Patch to change license to GPL only, from GSR.
[blender.git] / source / gameengine / Rasterizer / RAS_FramingManager.h
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL 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.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): none yet.
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29 #ifndef RAS_FRAMINGMANAGER_H
30 #define RAS_FRAMINGMANAGER_H
31
32 class RAS_Rect;
33
34 /**
35  * @section RAS_FrameSettings
36  * This is a value type describing the framing used
37  * by a particular scene in the game engine.
38  * Each KX_Scene contains a RAS_FrameSetting describing
39  * how the frustum and viewport are to be modified 
40  * depending on the canvas size.
41  *
42  * e_frame_scale means that the viewport is set to the current
43  * canvas size. If the view frustum aspect ratio is different 
44  * to the canvas aspect this will lead to stretching.
45  *
46  * e_frame_extend means that the best fit viewport will be 
47  * computed based upon the design aspect ratio
48  * and the view frustum will be adjusted so that 
49  * more of the scene is visible.
50  *
51  * e_frame_bars means that the best fit viewport will be
52  * be computed based upon the design aspect ratio.
53  */
54
55 class RAS_FrameSettings 
56 {
57 public :
58
59         /**
60          * enum defining the policy to use 
61          * in each axis.
62          */
63         enum RAS_FrameType {
64                 e_frame_scale,
65                 e_frame_extend,
66                 e_frame_bars
67         };
68         
69         /**
70          * Contructor
71          */
72
73         RAS_FrameSettings(
74                 RAS_FrameType frame_type,
75                 float bar_r,
76                 float bar_g,
77                 float bar_b,
78                 unsigned int design_aspect_width,
79                 unsigned int design_aspect_height 
80         ):
81                 m_frame_type(frame_type),
82                 m_bar_r(bar_r),
83                 m_bar_g(bar_g),
84                 m_bar_b(bar_b),
85                 m_design_aspect_width(design_aspect_width),
86                 m_design_aspect_height(design_aspect_height)
87         {
88         };
89
90         RAS_FrameSettings(
91         ):
92                 m_frame_type(e_frame_scale),
93                 m_bar_r(0),
94                 m_bar_g(0),
95                 m_bar_b(0),
96                 m_design_aspect_width(1),
97                 m_design_aspect_height(1)
98         {
99         };
100
101         /**
102          * Accessors
103          */
104
105         const
106                 RAS_FrameType &         
107         FrameType(
108         ) const {
109                 return m_frame_type;
110         };
111         
112                 float
113         BarRed(
114         ) const {
115                 return m_bar_r;
116         };
117                 
118                 float
119         BarGreen(
120         ) const {
121                 return m_bar_g;
122         };
123
124                 float
125         BarBlue(
126         ) const {
127                 return m_bar_b;
128         };
129
130                 unsigned int
131         DesignAspectWidth(
132         ) const {
133                 return m_design_aspect_width;   
134         };
135
136                 unsigned int
137         DesignAspectHeight(
138         ) const {
139                 return m_design_aspect_height;  
140         };
141
142 private :
143         
144         /**
145          * private to force use of public constructor
146          */
147
148         RAS_FrameSettings(
149                 const RAS_FrameSettings &
150         );
151
152         RAS_FrameType m_frame_type;
153         float m_bar_r;
154         float m_bar_g;
155         float m_bar_b;
156         unsigned int m_design_aspect_width;
157         unsigned int m_design_aspect_height;
158 }; 
159
160 struct RAS_FrameFrustum
161 {
162         float camnear,camfar;
163         float x1,y1;
164         float x2,y2;
165 };      
166
167
168 /**
169  * @section RAS_FramingManager
170  * This class helps to compute a view frustum
171  * and a viewport rectangle given the 
172  * above settings and a description of the 
173  * current canvas dimensions.
174  *
175  * You do not have to instantiate this class
176  * directly, it only contains static helper functions
177  */
178
179 class RAS_FramingManager
180 {
181 public :
182
183         /**
184          * Compute a viewport given
185          * a RAS_FrameSettings and a description of the
186          * canvas.
187          */
188
189         static
190                 void
191         ComputeViewport(
192                 const RAS_FrameSettings &settings,
193                 const RAS_Rect &availableViewport,
194                 RAS_Rect &viewport
195         );
196
197         
198         /**
199          * compute a frustrum given a valid viewport,
200          * RAS_FrameSettings, canvas description 
201          * and camera description
202          */
203
204         static
205                 void
206         ComputeFrustum(
207                 const RAS_FrameSettings &settings,
208                 const RAS_Rect &availableViewport,
209                 const RAS_Rect &viewport,
210                 const float lens,
211                 const float camnear,
212                 const float camfar,
213                 RAS_FrameFrustum &frustum
214         );
215
216
217 private :
218
219         static
220                 void
221         ComputeDefaultFrustum(
222                 const float camnear,
223                 const float camfar,
224                 const float lens,
225                 const float design_aspect_ratio,
226                 RAS_FrameFrustum & frustum
227         );      
228
229         static
230                 void
231         ComputeBestFitViewRect(
232                 const RAS_Rect &availableViewport,
233                 const float design_aspect_ratio,
234                 RAS_Rect &viewport
235         );
236
237
238
239         /**
240          * Private constructor - this class is not meant
241          * for instanciation.
242          */
243
244         RAS_FramingManager(
245         );
246
247         RAS_FramingManager(
248                 const RAS_FramingManager &
249         );
250 };              
251                 
252 #endif
253