pseffectobj.h

Go to the documentation of this file.

/*
 * Author: Andrew Robberts
 *
 * Copyright (C) 2003 Atomic Blue (info@planeshift.it, http://www.atomicblue.org)
 *
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation (version 2 of the License)
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */

#ifndef PS_EFFECT_OBJ_HEADER
#define PS_EFFECT_OBJ_HEADER

#include <csgfx/shadervar.h>
#include <csutil/csstring.h>
#include <csutil/array.h>
#include <csutil/bitarray.h>
#include <csutil/parray.h>
#include <csutil/refcount.h>
#include <csutil/leakguard.h>
#include <iutil/virtclk.h>
#include <imesh/object.h>
#include <ivideo/rendermesh.h>
#include <csgeom/matrix3.h>
#include <csgeom/vector3.h>


struct iDocumentNode;
struct iEngine;
struct iView;
struct iMeshFactoryWrapper;
struct iSector;
struct iCollection;
struct iLoaderContext;

class psEffect2DRenderer;
class psEffectAnchor;

class psEffectObjKeyFrame
{
public:
    psEffectObjKeyFrame();
    psEffectObjKeyFrame(const psEffectObjKeyFrame* other);
    psEffectObjKeyFrame(iDocumentNode* node, const psEffectObjKeyFrame* prevKeyFrame);
    ~psEffectObjKeyFrame();

    bool SetParamScalings(const float* scale);


    csTicks time;

    enum INTERP_TYPE
    {
        IT_NONE = 0,
        IT_FLOOR,
        IT_CEILING,
        IT_LERP,

        IT_COUNT
    };

    enum KEY_ACTION
    {
        KA_SCALE = 1,
        KA_TOPSCALE,
        KA_CELL,
        KA_ALPHA,
        KA_HEIGHT,
        KA_PADDING,
        KA_ANIMATE,

        KA_COUNT
    };

    enum KEY_VEC_ACTION
    {
        KA_POS = KA_COUNT,
        KA_ROT,
        KA_SPIN,
        KA_COLOUR,

        KA_VEC_COUNT
    };

    float     actions[KA_COUNT];
    csVector3 vecActions[KA_VEC_COUNT - KA_COUNT];
    int       useScale[KA_VEC_COUNT];  

    csBitArray specAction;
};

class psEffectObjKeyFrameGroup : public csRefCount
{
private:
    csPDelArray<psEffectObjKeyFrame> keyFrames;

public:
    psEffectObjKeyFrameGroup();
    ~psEffectObjKeyFrameGroup();

    size_t GetSize() const
    {
        return keyFrames.GetSize();
    }

    psEffectObjKeyFrame* Get(size_t idx) const
    {
        return keyFrames[idx];
    }

    psEffectObjKeyFrame* operator [](size_t idx) const
    {
        return keyFrames[idx];
    }

    void Push(psEffectObjKeyFrame* keyFrame)
    {
        keyFrames.Push(keyFrame);
    }

    void DeleteIndex(size_t idx)
    {
        keyFrames.DeleteIndex(idx);
    }

    void DeleteAll()
    {
        keyFrames.DeleteAll();
    }

    csPtr<psEffectObjKeyFrameGroup> Clone() const;    //ticket 6051

    bool SetFrameParamScalings(const float* scale);

};

class psEffectObj
{
public:
    psEffectObj(iView* parentView, psEffect2DRenderer* renderer2d);
    virtual ~psEffectObj();

    virtual bool Load(iDocumentNode* node, iLoaderContext* ldr_context);

    virtual bool Render(const csVector3 &up);

    virtual bool SetScaling(float scale, float aspect);

    virtual bool SetFrameParamScalings(const float* scale);

    virtual bool Update(csTicks elapsed);

    virtual void CloneBase(psEffectObj* newObj) const;

    virtual psEffectObj* Clone() const;

    virtual bool AttachToAnchor(psEffectAnchor* newAnchor);

    virtual void Show(bool value);

    int GetKillTime() const
    {
        return killTime;
    }

    void SetKillTime(int newKillTime)
    {
        killTime = newKillTime;
    }

    void SetRotBase(const csMatrix3 &newRotBase)
    {
        if(dir == DT_TO_TARGET)
            matBase = newRotBase;
    }

    void SetPosition(const csMatrix3 &newPosTransf)
    {
        if(dir == DT_ORIGIN)
            matBase = newPosTransf;
    }

    void SetTarget(const csMatrix3 &newTargetTransf)
    {
        if(dir == DT_TARGET)
            matBase = newTargetTransf;
    }

    int GetDirection() const
    {
        return dir;
    }

