Files
cocos4/cocos2d/core/sprites/CCSGSprite.js
T
2016-05-13 13:45:01 +08:00

1019 lines
37 KiB
JavaScript

/****************************************************************************
Copyright (c) 2008-2010 Ricardo Quesada
Copyright (c) 2011-2012 cocos2d-x.org
Copyright (c) 2013-2014 Chukong Technologies Inc.
http://www.cocos2d-x.org
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
var EventTarget = require("../cocos2d/core/event/event-target");
/**
* <p>_ccsg.Sprite is a 2d image ( http://en.wikipedia.org/wiki/Sprite_(computer_graphics) ) <br/>
*
* _ccsg.Sprite can be created with an image, or with a sub-rectangle of an image. <br/>
*
* If the parent or any of its ancestors is a cc.SpriteBatchNode then the following features/limitations are valid <br/>
* - Features when the parent is a cc.BatchNode: <br/>
* - MUCH faster rendering, specially if the cc.SpriteBatchNode has many children. All the children will be drawn in a single batch. <br/>
*
* - Limitations <br/>
* - Camera is not supported yet (eg: CCOrbitCamera action doesn't work) <br/>
* - GridBase actions are not supported (eg: CCLens, CCRipple, CCTwirl) <br/>
* - The Alias/Antialias property belongs to CCSpriteBatchNode, so you can't individually set the aliased property. <br/>
* - The Blending function property belongs to CCSpriteBatchNode, so you can't individually set the blending function property. <br/>
* - Parallax scroller is not supported, but can be simulated with a "proxy" sprite. <br/>
*
* If the parent is an standard ccsg.Node, then _ccsg.Sprite behaves like any other ccsg.Node: <br/>
* - It supports blending functions <br/>
* - It supports aliasing / antialiasing <br/>
* - But the rendering will be slower: 1 draw per children. <br/>
*
* The default anchorPoint in _ccsg.Sprite is (0.5, 0.5). </p>
* @class
* @extends _ccsg.Node
*
* @param {String|cc.SpriteFrame|HTMLImageElement|cc.Texture2D} fileName The string which indicates a path to image file, e.g., "scene1/monster.png".
* @param {cc.Rect} rect Only the contents inside rect of pszFileName's texture will be applied for this sprite.
* @param {Boolean} [rotated] Whether or not the texture rectangle is rotated.
* @example
*
* 1.Create a sprite with image path and rect
* var sprite1 = new _ccsg.Sprite("res/HelloHTML5World.png");
* var sprite2 = new _ccsg.Sprite("res/HelloHTML5World.png",cc.rect(0,0,480,320));
*
* 2.Create a sprite with a sprite frame name. Must add "#" before frame name.
* var sprite = new _ccsg.Sprite('#grossini_dance_01.png');
*
* 3.Create a sprite with a sprite frame
* var spriteFrame = cc.spriteFrameCache.getSpriteFrame("grossini_dance_01.png");
* var sprite = new _ccsg.Sprite(spriteFrame);
*
* 4.Create a sprite with an existing texture contained in a CCTexture2D object
* After creation, the rect will be the size of the texture, and the offset will be (0,0).
* var texture = cc.textureCache.addImage("HelloHTML5World.png");
* var sprite1 = new _ccsg.Sprite(texture);
* var sprite2 = new _ccsg.Sprite(texture, cc.rect(0,0,480,320));
*
* @property {Boolean} dirty - Indicates whether the sprite needs to be updated.
* @property {Boolean} flippedX - Indicates whether or not the sprite is flipped on x axis.
* @property {Boolean} flippedY - Indicates whether or not the sprite is flipped on y axis.
* @property {Number} offsetX - <@readonly> The offset position on x axis of the sprite in texture. Calculated automatically by editors like Zwoptex.
* @property {Number} offsetY - <@readonly> The offset position on x axis of the sprite in texture. Calculated automatically by editors like Zwoptex.
* @property {Number} atlasIndex - The index used on the TextureAtlas.
* @property {cc.Texture2D} texture - Texture used to render the sprite.
* @property {Boolean} textureRectRotated - <@readonly> Indicate whether the texture rectangle is rotated.
* @property {cc.TextureAtlas} textureAtlas - The weak reference of the cc.TextureAtlas when the sprite is rendered using via cc.SpriteBatchNode.
* @property {cc.SpriteBatchNode} batchNode - The batch node object if this sprite is rendered by cc.SpriteBatchNode.
* @property {cc.V3F_C4B_T2F_Quad} quad - <@readonly> The quad (tex coords, vertex coords and color) information.
*/
_ccsg.Sprite = _ccsg.Node.extend({
dirty:false,
atlasIndex:0,
textureAtlas:null,
_batchNode:null,
_recursiveDirty:null, //Whether all of the sprite's children needs to be updated
_hasChildren:null, //Whether the sprite contains children
_shouldBeHidden:false, //should not be drawn because one of the ancestors is not visible
_transformToBatch:null,
//
// Data used when the sprite is self-rendered
//
_blendFunc:null, //It's required for CCTextureProtocol inheritance
_texture:null, //cc.Texture2D object that is used to render the sprite
//
// Shared data
//
// texture
_rect:null, //Rectangle of cc.Texture2D
_rectRotated:false, //Whether the texture is rotated
// Offset Position (used by Zwoptex)
_offsetPosition:null, // absolute
_unflippedOffsetPositionFromCenter:null,
_opacityModifyRGB:false,
// image is flipped
_flippedX:false, //Whether the sprite is flipped horizontally or not.
_flippedY:false, //Whether the sprite is flipped vertically or not.
_textureLoaded:false,
_className:"Sprite",
ctor: function (fileName, rect, rotated) {
var self = this;
_ccsg.Node.prototype.ctor.call(self);
EventTarget.call(self);
self._shouldBeHidden = false;
self._offsetPosition = cc.p(0, 0);
self._unflippedOffsetPositionFromCenter = cc.p(0, 0);
self._blendFunc = {src: cc.macro.BLEND_SRC, dst: cc.macro.BLEND_DST};
self._rect = cc.rect(0, 0, 0, 0);
self._softInit(fileName, rect, rotated);
},
/**
* Returns whether the texture have been loaded
* @returns {boolean}
*/
textureLoaded:function(){
return this._textureLoaded;
},
/**
* Add a event listener for texture loaded event.
* @param {Function} callback
* @param {Object} target
* @deprecated since 3.1, please use EventTarget instead
*/
addLoadedEventListener:function(callback, target){
this.once("load", callback, target);
},
/**
* Returns whether or not the Sprite needs to be updated in the Atlas
* @return {Boolean} True if the sprite needs to be updated in the Atlas, false otherwise.
*/
isDirty:function () {
return this.dirty;
},
/**
* Makes the sprite to be updated in the Atlas.
* @param {Boolean} bDirty
*/
setDirty:function (bDirty) {
this.dirty = bDirty;
},
/**
* Returns whether or not the texture rectangle is rotated.
* @return {Boolean}
*/
isTextureRectRotated:function () {
return this._rectRotated;
},
/**
* Returns the index used on the TextureAtlas.
* @return {Number}
*/
getAtlasIndex:function () {
return this.atlasIndex;
},
/**
* Sets the index used on the TextureAtlas.
* @warning Don't modify this value unless you know what you are doing
* @param {Number} atlasIndex
*/
setAtlasIndex:function (atlasIndex) {
this.atlasIndex = atlasIndex;
},
/**
* Returns the rect of the _ccsg.Sprite in points
* @return {cc.Rect}
*/
getTextureRect:function () {
return cc.rect(this._rect);
},
/**
* Returns the weak reference of the cc.TextureAtlas when the sprite is rendered using via cc.SpriteBatchNode
* @return {cc.TextureAtlas}
*/
getTextureAtlas:function () {
return this.textureAtlas;
},
/**
* Sets the weak reference of the cc.TextureAtlas when the sprite is rendered using via cc.SpriteBatchNode
* @param {cc.TextureAtlas} textureAtlas
*/
setTextureAtlas:function (textureAtlas) {
this.textureAtlas = textureAtlas;
},
/**
* Returns the offset position of the sprite. Calculated automatically by editors like Zwoptex.
* @return {cc.Vec2}
*/
getOffsetPosition:function () {
return cc.p(this._offsetPosition);
},
_getOffsetX: function () {
return this._offsetPosition.x;
},
_getOffsetY: function () {
return this._offsetPosition.y;
},
/**
* Returns the blend function
* @return {cc.BlendFunc}
*/
getBlendFunc:function () {
return this._blendFunc;
},
/**
* Initializes a sprite with a SpriteFrame. The texture and rect in SpriteFrame will be applied on this sprite.<br/>
* Please pass parameters to the constructor to initialize the sprite, do not call this function yourself,
* @param {cc.SpriteFrame} spriteFrame A CCSpriteFrame object. It should includes a valid texture and a rect
* @return {Boolean} true if the sprite is initialized properly, false otherwise.
*/
initWithSpriteFrame:function (spriteFrame) {
cc.assert(spriteFrame, cc._LogInfos.Sprite.initWithSpriteFrame);
if(!spriteFrame.textureLoaded()){
//add event listener
this._textureLoaded = false;
spriteFrame.once("load", this._renderCmd._spriteFrameLoadedCallback, this._renderCmd);
}
//TODO
var rotated = cc._renderType === cc.game.RENDER_TYPE_CANVAS ? false : spriteFrame._rotated;
var ret = this.initWithTexture(spriteFrame.getTexture(), spriteFrame.getRect(), rotated);
this.setSpriteFrame(spriteFrame);
return ret;
},
/**
* Initializes a sprite with a sprite frame name. <br/>
* A cc.SpriteFrame will be fetched from the cc.SpriteFrameCache by name. <br/>
* If the cc.SpriteFrame doesn't exist it will raise an exception. <br/>
* Please pass parameters to the constructor to initialize the sprite, do not call this function yourself.
* @param {String} spriteFrameName A key string that can fected a valid cc.SpriteFrame from cc.SpriteFrameCache
* @return {Boolean} true if the sprite is initialized properly, false otherwise.
* @example
* var sprite = new _ccsg.Sprite();
* sprite.initWithSpriteFrameName("grossini_dance_01.png");
*/
initWithSpriteFrameName:function (spriteFrameName) {
cc.assert(spriteFrameName, cc._LogInfos.Sprite.initWithSpriteFrameName);
var frame = cc.spriteFrameCache.getSpriteFrame(spriteFrameName);
cc.assert(frame, spriteFrameName + cc._LogInfos.Sprite.initWithSpriteFrameName1);
return this.initWithSpriteFrame(frame);
},
/**
* Tell the sprite to use batch node render.
* @param {cc.SpriteBatchNode} batchNode
*/
useBatchNode:function (batchNode) {
this.textureAtlas = batchNode.getTextureAtlas(); // weak ref
this._batchNode = batchNode;
},
/**
* <p>
* set the vertex rect.<br/>
* It will be called internally by setTextureRect. <br/>
* Useful if you want to create 2x images from SD images in Retina Display. <br/>
* Do not call it manually. Use setTextureRect instead. <br/>
* (override this method to generate "double scale" sprites)
* </p>
* @param {cc.Rect} rect
*/
setVertexRect:function (rect) {
var locRect = this._rect;
locRect.x = rect.x;
locRect.y = rect.y;
locRect.width = rect.width;
locRect.height = rect.height;
},
/**
* Sort all children of this sprite node.
* @override
*/
sortAllChildren:function () {
if (this._reorderChildDirty) {
var _children = this._children;
// insertion sort
var len = _children.length, i, j, tmp;
for(i=1; i<len; i++){
tmp = _children[i];
j = i - 1;
//continue moving element downwards while zOrder is smaller or when zOrder is the same but mutatedIndex is smaller
while(j >= 0){
if(tmp._localZOrder < _children[j]._localZOrder){
_children[j+1] = _children[j];
}else if(tmp._localZOrder === _children[j]._localZOrder && tmp.arrivalOrder < _children[j].arrivalOrder){
_children[j+1] = _children[j];
}else{
break;
}
j--;
}
_children[j+1] = tmp;
}
if (this._batchNode) {
this._arrayMakeObjectsPerformSelector(_children, _ccsg.Node._stateCallbackType.sortAllChildren);
}
//don't need to check children recursively, that's done in visit of each child
this._reorderChildDirty = false;
}
},
/**
* Reorders a child according to a new z value. (override ccsg.Node )
* @param {_ccsg.Node} child
* @param {Number} zOrder
* @override
*/
reorderChild:function (child, zOrder) {
cc.assert(child, cc._LogInfos.Sprite.reorderChild_2);
if(this._children.indexOf(child) === -1){
cc.log(cc._LogInfos.Sprite.reorderChild);
return;
}
if (zOrder === child.zIndex)
return;
if (this._batchNode && !this._reorderChildDirty) {
this._setReorderChildDirtyRecursively();
this._batchNode.reorderBatch(true);
}
_ccsg.Node.prototype.reorderChild.call(this, child, zOrder);
},
/**
* Removes a child from the sprite.
* @param child
* @param cleanup whether or not cleanup all running actions
* @override
*/
removeChild:function (child, cleanup) {
if (this._batchNode)
this._batchNode.removeSpriteFromAtlas(child);
_ccsg.Node.prototype.removeChild.call(this, child, cleanup);
},
/**
* Sets whether the sprite is visible or not.
* @param {Boolean} visible
* @override
*/
setVisible:function (visible) {
_ccsg.Node.prototype.setVisible.call(this, visible);
this._renderCmd.setDirtyRecursively(true);
},
/**
* Removes all children from the container.
* @param cleanup whether or not cleanup all running actions
* @override
*/
removeAllChildren:function (cleanup) {
var locChildren = this._children, locBatchNode = this._batchNode;
if (locBatchNode && locChildren != null) {
for (var i = 0, len = locChildren.length; i < len; i++)
locBatchNode.removeSpriteFromAtlas(locChildren[i]);
}
_ccsg.Node.prototype.removeAllChildren.call(this, cleanup);
this._hasChildren = false;
},
//
// _ccsg.Node property overloads
//
/**
* Sets whether ignore anchor point for positioning
* @param {Boolean} relative
* @override
*/
ignoreAnchorPointForPosition:function (relative) {
if(this._batchNode){
cc.log(cc._LogInfos.Sprite.ignoreAnchorPointForPosition);
return;
}
_ccsg.Node.prototype.ignoreAnchorPointForPosition.call(this, relative);
},
/**
* Sets whether the sprite should be flipped horizontally or not.
* @param {Boolean} flippedX true if the sprite should be flipped horizontally, false otherwise.
*/
setFlippedX:function (flippedX) {
if (this._flippedX !== flippedX) {
this._flippedX = flippedX;
this.setTextureRect(this._rect, this._rectRotated, this._contentSize);
this.setNodeDirty(true);
}
},
/**
* Sets whether the sprite should be flipped vertically or not.
* @param {Boolean} flippedY true if the sprite should be flipped vertically, false otherwise.
*/
setFlippedY:function (flippedY) {
if (this._flippedY !== flippedY) {
this._flippedY = flippedY;
this.setTextureRect(this._rect, this._rectRotated, this._contentSize);
this.setNodeDirty(true);
}
},
/**
* <p>
* Returns the flag which indicates whether the sprite is flipped horizontally or not. <br/>
* <br/>
* It only flips the texture of the sprite, and not the texture of the sprite's children. <br/>
* Also, flipping the texture doesn't alter the anchorPoint. <br/>
* If you want to flip the anchorPoint too, and/or to flip the children too use: <br/>
* sprite.setScaleX(sprite.getScaleX() * -1); <p/>
* @return {Boolean} true if the sprite is flipped horizontally, false otherwise.
*/
isFlippedX:function () {
return this._flippedX;
},
/**
* <p>
* Return the flag which indicates whether the sprite is flipped vertically or not. <br/>
* <br/>
* It only flips the texture of the sprite, and not the texture of the sprite's children. <br/>
* Also, flipping the texture doesn't alter the anchorPoint. <br/>
* If you want to flip the anchorPoint too, and/or to flip the children too use: <br/>
* sprite.setScaleY(sprite.getScaleY() * -1); <p/>
* @return {Boolean} true if the sprite is flipped vertically, false otherwise.
*/
isFlippedY:function () {
return this._flippedY;
},
//
// RGBA protocol
//
/**
* Sets whether opacity modify color or not.
* @function
* @param {Boolean} modify
*/
setOpacityModifyRGB: function (modify) {
if (this._opacityModifyRGB !== modify) {
this._opacityModifyRGB = modify;
this._renderCmd._setColorDirty();
}
},
/**
* Returns whether opacity modify color or not.
* @return {Boolean}
*/
isOpacityModifyRGB:function () {
return this._opacityModifyRGB;
},
// Animation
/**
* Changes the display frame with animation name and index.<br/>
* The animation name will be get from the CCAnimationCache
* @param {String} animationName
* @param {Number} frameIndex
*/
setDisplayFrameWithAnimationName:function (animationName, frameIndex) {
cc.assert(animationName, cc._LogInfos.Sprite.setDisplayFrameWithAnimationName_3);
var cache = cc.spriteFrameAnimationCache.getAnimation(animationName);
if(!cache){
cc.log(cc._LogInfos.Sprite.setDisplayFrameWithAnimationName);
return;
}
var animFrame = cache.getFrames()[frameIndex];
if(!animFrame){
cc.log(cc._LogInfos.Sprite.setDisplayFrameWithAnimationName_2);
return;
}
this.setSpriteFrame(animFrame.getSpriteFrame());
},
/**
* Returns the batch node object if this sprite is rendered by cc.SpriteBatchNode
* @returns {cc.SpriteBatchNode|null} The cc.SpriteBatchNode object if this sprite is rendered by cc.SpriteBatchNode, null if the sprite isn't used batch node.
*/
getBatchNode:function () {
return this._batchNode;
},
_setReorderChildDirtyRecursively:function () {
//only set parents flag the first time
if (!this._reorderChildDirty) {
this._reorderChildDirty = true;
var pNode = this._parent;
while (pNode && pNode !== this._batchNode) {
pNode._setReorderChildDirtyRecursively();
pNode = pNode.parent;
}
}
},
// CCTextureProtocol
/**
* Returns the texture of the sprite node
* @returns {cc.Texture2D}
*/
getTexture:function () {
return this._texture;
},
_softInit: function (fileName, rect, rotated) {
if (fileName === undefined)
_ccsg.Sprite.prototype.init.call(this);
else if (cc.js.isString(fileName)) {
if (fileName[0] === "#") {
// Init with a sprite frame name
var frameName = fileName.substr(1, fileName.length - 1);
var spriteFrame = cc.spriteFrameCache.getSpriteFrame(frameName);
if (spriteFrame)
this.initWithSpriteFrame(spriteFrame);
else
cc.log("%s does not exist", fileName);
} else {
// Init with filename and rect
_ccsg.Sprite.prototype.init.call(this, fileName, rect);
}
} else if (typeof fileName === "object") {
if (fileName instanceof cc.Texture2D) {
// Init with texture and rect
this.initWithTexture(fileName, rect, rotated);
} else if (fileName instanceof cc.SpriteFrame) {
// Init with a sprite frame
this.initWithSpriteFrame(fileName);
} else if ((fileName instanceof HTMLImageElement) || (fileName instanceof HTMLCanvasElement)) {
// Init with a canvas or image element
var texture2d = new cc.Texture2D();
texture2d.initWithElement(fileName);
texture2d.handleLoadedTexture();
this.initWithTexture(texture2d);
}
}
},
/**
* Returns the quad (tex coords, vertex coords and color) information.
* @return {cc.V3F_C4B_T2F_Quad|null} Returns a cc.V3F_C4B_T2F_Quad object when render mode is WebGL, returns null when render mode is Canvas.
*/
getQuad:function () {
return this._renderCmd.getQuad();
},
/**
* conforms to cc.TextureProtocol protocol
* @function
* @param {Number|cc.BlendFunc} src
* @param {Number} dst
*/
setBlendFunc: function (src, dst) {
var locBlendFunc = this._blendFunc;
if (dst === undefined) {
locBlendFunc.src = src.src;
locBlendFunc.dst = src.dst;
} else {
locBlendFunc.src = src;
locBlendFunc.dst = dst;
}
this._renderCmd.updateBlendFunc(locBlendFunc);
},
/**
* Initializes an empty sprite with nothing init.<br/>
* Please pass parameters to the constructor to initialize the sprite, do not call this function yourself.
* @function
* @return {Boolean}
*/
init: function () {
var _t = this;
if (arguments.length > 0)
return _t.initWithFile(arguments[0], arguments[1]);
_ccsg.Node.prototype.init.call(_t);
_t.dirty = _t._recursiveDirty = false;
_t._blendFunc.src = cc.macro.BLEND_SRC;
_t._blendFunc.dst = cc.macro.BLEND_DST;
_t.texture = null;
_t._flippedX = _t._flippedY = false;
// default transform anchor: center
_t.anchorX = 0.5;
_t.anchorY = 0.5;
// zwoptex default values
_t._offsetPosition.x = 0;
_t._offsetPosition.y = 0;
_t._hasChildren = false;
this._renderCmd._init();
// updated in "useSelfRender"
// Atlas: TexCoords
_t.setTextureRect(cc.rect(0, 0, 0, 0), false, cc.size(0, 0));
return true;
},
/**
* <p>
* Initializes a sprite with an image filename.<br/>
*
* This method will find pszFilename from local file system, load its content to CCTexture2D,<br/>
* then use CCTexture2D to create a sprite.<br/>
* After initialization, the rect used will be the size of the image. The offset will be (0,0).<br/>
* Please pass parameters to the constructor to initialize the sprite, do not call this function yourself.
* </p>
* @param {String} filename The path to an image file in local file system
* @param {cc.Rect} rect The rectangle assigned the content area from texture.
* @return {Boolean} true if the sprite is initialized properly, false otherwise.
*/
initWithFile:function (filename, rect) {
cc.assert(filename, cc._LogInfos.Sprite.initWithFile);
var tex = cc.textureCache.getTextureForKey(filename);
if (!tex) {
tex = cc.textureCache.addImage(filename);
return this.initWithTexture(tex, rect || cc.rect(0, 0, tex._contentSize.width, tex._contentSize.height));
} else {
if (!rect) {
var size = tex.getContentSize();
rect = cc.rect(0, 0, size.width, size.height);
}
return this.initWithTexture(tex, rect);
}
},
/**
* Initializes a sprite with a texture and a rect in points, optionally rotated. <br/>
* After initialization, the rect used will be the size of the texture, and the offset will be (0,0).<br/>
* Please pass parameters to the constructor to initialize the sprite, do not call this function yourself.
* @function
* @param {cc.Texture2D|HTMLImageElement|HTMLCanvasElement} texture A pointer to an existing CCTexture2D object. You can use a CCTexture2D object for many sprites.
* @param {cc.Rect} [rect] Only the contents inside rect of this texture will be applied for this sprite.
* @param {Boolean} [rotated] Whether or not the texture rectangle is rotated.
* @param {Boolean} [counterclockwise=true] Whether or not the texture rectangle rotation is counterclockwise (texture package is counterclockwise, spine is clockwise).
* @return {Boolean} true if the sprite is initialized properly, false otherwise.
*/
initWithTexture: function (texture, rect, rotated, counterclockwise) {
var _t = this;
cc.assert(arguments.length !== 0, cc._LogInfos.SpriteBatchNode.initWithTexture);
rotated = rotated || false;
texture = this._renderCmd._handleTextureForRotatedTexture(texture, rect, rotated, counterclockwise);
if (!_ccsg.Node.prototype.init.call(_t))
return false;
_t._batchNode = null;
_t._recursiveDirty = false;
_t.dirty = false;
_t._opacityModifyRGB = true;
_t._blendFunc.src = cc.macro.BLEND_SRC;
_t._blendFunc.dst = cc.macro.BLEND_DST;
_t._flippedX = _t._flippedY = false;
// default transform anchor: center
_t.setAnchorPoint(0.5, 0.5);
// zwoptex default values
_t._offsetPosition.x = 0;
_t._offsetPosition.y = 0;
_t._hasChildren = false;
this._renderCmd._init();
var locTextureLoaded = texture.isLoaded();
_t._textureLoaded = locTextureLoaded;
if (!locTextureLoaded) {
_t._rectRotated = rotated;
if (rect) {
_t._rect.x = rect.x;
_t._rect.y = rect.y;
_t._rect.width = rect.width;
_t._rect.height = rect.height;
}
if(_t.texture)
_t.texture.off("load", _t._renderCmd._textureLoadedCallback, _t._renderCmd);
texture.once("load", _t._renderCmd._textureLoadedCallback, _t._renderCmd);
_t.setTexture(texture);
return true;
}
if (!rect)
rect = cc.rect(0, 0, texture.width, texture.height);
this._renderCmd._checkTextureBoundary(texture, rect, rotated);
_t.setTexture(texture);
_t.setTextureRect(rect, rotated);
// by default use "Self Render".
// if the sprite is added to a batchnode, then it will automatically switch to "batchnode Render"
_t.setBatchNode(null);
this.emit("load");
return true;
},
/**
* Updates the texture rect of the CCSprite in points.
* @function
* @param {cc.Rect} rect a rect of texture
* @param {Boolean} [rotated] Whether or not the texture is rotated
* @param {cc.Size} [untrimmedSize] The original pixels size of the texture
*/
setTextureRect: function (rect, rotated, untrimmedSize) {
var _t = this;
_t._rectRotated = rotated || false;
_t.setContentSize(untrimmedSize || rect);
_t.setVertexRect(rect);
_t._renderCmd._setTextureCoords(rect);
var relativeOffsetX = _t._unflippedOffsetPositionFromCenter.x, relativeOffsetY = _t._unflippedOffsetPositionFromCenter.y;
if (_t._flippedX)
relativeOffsetX = -relativeOffsetX;
if (_t._flippedY)
relativeOffsetY = -relativeOffsetY;
var locRect = _t._rect;
_t._offsetPosition.x = relativeOffsetX + (_t._contentSize.width - locRect.width) / 2;
_t._offsetPosition.y = relativeOffsetY + (_t._contentSize.height - locRect.height) / 2;
// rendering using batch node
if (_t._batchNode) {
// update dirty, don't update _recursiveDirty
_t.dirty = true;
} else {
// self rendering
// Atlas: Vertex
this._renderCmd._resetForBatchNode();
}
},
// BatchNode methods
/**
* Updates the quad according the the rotation, position, scale values.
* @function
*/
updateTransform: function(){
this._renderCmd.updateTransform();
},
/**
* Add child to sprite (override ccsg.Node)
* @function
* @param {_ccsg.Sprite} child
* @param {Number} localZOrder child's zOrder
* @param {String} [tag] child's tag
* @override
*/
addChild: function (child, localZOrder, tag) {
cc.assert(child, cc._LogInfos.SpriteBatchNode.addChild_2);
if (localZOrder == null)
localZOrder = child._localZOrder;
if (tag == null)
tag = child.tag;
if(this._renderCmd._setBatchNodeForAddChild(child)){
//_ccsg.Node already sets isReorderChildDirty_ so this needs to be after batchNode check
_ccsg.Node.prototype.addChild.call(this, child, localZOrder, tag);
this._hasChildren = true;
}
},
// Frames
/**
* Sets a new sprite frame to the sprite.
* @function
* @param {cc.SpriteFrame|String} newFrame
*/
setSpriteFrame: function (newFrame) {
var _t = this;
if(cc.js.isString(newFrame)){
newFrame = cc.spriteFrameCache.getSpriteFrame(newFrame);
cc.assert(newFrame, cc._LogInfos.Sprite.setSpriteFrame)
}
this.setNodeDirty(true);
var frameOffset = newFrame.getOffset();
_t._unflippedOffsetPositionFromCenter.x = frameOffset.x;
_t._unflippedOffsetPositionFromCenter.y = frameOffset.y;
// update rect
var pNewTexture = newFrame.getTexture();
var locTextureLoaded = newFrame.textureLoaded();
if (!locTextureLoaded) {
if (pNewTexture !== _t._texture)
_t.setTexture(pNewTexture);
_t._textureLoaded = false;
newFrame.once("load", function (event) {
var sender = event.currentTarget;
_t._textureLoaded = true;
_t.setTextureRect(sender.getRect(), sender.isRotated(), sender.getOriginalSize());
_t.emit("load");
_t.setColor(_t.color);
}, _t);
}else{
// update texture before updating texture rect
if (pNewTexture !== _t._texture)
_t.setTexture(pNewTexture);
_t.setTextureRect(newFrame.getRect(), newFrame.isRotated(), newFrame.getOriginalSize());
}
this._renderCmd._updateForSetSpriteFrame(pNewTexture);
},
/**
* Sets a new display frame to the sprite.
* @param {cc.SpriteFrame|String} newFrame
* @deprecated
*/
setDisplayFrame: function(newFrame){
cc.log(cc._LogInfos.Sprite.setDisplayFrame);
this.setSpriteFrame(newFrame);
},
/**
* Returns whether or not a cc.SpriteFrame is being displayed
* @function
* @param {cc.SpriteFrame} frame
* @return {Boolean}
*/
isFrameDisplayed: function(frame){
return this._renderCmd.isFrameDisplayed(frame);
},
/**
* Returns the current displayed frame.
* @deprecated since 3.4, please use getSpriteFrame instead
* @return {cc.SpriteFrame}
*/
displayFrame: function () {
return this.getSpriteFrame();
},
/**
* Returns the current displayed frame.
* @return {cc.SpriteFrame}
*/
getSpriteFrame: function () {
return new cc.SpriteFrame(this._texture,
this._rect,
this._rectRotated,
this._unflippedOffsetPositionFromCenter,
this._contentSize);
},
/**
* Sets the batch node to sprite
* @function
* @param {cc.SpriteBatchNode|null} spriteBatchNode
* @example
* var batch = new cc.SpriteBatchNode("Images/grossini_dance_atlas.png", 15);
* var sprite = new _ccsg.Sprite(batch.texture, cc.rect(0, 0, 57, 57));
* batch.addChild(sprite);
* layer.addChild(batch);
*/
setBatchNode:function (spriteBatchNode) {
var _t = this;
_t._batchNode = spriteBatchNode; // weak reference
// self render
if (!_t._batchNode) {
_t.atlasIndex = _ccsg.Sprite.INDEX_NOT_INITIALIZED;
_t.textureAtlas = null;
_t._recursiveDirty = false;
_t.dirty = false;
this._renderCmd._resetForBatchNode();
} else {
// using batch
_t._transformToBatch = cc.affineTransformIdentity();
_t.textureAtlas = _t._batchNode.getTextureAtlas(); // weak ref
}
},
// CCTextureProtocol
/**
* Sets the texture of sprite
* @function
* @param {cc.Texture2D|String} texture
*/
setTexture: function (texture) {
if(!texture)
return this._renderCmd._setTexture(null);
//CCSprite.cpp 327 and 338
var isFileName = cc.js.isString(texture);
if(isFileName)
texture = cc.textureCache.addImage(texture);
if(texture._textureLoaded){
this._setTexture(texture, isFileName);
this.setColor(this._realColor);
this._textureLoaded = true;
this.emit("load");
}else{
this._renderCmd._setTexture(texture);
texture.once("load", function (event) {
this._setTexture(texture, isFileName);
this.setColor(this._realColor);
this._textureLoaded = true;
this.emit("load");
}, this);
}
},
_setTexture: function(texture, change){
this._renderCmd._setTexture(texture);
if(change)
this._changeRectWithTexture(texture);
},
_changeRectWithTexture: function(texture){
var contentSize = texture._contentSize;
var rect = cc.rect(
0, 0,
contentSize.width, contentSize.height
);
this.setTextureRect(rect);
},
_createRenderCmd: function(){
if(cc._renderType === cc.game.RENDER_TYPE_CANVAS)
return new _ccsg.Sprite.CanvasRenderCmd(this);
else
return new _ccsg.Sprite.WebGLRenderCmd(this);
}
});
/**
* _ccsg.Sprite invalid index on the cc.SpriteBatchNode
* @constant
* @type {Number}
*/
_ccsg.Sprite.INDEX_NOT_INITIALIZED = -1;
cc.js.addon(_ccsg.Sprite.prototype, EventTarget.prototype);
cc.assert(typeof cc._tmp.PrototypeSprite === 'function', cc._LogInfos.MissingFile, "SpritesPropertyDefine.js");
cc._tmp.PrototypeSprite();
delete cc._tmp.PrototypeSprite;
// fireball#2856
var spritePro = _ccsg.Sprite.prototype;
Object.defineProperty(spritePro, 'visible', {
get: _ccsg.Node.prototype.isVisible,
set: spritePro.setVisible
});
Object.defineProperty(spritePro, 'ignoreAnchor', {
get: _ccsg.Node.prototype.isIgnoreAnchorPointForPosition,
set: spritePro.ignoreAnchorPointForPosition
});
Object.defineProperty(spritePro, 'opacityModifyRGB', {
get: spritePro.isOpacityModifyRGB
});