void CCBone::update(float delta)
{
if (m_pParentBone)
m_bBoneTransformDirty = m_bBoneTransformDirty || m_pParentBone->isTransformDirty();
if (m_bBoneTransformDirty)
{
if (m_pArmature->getArmatureData()->dataVersion >= VERSION_COMBINED)
{
CCTransformHelp::nodeConcat(*m_pTweenData, *m_pBoneData);
m_pTweenData->scaleX -= 1;
m_pTweenData->scaleY -= 1;
}
CCTransformHelp::nodeToMatrix(*m_pTweenData, m_tWorldTransform);
m_tWorldTransform = CCAffineTransformConcat(nodeToParentTransform(), m_tWorldTransform);
if(m_pParentBone)
{
m_tWorldTransform = CCAffineTransformConcat(m_tWorldTransform, m_pParentBone->m_tWorldTransform);
}
}
CCDisplayFactory::updateDisplay(this, m_pDisplayManager->getCurrentDecorativeDisplay(), delta, m_bBoneTransformDirty || m_pArmature->getArmatureTransformDirty());
CCObject *object = NULL;
CCARRAY_FOREACH(m_pChildren, object)
{
CCBone *childBone = (CCBone *)object;
childBone->update(delta);
}
CCRect VEScrollView::boundingBox()
{
CCRect rect = CCRectMake(-m_viewSize.width*0.5f,
-m_viewSize.height*0.5,
m_viewSize.width,
m_viewSize.height);
return CCRectApplyAffineTransform(rect, nodeToParentTransform());
}
//-------------------------------------------------------------------------
// 获取对象包围盒
bool FKFrameSpriteObj::GetBoundingBox( CCRect& rt )
{
if( m_pSprite )
{
rt = m_pSprite->boundingBox();
rt = CCRectApplyAffineTransform( rt, nodeToParentTransform() );
return true;
}
return false;
}
void CCSkin::setSkinData(const CCBaseData &var)
{
m_sSkinData = var;
setScaleX(m_sSkinData.scaleX);
setScaleY(m_sSkinData.scaleY);
setRotation(CC_RADIANS_TO_DEGREES(m_sSkinData.skewX));
setPosition(ccp(m_sSkinData.x, m_sSkinData.y));
m_tSkinTransform = nodeToParentTransform();
}
CCRect CCNode::boundingBoxInPixels()
{
CCRect rect = CCRectMake(0, 0, m_tContentSizeInPixels.width, m_tContentSizeInPixels.height);
return CCRectApplyAffineTransform(rect, nodeToParentTransform());
}
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
}
CCNodeTransform CCNode::parentToNodeTransform(void)
{
return nodeToParentTransform().invert();
}
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
}
