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__)
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__)
83 #elif defined(__EMSCRIPTEN__)
85 #define property _property
90 //#include <GLES/gl.h>
91 //#include <EGL/egl.h>
93 //#include <GLES2/gl.h>
94 //#include <EGL/egl.h>
96 //#include <GLES2/gl2.h>
98 #include <emscripten/emscripten.h>
106 #include <GL/glext.h>
110 #if defined(__EMSCRIPTEN__)
121 #if defined(__unix__) || defined(__APPLE__)
123 #if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__)
129 static double nearPlane = 1;
131 public double glesGetNearPlane()
136 public void glesSetNearPlane(double value)
141 #define glLoadMatrix glLoadMatrixd
142 #define glMultMatrix glMultMatrixd
143 #define glGetMatrix glGetDoublev
144 #define glTranslate glTranslated
145 #define glScale glScaled
148 #define glVertex3v glVertex3dv
149 #define glNormal3v glNormal3dv
153 //#ifdef VERTEX_FORMAT_DOUBLE
155 #define glLoadMatrix glLoadMatrixd
156 #define glMultMatrix glMultMatrixd
157 #define glGetMatrix glGetDoublev
158 #define glVertex3v glVertex3dv
159 #define glNormal3v glNormal3dv
160 #define glTranslate glTranslated
161 #define glScale glScaled
162 //#define GL_VERTEX_FORMAT GL_DOUBLE
166 #define glLoadMatrix glLoadMatrixf
167 #define glMultMatrix glMultMatrixf
168 #define glGetMatrix glGetFloatv
169 #define glVertex3v glVertex3fv
170 #define glNormal3v glNormal3fv
171 #define glTranslate glTranslatef
172 #define glScale glScalef
173 //#define GL_VERTEX_FORMAT GL_FLOAT
178 #define GL_ARRAY_BUFFER_ARB 0x8892
179 #define GL_ELEMENT_ARRAY_BUFFER_ARB 0x8893
180 #define GL_STATIC_DRAW_ARB 0x88E4
181 #define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8
182 #define GL_SEPARATE_SPECULAR_COLOR 0x81FA
184 #define GL_MULTISAMPLE_ARB 0x809D
186 #if defined(__WIN32__)
188 #define WGL_SAMPLE_BUFFERS_ARB 0x2041
189 #define WGL_SAMPLES_ARB 0x2042
191 #define WGL_WGLEXT_VERSION 1
192 #define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001
193 #define WGL_BACK_COLOR_BUFFER_BIT_ARB 0x00000002
194 #define WGL_DEPTH_BUFFER_BIT_ARB 0x00000004
195 #define WGL_STENCIL_BUFFER_BIT_ARB 0x00000008
196 #define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000
197 #define WGL_DRAW_TO_WINDOW_ARB 0x2001
198 #define WGL_DRAW_TO_BITMAP_ARB 0x2002
199 #define WGL_ACCELERATION_ARB 0x2003
200 #define WGL_NEED_PALETTE_ARB 0x2004
201 #define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005
202 #define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006
203 #define WGL_SWAP_METHOD_ARB 0x2007
204 #define WGL_NUMBER_OVERLAYS_ARB 0x2008
205 #define WGL_NUMBER_UNDERLAYS_ARB 0x2009
206 #define WGL_TRANSPARENT_ARB 0x200A
207 #define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037
208 #define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038
209 #define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039
210 #define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A
211 #define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B
212 #define WGL_SHARE_DEPTH_ARB 0x200C
213 #define WGL_SHARE_STENCIL_ARB 0x200D
214 #define WGL_SHARE_ACCUM_ARB 0x200E
215 #define WGL_SUPPORT_GDI_ARB 0x200F
216 #define WGL_SUPPORT_OPENGL_ARB 0x2010
217 #define WGL_DOUBLE_BUFFER_ARB 0x2011
218 #define WGL_STEREO_ARB 0x2012
219 #define WGL_PIXEL_TYPE_ARB 0x2013
220 #define WGL_COLOR_BITS_ARB 0x2014
221 #define WGL_RED_BITS_ARB 0x2015
222 #define WGL_RED_SHIFT_ARB 0x2016
223 #define WGL_GREEN_BITS_ARB 0x2017
224 #define WGL_GREEN_SHIFT_ARB 0x2018
225 #define WGL_BLUE_BITS_ARB 0x2019
226 #define WGL_BLUE_SHIFT_ARB 0x201A
227 #define WGL_ALPHA_BITS_ARB 0x201B
228 #define WGL_ALPHA_SHIFT_ARB 0x201C
229 #define WGL_ACCUM_BITS_ARB 0x201D
230 #define WGL_ACCUM_RED_BITS_ARB 0x201E
231 #define WGL_ACCUM_GREEN_BITS_ARB 0x201F
232 #define WGL_ACCUM_BLUE_BITS_ARB 0x2020
233 #define WGL_ACCUM_ALPHA_BITS_ARB 0x2021
234 #define WGL_DEPTH_BITS_ARB 0x2022
235 #define WGL_STENCIL_BITS_ARB 0x2023
236 #define WGL_AUX_BUFFERS_ARB 0x2024
237 #define WGL_NO_ACCELERATION_ARB 0x2025
238 #define WGL_GENERIC_ACCELERATION_ARB 0x2026
239 #define WGL_FULL_ACCELERATION_ARB 0x2027
240 #define WGL_SWAP_EXCHANGE_ARB 0x2028
241 #define WGL_SWAP_COPY_ARB 0x2029
242 #define WGL_SWAP_UNDEFINED_ARB 0x202A
243 #define WGL_TYPE_RGBA_ARB 0x202B
244 #define WGL_TYPE_COLORINDEX_ARB 0x202C
245 #define ERROR_INVALID_PIXEL_TYPE_ARB 0x2043
246 #define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054
247 #define WGL_DRAW_TO_PBUFFER_ARB 0x202D
248 #define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E
249 #define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F
250 #define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030
251 #define WGL_PBUFFER_LARGEST_ARB 0x2033
252 #define WGL_PBUFFER_WIDTH_ARB 0x2034
253 #define WGL_PBUFFER_HEIGHT_ARB 0x2035
254 #define WGL_PBUFFER_LOST_ARB 0x2036
255 #define ERROR_INVALID_PIXEL_TYPE_EXT 0x2043
256 #define WGL_NUMBER_PIXEL_FORMATS_EXT 0x2000
257 #define WGL_DRAW_TO_WINDOW_EXT 0x2001
258 #define WGL_DRAW_TO_BITMAP_EXT 0x2002
259 #define WGL_ACCELERATION_EXT 0x2003
260 #define WGL_NEED_PALETTE_EXT 0x2004
261 #define WGL_NEED_SYSTEM_PALETTE_EXT 0x2005
262 #define WGL_SWAP_LAYER_BUFFERS_EXT 0x2006
263 #define WGL_SWAP_METHOD_EXT 0x2007
264 #define WGL_NUMBER_OVERLAYS_EXT 0x2008
265 #define WGL_NUMBER_UNDERLAYS_EXT 0x2009
266 #define WGL_TRANSPARENT_EXT 0x200A
267 #define WGL_TRANSPARENT_VALUE_EXT 0x200B
268 #define WGL_SHARE_DEPTH_EXT 0x200C
269 #define WGL_SHARE_STENCIL_EXT 0x200D
270 #define WGL_SHARE_ACCUM_EXT 0x200E
271 #define WGL_SUPPORT_GDI_EXT 0x200F
272 #define WGL_SUPPORT_OPENGL_EXT 0x2010
273 #define WGL_DOUBLE_BUFFER_EXT 0x2011
274 #define WGL_STEREO_EXT 0x2012
275 #define WGL_PIXEL_TYPE_EXT 0x2013
276 #define WGL_COLOR_BITS_EXT 0x2014
277 #define WGL_RED_BITS_EXT 0x2015
278 #define WGL_RED_SHIFT_EXT 0x2016
279 #define WGL_GREEN_BITS_EXT 0x2017
280 #define WGL_GREEN_SHIFT_EXT 0x2018
281 #define WGL_BLUE_BITS_EXT 0x2019
282 #define WGL_BLUE_SHIFT_EXT 0x201A
283 #define WGL_ALPHA_BITS_EXT 0x201B
284 #define WGL_ALPHA_SHIFT_EXT 0x201C
285 #define WGL_ACCUM_BITS_EXT 0x201D
286 #define WGL_ACCUM_RED_BITS_EXT 0x201E
287 #define WGL_ACCUM_GREEN_BITS_EXT 0x201F
288 #define WGL_ACCUM_BLUE_BITS_EXT 0x2020
289 #define WGL_ACCUM_ALPHA_BITS_EXT 0x2021
290 #define WGL_DEPTH_BITS_EXT 0x2022
291 #define WGL_STENCIL_BITS_EXT 0x2023
292 #define WGL_AUX_BUFFERS_EXT 0x2024
293 #define WGL_NO_ACCELERATION_EXT 0x2025
294 #define WGL_GENERIC_ACCELERATION_EXT 0x2026
295 #define WGL_FULL_ACCELERATION_EXT 0x2027
296 #define WGL_SWAP_EXCHANGE_EXT 0x2028
297 #define WGL_SWAP_COPY_EXT 0x2029
298 #define WGL_SWAP_UNDEFINED_EXT 0x202A
299 #define WGL_TYPE_RGBA_EXT 0x202B
300 #define WGL_TYPE_COLORINDEX_EXT 0x202C
301 #define WGL_DRAW_TO_PBUFFER_EXT 0x202D
302 #define WGL_MAX_PBUFFER_PIXELS_EXT 0x202E
303 #define WGL_MAX_PBUFFER_WIDTH_EXT 0x202F
304 #define WGL_MAX_PBUFFER_HEIGHT_EXT 0x2030
305 #define WGL_OPTIMAL_PBUFFER_WIDTH_EXT 0x2031
306 #define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032
307 #define WGL_PBUFFER_LARGEST_EXT 0x2033
308 #define WGL_PBUFFER_WIDTH_EXT 0x2034
309 #define WGL_PBUFFER_HEIGHT_EXT 0x2035
310 #define WGL_DEPTH_FLOAT_EXT 0x2040
311 #define WGL_SAMPLE_BUFFERS_3DFX 0x2060
312 #define WGL_SAMPLES_3DFX 0x2061
313 #define WGL_SAMPLE_BUFFERS_EXT 0x2041
314 #define WGL_SAMPLES_EXT 0x2042
315 #define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044
316 #define WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D 0x2045
317 #define WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D 0x2046
318 #define WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D 0x2047
319 #define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048
320 #define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049
321 #define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A
322 #define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B
323 #define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C
324 #define WGL_GAMMA_TABLE_SIZE_I3D 0x204E
325 #define WGL_GAMMA_EXCLUDE_DESKTOP_I3D 0x204F
326 #define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050
327 #define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051
328 #define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052
329 #define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053
330 #define WGL_ARB_buffer_region 1
331 #define WGL_ARB_extensions_string 1
332 #define WGL_ARB_pixel_format 1
333 #define WGL_ARB_make_current_read 1
334 #define WGL_ARB_pbuffer 1
335 #define WGL_EXT_display_color_table 1
336 #define WGL_EXT_extensions_string 1
337 #define WGL_EXT_make_current_read 1
338 #define WGL_EXT_pbuffer 1
339 #define WGL_EXT_pixel_format 1
340 #define WGL_EXT_swap_control 1
341 #define WGL_WGL_EXT_depth_float 1
342 #define WGL_WGL_3DFX_multisample 1
343 #define WGL_WGL_EXT_multisample 1
344 #define WGL_NV_allocate_memory 1
347 typedef void (APIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum target);
348 typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);
349 typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum target);
350 typedef void (APIENTRY * PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei count);
351 typedef void (APIENTRY * PFNGLUNLOCKARRAYSEXTPROC) (void);
355 typedef int (APIENTRY * PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer);
356 typedef int (APIENTRY * PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint *buffers);
357 typedef int (APIENTRY * PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint *buffers);
358 typedef int (APIENTRY * PFNGLBUFFERDATAARBPROC) (GLenum target, int size, const GLvoid *data, GLenum usage);
360 typedef int (APIENTRY * PFNWGLCHOOSEPIXELFORMATARBPROC) ();
361 typedef void * (APIENTRY * PFNWGLCREATEPBUFFERARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
362 typedef HDC (APIENTRY * PFNWGLGETPBUFFERDCARBPROC) (void * hPbuffer);
363 typedef int (APIENTRY * PFNWGLRELEASEPBUFFERDCARBPROC) (void * hPbuffer, HDC hDC);
364 typedef BOOL (APIENTRY * PFNWGLDESTROYPBUFFERARBPROC) (void * hPbuffer);
365 typedef BOOL (APIENTRY * PFNWGLQUERYPBUFFERARBPROC) (void * hPbuffer, int iAttribute, int *piValue);
366 typedef const char * (APIENTRY * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc);
367 typedef BOOL (APIENTRY * PFNWGLBINDTEXIMAGEARBPROC) (void * hPbuffer, int iBuffer);
368 typedef BOOL (APIENTRY * PFNWGLRELEASETEXIMAGEARBPROC) (void * hPbuffer, int iBuffer);
370 static PFNGLMAPBUFFERARBPROC glMapBufferARB = null;
371 static PFNGLUNMAPBUFFERARBPROC glUnmapBufferARB = null;
372 static PFNGLACTIVETEXTUREARBPROC glActiveTextureARB = null;
373 static PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB = null;
374 static PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB = null;
375 static PFNGLLOCKARRAYSEXTPROC glLockArraysEXT = null;
376 static PFNGLUNLOCKARRAYSEXTPROC glUnlockArraysEXT = null;
377 static PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate = null;
379 static PFNGLGENBUFFERSARBPROC glGenBuffersARB = null;
380 static PFNGLBINDBUFFERARBPROC glBindBufferARB = null;
381 static PFNGLBUFFERDATAARBPROC glBufferDataARB = null;
382 static PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB = null;
383 static PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = null;
384 static PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB = null;
385 static PFNWGLCREATEPBUFFERARBPROC wglCreatePbufferARB = null;
386 static PFNWGLGETPBUFFERDCARBPROC wglGetPbufferDCARB = null;
387 static PFNWGLQUERYPBUFFERARBPROC wglQueryPbufferARB = null;
388 static PFNWGLDESTROYPBUFFERARBPROC wglDestroyPbufferARB = null;
389 static PFNWGLRELEASEPBUFFERDCARBPROC wglReleasePbufferDCARB = null;
390 static PFNWGLBINDTEXIMAGEARBPROC wglBindTexImageARB = null;
391 static PFNWGLRELEASETEXIMAGEARBPROC wglReleaseTexImageARB = null;
393 #define glBufferData glBufferDataARB
395 #ifdef WGL_WGLEXT_PROTOTYPES
396 extern BOOL WINAPI wglSwapIntervalEXT (int);
397 extern int WINAPI wglGetSwapIntervalEXT (void);
398 #endif /* WGL_WGLEXT_PROTOTYPES */
399 typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC) (int interval);
400 typedef int (WINAPI * PFNWGLGETSWAPINTERVALEXTPROC) (void);
402 static PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = NULL;
404 #elif defined(__ANDROID__)
406 #define GL_FRAMEBUFFER GL_FRAMEBUFFER_OES
407 #define GL_RENDERBUFFER GL_RENDERBUFFER_OES
408 #define GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_OES
410 #define GL_POLYGON_STIPPLE 0xFFFF
411 #define GL_LINE_STIPPLE 0xFFFF
412 #define GL_LINE 0xFFFF
413 #define GL_FILL 0xFFFF
414 #define GL_ALL_ATTRIB_BITS 0xFFFF
415 #define GL_LIGHT_MODEL_LOCAL_VIEWER 0xFFFF
421 #define GL_QUAD_STRIP 0
422 //#define GL_DOUBLE 0
423 //#define GL_UNSIGNED_INT 0
426 //#define GL_LINE_STIPPLE 0
427 #define GL_BGRA_EXT 0
428 #define GL_UNPACK_ROW_LENGTH 0
429 #define GL_UNPACK_SKIP_PIXELS 0
430 #define GL_UNPACK_SKIP_ROWS 0
432 #define GL_PACK_ROW_LENGTH 0
433 #define GL_PACK_SKIP_ROWS 0
434 #define GL_PACK_SKIP_PIXELS 0
438 #if defined(ECERE_NO3D) || defined(ECERE_VANILLA)
446 FillBytesBy4(this, 0, sizeof(Matrix) >> 2);
447 m[0][0]=m[1][1]=m[2][2]=m[3][3]=1;
450 void Transpose(Matrix source)
455 m[j][i] = source.m[i][j];
458 void Multiply(Matrix a, Matrix b)
460 // We need a full matrix multiplication for the Projection matrix
461 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];
462 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];
463 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];
464 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];
466 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];
467 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];
468 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];
469 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];
471 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];
472 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];
473 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];
474 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];
476 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];
477 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];
478 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];
479 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];
484 // Our own matrix stack
485 static Matrix matrixStack[3][32];
486 static int matrixIndex[3];
487 static int curStack = 0;
491 // OpenGL ES Porting Kit
492 #if defined(__ANDROID__)
493 #define glBindFramebuffer glBindFramebufferOES
494 #define glBindRenderbuffer glBindRenderbufferOES
495 #define glFramebufferTexture2D glFramebufferTexture2DOES
496 #define glGenFramebuffers glGenFramebuffersOES
497 #define glGenRenderbuffers glGenRenderbuffersOES
498 #define glDeleteFramebuffers glDeleteFramebuffersOES
499 #define glDeleteRenderbuffers glDeleteRenderbuffersOES
501 #define GL_INT 0x1404
502 #define GL_UNSIGNED_INT 0x1405
503 #define GL_DOUBLE 0x140A
507 #define glDrawElementsi(type, count, start) glDrawElements(type, count, GL_UNSIGNED_SHORT, start)
509 #define glBufferDatai glesBufferDatai
510 #define glBufferDatad glesBufferDatad
511 #define glVertexPointeri glesVertexPointeri
512 #define glVertexPointerd glesVertexPointerd
514 #define glRecti glesRecti
515 #define glBegin glesBegin
516 #define glTexCoord2i glesTexCoord2i
517 #define glVertex2i glesVertex2i
518 #define glTexCoord2d glesTexCoord2d
519 #define glVertex2d glesVertex2d
520 #define glTexCoord2f glesTexCoord2f
521 #define glVertex2f glesVertex2f
522 #define glEnd glesEnd
523 #define glColor3f glesColor3f
524 #define glColor4ub glesColor4ub
525 #define glColor4fv glesColor4fv
526 #define glLineStipple glesLineStipple
527 #define glNormal3fv glesNormal3fv
528 #define glNormal3f glesNormal3f
529 #define glTexCoord2fv glesTexCoord2fv
530 #define glColorMaterial glesColorMaterial
532 #define glLoadMatrixd glesLoadMatrixd
533 #define glMultMatrixd glesMultMatrixd
534 #define glFrustum glesFrustum
535 #define glOrtho glesOrtho
536 #define glScaled glesScaled
537 #define glTranslated glesTranslated
538 #define glRotated glesRotated
539 #define glVertex3d glesVertex3d
540 #define glVertex3dv glesVertex3dv
541 #define glVertex3f glesVertex3f
542 #define glVertex3fv glesVertex3fv
543 #define glLightModeli glesLightModeli
547 #define glVertexPointerd(nc, s, p, nv) glVertexPointer(nc, GL_DOUBLE, s, p)
548 #define glDrawElementsi(type, count, start) glDrawElements(type, count, GL_UNSIGNED_INT, start)
552 #if defined(__ANDROID__)
553 static EGLDisplay eglDisplay;
554 static EGLSurface eglSurface;
555 static EGLContext eglContext;
556 static int eglWidth, eglHeight;
558 static bool egl_init_display(ANativeWindow* window)
560 const EGLint attribs[] =
562 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
566 EGL_DEPTH_SIZE, 16, //24,
567 /*EGL_SAMPLE_BUFFERS, 1,
568 EGL_SAMPLES, 0, //2,*/
577 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
578 eglInitialize(display, 0, 0);
579 eglChooseConfig(display, attribs, &config, 1, &numConfigs);
580 eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &format);
582 surface = eglCreateWindowSurface(display, config, window, null);
583 context = eglCreateContext(display, config, null, null);
585 if(!eglMakeCurrent(display, surface, surface, context))
588 eglQuerySurface(display, surface, EGL_WIDTH, &w);
589 eglQuerySurface(display, surface, EGL_HEIGHT, &h);
591 eglDisplay = display;
592 eglContext = context;
593 eglSurface = surface;
597 glEnableClientState(GL_VERTEX_ARRAY);
599 // Initialize GL state.
600 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
601 glEnable(GL_CULL_FACE);
602 glShadeModel(GL_SMOOTH);
603 glDisable(GL_DEPTH_TEST);
605 glDisable(GL_CULL_FACE);
606 glDisable(GL_DEPTH_TEST);
608 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
611 matrixStack[0][0].Identity();
612 matrixStack[1][0].Identity();
613 matrixStack[2][0].Identity();
615 glesMatrixMode(GL_MODELVIEW);
616 glScaled(1.0, 1.0, -1.0);
617 glesMatrixMode(GL_PROJECTION);
618 glShadeModel(GL_FLAT);
620 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
621 glFogi(GL_FOG_MODE, GL_EXP);
622 glFogf(GL_FOG_DENSITY, 0);
623 glEnable(GL_NORMALIZE);
624 glDepthFunc(GL_LESS);
626 glDisable(GL_MULTISAMPLE_ARB);
630 glOrtho(0,w,h,0,0.0,1.0);
632 currentVertexBuffer = 0;
636 static void egl_term_display()
640 glDeleteTextures(1, &stippleTexture);
643 if(eglDisplay != EGL_NO_DISPLAY)
645 eglMakeCurrent(eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
646 if(eglContext != EGL_NO_CONTEXT)
647 eglDestroyContext(eglDisplay, eglContext);
648 if(eglSurface != EGL_NO_SURFACE)
649 eglDestroySurface(eglDisplay, eglSurface);
650 eglTerminate(eglDisplay);
652 eglDisplay = EGL_NO_DISPLAY;
653 eglContext = EGL_NO_CONTEXT;
654 eglSurface = EGL_NO_SURFACE;
659 // OpenGL Immediate Mode Porting Kit
660 static int beginCount;
661 static int vertexCount;
662 static int normalCount;
663 static float *vertexPointer;
664 static float *normalPointer;
665 static GLenum beginMode = -1;
666 static uint beginBufferSize, normalBufferSize;
667 static int numVertexCoords = 2;
668 static bool vertexColorValues = false;
669 static int vertexStride = 4;
670 static int vertexOffset = 2;
672 public void glesRecti(int a, int b, int c, int d)
682 public void glesBegin(GLenum mode)
687 vertexColorValues = false;
694 normalBufferSize = beginBufferSize = 1024; // default number of vertices
695 vertexPointer = new float[beginBufferSize * vertexStride];
696 normalPointer = new float[normalBufferSize * 3];
700 public void glesTexCoord2f(float x, float y)
702 int count = vertexCount;
704 if(vertexCount + numVertexCoords > beginBufferSize)
706 beginBufferSize = beginBufferSize + beginBufferSize/2;
707 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
710 vertexPointer[count*vertexStride ] = x;
711 vertexPointer[count*vertexStride+1] = y;
714 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
716 vertexPointer[count*vertexStride ] = vertexPointer[(count-4)*vertexStride];
717 vertexPointer[count*vertexStride+1] = vertexPointer[(count-4)*vertexStride+1];
719 vertexPointer[count*vertexStride ] = vertexPointer[(count-3)*vertexStride];
720 vertexPointer[count*vertexStride+1] = vertexPointer[(count-3)*vertexStride+1];
724 public void glesTexCoord2i(int x, int y) { glesTexCoord2f((float)x, (float)y); }
725 public void glesTexCoord2d(double x, double y) { glesTexCoord2f((float)x, (float)y); }
726 public void glesTexCoord2fv(float * a) { glesTexCoord2f(a[0], a[1]); }
728 public void glesVertex2f(float x, float y)
731 vertexStride = vertexOffset + numVertexCoords;
733 if(vertexCount + 4 > beginBufferSize)
735 beginBufferSize = beginBufferSize + beginBufferSize/2;
736 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
739 vertexPointer[vertexCount*vertexStride+vertexOffset] = x;
740 vertexPointer[vertexCount*vertexStride+vertexOffset + 1] = y;
743 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
745 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset];
746 vertexPointer[vertexCount*vertexStride+vertexOffset + 1] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset + 1];
748 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset];
749 vertexPointer[vertexCount*vertexStride+vertexOffset + 1] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset + 1];
754 public void glesVertex2i(int x, int y) { glesVertex2f((float)x, (float)y); }
755 public void glesVertex2d(double x, double y) { glesVertex2f((float)x, (float)y); }
757 public void glesEnd(void)
759 int mode = beginMode;
760 if(mode == GL_QUADS) mode = GL_TRIANGLES;
761 else if(mode == GL_POLYGON) mode = GL_TRIANGLE_FAN;
764 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
765 glTexCoordPointer(2, GL_FLOAT, vertexStride * sizeof(float), vertexPointer);
766 if(vertexColorValues)
768 glEnableClientState(GL_COLOR_ARRAY);
769 glColorPointer(4, GL_FLOAT, vertexStride * sizeof(float), vertexPointer + 2);
771 glVertexPointer (numVertexCoords, GL_FLOAT, (vertexStride)*sizeof(float),vertexPointer+vertexOffset);
772 if(normalCount && normalCount == vertexCount)
774 glEnableClientState(GL_NORMAL_ARRAY);
775 glNormalPointer (GL_FLOAT, 3*sizeof(float),normalPointer);
778 glDrawArrays(mode, 0, vertexCount);
780 glDisableClientState(GL_NORMAL_ARRAY);
781 if(vertexColorValues)
782 glDisableClientState(GL_COLOR_ARRAY);
783 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
785 vertexColorValues = false;
791 static float *floatVPBuffer = null;
792 static short *shortVPBuffer = null;
793 static unsigned int shortVPSize = 0, floatVPSize = 0;
796 //static float *floatVPBuffer = null; // For floats we reuse floatVPBuffer
797 static unsigned short *shortBDBuffer = null;
798 static unsigned int shortBDSize = 0/*, floatVPSize = 0*/;
800 public void glesVertexPointeri(int numCoords, int stride, int *pointer, int numVertices)
805 if(numVertices*numCoords > shortVPSize)
807 shortVPSize = numVertices*numCoords;
808 shortVPBuffer = renew shortVPBuffer short[shortVPSize];
810 for(i = 0; i < numVertices*numCoords; i++)
811 shortVPBuffer[i] = (short)pointer[i];
812 glVertexPointer(numCoords, GL_SHORT, stride, shortVPBuffer);
815 glVertexPointer(numCoords, GL_SHORT, stride, 0);
818 public void glesVertexPointerd(int numCoords, int stride, double *pointer, int numVertices)
823 if(numVertices*numCoords > floatVPSize)
825 floatVPSize = numVertices*numCoords;
826 floatVPBuffer = renew floatVPBuffer float[floatVPSize];
828 for(i = 0; i < numVertices*numCoords; i++)
829 floatVPBuffer[i] = (float)pointer[i];
830 glVertexPointer(numCoords, GL_FLOAT, stride, floatVPBuffer);
833 glVertexPointer(numCoords, GL_FLOAT, stride, 0);
836 public void glesTexReuseIntVP(int numCoords)
838 glTexCoordPointer(numCoords, GL_SHORT, 0, floatVPBuffer);
841 public void glesTexReuseDoubleVP(int numCoords)
843 glTexCoordPointer(numCoords, GL_FLOAT, 0, floatVPBuffer);
846 public void glesColor4f(float r, float g, float b, float a)
848 if(beginMode != (GLenum)-1)
850 int count = vertexCount;
852 vertexColorValues = true;
854 vertexStride = vertexOffset + numVertexCoords;
856 if(vertexCount + vertexStride > beginBufferSize)
858 beginBufferSize = beginBufferSize + beginBufferSize/2;
859 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
862 vertexPointer[count*vertexStride + 2] = r;
863 vertexPointer[count*vertexStride + 3] = g;
864 vertexPointer[count*vertexStride + 4] = b;
865 vertexPointer[count*vertexStride + 5] = a;
868 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
870 vertexPointer[count*vertexStride + 2] = vertexPointer[(count-4) * vertexStride + 2];
871 vertexPointer[count*vertexStride + 3] = vertexPointer[(count-4) * vertexStride + 3];
872 vertexPointer[count*vertexStride + 4] = vertexPointer[(count-4) * vertexStride + 4];
873 vertexPointer[count*vertexStride + 5] = vertexPointer[(count-4) * vertexStride + 5];
875 vertexPointer[count*vertexStride + 2] = vertexPointer[(count-3) * vertexStride + 2];
876 vertexPointer[count*vertexStride + 3] = vertexPointer[(count-3) * vertexStride + 3];
877 vertexPointer[count*vertexStride + 4] = vertexPointer[(count-3) * vertexStride + 4];
878 vertexPointer[count*vertexStride + 5] = vertexPointer[(count-3) * vertexStride + 5];
883 glColor4f(r, g, b, a);
886 public void glesColor3f( float r, float g, float b )
888 glesColor4f(r, g, b, 1.0f);
891 public void glesColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
893 glesColor4f(r/255.0f, g/255.0f, b/255.0f, a/255.0f);
896 public void glesColor4fv(float * a)
898 glesColor4f(a[0], a[1], a[2], a[3]);
901 public void glesBufferDatad(int target, int size, void * data, int usage)
903 int numElems = size/sizeof(double);
904 double * dblPtr = (double *)data;
906 if (numElems > floatVPSize)
908 floatVPSize = numElems;
909 floatVPBuffer = renew floatVPBuffer float[floatVPSize];
911 for (i=0; i< numElems; i++)
912 floatVPBuffer[i] = (float)dblPtr[i];
914 glBufferData(target, numElems*sizeof(float), floatVPBuffer, usage);
917 public void glesBufferDatai(int target, int size, void * data, int usage)
919 int numElems = size/sizeof(unsigned int);
920 unsigned int * pointer = (unsigned int *)data;
922 if (numElems > shortBDSize)
924 shortBDSize = numElems;
925 shortBDBuffer = renew shortBDBuffer uint16[shortBDSize];
927 for (i=0; i< numElems; i++)
928 shortBDBuffer[i] = (unsigned short)pointer[i];
930 glBufferData(target, numElems*sizeof(unsigned short), shortBDBuffer, usage);
933 // *** Our Custom Matrix Stack ***
935 static void LoadCurMatrix()
937 double * i = matrixStack[curStack][matrixIndex[curStack]].array;
940 (float)i[0],(float)i[1],(float)i[2],(float)i[3],
941 (float)i[4],(float)i[5],(float)i[6],(float)i[7],
942 (float)i[8],(float)i[9],(float)i[10],(float)i[11],
943 (float)i[12],(float)i[13],(float)i[14],(float)i[15]
948 public void glesLoadIdentity()
950 matrixStack[curStack][matrixIndex[curStack]].Identity();
954 public void glesPushMatrix()
956 if(matrixIndex[curStack] + 1 < sizeof(matrixStack[0]) / sizeof(Matrix))
958 matrixIndex[curStack]++;
959 memcpy(matrixStack[curStack][matrixIndex[curStack]].array, matrixStack[curStack][matrixIndex[curStack]-1].array, sizeof(Matrix));
963 public void glesPopMatrix()
965 if(matrixIndex[curStack] > 0)
967 matrixIndex[curStack]--;
972 public void glesLoadMatrixd(double * i)
974 memcpy(matrixStack[curStack][matrixIndex[curStack]].array, i, sizeof(Matrix));
978 public void glesOrtho( double l, double r, double b, double t, double n, double f )
982 (2 / (r - l)), 0, 0, 0,
983 0, (2 / (t - b)), 0, 0,
984 0, 0, (-2 / (f - n)), 0,
985 (-(r + l) / (r - l)), (-(t + b) / (t - b)), (-(f + n) / (f - n)), 1
988 res.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
989 matrixStack[curStack][matrixIndex[curStack]] = res;
993 public void glesFrustum( double l, double r, double b, double t, double n, double f )
1003 double A = ((r + l) / (r - l));
1004 double B = ((t + b) / (t - b));
1005 double C = (-(f + n) / (f - n));
1006 double D = (-2*f*n/(f-n));
1009 (2.0*n / (r - l)), 0, 0, 0,
1010 0, (2.0*n / (t - b)), 0, 0,
1015 res.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1016 matrixStack[curStack][matrixIndex[curStack]] = res;
1021 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1022 public void glesRotated( double a, double b, double c, double d )
1027 q.RotationAxis({(float)b,(float)c,(float)-d}, a );
1028 m.RotationQuaternion(q);
1029 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1030 matrixStack[curStack][matrixIndex[curStack]] = r;
1033 public void glesScaled( double a, double b, double c )
1039 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1040 matrixStack[curStack][matrixIndex[curStack]] = r;
1044 public void glesTranslated( double a, double b, double c )
1050 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1051 matrixStack[curStack][matrixIndex[curStack]] = r;
1055 public void glesMultMatrixd( double * i )
1058 r.Multiply((Matrix *)i, matrixStack[curStack][matrixIndex[curStack]]);
1059 matrixStack[curStack][matrixIndex[curStack]] = r;
1064 public void glesMatrixMode(int mode)
1066 curStack = (mode == GL_MODELVIEW) ? 0 : (mode == GL_PROJECTION) ? 1 : 2;
1072 #define glPushMatrix glesPushMatrix
1073 #define glPopMatrix glesPopMatrix
1074 #define glLoadIdentity glesLoadIdentity
1075 #define glMatrixMode glesMatrixMode
1079 /* Using the built-in matrix stack
1080 void glesLoadMatrixd( double * i )
1084 (float)i[0],(float)i[1],(float)i[2],(float)i[3],
1085 (float)i[4],(float)i[5],(float)i[6],(float)i[7],
1086 (float)i[8],(float)i[9],(float)i[10],(float)i[11],
1087 (float)i[12],(float)i[13],(float)i[14],(float)i[15]
1092 void glesOrtho( double l, double r, double b, double t, double n, double f )
1094 float matrix[4][4] =
1096 { (float)(2 / (r - l)), 0, 0, 0 },
1097 { 0, (float)(2 / (t - b)), 0, 0 },
1098 { 0, 0, (float)(-2 / (f - n)), 0 },
1099 { (float)(-(r + l) / (r - l)), (float)(-(t + b) / (t - b)), (float)(-(f + n) / (f - n)), 1 }
1101 glMultMatrixf((float *)matrix);
1104 void glesFrustum( double l, double r, double b, double t, double n, double f )
1106 float A = (float)((r + l) / (r - l));
1107 float B = (float)((t + b) / (t - b));
1108 float C = (float)(-(f + n) / (f - n));
1109 float D = (float)(-2*f*n/(f-n));
1110 float matrix[4][4] =
1112 { (float)(2*n / (r - l)), 0, 0, 0 },
1113 { 0, (float)(2*n / (t - b)), 0, 0 },
1117 glMultMatrixf((float *)matrix);
1120 void glesRotated( double a, double b, double c, double d ) { glRotatef((float)a, (float)b, (float)c, (float)d); }
1121 void glesScaled( double a, double b, double c ) { glScalef((float)a, (float)b, (float)c); }
1122 void glesTranslated( double a, double b, double c ) { glTranslatef((float)a, (float)b, (float)c); }
1124 void glesMultMatrixd( double * i )
1128 (float)i[0], (float)i[1], (float)i[2], (float)i[3],
1129 (float)i[4], (float)i[5], (float)i[6], (float)i[7],
1130 (float)i[8], (float)i[9], (float)i[10], (float)i[11],
1131 (float)i[12], (float)i[13], (float)i[14], (float)i[15]
1137 // Need to do these...
1138 public void glesVertex3f( float x, float y, float z )
1140 numVertexCoords = 3;
1141 vertexStride = vertexOffset + numVertexCoords;
1143 if(vertexCount + vertexStride > beginBufferSize)
1145 beginBufferSize = beginBufferSize + beginBufferSize/2;
1146 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
1149 vertexPointer[vertexCount*vertexStride+vertexOffset] = x;
1150 vertexPointer[vertexCount*vertexStride+vertexOffset+1] = y;
1151 vertexPointer[vertexCount*vertexStride+vertexOffset+2] = z;
1154 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
1156 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset];
1157 vertexPointer[vertexCount*vertexStride+vertexOffset+1] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset+1];
1158 vertexPointer[vertexCount*vertexStride+vertexOffset+2] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset+2];
1160 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset];
1161 vertexPointer[vertexCount*vertexStride+vertexOffset+1] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset+1];
1162 vertexPointer[vertexCount*vertexStride+vertexOffset+2] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset+2];
1168 public void glesVertex3d( double x, double y, double z ) { glesVertex3f((float)x, (float)y, (float)z); }
1169 public void glesVertex3fv( float* coords ) { glesVertex3f(coords[0], coords[1], coords[2]); }
1170 public void glesVertex3dv( double* coords ) { glesVertex3f((float)coords[0], (float)coords[1], (float)coords[2]); }
1172 public void glesNormal3f(float x, float y, float z)
1174 normalCount = vertexCount;
1175 if(vertexCount + 4 > normalBufferSize)
1177 normalBufferSize = normalBufferSize + normalBufferSize/2;
1178 normalPointer = renew normalPointer float[normalBufferSize * 2];
1181 normalPointer[normalCount*3+0] = x;
1182 normalPointer[normalCount*3+1] = y;
1183 normalPointer[normalCount*3+2] = z;
1186 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
1188 normalPointer[normalCount*3+0] = normalPointer[(normalCount-4)*3+0];
1189 normalPointer[normalCount*3+1] = normalPointer[(normalCount-4)*3+1];
1190 normalPointer[normalCount*3+2] = normalPointer[(normalCount-4)*3+2];
1192 normalPointer[normalCount*3+0] = normalPointer[(normalCount-3)*3+0];
1193 normalPointer[normalCount*3+1] = normalPointer[(normalCount-3)*3+1];
1194 normalPointer[normalCount*3+2] = normalPointer[(normalCount-3)*3+2];
1198 public void glesNormal3fd(double x, double y, double z) { glesNormal3f((float)x, (float)y, (float)z); }
1199 public void glesNormal3fv(float * coords) { glesNormal3f(coords[0], coords[1], coords[2]); }
1201 public void glesColorMaterial(int a, int b)
1203 PrintLn("glColorMaterial stub");
1206 public void glesTerminate()
1208 delete vertexPointer;
1209 delete normalPointer;
1210 beginBufferSize = 0;
1212 delete floatVPBuffer;
1215 delete shortVPBuffer;
1218 delete shortBDBuffer;
1222 static GLuint stippleTexture;
1223 #if defined(_GLES) || defined(EM_MODE)
1224 static bool stippleEnabled;
1227 public void glesLineStipple( int i, unsigned short j )
1231 for(x = 0; x < 16; x++)
1233 bool v = (j & (1 << x)) != 0;
1234 texture[x] = v ? 0xFFFFFFFF : 0;
1237 glGenTextures(1, &stippleTexture);
1238 glBindTexture(GL_TEXTURE_2D, stippleTexture);
1239 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture);
1240 glEnable(GL_TEXTURE_2D);
1241 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1242 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1243 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
1244 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1245 glMatrixMode(GL_TEXTURE);
1247 //glTranslated(1.0/backAttrib->texW/2.0f, 1.0/backAttrib->texH/2.0f, 0.0f);
1248 glScaled(i/16.0, 1, 1.0f);
1249 glTranslated(0.5, 0.5, 0);
1250 glMatrixMode(GL_PROJECTION);
1253 public void glesLightModeli( unsigned int pname, int param )
1255 #if !defined(EM_MODE)
1256 if(pname == GL_LIGHT_MODEL_TWO_SIDE)
1257 glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, param);
1262 void glClearDepth( double depth ) { glClearDepthf((float)depth); }
1263 void glFogi( unsigned int pname, int param ) { }
1264 void glPolygonMode( unsigned int i, unsigned int j ) { }
1267 // *** Picking won't be supported for now ***
1268 void glPushName( unsigned int i ) { }
1269 void glLoadName( unsigned int i ) { }
1270 void glPopName() { }
1272 // Probably replace by regular glBlendFunc ...
1273 void glBlendFuncSeparate(int a, int b, int c, int d)
1278 // For direct pixel blitting...
1279 void glRasterPos2d(double a, double b) { }
1280 void glPixelZoom(float a, float b) { }
1281 void glDrawPixels(int a, int b, int c, int d, void * e) { }
1285 #if !defined(__APPLE__) && !defined(__WIN32__)
1286 void (APIENTRY * glBindBufferARB) (GLenum target, GLuint buffer);
1287 void (APIENTRY * glGenBuffersARB) (GLsizei n, GLuint *buffers);
1288 void (APIENTRY * glDeleteBuffersARB) (GLsizei n, const GLuint *buffers);
1289 void (APIENTRY * glBufferDataARB) (GLenum target, int size, const GLvoid *data, GLenum usage);
1292 static int currentVertexBuffer;
1294 bool GLSelectVBO(uint vbo)
1296 if(currentVertexBuffer != vbo)
1298 GLBindBuffer(GL_ARRAY_BUFFER, vbo);
1299 currentVertexBuffer = vbo;
1305 void GLGenBuffers(int count, uint * buffer)
1307 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__)
1308 glGenBuffers(count, buffer);
1310 #if defined(__WIN32__)
1313 glGenBuffersARB(count, buffer);
1317 void GLDeleteBuffers(int count, GLuint * buffer)
1319 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__)
1320 glDeleteBuffers(count, buffer);
1322 #if defined(__WIN32__)
1323 if(glDeleteBuffersARB)
1325 glDeleteBuffersARB(count, buffer);
1329 void GLBindBuffer(int target, uint buffer)
1331 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__)
1332 glBindBuffer(target, buffer);
1334 #if defined(__WIN32__)
1337 glBindBufferARB(target, buffer);
1339 currentVertexBuffer = buffer;
1342 public void GLVertexPointer(int numCoords, int glType, int stride, void *ptr, int numVertices)
1345 if(glType == GL_DOUBLE)
1346 glesVertexPointerd(numCoords, stride, ptr, numVertices);
1347 else if(glType == GL_INT)
1348 glesVertexPointeri(numCoords, stride, ptr, numVertices);
1351 glVertexPointer(numCoords, glType, stride, ptr);
1354 public void GLBufferData(int type, GLenum target, int size, const GLvoid *data, GLenum usage)
1357 if(type == GL_DOUBLE)
1358 glesBufferDatad(target, size, (void *)data, usage);
1359 else if(type == GL_UNSIGNED_INT)
1360 glesBufferDatai(target, size, (void *)data, usage);
1364 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__)
1365 glBufferData(target, size, data, usage);
1368 #if defined(__WIN32__)
1371 glBufferDataARB(target, size, data, usage);
1375 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1376 static int primitiveTypes[RenderPrimitiveType] =
1378 GL_POINTS, GL_LINES, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP, GL_LINE_STRIP
1383 // Non OpenGL ES friendly stuff
1387 //#undef GL_UNSIGNED_INT
1392 #undef GL_QUAD_STRIP
1393 #undef GL_POLYGON_STIPPLE
1394 #undef GL_LINE_STIPPLE
1397 #undef GL_ALL_ATTRIB_BITS
1398 #undef GL_LIGHT_MODEL_LOCAL_VIEWER
1402 static int displayWidth, displayHeight;
1404 #define GL_CLAMP_TO_EDGE 0x812F
1406 static bool vboAvailable;
1408 static bool useSingleGLContext = false;
1409 class OGLDisplay : struct
1411 #if defined(__WIN32__)
1421 int imageBuffers[2];
1422 byte * pboMemory1, * pboMemory2;
1424 #elif !defined(__ANDROID__) && !defined(__EMSCRIPTEN__)
1425 GLXContext glContext;
1428 XShmSegmentInfo shminfo;
1430 XShmSegmentInfo shminfoShape;
1431 XImage * shapeImage;
1435 X11Picture windowPicture;
1436 X11Picture pixmapPicture;
1438 X11Picture shapePicture;
1441 ColorAlpha * flippingBuffer;
1442 int flipBufH, flipBufW;
1447 class OGLSystem : struct
1452 #if defined(__WIN32__)
1453 PIXELFORMATDESCRIPTOR pfd;
1458 #elif !defined(__ANDROID__) && !defined(__EMSCRIPTEN__)
1459 XVisualInfo * visualInfo;
1460 GLXContext glContext;
1461 GLXDrawable glxDrawable;
1465 class OGLSurface : struct
1471 bool writingOutline;
1473 float foreground[4], background[4], bitmapMult[4];
1476 class OGLMesh : struct
1485 class OGLIndices : struct
1495 class OpenGLDisplayDriver : DisplayDriver
1497 class_property(name) = "OpenGL";
1499 bool LockSystem(DisplaySystem displaySystem)
1501 #if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__)
1502 OGLSystem oglSystem = displaySystem.driverData;
1503 if(useSingleGLContext) return true;
1504 #if defined(__WIN32__)
1505 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1506 #elif defined(__unix__) || defined(__APPLE__)
1507 //if(previous) return true;
1508 // printf("Making SYSTEM current\n");
1509 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)oglSystem.glxDrawable, oglSystem.glContext);
1510 //previous = oglSystem.glContext;
1516 void UnlockSystem(DisplaySystem displaySystem)
1518 if(useSingleGLContext) return;
1519 #if defined(__WIN32__)
1520 wglMakeCurrent(null, null);
1521 #elif defined(__unix__) || defined(__APPLE__)
1522 // printf("Making NULL current\n");
1523 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__)
1525 glXMakeCurrent(xGlobalDisplay, None, null);
1531 bool Lock(Display display)
1533 #if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__)
1534 OGLDisplay oglDisplay = display.driverData;
1535 if(useSingleGLContext) return true;
1536 #if defined(__WIN32__)
1537 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1538 #elif defined(__unix__) || defined(__APPLE__)
1539 // if(previous) glXMakeCurrent(xGlobalDisplay, None, null);
1540 // printf(" Making DISPLAY current\n");
1541 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
1547 void Unlock(Display display)
1549 if(useSingleGLContext) return;
1550 //printf(" Making NULL current\n");
1551 //glXMakeCurrent(xGlobalDisplay, None, null);
1553 LockSystem(display.displaySystem);
1556 void DestroyDisplay(Display display)
1558 OGLDisplay oglDisplay = display.driverData;
1562 #if defined(__WIN32__)
1563 wglMakeCurrent( null, null );
1566 wglDeleteContext(oglDisplay.glrc);
1568 if(oglDisplay.hdc && oglDisplay.pBuffer)
1569 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
1571 if(oglDisplay.pBuffer)
1572 wglDestroyPbufferARB(oglDisplay.pBuffer);
1575 ReleaseDC(display.window, oglDisplay.hdc);
1577 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
1578 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
1580 #elif defined(__unix__) || defined(__APPLE__)
1581 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__)
1583 if(oglDisplay.shapePixmap)
1584 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
1585 if(oglDisplay.pixmap)
1586 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1587 if(oglDisplay.image)
1589 if(oglDisplay.shminfoShape.shmid != -1)
1591 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
1592 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1593 shmdt(oglDisplay.shminfo.shmaddr);
1594 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
1597 if(oglDisplay.shapeImage)
1599 if(oglDisplay.shminfoShape.shmid != -1)
1601 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
1602 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1603 shmdt(oglDisplay.shminfoShape.shmaddr);
1604 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
1606 XDestroyImage(oglDisplay.shapeImage);
1607 oglDisplay.shapeImage = None;
1610 glXMakeCurrent(xGlobalDisplay, None, null);
1612 if(oglDisplay.glContext)
1613 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
1616 delete oglDisplay.flippingBuffer;
1618 display.driverData = null;
1622 void ::CheckExtensions(OGLSystem oglSystem)
1624 const char * extensions = (const char *)glGetString(GL_EXTENSIONS);
1626 oglSystem.pow2textures = strstr(extensions, "GL_ARB_texture_non_power_of_two") ? false : true;
1627 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &oglSystem.maxTextureSize);
1630 bool CreateDisplaySystem(DisplaySystem displaySystem)
1632 bool result = false;
1633 OGLSystem oglSystem = displaySystem.driverData = OGLSystem { };
1636 oglSystem.hwnd = CreateWindow("static", null, 0,0,0,0,0,null,null,null,null);
1638 oglSystem.hdc = GetDC(oglSystem.hwnd);
1642 oglSystem.pfd.nSize = (short)sizeof(oglSystem.pfd);
1643 oglSystem.pfd.nVersion = 1;
1644 oglSystem.pfd.dwFlags = PFD_DRAW_TO_WINDOW /*PFD_DRAW_TO_BITMAP*/ | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
1645 oglSystem.pfd.iPixelType = PFD_TYPE_RGBA;
1646 oglSystem.pfd.cColorBits = 24;
1647 oglSystem.pfd.cAlphaBits = 8;
1648 oglSystem.pfd.cDepthBits = 24;
1649 oglSystem.pfd.iLayerType = PFD_MAIN_PLANE;
1651 oglSystem.format = ChoosePixelFormat(oglSystem.hdc, &oglSystem.pfd);
1652 DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1654 if(oglSystem.pfd.cColorBits > 8)
1656 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1657 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1660 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1662 // Get Pointers To The GL Functions
1663 glActiveTextureARB = (void *) wglGetProcAddress("glActiveTextureARB");
1664 glMultiTexCoord2fARB = (void *) wglGetProcAddress("glMultiTexCoord2fARB");
1665 glClientActiveTextureARB = (void *) wglGetProcAddress("glClientActiveTextureARB");
1666 glLockArraysEXT = (void *) wglGetProcAddress("glLockArraysEXT" );
1667 glUnlockArraysEXT = (void *) wglGetProcAddress("glUnlockArraysEXT");
1668 glGenBuffersARB = (void *) wglGetProcAddress("glGenBuffersARB");
1669 glBindBufferARB = (void *) wglGetProcAddress("glBindBufferARB");
1670 glBufferDataARB = (void *) wglGetProcAddress("glBufferDataARB");
1671 glMapBufferARB = (void *) wglGetProcAddress("glMapBufferARB");
1672 glUnmapBufferARB = (void *) wglGetProcAddress("glUnmapBufferARB");
1673 glDeleteBuffersARB = (void *) wglGetProcAddress("glDeleteBuffersARB");
1674 glBlendFuncSeparate = (void *) wglGetProcAddress("glBlendFuncSeparate");
1676 wglChoosePixelFormatARB = (void *) wglGetProcAddress("wglChoosePixelFormatARB");
1677 wglGetExtensionsStringARB = (void *)wglGetProcAddress("wglGetExtensionsStringARB");
1678 wglCreatePbufferARB = (void *)wglGetProcAddress("wglCreatePbufferARB");
1679 wglGetPbufferDCARB = (void *)wglGetProcAddress("wglGetPbufferDCARB");
1680 wglQueryPbufferARB = (void *)wglGetProcAddress("wglQueryPbufferARB");
1681 wglDestroyPbufferARB = (void *)wglGetProcAddress("wglDestroyPbufferARB");
1682 wglReleasePbufferDCARB = (void *)wglGetProcAddress("wglReleasePbufferDCARB");
1683 wglBindTexImageARB = (void *)wglGetProcAddress("wglBindTexImageARB");
1684 wglReleaseTexImageARB = (void *)wglGetProcAddress("wglReleaseTexImageARB");
1686 wglSwapIntervalEXT = (void *)wglGetProcAddress("wglSwapIntervalEXT");
1688 vboAvailable = glBindBufferARB != null;
1690 // eSystem_LoggingMode(LOG_MSGBOX, null);
1692 if(wglChoosePixelFormatARB)
1697 float fAttributes[] = {0,0};
1700 WGL_DRAW_TO_WINDOW_ARB,GL_TRUE,
1701 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1702 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
1703 WGL_COLOR_BITS_ARB,24,
1704 WGL_ALPHA_BITS_ARB,8,
1705 WGL_DEPTH_BITS_ARB,16,
1706 WGL_STENCIL_BITS_ARB,0,
1707 WGL_DOUBLE_BUFFER_ARB,GL_TRUE,
1708 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
1709 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
1713 //Log("Found wglChoosePixelFormatARB\n");
1715 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1716 if(!valid || !numFormats)
1718 //Log("Can't find 4x multi sampling\n");
1719 iAttributes[19] = 2;
1720 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1721 if(!valid || !numFormats)
1723 // Log("Can't find 2x multi sampling\n");
1724 iAttributes[16] = 0;
1725 iAttributes[17] = 0;
1726 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1729 if(valid && numFormats)
1731 oglSystem.format = pixelFormat;
1732 wglMakeCurrent(null, null);
1733 wglDeleteContext(oglSystem.glrc);
1735 // *** DescribePixelFormat does not support WGL pixel formats! ***
1736 //DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1737 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1738 //Log("Successfully set pixel format\n");
1740 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1741 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1745 eSystem_Logf("Can't find wglChoosePixelFormatARB\n");*/
1749 CheckExtensions(oglSystem);
1751 wglMakeCurrent(null, null);
1753 //eSystem_DumpErrors(true);
1757 #elif defined(__unix__) || defined(__APPLE__)
1758 vboAvailable = true;
1759 #if defined(__ANDROID__)
1760 egl_init_display(guiApp.desktop.windowHandle);
1761 CheckExtensions(oglSystem);
1763 #elif defined(__EMSCRIPTEN__)
1764 if(glfwInit() == GL_TRUE)
1766 const int width = 640, height = 480;
1767 if(glfwOpenWindow(width, height, 8, 8, 8, 8, 16, 0, GLFW_WINDOW) == GL_TRUE)
1769 //glfwSwapBuffers();
1773 printf("glfwOpenWindow() failed\n"); //glfwTerminate();
1776 printf("glfwInit() failed\n"); //glfwTerminate();
1779 X11Window root = RootWindow( xGlobalDisplay, DefaultScreen( xGlobalDisplay ) );
1780 XSetWindowAttributes attr;
1785 #ifndef ECERE_MINIGLX
1786 GLX_USE_GL, GLX_DEPTH_SIZE, 1,
1789 GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,
1793 oglSystem.visualInfo = glXChooseVisual( xGlobalDisplay, DefaultScreen( xGlobalDisplay ), attrList );
1794 attr.background_pixel = 0;
1795 attr.border_pixel = 0;
1796 attr.colormap = XCreateColormap( xGlobalDisplay, root, oglSystem.visualInfo->visual, AllocNone);
1797 attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
1798 mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
1800 oglSystem.glxDrawable = XCreateWindow( xGlobalDisplay, root, 0, 0, 1, 1, 0, oglSystem.visualInfo->depth, InputOutput,
1801 oglSystem.visualInfo->visual, mask, &attr );
1803 if(oglSystem.visualInfo)
1805 oglSystem.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, null, True);
1806 if(oglSystem.glContext)
1808 glXMakeCurrent(xGlobalDisplay, oglSystem.glxDrawable, oglSystem.glContext);
1810 CheckExtensions(oglSystem);
1811 glXMakeCurrent(xGlobalDisplay, None, null);
1818 displaySystem.flags.alpha = true;
1819 displaySystem.flags.flipping = true;
1820 displaySystem.pixelFormat = pixelFormat888;
1824 void DestroyDisplaySystem(DisplaySystem displaySystem)
1826 OGLSystem oglSystem = displaySystem.driverData;
1828 #if defined(__WIN32__)
1829 wglMakeCurrent( null, null );
1832 wglDeleteContext(oglSystem.glrc);
1835 ReleaseDC(oglSystem.hwnd, oglSystem.hdc);
1836 DestroyWindow(oglSystem.hwnd);
1838 #elif defined(__unix__) || defined(__APPLE__)
1839 #if defined(__ANDROID__)
1841 #elif defined(__EMSCRIPTEN__)
1844 if(oglSystem.visualInfo)
1846 #ifdef ECERE_MINIGLX
1847 __miniglx_XFree(oglSystem.visualInfo);
1849 XFree(oglSystem.visualInfo);
1853 if(oglSystem.glxDrawable)
1855 XDestroyWindow(xGlobalDisplay, oglSystem.glxDrawable);
1856 oglSystem.glxDrawable = 0;
1863 bool CreateDisplay(Display display)
1865 bool result = false;
1866 OGLDisplay oglDisplay = display.driverData;
1867 #if !defined(__ANDROID__) && !defined(__EMSCRIPTEN__)
1868 OGLSystem oglSystem = display.displaySystem.driverData;
1871 oglDisplay = display.driverData = OGLDisplay { };
1872 //printf("Inside CreateDisplay\n");
1874 #if defined(__WIN32__) || defined(USEPBUFFER)
1875 if(!display.alphaBlend)
1878 #if defined(__WIN32__)
1879 oglDisplay.hdc = GetDC(display.window);
1880 SetPixelFormat(oglDisplay.hdc, oglSystem.format, &oglSystem.pfd);
1881 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
1883 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
1884 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1888 ReleaseDC(display.window, oglDisplay.hdc);
1889 #elif defined(__unix__) || defined(__APPLE__)
1890 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__)
1892 XVisualInfo * visualInfo = ((XWindowData)display.windowDriverData).visual;
1894 #if defined(__APPLE__)
1895 XVisualInfo template = { 0 };
1896 XWindowAttributes winAttr;
1898 XGetWindowAttributes(xGlobalDisplay, (X11Window)display.window, &winAttr);
1899 template.visualid = XVisualIDFromVisual(winAttr.visual);
1900 visualInfo = XGetVisualInfo(xGlobalDisplay, VisualIDMask, &template, &n);
1902 printf("XGetVisualInfo visual ID = %d\n", template.visualid);
1903 printf("visualInfo visual ID = %d\n", visualInfo->visualid);
1904 printf("oglSystem.visualInfo visual ID = %d\n", oglSystem.visualInfo->visualid);
1905 printf("((XWindowData)display.windowDriverData).visual visual ID = %d\n", ((XWindowData)display.windowDriverData).visual->visualid);
1907 // visualInfo = oglSystem.visualInfo;
1912 //printf("visualInfo is not null\n");
1913 // printf("Creating Display Context, sharing with %x!\n", oglSystem.glContext);
1914 oglDisplay.glContext = glXCreateContext(xGlobalDisplay, visualInfo, oglSystem.glContext, True);
1915 //XFree(visualInfo);
1918 // oglDisplay.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, oglSystem.glContext, True);
1919 if(oglDisplay.glContext)
1921 //printf("CreateDisplay Got a Context\n");
1922 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
1928 #if defined(__WIN32__) || defined(USEPBUFFER)
1934 #if defined(__WIN32__)
1935 if(glBlendFuncSeparate)
1936 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1938 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1940 #if !defined(__OLDX__)
1941 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1943 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1948 glMatrixMode(GL_MODELVIEW);
1949 glScaled(1.0, 1.0, -1.0);
1950 // glTranslatef(0.375f, 0.375f, 0.0f);
1951 // glTranslatef(-0.625f, -0.625f, 0.0f);
1952 glMatrixMode(GL_PROJECTION);
1953 glShadeModel(GL_FLAT);
1955 // glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, true);
1956 #if !defined(EM_MODE)
1957 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
1959 glFogi(GL_FOG_MODE, GL_EXP);
1960 glFogf(GL_FOG_DENSITY, 0);
1961 glEnable(GL_NORMALIZE);
1962 glDepthFunc(GL_LESS);
1964 glDisable(GL_MULTISAMPLE_ARB);
1966 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1967 display.ambient = Color { 50,50,50 };
1970 if(!useSingleGLContext)
1972 #if defined(__WIN32__)
1973 wglMakeCurrent(null, null);
1974 #elif defined(__unix__) || defined(__APPLE__)
1975 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__)
1978 glXMakeCurrent(xGlobalDisplay, None, null);
1986 bool DisplaySize(Display display, int width, int height)
1988 OGLDisplay oglDisplay = display.driverData;
1990 bool result = false;
1992 //printf("Inside DisplaySize\n");
1993 #if defined(__WIN32__) || defined(USEPBUFFER)
1994 OGLSystem oglSystem = display.displaySystem.driverData;
1995 if(display.alphaBlend)
1997 #if defined(__WIN32__)
1998 const int attributes[]=
2000 /*WGL_TEXTURE_FORMAT_ARB, WGL_TEXTURE_RGBA_ARB,
2001 WGL_TEXTURE_TARGET_ARB, WGL_TEXTURE_2D_ARB, */0
2003 int pixelFormat = 0;
2004 if(wglChoosePixelFormatARB)
2008 float fAttributes[] = {0,0};
2011 //WGL_DRAW_TO_BITMAP_ARB, GL_TRUE,
2012 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2013 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2014 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
2015 WGL_COLOR_BITS_ARB,24,
2016 WGL_ALPHA_BITS_ARB,8,
2017 WGL_DEPTH_BITS_ARB,16,
2018 WGL_STENCIL_BITS_ARB,0,
2019 WGL_DOUBLE_BUFFER_ARB,GL_FALSE,
2020 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
2021 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
2025 //Log("Found wglChoosePixelFormatARB\n");
2027 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2028 if(!valid || !numFormats)
2030 //Log("Can't find 4x multi sampling\n");
2031 iAttributes[19] = 2;
2032 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2033 if(!valid || !numFormats)
2035 // Log("Can't find 2x multi sampling\n");
2036 iAttributes[16] = 0;
2037 iAttributes[17] = 0;
2038 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2039 if(!valid || !numFormats)
2043 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2044 //WGL_DRAW_TO_BITMAP_ARB,GL_TRUE,
2045 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2046 WGL_COLOR_BITS_ARB,24,
2047 WGL_ALPHA_BITS_ARB,8,
2048 WGL_DEPTH_BITS_ARB,16,
2051 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2055 if(valid && numFormats)
2057 wglMakeCurrent(null, null);
2061 wglMakeCurrent( null, null );
2062 wglMakeCurrent( oglDisplay.hdc, oglDisplay.glrc );
2063 if(oglDisplay.hdc && oglDisplay.pBuffer)
2064 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
2066 wglDestroyPbufferARB(oglDisplay.pBuffer);
2068 if(!useSingleGLContext)
2069 wglMakeCurrent( null, null );
2072 wglDeleteContext(oglDisplay.glrc);
2074 oglDisplay.pBuffer = wglCreatePbufferARB(oglSystem.hdc, pixelFormat, width, height, attributes);
2075 oglDisplay.hdc = wglGetPbufferDCARB(oglDisplay.pBuffer);
2076 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
2079 HDC hdc = GetDC(display.window);
2081 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2082 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2084 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_WIDTH_ARB, &width);
2085 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_HEIGHT_ARB, &height);
2087 // glDeleteBuffersARB(2, oglDisplay.imageBuffers);
2089 if((info = (BITMAPINFO *)new0 byte[sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*256]))
2093 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
2094 oglDisplay.memDC = CreateCompatibleDC(hdc);
2095 SetMapMode(oglDisplay.memDC, MM_TEXT);
2096 info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2097 info->bmiHeader.biPlanes = 1;
2098 info->bmiHeader.biCompression = BI_RGB;
2099 info->bmiHeader.biBitCount = 32; //(uint16)GetDeviceCaps(hdc, BITSPIXEL);
2100 info->bmiHeader.biWidth = width;
2101 info->bmiHeader.biHeight = height;
2102 newBitmap = CreateDIBSection(hdc, info, DIB_RGB_COLORS, &oglDisplay.picture, null, 0);
2105 SelectObject(oglDisplay.memDC, newBitmap);
2106 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
2109 PIXELFORMATDESCRIPTOR pfd = { 0 };
2110 pfd.nSize = (short)sizeof(pfd);
2112 pfd.dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL;
2113 pfd.iPixelType = PFD_TYPE_RGBA;
2114 pfd.cColorBits = 32;
2115 //pfd.cAlphaBits = 8;
2116 pfd.cDepthBits = 24;
2117 pfd.iLayerType = PFD_MAIN_PLANE;
2119 oglDisplay.hdc = oglDisplay.memDC;
2121 pixelFormat = ChoosePixelFormat(oglSystem.hdc, &pfd);
2122 DescribePixelFormat(oglDisplay.hdc, pixelFormat, sizeof(pfd), &pfd);
2123 SetPixelFormat(oglDisplay.hdc, pixelFormat, &pfd);
2125 oglDisplay.glrc = wglCreateContext(oglDisplay.hdc);
2126 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2127 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2132 const int imageSize = width * height * 4;
2134 glGenBuffersARB(2, oglDisplay.imageBuffers);
2136 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2137 glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize, null, GL_STREAM_READ);
2138 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2139 // glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize / 2, null, GL_STREAM_READ);
2142 oglDisplay.memBitmap = newBitmap;
2143 oglDisplay.stride = width;
2149 ReleaseDC(display.window, hdc);
2151 #elif defined(__unix__) || defined(__APPLE__)
2152 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__)
2157 GLX_DOUBLEBUFFER, True,
2163 GLX_STENCIL_SIZE, 1,
2164 //GLX_DEPTH_SIZE, 24,
2165 GLX_RENDER_TYPE, GLX_RGBA_BIT,
2166 GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT | GLX_WINDOW_BIT,
2172 GLX_PBUFFER_WIDTH, width,
2173 GLX_PBUFFER_HEIGHT, height,
2174 GLX_LARGEST_PBUFFER, False,
2178 // choose a pixel format that meets our minimum requirements
2181 GLXFBConfig *config = glXChooseFBConfig(xGlobalDisplay, DefaultScreen(xGlobalDisplay), attrib, &count);
2184 if(oglDisplay.pixmap)
2186 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2187 oglDisplay.pixmap = None;
2189 if(oglDisplay.shapePixmap)
2191 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
2192 oglDisplay.shapePixmap = None;
2195 // Free Shared Memory Pixmap
2196 if(oglDisplay.image)
2198 if(oglDisplay.shminfoShape.shmid != -1)
2200 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
2201 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2202 shmdt(oglDisplay.shminfo.shmaddr);
2203 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
2205 XDestroyImage(oglDisplay.image);
2206 oglDisplay.image = None;
2208 if(oglDisplay.shapeImage)
2210 if(oglDisplay.shminfoShape.shmid != -1)
2212 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
2213 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2214 shmdt(oglDisplay.shminfoShape.shmaddr);
2215 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
2217 XDestroyImage(oglDisplay.shapeImage);
2218 oglDisplay.shapeImage = None;
2221 if(oglDisplay.windowPicture)
2222 XRenderFreePicture(xGlobalDisplay, oglDisplay.windowPicture);
2223 if(oglDisplay.pixmapPicture)
2224 XRenderFreePicture(xGlobalDisplay, oglDisplay.pixmapPicture);
2226 if(oglDisplay.pixmap)
2227 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2229 if(oglDisplay.glContext)
2230 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
2231 if(oglDisplay.pBuffer)
2232 glXDestroyPbuffer(xGlobalDisplay, oglDisplay.pBuffer);
2234 oglDisplay.pBuffer = glXCreatePbuffer(xGlobalDisplay, config[0], PBattrib);
2235 if(oglDisplay.pBuffer)
2237 oglDisplay.glContext = glXCreateNewContext(xGlobalDisplay, config[0], GLX_RGBA_TYPE, oglSystem.glContext, True);
2238 if(oglDisplay.glContext)
2240 glXMakeCurrent(xGlobalDisplay, None, null);
2241 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2243 // Initialize Shared Memory Pixmap
2244 oglDisplay.image = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 32,
2245 ZPixmap, null, &oglDisplay.shminfo, width, height);
2246 if(oglDisplay.image)
2248 oglDisplay.shminfo.shmid = shmget(IPC_PRIVATE,
2249 oglDisplay.image->bytes_per_line * oglDisplay.image->height, IPC_CREAT|0777);
2250 if(oglDisplay.shminfo.shmid != -1)
2252 oglDisplay.shminfo.shmaddr = shmat(oglDisplay.shminfo.shmid, 0, 0);
2253 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2255 oglDisplay.shminfo.readOnly = False;
2256 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfo))
2258 oglDisplay.pixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfo.shmaddr,
2259 &oglDisplay.shminfo, width, height, 32);
2261 // Initialize Shared Memory Shape Pixmap
2262 oglDisplay.shapeImage = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 1,
2263 ZPixmap, null, &oglDisplay.shminfoShape, width, height);
2264 if(oglDisplay.shapeImage)
2266 oglDisplay.shminfoShape.shmid = shmget(IPC_PRIVATE,
2267 oglDisplay.shapeImage->bytes_per_line * oglDisplay.shapeImage->height, IPC_CREAT|0777);
2268 if(oglDisplay.shminfoShape.shmid != -1)
2270 oglDisplay.shminfoShape.shmaddr = shmat(oglDisplay.shminfoShape.shmid, 0, 0);
2271 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2273 oglDisplay.shminfoShape.readOnly = False;
2274 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfoShape))
2276 oglDisplay.shapePixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfoShape.shmaddr,
2277 &oglDisplay.shminfoShape, width, height, 1);
2278 //oglDisplay.shapePixmap = XCreatePixmap(xGlobalDisplay, (X11Window)display.window, width, height, 1);
2281 XRenderPictureAttributes attributes = { 0 };
2282 XRenderPictFormat * format = XRenderFindStandardFormat(xGlobalDisplay, /*PictStandardRGB24*/ PictStandardARGB32);
2283 #if !defined(__APPLE__) && !defined(__OLDX__)
2284 attributes.repeat = RepeatNormal;
2286 attributes.repeat = 1;
2288 oglDisplay.pixmapPicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.pixmap, format, CPRepeat, &attributes);
2289 oglDisplay.windowPicture = XRenderCreatePicture(xGlobalDisplay, (X11Window)display.window, format, 0, &attributes);
2290 oglDisplay.shapePicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.shapePixmap,
2291 XRenderFindStandardFormat(xGlobalDisplay, PictStandardA1), 0, &attributes);
2294 oglDisplay.picture = oglDisplay.shminfo.shmaddr;
2295 oglDisplay.stride = oglDisplay.image->bytes_per_line / 4;
2312 CreateDisplay(display);
2313 #if defined(__WIN32__)
2314 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2315 #elif defined(__unix__) || defined(__APPLE__)
2316 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__)
2320 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2327 if(!result && display.alphaBlend)
2329 printf("Alpha blending windows not supported on this display\n");
2336 glViewport(0,0,width,height);
2338 glOrtho(0,width,height,0,0.0,1.0);
2339 displayWidth = display.width = width;
2340 displayHeight = display.height = height;
2342 if(!oglDisplay.flippingBuffer || oglDisplay.flipBufW < width || oglDisplay.flipBufH < height)
2344 oglDisplay.flipBufW = width;
2345 oglDisplay.flipBufH = height;
2349 oglDisplay.flippingBuffer = renew oglDisplay.flippingBuffer ColorAlpha [width * height];
2352 if(oglDisplay.flippingBuffer || !width || !height)
2358 void DisplayPosition(Display display, int x, int y)
2360 OGLDisplay oglDisplay = display.driverData;
2366 void SetPalette(Display display, ColorAlpha * palette, bool colorMatch)
2370 void RestorePalette(Display display)
2374 void StartUpdate(Display display)
2378 void EndUpdate(Display display)
2382 void Scroll(Display display, Box scroll, int x, int y, Extent dirty)
2386 void Update(Display display, Box updateBox)
2388 #if defined(__WIN32__) || defined(USEPBUFFER)
2389 OGLDisplay oglDisplay = display.driverData;
2391 //Logf("DisplayScreen\n");
2395 #if defined(__WIN32__) || defined(USEPBUFFER)
2396 if(display.alphaBlend)
2398 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2399 glPixelStorei(GL_PACK_ROW_LENGTH, oglDisplay.stride);
2400 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2401 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2402 glReadPixels(0,0,display.width,display.height,GL_BGRA_EXT,GL_UNSIGNED_BYTE, oglDisplay.picture);
2405 #if defined(__WIN32__)
2407 POINT point = { oglDisplay.x, oglDisplay.y};
2408 POINT srcPoint = { 0, 0 };
2409 BLENDFUNCTION blend = { 0 };
2411 size.cx = display.width;
2412 size.cy = display.height;
2413 blend.BlendOp = AC_SRC_OVER;
2414 blend.BlendFlags = 0;
2415 blend.SourceConstantAlpha = 255;
2416 blend.AlphaFormat = AC_SRC_ALPHA;
2419 // Process partial images. Mapping the buffer waits for
2420 // outstanding DMA transfers into the buffer to finish.
2421 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2422 oglDisplay.pboMemory1 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY);
2424 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2425 // oglDisplay.pboMemory2 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB,GL_READ_ONLY);
2428 memcpy(oglDisplay.picture, oglDisplay.pboMemory1, display.width * display.height * 4);
2429 //memcpy(oglDisplay.picture + display.width * display.height * 4 / 2, oglDisplay.pboMemory2, display.width * display.height * 4/ 2);
2432 UpdateLayeredWindow(display.window, hdc, &point, &size, oglDisplay.memDC, &srcPoint, 0, &blend, ULW_ALPHA);
2435 // Unmap the image buffers
2436 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2437 glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2439 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2440 // glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2442 // Bind two different buffer objects and start the glReadPixels
2443 // asynchronously. Each call will return directly after
2444 // starting the DMA transfer.
2445 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2446 glReadPixels(0, 0, display.width, display.height, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2448 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2449 // glReadPixels(0, display.height/2, display.width, display.height/2, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2453 #elif defined(__unix__) || defined(__APPLE__)
2454 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__)
2456 XTransform transform =
2459 { (int)(1.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(0 * (1 << 16)) },
2460 { (int)(0.0f), (int)(-1.0f * (1<<16)), (int)(0 * (1<<16)) },
2461 { (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)) }
2464 XRenderSetPictureTransform(xGlobalDisplay, oglDisplay.pixmapPicture, &transform);
2465 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.shapePicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2466 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.windowPicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2467 #if !defined(__APPLE__) && !defined(__OLDX__)
2468 XShapeCombineMask(xGlobalDisplay, (X11Window)display.window, ShapeInput, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2470 XShapeCombineMask(xGlobalDisplay, display.window, 2, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2472 XFlush(xGlobalDisplay);
2480 #if defined(__WIN32__)
2481 //wglSwapLayerBuffers(oglDisplay.hdc,WGL_SWAP_MAIN_PLANE);
2482 SwapBuffers(oglDisplay.hdc);
2483 #elif defined(__unix__) || defined(__APPLE__)
2484 #if defined(__ANDROID__)
2485 eglSwapBuffers(eglDisplay, eglSurface);
2486 #elif defined(__EMSCRIPTEN__)
2489 glXSwapBuffers(xGlobalDisplay, (GLXDrawable)display.window);
2493 //Logf("Out of DisplayScreen\n");
2496 void FreeBitmap(DisplaySystem displaySystem, Bitmap bitmap)
2498 if(bitmap.driverData)
2500 GLuint tex = (GLuint)(uintptr)bitmap.driverData;
2501 glDeleteTextures(1, &tex);
2502 bitmap.driverData = 0;
2504 bitmap.driver = ((subclass(DisplayDriver))class(LFBDisplayDriver));
2507 bool AllocateBitmap(DisplaySystem displaySystem, Bitmap bitmap, int width, int height, int stride, PixelFormat format, bool allocatePalette)
2509 OGLSystem oglSystem = displaySystem.driverData;
2510 bool result = false;
2512 GLuint glBitmap = 0;
2514 uint w = width, h = height;
2515 if(oglSystem.pow2textures)
2520 w = Min(w, oglSystem.maxTextureSize);
2521 h = Min(h, oglSystem.maxTextureSize);
2523 glGenTextures(1, &glBitmap);
2524 glBindTexture(GL_TEXTURE_2D, glBitmap);
2526 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2528 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2529 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2531 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2532 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2534 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2536 mipMap.Allocate(null, w, h, w, pixelFormatRGBA, false);
2538 // glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2539 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2543 bitmap.driverData = (void *)(uintptr)glBitmap;
2544 bitmap.driver = displaySystem.driver;
2552 bool MakeDDBitmap(DisplaySystem displaySystem, Bitmap bitmap, bool mipMaps)
2554 bool result = false;
2555 OGLSystem oglSystem = displaySystem.driverData;
2556 Bitmap convBitmap = bitmap;
2560 convBitmap.Copy(bitmap);
2563 // Pre process the bitmap... First make it 32 bit
2564 if(/*bitmap.pixelFormat == pixelFormatRGBA || */convBitmap.Convert(null, pixelFormat888, null))
2567 uint w = bitmap.width, h = bitmap.height;
2568 GLuint glBitmap = 0;
2569 if(oglSystem.pow2textures)
2574 w = Min(w, oglSystem.maxTextureSize);
2575 h = Min(h, oglSystem.maxTextureSize);
2579 while(w * 2 < h) w *= 2;
2580 while(h * 2 < w) h *= 2;
2583 // Switch ARGB to RGBA
2584 //if(bitmap.format != pixelFormatRGBA)
2586 for(c=0; c<bitmap.size; c++)
2588 // ((ColorRGBA *)bitmap.picture)[c] = ((ColorAlpha *)bitmap.picture)[c];
2590 ColorAlpha color = ((ColorAlpha *)convBitmap.picture)[c];
2591 ((ColorRGBA *)convBitmap.picture)[c] = ColorRGBA { color.color.r, color.color.g, color.color.b, color.a };
2594 // convBitmap.pixelFormat = pixelFormat888;
2597 glGenTextures(1, &glBitmap);
2600 //int error = glGetError();
2604 glBindTexture(GL_TEXTURE_2D, glBitmap);
2605 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2607 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2608 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mipMaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
2609 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2611 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
2612 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
2614 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2615 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2617 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2621 for(level = 0; result && (w > 1 || h > 1); level++, w >>= 1, h >>= 1)
2624 if(bitmap.width != w || bitmap.height != h)
2626 mipMap = Bitmap { };
2627 if(mipMap.Allocate(null, w, h, w, convBitmap.pixelFormat, false))
2629 Surface mipSurface = mipMap.GetSurface(0,0,null);
2630 mipSurface.Filter(convBitmap, 0,0,0,0, w, h, convBitmap.width, convBitmap.height);
2640 mipMap = convBitmap;
2647 // glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2648 glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2649 //printf("Calling glTexImage2D\n");
2650 //glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &width);
2651 //printf("width = %d (Should be %d, %d)\n", width, w, h);
2652 if((error = glGetError()))
2654 //Logf("OpenGL Bitmap MakeDD error: %d...\n", error);
2655 //printf("OpenGL Bitmap MakeDD error: %d...\n", error);
2659 if(mipMap != convBitmap)
2664 convBitmap.driver.FreeBitmap(convBitmap.displaySystem, convBitmap);
2665 bitmap.driverData = (void *)(uintptr)glBitmap;
2666 bitmap.driver = displaySystem.driver;
2671 FreeBitmap(displaySystem, bitmap);
2672 else if(oglSystem.loadingFont)
2674 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2675 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2676 oglSystem.loadingFont = false;
2682 void ReleaseSurface(Display display, Surface surface)
2684 glDisable(GL_SCISSOR_TEST);
2685 delete surface.driverData;
2686 surface.driverData = null;
2689 bool GetBitmapSurface(DisplaySystem displaySystem, Surface surface, Bitmap bitmap, int x, int y, Box clip)
2694 bool GetSurface(Display display, Surface surface, int x,int y, Box clip)
2696 bool result = false;
2697 OGLSurface oglSurface = surface.driverData = OGLSurface { };
2699 //Logf("GetSurface\n");
2703 if(displayWidth != display.width || displayHeight != display.height)
2705 displayWidth = display.width;
2706 displayHeight = display.height;
2708 glViewport(0,0,display.width,display.height);
2710 glOrtho(0,display.width,display.height,0,0.0,1.0);
2713 surface.offset.x = x;
2714 surface.offset.y = y;
2715 surface.unclippedBox = surface.box = clip;
2716 oglSurface.bitmapMult[0] = 1;
2717 oglSurface.bitmapMult[1] = 1;
2718 oglSurface.bitmapMult[2] = 1;
2719 oglSurface.bitmapMult[3] = 1;
2721 glEnable(GL_SCISSOR_TEST);
2724 (display.height) -(y+clip.bottom)-1,
2725 clip.right-clip.left+1,
2726 clip.bottom-clip.top+1);
2732 void Clip(Display display, Surface surface, Box clip)
2741 box.Clip(surface.unclippedBox);
2745 box = surface.box = surface.unclippedBox;
2746 box.left += surface.offset.x;
2747 box.top += surface.offset.y;
2748 box.right+= surface.offset.x;
2749 box.bottom += surface.offset.y;
2752 box.left,display.height - box.bottom - 1,
2753 box.right-box.left+1, box.bottom-box.top+1);
2756 bool GrabScreen(Display display, Bitmap bitmap, int x, int y, unsigned int w, unsigned int h)
2758 bool result = false;
2759 OGLDisplay oglDisplay = display.driverData;
2760 ColorAlpha * flippingBuffer = oglDisplay.flippingBuffer;
2762 if(oglDisplay.flippingBuffer)
2764 if(bitmap.pixelFormat != pixelFormat888 || bitmap.width < w || bitmap.height < h)
2767 bitmap.Allocate(null, w,h,w, pixelFormat888, false);
2773 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2774 glPixelStorei(GL_PACK_ROW_LENGTH, bitmap.stride);
2775 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2776 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2777 glReadPixels(x,display.height-h-y,w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, flippingBuffer);
2780 for(row = 0; row<h; row++)
2781 CopyBytesBy4(((ColorAlpha *)bitmap.picture) + row * w, ((ColorAlpha *)flippingBuffer) + (h-row-1) * w, w);
2788 void SetForeground(Display display, Surface surface, ColorAlpha color)
2790 OGLSurface oglSurface = surface.driverData;
2792 //Logf("SetForeground\n");
2794 oglSurface.foreground[0] = color.color.r/255.0f;
2795 oglSurface.foreground[1] = color.color.g/255.0f;
2796 oglSurface.foreground[2] = color.color.b/255.0f;
2797 //oglSurface.foreground[3] = 1.0f;
2798 oglSurface.foreground[3] = color.a/255.0f;
2800 //if(!oglSurface.foreground[3])printf("bug");
2803 void SetBackground(Display display, Surface surface, ColorAlpha color)
2805 OGLSurface oglSurface = surface.driverData;
2807 //Logf("SetBackground\n");
2809 oglSurface.background[0] = color.color.r/255.0f;
2810 oglSurface.background[1] = color.color.g/255.0f;
2811 oglSurface.background[2] = color.color.b/255.0f;
2812 //oglSurface.background[3] = 1.0;
2813 oglSurface.background[3] = color.a/255.0f;
2816 void SetBlitTint(Display display, Surface surface, ColorAlpha color)
2818 OGLSurface oglSurface = surface.driverData;
2820 oglSurface.bitmapMult[0] = color.color.r/255.0f;
2821 oglSurface.bitmapMult[1] = color.color.g/255.0f;
2822 oglSurface.bitmapMult[2] = color.color.b/255.0f;
2823 oglSurface.bitmapMult[3] = color.a/255.0f;
2826 ColorAlpha GetPixel(Display display, Surface surface,int x,int y)
2831 void PutPixel(Display display, Surface surface,int x,int y)
2833 OGLSurface oglSurface = surface.driverData;
2835 //Logf("PutPixel\n");
2837 glColor4fv(oglSurface.foreground);
2839 // glVertex2i(x+surface.offset.x, y+surface.offset.y);
2840 glVertex2f(x+surface.offset.x + 0.5f, y+surface.offset.y + 0.5f);
2845 void DrawLine(Display display, Surface surface, int _x1, int _y1, int _x2, int _y2)
2847 OGLSurface oglSurface = surface.driverData;
2848 float x1 = _x1, x2 = _x2, y1 = _y1, y2 = _y2;
2863 x1 += surface.offset.x;
2864 y1 += surface.offset.y;
2865 x2 += surface.offset.x;
2866 y2 += surface.offset.y;
2870 glColor4fv(oglSurface.foreground);
2872 #if defined(_GLES) || defined(EM_MODE)
2875 glTexCoord2f(0.5f, 0);
2876 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2877 glTexCoord2f(Max(x2-x1, y2-y1) + 0.5f, 0);
2878 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2887 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2888 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2894 void Rectangle(Display display, Surface surface,int x1,int y1,int x2,int y2)
2896 OGLSurface oglSurface = surface.driverData;
2897 x1 += surface.offset.x;
2898 y1 += surface.offset.y;
2899 x2 += surface.offset.x;
2900 y2 += surface.offset.y;
2902 //Logf("Rectangle\n");
2904 glColor4fv(oglSurface.foreground);
2905 #if defined(_GLES) || defined(EM_MODE)
2910 glTexCoord2f(0.5f, 0);
2911 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2912 glTexCoord2f(y2-y1 + 0.5f, 0);
2913 glVertex2f(x1 + 0.5f, y2 + 0.5f);
2915 glTexCoord2f(0.5f, 0);
2916 glVertex2f(x1 + 0.5f, y2 + 0.5f);
2917 glTexCoord2f(x2 - x1 + 0.5f, 0);
2918 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2920 glTexCoord2f(0.5f, 0);
2921 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2922 glTexCoord2f(y1 - y2 + 0.5f, 0);
2923 glVertex2f(x2 + 0.5f, y1 + 0.5f);
2925 glTexCoord2f(0.5f, 0);
2926 glVertex2f(x2 + 0.5f, y1 + 0.5f);
2927 glTexCoord2f(x1 - x2 + 0.5f, 0);
2928 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2933 glBegin(GL_LINE_LOOP);
2940 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2941 glVertex2f(x1 + 0.5f, y2 + 0.5f);
2942 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2943 glVertex2f(x2 + 0.5f, y1 + 0.5f);
2948 void Area(Display display, Surface surface,int x1,int y1,int x2,int y2)
2950 OGLSurface oglSurface = surface.driverData;
2953 glColor4fv(oglSurface.background);
2957 glVertex2f(x1+surface.offset.x, y1+surface.offset.y);
2958 glVertex2f(x1+surface.offset.x, y2+surface.offset.y+1);
2959 glVertex2f(x2+surface.offset.x+1, y2+surface.offset.y+1);
2960 glVertex2f(x2+surface.offset.x+1, y1+surface.offset.y);
2963 glRecti(x1+surface.offset.x, y1+surface.offset.y,
2964 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
2967 glRectf(x1+surface.offset.x, y1+surface.offset.y,
2968 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
2972 void Clear(Display display, Surface surface, ClearType type)
2974 OGLDisplay oglDisplay = display.driverData;
2975 OGLSurface oglSurface = surface.driverData;
2978 if(type != depthBuffer)
2979 glClearColor(oglSurface.background[0], oglSurface.background[1], oglSurface.background[2], oglSurface.background[3]);
2980 if(type != colorBuffer && !oglDisplay.depthWrite)
2982 glDepthMask((byte)bool::true);
2984 glClear(((type != depthBuffer) ? GL_COLOR_BUFFER_BIT : 0) |
2985 ((type != colorBuffer) ? GL_DEPTH_BUFFER_BIT : 0));
2986 if(type != colorBuffer && !oglDisplay.depthWrite)
2988 glDepthMask((byte)bool::false);
2992 bool ConvertBitmap(DisplaySystem displaySystem, Bitmap bitmap, PixelFormat format, ColorAlpha * palette)
2997 void Blit(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
2999 OGLSurface oglSurface = surface.driverData;
3001 #if !defined(__OLDX__)
3002 // WHY DO WE HAVE GL_ONE HERE ?
3003 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3004 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3007 if(!oglSurface.writingText)
3009 // glTranslatef(-0.375f, -0.375f, 0.0f);
3010 glEnable(GL_TEXTURE_2D);
3011 glColor4fv(oglSurface.bitmapMult);
3013 else if(oglSurface.xOffset)
3014 glTranslated(oglSurface.xOffset / 64.0/*-0.375*/, 0.0, 0.0);
3016 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3021 glTexCoord2f((float)sx/ bitmap.width, (float)(sy-h)/ bitmap.height);
3022 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3023 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy-h)/ bitmap.height);
3024 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3025 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3026 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
3027 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3028 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3033 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3034 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3035 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3036 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3037 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3038 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3039 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3040 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3043 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3044 glVertex2f((float)dx+surface.offset.x, (float)dy+surface.offset.y);
3045 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3046 glVertex2f((float)dx+w+surface.offset.x, (float)dy+surface.offset.y);
3047 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3048 glVertex2f((float)dx+w+surface.offset.x, (float)dy+h+surface.offset.y);
3049 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3050 glVertex2f((float)dx+surface.offset.x, (float)dy+h+surface.offset.y);
3054 if(!oglSurface.writingText)
3056 glDisable(GL_TEXTURE_2D);
3058 //glTranslate(0.375, 0.375, 0.0);
3060 else if(oglSurface.xOffset)
3061 glTranslated(-oglSurface.xOffset / 64.0/*+0.375*/, 0.0, 0.0);
3063 #if !defined(__OLDX__)
3064 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3065 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3069 void Stretch(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3071 OGLSurface oglSurface = surface.driverData;
3073 //glTranslate(-0.375, -0.375, 0.0);
3075 //Logf("Stretch\n");
3077 #if !defined(__OLDX__)
3078 /*if(glBlendFuncSeparate)
3079 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3082 glEnable(GL_TEXTURE_2D);
3083 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3085 glColor4fv(oglSurface.bitmapMult);
3091 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3092 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3094 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3095 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3097 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3098 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
3100 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3101 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3105 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3106 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3108 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3109 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3111 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3112 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3114 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3115 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3120 glDisable(GL_TEXTURE_2D);
3122 //glTranslate(0.375, 0.375, 0.0);
3123 #if !defined(__OLDX__)
3124 /*if(glBlendFuncSeparate)
3125 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3130 void Filter(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3132 Stretch(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3135 void StretchDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3137 #if !defined(EM_MODE)
3138 float s2dw,s2dh,d2sw,d2sh;
3139 //bool flipX = false, flipY = false;
3141 //Logf("StretchDI\n");
3143 if(Sgn(w) != Sgn(sw))
3149 if(Sgn(h) != Sgn(sh))
3161 //Clip against the edges of the source
3164 dx+=(int)((0-sx) * s2dw);
3165 w-=(int)((0-sx) * s2dw);
3171 dy+=(int)((0-sy) * s2dh);
3172 h-=(int)((0-sy) * s2dh);
3177 if(sx+sw>bitmap.width-1)
3179 w-=(int)((sx+sw-(bitmap.width-1)-1)*s2dw);
3180 sw-=sx+sw-(bitmap.width-1)-1;
3182 if(sy+sh>(bitmap.height-1))
3184 h-=(int)((sy+sh-(bitmap.height-1)-1)*s2dh);
3185 sh-=sy+sh-(bitmap.height-1)-1;
3187 //Clip against the edges of the surfaceination
3188 if(dx<surface.box.left)
3191 sx+=(int)((surface.box.left-dx)*d2sw);
3192 sw-=(int)((surface.box.left-dx)*d2sw);
3193 w-=surface.box.left-dx;
3194 dx=surface.box.left;
3196 if(dy<surface.box.top)
3198 sy+=(int)((surface.box.top-dy)*d2sh);
3199 sh-=(int)((surface.box.top-dy)*d2sh);
3200 h-=surface.box.top-dy;
3203 if(dx+w>surface.box.right)
3205 //if(flip) sx+=(int)((dx+w-surface.box.right-1)*d2sw);
3206 sw-=(int)((dx+w-surface.box.right-1)*d2sw);
3207 w-=dx+w-surface.box.right-1;
3209 if(dy+h>surface.box.bottom)
3211 sh-=(int)((dy+h-surface.box.bottom-1)*d2sh);
3212 h-=dy+h-surface.box.bottom-1;
3214 if((w<=0)||(h<=0)||(sw<=0)||(sh<=0)) return;
3216 dx += surface.offset.x;
3217 dy += surface.offset.y;
3219 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3221 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3222 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3223 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3224 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3225 glRasterPos2d(dx,dy);
3226 //glPixelZoom(flipX ? -s2dw : s2dw, flipY ? s2dh : -s2dh);
3227 glPixelZoom(s2dw, -s2dh);
3228 glDrawPixels(sw,sh,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3229 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3230 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3231 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3232 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3237 void BlitDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3239 #if !defined(EM_MODE)
3242 //Clip against the edges of the source
3255 if(sx+w>bitmap.width-1)
3256 w-=sx+w-(bitmap.width-1)-1;
3257 if(sy+h>bitmap.height-1)
3258 h-=sy+h-(bitmap.height-1)-1;
3259 //Clip against the edges of the surfaceination
3260 if(dx<surface.box.left)
3263 sx+=surface.box.left-dx;
3264 w-=surface.box.left-dx;
3265 dx=surface.box.left;
3267 if(dy<surface.box.top)
3269 sy+=surface.box.top-dy;
3270 h-=surface.box.top-dy;
3273 if(dx+w>surface.box.right)
3275 //if(flip) sx+=dx+w-surface.box.right-1;
3276 w-=dx+w-surface.box.right-1;
3278 if(dy+h>surface.box.bottom)
3279 h-=dy+h-surface.box.bottom-1;
3283 dx += surface.offset.x;
3284 dy += surface.offset.y;
3286 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3288 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3289 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3290 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3291 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3292 glRasterPos2d(dx,dy);
3294 glDrawPixels(w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3295 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3296 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3297 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3298 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3303 void FilterDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3305 StretchDI(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3308 void UnloadFont(DisplaySystem displaySystem, Font font)
3310 ((subclass(DisplayDriver))class(LFBDisplayDriver)).UnloadFont(displaySystem, font);
3313 Font LoadFont(DisplaySystem displaySystem, const char * faceName, float size, FontFlags flags)
3316 OGLSystem oglSystem = displaySystem.driverData;
3317 oglSystem.loadingFont = true;
3318 font = ((subclass(DisplayDriver))class(LFBDisplayDriver)).LoadFont(displaySystem, faceName, size, flags);
3322 void FontExtent(DisplaySystem displaySystem, Font font, const char * text, int len, int * width, int * height)
3324 ((subclass(DisplayDriver))class(LFBDisplayDriver)).FontExtent(displaySystem, font, text, len, width, height);
3327 void WriteText(Display display, Surface surface, int x, int y, const char * text, int len)
3329 OGLSurface oglSurface = surface.driverData;
3330 OGLSystem oglSystem = display.displaySystem.driverData;
3331 oglSystem.loadingFont = true;
3333 //glTranslated(-0.375, -0.375, 0.0);
3337 if(surface.textOpacity)
3340 FontExtent(display.displaySystem, surface.font, text, len, &w, &h);
3341 display.displaySystem.driver.Area(display, surface,x,y,x+w-1,y+h-1);
3344 oglSurface.writingText = true;
3346 glEnable(GL_TEXTURE_2D);
3348 if(surface.outline.size)
3350 ColorAlpha outlineColor = surface.outline.color;
3351 glColor4ub(outlineColor.color.r, outlineColor.color.g, outlineColor.color.b, outlineColor.a);
3352 //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3353 //glEnable(GL_BLEND);
3355 oglSurface.writingOutline = true;
3356 ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x, y, text, len);
3357 oglSurface.writingOutline = false;
3359 glColor4fv(oglSurface.foreground);
3361 ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x, y, text, len);
3362 oglSurface.writingText = false;
3363 oglSystem.loadingFont = false;
3365 glDisable(GL_TEXTURE_2D);
3367 //glTranslated(0.375, 0.375, 0.0);
3370 void TextFont(Display display, Surface surface, Font font)
3372 ((subclass(DisplayDriver))class(LFBDisplayDriver)).TextFont(display, surface, font);
3375 void TextOpacity(Display display, Surface surface, bool opaque)
3377 OGLSurface oglSurface = surface.driverData;
3378 oglSurface.opaqueText = opaque;
3381 void TextExtent(Display display, Surface surface, const char * text, int len, int * width, int * height)
3383 OGLSurface oglSurface = surface.driverData;
3384 OGLSystem oglSystem = display.displaySystem.driverData;
3385 oglSystem.loadingFont = true;
3386 FontExtent(display.displaySystem, oglSurface.font, text, len, width, height);
3387 oglSystem.loadingFont = false;
3390 void DrawingChar(Display display, Surface surface, char character)
3395 void LineStipple(Display display, Surface surface, uint32 stipple)
3397 //Logf("Stipple\n");
3401 #if defined(_GLES) || defined(EM_MODE)
3402 stippleEnabled = true;
3403 glesLineStipple(1, (uint16)stipple);
3405 glLineStipple(1, (uint16)stipple);
3406 glEnable(GL_LINE_STIPPLE);
3411 #if defined(_GLES) || defined(EM_MODE)
3412 stippleEnabled = false;
3413 glMatrixMode(GL_TEXTURE);
3415 glMatrixMode(GL_PROJECTION);
3416 glDisable(GL_TEXTURE_2D);
3418 glDisable(GL_LINE_STIPPLE);
3422 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
3423 void SetRenderState(Display display, RenderState state, uint value)
3425 OGLDisplay oglDisplay = display.driverData;
3426 //Logf("RenderState\n");
3432 glEnable(GL_MULTISAMPLE_ARB);
3434 glDisable(GL_MULTISAMPLE_ARB);
3438 glPolygonMode(GL_FRONT_AND_BACK, ((FillModeValue)value == solid) ? GL_FILL : GL_LINE);
3442 if(value) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
3445 if(value) glDepthMask((byte)bool::true); else glDepthMask((byte)bool::false);
3446 oglDisplay.depthWrite = (bool)value;
3450 float color[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3451 glFogfv(GL_FOG_COLOR, (float *)&color);
3455 glFogf(GL_FOG_DENSITY, (float)(RenderStateFloat { ui = value }.f * nearPlane));
3458 if(value) glEnable(GL_BLEND); else glDisable(GL_BLEND);
3462 #if !defined(EM_MODE)
3463 float ambient[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3464 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
3470 if(value) glColorMask(1,1,1,1); else glColorMask(1,1,1,0);
3475 #if defined(__WIN32__)
3476 wglSwapIntervalEXT(value ? 1 : 0);
3483 void SetLight(Display display, int id, Light light)
3485 #if !defined(EM_MODE)
3486 //Logf("SetLight\n");
3490 Object lightObject = light.lightObject;
3491 float position[4] = { 0, 0, 0, 0 };
3492 float color[4] = { 0, 0, 0, 1 };
3494 glEnable(GL_LIGHT0 + id);
3496 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, (float *)&light.diffuse);
3497 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, (float *)&light.ambient);
3498 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,(float *)&light.specular);
3501 if(!light.multiplier) light.multiplier = 1.0f;
3503 color[0] = light.diffuse.r * light.multiplier;
3504 color[1] = light.diffuse.g * light.multiplier;
3505 color[2] = light.diffuse.b * light.multiplier;
3506 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, color);
3508 color[0] = light.ambient.r * light.multiplier;
3509 color[1] = light.ambient.g * light.multiplier;
3510 color[2] = light.ambient.b * light.multiplier;
3511 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, color);
3512 color[0] = light.specular.r * light.multiplier;
3513 color[1] = light.specular.g * light.multiplier;
3514 color[2] = light.specular.b * light.multiplier;
3515 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,color);
3519 Vector3D positionVector;
3520 if(light.flags.spot)
3522 if(lightObject.flags.root || !lightObject.parent)
3524 positionVector = lightObject.transform.position;
3525 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3529 positionVector.MultMatrix(lightObject.transform.position, lightObject.parent.matrix);
3530 if(display.display3D.camera)
3531 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3537 if(!light.direction.x && !light.direction.y && !light.direction.z)
3539 Vector3Df vector { 0,0,-1 };
3541 mat.RotationQuaternion(light.orientation);
3542 positionVector.MultMatrixf(vector, mat);
3546 positionVector = light.direction;
3551 position[0] = (float)positionVector.x;
3552 position[1] = (float)positionVector.y;
3553 position[2] = (float)positionVector.z;
3555 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3558 // Display Light Position
3559 glDisable(GL_LIGHTING);
3560 glDisable(GL_DEPTH_TEST);
3564 glVertex3fv(position);
3566 glEnable(GL_DEPTH_TEST);
3567 glEnable(GL_LIGHTING);
3571 if(lightObject.flags.root || !lightObject.parent)
3573 positionVector = light.target.transform.position;
3574 positionVector.Subtract(positionVector, display.camera.cPosition);
3578 positionVector.MultMatrix(light.target.transform.position,
3579 lightObject.light.target.parent.matrix);
3580 positionVector.Subtract(positionVector, display.camera.cPosition);
3583 position[0] = positionVector.x;
3584 position[1] = positionVector.y;
3585 position[2] = positionVector.z;
3587 glDisable(GL_LIGHTING);
3588 glDisable(GL_DEPTH_TEST);
3592 glVertex3fv(position);
3594 glEnable(GL_DEPTH_TEST);
3595 glEnable(GL_LIGHTING);
3598 if(light.flags.attenuation)
3600 glLightf(GL_LIGHT0 + id, GL_CONSTANT_ATTENUATION, light.Kc);
3601 glLightf(GL_LIGHT0 + id, GL_LINEAR_ATTENUATION, light.Kl);
3602 glLightf(GL_LIGHT0 + id, GL_QUADRATIC_ATTENUATION, light.Kq);
3605 if(light.flags.spot)
3608 #define MAXLIGHT 0.9
3609 float direction[4] = { (float)light.direction.x, (float)light.direction.y, (float)light.direction.z, 1 };
3610 // Figure out exponent out of the hot spot
3611 exponent = (float)(log(MAXLIGHT) / log(cos((light.hotSpot / 2))));
3613 glLightfv(GL_LIGHT0 + id, GL_SPOT_DIRECTION, direction);
3614 glLightf(GL_LIGHT0 + id, GL_SPOT_CUTOFF, (float)(light.fallOff / 2));
3615 glLightf(GL_LIGHT0 + id, GL_SPOT_EXPONENT, exponent);
3621 Vector3Df vector { 0,0,-1 };
3622 Vector3Df direction;
3625 mat.RotationQuaternion(light.orientation);
3626 direction.MultMatrix(vector, mat);
3628 position[0] = direction.x;
3629 position[1] = direction.y;
3630 position[2] = direction.z;
3632 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3636 glDisable(GL_LIGHT0 + id);
3640 void SetCamera(Display display, Surface surface, Camera camera)
3642 OGLDisplay oglDisplay = display.driverData;
3643 //Logf("SetCamera\n");
3647 int left = surface.box.left + surface.offset.x;
3648 int top = surface.box.top + surface.offset.y;
3649 int right = surface.box.right + surface.offset.x;
3650 int bottom = surface.box.bottom + surface.offset.y;
3651 float origX = surface.offset.x + camera.origin.x;
3652 float origY = surface.offset.y + camera.origin.y;
3654 int y = display.height - bottom - 1;
3655 int w = right - left + 1;
3656 int h = bottom - top + 1;
3659 glViewport(x, y, w, h);
3661 // *** Projection Matrix ***
3662 if(!display.display3D.camera)
3664 glMatrixMode(GL_PROJECTION);
3668 glMatrixMode(GL_PROJECTION);
3669 if(display.display3D.collectingHits)
3671 float pickX = display.display3D.pickX + surface.offset.x;
3672 float pickY = display.height - (display.display3D.pickY + surface.offset.y) - 1;
3676 w / display.display3D.pickWidth, 0, 0, 0,
3677 0, h / display.display3D.pickHeight, 0, 0,
3679 (w + 2.0f * (x - pickX)) / display.display3D.pickWidth,
3680 (h + 2.0f * (y - pickY)) / display.display3D.pickHeight, 0, 1
3683 glLoadMatrixd(pickMatrix.array);
3688 (left - origX) * camera.zMin / camera.focalX,
3689 (right - origX) * camera.zMin / camera.focalX,
3690 (bottom - origY) * camera.zMin / camera.focalY,
3691 (top - origY) * camera.zMin / camera.focalY,
3692 camera.zMin, camera.zMax);
3694 glDisable(GL_BLEND);
3696 // *** Z Inverted Identity Matrix ***
3697 glMatrixMode(GL_MODELVIEW);
3698 if(!display.display3D.camera)
3703 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
3705 // *** View Matrix ***
3706 glMultMatrixd(camera.viewMatrix.array);
3711 glEnable(GL_DEPTH_TEST);
3712 //#if !defined(EM_MODE)
3713 glEnable(GL_LIGHTING);
3714 glShadeModel(GL_SMOOTH);
3716 glDepthMask((byte)bool::true);
3717 oglDisplay.depthWrite = true;
3719 glEnable(GL_MULTISAMPLE_ARB);
3721 else if(display.display3D.camera)
3723 oglDisplay.depthWrite = false;
3724 glViewport(0,0,display.width,display.height);
3726 glDisable(GL_CULL_FACE);
3727 glDisable(GL_DEPTH_TEST);
3728 glDisable(GL_LIGHTING);
3730 glDisable(GL_TEXTURE_2D);
3731 //#if !defined(EM_MODE)
3732 glShadeModel(GL_FLAT);
3735 glDisable(GL_MULTISAMPLE_ARB);
3737 // *** Restore 2D MODELVIEW Matrix ***
3740 // *** Restore 2D PROJECTION Matrix ***
3741 glMatrixMode(GL_PROJECTION);
3745 GLBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
3748 void ApplyMaterial(Display display, Material material, Mesh mesh)
3750 //Logf("ApplyMaterial\n");
3753 if(material.flags.doubleSided)
3755 #if !defined(EM_MODE)
3756 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, !material.flags.singleSideLight);
3758 glDisable(GL_CULL_FACE);
3762 #if !defined(EM_MODE)
3763 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, bool::false);
3765 glEnable(GL_CULL_FACE);
3769 if(material.flags.noFog)
3775 if(material.baseMap && (mesh.texCoords || mesh.flags.texCoords1))
3777 Bitmap map = material.baseMap;
3778 glEnable(GL_TEXTURE_2D);
3779 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)map.driverData);
3781 glMatrixMode(GL_TEXTURE);
3783 if(material.uScale && material.vScale)
3784 glScalef(material.uScale, material.vScale, 1);
3785 glMatrixMode(GL_MODELVIEW);
3787 if(material.flags.tile)
3789 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
3790 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
3794 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
3795 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
3799 glDisable(GL_TEXTURE_2D);
3802 glColor4f(material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity);
3804 if(mesh.flags.colors)
3806 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
3807 glEnable(GL_COLOR_MATERIAL);
3811 glDisable(GL_COLOR_MATERIAL);
3813 float color[4] = { material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity };
3814 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
3817 float color[4] = { material.ambient.r, material.ambient.g, material.ambient.b, 0 };
3818 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
3822 float color[4] = { material.specular.r, material.specular.g, material.specular.b, 0 };
3823 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, color);
3826 float color[4] = { material.emissive.r, material.emissive.g, material.emissive.b, 0 };
3827 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, color);
3830 glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &material.power);
3834 void FreeMesh(DisplaySystem displaySystem, Mesh mesh)
3836 OGLMesh oglMesh = mesh.data;
3839 if(!mesh.flags.vertices)
3841 if(oglMesh.vertices)
3843 GLDeleteBuffers(1, &oglMesh.vertices);
3844 oglMesh.vertices = 0;
3846 delete mesh.vertices;
3848 if(!mesh.flags.normals)
3852 GLDeleteBuffers(1, &oglMesh.normals);
3853 oglMesh.normals = 0;
3855 delete mesh.normals;
3857 if(!mesh.flags.texCoords1)
3859 if(oglMesh.texCoords)
3861 GLDeleteBuffers(1, &oglMesh.texCoords);
3862 oglMesh.texCoords = 0;
3864 delete mesh.texCoords;
3866 if(!mesh.flags.texCoords2)
3868 if(oglMesh.texCoords2)
3870 GLDeleteBuffers(1, &oglMesh.texCoords2);
3871 oglMesh.texCoords2 = 0;
3874 delete mesh.texCoords2;
3877 if(!mesh.flags.colors)
3881 GLDeleteBuffers(1, &oglMesh.colors);
3893 bool AllocateMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags, int nVertices)
3895 bool result = false;
3898 mesh.data = OGLMesh { };
3901 if(mesh.nVertices == nVertices)
3903 // Same number of vertices, adding features (Leaves the other features pointers alone)
3904 if(mesh.flags != flags)
3906 if(!mesh.flags.vertices && flags.vertices)
3908 if(flags.doubleVertices)
3910 mesh.vertices = (Vector3Df *)new Vector3D[nVertices];
3913 mesh.vertices = new Vector3Df[nVertices];
3915 if(!mesh.flags.normals && flags.normals)
3917 if(flags.doubleNormals)
3919 mesh.normals = (Vector3Df *)new Vector3D[nVertices];
3922 mesh.normals = new Vector3Df[nVertices];
3924 if(!mesh.flags.texCoords1 && flags.texCoords1)
3926 mesh.texCoords = new Pointf[nVertices];
3928 if(!mesh.flags.colors && flags.colors)
3930 mesh.colors = new ColorRGBAf[nVertices];
3936 // New number of vertices, reallocate all current and new features
3937 flags |= mesh.flags;
3940 if(flags.doubleVertices)
3942 mesh.vertices = (Vector3Df *)renew mesh.vertices Vector3D[nVertices];
3945 mesh.vertices = renew mesh.vertices Vector3Df[nVertices];
3949 if(flags.doubleNormals)
3951 mesh.normals = (Vector3Df *)renew mesh.normals Vector3D[nVertices];
3954 mesh.normals = renew mesh.normals Vector3Df[nVertices];
3956 if(flags.texCoords1)
3958 mesh.texCoords = renew mesh.texCoords Pointf[nVertices];
3962 mesh.colors = renew mesh.colors ColorRGBAf[nVertices];
3970 void UnlockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
3972 OGLMesh oglMesh = mesh.data;
3973 if(!flags) flags = mesh.flags;
3979 if(!oglMesh.vertices)
3980 GLGenBuffers(1, &oglMesh.vertices);
3981 GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.vertices);
3982 GLBufferData( mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT, GL_ARRAY_BUFFER_ARB, mesh.nVertices * (mesh.flags.doubleVertices ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.vertices, GL_STATIC_DRAW_ARB );
3987 if(!oglMesh.normals)
3988 GLGenBuffers(1, &oglMesh.normals);
3989 GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.normals);
3990 GLBufferData( mesh.flags.doubleNormals ? GL_DOUBLE : GL_FLOAT, GL_ARRAY_BUFFER_ARB, mesh.nVertices * (mesh.flags.doubleNormals ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.normals, GL_STATIC_DRAW_ARB );
3993 if(flags.texCoords1)
3995 if(!oglMesh.texCoords)
3996 GLGenBuffers(1, &oglMesh.texCoords);
3997 GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.texCoords);
3998 GLBufferData( GL_FLOAT, GL_ARRAY_BUFFER_ARB, mesh.nVertices * sizeof(Pointf), mesh.texCoords, GL_STATIC_DRAW_ARB );
4004 GLGenBuffers( 1, &oglMesh.colors);
4005 GLBindBuffer( GL_ARRAY_BUFFER_ARB, oglMesh.colors);
4006 GLBufferData( GL_FLOAT, GL_ARRAY_BUFFER_ARB, mesh.nVertices * sizeof(ColorRGBAf), mesh.colors, GL_STATIC_DRAW_ARB );
4009 GLBindBuffer( GL_ARRAY_BUFFER_ARB, 0);
4013 bool LockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
4020 void FreeIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4024 if(oglIndices.buffer)
4025 GLDeleteBuffers(1, &oglIndices.buffer);
4026 delete oglIndices.indices;
4031 void * AllocateIndices(DisplaySystem displaySystem, int nIndices, bool indices32bit)
4033 OGLIndices oglIndices = OGLIndices { };
4036 oglIndices.indices = (void *)(indices32bit ? new uint32[nIndices] : new uint16[nIndices]);
4037 GLGenBuffers( 1, &oglIndices.buffer);
4038 oglIndices.nIndices = nIndices;
4043 void UnlockIndices(DisplaySystem displaySystem, OGLIndices oglIndices, bool indices32bit, int nIndices)
4047 GLBindBuffer( GL_ELEMENT_ARRAY_BUFFER_ARB, oglIndices.buffer);
4048 GLBufferData( indices32bit ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT, GL_ELEMENT_ARRAY_BUFFER_ARB, nIndices * (indices32bit ? sizeof(uint32) : sizeof(uint16)),
4049 oglIndices.indices, GL_STATIC_DRAW_ARB);
4050 GLBindBuffer( GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
4054 uint16 * LockIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4057 return oglIndices.indices;
4060 void SelectMesh(Display display, Mesh mesh)
4062 //Logf("SelectMesh\n");
4064 #if !defined( __ANDROID__) && !defined(__APPLE__) && !defined(__EMSCRIPTEN__)
4066 #if defined(__WIN32__)
4067 if(glUnlockArraysEXT)
4069 if(!vboAvailable && display.display3D.mesh)
4070 glUnlockArraysEXT();
4075 OGLMesh oglMesh = mesh.data;
4077 // *** Vertex Stream ***
4078 glEnableClientState(GL_VERTEX_ARRAY);
4079 if(!display.display3D.collectingHits && oglMesh)
4081 GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.vertices );
4082 if(mesh.flags.doubleVertices)
4083 glVertexPointerd(3, 0, oglMesh.vertices ? null : (double *)mesh.vertices, mesh.nVertices);
4085 glVertexPointer(3, GL_FLOAT, 0, oglMesh.vertices ? null : mesh.vertices);
4087 // *** Normals Stream ***
4088 if(mesh.normals || mesh.flags.normals)
4090 glEnableClientState(GL_NORMAL_ARRAY);
4091 GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.normals);
4092 glNormalPointer(/*mesh.flags.doubleNormals ? GL_DOUBLE : */GL_FLOAT, 0, oglMesh.normals ? null : mesh.normals);
4095 glDisableClientState(GL_NORMAL_ARRAY);
4097 // *** Texture Coordinates Stream ***
4098 if(mesh.texCoords || mesh.flags.texCoords1)
4100 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4101 GLBindBuffer( GL_ARRAY_BUFFER_ARB, oglMesh.texCoords);
4102 glTexCoordPointer(2, GL_FLOAT, 0, oglMesh.texCoords ? null : mesh.texCoords);
4105 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4107 // *** Color Stream ***
4108 if(mesh.colors || mesh.flags.colors)
4110 glEnableClientState(GL_COLOR_ARRAY);
4111 GLBindBuffer( GL_ARRAY_BUFFER_ARB, oglMesh.colors);
4112 glColorPointer(4, GL_FLOAT, 0, oglMesh.colors ? null : mesh.colors);
4115 glDisableClientState(GL_COLOR_ARRAY);
4119 GLBindBuffer( GL_ARRAY_BUFFER_ARB, 0);
4120 if(mesh.flags.doubleVertices)
4121 glVertexPointerd(3, 0, (double *)mesh.vertices, mesh.nVertices);
4123 glVertexPointer(3, GL_FLOAT, 0, mesh.vertices);
4124 if((mesh.normals || mesh.flags.normals) && !display.display3D.collectingHits)
4126 glEnableClientState(GL_NORMAL_ARRAY);
4127 glNormalPointer(/*mesh.flags.doubleNormals ? GL_DOUBLE : */GL_FLOAT, 0, mesh.normals);
4130 glDisableClientState(GL_NORMAL_ARRAY);
4131 if((mesh.texCoords || mesh.flags.texCoords1) && !display.display3D.collectingHits)
4133 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4134 glTexCoordPointer(2, GL_FLOAT, 0, mesh.texCoords);
4137 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4138 if((mesh.colors || mesh.flags.colors) && !display.display3D.collectingHits)
4140 glEnableClientState(GL_COLOR_ARRAY);
4141 glColorPointer(4, GL_FLOAT, 0, mesh.colors);
4144 glDisableClientState(GL_COLOR_ARRAY);
4147 #if !defined(__ANDROID__) && !defined(__APPLE__) && !defined(__EMSCRIPTEN__)
4149 #if defined(__WIN32__)
4153 glLockArraysEXT(0, mesh.nVertices);
4158 GLBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
4161 void DrawPrimitives(Display display, PrimitiveSingle * primitive, Mesh mesh)
4163 //Logf("DrawPrimitives\n");
4165 if(primitive->type.vertexRange)
4166 glDrawArrays(primitiveTypes[primitive->type.primitiveType], primitive->first, primitive->nVertices);
4169 // *** Hoping the data won't be uploaded at all (Won't really work if another group of the mesh is using the mesh ) ***
4170 // HACK TO SPEED THINGS UP...
4172 /*GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
4173 if(primitive->nIndices < (mesh.nVertices >> 2) && !primitive->type.indices32bit)
4176 glBegin(primitiveTypes[primitive->type.primitiveType]);
4179 OGLIndices oglIndices = primitive->data;
4180 MeshFeatures flags = mesh.flags;
4181 for(c = 0; c<primitive->nIndices; c++)
4183 uint16 index = ((uint16 *) oglIndices.indices)[c];
4184 if(flags.normals) glNormal3fv((float *)&mesh.normals[index]);
4185 if(flags.texCoords1) glTexCoord2fv((float *)&mesh.texCoords[index]);
4186 if(flags.colors) glColor4fv((float *)&mesh.colors[index]);
4187 glVertex3fv((float *)&mesh.vertices[index]);
4195 OGLIndices oglIndices = primitive->data;
4197 if(!display.display3D.collectingHits && vboAvailable && oglIndices)
4199 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, oglIndices.buffer);
4200 if(primitive->type.indices32bit)
4201 glDrawElementsi(primitiveTypes[primitive->type.primitiveType], primitive->nIndices, 0);
4203 glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices, GL_UNSIGNED_SHORT, 0);
4204 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
4208 if(primitive->type.indices32bit)
4209 glDrawElementsi(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
4210 oglIndices ? oglIndices.indices : primitive->indices);
4212 glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
4213 GL_UNSIGNED_SHORT, oglIndices ? oglIndices.indices : primitive->indices);
4219 void PushMatrix(Display display)
4224 void PopMatrix(Display display, bool setMatrix)
4229 void SetTransform(Display display, Matrix transMatrix, bool viewSpace, bool useCamera)
4231 Matrix matrix = transMatrix;
4232 Camera camera = useCamera ? display.display3D.camera : null;
4237 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
4242 matrix.m[3][0] - camera.cPosition.x,
4243 matrix.m[3][1] - camera.cPosition.y,
4244 matrix.m[3][2] - camera.cPosition.z);
4256 glMultMatrixd(matrix.array);
4261 public void UseSingleGLContext(bool useSingle)
4263 useSingleGLContext = useSingle;
4266 default dllexport void *
4267 #if defined(__WIN32__)
4268 __attribute__((stdcall))
4270 IS_GLGetContext(DisplaySystem displaySystem)
4274 #if defined(__WIN32__)
4275 OGLSystem system = displaySystem.driverData;
4277 #elif defined(__ANDROID__)
4279 #elif defined(__EMSCRIPTEN__)
4281 OGLSystem system = displaySystem.driverData;
4282 return system.glContext;