1 // We were using PBUFFER for alpha compositing on Linux before, but it does not seem to work, nor be required anymore.
4 namespace gfx::drivers;
7 #if defined(__unix__) || defined(__APPLE__)
9 #if !defined(__MINGW32__)
10 #define GL_GLEXT_PROTOTYPES
13 #define pointer _pointer
17 //#include <GL/miniglx.h>
21 #if !defined(__ANDROID__) && !defined(__ODROID__)
23 #define property _property
27 #define Window X11Window
28 #define Cursor X11Cursor
30 #define Display X11Display
32 #define KeyCode X11KeyCode
33 #define Picture X11Picture
37 #include <X11/Xutil.h>
39 #include <X11/extensions/XShm.h>
42 #include <X11/extensions/Xrender.h>
43 #include <X11/extensions/shape.h>
63 #if defined(__APPLE__)
64 #include <OpenGl/gl.h>
67 #if defined(__WIN32__) || defined(__unix__) || defined(__APPLE__)
69 #if defined(__WIN32__)
70 #define WIN32_LEAN_AND_MEAN
72 #define _WIN32_WINNT 0x0502
78 #if defined(__ANDROID__) || defined(__ODROID__)
81 #define property _property
84 #define Window X11Window
85 #define Cursor X11Cursor
87 #define Display X11Display
89 #define KeyCode X11KeyCode
90 #define Picture X11Picture
112 #include <GL/glext.h>
116 #if defined(__ODROID__) && !defined(_GLES)
124 #if defined(__unix__) || defined(__APPLE__)
126 #if !defined(__ANDROID__) && !defined(__ODROID__)
132 static double nearPlane = 1;
134 public double glesGetNearPlane()
139 public void glesSetNearPlane(double value)
144 #define glLoadMatrix glLoadMatrixd
145 #define glMultMatrix glMultMatrixd
146 #define glGetMatrix glGetDoublev
147 #define glTranslate glTranslated
148 #define glScale glScaled
151 #define glVertex3v glVertex3dv
152 #define glNormal3v glNormal3dv
156 //#ifdef VERTEX_FORMAT_DOUBLE
158 #define glLoadMatrix glLoadMatrixd
159 #define glMultMatrix glMultMatrixd
160 #define glGetMatrix glGetDoublev
161 #define glVertex3v glVertex3dv
162 #define glNormal3v glNormal3dv
163 #define glTranslate glTranslated
164 #define glScale glScaled
165 //#define GL_VERTEX_FORMAT GL_DOUBLE
169 #define glLoadMatrix glLoadMatrixf
170 #define glMultMatrix glMultMatrixf
171 #define glGetMatrix glGetFloatv
172 #define glVertex3v glVertex3fv
173 #define glNormal3v glNormal3fv
174 #define glTranslate glTranslatef
175 #define glScale glScalef
176 //#define GL_VERTEX_FORMAT GL_FLOAT
181 #define GL_ARRAY_BUFFER_ARB 0x8892
182 #define GL_ELEMENT_ARRAY_BUFFER_ARB 0x8893
183 #define GL_STATIC_DRAW_ARB 0x88E4
184 #define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8
185 #define GL_SEPARATE_SPECULAR_COLOR 0x81FA
187 #define GL_MULTISAMPLE_ARB 0x809D
189 #if defined(__WIN32__)
191 #define WGL_SAMPLE_BUFFERS_ARB 0x2041
192 #define WGL_SAMPLES_ARB 0x2042
194 #define WGL_WGLEXT_VERSION 1
195 #define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001
196 #define WGL_BACK_COLOR_BUFFER_BIT_ARB 0x00000002
197 #define WGL_DEPTH_BUFFER_BIT_ARB 0x00000004
198 #define WGL_STENCIL_BUFFER_BIT_ARB 0x00000008
199 #define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000
200 #define WGL_DRAW_TO_WINDOW_ARB 0x2001
201 #define WGL_DRAW_TO_BITMAP_ARB 0x2002
202 #define WGL_ACCELERATION_ARB 0x2003
203 #define WGL_NEED_PALETTE_ARB 0x2004
204 #define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005
205 #define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006
206 #define WGL_SWAP_METHOD_ARB 0x2007
207 #define WGL_NUMBER_OVERLAYS_ARB 0x2008
208 #define WGL_NUMBER_UNDERLAYS_ARB 0x2009
209 #define WGL_TRANSPARENT_ARB 0x200A
210 #define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037
211 #define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038
212 #define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039
213 #define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A
214 #define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B
215 #define WGL_SHARE_DEPTH_ARB 0x200C
216 #define WGL_SHARE_STENCIL_ARB 0x200D
217 #define WGL_SHARE_ACCUM_ARB 0x200E
218 #define WGL_SUPPORT_GDI_ARB 0x200F
219 #define WGL_SUPPORT_OPENGL_ARB 0x2010
220 #define WGL_DOUBLE_BUFFER_ARB 0x2011
221 #define WGL_STEREO_ARB 0x2012
222 #define WGL_PIXEL_TYPE_ARB 0x2013
223 #define WGL_COLOR_BITS_ARB 0x2014
224 #define WGL_RED_BITS_ARB 0x2015
225 #define WGL_RED_SHIFT_ARB 0x2016
226 #define WGL_GREEN_BITS_ARB 0x2017
227 #define WGL_GREEN_SHIFT_ARB 0x2018
228 #define WGL_BLUE_BITS_ARB 0x2019
229 #define WGL_BLUE_SHIFT_ARB 0x201A
230 #define WGL_ALPHA_BITS_ARB 0x201B
231 #define WGL_ALPHA_SHIFT_ARB 0x201C
232 #define WGL_ACCUM_BITS_ARB 0x201D
233 #define WGL_ACCUM_RED_BITS_ARB 0x201E
234 #define WGL_ACCUM_GREEN_BITS_ARB 0x201F
235 #define WGL_ACCUM_BLUE_BITS_ARB 0x2020
236 #define WGL_ACCUM_ALPHA_BITS_ARB 0x2021
237 #define WGL_DEPTH_BITS_ARB 0x2022
238 #define WGL_STENCIL_BITS_ARB 0x2023
239 #define WGL_AUX_BUFFERS_ARB 0x2024
240 #define WGL_NO_ACCELERATION_ARB 0x2025
241 #define WGL_GENERIC_ACCELERATION_ARB 0x2026
242 #define WGL_FULL_ACCELERATION_ARB 0x2027
243 #define WGL_SWAP_EXCHANGE_ARB 0x2028
244 #define WGL_SWAP_COPY_ARB 0x2029
245 #define WGL_SWAP_UNDEFINED_ARB 0x202A
246 #define WGL_TYPE_RGBA_ARB 0x202B
247 #define WGL_TYPE_COLORINDEX_ARB 0x202C
248 #define ERROR_INVALID_PIXEL_TYPE_ARB 0x2043
249 #define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054
250 #define WGL_DRAW_TO_PBUFFER_ARB 0x202D
251 #define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E
252 #define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F
253 #define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030
254 #define WGL_PBUFFER_LARGEST_ARB 0x2033
255 #define WGL_PBUFFER_WIDTH_ARB 0x2034
256 #define WGL_PBUFFER_HEIGHT_ARB 0x2035
257 #define WGL_PBUFFER_LOST_ARB 0x2036
258 #define ERROR_INVALID_PIXEL_TYPE_EXT 0x2043
259 #define WGL_NUMBER_PIXEL_FORMATS_EXT 0x2000
260 #define WGL_DRAW_TO_WINDOW_EXT 0x2001
261 #define WGL_DRAW_TO_BITMAP_EXT 0x2002
262 #define WGL_ACCELERATION_EXT 0x2003
263 #define WGL_NEED_PALETTE_EXT 0x2004
264 #define WGL_NEED_SYSTEM_PALETTE_EXT 0x2005
265 #define WGL_SWAP_LAYER_BUFFERS_EXT 0x2006
266 #define WGL_SWAP_METHOD_EXT 0x2007
267 #define WGL_NUMBER_OVERLAYS_EXT 0x2008
268 #define WGL_NUMBER_UNDERLAYS_EXT 0x2009
269 #define WGL_TRANSPARENT_EXT 0x200A
270 #define WGL_TRANSPARENT_VALUE_EXT 0x200B
271 #define WGL_SHARE_DEPTH_EXT 0x200C
272 #define WGL_SHARE_STENCIL_EXT 0x200D
273 #define WGL_SHARE_ACCUM_EXT 0x200E
274 #define WGL_SUPPORT_GDI_EXT 0x200F
275 #define WGL_SUPPORT_OPENGL_EXT 0x2010
276 #define WGL_DOUBLE_BUFFER_EXT 0x2011
277 #define WGL_STEREO_EXT 0x2012
278 #define WGL_PIXEL_TYPE_EXT 0x2013
279 #define WGL_COLOR_BITS_EXT 0x2014
280 #define WGL_RED_BITS_EXT 0x2015
281 #define WGL_RED_SHIFT_EXT 0x2016
282 #define WGL_GREEN_BITS_EXT 0x2017
283 #define WGL_GREEN_SHIFT_EXT 0x2018
284 #define WGL_BLUE_BITS_EXT 0x2019
285 #define WGL_BLUE_SHIFT_EXT 0x201A
286 #define WGL_ALPHA_BITS_EXT 0x201B
287 #define WGL_ALPHA_SHIFT_EXT 0x201C
288 #define WGL_ACCUM_BITS_EXT 0x201D
289 #define WGL_ACCUM_RED_BITS_EXT 0x201E
290 #define WGL_ACCUM_GREEN_BITS_EXT 0x201F
291 #define WGL_ACCUM_BLUE_BITS_EXT 0x2020
292 #define WGL_ACCUM_ALPHA_BITS_EXT 0x2021
293 #define WGL_DEPTH_BITS_EXT 0x2022
294 #define WGL_STENCIL_BITS_EXT 0x2023
295 #define WGL_AUX_BUFFERS_EXT 0x2024
296 #define WGL_NO_ACCELERATION_EXT 0x2025
297 #define WGL_GENERIC_ACCELERATION_EXT 0x2026
298 #define WGL_FULL_ACCELERATION_EXT 0x2027
299 #define WGL_SWAP_EXCHANGE_EXT 0x2028
300 #define WGL_SWAP_COPY_EXT 0x2029
301 #define WGL_SWAP_UNDEFINED_EXT 0x202A
302 #define WGL_TYPE_RGBA_EXT 0x202B
303 #define WGL_TYPE_COLORINDEX_EXT 0x202C
304 #define WGL_DRAW_TO_PBUFFER_EXT 0x202D
305 #define WGL_MAX_PBUFFER_PIXELS_EXT 0x202E
306 #define WGL_MAX_PBUFFER_WIDTH_EXT 0x202F
307 #define WGL_MAX_PBUFFER_HEIGHT_EXT 0x2030
308 #define WGL_OPTIMAL_PBUFFER_WIDTH_EXT 0x2031
309 #define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032
310 #define WGL_PBUFFER_LARGEST_EXT 0x2033
311 #define WGL_PBUFFER_WIDTH_EXT 0x2034
312 #define WGL_PBUFFER_HEIGHT_EXT 0x2035
313 #define WGL_DEPTH_FLOAT_EXT 0x2040
314 #define WGL_SAMPLE_BUFFERS_3DFX 0x2060
315 #define WGL_SAMPLES_3DFX 0x2061
316 #define WGL_SAMPLE_BUFFERS_EXT 0x2041
317 #define WGL_SAMPLES_EXT 0x2042
318 #define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044
319 #define WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D 0x2045
320 #define WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D 0x2046
321 #define WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D 0x2047
322 #define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048
323 #define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049
324 #define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A
325 #define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B
326 #define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C
327 #define WGL_GAMMA_TABLE_SIZE_I3D 0x204E
328 #define WGL_GAMMA_EXCLUDE_DESKTOP_I3D 0x204F
329 #define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050
330 #define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051
331 #define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052
332 #define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053
333 #define WGL_ARB_buffer_region 1
334 #define WGL_ARB_extensions_string 1
335 #define WGL_ARB_pixel_format 1
336 #define WGL_ARB_make_current_read 1
337 #define WGL_ARB_pbuffer 1
338 #define WGL_EXT_display_color_table 1
339 #define WGL_EXT_extensions_string 1
340 #define WGL_EXT_make_current_read 1
341 #define WGL_EXT_pbuffer 1
342 #define WGL_EXT_pixel_format 1
343 #define WGL_EXT_swap_control 1
344 #define WGL_WGL_EXT_depth_float 1
345 #define WGL_WGL_3DFX_multisample 1
346 #define WGL_WGL_EXT_multisample 1
347 #define WGL_NV_allocate_memory 1
350 typedef void (APIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum target);
351 typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);
352 typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum target);
353 typedef void (APIENTRY * PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei count);
354 typedef void (APIENTRY * PFNGLUNLOCKARRAYSEXTPROC) (void);
358 typedef int (APIENTRY * PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer);
359 typedef int (APIENTRY * PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint *buffers);
360 typedef int (APIENTRY * PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint *buffers);
361 typedef int (APIENTRY * PFNGLBUFFERDATAARBPROC) (GLenum target, int size, const GLvoid *data, GLenum usage);
363 typedef int (APIENTRY * PFNWGLCHOOSEPIXELFORMATARBPROC) ();
364 typedef void * (APIENTRY * PFNWGLCREATEPBUFFERARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
365 typedef HDC (APIENTRY * PFNWGLGETPBUFFERDCARBPROC) (void * hPbuffer);
366 typedef int (APIENTRY * PFNWGLRELEASEPBUFFERDCARBPROC) (void * hPbuffer, HDC hDC);
367 typedef BOOL (APIENTRY * PFNWGLDESTROYPBUFFERARBPROC) (void * hPbuffer);
368 typedef BOOL (APIENTRY * PFNWGLQUERYPBUFFERARBPROC) (void * hPbuffer, int iAttribute, int *piValue);
369 typedef const char * (APIENTRY * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc);
370 typedef BOOL (APIENTRY * PFNWGLBINDTEXIMAGEARBPROC) (void * hPbuffer, int iBuffer);
371 typedef BOOL (APIENTRY * PFNWGLRELEASETEXIMAGEARBPROC) (void * hPbuffer, int iBuffer);
373 static PFNGLMAPBUFFERARBPROC glMapBufferARB = null;
374 static PFNGLUNMAPBUFFERARBPROC glUnmapBufferARB = null;
375 static PFNGLACTIVETEXTUREARBPROC glActiveTextureARB = null;
376 static PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB = null;
377 static PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB = null;
378 static PFNGLLOCKARRAYSEXTPROC glLockArraysEXT = null;
379 static PFNGLUNLOCKARRAYSEXTPROC glUnlockArraysEXT = null;
380 static PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate = null;
382 static PFNGLGENBUFFERSARBPROC glGenBuffersARB = null;
383 static PFNGLBINDBUFFERARBPROC glBindBufferARB = null;
384 static PFNGLBUFFERDATAARBPROC glBufferDataARB = null;
385 static PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB = null;
386 static PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = null;
387 static PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB = null;
388 static PFNWGLCREATEPBUFFERARBPROC wglCreatePbufferARB = null;
389 static PFNWGLGETPBUFFERDCARBPROC wglGetPbufferDCARB = null;
390 static PFNWGLQUERYPBUFFERARBPROC wglQueryPbufferARB = null;
391 static PFNWGLDESTROYPBUFFERARBPROC wglDestroyPbufferARB = null;
392 static PFNWGLRELEASEPBUFFERDCARBPROC wglReleasePbufferDCARB = null;
393 static PFNWGLBINDTEXIMAGEARBPROC wglBindTexImageARB = null;
394 static PFNWGLRELEASETEXIMAGEARBPROC wglReleaseTexImageARB = null;
396 #define glBufferData glBufferDataARB
398 #ifdef WGL_WGLEXT_PROTOTYPES
399 extern BOOL WINAPI wglSwapIntervalEXT (int);
400 extern int WINAPI wglGetSwapIntervalEXT (void);
401 #endif /* WGL_WGLEXT_PROTOTYPES */
402 typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC) (int interval);
403 typedef int (WINAPI * PFNWGLGETSWAPINTERVALEXTPROC) (void);
405 static PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = NULL;
407 #elif defined(__ANDROID__) || defined(__ODROID__)
409 #define GL_FRAMEBUFFER GL_FRAMEBUFFER_OES
410 #define GL_RENDERBUFFER GL_RENDERBUFFER_OES
411 #define GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_OES
413 #define GL_POLYGON_STIPPLE 0xFFFF
414 #define GL_LINE_STIPPLE 0xFFFF
415 #define GL_LINE 0xFFFF
416 #define GL_FILL 0xFFFF
417 #define GL_ALL_ATTRIB_BITS 0xFFFF
418 #define GL_LIGHT_MODEL_LOCAL_VIEWER 0xFFFF
424 #define GL_QUAD_STRIP 0
425 //#define GL_DOUBLE 0
426 //#define GL_UNSIGNED_INT 0
429 //#define GL_LINE_STIPPLE 0
430 #define GL_BGRA_EXT 0
431 #define GL_UNPACK_ROW_LENGTH 0
432 #define GL_UNPACK_SKIP_PIXELS 0
433 #define GL_UNPACK_SKIP_ROWS 0
435 #define GL_PACK_ROW_LENGTH 0
436 #define GL_PACK_SKIP_ROWS 0
437 #define GL_PACK_SKIP_PIXELS 0
441 #if defined(ECERE_NO3D) || defined(ECERE_VANILLA)
449 FillBytesBy4(this, 0, sizeof(Matrix) >> 2);
450 m[0][0]=m[1][1]=m[2][2]=m[3][3]=1;
453 void Transpose(Matrix source)
458 m[j][i] = source.m[i][j];
461 void Multiply(Matrix a, Matrix b)
463 // We need a full matrix multiplication for the Projection matrix
464 m[0][0]=a.m[0][0]*b.m[0][0] + a.m[0][1]*b.m[1][0] + a.m[0][2]*b.m[2][0] + a.m[0][3]*b.m[3][0];
465 m[0][1]=a.m[0][0]*b.m[0][1] + a.m[0][1]*b.m[1][1] + a.m[0][2]*b.m[2][1] + a.m[0][3]*b.m[3][1];
466 m[0][2]=a.m[0][0]*b.m[0][2] + a.m[0][1]*b.m[1][2] + a.m[0][2]*b.m[2][2] + a.m[0][3]*b.m[3][2];
467 m[0][3]=a.m[0][0]*b.m[0][3] + a.m[0][1]*b.m[1][3] + a.m[0][2]*b.m[2][3] + a.m[0][3]*b.m[3][3];
469 m[1][0]=a.m[1][0]*b.m[0][0] + a.m[1][1]*b.m[1][0] + a.m[1][2]*b.m[2][0] + a.m[1][3]*b.m[3][0];
470 m[1][1]=a.m[1][0]*b.m[0][1] + a.m[1][1]*b.m[1][1] + a.m[1][2]*b.m[2][1] + a.m[1][3]*b.m[3][1];
471 m[1][2]=a.m[1][0]*b.m[0][2] + a.m[1][1]*b.m[1][2] + a.m[1][2]*b.m[2][2] + a.m[1][3]*b.m[3][2];
472 m[1][3]=a.m[1][0]*b.m[0][3] + a.m[1][1]*b.m[1][3] + a.m[1][2]*b.m[2][3] + a.m[1][3]*b.m[3][3];
474 m[2][0]=a.m[2][0]*b.m[0][0] + a.m[2][1]*b.m[1][0] + a.m[2][2]*b.m[2][0] + a.m[2][3]*b.m[3][0];
475 m[2][1]=a.m[2][0]*b.m[0][1] + a.m[2][1]*b.m[1][1] + a.m[2][2]*b.m[2][1] + a.m[2][3]*b.m[3][1];
476 m[2][2]=a.m[2][0]*b.m[0][2] + a.m[2][1]*b.m[1][2] + a.m[2][2]*b.m[2][2] + a.m[2][3]*b.m[3][2];
477 m[2][3]=a.m[2][0]*b.m[0][3] + a.m[2][1]*b.m[1][3] + a.m[2][2]*b.m[2][3] + a.m[2][3]*b.m[3][3];
479 m[3][0]=a.m[3][0]*b.m[0][0] + a.m[3][1]*b.m[1][0] + a.m[3][2]*b.m[2][0] + a.m[3][3]*b.m[3][0];
480 m[3][1]=a.m[3][0]*b.m[0][1] + a.m[3][1]*b.m[1][1] + a.m[3][2]*b.m[2][1] + a.m[3][3]*b.m[3][1];
481 m[3][2]=a.m[3][0]*b.m[0][2] + a.m[3][1]*b.m[1][2] + a.m[3][2]*b.m[2][2] + a.m[3][3]*b.m[3][2];
482 m[3][3]=a.m[3][0]*b.m[0][3] + a.m[3][1]*b.m[1][3] + a.m[3][2]*b.m[2][3] + a.m[3][3]*b.m[3][3];
487 // Our own matrix stack
488 static Matrix matrixStack[3][32];
489 static int matrixIndex[3];
490 static int curStack = 0;
494 // OpenGL ES Porting Kit
495 #if defined(__ANDROID__) || defined(__ODROID__)
496 #define glBindFramebuffer glBindFramebufferOES
497 #define glBindRenderbuffer glBindRenderbufferOES
498 #define GL_FRAMEBUFFER GL_FRAMEBUFFER_OES
499 #define GL_RENDERBUFFER GL_RENDERBUFFER_OES
500 #define glFramebufferTexture2D glFramebufferTexture2DOES
501 #define GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_OES
502 #define glGenFramebuffers glGenFramebuffersOES
503 #define glGenRenderbuffers glGenRenderbuffersOES
504 #define glDeleteFramebuffers glDeleteFramebuffersOES
505 #define glDeleteRenderbuffers glDeleteRenderbuffersOES
507 #define GL_POLYGON_STIPPLE 0xFFFF
508 #define GL_LINE_STIPPLE 0xFFFF
509 #define GL_LINE 0xFFFF
510 #define GL_FILL 0xFFFF
511 #define GL_ALL_ATTRIB_BITS 0xFFFF
512 #define GL_LIGHT_MODEL_LOCAL_VIEWER 0xFFFF
513 #define GL_INT 0x1404
514 #define GL_UNSIGNED_INT 0x1405
515 #define GL_DOUBLE 0x140A
521 #define glDrawElementsi(type, count, start) glDrawElements(type, count, GL_UNSIGNED_SHORT, start)
523 #define glBufferDatai glesBufferDatai
524 #define glBufferDatad glesBufferDatad
525 #define glVertexPointeri glesVertexPointeri
526 #define glVertexPointerd glesVertexPointerd
528 #define glRecti glesRecti
529 #define glBegin glesBegin
530 #define glTexCoord2i glesTexCoord2i
531 #define glVertex2i glesVertex2i
532 #define glTexCoord2d glesTexCoord2d
533 #define glVertex2d glesVertex2d
534 #define glTexCoord2f glesTexCoord2f
535 #define glVertex2f glesVertex2f
536 #define glEnd glesEnd
537 #define glColor3f glesColor3f
538 #define glColor4ub glesColor4ub
539 #define glColor4fv glesColor4fv
540 #define glLineStipple glesLineStipple
541 #define glNormal3fv glesNormal3fv
542 #define glNormal3f glesNormal3f
543 #define glTexCoord2fv glesTexCoord2fv
544 #define glColorMaterial glesColorMaterial
546 #define glLoadMatrixd glesLoadMatrixd
547 #define glMultMatrixd glesMultMatrixd
548 #define glFrustum glesFrustum
549 #define glOrtho glesOrtho
550 #define glScaled glesScaled
551 #define glTranslated glesTranslated
552 #define glRotated glesRotated
553 #define glVertex3d glesVertex3d
554 #define glVertex3dv glesVertex3dv
555 #define glVertex3f glesVertex3f
556 #define glVertex3fv glesVertex3fv
557 #define glLightModeli glesLightModeli
559 #if defined(__ANDROID__)
561 #define GL_QUAD_STRIP 0
562 //#define GL_DOUBLE 0
563 //#define GL_UNSIGNED_INT 0
566 //#define GL_LINE_STIPPLE 0
567 #define GL_BGRA_EXT 0
568 #define GL_UNPACK_ROW_LENGTH 0
569 #define GL_UNPACK_SKIP_PIXELS 0
570 #define GL_UNPACK_SKIP_ROWS 0
572 #define GL_PACK_ROW_LENGTH 0
573 #define GL_PACK_SKIP_ROWS 0
574 #define GL_PACK_SKIP_PIXELS 0
579 #define glVertexPointerd(nc, s, p, nv) glVertexPointer(nc, GL_DOUBLE, s, p)
580 #define glDrawElementsi(type, count, start) glDrawElements(type, count, GL_UNSIGNED_INT, start)
584 #if defined(__ANDROID__) || defined(__ODROID__)
585 static EGLDisplay eglDisplay;
586 static EGLSurface eglSurface;
587 static EGLContext eglContext;
588 static int eglWidth, eglHeight;
590 #if defined(__ANDROID__)
591 static bool egl_init_display(ANativeWindow* window)
593 static bool egl_init_display(uint window)
596 const EGLint attribs[] =
598 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
602 EGL_DEPTH_SIZE, 16, //24,
603 /*EGL_SAMPLE_BUFFERS, 1,
604 EGL_SAMPLES, 0, //2,*/
613 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
614 eglInitialize(display, 0, 0);
615 eglChooseConfig(display, attribs, &config, 1, &numConfigs);
616 eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &format);
618 surface = eglCreateWindowSurface(display, config, window, null);
619 context = eglCreateContext(display, config, null, null);
621 if(!eglMakeCurrent(display, surface, surface, context))
624 eglQuerySurface(display, surface, EGL_WIDTH, &w);
625 eglQuerySurface(display, surface, EGL_HEIGHT, &h);
627 eglDisplay = display;
628 eglContext = context;
629 eglSurface = surface;
633 glEnableClientState(GL_VERTEX_ARRAY);
635 // Initialize GL state.
636 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
637 glEnable(GL_CULL_FACE);
638 glShadeModel(GL_SMOOTH);
639 glDisable(GL_DEPTH_TEST);
641 glDisable(GL_CULL_FACE);
642 glDisable(GL_DEPTH_TEST);
644 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
647 matrixStack[0][0].Identity();
648 matrixStack[1][0].Identity();
649 matrixStack[2][0].Identity();
651 glesMatrixMode(GL_MODELVIEW);
652 glScaled(1.0, 1.0, -1.0);
653 glesMatrixMode(GL_PROJECTION);
654 glShadeModel(GL_FLAT);
656 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
657 glFogi(GL_FOG_MODE, GL_EXP);
658 glFogf(GL_FOG_DENSITY, 0);
659 glEnable(GL_NORMALIZE);
660 glDepthFunc(GL_LESS);
662 glDisable(GL_MULTISAMPLE_ARB);
666 glOrtho(0,w,h,0,0.0,1.0);
669 curElementBuffer = 0;
673 static void egl_term_display()
677 glDeleteTextures(1, &stippleTexture);
680 if(eglDisplay != EGL_NO_DISPLAY)
682 eglMakeCurrent(eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
683 if(eglContext != EGL_NO_CONTEXT)
684 eglDestroyContext(eglDisplay, eglContext);
685 if(eglSurface != EGL_NO_SURFACE)
686 eglDestroySurface(eglDisplay, eglSurface);
687 eglTerminate(eglDisplay);
689 eglDisplay = EGL_NO_DISPLAY;
690 eglContext = EGL_NO_CONTEXT;
691 eglSurface = EGL_NO_SURFACE;
696 // OpenGL Immediate Mode Porting Kit
697 static int beginCount;
698 static int vertexCount;
699 static int normalCount;
700 static float *vertexPointer;
701 static float *normalPointer;
702 static GLenum beginMode = -1;
703 static uint beginBufferSize, normalBufferSize;
704 static int numVertexCoords = 2;
705 static bool vertexColorValues = false;
706 static int vertexStride = 4;
707 static int vertexOffset = 2;
709 public void glesRecti(int a, int b, int c, int d)
719 public void glesBegin(GLenum mode)
724 vertexColorValues = false;
731 normalBufferSize = beginBufferSize = 1024; // default number of vertices
732 vertexPointer = new float[beginBufferSize * vertexStride];
733 normalPointer = new float[normalBufferSize * 3];
737 public void glesTexCoord2f(float x, float y)
739 int count = vertexCount;
741 if(vertexCount + numVertexCoords > beginBufferSize)
743 beginBufferSize = beginBufferSize + beginBufferSize/2;
744 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
747 vertexPointer[count*vertexStride ] = x;
748 vertexPointer[count*vertexStride+1] = y;
751 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
753 vertexPointer[count*vertexStride ] = vertexPointer[(count-4)*vertexStride];
754 vertexPointer[count*vertexStride+1] = vertexPointer[(count-4)*vertexStride+1];
756 vertexPointer[count*vertexStride ] = vertexPointer[(count-3)*vertexStride];
757 vertexPointer[count*vertexStride+1] = vertexPointer[(count-3)*vertexStride+1];
761 public void glesTexCoord2i(int x, int y) { glesTexCoord2f((float)x, (float)y); }
762 public void glesTexCoord2d(double x, double y) { glesTexCoord2f((float)x, (float)y); }
763 public void glesTexCoord2fv(float * a) { glesTexCoord2f(a[0], a[1]); }
765 public void glesVertex2f(float x, float y)
768 vertexStride = vertexOffset + numVertexCoords;
770 if(vertexCount + 4 > beginBufferSize)
772 beginBufferSize = beginBufferSize + beginBufferSize/2;
773 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
776 vertexPointer[vertexCount*vertexStride+vertexOffset] = x;
777 vertexPointer[vertexCount*vertexStride+vertexOffset + 1] = y;
780 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
782 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset];
783 vertexPointer[vertexCount*vertexStride+vertexOffset + 1] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset + 1];
785 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset];
786 vertexPointer[vertexCount*vertexStride+vertexOffset + 1] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset + 1];
791 public void glesVertex2i(int x, int y) { glesVertex2f((float)x, (float)y); }
792 public void glesVertex2d(double x, double y) { glesVertex2f((float)x, (float)y); }
794 public void glesEnd(void)
796 int mode = beginMode;
797 if(mode == GL_QUADS) mode = GL_TRIANGLES;
798 else if(mode == GL_POLYGON) mode = GL_TRIANGLE_FAN;
800 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
801 noAB.use(texCoord, 2, GL_FLOAT, vertexStride * sizeof(float), vertexPointer);
802 if(vertexColorValues)
804 glEnableClientState(GL_COLOR_ARRAY);
805 noAB.use(color, 4, GL_FLOAT, vertexStride * sizeof(float), vertexPointer + 2);
807 noAB.use(vertex, numVertexCoords, GL_FLOAT, (vertexStride)*sizeof(float),vertexPointer+vertexOffset);
808 if(normalCount && normalCount == vertexCount)
810 glEnableClientState(GL_NORMAL_ARRAY);
811 noAB.use(normal, 3, GL_FLOAT, 3*sizeof(float),normalPointer);
814 glDrawArrays(mode, 0, vertexCount);
816 glDisableClientState(GL_NORMAL_ARRAY);
817 if(vertexColorValues)
818 glDisableClientState(GL_COLOR_ARRAY);
819 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
821 vertexColorValues = false;
827 static float *floatVPBuffer = null;
828 static short *shortVPBuffer = null;
829 static unsigned int shortVPSize = 0, floatVPSize = 0;
832 //static float *floatVPBuffer = null; // For floats we reuse floatVPBuffer
833 static unsigned short *shortBDBuffer = null;
834 static unsigned int shortBDSize = 0/*, floatVPSize = 0*/;
836 public void glesVertexPointeri(int numCoords, int stride, int *pointer, int numVertices)
841 if(numVertices*numCoords > shortVPSize)
843 shortVPSize = numVertices*numCoords;
844 shortVPBuffer = renew shortVPBuffer short[shortVPSize];
846 for(i = 0; i < numVertices*numCoords; i++)
847 shortVPBuffer[i] = (short)pointer[i];
848 glVertexPointer(numCoords, GL_SHORT, stride, shortVPBuffer);
851 glVertexPointer(numCoords, GL_SHORT, stride, 0);
854 public void glesVertexPointerd(int numCoords, int stride, double *pointer, int numVertices)
859 if(numVertices*numCoords > floatVPSize)
861 floatVPSize = numVertices*numCoords;
862 floatVPBuffer = renew floatVPBuffer float[floatVPSize];
864 for(i = 0; i < numVertices*numCoords; i++)
865 floatVPBuffer[i] = (float)pointer[i];
866 glVertexPointer(numCoords, GL_FLOAT, stride, floatVPBuffer);
869 glVertexPointer(numCoords, GL_FLOAT, stride, 0);
872 public void glesTexReuseIntVP(int numCoords)
874 glTexCoordPointer(numCoords, GL_SHORT, 0, floatVPBuffer);
877 public void glesTexReuseDoubleVP(int numCoords)
879 glTexCoordPointer(numCoords, GL_FLOAT, 0, floatVPBuffer);
882 public void glesColor4f(float r, float g, float b, float a)
884 if(beginMode != (GLenum)-1)
886 int count = vertexCount;
888 vertexColorValues = true;
890 vertexStride = vertexOffset + numVertexCoords;
892 if(vertexCount + vertexStride > beginBufferSize)
894 beginBufferSize = beginBufferSize + beginBufferSize/2;
895 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
898 vertexPointer[count*vertexStride + 2] = r;
899 vertexPointer[count*vertexStride + 3] = g;
900 vertexPointer[count*vertexStride + 4] = b;
901 vertexPointer[count*vertexStride + 5] = a;
904 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
906 vertexPointer[count*vertexStride + 2] = vertexPointer[(count-4) * vertexStride + 2];
907 vertexPointer[count*vertexStride + 3] = vertexPointer[(count-4) * vertexStride + 3];
908 vertexPointer[count*vertexStride + 4] = vertexPointer[(count-4) * vertexStride + 4];
909 vertexPointer[count*vertexStride + 5] = vertexPointer[(count-4) * vertexStride + 5];
911 vertexPointer[count*vertexStride + 2] = vertexPointer[(count-3) * vertexStride + 2];
912 vertexPointer[count*vertexStride + 3] = vertexPointer[(count-3) * vertexStride + 3];
913 vertexPointer[count*vertexStride + 4] = vertexPointer[(count-3) * vertexStride + 4];
914 vertexPointer[count*vertexStride + 5] = vertexPointer[(count-3) * vertexStride + 5];
919 glColor4f(r, g, b, a);
922 public void glesColor3f( float r, float g, float b )
924 glesColor4f(r, g, b, 1.0f);
927 public void glesColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
929 glesColor4f(r/255.0f, g/255.0f, b/255.0f, a/255.0f);
932 public void glesColor4fv(float * a)
934 glesColor4f(a[0], a[1], a[2], a[3]);
937 public void glesBufferDatad(int target, int size, void * data, int usage)
939 int numElems = size/sizeof(double);
940 double * dblPtr = (double *)data;
942 if (numElems > floatVPSize)
944 floatVPSize = numElems;
945 floatVPBuffer = renew floatVPBuffer float[floatVPSize];
947 for (i=0; i< numElems; i++)
948 floatVPBuffer[i] = (float)dblPtr[i];
950 glBufferData(target, numElems*sizeof(float), floatVPBuffer, usage);
953 public void glesBufferDatai(int target, int size, void * data, int usage)
955 int numElems = size/sizeof(unsigned int);
956 unsigned int * pointer = (unsigned int *)data;
958 if (numElems > shortBDSize)
960 shortBDSize = numElems;
961 shortBDBuffer = renew shortBDBuffer uint16[shortBDSize];
963 for (i=0; i< numElems; i++)
964 shortBDBuffer[i] = (unsigned short)pointer[i];
966 glBufferData(target, numElems*sizeof(unsigned short), shortBDBuffer, usage);
969 // *** Our Custom Matrix Stack ***
971 static void LoadCurMatrix()
973 double * i = matrixStack[curStack][matrixIndex[curStack]].array;
976 (float)i[0],(float)i[1],(float)i[2],(float)i[3],
977 (float)i[4],(float)i[5],(float)i[6],(float)i[7],
978 (float)i[8],(float)i[9],(float)i[10],(float)i[11],
979 (float)i[12],(float)i[13],(float)i[14],(float)i[15]
984 public void glesLoadIdentity()
986 matrixStack[curStack][matrixIndex[curStack]].Identity();
990 public void glesPushMatrix()
992 if(matrixIndex[curStack] + 1 < sizeof(matrixStack[0]) / sizeof(Matrix))
994 matrixIndex[curStack]++;
995 memcpy(matrixStack[curStack][matrixIndex[curStack]].array, matrixStack[curStack][matrixIndex[curStack]-1].array, sizeof(Matrix));
999 public void glesPopMatrix()
1001 if(matrixIndex[curStack] > 0)
1003 matrixIndex[curStack]--;
1008 public void glesLoadMatrixd(double * i)
1010 memcpy(matrixStack[curStack][matrixIndex[curStack]].array, i, sizeof(Matrix));
1014 public void glesOrtho( double l, double r, double b, double t, double n, double f )
1018 (2 / (r - l)), 0, 0, 0,
1019 0, (2 / (t - b)), 0, 0,
1020 0, 0, (-2 / (f - n)), 0,
1021 (-(r + l) / (r - l)), (-(t + b) / (t - b)), (-(f + n) / (f - n)), 1
1024 res.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1025 matrixStack[curStack][matrixIndex[curStack]] = res;
1029 public void glesFrustum( double l, double r, double b, double t, double n, double f )
1039 double A = ((r + l) / (r - l));
1040 double B = ((t + b) / (t - b));
1041 double C = (-(f + n) / (f - n));
1042 double D = (-2*f*n/(f-n));
1045 (2.0*n / (r - l)), 0, 0, 0,
1046 0, (2.0*n / (t - b)), 0, 0,
1051 res.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1052 matrixStack[curStack][matrixIndex[curStack]] = res;
1057 public void glesRotated( double a, double b, double c, double d )
1062 q.RotationAxis({(float)b,(float)c,(float)-d}, a );
1063 m.RotationQuaternion(q);
1064 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1065 matrixStack[curStack][matrixIndex[curStack]] = r;
1068 public void glesScaled( double a, double b, double c )
1074 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1075 matrixStack[curStack][matrixIndex[curStack]] = r;
1079 public void glesTranslated( double a, double b, double c )
1085 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1086 matrixStack[curStack][matrixIndex[curStack]] = r;
1090 public void glesMultMatrixd( double * i )
1093 r.Multiply((Matrix *)i, matrixStack[curStack][matrixIndex[curStack]]);
1094 matrixStack[curStack][matrixIndex[curStack]] = r;
1098 public void glesMatrixMode(int mode)
1100 curStack = (mode == GL_MODELVIEW) ? 0 : (mode == GL_PROJECTION) ? 1 : 2;
1106 #define glPushMatrix glesPushMatrix
1107 #define glPopMatrix glesPopMatrix
1108 #define glLoadIdentity glesLoadIdentity
1109 #define glMatrixMode glesMatrixMode
1113 /* Using the built-in matrix stack
1114 void glesLoadMatrixd( double * i )
1118 (float)i[0],(float)i[1],(float)i[2],(float)i[3],
1119 (float)i[4],(float)i[5],(float)i[6],(float)i[7],
1120 (float)i[8],(float)i[9],(float)i[10],(float)i[11],
1121 (float)i[12],(float)i[13],(float)i[14],(float)i[15]
1126 void glesOrtho( double l, double r, double b, double t, double n, double f )
1128 float matrix[4][4] =
1130 { (float)(2 / (r - l)), 0, 0, 0 },
1131 { 0, (float)(2 / (t - b)), 0, 0 },
1132 { 0, 0, (float)(-2 / (f - n)), 0 },
1133 { (float)(-(r + l) / (r - l)), (float)(-(t + b) / (t - b)), (float)(-(f + n) / (f - n)), 1 }
1135 glMultMatrixf((float *)matrix);
1138 void glesFrustum( double l, double r, double b, double t, double n, double f )
1140 float A = (float)((r + l) / (r - l));
1141 float B = (float)((t + b) / (t - b));
1142 float C = (float)(-(f + n) / (f - n));
1143 float D = (float)(-2*f*n/(f-n));
1144 float matrix[4][4] =
1146 { (float)(2*n / (r - l)), 0, 0, 0 },
1147 { 0, (float)(2*n / (t - b)), 0, 0 },
1151 glMultMatrixf((float *)matrix);
1154 void glesRotated( double a, double b, double c, double d ) { glRotatef((float)a, (float)b, (float)c, (float)d); }
1155 void glesScaled( double a, double b, double c ) { glScalef((float)a, (float)b, (float)c); }
1156 void glesTranslated( double a, double b, double c ) { glTranslatef((float)a, (float)b, (float)c); }
1158 void glesMultMatrixd( double * i )
1162 (float)i[0], (float)i[1], (float)i[2], (float)i[3],
1163 (float)i[4], (float)i[5], (float)i[6], (float)i[7],
1164 (float)i[8], (float)i[9], (float)i[10], (float)i[11],
1165 (float)i[12], (float)i[13], (float)i[14], (float)i[15]
1171 // Need to do these...
1172 public void glesVertex3f( float x, float y, float z )
1174 numVertexCoords = 3;
1175 vertexStride = vertexOffset + numVertexCoords;
1177 if(vertexCount + vertexStride > beginBufferSize)
1179 beginBufferSize = beginBufferSize + beginBufferSize/2;
1180 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
1183 vertexPointer[vertexCount*vertexStride+vertexOffset] = x;
1184 vertexPointer[vertexCount*vertexStride+vertexOffset+1] = y;
1185 vertexPointer[vertexCount*vertexStride+vertexOffset+2] = z;
1188 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
1190 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset];
1191 vertexPointer[vertexCount*vertexStride+vertexOffset+1] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset+1];
1192 vertexPointer[vertexCount*vertexStride+vertexOffset+2] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset+2];
1194 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset];
1195 vertexPointer[vertexCount*vertexStride+vertexOffset+1] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset+1];
1196 vertexPointer[vertexCount*vertexStride+vertexOffset+2] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset+2];
1202 public void glesVertex3d( double x, double y, double z ) { glesVertex3f((float)x, (float)y, (float)z); }
1203 public void glesVertex3fv( float* coords ) { glesVertex3f(coords[0], coords[1], coords[2]); }
1204 public void glesVertex3dv( double* coords ) { glesVertex3f((float)coords[0], (float)coords[1], (float)coords[2]); }
1206 public void glesNormal3f(float x, float y, float z)
1208 normalCount = vertexCount;
1209 if(vertexCount + 4 > normalBufferSize)
1211 normalBufferSize = normalBufferSize + normalBufferSize/2;
1212 normalPointer = renew normalPointer float[normalBufferSize * 2];
1215 normalPointer[normalCount*3+0] = x;
1216 normalPointer[normalCount*3+1] = y;
1217 normalPointer[normalCount*3+2] = z;
1220 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
1222 normalPointer[normalCount*3+0] = normalPointer[(normalCount-4)*3+0];
1223 normalPointer[normalCount*3+1] = normalPointer[(normalCount-4)*3+1];
1224 normalPointer[normalCount*3+2] = normalPointer[(normalCount-4)*3+2];
1226 normalPointer[normalCount*3+0] = normalPointer[(normalCount-3)*3+0];
1227 normalPointer[normalCount*3+1] = normalPointer[(normalCount-3)*3+1];
1228 normalPointer[normalCount*3+2] = normalPointer[(normalCount-3)*3+2];
1232 public void glesNormal3fd(double x, double y, double z) { glesNormal3f((float)x, (float)y, (float)z); }
1233 public void glesNormal3fv(float * coords) { glesNormal3f(coords[0], coords[1], coords[2]); }
1235 public void glesColorMaterial(int a, int b)
1237 PrintLn("glColorMaterial stub");
1240 public void glesTerminate()
1242 delete vertexPointer;
1243 delete normalPointer;
1244 beginBufferSize = 0;
1246 delete floatVPBuffer;
1249 delete shortVPBuffer;
1252 delete shortBDBuffer;
1256 static GLuint stippleTexture;
1258 static bool stippleEnabled;
1261 public void glesLineStipple( int i, unsigned short j )
1265 for(x = 0; x < 16; x++)
1267 bool v = (j & (1 << x)) != 0;
1268 texture[x] = v ? 0xFFFFFFFF : 0;
1271 glGenTextures(1, &stippleTexture);
1272 glBindTexture(GL_TEXTURE_2D, stippleTexture);
1273 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture);
1274 glEnable(GL_TEXTURE_2D);
1275 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1276 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1277 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
1278 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1279 glMatrixMode(GL_TEXTURE);
1281 //glTranslated(1.0/backAttrib->texW/2.0f, 1.0/backAttrib->texH/2.0f, 0.0f);
1282 glScaled(i/16.0, 1, 1.0f);
1283 glTranslated(0.5, 0.5, 0);
1284 glMatrixMode(GL_PROJECTION);
1287 public void glesLightModeli( unsigned int pname, int param )
1289 if(pname == GL_LIGHT_MODEL_TWO_SIDE)
1290 glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, param);
1293 #if defined(__ANDROID__) || defined(__ODROID__)
1294 void glClearDepth( double depth ) { glClearDepthf((float)depth); }
1295 void glFogi( unsigned int pname, int param ) { }
1296 void glPolygonMode( unsigned int i, unsigned int j ) { }
1299 // *** Picking won't be supported for now ***
1300 void glPushName( unsigned int i ) { }
1301 void glLoadName( unsigned int i ) { }
1302 void glPopName() { }
1304 // Probably replace by regular glBlendFunc ...
1305 void glBlendFuncSeparate(int a, int b, int c, int d)
1310 // For direct pixel blitting...
1311 void glRasterPos2d(double a, double b) { }
1312 void glPixelZoom(float a, float b) { }
1313 void glDrawPixels(int a, int b, int c, int d, void * e) { }
1317 #if !defined(__APPLE__) && !defined(__WIN32__) && !defined(__ODROID__)
1318 void (APIENTRY * glBindBufferARB) (GLenum target, GLuint buffer);
1319 void (APIENTRY * glGenBuffersARB) (GLsizei n, GLuint *buffers);
1320 void (APIENTRY * glDeleteBuffersARB) (GLsizei n, const GLuint *buffers);
1321 void (APIENTRY * glBufferDataARB) (GLenum target, int size, const GLvoid *data, GLenum usage);
1324 public void GLLoadMatrix(Matrix matrix)
1328 (float)matrix.m[0][0], (float)matrix.m[0][1], (float)matrix.m[0][2], (float)matrix.m[0][3],
1329 (float)matrix.m[1][0], (float)matrix.m[1][1], (float)matrix.m[1][2], (float)matrix.m[1][3],
1330 (float)matrix.m[2][0], (float)matrix.m[2][1], (float)matrix.m[2][2], (float)matrix.m[2][3],
1331 (float)matrix.m[3][0], (float)matrix.m[3][1], (float)matrix.m[3][2], (float)matrix.m[3][3]
1336 public enum GLBufferContents { vertex, normal, texCoord, color };
1338 public define noAB = GLAB { 0 };
1340 static uint curArrayBuffer;
1346 void upload(uint size, void * data)
1351 GLGenBuffers(1, this);
1352 if(curArrayBuffer != buffer)
1353 GLBindBuffer(GL_ARRAY_BUFFER, buffer);
1354 glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW); //GL_DYNAMIC_DRAW);
1360 if(this != null && buffer)
1362 GLDeleteBuffers(1, this);
1367 void use(GLBufferContents contents, int n, int type, uint stride, void * pointer)
1369 if(curArrayBuffer != ((this != null) ? buffer : 0))
1370 GLBindBuffer(GL_ARRAY_BUFFER, ((this != null) ? buffer : 0));
1373 case normal: glNormalPointer(type, stride, pointer); break;
1374 case vertex: glVertexPointer(n, type, stride, pointer); break;
1375 case texCoord: glTexCoordPointer(n, type, stride, pointer); break;
1376 case color: glColorPointer(n, type, stride, pointer); break;
1380 void useVertTrans(uint count, int n, int type, uint stride, void * pointer)
1383 if(curArrayBuffer != ((this != null) ? buffer : 0))
1384 GLBindBuffer(GL_ARRAY_BUFFER, ((this != null) ? buffer : 0));
1386 glVertexPointeri(n, stride, pointer, count);
1387 else if(type == GL_DOUBLE)
1388 glVertexPointerd(n, stride, pointer, count);
1390 use(vertex, n, type, stride, pointer);
1395 static uint curElementBuffer;
1397 public define noEAB = GLEAB { 0 };
1403 void upload(uint size, void * data)
1408 GLGenBuffers(1, (GLAB *)this);
1410 if(curElementBuffer != buffer)
1411 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
1412 glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, data, GL_STATIC_DRAW); //GL_DYNAMIC_DRAW);
1418 if(this != null && buffer)
1420 GLDeleteBuffers(1, (GLAB *)this);
1425 void draw(int primType, int count, int type, void * indices)
1427 if(curElementBuffer != ((this != null) ? buffer : 0))
1428 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ((this != null) ? buffer : 0));
1430 type = GL_UNSIGNED_SHORT;
1432 glDrawElements(primType, count, type, indices);
1436 public void GLGenBuffers(int count, GLAB * buffers)
1438 #if defined(__ANDROID__) || defined(__ODROID__)
1439 glGenBuffers(count, (GLuint *)buffers);
1441 #if defined(__WIN32__)
1444 glGenBuffersARB(count, (GLuint *)buffers);
1448 public void GLDeleteBuffers(int count, GLAB * buffers)
1451 for(i = 0; i < count; i++)
1453 uint buffer = buffers[i].buffer;
1456 if(buffer == curArrayBuffer)
1457 GLBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
1458 else if(buffer == curElementBuffer)
1459 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
1462 #if defined(__ANDROID__) || defined(__ODROID__)
1463 if(count && buffers[0].buffer)
1464 glDeleteBuffers(count, (GLuint *)buffers);
1466 #if defined(__WIN32__)
1467 if(glDeleteBuffersARB)
1469 glDeleteBuffersARB(count, (GLuint *)buffers);
1473 void GLBindBuffer(int target, uint buffer)
1475 #if defined(__ANDROID__) || defined(__ODROID__)
1476 glBindBuffer(target, buffer);
1478 #if defined(__WIN32__)
1481 glBindBufferARB(target, buffer);
1483 if(target == GL_ARRAY_BUFFER_ARB)
1484 curArrayBuffer = buffer;
1485 else if(target == GL_ELEMENT_ARRAY_BUFFER_ARB)
1486 curElementBuffer = buffer;
1489 public void GLVertexPointer(int numCoords, int glType, int stride, void *ptr, int numVertices)
1492 if(glType == GL_DOUBLE)
1493 glesVertexPointerd(numCoords, stride, ptr, numVertices);
1494 else if(glType == GL_INT)
1495 glesVertexPointeri(numCoords, stride, ptr, numVertices);
1498 glVertexPointer(numCoords, glType, stride, ptr);
1501 public void GLBufferData(int type, GLenum target, int size, const GLvoid *data, GLenum usage)
1504 if(type == GL_DOUBLE)
1505 glesBufferDatad(target, size, (void *)data, usage);
1506 else if(type == GL_UNSIGNED_INT)
1507 glesBufferDatai(target, size, (void *)data, usage);
1511 #if defined(__ANDROID__) || defined(__ODROID__)
1512 glBufferData(target, size, data, usage);
1515 #if defined(__WIN32__)
1518 glBufferDataARB(target, size, data, usage);
1522 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1523 static int primitiveTypes[RenderPrimitiveType] =
1525 GL_POINTS, GL_LINES, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP, GL_LINE_STRIP
1530 // Non OpenGL ES friendly stuff
1534 //#undef GL_UNSIGNED_INT
1539 #undef GL_QUAD_STRIP
1540 #undef GL_POLYGON_STIPPLE
1541 #undef GL_LINE_STIPPLE
1544 #undef GL_ALL_ATTRIB_BITS
1545 #undef GL_LIGHT_MODEL_LOCAL_VIEWER
1549 static int displayWidth, displayHeight;
1551 #define GL_CLAMP_TO_EDGE 0x812F
1553 static bool vboAvailable;
1555 static bool useSingleGLContext = false;
1556 class OGLDisplay : struct
1558 #if defined(__WIN32__)
1568 int imageBuffers[2];
1569 byte * pboMemory1, * pboMemory2;
1571 #elif !defined(__ANDROID__) && !defined(__ODROID__)
1572 GLXContext glContext;
1575 XShmSegmentInfo shminfo;
1577 XShmSegmentInfo shminfoShape;
1578 XImage * shapeImage;
1582 X11Picture windowPicture;
1583 X11Picture pixmapPicture;
1585 X11Picture shapePicture;
1588 ColorAlpha * flippingBuffer;
1589 int flipBufH, flipBufW;
1594 class OGLSystem : struct
1599 #if defined(__WIN32__)
1600 PIXELFORMATDESCRIPTOR pfd;
1605 #elif !defined(__ANDROID__) && !defined(__ODROID__)
1606 XVisualInfo * visualInfo;
1607 GLXContext glContext;
1608 GLXDrawable glxDrawable;
1612 class OGLSurface : struct
1619 float foreground[4], background[4], bitmapMult[4];
1622 class OGLMesh : struct
1631 class OGLIndices : struct
1641 class OpenGLDisplayDriver : DisplayDriver
1643 class_property(name) = "OpenGL";
1645 bool LockSystem(DisplaySystem displaySystem)
1647 #if !defined(__ANDROID__) && !defined(__ODROID__)
1648 OGLSystem oglSystem = displaySystem.driverData;
1649 if(useSingleGLContext) return true;
1650 #if defined(__WIN32__)
1651 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1652 #elif defined(__unix__) || defined(__APPLE__)
1653 //if(previous) return true;
1654 // printf("Making SYSTEM current\n");
1655 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)oglSystem.glxDrawable, oglSystem.glContext);
1656 //previous = oglSystem.glContext;
1659 GLBindBuffer(GL_ARRAY_BUFFER, 0);
1660 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1664 void UnlockSystem(DisplaySystem displaySystem)
1666 if(useSingleGLContext) return;
1667 #if defined(__WIN32__)
1668 wglMakeCurrent(null, null);
1669 #elif defined(__unix__) || defined(__APPLE__)
1670 // printf("Making NULL current\n");
1671 #if defined(__ANDROID__) || defined(__ODROID__)
1673 glXMakeCurrent(xGlobalDisplay, None, null);
1679 bool Lock(Display display)
1681 #if !defined(__ANDROID__) && !defined(__ODROID__)
1682 OGLDisplay oglDisplay = display.driverData;
1683 if(useSingleGLContext) return true;
1684 #if defined(__WIN32__)
1685 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1686 #elif defined(__unix__) || defined(__APPLE__)
1687 // if(previous) glXMakeCurrent(xGlobalDisplay, None, null);
1688 // printf(" Making DISPLAY current\n");
1689 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
1692 GLBindBuffer(GL_ARRAY_BUFFER, 0);
1693 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1697 void Unlock(Display display)
1699 if(useSingleGLContext) return;
1700 //printf(" Making NULL current\n");
1701 //glXMakeCurrent(xGlobalDisplay, None, null);
1703 LockSystem(display.displaySystem);
1706 void DestroyDisplay(Display display)
1708 OGLDisplay oglDisplay = display.driverData;
1712 #if defined(__WIN32__)
1713 wglMakeCurrent( null, null );
1716 wglDeleteContext(oglDisplay.glrc);
1718 if(oglDisplay.hdc && oglDisplay.pBuffer)
1719 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
1721 if(oglDisplay.pBuffer)
1722 wglDestroyPbufferARB(oglDisplay.pBuffer);
1725 ReleaseDC(display.window, oglDisplay.hdc);
1727 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
1728 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
1730 #elif defined(__unix__) || defined(__APPLE__)
1731 #if defined(__ANDROID__) || defined(__ODROID__)
1733 if(oglDisplay.shapePixmap)
1734 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
1735 if(oglDisplay.pixmap)
1736 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1737 if(oglDisplay.image)
1739 if(oglDisplay.shminfoShape.shmid != -1)
1741 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
1742 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1743 shmdt(oglDisplay.shminfo.shmaddr);
1744 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
1747 if(oglDisplay.shapeImage)
1749 if(oglDisplay.shminfoShape.shmid != -1)
1751 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
1752 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1753 shmdt(oglDisplay.shminfoShape.shmaddr);
1754 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
1756 XDestroyImage(oglDisplay.shapeImage);
1757 oglDisplay.shapeImage = None;
1760 glXMakeCurrent(xGlobalDisplay, None, null);
1762 if(oglDisplay.glContext)
1763 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
1766 delete oglDisplay.flippingBuffer;
1768 display.driverData = null;
1772 void ::CheckExtensions(OGLSystem oglSystem)
1774 const char * extensions = (const char *)glGetString(GL_EXTENSIONS);
1776 oglSystem.pow2textures = strstr(extensions, "GL_ARB_texture_non_power_of_two") ? false : true;
1777 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &oglSystem.maxTextureSize);
1780 bool CreateDisplaySystem(DisplaySystem displaySystem)
1782 bool result = false;
1783 OGLSystem oglSystem = displaySystem.driverData = OGLSystem { };
1786 oglSystem.hwnd = CreateWindow("static", null, 0,0,0,0,0,null,null,null,null);
1788 oglSystem.hdc = GetDC(oglSystem.hwnd);
1792 oglSystem.pfd.nSize = (short)sizeof(oglSystem.pfd);
1793 oglSystem.pfd.nVersion = 1;
1794 oglSystem.pfd.dwFlags = PFD_DRAW_TO_WINDOW /*PFD_DRAW_TO_BITMAP*/ | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
1795 oglSystem.pfd.iPixelType = PFD_TYPE_RGBA;
1796 oglSystem.pfd.cColorBits = 24;
1797 oglSystem.pfd.cAlphaBits = 8;
1798 oglSystem.pfd.cDepthBits = 24;
1799 oglSystem.pfd.iLayerType = PFD_MAIN_PLANE;
1801 oglSystem.format = ChoosePixelFormat(oglSystem.hdc, &oglSystem.pfd);
1802 DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1804 if(oglSystem.pfd.cColorBits > 8)
1806 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1807 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1810 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1812 // Get Pointers To The GL Functions
1813 glActiveTextureARB = (void *) wglGetProcAddress("glActiveTextureARB");
1814 glMultiTexCoord2fARB = (void *) wglGetProcAddress("glMultiTexCoord2fARB");
1815 glClientActiveTextureARB = (void *) wglGetProcAddress("glClientActiveTextureARB");
1816 glLockArraysEXT = (void *) wglGetProcAddress("glLockArraysEXT" );
1817 glUnlockArraysEXT = (void *) wglGetProcAddress("glUnlockArraysEXT");
1818 glGenBuffersARB = (void *) wglGetProcAddress("glGenBuffersARB");
1819 glBindBufferARB = (void *) wglGetProcAddress("glBindBufferARB");
1820 glBufferDataARB = (void *) wglGetProcAddress("glBufferDataARB");
1821 glMapBufferARB = (void *) wglGetProcAddress("glMapBufferARB");
1822 glUnmapBufferARB = (void *) wglGetProcAddress("glUnmapBufferARB");
1823 glDeleteBuffersARB = (void *) wglGetProcAddress("glDeleteBuffersARB");
1824 glBlendFuncSeparate = (void *) wglGetProcAddress("glBlendFuncSeparate");
1826 wglChoosePixelFormatARB = (void *) wglGetProcAddress("wglChoosePixelFormatARB");
1827 wglGetExtensionsStringARB = (void *)wglGetProcAddress("wglGetExtensionsStringARB");
1828 wglCreatePbufferARB = (void *)wglGetProcAddress("wglCreatePbufferARB");
1829 wglGetPbufferDCARB = (void *)wglGetProcAddress("wglGetPbufferDCARB");
1830 wglQueryPbufferARB = (void *)wglGetProcAddress("wglQueryPbufferARB");
1831 wglDestroyPbufferARB = (void *)wglGetProcAddress("wglDestroyPbufferARB");
1832 wglReleasePbufferDCARB = (void *)wglGetProcAddress("wglReleasePbufferDCARB");
1833 wglBindTexImageARB = (void *)wglGetProcAddress("wglBindTexImageARB");
1834 wglReleaseTexImageARB = (void *)wglGetProcAddress("wglReleaseTexImageARB");
1836 wglSwapIntervalEXT = (void *)wglGetProcAddress("wglSwapIntervalEXT");
1838 vboAvailable = glBindBufferARB != null;
1840 // eSystem_LoggingMode(LOG_MSGBOX, null);
1842 if(wglChoosePixelFormatARB)
1847 float fAttributes[] = {0,0};
1850 WGL_DRAW_TO_WINDOW_ARB,GL_TRUE,
1851 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1852 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
1853 WGL_COLOR_BITS_ARB,24,
1854 WGL_ALPHA_BITS_ARB,8,
1855 WGL_DEPTH_BITS_ARB,16,
1856 WGL_STENCIL_BITS_ARB,0,
1857 WGL_DOUBLE_BUFFER_ARB,GL_TRUE,
1858 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
1859 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
1863 //Log("Found wglChoosePixelFormatARB\n");
1865 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1866 if(!valid || !numFormats)
1868 //Log("Can't find 4x multi sampling\n");
1869 iAttributes[19] = 2;
1870 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1871 if(!valid || !numFormats)
1873 // Log("Can't find 2x multi sampling\n");
1874 iAttributes[16] = 0;
1875 iAttributes[17] = 0;
1876 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1879 if(valid && numFormats)
1881 oglSystem.format = pixelFormat;
1882 wglMakeCurrent(null, null);
1883 wglDeleteContext(oglSystem.glrc);
1885 // *** DescribePixelFormat does not support WGL pixel formats! ***
1886 //DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1887 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1888 //Log("Successfully set pixel format\n");
1890 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1891 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1895 eSystem_Logf("Can't find wglChoosePixelFormatARB\n");*/
1899 CheckExtensions(oglSystem);
1901 wglMakeCurrent(null, null);
1903 //eSystem_DumpErrors(true);
1907 #elif defined(__unix__) || defined(__APPLE__)
1908 vboAvailable = true;
1909 #if defined(__ANDROID__)
1910 egl_init_display(guiApp.desktop.windowHandle);
1911 #elif defined(__ODROID__)
1912 egl_init_display((uint)displaySystem.window);
1913 CheckExtensions(oglSystem);
1917 X11Window root = RootWindow( xGlobalDisplay, DefaultScreen( xGlobalDisplay ) );
1918 XSetWindowAttributes attr;
1923 #ifndef ECERE_MINIGLX
1924 GLX_USE_GL, GLX_DEPTH_SIZE, 1,
1927 GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,
1931 oglSystem.visualInfo = glXChooseVisual( xGlobalDisplay, DefaultScreen( xGlobalDisplay ), attrList );
1932 attr.background_pixel = 0;
1933 attr.border_pixel = 0;
1934 attr.colormap = XCreateColormap( xGlobalDisplay, root, oglSystem.visualInfo->visual, AllocNone);
1935 attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
1936 mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
1938 oglSystem.glxDrawable = XCreateWindow( xGlobalDisplay, root, 0, 0, 1, 1, 0, oglSystem.visualInfo->depth, InputOutput,
1939 oglSystem.visualInfo->visual, mask, &attr );
1941 if(oglSystem.visualInfo)
1943 oglSystem.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, null, True);
1944 if(oglSystem.glContext)
1946 glXMakeCurrent(xGlobalDisplay, oglSystem.glxDrawable, oglSystem.glContext);
1948 CheckExtensions(oglSystem);
1949 glXMakeCurrent(xGlobalDisplay, None, null);
1956 displaySystem.flags.alpha = true;
1957 displaySystem.flags.flipping = true;
1958 displaySystem.pixelFormat = pixelFormat888;
1962 void DestroyDisplaySystem(DisplaySystem displaySystem)
1964 OGLSystem oglSystem = displaySystem.driverData;
1966 #if defined(__WIN32__)
1967 wglMakeCurrent( null, null );
1970 wglDeleteContext(oglSystem.glrc);
1973 ReleaseDC(oglSystem.hwnd, oglSystem.hdc);
1974 DestroyWindow(oglSystem.hwnd);
1976 #elif defined(__unix__) || defined(__APPLE__)
1977 #if defined(__ANDROID__) || defined(__ODROID__)
1980 if(oglSystem.visualInfo)
1982 #ifdef ECERE_MINIGLX
1983 __miniglx_XFree(oglSystem.visualInfo);
1985 XFree(oglSystem.visualInfo);
1989 if(oglSystem.glxDrawable)
1991 XDestroyWindow(xGlobalDisplay, oglSystem.glxDrawable);
1992 oglSystem.glxDrawable = 0;
1999 bool CreateDisplay(Display display)
2001 bool result = false;
2002 OGLDisplay oglDisplay = display.driverData;
2003 #if !defined(__ANDROID__) && !defined(__ODROID__)
2004 OGLSystem oglSystem = display.displaySystem.driverData;
2007 oglDisplay = display.driverData = OGLDisplay { };
2008 //printf("Inside CreateDisplay\n");
2010 #if defined(__WIN32__) || defined(USEPBUFFER)
2011 if(!display.alphaBlend)
2014 #if defined(__WIN32__)
2015 oglDisplay.hdc = GetDC(display.window);
2016 SetPixelFormat(oglDisplay.hdc, oglSystem.format, &oglSystem.pfd);
2017 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
2019 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2020 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2024 ReleaseDC(display.window, oglDisplay.hdc);
2025 #elif defined(__unix__) || defined(__APPLE__)
2026 #if defined(__ANDROID__) || defined(__ODROID__)
2028 XVisualInfo * visualInfo = ((XWindowData)display.windowDriverData).visual;
2030 #if defined(__APPLE__)
2031 XVisualInfo template = { 0 };
2032 XWindowAttributes winAttr;
2034 XGetWindowAttributes(xGlobalDisplay, (X11Window)display.window, &winAttr);
2035 template.visualid = XVisualIDFromVisual(winAttr.visual);
2036 visualInfo = XGetVisualInfo(xGlobalDisplay, VisualIDMask, &template, &n);
2038 printf("XGetVisualInfo visual ID = %d\n", template.visualid);
2039 printf("visualInfo visual ID = %d\n", visualInfo->visualid);
2040 printf("oglSystem.visualInfo visual ID = %d\n", oglSystem.visualInfo->visualid);
2041 printf("((XWindowData)display.windowDriverData).visual visual ID = %d\n", ((XWindowData)display.windowDriverData).visual->visualid);
2043 // visualInfo = oglSystem.visualInfo;
2048 //printf("visualInfo is not null\n");
2049 // printf("Creating Display Context, sharing with %x!\n", oglSystem.glContext);
2050 oglDisplay.glContext = glXCreateContext(xGlobalDisplay, visualInfo, oglSystem.glContext, True);
2051 //XFree(visualInfo);
2054 // oglDisplay.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, oglSystem.glContext, True);
2055 if(oglDisplay.glContext)
2057 //printf("CreateDisplay Got a Context\n");
2058 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2064 #if defined(__WIN32__) || defined(USEPBUFFER)
2070 GLBindBuffer(GL_ARRAY_BUFFER, 0);
2071 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
2073 #if defined(__WIN32__)
2074 if(glBlendFuncSeparate)
2075 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2077 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2079 #if !defined(__OLDX__)
2080 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2082 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2087 glMatrixMode(GL_MODELVIEW);
2088 glLoadIdentity(); // For setting up GLES stack
2089 glScaled(1.0, 1.0, -1.0);
2090 // glTranslatef(0.375f, 0.375f, 0.0f);
2091 // glTranslatef(-0.625f, -0.625f, 0.0f);
2092 glMatrixMode(GL_PROJECTION);
2093 glShadeModel(GL_FLAT);
2095 // glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, true);
2096 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
2097 glFogi(GL_FOG_MODE, GL_EXP);
2098 glFogf(GL_FOG_DENSITY, 0);
2099 glEnable(GL_NORMALIZE);
2100 glDepthFunc(GL_LESS);
2102 glDisable(GL_MULTISAMPLE_ARB);
2104 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
2105 display.ambient = Color { 50,50,50 };
2108 if(!useSingleGLContext)
2110 #if defined(__WIN32__)
2111 wglMakeCurrent(null, null);
2112 #elif defined(__unix__) || defined(__APPLE__)
2113 #if defined(__ANDROID__) || defined(__ODROID__)
2116 glXMakeCurrent(xGlobalDisplay, None, null);
2122 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2130 bool DisplaySize(Display display, int width, int height)
2132 OGLDisplay oglDisplay = display.driverData;
2134 bool result = false;
2136 //printf("Inside DisplaySize\n");
2137 #if defined(__WIN32__) || defined(USEPBUFFER)
2138 OGLSystem oglSystem = display.displaySystem.driverData;
2139 if(display.alphaBlend)
2141 #if defined(__WIN32__)
2142 const int attributes[]=
2144 /*WGL_TEXTURE_FORMAT_ARB, WGL_TEXTURE_RGBA_ARB,
2145 WGL_TEXTURE_TARGET_ARB, WGL_TEXTURE_2D_ARB, */0
2147 int pixelFormat = 0;
2148 if(wglChoosePixelFormatARB)
2152 float fAttributes[] = {0,0};
2155 //WGL_DRAW_TO_BITMAP_ARB, GL_TRUE,
2156 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2157 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2158 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
2159 WGL_COLOR_BITS_ARB,24,
2160 WGL_ALPHA_BITS_ARB,8,
2161 WGL_DEPTH_BITS_ARB,16,
2162 WGL_STENCIL_BITS_ARB,0,
2163 WGL_DOUBLE_BUFFER_ARB,GL_FALSE,
2164 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
2165 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
2169 //Log("Found wglChoosePixelFormatARB\n");
2171 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2172 if(!valid || !numFormats)
2174 //Log("Can't find 4x multi sampling\n");
2175 iAttributes[19] = 2;
2176 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2177 if(!valid || !numFormats)
2179 // Log("Can't find 2x multi sampling\n");
2180 iAttributes[16] = 0;
2181 iAttributes[17] = 0;
2182 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2183 if(!valid || !numFormats)
2187 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2188 //WGL_DRAW_TO_BITMAP_ARB,GL_TRUE,
2189 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2190 WGL_COLOR_BITS_ARB,24,
2191 WGL_ALPHA_BITS_ARB,8,
2192 WGL_DEPTH_BITS_ARB,16,
2195 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2199 if(valid && numFormats)
2201 wglMakeCurrent(null, null);
2205 wglMakeCurrent( null, null );
2206 wglMakeCurrent( oglDisplay.hdc, oglDisplay.glrc );
2207 if(oglDisplay.hdc && oglDisplay.pBuffer)
2208 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
2210 wglDestroyPbufferARB(oglDisplay.pBuffer);
2212 if(!useSingleGLContext)
2213 wglMakeCurrent( null, null );
2216 wglDeleteContext(oglDisplay.glrc);
2218 oglDisplay.pBuffer = wglCreatePbufferARB(oglSystem.hdc, pixelFormat, width, height, attributes);
2219 oglDisplay.hdc = wglGetPbufferDCARB(oglDisplay.pBuffer);
2220 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
2223 HDC hdc = GetDC(display.window);
2225 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2226 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2228 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_WIDTH_ARB, &width);
2229 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_HEIGHT_ARB, &height);
2231 // glDeleteBuffersARB(2, oglDisplay.imageBuffers);
2233 if((info = (BITMAPINFO *)new0 byte[sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*256]))
2237 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
2238 oglDisplay.memDC = CreateCompatibleDC(hdc);
2239 SetMapMode(oglDisplay.memDC, MM_TEXT);
2240 info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2241 info->bmiHeader.biPlanes = 1;
2242 info->bmiHeader.biCompression = BI_RGB;
2243 info->bmiHeader.biBitCount = 32; //(uint16)GetDeviceCaps(hdc, BITSPIXEL);
2244 info->bmiHeader.biWidth = width;
2245 info->bmiHeader.biHeight = height;
2246 newBitmap = CreateDIBSection(hdc, info, DIB_RGB_COLORS, &oglDisplay.picture, null, 0);
2249 SelectObject(oglDisplay.memDC, newBitmap);
2250 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
2253 PIXELFORMATDESCRIPTOR pfd = { 0 };
2254 pfd.nSize = (short)sizeof(pfd);
2256 pfd.dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL;
2257 pfd.iPixelType = PFD_TYPE_RGBA;
2258 pfd.cColorBits = 32;
2259 //pfd.cAlphaBits = 8;
2260 pfd.cDepthBits = 24;
2261 pfd.iLayerType = PFD_MAIN_PLANE;
2263 oglDisplay.hdc = oglDisplay.memDC;
2265 pixelFormat = ChoosePixelFormat(oglSystem.hdc, &pfd);
2266 DescribePixelFormat(oglDisplay.hdc, pixelFormat, sizeof(pfd), &pfd);
2267 SetPixelFormat(oglDisplay.hdc, pixelFormat, &pfd);
2269 oglDisplay.glrc = wglCreateContext(oglDisplay.hdc);
2270 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2271 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2276 const int imageSize = width * height * 4;
2278 glGenBuffersARB(2, oglDisplay.imageBuffers);
2280 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2281 glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize, null, GL_STREAM_READ);
2282 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2283 // glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize / 2, null, GL_STREAM_READ);
2286 oglDisplay.memBitmap = newBitmap;
2287 oglDisplay.stride = width;
2293 ReleaseDC(display.window, hdc);
2295 #elif defined(__unix__) || defined(__APPLE__)
2296 #if defined(__ANDROID__) || defined(__ODROID__)
2301 GLX_DOUBLEBUFFER, True,
2307 GLX_STENCIL_SIZE, 1,
2308 //GLX_DEPTH_SIZE, 24,
2309 GLX_RENDER_TYPE, GLX_RGBA_BIT,
2310 GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT | GLX_WINDOW_BIT,
2316 GLX_PBUFFER_WIDTH, width,
2317 GLX_PBUFFER_HEIGHT, height,
2318 GLX_LARGEST_PBUFFER, False,
2322 // choose a pixel format that meets our minimum requirements
2325 GLXFBConfig *config = glXChooseFBConfig(xGlobalDisplay, DefaultScreen(xGlobalDisplay), attrib, &count);
2328 if(oglDisplay.pixmap)
2330 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2331 oglDisplay.pixmap = None;
2333 if(oglDisplay.shapePixmap)
2335 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
2336 oglDisplay.shapePixmap = None;
2339 // Free Shared Memory Pixmap
2340 if(oglDisplay.image)
2342 if(oglDisplay.shminfoShape.shmid != -1)
2344 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
2345 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2346 shmdt(oglDisplay.shminfo.shmaddr);
2347 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
2349 XDestroyImage(oglDisplay.image);
2350 oglDisplay.image = None;
2352 if(oglDisplay.shapeImage)
2354 if(oglDisplay.shminfoShape.shmid != -1)
2356 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
2357 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2358 shmdt(oglDisplay.shminfoShape.shmaddr);
2359 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
2361 XDestroyImage(oglDisplay.shapeImage);
2362 oglDisplay.shapeImage = None;
2365 if(oglDisplay.windowPicture)
2366 XRenderFreePicture(xGlobalDisplay, oglDisplay.windowPicture);
2367 if(oglDisplay.pixmapPicture)
2368 XRenderFreePicture(xGlobalDisplay, oglDisplay.pixmapPicture);
2370 if(oglDisplay.pixmap)
2371 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2373 if(oglDisplay.glContext)
2374 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
2375 if(oglDisplay.pBuffer)
2376 glXDestroyPbuffer(xGlobalDisplay, oglDisplay.pBuffer);
2378 oglDisplay.pBuffer = glXCreatePbuffer(xGlobalDisplay, config[0], PBattrib);
2379 if(oglDisplay.pBuffer)
2381 oglDisplay.glContext = glXCreateNewContext(xGlobalDisplay, config[0], GLX_RGBA_TYPE, oglSystem.glContext, True);
2382 if(oglDisplay.glContext)
2384 glXMakeCurrent(xGlobalDisplay, None, null);
2385 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2387 // Initialize Shared Memory Pixmap
2388 oglDisplay.image = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 32,
2389 ZPixmap, null, &oglDisplay.shminfo, width, height);
2390 if(oglDisplay.image)
2392 oglDisplay.shminfo.shmid = shmget(IPC_PRIVATE,
2393 oglDisplay.image->bytes_per_line * oglDisplay.image->height, IPC_CREAT|0777);
2394 if(oglDisplay.shminfo.shmid != -1)
2396 oglDisplay.shminfo.shmaddr = shmat(oglDisplay.shminfo.shmid, 0, 0);
2397 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2399 oglDisplay.shminfo.readOnly = False;
2400 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfo))
2402 oglDisplay.pixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfo.shmaddr,
2403 &oglDisplay.shminfo, width, height, 32);
2405 // Initialize Shared Memory Shape Pixmap
2406 oglDisplay.shapeImage = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 1,
2407 ZPixmap, null, &oglDisplay.shminfoShape, width, height);
2408 if(oglDisplay.shapeImage)
2410 oglDisplay.shminfoShape.shmid = shmget(IPC_PRIVATE,
2411 oglDisplay.shapeImage->bytes_per_line * oglDisplay.shapeImage->height, IPC_CREAT|0777);
2412 if(oglDisplay.shminfoShape.shmid != -1)
2414 oglDisplay.shminfoShape.shmaddr = shmat(oglDisplay.shminfoShape.shmid, 0, 0);
2415 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2417 oglDisplay.shminfoShape.readOnly = False;
2418 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfoShape))
2420 oglDisplay.shapePixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfoShape.shmaddr,
2421 &oglDisplay.shminfoShape, width, height, 1);
2422 //oglDisplay.shapePixmap = XCreatePixmap(xGlobalDisplay, (X11Window)display.window, width, height, 1);
2425 XRenderPictureAttributes attributes = { 0 };
2426 XRenderPictFormat * format = XRenderFindStandardFormat(xGlobalDisplay, /*PictStandardRGB24*/ PictStandardARGB32);
2427 #if !defined(__APPLE__) && !defined(__OLDX__)
2428 attributes.repeat = RepeatNormal;
2430 attributes.repeat = 1;
2432 oglDisplay.pixmapPicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.pixmap, format, CPRepeat, &attributes);
2433 oglDisplay.windowPicture = XRenderCreatePicture(xGlobalDisplay, (X11Window)display.window, format, 0, &attributes);
2434 oglDisplay.shapePicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.shapePixmap,
2435 XRenderFindStandardFormat(xGlobalDisplay, PictStandardA1), 0, &attributes);
2438 oglDisplay.picture = oglDisplay.shminfo.shmaddr;
2439 oglDisplay.stride = oglDisplay.image->bytes_per_line / 4;
2456 CreateDisplay(display);
2457 #if defined(__WIN32__)
2458 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2459 #elif defined(__unix__) || defined(__APPLE__)
2460 #if defined(__ANDROID__) || defined(__ODROID__)
2464 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2471 if(!result && display.alphaBlend)
2473 printf("Alpha blending windows not supported on this display\n");
2480 glViewport(0,0,width,height);
2481 glMatrixMode(GL_PROJECTION);
2483 glOrtho(0,width,height,0,0.0,1.0);
2484 displayWidth = display.width = width;
2485 displayHeight = display.height = height;
2487 if(!oglDisplay.flippingBuffer || oglDisplay.flipBufW < width || oglDisplay.flipBufH < height)
2489 oglDisplay.flipBufW = width;
2490 oglDisplay.flipBufH = height;
2494 oglDisplay.flippingBuffer = renew oglDisplay.flippingBuffer ColorAlpha [width * height];
2497 if(oglDisplay.flippingBuffer || !width || !height)
2503 void DisplayPosition(Display display, int x, int y)
2505 OGLDisplay oglDisplay = display.driverData;
2511 void SetPalette(Display display, ColorAlpha * palette, bool colorMatch)
2515 void RestorePalette(Display display)
2519 void StartUpdate(Display display)
2523 void EndUpdate(Display display)
2527 void Scroll(Display display, Box scroll, int x, int y, Extent dirty)
2531 void Update(Display display, Box updateBox)
2533 #if defined(__WIN32__) || defined(USEPBUFFER)
2534 OGLDisplay oglDisplay = display.driverData;
2536 //Logf("DisplayScreen\n");
2540 #if defined(__WIN32__) || defined(USEPBUFFER)
2541 if(display.alphaBlend)
2543 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2544 glPixelStorei(GL_PACK_ROW_LENGTH, oglDisplay.stride);
2545 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2546 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2547 glReadPixels(0,0,display.width,display.height,GL_BGRA_EXT,GL_UNSIGNED_BYTE, oglDisplay.picture);
2550 #if defined(__WIN32__)
2552 POINT point = { oglDisplay.x, oglDisplay.y};
2553 POINT srcPoint = { 0, 0 };
2554 BLENDFUNCTION blend = { 0 };
2556 size.cx = display.width;
2557 size.cy = display.height;
2558 blend.BlendOp = AC_SRC_OVER;
2559 blend.BlendFlags = 0;
2560 blend.SourceConstantAlpha = 255;
2561 blend.AlphaFormat = AC_SRC_ALPHA;
2564 // Process partial images. Mapping the buffer waits for
2565 // outstanding DMA transfers into the buffer to finish.
2566 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2567 oglDisplay.pboMemory1 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY);
2569 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2570 // oglDisplay.pboMemory2 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB,GL_READ_ONLY);
2573 memcpy(oglDisplay.picture, oglDisplay.pboMemory1, display.width * display.height * 4);
2574 //memcpy(oglDisplay.picture + display.width * display.height * 4 / 2, oglDisplay.pboMemory2, display.width * display.height * 4/ 2);
2577 UpdateLayeredWindow(display.window, hdc, &point, &size, oglDisplay.memDC, &srcPoint, 0, &blend, ULW_ALPHA);
2580 // Unmap the image buffers
2581 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2582 glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2584 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2585 // glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2587 // Bind two different buffer objects and start the glReadPixels
2588 // asynchronously. Each call will return directly after
2589 // starting the DMA transfer.
2590 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2591 glReadPixels(0, 0, display.width, display.height, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2593 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2594 // glReadPixels(0, display.height/2, display.width, display.height/2, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2598 #elif defined(__unix__) || defined(__APPLE__)
2599 #if defined(__ANDROID__) || defined(__ODROID__)
2601 XTransform transform =
2604 { (int)(1.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(0 * (1 << 16)) },
2605 { (int)(0.0f), (int)(-1.0f * (1<<16)), (int)(0 * (1<<16)) },
2606 { (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)) }
2609 XRenderSetPictureTransform(xGlobalDisplay, oglDisplay.pixmapPicture, &transform);
2610 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.shapePicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2611 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.windowPicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2612 #if !defined(__APPLE__) && !defined(__OLDX__)
2613 XShapeCombineMask(xGlobalDisplay, (X11Window)display.window, ShapeInput, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2615 XShapeCombineMask(xGlobalDisplay, display.window, 2, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2617 XFlush(xGlobalDisplay);
2625 #if defined(__WIN32__)
2626 //wglSwapLayerBuffers(oglDisplay.hdc,WGL_SWAP_MAIN_PLANE);
2627 SwapBuffers(oglDisplay.hdc);
2628 #elif defined(__unix__) || defined(__APPLE__)
2629 #if defined(__ANDROID__) || defined(__ODROID__)
2630 eglSwapBuffers(eglDisplay, eglSurface);
2632 glXSwapBuffers(xGlobalDisplay, (GLXDrawable)display.window);
2636 //Logf("Out of DisplayScreen\n");
2639 void FreeBitmap(DisplaySystem displaySystem, Bitmap bitmap)
2641 if(bitmap.driverData)
2643 GLuint tex = (GLuint)(uintptr)bitmap.driverData;
2644 glDeleteTextures(1, &tex);
2645 bitmap.driverData = 0;
2647 bitmap.driver = ((subclass(DisplayDriver))class(LFBDisplayDriver));
2650 bool AllocateBitmap(DisplaySystem displaySystem, Bitmap bitmap, int width, int height, int stride, PixelFormat format, bool allocatePalette)
2652 OGLSystem oglSystem = displaySystem.driverData;
2653 bool result = false;
2655 GLuint glBitmap = 0;
2657 uint w = width, h = height;
2658 if(oglSystem.pow2textures)
2663 w = Min(w, oglSystem.maxTextureSize);
2664 h = Min(h, oglSystem.maxTextureSize);
2666 glGenTextures(1, &glBitmap);
2667 glBindTexture(GL_TEXTURE_2D, glBitmap);
2669 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2671 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2672 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2674 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2675 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2677 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2679 mipMap.Allocate(null, w, h, w, pixelFormatRGBA, false);
2681 // glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2682 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2686 bitmap.driverData = (void *)(uintptr)glBitmap;
2687 bitmap.driver = displaySystem.driver;
2695 bool MakeDDBitmap(DisplaySystem displaySystem, Bitmap bitmap, bool mipMaps)
2697 bool result = false;
2698 OGLSystem oglSystem = displaySystem.driverData;
2699 Bitmap convBitmap = bitmap;
2703 convBitmap.Copy(bitmap);
2706 // Pre process the bitmap... First make it 32 bit
2707 if(/*bitmap.pixelFormat == pixelFormatRGBA || */convBitmap.Convert(null, pixelFormat888, null))
2710 uint w = bitmap.width, h = bitmap.height;
2711 GLuint glBitmap = 0;
2712 if(oglSystem.pow2textures)
2717 w = Min(w, oglSystem.maxTextureSize);
2718 h = Min(h, oglSystem.maxTextureSize);
2722 while(w * 2 < h) w *= 2;
2723 while(h * 2 < w) h *= 2;
2726 // Switch ARGB to RGBA
2727 //if(bitmap.format != pixelFormatRGBA)
2729 for(c=0; c<bitmap.size; c++)
2731 // ((ColorRGBA *)bitmap.picture)[c] = ((ColorAlpha *)bitmap.picture)[c];
2733 ColorAlpha color = ((ColorAlpha *)convBitmap.picture)[c];
2734 ((ColorRGBA *)convBitmap.picture)[c] = ColorRGBA { color.color.r, color.color.g, color.color.b, color.a };
2737 // convBitmap.pixelFormat = pixelFormat888;
2740 glGenTextures(1, &glBitmap);
2743 //int error = glGetError();
2747 glBindTexture(GL_TEXTURE_2D, glBitmap);
2748 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2750 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, mipMaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
2751 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2753 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2755 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
2756 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
2758 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2759 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2761 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2765 for(level = 0; result && (w >= 1 || h >= 1); level++, w >>= 1, h >>= 1)
2770 if(bitmap.width != w || bitmap.height != h)
2772 mipMap = Bitmap { };
2773 if(mipMap.Allocate(null, w, h, w, convBitmap.pixelFormat, false))
2775 Surface mipSurface = mipMap.GetSurface(0,0,null);
2776 mipSurface.Filter(convBitmap, 0,0,0,0, w, h, convBitmap.width, convBitmap.height);
2786 mipMap = convBitmap;
2793 // glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2794 glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2795 //printf("Calling glTexImage2D\n");
2796 //glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &width);
2797 //printf("width = %d (Should be %d, %d)\n", width, w, h);
2798 if((error = glGetError()))
2800 //Logf("OpenGL Bitmap MakeDD error: %d...\n", error);
2801 //printf("OpenGL Bitmap MakeDD error: %d...\n", error);
2805 if(mipMap != convBitmap)
2810 convBitmap.driver.FreeBitmap(convBitmap.displaySystem, convBitmap);
2811 bitmap.driverData = (void *)(uintptr)glBitmap;
2812 bitmap.driver = displaySystem.driver;
2817 FreeBitmap(displaySystem, bitmap);
2818 else if(oglSystem.loadingFont)
2820 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2821 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2822 oglSystem.loadingFont = false;
2828 void ReleaseSurface(Display display, Surface surface)
2830 glDisable(GL_SCISSOR_TEST);
2831 delete surface.driverData;
2832 surface.driverData = null;
2835 bool GetBitmapSurface(DisplaySystem displaySystem, Surface surface, Bitmap bitmap, int x, int y, Box clip)
2840 bool GetSurface(Display display, Surface surface, int x,int y, Box clip)
2842 bool result = false;
2843 OGLSurface oglSurface = surface.driverData = OGLSurface { };
2845 //Logf("GetSurface\n");
2849 if(displayWidth != display.width || displayHeight != display.height)
2851 displayWidth = display.width;
2852 displayHeight = display.height;
2854 glViewport(0,0,display.width,display.height);
2856 glOrtho(0,display.width,display.height,0,0.0,1.0);
2859 surface.offset.x = x;
2860 surface.offset.y = y;
2861 surface.unclippedBox = surface.box = clip;
2862 oglSurface.bitmapMult[0] = 1;
2863 oglSurface.bitmapMult[1] = 1;
2864 oglSurface.bitmapMult[2] = 1;
2865 oglSurface.bitmapMult[3] = 1;
2867 glEnable(GL_SCISSOR_TEST);
2870 (display.height) -(y+clip.bottom)-1,
2871 clip.right-clip.left+1,
2872 clip.bottom-clip.top+1);
2878 void Clip(Display display, Surface surface, Box clip)
2887 box.Clip(surface.unclippedBox);
2891 box = surface.box = surface.unclippedBox;
2892 box.left += surface.offset.x;
2893 box.top += surface.offset.y;
2894 box.right+= surface.offset.x;
2895 box.bottom += surface.offset.y;
2898 box.left,display.height - box.bottom - 1,
2899 box.right-box.left+1, box.bottom-box.top+1);
2902 bool GrabScreen(Display display, Bitmap bitmap, int x, int y, unsigned int w, unsigned int h)
2904 bool result = false;
2905 OGLDisplay oglDisplay = display.driverData;
2906 ColorAlpha * flippingBuffer = oglDisplay.flippingBuffer;
2908 if(oglDisplay.flippingBuffer)
2910 if(bitmap.pixelFormat != pixelFormat888 || bitmap.width < w || bitmap.height < h)
2913 bitmap.Allocate(null, w,h,w, pixelFormat888, false);
2919 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2920 glPixelStorei(GL_PACK_ROW_LENGTH, bitmap.stride);
2921 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2922 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2923 glReadPixels(x,display.height-h-y,w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, flippingBuffer);
2926 for(row = 0; row<h; row++)
2927 CopyBytesBy4(((ColorAlpha *)bitmap.picture) + row * w, ((ColorAlpha *)flippingBuffer) + (h-row-1) * w, w);
2934 void SetForeground(Display display, Surface surface, ColorAlpha color)
2936 OGLSurface oglSurface = surface.driverData;
2938 //Logf("SetForeground\n");
2940 oglSurface.foreground[0] = color.color.r/255.0f;
2941 oglSurface.foreground[1] = color.color.g/255.0f;
2942 oglSurface.foreground[2] = color.color.b/255.0f;
2943 //oglSurface.foreground[3] = 1.0f;
2944 oglSurface.foreground[3] = color.a/255.0f;
2946 //if(!oglSurface.foreground[3])printf("bug");
2949 void SetBackground(Display display, Surface surface, ColorAlpha color)
2951 OGLSurface oglSurface = surface.driverData;
2953 //Logf("SetBackground\n");
2955 oglSurface.background[0] = color.color.r/255.0f;
2956 oglSurface.background[1] = color.color.g/255.0f;
2957 oglSurface.background[2] = color.color.b/255.0f;
2958 //oglSurface.background[3] = 1.0;
2959 oglSurface.background[3] = color.a/255.0f;
2962 void SetBlitTint(Display display, Surface surface, ColorAlpha color)
2964 OGLSurface oglSurface = surface.driverData;
2966 oglSurface.bitmapMult[0] = color.color.r/255.0f;
2967 oglSurface.bitmapMult[1] = color.color.g/255.0f;
2968 oglSurface.bitmapMult[2] = color.color.b/255.0f;
2969 oglSurface.bitmapMult[3] = color.a/255.0f;
2972 ColorAlpha GetPixel(Display display, Surface surface,int x,int y)
2977 void PutPixel(Display display, Surface surface,int x,int y)
2979 OGLSurface oglSurface = surface.driverData;
2981 //Logf("PutPixel\n");
2983 glColor4fv(oglSurface.foreground);
2985 // glVertex2i(x+surface.offset.x, y+surface.offset.y);
2986 glVertex2f(x+surface.offset.x + 0.5f, y+surface.offset.y + 0.5f);
2991 void DrawLine(Display display, Surface surface, int _x1, int _y1, int _x2, int _y2)
2993 OGLSurface oglSurface = surface.driverData;
2994 float x1 = _x1, x2 = _x2, y1 = _y1, y2 = _y2;
3009 x1 += surface.offset.x;
3010 y1 += surface.offset.y;
3011 x2 += surface.offset.x;
3012 y2 += surface.offset.y;
3016 glColor4fv(oglSurface.foreground);
3021 glTexCoord2f(0.5f, 0);
3022 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3023 glTexCoord2f(Max(x2-x1, y2-y1) + 0.5f, 0);
3024 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3033 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3034 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3040 void Rectangle(Display display, Surface surface,int x1,int y1,int x2,int y2)
3042 OGLSurface oglSurface = surface.driverData;
3043 x1 += surface.offset.x;
3044 y1 += surface.offset.y;
3045 x2 += surface.offset.x;
3046 y2 += surface.offset.y;
3048 //Logf("Rectangle\n");
3050 glColor4fv(oglSurface.foreground);
3056 glTexCoord2f(0.5f, 0);
3057 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3058 glTexCoord2f(y2-y1 + 0.5f, 0);
3059 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3061 glTexCoord2f(0.5f, 0);
3062 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3063 glTexCoord2f(x2 - x1 + 0.5f, 0);
3064 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3066 glTexCoord2f(0.5f, 0);
3067 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3068 glTexCoord2f(y1 - y2 + 0.5f, 0);
3069 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3071 glTexCoord2f(0.5f, 0);
3072 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3073 glTexCoord2f(x1 - x2 + 0.5f, 0);
3074 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3079 glBegin(GL_LINE_LOOP);
3086 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3087 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3088 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3089 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3094 void Area(Display display, Surface surface,int x1,int y1,int x2,int y2)
3096 OGLSurface oglSurface = surface.driverData;
3099 glColor4fv(oglSurface.background);
3100 glRecti(x1+surface.offset.x, y1+surface.offset.y,
3101 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
3104 glRectf(x1+surface.offset.x, y1+surface.offset.y,
3105 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
3109 void Clear(Display display, Surface surface, ClearType type)
3111 OGLDisplay oglDisplay = display.driverData;
3112 OGLSurface oglSurface = surface.driverData;
3115 if(type != depthBuffer)
3116 glClearColor(oglSurface.background[0], oglSurface.background[1], oglSurface.background[2], oglSurface.background[3]);
3117 if(type != colorBuffer && !oglDisplay.depthWrite)
3119 glDepthMask((byte)bool::true);
3121 glClear(((type != depthBuffer) ? GL_COLOR_BUFFER_BIT : 0) |
3122 ((type != colorBuffer) ? GL_DEPTH_BUFFER_BIT : 0));
3123 if(type != colorBuffer && !oglDisplay.depthWrite)
3125 glDepthMask((byte)bool::false);
3129 bool ConvertBitmap(DisplaySystem displaySystem, Bitmap bitmap, PixelFormat format, ColorAlpha * palette)
3134 void Blit(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3136 OGLSurface oglSurface = surface.driverData;
3138 #if !defined(__OLDX__)
3139 // WHY DO WE HAVE GL_ONE HERE ?
3140 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3141 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3144 if(!oglSurface.writingText)
3146 // glTranslatef(-0.375f, -0.375f, 0.0f);
3147 glEnable(GL_TEXTURE_2D);
3148 glColor4fv(oglSurface.bitmapMult);
3150 else if(oglSurface.xOffset)
3151 glTranslated(oglSurface.xOffset / 64.0/*-0.375*/, 0.0, 0.0);
3153 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3158 glTexCoord2f((float)sx/ bitmap.width, (float)(sy-h)/ bitmap.height);
3159 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3160 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy-h)/ bitmap.height);
3161 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3162 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3163 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
3164 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3165 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3170 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3171 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3172 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3173 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3174 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3175 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3176 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3177 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3180 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3181 glVertex2f((float)dx+surface.offset.x, (float)dy+surface.offset.y);
3182 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3183 glVertex2f((float)dx+w+surface.offset.x, (float)dy+surface.offset.y);
3184 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3185 glVertex2f((float)dx+w+surface.offset.x, (float)dy+h+surface.offset.y);
3186 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3187 glVertex2f((float)dx+surface.offset.x, (float)dy+h+surface.offset.y);
3191 if(!oglSurface.writingText)
3193 glDisable(GL_TEXTURE_2D);
3195 //glTranslate(0.375, 0.375, 0.0);
3197 else if(oglSurface.xOffset)
3198 glTranslated(-oglSurface.xOffset / 64.0/*+0.375*/, 0.0, 0.0);
3200 #if !defined(__OLDX__)
3201 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3202 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3206 void Stretch(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3208 OGLSurface oglSurface = surface.driverData;
3210 //glTranslate(-0.375, -0.375, 0.0);
3212 //Logf("Stretch\n");
3214 #if !defined(__OLDX__)
3215 /*if(glBlendFuncSeparate)
3216 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3219 glEnable(GL_TEXTURE_2D);
3220 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3222 glColor4fv(oglSurface.bitmapMult);
3228 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3229 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3231 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3232 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3234 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3235 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
3237 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3238 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3242 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3243 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3245 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3246 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3248 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3249 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3251 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3252 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3257 glDisable(GL_TEXTURE_2D);
3259 //glTranslate(0.375, 0.375, 0.0);
3260 #if !defined(__OLDX__)
3261 /*if(glBlendFuncSeparate)
3262 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3267 void Filter(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3269 Stretch(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3272 void StretchDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3274 float s2dw,s2dh,d2sw,d2sh;
3275 //bool flipX = false, flipY = false;
3277 //Logf("StretchDI\n");
3279 if(Sgn(w) != Sgn(sw))
3285 if(Sgn(h) != Sgn(sh))
3297 //Clip against the edges of the source
3300 dx+=(int)((0-sx) * s2dw);
3301 w-=(int)((0-sx) * s2dw);
3307 dy+=(int)((0-sy) * s2dh);
3308 h-=(int)((0-sy) * s2dh);
3313 if(sx+sw>bitmap.width-1)
3315 w-=(int)((sx+sw-(bitmap.width-1)-1)*s2dw);
3316 sw-=sx+sw-(bitmap.width-1)-1;
3318 if(sy+sh>(bitmap.height-1))
3320 h-=(int)((sy+sh-(bitmap.height-1)-1)*s2dh);
3321 sh-=sy+sh-(bitmap.height-1)-1;
3323 //Clip against the edges of the surfaceination
3324 if(dx<surface.box.left)
3327 sx+=(int)((surface.box.left-dx)*d2sw);
3328 sw-=(int)((surface.box.left-dx)*d2sw);
3329 w-=surface.box.left-dx;
3330 dx=surface.box.left;
3332 if(dy<surface.box.top)
3334 sy+=(int)((surface.box.top-dy)*d2sh);
3335 sh-=(int)((surface.box.top-dy)*d2sh);
3336 h-=surface.box.top-dy;
3339 if(dx+w>surface.box.right)
3341 //if(flip) sx+=(int)((dx+w-surface.box.right-1)*d2sw);
3342 sw-=(int)((dx+w-surface.box.right-1)*d2sw);
3343 w-=dx+w-surface.box.right-1;
3345 if(dy+h>surface.box.bottom)
3347 sh-=(int)((dy+h-surface.box.bottom-1)*d2sh);
3348 h-=dy+h-surface.box.bottom-1;
3350 if((w<=0)||(h<=0)||(sw<=0)||(sh<=0)) return;
3352 dx += surface.offset.x;
3353 dy += surface.offset.y;
3355 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3357 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3358 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3359 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3360 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3361 glRasterPos2d(dx,dy);
3362 //glPixelZoom(flipX ? -s2dw : s2dw, flipY ? s2dh : -s2dh);
3363 glPixelZoom(s2dw, -s2dh);
3364 glDrawPixels(sw,sh,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3365 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3366 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3367 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3368 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3372 void BlitDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3376 //Clip against the edges of the source
3389 if(sx+w>bitmap.width-1)
3390 w-=sx+w-(bitmap.width-1)-1;
3391 if(sy+h>bitmap.height-1)
3392 h-=sy+h-(bitmap.height-1)-1;
3393 //Clip against the edges of the surfaceination
3394 if(dx<surface.box.left)
3397 sx+=surface.box.left-dx;
3398 w-=surface.box.left-dx;
3399 dx=surface.box.left;
3401 if(dy<surface.box.top)
3403 sy+=surface.box.top-dy;
3404 h-=surface.box.top-dy;
3407 if(dx+w>surface.box.right)
3409 //if(flip) sx+=dx+w-surface.box.right-1;
3410 w-=dx+w-surface.box.right-1;
3412 if(dy+h>surface.box.bottom)
3413 h-=dy+h-surface.box.bottom-1;
3417 dx += surface.offset.x;
3418 dy += surface.offset.y;
3420 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3422 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3423 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3424 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3425 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3426 glRasterPos2d(dx,dy);
3428 glDrawPixels(w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3429 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3430 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3431 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3432 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3436 void FilterDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3438 StretchDI(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3441 void UnloadFont(DisplaySystem displaySystem, Font font)
3443 ((subclass(DisplayDriver))class(LFBDisplayDriver)).UnloadFont(displaySystem, font);
3446 Font LoadFont(DisplaySystem displaySystem, const char * faceName, float size, FontFlags flags)
3449 OGLSystem oglSystem = displaySystem.driverData;
3450 oglSystem.loadingFont = true;
3451 font = ((subclass(DisplayDriver))class(LFBDisplayDriver)).LoadFont(displaySystem, faceName, size, flags);
3455 void FontExtent(DisplaySystem displaySystem, Font font, const char * text, int len, int * width, int * height, int prevGlyph, int * rPrevGlyph, int * adv)
3457 ((subclass(DisplayDriver))class(LFBDisplayDriver)).FontExtent(displaySystem, font, text, len, width, height, prevGlyph, rPrevGlyph, adv);
3460 void WriteText(Display display, Surface surface, int x, int y, const char * text, int len, int prevGlyph, int * rPrevGlyph)
3462 OGLSurface oglSurface = surface.driverData;
3463 OGLSystem oglSystem = display.displaySystem.driverData;
3464 oglSystem.loadingFont = true;
3466 //glTranslated(-0.375, -0.375, 0.0);
3470 if(surface.textOpacity)
3473 FontExtent(display.displaySystem, surface.font, text, len, &w, &h, 0, null, &adv);
3475 display.displaySystem.driver.Area(display, surface,x,y,x+w-1,y+h-1);
3478 oglSurface.writingText = true;
3480 glEnable(GL_TEXTURE_2D);
3481 glColor4fv(oglSurface.foreground);
3483 ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x, y, text, len, prevGlyph, rPrevGlyph);
3484 oglSurface.writingText = false;
3485 oglSystem.loadingFont = false;
3487 glDisable(GL_TEXTURE_2D);
3489 //glTranslated(0.375, 0.375, 0.0);
3492 void TextFont(Display display, Surface surface, Font font)
3494 ((subclass(DisplayDriver))class(LFBDisplayDriver)).TextFont(display, surface, font);
3497 void TextOpacity(Display display, Surface surface, bool opaque)
3499 OGLSurface oglSurface = surface.driverData;
3500 oglSurface.opaqueText = opaque;
3503 void TextExtent(Display display, Surface surface, const char * text, int len, int * width, int * height, int prevGlyph, int * rPrevGlyph, int * adv)
3505 OGLSurface oglSurface = surface.driverData;
3506 OGLSystem oglSystem = display.displaySystem.driverData;
3507 oglSystem.loadingFont = true;
3508 FontExtent(display.displaySystem, oglSurface.font, text, len, width, height, prevGlyph, rPrevGlyph, adv);
3509 oglSystem.loadingFont = false;
3512 void DrawingChar(Display display, Surface surface, char character)
3517 void LineStipple(Display display, Surface surface, uint32 stipple)
3519 //Logf("Stipple\n");
3524 stippleEnabled = true;
3525 glesLineStipple(1, (uint16)stipple);
3527 glLineStipple(1, (uint16)stipple);
3528 glEnable(GL_LINE_STIPPLE);
3534 stippleEnabled = false;
3535 glMatrixMode(GL_TEXTURE);
3537 glMatrixMode(GL_PROJECTION);
3538 glDisable(GL_TEXTURE_2D);
3540 glDisable(GL_LINE_STIPPLE);
3544 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
3545 void SetRenderState(Display display, RenderState state, uint value)
3547 OGLDisplay oglDisplay = display.driverData;
3548 //Logf("RenderState\n");
3554 glEnable(GL_MULTISAMPLE_ARB);
3556 glDisable(GL_MULTISAMPLE_ARB);
3560 glPolygonMode(GL_FRONT_AND_BACK, ((FillModeValue)value == solid) ? GL_FILL : GL_LINE);
3564 if(value) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
3567 if(value) glDepthMask((byte)bool::true); else glDepthMask((byte)bool::false);
3568 oglDisplay.depthWrite = (bool)value;
3572 float color[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3573 glFogfv(GL_FOG_COLOR, (float *)&color);
3577 glFogf(GL_FOG_DENSITY, (float)(RenderStateFloat { ui = value }.f * nearPlane));
3580 if(value) glEnable(GL_BLEND); else glDisable(GL_BLEND);
3584 float ambient[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3585 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
3590 if(value) glColorMask(1,1,1,1); else glColorMask(1,1,1,0);
3595 #if defined(__WIN32__)
3596 wglSwapIntervalEXT(value ? 1 : 0);
3603 void SetLight(Display display, int id, Light light)
3605 //Logf("SetLight\n");
3609 Object lightObject = light.lightObject;
3610 float position[4] = { 0, 0, 0, 0 };
3611 float color[4] = { 0, 0, 0, 1 };
3613 glEnable(GL_LIGHT0 + id);
3615 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, (float *)&light.diffuse);
3616 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, (float *)&light.ambient);
3617 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,(float *)&light.specular);
3620 if(!light.multiplier) light.multiplier = 1.0f;
3622 color[0] = light.diffuse.r * light.multiplier;
3623 color[1] = light.diffuse.g * light.multiplier;
3624 color[2] = light.diffuse.b * light.multiplier;
3625 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, color);
3627 color[0] = light.ambient.r * light.multiplier;
3628 color[1] = light.ambient.g * light.multiplier;
3629 color[2] = light.ambient.b * light.multiplier;
3630 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, color);
3631 color[0] = light.specular.r * light.multiplier;
3632 color[1] = light.specular.g * light.multiplier;
3633 color[2] = light.specular.b * light.multiplier;
3634 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,color);
3638 Vector3D positionVector;
3639 if(light.flags.spot)
3641 if(lightObject.flags.root || !lightObject.parent)
3643 positionVector = lightObject.transform.position;
3644 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3648 positionVector.MultMatrix(lightObject.transform.position, lightObject.parent.matrix);
3649 if(display.display3D.camera)
3650 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3656 if(!light.direction.x && !light.direction.y && !light.direction.z)
3658 Vector3Df vector { 0,0,-1 };
3660 mat.RotationQuaternion(light.orientation);
3661 positionVector.MultMatrixf(vector, mat);
3665 positionVector = light.direction;
3670 position[0] = (float)positionVector.x;
3671 position[1] = (float)positionVector.y;
3672 position[2] = (float)positionVector.z;
3674 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3677 // Display Light Position
3678 glDisable(GL_LIGHTING);
3679 glDisable(GL_DEPTH_TEST);
3683 glVertex3fv(position);
3685 glEnable(GL_DEPTH_TEST);
3686 glEnable(GL_LIGHTING);
3690 if(lightObject.flags.root || !lightObject.parent)
3692 positionVector = light.target.transform.position;
3693 positionVector.Subtract(positionVector, display.camera.cPosition);
3697 positionVector.MultMatrix(light.target.transform.position,
3698 lightObject.light.target.parent.matrix);
3699 positionVector.Subtract(positionVector, display.camera.cPosition);
3702 position[0] = positionVector.x;
3703 position[1] = positionVector.y;
3704 position[2] = positionVector.z;
3706 glDisable(GL_LIGHTING);
3707 glDisable(GL_DEPTH_TEST);
3711 glVertex3fv(position);
3713 glEnable(GL_DEPTH_TEST);
3714 glEnable(GL_LIGHTING);
3717 if(light.flags.attenuation)
3719 glLightf(GL_LIGHT0 + id, GL_CONSTANT_ATTENUATION, light.Kc);
3720 glLightf(GL_LIGHT0 + id, GL_LINEAR_ATTENUATION, light.Kl);
3721 glLightf(GL_LIGHT0 + id, GL_QUADRATIC_ATTENUATION, light.Kq);
3724 if(light.flags.spot)
3727 #define MAXLIGHT 0.9
3728 float direction[4] = { (float)light.direction.x, (float)light.direction.y, (float)light.direction.z, 1 };
3729 // Figure out exponent out of the hot spot
3730 exponent = (float)(log(MAXLIGHT) / log(cos((light.hotSpot / 2))));
3732 glLightfv(GL_LIGHT0 + id, GL_SPOT_DIRECTION, direction);
3733 glLightf(GL_LIGHT0 + id, GL_SPOT_CUTOFF, (float)(light.fallOff / 2));
3734 glLightf(GL_LIGHT0 + id, GL_SPOT_EXPONENT, exponent);
3740 Vector3Df vector { 0,0,-1 };
3741 Vector3Df direction;
3744 mat.RotationQuaternion(light.orientation);
3745 direction.MultMatrix(vector, mat);
3747 position[0] = direction.x;
3748 position[1] = direction.y;
3749 position[2] = direction.z;
3751 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3755 glDisable(GL_LIGHT0 + id);
3758 void SetCamera(Display display, Surface surface, Camera camera)
3760 OGLDisplay oglDisplay = display.driverData;
3761 //Logf("SetCamera\n");
3763 if(surface && camera)
3765 int left = surface.box.left + surface.offset.x;
3766 int top = surface.box.top + surface.offset.y;
3767 int right = surface.box.right + surface.offset.x;
3768 int bottom = surface.box.bottom + surface.offset.y;
3769 float origX = surface.offset.x + camera.origin.x;
3770 float origY = surface.offset.y + camera.origin.y;
3772 int y = display.height - bottom - 1;
3773 int w = right - left + 1;
3774 int h = bottom - top + 1;
3777 glViewport(x, y, w, h);
3779 // *** Projection Matrix ***
3780 glMatrixMode(GL_PROJECTION);
3781 if(!display.display3D.camera)
3784 if(display.display3D.collectingHits)
3786 float pickX = display.display3D.pickX + surface.offset.x;
3787 float pickY = display.height - (display.display3D.pickY + surface.offset.y) - 1;
3791 w / display.display3D.pickWidth, 0, 0, 0,
3792 0, h / display.display3D.pickHeight, 0, 0,
3794 (w + 2.0f * (x - pickX)) / display.display3D.pickWidth,
3795 (h + 2.0f * (y - pickY)) / display.display3D.pickHeight, 0, 1
3798 glLoadMatrixd(pickMatrix.array);
3803 (left - origX) * camera.zMin / camera.focalX,
3804 (right - origX) * camera.zMin / camera.focalX,
3805 (bottom - origY) * camera.zMin / camera.focalY,
3806 (top - origY) * camera.zMin / camera.focalY,
3807 camera.zMin, camera.zMax);
3809 glDisable(GL_BLEND);
3811 // *** Z Inverted Identity Matrix ***
3812 glMatrixMode(GL_MODELVIEW);
3813 if(!display.display3D.camera)
3818 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
3820 // *** View Matrix ***
3821 glMultMatrixd(camera.viewMatrix.array);
3826 glEnable(GL_DEPTH_TEST);
3827 glEnable(GL_LIGHTING);
3828 glShadeModel(GL_SMOOTH);
3829 glDepthMask((byte)bool::true);
3830 oglDisplay.depthWrite = true;
3832 glEnable(GL_MULTISAMPLE_ARB);
3834 else if(surface && display.display3D.camera)
3836 oglDisplay.depthWrite = false;
3837 glViewport(0,0,display.width,display.height);
3839 glDisable(GL_CULL_FACE);
3840 glDisable(GL_DEPTH_TEST);
3841 glDisable(GL_LIGHTING);
3843 glDisable(GL_TEXTURE_2D);
3844 glShadeModel(GL_FLAT);
3846 glDisable(GL_MULTISAMPLE_ARB);
3848 // *** Restore 2D MODELVIEW Matrix ***
3851 // *** Restore 2D PROJECTION Matrix ***
3852 glMatrixMode(GL_PROJECTION);
3858 void ApplyMaterial(Display display, Material material, Mesh mesh)
3860 //Logf("ApplyMaterial\n");
3863 if(material.flags.doubleSided)
3865 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, !material.flags.singleSideLight);
3866 glDisable(GL_CULL_FACE);
3870 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, bool::false);
3871 glEnable(GL_CULL_FACE);
3875 if(material.flags.noFog)
3881 if(material.baseMap && (mesh.texCoords || mesh.flags.texCoords1))
3883 Bitmap map = material.baseMap;
3884 glEnable(GL_TEXTURE_2D);
3885 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)map.driverData);
3887 glMatrixMode(GL_TEXTURE);
3889 if(material.uScale && material.vScale)
3890 glScalef(material.uScale, material.vScale, 1);
3891 glMatrixMode(GL_MODELVIEW);
3893 if(material.flags.tile)
3895 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
3896 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
3900 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
3901 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
3905 glDisable(GL_TEXTURE_2D);
3907 if(mesh.flags.colors)
3909 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
3910 glEnable(GL_COLOR_MATERIAL);
3914 glDisable(GL_COLOR_MATERIAL);
3916 float color[4] = { material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity };
3917 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
3920 float color[4] = { material.ambient.r, material.ambient.g, material.ambient.b, 0 };
3921 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
3925 float color[4] = { material.specular.r, material.specular.g, material.specular.b, 0 };
3926 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, color);
3929 float color[4] = { material.emissive.r, material.emissive.g, material.emissive.b, 0 };
3930 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, color);
3933 glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &material.power);
3936 void FreeMesh(DisplaySystem displaySystem, Mesh mesh)
3938 OGLMesh oglMesh = mesh.data;
3941 if(!mesh.flags.vertices)
3943 oglMesh.vertices.free();
3944 delete mesh.vertices;
3946 if(!mesh.flags.normals)
3948 oglMesh.normals.free();
3949 delete mesh.normals;
3951 if(!mesh.flags.texCoords1)
3953 oglMesh.texCoords.free();
3954 delete mesh.texCoords;
3956 if(!mesh.flags.texCoords2)
3958 oglMesh.texCoords2.free();
3959 // delete mesh.texCoords2;
3961 if(!mesh.flags.colors)
3963 oglMesh.colors.free();
3974 bool AllocateMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags, int nVertices)
3976 bool result = false;
3979 mesh.data = OGLMesh { };
3982 if(mesh.nVertices == nVertices)
3984 // Same number of vertices, adding features (Leaves the other features pointers alone)
3985 if(mesh.flags != flags)
3987 if(!mesh.flags.vertices && flags.vertices)
3989 if(flags.doubleVertices)
3991 mesh.vertices = (Vector3Df *)new Vector3D[nVertices];
3994 mesh.vertices = new Vector3Df[nVertices];
3996 if(!mesh.flags.normals && flags.normals)
3998 if(flags.doubleNormals)
4000 mesh.normals = (Vector3Df *)new Vector3D[nVertices];
4003 mesh.normals = new Vector3Df[nVertices];
4005 if(!mesh.flags.texCoords1 && flags.texCoords1)
4007 mesh.texCoords = new Pointf[nVertices];
4009 if(!mesh.flags.colors && flags.colors)
4011 mesh.colors = new ColorRGBAf[nVertices];
4017 // New number of vertices, reallocate all current and new features
4018 flags |= mesh.flags;
4021 if(flags.doubleVertices)
4023 mesh.vertices = (Vector3Df *)renew mesh.vertices Vector3D[nVertices];
4026 mesh.vertices = renew mesh.vertices Vector3Df[nVertices];
4030 if(flags.doubleNormals)
4032 mesh.normals = (Vector3Df *)renew mesh.normals Vector3D[nVertices];
4035 mesh.normals = renew mesh.normals Vector3Df[nVertices];
4037 if(flags.texCoords1)
4039 mesh.texCoords = renew mesh.texCoords Pointf[nVertices];
4043 mesh.colors = renew mesh.colors ColorRGBAf[nVertices];
4051 void UnlockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
4053 OGLMesh oglMesh = mesh.data;
4054 if(!flags) flags = mesh.flags;
4059 oglMesh.vertices.upload(
4060 mesh.nVertices * (mesh.flags.doubleVertices ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.vertices); //, GL_STATIC_DRAW_ARB );
4063 oglMesh.normals.upload(
4064 mesh.nVertices * (mesh.flags.doubleNormals ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.normals); //, GL_STATIC_DRAW_ARB );
4066 if(flags.texCoords1)
4067 oglMesh.texCoords.upload(
4068 mesh.nVertices * sizeof(Pointf), mesh.texCoords); //, GL_STATIC_DRAW_ARB );
4071 oglMesh.colors.upload(
4072 mesh.nVertices * sizeof(ColorRGBAf), mesh.colors); //, GL_STATIC_DRAW_ARB );
4076 bool LockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
4083 void FreeIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4087 oglIndices.buffer.free();
4088 delete oglIndices.indices;
4093 void * AllocateIndices(DisplaySystem displaySystem, int nIndices, bool indices32bit)
4095 OGLIndices oglIndices = OGLIndices { };
4098 oglIndices.indices = (void *)(indices32bit ? new uint32[nIndices] : new uint16[nIndices]);
4099 oglIndices.nIndices = nIndices;
4104 void UnlockIndices(DisplaySystem displaySystem, OGLIndices oglIndices, bool indices32bit, int nIndices)
4111 if(!oglIndices.buffer.buffer)
4112 GLGenBuffers(1, (GLAB *)&oglIndices.buffer);
4113 if(curElementBuffer != oglIndices.buffer.buffer)
4114 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, oglIndices.buffer.buffer);
4115 glesBufferDatai(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32) * nIndices, oglIndices.indices, GL_STATIC_DRAW_ARB);
4119 oglIndices.buffer.upload(
4120 nIndices * (indices32bit ? sizeof(uint32) : sizeof(uint16)),
4121 oglIndices.indices); //GL_STATIC_DRAW_ARB);
4125 uint16 * LockIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4128 return oglIndices.indices;
4131 void SelectMesh(Display display, Mesh mesh)
4133 //Logf("SelectMesh\n");
4135 #if !defined( __ANDROID__) && !defined(__APPLE__) && !defined(__ODROID__)
4137 #if defined(__WIN32__)
4138 if(glUnlockArraysEXT)
4140 if(!vboAvailable && display.display3D.mesh)
4141 glUnlockArraysEXT();
4146 OGLMesh oglMesh = mesh.data;
4148 // *** Vertex Stream ***
4149 glEnableClientState(GL_VERTEX_ARRAY);
4150 if(!display.display3D.collectingHits && oglMesh)
4152 oglMesh.vertices.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, oglMesh.vertices.buffer ? null : (double *)mesh.vertices);
4154 // *** Normals Stream ***
4155 if(mesh.normals || mesh.flags.normals)
4157 glEnableClientState(GL_NORMAL_ARRAY);
4158 oglMesh.normals.use(normal, 3, GL_FLOAT, 0, oglMesh.normals.buffer ? null : mesh.normals);
4161 glDisableClientState(GL_NORMAL_ARRAY);
4163 // *** Texture Coordinates Stream ***
4164 if(mesh.texCoords || mesh.flags.texCoords1)
4166 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4167 oglMesh.texCoords.use(texCoord, 2, GL_FLOAT, 0, oglMesh.texCoords.buffer ? null : mesh.texCoords);
4170 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4172 // *** Color Stream ***
4173 if(mesh.colors || mesh.flags.colors)
4175 glEnableClientState(GL_COLOR_ARRAY);
4176 oglMesh.colors.use(color, 4, GL_FLOAT, 0, oglMesh.colors.buffer ? null : mesh.colors);
4179 glDisableClientState(GL_COLOR_ARRAY);
4183 noAB.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, (double *)mesh.vertices);
4184 if((mesh.normals || mesh.flags.normals) && !display.display3D.collectingHits)
4186 glEnableClientState(GL_NORMAL_ARRAY);
4187 noAB.use(normal, 3, GL_FLOAT, 0, mesh.normals);
4190 glDisableClientState(GL_NORMAL_ARRAY);
4191 if((mesh.texCoords || mesh.flags.texCoords1) && !display.display3D.collectingHits)
4193 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4194 noAB.use(texCoord, 2, GL_FLOAT, 0, mesh.texCoords);
4197 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4198 if((mesh.colors || mesh.flags.colors) && !display.display3D.collectingHits)
4200 glEnableClientState(GL_COLOR_ARRAY);
4201 noAB.use(color, 4, GL_FLOAT, 0, mesh.colors);
4204 glDisableClientState(GL_COLOR_ARRAY);
4207 #if !defined(__ANDROID__) && !defined(__APPLE__) && !defined(__ODROID__)
4209 #if defined(__WIN32__)
4213 glLockArraysEXT(0, mesh.nVertices);
4219 void DrawPrimitives(Display display, PrimitiveSingle * primitive, Mesh mesh)
4221 //Logf("DrawPrimitives\n");
4223 if(primitive->type.vertexRange)
4224 glDrawArrays(primitiveTypes[primitive->type.primitiveType], primitive->first, primitive->nVertices);
4227 // *** Hoping the data won't be uploaded at all (Won't really work if another group of the mesh is using the mesh ) ***
4228 // HACK TO SPEED THINGS UP...
4230 /*GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
4231 if(primitive->nIndices < (mesh.nVertices >> 2) && !primitive->type.indices32bit)
4234 glBegin(primitiveTypes[primitive->type.primitiveType]);
4237 OGLIndices oglIndices = primitive->data;
4238 MeshFeatures flags = mesh.flags;
4239 for(c = 0; c<primitive->nIndices; c++)
4241 uint16 index = ((uint16 *) oglIndices.indices)[c];
4242 if(flags.normals) glNormal3fv((float *)&mesh.normals[index]);
4243 if(flags.texCoords1) glTexCoord2fv((float *)&mesh.texCoords[index]);
4244 if(flags.colors) glColor4fv((float *)&mesh.colors[index]);
4245 glVertex3fv((float *)&mesh.vertices[index]);
4254 OGLIndices oglIndices = primitive->data;
4255 GLEAB eab = ((!display.display3D.collectingHits && oglIndices) ? oglIndices.buffer : noEAB);
4257 eab.draw(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
4258 primitive->type.indices32bit ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT,
4259 eab.buffer ? 0 : (oglIndices ? oglIndices.indices : primitive->indices));
4260 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
4265 void PushMatrix(Display display)
4270 void PopMatrix(Display display, bool setMatrix)
4275 void SetTransform(Display display, Matrix transMatrix, bool viewSpace, bool useCamera)
4277 Matrix matrix = transMatrix;
4278 Camera camera = useCamera ? display.display3D.camera : null;
4283 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
4288 matrix.m[3][0] - camera.cPosition.x,
4289 matrix.m[3][1] - camera.cPosition.y,
4290 matrix.m[3][2] - camera.cPosition.z);
4302 glMultMatrixd(matrix.array);
4307 public void UseSingleGLContext(bool useSingle)
4309 useSingleGLContext = useSingle;
4312 default dllexport void *
4313 #if defined(__WIN32__)
4314 __attribute__((stdcall))
4316 IS_GLGetContext(DisplaySystem displaySystem)
4320 #if defined(__WIN32__)
4321 OGLSystem system = displaySystem.driverData;
4323 #elif defined(__ANDROID__) || defined(__ODROID__)
4326 OGLSystem system = displaySystem.driverData;
4327 return system.glContext;