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);
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);
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;
1454 if(buffer == curArrayBuffer)
1455 GLBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
1456 else if(buffer == curElementBuffer)
1457 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
1459 #if defined(__ANDROID__) || defined(__ODROID__)
1460 glDeleteBuffers(count, (GLuint *)buffers);
1462 #if defined(__WIN32__)
1463 if(glDeleteBuffersARB)
1465 glDeleteBuffersARB(count, (GLuint *)buffers);
1469 void GLBindBuffer(int target, uint buffer)
1471 #if defined(__ANDROID__) || defined(__ODROID__)
1472 glBindBuffer(target, buffer);
1474 #if defined(__WIN32__)
1477 glBindBufferARB(target, buffer);
1479 if(target == GL_ARRAY_BUFFER_ARB)
1480 curArrayBuffer = buffer;
1481 else if(target == GL_ELEMENT_ARRAY_BUFFER_ARB)
1482 curElementBuffer = buffer;
1485 public void GLVertexPointer(int numCoords, int glType, int stride, void *ptr, int numVertices)
1488 if(glType == GL_DOUBLE)
1489 glesVertexPointerd(numCoords, stride, ptr, numVertices);
1490 else if(glType == GL_INT)
1491 glesVertexPointeri(numCoords, stride, ptr, numVertices);
1494 glVertexPointer(numCoords, glType, stride, ptr);
1497 public void GLBufferData(int type, GLenum target, int size, const GLvoid *data, GLenum usage)
1500 if(type == GL_DOUBLE)
1501 glesBufferDatad(target, size, (void *)data, usage);
1502 else if(type == GL_UNSIGNED_INT)
1503 glesBufferDatai(target, size, (void *)data, usage);
1507 #if defined(__ANDROID__) || defined(__ODROID__)
1508 glBufferData(target, size, data, usage);
1511 #if defined(__WIN32__)
1514 glBufferDataARB(target, size, data, usage);
1518 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1519 static int primitiveTypes[RenderPrimitiveType] =
1521 GL_POINTS, GL_LINES, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP, GL_LINE_STRIP
1526 // Non OpenGL ES friendly stuff
1530 //#undef GL_UNSIGNED_INT
1535 #undef GL_QUAD_STRIP
1536 #undef GL_POLYGON_STIPPLE
1537 #undef GL_LINE_STIPPLE
1540 #undef GL_ALL_ATTRIB_BITS
1541 #undef GL_LIGHT_MODEL_LOCAL_VIEWER
1545 static int displayWidth, displayHeight;
1547 #define GL_CLAMP_TO_EDGE 0x812F
1549 static bool vboAvailable;
1551 static bool useSingleGLContext = false;
1552 class OGLDisplay : struct
1554 #if defined(__WIN32__)
1564 int imageBuffers[2];
1565 byte * pboMemory1, * pboMemory2;
1567 #elif !defined(__ANDROID__) && !defined(__ODROID__)
1568 GLXContext glContext;
1571 XShmSegmentInfo shminfo;
1573 XShmSegmentInfo shminfoShape;
1574 XImage * shapeImage;
1578 X11Picture windowPicture;
1579 X11Picture pixmapPicture;
1581 X11Picture shapePicture;
1584 ColorAlpha * flippingBuffer;
1585 int flipBufH, flipBufW;
1590 class OGLSystem : struct
1595 #if defined(__WIN32__)
1596 PIXELFORMATDESCRIPTOR pfd;
1601 #elif !defined(__ANDROID__) && !defined(__ODROID__)
1602 XVisualInfo * visualInfo;
1603 GLXContext glContext;
1604 GLXDrawable glxDrawable;
1608 class OGLSurface : struct
1615 float foreground[4], background[4], bitmapMult[4];
1618 class OGLMesh : struct
1627 class OGLIndices : struct
1637 class OpenGLDisplayDriver : DisplayDriver
1639 class_property(name) = "OpenGL";
1641 bool LockSystem(DisplaySystem displaySystem)
1643 #if !defined(__ANDROID__) && !defined(__ODROID__)
1644 OGLSystem oglSystem = displaySystem.driverData;
1645 if(useSingleGLContext) return true;
1646 #if defined(__WIN32__)
1647 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1648 #elif defined(__unix__) || defined(__APPLE__)
1649 //if(previous) return true;
1650 // printf("Making SYSTEM current\n");
1651 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)oglSystem.glxDrawable, oglSystem.glContext);
1652 //previous = oglSystem.glContext;
1658 void UnlockSystem(DisplaySystem displaySystem)
1660 if(useSingleGLContext) return;
1661 #if defined(__WIN32__)
1662 wglMakeCurrent(null, null);
1663 #elif defined(__unix__) || defined(__APPLE__)
1664 // printf("Making NULL current\n");
1665 #if defined(__ANDROID__) || defined(__ODROID__)
1667 glXMakeCurrent(xGlobalDisplay, None, null);
1673 bool Lock(Display display)
1675 #if !defined(__ANDROID__) && !defined(__ODROID__)
1676 OGLDisplay oglDisplay = display.driverData;
1677 if(useSingleGLContext) return true;
1678 #if defined(__WIN32__)
1679 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1680 #elif defined(__unix__) || defined(__APPLE__)
1681 // if(previous) glXMakeCurrent(xGlobalDisplay, None, null);
1682 // printf(" Making DISPLAY current\n");
1683 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
1689 void Unlock(Display display)
1691 if(useSingleGLContext) return;
1692 //printf(" Making NULL current\n");
1693 //glXMakeCurrent(xGlobalDisplay, None, null);
1695 LockSystem(display.displaySystem);
1698 void DestroyDisplay(Display display)
1700 OGLDisplay oglDisplay = display.driverData;
1704 #if defined(__WIN32__)
1705 wglMakeCurrent( null, null );
1708 wglDeleteContext(oglDisplay.glrc);
1710 if(oglDisplay.hdc && oglDisplay.pBuffer)
1711 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
1713 if(oglDisplay.pBuffer)
1714 wglDestroyPbufferARB(oglDisplay.pBuffer);
1717 ReleaseDC(display.window, oglDisplay.hdc);
1719 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
1720 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
1722 #elif defined(__unix__) || defined(__APPLE__)
1723 #if defined(__ANDROID__) || defined(__ODROID__)
1725 if(oglDisplay.shapePixmap)
1726 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
1727 if(oglDisplay.pixmap)
1728 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1729 if(oglDisplay.image)
1731 if(oglDisplay.shminfoShape.shmid != -1)
1733 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
1734 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1735 shmdt(oglDisplay.shminfo.shmaddr);
1736 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
1739 if(oglDisplay.shapeImage)
1741 if(oglDisplay.shminfoShape.shmid != -1)
1743 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
1744 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1745 shmdt(oglDisplay.shminfoShape.shmaddr);
1746 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
1748 XDestroyImage(oglDisplay.shapeImage);
1749 oglDisplay.shapeImage = None;
1752 glXMakeCurrent(xGlobalDisplay, None, null);
1754 if(oglDisplay.glContext)
1755 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
1758 delete oglDisplay.flippingBuffer;
1760 display.driverData = null;
1764 void ::CheckExtensions(OGLSystem oglSystem)
1766 const char * extensions = (const char *)glGetString(GL_EXTENSIONS);
1768 oglSystem.pow2textures = strstr(extensions, "GL_ARB_texture_non_power_of_two") ? false : true;
1769 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &oglSystem.maxTextureSize);
1772 bool CreateDisplaySystem(DisplaySystem displaySystem)
1774 bool result = false;
1775 OGLSystem oglSystem = displaySystem.driverData = OGLSystem { };
1778 oglSystem.hwnd = CreateWindow("static", null, 0,0,0,0,0,null,null,null,null);
1780 oglSystem.hdc = GetDC(oglSystem.hwnd);
1784 oglSystem.pfd.nSize = (short)sizeof(oglSystem.pfd);
1785 oglSystem.pfd.nVersion = 1;
1786 oglSystem.pfd.dwFlags = PFD_DRAW_TO_WINDOW /*PFD_DRAW_TO_BITMAP*/ | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
1787 oglSystem.pfd.iPixelType = PFD_TYPE_RGBA;
1788 oglSystem.pfd.cColorBits = 24;
1789 oglSystem.pfd.cAlphaBits = 8;
1790 oglSystem.pfd.cDepthBits = 24;
1791 oglSystem.pfd.iLayerType = PFD_MAIN_PLANE;
1793 oglSystem.format = ChoosePixelFormat(oglSystem.hdc, &oglSystem.pfd);
1794 DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1796 if(oglSystem.pfd.cColorBits > 8)
1798 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1799 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1802 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1804 // Get Pointers To The GL Functions
1805 glActiveTextureARB = (void *) wglGetProcAddress("glActiveTextureARB");
1806 glMultiTexCoord2fARB = (void *) wglGetProcAddress("glMultiTexCoord2fARB");
1807 glClientActiveTextureARB = (void *) wglGetProcAddress("glClientActiveTextureARB");
1808 glLockArraysEXT = (void *) wglGetProcAddress("glLockArraysEXT" );
1809 glUnlockArraysEXT = (void *) wglGetProcAddress("glUnlockArraysEXT");
1810 glGenBuffersARB = (void *) wglGetProcAddress("glGenBuffersARB");
1811 glBindBufferARB = (void *) wglGetProcAddress("glBindBufferARB");
1812 glBufferDataARB = (void *) wglGetProcAddress("glBufferDataARB");
1813 glMapBufferARB = (void *) wglGetProcAddress("glMapBufferARB");
1814 glUnmapBufferARB = (void *) wglGetProcAddress("glUnmapBufferARB");
1815 glDeleteBuffersARB = (void *) wglGetProcAddress("glDeleteBuffersARB");
1816 glBlendFuncSeparate = (void *) wglGetProcAddress("glBlendFuncSeparate");
1818 wglChoosePixelFormatARB = (void *) wglGetProcAddress("wglChoosePixelFormatARB");
1819 wglGetExtensionsStringARB = (void *)wglGetProcAddress("wglGetExtensionsStringARB");
1820 wglCreatePbufferARB = (void *)wglGetProcAddress("wglCreatePbufferARB");
1821 wglGetPbufferDCARB = (void *)wglGetProcAddress("wglGetPbufferDCARB");
1822 wglQueryPbufferARB = (void *)wglGetProcAddress("wglQueryPbufferARB");
1823 wglDestroyPbufferARB = (void *)wglGetProcAddress("wglDestroyPbufferARB");
1824 wglReleasePbufferDCARB = (void *)wglGetProcAddress("wglReleasePbufferDCARB");
1825 wglBindTexImageARB = (void *)wglGetProcAddress("wglBindTexImageARB");
1826 wglReleaseTexImageARB = (void *)wglGetProcAddress("wglReleaseTexImageARB");
1828 wglSwapIntervalEXT = (void *)wglGetProcAddress("wglSwapIntervalEXT");
1830 vboAvailable = glBindBufferARB != null;
1832 // eSystem_LoggingMode(LOG_MSGBOX, null);
1834 if(wglChoosePixelFormatARB)
1839 float fAttributes[] = {0,0};
1842 WGL_DRAW_TO_WINDOW_ARB,GL_TRUE,
1843 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1844 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
1845 WGL_COLOR_BITS_ARB,24,
1846 WGL_ALPHA_BITS_ARB,8,
1847 WGL_DEPTH_BITS_ARB,16,
1848 WGL_STENCIL_BITS_ARB,0,
1849 WGL_DOUBLE_BUFFER_ARB,GL_TRUE,
1850 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
1851 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
1855 //Log("Found wglChoosePixelFormatARB\n");
1857 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1858 if(!valid || !numFormats)
1860 //Log("Can't find 4x multi sampling\n");
1861 iAttributes[19] = 2;
1862 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1863 if(!valid || !numFormats)
1865 // Log("Can't find 2x multi sampling\n");
1866 iAttributes[16] = 0;
1867 iAttributes[17] = 0;
1868 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1871 if(valid && numFormats)
1873 oglSystem.format = pixelFormat;
1874 wglMakeCurrent(null, null);
1875 wglDeleteContext(oglSystem.glrc);
1877 // *** DescribePixelFormat does not support WGL pixel formats! ***
1878 //DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1879 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1880 //Log("Successfully set pixel format\n");
1882 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1883 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1887 eSystem_Logf("Can't find wglChoosePixelFormatARB\n");*/
1891 CheckExtensions(oglSystem);
1893 wglMakeCurrent(null, null);
1895 //eSystem_DumpErrors(true);
1899 #elif defined(__unix__) || defined(__APPLE__)
1900 vboAvailable = true;
1901 #if defined(__ANDROID__)
1902 egl_init_display(guiApp.desktop.windowHandle);
1903 #elif defined(__ODROID__)
1904 egl_init_display((uint)displaySystem.window);
1905 CheckExtensions(oglSystem);
1909 X11Window root = RootWindow( xGlobalDisplay, DefaultScreen( xGlobalDisplay ) );
1910 XSetWindowAttributes attr;
1915 #ifndef ECERE_MINIGLX
1916 GLX_USE_GL, GLX_DEPTH_SIZE, 1,
1919 GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,
1923 oglSystem.visualInfo = glXChooseVisual( xGlobalDisplay, DefaultScreen( xGlobalDisplay ), attrList );
1924 attr.background_pixel = 0;
1925 attr.border_pixel = 0;
1926 attr.colormap = XCreateColormap( xGlobalDisplay, root, oglSystem.visualInfo->visual, AllocNone);
1927 attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
1928 mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
1930 oglSystem.glxDrawable = XCreateWindow( xGlobalDisplay, root, 0, 0, 1, 1, 0, oglSystem.visualInfo->depth, InputOutput,
1931 oglSystem.visualInfo->visual, mask, &attr );
1933 if(oglSystem.visualInfo)
1935 oglSystem.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, null, True);
1936 if(oglSystem.glContext)
1938 glXMakeCurrent(xGlobalDisplay, oglSystem.glxDrawable, oglSystem.glContext);
1940 CheckExtensions(oglSystem);
1941 glXMakeCurrent(xGlobalDisplay, None, null);
1948 displaySystem.flags.alpha = true;
1949 displaySystem.flags.flipping = true;
1950 displaySystem.pixelFormat = pixelFormat888;
1954 void DestroyDisplaySystem(DisplaySystem displaySystem)
1956 OGLSystem oglSystem = displaySystem.driverData;
1958 #if defined(__WIN32__)
1959 wglMakeCurrent( null, null );
1962 wglDeleteContext(oglSystem.glrc);
1965 ReleaseDC(oglSystem.hwnd, oglSystem.hdc);
1966 DestroyWindow(oglSystem.hwnd);
1968 #elif defined(__unix__) || defined(__APPLE__)
1969 #if defined(__ANDROID__) || defined(__ODROID__)
1972 if(oglSystem.visualInfo)
1974 #ifdef ECERE_MINIGLX
1975 __miniglx_XFree(oglSystem.visualInfo);
1977 XFree(oglSystem.visualInfo);
1981 if(oglSystem.glxDrawable)
1983 XDestroyWindow(xGlobalDisplay, oglSystem.glxDrawable);
1984 oglSystem.glxDrawable = 0;
1991 bool CreateDisplay(Display display)
1993 bool result = false;
1994 OGLDisplay oglDisplay = display.driverData;
1995 #if !defined(__ANDROID__) && !defined(__ODROID__)
1996 OGLSystem oglSystem = display.displaySystem.driverData;
1999 oglDisplay = display.driverData = OGLDisplay { };
2000 //printf("Inside CreateDisplay\n");
2002 #if defined(__WIN32__) || defined(USEPBUFFER)
2003 if(!display.alphaBlend)
2006 #if defined(__WIN32__)
2007 oglDisplay.hdc = GetDC(display.window);
2008 SetPixelFormat(oglDisplay.hdc, oglSystem.format, &oglSystem.pfd);
2009 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
2011 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2012 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2016 ReleaseDC(display.window, oglDisplay.hdc);
2017 #elif defined(__unix__) || defined(__APPLE__)
2018 #if defined(__ANDROID__) || defined(__ODROID__)
2020 XVisualInfo * visualInfo = ((XWindowData)display.windowDriverData).visual;
2022 #if defined(__APPLE__)
2023 XVisualInfo template = { 0 };
2024 XWindowAttributes winAttr;
2026 XGetWindowAttributes(xGlobalDisplay, (X11Window)display.window, &winAttr);
2027 template.visualid = XVisualIDFromVisual(winAttr.visual);
2028 visualInfo = XGetVisualInfo(xGlobalDisplay, VisualIDMask, &template, &n);
2030 printf("XGetVisualInfo visual ID = %d\n", template.visualid);
2031 printf("visualInfo visual ID = %d\n", visualInfo->visualid);
2032 printf("oglSystem.visualInfo visual ID = %d\n", oglSystem.visualInfo->visualid);
2033 printf("((XWindowData)display.windowDriverData).visual visual ID = %d\n", ((XWindowData)display.windowDriverData).visual->visualid);
2035 // visualInfo = oglSystem.visualInfo;
2040 //printf("visualInfo is not null\n");
2041 // printf("Creating Display Context, sharing with %x!\n", oglSystem.glContext);
2042 oglDisplay.glContext = glXCreateContext(xGlobalDisplay, visualInfo, oglSystem.glContext, True);
2043 //XFree(visualInfo);
2046 // oglDisplay.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, oglSystem.glContext, True);
2047 if(oglDisplay.glContext)
2049 //printf("CreateDisplay Got a Context\n");
2050 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2056 #if defined(__WIN32__) || defined(USEPBUFFER)
2062 #if defined(__WIN32__)
2063 if(glBlendFuncSeparate)
2064 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2066 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2068 #if !defined(__OLDX__)
2069 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2071 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2076 glMatrixMode(GL_MODELVIEW);
2077 glLoadIdentity(); // For setting up GLES stack
2078 glScaled(1.0, 1.0, -1.0);
2079 // glTranslatef(0.375f, 0.375f, 0.0f);
2080 // glTranslatef(-0.625f, -0.625f, 0.0f);
2081 glMatrixMode(GL_PROJECTION);
2082 glShadeModel(GL_FLAT);
2084 // glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, true);
2085 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
2086 glFogi(GL_FOG_MODE, GL_EXP);
2087 glFogf(GL_FOG_DENSITY, 0);
2088 glEnable(GL_NORMALIZE);
2089 glDepthFunc(GL_LESS);
2091 glDisable(GL_MULTISAMPLE_ARB);
2093 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
2094 display.ambient = Color { 50,50,50 };
2097 if(!useSingleGLContext)
2099 #if defined(__WIN32__)
2100 wglMakeCurrent(null, null);
2101 #elif defined(__unix__) || defined(__APPLE__)
2102 #if defined(__ANDROID__) || defined(__ODROID__)
2105 glXMakeCurrent(xGlobalDisplay, None, null);
2111 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2119 bool DisplaySize(Display display, int width, int height)
2121 OGLDisplay oglDisplay = display.driverData;
2123 bool result = false;
2125 //printf("Inside DisplaySize\n");
2126 #if defined(__WIN32__) || defined(USEPBUFFER)
2127 OGLSystem oglSystem = display.displaySystem.driverData;
2128 if(display.alphaBlend)
2130 #if defined(__WIN32__)
2131 const int attributes[]=
2133 /*WGL_TEXTURE_FORMAT_ARB, WGL_TEXTURE_RGBA_ARB,
2134 WGL_TEXTURE_TARGET_ARB, WGL_TEXTURE_2D_ARB, */0
2136 int pixelFormat = 0;
2137 if(wglChoosePixelFormatARB)
2141 float fAttributes[] = {0,0};
2144 //WGL_DRAW_TO_BITMAP_ARB, GL_TRUE,
2145 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2146 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2147 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
2148 WGL_COLOR_BITS_ARB,24,
2149 WGL_ALPHA_BITS_ARB,8,
2150 WGL_DEPTH_BITS_ARB,16,
2151 WGL_STENCIL_BITS_ARB,0,
2152 WGL_DOUBLE_BUFFER_ARB,GL_FALSE,
2153 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
2154 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
2158 //Log("Found wglChoosePixelFormatARB\n");
2160 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2161 if(!valid || !numFormats)
2163 //Log("Can't find 4x multi sampling\n");
2164 iAttributes[19] = 2;
2165 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2166 if(!valid || !numFormats)
2168 // Log("Can't find 2x multi sampling\n");
2169 iAttributes[16] = 0;
2170 iAttributes[17] = 0;
2171 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2172 if(!valid || !numFormats)
2176 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2177 //WGL_DRAW_TO_BITMAP_ARB,GL_TRUE,
2178 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2179 WGL_COLOR_BITS_ARB,24,
2180 WGL_ALPHA_BITS_ARB,8,
2181 WGL_DEPTH_BITS_ARB,16,
2184 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2188 if(valid && numFormats)
2190 wglMakeCurrent(null, null);
2194 wglMakeCurrent( null, null );
2195 wglMakeCurrent( oglDisplay.hdc, oglDisplay.glrc );
2196 if(oglDisplay.hdc && oglDisplay.pBuffer)
2197 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
2199 wglDestroyPbufferARB(oglDisplay.pBuffer);
2201 if(!useSingleGLContext)
2202 wglMakeCurrent( null, null );
2205 wglDeleteContext(oglDisplay.glrc);
2207 oglDisplay.pBuffer = wglCreatePbufferARB(oglSystem.hdc, pixelFormat, width, height, attributes);
2208 oglDisplay.hdc = wglGetPbufferDCARB(oglDisplay.pBuffer);
2209 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
2212 HDC hdc = GetDC(display.window);
2214 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2215 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2217 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_WIDTH_ARB, &width);
2218 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_HEIGHT_ARB, &height);
2220 // glDeleteBuffersARB(2, oglDisplay.imageBuffers);
2222 if((info = (BITMAPINFO *)new0 byte[sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*256]))
2226 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
2227 oglDisplay.memDC = CreateCompatibleDC(hdc);
2228 SetMapMode(oglDisplay.memDC, MM_TEXT);
2229 info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2230 info->bmiHeader.biPlanes = 1;
2231 info->bmiHeader.biCompression = BI_RGB;
2232 info->bmiHeader.biBitCount = 32; //(uint16)GetDeviceCaps(hdc, BITSPIXEL);
2233 info->bmiHeader.biWidth = width;
2234 info->bmiHeader.biHeight = height;
2235 newBitmap = CreateDIBSection(hdc, info, DIB_RGB_COLORS, &oglDisplay.picture, null, 0);
2238 SelectObject(oglDisplay.memDC, newBitmap);
2239 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
2242 PIXELFORMATDESCRIPTOR pfd = { 0 };
2243 pfd.nSize = (short)sizeof(pfd);
2245 pfd.dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL;
2246 pfd.iPixelType = PFD_TYPE_RGBA;
2247 pfd.cColorBits = 32;
2248 //pfd.cAlphaBits = 8;
2249 pfd.cDepthBits = 24;
2250 pfd.iLayerType = PFD_MAIN_PLANE;
2252 oglDisplay.hdc = oglDisplay.memDC;
2254 pixelFormat = ChoosePixelFormat(oglSystem.hdc, &pfd);
2255 DescribePixelFormat(oglDisplay.hdc, pixelFormat, sizeof(pfd), &pfd);
2256 SetPixelFormat(oglDisplay.hdc, pixelFormat, &pfd);
2258 oglDisplay.glrc = wglCreateContext(oglDisplay.hdc);
2259 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2260 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2265 const int imageSize = width * height * 4;
2267 glGenBuffersARB(2, oglDisplay.imageBuffers);
2269 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2270 glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize, null, GL_STREAM_READ);
2271 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2272 // glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize / 2, null, GL_STREAM_READ);
2275 oglDisplay.memBitmap = newBitmap;
2276 oglDisplay.stride = width;
2282 ReleaseDC(display.window, hdc);
2284 #elif defined(__unix__) || defined(__APPLE__)
2285 #if defined(__ANDROID__) || defined(__ODROID__)
2290 GLX_DOUBLEBUFFER, True,
2296 GLX_STENCIL_SIZE, 1,
2297 //GLX_DEPTH_SIZE, 24,
2298 GLX_RENDER_TYPE, GLX_RGBA_BIT,
2299 GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT | GLX_WINDOW_BIT,
2305 GLX_PBUFFER_WIDTH, width,
2306 GLX_PBUFFER_HEIGHT, height,
2307 GLX_LARGEST_PBUFFER, False,
2311 // choose a pixel format that meets our minimum requirements
2314 GLXFBConfig *config = glXChooseFBConfig(xGlobalDisplay, DefaultScreen(xGlobalDisplay), attrib, &count);
2317 if(oglDisplay.pixmap)
2319 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2320 oglDisplay.pixmap = None;
2322 if(oglDisplay.shapePixmap)
2324 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
2325 oglDisplay.shapePixmap = None;
2328 // Free Shared Memory Pixmap
2329 if(oglDisplay.image)
2331 if(oglDisplay.shminfoShape.shmid != -1)
2333 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
2334 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2335 shmdt(oglDisplay.shminfo.shmaddr);
2336 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
2338 XDestroyImage(oglDisplay.image);
2339 oglDisplay.image = None;
2341 if(oglDisplay.shapeImage)
2343 if(oglDisplay.shminfoShape.shmid != -1)
2345 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
2346 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2347 shmdt(oglDisplay.shminfoShape.shmaddr);
2348 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
2350 XDestroyImage(oglDisplay.shapeImage);
2351 oglDisplay.shapeImage = None;
2354 if(oglDisplay.windowPicture)
2355 XRenderFreePicture(xGlobalDisplay, oglDisplay.windowPicture);
2356 if(oglDisplay.pixmapPicture)
2357 XRenderFreePicture(xGlobalDisplay, oglDisplay.pixmapPicture);
2359 if(oglDisplay.pixmap)
2360 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2362 if(oglDisplay.glContext)
2363 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
2364 if(oglDisplay.pBuffer)
2365 glXDestroyPbuffer(xGlobalDisplay, oglDisplay.pBuffer);
2367 oglDisplay.pBuffer = glXCreatePbuffer(xGlobalDisplay, config[0], PBattrib);
2368 if(oglDisplay.pBuffer)
2370 oglDisplay.glContext = glXCreateNewContext(xGlobalDisplay, config[0], GLX_RGBA_TYPE, oglSystem.glContext, True);
2371 if(oglDisplay.glContext)
2373 glXMakeCurrent(xGlobalDisplay, None, null);
2374 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2376 // Initialize Shared Memory Pixmap
2377 oglDisplay.image = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 32,
2378 ZPixmap, null, &oglDisplay.shminfo, width, height);
2379 if(oglDisplay.image)
2381 oglDisplay.shminfo.shmid = shmget(IPC_PRIVATE,
2382 oglDisplay.image->bytes_per_line * oglDisplay.image->height, IPC_CREAT|0777);
2383 if(oglDisplay.shminfo.shmid != -1)
2385 oglDisplay.shminfo.shmaddr = shmat(oglDisplay.shminfo.shmid, 0, 0);
2386 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2388 oglDisplay.shminfo.readOnly = False;
2389 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfo))
2391 oglDisplay.pixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfo.shmaddr,
2392 &oglDisplay.shminfo, width, height, 32);
2394 // Initialize Shared Memory Shape Pixmap
2395 oglDisplay.shapeImage = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 1,
2396 ZPixmap, null, &oglDisplay.shminfoShape, width, height);
2397 if(oglDisplay.shapeImage)
2399 oglDisplay.shminfoShape.shmid = shmget(IPC_PRIVATE,
2400 oglDisplay.shapeImage->bytes_per_line * oglDisplay.shapeImage->height, IPC_CREAT|0777);
2401 if(oglDisplay.shminfoShape.shmid != -1)
2403 oglDisplay.shminfoShape.shmaddr = shmat(oglDisplay.shminfoShape.shmid, 0, 0);
2404 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2406 oglDisplay.shminfoShape.readOnly = False;
2407 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfoShape))
2409 oglDisplay.shapePixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfoShape.shmaddr,
2410 &oglDisplay.shminfoShape, width, height, 1);
2411 //oglDisplay.shapePixmap = XCreatePixmap(xGlobalDisplay, (X11Window)display.window, width, height, 1);
2414 XRenderPictureAttributes attributes = { 0 };
2415 XRenderPictFormat * format = XRenderFindStandardFormat(xGlobalDisplay, /*PictStandardRGB24*/ PictStandardARGB32);
2416 #if !defined(__APPLE__) && !defined(__OLDX__)
2417 attributes.repeat = RepeatNormal;
2419 attributes.repeat = 1;
2421 oglDisplay.pixmapPicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.pixmap, format, CPRepeat, &attributes);
2422 oglDisplay.windowPicture = XRenderCreatePicture(xGlobalDisplay, (X11Window)display.window, format, 0, &attributes);
2423 oglDisplay.shapePicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.shapePixmap,
2424 XRenderFindStandardFormat(xGlobalDisplay, PictStandardA1), 0, &attributes);
2427 oglDisplay.picture = oglDisplay.shminfo.shmaddr;
2428 oglDisplay.stride = oglDisplay.image->bytes_per_line / 4;
2445 CreateDisplay(display);
2446 #if defined(__WIN32__)
2447 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2448 #elif defined(__unix__) || defined(__APPLE__)
2449 #if defined(__ANDROID__) || defined(__ODROID__)
2453 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2460 if(!result && display.alphaBlend)
2462 printf("Alpha blending windows not supported on this display\n");
2469 glViewport(0,0,width,height);
2470 glMatrixMode(GL_PROJECTION);
2472 glOrtho(0,width,height,0,0.0,1.0);
2473 displayWidth = display.width = width;
2474 displayHeight = display.height = height;
2476 if(!oglDisplay.flippingBuffer || oglDisplay.flipBufW < width || oglDisplay.flipBufH < height)
2478 oglDisplay.flipBufW = width;
2479 oglDisplay.flipBufH = height;
2483 oglDisplay.flippingBuffer = renew oglDisplay.flippingBuffer ColorAlpha [width * height];
2486 if(oglDisplay.flippingBuffer || !width || !height)
2492 void DisplayPosition(Display display, int x, int y)
2494 OGLDisplay oglDisplay = display.driverData;
2500 void SetPalette(Display display, ColorAlpha * palette, bool colorMatch)
2504 void RestorePalette(Display display)
2508 void StartUpdate(Display display)
2512 void EndUpdate(Display display)
2516 void Scroll(Display display, Box scroll, int x, int y, Extent dirty)
2520 void Update(Display display, Box updateBox)
2522 #if defined(__WIN32__) || defined(USEPBUFFER)
2523 OGLDisplay oglDisplay = display.driverData;
2525 //Logf("DisplayScreen\n");
2529 #if defined(__WIN32__) || defined(USEPBUFFER)
2530 if(display.alphaBlend)
2532 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2533 glPixelStorei(GL_PACK_ROW_LENGTH, oglDisplay.stride);
2534 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2535 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2536 glReadPixels(0,0,display.width,display.height,GL_BGRA_EXT,GL_UNSIGNED_BYTE, oglDisplay.picture);
2539 #if defined(__WIN32__)
2541 POINT point = { oglDisplay.x, oglDisplay.y};
2542 POINT srcPoint = { 0, 0 };
2543 BLENDFUNCTION blend = { 0 };
2545 size.cx = display.width;
2546 size.cy = display.height;
2547 blend.BlendOp = AC_SRC_OVER;
2548 blend.BlendFlags = 0;
2549 blend.SourceConstantAlpha = 255;
2550 blend.AlphaFormat = AC_SRC_ALPHA;
2553 // Process partial images. Mapping the buffer waits for
2554 // outstanding DMA transfers into the buffer to finish.
2555 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2556 oglDisplay.pboMemory1 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY);
2558 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2559 // oglDisplay.pboMemory2 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB,GL_READ_ONLY);
2562 memcpy(oglDisplay.picture, oglDisplay.pboMemory1, display.width * display.height * 4);
2563 //memcpy(oglDisplay.picture + display.width * display.height * 4 / 2, oglDisplay.pboMemory2, display.width * display.height * 4/ 2);
2566 UpdateLayeredWindow(display.window, hdc, &point, &size, oglDisplay.memDC, &srcPoint, 0, &blend, ULW_ALPHA);
2569 // Unmap the image buffers
2570 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2571 glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2573 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2574 // glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2576 // Bind two different buffer objects and start the glReadPixels
2577 // asynchronously. Each call will return directly after
2578 // starting the DMA transfer.
2579 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2580 glReadPixels(0, 0, display.width, display.height, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2582 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2583 // glReadPixels(0, display.height/2, display.width, display.height/2, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2587 #elif defined(__unix__) || defined(__APPLE__)
2588 #if defined(__ANDROID__) || defined(__ODROID__)
2590 XTransform transform =
2593 { (int)(1.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(0 * (1 << 16)) },
2594 { (int)(0.0f), (int)(-1.0f * (1<<16)), (int)(0 * (1<<16)) },
2595 { (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)) }
2598 XRenderSetPictureTransform(xGlobalDisplay, oglDisplay.pixmapPicture, &transform);
2599 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.shapePicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2600 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.windowPicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2601 #if !defined(__APPLE__) && !defined(__OLDX__)
2602 XShapeCombineMask(xGlobalDisplay, (X11Window)display.window, ShapeInput, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2604 XShapeCombineMask(xGlobalDisplay, display.window, 2, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2606 XFlush(xGlobalDisplay);
2614 #if defined(__WIN32__)
2615 //wglSwapLayerBuffers(oglDisplay.hdc,WGL_SWAP_MAIN_PLANE);
2616 SwapBuffers(oglDisplay.hdc);
2617 #elif defined(__unix__) || defined(__APPLE__)
2618 #if defined(__ANDROID__) || defined(__ODROID__)
2619 eglSwapBuffers(eglDisplay, eglSurface);
2621 glXSwapBuffers(xGlobalDisplay, (GLXDrawable)display.window);
2625 //Logf("Out of DisplayScreen\n");
2628 void FreeBitmap(DisplaySystem displaySystem, Bitmap bitmap)
2630 if(bitmap.driverData)
2632 GLuint tex = (GLuint)(uintptr)bitmap.driverData;
2633 glDeleteTextures(1, &tex);
2634 bitmap.driverData = 0;
2636 bitmap.driver = ((subclass(DisplayDriver))class(LFBDisplayDriver));
2639 bool AllocateBitmap(DisplaySystem displaySystem, Bitmap bitmap, int width, int height, int stride, PixelFormat format, bool allocatePalette)
2641 OGLSystem oglSystem = displaySystem.driverData;
2642 bool result = false;
2644 GLuint glBitmap = 0;
2646 uint w = width, h = height;
2647 if(oglSystem.pow2textures)
2652 w = Min(w, oglSystem.maxTextureSize);
2653 h = Min(h, oglSystem.maxTextureSize);
2655 glGenTextures(1, &glBitmap);
2656 glBindTexture(GL_TEXTURE_2D, glBitmap);
2658 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2660 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2661 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2663 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2664 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2666 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2668 mipMap.Allocate(null, w, h, w, pixelFormatRGBA, false);
2670 // glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2671 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2675 bitmap.driverData = (void *)(uintptr)glBitmap;
2676 bitmap.driver = displaySystem.driver;
2684 bool MakeDDBitmap(DisplaySystem displaySystem, Bitmap bitmap, bool mipMaps)
2686 bool result = false;
2687 OGLSystem oglSystem = displaySystem.driverData;
2689 // Pre process the bitmap... First make it 32 bit
2690 if(/*bitmap.pixelFormat == pixelFormatRGBA || */bitmap.Convert(null, pixelFormat888, null))
2693 uint w = bitmap.width, h = bitmap.height;
2694 GLuint glBitmap = 0;
2695 if(oglSystem.pow2textures)
2700 w = Min(w, oglSystem.maxTextureSize);
2701 h = Min(h, oglSystem.maxTextureSize);
2705 while(w * 2 < h) w *= 2;
2706 while(h * 2 < w) h *= 2;
2709 // Switch ARGB to RGBA
2710 //if(bitmap.format != pixelFormatRGBA)
2712 for(c=0; c<bitmap.size; c++)
2714 // ((ColorRGBA *)bitmap.picture)[c] = ((ColorAlpha *)bitmap.picture)[c];
2716 ColorAlpha color = ((ColorAlpha *)bitmap.picture)[c];
2717 ((ColorRGBA *)bitmap.picture)[c] = ColorRGBA { color.color.r, color.color.g, color.color.b, color.a };
2720 bitmap.pixelFormat = pixelFormat888;
2723 glGenTextures(1, &glBitmap);
2726 //int error = glGetError();
2730 glBindTexture(GL_TEXTURE_2D, glBitmap);
2731 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2733 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, mipMaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
2734 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2736 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2738 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
2739 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
2741 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2742 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2744 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2748 for(level = 0; result && (w >= 1 || h >= 1); level++, w >>= 1, h >>= 1)
2753 if(bitmap.width != w || bitmap.height != h)
2755 mipMap = Bitmap { };
2756 if(mipMap.Allocate(null, w, h, w, bitmap.pixelFormat, false))
2758 Surface mipSurface = mipMap.GetSurface(0,0,null);
2759 mipSurface.Filter(bitmap, 0,0,0,0, w, h, bitmap.width, bitmap.height);
2776 // glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2777 glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2778 //printf("Calling glTexImage2D\n");
2779 //glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &width);
2780 //printf("width = %d (Should be %d, %d)\n", width, w, h);
2781 if((error = glGetError()))
2783 //Logf("OpenGL Bitmap MakeDD error: %d...\n", error);
2784 //printf("OpenGL Bitmap MakeDD error: %d...\n", error);
2788 if(mipMap != bitmap)
2793 if(!bitmap.keepData)
2794 bitmap.driver.FreeBitmap(bitmap.displaySystem, bitmap);
2795 bitmap.driverData = (void *)(uintptr)glBitmap;
2796 bitmap.driver = displaySystem.driver;
2799 FreeBitmap(displaySystem, bitmap);
2800 else if(oglSystem.loadingFont)
2802 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2803 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2804 oglSystem.loadingFont = false;
2810 void ReleaseSurface(Display display, Surface surface)
2812 glDisable(GL_SCISSOR_TEST);
2813 delete surface.driverData;
2814 surface.driverData = null;
2817 bool GetBitmapSurface(DisplaySystem displaySystem, Surface surface, Bitmap bitmap, int x, int y, Box clip)
2822 bool GetSurface(Display display, Surface surface, int x,int y, Box clip)
2824 bool result = false;
2825 OGLSurface oglSurface = surface.driverData = OGLSurface { };
2827 //Logf("GetSurface\n");
2831 if(displayWidth != display.width || displayHeight != display.height)
2833 displayWidth = display.width;
2834 displayHeight = display.height;
2836 glViewport(0,0,display.width,display.height);
2838 glOrtho(0,display.width,display.height,0,0.0,1.0);
2841 surface.offset.x = x;
2842 surface.offset.y = y;
2843 surface.unclippedBox = surface.box = clip;
2844 oglSurface.bitmapMult[0] = 1;
2845 oglSurface.bitmapMult[1] = 1;
2846 oglSurface.bitmapMult[2] = 1;
2847 oglSurface.bitmapMult[3] = 1;
2849 glEnable(GL_SCISSOR_TEST);
2852 (display.height) -(y+clip.bottom)-1,
2853 clip.right-clip.left+1,
2854 clip.bottom-clip.top+1);
2860 void Clip(Display display, Surface surface, Box clip)
2869 box.Clip(surface.unclippedBox);
2873 box = surface.box = surface.unclippedBox;
2874 box.left += surface.offset.x;
2875 box.top += surface.offset.y;
2876 box.right+= surface.offset.x;
2877 box.bottom += surface.offset.y;
2880 box.left,display.height - box.bottom - 1,
2881 box.right-box.left+1, box.bottom-box.top+1);
2884 bool GrabScreen(Display display, Bitmap bitmap, int x, int y, unsigned int w, unsigned int h)
2886 bool result = false;
2887 OGLDisplay oglDisplay = display.driverData;
2888 ColorAlpha * flippingBuffer = oglDisplay.flippingBuffer;
2890 if(oglDisplay.flippingBuffer)
2892 if(bitmap.pixelFormat != pixelFormat888 || bitmap.width < w || bitmap.height < h)
2895 bitmap.Allocate(null, w,h,w, pixelFormat888, false);
2901 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2902 glPixelStorei(GL_PACK_ROW_LENGTH, bitmap.stride);
2903 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2904 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2905 glReadPixels(x,display.height-h-y,w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, flippingBuffer);
2908 for(row = 0; row<h; row++)
2909 CopyBytesBy4(((ColorAlpha *)bitmap.picture) + row * w, ((ColorAlpha *)flippingBuffer) + (h-row-1) * w, w);
2916 void SetForeground(Display display, Surface surface, ColorAlpha color)
2918 OGLSurface oglSurface = surface.driverData;
2920 //Logf("SetForeground\n");
2922 oglSurface.foreground[0] = color.color.r/255.0f;
2923 oglSurface.foreground[1] = color.color.g/255.0f;
2924 oglSurface.foreground[2] = color.color.b/255.0f;
2925 //oglSurface.foreground[3] = 1.0f;
2926 oglSurface.foreground[3] = color.a/255.0f;
2928 //if(!oglSurface.foreground[3])printf("bug");
2931 void SetBackground(Display display, Surface surface, ColorAlpha color)
2933 OGLSurface oglSurface = surface.driverData;
2935 //Logf("SetBackground\n");
2937 oglSurface.background[0] = color.color.r/255.0f;
2938 oglSurface.background[1] = color.color.g/255.0f;
2939 oglSurface.background[2] = color.color.b/255.0f;
2940 //oglSurface.background[3] = 1.0;
2941 oglSurface.background[3] = color.a/255.0f;
2944 void SetBlitTint(Display display, Surface surface, ColorAlpha color)
2946 OGLSurface oglSurface = surface.driverData;
2948 oglSurface.bitmapMult[0] = color.color.r/255.0f;
2949 oglSurface.bitmapMult[1] = color.color.g/255.0f;
2950 oglSurface.bitmapMult[2] = color.color.b/255.0f;
2951 oglSurface.bitmapMult[3] = color.a/255.0f;
2954 ColorAlpha GetPixel(Display display, Surface surface,int x,int y)
2959 void PutPixel(Display display, Surface surface,int x,int y)
2961 OGLSurface oglSurface = surface.driverData;
2963 //Logf("PutPixel\n");
2965 glColor4fv(oglSurface.foreground);
2967 // glVertex2i(x+surface.offset.x, y+surface.offset.y);
2968 glVertex2f(x+surface.offset.x + 0.5f, y+surface.offset.y + 0.5f);
2973 void DrawLine(Display display, Surface surface, int _x1, int _y1, int _x2, int _y2)
2975 OGLSurface oglSurface = surface.driverData;
2976 float x1 = _x1, x2 = _x2, y1 = _y1, y2 = _y2;
2991 x1 += surface.offset.x;
2992 y1 += surface.offset.y;
2993 x2 += surface.offset.x;
2994 y2 += surface.offset.y;
2998 glColor4fv(oglSurface.foreground);
3003 glTexCoord2f(0.5f, 0);
3004 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3005 glTexCoord2f(Max(x2-x1, y2-y1) + 0.5f, 0);
3006 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3015 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3016 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3022 void Rectangle(Display display, Surface surface,int x1,int y1,int x2,int y2)
3024 OGLSurface oglSurface = surface.driverData;
3025 x1 += surface.offset.x;
3026 y1 += surface.offset.y;
3027 x2 += surface.offset.x;
3028 y2 += surface.offset.y;
3030 //Logf("Rectangle\n");
3032 glColor4fv(oglSurface.foreground);
3038 glTexCoord2f(0.5f, 0);
3039 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3040 glTexCoord2f(y2-y1 + 0.5f, 0);
3041 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3043 glTexCoord2f(0.5f, 0);
3044 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3045 glTexCoord2f(x2 - x1 + 0.5f, 0);
3046 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3048 glTexCoord2f(0.5f, 0);
3049 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3050 glTexCoord2f(y1 - y2 + 0.5f, 0);
3051 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3053 glTexCoord2f(0.5f, 0);
3054 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3055 glTexCoord2f(x1 - x2 + 0.5f, 0);
3056 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3061 glBegin(GL_LINE_LOOP);
3068 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3069 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3070 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3071 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3076 void Area(Display display, Surface surface,int x1,int y1,int x2,int y2)
3078 OGLSurface oglSurface = surface.driverData;
3081 glColor4fv(oglSurface.background);
3082 glRecti(x1+surface.offset.x, y1+surface.offset.y,
3083 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
3086 glRectf(x1+surface.offset.x, y1+surface.offset.y,
3087 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
3091 void Clear(Display display, Surface surface, ClearType type)
3093 OGLDisplay oglDisplay = display.driverData;
3094 OGLSurface oglSurface = surface.driverData;
3097 if(type != depthBuffer)
3098 glClearColor(oglSurface.background[0], oglSurface.background[1], oglSurface.background[2], oglSurface.background[3]);
3099 if(type != colorBuffer && !oglDisplay.depthWrite)
3101 glDepthMask((byte)bool::true);
3103 glClear(((type != depthBuffer) ? GL_COLOR_BUFFER_BIT : 0) |
3104 ((type != colorBuffer) ? GL_DEPTH_BUFFER_BIT : 0));
3105 if(type != colorBuffer && !oglDisplay.depthWrite)
3107 glDepthMask((byte)bool::false);
3111 bool ConvertBitmap(DisplaySystem displaySystem, Bitmap bitmap, PixelFormat format, ColorAlpha * palette)
3116 void Blit(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3118 OGLSurface oglSurface = surface.driverData;
3120 #if !defined(__OLDX__)
3121 // WHY DO WE HAVE GL_ONE HERE ?
3122 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3123 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3126 if(!oglSurface.writingText)
3128 // glTranslatef(-0.375f, -0.375f, 0.0f);
3129 glEnable(GL_TEXTURE_2D);
3130 glColor4fv(oglSurface.bitmapMult);
3132 else if(oglSurface.xOffset)
3133 glTranslated(oglSurface.xOffset / 64.0/*-0.375*/, 0.0, 0.0);
3135 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3140 glTexCoord2f((float)sx/ bitmap.width, (float)(sy-h)/ bitmap.height);
3141 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3142 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy-h)/ bitmap.height);
3143 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3144 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3145 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
3146 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3147 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3152 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3153 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3154 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3155 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3156 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3157 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3158 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3159 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3162 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3163 glVertex2f((float)dx+surface.offset.x, (float)dy+surface.offset.y);
3164 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3165 glVertex2f((float)dx+w+surface.offset.x, (float)dy+surface.offset.y);
3166 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3167 glVertex2f((float)dx+w+surface.offset.x, (float)dy+h+surface.offset.y);
3168 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3169 glVertex2f((float)dx+surface.offset.x, (float)dy+h+surface.offset.y);
3173 if(!oglSurface.writingText)
3175 glDisable(GL_TEXTURE_2D);
3177 //glTranslate(0.375, 0.375, 0.0);
3179 else if(oglSurface.xOffset)
3180 glTranslated(-oglSurface.xOffset / 64.0/*+0.375*/, 0.0, 0.0);
3182 #if !defined(__OLDX__)
3183 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3184 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3188 void Stretch(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3190 OGLSurface oglSurface = surface.driverData;
3192 //glTranslate(-0.375, -0.375, 0.0);
3194 //Logf("Stretch\n");
3196 #if !defined(__OLDX__)
3197 /*if(glBlendFuncSeparate)
3198 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3201 glEnable(GL_TEXTURE_2D);
3202 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3204 glColor4fv(oglSurface.bitmapMult);
3210 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3211 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3213 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3214 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3216 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3217 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
3219 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3220 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3224 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3225 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3227 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3228 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3230 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3231 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3233 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3234 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3239 glDisable(GL_TEXTURE_2D);
3241 //glTranslate(0.375, 0.375, 0.0);
3242 #if !defined(__OLDX__)
3243 /*if(glBlendFuncSeparate)
3244 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3249 void Filter(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3251 Stretch(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3254 void StretchDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3256 float s2dw,s2dh,d2sw,d2sh;
3257 //bool flipX = false, flipY = false;
3259 //Logf("StretchDI\n");
3261 if(Sgn(w) != Sgn(sw))
3267 if(Sgn(h) != Sgn(sh))
3279 //Clip against the edges of the source
3282 dx+=(int)((0-sx) * s2dw);
3283 w-=(int)((0-sx) * s2dw);
3289 dy+=(int)((0-sy) * s2dh);
3290 h-=(int)((0-sy) * s2dh);
3295 if(sx+sw>bitmap.width-1)
3297 w-=(int)((sx+sw-(bitmap.width-1)-1)*s2dw);
3298 sw-=sx+sw-(bitmap.width-1)-1;
3300 if(sy+sh>(bitmap.height-1))
3302 h-=(int)((sy+sh-(bitmap.height-1)-1)*s2dh);
3303 sh-=sy+sh-(bitmap.height-1)-1;
3305 //Clip against the edges of the surfaceination
3306 if(dx<surface.box.left)
3309 sx+=(int)((surface.box.left-dx)*d2sw);
3310 sw-=(int)((surface.box.left-dx)*d2sw);
3311 w-=surface.box.left-dx;
3312 dx=surface.box.left;
3314 if(dy<surface.box.top)
3316 sy+=(int)((surface.box.top-dy)*d2sh);
3317 sh-=(int)((surface.box.top-dy)*d2sh);
3318 h-=surface.box.top-dy;
3321 if(dx+w>surface.box.right)
3323 //if(flip) sx+=(int)((dx+w-surface.box.right-1)*d2sw);
3324 sw-=(int)((dx+w-surface.box.right-1)*d2sw);
3325 w-=dx+w-surface.box.right-1;
3327 if(dy+h>surface.box.bottom)
3329 sh-=(int)((dy+h-surface.box.bottom-1)*d2sh);
3330 h-=dy+h-surface.box.bottom-1;
3332 if((w<=0)||(h<=0)||(sw<=0)||(sh<=0)) return;
3334 dx += surface.offset.x;
3335 dy += surface.offset.y;
3337 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3339 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3340 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3341 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3342 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3343 glRasterPos2d(dx,dy);
3344 //glPixelZoom(flipX ? -s2dw : s2dw, flipY ? s2dh : -s2dh);
3345 glPixelZoom(s2dw, -s2dh);
3346 glDrawPixels(sw,sh,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3347 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3348 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3349 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3350 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3354 void BlitDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3358 //Clip against the edges of the source
3371 if(sx+w>bitmap.width-1)
3372 w-=sx+w-(bitmap.width-1)-1;
3373 if(sy+h>bitmap.height-1)
3374 h-=sy+h-(bitmap.height-1)-1;
3375 //Clip against the edges of the surfaceination
3376 if(dx<surface.box.left)
3379 sx+=surface.box.left-dx;
3380 w-=surface.box.left-dx;
3381 dx=surface.box.left;
3383 if(dy<surface.box.top)
3385 sy+=surface.box.top-dy;
3386 h-=surface.box.top-dy;
3389 if(dx+w>surface.box.right)
3391 //if(flip) sx+=dx+w-surface.box.right-1;
3392 w-=dx+w-surface.box.right-1;
3394 if(dy+h>surface.box.bottom)
3395 h-=dy+h-surface.box.bottom-1;
3399 dx += surface.offset.x;
3400 dy += surface.offset.y;
3402 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3404 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3405 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3406 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3407 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3408 glRasterPos2d(dx,dy);
3410 glDrawPixels(w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3411 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3412 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3413 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3414 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3418 void FilterDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3420 StretchDI(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3423 void UnloadFont(DisplaySystem displaySystem, Font font)
3425 ((subclass(DisplayDriver))class(LFBDisplayDriver)).UnloadFont(displaySystem, font);
3428 Font LoadFont(DisplaySystem displaySystem, const char * faceName, float size, FontFlags flags)
3431 OGLSystem oglSystem = displaySystem.driverData;
3432 oglSystem.loadingFont = true;
3433 font = ((subclass(DisplayDriver))class(LFBDisplayDriver)).LoadFont(displaySystem, faceName, size, flags);
3437 void FontExtent(DisplaySystem displaySystem, Font font, const char * text, int len, int * width, int * height)
3439 ((subclass(DisplayDriver))class(LFBDisplayDriver)).FontExtent(displaySystem, font, text, len, width, height);
3442 void WriteText(Display display, Surface surface, int x, int y, const char * text, int len)
3444 OGLSurface oglSurface = surface.driverData;
3445 OGLSystem oglSystem = display.displaySystem.driverData;
3446 oglSystem.loadingFont = true;
3448 //glTranslated(-0.375, -0.375, 0.0);
3452 if(surface.textOpacity)
3455 FontExtent(display.displaySystem, surface.font, text, len, &w, &h);
3456 display.displaySystem.driver.Area(display, surface,x,y,x+w-1,y+h-1);
3459 oglSurface.writingText = true;
3461 glEnable(GL_TEXTURE_2D);
3462 glColor4fv(oglSurface.foreground);
3464 ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x, y, text, len);
3465 oglSurface.writingText = false;
3466 oglSystem.loadingFont = false;
3468 glDisable(GL_TEXTURE_2D);
3470 //glTranslated(0.375, 0.375, 0.0);
3473 void TextFont(Display display, Surface surface, Font font)
3475 ((subclass(DisplayDriver))class(LFBDisplayDriver)).TextFont(display, surface, font);
3478 void TextOpacity(Display display, Surface surface, bool opaque)
3480 OGLSurface oglSurface = surface.driverData;
3481 oglSurface.opaqueText = opaque;
3484 void TextExtent(Display display, Surface surface, const char * text, int len, int * width, int * height)
3486 OGLSurface oglSurface = surface.driverData;
3487 OGLSystem oglSystem = display.displaySystem.driverData;
3488 oglSystem.loadingFont = true;
3489 FontExtent(display.displaySystem, oglSurface.font, text, len, width, height);
3490 oglSystem.loadingFont = false;
3493 void DrawingChar(Display display, Surface surface, char character)
3498 void LineStipple(Display display, Surface surface, uint32 stipple)
3500 //Logf("Stipple\n");
3505 stippleEnabled = true;
3506 glesLineStipple(1, (uint16)stipple);
3508 glLineStipple(1, (uint16)stipple);
3509 glEnable(GL_LINE_STIPPLE);
3515 stippleEnabled = false;
3516 glMatrixMode(GL_TEXTURE);
3518 glMatrixMode(GL_PROJECTION);
3519 glDisable(GL_TEXTURE_2D);
3521 glDisable(GL_LINE_STIPPLE);
3525 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
3526 void SetRenderState(Display display, RenderState state, uint value)
3528 OGLDisplay oglDisplay = display.driverData;
3529 //Logf("RenderState\n");
3535 glEnable(GL_MULTISAMPLE_ARB);
3537 glDisable(GL_MULTISAMPLE_ARB);
3541 glPolygonMode(GL_FRONT_AND_BACK, ((FillModeValue)value == solid) ? GL_FILL : GL_LINE);
3545 if(value) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
3548 if(value) glDepthMask((byte)bool::true); else glDepthMask((byte)bool::false);
3549 oglDisplay.depthWrite = (bool)value;
3553 float color[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3554 glFogfv(GL_FOG_COLOR, (float *)&color);
3558 glFogf(GL_FOG_DENSITY, (float)(RenderStateFloat { ui = value }.f * nearPlane));
3561 if(value) glEnable(GL_BLEND); else glDisable(GL_BLEND);
3565 float ambient[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3566 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
3571 if(value) glColorMask(1,1,1,1); else glColorMask(1,1,1,0);
3576 #if defined(__WIN32__)
3577 wglSwapIntervalEXT(value ? 1 : 0);
3584 void SetLight(Display display, int id, Light light)
3586 //Logf("SetLight\n");
3590 Object lightObject = light.lightObject;
3591 float position[4] = { 0, 0, 0, 0 };
3592 float color[4] = { 0, 0, 0, 1 };
3594 glEnable(GL_LIGHT0 + id);
3596 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, (float *)&light.diffuse);
3597 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, (float *)&light.ambient);
3598 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,(float *)&light.specular);
3601 if(!light.multiplier) light.multiplier = 1.0f;
3603 color[0] = light.diffuse.r * light.multiplier;
3604 color[1] = light.diffuse.g * light.multiplier;
3605 color[2] = light.diffuse.b * light.multiplier;
3606 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, color);
3608 color[0] = light.ambient.r * light.multiplier;
3609 color[1] = light.ambient.g * light.multiplier;
3610 color[2] = light.ambient.b * light.multiplier;
3611 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, color);
3612 color[0] = light.specular.r * light.multiplier;
3613 color[1] = light.specular.g * light.multiplier;
3614 color[2] = light.specular.b * light.multiplier;
3615 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,color);
3619 Vector3D positionVector;
3620 if(light.flags.spot)
3622 if(lightObject.flags.root || !lightObject.parent)
3624 positionVector = lightObject.transform.position;
3625 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3629 positionVector.MultMatrix(lightObject.transform.position, lightObject.parent.matrix);
3630 if(display.display3D.camera)
3631 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3637 if(!light.direction.x && !light.direction.y && !light.direction.z)
3639 Vector3Df vector { 0,0,-1 };
3641 mat.RotationQuaternion(light.orientation);
3642 positionVector.MultMatrixf(vector, mat);
3646 positionVector = light.direction;
3651 position[0] = (float)positionVector.x;
3652 position[1] = (float)positionVector.y;
3653 position[2] = (float)positionVector.z;
3655 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3658 // Display Light Position
3659 glDisable(GL_LIGHTING);
3660 glDisable(GL_DEPTH_TEST);
3664 glVertex3fv(position);
3666 glEnable(GL_DEPTH_TEST);
3667 glEnable(GL_LIGHTING);
3671 if(lightObject.flags.root || !lightObject.parent)
3673 positionVector = light.target.transform.position;
3674 positionVector.Subtract(positionVector, display.camera.cPosition);
3678 positionVector.MultMatrix(light.target.transform.position,
3679 lightObject.light.target.parent.matrix);
3680 positionVector.Subtract(positionVector, display.camera.cPosition);
3683 position[0] = positionVector.x;
3684 position[1] = positionVector.y;
3685 position[2] = positionVector.z;
3687 glDisable(GL_LIGHTING);
3688 glDisable(GL_DEPTH_TEST);
3692 glVertex3fv(position);
3694 glEnable(GL_DEPTH_TEST);
3695 glEnable(GL_LIGHTING);
3698 if(light.flags.attenuation)
3700 glLightf(GL_LIGHT0 + id, GL_CONSTANT_ATTENUATION, light.Kc);
3701 glLightf(GL_LIGHT0 + id, GL_LINEAR_ATTENUATION, light.Kl);
3702 glLightf(GL_LIGHT0 + id, GL_QUADRATIC_ATTENUATION, light.Kq);
3705 if(light.flags.spot)
3708 #define MAXLIGHT 0.9
3709 float direction[4] = { (float)light.direction.x, (float)light.direction.y, (float)light.direction.z, 1 };
3710 // Figure out exponent out of the hot spot
3711 exponent = (float)(log(MAXLIGHT) / log(cos((light.hotSpot / 2))));
3713 glLightfv(GL_LIGHT0 + id, GL_SPOT_DIRECTION, direction);
3714 glLightf(GL_LIGHT0 + id, GL_SPOT_CUTOFF, (float)(light.fallOff / 2));
3715 glLightf(GL_LIGHT0 + id, GL_SPOT_EXPONENT, exponent);
3721 Vector3Df vector { 0,0,-1 };
3722 Vector3Df direction;
3725 mat.RotationQuaternion(light.orientation);
3726 direction.MultMatrix(vector, mat);
3728 position[0] = direction.x;
3729 position[1] = direction.y;
3730 position[2] = direction.z;
3732 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3736 glDisable(GL_LIGHT0 + id);
3739 void SetCamera(Display display, Surface surface, Camera camera)
3741 OGLDisplay oglDisplay = display.driverData;
3742 //Logf("SetCamera\n");
3746 int left = surface.box.left + surface.offset.x;
3747 int top = surface.box.top + surface.offset.y;
3748 int right = surface.box.right + surface.offset.x;
3749 int bottom = surface.box.bottom + surface.offset.y;
3750 float origX = surface.offset.x + camera.origin.x;
3751 float origY = surface.offset.y + camera.origin.y;
3753 int y = display.height - bottom - 1;
3754 int w = right - left + 1;
3755 int h = bottom - top + 1;
3758 glViewport(x, y, w, h);
3760 // *** Projection Matrix ***
3761 glMatrixMode(GL_PROJECTION);
3762 if(!display.display3D.camera)
3765 if(display.display3D.collectingHits)
3767 float pickX = display.display3D.pickX + surface.offset.x;
3768 float pickY = display.height - (display.display3D.pickY + surface.offset.y) - 1;
3772 w / display.display3D.pickWidth, 0, 0, 0,
3773 0, h / display.display3D.pickHeight, 0, 0,
3775 (w + 2.0f * (x - pickX)) / display.display3D.pickWidth,
3776 (h + 2.0f * (y - pickY)) / display.display3D.pickHeight, 0, 1
3779 glLoadMatrixd(pickMatrix.array);
3784 (left - origX) * camera.zMin / camera.focalX,
3785 (right - origX) * camera.zMin / camera.focalX,
3786 (bottom - origY) * camera.zMin / camera.focalY,
3787 (top - origY) * camera.zMin / camera.focalY,
3788 camera.zMin, camera.zMax);
3790 glDisable(GL_BLEND);
3792 // *** Z Inverted Identity Matrix ***
3793 glMatrixMode(GL_MODELVIEW);
3794 if(!display.display3D.camera)
3799 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
3801 // *** View Matrix ***
3802 glMultMatrixd(camera.viewMatrix.array);
3807 glEnable(GL_DEPTH_TEST);
3808 glEnable(GL_LIGHTING);
3809 glShadeModel(GL_SMOOTH);
3810 glDepthMask((byte)bool::true);
3811 oglDisplay.depthWrite = true;
3813 glEnable(GL_MULTISAMPLE_ARB);
3815 else if(display.display3D.camera)
3817 oglDisplay.depthWrite = false;
3818 glViewport(0,0,display.width,display.height);
3820 glDisable(GL_CULL_FACE);
3821 glDisable(GL_DEPTH_TEST);
3822 glDisable(GL_LIGHTING);
3824 glDisable(GL_TEXTURE_2D);
3825 glShadeModel(GL_FLAT);
3827 glDisable(GL_MULTISAMPLE_ARB);
3829 // *** Restore 2D MODELVIEW Matrix ***
3832 // *** Restore 2D PROJECTION Matrix ***
3833 glMatrixMode(GL_PROJECTION);
3839 void ApplyMaterial(Display display, Material material, Mesh mesh)
3841 //Logf("ApplyMaterial\n");
3844 if(material.flags.doubleSided)
3846 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, !material.flags.singleSideLight);
3847 glDisable(GL_CULL_FACE);
3851 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, bool::false);
3852 glEnable(GL_CULL_FACE);
3856 if(material.flags.noFog)
3862 if(material.baseMap && (mesh.texCoords || mesh.flags.texCoords1))
3864 Bitmap map = material.baseMap;
3865 glEnable(GL_TEXTURE_2D);
3866 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)map.driverData);
3868 glMatrixMode(GL_TEXTURE);
3870 if(material.uScale && material.vScale)
3871 glScalef(material.uScale, material.vScale, 1);
3872 glMatrixMode(GL_MODELVIEW);
3874 if(material.flags.tile)
3876 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
3877 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
3881 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
3882 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
3886 glDisable(GL_TEXTURE_2D);
3888 if(mesh.flags.colors)
3890 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
3891 glEnable(GL_COLOR_MATERIAL);
3895 glDisable(GL_COLOR_MATERIAL);
3897 float color[4] = { material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity };
3898 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
3901 float color[4] = { material.ambient.r, material.ambient.g, material.ambient.b, 0 };
3902 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
3906 float color[4] = { material.specular.r, material.specular.g, material.specular.b, 0 };
3907 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, color);
3910 float color[4] = { material.emissive.r, material.emissive.g, material.emissive.b, 0 };
3911 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, color);
3914 glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &material.power);
3917 void FreeMesh(DisplaySystem displaySystem, Mesh mesh)
3919 OGLMesh oglMesh = mesh.data;
3922 if(!mesh.flags.vertices)
3924 oglMesh.vertices.free();
3925 delete mesh.vertices;
3927 if(!mesh.flags.normals)
3929 oglMesh.normals.free();
3930 delete mesh.normals;
3932 if(!mesh.flags.texCoords1)
3934 oglMesh.texCoords.free();
3935 delete mesh.texCoords;
3937 if(!mesh.flags.texCoords2)
3939 oglMesh.texCoords2.free();
3940 // delete mesh.texCoords2;
3942 if(!mesh.flags.colors)
3944 oglMesh.colors.free();
3955 bool AllocateMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags, int nVertices)
3957 bool result = false;
3960 mesh.data = OGLMesh { };
3963 if(mesh.nVertices == nVertices)
3965 // Same number of vertices, adding features (Leaves the other features pointers alone)
3966 if(mesh.flags != flags)
3968 if(!mesh.flags.vertices && flags.vertices)
3970 if(flags.doubleVertices)
3972 mesh.vertices = (Vector3Df *)new Vector3D[nVertices];
3975 mesh.vertices = new Vector3Df[nVertices];
3977 if(!mesh.flags.normals && flags.normals)
3979 if(flags.doubleNormals)
3981 mesh.normals = (Vector3Df *)new Vector3D[nVertices];
3984 mesh.normals = new Vector3Df[nVertices];
3986 if(!mesh.flags.texCoords1 && flags.texCoords1)
3988 mesh.texCoords = new Pointf[nVertices];
3990 if(!mesh.flags.colors && flags.colors)
3992 mesh.colors = new ColorRGBAf[nVertices];
3998 // New number of vertices, reallocate all current and new features
3999 flags |= mesh.flags;
4002 if(flags.doubleVertices)
4004 mesh.vertices = (Vector3Df *)renew mesh.vertices Vector3D[nVertices];
4007 mesh.vertices = renew mesh.vertices Vector3Df[nVertices];
4011 if(flags.doubleNormals)
4013 mesh.normals = (Vector3Df *)renew mesh.normals Vector3D[nVertices];
4016 mesh.normals = renew mesh.normals Vector3Df[nVertices];
4018 if(flags.texCoords1)
4020 mesh.texCoords = renew mesh.texCoords Pointf[nVertices];
4024 mesh.colors = renew mesh.colors ColorRGBAf[nVertices];
4032 void UnlockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
4034 OGLMesh oglMesh = mesh.data;
4035 if(!flags) flags = mesh.flags;
4040 oglMesh.vertices.upload(
4041 mesh.nVertices * (mesh.flags.doubleVertices ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.vertices); //, GL_STATIC_DRAW_ARB );
4044 oglMesh.normals.upload(
4045 mesh.nVertices * (mesh.flags.doubleNormals ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.normals); //, GL_STATIC_DRAW_ARB );
4047 if(flags.texCoords1)
4048 oglMesh.texCoords.upload(
4049 mesh.nVertices * sizeof(Pointf), mesh.texCoords); //, GL_STATIC_DRAW_ARB );
4052 oglMesh.colors.upload(
4053 mesh.nVertices * sizeof(ColorRGBAf), mesh.colors); //, GL_STATIC_DRAW_ARB );
4057 bool LockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
4064 void FreeIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4068 oglIndices.buffer.free();
4069 delete oglIndices.indices;
4074 void * AllocateIndices(DisplaySystem displaySystem, int nIndices, bool indices32bit)
4076 OGLIndices oglIndices = OGLIndices { };
4079 oglIndices.indices = (void *)(indices32bit ? new uint32[nIndices] : new uint16[nIndices]);
4080 oglIndices.nIndices = nIndices;
4085 void UnlockIndices(DisplaySystem displaySystem, OGLIndices oglIndices, bool indices32bit, int nIndices)
4092 if(!oglIndices.buffer.buffer)
4093 GLGenBuffers(1, (GLAB *)&oglIndices.buffer);
4094 if(curElementBuffer != oglIndices.buffer.buffer)
4095 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, oglIndices.buffer.buffer);
4096 glesBufferDatai(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32) * nIndices, oglIndices.indices, GL_STATIC_DRAW_ARB);
4100 oglIndices.buffer.upload(
4101 nIndices * (indices32bit ? sizeof(uint32) : sizeof(uint16)),
4102 oglIndices.indices); //GL_STATIC_DRAW_ARB);
4106 uint16 * LockIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4109 return oglIndices.indices;
4112 void SelectMesh(Display display, Mesh mesh)
4114 //Logf("SelectMesh\n");
4116 #if !defined( __ANDROID__) && !defined(__APPLE__) && !defined(__ODROID__)
4118 #if defined(__WIN32__)
4119 if(glUnlockArraysEXT)
4121 if(!vboAvailable && display.display3D.mesh)
4122 glUnlockArraysEXT();
4127 OGLMesh oglMesh = mesh.data;
4129 // *** Vertex Stream ***
4130 glEnableClientState(GL_VERTEX_ARRAY);
4131 if(!display.display3D.collectingHits && oglMesh)
4133 oglMesh.vertices.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, oglMesh.vertices.buffer ? null : (double *)mesh.vertices);
4135 // *** Normals Stream ***
4136 if(mesh.normals || mesh.flags.normals)
4138 glEnableClientState(GL_NORMAL_ARRAY);
4139 oglMesh.normals.use(normal, 3, GL_FLOAT, 0, oglMesh.normals.buffer ? null : mesh.normals);
4142 glDisableClientState(GL_NORMAL_ARRAY);
4144 // *** Texture Coordinates Stream ***
4145 if(mesh.texCoords || mesh.flags.texCoords1)
4147 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4148 oglMesh.texCoords.use(texCoord, 2, GL_FLOAT, 0, oglMesh.texCoords.buffer ? null : mesh.texCoords);
4151 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4153 // *** Color Stream ***
4154 if(mesh.colors || mesh.flags.colors)
4156 glEnableClientState(GL_COLOR_ARRAY);
4157 oglMesh.colors.use(color, 4, GL_FLOAT, 0, oglMesh.colors.buffer ? null : mesh.colors);
4160 glDisableClientState(GL_COLOR_ARRAY);
4164 noAB.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, (double *)mesh.vertices);
4165 if((mesh.normals || mesh.flags.normals) && !display.display3D.collectingHits)
4167 glEnableClientState(GL_NORMAL_ARRAY);
4168 noAB.use(normal, 3, GL_FLOAT, 0, mesh.normals);
4171 glDisableClientState(GL_NORMAL_ARRAY);
4172 if((mesh.texCoords || mesh.flags.texCoords1) && !display.display3D.collectingHits)
4174 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4175 noAB.use(texCoord, 2, GL_FLOAT, 0, mesh.texCoords);
4178 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4179 if((mesh.colors || mesh.flags.colors) && !display.display3D.collectingHits)
4181 glEnableClientState(GL_COLOR_ARRAY);
4182 noAB.use(color, 4, GL_FLOAT, 0, mesh.colors);
4185 glDisableClientState(GL_COLOR_ARRAY);
4188 #if !defined(__ANDROID__) && !defined(__APPLE__) && !defined(__ODROID__)
4190 #if defined(__WIN32__)
4194 glLockArraysEXT(0, mesh.nVertices);
4200 void DrawPrimitives(Display display, PrimitiveSingle * primitive, Mesh mesh)
4202 //Logf("DrawPrimitives\n");
4204 if(primitive->type.vertexRange)
4205 glDrawArrays(primitiveTypes[primitive->type.primitiveType], primitive->first, primitive->nVertices);
4208 // *** Hoping the data won't be uploaded at all (Won't really work if another group of the mesh is using the mesh ) ***
4209 // HACK TO SPEED THINGS UP...
4211 /*GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
4212 if(primitive->nIndices < (mesh.nVertices >> 2) && !primitive->type.indices32bit)
4215 glBegin(primitiveTypes[primitive->type.primitiveType]);
4218 OGLIndices oglIndices = primitive->data;
4219 MeshFeatures flags = mesh.flags;
4220 for(c = 0; c<primitive->nIndices; c++)
4222 uint16 index = ((uint16 *) oglIndices.indices)[c];
4223 if(flags.normals) glNormal3fv((float *)&mesh.normals[index]);
4224 if(flags.texCoords1) glTexCoord2fv((float *)&mesh.texCoords[index]);
4225 if(flags.colors) glColor4fv((float *)&mesh.colors[index]);
4226 glVertex3fv((float *)&mesh.vertices[index]);
4235 OGLIndices oglIndices = primitive->data;
4236 GLEAB eab = ((!display.display3D.collectingHits && oglIndices) ? oglIndices.buffer : noEAB);
4238 eab.draw(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
4239 primitive->type.indices32bit ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT,
4240 eab.buffer ? 0 : (oglIndices ? oglIndices.indices : primitive->indices));
4241 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
4246 void PushMatrix(Display display)
4251 void PopMatrix(Display display, bool setMatrix)
4256 void SetTransform(Display display, Matrix transMatrix, bool viewSpace, bool useCamera)
4258 Matrix matrix = transMatrix;
4259 Camera camera = useCamera ? display.display3D.camera : null;
4264 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
4269 matrix.m[3][0] - camera.cPosition.x,
4270 matrix.m[3][1] - camera.cPosition.y,
4271 matrix.m[3][2] - camera.cPosition.z);
4283 glMultMatrixd(matrix.array);
4288 public void UseSingleGLContext(bool useSingle)
4290 useSingleGLContext = useSingle;
4293 default dllexport void *
4294 #if defined(__WIN32__)
4295 __attribute__((stdcall))
4297 IS_GLGetContext(DisplaySystem displaySystem)
4301 #if defined(__WIN32__)
4302 OGLSystem system = displaySystem.driverData;
4304 #elif defined(__ANDROID__) || defined(__ODROID__)
4307 OGLSystem system = displaySystem.driverData;
4308 return system.glContext;