void Skin::draw()
{
// If it is not visible, or one of its ancestors is not visible, then do nothing:
if( !_visible)
{
_quad.br.vertices = _quad.tl.vertices = _quad.tr.vertices = _quad.bl.vertices = Vertex3F(0, 0, 0);
}
else
{
//
// calculate the Quad based on the Affine Matrix
//
Size size = _rect.size;
float x1 = _offsetPosition.x;
float y1 = _offsetPosition.y;
float x2 = x1 + size.width;
float y2 = y1 + size.height;
float x = _transform.tx;
float y = _transform.ty;
float cr = _transform.a;
float sr = _transform.b;
float cr2 = _transform.d;
float sr2 = -_transform.c;
float ax = x1 * cr - y1 * sr2 + x;
float ay = x1 * sr + y1 * cr2 + y;
float bx = x2 * cr - y1 * sr2 + x;
float by = x2 * sr + y1 * cr2 + y;
float cx = x2 * cr - y2 * sr2 + x;
float cy = x2 * sr + y2 * cr2 + y;
float dx = x1 * cr - y2 * sr2 + x;
float dy = x1 * sr + y2 * cr2 + y;
_quad.bl.vertices = Vertex3F( RENDER_IN_SUBPIXEL(ax), RENDER_IN_SUBPIXEL(ay), _vertexZ );
_quad.br.vertices = Vertex3F( RENDER_IN_SUBPIXEL(bx), RENDER_IN_SUBPIXEL(by), _vertexZ );
_quad.tl.vertices = Vertex3F( RENDER_IN_SUBPIXEL(dx), RENDER_IN_SUBPIXEL(dy), _vertexZ );
_quad.tr.vertices = Vertex3F( RENDER_IN_SUBPIXEL(cx), RENDER_IN_SUBPIXEL(cy), _vertexZ );
}
// MARMALADE CHANGE: ADDED CHECK FOR NULL, TO PERMIT SPRITES WITH NO BATCH NODE / TEXTURE ATLAS
if (_textureAtlas)
{
_textureAtlas->updateQuad(&_quad, _textureAtlas->getTotalQuads());
}
}
void CCSkin::updateTransform()
{
// If it is not visible, or one of its ancestors is not visible, then do nothing:
if( !m_bVisible)
{
m_sQuad.br.vertices = m_sQuad.tl.vertices = m_sQuad.tr.vertices = m_sQuad.bl.vertices = vertex3(0, 0, 0);
}
else
{
//
// calculate the Quad based on the Affine Matrix
//
CCSize size = m_obRect.size;
float x1 = m_obOffsetPosition.x;
float y1 = m_obOffsetPosition.y;
float x2 = x1 + size.width;
float y2 = y1 + size.height;
float x = m_sTransform.tx;
float y = m_sTransform.ty;
float cr = m_sTransform.a;
float sr = m_sTransform.b;
float cr2 = m_sTransform.d;
float sr2 = -m_sTransform.c;
float ax = x1 * cr - y1 * sr2 + x;
float ay = x1 * sr + y1 * cr2 + y;
float bx = x2 * cr - y1 * sr2 + x;
float by = x2 * sr + y1 * cr2 + y;
float cx = x2 * cr - y2 * sr2 + x;
float cy = x2 * sr + y2 * cr2 + y;
float dx = x1 * cr - y2 * sr2 + x;
float dy = x1 * sr + y2 * cr2 + y;
m_sQuad.bl.vertices = vertex3( RENDER_IN_SUBPIXEL(ax), RENDER_IN_SUBPIXEL(ay), m_fVertexZ );
m_sQuad.br.vertices = vertex3( RENDER_IN_SUBPIXEL(bx), RENDER_IN_SUBPIXEL(by), m_fVertexZ );
m_sQuad.tl.vertices = vertex3( RENDER_IN_SUBPIXEL(dx), RENDER_IN_SUBPIXEL(dy), m_fVertexZ );
m_sQuad.tr.vertices = vertex3( RENDER_IN_SUBPIXEL(cx), RENDER_IN_SUBPIXEL(cy), m_fVertexZ );
}
// MARMALADE CHANGE: ADDED CHECK FOR NULL, TO PERMIT SPRITES WITH NO BATCH NODE / TEXTURE ATLAS
if (m_pobTextureAtlas)
{
m_pobTextureAtlas->updateQuad(&m_sQuad, m_pobTextureAtlas->getTotalQuads());
}
}
void CAView::transform()
{
kmMat4 transfrom4x4;
// Convert 3x3 into 4x4 matrix
CATransformation tmpAffine = this->nodeToParentTransform();
CGAffineToGL(&tmpAffine, transfrom4x4.mat);
// Update Z vertex manually
transfrom4x4.mat[14] = m_fVertexZ;
kmGLMultMatrix( &transfrom4x4 );
// XXX: Expensive calls. Camera should be integrated into the cached affine matrix
if ( m_pCamera != NULL)
{
DPoint anchorPointInPoints = DPoint(m_obAnchorPointInPoints.x,
m_obContentSize.height - m_obAnchorPointInPoints.y);
bool translate = (anchorPointInPoints.x != 0.0f || anchorPointInPoints.y != 0.0f);
if( translate )
kmGLTranslatef(RENDER_IN_SUBPIXEL(anchorPointInPoints.x),
RENDER_IN_SUBPIXEL(anchorPointInPoints.y),
0 );
m_pCamera->locate();
if( translate )
kmGLTranslatef(RENDER_IN_SUBPIXEL(-anchorPointInPoints.x),
RENDER_IN_SUBPIXEL(-anchorPointInPoints.y),
0 );
}
}
void Skin::updateTransform()
{
// If it is not visible, or one of its ancestors is not visible, then do nothing:
if( !_visible)
{
_quad.br.vertices.setZero();
_quad.tl.vertices.setZero();
_quad.tr.vertices.setZero();
_quad.bl.vertices.setZero();
}
else
{
//
// calculate the Quad based on the Affine Matrix
//
Mat4 transform = getNodeToParentTransform();
Size &size = _rect.size;
float x1 = _offsetPosition.x;
float y1 = _offsetPosition.y;
float x2 = x1 + size.width;
float y2 = y1 + size.height;
if (_flippedX)
{
std::swap(x1, x2);
}
if (_flippedY)
{
std::swap(y1, y2);
}
float x = transform.m[12];
float y = transform.m[13];
float cr = transform.m[0];
float sr = transform.m[1];
float cr2 = transform.m[5];
float sr2 = -transform.m[4];
float ax = x1 * cr - y1 * sr2 + x;
float ay = x1 * sr + y1 * cr2 + y;
float bx = x2 * cr - y1 * sr2 + x;
float by = x2 * sr + y1 * cr2 + y;
float cx = x2 * cr - y2 * sr2 + x;
float cy = x2 * sr + y2 * cr2 + y;
float dx = x1 * cr - y2 * sr2 + x;
float dy = x1 * sr + y2 * cr2 + y;
_quad.bl.vertices.set(RENDER_IN_SUBPIXEL(ax), RENDER_IN_SUBPIXEL(ay), _positionZ);
_quad.br.vertices.set(RENDER_IN_SUBPIXEL(bx), RENDER_IN_SUBPIXEL(by), _positionZ);
_quad.tl.vertices.set(RENDER_IN_SUBPIXEL(dx), RENDER_IN_SUBPIXEL(dy), _positionZ);
_quad.tr.vertices.set(RENDER_IN_SUBPIXEL(cx), RENDER_IN_SUBPIXEL(cy), _positionZ);
}
// MARMALADE CHANGE: ADDED CHECK FOR nullptr, TO PERMIT SPRITES WITH NO BATCH NODE / TEXTURE ATLAS
if (_textureAtlas)
{
_textureAtlas->updateQuad(&_quad, _textureAtlas->getTotalQuads());
}
}
void Sprite::updateTransform(void)
{
CCASSERT(_batchNode, "updateTransform is only valid when Sprite is being rendered using an SpriteBatchNode");
// recalculate matrix only if it is dirty
if( isDirty() ) {
// If it is not visible, or one of its ancestors is not visible, then do nothing:
if( !_visible || ( _parent && _parent != _batchNode && static_cast<Sprite*>(_parent)->_shouldBeHidden) )
{
_quad.br.vertices = _quad.tl.vertices = _quad.tr.vertices = _quad.bl.vertices = Vertex3F(0,0,0);
_shouldBeHidden = true;
}
else
{
_shouldBeHidden = false;
if( ! _parent || _parent == _batchNode )
{
_transformToBatch = getNodeToParentTransform();
}
else
{
CCASSERT( dynamic_cast<Sprite*>(_parent), "Logic error in Sprite. Parent must be a Sprite");
kmMat4 nodeToParent = getNodeToParentTransform();
kmMat4 parentTransform = static_cast<Sprite*>(_parent)->_transformToBatch;
kmMat4Multiply(&_transformToBatch, &parentTransform, &nodeToParent);
}
//
// calculate the Quad based on the Affine Matrix
//
Size size = _rect.size;
float x1 = _offsetPosition.x;
float y1 = _offsetPosition.y;
float x2 = x1 + size.width;
float y2 = y1 + size.height;
float x = _transformToBatch.mat[12];
float y = _transformToBatch.mat[13];
float cr = _transformToBatch.mat[0];
float sr = _transformToBatch.mat[1];
float cr2 = _transformToBatch.mat[5];
float sr2 = -_transformToBatch.mat[4];
float ax = x1 * cr - y1 * sr2 + x;
float ay = x1 * sr + y1 * cr2 + y;
float bx = x2 * cr - y1 * sr2 + x;
float by = x2 * sr + y1 * cr2 + y;
float cx = x2 * cr - y2 * sr2 + x;
float cy = x2 * sr + y2 * cr2 + y;
float dx = x1 * cr - y2 * sr2 + x;
float dy = x1 * sr + y2 * cr2 + y;
_quad.bl.vertices = Vertex3F( RENDER_IN_SUBPIXEL(ax), RENDER_IN_SUBPIXEL(ay), _positionZ );
_quad.br.vertices = Vertex3F( RENDER_IN_SUBPIXEL(bx), RENDER_IN_SUBPIXEL(by), _positionZ );
_quad.tl.vertices = Vertex3F( RENDER_IN_SUBPIXEL(dx), RENDER_IN_SUBPIXEL(dy), _positionZ );
_quad.tr.vertices = Vertex3F( RENDER_IN_SUBPIXEL(cx), RENDER_IN_SUBPIXEL(cy), _positionZ );
}
// MARMALADE CHANGE: ADDED CHECK FOR nullptr, TO PERMIT SPRITES WITH NO BATCH NODE / TEXTURE ATLAS
if (_textureAtlas)
{
_textureAtlas->updateQuad(&_quad, _atlasIndex);
}
_recursiveDirty = false;
setDirty(false);
}
// MARMALADE CHANGED
// recursively iterate over children
/* if( _hasChildren )
{
// MARMALADE: CHANGED TO USE Node*
// NOTE THAT WE HAVE ALSO DEFINED virtual Node::updateTransform()
arrayMakeObjectsPerformSelector(_children, updateTransform, Sprite*);
}*/
Node::updateTransform();
}
void CCSprite::updateTransform(void)
{
assert(m_bUsesBatchNode);
// optimization. Quick return if not dirty
if (! m_bDirty)
{
return;
}
CGAffineTransform matrix;
// Optimization: if it is not visible, then do nothing
if (! m_bIsVisible)
{
m_sQuad.br.vertices = m_sQuad.tl.vertices = m_sQuad.tr.vertices = m_sQuad.bl.vertices = vertex3(0,0,0);
m_pobTextureAtlas->updateQuad(&m_sQuad, m_uAtlasIndex);
m_bDirty = m_bRecursiveDirty = false;
return;
}
// Optimization: If parent is batchnode, or parent is nil
// build Affine transform manually
if (! m_pParent || m_pParent == m_pobBatchNode)
{
float radians = -CC_DEGREES_TO_RADIANS(m_fRotation);
float c = cosf(radians);
float s = sinf(radians);
matrix = CGAffineTransformMake(c * m_fScaleX, s * m_fScaleX,
-s * m_fScaleY, c * m_fScaleY,
m_tPositionInPixels.x, m_tPositionInPixels.y);
matrix = CGAffineTransformTranslate(matrix, -m_tAnchorPointInPixels.x, -m_tAnchorPointInPixels.y);
} else // parent_ != batchNode_
{
// else do affine transformation according to the HonorParentTransform
matrix = CGAffineTransformIdentity;
ccHonorParentTransform prevHonor = CC_HONOR_PARENT_TRANSFORM_ALL;
for (CCNode *p = this; p && p != m_pobBatchNode; p = p->getParent())
{
// Might happen. Issue #1053
// how to implement, we can not use dynamic
// NSAssert( [p isKindOfClass:[CCSprite class]], @"CCSprite should be a CCSprite subclass. Probably you initialized an sprite with a batchnode, but you didn't add it to the batch node." );
struct transformValues_ tv;
((CCSprite*)p)->getTransformValues(&tv);
// If any of the parents are not visible, then don't draw this node
if (! tv.visible)
{
m_sQuad.br.vertices = m_sQuad.tl.vertices = m_sQuad.tr.vertices = m_sQuad.bl.vertices = vertex3(0,0,0);
m_pobTextureAtlas->updateQuad(&m_sQuad, m_uAtlasIndex);
m_bDirty = m_bRecursiveDirty = false;
return;
}
CGAffineTransform newMatrix = CGAffineTransformIdentity;
// 2nd: Translate, Rotate, Scale
if( prevHonor & CC_HONOR_PARENT_TRANSFORM_TRANSLATE )
{
newMatrix = CGAffineTransformTranslate(newMatrix, tv.pos.x, tv.pos.y);
}
if( prevHonor & CC_HONOR_PARENT_TRANSFORM_ROTATE )
{
newMatrix = CGAffineTransformRotate(newMatrix, -CC_DEGREES_TO_RADIANS(tv.rotation));
}
if( prevHonor & CC_HONOR_PARENT_TRANSFORM_SCALE )
{
newMatrix = CGAffineTransformScale(newMatrix, tv.scale.x, tv.scale.y);
}
// 3rd: Translate anchor point
newMatrix = CGAffineTransformTranslate(newMatrix, -tv.ap.x, -tv.ap.y);
// 4th: Matrix multiplication
matrix = CGAffineTransformConcat( matrix, newMatrix);
prevHonor = ((CCSprite*)p)->getHornorParentTransform();
}
}
//
// calculate the Quad based on the Affine Matrix
//
CGSize size = m_obRectInPixels.size;
float x1 = m_obOffsetPositionInPixels.x;
float y1 = m_obOffsetPositionInPixels.y;
float x2 = x1 + size.width;
float y2 = y1 + size.height;
float x = matrix.tx;
float y = matrix.ty;
float cr = matrix.a;
float sr = matrix.b;
float cr2 = matrix.d;
float sr2 = -matrix.c;
float ax = x1 * cr - y1 * sr2 + x;
float ay = x1 * sr + y1 * cr2 + y;
float bx = x2 * cr - y1 * sr2 + x;
float by = x2 * sr + y1 * cr2 + y;
float cx = x2 * cr - y2 * sr2 + x;
float cy = x2 * sr + y2 * cr2 + y;
float dx = x1 * cr - y2 * sr2 + x;
float dy = x1 * sr + y2 * cr2 + y;
m_sQuad.bl.vertices = vertex3((float)RENDER_IN_SUBPIXEL(ax), (float)RENDER_IN_SUBPIXEL(ay), m_fVertexZ);
m_sQuad.br.vertices = vertex3((float)RENDER_IN_SUBPIXEL(bx), (float)RENDER_IN_SUBPIXEL(by), m_fVertexZ);
m_sQuad.tl.vertices = vertex3((float)RENDER_IN_SUBPIXEL(dx), (float)RENDER_IN_SUBPIXEL(dy), m_fVertexZ);
m_sQuad.tr.vertices = vertex3((float)RENDER_IN_SUBPIXEL(cx), (float)RENDER_IN_SUBPIXEL(cy), m_fVertexZ);
m_pobTextureAtlas->updateQuad(&m_sQuad, m_uAtlasIndex);
m_bDirty = m_bRecursiveDirty = false;
}
void CCNode::transform()
{
// transformations
#if CC_NODE_TRANSFORM_USING_AFFINE_MATRIX
// BEGIN alternative -- using cached transform
//
if( m_bIsTransformGLDirty ) {
CCAffineTransform t = this->nodeToParentTransform();
CGAffineToGL(&t, m_pTransformGL);
m_bIsTransformGLDirty = false;
}
glMultMatrixf(m_pTransformGL);
if( m_fVertexZ )
{
glTranslatef(0, 0, m_fVertexZ);
}
// XXX: Expensive calls. Camera should be integrated into the cached affine matrix
if (m_pCamera && !(m_pGrid && m_pGrid->isActive())) {
bool translate = (m_tAnchorPointInPixels.x != 0.0f || m_tAnchorPointInPixels.y != 0.0f);
if( translate )
{
ccglTranslate(RENDER_IN_SUBPIXEL(m_tAnchorPointInPixels.x), RENDER_IN_SUBPIXEL(m_tAnchorPointInPixels.y), 0);
}
m_pCamera->locate();
if( translate )
{
ccglTranslate(RENDER_IN_SUBPIXEL(-m_tAnchorPointInPixels.x), RENDER_IN_SUBPIXEL(-m_tAnchorPointInPixels.y), 0);
}
}
// END alternative
#else
// BEGIN original implementation
//
// translate
if ( m_bIsRelativeAnchorPoint && (m_tAnchorPointInPixels.x != 0 || m_tAnchorPointInPixels.y != 0 ) )
glTranslatef( RENDER_IN_SUBPIXEL(-m_tAnchorPointInPixels.x), RENDER_IN_SUBPIXEL(-m_tAnchorPointInPixels.y), 0);
if (m_tAnchorPointInPixels.x != 0 || m_tAnchorPointInPixels.y != 0)
glTranslatef( RENDER_IN_SUBPIXEL(m_tPositionInPixels.x + m_tAnchorPointInPixels.x), RENDER_IN_SUBPIXEL(m_tPositionInPixels.y + m_tAnchorPointInPixels.y), m_fVertexZ);
else if ( m_tPositionInPixels.x !=0 || m_tPositionInPixels.y !=0 || m_fVertexZ != 0)
glTranslatef( RENDER_IN_SUBPIXEL(m_tPositionInPixels.x), RENDER_IN_SUBPIXEL(m_tPositionInPixels.y), m_fVertexZ );
// rotate
if (m_fRotation != 0.0f )
glRotatef( -m_fRotation, 0.0f, 0.0f, 1.0f );
// scale
if (m_fScaleX != 1.0f || m_fScaleY != 1.0f)
glScalef( m_fScaleX, m_fScaleY, 1.0f );
if ( m_pCamera && !(m_pGrid && m_pGrid->isActive()) )
m_pCamera->locate();
// restore and re-position point
if (m_tAnchorPointInPixels.x != 0.0f || m_tAnchorPointInPixels.y != 0.0f)
glTranslatef(RENDER_IN_SUBPIXEL(-m_tAnchorPointInPixels.x), RENDER_IN_SUBPIXEL(-m_tAnchorPointInPixels.y), 0);
//
// END original implementation
#endif
}
void Skeleton2D_BoneDisplay::updateTransform(void)
{
CCAssert(m_pobBatchNode, "updateTransform is only valid when CCSprite is being rendered using an CCSpriteBatchNode");
// recalculate matrix only if it is dirty
if( isDirty() ) {
// If it is not visible, or one of its ancestors is not visible, then do nothing:
//if( !IsVisable() || ( m_pParent && m_pParent != m_pobBatchNode /*&& ((CCSprite*)m_pParent)->m_bShouldBeHidden*/) )
if (false)
{
m_sQuad.br.vertices = m_sQuad.tl.vertices = m_sQuad.tr.vertices = m_sQuad.bl.vertices = vertex3(0,0,0);
m_bShouldBeHidden = true;
}
else
{//
CCAffineTransform tm;
m_bShouldBeHidden = false;
tm = nodeToParentTransform();
//
// calculate the Quad based on the Affine Matrix
//
CCSize size = m_obRect.size;
float x1 = m_obOffsetPosition.x;
float y1 = m_obOffsetPosition.y;
float x2 = x1 + size.width;
float y2 = y1 + size.height;
float x = tm.tx;
float y = tm.ty;
float cr = tm.a;
float sr = tm.b;
float cr2 = tm.d;
float sr2 = -tm.c;
float ax = x1 * cr - y1 * sr2 + x;
float ay = x1 * sr + y1 * cr2 + y;
float bx = x2 * cr - y1 * sr2 + x;
float by = x2 * sr + y1 * cr2 + y;
float cx = x2 * cr - y2 * sr2 + x;
float cy = x2 * sr + y2 * cr2 + y;
float dx = x1 * cr - y2 * sr2 + x;
float dy = x1 * sr + y2 * cr2 + y;
ax*=-1.0f;ay*=-1.0f;bx*=-1.0f;by*=-1.0f;cx*=-1.0f;cy*=-1.0f;dx*=-1.0f;dy*=-1.0f;
m_sQuad.bl.vertices = vertex3( RENDER_IN_SUBPIXEL(ax), RENDER_IN_SUBPIXEL(ay), m_fVertexZ );
m_sQuad.br.vertices = vertex3( RENDER_IN_SUBPIXEL(bx), RENDER_IN_SUBPIXEL(by), m_fVertexZ );
m_sQuad.tl.vertices = vertex3( RENDER_IN_SUBPIXEL(dx), RENDER_IN_SUBPIXEL(dy), m_fVertexZ );
m_sQuad.tr.vertices = vertex3( RENDER_IN_SUBPIXEL(cx), RENDER_IN_SUBPIXEL(cy), m_fVertexZ );
}
m_pobTextureAtlas->updateQuad(&m_sQuad, m_uAtlasIndex);
m_bRecursiveDirty = false;
setDirty(false);
}
// recursively iterate over children
if( m_bHasChildren )
{
arrayMakeObjectsPerformSelector(m_pChildren, updateTransform, CCSprite*);
}
#if CC_SPRITE_DEBUG_DRAW
// draw bounding box
CCPoint vertices[4] = {
ccp( m_sQuad.bl.vertices.x, m_sQuad.bl.vertices.y ),
ccp( m_sQuad.br.vertices.x, m_sQuad.br.vertices.y ),
ccp( m_sQuad.tr.vertices.x, m_sQuad.tr.vertices.y ),
ccp( m_sQuad.tl.vertices.x, m_sQuad.tl.vertices.y ),
};
ccDrawPoly(vertices, 4, true);
#endif // CC_SPRITE_DEBUG_DRAW
}
void GAFSprite::updateTransform(void)
{
CCAssert( m_pobBatchNode, "updateTransform is only valid when CCSprite is being rendered using an CCSpriteBatchNode");
// recalculate matrix only if it is dirty
if( isDirty() ) {
// If it is not visible, or one of its ancestors is not visible, then do nothing:
if( !m_bVisible || ( m_pParent && m_pParent != (CCSprite*)m_pobBatchNode && ((CCSprite*)m_pParent)->m_bShouldBeHidden) )
{
m_sQuad.br.vertices = m_sQuad.tl.vertices = m_sQuad.tr.vertices = m_sQuad.bl.vertices = vertex3(0,0,0);
m_bShouldBeHidden = true;
}
else
{
m_bShouldBeHidden = false;
if( ! m_pParent || m_pParent == (CCSprite*)m_pobBatchNode )
{
m_transformToBatch = nodeToParentTransform();
}
else
{
CCAssert( dynamic_cast<CCSprite*>(m_pParent), "Logic error in CCSprite. Parent must be a CCSprite");
m_transformToBatch = CCAffineTransformConcat( nodeToParentTransform() , ((CCSprite*)m_pParent)->m_transformToBatch );
}
//
// calculate the Quad based on the Affine Matrix
//
CCSize size = m_obRect.size;
// x1, x2, y1, y2 are changed (comapring to CCSprite) to place Sprite at center
float x1 = m_obOffsetPosition.x - size.width / 2;
float y1 = m_obOffsetPosition.y - size.height / 2;
float x2 = x1 + size.width;
float y2 = y1 + size.height;
float x = m_transformToBatch.tx;
float y = m_transformToBatch.ty;
float cr = m_transformToBatch.a;
float sr = m_transformToBatch.b;
float cr2 = m_transformToBatch.d;
float sr2 = -m_transformToBatch.c;
float ax = x1 * cr - y1 * sr2 + x;
float ay = x1 * sr + y1 * cr2 + y;
float bx = x2 * cr - y1 * sr2 + x;
float by = x2 * sr + y1 * cr2 + y;
float cx = x2 * cr - y2 * sr2 + x;
float cy = x2 * sr + y2 * cr2 + y;
float dx = x1 * cr - y2 * sr2 + x;
float dy = x1 * sr + y2 * cr2 + y;
m_sQuad.bl.vertices = vertex3( RENDER_IN_SUBPIXEL(ax), RENDER_IN_SUBPIXEL(ay), m_fVertexZ );
m_sQuad.br.vertices = vertex3( RENDER_IN_SUBPIXEL(bx), RENDER_IN_SUBPIXEL(by), m_fVertexZ );
m_sQuad.tl.vertices = vertex3( RENDER_IN_SUBPIXEL(dx), RENDER_IN_SUBPIXEL(dy), m_fVertexZ );
m_sQuad.tr.vertices = vertex3( RENDER_IN_SUBPIXEL(cx), RENDER_IN_SUBPIXEL(cy), m_fVertexZ );
}
// MARMALADE CHANGE: ADDED CHECK FOR NULL, TO PERMIT SPRITES WITH NO BATCH NODE / TEXTURE ATLAS
if (m_pobTextureAtlas)
{
m_pobTextureAtlas->updateQuad(&m_sQuad, m_uAtlasIndex);
}
m_bRecursiveDirty = false;
setDirty(false);
}
// MARMALADE CHANGED
// recursively iterate over children
/* if( m_bHasChildren )
{
// MARMALADE: CHANGED TO USE CCNode*
// NOTE THAT WE HAVE ALSO DEFINED virtual CCNode::updateTransform()
arrayMakeObjectsPerformSelector(m_pChildren, updateTransform, CCSprite*);
}*/
CCNode::updateTransform();
#if CC_SPRITE_DEBUG_DRAW
// draw bounding box
CCPoint vertices[4] = {
ccp( m_sQuad.bl.vertices.x, m_sQuad.bl.vertices.y ),
ccp( m_sQuad.br.vertices.x, m_sQuad.br.vertices.y ),
ccp( m_sQuad.tr.vertices.x, m_sQuad.tr.vertices.y ),
ccp( m_sQuad.tl.vertices.x, m_sQuad.tl.vertices.y ),
};
ccDrawPoly(vertices, 4, true);
#endif // CC_SPRITE_DEBUG_DRAW
}
void CAView::updateTransform()
{
// Recursively iterate over children
if(m_pobImage && isDirty() )
{
// If it is not visible, or one of its ancestors is not visible, then do nothing:
if( !m_bVisible || ( m_pSuperview && m_pSuperview != m_pobBatchView && m_pSuperview->m_bShouldBeHidden) )
{
m_sQuad.br.vertices = m_sQuad.tl.vertices = m_sQuad.tr.vertices = m_sQuad.bl.vertices = vertex3(0,0,0);
m_bShouldBeHidden = true;
}
else
{
m_bShouldBeHidden = false;
if( !m_pSuperview || m_pSuperview == m_pobBatchView)
{
m_transformToBatch = nodeToParentTransform();
}
else
{
m_transformToBatch = CATransformationConcat( nodeToParentTransform() , m_pSuperview->m_transformToBatch );
}
DSize size = m_obContentSize;
float x1 = 0;
float y1 = 0;
float x = m_transformToBatch.tx;
float y = m_transformToBatch.ty;
float cr = m_transformToBatch.a;
float sr = m_transformToBatch.b;
float cr2 = m_transformToBatch.d;
float sr2 = -m_transformToBatch.c;
x1 = x1 * cr - y1 * sr2 + x;
y1 = x1 * sr + y1 * cr2 + y;
x1 = RENDER_IN_SUBPIXEL(x1);
y1 = RENDER_IN_SUBPIXEL(y1);
float x2 = x1 + size.width;
float y2 = y1 + size.height;
m_sQuad.bl.vertices = vertex3( x1, y1, m_fVertexZ );
m_sQuad.br.vertices = vertex3( x2, y1, m_fVertexZ );
m_sQuad.tl.vertices = vertex3( x1, y2, m_fVertexZ );
m_sQuad.tr.vertices = vertex3( x2, y2, m_fVertexZ );
}
if (m_pobImageAtlas)
{
m_pobImageAtlas->updateQuad(&m_sQuad, m_uAtlasIndex);
}
m_bRecursiveDirty = false;
setDirty(false);
}
if (!m_obSubviews.empty())
{
CAVector<CAView*>::iterator itr;
for (itr=m_obSubviews.begin(); itr!=m_obSubviews.end(); itr++)
(*itr)->updateTransform();
}
#if CC_SPRITE_DEBUG_DRAW
// draw bounding box
DPoint vertices[4] =
{
DPoint( m_sQuad.bl.vertices.x, m_sQuad.bl.vertices.y ),
DPoint( m_sQuad.br.vertices.x, m_sQuad.br.vertices.y ),
DPoint( m_sQuad.tr.vertices.x, m_sQuad.tr.vertices.y ),
DPoint( m_sQuad.tl.vertices.x, m_sQuad.tl.vertices.y ),
};
ccDrawPoly(vertices, 4, true);
#endif
}
