BGE: Adding a render.setFullScreen() and a render.getFullScreen() to allow fulscreeni...
[blender.git] / source / gameengine / BlenderRoutines / KX_BlenderCanvas.cpp
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 gameengine/BlenderRoutines/KX_BlenderCanvas.cpp
29  *  \ingroup blroutines
30  */
31
32
33 #include "KX_BlenderCanvas.h"
34 #include "DNA_screen_types.h"
35 #include "DNA_windowmanager_types.h"
36 #include <stdio.h>
37 #include <assert.h>
38
39
40 KX_BlenderCanvas::KX_BlenderCanvas(struct wmWindow *win, RAS_Rect &rect, struct ARegion *ar) :
41 m_win(win),
42 m_frame_rect(rect)
43 {
44         // initialize area so that it's available for game logic on frame 1 (ImageViewport)
45         m_area_rect = rect;
46         // area boundaries needed for mouse coordinates in Letterbox framing mode
47         m_area_left = ar->winrct.xmin;
48         m_area_top = ar->winrct.ymax;
49
50         glGetIntegerv(GL_VIEWPORT, (GLint *)m_viewport);
51 }
52
53 KX_BlenderCanvas::~KX_BlenderCanvas()
54 {
55 }
56
57 void KX_BlenderCanvas::Init()
58 {
59         glDepthFunc(GL_LEQUAL);
60 }
61
62
63 void KX_BlenderCanvas::SwapBuffers()
64 {
65         BL_SwapBuffers(m_win);
66 }
67
68 void KX_BlenderCanvas::ResizeWindow(int width, int height)
69 {
70         // Not implemented for the embedded player
71 }
72
73 void KX_BlenderCanvas::SetFullScreen(bool enable)
74 {
75         // Not implemented for the embedded player
76 }
77
78 bool KX_BlenderCanvas::GetFullScreen()
79 {
80         // Not implemented for the embedded player
81         return false;
82 }
83
84 void KX_BlenderCanvas::BeginFrame()
85 {
86         glEnable(GL_DEPTH_TEST);
87         glDepthFunc(GL_LEQUAL);
88
89 }
90
91
92 void KX_BlenderCanvas::EndFrame()
93 {
94                 // this is needed, else blender distorts a lot
95         glPopAttrib();
96         glPushAttrib(GL_ALL_ATTRIB_BITS);
97                 
98         glDisable(GL_FOG);
99 }
100
101
102
103 void KX_BlenderCanvas::ClearColor(float r,float g,float b,float a)
104 {
105         glClearColor(r,g,b,a);
106 }
107
108
109
110 void KX_BlenderCanvas::ClearBuffer(int type)
111 {
112         int ogltype = 0;
113
114         if (type & RAS_ICanvas::COLOR_BUFFER )
115                 ogltype |= GL_COLOR_BUFFER_BIT;
116
117         if (type & RAS_ICanvas::DEPTH_BUFFER )
118                 ogltype |= GL_DEPTH_BUFFER_BIT;
119         glClear(ogltype);
120 }
121
122 int KX_BlenderCanvas::GetWidth(
123 ) const {
124         return m_frame_rect.GetWidth();
125 }
126
127 int KX_BlenderCanvas::GetHeight(
128 ) const {
129         return m_frame_rect.GetHeight();
130 }
131
132 int KX_BlenderCanvas::GetMouseX(int x)
133 {
134         int left = GetWindowArea().GetLeft();
135         return x - (left - m_area_left);
136 }
137
138 int KX_BlenderCanvas::GetMouseY(int y)
139 {
140         int top = GetWindowArea().GetTop();
141         return y - (m_area_top - top);
142 }
143
144 float KX_BlenderCanvas::GetMouseNormalizedX(int x)
145 {
146         int can_x = GetMouseX(x);
147         return float(can_x)/this->GetWidth();
148 }
149
150 float KX_BlenderCanvas::GetMouseNormalizedY(int y)
151 {
152         int can_y = GetMouseY(y);
153         return float(can_y)/this->GetHeight();
154 }
155
156 RAS_Rect &
157 KX_BlenderCanvas::
158 GetWindowArea(
159 ) {
160         return m_area_rect;
161 }
162
163         void
164 KX_BlenderCanvas::
165 SetViewPort(
166         int x1, int y1,
167         int x2, int y2
168 ) {
169         /* x1 and y1 are the min pixel coordinate (e.g. 0)
170          * x2 and y2 are the max pixel coordinate
171          * the width,height is calculated including both pixels
172          * therefore: max - min + 1
173          */
174         int vp_width = (x2 - x1) + 1;
175         int vp_height = (y2 - y1) + 1;
176         int minx = m_frame_rect.GetLeft();
177         int miny = m_frame_rect.GetBottom();
178
179         m_area_rect.SetLeft(minx + x1);
180         m_area_rect.SetBottom(miny + y1);
181         m_area_rect.SetRight(minx + x2);
182         m_area_rect.SetTop(miny + y2);
183
184         m_viewport[0] = minx+x1;
185         m_viewport[1] = miny+y1;
186         m_viewport[2] = vp_width;
187         m_viewport[3] = vp_height;
188
189         glViewport(minx + x1, miny + y1, vp_width, vp_height);
190         glScissor(minx + x1, miny + y1, vp_width, vp_height);
191 }
192
193         void
194 KX_BlenderCanvas::
195 UpdateViewPort(
196         int x1, int y1,
197         int x2, int y2
198 ) {
199         m_viewport[0] = x1;
200         m_viewport[1] = y1;
201         m_viewport[2] = x2;
202         m_viewport[3] = y2;
203 }
204
205         const int*
206 KX_BlenderCanvas::
207 GetViewPort() {
208 #ifdef DEBUG
209         // If we're in a debug build, we might as well make sure our values don't differ
210         // from what the gpu thinks we have. This could lead to nasty, hard to find bugs.
211         int viewport[4];
212         glGetIntegerv(GL_VIEWPORT, viewport);
213         assert(viewport[0] == m_viewport[0]);
214         assert(viewport[1] == m_viewport[1]);
215         assert(viewport[2] == m_viewport[2]);
216         assert(viewport[3] == m_viewport[3]);
217 #endif
218
219         return m_viewport;
220 }
221
222 void KX_BlenderCanvas::SetMouseState(RAS_MouseState mousestate)
223 {
224         m_mousestate = mousestate;
225
226         switch (mousestate)
227         {
228         case MOUSE_INVISIBLE:
229                 {
230                         BL_HideMouse(m_win);
231                         break;
232                 }
233         case MOUSE_WAIT:
234                 {
235                         BL_WaitMouse(m_win);
236                         break;
237                 }
238         case MOUSE_NORMAL:
239                 {
240                         BL_NormalMouse(m_win);
241                         break;
242                 }
243         default:
244                 {
245                 }
246         }
247 }
248
249
250
251 //      (0,0) is top left, (width,height) is bottom right
252 void KX_BlenderCanvas::SetMousePosition(int x,int y)
253 {
254         int winX = m_frame_rect.GetLeft();
255         int winY = m_frame_rect.GetBottom();
256         int winH = m_frame_rect.GetHeight();
257         
258         BL_warp_pointer(m_win, winX + x, winY + (winH-y));
259 }
260
261
262
263 void KX_BlenderCanvas::MakeScreenShot(const char *filename)
264 {
265         ScrArea area_dummy= {0};
266         area_dummy.totrct.xmin = m_frame_rect.GetLeft();
267         area_dummy.totrct.xmax = m_frame_rect.GetRight();
268         area_dummy.totrct.ymin = m_frame_rect.GetBottom();
269         area_dummy.totrct.ymax = m_frame_rect.GetTop();
270
271         BL_MakeScreenShot(m_win->screen, &area_dummy, filename);
272 }