source: GTP/trunk/App/Games/Jungle_Rumble/src/Sprite.cpp @ 1378

#include "dxstdafx.h"
#include ".\sprite.h"
#include "Scene.h"
#include "GameManager.h"
#include "ResourceManager.h"

Sprite::Sprite(void) : Node()
{
        this->firstTime = true;
        this->lookAtCamera = true;
        this->rightVec.setXYZ(1, 0, 0);
        this->upVec.setXYZ(0, 1, 0);
        this->activeFrame = 0;
        this->nbFrames = 1;
        this->animationDuration = 0;
        this->maxDuration = 0;
        this->nbRows = 1;
        this->nbColumns = 1;
        this->invRows = 1;
        this->invColumns = 1;
        this->loopAnimation = true;
        this->invFps = 1;
        this->fps = 1;
        this->sphereSizeFactor = 1;
        for(int i=0;i<3;i++) {
                for(int j=0;j<7;j++) {
                        this->keyFrame[i][j] = 1;
                        currentValues[j] = 1;
                }
        }
        this->halfWidth = 1;
        this->halfHeight = 1;
        this->keyFrame[Sprite::KEY_START][KF_TIME] = 0;
        this->keyFrame[Sprite::KEY_MIDDLE][KF_TIME] = 0.5;
        this->firstRendering = true;
        this->nodeType |= Scene::NODE_SPRITE;
        this->animatedSprite = false;
        this->textureName = "";
        this->alpha = 1;
        this->firstRendering = true;
        this->texture = NULL;

}

Sprite::~Sprite(void)
{
}

void Sprite::setDimension(float _width, float _height)
{
        this->halfWidth = _width/2;
        this->halfHeight = _height/2;

        for(int i=0;i<3;i++) {
                this->keyFrame[i][Sprite::KF_HWIDTH] = this->halfWidth;
                this->keyFrame[i][Sprite::KF_HHEIGHT] = this->halfHeight;
        }

        this->minAABBox.x = -this->halfWidth;
        this->maxAABBox.x = this->halfWidth;

        this->minAABBox.y = -this->halfWidth;
        this->maxAABBox.y = this->halfWidth;

        this->minAABBox.z = -0.5;
        this->maxAABBox.z = 0.5;
}

void Sprite::update(float dt)
{
        Node::update(dt);
        
        if(!this->firstRendering) {
                this->calcCurrentValues(this->maxAge - this->timeToLive);
                
                if(this->animatedSprite) {
                        //Calculate activeFrame
                        this->animationDuration+=dt;
                        if(this->loopAnimation) {
                                if(this->animationDuration>this->maxDuration)
                                        this->animationDuration-=this->maxDuration;
                        } else {
                                this->animationDuration = this->maxDuration;
                        }

                        this->activeFrame = (int) (this->animationDuration*this->fps);
                } else {
                        this->maxDuration = (float) this->nbFrames*this->invFps;
                        this->maxDuration++;
                }
        }
}

void Sprite::generatePhysicMesh(int type) 
{ 
        sphereDesc.radius = (this->halfHeight>this->halfWidth) ? this->halfHeight*this->sphereSizeFactor : this->halfWidth*this->sphereSizeFactor;
        this->pActorDesc.shapes.pushBack(&sphereDesc);
}

Node* Sprite::clone()
{
        Sprite* obj = (Sprite*) this->myScene->createNode(Scene::NODE_SPRITE,*this->father, true, false);
        this->cloneChildren(obj);
        
        obj->lookAtCamera = this->lookAtCamera;
        obj->halfWidth = this->halfWidth;
        obj->halfHeight = this->halfHeight;
        obj->rightVec = this->rightVec;
        obj->upVec = this->upVec;
        obj->setAlpha(this->alpha);
        obj->setRowColumnCount(this->nbRows, this->nbColumns);
        obj->setFPS(this->fps);
        obj->setFrameCount(this->nbFrames);
        obj->setTexture(this->textureName);
        obj->setDimension(2*this->halfWidth, 2*this->halfHeight);
        obj->setTimeToLive(this->timeToLive);
        obj->userData = this->userData;
        for(int i=0;i<3;i++) {
                for(int j=0;j<7;j++) {
                        obj->keyFrame[i][j] = this->keyFrame[i][j];
                }
        }
        obj->animatedSprite = this->animatedSprite;

        obj->pActorDesc = this->pActorDesc;
        obj->pBodyDesc = this->pBodyDesc;
        obj->pActorDesc.body = &obj->pBodyDesc;
        
        obj->pActorDesc.shapes.clear();
        obj->sphereDesc.radius = this->sphereDesc.radius;
        obj->pActorDesc.shapes.pushBack(&obj->sphereDesc);
        return obj;
}

