diff options
Diffstat (limited to 'apps/plugins/sdl/src/video/photon/SDL_ph_gl.c')
-rw-r--r-- | apps/plugins/sdl/src/video/photon/SDL_ph_gl.c | 406 |
1 files changed, 0 insertions, 406 deletions
diff --git a/apps/plugins/sdl/src/video/photon/SDL_ph_gl.c b/apps/plugins/sdl/src/video/photon/SDL_ph_gl.c deleted file mode 100644 index 3121777639..0000000000 --- a/apps/plugins/sdl/src/video/photon/SDL_ph_gl.c +++ /dev/null | |||
@@ -1,406 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | #include <dlfcn.h> | ||
25 | #include "SDL.h" | ||
26 | #include "SDL_ph_gl.h" | ||
27 | |||
28 | #if SDL_VIDEO_OPENGL | ||
29 | |||
30 | #if (_NTO_VERSION >= 630) | ||
31 | /* PhotonGL functions */ | ||
32 | GLPH_DECLARE_FUNCS; | ||
33 | #endif /* 6.3.0 */ | ||
34 | |||
35 | #if (_NTO_VERSION < 630) | ||
36 | void ph_GL_SwapBuffers(_THIS) | ||
37 | { | ||
38 | PgSetRegion(PtWidgetRid(window)); | ||
39 | PdOpenGLContextSwapBuffers(oglctx); | ||
40 | } | ||
41 | #else | ||
42 | void ph_GL_SwapBuffers(_THIS) | ||
43 | { | ||
44 | qnxgl_swap_buffers(oglbuffers); | ||
45 | } | ||
46 | #endif /* 6.3.0 */ | ||
47 | |||
48 | int ph_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value) | ||
49 | { | ||
50 | switch (attrib) | ||
51 | { | ||
52 | case SDL_GL_DOUBLEBUFFER: | ||
53 | *value=this->gl_config.double_buffer; | ||
54 | break; | ||
55 | case SDL_GL_STENCIL_SIZE: | ||
56 | *value=this->gl_config.stencil_size; | ||
57 | break; | ||
58 | case SDL_GL_DEPTH_SIZE: | ||
59 | *value=this->gl_config.depth_size; | ||
60 | break; | ||
61 | #if (_NTO_VERSION >= 630) | ||
62 | case SDL_GL_RED_SIZE: | ||
63 | *value=this->gl_config.red_size; | ||
64 | break; | ||
65 | case SDL_GL_GREEN_SIZE: | ||
66 | *value=this->gl_config.green_size; | ||
67 | break; | ||
68 | case SDL_GL_BLUE_SIZE: | ||
69 | *value=this->gl_config.blue_size; | ||
70 | break; | ||
71 | case SDL_GL_ALPHA_SIZE: | ||
72 | *value=this->gl_config.alpha_size; | ||
73 | break; | ||
74 | case SDL_GL_ACCUM_RED_SIZE: | ||
75 | *value=this->gl_config.accum_red_size; | ||
76 | break; | ||
77 | case SDL_GL_ACCUM_GREEN_SIZE: | ||
78 | *value=this->gl_config.accum_green_size; | ||
79 | break; | ||
80 | case SDL_GL_ACCUM_BLUE_SIZE: | ||
81 | *value=this->gl_config.accum_blue_size; | ||
82 | break; | ||
83 | case SDL_GL_ACCUM_ALPHA_SIZE: | ||
84 | *value=this->gl_config.accum_alpha_size; | ||
85 | break; | ||
86 | case SDL_GL_STEREO: | ||
87 | *value=this->gl_config.stereo; | ||
88 | break; | ||
89 | #endif /* 6.3.0 */ | ||
90 | default: | ||
91 | *value=0; | ||
92 | return(-1); | ||
93 | } | ||
94 | return 0; | ||
95 | } | ||
96 | |||
97 | #if (_NTO_VERSION < 630) | ||
98 | int ph_GL_LoadLibrary(_THIS, const char* path) | ||
99 | { | ||
100 | /* if code compiled with SDL_VIDEO_OPENGL, that mean that library already linked */ | ||
101 | this->gl_config.driver_loaded = 1; | ||
102 | |||
103 | return 0; | ||
104 | } | ||
105 | #else | ||
106 | int ph_GL_LoadLibrary(_THIS, const char* path) | ||
107 | { | ||
108 | void* handle; | ||
109 | int dlopen_flags=RTLD_WORLD | RTLD_GROUP; | ||
110 | |||
111 | if (this->gl_config.dll_handle!=NULL) | ||
112 | { | ||
113 | return 0; | ||
114 | } | ||
115 | |||
116 | handle = dlopen(path, dlopen_flags); | ||
117 | |||
118 | if (handle==NULL) | ||
119 | { | ||
120 | SDL_SetError("ph_GL_LoadLibrary(): Could not load OpenGL library"); | ||
121 | return -1; | ||
122 | } | ||
123 | |||
124 | this->gl_config.dll_handle = handle; | ||
125 | this->gl_config.driver_loaded = 1; | ||
126 | |||
127 | SDL_strlcpy(this->gl_config.driver_path, path, SDL_arraysize(this->gl_config.driver_path)); | ||
128 | |||
129 | return 0; | ||
130 | } | ||
131 | #endif /* 6.3.0 */ | ||
132 | |||
133 | #if (_NTO_VERSION < 630) | ||
134 | void* ph_GL_GetProcAddress(_THIS, const char* proc) | ||
135 | { | ||
136 | return NULL; | ||
137 | } | ||
138 | #else | ||
139 | void* ph_GL_GetProcAddress(_THIS, const char* proc) | ||
140 | { | ||
141 | void* function; | ||
142 | |||
143 | if (this->gl_config.dll_handle==NULL) | ||
144 | { | ||
145 | ph_GL_LoadLibrary(this, DEFAULT_OPENGL); | ||
146 | if (this->gl_config.dll_handle==NULL) | ||
147 | { | ||
148 | return NULL; | ||
149 | } | ||
150 | } | ||
151 | |||
152 | function=qnxgl_get_func(proc, oglctx, 0); | ||
153 | if (function==NULL) | ||
154 | { | ||
155 | function=dlsym(this->gl_config.dll_handle, proc); | ||
156 | } | ||
157 | |||
158 | return function; | ||
159 | } | ||
160 | #endif /* 6.3.0 */ | ||
161 | |||
162 | #if (_NTO_VERSION < 630) | ||
163 | int ph_GL_MakeCurrent(_THIS) | ||
164 | { | ||
165 | PgSetRegion(PtWidgetRid(window)); | ||
166 | |||
167 | if (oglctx!=NULL) | ||
168 | { | ||
169 | PhDCSetCurrent(oglctx); | ||
170 | } | ||
171 | |||
172 | return 0; | ||
173 | } | ||
174 | #else | ||
175 | int ph_GL_MakeCurrent(_THIS) | ||
176 | { | ||
177 | PgSetRegion(PtWidgetRid(window)); | ||
178 | |||
179 | if (oglctx!=NULL) | ||
180 | { | ||
181 | if (qnxgl_set_current(oglctx) == -1) | ||
182 | { | ||
183 | return -1; | ||
184 | } | ||
185 | } | ||
186 | |||
187 | return 0; | ||
188 | } | ||
189 | #endif /* 6.3.0 */ | ||
190 | |||
191 | #if (_NTO_VERSION < 630) | ||
192 | |||
193 | /* This code is actual for the Photon3D Runtime which was available prior to 6.3 only */ | ||
194 | |||
195 | int ph_SetupOpenGLContext(_THIS, int width, int height, int bpp, Uint32 flags) | ||
196 | { | ||
197 | PhDim_t dim; | ||
198 | uint64_t OGLAttrib[PH_OGL_MAX_ATTRIBS]; | ||
199 | int exposepost=0; | ||
200 | int OGLargc; | ||
201 | |||
202 | dim.w=width; | ||
203 | dim.h=height; | ||
204 | |||
205 | if ((oglctx!=NULL) && (oglflags==flags) && (oglbpp==bpp)) | ||
206 | { | ||
207 | PdOpenGLContextResize(oglctx, &dim); | ||
208 | PhDCSetCurrent(oglctx); | ||
209 | return 0; | ||
210 | } | ||
211 | else | ||
212 | { | ||
213 | if (oglctx!=NULL) | ||
214 | { | ||
215 | PhDCSetCurrent(NULL); | ||
216 | PhDCRelease(oglctx); | ||
217 | oglctx=NULL; | ||
218 | exposepost=1; | ||
219 | } | ||
220 | } | ||
221 | |||
222 | OGLargc=0; | ||
223 | if (this->gl_config.depth_size) | ||
224 | { | ||
225 | OGLAttrib[OGLargc++]=PHOGL_ATTRIB_DEPTH_BITS; | ||
226 | OGLAttrib[OGLargc++]=this->gl_config.depth_size; | ||
227 | } | ||
228 | if (this->gl_config.stencil_size) | ||
229 | { | ||
230 | OGLAttrib[OGLargc++]=PHOGL_ATTRIB_STENCIL_BITS; | ||
231 | OGLAttrib[OGLargc++]=this->gl_config.stencil_size; | ||
232 | } | ||
233 | OGLAttrib[OGLargc++]=PHOGL_ATTRIB_FORCE_SW; | ||
234 | if (flags & SDL_FULLSCREEN) | ||
235 | { | ||
236 | OGLAttrib[OGLargc++]=PHOGL_ATTRIB_FULLSCREEN; | ||
237 | OGLAttrib[OGLargc++]=PHOGL_ATTRIB_DIRECT; | ||
238 | OGLAttrib[OGLargc++]=PHOGL_ATTRIB_FULLSCREEN_BEST; | ||
239 | OGLAttrib[OGLargc++]=PHOGL_ATTRIB_FULLSCREEN_CENTER; | ||
240 | } | ||
241 | OGLAttrib[OGLargc++]=PHOGL_ATTRIB_NONE; | ||
242 | |||
243 | if (this->gl_config.double_buffer) | ||
244 | { | ||
245 | oglctx=PdCreateOpenGLContext(2, &dim, 0, OGLAttrib); | ||
246 | } | ||
247 | else | ||
248 | { | ||
249 | oglctx=PdCreateOpenGLContext(1, &dim, 0, OGLAttrib); | ||
250 | } | ||
251 | |||
252 | if (oglctx==NULL) | ||
253 | { | ||
254 | SDL_SetError("ph_SetupOpenGLContext(): cannot create OpenGL context !\n"); | ||
255 | return -1; | ||
256 | } | ||
257 | |||
258 | PhDCSetCurrent(oglctx); | ||
259 | |||
260 | PtFlush(); | ||
261 | |||
262 | oglflags=flags; | ||
263 | oglbpp=bpp; | ||
264 | |||
265 | if (exposepost!=0) | ||
266 | { | ||
267 | /* OpenGL context has been recreated, so report about this fact */ | ||
268 | SDL_PrivateExpose(); | ||
269 | } | ||
270 | |||
271 | return 0; | ||
272 | } | ||
273 | |||
274 | #else /* _NTO_VERSION */ | ||
275 | |||
276 | /* This code is actual for the built-in PhGL support, which became available since 6.3 */ | ||
277 | |||
278 | int ph_SetupOpenGLContext(_THIS, int width, int height, int bpp, Uint32 flags) | ||
279 | { | ||
280 | qnxgl_buf_attrib_t qnxgl_attribs[PH_OGL_MAX_ATTRIBS]; | ||
281 | qnxgl_buf_attrib_t* qnxgl_attribs_slide; | ||
282 | int num_interfaces = 0; | ||
283 | int num_buffers = 0; | ||
284 | |||
285 | /* Initialize the OpenGL subsystem */ | ||
286 | |||
287 | num_interfaces = qnxgl_init(NULL, NULL, 0); | ||
288 | |||
289 | if (num_interfaces < 0) | ||
290 | { | ||
291 | SDL_SetError("ph_SetupOpenGLContext(): cannot initialize OpenGL subsystem !\n"); | ||
292 | return -1; | ||
293 | } | ||
294 | if (num_interfaces == 0) | ||
295 | { | ||
296 | SDL_SetError("ph_SetupOpenGLContext(): there are no available OpenGL renderers was found !\n"); | ||
297 | return -1; | ||
298 | } | ||
299 | |||
300 | /* Driver is linked */ | ||
301 | this->gl_config.driver_loaded=1; | ||
302 | |||
303 | /* Initialize the OpenGL context attributes */ | ||
304 | qnxgl_attribs_slide=qnxgl_attribs; | ||
305 | |||
306 | /* Depth size */ | ||
307 | if (this->gl_config.depth_size) | ||
308 | { | ||
309 | fprintf(stderr, "setted depth size %d\n", this->gl_config.depth_size); | ||
310 | qnxgl_attribs_slide = qnxgl_attrib_set_depth(qnxgl_attribs_slide, this->gl_config.depth_size); | ||
311 | } | ||
312 | |||
313 | /* Stencil size */ | ||
314 | if (this->gl_config.stencil_size) | ||
315 | { | ||
316 | qnxgl_attribs_slide = qnxgl_attrib_set_stencil(qnxgl_attribs_slide, this->gl_config.stencil_size); | ||
317 | } | ||
318 | |||
319 | /* The sum of the accum bits of each channel */ | ||
320 | if ((this->gl_config.accum_red_size != 0) && (this->gl_config.accum_blue_size != 0) && | ||
321 | (this->gl_config.accum_green_size != 0)) | ||
322 | { | ||
323 | qnxgl_attribs_slide = qnxgl_attrib_set_accum(qnxgl_attribs_slide, | ||
324 | this->gl_config.accum_red_size + this->gl_config.accum_blue_size + | ||
325 | this->gl_config.accum_green_size + this->gl_config.accum_alpha_size); | ||
326 | } | ||
327 | |||
328 | /* Stereo mode */ | ||
329 | if (this->gl_config.stereo) | ||
330 | { | ||
331 | qnxgl_attribs_slide = qnxgl_attrib_set_stereo(qnxgl_attribs_slide); | ||
332 | } | ||
333 | |||
334 | /* Fullscreen mode */ | ||
335 | if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) | ||
336 | { | ||
337 | qnxgl_attribs_slide = qnxgl_attrib_set_hint_fullscreen(qnxgl_attribs_slide); | ||
338 | } | ||
339 | |||
340 | /* Double buffering mode */ | ||
341 | if (this->gl_config.double_buffer) | ||
342 | { | ||
343 | num_buffers=2; | ||
344 | } | ||
345 | else | ||
346 | { | ||
347 | num_buffers=1; | ||
348 | } | ||
349 | |||
350 | /* Loading the function pointers so we can use the extensions */ | ||
351 | GLPH_LOAD_FUNCS_GC(oglctx); | ||
352 | |||
353 | /* Set the buffers region to be that of our window's region */ | ||
354 | qnxgl_attribs_slide = glph_attrib_set_region(qnxgl_attribs_slide, PtWidgetRid(window)); | ||
355 | |||
356 | /* End of the attributes array */ | ||
357 | qnxgl_attribs_slide = qnxgl_attrib_set_end(qnxgl_attribs_slide); | ||
358 | |||
359 | /* Create the buffers with the specified color model */ | ||
360 | fprintf(stderr, "ARGB: %d, %d, %d, %d\n", this->gl_config.alpha_size, this->gl_config.red_size, this->gl_config.green_size, this->gl_config.blue_size); | ||
361 | oglbuffers = qnxgl_buffers_create( | ||
362 | QNXGL_FORMAT_BEST_RGB, | ||
363 | /* __QNXGL_BUILD_FORMAT(0, __QNXGL_COLOR_MODEL_RGB, this->gl_config.alpha_size, | ||
364 | this->gl_config.red_size, this->gl_config.green_size, this->gl_config.blue_size), */ | ||
365 | num_buffers, width, height, qnxgl_attribs, -1); | ||
366 | |||
367 | |||
368 | if (oglbuffers == NULL) | ||
369 | { | ||
370 | SDL_SetError("ph_SetupOpenGLContext(): failed to create OpenGL buffers !\n"); | ||
371 | qnxgl_finish(); | ||
372 | return -1; | ||
373 | } | ||
374 | |||
375 | /* Create a QNXGL context for the previously created buffer */ | ||
376 | oglctx = qnxgl_context_create(oglbuffers, NULL); | ||
377 | |||
378 | if (oglctx == NULL) | ||
379 | { | ||
380 | SDL_SetError("ph_SetupOpenGLContext(): failed to create OpenGL context !\n"); | ||
381 | qnxgl_buffers_destroy(oglbuffers); | ||
382 | qnxgl_finish(); | ||
383 | return -1; | ||
384 | } | ||
385 | |||
386 | /* Attempt to make the context current so we can use OpenGL commands */ | ||
387 | if (qnxgl_set_current(oglctx) == -1) | ||
388 | { | ||
389 | SDL_SetError("ph_SetupOpenGLContext(): failed to make the OpenGL context current !\n"); | ||
390 | qnxgl_context_destroy(oglctx); | ||
391 | qnxgl_buffers_destroy(oglbuffers); | ||
392 | qnxgl_finish(); | ||
393 | return -1; | ||
394 | } | ||
395 | |||
396 | PtFlush(); | ||
397 | |||
398 | oglflags=flags; | ||
399 | oglbpp=bpp; | ||
400 | |||
401 | return 0; | ||
402 | } | ||
403 | |||
404 | #endif /* _NTO_VERSION */ | ||
405 | |||
406 | #endif /* SDL_VIDEO_OPENGL */ | ||