    void SetAnchorName(const csString &anchor)
    {
        anchorName = anchor;
    }

    const csString &GetAnchorName() const
    {
        return anchorName;
    }

    CS::Graphics::RenderPriority GetRenderPriority() const
    {
        return priority;
    }

    csZBufMode GetZBufMode() const
    {
        return zFunc;
    }

    unsigned int GetMixMode() const
    {
        return mixmode;
    }

    float GetBirth() const
    {
        return birth;
    }

    float GetAnimLength() const
    {
        return animLength;
    }

    void SetAnimationScaling(float s);

    csString GetName() const
    {
        return name;
    }

    size_t GetKeyFrameCount() const
    {
        return keyFrames->GetSize();
    }

    psEffectObjKeyFrame* GetKeyFrame(size_t idx) const
    {
        return keyFrames->Get(idx);
    }

    enum DIR_TYPE
    {
        DT_NONE = 0,
        DT_ORIGIN,
        DT_TARGET,
        DT_TO_TARGET,
        DT_CAMERA,
        DT_BILLBOARD,

        DT_COUNT
    };

protected:

    enum SCALING_TYPE
    {
        SCALING_NONE   = 0,
        SCALING_BIRTH  = 1,
        SCALING_DEATH  = 2,
        SCALING_FRAMES = 4,
        SCALING_LOOP   = 8
    };

    size_t FindKeyFrameByTime(csTicks time) const;

    bool FindNextKeyFrameWithAction(size_t startFrame, size_t action, size_t &index) const;

    void FillInLerps();

    csMatrix3 BuildRotMatrix(const csVector3 &up) const;

    csRef<iShaderVarStringSet> stringSet;

    csString name;
    csString materialName;

    int killTime;
    csTicks life;
    csTicks animLength;
    float animScaling;
    int autoScale;

    // the effect anchor that this obj is attached to
    csString anchorName;
    csRef<iMeshWrapper> anchorMesh;
    psEffectAnchor* anchor;

    csVector3 target;

    csVector3 objUp;
    csMatrix3 matBase;
    csMatrix3 matUp;

    csRef<iMeshFactoryWrapper> meshFact;
    csRef<iMeshWrapper> mesh;

    csTicks birth;
    bool isAlive;
    float baseScale;

    psEffect2DRenderer* renderer2d;

    csZBufMode zFunc;
    CS::Graphics::RenderPriority priority;
    unsigned int mixmode;

    // direction
    int dir;

    // used for the update loop
    size_t currKeyFrame;
    size_t nextKeyFrame;

    //csArray<psEffectObjKeyFrame> keyFrames;
    csRef<psEffectObjKeyFrameGroup> keyFrames;

    // CS references
    csRef<iEngine> engine;
    csRef<iView> view;
    csRef<iStringSet> globalStringSet;

    csRef<iCollection> effectsCollection;

    float scale;
    float aspect;

    inline float lerp(float f1, float f2, float factor)
    {
        if(factor == 0.f)
        {
            return f1;
        }
        else
        {
            return f1 + (f2-f1)*factor;
        }
    }

    inline csVector3 lerpVec(const csVector3 &v1, const csVector3 &v2, float factor)
    {
        if(factor == 0.f)
        {
            return v1;
        }
        else
        {
            return v1 + (v2-v1)*factor;
        }
    }

    inline float lerpFactor(csTicks t1, csTicks t2, csTicks t)
    {
        if(t2 == t1)
        {
            return 0.f;
        }
        else
        {
            if(autoScale & SCALING_FRAMES)
            {
                t /= animScaling;
            }
            else if(autoScale & SCALING_LOOP)
            {
                t %= animLength;
            }

            return ((float)(t-t1)/(float)(t2-t1));
        }
    }
};

#define LERP_KEY(action,factor) \
    lerp(keyFrames->Get(currKeyFrame)->actions[psEffectObjKeyFrame::action], \
         keyFrames->Get(nextKeyFrame)->actions[psEffectObjKeyFrame::action], \
         factor)

#define LERP_VEC_KEY(action,factor) \
    lerpVec(keyFrames->Get(currKeyFrame)->vecActions[psEffectObjKeyFrame::action - psEffectObjKeyFrame::KA_COUNT], \
            keyFrames->Get(nextKeyFrame)->vecActions[psEffectObjKeyFrame::action - psEffectObjKeyFrame::KA_COUNT], \
            factor)

#define LERP_FACTOR \
    lerpFactor(keyFrames->Get(currKeyFrame)->time, \
               keyFrames->Get(nextKeyFrame)->time, \
               life)

#endif