KX_Camera.h

Go to the documentation of this file.

/*
 * $Id: KX_Camera.h 35063 2011-02-22 10:33:14Z jesterking $
 *
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * 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; either version 2
 * of the License, or (at your option) any later version.
 *
 * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * The Original Code is: all of this file.
 *
 * Contributor(s): none yet.
 *
 * ***** END GPL LICENSE BLOCK *****
 */

#ifndef __KX_CAMERA
#define __KX_CAMERA


#include "MT_Transform.h"
#include "MT_Matrix3x3.h"
#include "MT_Matrix4x4.h"
#include "MT_Vector3.h"
#include "MT_Point3.h"
#include "KX_GameObject.h"
#include "IntValue.h"
#include "RAS_CameraData.h"

#ifdef WITH_PYTHON
/* utility conversion function */
bool ConvertPythonToCamera(PyObject * value, KX_Camera **object, bool py_none_ok, const char *error_prefix);
#endif

class KX_Camera : public KX_GameObject
{
        Py_Header;
protected:
        friend class KX_Scene;
        RAS_CameraData  m_camdata;

        // Never used, I think...
//      void MoveTo(const MT_Point3& movevec)
//      {
                /*MT_Transform camtrans;
                camtrans.invert(m_trans1);
                MT_Matrix3x3 camorient = camtrans.getBasis();
                camtrans.translate(camorient.inverse()*movevec);
                m_trans1.invert(camtrans);
                */
//      }

        MT_Matrix4x4 m_projection_matrix;
        //MT_Matrix4x4 m_projection_matrix1;

        MT_Matrix4x4 m_modelview_matrix;
        
        bool         m_dirty;
        bool         m_normalized;
        
        MT_Vector4   m_planes[6];
        
        bool         m_frustum_culling;
        
        bool         m_set_projection_matrix;
        
        MT_Point3    m_frustum_center;
        MT_Scalar    m_frustum_radius;
        bool         m_set_frustum_center;

        bool             m_delete_node;

        void ExtractClipPlanes();
        void NormalizeClipPlanes();
        void ExtractFrustumSphere();
        MT_Vector4 *GetNormalizedClipPlanes()
        {
                ExtractClipPlanes();
                NormalizeClipPlanes();
                return m_planes;
        }

public:

        enum { INSIDE, INTERSECT, OUTSIDE } ;

        KX_Camera(void* sgReplicationInfo,SG_Callbacks callbacks,const RAS_CameraData& camdata, bool frustum_culling = true, bool delete_node = false);
        virtual ~KX_Camera();
        
        virtual CValue*                         
        GetReplica(
        );
        virtual void ProcessReplica();

        MT_Transform            GetWorldToCamera() const;
        MT_Transform            GetCameraToWorld() const;

        void                            CorrectLookUp(MT_Scalar speed);
        const MT_Point3         GetCameraLocation() const;

        /* I want the camera orientation as well. */
        const MT_Quaternion GetCameraOrientation() const;
                
        void                            SetProjectionMatrix(const MT_Matrix4x4 & mat);

        void                            SetModelviewMatrix(const MT_Matrix4x4 & mat);
                
        const MT_Matrix4x4&             GetProjectionMatrix() const;
        
        bool                            hasValidProjectionMatrix() const;
        
        void                            InvalidateProjectionMatrix(bool valid = false);
        
        const MT_Matrix4x4&             GetModelviewMatrix() const;

        float                           GetLens() const;
        float                           GetScale() const;
        float                           GetCameraNear() const;
        float                           GetCameraFar() const;
        float                           GetFocalLength() const;
        RAS_CameraData*         GetCameraData();
        
        int SphereInsideFrustum(const MT_Point3& center, const MT_Scalar &radius);
        int BoxInsideFrustum(const MT_Point3 *box);
        bool PointInsideFrustum(const MT_Point3& x);
        
        bool GetFrustumCulling() const;
        
        void EnableViewport(bool viewport);
        
        void SetViewport(int left, int bottom, int right, int top);
        
        bool GetViewport() const;
        
        int GetViewportLeft() const;
        
        int GetViewportBottom() const;
        
        int GetViewportRight() const;
        
        int GetViewportTop() const;

        virtual int GetGameObjectType() { return OBJ_CAMERA; }

#ifdef WITH_PYTHON
        KX_PYMETHOD_DOC_VARARGS(KX_Camera, sphereInsideFrustum);
        KX_PYMETHOD_DOC_O(KX_Camera, boxInsideFrustum);
        KX_PYMETHOD_DOC_O(KX_Camera, pointInsideFrustum);
        
        KX_PYMETHOD_DOC_NOARGS(KX_Camera, getCameraToWorld);
        KX_PYMETHOD_DOC_NOARGS(KX_Camera, getWorldToCamera);
        
        KX_PYMETHOD_DOC_VARARGS(KX_Camera, setViewport);        
        KX_PYMETHOD_DOC_NOARGS(KX_Camera, setOnTop);    

        KX_PYMETHOD_DOC_O(KX_Camera, getScreenPosition);
        KX_PYMETHOD_DOC_VARARGS(KX_Camera, getScreenVect);
        KX_PYMETHOD_DOC_VARARGS(KX_Camera, getScreenRay);
        
        static PyObject*        pyattr_get_perspective(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static int                      pyattr_set_perspective(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);

        static PyObject*        pyattr_get_lens(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static int                      pyattr_set_lens(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
        static PyObject*        pyattr_get_ortho_scale(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static int                      pyattr_set_ortho_scale(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
        static PyObject*        pyattr_get_near(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static int                      pyattr_set_near(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
        static PyObject*        pyattr_get_far(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static int                      pyattr_set_far(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
        
        static PyObject*        pyattr_get_use_viewport(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static int                      pyattr_set_use_viewport(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
        
        static PyObject*        pyattr_get_projection_matrix(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static int                      pyattr_set_projection_matrix(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
        
        static PyObject*        pyattr_get_modelview_matrix(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static PyObject*        pyattr_get_camera_to_world(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static PyObject*        pyattr_get_world_to_camera(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        
        static PyObject*        pyattr_get_INSIDE(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static PyObject*        pyattr_get_OUTSIDE(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static PyObject*        pyattr_get_INTERSECT(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
#endif
};

#endif //__KX_CAMERA