patch 8235 8218 8211 added: various gameengine improvements, fixed windows project...
[blender.git] / source / gameengine / Ketsji / KX_Camera.h
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version. The Blender
10  * Foundation also sells licenses for use in proprietary software under
11  * the Blender License.  See http://www.blender.org/BL/ for information
12  * about this.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
24  * All rights reserved.
25  *
26  * The Original Code is: all of this file.
27  *
28  * Contributor(s): none yet.
29  *
30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
31  * Camera in the gameengine. Cameras are also used for views.
32  */
33
34 #ifndef __KX_CAMERA
35 #define __KX_CAMERA
36
37
38 #include "MT_Transform.h"
39 #include "MT_Matrix3x3.h"
40 #include "MT_Matrix4x4.h"
41 #include "MT_Vector3.h"
42 #include "MT_Point3.h"
43 #include "KX_GameObject.h"
44 #include "IntValue.h"
45 #include "RAS_CameraData.h"
46
47 class KX_Camera : public KX_GameObject
48 {
49         Py_Header;
50 protected:
51         /** Camera parameters (clips distances, focal lenght). These
52          * params are closely tied to Blender. In the gameengine, only the
53          * projection and modelview matrices are relevant. There's a
54          * conversion being done in the engine class. Why is it stored
55          * here? It doesn't really have a function here. */
56         RAS_CameraData  m_camdata;
57
58         // Never used, I think...
59 //      void MoveTo(const MT_Point3& movevec)
60 //      {
61                 /*MT_Transform camtrans;
62                 camtrans.invert(m_trans1);
63                 MT_Matrix3x3 camorient = camtrans.getBasis();
64                 camtrans.translate(camorient.inverse()*movevec);
65                 m_trans1.invert(camtrans);
66                 */
67 //      }
68
69         /**
70          * Storage for the projection matrix that is passed to the
71          * rasterizer. */
72         MT_Matrix4x4 m_projection_matrix;
73
74         /**
75          * Storage for the modelview matrix that is passed to the
76          * rasterizer. */
77         MT_Matrix4x4 m_modelview_matrix;
78         
79         /**
80          * true if the view frustum (modelview/projection matrix)
81          * has changed - the clip planes (m_planes) will have to be
82          * regenerated.
83          */
84         bool         m_dirty;
85         /**
86          * true if the frustum planes have been normalized.
87          */
88         bool         m_normalized;
89         
90         /**
91          * View Frustum clip planes.
92          */
93         MT_Vector4   m_planes[6];
94         
95         /**
96          * This camera is frustum culling.
97          * Some cameras (ie if the game was started from a non camera view should not cull.)
98          */
99         bool         m_frustum_culling;
100         
101         /**
102          * true if this camera has a valid projection matrix.
103          */
104         bool         m_set_projection_matrix;
105         
106         /**
107          * The center point of the frustum.
108          */
109         MT_Point3    m_frustum_center;
110         MT_Scalar    m_frustum_radius;
111         bool         m_set_frustum_center;
112
113         /**
114          * Python module doc string.
115          */
116         static char doc[];
117
118         /**
119          * Extracts the camera clip frames from the projection and world-to-camera matrices.
120          */
121         void ExtractClipPlanes();
122         /**
123          * Normalize the camera clip frames.
124          */
125         void NormalizeClipPlanes();
126         /**
127          * Extracts the bound sphere of the view frustum.
128          */
129         void ExtractFrustumSphere();
130 public:
131
132         typedef enum { INSIDE, INTERSECT, OUTSIDE } ;
133
134         KX_Camera(void* sgReplicationInfo,SG_Callbacks callbacks,const RAS_CameraData& camdata, bool frustum_culling = true, PyTypeObject *T = &Type);
135         virtual ~KX_Camera();
136         
137         MT_Transform            GetWorldToCamera() const;
138         MT_Transform            GetCameraToWorld() const;
139
140         /**
141          * Not implemented.
142          */
143         void                            CorrectLookUp(MT_Scalar speed);
144         const MT_Point3         GetCameraLocation() const;
145
146         /* I want the camera orientation as well. */
147         const MT_Quaternion GetCameraOrientation() const;
148                 
149         /** Sets the projection matrix that is used by the rasterizer. */
150         void                            SetProjectionMatrix(const MT_Matrix4x4 & mat);
151
152         /** Sets the modelview matrix that is used by the rasterizer. */
153         void                            SetModelviewMatrix(const MT_Matrix4x4 & mat);
154                 
155         /** Gets the projection matrix that is used by the rasterizer. */
156         const MT_Matrix4x4&             GetProjectionMatrix() const;
157         
158         /** returns true if this camera has been set a projection matrix. */
159         bool                            hasValidProjectionMatrix() const;
160         
161         /** Sets the validity of the projection matrix.  Call this if you change camera
162             data (eg lens, near plane, far plane) and require the projection matrix to be
163             recalculated.
164          */
165         void                            InvalidateProjectionMatrix(bool valid = false);
166         
167         /** Gets the modelview matrix that is used by the rasterizer. 
168          *  @warning If the Camera is a dynamic object then this method may return garbage.  Use GetCameraToWorld() instead.
169          */
170         const MT_Matrix4x4&             GetModelviewMatrix() const;
171
172         /** Gets the focal length. */
173         float                           GetLens() const;
174         /** Gets the near clip distance. */
175         float                           GetCameraNear() const;
176         /** Gets the far clip distance. */
177         float                           GetCameraFar() const;
178         /** Gets all camera data. */
179         RAS_CameraData*         GetCameraData();
180         
181         /**
182          * Tests if the given sphere is inside this camera's view frustum.
183          *
184          * @param center The center of the sphere, in world coordinates.
185          * @param radius The radius of the sphere.
186          * @return INSIDE, INTERSECT, or OUTSIDE depending on the sphere's relation to the frustum.
187          */
188         int SphereInsideFrustum(const MT_Point3& center, const MT_Scalar &radius);
189         /**
190          * Tests the given eight corners of a box with the view frustum.
191          *
192          * @param box a pointer to eight MT_Point3 representing the world coordinates of the corners of the box.
193          * @return INSIDE, INTERSECT, or OUTSIDE depending on the box's relation to the frustum.
194          */
195         int BoxInsideFrustum(const MT_Point3 *box);
196         /**
197          * Tests the given point against the view frustum.
198          * @return true if the given point is inside or on the view frustum; false if it is outside.
199          */
200         bool PointInsideFrustum(const MT_Point3& x);
201         
202         /**
203          * Gets this camera's culling status.
204          */
205         bool GetFrustumCulling() const;
206         
207         /**
208          * Sets this camera's viewport status.
209          */
210         void EnableViewport(bool viewport);
211         
212         /**
213          * Sets this camera's viewport.
214          */
215         void SetViewport(int left, int bottom, int right, int top);
216         
217         /**
218          * Gets this camera's viewport status.
219          */
220         bool GetViewport() const;
221         
222         /**
223          * Gets this camera's viewport left.
224          */
225         int GetViewportLeft() const;
226         
227         /**
228          * Gets this camera's viewport bottom.
229          */
230         int GetViewportBottom() const;
231         
232         /**
233          * Gets this camera's viewport right.
234          */
235         int GetViewportRight() const;
236         
237         /**
238          * Gets this camera's viewport top.
239          */
240         int GetViewportTop() const;
241
242
243         KX_PYMETHOD_DOC(KX_Camera, sphereInsideFrustum);
244         KX_PYMETHOD_DOC(KX_Camera, boxInsideFrustum);
245         KX_PYMETHOD_DOC(KX_Camera, pointInsideFrustum);
246         
247         KX_PYMETHOD_DOC(KX_Camera, getCameraToWorld);
248         KX_PYMETHOD_DOC(KX_Camera, getWorldToCamera);
249         KX_PYMETHOD_DOC(KX_Camera, getProjectionMatrix);
250         KX_PYMETHOD_DOC(KX_Camera, setProjectionMatrix);
251         
252         KX_PYMETHOD_DOC(KX_Camera, enableViewport);
253         KX_PYMETHOD_DOC(KX_Camera, setViewport);        
254         KX_PYMETHOD_DOC(KX_Camera, setOnTop);   
255
256         virtual PyObject* _getattr(const STR_String& attr); /* lens, near, far, projection_matrix */
257         virtual int       _setattr(const STR_String& attr, PyObject *pyvalue);
258
259 };
260
261 #endif //__KX_CAMERA
262