fsINode.h

Go to the documentation of this file.

/********************************************************************
*
*       Created:        25/2/2014   11:36
*
*       File:           fsINode.h
*
*       Author:         Mick Waites
*       
*       Purpose:        The base of all "things" in the app. Contains the
*                               hierarchy system and a 2D affine transformation
*                               matrix for hierarchy based rendering.
*
*********************************************************************/
 
#ifndef fsINodehdr
#define fsINodehdr
 
#include <vector>
 
#include <fsCore/fsStr.h>
#include <fsCore/fsAffineMtx2d.h>
#include <fsCore/fsVec2d.h>
#include <fsCore/fsPoint.h>
 
class fsCVariableTable;
class fsIScene;
class fsISerialisable;
 
class fsINode
{
        friend class fsCEntity;
        friend class gfCDebugJustCollectablesView;
 
public:
 
        static void staticVectorsCreate();
        static void staticVectorsDestroy();
        static void flaggedNodesDestroy();
        static void newNodesParent();
 
        fsBool matrixDirtyGet() const;
        void destroy();
 
        void initialiseFromVariableTable(const fsCVariableTable& pVars);
        void init();
 
        fsBool screenCoordConvertToLocal(const fsVec2d& pScreenPos, fsVec2d& pLocalPos);
        void posSet(const fsVec2d& pPos);
        fsVec2d posGet() const;
        fsVec2d posRelativeToAncestorGet(const fsINode* pAncestor) const;
        fsVec2d screenPositionGet() const;
 
        void scaleSet(fsVec2d const& pScale);
        fsVec2d const& scaleGet() const;
 
        void angleSet(fsF32 pAngleRadians);
        void targetAngleSet(fsF32 pRadians, fsF32 pRadiansPerSec);
        fsF32 angleGet() const;
 
        void visibleSet(fsBool pVisible);
        fsBool visibleGet() const;
        void skipMeSet(fsBool pVisible);
        fsBool skipMeGet() const;
 
        const fsStr& nameGet() const;
        void nameSet(const fsStr& pName);
 
        const fsAffineMtx2d& localMatrixGet() const;
        const fsAffineMtx2d& renderMatrixGet() const;
 
        void childAdd(fsINode* pChild);
        void childRemove(fsINode* pChild);
 
        fsINode *parentGet() const;
        fsINode *childFind(const fsStr& pName, fsBool pCaseless = false) const;
 
        void bringToFrontOfSiblings();
        void pushToBackOfSiblings();
 
        void postLink();
        void matrixUpdateIfDirty();
        void update(fsS32 pDeltaMs);
        void render();
        void reset();
 
        void hierarchyDumpToLog() const;
 
        void serialise(fsStr& pSaveStr);
        void deserialise(fsStr& pLoadStr);
        void s32Serialise(fsS32 pVal);
        fsS32 s32Deserialise();
        void boolSerialise(fsBool pVal);
        fsBool boolDeserialise();
        void strSerialise(const fsStr& pVal);
        fsStr strDeserialise();
        void pointSerialise(const fsPoint& pVal);
        fsPoint pointDeserialise();
 
        void matrixUpdate();
 
        fsINode(const fsStr& pName);
 
protected:
        virtual ~fsINode();
 
        virtual void initialiseFromVariableTableDo(const fsCVariableTable& pVars) {}
        virtual void initDo() {}
        virtual void updateDo(fsS32 pDeltaMs) {}
        virtual void renderDo() {}
        virtual void updatedMatrixProcess() {}
        virtual void resetDo() {}
        virtual void serialiseDo() {}
        virtual void deserialiseDo() {}
        virtual void postLoad() {}
        virtual void postLinkDo(){}
 
        std::vector<fsINode*> mChildren;
        fsINode* mParent;
 
        fsStr mName;
 
        fsAffineMtx2d mLocalMtx;
        fsAffineMtx2d mRenderMtx;
 
        fsBool mInChildUpdate;
 
        fsBool mVisible;
        fsBool mRenderChildrenRegardless;
        fsBool mSkipMe;
 
        fsBool mMtxDirty;
 
        fsVec2d mPos;
        fsVec2d mScale;
        fsF32 mAngle;
        
        fsF32 mTargetAngle;
        fsF32 mRotationDir;
        fsF32 mRotationSpeed;
 
        fsISerialisable* mSerialisableController;
 
private:
 
        fsBool destroyingGet() const;
 
        void rotationDirectionCalculate();
        void rotationUpdate(fsS32 pDeltaMs);
 
        void hierarchyDumpToLog(fsS32 pDepth) const;
 
        static std::vector<fsINode*>* mNodesToDestroy;
        static std::vector<std::pair<fsINode*, fsINode*>>* mNodesToParent;
};
 
#endif