pseffect.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_HEADER
#define PS_EFFECT_HEADER

#include <iutil/document.h>
#include <csutil/csstring.h>
#include <csutil/array.h>
#include <csgeom/matrix3.h>
#include <iengine/movable.h>
#include <csutil/ref.h>
#include <csutil/scf.h>
#include <iutil/virtclk.h>
#include <iengine/movable.h>
#include <iengine/objwatch.h>
#include <csutil/parray.h>

struct iDocumentNode;
struct iLoaderContext;
struct iView;

class psEffectAnchor;
class psEffectObj;
class psEffect2DRenderer;
class psEffectObjTextable;

class psEffect
{
public:
    psEffect();

    ~psEffect();

    psEffectAnchor* CreateAnchor(const csString &type);

    size_t AddAnchor(psEffectAnchor* anchor);

    bool Load(iDocumentNode* node, iView* parentView, psEffect2DRenderer* renderer2d,
              iLoaderContext* ldr_context);

    unsigned int Render(iSectorList* sectors, const csVector3 &offset, iMeshWrapper* attachPos,
                        iMeshWrapper* attachTarget, const csVector3 &up, const unsigned int uniqueIDOverride = 0,
                        bool rotateWithMesh = false);

    unsigned int Render(iSector* sector, const csVector3 &offset, iMeshWrapper* attachPos,
                        iMeshWrapper* attachTarget, const csVector3 &up, const unsigned int uniqueIDOverride = 0);

    bool Update(csTicks elapsed);

    psEffect* Clone() const;

    unsigned int GetUniqueID() const;

    void SetKillTime(const int newKillTime);

    int GetKillTime() const;

    bool SetFrameParamScalings(const float* scale);

    float GetAnimLength() const;

    size_t GetAnchorCount() const;

    psEffectAnchor* GetAnchor(size_t idx) const;

    psEffectAnchor* FindAnchor(const csString &anchorName) const;

    size_t GetObjCount() const;

    psEffectObj* GetObj(size_t idx) const;

    psEffectObj* FindObj(const csString &objName) const;

    const csString &GetName() const;

    psEffectObjTextable* GetMainTextObj() const;

    bool IsVisible();

    void Show();

    void Hide();

    void SetScaling(float scale, float aspect);

private:
    class psEffectMovableListener : public scfImplementation1<psEffectMovableListener,iMovableListener>
    {
    private:
        bool movableDead;
        bool movableChanged;
        iMovable* movable;

    public:
        psEffectMovableListener()
            : scfImplementationType(this)
        {
            movableDead = false;
            movableChanged = false;
            movable = 0;
        }

        virtual ~psEffectMovableListener() {}

        virtual void MovableChanged(iMovable* movable)
        {
            movableChanged = true;
            this->movable = movable;
        }

        virtual void MovableDestroyed(iMovable* /*movable*/)
        {
            movableDead = true;
            this->movable = 0;
            movableChanged = false;
        }

        bool IsMovableDead() const
        {
            return movableDead;
        }

        bool GrabNewData(iSectorList* &newSectors, csVector3 &newPos, csMatrix3 &newTransf)
        {
            if(!movableChanged || !movable)
                return false;

            newPos = movable->GetFullPosition();
            newSectors = movable->GetSectors();
            newTransf = movable->GetFullTransform().GetT2O();

            movableChanged = false;
            return true;
        }

        bool GrabNewData(csVector3 &newPos, csMatrix3 &newTransf)
        {
            if(!movableChanged || !movable)
                return false;

            newPos = movable->GetFullPosition();
            newTransf = movable->GetFullTransform().GetT2O();
            movableChanged = false;
            return true;
        }

        csVector3 GetPosition()
        {
            if(movable)
                return movable->GetFullPosition();
            else
                return csVector3(0, 0, 0);
        }
    };

    csRef<psEffectMovableListener> positionListener;
    csRef<psEffectMovableListener> targetListener;

    bool visible;
    unsigned int uniqueID;
    csString name;

    csPDelArray<psEffectAnchor> effectAnchors;
    csPDelArray<psEffectObj> effectObjs;

    size_t mainTextObj;
    psEffect2DRenderer* renderer2d;
};

#endif