GVectBase<GReal, 2> GAnimTRSNode2D::Scale(const GTimeValue TimePos, const GSpaceSystem Space, GTimeInterval& ValidInterval) const {
GProperty *tmpProp = Property("transform");
if (!tmpProp)
return GVector2(1, 1);
tmpProp = tmpProp->Property("scale");
G_ASSERT(tmpProp);
GTimeInterval tmpValid = G_FOREVER_TIMEINTERVAL;
GKeyValue xValue, yValue;
// extract scale
GProperty *xProp = tmpProp->Property("x");
GProperty *yProp = tmpProp->Property("y");
G_ASSERT(xProp != NULL);
G_ASSERT(yProp != NULL);
GError xErr = xProp->Value(xValue, tmpValid, TimePos, G_ABSOLUTE_VALUE);
GError yErr = yProp->Value(yValue, tmpValid, TimePos, G_ABSOLUTE_VALUE);
if (xErr != G_NO_ERROR || yErr != G_NO_ERROR)
return GVector2(1, 1);
ValidInterval = tmpValid;
// take care of father
if (gFather && Space == G_WORLD_SPACE) {
GVectBase<GReal, 2> retValue(xValue.RealValue(), yValue.RealValue());
retValue += gFather->Scale(TimePos, G_WORLD_SPACE, tmpValid);
ValidInterval &= tmpValid;
return retValue;
}
return GVectBase<GReal, 2>(xValue.RealValue(), yValue.RealValue());
}
void ShadowBeast::ShadowMouth::shoot()
{
BulletManager::insertBullet(new BeastBullet(this->getPosition() + GVector2(- 32, -32), D3DXToDegree( M_PI + M_PI_2 / 3)));
BulletManager::insertBullet(new BeastBullet(this->getPosition() + GVector2(0, -32), D3DXToDegree(M_PI + 0)));
BulletManager::insertBullet(new BeastBullet(this->getPosition() + GVector2(+ 32, -32), D3DXToDegree(M_PI - M_PI_2 / 3)));
_flagCanShoot = false;
}
bool SelectionScene::init()
{
_gap = 64;
_maxIndex = 1;
_stage1 = new TextSprite(eID::FONTFULL, "STAGE 1: JUNGLE", GVector2(WINDOW_WIDTH / 4, WINDOW_HEIGHT / 4));
_stage1->init();
_stage1->setScale(SCALE_FACTOR);
_stage1->setOrigin(VECTOR2ZERO);
_stage1->setOpacity(0.8f);
_stage3 = new TextSprite(eID::FONTFULL, "STAGE 3: WATERFALL", GVector2(WINDOW_WIDTH / 4, _stage1->getPosition().y + _gap));
_stage3->init();
_stage3->setScale(SCALE_FACTOR);
_stage3->setOrigin(VECTOR2ZERO);
_stage3->setOpacity(0.8f);
_yellowFancon = SpriteManager::getInstance()->getSprite(eID::YELLOWFALCON);
_yellowFancon->setPosition(GVector2(32.0f, _stage1->getPosition().y));
_yellowFancon->setScale(SCALE_FACTOR);
_yellowFancon->setOrigin(VECTOR2ZERO);
_tutLayer = SpriteManager::getInstance()->getSprite(eID::TUT_LAYER);
_tutLayer->setPosition(0, WINDOW_HEIGHT);
_tutLayer->setOrigin(VECTOR2ZERO);
_tutLayer->setOpacity(0.7f);
return true;
}
void ShadowBeast::ShadowMouth::init()
{
_hitpoint = 32;
_score = 10000;
_sprite = SpriteManager::getInstance()->getSprite(eID::SHADOW_MOUTH);
_sprite->setFrameRect(SpriteManager::getInstance()->getSourceRect(eID::SHADOW_MOUTH, "mouth_opening1"));
_sprite->setScale(SCALE_FACTOR);
_sprite->setPosition(_startposition);
_animation = new Animation(_sprite, 0.33f);
_animation->addFrameRect(eID::SHADOW_MOUTH, "mouth_opening1", "mouth_opening2", "mouth_opening3", "mouth_opening4", "mouth_opening5", "mouth_opening4", "mouth_opening3", "mouth_opening2", "mouth_opening1", "mouth_closed3", "mouth_closed2", "mouth_closed1", "mouth_closed2", "mouth_closed3", NULL);
_flagCanShoot = true;
_explosion = nullptr;
_flagBigExplosion = true;
_moulder = SpriteManager::getInstance()->getSprite(eID::SHADOW_MOUTH);
_moulder->setFrameRect(SpriteManager::getInstance()->getSourceRect(eID::SHADOW_MOUTH, "moudler"));
_moulder->setScale(SCALE_FACTOR);
_moulder->setOrigin(GVector2(0.5f, 1.0f));
_moulder->setPosition(_startposition + GVector2(0, -120) + GVector2(-1, 3));
_moulder->setZIndex(0.0f);
_flagMoudle = false;
}
void ShadowBeast::ShadowArm::init()
{
srand(599999);
_hitpoint = 16;
_score = 2000;
Sprite* hand1 = SpriteManager::getInstance()->getSprite(eID::SHADOW_ARM);
hand1->setFrameRect(SpriteManager::getInstance()->getSourceRect(eID::SHADOW_ARM, "arm"));
hand1->setScale(SCALE_FACTOR);
hand1->setPosition(_rootOfArm);
Sprite* hand2 = SpriteManager::getInstance()->getSprite(eID::SHADOW_ARM);
hand2->setFrameRect(SpriteManager::getInstance()->getSourceRect(eID::SHADOW_ARM, "arm"));
hand2->setScale(SCALE_FACTOR);
hand2->setPosition(_rootOfArm + GVector2(28, 14));
Sprite* hand3 = SpriteManager::getInstance()->getSprite(eID::SHADOW_ARM);
hand3->setFrameRect(SpriteManager::getInstance()->getSourceRect(eID::SHADOW_ARM, "arm"));
hand3->setScale(SCALE_FACTOR);
hand3->setPosition(_rootOfArm + GVector2(42, 42));
Sprite* hand4 = SpriteManager::getInstance()->getSprite(eID::SHADOW_ARM);
hand4->setFrameRect(SpriteManager::getInstance()->getSourceRect(eID::SHADOW_ARM, "arm"));
hand4->setScale(SCALE_FACTOR);
hand4->setPosition(_rootOfArm + GVector2(28, 70));
_sprite = SpriteManager::getInstance()->getSprite(eID::SHADOW_ARM);
_sprite->setFrameRect(SpriteManager::getInstance()->getSourceRect(eID::SHADOW_ARM, "hand"));
_sprite->setScale(SCALE_FACTOR);
_sprite->setPosition(_rootOfArm + GVector2(0, 80));
roundCircletime = 0.0f;
CollisionBody* collisionBody = new CollisionBody(this);
this->_componentList["CollisionBody"] = collisionBody;
__hook(&CollisionBody::onCollisionBegin, collisionBody, &Bullet::onCollisionBegin); //dư?
_stopWatch = new StopWatch();
_aimtime = new StopWatch();
_trackBillTime = new StopWatch();
_explosion = nullptr;
_isClockWise = false;
_isAiming = false;
flagforTrackBill = false;
counterforFire = 0;
_handelem1 = HandElement( hand1, 0.0f, 0 );
_handelem2 = HandElement( hand2, 0.0f, 32 );
_handelem3 = HandElement( hand3, 0.0f, 0 );
_handelem4 = HandElement( hand4, 0.0f, 0 );
_arm = HandElement( _sprite, 0.0f, 0 );
_flagAimFinish[0] = false;
_flagAimFinish[1] = false;
_flagAimFinish[2] = false;
_flagAimFinish[3] = false;
_waveCount = 0;
_memStatus = normal;
}
void ShadowBeast::init()
{
_leftArm = new ShadowArm(_position + GVector2(-115, 60));
_leftArm->init();
_leftArm->setWise(false);
_rightArm = new ShadowArm(_position + GVector2(115, 60));
_rightArm->init();
_rightArm->setWise(true);
_mouth = new ShadowMouth(_position+ GVector2(0, 120));
_mouth->init();
_flagPlayedDestroyBoss = false;
}
void FBullet::init()
{
_damage = 1;
_sprite = SpriteManager::getInstance()->getSprite(eID::BULLET);
_sprite->setFrameRect(SpriteManager::getInstance()->getSourceRect(eID::BULLET, "f_bullet"));
this->setPosition(_startPosition);
this->setScale(SCALE_FACTOR);
GVector2 begin_veloc = Bullet::initveloc(F_BULLET_SPEED);
auto movement = new Movement(GVector2(0, 0), begin_veloc, _sprite);
_componentList.insert(pair<string, IComponent*>("Movement", movement));
float radian = this->initRadian();
auto roundmovement = new RoundMovement(ROUND_RADIUS, ROUND_FREQUENCE, radian, _sprite);
_componentList["RoundMovement"] = roundmovement;
//auto circlemovement = new CircleMovement(150.0f, 1.0f, _sprite);
//_componentList["RoundMovement"] = circlemovement;
auto collisionBody = new CollisionBody(this);
_componentList.insert(pair<string, IComponent*>("CollisionBody", collisionBody));
__hook(&CollisionBody::onCollisionBegin, collisionBody, &Bullet::onCollisionBegin);
}
bool GameOverScene::init()
{
_index = 0;
_blank = SpriteManager::getInstance()->getSprite(eID::BLANK);
_blank->setScale(SCALE_FACTOR);
_blank->setOrigin(VECTOR2ZERO);
_yellowfancon = SpriteManager::getInstance()->getSprite(eID::YELLOWFALCON);
_yellowfancon->setPosition(GVector2(192.0f, 320.0f)); // hardcode
_yellowfancon->setScale(SCALE_FACTOR);
_yellowfancon->setOrigin(VECTOR2ZERO);
_background = SpriteManager::getInstance()->getSprite(eID::GAME_OVER_SCENE);
_background->setPosition(VECTOR2ZERO);
_background->setScale(SCALE_FACTOR);
_background->setOrigin(GVector2(0.0f, 1.0f));
_flash = new StopWatch();
_highscore = HighScore::loadHighScore(HighScore::filehighscore);
if (_score > _highscore)
{
_highscore = _score;
HighScore::saveHighScore(HighScore::filehighscore, _highscore);
}
_textscore = new TextSprite(eID::FONTFULL, std::to_string(_score), GVector2(160, 68));
_textscore->init();
_textscore->setScale(SCALE_FACTOR);
_textscore->getSprite()->setOpacity(0.7f);
_texthighscore = new TextSprite(eID::FONTFULL, std::to_string(_highscore), GVector2(288, 144));
_texthighscore->init();
_texthighscore->setScale(SCALE_FACTOR);
_texthighscore->getSprite()->setOpacity(0.7f);
SoundManager::getInstance()->Play(eSoundId::GAME_OVER);
return true;
}
void TextSprite::draw(LPD3DXSPRITE spriteHandle, Viewport* viewport)
{
int x = 0, y = 0;
int index = 0;
int i = 0;
for each (char c in _text)
{
if (c >= 'A' && c <= 'Z')
{
index = ((int)c) - 'A';
}
else if (c >= 'a' && c <= 'z')
{
index = ((int)c) - 'a';
}
else if (c >= '0' && c <= '9')
{
index = (((int)c) - '0') + 26;
}
else if (c == ' ')
{
index = 53;
}
else if (c == ':')
{
index = 45;
}
_sprite->setIndex(index);
_sprite->setPosition(GVector2(_position.x + _sprite->getFrameWidth() * i, _position.y));
if (viewport == nullptr)
{
_sprite->render(spriteHandle);
}
else
{
_sprite->render(spriteHandle, viewport);
}
i++;
}
}
GTwoConstantProperty1D::GTwoConstantProperty1D(const GElement* Owner) : GMultiProperty1D(Owner) {
this->Init(2, G_CONSTANTPROPERTY1D_CLASSID, GKeyValue(GVector2(0, 0)), "x;y");
}
Transformable::Transformable()
{
_scale = GVector2(1.0f, 1.0f);
}
// *********************************************************************
// GTwoLinearProperty1D
// *********************************************************************
GTwoLinearProperty1D::GTwoLinearProperty1D() : GMultiProperty1D() {
this->Init(2, G_LINEARPROPERTY1D_CLASSID, GKeyValue(GVector2(0, 0)), "x;y");
}
GTwoLinearProperty1D::GTwoLinearProperty1D(const GElement* Owner) : GMultiProperty1D(Owner) {
this->Init(2, G_LINEARPROPERTY1D_CLASSID, GKeyValue(GVector2(0, 0)), "x;y");
}
GTwoHermiteProperty1D::GTwoHermiteProperty1D(const GElement* Owner) : GMultiProperty1D(Owner) {
this->Init(2, G_HERMITEPROPERTY1D_CLASSID, GKeyValue(GVector2(0, 0)), "x;y");
}
void ShadowBeast::ShadowArm::updateElemPosition(HandElement& elem)
{
elem._sprite->setPosition(
_rootOfArm + elem._lenght * GVector2(cos(elem._angle), sin(elem._angle))
);
}
GVector2 GKeyValue::Vect2Value() const {
return GVector2(gValue[0], gValue[1]);
}
GMatrix33 GAnimTRSNode2D::InverseMatrix(const GTimeValue TimePos, const GSpaceSystem Space, GTimeInterval& ValidInterval) const {
GProperty *tmpProp = Property("transform");
// this can be the case of a curve not created through a kernel
if (!tmpProp) {
ValidInterval = G_FOREVER_TIMEINTERVAL;
return GMatrix33();
}
GMatrix33 invTranslation;
GMatrix33 invRotation;
GMatrix33 invScale;
GTimeInterval tmpValid = G_FOREVER_TIMEINTERVAL;
GKeyValue xValue, yValue;
GError xErr, yErr;
GProperty *transProp = tmpProp->Property("position");
GProperty *rotProp = tmpProp->Property("rotation");
GProperty *scaleProp = tmpProp->Property("scale");
G_ASSERT(transProp != NULL);
G_ASSERT(rotProp != NULL);
G_ASSERT(scaleProp != NULL);
// extract translation
GProperty *xProp = transProp->Property("x");
GProperty *yProp = transProp->Property("y");
G_ASSERT(xProp != NULL);
G_ASSERT(yProp != NULL);
// build translation factor
xErr = xProp->Value(xValue, tmpValid, TimePos, G_ABSOLUTE_VALUE);
yErr = yProp->Value(yValue, tmpValid, TimePos, G_ABSOLUTE_VALUE);
if (xErr != G_NO_ERROR || yErr != G_NO_ERROR)
return GMatrix33();
TranslationToMatrix(invTranslation, GVector2(-xValue.RealValue(), -yValue.RealValue()));
// build rotation factor
xErr = rotProp->Value(xValue, tmpValid, TimePos, G_ABSOLUTE_VALUE);
if (xErr != G_NO_ERROR)
return GMatrix33();
RotationToMatrix(invRotation, -xValue.RealValue());
// extract scale
xProp = scaleProp->Property("x");
yProp = scaleProp->Property("y");
G_ASSERT(xProp != NULL);
G_ASSERT(yProp != NULL);
// build scale factor
xErr = xProp->Value(xValue, tmpValid, TimePos, G_ABSOLUTE_VALUE);
yErr = yProp->Value(yValue, tmpValid, TimePos, G_ABSOLUTE_VALUE);
if (xErr != G_NO_ERROR || yErr != G_NO_ERROR)
return GMatrix33();
GPoint2 tmpScale(1, 1);
if (GMath::Abs(xValue.RealValue()) > G_EPSILON)
tmpScale[G_X] = 1 / xValue.RealValue();
if (GMath::Abs(yValue.RealValue()) > G_EPSILON)
tmpScale[G_Y] = 1 / yValue.RealValue();
ScaleToMatrix(invScale, tmpScale);
ValidInterval = tmpValid;
// take care of father
GMatrix33 invLocalMatrix = (invScale * (invRotation * invTranslation));
if (gFather && Space == G_WORLD_SPACE) {
GMatrix33 invFatherMatrix = gFather->InverseMatrix(TimePos, G_WORLD_SPACE, tmpValid);
ValidInterval &= tmpValid;
return (invLocalMatrix * invFatherMatrix);
}
return invLocalMatrix;
}
void QGLWidgetTest::BuildShape(const GFloat RadAngle1, const GFloat RadAngle2, const GFloat RadAngle3) {
GMatrix33 preTrans, postTrans, rot;
GMatrix33 finalMatrix;
// rotation pivot is at (8, 8)
TranslationToMatrix(preTrans, GVector2(-8, -8));
TranslationToMatrix(postTrans, GVector2(8, 8));
gContoursPoints.clear();
gContoursIndexes.clear();
// little cross
RotationToMatrix(rot, (GReal)RadAngle1);
finalMatrix = (postTrans * rot) * preTrans;
gContoursPoints.push_back(finalMatrix * GPoint2(6, 7));
gContoursPoints.push_back(finalMatrix * GPoint2(7, 8));
gContoursPoints.push_back(finalMatrix * GPoint2(6, 9));
gContoursPoints.push_back(finalMatrix * GPoint2(7, 10));
gContoursPoints.push_back(finalMatrix * GPoint2(8, 9));
gContoursPoints.push_back(finalMatrix * GPoint2(9, 10));
gContoursPoints.push_back(finalMatrix * GPoint2(10, 9));
gContoursPoints.push_back(finalMatrix * GPoint2(9, 8));
gContoursPoints.push_back(finalMatrix * GPoint2(10, 7));
gContoursPoints.push_back(finalMatrix * GPoint2(9, 6));
gContoursPoints.push_back(finalMatrix * GPoint2(8, 7));
gContoursPoints.push_back(finalMatrix * GPoint2(7, 6));
gContoursIndexes.push_back(12);
// big cross
RotationToMatrix(rot, (GReal)RadAngle2);
finalMatrix = (postTrans * rot) * preTrans;
gContoursPoints.push_back(finalMatrix * GPoint2(2, 6));
gContoursPoints.push_back(finalMatrix * GPoint2(2, 10));
gContoursPoints.push_back(finalMatrix * GPoint2(6, 10));
gContoursPoints.push_back(finalMatrix * GPoint2(6, 14));
gContoursPoints.push_back(finalMatrix * GPoint2(10, 14));
gContoursPoints.push_back(finalMatrix * GPoint2(10, 10));
gContoursPoints.push_back(finalMatrix * GPoint2(14, 10));
gContoursPoints.push_back(finalMatrix * GPoint2(14, 6));
gContoursPoints.push_back(finalMatrix * GPoint2(10, 6));
gContoursPoints.push_back(finalMatrix * GPoint2(10, 2));
gContoursPoints.push_back(finalMatrix * GPoint2(6, 2));
gContoursPoints.push_back(finalMatrix * GPoint2(6, 6));
gContoursIndexes.push_back(12);
// star
RotationToMatrix(rot, (GReal)RadAngle3);
finalMatrix = (postTrans * rot) * preTrans;
gContoursPoints.push_back(finalMatrix * GPoint2(2, 2));
gContoursPoints.push_back(finalMatrix * GPoint2(5, 8));
gContoursPoints.push_back(finalMatrix * GPoint2(2, 14));
gContoursPoints.push_back(finalMatrix * GPoint2(8, 11));
gContoursPoints.push_back(finalMatrix * GPoint2(14, 14));
gContoursPoints.push_back(finalMatrix * GPoint2(11, 8));
gContoursPoints.push_back(finalMatrix * GPoint2(14, 2));
gContoursPoints.push_back(finalMatrix * GPoint2(8, 5));
gContoursIndexes.push_back(8);
// square
gContoursPoints.push_back(GPoint2(1, 1));
gContoursPoints.push_back(GPoint2(1, 15));
gContoursPoints.push_back(GPoint2(15, 15));
gContoursPoints.push_back(GPoint2(15, 1));
gContoursIndexes.push_back(4);
}
void QGLWidgetTest::TestLinearGradient(const GUInt32 TestIndex, const GReal RotAngle, const GReal Scale) {
GUInt32 idx = (TestIndex % 4);
GMatrix33 ofsTransf, m;
GMatrix33 rot, scl, preTrans, postTrans;
TranslationToMatrix(preTrans, GPoint2(-120, -88));
TranslationToMatrix(postTrans, GPoint2(120, 88));
RotationToMatrix(rot, RotAngle);
ScaleToMatrix(scl, GVector2(Scale, Scale));
ofsTransf = (postTrans * (rot * (scl * preTrans)));
gDrawBoard->SetTargetMode(G_COLOR_MODE);
gDrawBoard->SetStrokePaintType(G_COLOR_PAINT_TYPE);
gDrawBoard->SetStrokeStyle(G_SOLID_STROKE);
gDrawBoard->SetStrokeJoinStyle(G_MITER_JOIN);
gDrawBoard->SetStrokeEnabled(G_TRUE);
gDrawBoard->SetStrokeWidth(4);
gDrawBoard->SetStrokeColor(GVector4(0.0, 0.0, 0.0, 1.000));
gDrawBoard->SetFillEnabled(G_TRUE);
gDrawBoard->SetFillPaintType(G_GRADIENT_PAINT_TYPE);
// OPAQUE
if (idx == 0) {
gDrawBoard->SetFillColor(GVector4(0.0, 0.0, 0.0, 1.0));
// --------------------------------------------------------------
gLinGrad1->SetColorInterpolation(G_HERMITE_COLOR_INTERPOLATION);
gLinGrad1->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+18,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(20, 18), GPoint2(260, 194));
gLinGrad1->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+18,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(280, 18), GPoint2(520, 194));
gLinGrad1->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+18,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(540, 18), GPoint2(780, 194));
// --------------------------------------------------------------
gLinGrad1->SetColorInterpolation(G_LINEAR_COLOR_INTERPOLATION);
gLinGrad1->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+212,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(20, 212), GPoint2(260, 388));
gLinGrad1->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+212,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(280, 212), GPoint2(520, 388));
gLinGrad1->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+212,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(540, 212), GPoint2(780, 388));
// --------------------------------------------------------------
gLinGrad1->SetColorInterpolation(G_CONSTANT_COLOR_INTERPOLATION);
gLinGrad1->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+406,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(20, 406), GPoint2(260, 582));
gLinGrad1->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+406,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(280, 406), GPoint2(520, 582));
gLinGrad1->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+406,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(540, 406), GPoint2(780, 582));
// --------------------------------------------------------------
}
else
if (idx == 1) {
// TRANSPARENT
gDrawBoard->SetFillColor(GVector4(0.0, 0.0, 0.0, 0.5));
// --------------------------------------------------------------
gLinGrad1->SetColorInterpolation(G_HERMITE_COLOR_INTERPOLATION);
gLinGrad1->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+18,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(20, 18), GPoint2(260, 194));
gLinGrad1->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+18,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(280, 18), GPoint2(520, 194));
gLinGrad1->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+18,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(540, 18), GPoint2(780, 194));
// --------------------------------------------------------------
gLinGrad1->SetColorInterpolation(G_LINEAR_COLOR_INTERPOLATION);
gLinGrad1->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+212,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(20, 212), GPoint2(260, 388));
gLinGrad1->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+212,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(280, 212), GPoint2(520, 388));
gLinGrad1->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+212,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(540, 212), GPoint2(780, 388));
// --------------------------------------------------------------
gLinGrad1->SetColorInterpolation(G_CONSTANT_COLOR_INTERPOLATION);
gLinGrad1->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+406,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(20, 406), GPoint2(260, 582));
gLinGrad1->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+406,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(280, 406), GPoint2(520, 582));
gLinGrad1->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+406,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(540, 406), GPoint2(780, 582));
// --------------------------------------------------------------
}
else
if (idx == 2) {
// TRANSPARENT IN KEYS
gDrawBoard->SetFillColor(GVector4(0.0, 0.0, 0.0, 1.0));
// --------------------------------------------------------------
gLinGrad2->SetColorInterpolation(G_HERMITE_COLOR_INTERPOLATION);
gLinGrad2->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+18,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(20, 18), GPoint2(260, 194));
gLinGrad2->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+18,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(280, 18), GPoint2(520, 194));
gLinGrad2->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+18,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(540, 18), GPoint2(780, 194));
// --------------------------------------------------------------
gLinGrad2->SetColorInterpolation(G_LINEAR_COLOR_INTERPOLATION);
gLinGrad2->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+212,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(20, 212), GPoint2(260, 388));
gLinGrad2->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+212,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(280, 212), GPoint2(520, 388));
gLinGrad2->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+212,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(540, 212), GPoint2(780, 388));
// --------------------------------------------------------------
gLinGrad2->SetColorInterpolation(G_CONSTANT_COLOR_INTERPOLATION);
gLinGrad2->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+406,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(20, 406), GPoint2(260, 582));
gLinGrad2->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+406,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(280, 406), GPoint2(520, 582));
gLinGrad2->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+406,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(540, 406), GPoint2(780, 582));
// --------------------------------------------------------------
}
else {
// TRANSPARENT IN KEYS AND COLOR
gDrawBoard->SetFillColor(GVector4(0.0, 0.0, 0.0, 0.5));
// --------------------------------------------------------------
gLinGrad2->SetColorInterpolation(G_HERMITE_COLOR_INTERPOLATION);
gLinGrad2->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+18,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(20, 18), GPoint2(260, 194));
gLinGrad2->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+18,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(280, 18), GPoint2(520, 194));
gLinGrad2->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+18,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(540, 18), GPoint2(780, 194));
// --------------------------------------------------------------
gLinGrad2->SetColorInterpolation(G_LINEAR_COLOR_INTERPOLATION);
gLinGrad2->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+212,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(20, 212), GPoint2(260, 388));
gLinGrad2->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+212,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(280, 212), GPoint2(520, 388));
gLinGrad2->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+212,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(540, 212), GPoint2(780, 388));
// --------------------------------------------------------------
gLinGrad2->SetColorInterpolation(G_CONSTANT_COLOR_INTERPOLATION);
gLinGrad2->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+406,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(20, 406), GPoint2(260, 582));
gLinGrad2->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+406,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(280, 406), GPoint2(520, 582));
gLinGrad2->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+406,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(540, 406), GPoint2(780, 582));
// --------------------------------------------------------------
}
}
void Transformable::setPosition(GVector3 vector)
{
this->_position = GVector2(vector.x, vector.y);
}
void Transformable::setPosition(GVector2 position)
{
this->_position = GVector2(position.x, position.y);
}
// *********************************************************************
// GTwoHermiteProperty1D
// *********************************************************************
GTwoHermiteProperty1D::GTwoHermiteProperty1D() : GMultiProperty1D() {
this->Init(2, G_HERMITEPROPERTY1D_CLASSID, GKeyValue(GVector2(0, 0)), "x;y");
}
void ShadingPoint::fetch_source_geometry() const
{
assert(hit());
assert(!(m_members & HasSourceGeometry));
// Retrieve the assembly.
m_assembly = &m_assembly_instance->get_assembly();
// Retrieve the object instance.
m_object_instance = m_assembly->object_instances().get_by_index(m_object_instance_index);
assert(m_object_instance);
// Retrieve the object.
m_object = &m_object_instance->get_object();
// Retrieve the region kit of the object.
assert(m_region_kit_cache);
const RegionKit& region_kit =
*m_region_kit_cache->access(
m_object->get_uid(), m_object->get_region_kit());
// Retrieve the region.
const IRegion* region = region_kit[m_region_index];
// Retrieve the tessellation of the region.
assert(m_tess_cache);
const StaticTriangleTess& tess =
*m_tess_cache->access(
region->get_uid(), region->get_static_triangle_tess());
const size_t motion_segment_count = tess.get_motion_segment_count();
// Retrieve the triangle.
const Triangle& triangle = tess.m_primitives[m_triangle_index];
// Copy the index of the triangle attribute.
m_triangle_pa = triangle.m_pa;
// Copy the texture coordinates from UV set #0.
if (triangle.has_vertex_attributes() && tess.get_uv_vertex_count() > 0)
{
m_v0_uv = tess.get_uv_vertex(triangle.m_a0);
m_v1_uv = tess.get_uv_vertex(triangle.m_a1);
m_v2_uv = tess.get_uv_vertex(triangle.m_a2);
}
else
{
// UV set #0 doesn't exist, or this triangle doesn't have vertex attributes.
m_v0_uv =
m_v1_uv =
m_v2_uv = GVector2(0.0);
}
// Copy the object instance space triangle vertices.
assert(triangle.m_v0 != Triangle::None);
assert(triangle.m_v1 != Triangle::None);
assert(triangle.m_v2 != Triangle::None);
if (motion_segment_count > 0)
{
// Fetch triangle vertices from the previous pose.
const size_t prev_index = truncate<size_t>(m_ray.m_time * motion_segment_count);
GVector3 prev_v0, prev_v1, prev_v2;
if (prev_index == 0)
{
prev_v0 = tess.m_vertices[triangle.m_v0];
prev_v1 = tess.m_vertices[triangle.m_v1];
prev_v2 = tess.m_vertices[triangle.m_v2];
}
else
{
prev_v0 = tess.get_vertex_pose(triangle.m_v0, prev_index - 1);
prev_v1 = tess.get_vertex_pose(triangle.m_v1, prev_index - 1);
prev_v2 = tess.get_vertex_pose(triangle.m_v2, prev_index - 1);
}
// Fetch triangle vertices from the next pose.
const GVector3 next_v0 = tess.get_vertex_pose(triangle.m_v0, prev_index);
const GVector3 next_v1 = tess.get_vertex_pose(triangle.m_v1, prev_index);
const GVector3 next_v2 = tess.get_vertex_pose(triangle.m_v2, prev_index);
// Interpolate triangle vertices.
const GScalar k = static_cast<GScalar>(m_ray.m_time * motion_segment_count - prev_index);
m_v0 = (GScalar(1.0) - k) * prev_v0 + k * next_v0;
m_v1 = (GScalar(1.0) - k) * prev_v1 + k * next_v1;
m_v2 = (GScalar(1.0) - k) * prev_v2 + k * next_v2;
}
else
{
m_v0 = tess.m_vertices[triangle.m_v0];
m_v1 = tess.m_vertices[triangle.m_v1];
m_v2 = tess.m_vertices[triangle.m_v2];
}
// Copy the object instance space triangle vertex normals.
assert(triangle.m_n0 != Triangle::None);
assert(triangle.m_n1 != Triangle::None);
assert(triangle.m_n2 != Triangle::None);
m_n0 = tess.m_vertex_normals[triangle.m_n0];
m_n1 = tess.m_vertex_normals[triangle.m_n1];
m_n2 = tess.m_vertex_normals[triangle.m_n2];
assert(is_normalized(m_n0));
assert(is_normalized(m_n1));
assert(is_normalized(m_n2));
}
this->updateElemPosition(_handelem4);
this->updateElemPosition(_arm);
}
void ShadowBeast::ShadowArm::updateElemPosition(HandElement& elem)
{
elem._sprite->setPosition(
_rootOfArm + elem._lenght * GVector2(cos(elem._angle), sin(elem._angle))
);
}
/* Shadow Mouth */
GVector2 ShadowBeast::ShadowMouth::explose_position[12] =
{
GVector2(96, 64),
GVector2(-96, 64),
GVector2(32, 64),
GVector2(-32, 64),
GVector2(32, 0),
GVector2(-32, 0),
GVector2(32, -64),
GVector2(-32, -64),
GVector2(32, -128),
GVector2(-32, -128),
GVector2(32, -192),
GVector2(-32, -192)
};
void ShadowBeast::ShadowMouth::init()
{
_hitpoint = 32;
