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, this);
1354 if(curArrayBuffer != buffer)
1355 GLBindBuffer(GL_ARRAY_BUFFER, buffer);
1356 glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW); //GL_DYNAMIC_DRAW);
1364 GLDeleteBuffers(1, this);
1369 void use(GLBufferContents contents, int n, int type, uint stride, void * pointer)
1371 if(curArrayBuffer != ((this != null) ? buffer : 0))
1372 GLBindBuffer(GL_ARRAY_BUFFER, ((this != null) ? buffer : 0));
1375 case normal: glNormalPointer(type, stride, pointer); break;
1376 case vertex: glVertexPointer(n, type, stride, pointer); break;
1377 case texCoord: glTexCoordPointer(n, type, stride, pointer); break;
1378 case color: glColorPointer(n, type, stride, pointer); break;
1383 static uint curElementBuffer;
1385 public define noEAB = GLEAB { 0 };
1391 void upload(uint size, void * data)
1396 GLGenBuffers(1, (GLAB *)this);
1398 if(curElementBuffer != buffer)
1399 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
1400 glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, data, GL_STATIC_DRAW); //GL_DYNAMIC_DRAW);
1408 GLDeleteBuffers(1, (GLAB *)this);
1413 void draw(int primType, int count, int type, void * indices)
1415 if(curElementBuffer != ((this != null) ? buffer : 0))
1416 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ((this != null) ? buffer : 0));
1417 glDrawElements(primType, count, type, indices);
1421 public void GLGenBuffers(int count, GLAB * buffers)
1423 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
1424 glGenBuffers(count, (GLuint *)buffers);
1426 #if defined(__WIN32__)
1429 glGenBuffersARB(count, (GLuint *)buffers);
1433 public void GLDeleteBuffers(int count, GLAB * buffers)
1436 for(i = 0; i < count; i++)
1438 uint buffer = buffers[i].buffer;
1439 if(buffer == curArrayBuffer)
1440 GLBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
1441 else if(buffer == curElementBuffer)
1442 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
1444 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
1445 glDeleteBuffers(count, (GLuint *)buffers);
1447 #if defined(__WIN32__)
1448 if(glDeleteBuffersARB)
1450 glDeleteBuffersARB(count, (GLuint *)buffers);
1454 void GLBindBuffer(int target, uint buffer)
1456 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
1457 glBindBuffer(target, buffer);
1459 #if defined(__WIN32__)
1462 glBindBufferARB(target, buffer);
1464 if(target == GL_ARRAY_BUFFER_ARB)
1465 curArrayBuffer = buffer;
1466 else if(target == GL_ELEMENT_ARRAY_BUFFER_ARB)
1467 curElementBuffer = buffer;
1470 public void GLVertexPointer(int numCoords, int glType, int stride, void *ptr, int numVertices)
1473 if(glType == GL_DOUBLE)
1474 glesVertexPointerd(numCoords, stride, ptr, numVertices);
1475 else if(glType == GL_INT)
1476 glesVertexPointeri(numCoords, stride, ptr, numVertices);
1479 glVertexPointer(numCoords, glType, stride, ptr);
1482 public void GLBufferData(int type, GLenum target, int size, const GLvoid *data, GLenum usage)
1485 if(type == GL_DOUBLE)
1486 glesBufferDatad(target, size, (void *)data, usage);
1487 else if(type == GL_UNSIGNED_INT)
1488 glesBufferDatai(target, size, (void *)data, usage);
1492 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
1493 glBufferData(target, size, data, usage);
1496 #if defined(__WIN32__)
1499 glBufferDataARB(target, size, data, usage);
1503 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1504 static int primitiveTypes[RenderPrimitiveType] =
1506 GL_POINTS, GL_LINES, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP, GL_LINE_STRIP
1511 // Non OpenGL ES friendly stuff
1515 //#undef GL_UNSIGNED_INT
1520 #undef GL_QUAD_STRIP
1521 #undef GL_POLYGON_STIPPLE
1522 #undef GL_LINE_STIPPLE
1525 #undef GL_ALL_ATTRIB_BITS
1526 #undef GL_LIGHT_MODEL_LOCAL_VIEWER
1530 static int displayWidth, displayHeight;
1532 #define GL_CLAMP_TO_EDGE 0x812F
1534 static bool vboAvailable;
1536 static bool useSingleGLContext = false;
1537 class OGLDisplay : struct
1539 #if defined(__WIN32__)
1549 int imageBuffers[2];
1550 byte * pboMemory1, * pboMemory2;
1552 #elif !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
1553 GLXContext glContext;
1556 XShmSegmentInfo shminfo;
1558 XShmSegmentInfo shminfoShape;
1559 XImage * shapeImage;
1563 X11Picture windowPicture;
1564 X11Picture pixmapPicture;
1566 X11Picture shapePicture;
1569 ColorAlpha * flippingBuffer;
1570 int flipBufH, flipBufW;
1575 class OGLSystem : struct
1580 #if defined(__WIN32__)
1581 PIXELFORMATDESCRIPTOR pfd;
1586 #elif !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
1587 XVisualInfo * visualInfo;
1588 GLXContext glContext;
1589 GLXDrawable glxDrawable;
1593 class OGLSurface : struct
1599 bool writingOutline;
1601 float foreground[4], background[4], bitmapMult[4];
1604 class OGLMesh : struct
1613 class OGLIndices : struct
1623 class OpenGLDisplayDriver : DisplayDriver
1625 class_property(name) = "OpenGL";
1627 bool LockSystem(DisplaySystem displaySystem)
1629 #if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
1630 OGLSystem oglSystem = displaySystem.driverData;
1631 if(useSingleGLContext) return true;
1632 #if defined(__WIN32__)
1633 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1634 #elif defined(__unix__) || defined(__APPLE__)
1635 //if(previous) return true;
1636 // printf("Making SYSTEM current\n");
1637 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)oglSystem.glxDrawable, oglSystem.glContext);
1638 //previous = oglSystem.glContext;
1644 void UnlockSystem(DisplaySystem displaySystem)
1646 if(useSingleGLContext) return;
1647 #if defined(__WIN32__)
1648 wglMakeCurrent(null, null);
1649 #elif defined(__unix__) || defined(__APPLE__)
1650 // printf("Making NULL current\n");
1651 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
1653 glXMakeCurrent(xGlobalDisplay, None, null);
1659 bool Lock(Display display)
1661 #if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
1662 OGLDisplay oglDisplay = display.driverData;
1663 if(useSingleGLContext) return true;
1664 #if defined(__WIN32__)
1665 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1666 #elif defined(__unix__) || defined(__APPLE__)
1667 // if(previous) glXMakeCurrent(xGlobalDisplay, None, null);
1668 // printf(" Making DISPLAY current\n");
1669 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
1675 void Unlock(Display display)
1677 if(useSingleGLContext) return;
1678 //printf(" Making NULL current\n");
1679 //glXMakeCurrent(xGlobalDisplay, None, null);
1681 LockSystem(display.displaySystem);
1684 void DestroyDisplay(Display display)
1686 OGLDisplay oglDisplay = display.driverData;
1690 #if defined(__WIN32__)
1691 wglMakeCurrent( null, null );
1694 wglDeleteContext(oglDisplay.glrc);
1696 if(oglDisplay.hdc && oglDisplay.pBuffer)
1697 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
1699 if(oglDisplay.pBuffer)
1700 wglDestroyPbufferARB(oglDisplay.pBuffer);
1703 ReleaseDC(display.window, oglDisplay.hdc);
1705 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
1706 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
1708 #elif defined(__unix__) || defined(__APPLE__)
1709 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
1711 if(oglDisplay.shapePixmap)
1712 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
1713 if(oglDisplay.pixmap)
1714 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1715 if(oglDisplay.image)
1717 if(oglDisplay.shminfoShape.shmid != -1)
1719 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
1720 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1721 shmdt(oglDisplay.shminfo.shmaddr);
1722 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
1725 if(oglDisplay.shapeImage)
1727 if(oglDisplay.shminfoShape.shmid != -1)
1729 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
1730 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1731 shmdt(oglDisplay.shminfoShape.shmaddr);
1732 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
1734 XDestroyImage(oglDisplay.shapeImage);
1735 oglDisplay.shapeImage = None;
1738 glXMakeCurrent(xGlobalDisplay, None, null);
1740 if(oglDisplay.glContext)
1741 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
1744 delete oglDisplay.flippingBuffer;
1746 display.driverData = null;
1750 void ::CheckExtensions(OGLSystem oglSystem)
1752 const char * extensions = (const char *)glGetString(GL_EXTENSIONS);
1754 oglSystem.pow2textures = strstr(extensions, "GL_ARB_texture_non_power_of_two") ? false : true;
1755 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &oglSystem.maxTextureSize);
1758 bool CreateDisplaySystem(DisplaySystem displaySystem)
1760 bool result = false;
1761 OGLSystem oglSystem = displaySystem.driverData = OGLSystem { };
1764 oglSystem.hwnd = CreateWindow("static", null, 0,0,0,0,0,null,null,null,null);
1766 oglSystem.hdc = GetDC(oglSystem.hwnd);
1770 oglSystem.pfd.nSize = (short)sizeof(oglSystem.pfd);
1771 oglSystem.pfd.nVersion = 1;
1772 oglSystem.pfd.dwFlags = PFD_DRAW_TO_WINDOW /*PFD_DRAW_TO_BITMAP*/ | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
1773 oglSystem.pfd.iPixelType = PFD_TYPE_RGBA;
1774 oglSystem.pfd.cColorBits = 24;
1775 oglSystem.pfd.cAlphaBits = 8;
1776 oglSystem.pfd.cDepthBits = 24;
1777 oglSystem.pfd.iLayerType = PFD_MAIN_PLANE;
1779 oglSystem.format = ChoosePixelFormat(oglSystem.hdc, &oglSystem.pfd);
1780 DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1782 if(oglSystem.pfd.cColorBits > 8)
1784 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1785 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1788 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1790 // Get Pointers To The GL Functions
1791 glActiveTextureARB = (void *) wglGetProcAddress("glActiveTextureARB");
1792 glMultiTexCoord2fARB = (void *) wglGetProcAddress("glMultiTexCoord2fARB");
1793 glClientActiveTextureARB = (void *) wglGetProcAddress("glClientActiveTextureARB");
1794 glLockArraysEXT = (void *) wglGetProcAddress("glLockArraysEXT" );
1795 glUnlockArraysEXT = (void *) wglGetProcAddress("glUnlockArraysEXT");
1796 glGenBuffersARB = (void *) wglGetProcAddress("glGenBuffersARB");
1797 glBindBufferARB = (void *) wglGetProcAddress("glBindBufferARB");
1798 glBufferDataARB = (void *) wglGetProcAddress("glBufferDataARB");
1799 glMapBufferARB = (void *) wglGetProcAddress("glMapBufferARB");
1800 glUnmapBufferARB = (void *) wglGetProcAddress("glUnmapBufferARB");
1801 glDeleteBuffersARB = (void *) wglGetProcAddress("glDeleteBuffersARB");
1802 glBlendFuncSeparate = (void *) wglGetProcAddress("glBlendFuncSeparate");
1804 wglChoosePixelFormatARB = (void *) wglGetProcAddress("wglChoosePixelFormatARB");
1805 wglGetExtensionsStringARB = (void *)wglGetProcAddress("wglGetExtensionsStringARB");
1806 wglCreatePbufferARB = (void *)wglGetProcAddress("wglCreatePbufferARB");
1807 wglGetPbufferDCARB = (void *)wglGetProcAddress("wglGetPbufferDCARB");
1808 wglQueryPbufferARB = (void *)wglGetProcAddress("wglQueryPbufferARB");
1809 wglDestroyPbufferARB = (void *)wglGetProcAddress("wglDestroyPbufferARB");
1810 wglReleasePbufferDCARB = (void *)wglGetProcAddress("wglReleasePbufferDCARB");
1811 wglBindTexImageARB = (void *)wglGetProcAddress("wglBindTexImageARB");
1812 wglReleaseTexImageARB = (void *)wglGetProcAddress("wglReleaseTexImageARB");
1814 wglSwapIntervalEXT = (void *)wglGetProcAddress("wglSwapIntervalEXT");
1816 vboAvailable = glBindBufferARB != null;
1818 // eSystem_LoggingMode(LOG_MSGBOX, null);
1820 if(wglChoosePixelFormatARB)
1825 float fAttributes[] = {0,0};
1828 WGL_DRAW_TO_WINDOW_ARB,GL_TRUE,
1829 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1830 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
1831 WGL_COLOR_BITS_ARB,24,
1832 WGL_ALPHA_BITS_ARB,8,
1833 WGL_DEPTH_BITS_ARB,16,
1834 WGL_STENCIL_BITS_ARB,0,
1835 WGL_DOUBLE_BUFFER_ARB,GL_TRUE,
1836 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
1837 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
1841 //Log("Found wglChoosePixelFormatARB\n");
1843 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1844 if(!valid || !numFormats)
1846 //Log("Can't find 4x multi sampling\n");
1847 iAttributes[19] = 2;
1848 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1849 if(!valid || !numFormats)
1851 // Log("Can't find 2x multi sampling\n");
1852 iAttributes[16] = 0;
1853 iAttributes[17] = 0;
1854 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1857 if(valid && numFormats)
1859 oglSystem.format = pixelFormat;
1860 wglMakeCurrent(null, null);
1861 wglDeleteContext(oglSystem.glrc);
1863 // *** DescribePixelFormat does not support WGL pixel formats! ***
1864 //DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1865 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1866 //Log("Successfully set pixel format\n");
1868 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1869 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1873 eSystem_Logf("Can't find wglChoosePixelFormatARB\n");*/
1877 CheckExtensions(oglSystem);
1879 wglMakeCurrent(null, null);
1881 //eSystem_DumpErrors(true);
1885 #elif defined(__unix__) || defined(__APPLE__)
1886 vboAvailable = true;
1887 #if defined(__ANDROID__)
1888 egl_init_display(guiApp.desktop.windowHandle);
1889 #elif defined(__ODROID__)
1890 egl_init_display((uint)displaySystem.window);
1891 CheckExtensions(oglSystem);
1893 #elif defined(__EMSCRIPTEN__)
1894 if(glfwInit() == GL_TRUE)
1896 const int width = 640, height = 480;
1897 if(glfwOpenWindow(width, height, 8, 8, 8, 8, 16, 0, GLFW_WINDOW) == GL_TRUE)
1899 //glfwSwapBuffers();
1903 printf("glfwOpenWindow() failed\n"); //glfwTerminate();
1906 printf("glfwInit() failed\n"); //glfwTerminate();
1909 X11Window root = RootWindow( xGlobalDisplay, DefaultScreen( xGlobalDisplay ) );
1910 XSetWindowAttributes attr;
1915 #ifndef ECERE_MINIGLX
1916 GLX_USE_GL, GLX_DEPTH_SIZE, 1,
1919 GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,
1923 oglSystem.visualInfo = glXChooseVisual( xGlobalDisplay, DefaultScreen( xGlobalDisplay ), attrList );
1924 attr.background_pixel = 0;
1925 attr.border_pixel = 0;
1926 attr.colormap = XCreateColormap( xGlobalDisplay, root, oglSystem.visualInfo->visual, AllocNone);
1927 attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
1928 mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
1930 oglSystem.glxDrawable = XCreateWindow( xGlobalDisplay, root, 0, 0, 1, 1, 0, oglSystem.visualInfo->depth, InputOutput,
1931 oglSystem.visualInfo->visual, mask, &attr );
1933 if(oglSystem.visualInfo)
1935 oglSystem.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, null, True);
1936 if(oglSystem.glContext)
1938 glXMakeCurrent(xGlobalDisplay, oglSystem.glxDrawable, oglSystem.glContext);
1940 CheckExtensions(oglSystem);
1941 glXMakeCurrent(xGlobalDisplay, None, null);
1948 displaySystem.flags.alpha = true;
1949 displaySystem.flags.flipping = true;
1950 displaySystem.pixelFormat = pixelFormat888;
1954 void DestroyDisplaySystem(DisplaySystem displaySystem)
1956 OGLSystem oglSystem = displaySystem.driverData;
1958 #if defined(__WIN32__)
1959 wglMakeCurrent( null, null );
1962 wglDeleteContext(oglSystem.glrc);
1965 ReleaseDC(oglSystem.hwnd, oglSystem.hdc);
1966 DestroyWindow(oglSystem.hwnd);
1968 #elif defined(__unix__) || defined(__APPLE__)
1969 #if defined(__ANDROID__) || defined(__ODROID__)
1971 #elif defined(__EMSCRIPTEN__)
1974 if(oglSystem.visualInfo)
1976 #ifdef ECERE_MINIGLX
1977 __miniglx_XFree(oglSystem.visualInfo);
1979 XFree(oglSystem.visualInfo);
1983 if(oglSystem.glxDrawable)
1985 XDestroyWindow(xGlobalDisplay, oglSystem.glxDrawable);
1986 oglSystem.glxDrawable = 0;
1993 bool CreateDisplay(Display display)
1995 bool result = false;
1996 OGLDisplay oglDisplay = display.driverData;
1997 #if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
1998 OGLSystem oglSystem = display.displaySystem.driverData;
2001 oglDisplay = display.driverData = OGLDisplay { };
2002 //printf("Inside CreateDisplay\n");
2004 #if defined(__WIN32__) || defined(USEPBUFFER)
2005 if(!display.alphaBlend)
2008 #if defined(__WIN32__)
2009 oglDisplay.hdc = GetDC(display.window);
2010 SetPixelFormat(oglDisplay.hdc, oglSystem.format, &oglSystem.pfd);
2011 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
2013 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2014 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2018 ReleaseDC(display.window, oglDisplay.hdc);
2019 #elif defined(__unix__) || defined(__APPLE__)
2020 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2022 XVisualInfo * visualInfo = ((XWindowData)display.windowDriverData).visual;
2024 #if defined(__APPLE__)
2025 XVisualInfo template = { 0 };
2026 XWindowAttributes winAttr;
2028 XGetWindowAttributes(xGlobalDisplay, (X11Window)display.window, &winAttr);
2029 template.visualid = XVisualIDFromVisual(winAttr.visual);
2030 visualInfo = XGetVisualInfo(xGlobalDisplay, VisualIDMask, &template, &n);
2032 printf("XGetVisualInfo visual ID = %d\n", template.visualid);
2033 printf("visualInfo visual ID = %d\n", visualInfo->visualid);
2034 printf("oglSystem.visualInfo visual ID = %d\n", oglSystem.visualInfo->visualid);
2035 printf("((XWindowData)display.windowDriverData).visual visual ID = %d\n", ((XWindowData)display.windowDriverData).visual->visualid);
2037 // visualInfo = oglSystem.visualInfo;
2042 //printf("visualInfo is not null\n");
2043 // printf("Creating Display Context, sharing with %x!\n", oglSystem.glContext);
2044 oglDisplay.glContext = glXCreateContext(xGlobalDisplay, visualInfo, oglSystem.glContext, True);
2045 //XFree(visualInfo);
2048 // oglDisplay.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, oglSystem.glContext, True);
2049 if(oglDisplay.glContext)
2051 //printf("CreateDisplay Got a Context\n");
2052 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2058 #if defined(__WIN32__) || defined(USEPBUFFER)
2064 #if defined(__WIN32__)
2065 if(glBlendFuncSeparate)
2066 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2068 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2070 #if !defined(__OLDX__)
2071 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2073 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2078 glMatrixMode(GL_MODELVIEW);
2079 glScaled(1.0, 1.0, -1.0);
2080 // glTranslatef(0.375f, 0.375f, 0.0f);
2081 // glTranslatef(-0.625f, -0.625f, 0.0f);
2082 glMatrixMode(GL_PROJECTION);
2083 glShadeModel(GL_FLAT);
2085 // glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, true);
2086 #if !defined(EM_MODE)
2087 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
2089 glFogi(GL_FOG_MODE, GL_EXP);
2090 glFogf(GL_FOG_DENSITY, 0);
2091 glEnable(GL_NORMALIZE);
2092 glDepthFunc(GL_LESS);
2094 glDisable(GL_MULTISAMPLE_ARB);
2096 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
2097 display.ambient = Color { 50,50,50 };
2100 if(!useSingleGLContext)
2102 #if defined(__WIN32__)
2103 wglMakeCurrent(null, null);
2104 #elif defined(__unix__) || defined(__APPLE__)
2105 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2108 glXMakeCurrent(xGlobalDisplay, None, null);
2114 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2122 bool DisplaySize(Display display, int width, int height)
2124 OGLDisplay oglDisplay = display.driverData;
2126 bool result = false;
2128 //printf("Inside DisplaySize\n");
2129 #if defined(__WIN32__) || defined(USEPBUFFER)
2130 OGLSystem oglSystem = display.displaySystem.driverData;
2131 if(display.alphaBlend)
2133 #if defined(__WIN32__)
2134 const int attributes[]=
2136 /*WGL_TEXTURE_FORMAT_ARB, WGL_TEXTURE_RGBA_ARB,
2137 WGL_TEXTURE_TARGET_ARB, WGL_TEXTURE_2D_ARB, */0
2139 int pixelFormat = 0;
2140 if(wglChoosePixelFormatARB)
2144 float fAttributes[] = {0,0};
2147 //WGL_DRAW_TO_BITMAP_ARB, GL_TRUE,
2148 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2149 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2150 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
2151 WGL_COLOR_BITS_ARB,24,
2152 WGL_ALPHA_BITS_ARB,8,
2153 WGL_DEPTH_BITS_ARB,16,
2154 WGL_STENCIL_BITS_ARB,0,
2155 WGL_DOUBLE_BUFFER_ARB,GL_FALSE,
2156 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
2157 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
2161 //Log("Found wglChoosePixelFormatARB\n");
2163 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2164 if(!valid || !numFormats)
2166 //Log("Can't find 4x multi sampling\n");
2167 iAttributes[19] = 2;
2168 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2169 if(!valid || !numFormats)
2171 // Log("Can't find 2x multi sampling\n");
2172 iAttributes[16] = 0;
2173 iAttributes[17] = 0;
2174 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2175 if(!valid || !numFormats)
2179 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2180 //WGL_DRAW_TO_BITMAP_ARB,GL_TRUE,
2181 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2182 WGL_COLOR_BITS_ARB,24,
2183 WGL_ALPHA_BITS_ARB,8,
2184 WGL_DEPTH_BITS_ARB,16,
2187 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2191 if(valid && numFormats)
2193 wglMakeCurrent(null, null);
2197 wglMakeCurrent( null, null );
2198 wglMakeCurrent( oglDisplay.hdc, oglDisplay.glrc );
2199 if(oglDisplay.hdc && oglDisplay.pBuffer)
2200 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
2202 wglDestroyPbufferARB(oglDisplay.pBuffer);
2204 if(!useSingleGLContext)
2205 wglMakeCurrent( null, null );
2208 wglDeleteContext(oglDisplay.glrc);
2210 oglDisplay.pBuffer = wglCreatePbufferARB(oglSystem.hdc, pixelFormat, width, height, attributes);
2211 oglDisplay.hdc = wglGetPbufferDCARB(oglDisplay.pBuffer);
2212 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
2215 HDC hdc = GetDC(display.window);
2217 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2218 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2220 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_WIDTH_ARB, &width);
2221 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_HEIGHT_ARB, &height);
2223 // glDeleteBuffersARB(2, oglDisplay.imageBuffers);
2225 if((info = (BITMAPINFO *)new0 byte[sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*256]))
2229 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
2230 oglDisplay.memDC = CreateCompatibleDC(hdc);
2231 SetMapMode(oglDisplay.memDC, MM_TEXT);
2232 info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2233 info->bmiHeader.biPlanes = 1;
2234 info->bmiHeader.biCompression = BI_RGB;
2235 info->bmiHeader.biBitCount = 32; //(uint16)GetDeviceCaps(hdc, BITSPIXEL);
2236 info->bmiHeader.biWidth = width;
2237 info->bmiHeader.biHeight = height;
2238 newBitmap = CreateDIBSection(hdc, info, DIB_RGB_COLORS, &oglDisplay.picture, null, 0);
2241 SelectObject(oglDisplay.memDC, newBitmap);
2242 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
2245 PIXELFORMATDESCRIPTOR pfd = { 0 };
2246 pfd.nSize = (short)sizeof(pfd);
2248 pfd.dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL;
2249 pfd.iPixelType = PFD_TYPE_RGBA;
2250 pfd.cColorBits = 32;
2251 //pfd.cAlphaBits = 8;
2252 pfd.cDepthBits = 24;
2253 pfd.iLayerType = PFD_MAIN_PLANE;
2255 oglDisplay.hdc = oglDisplay.memDC;
2257 pixelFormat = ChoosePixelFormat(oglSystem.hdc, &pfd);
2258 DescribePixelFormat(oglDisplay.hdc, pixelFormat, sizeof(pfd), &pfd);
2259 SetPixelFormat(oglDisplay.hdc, pixelFormat, &pfd);
2261 oglDisplay.glrc = wglCreateContext(oglDisplay.hdc);
2262 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2263 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2268 const int imageSize = width * height * 4;
2270 glGenBuffersARB(2, oglDisplay.imageBuffers);
2272 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2273 glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize, null, GL_STREAM_READ);
2274 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2275 // glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize / 2, null, GL_STREAM_READ);
2278 oglDisplay.memBitmap = newBitmap;
2279 oglDisplay.stride = width;
2285 ReleaseDC(display.window, hdc);
2287 #elif defined(__unix__) || defined(__APPLE__)
2288 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2293 GLX_DOUBLEBUFFER, True,
2299 GLX_STENCIL_SIZE, 1,
2300 //GLX_DEPTH_SIZE, 24,
2301 GLX_RENDER_TYPE, GLX_RGBA_BIT,
2302 GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT | GLX_WINDOW_BIT,
2308 GLX_PBUFFER_WIDTH, width,
2309 GLX_PBUFFER_HEIGHT, height,
2310 GLX_LARGEST_PBUFFER, False,
2314 // choose a pixel format that meets our minimum requirements
2317 GLXFBConfig *config = glXChooseFBConfig(xGlobalDisplay, DefaultScreen(xGlobalDisplay), attrib, &count);
2320 if(oglDisplay.pixmap)
2322 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2323 oglDisplay.pixmap = None;
2325 if(oglDisplay.shapePixmap)
2327 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
2328 oglDisplay.shapePixmap = None;
2331 // Free Shared Memory Pixmap
2332 if(oglDisplay.image)
2334 if(oglDisplay.shminfoShape.shmid != -1)
2336 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
2337 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2338 shmdt(oglDisplay.shminfo.shmaddr);
2339 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
2341 XDestroyImage(oglDisplay.image);
2342 oglDisplay.image = None;
2344 if(oglDisplay.shapeImage)
2346 if(oglDisplay.shminfoShape.shmid != -1)
2348 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
2349 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2350 shmdt(oglDisplay.shminfoShape.shmaddr);
2351 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
2353 XDestroyImage(oglDisplay.shapeImage);
2354 oglDisplay.shapeImage = None;
2357 if(oglDisplay.windowPicture)
2358 XRenderFreePicture(xGlobalDisplay, oglDisplay.windowPicture);
2359 if(oglDisplay.pixmapPicture)
2360 XRenderFreePicture(xGlobalDisplay, oglDisplay.pixmapPicture);
2362 if(oglDisplay.pixmap)
2363 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2365 if(oglDisplay.glContext)
2366 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
2367 if(oglDisplay.pBuffer)
2368 glXDestroyPbuffer(xGlobalDisplay, oglDisplay.pBuffer);
2370 oglDisplay.pBuffer = glXCreatePbuffer(xGlobalDisplay, config[0], PBattrib);
2371 if(oglDisplay.pBuffer)
2373 oglDisplay.glContext = glXCreateNewContext(xGlobalDisplay, config[0], GLX_RGBA_TYPE, oglSystem.glContext, True);
2374 if(oglDisplay.glContext)
2376 glXMakeCurrent(xGlobalDisplay, None, null);
2377 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2379 // Initialize Shared Memory Pixmap
2380 oglDisplay.image = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 32,
2381 ZPixmap, null, &oglDisplay.shminfo, width, height);
2382 if(oglDisplay.image)
2384 oglDisplay.shminfo.shmid = shmget(IPC_PRIVATE,
2385 oglDisplay.image->bytes_per_line * oglDisplay.image->height, IPC_CREAT|0777);
2386 if(oglDisplay.shminfo.shmid != -1)
2388 oglDisplay.shminfo.shmaddr = shmat(oglDisplay.shminfo.shmid, 0, 0);
2389 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2391 oglDisplay.shminfo.readOnly = False;
2392 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfo))
2394 oglDisplay.pixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfo.shmaddr,
2395 &oglDisplay.shminfo, width, height, 32);
2397 // Initialize Shared Memory Shape Pixmap
2398 oglDisplay.shapeImage = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 1,
2399 ZPixmap, null, &oglDisplay.shminfoShape, width, height);
2400 if(oglDisplay.shapeImage)
2402 oglDisplay.shminfoShape.shmid = shmget(IPC_PRIVATE,
2403 oglDisplay.shapeImage->bytes_per_line * oglDisplay.shapeImage->height, IPC_CREAT|0777);
2404 if(oglDisplay.shminfoShape.shmid != -1)
2406 oglDisplay.shminfoShape.shmaddr = shmat(oglDisplay.shminfoShape.shmid, 0, 0);
2407 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2409 oglDisplay.shminfoShape.readOnly = False;
2410 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfoShape))
2412 oglDisplay.shapePixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfoShape.shmaddr,
2413 &oglDisplay.shminfoShape, width, height, 1);
2414 //oglDisplay.shapePixmap = XCreatePixmap(xGlobalDisplay, (X11Window)display.window, width, height, 1);
2417 XRenderPictureAttributes attributes = { 0 };
2418 XRenderPictFormat * format = XRenderFindStandardFormat(xGlobalDisplay, /*PictStandardRGB24*/ PictStandardARGB32);
2419 #if !defined(__APPLE__) && !defined(__OLDX__)
2420 attributes.repeat = RepeatNormal;
2422 attributes.repeat = 1;
2424 oglDisplay.pixmapPicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.pixmap, format, CPRepeat, &attributes);
2425 oglDisplay.windowPicture = XRenderCreatePicture(xGlobalDisplay, (X11Window)display.window, format, 0, &attributes);
2426 oglDisplay.shapePicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.shapePixmap,
2427 XRenderFindStandardFormat(xGlobalDisplay, PictStandardA1), 0, &attributes);
2430 oglDisplay.picture = oglDisplay.shminfo.shmaddr;
2431 oglDisplay.stride = oglDisplay.image->bytes_per_line / 4;
2448 CreateDisplay(display);
2449 #if defined(__WIN32__)
2450 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2451 #elif defined(__unix__) || defined(__APPLE__)
2452 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2456 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2463 if(!result && display.alphaBlend)
2465 printf("Alpha blending windows not supported on this display\n");
2472 glViewport(0,0,width,height);
2474 glOrtho(0,width,height,0,0.0,1.0);
2475 displayWidth = display.width = width;
2476 displayHeight = display.height = height;
2478 if(!oglDisplay.flippingBuffer || oglDisplay.flipBufW < width || oglDisplay.flipBufH < height)
2480 oglDisplay.flipBufW = width;
2481 oglDisplay.flipBufH = height;
2485 oglDisplay.flippingBuffer = renew oglDisplay.flippingBuffer ColorAlpha [width * height];
2488 if(oglDisplay.flippingBuffer || !width || !height)
2494 void DisplayPosition(Display display, int x, int y)
2496 OGLDisplay oglDisplay = display.driverData;
2502 void SetPalette(Display display, ColorAlpha * palette, bool colorMatch)
2506 void RestorePalette(Display display)
2510 void StartUpdate(Display display)
2514 void EndUpdate(Display display)
2518 void Scroll(Display display, Box scroll, int x, int y, Extent dirty)
2522 void Update(Display display, Box updateBox)
2524 #if defined(__WIN32__) || defined(USEPBUFFER)
2525 OGLDisplay oglDisplay = display.driverData;
2527 //Logf("DisplayScreen\n");
2531 #if defined(__WIN32__) || defined(USEPBUFFER)
2532 if(display.alphaBlend)
2534 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2535 glPixelStorei(GL_PACK_ROW_LENGTH, oglDisplay.stride);
2536 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2537 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2538 glReadPixels(0,0,display.width,display.height,GL_BGRA_EXT,GL_UNSIGNED_BYTE, oglDisplay.picture);
2541 #if defined(__WIN32__)
2543 POINT point = { oglDisplay.x, oglDisplay.y};
2544 POINT srcPoint = { 0, 0 };
2545 BLENDFUNCTION blend = { 0 };
2547 size.cx = display.width;
2548 size.cy = display.height;
2549 blend.BlendOp = AC_SRC_OVER;
2550 blend.BlendFlags = 0;
2551 blend.SourceConstantAlpha = 255;
2552 blend.AlphaFormat = AC_SRC_ALPHA;
2555 // Process partial images. Mapping the buffer waits for
2556 // outstanding DMA transfers into the buffer to finish.
2557 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2558 oglDisplay.pboMemory1 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY);
2560 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2561 // oglDisplay.pboMemory2 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB,GL_READ_ONLY);
2564 memcpy(oglDisplay.picture, oglDisplay.pboMemory1, display.width * display.height * 4);
2565 //memcpy(oglDisplay.picture + display.width * display.height * 4 / 2, oglDisplay.pboMemory2, display.width * display.height * 4/ 2);
2568 UpdateLayeredWindow(display.window, hdc, &point, &size, oglDisplay.memDC, &srcPoint, 0, &blend, ULW_ALPHA);
2571 // Unmap the image buffers
2572 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2573 glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2575 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2576 // glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2578 // Bind two different buffer objects and start the glReadPixels
2579 // asynchronously. Each call will return directly after
2580 // starting the DMA transfer.
2581 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2582 glReadPixels(0, 0, display.width, display.height, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2584 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2585 // glReadPixels(0, display.height/2, display.width, display.height/2, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2589 #elif defined(__unix__) || defined(__APPLE__)
2590 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2592 XTransform transform =
2595 { (int)(1.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(0 * (1 << 16)) },
2596 { (int)(0.0f), (int)(-1.0f * (1<<16)), (int)(0 * (1<<16)) },
2597 { (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)) }
2600 XRenderSetPictureTransform(xGlobalDisplay, oglDisplay.pixmapPicture, &transform);
2601 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.shapePicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2602 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.windowPicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2603 #if !defined(__APPLE__) && !defined(__OLDX__)
2604 XShapeCombineMask(xGlobalDisplay, (X11Window)display.window, ShapeInput, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2606 XShapeCombineMask(xGlobalDisplay, display.window, 2, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2608 XFlush(xGlobalDisplay);
2616 #if defined(__WIN32__)
2617 //wglSwapLayerBuffers(oglDisplay.hdc,WGL_SWAP_MAIN_PLANE);
2618 SwapBuffers(oglDisplay.hdc);
2619 #elif defined(__unix__) || defined(__APPLE__)
2620 #if defined(__ANDROID__) || defined(__ODROID__)
2621 eglSwapBuffers(eglDisplay, eglSurface);
2622 #elif defined(__EMSCRIPTEN__)
2625 glXSwapBuffers(xGlobalDisplay, (GLXDrawable)display.window);
2629 //Logf("Out of DisplayScreen\n");
2632 void FreeBitmap(DisplaySystem displaySystem, Bitmap bitmap)
2634 if(bitmap.driverData)
2636 GLuint tex = (GLuint)(uintptr)bitmap.driverData;
2637 glDeleteTextures(1, &tex);
2638 bitmap.driverData = 0;
2640 bitmap.driver = ((subclass(DisplayDriver))class(LFBDisplayDriver));
2643 bool AllocateBitmap(DisplaySystem displaySystem, Bitmap bitmap, int width, int height, int stride, PixelFormat format, bool allocatePalette)
2645 OGLSystem oglSystem = displaySystem.driverData;
2646 bool result = false;
2648 GLuint glBitmap = 0;
2650 uint w = width, h = height;
2651 if(oglSystem.pow2textures)
2656 w = Min(w, oglSystem.maxTextureSize);
2657 h = Min(h, oglSystem.maxTextureSize);
2659 glGenTextures(1, &glBitmap);
2660 glBindTexture(GL_TEXTURE_2D, glBitmap);
2662 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2664 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2665 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2667 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2668 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2670 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2672 mipMap.Allocate(null, w, h, w, pixelFormatRGBA, false);
2674 // glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2675 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2679 bitmap.driverData = (void *)(uintptr)glBitmap;
2680 bitmap.driver = displaySystem.driver;
2688 bool MakeDDBitmap(DisplaySystem displaySystem, Bitmap bitmap, bool mipMaps)
2690 bool result = false;
2691 OGLSystem oglSystem = displaySystem.driverData;
2692 Bitmap convBitmap = bitmap;
2696 convBitmap.Copy(bitmap);
2699 // Pre process the bitmap... First make it 32 bit
2700 if(/*bitmap.pixelFormat == pixelFormatRGBA || */convBitmap.Convert(null, pixelFormat888, null))
2703 uint w = bitmap.width, h = bitmap.height;
2704 GLuint glBitmap = 0;
2705 if(oglSystem.pow2textures)
2710 w = Min(w, oglSystem.maxTextureSize);
2711 h = Min(h, oglSystem.maxTextureSize);
2715 while(w * 2 < h) w *= 2;
2716 while(h * 2 < w) h *= 2;
2719 // Switch ARGB to RGBA
2720 //if(bitmap.format != pixelFormatRGBA)
2722 for(c=0; c<bitmap.size; c++)
2724 // ((ColorRGBA *)bitmap.picture)[c] = ((ColorAlpha *)bitmap.picture)[c];
2726 ColorAlpha color = ((ColorAlpha *)convBitmap.picture)[c];
2727 ((ColorRGBA *)convBitmap.picture)[c] = ColorRGBA { color.color.r, color.color.g, color.color.b, color.a };
2730 // convBitmap.pixelFormat = pixelFormat888;
2733 glGenTextures(1, &glBitmap);
2736 //int error = glGetError();
2740 glBindTexture(GL_TEXTURE_2D, glBitmap);
2741 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2743 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2744 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mipMaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
2745 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2747 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
2748 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
2750 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2751 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2753 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2757 for(level = 0; result && (w > 1 || h > 1); level++, w >>= 1, h >>= 1)
2760 if(bitmap.width != w || bitmap.height != h)
2762 mipMap = Bitmap { };
2763 if(mipMap.Allocate(null, w, h, w, convBitmap.pixelFormat, false))
2765 Surface mipSurface = mipMap.GetSurface(0,0,null);
2766 mipSurface.Filter(convBitmap, 0,0,0,0, w, h, convBitmap.width, convBitmap.height);
2776 mipMap = convBitmap;
2783 // glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2784 glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2785 //printf("Calling glTexImage2D\n");
2786 //glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &width);
2787 //printf("width = %d (Should be %d, %d)\n", width, w, h);
2788 if((error = glGetError()))
2790 //Logf("OpenGL Bitmap MakeDD error: %d...\n", error);
2791 //printf("OpenGL Bitmap MakeDD error: %d...\n", error);
2795 if(mipMap != convBitmap)
2800 convBitmap.driver.FreeBitmap(convBitmap.displaySystem, convBitmap);
2801 bitmap.driverData = (void *)(uintptr)glBitmap;
2802 bitmap.driver = displaySystem.driver;
2807 FreeBitmap(displaySystem, bitmap);
2808 else if(oglSystem.loadingFont)
2810 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2811 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2812 oglSystem.loadingFont = false;
2818 void ReleaseSurface(Display display, Surface surface)
2820 glDisable(GL_SCISSOR_TEST);
2821 delete surface.driverData;
2822 surface.driverData = null;
2825 bool GetBitmapSurface(DisplaySystem displaySystem, Surface surface, Bitmap bitmap, int x, int y, Box clip)
2830 bool GetSurface(Display display, Surface surface, int x,int y, Box clip)
2832 bool result = false;
2833 OGLSurface oglSurface = surface.driverData = OGLSurface { };
2835 //Logf("GetSurface\n");
2839 if(displayWidth != display.width || displayHeight != display.height)
2841 displayWidth = display.width;
2842 displayHeight = display.height;
2844 glViewport(0,0,display.width,display.height);
2846 glOrtho(0,display.width,display.height,0,0.0,1.0);
2849 surface.offset.x = x;
2850 surface.offset.y = y;
2851 surface.unclippedBox = surface.box = clip;
2852 oglSurface.bitmapMult[0] = 1;
2853 oglSurface.bitmapMult[1] = 1;
2854 oglSurface.bitmapMult[2] = 1;
2855 oglSurface.bitmapMult[3] = 1;
2857 glEnable(GL_SCISSOR_TEST);
2860 (display.height) -(y+clip.bottom)-1,
2861 clip.right-clip.left+1,
2862 clip.bottom-clip.top+1);
2868 void Clip(Display display, Surface surface, Box clip)
2877 box.Clip(surface.unclippedBox);
2881 box = surface.box = surface.unclippedBox;
2882 box.left += surface.offset.x;
2883 box.top += surface.offset.y;
2884 box.right+= surface.offset.x;
2885 box.bottom += surface.offset.y;
2888 box.left,display.height - box.bottom - 1,
2889 box.right-box.left+1, box.bottom-box.top+1);
2892 bool GrabScreen(Display display, Bitmap bitmap, int x, int y, unsigned int w, unsigned int h)
2894 bool result = false;
2895 OGLDisplay oglDisplay = display.driverData;
2896 ColorAlpha * flippingBuffer = oglDisplay.flippingBuffer;
2898 if(oglDisplay.flippingBuffer)
2900 if(bitmap.pixelFormat != pixelFormat888 || bitmap.width < w || bitmap.height < h)
2903 bitmap.Allocate(null, w,h,w, pixelFormat888, false);
2909 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2910 glPixelStorei(GL_PACK_ROW_LENGTH, bitmap.stride);
2911 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2912 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2913 glReadPixels(x,display.height-h-y,w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, flippingBuffer);
2916 for(row = 0; row<h; row++)
2917 CopyBytesBy4(((ColorAlpha *)bitmap.picture) + row * w, ((ColorAlpha *)flippingBuffer) + (h-row-1) * w, w);
2924 void SetForeground(Display display, Surface surface, ColorAlpha color)
2926 OGLSurface oglSurface = surface.driverData;
2928 //Logf("SetForeground\n");
2930 oglSurface.foreground[0] = color.color.r/255.0f;
2931 oglSurface.foreground[1] = color.color.g/255.0f;
2932 oglSurface.foreground[2] = color.color.b/255.0f;
2933 //oglSurface.foreground[3] = 1.0f;
2934 oglSurface.foreground[3] = color.a/255.0f;
2936 //if(!oglSurface.foreground[3])printf("bug");
2939 void SetBackground(Display display, Surface surface, ColorAlpha color)
2941 OGLSurface oglSurface = surface.driverData;
2943 //Logf("SetBackground\n");
2945 oglSurface.background[0] = color.color.r/255.0f;
2946 oglSurface.background[1] = color.color.g/255.0f;
2947 oglSurface.background[2] = color.color.b/255.0f;
2948 //oglSurface.background[3] = 1.0;
2949 oglSurface.background[3] = color.a/255.0f;
2952 void SetBlitTint(Display display, Surface surface, ColorAlpha color)
2954 OGLSurface oglSurface = surface.driverData;
2956 oglSurface.bitmapMult[0] = color.color.r/255.0f;
2957 oglSurface.bitmapMult[1] = color.color.g/255.0f;
2958 oglSurface.bitmapMult[2] = color.color.b/255.0f;
2959 oglSurface.bitmapMult[3] = color.a/255.0f;
2962 ColorAlpha GetPixel(Display display, Surface surface,int x,int y)
2967 void PutPixel(Display display, Surface surface,int x,int y)
2969 OGLSurface oglSurface = surface.driverData;
2971 //Logf("PutPixel\n");
2973 glColor4fv(oglSurface.foreground);
2975 // glVertex2i(x+surface.offset.x, y+surface.offset.y);
2976 glVertex2f(x+surface.offset.x + 0.5f, y+surface.offset.y + 0.5f);
2981 void DrawLine(Display display, Surface surface, int _x1, int _y1, int _x2, int _y2)
2983 OGLSurface oglSurface = surface.driverData;
2984 float x1 = _x1, x2 = _x2, y1 = _y1, y2 = _y2;
2999 x1 += surface.offset.x;
3000 y1 += surface.offset.y;
3001 x2 += surface.offset.x;
3002 y2 += surface.offset.y;
3006 glColor4fv(oglSurface.foreground);
3008 #if defined(_GLES) || defined(EM_MODE)
3011 glTexCoord2f(0.5f, 0);
3012 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3013 glTexCoord2f(Max(x2-x1, y2-y1) + 0.5f, 0);
3014 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3023 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3024 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3030 void Rectangle(Display display, Surface surface,int x1,int y1,int x2,int y2)
3032 OGLSurface oglSurface = surface.driverData;
3033 x1 += surface.offset.x;
3034 y1 += surface.offset.y;
3035 x2 += surface.offset.x;
3036 y2 += surface.offset.y;
3038 //Logf("Rectangle\n");
3040 glColor4fv(oglSurface.foreground);
3041 #if defined(_GLES) || defined(EM_MODE)
3046 glTexCoord2f(0.5f, 0);
3047 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3048 glTexCoord2f(y2-y1 + 0.5f, 0);
3049 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3051 glTexCoord2f(0.5f, 0);
3052 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3053 glTexCoord2f(x2 - x1 + 0.5f, 0);
3054 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3056 glTexCoord2f(0.5f, 0);
3057 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3058 glTexCoord2f(y1 - y2 + 0.5f, 0);
3059 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3061 glTexCoord2f(0.5f, 0);
3062 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3063 glTexCoord2f(x1 - x2 + 0.5f, 0);
3064 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3069 glBegin(GL_LINE_LOOP);
3076 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3077 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3078 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3079 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3084 void Area(Display display, Surface surface,int x1,int y1,int x2,int y2)
3086 OGLSurface oglSurface = surface.driverData;
3089 glColor4fv(oglSurface.background);
3093 glVertex2f(x1+surface.offset.x, y1+surface.offset.y);
3094 glVertex2f(x1+surface.offset.x, y2+surface.offset.y+1);
3095 glVertex2f(x2+surface.offset.x+1, y2+surface.offset.y+1);
3096 glVertex2f(x2+surface.offset.x+1, y1+surface.offset.y);
3099 glRecti(x1+surface.offset.x, y1+surface.offset.y,
3100 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
3103 glRectf(x1+surface.offset.x, y1+surface.offset.y,
3104 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
3108 void Clear(Display display, Surface surface, ClearType type)
3110 OGLDisplay oglDisplay = display.driverData;
3111 OGLSurface oglSurface = surface.driverData;
3114 if(type != depthBuffer)
3115 glClearColor(oglSurface.background[0], oglSurface.background[1], oglSurface.background[2], oglSurface.background[3]);
3116 if(type != colorBuffer && !oglDisplay.depthWrite)
3118 glDepthMask((byte)bool::true);
3120 glClear(((type != depthBuffer) ? GL_COLOR_BUFFER_BIT : 0) |
3121 ((type != colorBuffer) ? GL_DEPTH_BUFFER_BIT : 0));
3122 if(type != colorBuffer && !oglDisplay.depthWrite)
3124 glDepthMask((byte)bool::false);
3128 bool ConvertBitmap(DisplaySystem displaySystem, Bitmap bitmap, PixelFormat format, ColorAlpha * palette)
3133 void Blit(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3135 OGLSurface oglSurface = surface.driverData;
3137 #if !defined(__OLDX__)
3138 // WHY DO WE HAVE GL_ONE HERE ?
3139 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3140 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3143 if(!oglSurface.writingText)
3145 // glTranslatef(-0.375f, -0.375f, 0.0f);
3146 glEnable(GL_TEXTURE_2D);
3147 glColor4fv(oglSurface.bitmapMult);
3149 else if(oglSurface.xOffset)
3150 glTranslated(oglSurface.xOffset / 64.0/*-0.375*/, 0.0, 0.0);
3152 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3157 glTexCoord2f((float)sx/ bitmap.width, (float)(sy-h)/ bitmap.height);
3158 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3159 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy-h)/ bitmap.height);
3160 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3161 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3162 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
3163 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3164 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3169 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3170 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3171 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3172 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3173 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3174 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3175 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3176 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3179 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3180 glVertex2f((float)dx+surface.offset.x, (float)dy+surface.offset.y);
3181 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3182 glVertex2f((float)dx+w+surface.offset.x, (float)dy+surface.offset.y);
3183 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3184 glVertex2f((float)dx+w+surface.offset.x, (float)dy+h+surface.offset.y);
3185 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3186 glVertex2f((float)dx+surface.offset.x, (float)dy+h+surface.offset.y);
3190 if(!oglSurface.writingText)
3192 glDisable(GL_TEXTURE_2D);
3194 //glTranslate(0.375, 0.375, 0.0);
3196 else if(oglSurface.xOffset)
3197 glTranslated(-oglSurface.xOffset / 64.0/*+0.375*/, 0.0, 0.0);
3199 #if !defined(__OLDX__)
3200 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3201 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3205 void Stretch(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3207 OGLSurface oglSurface = surface.driverData;
3209 //glTranslate(-0.375, -0.375, 0.0);
3211 //Logf("Stretch\n");
3213 #if !defined(__OLDX__)
3214 /*if(glBlendFuncSeparate)
3215 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3218 glEnable(GL_TEXTURE_2D);
3219 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3221 glColor4fv(oglSurface.bitmapMult);
3227 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3228 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3230 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3231 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3233 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3234 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
3236 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3237 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3241 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3242 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3244 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3245 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3247 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3248 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3250 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3251 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3256 glDisable(GL_TEXTURE_2D);
3258 //glTranslate(0.375, 0.375, 0.0);
3259 #if !defined(__OLDX__)
3260 /*if(glBlendFuncSeparate)
3261 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3266 void Filter(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3268 Stretch(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3271 void StretchDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3273 #if !defined(EM_MODE)
3274 float s2dw,s2dh,d2sw,d2sh;
3275 //bool flipX = false, flipY = false;
3277 //Logf("StretchDI\n");
3279 if(Sgn(w) != Sgn(sw))
3285 if(Sgn(h) != Sgn(sh))
3297 //Clip against the edges of the source
3300 dx+=(int)((0-sx) * s2dw);
3301 w-=(int)((0-sx) * s2dw);
3307 dy+=(int)((0-sy) * s2dh);
3308 h-=(int)((0-sy) * s2dh);
3313 if(sx+sw>bitmap.width-1)
3315 w-=(int)((sx+sw-(bitmap.width-1)-1)*s2dw);
3316 sw-=sx+sw-(bitmap.width-1)-1;
3318 if(sy+sh>(bitmap.height-1))
3320 h-=(int)((sy+sh-(bitmap.height-1)-1)*s2dh);
3321 sh-=sy+sh-(bitmap.height-1)-1;
3323 //Clip against the edges of the surfaceination
3324 if(dx<surface.box.left)
3327 sx+=(int)((surface.box.left-dx)*d2sw);
3328 sw-=(int)((surface.box.left-dx)*d2sw);
3329 w-=surface.box.left-dx;
3330 dx=surface.box.left;
3332 if(dy<surface.box.top)
3334 sy+=(int)((surface.box.top-dy)*d2sh);
3335 sh-=(int)((surface.box.top-dy)*d2sh);
3336 h-=surface.box.top-dy;
3339 if(dx+w>surface.box.right)
3341 //if(flip) sx+=(int)((dx+w-surface.box.right-1)*d2sw);
3342 sw-=(int)((dx+w-surface.box.right-1)*d2sw);
3343 w-=dx+w-surface.box.right-1;
3345 if(dy+h>surface.box.bottom)
3347 sh-=(int)((dy+h-surface.box.bottom-1)*d2sh);
3348 h-=dy+h-surface.box.bottom-1;
3350 if((w<=0)||(h<=0)||(sw<=0)||(sh<=0)) return;
3352 dx += surface.offset.x;
3353 dy += surface.offset.y;
3355 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3357 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3358 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3359 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3360 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3361 glRasterPos2d(dx,dy);
3362 //glPixelZoom(flipX ? -s2dw : s2dw, flipY ? s2dh : -s2dh);
3363 glPixelZoom(s2dw, -s2dh);
3364 glDrawPixels(sw,sh,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3365 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3366 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3367 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3368 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3373 void BlitDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3375 #if !defined(EM_MODE)
3378 //Clip against the edges of the source
3391 if(sx+w>bitmap.width-1)
3392 w-=sx+w-(bitmap.width-1)-1;
3393 if(sy+h>bitmap.height-1)
3394 h-=sy+h-(bitmap.height-1)-1;
3395 //Clip against the edges of the surfaceination
3396 if(dx<surface.box.left)
3399 sx+=surface.box.left-dx;
3400 w-=surface.box.left-dx;
3401 dx=surface.box.left;
3403 if(dy<surface.box.top)
3405 sy+=surface.box.top-dy;
3406 h-=surface.box.top-dy;
3409 if(dx+w>surface.box.right)
3411 //if(flip) sx+=dx+w-surface.box.right-1;
3412 w-=dx+w-surface.box.right-1;
3414 if(dy+h>surface.box.bottom)
3415 h-=dy+h-surface.box.bottom-1;
3419 dx += surface.offset.x;
3420 dy += surface.offset.y;
3422 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3424 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3425 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3426 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3427 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3428 glRasterPos2d(dx,dy);
3430 glDrawPixels(w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3431 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3432 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3433 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3434 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3439 void FilterDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3441 StretchDI(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3444 void UnloadFont(DisplaySystem displaySystem, Font font)
3446 ((subclass(DisplayDriver))class(LFBDisplayDriver)).UnloadFont(displaySystem, font);
3449 Font LoadFont(DisplaySystem displaySystem, const char * faceName, float size, FontFlags flags)
3452 OGLSystem oglSystem = displaySystem.driverData;
3453 oglSystem.loadingFont = true;
3454 font = ((subclass(DisplayDriver))class(LFBDisplayDriver)).LoadFont(displaySystem, faceName, size, flags);
3458 void FontExtent(DisplaySystem displaySystem, Font font, const char * text, int len, int * width, int * height)
3460 ((subclass(DisplayDriver))class(LFBDisplayDriver)).FontExtent(displaySystem, font, text, len, width, height);
3463 void WriteText(Display display, Surface surface, int x, int y, const char * text, int len)
3465 OGLSurface oglSurface = surface.driverData;
3466 OGLSystem oglSystem = display.displaySystem.driverData;
3467 oglSystem.loadingFont = true;
3469 //glTranslated(-0.375, -0.375, 0.0);
3473 if(surface.textOpacity)
3476 FontExtent(display.displaySystem, surface.font, text, len, &w, &h);
3477 display.displaySystem.driver.Area(display, surface,x,y,x+w-1,y+h-1);
3480 oglSurface.writingText = true;
3482 glEnable(GL_TEXTURE_2D);
3484 if(surface.outline.size)
3486 ColorAlpha outlineColor = surface.outline.color;
3487 glColor4ub(outlineColor.color.r, outlineColor.color.g, outlineColor.color.b, outlineColor.a);
3488 //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3489 //glEnable(GL_BLEND);
3491 oglSurface.writingOutline = true;
3492 ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x, y, text, len);
3493 oglSurface.writingOutline = false;
3495 glColor4fv(oglSurface.foreground);
3497 ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x, y, text, len);
3498 oglSurface.writingText = false;
3499 oglSystem.loadingFont = false;
3501 glDisable(GL_TEXTURE_2D);
3503 //glTranslated(0.375, 0.375, 0.0);
3506 void TextFont(Display display, Surface surface, Font font)
3508 ((subclass(DisplayDriver))class(LFBDisplayDriver)).TextFont(display, surface, font);
3511 void TextOpacity(Display display, Surface surface, bool opaque)
3513 OGLSurface oglSurface = surface.driverData;
3514 oglSurface.opaqueText = opaque;
3517 void TextExtent(Display display, Surface surface, const char * text, int len, int * width, int * height)
3519 OGLSurface oglSurface = surface.driverData;
3520 OGLSystem oglSystem = display.displaySystem.driverData;
3521 oglSystem.loadingFont = true;
3522 FontExtent(display.displaySystem, oglSurface.font, text, len, width, height);
3523 oglSystem.loadingFont = false;
3526 void DrawingChar(Display display, Surface surface, char character)
3531 void LineStipple(Display display, Surface surface, uint32 stipple)
3533 //Logf("Stipple\n");
3537 #if defined(_GLES) || defined(EM_MODE)
3538 stippleEnabled = true;
3539 glesLineStipple(1, (uint16)stipple);
3541 glLineStipple(1, (uint16)stipple);
3542 glEnable(GL_LINE_STIPPLE);
3547 #if defined(_GLES) || defined(EM_MODE)
3548 stippleEnabled = false;
3549 glMatrixMode(GL_TEXTURE);
3551 glMatrixMode(GL_PROJECTION);
3552 glDisable(GL_TEXTURE_2D);
3554 glDisable(GL_LINE_STIPPLE);
3558 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
3559 void SetRenderState(Display display, RenderState state, uint value)
3561 OGLDisplay oglDisplay = display.driverData;
3562 //Logf("RenderState\n");
3568 glEnable(GL_MULTISAMPLE_ARB);
3570 glDisable(GL_MULTISAMPLE_ARB);
3574 glPolygonMode(GL_FRONT_AND_BACK, ((FillModeValue)value == solid) ? GL_FILL : GL_LINE);
3578 if(value) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
3581 if(value) glDepthMask((byte)bool::true); else glDepthMask((byte)bool::false);
3582 oglDisplay.depthWrite = (bool)value;
3586 float color[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3587 glFogfv(GL_FOG_COLOR, (float *)&color);
3591 glFogf(GL_FOG_DENSITY, (float)(RenderStateFloat { ui = value }.f * nearPlane));
3594 if(value) glEnable(GL_BLEND); else glDisable(GL_BLEND);
3598 #if !defined(EM_MODE)
3599 float ambient[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3600 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
3606 if(value) glColorMask(1,1,1,1); else glColorMask(1,1,1,0);
3611 #if defined(__WIN32__)
3612 wglSwapIntervalEXT(value ? 1 : 0);
3619 void SetLight(Display display, int id, Light light)
3621 #if !defined(EM_MODE)
3622 //Logf("SetLight\n");
3626 Object lightObject = light.lightObject;
3627 float position[4] = { 0, 0, 0, 0 };
3628 float color[4] = { 0, 0, 0, 1 };
3630 glEnable(GL_LIGHT0 + id);
3632 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, (float *)&light.diffuse);
3633 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, (float *)&light.ambient);
3634 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,(float *)&light.specular);
3637 if(!light.multiplier) light.multiplier = 1.0f;
3639 color[0] = light.diffuse.r * light.multiplier;
3640 color[1] = light.diffuse.g * light.multiplier;
3641 color[2] = light.diffuse.b * light.multiplier;
3642 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, color);
3644 color[0] = light.ambient.r * light.multiplier;
3645 color[1] = light.ambient.g * light.multiplier;
3646 color[2] = light.ambient.b * light.multiplier;
3647 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, color);
3648 color[0] = light.specular.r * light.multiplier;
3649 color[1] = light.specular.g * light.multiplier;
3650 color[2] = light.specular.b * light.multiplier;
3651 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,color);
3655 Vector3D positionVector;
3656 if(light.flags.spot)
3658 if(lightObject.flags.root || !lightObject.parent)
3660 positionVector = lightObject.transform.position;
3661 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3665 positionVector.MultMatrix(lightObject.transform.position, lightObject.parent.matrix);
3666 if(display.display3D.camera)
3667 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3673 if(!light.direction.x && !light.direction.y && !light.direction.z)
3675 Vector3Df vector { 0,0,-1 };
3677 mat.RotationQuaternion(light.orientation);
3678 positionVector.MultMatrixf(vector, mat);
3682 positionVector = light.direction;
3687 position[0] = (float)positionVector.x;
3688 position[1] = (float)positionVector.y;
3689 position[2] = (float)positionVector.z;
3691 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3694 // Display Light Position
3695 glDisable(GL_LIGHTING);
3696 glDisable(GL_DEPTH_TEST);
3700 glVertex3fv(position);
3702 glEnable(GL_DEPTH_TEST);
3703 glEnable(GL_LIGHTING);
3707 if(lightObject.flags.root || !lightObject.parent)
3709 positionVector = light.target.transform.position;
3710 positionVector.Subtract(positionVector, display.camera.cPosition);
3714 positionVector.MultMatrix(light.target.transform.position,
3715 lightObject.light.target.parent.matrix);
3716 positionVector.Subtract(positionVector, display.camera.cPosition);
3719 position[0] = positionVector.x;
3720 position[1] = positionVector.y;
3721 position[2] = positionVector.z;
3723 glDisable(GL_LIGHTING);
3724 glDisable(GL_DEPTH_TEST);
3728 glVertex3fv(position);
3730 glEnable(GL_DEPTH_TEST);
3731 glEnable(GL_LIGHTING);
3734 if(light.flags.attenuation)
3736 glLightf(GL_LIGHT0 + id, GL_CONSTANT_ATTENUATION, light.Kc);
3737 glLightf(GL_LIGHT0 + id, GL_LINEAR_ATTENUATION, light.Kl);
3738 glLightf(GL_LIGHT0 + id, GL_QUADRATIC_ATTENUATION, light.Kq);
3741 if(light.flags.spot)
3744 #define MAXLIGHT 0.9
3745 float direction[4] = { (float)light.direction.x, (float)light.direction.y, (float)light.direction.z, 1 };
3746 // Figure out exponent out of the hot spot
3747 exponent = (float)(log(MAXLIGHT) / log(cos((light.hotSpot / 2))));
3749 glLightfv(GL_LIGHT0 + id, GL_SPOT_DIRECTION, direction);
3750 glLightf(GL_LIGHT0 + id, GL_SPOT_CUTOFF, (float)(light.fallOff / 2));
3751 glLightf(GL_LIGHT0 + id, GL_SPOT_EXPONENT, exponent);
3757 Vector3Df vector { 0,0,-1 };
3758 Vector3Df direction;
3761 mat.RotationQuaternion(light.orientation);
3762 direction.MultMatrix(vector, mat);
3764 position[0] = direction.x;
3765 position[1] = direction.y;
3766 position[2] = direction.z;
3768 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3772 glDisable(GL_LIGHT0 + id);
3776 void SetCamera(Display display, Surface surface, Camera camera)
3778 OGLDisplay oglDisplay = display.driverData;
3779 //Logf("SetCamera\n");
3783 int left = surface.box.left + surface.offset.x;
3784 int top = surface.box.top + surface.offset.y;
3785 int right = surface.box.right + surface.offset.x;
3786 int bottom = surface.box.bottom + surface.offset.y;
3787 float origX = surface.offset.x + camera.origin.x;
3788 float origY = surface.offset.y + camera.origin.y;
3790 int y = display.height - bottom - 1;
3791 int w = right - left + 1;
3792 int h = bottom - top + 1;
3795 glViewport(x, y, w, h);
3797 // *** Projection Matrix ***
3798 if(!display.display3D.camera)
3800 glMatrixMode(GL_PROJECTION);
3804 glMatrixMode(GL_PROJECTION);
3805 if(display.display3D.collectingHits)
3807 float pickX = display.display3D.pickX + surface.offset.x;
3808 float pickY = display.height - (display.display3D.pickY + surface.offset.y) - 1;
3812 w / display.display3D.pickWidth, 0, 0, 0,
3813 0, h / display.display3D.pickHeight, 0, 0,
3815 (w + 2.0f * (x - pickX)) / display.display3D.pickWidth,
3816 (h + 2.0f * (y - pickY)) / display.display3D.pickHeight, 0, 1
3819 glLoadMatrixd(pickMatrix.array);
3824 (left - origX) * camera.zMin / camera.focalX,
3825 (right - origX) * camera.zMin / camera.focalX,
3826 (bottom - origY) * camera.zMin / camera.focalY,
3827 (top - origY) * camera.zMin / camera.focalY,
3828 camera.zMin, camera.zMax);
3830 glDisable(GL_BLEND);
3832 // *** Z Inverted Identity Matrix ***
3833 glMatrixMode(GL_MODELVIEW);
3834 if(!display.display3D.camera)
3839 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
3841 // *** View Matrix ***
3842 glMultMatrixd(camera.viewMatrix.array);
3847 glEnable(GL_DEPTH_TEST);
3848 //#if !defined(EM_MODE)
3849 glEnable(GL_LIGHTING);
3850 glShadeModel(GL_SMOOTH);
3852 glDepthMask((byte)bool::true);
3853 oglDisplay.depthWrite = true;
3855 glEnable(GL_MULTISAMPLE_ARB);
3857 else if(display.display3D.camera)
3859 oglDisplay.depthWrite = false;
3860 glViewport(0,0,display.width,display.height);
3862 glDisable(GL_CULL_FACE);
3863 glDisable(GL_DEPTH_TEST);
3864 glDisable(GL_LIGHTING);
3866 glDisable(GL_TEXTURE_2D);
3867 //#if !defined(EM_MODE)
3868 glShadeModel(GL_FLAT);
3871 glDisable(GL_MULTISAMPLE_ARB);
3873 // *** Restore 2D MODELVIEW Matrix ***
3876 // *** Restore 2D PROJECTION Matrix ***
3877 glMatrixMode(GL_PROJECTION);
3883 void ApplyMaterial(Display display, Material material, Mesh mesh)
3885 //Logf("ApplyMaterial\n");
3888 if(material.flags.doubleSided)
3890 #if !defined(EM_MODE)
3891 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, !material.flags.singleSideLight);
3893 glDisable(GL_CULL_FACE);
3897 #if !defined(EM_MODE)
3898 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, bool::false);
3900 glEnable(GL_CULL_FACE);
3904 if(material.flags.noFog)
3910 if(material.baseMap && (mesh.texCoords || mesh.flags.texCoords1))
3912 Bitmap map = material.baseMap;
3913 glEnable(GL_TEXTURE_2D);
3914 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)map.driverData);
3916 glMatrixMode(GL_TEXTURE);
3918 if(material.uScale && material.vScale)
3919 glScalef(material.uScale, material.vScale, 1);
3920 glMatrixMode(GL_MODELVIEW);
3922 if(material.flags.tile)
3924 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
3925 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
3929 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
3930 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
3934 glDisable(GL_TEXTURE_2D);
3937 glColor4f(material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity);
3939 if(mesh.flags.colors)
3941 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
3942 glEnable(GL_COLOR_MATERIAL);
3946 glDisable(GL_COLOR_MATERIAL);
3948 float color[4] = { material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity };
3949 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
3952 float color[4] = { material.ambient.r, material.ambient.g, material.ambient.b, 0 };
3953 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
3957 float color[4] = { material.specular.r, material.specular.g, material.specular.b, 0 };
3958 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, color);
3961 float color[4] = { material.emissive.r, material.emissive.g, material.emissive.b, 0 };
3962 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, color);
3965 glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &material.power);
3969 void FreeMesh(DisplaySystem displaySystem, Mesh mesh)
3971 OGLMesh oglMesh = mesh.data;
3974 if(!mesh.flags.vertices)
3976 oglMesh.vertices.free();
3977 delete mesh.vertices;
3979 if(!mesh.flags.normals)
3981 oglMesh.normals.free();
3982 delete mesh.normals;
3984 if(!mesh.flags.texCoords1)
3986 oglMesh.texCoords.free();
3987 delete mesh.texCoords;
3989 if(!mesh.flags.texCoords2)
3991 oglMesh.texCoords2.free();
3992 // delete mesh.texCoords2;
3994 if(!mesh.flags.colors)
3996 oglMesh.colors.free();
4007 bool AllocateMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags, int nVertices)
4009 bool result = false;
4012 mesh.data = OGLMesh { };
4015 if(mesh.nVertices == nVertices)
4017 // Same number of vertices, adding features (Leaves the other features pointers alone)
4018 if(mesh.flags != flags)
4020 if(!mesh.flags.vertices && flags.vertices)
4022 if(flags.doubleVertices)
4024 mesh.vertices = (Vector3Df *)new Vector3D[nVertices];
4027 mesh.vertices = new Vector3Df[nVertices];
4029 if(!mesh.flags.normals && flags.normals)
4031 if(flags.doubleNormals)
4033 mesh.normals = (Vector3Df *)new Vector3D[nVertices];
4036 mesh.normals = new Vector3Df[nVertices];
4038 if(!mesh.flags.texCoords1 && flags.texCoords1)
4040 mesh.texCoords = new Pointf[nVertices];
4042 if(!mesh.flags.colors && flags.colors)
4044 mesh.colors = new ColorRGBAf[nVertices];
4050 // New number of vertices, reallocate all current and new features
4051 flags |= mesh.flags;
4054 if(flags.doubleVertices)
4056 mesh.vertices = (Vector3Df *)renew mesh.vertices Vector3D[nVertices];
4059 mesh.vertices = renew mesh.vertices Vector3Df[nVertices];
4063 if(flags.doubleNormals)
4065 mesh.normals = (Vector3Df *)renew mesh.normals Vector3D[nVertices];
4068 mesh.normals = renew mesh.normals Vector3Df[nVertices];
4070 if(flags.texCoords1)
4072 mesh.texCoords = renew mesh.texCoords Pointf[nVertices];
4076 mesh.colors = renew mesh.colors ColorRGBAf[nVertices];
4084 void UnlockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
4086 OGLMesh oglMesh = mesh.data;
4087 if(!flags) flags = mesh.flags;
4092 oglMesh.vertices.upload(
4093 mesh.nVertices * (mesh.flags.doubleVertices ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.vertices); //, GL_STATIC_DRAW_ARB );
4096 oglMesh.normals.upload(
4097 mesh.nVertices * (mesh.flags.doubleNormals ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.normals); //, GL_STATIC_DRAW_ARB );
4099 if(flags.texCoords1)
4100 oglMesh.texCoords.upload(
4101 mesh.nVertices * sizeof(Pointf), mesh.texCoords); //, GL_STATIC_DRAW_ARB );
4104 oglMesh.colors.upload(
4105 mesh.nVertices * sizeof(ColorRGBAf), mesh.colors); //, GL_STATIC_DRAW_ARB );
4109 bool LockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
4116 void FreeIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4120 oglIndices.buffer.free();
4121 delete oglIndices.indices;
4126 void * AllocateIndices(DisplaySystem displaySystem, int nIndices, bool indices32bit)
4128 OGLIndices oglIndices = OGLIndices { };
4131 oglIndices.indices = (void *)(indices32bit ? new uint32[nIndices] : new uint16[nIndices]);
4132 oglIndices.nIndices = nIndices;
4137 void UnlockIndices(DisplaySystem displaySystem, OGLIndices oglIndices, bool indices32bit, int nIndices)
4141 oglIndices.buffer.upload(
4142 nIndices * (indices32bit ? sizeof(uint32) : sizeof(uint16)),
4143 oglIndices.indices); //GL_STATIC_DRAW_ARB);
4147 uint16 * LockIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4150 return oglIndices.indices;
4153 void SelectMesh(Display display, Mesh mesh)
4155 //Logf("SelectMesh\n");
4157 #if !defined( __ANDROID__) && !defined(__APPLE__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
4159 #if defined(__WIN32__)
4160 if(glUnlockArraysEXT)
4162 if(!vboAvailable && display.display3D.mesh)
4163 glUnlockArraysEXT();
4168 OGLMesh oglMesh = mesh.data;
4170 // *** Vertex Stream ***
4171 glEnableClientState(GL_VERTEX_ARRAY);
4172 if(!display.display3D.collectingHits && oglMesh)
4174 oglMesh.vertices.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, oglMesh.vertices.buffer ? null : (double *)mesh.vertices);
4176 // *** Normals Stream ***
4177 if(mesh.normals || mesh.flags.normals)
4179 glEnableClientState(GL_NORMAL_ARRAY);
4180 oglMesh.normals.use(normal, 3, GL_FLOAT, 0, oglMesh.normals.buffer ? null : mesh.normals);
4183 glDisableClientState(GL_NORMAL_ARRAY);
4185 // *** Texture Coordinates Stream ***
4186 if(mesh.texCoords || mesh.flags.texCoords1)
4188 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4189 oglMesh.texCoords.use(texCoord, 2, GL_FLOAT, 0, oglMesh.texCoords.buffer ? null : mesh.texCoords);
4192 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4194 // *** Color Stream ***
4195 if(mesh.colors || mesh.flags.colors)
4197 glEnableClientState(GL_COLOR_ARRAY);
4198 oglMesh.colors.use(color, 4, GL_FLOAT, 0, oglMesh.colors.buffer ? null : mesh.colors);
4201 glDisableClientState(GL_COLOR_ARRAY);
4205 noAB.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, (double *)mesh.vertices);
4206 if((mesh.normals || mesh.flags.normals) && !display.display3D.collectingHits)
4208 glEnableClientState(GL_NORMAL_ARRAY);
4209 noAB.use(normal, 3, GL_FLOAT, 0, mesh.normals);
4212 glDisableClientState(GL_NORMAL_ARRAY);
4213 if((mesh.texCoords || mesh.flags.texCoords1) && !display.display3D.collectingHits)
4215 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4216 noAB.use(texCoord, 2, GL_FLOAT, 0, mesh.texCoords);
4219 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4220 if((mesh.colors || mesh.flags.colors) && !display.display3D.collectingHits)
4222 glEnableClientState(GL_COLOR_ARRAY);
4223 noAB.use(color, 4, GL_FLOAT, 0, mesh.colors);
4226 glDisableClientState(GL_COLOR_ARRAY);
4229 #if !defined(__ANDROID__) && !defined(__APPLE__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
4231 #if defined(__WIN32__)
4235 glLockArraysEXT(0, mesh.nVertices);
4241 void DrawPrimitives(Display display, PrimitiveSingle * primitive, Mesh mesh)
4243 //Logf("DrawPrimitives\n");
4245 if(primitive->type.vertexRange)
4246 glDrawArrays(primitiveTypes[primitive->type.primitiveType], primitive->first, primitive->nVertices);
4249 // *** Hoping the data won't be uploaded at all (Won't really work if another group of the mesh is using the mesh ) ***
4250 // HACK TO SPEED THINGS UP...
4252 /*GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
4253 if(primitive->nIndices < (mesh.nVertices >> 2) && !primitive->type.indices32bit)
4256 glBegin(primitiveTypes[primitive->type.primitiveType]);
4259 OGLIndices oglIndices = primitive->data;
4260 MeshFeatures flags = mesh.flags;
4261 for(c = 0; c<primitive->nIndices; c++)
4263 uint16 index = ((uint16 *) oglIndices.indices)[c];
4264 if(flags.normals) glNormal3fv((float *)&mesh.normals[index]);
4265 if(flags.texCoords1) glTexCoord2fv((float *)&mesh.texCoords[index]);
4266 if(flags.colors) glColor4fv((float *)&mesh.colors[index]);
4267 glVertex3fv((float *)&mesh.vertices[index]);
4275 OGLIndices oglIndices = primitive->data;
4277 if(!display.display3D.collectingHits && vboAvailable && oglIndices)
4279 if(primitive->type.indices32bit)
4280 ; //oglIndices.buffer.draw(primitiveTypes[primitive->type.primitiveType], primitive->nIndices, GL_UNSIGNED_SHORT, 0);
4282 oglIndices.buffer.draw(primitiveTypes[primitive->type.primitiveType], primitive->nIndices, GL_UNSIGNED_SHORT, 0);
4286 if(primitive->type.indices32bit)
4287 glDrawElementsi(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
4288 oglIndices ? oglIndices.indices : primitive->indices);
4290 glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
4291 GL_UNSIGNED_SHORT, oglIndices ? oglIndices.indices : primitive->indices);
4297 void PushMatrix(Display display)
4302 void PopMatrix(Display display, bool setMatrix)
4307 void SetTransform(Display display, Matrix transMatrix, bool viewSpace, bool useCamera)
4309 Matrix matrix = transMatrix;
4310 Camera camera = useCamera ? display.display3D.camera : null;
4315 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
4320 matrix.m[3][0] - camera.cPosition.x,
4321 matrix.m[3][1] - camera.cPosition.y,
4322 matrix.m[3][2] - camera.cPosition.z);
4334 glMultMatrixd(matrix.array);
4339 public void UseSingleGLContext(bool useSingle)
4341 useSingleGLContext = useSingle;
4344 default dllexport void *
4345 #if defined(__WIN32__)
4346 __attribute__((stdcall))
4348 IS_GLGetContext(DisplaySystem displaySystem)
4352 #if defined(__WIN32__)
4353 OGLSystem system = displaySystem.driverData;
4355 #elif defined(__ANDROID__) || defined(__ODROID__)
4357 #elif defined(__EMSCRIPTEN__)
4359 OGLSystem system = displaySystem.driverData;
4360 return system.glContext;