Did all of the .h's in source
[blender.git] / source / gameengine / Rasterizer / RAS_FramingManager.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  */
32 #ifndef RAS_FRAMINGMANAGER_H
33 #define RAS_FRAMINGMANAGER_H
34
35 #ifdef HAVE_CONFIG_H
36 #include <config.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         /**
67          * enum defining the policy to use 
68          * in each axis.
69          */
70         enum RAS_FrameType {
71                 e_frame_scale,
72                 e_frame_extend,
73                 e_frame_bars
74         };
75         
76         /**
77          * Contructor
78          */
79
80         RAS_FrameSettings(
81                 RAS_FrameType frame_type,
82                 float bar_r,
83                 float bar_g,
84                 float bar_b,
85                 unsigned int design_aspect_width,
86                 unsigned int design_aspect_height 
87         ):
88                 m_frame_type(frame_type),
89                 m_bar_r(bar_r),
90                 m_bar_g(bar_g),
91                 m_bar_b(bar_b),
92                 m_design_aspect_width(design_aspect_width),
93                 m_design_aspect_height(design_aspect_height)
94         {
95         };
96
97         RAS_FrameSettings(
98         ):
99                 m_frame_type(e_frame_scale),
100                 m_bar_r(0),
101                 m_bar_g(0),
102                 m_bar_b(0),
103                 m_design_aspect_width(1),
104                 m_design_aspect_height(1)
105         {
106         };
107
108         /**
109          * Accessors
110          */
111
112         const
113                 RAS_FrameType &         
114         FrameType(
115         ) const {
116                 return m_frame_type;
117         };
118         
119                 float
120         BarRed(
121         ) const {
122                 return m_bar_r;
123         };
124                 
125                 float
126         BarGreen(
127         ) const {
128                 return m_bar_g;
129         };
130
131                 float
132         BarBlue(
133         ) const {
134                 return m_bar_b;
135         };
136
137                 unsigned int
138         DesignAspectWidth(
139         ) const {
140                 return m_design_aspect_width;   
141         };
142
143                 unsigned int
144         DesignAspectHeight(
145         ) const {
146                 return m_design_aspect_height;  
147         };
148
149 private :
150         
151         /**
152          * private to force use of public constructor
153          */
154
155         RAS_FrameSettings(
156                 const RAS_FrameSettings &
157         );
158
159         RAS_FrameType m_frame_type;
160         float m_bar_r;
161         float m_bar_g;
162         float m_bar_b;
163         unsigned int m_design_aspect_width;
164         unsigned int m_design_aspect_height;
165 }; 
166
167 struct RAS_FrameFrustum
168 {
169         float camnear,camfar;
170         float x1,y1;
171         float x2,y2;
172 };      
173
174
175 /**
176  * @section RAS_FramingManager
177  * This class helps to compute a view frustum
178  * and a viewport rectangle given the 
179  * above settings and a description of the 
180  * current canvas dimensions.
181  *
182  * You do not have to instantiate this class
183  * directly, it only contains static helper functions
184  */
185
186 class RAS_FramingManager
187 {
188 public :
189
190         /**
191          * Compute a viewport given
192          * a RAS_FrameSettings and a description of the
193          * canvas.
194          */
195
196         static
197                 void
198         ComputeViewport(
199                 const RAS_FrameSettings &settings,
200                 const RAS_Rect &availableViewport,
201                 RAS_Rect &viewport
202         );
203
204         
205         /**
206          * compute a frustrum given a valid viewport,
207          * RAS_FrameSettings, canvas description 
208          * and camera description
209          */
210
211         static
212                 void
213         ComputeFrustum(
214                 const RAS_FrameSettings &settings,
215                 const RAS_Rect &availableViewport,
216                 const RAS_Rect &viewport,
217                 const float lens,
218                 const float camnear,
219                 const float camfar,
220                 RAS_FrameFrustum &frustum
221         );
222
223
224 private :
225
226         static
227                 void
228         ComputeDefaultFrustum(
229                 const float camnear,
230                 const float camfar,
231                 const float lens,
232                 const float design_aspect_ratio,
233                 RAS_FrameFrustum & frustum
234         );      
235
236         static
237                 void
238         ComputeBestFitViewRect(
239                 const RAS_Rect &availableViewport,
240                 const float design_aspect_ratio,
241                 RAS_Rect &viewport
242         );
243
244
245
246         /**
247          * Private constructor - this class is not meant
248          * for instanciation.
249          */
250
251         RAS_FramingManager(
252         );
253
254         RAS_FramingManager(
255                 const RAS_FramingManager &
256         );
257 };              
258                 
259 #endif
260