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(__ODROID__)
23 #define property _property
27 #define Window X11Window
28 #define Cursor X11Cursor
30 #define Display X11Display
32 #define KeyCode X11KeyCode
33 #define Picture X11Picture
37 #include <X11/Xutil.h>
39 #include <X11/extensions/XShm.h>
42 #include <X11/extensions/Xrender.h>
43 #include <X11/extensions/shape.h>
63 #if defined(__APPLE__)
64 #include <OpenGl/gl.h>
67 #if defined(__WIN32__) || defined(__unix__) || defined(__APPLE__)
69 #if defined(__WIN32__)
70 #define WIN32_LEAN_AND_MEAN
72 #define _WIN32_WINNT 0x0502
78 #if defined(__ANDROID__) || defined(__ODROID__)
81 #define property _property
84 #define Window X11Window
85 #define Cursor X11Cursor
87 #define Display X11Display
89 #define KeyCode X11KeyCode
90 #define Picture X11Picture
112 #include <GL/glext.h>
116 #if defined(__ODROID__) && !defined(_GLES)
124 #if defined(__unix__) || defined(__APPLE__)
126 #if !defined(__ANDROID__) && !defined(__ODROID__)
132 static double nearPlane = 1;
134 public double glesGetNearPlane()
139 public void glesSetNearPlane(double value)
144 #define glLoadMatrix glLoadMatrixd
145 #define glMultMatrix glMultMatrixd
146 #define glGetMatrix glGetDoublev
147 #define glTranslate glTranslated
148 #define glScale glScaled
151 #define glVertex3v glVertex3dv
152 #define glNormal3v glNormal3dv
156 //#ifdef VERTEX_FORMAT_DOUBLE
158 #define glLoadMatrix glLoadMatrixd
159 #define glMultMatrix glMultMatrixd
160 #define glGetMatrix glGetDoublev
161 #define glVertex3v glVertex3dv
162 #define glNormal3v glNormal3dv
163 #define glTranslate glTranslated
164 #define glScale glScaled
165 //#define GL_VERTEX_FORMAT GL_DOUBLE
169 #define glLoadMatrix glLoadMatrixf
170 #define glMultMatrix glMultMatrixf
171 #define glGetMatrix glGetFloatv
172 #define glVertex3v glVertex3fv
173 #define glNormal3v glNormal3fv
174 #define glTranslate glTranslatef
175 #define glScale glScalef
176 //#define GL_VERTEX_FORMAT GL_FLOAT
181 #define GL_ARRAY_BUFFER_ARB 0x8892
182 #define GL_ELEMENT_ARRAY_BUFFER_ARB 0x8893
183 #define GL_STATIC_DRAW_ARB 0x88E4
184 #define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8
185 #define GL_SEPARATE_SPECULAR_COLOR 0x81FA
187 #define GL_MULTISAMPLE_ARB 0x809D
189 #if defined(__WIN32__)
191 #define WGL_SAMPLE_BUFFERS_ARB 0x2041
192 #define WGL_SAMPLES_ARB 0x2042
194 #define WGL_WGLEXT_VERSION 1
195 #define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001
196 #define WGL_BACK_COLOR_BUFFER_BIT_ARB 0x00000002
197 #define WGL_DEPTH_BUFFER_BIT_ARB 0x00000004
198 #define WGL_STENCIL_BUFFER_BIT_ARB 0x00000008
199 #define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000
200 #define WGL_DRAW_TO_WINDOW_ARB 0x2001
201 #define WGL_DRAW_TO_BITMAP_ARB 0x2002
202 #define WGL_ACCELERATION_ARB 0x2003
203 #define WGL_NEED_PALETTE_ARB 0x2004
204 #define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005
205 #define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006
206 #define WGL_SWAP_METHOD_ARB 0x2007
207 #define WGL_NUMBER_OVERLAYS_ARB 0x2008
208 #define WGL_NUMBER_UNDERLAYS_ARB 0x2009
209 #define WGL_TRANSPARENT_ARB 0x200A
210 #define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037
211 #define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038
212 #define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039
213 #define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A
214 #define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B
215 #define WGL_SHARE_DEPTH_ARB 0x200C
216 #define WGL_SHARE_STENCIL_ARB 0x200D
217 #define WGL_SHARE_ACCUM_ARB 0x200E
218 #define WGL_SUPPORT_GDI_ARB 0x200F
219 #define WGL_SUPPORT_OPENGL_ARB 0x2010
220 #define WGL_DOUBLE_BUFFER_ARB 0x2011
221 #define WGL_STEREO_ARB 0x2012
222 #define WGL_PIXEL_TYPE_ARB 0x2013
223 #define WGL_COLOR_BITS_ARB 0x2014
224 #define WGL_RED_BITS_ARB 0x2015
225 #define WGL_RED_SHIFT_ARB 0x2016
226 #define WGL_GREEN_BITS_ARB 0x2017
227 #define WGL_GREEN_SHIFT_ARB 0x2018
228 #define WGL_BLUE_BITS_ARB 0x2019
229 #define WGL_BLUE_SHIFT_ARB 0x201A
230 #define WGL_ALPHA_BITS_ARB 0x201B
231 #define WGL_ALPHA_SHIFT_ARB 0x201C
232 #define WGL_ACCUM_BITS_ARB 0x201D
233 #define WGL_ACCUM_RED_BITS_ARB 0x201E
234 #define WGL_ACCUM_GREEN_BITS_ARB 0x201F
235 #define WGL_ACCUM_BLUE_BITS_ARB 0x2020
236 #define WGL_ACCUM_ALPHA_BITS_ARB 0x2021
237 #define WGL_DEPTH_BITS_ARB 0x2022
238 #define WGL_STENCIL_BITS_ARB 0x2023
239 #define WGL_AUX_BUFFERS_ARB 0x2024
240 #define WGL_NO_ACCELERATION_ARB 0x2025
241 #define WGL_GENERIC_ACCELERATION_ARB 0x2026
242 #define WGL_FULL_ACCELERATION_ARB 0x2027
243 #define WGL_SWAP_EXCHANGE_ARB 0x2028
244 #define WGL_SWAP_COPY_ARB 0x2029
245 #define WGL_SWAP_UNDEFINED_ARB 0x202A
246 #define WGL_TYPE_RGBA_ARB 0x202B
247 #define WGL_TYPE_COLORINDEX_ARB 0x202C
248 #define ERROR_INVALID_PIXEL_TYPE_ARB 0x2043
249 #define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054
250 #define WGL_DRAW_TO_PBUFFER_ARB 0x202D
251 #define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E
252 #define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F
253 #define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030
254 #define WGL_PBUFFER_LARGEST_ARB 0x2033
255 #define WGL_PBUFFER_WIDTH_ARB 0x2034
256 #define WGL_PBUFFER_HEIGHT_ARB 0x2035
257 #define WGL_PBUFFER_LOST_ARB 0x2036
258 #define ERROR_INVALID_PIXEL_TYPE_EXT 0x2043
259 #define WGL_NUMBER_PIXEL_FORMATS_EXT 0x2000
260 #define WGL_DRAW_TO_WINDOW_EXT 0x2001
261 #define WGL_DRAW_TO_BITMAP_EXT 0x2002
262 #define WGL_ACCELERATION_EXT 0x2003
263 #define WGL_NEED_PALETTE_EXT 0x2004
264 #define WGL_NEED_SYSTEM_PALETTE_EXT 0x2005
265 #define WGL_SWAP_LAYER_BUFFERS_EXT 0x2006
266 #define WGL_SWAP_METHOD_EXT 0x2007
267 #define WGL_NUMBER_OVERLAYS_EXT 0x2008
268 #define WGL_NUMBER_UNDERLAYS_EXT 0x2009
269 #define WGL_TRANSPARENT_EXT 0x200A
270 #define WGL_TRANSPARENT_VALUE_EXT 0x200B
271 #define WGL_SHARE_DEPTH_EXT 0x200C
272 #define WGL_SHARE_STENCIL_EXT 0x200D
273 #define WGL_SHARE_ACCUM_EXT 0x200E
274 #define WGL_SUPPORT_GDI_EXT 0x200F
275 #define WGL_SUPPORT_OPENGL_EXT 0x2010
276 #define WGL_DOUBLE_BUFFER_EXT 0x2011
277 #define WGL_STEREO_EXT 0x2012
278 #define WGL_PIXEL_TYPE_EXT 0x2013
279 #define WGL_COLOR_BITS_EXT 0x2014
280 #define WGL_RED_BITS_EXT 0x2015
281 #define WGL_RED_SHIFT_EXT 0x2016
282 #define WGL_GREEN_BITS_EXT 0x2017
283 #define WGL_GREEN_SHIFT_EXT 0x2018
284 #define WGL_BLUE_BITS_EXT 0x2019
285 #define WGL_BLUE_SHIFT_EXT 0x201A
286 #define WGL_ALPHA_BITS_EXT 0x201B
287 #define WGL_ALPHA_SHIFT_EXT 0x201C
288 #define WGL_ACCUM_BITS_EXT 0x201D
289 #define WGL_ACCUM_RED_BITS_EXT 0x201E
290 #define WGL_ACCUM_GREEN_BITS_EXT 0x201F
291 #define WGL_ACCUM_BLUE_BITS_EXT 0x2020
292 #define WGL_ACCUM_ALPHA_BITS_EXT 0x2021
293 #define WGL_DEPTH_BITS_EXT 0x2022
294 #define WGL_STENCIL_BITS_EXT 0x2023
295 #define WGL_AUX_BUFFERS_EXT 0x2024
296 #define WGL_NO_ACCELERATION_EXT 0x2025
297 #define WGL_GENERIC_ACCELERATION_EXT 0x2026
298 #define WGL_FULL_ACCELERATION_EXT 0x2027
299 #define WGL_SWAP_EXCHANGE_EXT 0x2028
300 #define WGL_SWAP_COPY_EXT 0x2029
301 #define WGL_SWAP_UNDEFINED_EXT 0x202A
302 #define WGL_TYPE_RGBA_EXT 0x202B
303 #define WGL_TYPE_COLORINDEX_EXT 0x202C
304 #define WGL_DRAW_TO_PBUFFER_EXT 0x202D
305 #define WGL_MAX_PBUFFER_PIXELS_EXT 0x202E
306 #define WGL_MAX_PBUFFER_WIDTH_EXT 0x202F
307 #define WGL_MAX_PBUFFER_HEIGHT_EXT 0x2030
308 #define WGL_OPTIMAL_PBUFFER_WIDTH_EXT 0x2031
309 #define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032
310 #define WGL_PBUFFER_LARGEST_EXT 0x2033
311 #define WGL_PBUFFER_WIDTH_EXT 0x2034
312 #define WGL_PBUFFER_HEIGHT_EXT 0x2035
313 #define WGL_DEPTH_FLOAT_EXT 0x2040
314 #define WGL_SAMPLE_BUFFERS_3DFX 0x2060
315 #define WGL_SAMPLES_3DFX 0x2061
316 #define WGL_SAMPLE_BUFFERS_EXT 0x2041
317 #define WGL_SAMPLES_EXT 0x2042
318 #define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044
319 #define WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D 0x2045
320 #define WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D 0x2046
321 #define WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D 0x2047
322 #define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048
323 #define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049
324 #define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A
325 #define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B
326 #define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C
327 #define WGL_GAMMA_TABLE_SIZE_I3D 0x204E
328 #define WGL_GAMMA_EXCLUDE_DESKTOP_I3D 0x204F
329 #define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050
330 #define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051
331 #define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052
332 #define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053
333 #define WGL_ARB_buffer_region 1
334 #define WGL_ARB_extensions_string 1
335 #define WGL_ARB_pixel_format 1
336 #define WGL_ARB_make_current_read 1
337 #define WGL_ARB_pbuffer 1
338 #define WGL_EXT_display_color_table 1
339 #define WGL_EXT_extensions_string 1
340 #define WGL_EXT_make_current_read 1
341 #define WGL_EXT_pbuffer 1
342 #define WGL_EXT_pixel_format 1
343 #define WGL_EXT_swap_control 1
344 #define WGL_WGL_EXT_depth_float 1
345 #define WGL_WGL_3DFX_multisample 1
346 #define WGL_WGL_EXT_multisample 1
347 #define WGL_NV_allocate_memory 1
350 typedef void (APIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum target);
351 typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);
352 typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum target);
353 typedef void (APIENTRY * PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei count);
354 typedef void (APIENTRY * PFNGLUNLOCKARRAYSEXTPROC) (void);
358 typedef int (APIENTRY * PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer);
359 typedef int (APIENTRY * PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint *buffers);
360 typedef int (APIENTRY * PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint *buffers);
361 typedef int (APIENTRY * PFNGLBUFFERDATAARBPROC) (GLenum target, int size, const GLvoid *data, GLenum usage);
363 typedef int (APIENTRY * PFNWGLCHOOSEPIXELFORMATARBPROC) ();
364 typedef void * (APIENTRY * PFNWGLCREATEPBUFFERARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
365 typedef HDC (APIENTRY * PFNWGLGETPBUFFERDCARBPROC) (void * hPbuffer);
366 typedef int (APIENTRY * PFNWGLRELEASEPBUFFERDCARBPROC) (void * hPbuffer, HDC hDC);
367 typedef BOOL (APIENTRY * PFNWGLDESTROYPBUFFERARBPROC) (void * hPbuffer);
368 typedef BOOL (APIENTRY * PFNWGLQUERYPBUFFERARBPROC) (void * hPbuffer, int iAttribute, int *piValue);
369 typedef const char * (APIENTRY * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc);
370 typedef BOOL (APIENTRY * PFNWGLBINDTEXIMAGEARBPROC) (void * hPbuffer, int iBuffer);
371 typedef BOOL (APIENTRY * PFNWGLRELEASETEXIMAGEARBPROC) (void * hPbuffer, int iBuffer);
373 static PFNGLMAPBUFFERARBPROC glMapBufferARB = null;
374 static PFNGLUNMAPBUFFERARBPROC glUnmapBufferARB = null;
375 static PFNGLACTIVETEXTUREARBPROC glActiveTextureARB = null;
376 static PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB = null;
377 static PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB = null;
378 static PFNGLLOCKARRAYSEXTPROC glLockArraysEXT = null;
379 static PFNGLUNLOCKARRAYSEXTPROC glUnlockArraysEXT = null;
380 static PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate = null;
382 static PFNGLGENBUFFERSARBPROC glGenBuffersARB = null;
383 static PFNGLBINDBUFFERARBPROC glBindBufferARB = null;
384 static PFNGLBUFFERDATAARBPROC glBufferDataARB = null;
385 static PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB = null;
386 static PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = null;
387 static PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB = null;
388 static PFNWGLCREATEPBUFFERARBPROC wglCreatePbufferARB = null;
389 static PFNWGLGETPBUFFERDCARBPROC wglGetPbufferDCARB = null;
390 static PFNWGLQUERYPBUFFERARBPROC wglQueryPbufferARB = null;
391 static PFNWGLDESTROYPBUFFERARBPROC wglDestroyPbufferARB = null;
392 static PFNWGLRELEASEPBUFFERDCARBPROC wglReleasePbufferDCARB = null;
393 static PFNWGLBINDTEXIMAGEARBPROC wglBindTexImageARB = null;
394 static PFNWGLRELEASETEXIMAGEARBPROC wglReleaseTexImageARB = null;
396 #define glBufferData glBufferDataARB
398 #ifdef WGL_WGLEXT_PROTOTYPES
399 extern BOOL WINAPI wglSwapIntervalEXT (int);
400 extern int WINAPI wglGetSwapIntervalEXT (void);
401 #endif /* WGL_WGLEXT_PROTOTYPES */
402 typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC) (int interval);
403 typedef int (WINAPI * PFNWGLGETSWAPINTERVALEXTPROC) (void);
405 static PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = NULL;
407 #elif defined(__ANDROID__) || defined(__ODROID__)
409 #define GL_FRAMEBUFFER GL_FRAMEBUFFER_OES
410 #define GL_RENDERBUFFER GL_RENDERBUFFER_OES
411 #define GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_OES
413 #define GL_POLYGON_STIPPLE 0xFFFF
414 #define GL_LINE_STIPPLE 0xFFFF
415 #define GL_LINE 0xFFFF
416 #define GL_FILL 0xFFFF
417 #define GL_ALL_ATTRIB_BITS 0xFFFF
418 #define GL_LIGHT_MODEL_LOCAL_VIEWER 0xFFFF
424 #define GL_QUAD_STRIP 0
425 //#define GL_DOUBLE 0
426 //#define GL_UNSIGNED_INT 0
429 //#define GL_LINE_STIPPLE 0
430 #define GL_BGRA_EXT 0
431 #define GL_UNPACK_ROW_LENGTH 0
432 #define GL_UNPACK_SKIP_PIXELS 0
433 #define GL_UNPACK_SKIP_ROWS 0
435 #define GL_PACK_ROW_LENGTH 0
436 #define GL_PACK_SKIP_ROWS 0
437 #define GL_PACK_SKIP_PIXELS 0
441 #if defined(ECERE_NO3D) || defined(ECERE_VANILLA)
449 FillBytesBy4(this, 0, sizeof(Matrix) >> 2);
450 m[0][0]=m[1][1]=m[2][2]=m[3][3]=1;
453 void Transpose(Matrix source)
458 m[j][i] = source.m[i][j];
461 void Multiply(Matrix a, Matrix b)
463 // We need a full matrix multiplication for the Projection matrix
464 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];
465 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];
466 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];
467 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];
469 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];
470 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];
471 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];
472 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];
474 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];
475 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];
476 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];
477 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];
479 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];
480 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];
481 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];
482 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];
487 // Our own matrix stack
488 static Matrix matrixStack[3][32];
489 static int matrixIndex[3];
490 static int curStack = 0;
494 // OpenGL ES Porting Kit
495 #if defined(__ANDROID__) || defined(__ODROID__)
496 #define glBindFramebuffer glBindFramebufferOES
497 #define glBindRenderbuffer glBindRenderbufferOES
498 #define GL_FRAMEBUFFER GL_FRAMEBUFFER_OES
499 #define GL_RENDERBUFFER GL_RENDERBUFFER_OES
500 #define glFramebufferTexture2D glFramebufferTexture2DOES
501 #define GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_OES
502 #define glGenFramebuffers glGenFramebuffersOES
503 #define glGenRenderbuffers glGenRenderbuffersOES
504 #define glDeleteFramebuffers glDeleteFramebuffersOES
505 #define glDeleteRenderbuffers glDeleteRenderbuffersOES
507 #define GL_POLYGON_STIPPLE 0xFFFF
508 #define GL_LINE_STIPPLE 0xFFFF
509 #define GL_LINE 0xFFFF
510 #define GL_FILL 0xFFFF
511 #define GL_ALL_ATTRIB_BITS 0xFFFF
512 #define GL_LIGHT_MODEL_LOCAL_VIEWER 0xFFFF
513 #define GL_INT 0x1404
514 #define GL_UNSIGNED_INT 0x1405
515 #define GL_DOUBLE 0x140A
521 #define glDrawElementsi(type, count, start) glDrawElements(type, count, GL_UNSIGNED_SHORT, start)
523 #define glBufferDatai glesBufferDatai
524 #define glBufferDatad glesBufferDatad
525 #define glVertexPointeri glesVertexPointeri
526 #define glVertexPointerd glesVertexPointerd
528 #define glRecti glesRecti
529 #define glBegin glesBegin
530 #define glTexCoord2i glesTexCoord2i
531 #define glVertex2i glesVertex2i
532 #define glTexCoord2d glesTexCoord2d
533 #define glVertex2d glesVertex2d
534 #define glTexCoord2f glesTexCoord2f
535 #define glVertex2f glesVertex2f
536 #define glEnd glesEnd
537 #define glColor3f glesColor3f
538 #define glColor4ub glesColor4ub
539 #define glColor4fv glesColor4fv
540 #define glLineStipple glesLineStipple
541 #define glNormal3fv glesNormal3fv
542 #define glNormal3f glesNormal3f
543 #define glTexCoord2fv glesTexCoord2fv
544 #define glColorMaterial glesColorMaterial
546 #define glLoadMatrixd glesLoadMatrixd
547 #define glMultMatrixd glesMultMatrixd
548 #define glFrustum glesFrustum
549 #define glOrtho glesOrtho
550 #define glScaled glesScaled
551 #define glTranslated glesTranslated
552 #define glRotated glesRotated
553 #define glVertex3d glesVertex3d
554 #define glVertex3dv glesVertex3dv
555 #define glVertex3f glesVertex3f
556 #define glVertex3fv glesVertex3fv
557 #define glLightModeli glesLightModeli
559 #if defined(__ANDROID__)
561 #define GL_QUAD_STRIP 0
562 //#define GL_DOUBLE 0
563 //#define GL_UNSIGNED_INT 0
566 //#define GL_LINE_STIPPLE 0
567 #define GL_BGRA_EXT 0
568 #define GL_UNPACK_ROW_LENGTH 0
569 #define GL_UNPACK_SKIP_PIXELS 0
570 #define GL_UNPACK_SKIP_ROWS 0
572 #define GL_PACK_ROW_LENGTH 0
573 #define GL_PACK_SKIP_ROWS 0
574 #define GL_PACK_SKIP_PIXELS 0
579 #define glVertexPointerd(nc, s, p, nv) glVertexPointer(nc, GL_DOUBLE, s, p)
580 #define glDrawElementsi(type, count, start) glDrawElements(type, count, GL_UNSIGNED_INT, start)
584 #if defined(__ANDROID__) || defined(__ODROID__)
585 static EGLDisplay eglDisplay;
586 static EGLSurface eglSurface;
587 static EGLContext eglContext;
588 static int eglWidth, eglHeight;
590 #if defined(__ANDROID__)
591 static bool egl_init_display(ANativeWindow* window)
593 static bool egl_init_display(uint window)
596 const EGLint attribs[] =
598 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
602 EGL_DEPTH_SIZE, 16, //24,
603 /*EGL_SAMPLE_BUFFERS, 1,
604 EGL_SAMPLES, 0, //2,*/
613 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
614 eglInitialize(display, 0, 0);
615 eglChooseConfig(display, attribs, &config, 1, &numConfigs);
616 eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &format);
618 surface = eglCreateWindowSurface(display, config, window, null);
619 context = eglCreateContext(display, config, null, null);
621 if(!eglMakeCurrent(display, surface, surface, context))
624 eglQuerySurface(display, surface, EGL_WIDTH, &w);
625 eglQuerySurface(display, surface, EGL_HEIGHT, &h);
627 eglDisplay = display;
628 eglContext = context;
629 eglSurface = surface;
633 glEnableClientState(GL_VERTEX_ARRAY);
635 // Initialize GL state.
636 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
637 glEnable(GL_CULL_FACE);
638 glShadeModel(GL_SMOOTH);
639 glDisable(GL_DEPTH_TEST);
641 glDisable(GL_CULL_FACE);
642 glDisable(GL_DEPTH_TEST);
644 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
647 matrixStack[0][0].Identity();
648 matrixStack[1][0].Identity();
649 matrixStack[2][0].Identity();
651 glesMatrixMode(GL_MODELVIEW);
652 glScaled(1.0, 1.0, -1.0);
653 glesMatrixMode(GL_PROJECTION);
654 glShadeModel(GL_FLAT);
656 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
657 glFogi(GL_FOG_MODE, GL_EXP);
658 glFogf(GL_FOG_DENSITY, 0);
659 glEnable(GL_NORMALIZE);
660 glDepthFunc(GL_LESS);
662 glDisable(GL_MULTISAMPLE_ARB);
666 glOrtho(0,w,h,0,0.0,1.0);
669 curElementBuffer = 0;
673 static void egl_term_display()
677 glDeleteTextures(1, &stippleTexture);
680 if(eglDisplay != EGL_NO_DISPLAY)
682 eglMakeCurrent(eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
683 if(eglContext != EGL_NO_CONTEXT)
684 eglDestroyContext(eglDisplay, eglContext);
685 if(eglSurface != EGL_NO_SURFACE)
686 eglDestroySurface(eglDisplay, eglSurface);
687 eglTerminate(eglDisplay);
689 eglDisplay = EGL_NO_DISPLAY;
690 eglContext = EGL_NO_CONTEXT;
691 eglSurface = EGL_NO_SURFACE;
696 // OpenGL Immediate Mode Porting Kit
697 static int beginCount;
698 static int vertexCount;
699 static int normalCount;
700 static float *vertexPointer;
701 static float *normalPointer;
702 static GLenum beginMode = -1;
703 static uint beginBufferSize, normalBufferSize;
704 static int numVertexCoords = 2;
705 static bool vertexColorValues = false;
706 static int vertexStride = 4;
707 static int vertexOffset = 2;
709 public void glesRecti(int a, int b, int c, int d)
719 public void glesBegin(GLenum mode)
724 vertexColorValues = false;
731 normalBufferSize = beginBufferSize = 1024; // default number of vertices
732 vertexPointer = new float[beginBufferSize * vertexStride];
733 normalPointer = new float[normalBufferSize * 3];
737 public void glesTexCoord2f(float x, float y)
739 int count = vertexCount;
741 if(vertexCount + numVertexCoords > beginBufferSize)
743 beginBufferSize = beginBufferSize + beginBufferSize/2;
744 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
747 vertexPointer[count*vertexStride ] = x;
748 vertexPointer[count*vertexStride+1] = y;
751 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
753 vertexPointer[count*vertexStride ] = vertexPointer[(count-4)*vertexStride];
754 vertexPointer[count*vertexStride+1] = vertexPointer[(count-4)*vertexStride+1];
756 vertexPointer[count*vertexStride ] = vertexPointer[(count-3)*vertexStride];
757 vertexPointer[count*vertexStride+1] = vertexPointer[(count-3)*vertexStride+1];
761 public void glesTexCoord2i(int x, int y) { glesTexCoord2f((float)x, (float)y); }
762 public void glesTexCoord2d(double x, double y) { glesTexCoord2f((float)x, (float)y); }
763 public void glesTexCoord2fv(float * a) { glesTexCoord2f(a[0], a[1]); }
765 public void glesVertex2f(float x, float y)
768 vertexStride = vertexOffset + numVertexCoords;
770 if(vertexCount + 4 > beginBufferSize)
772 beginBufferSize = beginBufferSize + beginBufferSize/2;
773 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
776 vertexPointer[vertexCount*vertexStride+vertexOffset] = x;
777 vertexPointer[vertexCount*vertexStride+vertexOffset + 1] = y;
780 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
782 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset];
783 vertexPointer[vertexCount*vertexStride+vertexOffset + 1] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset + 1];
785 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset];
786 vertexPointer[vertexCount*vertexStride+vertexOffset + 1] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset + 1];
791 public void glesVertex2i(int x, int y) { glesVertex2f((float)x, (float)y); }
792 public void glesVertex2d(double x, double y) { glesVertex2f((float)x, (float)y); }
794 public void glesEnd(void)
796 int mode = beginMode;
797 if(mode == GL_QUADS) mode = GL_TRIANGLES;
798 else if(mode == GL_POLYGON) mode = GL_TRIANGLE_FAN;
800 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
801 noAB.use(texCoord, 2, GL_FLOAT, vertexStride * sizeof(float), vertexPointer);
802 if(vertexColorValues)
804 glEnableClientState(GL_COLOR_ARRAY);
805 noAB.use(color, 4, GL_FLOAT, vertexStride * sizeof(float), vertexPointer + 2);
807 noAB.use(vertex, numVertexCoords, GL_FLOAT, (vertexStride)*sizeof(float),vertexPointer+vertexOffset);
808 if(normalCount && normalCount == vertexCount)
810 glEnableClientState(GL_NORMAL_ARRAY);
811 noAB.use(normal, 3, GL_FLOAT, 3*sizeof(float),normalPointer);
814 glDrawArrays(mode, 0, vertexCount);
816 glDisableClientState(GL_NORMAL_ARRAY);
817 if(vertexColorValues)
818 glDisableClientState(GL_COLOR_ARRAY);
819 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
821 vertexColorValues = false;
827 static float *floatVPBuffer = null;
828 static short *shortVPBuffer = null;
829 static unsigned int shortVPSize = 0, floatVPSize = 0;
832 //static float *floatVPBuffer = null; // For floats we reuse floatVPBuffer
833 static unsigned short *shortBDBuffer = null;
834 static unsigned int shortBDSize = 0/*, floatVPSize = 0*/;
836 public void glesVertexPointeri(int numCoords, int stride, int *pointer, int numVertices)
841 if(numVertices*numCoords > shortVPSize)
843 shortVPSize = numVertices*numCoords;
844 shortVPBuffer = renew shortVPBuffer short[shortVPSize];
846 for(i = 0; i < numVertices*numCoords; i++)
847 shortVPBuffer[i] = (short)pointer[i];
848 glVertexPointer(numCoords, GL_SHORT, stride, shortVPBuffer);
851 glVertexPointer(numCoords, GL_SHORT, stride, 0);
854 public void glesVertexPointerd(int numCoords, int stride, double *pointer, int numVertices)
859 if(numVertices*numCoords > floatVPSize)
861 floatVPSize = numVertices*numCoords;
862 floatVPBuffer = renew floatVPBuffer float[floatVPSize];
864 for(i = 0; i < numVertices*numCoords; i++)
865 floatVPBuffer[i] = (float)pointer[i];
866 glVertexPointer(numCoords, GL_FLOAT, stride, floatVPBuffer);
869 glVertexPointer(numCoords, GL_FLOAT, stride, 0);
872 public void glesTexReuseIntVP(int numCoords)
874 glTexCoordPointer(numCoords, GL_SHORT, 0, floatVPBuffer);
877 public void glesTexReuseDoubleVP(int numCoords)
879 glTexCoordPointer(numCoords, GL_FLOAT, 0, floatVPBuffer);
882 public void glesColor4f(float r, float g, float b, float a)
884 if(beginMode != (GLenum)-1)
886 int count = vertexCount;
888 vertexColorValues = true;
890 vertexStride = vertexOffset + numVertexCoords;
892 if(vertexCount + vertexStride > beginBufferSize)
894 beginBufferSize = beginBufferSize + beginBufferSize/2;
895 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
898 vertexPointer[count*vertexStride + 2] = r;
899 vertexPointer[count*vertexStride + 3] = g;
900 vertexPointer[count*vertexStride + 4] = b;
901 vertexPointer[count*vertexStride + 5] = a;
904 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
906 vertexPointer[count*vertexStride + 2] = vertexPointer[(count-4) * vertexStride + 2];
907 vertexPointer[count*vertexStride + 3] = vertexPointer[(count-4) * vertexStride + 3];
908 vertexPointer[count*vertexStride + 4] = vertexPointer[(count-4) * vertexStride + 4];
909 vertexPointer[count*vertexStride + 5] = vertexPointer[(count-4) * vertexStride + 5];
911 vertexPointer[count*vertexStride + 2] = vertexPointer[(count-3) * vertexStride + 2];
912 vertexPointer[count*vertexStride + 3] = vertexPointer[(count-3) * vertexStride + 3];
913 vertexPointer[count*vertexStride + 4] = vertexPointer[(count-3) * vertexStride + 4];
914 vertexPointer[count*vertexStride + 5] = vertexPointer[(count-3) * vertexStride + 5];
919 glColor4f(r, g, b, a);
922 public void glesColor3f( float r, float g, float b )
924 glesColor4f(r, g, b, 1.0f);
927 public void glesColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
929 glesColor4f(r/255.0f, g/255.0f, b/255.0f, a/255.0f);
932 public void glesColor4fv(float * a)
934 glesColor4f(a[0], a[1], a[2], a[3]);
937 public void glesBufferDatad(int target, int size, void * data, int usage)
939 int numElems = size/sizeof(double);
940 double * dblPtr = (double *)data;
942 if (numElems > floatVPSize)
944 floatVPSize = numElems;
945 floatVPBuffer = renew floatVPBuffer float[floatVPSize];
947 for (i=0; i< numElems; i++)
948 floatVPBuffer[i] = (float)dblPtr[i];
950 glBufferData(target, numElems*sizeof(float), floatVPBuffer, usage);
953 public void glesBufferDatai(int target, int size, void * data, int usage)
955 int numElems = size/sizeof(unsigned int);
956 unsigned int * pointer = (unsigned int *)data;
958 if (numElems > shortBDSize)
960 shortBDSize = numElems;
961 shortBDBuffer = renew shortBDBuffer uint16[shortBDSize];
963 for (i=0; i< numElems; i++)
964 shortBDBuffer[i] = (unsigned short)pointer[i];
966 glBufferData(target, numElems*sizeof(unsigned short), shortBDBuffer, usage);
969 // *** Our Custom Matrix Stack ***
971 static void LoadCurMatrix()
973 double * i = matrixStack[curStack][matrixIndex[curStack]].array;
976 (float)i[0],(float)i[1],(float)i[2],(float)i[3],
977 (float)i[4],(float)i[5],(float)i[6],(float)i[7],
978 (float)i[8],(float)i[9],(float)i[10],(float)i[11],
979 (float)i[12],(float)i[13],(float)i[14],(float)i[15]
984 public void glesLoadIdentity()
986 matrixStack[curStack][matrixIndex[curStack]].Identity();
990 public void glesPushMatrix()
992 if(matrixIndex[curStack] + 1 < sizeof(matrixStack[0]) / sizeof(Matrix))
994 matrixIndex[curStack]++;
995 memcpy(matrixStack[curStack][matrixIndex[curStack]].array, matrixStack[curStack][matrixIndex[curStack]-1].array, sizeof(Matrix));
999 public void glesPopMatrix()
1001 if(matrixIndex[curStack] > 0)
1003 matrixIndex[curStack]--;
1008 public void glesLoadMatrixd(double * i)
1010 memcpy(matrixStack[curStack][matrixIndex[curStack]].array, i, sizeof(Matrix));
1014 public void glesOrtho( double l, double r, double b, double t, double n, double f )
1018 (2 / (r - l)), 0, 0, 0,
1019 0, (2 / (t - b)), 0, 0,
1020 0, 0, (-2 / (f - n)), 0,
1021 (-(r + l) / (r - l)), (-(t + b) / (t - b)), (-(f + n) / (f - n)), 1
1024 res.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1025 matrixStack[curStack][matrixIndex[curStack]] = res;
1029 public void glesFrustum( double l, double r, double b, double t, double n, double f )
1039 double A = ((r + l) / (r - l));
1040 double B = ((t + b) / (t - b));
1041 double C = (-(f + n) / (f - n));
1042 double D = (-2*f*n/(f-n));
1045 (2.0*n / (r - l)), 0, 0, 0,
1046 0, (2.0*n / (t - b)), 0, 0,
1051 res.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1052 matrixStack[curStack][matrixIndex[curStack]] = res;
1057 public void glesRotated( double a, double b, double c, double d )
1062 q.RotationAxis({(float)b,(float)c,(float)-d}, a );
1063 m.RotationQuaternion(q);
1064 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1065 matrixStack[curStack][matrixIndex[curStack]] = r;
1068 public void glesScaled( double a, double b, double c )
1074 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1075 matrixStack[curStack][matrixIndex[curStack]] = r;
1079 public void glesTranslated( double a, double b, double c )
1085 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1086 matrixStack[curStack][matrixIndex[curStack]] = r;
1090 public void glesMultMatrixd( double * i )
1093 r.Multiply((Matrix *)i, matrixStack[curStack][matrixIndex[curStack]]);
1094 matrixStack[curStack][matrixIndex[curStack]] = r;
1098 public void glesMatrixMode(int mode)
1100 curStack = (mode == GL_MODELVIEW) ? 0 : (mode == GL_PROJECTION) ? 1 : 2;
1106 #define glPushMatrix glesPushMatrix
1107 #define glPopMatrix glesPopMatrix
1108 #define glLoadIdentity glesLoadIdentity
1109 #define glMatrixMode glesMatrixMode
1113 /* Using the built-in matrix stack
1114 void glesLoadMatrixd( double * i )
1118 (float)i[0],(float)i[1],(float)i[2],(float)i[3],
1119 (float)i[4],(float)i[5],(float)i[6],(float)i[7],
1120 (float)i[8],(float)i[9],(float)i[10],(float)i[11],
1121 (float)i[12],(float)i[13],(float)i[14],(float)i[15]
1126 void glesOrtho( double l, double r, double b, double t, double n, double f )
1128 float matrix[4][4] =
1130 { (float)(2 / (r - l)), 0, 0, 0 },
1131 { 0, (float)(2 / (t - b)), 0, 0 },
1132 { 0, 0, (float)(-2 / (f - n)), 0 },
1133 { (float)(-(r + l) / (r - l)), (float)(-(t + b) / (t - b)), (float)(-(f + n) / (f - n)), 1 }
1135 glMultMatrixf((float *)matrix);
1138 void glesFrustum( double l, double r, double b, double t, double n, double f )
1140 float A = (float)((r + l) / (r - l));
1141 float B = (float)((t + b) / (t - b));
1142 float C = (float)(-(f + n) / (f - n));
1143 float D = (float)(-2*f*n/(f-n));
1144 float matrix[4][4] =
1146 { (float)(2*n / (r - l)), 0, 0, 0 },
1147 { 0, (float)(2*n / (t - b)), 0, 0 },
1151 glMultMatrixf((float *)matrix);
1154 void glesRotated( double a, double b, double c, double d ) { glRotatef((float)a, (float)b, (float)c, (float)d); }
1155 void glesScaled( double a, double b, double c ) { glScalef((float)a, (float)b, (float)c); }
1156 void glesTranslated( double a, double b, double c ) { glTranslatef((float)a, (float)b, (float)c); }
1158 void glesMultMatrixd( double * i )
1162 (float)i[0], (float)i[1], (float)i[2], (float)i[3],
1163 (float)i[4], (float)i[5], (float)i[6], (float)i[7],
1164 (float)i[8], (float)i[9], (float)i[10], (float)i[11],
1165 (float)i[12], (float)i[13], (float)i[14], (float)i[15]
1171 // Need to do these...
1172 public void glesVertex3f( float x, float y, float z )
1174 numVertexCoords = 3;
1175 vertexStride = vertexOffset + numVertexCoords;
1177 if(vertexCount + vertexStride > beginBufferSize)
1179 beginBufferSize = beginBufferSize + beginBufferSize/2;
1180 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
1183 vertexPointer[vertexCount*vertexStride+vertexOffset] = x;
1184 vertexPointer[vertexCount*vertexStride+vertexOffset+1] = y;
1185 vertexPointer[vertexCount*vertexStride+vertexOffset+2] = z;
1188 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
1190 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset];
1191 vertexPointer[vertexCount*vertexStride+vertexOffset+1] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset+1];
1192 vertexPointer[vertexCount*vertexStride+vertexOffset+2] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset+2];
1194 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset];
1195 vertexPointer[vertexCount*vertexStride+vertexOffset+1] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset+1];
1196 vertexPointer[vertexCount*vertexStride+vertexOffset+2] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset+2];
1202 public void glesVertex3d( double x, double y, double z ) { glesVertex3f((float)x, (float)y, (float)z); }
1203 public void glesVertex3fv( float* coords ) { glesVertex3f(coords[0], coords[1], coords[2]); }
1204 public void glesVertex3dv( double* coords ) { glesVertex3f((float)coords[0], (float)coords[1], (float)coords[2]); }
1206 public void glesNormal3f(float x, float y, float z)
1208 normalCount = vertexCount;
1209 if(vertexCount + 4 > normalBufferSize)
1211 normalBufferSize = normalBufferSize + normalBufferSize/2;
1212 normalPointer = renew normalPointer float[normalBufferSize * 2];
1215 normalPointer[normalCount*3+0] = x;
1216 normalPointer[normalCount*3+1] = y;
1217 normalPointer[normalCount*3+2] = z;
1220 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
1222 normalPointer[normalCount*3+0] = normalPointer[(normalCount-4)*3+0];
1223 normalPointer[normalCount*3+1] = normalPointer[(normalCount-4)*3+1];
1224 normalPointer[normalCount*3+2] = normalPointer[(normalCount-4)*3+2];
1226 normalPointer[normalCount*3+0] = normalPointer[(normalCount-3)*3+0];
1227 normalPointer[normalCount*3+1] = normalPointer[(normalCount-3)*3+1];
1228 normalPointer[normalCount*3+2] = normalPointer[(normalCount-3)*3+2];
1232 public void glesNormal3fd(double x, double y, double z) { glesNormal3f((float)x, (float)y, (float)z); }
1233 public void glesNormal3fv(float * coords) { glesNormal3f(coords[0], coords[1], coords[2]); }
1235 public void glesColorMaterial(int a, int b)
1237 PrintLn("glColorMaterial stub");
1240 public void glesTerminate()
1242 delete vertexPointer;
1243 delete normalPointer;
1244 beginBufferSize = 0;
1246 delete floatVPBuffer;
1249 delete shortVPBuffer;
1252 delete shortBDBuffer;
1256 static GLuint stippleTexture;
1258 static bool stippleEnabled;
1261 public void glesLineStipple( int i, unsigned short j )
1265 for(x = 0; x < 16; x++)
1267 bool v = (j & (1 << x)) != 0;
1268 texture[x] = v ? 0xFFFFFFFF : 0;
1271 glGenTextures(1, &stippleTexture);
1272 glBindTexture(GL_TEXTURE_2D, stippleTexture);
1273 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture);
1274 glEnable(GL_TEXTURE_2D);
1275 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1276 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1277 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
1278 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1279 glMatrixMode(GL_TEXTURE);
1281 //glTranslated(1.0/backAttrib->texW/2.0f, 1.0/backAttrib->texH/2.0f, 0.0f);
1282 glScaled(i/16.0, 1, 1.0f);
1283 glTranslated(0.5, 0.5, 0);
1284 glMatrixMode(GL_PROJECTION);
1287 public void glesLightModeli( unsigned int pname, int param )
1289 if(pname == GL_LIGHT_MODEL_TWO_SIDE)
1290 glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, param);
1293 #if defined(__ANDROID__) || defined(__ODROID__)
1294 void glClearDepth( double depth ) { glClearDepthf((float)depth); }
1295 void glFogi( unsigned int pname, int param ) { }
1296 void glPolygonMode( unsigned int i, unsigned int j ) { }
1299 // *** Picking won't be supported for now ***
1300 void glPushName( unsigned int i ) { }
1301 void glLoadName( unsigned int i ) { }
1302 void glPopName() { }
1304 // Probably replace by regular glBlendFunc ...
1305 void glBlendFuncSeparate(int a, int b, int c, int d)
1310 // For direct pixel blitting...
1311 void glRasterPos2d(double a, double b) { }
1312 void glPixelZoom(float a, float b) { }
1313 void glDrawPixels(int a, int b, int c, int d, void * e) { }
1317 #if !defined(__APPLE__) && !defined(__WIN32__) && !defined(__ODROID__)
1318 void (APIENTRY * glBindBufferARB) (GLenum target, GLuint buffer);
1319 void (APIENTRY * glGenBuffersARB) (GLsizei n, GLuint *buffers);
1320 void (APIENTRY * glDeleteBuffersARB) (GLsizei n, const GLuint *buffers);
1321 void (APIENTRY * glBufferDataARB) (GLenum target, int size, const GLvoid *data, GLenum usage);
1324 public void GLLoadMatrix(Matrix matrix)
1328 (float)matrix.m[0][0], (float)matrix.m[0][1], (float)matrix.m[0][2], (float)matrix.m[0][3],
1329 (float)matrix.m[1][0], (float)matrix.m[1][1], (float)matrix.m[1][2], (float)matrix.m[1][3],
1330 (float)matrix.m[2][0], (float)matrix.m[2][1], (float)matrix.m[2][2], (float)matrix.m[2][3],
1331 (float)matrix.m[3][0], (float)matrix.m[3][1], (float)matrix.m[3][2], (float)matrix.m[3][3]
1336 public enum GLBufferContents { vertex, normal, texCoord, color };
1338 public define noAB = GLAB { 0 };
1340 static uint curArrayBuffer;
1346 void upload(uint size, void * data)
1351 GLGenBuffers(1, this);
1352 if(curArrayBuffer != buffer)
1353 GLBindBuffer(GL_ARRAY_BUFFER, buffer);
1354 glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW); //GL_DYNAMIC_DRAW);
1360 if(this != null && buffer)
1362 GLDeleteBuffers(1, this);
1367 void use(GLBufferContents contents, int n, int type, uint stride, void * pointer)
1369 if(curArrayBuffer != ((this != null) ? buffer : 0))
1370 GLBindBuffer(GL_ARRAY_BUFFER, ((this != null) ? buffer : 0));
1373 case normal: glNormalPointer(type, stride, pointer); break;
1374 case vertex: glVertexPointer(n, type, stride, pointer); break;
1375 case texCoord: glTexCoordPointer(n, type, stride, pointer); break;
1376 case color: glColorPointer(n, type, stride, pointer); break;
1380 void useVertTrans(uint count, int n, int type, uint stride, void * pointer)
1383 if(curArrayBuffer != ((this != null) ? buffer : 0))
1384 GLBindBuffer(GL_ARRAY_BUFFER, ((this != null) ? buffer : 0));
1386 glVertexPointeri(n, stride, pointer, count);
1387 else if(type == GL_DOUBLE)
1388 glVertexPointerd(n, stride, pointer, count);
1390 use(vertex, n, type, stride, pointer);
1395 static uint curElementBuffer;
1397 public define noEAB = GLEAB { 0 };
1403 void upload(uint size, void * data)
1408 GLGenBuffers(1, (GLAB *)this);
1410 if(curElementBuffer != buffer)
1411 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
1412 glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, data, GL_STATIC_DRAW); //GL_DYNAMIC_DRAW);
1418 if(this != null && buffer)
1420 GLDeleteBuffers(1, (GLAB *)this);
1425 void draw(int primType, int count, int type, void * indices)
1427 if(curElementBuffer != ((this != null) ? buffer : 0))
1428 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ((this != null) ? buffer : 0));
1430 type = GL_UNSIGNED_SHORT;
1432 glDrawElements(primType, count, type, indices);
1436 public void GLGenBuffers(int count, GLAB * buffers)
1438 #if defined(__ANDROID__) || defined(__ODROID__)
1439 glGenBuffers(count, (GLuint *)buffers);
1441 #if defined(__WIN32__)
1444 glGenBuffersARB(count, (GLuint *)buffers);
1448 public void GLDeleteBuffers(int count, GLAB * buffers)
1451 for(i = 0; i < count; i++)
1453 uint buffer = buffers[i].buffer;
1456 if(buffer == curArrayBuffer)
1457 GLBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
1458 else if(buffer == curElementBuffer)
1459 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
1462 #if defined(__ANDROID__) || defined(__ODROID__)
1463 if(count && buffers[0].buffer)
1464 glDeleteBuffers(count, (GLuint *)buffers);
1466 #if defined(__WIN32__)
1467 if(glDeleteBuffersARB)
1469 glDeleteBuffersARB(count, (GLuint *)buffers);
1473 void GLBindBuffer(int target, uint buffer)
1475 #if defined(__ANDROID__) || defined(__ODROID__)
1476 glBindBuffer(target, buffer);
1478 #if defined(__WIN32__)
1481 glBindBufferARB(target, buffer);
1483 if(target == GL_ARRAY_BUFFER_ARB)
1484 curArrayBuffer = buffer;
1485 else if(target == GL_ELEMENT_ARRAY_BUFFER_ARB)
1486 curElementBuffer = buffer;
1489 public void GLVertexPointer(int numCoords, int glType, int stride, void *ptr, int numVertices)
1492 if(glType == GL_DOUBLE)
1493 glesVertexPointerd(numCoords, stride, ptr, numVertices);
1494 else if(glType == GL_INT)
1495 glesVertexPointeri(numCoords, stride, ptr, numVertices);
1498 glVertexPointer(numCoords, glType, stride, ptr);
1501 public void GLBufferData(int type, GLenum target, int size, const GLvoid *data, GLenum usage)
1504 if(type == GL_DOUBLE)
1505 glesBufferDatad(target, size, (void *)data, usage);
1506 else if(type == GL_UNSIGNED_INT)
1507 glesBufferDatai(target, size, (void *)data, usage);
1511 #if defined(__ANDROID__) || defined(__ODROID__)
1512 glBufferData(target, size, data, usage);
1515 #if defined(__WIN32__)
1518 glBufferDataARB(target, size, data, usage);
1522 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1523 static int primitiveTypes[RenderPrimitiveType] =
1525 GL_POINTS, GL_LINES, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP, GL_LINE_STRIP
1530 // Non OpenGL ES friendly stuff
1534 //#undef GL_UNSIGNED_INT
1539 #undef GL_QUAD_STRIP
1540 #undef GL_POLYGON_STIPPLE
1541 #undef GL_LINE_STIPPLE
1544 #undef GL_ALL_ATTRIB_BITS
1545 #undef GL_LIGHT_MODEL_LOCAL_VIEWER
1549 static int displayWidth, displayHeight;
1551 #define GL_CLAMP_TO_EDGE 0x812F
1553 static bool vboAvailable;
1555 static bool useSingleGLContext = false;
1556 class OGLDisplay : struct
1558 #if defined(__WIN32__)
1568 int imageBuffers[2];
1569 byte * pboMemory1, * pboMemory2;
1571 #elif !defined(__ANDROID__) && !defined(__ODROID__)
1572 GLXContext glContext;
1575 XShmSegmentInfo shminfo;
1577 XShmSegmentInfo shminfoShape;
1578 XImage * shapeImage;
1582 X11Picture windowPicture;
1583 X11Picture pixmapPicture;
1585 X11Picture shapePicture;
1588 ColorAlpha * flippingBuffer;
1589 int flipBufH, flipBufW;
1594 class OGLSystem : struct
1599 #if defined(__WIN32__)
1600 PIXELFORMATDESCRIPTOR pfd;
1605 #elif !defined(__ANDROID__) && !defined(__ODROID__)
1606 XVisualInfo * visualInfo;
1607 GLXContext glContext;
1608 GLXDrawable glxDrawable;
1612 class OGLSurface : struct
1619 float foreground[4], background[4], bitmapMult[4];
1622 class OGLMesh : struct
1631 class OGLIndices : struct
1641 class OpenGLDisplayDriver : DisplayDriver
1643 class_property(name) = "OpenGL";
1645 bool LockSystem(DisplaySystem displaySystem)
1647 #if !defined(__ANDROID__) && !defined(__ODROID__)
1648 OGLSystem oglSystem = displaySystem.driverData;
1649 if(useSingleGLContext) return true;
1650 #if defined(__WIN32__)
1651 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1652 #elif defined(__unix__) || defined(__APPLE__)
1653 //if(previous) return true;
1654 // printf("Making SYSTEM current\n");
1655 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)oglSystem.glxDrawable, oglSystem.glContext);
1656 //previous = oglSystem.glContext;
1662 void UnlockSystem(DisplaySystem displaySystem)
1664 if(useSingleGLContext) return;
1665 #if defined(__WIN32__)
1666 wglMakeCurrent(null, null);
1667 #elif defined(__unix__) || defined(__APPLE__)
1668 // printf("Making NULL current\n");
1669 #if defined(__ANDROID__) || defined(__ODROID__)
1671 glXMakeCurrent(xGlobalDisplay, None, null);
1677 bool Lock(Display display)
1679 #if !defined(__ANDROID__) && !defined(__ODROID__)
1680 OGLDisplay oglDisplay = display.driverData;
1681 if(useSingleGLContext) return true;
1682 #if defined(__WIN32__)
1683 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1684 #elif defined(__unix__) || defined(__APPLE__)
1685 // if(previous) glXMakeCurrent(xGlobalDisplay, None, null);
1686 // printf(" Making DISPLAY current\n");
1687 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
1693 void Unlock(Display display)
1695 if(useSingleGLContext) return;
1696 //printf(" Making NULL current\n");
1697 //glXMakeCurrent(xGlobalDisplay, None, null);
1699 LockSystem(display.displaySystem);
1702 void DestroyDisplay(Display display)
1704 OGLDisplay oglDisplay = display.driverData;
1708 #if defined(__WIN32__)
1709 wglMakeCurrent( null, null );
1712 wglDeleteContext(oglDisplay.glrc);
1714 if(oglDisplay.hdc && oglDisplay.pBuffer)
1715 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
1717 if(oglDisplay.pBuffer)
1718 wglDestroyPbufferARB(oglDisplay.pBuffer);
1721 ReleaseDC(display.window, oglDisplay.hdc);
1723 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
1724 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
1726 #elif defined(__unix__) || defined(__APPLE__)
1727 #if defined(__ANDROID__) || defined(__ODROID__)
1729 if(oglDisplay.shapePixmap)
1730 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
1731 if(oglDisplay.pixmap)
1732 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1733 if(oglDisplay.image)
1735 if(oglDisplay.shminfoShape.shmid != -1)
1737 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
1738 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1739 shmdt(oglDisplay.shminfo.shmaddr);
1740 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
1743 if(oglDisplay.shapeImage)
1745 if(oglDisplay.shminfoShape.shmid != -1)
1747 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
1748 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1749 shmdt(oglDisplay.shminfoShape.shmaddr);
1750 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
1752 XDestroyImage(oglDisplay.shapeImage);
1753 oglDisplay.shapeImage = None;
1756 glXMakeCurrent(xGlobalDisplay, None, null);
1758 if(oglDisplay.glContext)
1759 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
1762 delete oglDisplay.flippingBuffer;
1764 display.driverData = null;
1768 void ::CheckExtensions(OGLSystem oglSystem)
1770 const char * extensions = (const char *)glGetString(GL_EXTENSIONS);
1772 oglSystem.pow2textures = strstr(extensions, "GL_ARB_texture_non_power_of_two") ? false : true;
1773 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &oglSystem.maxTextureSize);
1776 bool CreateDisplaySystem(DisplaySystem displaySystem)
1778 bool result = false;
1779 OGLSystem oglSystem = displaySystem.driverData = OGLSystem { };
1782 oglSystem.hwnd = CreateWindow("static", null, 0,0,0,0,0,null,null,null,null);
1784 oglSystem.hdc = GetDC(oglSystem.hwnd);
1788 oglSystem.pfd.nSize = (short)sizeof(oglSystem.pfd);
1789 oglSystem.pfd.nVersion = 1;
1790 oglSystem.pfd.dwFlags = PFD_DRAW_TO_WINDOW /*PFD_DRAW_TO_BITMAP*/ | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
1791 oglSystem.pfd.iPixelType = PFD_TYPE_RGBA;
1792 oglSystem.pfd.cColorBits = 24;
1793 oglSystem.pfd.cAlphaBits = 8;
1794 oglSystem.pfd.cDepthBits = 24;
1795 oglSystem.pfd.iLayerType = PFD_MAIN_PLANE;
1797 oglSystem.format = ChoosePixelFormat(oglSystem.hdc, &oglSystem.pfd);
1798 DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1800 if(oglSystem.pfd.cColorBits > 8)
1802 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1803 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1806 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1808 // Get Pointers To The GL Functions
1809 glActiveTextureARB = (void *) wglGetProcAddress("glActiveTextureARB");
1810 glMultiTexCoord2fARB = (void *) wglGetProcAddress("glMultiTexCoord2fARB");
1811 glClientActiveTextureARB = (void *) wglGetProcAddress("glClientActiveTextureARB");
1812 glLockArraysEXT = (void *) wglGetProcAddress("glLockArraysEXT" );
1813 glUnlockArraysEXT = (void *) wglGetProcAddress("glUnlockArraysEXT");
1814 glGenBuffersARB = (void *) wglGetProcAddress("glGenBuffersARB");
1815 glBindBufferARB = (void *) wglGetProcAddress("glBindBufferARB");
1816 glBufferDataARB = (void *) wglGetProcAddress("glBufferDataARB");
1817 glMapBufferARB = (void *) wglGetProcAddress("glMapBufferARB");
1818 glUnmapBufferARB = (void *) wglGetProcAddress("glUnmapBufferARB");
1819 glDeleteBuffersARB = (void *) wglGetProcAddress("glDeleteBuffersARB");
1820 glBlendFuncSeparate = (void *) wglGetProcAddress("glBlendFuncSeparate");
1822 wglChoosePixelFormatARB = (void *) wglGetProcAddress("wglChoosePixelFormatARB");
1823 wglGetExtensionsStringARB = (void *)wglGetProcAddress("wglGetExtensionsStringARB");
1824 wglCreatePbufferARB = (void *)wglGetProcAddress("wglCreatePbufferARB");
1825 wglGetPbufferDCARB = (void *)wglGetProcAddress("wglGetPbufferDCARB");
1826 wglQueryPbufferARB = (void *)wglGetProcAddress("wglQueryPbufferARB");
1827 wglDestroyPbufferARB = (void *)wglGetProcAddress("wglDestroyPbufferARB");
1828 wglReleasePbufferDCARB = (void *)wglGetProcAddress("wglReleasePbufferDCARB");
1829 wglBindTexImageARB = (void *)wglGetProcAddress("wglBindTexImageARB");
1830 wglReleaseTexImageARB = (void *)wglGetProcAddress("wglReleaseTexImageARB");
1832 wglSwapIntervalEXT = (void *)wglGetProcAddress("wglSwapIntervalEXT");
1834 vboAvailable = glBindBufferARB != null;
1836 // eSystem_LoggingMode(LOG_MSGBOX, null);
1838 if(wglChoosePixelFormatARB)
1843 float fAttributes[] = {0,0};
1846 WGL_DRAW_TO_WINDOW_ARB,GL_TRUE,
1847 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1848 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
1849 WGL_COLOR_BITS_ARB,24,
1850 WGL_ALPHA_BITS_ARB,8,
1851 WGL_DEPTH_BITS_ARB,16,
1852 WGL_STENCIL_BITS_ARB,0,
1853 WGL_DOUBLE_BUFFER_ARB,GL_TRUE,
1854 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
1855 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
1859 //Log("Found wglChoosePixelFormatARB\n");
1861 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1862 if(!valid || !numFormats)
1864 //Log("Can't find 4x multi sampling\n");
1865 iAttributes[19] = 2;
1866 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1867 if(!valid || !numFormats)
1869 // Log("Can't find 2x multi sampling\n");
1870 iAttributes[16] = 0;
1871 iAttributes[17] = 0;
1872 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1875 if(valid && numFormats)
1877 oglSystem.format = pixelFormat;
1878 wglMakeCurrent(null, null);
1879 wglDeleteContext(oglSystem.glrc);
1881 // *** DescribePixelFormat does not support WGL pixel formats! ***
1882 //DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1883 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1884 //Log("Successfully set pixel format\n");
1886 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1887 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1891 eSystem_Logf("Can't find wglChoosePixelFormatARB\n");*/
1895 CheckExtensions(oglSystem);
1897 wglMakeCurrent(null, null);
1899 //eSystem_DumpErrors(true);
1903 #elif defined(__unix__) || defined(__APPLE__)
1904 vboAvailable = true;
1905 #if defined(__ANDROID__)
1906 egl_init_display(guiApp.desktop.windowHandle);
1907 #elif defined(__ODROID__)
1908 egl_init_display((uint)displaySystem.window);
1909 CheckExtensions(oglSystem);
1913 X11Window root = RootWindow( xGlobalDisplay, DefaultScreen( xGlobalDisplay ) );
1914 XSetWindowAttributes attr;
1919 #ifndef ECERE_MINIGLX
1920 GLX_USE_GL, GLX_DEPTH_SIZE, 1,
1923 GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,
1927 oglSystem.visualInfo = glXChooseVisual( xGlobalDisplay, DefaultScreen( xGlobalDisplay ), attrList );
1928 attr.background_pixel = 0;
1929 attr.border_pixel = 0;
1930 attr.colormap = XCreateColormap( xGlobalDisplay, root, oglSystem.visualInfo->visual, AllocNone);
1931 attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
1932 mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
1934 oglSystem.glxDrawable = XCreateWindow( xGlobalDisplay, root, 0, 0, 1, 1, 0, oglSystem.visualInfo->depth, InputOutput,
1935 oglSystem.visualInfo->visual, mask, &attr );
1937 if(oglSystem.visualInfo)
1939 oglSystem.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, null, True);
1940 if(oglSystem.glContext)
1942 glXMakeCurrent(xGlobalDisplay, oglSystem.glxDrawable, oglSystem.glContext);
1944 CheckExtensions(oglSystem);
1945 glXMakeCurrent(xGlobalDisplay, None, null);
1952 displaySystem.flags.alpha = true;
1953 displaySystem.flags.flipping = true;
1954 displaySystem.pixelFormat = pixelFormat888;
1958 void DestroyDisplaySystem(DisplaySystem displaySystem)
1960 OGLSystem oglSystem = displaySystem.driverData;
1962 #if defined(__WIN32__)
1963 wglMakeCurrent( null, null );
1966 wglDeleteContext(oglSystem.glrc);
1969 ReleaseDC(oglSystem.hwnd, oglSystem.hdc);
1970 DestroyWindow(oglSystem.hwnd);
1972 #elif defined(__unix__) || defined(__APPLE__)
1973 #if defined(__ANDROID__) || defined(__ODROID__)
1976 if(oglSystem.visualInfo)
1978 #ifdef ECERE_MINIGLX
1979 __miniglx_XFree(oglSystem.visualInfo);
1981 XFree(oglSystem.visualInfo);
1985 if(oglSystem.glxDrawable)
1987 XDestroyWindow(xGlobalDisplay, oglSystem.glxDrawable);
1988 oglSystem.glxDrawable = 0;
1995 bool CreateDisplay(Display display)
1997 bool result = false;
1998 OGLDisplay oglDisplay = display.driverData;
1999 #if !defined(__ANDROID__) && !defined(__ODROID__)
2000 OGLSystem oglSystem = display.displaySystem.driverData;
2003 oglDisplay = display.driverData = OGLDisplay { };
2004 //printf("Inside CreateDisplay\n");
2006 #if defined(__WIN32__) || defined(USEPBUFFER)
2007 if(!display.alphaBlend)
2010 #if defined(__WIN32__)
2011 oglDisplay.hdc = GetDC(display.window);
2012 SetPixelFormat(oglDisplay.hdc, oglSystem.format, &oglSystem.pfd);
2013 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
2015 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2016 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2020 ReleaseDC(display.window, oglDisplay.hdc);
2021 #elif defined(__unix__) || defined(__APPLE__)
2022 #if defined(__ANDROID__) || defined(__ODROID__)
2024 XVisualInfo * visualInfo = ((XWindowData)display.windowDriverData).visual;
2026 #if defined(__APPLE__)
2027 XVisualInfo template = { 0 };
2028 XWindowAttributes winAttr;
2030 XGetWindowAttributes(xGlobalDisplay, (X11Window)display.window, &winAttr);
2031 template.visualid = XVisualIDFromVisual(winAttr.visual);
2032 visualInfo = XGetVisualInfo(xGlobalDisplay, VisualIDMask, &template, &n);
2034 printf("XGetVisualInfo visual ID = %d\n", template.visualid);
2035 printf("visualInfo visual ID = %d\n", visualInfo->visualid);
2036 printf("oglSystem.visualInfo visual ID = %d\n", oglSystem.visualInfo->visualid);
2037 printf("((XWindowData)display.windowDriverData).visual visual ID = %d\n", ((XWindowData)display.windowDriverData).visual->visualid);
2039 // visualInfo = oglSystem.visualInfo;
2044 //printf("visualInfo is not null\n");
2045 // printf("Creating Display Context, sharing with %x!\n", oglSystem.glContext);
2046 oglDisplay.glContext = glXCreateContext(xGlobalDisplay, visualInfo, oglSystem.glContext, True);
2047 //XFree(visualInfo);
2050 // oglDisplay.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, oglSystem.glContext, True);
2051 if(oglDisplay.glContext)
2053 //printf("CreateDisplay Got a Context\n");
2054 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2060 #if defined(__WIN32__) || defined(USEPBUFFER)
2066 #if defined(__WIN32__)
2067 if(glBlendFuncSeparate)
2068 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2070 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2072 #if !defined(__OLDX__)
2073 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2075 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2080 glMatrixMode(GL_MODELVIEW);
2081 glLoadIdentity(); // For setting up GLES stack
2082 glScaled(1.0, 1.0, -1.0);
2083 // glTranslatef(0.375f, 0.375f, 0.0f);
2084 // glTranslatef(-0.625f, -0.625f, 0.0f);
2085 glMatrixMode(GL_PROJECTION);
2086 glShadeModel(GL_FLAT);
2088 // glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, true);
2089 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
2090 glFogi(GL_FOG_MODE, GL_EXP);
2091 glFogf(GL_FOG_DENSITY, 0);
2092 glEnable(GL_NORMALIZE);
2093 glDepthFunc(GL_LESS);
2095 glDisable(GL_MULTISAMPLE_ARB);
2097 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
2098 display.ambient = Color { 50,50,50 };
2101 if(!useSingleGLContext)
2103 #if defined(__WIN32__)
2104 wglMakeCurrent(null, null);
2105 #elif defined(__unix__) || defined(__APPLE__)
2106 #if defined(__ANDROID__) || defined(__ODROID__)
2109 glXMakeCurrent(xGlobalDisplay, None, null);
2115 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2123 bool DisplaySize(Display display, int width, int height)
2125 OGLDisplay oglDisplay = display.driverData;
2127 bool result = false;
2129 //printf("Inside DisplaySize\n");
2130 #if defined(__WIN32__) || defined(USEPBUFFER)
2131 OGLSystem oglSystem = display.displaySystem.driverData;
2132 if(display.alphaBlend)
2134 #if defined(__WIN32__)
2135 const int attributes[]=
2137 /*WGL_TEXTURE_FORMAT_ARB, WGL_TEXTURE_RGBA_ARB,
2138 WGL_TEXTURE_TARGET_ARB, WGL_TEXTURE_2D_ARB, */0
2140 int pixelFormat = 0;
2141 if(wglChoosePixelFormatARB)
2145 float fAttributes[] = {0,0};
2148 //WGL_DRAW_TO_BITMAP_ARB, GL_TRUE,
2149 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2150 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2151 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
2152 WGL_COLOR_BITS_ARB,24,
2153 WGL_ALPHA_BITS_ARB,8,
2154 WGL_DEPTH_BITS_ARB,16,
2155 WGL_STENCIL_BITS_ARB,0,
2156 WGL_DOUBLE_BUFFER_ARB,GL_FALSE,
2157 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
2158 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
2162 //Log("Found wglChoosePixelFormatARB\n");
2164 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2165 if(!valid || !numFormats)
2167 //Log("Can't find 4x multi sampling\n");
2168 iAttributes[19] = 2;
2169 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2170 if(!valid || !numFormats)
2172 // Log("Can't find 2x multi sampling\n");
2173 iAttributes[16] = 0;
2174 iAttributes[17] = 0;
2175 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2176 if(!valid || !numFormats)
2180 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2181 //WGL_DRAW_TO_BITMAP_ARB,GL_TRUE,
2182 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2183 WGL_COLOR_BITS_ARB,24,
2184 WGL_ALPHA_BITS_ARB,8,
2185 WGL_DEPTH_BITS_ARB,16,
2188 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2192 if(valid && numFormats)
2194 wglMakeCurrent(null, null);
2198 wglMakeCurrent( null, null );
2199 wglMakeCurrent( oglDisplay.hdc, oglDisplay.glrc );
2200 if(oglDisplay.hdc && oglDisplay.pBuffer)
2201 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
2203 wglDestroyPbufferARB(oglDisplay.pBuffer);
2205 if(!useSingleGLContext)
2206 wglMakeCurrent( null, null );
2209 wglDeleteContext(oglDisplay.glrc);
2211 oglDisplay.pBuffer = wglCreatePbufferARB(oglSystem.hdc, pixelFormat, width, height, attributes);
2212 oglDisplay.hdc = wglGetPbufferDCARB(oglDisplay.pBuffer);
2213 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
2216 HDC hdc = GetDC(display.window);
2218 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2219 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2221 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_WIDTH_ARB, &width);
2222 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_HEIGHT_ARB, &height);
2224 // glDeleteBuffersARB(2, oglDisplay.imageBuffers);
2226 if((info = (BITMAPINFO *)new0 byte[sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*256]))
2230 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
2231 oglDisplay.memDC = CreateCompatibleDC(hdc);
2232 SetMapMode(oglDisplay.memDC, MM_TEXT);
2233 info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2234 info->bmiHeader.biPlanes = 1;
2235 info->bmiHeader.biCompression = BI_RGB;
2236 info->bmiHeader.biBitCount = 32; //(uint16)GetDeviceCaps(hdc, BITSPIXEL);
2237 info->bmiHeader.biWidth = width;
2238 info->bmiHeader.biHeight = height;
2239 newBitmap = CreateDIBSection(hdc, info, DIB_RGB_COLORS, &oglDisplay.picture, null, 0);
2242 SelectObject(oglDisplay.memDC, newBitmap);
2243 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
2246 PIXELFORMATDESCRIPTOR pfd = { 0 };
2247 pfd.nSize = (short)sizeof(pfd);
2249 pfd.dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL;
2250 pfd.iPixelType = PFD_TYPE_RGBA;
2251 pfd.cColorBits = 32;
2252 //pfd.cAlphaBits = 8;
2253 pfd.cDepthBits = 24;
2254 pfd.iLayerType = PFD_MAIN_PLANE;
2256 oglDisplay.hdc = oglDisplay.memDC;
2258 pixelFormat = ChoosePixelFormat(oglSystem.hdc, &pfd);
2259 DescribePixelFormat(oglDisplay.hdc, pixelFormat, sizeof(pfd), &pfd);
2260 SetPixelFormat(oglDisplay.hdc, pixelFormat, &pfd);
2262 oglDisplay.glrc = wglCreateContext(oglDisplay.hdc);
2263 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2264 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2269 const int imageSize = width * height * 4;
2271 glGenBuffersARB(2, oglDisplay.imageBuffers);
2273 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2274 glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize, null, GL_STREAM_READ);
2275 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2276 // glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize / 2, null, GL_STREAM_READ);
2279 oglDisplay.memBitmap = newBitmap;
2280 oglDisplay.stride = width;
2286 ReleaseDC(display.window, hdc);
2288 #elif defined(__unix__) || defined(__APPLE__)
2289 #if defined(__ANDROID__) || defined(__ODROID__)
2294 GLX_DOUBLEBUFFER, True,
2300 GLX_STENCIL_SIZE, 1,
2301 //GLX_DEPTH_SIZE, 24,
2302 GLX_RENDER_TYPE, GLX_RGBA_BIT,
2303 GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT | GLX_WINDOW_BIT,
2309 GLX_PBUFFER_WIDTH, width,
2310 GLX_PBUFFER_HEIGHT, height,
2311 GLX_LARGEST_PBUFFER, False,
2315 // choose a pixel format that meets our minimum requirements
2318 GLXFBConfig *config = glXChooseFBConfig(xGlobalDisplay, DefaultScreen(xGlobalDisplay), attrib, &count);
2321 if(oglDisplay.pixmap)
2323 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2324 oglDisplay.pixmap = None;
2326 if(oglDisplay.shapePixmap)
2328 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
2329 oglDisplay.shapePixmap = None;
2332 // Free Shared Memory Pixmap
2333 if(oglDisplay.image)
2335 if(oglDisplay.shminfoShape.shmid != -1)
2337 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
2338 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2339 shmdt(oglDisplay.shminfo.shmaddr);
2340 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
2342 XDestroyImage(oglDisplay.image);
2343 oglDisplay.image = None;
2345 if(oglDisplay.shapeImage)
2347 if(oglDisplay.shminfoShape.shmid != -1)
2349 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
2350 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2351 shmdt(oglDisplay.shminfoShape.shmaddr);
2352 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
2354 XDestroyImage(oglDisplay.shapeImage);
2355 oglDisplay.shapeImage = None;
2358 if(oglDisplay.windowPicture)
2359 XRenderFreePicture(xGlobalDisplay, oglDisplay.windowPicture);
2360 if(oglDisplay.pixmapPicture)
2361 XRenderFreePicture(xGlobalDisplay, oglDisplay.pixmapPicture);
2363 if(oglDisplay.pixmap)
2364 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2366 if(oglDisplay.glContext)
2367 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
2368 if(oglDisplay.pBuffer)
2369 glXDestroyPbuffer(xGlobalDisplay, oglDisplay.pBuffer);
2371 oglDisplay.pBuffer = glXCreatePbuffer(xGlobalDisplay, config[0], PBattrib);
2372 if(oglDisplay.pBuffer)
2374 oglDisplay.glContext = glXCreateNewContext(xGlobalDisplay, config[0], GLX_RGBA_TYPE, oglSystem.glContext, True);
2375 if(oglDisplay.glContext)
2377 glXMakeCurrent(xGlobalDisplay, None, null);
2378 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2380 // Initialize Shared Memory Pixmap
2381 oglDisplay.image = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 32,
2382 ZPixmap, null, &oglDisplay.shminfo, width, height);
2383 if(oglDisplay.image)
2385 oglDisplay.shminfo.shmid = shmget(IPC_PRIVATE,
2386 oglDisplay.image->bytes_per_line * oglDisplay.image->height, IPC_CREAT|0777);
2387 if(oglDisplay.shminfo.shmid != -1)
2389 oglDisplay.shminfo.shmaddr = shmat(oglDisplay.shminfo.shmid, 0, 0);
2390 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2392 oglDisplay.shminfo.readOnly = False;
2393 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfo))
2395 oglDisplay.pixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfo.shmaddr,
2396 &oglDisplay.shminfo, width, height, 32);
2398 // Initialize Shared Memory Shape Pixmap
2399 oglDisplay.shapeImage = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 1,
2400 ZPixmap, null, &oglDisplay.shminfoShape, width, height);
2401 if(oglDisplay.shapeImage)
2403 oglDisplay.shminfoShape.shmid = shmget(IPC_PRIVATE,
2404 oglDisplay.shapeImage->bytes_per_line * oglDisplay.shapeImage->height, IPC_CREAT|0777);
2405 if(oglDisplay.shminfoShape.shmid != -1)
2407 oglDisplay.shminfoShape.shmaddr = shmat(oglDisplay.shminfoShape.shmid, 0, 0);
2408 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2410 oglDisplay.shminfoShape.readOnly = False;
2411 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfoShape))
2413 oglDisplay.shapePixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfoShape.shmaddr,
2414 &oglDisplay.shminfoShape, width, height, 1);
2415 //oglDisplay.shapePixmap = XCreatePixmap(xGlobalDisplay, (X11Window)display.window, width, height, 1);
2418 XRenderPictureAttributes attributes = { 0 };
2419 XRenderPictFormat * format = XRenderFindStandardFormat(xGlobalDisplay, /*PictStandardRGB24*/ PictStandardARGB32);
2420 #if !defined(__APPLE__) && !defined(__OLDX__)
2421 attributes.repeat = RepeatNormal;
2423 attributes.repeat = 1;
2425 oglDisplay.pixmapPicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.pixmap, format, CPRepeat, &attributes);
2426 oglDisplay.windowPicture = XRenderCreatePicture(xGlobalDisplay, (X11Window)display.window, format, 0, &attributes);
2427 oglDisplay.shapePicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.shapePixmap,
2428 XRenderFindStandardFormat(xGlobalDisplay, PictStandardA1), 0, &attributes);
2431 oglDisplay.picture = oglDisplay.shminfo.shmaddr;
2432 oglDisplay.stride = oglDisplay.image->bytes_per_line / 4;
2449 CreateDisplay(display);
2450 #if defined(__WIN32__)
2451 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2452 #elif defined(__unix__) || defined(__APPLE__)
2453 #if defined(__ANDROID__) || defined(__ODROID__)
2457 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2464 if(!result && display.alphaBlend)
2466 printf("Alpha blending windows not supported on this display\n");
2473 glViewport(0,0,width,height);
2474 glMatrixMode(GL_PROJECTION);
2476 glOrtho(0,width,height,0,0.0,1.0);
2477 displayWidth = display.width = width;
2478 displayHeight = display.height = height;
2480 if(!oglDisplay.flippingBuffer || oglDisplay.flipBufW < width || oglDisplay.flipBufH < height)
2482 oglDisplay.flipBufW = width;
2483 oglDisplay.flipBufH = height;
2487 oglDisplay.flippingBuffer = renew oglDisplay.flippingBuffer ColorAlpha [width * height];
2490 if(oglDisplay.flippingBuffer || !width || !height)
2496 void DisplayPosition(Display display, int x, int y)
2498 OGLDisplay oglDisplay = display.driverData;
2504 void SetPalette(Display display, ColorAlpha * palette, bool colorMatch)
2508 void RestorePalette(Display display)
2512 void StartUpdate(Display display)
2516 void EndUpdate(Display display)
2520 void Scroll(Display display, Box scroll, int x, int y, Extent dirty)
2524 void Update(Display display, Box updateBox)
2526 #if defined(__WIN32__) || defined(USEPBUFFER)
2527 OGLDisplay oglDisplay = display.driverData;
2529 //Logf("DisplayScreen\n");
2533 #if defined(__WIN32__) || defined(USEPBUFFER)
2534 if(display.alphaBlend)
2536 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2537 glPixelStorei(GL_PACK_ROW_LENGTH, oglDisplay.stride);
2538 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2539 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2540 glReadPixels(0,0,display.width,display.height,GL_BGRA_EXT,GL_UNSIGNED_BYTE, oglDisplay.picture);
2543 #if defined(__WIN32__)
2545 POINT point = { oglDisplay.x, oglDisplay.y};
2546 POINT srcPoint = { 0, 0 };
2547 BLENDFUNCTION blend = { 0 };
2549 size.cx = display.width;
2550 size.cy = display.height;
2551 blend.BlendOp = AC_SRC_OVER;
2552 blend.BlendFlags = 0;
2553 blend.SourceConstantAlpha = 255;
2554 blend.AlphaFormat = AC_SRC_ALPHA;
2557 // Process partial images. Mapping the buffer waits for
2558 // outstanding DMA transfers into the buffer to finish.
2559 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2560 oglDisplay.pboMemory1 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY);
2562 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2563 // oglDisplay.pboMemory2 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB,GL_READ_ONLY);
2566 memcpy(oglDisplay.picture, oglDisplay.pboMemory1, display.width * display.height * 4);
2567 //memcpy(oglDisplay.picture + display.width * display.height * 4 / 2, oglDisplay.pboMemory2, display.width * display.height * 4/ 2);
2570 UpdateLayeredWindow(display.window, hdc, &point, &size, oglDisplay.memDC, &srcPoint, 0, &blend, ULW_ALPHA);
2573 // Unmap the image buffers
2574 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2575 glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2577 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2578 // glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2580 // Bind two different buffer objects and start the glReadPixels
2581 // asynchronously. Each call will return directly after
2582 // starting the DMA transfer.
2583 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2584 glReadPixels(0, 0, display.width, display.height, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2586 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2587 // glReadPixels(0, display.height/2, display.width, display.height/2, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2591 #elif defined(__unix__) || defined(__APPLE__)
2592 #if defined(__ANDROID__) || defined(__ODROID__)
2594 XTransform transform =
2597 { (int)(1.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(0 * (1 << 16)) },
2598 { (int)(0.0f), (int)(-1.0f * (1<<16)), (int)(0 * (1<<16)) },
2599 { (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)) }
2602 XRenderSetPictureTransform(xGlobalDisplay, oglDisplay.pixmapPicture, &transform);
2603 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.shapePicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2604 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.windowPicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2605 #if !defined(__APPLE__) && !defined(__OLDX__)
2606 XShapeCombineMask(xGlobalDisplay, (X11Window)display.window, ShapeInput, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2608 XShapeCombineMask(xGlobalDisplay, display.window, 2, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2610 XFlush(xGlobalDisplay);
2618 #if defined(__WIN32__)
2619 //wglSwapLayerBuffers(oglDisplay.hdc,WGL_SWAP_MAIN_PLANE);
2620 SwapBuffers(oglDisplay.hdc);
2621 #elif defined(__unix__) || defined(__APPLE__)
2622 #if defined(__ANDROID__) || defined(__ODROID__)
2623 eglSwapBuffers(eglDisplay, eglSurface);
2625 glXSwapBuffers(xGlobalDisplay, (GLXDrawable)display.window);
2629 //Logf("Out of DisplayScreen\n");
2632 void FreeBitmap(DisplaySystem displaySystem, Bitmap bitmap)
2634 if(bitmap.driverData)
2636 GLuint tex = (GLuint)(uintptr)bitmap.driverData;
2637 glDeleteTextures(1, &tex);
2638 bitmap.driverData = 0;
2640 bitmap.driver = ((subclass(DisplayDriver))class(LFBDisplayDriver));
2643 bool AllocateBitmap(DisplaySystem displaySystem, Bitmap bitmap, int width, int height, int stride, PixelFormat format, bool allocatePalette)
2645 OGLSystem oglSystem = displaySystem.driverData;
2646 bool result = false;
2648 GLuint glBitmap = 0;
2650 uint w = width, h = height;
2651 if(oglSystem.pow2textures)
2656 w = Min(w, oglSystem.maxTextureSize);
2657 h = Min(h, oglSystem.maxTextureSize);
2659 glGenTextures(1, &glBitmap);
2660 glBindTexture(GL_TEXTURE_2D, glBitmap);
2662 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2664 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2665 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2667 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2668 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2670 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2672 mipMap.Allocate(null, w, h, w, pixelFormatRGBA, false);
2674 // glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2675 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2679 bitmap.driverData = (void *)(uintptr)glBitmap;
2680 bitmap.driver = displaySystem.driver;
2688 bool MakeDDBitmap(DisplaySystem displaySystem, Bitmap bitmap, bool mipMaps)
2690 bool result = false;
2691 OGLSystem oglSystem = displaySystem.driverData;
2693 // Pre process the bitmap... First make it 32 bit
2694 if(/*bitmap.pixelFormat == pixelFormatRGBA || */bitmap.Convert(null, pixelFormat888, null))
2697 uint w = bitmap.width, h = bitmap.height;
2698 GLuint glBitmap = 0;
2699 if(oglSystem.pow2textures)
2704 w = Min(w, oglSystem.maxTextureSize);
2705 h = Min(h, oglSystem.maxTextureSize);
2709 while(w * 2 < h) w *= 2;
2710 while(h * 2 < w) h *= 2;
2713 // Switch ARGB to RGBA
2714 //if(bitmap.format != pixelFormatRGBA)
2716 for(c=0; c<bitmap.size; c++)
2718 // ((ColorRGBA *)bitmap.picture)[c] = ((ColorAlpha *)bitmap.picture)[c];
2720 ColorAlpha color = ((ColorAlpha *)bitmap.picture)[c];
2721 ((ColorRGBA *)bitmap.picture)[c] = ColorRGBA { color.color.r, color.color.g, color.color.b, color.a };
2724 bitmap.pixelFormat = pixelFormat888;
2727 glGenTextures(1, &glBitmap);
2730 //int error = glGetError();
2734 glBindTexture(GL_TEXTURE_2D, glBitmap);
2735 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2737 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, mipMaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
2738 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2740 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2742 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
2743 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
2745 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2746 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2748 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2752 for(level = 0; result && (w >= 1 || h >= 1); level++, w >>= 1, h >>= 1)
2757 if(bitmap.width != w || bitmap.height != h)
2759 mipMap = Bitmap { };
2760 if(mipMap.Allocate(null, w, h, w, bitmap.pixelFormat, false))
2762 Surface mipSurface = mipMap.GetSurface(0,0,null);
2763 mipSurface.Filter(bitmap, 0,0,0,0, w, h, bitmap.width, bitmap.height);
2780 // glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2781 glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2782 //printf("Calling glTexImage2D\n");
2783 //glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &width);
2784 //printf("width = %d (Should be %d, %d)\n", width, w, h);
2785 if((error = glGetError()))
2787 //Logf("OpenGL Bitmap MakeDD error: %d...\n", error);
2788 //printf("OpenGL Bitmap MakeDD error: %d...\n", error);
2792 if(mipMap != bitmap)
2797 if(!bitmap.keepData)
2798 bitmap.driver.FreeBitmap(bitmap.displaySystem, bitmap);
2799 bitmap.driverData = (void *)(uintptr)glBitmap;
2800 bitmap.driver = displaySystem.driver;
2803 FreeBitmap(displaySystem, bitmap);
2804 else if(oglSystem.loadingFont)
2806 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2807 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2808 oglSystem.loadingFont = false;
2814 void ReleaseSurface(Display display, Surface surface)
2816 glDisable(GL_SCISSOR_TEST);
2817 delete surface.driverData;
2818 surface.driverData = null;
2821 bool GetBitmapSurface(DisplaySystem displaySystem, Surface surface, Bitmap bitmap, int x, int y, Box clip)
2826 bool GetSurface(Display display, Surface surface, int x,int y, Box clip)
2828 bool result = false;
2829 OGLSurface oglSurface = surface.driverData = OGLSurface { };
2831 //Logf("GetSurface\n");
2835 if(displayWidth != display.width || displayHeight != display.height)
2837 displayWidth = display.width;
2838 displayHeight = display.height;
2840 glViewport(0,0,display.width,display.height);
2842 glOrtho(0,display.width,display.height,0,0.0,1.0);
2845 surface.offset.x = x;
2846 surface.offset.y = y;
2847 surface.unclippedBox = surface.box = clip;
2848 oglSurface.bitmapMult[0] = 1;
2849 oglSurface.bitmapMult[1] = 1;
2850 oglSurface.bitmapMult[2] = 1;
2851 oglSurface.bitmapMult[3] = 1;
2853 glEnable(GL_SCISSOR_TEST);
2856 (display.height) -(y+clip.bottom)-1,
2857 clip.right-clip.left+1,
2858 clip.bottom-clip.top+1);
2864 void Clip(Display display, Surface surface, Box clip)
2873 box.Clip(surface.unclippedBox);
2877 box = surface.box = surface.unclippedBox;
2878 box.left += surface.offset.x;
2879 box.top += surface.offset.y;
2880 box.right+= surface.offset.x;
2881 box.bottom += surface.offset.y;
2884 box.left,display.height - box.bottom - 1,
2885 box.right-box.left+1, box.bottom-box.top+1);
2888 bool GrabScreen(Display display, Bitmap bitmap, int x, int y, unsigned int w, unsigned int h)
2890 bool result = false;
2891 OGLDisplay oglDisplay = display.driverData;
2892 ColorAlpha * flippingBuffer = oglDisplay.flippingBuffer;
2894 if(oglDisplay.flippingBuffer)
2896 if(bitmap.pixelFormat != pixelFormat888 || bitmap.width < w || bitmap.height < h)
2899 bitmap.Allocate(null, w,h,w, pixelFormat888, false);
2905 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2906 glPixelStorei(GL_PACK_ROW_LENGTH, bitmap.stride);
2907 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2908 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2909 glReadPixels(x,display.height-h-y,w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, flippingBuffer);
2912 for(row = 0; row<h; row++)
2913 CopyBytesBy4(((ColorAlpha *)bitmap.picture) + row * w, ((ColorAlpha *)flippingBuffer) + (h-row-1) * w, w);
2920 void SetForeground(Display display, Surface surface, ColorAlpha color)
2922 OGLSurface oglSurface = surface.driverData;
2924 //Logf("SetForeground\n");
2926 oglSurface.foreground[0] = color.color.r/255.0f;
2927 oglSurface.foreground[1] = color.color.g/255.0f;
2928 oglSurface.foreground[2] = color.color.b/255.0f;
2929 //oglSurface.foreground[3] = 1.0f;
2930 oglSurface.foreground[3] = color.a/255.0f;
2932 //if(!oglSurface.foreground[3])printf("bug");
2935 void SetBackground(Display display, Surface surface, ColorAlpha color)
2937 OGLSurface oglSurface = surface.driverData;
2939 //Logf("SetBackground\n");
2941 oglSurface.background[0] = color.color.r/255.0f;
2942 oglSurface.background[1] = color.color.g/255.0f;
2943 oglSurface.background[2] = color.color.b/255.0f;
2944 //oglSurface.background[3] = 1.0;
2945 oglSurface.background[3] = color.a/255.0f;
2948 void SetBlitTint(Display display, Surface surface, ColorAlpha color)
2950 OGLSurface oglSurface = surface.driverData;
2952 oglSurface.bitmapMult[0] = color.color.r/255.0f;
2953 oglSurface.bitmapMult[1] = color.color.g/255.0f;
2954 oglSurface.bitmapMult[2] = color.color.b/255.0f;
2955 oglSurface.bitmapMult[3] = color.a/255.0f;
2958 ColorAlpha GetPixel(Display display, Surface surface,int x,int y)
2963 void PutPixel(Display display, Surface surface,int x,int y)
2965 OGLSurface oglSurface = surface.driverData;
2967 //Logf("PutPixel\n");
2969 glColor4fv(oglSurface.foreground);
2971 // glVertex2i(x+surface.offset.x, y+surface.offset.y);
2972 glVertex2f(x+surface.offset.x + 0.5f, y+surface.offset.y + 0.5f);
2977 void DrawLine(Display display, Surface surface, int _x1, int _y1, int _x2, int _y2)
2979 OGLSurface oglSurface = surface.driverData;
2980 float x1 = _x1, x2 = _x2, y1 = _y1, y2 = _y2;
2995 x1 += surface.offset.x;
2996 y1 += surface.offset.y;
2997 x2 += surface.offset.x;
2998 y2 += surface.offset.y;
3002 glColor4fv(oglSurface.foreground);
3007 glTexCoord2f(0.5f, 0);
3008 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3009 glTexCoord2f(Max(x2-x1, y2-y1) + 0.5f, 0);
3010 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3019 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3020 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3026 void Rectangle(Display display, Surface surface,int x1,int y1,int x2,int y2)
3028 OGLSurface oglSurface = surface.driverData;
3029 x1 += surface.offset.x;
3030 y1 += surface.offset.y;
3031 x2 += surface.offset.x;
3032 y2 += surface.offset.y;
3034 //Logf("Rectangle\n");
3036 glColor4fv(oglSurface.foreground);
3042 glTexCoord2f(0.5f, 0);
3043 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3044 glTexCoord2f(y2-y1 + 0.5f, 0);
3045 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3047 glTexCoord2f(0.5f, 0);
3048 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3049 glTexCoord2f(x2 - x1 + 0.5f, 0);
3050 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3052 glTexCoord2f(0.5f, 0);
3053 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3054 glTexCoord2f(y1 - y2 + 0.5f, 0);
3055 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3057 glTexCoord2f(0.5f, 0);
3058 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3059 glTexCoord2f(x1 - x2 + 0.5f, 0);
3060 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3065 glBegin(GL_LINE_LOOP);
3072 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3073 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3074 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3075 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3080 void Area(Display display, Surface surface,int x1,int y1,int x2,int y2)
3082 OGLSurface oglSurface = surface.driverData;
3085 glColor4fv(oglSurface.background);
3086 glRecti(x1+surface.offset.x, y1+surface.offset.y,
3087 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
3090 glRectf(x1+surface.offset.x, y1+surface.offset.y,
3091 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
3095 void Clear(Display display, Surface surface, ClearType type)
3097 OGLDisplay oglDisplay = display.driverData;
3098 OGLSurface oglSurface = surface.driverData;
3101 if(type != depthBuffer)
3102 glClearColor(oglSurface.background[0], oglSurface.background[1], oglSurface.background[2], oglSurface.background[3]);
3103 if(type != colorBuffer && !oglDisplay.depthWrite)
3105 glDepthMask((byte)bool::true);
3107 glClear(((type != depthBuffer) ? GL_COLOR_BUFFER_BIT : 0) |
3108 ((type != colorBuffer) ? GL_DEPTH_BUFFER_BIT : 0));
3109 if(type != colorBuffer && !oglDisplay.depthWrite)
3111 glDepthMask((byte)bool::false);
3115 bool ConvertBitmap(DisplaySystem displaySystem, Bitmap bitmap, PixelFormat format, ColorAlpha * palette)
3120 void Blit(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3122 OGLSurface oglSurface = surface.driverData;
3124 #if !defined(__OLDX__)
3125 // WHY DO WE HAVE GL_ONE HERE ?
3126 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3127 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3130 if(!oglSurface.writingText)
3132 // glTranslatef(-0.375f, -0.375f, 0.0f);
3133 glEnable(GL_TEXTURE_2D);
3134 glColor4fv(oglSurface.bitmapMult);
3136 else if(oglSurface.xOffset)
3137 glTranslated(oglSurface.xOffset / 64.0/*-0.375*/, 0.0, 0.0);
3139 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3144 glTexCoord2f((float)sx/ bitmap.width, (float)(sy-h)/ bitmap.height);
3145 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3146 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy-h)/ bitmap.height);
3147 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3148 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3149 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
3150 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3151 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3156 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3157 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3158 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3159 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3160 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3161 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3162 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3163 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3166 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3167 glVertex2f((float)dx+surface.offset.x, (float)dy+surface.offset.y);
3168 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3169 glVertex2f((float)dx+w+surface.offset.x, (float)dy+surface.offset.y);
3170 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3171 glVertex2f((float)dx+w+surface.offset.x, (float)dy+h+surface.offset.y);
3172 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3173 glVertex2f((float)dx+surface.offset.x, (float)dy+h+surface.offset.y);
3177 if(!oglSurface.writingText)
3179 glDisable(GL_TEXTURE_2D);
3181 //glTranslate(0.375, 0.375, 0.0);
3183 else if(oglSurface.xOffset)
3184 glTranslated(-oglSurface.xOffset / 64.0/*+0.375*/, 0.0, 0.0);
3186 #if !defined(__OLDX__)
3187 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3188 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3192 void Stretch(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3194 OGLSurface oglSurface = surface.driverData;
3196 //glTranslate(-0.375, -0.375, 0.0);
3198 //Logf("Stretch\n");
3200 #if !defined(__OLDX__)
3201 /*if(glBlendFuncSeparate)
3202 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3205 glEnable(GL_TEXTURE_2D);
3206 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3208 glColor4fv(oglSurface.bitmapMult);
3214 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3215 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3217 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3218 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3220 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3221 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
3223 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3224 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3228 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3229 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3231 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3232 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3234 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3235 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3237 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3238 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3243 glDisable(GL_TEXTURE_2D);
3245 //glTranslate(0.375, 0.375, 0.0);
3246 #if !defined(__OLDX__)
3247 /*if(glBlendFuncSeparate)
3248 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3253 void Filter(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3255 Stretch(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3258 void StretchDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3260 float s2dw,s2dh,d2sw,d2sh;
3261 //bool flipX = false, flipY = false;
3263 //Logf("StretchDI\n");
3265 if(Sgn(w) != Sgn(sw))
3271 if(Sgn(h) != Sgn(sh))
3283 //Clip against the edges of the source
3286 dx+=(int)((0-sx) * s2dw);
3287 w-=(int)((0-sx) * s2dw);
3293 dy+=(int)((0-sy) * s2dh);
3294 h-=(int)((0-sy) * s2dh);
3299 if(sx+sw>bitmap.width-1)
3301 w-=(int)((sx+sw-(bitmap.width-1)-1)*s2dw);
3302 sw-=sx+sw-(bitmap.width-1)-1;
3304 if(sy+sh>(bitmap.height-1))
3306 h-=(int)((sy+sh-(bitmap.height-1)-1)*s2dh);
3307 sh-=sy+sh-(bitmap.height-1)-1;
3309 //Clip against the edges of the surfaceination
3310 if(dx<surface.box.left)
3313 sx+=(int)((surface.box.left-dx)*d2sw);
3314 sw-=(int)((surface.box.left-dx)*d2sw);
3315 w-=surface.box.left-dx;
3316 dx=surface.box.left;
3318 if(dy<surface.box.top)
3320 sy+=(int)((surface.box.top-dy)*d2sh);
3321 sh-=(int)((surface.box.top-dy)*d2sh);
3322 h-=surface.box.top-dy;
3325 if(dx+w>surface.box.right)
3327 //if(flip) sx+=(int)((dx+w-surface.box.right-1)*d2sw);
3328 sw-=(int)((dx+w-surface.box.right-1)*d2sw);
3329 w-=dx+w-surface.box.right-1;
3331 if(dy+h>surface.box.bottom)
3333 sh-=(int)((dy+h-surface.box.bottom-1)*d2sh);
3334 h-=dy+h-surface.box.bottom-1;
3336 if((w<=0)||(h<=0)||(sw<=0)||(sh<=0)) return;
3338 dx += surface.offset.x;
3339 dy += surface.offset.y;
3341 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3343 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3344 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3345 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3346 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3347 glRasterPos2d(dx,dy);
3348 //glPixelZoom(flipX ? -s2dw : s2dw, flipY ? s2dh : -s2dh);
3349 glPixelZoom(s2dw, -s2dh);
3350 glDrawPixels(sw,sh,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3351 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3352 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3353 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3354 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3358 void BlitDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3362 //Clip against the edges of the source
3375 if(sx+w>bitmap.width-1)
3376 w-=sx+w-(bitmap.width-1)-1;
3377 if(sy+h>bitmap.height-1)
3378 h-=sy+h-(bitmap.height-1)-1;
3379 //Clip against the edges of the surfaceination
3380 if(dx<surface.box.left)
3383 sx+=surface.box.left-dx;
3384 w-=surface.box.left-dx;
3385 dx=surface.box.left;
3387 if(dy<surface.box.top)
3389 sy+=surface.box.top-dy;
3390 h-=surface.box.top-dy;
3393 if(dx+w>surface.box.right)
3395 //if(flip) sx+=dx+w-surface.box.right-1;
3396 w-=dx+w-surface.box.right-1;
3398 if(dy+h>surface.box.bottom)
3399 h-=dy+h-surface.box.bottom-1;
3403 dx += surface.offset.x;
3404 dy += surface.offset.y;
3406 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3408 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3409 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3410 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3411 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3412 glRasterPos2d(dx,dy);
3414 glDrawPixels(w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3415 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3416 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3417 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3418 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3422 void FilterDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3424 StretchDI(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3427 void UnloadFont(DisplaySystem displaySystem, Font font)
3429 ((subclass(DisplayDriver))class(LFBDisplayDriver)).UnloadFont(displaySystem, font);
3432 Font LoadFont(DisplaySystem displaySystem, const char * faceName, float size, FontFlags flags)
3435 OGLSystem oglSystem = displaySystem.driverData;
3436 oglSystem.loadingFont = true;
3437 font = ((subclass(DisplayDriver))class(LFBDisplayDriver)).LoadFont(displaySystem, faceName, size, flags);
3441 void FontExtent(DisplaySystem displaySystem, Font font, const char * text, int len, int * width, int * height)
3443 ((subclass(DisplayDriver))class(LFBDisplayDriver)).FontExtent(displaySystem, font, text, len, width, height);
3446 void WriteText(Display display, Surface surface, int x, int y, const char * text, int len)
3448 OGLSurface oglSurface = surface.driverData;
3449 OGLSystem oglSystem = display.displaySystem.driverData;
3450 oglSystem.loadingFont = true;
3452 //glTranslated(-0.375, -0.375, 0.0);
3456 if(surface.textOpacity)
3459 FontExtent(display.displaySystem, surface.font, text, len, &w, &h);
3460 display.displaySystem.driver.Area(display, surface,x,y,x+w-1,y+h-1);
3463 oglSurface.writingText = true;
3465 glEnable(GL_TEXTURE_2D);
3466 glColor4fv(oglSurface.foreground);
3468 ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x, y, text, len);
3469 oglSurface.writingText = false;
3470 oglSystem.loadingFont = false;
3472 glDisable(GL_TEXTURE_2D);
3474 //glTranslated(0.375, 0.375, 0.0);
3477 void TextFont(Display display, Surface surface, Font font)
3479 ((subclass(DisplayDriver))class(LFBDisplayDriver)).TextFont(display, surface, font);
3482 void TextOpacity(Display display, Surface surface, bool opaque)
3484 OGLSurface oglSurface = surface.driverData;
3485 oglSurface.opaqueText = opaque;
3488 void TextExtent(Display display, Surface surface, const char * text, int len, int * width, int * height)
3490 OGLSurface oglSurface = surface.driverData;
3491 OGLSystem oglSystem = display.displaySystem.driverData;
3492 oglSystem.loadingFont = true;
3493 FontExtent(display.displaySystem, oglSurface.font, text, len, width, height);
3494 oglSystem.loadingFont = false;
3497 void DrawingChar(Display display, Surface surface, char character)
3502 void LineStipple(Display display, Surface surface, uint32 stipple)
3504 //Logf("Stipple\n");
3509 stippleEnabled = true;
3510 glesLineStipple(1, (uint16)stipple);
3512 glLineStipple(1, (uint16)stipple);
3513 glEnable(GL_LINE_STIPPLE);
3519 stippleEnabled = false;
3520 glMatrixMode(GL_TEXTURE);
3522 glMatrixMode(GL_PROJECTION);
3523 glDisable(GL_TEXTURE_2D);
3525 glDisable(GL_LINE_STIPPLE);
3529 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
3530 void SetRenderState(Display display, RenderState state, uint value)
3532 OGLDisplay oglDisplay = display.driverData;
3533 //Logf("RenderState\n");
3539 glEnable(GL_MULTISAMPLE_ARB);
3541 glDisable(GL_MULTISAMPLE_ARB);
3545 glPolygonMode(GL_FRONT_AND_BACK, ((FillModeValue)value == solid) ? GL_FILL : GL_LINE);
3549 if(value) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
3552 if(value) glDepthMask((byte)bool::true); else glDepthMask((byte)bool::false);
3553 oglDisplay.depthWrite = (bool)value;
3557 float color[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3558 glFogfv(GL_FOG_COLOR, (float *)&color);
3562 glFogf(GL_FOG_DENSITY, (float)(RenderStateFloat { ui = value }.f * nearPlane));
3565 if(value) glEnable(GL_BLEND); else glDisable(GL_BLEND);
3569 float ambient[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3570 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
3575 if(value) glColorMask(1,1,1,1); else glColorMask(1,1,1,0);
3580 #if defined(__WIN32__)
3581 wglSwapIntervalEXT(value ? 1 : 0);
3588 void SetLight(Display display, int id, Light light)
3590 //Logf("SetLight\n");
3594 Object lightObject = light.lightObject;
3595 float position[4] = { 0, 0, 0, 0 };
3596 float color[4] = { 0, 0, 0, 1 };
3598 glEnable(GL_LIGHT0 + id);
3600 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, (float *)&light.diffuse);
3601 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, (float *)&light.ambient);
3602 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,(float *)&light.specular);
3605 if(!light.multiplier) light.multiplier = 1.0f;
3607 color[0] = light.diffuse.r * light.multiplier;
3608 color[1] = light.diffuse.g * light.multiplier;
3609 color[2] = light.diffuse.b * light.multiplier;
3610 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, color);
3612 color[0] = light.ambient.r * light.multiplier;
3613 color[1] = light.ambient.g * light.multiplier;
3614 color[2] = light.ambient.b * light.multiplier;
3615 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, color);
3616 color[0] = light.specular.r * light.multiplier;
3617 color[1] = light.specular.g * light.multiplier;
3618 color[2] = light.specular.b * light.multiplier;
3619 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,color);
3623 Vector3D positionVector;
3624 if(light.flags.spot)
3626 if(lightObject.flags.root || !lightObject.parent)
3628 positionVector = lightObject.transform.position;
3629 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3633 positionVector.MultMatrix(lightObject.transform.position, lightObject.parent.matrix);
3634 if(display.display3D.camera)
3635 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3641 if(!light.direction.x && !light.direction.y && !light.direction.z)
3643 Vector3Df vector { 0,0,-1 };
3645 mat.RotationQuaternion(light.orientation);
3646 positionVector.MultMatrixf(vector, mat);
3650 positionVector = light.direction;
3655 position[0] = (float)positionVector.x;
3656 position[1] = (float)positionVector.y;
3657 position[2] = (float)positionVector.z;
3659 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3662 // Display Light Position
3663 glDisable(GL_LIGHTING);
3664 glDisable(GL_DEPTH_TEST);
3668 glVertex3fv(position);
3670 glEnable(GL_DEPTH_TEST);
3671 glEnable(GL_LIGHTING);
3675 if(lightObject.flags.root || !lightObject.parent)
3677 positionVector = light.target.transform.position;
3678 positionVector.Subtract(positionVector, display.camera.cPosition);
3682 positionVector.MultMatrix(light.target.transform.position,
3683 lightObject.light.target.parent.matrix);
3684 positionVector.Subtract(positionVector, display.camera.cPosition);
3687 position[0] = positionVector.x;
3688 position[1] = positionVector.y;
3689 position[2] = positionVector.z;
3691 glDisable(GL_LIGHTING);
3692 glDisable(GL_DEPTH_TEST);
3696 glVertex3fv(position);
3698 glEnable(GL_DEPTH_TEST);
3699 glEnable(GL_LIGHTING);
3702 if(light.flags.attenuation)
3704 glLightf(GL_LIGHT0 + id, GL_CONSTANT_ATTENUATION, light.Kc);
3705 glLightf(GL_LIGHT0 + id, GL_LINEAR_ATTENUATION, light.Kl);
3706 glLightf(GL_LIGHT0 + id, GL_QUADRATIC_ATTENUATION, light.Kq);
3709 if(light.flags.spot)
3712 #define MAXLIGHT 0.9
3713 float direction[4] = { (float)light.direction.x, (float)light.direction.y, (float)light.direction.z, 1 };
3714 // Figure out exponent out of the hot spot
3715 exponent = (float)(log(MAXLIGHT) / log(cos((light.hotSpot / 2))));
3717 glLightfv(GL_LIGHT0 + id, GL_SPOT_DIRECTION, direction);
3718 glLightf(GL_LIGHT0 + id, GL_SPOT_CUTOFF, (float)(light.fallOff / 2));
3719 glLightf(GL_LIGHT0 + id, GL_SPOT_EXPONENT, exponent);
3725 Vector3Df vector { 0,0,-1 };
3726 Vector3Df direction;
3729 mat.RotationQuaternion(light.orientation);
3730 direction.MultMatrix(vector, mat);
3732 position[0] = direction.x;
3733 position[1] = direction.y;
3734 position[2] = direction.z;
3736 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3740 glDisable(GL_LIGHT0 + id);
3743 void SetCamera(Display display, Surface surface, Camera camera)
3745 OGLDisplay oglDisplay = display.driverData;
3746 //Logf("SetCamera\n");
3750 int left = surface.box.left + surface.offset.x;
3751 int top = surface.box.top + surface.offset.y;
3752 int right = surface.box.right + surface.offset.x;
3753 int bottom = surface.box.bottom + surface.offset.y;
3754 float origX = surface.offset.x + camera.origin.x;
3755 float origY = surface.offset.y + camera.origin.y;
3757 int y = display.height - bottom - 1;
3758 int w = right - left + 1;
3759 int h = bottom - top + 1;
3762 glViewport(x, y, w, h);
3764 // *** Projection Matrix ***
3765 glMatrixMode(GL_PROJECTION);
3766 if(!display.display3D.camera)
3769 if(display.display3D.collectingHits)
3771 float pickX = display.display3D.pickX + surface.offset.x;
3772 float pickY = display.height - (display.display3D.pickY + surface.offset.y) - 1;
3776 w / display.display3D.pickWidth, 0, 0, 0,
3777 0, h / display.display3D.pickHeight, 0, 0,
3779 (w + 2.0f * (x - pickX)) / display.display3D.pickWidth,
3780 (h + 2.0f * (y - pickY)) / display.display3D.pickHeight, 0, 1
3783 glLoadMatrixd(pickMatrix.array);
3788 (left - origX) * camera.zMin / camera.focalX,
3789 (right - origX) * camera.zMin / camera.focalX,
3790 (bottom - origY) * camera.zMin / camera.focalY,
3791 (top - origY) * camera.zMin / camera.focalY,
3792 camera.zMin, camera.zMax);
3794 glDisable(GL_BLEND);
3796 // *** Z Inverted Identity Matrix ***
3797 glMatrixMode(GL_MODELVIEW);
3798 if(!display.display3D.camera)
3803 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
3805 // *** View Matrix ***
3806 glMultMatrixd(camera.viewMatrix.array);
3811 glEnable(GL_DEPTH_TEST);
3812 glEnable(GL_LIGHTING);
3813 glShadeModel(GL_SMOOTH);
3814 glDepthMask((byte)bool::true);
3815 oglDisplay.depthWrite = true;
3817 glEnable(GL_MULTISAMPLE_ARB);
3819 else if(display.display3D.camera)
3821 oglDisplay.depthWrite = false;
3822 glViewport(0,0,display.width,display.height);
3824 glDisable(GL_CULL_FACE);
3825 glDisable(GL_DEPTH_TEST);
3826 glDisable(GL_LIGHTING);
3828 glDisable(GL_TEXTURE_2D);
3829 glShadeModel(GL_FLAT);
3831 glDisable(GL_MULTISAMPLE_ARB);
3833 // *** Restore 2D MODELVIEW Matrix ***
3836 // *** Restore 2D PROJECTION Matrix ***
3837 glMatrixMode(GL_PROJECTION);
3843 void ApplyMaterial(Display display, Material material, Mesh mesh)
3845 //Logf("ApplyMaterial\n");
3848 if(material.flags.doubleSided)
3850 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, !material.flags.singleSideLight);
3851 glDisable(GL_CULL_FACE);
3855 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, bool::false);
3856 glEnable(GL_CULL_FACE);
3860 if(material.flags.noFog)
3866 if(material.baseMap && (mesh.texCoords || mesh.flags.texCoords1))
3868 Bitmap map = material.baseMap;
3869 glEnable(GL_TEXTURE_2D);
3870 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)map.driverData);
3872 glMatrixMode(GL_TEXTURE);
3874 if(material.uScale && material.vScale)
3875 glScalef(material.uScale, material.vScale, 1);
3876 glMatrixMode(GL_MODELVIEW);
3878 if(material.flags.tile)
3880 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
3881 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
3885 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
3886 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
3890 glDisable(GL_TEXTURE_2D);
3892 if(mesh.flags.colors)
3894 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
3895 glEnable(GL_COLOR_MATERIAL);
3899 glDisable(GL_COLOR_MATERIAL);
3901 float color[4] = { material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity };
3902 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
3905 float color[4] = { material.ambient.r, material.ambient.g, material.ambient.b, 0 };
3906 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
3910 float color[4] = { material.specular.r, material.specular.g, material.specular.b, 0 };
3911 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, color);
3914 float color[4] = { material.emissive.r, material.emissive.g, material.emissive.b, 0 };
3915 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, color);
3918 glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &material.power);
3921 void FreeMesh(DisplaySystem displaySystem, Mesh mesh)
3923 OGLMesh oglMesh = mesh.data;
3926 if(!mesh.flags.vertices)
3928 oglMesh.vertices.free();
3929 delete mesh.vertices;
3931 if(!mesh.flags.normals)
3933 oglMesh.normals.free();
3934 delete mesh.normals;
3936 if(!mesh.flags.texCoords1)
3938 oglMesh.texCoords.free();
3939 delete mesh.texCoords;
3941 if(!mesh.flags.texCoords2)
3943 oglMesh.texCoords2.free();
3944 // delete mesh.texCoords2;
3946 if(!mesh.flags.colors)
3948 oglMesh.colors.free();
3959 bool AllocateMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags, int nVertices)
3961 bool result = false;
3964 mesh.data = OGLMesh { };
3967 if(mesh.nVertices == nVertices)
3969 // Same number of vertices, adding features (Leaves the other features pointers alone)
3970 if(mesh.flags != flags)
3972 if(!mesh.flags.vertices && flags.vertices)
3974 if(flags.doubleVertices)
3976 mesh.vertices = (Vector3Df *)new Vector3D[nVertices];
3979 mesh.vertices = new Vector3Df[nVertices];
3981 if(!mesh.flags.normals && flags.normals)
3983 if(flags.doubleNormals)
3985 mesh.normals = (Vector3Df *)new Vector3D[nVertices];
3988 mesh.normals = new Vector3Df[nVertices];
3990 if(!mesh.flags.texCoords1 && flags.texCoords1)
3992 mesh.texCoords = new Pointf[nVertices];
3994 if(!mesh.flags.colors && flags.colors)
3996 mesh.colors = new ColorRGBAf[nVertices];
4002 // New number of vertices, reallocate all current and new features
4003 flags |= mesh.flags;
4006 if(flags.doubleVertices)
4008 mesh.vertices = (Vector3Df *)renew mesh.vertices Vector3D[nVertices];
4011 mesh.vertices = renew mesh.vertices Vector3Df[nVertices];
4015 if(flags.doubleNormals)
4017 mesh.normals = (Vector3Df *)renew mesh.normals Vector3D[nVertices];
4020 mesh.normals = renew mesh.normals Vector3Df[nVertices];
4022 if(flags.texCoords1)
4024 mesh.texCoords = renew mesh.texCoords Pointf[nVertices];
4028 mesh.colors = renew mesh.colors ColorRGBAf[nVertices];
4036 void UnlockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
4038 OGLMesh oglMesh = mesh.data;
4039 if(!flags) flags = mesh.flags;
4044 oglMesh.vertices.upload(
4045 mesh.nVertices * (mesh.flags.doubleVertices ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.vertices); //, GL_STATIC_DRAW_ARB );
4048 oglMesh.normals.upload(
4049 mesh.nVertices * (mesh.flags.doubleNormals ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.normals); //, GL_STATIC_DRAW_ARB );
4051 if(flags.texCoords1)
4052 oglMesh.texCoords.upload(
4053 mesh.nVertices * sizeof(Pointf), mesh.texCoords); //, GL_STATIC_DRAW_ARB );
4056 oglMesh.colors.upload(
4057 mesh.nVertices * sizeof(ColorRGBAf), mesh.colors); //, GL_STATIC_DRAW_ARB );
4061 bool LockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
4068 void FreeIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4072 oglIndices.buffer.free();
4073 delete oglIndices.indices;
4078 void * AllocateIndices(DisplaySystem displaySystem, int nIndices, bool indices32bit)
4080 OGLIndices oglIndices = OGLIndices { };
4083 oglIndices.indices = (void *)(indices32bit ? new uint32[nIndices] : new uint16[nIndices]);
4084 oglIndices.nIndices = nIndices;
4089 void UnlockIndices(DisplaySystem displaySystem, OGLIndices oglIndices, bool indices32bit, int nIndices)
4096 if(!oglIndices.buffer.buffer)
4097 GLGenBuffers(1, (GLAB *)&oglIndices.buffer);
4098 if(curElementBuffer != oglIndices.buffer.buffer)
4099 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, oglIndices.buffer.buffer);
4100 glesBufferDatai(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32) * nIndices, oglIndices.indices, GL_STATIC_DRAW_ARB);
4104 oglIndices.buffer.upload(
4105 nIndices * (indices32bit ? sizeof(uint32) : sizeof(uint16)),
4106 oglIndices.indices); //GL_STATIC_DRAW_ARB);
4110 uint16 * LockIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4113 return oglIndices.indices;
4116 void SelectMesh(Display display, Mesh mesh)
4118 //Logf("SelectMesh\n");
4120 #if !defined( __ANDROID__) && !defined(__APPLE__) && !defined(__ODROID__)
4122 #if defined(__WIN32__)
4123 if(glUnlockArraysEXT)
4125 if(!vboAvailable && display.display3D.mesh)
4126 glUnlockArraysEXT();
4131 OGLMesh oglMesh = mesh.data;
4133 // *** Vertex Stream ***
4134 glEnableClientState(GL_VERTEX_ARRAY);
4135 if(!display.display3D.collectingHits && oglMesh)
4137 oglMesh.vertices.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, oglMesh.vertices.buffer ? null : (double *)mesh.vertices);
4139 // *** Normals Stream ***
4140 if(mesh.normals || mesh.flags.normals)
4142 glEnableClientState(GL_NORMAL_ARRAY);
4143 oglMesh.normals.use(normal, 3, GL_FLOAT, 0, oglMesh.normals.buffer ? null : mesh.normals);
4146 glDisableClientState(GL_NORMAL_ARRAY);
4148 // *** Texture Coordinates Stream ***
4149 if(mesh.texCoords || mesh.flags.texCoords1)
4151 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4152 oglMesh.texCoords.use(texCoord, 2, GL_FLOAT, 0, oglMesh.texCoords.buffer ? null : mesh.texCoords);
4155 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4157 // *** Color Stream ***
4158 if(mesh.colors || mesh.flags.colors)
4160 glEnableClientState(GL_COLOR_ARRAY);
4161 oglMesh.colors.use(color, 4, GL_FLOAT, 0, oglMesh.colors.buffer ? null : mesh.colors);
4164 glDisableClientState(GL_COLOR_ARRAY);
4168 noAB.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, (double *)mesh.vertices);
4169 if((mesh.normals || mesh.flags.normals) && !display.display3D.collectingHits)
4171 glEnableClientState(GL_NORMAL_ARRAY);
4172 noAB.use(normal, 3, GL_FLOAT, 0, mesh.normals);
4175 glDisableClientState(GL_NORMAL_ARRAY);
4176 if((mesh.texCoords || mesh.flags.texCoords1) && !display.display3D.collectingHits)
4178 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4179 noAB.use(texCoord, 2, GL_FLOAT, 0, mesh.texCoords);
4182 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4183 if((mesh.colors || mesh.flags.colors) && !display.display3D.collectingHits)
4185 glEnableClientState(GL_COLOR_ARRAY);
4186 noAB.use(color, 4, GL_FLOAT, 0, mesh.colors);
4189 glDisableClientState(GL_COLOR_ARRAY);
4192 #if !defined(__ANDROID__) && !defined(__APPLE__) && !defined(__ODROID__)
4194 #if defined(__WIN32__)
4198 glLockArraysEXT(0, mesh.nVertices);
4204 void DrawPrimitives(Display display, PrimitiveSingle * primitive, Mesh mesh)
4206 //Logf("DrawPrimitives\n");
4208 if(primitive->type.vertexRange)
4209 glDrawArrays(primitiveTypes[primitive->type.primitiveType], primitive->first, primitive->nVertices);
4212 // *** Hoping the data won't be uploaded at all (Won't really work if another group of the mesh is using the mesh ) ***
4213 // HACK TO SPEED THINGS UP...
4215 /*GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
4216 if(primitive->nIndices < (mesh.nVertices >> 2) && !primitive->type.indices32bit)
4219 glBegin(primitiveTypes[primitive->type.primitiveType]);
4222 OGLIndices oglIndices = primitive->data;
4223 MeshFeatures flags = mesh.flags;
4224 for(c = 0; c<primitive->nIndices; c++)
4226 uint16 index = ((uint16 *) oglIndices.indices)[c];
4227 if(flags.normals) glNormal3fv((float *)&mesh.normals[index]);
4228 if(flags.texCoords1) glTexCoord2fv((float *)&mesh.texCoords[index]);
4229 if(flags.colors) glColor4fv((float *)&mesh.colors[index]);
4230 glVertex3fv((float *)&mesh.vertices[index]);
4239 OGLIndices oglIndices = primitive->data;
4240 GLEAB eab = ((!display.display3D.collectingHits && oglIndices) ? oglIndices.buffer : noEAB);
4242 eab.draw(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
4243 primitive->type.indices32bit ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT,
4244 eab.buffer ? 0 : (oglIndices ? oglIndices.indices : primitive->indices));
4245 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
4250 void PushMatrix(Display display)
4255 void PopMatrix(Display display, bool setMatrix)
4260 void SetTransform(Display display, Matrix transMatrix, bool viewSpace, bool useCamera)
4262 Matrix matrix = transMatrix;
4263 Camera camera = useCamera ? display.display3D.camera : null;
4268 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
4273 matrix.m[3][0] - camera.cPosition.x,
4274 matrix.m[3][1] - camera.cPosition.y,
4275 matrix.m[3][2] - camera.cPosition.z);
4287 glMultMatrixd(matrix.array);
4292 public void UseSingleGLContext(bool useSingle)
4294 useSingleGLContext = useSingle;
4297 default dllexport void *
4298 #if defined(__WIN32__)
4299 __attribute__((stdcall))
4301 IS_GLGetContext(DisplaySystem displaySystem)
4305 #if defined(__WIN32__)
4306 OGLSystem system = displaySystem.driverData;
4308 #elif defined(__ANDROID__) || defined(__ODROID__)
4311 OGLSystem system = displaySystem.driverData;
4312 return system.glContext;