Esempio n. 1
0
void TransformHelp::matrixToNode(const CCAffineTransform &matrix, Node &node)
{
    /*
     *  In as3 language, there is a function called "deltaTransformPoint", it calculate a point used give Transform
     *  but not used the tx, ty value. we simulate the function here
     */
	helpPoint1.x = 0;
	helpPoint1.y = 1;
	helpPoint1 = CCPointApplyAffineTransform(helpPoint1, matrix);
	helpPoint1.x -= matrix.tx;
	helpPoint1.y -= matrix.ty;

	helpPoint2.x = 1;
	helpPoint2.y = 0;
	helpPoint2 = CCPointApplyAffineTransform(helpPoint2, matrix);
	helpPoint2.x -= matrix.tx;
	helpPoint2.y -= matrix.ty;

	node.skewX = -(atan2f(helpPoint1.y, helpPoint1.x) - 1.5707964f);
	node.skewY = atan2f(helpPoint2.y, helpPoint2.x);
	node.scaleX = sqrt(matrix.a * matrix.a + matrix.b * matrix.b);
	node.scaleY = sqrt(matrix.c * matrix.c + matrix.d * matrix.d);
	node.x = matrix.tx;
	node.y = matrix.ty;
}
Esempio n. 2
0
NoPL_FunctionValue Node::evaluateFunction(const char* functionName, const NoPL_FunctionValue* argv, unsigned int argc)
{
	NoPL_FunctionValue returnVal;
	returnVal.type = NoPL_DataType_Uninitialized;
	
	if(node)
	{
		if(argc == 0)
		{
			if(!strcmp(functionName, "worldPositionX"))
			{
				returnVal.numberValue = node->convertToWorldSpaceAR(cocos2d::CCPointZero).x;
				returnVal.type = NoPL_DataType_Number;
			}
			else if(!strcmp(functionName, "worldPositionY"))
			{
				returnVal.numberValue = node->convertToWorldSpaceAR(cocos2d::CCPointZero).y;
				returnVal.type = NoPL_DataType_Number;
			}
		}
		else if(!strcmp(functionName, "hitTest"))
		{
			if(argc == 2 &&
			   argv[0].type == NoPL_DataType_Number &&
			   argv[1].type == NoPL_DataType_Number)
			{
				returnVal.booleanValue = (node->hitTest(cocos2d::CCPoint(argv[0].numberValue, argv[1].numberValue)));
				returnVal.type = NoPL_DataType_Boolean;
			}
			else if(argc == 1 && argv[0].type == NoPL_DataType_Pointer)
			{
				cocos2d::CCObject* arg = (cocos2d::CCObject*)argv[0].pointerValue;
				Node* otherNode = dynamic_cast<Node*>(arg);
				if(otherNode && otherNode->getCCNode())
				{
					//get the transforms for each node
					cocos2d::CCAffineTransform thisTransform = node->nodeToWorldTransform();
					cocos2d::CCAffineTransform nodeTransform = otherNode->getCCNode()->nodeToWorldTransform();
					
					//create a rect for each node in the same coord system
					cocos2d::CCRect thisRect;
					thisRect.origin = CCPointApplyAffineTransform(cocos2d::CCPoint(0,0), thisTransform);
					thisRect.size = CCSizeApplyAffineTransform(node->getContentSize(), thisTransform);
					cocos2d::CCRect nodeRect;
					nodeRect.origin = CCPointApplyAffineTransform(cocos2d::CCPoint(0,0), nodeTransform);
					nodeRect.size = CCSizeApplyAffineTransform(otherNode->getCCNode()->getContentSize(), nodeTransform);
					
					//return the result of the hit test
					returnVal.booleanValue = thisRect.intersectsRect(nodeRect);
					returnVal.type = NoPL_DataType_Boolean;
				}
			}
		}
	}
	
	if(returnVal.type == NoPL_DataType_Uninitialized)
		return Node_Base::evaluateFunction(functionName, argv, argc);
	return returnVal;
}
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);
}
Esempio n. 4
0
void MissileAttack::resetPosition()
{
    CCPoint p(0, distance);
    
    CCAffineTransform transform = CCAffineTransformRotate(CCAffineTransformIdentity, angle);
    p = CCPointApplyAffineTransform(p, transform);
    missile->setRotation(-angle / M_PI * 180);
    missile->setPosition(p);
    
    p = CCPoint(0, 120);
    
    transform = CCAffineTransformRotate(CCAffineTransformIdentity, angle);
    p = CCPointApplyAffineTransform(p, transform);
    aim->setRotation(-angle / M_PI * 180);
    aim->setPosition(p);
}
Esempio n. 5
0
//------------------------------------------------------------------------------
void QLabel::CalculateSize( void)
{
    CCPoint bottom_left( 0.0f, 0.0f);
    CCSize content_size = m_CCFontNode->getContentSize();
    CCPoint top_right( content_size.width, content_size.height);

    CCAffineTransform to_parent = CCAffineTransformConcat(m_CCFontNode->nodeToParentTransform(), m_CCNode->nodeToParentTransform());

    bottom_left = CCPointApplyAffineTransform( bottom_left, to_parent);
    top_right = CCPointApplyAffineTransform( top_right, to_parent);
    
    xText = bottom_left.x;
    yText = bottom_left.y;
    wText = top_right.x - bottom_left.x;
    hText = top_right.y - bottom_left.y;
}
Esempio n. 6
0
CCPoint CCNode::convertToWorldSpace(CCPoint nodePoint)
{
	CCPoint ret;
	if(CC_CONTENT_SCALE_FACTOR() == 1)
	{
		ret = CCPointApplyAffineTransform(nodePoint, nodeToWorldTransform());
	}
	else 
	{
		ret = ccpMult( nodePoint, CC_CONTENT_SCALE_FACTOR() );
		ret = CCPointApplyAffineTransform(ret, nodeToWorldTransform());
		ret = ccpMult( ret, 1/CC_CONTENT_SCALE_FACTOR() );
	}

	return ret;
}
Esempio n. 7
0
void NormalAttack::resetPosition()
{
    CCPoint p(0, distance);
    CCAffineTransform transform = CCAffineTransformRotate(CCAffineTransformIdentity, angle);
    p = CCPointApplyAffineTransform(p, transform);
    sprite->setRotation(-angle / M_PI * 180);
    sprite->setPosition(p);
}
	CCRect CCRectApplyAffineTransform(const CCRect& rect, const CCAffineTransform& anAffineTransform)
	{
		float top = CCRect::CCRectGetMinY(rect);
		float left = CCRect::CCRectGetMinX(rect);
		float right = CCRect::CCRectGetMaxX(rect);
		float bottom = CCRect::CCRectGetMaxY(rect);

		CCPoint topLeft = CCPointApplyAffineTransform(CCPointMake(left, top), anAffineTransform);
		CCPoint topRight = CCPointApplyAffineTransform(CCPointMake(right, top), anAffineTransform);
		CCPoint bottomLeft = CCPointApplyAffineTransform(CCPointMake(left, bottom), anAffineTransform);
		CCPoint bottomRight = CCPointApplyAffineTransform(CCPointMake(right, bottom), anAffineTransform);

		float minX = std::min(std::min(topLeft.x, topRight.x), std::min(bottomLeft.x, bottomRight.x));
		float maxX = std::max(std::max(topLeft.x, topRight.x), std::max(bottomLeft.x, bottomRight.x));
		float minY = std::min(std::min(topLeft.y, topRight.y), std::min(bottomLeft.y, bottomRight.y));
		float maxY = std::max(std::max(topLeft.y, topRight.y), std::max(bottomLeft.y, bottomRight.y));

		return CCRectMake(minX, minY, (maxX - minX), (maxY - minY));
	}
