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;
1382 void useVertTrans(uint count, int n, int type, uint stride, void * pointer)
1384 if(curArrayBuffer != ((this != null) ? buffer : 0))
1385 GLBindBuffer(GL_ARRAY_BUFFER, ((this != null) ? buffer : 0));
1387 glVertexPointeri(n, stride, pointer, count);
1388 else if(type == GL_DOUBLE)
1389 glVertexPointerd(n, stride, pointer, count);
1393 static uint curElementBuffer;
1395 public define noEAB = GLEAB { 0 };
1401 void upload(uint size, void * data)
1406 GLGenBuffers(1, (GLAB *)this);
1408 if(curElementBuffer != buffer)
1409 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
1410 glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, data, GL_STATIC_DRAW); //GL_DYNAMIC_DRAW);
1418 GLDeleteBuffers(1, (GLAB *)this);
1423 void draw(int primType, int count, int type, void * indices)
1425 if(curElementBuffer != ((this != null) ? buffer : 0))
1426 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ((this != null) ? buffer : 0));
1427 glDrawElements(primType, count, type, indices);
1431 public void GLGenBuffers(int count, GLAB * buffers)
1433 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
1434 glGenBuffers(count, (GLuint *)buffers);
1436 #if defined(__WIN32__)
1439 glGenBuffersARB(count, (GLuint *)buffers);
1443 public void GLDeleteBuffers(int count, GLAB * buffers)
1446 for(i = 0; i < count; i++)
1448 uint buffer = buffers[i].buffer;
1449 if(buffer == curArrayBuffer)
1450 GLBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
1451 else if(buffer == curElementBuffer)
1452 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
1454 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
1455 glDeleteBuffers(count, (GLuint *)buffers);
1457 #if defined(__WIN32__)
1458 if(glDeleteBuffersARB)
1460 glDeleteBuffersARB(count, (GLuint *)buffers);
1464 void GLBindBuffer(int target, uint buffer)
1466 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
1467 glBindBuffer(target, buffer);
1469 #if defined(__WIN32__)
1472 glBindBufferARB(target, buffer);
1474 if(target == GL_ARRAY_BUFFER_ARB)
1475 curArrayBuffer = buffer;
1476 else if(target == GL_ELEMENT_ARRAY_BUFFER_ARB)
1477 curElementBuffer = buffer;
1480 public void GLVertexPointer(int numCoords, int glType, int stride, void *ptr, int numVertices)
1483 if(glType == GL_DOUBLE)
1484 glesVertexPointerd(numCoords, stride, ptr, numVertices);
1485 else if(glType == GL_INT)
1486 glesVertexPointeri(numCoords, stride, ptr, numVertices);
1489 glVertexPointer(numCoords, glType, stride, ptr);
1492 public void GLBufferData(int type, GLenum target, int size, const GLvoid *data, GLenum usage)
1495 if(type == GL_DOUBLE)
1496 glesBufferDatad(target, size, (void *)data, usage);
1497 else if(type == GL_UNSIGNED_INT)
1498 glesBufferDatai(target, size, (void *)data, usage);
1502 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
1503 glBufferData(target, size, data, usage);
1506 #if defined(__WIN32__)
1509 glBufferDataARB(target, size, data, usage);
1513 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1514 static int primitiveTypes[RenderPrimitiveType] =
1516 GL_POINTS, GL_LINES, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP, GL_LINE_STRIP
1521 // Non OpenGL ES friendly stuff
1525 //#undef GL_UNSIGNED_INT
1530 #undef GL_QUAD_STRIP
1531 #undef GL_POLYGON_STIPPLE
1532 #undef GL_LINE_STIPPLE
1535 #undef GL_ALL_ATTRIB_BITS
1536 #undef GL_LIGHT_MODEL_LOCAL_VIEWER
1540 static int displayWidth, displayHeight;
1542 #define GL_CLAMP_TO_EDGE 0x812F
1544 static bool vboAvailable;
1546 static bool useSingleGLContext = false;
1547 class OGLDisplay : struct
1549 #if defined(__WIN32__)
1559 int imageBuffers[2];
1560 byte * pboMemory1, * pboMemory2;
1562 #elif !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
1563 GLXContext glContext;
1566 XShmSegmentInfo shminfo;
1568 XShmSegmentInfo shminfoShape;
1569 XImage * shapeImage;
1573 X11Picture windowPicture;
1574 X11Picture pixmapPicture;
1576 X11Picture shapePicture;
1579 ColorAlpha * flippingBuffer;
1580 int flipBufH, flipBufW;
1585 class OGLSystem : struct
1590 #if defined(__WIN32__)
1591 PIXELFORMATDESCRIPTOR pfd;
1596 #elif !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
1597 XVisualInfo * visualInfo;
1598 GLXContext glContext;
1599 GLXDrawable glxDrawable;
1603 class OGLSurface : struct
1609 bool writingOutline;
1611 float foreground[4], background[4], bitmapMult[4];
1614 class OGLMesh : struct
1623 class OGLIndices : struct
1633 class OpenGLDisplayDriver : DisplayDriver
1635 class_property(name) = "OpenGL";
1637 bool LockSystem(DisplaySystem displaySystem)
1639 #if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
1640 OGLSystem oglSystem = displaySystem.driverData;
1641 if(useSingleGLContext) return true;
1642 #if defined(__WIN32__)
1643 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1644 #elif defined(__unix__) || defined(__APPLE__)
1645 //if(previous) return true;
1646 // printf("Making SYSTEM current\n");
1647 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)oglSystem.glxDrawable, oglSystem.glContext);
1648 //previous = oglSystem.glContext;
1654 void UnlockSystem(DisplaySystem displaySystem)
1656 if(useSingleGLContext) return;
1657 #if defined(__WIN32__)
1658 wglMakeCurrent(null, null);
1659 #elif defined(__unix__) || defined(__APPLE__)
1660 // printf("Making NULL current\n");
1661 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
1663 glXMakeCurrent(xGlobalDisplay, None, null);
1669 bool Lock(Display display)
1671 #if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
1672 OGLDisplay oglDisplay = display.driverData;
1673 if(useSingleGLContext) return true;
1674 #if defined(__WIN32__)
1675 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1676 #elif defined(__unix__) || defined(__APPLE__)
1677 // if(previous) glXMakeCurrent(xGlobalDisplay, None, null);
1678 // printf(" Making DISPLAY current\n");
1679 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
1685 void Unlock(Display display)
1687 if(useSingleGLContext) return;
1688 //printf(" Making NULL current\n");
1689 //glXMakeCurrent(xGlobalDisplay, None, null);
1691 LockSystem(display.displaySystem);
1694 void DestroyDisplay(Display display)
1696 OGLDisplay oglDisplay = display.driverData;
1700 #if defined(__WIN32__)
1701 wglMakeCurrent( null, null );
1704 wglDeleteContext(oglDisplay.glrc);
1706 if(oglDisplay.hdc && oglDisplay.pBuffer)
1707 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
1709 if(oglDisplay.pBuffer)
1710 wglDestroyPbufferARB(oglDisplay.pBuffer);
1713 ReleaseDC(display.window, oglDisplay.hdc);
1715 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
1716 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
1718 #elif defined(__unix__) || defined(__APPLE__)
1719 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
1721 if(oglDisplay.shapePixmap)
1722 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
1723 if(oglDisplay.pixmap)
1724 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1725 if(oglDisplay.image)
1727 if(oglDisplay.shminfoShape.shmid != -1)
1729 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
1730 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1731 shmdt(oglDisplay.shminfo.shmaddr);
1732 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
1735 if(oglDisplay.shapeImage)
1737 if(oglDisplay.shminfoShape.shmid != -1)
1739 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
1740 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1741 shmdt(oglDisplay.shminfoShape.shmaddr);
1742 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
1744 XDestroyImage(oglDisplay.shapeImage);
1745 oglDisplay.shapeImage = None;
1748 glXMakeCurrent(xGlobalDisplay, None, null);
1750 if(oglDisplay.glContext)
1751 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
1754 delete oglDisplay.flippingBuffer;
1756 display.driverData = null;
1760 void ::CheckExtensions(OGLSystem oglSystem)
1762 const char * extensions = (const char *)glGetString(GL_EXTENSIONS);
1764 oglSystem.pow2textures = strstr(extensions, "GL_ARB_texture_non_power_of_two") ? false : true;
1765 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &oglSystem.maxTextureSize);
1768 bool CreateDisplaySystem(DisplaySystem displaySystem)
1770 bool result = false;
1771 OGLSystem oglSystem = displaySystem.driverData = OGLSystem { };
1774 oglSystem.hwnd = CreateWindow("static", null, 0,0,0,0,0,null,null,null,null);
1776 oglSystem.hdc = GetDC(oglSystem.hwnd);
1780 oglSystem.pfd.nSize = (short)sizeof(oglSystem.pfd);
1781 oglSystem.pfd.nVersion = 1;
1782 oglSystem.pfd.dwFlags = PFD_DRAW_TO_WINDOW /*PFD_DRAW_TO_BITMAP*/ | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
1783 oglSystem.pfd.iPixelType = PFD_TYPE_RGBA;
1784 oglSystem.pfd.cColorBits = 24;
1785 oglSystem.pfd.cAlphaBits = 8;
1786 oglSystem.pfd.cDepthBits = 24;
1787 oglSystem.pfd.iLayerType = PFD_MAIN_PLANE;
1789 oglSystem.format = ChoosePixelFormat(oglSystem.hdc, &oglSystem.pfd);
1790 DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1792 if(oglSystem.pfd.cColorBits > 8)
1794 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1795 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1798 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1800 // Get Pointers To The GL Functions
1801 glActiveTextureARB = (void *) wglGetProcAddress("glActiveTextureARB");
1802 glMultiTexCoord2fARB = (void *) wglGetProcAddress("glMultiTexCoord2fARB");
1803 glClientActiveTextureARB = (void *) wglGetProcAddress("glClientActiveTextureARB");
1804 glLockArraysEXT = (void *) wglGetProcAddress("glLockArraysEXT" );
1805 glUnlockArraysEXT = (void *) wglGetProcAddress("glUnlockArraysEXT");
1806 glGenBuffersARB = (void *) wglGetProcAddress("glGenBuffersARB");
1807 glBindBufferARB = (void *) wglGetProcAddress("glBindBufferARB");
1808 glBufferDataARB = (void *) wglGetProcAddress("glBufferDataARB");
1809 glMapBufferARB = (void *) wglGetProcAddress("glMapBufferARB");
1810 glUnmapBufferARB = (void *) wglGetProcAddress("glUnmapBufferARB");
1811 glDeleteBuffersARB = (void *) wglGetProcAddress("glDeleteBuffersARB");
1812 glBlendFuncSeparate = (void *) wglGetProcAddress("glBlendFuncSeparate");
1814 wglChoosePixelFormatARB = (void *) wglGetProcAddress("wglChoosePixelFormatARB");
1815 wglGetExtensionsStringARB = (void *)wglGetProcAddress("wglGetExtensionsStringARB");
1816 wglCreatePbufferARB = (void *)wglGetProcAddress("wglCreatePbufferARB");
1817 wglGetPbufferDCARB = (void *)wglGetProcAddress("wglGetPbufferDCARB");
1818 wglQueryPbufferARB = (void *)wglGetProcAddress("wglQueryPbufferARB");
1819 wglDestroyPbufferARB = (void *)wglGetProcAddress("wglDestroyPbufferARB");
1820 wglReleasePbufferDCARB = (void *)wglGetProcAddress("wglReleasePbufferDCARB");
1821 wglBindTexImageARB = (void *)wglGetProcAddress("wglBindTexImageARB");
1822 wglReleaseTexImageARB = (void *)wglGetProcAddress("wglReleaseTexImageARB");
1824 wglSwapIntervalEXT = (void *)wglGetProcAddress("wglSwapIntervalEXT");
1826 vboAvailable = glBindBufferARB != null;
1828 // eSystem_LoggingMode(LOG_MSGBOX, null);
1830 if(wglChoosePixelFormatARB)
1835 float fAttributes[] = {0,0};
1838 WGL_DRAW_TO_WINDOW_ARB,GL_TRUE,
1839 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1840 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
1841 WGL_COLOR_BITS_ARB,24,
1842 WGL_ALPHA_BITS_ARB,8,
1843 WGL_DEPTH_BITS_ARB,16,
1844 WGL_STENCIL_BITS_ARB,0,
1845 WGL_DOUBLE_BUFFER_ARB,GL_TRUE,
1846 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
1847 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
1851 //Log("Found wglChoosePixelFormatARB\n");
1853 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1854 if(!valid || !numFormats)
1856 //Log("Can't find 4x multi sampling\n");
1857 iAttributes[19] = 2;
1858 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1859 if(!valid || !numFormats)
1861 // Log("Can't find 2x multi sampling\n");
1862 iAttributes[16] = 0;
1863 iAttributes[17] = 0;
1864 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1867 if(valid && numFormats)
1869 oglSystem.format = pixelFormat;
1870 wglMakeCurrent(null, null);
1871 wglDeleteContext(oglSystem.glrc);
1873 // *** DescribePixelFormat does not support WGL pixel formats! ***
1874 //DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1875 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1876 //Log("Successfully set pixel format\n");
1878 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1879 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1883 eSystem_Logf("Can't find wglChoosePixelFormatARB\n");*/
1887 CheckExtensions(oglSystem);
1889 wglMakeCurrent(null, null);
1891 //eSystem_DumpErrors(true);
1895 #elif defined(__unix__) || defined(__APPLE__)
1896 vboAvailable = true;
1897 #if defined(__ANDROID__)
1898 egl_init_display(guiApp.desktop.windowHandle);
1899 #elif defined(__ODROID__)
1900 egl_init_display((uint)displaySystem.window);
1901 CheckExtensions(oglSystem);
1903 #elif defined(__EMSCRIPTEN__)
1904 if(glfwInit() == GL_TRUE)
1906 const int width = 640, height = 480;
1907 if(glfwOpenWindow(width, height, 8, 8, 8, 8, 16, 0, GLFW_WINDOW) == GL_TRUE)
1909 //glfwSwapBuffers();
1913 printf("glfwOpenWindow() failed\n"); //glfwTerminate();
1916 printf("glfwInit() failed\n"); //glfwTerminate();
1919 X11Window root = RootWindow( xGlobalDisplay, DefaultScreen( xGlobalDisplay ) );
1920 XSetWindowAttributes attr;
1925 #ifndef ECERE_MINIGLX
1926 GLX_USE_GL, GLX_DEPTH_SIZE, 1,
1929 GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,
1933 oglSystem.visualInfo = glXChooseVisual( xGlobalDisplay, DefaultScreen( xGlobalDisplay ), attrList );
1934 attr.background_pixel = 0;
1935 attr.border_pixel = 0;
1936 attr.colormap = XCreateColormap( xGlobalDisplay, root, oglSystem.visualInfo->visual, AllocNone);
1937 attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
1938 mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
1940 oglSystem.glxDrawable = XCreateWindow( xGlobalDisplay, root, 0, 0, 1, 1, 0, oglSystem.visualInfo->depth, InputOutput,
1941 oglSystem.visualInfo->visual, mask, &attr );
1943 if(oglSystem.visualInfo)
1945 oglSystem.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, null, True);
1946 if(oglSystem.glContext)
1948 glXMakeCurrent(xGlobalDisplay, oglSystem.glxDrawable, oglSystem.glContext);
1950 CheckExtensions(oglSystem);
1951 glXMakeCurrent(xGlobalDisplay, None, null);
1958 displaySystem.flags.alpha = true;
1959 displaySystem.flags.flipping = true;
1960 displaySystem.pixelFormat = pixelFormat888;
1964 void DestroyDisplaySystem(DisplaySystem displaySystem)
1966 OGLSystem oglSystem = displaySystem.driverData;
1968 #if defined(__WIN32__)
1969 wglMakeCurrent( null, null );
1972 wglDeleteContext(oglSystem.glrc);
1975 ReleaseDC(oglSystem.hwnd, oglSystem.hdc);
1976 DestroyWindow(oglSystem.hwnd);
1978 #elif defined(__unix__) || defined(__APPLE__)
1979 #if defined(__ANDROID__) || defined(__ODROID__)
1981 #elif defined(__EMSCRIPTEN__)
1984 if(oglSystem.visualInfo)
1986 #ifdef ECERE_MINIGLX
1987 __miniglx_XFree(oglSystem.visualInfo);
1989 XFree(oglSystem.visualInfo);
1993 if(oglSystem.glxDrawable)
1995 XDestroyWindow(xGlobalDisplay, oglSystem.glxDrawable);
1996 oglSystem.glxDrawable = 0;
2003 bool CreateDisplay(Display display)
2005 bool result = false;
2006 OGLDisplay oglDisplay = display.driverData;
2007 #if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
2008 OGLSystem oglSystem = display.displaySystem.driverData;
2011 oglDisplay = display.driverData = OGLDisplay { };
2012 //printf("Inside CreateDisplay\n");
2014 #if defined(__WIN32__) || defined(USEPBUFFER)
2015 if(!display.alphaBlend)
2018 #if defined(__WIN32__)
2019 oglDisplay.hdc = GetDC(display.window);
2020 SetPixelFormat(oglDisplay.hdc, oglSystem.format, &oglSystem.pfd);
2021 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
2023 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2024 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2028 ReleaseDC(display.window, oglDisplay.hdc);
2029 #elif defined(__unix__) || defined(__APPLE__)
2030 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2032 XVisualInfo * visualInfo = ((XWindowData)display.windowDriverData).visual;
2034 #if defined(__APPLE__)
2035 XVisualInfo template = { 0 };
2036 XWindowAttributes winAttr;
2038 XGetWindowAttributes(xGlobalDisplay, (X11Window)display.window, &winAttr);
2039 template.visualid = XVisualIDFromVisual(winAttr.visual);
2040 visualInfo = XGetVisualInfo(xGlobalDisplay, VisualIDMask, &template, &n);
2042 printf("XGetVisualInfo visual ID = %d\n", template.visualid);
2043 printf("visualInfo visual ID = %d\n", visualInfo->visualid);
2044 printf("oglSystem.visualInfo visual ID = %d\n", oglSystem.visualInfo->visualid);
2045 printf("((XWindowData)display.windowDriverData).visual visual ID = %d\n", ((XWindowData)display.windowDriverData).visual->visualid);
2047 // visualInfo = oglSystem.visualInfo;
2052 //printf("visualInfo is not null\n");
2053 // printf("Creating Display Context, sharing with %x!\n", oglSystem.glContext);
2054 oglDisplay.glContext = glXCreateContext(xGlobalDisplay, visualInfo, oglSystem.glContext, True);
2055 //XFree(visualInfo);
2058 // oglDisplay.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, oglSystem.glContext, True);
2059 if(oglDisplay.glContext)
2061 //printf("CreateDisplay Got a Context\n");
2062 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2068 #if defined(__WIN32__) || defined(USEPBUFFER)
2074 #if defined(__WIN32__)
2075 if(glBlendFuncSeparate)
2076 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2078 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2080 #if !defined(__OLDX__)
2081 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2083 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2088 glMatrixMode(GL_MODELVIEW);
2089 glScaled(1.0, 1.0, -1.0);
2090 // glTranslatef(0.375f, 0.375f, 0.0f);
2091 // glTranslatef(-0.625f, -0.625f, 0.0f);
2092 glMatrixMode(GL_PROJECTION);
2093 glShadeModel(GL_FLAT);
2095 // glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, true);
2096 #if !defined(EM_MODE)
2097 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
2099 glFogi(GL_FOG_MODE, GL_EXP);
2100 glFogf(GL_FOG_DENSITY, 0);
2101 glEnable(GL_NORMALIZE);
2102 glDepthFunc(GL_LESS);
2104 glDisable(GL_MULTISAMPLE_ARB);
2106 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
2107 display.ambient = Color { 50,50,50 };
2110 if(!useSingleGLContext)
2112 #if defined(__WIN32__)
2113 wglMakeCurrent(null, null);
2114 #elif defined(__unix__) || defined(__APPLE__)
2115 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2118 glXMakeCurrent(xGlobalDisplay, None, null);
2124 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2132 bool DisplaySize(Display display, int width, int height)
2134 OGLDisplay oglDisplay = display.driverData;
2136 bool result = false;
2138 //printf("Inside DisplaySize\n");
2139 #if defined(__WIN32__) || defined(USEPBUFFER)
2140 OGLSystem oglSystem = display.displaySystem.driverData;
2141 if(display.alphaBlend)
2143 #if defined(__WIN32__)
2144 const int attributes[]=
2146 /*WGL_TEXTURE_FORMAT_ARB, WGL_TEXTURE_RGBA_ARB,
2147 WGL_TEXTURE_TARGET_ARB, WGL_TEXTURE_2D_ARB, */0
2149 int pixelFormat = 0;
2150 if(wglChoosePixelFormatARB)
2154 float fAttributes[] = {0,0};
2157 //WGL_DRAW_TO_BITMAP_ARB, GL_TRUE,
2158 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2159 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2160 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
2161 WGL_COLOR_BITS_ARB,24,
2162 WGL_ALPHA_BITS_ARB,8,
2163 WGL_DEPTH_BITS_ARB,16,
2164 WGL_STENCIL_BITS_ARB,0,
2165 WGL_DOUBLE_BUFFER_ARB,GL_FALSE,
2166 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
2167 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
2171 //Log("Found wglChoosePixelFormatARB\n");
2173 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2174 if(!valid || !numFormats)
2176 //Log("Can't find 4x multi sampling\n");
2177 iAttributes[19] = 2;
2178 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2179 if(!valid || !numFormats)
2181 // Log("Can't find 2x multi sampling\n");
2182 iAttributes[16] = 0;
2183 iAttributes[17] = 0;
2184 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2185 if(!valid || !numFormats)
2189 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2190 //WGL_DRAW_TO_BITMAP_ARB,GL_TRUE,
2191 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2192 WGL_COLOR_BITS_ARB,24,
2193 WGL_ALPHA_BITS_ARB,8,
2194 WGL_DEPTH_BITS_ARB,16,
2197 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2201 if(valid && numFormats)
2203 wglMakeCurrent(null, null);
2207 wglMakeCurrent( null, null );
2208 wglMakeCurrent( oglDisplay.hdc, oglDisplay.glrc );
2209 if(oglDisplay.hdc && oglDisplay.pBuffer)
2210 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
2212 wglDestroyPbufferARB(oglDisplay.pBuffer);
2214 if(!useSingleGLContext)
2215 wglMakeCurrent( null, null );
2218 wglDeleteContext(oglDisplay.glrc);
2220 oglDisplay.pBuffer = wglCreatePbufferARB(oglSystem.hdc, pixelFormat, width, height, attributes);
2221 oglDisplay.hdc = wglGetPbufferDCARB(oglDisplay.pBuffer);
2222 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
2225 HDC hdc = GetDC(display.window);
2227 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2228 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2230 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_WIDTH_ARB, &width);
2231 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_HEIGHT_ARB, &height);
2233 // glDeleteBuffersARB(2, oglDisplay.imageBuffers);
2235 if((info = (BITMAPINFO *)new0 byte[sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*256]))
2239 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
2240 oglDisplay.memDC = CreateCompatibleDC(hdc);
2241 SetMapMode(oglDisplay.memDC, MM_TEXT);
2242 info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2243 info->bmiHeader.biPlanes = 1;
2244 info->bmiHeader.biCompression = BI_RGB;
2245 info->bmiHeader.biBitCount = 32; //(uint16)GetDeviceCaps(hdc, BITSPIXEL);
2246 info->bmiHeader.biWidth = width;
2247 info->bmiHeader.biHeight = height;
2248 newBitmap = CreateDIBSection(hdc, info, DIB_RGB_COLORS, &oglDisplay.picture, null, 0);
2251 SelectObject(oglDisplay.memDC, newBitmap);
2252 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
2255 PIXELFORMATDESCRIPTOR pfd = { 0 };
2256 pfd.nSize = (short)sizeof(pfd);
2258 pfd.dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL;
2259 pfd.iPixelType = PFD_TYPE_RGBA;
2260 pfd.cColorBits = 32;
2261 //pfd.cAlphaBits = 8;
2262 pfd.cDepthBits = 24;
2263 pfd.iLayerType = PFD_MAIN_PLANE;
2265 oglDisplay.hdc = oglDisplay.memDC;
2267 pixelFormat = ChoosePixelFormat(oglSystem.hdc, &pfd);
2268 DescribePixelFormat(oglDisplay.hdc, pixelFormat, sizeof(pfd), &pfd);
2269 SetPixelFormat(oglDisplay.hdc, pixelFormat, &pfd);
2271 oglDisplay.glrc = wglCreateContext(oglDisplay.hdc);
2272 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2273 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2278 const int imageSize = width * height * 4;
2280 glGenBuffersARB(2, oglDisplay.imageBuffers);
2282 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2283 glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize, null, GL_STREAM_READ);
2284 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2285 // glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize / 2, null, GL_STREAM_READ);
2288 oglDisplay.memBitmap = newBitmap;
2289 oglDisplay.stride = width;
2295 ReleaseDC(display.window, hdc);
2297 #elif defined(__unix__) || defined(__APPLE__)
2298 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2303 GLX_DOUBLEBUFFER, True,
2309 GLX_STENCIL_SIZE, 1,
2310 //GLX_DEPTH_SIZE, 24,
2311 GLX_RENDER_TYPE, GLX_RGBA_BIT,
2312 GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT | GLX_WINDOW_BIT,
2318 GLX_PBUFFER_WIDTH, width,
2319 GLX_PBUFFER_HEIGHT, height,
2320 GLX_LARGEST_PBUFFER, False,
2324 // choose a pixel format that meets our minimum requirements
2327 GLXFBConfig *config = glXChooseFBConfig(xGlobalDisplay, DefaultScreen(xGlobalDisplay), attrib, &count);
2330 if(oglDisplay.pixmap)
2332 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2333 oglDisplay.pixmap = None;
2335 if(oglDisplay.shapePixmap)
2337 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
2338 oglDisplay.shapePixmap = None;
2341 // Free Shared Memory Pixmap
2342 if(oglDisplay.image)
2344 if(oglDisplay.shminfoShape.shmid != -1)
2346 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
2347 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2348 shmdt(oglDisplay.shminfo.shmaddr);
2349 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
2351 XDestroyImage(oglDisplay.image);
2352 oglDisplay.image = None;
2354 if(oglDisplay.shapeImage)
2356 if(oglDisplay.shminfoShape.shmid != -1)
2358 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
2359 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2360 shmdt(oglDisplay.shminfoShape.shmaddr);
2361 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
2363 XDestroyImage(oglDisplay.shapeImage);
2364 oglDisplay.shapeImage = None;
2367 if(oglDisplay.windowPicture)
2368 XRenderFreePicture(xGlobalDisplay, oglDisplay.windowPicture);
2369 if(oglDisplay.pixmapPicture)
2370 XRenderFreePicture(xGlobalDisplay, oglDisplay.pixmapPicture);
2372 if(oglDisplay.pixmap)
2373 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2375 if(oglDisplay.glContext)
2376 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
2377 if(oglDisplay.pBuffer)
2378 glXDestroyPbuffer(xGlobalDisplay, oglDisplay.pBuffer);
2380 oglDisplay.pBuffer = glXCreatePbuffer(xGlobalDisplay, config[0], PBattrib);
2381 if(oglDisplay.pBuffer)
2383 oglDisplay.glContext = glXCreateNewContext(xGlobalDisplay, config[0], GLX_RGBA_TYPE, oglSystem.glContext, True);
2384 if(oglDisplay.glContext)
2386 glXMakeCurrent(xGlobalDisplay, None, null);
2387 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2389 // Initialize Shared Memory Pixmap
2390 oglDisplay.image = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 32,
2391 ZPixmap, null, &oglDisplay.shminfo, width, height);
2392 if(oglDisplay.image)
2394 oglDisplay.shminfo.shmid = shmget(IPC_PRIVATE,
2395 oglDisplay.image->bytes_per_line * oglDisplay.image->height, IPC_CREAT|0777);
2396 if(oglDisplay.shminfo.shmid != -1)
2398 oglDisplay.shminfo.shmaddr = shmat(oglDisplay.shminfo.shmid, 0, 0);
2399 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2401 oglDisplay.shminfo.readOnly = False;
2402 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfo))
2404 oglDisplay.pixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfo.shmaddr,
2405 &oglDisplay.shminfo, width, height, 32);
2407 // Initialize Shared Memory Shape Pixmap
2408 oglDisplay.shapeImage = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 1,
2409 ZPixmap, null, &oglDisplay.shminfoShape, width, height);
2410 if(oglDisplay.shapeImage)
2412 oglDisplay.shminfoShape.shmid = shmget(IPC_PRIVATE,
2413 oglDisplay.shapeImage->bytes_per_line * oglDisplay.shapeImage->height, IPC_CREAT|0777);
2414 if(oglDisplay.shminfoShape.shmid != -1)
2416 oglDisplay.shminfoShape.shmaddr = shmat(oglDisplay.shminfoShape.shmid, 0, 0);
2417 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2419 oglDisplay.shminfoShape.readOnly = False;
2420 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfoShape))
2422 oglDisplay.shapePixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfoShape.shmaddr,
2423 &oglDisplay.shminfoShape, width, height, 1);
2424 //oglDisplay.shapePixmap = XCreatePixmap(xGlobalDisplay, (X11Window)display.window, width, height, 1);
2427 XRenderPictureAttributes attributes = { 0 };
2428 XRenderPictFormat * format = XRenderFindStandardFormat(xGlobalDisplay, /*PictStandardRGB24*/ PictStandardARGB32);
2429 #if !defined(__APPLE__) && !defined(__OLDX__)
2430 attributes.repeat = RepeatNormal;
2432 attributes.repeat = 1;
2434 oglDisplay.pixmapPicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.pixmap, format, CPRepeat, &attributes);
2435 oglDisplay.windowPicture = XRenderCreatePicture(xGlobalDisplay, (X11Window)display.window, format, 0, &attributes);
2436 oglDisplay.shapePicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.shapePixmap,
2437 XRenderFindStandardFormat(xGlobalDisplay, PictStandardA1), 0, &attributes);
2440 oglDisplay.picture = oglDisplay.shminfo.shmaddr;
2441 oglDisplay.stride = oglDisplay.image->bytes_per_line / 4;
2458 CreateDisplay(display);
2459 #if defined(__WIN32__)
2460 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2461 #elif defined(__unix__) || defined(__APPLE__)
2462 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2466 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2473 if(!result && display.alphaBlend)
2475 printf("Alpha blending windows not supported on this display\n");
2482 glViewport(0,0,width,height);
2484 glOrtho(0,width,height,0,0.0,1.0);
2485 displayWidth = display.width = width;
2486 displayHeight = display.height = height;
2488 if(!oglDisplay.flippingBuffer || oglDisplay.flipBufW < width || oglDisplay.flipBufH < height)
2490 oglDisplay.flipBufW = width;
2491 oglDisplay.flipBufH = height;
2495 oglDisplay.flippingBuffer = renew oglDisplay.flippingBuffer ColorAlpha [width * height];
2498 if(oglDisplay.flippingBuffer || !width || !height)
2504 void DisplayPosition(Display display, int x, int y)
2506 OGLDisplay oglDisplay = display.driverData;
2512 void SetPalette(Display display, ColorAlpha * palette, bool colorMatch)
2516 void RestorePalette(Display display)
2520 void StartUpdate(Display display)
2524 void EndUpdate(Display display)
2528 void Scroll(Display display, Box scroll, int x, int y, Extent dirty)
2532 void Update(Display display, Box updateBox)
2534 #if defined(__WIN32__) || defined(USEPBUFFER)
2535 OGLDisplay oglDisplay = display.driverData;
2537 //Logf("DisplayScreen\n");
2541 #if defined(__WIN32__) || defined(USEPBUFFER)
2542 if(display.alphaBlend)
2544 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2545 glPixelStorei(GL_PACK_ROW_LENGTH, oglDisplay.stride);
2546 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2547 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2548 glReadPixels(0,0,display.width,display.height,GL_BGRA_EXT,GL_UNSIGNED_BYTE, oglDisplay.picture);
2551 #if defined(__WIN32__)
2553 POINT point = { oglDisplay.x, oglDisplay.y};
2554 POINT srcPoint = { 0, 0 };
2555 BLENDFUNCTION blend = { 0 };
2557 size.cx = display.width;
2558 size.cy = display.height;
2559 blend.BlendOp = AC_SRC_OVER;
2560 blend.BlendFlags = 0;
2561 blend.SourceConstantAlpha = 255;
2562 blend.AlphaFormat = AC_SRC_ALPHA;
2565 // Process partial images. Mapping the buffer waits for
2566 // outstanding DMA transfers into the buffer to finish.
2567 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2568 oglDisplay.pboMemory1 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY);
2570 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2571 // oglDisplay.pboMemory2 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB,GL_READ_ONLY);
2574 memcpy(oglDisplay.picture, oglDisplay.pboMemory1, display.width * display.height * 4);
2575 //memcpy(oglDisplay.picture + display.width * display.height * 4 / 2, oglDisplay.pboMemory2, display.width * display.height * 4/ 2);
2578 UpdateLayeredWindow(display.window, hdc, &point, &size, oglDisplay.memDC, &srcPoint, 0, &blend, ULW_ALPHA);
2581 // Unmap the image buffers
2582 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2583 glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2585 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2586 // glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2588 // Bind two different buffer objects and start the glReadPixels
2589 // asynchronously. Each call will return directly after
2590 // starting the DMA transfer.
2591 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2592 glReadPixels(0, 0, display.width, display.height, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2594 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2595 // glReadPixels(0, display.height/2, display.width, display.height/2, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2599 #elif defined(__unix__) || defined(__APPLE__)
2600 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2602 XTransform transform =
2605 { (int)(1.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(0 * (1 << 16)) },
2606 { (int)(0.0f), (int)(-1.0f * (1<<16)), (int)(0 * (1<<16)) },
2607 { (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)) }
2610 XRenderSetPictureTransform(xGlobalDisplay, oglDisplay.pixmapPicture, &transform);
2611 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.shapePicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2612 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.windowPicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2613 #if !defined(__APPLE__) && !defined(__OLDX__)
2614 XShapeCombineMask(xGlobalDisplay, (X11Window)display.window, ShapeInput, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2616 XShapeCombineMask(xGlobalDisplay, display.window, 2, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2618 XFlush(xGlobalDisplay);
2626 #if defined(__WIN32__)
2627 //wglSwapLayerBuffers(oglDisplay.hdc,WGL_SWAP_MAIN_PLANE);
2628 SwapBuffers(oglDisplay.hdc);
2629 #elif defined(__unix__) || defined(__APPLE__)
2630 #if defined(__ANDROID__) || defined(__ODROID__)
2631 eglSwapBuffers(eglDisplay, eglSurface);
2632 #elif defined(__EMSCRIPTEN__)
2635 glXSwapBuffers(xGlobalDisplay, (GLXDrawable)display.window);
2639 //Logf("Out of DisplayScreen\n");
2642 void FreeBitmap(DisplaySystem displaySystem, Bitmap bitmap)
2644 if(bitmap.driverData)
2646 GLuint tex = (GLuint)(uintptr)bitmap.driverData;
2647 glDeleteTextures(1, &tex);
2648 bitmap.driverData = 0;
2650 bitmap.driver = ((subclass(DisplayDriver))class(LFBDisplayDriver));
2653 bool AllocateBitmap(DisplaySystem displaySystem, Bitmap bitmap, int width, int height, int stride, PixelFormat format, bool allocatePalette)
2655 OGLSystem oglSystem = displaySystem.driverData;
2656 bool result = false;
2658 GLuint glBitmap = 0;
2660 uint w = width, h = height;
2661 if(oglSystem.pow2textures)
2666 w = Min(w, oglSystem.maxTextureSize);
2667 h = Min(h, oglSystem.maxTextureSize);
2669 glGenTextures(1, &glBitmap);
2670 glBindTexture(GL_TEXTURE_2D, glBitmap);
2672 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2674 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2675 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2677 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2678 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2680 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2682 mipMap.Allocate(null, w, h, w, pixelFormatRGBA, false);
2684 // glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2685 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2689 bitmap.driverData = (void *)(uintptr)glBitmap;
2690 bitmap.driver = displaySystem.driver;
2698 bool MakeDDBitmap(DisplaySystem displaySystem, Bitmap bitmap, bool mipMaps)
2700 bool result = false;
2701 OGLSystem oglSystem = displaySystem.driverData;
2702 Bitmap convBitmap = bitmap;
2706 convBitmap.Copy(bitmap);
2709 // Pre process the bitmap... First make it 32 bit
2710 if(/*bitmap.pixelFormat == pixelFormatRGBA || */convBitmap.Convert(null, pixelFormat888, null))
2713 uint w = bitmap.width, h = bitmap.height;
2714 GLuint glBitmap = 0;
2715 if(oglSystem.pow2textures)
2720 w = Min(w, oglSystem.maxTextureSize);
2721 h = Min(h, oglSystem.maxTextureSize);
2725 while(w * 2 < h) w *= 2;
2726 while(h * 2 < w) h *= 2;
2729 // Switch ARGB to RGBA
2730 //if(bitmap.format != pixelFormatRGBA)
2732 for(c=0; c<bitmap.size; c++)
2734 // ((ColorRGBA *)bitmap.picture)[c] = ((ColorAlpha *)bitmap.picture)[c];
2736 ColorAlpha color = ((ColorAlpha *)convBitmap.picture)[c];
2737 ((ColorRGBA *)convBitmap.picture)[c] = ColorRGBA { color.color.r, color.color.g, color.color.b, color.a };
2740 // convBitmap.pixelFormat = pixelFormat888;
2743 glGenTextures(1, &glBitmap);
2746 //int error = glGetError();
2750 glBindTexture(GL_TEXTURE_2D, glBitmap);
2751 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2753 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2754 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mipMaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
2755 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2757 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
2758 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
2760 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2761 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2763 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2767 for(level = 0; result && (w > 1 || h > 1); level++, w >>= 1, h >>= 1)
2770 if(bitmap.width != w || bitmap.height != h)
2772 mipMap = Bitmap { };
2773 if(mipMap.Allocate(null, w, h, w, convBitmap.pixelFormat, false))
2775 Surface mipSurface = mipMap.GetSurface(0,0,null);
2776 mipSurface.Filter(convBitmap, 0,0,0,0, w, h, convBitmap.width, convBitmap.height);
2786 mipMap = convBitmap;
2793 // glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2794 glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2795 //printf("Calling glTexImage2D\n");
2796 //glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &width);
2797 //printf("width = %d (Should be %d, %d)\n", width, w, h);
2798 if((error = glGetError()))
2800 //Logf("OpenGL Bitmap MakeDD error: %d...\n", error);
2801 //printf("OpenGL Bitmap MakeDD error: %d...\n", error);
2805 if(mipMap != convBitmap)
2810 convBitmap.driver.FreeBitmap(convBitmap.displaySystem, convBitmap);
2811 bitmap.driverData = (void *)(uintptr)glBitmap;
2812 bitmap.driver = displaySystem.driver;
2817 FreeBitmap(displaySystem, bitmap);
2818 else if(oglSystem.loadingFont)
2820 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2821 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2822 oglSystem.loadingFont = false;
2828 void ReleaseSurface(Display display, Surface surface)
2830 glDisable(GL_SCISSOR_TEST);
2831 delete surface.driverData;
2832 surface.driverData = null;
2835 bool GetBitmapSurface(DisplaySystem displaySystem, Surface surface, Bitmap bitmap, int x, int y, Box clip)
2840 bool GetSurface(Display display, Surface surface, int x,int y, Box clip)
2842 bool result = false;
2843 OGLSurface oglSurface = surface.driverData = OGLSurface { };
2845 //Logf("GetSurface\n");
2849 if(displayWidth != display.width || displayHeight != display.height)
2851 displayWidth = display.width;
2852 displayHeight = display.height;
2854 glViewport(0,0,display.width,display.height);
2856 glOrtho(0,display.width,display.height,0,0.0,1.0);
2859 surface.offset.x = x;
2860 surface.offset.y = y;
2861 surface.unclippedBox = surface.box = clip;
2862 oglSurface.bitmapMult[0] = 1;
2863 oglSurface.bitmapMult[1] = 1;
2864 oglSurface.bitmapMult[2] = 1;
2865 oglSurface.bitmapMult[3] = 1;
2867 glEnable(GL_SCISSOR_TEST);
2870 (display.height) -(y+clip.bottom)-1,
2871 clip.right-clip.left+1,
2872 clip.bottom-clip.top+1);
2878 void Clip(Display display, Surface surface, Box clip)
2887 box.Clip(surface.unclippedBox);
2891 box = surface.box = surface.unclippedBox;
2892 box.left += surface.offset.x;
2893 box.top += surface.offset.y;
2894 box.right+= surface.offset.x;
2895 box.bottom += surface.offset.y;
2898 box.left,display.height - box.bottom - 1,
2899 box.right-box.left+1, box.bottom-box.top+1);
2902 bool GrabScreen(Display display, Bitmap bitmap, int x, int y, unsigned int w, unsigned int h)
2904 bool result = false;
2905 OGLDisplay oglDisplay = display.driverData;
2906 ColorAlpha * flippingBuffer = oglDisplay.flippingBuffer;
2908 if(oglDisplay.flippingBuffer)
2910 if(bitmap.pixelFormat != pixelFormat888 || bitmap.width < w || bitmap.height < h)
2913 bitmap.Allocate(null, w,h,w, pixelFormat888, false);
2919 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2920 glPixelStorei(GL_PACK_ROW_LENGTH, bitmap.stride);
2921 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2922 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2923 glReadPixels(x,display.height-h-y,w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, flippingBuffer);
2926 for(row = 0; row<h; row++)
2927 CopyBytesBy4(((ColorAlpha *)bitmap.picture) + row * w, ((ColorAlpha *)flippingBuffer) + (h-row-1) * w, w);
2934 void SetForeground(Display display, Surface surface, ColorAlpha color)
2936 OGLSurface oglSurface = surface.driverData;
2938 //Logf("SetForeground\n");
2940 oglSurface.foreground[0] = color.color.r/255.0f;
2941 oglSurface.foreground[1] = color.color.g/255.0f;
2942 oglSurface.foreground[2] = color.color.b/255.0f;
2943 //oglSurface.foreground[3] = 1.0f;
2944 oglSurface.foreground[3] = color.a/255.0f;
2946 //if(!oglSurface.foreground[3])printf("bug");
2949 void SetBackground(Display display, Surface surface, ColorAlpha color)
2951 OGLSurface oglSurface = surface.driverData;
2953 //Logf("SetBackground\n");
2955 oglSurface.background[0] = color.color.r/255.0f;
2956 oglSurface.background[1] = color.color.g/255.0f;
2957 oglSurface.background[2] = color.color.b/255.0f;
2958 //oglSurface.background[3] = 1.0;
2959 oglSurface.background[3] = color.a/255.0f;
2962 void SetBlitTint(Display display, Surface surface, ColorAlpha color)
2964 OGLSurface oglSurface = surface.driverData;
2966 oglSurface.bitmapMult[0] = color.color.r/255.0f;
2967 oglSurface.bitmapMult[1] = color.color.g/255.0f;
2968 oglSurface.bitmapMult[2] = color.color.b/255.0f;
2969 oglSurface.bitmapMult[3] = color.a/255.0f;
2972 ColorAlpha GetPixel(Display display, Surface surface,int x,int y)
2977 void PutPixel(Display display, Surface surface,int x,int y)
2979 OGLSurface oglSurface = surface.driverData;
2981 //Logf("PutPixel\n");
2983 glColor4fv(oglSurface.foreground);
2985 // glVertex2i(x+surface.offset.x, y+surface.offset.y);
2986 glVertex2f(x+surface.offset.x + 0.5f, y+surface.offset.y + 0.5f);
2991 void DrawLine(Display display, Surface surface, int _x1, int _y1, int _x2, int _y2)
2993 OGLSurface oglSurface = surface.driverData;
2994 float x1 = _x1, x2 = _x2, y1 = _y1, y2 = _y2;
3009 x1 += surface.offset.x;
3010 y1 += surface.offset.y;
3011 x2 += surface.offset.x;
3012 y2 += surface.offset.y;
3016 glColor4fv(oglSurface.foreground);
3018 #if defined(_GLES) || defined(EM_MODE)
3021 glTexCoord2f(0.5f, 0);
3022 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3023 glTexCoord2f(Max(x2-x1, y2-y1) + 0.5f, 0);
3024 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3033 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3034 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3040 void Rectangle(Display display, Surface surface,int x1,int y1,int x2,int y2)
3042 OGLSurface oglSurface = surface.driverData;
3043 x1 += surface.offset.x;
3044 y1 += surface.offset.y;
3045 x2 += surface.offset.x;
3046 y2 += surface.offset.y;
3048 //Logf("Rectangle\n");
3050 glColor4fv(oglSurface.foreground);
3051 #if defined(_GLES) || defined(EM_MODE)
3056 glTexCoord2f(0.5f, 0);
3057 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3058 glTexCoord2f(y2-y1 + 0.5f, 0);
3059 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3061 glTexCoord2f(0.5f, 0);
3062 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3063 glTexCoord2f(x2 - x1 + 0.5f, 0);
3064 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3066 glTexCoord2f(0.5f, 0);
3067 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3068 glTexCoord2f(y1 - y2 + 0.5f, 0);
3069 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3071 glTexCoord2f(0.5f, 0);
3072 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3073 glTexCoord2f(x1 - x2 + 0.5f, 0);
3074 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3079 glBegin(GL_LINE_LOOP);
3086 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3087 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3088 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3089 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3094 void Area(Display display, Surface surface,int x1,int y1,int x2,int y2)
3096 OGLSurface oglSurface = surface.driverData;
3099 glColor4fv(oglSurface.background);
3103 glVertex2f(x1+surface.offset.x, y1+surface.offset.y);
3104 glVertex2f(x1+surface.offset.x, y2+surface.offset.y+1);
3105 glVertex2f(x2+surface.offset.x+1, y2+surface.offset.y+1);
3106 glVertex2f(x2+surface.offset.x+1, y1+surface.offset.y);
3109 glRecti(x1+surface.offset.x, y1+surface.offset.y,
3110 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
3113 glRectf(x1+surface.offset.x, y1+surface.offset.y,
3114 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
3118 void Clear(Display display, Surface surface, ClearType type)
3120 OGLDisplay oglDisplay = display.driverData;
3121 OGLSurface oglSurface = surface.driverData;
3124 if(type != depthBuffer)
3125 glClearColor(oglSurface.background[0], oglSurface.background[1], oglSurface.background[2], oglSurface.background[3]);
3126 if(type != colorBuffer && !oglDisplay.depthWrite)
3128 glDepthMask((byte)bool::true);
3130 glClear(((type != depthBuffer) ? GL_COLOR_BUFFER_BIT : 0) |
3131 ((type != colorBuffer) ? GL_DEPTH_BUFFER_BIT : 0));
3132 if(type != colorBuffer && !oglDisplay.depthWrite)
3134 glDepthMask((byte)bool::false);
3138 bool ConvertBitmap(DisplaySystem displaySystem, Bitmap bitmap, PixelFormat format, ColorAlpha * palette)
3143 void Blit(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3145 OGLSurface oglSurface = surface.driverData;
3147 #if !defined(__OLDX__)
3148 // WHY DO WE HAVE GL_ONE HERE ?
3149 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3150 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3153 if(!oglSurface.writingText)
3155 // glTranslatef(-0.375f, -0.375f, 0.0f);
3156 glEnable(GL_TEXTURE_2D);
3157 glColor4fv(oglSurface.bitmapMult);
3159 else if(oglSurface.xOffset)
3160 glTranslated(oglSurface.xOffset / 64.0/*-0.375*/, 0.0, 0.0);
3162 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3167 glTexCoord2f((float)sx/ bitmap.width, (float)(sy-h)/ bitmap.height);
3168 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3169 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy-h)/ bitmap.height);
3170 glVertex2i(dx+w+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-h+surface.offset.y);
3173 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3174 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3179 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3180 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3181 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3182 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3183 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3184 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3185 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3186 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3189 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3190 glVertex2f((float)dx+surface.offset.x, (float)dy+surface.offset.y);
3191 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3192 glVertex2f((float)dx+w+surface.offset.x, (float)dy+surface.offset.y);
3193 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3194 glVertex2f((float)dx+w+surface.offset.x, (float)dy+h+surface.offset.y);
3195 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3196 glVertex2f((float)dx+surface.offset.x, (float)dy+h+surface.offset.y);
3200 if(!oglSurface.writingText)
3202 glDisable(GL_TEXTURE_2D);
3204 //glTranslate(0.375, 0.375, 0.0);
3206 else if(oglSurface.xOffset)
3207 glTranslated(-oglSurface.xOffset / 64.0/*+0.375*/, 0.0, 0.0);
3209 #if !defined(__OLDX__)
3210 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3211 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3215 void Stretch(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3217 OGLSurface oglSurface = surface.driverData;
3219 //glTranslate(-0.375, -0.375, 0.0);
3221 //Logf("Stretch\n");
3223 #if !defined(__OLDX__)
3224 /*if(glBlendFuncSeparate)
3225 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3228 glEnable(GL_TEXTURE_2D);
3229 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3231 glColor4fv(oglSurface.bitmapMult);
3237 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3238 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3240 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3241 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3243 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3244 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
3246 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3247 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3251 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3252 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3254 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3255 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3257 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3258 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3260 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3261 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3266 glDisable(GL_TEXTURE_2D);
3268 //glTranslate(0.375, 0.375, 0.0);
3269 #if !defined(__OLDX__)
3270 /*if(glBlendFuncSeparate)
3271 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3276 void Filter(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3278 Stretch(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3281 void StretchDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3283 #if !defined(EM_MODE)
3284 float s2dw,s2dh,d2sw,d2sh;
3285 //bool flipX = false, flipY = false;
3287 //Logf("StretchDI\n");
3289 if(Sgn(w) != Sgn(sw))
3295 if(Sgn(h) != Sgn(sh))
3307 //Clip against the edges of the source
3310 dx+=(int)((0-sx) * s2dw);
3311 w-=(int)((0-sx) * s2dw);
3317 dy+=(int)((0-sy) * s2dh);
3318 h-=(int)((0-sy) * s2dh);
3323 if(sx+sw>bitmap.width-1)
3325 w-=(int)((sx+sw-(bitmap.width-1)-1)*s2dw);
3326 sw-=sx+sw-(bitmap.width-1)-1;
3328 if(sy+sh>(bitmap.height-1))
3330 h-=(int)((sy+sh-(bitmap.height-1)-1)*s2dh);
3331 sh-=sy+sh-(bitmap.height-1)-1;
3333 //Clip against the edges of the surfaceination
3334 if(dx<surface.box.left)
3337 sx+=(int)((surface.box.left-dx)*d2sw);
3338 sw-=(int)((surface.box.left-dx)*d2sw);
3339 w-=surface.box.left-dx;
3340 dx=surface.box.left;
3342 if(dy<surface.box.top)
3344 sy+=(int)((surface.box.top-dy)*d2sh);
3345 sh-=(int)((surface.box.top-dy)*d2sh);
3346 h-=surface.box.top-dy;
3349 if(dx+w>surface.box.right)
3351 //if(flip) sx+=(int)((dx+w-surface.box.right-1)*d2sw);
3352 sw-=(int)((dx+w-surface.box.right-1)*d2sw);
3353 w-=dx+w-surface.box.right-1;
3355 if(dy+h>surface.box.bottom)
3357 sh-=(int)((dy+h-surface.box.bottom-1)*d2sh);
3358 h-=dy+h-surface.box.bottom-1;
3360 if((w<=0)||(h<=0)||(sw<=0)||(sh<=0)) return;
3362 dx += surface.offset.x;
3363 dy += surface.offset.y;
3365 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3367 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3368 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3369 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3370 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3371 glRasterPos2d(dx,dy);
3372 //glPixelZoom(flipX ? -s2dw : s2dw, flipY ? s2dh : -s2dh);
3373 glPixelZoom(s2dw, -s2dh);
3374 glDrawPixels(sw,sh,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3375 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3376 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3377 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3378 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3383 void BlitDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3385 #if !defined(EM_MODE)
3388 //Clip against the edges of the source
3401 if(sx+w>bitmap.width-1)
3402 w-=sx+w-(bitmap.width-1)-1;
3403 if(sy+h>bitmap.height-1)
3404 h-=sy+h-(bitmap.height-1)-1;
3405 //Clip against the edges of the surfaceination
3406 if(dx<surface.box.left)
3409 sx+=surface.box.left-dx;
3410 w-=surface.box.left-dx;
3411 dx=surface.box.left;
3413 if(dy<surface.box.top)
3415 sy+=surface.box.top-dy;
3416 h-=surface.box.top-dy;
3419 if(dx+w>surface.box.right)
3421 //if(flip) sx+=dx+w-surface.box.right-1;
3422 w-=dx+w-surface.box.right-1;
3424 if(dy+h>surface.box.bottom)
3425 h-=dy+h-surface.box.bottom-1;
3429 dx += surface.offset.x;
3430 dy += surface.offset.y;
3432 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3434 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3435 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3436 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3437 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3438 glRasterPos2d(dx,dy);
3440 glDrawPixels(w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3441 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3442 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3443 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3444 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3449 void FilterDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3451 StretchDI(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3454 void UnloadFont(DisplaySystem displaySystem, Font font)
3456 ((subclass(DisplayDriver))class(LFBDisplayDriver)).UnloadFont(displaySystem, font);
3459 Font LoadFont(DisplaySystem displaySystem, const char * faceName, float size, FontFlags flags)
3462 OGLSystem oglSystem = displaySystem.driverData;
3463 oglSystem.loadingFont = true;
3464 font = ((subclass(DisplayDriver))class(LFBDisplayDriver)).LoadFont(displaySystem, faceName, size, flags);
3468 void FontExtent(DisplaySystem displaySystem, Font font, const char * text, int len, int * width, int * height)
3470 ((subclass(DisplayDriver))class(LFBDisplayDriver)).FontExtent(displaySystem, font, text, len, width, height);
3473 void WriteText(Display display, Surface surface, int x, int y, const char * text, int len)
3475 OGLSurface oglSurface = surface.driverData;
3476 OGLSystem oglSystem = display.displaySystem.driverData;
3477 oglSystem.loadingFont = true;
3479 //glTranslated(-0.375, -0.375, 0.0);
3483 if(surface.textOpacity)
3486 FontExtent(display.displaySystem, surface.font, text, len, &w, &h);
3487 display.displaySystem.driver.Area(display, surface,x,y,x+w-1,y+h-1);
3490 oglSurface.writingText = true;
3492 glEnable(GL_TEXTURE_2D);
3494 if(surface.outline.size)
3496 ColorAlpha outlineColor = surface.outline.color;
3497 glColor4ub(outlineColor.color.r, outlineColor.color.g, outlineColor.color.b, outlineColor.a);
3498 //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3499 //glEnable(GL_BLEND);
3501 oglSurface.writingOutline = true;
3502 ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x, y, text, len);
3503 oglSurface.writingOutline = false;
3505 glColor4fv(oglSurface.foreground);
3507 ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x, y, text, len);
3508 oglSurface.writingText = false;
3509 oglSystem.loadingFont = false;
3511 glDisable(GL_TEXTURE_2D);
3513 //glTranslated(0.375, 0.375, 0.0);
3516 void TextFont(Display display, Surface surface, Font font)
3518 ((subclass(DisplayDriver))class(LFBDisplayDriver)).TextFont(display, surface, font);
3521 void TextOpacity(Display display, Surface surface, bool opaque)
3523 OGLSurface oglSurface = surface.driverData;
3524 oglSurface.opaqueText = opaque;
3527 void TextExtent(Display display, Surface surface, const char * text, int len, int * width, int * height)
3529 OGLSurface oglSurface = surface.driverData;
3530 OGLSystem oglSystem = display.displaySystem.driverData;
3531 oglSystem.loadingFont = true;
3532 FontExtent(display.displaySystem, oglSurface.font, text, len, width, height);
3533 oglSystem.loadingFont = false;
3536 void DrawingChar(Display display, Surface surface, char character)
3541 void LineStipple(Display display, Surface surface, uint32 stipple)
3543 //Logf("Stipple\n");
3547 #if defined(_GLES) || defined(EM_MODE)
3548 stippleEnabled = true;
3549 glesLineStipple(1, (uint16)stipple);
3551 glLineStipple(1, (uint16)stipple);
3552 glEnable(GL_LINE_STIPPLE);
3557 #if defined(_GLES) || defined(EM_MODE)
3558 stippleEnabled = false;
3559 glMatrixMode(GL_TEXTURE);
3561 glMatrixMode(GL_PROJECTION);
3562 glDisable(GL_TEXTURE_2D);
3564 glDisable(GL_LINE_STIPPLE);
3568 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
3569 void SetRenderState(Display display, RenderState state, uint value)
3571 OGLDisplay oglDisplay = display.driverData;
3572 //Logf("RenderState\n");
3578 glEnable(GL_MULTISAMPLE_ARB);
3580 glDisable(GL_MULTISAMPLE_ARB);
3584 glPolygonMode(GL_FRONT_AND_BACK, ((FillModeValue)value == solid) ? GL_FILL : GL_LINE);
3588 if(value) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
3591 if(value) glDepthMask((byte)bool::true); else glDepthMask((byte)bool::false);
3592 oglDisplay.depthWrite = (bool)value;
3596 float color[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3597 glFogfv(GL_FOG_COLOR, (float *)&color);
3601 glFogf(GL_FOG_DENSITY, (float)(RenderStateFloat { ui = value }.f * nearPlane));
3604 if(value) glEnable(GL_BLEND); else glDisable(GL_BLEND);
3608 #if !defined(EM_MODE)
3609 float ambient[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3610 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
3616 if(value) glColorMask(1,1,1,1); else glColorMask(1,1,1,0);
3621 #if defined(__WIN32__)
3622 wglSwapIntervalEXT(value ? 1 : 0);
3629 void SetLight(Display display, int id, Light light)
3631 #if !defined(EM_MODE)
3632 //Logf("SetLight\n");
3636 Object lightObject = light.lightObject;
3637 float position[4] = { 0, 0, 0, 0 };
3638 float color[4] = { 0, 0, 0, 1 };
3640 glEnable(GL_LIGHT0 + id);
3642 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, (float *)&light.diffuse);
3643 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, (float *)&light.ambient);
3644 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,(float *)&light.specular);
3647 if(!light.multiplier) light.multiplier = 1.0f;
3649 color[0] = light.diffuse.r * light.multiplier;
3650 color[1] = light.diffuse.g * light.multiplier;
3651 color[2] = light.diffuse.b * light.multiplier;
3652 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, color);
3654 color[0] = light.ambient.r * light.multiplier;
3655 color[1] = light.ambient.g * light.multiplier;
3656 color[2] = light.ambient.b * light.multiplier;
3657 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, color);
3658 color[0] = light.specular.r * light.multiplier;
3659 color[1] = light.specular.g * light.multiplier;
3660 color[2] = light.specular.b * light.multiplier;
3661 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,color);
3665 Vector3D positionVector;
3666 if(light.flags.spot)
3668 if(lightObject.flags.root || !lightObject.parent)
3670 positionVector = lightObject.transform.position;
3671 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3675 positionVector.MultMatrix(lightObject.transform.position, lightObject.parent.matrix);
3676 if(display.display3D.camera)
3677 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3683 if(!light.direction.x && !light.direction.y && !light.direction.z)
3685 Vector3Df vector { 0,0,-1 };
3687 mat.RotationQuaternion(light.orientation);
3688 positionVector.MultMatrixf(vector, mat);
3692 positionVector = light.direction;
3697 position[0] = (float)positionVector.x;
3698 position[1] = (float)positionVector.y;
3699 position[2] = (float)positionVector.z;
3701 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3704 // Display Light Position
3705 glDisable(GL_LIGHTING);
3706 glDisable(GL_DEPTH_TEST);
3710 glVertex3fv(position);
3712 glEnable(GL_DEPTH_TEST);
3713 glEnable(GL_LIGHTING);
3717 if(lightObject.flags.root || !lightObject.parent)
3719 positionVector = light.target.transform.position;
3720 positionVector.Subtract(positionVector, display.camera.cPosition);
3724 positionVector.MultMatrix(light.target.transform.position,
3725 lightObject.light.target.parent.matrix);
3726 positionVector.Subtract(positionVector, display.camera.cPosition);
3729 position[0] = positionVector.x;
3730 position[1] = positionVector.y;
3731 position[2] = positionVector.z;
3733 glDisable(GL_LIGHTING);
3734 glDisable(GL_DEPTH_TEST);
3738 glVertex3fv(position);
3740 glEnable(GL_DEPTH_TEST);
3741 glEnable(GL_LIGHTING);
3744 if(light.flags.attenuation)
3746 glLightf(GL_LIGHT0 + id, GL_CONSTANT_ATTENUATION, light.Kc);
3747 glLightf(GL_LIGHT0 + id, GL_LINEAR_ATTENUATION, light.Kl);
3748 glLightf(GL_LIGHT0 + id, GL_QUADRATIC_ATTENUATION, light.Kq);
3751 if(light.flags.spot)
3754 #define MAXLIGHT 0.9
3755 float direction[4] = { (float)light.direction.x, (float)light.direction.y, (float)light.direction.z, 1 };
3756 // Figure out exponent out of the hot spot
3757 exponent = (float)(log(MAXLIGHT) / log(cos((light.hotSpot / 2))));
3759 glLightfv(GL_LIGHT0 + id, GL_SPOT_DIRECTION, direction);
3760 glLightf(GL_LIGHT0 + id, GL_SPOT_CUTOFF, (float)(light.fallOff / 2));
3761 glLightf(GL_LIGHT0 + id, GL_SPOT_EXPONENT, exponent);
3767 Vector3Df vector { 0,0,-1 };
3768 Vector3Df direction;
3771 mat.RotationQuaternion(light.orientation);
3772 direction.MultMatrix(vector, mat);
3774 position[0] = direction.x;
3775 position[1] = direction.y;
3776 position[2] = direction.z;
3778 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3782 glDisable(GL_LIGHT0 + id);
3786 void SetCamera(Display display, Surface surface, Camera camera)
3788 OGLDisplay oglDisplay = display.driverData;
3789 //Logf("SetCamera\n");
3793 int left = surface.box.left + surface.offset.x;
3794 int top = surface.box.top + surface.offset.y;
3795 int right = surface.box.right + surface.offset.x;
3796 int bottom = surface.box.bottom + surface.offset.y;
3797 float origX = surface.offset.x + camera.origin.x;
3798 float origY = surface.offset.y + camera.origin.y;
3800 int y = display.height - bottom - 1;
3801 int w = right - left + 1;
3802 int h = bottom - top + 1;
3805 glViewport(x, y, w, h);
3807 // *** Projection Matrix ***
3808 if(!display.display3D.camera)
3810 glMatrixMode(GL_PROJECTION);
3814 glMatrixMode(GL_PROJECTION);
3815 if(display.display3D.collectingHits)
3817 float pickX = display.display3D.pickX + surface.offset.x;
3818 float pickY = display.height - (display.display3D.pickY + surface.offset.y) - 1;
3822 w / display.display3D.pickWidth, 0, 0, 0,
3823 0, h / display.display3D.pickHeight, 0, 0,
3825 (w + 2.0f * (x - pickX)) / display.display3D.pickWidth,
3826 (h + 2.0f * (y - pickY)) / display.display3D.pickHeight, 0, 1
3829 glLoadMatrixd(pickMatrix.array);
3834 (left - origX) * camera.zMin / camera.focalX,
3835 (right - origX) * camera.zMin / camera.focalX,
3836 (bottom - origY) * camera.zMin / camera.focalY,
3837 (top - origY) * camera.zMin / camera.focalY,
3838 camera.zMin, camera.zMax);
3840 glDisable(GL_BLEND);
3842 // *** Z Inverted Identity Matrix ***
3843 glMatrixMode(GL_MODELVIEW);
3844 if(!display.display3D.camera)
3849 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
3851 // *** View Matrix ***
3852 glMultMatrixd(camera.viewMatrix.array);
3857 glEnable(GL_DEPTH_TEST);
3858 //#if !defined(EM_MODE)
3859 glEnable(GL_LIGHTING);
3860 glShadeModel(GL_SMOOTH);
3862 glDepthMask((byte)bool::true);
3863 oglDisplay.depthWrite = true;
3865 glEnable(GL_MULTISAMPLE_ARB);
3867 else if(display.display3D.camera)
3869 oglDisplay.depthWrite = false;
3870 glViewport(0,0,display.width,display.height);
3872 glDisable(GL_CULL_FACE);
3873 glDisable(GL_DEPTH_TEST);
3874 glDisable(GL_LIGHTING);
3876 glDisable(GL_TEXTURE_2D);
3877 //#if !defined(EM_MODE)
3878 glShadeModel(GL_FLAT);
3881 glDisable(GL_MULTISAMPLE_ARB);
3883 // *** Restore 2D MODELVIEW Matrix ***
3886 // *** Restore 2D PROJECTION Matrix ***
3887 glMatrixMode(GL_PROJECTION);
3893 void ApplyMaterial(Display display, Material material, Mesh mesh)
3895 //Logf("ApplyMaterial\n");
3898 if(material.flags.doubleSided)
3900 #if !defined(EM_MODE)
3901 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, !material.flags.singleSideLight);
3903 glDisable(GL_CULL_FACE);
3907 #if !defined(EM_MODE)
3908 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, bool::false);
3910 glEnable(GL_CULL_FACE);
3914 if(material.flags.noFog)
3920 if(material.baseMap && (mesh.texCoords || mesh.flags.texCoords1))
3922 Bitmap map = material.baseMap;
3923 glEnable(GL_TEXTURE_2D);
3924 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)map.driverData);
3926 glMatrixMode(GL_TEXTURE);
3928 if(material.uScale && material.vScale)
3929 glScalef(material.uScale, material.vScale, 1);
3930 glMatrixMode(GL_MODELVIEW);
3932 if(material.flags.tile)
3934 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
3935 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
3939 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
3940 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
3944 glDisable(GL_TEXTURE_2D);
3947 glColor4f(material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity);
3949 if(mesh.flags.colors)
3951 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
3952 glEnable(GL_COLOR_MATERIAL);
3956 glDisable(GL_COLOR_MATERIAL);
3958 float color[4] = { material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity };
3959 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
3962 float color[4] = { material.ambient.r, material.ambient.g, material.ambient.b, 0 };
3963 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
3967 float color[4] = { material.specular.r, material.specular.g, material.specular.b, 0 };
3968 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, color);
3971 float color[4] = { material.emissive.r, material.emissive.g, material.emissive.b, 0 };
3972 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, color);
3975 glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &material.power);
3979 void FreeMesh(DisplaySystem displaySystem, Mesh mesh)
3981 OGLMesh oglMesh = mesh.data;
3984 if(!mesh.flags.vertices)
3986 oglMesh.vertices.free();
3987 delete mesh.vertices;
3989 if(!mesh.flags.normals)
3991 oglMesh.normals.free();
3992 delete mesh.normals;
3994 if(!mesh.flags.texCoords1)
3996 oglMesh.texCoords.free();
3997 delete mesh.texCoords;
3999 if(!mesh.flags.texCoords2)
4001 oglMesh.texCoords2.free();
4002 // delete mesh.texCoords2;
4004 if(!mesh.flags.colors)
4006 oglMesh.colors.free();
4017 bool AllocateMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags, int nVertices)
4019 bool result = false;
4022 mesh.data = OGLMesh { };
4025 if(mesh.nVertices == nVertices)
4027 // Same number of vertices, adding features (Leaves the other features pointers alone)
4028 if(mesh.flags != flags)
4030 if(!mesh.flags.vertices && flags.vertices)
4032 if(flags.doubleVertices)
4034 mesh.vertices = (Vector3Df *)new Vector3D[nVertices];
4037 mesh.vertices = new Vector3Df[nVertices];
4039 if(!mesh.flags.normals && flags.normals)
4041 if(flags.doubleNormals)
4043 mesh.normals = (Vector3Df *)new Vector3D[nVertices];
4046 mesh.normals = new Vector3Df[nVertices];
4048 if(!mesh.flags.texCoords1 && flags.texCoords1)
4050 mesh.texCoords = new Pointf[nVertices];
4052 if(!mesh.flags.colors && flags.colors)
4054 mesh.colors = new ColorRGBAf[nVertices];
4060 // New number of vertices, reallocate all current and new features
4061 flags |= mesh.flags;
4064 if(flags.doubleVertices)
4066 mesh.vertices = (Vector3Df *)renew mesh.vertices Vector3D[nVertices];
4069 mesh.vertices = renew mesh.vertices Vector3Df[nVertices];
4073 if(flags.doubleNormals)
4075 mesh.normals = (Vector3Df *)renew mesh.normals Vector3D[nVertices];
4078 mesh.normals = renew mesh.normals Vector3Df[nVertices];
4080 if(flags.texCoords1)
4082 mesh.texCoords = renew mesh.texCoords Pointf[nVertices];
4086 mesh.colors = renew mesh.colors ColorRGBAf[nVertices];
4094 void UnlockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
4096 OGLMesh oglMesh = mesh.data;
4097 if(!flags) flags = mesh.flags;
4102 oglMesh.vertices.upload(
4103 mesh.nVertices * (mesh.flags.doubleVertices ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.vertices); //, GL_STATIC_DRAW_ARB );
4106 oglMesh.normals.upload(
4107 mesh.nVertices * (mesh.flags.doubleNormals ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.normals); //, GL_STATIC_DRAW_ARB );
4109 if(flags.texCoords1)
4110 oglMesh.texCoords.upload(
4111 mesh.nVertices * sizeof(Pointf), mesh.texCoords); //, GL_STATIC_DRAW_ARB );
4114 oglMesh.colors.upload(
4115 mesh.nVertices * sizeof(ColorRGBAf), mesh.colors); //, GL_STATIC_DRAW_ARB );
4119 bool LockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
4126 void FreeIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4130 oglIndices.buffer.free();
4131 delete oglIndices.indices;
4136 void * AllocateIndices(DisplaySystem displaySystem, int nIndices, bool indices32bit)
4138 OGLIndices oglIndices = OGLIndices { };
4141 oglIndices.indices = (void *)(indices32bit ? new uint32[nIndices] : new uint16[nIndices]);
4142 oglIndices.nIndices = nIndices;
4147 void UnlockIndices(DisplaySystem displaySystem, OGLIndices oglIndices, bool indices32bit, int nIndices)
4151 oglIndices.buffer.upload(
4152 nIndices * (indices32bit ? sizeof(uint32) : sizeof(uint16)),
4153 oglIndices.indices); //GL_STATIC_DRAW_ARB);
4157 uint16 * LockIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4160 return oglIndices.indices;
4163 void SelectMesh(Display display, Mesh mesh)
4165 //Logf("SelectMesh\n");
4167 #if !defined( __ANDROID__) && !defined(__APPLE__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
4169 #if defined(__WIN32__)
4170 if(glUnlockArraysEXT)
4172 if(!vboAvailable && display.display3D.mesh)
4173 glUnlockArraysEXT();
4178 OGLMesh oglMesh = mesh.data;
4180 // *** Vertex Stream ***
4181 glEnableClientState(GL_VERTEX_ARRAY);
4182 if(!display.display3D.collectingHits && oglMesh)
4184 oglMesh.vertices.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, oglMesh.vertices.buffer ? null : (double *)mesh.vertices);
4186 // *** Normals Stream ***
4187 if(mesh.normals || mesh.flags.normals)
4189 glEnableClientState(GL_NORMAL_ARRAY);
4190 oglMesh.normals.use(normal, 3, GL_FLOAT, 0, oglMesh.normals.buffer ? null : mesh.normals);
4193 glDisableClientState(GL_NORMAL_ARRAY);
4195 // *** Texture Coordinates Stream ***
4196 if(mesh.texCoords || mesh.flags.texCoords1)
4198 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4199 oglMesh.texCoords.use(texCoord, 2, GL_FLOAT, 0, oglMesh.texCoords.buffer ? null : mesh.texCoords);
4202 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4204 // *** Color Stream ***
4205 if(mesh.colors || mesh.flags.colors)
4207 glEnableClientState(GL_COLOR_ARRAY);
4208 oglMesh.colors.use(color, 4, GL_FLOAT, 0, oglMesh.colors.buffer ? null : mesh.colors);
4211 glDisableClientState(GL_COLOR_ARRAY);
4215 noAB.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, (double *)mesh.vertices);
4216 if((mesh.normals || mesh.flags.normals) && !display.display3D.collectingHits)
4218 glEnableClientState(GL_NORMAL_ARRAY);
4219 noAB.use(normal, 3, GL_FLOAT, 0, mesh.normals);
4222 glDisableClientState(GL_NORMAL_ARRAY);
4223 if((mesh.texCoords || mesh.flags.texCoords1) && !display.display3D.collectingHits)
4225 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4226 noAB.use(texCoord, 2, GL_FLOAT, 0, mesh.texCoords);
4229 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4230 if((mesh.colors || mesh.flags.colors) && !display.display3D.collectingHits)
4232 glEnableClientState(GL_COLOR_ARRAY);
4233 noAB.use(color, 4, GL_FLOAT, 0, mesh.colors);
4236 glDisableClientState(GL_COLOR_ARRAY);
4239 #if !defined(__ANDROID__) && !defined(__APPLE__) && !defined(__EMSCRIPTEN__) && !defined(__ODROID__)
4241 #if defined(__WIN32__)
4245 glLockArraysEXT(0, mesh.nVertices);
4251 void DrawPrimitives(Display display, PrimitiveSingle * primitive, Mesh mesh)
4253 //Logf("DrawPrimitives\n");
4255 if(primitive->type.vertexRange)
4256 glDrawArrays(primitiveTypes[primitive->type.primitiveType], primitive->first, primitive->nVertices);
4259 // *** Hoping the data won't be uploaded at all (Won't really work if another group of the mesh is using the mesh ) ***
4260 // HACK TO SPEED THINGS UP...
4262 /*GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
4263 if(primitive->nIndices < (mesh.nVertices >> 2) && !primitive->type.indices32bit)
4266 glBegin(primitiveTypes[primitive->type.primitiveType]);
4269 OGLIndices oglIndices = primitive->data;
4270 MeshFeatures flags = mesh.flags;
4271 for(c = 0; c<primitive->nIndices; c++)
4273 uint16 index = ((uint16 *) oglIndices.indices)[c];
4274 if(flags.normals) glNormal3fv((float *)&mesh.normals[index]);
4275 if(flags.texCoords1) glTexCoord2fv((float *)&mesh.texCoords[index]);
4276 if(flags.colors) glColor4fv((float *)&mesh.colors[index]);
4277 glVertex3fv((float *)&mesh.vertices[index]);
4285 OGLIndices oglIndices = primitive->data;
4287 if(!display.display3D.collectingHits && vboAvailable && oglIndices)
4289 if(primitive->type.indices32bit)
4290 ; //oglIndices.buffer.draw(primitiveTypes[primitive->type.primitiveType], primitive->nIndices, GL_UNSIGNED_SHORT, 0);
4292 oglIndices.buffer.draw(primitiveTypes[primitive->type.primitiveType], primitive->nIndices, GL_UNSIGNED_SHORT, 0);
4296 if(primitive->type.indices32bit)
4297 glDrawElementsi(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
4298 oglIndices ? oglIndices.indices : primitive->indices);
4300 glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
4301 GL_UNSIGNED_SHORT, oglIndices ? oglIndices.indices : primitive->indices);
4307 void PushMatrix(Display display)
4312 void PopMatrix(Display display, bool setMatrix)
4317 void SetTransform(Display display, Matrix transMatrix, bool viewSpace, bool useCamera)
4319 Matrix matrix = transMatrix;
4320 Camera camera = useCamera ? display.display3D.camera : null;
4325 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
4330 matrix.m[3][0] - camera.cPosition.x,
4331 matrix.m[3][1] - camera.cPosition.y,
4332 matrix.m[3][2] - camera.cPosition.z);
4344 glMultMatrixd(matrix.array);
4349 public void UseSingleGLContext(bool useSingle)
4351 useSingleGLContext = useSingle;
4354 default dllexport void *
4355 #if defined(__WIN32__)
4356 __attribute__((stdcall))
4358 IS_GLGetContext(DisplaySystem displaySystem)
4362 #if defined(__WIN32__)
4363 OGLSystem system = displaySystem.driverData;
4365 #elif defined(__ANDROID__) || defined(__ODROID__)
4367 #elif defined(__EMSCRIPTEN__)
4369 OGLSystem system = displaySystem.driverData;
4370 return system.glContext;