optionally use guarded alloc for tiles compositor, also replace allocation functions...
[blender.git] / source / gameengine / Rasterizer / RAS_FramingManager.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file RAS_FramingManager.h
29  *  \ingroup bgerast
30  */
31
32 #ifndef __RAS_FRAMINGMANAGER_H__
33 #define __RAS_FRAMINGMANAGER_H__
34
35 #ifdef WITH_CXX_GUARDEDALLOC
36 #include "MEM_guardedalloc.h"
37 #endif
38
39 class RAS_Rect;
40
41 /**
42  * \section RAS_FrameSettings
43  * This is a value type describing the framing used
44  * by a particular scene in the game engine.
45  * Each KX_Scene contains a RAS_FrameSetting describing
46  * how the frustum and viewport are to be modified 
47  * depending on the canvas size.
48  *
49  * e_frame_scale means that the viewport is set to the current
50  * canvas size. If the view frustum aspect ratio is different 
51  * to the canvas aspect this will lead to stretching.
52  *
53  * e_frame_extend means that the best fit viewport will be 
54  * computed based upon the design aspect ratio
55  * and the view frustum will be adjusted so that 
56  * more of the scene is visible.
57  *
58  * e_frame_bars means that the best fit viewport will be
59  * be computed based upon the design aspect ratio.
60  */
61
62 class RAS_FrameSettings 
63 {
64 public :
65         /**
66          * enum defining the policy to use 
67          * in each axis.
68          */
69         enum RAS_FrameType {
70                 e_frame_scale,
71                 e_frame_extend,
72                 e_frame_bars
73         };
74         
75         /**
76          * Contructor
77          */
78
79         RAS_FrameSettings(
80                 RAS_FrameType frame_type,
81                 float bar_r,
82                 float bar_g,
83                 float bar_b,
84                 unsigned int design_aspect_width,
85                 unsigned int design_aspect_height 
86         ):
87                 m_frame_type(frame_type),
88                 m_bar_r(bar_r),
89                 m_bar_g(bar_g),
90                 m_bar_b(bar_b),
91                 m_design_aspect_width(design_aspect_width),
92                 m_design_aspect_height(design_aspect_height)
93         {
94         };
95
96         RAS_FrameSettings(
97         ):
98                 m_frame_type(e_frame_scale),
99                 m_bar_r(0),
100                 m_bar_g(0),
101                 m_bar_b(0),
102                 m_design_aspect_width(1),
103                 m_design_aspect_height(1)
104         {
105         };
106
107         /**
108          * Accessors
109          */
110
111         const
112                 RAS_FrameType &         
113         FrameType(
114         ) const {
115                 return m_frame_type;
116         };
117
118                 void
119         SetFrameType(
120                 RAS_FrameType type
121         ) {
122                 m_frame_type = type;
123         };
124         
125                 float
126         BarRed(
127         ) const {
128                 return m_bar_r;
129         };
130                 
131                 float
132         BarGreen(
133         ) const {
134                 return m_bar_g;
135         };
136
137                 float
138         BarBlue(
139         ) const {
140                 return m_bar_b;
141         };
142
143                 unsigned int
144         DesignAspectWidth(
145         ) const {
146                 return m_design_aspect_width;   
147         };
148
149                 unsigned int
150         DesignAspectHeight(
151         ) const {
152                 return m_design_aspect_height;  
153         };
154
155 private :
156
157         RAS_FrameType m_frame_type;
158         float m_bar_r;
159         float m_bar_g;
160         float m_bar_b;
161         unsigned int m_design_aspect_width;
162         unsigned int m_design_aspect_height;
163
164
165 #ifdef WITH_CXX_GUARDEDALLOC
166         MEM_CXX_CLASS_ALLOC_FUNCS("GE:RAS_FrameSettings")
167 #endif
168 }; 
169
170 struct RAS_FrameFrustum
171 {
172         float camnear,camfar;
173         float x1,y1;
174         float x2,y2;
175 };
176
177 /* must match R_CULLING_... from DNA_scene_types.h */
178 enum RAS_CullingMode
179 {
180         RAS_CULLING_DBVT = 0,
181         RAS_CULLING_NORMAL,
182         RAS_CULLING_NONE
183 };
184
185 /* Should match CAMERA_SENSOR_FIT... from DNA_camera_types.h */
186 enum RAS_SensorFit
187 {
188         RAS_SENSORFIT_AUTO = 0,
189         RAS_SENSORFIT_HOR,
190         RAS_SENSORFIT_VERT
191 };
192
193 /**
194  * \section RAS_FramingManager
195  * This class helps to compute a view frustum
196  * and a viewport rectangle given the 
197  * above settings and a description of the 
198  * current canvas dimensions.
199  *
200  * You do not have to instantiate this class
201  * directly, it only contains static helper functions
202  */
203
204 class RAS_FramingManager
205 {
206 public :
207
208         /**
209          * Compute a viewport given
210          * a RAS_FrameSettings and a description of the
211          * canvas.
212          */
213
214         static
215                 void
216         ComputeViewport(
217                 const RAS_FrameSettings &settings,
218                 const RAS_Rect &availableViewport,
219                 RAS_Rect &viewport
220         );
221
222         
223         /**
224          * compute a frustrum given a valid viewport,
225          * RAS_FrameSettings, canvas description 
226          * and camera description
227          */
228
229         static
230                 void
231         ComputeOrtho(
232                 const RAS_FrameSettings &settings,
233                 const RAS_Rect &availableViewport,
234                 const RAS_Rect &viewport,
235                 const float scale,
236                 const float camnear,
237                 const float camfar,
238                 const short sensor_fit,
239                 RAS_FrameFrustum &frustum
240         );
241
242         static
243                 void
244         ComputeFrustum(
245                 const RAS_FrameSettings &settings,
246                 const RAS_Rect &availableViewport,
247                 const RAS_Rect &viewport,
248                 const float lens,
249                 const float sensor_x, const float sensor_y, const short sensor_fit,
250                 const float camnear,
251                 const float camfar,
252                 RAS_FrameFrustum &frustum
253         );
254
255         static
256                 void
257         ComputeDefaultFrustum(
258                 const float camnear,
259                 const float camfar,
260                 const float lens,
261                 const float sensor_x, const float sensor_y,
262                 const short sensor_fit,
263                 const float design_aspect_ratio,
264                 RAS_FrameFrustum & frustum
265         );      
266
267         static
268                 void
269         ComputeDefaultOrtho(
270                 const float camnear,
271                 const float camfar,
272                 const float scale,
273                 const float design_aspect_ratio,
274                 const short sensor_fit,
275                 RAS_FrameFrustum & frustum
276         );
277
278 private :
279
280         static
281                 void
282         ComputeBestFitViewRect(
283                 const RAS_Rect &availableViewport,
284                 const float design_aspect_ratio,
285                 RAS_Rect &viewport
286         );
287
288
289
290         /**
291          * Private constructor - this class is not meant
292          * for instanciation.
293          */
294
295         RAS_FramingManager(
296         );
297
298         RAS_FramingManager(
299                 const RAS_FramingManager &
300         );
301
302
303 #ifdef WITH_CXX_GUARDEDALLOC
304         MEM_CXX_CLASS_ALLOC_FUNCS("GE:RAS_FramingManager")
305 #endif
306 };
307
308 #endif