CCAffineTransform CCSkin::nodeToWorldTransformAR()
{
	CCAffineTransform displayTransform = m_sTransform;
	CCPoint anchorPoint =  m_obAnchorPointInPoints;

	anchorPoint = CCPointApplyAffineTransform(anchorPoint, displayTransform);
	
	displayTransform.tx = anchorPoint.x;
	displayTransform.ty = anchorPoint.y;

	return CCAffineTransformConcat(displayTransform, m_pBone->getArmature()->nodeToWorldTransform());
}
Esempio n. 10
0
void CCDisplayFactory::updateDisplay(CCBone *bone, float dt, bool dirty)
{
    CCNode *display = bone->getDisplayRenderNode();
    CS_RETURN_IF(!display);

    switch(bone->getDisplayRenderNodeType())
    {
    case CS_DISPLAY_SPRITE:
        if (dirty)
        {
            (static_cast<CCSkin*>(display))->updateArmatureTransform();
        }
        break;
    case CS_DISPLAY_PARTICLE:
        updateParticleDisplay(bone, display, dt);
        break;
    case CS_DISPLAY_ARMATURE:
        updateArmatureDisplay(bone, display, dt);
        break;
    default:
        display->setAdditionalTransform(bone->nodeToArmatureTransform());
        break;
    }

#if ENABLE_PHYSICS_BOX2D_DETECT || ENABLE_PHYSICS_CHIPMUNK_DETECT || ENABLE_PHYSICS_SAVE_CALCULATED_VERTEX
    if (dirty)
    {
        CCDecorativeDisplay *decoDisplay = bone->getDisplayManager()->getCurrentDecorativeDisplay();
        CCColliderDetector *detector = decoDisplay->getColliderDetector();
        if (detector)
        {
            do
            {
#if ENABLE_PHYSICS_BOX2D_DETECT
                CC_BREAK_IF(!detector->getBody());
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
                CC_BREAK_IF(!detector->getBody());
#endif

                CCAffineTransform displayTransform = display->nodeToParentTransform();
                CCPoint anchorPoint =  display->getAnchorPointInPoints();
                anchorPoint = CCPointApplyAffineTransform(anchorPoint, displayTransform);
                displayTransform.tx = anchorPoint.x;
                displayTransform.ty = anchorPoint.y;
                CCAffineTransform t = CCAffineTransformConcat(displayTransform, bone->getArmature()->nodeToParentTransform());
                detector->updateTransform(t);
            }
            while (0);
        }
    }
#endif
}
Esempio n. 11
0
void CCDisplayFactory::updateDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay, float dt, bool dirty)
{
    CS_RETURN_IF(!decoDisplay);

#if ENABLE_PHYSICS_BOX2D_DETECT || ENABLE_PHYSICS_CHIPMUNK_DETECT
    if (dirty)
    {
        CCColliderDetector *detector = decoDisplay->getColliderDetector();
        if (detector)
        {
            do
            {
#if ENABLE_PHYSICS_BOX2D_DETECT
                CC_BREAK_IF(!detector->getBody());
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
                CC_BREAK_IF(!detector->getBody());
#endif
                CCNode *node = decoDisplay->getDisplay();
                CCAffineTransform displayTransform = node->nodeToParentTransform();
                CCPoint anchorPoint =  node->getAnchorPointInPoints();
                anchorPoint = CCPointApplyAffineTransform(anchorPoint, displayTransform);
                displayTransform.tx = anchorPoint.x;
                displayTransform.ty = anchorPoint.y;
                CCAffineTransform t = CCAffineTransformConcat(displayTransform, bone->getArmature()->nodeToParentTransform());
                detector->updateTransform(t);
            }
            while (0);
        }
    }
#endif

    CCNode *display = decoDisplay->getDisplay();

    switch(decoDisplay->getDisplayData()->displayType)
    {
    case CS_DISPLAY_SPRITE:
        updateSpriteDisplay(bone, display, dt, dirty);
        break;
    case CS_DISPLAY_PARTICLE:
        updateParticleDisplay(bone, display, dt, dirty);
        break;
    case CS_DISPLAY_ARMATURE:
        updateArmatureDisplay(bone, display, dt, dirty);
        break;
    default:
    {
        display->setAdditionalTransform(bone->nodeToArmatureTransform());
    }
    break;
    }
}
Esempio n. 12
0
bool MissileAttack::enable()
{
    if (distance < 120)
    {
        CCPoint p(0, -10);
        CCAffineTransform transform = CCAffineTransformRotate(CCAffineTransformIdentity, angle);
        p = CCPointApplyAffineTransform(p, transform);
        CCMoveBy * move = CCMoveBy::create(0.1f, p);
        CCActionInterval * rev = move->reverse();
        CCAction * seq = CCSequence::create(move, rev, NULL);
        getParent()->runAction(seq);
        return false;
    }
    
    return true;
}
Esempio n. 13
0
bool MissileAttack::hit(cocos2d::CCSprite *player)
{
    if (isHit)
        return false;
    
    CCPoint p1(0, distance - missile->getContentSize().height / 2);
    CCAffineTransform transform = CCAffineTransformRotate(CCAffineTransformIdentity, angle);
    p1 = CCPointApplyAffineTransform(p1, transform);
    
    CCPoint p2 = player->getPosition();
    
    float dist = sqrtf(powf(p1.x - p2.x, 2) + powf(p1.y - p2.y, 2));
    
    if (dist < player->getContentSize().width / 2)
        return isHit = true;
    
    return false;
}