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;
1381 static uint curElementBuffer;
1383 public define noEAB = GLEAB { 0 };
1389 void upload(uint size, void * data)
1394 GLGenBuffers(1, (GLAB *)this);
1396 if(curElementBuffer != buffer)
1397 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
1398 glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, data, GL_STATIC_DRAW); //GL_DYNAMIC_DRAW);
1406 GLDeleteBuffers(1, (GLAB *)this);
1411 void draw(int primType, int count, int type, void * indices)
1413 if(curElementBuffer != ((this != null) ? buffer : 0))
1414 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ((this != null) ? buffer : 0));
1415 glDrawElements(primType, count, type, indices);
1419 public void GLGenBuffers(int count, GLAB * buffers)
1421 #if defined(__ANDROID__) || defined(__ODROID__)
1422 glGenBuffers(count, (GLuint *)buffers);
1424 #if defined(__WIN32__)
1427 glGenBuffersARB(count, (GLuint *)buffers);
1431 public void GLDeleteBuffers(int count, GLAB * buffers)
1434 for(i = 0; i < count; i++)
1436 uint buffer = buffers[i].buffer;
1437 if(buffer == curArrayBuffer)
1438 GLBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
1439 else if(buffer == curElementBuffer)
1440 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
1442 #if defined(__ANDROID__) || defined(__ODROID__)
1443 glDeleteBuffers(count, (GLuint *)buffers);
1445 #if defined(__WIN32__)
1446 if(glDeleteBuffersARB)
1448 glDeleteBuffersARB(count, (GLuint *)buffers);
1452 void GLBindBuffer(int target, uint buffer)
1454 #if defined(__ANDROID__) || defined(__ODROID__)
1455 glBindBuffer(target, buffer);
1457 #if defined(__WIN32__)
1460 glBindBufferARB(target, buffer);
1462 if(target == GL_ARRAY_BUFFER_ARB)
1463 curArrayBuffer = buffer;
1464 else if(target == GL_ELEMENT_ARRAY_BUFFER_ARB)
1465 curElementBuffer = buffer;
1468 public void GLVertexPointer(int numCoords, int glType, int stride, void *ptr, int numVertices)
1471 if(glType == GL_DOUBLE)
1472 glesVertexPointerd(numCoords, stride, ptr, numVertices);
1473 else if(glType == GL_INT)
1474 glesVertexPointeri(numCoords, stride, ptr, numVertices);
1477 glVertexPointer(numCoords, glType, stride, ptr);
1480 public void GLBufferData(int type, GLenum target, int size, const GLvoid *data, GLenum usage)
1483 if(type == GL_DOUBLE)
1484 glesBufferDatad(target, size, (void *)data, usage);
1485 else if(type == GL_UNSIGNED_INT)
1486 glesBufferDatai(target, size, (void *)data, usage);
1490 #if defined(__ANDROID__) || defined(__ODROID__)
1491 glBufferData(target, size, data, usage);
1494 #if defined(__WIN32__)
1497 glBufferDataARB(target, size, data, usage);
1501 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1502 static int primitiveTypes[RenderPrimitiveType] =
1504 GL_POINTS, GL_LINES, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP, GL_LINE_STRIP
1509 // Non OpenGL ES friendly stuff
1513 //#undef GL_UNSIGNED_INT
1518 #undef GL_QUAD_STRIP
1519 #undef GL_POLYGON_STIPPLE
1520 #undef GL_LINE_STIPPLE
1523 #undef GL_ALL_ATTRIB_BITS
1524 #undef GL_LIGHT_MODEL_LOCAL_VIEWER
1528 static int displayWidth, displayHeight;
1530 #define GL_CLAMP_TO_EDGE 0x812F
1532 static bool vboAvailable;
1534 static bool useSingleGLContext = false;
1535 class OGLDisplay : struct
1537 #if defined(__WIN32__)
1547 int imageBuffers[2];
1548 byte * pboMemory1, * pboMemory2;
1550 #elif !defined(__ANDROID__) && !defined(__ODROID__)
1551 GLXContext glContext;
1554 XShmSegmentInfo shminfo;
1556 XShmSegmentInfo shminfoShape;
1557 XImage * shapeImage;
1561 X11Picture windowPicture;
1562 X11Picture pixmapPicture;
1564 X11Picture shapePicture;
1567 ColorAlpha * flippingBuffer;
1568 int flipBufH, flipBufW;
1573 class OGLSystem : struct
1578 #if defined(__WIN32__)
1579 PIXELFORMATDESCRIPTOR pfd;
1584 #elif !defined(__ANDROID__) && !defined(__ODROID__)
1585 XVisualInfo * visualInfo;
1586 GLXContext glContext;
1587 GLXDrawable glxDrawable;
1591 class OGLSurface : struct
1598 float foreground[4], background[4], bitmapMult[4];
1601 class OGLMesh : struct
1610 class OGLIndices : struct
1620 class OpenGLDisplayDriver : DisplayDriver
1622 class_property(name) = "OpenGL";
1624 bool LockSystem(DisplaySystem displaySystem)
1626 #if !defined(__ANDROID__) && !defined(__ODROID__)
1627 OGLSystem oglSystem = displaySystem.driverData;
1628 if(useSingleGLContext) return true;
1629 #if defined(__WIN32__)
1630 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1631 #elif defined(__unix__) || defined(__APPLE__)
1632 //if(previous) return true;
1633 // printf("Making SYSTEM current\n");
1634 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)oglSystem.glxDrawable, oglSystem.glContext);
1635 //previous = oglSystem.glContext;
1641 void UnlockSystem(DisplaySystem displaySystem)
1643 if(useSingleGLContext) return;
1644 #if defined(__WIN32__)
1645 wglMakeCurrent(null, null);
1646 #elif defined(__unix__) || defined(__APPLE__)
1647 // printf("Making NULL current\n");
1648 #if defined(__ANDROID__) || defined(__ODROID__)
1650 glXMakeCurrent(xGlobalDisplay, None, null);
1656 bool Lock(Display display)
1658 #if !defined(__ANDROID__) && !defined(__ODROID__)
1659 OGLDisplay oglDisplay = display.driverData;
1660 if(useSingleGLContext) return true;
1661 #if defined(__WIN32__)
1662 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1663 #elif defined(__unix__) || defined(__APPLE__)
1664 // if(previous) glXMakeCurrent(xGlobalDisplay, None, null);
1665 // printf(" Making DISPLAY current\n");
1666 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
1672 void Unlock(Display display)
1674 if(useSingleGLContext) return;
1675 //printf(" Making NULL current\n");
1676 //glXMakeCurrent(xGlobalDisplay, None, null);
1678 LockSystem(display.displaySystem);
1681 void DestroyDisplay(Display display)
1683 OGLDisplay oglDisplay = display.driverData;
1687 #if defined(__WIN32__)
1688 wglMakeCurrent( null, null );
1691 wglDeleteContext(oglDisplay.glrc);
1693 if(oglDisplay.hdc && oglDisplay.pBuffer)
1694 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
1696 if(oglDisplay.pBuffer)
1697 wglDestroyPbufferARB(oglDisplay.pBuffer);
1700 ReleaseDC(display.window, oglDisplay.hdc);
1702 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
1703 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
1705 #elif defined(__unix__) || defined(__APPLE__)
1706 #if defined(__ANDROID__) || defined(__ODROID__)
1708 if(oglDisplay.shapePixmap)
1709 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
1710 if(oglDisplay.pixmap)
1711 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1712 if(oglDisplay.image)
1714 if(oglDisplay.shminfoShape.shmid != -1)
1716 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
1717 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1718 shmdt(oglDisplay.shminfo.shmaddr);
1719 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
1722 if(oglDisplay.shapeImage)
1724 if(oglDisplay.shminfoShape.shmid != -1)
1726 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
1727 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1728 shmdt(oglDisplay.shminfoShape.shmaddr);
1729 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
1731 XDestroyImage(oglDisplay.shapeImage);
1732 oglDisplay.shapeImage = None;
1735 glXMakeCurrent(xGlobalDisplay, None, null);
1737 if(oglDisplay.glContext)
1738 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
1741 delete oglDisplay.flippingBuffer;
1743 display.driverData = null;
1747 void ::CheckExtensions(OGLSystem oglSystem)
1749 const char * extensions = (const char *)glGetString(GL_EXTENSIONS);
1751 oglSystem.pow2textures = strstr(extensions, "GL_ARB_texture_non_power_of_two") ? false : true;
1752 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &oglSystem.maxTextureSize);
1755 bool CreateDisplaySystem(DisplaySystem displaySystem)
1757 bool result = false;
1758 OGLSystem oglSystem = displaySystem.driverData = OGLSystem { };
1761 oglSystem.hwnd = CreateWindow("static", null, 0,0,0,0,0,null,null,null,null);
1763 oglSystem.hdc = GetDC(oglSystem.hwnd);
1767 oglSystem.pfd.nSize = (short)sizeof(oglSystem.pfd);
1768 oglSystem.pfd.nVersion = 1;
1769 oglSystem.pfd.dwFlags = PFD_DRAW_TO_WINDOW /*PFD_DRAW_TO_BITMAP*/ | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
1770 oglSystem.pfd.iPixelType = PFD_TYPE_RGBA;
1771 oglSystem.pfd.cColorBits = 24;
1772 oglSystem.pfd.cAlphaBits = 8;
1773 oglSystem.pfd.cDepthBits = 24;
1774 oglSystem.pfd.iLayerType = PFD_MAIN_PLANE;
1776 oglSystem.format = ChoosePixelFormat(oglSystem.hdc, &oglSystem.pfd);
1777 DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1779 if(oglSystem.pfd.cColorBits > 8)
1781 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1782 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1785 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1787 // Get Pointers To The GL Functions
1788 glActiveTextureARB = (void *) wglGetProcAddress("glActiveTextureARB");
1789 glMultiTexCoord2fARB = (void *) wglGetProcAddress("glMultiTexCoord2fARB");
1790 glClientActiveTextureARB = (void *) wglGetProcAddress("glClientActiveTextureARB");
1791 glLockArraysEXT = (void *) wglGetProcAddress("glLockArraysEXT" );
1792 glUnlockArraysEXT = (void *) wglGetProcAddress("glUnlockArraysEXT");
1793 glGenBuffersARB = (void *) wglGetProcAddress("glGenBuffersARB");
1794 glBindBufferARB = (void *) wglGetProcAddress("glBindBufferARB");
1795 glBufferDataARB = (void *) wglGetProcAddress("glBufferDataARB");
1796 glMapBufferARB = (void *) wglGetProcAddress("glMapBufferARB");
1797 glUnmapBufferARB = (void *) wglGetProcAddress("glUnmapBufferARB");
1798 glDeleteBuffersARB = (void *) wglGetProcAddress("glDeleteBuffersARB");
1799 glBlendFuncSeparate = (void *) wglGetProcAddress("glBlendFuncSeparate");
1801 wglChoosePixelFormatARB = (void *) wglGetProcAddress("wglChoosePixelFormatARB");
1802 wglGetExtensionsStringARB = (void *)wglGetProcAddress("wglGetExtensionsStringARB");
1803 wglCreatePbufferARB = (void *)wglGetProcAddress("wglCreatePbufferARB");
1804 wglGetPbufferDCARB = (void *)wglGetProcAddress("wglGetPbufferDCARB");
1805 wglQueryPbufferARB = (void *)wglGetProcAddress("wglQueryPbufferARB");
1806 wglDestroyPbufferARB = (void *)wglGetProcAddress("wglDestroyPbufferARB");
1807 wglReleasePbufferDCARB = (void *)wglGetProcAddress("wglReleasePbufferDCARB");
1808 wglBindTexImageARB = (void *)wglGetProcAddress("wglBindTexImageARB");
1809 wglReleaseTexImageARB = (void *)wglGetProcAddress("wglReleaseTexImageARB");
1811 wglSwapIntervalEXT = (void *)wglGetProcAddress("wglSwapIntervalEXT");
1813 vboAvailable = glBindBufferARB != null;
1815 // eSystem_LoggingMode(LOG_MSGBOX, null);
1817 if(wglChoosePixelFormatARB)
1822 float fAttributes[] = {0,0};
1825 WGL_DRAW_TO_WINDOW_ARB,GL_TRUE,
1826 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1827 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
1828 WGL_COLOR_BITS_ARB,24,
1829 WGL_ALPHA_BITS_ARB,8,
1830 WGL_DEPTH_BITS_ARB,16,
1831 WGL_STENCIL_BITS_ARB,0,
1832 WGL_DOUBLE_BUFFER_ARB,GL_TRUE,
1833 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
1834 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
1838 //Log("Found wglChoosePixelFormatARB\n");
1840 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1841 if(!valid || !numFormats)
1843 //Log("Can't find 4x multi sampling\n");
1844 iAttributes[19] = 2;
1845 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1846 if(!valid || !numFormats)
1848 // Log("Can't find 2x multi sampling\n");
1849 iAttributes[16] = 0;
1850 iAttributes[17] = 0;
1851 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1854 if(valid && numFormats)
1856 oglSystem.format = pixelFormat;
1857 wglMakeCurrent(null, null);
1858 wglDeleteContext(oglSystem.glrc);
1860 // *** DescribePixelFormat does not support WGL pixel formats! ***
1861 //DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1862 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1863 //Log("Successfully set pixel format\n");
1865 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1866 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1870 eSystem_Logf("Can't find wglChoosePixelFormatARB\n");*/
1874 CheckExtensions(oglSystem);
1876 wglMakeCurrent(null, null);
1878 //eSystem_DumpErrors(true);
1882 #elif defined(__unix__) || defined(__APPLE__)
1883 vboAvailable = true;
1884 #if defined(__ANDROID__)
1885 egl_init_display(guiApp.desktop.windowHandle);
1886 #elif defined(__ODROID__)
1887 egl_init_display((uint)displaySystem.window);
1888 CheckExtensions(oglSystem);
1892 X11Window root = RootWindow( xGlobalDisplay, DefaultScreen( xGlobalDisplay ) );
1893 XSetWindowAttributes attr;
1898 #ifndef ECERE_MINIGLX
1899 GLX_USE_GL, GLX_DEPTH_SIZE, 1,
1902 GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,
1906 oglSystem.visualInfo = glXChooseVisual( xGlobalDisplay, DefaultScreen( xGlobalDisplay ), attrList );
1907 attr.background_pixel = 0;
1908 attr.border_pixel = 0;
1909 attr.colormap = XCreateColormap( xGlobalDisplay, root, oglSystem.visualInfo->visual, AllocNone);
1910 attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
1911 mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
1913 oglSystem.glxDrawable = XCreateWindow( xGlobalDisplay, root, 0, 0, 1, 1, 0, oglSystem.visualInfo->depth, InputOutput,
1914 oglSystem.visualInfo->visual, mask, &attr );
1916 if(oglSystem.visualInfo)
1918 oglSystem.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, null, True);
1919 if(oglSystem.glContext)
1921 glXMakeCurrent(xGlobalDisplay, oglSystem.glxDrawable, oglSystem.glContext);
1923 CheckExtensions(oglSystem);
1924 glXMakeCurrent(xGlobalDisplay, None, null);
1931 displaySystem.flags.alpha = true;
1932 displaySystem.flags.flipping = true;
1933 displaySystem.pixelFormat = pixelFormat888;
1937 void DestroyDisplaySystem(DisplaySystem displaySystem)
1939 OGLSystem oglSystem = displaySystem.driverData;
1941 #if defined(__WIN32__)
1942 wglMakeCurrent( null, null );
1945 wglDeleteContext(oglSystem.glrc);
1948 ReleaseDC(oglSystem.hwnd, oglSystem.hdc);
1949 DestroyWindow(oglSystem.hwnd);
1951 #elif defined(__unix__) || defined(__APPLE__)
1952 #if defined(__ANDROID__) || defined(__ODROID__)
1955 if(oglSystem.visualInfo)
1957 #ifdef ECERE_MINIGLX
1958 __miniglx_XFree(oglSystem.visualInfo);
1960 XFree(oglSystem.visualInfo);
1964 if(oglSystem.glxDrawable)
1966 XDestroyWindow(xGlobalDisplay, oglSystem.glxDrawable);
1967 oglSystem.glxDrawable = 0;
1974 bool CreateDisplay(Display display)
1976 bool result = false;
1977 OGLDisplay oglDisplay = display.driverData;
1978 #if !defined(__ANDROID__) && !defined(__ODROID__)
1979 OGLSystem oglSystem = display.displaySystem.driverData;
1982 oglDisplay = display.driverData = OGLDisplay { };
1983 //printf("Inside CreateDisplay\n");
1985 #if defined(__WIN32__) || defined(USEPBUFFER)
1986 if(!display.alphaBlend)
1989 #if defined(__WIN32__)
1990 oglDisplay.hdc = GetDC(display.window);
1991 SetPixelFormat(oglDisplay.hdc, oglSystem.format, &oglSystem.pfd);
1992 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
1994 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
1995 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1999 ReleaseDC(display.window, oglDisplay.hdc);
2000 #elif defined(__unix__) || defined(__APPLE__)
2001 #if defined(__ANDROID__) || defined(__ODROID__)
2003 XVisualInfo * visualInfo = ((XWindowData)display.windowDriverData).visual;
2005 #if defined(__APPLE__)
2006 XVisualInfo template = { 0 };
2007 XWindowAttributes winAttr;
2009 XGetWindowAttributes(xGlobalDisplay, (X11Window)display.window, &winAttr);
2010 template.visualid = XVisualIDFromVisual(winAttr.visual);
2011 visualInfo = XGetVisualInfo(xGlobalDisplay, VisualIDMask, &template, &n);
2013 printf("XGetVisualInfo visual ID = %d\n", template.visualid);
2014 printf("visualInfo visual ID = %d\n", visualInfo->visualid);
2015 printf("oglSystem.visualInfo visual ID = %d\n", oglSystem.visualInfo->visualid);
2016 printf("((XWindowData)display.windowDriverData).visual visual ID = %d\n", ((XWindowData)display.windowDriverData).visual->visualid);
2018 // visualInfo = oglSystem.visualInfo;
2023 //printf("visualInfo is not null\n");
2024 // printf("Creating Display Context, sharing with %x!\n", oglSystem.glContext);
2025 oglDisplay.glContext = glXCreateContext(xGlobalDisplay, visualInfo, oglSystem.glContext, True);
2026 //XFree(visualInfo);
2029 // oglDisplay.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, oglSystem.glContext, True);
2030 if(oglDisplay.glContext)
2032 //printf("CreateDisplay Got a Context\n");
2033 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2039 #if defined(__WIN32__) || defined(USEPBUFFER)
2045 #if defined(__WIN32__)
2046 if(glBlendFuncSeparate)
2047 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2049 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2051 #if !defined(__OLDX__)
2052 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2054 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2059 glMatrixMode(GL_MODELVIEW);
2060 glScaled(1.0, 1.0, -1.0);
2061 // glTranslatef(0.375f, 0.375f, 0.0f);
2062 // glTranslatef(-0.625f, -0.625f, 0.0f);
2063 glMatrixMode(GL_PROJECTION);
2064 glShadeModel(GL_FLAT);
2066 // glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, true);
2067 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
2068 glFogi(GL_FOG_MODE, GL_EXP);
2069 glFogf(GL_FOG_DENSITY, 0);
2070 glEnable(GL_NORMALIZE);
2071 glDepthFunc(GL_LESS);
2073 glDisable(GL_MULTISAMPLE_ARB);
2075 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
2076 display.ambient = Color { 50,50,50 };
2079 if(!useSingleGLContext)
2081 #if defined(__WIN32__)
2082 wglMakeCurrent(null, null);
2083 #elif defined(__unix__) || defined(__APPLE__)
2084 #if defined(__ANDROID__) || defined(__ODROID__)
2087 glXMakeCurrent(xGlobalDisplay, None, null);
2093 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2101 bool DisplaySize(Display display, int width, int height)
2103 OGLDisplay oglDisplay = display.driverData;
2105 bool result = false;
2107 //printf("Inside DisplaySize\n");
2108 #if defined(__WIN32__) || defined(USEPBUFFER)
2109 OGLSystem oglSystem = display.displaySystem.driverData;
2110 if(display.alphaBlend)
2112 #if defined(__WIN32__)
2113 const int attributes[]=
2115 /*WGL_TEXTURE_FORMAT_ARB, WGL_TEXTURE_RGBA_ARB,
2116 WGL_TEXTURE_TARGET_ARB, WGL_TEXTURE_2D_ARB, */0
2118 int pixelFormat = 0;
2119 if(wglChoosePixelFormatARB)
2123 float fAttributes[] = {0,0};
2126 //WGL_DRAW_TO_BITMAP_ARB, GL_TRUE,
2127 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2128 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2129 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
2130 WGL_COLOR_BITS_ARB,24,
2131 WGL_ALPHA_BITS_ARB,8,
2132 WGL_DEPTH_BITS_ARB,16,
2133 WGL_STENCIL_BITS_ARB,0,
2134 WGL_DOUBLE_BUFFER_ARB,GL_FALSE,
2135 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
2136 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
2140 //Log("Found wglChoosePixelFormatARB\n");
2142 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2143 if(!valid || !numFormats)
2145 //Log("Can't find 4x multi sampling\n");
2146 iAttributes[19] = 2;
2147 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2148 if(!valid || !numFormats)
2150 // Log("Can't find 2x multi sampling\n");
2151 iAttributes[16] = 0;
2152 iAttributes[17] = 0;
2153 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2154 if(!valid || !numFormats)
2158 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2159 //WGL_DRAW_TO_BITMAP_ARB,GL_TRUE,
2160 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2161 WGL_COLOR_BITS_ARB,24,
2162 WGL_ALPHA_BITS_ARB,8,
2163 WGL_DEPTH_BITS_ARB,16,
2166 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2170 if(valid && numFormats)
2172 wglMakeCurrent(null, null);
2176 wglMakeCurrent( null, null );
2177 wglMakeCurrent( oglDisplay.hdc, oglDisplay.glrc );
2178 if(oglDisplay.hdc && oglDisplay.pBuffer)
2179 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
2181 wglDestroyPbufferARB(oglDisplay.pBuffer);
2183 if(!useSingleGLContext)
2184 wglMakeCurrent( null, null );
2187 wglDeleteContext(oglDisplay.glrc);
2189 oglDisplay.pBuffer = wglCreatePbufferARB(oglSystem.hdc, pixelFormat, width, height, attributes);
2190 oglDisplay.hdc = wglGetPbufferDCARB(oglDisplay.pBuffer);
2191 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
2194 HDC hdc = GetDC(display.window);
2196 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2197 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2199 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_WIDTH_ARB, &width);
2200 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_HEIGHT_ARB, &height);
2202 // glDeleteBuffersARB(2, oglDisplay.imageBuffers);
2204 if((info = (BITMAPINFO *)new0 byte[sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*256]))
2208 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
2209 oglDisplay.memDC = CreateCompatibleDC(hdc);
2210 SetMapMode(oglDisplay.memDC, MM_TEXT);
2211 info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2212 info->bmiHeader.biPlanes = 1;
2213 info->bmiHeader.biCompression = BI_RGB;
2214 info->bmiHeader.biBitCount = 32; //(uint16)GetDeviceCaps(hdc, BITSPIXEL);
2215 info->bmiHeader.biWidth = width;
2216 info->bmiHeader.biHeight = height;
2217 newBitmap = CreateDIBSection(hdc, info, DIB_RGB_COLORS, &oglDisplay.picture, null, 0);
2220 SelectObject(oglDisplay.memDC, newBitmap);
2221 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
2224 PIXELFORMATDESCRIPTOR pfd = { 0 };
2225 pfd.nSize = (short)sizeof(pfd);
2227 pfd.dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL;
2228 pfd.iPixelType = PFD_TYPE_RGBA;
2229 pfd.cColorBits = 32;
2230 //pfd.cAlphaBits = 8;
2231 pfd.cDepthBits = 24;
2232 pfd.iLayerType = PFD_MAIN_PLANE;
2234 oglDisplay.hdc = oglDisplay.memDC;
2236 pixelFormat = ChoosePixelFormat(oglSystem.hdc, &pfd);
2237 DescribePixelFormat(oglDisplay.hdc, pixelFormat, sizeof(pfd), &pfd);
2238 SetPixelFormat(oglDisplay.hdc, pixelFormat, &pfd);
2240 oglDisplay.glrc = wglCreateContext(oglDisplay.hdc);
2241 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2242 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2247 const int imageSize = width * height * 4;
2249 glGenBuffersARB(2, oglDisplay.imageBuffers);
2251 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2252 glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize, null, GL_STREAM_READ);
2253 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2254 // glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize / 2, null, GL_STREAM_READ);
2257 oglDisplay.memBitmap = newBitmap;
2258 oglDisplay.stride = width;
2264 ReleaseDC(display.window, hdc);
2266 #elif defined(__unix__) || defined(__APPLE__)
2267 #if defined(__ANDROID__) || defined(__ODROID__)
2272 GLX_DOUBLEBUFFER, True,
2278 GLX_STENCIL_SIZE, 1,
2279 //GLX_DEPTH_SIZE, 24,
2280 GLX_RENDER_TYPE, GLX_RGBA_BIT,
2281 GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT | GLX_WINDOW_BIT,
2287 GLX_PBUFFER_WIDTH, width,
2288 GLX_PBUFFER_HEIGHT, height,
2289 GLX_LARGEST_PBUFFER, False,
2293 // choose a pixel format that meets our minimum requirements
2296 GLXFBConfig *config = glXChooseFBConfig(xGlobalDisplay, DefaultScreen(xGlobalDisplay), attrib, &count);
2299 if(oglDisplay.pixmap)
2301 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2302 oglDisplay.pixmap = None;
2304 if(oglDisplay.shapePixmap)
2306 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
2307 oglDisplay.shapePixmap = None;
2310 // Free Shared Memory Pixmap
2311 if(oglDisplay.image)
2313 if(oglDisplay.shminfoShape.shmid != -1)
2315 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
2316 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2317 shmdt(oglDisplay.shminfo.shmaddr);
2318 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
2320 XDestroyImage(oglDisplay.image);
2321 oglDisplay.image = None;
2323 if(oglDisplay.shapeImage)
2325 if(oglDisplay.shminfoShape.shmid != -1)
2327 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
2328 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2329 shmdt(oglDisplay.shminfoShape.shmaddr);
2330 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
2332 XDestroyImage(oglDisplay.shapeImage);
2333 oglDisplay.shapeImage = None;
2336 if(oglDisplay.windowPicture)
2337 XRenderFreePicture(xGlobalDisplay, oglDisplay.windowPicture);
2338 if(oglDisplay.pixmapPicture)
2339 XRenderFreePicture(xGlobalDisplay, oglDisplay.pixmapPicture);
2341 if(oglDisplay.pixmap)
2342 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2344 if(oglDisplay.glContext)
2345 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
2346 if(oglDisplay.pBuffer)
2347 glXDestroyPbuffer(xGlobalDisplay, oglDisplay.pBuffer);
2349 oglDisplay.pBuffer = glXCreatePbuffer(xGlobalDisplay, config[0], PBattrib);
2350 if(oglDisplay.pBuffer)
2352 oglDisplay.glContext = glXCreateNewContext(xGlobalDisplay, config[0], GLX_RGBA_TYPE, oglSystem.glContext, True);
2353 if(oglDisplay.glContext)
2355 glXMakeCurrent(xGlobalDisplay, None, null);
2356 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2358 // Initialize Shared Memory Pixmap
2359 oglDisplay.image = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 32,
2360 ZPixmap, null, &oglDisplay.shminfo, width, height);
2361 if(oglDisplay.image)
2363 oglDisplay.shminfo.shmid = shmget(IPC_PRIVATE,
2364 oglDisplay.image->bytes_per_line * oglDisplay.image->height, IPC_CREAT|0777);
2365 if(oglDisplay.shminfo.shmid != -1)
2367 oglDisplay.shminfo.shmaddr = shmat(oglDisplay.shminfo.shmid, 0, 0);
2368 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2370 oglDisplay.shminfo.readOnly = False;
2371 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfo))
2373 oglDisplay.pixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfo.shmaddr,
2374 &oglDisplay.shminfo, width, height, 32);
2376 // Initialize Shared Memory Shape Pixmap
2377 oglDisplay.shapeImage = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 1,
2378 ZPixmap, null, &oglDisplay.shminfoShape, width, height);
2379 if(oglDisplay.shapeImage)
2381 oglDisplay.shminfoShape.shmid = shmget(IPC_PRIVATE,
2382 oglDisplay.shapeImage->bytes_per_line * oglDisplay.shapeImage->height, IPC_CREAT|0777);
2383 if(oglDisplay.shminfoShape.shmid != -1)
2385 oglDisplay.shminfoShape.shmaddr = shmat(oglDisplay.shminfoShape.shmid, 0, 0);
2386 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2388 oglDisplay.shminfoShape.readOnly = False;
2389 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfoShape))
2391 oglDisplay.shapePixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfoShape.shmaddr,
2392 &oglDisplay.shminfoShape, width, height, 1);
2393 //oglDisplay.shapePixmap = XCreatePixmap(xGlobalDisplay, (X11Window)display.window, width, height, 1);
2396 XRenderPictureAttributes attributes = { 0 };
2397 XRenderPictFormat * format = XRenderFindStandardFormat(xGlobalDisplay, /*PictStandardRGB24*/ PictStandardARGB32);
2398 #if !defined(__APPLE__) && !defined(__OLDX__)
2399 attributes.repeat = RepeatNormal;
2401 attributes.repeat = 1;
2403 oglDisplay.pixmapPicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.pixmap, format, CPRepeat, &attributes);
2404 oglDisplay.windowPicture = XRenderCreatePicture(xGlobalDisplay, (X11Window)display.window, format, 0, &attributes);
2405 oglDisplay.shapePicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.shapePixmap,
2406 XRenderFindStandardFormat(xGlobalDisplay, PictStandardA1), 0, &attributes);
2409 oglDisplay.picture = oglDisplay.shminfo.shmaddr;
2410 oglDisplay.stride = oglDisplay.image->bytes_per_line / 4;
2427 CreateDisplay(display);
2428 #if defined(__WIN32__)
2429 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2430 #elif defined(__unix__) || defined(__APPLE__)
2431 #if defined(__ANDROID__) || defined(__ODROID__)
2435 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2442 if(!result && display.alphaBlend)
2444 printf("Alpha blending windows not supported on this display\n");
2451 glViewport(0,0,width,height);
2453 glOrtho(0,width,height,0,0.0,1.0);
2454 displayWidth = display.width = width;
2455 displayHeight = display.height = height;
2457 if(!oglDisplay.flippingBuffer || oglDisplay.flipBufW < width || oglDisplay.flipBufH < height)
2459 oglDisplay.flipBufW = width;
2460 oglDisplay.flipBufH = height;
2464 oglDisplay.flippingBuffer = renew oglDisplay.flippingBuffer ColorAlpha [width * height];
2467 if(oglDisplay.flippingBuffer || !width || !height)
2473 void DisplayPosition(Display display, int x, int y)
2475 OGLDisplay oglDisplay = display.driverData;
2481 void SetPalette(Display display, ColorAlpha * palette, bool colorMatch)
2485 void RestorePalette(Display display)
2489 void StartUpdate(Display display)
2493 void EndUpdate(Display display)
2497 void Scroll(Display display, Box scroll, int x, int y, Extent dirty)
2501 void Update(Display display, Box updateBox)
2503 #if defined(__WIN32__) || defined(USEPBUFFER)
2504 OGLDisplay oglDisplay = display.driverData;
2506 //Logf("DisplayScreen\n");
2510 #if defined(__WIN32__) || defined(USEPBUFFER)
2511 if(display.alphaBlend)
2513 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2514 glPixelStorei(GL_PACK_ROW_LENGTH, oglDisplay.stride);
2515 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2516 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2517 glReadPixels(0,0,display.width,display.height,GL_BGRA_EXT,GL_UNSIGNED_BYTE, oglDisplay.picture);
2520 #if defined(__WIN32__)
2522 POINT point = { oglDisplay.x, oglDisplay.y};
2523 POINT srcPoint = { 0, 0 };
2524 BLENDFUNCTION blend = { 0 };
2526 size.cx = display.width;
2527 size.cy = display.height;
2528 blend.BlendOp = AC_SRC_OVER;
2529 blend.BlendFlags = 0;
2530 blend.SourceConstantAlpha = 255;
2531 blend.AlphaFormat = AC_SRC_ALPHA;
2534 // Process partial images. Mapping the buffer waits for
2535 // outstanding DMA transfers into the buffer to finish.
2536 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2537 oglDisplay.pboMemory1 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY);
2539 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2540 // oglDisplay.pboMemory2 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB,GL_READ_ONLY);
2543 memcpy(oglDisplay.picture, oglDisplay.pboMemory1, display.width * display.height * 4);
2544 //memcpy(oglDisplay.picture + display.width * display.height * 4 / 2, oglDisplay.pboMemory2, display.width * display.height * 4/ 2);
2547 UpdateLayeredWindow(display.window, hdc, &point, &size, oglDisplay.memDC, &srcPoint, 0, &blend, ULW_ALPHA);
2550 // Unmap the image buffers
2551 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2552 glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2554 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2555 // glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2557 // Bind two different buffer objects and start the glReadPixels
2558 // asynchronously. Each call will return directly after
2559 // starting the DMA transfer.
2560 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2561 glReadPixels(0, 0, display.width, display.height, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2563 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2564 // glReadPixels(0, display.height/2, display.width, display.height/2, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2568 #elif defined(__unix__) || defined(__APPLE__)
2569 #if defined(__ANDROID__) || defined(__ODROID__)
2571 XTransform transform =
2574 { (int)(1.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(0 * (1 << 16)) },
2575 { (int)(0.0f), (int)(-1.0f * (1<<16)), (int)(0 * (1<<16)) },
2576 { (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)) }
2579 XRenderSetPictureTransform(xGlobalDisplay, oglDisplay.pixmapPicture, &transform);
2580 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.shapePicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2581 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.windowPicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2582 #if !defined(__APPLE__) && !defined(__OLDX__)
2583 XShapeCombineMask(xGlobalDisplay, (X11Window)display.window, ShapeInput, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2585 XShapeCombineMask(xGlobalDisplay, display.window, 2, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2587 XFlush(xGlobalDisplay);
2595 #if defined(__WIN32__)
2596 //wglSwapLayerBuffers(oglDisplay.hdc,WGL_SWAP_MAIN_PLANE);
2597 SwapBuffers(oglDisplay.hdc);
2598 #elif defined(__unix__) || defined(__APPLE__)
2599 #if defined(__ANDROID__) || defined(__ODROID__)
2600 eglSwapBuffers(eglDisplay, eglSurface);
2602 glXSwapBuffers(xGlobalDisplay, (GLXDrawable)display.window);
2606 //Logf("Out of DisplayScreen\n");
2609 void FreeBitmap(DisplaySystem displaySystem, Bitmap bitmap)
2611 if(bitmap.driverData)
2613 GLuint tex = (GLuint)(uintptr)bitmap.driverData;
2614 glDeleteTextures(1, &tex);
2615 bitmap.driverData = 0;
2617 bitmap.driver = ((subclass(DisplayDriver))class(LFBDisplayDriver));
2620 bool AllocateBitmap(DisplaySystem displaySystem, Bitmap bitmap, int width, int height, int stride, PixelFormat format, bool allocatePalette)
2622 OGLSystem oglSystem = displaySystem.driverData;
2623 bool result = false;
2625 GLuint glBitmap = 0;
2627 uint w = width, h = height;
2628 if(oglSystem.pow2textures)
2633 w = Min(w, oglSystem.maxTextureSize);
2634 h = Min(h, oglSystem.maxTextureSize);
2636 glGenTextures(1, &glBitmap);
2637 glBindTexture(GL_TEXTURE_2D, glBitmap);
2639 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2641 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2642 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2644 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2645 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2647 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2649 mipMap.Allocate(null, w, h, w, pixelFormatRGBA, false);
2651 // glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2652 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2656 bitmap.driverData = (void *)(uintptr)glBitmap;
2657 bitmap.driver = displaySystem.driver;
2665 bool MakeDDBitmap(DisplaySystem displaySystem, Bitmap bitmap, bool mipMaps)
2667 bool result = false;
2668 OGLSystem oglSystem = displaySystem.driverData;
2670 // Pre process the bitmap... First make it 32 bit
2671 if(/*bitmap.pixelFormat == pixelFormatRGBA || */bitmap.Convert(null, pixelFormat888, null))
2674 uint w = bitmap.width, h = bitmap.height;
2675 GLuint glBitmap = 0;
2676 if(oglSystem.pow2textures)
2681 w = Min(w, oglSystem.maxTextureSize);
2682 h = Min(h, oglSystem.maxTextureSize);
2686 while(w * 2 < h) w *= 2;
2687 while(h * 2 < w) h *= 2;
2690 // Switch ARGB to RGBA
2691 //if(bitmap.format != pixelFormatRGBA)
2693 for(c=0; c<bitmap.size; c++)
2695 // ((ColorRGBA *)bitmap.picture)[c] = ((ColorAlpha *)bitmap.picture)[c];
2697 ColorAlpha color = ((ColorAlpha *)bitmap.picture)[c];
2698 ((ColorRGBA *)bitmap.picture)[c] = ColorRGBA { color.color.r, color.color.g, color.color.b, color.a };
2701 bitmap.pixelFormat = pixelFormat888;
2704 glGenTextures(1, &glBitmap);
2707 //int error = glGetError();
2711 glBindTexture(GL_TEXTURE_2D, glBitmap);
2712 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2714 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, mipMaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
2715 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2717 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2719 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
2720 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
2722 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2723 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2725 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2729 for(level = 0; result && (w >= 1 || h >= 1); level++, w >>= 1, h >>= 1)
2734 if(bitmap.width != w || bitmap.height != h)
2736 mipMap = Bitmap { };
2737 if(mipMap.Allocate(null, w, h, w, bitmap.pixelFormat, false))
2739 Surface mipSurface = mipMap.GetSurface(0,0,null);
2740 mipSurface.Filter(bitmap, 0,0,0,0, w, h, bitmap.width, bitmap.height);
2757 // glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2758 glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2759 //printf("Calling glTexImage2D\n");
2760 //glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &width);
2761 //printf("width = %d (Should be %d, %d)\n", width, w, h);
2762 if((error = glGetError()))
2764 //Logf("OpenGL Bitmap MakeDD error: %d...\n", error);
2765 //printf("OpenGL Bitmap MakeDD error: %d...\n", error);
2769 if(mipMap != bitmap)
2774 if(!bitmap.keepData)
2775 bitmap.driver.FreeBitmap(bitmap.displaySystem, bitmap);
2776 bitmap.driverData = (void *)(uintptr)glBitmap;
2777 bitmap.driver = displaySystem.driver;
2780 FreeBitmap(displaySystem, bitmap);
2781 else if(oglSystem.loadingFont)
2783 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2784 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2785 oglSystem.loadingFont = false;
2791 void ReleaseSurface(Display display, Surface surface)
2793 glDisable(GL_SCISSOR_TEST);
2794 delete surface.driverData;
2795 surface.driverData = null;
2798 bool GetBitmapSurface(DisplaySystem displaySystem, Surface surface, Bitmap bitmap, int x, int y, Box clip)
2803 bool GetSurface(Display display, Surface surface, int x,int y, Box clip)
2805 bool result = false;
2806 OGLSurface oglSurface = surface.driverData = OGLSurface { };
2808 //Logf("GetSurface\n");
2812 if(displayWidth != display.width || displayHeight != display.height)
2814 displayWidth = display.width;
2815 displayHeight = display.height;
2817 glViewport(0,0,display.width,display.height);
2819 glOrtho(0,display.width,display.height,0,0.0,1.0);
2822 surface.offset.x = x;
2823 surface.offset.y = y;
2824 surface.unclippedBox = surface.box = clip;
2825 oglSurface.bitmapMult[0] = 1;
2826 oglSurface.bitmapMult[1] = 1;
2827 oglSurface.bitmapMult[2] = 1;
2828 oglSurface.bitmapMult[3] = 1;
2830 glEnable(GL_SCISSOR_TEST);
2833 (display.height) -(y+clip.bottom)-1,
2834 clip.right-clip.left+1,
2835 clip.bottom-clip.top+1);
2841 void Clip(Display display, Surface surface, Box clip)
2850 box.Clip(surface.unclippedBox);
2854 box = surface.box = surface.unclippedBox;
2855 box.left += surface.offset.x;
2856 box.top += surface.offset.y;
2857 box.right+= surface.offset.x;
2858 box.bottom += surface.offset.y;
2861 box.left,display.height - box.bottom - 1,
2862 box.right-box.left+1, box.bottom-box.top+1);
2865 bool GrabScreen(Display display, Bitmap bitmap, int x, int y, unsigned int w, unsigned int h)
2867 bool result = false;
2868 OGLDisplay oglDisplay = display.driverData;
2869 ColorAlpha * flippingBuffer = oglDisplay.flippingBuffer;
2871 if(oglDisplay.flippingBuffer)
2873 if(bitmap.pixelFormat != pixelFormat888 || bitmap.width < w || bitmap.height < h)
2876 bitmap.Allocate(null, w,h,w, pixelFormat888, false);
2882 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2883 glPixelStorei(GL_PACK_ROW_LENGTH, bitmap.stride);
2884 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2885 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2886 glReadPixels(x,display.height-h-y,w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, flippingBuffer);
2889 for(row = 0; row<h; row++)
2890 CopyBytesBy4(((ColorAlpha *)bitmap.picture) + row * w, ((ColorAlpha *)flippingBuffer) + (h-row-1) * w, w);
2897 void SetForeground(Display display, Surface surface, ColorAlpha color)
2899 OGLSurface oglSurface = surface.driverData;
2901 //Logf("SetForeground\n");
2903 oglSurface.foreground[0] = color.color.r/255.0f;
2904 oglSurface.foreground[1] = color.color.g/255.0f;
2905 oglSurface.foreground[2] = color.color.b/255.0f;
2906 //oglSurface.foreground[3] = 1.0f;
2907 oglSurface.foreground[3] = color.a/255.0f;
2909 //if(!oglSurface.foreground[3])printf("bug");
2912 void SetBackground(Display display, Surface surface, ColorAlpha color)
2914 OGLSurface oglSurface = surface.driverData;
2916 //Logf("SetBackground\n");
2918 oglSurface.background[0] = color.color.r/255.0f;
2919 oglSurface.background[1] = color.color.g/255.0f;
2920 oglSurface.background[2] = color.color.b/255.0f;
2921 //oglSurface.background[3] = 1.0;
2922 oglSurface.background[3] = color.a/255.0f;
2925 void SetBlitTint(Display display, Surface surface, ColorAlpha color)
2927 OGLSurface oglSurface = surface.driverData;
2929 oglSurface.bitmapMult[0] = color.color.r/255.0f;
2930 oglSurface.bitmapMult[1] = color.color.g/255.0f;
2931 oglSurface.bitmapMult[2] = color.color.b/255.0f;
2932 oglSurface.bitmapMult[3] = color.a/255.0f;
2935 ColorAlpha GetPixel(Display display, Surface surface,int x,int y)
2940 void PutPixel(Display display, Surface surface,int x,int y)
2942 OGLSurface oglSurface = surface.driverData;
2944 //Logf("PutPixel\n");
2946 glColor4fv(oglSurface.foreground);
2948 // glVertex2i(x+surface.offset.x, y+surface.offset.y);
2949 glVertex2f(x+surface.offset.x + 0.5f, y+surface.offset.y + 0.5f);
2954 void DrawLine(Display display, Surface surface, int _x1, int _y1, int _x2, int _y2)
2956 OGLSurface oglSurface = surface.driverData;
2957 float x1 = _x1, x2 = _x2, y1 = _y1, y2 = _y2;
2972 x1 += surface.offset.x;
2973 y1 += surface.offset.y;
2974 x2 += surface.offset.x;
2975 y2 += surface.offset.y;
2979 glColor4fv(oglSurface.foreground);
2984 glTexCoord2f(0.5f, 0);
2985 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2986 glTexCoord2f(Max(x2-x1, y2-y1) + 0.5f, 0);
2987 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2996 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2997 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3003 void Rectangle(Display display, Surface surface,int x1,int y1,int x2,int y2)
3005 OGLSurface oglSurface = surface.driverData;
3006 x1 += surface.offset.x;
3007 y1 += surface.offset.y;
3008 x2 += surface.offset.x;
3009 y2 += surface.offset.y;
3011 //Logf("Rectangle\n");
3013 glColor4fv(oglSurface.foreground);
3019 glTexCoord2f(0.5f, 0);
3020 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3021 glTexCoord2f(y2-y1 + 0.5f, 0);
3022 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3024 glTexCoord2f(0.5f, 0);
3025 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3026 glTexCoord2f(x2 - x1 + 0.5f, 0);
3027 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3029 glTexCoord2f(0.5f, 0);
3030 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3031 glTexCoord2f(y1 - y2 + 0.5f, 0);
3032 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3034 glTexCoord2f(0.5f, 0);
3035 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3036 glTexCoord2f(x1 - x2 + 0.5f, 0);
3037 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3042 glBegin(GL_LINE_LOOP);
3049 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3050 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3051 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3052 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3057 void Area(Display display, Surface surface,int x1,int y1,int x2,int y2)
3059 OGLSurface oglSurface = surface.driverData;
3062 glColor4fv(oglSurface.background);
3063 glRecti(x1+surface.offset.x, y1+surface.offset.y,
3064 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
3067 glRectf(x1+surface.offset.x, y1+surface.offset.y,
3068 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
3072 void Clear(Display display, Surface surface, ClearType type)
3074 OGLDisplay oglDisplay = display.driverData;
3075 OGLSurface oglSurface = surface.driverData;
3078 if(type != depthBuffer)
3079 glClearColor(oglSurface.background[0], oglSurface.background[1], oglSurface.background[2], oglSurface.background[3]);
3080 if(type != colorBuffer && !oglDisplay.depthWrite)
3082 glDepthMask((byte)bool::true);
3084 glClear(((type != depthBuffer) ? GL_COLOR_BUFFER_BIT : 0) |
3085 ((type != colorBuffer) ? GL_DEPTH_BUFFER_BIT : 0));
3086 if(type != colorBuffer && !oglDisplay.depthWrite)
3088 glDepthMask((byte)bool::false);
3092 bool ConvertBitmap(DisplaySystem displaySystem, Bitmap bitmap, PixelFormat format, ColorAlpha * palette)
3097 void Blit(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3099 OGLSurface oglSurface = surface.driverData;
3101 #if !defined(__OLDX__)
3102 // WHY DO WE HAVE GL_ONE HERE ?
3103 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3104 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3107 if(!oglSurface.writingText)
3109 // glTranslatef(-0.375f, -0.375f, 0.0f);
3110 glEnable(GL_TEXTURE_2D);
3111 glColor4fv(oglSurface.bitmapMult);
3113 else if(oglSurface.xOffset)
3114 glTranslated(oglSurface.xOffset / 64.0/*-0.375*/, 0.0, 0.0);
3116 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3121 glTexCoord2f((float)sx/ bitmap.width, (float)(sy-h)/ bitmap.height);
3122 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3123 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy-h)/ bitmap.height);
3124 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3125 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3126 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
3127 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3128 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3133 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3134 glVertex2i(dx+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+surface.offset.y);
3137 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3138 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3139 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3140 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3143 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3144 glVertex2f((float)dx+surface.offset.x, (float)dy+surface.offset.y);
3145 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3146 glVertex2f((float)dx+w+surface.offset.x, (float)dy+surface.offset.y);
3147 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3148 glVertex2f((float)dx+w+surface.offset.x, (float)dy+h+surface.offset.y);
3149 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3150 glVertex2f((float)dx+surface.offset.x, (float)dy+h+surface.offset.y);
3154 if(!oglSurface.writingText)
3156 glDisable(GL_TEXTURE_2D);
3158 //glTranslate(0.375, 0.375, 0.0);
3160 else if(oglSurface.xOffset)
3161 glTranslated(-oglSurface.xOffset / 64.0/*+0.375*/, 0.0, 0.0);
3163 #if !defined(__OLDX__)
3164 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3165 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3169 void Stretch(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3171 OGLSurface oglSurface = surface.driverData;
3173 //glTranslate(-0.375, -0.375, 0.0);
3175 //Logf("Stretch\n");
3177 #if !defined(__OLDX__)
3178 /*if(glBlendFuncSeparate)
3179 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3182 glEnable(GL_TEXTURE_2D);
3183 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3185 glColor4fv(oglSurface.bitmapMult);
3191 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3192 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3194 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3195 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3197 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3198 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
3200 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3201 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3205 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3206 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3208 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3209 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3211 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3212 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3214 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3215 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3220 glDisable(GL_TEXTURE_2D);
3222 //glTranslate(0.375, 0.375, 0.0);
3223 #if !defined(__OLDX__)
3224 /*if(glBlendFuncSeparate)
3225 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3230 void Filter(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3232 Stretch(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3235 void StretchDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3237 float s2dw,s2dh,d2sw,d2sh;
3238 //bool flipX = false, flipY = false;
3240 //Logf("StretchDI\n");
3242 if(Sgn(w) != Sgn(sw))
3248 if(Sgn(h) != Sgn(sh))
3260 //Clip against the edges of the source
3263 dx+=(int)((0-sx) * s2dw);
3264 w-=(int)((0-sx) * s2dw);
3270 dy+=(int)((0-sy) * s2dh);
3271 h-=(int)((0-sy) * s2dh);
3276 if(sx+sw>bitmap.width-1)
3278 w-=(int)((sx+sw-(bitmap.width-1)-1)*s2dw);
3279 sw-=sx+sw-(bitmap.width-1)-1;
3281 if(sy+sh>(bitmap.height-1))
3283 h-=(int)((sy+sh-(bitmap.height-1)-1)*s2dh);
3284 sh-=sy+sh-(bitmap.height-1)-1;
3286 //Clip against the edges of the surfaceination
3287 if(dx<surface.box.left)
3290 sx+=(int)((surface.box.left-dx)*d2sw);
3291 sw-=(int)((surface.box.left-dx)*d2sw);
3292 w-=surface.box.left-dx;
3293 dx=surface.box.left;
3295 if(dy<surface.box.top)
3297 sy+=(int)((surface.box.top-dy)*d2sh);
3298 sh-=(int)((surface.box.top-dy)*d2sh);
3299 h-=surface.box.top-dy;
3302 if(dx+w>surface.box.right)
3304 //if(flip) sx+=(int)((dx+w-surface.box.right-1)*d2sw);
3305 sw-=(int)((dx+w-surface.box.right-1)*d2sw);
3306 w-=dx+w-surface.box.right-1;
3308 if(dy+h>surface.box.bottom)
3310 sh-=(int)((dy+h-surface.box.bottom-1)*d2sh);
3311 h-=dy+h-surface.box.bottom-1;
3313 if((w<=0)||(h<=0)||(sw<=0)||(sh<=0)) return;
3315 dx += surface.offset.x;
3316 dy += surface.offset.y;
3318 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3320 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3321 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3322 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3323 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3324 glRasterPos2d(dx,dy);
3325 //glPixelZoom(flipX ? -s2dw : s2dw, flipY ? s2dh : -s2dh);
3326 glPixelZoom(s2dw, -s2dh);
3327 glDrawPixels(sw,sh,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3328 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3329 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3330 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3331 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3335 void BlitDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3339 //Clip against the edges of the source
3352 if(sx+w>bitmap.width-1)
3353 w-=sx+w-(bitmap.width-1)-1;
3354 if(sy+h>bitmap.height-1)
3355 h-=sy+h-(bitmap.height-1)-1;
3356 //Clip against the edges of the surfaceination
3357 if(dx<surface.box.left)
3360 sx+=surface.box.left-dx;
3361 w-=surface.box.left-dx;
3362 dx=surface.box.left;
3364 if(dy<surface.box.top)
3366 sy+=surface.box.top-dy;
3367 h-=surface.box.top-dy;
3370 if(dx+w>surface.box.right)
3372 //if(flip) sx+=dx+w-surface.box.right-1;
3373 w-=dx+w-surface.box.right-1;
3375 if(dy+h>surface.box.bottom)
3376 h-=dy+h-surface.box.bottom-1;
3380 dx += surface.offset.x;
3381 dy += surface.offset.y;
3383 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3385 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3386 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3387 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3388 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3389 glRasterPos2d(dx,dy);
3391 glDrawPixels(w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3392 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3393 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3394 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3395 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3399 void FilterDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3401 StretchDI(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3404 void UnloadFont(DisplaySystem displaySystem, Font font)
3406 ((subclass(DisplayDriver))class(LFBDisplayDriver)).UnloadFont(displaySystem, font);
3409 Font LoadFont(DisplaySystem displaySystem, const char * faceName, float size, FontFlags flags)
3412 OGLSystem oglSystem = displaySystem.driverData;
3413 oglSystem.loadingFont = true;
3414 font = ((subclass(DisplayDriver))class(LFBDisplayDriver)).LoadFont(displaySystem, faceName, size, flags);
3418 void FontExtent(DisplaySystem displaySystem, Font font, const char * text, int len, int * width, int * height)
3420 ((subclass(DisplayDriver))class(LFBDisplayDriver)).FontExtent(displaySystem, font, text, len, width, height);
3423 void WriteText(Display display, Surface surface, int x, int y, const char * text, int len)
3425 OGLSurface oglSurface = surface.driverData;
3426 OGLSystem oglSystem = display.displaySystem.driverData;
3427 oglSystem.loadingFont = true;
3429 //glTranslated(-0.375, -0.375, 0.0);
3433 if(surface.textOpacity)
3436 FontExtent(display.displaySystem, surface.font, text, len, &w, &h);
3437 display.displaySystem.driver.Area(display, surface,x,y,x+w-1,y+h-1);
3440 oglSurface.writingText = true;
3442 glEnable(GL_TEXTURE_2D);
3443 glColor4fv(oglSurface.foreground);
3445 ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x, y, text, len);
3446 oglSurface.writingText = false;
3447 oglSystem.loadingFont = false;
3449 glDisable(GL_TEXTURE_2D);
3451 //glTranslated(0.375, 0.375, 0.0);
3454 void TextFont(Display display, Surface surface, Font font)
3456 ((subclass(DisplayDriver))class(LFBDisplayDriver)).TextFont(display, surface, font);
3459 void TextOpacity(Display display, Surface surface, bool opaque)
3461 OGLSurface oglSurface = surface.driverData;
3462 oglSurface.opaqueText = opaque;
3465 void TextExtent(Display display, Surface surface, const char * text, int len, int * width, int * height)
3467 OGLSurface oglSurface = surface.driverData;
3468 OGLSystem oglSystem = display.displaySystem.driverData;
3469 oglSystem.loadingFont = true;
3470 FontExtent(display.displaySystem, oglSurface.font, text, len, width, height);
3471 oglSystem.loadingFont = false;
3474 void DrawingChar(Display display, Surface surface, char character)
3479 void LineStipple(Display display, Surface surface, uint32 stipple)
3481 //Logf("Stipple\n");
3486 stippleEnabled = true;
3487 glesLineStipple(1, (uint16)stipple);
3489 glLineStipple(1, (uint16)stipple);
3490 glEnable(GL_LINE_STIPPLE);
3496 stippleEnabled = false;
3497 glMatrixMode(GL_TEXTURE);
3499 glMatrixMode(GL_PROJECTION);
3500 glDisable(GL_TEXTURE_2D);
3502 glDisable(GL_LINE_STIPPLE);
3506 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
3507 void SetRenderState(Display display, RenderState state, uint value)
3509 OGLDisplay oglDisplay = display.driverData;
3510 //Logf("RenderState\n");
3516 glEnable(GL_MULTISAMPLE_ARB);
3518 glDisable(GL_MULTISAMPLE_ARB);
3522 glPolygonMode(GL_FRONT_AND_BACK, ((FillModeValue)value == solid) ? GL_FILL : GL_LINE);
3526 if(value) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
3529 if(value) glDepthMask((byte)bool::true); else glDepthMask((byte)bool::false);
3530 oglDisplay.depthWrite = (bool)value;
3534 float color[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3535 glFogfv(GL_FOG_COLOR, (float *)&color);
3539 glFogf(GL_FOG_DENSITY, (float)(RenderStateFloat { ui = value }.f * nearPlane));
3542 if(value) glEnable(GL_BLEND); else glDisable(GL_BLEND);
3546 float ambient[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3547 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
3552 if(value) glColorMask(1,1,1,1); else glColorMask(1,1,1,0);
3557 #if defined(__WIN32__)
3558 wglSwapIntervalEXT(value ? 1 : 0);
3565 void SetLight(Display display, int id, Light light)
3567 //Logf("SetLight\n");
3571 Object lightObject = light.lightObject;
3572 float position[4] = { 0, 0, 0, 0 };
3573 float color[4] = { 0, 0, 0, 1 };
3575 glEnable(GL_LIGHT0 + id);
3577 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, (float *)&light.diffuse);
3578 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, (float *)&light.ambient);
3579 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,(float *)&light.specular);
3582 if(!light.multiplier) light.multiplier = 1.0f;
3584 color[0] = light.diffuse.r * light.multiplier;
3585 color[1] = light.diffuse.g * light.multiplier;
3586 color[2] = light.diffuse.b * light.multiplier;
3587 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, color);
3589 color[0] = light.ambient.r * light.multiplier;
3590 color[1] = light.ambient.g * light.multiplier;
3591 color[2] = light.ambient.b * light.multiplier;
3592 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, color);
3593 color[0] = light.specular.r * light.multiplier;
3594 color[1] = light.specular.g * light.multiplier;
3595 color[2] = light.specular.b * light.multiplier;
3596 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,color);
3600 Vector3D positionVector;
3601 if(light.flags.spot)
3603 if(lightObject.flags.root || !lightObject.parent)
3605 positionVector = lightObject.transform.position;
3606 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3610 positionVector.MultMatrix(lightObject.transform.position, lightObject.parent.matrix);
3611 if(display.display3D.camera)
3612 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3618 if(!light.direction.x && !light.direction.y && !light.direction.z)
3620 Vector3Df vector { 0,0,-1 };
3622 mat.RotationQuaternion(light.orientation);
3623 positionVector.MultMatrixf(vector, mat);
3627 positionVector = light.direction;
3632 position[0] = (float)positionVector.x;
3633 position[1] = (float)positionVector.y;
3634 position[2] = (float)positionVector.z;
3636 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3639 // Display Light Position
3640 glDisable(GL_LIGHTING);
3641 glDisable(GL_DEPTH_TEST);
3645 glVertex3fv(position);
3647 glEnable(GL_DEPTH_TEST);
3648 glEnable(GL_LIGHTING);
3652 if(lightObject.flags.root || !lightObject.parent)
3654 positionVector = light.target.transform.position;
3655 positionVector.Subtract(positionVector, display.camera.cPosition);
3659 positionVector.MultMatrix(light.target.transform.position,
3660 lightObject.light.target.parent.matrix);
3661 positionVector.Subtract(positionVector, display.camera.cPosition);
3664 position[0] = positionVector.x;
3665 position[1] = positionVector.y;
3666 position[2] = positionVector.z;
3668 glDisable(GL_LIGHTING);
3669 glDisable(GL_DEPTH_TEST);
3673 glVertex3fv(position);
3675 glEnable(GL_DEPTH_TEST);
3676 glEnable(GL_LIGHTING);
3679 if(light.flags.attenuation)
3681 glLightf(GL_LIGHT0 + id, GL_CONSTANT_ATTENUATION, light.Kc);
3682 glLightf(GL_LIGHT0 + id, GL_LINEAR_ATTENUATION, light.Kl);
3683 glLightf(GL_LIGHT0 + id, GL_QUADRATIC_ATTENUATION, light.Kq);
3686 if(light.flags.spot)
3689 #define MAXLIGHT 0.9
3690 float direction[4] = { (float)light.direction.x, (float)light.direction.y, (float)light.direction.z, 1 };
3691 // Figure out exponent out of the hot spot
3692 exponent = (float)(log(MAXLIGHT) / log(cos((light.hotSpot / 2))));
3694 glLightfv(GL_LIGHT0 + id, GL_SPOT_DIRECTION, direction);
3695 glLightf(GL_LIGHT0 + id, GL_SPOT_CUTOFF, (float)(light.fallOff / 2));
3696 glLightf(GL_LIGHT0 + id, GL_SPOT_EXPONENT, exponent);
3702 Vector3Df vector { 0,0,-1 };
3703 Vector3Df direction;
3706 mat.RotationQuaternion(light.orientation);
3707 direction.MultMatrix(vector, mat);
3709 position[0] = direction.x;
3710 position[1] = direction.y;
3711 position[2] = direction.z;
3713 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3717 glDisable(GL_LIGHT0 + id);
3720 void SetCamera(Display display, Surface surface, Camera camera)
3722 OGLDisplay oglDisplay = display.driverData;
3723 //Logf("SetCamera\n");
3727 int left = surface.box.left + surface.offset.x;
3728 int top = surface.box.top + surface.offset.y;
3729 int right = surface.box.right + surface.offset.x;
3730 int bottom = surface.box.bottom + surface.offset.y;
3731 float origX = surface.offset.x + camera.origin.x;
3732 float origY = surface.offset.y + camera.origin.y;
3734 int y = display.height - bottom - 1;
3735 int w = right - left + 1;
3736 int h = bottom - top + 1;
3739 glViewport(x, y, w, h);
3741 // *** Projection Matrix ***
3742 if(!display.display3D.camera)
3745 glMatrixMode(GL_PROJECTION);
3746 if(display.display3D.collectingHits)
3748 float pickX = display.display3D.pickX + surface.offset.x;
3749 float pickY = display.height - (display.display3D.pickY + surface.offset.y) - 1;
3753 w / display.display3D.pickWidth, 0, 0, 0,
3754 0, h / display.display3D.pickHeight, 0, 0,
3756 (w + 2.0f * (x - pickX)) / display.display3D.pickWidth,
3757 (h + 2.0f * (y - pickY)) / display.display3D.pickHeight, 0, 1
3760 glLoadMatrixd(pickMatrix.array);
3765 (left - origX) * camera.zMin / camera.focalX,
3766 (right - origX) * camera.zMin / camera.focalX,
3767 (bottom - origY) * camera.zMin / camera.focalY,
3768 (top - origY) * camera.zMin / camera.focalY,
3769 camera.zMin, camera.zMax);
3771 glDisable(GL_BLEND);
3773 // *** Z Inverted Identity Matrix ***
3774 glMatrixMode(GL_MODELVIEW);
3775 if(!display.display3D.camera)
3780 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
3782 // *** View Matrix ***
3783 glMultMatrixd(camera.viewMatrix.array);
3788 glEnable(GL_DEPTH_TEST);
3789 glEnable(GL_LIGHTING);
3790 glShadeModel(GL_SMOOTH);
3791 glDepthMask((byte)bool::true);
3792 oglDisplay.depthWrite = true;
3794 glEnable(GL_MULTISAMPLE_ARB);
3796 else if(display.display3D.camera)
3798 oglDisplay.depthWrite = false;
3799 glViewport(0,0,display.width,display.height);
3801 glDisable(GL_CULL_FACE);
3802 glDisable(GL_DEPTH_TEST);
3803 glDisable(GL_LIGHTING);
3805 glDisable(GL_TEXTURE_2D);
3806 glShadeModel(GL_FLAT);
3808 glDisable(GL_MULTISAMPLE_ARB);
3810 // *** Restore 2D MODELVIEW Matrix ***
3813 // *** Restore 2D PROJECTION Matrix ***
3814 glMatrixMode(GL_PROJECTION);
3820 void ApplyMaterial(Display display, Material material, Mesh mesh)
3822 //Logf("ApplyMaterial\n");
3825 if(material.flags.doubleSided)
3827 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, !material.flags.singleSideLight);
3828 glDisable(GL_CULL_FACE);
3832 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, bool::false);
3833 glEnable(GL_CULL_FACE);
3837 if(material.flags.noFog)
3843 if(material.baseMap && (mesh.texCoords || mesh.flags.texCoords1))
3845 Bitmap map = material.baseMap;
3846 glEnable(GL_TEXTURE_2D);
3847 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)map.driverData);
3849 glMatrixMode(GL_TEXTURE);
3851 if(material.uScale && material.vScale)
3852 glScalef(material.uScale, material.vScale, 1);
3853 glMatrixMode(GL_MODELVIEW);
3855 if(material.flags.tile)
3857 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
3858 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
3862 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
3863 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
3867 glDisable(GL_TEXTURE_2D);
3869 if(mesh.flags.colors)
3871 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
3872 glEnable(GL_COLOR_MATERIAL);
3876 glDisable(GL_COLOR_MATERIAL);
3878 float color[4] = { material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity };
3879 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
3882 float color[4] = { material.ambient.r, material.ambient.g, material.ambient.b, 0 };
3883 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
3887 float color[4] = { material.specular.r, material.specular.g, material.specular.b, 0 };
3888 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, color);
3891 float color[4] = { material.emissive.r, material.emissive.g, material.emissive.b, 0 };
3892 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, color);
3895 glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &material.power);
3898 void FreeMesh(DisplaySystem displaySystem, Mesh mesh)
3900 OGLMesh oglMesh = mesh.data;
3903 if(!mesh.flags.vertices)
3905 oglMesh.vertices.free();
3906 delete mesh.vertices;
3908 if(!mesh.flags.normals)
3910 oglMesh.normals.free();
3911 delete mesh.normals;
3913 if(!mesh.flags.texCoords1)
3915 oglMesh.texCoords.free();
3916 delete mesh.texCoords;
3918 if(!mesh.flags.texCoords2)
3920 oglMesh.texCoords2.free();
3921 // delete mesh.texCoords2;
3923 if(!mesh.flags.colors)
3925 oglMesh.colors.free();
3936 bool AllocateMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags, int nVertices)
3938 bool result = false;
3941 mesh.data = OGLMesh { };
3944 if(mesh.nVertices == nVertices)
3946 // Same number of vertices, adding features (Leaves the other features pointers alone)
3947 if(mesh.flags != flags)
3949 if(!mesh.flags.vertices && flags.vertices)
3951 if(flags.doubleVertices)
3953 mesh.vertices = (Vector3Df *)new Vector3D[nVertices];
3956 mesh.vertices = new Vector3Df[nVertices];
3958 if(!mesh.flags.normals && flags.normals)
3960 if(flags.doubleNormals)
3962 mesh.normals = (Vector3Df *)new Vector3D[nVertices];
3965 mesh.normals = new Vector3Df[nVertices];
3967 if(!mesh.flags.texCoords1 && flags.texCoords1)
3969 mesh.texCoords = new Pointf[nVertices];
3971 if(!mesh.flags.colors && flags.colors)
3973 mesh.colors = new ColorRGBAf[nVertices];
3979 // New number of vertices, reallocate all current and new features
3980 flags |= mesh.flags;
3983 if(flags.doubleVertices)
3985 mesh.vertices = (Vector3Df *)renew mesh.vertices Vector3D[nVertices];
3988 mesh.vertices = renew mesh.vertices Vector3Df[nVertices];
3992 if(flags.doubleNormals)
3994 mesh.normals = (Vector3Df *)renew mesh.normals Vector3D[nVertices];
3997 mesh.normals = renew mesh.normals Vector3Df[nVertices];
3999 if(flags.texCoords1)
4001 mesh.texCoords = renew mesh.texCoords Pointf[nVertices];
4005 mesh.colors = renew mesh.colors ColorRGBAf[nVertices];
4013 void UnlockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
4015 OGLMesh oglMesh = mesh.data;
4016 if(!flags) flags = mesh.flags;
4021 oglMesh.vertices.upload(
4022 mesh.nVertices * (mesh.flags.doubleVertices ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.vertices); //, GL_STATIC_DRAW_ARB );
4025 oglMesh.normals.upload(
4026 mesh.nVertices * (mesh.flags.doubleNormals ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.normals); //, GL_STATIC_DRAW_ARB );
4028 if(flags.texCoords1)
4029 oglMesh.texCoords.upload(
4030 mesh.nVertices * sizeof(Pointf), mesh.texCoords); //, GL_STATIC_DRAW_ARB );
4033 oglMesh.colors.upload(
4034 mesh.nVertices * sizeof(ColorRGBAf), mesh.colors); //, GL_STATIC_DRAW_ARB );
4038 bool LockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
4045 void FreeIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4049 oglIndices.buffer.free();
4050 delete oglIndices.indices;
4055 void * AllocateIndices(DisplaySystem displaySystem, int nIndices, bool indices32bit)
4057 OGLIndices oglIndices = OGLIndices { };
4060 oglIndices.indices = (void *)(indices32bit ? new uint32[nIndices] : new uint16[nIndices]);
4061 oglIndices.nIndices = nIndices;
4066 void UnlockIndices(DisplaySystem displaySystem, OGLIndices oglIndices, bool indices32bit, int nIndices)
4070 oglIndices.buffer.upload(
4071 nIndices * (indices32bit ? sizeof(uint32) : sizeof(uint16)),
4072 oglIndices.indices); //GL_STATIC_DRAW_ARB);
4076 uint16 * LockIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4079 return oglIndices.indices;
4082 void SelectMesh(Display display, Mesh mesh)
4084 //Logf("SelectMesh\n");
4086 #if !defined( __ANDROID__) && !defined(__APPLE__) && !defined(__ODROID__)
4088 #if defined(__WIN32__)
4089 if(glUnlockArraysEXT)
4091 if(!vboAvailable && display.display3D.mesh)
4092 glUnlockArraysEXT();
4097 OGLMesh oglMesh = mesh.data;
4099 // *** Vertex Stream ***
4100 glEnableClientState(GL_VERTEX_ARRAY);
4101 if(!display.display3D.collectingHits && oglMesh)
4103 oglMesh.vertices.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, oglMesh.vertices.buffer ? null : (double *)mesh.vertices);
4105 // *** Normals Stream ***
4106 if(mesh.normals || mesh.flags.normals)
4108 glEnableClientState(GL_NORMAL_ARRAY);
4109 oglMesh.normals.use(normal, 3, GL_FLOAT, 0, oglMesh.normals.buffer ? null : mesh.normals);
4112 glDisableClientState(GL_NORMAL_ARRAY);
4114 // *** Texture Coordinates Stream ***
4115 if(mesh.texCoords || mesh.flags.texCoords1)
4117 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4118 oglMesh.texCoords.use(texCoord, 2, GL_FLOAT, 0, oglMesh.texCoords.buffer ? null : mesh.texCoords);
4121 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4123 // *** Color Stream ***
4124 if(mesh.colors || mesh.flags.colors)
4126 glEnableClientState(GL_COLOR_ARRAY);
4127 oglMesh.colors.use(color, 4, GL_FLOAT, 0, oglMesh.colors.buffer ? null : mesh.colors);
4130 glDisableClientState(GL_COLOR_ARRAY);
4134 noAB.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, (double *)mesh.vertices);
4135 if((mesh.normals || mesh.flags.normals) && !display.display3D.collectingHits)
4137 glEnableClientState(GL_NORMAL_ARRAY);
4138 noAB.use(normal, 3, GL_FLOAT, 0, mesh.normals);
4141 glDisableClientState(GL_NORMAL_ARRAY);
4142 if((mesh.texCoords || mesh.flags.texCoords1) && !display.display3D.collectingHits)
4144 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4145 noAB.use(texCoord, 2, GL_FLOAT, 0, mesh.texCoords);
4148 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4149 if((mesh.colors || mesh.flags.colors) && !display.display3D.collectingHits)
4151 glEnableClientState(GL_COLOR_ARRAY);
4152 noAB.use(color, 4, GL_FLOAT, 0, mesh.colors);
4155 glDisableClientState(GL_COLOR_ARRAY);
4158 #if !defined(__ANDROID__) && !defined(__APPLE__) && !defined(__ODROID__)
4160 #if defined(__WIN32__)
4164 glLockArraysEXT(0, mesh.nVertices);
4170 void DrawPrimitives(Display display, PrimitiveSingle * primitive, Mesh mesh)
4172 //Logf("DrawPrimitives\n");
4174 if(primitive->type.vertexRange)
4175 glDrawArrays(primitiveTypes[primitive->type.primitiveType], primitive->first, primitive->nVertices);
4178 // *** Hoping the data won't be uploaded at all (Won't really work if another group of the mesh is using the mesh ) ***
4179 // HACK TO SPEED THINGS UP...
4181 /*GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
4182 if(primitive->nIndices < (mesh.nVertices >> 2) && !primitive->type.indices32bit)
4185 glBegin(primitiveTypes[primitive->type.primitiveType]);
4188 OGLIndices oglIndices = primitive->data;
4189 MeshFeatures flags = mesh.flags;
4190 for(c = 0; c<primitive->nIndices; c++)
4192 uint16 index = ((uint16 *) oglIndices.indices)[c];
4193 if(flags.normals) glNormal3fv((float *)&mesh.normals[index]);
4194 if(flags.texCoords1) glTexCoord2fv((float *)&mesh.texCoords[index]);
4195 if(flags.colors) glColor4fv((float *)&mesh.colors[index]);
4196 glVertex3fv((float *)&mesh.vertices[index]);
4204 OGLIndices oglIndices = primitive->data;
4206 if(!display.display3D.collectingHits && vboAvailable && oglIndices)
4208 if(primitive->type.indices32bit)
4209 ; //oglIndices.buffer.draw(primitiveTypes[primitive->type.primitiveType], primitive->nIndices, GL_UNSIGNED_SHORT, 0);
4211 oglIndices.buffer.draw(primitiveTypes[primitive->type.primitiveType], primitive->nIndices, GL_UNSIGNED_SHORT, 0);
4215 if(primitive->type.indices32bit)
4216 glDrawElementsi(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
4217 oglIndices ? oglIndices.indices : primitive->indices);
4219 glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
4220 GL_UNSIGNED_SHORT, oglIndices ? oglIndices.indices : primitive->indices);
4226 void PushMatrix(Display display)
4231 void PopMatrix(Display display, bool setMatrix)
4236 void SetTransform(Display display, Matrix transMatrix, bool viewSpace, bool useCamera)
4238 Matrix matrix = transMatrix;
4239 Camera camera = useCamera ? display.display3D.camera : null;
4244 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
4249 matrix.m[3][0] - camera.cPosition.x,
4250 matrix.m[3][1] - camera.cPosition.y,
4251 matrix.m[3][2] - camera.cPosition.z);
4263 glMultMatrixd(matrix.array);
4268 public void UseSingleGLContext(bool useSingle)
4270 useSingleGLContext = useSingle;
4273 default dllexport void *
4274 #if defined(__WIN32__)
4275 __attribute__((stdcall))
4277 IS_GLGetContext(DisplaySystem displaySystem)
4281 #if defined(__WIN32__)
4282 OGLSystem system = displaySystem.driverData;
4284 #elif defined(__ANDROID__) || defined(__ODROID__)
4287 OGLSystem system = displaySystem.driverData;
4288 return system.glContext;