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, &buffer);
1352 if(curArrayBuffer != buffer)
1354 glBindBuffer(GL_ARRAY_BUFFER, buffer);
1355 curArrayBuffer = buffer;
1357 glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW); //GL_DYNAMIC_DRAW);
1365 glDeleteBuffers(1, &buffer);
1370 void use(GLBufferContents contents, int n, int type, uint stride, void * pointer)
1372 if(curArrayBuffer != ((this != null) ? buffer : 0))
1374 glBindBuffer(GL_ARRAY_BUFFER, ((this != null) ? buffer : 0));
1375 curArrayBuffer = ((this != null) ? buffer : 0);
1379 case normal: glNormalPointer(type, stride, pointer); break;
1380 case vertex: glVertexPointer(n, type, stride, pointer); break;
1381 case texCoord: glTexCoordPointer(n, type, stride, pointer); break;
1382 case color: glColorPointer(n, type, stride, pointer); break;
1387 static uint curElementBuffer;
1389 public define noEAB = GLEAB { 0 };
1395 void upload(uint size, void * data)
1400 glGenBuffers(1, &buffer);
1402 if(curElementBuffer != buffer)
1404 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
1405 curElementBuffer = buffer;
1407 glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, data, GL_STATIC_DRAW); //GL_DYNAMIC_DRAW);
1415 glDeleteBuffers(1, &buffer);
1420 void draw(int primType, int count, int type, void * indices)
1422 if(curElementBuffer != ((this != null) ? buffer : 0))
1424 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ((this != null) ? buffer : 0));
1425 curElementBuffer = ((this != null) ? buffer : 0);
1427 glDrawElements(primType, count, type, indices);
1431 public void GLGenBuffers(int count, GLAB * buffers)
1433 #if defined(__ANDROID__) || defined(__ODROID__)
1434 glGenBuffers(count, (GLuint *)buffers);
1436 #if defined(__WIN32__)
1439 glGenBuffersARB(count, (GLuint *)buffers);
1443 public void GLDeleteBuffers(int count, GLAB * buffers)
1445 #if defined(__ANDROID__) || defined(__ODROID__)
1446 glDeleteBuffers(count, (GLuint *)buffers);
1448 #if defined(__WIN32__)
1449 if(glDeleteBuffersARB)
1451 glDeleteBuffersARB(count, (GLuint *)buffers);
1455 void GLBindBuffer(int target, uint buffer)
1457 #if defined(__ANDROID__) || defined(__ODROID__)
1458 glBindBuffer(target, buffer);
1460 #if defined(__WIN32__)
1463 glBindBufferARB(target, buffer);
1465 if(target == GL_ARRAY_BUFFER_ARB)
1466 curArrayBuffer = buffer;
1467 else if(target == GL_ELEMENT_ARRAY_BUFFER_ARB)
1468 curElementBuffer = buffer;
1471 public void GLVertexPointer(int numCoords, int glType, int stride, void *ptr, int numVertices)
1474 if(glType == GL_DOUBLE)
1475 glesVertexPointerd(numCoords, stride, ptr, numVertices);
1476 else if(glType == GL_INT)
1477 glesVertexPointeri(numCoords, stride, ptr, numVertices);
1480 glVertexPointer(numCoords, glType, stride, ptr);
1483 public void GLBufferData(int type, GLenum target, int size, const GLvoid *data, GLenum usage)
1486 if(type == GL_DOUBLE)
1487 glesBufferDatad(target, size, (void *)data, usage);
1488 else if(type == GL_UNSIGNED_INT)
1489 glesBufferDatai(target, size, (void *)data, usage);
1493 #if defined(__ANDROID__) || defined(__ODROID__)
1494 glBufferData(target, size, data, usage);
1497 #if defined(__WIN32__)
1500 glBufferDataARB(target, size, data, usage);
1504 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1505 static int primitiveTypes[RenderPrimitiveType] =
1507 GL_POINTS, GL_LINES, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP, GL_LINE_STRIP
1512 // Non OpenGL ES friendly stuff
1516 //#undef GL_UNSIGNED_INT
1521 #undef GL_QUAD_STRIP
1522 #undef GL_POLYGON_STIPPLE
1523 #undef GL_LINE_STIPPLE
1526 #undef GL_ALL_ATTRIB_BITS
1527 #undef GL_LIGHT_MODEL_LOCAL_VIEWER
1531 static int displayWidth, displayHeight;
1533 #define GL_CLAMP_TO_EDGE 0x812F
1535 static bool vboAvailable;
1537 static bool useSingleGLContext = false;
1538 class OGLDisplay : struct
1540 #if defined(__WIN32__)
1550 int imageBuffers[2];
1551 byte * pboMemory1, * pboMemory2;
1553 #elif !defined(__ANDROID__) && !defined(__ODROID__)
1554 GLXContext glContext;
1557 XShmSegmentInfo shminfo;
1559 XShmSegmentInfo shminfoShape;
1560 XImage * shapeImage;
1564 X11Picture windowPicture;
1565 X11Picture pixmapPicture;
1567 X11Picture shapePicture;
1570 ColorAlpha * flippingBuffer;
1571 int flipBufH, flipBufW;
1576 class OGLSystem : struct
1581 #if defined(__WIN32__)
1582 PIXELFORMATDESCRIPTOR pfd;
1587 #elif !defined(__ANDROID__) && !defined(__ODROID__)
1588 XVisualInfo * visualInfo;
1589 GLXContext glContext;
1590 GLXDrawable glxDrawable;
1594 class OGLSurface : struct
1601 float foreground[4], background[4], bitmapMult[4];
1604 class OGLMesh : struct
1613 class OGLIndices : struct
1623 class OpenGLDisplayDriver : DisplayDriver
1625 class_property(name) = "OpenGL";
1627 bool LockSystem(DisplaySystem displaySystem)
1629 #if !defined(__ANDROID__) && !defined(__ODROID__)
1630 OGLSystem oglSystem = displaySystem.driverData;
1631 if(useSingleGLContext) return true;
1632 #if defined(__WIN32__)
1633 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1634 #elif defined(__unix__) || defined(__APPLE__)
1635 //if(previous) return true;
1636 // printf("Making SYSTEM current\n");
1637 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)oglSystem.glxDrawable, oglSystem.glContext);
1638 //previous = oglSystem.glContext;
1644 void UnlockSystem(DisplaySystem displaySystem)
1646 if(useSingleGLContext) return;
1647 #if defined(__WIN32__)
1648 wglMakeCurrent(null, null);
1649 #elif defined(__unix__) || defined(__APPLE__)
1650 // printf("Making NULL current\n");
1651 #if defined(__ANDROID__) || defined(__ODROID__)
1653 glXMakeCurrent(xGlobalDisplay, None, null);
1659 bool Lock(Display display)
1661 #if !defined(__ANDROID__) && !defined(__ODROID__)
1662 OGLDisplay oglDisplay = display.driverData;
1663 if(useSingleGLContext) return true;
1664 #if defined(__WIN32__)
1665 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1666 #elif defined(__unix__) || defined(__APPLE__)
1667 // if(previous) glXMakeCurrent(xGlobalDisplay, None, null);
1668 // printf(" Making DISPLAY current\n");
1669 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
1675 void Unlock(Display display)
1677 if(useSingleGLContext) return;
1678 //printf(" Making NULL current\n");
1679 //glXMakeCurrent(xGlobalDisplay, None, null);
1681 LockSystem(display.displaySystem);
1684 void DestroyDisplay(Display display)
1686 OGLDisplay oglDisplay = display.driverData;
1690 #if defined(__WIN32__)
1691 wglMakeCurrent( null, null );
1694 wglDeleteContext(oglDisplay.glrc);
1696 if(oglDisplay.hdc && oglDisplay.pBuffer)
1697 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
1699 if(oglDisplay.pBuffer)
1700 wglDestroyPbufferARB(oglDisplay.pBuffer);
1703 ReleaseDC(display.window, oglDisplay.hdc);
1705 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
1706 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
1708 #elif defined(__unix__) || defined(__APPLE__)
1709 #if defined(__ANDROID__) || defined(__ODROID__)
1711 if(oglDisplay.shapePixmap)
1712 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
1713 if(oglDisplay.pixmap)
1714 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1715 if(oglDisplay.image)
1717 if(oglDisplay.shminfoShape.shmid != -1)
1719 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
1720 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1721 shmdt(oglDisplay.shminfo.shmaddr);
1722 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
1725 if(oglDisplay.shapeImage)
1727 if(oglDisplay.shminfoShape.shmid != -1)
1729 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
1730 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1731 shmdt(oglDisplay.shminfoShape.shmaddr);
1732 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
1734 XDestroyImage(oglDisplay.shapeImage);
1735 oglDisplay.shapeImage = None;
1738 glXMakeCurrent(xGlobalDisplay, None, null);
1740 if(oglDisplay.glContext)
1741 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
1744 delete oglDisplay.flippingBuffer;
1746 display.driverData = null;
1750 void ::CheckExtensions(OGLSystem oglSystem)
1752 const char * extensions = (const char *)glGetString(GL_EXTENSIONS);
1754 oglSystem.pow2textures = strstr(extensions, "GL_ARB_texture_non_power_of_two") ? false : true;
1755 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &oglSystem.maxTextureSize);
1758 bool CreateDisplaySystem(DisplaySystem displaySystem)
1760 bool result = false;
1761 OGLSystem oglSystem = displaySystem.driverData = OGLSystem { };
1764 oglSystem.hwnd = CreateWindow("static", null, 0,0,0,0,0,null,null,null,null);
1766 oglSystem.hdc = GetDC(oglSystem.hwnd);
1770 oglSystem.pfd.nSize = (short)sizeof(oglSystem.pfd);
1771 oglSystem.pfd.nVersion = 1;
1772 oglSystem.pfd.dwFlags = PFD_DRAW_TO_WINDOW /*PFD_DRAW_TO_BITMAP*/ | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
1773 oglSystem.pfd.iPixelType = PFD_TYPE_RGBA;
1774 oglSystem.pfd.cColorBits = 24;
1775 oglSystem.pfd.cAlphaBits = 8;
1776 oglSystem.pfd.cDepthBits = 24;
1777 oglSystem.pfd.iLayerType = PFD_MAIN_PLANE;
1779 oglSystem.format = ChoosePixelFormat(oglSystem.hdc, &oglSystem.pfd);
1780 DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1782 if(oglSystem.pfd.cColorBits > 8)
1784 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1785 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1788 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1790 // Get Pointers To The GL Functions
1791 glActiveTextureARB = (void *) wglGetProcAddress("glActiveTextureARB");
1792 glMultiTexCoord2fARB = (void *) wglGetProcAddress("glMultiTexCoord2fARB");
1793 glClientActiveTextureARB = (void *) wglGetProcAddress("glClientActiveTextureARB");
1794 glLockArraysEXT = (void *) wglGetProcAddress("glLockArraysEXT" );
1795 glUnlockArraysEXT = (void *) wglGetProcAddress("glUnlockArraysEXT");
1796 glGenBuffersARB = (void *) wglGetProcAddress("glGenBuffersARB");
1797 glBindBufferARB = (void *) wglGetProcAddress("glBindBufferARB");
1798 glBufferDataARB = (void *) wglGetProcAddress("glBufferDataARB");
1799 glMapBufferARB = (void *) wglGetProcAddress("glMapBufferARB");
1800 glUnmapBufferARB = (void *) wglGetProcAddress("glUnmapBufferARB");
1801 glDeleteBuffersARB = (void *) wglGetProcAddress("glDeleteBuffersARB");
1802 glBlendFuncSeparate = (void *) wglGetProcAddress("glBlendFuncSeparate");
1804 wglChoosePixelFormatARB = (void *) wglGetProcAddress("wglChoosePixelFormatARB");
1805 wglGetExtensionsStringARB = (void *)wglGetProcAddress("wglGetExtensionsStringARB");
1806 wglCreatePbufferARB = (void *)wglGetProcAddress("wglCreatePbufferARB");
1807 wglGetPbufferDCARB = (void *)wglGetProcAddress("wglGetPbufferDCARB");
1808 wglQueryPbufferARB = (void *)wglGetProcAddress("wglQueryPbufferARB");
1809 wglDestroyPbufferARB = (void *)wglGetProcAddress("wglDestroyPbufferARB");
1810 wglReleasePbufferDCARB = (void *)wglGetProcAddress("wglReleasePbufferDCARB");
1811 wglBindTexImageARB = (void *)wglGetProcAddress("wglBindTexImageARB");
1812 wglReleaseTexImageARB = (void *)wglGetProcAddress("wglReleaseTexImageARB");
1814 wglSwapIntervalEXT = (void *)wglGetProcAddress("wglSwapIntervalEXT");
1816 vboAvailable = glBindBufferARB != null;
1818 // eSystem_LoggingMode(LOG_MSGBOX, null);
1820 if(wglChoosePixelFormatARB)
1825 float fAttributes[] = {0,0};
1828 WGL_DRAW_TO_WINDOW_ARB,GL_TRUE,
1829 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1830 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
1831 WGL_COLOR_BITS_ARB,24,
1832 WGL_ALPHA_BITS_ARB,8,
1833 WGL_DEPTH_BITS_ARB,16,
1834 WGL_STENCIL_BITS_ARB,0,
1835 WGL_DOUBLE_BUFFER_ARB,GL_TRUE,
1836 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
1837 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
1841 //Log("Found wglChoosePixelFormatARB\n");
1843 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1844 if(!valid || !numFormats)
1846 //Log("Can't find 4x multi sampling\n");
1847 iAttributes[19] = 2;
1848 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1849 if(!valid || !numFormats)
1851 // Log("Can't find 2x multi sampling\n");
1852 iAttributes[16] = 0;
1853 iAttributes[17] = 0;
1854 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1857 if(valid && numFormats)
1859 oglSystem.format = pixelFormat;
1860 wglMakeCurrent(null, null);
1861 wglDeleteContext(oglSystem.glrc);
1863 // *** DescribePixelFormat does not support WGL pixel formats! ***
1864 //DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1865 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1866 //Log("Successfully set pixel format\n");
1868 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1869 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1873 eSystem_Logf("Can't find wglChoosePixelFormatARB\n");*/
1877 CheckExtensions(oglSystem);
1879 wglMakeCurrent(null, null);
1881 //eSystem_DumpErrors(true);
1885 #elif defined(__unix__) || defined(__APPLE__)
1886 vboAvailable = true;
1887 #if defined(__ANDROID__)
1888 egl_init_display(guiApp.desktop.windowHandle);
1889 #elif defined(__ODROID__)
1890 egl_init_display((uint)displaySystem.window);
1891 CheckExtensions(oglSystem);
1895 X11Window root = RootWindow( xGlobalDisplay, DefaultScreen( xGlobalDisplay ) );
1896 XSetWindowAttributes attr;
1901 #ifndef ECERE_MINIGLX
1902 GLX_USE_GL, GLX_DEPTH_SIZE, 1,
1905 GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,
1909 oglSystem.visualInfo = glXChooseVisual( xGlobalDisplay, DefaultScreen( xGlobalDisplay ), attrList );
1910 attr.background_pixel = 0;
1911 attr.border_pixel = 0;
1912 attr.colormap = XCreateColormap( xGlobalDisplay, root, oglSystem.visualInfo->visual, AllocNone);
1913 attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
1914 mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
1916 oglSystem.glxDrawable = XCreateWindow( xGlobalDisplay, root, 0, 0, 1, 1, 0, oglSystem.visualInfo->depth, InputOutput,
1917 oglSystem.visualInfo->visual, mask, &attr );
1919 if(oglSystem.visualInfo)
1921 oglSystem.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, null, True);
1922 if(oglSystem.glContext)
1924 glXMakeCurrent(xGlobalDisplay, oglSystem.glxDrawable, oglSystem.glContext);
1926 CheckExtensions(oglSystem);
1927 glXMakeCurrent(xGlobalDisplay, None, null);
1934 displaySystem.flags.alpha = true;
1935 displaySystem.flags.flipping = true;
1936 displaySystem.pixelFormat = pixelFormat888;
1940 void DestroyDisplaySystem(DisplaySystem displaySystem)
1942 OGLSystem oglSystem = displaySystem.driverData;
1944 #if defined(__WIN32__)
1945 wglMakeCurrent( null, null );
1948 wglDeleteContext(oglSystem.glrc);
1951 ReleaseDC(oglSystem.hwnd, oglSystem.hdc);
1952 DestroyWindow(oglSystem.hwnd);
1954 #elif defined(__unix__) || defined(__APPLE__)
1955 #if defined(__ANDROID__) || defined(__ODROID__)
1958 if(oglSystem.visualInfo)
1960 #ifdef ECERE_MINIGLX
1961 __miniglx_XFree(oglSystem.visualInfo);
1963 XFree(oglSystem.visualInfo);
1967 if(oglSystem.glxDrawable)
1969 XDestroyWindow(xGlobalDisplay, oglSystem.glxDrawable);
1970 oglSystem.glxDrawable = 0;
1977 bool CreateDisplay(Display display)
1979 bool result = false;
1980 OGLDisplay oglDisplay = display.driverData;
1981 #if !defined(__ANDROID__) && !defined(__ODROID__)
1982 OGLSystem oglSystem = display.displaySystem.driverData;
1985 oglDisplay = display.driverData = OGLDisplay { };
1986 //printf("Inside CreateDisplay\n");
1988 #if defined(__WIN32__) || defined(USEPBUFFER)
1989 if(!display.alphaBlend)
1992 #if defined(__WIN32__)
1993 oglDisplay.hdc = GetDC(display.window);
1994 SetPixelFormat(oglDisplay.hdc, oglSystem.format, &oglSystem.pfd);
1995 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
1997 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
1998 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2002 ReleaseDC(display.window, oglDisplay.hdc);
2003 #elif defined(__unix__) || defined(__APPLE__)
2004 #if defined(__ANDROID__) || defined(__ODROID__)
2006 XVisualInfo * visualInfo = ((XWindowData)display.windowDriverData).visual;
2008 #if defined(__APPLE__)
2009 XVisualInfo template = { 0 };
2010 XWindowAttributes winAttr;
2012 XGetWindowAttributes(xGlobalDisplay, (X11Window)display.window, &winAttr);
2013 template.visualid = XVisualIDFromVisual(winAttr.visual);
2014 visualInfo = XGetVisualInfo(xGlobalDisplay, VisualIDMask, &template, &n);
2016 printf("XGetVisualInfo visual ID = %d\n", template.visualid);
2017 printf("visualInfo visual ID = %d\n", visualInfo->visualid);
2018 printf("oglSystem.visualInfo visual ID = %d\n", oglSystem.visualInfo->visualid);
2019 printf("((XWindowData)display.windowDriverData).visual visual ID = %d\n", ((XWindowData)display.windowDriverData).visual->visualid);
2021 // visualInfo = oglSystem.visualInfo;
2026 //printf("visualInfo is not null\n");
2027 // printf("Creating Display Context, sharing with %x!\n", oglSystem.glContext);
2028 oglDisplay.glContext = glXCreateContext(xGlobalDisplay, visualInfo, oglSystem.glContext, True);
2029 //XFree(visualInfo);
2032 // oglDisplay.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, oglSystem.glContext, True);
2033 if(oglDisplay.glContext)
2035 //printf("CreateDisplay Got a Context\n");
2036 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2042 #if defined(__WIN32__) || defined(USEPBUFFER)
2048 #if defined(__WIN32__)
2049 if(glBlendFuncSeparate)
2050 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2052 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2054 #if !defined(__OLDX__)
2055 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2057 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2062 glMatrixMode(GL_MODELVIEW);
2063 glScaled(1.0, 1.0, -1.0);
2064 // glTranslatef(0.375f, 0.375f, 0.0f);
2065 // glTranslatef(-0.625f, -0.625f, 0.0f);
2066 glMatrixMode(GL_PROJECTION);
2067 glShadeModel(GL_FLAT);
2069 // glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, true);
2070 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
2071 glFogi(GL_FOG_MODE, GL_EXP);
2072 glFogf(GL_FOG_DENSITY, 0);
2073 glEnable(GL_NORMALIZE);
2074 glDepthFunc(GL_LESS);
2076 glDisable(GL_MULTISAMPLE_ARB);
2078 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
2079 display.ambient = Color { 50,50,50 };
2082 if(!useSingleGLContext)
2084 #if defined(__WIN32__)
2085 wglMakeCurrent(null, null);
2086 #elif defined(__unix__) || defined(__APPLE__)
2087 #if defined(__ANDROID__) || defined(__ODROID__)
2090 glXMakeCurrent(xGlobalDisplay, None, null);
2096 #if defined(__ANDROID__) || defined(__EMSCRIPTEN__) || defined(__ODROID__)
2104 bool DisplaySize(Display display, int width, int height)
2106 OGLDisplay oglDisplay = display.driverData;
2108 bool result = false;
2110 //printf("Inside DisplaySize\n");
2111 #if defined(__WIN32__) || defined(USEPBUFFER)
2112 OGLSystem oglSystem = display.displaySystem.driverData;
2113 if(display.alphaBlend)
2115 #if defined(__WIN32__)
2116 const int attributes[]=
2118 /*WGL_TEXTURE_FORMAT_ARB, WGL_TEXTURE_RGBA_ARB,
2119 WGL_TEXTURE_TARGET_ARB, WGL_TEXTURE_2D_ARB, */0
2121 int pixelFormat = 0;
2122 if(wglChoosePixelFormatARB)
2126 float fAttributes[] = {0,0};
2129 //WGL_DRAW_TO_BITMAP_ARB, GL_TRUE,
2130 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2131 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2132 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
2133 WGL_COLOR_BITS_ARB,24,
2134 WGL_ALPHA_BITS_ARB,8,
2135 WGL_DEPTH_BITS_ARB,16,
2136 WGL_STENCIL_BITS_ARB,0,
2137 WGL_DOUBLE_BUFFER_ARB,GL_FALSE,
2138 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
2139 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
2143 //Log("Found wglChoosePixelFormatARB\n");
2145 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2146 if(!valid || !numFormats)
2148 //Log("Can't find 4x multi sampling\n");
2149 iAttributes[19] = 2;
2150 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2151 if(!valid || !numFormats)
2153 // Log("Can't find 2x multi sampling\n");
2154 iAttributes[16] = 0;
2155 iAttributes[17] = 0;
2156 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2157 if(!valid || !numFormats)
2161 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
2162 //WGL_DRAW_TO_BITMAP_ARB,GL_TRUE,
2163 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
2164 WGL_COLOR_BITS_ARB,24,
2165 WGL_ALPHA_BITS_ARB,8,
2166 WGL_DEPTH_BITS_ARB,16,
2169 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
2173 if(valid && numFormats)
2175 wglMakeCurrent(null, null);
2179 wglMakeCurrent( null, null );
2180 wglMakeCurrent( oglDisplay.hdc, oglDisplay.glrc );
2181 if(oglDisplay.hdc && oglDisplay.pBuffer)
2182 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
2184 wglDestroyPbufferARB(oglDisplay.pBuffer);
2186 if(!useSingleGLContext)
2187 wglMakeCurrent( null, null );
2190 wglDeleteContext(oglDisplay.glrc);
2192 oglDisplay.pBuffer = wglCreatePbufferARB(oglSystem.hdc, pixelFormat, width, height, attributes);
2193 oglDisplay.hdc = wglGetPbufferDCARB(oglDisplay.pBuffer);
2194 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
2197 HDC hdc = GetDC(display.window);
2199 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2200 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2202 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_WIDTH_ARB, &width);
2203 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_HEIGHT_ARB, &height);
2205 // glDeleteBuffersARB(2, oglDisplay.imageBuffers);
2207 if((info = (BITMAPINFO *)new0 byte[sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*256]))
2211 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
2212 oglDisplay.memDC = CreateCompatibleDC(hdc);
2213 SetMapMode(oglDisplay.memDC, MM_TEXT);
2214 info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2215 info->bmiHeader.biPlanes = 1;
2216 info->bmiHeader.biCompression = BI_RGB;
2217 info->bmiHeader.biBitCount = 32; //(uint16)GetDeviceCaps(hdc, BITSPIXEL);
2218 info->bmiHeader.biWidth = width;
2219 info->bmiHeader.biHeight = height;
2220 newBitmap = CreateDIBSection(hdc, info, DIB_RGB_COLORS, &oglDisplay.picture, null, 0);
2223 SelectObject(oglDisplay.memDC, newBitmap);
2224 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
2227 PIXELFORMATDESCRIPTOR pfd = { 0 };
2228 pfd.nSize = (short)sizeof(pfd);
2230 pfd.dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL;
2231 pfd.iPixelType = PFD_TYPE_RGBA;
2232 pfd.cColorBits = 32;
2233 //pfd.cAlphaBits = 8;
2234 pfd.cDepthBits = 24;
2235 pfd.iLayerType = PFD_MAIN_PLANE;
2237 oglDisplay.hdc = oglDisplay.memDC;
2239 pixelFormat = ChoosePixelFormat(oglSystem.hdc, &pfd);
2240 DescribePixelFormat(oglDisplay.hdc, pixelFormat, sizeof(pfd), &pfd);
2241 SetPixelFormat(oglDisplay.hdc, pixelFormat, &pfd);
2243 oglDisplay.glrc = wglCreateContext(oglDisplay.hdc);
2244 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
2245 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2250 const int imageSize = width * height * 4;
2252 glGenBuffersARB(2, oglDisplay.imageBuffers);
2254 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2255 glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize, null, GL_STREAM_READ);
2256 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2257 // glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize / 2, null, GL_STREAM_READ);
2260 oglDisplay.memBitmap = newBitmap;
2261 oglDisplay.stride = width;
2267 ReleaseDC(display.window, hdc);
2269 #elif defined(__unix__) || defined(__APPLE__)
2270 #if defined(__ANDROID__) || defined(__ODROID__)
2275 GLX_DOUBLEBUFFER, True,
2281 GLX_STENCIL_SIZE, 1,
2282 //GLX_DEPTH_SIZE, 24,
2283 GLX_RENDER_TYPE, GLX_RGBA_BIT,
2284 GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT | GLX_WINDOW_BIT,
2290 GLX_PBUFFER_WIDTH, width,
2291 GLX_PBUFFER_HEIGHT, height,
2292 GLX_LARGEST_PBUFFER, False,
2296 // choose a pixel format that meets our minimum requirements
2299 GLXFBConfig *config = glXChooseFBConfig(xGlobalDisplay, DefaultScreen(xGlobalDisplay), attrib, &count);
2302 if(oglDisplay.pixmap)
2304 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2305 oglDisplay.pixmap = None;
2307 if(oglDisplay.shapePixmap)
2309 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
2310 oglDisplay.shapePixmap = None;
2313 // Free Shared Memory Pixmap
2314 if(oglDisplay.image)
2316 if(oglDisplay.shminfoShape.shmid != -1)
2318 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
2319 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2320 shmdt(oglDisplay.shminfo.shmaddr);
2321 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
2323 XDestroyImage(oglDisplay.image);
2324 oglDisplay.image = None;
2326 if(oglDisplay.shapeImage)
2328 if(oglDisplay.shminfoShape.shmid != -1)
2330 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
2331 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2332 shmdt(oglDisplay.shminfoShape.shmaddr);
2333 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
2335 XDestroyImage(oglDisplay.shapeImage);
2336 oglDisplay.shapeImage = None;
2339 if(oglDisplay.windowPicture)
2340 XRenderFreePicture(xGlobalDisplay, oglDisplay.windowPicture);
2341 if(oglDisplay.pixmapPicture)
2342 XRenderFreePicture(xGlobalDisplay, oglDisplay.pixmapPicture);
2344 if(oglDisplay.pixmap)
2345 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2347 if(oglDisplay.glContext)
2348 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
2349 if(oglDisplay.pBuffer)
2350 glXDestroyPbuffer(xGlobalDisplay, oglDisplay.pBuffer);
2352 oglDisplay.pBuffer = glXCreatePbuffer(xGlobalDisplay, config[0], PBattrib);
2353 if(oglDisplay.pBuffer)
2355 oglDisplay.glContext = glXCreateNewContext(xGlobalDisplay, config[0], GLX_RGBA_TYPE, oglSystem.glContext, True);
2356 if(oglDisplay.glContext)
2358 glXMakeCurrent(xGlobalDisplay, None, null);
2359 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2361 // Initialize Shared Memory Pixmap
2362 oglDisplay.image = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 32,
2363 ZPixmap, null, &oglDisplay.shminfo, width, height);
2364 if(oglDisplay.image)
2366 oglDisplay.shminfo.shmid = shmget(IPC_PRIVATE,
2367 oglDisplay.image->bytes_per_line * oglDisplay.image->height, IPC_CREAT|0777);
2368 if(oglDisplay.shminfo.shmid != -1)
2370 oglDisplay.shminfo.shmaddr = shmat(oglDisplay.shminfo.shmid, 0, 0);
2371 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2373 oglDisplay.shminfo.readOnly = False;
2374 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfo))
2376 oglDisplay.pixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfo.shmaddr,
2377 &oglDisplay.shminfo, width, height, 32);
2379 // Initialize Shared Memory Shape Pixmap
2380 oglDisplay.shapeImage = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 1,
2381 ZPixmap, null, &oglDisplay.shminfoShape, width, height);
2382 if(oglDisplay.shapeImage)
2384 oglDisplay.shminfoShape.shmid = shmget(IPC_PRIVATE,
2385 oglDisplay.shapeImage->bytes_per_line * oglDisplay.shapeImage->height, IPC_CREAT|0777);
2386 if(oglDisplay.shminfoShape.shmid != -1)
2388 oglDisplay.shminfoShape.shmaddr = shmat(oglDisplay.shminfoShape.shmid, 0, 0);
2389 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2391 oglDisplay.shminfoShape.readOnly = False;
2392 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfoShape))
2394 oglDisplay.shapePixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfoShape.shmaddr,
2395 &oglDisplay.shminfoShape, width, height, 1);
2396 //oglDisplay.shapePixmap = XCreatePixmap(xGlobalDisplay, (X11Window)display.window, width, height, 1);
2399 XRenderPictureAttributes attributes = { 0 };
2400 XRenderPictFormat * format = XRenderFindStandardFormat(xGlobalDisplay, /*PictStandardRGB24*/ PictStandardARGB32);
2401 #if !defined(__APPLE__) && !defined(__OLDX__)
2402 attributes.repeat = RepeatNormal;
2404 attributes.repeat = 1;
2406 oglDisplay.pixmapPicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.pixmap, format, CPRepeat, &attributes);
2407 oglDisplay.windowPicture = XRenderCreatePicture(xGlobalDisplay, (X11Window)display.window, format, 0, &attributes);
2408 oglDisplay.shapePicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.shapePixmap,
2409 XRenderFindStandardFormat(xGlobalDisplay, PictStandardA1), 0, &attributes);
2412 oglDisplay.picture = oglDisplay.shminfo.shmaddr;
2413 oglDisplay.stride = oglDisplay.image->bytes_per_line / 4;
2430 CreateDisplay(display);
2431 #if defined(__WIN32__)
2432 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2433 #elif defined(__unix__) || defined(__APPLE__)
2434 #if defined(__ANDROID__) || defined(__ODROID__)
2438 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2445 if(!result && display.alphaBlend)
2447 printf("Alpha blending windows not supported on this display\n");
2454 glViewport(0,0,width,height);
2456 glOrtho(0,width,height,0,0.0,1.0);
2457 displayWidth = display.width = width;
2458 displayHeight = display.height = height;
2460 if(!oglDisplay.flippingBuffer || oglDisplay.flipBufW < width || oglDisplay.flipBufH < height)
2462 oglDisplay.flipBufW = width;
2463 oglDisplay.flipBufH = height;
2467 oglDisplay.flippingBuffer = renew oglDisplay.flippingBuffer ColorAlpha [width * height];
2470 if(oglDisplay.flippingBuffer || !width || !height)
2476 void DisplayPosition(Display display, int x, int y)
2478 OGLDisplay oglDisplay = display.driverData;
2484 void SetPalette(Display display, ColorAlpha * palette, bool colorMatch)
2488 void RestorePalette(Display display)
2492 void StartUpdate(Display display)
2496 void EndUpdate(Display display)
2500 void Scroll(Display display, Box scroll, int x, int y, Extent dirty)
2504 void Update(Display display, Box updateBox)
2506 #if defined(__WIN32__) || defined(USEPBUFFER)
2507 OGLDisplay oglDisplay = display.driverData;
2509 //Logf("DisplayScreen\n");
2513 #if defined(__WIN32__) || defined(USEPBUFFER)
2514 if(display.alphaBlend)
2516 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2517 glPixelStorei(GL_PACK_ROW_LENGTH, oglDisplay.stride);
2518 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2519 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2520 glReadPixels(0,0,display.width,display.height,GL_BGRA_EXT,GL_UNSIGNED_BYTE, oglDisplay.picture);
2523 #if defined(__WIN32__)
2525 POINT point = { oglDisplay.x, oglDisplay.y};
2526 POINT srcPoint = { 0, 0 };
2527 BLENDFUNCTION blend = { 0 };
2529 size.cx = display.width;
2530 size.cy = display.height;
2531 blend.BlendOp = AC_SRC_OVER;
2532 blend.BlendFlags = 0;
2533 blend.SourceConstantAlpha = 255;
2534 blend.AlphaFormat = AC_SRC_ALPHA;
2537 // Process partial images. Mapping the buffer waits for
2538 // outstanding DMA transfers into the buffer to finish.
2539 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2540 oglDisplay.pboMemory1 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY);
2542 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2543 // oglDisplay.pboMemory2 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB,GL_READ_ONLY);
2546 memcpy(oglDisplay.picture, oglDisplay.pboMemory1, display.width * display.height * 4);
2547 //memcpy(oglDisplay.picture + display.width * display.height * 4 / 2, oglDisplay.pboMemory2, display.width * display.height * 4/ 2);
2550 UpdateLayeredWindow(display.window, hdc, &point, &size, oglDisplay.memDC, &srcPoint, 0, &blend, ULW_ALPHA);
2553 // Unmap the image buffers
2554 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2555 glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2557 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2558 // glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2560 // Bind two different buffer objects and start the glReadPixels
2561 // asynchronously. Each call will return directly after
2562 // starting the DMA transfer.
2563 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2564 glReadPixels(0, 0, display.width, display.height, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2566 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2567 // glReadPixels(0, display.height/2, display.width, display.height/2, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2571 #elif defined(__unix__) || defined(__APPLE__)
2572 #if defined(__ANDROID__) || defined(__ODROID__)
2574 XTransform transform =
2577 { (int)(1.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(0 * (1 << 16)) },
2578 { (int)(0.0f), (int)(-1.0f * (1<<16)), (int)(0 * (1<<16)) },
2579 { (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)) }
2582 XRenderSetPictureTransform(xGlobalDisplay, oglDisplay.pixmapPicture, &transform);
2583 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.shapePicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2584 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.windowPicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2585 #if !defined(__APPLE__) && !defined(__OLDX__)
2586 XShapeCombineMask(xGlobalDisplay, (X11Window)display.window, ShapeInput, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2588 XShapeCombineMask(xGlobalDisplay, display.window, 2, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2590 XFlush(xGlobalDisplay);
2598 #if defined(__WIN32__)
2599 //wglSwapLayerBuffers(oglDisplay.hdc,WGL_SWAP_MAIN_PLANE);
2600 SwapBuffers(oglDisplay.hdc);
2601 #elif defined(__unix__) || defined(__APPLE__)
2602 #if defined(__ANDROID__) || defined(__ODROID__)
2603 eglSwapBuffers(eglDisplay, eglSurface);
2605 glXSwapBuffers(xGlobalDisplay, (GLXDrawable)display.window);
2609 //Logf("Out of DisplayScreen\n");
2612 void FreeBitmap(DisplaySystem displaySystem, Bitmap bitmap)
2614 if(bitmap.driverData)
2616 GLuint tex = (GLuint)(uintptr)bitmap.driverData;
2617 glDeleteTextures(1, &tex);
2618 bitmap.driverData = 0;
2620 bitmap.driver = ((subclass(DisplayDriver))class(LFBDisplayDriver));
2623 bool AllocateBitmap(DisplaySystem displaySystem, Bitmap bitmap, int width, int height, int stride, PixelFormat format, bool allocatePalette)
2625 OGLSystem oglSystem = displaySystem.driverData;
2626 bool result = false;
2628 GLuint glBitmap = 0;
2630 uint w = width, h = height;
2631 if(oglSystem.pow2textures)
2636 w = Min(w, oglSystem.maxTextureSize);
2637 h = Min(h, oglSystem.maxTextureSize);
2639 glGenTextures(1, &glBitmap);
2640 glBindTexture(GL_TEXTURE_2D, glBitmap);
2642 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2644 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2645 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2647 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2648 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2650 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2652 mipMap.Allocate(null, w, h, w, pixelFormatRGBA, false);
2654 // glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2655 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2659 bitmap.driverData = (void *)(uintptr)glBitmap;
2660 bitmap.driver = displaySystem.driver;
2668 bool MakeDDBitmap(DisplaySystem displaySystem, Bitmap bitmap, bool mipMaps)
2670 bool result = false;
2671 OGLSystem oglSystem = displaySystem.driverData;
2673 // Pre process the bitmap... First make it 32 bit
2674 if(/*bitmap.pixelFormat == pixelFormatRGBA || */bitmap.Convert(null, pixelFormat888, null))
2677 uint w = bitmap.width, h = bitmap.height;
2678 GLuint glBitmap = 0;
2679 if(oglSystem.pow2textures)
2684 w = Min(w, oglSystem.maxTextureSize);
2685 h = Min(h, oglSystem.maxTextureSize);
2689 while(w * 2 < h) w *= 2;
2690 while(h * 2 < w) h *= 2;
2693 // Switch ARGB to RGBA
2694 //if(bitmap.format != pixelFormatRGBA)
2696 for(c=0; c<bitmap.size; c++)
2698 // ((ColorRGBA *)bitmap.picture)[c] = ((ColorAlpha *)bitmap.picture)[c];
2700 ColorAlpha color = ((ColorAlpha *)bitmap.picture)[c];
2701 ((ColorRGBA *)bitmap.picture)[c] = ColorRGBA { color.color.r, color.color.g, color.color.b, color.a };
2704 bitmap.pixelFormat = pixelFormat888;
2707 glGenTextures(1, &glBitmap);
2710 //int error = glGetError();
2714 glBindTexture(GL_TEXTURE_2D, glBitmap);
2715 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2717 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, mipMaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
2718 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2720 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2722 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
2723 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
2725 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2726 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2728 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2732 for(level = 0; result && (w >= 1 || h >= 1); level++, w >>= 1, h >>= 1)
2737 if(bitmap.width != w || bitmap.height != h)
2739 mipMap = Bitmap { };
2740 if(mipMap.Allocate(null, w, h, w, bitmap.pixelFormat, false))
2742 Surface mipSurface = mipMap.GetSurface(0,0,null);
2743 mipSurface.Filter(bitmap, 0,0,0,0, w, h, bitmap.width, bitmap.height);
2760 // glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2761 glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2762 //printf("Calling glTexImage2D\n");
2763 //glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &width);
2764 //printf("width = %d (Should be %d, %d)\n", width, w, h);
2765 if((error = glGetError()))
2767 //Logf("OpenGL Bitmap MakeDD error: %d...\n", error);
2768 //printf("OpenGL Bitmap MakeDD error: %d...\n", error);
2772 if(mipMap != bitmap)
2777 if(!bitmap.keepData)
2778 bitmap.driver.FreeBitmap(bitmap.displaySystem, bitmap);
2779 bitmap.driverData = (void *)(uintptr)glBitmap;
2780 bitmap.driver = displaySystem.driver;
2783 FreeBitmap(displaySystem, bitmap);
2784 else if(oglSystem.loadingFont)
2786 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2787 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2788 oglSystem.loadingFont = false;
2794 void ReleaseSurface(Display display, Surface surface)
2796 glDisable(GL_SCISSOR_TEST);
2797 delete surface.driverData;
2798 surface.driverData = null;
2801 bool GetBitmapSurface(DisplaySystem displaySystem, Surface surface, Bitmap bitmap, int x, int y, Box clip)
2806 bool GetSurface(Display display, Surface surface, int x,int y, Box clip)
2808 bool result = false;
2809 OGLSurface oglSurface = surface.driverData = OGLSurface { };
2811 //Logf("GetSurface\n");
2815 if(displayWidth != display.width || displayHeight != display.height)
2817 displayWidth = display.width;
2818 displayHeight = display.height;
2820 glViewport(0,0,display.width,display.height);
2822 glOrtho(0,display.width,display.height,0,0.0,1.0);
2825 surface.offset.x = x;
2826 surface.offset.y = y;
2827 surface.unclippedBox = surface.box = clip;
2828 oglSurface.bitmapMult[0] = 1;
2829 oglSurface.bitmapMult[1] = 1;
2830 oglSurface.bitmapMult[2] = 1;
2831 oglSurface.bitmapMult[3] = 1;
2833 glEnable(GL_SCISSOR_TEST);
2836 (display.height) -(y+clip.bottom)-1,
2837 clip.right-clip.left+1,
2838 clip.bottom-clip.top+1);
2844 void Clip(Display display, Surface surface, Box clip)
2853 box.Clip(surface.unclippedBox);
2857 box = surface.box = surface.unclippedBox;
2858 box.left += surface.offset.x;
2859 box.top += surface.offset.y;
2860 box.right+= surface.offset.x;
2861 box.bottom += surface.offset.y;
2864 box.left,display.height - box.bottom - 1,
2865 box.right-box.left+1, box.bottom-box.top+1);
2868 bool GrabScreen(Display display, Bitmap bitmap, int x, int y, unsigned int w, unsigned int h)
2870 bool result = false;
2871 OGLDisplay oglDisplay = display.driverData;
2872 ColorAlpha * flippingBuffer = oglDisplay.flippingBuffer;
2874 if(oglDisplay.flippingBuffer)
2876 if(bitmap.pixelFormat != pixelFormat888 || bitmap.width < w || bitmap.height < h)
2879 bitmap.Allocate(null, w,h,w, pixelFormat888, false);
2885 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2886 glPixelStorei(GL_PACK_ROW_LENGTH, bitmap.stride);
2887 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2888 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2889 glReadPixels(x,display.height-h-y,w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, flippingBuffer);
2892 for(row = 0; row<h; row++)
2893 CopyBytesBy4(((ColorAlpha *)bitmap.picture) + row * w, ((ColorAlpha *)flippingBuffer) + (h-row-1) * w, w);
2900 void SetForeground(Display display, Surface surface, ColorAlpha color)
2902 OGLSurface oglSurface = surface.driverData;
2904 //Logf("SetForeground\n");
2906 oglSurface.foreground[0] = color.color.r/255.0f;
2907 oglSurface.foreground[1] = color.color.g/255.0f;
2908 oglSurface.foreground[2] = color.color.b/255.0f;
2909 //oglSurface.foreground[3] = 1.0f;
2910 oglSurface.foreground[3] = color.a/255.0f;
2912 //if(!oglSurface.foreground[3])printf("bug");
2915 void SetBackground(Display display, Surface surface, ColorAlpha color)
2917 OGLSurface oglSurface = surface.driverData;
2919 //Logf("SetBackground\n");
2921 oglSurface.background[0] = color.color.r/255.0f;
2922 oglSurface.background[1] = color.color.g/255.0f;
2923 oglSurface.background[2] = color.color.b/255.0f;
2924 //oglSurface.background[3] = 1.0;
2925 oglSurface.background[3] = color.a/255.0f;
2928 void SetBlitTint(Display display, Surface surface, ColorAlpha color)
2930 OGLSurface oglSurface = surface.driverData;
2932 oglSurface.bitmapMult[0] = color.color.r/255.0f;
2933 oglSurface.bitmapMult[1] = color.color.g/255.0f;
2934 oglSurface.bitmapMult[2] = color.color.b/255.0f;
2935 oglSurface.bitmapMult[3] = color.a/255.0f;
2938 ColorAlpha GetPixel(Display display, Surface surface,int x,int y)
2943 void PutPixel(Display display, Surface surface,int x,int y)
2945 OGLSurface oglSurface = surface.driverData;
2947 //Logf("PutPixel\n");
2949 glColor4fv(oglSurface.foreground);
2951 // glVertex2i(x+surface.offset.x, y+surface.offset.y);
2952 glVertex2f(x+surface.offset.x + 0.5f, y+surface.offset.y + 0.5f);
2957 void DrawLine(Display display, Surface surface, int _x1, int _y1, int _x2, int _y2)
2959 OGLSurface oglSurface = surface.driverData;
2960 float x1 = _x1, x2 = _x2, y1 = _y1, y2 = _y2;
2975 x1 += surface.offset.x;
2976 y1 += surface.offset.y;
2977 x2 += surface.offset.x;
2978 y2 += surface.offset.y;
2982 glColor4fv(oglSurface.foreground);
2987 glTexCoord2f(0.5f, 0);
2988 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2989 glTexCoord2f(Max(x2-x1, y2-y1) + 0.5f, 0);
2990 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2999 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3000 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3006 void Rectangle(Display display, Surface surface,int x1,int y1,int x2,int y2)
3008 OGLSurface oglSurface = surface.driverData;
3009 x1 += surface.offset.x;
3010 y1 += surface.offset.y;
3011 x2 += surface.offset.x;
3012 y2 += surface.offset.y;
3014 //Logf("Rectangle\n");
3016 glColor4fv(oglSurface.foreground);
3022 glTexCoord2f(0.5f, 0);
3023 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3024 glTexCoord2f(y2-y1 + 0.5f, 0);
3025 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3027 glTexCoord2f(0.5f, 0);
3028 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3029 glTexCoord2f(x2 - x1 + 0.5f, 0);
3030 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3032 glTexCoord2f(0.5f, 0);
3033 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3034 glTexCoord2f(y1 - y2 + 0.5f, 0);
3035 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3037 glTexCoord2f(0.5f, 0);
3038 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3039 glTexCoord2f(x1 - x2 + 0.5f, 0);
3040 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3045 glBegin(GL_LINE_LOOP);
3052 glVertex2f(x1 + 0.5f, y1 + 0.5f);
3053 glVertex2f(x1 + 0.5f, y2 + 0.5f);
3054 glVertex2f(x2 + 0.5f, y2 + 0.5f);
3055 glVertex2f(x2 + 0.5f, y1 + 0.5f);
3060 void Area(Display display, Surface surface,int x1,int y1,int x2,int y2)
3062 OGLSurface oglSurface = surface.driverData;
3065 glColor4fv(oglSurface.background);
3066 glRecti(x1+surface.offset.x, y1+surface.offset.y,
3067 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
3070 glRectf(x1+surface.offset.x, y1+surface.offset.y,
3071 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
3075 void Clear(Display display, Surface surface, ClearType type)
3077 OGLDisplay oglDisplay = display.driverData;
3078 OGLSurface oglSurface = surface.driverData;
3081 if(type != depthBuffer)
3082 glClearColor(oglSurface.background[0], oglSurface.background[1], oglSurface.background[2], oglSurface.background[3]);
3083 if(type != colorBuffer && !oglDisplay.depthWrite)
3085 glDepthMask((byte)bool::true);
3087 glClear(((type != depthBuffer) ? GL_COLOR_BUFFER_BIT : 0) |
3088 ((type != colorBuffer) ? GL_DEPTH_BUFFER_BIT : 0));
3089 if(type != colorBuffer && !oglDisplay.depthWrite)
3091 glDepthMask((byte)bool::false);
3095 bool ConvertBitmap(DisplaySystem displaySystem, Bitmap bitmap, PixelFormat format, ColorAlpha * palette)
3100 void Blit(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3102 OGLSurface oglSurface = surface.driverData;
3104 #if !defined(__OLDX__)
3105 // WHY DO WE HAVE GL_ONE HERE ?
3106 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3107 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3110 if(!oglSurface.writingText)
3112 // glTranslatef(-0.375f, -0.375f, 0.0f);
3113 glEnable(GL_TEXTURE_2D);
3114 glColor4fv(oglSurface.bitmapMult);
3116 else if(oglSurface.xOffset)
3117 glTranslated(oglSurface.xOffset / 64.0/*-0.375*/, 0.0, 0.0);
3119 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3124 glTexCoord2f((float)sx/ bitmap.width, (float)(sy-h)/ bitmap.height);
3125 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3126 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy-h)/ bitmap.height);
3127 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3128 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3129 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
3130 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3131 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3136 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3137 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3138 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3139 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3140 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3141 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3142 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3143 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3146 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
3147 glVertex2f((float)dx+surface.offset.x, (float)dy+surface.offset.y);
3148 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
3149 glVertex2f((float)dx+w+surface.offset.x, (float)dy+surface.offset.y);
3150 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
3151 glVertex2f((float)dx+w+surface.offset.x, (float)dy+h+surface.offset.y);
3152 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
3153 glVertex2f((float)dx+surface.offset.x, (float)dy+h+surface.offset.y);
3157 if(!oglSurface.writingText)
3159 glDisable(GL_TEXTURE_2D);
3161 //glTranslate(0.375, 0.375, 0.0);
3163 else if(oglSurface.xOffset)
3164 glTranslated(-oglSurface.xOffset / 64.0/*+0.375*/, 0.0, 0.0);
3166 #if !defined(__OLDX__)
3167 /*if(glBlendFuncSeparate && !oglSurface.writingText)
3168 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3172 void Stretch(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3174 OGLSurface oglSurface = surface.driverData;
3176 //glTranslate(-0.375, -0.375, 0.0);
3178 //Logf("Stretch\n");
3180 #if !defined(__OLDX__)
3181 /*if(glBlendFuncSeparate)
3182 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3185 glEnable(GL_TEXTURE_2D);
3186 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
3188 glColor4fv(oglSurface.bitmapMult);
3194 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3195 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3197 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3198 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3200 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3201 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
3203 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3204 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
3208 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
3209 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
3211 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
3212 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
3214 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
3215 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
3217 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
3218 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
3223 glDisable(GL_TEXTURE_2D);
3225 //glTranslate(0.375, 0.375, 0.0);
3226 #if !defined(__OLDX__)
3227 /*if(glBlendFuncSeparate)
3228 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
3233 void Filter(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3235 Stretch(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3238 void StretchDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3240 float s2dw,s2dh,d2sw,d2sh;
3241 //bool flipX = false, flipY = false;
3243 //Logf("StretchDI\n");
3245 if(Sgn(w) != Sgn(sw))
3251 if(Sgn(h) != Sgn(sh))
3263 //Clip against the edges of the source
3266 dx+=(int)((0-sx) * s2dw);
3267 w-=(int)((0-sx) * s2dw);
3273 dy+=(int)((0-sy) * s2dh);
3274 h-=(int)((0-sy) * s2dh);
3279 if(sx+sw>bitmap.width-1)
3281 w-=(int)((sx+sw-(bitmap.width-1)-1)*s2dw);
3282 sw-=sx+sw-(bitmap.width-1)-1;
3284 if(sy+sh>(bitmap.height-1))
3286 h-=(int)((sy+sh-(bitmap.height-1)-1)*s2dh);
3287 sh-=sy+sh-(bitmap.height-1)-1;
3289 //Clip against the edges of the surfaceination
3290 if(dx<surface.box.left)
3293 sx+=(int)((surface.box.left-dx)*d2sw);
3294 sw-=(int)((surface.box.left-dx)*d2sw);
3295 w-=surface.box.left-dx;
3296 dx=surface.box.left;
3298 if(dy<surface.box.top)
3300 sy+=(int)((surface.box.top-dy)*d2sh);
3301 sh-=(int)((surface.box.top-dy)*d2sh);
3302 h-=surface.box.top-dy;
3305 if(dx+w>surface.box.right)
3307 //if(flip) sx+=(int)((dx+w-surface.box.right-1)*d2sw);
3308 sw-=(int)((dx+w-surface.box.right-1)*d2sw);
3309 w-=dx+w-surface.box.right-1;
3311 if(dy+h>surface.box.bottom)
3313 sh-=(int)((dy+h-surface.box.bottom-1)*d2sh);
3314 h-=dy+h-surface.box.bottom-1;
3316 if((w<=0)||(h<=0)||(sw<=0)||(sh<=0)) return;
3318 dx += surface.offset.x;
3319 dy += surface.offset.y;
3321 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3323 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3324 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3325 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3326 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3327 glRasterPos2d(dx,dy);
3328 //glPixelZoom(flipX ? -s2dw : s2dw, flipY ? s2dh : -s2dh);
3329 glPixelZoom(s2dw, -s2dh);
3330 glDrawPixels(sw,sh,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3331 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3332 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3333 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3334 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3338 void BlitDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3342 //Clip against the edges of the source
3355 if(sx+w>bitmap.width-1)
3356 w-=sx+w-(bitmap.width-1)-1;
3357 if(sy+h>bitmap.height-1)
3358 h-=sy+h-(bitmap.height-1)-1;
3359 //Clip against the edges of the surfaceination
3360 if(dx<surface.box.left)
3363 sx+=surface.box.left-dx;
3364 w-=surface.box.left-dx;
3365 dx=surface.box.left;
3367 if(dy<surface.box.top)
3369 sy+=surface.box.top-dy;
3370 h-=surface.box.top-dy;
3373 if(dx+w>surface.box.right)
3375 //if(flip) sx+=dx+w-surface.box.right-1;
3376 w-=dx+w-surface.box.right-1;
3378 if(dy+h>surface.box.bottom)
3379 h-=dy+h-surface.box.bottom-1;
3383 dx += surface.offset.x;
3384 dy += surface.offset.y;
3386 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3388 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3389 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3390 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3391 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3392 glRasterPos2d(dx,dy);
3394 glDrawPixels(w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3395 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3396 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3397 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3398 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3402 void FilterDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3404 StretchDI(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3407 void UnloadFont(DisplaySystem displaySystem, Font font)
3409 ((subclass(DisplayDriver))class(LFBDisplayDriver)).UnloadFont(displaySystem, font);
3412 Font LoadFont(DisplaySystem displaySystem, const char * faceName, float size, FontFlags flags)
3415 OGLSystem oglSystem = displaySystem.driverData;
3416 oglSystem.loadingFont = true;
3417 font = ((subclass(DisplayDriver))class(LFBDisplayDriver)).LoadFont(displaySystem, faceName, size, flags);
3421 void FontExtent(DisplaySystem displaySystem, Font font, const char * text, int len, int * width, int * height)
3423 ((subclass(DisplayDriver))class(LFBDisplayDriver)).FontExtent(displaySystem, font, text, len, width, height);
3426 void WriteText(Display display, Surface surface, int x, int y, const char * text, int len)
3428 OGLSurface oglSurface = surface.driverData;
3429 OGLSystem oglSystem = display.displaySystem.driverData;
3430 oglSystem.loadingFont = true;
3432 //glTranslated(-0.375, -0.375, 0.0);
3436 if(surface.textOpacity)
3439 FontExtent(display.displaySystem, surface.font, text, len, &w, &h);
3440 display.displaySystem.driver.Area(display, surface,x,y,x+w-1,y+h-1);
3443 oglSurface.writingText = true;
3445 glEnable(GL_TEXTURE_2D);
3446 glColor4fv(oglSurface.foreground);
3448 ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x, y, text, len);
3449 oglSurface.writingText = false;
3450 oglSystem.loadingFont = false;
3452 glDisable(GL_TEXTURE_2D);
3454 //glTranslated(0.375, 0.375, 0.0);
3457 void TextFont(Display display, Surface surface, Font font)
3459 ((subclass(DisplayDriver))class(LFBDisplayDriver)).TextFont(display, surface, font);
3462 void TextOpacity(Display display, Surface surface, bool opaque)
3464 OGLSurface oglSurface = surface.driverData;
3465 oglSurface.opaqueText = opaque;
3468 void TextExtent(Display display, Surface surface, const char * text, int len, int * width, int * height)
3470 OGLSurface oglSurface = surface.driverData;
3471 OGLSystem oglSystem = display.displaySystem.driverData;
3472 oglSystem.loadingFont = true;
3473 FontExtent(display.displaySystem, oglSurface.font, text, len, width, height);
3474 oglSystem.loadingFont = false;
3477 void DrawingChar(Display display, Surface surface, char character)
3482 void LineStipple(Display display, Surface surface, uint32 stipple)
3484 //Logf("Stipple\n");
3489 stippleEnabled = true;
3490 glesLineStipple(1, (uint16)stipple);
3492 glLineStipple(1, (uint16)stipple);
3493 glEnable(GL_LINE_STIPPLE);
3499 stippleEnabled = false;
3500 glMatrixMode(GL_TEXTURE);
3502 glMatrixMode(GL_PROJECTION);
3503 glDisable(GL_TEXTURE_2D);
3505 glDisable(GL_LINE_STIPPLE);
3509 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
3510 void SetRenderState(Display display, RenderState state, uint value)
3512 OGLDisplay oglDisplay = display.driverData;
3513 //Logf("RenderState\n");
3519 glEnable(GL_MULTISAMPLE_ARB);
3521 glDisable(GL_MULTISAMPLE_ARB);
3525 glPolygonMode(GL_FRONT_AND_BACK, ((FillModeValue)value == solid) ? GL_FILL : GL_LINE);
3529 if(value) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
3532 if(value) glDepthMask((byte)bool::true); else glDepthMask((byte)bool::false);
3533 oglDisplay.depthWrite = (bool)value;
3537 float color[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3538 glFogfv(GL_FOG_COLOR, (float *)&color);
3542 glFogf(GL_FOG_DENSITY, (float)(RenderStateFloat { ui = value }.f * nearPlane));
3545 if(value) glEnable(GL_BLEND); else glDisable(GL_BLEND);
3549 float ambient[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3550 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
3555 if(value) glColorMask(1,1,1,1); else glColorMask(1,1,1,0);
3560 #if defined(__WIN32__)
3561 wglSwapIntervalEXT(value ? 1 : 0);
3568 void SetLight(Display display, int id, Light light)
3570 //Logf("SetLight\n");
3574 Object lightObject = light.lightObject;
3575 float position[4] = { 0, 0, 0, 0 };
3576 float color[4] = { 0, 0, 0, 1 };
3578 glEnable(GL_LIGHT0 + id);
3580 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, (float *)&light.diffuse);
3581 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, (float *)&light.ambient);
3582 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,(float *)&light.specular);
3585 if(!light.multiplier) light.multiplier = 1.0f;
3587 color[0] = light.diffuse.r * light.multiplier;
3588 color[1] = light.diffuse.g * light.multiplier;
3589 color[2] = light.diffuse.b * light.multiplier;
3590 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, color);
3592 color[0] = light.ambient.r * light.multiplier;
3593 color[1] = light.ambient.g * light.multiplier;
3594 color[2] = light.ambient.b * light.multiplier;
3595 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, color);
3596 color[0] = light.specular.r * light.multiplier;
3597 color[1] = light.specular.g * light.multiplier;
3598 color[2] = light.specular.b * light.multiplier;
3599 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,color);
3603 Vector3D positionVector;
3604 if(light.flags.spot)
3606 if(lightObject.flags.root || !lightObject.parent)
3608 positionVector = lightObject.transform.position;
3609 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3613 positionVector.MultMatrix(lightObject.transform.position, lightObject.parent.matrix);
3614 if(display.display3D.camera)
3615 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3621 if(!light.direction.x && !light.direction.y && !light.direction.z)
3623 Vector3Df vector { 0,0,-1 };
3625 mat.RotationQuaternion(light.orientation);
3626 positionVector.MultMatrixf(vector, mat);
3630 positionVector = light.direction;
3635 position[0] = (float)positionVector.x;
3636 position[1] = (float)positionVector.y;
3637 position[2] = (float)positionVector.z;
3639 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3642 // Display Light Position
3643 glDisable(GL_LIGHTING);
3644 glDisable(GL_DEPTH_TEST);
3648 glVertex3fv(position);
3650 glEnable(GL_DEPTH_TEST);
3651 glEnable(GL_LIGHTING);
3655 if(lightObject.flags.root || !lightObject.parent)
3657 positionVector = light.target.transform.position;
3658 positionVector.Subtract(positionVector, display.camera.cPosition);
3662 positionVector.MultMatrix(light.target.transform.position,
3663 lightObject.light.target.parent.matrix);
3664 positionVector.Subtract(positionVector, display.camera.cPosition);
3667 position[0] = positionVector.x;
3668 position[1] = positionVector.y;
3669 position[2] = positionVector.z;
3671 glDisable(GL_LIGHTING);
3672 glDisable(GL_DEPTH_TEST);
3676 glVertex3fv(position);
3678 glEnable(GL_DEPTH_TEST);
3679 glEnable(GL_LIGHTING);
3682 if(light.flags.attenuation)
3684 glLightf(GL_LIGHT0 + id, GL_CONSTANT_ATTENUATION, light.Kc);
3685 glLightf(GL_LIGHT0 + id, GL_LINEAR_ATTENUATION, light.Kl);
3686 glLightf(GL_LIGHT0 + id, GL_QUADRATIC_ATTENUATION, light.Kq);
3689 if(light.flags.spot)
3692 #define MAXLIGHT 0.9
3693 float direction[4] = { (float)light.direction.x, (float)light.direction.y, (float)light.direction.z, 1 };
3694 // Figure out exponent out of the hot spot
3695 exponent = (float)(log(MAXLIGHT) / log(cos((light.hotSpot / 2))));
3697 glLightfv(GL_LIGHT0 + id, GL_SPOT_DIRECTION, direction);
3698 glLightf(GL_LIGHT0 + id, GL_SPOT_CUTOFF, (float)(light.fallOff / 2));
3699 glLightf(GL_LIGHT0 + id, GL_SPOT_EXPONENT, exponent);
3705 Vector3Df vector { 0,0,-1 };
3706 Vector3Df direction;
3709 mat.RotationQuaternion(light.orientation);
3710 direction.MultMatrix(vector, mat);
3712 position[0] = direction.x;
3713 position[1] = direction.y;
3714 position[2] = direction.z;
3716 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3720 glDisable(GL_LIGHT0 + id);
3723 void SetCamera(Display display, Surface surface, Camera camera)
3725 OGLDisplay oglDisplay = display.driverData;
3726 //Logf("SetCamera\n");
3730 int left = surface.box.left + surface.offset.x;
3731 int top = surface.box.top + surface.offset.y;
3732 int right = surface.box.right + surface.offset.x;
3733 int bottom = surface.box.bottom + surface.offset.y;
3734 float origX = surface.offset.x + camera.origin.x;
3735 float origY = surface.offset.y + camera.origin.y;
3737 int y = display.height - bottom - 1;
3738 int w = right - left + 1;
3739 int h = bottom - top + 1;
3742 glViewport(x, y, w, h);
3744 // *** Projection Matrix ***
3745 if(!display.display3D.camera)
3748 glMatrixMode(GL_PROJECTION);
3749 if(display.display3D.collectingHits)
3751 float pickX = display.display3D.pickX + surface.offset.x;
3752 float pickY = display.height - (display.display3D.pickY + surface.offset.y) - 1;
3756 w / display.display3D.pickWidth, 0, 0, 0,
3757 0, h / display.display3D.pickHeight, 0, 0,
3759 (w + 2.0f * (x - pickX)) / display.display3D.pickWidth,
3760 (h + 2.0f * (y - pickY)) / display.display3D.pickHeight, 0, 1
3763 glLoadMatrixd(pickMatrix.array);
3768 (left - origX) * camera.zMin / camera.focalX,
3769 (right - origX) * camera.zMin / camera.focalX,
3770 (bottom - origY) * camera.zMin / camera.focalY,
3771 (top - origY) * camera.zMin / camera.focalY,
3772 camera.zMin, camera.zMax);
3774 glDisable(GL_BLEND);
3776 // *** Z Inverted Identity Matrix ***
3777 glMatrixMode(GL_MODELVIEW);
3778 if(!display.display3D.camera)
3783 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
3785 // *** View Matrix ***
3786 glMultMatrixd(camera.viewMatrix.array);
3791 glEnable(GL_DEPTH_TEST);
3792 glEnable(GL_LIGHTING);
3793 glShadeModel(GL_SMOOTH);
3794 glDepthMask((byte)bool::true);
3795 oglDisplay.depthWrite = true;
3797 glEnable(GL_MULTISAMPLE_ARB);
3799 else if(display.display3D.camera)
3801 oglDisplay.depthWrite = false;
3802 glViewport(0,0,display.width,display.height);
3804 glDisable(GL_CULL_FACE);
3805 glDisable(GL_DEPTH_TEST);
3806 glDisable(GL_LIGHTING);
3808 glDisable(GL_TEXTURE_2D);
3809 glShadeModel(GL_FLAT);
3811 glDisable(GL_MULTISAMPLE_ARB);
3813 // *** Restore 2D MODELVIEW Matrix ***
3816 // *** Restore 2D PROJECTION Matrix ***
3817 glMatrixMode(GL_PROJECTION);
3823 void ApplyMaterial(Display display, Material material, Mesh mesh)
3825 //Logf("ApplyMaterial\n");
3828 if(material.flags.doubleSided)
3830 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, !material.flags.singleSideLight);
3831 glDisable(GL_CULL_FACE);
3835 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, bool::false);
3836 glEnable(GL_CULL_FACE);
3840 if(material.flags.noFog)
3846 if(material.baseMap && (mesh.texCoords || mesh.flags.texCoords1))
3848 Bitmap map = material.baseMap;
3849 glEnable(GL_TEXTURE_2D);
3850 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)map.driverData);
3852 glMatrixMode(GL_TEXTURE);
3854 if(material.uScale && material.vScale)
3855 glScalef(material.uScale, material.vScale, 1);
3856 glMatrixMode(GL_MODELVIEW);
3858 if(material.flags.tile)
3860 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
3861 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
3865 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
3866 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
3870 glDisable(GL_TEXTURE_2D);
3872 if(mesh.flags.colors)
3874 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
3875 glEnable(GL_COLOR_MATERIAL);
3879 glDisable(GL_COLOR_MATERIAL);
3881 float color[4] = { material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity };
3882 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
3885 float color[4] = { material.ambient.r, material.ambient.g, material.ambient.b, 0 };
3886 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
3890 float color[4] = { material.specular.r, material.specular.g, material.specular.b, 0 };
3891 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, color);
3894 float color[4] = { material.emissive.r, material.emissive.g, material.emissive.b, 0 };
3895 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, color);
3898 glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &material.power);
3901 void FreeMesh(DisplaySystem displaySystem, Mesh mesh)
3903 OGLMesh oglMesh = mesh.data;
3906 if(!mesh.flags.vertices)
3908 oglMesh.vertices.free();
3909 delete mesh.vertices;
3911 if(!mesh.flags.normals)
3913 oglMesh.normals.free();
3914 delete mesh.normals;
3916 if(!mesh.flags.texCoords1)
3918 oglMesh.texCoords.free();
3919 delete mesh.texCoords;
3921 if(!mesh.flags.texCoords2)
3923 oglMesh.texCoords2.free();
3924 // delete mesh.texCoords2;
3926 if(!mesh.flags.colors)
3928 oglMesh.colors.free();
3939 bool AllocateMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags, int nVertices)
3941 bool result = false;
3944 mesh.data = OGLMesh { };
3947 if(mesh.nVertices == nVertices)
3949 // Same number of vertices, adding features (Leaves the other features pointers alone)
3950 if(mesh.flags != flags)
3952 if(!mesh.flags.vertices && flags.vertices)
3954 if(flags.doubleVertices)
3956 mesh.vertices = (Vector3Df *)new Vector3D[nVertices];
3959 mesh.vertices = new Vector3Df[nVertices];
3961 if(!mesh.flags.normals && flags.normals)
3963 if(flags.doubleNormals)
3965 mesh.normals = (Vector3Df *)new Vector3D[nVertices];
3968 mesh.normals = new Vector3Df[nVertices];
3970 if(!mesh.flags.texCoords1 && flags.texCoords1)
3972 mesh.texCoords = new Pointf[nVertices];
3974 if(!mesh.flags.colors && flags.colors)
3976 mesh.colors = new ColorRGBAf[nVertices];
3982 // New number of vertices, reallocate all current and new features
3983 flags |= mesh.flags;
3986 if(flags.doubleVertices)
3988 mesh.vertices = (Vector3Df *)renew mesh.vertices Vector3D[nVertices];
3991 mesh.vertices = renew mesh.vertices Vector3Df[nVertices];
3995 if(flags.doubleNormals)
3997 mesh.normals = (Vector3Df *)renew mesh.normals Vector3D[nVertices];
4000 mesh.normals = renew mesh.normals Vector3Df[nVertices];
4002 if(flags.texCoords1)
4004 mesh.texCoords = renew mesh.texCoords Pointf[nVertices];
4008 mesh.colors = renew mesh.colors ColorRGBAf[nVertices];
4016 void UnlockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
4018 OGLMesh oglMesh = mesh.data;
4019 if(!flags) flags = mesh.flags;
4024 oglMesh.vertices.upload(
4025 mesh.nVertices * (mesh.flags.doubleVertices ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.vertices); //, GL_STATIC_DRAW_ARB );
4028 oglMesh.normals.upload(
4029 mesh.nVertices * (mesh.flags.doubleNormals ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.normals); //, GL_STATIC_DRAW_ARB );
4031 if(flags.texCoords1)
4032 oglMesh.texCoords.upload(
4033 mesh.nVertices * sizeof(Pointf), mesh.texCoords); //, GL_STATIC_DRAW_ARB );
4036 oglMesh.colors.upload(
4037 mesh.nVertices * sizeof(ColorRGBAf), mesh.colors); //, GL_STATIC_DRAW_ARB );
4041 bool LockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
4048 void FreeIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4052 oglIndices.buffer.free();
4053 delete oglIndices.indices;
4058 void * AllocateIndices(DisplaySystem displaySystem, int nIndices, bool indices32bit)
4060 OGLIndices oglIndices = OGLIndices { };
4063 oglIndices.indices = (void *)(indices32bit ? new uint32[nIndices] : new uint16[nIndices]);
4064 oglIndices.nIndices = nIndices;
4069 void UnlockIndices(DisplaySystem displaySystem, OGLIndices oglIndices, bool indices32bit, int nIndices)
4073 oglIndices.buffer.upload(
4074 nIndices * (indices32bit ? sizeof(uint32) : sizeof(uint16)),
4075 oglIndices.indices); //GL_STATIC_DRAW_ARB);
4079 uint16 * LockIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
4082 return oglIndices.indices;
4085 void SelectMesh(Display display, Mesh mesh)
4087 //Logf("SelectMesh\n");
4089 #if !defined( __ANDROID__) && !defined(__APPLE__) && !defined(__ODROID__)
4091 #if defined(__WIN32__)
4092 if(glUnlockArraysEXT)
4094 if(!vboAvailable && display.display3D.mesh)
4095 glUnlockArraysEXT();
4100 OGLMesh oglMesh = mesh.data;
4102 // *** Vertex Stream ***
4103 glEnableClientState(GL_VERTEX_ARRAY);
4104 if(!display.display3D.collectingHits && oglMesh)
4106 oglMesh.vertices.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, oglMesh.vertices.buffer ? null : (double *)mesh.vertices);
4108 // *** Normals Stream ***
4109 if(mesh.normals || mesh.flags.normals)
4111 glEnableClientState(GL_NORMAL_ARRAY);
4112 oglMesh.normals.use(normal, 3, GL_FLOAT, 0, oglMesh.normals.buffer ? null : mesh.normals);
4115 glDisableClientState(GL_NORMAL_ARRAY);
4117 // *** Texture Coordinates Stream ***
4118 if(mesh.texCoords || mesh.flags.texCoords1)
4120 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4121 oglMesh.texCoords.use(texCoord, 2, GL_FLOAT, 0, oglMesh.texCoords.buffer ? null : mesh.texCoords);
4124 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4126 // *** Color Stream ***
4127 if(mesh.colors || mesh.flags.colors)
4129 glEnableClientState(GL_COLOR_ARRAY);
4130 oglMesh.colors.use(color, 4, GL_FLOAT, 0, oglMesh.colors.buffer ? null : mesh.colors);
4133 glDisableClientState(GL_COLOR_ARRAY);
4137 noAB.use(vertex, 3, (mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT), 0, (double *)mesh.vertices);
4138 if((mesh.normals || mesh.flags.normals) && !display.display3D.collectingHits)
4140 glEnableClientState(GL_NORMAL_ARRAY);
4141 noAB.use(normal, 3, GL_FLOAT, 0, mesh.normals);
4144 glDisableClientState(GL_NORMAL_ARRAY);
4145 if((mesh.texCoords || mesh.flags.texCoords1) && !display.display3D.collectingHits)
4147 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
4148 noAB.use(texCoord, 2, GL_FLOAT, 0, mesh.texCoords);
4151 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
4152 if((mesh.colors || mesh.flags.colors) && !display.display3D.collectingHits)
4154 glEnableClientState(GL_COLOR_ARRAY);
4155 noAB.use(color, 4, GL_FLOAT, 0, mesh.colors);
4158 glDisableClientState(GL_COLOR_ARRAY);
4161 #if !defined(__ANDROID__) && !defined(__APPLE__) && !defined(__ODROID__)
4163 #if defined(__WIN32__)
4167 glLockArraysEXT(0, mesh.nVertices);
4173 void DrawPrimitives(Display display, PrimitiveSingle * primitive, Mesh mesh)
4175 //Logf("DrawPrimitives\n");
4177 if(primitive->type.vertexRange)
4178 glDrawArrays(primitiveTypes[primitive->type.primitiveType], primitive->first, primitive->nVertices);
4181 // *** Hoping the data won't be uploaded at all (Won't really work if another group of the mesh is using the mesh ) ***
4182 // HACK TO SPEED THINGS UP...
4184 /*GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
4185 if(primitive->nIndices < (mesh.nVertices >> 2) && !primitive->type.indices32bit)
4188 glBegin(primitiveTypes[primitive->type.primitiveType]);
4191 OGLIndices oglIndices = primitive->data;
4192 MeshFeatures flags = mesh.flags;
4193 for(c = 0; c<primitive->nIndices; c++)
4195 uint16 index = ((uint16 *) oglIndices.indices)[c];
4196 if(flags.normals) glNormal3fv((float *)&mesh.normals[index]);
4197 if(flags.texCoords1) glTexCoord2fv((float *)&mesh.texCoords[index]);
4198 if(flags.colors) glColor4fv((float *)&mesh.colors[index]);
4199 glVertex3fv((float *)&mesh.vertices[index]);
4207 OGLIndices oglIndices = primitive->data;
4209 if(!display.display3D.collectingHits && vboAvailable && oglIndices)
4211 if(primitive->type.indices32bit)
4212 ; //oglIndices.buffer.draw(primitiveTypes[primitive->type.primitiveType], primitive->nIndices, GL_UNSIGNED_SHORT, 0);
4214 oglIndices.buffer.draw(primitiveTypes[primitive->type.primitiveType], primitive->nIndices, GL_UNSIGNED_SHORT, 0);
4218 if(primitive->type.indices32bit)
4219 glDrawElementsi(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
4220 oglIndices ? oglIndices.indices : primitive->indices);
4222 glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
4223 GL_UNSIGNED_SHORT, oglIndices ? oglIndices.indices : primitive->indices);
4229 void PushMatrix(Display display)
4234 void PopMatrix(Display display, bool setMatrix)
4239 void SetTransform(Display display, Matrix transMatrix, bool viewSpace, bool useCamera)
4241 Matrix matrix = transMatrix;
4242 Camera camera = useCamera ? display.display3D.camera : null;
4247 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
4252 matrix.m[3][0] - camera.cPosition.x,
4253 matrix.m[3][1] - camera.cPosition.y,
4254 matrix.m[3][2] - camera.cPosition.z);
4266 glMultMatrixd(matrix.array);
4271 public void UseSingleGLContext(bool useSingle)
4273 useSingleGLContext = useSingle;
4276 default dllexport void *
4277 #if defined(__WIN32__)
4278 __attribute__((stdcall))
4280 IS_GLGetContext(DisplaySystem displaySystem)
4284 #if defined(__WIN32__)
4285 OGLSystem system = displaySystem.driverData;
4287 #elif defined(__ANDROID__) || defined(__ODROID__)
4290 OGLSystem system = displaySystem.driverData;
4291 return system.glContext;