IViewClippingObject.h

#pragma once
#include "IRefObject.h"

namespace ParaEngine
{
    class IBatchedElementDraw;
    class CShapeOBB;
    class CShapeAABB;
    class CBaseCamera;
    struct SceneState;
    
    enum ObjectShape
    {
        _ObjectShape_Circle = 0,
        _ObjectShape_Sphere,
        _ObjectShape_Rectangular,
        _ObjectShape_Box,
        _ObjectShape_NX_dynamic, 
        _ObjectShape_NX_static, 
        _ObjectShape_NX_kinematicBox,   
    };

    struct AssetEntity;

    class IViewClippingObject : public IRefObject
    {
    public:
        virtual ~IViewClippingObject(){};

        virtual ObjectShape GetObjectShape(){return _ObjectShape_Box;};

        virtual void SetObjectShape(ObjectShape shape){};

        virtual void SetBoundingBox(float fOBB_X, float fOBB_Y, float fOBB_Z, float fFacing);

        virtual void GetBoundingBox(float* fOBB_X, float* fOBB_Y, float* fOBB_Z, float* fFacing);
    
        virtual void SetBoundRect(float fWidth ,float fHeight, float fFacing){};
        virtual void GetBoundRect(float* fWidth ,float* fHeight, float* fFacing);

        virtual void SetRadius(float fRadius){};
    
        virtual float GetRadius(){return 0.f;};
    
        virtual void GetVertices(Vector3 * pVertices, int* nNumber);

        virtual void GetRenderVertices(Vector3 * pVertices, int* nNumber);

        virtual void GetVerticesWithOrigin( const Vector3* vOrigin, Vector3 * pVertices, int* nNumber);
        virtual DVector3 GetPosition();
        
        virtual void SetPosition(const DVector3& v);

        virtual void Rotate(float x, float y, float z);

        virtual void SetRotation(const Quaternion& quat);
        virtual void GetRotation(Quaternion* quat);

        virtual void SetScaling(float s);

        virtual float GetScaling();

        virtual Vector3 GetRenderOffset();

        virtual DVector3 GetObjectCenter();
        virtual void SetObjectCenter(const DVector3 & v);

        virtual void GetFacing3D( Vector3 *pV );

        inline float GetFacing() { return GetYaw(); };
        inline void SetFacing(float fFacing) { SetYaw(fFacing); };

        virtual float GetYaw(){ return 0.f; };
        virtual void SetYaw(float fFacing){};

        virtual float GetPitch(){ return 0.f; };
        virtual void SetPitch(float fFacing){};

        virtual float GetRoll(){ return 0.f; };
        virtual void SetRoll(float fFacing){};


        virtual float GetHeight(){return 0.f;};
        virtual void SetHeight(float fHeight){};

        virtual float GetWidth(){return 0.f;};
        virtual void SetWidth(float fWidth){};

        virtual float GetDepth(){return 0.f;};
        virtual void SetDepth(float fDepth){};
    
        /* return the normal at the terrain position where the object is situated at its x,z plane.*/
        virtual Vector3 GetNormal(){return Vector3(0,1.f,0);};
        virtual void SetNormal(const Vector3 & pNorm){};

        virtual void GetOBB(CShapeOBB* obb);
        virtual void GetAABB(CShapeAABB* aabb);

        
        virtual void SetAABB(const Vector3 *vMin, const Vector3 *vMax);
        
        virtual Vector3 GetLocalAABBCenter();

        virtual void SetTransform(Matrix4* pLocalTransform, const DVector3& pGlobalPos, float* pRotation);
        virtual void SetTransform(Matrix4* pWorldTransform);

        virtual Matrix4* GetRenderMatrix(Matrix4& out, int nRenderNumber = 0);

        virtual Matrix4* GetWorldTransform(Matrix4& pOut, int nRenderNumber = 0);


        virtual bool TestCollisionSphere(const Vector3* pvCenter, float radius, BYTE nMethod = 1);
        virtual bool TestCollisionSphere(CBaseCamera* pCamera, float fFarPlaneDistance);

        virtual bool TestShadowSweptSphere(CBaseCamera* pCamera, const Vector3* pvDirection);

        virtual bool TestCollision(CBaseCamera* pCamera);

        virtual bool TestCollisionObject(IViewClippingObject* pObj);
        virtual bool TestCollisionRay(const Vector3& vPickRayOrig, const Vector3& vPickRayDir, float* fDistance);
        virtual float GetSphereCollisionDepth(Vector3* pvCenter, float radius, bool bSolveDepth = false);
        virtual float GetObjectCollisionDepth(IViewClippingObject* pObj);
    
        virtual float GetObjectToPointDistance(const Vector3* pPoint);

        virtual void    DrawBoundingBox(SceneState * sceneState, DWORD color);

        virtual void    DrawOcclusionObject(SceneState * sceneState);

        virtual void DebugDraw(IBatchedElementDraw* pDebugDraw);
    };
}