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 0x0500
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 )
859 q.RotationAxis({(float)b,(float)-c,(float)d}, a );
860 m.RotationQuaternion(q);
861 matrixStack[curStack][matrixIndex[curStack]].Rotate(q);
864 void glesScaled( double a, double b, double c )
870 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
871 matrixStack[curStack][matrixIndex[curStack]] = r;
875 void glesTranslated( double a, double b, double c )
881 r.Multiply(m, matrixStack[curStack][matrixIndex[curStack]]);
882 matrixStack[curStack][matrixIndex[curStack]] = r;
886 void glesMultMatrixd( double * i )
889 r.Multiply((Matrix *)i, matrixStack[curStack][matrixIndex[curStack]]);
890 matrixStack[curStack][matrixIndex[curStack]] = r;
894 void glesMatrixMode(int mode)
896 curStack = mode == GL_MODELVIEW ? 0 : mode == GL_PROJECTION ? 1 : 2;
900 #define glPushMatrix glesPushMatrix
901 #define glPopMatrix glesPopMatrix
902 #define glLoadIdentity glesLoadIdentity
903 #define glMatrixMode glesMatrixMode
905 /* Using the built-in matrix stack
906 void glesLoadMatrixd( double * i )
910 (float)i[0],(float)i[1],(float)i[2],(float)i[3],
911 (float)i[4],(float)i[5],(float)i[6],(float)i[7],
912 (float)i[8],(float)i[9],(float)i[10],(float)i[11],
913 (float)i[12],(float)i[13],(float)i[14],(float)i[15]
918 void glesOrtho( double l, double r, double b, double t, double n, double f )
922 { (float)(2 / (r - l)), 0, 0, 0 },
923 { 0, (float)(2 / (t - b)), 0, 0 },
924 { 0, 0, (float)(-2 / (f - n)), 0 },
925 { (float)(-(r + l) / (r - l)), (float)(-(t + b) / (t - b)), (float)(-(f + n) / (f - n)), 1 }
927 glMultMatrixf((float *)matrix);
930 void glesFrustum( double l, double r, double b, double t, double n, double f )
932 float A = (float)((r + l) / (r - l));
933 float B = (float)((t + b) / (t - b));
934 float C = (float)(-(f + n) / (f - n));
935 float D = (float)(-2*f*n/(f-n));
938 { (float)(2*n / (r - l)), 0, 0, 0 },
939 { 0, (float)(2*n / (t - b)), 0, 0 },
943 glMultMatrixf((float *)matrix);
946 void glesRotated( double a, double b, double c, double d ) { glRotatef((float)a, (float)b, (float)c, (float)d); }
947 void glesScaled( double a, double b, double c ) { glScalef((float)a, (float)b, (float)c); }
948 void glesTranslated( double a, double b, double c ) { glTranslatef((float)a, (float)b, (float)c); }
950 void glesMultMatrixd( double * i )
954 (float)i[0], (float)i[1], (float)i[2], (float)i[3],
955 (float)i[4], (float)i[5], (float)i[6], (float)i[7],
956 (float)i[8], (float)i[9], (float)i[10], (float)i[11],
957 (float)i[12], (float)i[13], (float)i[14], (float)i[15]
963 // Need to do these...
964 void glesVertex3f( float x, float y, float z )
967 if(vertexCount + 4 > beginBufferSize)
969 beginBufferSize = beginBufferSize + beginBufferSize/2;
970 vertexPointer = renew vertexPointer float[beginBufferSize * 5];
973 vertexPointer[vertexCount*5+2] = x;
974 vertexPointer[vertexCount*5+3] = y;
975 vertexPointer[vertexCount*5+4] = z;
978 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
980 vertexPointer[vertexCount*5+2] = vertexPointer[(vertexCount-4)*5+2];
981 vertexPointer[vertexCount*5+3] = vertexPointer[(vertexCount-4)*5+3];
982 vertexPointer[vertexCount*5+4] = vertexPointer[(vertexCount-4)*5+4];
984 vertexPointer[vertexCount*5+2] = vertexPointer[(vertexCount-3)*5+2];
985 vertexPointer[vertexCount*5+3] = vertexPointer[(vertexCount-3)*5+3];
986 vertexPointer[vertexCount*5+4] = vertexPointer[(vertexCount-3)*5+4];
992 void glesVertex3d( double x, double y, double z ) { glesVertex3f((float)x, (float)y, (float)z); }
993 void glesVertex3fv( float* coords ) { glesVertex3f(coords[0], coords[1], coords[2]); }
995 void glesNormal3f(float x, float y, float z)
997 normalCount = vertexCount;
998 if(vertexCount + 4 > normalBufferSize)
1000 normalBufferSize = normalBufferSize + normalBufferSize/2;
1001 normalPointer = renew normalPointer float[normalBufferSize * 2];
1004 normalPointer[normalCount*3+0] = x;
1005 normalPointer[normalCount*3+1] = y;
1006 normalPointer[normalCount*3+2] = z;
1009 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
1011 normalPointer[normalCount*3+0] = normalPointer[(normalCount-4)*3+0];
1012 normalPointer[normalCount*3+1] = normalPointer[(normalCount-4)*3+1];
1013 normalPointer[normalCount*3+2] = normalPointer[(normalCount-4)*3+2];
1015 normalPointer[normalCount*3+0] = normalPointer[(normalCount-3)*3+0];
1016 normalPointer[normalCount*3+1] = normalPointer[(normalCount-3)*3+1];
1017 normalPointer[normalCount*3+2] = normalPointer[(normalCount-3)*3+2];
1021 void glesNormal3fd(double x, double y, double z) { glesNormal3f((float)x, (float)y, (float)z); }
1022 void glesNormal3fv(float * coords) { glesNormal3f(coords[0], coords[1], coords[2]); }
1024 void glesColorMaterial(int a, int b)
1026 PrintLn("glColorMaterial stub");
1029 void glesTerminate()
1031 delete vertexPointer;
1032 beginBufferSize = 0;
1034 delete floatVPBuffer;
1037 delete shortVPBuffer;
1040 delete shortBDBuffer;
1044 static GLuint stippleTexture;
1045 static bool stippleEnabled;
1047 void glesLineStipple( int i, unsigned short j )
1051 for(x = 0; x < 16; x++)
1053 bool v = (j & (1 << x)) != 0;
1054 texture[x] = v ? 0xFFFFFFFF : 0;
1057 glGenTextures(1, &stippleTexture);
1058 glBindTexture(GL_TEXTURE_2D, stippleTexture);
1059 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture);
1060 glEnable(GL_TEXTURE_2D);
1061 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1062 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1063 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
1064 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1065 glMatrixMode(GL_TEXTURE);
1067 //glTranslated(1.0/backAttrib->texW/2.0f, 1.0/backAttrib->texH/2.0f, 0.0f);
1068 glScaled(i/16.0, 1, 1.0f);
1069 glTranslated(0.5, 0.5, 0);
1070 glMatrixMode(GL_PROJECTION);
1073 void glesLightModeli( unsigned int pname, int param )
1075 if(pname == GL_LIGHT_MODEL_TWO_SIDE)
1076 glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, param);
1079 void glClearDepth( double depth ) { glClearDepthf((float)depth); }
1080 void glFogi( unsigned int pname, int param ) { }
1081 void glPolygonMode( unsigned int i, unsigned int j ) { }
1084 // *** Picking won't be supported for now ***
1085 void glPushName( unsigned int i ) { }
1086 void glLoadName( unsigned int i ) { }
1087 void glPopName() { }
1089 // Probably replace by regular glBlendFunc ...
1090 void glBlendFuncSeparate(int a, int b, int c, int d)
1095 // For direct pixel blitting...
1096 void glRasterPos2d(double a, double b) { }
1097 void glPixelZoom(float a, float b) { }
1098 void glDrawPixels(int a, int b, int c, int d, void * e) { }
1102 /* Non OpenGL ES friendly stuff
1103 #undef GL_UNSIGNED_INT
1108 #undef GL_QUAD_STRIP
1109 #undef GL_POLYGON_STIPPLE
1110 #undef GL_LINE_STIPPLE
1113 #undef GL_ALL_ATTRIB_BITS
1114 #undef GL_LIGHT_MODEL_LOCAL_VIEWER
1119 #if !defined(__APPLE__)
1120 void (APIENTRY * glBindBufferARB) (GLenum target, GLuint buffer);
1121 void (APIENTRY * glGenBuffersARB) (GLsizei n, GLuint *buffers);
1122 void (APIENTRY * glDeleteBuffersARB) (GLsizei n, const GLuint *buffers);
1123 void (APIENTRY * glBufferDataARB) (GLenum target, int size, const GLvoid *data, GLenum usage);
1128 static int currentVertexBuffer;
1130 bool GLSelectVBO(uint vbo)
1132 if(currentVertexBuffer != vbo)
1134 GLBindBuffer(GL_ARRAY_BUFFER, vbo);
1135 currentVertexBuffer = vbo;
1141 void GLGenBuffers(int count, uint * buffer)
1144 glGenBuffers(count, buffer);
1146 #if defined(__WIN32__)
1149 glGenBuffersARB(count, buffer);
1153 void GLDeleteBuffers(int count, GLuint * buffer)
1156 glDeleteBuffers(count, buffer);
1158 #if defined(__WIN32__)
1159 if(glDeleteBuffersARB)
1161 glDeleteBuffersARB(count, buffer);
1165 void GLBindBuffer(int target, uint buffer)
1168 glBindBuffer(target, buffer);
1170 #if defined(__WIN32__)
1173 glBindBufferARB(target, buffer);
1177 void GLBufferData(int type, GLenum target, int size, const GLvoid *data, GLenum usage)
1180 if(type == GL_DOUBLE)
1181 glesBufferDatad(target, size, (void *)data, usage);
1182 else if(type == GL_UNSIGNED_INT)
1183 glesBufferDatai(target, size, (void *)data, usage);
1185 glBufferData(target, size, data, usage);
1188 #if defined(__WIN32__)
1191 glBufferDataARB(target, size, data, usage);
1196 static int displayWidth, displayHeight;
1198 #define GL_CLAMP_TO_EDGE 0x812F
1200 static bool vboAvailable;
1202 static bool useSingleGLContext = false;
1203 class OGLDisplay : struct
1205 #if defined(__WIN32__)
1215 int imageBuffers[2];
1216 byte * pboMemory1, * pboMemory2;
1218 #elif !defined(__ANDROID__)
1219 GLXContext glContext;
1222 XShmSegmentInfo shminfo;
1224 XShmSegmentInfo shminfoShape;
1225 XImage * shapeImage;
1229 X11Picture windowPicture;
1230 X11Picture pixmapPicture;
1232 X11Picture shapePicture;
1235 ColorAlpha * flippingBuffer;
1236 int flipBufH, flipBufW;
1241 class OGLSystem : struct
1246 #if defined(__WIN32__)
1247 PIXELFORMATDESCRIPTOR pfd;
1252 #elif !defined(__ANDROID__)
1253 XVisualInfo * visualInfo;
1254 GLXContext glContext;
1255 GLXDrawable glxDrawable;
1259 class OGLSurface : struct
1266 float foreground[4], background[4], bitmapMult[4];
1269 class OGLMesh : struct
1278 class OGLIndices : struct
1285 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1286 static int primitiveTypes[RenderPrimitiveType] =
1288 GL_POINTS, GL_LINES, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP, GL_LINE_STRIP
1295 class OpenGLDisplayDriver : DisplayDriver
1297 class_property(name) = "OpenGL";
1299 bool LockSystem(DisplaySystem displaySystem)
1301 #if !defined(__ANDROID__)
1302 OGLSystem oglSystem = displaySystem.driverData;
1303 if(useSingleGLContext) return true;
1304 #if defined(__WIN32__)
1305 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1306 #elif defined(__unix__) || defined(__APPLE__)
1307 //if(previous) return true;
1308 // printf("Making SYSTEM current\n");
1309 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)oglSystem.glxDrawable, oglSystem.glContext);
1310 //previous = oglSystem.glContext;
1316 void UnlockSystem(DisplaySystem displaySystem)
1318 if(useSingleGLContext) return;
1319 #if defined(__WIN32__)
1320 wglMakeCurrent(null, null);
1321 #elif defined(__unix__) || defined(__APPLE__)
1322 // printf("Making NULL current\n");
1323 #if defined(__ANDROID__)
1325 glXMakeCurrent(xGlobalDisplay, None, null);
1331 bool Lock(Display display)
1333 #if !defined(__ANDROID__)
1334 OGLDisplay oglDisplay = display.driverData;
1335 if(useSingleGLContext) return true;
1336 #if defined(__WIN32__)
1337 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1338 #elif defined(__unix__) || defined(__APPLE__)
1339 // if(previous) glXMakeCurrent(xGlobalDisplay, None, null);
1340 // printf(" Making DISPLAY current\n");
1341 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
1347 void Unlock(Display display)
1349 if(useSingleGLContext) return;
1350 //printf(" Making NULL current\n");
1351 //glXMakeCurrent(xGlobalDisplay, None, null);
1353 LockSystem(display.displaySystem);
1356 void DestroyDisplay(Display display)
1358 OGLDisplay oglDisplay = display.driverData;
1362 #if defined(__WIN32__)
1363 wglMakeCurrent( null, null );
1366 wglDeleteContext(oglDisplay.glrc);
1368 if(oglDisplay.hdc && oglDisplay.pBuffer)
1369 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
1371 if(oglDisplay.pBuffer)
1372 wglDestroyPbufferARB(oglDisplay.pBuffer);
1375 ReleaseDC(display.window, oglDisplay.hdc);
1377 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
1378 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
1380 #elif defined(__unix__) || defined(__APPLE__)
1381 #if defined(__ANDROID__)
1383 if(oglDisplay.shapePixmap)
1384 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
1385 if(oglDisplay.pixmap)
1386 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1387 if(oglDisplay.image)
1389 if(oglDisplay.shminfoShape.shmid != -1)
1391 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
1392 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1393 shmdt(oglDisplay.shminfo.shmaddr);
1394 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
1397 if(oglDisplay.shapeImage)
1399 if(oglDisplay.shminfoShape.shmid != -1)
1401 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
1402 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1403 shmdt(oglDisplay.shminfoShape.shmaddr);
1404 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
1406 XDestroyImage(oglDisplay.shapeImage);
1407 oglDisplay.shapeImage = None;
1410 glXMakeCurrent(xGlobalDisplay, None, null);
1412 if(oglDisplay.glContext)
1413 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
1416 delete oglDisplay.flippingBuffer;
1418 display.driverData = null;
1422 void ::CheckExtensions(OGLSystem oglSystem)
1424 const char * extensions = (const char *)glGetString(GL_EXTENSIONS);
1426 oglSystem.pow2textures = strstr(extensions, "GL_ARB_texture_non_power_of_two") ? false : true;
1427 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &oglSystem.maxTextureSize);
1430 bool CreateDisplaySystem(DisplaySystem displaySystem)
1432 bool result = false;
1433 OGLSystem oglSystem = displaySystem.driverData = OGLSystem { };
1436 oglSystem.hwnd = CreateWindow("static", null, 0,0,0,0,0,null,null,null,null);
1438 oglSystem.hdc = GetDC(oglSystem.hwnd);
1442 oglSystem.pfd.nSize = (short)sizeof(oglSystem.pfd);
1443 oglSystem.pfd.nVersion = 1;
1444 oglSystem.pfd.dwFlags = PFD_DRAW_TO_WINDOW /*PFD_DRAW_TO_BITMAP*/ | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
1445 oglSystem.pfd.iPixelType = PFD_TYPE_RGBA;
1446 oglSystem.pfd.cColorBits = 24;
1447 oglSystem.pfd.cAlphaBits = 8;
1448 oglSystem.pfd.cDepthBits = 24;
1449 oglSystem.pfd.iLayerType = PFD_MAIN_PLANE;
1451 oglSystem.format = ChoosePixelFormat(oglSystem.hdc, &oglSystem.pfd);
1452 DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1454 if(oglSystem.pfd.cColorBits > 8)
1456 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1457 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1460 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1462 // Get Pointers To The GL Functions
1463 glActiveTextureARB = (void *) wglGetProcAddress("glActiveTextureARB");
1464 glMultiTexCoord2fARB = (void *) wglGetProcAddress("glMultiTexCoord2fARB");
1465 glClientActiveTextureARB = (void *) wglGetProcAddress("glClientActiveTextureARB");
1466 glLockArraysEXT = (void *) wglGetProcAddress("glLockArraysEXT" );
1467 glUnlockArraysEXT = (void *) wglGetProcAddress("glUnlockArraysEXT");
1468 glGenBuffersARB = (void *) wglGetProcAddress("glGenBuffersARB");
1469 glBindBufferARB = (void *) wglGetProcAddress("glBindBufferARB");
1470 glBufferDataARB = (void *) wglGetProcAddress("glBufferDataARB");
1471 glMapBufferARB = (void *) wglGetProcAddress("glMapBufferARB");
1472 glUnmapBufferARB = (void *) wglGetProcAddress("glUnmapBufferARB");
1473 glDeleteBuffersARB = (void *) wglGetProcAddress("glDeleteBuffersARB");
1474 glBlendFuncSeparate = (void *) wglGetProcAddress("glBlendFuncSeparate");
1476 wglChoosePixelFormatARB = (void *) wglGetProcAddress("wglChoosePixelFormatARB");
1477 wglGetExtensionsStringARB = (void *)wglGetProcAddress("wglGetExtensionsStringARB");
1478 wglCreatePbufferARB = (void *)wglGetProcAddress("wglCreatePbufferARB");
1479 wglGetPbufferDCARB = (void *)wglGetProcAddress("wglGetPbufferDCARB");
1480 wglQueryPbufferARB = (void *)wglGetProcAddress("wglQueryPbufferARB");
1481 wglDestroyPbufferARB = (void *)wglGetProcAddress("wglDestroyPbufferARB");
1482 wglReleasePbufferDCARB = (void *)wglGetProcAddress("wglReleasePbufferDCARB");
1483 wglBindTexImageARB = (void *)wglGetProcAddress("wglBindTexImageARB");
1484 wglReleaseTexImageARB = (void *)wglGetProcAddress("wglReleaseTexImageARB");
1486 wglSwapIntervalEXT = (void *)wglGetProcAddress("wglSwapIntervalEXT");
1488 vboAvailable = glBindBufferARB != null;
1490 // eSystem_LoggingMode(LOG_MSGBOX, null);
1492 if(wglChoosePixelFormatARB)
1497 float fAttributes[] = {0,0};
1500 WGL_DRAW_TO_WINDOW_ARB,GL_TRUE,
1501 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1502 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
1503 WGL_COLOR_BITS_ARB,24,
1504 WGL_ALPHA_BITS_ARB,8,
1505 WGL_DEPTH_BITS_ARB,16,
1506 WGL_STENCIL_BITS_ARB,0,
1507 WGL_DOUBLE_BUFFER_ARB,GL_TRUE,
1508 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
1509 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
1513 //Log("Found wglChoosePixelFormatARB\n");
1515 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1516 if(!valid || !numFormats)
1518 //Log("Can't find 4x multi sampling\n");
1519 iAttributes[19] = 2;
1520 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1521 if(!valid || !numFormats)
1523 // Log("Can't find 2x multi sampling\n");
1524 iAttributes[16] = 0;
1525 iAttributes[17] = 0;
1526 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1529 if(valid && numFormats)
1531 oglSystem.format = pixelFormat;
1532 wglMakeCurrent(null, null);
1533 wglDeleteContext(oglSystem.glrc);
1535 // *** DescribePixelFormat does not support WGL pixel formats! ***
1536 //DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1537 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1538 //Log("Successfully set pixel format\n");
1540 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1541 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1545 eSystem_Logf("Can't find wglChoosePixelFormatARB\n");*/
1549 CheckExtensions(oglSystem);
1551 wglMakeCurrent(null, null);
1553 //eSystem_DumpErrors(true);
1557 #elif defined(__unix__) || defined(__APPLE__)
1558 vboAvailable = true;
1559 #if defined(__ANDROID__)
1560 egl_init_display(guiApp.desktop.windowHandle);
1561 CheckExtensions(oglSystem);
1565 X11Window root = RootWindow( xGlobalDisplay, DefaultScreen( xGlobalDisplay ) );
1566 XSetWindowAttributes attr;
1571 #ifndef ECERE_MINIGLX
1572 GLX_USE_GL, GLX_DEPTH_SIZE, 1,
1575 GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,
1579 oglSystem.visualInfo = glXChooseVisual( xGlobalDisplay, DefaultScreen( xGlobalDisplay ), attrList );
1580 attr.background_pixel = 0;
1581 attr.border_pixel = 0;
1582 attr.colormap = XCreateColormap( xGlobalDisplay, root, oglSystem.visualInfo->visual, AllocNone);
1583 attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
1584 mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
1586 oglSystem.glxDrawable = XCreateWindow( xGlobalDisplay, root, 0, 0, 1, 1, 0, oglSystem.visualInfo->depth, InputOutput,
1587 oglSystem.visualInfo->visual, mask, &attr );
1589 if(oglSystem.visualInfo)
1591 oglSystem.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, null, True);
1592 if(oglSystem.glContext)
1594 glXMakeCurrent(xGlobalDisplay, oglSystem.glxDrawable, oglSystem.glContext);
1596 CheckExtensions(oglSystem);
1597 glXMakeCurrent(xGlobalDisplay, None, null);
1604 displaySystem.flags.alpha = true;
1605 displaySystem.flags.flipping = true;
1606 displaySystem.pixelFormat = pixelFormat888;
1610 void DestroyDisplaySystem(DisplaySystem displaySystem)
1612 OGLSystem oglSystem = displaySystem.driverData;
1614 #if defined(__WIN32__)
1615 wglMakeCurrent( null, null );
1618 wglDeleteContext(oglSystem.glrc);
1621 ReleaseDC(oglSystem.hwnd, oglSystem.hdc);
1622 DestroyWindow(oglSystem.hwnd);
1624 #elif defined(__unix__) || defined(__APPLE__)
1625 #if defined(__ANDROID__)
1628 if(oglSystem.visualInfo)
1630 #ifdef ECERE_MINIGLX
1631 __miniglx_XFree(oglSystem.visualInfo);
1633 XFree(oglSystem.visualInfo);
1637 if(oglSystem.glxDrawable)
1639 XDestroyWindow(xGlobalDisplay, oglSystem.glxDrawable);
1640 oglSystem.glxDrawable = 0;
1647 bool CreateDisplay(Display display)
1649 bool result = false;
1650 OGLDisplay oglDisplay = display.driverData;
1651 #if !defined(__ANDROID__)
1652 OGLSystem oglSystem = display.displaySystem.driverData;
1655 oglDisplay = display.driverData = OGLDisplay { };
1656 //printf("Inside CreateDisplay\n");
1658 #if defined(__WIN32__) || defined(USEPBUFFER)
1659 if(!display.alphaBlend)
1662 #if defined(__WIN32__)
1663 oglDisplay.hdc = GetDC(display.window);
1664 SetPixelFormat(oglDisplay.hdc, oglSystem.format, &oglSystem.pfd);
1665 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
1667 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
1668 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1672 ReleaseDC(display.window, oglDisplay.hdc);
1673 #elif defined(__unix__) || defined(__APPLE__)
1674 #if defined(__ANDROID__)
1676 XVisualInfo * visualInfo = ((XWindowData)display.windowDriverData).visual;
1678 #if defined(__APPLE__)
1679 XVisualInfo template = { 0 };
1680 XWindowAttributes winAttr;
1682 XGetWindowAttributes(xGlobalDisplay, (X11Window)display.window, &winAttr);
1683 template.visualid = XVisualIDFromVisual(winAttr.visual);
1684 visualInfo = XGetVisualInfo(xGlobalDisplay, VisualIDMask, &template, &n);
1686 printf("XGetVisualInfo visual ID = %d\n", template.visualid);
1687 printf("visualInfo visual ID = %d\n", visualInfo->visualid);
1688 printf("oglSystem.visualInfo visual ID = %d\n", oglSystem.visualInfo->visualid);
1689 printf("((XWindowData)display.windowDriverData).visual visual ID = %d\n", ((XWindowData)display.windowDriverData).visual->visualid);
1691 // visualInfo = oglSystem.visualInfo;
1696 //printf("visualInfo is not null\n");
1697 // printf("Creating Display Context, sharing with %x!\n", oglSystem.glContext);
1698 oglDisplay.glContext = glXCreateContext(xGlobalDisplay, visualInfo, oglSystem.glContext, True);
1699 //XFree(visualInfo);
1702 // oglDisplay.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, oglSystem.glContext, True);
1703 if(oglDisplay.glContext)
1705 //printf("CreateDisplay Got a Context\n");
1706 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
1712 #if defined(__WIN32__) || defined(USEPBUFFER)
1718 #if defined(__WIN32__)
1719 if(glBlendFuncSeparate)
1720 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1722 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1724 #if !defined(__OLDX__)
1725 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1727 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1732 glMatrixMode(GL_MODELVIEW);
1733 glScaled(1.0, 1.0, -1.0);
1734 // glTranslatef(0.375f, 0.375f, 0.0f);
1735 // glTranslatef(-0.625f, -0.625f, 0.0f);
1736 glMatrixMode(GL_PROJECTION);
1737 glShadeModel(GL_FLAT);
1739 // glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, true);
1740 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
1741 glFogi(GL_FOG_MODE, GL_EXP);
1742 glFogf(GL_FOG_DENSITY, 0);
1743 glEnable(GL_NORMALIZE);
1744 glDepthFunc(GL_LESS);
1746 glDisable(GL_MULTISAMPLE_ARB);
1748 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1749 display.ambient = Color { 50,50,50 };
1752 if(!useSingleGLContext)
1754 #if defined(__WIN32__)
1755 wglMakeCurrent(null, null);
1756 #elif defined(__unix__) || defined(__APPLE__)
1757 #if defined(__ANDROID__)
1760 glXMakeCurrent(xGlobalDisplay, None, null);
1768 bool DisplaySize(Display display, int width, int height)
1770 OGLDisplay oglDisplay = display.driverData;
1772 bool result = false;
1774 //printf("Inside DisplaySize\n");
1775 #if defined(__WIN32__) || defined(USEPBUFFER)
1776 OGLSystem oglSystem = display.displaySystem.driverData;
1777 if(display.alphaBlend)
1779 #if defined(__WIN32__)
1780 const int attributes[]=
1782 /*WGL_TEXTURE_FORMAT_ARB, WGL_TEXTURE_RGBA_ARB,
1783 WGL_TEXTURE_TARGET_ARB, WGL_TEXTURE_2D_ARB, */0
1785 int pixelFormat = 0;
1786 if(wglChoosePixelFormatARB)
1790 float fAttributes[] = {0,0};
1793 //WGL_DRAW_TO_BITMAP_ARB, GL_TRUE,
1794 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
1795 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1796 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
1797 WGL_COLOR_BITS_ARB,24,
1798 WGL_ALPHA_BITS_ARB,8,
1799 WGL_DEPTH_BITS_ARB,16,
1800 WGL_STENCIL_BITS_ARB,0,
1801 WGL_DOUBLE_BUFFER_ARB,GL_FALSE,
1802 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
1803 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
1807 //Log("Found wglChoosePixelFormatARB\n");
1809 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1810 if(!valid || !numFormats)
1812 //Log("Can't find 4x multi sampling\n");
1813 iAttributes[19] = 2;
1814 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1815 if(!valid || !numFormats)
1817 // Log("Can't find 2x multi sampling\n");
1818 iAttributes[16] = 0;
1819 iAttributes[17] = 0;
1820 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1821 if(!valid || !numFormats)
1825 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
1826 //WGL_DRAW_TO_BITMAP_ARB,GL_TRUE,
1827 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1828 WGL_COLOR_BITS_ARB,24,
1829 WGL_ALPHA_BITS_ARB,8,
1830 WGL_DEPTH_BITS_ARB,16,
1833 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1837 if(valid && numFormats)
1839 wglMakeCurrent(null, null);
1843 wglMakeCurrent( null, null );
1844 wglMakeCurrent( oglDisplay.hdc, oglDisplay.glrc );
1845 if(oglDisplay.hdc && oglDisplay.pBuffer)
1846 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
1848 wglDestroyPbufferARB(oglDisplay.pBuffer);
1850 if(!useSingleGLContext)
1851 wglMakeCurrent( null, null );
1854 wglDeleteContext(oglDisplay.glrc);
1856 oglDisplay.pBuffer = wglCreatePbufferARB(oglSystem.hdc, pixelFormat, width, height, attributes);
1857 oglDisplay.hdc = wglGetPbufferDCARB(oglDisplay.pBuffer);
1858 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
1861 HDC hdc = GetDC(display.window);
1863 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
1864 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1866 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_WIDTH_ARB, &width);
1867 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_HEIGHT_ARB, &height);
1869 // glDeleteBuffersARB(2, oglDisplay.imageBuffers);
1871 if((info = (BITMAPINFO *)new0 byte[sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*256]))
1875 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
1876 oglDisplay.memDC = CreateCompatibleDC(hdc);
1877 SetMapMode(oglDisplay.memDC, MM_TEXT);
1878 info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1879 info->bmiHeader.biPlanes = 1;
1880 info->bmiHeader.biCompression = BI_RGB;
1881 info->bmiHeader.biBitCount = 32; //(uint16)GetDeviceCaps(hdc, BITSPIXEL);
1882 info->bmiHeader.biWidth = width;
1883 info->bmiHeader.biHeight = height;
1884 newBitmap = CreateDIBSection(hdc, info, DIB_RGB_COLORS, &oglDisplay.picture, null, 0);
1887 SelectObject(oglDisplay.memDC, newBitmap);
1888 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
1891 PIXELFORMATDESCRIPTOR pfd = { 0 };
1892 pfd.nSize = (short)sizeof(pfd);
1894 pfd.dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL;
1895 pfd.iPixelType = PFD_TYPE_RGBA;
1896 pfd.cColorBits = 32;
1897 //pfd.cAlphaBits = 8;
1898 pfd.cDepthBits = 24;
1899 pfd.iLayerType = PFD_MAIN_PLANE;
1901 oglDisplay.hdc = oglDisplay.memDC;
1903 pixelFormat = ChoosePixelFormat(oglSystem.hdc, &pfd);
1904 DescribePixelFormat(oglDisplay.hdc, pixelFormat, sizeof(pfd), &pfd);
1905 SetPixelFormat(oglDisplay.hdc, pixelFormat, &pfd);
1907 oglDisplay.glrc = wglCreateContext(oglDisplay.hdc);
1908 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
1909 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1914 const int imageSize = width * height * 4;
1916 glGenBuffersARB(2, oglDisplay.imageBuffers);
1918 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
1919 glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize, null, GL_STREAM_READ);
1920 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
1921 // glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize / 2, null, GL_STREAM_READ);
1924 oglDisplay.memBitmap = newBitmap;
1925 oglDisplay.stride = width;
1931 ReleaseDC(display.window, hdc);
1933 #elif defined(__unix__) || defined(__APPLE__)
1934 #if defined(__ANDROID__)
1939 GLX_DOUBLEBUFFER, True,
1945 GLX_STENCIL_SIZE, 1,
1946 //GLX_DEPTH_SIZE, 24,
1947 GLX_RENDER_TYPE, GLX_RGBA_BIT,
1948 GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT | GLX_WINDOW_BIT,
1954 GLX_PBUFFER_WIDTH, width,
1955 GLX_PBUFFER_HEIGHT, height,
1956 GLX_LARGEST_PBUFFER, False,
1960 // choose a pixel format that meets our minimum requirements
1963 GLXFBConfig *config = glXChooseFBConfig(xGlobalDisplay, DefaultScreen(xGlobalDisplay), attrib, &count);
1966 if(oglDisplay.pixmap)
1968 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1969 oglDisplay.pixmap = None;
1971 if(oglDisplay.shapePixmap)
1973 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
1974 oglDisplay.shapePixmap = None;
1977 // Free Shared Memory Pixmap
1978 if(oglDisplay.image)
1980 if(oglDisplay.shminfoShape.shmid != -1)
1982 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
1983 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1984 shmdt(oglDisplay.shminfo.shmaddr);
1985 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
1987 XDestroyImage(oglDisplay.image);
1988 oglDisplay.image = None;
1990 if(oglDisplay.shapeImage)
1992 if(oglDisplay.shminfoShape.shmid != -1)
1994 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
1995 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1996 shmdt(oglDisplay.shminfoShape.shmaddr);
1997 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
1999 XDestroyImage(oglDisplay.shapeImage);
2000 oglDisplay.shapeImage = None;
2003 if(oglDisplay.windowPicture)
2004 XRenderFreePicture(xGlobalDisplay, oglDisplay.windowPicture);
2005 if(oglDisplay.pixmapPicture)
2006 XRenderFreePicture(xGlobalDisplay, oglDisplay.pixmapPicture);
2008 if(oglDisplay.pixmap)
2009 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
2011 if(oglDisplay.glContext)
2012 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
2013 if(oglDisplay.pBuffer)
2014 glXDestroyPbuffer(xGlobalDisplay, oglDisplay.pBuffer);
2016 oglDisplay.pBuffer = glXCreatePbuffer(xGlobalDisplay, config[0], PBattrib);
2017 if(oglDisplay.pBuffer)
2019 oglDisplay.glContext = glXCreateNewContext(xGlobalDisplay, config[0], GLX_RGBA_TYPE, oglSystem.glContext, True);
2020 if(oglDisplay.glContext)
2022 glXMakeCurrent(xGlobalDisplay, None, null);
2023 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2025 // Initialize Shared Memory Pixmap
2026 oglDisplay.image = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 32,
2027 ZPixmap, null, &oglDisplay.shminfo, width, height);
2028 if(oglDisplay.image)
2030 oglDisplay.shminfo.shmid = shmget(IPC_PRIVATE,
2031 oglDisplay.image->bytes_per_line * oglDisplay.image->height, IPC_CREAT|0777);
2032 if(oglDisplay.shminfo.shmid != -1)
2034 oglDisplay.shminfo.shmaddr = shmat(oglDisplay.shminfo.shmid, 0, 0);
2035 if(oglDisplay.shminfo.shmaddr != (void *)-1)
2037 oglDisplay.shminfo.readOnly = False;
2038 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfo))
2040 oglDisplay.pixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfo.shmaddr,
2041 &oglDisplay.shminfo, width, height, 32);
2043 // Initialize Shared Memory Shape Pixmap
2044 oglDisplay.shapeImage = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 1,
2045 ZPixmap, null, &oglDisplay.shminfoShape, width, height);
2046 if(oglDisplay.shapeImage)
2048 oglDisplay.shminfoShape.shmid = shmget(IPC_PRIVATE,
2049 oglDisplay.shapeImage->bytes_per_line * oglDisplay.shapeImage->height, IPC_CREAT|0777);
2050 if(oglDisplay.shminfoShape.shmid != -1)
2052 oglDisplay.shminfoShape.shmaddr = shmat(oglDisplay.shminfoShape.shmid, 0, 0);
2053 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
2055 oglDisplay.shminfoShape.readOnly = False;
2056 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfoShape))
2058 oglDisplay.shapePixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfoShape.shmaddr,
2059 &oglDisplay.shminfoShape, width, height, 1);
2060 //oglDisplay.shapePixmap = XCreatePixmap(xGlobalDisplay, (X11Window)display.window, width, height, 1);
2063 XRenderPictureAttributes attributes = { 0 };
2064 XRenderPictFormat * format = XRenderFindStandardFormat(xGlobalDisplay, /*PictStandardRGB24*/ PictStandardARGB32);
2065 #if !defined(__APPLE__) && !defined(__OLDX__)
2066 attributes.repeat = RepeatNormal;
2068 attributes.repeat = 1;
2070 oglDisplay.pixmapPicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.pixmap, format, CPRepeat, &attributes);
2071 oglDisplay.windowPicture = XRenderCreatePicture(xGlobalDisplay, (X11Window)display.window, format, 0, &attributes);
2072 oglDisplay.shapePicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.shapePixmap,
2073 XRenderFindStandardFormat(xGlobalDisplay, PictStandardA1), 0, &attributes);
2076 oglDisplay.picture = oglDisplay.shminfo.shmaddr;
2077 oglDisplay.stride = oglDisplay.image->bytes_per_line / 4;
2094 CreateDisplay(display);
2095 #if defined(__WIN32__)
2096 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
2097 #elif defined(__unix__) || defined(__APPLE__)
2098 #if defined(__ANDROID__)
2102 glXMakeCurrent(xGlobalDisplay, (GLXDrawable)display.window, oglDisplay.glContext);
2109 if(!result && display.alphaBlend)
2111 printf("Alpha blending windows not supported on this display\n");
2118 glViewport(0,0,width,height);
2120 glOrtho(0,width,height,0,0.0,1.0);
2121 displayWidth = display.width = width;
2122 displayHeight = display.height = height;
2124 if(!oglDisplay.flippingBuffer || oglDisplay.flipBufW < width || oglDisplay.flipBufH < height)
2126 oglDisplay.flipBufW = width;
2127 oglDisplay.flipBufH = height;
2128 oglDisplay.flippingBuffer = renew oglDisplay.flippingBuffer ColorAlpha [width * height];
2130 if(oglDisplay.flippingBuffer || !width || !height)
2136 void DisplayPosition(Display display, int x, int y)
2138 OGLDisplay oglDisplay = display.driverData;
2144 void SetPalette(Display display, ColorAlpha * palette, bool colorMatch)
2148 void RestorePalette(Display display)
2152 void StartUpdate(Display display)
2156 void EndUpdate(Display display)
2160 void Scroll(Display display, Box scroll, int x, int y, Extent dirty)
2164 void Update(Display display, Box updateBox)
2166 #if defined(__WIN32__) || defined(USEPBUFFER)
2167 OGLDisplay oglDisplay = display.driverData;
2169 //Logf("DisplayScreen\n");
2173 #if defined(__WIN32__) || defined(USEPBUFFER)
2174 if(display.alphaBlend)
2176 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2177 glPixelStorei(GL_PACK_ROW_LENGTH, oglDisplay.stride);
2178 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2179 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2180 glReadPixels(0,0,display.width,display.height,GL_BGRA_EXT,GL_UNSIGNED_BYTE, oglDisplay.picture);
2183 #if defined(__WIN32__)
2185 POINT point = { oglDisplay.x, oglDisplay.y};
2186 POINT srcPoint = { 0, 0 };
2187 BLENDFUNCTION blend = { 0 };
2189 size.cx = display.width;
2190 size.cy = display.height;
2191 blend.BlendOp = AC_SRC_OVER;
2192 blend.BlendFlags = 0;
2193 blend.SourceConstantAlpha = 255;
2194 blend.AlphaFormat = AC_SRC_ALPHA;
2197 // Process partial images. Mapping the buffer waits for
2198 // outstanding DMA transfers into the buffer to finish.
2199 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2200 oglDisplay.pboMemory1 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY);
2202 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2203 // oglDisplay.pboMemory2 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB,GL_READ_ONLY);
2206 memcpy(oglDisplay.picture, oglDisplay.pboMemory1, display.width * display.height * 4);
2207 //memcpy(oglDisplay.picture + display.width * display.height * 4 / 2, oglDisplay.pboMemory2, display.width * display.height * 4/ 2);
2210 UpdateLayeredWindow(display.window, hdc, &point, &size, oglDisplay.memDC, &srcPoint, 0, &blend, ULW_ALPHA);
2213 // Unmap the image buffers
2214 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2215 glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2217 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2218 // glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2220 // Bind two different buffer objects and start the glReadPixels
2221 // asynchronously. Each call will return directly after
2222 // starting the DMA transfer.
2223 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2224 glReadPixels(0, 0, display.width, display.height, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2226 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2227 // glReadPixels(0, display.height/2, display.width, display.height/2, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2231 #elif defined(__unix__) || defined(__APPLE__)
2232 #if defined(__ANDROID__)
2234 XTransform transform =
2237 { (int)(1.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(0 * (1 << 16)) },
2238 { (int)(0.0f), (int)(-1.0f * (1<<16)), (int)(0 * (1<<16)) },
2239 { (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)) }
2242 XRenderSetPictureTransform(xGlobalDisplay, oglDisplay.pixmapPicture, &transform);
2243 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.shapePicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2244 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.windowPicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2245 #if !defined(__APPLE__) && !defined(__OLDX__)
2246 XShapeCombineMask(xGlobalDisplay, (X11Window)display.window, ShapeInput, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2248 XShapeCombineMask(xGlobalDisplay, display.window, 2, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2250 XFlush(xGlobalDisplay);
2258 #if defined(__WIN32__)
2259 //wglSwapLayerBuffers(oglDisplay.hdc,WGL_SWAP_MAIN_PLANE);
2260 SwapBuffers(oglDisplay.hdc);
2261 #elif defined(__unix__) || defined(__APPLE__)
2262 #if defined(__ANDROID__)
2263 eglSwapBuffers(eglDisplay, eglSurface);
2265 glXSwapBuffers(xGlobalDisplay, (GLXDrawable)display.window);
2269 //Logf("Out of DisplayScreen\n");
2272 void FreeBitmap(DisplaySystem displaySystem, Bitmap bitmap)
2274 if(bitmap.driverData)
2276 GLuint tex = (GLuint)(uintptr)bitmap.driverData;
2277 glDeleteTextures(1, &tex);
2278 bitmap.driverData = 0;
2280 bitmap.driver = ((subclass(DisplayDriver))class(LFBDisplayDriver));
2283 bool AllocateBitmap(DisplaySystem displaySystem, Bitmap bitmap, int width, int height, int stride, PixelFormat format, bool allocatePalette)
2285 OGLSystem oglSystem = displaySystem.driverData;
2286 bool result = false;
2288 GLuint glBitmap = 0;
2290 uint w = width, h = height;
2291 if(oglSystem.pow2textures)
2296 w = Min(w, oglSystem.maxTextureSize);
2297 h = Min(h, oglSystem.maxTextureSize);
2299 glGenTextures(1, &glBitmap);
2300 glBindTexture(GL_TEXTURE_2D, glBitmap);
2302 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2304 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2305 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2307 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2308 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2310 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2312 mipMap.Allocate(null, w, h, w, pixelFormatRGBA, false);
2314 // glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2315 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2319 bitmap.driverData = (void *)(uintptr)glBitmap;
2320 bitmap.driver = displaySystem.driver;
2328 bool MakeDDBitmap(DisplaySystem displaySystem, Bitmap bitmap, bool mipMaps)
2330 bool result = false;
2331 OGLSystem oglSystem = displaySystem.driverData;
2333 // Pre process the bitmap... First make it 32 bit
2334 if(/*bitmap.pixelFormat == pixelFormatRGBA || */bitmap.Convert(null, pixelFormat888, null))
2337 uint w = bitmap.width, h = bitmap.height;
2338 GLuint glBitmap = 0;
2339 if(oglSystem.pow2textures)
2344 w = Min(w, oglSystem.maxTextureSize);
2345 h = Min(h, oglSystem.maxTextureSize);
2349 while(w * 2 < h) w *= 2;
2350 while(h * 2 < w) h *= 2;
2353 // Switch ARGB to RGBA
2354 //if(bitmap.format != pixelFormatRGBA)
2356 for(c=0; c<bitmap.size; c++)
2358 // ((ColorRGBA *)bitmap.picture)[c] = ((ColorAlpha *)bitmap.picture)[c];
2360 ColorAlpha color = ((ColorAlpha *)bitmap.picture)[c];
2361 ((ColorRGBA *)bitmap.picture)[c] = ColorRGBA { color.color.r, color.color.g, color.color.b, color.a };
2364 bitmap.pixelFormat = pixelFormat888;
2367 glGenTextures(1, &glBitmap);
2370 //int error = glGetError();
2374 glBindTexture(GL_TEXTURE_2D, glBitmap);
2375 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2377 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2378 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mipMaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
2379 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2381 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
2382 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
2384 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2385 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2387 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2391 for(level = 0; result && (w > 1 || h > 1); level++, w >>= 1, h >>= 1)
2394 if(bitmap.width != w || bitmap.height != h)
2396 mipMap = Bitmap { };
2397 if(mipMap.Allocate(null, w, h, w, bitmap.pixelFormat, false))
2399 Surface mipSurface = mipMap.GetSurface(0,0,null);
2400 mipSurface.Filter(bitmap, 0,0,0,0, w, h, bitmap.width, bitmap.height);
2417 // glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2418 glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2419 //printf("Calling glTexImage2D\n");
2420 //glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &width);
2421 //printf("width = %d (Should be %d, %d)\n", width, w, h);
2422 if((error = glGetError()))
2424 //Logf("OpenGL Bitmap MakeDD error: %d...\n", error);
2425 //printf("OpenGL Bitmap MakeDD error: %d...\n", error);
2429 if(mipMap != bitmap)
2434 if(!bitmap.keepData)
2435 bitmap.driver.FreeBitmap(bitmap.displaySystem, bitmap);
2436 bitmap.driverData = (void *)(uintptr)glBitmap;
2437 bitmap.driver = displaySystem.driver;
2440 FreeBitmap(displaySystem, bitmap);
2441 else if(oglSystem.loadingFont)
2443 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2444 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2445 oglSystem.loadingFont = false;
2451 void ReleaseSurface(Display display, Surface surface)
2453 glDisable(GL_SCISSOR_TEST);
2454 delete surface.driverData;
2455 surface.driverData = null;
2458 bool GetBitmapSurface(DisplaySystem displaySystem, Surface surface, Bitmap bitmap, int x, int y, Box clip)
2463 bool GetSurface(Display display, Surface surface, int x,int y, Box clip)
2465 bool result = false;
2466 OGLSurface oglSurface = surface.driverData = OGLSurface { };
2468 //Logf("GetSurface\n");
2472 if(displayWidth != display.width || displayHeight != display.height)
2474 displayWidth = display.width;
2475 displayHeight = display.height;
2477 glViewport(0,0,display.width,display.height);
2479 glOrtho(0,display.width,display.height,0,0.0,1.0);
2482 surface.offset.x = x;
2483 surface.offset.y = y;
2484 surface.unclippedBox = surface.box = clip;
2485 oglSurface.bitmapMult[0] = 1;
2486 oglSurface.bitmapMult[1] = 1;
2487 oglSurface.bitmapMult[2] = 1;
2488 oglSurface.bitmapMult[3] = 1;
2490 glEnable(GL_SCISSOR_TEST);
2493 (display.height) -(y+clip.bottom)-1,
2494 clip.right-clip.left+1,
2495 clip.bottom-clip.top+1);
2501 void Clip(Display display, Surface surface, Box clip)
2510 box.Clip(surface.unclippedBox);
2514 box = surface.box = surface.unclippedBox;
2515 box.left += surface.offset.x;
2516 box.top += surface.offset.y;
2517 box.right+= surface.offset.x;
2518 box.bottom += surface.offset.y;
2521 box.left,display.height - box.bottom - 1,
2522 box.right-box.left+1, box.bottom-box.top+1);
2525 bool GrabScreen(Display display, Bitmap bitmap, int x, int y, unsigned int w, unsigned int h)
2527 bool result = false;
2528 OGLDisplay oglDisplay = display.driverData;
2529 ColorAlpha * flippingBuffer = oglDisplay.flippingBuffer;
2531 if(oglDisplay.flippingBuffer)
2533 if(bitmap.pixelFormat != pixelFormat888 || bitmap.width < w || bitmap.height < h)
2536 bitmap.Allocate(null, w,h,w, pixelFormat888, false);
2542 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2543 glPixelStorei(GL_PACK_ROW_LENGTH, bitmap.stride);
2544 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2545 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2546 glReadPixels(x,display.height-h-y,w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, flippingBuffer);
2549 for(row = 0; row<h; row++)
2550 CopyBytesBy4(((ColorAlpha *)bitmap.picture) + row * w, ((ColorAlpha *)flippingBuffer) + (h-row-1) * w, w);
2557 void SetForeground(Display display, Surface surface, ColorAlpha color)
2559 OGLSurface oglSurface = surface.driverData;
2561 //Logf("SetForeground\n");
2563 oglSurface.foreground[0] = color.color.r/255.0f;
2564 oglSurface.foreground[1] = color.color.g/255.0f;
2565 oglSurface.foreground[2] = color.color.b/255.0f;
2566 //oglSurface.foreground[3] = 1.0f;
2567 oglSurface.foreground[3] = color.a/255.0f;
2569 //if(!oglSurface.foreground[3])printf("bug");
2572 void SetBackground(Display display, Surface surface, ColorAlpha color)
2574 OGLSurface oglSurface = surface.driverData;
2576 //Logf("SetBackground\n");
2578 oglSurface.background[0] = color.color.r/255.0f;
2579 oglSurface.background[1] = color.color.g/255.0f;
2580 oglSurface.background[2] = color.color.b/255.0f;
2581 //oglSurface.background[3] = 1.0;
2582 oglSurface.background[3] = color.a/255.0f;
2585 void SetBlitTint(Display display, Surface surface, ColorAlpha color)
2587 OGLSurface oglSurface = surface.driverData;
2589 oglSurface.bitmapMult[0] = color.color.r/255.0f;
2590 oglSurface.bitmapMult[1] = color.color.g/255.0f;
2591 oglSurface.bitmapMult[2] = color.color.b/255.0f;
2592 oglSurface.bitmapMult[3] = color.a/255.0f;
2595 ColorAlpha GetPixel(Display display, Surface surface,int x,int y)
2600 void PutPixel(Display display, Surface surface,int x,int y)
2602 OGLSurface oglSurface = surface.driverData;
2604 //Logf("PutPixel\n");
2606 glColor4fv(oglSurface.foreground);
2608 // glVertex2i(x+surface.offset.x, y+surface.offset.y);
2609 glVertex2f(x+surface.offset.x + 0.5f, y+surface.offset.y + 0.5f);
2614 void DrawLine(Display display, Surface surface, int _x1, int _y1, int _x2, int _y2)
2616 OGLSurface oglSurface = surface.driverData;
2617 float x1 = _x1, x2 = _x2, y1 = _y1, y2 = _y2;
2632 x1 += surface.offset.x;
2633 y1 += surface.offset.y;
2634 x2 += surface.offset.x;
2635 y2 += surface.offset.y;
2639 glColor4fv(oglSurface.foreground);
2644 glTexCoord2f(0.5f, 0);
2645 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2646 glTexCoord2f(Max(x2-x1, y2-y1) + 0.5f, 0);
2647 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2656 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2657 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2663 void Rectangle(Display display, Surface surface,int x1,int y1,int x2,int y2)
2665 OGLSurface oglSurface = surface.driverData;
2666 x1 += surface.offset.x;
2667 y1 += surface.offset.y;
2668 x2 += surface.offset.x;
2669 y2 += surface.offset.y;
2671 //Logf("Rectangle\n");
2673 glColor4fv(oglSurface.foreground);
2679 glTexCoord2f(0.5f, 0);
2680 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2681 glTexCoord2f(y2-y1 + 0.5f, 0);
2682 glVertex2f(x1 + 0.5f, y2 + 0.5f);
2684 glTexCoord2f(0.5f, 0);
2685 glVertex2f(x1 + 0.5f, y2 + 0.5f);
2686 glTexCoord2f(x2 - x1 + 0.5f, 0);
2687 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2689 glTexCoord2f(0.5f, 0);
2690 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2691 glTexCoord2f(y1 - y2 + 0.5f, 0);
2692 glVertex2f(x2 + 0.5f, y1 + 0.5f);
2694 glTexCoord2f(0.5f, 0);
2695 glVertex2f(x2 + 0.5f, y1 + 0.5f);
2696 glTexCoord2f(x1 - x2 + 0.5f, 0);
2697 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2702 glBegin(GL_LINE_LOOP);
2709 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2710 glVertex2f(x1 + 0.5f, y2 + 0.5f);
2711 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2712 glVertex2f(x2 + 0.5f, y1 + 0.5f);
2717 void Area(Display display, Surface surface,int x1,int y1,int x2,int y2)
2719 OGLSurface oglSurface = surface.driverData;
2722 glColor4fv(oglSurface.background);
2723 glRecti(x1+surface.offset.x, y1+surface.offset.y,
2724 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
2727 glRectf(x1+surface.offset.x, y1+surface.offset.y,
2728 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
2732 void Clear(Display display, Surface surface, ClearType type)
2734 OGLDisplay oglDisplay = display.driverData;
2735 OGLSurface oglSurface = surface.driverData;
2738 if(type != depthBuffer)
2739 glClearColor(oglSurface.background[0], oglSurface.background[1], oglSurface.background[2], oglSurface.background[3]);
2740 if(type != colorBuffer && !oglDisplay.depthWrite)
2742 glDepthMask((byte)bool::true);
2744 glClear(((type != depthBuffer) ? GL_COLOR_BUFFER_BIT : 0) |
2745 ((type != colorBuffer) ? GL_DEPTH_BUFFER_BIT : 0));
2746 if(type != colorBuffer && !oglDisplay.depthWrite)
2748 glDepthMask((byte)bool::false);
2752 bool ConvertBitmap(DisplaySystem displaySystem, Bitmap bitmap, PixelFormat format, ColorAlpha * palette)
2757 void Blit(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
2759 OGLSurface oglSurface = surface.driverData;
2761 #if !defined(__OLDX__)
2762 // WHY DO WE HAVE GL_ONE HERE ?
2763 /*if(glBlendFuncSeparate && !oglSurface.writingText)
2764 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
2767 if(!oglSurface.writingText)
2769 // glTranslatef(-0.375f, -0.375f, 0.0f);
2770 glEnable(GL_TEXTURE_2D);
2771 glColor4fv(oglSurface.bitmapMult);
2773 else if(oglSurface.xOffset)
2774 glTranslated(oglSurface.xOffset / 64.0/*-0.375*/, 0.0, 0.0);
2776 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
2781 glTexCoord2f((float)sx/ bitmap.width, (float)(sy-h)/ bitmap.height);
2782 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
2783 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy-h)/ bitmap.height);
2784 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
2785 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
2786 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
2787 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
2788 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
2793 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
2794 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
2795 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
2796 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
2797 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
2798 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
2799 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
2800 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
2803 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
2804 glVertex2f((float)dx+surface.offset.x, (float)dy+surface.offset.y);
2805 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
2806 glVertex2f((float)dx+w+surface.offset.x, (float)dy+surface.offset.y);
2807 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
2808 glVertex2f((float)dx+w+surface.offset.x, (float)dy+h+surface.offset.y);
2809 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
2810 glVertex2f((float)dx+surface.offset.x, (float)dy+h+surface.offset.y);
2814 if(!oglSurface.writingText)
2816 glDisable(GL_TEXTURE_2D);
2818 //glTranslate(0.375, 0.375, 0.0);
2820 else if(oglSurface.xOffset)
2821 glTranslated(-oglSurface.xOffset / 64.0/*+0.375*/, 0.0, 0.0);
2823 #if !defined(__OLDX__)
2824 /*if(glBlendFuncSeparate && !oglSurface.writingText)
2825 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
2829 void Stretch(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
2831 OGLSurface oglSurface = surface.driverData;
2833 //glTranslate(-0.375, -0.375, 0.0);
2835 //Logf("Stretch\n");
2837 #if !defined(__OLDX__)
2838 /*if(glBlendFuncSeparate)
2839 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
2842 glEnable(GL_TEXTURE_2D);
2843 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)bitmap.driverData);
2845 glColor4fv(oglSurface.bitmapMult);
2851 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
2852 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
2854 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
2855 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
2857 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
2858 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
2860 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
2861 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
2865 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
2866 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
2868 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
2869 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
2871 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
2872 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
2874 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
2875 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
2880 glDisable(GL_TEXTURE_2D);
2882 //glTranslate(0.375, 0.375, 0.0);
2883 #if !defined(__OLDX__)
2884 /*if(glBlendFuncSeparate)
2885 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
2890 void Filter(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
2892 Stretch(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
2895 void StretchDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
2897 float s2dw,s2dh,d2sw,d2sh;
2898 //bool flipX = false, flipY = false;
2900 //Logf("StretchDI\n");
2902 if(Sgn(w) != Sgn(sw))
2908 if(Sgn(h) != Sgn(sh))
2920 //Clip against the edges of the source
2923 dx+=(int)((0-sx) * s2dw);
2924 w-=(int)((0-sx) * s2dw);
2930 dy+=(int)((0-sy) * s2dh);
2931 h-=(int)((0-sy) * s2dh);
2936 if(sx+sw>bitmap.width-1)
2938 w-=(int)((sx+sw-(bitmap.width-1)-1)*s2dw);
2939 sw-=sx+sw-(bitmap.width-1)-1;
2941 if(sy+sh>(bitmap.height-1))
2943 h-=(int)((sy+sh-(bitmap.height-1)-1)*s2dh);
2944 sh-=sy+sh-(bitmap.height-1)-1;
2946 //Clip against the edges of the surfaceination
2947 if(dx<surface.box.left)
2950 sx+=(int)((surface.box.left-dx)*d2sw);
2951 sw-=(int)((surface.box.left-dx)*d2sw);
2952 w-=surface.box.left-dx;
2953 dx=surface.box.left;
2955 if(dy<surface.box.top)
2957 sy+=(int)((surface.box.top-dy)*d2sh);
2958 sh-=(int)((surface.box.top-dy)*d2sh);
2959 h-=surface.box.top-dy;
2962 if(dx+w>surface.box.right)
2964 //if(flip) sx+=(int)((dx+w-surface.box.right-1)*d2sw);
2965 sw-=(int)((dx+w-surface.box.right-1)*d2sw);
2966 w-=dx+w-surface.box.right-1;
2968 if(dy+h>surface.box.bottom)
2970 sh-=(int)((dy+h-surface.box.bottom-1)*d2sh);
2971 h-=dy+h-surface.box.bottom-1;
2973 if((w<=0)||(h<=0)||(sw<=0)||(sh<=0)) return;
2975 dx += surface.offset.x;
2976 dy += surface.offset.y;
2978 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
2980 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
2981 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
2982 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
2983 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
2984 glRasterPos2d(dx,dy);
2985 //glPixelZoom(flipX ? -s2dw : s2dw, flipY ? s2dh : -s2dh);
2986 glPixelZoom(s2dw, -s2dh);
2987 glDrawPixels(sw,sh,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
2988 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
2989 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
2990 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
2991 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
2995 void BlitDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
2999 //Clip against the edges of the source
3012 if(sx+w>bitmap.width-1)
3013 w-=sx+w-(bitmap.width-1)-1;
3014 if(sy+h>bitmap.height-1)
3015 h-=sy+h-(bitmap.height-1)-1;
3016 //Clip against the edges of the surfaceination
3017 if(dx<surface.box.left)
3020 sx+=surface.box.left-dx;
3021 w-=surface.box.left-dx;
3022 dx=surface.box.left;
3024 if(dy<surface.box.top)
3026 sy+=surface.box.top-dy;
3027 h-=surface.box.top-dy;
3030 if(dx+w>surface.box.right)
3032 //if(flip) sx+=dx+w-surface.box.right-1;
3033 w-=dx+w-surface.box.right-1;
3035 if(dy+h>surface.box.bottom)
3036 h-=dy+h-surface.box.bottom-1;
3040 dx += surface.offset.x;
3041 dy += surface.offset.y;
3043 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
3045 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
3046 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
3047 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
3048 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
3049 glRasterPos2d(dx,dy);
3051 glDrawPixels(w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
3052 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3053 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
3054 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
3055 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
3059 void FilterDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
3061 StretchDI(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
3064 void UnloadFont(DisplaySystem displaySystem, Font font)
3066 ((subclass(DisplayDriver))class(LFBDisplayDriver)).UnloadFont(displaySystem, font);
3069 Font LoadFont(DisplaySystem displaySystem, const char * faceName, float size, FontFlags flags)
3072 OGLSystem oglSystem = displaySystem.driverData;
3073 oglSystem.loadingFont = true;
3074 font = ((subclass(DisplayDriver))class(LFBDisplayDriver)).LoadFont(displaySystem, faceName, size, flags);
3078 void FontExtent(DisplaySystem displaySystem, Font font, const char * text, int len, int * width, int * height)
3080 ((subclass(DisplayDriver))class(LFBDisplayDriver)).FontExtent(displaySystem, font, text, len, width, height);
3083 void WriteText(Display display, Surface surface, int x, int y, const char * text, int len)
3085 OGLSurface oglSurface = surface.driverData;
3086 OGLSystem oglSystem = display.displaySystem.driverData;
3087 oglSystem.loadingFont = true;
3089 //glTranslated(-0.375, -0.375, 0.0);
3093 if(surface.textOpacity)
3096 FontExtent(display.displaySystem, surface.font, text, len, &w, &h);
3097 display.displaySystem.driver.Area(display, surface,x,y,x+w-1,y+h-1);
3100 oglSurface.writingText = true;
3102 glEnable(GL_TEXTURE_2D);
3103 glColor4fv(oglSurface.foreground);
3105 ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x, y, text, len);
3106 oglSurface.writingText = false;
3107 oglSystem.loadingFont = false;
3109 glDisable(GL_TEXTURE_2D);
3111 //glTranslated(0.375, 0.375, 0.0);
3114 void TextFont(Display display, Surface surface, Font font)
3116 ((subclass(DisplayDriver))class(LFBDisplayDriver)).TextFont(display, surface, font);
3119 void TextOpacity(Display display, Surface surface, bool opaque)
3121 OGLSurface oglSurface = surface.driverData;
3122 oglSurface.opaqueText = opaque;
3125 void TextExtent(Display display, Surface surface, const char * text, int len, int * width, int * height)
3127 OGLSurface oglSurface = surface.driverData;
3128 OGLSystem oglSystem = display.displaySystem.driverData;
3129 oglSystem.loadingFont = true;
3130 FontExtent(display.displaySystem, oglSurface.font, text, len, width, height);
3131 oglSystem.loadingFont = false;
3134 void DrawingChar(Display display, Surface surface, char character)
3139 void LineStipple(Display display, Surface surface, uint32 stipple)
3141 //Logf("Stipple\n");
3145 #if defined(__ANDROID__)
3146 stippleEnabled = true;
3147 glesLineStipple(1, (uint16)stipple);
3149 glLineStipple(1, (uint16)stipple);
3150 glEnable(GL_LINE_STIPPLE);
3155 #if defined(__ANDROID__)
3156 stippleEnabled = false;
3157 glMatrixMode(GL_TEXTURE);
3159 glMatrixMode(GL_PROJECTION);
3160 glDisable(GL_TEXTURE_2D);
3162 glDisable(GL_LINE_STIPPLE);
3166 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
3167 void SetRenderState(Display display, RenderState state, uint value)
3169 OGLDisplay oglDisplay = display.driverData;
3170 //Logf("RenderState\n");
3176 glEnable(GL_MULTISAMPLE_ARB);
3178 glDisable(GL_MULTISAMPLE_ARB);
3181 glPolygonMode(GL_FRONT_AND_BACK, ((FillModeValue)value == solid) ? GL_FILL : GL_LINE);
3184 if(value) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
3187 if(value) glDepthMask((byte)bool::true); else glDepthMask((byte)bool::false);
3188 oglDisplay.depthWrite = (bool)value;
3192 float color[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3193 glFogfv(GL_FOG_COLOR, (float *)&color);
3197 glFogf(GL_FOG_DENSITY, (float)(RenderStateFloat { value }.f * nearPlane));
3200 if(value) glEnable(GL_BLEND); else glDisable(GL_BLEND);
3204 float ambient[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
3205 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
3210 if(value) glColorMask(1,1,1,1); else glColorMask(1,1,1,0);
3215 #if defined(__WIN32__)
3216 wglSwapIntervalEXT(value ? 1 : 0);
3223 void SetLight(Display display, int id, Light light)
3225 //Logf("SetLight\n");
3229 Object lightObject = light.lightObject;
3230 float position[4] = { 0, 0, 0, 0 };
3231 float color[4] = { 0, 0, 0, 1 };
3233 glEnable(GL_LIGHT0 + id);
3235 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, (float *)&light.diffuse);
3236 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, (float *)&light.ambient);
3237 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,(float *)&light.specular);
3240 if(!light.multiplier) light.multiplier = 1.0f;
3242 color[0] = light.diffuse.r * light.multiplier;
3243 color[1] = light.diffuse.g * light.multiplier;
3244 color[2] = light.diffuse.b * light.multiplier;
3245 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, color);
3247 color[0] = light.ambient.r * light.multiplier;
3248 color[1] = light.ambient.g * light.multiplier;
3249 color[2] = light.ambient.b * light.multiplier;
3250 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, color);
3251 color[0] = light.specular.r * light.multiplier;
3252 color[1] = light.specular.g * light.multiplier;
3253 color[2] = light.specular.b * light.multiplier;
3254 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,color);
3258 Vector3D positionVector;
3259 if(light.flags.spot)
3261 if(lightObject.flags.root || !lightObject.parent)
3263 positionVector = lightObject.transform.position;
3264 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3268 positionVector.MultMatrix(lightObject.transform.position, lightObject.parent.matrix);
3269 if(display.display3D.camera)
3270 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3276 if(!light.direction.x && !light.direction.y && !light.direction.z)
3278 Vector3Df vector { 0,0,-1 };
3280 mat.RotationQuaternion(light.orientation);
3281 positionVector.MultMatrixf(vector, mat);
3285 positionVector = light.direction;
3290 position[0] = (float)positionVector.x;
3291 position[1] = (float)positionVector.y;
3292 position[2] = (float)positionVector.z;
3294 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3297 // Display Light Position
3298 glDisable(GL_LIGHTING);
3299 glDisable(GL_DEPTH_TEST);
3303 glVertex3fv(position);
3305 glEnable(GL_DEPTH_TEST);
3306 glEnable(GL_LIGHTING);
3310 if(lightObject.flags.root || !lightObject.parent)
3312 positionVector = light.target.transform.position;
3313 positionVector.Subtract(positionVector, display.camera.cPosition);
3317 positionVector.MultMatrix(light.target.transform.position,
3318 lightObject.light.target.parent.matrix);
3319 positionVector.Subtract(positionVector, display.camera.cPosition);
3322 position[0] = positionVector.x;
3323 position[1] = positionVector.y;
3324 position[2] = positionVector.z;
3326 glDisable(GL_LIGHTING);
3327 glDisable(GL_DEPTH_TEST);
3331 glVertex3fv(position);
3333 glEnable(GL_DEPTH_TEST);
3334 glEnable(GL_LIGHTING);
3337 if(light.flags.attenuation)
3339 glLightf(GL_LIGHT0 + id, GL_CONSTANT_ATTENUATION, light.Kc);
3340 glLightf(GL_LIGHT0 + id, GL_LINEAR_ATTENUATION, light.Kl);
3341 glLightf(GL_LIGHT0 + id, GL_QUADRATIC_ATTENUATION, light.Kq);
3344 if(light.flags.spot)
3347 #define MAXLIGHT 0.9
3348 float direction[4] = { (float)light.direction.x, (float)light.direction.y, (float)light.direction.z, 1 };
3349 // Figure out exponent out of the hot spot
3350 exponent = (float)(log(MAXLIGHT) / log(cos((light.hotSpot / 2))));
3352 glLightfv(GL_LIGHT0 + id, GL_SPOT_DIRECTION, direction);
3353 glLightf(GL_LIGHT0 + id, GL_SPOT_CUTOFF, (float)(light.fallOff / 2));
3354 glLightf(GL_LIGHT0 + id, GL_SPOT_EXPONENT, exponent);
3360 Vector3Df vector { 0,0,-1 };
3361 Vector3Df direction;
3364 mat.RotationQuaternion(light.orientation);
3365 direction.MultMatrix(vector, mat);
3367 position[0] = direction.x;
3368 position[1] = direction.y;
3369 position[2] = direction.z;
3371 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3375 glDisable(GL_LIGHT0 + id);
3378 void SetCamera(Display display, Surface surface, Camera camera)
3380 OGLDisplay oglDisplay = display.driverData;
3381 //Logf("SetCamera\n");
3385 int left = surface.box.left + surface.offset.x;
3386 int top = surface.box.top + surface.offset.y;
3387 int right = surface.box.right + surface.offset.x;
3388 int bottom = surface.box.bottom + surface.offset.y;
3389 float origX = surface.offset.x + camera.origin.x;
3390 float origY = surface.offset.y + camera.origin.y;
3392 int y = display.height - bottom - 1;
3393 int w = right - left + 1;
3394 int h = bottom - top + 1;
3397 glViewport(x, y, w, h);
3399 // *** Projection Matrix ***
3400 if(!display.display3D.camera)
3403 glMatrixMode(GL_PROJECTION);
3404 if(display.display3D.collectingHits)
3406 float pickX = display.display3D.pickX + surface.offset.x;
3407 float pickY = display.height - (display.display3D.pickY + surface.offset.y) - 1;
3411 w / display.display3D.pickWidth, 0, 0, 0,
3412 0, h / display.display3D.pickHeight, 0, 0,
3414 (w + 2.0f * (x - pickX)) / display.display3D.pickWidth,
3415 (h + 2.0f * (y - pickY)) / display.display3D.pickHeight, 0, 1
3418 glLoadMatrixd(pickMatrix.array);
3423 (left - origX) * camera.zMin / camera.focalX,
3424 (right - origX) * camera.zMin / camera.focalX,
3425 (bottom - origY) * camera.zMin / camera.focalY,
3426 (top - origY) * camera.zMin / camera.focalY,
3427 camera.zMin, camera.zMax);
3429 glDisable(GL_BLEND);
3431 // *** Z Inverted Identity Matrix ***
3432 glMatrixMode(GL_MODELVIEW);
3433 if(!display.display3D.camera)
3438 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
3440 // *** View Matrix ***
3441 glMultMatrixd(camera.viewMatrix.array);
3446 glEnable(GL_DEPTH_TEST);
3447 glEnable(GL_LIGHTING);
3448 glShadeModel(GL_SMOOTH);
3449 glDepthMask((byte)bool::true);
3450 oglDisplay.depthWrite = true;
3452 glEnable(GL_MULTISAMPLE_ARB);
3454 else if(display.display3D.camera)
3456 oglDisplay.depthWrite = false;
3457 glViewport(0,0,display.width,display.height);
3459 glDisable(GL_CULL_FACE);
3460 glDisable(GL_DEPTH_TEST);
3461 glDisable(GL_LIGHTING);
3463 glDisable(GL_TEXTURE_2D);
3464 glShadeModel(GL_FLAT);
3466 glDisable(GL_MULTISAMPLE_ARB);
3468 // *** Restore 2D MODELVIEW Matrix ***
3471 // *** Restore 2D PROJECTION Matrix ***
3472 glMatrixMode(GL_PROJECTION);
3476 GLBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
3479 void ApplyMaterial(Display display, Material material, Mesh mesh)
3481 //Logf("ApplyMaterial\n");
3484 if(material.flags.doubleSided)
3486 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, !material.flags.singleSideLight);
3487 glDisable(GL_CULL_FACE);
3491 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, bool::false);
3492 glEnable(GL_CULL_FACE);
3496 if(material.flags.noFog)
3502 if(material.baseMap && mesh.texCoords)
3504 Bitmap map = material.baseMap;
3505 glEnable(GL_TEXTURE_2D);
3506 glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)map.driverData);
3508 glMatrixMode(GL_TEXTURE);
3510 if(material.uScale && material.vScale)
3511 glScalef(material.uScale, material.vScale, 1);
3512 glMatrixMode(GL_MODELVIEW);
3514 if(material.flags.tile)
3516 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
3517 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
3521 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
3522 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
3526 glDisable(GL_TEXTURE_2D);
3528 if(mesh.flags.colors)
3530 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
3531 glEnable(GL_COLOR_MATERIAL);
3535 glDisable(GL_COLOR_MATERIAL);
3537 float color[4] = { material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity };
3538 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
3541 float color[4] = { material.ambient.r, material.ambient.g, material.ambient.b, 0 };
3542 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
3546 float color[4] = { material.specular.r, material.specular.g, material.specular.b, 0 };
3547 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, color);
3550 float color[4] = { material.emissive.r, material.emissive.g, material.emissive.b, 0 };
3551 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, color);
3554 glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &material.power);
3557 void FreeMesh(DisplaySystem displaySystem, Mesh mesh)
3559 OGLMesh oglMesh = mesh.data;
3562 if(!mesh.flags.vertices)
3564 if(oglMesh.vertices)
3566 GLDeleteBuffers(1, &oglMesh.vertices);
3567 oglMesh.vertices = 0;
3569 delete mesh.vertices;
3571 if(!mesh.flags.normals)
3575 GLDeleteBuffers(1, &oglMesh.normals);
3576 oglMesh.normals = 0;
3578 delete mesh.normals;
3580 if(!mesh.flags.texCoords1)
3582 if(oglMesh.texCoords)
3584 GLDeleteBuffers(1, &oglMesh.texCoords);
3585 oglMesh.texCoords = 0;
3587 delete mesh.texCoords;
3589 if(!mesh.flags.texCoords2)
3591 if(oglMesh.texCoords2)
3593 GLDeleteBuffers(1, &oglMesh.texCoords2);
3594 oglMesh.texCoords2 = 0;
3597 delete mesh.texCoords2;
3600 if(!mesh.flags.colors)
3604 GLDeleteBuffers(1, &oglMesh.colors);
3616 bool AllocateMesh(DisplaySystem displaySystem, Mesh mesh)
3618 bool result = false;
3621 mesh.data = OGLMesh { };
3624 OGLMesh oglMesh = mesh.data;
3626 if(mesh.flags.vertices && !oglMesh.vertices && !mesh.vertices)
3628 mesh.vertices = mesh.flags.doubleVertices ? (Vector3Df *)new Vector3D[mesh.nVertices] : new Vector3Df[mesh.nVertices];
3629 GLGenBuffers(1, &oglMesh.vertices);
3631 if(mesh.flags.normals && !oglMesh.normals && !mesh.normals)
3633 GLGenBuffers( 1, &oglMesh.normals);
3634 mesh.normals = mesh.flags.doubleNormals ? (Vector3Df *)new Vector3D[mesh.nVertices] : new Vector3Df[mesh.nVertices];
3636 if(mesh.flags.texCoords1 && !oglMesh.texCoords && !mesh.texCoords)
3638 GLGenBuffers( 1, &oglMesh.texCoords);
3639 mesh.texCoords = new Pointf[mesh.nVertices];
3641 if(mesh.flags.colors && !oglMesh.colors && !mesh.colors)
3643 GLGenBuffers( 1, &oglMesh.colors);
3644 mesh.colors = new ColorRGBAf[mesh.nVertices];
3651 void UnlockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
3653 OGLMesh oglMesh = mesh.data;
3654 if(!flags) flags = mesh.flags;
3658 if(!(flags.vertices) || oglMesh.vertices)
3660 GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.vertices);
3661 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 );
3664 if(!(flags.normals) || oglMesh.normals)
3666 GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.normals);
3667 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 );
3670 if(!(flags.texCoords1) || oglMesh.texCoords)
3672 GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.texCoords);
3673 GLBufferData( GL_FLOAT, GL_ARRAY_BUFFER_ARB, mesh.nVertices * sizeof(Pointf), mesh.texCoords, GL_STATIC_DRAW_ARB );
3676 if(!(flags.colors) || oglMesh.colors)
3678 GLBindBuffer( GL_ARRAY_BUFFER_ARB, oglMesh.colors);
3679 GLBufferData( GL_FLOAT, GL_ARRAY_BUFFER_ARB, mesh.nVertices * sizeof(ColorRGBAf), mesh.colors, GL_STATIC_DRAW_ARB );
3682 GLBindBuffer( GL_ARRAY_BUFFER_ARB, 0);
3686 bool LockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
3693 void FreeIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
3697 if(oglIndices.buffer)
3698 GLDeleteBuffers(1, &oglIndices.buffer);
3699 delete oglIndices.indices;
3704 void * AllocateIndices(DisplaySystem displaySystem, int nIndices, bool indices32bit)
3706 OGLIndices oglIndices = OGLIndices { };
3709 oglIndices.indices = (void *)(indices32bit ? new uint32[nIndices] : new uint16[nIndices]);
3710 GLGenBuffers( 1, &oglIndices.buffer);
3711 oglIndices.nIndices = nIndices;
3716 void UnlockIndices(DisplaySystem displaySystem, OGLIndices oglIndices, bool indices32bit, int nIndices)
3720 GLBindBuffer( GL_ELEMENT_ARRAY_BUFFER_ARB, oglIndices.buffer);
3721 GLBufferData( indices32bit ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT, GL_ELEMENT_ARRAY_BUFFER_ARB, nIndices * (indices32bit ? sizeof(uint32) : sizeof(uint16)),
3722 oglIndices.indices, GL_STATIC_DRAW_ARB);
3723 GLBindBuffer( GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
3727 uint16 * LockIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
3730 return oglIndices.indices;
3733 void SelectMesh(Display display, Mesh mesh)
3735 //Logf("SelectMesh\n");
3737 #if !defined( __ANDROID__) && !defined(__APPLE__)
3738 #if defined(__WIN32__)
3739 if(glUnlockArraysEXT)
3741 if(display.display3D.mesh)
3742 glUnlockArraysEXT();
3746 OGLMesh oglMesh = mesh.data;
3748 // *** Vertex Stream ***
3749 glEnableClientState(GL_VERTEX_ARRAY);
3750 if(!display.display3D.collectingHits && oglMesh)
3752 GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.vertices );
3753 glVertexPointer(3, mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT, 0, vboAvailable ? null : mesh.vertices);
3755 // *** Normals Stream ***
3758 glEnableClientState(GL_NORMAL_ARRAY);
3759 GLBindBuffer(GL_ARRAY_BUFFER_ARB, oglMesh.normals);
3760 glNormalPointer(mesh.flags.doubleNormals ? GL_DOUBLE : GL_FLOAT, 0, vboAvailable ? null : mesh.normals);
3763 glDisableClientState(GL_NORMAL_ARRAY);
3765 // *** Texture Coordinates Stream ***
3768 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
3769 GLBindBuffer( GL_ARRAY_BUFFER_ARB, oglMesh.texCoords);
3770 glTexCoordPointer(2, GL_FLOAT, 0, vboAvailable ? null : mesh.texCoords);
3773 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
3775 // *** Color Stream ***
3778 glEnableClientState(GL_COLOR_ARRAY);
3779 GLBindBuffer( GL_ARRAY_BUFFER_ARB, oglMesh.colors);
3780 glColorPointer(4, GL_FLOAT, 0, vboAvailable ? null : mesh.colors);
3783 glDisableClientState(GL_COLOR_ARRAY);
3788 GLBindBuffer( GL_ARRAY_BUFFER_ARB, 0);
3789 glVertexPointer(3,mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT,0,mesh.vertices);
3790 if(mesh.normals && !display.display3D.collectingHits)
3792 glEnableClientState(GL_NORMAL_ARRAY);
3793 glNormalPointer(mesh.flags.doubleNormals ? GL_DOUBLE : GL_FLOAT, 0, mesh.normals);
3796 glDisableClientState(GL_NORMAL_ARRAY);
3797 if(mesh.texCoords && !display.display3D.collectingHits)
3799 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
3800 glTexCoordPointer(2, GL_FLOAT, 0, mesh.texCoords);
3803 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
3804 if(mesh.colors && !display.display3D.collectingHits)
3806 glEnableClientState(GL_COLOR_ARRAY);
3807 glColorPointer(4, GL_FLOAT, 0, mesh.colors);
3810 glDisableClientState(GL_COLOR_ARRAY);
3813 #if !defined(__ANDROID__) && !defined(__APPLE__)
3815 #if defined(__WIN32__)
3818 glLockArraysEXT(0, mesh.nVertices);
3822 GLBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
3825 void DrawPrimitives(Display display, PrimitiveSingle * primitive, Mesh mesh)
3827 //Logf("DrawPrimitives\n");
3829 if(primitive->type.vertexRange)
3830 glDrawArrays(primitiveTypes[primitive->type.primitiveType], primitive->first, primitive->nVertices);
3833 // *** Hoping the data won't be uploaded at all (Won't really work if another group of the mesh is using the mesh ) ***
3834 // HACK TO SPEED THINGS UP...
3836 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
3837 if(primitive->nIndices < (mesh.nVertices >> 2) && !primitive->type.indices32bit)
3840 glBegin(primitiveTypes[primitive->type.primitiveType]);
3843 OGLIndices oglIndices = primitive->data;
3844 MeshFeatures flags = mesh.flags;
3845 for(c = 0; c<primitive->nIndices; c++)
3847 uint16 index = ((uint16 *) oglIndices.indices)[c];
3848 if(flags.normals) glNormal3fv((float *)&mesh.normals[index]);
3849 if(flags.texCoords1) glTexCoord2fv((float *)&mesh.texCoords[index]);
3850 if(flags.colors) glColor4fv((float *)&mesh.colors[index]);
3851 glVertex3fv((float *)&mesh.vertices[index]);
3859 OGLIndices oglIndices = primitive->data;
3861 if(!display.display3D.collectingHits && vboAvailable && oglIndices)
3863 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, oglIndices.buffer);
3864 glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
3865 primitive->type.indices32bit ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT, 0);
3866 GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
3869 glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
3870 primitive->type.indices32bit ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT, oglIndices ? oglIndices.indices : primitive->indices);
3875 void PushMatrix(Display display)
3880 void PopMatrix(Display display, bool setMatrix)
3885 void SetTransform(Display display, Matrix transMatrix, bool viewSpace, bool useCamera)
3887 Matrix matrix = transMatrix;
3888 Camera camera = useCamera ? display.display3D.camera : null;
3893 glScaled(1.0/nearPlane, 1.0/nearPlane, -1.0/nearPlane);
3898 matrix.m[3][0] - camera.cPosition.x,
3899 matrix.m[3][1] - camera.cPosition.y,
3900 matrix.m[3][2] - camera.cPosition.z);
3912 glMultMatrixd(matrix.array);
3917 public void UseSingleGLContext(bool useSingle)
3919 useSingleGLContext = useSingle;
3922 default dllexport void *
3923 #if defined(__WIN32__)
3924 __attribute__((stdcall))
3926 IS_GLGetContext(DisplaySystem displaySystem)
3930 #if defined(__WIN32__)
3931 OGLSystem system = displaySystem.driverData;
3933 #elif !defined(__ANDROID__)
3934 OGLSystem system = displaySystem.driverData;
3935 return system.glContext;