CCAffineTransform CPhysicsObject::nodeToParentTransform()
{
CCSprite::nodeToParentTransform();
b2Vec2 pos = m_pB2body->GetPosition();
float x = pos.x * PTM_RATIO;
float y = pos.y * PTM_RATIO;
if ( isIgnoreAnchorPointForPosition() ) {
x += m_obAnchorPointInPoints.x;
y += m_obAnchorPointInPoints.y;
}
// Make matrix
float radians = m_pB2body->GetAngle();
float c = cosf(radians);
float s = sinf(radians);
bool needsSkewMatrix = ( m_fSkewX || m_fSkewY );
if(!m_obAnchorPointInPoints.equals(CCPointZero) ){
x += c*-m_obAnchorPointInPoints.x * m_fScaleX + -s*-m_obAnchorPointInPoints.y*m_fScaleX;
y += s*-m_obAnchorPointInPoints.x * m_fScaleY + c*-m_obAnchorPointInPoints.y*m_fScaleY;
}
// Rot, Translate Matrix
m_sTransform = CCAffineTransformMake( c * m_fScaleX, s * m_fScaleX,
-s * m_fScaleY, c * m_fScaleY,
x, y );
if (needsSkewMatrix)
{
CCAffineTransform skewMatrix = CCAffineTransformMake(1.0f, tanf(CC_DEGREES_TO_RADIANS(m_fSkewY)),
tanf(CC_DEGREES_TO_RADIANS(m_fSkewX)), 1.0f,
0.0f, 0.0f );
m_sTransform = CCAffineTransformConcat(skewMatrix, m_sTransform);
// adjust anchor point
if (!m_obAnchorPointInPoints.equals(CCPointZero))
{
m_sTransform = CCAffineTransformTranslate(m_sTransform, -m_obAnchorPointInPoints.x, -m_obAnchorPointInPoints.y);
}
}
if (m_bAdditionalTransformDirty)
{
m_sTransform = CCAffineTransformConcat(m_sTransform, m_sAdditionalTransform);
m_bAdditionalTransformDirty = false;
}
return m_sTransform;
}
CCAffineTransform CCNode::nodeToParentTransform(void)
{
if ( m_bIsTransformDirty ) {
m_tTransform = CCAffineTransformIdentity;
if( ! m_bIsRelativeAnchorPoint && ! CCPoint::CCPointEqualToPoint(m_tAnchorPointInPixels, CCPointZero) )
m_tTransform = CCAffineTransformTranslate(m_tTransform, m_tAnchorPointInPixels.x, m_tAnchorPointInPixels.y);
if( ! CCPoint::CCPointEqualToPoint(m_tPositionInPixels, CCPointZero) )
m_tTransform = CCAffineTransformTranslate(m_tTransform, m_tPositionInPixels.x, m_tPositionInPixels.y);
if( m_fRotation != 0 )
m_tTransform = CCAffineTransformRotate(m_tTransform, -CC_DEGREES_TO_RADIANS(m_fRotation));
if( ! (m_fScaleX == 1 && m_fScaleY == 1) )
m_tTransform = CCAffineTransformScale(m_tTransform, m_fScaleX, m_fScaleY);
if( ! CCPoint::CCPointEqualToPoint(m_tAnchorPointInPixels, CCPointZero) )
m_tTransform = CCAffineTransformTranslate(m_tTransform, -m_tAnchorPointInPixels.x, -m_tAnchorPointInPixels.y);
m_bIsTransformDirty = false;
}
return m_tTransform;
}
void GHBoneSkin::transform()
{
if(sprite == NULL || bone == NULL)return;
float degrees = bone->degrees();
CCPoint posOffset = positionOffset;
CCPoint bonePos = ccp(((GHBone*)bone->getParent())->getPosition().x,
((GHBone*)bone->getParent())->getPosition().y);
CCAffineTransform transformOffset = CCAffineTransformTranslate(CCAffineTransformMakeIdentity(), bonePos.x, bonePos.y);
CCAffineTransform transform = CCAffineTransformRotate(CCAffineTransformMakeIdentity(),
CC_DEGREES_TO_RADIANS(degrees - angleOffset));
//we need 2 points
//origin - upward point, in order to calculate new position and new angle
CCPoint origin = ccp(0,0);
CCPoint upward = ccp(0, -10);
CCAffineTransform transform3 = CCAffineTransformRotate(CCAffineTransformMakeIdentity(),
CC_DEGREES_TO_RADIANS(degrees - angleOffset - connectionAngle));
posOffset = CCPointApplyAffineTransform(posOffset, transform3);
origin = CCPointApplyAffineTransform(origin, transform);
upward = CCPointApplyAffineTransform(upward, transform);
origin = CCPointApplyAffineTransform(origin, transformOffset);
upward = CCPointApplyAffineTransform(upward, transformOffset);
//now that we have the 2 points - lets calculate the angle
float newAngle = (atan2(upward.y - origin.y,
upward.x - origin.x)*180.0)/M_PI + 90.0;
sprite->setPosition(ccp(origin.x + posOffset.x, origin.y - posOffset.y));
sprite->setRotation(newAngle);
}
CCAffineTransform GAFSprite::nodeToParentTransform(void)
{
if (_useExternalTransform)
{
if (m_bTransformDirty)
{
m_sTransform = CCAffineTransformTranslate(_externalTransform, -m_obAnchorPointInPoints.x, -m_obAnchorPointInPoints.y);
m_bTransformDirty = false;
GAFSprite * parent = dynamic_cast<GAFSprite*>(m_pParent);
if (parent && parent->isUseChildTransform())
{
m_sTransform = CCAffineTransformConcat(m_sTransform, parent->childTransform());
}
m_bTransformDirty = false;
}
return m_sTransform;
}
else
{
return CCSprite::nodeToParentTransform();
}
}
CCAffineTransform GameObject::nodeToParentTransform(){
if (_isBox2DBody) {
b2Vec2 pos = _pB2Body->GetPosition();
float x = pos.x * _ptmRadio;
float y = pos.y * _ptmRadio;
if (m_bIgnoreAnchorPointForPosition) {
x += m_obAnchorPointInPoints.x;
y += m_obAnchorPointInPoints.y;
}
float radians = _pB2Body->GetAngle();
float c = cosf(radians);
float s = sinf(radians);
if (!m_obAnchorPointInPoints.equals(CCPointZero))
{
x += ((c * -m_obAnchorPointInPoints.x * m_fScaleX) + (-s * -m_obAnchorPointInPoints.y * m_fScaleY));
y += ((s * -m_obAnchorPointInPoints.x * m_fScaleX) + (c * -m_obAnchorPointInPoints.y * m_fScaleY));
}
m_sTransform = CCAffineTransformMake( c * m_fScaleX, s * m_fScaleX,
-s * m_fScaleY, c * m_fScaleY,
x, y );
}else{
if (m_bTransformDirty)
{
// Translate values
float x = m_obPosition.x;
float y = m_obPosition.y;
if (m_bIgnoreAnchorPointForPosition)
{
x += m_obAnchorPointInPoints.x;
y += m_obAnchorPointInPoints.y;
}
// Rotation values
// Change rotation code to handle X and Y
// If we skew with the exact same value for both x and y then we're simply just rotating
float cx = 1, sx = 0, cy = 1, sy = 0;
if (m_fRotationX || m_fRotationY)
{
float radiansX = -CC_DEGREES_TO_RADIANS(m_fRotationX);
float radiansY = -CC_DEGREES_TO_RADIANS(m_fRotationY);
cx = cosf(radiansX);
sx = sinf(radiansX);
cy = cosf(radiansY);
sy = sinf(radiansY);
}
bool needsSkewMatrix = ( m_fSkewX || m_fSkewY );
// optimization:
// inline anchor point calculation if skew is not needed
// Adjusted transform calculation for rotational skew
if (! needsSkewMatrix && !m_obAnchorPointInPoints.equals(CCPointZero))
{
x += cy * -m_obAnchorPointInPoints.x * m_fScaleX + -sx * -m_obAnchorPointInPoints.y * m_fScaleY;
y += sy * -m_obAnchorPointInPoints.x * m_fScaleX + cx * -m_obAnchorPointInPoints.y * m_fScaleY;
}
// Build Transform Matrix
// Adjusted transform calculation for rotational skew
m_sTransform = CCAffineTransformMake( cy * m_fScaleX, sy * m_fScaleX,
-sx * m_fScaleY, cx * m_fScaleY,
x, y );
// XXX: Try to inline skew
// If skew is needed, apply skew and then anchor point
if (needsSkewMatrix)
{
CCAffineTransform skewMatrix = CCAffineTransformMake(1.0f, tanf(CC_DEGREES_TO_RADIANS(m_fSkewY)),
tanf(CC_DEGREES_TO_RADIANS(m_fSkewX)), 1.0f,
0.0f, 0.0f );
m_sTransform = CCAffineTransformConcat(skewMatrix, m_sTransform);
// adjust anchor point
if (!m_obAnchorPointInPoints.equals(CCPointZero))
{
m_sTransform = CCAffineTransformTranslate(m_sTransform, -m_obAnchorPointInPoints.x, -m_obAnchorPointInPoints.y);
}
}
if (m_bAdditionalTransformDirty)
{
m_sTransform = CCAffineTransformConcat(m_sTransform, m_sAdditionalTransform);
m_bAdditionalTransformDirty = false;
}
m_bTransformDirty = false;
}
}
return m_sTransform;
}
bool CCScale9Sprite::updateWithBatchNode(CCSpriteBatchNode* batchnode, CCRect rect, bool rotated, CCRect capInsets)
{
GLubyte opacity = getOpacity();
ccColor3B color = getColor();
// Release old sprites
this->removeAllChildrenWithCleanup(true);
CC_SAFE_RELEASE(this->_centre);
CC_SAFE_RELEASE(this->_top);
CC_SAFE_RELEASE(this->_topLeft);
CC_SAFE_RELEASE(this->_topRight);
CC_SAFE_RELEASE(this->_left);
CC_SAFE_RELEASE(this->_right);
CC_SAFE_RELEASE(this->_bottomLeft);
CC_SAFE_RELEASE(this->_bottom);
CC_SAFE_RELEASE(this->_bottomRight);
if(this->_scale9Image != batchnode)
{
CC_SAFE_RELEASE(this->_scale9Image);
_scale9Image = batchnode;
CC_SAFE_RETAIN(_scale9Image);
}
_scale9Image->removeAllChildrenWithCleanup(true);
m_capInsets = capInsets;
// If there is no given rect
if ( rect.equals(CCRectZero) )
{
// Get the texture size as original
CCSize textureSize = _scale9Image->getTextureAtlas()->getTexture()->getContentSize();
rect = CCRectMake(0, 0, textureSize.width, textureSize.height);
}
// Set the given rect's size as original size
m_spriteRect = rect;
m_originalSize = rect.size;
m_preferredSize = m_originalSize;
m_capInsetsInternal = capInsets;
float w = rect.size.width;
float h = rect.size.height;
// If there is no specified center region
if ( m_capInsetsInternal.equals(CCRectZero) )
{
// CCLog("... cap insets not specified : using default cap insets ...");
m_capInsetsInternal = CCRectMake(w/3, h/3, w/3, h/3);
}
float left_w = m_capInsetsInternal.origin.x;
float center_w = m_capInsetsInternal.size.width;
float right_w = rect.size.width - (left_w + center_w);
float top_h = m_capInsetsInternal.origin.y;
float center_h = m_capInsetsInternal.size.height;
float bottom_h = rect.size.height - (top_h + center_h);
// calculate rects
// ... top row
float x = 0.0;
float y = 0.0;
// top left
CCRect lefttopbounds = CCRectMake(x, y,
left_w, top_h);
// top center
TRANSLATE_X(x, y, left_w);
CCRect centertopbounds = CCRectMake(x, y,
center_w, top_h);
// top right
TRANSLATE_X(x, y, center_w);
CCRect righttopbounds = CCRectMake(x, y,
right_w, top_h);
// ... center row
x = 0.0;
y = 0.0;
TRANSLATE_Y(x, y, top_h);
// center left
CCRect leftcenterbounds = CCRectMake(x, y,
left_w, center_h);
// center center
TRANSLATE_X(x, y, left_w);
CCRect centerbounds = CCRectMake(x, y,
center_w, center_h);
// center right
TRANSLATE_X(x, y, center_w);
CCRect rightcenterbounds = CCRectMake(x, y,
right_w, center_h);
// ... bottom row
x = 0.0;
y = 0.0;
TRANSLATE_Y(x, y, top_h);
TRANSLATE_Y(x, y, center_h);
// bottom left
CCRect leftbottombounds = CCRectMake(x, y,
left_w, bottom_h);
// bottom center
TRANSLATE_X(x, y, left_w);
CCRect centerbottombounds = CCRectMake(x, y,
center_w, bottom_h);
// bottom right
TRANSLATE_X(x, y, center_w);
CCRect rightbottombounds = CCRectMake(x, y,
right_w, bottom_h);
if (!rotated) {
// CCLog("!rotated");
CCAffineTransform t = CCAffineTransformMakeIdentity();
t = CCAffineTransformTranslate(t, rect.origin.x, rect.origin.y);
centerbounds = CCRectApplyAffineTransform(centerbounds, t);
rightbottombounds = CCRectApplyAffineTransform(rightbottombounds, t);
leftbottombounds = CCRectApplyAffineTransform(leftbottombounds, t);
righttopbounds = CCRectApplyAffineTransform(righttopbounds, t);
lefttopbounds = CCRectApplyAffineTransform(lefttopbounds, t);
rightcenterbounds = CCRectApplyAffineTransform(rightcenterbounds, t);
leftcenterbounds = CCRectApplyAffineTransform(leftcenterbounds, t);
centerbottombounds = CCRectApplyAffineTransform(centerbottombounds, t);
centertopbounds = CCRectApplyAffineTransform(centertopbounds, t);
// Centre
_centre = new CCSprite();
_centre->initWithTexture(_scale9Image->getTexture(), centerbounds);
_scale9Image->addChild(_centre, 0, pCentre);
// Top
_top = new CCSprite();
_top->initWithTexture(_scale9Image->getTexture(), centertopbounds);
_scale9Image->addChild(_top, 1, pTop);
// Bottom
_bottom = new CCSprite();
_bottom->initWithTexture(_scale9Image->getTexture(), centerbottombounds);
_scale9Image->addChild(_bottom, 1, pBottom);
// Left
_left = new CCSprite();
_left->initWithTexture(_scale9Image->getTexture(), leftcenterbounds);
_scale9Image->addChild(_left, 1, pLeft);
// Right
_right = new CCSprite();
_right->initWithTexture(_scale9Image->getTexture(), rightcenterbounds);
_scale9Image->addChild(_right, 1, pRight);
// Top left
_topLeft = new CCSprite();
_topLeft->initWithTexture(_scale9Image->getTexture(), lefttopbounds);
_scale9Image->addChild(_topLeft, 2, pTopLeft);
// Top right
_topRight = new CCSprite();
_topRight->initWithTexture(_scale9Image->getTexture(), righttopbounds);
_scale9Image->addChild(_topRight, 2, pTopRight);
// Bottom left
_bottomLeft = new CCSprite();
_bottomLeft->initWithTexture(_scale9Image->getTexture(), leftbottombounds);
_scale9Image->addChild(_bottomLeft, 2, pBottomLeft);
// Bottom right
_bottomRight = new CCSprite();
_bottomRight->initWithTexture(_scale9Image->getTexture(), rightbottombounds);
_scale9Image->addChild(_bottomRight, 2, pBottomRight);
} else {
// set up transformation of coordinates
// to handle the case where the sprite is stored rotated
// in the spritesheet
// CCLog("rotated");
CCAffineTransform t = CCAffineTransformMakeIdentity();
CCRect rotatedcenterbounds = centerbounds;
CCRect rotatedrightbottombounds = rightbottombounds;
CCRect rotatedleftbottombounds = leftbottombounds;
CCRect rotatedrighttopbounds = righttopbounds;
CCRect rotatedlefttopbounds = lefttopbounds;
CCRect rotatedrightcenterbounds = rightcenterbounds;
CCRect rotatedleftcenterbounds = leftcenterbounds;
CCRect rotatedcenterbottombounds = centerbottombounds;
CCRect rotatedcentertopbounds = centertopbounds;
t = CCAffineTransformTranslate(t, rect.size.height+rect.origin.x, rect.origin.y);
t = CCAffineTransformRotate(t, 1.57079633f);
centerbounds = CCRectApplyAffineTransform(centerbounds, t);
rightbottombounds = CCRectApplyAffineTransform(rightbottombounds, t);
leftbottombounds = CCRectApplyAffineTransform(leftbottombounds, t);
righttopbounds = CCRectApplyAffineTransform(righttopbounds, t);
lefttopbounds = CCRectApplyAffineTransform(lefttopbounds, t);
rightcenterbounds = CCRectApplyAffineTransform(rightcenterbounds, t);
leftcenterbounds = CCRectApplyAffineTransform(leftcenterbounds, t);
centerbottombounds = CCRectApplyAffineTransform(centerbottombounds, t);
centertopbounds = CCRectApplyAffineTransform(centertopbounds, t);
rotatedcenterbounds.origin = centerbounds.origin;
rotatedrightbottombounds.origin = rightbottombounds.origin;
rotatedleftbottombounds.origin = leftbottombounds.origin;
rotatedrighttopbounds.origin = righttopbounds.origin;
rotatedlefttopbounds.origin = lefttopbounds.origin;
rotatedrightcenterbounds.origin = rightcenterbounds.origin;
rotatedleftcenterbounds.origin = leftcenterbounds.origin;
rotatedcenterbottombounds.origin = centerbottombounds.origin;
rotatedcentertopbounds.origin = centertopbounds.origin;
// Centre
_centre = new CCSprite();
_centre->initWithTexture(_scale9Image->getTexture(), rotatedcenterbounds, true);
_scale9Image->addChild(_centre, 0, pCentre);
// Top
_top = new CCSprite();
_top->initWithTexture(_scale9Image->getTexture(), rotatedcentertopbounds, true);
_scale9Image->addChild(_top, 1, pTop);
// Bottom
_bottom = new CCSprite();
_bottom->initWithTexture(_scale9Image->getTexture(), rotatedcenterbottombounds, true);
_scale9Image->addChild(_bottom, 1, pBottom);
// Left
_left = new CCSprite();
_left->initWithTexture(_scale9Image->getTexture(), rotatedleftcenterbounds, true);
_scale9Image->addChild(_left, 1, pLeft);
// Right
_right = new CCSprite();
_right->initWithTexture(_scale9Image->getTexture(), rotatedrightcenterbounds, true);
_scale9Image->addChild(_right, 1, pRight);
// Top left
_topLeft = new CCSprite();
_topLeft->initWithTexture(_scale9Image->getTexture(), rotatedlefttopbounds, true);
_scale9Image->addChild(_topLeft, 2, pTopLeft);
// Top right
_topRight = new CCSprite();
_topRight->initWithTexture(_scale9Image->getTexture(), rotatedrighttopbounds, true);
_scale9Image->addChild(_topRight, 2, pTopRight);
// Bottom left
_bottomLeft = new CCSprite();
_bottomLeft->initWithTexture(_scale9Image->getTexture(), rotatedleftbottombounds, true);
_scale9Image->addChild(_bottomLeft, 2, pBottomLeft);
// Bottom right
_bottomRight = new CCSprite();
_bottomRight->initWithTexture(_scale9Image->getTexture(), rotatedrightbottombounds, true);
_scale9Image->addChild(_bottomRight, 2, pBottomRight);
}
this->setContentSize(rect.size);
this->addChild(_scale9Image);
if (m_bSpritesGenerated)
{
// Restore color and opacity
this->setOpacity(opacity);
this->setColor(color);
}
m_bSpritesGenerated = true;
return true;
}
bool CCScale9Sprite::updateWithImage(CAImage* image, CCRect rect, CCRect capInsets)
{
GLubyte opacity = getOpacity();
ccColor3B color = getColor();
// Release old sprites
this->removeAllSubviews();
CC_SAFE_RELEASE(this->_centre);
CC_SAFE_RELEASE(this->_top);
CC_SAFE_RELEASE(this->_topLeft);
CC_SAFE_RELEASE(this->_topRight);
CC_SAFE_RELEASE(this->_left);
CC_SAFE_RELEASE(this->_right);
CC_SAFE_RELEASE(this->_bottomLeft);
CC_SAFE_RELEASE(this->_bottom);
CC_SAFE_RELEASE(this->_bottomRight);
this->setImage(image);
this->removeAllSubviews();
m_capInsets = capInsets;
// If there is no given rect
if ( rect.equals(CCRectZero) )
{
// Get the Image size as original
CCSize textureSize = image->getContentSize();
rect = CCRectMake(0, 0, textureSize.width, textureSize.height);
}
this->setContentSize(rect.size);
// Set the given rect's size as original size
m_spriteRect = rect;
m_originalSize = rect.size;
m_preferredSize = m_originalSize;
m_capInsetsInternal = capInsets;
float w = rect.size.width;
float h = rect.size.height;
// If there is no specified center region
if ( m_capInsetsInternal.equals(CCRectZero) )
{
// CCLog("... cap insets not specified : using default cap insets ...");
m_capInsetsInternal = CCRectMake(w/3, h/3, w/3, h/3);
}
float left_w = m_capInsetsInternal.origin.x;
float center_w = m_capInsetsInternal.size.width;
float right_w = rect.size.width - (left_w + center_w);
float top_h = m_capInsetsInternal.origin.y;
float center_h = m_capInsetsInternal.size.height;
float bottom_h = rect.size.height - (top_h + center_h);
// calculate rects
// ... top row
float x = 0.0;
float y = 0.0;
// top left
CCRect leftbottombounds = CCRectMake(x, y,
left_w, top_h);
// top center
TRANSLATE_X(x, y, left_w);
CCRect centerbottombounds = CCRectMake(x, y,
center_w, top_h);
// top right
TRANSLATE_X(x, y, center_w);
CCRect rightbottombounds = CCRectMake(x, y,
right_w, top_h);
// ... center row
x = 0.0;
y = 0.0;
TRANSLATE_Y(x, y, bottom_h);
// center left
CCRect leftcenterbounds = CCRectMake(x, y,
left_w, center_h);
// center center
TRANSLATE_X(x, y, left_w);
CCRect centerbounds = CCRectMake(x, y,
center_w, center_h);
// center right
TRANSLATE_X(x, y, center_w);
CCRect rightcenterbounds = CCRectMake(x, y,
right_w, center_h);
// ... bottom row
x = 0.0;
y = 0.0;
TRANSLATE_Y(x, y, bottom_h);
TRANSLATE_Y(x, y, center_h);
// bottom left
CCRect lefttopbounds = CCRectMake(x, y,
left_w, bottom_h);
// bottom center
TRANSLATE_X(x, y, left_w);
CCRect centertopbounds = CCRectMake(x, y,
center_w, bottom_h);
// bottom right
TRANSLATE_X(x, y, center_w);
CCRect righttopbounds = CCRectMake(x, y,
right_w, bottom_h);
CCAffineTransform t = CCAffineTransformMakeIdentity();
t = CCAffineTransformTranslate(t, rect.origin.x, rect.origin.y);
centerbounds = CCRectApplyAffineTransform(centerbounds, t);
rightbottombounds = CCRectApplyAffineTransform(rightbottombounds, t);
leftbottombounds = CCRectApplyAffineTransform(leftbottombounds, t);
righttopbounds = CCRectApplyAffineTransform(righttopbounds, t);
lefttopbounds = CCRectApplyAffineTransform(lefttopbounds, t);
rightcenterbounds = CCRectApplyAffineTransform(rightcenterbounds, t);
leftcenterbounds = CCRectApplyAffineTransform(leftcenterbounds, t);
centerbottombounds = CCRectApplyAffineTransform(centerbottombounds, t);
centertopbounds = CCRectApplyAffineTransform(centertopbounds, t);
// Centre
_centre = new CAImageView();
_centre->initWithImage(m_pImage, centerbounds);
_centre->setTag(pCentre);
this->insertSubview(_centre, 0);
// Top
_top = new CAImageView();
_top->initWithImage(m_pImage, centertopbounds);
_top->setTag(pTop);
this->insertSubview(_top, 1);
// Bottom
_bottom = new CAImageView();
_bottom->initWithImage(m_pImage, centerbottombounds);
_bottom->setTag(pBottom);
this->insertSubview(_bottom, 1);
// Left
_left = new CAImageView();
_left->initWithImage(m_pImage, leftcenterbounds);
_left->setTag(pLeft);
this->insertSubview(_left, 1);
// Right
_right = new CAImageView();
_right->initWithImage(m_pImage, rightcenterbounds);
_right->setTag(pRight);
this->insertSubview(_right, 1);
// Top left
_topLeft = new CAImageView();
_topLeft->initWithImage(m_pImage, lefttopbounds);
_topLeft->setTag(pTopLeft);
this->insertSubview(_topLeft, 2);
// Top right
_topRight = new CAImageView();
_topRight->initWithImage(m_pImage, righttopbounds);
_topLeft->setTag(pTopRight);
this->insertSubview(_topRight, 2);
// Bottom left
_bottomLeft = new CAImageView();
_bottomLeft->initWithImage(m_pImage, leftbottombounds);
_bottom->setTag(pBottomLeft);
this->insertSubview(_bottomLeft, 2);
// Bottom right
_bottomRight = new CAImageView();
_bottomRight->initWithImage(m_pImage, rightbottombounds);
_bottomRight->setTag(pBottomRight);
this->insertSubview(_bottomRight, 2);
this->setContentSize(rect.size);
_bottomLeft->setAnchorPoint(CCPoint(0,0));
_bottomRight->setAnchorPoint(CCPoint(0,0));
_topLeft->setAnchorPoint(CCPoint(0,0));
_topRight->setAnchorPoint(CCPoint(0,0));
_left->setAnchorPoint(CCPoint(0,0));
_right->setAnchorPoint(CCPoint(0,0));
_top->setAnchorPoint(CCPoint(0,0));
_bottom->setAnchorPoint(CCPoint(0,0));
_centre->setAnchorPoint(CCPoint(0,0));
if (m_bSpritesGenerated)
{
// Restore color and opacity
this->setOpacity(opacity);
this->setColor(color);
}
m_bSpritesGenerated = true;
return true;
}