void Sprite::setLookAtCamera(bool _lookAtCamera)
{
        this->lookAtCamera = _lookAtCamera;
}

void Sprite::calcPhysicWorldMatrix(D3DXMATRIX &pMatWorld)
{
        if(this->lookAtCamera) {
                if(this->pActor!=NULL) {
                        NxVec3 vec = this->pActor->getGlobalPosition();
                        D3DXMatrixTranslation(&this->myWorldMatrix, vec.x, vec.y, vec.z);
                }
        } else {
                Node::calcPhysicWorldMatrix(pMatWorld);
        }
}

void Sprite::setTexture(std::string _textureName)
{
        this->textureName = _textureName;
        this->texture = this->myScene->manager->resManager.loadTexture(this->textureName);
}

void Sprite::setAlpha(float _alpha)
{
        this->alpha = _alpha;
        if(this->hasRenderer() && this->alpha!=1) {
                SimpleMeshRenderer* r = (SimpleMeshRenderer*) this->myRenderer.get();
                r->enableAlphaBlending(true);
        }
}

float Sprite::getMinDim() {
        return min(this->halfWidth, this->halfHeight);
}

void Sprite::setFPS(int _fps)
{
        this->animatedSprite = true;
        this->invFps = (float) 1.0f/_fps;
        this->fps = _fps;
}

void Sprite::setFrameCount(int _frameCount)
{
        this->animatedSprite = true;
        this->nbFrames = _frameCount;
}

void Sprite::setRowColumnCount(int _nbRows, int _nbColumns)
{
        this->animatedSprite = true;
        this->nbRows = _nbRows;
        this->nbColumns = _nbColumns;
        this->invRows = (float) 1/this->nbRows;
        this->invColumns = (float) 1/this->nbColumns;
}

void Sprite::setLoopAnimation(bool _loopAnimation)
{
        this->animatedSprite = true;
        this->loopAnimation = _loopAnimation;
}

void Sprite::setSphereSizeFactor(float _sphereSizeFactor)
{
        this->sphereSizeFactor = _sphereSizeFactor;
}

void Sprite::setKeyFrame(int _keyFrame, float alpha, float red, float green, float blue, float width, float height, float time)
{
        this->keyFrame[_keyFrame][Sprite::KF_ALPHA]     = alpha;
        this->keyFrame[_keyFrame][Sprite::KF_RED] = red;
        this->keyFrame[_keyFrame][Sprite::KF_GREEN] = green;
        this->keyFrame[_keyFrame][Sprite::KF_BLUE] = blue;
        this->keyFrame[_keyFrame][Sprite::KF_HWIDTH] = width/2;
        this->keyFrame[_keyFrame][Sprite::KF_HHEIGHT] = height/2;
        this->keyFrame[_keyFrame][Sprite::KF_TIME] = time;
}

void Sprite::calcCurrentValues(float age) {
        int sid;
        int eid;
        float fadeFactor = age/this->maxAge;
        if(fadeFactor < this->keyFrame[Sprite::KEY_MIDDLE][KF_TIME]) {
                //interpolate between start - middle
                sid = KEY_START;
                eid = KEY_MIDDLE;
                fadeFactor = fadeFactor/this->keyFrame[Sprite::KEY_MIDDLE][KF_TIME];
        } else {
                //interpolate between middle - end
                sid = KEY_MIDDLE;
                eid = KEY_END;
                fadeFactor = (fadeFactor-this->keyFrame[Sprite::KEY_MIDDLE][KF_TIME])/(1-this->keyFrame[Sprite::KEY_MIDDLE][KF_TIME]);
        }
        fadeFactor = (fadeFactor>1) ? 1 : fadeFactor;
        for(int i=0;i<7;i++) {
                this->currentValues[i] = (1-fadeFactor)*this->keyFrame[sid][i] + fadeFactor*this->keyFrame[eid][i];
        }
        this->currentValues[Sprite::KF_ALPHA] = max(0.0f, this->currentValues[Sprite::KF_ALPHA]);
        this->halfWidth = this->currentValues[Sprite::KF_HWIDTH];
        this->halfHeight = this->currentValues[Sprite::KF_HHEIGHT];
}