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
15 //#include <GL/miniglx.h>
19 #if defined(__ANDROID__)
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__)
92 #if defined(__unix__) || defined(__APPLE__)
100 static double nearPlane = 1;
102 #define glLoadMatrix glLoadMatrixd
103 #define glMultMatrix glMultMatrixd
104 #define glGetMatrix glGetDoublev
105 #define glTranslate glTranslated
106 #define glScale glScaled
109 #define glVertex3v glVertex3dv
110 #define glNormal3v glNormal3dv
114 //#ifdef VERTEX_FORMAT_DOUBLE
116 #define glLoadMatrix glLoadMatrixd
117 #define glMultMatrix glMultMatrixd
118 #define glGetMatrix glGetDoublev
119 #define glVertex3v glVertex3dv
120 #define glNormal3v glNormal3dv
121 #define glTranslate glTranslated
122 #define glScale glScaled
123 //#define GL_VERTEX_FORMAT GL_DOUBLE
127 #define glLoadMatrix glLoadMatrixf
128 #define glMultMatrix glMultMatrixf
129 #define glGetMatrix glGetFloatv
130 #define glVertex3v glVertex3fv
131 #define glNormal3v glNormal3fv
132 #define glTranslate glTranslatef
133 #define glScale glScalef
134 //#define GL_VERTEX_FORMAT GL_FLOAT
139 #define GL_ARRAY_BUFFER_ARB 0x8892
140 #define GL_ELEMENT_ARRAY_BUFFER_ARB 0x8893
141 #define GL_STATIC_DRAW_ARB 0x88E4
142 #define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8
143 #define GL_SEPARATE_SPECULAR_COLOR 0x81FA
145 #define GL_MULTISAMPLE_ARB 0x809D
147 #if defined(__WIN32__)
149 #define WGL_SAMPLE_BUFFERS_ARB 0x2041
150 #define WGL_SAMPLES_ARB 0x2042
152 #define WGL_WGLEXT_VERSION 1
153 #define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001
154 #define WGL_BACK_COLOR_BUFFER_BIT_ARB 0x00000002
155 #define WGL_DEPTH_BUFFER_BIT_ARB 0x00000004
156 #define WGL_STENCIL_BUFFER_BIT_ARB 0x00000008
157 #define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000
158 #define WGL_DRAW_TO_WINDOW_ARB 0x2001
159 #define WGL_DRAW_TO_BITMAP_ARB 0x2002
160 #define WGL_ACCELERATION_ARB 0x2003
161 #define WGL_NEED_PALETTE_ARB 0x2004
162 #define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005
163 #define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006
164 #define WGL_SWAP_METHOD_ARB 0x2007
165 #define WGL_NUMBER_OVERLAYS_ARB 0x2008
166 #define WGL_NUMBER_UNDERLAYS_ARB 0x2009
167 #define WGL_TRANSPARENT_ARB 0x200A
168 #define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037
169 #define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038
170 #define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039
171 #define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A
172 #define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B
173 #define WGL_SHARE_DEPTH_ARB 0x200C
174 #define WGL_SHARE_STENCIL_ARB 0x200D
175 #define WGL_SHARE_ACCUM_ARB 0x200E
176 #define WGL_SUPPORT_GDI_ARB 0x200F
177 #define WGL_SUPPORT_OPENGL_ARB 0x2010
178 #define WGL_DOUBLE_BUFFER_ARB 0x2011
179 #define WGL_STEREO_ARB 0x2012
180 #define WGL_PIXEL_TYPE_ARB 0x2013
181 #define WGL_COLOR_BITS_ARB 0x2014
182 #define WGL_RED_BITS_ARB 0x2015
183 #define WGL_RED_SHIFT_ARB 0x2016
184 #define WGL_GREEN_BITS_ARB 0x2017
185 #define WGL_GREEN_SHIFT_ARB 0x2018
186 #define WGL_BLUE_BITS_ARB 0x2019
187 #define WGL_BLUE_SHIFT_ARB 0x201A
188 #define WGL_ALPHA_BITS_ARB 0x201B
189 #define WGL_ALPHA_SHIFT_ARB 0x201C
190 #define WGL_ACCUM_BITS_ARB 0x201D
191 #define WGL_ACCUM_RED_BITS_ARB 0x201E
192 #define WGL_ACCUM_GREEN_BITS_ARB 0x201F
193 #define WGL_ACCUM_BLUE_BITS_ARB 0x2020
194 #define WGL_ACCUM_ALPHA_BITS_ARB 0x2021
195 #define WGL_DEPTH_BITS_ARB 0x2022
196 #define WGL_STENCIL_BITS_ARB 0x2023
197 #define WGL_AUX_BUFFERS_ARB 0x2024
198 #define WGL_NO_ACCELERATION_ARB 0x2025
199 #define WGL_GENERIC_ACCELERATION_ARB 0x2026
200 #define WGL_FULL_ACCELERATION_ARB 0x2027
201 #define WGL_SWAP_EXCHANGE_ARB 0x2028
202 #define WGL_SWAP_COPY_ARB 0x2029
203 #define WGL_SWAP_UNDEFINED_ARB 0x202A
204 #define WGL_TYPE_RGBA_ARB 0x202B
205 #define WGL_TYPE_COLORINDEX_ARB 0x202C
206 #define ERROR_INVALID_PIXEL_TYPE_ARB 0x2043
207 #define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054
208 #define WGL_DRAW_TO_PBUFFER_ARB 0x202D
209 #define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E
210 #define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F
211 #define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030
212 #define WGL_PBUFFER_LARGEST_ARB 0x2033
213 #define WGL_PBUFFER_WIDTH_ARB 0x2034
214 #define WGL_PBUFFER_HEIGHT_ARB 0x2035
215 #define WGL_PBUFFER_LOST_ARB 0x2036
216 #define ERROR_INVALID_PIXEL_TYPE_EXT 0x2043
217 #define WGL_NUMBER_PIXEL_FORMATS_EXT 0x2000
218 #define WGL_DRAW_TO_WINDOW_EXT 0x2001
219 #define WGL_DRAW_TO_BITMAP_EXT 0x2002
220 #define WGL_ACCELERATION_EXT 0x2003
221 #define WGL_NEED_PALETTE_EXT 0x2004
222 #define WGL_NEED_SYSTEM_PALETTE_EXT 0x2005
223 #define WGL_SWAP_LAYER_BUFFERS_EXT 0x2006
224 #define WGL_SWAP_METHOD_EXT 0x2007
225 #define WGL_NUMBER_OVERLAYS_EXT 0x2008
226 #define WGL_NUMBER_UNDERLAYS_EXT 0x2009
227 #define WGL_TRANSPARENT_EXT 0x200A
228 #define WGL_TRANSPARENT_VALUE_EXT 0x200B
229 #define WGL_SHARE_DEPTH_EXT 0x200C
230 #define WGL_SHARE_STENCIL_EXT 0x200D
231 #define WGL_SHARE_ACCUM_EXT 0x200E
232 #define WGL_SUPPORT_GDI_EXT 0x200F
233 #define WGL_SUPPORT_OPENGL_EXT 0x2010
234 #define WGL_DOUBLE_BUFFER_EXT 0x2011
235 #define WGL_STEREO_EXT 0x2012
236 #define WGL_PIXEL_TYPE_EXT 0x2013
237 #define WGL_COLOR_BITS_EXT 0x2014
238 #define WGL_RED_BITS_EXT 0x2015
239 #define WGL_RED_SHIFT_EXT 0x2016
240 #define WGL_GREEN_BITS_EXT 0x2017
241 #define WGL_GREEN_SHIFT_EXT 0x2018
242 #define WGL_BLUE_BITS_EXT 0x2019
243 #define WGL_BLUE_SHIFT_EXT 0x201A
244 #define WGL_ALPHA_BITS_EXT 0x201B
245 #define WGL_ALPHA_SHIFT_EXT 0x201C
246 #define WGL_ACCUM_BITS_EXT 0x201D
247 #define WGL_ACCUM_RED_BITS_EXT 0x201E
248 #define WGL_ACCUM_GREEN_BITS_EXT 0x201F
249 #define WGL_ACCUM_BLUE_BITS_EXT 0x2020
250 #define WGL_ACCUM_ALPHA_BITS_EXT 0x2021
251 #define WGL_DEPTH_BITS_EXT 0x2022
252 #define WGL_STENCIL_BITS_EXT 0x2023
253 #define WGL_AUX_BUFFERS_EXT 0x2024
254 #define WGL_NO_ACCELERATION_EXT 0x2025
255 #define WGL_GENERIC_ACCELERATION_EXT 0x2026
256 #define WGL_FULL_ACCELERATION_EXT 0x2027
257 #define WGL_SWAP_EXCHANGE_EXT 0x2028
258 #define WGL_SWAP_COPY_EXT 0x2029
259 #define WGL_SWAP_UNDEFINED_EXT 0x202A
260 #define WGL_TYPE_RGBA_EXT 0x202B
261 #define WGL_TYPE_COLORINDEX_EXT 0x202C
262 #define WGL_DRAW_TO_PBUFFER_EXT 0x202D
263 #define WGL_MAX_PBUFFER_PIXELS_EXT 0x202E
264 #define WGL_MAX_PBUFFER_WIDTH_EXT 0x202F
265 #define WGL_MAX_PBUFFER_HEIGHT_EXT 0x2030
266 #define WGL_OPTIMAL_PBUFFER_WIDTH_EXT 0x2031
267 #define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032
268 #define WGL_PBUFFER_LARGEST_EXT 0x2033
269 #define WGL_PBUFFER_WIDTH_EXT 0x2034
270 #define WGL_PBUFFER_HEIGHT_EXT 0x2035
271 #define WGL_DEPTH_FLOAT_EXT 0x2040
272 #define WGL_SAMPLE_BUFFERS_3DFX 0x2060
273 #define WGL_SAMPLES_3DFX 0x2061
274 #define WGL_SAMPLE_BUFFERS_EXT 0x2041
275 #define WGL_SAMPLES_EXT 0x2042
276 #define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044
277 #define WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D 0x2045
278 #define WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D 0x2046
279 #define WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D 0x2047
280 #define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048
281 #define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049
282 #define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A
283 #define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B
284 #define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C
285 #define WGL_GAMMA_TABLE_SIZE_I3D 0x204E
286 #define WGL_GAMMA_EXCLUDE_DESKTOP_I3D 0x204F
287 #define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050
288 #define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051
289 #define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052
290 #define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053
291 #define WGL_ARB_buffer_region 1
292 #define WGL_ARB_extensions_string 1
293 #define WGL_ARB_pixel_format 1
294 #define WGL_ARB_make_current_read 1
295 #define WGL_ARB_pbuffer 1
296 #define WGL_EXT_display_color_table 1
297 #define WGL_EXT_extensions_string 1
298 #define WGL_EXT_make_current_read 1
299 #define WGL_EXT_pbuffer 1
300 #define WGL_EXT_pixel_format 1
301 #define WGL_EXT_swap_control 1
302 #define WGL_WGL_EXT_depth_float 1
303 #define WGL_WGL_3DFX_multisample 1
304 #define WGL_WGL_EXT_multisample 1
305 #define WGL_NV_allocate_memory 1
308 typedef void (APIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum target);
309 typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);
310 typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum target);
311 typedef void (APIENTRY * PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei count);
312 typedef void (APIENTRY * PFNGLUNLOCKARRAYSEXTPROC) (void);
316 typedef int (APIENTRY * PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer);
317 typedef int (APIENTRY * PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint *buffers);
318 typedef int (APIENTRY * PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint *buffers);
319 typedef int (APIENTRY * PFNGLBUFFERDATAARBPROC) (GLenum target, int size, const GLvoid *data, GLenum usage);
321 typedef int (APIENTRY * PFNWGLCHOOSEPIXELFORMATARBPROC) ();
322 typedef void * (APIENTRY * PFNWGLCREATEPBUFFERARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
323 typedef HDC (APIENTRY * PFNWGLGETPBUFFERDCARBPROC) (void * hPbuffer);
324 typedef int (APIENTRY * PFNWGLRELEASEPBUFFERDCARBPROC) (void * hPbuffer, HDC hDC);
325 typedef BOOL (APIENTRY * PFNWGLDESTROYPBUFFERARBPROC) (void * hPbuffer);
326 typedef BOOL (APIENTRY * PFNWGLQUERYPBUFFERARBPROC) (void * hPbuffer, int iAttribute, int *piValue);
327 typedef const char * (APIENTRY * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc);
328 typedef BOOL (APIENTRY * PFNWGLBINDTEXIMAGEARBPROC) (void * hPbuffer, int iBuffer);
329 typedef BOOL (APIENTRY * PFNWGLRELEASETEXIMAGEARBPROC) (void * hPbuffer, int iBuffer);
331 static PFNGLMAPBUFFERARBPROC glMapBufferARB = null;
332 static PFNGLUNMAPBUFFERARBPROC glUnmapBufferARB = null;
333 static PFNGLACTIVETEXTUREARBPROC glActiveTextureARB = null;
334 static PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB = null;
335 static PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB = null;
336 static PFNGLLOCKARRAYSEXTPROC glLockArraysEXT = null;
337 static PFNGLUNLOCKARRAYSEXTPROC glUnlockArraysEXT = null;
338 static PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate = null;
340 static PFNGLGENBUFFERSARBPROC glGenBuffersARB = null;
341 static PFNGLBINDBUFFERARBPROC glBindBufferARB = null;
342 static PFNGLBUFFERDATAARBPROC glBufferDataARB = null;
343 static PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB = null;
344 static PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = null;
345 static PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB = null;
346 static PFNWGLCREATEPBUFFERARBPROC wglCreatePbufferARB = null;
347 static PFNWGLGETPBUFFERDCARBPROC wglGetPbufferDCARB = null;
348 static PFNWGLQUERYPBUFFERARBPROC wglQueryPbufferARB = null;
349 static PFNWGLDESTROYPBUFFERARBPROC wglDestroyPbufferARB = null;
350 static PFNWGLRELEASEPBUFFERDCARBPROC wglReleasePbufferDCARB = null;
351 static PFNWGLBINDTEXIMAGEARBPROC wglBindTexImageARB = null;
352 static PFNWGLRELEASETEXIMAGEARBPROC wglReleaseTexImageARB = null;
354 #ifdef WGL_WGLEXT_PROTOTYPES
355 extern BOOL WINAPI wglSwapIntervalEXT (int);
356 extern int WINAPI wglGetSwapIntervalEXT (void);
357 #endif /* WGL_WGLEXT_PROTOTYPES */
358 typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC) (int interval);
359 typedef int (WINAPI * PFNWGLGETSWAPINTERVALEXTPROC) (void);
361 static PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = NULL;
365 #if defined(__ANDROID__)
367 // Our own matrix stack
368 static Matrix matrixStack[3][32];
369 static int matrixIndex[3];
370 static int curStack = 0;
372 // OpenGL ES Porting Kit
374 #define glBindFramebuffer glBindFramebufferOES
375 #define glBindRenderbuffer glBindRenderbufferOES
376 #define GL_FRAMEBUFFER GL_FRAMEBUFFER_OES
377 #define GL_RENDERBUFFER GL_RENDERBUFFER_OES
378 #define glFramebufferTexture2D glFramebufferTexture2DOES
379 #define GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_OES
380 #define glGenFramebuffers glGenFramebuffersOES
381 #define glGenRenderbuffers glGenRenderbuffersOES
382 #define glDeleteFramebuffers glDeleteFramebuffersOES
383 #define glDeleteRenderbuffers glDeleteRenderbuffersOES
385 #define GL_POLYGON_STIPPLE 0xFFFF
386 #define GL_LINE_STIPPLE 0xFFFF
387 #define GL_LINE 0xFFFF
388 #define GL_FILL 0xFFFF
389 #define GL_ALL_ATTRIB_BITS 0xFFFF
390 #define GL_LIGHT_MODEL_LOCAL_VIEWER 0xFFFF
391 #define glDrawElementsi(type, count, start) glDrawElements(type, count, GL_UNSIGNED_SHORT, start)
393 #define GL_UNSIGNED_INT 0x1405
394 #define GL_DOUBLE 0x140A
399 #define glBufferDatai glesBufferDatai
400 #define glBufferDatad glesBufferDatad
401 #define glVertexPointeri glesVertexPointeri
402 #define glVertexPointerd glesVertexPointerd
404 #define glRecti glesRecti
405 #define glBegin glesBegin
406 #define glTexCoord2i glesTexCoord2i
407 #define glVertex2i glesVertex2i
408 #define glTexCoord2d glesTexCoord2d
409 #define glVertex2d glesVertex2d
410 #define glTexCoord2f glesTexCoord2f
411 #define glVertex2f glesVertex2f
412 #define glEnd glesEnd
413 #define glColor3f glesColor3f
414 #define glColor4ub glesColor4ub
415 #define glColor4fv glesColor4fv
416 #define glLineStipple glesLineStipple
417 #define glNormal3fv glesNormal3fv
418 #define glTexCoord2fv glesTexCoord2fv
419 #define glColorMaterial glesColorMaterial
421 #define glLoadMatrixd glesLoadMatrixd
422 #define glMultMatrixd glesMultMatrixd
423 #define glFrustum glesFrustum
424 #define glOrtho glesOrtho
425 #define glScaled glesScaled
426 #define glTranslated glesTranslated
427 #define glRotated glesRotated
428 #define glVertex3d glesVertex3d
429 #define glVertex3f glesVertex3f
430 #define glVertex3fv glesVertex3fv
431 #define glLightModeli glesLightModeli
435 #define GL_QUAD_STRIP 0
436 //#define GL_DOUBLE 0
437 //#define GL_UNSIGNED_INT 0
440 //#define GL_LINE_STIPPLE 0
441 #define GL_BGRA_EXT 0
442 #define GL_UNPACK_ROW_LENGTH 0
443 #define GL_UNPACK_SKIP_PIXELS 0
444 #define GL_UNPACK_SKIP_ROWS 0
446 #define GL_PACK_ROW_LENGTH 0
447 #define GL_PACK_SKIP_ROWS 0
448 #define GL_PACK_SKIP_PIXELS 0
450 static EGLDisplay eglDisplay;
451 static EGLSurface eglSurface;
452 static EGLContext eglContext;
453 static int eglWidth, eglHeight;
455 static bool egl_init_display(ANativeWindow* window)
457 const EGLint attribs[] =
459 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
464 /*EGL_SAMPLE_BUFFERS, 1,
465 EGL_SAMPLES, 0, //2,*/
474 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
475 eglInitialize(display, 0, 0);
476 eglChooseConfig(display, attribs, &config, 1, &numConfigs);
477 eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &format);
479 surface = eglCreateWindowSurface(display, config, window, null);
480 context = eglCreateContext(display, config, null, null);
482 if(!eglMakeCurrent(display, surface, surface, context))
485 eglQuerySurface(display, surface, EGL_WIDTH, &w);
486 eglQuerySurface(display, surface, EGL_HEIGHT, &h);
488 eglDisplay = display;
489 eglContext = context;
490 eglSurface = surface;
494 glEnableClientState(GL_VERTEX_ARRAY);
496 // Initialize GL state.
497 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
498 glEnable(GL_CULL_FACE);
499 glShadeModel(GL_SMOOTH);
500 glDisable(GL_DEPTH_TEST);
502 glDisable(GL_CULL_FACE);
503 glDisable(GL_DEPTH_TEST);
505 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
508 matrixStack[0][0].Identity();
509 matrixStack[1][0].Identity();
510 matrixStack[2][0].Identity();
512 glesMatrixMode(GL_MODELVIEW);
513 glScaled(1.0, 1.0, -1.0);
514 glesMatrixMode(GL_PROJECTION);
515 glShadeModel(GL_FLAT);
517 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
518 glFogi(GL_FOG_MODE, GL_EXP);
519 glFogf(GL_FOG_DENSITY, 0);
520 glEnable(GL_NORMALIZE);
521 glDepthFunc(GL_LESS);
523 glDisable(GL_MULTISAMPLE_ARB);
527 glOrtho(0,w,h,0,0.0,1.0);
529 currentVertexBuffer = 0;
533 static void egl_term_display()
537 glDeleteTextures(1, &stippleTexture);
540 if(eglDisplay != EGL_NO_DISPLAY)
542 eglMakeCurrent(eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
543 if(eglContext != EGL_NO_CONTEXT)
544 eglDestroyContext(eglDisplay, eglContext);
545 if(eglSurface != EGL_NO_SURFACE)
546 eglDestroySurface(eglDisplay, eglSurface);
547 eglTerminate(eglDisplay);
549 eglDisplay = EGL_NO_DISPLAY;
550 eglContext = EGL_NO_CONTEXT;
551 eglSurface = EGL_NO_SURFACE;
554 // OpenGL Immediate Mode Porting Kit
555 static int beginCount;
556 static int vertexCount;
557 static int normalCount;
558 static float *vertexPointer;
559 static float *normalPointer;
560 static GLenum beginMode;
561 static unsigned int beginBufferSize, normalBufferSize;
562 static int numVertexCoords = 2;
564 void glesRecti(int a, int b, int c, int d)
574 void glesBegin(GLenum mode)
581 normalBufferSize = beginBufferSize = 1024; // default number of vertices
582 vertexPointer = new float[beginBufferSize * 5];
583 normalPointer = new float[normalBufferSize * 3];
587 void glesTexCoord2f(float x, float y)
589 int count = vertexCount;
591 if(vertexCount + numVertexCoords > beginBufferSize)
593 beginBufferSize = beginBufferSize + beginBufferSize/2;
594 vertexPointer = renew vertexPointer float[beginBufferSize * 5];
597 vertexPointer[count*(2+numVertexCoords) ] = x;
598 vertexPointer[count*(2+numVertexCoords)+1] = y;
601 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
603 vertexPointer[count*(2+numVertexCoords) ] = vertexPointer[(count-4)*(2+numVertexCoords)];
604 vertexPointer[count*(2+numVertexCoords)+1] = vertexPointer[(count-4)*(2+numVertexCoords)+1];
606 vertexPointer[count*(2+numVertexCoords) ] = vertexPointer[(count-3)*(2+numVertexCoords)];
607 vertexPointer[count*(2+numVertexCoords)+1] = vertexPointer[(count-3)*(2+numVertexCoords)+1];
611 void glesTexCoord2i(int x, int y) { glesTexCoord2f((float)x, (float)y); }
612 void glesTexCoord2d(double x, double y) { glesTexCoord2f((float)x, (float)y); }
613 void glesTexCoord2fv(float * a) { glesTexCoord2f(a[0], a[1]); }
615 void glesVertex2f(float x, float y)
618 if(vertexCount + 4 > beginBufferSize)
620 beginBufferSize = beginBufferSize + beginBufferSize/2;
621 vertexPointer = renew vertexPointer float[beginBufferSize * 5];
624 vertexPointer[vertexCount*4+2] = x;
625 vertexPointer[vertexCount*4+3] = y;
628 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
630 vertexPointer[vertexCount*4+2] = vertexPointer[(vertexCount-4)*4+2];
631 vertexPointer[vertexCount*4+3] = vertexPointer[(vertexCount-4)*4+3];
633 vertexPointer[vertexCount*4+2] = vertexPointer[(vertexCount-3)*4+2];
634 vertexPointer[vertexCount*4+3] = vertexPointer[(vertexCount-3)*4+3];
639 void glesVertex2i(int x, int y) { glesVertex2f((float)x, (float)y); }
640 void glesVertex2d(double x, double y) { glesVertex2f((float)x, (float)y); }
644 int mode = beginMode;
645 if(mode == GL_QUADS) mode = GL_TRIANGLES;
646 else if(mode == GL_POLYGON) mode = GL_TRIANGLE_FAN;
648 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
649 glTexCoordPointer(numVertexCoords, GL_FLOAT, (numVertexCoords+2)*sizeof(float),vertexPointer);
650 glVertexPointer (numVertexCoords, GL_FLOAT, (numVertexCoords+2)*sizeof(float),vertexPointer+2);
651 if(normalCount && normalCount == vertexCount)
653 glEnableClientState(GL_NORMAL_ARRAY);
654 glNormalPointer (GL_FLOAT, 3*sizeof(float),normalPointer);
657 glDrawArrays(mode, 0, vertexCount);
659 glDisableClientState(GL_NORMAL_ARRAY);
660 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
665 static float *floatVPBuffer = null;
666 static short *shortVPBuffer = null;
667 static unsigned int shortVPSize = 0, floatVPSize = 0;
670 //static float *floatVPBuffer = null; // For floats we reuse floatVPBuffer
671 static unsigned short *shortBDBuffer = null;
672 static unsigned int shortBDSize = 0/*, floatVPSize = 0*/;
674 void glesVertexPointeri(int numCoords, int stride, int *pointer, int numVertices)
679 if(numVertices*numCoords > shortVPSize)
681 shortVPSize = numVertices*numCoords;
682 shortVPBuffer = renew shortVPBuffer short[shortVPSize];
684 for(i = 0; i < numVertices*numCoords; i++)
685 shortVPBuffer[i] = (short)pointer[i];
686 glVertexPointer(numCoords, GL_SHORT, stride, shortVPBuffer);
689 glVertexPointer(numCoords, GL_SHORT, stride, 0);
692 void glesVertexPointerd(int numCoords, int stride, double *pointer, int numVertices)
697 if(numVertices*numCoords > floatVPSize)
699 floatVPSize = numVertices*numCoords;
700 floatVPBuffer = renew floatVPBuffer float[floatVPSize];
702 for(i = 0; i < numVertices*numCoords; i++)
703 floatVPBuffer[i] = (float)pointer[i];
704 glVertexPointer(numCoords, GL_FLOAT, stride, floatVPBuffer);
707 glVertexPointer(numCoords, GL_FLOAT, stride, 0);
710 void glesTexReuseIntVP(int numCoords)
712 glTexCoordPointer(numCoords, GL_SHORT, 0, floatVPBuffer);
715 void glesTexReuseDoubleVP(int numCoords)
717 glTexCoordPointer(numCoords, GL_FLOAT, 0, floatVPBuffer);
720 void glesColor3f( float r, float g, float b )
722 glColor4f(r, g, b, 1.0f);
725 void glesColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
727 glColor4f(r/255.0f, g/255.0f, b/255.0f, a/255.0f);
730 void glesColor4fv(float * a)
732 glColor4f(a[0], a[1], a[2], a[3]);
735 void glesBufferDatad(int target, int size, void * data, int usage)
737 int numElems = size/sizeof(double);
738 double * dblPtr = (double *)data;
740 if (numElems > floatVPSize)
742 floatVPSize = numElems;
743 floatVPBuffer = renew floatVPBuffer float[floatVPSize];
745 for (i=0; i< numElems; i++)
746 floatVPBuffer[i] = (float)dblPtr[i];
748 glBufferData(target, numElems*sizeof(float), floatVPBuffer, usage);
751 void glesBufferDatai(int target, int size, void * data, int usage)
753 int numElems = size/sizeof(unsigned int);
754 unsigned int * pointer = (unsigned int *)data;
756 if (numElems > shortBDSize)
758 shortBDSize = numElems;
759 shortBDBuffer = renew shortBDBuffer uint16[shortBDSize];
761 for (i=0; i< numElems; i++)
762 shortBDBuffer[i] = (unsigned short)pointer[i];
764 glBufferData(target, numElems*sizeof(unsigned short), shortBDBuffer, usage);
767 // *** Our Custom Matrix Stack ***
769 static void LoadCurMatrix()
771 double * i = matrixStack[curStack][matrixIndex[curStack]].array;
774 (float)i[0],(float)i[1],(float)i[2],(float)i[3],
775 (float)i[4],(float)i[5],(float)i[6],(float)i[7],
776 (float)i[8],(float)i[9],(float)i[10],(float)i[11],
777 (float)i[12],(float)i[13],(float)i[14],(float)i[15]
782 void glesLoadIdentity()
784 matrixStack[curStack][matrixIndex[curStack]].Identity();
788 void glesPushMatrix()
790 if(matrixIndex[curStack] + 1 < sizeof(matrixStack[0]) / sizeof(Matrix))
792 matrixIndex[curStack]++;
793 memcpy(matrixStack[curStack][matrixIndex[curStack]].array, matrixStack[curStack][matrixIndex[curStack]-1].array, sizeof(Matrix));
799 if(matrixIndex[curStack] > 0)
801 matrixIndex[curStack]--;
806 void glesLoadMatrixd(double * i)
808 memcpy(matrixStack[curStack][matrixIndex[curStack]].array, i, sizeof(Matrix));
812 void glesOrtho( double l, double r, double b, double t, double n, double f )
816 (2 / (r - l)), 0, 0, 0,
817 0, (2 / (t - b)), 0, 0,
818 0, 0, (-2 / (f - n)), 0,
819 (-(r + l) / (r - l)), (-(t + b) / (t - b)), (-(f + n) / (f - n)), 1
822 res.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
823 matrixStack[curStack][matrixIndex[curStack]] = res;
827 void glesFrustum( double l, double r, double b, double t, double n, double f )
837 double A = ((r + l) / (r - l));
838 double B = ((t + b) / (t - b));
839 double C = (-(f + n) / (f - n));
840 double D = (-2*f*n/(f-n));
843 (2.0*n / (r - l)), 0, 0, 0,
844 0, (2.0*n / (t - b)), 0, 0,
849 res.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
850 matrixStack[curStack][matrixIndex[curStack]] = res;
855 void glesRotated( double a, double b, double c, double d )
860 q.RotationAxis({(float)b,(float)c,(float)-d}, a );
861 m.RotationQuaternion(q);
862 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
863 matrixStack[curStack][matrixIndex[curStack]] = r;
866 void glesScaled( double a, double b, double c )
872 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
873 matrixStack[curStack][matrixIndex[curStack]] = r;
877 void glesTranslated( double a, double b, double c )
883 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
884 matrixStack[curStack][matrixIndex[curStack]] = r;
888 void glesMultMatrixd( double * i )
891 r.Multiply((Matrix *)i, matrixStack[curStack][matrixIndex[curStack]]);
892 matrixStack[curStack][matrixIndex[curStack]] = r;
896 void glesMatrixMode(int mode)
898 curStack = (mode == GL_MODELVIEW) ? 0 : (mode == GL_PROJECTION) ? 1 : 2;
902 #define glPushMatrix glesPushMatrix
903 #define glPopMatrix glesPopMatrix
904 #define glLoadIdentity glesLoadIdentity
905 #define glMatrixMode glesMatrixMode
907 /* Using the built-in matrix stack
908 void glesLoadMatrixd( double * i )
912 (float)i[0],(float)i[1],(float)i[2],(float)i[3],
913 (float)i[4],(float)i[5],(float)i[6],(float)i[7],
914 (float)i[8],(float)i[9],(float)i[10],(float)i[11],
915 (float)i[12],(float)i[13],(float)i[14],(float)i[15]
920 void glesOrtho( double l, double r, double b, double t, double n, double f )
924 { (float)(2 / (r - l)), 0, 0, 0 },
925 { 0, (float)(2 / (t - b)), 0, 0 },
926 { 0, 0, (float)(-2 / (f - n)), 0 },
927 { (float)(-(r + l) / (r - l)), (float)(-(t + b) / (t - b)), (float)(-(f + n) / (f - n)), 1 }
929 glMultMatrixf((float *)matrix);
932 void glesFrustum( double l, double r, double b, double t, double n, double f )
934 float A = (float)((r + l) / (r - l));
935 float B = (float)((t + b) / (t - b));
936 float C = (float)(-(f + n) / (f - n));
937 float D = (float)(-2*f*n/(f-n));
940 { (float)(2*n / (r - l)), 0, 0, 0 },
941 { 0, (float)(2*n / (t - b)), 0, 0 },
945 glMultMatrixf((float *)matrix);
948 void glesRotated( double a, double b, double c, double d ) { glRotatef((float)a, (float)b, (float)c, (float)d); }
949 void glesScaled( double a, double b, double c ) { glScalef((float)a, (float)b, (float)c); }
950 void glesTranslated( double a, double b, double c ) { glTranslatef((float)a, (float)b, (float)c); }
952 void glesMultMatrixd( double * i )
956 (float)i[0], (float)i[1], (float)i[2], (float)i[3],
957 (float)i[4], (float)i[5], (float)i[6], (float)i[7],
958 (float)i[8], (float)i[9], (float)i[10], (float)i[11],
959 (float)i[12], (float)i[13], (float)i[14], (float)i[15]
965 // Need to do these...
966 void glesVertex3f( float x, float y, float z )
969 if(vertexCount + 4 > beginBufferSize)
971 beginBufferSize = beginBufferSize + beginBufferSize/2;
972 vertexPointer = renew vertexPointer float[beginBufferSize * 5];
975 vertexPointer[vertexCount*5+2] = x;
976 vertexPointer[vertexCount*5+3] = y;
977 vertexPointer[vertexCount*5+4] = z;
980 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
982 vertexPointer[vertexCount*5+2] = vertexPointer[(vertexCount-4)*5+2];
983 vertexPointer[vertexCount*5+3] = vertexPointer[(vertexCount-4)*5+3];
984 vertexPointer[vertexCount*5+4] = vertexPointer[(vertexCount-4)*5+4];
986 vertexPointer[vertexCount*5+2] = vertexPointer[(vertexCount-3)*5+2];
987 vertexPointer[vertexCount*5+3] = vertexPointer[(vertexCount-3)*5+3];
988 vertexPointer[vertexCount*5+4] = vertexPointer[(vertexCount-3)*5+4];
994 void glesVertex3d( double x, double y, double z ) { glesVertex3f((float)x, (float)y, (float)z); }
995 void glesVertex3fv( float* coords ) { glesVertex3f(coords[0], coords[1], coords[2]); }
997 void glesNormal3f(float x, float y, float z)
999 normalCount = vertexCount;
1000 if(vertexCount + 4 > normalBufferSize)
1002 normalBufferSize = normalBufferSize + normalBufferSize/2;
1003 normalPointer = renew normalPointer float[normalBufferSize * 2];
1006 normalPointer[normalCount*3+0] = x;
1007 normalPointer[normalCount*3+1] = y;
1008 normalPointer[normalCount*3+2] = z;
1011 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
1013 normalPointer[normalCount*3+0] = normalPointer[(normalCount-4)*3+0];
1014 normalPointer[normalCount*3+1] = normalPointer[(normalCount-4)*3+1];
1015 normalPointer[normalCount*3+2] = normalPointer[(normalCount-4)*3+2];
1017 normalPointer[normalCount*3+0] = normalPointer[(normalCount-3)*3+0];
1018 normalPointer[normalCount*3+1] = normalPointer[(normalCount-3)*3+1];
1019 normalPointer[normalCount*3+2] = normalPointer[(normalCount-3)*3+2];
1023 void glesNormal3fd(double x, double y, double z) { glesNormal3f((float)x, (float)y, (float)z); }
1024 void glesNormal3fv(float * coords) { glesNormal3f(coords[0], coords[1], coords[2]); }
1026 void glesColorMaterial(int a, int b)
1028 PrintLn("glColorMaterial stub");
1031 void glesTerminate()
1033 delete vertexPointer;
1034 delete normalPointer;
1035 beginBufferSize = 0;
1037 delete floatVPBuffer;
1040 delete shortVPBuffer;
1043 delete shortBDBuffer;
1047 static GLuint stippleTexture;
1048 static bool stippleEnabled;
1050 void glesLineStipple( int i, unsigned short j )
1054 for(x = 0; x < 16; x++)
1056 bool v = (j & (1 << x)) != 0;
1057 texture[x] = v ? 0xFFFFFFFF : 0;
1060 glGenTextures(1, &stippleTexture);
1061 glBindTexture(GL_TEXTURE_2D, stippleTexture);
1062 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture);
1063 glEnable(GL_TEXTURE_2D);
1064 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1065 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1066 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
1067 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1068 glMatrixMode(GL_TEXTURE);
1070 //glTranslated(1.0/backAttrib->texW/2.0f, 1.0/backAttrib->texH/2.0f, 0.0f);
1071 glScaled(i/16.0, 1, 1.0f);
1072 glTranslated(0.5, 0.5, 0);
1073 glMatrixMode(GL_PROJECTION);
1076 void glesLightModeli( unsigned int pname, int param )
1078 if(pname == GL_LIGHT_MODEL_TWO_SIDE)
1079 glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, param);
1082 void glClearDepth( double depth ) { glClearDepthf((float)depth); }
1083 void glFogi( unsigned int pname, int param ) { }
1084 void glPolygonMode( unsigned int i, unsigned int j ) { }
1087 // *** Picking won't be supported for now ***
1088 void glPushName( unsigned int i ) { }
1089 void glLoadName( unsigned int i ) { }
1090 void glPopName() { }
1092 // Probably replace by regular glBlendFunc ...
1093 void glBlendFuncSeparate(int a, int b, int c, int d)
1098 // For direct pixel blitting...
1099 void glRasterPos2d(double a, double b) { }
1100 void glPixelZoom(float a, float b) { }
1101 void glDrawPixels(int a, int b, int c, int d, void * e) { }
1105 /* Non OpenGL ES friendly stuff
1106 #undef GL_UNSIGNED_INT
1111 #undef GL_QUAD_STRIP
1112 #undef GL_POLYGON_STIPPLE
1113 #undef GL_LINE_STIPPLE
1116 #undef GL_ALL_ATTRIB_BITS
1117 #undef GL_LIGHT_MODEL_LOCAL_VIEWER
1122 #if !defined(__APPLE__)
1123 void (APIENTRY * glBindBufferARB) (GLenum target, GLuint buffer);
1124 void (APIENTRY * glGenBuffersARB) (GLsizei n, GLuint *buffers);
1125 void (APIENTRY * glDeleteBuffersARB) (GLsizei n, const GLuint *buffers);
1126 void (APIENTRY * glBufferDataARB) (GLenum target, int size, const GLvoid *data, GLenum usage);
1131 static int currentVertexBuffer;
1133 bool GLSelectVBO(uint vbo)
1135 if(currentVertexBuffer != vbo)
1137 GLBindBuffer(GL_ARRAY_BUFFER, vbo);
1138 currentVertexBuffer = vbo;
1144 void GLGenBuffers(int count, uint * buffer)
1147 glGenBuffers(count, buffer);
1149 #if defined(__WIN32__)
1152 glGenBuffersARB(count, buffer);
1156 void GLDeleteBuffers(int count, GLuint * buffer)
1159 glDeleteBuffers(count, buffer);
1161 #if defined(__WIN32__)
1162 if(glDeleteBuffersARB)
1164 glDeleteBuffersARB(count, buffer);
1168 void GLBindBuffer(int target, uint buffer)
1171 glBindBuffer(target, buffer);
1173 #if defined(__WIN32__)
1176 glBindBufferARB(target, buffer);
1180 void GLBufferData(int type, GLenum target, int size, const GLvoid *data, GLenum usage)
1183 if(type == GL_DOUBLE)
1184 glesBufferDatad(target, size, (void *)data, usage);
1185 else if(type == GL_UNSIGNED_INT)
1186 glesBufferDatai(target, size, (void *)data, usage);
1188 glBufferData(target, size, data, usage);
1191 #if defined(__WIN32__)
1194 glBufferDataARB(target, size, data, usage);
1199 static int displayWidth, displayHeight;
1201 #define GL_CLAMP_TO_EDGE 0x812F
1203 static bool vboAvailable;
1205 static bool useSingleGLContext = false;
1206 class OGLDisplay : struct
1208 #if defined(__WIN32__)
1218 int imageBuffers[2];
1219 byte * pboMemory1, * pboMemory2;
1221 #elif !defined(__ANDROID__)
1222 GLXContext glContext;
1225 XShmSegmentInfo shminfo;
1227 XShmSegmentInfo shminfoShape;
1228 XImage * shapeImage;
1232 X11Picture windowPicture;
1233 X11Picture pixmapPicture;
1235 X11Picture shapePicture;
1238 ColorAlpha * flippingBuffer;
1239 int flipBufH, flipBufW;
1244 class OGLSystem : struct
1249 #if defined(__WIN32__)
1250 PIXELFORMATDESCRIPTOR pfd;
1255 #elif !defined(__ANDROID__)
1256 XVisualInfo * visualInfo;
1257 GLXContext glContext;
1258 GLXDrawable glxDrawable;
1262 class OGLSurface : struct
1269 float foreground[4], background[4], bitmapMult[4];
1272 class OGLMesh : struct
1281 class OGLIndices : struct
1288 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1289 static int primitiveTypes[RenderPrimitiveType] =
1291 GL_POINTS, GL_LINES, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP, GL_LINE_STRIP
1298 class OpenGLDisplayDriver : DisplayDriver
1300 class_property(name) = "OpenGL";
1302 bool LockSystem(DisplaySystem displaySystem)
1304 #if !defined(__ANDROID__)
1305 OGLSystem oglSystem = displaySystem.driverData;
1306 if(useSingleGLContext) return true;
1307 #if defined(__WIN32__)
1308 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1309 #elif defined(__unix__) || defined(__APPLE__)
1310 //if(previous) return true;
1311 // printf("Making SYSTEM current\n");
1312 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)oglSystem.glxDrawable, oglSystem.glContext);
1313 //previous = oglSystem.glContext;
1319 void UnlockSystem(DisplaySystem displaySystem)
1321 if(useSingleGLContext) return;
1322 #if defined(__WIN32__)
1323 wglMakeCurrent(null, null);
1324 #elif defined(__unix__) || defined(__APPLE__)
1325 // printf("Making NULL current\n");
1326 #if defined(__ANDROID__)
1328 glXMakeCurrent(xGlobalDisplay, None, null);
1334 bool Lock(Display display)
1336 #if !defined(__ANDROID__)
1337 OGLDisplay oglDisplay = display.driverData;
1338 if(useSingleGLContext) return true;
1339 #if defined(__WIN32__)
1340 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1341 #elif defined(__unix__) || defined(__APPLE__)
1342 // if(previous) glXMakeCurrent(xGlobalDisplay, None, null);
1343 // printf(" Making DISPLAY current\n");
1344 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
1350 void Unlock(Display display)
1352 if(useSingleGLContext) return;
1353 //printf(" Making NULL current\n");
1354 //glXMakeCurrent(xGlobalDisplay, None, null);
1356 LockSystem(display.displaySystem);
1359 void DestroyDisplay(Display display)
1361 OGLDisplay oglDisplay = display.driverData;
1365 #if defined(__WIN32__)
1366 wglMakeCurrent( null, null );
1369 wglDeleteContext(oglDisplay.glrc);
1371 if(oglDisplay.hdc && oglDisplay.pBuffer)
1372 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
1374 if(oglDisplay.pBuffer)
1375 wglDestroyPbufferARB(oglDisplay.pBuffer);
1378 ReleaseDC(display.window, oglDisplay.hdc);
1380 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
1381 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
1383 #elif defined(__unix__) || defined(__APPLE__)
1384 #if defined(__ANDROID__)
1386 if(oglDisplay.shapePixmap)
1387 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
1388 if(oglDisplay.pixmap)
1389 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1390 if(oglDisplay.image)
1392 if(oglDisplay.shminfoShape.shmid != -1)
1394 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
1395 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1396 shmdt(oglDisplay.shminfo.shmaddr);
1397 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
1400 if(oglDisplay.shapeImage)
1402 if(oglDisplay.shminfoShape.shmid != -1)
1404 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
1405 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1406 shmdt(oglDisplay.shminfoShape.shmaddr);
1407 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
1409 XDestroyImage(oglDisplay.shapeImage);
1410 oglDisplay.shapeImage = None;
1413 glXMakeCurrent(xGlobalDisplay, None, null);
1415 if(oglDisplay.glContext)
1416 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
1419 delete oglDisplay.flippingBuffer;
1421 display.driverData = null;
1425 void ::CheckExtensions(OGLSystem oglSystem)
1427 const char * extensions = (const char *)glGetString(GL_EXTENSIONS);
1429 oglSystem.pow2textures = strstr(extensions, "GL_ARB_texture_non_power_of_two") ? false : true;
1430 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &oglSystem.maxTextureSize);
1433 bool CreateDisplaySystem(DisplaySystem displaySystem)
1435 bool result = false;
1436 OGLSystem oglSystem = displaySystem.driverData = OGLSystem { };
1439 oglSystem.hwnd = CreateWindow("static", null, 0,0,0,0,0,null,null,null,null);
1441 oglSystem.hdc = GetDC(oglSystem.hwnd);
1445 oglSystem.pfd.nSize = (short)sizeof(oglSystem.pfd);
1446 oglSystem.pfd.nVersion = 1;
1447 oglSystem.pfd.dwFlags = PFD_DRAW_TO_WINDOW /*PFD_DRAW_TO_BITMAP*/ | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
1448 oglSystem.pfd.iPixelType = PFD_TYPE_RGBA;
1449 oglSystem.pfd.cColorBits = 24;
1450 oglSystem.pfd.cAlphaBits = 8;
1451 oglSystem.pfd.cDepthBits = 24;
1452 oglSystem.pfd.iLayerType = PFD_MAIN_PLANE;
1454 oglSystem.format = ChoosePixelFormat(oglSystem.hdc, &oglSystem.pfd);
1455 DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1457 if(oglSystem.pfd.cColorBits > 8)
1459 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1460 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1463 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1465 // Get Pointers To The GL Functions
1466 glActiveTextureARB = (void *) wglGetProcAddress("glActiveTextureARB");
1467 glMultiTexCoord2fARB = (void *) wglGetProcAddress("glMultiTexCoord2fARB");
1468 glClientActiveTextureARB = (void *) wglGetProcAddress("glClientActiveTextureARB");
1469 glLockArraysEXT = (void *) wglGetProcAddress("glLockArraysEXT" );
1470 glUnlockArraysEXT = (void *) wglGetProcAddress("glUnlockArraysEXT");
1471 glGenBuffersARB = (void *) wglGetProcAddress("glGenBuffersARB");
1472 glBindBufferARB = (void *) wglGetProcAddress("glBindBufferARB");
1473 glBufferDataARB = (void *) wglGetProcAddress("glBufferDataARB");
1474 glMapBufferARB = (void *) wglGetProcAddress("glMapBufferARB");
1475 glUnmapBufferARB = (void *) wglGetProcAddress("glUnmapBufferARB");
1476 glDeleteBuffersARB = (void *) wglGetProcAddress("glDeleteBuffersARB");
1477 glBlendFuncSeparate = (void *) wglGetProcAddress("glBlendFuncSeparate");
1479 wglChoosePixelFormatARB = (void *) wglGetProcAddress("wglChoosePixelFormatARB");
1480 wglGetExtensionsStringARB = (void *)wglGetProcAddress("wglGetExtensionsStringARB");
1481 wglCreatePbufferARB = (void *)wglGetProcAddress("wglCreatePbufferARB");
1482 wglGetPbufferDCARB = (void *)wglGetProcAddress("wglGetPbufferDCARB");
1483 wglQueryPbufferARB = (void *)wglGetProcAddress("wglQueryPbufferARB");
1484 wglDestroyPbufferARB = (void *)wglGetProcAddress("wglDestroyPbufferARB");
1485 wglReleasePbufferDCARB = (void *)wglGetProcAddress("wglReleasePbufferDCARB");
1486 wglBindTexImageARB = (void *)wglGetProcAddress("wglBindTexImageARB");
1487 wglReleaseTexImageARB = (void *)wglGetProcAddress("wglReleaseTexImageARB");
1489 wglSwapIntervalEXT = (void *)wglGetProcAddress("wglSwapIntervalEXT");
1491 vboAvailable = glBindBufferARB != null;
1493 // eSystem_LoggingMode(LOG_MSGBOX, null);
1495 if(wglChoosePixelFormatARB)
1500 float fAttributes[] = {0,0};
1503 WGL_DRAW_TO_WINDOW_ARB,GL_TRUE,
1504 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1505 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
1506 WGL_COLOR_BITS_ARB,24,
1507 WGL_ALPHA_BITS_ARB,8,
1508 WGL_DEPTH_BITS_ARB,16,
1509 WGL_STENCIL_BITS_ARB,0,
1510 WGL_DOUBLE_BUFFER_ARB,GL_TRUE,
1511 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
1512 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
1516 //Log("Found wglChoosePixelFormatARB\n");
1518 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1519 if(!valid || !numFormats)
1521 //Log("Can't find 4x multi sampling\n");
1522 iAttributes[19] = 2;
1523 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1524 if(!valid || !numFormats)
1526 // Log("Can't find 2x multi sampling\n");
1527 iAttributes[16] = 0;
1528 iAttributes[17] = 0;
1529 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1532 if(valid && numFormats)
1534 oglSystem.format = pixelFormat;
1535 wglMakeCurrent(null, null);
1536 wglDeleteContext(oglSystem.glrc);
1538 // *** DescribePixelFormat does not support WGL pixel formats! ***
1539 //DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1540 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1541 //Log("Successfully set pixel format\n");
1543 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1544 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1548 eSystem_Logf("Can't find wglChoosePixelFormatARB\n");*/
1552 CheckExtensions(oglSystem);
1554 wglMakeCurrent(null, null);
1556 //eSystem_DumpErrors(true);
1560 #elif defined(__unix__) || defined(__APPLE__)
1561 vboAvailable = true;
1562 #if defined(__ANDROID__)
1563 egl_init_display(guiApp.desktop.windowHandle);
1564 CheckExtensions(oglSystem);
1568 X11Window root = RootWindow( xGlobalDisplay, DefaultScreen( xGlobalDisplay ) );
1569 XSetWindowAttributes attr;
1574 #ifndef ECERE_MINIGLX
1575 GLX_USE_GL, GLX_DEPTH_SIZE, 1,
1578 GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,
1582 oglSystem.visualInfo = glXChooseVisual( xGlobalDisplay, DefaultScreen( xGlobalDisplay ), attrList );
1583 attr.background_pixel = 0;
1584 attr.border_pixel = 0;
1585 attr.colormap = XCreateColormap( xGlobalDisplay, root, oglSystem.visualInfo->visual, AllocNone);
1586 attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
1587 mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
1589 oglSystem.glxDrawable = XCreateWindow( xGlobalDisplay, root, 0, 0, 1, 1, 0, oglSystem.visualInfo->depth, InputOutput,
1590 oglSystem.visualInfo->visual, mask, &attr );
1592 if(oglSystem.visualInfo)
1594 oglSystem.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, null, True);
1595 if(oglSystem.glContext)
1597 glXMakeCurrent(xGlobalDisplay, oglSystem.glxDrawable, oglSystem.glContext);
1599 CheckExtensions(oglSystem);
1600 glXMakeCurrent(xGlobalDisplay, None, null);
1607 displaySystem.flags.alpha = true;
1608 displaySystem.flags.flipping = true;
1609 displaySystem.pixelFormat = pixelFormat888;
1613 void DestroyDisplaySystem(DisplaySystem displaySystem)
1615 OGLSystem oglSystem = displaySystem.driverData;
1617 #if defined(__WIN32__)
1618 wglMakeCurrent( null, null );
1621 wglDeleteContext(oglSystem.glrc);
1624 ReleaseDC(oglSystem.hwnd, oglSystem.hdc);
1625 DestroyWindow(oglSystem.hwnd);
1627 #elif defined(__unix__) || defined(__APPLE__)
1628 #if defined(__ANDROID__)
1631 if(oglSystem.visualInfo)
1633 #ifdef ECERE_MINIGLX
1634 __miniglx_XFree(oglSystem.visualInfo);
1636 XFree(oglSystem.visualInfo);
1640 if(oglSystem.glxDrawable)
1642 XDestroyWindow(xGlobalDisplay, oglSystem.glxDrawable);
1643 oglSystem.glxDrawable = 0;
1650 bool CreateDisplay(Display display)
1652 bool result = false;
1653 OGLDisplay oglDisplay = display.driverData;
1654 #if !defined(__ANDROID__)
1655 OGLSystem oglSystem = display.displaySystem.driverData;
1658 oglDisplay = display.driverData = OGLDisplay { };
1659 //printf("Inside CreateDisplay\n");
1661 #if defined(__WIN32__) || defined(USEPBUFFER)
1662 if(!display.alphaBlend)
1665 #if defined(__WIN32__)
1666 oglDisplay.hdc = GetDC(display.window);
1667 SetPixelFormat(oglDisplay.hdc, oglSystem.format, &oglSystem.pfd);
1668 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
1670 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
1671 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1675 ReleaseDC(display.window, oglDisplay.hdc);
1676 #elif defined(__unix__) || defined(__APPLE__)
1677 #if defined(__ANDROID__)
1679 XVisualInfo * visualInfo = ((XWindowData)display.windowDriverData).visual;
1681 #if defined(__APPLE__)
1682 XVisualInfo template = { 0 };
1683 XWindowAttributes winAttr;
1685 XGetWindowAttributes(xGlobalDisplay, (X11Window)display.window, &winAttr);
1686 template.visualid = XVisualIDFromVisual(winAttr.visual);
1687 visualInfo = XGetVisualInfo(xGlobalDisplay, VisualIDMask, &template, &n);
1689 printf("XGetVisualInfo visual ID = %d\n", template.visualid);
1690 printf("visualInfo visual ID = %d\n", visualInfo->visualid);
1691 printf("oglSystem.visualInfo visual ID = %d\n", oglSystem.visualInfo->visualid);
1692 printf("((XWindowData)display.windowDriverData).visual visual ID = %d\n", ((XWindowData)display.windowDriverData).visual->visualid);
1694 // visualInfo = oglSystem.visualInfo;
1699 //printf("visualInfo is not null\n");
1700 // printf("Creating Display Context, sharing with %x!\n", oglSystem.glContext);
1701 oglDisplay.glContext = glXCreateContext(xGlobalDisplay, visualInfo, oglSystem.glContext, True);
1702 //XFree(visualInfo);
1705 // oglDisplay.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, oglSystem.glContext, True);
1706 if(oglDisplay.glContext)
1708 //printf("CreateDisplay Got a Context\n");
1709 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
1715 #if defined(__WIN32__) || defined(USEPBUFFER)
1721 #if defined(__WIN32__)
1722 if(glBlendFuncSeparate)
1723 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1725 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1727 #if !defined(__OLDX__)
1728 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1730 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1735 glMatrixMode(GL_MODELVIEW);
1736 glScaled(1.0, 1.0, -1.0);
1737 // glTranslatef(0.375f, 0.375f, 0.0f);
1738 // glTranslatef(-0.625f, -0.625f, 0.0f);
1739 glMatrixMode(GL_PROJECTION);
1740 glShadeModel(GL_FLAT);
1742 // glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, true);
1743 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
1744 glFogi(GL_FOG_MODE, GL_EXP);
1745 glFogf(GL_FOG_DENSITY, 0);
1746 glEnable(GL_NORMALIZE);
1747 glDepthFunc(GL_LESS);
1749 glDisable(GL_MULTISAMPLE_ARB);
1751 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1752 display.ambient = Color { 50,50,50 };
1755 if(!useSingleGLContext)
1757 #if defined(__WIN32__)
1758 wglMakeCurrent(null, null);
1759 #elif defined(__unix__) || defined(__APPLE__)
1760 #if defined(__ANDROID__)
1763 glXMakeCurrent(xGlobalDisplay, None, null);
1771 bool DisplaySize(Display display, int width, int height)
1773 OGLDisplay oglDisplay = display.driverData;
1775 bool result = false;
1777 //printf("Inside DisplaySize\n");
1778 #if defined(__WIN32__) || defined(USEPBUFFER)
1779 OGLSystem oglSystem = display.displaySystem.driverData;
1780 if(display.alphaBlend)
1782 #if defined(__WIN32__)
1783 const int attributes[]=
1785 /*WGL_TEXTURE_FORMAT_ARB, WGL_TEXTURE_RGBA_ARB,
1786 WGL_TEXTURE_TARGET_ARB, WGL_TEXTURE_2D_ARB, */0
1788 int pixelFormat = 0;
1789 if(wglChoosePixelFormatARB)
1793 float fAttributes[] = {0,0};
1796 //WGL_DRAW_TO_BITMAP_ARB, GL_TRUE,
1797 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
1798 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1799 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
1800 WGL_COLOR_BITS_ARB,24,
1801 WGL_ALPHA_BITS_ARB,8,
1802 WGL_DEPTH_BITS_ARB,16,
1803 WGL_STENCIL_BITS_ARB,0,
1804 WGL_DOUBLE_BUFFER_ARB,GL_FALSE,
1805 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
1806 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
1810 //Log("Found wglChoosePixelFormatARB\n");
1812 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1813 if(!valid || !numFormats)
1815 //Log("Can't find 4x multi sampling\n");
1816 iAttributes[19] = 2;
1817 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1818 if(!valid || !numFormats)
1820 // Log("Can't find 2x multi sampling\n");
1821 iAttributes[16] = 0;
1822 iAttributes[17] = 0;
1823 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1824 if(!valid || !numFormats)
1828 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
1829 //WGL_DRAW_TO_BITMAP_ARB,GL_TRUE,
1830 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1831 WGL_COLOR_BITS_ARB,24,
1832 WGL_ALPHA_BITS_ARB,8,
1833 WGL_DEPTH_BITS_ARB,16,
1836 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1840 if(valid && numFormats)
1842 wglMakeCurrent(null, null);
1846 wglMakeCurrent( null, null );
1847 wglMakeCurrent( oglDisplay.hdc, oglDisplay.glrc );
1848 if(oglDisplay.hdc && oglDisplay.pBuffer)
1849 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
1851 wglDestroyPbufferARB(oglDisplay.pBuffer);
1853 if(!useSingleGLContext)
1854 wglMakeCurrent( null, null );
1857 wglDeleteContext(oglDisplay.glrc);
1859 oglDisplay.pBuffer = wglCreatePbufferARB(oglSystem.hdc, pixelFormat, width, height, attributes);
1860 oglDisplay.hdc = wglGetPbufferDCARB(oglDisplay.pBuffer);
1861 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
1864 HDC hdc = GetDC(display.window);
1866 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
1867 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1869 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_WIDTH_ARB, &width);
1870 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_HEIGHT_ARB, &height);
1872 // glDeleteBuffersARB(2, oglDisplay.imageBuffers);
1874 if((info = (BITMAPINFO *)new0 byte[sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*256]))
1878 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
1879 oglDisplay.memDC = CreateCompatibleDC(hdc);
1880 SetMapMode(oglDisplay.memDC, MM_TEXT);
1881 info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1882 info->bmiHeader.biPlanes = 1;
1883 info->bmiHeader.biCompression = BI_RGB;
1884 info->bmiHeader.biBitCount = 32; //(uint16)GetDeviceCaps(hdc, BITSPIXEL);
1885 info->bmiHeader.biWidth = width;
1886 info->bmiHeader.biHeight = height;
1887 newBitmap = CreateDIBSection(hdc, info, DIB_RGB_COLORS, &oglDisplay.picture, null, 0);
1890 SelectObject(oglDisplay.memDC, newBitmap);
1891 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
1894 PIXELFORMATDESCRIPTOR pfd = { 0 };
1895 pfd.nSize = (short)sizeof(pfd);
1897 pfd.dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL;
1898 pfd.iPixelType = PFD_TYPE_RGBA;
1899 pfd.cColorBits = 32;
1900 //pfd.cAlphaBits = 8;
1901 pfd.cDepthBits = 24;
1902 pfd.iLayerType = PFD_MAIN_PLANE;
1904 oglDisplay.hdc = oglDisplay.memDC;
1906 pixelFormat = ChoosePixelFormat(oglSystem.hdc, &pfd);
1907 DescribePixelFormat(oglDisplay.hdc, pixelFormat, sizeof(pfd), &pfd);
1908 SetPixelFormat(oglDisplay.hdc, pixelFormat, &pfd);
1910 oglDisplay.glrc = wglCreateContext(oglDisplay.hdc);
1911 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
1912 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1917 const int imageSize = width * height * 4;
1919 glGenBuffersARB(2, oglDisplay.imageBuffers);
1921 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
1922 glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize, null, GL_STREAM_READ);
1923 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
1924 // glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize / 2, null, GL_STREAM_READ);
1927 oglDisplay.memBitmap = newBitmap;
1928 oglDisplay.stride = width;
1934 ReleaseDC(display.window, hdc);
1936 #elif defined(__unix__) || defined(__APPLE__)
1937 #if defined(__ANDROID__)
1942 GLX_DOUBLEBUFFER, True,
1948 GLX_STENCIL_SIZE, 1,
1949 //GLX_DEPTH_SIZE, 24,
1950 GLX_RENDER_TYPE, GLX_RGBA_BIT,
1951 GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT | GLX_WINDOW_BIT,
1957 GLX_PBUFFER_WIDTH, width,
1958 GLX_PBUFFER_HEIGHT, height,
1959 GLX_LARGEST_PBUFFER, False,
1963 // choose a pixel format that meets our minimum requirements
1966 GLXFBConfig *config = glXChooseFBConfig(xGlobalDisplay, DefaultScreen(xGlobalDisplay), attrib, &count);
1969 if(oglDisplay.pixmap)
1971 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1972 oglDisplay.pixmap = None;
1974 if(oglDisplay.shapePixmap)
1976 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
1977 oglDisplay.shapePixmap = None;
1980 // Free Shared Memory Pixmap
1981 if(oglDisplay.image)
1983 if(oglDisplay.shminfoShape.shmid != -1)
1985 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
1986 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1987 shmdt(oglDisplay.shminfo.shmaddr);
1988 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
1990 XDestroyImage(oglDisplay.image);
1991 oglDisplay.image = None;
1993 if(oglDisplay.shapeImage)
1995 if(oglDisplay.shminfoShape.shmid != -1)
1997 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
1998 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1999 shmdt(oglDisplay.shminfoShape.shmaddr);
2000 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
2002 XDestroyImage(oglDisplay.shapeImage);
2003 oglDisplay.shapeImage = None;
2006 if(oglDisplay.windowPicture)
2007 XRenderFreePicture(xGlobalDisplay, oglDisplay.windowPicture);
2008 if(oglDisplay.pixmapPicture)
2009 XRenderFreePicture(xGlobalDisplay, oglDisplay.pixmapPicture);
2011 if(oglDisplay.pixmap)
2012 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2014 if(oglDisplay.glContext)
2015 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
2016 if(oglDisplay.pBuffer)
2017 glXDestroyPbuffer(xGlobalDisplay, oglDisplay.pBuffer);
2019 oglDisplay.pBuffer = glXCreatePbuffer(xGlobalDisplay, config[0], PBattrib);
2020 if(oglDisplay.pBuffer)
2022 oglDisplay.glContext = glXCreateNewContext(xGlobalDisplay, config[0], GLX_RGBA_TYPE, oglSystem.glContext, True);
2023 if(oglDisplay.glContext)
2025 glXMakeCurrent(xGlobalDisplay, None, null);
2026 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2028 // Initialize Shared Memory Pixmap
2029 oglDisplay.image = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 32,
2030 ZPixmap, null, &oglDisplay.shminfo, width, height);
2031 if(oglDisplay.image)
2033 oglDisplay.shminfo.shmid = shmget(IPC_PRIVATE,
2034 oglDisplay.image->bytes_per_line * oglDisplay.image->height, IPC_CREAT|0777);
2035 if(oglDisplay.shminfo.shmid != -1)
2037 oglDisplay.shminfo.shmaddr = shmat(oglDisplay.shminfo.shmid, 0, 0);
2038 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2040 oglDisplay.shminfo.readOnly = False;
2041 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfo))
2043 oglDisplay.pixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfo.shmaddr,
2044 &oglDisplay.shminfo, width, height, 32);
2046 // Initialize Shared Memory Shape Pixmap
2047 oglDisplay.shapeImage = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 1,
2048 ZPixmap, null, &oglDisplay.shminfoShape, width, height);
2049 if(oglDisplay.shapeImage)
2051 oglDisplay.shminfoShape.shmid = shmget(IPC_PRIVATE,
2052 oglDisplay.shapeImage->bytes_per_line * oglDisplay.shapeImage->height, IPC_CREAT|0777);
2053 if(oglDisplay.shminfoShape.shmid != -1)
2055 oglDisplay.shminfoShape.shmaddr = shmat(oglDisplay.shminfoShape.shmid, 0, 0);
2056 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2058 oglDisplay.shminfoShape.readOnly = False;
2059 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfoShape))
2061 oglDisplay.shapePixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfoShape.shmaddr,
2062 &oglDisplay.shminfoShape, width, height, 1);
2063 //oglDisplay.shapePixmap = XCreatePixmap(xGlobalDisplay, (X11Window)display.window, width, height, 1);
2066 XRenderPictureAttributes attributes = { 0 };
2067 XRenderPictFormat * format = XRenderFindStandardFormat(xGlobalDisplay, /*PictStandardRGB24*/ PictStandardARGB32);
2068 #if !defined(__APPLE__) && !defined(__OLDX__)
2069 attributes.repeat = RepeatNormal;
2071 attributes.repeat = 1;
2073 oglDisplay.pixmapPicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.pixmap, format, CPRepeat, &attributes);
2074 oglDisplay.windowPicture = XRenderCreatePicture(xGlobalDisplay, (X11Window)display.window, format, 0, &attributes);
2075 oglDisplay.shapePicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.shapePixmap,
2076 XRenderFindStandardFormat(xGlobalDisplay, PictStandardA1), 0, &attributes);
2079 oglDisplay.picture = oglDisplay.shminfo.shmaddr;
2080 oglDisplay.stride = oglDisplay.image->bytes_per_line / 4;
2097 CreateDisplay(display);
2098 #if defined(__WIN32__)
2099 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2100 #elif defined(__unix__) || defined(__APPLE__)
2101 #if defined(__ANDROID__)
2105 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2112 if(!result && display.alphaBlend)
2114 printf("Alpha blending windows not supported on this display\n");
2121 glViewport(0,0,width,height);
2123 glOrtho(0,width,height,0,0.0,1.0);
2124 displayWidth = display.width = width;
2125 displayHeight = display.height = height;
2127 if(!oglDisplay.flippingBuffer || oglDisplay.flipBufW < width || oglDisplay.flipBufH < height)
2129 oglDisplay.flipBufW = width;
2130 oglDisplay.flipBufH = height;
2134 oglDisplay.flippingBuffer = renew oglDisplay.flippingBuffer ColorAlpha [width * height];
2137 if(oglDisplay.flippingBuffer || !width || !height)
2143 void DisplayPosition(Display display, int x, int y)
2145 OGLDisplay oglDisplay = display.driverData;
2151 void SetPalette(Display display, ColorAlpha * palette, bool colorMatch)
2155 void RestorePalette(Display display)
2159 void StartUpdate(Display display)
2163 void EndUpdate(Display display)
2167 void Scroll(Display display, Box scroll, int x, int y, Extent dirty)
2171 void Update(Display display, Box updateBox)
2173 #if defined(__WIN32__) || defined(USEPBUFFER)
2174 OGLDisplay oglDisplay = display.driverData;
2176 //Logf("DisplayScreen\n");
2180 #if defined(__WIN32__) || defined(USEPBUFFER)
2181 if(display.alphaBlend)
2183 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2184 glPixelStorei(GL_PACK_ROW_LENGTH, oglDisplay.stride);
2185 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2186 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2187 glReadPixels(0,0,display.width,display.height,GL_BGRA_EXT,GL_UNSIGNED_BYTE, oglDisplay.picture);
2190 #if defined(__WIN32__)
2192 POINT point = { oglDisplay.x, oglDisplay.y};
2193 POINT srcPoint = { 0, 0 };
2194 BLENDFUNCTION blend = { 0 };
2196 size.cx = display.width;
2197 size.cy = display.height;
2198 blend.BlendOp = AC_SRC_OVER;
2199 blend.BlendFlags = 0;
2200 blend.SourceConstantAlpha = 255;
2201 blend.AlphaFormat = AC_SRC_ALPHA;
2204 // Process partial images. Mapping the buffer waits for
2205 // outstanding DMA transfers into the buffer to finish.
2206 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2207 oglDisplay.pboMemory1 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY);
2209 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2210 // oglDisplay.pboMemory2 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB,GL_READ_ONLY);
2213 memcpy(oglDisplay.picture, oglDisplay.pboMemory1, display.width * display.height * 4);
2214 //memcpy(oglDisplay.picture + display.width * display.height * 4 / 2, oglDisplay.pboMemory2, display.width * display.height * 4/ 2);
2217 UpdateLayeredWindow(display.window, hdc, &point, &size, oglDisplay.memDC, &srcPoint, 0, &blend, ULW_ALPHA);
2220 // Unmap the image buffers
2221 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2222 glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2224 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2225 // glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2227 // Bind two different buffer objects and start the glReadPixels
2228 // asynchronously. Each call will return directly after
2229 // starting the DMA transfer.
2230 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2231 glReadPixels(0, 0, display.width, display.height, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2233 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2234 // glReadPixels(0, display.height/2, display.width, display.height/2, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2238 #elif defined(__unix__) || defined(__APPLE__)
2239 #if defined(__ANDROID__)
2241 XTransform transform =
2244 { (int)(1.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(0 * (1 << 16)) },
2245 { (int)(0.0f), (int)(-1.0f * (1<<16)), (int)(0 * (1<<16)) },
2246 { (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)) }
2249 XRenderSetPictureTransform(xGlobalDisplay, oglDisplay.pixmapPicture, &transform);
2250 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.shapePicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2251 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.windowPicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2252 #if !defined(__APPLE__) && !defined(__OLDX__)
2253 XShapeCombineMask(xGlobalDisplay, (X11Window)display.window, ShapeInput, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2255 XShapeCombineMask(xGlobalDisplay, display.window, 2, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2257 XFlush(xGlobalDisplay);
2265 #if defined(__WIN32__)
2266 //wglSwapLayerBuffers(oglDisplay.hdc,WGL_SWAP_MAIN_PLANE);
2267 SwapBuffers(oglDisplay.hdc);
2268 #elif defined(__unix__) || defined(__APPLE__)
2269 #if defined(__ANDROID__)
2270 eglSwapBuffers(eglDisplay, eglSurface);
2272 glXSwapBuffers(xGlobalDisplay, (GLXDrawable)display.window);
2276 //Logf("Out of DisplayScreen\n");
2279 void FreeBitmap(DisplaySystem displaySystem, Bitmap bitmap)
2281 if(bitmap.driverData)
2283 GLuint tex = (GLuint)(uintptr)bitmap.driverData;
2284 glDeleteTextures(1, &tex);
2285 bitmap.driverData = 0;
2287 bitmap.driver = ((subclass(DisplayDriver))class(LFBDisplayDriver));
2290 bool AllocateBitmap(DisplaySystem displaySystem, Bitmap bitmap, int width, int height, int stride, PixelFormat format, bool allocatePalette)
2292 OGLSystem oglSystem = displaySystem.driverData;
2293 bool result = false;
2295 GLuint glBitmap = 0;
2297 uint w = width, h = height;
2298 if(oglSystem.pow2textures)
2303 w = Min(w, oglSystem.maxTextureSize);
2304 h = Min(h, oglSystem.maxTextureSize);
2306 glGenTextures(1, &glBitmap);
2307 glBindTexture(GL_TEXTURE_2D, glBitmap);
2309 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2311 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2312 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2314 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2315 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2317 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2319 mipMap.Allocate(null, w, h, w, pixelFormatRGBA, false);
2321 // glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2322 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2326 bitmap.driverData = (void *)(uintptr)glBitmap;
2327 bitmap.driver = displaySystem.driver;
2335 bool MakeDDBitmap(DisplaySystem displaySystem, Bitmap bitmap, bool mipMaps)
2337 bool result = false;
2338 OGLSystem oglSystem = displaySystem.driverData;
2340 // Pre process the bitmap... First make it 32 bit
2341 if(/*bitmap.pixelFormat == pixelFormatRGBA || */bitmap.Convert(null, pixelFormat888, null))
2344 uint w = bitmap.width, h = bitmap.height;
2345 GLuint glBitmap = 0;
2346 if(oglSystem.pow2textures)
2351 w = Min(w, oglSystem.maxTextureSize);
2352 h = Min(h, oglSystem.maxTextureSize);
2356 while(w * 2 < h) w *= 2;
2357 while(h * 2 < w) h *= 2;
2360 // Switch ARGB to RGBA
2361 //if(bitmap.format != pixelFormatRGBA)
2363 for(c=0; c<bitmap.size; c++)
2365 // ((ColorRGBA *)bitmap.picture)[c] = ((ColorAlpha *)bitmap.picture)[c];
2367 ColorAlpha color = ((ColorAlpha *)bitmap.picture)[c];
2368 ((ColorRGBA *)bitmap.picture)[c] = ColorRGBA { color.color.r, color.color.g, color.color.b, color.a };
2371 bitmap.pixelFormat = pixelFormat888;
2374 glGenTextures(1, &glBitmap);
2377 //int error = glGetError();
2381 glBindTexture(GL_TEXTURE_2D, glBitmap);
2382 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2384 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2385 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mipMaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
2386 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2388 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
2389 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
2391 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2392 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2394 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2398 for(level = 0; result && (w > 1 || h > 1); level++, w >>= 1, h >>= 1)
2401 if(bitmap.width != w || bitmap.height != h)
2403 mipMap = Bitmap { };
2404 if(mipMap.Allocate(null, w, h, w, bitmap.pixelFormat, false))
2406 Surface mipSurface = mipMap.GetSurface(0,0,null);
2407 mipSurface.Filter(bitmap, 0,0,0,0, w, h, bitmap.width, bitmap.height);
2424 // glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2425 glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2426 //printf("Calling glTexImage2D\n");
2427 //glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &width);
2428 //printf("width = %d (Should be %d, %d)\n", width, w, h);
2429 if((error = glGetError()))
2431 //Logf("OpenGL Bitmap MakeDD error: %d...\n", error);
2432 //printf("OpenGL Bitmap MakeDD error: %d...\n", error);
2436 if(mipMap != bitmap)
2441 if(!bitmap.keepData)
2442 bitmap.driver.FreeBitmap(bitmap.displaySystem, bitmap);
2443 bitmap.driverData = (void *)(uintptr)glBitmap;
2444 bitmap.driver = displaySystem.driver;
2447 FreeBitmap(displaySystem, bitmap);
2448 else if(oglSystem.loadingFont)
2450 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2451 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2452 oglSystem.loadingFont = false;
2458 void ReleaseSurface(Display display, Surface surface)
2460 glDisable(GL_SCISSOR_TEST);
2461 delete surface.driverData;
2462 surface.driverData = null;
2465 bool GetBitmapSurface(DisplaySystem displaySystem, Surface surface, Bitmap bitmap, int x, int y, Box clip)
2470 bool GetSurface(Display display, Surface surface, int x,int y, Box clip)
2472 bool result = false;
2473 OGLSurface oglSurface = surface.driverData = OGLSurface { };
2475 //Logf("GetSurface\n");
2479 if(displayWidth != display.width || displayHeight != display.height)
2481 displayWidth = display.width;
2482 displayHeight = display.height;
2484 glViewport(0,0,display.width,display.height);
2486 glOrtho(0,display.width,display.height,0,0.0,1.0);
2489 surface.offset.x = x;
2490 surface.offset.y = y;
2491 surface.unclippedBox = surface.box = clip;
2492 oglSurface.bitmapMult[0] = 1;
2493 oglSurface.bitmapMult[1] = 1;
2494 oglSurface.bitmapMult[2] = 1;
2495 oglSurface.bitmapMult[3] = 1;
2497 glEnable(GL_SCISSOR_TEST);
2500 (display.height) -(y+clip.bottom)-1,
2501 clip.right-clip.left+1,
2502 clip.bottom-clip.top+1);
2508 void Clip(Display display, Surface surface, Box clip)
2517 box.Clip(surface.unclippedBox);
2521 box = surface.box = surface.unclippedBox;
2522 box.left += surface.offset.x;
2523 box.top += surface.offset.y;
2524 box.right+= surface.offset.x;
2525 box.bottom += surface.offset.y;
2528 box.left,display.height - box.bottom - 1,
2529 box.right-box.left+1, box.bottom-box.top+1);
2532 bool GrabScreen(Display display, Bitmap bitmap, int x, int y, unsigned int w, unsigned int h)
2534 bool result = false;
2535 OGLDisplay oglDisplay = display.driverData;
2536 ColorAlpha * flippingBuffer = oglDisplay.flippingBuffer;
2538 if(oglDisplay.flippingBuffer)
2540 if(bitmap.pixelFormat != pixelFormat888 || bitmap.width < w || bitmap.height < h)
2543 bitmap.Allocate(null, w,h,w, pixelFormat888, false);
2549 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2550 glPixelStorei(GL_PACK_ROW_LENGTH, bitmap.stride);
2551 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2552 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2553 glReadPixels(x,display.height-h-y,w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, flippingBuffer);
2556 for(row = 0; row<h; row++)
2557 CopyBytesBy4(((ColorAlpha *)bitmap.picture) + row * w, ((ColorAlpha *)flippingBuffer) + (h-row-1) * w, w);
2564 void SetForeground(Display display, Surface surface, ColorAlpha color)
2566 OGLSurface oglSurface = surface.driverData;
2568 //Logf("SetForeground\n");
2570 oglSurface.foreground[0] = color.color.r/255.0f;
2571 oglSurface.foreground[1] = color.color.g/255.0f;
2572 oglSurface.foreground[2] = color.color.b/255.0f;
2573 //oglSurface.foreground[3] = 1.0f;
2574 oglSurface.foreground[3] = color.a/255.0f;
2576 //if(!oglSurface.foreground[3])printf("bug");
2579 void SetBackground(Display display, Surface surface, ColorAlpha color)
2581 OGLSurface oglSurface = surface.driverData;
2583 //Logf("SetBackground\n");
2585 oglSurface.background[0] = color.color.r/255.0f;
2586 oglSurface.background[1] = color.color.g/255.0f;
2587 oglSurface.background[2] = color.color.b/255.0f;
2588 //oglSurface.background[3] = 1.0;
2589 oglSurface.background[3] = color.a/255.0f;
2592 void SetBlitTint(Display display, Surface surface, ColorAlpha color)
2594 OGLSurface oglSurface = surface.driverData;
2596 oglSurface.bitmapMult[0] = color.color.r/255.0f;
2597 oglSurface.bitmapMult[1] = color.color.g/255.0f;
2598 oglSurface.bitmapMult[2] = color.color.b/255.0f;
2599 oglSurface.bitmapMult[3] = color.a/255.0f;
2602 ColorAlpha GetPixel(Display display, Surface surface,int x,int y)
2607 void PutPixel(Display display, Surface surface,int x,int y)
2609 OGLSurface oglSurface = surface.driverData;
2611 //Logf("PutPixel\n");
2613 glColor4fv(oglSurface.foreground);
2615 // glVertex2i(x+surface.offset.x, y+surface.offset.y);
2616 glVertex2f(x+surface.offset.x + 0.5f, y+surface.offset.y + 0.5f);
2621 void DrawLine(Display display, Surface surface, int _x1, int _y1, int _x2, int _y2)
2623 OGLSurface oglSurface = surface.driverData;
2624 float x1 = _x1, x2 = _x2, y1 = _y1, y2 = _y2;
2639 x1 += surface.offset.x;
2640 y1 += surface.offset.y;
2641 x2 += surface.offset.x;
2642 y2 += surface.offset.y;
2646 glColor4fv(oglSurface.foreground);
2651 glTexCoord2f(0.5f, 0);
2652 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2653 glTexCoord2f(Max(x2-x1, y2-y1) + 0.5f, 0);
2654 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2663 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2664 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2670 void Rectangle(Display display, Surface surface,int x1,int y1,int x2,int y2)
2672 OGLSurface oglSurface = surface.driverData;
2673 x1 += surface.offset.x;
2674 y1 += surface.offset.y;
2675 x2 += surface.offset.x;
2676 y2 += surface.offset.y;
2678 //Logf("Rectangle\n");
2680 glColor4fv(oglSurface.foreground);
2686 glTexCoord2f(0.5f, 0);
2687 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2688 glTexCoord2f(y2-y1 + 0.5f, 0);
2689 glVertex2f(x1 + 0.5f, y2 + 0.5f);
2691 glTexCoord2f(0.5f, 0);
2692 glVertex2f(x1 + 0.5f, y2 + 0.5f);
2693 glTexCoord2f(x2 - x1 + 0.5f, 0);
2694 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2696 glTexCoord2f(0.5f, 0);
2697 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2698 glTexCoord2f(y1 - y2 + 0.5f, 0);
2699 glVertex2f(x2 + 0.5f, y1 + 0.5f);
2701 glTexCoord2f(0.5f, 0);
2702 glVertex2f(x2 + 0.5f, y1 + 0.5f);
2703 glTexCoord2f(x1 - x2 + 0.5f, 0);
2704 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2709 glBegin(GL_LINE_LOOP);
2716 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2717 glVertex2f(x1 + 0.5f, y2 + 0.5f);
2718 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2719 glVertex2f(x2 + 0.5f, y1 + 0.5f);
2724 void Area(Display display, Surface surface,int x1,int y1,int x2,int y2)
2726 OGLSurface oglSurface = surface.driverData;
2729 glColor4fv(oglSurface.background);
2730 glRecti(x1+surface.offset.x, y1+surface.offset.y,
2731 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
2734 glRectf(x1+surface.offset.x, y1+surface.offset.y,
2735 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
2739 void Clear(Display display, Surface surface, ClearType type)
2741 OGLDisplay oglDisplay = display.driverData;
2742 OGLSurface oglSurface = surface.driverData;
2745 if(type != depthBuffer)
2746 glClearColor(oglSurface.background[0], oglSurface.background[1], oglSurface.background[2], oglSurface.background[3]);
2747 if(type != colorBuffer && !oglDisplay.depthWrite)
2749 glDepthMask((byte)bool::true);
2751 glClear(((type != depthBuffer) ? GL_COLOR_BUFFER_BIT : 0) |
2752 ((type != colorBuffer) ? GL_DEPTH_BUFFER_BIT : 0));
2753 if(type != colorBuffer && !oglDisplay.depthWrite)
2755 glDepthMask((byte)bool::false);
2759 bool ConvertBitmap(DisplaySystem displaySystem, Bitmap bitmap, PixelFormat format, ColorAlpha * palette)
2764 void Blit(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
2766 OGLSurface oglSurface = surface.driverData;
2768 #if !defined(__OLDX__)
2769 // WHY DO WE HAVE GL_ONE HERE ?
2770 /*if(glBlendFuncSeparate && !oglSurface.writingText)
2771 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
2774 if(!oglSurface.writingText)
2776 // glTranslatef(-0.375f, -0.375f, 0.0f);
2777 glEnable(GL_TEXTURE_2D);
2778 glColor4fv(oglSurface.bitmapMult);
2780 else if(oglSurface.xOffset)
2781 glTranslated(oglSurface.xOffset / 64.0/*-0.375*/, 0.0, 0.0);
2783 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
2788 glTexCoord2f((float)sx/ bitmap.width, (float)(sy-h)/ bitmap.height);
2789 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
2790 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy-h)/ bitmap.height);
2791 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
2792 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
2793 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
2794 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
2795 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
2800 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
2801 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
2802 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
2803 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
2804 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
2805 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
2806 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
2807 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
2810 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
2811 glVertex2f((float)dx+surface.offset.x, (float)dy+surface.offset.y);
2812 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
2813 glVertex2f((float)dx+w+surface.offset.x, (float)dy+surface.offset.y);
2814 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
2815 glVertex2f((float)dx+w+surface.offset.x, (float)dy+h+surface.offset.y);
2816 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
2817 glVertex2f((float)dx+surface.offset.x, (float)dy+h+surface.offset.y);
2821 if(!oglSurface.writingText)
2823 glDisable(GL_TEXTURE_2D);
2825 //glTranslate(0.375, 0.375, 0.0);
2827 else if(oglSurface.xOffset)
2828 glTranslated(-oglSurface.xOffset / 64.0/*+0.375*/, 0.0, 0.0);
2830 #if !defined(__OLDX__)
2831 /*if(glBlendFuncSeparate && !oglSurface.writingText)
2832 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
2836 void Stretch(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
2838 OGLSurface oglSurface = surface.driverData;
2840 //glTranslate(-0.375, -0.375, 0.0);
2842 //Logf("Stretch\n");
2844 #if !defined(__OLDX__)
2845 /*if(glBlendFuncSeparate)
2846 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
2849 glEnable(GL_TEXTURE_2D);
2850 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
2852 glColor4fv(oglSurface.bitmapMult);
2858 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
2859 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
2861 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
2862 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
2864 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
2865 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
2867 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
2868 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
2872 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
2873 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
2875 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
2876 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
2878 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
2879 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
2881 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
2882 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
2887 glDisable(GL_TEXTURE_2D);
2889 //glTranslate(0.375, 0.375, 0.0);
2890 #if !defined(__OLDX__)
2891 /*if(glBlendFuncSeparate)
2892 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
2897 void Filter(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
2899 Stretch(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
2902 void StretchDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
2904 float s2dw,s2dh,d2sw,d2sh;
2905 //bool flipX = false, flipY = false;
2907 //Logf("StretchDI\n");
2909 if(Sgn(w) != Sgn(sw))
2915 if(Sgn(h) != Sgn(sh))
2927 //Clip against the edges of the source
2930 dx+=(int)((0-sx) * s2dw);
2931 w-=(int)((0-sx) * s2dw);
2937 dy+=(int)((0-sy) * s2dh);
2938 h-=(int)((0-sy) * s2dh);
2943 if(sx+sw>bitmap.width-1)
2945 w-=(int)((sx+sw-(bitmap.width-1)-1)*s2dw);
2946 sw-=sx+sw-(bitmap.width-1)-1;
2948 if(sy+sh>(bitmap.height-1))
2950 h-=(int)((sy+sh-(bitmap.height-1)-1)*s2dh);
2951 sh-=sy+sh-(bitmap.height-1)-1;
2953 //Clip against the edges of the surfaceination
2954 if(dx<surface.box.left)
2957 sx+=(int)((surface.box.left-dx)*d2sw);
2958 sw-=(int)((surface.box.left-dx)*d2sw);
2959 w-=surface.box.left-dx;
2960 dx=surface.box.left;
2962 if(dy<surface.box.top)
2964 sy+=(int)((surface.box.top-dy)*d2sh);
2965 sh-=(int)((surface.box.top-dy)*d2sh);
2966 h-=surface.box.top-dy;
2969 if(dx+w>surface.box.right)
2971 //if(flip) sx+=(int)((dx+w-surface.box.right-1)*d2sw);
2972 sw-=(int)((dx+w-surface.box.right-1)*d2sw);
2973 w-=dx+w-surface.box.right-1;
2975 if(dy+h>surface.box.bottom)
2977 sh-=(int)((dy+h-surface.box.bottom-1)*d2sh);
2978 h-=dy+h-surface.box.bottom-1;
2980 if((w<=0)||(h<=0)||(sw<=0)||(sh<=0)) return;
2982 dx += surface.offset.x;
2983 dy += surface.offset.y;
2985 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
2987 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
2988 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
2989 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
2990 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
2991 glRasterPos2d(dx,dy);
2992 //glPixelZoom(flipX ? -s2dw : s2dw, flipY ? s2dh : -s2dh);
2993 glPixelZoom(s2dw, -s2dh);
2994 glDrawPixels(sw,sh,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
2995 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
2996 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
2997 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
2998 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3002 void BlitDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
3006 //Clip against the edges of the source
3019 if(sx+w>bitmap.width-1)
3020 w-=sx+w-(bitmap.width-1)-1;
3021 if(sy+h>bitmap.height-1)
3022 h-=sy+h-(bitmap.height-1)-1;
3023 //Clip against the edges of the surfaceination
3024 if(dx<surface.box.left)
3027 sx+=surface.box.left-dx;
3028 w-=surface.box.left-dx;
3029 dx=surface.box.left;
3031 if(dy<surface.box.top)
3033 sy+=surface.box.top-dy;
3034 h-=surface.box.top-dy;
3037 if(dx+w>surface.box.right)
3039 //if(flip) sx+=dx+w-surface.box.right-1;
3040 w-=dx+w-surface.box.right-1;
3042 if(dy+h>surface.box.bottom)
3043 h-=dy+h-surface.box.bottom-1;
3047 dx += surface.offset.x;
3048 dy += surface.offset.y;
3050 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3052 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3053 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3054 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3055 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3056 glRasterPos2d(dx,dy);
3058 glDrawPixels(w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3059 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3060 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3061 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3062 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3066 void FilterDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3068 StretchDI(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3071 void UnloadFont(DisplaySystem displaySystem, Font font)
3073 ((subclass(DisplayDriver))class(LFBDisplayDriver)).UnloadFont(displaySystem, font);
3076 Font LoadFont(DisplaySystem displaySystem, const char * faceName, float size, FontFlags flags)
3079 OGLSystem oglSystem = displaySystem.driverData;
3080 oglSystem.loadingFont = true;
3081 font = ((subclass(DisplayDriver))class(LFBDisplayDriver)).LoadFont(displaySystem, faceName, size, flags);
3085 void FontExtent(DisplaySystem displaySystem, Font font, const char * text, int len, int * width, int * height)
3087 ((subclass(DisplayDriver))class(LFBDisplayDriver)).FontExtent(displaySystem, font, text, len, width, height);
3090 void WriteText(Display display, Surface surface, int x, int y, const char * text, int len)
3092 OGLSurface oglSurface = surface.driverData;
3093 OGLSystem oglSystem = display.displaySystem.driverData;
3094 oglSystem.loadingFont = true;
3096 //glTranslated(-0.375, -0.375, 0.0);
3100 if(surface.textOpacity)
3103 FontExtent(display.displaySystem, surface.font, text, len, &w, &h);
3104 display.displaySystem.driver.Area(display, surface,x,y,x+w-1,y+h-1);
3107 oglSurface.writingText = true;
3109 glEnable(GL_TEXTURE_2D);
3110 glColor4fv(oglSurface.foreground);
3112 ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x, y, text, len);
3113 oglSurface.writingText = false;
3114 oglSystem.loadingFont = false;
3116 glDisable(GL_TEXTURE_2D);
3118 //glTranslated(0.375, 0.375, 0.0);
3121 void TextFont(Display display, Surface surface, Font font)
3123 ((subclass(DisplayDriver))class(LFBDisplayDriver)).TextFont(display, surface, font);
3126 void TextOpacity(Display display, Surface surface, bool opaque)
3128 OGLSurface oglSurface = surface.driverData;
3129 oglSurface.opaqueText = opaque;
3132 void TextExtent(Display display, Surface surface, const char * text, int len, int * width, int * height)
3134 OGLSurface oglSurface = surface.driverData;
3135 OGLSystem oglSystem = display.displaySystem.driverData;
3136 oglSystem.loadingFont = true;
3137 FontExtent(display.displaySystem, oglSurface.font, text, len, width, height);
3138 oglSystem.loadingFont = false;
3141 void DrawingChar(Display display, Surface surface, char character)
3146 void LineStipple(Display display, Surface surface, uint32 stipple)
3148 //Logf("Stipple\n");
3152 #if defined(__ANDROID__)
3153 stippleEnabled = true;
3154 glesLineStipple(1, (uint16)stipple);
3156 glLineStipple(1, (uint16)stipple);
3157 glEnable(GL_LINE_STIPPLE);
3162 #if defined(__ANDROID__)
3163 stippleEnabled = false;
3164 glMatrixMode(GL_TEXTURE);
3166 glMatrixMode(GL_PROJECTION);
3167 glDisable(GL_TEXTURE_2D);
3169 glDisable(GL_LINE_STIPPLE);
3173 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
3174 void SetRenderState(Display display, RenderState state, uint value)
3176 OGLDisplay oglDisplay = display.driverData;
3177 //Logf("RenderState\n");
3183 glEnable(GL_MULTISAMPLE_ARB);
3185 glDisable(GL_MULTISAMPLE_ARB);
3188 glPolygonMode(GL_FRONT_AND_BACK, ((FillModeValue)value == solid) ? GL_FILL : GL_LINE);
3191 if(value) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
3194 if(value) glDepthMask((byte)bool::true); else glDepthMask((byte)bool::false);
3195 oglDisplay.depthWrite = (bool)value;
3199 float color[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3200 glFogfv(GL_FOG_COLOR, (float *)&color);
3204 glFogf(GL_FOG_DENSITY, (float)(RenderStateFloat { ui = value }.f * nearPlane));
3207 if(value) glEnable(GL_BLEND); else glDisable(GL_BLEND);
3211 float ambient[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3212 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
3217 if(value) glColorMask(1,1,1,1); else glColorMask(1,1,1,0);
3222 #if defined(__WIN32__)
3223 wglSwapIntervalEXT(value ? 1 : 0);
3230 void SetLight(Display display, int id, Light light)
3232 //Logf("SetLight\n");
3236 Object lightObject = light.lightObject;
3237 float position[4] = { 0, 0, 0, 0 };
3238 float color[4] = { 0, 0, 0, 1 };
3240 glEnable(GL_LIGHT0 + id);
3242 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, (float *)&light.diffuse);
3243 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, (float *)&light.ambient);
3244 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,(float *)&light.specular);
3247 if(!light.multiplier) light.multiplier = 1.0f;
3249 color[0] = light.diffuse.r * light.multiplier;
3250 color[1] = light.diffuse.g * light.multiplier;
3251 color[2] = light.diffuse.b * light.multiplier;
3252 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, color);
3254 color[0] = light.ambient.r * light.multiplier;
3255 color[1] = light.ambient.g * light.multiplier;
3256 color[2] = light.ambient.b * light.multiplier;
3257 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, color);
3258 color[0] = light.specular.r * light.multiplier;
3259 color[1] = light.specular.g * light.multiplier;
3260 color[2] = light.specular.b * light.multiplier;
3261 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,color);
3265 Vector3D positionVector;
3266 if(light.flags.spot)
3268 if(lightObject.flags.root || !lightObject.parent)
3270 positionVector = lightObject.transform.position;
3271 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3275 positionVector.MultMatrix(lightObject.transform.position, lightObject.parent.matrix);
3276 if(display.display3D.camera)
3277 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3283 if(!light.direction.x && !light.direction.y && !light.direction.z)
3285 Vector3Df vector { 0,0,-1 };
3287 mat.RotationQuaternion(light.orientation);
3288 positionVector.MultMatrixf(vector, mat);
3292 positionVector = light.direction;
3297 position[0] = (float)positionVector.x;
3298 position[1] = (float)positionVector.y;
3299 position[2] = (float)positionVector.z;
3301 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3304 // Display Light Position
3305 glDisable(GL_LIGHTING);
3306 glDisable(GL_DEPTH_TEST);
3310 glVertex3fv(position);
3312 glEnable(GL_DEPTH_TEST);
3313 glEnable(GL_LIGHTING);
3317 if(lightObject.flags.root || !lightObject.parent)
3319 positionVector = light.target.transform.position;
3320 positionVector.Subtract(positionVector, display.camera.cPosition);
3324 positionVector.MultMatrix(light.target.transform.position,
3325 lightObject.light.target.parent.matrix);
3326 positionVector.Subtract(positionVector, display.camera.cPosition);
3329 position[0] = positionVector.x;
3330 position[1] = positionVector.y;
3331 position[2] = positionVector.z;
3333 glDisable(GL_LIGHTING);
3334 glDisable(GL_DEPTH_TEST);
3338 glVertex3fv(position);
3340 glEnable(GL_DEPTH_TEST);
3341 glEnable(GL_LIGHTING);
3344 if(light.flags.attenuation)
3346 glLightf(GL_LIGHT0 + id, GL_CONSTANT_ATTENUATION, light.Kc);
3347 glLightf(GL_LIGHT0 + id, GL_LINEAR_ATTENUATION, light.Kl);
3348 glLightf(GL_LIGHT0 + id, GL_QUADRATIC_ATTENUATION, light.Kq);
3351 if(light.flags.spot)
3354 #define MAXLIGHT 0.9
3355 float direction[4] = { (float)light.direction.x, (float)light.direction.y, (float)light.direction.z, 1 };
3356 // Figure out exponent out of the hot spot
3357 exponent = (float)(log(MAXLIGHT) / log(cos((light.hotSpot / 2))));
3359 glLightfv(GL_LIGHT0 + id, GL_SPOT_DIRECTION, direction);
3360 glLightf(GL_LIGHT0 + id, GL_SPOT_CUTOFF, (float)(light.fallOff / 2));
3361 glLightf(GL_LIGHT0 + id, GL_SPOT_EXPONENT, exponent);
3367 Vector3Df vector { 0,0,-1 };
3368 Vector3Df direction;
3371 mat.RotationQuaternion(light.orientation);
3372 direction.MultMatrix(vector, mat);
3374 position[0] = direction.x;
3375 position[1] = direction.y;
3376 position[2] = direction.z;
3378 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3382 glDisable(GL_LIGHT0 + id);
3385 void SetCamera(Display display, Surface surface, Camera camera)
3387 OGLDisplay oglDisplay = display.driverData;
3388 //Logf("SetCamera\n");
3392 int left = surface.box.left + surface.offset.x;
3393 int top = surface.box.top + surface.offset.y;
3394 int right = surface.box.right + surface.offset.x;
3395 int bottom = surface.box.bottom + surface.offset.y;
3396 float origX = surface.offset.x + camera.origin.x;
3397 float origY = surface.offset.y + camera.origin.y;
3399 int y = display.height - bottom - 1;
3400 int w = right - left + 1;
3401 int h = bottom - top + 1;
3404 glViewport(x, y, w, h);
3406 // *** Projection Matrix ***
3407 if(!display.display3D.camera)
3410 glMatrixMode(GL_PROJECTION);
3411 if(display.display3D.collectingHits)
3413 float pickX = display.display3D.pickX + surface.offset.x;
3414 float pickY = display.height - (display.display3D.pickY + surface.offset.y) - 1;
3418 w / display.display3D.pickWidth, 0, 0, 0,
3419 0, h / display.display3D.pickHeight, 0, 0,
3421 (w + 2.0f * (x - pickX)) / display.display3D.pickWidth,
3422 (h + 2.0f * (y - pickY)) / display.display3D.pickHeight, 0, 1
3425 glLoadMatrixd(pickMatrix.array);
3430 (left - origX) * camera.zMin / camera.focalX,
3431 (right - origX) * camera.zMin / camera.focalX,
3432 (bottom - origY) * camera.zMin / camera.focalY,
3433 (top - origY) * camera.zMin / camera.focalY,
3434 camera.zMin, camera.zMax);
3436 glDisable(GL_BLEND);
3438 // *** Z Inverted Identity Matrix ***
3439 glMatrixMode(GL_MODELVIEW);
3440 if(!display.display3D.camera)
3445 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
3447 // *** View Matrix ***
3448 glMultMatrixd(camera.viewMatrix.array);
3453 glEnable(GL_DEPTH_TEST);
3454 glEnable(GL_LIGHTING);
3455 glShadeModel(GL_SMOOTH);
3456 glDepthMask((byte)bool::true);
3457 oglDisplay.depthWrite = true;
3459 glEnable(GL_MULTISAMPLE_ARB);
3461 else if(display.display3D.camera)
3463 oglDisplay.depthWrite = false;
3464 glViewport(0,0,display.width,display.height);
3466 glDisable(GL_CULL_FACE);
3467 glDisable(GL_DEPTH_TEST);
3468 glDisable(GL_LIGHTING);
3470 glDisable(GL_TEXTURE_2D);
3471 glShadeModel(GL_FLAT);
3473 glDisable(GL_MULTISAMPLE_ARB);
3475 // *** Restore 2D MODELVIEW Matrix ***
3478 // *** Restore 2D PROJECTION Matrix ***
3479 glMatrixMode(GL_PROJECTION);
3483 GLBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
3486 void ApplyMaterial(Display display, Material material, Mesh mesh)
3488 //Logf("ApplyMaterial\n");
3491 if(material.flags.doubleSided)
3493 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, !material.flags.singleSideLight);
3494 glDisable(GL_CULL_FACE);
3498 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, bool::false);
3499 glEnable(GL_CULL_FACE);
3503 if(material.flags.noFog)
3509 if(material.baseMap && mesh.texCoords)
3511 Bitmap map = material.baseMap;
3512 glEnable(GL_TEXTURE_2D);
3513 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)map.driverData);
3515 glMatrixMode(GL_TEXTURE);
3517 if(material.uScale && material.vScale)
3518 glScalef(material.uScale, material.vScale, 1);
3519 glMatrixMode(GL_MODELVIEW);
3521 if(material.flags.tile)
3523 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
3524 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
3528 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
3529 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
3533 glDisable(GL_TEXTURE_2D);
3535 if(mesh.flags.colors)
3537 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
3538 glEnable(GL_COLOR_MATERIAL);
3542 glDisable(GL_COLOR_MATERIAL);
3544 float color[4] = { material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity };
3545 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
3548 float color[4] = { material.ambient.r, material.ambient.g, material.ambient.b, 0 };
3549 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
3553 float color[4] = { material.specular.r, material.specular.g, material.specular.b, 0 };
3554 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, color);
3557 float color[4] = { material.emissive.r, material.emissive.g, material.emissive.b, 0 };
3558 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, color);
3561 glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &material.power);
3564 void FreeMesh(DisplaySystem displaySystem, Mesh mesh)
3566 OGLMesh oglMesh = mesh.data;
3569 if(!mesh.flags.vertices)
3571 if(oglMesh.vertices)
3573 GLDeleteBuffers(1, &oglMesh.vertices);
3574 oglMesh.vertices = 0;
3576 delete mesh.vertices;
3578 if(!mesh.flags.normals)
3582 GLDeleteBuffers(1, &oglMesh.normals);
3583 oglMesh.normals = 0;
3585 delete mesh.normals;
3587 if(!mesh.flags.texCoords1)
3589 if(oglMesh.texCoords)
3591 GLDeleteBuffers(1, &oglMesh.texCoords);
3592 oglMesh.texCoords = 0;
3594 delete mesh.texCoords;
3596 if(!mesh.flags.texCoords2)
3598 if(oglMesh.texCoords2)
3600 GLDeleteBuffers(1, &oglMesh.texCoords2);
3601 oglMesh.texCoords2 = 0;
3604 delete mesh.texCoords2;
3607 if(!mesh.flags.colors)
3611 GLDeleteBuffers(1, &oglMesh.colors);
3623 bool AllocateMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags, int nVertices)
3625 bool result = false;
3628 mesh.data = OGLMesh { };
3631 OGLMesh oglMesh = mesh.data;
3632 if(mesh.nVertices == nVertices)
3634 // Same number of vertices, adding features (Leaves the other features pointers alone)
3635 if(mesh.flags != flags)
3637 if(!mesh.flags.vertices && flags.vertices)
3639 if(flags.doubleVertices)
3641 mesh.vertices = (Vector3Df *)new Vector3D[nVertices];
3644 mesh.vertices = new Vector3Df[nVertices];
3645 if(!oglMesh.vertices)
3646 GLGenBuffers(1, &oglMesh.vertices);
3648 if(!mesh.flags.normals && flags.normals)
3650 if(flags.doubleNormals)
3652 mesh.normals = (Vector3Df *)new Vector3D[nVertices];
3655 mesh.normals = new Vector3Df[nVertices];
3656 if(!oglMesh.normals)
3657 GLGenBuffers( 1, &oglMesh.normals);
3659 if(!mesh.flags.texCoords1 && flags.texCoords1)
3661 mesh.texCoords = new Pointf[nVertices];
3662 if(!oglMesh.texCoords)
3663 GLGenBuffers( 1, &oglMesh.texCoords);
3665 if(!mesh.flags.colors && flags.colors)
3667 mesh.colors = new ColorRGBAf[nVertices];
3669 GLGenBuffers( 1, &oglMesh.colors);
3675 // New number of vertices, reallocate all current and new features
3676 flags |= mesh.flags;
3679 if(flags.doubleVertices)
3681 mesh.vertices = (Vector3Df *)renew mesh.vertices Vector3D[nVertices];
3684 mesh.vertices = renew mesh.vertices Vector3Df[nVertices];
3685 if(!oglMesh.vertices)
3686 GLGenBuffers(1, &oglMesh.vertices);
3690 if(flags.doubleNormals)
3692 mesh.normals = (Vector3Df *)renew mesh.normals Vector3D[nVertices];
3695 mesh.normals = renew mesh.normals Vector3Df[nVertices];
3696 if(!oglMesh.normals)
3697 GLGenBuffers( 1, &oglMesh.normals);
3699 if(flags.texCoords1)
3701 mesh.texCoords = renew mesh.texCoords Pointf[nVertices];
3702 if(!oglMesh.texCoords)
3703 GLGenBuffers( 1, &oglMesh.texCoords);
3707 mesh.colors = renew mesh.colors ColorRGBAf[nVertices];
3709 GLGenBuffers( 1, &oglMesh.colors);
3717 void UnlockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
3719 OGLMesh oglMesh = mesh.data;
3720 if(!flags) flags = mesh.flags;
3724 if(flags.vertices && oglMesh.vertices)
3726 GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.vertices);
3727 GLBufferData( mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT, GL_ARRAY_BUFFER_ARB, mesh.nVertices * (mesh.flags.doubleVertices ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.vertices, GL_STATIC_DRAW_ARB );
3730 if(flags.normals && oglMesh.normals)
3732 GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.normals);
3733 GLBufferData( mesh.flags.doubleNormals ? GL_DOUBLE : GL_FLOAT, GL_ARRAY_BUFFER_ARB, mesh.nVertices * (mesh.flags.doubleNormals ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.normals, GL_STATIC_DRAW_ARB );
3736 if(flags.texCoords1 && oglMesh.texCoords)
3738 GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.texCoords);
3739 GLBufferData( GL_FLOAT, GL_ARRAY_BUFFER_ARB, mesh.nVertices * sizeof(Pointf), mesh.texCoords, GL_STATIC_DRAW_ARB );
3742 if(flags.colors && oglMesh.colors)
3744 GLBindBuffer( GL_ARRAY_BUFFER_ARB, oglMesh.colors);
3745 GLBufferData( GL_FLOAT, GL_ARRAY_BUFFER_ARB, mesh.nVertices * sizeof(ColorRGBAf), mesh.colors, GL_STATIC_DRAW_ARB );
3748 GLBindBuffer( GL_ARRAY_BUFFER_ARB, 0);
3752 bool LockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
3759 void FreeIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
3763 if(oglIndices.buffer)
3764 GLDeleteBuffers(1, &oglIndices.buffer);
3765 delete oglIndices.indices;
3770 void * AllocateIndices(DisplaySystem displaySystem, int nIndices, bool indices32bit)
3772 OGLIndices oglIndices = OGLIndices { };
3775 oglIndices.indices = (void *)(indices32bit ? new uint32[nIndices] : new uint16[nIndices]);
3776 GLGenBuffers( 1, &oglIndices.buffer);
3777 oglIndices.nIndices = nIndices;
3782 void UnlockIndices(DisplaySystem displaySystem, OGLIndices oglIndices, bool indices32bit, int nIndices)
3786 GLBindBuffer( GL_ELEMENT_ARRAY_BUFFER_ARB, oglIndices.buffer);
3787 GLBufferData( indices32bit ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT, GL_ELEMENT_ARRAY_BUFFER_ARB, nIndices * (indices32bit ? sizeof(uint32) : sizeof(uint16)),
3788 oglIndices.indices, GL_STATIC_DRAW_ARB);
3789 GLBindBuffer( GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
3793 uint16 * LockIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
3796 return oglIndices.indices;
3799 void SelectMesh(Display display, Mesh mesh)
3801 //Logf("SelectMesh\n");
3803 #if !defined( __ANDROID__) && !defined(__APPLE__)
3805 #if defined(__WIN32__)
3806 if(glUnlockArraysEXT)
3808 if(!vboAvailable && display.display3D.mesh)
3809 glUnlockArraysEXT();
3814 OGLMesh oglMesh = mesh.data;
3816 // *** Vertex Stream ***
3817 glEnableClientState(GL_VERTEX_ARRAY);
3818 if(!display.display3D.collectingHits && oglMesh)
3820 GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.vertices );
3821 glVertexPointer(3, mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT, 0, vboAvailable ? null : mesh.vertices);
3823 // *** Normals Stream ***
3826 glEnableClientState(GL_NORMAL_ARRAY);
3827 GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.normals);
3828 glNormalPointer(mesh.flags.doubleNormals ? GL_DOUBLE : GL_FLOAT, 0, vboAvailable ? null : mesh.normals);
3831 glDisableClientState(GL_NORMAL_ARRAY);
3833 // *** Texture Coordinates Stream ***
3836 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
3837 GLBindBuffer( GL_ARRAY_BUFFER_ARB, oglMesh.texCoords);
3838 glTexCoordPointer(2, GL_FLOAT, 0, vboAvailable ? null : mesh.texCoords);
3841 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
3843 // *** Color Stream ***
3846 glEnableClientState(GL_COLOR_ARRAY);
3847 GLBindBuffer( GL_ARRAY_BUFFER_ARB, oglMesh.colors);
3848 glColorPointer(4, GL_FLOAT, 0, vboAvailable ? null : mesh.colors);
3851 glDisableClientState(GL_COLOR_ARRAY);
3856 GLBindBuffer( GL_ARRAY_BUFFER_ARB, 0);
3857 glVertexPointer(3,mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT,0,mesh.vertices);
3858 if(mesh.normals && !display.display3D.collectingHits)
3860 glEnableClientState(GL_NORMAL_ARRAY);
3861 glNormalPointer(mesh.flags.doubleNormals ? GL_DOUBLE : GL_FLOAT, 0, mesh.normals);
3864 glDisableClientState(GL_NORMAL_ARRAY);
3865 if(mesh.texCoords && !display.display3D.collectingHits)
3867 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
3868 glTexCoordPointer(2, GL_FLOAT, 0, mesh.texCoords);
3871 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
3872 if(mesh.colors && !display.display3D.collectingHits)
3874 glEnableClientState(GL_COLOR_ARRAY);
3875 glColorPointer(4, GL_FLOAT, 0, mesh.colors);
3878 glDisableClientState(GL_COLOR_ARRAY);
3881 #if !defined(__ANDROID__) && !defined(__APPLE__)
3883 #if defined(__WIN32__)
3887 glLockArraysEXT(0, mesh.nVertices);
3892 GLBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
3895 void DrawPrimitives(Display display, PrimitiveSingle * primitive, Mesh mesh)
3897 //Logf("DrawPrimitives\n");
3899 if(primitive->type.vertexRange)
3900 glDrawArrays(primitiveTypes[primitive->type.primitiveType], primitive->first, primitive->nVertices);
3903 // *** Hoping the data won't be uploaded at all (Won't really work if another group of the mesh is using the mesh ) ***
3904 // HACK TO SPEED THINGS UP...
3906 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
3907 if(primitive->nIndices < (mesh.nVertices >> 2) && !primitive->type.indices32bit)
3910 glBegin(primitiveTypes[primitive->type.primitiveType]);
3913 OGLIndices oglIndices = primitive->data;
3914 MeshFeatures flags = mesh.flags;
3915 for(c = 0; c<primitive->nIndices; c++)
3917 uint16 index = ((uint16 *) oglIndices.indices)[c];
3918 if(flags.normals) glNormal3fv((float *)&mesh.normals[index]);
3919 if(flags.texCoords1) glTexCoord2fv((float *)&mesh.texCoords[index]);
3920 if(flags.colors) glColor4fv((float *)&mesh.colors[index]);
3921 glVertex3fv((float *)&mesh.vertices[index]);
3929 OGLIndices oglIndices = primitive->data;
3931 if(!display.display3D.collectingHits && vboAvailable && oglIndices)
3933 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, oglIndices.buffer);
3934 glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
3935 primitive->type.indices32bit ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT, 0);
3936 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
3939 glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
3940 primitive->type.indices32bit ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT, oglIndices ? oglIndices.indices : primitive->indices);
3945 void PushMatrix(Display display)
3950 void PopMatrix(Display display, bool setMatrix)
3955 void SetTransform(Display display, Matrix transMatrix, bool viewSpace, bool useCamera)
3957 Matrix matrix = transMatrix;
3958 Camera camera = useCamera ? display.display3D.camera : null;
3963 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
3968 matrix.m[3][0] - camera.cPosition.x,
3969 matrix.m[3][1] - camera.cPosition.y,
3970 matrix.m[3][2] - camera.cPosition.z);
3982 glMultMatrixd(matrix.array);
3987 public void UseSingleGLContext(bool useSingle)
3989 useSingleGLContext = useSingle;
3992 default dllexport void *
3993 #if defined(__WIN32__)
3994 __attribute__((stdcall))
3996 IS_GLGetContext(DisplaySystem displaySystem)
4000 #if defined(__WIN32__)
4001 OGLSystem system = displaySystem.driverData;
4003 #elif !defined(__ANDROID__)
4004 OGLSystem system = displaySystem.driverData;
4005 return system.glContext;