1 // We were using PBUFFER for alpha compositing on Linux before, but it does not seem to work, nor be required anymore.
4 namespace gfx::drivers;
7 #if defined(__unix__) || defined(__APPLE__)
9 #if !defined(__MINGW32__)
10 #define GL_GLEXT_PROTOTYPES
13 #define pointer _pointer
17 //#include <GL/miniglx.h>
21 #if !defined(__ANDROID__) && !defined(__ODROID__)
23 #define property _property
27 #define Window X11Window
28 #define Cursor X11Cursor
30 #define Display X11Display
32 #define KeyCode X11KeyCode
33 #define Picture X11Picture
37 #include <X11/Xutil.h>
39 #include <X11/extensions/XShm.h>
42 #include <X11/extensions/Xrender.h>
43 #include <X11/extensions/shape.h>
63 #if defined(__APPLE__)
64 #include <OpenGl/gl.h>
67 #if defined(__WIN32__) || defined(__unix__) || defined(__APPLE__)
69 #if defined(__WIN32__)
70 #define WIN32_LEAN_AND_MEAN
72 #define _WIN32_WINNT 0x0502
78 #if defined(__ANDROID__) || defined(__ODROID__)
81 #define property _property
84 #define Window X11Window
85 #define Cursor X11Cursor
87 #define Display X11Display
89 #define KeyCode X11KeyCode
90 #define Picture X11Picture
112 #include <GL/glext.h>
116 #if defined(__ODROID__) && !defined(_GLES)
124 #if defined(__unix__) || defined(__APPLE__)
126 #if !defined(__ANDROID__) && !defined(__ODROID__)
132 static double nearPlane = 1;
134 public double glesGetNearPlane()
139 public void glesSetNearPlane(double value)
144 #define glLoadMatrix glLoadMatrixd
145 #define glMultMatrix glMultMatrixd
146 #define glGetMatrix glGetDoublev
147 #define glTranslate glTranslated
148 #define glScale glScaled
151 #define glVertex3v glVertex3dv
152 #define glNormal3v glNormal3dv
156 //#ifdef VERTEX_FORMAT_DOUBLE
158 #define glLoadMatrix glLoadMatrixd
159 #define glMultMatrix glMultMatrixd
160 #define glGetMatrix glGetDoublev
161 #define glVertex3v glVertex3dv
162 #define glNormal3v glNormal3dv
163 #define glTranslate glTranslated
164 #define glScale glScaled
165 //#define GL_VERTEX_FORMAT GL_DOUBLE
169 #define glLoadMatrix glLoadMatrixf
170 #define glMultMatrix glMultMatrixf
171 #define glGetMatrix glGetFloatv
172 #define glVertex3v glVertex3fv
173 #define glNormal3v glNormal3fv
174 #define glTranslate glTranslatef
175 #define glScale glScalef
176 //#define GL_VERTEX_FORMAT GL_FLOAT
181 #define GL_ARRAY_BUFFER_ARB 0x8892
182 #define GL_ELEMENT_ARRAY_BUFFER_ARB 0x8893
183 #define GL_STATIC_DRAW_ARB 0x88E4
184 #define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8
185 #define GL_SEPARATE_SPECULAR_COLOR 0x81FA
187 #define GL_MULTISAMPLE_ARB 0x809D
189 #if defined(__WIN32__)
191 #define WGL_SAMPLE_BUFFERS_ARB 0x2041
192 #define WGL_SAMPLES_ARB 0x2042
194 #define WGL_WGLEXT_VERSION 1
195 #define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001
196 #define WGL_BACK_COLOR_BUFFER_BIT_ARB 0x00000002
197 #define WGL_DEPTH_BUFFER_BIT_ARB 0x00000004
198 #define WGL_STENCIL_BUFFER_BIT_ARB 0x00000008
199 #define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000
200 #define WGL_DRAW_TO_WINDOW_ARB 0x2001
201 #define WGL_DRAW_TO_BITMAP_ARB 0x2002
202 #define WGL_ACCELERATION_ARB 0x2003
203 #define WGL_NEED_PALETTE_ARB 0x2004
204 #define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005
205 #define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006
206 #define WGL_SWAP_METHOD_ARB 0x2007
207 #define WGL_NUMBER_OVERLAYS_ARB 0x2008
208 #define WGL_NUMBER_UNDERLAYS_ARB 0x2009
209 #define WGL_TRANSPARENT_ARB 0x200A
210 #define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037
211 #define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038
212 #define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039
213 #define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A
214 #define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B
215 #define WGL_SHARE_DEPTH_ARB 0x200C
216 #define WGL_SHARE_STENCIL_ARB 0x200D
217 #define WGL_SHARE_ACCUM_ARB 0x200E
218 #define WGL_SUPPORT_GDI_ARB 0x200F
219 #define WGL_SUPPORT_OPENGL_ARB 0x2010
220 #define WGL_DOUBLE_BUFFER_ARB 0x2011
221 #define WGL_STEREO_ARB 0x2012
222 #define WGL_PIXEL_TYPE_ARB 0x2013
223 #define WGL_COLOR_BITS_ARB 0x2014
224 #define WGL_RED_BITS_ARB 0x2015
225 #define WGL_RED_SHIFT_ARB 0x2016
226 #define WGL_GREEN_BITS_ARB 0x2017
227 #define WGL_GREEN_SHIFT_ARB 0x2018
228 #define WGL_BLUE_BITS_ARB 0x2019
229 #define WGL_BLUE_SHIFT_ARB 0x201A
230 #define WGL_ALPHA_BITS_ARB 0x201B
231 #define WGL_ALPHA_SHIFT_ARB 0x201C
232 #define WGL_ACCUM_BITS_ARB 0x201D
233 #define WGL_ACCUM_RED_BITS_ARB 0x201E
234 #define WGL_ACCUM_GREEN_BITS_ARB 0x201F
235 #define WGL_ACCUM_BLUE_BITS_ARB 0x2020
236 #define WGL_ACCUM_ALPHA_BITS_ARB 0x2021
237 #define WGL_DEPTH_BITS_ARB 0x2022
238 #define WGL_STENCIL_BITS_ARB 0x2023
239 #define WGL_AUX_BUFFERS_ARB 0x2024
240 #define WGL_NO_ACCELERATION_ARB 0x2025
241 #define WGL_GENERIC_ACCELERATION_ARB 0x2026
242 #define WGL_FULL_ACCELERATION_ARB 0x2027
243 #define WGL_SWAP_EXCHANGE_ARB 0x2028
244 #define WGL_SWAP_COPY_ARB 0x2029
245 #define WGL_SWAP_UNDEFINED_ARB 0x202A
246 #define WGL_TYPE_RGBA_ARB 0x202B
247 #define WGL_TYPE_COLORINDEX_ARB 0x202C
248 #define ERROR_INVALID_PIXEL_TYPE_ARB 0x2043
249 #define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054
250 #define WGL_DRAW_TO_PBUFFER_ARB 0x202D
251 #define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E
252 #define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F
253 #define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030
254 #define WGL_PBUFFER_LARGEST_ARB 0x2033
255 #define WGL_PBUFFER_WIDTH_ARB 0x2034
256 #define WGL_PBUFFER_HEIGHT_ARB 0x2035
257 #define WGL_PBUFFER_LOST_ARB 0x2036
258 #define ERROR_INVALID_PIXEL_TYPE_EXT 0x2043
259 #define WGL_NUMBER_PIXEL_FORMATS_EXT 0x2000
260 #define WGL_DRAW_TO_WINDOW_EXT 0x2001
261 #define WGL_DRAW_TO_BITMAP_EXT 0x2002
262 #define WGL_ACCELERATION_EXT 0x2003
263 #define WGL_NEED_PALETTE_EXT 0x2004
264 #define WGL_NEED_SYSTEM_PALETTE_EXT 0x2005
265 #define WGL_SWAP_LAYER_BUFFERS_EXT 0x2006
266 #define WGL_SWAP_METHOD_EXT 0x2007
267 #define WGL_NUMBER_OVERLAYS_EXT 0x2008
268 #define WGL_NUMBER_UNDERLAYS_EXT 0x2009
269 #define WGL_TRANSPARENT_EXT 0x200A
270 #define WGL_TRANSPARENT_VALUE_EXT 0x200B
271 #define WGL_SHARE_DEPTH_EXT 0x200C
272 #define WGL_SHARE_STENCIL_EXT 0x200D
273 #define WGL_SHARE_ACCUM_EXT 0x200E
274 #define WGL_SUPPORT_GDI_EXT 0x200F
275 #define WGL_SUPPORT_OPENGL_EXT 0x2010
276 #define WGL_DOUBLE_BUFFER_EXT 0x2011
277 #define WGL_STEREO_EXT 0x2012
278 #define WGL_PIXEL_TYPE_EXT 0x2013
279 #define WGL_COLOR_BITS_EXT 0x2014
280 #define WGL_RED_BITS_EXT 0x2015
281 #define WGL_RED_SHIFT_EXT 0x2016
282 #define WGL_GREEN_BITS_EXT 0x2017
283 #define WGL_GREEN_SHIFT_EXT 0x2018
284 #define WGL_BLUE_BITS_EXT 0x2019
285 #define WGL_BLUE_SHIFT_EXT 0x201A
286 #define WGL_ALPHA_BITS_EXT 0x201B
287 #define WGL_ALPHA_SHIFT_EXT 0x201C
288 #define WGL_ACCUM_BITS_EXT 0x201D
289 #define WGL_ACCUM_RED_BITS_EXT 0x201E
290 #define WGL_ACCUM_GREEN_BITS_EXT 0x201F
291 #define WGL_ACCUM_BLUE_BITS_EXT 0x2020
292 #define WGL_ACCUM_ALPHA_BITS_EXT 0x2021
293 #define WGL_DEPTH_BITS_EXT 0x2022
294 #define WGL_STENCIL_BITS_EXT 0x2023
295 #define WGL_AUX_BUFFERS_EXT 0x2024
296 #define WGL_NO_ACCELERATION_EXT 0x2025
297 #define WGL_GENERIC_ACCELERATION_EXT 0x2026
298 #define WGL_FULL_ACCELERATION_EXT 0x2027
299 #define WGL_SWAP_EXCHANGE_EXT 0x2028
300 #define WGL_SWAP_COPY_EXT 0x2029
301 #define WGL_SWAP_UNDEFINED_EXT 0x202A
302 #define WGL_TYPE_RGBA_EXT 0x202B
303 #define WGL_TYPE_COLORINDEX_EXT 0x202C
304 #define WGL_DRAW_TO_PBUFFER_EXT 0x202D
305 #define WGL_MAX_PBUFFER_PIXELS_EXT 0x202E
306 #define WGL_MAX_PBUFFER_WIDTH_EXT 0x202F
307 #define WGL_MAX_PBUFFER_HEIGHT_EXT 0x2030
308 #define WGL_OPTIMAL_PBUFFER_WIDTH_EXT 0x2031
309 #define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032
310 #define WGL_PBUFFER_LARGEST_EXT 0x2033
311 #define WGL_PBUFFER_WIDTH_EXT 0x2034
312 #define WGL_PBUFFER_HEIGHT_EXT 0x2035
313 #define WGL_DEPTH_FLOAT_EXT 0x2040
314 #define WGL_SAMPLE_BUFFERS_3DFX 0x2060
315 #define WGL_SAMPLES_3DFX 0x2061
316 #define WGL_SAMPLE_BUFFERS_EXT 0x2041
317 #define WGL_SAMPLES_EXT 0x2042
318 #define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044
319 #define WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D 0x2045
320 #define WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D 0x2046
321 #define WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D 0x2047
322 #define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048
323 #define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049
324 #define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A
325 #define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B
326 #define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C
327 #define WGL_GAMMA_TABLE_SIZE_I3D 0x204E
328 #define WGL_GAMMA_EXCLUDE_DESKTOP_I3D 0x204F
329 #define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050
330 #define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051
331 #define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052
332 #define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053
333 #define WGL_ARB_buffer_region 1
334 #define WGL_ARB_extensions_string 1
335 #define WGL_ARB_pixel_format 1
336 #define WGL_ARB_make_current_read 1
337 #define WGL_ARB_pbuffer 1
338 #define WGL_EXT_display_color_table 1
339 #define WGL_EXT_extensions_string 1
340 #define WGL_EXT_make_current_read 1
341 #define WGL_EXT_pbuffer 1
342 #define WGL_EXT_pixel_format 1
343 #define WGL_EXT_swap_control 1
344 #define WGL_WGL_EXT_depth_float 1
345 #define WGL_WGL_3DFX_multisample 1
346 #define WGL_WGL_EXT_multisample 1
347 #define WGL_NV_allocate_memory 1
350 typedef void (APIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum target);
351 typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);
352 typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum target);
353 typedef void (APIENTRY * PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei count);
354 typedef void (APIENTRY * PFNGLUNLOCKARRAYSEXTPROC) (void);
358 typedef int (APIENTRY * PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer);
359 typedef int (APIENTRY * PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint *buffers);
360 typedef int (APIENTRY * PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint *buffers);
361 typedef int (APIENTRY * PFNGLBUFFERDATAARBPROC) (GLenum target, int size, const GLvoid *data, GLenum usage);
363 typedef int (APIENTRY * PFNWGLCHOOSEPIXELFORMATARBPROC) ();
364 typedef void * (APIENTRY * PFNWGLCREATEPBUFFERARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
365 typedef HDC (APIENTRY * PFNWGLGETPBUFFERDCARBPROC) (void * hPbuffer);
366 typedef int (APIENTRY * PFNWGLRELEASEPBUFFERDCARBPROC) (void * hPbuffer, HDC hDC);
367 typedef BOOL (APIENTRY * PFNWGLDESTROYPBUFFERARBPROC) (void * hPbuffer);
368 typedef BOOL (APIENTRY * PFNWGLQUERYPBUFFERARBPROC) (void * hPbuffer, int iAttribute, int *piValue);
369 typedef const char * (APIENTRY * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc);
370 typedef BOOL (APIENTRY * PFNWGLBINDTEXIMAGEARBPROC) (void * hPbuffer, int iBuffer);
371 typedef BOOL (APIENTRY * PFNWGLRELEASETEXIMAGEARBPROC) (void * hPbuffer, int iBuffer);
373 static PFNGLMAPBUFFERARBPROC glMapBufferARB = null;
374 static PFNGLUNMAPBUFFERARBPROC glUnmapBufferARB = null;
375 static PFNGLACTIVETEXTUREARBPROC glActiveTextureARB = null;
376 static PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB = null;
377 static PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB = null;
378 static PFNGLLOCKARRAYSEXTPROC glLockArraysEXT = null;
379 static PFNGLUNLOCKARRAYSEXTPROC glUnlockArraysEXT = null;
380 static PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate = null;
382 static PFNGLGENBUFFERSARBPROC glGenBuffersARB = null;
383 static PFNGLBINDBUFFERARBPROC glBindBufferARB = null;
384 static PFNGLBUFFERDATAARBPROC glBufferDataARB = null;
385 static PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB = null;
386 static PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = null;
387 static PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB = null;
388 static PFNWGLCREATEPBUFFERARBPROC wglCreatePbufferARB = null;
389 static PFNWGLGETPBUFFERDCARBPROC wglGetPbufferDCARB = null;
390 static PFNWGLQUERYPBUFFERARBPROC wglQueryPbufferARB = null;
391 static PFNWGLDESTROYPBUFFERARBPROC wglDestroyPbufferARB = null;
392 static PFNWGLRELEASEPBUFFERDCARBPROC wglReleasePbufferDCARB = null;
393 static PFNWGLBINDTEXIMAGEARBPROC wglBindTexImageARB = null;
394 static PFNWGLRELEASETEXIMAGEARBPROC wglReleaseTexImageARB = null;
396 #define glBufferData glBufferDataARB
398 #ifdef WGL_WGLEXT_PROTOTYPES
399 extern BOOL WINAPI wglSwapIntervalEXT (int);
400 extern int WINAPI wglGetSwapIntervalEXT (void);
401 #endif /* WGL_WGLEXT_PROTOTYPES */
402 typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC) (int interval);
403 typedef int (WINAPI * PFNWGLGETSWAPINTERVALEXTPROC) (void);
405 static PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = NULL;
407 #elif defined(__ANDROID__) || defined(__ODROID__)
409 #define GL_FRAMEBUFFER GL_FRAMEBUFFER_OES
410 #define GL_RENDERBUFFER GL_RENDERBUFFER_OES
411 #define GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_OES
413 #define GL_POLYGON_STIPPLE 0xFFFF
414 #define GL_LINE_STIPPLE 0xFFFF
415 #define GL_LINE 0xFFFF
416 #define GL_FILL 0xFFFF
417 #define GL_ALL_ATTRIB_BITS 0xFFFF
418 #define GL_LIGHT_MODEL_LOCAL_VIEWER 0xFFFF
424 #define GL_QUAD_STRIP 0
425 //#define GL_DOUBLE 0
426 //#define GL_UNSIGNED_INT 0
429 //#define GL_LINE_STIPPLE 0
430 #define GL_BGRA_EXT 0
431 #define GL_UNPACK_ROW_LENGTH 0
432 #define GL_UNPACK_SKIP_PIXELS 0
433 #define GL_UNPACK_SKIP_ROWS 0
435 #define GL_PACK_ROW_LENGTH 0
436 #define GL_PACK_SKIP_ROWS 0
437 #define GL_PACK_SKIP_PIXELS 0
441 #if defined(ECERE_NO3D) || defined(ECERE_VANILLA)
449 FillBytesBy4(this, 0, sizeof(Matrix) >> 2);
450 m[0][0]=m[1][1]=m[2][2]=m[3][3]=1;
453 void Transpose(Matrix source)
458 m[j][i] = source.m[i][j];
461 void Multiply(Matrix a, Matrix b)
463 // We need a full matrix multiplication for the Projection matrix
464 m[0][0]=a.m[0][0]*b.m[0][0] + a.m[0][1]*b.m[1][0] + a.m[0][2]*b.m[2][0] + a.m[0][3]*b.m[3][0];
465 m[0][1]=a.m[0][0]*b.m[0][1] + a.m[0][1]*b.m[1][1] + a.m[0][2]*b.m[2][1] + a.m[0][3]*b.m[3][1];
466 m[0][2]=a.m[0][0]*b.m[0][2] + a.m[0][1]*b.m[1][2] + a.m[0][2]*b.m[2][2] + a.m[0][3]*b.m[3][2];
467 m[0][3]=a.m[0][0]*b.m[0][3] + a.m[0][1]*b.m[1][3] + a.m[0][2]*b.m[2][3] + a.m[0][3]*b.m[3][3];
469 m[1][0]=a.m[1][0]*b.m[0][0] + a.m[1][1]*b.m[1][0] + a.m[1][2]*b.m[2][0] + a.m[1][3]*b.m[3][0];
470 m[1][1]=a.m[1][0]*b.m[0][1] + a.m[1][1]*b.m[1][1] + a.m[1][2]*b.m[2][1] + a.m[1][3]*b.m[3][1];
471 m[1][2]=a.m[1][0]*b.m[0][2] + a.m[1][1]*b.m[1][2] + a.m[1][2]*b.m[2][2] + a.m[1][3]*b.m[3][2];
472 m[1][3]=a.m[1][0]*b.m[0][3] + a.m[1][1]*b.m[1][3] + a.m[1][2]*b.m[2][3] + a.m[1][3]*b.m[3][3];
474 m[2][0]=a.m[2][0]*b.m[0][0] + a.m[2][1]*b.m[1][0] + a.m[2][2]*b.m[2][0] + a.m[2][3]*b.m[3][0];
475 m[2][1]=a.m[2][0]*b.m[0][1] + a.m[2][1]*b.m[1][1] + a.m[2][2]*b.m[2][1] + a.m[2][3]*b.m[3][1];
476 m[2][2]=a.m[2][0]*b.m[0][2] + a.m[2][1]*b.m[1][2] + a.m[2][2]*b.m[2][2] + a.m[2][3]*b.m[3][2];
477 m[2][3]=a.m[2][0]*b.m[0][3] + a.m[2][1]*b.m[1][3] + a.m[2][2]*b.m[2][3] + a.m[2][3]*b.m[3][3];
479 m[3][0]=a.m[3][0]*b.m[0][0] + a.m[3][1]*b.m[1][0] + a.m[3][2]*b.m[2][0] + a.m[3][3]*b.m[3][0];
480 m[3][1]=a.m[3][0]*b.m[0][1] + a.m[3][1]*b.m[1][1] + a.m[3][2]*b.m[2][1] + a.m[3][3]*b.m[3][1];
481 m[3][2]=a.m[3][0]*b.m[0][2] + a.m[3][1]*b.m[1][2] + a.m[3][2]*b.m[2][2] + a.m[3][3]*b.m[3][2];
482 m[3][3]=a.m[3][0]*b.m[0][3] + a.m[3][1]*b.m[1][3] + a.m[3][2]*b.m[2][3] + a.m[3][3]*b.m[3][3];
487 // Our own matrix stack
488 static Matrix matrixStack[3][32];
489 static int matrixIndex[3];
490 static int curStack = 0;
494 // OpenGL ES Porting Kit
495 #if defined(__ANDROID__) || defined(__ODROID__)
496 #define glBindFramebuffer glBindFramebufferOES
497 #define glBindRenderbuffer glBindRenderbufferOES
498 #define GL_FRAMEBUFFER GL_FRAMEBUFFER_OES
499 #define GL_RENDERBUFFER GL_RENDERBUFFER_OES
500 #define glFramebufferTexture2D glFramebufferTexture2DOES
501 #define GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_OES
502 #define glGenFramebuffers glGenFramebuffersOES
503 #define glGenRenderbuffers glGenRenderbuffersOES
504 #define glDeleteFramebuffers glDeleteFramebuffersOES
505 #define glDeleteRenderbuffers glDeleteRenderbuffersOES
507 #define GL_POLYGON_STIPPLE 0xFFFF
508 #define GL_LINE_STIPPLE 0xFFFF
509 #define GL_LINE 0xFFFF
510 #define GL_FILL 0xFFFF
511 #define GL_ALL_ATTRIB_BITS 0xFFFF
512 #define GL_LIGHT_MODEL_LOCAL_VIEWER 0xFFFF
513 #define GL_INT 0x1404
514 #define GL_UNSIGNED_INT 0x1405
515 #define GL_DOUBLE 0x140A
521 #define glDrawElementsi(type, count, start) glDrawElements(type, count, GL_UNSIGNED_SHORT, start)
523 #define glBufferDatai glesBufferDatai
524 #define glBufferDatad glesBufferDatad
525 #define glVertexPointeri glesVertexPointeri
526 #define glVertexPointerd glesVertexPointerd
528 #define glRecti glesRecti
529 #define glBegin glesBegin
530 #define glTexCoord2i glesTexCoord2i
531 #define glVertex2i glesVertex2i
532 #define glTexCoord2d glesTexCoord2d
533 #define glVertex2d glesVertex2d
534 #define glTexCoord2f glesTexCoord2f
535 #define glVertex2f glesVertex2f
536 #define glEnd glesEnd
537 #define glColor3f glesColor3f
538 #define glColor4ub glesColor4ub
539 #define glColor4fv glesColor4fv
540 #define glLineStipple glesLineStipple
541 #define glNormal3fv glesNormal3fv
542 #define glNormal3f glesNormal3f
543 #define glTexCoord2fv glesTexCoord2fv
544 #define glColorMaterial glesColorMaterial
546 #define glLoadMatrixd glesLoadMatrixd
547 #define glMultMatrixd glesMultMatrixd
548 #define glFrustum glesFrustum
549 #define glOrtho glesOrtho
550 #define glScaled glesScaled
551 #define glTranslated glesTranslated
552 #define glRotated glesRotated
553 #define glVertex3d glesVertex3d
554 #define glVertex3dv glesVertex3dv
555 #define glVertex3f glesVertex3f
556 #define glVertex3fv glesVertex3fv
557 #define glLightModeli glesLightModeli
559 #if defined(__ANDROID__)
561 #define GL_QUAD_STRIP 0
562 //#define GL_DOUBLE 0
563 //#define GL_UNSIGNED_INT 0
566 //#define GL_LINE_STIPPLE 0
567 #define GL_BGRA_EXT 0
568 #define GL_UNPACK_ROW_LENGTH 0
569 #define GL_UNPACK_SKIP_PIXELS 0
570 #define GL_UNPACK_SKIP_ROWS 0
572 #define GL_PACK_ROW_LENGTH 0
573 #define GL_PACK_SKIP_ROWS 0
574 #define GL_PACK_SKIP_PIXELS 0
579 #define glVertexPointerd(nc, s, p, nv) glVertexPointer(nc, GL_DOUBLE, s, p)
580 #define glDrawElementsi(type, count, start) glDrawElements(type, count, GL_UNSIGNED_INT, start)
584 #if defined(__ANDROID__) || defined(__ODROID__)
585 static EGLDisplay eglDisplay;
586 static EGLSurface eglSurface;
587 static EGLContext eglContext;
588 static int eglWidth, eglHeight;
590 #if defined(__ANDROID__)
591 static bool egl_init_display(ANativeWindow* window)
593 static bool egl_init_display(uint window)
596 const EGLint attribs[] =
598 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
602 EGL_DEPTH_SIZE, 16, //24,
603 /*EGL_SAMPLE_BUFFERS, 1,
604 EGL_SAMPLES, 0, //2,*/
613 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
614 eglInitialize(display, 0, 0);
615 eglChooseConfig(display, attribs, &config, 1, &numConfigs);
616 eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &format);
618 surface = eglCreateWindowSurface(display, config, window, null);
619 context = eglCreateContext(display, config, null, null);
621 if(!eglMakeCurrent(display, surface, surface, context))
624 eglQuerySurface(display, surface, EGL_WIDTH, &w);
625 eglQuerySurface(display, surface, EGL_HEIGHT, &h);
627 eglDisplay = display;
628 eglContext = context;
629 eglSurface = surface;
633 glEnableClientState(GL_VERTEX_ARRAY);
635 // Initialize GL state.
636 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
637 glEnable(GL_CULL_FACE);
638 glShadeModel(GL_SMOOTH);
639 glDisable(GL_DEPTH_TEST);
641 glDisable(GL_CULL_FACE);
642 glDisable(GL_DEPTH_TEST);
644 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
647 matrixStack[0][0].Identity();
648 matrixStack[1][0].Identity();
649 matrixStack[2][0].Identity();
651 glesMatrixMode(GL_MODELVIEW);
652 glScaled(1.0, 1.0, -1.0);
653 glesMatrixMode(GL_PROJECTION);
654 glShadeModel(GL_FLAT);
656 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
657 glFogi(GL_FOG_MODE, GL_EXP);
658 glFogf(GL_FOG_DENSITY, 0);
659 glEnable(GL_NORMALIZE);
660 glDepthFunc(GL_LESS);
662 glDisable(GL_MULTISAMPLE_ARB);
666 glOrtho(0,w,h,0,0.0,1.0);
669 curElementBuffer = 0;
673 static void egl_term_display()
677 glDeleteTextures(1, &stippleTexture);
680 if(eglDisplay != EGL_NO_DISPLAY)
682 eglMakeCurrent(eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
683 if(eglContext != EGL_NO_CONTEXT)
684 eglDestroyContext(eglDisplay, eglContext);
685 if(eglSurface != EGL_NO_SURFACE)
686 eglDestroySurface(eglDisplay, eglSurface);
687 eglTerminate(eglDisplay);
689 eglDisplay = EGL_NO_DISPLAY;
690 eglContext = EGL_NO_CONTEXT;
691 eglSurface = EGL_NO_SURFACE;
696 // OpenGL Immediate Mode Porting Kit
697 static int beginCount;
698 static int vertexCount;
699 static int normalCount;
700 static float *vertexPointer;
701 static float *normalPointer;
702 static GLenum beginMode = -1;
703 static uint beginBufferSize, normalBufferSize;
704 static int numVertexCoords = 2;
705 static bool vertexColorValues = false;
706 static int vertexStride = 4;
707 static int vertexOffset = 2;
709 public void glesRecti(int a, int b, int c, int d)
719 public void glesBegin(GLenum mode)
724 vertexColorValues = false;
731 normalBufferSize = beginBufferSize = 1024; // default number of vertices
732 vertexPointer = new float[beginBufferSize * vertexStride];
733 normalPointer = new float[normalBufferSize * 3];
737 public void glesTexCoord2f(float x, float y)
739 int count = vertexCount;
741 if(vertexCount + numVertexCoords > beginBufferSize)
743 beginBufferSize = beginBufferSize + beginBufferSize/2;
744 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
747 vertexPointer[count*vertexStride ] = x;
748 vertexPointer[count*vertexStride+1] = y;
751 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
753 vertexPointer[count*vertexStride ] = vertexPointer[(count-4)*vertexStride];
754 vertexPointer[count*vertexStride+1] = vertexPointer[(count-4)*vertexStride+1];
756 vertexPointer[count*vertexStride ] = vertexPointer[(count-3)*vertexStride];
757 vertexPointer[count*vertexStride+1] = vertexPointer[(count-3)*vertexStride+1];
761 public void glesTexCoord2i(int x, int y) { glesTexCoord2f((float)x, (float)y); }
762 public void glesTexCoord2d(double x, double y) { glesTexCoord2f((float)x, (float)y); }
763 public void glesTexCoord2fv(float * a) { glesTexCoord2f(a[0], a[1]); }
765 public void glesVertex2f(float x, float y)
768 vertexStride = vertexOffset + numVertexCoords;
770 if(vertexCount + 4 > beginBufferSize)
772 beginBufferSize = beginBufferSize + beginBufferSize/2;
773 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
776 vertexPointer[vertexCount*vertexStride+vertexOffset] = x;
777 vertexPointer[vertexCount*vertexStride+vertexOffset + 1] = y;
780 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
782 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset];
783 vertexPointer[vertexCount*vertexStride+vertexOffset + 1] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset + 1];
785 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset];
786 vertexPointer[vertexCount*vertexStride+vertexOffset + 1] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset + 1];
791 public void glesVertex2i(int x, int y) { glesVertex2f((float)x, (float)y); }
792 public void glesVertex2d(double x, double y) { glesVertex2f((float)x, (float)y); }
794 public void glesEnd(void)
796 int mode = beginMode;
797 if(mode == GL_QUADS) mode = GL_TRIANGLES;
798 else if(mode == GL_POLYGON) mode = GL_TRIANGLE_FAN;
800 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
801 noAB.use(texCoord, 2, GL_FLOAT, vertexStride * sizeof(float), vertexPointer);
802 if(vertexColorValues)
804 glEnableClientState(GL_COLOR_ARRAY);
805 noAB.use(color, 4, GL_FLOAT, vertexStride * sizeof(float), vertexPointer + 2);
807 noAB.use(vertex, numVertexCoords, GL_FLOAT, (vertexStride)*sizeof(float),vertexPointer+vertexOffset);
808 if(normalCount && normalCount == vertexCount)
810 glEnableClientState(GL_NORMAL_ARRAY);
811 noAB.use(normal, 3, GL_FLOAT, 3*sizeof(float),normalPointer);
814 glDrawArrays(mode, 0, vertexCount);
816 glDisableClientState(GL_NORMAL_ARRAY);
817 if(vertexColorValues)
818 glDisableClientState(GL_COLOR_ARRAY);
819 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
821 vertexColorValues = false;
827 static float *floatVPBuffer = null;
828 static short *shortVPBuffer = null;
829 static unsigned int shortVPSize = 0, floatVPSize = 0;
832 //static float *floatVPBuffer = null; // For floats we reuse floatVPBuffer
833 static unsigned short *shortBDBuffer = null;
834 static unsigned int shortBDSize = 0/*, floatVPSize = 0*/;
836 public void glesVertexPointeri(int numCoords, int stride, int *pointer, int numVertices)
841 if(numVertices*numCoords > shortVPSize)
843 shortVPSize = numVertices*numCoords;
844 shortVPBuffer = renew shortVPBuffer short[shortVPSize];
846 for(i = 0; i < numVertices*numCoords; i++)
847 shortVPBuffer[i] = (short)pointer[i];
848 glVertexPointer(numCoords, GL_SHORT, stride, shortVPBuffer);
851 glVertexPointer(numCoords, GL_SHORT, stride, 0);
854 public void glesVertexPointerd(int numCoords, int stride, double *pointer, int numVertices)
859 if(numVertices*numCoords > floatVPSize)
861 floatVPSize = numVertices*numCoords;
862 floatVPBuffer = renew floatVPBuffer float[floatVPSize];
864 for(i = 0; i < numVertices*numCoords; i++)
865 floatVPBuffer[i] = (float)pointer[i];
866 glVertexPointer(numCoords, GL_FLOAT, stride, floatVPBuffer);
869 glVertexPointer(numCoords, GL_FLOAT, stride, 0);
872 public void glesTexReuseIntVP(int numCoords)
874 glTexCoordPointer(numCoords, GL_SHORT, 0, floatVPBuffer);
877 public void glesTexReuseDoubleVP(int numCoords)
879 glTexCoordPointer(numCoords, GL_FLOAT, 0, floatVPBuffer);
882 public void glesColor4f(float r, float g, float b, float a)
884 if(beginMode != (GLenum)-1)
886 int count = vertexCount;
888 vertexColorValues = true;
890 vertexStride = vertexOffset + numVertexCoords;
892 if(vertexCount + vertexStride > beginBufferSize)
894 beginBufferSize = beginBufferSize + beginBufferSize/2;
895 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
898 vertexPointer[count*vertexStride + 2] = r;
899 vertexPointer[count*vertexStride + 3] = g;
900 vertexPointer[count*vertexStride + 4] = b;
901 vertexPointer[count*vertexStride + 5] = a;
904 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
906 vertexPointer[count*vertexStride + 2] = vertexPointer[(count-4) * vertexStride + 2];
907 vertexPointer[count*vertexStride + 3] = vertexPointer[(count-4) * vertexStride + 3];
908 vertexPointer[count*vertexStride + 4] = vertexPointer[(count-4) * vertexStride + 4];
909 vertexPointer[count*vertexStride + 5] = vertexPointer[(count-4) * vertexStride + 5];
911 vertexPointer[count*vertexStride + 2] = vertexPointer[(count-3) * vertexStride + 2];
912 vertexPointer[count*vertexStride + 3] = vertexPointer[(count-3) * vertexStride + 3];
913 vertexPointer[count*vertexStride + 4] = vertexPointer[(count-3) * vertexStride + 4];
914 vertexPointer[count*vertexStride + 5] = vertexPointer[(count-3) * vertexStride + 5];
919 glColor4f(r, g, b, a);
922 public void glesColor3f( float r, float g, float b )
924 glesColor4f(r, g, b, 1.0f);
927 public void glesColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
929 glesColor4f(r/255.0f, g/255.0f, b/255.0f, a/255.0f);
932 public void glesColor4fv(float * a)
934 glesColor4f(a[0], a[1], a[2], a[3]);
937 public void glesBufferDatad(int target, int size, void * data, int usage)
939 int numElems = size/sizeof(double);
940 double * dblPtr = (double *)data;
942 if (numElems > floatVPSize)
944 floatVPSize = numElems;
945 floatVPBuffer = renew floatVPBuffer float[floatVPSize];
947 for (i=0; i< numElems; i++)
948 floatVPBuffer[i] = (float)dblPtr[i];
950 glBufferData(target, numElems*sizeof(float), floatVPBuffer, usage);
953 public void glesBufferDatai(int target, int size, void * data, int usage)
955 int numElems = size/sizeof(unsigned int);
956 unsigned int * pointer = (unsigned int *)data;
958 if (numElems > shortBDSize)
960 shortBDSize = numElems;
961 shortBDBuffer = renew shortBDBuffer uint16[shortBDSize];
963 for (i=0; i< numElems; i++)
964 shortBDBuffer[i] = (unsigned short)pointer[i];
966 glBufferData(target, numElems*sizeof(unsigned short), shortBDBuffer, usage);
969 // *** Our Custom Matrix Stack ***
971 static void LoadCurMatrix()
973 double * i = matrixStack[curStack][matrixIndex[curStack]].array;
976 (float)i[0],(float)i[1],(float)i[2],(float)i[3],
977 (float)i[4],(float)i[5],(float)i[6],(float)i[7],
978 (float)i[8],(float)i[9],(float)i[10],(float)i[11],
979 (float)i[12],(float)i[13],(float)i[14],(float)i[15]
984 public void glesLoadIdentity()
986 matrixStack[curStack][matrixIndex[curStack]].Identity();
990 public void glesPushMatrix()
992 if(matrixIndex[curStack] + 1 < sizeof(matrixStack[0]) / sizeof(Matrix))
994 matrixIndex[curStack]++;
995 memcpy(matrixStack[curStack][matrixIndex[curStack]].array, matrixStack[curStack][matrixIndex[curStack]-1].array, sizeof(Matrix));
999 public void glesPopMatrix()
1001 if(matrixIndex[curStack] > 0)
1003 matrixIndex[curStack]--;
1008 public void glesLoadMatrixd(double * i)
1010 memcpy(matrixStack[curStack][matrixIndex[curStack]].array, i, sizeof(Matrix));
1014 public void glesOrtho( double l, double r, double b, double t, double n, double f )
1018 (2 / (r - l)), 0, 0, 0,
1019 0, (2 / (t - b)), 0, 0,
1020 0, 0, (-2 / (f - n)), 0,
1021 (-(r + l) / (r - l)), (-(t + b) / (t - b)), (-(f + n) / (f - n)), 1
1024 res.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1025 matrixStack[curStack][matrixIndex[curStack]] = res;
1029 public void glesFrustum( double l, double r, double b, double t, double n, double f )
1039 double A = ((r + l) / (r - l));
1040 double B = ((t + b) / (t - b));
1041 double C = (-(f + n) / (f - n));
1042 double D = (-2*f*n/(f-n));
1045 (2.0*n / (r - l)), 0, 0, 0,
1046 0, (2.0*n / (t - b)), 0, 0,
1051 res.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1052 matrixStack[curStack][matrixIndex[curStack]] = res;
1057 public void glesRotated( double a, double b, double c, double d )
1062 q.RotationAxis({(float)b,(float)c,(float)-d}, a );
1063 m.RotationQuaternion(q);
1064 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1065 matrixStack[curStack][matrixIndex[curStack]] = r;
1068 public void glesScaled( double a, double b, double c )
1074 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1075 matrixStack[curStack][matrixIndex[curStack]] = r;
1079 public void glesTranslated( double a, double b, double c )
1085 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
1086 matrixStack[curStack][matrixIndex[curStack]] = r;
1090 public void glesMultMatrixd( double * i )
1093 r.Multiply((Matrix *)i, matrixStack[curStack][matrixIndex[curStack]]);
1094 matrixStack[curStack][matrixIndex[curStack]] = r;
1098 public void glesMatrixMode(int mode)
1100 curStack = (mode == GL_MODELVIEW) ? 0 : (mode == GL_PROJECTION) ? 1 : 2;
1106 #define glPushMatrix glesPushMatrix
1107 #define glPopMatrix glesPopMatrix
1108 #define glLoadIdentity glesLoadIdentity
1109 #define glMatrixMode glesMatrixMode
1113 /* Using the built-in matrix stack
1114 void glesLoadMatrixd( double * i )
1118 (float)i[0],(float)i[1],(float)i[2],(float)i[3],
1119 (float)i[4],(float)i[5],(float)i[6],(float)i[7],
1120 (float)i[8],(float)i[9],(float)i[10],(float)i[11],
1121 (float)i[12],(float)i[13],(float)i[14],(float)i[15]
1126 void glesOrtho( double l, double r, double b, double t, double n, double f )
1128 float matrix[4][4] =
1130 { (float)(2 / (r - l)), 0, 0, 0 },
1131 { 0, (float)(2 / (t - b)), 0, 0 },
1132 { 0, 0, (float)(-2 / (f - n)), 0 },
1133 { (float)(-(r + l) / (r - l)), (float)(-(t + b) / (t - b)), (float)(-(f + n) / (f - n)), 1 }
1135 glMultMatrixf((float *)matrix);
1138 void glesFrustum( double l, double r, double b, double t, double n, double f )
1140 float A = (float)((r + l) / (r - l));
1141 float B = (float)((t + b) / (t - b));
1142 float C = (float)(-(f + n) / (f - n));
1143 float D = (float)(-2*f*n/(f-n));
1144 float matrix[4][4] =
1146 { (float)(2*n / (r - l)), 0, 0, 0 },
1147 { 0, (float)(2*n / (t - b)), 0, 0 },
1151 glMultMatrixf((float *)matrix);
1154 void glesRotated( double a, double b, double c, double d ) { glRotatef((float)a, (float)b, (float)c, (float)d); }
1155 void glesScaled( double a, double b, double c ) { glScalef((float)a, (float)b, (float)c); }
1156 void glesTranslated( double a, double b, double c ) { glTranslatef((float)a, (float)b, (float)c); }
1158 void glesMultMatrixd( double * i )
1162 (float)i[0], (float)i[1], (float)i[2], (float)i[3],
1163 (float)i[4], (float)i[5], (float)i[6], (float)i[7],
1164 (float)i[8], (float)i[9], (float)i[10], (float)i[11],
1165 (float)i[12], (float)i[13], (float)i[14], (float)i[15]
1171 // Need to do these...
1172 public void glesVertex3f( float x, float y, float z )
1174 numVertexCoords = 3;
1175 vertexStride = vertexOffset + numVertexCoords;
1177 if(vertexCount + vertexStride > beginBufferSize)
1179 beginBufferSize = beginBufferSize + beginBufferSize/2;
1180 vertexPointer = renew vertexPointer float[beginBufferSize * vertexStride];
1183 vertexPointer[vertexCount*vertexStride+vertexOffset] = x;
1184 vertexPointer[vertexCount*vertexStride+vertexOffset+1] = y;
1185 vertexPointer[vertexCount*vertexStride+vertexOffset+2] = z;
1188 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
1190 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset];
1191 vertexPointer[vertexCount*vertexStride+vertexOffset+1] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset+1];
1192 vertexPointer[vertexCount*vertexStride+vertexOffset+2] = vertexPointer[(vertexCount-4)*vertexStride+vertexOffset+2];
1194 vertexPointer[vertexCount*vertexStride+vertexOffset] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset];
1195 vertexPointer[vertexCount*vertexStride+vertexOffset+1] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset+1];
1196 vertexPointer[vertexCount*vertexStride+vertexOffset+2] = vertexPointer[(vertexCount-3)*vertexStride+vertexOffset+2];
1202 public void glesVertex3d( double x, double y, double z ) { glesVertex3f((float)x, (float)y, (float)z); }
1203 public void glesVertex3fv( float* coords ) { glesVertex3f(coords[0], coords[1], coords[2]); }
1204 public void glesVertex3dv( double* coords ) { glesVertex3f((float)coords[0], (float)coords[1], (float)coords[2]); }
1206 public void glesNormal3f(float x, float y, float z)
1208 normalCount = vertexCount;
1209 if(vertexCount + 4 > normalBufferSize)
1211 normalBufferSize = normalBufferSize + normalBufferSize/2;
1212 normalPointer = renew normalPointer float[normalBufferSize * 2];
1215 normalPointer[normalCount*3+0] = x;
1216 normalPointer[normalCount*3+1] = y;
1217 normalPointer[normalCount*3+2] = z;
1220 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
1222 normalPointer[normalCount*3+0] = normalPointer[(normalCount-4)*3+0];
1223 normalPointer[normalCount*3+1] = normalPointer[(normalCount-4)*3+1];
1224 normalPointer[normalCount*3+2] = normalPointer[(normalCount-4)*3+2];
1226 normalPointer[normalCount*3+0] = normalPointer[(normalCount-3)*3+0];
1227 normalPointer[normalCount*3+1] = normalPointer[(normalCount-3)*3+1];
1228 normalPointer[normalCount*3+2] = normalPointer[(normalCount-3)*3+2];
1232 public void glesNormal3fd(double x, double y, double z) { glesNormal3f((float)x, (float)y, (float)z); }
1233 public void glesNormal3fv(float * coords) { glesNormal3f(coords[0], coords[1], coords[2]); }
1235 public void glesColorMaterial(int a, int b)
1237 PrintLn("glColorMaterial stub");
1240 public void glesTerminate()
1242 delete vertexPointer;
1243 delete normalPointer;
1244 beginBufferSize = 0;
1246 delete floatVPBuffer;
1249 delete shortVPBuffer;
1252 delete shortBDBuffer;
1256 static GLuint stippleTexture;
1258 static bool stippleEnabled;
1261 public void glesLineStipple( int i, unsigned short j )
1265 for(x = 0; x < 16; x++)
1267 bool v = (j & (1 << x)) != 0;
1268 texture[x] = v ? 0xFFFFFFFF : 0;
1271 glGenTextures(1, &stippleTexture);
1272 glBindTexture(GL_TEXTURE_2D, stippleTexture);
1273 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture);
1274 glEnable(GL_TEXTURE_2D);
1275 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1276 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1277 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
1278 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1279 glMatrixMode(GL_TEXTURE);
1281 //glTranslated(1.0/backAttrib->texW/2.0f, 1.0/backAttrib->texH/2.0f, 0.0f);
1282 glScaled(i/16.0, 1, 1.0f);
1283 glTranslated(0.5, 0.5, 0);
1284 glMatrixMode(GL_PROJECTION);
1287 public void glesLightModeli( unsigned int pname, int param )
1289 if(pname == GL_LIGHT_MODEL_TWO_SIDE)
1290 glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, param);
1293 #if defined(__ANDROID__) || defined(__ODROID__)
1294 void glClearDepth( double depth ) { glClearDepthf((float)depth); }
1295 void glFogi( unsigned int pname, int param ) { }
1296 void glPolygonMode( unsigned int i, unsigned int j ) { }
1299 // *** Picking won't be supported for now ***
1300 void glPushName( unsigned int i ) { }
1301 void glLoadName( unsigned int i ) { }
1302 void glPopName() { }
1304 // Probably replace by regular glBlendFunc ...
1305 void glBlendFuncSeparate(int a, int b, int c, int d)
1310 // For direct pixel blitting...
1311 void glRasterPos2d(double a, double b) { }
1312 void glPixelZoom(float a, float b) { }
1313 void glDrawPixels(int a, int b, int c, int d, void * e) { }
1317 #if !defined(__APPLE__) && !defined(__WIN32__) && !defined(__ODROID__)
1318 void (APIENTRY * glBindBufferARB) (GLenum target, GLuint buffer);
1319 void (APIENTRY * glGenBuffersARB) (GLsizei n, GLuint *buffers);
1320 void (APIENTRY * glDeleteBuffersARB) (GLsizei n, const GLuint *buffers);
1321 void (APIENTRY * glBufferDataARB) (GLenum target, int size, const GLvoid *data, GLenum usage);
1324 public void GLLoadMatrix(Matrix matrix)
1328 (float)matrix.m[0][0], (float)matrix.m[0][1], (float)matrix.m[0][2], (float)matrix.m[0][3],
1329 (float)matrix.m[1][0], (float)matrix.m[1][1], (float)matrix.m[1][2], (float)matrix.m[1][3],
1330 (float)matrix.m[2][0], (float)matrix.m[2][1], (float)matrix.m[2][2], (float)matrix.m[2][3],
1331 (float)matrix.m[3][0], (float)matrix.m[3][1], (float)matrix.m[3][2], (float)matrix.m[3][3]
1336 public enum GLBufferContents { vertex, normal, texCoord, color };
1338 public define noAB = GLAB { 0 };
1340 static uint curArrayBuffer;
1346 void upload(uint size, void * data)
1351 GLGenBuffers(1, this);
1352 if(curArrayBuffer != buffer)
1353 GLBindBuffer(GL_ARRAY_BUFFER, buffer);
1354 glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW); //GL_DYNAMIC_DRAW);
1362 GLDeleteBuffers(1, this);
1367 void use(GLBufferContents contents, int n, int type, uint stride, void * pointer)
1369 if(curArrayBuffer != ((this != null) ? buffer : 0))
1370 GLBindBuffer(GL_ARRAY_BUFFER, ((this != null) ? buffer : 0));
1373 case normal: glNormalPointer(type, stride, pointer); break;
1374 case vertex: glVertexPointer(n, type, stride, pointer); break;
1375 case texCoord: glTexCoordPointer(n, type, stride, pointer); break;
1376 case color: glColorPointer(n, type, stride, pointer); break;
1380 void useVertTrans(uint count, int n, int type, uint stride, void * pointer)
1382 if(curArrayBuffer != ((this != null) ? buffer : 0))
1383 GLBindBuffer(GL_ARRAY_BUFFER, ((this != null) ? buffer : 0));
1385 glVertexPointeri(n, stride, pointer, count);
1386 else if(type == GL_DOUBLE)
1387 glVertexPointerd(n, stride, pointer, count);
1391 static uint curElementBuffer;
1393 public define noEAB = GLEAB { 0 };
1399 void upload(uint size, void * data)
1404 GLGenBuffers(1, (GLAB *)this);
1406 if(curElementBuffer != buffer)
1407 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
1408 glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, data, GL_STATIC_DRAW); //GL_DYNAMIC_DRAW);
1416 GLDeleteBuffers(1, (GLAB *)this);
1421 void draw(int primType, int count, int type, void * indices)
1423 if(curElementBuffer != ((this != null) ? buffer : 0))
1424 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ((this != null) ? buffer : 0));
1425 glDrawElements(primType, count, type, indices);
1429 public void GLGenBuffers(int count, GLAB * buffers)
1431 #if defined(__ANDROID__) || defined(__ODROID__)
1432 glGenBuffers(count, (GLuint *)buffers);
1434 #if defined(__WIN32__)
1437 glGenBuffersARB(count, (GLuint *)buffers);
1441 public void GLDeleteBuffers(int count, GLAB * buffers)
1444 for(i = 0; i < count; i++)
1446 uint buffer = buffers[i].buffer;
1447 if(buffer == curArrayBuffer)
1448 GLBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
1449 else if(buffer == curElementBuffer)
1450 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
1452 #if defined(__ANDROID__) || defined(__ODROID__)
1453 glDeleteBuffers(count, (GLuint *)buffers);
1455 #if defined(__WIN32__)
1456 if(glDeleteBuffersARB)
1458 glDeleteBuffersARB(count, (GLuint *)buffers);
1462 void GLBindBuffer(int target, uint buffer)
1464 #if defined(__ANDROID__) || defined(__ODROID__)
1465 glBindBuffer(target, buffer);
1467 #if defined(__WIN32__)
1470 glBindBufferARB(target, buffer);
1472 if(target == GL_ARRAY_BUFFER_ARB)
1473 curArrayBuffer = buffer;
1474 else if(target == GL_ELEMENT_ARRAY_BUFFER_ARB)
1475 curElementBuffer = buffer;
1478 public void GLVertexPointer(int numCoords, int glType, int stride, void *ptr, int numVertices)
1481 if(glType == GL_DOUBLE)
1482 glesVertexPointerd(numCoords, stride, ptr, numVertices);
1483 else if(glType == GL_INT)
1484 glesVertexPointeri(numCoords, stride, ptr, numVertices);
1487 glVertexPointer(numCoords, glType, stride, ptr);
1490 public void GLBufferData(int type, GLenum target, int size, const GLvoid *data, GLenum usage)
1493 if(type == GL_DOUBLE)
1494 glesBufferDatad(target, size, (void *)data, usage);
1495 else if(type == GL_UNSIGNED_INT)
1496 glesBufferDatai(target, size, (void *)data, usage);
1500 #if defined(__ANDROID__) || defined(__ODROID__)
1501 glBufferData(target, size, data, usage);
1504 #if defined(__WIN32__)
1507 glBufferDataARB(target, size, data, usage);
1511 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1512 static int primitiveTypes[RenderPrimitiveType] =
1514 GL_POINTS, GL_LINES, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP, GL_LINE_STRIP
1519 // Non OpenGL ES friendly stuff
1523 //#undef GL_UNSIGNED_INT
1528 #undef GL_QUAD_STRIP
1529 #undef GL_POLYGON_STIPPLE
1530 #undef GL_LINE_STIPPLE
1533 #undef GL_ALL_ATTRIB_BITS
1534 #undef GL_LIGHT_MODEL_LOCAL_VIEWER
1538 static int displayWidth, displayHeight;
1540 #define GL_CLAMP_TO_EDGE 0x812F
1542 static bool vboAvailable;
1544 static bool useSingleGLContext = false;
1545 class OGLDisplay : struct
1547 #if defined(__WIN32__)
1557 int imageBuffers[2];
1558 byte * pboMemory1, * pboMemory2;
1560 #elif !defined(__ANDROID__) && !defined(__ODROID__)
1561 GLXContext glContext;
1564 XShmSegmentInfo shminfo;
1566 XShmSegmentInfo shminfoShape;
1567 XImage * shapeImage;
1571 X11Picture windowPicture;
1572 X11Picture pixmapPicture;
1574 X11Picture shapePicture;
1577 ColorAlpha * flippingBuffer;
1578 int flipBufH, flipBufW;
1583 class OGLSystem : struct
1588 #if defined(__WIN32__)
1589 PIXELFORMATDESCRIPTOR pfd;
1594 #elif !defined(__ANDROID__) && !defined(__ODROID__)
1595 XVisualInfo * visualInfo;
1596 GLXContext glContext;
1597 GLXDrawable glxDrawable;
1601 class OGLSurface : struct
1608 float foreground[4], background[4], bitmapMult[4];
1611 class OGLMesh : struct
1620 class OGLIndices : struct
1630 class OpenGLDisplayDriver : DisplayDriver
1632 class_property(name) = "OpenGL";
1634 bool LockSystem(DisplaySystem displaySystem)
1636 #if !defined(__ANDROID__) && !defined(__ODROID__)
1637 OGLSystem oglSystem = displaySystem.driverData;
1638 if(useSingleGLContext) return true;
1639 #if defined(__WIN32__)
1640 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1641 #elif defined(__unix__) || defined(__APPLE__)
1642 //if(previous) return true;
1643 // printf("Making SYSTEM current\n");
1644 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)oglSystem.glxDrawable, oglSystem.glContext);
1645 //previous = oglSystem.glContext;
1651 void UnlockSystem(DisplaySystem displaySystem)
1653 if(useSingleGLContext) return;
1654 #if defined(__WIN32__)
1655 wglMakeCurrent(null, null);
1656 #elif defined(__unix__) || defined(__APPLE__)
1657 // printf("Making NULL current\n");
1658 #if defined(__ANDROID__) || defined(__ODROID__)
1660 glXMakeCurrent(xGlobalDisplay, None, null);
1666 bool Lock(Display display)
1668 #if !defined(__ANDROID__) && !defined(__ODROID__)
1669 OGLDisplay oglDisplay = display.driverData;
1670 if(useSingleGLContext) return true;
1671 #if defined(__WIN32__)
1672 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1673 #elif defined(__unix__) || defined(__APPLE__)
1674 // if(previous) glXMakeCurrent(xGlobalDisplay, None, null);
1675 // printf(" Making DISPLAY current\n");
1676 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
1682 void Unlock(Display display)
1684 if(useSingleGLContext) return;
1685 //printf(" Making NULL current\n");
1686 //glXMakeCurrent(xGlobalDisplay, None, null);
1688 LockSystem(display.displaySystem);
1691 void DestroyDisplay(Display display)
1693 OGLDisplay oglDisplay = display.driverData;
1697 #if defined(__WIN32__)
1698 wglMakeCurrent( null, null );
1701 wglDeleteContext(oglDisplay.glrc);
1703 if(oglDisplay.hdc && oglDisplay.pBuffer)
1704 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
1706 if(oglDisplay.pBuffer)
1707 wglDestroyPbufferARB(oglDisplay.pBuffer);
1710 ReleaseDC(display.window, oglDisplay.hdc);
1712 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
1713 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
1715 #elif defined(__unix__) || defined(__APPLE__)
1716 #if defined(__ANDROID__) || defined(__ODROID__)
1718 if(oglDisplay.shapePixmap)
1719 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
1720 if(oglDisplay.pixmap)
1721 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1722 if(oglDisplay.image)
1724 if(oglDisplay.shminfoShape.shmid != -1)
1726 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
1727 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1728 shmdt(oglDisplay.shminfo.shmaddr);
1729 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
1732 if(oglDisplay.shapeImage)
1734 if(oglDisplay.shminfoShape.shmid != -1)
1736 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
1737 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1738 shmdt(oglDisplay.shminfoShape.shmaddr);
1739 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
1741 XDestroyImage(oglDisplay.shapeImage);
1742 oglDisplay.shapeImage = None;
1745 glXMakeCurrent(xGlobalDisplay, None, null);
1747 if(oglDisplay.glContext)
1748 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
1751 delete oglDisplay.flippingBuffer;
1753 display.driverData = null;
1757 void ::CheckExtensions(OGLSystem oglSystem)
1759 const char * extensions = (const char *)glGetString(GL_EXTENSIONS);
1761 oglSystem.pow2textures = strstr(extensions, "GL_ARB_texture_non_power_of_two") ? false : true;
1762 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &oglSystem.maxTextureSize);
1765 bool CreateDisplaySystem(DisplaySystem displaySystem)
1767 bool result = false;
1768 OGLSystem oglSystem = displaySystem.driverData = OGLSystem { };
1771 oglSystem.hwnd = CreateWindow("static", null, 0,0,0,0,0,null,null,null,null);
1773 oglSystem.hdc = GetDC(oglSystem.hwnd);
1777 oglSystem.pfd.nSize = (short)sizeof(oglSystem.pfd);
1778 oglSystem.pfd.nVersion = 1;
1779 oglSystem.pfd.dwFlags = PFD_DRAW_TO_WINDOW /*PFD_DRAW_TO_BITMAP*/ | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
1780 oglSystem.pfd.iPixelType = PFD_TYPE_RGBA;
1781 oglSystem.pfd.cColorBits = 24;
1782 oglSystem.pfd.cAlphaBits = 8;
1783 oglSystem.pfd.cDepthBits = 24;
1784 oglSystem.pfd.iLayerType = PFD_MAIN_PLANE;
1786 oglSystem.format = ChoosePixelFormat(oglSystem.hdc, &oglSystem.pfd);
1787 DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1789 if(oglSystem.pfd.cColorBits > 8)
1791 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1792 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1795 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1797 // Get Pointers To The GL Functions
1798 glActiveTextureARB = (void *) wglGetProcAddress("glActiveTextureARB");
1799 glMultiTexCoord2fARB = (void *) wglGetProcAddress("glMultiTexCoord2fARB");
1800 glClientActiveTextureARB = (void *) wglGetProcAddress("glClientActiveTextureARB");
1801 glLockArraysEXT = (void *) wglGetProcAddress("glLockArraysEXT" );
1802 glUnlockArraysEXT = (void *) wglGetProcAddress("glUnlockArraysEXT");
1803 glGenBuffersARB = (void *) wglGetProcAddress("glGenBuffersARB");
1804 glBindBufferARB = (void *) wglGetProcAddress("glBindBufferARB");
1805 glBufferDataARB = (void *) wglGetProcAddress("glBufferDataARB");
1806 glMapBufferARB = (void *) wglGetProcAddress("glMapBufferARB");
1807 glUnmapBufferARB = (void *) wglGetProcAddress("glUnmapBufferARB");
1808 glDeleteBuffersARB = (void *) wglGetProcAddress("glDeleteBuffersARB");
1809 glBlendFuncSeparate = (void *) wglGetProcAddress("glBlendFuncSeparate");
1811 wglChoosePixelFormatARB = (void *) wglGetProcAddress("wglChoosePixelFormatARB");
1812 wglGetExtensionsStringARB = (void *)wglGetProcAddress("wglGetExtensionsStringARB");
1813 wglCreatePbufferARB = (void *)wglGetProcAddress("wglCreatePbufferARB");
1814 wglGetPbufferDCARB = (void *)wglGetProcAddress("wglGetPbufferDCARB");
1815 wglQueryPbufferARB = (void *)wglGetProcAddress("wglQueryPbufferARB");
1816 wglDestroyPbufferARB = (void *)wglGetProcAddress("wglDestroyPbufferARB");
1817 wglReleasePbufferDCARB = (void *)wglGetProcAddress("wglReleasePbufferDCARB");
1818 wglBindTexImageARB = (void *)wglGetProcAddress("wglBindTexImageARB");
1819 wglReleaseTexImageARB = (void *)wglGetProcAddress("wglReleaseTexImageARB");
1821 wglSwapIntervalEXT = (void *)wglGetProcAddress("wglSwapIntervalEXT");
1823 vboAvailable = glBindBufferARB != null;
1825 // eSystem_LoggingMode(LOG_MSGBOX, null);
1827 if(wglChoosePixelFormatARB)
1832 float fAttributes[] = {0,0};
1835 WGL_DRAW_TO_WINDOW_ARB,GL_TRUE,
1836 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1837 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
1838 WGL_COLOR_BITS_ARB,24,
1839 WGL_ALPHA_BITS_ARB,8,
1840 WGL_DEPTH_BITS_ARB,16,
1841 WGL_STENCIL_BITS_ARB,0,
1842 WGL_DOUBLE_BUFFER_ARB,GL_TRUE,
1843 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
1844 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
1848 //Log("Found wglChoosePixelFormatARB\n");
1850 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1851 if(!valid || !numFormats)
1853 //Log("Can't find 4x multi sampling\n");
1854 iAttributes[19] = 2;
1855 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1856 if(!valid || !numFormats)
1858 // Log("Can't find 2x multi sampling\n");
1859 iAttributes[16] = 0;
1860 iAttributes[17] = 0;
1861 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1864 if(valid && numFormats)
1866 oglSystem.format = pixelFormat;
1867 wglMakeCurrent(null, null);
1868 wglDeleteContext(oglSystem.glrc);
1870 // *** DescribePixelFormat does not support WGL pixel formats! ***
1871 //DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1872 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1873 //Log("Successfully set pixel format\n");
1875 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1876 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1880 eSystem_Logf("Can't find wglChoosePixelFormatARB\n");*/
1884 CheckExtensions(oglSystem);
1886 wglMakeCurrent(null, null);
1888 //eSystem_DumpErrors(true);
1892 #elif defined(__unix__) || defined(__APPLE__)
1893 vboAvailable = true;
1894 #if defined(__ANDROID__)
1895 egl_init_display(guiApp.desktop.windowHandle);
1896 #elif defined(__ODROID__)
1897 egl_init_display((uint)displaySystem.window);
1898 CheckExtensions(oglSystem);
1902 X11Window root = RootWindow( xGlobalDisplay, DefaultScreen( xGlobalDisplay ) );
1903 XSetWindowAttributes attr;
1908 #ifndef ECERE_MINIGLX
1909 GLX_USE_GL, GLX_DEPTH_SIZE, 1,
1912 GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,
1916 oglSystem.visualInfo = glXChooseVisual( xGlobalDisplay, DefaultScreen( xGlobalDisplay ), attrList );
1917 attr.background_pixel = 0;
1918 attr.border_pixel = 0;
1919 attr.colormap = XCreateColormap( xGlobalDisplay, root, oglSystem.visualInfo->visual, AllocNone);
1920 attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
1921 mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
1923 oglSystem.glxDrawable = XCreateWindow( xGlobalDisplay, root, 0, 0, 1, 1, 0, oglSystem.visualInfo->depth, InputOutput,
1924 oglSystem.visualInfo->visual, mask, &attr );
1926 if(oglSystem.visualInfo)
1928 oglSystem.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, null, True);
1929 if(oglSystem.glContext)
1931 glXMakeCurrent(xGlobalDisplay, oglSystem.glxDrawable, oglSystem.glContext);
1933 CheckExtensions(oglSystem);
1934 glXMakeCurrent(xGlobalDisplay, None, null);
1941 displaySystem.flags.alpha = true;
1942 displaySystem.flags.flipping = true;
1943 displaySystem.pixelFormat = pixelFormat888;
1947 void DestroyDisplaySystem(DisplaySystem displaySystem)
1949 OGLSystem oglSystem = displaySystem.driverData;
1951 #if defined(__WIN32__)
1952 wglMakeCurrent( null, null );
1955 wglDeleteContext(oglSystem.glrc);
1958 ReleaseDC(oglSystem.hwnd, oglSystem.hdc);
1959 DestroyWindow(oglSystem.hwnd);
1961 #elif defined(__unix__) || defined(__APPLE__)
1962 #if defined(__ANDROID__) || defined(__ODROID__)
1965 if(oglSystem.visualInfo)
1967 #ifdef ECERE_MINIGLX
1968 __miniglx_XFree(oglSystem.visualInfo);
1970 XFree(oglSystem.visualInfo);
1974 if(oglSystem.glxDrawable)
1976 XDestroyWindow(xGlobalDisplay, oglSystem.glxDrawable);
1977 oglSystem.glxDrawable = 0;
1984 bool CreateDisplay(Display display)
1986 bool result = false;
1987 OGLDisplay oglDisplay = display.driverData;
1988 #if !defined(__ANDROID__) && !defined(__ODROID__)
1989 OGLSystem oglSystem = display.displaySystem.driverData;
1992 oglDisplay = display.driverData = OGLDisplay { };
1993 //printf("Inside CreateDisplay\n");
1995 #if defined(__WIN32__) || defined(USEPBUFFER)
1996 if(!display.alphaBlend)
1999 #if defined(__WIN32__)
2000 oglDisplay.hdc = GetDC(display.window);
2001 SetPixelFormat(oglDisplay.hdc, oglSystem.format, &oglSystem.pfd);
2002 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
2004 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2005 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2009 ReleaseDC(display.window, oglDisplay.hdc);
2010 #elif defined(__unix__) || defined(__APPLE__)
2011 #if defined(__ANDROID__) || defined(__ODROID__)
2013 XVisualInfo * visualInfo = ((XWindowData)display.windowDriverData).visual;
2015 #if defined(__APPLE__)
2016 XVisualInfo template = { 0 };
2017 XWindowAttributes winAttr;
2019 XGetWindowAttributes(xGlobalDisplay, (X11Window)display.window, &winAttr);
2020 template.visualid = XVisualIDFromVisual(winAttr.visual);
2021 visualInfo = XGetVisualInfo(xGlobalDisplay, VisualIDMask, &template, &n);
2023 printf("XGetVisualInfo visual ID = %d\n", template.visualid);
2024 printf("visualInfo visual ID = %d\n", visualInfo->visualid);
2025 printf("oglSystem.visualInfo visual ID = %d\n", oglSystem.visualInfo->visualid);
2026 printf("((XWindowData)display.windowDriverData).visual visual ID = %d\n", ((XWindowData)display.windowDriverData).visual->visualid);
2028 // visualInfo = oglSystem.visualInfo;
2033 //printf("visualInfo is not null\n");
2034 // printf("Creating Display Context, sharing with %x!\n", oglSystem.glContext);
2035 oglDisplay.glContext = glXCreateContext(xGlobalDisplay, visualInfo, oglSystem.glContext, True);
2036 //XFree(visualInfo);
2039 // oglDisplay.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, oglSystem.glContext, True);
2040 if(oglDisplay.glContext)
2042 //printf("CreateDisplay Got a Context\n");
2043 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2049 #if defined(__WIN32__) || defined(USEPBUFFER)
2055 #if defined(__WIN32__)
2056 if(glBlendFuncSeparate)
2057 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2059 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2061 #if !defined(__OLDX__)
2062 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2064 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2069 glMatrixMode(GL_MODELVIEW);
2070 glScaled(1.0, 1.0, -1.0);
2071 // glTranslatef(0.375f, 0.375f, 0.0f);
2072 // glTranslatef(-0.625f, -0.625f, 0.0f);
2073 glMatrixMode(GL_PROJECTION);
2074 glShadeModel(GL_FLAT);
2076 // glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, true);
2077 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
2078 glFogi(GL_FOG_MODE, GL_EXP);
2079 glFogf(GL_FOG_DENSITY, 0);
2080 glEnable(GL_NORMALIZE);
2081 glDepthFunc(GL_LESS);
2083 glDisable(GL_MULTISAMPLE_ARB);
2085 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
2086 display.ambient = Color { 50,50,50 };
2089 if(!useSingleGLContext)
2091 #if defined(__WIN32__)
2092 wglMakeCurrent(null, null);
2093 #elif defined(__unix__) || defined(__APPLE__)
2094 #if defined(__ANDROID__) || defined(__ODROID__)
2097 glXMakeCurrent(xGlobalDisplay, None, null);
2103 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2111 bool DisplaySize(Display display, int width, int height)
2113 OGLDisplay oglDisplay = display.driverData;
2115 bool result = false;
2117 //printf("Inside DisplaySize\n");
2118 #if defined(__WIN32__) || defined(USEPBUFFER)
2119 OGLSystem oglSystem = display.displaySystem.driverData;
2120 if(display.alphaBlend)
2122 #if defined(__WIN32__)
2123 const int attributes[]=
2125 /*WGL_TEXTURE_FORMAT_ARB, WGL_TEXTURE_RGBA_ARB,
2126 WGL_TEXTURE_TARGET_ARB, WGL_TEXTURE_2D_ARB, */0
2128 int pixelFormat = 0;
2129 if(wglChoosePixelFormatARB)
2133 float fAttributes[] = {0,0};
2136 //WGL_DRAW_TO_BITMAP_ARB, GL_TRUE,
2137 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2138 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2139 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
2140 WGL_COLOR_BITS_ARB,24,
2141 WGL_ALPHA_BITS_ARB,8,
2142 WGL_DEPTH_BITS_ARB,16,
2143 WGL_STENCIL_BITS_ARB,0,
2144 WGL_DOUBLE_BUFFER_ARB,GL_FALSE,
2145 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
2146 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
2150 //Log("Found wglChoosePixelFormatARB\n");
2152 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2153 if(!valid || !numFormats)
2155 //Log("Can't find 4x multi sampling\n");
2156 iAttributes[19] = 2;
2157 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2158 if(!valid || !numFormats)
2160 // Log("Can't find 2x multi sampling\n");
2161 iAttributes[16] = 0;
2162 iAttributes[17] = 0;
2163 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2164 if(!valid || !numFormats)
2168 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2169 //WGL_DRAW_TO_BITMAP_ARB,GL_TRUE,
2170 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2171 WGL_COLOR_BITS_ARB,24,
2172 WGL_ALPHA_BITS_ARB,8,
2173 WGL_DEPTH_BITS_ARB,16,
2176 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2180 if(valid && numFormats)
2182 wglMakeCurrent(null, null);
2186 wglMakeCurrent( null, null );
2187 wglMakeCurrent( oglDisplay.hdc, oglDisplay.glrc );
2188 if(oglDisplay.hdc && oglDisplay.pBuffer)
2189 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
2191 wglDestroyPbufferARB(oglDisplay.pBuffer);
2193 if(!useSingleGLContext)
2194 wglMakeCurrent( null, null );
2197 wglDeleteContext(oglDisplay.glrc);
2199 oglDisplay.pBuffer = wglCreatePbufferARB(oglSystem.hdc, pixelFormat, width, height, attributes);
2200 oglDisplay.hdc = wglGetPbufferDCARB(oglDisplay.pBuffer);
2201 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
2204 HDC hdc = GetDC(display.window);
2206 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2207 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2209 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_WIDTH_ARB, &width);
2210 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_HEIGHT_ARB, &height);
2212 // glDeleteBuffersARB(2, oglDisplay.imageBuffers);
2214 if((info = (BITMAPINFO *)new0 byte[sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*256]))
2218 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
2219 oglDisplay.memDC = CreateCompatibleDC(hdc);
2220 SetMapMode(oglDisplay.memDC, MM_TEXT);
2221 info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2222 info->bmiHeader.biPlanes = 1;
2223 info->bmiHeader.biCompression = BI_RGB;
2224 info->bmiHeader.biBitCount = 32; //(uint16)GetDeviceCaps(hdc, BITSPIXEL);
2225 info->bmiHeader.biWidth = width;
2226 info->bmiHeader.biHeight = height;
2227 newBitmap = CreateDIBSection(hdc, info, DIB_RGB_COLORS, &oglDisplay.picture, null, 0);
2230 SelectObject(oglDisplay.memDC, newBitmap);
2231 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
2234 PIXELFORMATDESCRIPTOR pfd = { 0 };
2235 pfd.nSize = (short)sizeof(pfd);
2237 pfd.dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL;
2238 pfd.iPixelType = PFD_TYPE_RGBA;
2239 pfd.cColorBits = 32;
2240 //pfd.cAlphaBits = 8;
2241 pfd.cDepthBits = 24;
2242 pfd.iLayerType = PFD_MAIN_PLANE;
2244 oglDisplay.hdc = oglDisplay.memDC;
2246 pixelFormat = ChoosePixelFormat(oglSystem.hdc, &pfd);
2247 DescribePixelFormat(oglDisplay.hdc, pixelFormat, sizeof(pfd), &pfd);
2248 SetPixelFormat(oglDisplay.hdc, pixelFormat, &pfd);
2250 oglDisplay.glrc = wglCreateContext(oglDisplay.hdc);
2251 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2252 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2257 const int imageSize = width * height * 4;
2259 glGenBuffersARB(2, oglDisplay.imageBuffers);
2261 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2262 glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize, null, GL_STREAM_READ);
2263 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2264 // glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize / 2, null, GL_STREAM_READ);
2267 oglDisplay.memBitmap = newBitmap;
2268 oglDisplay.stride = width;
2274 ReleaseDC(display.window, hdc);
2276 #elif defined(__unix__) || defined(__APPLE__)
2277 #if defined(__ANDROID__) || defined(__ODROID__)
2282 GLX_DOUBLEBUFFER, True,
2288 GLX_STENCIL_SIZE, 1,
2289 //GLX_DEPTH_SIZE, 24,
2290 GLX_RENDER_TYPE, GLX_RGBA_BIT,
2291 GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT | GLX_WINDOW_BIT,
2297 GLX_PBUFFER_WIDTH, width,
2298 GLX_PBUFFER_HEIGHT, height,
2299 GLX_LARGEST_PBUFFER, False,
2303 // choose a pixel format that meets our minimum requirements
2306 GLXFBConfig *config = glXChooseFBConfig(xGlobalDisplay, DefaultScreen(xGlobalDisplay), attrib, &count);
2309 if(oglDisplay.pixmap)
2311 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2312 oglDisplay.pixmap = None;
2314 if(oglDisplay.shapePixmap)
2316 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
2317 oglDisplay.shapePixmap = None;
2320 // Free Shared Memory Pixmap
2321 if(oglDisplay.image)
2323 if(oglDisplay.shminfoShape.shmid != -1)
2325 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
2326 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2327 shmdt(oglDisplay.shminfo.shmaddr);
2328 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
2330 XDestroyImage(oglDisplay.image);
2331 oglDisplay.image = None;
2333 if(oglDisplay.shapeImage)
2335 if(oglDisplay.shminfoShape.shmid != -1)
2337 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
2338 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2339 shmdt(oglDisplay.shminfoShape.shmaddr);
2340 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
2342 XDestroyImage(oglDisplay.shapeImage);
2343 oglDisplay.shapeImage = None;
2346 if(oglDisplay.windowPicture)
2347 XRenderFreePicture(xGlobalDisplay, oglDisplay.windowPicture);
2348 if(oglDisplay.pixmapPicture)
2349 XRenderFreePicture(xGlobalDisplay, oglDisplay.pixmapPicture);
2351 if(oglDisplay.pixmap)
2352 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2354 if(oglDisplay.glContext)
2355 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
2356 if(oglDisplay.pBuffer)
2357 glXDestroyPbuffer(xGlobalDisplay, oglDisplay.pBuffer);
2359 oglDisplay.pBuffer = glXCreatePbuffer(xGlobalDisplay, config[0], PBattrib);
2360 if(oglDisplay.pBuffer)
2362 oglDisplay.glContext = glXCreateNewContext(xGlobalDisplay, config[0], GLX_RGBA_TYPE, oglSystem.glContext, True);
2363 if(oglDisplay.glContext)
2365 glXMakeCurrent(xGlobalDisplay, None, null);
2366 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2368 // Initialize Shared Memory Pixmap
2369 oglDisplay.image = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 32,
2370 ZPixmap, null, &oglDisplay.shminfo, width, height);
2371 if(oglDisplay.image)
2373 oglDisplay.shminfo.shmid = shmget(IPC_PRIVATE,
2374 oglDisplay.image->bytes_per_line * oglDisplay.image->height, IPC_CREAT|0777);
2375 if(oglDisplay.shminfo.shmid != -1)
2377 oglDisplay.shminfo.shmaddr = shmat(oglDisplay.shminfo.shmid, 0, 0);
2378 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2380 oglDisplay.shminfo.readOnly = False;
2381 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfo))
2383 oglDisplay.pixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfo.shmaddr,
2384 &oglDisplay.shminfo, width, height, 32);
2386 // Initialize Shared Memory Shape Pixmap
2387 oglDisplay.shapeImage = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 1,
2388 ZPixmap, null, &oglDisplay.shminfoShape, width, height);
2389 if(oglDisplay.shapeImage)
2391 oglDisplay.shminfoShape.shmid = shmget(IPC_PRIVATE,
2392 oglDisplay.shapeImage->bytes_per_line * oglDisplay.shapeImage->height, IPC_CREAT|0777);
2393 if(oglDisplay.shminfoShape.shmid != -1)
2395 oglDisplay.shminfoShape.shmaddr = shmat(oglDisplay.shminfoShape.shmid, 0, 0);
2396 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2398 oglDisplay.shminfoShape.readOnly = False;
2399 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfoShape))
2401 oglDisplay.shapePixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfoShape.shmaddr,
2402 &oglDisplay.shminfoShape, width, height, 1);
2403 //oglDisplay.shapePixmap = XCreatePixmap(xGlobalDisplay, (X11Window)display.window, width, height, 1);
2406 XRenderPictureAttributes attributes = { 0 };
2407 XRenderPictFormat * format = XRenderFindStandardFormat(xGlobalDisplay, /*PictStandardRGB24*/ PictStandardARGB32);
2408 #if !defined(__APPLE__) && !defined(__OLDX__)
2409 attributes.repeat = RepeatNormal;
2411 attributes.repeat = 1;
2413 oglDisplay.pixmapPicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.pixmap, format, CPRepeat, &attributes);
2414 oglDisplay.windowPicture = XRenderCreatePicture(xGlobalDisplay, (X11Window)display.window, format, 0, &attributes);
2415 oglDisplay.shapePicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.shapePixmap,
2416 XRenderFindStandardFormat(xGlobalDisplay, PictStandardA1), 0, &attributes);
2419 oglDisplay.picture = oglDisplay.shminfo.shmaddr;
2420 oglDisplay.stride = oglDisplay.image->bytes_per_line / 4;
2437 CreateDisplay(display);
2438 #if defined(__WIN32__)
2439 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2440 #elif defined(__unix__) || defined(__APPLE__)
2441 #if defined(__ANDROID__) || defined(__ODROID__)
2445 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2452 if(!result && display.alphaBlend)
2454 printf("Alpha blending windows not supported on this display\n");
2461 glViewport(0,0,width,height);
2463 glOrtho(0,width,height,0,0.0,1.0);
2464 displayWidth = display.width = width;
2465 displayHeight = display.height = height;
2467 if(!oglDisplay.flippingBuffer || oglDisplay.flipBufW < width || oglDisplay.flipBufH < height)
2469 oglDisplay.flipBufW = width;
2470 oglDisplay.flipBufH = height;
2474 oglDisplay.flippingBuffer = renew oglDisplay.flippingBuffer ColorAlpha [width * height];
2477 if(oglDisplay.flippingBuffer || !width || !height)
2483 void DisplayPosition(Display display, int x, int y)
2485 OGLDisplay oglDisplay = display.driverData;
2491 void SetPalette(Display display, ColorAlpha * palette, bool colorMatch)
2495 void RestorePalette(Display display)
2499 void StartUpdate(Display display)
2503 void EndUpdate(Display display)
2507 void Scroll(Display display, Box scroll, int x, int y, Extent dirty)
2511 void Update(Display display, Box updateBox)
2513 #if defined(__WIN32__) || defined(USEPBUFFER)
2514 OGLDisplay oglDisplay = display.driverData;
2516 //Logf("DisplayScreen\n");
2520 #if defined(__WIN32__) || defined(USEPBUFFER)
2521 if(display.alphaBlend)
2523 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2524 glPixelStorei(GL_PACK_ROW_LENGTH, oglDisplay.stride);
2525 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2526 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2527 glReadPixels(0,0,display.width,display.height,GL_BGRA_EXT,GL_UNSIGNED_BYTE, oglDisplay.picture);
2530 #if defined(__WIN32__)
2532 POINT point = { oglDisplay.x, oglDisplay.y};
2533 POINT srcPoint = { 0, 0 };
2534 BLENDFUNCTION blend = { 0 };
2536 size.cx = display.width;
2537 size.cy = display.height;
2538 blend.BlendOp = AC_SRC_OVER;
2539 blend.BlendFlags = 0;
2540 blend.SourceConstantAlpha = 255;
2541 blend.AlphaFormat = AC_SRC_ALPHA;
2544 // Process partial images. Mapping the buffer waits for
2545 // outstanding DMA transfers into the buffer to finish.
2546 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2547 oglDisplay.pboMemory1 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY);
2549 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2550 // oglDisplay.pboMemory2 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB,GL_READ_ONLY);
2553 memcpy(oglDisplay.picture, oglDisplay.pboMemory1, display.width * display.height * 4);
2554 //memcpy(oglDisplay.picture + display.width * display.height * 4 / 2, oglDisplay.pboMemory2, display.width * display.height * 4/ 2);
2557 UpdateLayeredWindow(display.window, hdc, &point, &size, oglDisplay.memDC, &srcPoint, 0, &blend, ULW_ALPHA);
2560 // Unmap the image buffers
2561 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2562 glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2564 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2565 // glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2567 // Bind two different buffer objects and start the glReadPixels
2568 // asynchronously. Each call will return directly after
2569 // starting the DMA transfer.
2570 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2571 glReadPixels(0, 0, display.width, display.height, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2573 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2574 // glReadPixels(0, display.height/2, display.width, display.height/2, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2578 #elif defined(__unix__) || defined(__APPLE__)
2579 #if defined(__ANDROID__) || defined(__ODROID__)
2581 XTransform transform =
2584 { (int)(1.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(0 * (1 << 16)) },
2585 { (int)(0.0f), (int)(-1.0f * (1<<16)), (int)(0 * (1<<16)) },
2586 { (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)) }
2589 XRenderSetPictureTransform(xGlobalDisplay, oglDisplay.pixmapPicture, &transform);
2590 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.shapePicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2591 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.windowPicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2592 #if !defined(__APPLE__) && !defined(__OLDX__)
2593 XShapeCombineMask(xGlobalDisplay, (X11Window)display.window, ShapeInput, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2595 XShapeCombineMask(xGlobalDisplay, display.window, 2, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2597 XFlush(xGlobalDisplay);
2605 #if defined(__WIN32__)
2606 //wglSwapLayerBuffers(oglDisplay.hdc,WGL_SWAP_MAIN_PLANE);
2607 SwapBuffers(oglDisplay.hdc);
2608 #elif defined(__unix__) || defined(__APPLE__)
2609 #if defined(__ANDROID__) || defined(__ODROID__)
2610 eglSwapBuffers(eglDisplay, eglSurface);
2612 glXSwapBuffers(xGlobalDisplay, (GLXDrawable)display.window);
2616 //Logf("Out of DisplayScreen\n");
2619 void FreeBitmap(DisplaySystem displaySystem, Bitmap bitmap)
2621 if(bitmap.driverData)
2623 GLuint tex = (GLuint)(uintptr)bitmap.driverData;
2624 glDeleteTextures(1, &tex);
2625 bitmap.driverData = 0;
2627 bitmap.driver = ((subclass(DisplayDriver))class(LFBDisplayDriver));
2630 bool AllocateBitmap(DisplaySystem displaySystem, Bitmap bitmap, int width, int height, int stride, PixelFormat format, bool allocatePalette)
2632 OGLSystem oglSystem = displaySystem.driverData;
2633 bool result = false;
2635 GLuint glBitmap = 0;
2637 uint w = width, h = height;
2638 if(oglSystem.pow2textures)
2643 w = Min(w, oglSystem.maxTextureSize);
2644 h = Min(h, oglSystem.maxTextureSize);
2646 glGenTextures(1, &glBitmap);
2647 glBindTexture(GL_TEXTURE_2D, glBitmap);
2649 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2651 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2652 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2654 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2655 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2657 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2659 mipMap.Allocate(null, w, h, w, pixelFormatRGBA, false);
2661 // glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2662 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2666 bitmap.driverData = (void *)(uintptr)glBitmap;
2667 bitmap.driver = displaySystem.driver;
2675 bool MakeDDBitmap(DisplaySystem displaySystem, Bitmap bitmap, bool mipMaps)
2677 bool result = false;
2678 OGLSystem oglSystem = displaySystem.driverData;
2680 // Pre process the bitmap... First make it 32 bit
2681 if(/*bitmap.pixelFormat == pixelFormatRGBA || */bitmap.Convert(null, pixelFormat888, null))
2684 uint w = bitmap.width, h = bitmap.height;
2685 GLuint glBitmap = 0;
2686 if(oglSystem.pow2textures)
2691 w = Min(w, oglSystem.maxTextureSize);
2692 h = Min(h, oglSystem.maxTextureSize);
2696 while(w * 2 < h) w *= 2;
2697 while(h * 2 < w) h *= 2;
2700 // Switch ARGB to RGBA
2701 //if(bitmap.format != pixelFormatRGBA)
2703 for(c=0; c<bitmap.size; c++)
2705 // ((ColorRGBA *)bitmap.picture)[c] = ((ColorAlpha *)bitmap.picture)[c];
2707 ColorAlpha color = ((ColorAlpha *)bitmap.picture)[c];
2708 ((ColorRGBA *)bitmap.picture)[c] = ColorRGBA { color.color.r, color.color.g, color.color.b, color.a };
2711 bitmap.pixelFormat = pixelFormat888;
2714 glGenTextures(1, &glBitmap);
2717 //int error = glGetError();
2721 glBindTexture(GL_TEXTURE_2D, glBitmap);
2722 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2724 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, mipMaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
2725 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2727 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2729 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
2730 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
2732 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2733 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2735 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2739 for(level = 0; result && (w >= 1 || h >= 1); level++, w >>= 1, h >>= 1)
2744 if(bitmap.width != w || bitmap.height != h)
2746 mipMap = Bitmap { };
2747 if(mipMap.Allocate(null, w, h, w, bitmap.pixelFormat, false))
2749 Surface mipSurface = mipMap.GetSurface(0,0,null);
2750 mipSurface.Filter(bitmap, 0,0,0,0, w, h, bitmap.width, bitmap.height);
2767 // glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2768 glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2769 //printf("Calling glTexImage2D\n");
2770 //glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &width);
2771 //printf("width = %d (Should be %d, %d)\n", width, w, h);
2772 if((error = glGetError()))
2774 //Logf("OpenGL Bitmap MakeDD error: %d...\n", error);
2775 //printf("OpenGL Bitmap MakeDD error: %d...\n", error);
2779 if(mipMap != bitmap)
2784 if(!bitmap.keepData)
2785 bitmap.driver.FreeBitmap(bitmap.displaySystem, bitmap);
2786 bitmap.driverData = (void *)(uintptr)glBitmap;
2787 bitmap.driver = displaySystem.driver;
2790 FreeBitmap(displaySystem, bitmap);
2791 else if(oglSystem.loadingFont)
2793 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2794 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2795 oglSystem.loadingFont = false;
2801 void ReleaseSurface(Display display, Surface surface)
2803 glDisable(GL_SCISSOR_TEST);
2804 delete surface.driverData;
2805 surface.driverData = null;
2808 bool GetBitmapSurface(DisplaySystem displaySystem, Surface surface, Bitmap bitmap, int x, int y, Box clip)
2813 bool GetSurface(Display display, Surface surface, int x,int y, Box clip)
2815 bool result = false;
2816 OGLSurface oglSurface = surface.driverData = OGLSurface { };
2818 //Logf("GetSurface\n");
2822 if(displayWidth != display.width || displayHeight != display.height)
2824 displayWidth = display.width;
2825 displayHeight = display.height;
2827 glViewport(0,0,display.width,display.height);
2829 glOrtho(0,display.width,display.height,0,0.0,1.0);
2832 surface.offset.x = x;
2833 surface.offset.y = y;
2834 surface.unclippedBox = surface.box = clip;
2835 oglSurface.bitmapMult[0] = 1;
2836 oglSurface.bitmapMult[1] = 1;
2837 oglSurface.bitmapMult[2] = 1;
2838 oglSurface.bitmapMult[3] = 1;
2840 glEnable(GL_SCISSOR_TEST);
2843 (display.height) -(y+clip.bottom)-1,
2844 clip.right-clip.left+1,
2845 clip.bottom-clip.top+1);
2851 void Clip(Display display, Surface surface, Box clip)
2860 box.Clip(surface.unclippedBox);
2864 box = surface.box = surface.unclippedBox;
2865 box.left += surface.offset.x;
2866 box.top += surface.offset.y;
2867 box.right+= surface.offset.x;
2868 box.bottom += surface.offset.y;
2871 box.left,display.height - box.bottom - 1,
2872 box.right-box.left+1, box.bottom-box.top+1);
2875 bool GrabScreen(Display display, Bitmap bitmap, int x, int y, unsigned int w, unsigned int h)
2877 bool result = false;
2878 OGLDisplay oglDisplay = display.driverData;
2879 ColorAlpha * flippingBuffer = oglDisplay.flippingBuffer;
2881 if(oglDisplay.flippingBuffer)
2883 if(bitmap.pixelFormat != pixelFormat888 || bitmap.width < w || bitmap.height < h)
2886 bitmap.Allocate(null, w,h,w, pixelFormat888, false);
2892 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2893 glPixelStorei(GL_PACK_ROW_LENGTH, bitmap.stride);
2894 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2895 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2896 glReadPixels(x,display.height-h-y,w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, flippingBuffer);
2899 for(row = 0; row<h; row++)
2900 CopyBytesBy4(((ColorAlpha *)bitmap.picture) + row * w, ((ColorAlpha *)flippingBuffer) + (h-row-1) * w, w);
2907 void SetForeground(Display display, Surface surface, ColorAlpha color)
2909 OGLSurface oglSurface = surface.driverData;
2911 //Logf("SetForeground\n");
2913 oglSurface.foreground[0] = color.color.r/255.0f;
2914 oglSurface.foreground[1] = color.color.g/255.0f;
2915 oglSurface.foreground[2] = color.color.b/255.0f;
2916 //oglSurface.foreground[3] = 1.0f;
2917 oglSurface.foreground[3] = color.a/255.0f;
2919 //if(!oglSurface.foreground[3])printf("bug");
2922 void SetBackground(Display display, Surface surface, ColorAlpha color)
2924 OGLSurface oglSurface = surface.driverData;
2926 //Logf("SetBackground\n");
2928 oglSurface.background[0] = color.color.r/255.0f;
2929 oglSurface.background[1] = color.color.g/255.0f;
2930 oglSurface.background[2] = color.color.b/255.0f;
2931 //oglSurface.background[3] = 1.0;
2932 oglSurface.background[3] = color.a/255.0f;
2935 void SetBlitTint(Display display, Surface surface, ColorAlpha color)
2937 OGLSurface oglSurface = surface.driverData;
2939 oglSurface.bitmapMult[0] = color.color.r/255.0f;
2940 oglSurface.bitmapMult[1] = color.color.g/255.0f;
2941 oglSurface.bitmapMult[2] = color.color.b/255.0f;
2942 oglSurface.bitmapMult[3] = color.a/255.0f;
2945 ColorAlpha GetPixel(Display display, Surface surface,int x,int y)
2950 void PutPixel(Display display, Surface surface,int x,int y)
2952 OGLSurface oglSurface = surface.driverData;
2954 //Logf("PutPixel\n");
2956 glColor4fv(oglSurface.foreground);
2958 // glVertex2i(x+surface.offset.x, y+surface.offset.y);
2959 glVertex2f(x+surface.offset.x + 0.5f, y+surface.offset.y + 0.5f);
2964 void DrawLine(Display display, Surface surface, int _x1, int _y1, int _x2, int _y2)
2966 OGLSurface oglSurface = surface.driverData;
2967 float x1 = _x1, x2 = _x2, y1 = _y1, y2 = _y2;
2982 x1 += surface.offset.x;
2983 y1 += surface.offset.y;
2984 x2 += surface.offset.x;
2985 y2 += surface.offset.y;
2989 glColor4fv(oglSurface.foreground);
2994 glTexCoord2f(0.5f, 0);
2995 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2996 glTexCoord2f(Max(x2-x1, y2-y1) + 0.5f, 0);
2997 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3006 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3007 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3013 void Rectangle(Display display, Surface surface,int x1,int y1,int x2,int y2)
3015 OGLSurface oglSurface = surface.driverData;
3016 x1 += surface.offset.x;
3017 y1 += surface.offset.y;
3018 x2 += surface.offset.x;
3019 y2 += surface.offset.y;
3021 //Logf("Rectangle\n");
3023 glColor4fv(oglSurface.foreground);
3029 glTexCoord2f(0.5f, 0);
3030 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3031 glTexCoord2f(y2-y1 + 0.5f, 0);
3032 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3034 glTexCoord2f(0.5f, 0);
3035 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3036 glTexCoord2f(x2 - x1 + 0.5f, 0);
3037 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3039 glTexCoord2f(0.5f, 0);
3040 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3041 glTexCoord2f(y1 - y2 + 0.5f, 0);
3042 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3044 glTexCoord2f(0.5f, 0);
3045 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3046 glTexCoord2f(x1 - x2 + 0.5f, 0);
3047 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3052 glBegin(GL_LINE_LOOP);
3059 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3060 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3061 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3062 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3067 void Area(Display display, Surface surface,int x1,int y1,int x2,int y2)
3069 OGLSurface oglSurface = surface.driverData;
3072 glColor4fv(oglSurface.background);
3073 glRecti(x1+surface.offset.x, y1+surface.offset.y,
3074 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
3077 glRectf(x1+surface.offset.x, y1+surface.offset.y,
3078 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
3082 void Clear(Display display, Surface surface, ClearType type)
3084 OGLDisplay oglDisplay = display.driverData;
3085 OGLSurface oglSurface = surface.driverData;
3088 if(type != depthBuffer)
3089 glClearColor(oglSurface.background[0], oglSurface.background[1], oglSurface.background[2], oglSurface.background[3]);
3090 if(type != colorBuffer && !oglDisplay.depthWrite)
3092 glDepthMask((byte)bool::true);
3094 glClear(((type != depthBuffer) ? GL_COLOR_BUFFER_BIT : 0) |
3095 ((type != colorBuffer) ? GL_DEPTH_BUFFER_BIT : 0));
3096 if(type != colorBuffer && !oglDisplay.depthWrite)
3098 glDepthMask((byte)bool::false);
3102 bool ConvertBitmap(DisplaySystem displaySystem, Bitmap bitmap, PixelFormat format, ColorAlpha * palette)
3107 void Blit(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3109 OGLSurface oglSurface = surface.driverData;
3111 #if !defined(__OLDX__)
3112 // WHY DO WE HAVE GL_ONE HERE ?
3113 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3114 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3117 if(!oglSurface.writingText)
3119 // glTranslatef(-0.375f, -0.375f, 0.0f);
3120 glEnable(GL_TEXTURE_2D);
3121 glColor4fv(oglSurface.bitmapMult);
3123 else if(oglSurface.xOffset)
3124 glTranslated(oglSurface.xOffset / 64.0/*-0.375*/, 0.0, 0.0);
3126 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3131 glTexCoord2f((float)sx/ bitmap.width, (float)(sy-h)/ bitmap.height);
3132 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3133 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy-h)/ bitmap.height);
3134 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3135 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3136 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
3137 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3138 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3143 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3144 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3145 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3146 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3147 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3148 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3149 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3150 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3153 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3154 glVertex2f((float)dx+surface.offset.x, (float)dy+surface.offset.y);
3155 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3156 glVertex2f((float)dx+w+surface.offset.x, (float)dy+surface.offset.y);
3157 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3158 glVertex2f((float)dx+w+surface.offset.x, (float)dy+h+surface.offset.y);
3159 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3160 glVertex2f((float)dx+surface.offset.x, (float)dy+h+surface.offset.y);
3164 if(!oglSurface.writingText)
3166 glDisable(GL_TEXTURE_2D);
3168 //glTranslate(0.375, 0.375, 0.0);
3170 else if(oglSurface.xOffset)
3171 glTranslated(-oglSurface.xOffset / 64.0/*+0.375*/, 0.0, 0.0);
3173 #if !defined(__OLDX__)
3174 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3175 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3179 void Stretch(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3181 OGLSurface oglSurface = surface.driverData;
3183 //glTranslate(-0.375, -0.375, 0.0);
3185 //Logf("Stretch\n");
3187 #if !defined(__OLDX__)
3188 /*if(glBlendFuncSeparate)
3189 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3192 glEnable(GL_TEXTURE_2D);
3193 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3195 glColor4fv(oglSurface.bitmapMult);
3201 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3202 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3204 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3205 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3207 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3208 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
3210 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3211 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3215 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3216 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3218 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3219 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3221 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3222 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3224 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3225 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3230 glDisable(GL_TEXTURE_2D);
3232 //glTranslate(0.375, 0.375, 0.0);
3233 #if !defined(__OLDX__)
3234 /*if(glBlendFuncSeparate)
3235 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3240 void Filter(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3242 Stretch(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3245 void StretchDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3247 float s2dw,s2dh,d2sw,d2sh;
3248 //bool flipX = false, flipY = false;
3250 //Logf("StretchDI\n");
3252 if(Sgn(w) != Sgn(sw))
3258 if(Sgn(h) != Sgn(sh))
3270 //Clip against the edges of the source
3273 dx+=(int)((0-sx) * s2dw);
3274 w-=(int)((0-sx) * s2dw);
3280 dy+=(int)((0-sy) * s2dh);
3281 h-=(int)((0-sy) * s2dh);
3286 if(sx+sw>bitmap.width-1)
3288 w-=(int)((sx+sw-(bitmap.width-1)-1)*s2dw);
3289 sw-=sx+sw-(bitmap.width-1)-1;
3291 if(sy+sh>(bitmap.height-1))
3293 h-=(int)((sy+sh-(bitmap.height-1)-1)*s2dh);
3294 sh-=sy+sh-(bitmap.height-1)-1;
3296 //Clip against the edges of the surfaceination
3297 if(dx<surface.box.left)
3300 sx+=(int)((surface.box.left-dx)*d2sw);
3301 sw-=(int)((surface.box.left-dx)*d2sw);
3302 w-=surface.box.left-dx;
3303 dx=surface.box.left;
3305 if(dy<surface.box.top)
3307 sy+=(int)((surface.box.top-dy)*d2sh);
3308 sh-=(int)((surface.box.top-dy)*d2sh);
3309 h-=surface.box.top-dy;
3312 if(dx+w>surface.box.right)
3314 //if(flip) sx+=(int)((dx+w-surface.box.right-1)*d2sw);
3315 sw-=(int)((dx+w-surface.box.right-1)*d2sw);
3316 w-=dx+w-surface.box.right-1;
3318 if(dy+h>surface.box.bottom)
3320 sh-=(int)((dy+h-surface.box.bottom-1)*d2sh);
3321 h-=dy+h-surface.box.bottom-1;
3323 if((w<=0)||(h<=0)||(sw<=0)||(sh<=0)) return;
3325 dx += surface.offset.x;
3326 dy += surface.offset.y;
3328 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3330 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3331 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3332 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3333 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3334 glRasterPos2d(dx,dy);
3335 //glPixelZoom(flipX ? -s2dw : s2dw, flipY ? s2dh : -s2dh);
3336 glPixelZoom(s2dw, -s2dh);
3337 glDrawPixels(sw,sh,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3338 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3339 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3340 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3341 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3345 void BlitDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3349 //Clip against the edges of the source
3362 if(sx+w>bitmap.width-1)
3363 w-=sx+w-(bitmap.width-1)-1;
3364 if(sy+h>bitmap.height-1)
3365 h-=sy+h-(bitmap.height-1)-1;
3366 //Clip against the edges of the surfaceination
3367 if(dx<surface.box.left)
3370 sx+=surface.box.left-dx;
3371 w-=surface.box.left-dx;
3372 dx=surface.box.left;
3374 if(dy<surface.box.top)
3376 sy+=surface.box.top-dy;
3377 h-=surface.box.top-dy;
3380 if(dx+w>surface.box.right)
3382 //if(flip) sx+=dx+w-surface.box.right-1;
3383 w-=dx+w-surface.box.right-1;
3385 if(dy+h>surface.box.bottom)
3386 h-=dy+h-surface.box.bottom-1;
3390 dx += surface.offset.x;
3391 dy += surface.offset.y;
3393 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3395 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3396 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3397 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3398 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3399 glRasterPos2d(dx,dy);
3401 glDrawPixels(w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3402 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3403 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3404 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3405 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3409 void FilterDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3411 StretchDI(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3414 void UnloadFont(DisplaySystem displaySystem, Font font)
3416 ((subclass(DisplayDriver))class(LFBDisplayDriver)).UnloadFont(displaySystem, font);
3419 Font LoadFont(DisplaySystem displaySystem, const char * faceName, float size, FontFlags flags)
3422 OGLSystem oglSystem = displaySystem.driverData;
3423 oglSystem.loadingFont = true;
3424 font = ((subclass(DisplayDriver))class(LFBDisplayDriver)).LoadFont(displaySystem, faceName, size, flags);
3428 void FontExtent(DisplaySystem displaySystem, Font font, const char * text, int len, int * width, int * height)
3430 ((subclass(DisplayDriver))class(LFBDisplayDriver)).FontExtent(displaySystem, font, text, len, width, height);
3433 void WriteText(Display display, Surface surface, int x, int y, const char * text, int len)
3435 OGLSurface oglSurface = surface.driverData;
3436 OGLSystem oglSystem = display.displaySystem.driverData;
3437 oglSystem.loadingFont = true;
3439 //glTranslated(-0.375, -0.375, 0.0);
3443 if(surface.textOpacity)
3446 FontExtent(display.displaySystem, surface.font, text, len, &w, &h);
3447 display.displaySystem.driver.Area(display, surface,x,y,x+w-1,y+h-1);
3450 oglSurface.writingText = true;
3452 glEnable(GL_TEXTURE_2D);
3453 glColor4fv(oglSurface.foreground);
3455 ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x, y, text, len);
3456 oglSurface.writingText = false;
3457 oglSystem.loadingFont = false;
3459 glDisable(GL_TEXTURE_2D);
3461 //glTranslated(0.375, 0.375, 0.0);
3464 void TextFont(Display display, Surface surface, Font font)
3466 ((subclass(DisplayDriver))class(LFBDisplayDriver)).TextFont(display, surface, font);
3469 void TextOpacity(Display display, Surface surface, bool opaque)
3471 OGLSurface oglSurface = surface.driverData;
3472 oglSurface.opaqueText = opaque;
3475 void TextExtent(Display display, Surface surface, const char * text, int len, int * width, int * height)
3477 OGLSurface oglSurface = surface.driverData;
3478 OGLSystem oglSystem = display.displaySystem.driverData;
3479 oglSystem.loadingFont = true;
3480 FontExtent(display.displaySystem, oglSurface.font, text, len, width, height);
3481 oglSystem.loadingFont = false;
3484 void DrawingChar(Display display, Surface surface, char character)
3489 void LineStipple(Display display, Surface surface, uint32 stipple)
3491 //Logf("Stipple\n");
3496 stippleEnabled = true;
3497 glesLineStipple(1, (uint16)stipple);
3499 glLineStipple(1, (uint16)stipple);
3500 glEnable(GL_LINE_STIPPLE);
3506 stippleEnabled = false;
3507 glMatrixMode(GL_TEXTURE);
3509 glMatrixMode(GL_PROJECTION);
3510 glDisable(GL_TEXTURE_2D);
3512 glDisable(GL_LINE_STIPPLE);
3516 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
3517 void SetRenderState(Display display, RenderState state, uint value)
3519 OGLDisplay oglDisplay = display.driverData;
3520 //Logf("RenderState\n");
3526 glEnable(GL_MULTISAMPLE_ARB);
3528 glDisable(GL_MULTISAMPLE_ARB);
3532 glPolygonMode(GL_FRONT_AND_BACK, ((FillModeValue)value == solid) ? GL_FILL : GL_LINE);
3536 if(value) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
3539 if(value) glDepthMask((byte)bool::true); else glDepthMask((byte)bool::false);
3540 oglDisplay.depthWrite = (bool)value;
3544 float color[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3545 glFogfv(GL_FOG_COLOR, (float *)&color);
3549 glFogf(GL_FOG_DENSITY, (float)(RenderStateFloat { ui = value }.f * nearPlane));
3552 if(value) glEnable(GL_BLEND); else glDisable(GL_BLEND);
3556 float ambient[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3557 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
3562 if(value) glColorMask(1,1,1,1); else glColorMask(1,1,1,0);
3567 #if defined(__WIN32__)
3568 wglSwapIntervalEXT(value ? 1 : 0);
3575 void SetLight(Display display, int id, Light light)
3577 //Logf("SetLight\n");
3581 Object lightObject = light.lightObject;
3582 float position[4] = { 0, 0, 0, 0 };
3583 float color[4] = { 0, 0, 0, 1 };
3585 glEnable(GL_LIGHT0 + id);
3587 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, (float *)&light.diffuse);
3588 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, (float *)&light.ambient);
3589 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,(float *)&light.specular);
3592 if(!light.multiplier) light.multiplier = 1.0f;
3594 color[0] = light.diffuse.r * light.multiplier;
3595 color[1] = light.diffuse.g * light.multiplier;
3596 color[2] = light.diffuse.b * light.multiplier;
3597 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, color);
3599 color[0] = light.ambient.r * light.multiplier;
3600 color[1] = light.ambient.g * light.multiplier;
3601 color[2] = light.ambient.b * light.multiplier;
3602 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, color);
3603 color[0] = light.specular.r * light.multiplier;
3604 color[1] = light.specular.g * light.multiplier;
3605 color[2] = light.specular.b * light.multiplier;
3606 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,color);
3610 Vector3D positionVector;
3611 if(light.flags.spot)
3613 if(lightObject.flags.root || !lightObject.parent)
3615 positionVector = lightObject.transform.position;
3616 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3620 positionVector.MultMatrix(lightObject.transform.position, lightObject.parent.matrix);
3621 if(display.display3D.camera)
3622 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3628 if(!light.direction.x && !light.direction.y && !light.direction.z)
3630 Vector3Df vector { 0,0,-1 };
3632 mat.RotationQuaternion(light.orientation);
3633 positionVector.MultMatrixf(vector, mat);
3637 positionVector = light.direction;
3642 position[0] = (float)positionVector.x;
3643 position[1] = (float)positionVector.y;
3644 position[2] = (float)positionVector.z;
3646 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3649 // Display Light Position
3650 glDisable(GL_LIGHTING);
3651 glDisable(GL_DEPTH_TEST);
3655 glVertex3fv(position);
3657 glEnable(GL_DEPTH_TEST);
3658 glEnable(GL_LIGHTING);
3662 if(lightObject.flags.root || !lightObject.parent)
3664 positionVector = light.target.transform.position;
3665 positionVector.Subtract(positionVector, display.camera.cPosition);
3669 positionVector.MultMatrix(light.target.transform.position,
3670 lightObject.light.target.parent.matrix);
3671 positionVector.Subtract(positionVector, display.camera.cPosition);
3674 position[0] = positionVector.x;
3675 position[1] = positionVector.y;
3676 position[2] = positionVector.z;
3678 glDisable(GL_LIGHTING);
3679 glDisable(GL_DEPTH_TEST);
3683 glVertex3fv(position);
3685 glEnable(GL_DEPTH_TEST);
3686 glEnable(GL_LIGHTING);
3689 if(light.flags.attenuation)
3691 glLightf(GL_LIGHT0 + id, GL_CONSTANT_ATTENUATION, light.Kc);
3692 glLightf(GL_LIGHT0 + id, GL_LINEAR_ATTENUATION, light.Kl);
3693 glLightf(GL_LIGHT0 + id, GL_QUADRATIC_ATTENUATION, light.Kq);
3696 if(light.flags.spot)
3699 #define MAXLIGHT 0.9
3700 float direction[4] = { (float)light.direction.x, (float)light.direction.y, (float)light.direction.z, 1 };
3701 // Figure out exponent out of the hot spot
3702 exponent = (float)(log(MAXLIGHT) / log(cos((light.hotSpot / 2))));
3704 glLightfv(GL_LIGHT0 + id, GL_SPOT_DIRECTION, direction);
3705 glLightf(GL_LIGHT0 + id, GL_SPOT_CUTOFF, (float)(light.fallOff / 2));
3706 glLightf(GL_LIGHT0 + id, GL_SPOT_EXPONENT, exponent);
3712 Vector3Df vector { 0,0,-1 };
3713 Vector3Df direction;
3716 mat.RotationQuaternion(light.orientation);
3717 direction.MultMatrix(vector, mat);
3719 position[0] = direction.x;
3720 position[1] = direction.y;
3721 position[2] = direction.z;
3723 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3727 glDisable(GL_LIGHT0 + id);
3730 void SetCamera(Display display, Surface surface, Camera camera)
3732 OGLDisplay oglDisplay = display.driverData;
3733 //Logf("SetCamera\n");
3737 int left = surface.box.left + surface.offset.x;
3738 int top = surface.box.top + surface.offset.y;
3739 int right = surface.box.right + surface.offset.x;
3740 int bottom = surface.box.bottom + surface.offset.y;
3741 float origX = surface.offset.x + camera.origin.x;
3742 float origY = surface.offset.y + camera.origin.y;
3744 int y = display.height - bottom - 1;
3745 int w = right - left + 1;
3746 int h = bottom - top + 1;
3749 glViewport(x, y, w, h);
3751 // *** Projection Matrix ***
3752 if(!display.display3D.camera)
3755 glMatrixMode(GL_PROJECTION);
3756 if(display.display3D.collectingHits)
3758 float pickX = display.display3D.pickX + surface.offset.x;
3759 float pickY = display.height - (display.display3D.pickY + surface.offset.y) - 1;
3763 w / display.display3D.pickWidth, 0, 0, 0,
3764 0, h / display.display3D.pickHeight, 0, 0,
3766 (w + 2.0f * (x - pickX)) / display.display3D.pickWidth,
3767 (h + 2.0f * (y - pickY)) / display.display3D.pickHeight, 0, 1
3770 glLoadMatrixd(pickMatrix.array);
3775 (left - origX) * camera.zMin / camera.focalX,
3776 (right - origX) * camera.zMin / camera.focalX,
3777 (bottom - origY) * camera.zMin / camera.focalY,
3778 (top - origY) * camera.zMin / camera.focalY,
3779 camera.zMin, camera.zMax);
3781 glDisable(GL_BLEND);
3783 // *** Z Inverted Identity Matrix ***
3784 glMatrixMode(GL_MODELVIEW);
3785 if(!display.display3D.camera)
3790 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
3792 // *** View Matrix ***
3793 glMultMatrixd(camera.viewMatrix.array);
3798 glEnable(GL_DEPTH_TEST);
3799 glEnable(GL_LIGHTING);
3800 glShadeModel(GL_SMOOTH);
3801 glDepthMask((byte)bool::true);
3802 oglDisplay.depthWrite = true;
3804 glEnable(GL_MULTISAMPLE_ARB);
3806 else if(display.display3D.camera)
3808 oglDisplay.depthWrite = false;
3809 glViewport(0,0,display.width,display.height);
3811 glDisable(GL_CULL_FACE);
3812 glDisable(GL_DEPTH_TEST);
3813 glDisable(GL_LIGHTING);
3815 glDisable(GL_TEXTURE_2D);
3816 glShadeModel(GL_FLAT);
3818 glDisable(GL_MULTISAMPLE_ARB);
3820 // *** Restore 2D MODELVIEW Matrix ***
3823 // *** Restore 2D PROJECTION Matrix ***
3824 glMatrixMode(GL_PROJECTION);
3830 void ApplyMaterial(Display display, Material material, Mesh mesh)
3832 //Logf("ApplyMaterial\n");
3835 if(material.flags.doubleSided)
3837 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, !material.flags.singleSideLight);
3838 glDisable(GL_CULL_FACE);
3842 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, bool::false);
3843 glEnable(GL_CULL_FACE);
3847 if(material.flags.noFog)
3853 if(material.baseMap && (mesh.texCoords || mesh.flags.texCoords1))
3855 Bitmap map = material.baseMap;
3856 glEnable(GL_TEXTURE_2D);
3857 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)map.driverData);
3859 glMatrixMode(GL_TEXTURE);
3861 if(material.uScale && material.vScale)
3862 glScalef(material.uScale, material.vScale, 1);
3863 glMatrixMode(GL_MODELVIEW);
3865 if(material.flags.tile)
3867 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
3868 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
3872 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
3873 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
3877 glDisable(GL_TEXTURE_2D);
3879 if(mesh.flags.colors)
3881 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
3882 glEnable(GL_COLOR_MATERIAL);
3886 glDisable(GL_COLOR_MATERIAL);
3888 float color[4] = { material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity };
3889 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
3892 float color[4] = { material.ambient.r, material.ambient.g, material.ambient.b, 0 };
3893 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
3897 float color[4] = { material.specular.r, material.specular.g, material.specular.b, 0 };
3898 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, color);
3901 float color[4] = { material.emissive.r, material.emissive.g, material.emissive.b, 0 };
3902 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, color);
3905 glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &material.power);
3908 void FreeMesh(DisplaySystem displaySystem, Mesh mesh)
3910 OGLMesh oglMesh = mesh.data;
3913 if(!mesh.flags.vertices)
3915 oglMesh.vertices.free();
3916 delete mesh.vertices;
3918 if(!mesh.flags.normals)
3920 oglMesh.normals.free();
3921 delete mesh.normals;
3923 if(!mesh.flags.texCoords1)
3925 oglMesh.texCoords.free();
3926 delete mesh.texCoords;
3928 if(!mesh.flags.texCoords2)
3930 oglMesh.texCoords2.free();
3931 // delete mesh.texCoords2;
3933 if(!mesh.flags.colors)
3935 oglMesh.colors.free();
3946 bool AllocateMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags, int nVertices)
3948 bool result = false;
3951 mesh.data = OGLMesh { };
3954 if(mesh.nVertices == nVertices)
3956 // Same number of vertices, adding features (Leaves the other features pointers alone)
3957 if(mesh.flags != flags)
3959 if(!mesh.flags.vertices && flags.vertices)
3961 if(flags.doubleVertices)
3963 mesh.vertices = (Vector3Df *)new Vector3D[nVertices];
3966 mesh.vertices = new Vector3Df[nVertices];
3968 if(!mesh.flags.normals && flags.normals)
3970 if(flags.doubleNormals)
3972 mesh.normals = (Vector3Df *)new Vector3D[nVertices];
3975 mesh.normals = new Vector3Df[nVertices];
3977 if(!mesh.flags.texCoords1 && flags.texCoords1)
3979 mesh.texCoords = new Pointf[nVertices];
3981 if(!mesh.flags.colors && flags.colors)
3983 mesh.colors = new ColorRGBAf[nVertices];
3989 // New number of vertices, reallocate all current and new features
3990 flags |= mesh.flags;
3993 if(flags.doubleVertices)
3995 mesh.vertices = (Vector3Df *)renew mesh.vertices Vector3D[nVertices];
3998 mesh.vertices = renew mesh.vertices Vector3Df[nVertices];
4002 if(flags.doubleNormals)
4004 mesh.normals = (Vector3Df *)renew mesh.normals Vector3D[nVertices];
4007 mesh.normals = renew mesh.normals Vector3Df[nVertices];
4009 if(flags.texCoords1)
4011 mesh.texCoords = renew mesh.texCoords Pointf[nVertices];
4015 mesh.colors = renew mesh.colors ColorRGBAf[nVertices];
4023 void UnlockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
4025 OGLMesh oglMesh = mesh.data;
4026 if(!flags) flags = mesh.flags;
4031 oglMesh.vertices.upload(
4032 mesh.nVertices * (mesh.flags.doubleVertices ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.vertices); //, GL_STATIC_DRAW_ARB );
4035 oglMesh.normals.upload(
4036 mesh.nVertices * (mesh.flags.doubleNormals ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.normals); //, GL_STATIC_DRAW_ARB );
4038 if(flags.texCoords1)
4039 oglMesh.texCoords.upload(
4040 mesh.nVertices * sizeof(Pointf), mesh.texCoords); //, GL_STATIC_DRAW_ARB );
4043 oglMesh.colors.upload(
4044 mesh.nVertices * sizeof(ColorRGBAf), mesh.colors); //, GL_STATIC_DRAW_ARB );
4048 bool LockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
4055 void FreeIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4059 oglIndices.buffer.free();
4060 delete oglIndices.indices;
4065 void * AllocateIndices(DisplaySystem displaySystem, int nIndices, bool indices32bit)
4067 OGLIndices oglIndices = OGLIndices { };
4070 oglIndices.indices = (void *)(indices32bit ? new uint32[nIndices] : new uint16[nIndices]);
4071 oglIndices.nIndices = nIndices;
4076 void UnlockIndices(DisplaySystem displaySystem, OGLIndices oglIndices, bool indices32bit, int nIndices)
4080 oglIndices.buffer.upload(
4081 nIndices * (indices32bit ? sizeof(uint32) : sizeof(uint16)),
4082 oglIndices.indices); //GL_STATIC_DRAW_ARB);
4086 uint16 * LockIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4089 return oglIndices.indices;
4092 void SelectMesh(Display display, Mesh mesh)
4094 //Logf("SelectMesh\n");
4096 #if !defined( __ANDROID__) && !defined(__APPLE__) && !defined(__ODROID__)
4098 #if defined(__WIN32__)
4099 if(glUnlockArraysEXT)
4101 if(!vboAvailable && display.display3D.mesh)
4102 glUnlockArraysEXT();
4107 OGLMesh oglMesh = mesh.data;
4109 // *** Vertex Stream ***
4110 glEnableClientState(GL_VERTEX_ARRAY);
4111 if(!display.display3D.collectingHits && oglMesh)
4113 oglMesh.vertices.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, oglMesh.vertices.buffer ? null : (double *)mesh.vertices);
4115 // *** Normals Stream ***
4116 if(mesh.normals || mesh.flags.normals)
4118 glEnableClientState(GL_NORMAL_ARRAY);
4119 oglMesh.normals.use(normal, 3, GL_FLOAT, 0, oglMesh.normals.buffer ? null : mesh.normals);
4122 glDisableClientState(GL_NORMAL_ARRAY);
4124 // *** Texture Coordinates Stream ***
4125 if(mesh.texCoords || mesh.flags.texCoords1)
4127 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4128 oglMesh.texCoords.use(texCoord, 2, GL_FLOAT, 0, oglMesh.texCoords.buffer ? null : mesh.texCoords);
4131 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4133 // *** Color Stream ***
4134 if(mesh.colors || mesh.flags.colors)
4136 glEnableClientState(GL_COLOR_ARRAY);
4137 oglMesh.colors.use(color, 4, GL_FLOAT, 0, oglMesh.colors.buffer ? null : mesh.colors);
4140 glDisableClientState(GL_COLOR_ARRAY);
4144 noAB.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, (double *)mesh.vertices);
4145 if((mesh.normals || mesh.flags.normals) && !display.display3D.collectingHits)
4147 glEnableClientState(GL_NORMAL_ARRAY);
4148 noAB.use(normal, 3, GL_FLOAT, 0, mesh.normals);
4151 glDisableClientState(GL_NORMAL_ARRAY);
4152 if((mesh.texCoords || mesh.flags.texCoords1) && !display.display3D.collectingHits)
4154 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4155 noAB.use(texCoord, 2, GL_FLOAT, 0, mesh.texCoords);
4158 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4159 if((mesh.colors || mesh.flags.colors) && !display.display3D.collectingHits)
4161 glEnableClientState(GL_COLOR_ARRAY);
4162 noAB.use(color, 4, GL_FLOAT, 0, mesh.colors);
4165 glDisableClientState(GL_COLOR_ARRAY);
4168 #if !defined(__ANDROID__) && !defined(__APPLE__) && !defined(__ODROID__)
4170 #if defined(__WIN32__)
4174 glLockArraysEXT(0, mesh.nVertices);
4180 void DrawPrimitives(Display display, PrimitiveSingle * primitive, Mesh mesh)
4182 //Logf("DrawPrimitives\n");
4184 if(primitive->type.vertexRange)
4185 glDrawArrays(primitiveTypes[primitive->type.primitiveType], primitive->first, primitive->nVertices);
4188 // *** Hoping the data won't be uploaded at all (Won't really work if another group of the mesh is using the mesh ) ***
4189 // HACK TO SPEED THINGS UP...
4191 /*GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
4192 if(primitive->nIndices < (mesh.nVertices >> 2) && !primitive->type.indices32bit)
4195 glBegin(primitiveTypes[primitive->type.primitiveType]);
4198 OGLIndices oglIndices = primitive->data;
4199 MeshFeatures flags = mesh.flags;
4200 for(c = 0; c<primitive->nIndices; c++)
4202 uint16 index = ((uint16 *) oglIndices.indices)[c];
4203 if(flags.normals) glNormal3fv((float *)&mesh.normals[index]);
4204 if(flags.texCoords1) glTexCoord2fv((float *)&mesh.texCoords[index]);
4205 if(flags.colors) glColor4fv((float *)&mesh.colors[index]);
4206 glVertex3fv((float *)&mesh.vertices[index]);
4214 OGLIndices oglIndices = primitive->data;
4216 if(!display.display3D.collectingHits && vboAvailable && oglIndices)
4218 if(primitive->type.indices32bit)
4219 ; //oglIndices.buffer.draw(primitiveTypes[primitive->type.primitiveType], primitive->nIndices, GL_UNSIGNED_SHORT, 0);
4221 oglIndices.buffer.draw(primitiveTypes[primitive->type.primitiveType], primitive->nIndices, GL_UNSIGNED_SHORT, 0);
4225 if(primitive->type.indices32bit)
4226 glDrawElementsi(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
4227 oglIndices ? oglIndices.indices : primitive->indices);
4229 glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
4230 GL_UNSIGNED_SHORT, oglIndices ? oglIndices.indices : primitive->indices);
4236 void PushMatrix(Display display)
4241 void PopMatrix(Display display, bool setMatrix)
4246 void SetTransform(Display display, Matrix transMatrix, bool viewSpace, bool useCamera)
4248 Matrix matrix = transMatrix;
4249 Camera camera = useCamera ? display.display3D.camera : null;
4254 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
4259 matrix.m[3][0] - camera.cPosition.x,
4260 matrix.m[3][1] - camera.cPosition.y,
4261 matrix.m[3][2] - camera.cPosition.z);
4273 glMultMatrixd(matrix.array);
4278 public void UseSingleGLContext(bool useSingle)
4280 useSingleGLContext = useSingle;
4283 default dllexport void *
4284 #if defined(__WIN32__)
4285 __attribute__((stdcall))
4287 IS_GLGetContext(DisplaySystem displaySystem)
4291 #if defined(__WIN32__)
4292 OGLSystem system = displaySystem.driverData;
4294 #elif defined(__ANDROID__) || defined(__ODROID__)
4297 OGLSystem system = displaySystem.driverData;
4298 return system.glContext;