pseffectanchor.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_ANCHOR_HEADER
#define PS_EFFECT_ANCHOR_HEADER

#include <csutil/csstring.h>
#include <csutil/array.h>
#include <csutil/bitarray.h>
#include <csutil/leakguard.h>
#include <csutil/parray.h>
#include <csutil/refcount.h>
#include <iutil/virtclk.h>
#include <imesh/object.h>

struct iDocumentNode;
struct iEngine;
struct iView;
struct iMeshFactoryWrapper;
struct iSector;
struct iSectorList;

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

    void SetDefaults();

    void SetupFirstFrame();

    float time;

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

        IT_COUNT
    };

    enum KEY_ACTION
    {
        KA_POS_X = 1, KA_POS_Y, KA_POS_Z,
        KA_TOTARGET_X, KA_TOTARGET_Y, KA_TOTARGET_Z,

        KA_COUNT
    };
    float actions[KA_COUNT];

    inline const char* GetActionName(size_t idx)
    {
        switch(idx)
        {
            case KA_POS_X:
                return "Position X";
            case KA_POS_Y:
                return "Position Y";
            case KA_POS_Z:
                return "Position Z";
            case KA_TOTARGET_X:
                return "To Target X";
            case KA_TOTARGET_Y:
                return "To Target Y";
            case KA_TOTARGET_Z:
                return "To Target Z";
        }
        return "";
    }

    inline bool IsActionSet(size_t idx)
    {
        return specAction.IsBitSet(idx);
    }

    csBitArray specAction;
};


class psEffectAnchorKeyFrameGroup : public csRefCount
{
private:
    csPDelArray<psEffectAnchorKeyFrame> keyFrames;

public:
    psEffectAnchorKeyFrameGroup();
    ~psEffectAnchorKeyFrameGroup();

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

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

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

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

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

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

class psEffectAnchor
{
public:
    psEffectAnchor();
    virtual ~psEffectAnchor();

    virtual bool Load(iDocumentNode* node);

    virtual bool Create(const csVector3 &offset, iMeshWrapper* posAttach, bool rotateWithMesh = false);

    virtual bool Update(csTicks elapsed);

    void CloneBase(psEffectAnchor* newAnchor) const;

    virtual psEffectAnchor* Clone() const;

    virtual void SetPosition(const csVector3 &basePos, iSector* sector, const csMatrix3 &transf);

    virtual void SetPosition(const csVector3 &basePos, iSectorList* sectors, const csMatrix3 &transf);

    void SetTarget(const csVector3 &newTarget, const csMatrix3 &transf)
    {
        target = newTarget;
        targetTransf = transf;
    }

    const csString &GetName() const
    {
        return name;
    }

    void SetName(const csString &newName)
    {
        name = newName;
    }

    iMeshWrapper* GetMesh() const
    {
        return mesh;
    }

    virtual void SetRotBase(const csMatrix3 &newRotBase)
    {
        matBase = newRotBase;
    }

    void TransformOffset(csVector3 &offset);

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

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

    const char* GetDirectionType() const;

    void SetDirectionType(const char* newDir);

    void SetAnimLength(float newAnimLength)
    {
        animLength = newAnimLength;
    }

    float GetAnimGetSize()
    {
        return animLength;
    }

    size_t AddKeyFrame(float time);

    bool IsReady() const
    {
        return isReady;
    }

    enum DIR_TYPE
    {
        DT_NONE = 0,
        DT_ORIGIN,
        DT_TARGET,

        DT_COUNT
    };

    void FillInLerps();

protected:

    size_t FindKeyFrameByTime(float time) const;

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

    csString name; 

    float life;       
    float animLength; 

    csMatrix3 matBase; 

    csVector3 objEffectPos;

    csVector3 objBasePos;

    csVector3 objTargetOffset;

    csVector3 objOffset;
    csMatrix3 posTransf;

    csVector3 target;
    csMatrix3 targetTransf;

    csRef<iMeshWrapper> mesh;

    int dir;

    bool rotateWithMesh;

    size_t currKeyFrame; 
    size_t nextKeyFrame; 

    csRef<psEffectAnchorKeyFrameGroup> keyFrames;

    csRef<iEngine> engine;

    bool isReady;

    inline float lerp(float f1, float f2, float t1, float t2, float t)
    {
        if(t2 == t1)
            return f1;

        return f1 + (f2-f1)*(t-t1)/(t2-t1);
    }

    inline csVector3 lerpVec(const csVector3 &v1, const csVector3 &v2, float t1, float t2, float t)
    {
        if(t2 == t1)
            return v1;

        return v1 + (v2-v1)*(t-t1)/(t2-t1);
    }
};

#endif