cCamera.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cCamera_H
#define _INC_cCamera_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#include "Gray3D.h"
#include "GrayLib/include/Geometry/cSphere.h"
#include "GrayLib/include/Geometry/cHexahedron.h"
#include "GrayLib/include/Geometry/cRectI.h"
#include "GrayCore/include/cUnitTestDecl.h"
 
namespace Gray3D
{
        class GRAY3D_LINK cCameraParamsBase
        {
 
        public:
                cVector3f m_vEye;               
                cVector3f m_vAng;               
                METERSf_t m_fFar;               
                METERSf_t m_fNear;              
 
        public:
                cCameraParamsBase();
 
                const cVector3f& get_Eye() const noexcept
                {
                        return m_vEye;
                }
                const cVector3f& get_Ang() const noexcept
                {
                        return m_vAng;
                }
        };
 
        class GRAY3D_LINK cCameraParams : public cCameraParamsBase
        {
 
        public:
                cRectI m_ProjRect;                      
 
                cVector3f m_vAxisCam[AXIS_Trans];               
 
                static const cVector3f k_vLocalSide;    
                static const cVector3f k_vLocalUp;              
                static const cVector3f k_vLocalAhead;   
 
        protected:
                cMatrix4x4f m_mProj;            
 
                cMatrix4x4f m_mView;            
                cMatrix4x4f m_mInvView;         
 
                cMatrix4x4f m_mView0;           
                cMatrix4x4f m_mInvView0;        
 
                cMatrix4x4f m_mViewProj;        
 
                cHexahedron m_FrustumWindow;    
 
        protected:
                void UpdateDerived();
        public:
                cCameraParams();
                DECLARE_HEAP_ALIGNED_ALLOC(cCameraParams); // needed! lot of need-to-be-aligned matrices inside!
 
                // derived params.
                const cMatrix4x4f& get_ProjMatrix() const
                { return m_mProj; }
 
                const cMatrix4x4f& get_ViewMatrix() const
                { return m_mView; }
                const cMatrix4x4f& get_InvViewMatrix() const
                { return m_mInvView; }
 
                const cMatrix4x4f& get_View0Matrix() const
                { return m_mView0; }
                const cMatrix4x4f& get_InvView0Matrix() const
                { return m_mInvView0; }
 
                const cMatrix4x4f& get_ViewProjMatrix() const
                { return m_mViewProj; }
 
                bool ClampProjectPos( cVector2f& posScreen ) const;
                bool GetProjectPos( cVector2f& posScreen, const cVector3f& posTop ) const;
 
                GINTERSECT_TYPE CheckBSphere( const cSpheref& sphere ) const
                {
                        return m_FrustumWindow.IntersectTest( sphere );
                }
                GINTERSECT_TYPE CheckBSphere( const cVector3f& vCenter, float fRadius ) const
                {
                        return CheckBSphere( cSpheref( vCenter, fRadius ));
                }
 
                GINTERSECT_TYPE CheckBSphereTrans( const cVector3f& vCenter, float fRadius ) const
                {
                        return CheckBSphere( vCenter.GetProj( m_mView ), fRadius );
                }
 
                void UpdateMatrix();    
        };
 
        class GRAY3D_LINK cCameraController
        {
        };
 
        class GRAY3D_LINK cCameraControlOrbit : public cCameraController
        {
 
        protected:
                cVector3f       m_vOrbitTarget;                 
                RADIANf_t       m_fOrbitPitch;                  
                RADIANf_t       m_fOrbitHeading;                
                METERSf_t       m_fOrbitDistanceCur;    
                METERSf_t       m_fOrbitDistanceMax;    
 
        public:
                cCameraControlOrbit();
 
                const cVector3f& get_OrbitTarget() const
                {
                        return m_vOrbitTarget;
                }
                void put_OrbitHeading( RADIANf_t fOrbitHeading )
                {
                        m_fOrbitHeading = fOrbitHeading;
                }
                const METERSf_t get_OrbitDistance() const
                {
                        return m_fOrbitDistanceCur;
                }
                void put_OrbitDistance( METERSf_t fOrbitDistance )
                {
                        m_fOrbitDistanceCur = fOrbitDistance;
                }
 
                cVector3f CalcOrbitEye();
        };
 
        class GRAY3D_LINK cCamera
        {
        public:
                cCameraParams m_Param;                          
                cCameraController* m_pControl;          
 
        public:
                cCamera(void);
                ~cCamera(void);
 
                UNITTEST_FRIEND(cCamera)
        };
};
#endif