1 // We were using PBUFFER for alpha compositing on Linux before, but it does not seem to work, nor be required anymore.
4 namespace gfx::drivers;
7 #if defined(__unix__) || defined(__APPLE__)
9 #if !defined(__MINGW32__)
10 #define GL_GLEXT_PROTOTYPES
13 #define pointer _pointer
17 //#include <GL/miniglx.h>
21 #if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
23 #define property _property
27 #define Window X11Window
28 #define Cursor X11Cursor
30 #define Display X11Display
32 #define KeyCode X11KeyCode
33 #define Picture X11Picture
37 #include <X11/Xutil.h>
39 #include <X11/extensions/XShm.h>
42 #include <X11/extensions/Xrender.h>
43 #include <X11/extensions/shape.h>
63 #if defined(__APPLE__)
64 #include <OpenGl/gl.h>
67 #if defined(__WIN32__) || defined(__unix__) || defined(__APPLE__)
69 #if defined(__WIN32__)
70 #define WIN32_LEAN_AND_MEAN
72 #define _WIN32_WINNT 0x0502
78 #if defined(__ANDROID__) || defined(__ODROID__)
81 #define property _property
84 #define Window X11Window
85 #define Cursor X11Cursor
87 #define Display X11Display
89 #define KeyCode X11KeyCode
90 #define Picture X11Picture
109 #elif defined(__EMSCRIPTEN__)
111 #define property _property
116 //#include <GLES/gl.h>
117 //#include <EGL/egl.h>
119 //#include <GLES2/gl.h>
120 //#include <EGL/egl.h>
122 //#include <GLES2/gl2.h>
124 #include <emscripten/emscripten.h>
132 #include <GL/glext.h>
136 #if defined(__ODROID__) && !defined(_GLES)
140 #if defined(__EMSCRIPTEN__)
151 #if defined(__unix__) || defined(__APPLE__)
153 #if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
159 static double nearPlane = 1;
161 public double glesGetNearPlane()
166 public void glesSetNearPlane(double value)
171 #define glLoadMatrix glLoadMatrixd
172 #define glMultMatrix glMultMatrixd
173 #define glGetMatrix glGetDoublev
174 #define glTranslate glTranslated
175 #define glScale glScaled
178 #define glVertex3v glVertex3dv
179 #define glNormal3v glNormal3dv
183 //#ifdef VERTEX_FORMAT_DOUBLE
185 #define glLoadMatrix glLoadMatrixd
186 #define glMultMatrix glMultMatrixd
187 #define glGetMatrix glGetDoublev
188 #define glVertex3v glVertex3dv
189 #define glNormal3v glNormal3dv
190 #define glTranslate glTranslated
191 #define glScale glScaled
192 //#define GL_VERTEX_FORMAT GL_DOUBLE
196 #define glLoadMatrix glLoadMatrixf
197 #define glMultMatrix glMultMatrixf
198 #define glGetMatrix glGetFloatv
199 #define glVertex3v glVertex3fv
200 #define glNormal3v glNormal3fv
201 #define glTranslate glTranslatef
202 #define glScale glScalef
203 //#define GL_VERTEX_FORMAT GL_FLOAT
208 #define GL_ARRAY_BUFFER_ARB 0x8892
209 #define GL_ELEMENT_ARRAY_BUFFER_ARB 0x8893
210 #define GL_STATIC_DRAW_ARB 0x88E4
211 #define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8
212 #define GL_SEPARATE_SPECULAR_COLOR 0x81FA
214 #define GL_MULTISAMPLE_ARB 0x809D
216 #if defined(__WIN32__)
218 #define WGL_SAMPLE_BUFFERS_ARB 0x2041
219 #define WGL_SAMPLES_ARB 0x2042
221 #define WGL_WGLEXT_VERSION 1
222 #define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001
223 #define WGL_BACK_COLOR_BUFFER_BIT_ARB 0x00000002
224 #define WGL_DEPTH_BUFFER_BIT_ARB 0x00000004
225 #define WGL_STENCIL_BUFFER_BIT_ARB 0x00000008
226 #define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000
227 #define WGL_DRAW_TO_WINDOW_ARB 0x2001
228 #define WGL_DRAW_TO_BITMAP_ARB 0x2002
229 #define WGL_ACCELERATION_ARB 0x2003
230 #define WGL_NEED_PALETTE_ARB 0x2004
231 #define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005
232 #define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006
233 #define WGL_SWAP_METHOD_ARB 0x2007
234 #define WGL_NUMBER_OVERLAYS_ARB 0x2008
235 #define WGL_NUMBER_UNDERLAYS_ARB 0x2009
236 #define WGL_TRANSPARENT_ARB 0x200A
237 #define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037
238 #define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038
239 #define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039
240 #define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A
241 #define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B
242 #define WGL_SHARE_DEPTH_ARB 0x200C
243 #define WGL_SHARE_STENCIL_ARB 0x200D
244 #define WGL_SHARE_ACCUM_ARB 0x200E
245 #define WGL_SUPPORT_GDI_ARB 0x200F
246 #define WGL_SUPPORT_OPENGL_ARB 0x2010
247 #define WGL_DOUBLE_BUFFER_ARB 0x2011
248 #define WGL_STEREO_ARB 0x2012
249 #define WGL_PIXEL_TYPE_ARB 0x2013
250 #define WGL_COLOR_BITS_ARB 0x2014
251 #define WGL_RED_BITS_ARB 0x2015
252 #define WGL_RED_SHIFT_ARB 0x2016
253 #define WGL_GREEN_BITS_ARB 0x2017
254 #define WGL_GREEN_SHIFT_ARB 0x2018
255 #define WGL_BLUE_BITS_ARB 0x2019
256 #define WGL_BLUE_SHIFT_ARB 0x201A
257 #define WGL_ALPHA_BITS_ARB 0x201B
258 #define WGL_ALPHA_SHIFT_ARB 0x201C
259 #define WGL_ACCUM_BITS_ARB 0x201D
260 #define WGL_ACCUM_RED_BITS_ARB 0x201E
261 #define WGL_ACCUM_GREEN_BITS_ARB 0x201F
262 #define WGL_ACCUM_BLUE_BITS_ARB 0x2020
263 #define WGL_ACCUM_ALPHA_BITS_ARB 0x2021
264 #define WGL_DEPTH_BITS_ARB 0x2022
265 #define WGL_STENCIL_BITS_ARB 0x2023
266 #define WGL_AUX_BUFFERS_ARB 0x2024
267 #define WGL_NO_ACCELERATION_ARB 0x2025
268 #define WGL_GENERIC_ACCELERATION_ARB 0x2026
269 #define WGL_FULL_ACCELERATION_ARB 0x2027
270 #define WGL_SWAP_EXCHANGE_ARB 0x2028
271 #define WGL_SWAP_COPY_ARB 0x2029
272 #define WGL_SWAP_UNDEFINED_ARB 0x202A
273 #define WGL_TYPE_RGBA_ARB 0x202B
274 #define WGL_TYPE_COLORINDEX_ARB 0x202C
275 #define ERROR_INVALID_PIXEL_TYPE_ARB 0x2043
276 #define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054
277 #define WGL_DRAW_TO_PBUFFER_ARB 0x202D
278 #define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E
279 #define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F
280 #define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030
281 #define WGL_PBUFFER_LARGEST_ARB 0x2033
282 #define WGL_PBUFFER_WIDTH_ARB 0x2034
283 #define WGL_PBUFFER_HEIGHT_ARB 0x2035
284 #define WGL_PBUFFER_LOST_ARB 0x2036
285 #define ERROR_INVALID_PIXEL_TYPE_EXT 0x2043
286 #define WGL_NUMBER_PIXEL_FORMATS_EXT 0x2000
287 #define WGL_DRAW_TO_WINDOW_EXT 0x2001
288 #define WGL_DRAW_TO_BITMAP_EXT 0x2002
289 #define WGL_ACCELERATION_EXT 0x2003
290 #define WGL_NEED_PALETTE_EXT 0x2004
291 #define WGL_NEED_SYSTEM_PALETTE_EXT 0x2005
292 #define WGL_SWAP_LAYER_BUFFERS_EXT 0x2006
293 #define WGL_SWAP_METHOD_EXT 0x2007
294 #define WGL_NUMBER_OVERLAYS_EXT 0x2008
295 #define WGL_NUMBER_UNDERLAYS_EXT 0x2009
296 #define WGL_TRANSPARENT_EXT 0x200A
297 #define WGL_TRANSPARENT_VALUE_EXT 0x200B
298 #define WGL_SHARE_DEPTH_EXT 0x200C
299 #define WGL_SHARE_STENCIL_EXT 0x200D
300 #define WGL_SHARE_ACCUM_EXT 0x200E
301 #define WGL_SUPPORT_GDI_EXT 0x200F
302 #define WGL_SUPPORT_OPENGL_EXT 0x2010
303 #define WGL_DOUBLE_BUFFER_EXT 0x2011
304 #define WGL_STEREO_EXT 0x2012
305 #define WGL_PIXEL_TYPE_EXT 0x2013
306 #define WGL_COLOR_BITS_EXT 0x2014
307 #define WGL_RED_BITS_EXT 0x2015
308 #define WGL_RED_SHIFT_EXT 0x2016
309 #define WGL_GREEN_BITS_EXT 0x2017
310 #define WGL_GREEN_SHIFT_EXT 0x2018
311 #define WGL_BLUE_BITS_EXT 0x2019
312 #define WGL_BLUE_SHIFT_EXT 0x201A
313 #define WGL_ALPHA_BITS_EXT 0x201B
314 #define WGL_ALPHA_SHIFT_EXT 0x201C
315 #define WGL_ACCUM_BITS_EXT 0x201D
316 #define WGL_ACCUM_RED_BITS_EXT 0x201E
317 #define WGL_ACCUM_GREEN_BITS_EXT 0x201F
318 #define WGL_ACCUM_BLUE_BITS_EXT 0x2020
319 #define WGL_ACCUM_ALPHA_BITS_EXT 0x2021
320 #define WGL_DEPTH_BITS_EXT 0x2022
321 #define WGL_STENCIL_BITS_EXT 0x2023
322 #define WGL_AUX_BUFFERS_EXT 0x2024
323 #define WGL_NO_ACCELERATION_EXT 0x2025
324 #define WGL_GENERIC_ACCELERATION_EXT 0x2026
325 #define WGL_FULL_ACCELERATION_EXT 0x2027
326 #define WGL_SWAP_EXCHANGE_EXT 0x2028
327 #define WGL_SWAP_COPY_EXT 0x2029
328 #define WGL_SWAP_UNDEFINED_EXT 0x202A
329 #define WGL_TYPE_RGBA_EXT 0x202B
330 #define WGL_TYPE_COLORINDEX_EXT 0x202C
331 #define WGL_DRAW_TO_PBUFFER_EXT 0x202D
332 #define WGL_MAX_PBUFFER_PIXELS_EXT 0x202E
333 #define WGL_MAX_PBUFFER_WIDTH_EXT 0x202F
334 #define WGL_MAX_PBUFFER_HEIGHT_EXT 0x2030
335 #define WGL_OPTIMAL_PBUFFER_WIDTH_EXT 0x2031
336 #define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032
337 #define WGL_PBUFFER_LARGEST_EXT 0x2033
338 #define WGL_PBUFFER_WIDTH_EXT 0x2034
339 #define WGL_PBUFFER_HEIGHT_EXT 0x2035
340 #define WGL_DEPTH_FLOAT_EXT 0x2040
341 #define WGL_SAMPLE_BUFFERS_3DFX 0x2060
342 #define WGL_SAMPLES_3DFX 0x2061
343 #define WGL_SAMPLE_BUFFERS_EXT 0x2041
344 #define WGL_SAMPLES_EXT 0x2042
345 #define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044
346 #define WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D 0x2045
347 #define WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D 0x2046
348 #define WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D 0x2047
349 #define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048
350 #define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049
351 #define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A
352 #define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B
353 #define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C
354 #define WGL_GAMMA_TABLE_SIZE_I3D 0x204E
355 #define WGL_GAMMA_EXCLUDE_DESKTOP_I3D 0x204F
356 #define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050
357 #define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051
358 #define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052
359 #define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053
360 #define WGL_ARB_buffer_region 1
361 #define WGL_ARB_extensions_string 1
362 #define WGL_ARB_pixel_format 1
363 #define WGL_ARB_make_current_read 1
364 #define WGL_ARB_pbuffer 1
365 #define WGL_EXT_display_color_table 1
366 #define WGL_EXT_extensions_string 1
367 #define WGL_EXT_make_current_read 1
368 #define WGL_EXT_pbuffer 1
369 #define WGL_EXT_pixel_format 1
370 #define WGL_EXT_swap_control 1
371 #define WGL_WGL_EXT_depth_float 1
372 #define WGL_WGL_3DFX_multisample 1
373 #define WGL_WGL_EXT_multisample 1
374 #define WGL_NV_allocate_memory 1
377 typedef void (APIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum target);
378 typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);
379 typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum target);
380 typedef void (APIENTRY * PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei count);
381 typedef void (APIENTRY * PFNGLUNLOCKARRAYSEXTPROC) (void);
385 typedef int (APIENTRY * PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer);
386 typedef int (APIENTRY * PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint *buffers);
387 typedef int (APIENTRY * PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint *buffers);
388 typedef int (APIENTRY * PFNGLBUFFERDATAARBPROC) (GLenum target, int size, const GLvoid *data, GLenum usage);
390 typedef int (APIENTRY * PFNWGLCHOOSEPIXELFORMATARBPROC) ();
391 typedef void * (APIENTRY * PFNWGLCREATEPBUFFERARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
392 typedef HDC (APIENTRY * PFNWGLGETPBUFFERDCARBPROC) (void * hPbuffer);
393 typedef int (APIENTRY * PFNWGLRELEASEPBUFFERDCARBPROC) (void * hPbuffer, HDC hDC);
394 typedef BOOL (APIENTRY * PFNWGLDESTROYPBUFFERARBPROC) (void * hPbuffer);
395 typedef BOOL (APIENTRY * PFNWGLQUERYPBUFFERARBPROC) (void * hPbuffer, int iAttribute, int *piValue);
396 typedef const char * (APIENTRY * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc);
397 typedef BOOL (APIENTRY * PFNWGLBINDTEXIMAGEARBPROC) (void * hPbuffer, int iBuffer);
398 typedef BOOL (APIENTRY * PFNWGLRELEASETEXIMAGEARBPROC) (void * hPbuffer, int iBuffer);
400 static PFNGLMAPBUFFERARBPROC glMapBufferARB = null;
401 static PFNGLUNMAPBUFFERARBPROC glUnmapBufferARB = null;
402 static PFNGLACTIVETEXTUREARBPROC glActiveTextureARB = null;
403 static PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB = null;
404 static PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB = null;
405 static PFNGLLOCKARRAYSEXTPROC glLockArraysEXT = null;
406 static PFNGLUNLOCKARRAYSEXTPROC glUnlockArraysEXT = null;
407 static PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate = null;
409 static PFNGLGENBUFFERSARBPROC glGenBuffersARB = null;
410 static PFNGLBINDBUFFERARBPROC glBindBufferARB = null;
411 static PFNGLBUFFERDATAARBPROC glBufferDataARB = null;
412 static PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB = null;
413 static PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = null;
414 static PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB = null;
415 static PFNWGLCREATEPBUFFERARBPROC wglCreatePbufferARB = null;
416 static PFNWGLGETPBUFFERDCARBPROC wglGetPbufferDCARB = null;
417 static PFNWGLQUERYPBUFFERARBPROC wglQueryPbufferARB = null;
418 static PFNWGLDESTROYPBUFFERARBPROC wglDestroyPbufferARB = null;
419 static PFNWGLRELEASEPBUFFERDCARBPROC wglReleasePbufferDCARB = null;
420 static PFNWGLBINDTEXIMAGEARBPROC wglBindTexImageARB = null;
421 static PFNWGLRELEASETEXIMAGEARBPROC wglReleaseTexImageARB = null;
423 #define glBufferData glBufferDataARB
425 #ifdef WGL_WGLEXT_PROTOTYPES
426 extern BOOL WINAPI wglSwapIntervalEXT (int);
427 extern int WINAPI wglGetSwapIntervalEXT (void);
428 #endif /* WGL_WGLEXT_PROTOTYPES */
429 typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC) (int interval);
430 typedef int (WINAPI * PFNWGLGETSWAPINTERVALEXTPROC) (void);
432 static PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = NULL;
434 #elif defined(__ANDROID__) || defined(__ODROID__)
436 #define GL_FRAMEBUFFER GL_FRAMEBUFFER_OES
437 #define GL_RENDERBUFFER GL_RENDERBUFFER_OES
438 #define GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_OES
440 #define GL_POLYGON_STIPPLE 0xFFFF
441 #define GL_LINE_STIPPLE 0xFFFF
442 #define GL_LINE 0xFFFF
443 #define GL_FILL 0xFFFF
444 #define GL_ALL_ATTRIB_BITS 0xFFFF
445 #define GL_LIGHT_MODEL_LOCAL_VIEWER 0xFFFF
451 #define GL_QUAD_STRIP 0
452 //#define GL_DOUBLE 0
453 //#define GL_UNSIGNED_INT 0
456 //#define GL_LINE_STIPPLE 0
457 #define GL_BGRA_EXT 0
458 #define GL_UNPACK_ROW_LENGTH 0
459 #define GL_UNPACK_SKIP_PIXELS 0
460 #define GL_UNPACK_SKIP_ROWS 0
462 #define GL_PACK_ROW_LENGTH 0
463 #define GL_PACK_SKIP_ROWS 0
464 #define GL_PACK_SKIP_PIXELS 0
468 #if defined(ECERE_NO3D) || defined(ECERE_VANILLA)
476 FillBytesBy4(this, 0, sizeof(Matrix) >> 2);
477 m[0][0]=m[1][1]=m[2][2]=m[3][3]=1;
480 void Transpose(Matrix source)
485 m[j][i] = source.m[i][j];
488 void Multiply(Matrix a, Matrix b)
490 // We need a full matrix multiplication for the Projection matrix
491 m[0][0]=a.m[0][0]*b.m[0][0] + a.m[0][1]*b.m[1][0] + a.m[0][2]*b.m[2][0] + a.m[0][3]*b.m[3][0];
492 m[0][1]=a.m[0][0]*b.m[0][1] + a.m[0][1]*b.m[1][1] + a.m[0][2]*b.m[2][1] + a.m[0][3]*b.m[3][1];
493 m[0][2]=a.m[0][0]*b.m[0][2] + a.m[0][1]*b.m[1][2] + a.m[0][2]*b.m[2][2] + a.m[0][3]*b.m[3][2];
494 m[0][3]=a.m[0][0]*b.m[0][3] + a.m[0][1]*b.m[1][3] + a.m[0][2]*b.m[2][3] + a.m[0][3]*b.m[3][3];
496 m[1][0]=a.m[1][0]*b.m[0][0] + a.m[1][1]*b.m[1][0] + a.m[1][2]*b.m[2][0] + a.m[1][3]*b.m[3][0];
497 m[1][1]=a.m[1][0]*b.m[0][1] + a.m[1][1]*b.m[1][1] + a.m[1][2]*b.m[2][1] + a.m[1][3]*b.m[3][1];
498 m[1][2]=a.m[1][0]*b.m[0][2] + a.m[1][1]*b.m[1][2] + a.m[1][2]*b.m[2][2] + a.m[1][3]*b.m[3][2];
499 m[1][3]=a.m[1][0]*b.m[0][3] + a.m[1][1]*b.m[1][3] + a.m[1][2]*b.m[2][3] + a.m[1][3]*b.m[3][3];
501 m[2][0]=a.m[2][0]*b.m[0][0] + a.m[2][1]*b.m[1][0] + a.m[2][2]*b.m[2][0] + a.m[2][3]*b.m[3][0];
502 m[2][1]=a.m[2][0]*b.m[0][1] + a.m[2][1]*b.m[1][1] + a.m[2][2]*b.m[2][1] + a.m[2][3]*b.m[3][1];
503 m[2][2]=a.m[2][0]*b.m[0][2] + a.m[2][1]*b.m[1][2] + a.m[2][2]*b.m[2][2] + a.m[2][3]*b.m[3][2];
504 m[2][3]=a.m[2][0]*b.m[0][3] + a.m[2][1]*b.m[1][3] + a.m[2][2]*b.m[2][3] + a.m[2][3]*b.m[3][3];
506 m[3][0]=a.m[3][0]*b.m[0][0] + a.m[3][1]*b.m[1][0] + a.m[3][2]*b.m[2][0] + a.m[3][3]*b.m[3][0];
507 m[3][1]=a.m[3][0]*b.m[0][1] + a.m[3][1]*b.m[1][1] + a.m[3][2]*b.m[2][1] + a.m[3][3]*b.m[3][1];
508 m[3][2]=a.m[3][0]*b.m[0][2] + a.m[3][1]*b.m[1][2] + a.m[3][2]*b.m[2][2] + a.m[3][3]*b.m[3][2];
509 m[3][3]=a.m[3][0]*b.m[0][3] + a.m[3][1]*b.m[1][3] + a.m[3][2]*b.m[2][3] + a.m[3][3]*b.m[3][3];
514 // Our own matrix stack
515 static Matrix matrixStack[3][32];
516 static int matrixIndex[3];
517 static int curStack = 0;
521 // OpenGL ES Porting Kit
522 #if defined(__ANDROID__) || defined(__ODROID__)
523 #define glBindFramebuffer glBindFramebufferOES
524 #define glBindRenderbuffer glBindRenderbufferOES
525 #define glFramebufferTexture2D glFramebufferTexture2DOES
526 #define glGenFramebuffers glGenFramebuffersOES
527 #define glGenRenderbuffers glGenRenderbuffersOES
528 #define glDeleteFramebuffers glDeleteFramebuffersOES
529 #define glDeleteRenderbuffers glDeleteRenderbuffersOES
531 #define GL_INT 0x1404
532 #define GL_UNSIGNED_INT 0x1405
533 #define GL_DOUBLE 0x140A
537 #define glDrawElementsi(type, count, start) glDrawElements(type, count, GL_UNSIGNED_SHORT, start)
539 #define glBufferDatai glesBufferDatai
540 #define glBufferDatad glesBufferDatad
541 #define glVertexPointeri glesVertexPointeri
542 #define glVertexPointerd glesVertexPointerd
544 #define glRecti glesRecti
545 #define glBegin glesBegin
546 #define glTexCoord2i glesTexCoord2i
547 #define glVertex2i glesVertex2i
548 #define glTexCoord2d glesTexCoord2d
549 #define glVertex2d glesVertex2d
550 #define glTexCoord2f glesTexCoord2f
551 #define glVertex2f glesVertex2f
552 #define glEnd glesEnd
553 #define glColor3f glesColor3f
554 #define glColor4ub glesColor4ub
555 #define glColor4fv glesColor4fv
556 #define glLineStipple glesLineStipple
557 #define glNormal3fv glesNormal3fv
558 #define glNormal3f glesNormal3f
559 #define glTexCoord2fv glesTexCoord2fv
560 #define glColorMaterial glesColorMaterial
562 #define glLoadMatrixd glesLoadMatrixd
563 #define glMultMatrixd glesMultMatrixd
564 #define glFrustum glesFrustum
565 #define glOrtho glesOrtho
566 #define glScaled glesScaled
567 #define glTranslated glesTranslated
568 #define glRotated glesRotated
569 #define glVertex3d glesVertex3d
570 #define glVertex3dv glesVertex3dv
571 #define glVertex3f glesVertex3f
572 #define glVertex3fv glesVertex3fv
573 #define glLightModeli glesLightModeli
577 #define glVertexPointerd(nc, s, p, nv) glVertexPointer(nc, GL_DOUBLE, s, p)
578 #define glDrawElementsi(type, count, start) glDrawElements(type, count, GL_UNSIGNED_INT, start)
582 #if defined(__ANDROID__) || defined(__ODROID__)
583 static EGLDisplay eglDisplay;
584 static EGLSurface eglSurface;
585 static EGLContext eglContext;
586 static int eglWidth, eglHeight;
588 #if defined(__ANDROID__)
589 static bool egl_init_display(ANativeWindow* window)
591 static bool egl_init_display(uint window)
594 const EGLint attribs[] =
596 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
600 EGL_DEPTH_SIZE, 16, //24,
601 /*EGL_SAMPLE_BUFFERS, 1,
602 EGL_SAMPLES, 0, //2,*/
611 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
612 eglInitialize(display, 0, 0);
613 eglChooseConfig(display, attribs, &config, 1, &numConfigs);
614 eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &format);
616 surface = eglCreateWindowSurface(display, config, window, null);
617 context = eglCreateContext(display, config, null, null);
619 if(!eglMakeCurrent(display, surface, surface, context))
622 eglQuerySurface(display, surface, EGL_WIDTH, &w);
623 eglQuerySurface(display, surface, EGL_HEIGHT, &h);
625 eglDisplay = display;
626 eglContext = context;
627 eglSurface = surface;
631 glEnableClientState(GL_VERTEX_ARRAY);
633 // Initialize GL state.
634 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
635 glEnable(GL_CULL_FACE);
636 glShadeModel(GL_SMOOTH);
637 glDisable(GL_DEPTH_TEST);
639 glDisable(GL_CULL_FACE);
640 glDisable(GL_DEPTH_TEST);
642 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
645 matrixStack[0][0].Identity();
646 matrixStack[1][0].Identity();
647 matrixStack[2][0].Identity();
649 glesMatrixMode(GL_MODELVIEW);
650 glScaled(1.0, 1.0, -1.0);
651 glesMatrixMode(GL_PROJECTION);
652 glShadeModel(GL_FLAT);
654 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
655 glFogi(GL_FOG_MODE, GL_EXP);
656 glFogf(GL_FOG_DENSITY, 0);
657 glEnable(GL_NORMALIZE);
658 glDepthFunc(GL_LESS);
660 glDisable(GL_MULTISAMPLE_ARB);
664 glOrtho(0,w,h,0,0.0,1.0);
667 curElementBuffer = 0;
671 static void egl_term_display()
675 glDeleteTextures(1, &stippleTexture);
678 if(eglDisplay != EGL_NO_DISPLAY)
680 eglMakeCurrent(eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
681 if(eglContext != EGL_NO_CONTEXT)
682 eglDestroyContext(eglDisplay, eglContext);
683 if(eglSurface != EGL_NO_SURFACE)
684 eglDestroySurface(eglDisplay, eglSurface);
685 eglTerminate(eglDisplay);
687 eglDisplay = EGL_NO_DISPLAY;
688 eglContext = EGL_NO_CONTEXT;
689 eglSurface = EGL_NO_SURFACE;
694 // OpenGL Immediate Mode Porting Kit
695 static int beginCount;
696 static int vertexCount;
697 static int normalCount;
698 static float *vertexPointer;
699 static float *normalPointer;
700 static GLenum beginMode = -1;
701 static uint beginBufferSize, normalBufferSize;
702 static int numVertexCoords = 2;
703 static bool vertexColorValues = false;
704 static int vertexStride = 4;
705 static int vertexOffset = 2;
707 public void glesRecti(int a, int b, int c, int d)
717 public void glesBegin(GLenum mode)
722 vertexColorValues = false;
729 normalBufferSize = beginBufferSize = 1024; // default number of vertices
730 vertexPointer = new float[beginBufferSize * vertexStride];
731 normalPointer = new float[normalBufferSize * 3];
735 public void glesTexCoord2f(float x, float y)
737 int count = vertexCount;
739 if(vertexCount + numVertexCoords > beginBufferSize)
741 beginBufferSize = beginBufferSize + beginBufferSize/2;
742 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
745 vertexPointer[count*vertexStride ] = x;
746 vertexPointer[count*vertexStride+1] = y;
749 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
751 vertexPointer[count*vertexStride ] = vertexPointer[(count-4)*vertexStride];
752 vertexPointer[count*vertexStride+1] = vertexPointer[(count-4)*vertexStride+1];
754 vertexPointer[count*vertexStride ] = vertexPointer[(count-3)*vertexStride];
755 vertexPointer[count*vertexStride+1] = vertexPointer[(count-3)*vertexStride+1];
759 public void glesTexCoord2i(int x, int y) { glesTexCoord2f((float)x, (float)y); }
760 public void glesTexCoord2d(double x, double y) { glesTexCoord2f((float)x, (float)y); }
761 public void glesTexCoord2fv(float * a) { glesTexCoord2f(a[0], a[1]); }
763 public void glesVertex2f(float x, float y)
766 vertexStride = vertexOffset + numVertexCoords;
768 if(vertexCount + 4 > beginBufferSize)
770 beginBufferSize = beginBufferSize + beginBufferSize/2;
771 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
774 vertexPointer[vertexCount*vertexStride+vertexOffset] = x;
775 vertexPointer[vertexCount*vertexStride+vertexOffset + 1] = y;
778 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
780 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset];
781 vertexPointer[vertexCount*vertexStride+vertexOffset + 1] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset + 1];
783 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset];
784 vertexPointer[vertexCount*vertexStride+vertexOffset + 1] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset + 1];
789 public void glesVertex2i(int x, int y) { glesVertex2f((float)x, (float)y); }
790 public void glesVertex2d(double x, double y) { glesVertex2f((float)x, (float)y); }
792 public void glesEnd(void)
794 int mode = beginMode;
795 if(mode == GL_QUADS) mode = GL_TRIANGLES;
796 else if(mode == GL_POLYGON) mode = GL_TRIANGLE_FAN;
798 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
799 noAB.use(texCoord, 2, GL_FLOAT, vertexStride * sizeof(float), vertexPointer);
800 if(vertexColorValues)
802 glEnableClientState(GL_COLOR_ARRAY);
803 noAB.use(color, 4, GL_FLOAT, vertexStride * sizeof(float), vertexPointer + 2);
805 noAB.use(vertex, numVertexCoords, GL_FLOAT, (vertexStride)*sizeof(float),vertexPointer+vertexOffset);
806 if(normalCount && normalCount == vertexCount)
808 glEnableClientState(GL_NORMAL_ARRAY);
809 noAB.use(normal, 3, GL_FLOAT, 3*sizeof(float),normalPointer);
812 glDrawArrays(mode, 0, vertexCount);
814 glDisableClientState(GL_NORMAL_ARRAY);
815 if(vertexColorValues)
816 glDisableClientState(GL_COLOR_ARRAY);
817 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
819 vertexColorValues = false;
825 static float *floatVPBuffer = null;
826 static short *shortVPBuffer = null;
827 static unsigned int shortVPSize = 0, floatVPSize = 0;
830 //static float *floatVPBuffer = null; // For floats we reuse floatVPBuffer
831 static unsigned short *shortBDBuffer = null;
832 static unsigned int shortBDSize = 0/*, floatVPSize = 0*/;
834 public void glesVertexPointeri(int numCoords, int stride, int *pointer, int numVertices)
839 if(numVertices*numCoords > shortVPSize)
841 shortVPSize = numVertices*numCoords;
842 shortVPBuffer = renew shortVPBuffer short[shortVPSize];
844 for(i = 0; i < numVertices*numCoords; i++)
845 shortVPBuffer[i] = (short)pointer[i];
846 glVertexPointer(numCoords, GL_SHORT, stride, shortVPBuffer);
849 glVertexPointer(numCoords, GL_SHORT, stride, 0);
852 public void glesVertexPointerd(int numCoords, int stride, double *pointer, int numVertices)
857 if(numVertices*numCoords > floatVPSize)
859 floatVPSize = numVertices*numCoords;
860 floatVPBuffer = renew floatVPBuffer float[floatVPSize];
862 for(i = 0; i < numVertices*numCoords; i++)
863 floatVPBuffer[i] = (float)pointer[i];
864 glVertexPointer(numCoords, GL_FLOAT, stride, floatVPBuffer);
867 glVertexPointer(numCoords, GL_FLOAT, stride, 0);
870 public void glesTexReuseIntVP(int numCoords)
872 glTexCoordPointer(numCoords, GL_SHORT, 0, floatVPBuffer);
875 public void glesTexReuseDoubleVP(int numCoords)
877 glTexCoordPointer(numCoords, GL_FLOAT, 0, floatVPBuffer);
880 public void glesColor4f(float r, float g, float b, float a)
882 if(beginMode != (GLenum)-1)
884 int count = vertexCount;
886 vertexColorValues = true;
888 vertexStride = vertexOffset + numVertexCoords;
890 if(vertexCount + vertexStride > beginBufferSize)
892 beginBufferSize = beginBufferSize + beginBufferSize/2;
893 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
896 vertexPointer[count*vertexStride + 2] = r;
897 vertexPointer[count*vertexStride + 3] = g;
898 vertexPointer[count*vertexStride + 4] = b;
899 vertexPointer[count*vertexStride + 5] = a;
902 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
904 vertexPointer[count*vertexStride + 2] = vertexPointer[(count-4) * vertexStride + 2];
905 vertexPointer[count*vertexStride + 3] = vertexPointer[(count-4) * vertexStride + 3];
906 vertexPointer[count*vertexStride + 4] = vertexPointer[(count-4) * vertexStride + 4];
907 vertexPointer[count*vertexStride + 5] = vertexPointer[(count-4) * vertexStride + 5];
909 vertexPointer[count*vertexStride + 2] = vertexPointer[(count-3) * vertexStride + 2];
910 vertexPointer[count*vertexStride + 3] = vertexPointer[(count-3) * vertexStride + 3];
911 vertexPointer[count*vertexStride + 4] = vertexPointer[(count-3) * vertexStride + 4];
912 vertexPointer[count*vertexStride + 5] = vertexPointer[(count-3) * vertexStride + 5];
917 glColor4f(r, g, b, a);
920 public void glesColor3f( float r, float g, float b )
922 glesColor4f(r, g, b, 1.0f);
925 public void glesColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
927 glesColor4f(r/255.0f, g/255.0f, b/255.0f, a/255.0f);
930 public void glesColor4fv(float * a)
932 glesColor4f(a[0], a[1], a[2], a[3]);
935 public void glesBufferDatad(int target, int size, void * data, int usage)
937 int numElems = size/sizeof(double);
938 double * dblPtr = (double *)data;
940 if (numElems > floatVPSize)
942 floatVPSize = numElems;
943 floatVPBuffer = renew floatVPBuffer float[floatVPSize];
945 for (i=0; i< numElems; i++)
946 floatVPBuffer[i] = (float)dblPtr[i];
948 glBufferData(target, numElems*sizeof(float), floatVPBuffer, usage);
951 public void glesBufferDatai(int target, int size, void * data, int usage)
953 int numElems = size/sizeof(unsigned int);
954 unsigned int * pointer = (unsigned int *)data;
956 if (numElems > shortBDSize)
958 shortBDSize = numElems;
959 shortBDBuffer = renew shortBDBuffer uint16[shortBDSize];
961 for (i=0; i< numElems; i++)
962 shortBDBuffer[i] = (unsigned short)pointer[i];
964 glBufferData(target, numElems*sizeof(unsigned short), shortBDBuffer, usage);
967 // *** Our Custom Matrix Stack ***
969 static void LoadCurMatrix()
971 double * i = matrixStack[curStack][matrixIndex[curStack]].array;
974 (float)i[0],(float)i[1],(float)i[2],(float)i[3],
975 (float)i[4],(float)i[5],(float)i[6],(float)i[7],
976 (float)i[8],(float)i[9],(float)i[10],(float)i[11],
977 (float)i[12],(float)i[13],(float)i[14],(float)i[15]
982 public void glesLoadIdentity()
984 matrixStack[curStack][matrixIndex[curStack]].Identity();
988 public void glesPushMatrix()
990 if(matrixIndex[curStack] + 1 < sizeof(matrixStack[0]) / sizeof(Matrix))
992 matrixIndex[curStack]++;
993 memcpy(matrixStack[curStack][matrixIndex[curStack]].array, matrixStack[curStack][matrixIndex[curStack]-1].array, sizeof(Matrix));
997 public void glesPopMatrix()
999 if(matrixIndex[curStack] > 0)
1001 matrixIndex[curStack]--;
1006 public void glesLoadMatrixd(double * i)
1008 memcpy(matrixStack[curStack][matrixIndex[curStack]].array, i, sizeof(Matrix));
1012 public void glesOrtho( double l, double r, double b, double t, double n, double f )
1016 (2 / (r - l)), 0, 0, 0,
1017 0, (2 / (t - b)), 0, 0,
1018 0, 0, (-2 / (f - n)), 0,
1019 (-(r + l) / (r - l)), (-(t + b) / (t - b)), (-(f + n) / (f - n)), 1
1022 res.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1023 matrixStack[curStack][matrixIndex[curStack]] = res;
1027 public void glesFrustum( double l, double r, double b, double t, double n, double f )
1037 double A = ((r + l) / (r - l));
1038 double B = ((t + b) / (t - b));
1039 double C = (-(f + n) / (f - n));
1040 double D = (-2*f*n/(f-n));
1043 (2.0*n / (r - l)), 0, 0, 0,
1044 0, (2.0*n / (t - b)), 0, 0,
1049 res.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1050 matrixStack[curStack][matrixIndex[curStack]] = res;
1055 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1056 public void glesRotated( double a, double b, double c, double d )
1061 q.RotationAxis({(float)b,(float)c,(float)-d}, a );
1062 m.RotationQuaternion(q);
1063 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1064 matrixStack[curStack][matrixIndex[curStack]] = r;
1067 public void glesScaled( double a, double b, double c )
1073 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1074 matrixStack[curStack][matrixIndex[curStack]] = r;
1078 public void glesTranslated( double a, double b, double c )
1084 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1085 matrixStack[curStack][matrixIndex[curStack]] = r;
1089 public void glesMultMatrixd( double * i )
1092 r.Multiply((Matrix *)i, matrixStack[curStack][matrixIndex[curStack]]);
1093 matrixStack[curStack][matrixIndex[curStack]] = r;
1098 public void glesMatrixMode(int mode)
1100 curStack = (mode == GL_MODELVIEW) ? 0 : (mode == GL_PROJECTION) ? 1 : 2;
1106 #define glPushMatrix glesPushMatrix
1107 #define glPopMatrix glesPopMatrix
1108 #define glLoadIdentity glesLoadIdentity
1109 #define glMatrixMode glesMatrixMode
1113 /* Using the built-in matrix stack
1114 void glesLoadMatrixd( double * i )
1118 (float)i[0],(float)i[1],(float)i[2],(float)i[3],
1119 (float)i[4],(float)i[5],(float)i[6],(float)i[7],
1120 (float)i[8],(float)i[9],(float)i[10],(float)i[11],
1121 (float)i[12],(float)i[13],(float)i[14],(float)i[15]
1126 void glesOrtho( double l, double r, double b, double t, double n, double f )
1128 float matrix[4][4] =
1130 { (float)(2 / (r - l)), 0, 0, 0 },
1131 { 0, (float)(2 / (t - b)), 0, 0 },
1132 { 0, 0, (float)(-2 / (f - n)), 0 },
1133 { (float)(-(r + l) / (r - l)), (float)(-(t + b) / (t - b)), (float)(-(f + n) / (f - n)), 1 }
1135 glMultMatrixf((float *)matrix);
1138 void glesFrustum( double l, double r, double b, double t, double n, double f )
1140 float A = (float)((r + l) / (r - l));
1141 float B = (float)((t + b) / (t - b));
1142 float C = (float)(-(f + n) / (f - n));
1143 float D = (float)(-2*f*n/(f-n));
1144 float matrix[4][4] =
1146 { (float)(2*n / (r - l)), 0, 0, 0 },
1147 { 0, (float)(2*n / (t - b)), 0, 0 },
1151 glMultMatrixf((float *)matrix);
1154 void glesRotated( double a, double b, double c, double d ) { glRotatef((float)a, (float)b, (float)c, (float)d); }
1155 void glesScaled( double a, double b, double c ) { glScalef((float)a, (float)b, (float)c); }
1156 void glesTranslated( double a, double b, double c ) { glTranslatef((float)a, (float)b, (float)c); }
1158 void glesMultMatrixd( double * i )
1162 (float)i[0], (float)i[1], (float)i[2], (float)i[3],
1163 (float)i[4], (float)i[5], (float)i[6], (float)i[7],
1164 (float)i[8], (float)i[9], (float)i[10], (float)i[11],
1165 (float)i[12], (float)i[13], (float)i[14], (float)i[15]
1171 // Need to do these...
1172 public void glesVertex3f( float x, float y, float z )
1174 numVertexCoords = 3;
1175 vertexStride = vertexOffset + numVertexCoords;
1177 if(vertexCount + vertexStride > beginBufferSize)
1179 beginBufferSize = beginBufferSize + beginBufferSize/2;
1180 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
1183 vertexPointer[vertexCount*vertexStride+vertexOffset] = x;
1184 vertexPointer[vertexCount*vertexStride+vertexOffset+1] = y;
1185 vertexPointer[vertexCount*vertexStride+vertexOffset+2] = z;
1188 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
1190 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset];
1191 vertexPointer[vertexCount*vertexStride+vertexOffset+1] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset+1];
1192 vertexPointer[vertexCount*vertexStride+vertexOffset+2] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset+2];
1194 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset];
1195 vertexPointer[vertexCount*vertexStride+vertexOffset+1] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset+1];
1196 vertexPointer[vertexCount*vertexStride+vertexOffset+2] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset+2];
1202 public void glesVertex3d( double x, double y, double z ) { glesVertex3f((float)x, (float)y, (float)z); }
1203 public void glesVertex3fv( float* coords ) { glesVertex3f(coords[0], coords[1], coords[2]); }
1204 public void glesVertex3dv( double* coords ) { glesVertex3f((float)coords[0], (float)coords[1], (float)coords[2]); }
1206 public void glesNormal3f(float x, float y, float z)
1208 normalCount = vertexCount;
1209 if(vertexCount + 4 > normalBufferSize)
1211 normalBufferSize = normalBufferSize + normalBufferSize/2;
1212 normalPointer = renew normalPointer float[normalBufferSize * 2];
1215 normalPointer[normalCount*3+0] = x;
1216 normalPointer[normalCount*3+1] = y;
1217 normalPointer[normalCount*3+2] = z;
1220 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
1222 normalPointer[normalCount*3+0] = normalPointer[(normalCount-4)*3+0];
1223 normalPointer[normalCount*3+1] = normalPointer[(normalCount-4)*3+1];
1224 normalPointer[normalCount*3+2] = normalPointer[(normalCount-4)*3+2];
1226 normalPointer[normalCount*3+0] = normalPointer[(normalCount-3)*3+0];
1227 normalPointer[normalCount*3+1] = normalPointer[(normalCount-3)*3+1];
1228 normalPointer[normalCount*3+2] = normalPointer[(normalCount-3)*3+2];
1232 public void glesNormal3fd(double x, double y, double z) { glesNormal3f((float)x, (float)y, (float)z); }
1233 public void glesNormal3fv(float * coords) { glesNormal3f(coords[0], coords[1], coords[2]); }
1235 public void glesColorMaterial(int a, int b)
1237 PrintLn("glColorMaterial stub");
1240 public void glesTerminate()
1242 delete vertexPointer;
1243 delete normalPointer;
1244 beginBufferSize = 0;
1246 delete floatVPBuffer;
1249 delete shortVPBuffer;
1252 delete shortBDBuffer;
1256 static GLuint stippleTexture;
1257 #if defined(_GLES) || defined(EM_MODE)
1258 static bool stippleEnabled;
1261 public void glesLineStipple( int i, unsigned short j )
1265 for(x = 0; x < 16; x++)
1267 bool v = (j & (1 << x)) != 0;
1268 texture[x] = v ? 0xFFFFFFFF : 0;
1271 glGenTextures(1, &stippleTexture);
1272 glBindTexture(GL_TEXTURE_2D, stippleTexture);
1273 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture);
1274 glEnable(GL_TEXTURE_2D);
1275 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1276 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1277 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
1278 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1279 glMatrixMode(GL_TEXTURE);
1281 //glTranslated(1.0/backAttrib->texW/2.0f, 1.0/backAttrib->texH/2.0f, 0.0f);
1282 glScaled(i/16.0, 1, 1.0f);
1283 glTranslated(0.5, 0.5, 0);
1284 glMatrixMode(GL_PROJECTION);
1287 public void glesLightModeli( unsigned int pname, int param )
1289 #if !defined(EM_MODE)
1290 if(pname == GL_LIGHT_MODEL_TWO_SIDE)
1291 glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, param);
1295 #if defined(__ANDROID__) || defined(__ODROID__)
1296 void glClearDepth( double depth ) { glClearDepthf((float)depth); }
1297 void glFogi( unsigned int pname, int param ) { }
1298 void glPolygonMode( unsigned int i, unsigned int j ) { }
1301 // *** Picking won't be supported for now ***
1302 void glPushName( unsigned int i ) { }
1303 void glLoadName( unsigned int i ) { }
1304 void glPopName() { }
1306 // Probably replace by regular glBlendFunc ...
1307 void glBlendFuncSeparate(int a, int b, int c, int d)
1312 // For direct pixel blitting...
1313 void glRasterPos2d(double a, double b) { }
1314 void glPixelZoom(float a, float b) { }
1315 void glDrawPixels(int a, int b, int c, int d, void * e) { }
1319 #if !defined(__APPLE__) && !defined(__WIN32__) && !defined(__ODROID__)
1320 void (APIENTRY * glBindBufferARB) (GLenum target, GLuint buffer);
1321 void (APIENTRY * glGenBuffersARB) (GLsizei n, GLuint *buffers);
1322 void (APIENTRY * glDeleteBuffersARB) (GLsizei n, const GLuint *buffers);
1323 void (APIENTRY * glBufferDataARB) (GLenum target, int size, const GLvoid *data, GLenum usage);
1326 public void GLLoadMatrix(Matrix matrix)
1330 (float)matrix.m[0][0], (float)matrix.m[0][1], (float)matrix.m[0][2], (float)matrix.m[0][3],
1331 (float)matrix.m[1][0], (float)matrix.m[1][1], (float)matrix.m[1][2], (float)matrix.m[1][3],
1332 (float)matrix.m[2][0], (float)matrix.m[2][1], (float)matrix.m[2][2], (float)matrix.m[2][3],
1333 (float)matrix.m[3][0], (float)matrix.m[3][1], (float)matrix.m[3][2], (float)matrix.m[3][3]
1338 public enum GLBufferContents { vertex, normal, texCoord, color };
1340 public define noAB = GLAB { 0 };
1342 static uint curArrayBuffer;
1348 void upload(uint size, void * data)
1353 glGenBuffers(1, &buffer);
1354 if(curArrayBuffer != buffer)
1356 glBindBuffer(GL_ARRAY_BUFFER, buffer);
1357 curArrayBuffer = buffer;
1359 glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW); //GL_DYNAMIC_DRAW);
1367 glDeleteBuffers(1, &buffer);
1372 void use(GLBufferContents contents, int n, int type, uint stride, void * pointer)
1374 if(curArrayBuffer != ((this != null) ? buffer : 0))
1376 glBindBuffer(GL_ARRAY_BUFFER, ((this != null) ? buffer : 0));
1377 curArrayBuffer = ((this != null) ? buffer : 0);
1381 case normal: glNormalPointer(type, stride, pointer); break;
1382 case vertex: glVertexPointer(n, type, stride, pointer); break;
1383 case texCoord: glTexCoordPointer(n, type, stride, pointer); break;
1384 case color: glColorPointer(n, type, stride, pointer); break;
1389 static uint curElementBuffer;
1391 public define noEAB = GLEAB { 0 };
1397 void upload(uint size, void * data)
1402 glGenBuffers(1, &buffer);
1404 if(curElementBuffer != buffer)
1406 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
1407 curElementBuffer = buffer;
1409 glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, data, GL_STATIC_DRAW); //GL_DYNAMIC_DRAW);
1417 glDeleteBuffers(1, &buffer);
1422 void draw(int primType, int count, int type, void * indices)
1424 if(curElementBuffer != ((this != null) ? buffer : 0))
1426 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ((this != null) ? buffer : 0));
1427 curElementBuffer = ((this != null) ? buffer : 0);
1429 glDrawElements(primType, count, type, indices);
1433 public void GLGenBuffers(int count, GLAB * buffers)
1435 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
1436 glGenBuffers(count, (GLuint *)buffers);
1438 #if defined(__WIN32__)
1441 glGenBuffersARB(count, (GLuint *)buffers);
1445 public void GLDeleteBuffers(int count, GLAB * buffers)
1447 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
1448 glDeleteBuffers(count, (GLuint *)buffers);
1450 #if defined(__WIN32__)
1451 if(glDeleteBuffersARB)
1453 glDeleteBuffersARB(count, (GLuint *)buffers);
1457 void GLBindBuffer(int target, uint buffer)
1459 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
1460 glBindBuffer(target, buffer);
1462 #if defined(__WIN32__)
1465 glBindBufferARB(target, buffer);
1467 if(target == GL_ARRAY_BUFFER_ARB)
1468 curArrayBuffer = buffer;
1469 else if(target == GL_ELEMENT_ARRAY_BUFFER_ARB)
1470 curElementBuffer = buffer;
1473 public void GLVertexPointer(int numCoords, int glType, int stride, void *ptr, int numVertices)
1476 if(glType == GL_DOUBLE)
1477 glesVertexPointerd(numCoords, stride, ptr, numVertices);
1478 else if(glType == GL_INT)
1479 glesVertexPointeri(numCoords, stride, ptr, numVertices);
1482 glVertexPointer(numCoords, glType, stride, ptr);
1485 public void GLBufferData(int type, GLenum target, int size, const GLvoid *data, GLenum usage)
1488 if(type == GL_DOUBLE)
1489 glesBufferDatad(target, size, (void *)data, usage);
1490 else if(type == GL_UNSIGNED_INT)
1491 glesBufferDatai(target, size, (void *)data, usage);
1495 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
1496 glBufferData(target, size, data, usage);
1499 #if defined(__WIN32__)
1502 glBufferDataARB(target, size, data, usage);
1506 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1507 static int primitiveTypes[RenderPrimitiveType] =
1509 GL_POINTS, GL_LINES, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP, GL_LINE_STRIP
1514 // Non OpenGL ES friendly stuff
1518 //#undef GL_UNSIGNED_INT
1523 #undef GL_QUAD_STRIP
1524 #undef GL_POLYGON_STIPPLE
1525 #undef GL_LINE_STIPPLE
1528 #undef GL_ALL_ATTRIB_BITS
1529 #undef GL_LIGHT_MODEL_LOCAL_VIEWER
1533 static int displayWidth, displayHeight;
1535 #define GL_CLAMP_TO_EDGE 0x812F
1537 static bool vboAvailable;
1539 static bool useSingleGLContext = false;
1540 class OGLDisplay : struct
1542 #if defined(__WIN32__)
1552 int imageBuffers[2];
1553 byte * pboMemory1, * pboMemory2;
1555 #elif !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
1556 GLXContext glContext;
1559 XShmSegmentInfo shminfo;
1561 XShmSegmentInfo shminfoShape;
1562 XImage * shapeImage;
1566 X11Picture windowPicture;
1567 X11Picture pixmapPicture;
1569 X11Picture shapePicture;
1572 ColorAlpha * flippingBuffer;
1573 int flipBufH, flipBufW;
1578 class OGLSystem : struct
1583 #if defined(__WIN32__)
1584 PIXELFORMATDESCRIPTOR pfd;
1589 #elif !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
1590 XVisualInfo * visualInfo;
1591 GLXContext glContext;
1592 GLXDrawable glxDrawable;
1596 class OGLSurface : struct
1602 bool writingOutline;
1604 float foreground[4], background[4], bitmapMult[4];
1607 class OGLMesh : struct
1616 class OGLIndices : struct
1626 class OpenGLDisplayDriver : DisplayDriver
1628 class_property(name) = "OpenGL";
1630 bool LockSystem(DisplaySystem displaySystem)
1632 #if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
1633 OGLSystem oglSystem = displaySystem.driverData;
1634 if(useSingleGLContext) return true;
1635 #if defined(__WIN32__)
1636 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1637 #elif defined(__unix__) || defined(__APPLE__)
1638 //if(previous) return true;
1639 // printf("Making SYSTEM current\n");
1640 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)oglSystem.glxDrawable, oglSystem.glContext);
1641 //previous = oglSystem.glContext;
1647 void UnlockSystem(DisplaySystem displaySystem)
1649 if(useSingleGLContext) return;
1650 #if defined(__WIN32__)
1651 wglMakeCurrent(null, null);
1652 #elif defined(__unix__) || defined(__APPLE__)
1653 // printf("Making NULL current\n");
1654 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
1656 glXMakeCurrent(xGlobalDisplay, None, null);
1662 bool Lock(Display display)
1664 #if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
1665 OGLDisplay oglDisplay = display.driverData;
1666 if(useSingleGLContext) return true;
1667 #if defined(__WIN32__)
1668 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1669 #elif defined(__unix__) || defined(__APPLE__)
1670 // if(previous) glXMakeCurrent(xGlobalDisplay, None, null);
1671 // printf(" Making DISPLAY current\n");
1672 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
1678 void Unlock(Display display)
1680 if(useSingleGLContext) return;
1681 //printf(" Making NULL current\n");
1682 //glXMakeCurrent(xGlobalDisplay, None, null);
1684 LockSystem(display.displaySystem);
1687 void DestroyDisplay(Display display)
1689 OGLDisplay oglDisplay = display.driverData;
1693 #if defined(__WIN32__)
1694 wglMakeCurrent( null, null );
1697 wglDeleteContext(oglDisplay.glrc);
1699 if(oglDisplay.hdc && oglDisplay.pBuffer)
1700 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
1702 if(oglDisplay.pBuffer)
1703 wglDestroyPbufferARB(oglDisplay.pBuffer);
1706 ReleaseDC(display.window, oglDisplay.hdc);
1708 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
1709 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
1711 #elif defined(__unix__) || defined(__APPLE__)
1712 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
1714 if(oglDisplay.shapePixmap)
1715 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
1716 if(oglDisplay.pixmap)
1717 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1718 if(oglDisplay.image)
1720 if(oglDisplay.shminfoShape.shmid != -1)
1722 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
1723 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1724 shmdt(oglDisplay.shminfo.shmaddr);
1725 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
1728 if(oglDisplay.shapeImage)
1730 if(oglDisplay.shminfoShape.shmid != -1)
1732 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
1733 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1734 shmdt(oglDisplay.shminfoShape.shmaddr);
1735 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
1737 XDestroyImage(oglDisplay.shapeImage);
1738 oglDisplay.shapeImage = None;
1741 glXMakeCurrent(xGlobalDisplay, None, null);
1743 if(oglDisplay.glContext)
1744 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
1747 delete oglDisplay.flippingBuffer;
1749 display.driverData = null;
1753 void ::CheckExtensions(OGLSystem oglSystem)
1755 const char * extensions = (const char *)glGetString(GL_EXTENSIONS);
1757 oglSystem.pow2textures = strstr(extensions, "GL_ARB_texture_non_power_of_two") ? false : true;
1758 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &oglSystem.maxTextureSize);
1761 bool CreateDisplaySystem(DisplaySystem displaySystem)
1763 bool result = false;
1764 OGLSystem oglSystem = displaySystem.driverData = OGLSystem { };
1767 oglSystem.hwnd = CreateWindow("static", null, 0,0,0,0,0,null,null,null,null);
1769 oglSystem.hdc = GetDC(oglSystem.hwnd);
1773 oglSystem.pfd.nSize = (short)sizeof(oglSystem.pfd);
1774 oglSystem.pfd.nVersion = 1;
1775 oglSystem.pfd.dwFlags = PFD_DRAW_TO_WINDOW /*PFD_DRAW_TO_BITMAP*/ | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
1776 oglSystem.pfd.iPixelType = PFD_TYPE_RGBA;
1777 oglSystem.pfd.cColorBits = 24;
1778 oglSystem.pfd.cAlphaBits = 8;
1779 oglSystem.pfd.cDepthBits = 24;
1780 oglSystem.pfd.iLayerType = PFD_MAIN_PLANE;
1782 oglSystem.format = ChoosePixelFormat(oglSystem.hdc, &oglSystem.pfd);
1783 DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1785 if(oglSystem.pfd.cColorBits > 8)
1787 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1788 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1791 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1793 // Get Pointers To The GL Functions
1794 glActiveTextureARB = (void *) wglGetProcAddress("glActiveTextureARB");
1795 glMultiTexCoord2fARB = (void *) wglGetProcAddress("glMultiTexCoord2fARB");
1796 glClientActiveTextureARB = (void *) wglGetProcAddress("glClientActiveTextureARB");
1797 glLockArraysEXT = (void *) wglGetProcAddress("glLockArraysEXT" );
1798 glUnlockArraysEXT = (void *) wglGetProcAddress("glUnlockArraysEXT");
1799 glGenBuffersARB = (void *) wglGetProcAddress("glGenBuffersARB");
1800 glBindBufferARB = (void *) wglGetProcAddress("glBindBufferARB");
1801 glBufferDataARB = (void *) wglGetProcAddress("glBufferDataARB");
1802 glMapBufferARB = (void *) wglGetProcAddress("glMapBufferARB");
1803 glUnmapBufferARB = (void *) wglGetProcAddress("glUnmapBufferARB");
1804 glDeleteBuffersARB = (void *) wglGetProcAddress("glDeleteBuffersARB");
1805 glBlendFuncSeparate = (void *) wglGetProcAddress("glBlendFuncSeparate");
1807 wglChoosePixelFormatARB = (void *) wglGetProcAddress("wglChoosePixelFormatARB");
1808 wglGetExtensionsStringARB = (void *)wglGetProcAddress("wglGetExtensionsStringARB");
1809 wglCreatePbufferARB = (void *)wglGetProcAddress("wglCreatePbufferARB");
1810 wglGetPbufferDCARB = (void *)wglGetProcAddress("wglGetPbufferDCARB");
1811 wglQueryPbufferARB = (void *)wglGetProcAddress("wglQueryPbufferARB");
1812 wglDestroyPbufferARB = (void *)wglGetProcAddress("wglDestroyPbufferARB");
1813 wglReleasePbufferDCARB = (void *)wglGetProcAddress("wglReleasePbufferDCARB");
1814 wglBindTexImageARB = (void *)wglGetProcAddress("wglBindTexImageARB");
1815 wglReleaseTexImageARB = (void *)wglGetProcAddress("wglReleaseTexImageARB");
1817 wglSwapIntervalEXT = (void *)wglGetProcAddress("wglSwapIntervalEXT");
1819 vboAvailable = glBindBufferARB != null;
1821 // eSystem_LoggingMode(LOG_MSGBOX, null);
1823 if(wglChoosePixelFormatARB)
1828 float fAttributes[] = {0,0};
1831 WGL_DRAW_TO_WINDOW_ARB,GL_TRUE,
1832 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1833 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
1834 WGL_COLOR_BITS_ARB,24,
1835 WGL_ALPHA_BITS_ARB,8,
1836 WGL_DEPTH_BITS_ARB,16,
1837 WGL_STENCIL_BITS_ARB,0,
1838 WGL_DOUBLE_BUFFER_ARB,GL_TRUE,
1839 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
1840 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
1844 //Log("Found wglChoosePixelFormatARB\n");
1846 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1847 if(!valid || !numFormats)
1849 //Log("Can't find 4x multi sampling\n");
1850 iAttributes[19] = 2;
1851 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1852 if(!valid || !numFormats)
1854 // Log("Can't find 2x multi sampling\n");
1855 iAttributes[16] = 0;
1856 iAttributes[17] = 0;
1857 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1860 if(valid && numFormats)
1862 oglSystem.format = pixelFormat;
1863 wglMakeCurrent(null, null);
1864 wglDeleteContext(oglSystem.glrc);
1866 // *** DescribePixelFormat does not support WGL pixel formats! ***
1867 //DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1868 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1869 //Log("Successfully set pixel format\n");
1871 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1872 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1876 eSystem_Logf("Can't find wglChoosePixelFormatARB\n");*/
1880 CheckExtensions(oglSystem);
1882 wglMakeCurrent(null, null);
1884 //eSystem_DumpErrors(true);
1888 #elif defined(__unix__) || defined(__APPLE__)
1889 vboAvailable = true;
1890 #if defined(__ANDROID__)
1891 egl_init_display(guiApp.desktop.windowHandle);
1892 #elif defined(__ODROID__)
1893 egl_init_display((uint)displaySystem.window);
1894 CheckExtensions(oglSystem);
1896 #elif defined(__EMSCRIPTEN__)
1897 if(glfwInit() == GL_TRUE)
1899 const int width = 640, height = 480;
1900 if(glfwOpenWindow(width, height, 8, 8, 8, 8, 16, 0, GLFW_WINDOW) == GL_TRUE)
1902 //glfwSwapBuffers();
1906 printf("glfwOpenWindow() failed\n"); //glfwTerminate();
1909 printf("glfwInit() failed\n"); //glfwTerminate();
1912 X11Window root = RootWindow( xGlobalDisplay, DefaultScreen( xGlobalDisplay ) );
1913 XSetWindowAttributes attr;
1918 #ifndef ECERE_MINIGLX
1919 GLX_USE_GL, GLX_DEPTH_SIZE, 1,
1922 GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,
1926 oglSystem.visualInfo = glXChooseVisual( xGlobalDisplay, DefaultScreen( xGlobalDisplay ), attrList );
1927 attr.background_pixel = 0;
1928 attr.border_pixel = 0;
1929 attr.colormap = XCreateColormap( xGlobalDisplay, root, oglSystem.visualInfo->visual, AllocNone);
1930 attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
1931 mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
1933 oglSystem.glxDrawable = XCreateWindow( xGlobalDisplay, root, 0, 0, 1, 1, 0, oglSystem.visualInfo->depth, InputOutput,
1934 oglSystem.visualInfo->visual, mask, &attr );
1936 if(oglSystem.visualInfo)
1938 oglSystem.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, null, True);
1939 if(oglSystem.glContext)
1941 glXMakeCurrent(xGlobalDisplay, oglSystem.glxDrawable, oglSystem.glContext);
1943 CheckExtensions(oglSystem);
1944 glXMakeCurrent(xGlobalDisplay, None, null);
1951 displaySystem.flags.alpha = true;
1952 displaySystem.flags.flipping = true;
1953 displaySystem.pixelFormat = pixelFormat888;
1957 void DestroyDisplaySystem(DisplaySystem displaySystem)
1959 OGLSystem oglSystem = displaySystem.driverData;
1961 #if defined(__WIN32__)
1962 wglMakeCurrent( null, null );
1965 wglDeleteContext(oglSystem.glrc);
1968 ReleaseDC(oglSystem.hwnd, oglSystem.hdc);
1969 DestroyWindow(oglSystem.hwnd);
1971 #elif defined(__unix__) || defined(__APPLE__)
1972 #if defined(__ANDROID__) || defined(__ODROID__)
1974 #elif defined(__EMSCRIPTEN__)
1977 if(oglSystem.visualInfo)
1979 #ifdef ECERE_MINIGLX
1980 __miniglx_XFree(oglSystem.visualInfo);
1982 XFree(oglSystem.visualInfo);
1986 if(oglSystem.glxDrawable)
1988 XDestroyWindow(xGlobalDisplay, oglSystem.glxDrawable);
1989 oglSystem.glxDrawable = 0;
1996 bool CreateDisplay(Display display)
1998 bool result = false;
1999 OGLDisplay oglDisplay = display.driverData;
2000 #if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
2001 OGLSystem oglSystem = display.displaySystem.driverData;
2004 oglDisplay = display.driverData = OGLDisplay { };
2005 //printf("Inside CreateDisplay\n");
2007 #if defined(__WIN32__) || defined(USEPBUFFER)
2008 if(!display.alphaBlend)
2011 #if defined(__WIN32__)
2012 oglDisplay.hdc = GetDC(display.window);
2013 SetPixelFormat(oglDisplay.hdc, oglSystem.format, &oglSystem.pfd);
2014 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
2016 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2017 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2021 ReleaseDC(display.window, oglDisplay.hdc);
2022 #elif defined(__unix__) || defined(__APPLE__)
2023 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2025 XVisualInfo * visualInfo = ((XWindowData)display.windowDriverData).visual;
2027 #if defined(__APPLE__)
2028 XVisualInfo template = { 0 };
2029 XWindowAttributes winAttr;
2031 XGetWindowAttributes(xGlobalDisplay, (X11Window)display.window, &winAttr);
2032 template.visualid = XVisualIDFromVisual(winAttr.visual);
2033 visualInfo = XGetVisualInfo(xGlobalDisplay, VisualIDMask, &template, &n);
2035 printf("XGetVisualInfo visual ID = %d\n", template.visualid);
2036 printf("visualInfo visual ID = %d\n", visualInfo->visualid);
2037 printf("oglSystem.visualInfo visual ID = %d\n", oglSystem.visualInfo->visualid);
2038 printf("((XWindowData)display.windowDriverData).visual visual ID = %d\n", ((XWindowData)display.windowDriverData).visual->visualid);
2040 // visualInfo = oglSystem.visualInfo;
2045 //printf("visualInfo is not null\n");
2046 // printf("Creating Display Context, sharing with %x!\n", oglSystem.glContext);
2047 oglDisplay.glContext = glXCreateContext(xGlobalDisplay, visualInfo, oglSystem.glContext, True);
2048 //XFree(visualInfo);
2051 // oglDisplay.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, oglSystem.glContext, True);
2052 if(oglDisplay.glContext)
2054 //printf("CreateDisplay Got a Context\n");
2055 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2061 #if defined(__WIN32__) || defined(USEPBUFFER)
2067 #if defined(__WIN32__)
2068 if(glBlendFuncSeparate)
2069 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2071 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2073 #if !defined(__OLDX__)
2074 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2076 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2081 glMatrixMode(GL_MODELVIEW);
2082 glScaled(1.0, 1.0, -1.0);
2083 // glTranslatef(0.375f, 0.375f, 0.0f);
2084 // glTranslatef(-0.625f, -0.625f, 0.0f);
2085 glMatrixMode(GL_PROJECTION);
2086 glShadeModel(GL_FLAT);
2088 // glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, true);
2089 #if !defined(EM_MODE)
2090 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
2092 glFogi(GL_FOG_MODE, GL_EXP);
2093 glFogf(GL_FOG_DENSITY, 0);
2094 glEnable(GL_NORMALIZE);
2095 glDepthFunc(GL_LESS);
2097 glDisable(GL_MULTISAMPLE_ARB);
2099 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
2100 display.ambient = Color { 50,50,50 };
2103 if(!useSingleGLContext)
2105 #if defined(__WIN32__)
2106 wglMakeCurrent(null, null);
2107 #elif defined(__unix__) || defined(__APPLE__)
2108 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2111 glXMakeCurrent(xGlobalDisplay, None, null);
2117 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2125 bool DisplaySize(Display display, int width, int height)
2127 OGLDisplay oglDisplay = display.driverData;
2129 bool result = false;
2131 //printf("Inside DisplaySize\n");
2132 #if defined(__WIN32__) || defined(USEPBUFFER)
2133 OGLSystem oglSystem = display.displaySystem.driverData;
2134 if(display.alphaBlend)
2136 #if defined(__WIN32__)
2137 const int attributes[]=
2139 /*WGL_TEXTURE_FORMAT_ARB, WGL_TEXTURE_RGBA_ARB,
2140 WGL_TEXTURE_TARGET_ARB, WGL_TEXTURE_2D_ARB, */0
2142 int pixelFormat = 0;
2143 if(wglChoosePixelFormatARB)
2147 float fAttributes[] = {0,0};
2150 //WGL_DRAW_TO_BITMAP_ARB, GL_TRUE,
2151 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2152 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2153 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
2154 WGL_COLOR_BITS_ARB,24,
2155 WGL_ALPHA_BITS_ARB,8,
2156 WGL_DEPTH_BITS_ARB,16,
2157 WGL_STENCIL_BITS_ARB,0,
2158 WGL_DOUBLE_BUFFER_ARB,GL_FALSE,
2159 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
2160 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
2164 //Log("Found wglChoosePixelFormatARB\n");
2166 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2167 if(!valid || !numFormats)
2169 //Log("Can't find 4x multi sampling\n");
2170 iAttributes[19] = 2;
2171 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2172 if(!valid || !numFormats)
2174 // Log("Can't find 2x multi sampling\n");
2175 iAttributes[16] = 0;
2176 iAttributes[17] = 0;
2177 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2178 if(!valid || !numFormats)
2182 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2183 //WGL_DRAW_TO_BITMAP_ARB,GL_TRUE,
2184 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2185 WGL_COLOR_BITS_ARB,24,
2186 WGL_ALPHA_BITS_ARB,8,
2187 WGL_DEPTH_BITS_ARB,16,
2190 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2194 if(valid && numFormats)
2196 wglMakeCurrent(null, null);
2200 wglMakeCurrent( null, null );
2201 wglMakeCurrent( oglDisplay.hdc, oglDisplay.glrc );
2202 if(oglDisplay.hdc && oglDisplay.pBuffer)
2203 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
2205 wglDestroyPbufferARB(oglDisplay.pBuffer);
2207 if(!useSingleGLContext)
2208 wglMakeCurrent( null, null );
2211 wglDeleteContext(oglDisplay.glrc);
2213 oglDisplay.pBuffer = wglCreatePbufferARB(oglSystem.hdc, pixelFormat, width, height, attributes);
2214 oglDisplay.hdc = wglGetPbufferDCARB(oglDisplay.pBuffer);
2215 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
2218 HDC hdc = GetDC(display.window);
2220 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2221 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2223 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_WIDTH_ARB, &width);
2224 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_HEIGHT_ARB, &height);
2226 // glDeleteBuffersARB(2, oglDisplay.imageBuffers);
2228 if((info = (BITMAPINFO *)new0 byte[sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*256]))
2232 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
2233 oglDisplay.memDC = CreateCompatibleDC(hdc);
2234 SetMapMode(oglDisplay.memDC, MM_TEXT);
2235 info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2236 info->bmiHeader.biPlanes = 1;
2237 info->bmiHeader.biCompression = BI_RGB;
2238 info->bmiHeader.biBitCount = 32; //(uint16)GetDeviceCaps(hdc, BITSPIXEL);
2239 info->bmiHeader.biWidth = width;
2240 info->bmiHeader.biHeight = height;
2241 newBitmap = CreateDIBSection(hdc, info, DIB_RGB_COLORS, &oglDisplay.picture, null, 0);
2244 SelectObject(oglDisplay.memDC, newBitmap);
2245 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
2248 PIXELFORMATDESCRIPTOR pfd = { 0 };
2249 pfd.nSize = (short)sizeof(pfd);
2251 pfd.dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL;
2252 pfd.iPixelType = PFD_TYPE_RGBA;
2253 pfd.cColorBits = 32;
2254 //pfd.cAlphaBits = 8;
2255 pfd.cDepthBits = 24;
2256 pfd.iLayerType = PFD_MAIN_PLANE;
2258 oglDisplay.hdc = oglDisplay.memDC;
2260 pixelFormat = ChoosePixelFormat(oglSystem.hdc, &pfd);
2261 DescribePixelFormat(oglDisplay.hdc, pixelFormat, sizeof(pfd), &pfd);
2262 SetPixelFormat(oglDisplay.hdc, pixelFormat, &pfd);
2264 oglDisplay.glrc = wglCreateContext(oglDisplay.hdc);
2265 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2266 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2271 const int imageSize = width * height * 4;
2273 glGenBuffersARB(2, oglDisplay.imageBuffers);
2275 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2276 glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize, null, GL_STREAM_READ);
2277 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2278 // glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize / 2, null, GL_STREAM_READ);
2281 oglDisplay.memBitmap = newBitmap;
2282 oglDisplay.stride = width;
2288 ReleaseDC(display.window, hdc);
2290 #elif defined(__unix__) || defined(__APPLE__)
2291 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2296 GLX_DOUBLEBUFFER, True,
2302 GLX_STENCIL_SIZE, 1,
2303 //GLX_DEPTH_SIZE, 24,
2304 GLX_RENDER_TYPE, GLX_RGBA_BIT,
2305 GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT | GLX_WINDOW_BIT,
2311 GLX_PBUFFER_WIDTH, width,
2312 GLX_PBUFFER_HEIGHT, height,
2313 GLX_LARGEST_PBUFFER, False,
2317 // choose a pixel format that meets our minimum requirements
2320 GLXFBConfig *config = glXChooseFBConfig(xGlobalDisplay, DefaultScreen(xGlobalDisplay), attrib, &count);
2323 if(oglDisplay.pixmap)
2325 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2326 oglDisplay.pixmap = None;
2328 if(oglDisplay.shapePixmap)
2330 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
2331 oglDisplay.shapePixmap = None;
2334 // Free Shared Memory Pixmap
2335 if(oglDisplay.image)
2337 if(oglDisplay.shminfoShape.shmid != -1)
2339 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
2340 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2341 shmdt(oglDisplay.shminfo.shmaddr);
2342 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
2344 XDestroyImage(oglDisplay.image);
2345 oglDisplay.image = None;
2347 if(oglDisplay.shapeImage)
2349 if(oglDisplay.shminfoShape.shmid != -1)
2351 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
2352 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2353 shmdt(oglDisplay.shminfoShape.shmaddr);
2354 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
2356 XDestroyImage(oglDisplay.shapeImage);
2357 oglDisplay.shapeImage = None;
2360 if(oglDisplay.windowPicture)
2361 XRenderFreePicture(xGlobalDisplay, oglDisplay.windowPicture);
2362 if(oglDisplay.pixmapPicture)
2363 XRenderFreePicture(xGlobalDisplay, oglDisplay.pixmapPicture);
2365 if(oglDisplay.pixmap)
2366 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2368 if(oglDisplay.glContext)
2369 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
2370 if(oglDisplay.pBuffer)
2371 glXDestroyPbuffer(xGlobalDisplay, oglDisplay.pBuffer);
2373 oglDisplay.pBuffer = glXCreatePbuffer(xGlobalDisplay, config[0], PBattrib);
2374 if(oglDisplay.pBuffer)
2376 oglDisplay.glContext = glXCreateNewContext(xGlobalDisplay, config[0], GLX_RGBA_TYPE, oglSystem.glContext, True);
2377 if(oglDisplay.glContext)
2379 glXMakeCurrent(xGlobalDisplay, None, null);
2380 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2382 // Initialize Shared Memory Pixmap
2383 oglDisplay.image = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 32,
2384 ZPixmap, null, &oglDisplay.shminfo, width, height);
2385 if(oglDisplay.image)
2387 oglDisplay.shminfo.shmid = shmget(IPC_PRIVATE,
2388 oglDisplay.image->bytes_per_line * oglDisplay.image->height, IPC_CREAT|0777);
2389 if(oglDisplay.shminfo.shmid != -1)
2391 oglDisplay.shminfo.shmaddr = shmat(oglDisplay.shminfo.shmid, 0, 0);
2392 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2394 oglDisplay.shminfo.readOnly = False;
2395 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfo))
2397 oglDisplay.pixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfo.shmaddr,
2398 &oglDisplay.shminfo, width, height, 32);
2400 // Initialize Shared Memory Shape Pixmap
2401 oglDisplay.shapeImage = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 1,
2402 ZPixmap, null, &oglDisplay.shminfoShape, width, height);
2403 if(oglDisplay.shapeImage)
2405 oglDisplay.shminfoShape.shmid = shmget(IPC_PRIVATE,
2406 oglDisplay.shapeImage->bytes_per_line * oglDisplay.shapeImage->height, IPC_CREAT|0777);
2407 if(oglDisplay.shminfoShape.shmid != -1)
2409 oglDisplay.shminfoShape.shmaddr = shmat(oglDisplay.shminfoShape.shmid, 0, 0);
2410 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2412 oglDisplay.shminfoShape.readOnly = False;
2413 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfoShape))
2415 oglDisplay.shapePixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfoShape.shmaddr,
2416 &oglDisplay.shminfoShape, width, height, 1);
2417 //oglDisplay.shapePixmap = XCreatePixmap(xGlobalDisplay, (X11Window)display.window, width, height, 1);
2420 XRenderPictureAttributes attributes = { 0 };
2421 XRenderPictFormat * format = XRenderFindStandardFormat(xGlobalDisplay, /*PictStandardRGB24*/ PictStandardARGB32);
2422 #if !defined(__APPLE__) && !defined(__OLDX__)
2423 attributes.repeat = RepeatNormal;
2425 attributes.repeat = 1;
2427 oglDisplay.pixmapPicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.pixmap, format, CPRepeat, &attributes);
2428 oglDisplay.windowPicture = XRenderCreatePicture(xGlobalDisplay, (X11Window)display.window, format, 0, &attributes);
2429 oglDisplay.shapePicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.shapePixmap,
2430 XRenderFindStandardFormat(xGlobalDisplay, PictStandardA1), 0, &attributes);
2433 oglDisplay.picture = oglDisplay.shminfo.shmaddr;
2434 oglDisplay.stride = oglDisplay.image->bytes_per_line / 4;
2451 CreateDisplay(display);
2452 #if defined(__WIN32__)
2453 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2454 #elif defined(__unix__) || defined(__APPLE__)
2455 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2459 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2466 if(!result && display.alphaBlend)
2468 printf("Alpha blending windows not supported on this display\n");
2475 glViewport(0,0,width,height);
2477 glOrtho(0,width,height,0,0.0,1.0);
2478 displayWidth = display.width = width;
2479 displayHeight = display.height = height;
2481 if(!oglDisplay.flippingBuffer || oglDisplay.flipBufW < width || oglDisplay.flipBufH < height)
2483 oglDisplay.flipBufW = width;
2484 oglDisplay.flipBufH = height;
2488 oglDisplay.flippingBuffer = renew oglDisplay.flippingBuffer ColorAlpha [width * height];
2491 if(oglDisplay.flippingBuffer || !width || !height)
2497 void DisplayPosition(Display display, int x, int y)
2499 OGLDisplay oglDisplay = display.driverData;
2505 void SetPalette(Display display, ColorAlpha * palette, bool colorMatch)
2509 void RestorePalette(Display display)
2513 void StartUpdate(Display display)
2517 void EndUpdate(Display display)
2521 void Scroll(Display display, Box scroll, int x, int y, Extent dirty)
2525 void Update(Display display, Box updateBox)
2527 #if defined(__WIN32__) || defined(USEPBUFFER)
2528 OGLDisplay oglDisplay = display.driverData;
2530 //Logf("DisplayScreen\n");
2534 #if defined(__WIN32__) || defined(USEPBUFFER)
2535 if(display.alphaBlend)
2537 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2538 glPixelStorei(GL_PACK_ROW_LENGTH, oglDisplay.stride);
2539 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2540 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2541 glReadPixels(0,0,display.width,display.height,GL_BGRA_EXT,GL_UNSIGNED_BYTE, oglDisplay.picture);
2544 #if defined(__WIN32__)
2546 POINT point = { oglDisplay.x, oglDisplay.y};
2547 POINT srcPoint = { 0, 0 };
2548 BLENDFUNCTION blend = { 0 };
2550 size.cx = display.width;
2551 size.cy = display.height;
2552 blend.BlendOp = AC_SRC_OVER;
2553 blend.BlendFlags = 0;
2554 blend.SourceConstantAlpha = 255;
2555 blend.AlphaFormat = AC_SRC_ALPHA;
2558 // Process partial images. Mapping the buffer waits for
2559 // outstanding DMA transfers into the buffer to finish.
2560 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2561 oglDisplay.pboMemory1 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY);
2563 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2564 // oglDisplay.pboMemory2 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB,GL_READ_ONLY);
2567 memcpy(oglDisplay.picture, oglDisplay.pboMemory1, display.width * display.height * 4);
2568 //memcpy(oglDisplay.picture + display.width * display.height * 4 / 2, oglDisplay.pboMemory2, display.width * display.height * 4/ 2);
2571 UpdateLayeredWindow(display.window, hdc, &point, &size, oglDisplay.memDC, &srcPoint, 0, &blend, ULW_ALPHA);
2574 // Unmap the image buffers
2575 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2576 glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2578 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2579 // glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2581 // Bind two different buffer objects and start the glReadPixels
2582 // asynchronously. Each call will return directly after
2583 // starting the DMA transfer.
2584 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2585 glReadPixels(0, 0, display.width, display.height, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2587 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2588 // glReadPixels(0, display.height/2, display.width, display.height/2, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2592 #elif defined(__unix__) || defined(__APPLE__)
2593 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2595 XTransform transform =
2598 { (int)(1.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(0 * (1 << 16)) },
2599 { (int)(0.0f), (int)(-1.0f * (1<<16)), (int)(0 * (1<<16)) },
2600 { (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)) }
2603 XRenderSetPictureTransform(xGlobalDisplay, oglDisplay.pixmapPicture, &transform);
2604 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.shapePicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2605 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.windowPicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2606 #if !defined(__APPLE__) && !defined(__OLDX__)
2607 XShapeCombineMask(xGlobalDisplay, (X11Window)display.window, ShapeInput, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2609 XShapeCombineMask(xGlobalDisplay, display.window, 2, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2611 XFlush(xGlobalDisplay);
2619 #if defined(__WIN32__)
2620 //wglSwapLayerBuffers(oglDisplay.hdc,WGL_SWAP_MAIN_PLANE);
2621 SwapBuffers(oglDisplay.hdc);
2622 #elif defined(__unix__) || defined(__APPLE__)
2623 #if defined(__ANDROID__) || defined(__ODROID__)
2624 eglSwapBuffers(eglDisplay, eglSurface);
2625 #elif defined(__EMSCRIPTEN__)
2628 glXSwapBuffers(xGlobalDisplay, (GLXDrawable)display.window);
2632 //Logf("Out of DisplayScreen\n");
2635 void FreeBitmap(DisplaySystem displaySystem, Bitmap bitmap)
2637 if(bitmap.driverData)
2639 GLuint tex = (GLuint)(uintptr)bitmap.driverData;
2640 glDeleteTextures(1, &tex);
2641 bitmap.driverData = 0;
2643 bitmap.driver = ((subclass(DisplayDriver))class(LFBDisplayDriver));
2646 bool AllocateBitmap(DisplaySystem displaySystem, Bitmap bitmap, int width, int height, int stride, PixelFormat format, bool allocatePalette)
2648 OGLSystem oglSystem = displaySystem.driverData;
2649 bool result = false;
2651 GLuint glBitmap = 0;
2653 uint w = width, h = height;
2654 if(oglSystem.pow2textures)
2659 w = Min(w, oglSystem.maxTextureSize);
2660 h = Min(h, oglSystem.maxTextureSize);
2662 glGenTextures(1, &glBitmap);
2663 glBindTexture(GL_TEXTURE_2D, glBitmap);
2665 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2667 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2668 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2670 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2671 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2673 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2675 mipMap.Allocate(null, w, h, w, pixelFormatRGBA, false);
2677 // glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2678 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2682 bitmap.driverData = (void *)(uintptr)glBitmap;
2683 bitmap.driver = displaySystem.driver;
2691 bool MakeDDBitmap(DisplaySystem displaySystem, Bitmap bitmap, bool mipMaps)
2693 bool result = false;
2694 OGLSystem oglSystem = displaySystem.driverData;
2695 Bitmap convBitmap = bitmap;
2699 convBitmap.Copy(bitmap);
2702 // Pre process the bitmap... First make it 32 bit
2703 if(/*bitmap.pixelFormat == pixelFormatRGBA || */convBitmap.Convert(null, pixelFormat888, null))
2706 uint w = bitmap.width, h = bitmap.height;
2707 GLuint glBitmap = 0;
2708 if(oglSystem.pow2textures)
2713 w = Min(w, oglSystem.maxTextureSize);
2714 h = Min(h, oglSystem.maxTextureSize);
2718 while(w * 2 < h) w *= 2;
2719 while(h * 2 < w) h *= 2;
2722 // Switch ARGB to RGBA
2723 //if(bitmap.format != pixelFormatRGBA)
2725 for(c=0; c<bitmap.size; c++)
2727 // ((ColorRGBA *)bitmap.picture)[c] = ((ColorAlpha *)bitmap.picture)[c];
2729 ColorAlpha color = ((ColorAlpha *)convBitmap.picture)[c];
2730 ((ColorRGBA *)convBitmap.picture)[c] = ColorRGBA { color.color.r, color.color.g, color.color.b, color.a };
2733 // convBitmap.pixelFormat = pixelFormat888;
2736 glGenTextures(1, &glBitmap);
2739 //int error = glGetError();
2743 glBindTexture(GL_TEXTURE_2D, glBitmap);
2744 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2746 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2747 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mipMaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
2748 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2750 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
2751 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
2753 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2754 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2756 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2760 for(level = 0; result && (w > 1 || h > 1); level++, w >>= 1, h >>= 1)
2763 if(bitmap.width != w || bitmap.height != h)
2765 mipMap = Bitmap { };
2766 if(mipMap.Allocate(null, w, h, w, convBitmap.pixelFormat, false))
2768 Surface mipSurface = mipMap.GetSurface(0,0,null);
2769 mipSurface.Filter(convBitmap, 0,0,0,0, w, h, convBitmap.width, convBitmap.height);
2779 mipMap = convBitmap;
2786 // glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2787 glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2788 //printf("Calling glTexImage2D\n");
2789 //glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &width);
2790 //printf("width = %d (Should be %d, %d)\n", width, w, h);
2791 if((error = glGetError()))
2793 //Logf("OpenGL Bitmap MakeDD error: %d...\n", error);
2794 //printf("OpenGL Bitmap MakeDD error: %d...\n", error);
2798 if(mipMap != convBitmap)
2803 convBitmap.driver.FreeBitmap(convBitmap.displaySystem, convBitmap);
2804 bitmap.driverData = (void *)(uintptr)glBitmap;
2805 bitmap.driver = displaySystem.driver;
2810 FreeBitmap(displaySystem, bitmap);
2811 else if(oglSystem.loadingFont)
2813 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2814 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2815 oglSystem.loadingFont = false;
2821 void ReleaseSurface(Display display, Surface surface)
2823 glDisable(GL_SCISSOR_TEST);
2824 delete surface.driverData;
2825 surface.driverData = null;
2828 bool GetBitmapSurface(DisplaySystem displaySystem, Surface surface, Bitmap bitmap, int x, int y, Box clip)
2833 bool GetSurface(Display display, Surface surface, int x,int y, Box clip)
2835 bool result = false;
2836 OGLSurface oglSurface = surface.driverData = OGLSurface { };
2838 //Logf("GetSurface\n");
2842 if(displayWidth != display.width || displayHeight != display.height)
2844 displayWidth = display.width;
2845 displayHeight = display.height;
2847 glViewport(0,0,display.width,display.height);
2849 glOrtho(0,display.width,display.height,0,0.0,1.0);
2852 surface.offset.x = x;
2853 surface.offset.y = y;
2854 surface.unclippedBox = surface.box = clip;
2855 oglSurface.bitmapMult[0] = 1;
2856 oglSurface.bitmapMult[1] = 1;
2857 oglSurface.bitmapMult[2] = 1;
2858 oglSurface.bitmapMult[3] = 1;
2860 glEnable(GL_SCISSOR_TEST);
2863 (display.height) -(y+clip.bottom)-1,
2864 clip.right-clip.left+1,
2865 clip.bottom-clip.top+1);
2871 void Clip(Display display, Surface surface, Box clip)
2880 box.Clip(surface.unclippedBox);
2884 box = surface.box = surface.unclippedBox;
2885 box.left += surface.offset.x;
2886 box.top += surface.offset.y;
2887 box.right+= surface.offset.x;
2888 box.bottom += surface.offset.y;
2891 box.left,display.height - box.bottom - 1,
2892 box.right-box.left+1, box.bottom-box.top+1);
2895 bool GrabScreen(Display display, Bitmap bitmap, int x, int y, unsigned int w, unsigned int h)
2897 bool result = false;
2898 OGLDisplay oglDisplay = display.driverData;
2899 ColorAlpha * flippingBuffer = oglDisplay.flippingBuffer;
2901 if(oglDisplay.flippingBuffer)
2903 if(bitmap.pixelFormat != pixelFormat888 || bitmap.width < w || bitmap.height < h)
2906 bitmap.Allocate(null, w,h,w, pixelFormat888, false);
2912 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2913 glPixelStorei(GL_PACK_ROW_LENGTH, bitmap.stride);
2914 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2915 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2916 glReadPixels(x,display.height-h-y,w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, flippingBuffer);
2919 for(row = 0; row<h; row++)
2920 CopyBytesBy4(((ColorAlpha *)bitmap.picture) + row * w, ((ColorAlpha *)flippingBuffer) + (h-row-1) * w, w);
2927 void SetForeground(Display display, Surface surface, ColorAlpha color)
2929 OGLSurface oglSurface = surface.driverData;
2931 //Logf("SetForeground\n");
2933 oglSurface.foreground[0] = color.color.r/255.0f;
2934 oglSurface.foreground[1] = color.color.g/255.0f;
2935 oglSurface.foreground[2] = color.color.b/255.0f;
2936 //oglSurface.foreground[3] = 1.0f;
2937 oglSurface.foreground[3] = color.a/255.0f;
2939 //if(!oglSurface.foreground[3])printf("bug");
2942 void SetBackground(Display display, Surface surface, ColorAlpha color)
2944 OGLSurface oglSurface = surface.driverData;
2946 //Logf("SetBackground\n");
2948 oglSurface.background[0] = color.color.r/255.0f;
2949 oglSurface.background[1] = color.color.g/255.0f;
2950 oglSurface.background[2] = color.color.b/255.0f;
2951 //oglSurface.background[3] = 1.0;
2952 oglSurface.background[3] = color.a/255.0f;
2955 void SetBlitTint(Display display, Surface surface, ColorAlpha color)
2957 OGLSurface oglSurface = surface.driverData;
2959 oglSurface.bitmapMult[0] = color.color.r/255.0f;
2960 oglSurface.bitmapMult[1] = color.color.g/255.0f;
2961 oglSurface.bitmapMult[2] = color.color.b/255.0f;
2962 oglSurface.bitmapMult[3] = color.a/255.0f;
2965 ColorAlpha GetPixel(Display display, Surface surface,int x,int y)
2970 void PutPixel(Display display, Surface surface,int x,int y)
2972 OGLSurface oglSurface = surface.driverData;
2974 //Logf("PutPixel\n");
2976 glColor4fv(oglSurface.foreground);
2978 // glVertex2i(x+surface.offset.x, y+surface.offset.y);
2979 glVertex2f(x+surface.offset.x + 0.5f, y+surface.offset.y + 0.5f);
2984 void DrawLine(Display display, Surface surface, int _x1, int _y1, int _x2, int _y2)
2986 OGLSurface oglSurface = surface.driverData;
2987 float x1 = _x1, x2 = _x2, y1 = _y1, y2 = _y2;
3002 x1 += surface.offset.x;
3003 y1 += surface.offset.y;
3004 x2 += surface.offset.x;
3005 y2 += surface.offset.y;
3009 glColor4fv(oglSurface.foreground);
3011 #if defined(_GLES) || defined(EM_MODE)
3014 glTexCoord2f(0.5f, 0);
3015 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3016 glTexCoord2f(Max(x2-x1, y2-y1) + 0.5f, 0);
3017 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3026 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3027 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3033 void Rectangle(Display display, Surface surface,int x1,int y1,int x2,int y2)
3035 OGLSurface oglSurface = surface.driverData;
3036 x1 += surface.offset.x;
3037 y1 += surface.offset.y;
3038 x2 += surface.offset.x;
3039 y2 += surface.offset.y;
3041 //Logf("Rectangle\n");
3043 glColor4fv(oglSurface.foreground);
3044 #if defined(_GLES) || defined(EM_MODE)
3049 glTexCoord2f(0.5f, 0);
3050 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3051 glTexCoord2f(y2-y1 + 0.5f, 0);
3052 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3054 glTexCoord2f(0.5f, 0);
3055 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3056 glTexCoord2f(x2 - x1 + 0.5f, 0);
3057 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3059 glTexCoord2f(0.5f, 0);
3060 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3061 glTexCoord2f(y1 - y2 + 0.5f, 0);
3062 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3064 glTexCoord2f(0.5f, 0);
3065 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3066 glTexCoord2f(x1 - x2 + 0.5f, 0);
3067 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3072 glBegin(GL_LINE_LOOP);
3079 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3080 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3081 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3082 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3087 void Area(Display display, Surface surface,int x1,int y1,int x2,int y2)
3089 OGLSurface oglSurface = surface.driverData;
3092 glColor4fv(oglSurface.background);
3096 glVertex2f(x1+surface.offset.x, y1+surface.offset.y);
3097 glVertex2f(x1+surface.offset.x, y2+surface.offset.y+1);
3098 glVertex2f(x2+surface.offset.x+1, y2+surface.offset.y+1);
3099 glVertex2f(x2+surface.offset.x+1, y1+surface.offset.y);
3102 glRecti(x1+surface.offset.x, y1+surface.offset.y,
3103 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
3106 glRectf(x1+surface.offset.x, y1+surface.offset.y,
3107 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
3111 void Clear(Display display, Surface surface, ClearType type)
3113 OGLDisplay oglDisplay = display.driverData;
3114 OGLSurface oglSurface = surface.driverData;
3117 if(type != depthBuffer)
3118 glClearColor(oglSurface.background[0], oglSurface.background[1], oglSurface.background[2], oglSurface.background[3]);
3119 if(type != colorBuffer && !oglDisplay.depthWrite)
3121 glDepthMask((byte)bool::true);
3123 glClear(((type != depthBuffer) ? GL_COLOR_BUFFER_BIT : 0) |
3124 ((type != colorBuffer) ? GL_DEPTH_BUFFER_BIT : 0));
3125 if(type != colorBuffer && !oglDisplay.depthWrite)
3127 glDepthMask((byte)bool::false);
3131 bool ConvertBitmap(DisplaySystem displaySystem, Bitmap bitmap, PixelFormat format, ColorAlpha * palette)
3136 void Blit(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3138 OGLSurface oglSurface = surface.driverData;
3140 #if !defined(__OLDX__)
3141 // WHY DO WE HAVE GL_ONE HERE ?
3142 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3143 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3146 if(!oglSurface.writingText)
3148 // glTranslatef(-0.375f, -0.375f, 0.0f);
3149 glEnable(GL_TEXTURE_2D);
3150 glColor4fv(oglSurface.bitmapMult);
3152 else if(oglSurface.xOffset)
3153 glTranslated(oglSurface.xOffset / 64.0/*-0.375*/, 0.0, 0.0);
3155 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3160 glTexCoord2f((float)sx/ bitmap.width, (float)(sy-h)/ bitmap.height);
3161 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3162 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy-h)/ bitmap.height);
3163 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3164 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3165 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
3166 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3167 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3172 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3173 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3174 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3175 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3176 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3177 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3178 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3179 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3182 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3183 glVertex2f((float)dx+surface.offset.x, (float)dy+surface.offset.y);
3184 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3185 glVertex2f((float)dx+w+surface.offset.x, (float)dy+surface.offset.y);
3186 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3187 glVertex2f((float)dx+w+surface.offset.x, (float)dy+h+surface.offset.y);
3188 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3189 glVertex2f((float)dx+surface.offset.x, (float)dy+h+surface.offset.y);
3193 if(!oglSurface.writingText)
3195 glDisable(GL_TEXTURE_2D);
3197 //glTranslate(0.375, 0.375, 0.0);
3199 else if(oglSurface.xOffset)
3200 glTranslated(-oglSurface.xOffset / 64.0/*+0.375*/, 0.0, 0.0);
3202 #if !defined(__OLDX__)
3203 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3204 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3208 void Stretch(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3210 OGLSurface oglSurface = surface.driverData;
3212 //glTranslate(-0.375, -0.375, 0.0);
3214 //Logf("Stretch\n");
3216 #if !defined(__OLDX__)
3217 /*if(glBlendFuncSeparate)
3218 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3221 glEnable(GL_TEXTURE_2D);
3222 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3224 glColor4fv(oglSurface.bitmapMult);
3230 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3231 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3233 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3234 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3236 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3237 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
3239 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3240 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3244 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3245 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3247 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3248 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3250 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3251 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3253 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3254 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3259 glDisable(GL_TEXTURE_2D);
3261 //glTranslate(0.375, 0.375, 0.0);
3262 #if !defined(__OLDX__)
3263 /*if(glBlendFuncSeparate)
3264 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3269 void Filter(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3271 Stretch(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3274 void StretchDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3276 #if !defined(EM_MODE)
3277 float s2dw,s2dh,d2sw,d2sh;
3278 //bool flipX = false, flipY = false;
3280 //Logf("StretchDI\n");
3282 if(Sgn(w) != Sgn(sw))
3288 if(Sgn(h) != Sgn(sh))
3300 //Clip against the edges of the source
3303 dx+=(int)((0-sx) * s2dw);
3304 w-=(int)((0-sx) * s2dw);
3310 dy+=(int)((0-sy) * s2dh);
3311 h-=(int)((0-sy) * s2dh);
3316 if(sx+sw>bitmap.width-1)
3318 w-=(int)((sx+sw-(bitmap.width-1)-1)*s2dw);
3319 sw-=sx+sw-(bitmap.width-1)-1;
3321 if(sy+sh>(bitmap.height-1))
3323 h-=(int)((sy+sh-(bitmap.height-1)-1)*s2dh);
3324 sh-=sy+sh-(bitmap.height-1)-1;
3326 //Clip against the edges of the surfaceination
3327 if(dx<surface.box.left)
3330 sx+=(int)((surface.box.left-dx)*d2sw);
3331 sw-=(int)((surface.box.left-dx)*d2sw);
3332 w-=surface.box.left-dx;
3333 dx=surface.box.left;
3335 if(dy<surface.box.top)
3337 sy+=(int)((surface.box.top-dy)*d2sh);
3338 sh-=(int)((surface.box.top-dy)*d2sh);
3339 h-=surface.box.top-dy;
3342 if(dx+w>surface.box.right)
3344 //if(flip) sx+=(int)((dx+w-surface.box.right-1)*d2sw);
3345 sw-=(int)((dx+w-surface.box.right-1)*d2sw);
3346 w-=dx+w-surface.box.right-1;
3348 if(dy+h>surface.box.bottom)
3350 sh-=(int)((dy+h-surface.box.bottom-1)*d2sh);
3351 h-=dy+h-surface.box.bottom-1;
3353 if((w<=0)||(h<=0)||(sw<=0)||(sh<=0)) return;
3355 dx += surface.offset.x;
3356 dy += surface.offset.y;
3358 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3360 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3361 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3362 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3363 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3364 glRasterPos2d(dx,dy);
3365 //glPixelZoom(flipX ? -s2dw : s2dw, flipY ? s2dh : -s2dh);
3366 glPixelZoom(s2dw, -s2dh);
3367 glDrawPixels(sw,sh,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3368 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3369 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3370 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3371 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3376 void BlitDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3378 #if !defined(EM_MODE)
3381 //Clip against the edges of the source
3394 if(sx+w>bitmap.width-1)
3395 w-=sx+w-(bitmap.width-1)-1;
3396 if(sy+h>bitmap.height-1)
3397 h-=sy+h-(bitmap.height-1)-1;
3398 //Clip against the edges of the surfaceination
3399 if(dx<surface.box.left)
3402 sx+=surface.box.left-dx;
3403 w-=surface.box.left-dx;
3404 dx=surface.box.left;
3406 if(dy<surface.box.top)
3408 sy+=surface.box.top-dy;
3409 h-=surface.box.top-dy;
3412 if(dx+w>surface.box.right)
3414 //if(flip) sx+=dx+w-surface.box.right-1;
3415 w-=dx+w-surface.box.right-1;
3417 if(dy+h>surface.box.bottom)
3418 h-=dy+h-surface.box.bottom-1;
3422 dx += surface.offset.x;
3423 dy += surface.offset.y;
3425 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3427 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3428 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3429 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3430 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3431 glRasterPos2d(dx,dy);
3433 glDrawPixels(w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3434 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3435 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3436 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3437 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3442 void FilterDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3444 StretchDI(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3447 void UnloadFont(DisplaySystem displaySystem, Font font)
3449 ((subclass(DisplayDriver))class(LFBDisplayDriver)).UnloadFont(displaySystem, font);
3452 Font LoadFont(DisplaySystem displaySystem, const char * faceName, float size, FontFlags flags)
3455 OGLSystem oglSystem = displaySystem.driverData;
3456 oglSystem.loadingFont = true;
3457 font = ((subclass(DisplayDriver))class(LFBDisplayDriver)).LoadFont(displaySystem, faceName, size, flags);
3461 void FontExtent(DisplaySystem displaySystem, Font font, const char * text, int len, int * width, int * height)
3463 ((subclass(DisplayDriver))class(LFBDisplayDriver)).FontExtent(displaySystem, font, text, len, width, height);
3466 void WriteText(Display display, Surface surface, int x, int y, const char * text, int len)
3468 OGLSurface oglSurface = surface.driverData;
3469 OGLSystem oglSystem = display.displaySystem.driverData;
3470 oglSystem.loadingFont = true;
3472 //glTranslated(-0.375, -0.375, 0.0);
3476 if(surface.textOpacity)
3479 FontExtent(display.displaySystem, surface.font, text, len, &w, &h);
3480 display.displaySystem.driver.Area(display, surface,x,y,x+w-1,y+h-1);
3483 oglSurface.writingText = true;
3485 glEnable(GL_TEXTURE_2D);
3487 if(surface.outline.size)
3489 ColorAlpha outlineColor = surface.outline.color;
3490 glColor4ub(outlineColor.color.r, outlineColor.color.g, outlineColor.color.b, outlineColor.a);
3491 //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3492 //glEnable(GL_BLEND);
3494 oglSurface.writingOutline = true;
3495 ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x, y, text, len);
3496 oglSurface.writingOutline = false;
3498 glColor4fv(oglSurface.foreground);
3500 ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x, y, text, len);
3501 oglSurface.writingText = false;
3502 oglSystem.loadingFont = false;
3504 glDisable(GL_TEXTURE_2D);
3506 //glTranslated(0.375, 0.375, 0.0);
3509 void TextFont(Display display, Surface surface, Font font)
3511 ((subclass(DisplayDriver))class(LFBDisplayDriver)).TextFont(display, surface, font);
3514 void TextOpacity(Display display, Surface surface, bool opaque)
3516 OGLSurface oglSurface = surface.driverData;
3517 oglSurface.opaqueText = opaque;
3520 void TextExtent(Display display, Surface surface, const char * text, int len, int * width, int * height)
3522 OGLSurface oglSurface = surface.driverData;
3523 OGLSystem oglSystem = display.displaySystem.driverData;
3524 oglSystem.loadingFont = true;
3525 FontExtent(display.displaySystem, oglSurface.font, text, len, width, height);
3526 oglSystem.loadingFont = false;
3529 void DrawingChar(Display display, Surface surface, char character)
3534 void LineStipple(Display display, Surface surface, uint32 stipple)
3536 //Logf("Stipple\n");
3540 #if defined(_GLES) || defined(EM_MODE)
3541 stippleEnabled = true;
3542 glesLineStipple(1, (uint16)stipple);
3544 glLineStipple(1, (uint16)stipple);
3545 glEnable(GL_LINE_STIPPLE);
3550 #if defined(_GLES) || defined(EM_MODE)
3551 stippleEnabled = false;
3552 glMatrixMode(GL_TEXTURE);
3554 glMatrixMode(GL_PROJECTION);
3555 glDisable(GL_TEXTURE_2D);
3557 glDisable(GL_LINE_STIPPLE);
3561 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
3562 void SetRenderState(Display display, RenderState state, uint value)
3564 OGLDisplay oglDisplay = display.driverData;
3565 //Logf("RenderState\n");
3571 glEnable(GL_MULTISAMPLE_ARB);
3573 glDisable(GL_MULTISAMPLE_ARB);
3577 glPolygonMode(GL_FRONT_AND_BACK, ((FillModeValue)value == solid) ? GL_FILL : GL_LINE);
3581 if(value) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
3584 if(value) glDepthMask((byte)bool::true); else glDepthMask((byte)bool::false);
3585 oglDisplay.depthWrite = (bool)value;
3589 float color[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3590 glFogfv(GL_FOG_COLOR, (float *)&color);
3594 glFogf(GL_FOG_DENSITY, (float)(RenderStateFloat { ui = value }.f * nearPlane));
3597 if(value) glEnable(GL_BLEND); else glDisable(GL_BLEND);
3601 #if !defined(EM_MODE)
3602 float ambient[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3603 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
3609 if(value) glColorMask(1,1,1,1); else glColorMask(1,1,1,0);
3614 #if defined(__WIN32__)
3615 wglSwapIntervalEXT(value ? 1 : 0);
3622 void SetLight(Display display, int id, Light light)
3624 #if !defined(EM_MODE)
3625 //Logf("SetLight\n");
3629 Object lightObject = light.lightObject;
3630 float position[4] = { 0, 0, 0, 0 };
3631 float color[4] = { 0, 0, 0, 1 };
3633 glEnable(GL_LIGHT0 + id);
3635 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, (float *)&light.diffuse);
3636 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, (float *)&light.ambient);
3637 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,(float *)&light.specular);
3640 if(!light.multiplier) light.multiplier = 1.0f;
3642 color[0] = light.diffuse.r * light.multiplier;
3643 color[1] = light.diffuse.g * light.multiplier;
3644 color[2] = light.diffuse.b * light.multiplier;
3645 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, color);
3647 color[0] = light.ambient.r * light.multiplier;
3648 color[1] = light.ambient.g * light.multiplier;
3649 color[2] = light.ambient.b * light.multiplier;
3650 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, color);
3651 color[0] = light.specular.r * light.multiplier;
3652 color[1] = light.specular.g * light.multiplier;
3653 color[2] = light.specular.b * light.multiplier;
3654 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,color);
3658 Vector3D positionVector;
3659 if(light.flags.spot)
3661 if(lightObject.flags.root || !lightObject.parent)
3663 positionVector = lightObject.transform.position;
3664 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3668 positionVector.MultMatrix(lightObject.transform.position, lightObject.parent.matrix);
3669 if(display.display3D.camera)
3670 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3676 if(!light.direction.x && !light.direction.y && !light.direction.z)
3678 Vector3Df vector { 0,0,-1 };
3680 mat.RotationQuaternion(light.orientation);
3681 positionVector.MultMatrixf(vector, mat);
3685 positionVector = light.direction;
3690 position[0] = (float)positionVector.x;
3691 position[1] = (float)positionVector.y;
3692 position[2] = (float)positionVector.z;
3694 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3697 // Display Light Position
3698 glDisable(GL_LIGHTING);
3699 glDisable(GL_DEPTH_TEST);
3703 glVertex3fv(position);
3705 glEnable(GL_DEPTH_TEST);
3706 glEnable(GL_LIGHTING);
3710 if(lightObject.flags.root || !lightObject.parent)
3712 positionVector = light.target.transform.position;
3713 positionVector.Subtract(positionVector, display.camera.cPosition);
3717 positionVector.MultMatrix(light.target.transform.position,
3718 lightObject.light.target.parent.matrix);
3719 positionVector.Subtract(positionVector, display.camera.cPosition);
3722 position[0] = positionVector.x;
3723 position[1] = positionVector.y;
3724 position[2] = positionVector.z;
3726 glDisable(GL_LIGHTING);
3727 glDisable(GL_DEPTH_TEST);
3731 glVertex3fv(position);
3733 glEnable(GL_DEPTH_TEST);
3734 glEnable(GL_LIGHTING);
3737 if(light.flags.attenuation)
3739 glLightf(GL_LIGHT0 + id, GL_CONSTANT_ATTENUATION, light.Kc);
3740 glLightf(GL_LIGHT0 + id, GL_LINEAR_ATTENUATION, light.Kl);
3741 glLightf(GL_LIGHT0 + id, GL_QUADRATIC_ATTENUATION, light.Kq);
3744 if(light.flags.spot)
3747 #define MAXLIGHT 0.9
3748 float direction[4] = { (float)light.direction.x, (float)light.direction.y, (float)light.direction.z, 1 };
3749 // Figure out exponent out of the hot spot
3750 exponent = (float)(log(MAXLIGHT) / log(cos((light.hotSpot / 2))));
3752 glLightfv(GL_LIGHT0 + id, GL_SPOT_DIRECTION, direction);
3753 glLightf(GL_LIGHT0 + id, GL_SPOT_CUTOFF, (float)(light.fallOff / 2));
3754 glLightf(GL_LIGHT0 + id, GL_SPOT_EXPONENT, exponent);
3760 Vector3Df vector { 0,0,-1 };
3761 Vector3Df direction;
3764 mat.RotationQuaternion(light.orientation);
3765 direction.MultMatrix(vector, mat);
3767 position[0] = direction.x;
3768 position[1] = direction.y;
3769 position[2] = direction.z;
3771 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3775 glDisable(GL_LIGHT0 + id);
3779 void SetCamera(Display display, Surface surface, Camera camera)
3781 OGLDisplay oglDisplay = display.driverData;
3782 //Logf("SetCamera\n");
3786 int left = surface.box.left + surface.offset.x;
3787 int top = surface.box.top + surface.offset.y;
3788 int right = surface.box.right + surface.offset.x;
3789 int bottom = surface.box.bottom + surface.offset.y;
3790 float origX = surface.offset.x + camera.origin.x;
3791 float origY = surface.offset.y + camera.origin.y;
3793 int y = display.height - bottom - 1;
3794 int w = right - left + 1;
3795 int h = bottom - top + 1;
3798 glViewport(x, y, w, h);
3800 // *** Projection Matrix ***
3801 if(!display.display3D.camera)
3803 glMatrixMode(GL_PROJECTION);
3807 glMatrixMode(GL_PROJECTION);
3808 if(display.display3D.collectingHits)
3810 float pickX = display.display3D.pickX + surface.offset.x;
3811 float pickY = display.height - (display.display3D.pickY + surface.offset.y) - 1;
3815 w / display.display3D.pickWidth, 0, 0, 0,
3816 0, h / display.display3D.pickHeight, 0, 0,
3818 (w + 2.0f * (x - pickX)) / display.display3D.pickWidth,
3819 (h + 2.0f * (y - pickY)) / display.display3D.pickHeight, 0, 1
3822 glLoadMatrixd(pickMatrix.array);
3827 (left - origX) * camera.zMin / camera.focalX,
3828 (right - origX) * camera.zMin / camera.focalX,
3829 (bottom - origY) * camera.zMin / camera.focalY,
3830 (top - origY) * camera.zMin / camera.focalY,
3831 camera.zMin, camera.zMax);
3833 glDisable(GL_BLEND);
3835 // *** Z Inverted Identity Matrix ***
3836 glMatrixMode(GL_MODELVIEW);
3837 if(!display.display3D.camera)
3842 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
3844 // *** View Matrix ***
3845 glMultMatrixd(camera.viewMatrix.array);
3850 glEnable(GL_DEPTH_TEST);
3851 //#if !defined(EM_MODE)
3852 glEnable(GL_LIGHTING);
3853 glShadeModel(GL_SMOOTH);
3855 glDepthMask((byte)bool::true);
3856 oglDisplay.depthWrite = true;
3858 glEnable(GL_MULTISAMPLE_ARB);
3860 else if(display.display3D.camera)
3862 oglDisplay.depthWrite = false;
3863 glViewport(0,0,display.width,display.height);
3865 glDisable(GL_CULL_FACE);
3866 glDisable(GL_DEPTH_TEST);
3867 glDisable(GL_LIGHTING);
3869 glDisable(GL_TEXTURE_2D);
3870 //#if !defined(EM_MODE)
3871 glShadeModel(GL_FLAT);
3874 glDisable(GL_MULTISAMPLE_ARB);
3876 // *** Restore 2D MODELVIEW Matrix ***
3879 // *** Restore 2D PROJECTION Matrix ***
3880 glMatrixMode(GL_PROJECTION);
3886 void ApplyMaterial(Display display, Material material, Mesh mesh)
3888 //Logf("ApplyMaterial\n");
3891 if(material.flags.doubleSided)
3893 #if !defined(EM_MODE)
3894 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, !material.flags.singleSideLight);
3896 glDisable(GL_CULL_FACE);
3900 #if !defined(EM_MODE)
3901 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, bool::false);
3903 glEnable(GL_CULL_FACE);
3907 if(material.flags.noFog)
3913 if(material.baseMap && (mesh.texCoords || mesh.flags.texCoords1))
3915 Bitmap map = material.baseMap;
3916 glEnable(GL_TEXTURE_2D);
3917 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)map.driverData);
3919 glMatrixMode(GL_TEXTURE);
3921 if(material.uScale && material.vScale)
3922 glScalef(material.uScale, material.vScale, 1);
3923 glMatrixMode(GL_MODELVIEW);
3925 if(material.flags.tile)
3927 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
3928 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
3932 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
3933 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
3937 glDisable(GL_TEXTURE_2D);
3940 glColor4f(material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity);
3942 if(mesh.flags.colors)
3944 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
3945 glEnable(GL_COLOR_MATERIAL);
3949 glDisable(GL_COLOR_MATERIAL);
3951 float color[4] = { material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity };
3952 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
3955 float color[4] = { material.ambient.r, material.ambient.g, material.ambient.b, 0 };
3956 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
3960 float color[4] = { material.specular.r, material.specular.g, material.specular.b, 0 };
3961 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, color);
3964 float color[4] = { material.emissive.r, material.emissive.g, material.emissive.b, 0 };
3965 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, color);
3968 glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &material.power);
3972 void FreeMesh(DisplaySystem displaySystem, Mesh mesh)
3974 OGLMesh oglMesh = mesh.data;
3977 if(!mesh.flags.vertices)
3979 oglMesh.vertices.free();
3980 delete mesh.vertices;
3982 if(!mesh.flags.normals)
3984 oglMesh.normals.free();
3985 delete mesh.normals;
3987 if(!mesh.flags.texCoords1)
3989 oglMesh.texCoords.free();
3990 delete mesh.texCoords;
3992 if(!mesh.flags.texCoords2)
3994 oglMesh.texCoords2.free();
3995 // delete mesh.texCoords2;
3997 if(!mesh.flags.colors)
3999 oglMesh.colors.free();
4010 bool AllocateMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags, int nVertices)
4012 bool result = false;
4015 mesh.data = OGLMesh { };
4018 if(mesh.nVertices == nVertices)
4020 // Same number of vertices, adding features (Leaves the other features pointers alone)
4021 if(mesh.flags != flags)
4023 if(!mesh.flags.vertices && flags.vertices)
4025 if(flags.doubleVertices)
4027 mesh.vertices = (Vector3Df *)new Vector3D[nVertices];
4030 mesh.vertices = new Vector3Df[nVertices];
4032 if(!mesh.flags.normals && flags.normals)
4034 if(flags.doubleNormals)
4036 mesh.normals = (Vector3Df *)new Vector3D[nVertices];
4039 mesh.normals = new Vector3Df[nVertices];
4041 if(!mesh.flags.texCoords1 && flags.texCoords1)
4043 mesh.texCoords = new Pointf[nVertices];
4045 if(!mesh.flags.colors && flags.colors)
4047 mesh.colors = new ColorRGBAf[nVertices];
4053 // New number of vertices, reallocate all current and new features
4054 flags |= mesh.flags;
4057 if(flags.doubleVertices)
4059 mesh.vertices = (Vector3Df *)renew mesh.vertices Vector3D[nVertices];
4062 mesh.vertices = renew mesh.vertices Vector3Df[nVertices];
4066 if(flags.doubleNormals)
4068 mesh.normals = (Vector3Df *)renew mesh.normals Vector3D[nVertices];
4071 mesh.normals = renew mesh.normals Vector3Df[nVertices];
4073 if(flags.texCoords1)
4075 mesh.texCoords = renew mesh.texCoords Pointf[nVertices];
4079 mesh.colors = renew mesh.colors ColorRGBAf[nVertices];
4087 void UnlockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
4089 OGLMesh oglMesh = mesh.data;
4090 if(!flags) flags = mesh.flags;
4095 oglMesh.vertices.upload(
4096 mesh.nVertices * (mesh.flags.doubleVertices ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.vertices); //, GL_STATIC_DRAW_ARB );
4099 oglMesh.normals.upload(
4100 mesh.nVertices * (mesh.flags.doubleNormals ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.normals); //, GL_STATIC_DRAW_ARB );
4102 if(flags.texCoords1)
4103 oglMesh.texCoords.upload(
4104 mesh.nVertices * sizeof(Pointf), mesh.texCoords); //, GL_STATIC_DRAW_ARB );
4107 oglMesh.colors.upload(
4108 mesh.nVertices * sizeof(ColorRGBAf), mesh.colors); //, GL_STATIC_DRAW_ARB );
4112 bool LockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
4119 void FreeIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4123 oglIndices.buffer.free();
4124 delete oglIndices.indices;
4129 void * AllocateIndices(DisplaySystem displaySystem, int nIndices, bool indices32bit)
4131 OGLIndices oglIndices = OGLIndices { };
4134 oglIndices.indices = (void *)(indices32bit ? new uint32[nIndices] : new uint16[nIndices]);
4135 oglIndices.nIndices = nIndices;
4140 void UnlockIndices(DisplaySystem displaySystem, OGLIndices oglIndices, bool indices32bit, int nIndices)
4144 oglIndices.buffer.upload(
4145 nIndices * (indices32bit ? sizeof(uint32) : sizeof(uint16)),
4146 oglIndices.indices); //GL_STATIC_DRAW_ARB);
4150 uint16 * LockIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4153 return oglIndices.indices;
4156 void SelectMesh(Display display, Mesh mesh)
4158 //Logf("SelectMesh\n");
4160 #if !defined( __ANDROID__) && !defined(__APPLE__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
4162 #if defined(__WIN32__)
4163 if(glUnlockArraysEXT)
4165 if(!vboAvailable && display.display3D.mesh)
4166 glUnlockArraysEXT();
4171 OGLMesh oglMesh = mesh.data;
4173 // *** Vertex Stream ***
4174 glEnableClientState(GL_VERTEX_ARRAY);
4175 if(!display.display3D.collectingHits && oglMesh)
4177 oglMesh.vertices.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, oglMesh.vertices.buffer ? null : (double *)mesh.vertices);
4179 // *** Normals Stream ***
4180 if(mesh.normals || mesh.flags.normals)
4182 glEnableClientState(GL_NORMAL_ARRAY);
4183 oglMesh.normals.use(normal, 3, GL_FLOAT, 0, oglMesh.normals.buffer ? null : mesh.normals);
4186 glDisableClientState(GL_NORMAL_ARRAY);
4188 // *** Texture Coordinates Stream ***
4189 if(mesh.texCoords || mesh.flags.texCoords1)
4191 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4192 oglMesh.texCoords.use(texCoord, 2, GL_FLOAT, 0, oglMesh.texCoords.buffer ? null : mesh.texCoords);
4195 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4197 // *** Color Stream ***
4198 if(mesh.colors || mesh.flags.colors)
4200 glEnableClientState(GL_COLOR_ARRAY);
4201 oglMesh.colors.use(color, 4, GL_FLOAT, 0, oglMesh.colors.buffer ? null : mesh.colors);
4204 glDisableClientState(GL_COLOR_ARRAY);
4208 noAB.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, (double *)mesh.vertices);
4209 if((mesh.normals || mesh.flags.normals) && !display.display3D.collectingHits)
4211 glEnableClientState(GL_NORMAL_ARRAY);
4212 noAB.use(normal, 3, GL_FLOAT, 0, mesh.normals);
4215 glDisableClientState(GL_NORMAL_ARRAY);
4216 if((mesh.texCoords || mesh.flags.texCoords1) && !display.display3D.collectingHits)
4218 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4219 noAB.use(texCoord, 2, GL_FLOAT, 0, mesh.texCoords);
4222 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4223 if((mesh.colors || mesh.flags.colors) && !display.display3D.collectingHits)
4225 glEnableClientState(GL_COLOR_ARRAY);
4226 noAB.use(color, 4, GL_FLOAT, 0, mesh.colors);
4229 glDisableClientState(GL_COLOR_ARRAY);
4232 #if !defined(__ANDROID__) && !defined(__APPLE__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
4234 #if defined(__WIN32__)
4238 glLockArraysEXT(0, mesh.nVertices);
4244 void DrawPrimitives(Display display, PrimitiveSingle * primitive, Mesh mesh)
4246 //Logf("DrawPrimitives\n");
4248 if(primitive->type.vertexRange)
4249 glDrawArrays(primitiveTypes[primitive->type.primitiveType], primitive->first, primitive->nVertices);
4252 // *** Hoping the data won't be uploaded at all (Won't really work if another group of the mesh is using the mesh ) ***
4253 // HACK TO SPEED THINGS UP...
4255 /*GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
4256 if(primitive->nIndices < (mesh.nVertices >> 2) && !primitive->type.indices32bit)
4259 glBegin(primitiveTypes[primitive->type.primitiveType]);
4262 OGLIndices oglIndices = primitive->data;
4263 MeshFeatures flags = mesh.flags;
4264 for(c = 0; c<primitive->nIndices; c++)
4266 uint16 index = ((uint16 *) oglIndices.indices)[c];
4267 if(flags.normals) glNormal3fv((float *)&mesh.normals[index]);
4268 if(flags.texCoords1) glTexCoord2fv((float *)&mesh.texCoords[index]);
4269 if(flags.colors) glColor4fv((float *)&mesh.colors[index]);
4270 glVertex3fv((float *)&mesh.vertices[index]);
4278 OGLIndices oglIndices = primitive->data;
4280 if(!display.display3D.collectingHits && vboAvailable && oglIndices)
4282 if(primitive->type.indices32bit)
4283 ; //oglIndices.buffer.draw(primitiveTypes[primitive->type.primitiveType], primitive->nIndices, GL_UNSIGNED_SHORT, 0);
4285 oglIndices.buffer.draw(primitiveTypes[primitive->type.primitiveType], primitive->nIndices, GL_UNSIGNED_SHORT, 0);
4289 if(primitive->type.indices32bit)
4290 glDrawElementsi(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
4291 oglIndices ? oglIndices.indices : primitive->indices);
4293 glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
4294 GL_UNSIGNED_SHORT, oglIndices ? oglIndices.indices : primitive->indices);
4300 void PushMatrix(Display display)
4305 void PopMatrix(Display display, bool setMatrix)
4310 void SetTransform(Display display, Matrix transMatrix, bool viewSpace, bool useCamera)
4312 Matrix matrix = transMatrix;
4313 Camera camera = useCamera ? display.display3D.camera : null;
4318 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
4323 matrix.m[3][0] - camera.cPosition.x,
4324 matrix.m[3][1] - camera.cPosition.y,
4325 matrix.m[3][2] - camera.cPosition.z);
4337 glMultMatrixd(matrix.array);
4342 public void UseSingleGLContext(bool useSingle)
4344 useSingleGLContext = useSingle;
4347 default dllexport void *
4348 #if defined(__WIN32__)
4349 __attribute__((stdcall))
4351 IS_GLGetContext(DisplaySystem displaySystem)
4355 #if defined(__WIN32__)
4356 OGLSystem system = displaySystem.driverData;
4358 #elif defined(__ANDROID__) || defined(__ODROID__)
4360 #elif defined(__EMSCRIPTEN__)
4362 OGLSystem system = displaySystem.driverData;
4363 return system.glContext;