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
71 #define _WIN32_WINNT 0x0500
75 #if defined(__ANDROID__)
89 #if defined(__unix__) || defined(__APPLE__)
97 #define glLoadMatrix glLoadMatrixd
98 #define glMultMatrix glMultMatrixd
99 #define glGetMatrix glGetDoublev
100 #define glTranslate glTranslated
101 #define glScale glScaled
104 #define glVertex3v glVertex3dv
105 #define glNormal3v glNormal3dv
109 //#ifdef VERTEX_FORMAT_DOUBLE
111 #define glLoadMatrix glLoadMatrixd
112 #define glMultMatrix glMultMatrixd
113 #define glGetMatrix glGetDoublev
114 #define glVertex3v glVertex3dv
115 #define glNormal3v glNormal3dv
116 #define glTranslate glTranslated
117 #define glScale glScaled
118 //#define GL_VERTEX_FORMAT GL_DOUBLE
122 #define glLoadMatrix glLoadMatrixf
123 #define glMultMatrix glMultMatrixf
124 #define glGetMatrix glGetFloatv
125 #define glVertex3v glVertex3fv
126 #define glNormal3v glNormal3fv
127 #define glTranslate glTranslatef
128 #define glScale glScalef
129 //#define GL_VERTEX_FORMAT GL_FLOAT
134 #define GL_ARRAY_BUFFER_ARB 0x8892
135 #define GL_ELEMENT_ARRAY_BUFFER_ARB 0x8893
136 #define GL_STATIC_DRAW_ARB 0x88E4
137 #define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8
138 #define GL_SEPARATE_SPECULAR_COLOR 0x81FA
140 #define GL_MULTISAMPLE_ARB 0x809D
142 #if defined(__WIN32__)
144 #define WGL_SAMPLE_BUFFERS_ARB 0x2041
145 #define WGL_SAMPLES_ARB 0x2042
147 #define WGL_WGLEXT_VERSION 1
148 #define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001
149 #define WGL_BACK_COLOR_BUFFER_BIT_ARB 0x00000002
150 #define WGL_DEPTH_BUFFER_BIT_ARB 0x00000004
151 #define WGL_STENCIL_BUFFER_BIT_ARB 0x00000008
152 #define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000
153 #define WGL_DRAW_TO_WINDOW_ARB 0x2001
154 #define WGL_DRAW_TO_BITMAP_ARB 0x2002
155 #define WGL_ACCELERATION_ARB 0x2003
156 #define WGL_NEED_PALETTE_ARB 0x2004
157 #define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005
158 #define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006
159 #define WGL_SWAP_METHOD_ARB 0x2007
160 #define WGL_NUMBER_OVERLAYS_ARB 0x2008
161 #define WGL_NUMBER_UNDERLAYS_ARB 0x2009
162 #define WGL_TRANSPARENT_ARB 0x200A
163 #define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037
164 #define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038
165 #define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039
166 #define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A
167 #define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B
168 #define WGL_SHARE_DEPTH_ARB 0x200C
169 #define WGL_SHARE_STENCIL_ARB 0x200D
170 #define WGL_SHARE_ACCUM_ARB 0x200E
171 #define WGL_SUPPORT_GDI_ARB 0x200F
172 #define WGL_SUPPORT_OPENGL_ARB 0x2010
173 #define WGL_DOUBLE_BUFFER_ARB 0x2011
174 #define WGL_STEREO_ARB 0x2012
175 #define WGL_PIXEL_TYPE_ARB 0x2013
176 #define WGL_COLOR_BITS_ARB 0x2014
177 #define WGL_RED_BITS_ARB 0x2015
178 #define WGL_RED_SHIFT_ARB 0x2016
179 #define WGL_GREEN_BITS_ARB 0x2017
180 #define WGL_GREEN_SHIFT_ARB 0x2018
181 #define WGL_BLUE_BITS_ARB 0x2019
182 #define WGL_BLUE_SHIFT_ARB 0x201A
183 #define WGL_ALPHA_BITS_ARB 0x201B
184 #define WGL_ALPHA_SHIFT_ARB 0x201C
185 #define WGL_ACCUM_BITS_ARB 0x201D
186 #define WGL_ACCUM_RED_BITS_ARB 0x201E
187 #define WGL_ACCUM_GREEN_BITS_ARB 0x201F
188 #define WGL_ACCUM_BLUE_BITS_ARB 0x2020
189 #define WGL_ACCUM_ALPHA_BITS_ARB 0x2021
190 #define WGL_DEPTH_BITS_ARB 0x2022
191 #define WGL_STENCIL_BITS_ARB 0x2023
192 #define WGL_AUX_BUFFERS_ARB 0x2024
193 #define WGL_NO_ACCELERATION_ARB 0x2025
194 #define WGL_GENERIC_ACCELERATION_ARB 0x2026
195 #define WGL_FULL_ACCELERATION_ARB 0x2027
196 #define WGL_SWAP_EXCHANGE_ARB 0x2028
197 #define WGL_SWAP_COPY_ARB 0x2029
198 #define WGL_SWAP_UNDEFINED_ARB 0x202A
199 #define WGL_TYPE_RGBA_ARB 0x202B
200 #define WGL_TYPE_COLORINDEX_ARB 0x202C
201 #define ERROR_INVALID_PIXEL_TYPE_ARB 0x2043
202 #define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054
203 #define WGL_DRAW_TO_PBUFFER_ARB 0x202D
204 #define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E
205 #define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F
206 #define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030
207 #define WGL_PBUFFER_LARGEST_ARB 0x2033
208 #define WGL_PBUFFER_WIDTH_ARB 0x2034
209 #define WGL_PBUFFER_HEIGHT_ARB 0x2035
210 #define WGL_PBUFFER_LOST_ARB 0x2036
211 #define ERROR_INVALID_PIXEL_TYPE_EXT 0x2043
212 #define WGL_NUMBER_PIXEL_FORMATS_EXT 0x2000
213 #define WGL_DRAW_TO_WINDOW_EXT 0x2001
214 #define WGL_DRAW_TO_BITMAP_EXT 0x2002
215 #define WGL_ACCELERATION_EXT 0x2003
216 #define WGL_NEED_PALETTE_EXT 0x2004
217 #define WGL_NEED_SYSTEM_PALETTE_EXT 0x2005
218 #define WGL_SWAP_LAYER_BUFFERS_EXT 0x2006
219 #define WGL_SWAP_METHOD_EXT 0x2007
220 #define WGL_NUMBER_OVERLAYS_EXT 0x2008
221 #define WGL_NUMBER_UNDERLAYS_EXT 0x2009
222 #define WGL_TRANSPARENT_EXT 0x200A
223 #define WGL_TRANSPARENT_VALUE_EXT 0x200B
224 #define WGL_SHARE_DEPTH_EXT 0x200C
225 #define WGL_SHARE_STENCIL_EXT 0x200D
226 #define WGL_SHARE_ACCUM_EXT 0x200E
227 #define WGL_SUPPORT_GDI_EXT 0x200F
228 #define WGL_SUPPORT_OPENGL_EXT 0x2010
229 #define WGL_DOUBLE_BUFFER_EXT 0x2011
230 #define WGL_STEREO_EXT 0x2012
231 #define WGL_PIXEL_TYPE_EXT 0x2013
232 #define WGL_COLOR_BITS_EXT 0x2014
233 #define WGL_RED_BITS_EXT 0x2015
234 #define WGL_RED_SHIFT_EXT 0x2016
235 #define WGL_GREEN_BITS_EXT 0x2017
236 #define WGL_GREEN_SHIFT_EXT 0x2018
237 #define WGL_BLUE_BITS_EXT 0x2019
238 #define WGL_BLUE_SHIFT_EXT 0x201A
239 #define WGL_ALPHA_BITS_EXT 0x201B
240 #define WGL_ALPHA_SHIFT_EXT 0x201C
241 #define WGL_ACCUM_BITS_EXT 0x201D
242 #define WGL_ACCUM_RED_BITS_EXT 0x201E
243 #define WGL_ACCUM_GREEN_BITS_EXT 0x201F
244 #define WGL_ACCUM_BLUE_BITS_EXT 0x2020
245 #define WGL_ACCUM_ALPHA_BITS_EXT 0x2021
246 #define WGL_DEPTH_BITS_EXT 0x2022
247 #define WGL_STENCIL_BITS_EXT 0x2023
248 #define WGL_AUX_BUFFERS_EXT 0x2024
249 #define WGL_NO_ACCELERATION_EXT 0x2025
250 #define WGL_GENERIC_ACCELERATION_EXT 0x2026
251 #define WGL_FULL_ACCELERATION_EXT 0x2027
252 #define WGL_SWAP_EXCHANGE_EXT 0x2028
253 #define WGL_SWAP_COPY_EXT 0x2029
254 #define WGL_SWAP_UNDEFINED_EXT 0x202A
255 #define WGL_TYPE_RGBA_EXT 0x202B
256 #define WGL_TYPE_COLORINDEX_EXT 0x202C
257 #define WGL_DRAW_TO_PBUFFER_EXT 0x202D
258 #define WGL_MAX_PBUFFER_PIXELS_EXT 0x202E
259 #define WGL_MAX_PBUFFER_WIDTH_EXT 0x202F
260 #define WGL_MAX_PBUFFER_HEIGHT_EXT 0x2030
261 #define WGL_OPTIMAL_PBUFFER_WIDTH_EXT 0x2031
262 #define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032
263 #define WGL_PBUFFER_LARGEST_EXT 0x2033
264 #define WGL_PBUFFER_WIDTH_EXT 0x2034
265 #define WGL_PBUFFER_HEIGHT_EXT 0x2035
266 #define WGL_DEPTH_FLOAT_EXT 0x2040
267 #define WGL_SAMPLE_BUFFERS_3DFX 0x2060
268 #define WGL_SAMPLES_3DFX 0x2061
269 #define WGL_SAMPLE_BUFFERS_EXT 0x2041
270 #define WGL_SAMPLES_EXT 0x2042
271 #define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044
272 #define WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D 0x2045
273 #define WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D 0x2046
274 #define WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D 0x2047
275 #define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048
276 #define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049
277 #define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A
278 #define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B
279 #define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C
280 #define WGL_GAMMA_TABLE_SIZE_I3D 0x204E
281 #define WGL_GAMMA_EXCLUDE_DESKTOP_I3D 0x204F
282 #define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050
283 #define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051
284 #define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052
285 #define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053
286 #define WGL_ARB_buffer_region 1
287 #define WGL_ARB_extensions_string 1
288 #define WGL_ARB_pixel_format 1
289 #define WGL_ARB_make_current_read 1
290 #define WGL_ARB_pbuffer 1
291 #define WGL_EXT_display_color_table 1
292 #define WGL_EXT_extensions_string 1
293 #define WGL_EXT_make_current_read 1
294 #define WGL_EXT_pbuffer 1
295 #define WGL_EXT_pixel_format 1
296 #define WGL_EXT_swap_control 1
297 #define WGL_WGL_EXT_depth_float 1
298 #define WGL_WGL_3DFX_multisample 1
299 #define WGL_WGL_EXT_multisample 1
300 #define WGL_NV_allocate_memory 1
303 typedef void (APIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum target);
304 typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);
305 typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum target);
306 typedef void (APIENTRY * PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei count);
307 typedef void (APIENTRY * PFNGLUNLOCKARRAYSEXTPROC) (void);
311 typedef int (APIENTRY * PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer);
312 typedef int (APIENTRY * PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint *buffers);
313 typedef int (APIENTRY * PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint *buffers);
314 typedef int (APIENTRY * PFNGLBUFFERDATAARBPROC) (GLenum target, int size, const GLvoid *data, GLenum usage);
316 typedef int (APIENTRY * PFNWGLCHOOSEPIXELFORMATARBPROC) ();
317 typedef void * (APIENTRY * PFNWGLCREATEPBUFFERARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
318 typedef HDC (APIENTRY * PFNWGLGETPBUFFERDCARBPROC) (void * hPbuffer);
319 typedef int (APIENTRY * PFNWGLRELEASEPBUFFERDCARBPROC) (void * hPbuffer, HDC hDC);
320 typedef BOOL (APIENTRY * PFNWGLDESTROYPBUFFERARBPROC) (void * hPbuffer);
321 typedef BOOL (APIENTRY * PFNWGLQUERYPBUFFERARBPROC) (void * hPbuffer, int iAttribute, int *piValue);
323 static PFNGLMAPBUFFERARBPROC glMapBufferARB = null;
324 static PFNGLUNMAPBUFFERARBPROC glUnmapBufferARB = null;
325 static PFNGLACTIVETEXTUREARBPROC glActiveTextureARB = null;
326 static PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB = null;
327 static PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB = null;
328 static PFNGLLOCKARRAYSEXTPROC glLockArraysEXT = null;
329 static PFNGLUNLOCKARRAYSEXTPROC glUnlockArraysEXT = null;
330 static PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate = null;
332 static PFNGLGENBUFFERSARBPROC glGenBuffersARB = null;
333 static PFNGLBINDBUFFERARBPROC glBindBufferARB = null;
334 static PFNGLBUFFERDATAARBPROC glBufferDataARB = null;
335 static PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB = null;
336 static PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = null;
337 static PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB = null;
338 static PFNWGLCREATEPBUFFERARBPROC wglCreatePbufferARB = null;
339 static PFNWGLGETPBUFFERDCARBPROC wglGetPbufferDCARB = null;
340 static PFNWGLQUERYPBUFFERARBPROC wglQueryPbufferARB = null;
341 static PFNWGLDESTROYPBUFFERARBPROC wglDestroyPbufferARB = null;
342 static PFNWGLRELEASEPBUFFERDCARBPROC wglReleasePbufferDCARB = null;
343 static PFNWGLBINDTEXIMAGEARBPROC wglBindTexImageARB = null;
344 static PFNWGLRELEASETEXIMAGEARBPROC wglReleaseTexImageARB = null;
346 #ifdef WGL_WGLEXT_PROTOTYPES
347 extern BOOL WINAPI wglSwapIntervalEXT (int);
348 extern int WINAPI wglGetSwapIntervalEXT (void);
349 #endif /* WGL_WGLEXT_PROTOTYPES */
350 typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC) (int interval);
351 typedef int (WINAPI * PFNWGLGETSWAPINTERVALEXTPROC) (void);
353 static PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = NULL;
357 #if defined(__ANDROID__)
359 // OpenGL ES Porting Kit
361 #define glBindFramebuffer glBindFramebufferOES
362 #define glBindRenderbuffer glBindRenderbufferOES
363 #define GL_FRAMEBUFFER GL_FRAMEBUFFER_OES
364 #define GL_RENDERBUFFER GL_RENDERBUFFER_OES
365 #define glFramebufferTexture2D glFramebufferTexture2DOES
366 #define GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_OES
367 #define glGenFramebuffers glGenFramebuffersOES
368 #define glGenRenderbuffers glGenRenderbuffersOES
369 #define glDeleteFramebuffers glDeleteFramebuffersOES
370 #define glDeleteRenderbuffers glDeleteRenderbuffersOES
372 #define GL_POLYGON_STIPPLE 0xFFFF
373 #define GL_LINE_STIPPLE 0xFFFF
374 #define GL_LINE 0xFFFF
375 #define GL_FILL 0xFFFF
376 #define GL_ALL_ATTRIB_BITS 0xFFFF
377 #define GL_LIGHT_MODEL_LOCAL_VIEWER 0xFFFF
378 #define glDrawElementsi(type, count, start) glDrawElements(type, count, GL_UNSIGNED_SHORT, start)
383 #define glBufferDatai glesBufferDatai
384 #define glBufferDatad glesBufferDatad
385 #define glVertexPointeri glesVertexPointeri
386 #define glVertexPointerd glesVertexPointerd
388 #define glRecti glesRecti
389 #define glBegin glesBegin
390 #define glTexCoord2i glesTexCoord2i
391 #define glVertex2i glesVertex2i
392 #define glTexCoord2d glesTexCoord2d
393 #define glVertex2d glesVertex2d
394 #define glTexCoord2f glesTexCoord2f
395 #define glVertex2f glesVertex2f
396 #define glEnd glesEnd
397 #define glColor3f glesColor3f
398 #define glColor4ub glesColor4ub
399 #define glColor4fv glesColor4fv
400 #define glLineStipple glesLineStipple
401 #define glNormal3fv glesNormal3fv
402 #define glTexCoord2fv glesTexCoord2fv
403 #define glColorMaterial glesColorMaterial
405 #define glLoadMatrixd glesLoadMatrixd
406 #define glMultMatrixd glesMultMatrixd
407 #define glFrustum glesFrustum
408 #define glOrtho glesOrtho
409 #define glScaled glesScaled
410 #define glTranslated glesTranslated
411 #define glRotated glesRotated
412 #define glVertex3d glesVertex3d
413 #define glVertex3f glesVertex3f
414 #define glVertex3fv glesVertex3fv
415 #define glLightModeli glesLightModeli
419 #define GL_QUAD_STRIP 0
421 #define GL_UNSIGNED_INT 0
424 //#define GL_LINE_STIPPLE 0
425 #define GL_BGRA_EXT 0
426 #define GL_UNPACK_ROW_LENGTH 0
427 #define GL_UNPACK_SKIP_PIXELS 0
428 #define GL_UNPACK_SKIP_ROWS 0
430 #define GL_PACK_ROW_LENGTH 0
431 #define GL_PACK_SKIP_ROWS 0
432 #define GL_PACK_SKIP_PIXELS 0
434 static EGLDisplay eglDisplay;
435 static EGLSurface eglSurface;
436 static EGLContext eglContext;
437 static int eglWidth, eglHeight;
439 static bool egl_init_display(ANativeWindow* window)
441 const EGLint attribs[] =
443 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
448 /*EGL_SAMPLE_BUFFERS, 1,
449 EGL_SAMPLES, 0, //2,*/
452 EGLint w, h, dummy, format;
458 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
459 eglInitialize(display, 0, 0);
460 eglChooseConfig(display, attribs, &config, 1, &numConfigs);
461 eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &format);
463 surface = eglCreateWindowSurface(display, config, window, null);
464 context = eglCreateContext(display, config, null, null);
466 if(!eglMakeCurrent(display, surface, surface, context))
469 eglQuerySurface(display, surface, EGL_WIDTH, &w);
470 eglQuerySurface(display, surface, EGL_HEIGHT, &h);
472 eglDisplay = display;
473 eglContext = context;
474 eglSurface = surface;
478 glEnableClientState(GL_VERTEX_ARRAY);
480 // Initialize GL state.
481 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
482 glEnable(GL_CULL_FACE);
483 glShadeModel(GL_SMOOTH);
484 glDisable(GL_DEPTH_TEST);
486 glDisable(GL_CULL_FACE);
487 glDisable(GL_DEPTH_TEST);
489 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
492 glMatrixMode(GL_MODELVIEW);
493 glScalef(1.0f, 1.0f, -1.0f);
494 glMatrixMode(GL_PROJECTION);
495 glShadeModel(GL_FLAT);
497 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
498 glFogi(GL_FOG_MODE, GL_EXP);
499 glFogf(GL_FOG_DENSITY, 0);
500 glEnable(GL_NORMALIZE);
501 glDepthFunc(GL_LESS);
503 glDisable(GL_MULTISAMPLE_ARB);
507 glOrtho(0,w,h,0,0.0,1.0);
511 static void egl_term_display()
515 glDeleteTextures(1, (int *)&stippleTexture);
518 if(eglDisplay != EGL_NO_DISPLAY)
520 eglMakeCurrent(eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
521 if(eglContext != EGL_NO_CONTEXT)
522 eglDestroyContext(eglDisplay, eglContext);
523 if(eglSurface != EGL_NO_SURFACE)
524 eglDestroySurface(eglDisplay, eglSurface);
525 eglTerminate(eglDisplay);
527 eglDisplay = EGL_NO_DISPLAY;
528 eglContext = EGL_NO_CONTEXT;
529 eglSurface = EGL_NO_SURFACE;
532 // OpenGL Immediate Mode Porting Kit
533 static int beginCount;
534 static int vertexCount;
535 static int normalCount;
536 static float *vertexPointer;
537 static float *normalPointer;
538 static GLenum beginMode;
539 static unsigned int beginBufferSize, normalBufferSize;
540 static int numVertexCoords = 2;
542 void glesRecti(int a, int b, int c, int d)
552 void glesBegin(GLenum mode)
559 normalBufferSize = beginBufferSize = 1024; // default number of vertices
560 vertexPointer = new float[beginBufferSize * 5];
561 normalPointer = new float[normalBufferSize * 3];
565 void glesTexCoord2f(float x, float y)
567 int count = vertexCount;
569 if(vertexCount + numVertexCoords > beginBufferSize)
571 beginBufferSize = beginBufferSize + beginBufferSize/2;
572 vertexPointer = renew vertexPointer float[beginBufferSize * 5];
575 vertexPointer[count*(2+numVertexCoords) ] = x;
576 vertexPointer[count*(2+numVertexCoords)+1] = y;
579 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
581 vertexPointer[count*(2+numVertexCoords) ] = vertexPointer[(count-4)*(2+numVertexCoords)];
582 vertexPointer[count*(2+numVertexCoords)+1] = vertexPointer[(count-4)*(2+numVertexCoords)+1];
584 vertexPointer[count*(2+numVertexCoords) ] = vertexPointer[(count-3)*(2+numVertexCoords)];
585 vertexPointer[count*(2+numVertexCoords)+1] = vertexPointer[(count-3)*(2+numVertexCoords)+1];
589 void glesTexCoord2i(int x, int y) { glesTexCoord2f((float)x, (float)y); }
590 void glesTexCoord2d(double x, double y) { glesTexCoord2f((float)x, (float)y); }
591 void glesTexCoord2fv(float * a) { glesTexCoord2f(a[0], a[1]); }
593 void glesVertex2f(float x, float y)
596 if(vertexCount + 4 > beginBufferSize)
598 beginBufferSize = beginBufferSize + beginBufferSize/2;
599 vertexPointer = renew vertexPointer float[beginBufferSize * 5];
602 vertexPointer[vertexCount*4+2] = x;
603 vertexPointer[vertexCount*4+3] = y;
606 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
608 vertexPointer[vertexCount*4+2] = vertexPointer[(vertexCount-4)*4+2];
609 vertexPointer[vertexCount*4+3] = vertexPointer[(vertexCount-4)*4+3];
611 vertexPointer[vertexCount*4+2] = vertexPointer[(vertexCount-3)*4+2];
612 vertexPointer[vertexCount*4+3] = vertexPointer[(vertexCount-3)*4+3];
617 void glesVertex2i(int x, int y) { glesVertex2f((float)x, (float)y); }
618 void glesVertex2d(double x, double y) { glesVertex2f((float)x, (float)y); }
622 int mode = beginMode;
623 if(mode == GL_QUADS) mode = GL_TRIANGLES;
624 else if(mode == GL_POLYGON) mode = GL_TRIANGLE_FAN;
626 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
627 glTexCoordPointer(numVertexCoords, GL_FLOAT, (numVertexCoords+2)*sizeof(float),vertexPointer);
628 glVertexPointer (numVertexCoords, GL_FLOAT, (numVertexCoords+2)*sizeof(float),vertexPointer+2);
629 if(normalCount && normalCount == vertexCount)
631 glEnableClientState(GL_NORMAL_ARRAY);
632 glNormalPointer (GL_FLOAT, 3*sizeof(float),normalPointer);
635 glDrawArrays(mode, 0, vertexCount);
637 glDisableClientState(GL_NORMAL_ARRAY);
638 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
643 static float *floatVPBuffer = null;
644 static short *shortVPBuffer = null;
645 static unsigned int shortVPSize = 0, floatVPSize = 0;
648 //static float *floatVPBuffer = null; // For floats we reuse floatVPBuffer
649 static unsigned short *shortBDBuffer = null;
650 static unsigned int shortBDSize = 0/*, floatVPSize = 0*/;
652 void glesVertexPointeri(int numCoords, int stride, int *pointer, int numVertices)
657 if(numVertices*numCoords > shortVPSize)
659 shortVPSize = numVertices*numCoords;
660 shortVPBuffer = renew shortVPBuffer short[shortVPSize];
662 for(i = 0; i < numVertices*numCoords; i++)
663 shortVPBuffer[i] = (short)pointer[i];
664 glVertexPointer(numCoords, GL_SHORT, stride, shortVPBuffer);
667 glVertexPointer(numCoords, GL_SHORT, stride, 0);
670 void glesVertexPointerd(int numCoords, int stride, double *pointer, int numVertices)
675 if(numVertices*numCoords > floatVPSize)
677 floatVPSize = numVertices*numCoords;
678 floatVPBuffer = renew floatVPBuffer float[floatVPSize];
680 for(i = 0; i < numVertices*numCoords; i++)
681 floatVPBuffer[i] = (float)pointer[i];
682 glVertexPointer(numCoords, GL_FLOAT, stride, floatVPBuffer);
685 glVertexPointer(numCoords, GL_FLOAT, stride, 0);
688 void glesTexReuseIntVP(int numCoords)
690 glTexCoordPointer(numCoords, GL_SHORT, 0, floatVPBuffer);
693 void glesTexReuseDoubleVP(int numCoords)
695 glTexCoordPointer(numCoords, GL_FLOAT, 0, floatVPBuffer);
698 void glesColor3f( float r, float g, float b )
700 glColor4f(r, g, b, 1.0f);
703 void glesColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
705 glColor4f(r/255.0f, g/255.0f, b/255.0f, a/255.0f);
708 void glesColor4fv(float * a)
710 glColor4f(a[0], a[1], a[2], a[3]);
713 void glesBufferDatad(int target, int size, void * data, int usage)
715 int numElems = size/sizeof(double);
716 double * dblPtr = (double *)data;
718 if (numElems > floatVPSize)
720 floatVPSize = numElems;
721 floatVPBuffer = renew floatVPBuffer float[floatVPSize];
723 for (i=0; i< numElems; i++)
724 floatVPBuffer[i] = (float)dblPtr[i];
726 glBufferData(target, numElems*sizeof(float), floatVPBuffer, usage);
729 void glesBufferDatai(int target, int size, void * data, int usage)
731 int numElems = size/sizeof(unsigned int);
732 unsigned int * pointer = (unsigned int *)data;
734 if (numElems > shortBDSize)
736 shortBDSize = numElems;
737 shortBDBuffer = renew shortBDBuffer uint16[shortBDSize];
739 for (i=0; i< numElems; i++)
740 shortBDBuffer[i] = (unsigned short)pointer[i];
742 glBufferData(target, numElems*sizeof(unsigned short), shortBDBuffer, usage);
745 /// *** These might require an implementation to get things working ***
746 void glesLoadMatrixd( double * i )
750 (float)i[0],(float)i[1],(float)i[2],(float)i[3],
751 (float)i[4],(float)i[5],(float)i[6],(float)i[7],
752 (float)i[8],(float)i[9],(float)i[10],(float)i[11],
753 (float)i[12],(float)i[13],(float)i[14],(float)i[15]
758 void glesOrtho( double l, double r, double b, double t, double n, double f )
762 { (float)(2 / (r - l)), 0, 0, 0 },
763 { 0, (float)(2 / (t - b)), 0, 0 },
764 { 0, 0, (float)(-2 / (f - n)), 0 },
765 { (float)(-(r + l) / (r - l)), (float)(-(t + b) / (t - b)), (float)(-(f + n) / (f - n)), 1 }
767 glMultMatrixf((float *)matrix);
770 void glesRotated( double a, double b, double c, double d ) { glRotatef((float)a, (float)b, (float)c, (float)d); }
771 void glesScaled( double a, double b, double c ) { glScalef((float)a, (float)b, (float)c); }
772 void glesTranslated( double a, double b, double c ) { glTranslatef((float)a, (float)b, (float)c); }
774 void glesMultMatrixd( double * i )
778 (float)i[0], (float)i[1], (float)i[2], (float)i[3],
779 (float)i[4], (float)i[5], (float)i[6], (float)i[7],
780 (float)i[8], (float)i[9], (float)i[10], (float)i[11],
781 (float)i[12], (float)i[13], (float)i[14], (float)i[15]
786 // Need to do these...
787 void glesVertex3f( float x, float y, float z )
790 if(vertexCount + 4 > beginBufferSize)
792 beginBufferSize = beginBufferSize + beginBufferSize/2;
793 vertexPointer = renew vertexPointer float[beginBufferSize * 5];
796 vertexPointer[vertexCount*5+2] = x;
797 vertexPointer[vertexCount*5+3] = y;
798 vertexPointer[vertexCount*5+4] = z;
801 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
803 vertexPointer[vertexCount*5+2] = vertexPointer[(vertexCount-4)*5+2];
804 vertexPointer[vertexCount*5+3] = vertexPointer[(vertexCount-4)*5+3];
805 vertexPointer[vertexCount*5+4] = vertexPointer[(vertexCount-4)*5+4];
807 vertexPointer[vertexCount*5+2] = vertexPointer[(vertexCount-3)*5+2];
808 vertexPointer[vertexCount*5+3] = vertexPointer[(vertexCount-3)*5+3];
809 vertexPointer[vertexCount*5+4] = vertexPointer[(vertexCount-3)*5+4];
815 void glesVertex3d( double x, double y, double z ) { glesVertex3f((float)x, (float)y, (float)z); }
816 void glesVertex3fv( float* coords ) { glesVertex3f(coords[0], coords[1], coords[2]); }
818 void glesNormal3f(float x, float y, float z)
820 normalCount = vertexCount;
821 if(vertexCount + 4 > normalBufferSize)
823 normalBufferSize = normalBufferSize + normalBufferSize/2;
824 normalPointer = renew normalPointer float[normalBufferSize * 2];
827 normalPointer[normalCount*3+0] = x;
828 normalPointer[normalCount*3+1] = y;
829 normalPointer[normalCount*3+2] = z;
832 if(beginMode == GL_QUADS && ((beginCount % 4) == 3))
834 normalPointer[normalCount*3+0] = normalPointer[(normalCount-4)*3+0];
835 normalPointer[normalCount*3+1] = normalPointer[(normalCount-4)*3+1];
836 normalPointer[normalCount*3+2] = normalPointer[(normalCount-4)*3+2];
838 normalPointer[normalCount*3+0] = normalPointer[(normalCount-3)*3+0];
839 normalPointer[normalCount*3+1] = normalPointer[(normalCount-3)*3+1];
840 normalPointer[normalCount*3+2] = normalPointer[(normalCount-3)*3+2];
844 void glesNormal3fd(double x, double y, double z) { glesNormal3f((float)x, (float)y, (float)z); }
845 void glesNormal3fv(float * coords) { glesNormal3f(coords[0], coords[1], coords[2]); }
847 void glesColorMaterial(int a, int b)
849 PrintLn("glColorMaterial stub");
854 delete vertexPointer;
857 delete floatVPBuffer;
860 delete shortVPBuffer;
863 delete shortBDBuffer;
867 static int stippleTexture;
868 static bool stippleEnabled;
870 void glesLineStipple( int i, unsigned short j )
875 for(x = 0; x < 16; x++)
877 bool v = (j & (1 << x)) != 0;
878 texture[x] = v ? 0xFFFFFFFF : 0;
881 glGenTextures(1, &stippleTexture);
882 glBindTexture(GL_TEXTURE_2D, stippleTexture);
883 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture);
884 glEnable(GL_TEXTURE_2D);
885 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
886 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
887 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
888 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
889 glMatrixMode(GL_TEXTURE);
891 //glTranslated(1.0/backAttrib->texW/2.0f, 1.0/backAttrib->texH/2.0f, 0.0f);
892 glScaled(i/16.0, 1, 1.0f);
893 glTranslated(0.5, 0.5, 0);
894 glMatrixMode(GL_PROJECTION);
897 void glesFrustum( double l, double r, double b, double t, double n, double f )
899 float A = (float)((r + l) / (r - l));
900 float B = (float)((t + b) / (t - b));
901 float C = (float)(-(f + n) / (f - n));
902 float D = (float)(-2*f*n/(f-n));
905 { (float)(2*n / (r - l)), 0, 0, 0 },
906 { 0, (float)(2*n / (t - b)), 0, 0 },
910 glMultMatrixf((float *)matrix);
913 void glesLightModeli( unsigned int pname, int param )
915 if(pname == GL_LIGHT_MODEL_TWO_SIDE)
916 glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, param);
919 void glClearDepth( double depth ) { glClearDepthf((float)depth); }
920 void glFogi( unsigned int pname, int param ) { }
921 void glPolygonMode( unsigned int i, unsigned int j ) { }
924 // *** Picking won't be supported for now ***
925 void glPushName( unsigned int i ) { }
926 void glLoadName( unsigned int i ) { }
929 // Probably replace by regular glBlendFunc ...
930 void glBlendFuncSeparate(int a, int b, int c, int d)
935 // For direct pixel blitting...
936 void glRasterPos2d(double a, double b) { }
937 void glPixelZoom(float a, float b) { }
938 void glDrawPixels(int a, int b, int c, int d, void * e) { }
942 /* Non OpenGL ES friendly stuff
943 #undef GL_UNSIGNED_INT
949 #undef GL_POLYGON_STIPPLE
950 #undef GL_LINE_STIPPLE
953 #undef GL_ALL_ATTRIB_BITS
954 #undef GL_LIGHT_MODEL_LOCAL_VIEWER
959 #if !defined(__APPLE__)
960 void (APIENTRY * glBindBufferARB) (GLenum target, GLuint buffer);
961 void (APIENTRY * glGenBuffersARB) (GLsizei n, GLuint *buffers);
962 void (APIENTRY * glDeleteBuffersARB) (GLsizei n, const GLuint *buffers);
963 void (APIENTRY * glBufferDataARB) (GLenum target, int size, const GLvoid *data, GLenum usage);
968 static int currentVertexBuffer;
970 bool GLSelectVBO(uint vbo)
972 if(currentVertexBuffer != vbo)
974 GLBindBuffer(GL_ARRAY_BUFFER, vbo);
975 currentVertexBuffer = vbo;
981 void GLBindBuffer(int target, uint buffer)
984 glBindBuffer(target, buffer);
986 glBindBufferARB(target, buffer);
990 static int displayWidth, displayHeight;
992 #define GL_CLAMP_TO_EDGE 0x812F
994 static bool useSingleGLContext = false;
995 class OGLDisplay : struct
997 #if defined(__WIN32__)
1007 int imageBuffers[2];
1008 byte * pboMemory1, * pboMemory2;
1011 GLXContext glContext;
1014 XShmSegmentInfo shminfo;
1016 XShmSegmentInfo shminfoShape;
1017 XImage * shapeImage;
1021 X11Picture windowPicture;
1022 X11Picture pixmapPicture;
1024 X11Picture shapePicture;
1027 ColorAlpha * flippingBuffer;
1028 int flipBufH, flipBufW;
1033 class OGLSystem : struct
1035 #if defined(__WIN32__)
1036 PIXELFORMATDESCRIPTOR pfd;
1042 XVisualInfo * visualInfo;
1043 GLXContext glContext;
1045 GLXPixmap dummyGLXPixmap;
1050 class OGLSurface : struct
1057 float foreground[4], background[4], bitmapMult[4];
1060 class OGLMesh : struct
1069 class OGLIndices : struct
1076 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1077 static int primitiveTypes[RenderPrimitiveType] =
1079 GL_POINTS, GL_LINES, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP, GL_LINE_STRIP
1086 class OpenGLDisplayDriver : DisplayDriver
1088 class_property(name) = "OpenGL";
1090 bool LockSystem(DisplaySystem displaySystem)
1092 OGLSystem oglSystem = displaySystem.driverData;
1093 if(useSingleGLContext) return true;
1094 #if defined(__WIN32__)
1095 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1096 #elif defined(__unix__) || defined(__APPLE__)
1097 //if(previous) return true;
1098 // printf("Making SYSTEM current\n");
1099 #if defined(__APPLE__)
1100 glXMakeCurrent(xGlobalDisplay, displaySystem.window, oglSystem.glContext);
1102 #if defined(__ANDROID__)
1104 glXMakeCurrent(xGlobalDisplay, oglSystem.dummyGLXPixmap /*displaySystem.window /-*DefaultRootWindow(xGlobalDisplay)*/, oglSystem.glContext);
1107 //previous = oglSystem.glContext;
1112 void UnlockSystem(DisplaySystem displaySystem)
1114 if(useSingleGLContext) return;
1115 #if defined(__WIN32__)
1116 wglMakeCurrent(null, null);
1117 #elif defined(__unix__) || defined(__APPLE__)
1118 // printf("Making NULL current\n");
1119 #if defined(__ANDROID__)
1121 glXMakeCurrent(xGlobalDisplay, None, null);
1127 bool Lock(Display display)
1129 OGLDisplay oglDisplay = display.driverData;
1130 OGLSystem oglSystem = display.displaySystem.driverData;
1132 if(useSingleGLContext) return true;
1133 #if defined(__WIN32__)
1134 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1135 #elif defined(__unix__) || defined(__APPLE__)
1136 // if(previous) glXMakeCurrent(xGlobalDisplay, None, null);
1137 // printf(" Making DISPLAY current\n");
1138 #if defined(__ANDROID__)
1140 glXMakeCurrent(xGlobalDisplay, (int)display.window, oglDisplay.glContext);
1146 void Unlock(Display display)
1148 if(useSingleGLContext) return;
1149 //printf(" Making NULL current\n");
1150 //glXMakeCurrent(xGlobalDisplay, None, null);
1152 LockSystem(display.displaySystem);
1155 void DestroyDisplay(Display display)
1157 OGLDisplay oglDisplay = display.driverData;
1161 #if defined(__WIN32__)
1162 wglMakeCurrent( null, null );
1165 wglDeleteContext(oglDisplay.glrc);
1167 if(oglDisplay.hdc && oglDisplay.pBuffer)
1168 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
1170 if(oglDisplay.pBuffer)
1171 wglDestroyPbufferARB(oglDisplay.pBuffer);
1174 ReleaseDC(display.window, oglDisplay.hdc);
1176 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
1177 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
1179 #elif defined(__unix__) || defined(__APPLE__)
1180 #if defined(__ANDROID__)
1182 if(oglDisplay.shapePixmap)
1183 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
1184 if(oglDisplay.pixmap)
1185 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1186 if(oglDisplay.image)
1188 if(oglDisplay.shminfoShape.shmid != -1)
1190 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
1191 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1192 shmdt(oglDisplay.shminfo.shmaddr);
1193 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
1196 if(oglDisplay.shapeImage)
1198 if(oglDisplay.shminfoShape.shmid != -1)
1200 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
1201 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1202 shmdt(oglDisplay.shminfoShape.shmaddr);
1203 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
1205 XDestroyImage(oglDisplay.shapeImage);
1206 oglDisplay.shapeImage = None;
1209 glXMakeCurrent(xGlobalDisplay, None, null);
1211 if(oglDisplay.glContext)
1212 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
1215 delete oglDisplay.flippingBuffer;
1217 display.driverData = null;
1221 bool CreateDisplaySystem(DisplaySystem displaySystem)
1223 bool result = false;
1224 OGLSystem oglSystem = displaySystem.driverData = OGLSystem { };
1227 oglSystem.hwnd = CreateWindow("static", null, 0,0,0,0,0,null,null,null,null);
1229 oglSystem.hdc = GetDC(oglSystem.hwnd);
1233 oglSystem.pfd.nSize = (short)sizeof(oglSystem.pfd);
1234 oglSystem.pfd.nVersion = 1;
1235 oglSystem.pfd.dwFlags = PFD_DRAW_TO_WINDOW /*PFD_DRAW_TO_BITMAP*/ | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
1236 oglSystem.pfd.iPixelType = PFD_TYPE_RGBA;
1237 oglSystem.pfd.cColorBits = 24;
1238 oglSystem.pfd.cAlphaBits = 8;
1239 oglSystem.pfd.cDepthBits = 24;
1240 oglSystem.pfd.iLayerType = PFD_MAIN_PLANE;
1242 oglSystem.format = ChoosePixelFormat(oglSystem.hdc, &oglSystem.pfd);
1243 DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1245 if(oglSystem.pfd.cColorBits > 8)
1247 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1248 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1251 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1253 // Get Pointers To The GL Functions
1254 glActiveTextureARB = (void *) wglGetProcAddress("glActiveTextureARB");
1255 glMultiTexCoord2fARB = (void *) wglGetProcAddress("glMultiTexCoord2fARB");
1256 glClientActiveTextureARB = (void *) wglGetProcAddress("glClientActiveTextureARB");
1257 glLockArraysEXT = (void *) wglGetProcAddress("glLockArraysEXT" );
1258 glUnlockArraysEXT = (void *) wglGetProcAddress("glUnlockArraysEXT");
1259 glGenBuffersARB = (void *) wglGetProcAddress("glGenBuffersARB");
1260 glBindBufferARB = (void *) wglGetProcAddress("glBindBufferARB");
1261 glBufferDataARB = (void *) wglGetProcAddress("glBufferDataARB");
1262 glMapBufferARB = (void *) wglGetProcAddress("glMapBufferARB");
1263 glUnmapBufferARB = (void *) wglGetProcAddress("glUnmapBufferARB");
1264 glDeleteBuffersARB = (void *) wglGetProcAddress("glDeleteBuffersARB");
1265 glBlendFuncSeparate = (void *) wglGetProcAddress("glBlendFuncSeparate");
1267 wglChoosePixelFormatARB = (void *) wglGetProcAddress("wglChoosePixelFormatARB");
1268 wglGetExtensionsStringARB = (void *)wglGetProcAddress("wglGetExtensionsStringARB");
1269 wglCreatePbufferARB = (void *)wglGetProcAddress("wglCreatePbufferARB");
1270 wglGetPbufferDCARB = (void *)wglGetProcAddress("wglGetPbufferDCARB");
1271 wglQueryPbufferARB = (void *)wglGetProcAddress("wglQueryPbufferARB");
1272 wglDestroyPbufferARB = (void *)wglGetProcAddress("wglDestroyPbufferARB");
1273 wglReleasePbufferDCARB = (void *)wglGetProcAddress("wglReleasePbufferDCARB");
1274 wglBindTexImageARB = (void *)wglGetProcAddress("wglBindTexImageARB");
1275 wglReleaseTexImageARB = (void *)wglGetProcAddress("wglReleaseTexImageARB");
1277 wglSwapIntervalEXT = (void *)wglGetProcAddress("wglSwapIntervalEXT");
1279 // eSystem_LoggingMode(LOG_MSGBOX, null);
1281 if(wglChoosePixelFormatARB)
1286 float fAttributes[] = {0,0};
1289 WGL_DRAW_TO_WINDOW_ARB,GL_TRUE,
1290 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1291 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
1292 WGL_COLOR_BITS_ARB,24,
1293 WGL_ALPHA_BITS_ARB,8,
1294 WGL_DEPTH_BITS_ARB,16,
1295 WGL_STENCIL_BITS_ARB,0,
1296 WGL_DOUBLE_BUFFER_ARB,GL_TRUE,
1297 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
1298 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
1302 //Log("Found wglChoosePixelFormatARB\n");
1304 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1305 if(!valid || !numFormats)
1307 //Log("Can't find 4x multi sampling\n");
1308 iAttributes[19] = 2;
1309 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1310 if(!valid || !numFormats)
1312 // Log("Can't find 2x multi sampling\n");
1313 iAttributes[16] = 0;
1314 iAttributes[17] = 0;
1315 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1318 if(valid && numFormats)
1320 oglSystem.format = pixelFormat;
1321 wglMakeCurrent(null, null);
1322 wglDeleteContext(oglSystem.glrc);
1324 // *** DescribePixelFormat does not support WGL pixel formats! ***
1325 //DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1326 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1327 //Log("Successfully set pixel format\n");
1329 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1330 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1334 eSystem_Logf("Can't find wglChoosePixelFormatARB\n");*/
1338 wglMakeCurrent(null, null);
1340 //eSystem_DumpErrors(true);
1344 #elif defined(__unix__) || defined(__APPLE__)
1345 #if defined(__ANDROID__)
1346 egl_init_display(guiApp.desktop.windowHandle);
1351 #ifndef ECERE_MINIGLX
1352 GLX_USE_GL, GLX_DEPTH_SIZE, 1,
1355 GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,
1359 oglSystem.visualInfo = glXChooseVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay), attrList);
1360 if(oglSystem.visualInfo)
1362 //printf("glXChooseVisual returnded a visual info\n");
1363 #if !defined(__APPLE__)
1364 oglSystem.dummyPixmap = XCreatePixmap(xGlobalDisplay, (uint)displaySystem.window, 1, 1, oglSystem.visualInfo->depth);
1365 oglSystem.dummyGLXPixmap = glXCreateGLXPixmap(xGlobalDisplay, oglSystem.visualInfo, oglSystem.dummyPixmap);
1368 oglSystem.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, null, True);
1369 // printf("Creating system Context (%x)!\n", oglSystem.glContext);
1370 if(oglSystem.glContext)
1372 //printf("Got a Context\n");
1373 #if defined(__APPLE__)
1374 glXMakeCurrent(xGlobalDisplay, displaySystem.window, oglSystem.glContext);
1376 glXMakeCurrent(xGlobalDisplay, oglSystem.dummyGLXPixmap /*displaySystem.window /-*DefaultRootWindow(xGlobalDisplay)*/, oglSystem.glContext);
1381 glXMakeCurrent(xGlobalDisplay, None, null);
1389 displaySystem.flags.alpha = true;
1390 displaySystem.flags.flipping = true;
1391 displaySystem.pixelFormat = pixelFormat888;
1395 void DestroyDisplaySystem(DisplaySystem displaySystem)
1397 OGLSystem oglSystem = displaySystem.driverData;
1399 #if defined(__WIN32__)
1400 wglMakeCurrent( null, null );
1403 wglDeleteContext(oglSystem.glrc);
1406 ReleaseDC(oglSystem.hwnd, oglSystem.hdc);
1407 DestroyWindow(oglSystem.hwnd);
1409 #elif defined(__unix__) || defined(__APPLE__)
1410 #if defined(__ANDROID__)
1413 if(oglSystem.visualInfo)
1415 #ifdef ECERE_MINIGLX
1416 __miniglx_XFree(oglSystem.visualInfo);
1418 XFree(oglSystem.visualInfo);
1422 if(oglSystem.dummyGLXPixmap)
1423 glXDestroyGLXPixmap(xGlobalDisplay, oglSystem.dummyGLXPixmap);
1424 if(oglSystem.dummyPixmap);
1425 XFreePixmap(xGlobalDisplay, oglSystem.dummyPixmap);
1431 bool CreateDisplay(Display display)
1433 bool result = false;
1434 OGLDisplay oglDisplay = display.driverData;
1435 OGLSystem oglSystem = display.displaySystem.driverData;
1437 oglDisplay = display.driverData = OGLDisplay { };
1438 //printf("Inside CreateDisplay\n");
1440 #if defined(__WIN32__) || defined(USEPBUFFER)
1441 if(!display.alphaBlend)
1444 #if defined(__WIN32__)
1445 oglDisplay.hdc = GetDC(display.window);
1446 SetPixelFormat(oglDisplay.hdc, oglSystem.format, &oglSystem.pfd);
1447 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
1449 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
1450 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1454 ReleaseDC(display.window, oglDisplay.hdc);
1455 #elif defined(__unix__) || defined(__APPLE__)
1456 #if defined(__ANDROID__)
1458 XVisualInfo * visualInfo = null;
1462 GLX_RENDER_TYPE, GLX_RGBA_BIT,
1463 GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
1467 GLX_DOUBLEBUFFER, True,
1472 //visualInfo = glXChooseVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay), attrib);
1473 #if defined(__APPLE__)
1474 visualInfo = oglSystem.visualInfo;
1476 visualInfo = ((XWindowData)display.windowDriverData).visual;
1480 GLXFBConfig *fbconfigs, fbconfig;
1482 fbconfigs = glXChooseFBConfig(xGlobalDisplay, DefaultScreen(xGlobalDisplay), attrib, &numfbconfigs);
1486 for (i = 0; i < numfbconfigs; i++)
1488 XRenderPictFormat * format;
1489 visualInfo = glXGetVisualFromFBConfig(xGlobalDisplay, fbconfigs[i]);
1490 if (!visualInfo) continue;
1491 format = XRenderFindVisualFormat(xGlobalDisplay, visualInfo->visual);
1492 if (!format) continue;
1494 if(format->direct.alphaMask > 0)
1496 fbconfig = fbconfigs[i];
1499 //XFree(visualInfo);
1502 if (i == numfbconfigs)
1504 fbconfig = fbconfigs[0];
1505 visualInfo = glXGetVisualFromFBConfig(xGlobalDisplay, fbconfig);
1512 //printf("visualInfo is not null\n");
1513 // printf("Creating Display Context, sharing with %x!\n", oglSystem.glContext);
1514 oglDisplay.glContext = glXCreateContext(xGlobalDisplay, visualInfo, oglSystem.glContext, True);
1515 //XFree(visualInfo);
1518 // oglDisplay.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, oglSystem.glContext, True);
1519 if(oglDisplay.glContext)
1521 //printf("CreateDisplay Got a Context\n");
1522 glXMakeCurrent(xGlobalDisplay, (int)display.window, oglDisplay.glContext);
1528 #if defined(__WIN32__) || defined(USEPBUFFER)
1534 #if !defined(__OLDX__)
1535 if(glBlendFuncSeparate)
1536 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1539 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1542 glMatrixMode(GL_MODELVIEW);
1543 glScalef(1.0f, 1.0f, -1.0f);
1544 // glTranslatef(0.375f, 0.375f, 0.0f);
1545 // glTranslatef(-0.625f, -0.625f, 0.0f);
1546 glMatrixMode(GL_PROJECTION);
1547 glShadeModel(GL_FLAT);
1549 // glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, true);
1550 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
1551 glFogi(GL_FOG_MODE, GL_EXP);
1552 glFogf(GL_FOG_DENSITY, 0);
1553 glEnable(GL_NORMALIZE);
1554 glDepthFunc(GL_LESS);
1556 glDisable(GL_MULTISAMPLE_ARB);
1558 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1559 display.ambient = Color { 50,50,50 };
1562 if(!useSingleGLContext)
1564 #if defined(__WIN32__)
1565 wglMakeCurrent(null, null);
1566 #elif defined(__unix__) || defined(__APPLE__)
1567 #if defined(__ANDROID__)
1570 glXMakeCurrent(xGlobalDisplay, None, null);
1578 bool DisplaySize(Display display, int width, int height)
1580 OGLDisplay oglDisplay = display.driverData;
1581 OGLSystem oglSystem = display.displaySystem.driverData;
1583 bool result = false;
1585 //printf("Inside DisplaySize\n");
1586 #if defined(__WIN32__) || defined(USEPBUFFER)
1587 if(display.alphaBlend)
1589 #if defined(__WIN32__)
1590 const int attributes[]=
1592 /*WGL_TEXTURE_FORMAT_ARB, WGL_TEXTURE_RGBA_ARB,
1593 WGL_TEXTURE_TARGET_ARB, WGL_TEXTURE_2D_ARB, */0
1595 int pixelFormat = 0;
1596 if(wglChoosePixelFormatARB)
1600 float fAttributes[] = {0,0};
1603 //WGL_DRAW_TO_BITMAP_ARB, GL_TRUE,
1604 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
1605 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1606 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
1607 WGL_COLOR_BITS_ARB,24,
1608 WGL_ALPHA_BITS_ARB,8,
1609 WGL_DEPTH_BITS_ARB,16,
1610 WGL_STENCIL_BITS_ARB,0,
1611 WGL_DOUBLE_BUFFER_ARB,GL_FALSE,
1612 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
1613 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
1617 //Log("Found wglChoosePixelFormatARB\n");
1619 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1620 if(!valid || !numFormats)
1622 //Log("Can't find 4x multi sampling\n");
1623 iAttributes[19] = 2;
1624 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1625 if(!valid || !numFormats)
1627 // Log("Can't find 2x multi sampling\n");
1628 iAttributes[16] = 0;
1629 iAttributes[17] = 0;
1630 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1631 if(!valid || !numFormats)
1635 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
1636 //WGL_DRAW_TO_BITMAP_ARB,GL_TRUE,
1637 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1638 WGL_COLOR_BITS_ARB,24,
1639 WGL_ALPHA_BITS_ARB,8,
1640 WGL_DEPTH_BITS_ARB,16,
1643 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1647 if(valid && numFormats)
1649 wglMakeCurrent(null, null);
1653 wglMakeCurrent( null, null );
1654 wglMakeCurrent( oglDisplay.hdc, oglDisplay.glrc );
1655 if(oglDisplay.hdc && oglDisplay.pBuffer)
1656 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
1658 wglDestroyPbufferARB(oglDisplay.pBuffer);
1660 if(!useSingleGLContext)
1661 wglMakeCurrent( null, null );
1664 wglDeleteContext(oglDisplay.glrc);
1666 oglDisplay.pBuffer = wglCreatePbufferARB(oglSystem.hdc, pixelFormat, width, height, attributes);
1667 oglDisplay.hdc = wglGetPbufferDCARB(oglDisplay.pBuffer);
1668 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
1671 HDC hdc = GetDC(display.window);
1673 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
1674 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1676 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_WIDTH_ARB, &width);
1677 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_HEIGHT_ARB, &height);
1679 // glDeleteBuffersARB(2, oglDisplay.imageBuffers);
1681 if((info = (BITMAPINFO *)new0 byte[sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*256]))
1685 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
1686 oglDisplay.memDC = CreateCompatibleDC(hdc);
1687 SetMapMode(oglDisplay.memDC, MM_TEXT);
1688 info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1689 info->bmiHeader.biPlanes = 1;
1690 info->bmiHeader.biCompression = BI_RGB;
1691 info->bmiHeader.biBitCount = 32; //(uint16)GetDeviceCaps(hdc, BITSPIXEL);
1692 info->bmiHeader.biWidth = width;
1693 info->bmiHeader.biHeight = height;
1694 newBitmap = CreateDIBSection(hdc, info, DIB_RGB_COLORS, &oglDisplay.picture, null, 0);
1697 SelectObject(oglDisplay.memDC, newBitmap);
1698 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
1701 PIXELFORMATDESCRIPTOR pfd = { 0 };
1702 pfd.nSize = (short)sizeof(pfd);
1704 pfd.dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL;
1705 pfd.iPixelType = PFD_TYPE_RGBA;
1706 pfd.cColorBits = 32;
1707 //pfd.cAlphaBits = 8;
1708 pfd.cDepthBits = 24;
1709 pfd.iLayerType = PFD_MAIN_PLANE;
1711 oglDisplay.hdc = oglDisplay.memDC;
1713 pixelFormat = ChoosePixelFormat(oglSystem.hdc, &pfd);
1714 DescribePixelFormat(oglDisplay.hdc, pixelFormat, sizeof(pfd), &pfd);
1715 SetPixelFormat(oglDisplay.hdc, pixelFormat, &pfd);
1717 oglDisplay.glrc = wglCreateContext(oglDisplay.hdc);
1718 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
1719 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1724 const int imageSize = width * height * 4;
1726 glGenBuffersARB(2, oglDisplay.imageBuffers);
1728 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
1729 glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize, null, GL_STREAM_READ);
1730 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
1731 // glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize / 2, null, GL_STREAM_READ);
1734 oglDisplay.memBitmap = newBitmap;
1735 oglDisplay.stride = width;
1741 ReleaseDC(display.window, hdc);
1743 #elif defined(__unix__) || defined(__APPLE__)
1744 #if defined(__ANDROID__)
1749 GLX_DOUBLEBUFFER, True,
1755 GLX_STENCIL_SIZE, 1,
1756 //GLX_DEPTH_SIZE, 24,
1757 GLX_RENDER_TYPE, GLX_RGBA_BIT,
1758 GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT | GLX_WINDOW_BIT,
1764 GLX_PBUFFER_WIDTH, width,
1765 GLX_PBUFFER_HEIGHT, height,
1766 GLX_LARGEST_PBUFFER, False,
1770 // choose a pixel format that meets our minimum requirements
1773 GLXFBConfig *config = glXChooseFBConfig(xGlobalDisplay, DefaultScreen(xGlobalDisplay), attrib, &count);
1776 if(oglDisplay.pixmap)
1778 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1779 oglDisplay.pixmap = None;
1781 if(oglDisplay.shapePixmap)
1783 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
1784 oglDisplay.shapePixmap = None;
1787 // Free Shared Memory Pixmap
1788 if(oglDisplay.image)
1790 if(oglDisplay.shminfoShape.shmid != -1)
1792 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
1793 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1794 shmdt(oglDisplay.shminfo.shmaddr);
1795 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
1797 XDestroyImage(oglDisplay.image);
1798 oglDisplay.image = None;
1800 if(oglDisplay.shapeImage)
1802 if(oglDisplay.shminfoShape.shmid != -1)
1804 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
1805 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1806 shmdt(oglDisplay.shminfoShape.shmaddr);
1807 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
1809 XDestroyImage(oglDisplay.shapeImage);
1810 oglDisplay.shapeImage = None;
1813 if(oglDisplay.windowPicture)
1814 XRenderFreePicture(xGlobalDisplay, oglDisplay.windowPicture);
1815 if(oglDisplay.pixmapPicture)
1816 XRenderFreePicture(xGlobalDisplay, oglDisplay.pixmapPicture);
1818 if(oglDisplay.pixmap)
1819 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1821 if(oglDisplay.glContext)
1822 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
1823 if(oglDisplay.pBuffer)
1824 glXDestroyPbuffer(xGlobalDisplay, oglDisplay.pBuffer);
1826 oglDisplay.pBuffer = glXCreatePbuffer(xGlobalDisplay, config[0], PBattrib);
1827 if(oglDisplay.pBuffer)
1829 oglDisplay.glContext = glXCreateNewContext(xGlobalDisplay, config[0], GLX_RGBA_TYPE, oglSystem.glContext, True);
1830 if(oglDisplay.glContext)
1832 glXMakeCurrent(xGlobalDisplay, None, null);
1833 glXMakeCurrent(xGlobalDisplay, (int)display.window, oglDisplay.glContext);
1835 // Initialize Shared Memory Pixmap
1836 oglDisplay.image = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 32,
1837 ZPixmap, null, &oglDisplay.shminfo, width, height);
1838 if(oglDisplay.image)
1840 oglDisplay.shminfo.shmid = shmget(IPC_PRIVATE,
1841 oglDisplay.image->bytes_per_line * oglDisplay.image->height, IPC_CREAT|0777);
1842 if(oglDisplay.shminfo.shmid != -1)
1844 oglDisplay.shminfo.shmaddr = shmat(oglDisplay.shminfo.shmid, 0, 0);
1845 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1847 oglDisplay.shminfo.readOnly = False;
1848 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfo))
1850 oglDisplay.pixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfo.shmaddr,
1851 &oglDisplay.shminfo, width, height, 32);
1853 // Initialize Shared Memory Shape Pixmap
1854 oglDisplay.shapeImage = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 1,
1855 ZPixmap, null, &oglDisplay.shminfoShape, width, height);
1856 if(oglDisplay.shapeImage)
1858 oglDisplay.shminfoShape.shmid = shmget(IPC_PRIVATE,
1859 oglDisplay.shapeImage->bytes_per_line * oglDisplay.shapeImage->height, IPC_CREAT|0777);
1860 if(oglDisplay.shminfoShape.shmid != -1)
1862 oglDisplay.shminfoShape.shmaddr = shmat(oglDisplay.shminfoShape.shmid, 0, 0);
1863 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1865 oglDisplay.shminfoShape.readOnly = False;
1866 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfoShape))
1868 oglDisplay.shapePixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfoShape.shmaddr,
1869 &oglDisplay.shminfoShape, width, height, 1);
1870 //oglDisplay.shapePixmap = XCreatePixmap(xGlobalDisplay, (X11Window)display.window, width, height, 1);
1873 XRenderPictureAttributes attributes = { 0 };
1874 XRenderPictFormat * format = XRenderFindStandardFormat(xGlobalDisplay, /*PictStandardRGB24*/ PictStandardARGB32);
1875 #if !defined(__APPLE__) && !defined(__OLDX__)
1876 attributes.repeat = RepeatNormal;
1878 attributes.repeat = 1;
1880 oglDisplay.pixmapPicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.pixmap, format, CPRepeat, &attributes);
1881 oglDisplay.windowPicture = XRenderCreatePicture(xGlobalDisplay, (X11Window)display.window, format, 0, &attributes);
1882 oglDisplay.shapePicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.shapePixmap,
1883 XRenderFindStandardFormat(xGlobalDisplay, PictStandardA1), 0, &attributes);
1886 oglDisplay.picture = oglDisplay.shminfo.shmaddr;
1887 oglDisplay.stride = oglDisplay.image->bytes_per_line / 4;
1904 CreateDisplay(display);
1905 #if defined(__WIN32__)
1906 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1907 #elif defined(__unix__) || defined(__APPLE__)
1908 #if defined(__ANDROID__)
1912 glXMakeCurrent(xGlobalDisplay, (int)display.window, oglDisplay.glContext);
1919 if(!result && display.alphaBlend)
1921 printf("Alpha blending windows not supported on this display\n");
1928 glViewport(0,0,width,height);
1930 glOrtho(0,width,height,0,0.0,1.0);
1931 displayWidth = display.width = width;
1932 displayHeight = display.height = height;
1934 if(!oglDisplay.flippingBuffer || oglDisplay.flipBufW < width || oglDisplay.flipBufH < height)
1936 oglDisplay.flipBufW = width;
1937 oglDisplay.flipBufH = height;
1938 oglDisplay.flippingBuffer = renew oglDisplay.flippingBuffer ColorAlpha [width * height];
1940 if(oglDisplay.flippingBuffer || !width || !height)
1946 void DisplayPosition(Display display, int x, int y)
1948 OGLDisplay oglDisplay = display.driverData;
1954 void SetPalette(Display display, ColorAlpha * palette, bool colorMatch)
1958 void RestorePalette(Display display)
1962 void StartUpdate(Display display)
1966 void EndUpdate(Display display)
1970 void Scroll(Display display, Box scroll, int x, int y, Extent dirty)
1974 void Update(Display display, Box updateBox)
1976 OGLDisplay oglDisplay = display.driverData;
1977 //Logf("DisplayScreen\n");
1981 #if defined(__WIN32__) || defined(USEPBUFFER)
1982 if(display.alphaBlend)
1984 glPixelStorei(GL_PACK_ALIGNMENT, 4);
1985 glPixelStorei(GL_PACK_ROW_LENGTH, oglDisplay.stride);
1986 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
1987 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
1988 glReadPixels(0,0,display.width,display.height,GL_BGRA_EXT,GL_UNSIGNED_BYTE, oglDisplay.picture);
1991 #if defined(__WIN32__)
1993 POINT point = { oglDisplay.x, oglDisplay.y};
1994 POINT srcPoint = { 0, 0 };
1995 BLENDFUNCTION blend = { 0 };
1997 size.cx = display.width;
1998 size.cy = display.height;
1999 blend.BlendOp = AC_SRC_OVER;
2000 blend.BlendFlags = 0;
2001 blend.SourceConstantAlpha = 255;
2002 blend.AlphaFormat = AC_SRC_ALPHA;
2005 // Process partial images. Mapping the buffer waits for
2006 // outstanding DMA transfers into the buffer to finish.
2007 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2008 oglDisplay.pboMemory1 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY);
2010 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2011 // oglDisplay.pboMemory2 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB,GL_READ_ONLY);
2014 memcpy(oglDisplay.picture, oglDisplay.pboMemory1, display.width * display.height * 4);
2015 //memcpy(oglDisplay.picture + display.width * display.height * 4 / 2, oglDisplay.pboMemory2, display.width * display.height * 4/ 2);
2018 UpdateLayeredWindow(display.window, hdc, &point, &size, oglDisplay.memDC, &srcPoint, 0, &blend, ULW_ALPHA);
2021 // Unmap the image buffers
2022 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2023 glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2025 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2026 // glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2028 // Bind two different buffer objects and start the glReadPixels
2029 // asynchronously. Each call will return directly after
2030 // starting the DMA transfer.
2031 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2032 glReadPixels(0, 0, display.width, display.height, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2034 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2035 // glReadPixels(0, display.height/2, display.width, display.height/2, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2039 #elif defined(__unix__) || defined(__APPLE__)
2040 #if defined(__ANDROID__)
2042 XTransform transform =
2045 { (int)(1.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(0 * (1 << 16)) },
2046 { (int)(0.0f), (int)(-1.0f * (1<<16)), (int)(0 * (1<<16)) },
2047 { (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)) }
2050 XRenderSetPictureTransform(xGlobalDisplay, oglDisplay.pixmapPicture, &transform);
2051 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.shapePicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2052 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.windowPicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2053 #if !defined(__APPLE__) && !defined(__OLDX__)
2054 XShapeCombineMask(xGlobalDisplay, (uint)display.window, ShapeInput, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2056 XShapeCombineMask(xGlobalDisplay, display.window, 2, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2058 XFlush(xGlobalDisplay);
2066 #if defined(__WIN32__)
2067 //wglSwapLayerBuffers(oglDisplay.hdc,WGL_SWAP_MAIN_PLANE);
2068 SwapBuffers(oglDisplay.hdc);
2069 #elif defined(__unix__) || defined(__APPLE__)
2070 #if defined(__ANDROID__)
2071 eglSwapBuffers(eglDisplay, eglSurface);
2073 glXSwapBuffers(xGlobalDisplay, (int)display.window);
2077 //Logf("Out of DisplayScreen\n");
2080 void FreeBitmap(DisplaySystem displaySystem, Bitmap bitmap)
2082 glDeleteTextures(1, (int *)&bitmap.driverData);
2083 bitmap.driverData = 0;
2085 bitmap.driver = ((subclass(DisplayDriver))class(LFBDisplayDriver));
2088 bool AllocateBitmap(DisplaySystem displaySystem, Bitmap bitmap, int width, int height, int stride, PixelFormat format, bool allocatePalette)
2090 bool result = false;
2094 uint w = pow2i(Min(width, 1024)), h = pow2i(Min(height, 1024));
2095 //uint w = pow2i(Min(width, 2048)), h = pow2i(Min(height, 2048));
2096 //uint w = pow2i(Min(width, 512)), h = pow2i(Min(height, 512));
2098 glGenTextures(1, &glBitmap);
2099 glBindTexture(GL_TEXTURE_2D, glBitmap);
2101 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2103 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2104 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2106 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2107 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2109 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2111 mipMap.Allocate(null, w, h, w, pixelFormatRGBA, false);
2113 // glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2114 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2118 bitmap.driverData = (void *)glBitmap;
2119 bitmap.driver = displaySystem.driver;
2127 bool MakeDDBitmap(DisplaySystem displaySystem, Bitmap bitmap, bool mipMaps)
2129 bool result = false;
2130 OGLSystem oglSystem = displaySystem.driverData;
2132 // Pre process the bitmap... First make it 32 bit
2133 if(/*bitmap.pixelFormat == pixelFormatRGBA || */bitmap.Convert(null, pixelFormat888, null))
2136 uint w = pow2i(Min(bitmap.width, 1024)), h = pow2i(Min(bitmap.height, 1024));
2137 //uint w = pow2i(Min(bitmap.width, 512)), h = pow2i(Min(bitmap.height, 512));
2140 // Switch ARGB to RGBA
2141 //if(bitmap.format != pixelFormatRGBA)
2143 for(c=0; c<bitmap.size; c++)
2145 // ((ColorRGBA *)bitmap.picture)[c] = ((ColorAlpha *)bitmap.picture)[c];
2147 ColorAlpha color = ((ColorAlpha *)bitmap.picture)[c];
2148 ((ColorRGBA *)bitmap.picture)[c] = ColorRGBA { color.color.r, color.color.g, color.color.b, color.a };
2151 bitmap.pixelFormat = pixelFormat888;
2154 glGenTextures(1, &glBitmap);
2157 int error = glGetError();
2162 glBindTexture(GL_TEXTURE_2D, glBitmap);
2163 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2165 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2166 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mipMaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
2167 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2169 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
2170 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
2172 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2173 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2175 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2179 for(level = 0; result && (w > 1 || h > 1); level++, w >>= 1, h >>= 1)
2182 if(bitmap.width != w || bitmap.height != h)
2184 mipMap = Bitmap { };
2185 if(mipMap.Allocate(null, w, h, w, bitmap.pixelFormat, false))
2187 Surface mipSurface = mipMap.GetSurface(0,0,null);
2188 mipSurface.Filter(bitmap, 0,0,0,0, w, h, bitmap.width, bitmap.height);
2205 // glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2206 glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2207 //printf("Calling glTexImage2D\n");
2208 //glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &width);
2209 //printf("width = %d (Should be %d, %d)\n", width, w, h);
2210 if((error = glGetError()))
2212 //Logf("OpenGL Bitmap MakeDD error: %d...\n", error);
2213 //printf("OpenGL Bitmap MakeDD error: %d...\n", error);
2217 if(mipMap != bitmap)
2222 if(!bitmap.keepData)
2223 bitmap.driver.FreeBitmap(bitmap.displaySystem, bitmap);
2224 bitmap.driverData = (void *)glBitmap;
2225 bitmap.driver = displaySystem.driver;
2228 FreeBitmap(displaySystem, bitmap);
2229 else if(oglSystem.loadingFont)
2231 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2232 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2233 oglSystem.loadingFont = false;
2239 void ReleaseSurface(Display display, Surface surface)
2241 glDisable(GL_SCISSOR_TEST);
2242 delete surface.driverData;
2243 surface.driverData = null;
2246 bool GetBitmapSurface(DisplaySystem displaySystem, Surface surface, Bitmap bitmap, int x, int y, Box clip)
2251 bool GetSurface(Display display, Surface surface, int x,int y, Box clip)
2253 bool result = false;
2254 OGLSurface oglSurface = surface.driverData = OGLSurface { };
2256 //Logf("GetSurface\n");
2260 if(displayWidth != display.width || displayHeight != display.height)
2262 displayWidth = display.width;
2263 displayHeight = display.height;
2265 glViewport(0,0,display.width,display.height);
2267 glOrtho(0,display.width,display.height,0,0.0,1.0);
2270 surface.offset.x = x;
2271 surface.offset.y = y;
2272 surface.unclippedBox = surface.box = clip;
2273 oglSurface.bitmapMult[0] = 1;
2274 oglSurface.bitmapMult[1] = 1;
2275 oglSurface.bitmapMult[2] = 1;
2276 oglSurface.bitmapMult[3] = 1;
2278 glEnable(GL_SCISSOR_TEST);
2281 (display.height) -(y+clip.bottom)-1,
2282 clip.right-clip.left+1,
2283 clip.bottom-clip.top+1);
2289 void Clip(Display display, Surface surface, Box clip)
2298 box.Clip(surface.unclippedBox);
2302 box = surface.box = surface.unclippedBox;
2303 box.left += surface.offset.x;
2304 box.top += surface.offset.y;
2305 box.right+= surface.offset.x;
2306 box.bottom += surface.offset.y;
2309 box.left,display.height - box.bottom - 1,
2310 box.right-box.left+1, box.bottom-box.top+1);
2313 bool GrabScreen(Display display, Bitmap bitmap, int x, int y, unsigned int w, unsigned int h)
2315 bool result = false;
2316 OGLDisplay oglDisplay = display.driverData;
2317 ColorAlpha * flippingBuffer = oglDisplay.flippingBuffer;
2319 if(oglDisplay.flippingBuffer)
2321 if(bitmap.pixelFormat != pixelFormat888 || bitmap.width < w || bitmap.height < h)
2324 bitmap.Allocate(null, w,h,w, pixelFormat888, false);
2330 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2331 glPixelStorei(GL_PACK_ROW_LENGTH, bitmap.stride);
2332 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2333 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2334 glReadPixels(x,display.height-h-y,w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, flippingBuffer);
2337 for(row = 0; row<h; row++)
2338 CopyBytesBy4(((ColorAlpha *)bitmap.picture) + row * w, ((ColorAlpha *)flippingBuffer) + (h-row-1) * w, w);
2345 void SetForeground(Display display, Surface surface, ColorAlpha color)
2347 OGLSurface oglSurface = surface.driverData;
2349 //Logf("SetForeground\n");
2351 oglSurface.foreground[0] = color.color.r/255.0f;
2352 oglSurface.foreground[1] = color.color.g/255.0f;
2353 oglSurface.foreground[2] = color.color.b/255.0f;
2354 //oglSurface.foreground[3] = 1.0f;
2355 oglSurface.foreground[3] = color.a/255.0f;
2357 //if(!oglSurface.foreground[3])printf("bug");
2360 void SetBackground(Display display, Surface surface, ColorAlpha color)
2362 OGLSurface oglSurface = surface.driverData;
2364 //Logf("SetBackground\n");
2366 oglSurface.background[0] = color.color.r/255.0f;
2367 oglSurface.background[1] = color.color.g/255.0f;
2368 oglSurface.background[2] = color.color.b/255.0f;
2369 //oglSurface.background[3] = 1.0;
2370 oglSurface.background[3] = color.a/255.0f;
2373 void SetBlitTint(Display display, Surface surface, ColorAlpha color)
2375 OGLSurface oglSurface = surface.driverData;
2377 oglSurface.bitmapMult[0] = color.color.r/255.0f;
2378 oglSurface.bitmapMult[1] = color.color.g/255.0f;
2379 oglSurface.bitmapMult[2] = color.color.b/255.0f;
2380 oglSurface.bitmapMult[3] = color.a/255.0f;
2383 ColorAlpha GetPixel(Display display, Surface surface,int x,int y)
2388 void PutPixel(Display display, Surface surface,int x,int y)
2390 OGLSurface oglSurface = surface.driverData;
2392 //Logf("PutPixel\n");
2394 glColor4fv(oglSurface.foreground);
2396 // glVertex2i(x+surface.offset.x, y+surface.offset.y);
2397 glVertex2f(x+surface.offset.x + 0.5f, y+surface.offset.y + 0.5f);
2402 void DrawLine(Display display, Surface surface, int x1, int y1, int x2, int y2)
2404 OGLSurface oglSurface = surface.driverData;
2405 if(x1 == x2) { y2++; y1--; }
2406 else if(y1 == y2) { x2++; x1--; }
2407 x1 += surface.offset.x;
2408 y1 += surface.offset.y;
2409 x2 += surface.offset.x;
2410 y2 += surface.offset.y;
2414 glColor4fv(oglSurface.foreground);
2419 glTexCoord2f(0.5f, 0);
2420 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2421 glTexCoord2f(Max(x2-x1, y2-y1) + 0.5f, 0);
2422 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2431 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2432 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2438 void Rectangle(Display display, Surface surface,int x1,int y1,int x2,int y2)
2440 OGLSurface oglSurface = surface.driverData;
2441 x1 += surface.offset.x;
2442 y1 += surface.offset.y;
2443 x2 += surface.offset.x;
2444 y2 += surface.offset.y;
2446 //Logf("Rectangle\n");
2448 glColor4fv(oglSurface.foreground);
2454 glTexCoord2f(0.5f, 0);
2455 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2456 glTexCoord2f(y2-y1 + 0.5f, 0);
2457 glVertex2f(x1 + 0.5f, y2 + 0.5f);
2459 glTexCoord2f(0.5f, 0);
2460 glVertex2f(x1 + 0.5f, y2 + 0.5f);
2461 glTexCoord2f(x2 - x1 + 0.5f, 0);
2462 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2464 glTexCoord2f(0.5f, 0);
2465 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2466 glTexCoord2f(y1 - y2 + 0.5f, 0);
2467 glVertex2f(x2 + 0.5f, y1 + 0.5f);
2469 glTexCoord2f(0.5f, 0);
2470 glVertex2f(x2 + 0.5f, y1 + 0.5f);
2471 glTexCoord2f(x1 - x2 + 0.5f, 0);
2472 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2477 glBegin(GL_LINE_LOOP);
2484 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2485 glVertex2f(x1 + 0.5f, y2 + 0.5f);
2486 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2487 glVertex2f(x2 + 0.5f, y1 + 0.5f);
2492 void Area(Display display, Surface surface,int x1,int y1,int x2,int y2)
2494 OGLSurface oglSurface = surface.driverData;
2497 glColor4fv(oglSurface.background);
2498 glRecti(x1+surface.offset.x, y1+surface.offset.y,
2499 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
2502 glRectf(x1+surface.offset.x, y1+surface.offset.y,
2503 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
2507 void Clear(Display display, Surface surface, ClearType type)
2509 OGLDisplay oglDisplay = display.driverData;
2510 OGLSurface oglSurface = surface.driverData;
2513 if(type != depthBuffer)
2514 glClearColor(oglSurface.background[0], oglSurface.background[1], oglSurface.background[2], oglSurface.background[3]);
2515 if(type != colorBuffer && !oglDisplay.depthWrite)
2517 glDepthMask((byte)bool::true);
2519 glClear(((type != depthBuffer) ? GL_COLOR_BUFFER_BIT : 0) |
2520 ((type != colorBuffer) ? GL_DEPTH_BUFFER_BIT : 0));
2521 if(type != colorBuffer && !oglDisplay.depthWrite)
2523 glDepthMask((byte)bool::false);
2527 bool ConvertBitmap(DisplaySystem displaySystem, Bitmap bitmap, PixelFormat format, ColorAlpha * palette)
2532 void Blit(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
2534 OGLSurface oglSurface = surface.driverData;
2536 #if !defined(__OLDX__)
2537 // WHY DO WE HAVE GL_ONE HERE ?
2538 /*if(glBlendFuncSeparate && !oglSurface.writingText)
2539 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
2542 if(!oglSurface.writingText)
2544 // glTranslatef(-0.375f, -0.375f, 0.0f);
2545 glEnable(GL_TEXTURE_2D);
2546 glColor4fv(oglSurface.bitmapMult);
2548 else if(oglSurface.xOffset)
2549 glTranslatef(oglSurface.xOffset / 64.0f/*-0.375f*/, 0.0f, 0.0f);
2551 glBindTexture(GL_TEXTURE_2D, (uint)bitmap.driverData);
2556 glTexCoord2f((float)sx/ bitmap.width, (float)(sy-h)/ bitmap.height);
2557 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
2558 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy-h)/ bitmap.height);
2559 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
2560 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
2561 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
2562 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
2563 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
2568 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
2569 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
2570 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
2571 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
2572 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
2573 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
2574 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
2575 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
2578 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
2579 glVertex2f((float)dx+surface.offset.x, (float)dy+surface.offset.y);
2580 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
2581 glVertex2f((float)dx+w+surface.offset.x, (float)dy+surface.offset.y);
2582 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
2583 glVertex2f((float)dx+w+surface.offset.x, (float)dy+h+surface.offset.y);
2584 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
2585 glVertex2f((float)dx+surface.offset.x, (float)dy+h+surface.offset.y);
2589 if(!oglSurface.writingText)
2591 glDisable(GL_TEXTURE_2D);
2593 //glTranslatef(0.375f, 0.375f, 0.0f);
2595 else if(oglSurface.xOffset)
2596 glTranslatef(-oglSurface.xOffset / 64.0f/*+0.375f*/, 0.0f, 0.0f);
2598 #if !defined(__OLDX__)
2599 /*if(glBlendFuncSeparate && !oglSurface.writingText)
2600 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
2604 void Stretch(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
2606 OGLSurface oglSurface = surface.driverData;
2608 //glTranslatef(-0.375f, -0.375f, 0.0f);
2610 //Logf("Stretch\n");
2612 #if !defined(__OLDX__)
2613 /*if(glBlendFuncSeparate)
2614 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
2617 glEnable(GL_TEXTURE_2D);
2618 glBindTexture(GL_TEXTURE_2D, (uint)bitmap.driverData);
2620 glColor4fv(oglSurface.bitmapMult);
2626 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
2627 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
2629 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
2630 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
2632 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
2633 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
2635 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
2636 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
2640 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
2641 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
2643 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
2644 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
2646 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
2647 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
2649 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
2650 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
2655 glDisable(GL_TEXTURE_2D);
2657 //glTranslatef(0.375f, 0.375f, 0.0f);
2658 #if !defined(__OLDX__)
2659 /*if(glBlendFuncSeparate)
2660 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
2665 void Filter(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
2667 Stretch(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
2670 void StretchDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
2672 float s2dw,s2dh,d2sw,d2sh;
2673 bool flipX = false, flipY = false;
2675 //Logf("StretchDI\n");
2677 if(Sgn(w) != Sgn(sw))
2683 if(Sgn(h) != Sgn(sh))
2695 //Clip against the edges of the source
2698 dx+=(int)((0-sx) * s2dw);
2699 w-=(int)((0-sx) * s2dw);
2705 dy+=(int)((0-sy) * s2dh);
2706 h-=(int)((0-sy) * s2dh);
2711 if(sx+sw>bitmap.width-1)
2713 w-=(int)((sx+sw-(bitmap.width-1)-1)*s2dw);
2714 sw-=sx+sw-(bitmap.width-1)-1;
2716 if(sy+sh>(bitmap.height-1))
2718 h-=(int)((sy+sh-(bitmap.height-1)-1)*s2dh);
2719 sh-=sy+sh-(bitmap.height-1)-1;
2721 //Clip against the edges of the surfaceination
2722 if(dx<surface.box.left)
2725 sx+=(int)((surface.box.left-dx)*d2sw);
2726 sw-=(int)((surface.box.left-dx)*d2sw);
2727 w-=surface.box.left-dx;
2728 dx=surface.box.left;
2730 if(dy<surface.box.top)
2732 sy+=(int)((surface.box.top-dy)*d2sh);
2733 sh-=(int)((surface.box.top-dy)*d2sh);
2734 h-=surface.box.top-dy;
2737 if(dx+w>surface.box.right)
2739 //if(flip) sx+=(int)((dx+w-surface.box.right-1)*d2sw);
2740 sw-=(int)((dx+w-surface.box.right-1)*d2sw);
2741 w-=dx+w-surface.box.right-1;
2743 if(dy+h>surface.box.bottom)
2745 sh-=(int)((dy+h-surface.box.bottom-1)*d2sh);
2746 h-=dy+h-surface.box.bottom-1;
2748 if((w<=0)||(h<=0)||(sw<=0)||(sh<=0)) return;
2750 dx += surface.offset.x;
2751 dy += surface.offset.y;
2753 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
2755 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
2756 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
2757 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
2758 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
2759 glRasterPos2d(dx,dy);
2760 //glPixelZoom(flipX ? -s2dw : s2dw, flipY ? s2dh : -s2dh);
2761 glPixelZoom(s2dw, -s2dh);
2762 glDrawPixels(sw,sh,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
2763 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
2764 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
2768 void BlitDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
2772 //Clip against the edges of the source
2785 if(sx+w>bitmap.width-1)
2786 w-=sx+w-(bitmap.width-1)-1;
2787 if(sy+h>bitmap.height-1)
2788 h-=sy+h-(bitmap.height-1)-1;
2789 //Clip against the edges of the surfaceination
2790 if(dx<surface.box.left)
2793 sx+=surface.box.left-dx;
2794 w-=surface.box.left-dx;
2795 dx=surface.box.left;
2797 if(dy<surface.box.top)
2799 sy+=surface.box.top-dy;
2800 h-=surface.box.top-dy;
2803 if(dx+w>surface.box.right)
2805 //if(flip) sx+=dx+w-surface.box.right-1;
2806 w-=dx+w-surface.box.right-1;
2808 if(dy+h>surface.box.bottom)
2809 h-=dy+h-surface.box.bottom-1;
2813 dx += surface.offset.x;
2814 dy += surface.offset.y;
2816 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
2818 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
2819 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
2820 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
2821 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
2822 glRasterPos2d(dx,dy);
2824 glDrawPixels(w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
2825 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
2826 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
2830 void FilterDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
2832 StretchDI(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
2835 void UnloadFont(DisplaySystem displaySystem, Font font)
2837 ((subclass(DisplayDriver))class(LFBDisplayDriver)).UnloadFont(displaySystem, font);
2840 Font LoadFont(DisplaySystem displaySystem, char * faceName, float size, FontFlags flags)
2843 OGLSystem oglSystem = displaySystem.driverData;
2844 oglSystem.loadingFont = true;
2845 font = ((subclass(DisplayDriver))class(LFBDisplayDriver)).LoadFont(displaySystem, faceName, size, flags);
2849 void FontExtent(DisplaySystem displaySystem, Font font, char * text, int len, int * width, int * height)
2851 ((subclass(DisplayDriver))class(LFBDisplayDriver)).FontExtent(displaySystem, font, text, len, width, height);
2854 void WriteText(Display display, Surface surface, int x, int y, char * text, int len)
2856 OGLSurface oglSurface = surface.driverData;
2857 OGLSystem oglSystem = display.displaySystem.driverData;
2858 oglSystem.loadingFont = true;
2860 //glTranslatef(-0.375f, -0.375f, 0.0f);
2864 if(surface.textOpacity)
2867 FontExtent(display.displaySystem, surface.font, text, len, &w, &h);
2868 display.displaySystem.driver.Area(display, surface,x,y,x+w-1,y+h-1);
2871 oglSurface.writingText = true;
2873 glEnable(GL_TEXTURE_2D);
2874 glColor4fv(oglSurface.foreground);
2876 ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x, y, text, len);
2877 oglSurface.writingText = false;
2878 oglSystem.loadingFont = false;
2880 glDisable(GL_TEXTURE_2D);
2882 //glTranslatef(0.375f, 0.375f, 0.0f);
2885 void TextFont(Display display, Surface surface, Font font)
2887 ((subclass(DisplayDriver))class(LFBDisplayDriver)).TextFont(display, surface, font);
2890 void TextOpacity(Display display, Surface surface, bool opaque)
2892 OGLSurface oglSurface = surface.driverData;
2893 oglSurface.opaqueText = opaque;
2896 void TextExtent(Display display, Surface surface, char * text, int len, int * width, int * height)
2898 OGLSurface oglSurface = surface.driverData;
2899 OGLSystem oglSystem = display.displaySystem.driverData;
2900 oglSystem.loadingFont = true;
2901 FontExtent(display.displaySystem, oglSurface.font, text, len, width, height);
2902 oglSystem.loadingFont = false;
2905 void DrawingChar(Display display, Surface surface, char character)
2910 void LineStipple(Display display, Surface surface, uint32 stipple)
2912 //Logf("Stipple\n");
2916 #if defined(__ANDROID__)
2917 stippleEnabled = true;
2918 glesLineStipple(1, (uint16)stipple);
2920 glLineStipple(1, (uint16)stipple);
2921 glEnable(GL_LINE_STIPPLE);
2926 #if defined(__ANDROID__)
2927 stippleEnabled = false;
2928 glMatrixMode(GL_TEXTURE);
2930 glMatrixMode(GL_PROJECTION);
2931 glDisable(GL_TEXTURE_2D);
2933 glDisable(GL_LINE_STIPPLE);
2937 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
2938 void SetRenderState(Display display, RenderState state, uint value)
2940 OGLDisplay oglDisplay = display.driverData;
2941 //Logf("RenderState\n");
2947 glEnable(GL_MULTISAMPLE_ARB);
2949 glDisable(GL_MULTISAMPLE_ARB);
2952 glPolygonMode(GL_FRONT_AND_BACK, ((FillModeValue)value == solid) ? GL_FILL : GL_LINE);
2955 if(value) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
2958 if(value) glDepthMask((byte)bool::true); else glDepthMask((byte)bool::false);
2959 oglDisplay.depthWrite = value;
2963 float color[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
2964 glFogfv(GL_FOG_COLOR, (float *)&color);
2968 glFogf(GL_FOG_DENSITY, *(float *)(void *)&value);
2971 if(value) glEnable(GL_BLEND); else glDisable(GL_BLEND);
2975 float ambient[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
2976 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
2981 if(value) glColorMask(1,1,1,1); else glColorMask(1,1,1,0);
2986 #if defined(__WIN32__)
2987 wglSwapIntervalEXT(value ? 1 : 0);
2994 void SetLight(Display display, int id, Light light)
2996 //Logf("SetLight\n");
3000 Object lightObject = light.lightObject;
3001 float position[4] = { 0, 0, 0, 0 };
3002 float color[4] = { 0, 0, 0, 1 };
3004 glEnable(GL_LIGHT0 + id);
3006 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, (float *)&light.diffuse);
3007 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, (float *)&light.ambient);
3008 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,(float *)&light.specular);
3011 if(!light.multiplier) light.multiplier = 1.0f;
3013 color[0] = light.diffuse.r * light.multiplier;
3014 color[1] = light.diffuse.g * light.multiplier;
3015 color[2] = light.diffuse.b * light.multiplier;
3016 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, color);
3018 color[0] = light.ambient.r * light.multiplier;
3019 color[1] = light.ambient.g * light.multiplier;
3020 color[2] = light.ambient.b * light.multiplier;
3021 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, color);
3022 color[0] = light.specular.r * light.multiplier;
3023 color[1] = light.specular.g * light.multiplier;
3024 color[2] = light.specular.b * light.multiplier;
3025 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,color);
3029 Vector3D positionVector;
3030 if(light.flags.spot)
3032 if(lightObject.flags.root || !lightObject.parent)
3034 positionVector = lightObject.transform.position;
3035 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3039 positionVector.MultMatrix(lightObject.transform.position, lightObject.parent.matrix);
3040 if(display.display3D.camera)
3041 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3047 if(!light.direction.x && !light.direction.y && !light.direction.z)
3049 Vector3Df vector { 0,0,-1 };
3051 mat.RotationQuaternion(light.orientation);
3052 positionVector.MultMatrixf(vector, mat);
3056 positionVector = light.direction;
3061 position[0] = (float)positionVector.x;
3062 position[1] = (float)positionVector.y;
3063 position[2] = (float)positionVector.z;
3065 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3068 // Display Light Position
3069 glDisable(GL_LIGHTING);
3070 glDisable(GL_DEPTH_TEST);
3074 glVertex3fv(position);
3076 glEnable(GL_DEPTH_TEST);
3077 glEnable(GL_LIGHTING);
3081 if(lightObject.flags.root || !lightObject.parent)
3083 positionVector = light.target.transform.position;
3084 positionVector.Subtract(positionVector, display.camera.cPosition);
3088 positionVector.MultMatrix(light.target.transform.position,
3089 lightObject.light.target.parent.matrix);
3090 positionVector.Subtract(positionVector, display.camera.cPosition);
3093 position[0] = positionVector.x;
3094 position[1] = positionVector.y;
3095 position[2] = positionVector.z;
3097 glDisable(GL_LIGHTING);
3098 glDisable(GL_DEPTH_TEST);
3102 glVertex3fv(position);
3104 glEnable(GL_DEPTH_TEST);
3105 glEnable(GL_LIGHTING);
3108 if(light.flags.attenuation)
3110 glLightf(GL_LIGHT0 + id, GL_CONSTANT_ATTENUATION, light.Kc);
3111 glLightf(GL_LIGHT0 + id, GL_LINEAR_ATTENUATION, light.Kl);
3112 glLightf(GL_LIGHT0 + id, GL_QUADRATIC_ATTENUATION, light.Kq);
3115 if(light.flags.spot)
3118 #define MAXLIGHT 0.9
3119 float direction[4] = { (float)light.direction.x, (float)light.direction.y, (float)light.direction.z, 1 };
3120 // Figure out exponent out of the hot spot
3121 exponent = (float)(log(MAXLIGHT) / log(cos((light.hotSpot / 2))));
3123 glLightfv(GL_LIGHT0 + id, GL_SPOT_DIRECTION, direction);
3124 glLightf(GL_LIGHT0 + id, GL_SPOT_CUTOFF, (float)(light.fallOff / 2));
3125 glLightf(GL_LIGHT0 + id, GL_SPOT_EXPONENT, exponent);
3131 Vector3Df vector { 0,0,-1 };
3132 Vector3Df direction;
3135 mat.RotationQuaternion(light.orientation);
3136 direction.MultMatrix(vector, mat);
3138 position[0] = direction.x;
3139 position[1] = direction.y;
3140 position[2] = direction.z;
3142 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3146 glDisable(GL_LIGHT0 + id);
3149 void SetCamera(Display display, Surface surface, Camera camera)
3151 OGLDisplay oglDisplay = display.driverData;
3152 //Logf("SetCamera\n");
3156 int left = surface.box.left + surface.offset.x;
3157 int top = surface.box.top + surface.offset.y;
3158 int right = surface.box.right + surface.offset.x;
3159 int bottom = surface.box.bottom + surface.offset.y;
3160 float origX = surface.offset.x + camera.origin.x;
3161 float origY = surface.offset.y + camera.origin.y;
3163 int y = display.height - bottom - 1;
3164 int w = right - left + 1;
3165 int h = bottom - top + 1;
3168 glViewport(x, y, w, h);
3170 // *** Projection Matrix ***
3171 if(!display.display3D.camera)
3174 glMatrixMode(GL_PROJECTION);
3175 if(display.display3D.collectingHits)
3177 float pickX = display.display3D.pickX + surface.offset.x;
3178 float pickY = display.height - (display.display3D.pickY + surface.offset.y) - 1;
3182 w / display.display3D.pickWidth, 0, 0, 0,
3183 0, h / display.display3D.pickHeight, 0, 0,
3185 (w + 2.0f * (x - pickX)) / display.display3D.pickWidth,
3186 (h + 2.0f * (y - pickY)) / display.display3D.pickHeight, 0, 1
3189 glLoadMatrixd(pickMatrix.array);
3194 (left - origX) * camera.zMin / camera.focalX,
3195 (right - origX) * camera.zMin / camera.focalX,
3196 (bottom - origY) * camera.zMin / camera.focalY,
3197 (top - origY) * camera.zMin / camera.focalY,
3198 camera.zMin, camera.zMax);
3200 glDisable(GL_BLEND);
3202 // *** Z Inverted Identity Matrix ***
3203 glMatrixMode(GL_MODELVIEW);
3204 if(!display.display3D.camera)
3208 glScalef(1.0f, 1.0f, -1.0f);
3210 // *** View Matrix ***
3211 glMultMatrixd(camera.viewMatrix.array);
3216 glEnable(GL_DEPTH_TEST);
3217 glEnable(GL_LIGHTING);
3218 glShadeModel(GL_SMOOTH);
3219 glDepthMask((byte)bool::true);
3220 oglDisplay.depthWrite = true;
3222 glEnable(GL_MULTISAMPLE_ARB);
3224 else if(display.display3D.camera)
3226 oglDisplay.depthWrite = false;
3227 glViewport(0,0,display.width,display.height);
3229 glDisable(GL_CULL_FACE);
3230 glDisable(GL_DEPTH_TEST);
3231 glDisable(GL_LIGHTING);
3233 glDisable(GL_TEXTURE_2D);
3234 glShadeModel(GL_FLAT);
3236 glDisable(GL_MULTISAMPLE_ARB);
3238 // *** Restore 2D MODELVIEW Matrix ***
3241 // *** Restore 2D PROJECTION Matrix ***
3242 glMatrixMode(GL_PROJECTION);
3247 glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
3250 void ApplyMaterial(Display display, Material material, Mesh mesh)
3252 //Logf("ApplyMaterial\n");
3255 if(material.flags.doubleSided)
3257 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, !material.flags.singleSideLight);
3258 glDisable(GL_CULL_FACE);
3262 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, bool::false);
3263 glEnable(GL_CULL_FACE);
3267 if(material.flags.noFog)
3273 if(material.baseMap && mesh.texCoords)
3275 Bitmap map = material.baseMap;
3276 glEnable(GL_TEXTURE_2D);
3277 glBindTexture(GL_TEXTURE_2D, (uint)map.driverData);
3279 if(material.flags.tile)
3281 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
3282 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
3286 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
3287 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
3291 glDisable(GL_TEXTURE_2D);
3293 if(mesh.flags.colors)
3295 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
3296 glEnable(GL_COLOR_MATERIAL);
3300 glDisable(GL_COLOR_MATERIAL);
3302 float color[4] = { material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity };
3303 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
3306 float color[4] = { material.ambient.r, material.ambient.g, material.ambient.b, 0 };
3307 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
3311 float color[4] = { material.specular.r, material.specular.g, material.specular.b, 0 };
3312 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, color);
3315 float color[4] = { material.emissive.r, material.emissive.g, material.emissive.b, 0 };
3316 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, color);
3319 glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &material.power);
3322 void FreeMesh(DisplaySystem displaySystem, Mesh mesh)
3324 OGLMesh oglMesh = mesh.data;
3327 if(!mesh.flags.vertices)
3329 if(oglMesh.vertices)
3331 glDeleteBuffersARB(1, &oglMesh.vertices);
3332 oglMesh.vertices = 0;
3334 delete mesh.vertices;
3336 if(!mesh.flags.normals)
3340 glDeleteBuffersARB(1, &oglMesh.normals);
3341 oglMesh.normals = 0;
3343 delete mesh.normals;
3345 if(!mesh.flags.texCoords1)
3347 if(oglMesh.texCoords)
3349 glDeleteBuffersARB(1, &oglMesh.texCoords);
3350 oglMesh.texCoords = 0;
3352 delete mesh.texCoords;
3354 if(!mesh.flags.texCoords2)
3356 if(oglMesh.texCoords2)
3358 glDeleteBuffersARB(1, &oglMesh.texCoords2);
3359 oglMesh.texCoords2 = 0;
3362 delete mesh.texCoords2;
3365 if(!mesh.flags.colors)
3369 glDeleteBuffersARB(1, &oglMesh.colors);
3381 bool AllocateMesh(DisplaySystem displaySystem, Mesh mesh)
3383 bool result = false;
3386 mesh.data = OGLMesh { };
3389 OGLMesh oglMesh = mesh.data;
3391 if(mesh.flags.vertices && !oglMesh.vertices && !mesh.vertices)
3393 mesh.vertices = mesh.flags.doubleVertices ? (Vector3Df *)new Vector3D[mesh.nVertices] : new Vector3Df[mesh.nVertices];
3395 glGenBuffersARB(1, &oglMesh.vertices);
3397 if(mesh.flags.normals && !oglMesh.normals && !mesh.normals)
3400 glGenBuffersARB( 1, &oglMesh.normals);
3401 mesh.normals = mesh.flags.doubleNormals ? (Vector3Df *)new Vector3D[mesh.nVertices] : new Vector3Df[mesh.nVertices];
3403 if(mesh.flags.texCoords1 && !oglMesh.texCoords && !mesh.texCoords)
3406 glGenBuffersARB( 1, &oglMesh.texCoords);
3407 mesh.texCoords = new Pointf[mesh.nVertices];
3409 if(mesh.flags.colors && !oglMesh.colors && !mesh.colors)
3412 glGenBuffersARB( 1, &oglMesh.colors);
3413 mesh.colors = new ColorRGBAf[mesh.nVertices];
3420 void UnlockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
3422 OGLMesh oglMesh = mesh.data;
3423 if(!flags) flags = mesh.flags;
3427 if(!(flags.vertices) || oglMesh.vertices)
3429 glBindBufferARB( GL_ARRAY_BUFFER_ARB, oglMesh.vertices);
3430 glBufferDataARB( GL_ARRAY_BUFFER_ARB, mesh.nVertices * (mesh.flags.doubleVertices ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.vertices, GL_STATIC_DRAW_ARB );
3433 if(!(flags.normals) || oglMesh.normals)
3435 glBindBufferARB( GL_ARRAY_BUFFER_ARB, oglMesh.normals);
3436 glBufferDataARB( GL_ARRAY_BUFFER_ARB, mesh.nVertices * (mesh.flags.doubleNormals ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.normals, GL_STATIC_DRAW_ARB );
3439 if(!(flags.texCoords1) || oglMesh.texCoords)
3441 glBindBufferARB( GL_ARRAY_BUFFER_ARB, oglMesh.texCoords);
3442 glBufferDataARB( GL_ARRAY_BUFFER_ARB, mesh.nVertices * sizeof(Pointf), mesh.texCoords, GL_STATIC_DRAW_ARB );
3445 if(!(flags.colors) || oglMesh.colors)
3447 glBindBufferARB( GL_ARRAY_BUFFER_ARB, oglMesh.colors);
3448 glBufferDataARB( GL_ARRAY_BUFFER_ARB, mesh.nVertices * sizeof(ColorRGBAf), mesh.colors, GL_STATIC_DRAW_ARB );
3451 glBindBufferARB( GL_ARRAY_BUFFER_ARB, 0);
3455 bool LockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
3462 void FreeIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
3466 if(oglIndices.buffer)
3467 glDeleteBuffersARB(1, &oglIndices.buffer);
3468 delete oglIndices.indices;
3473 void * AllocateIndices(DisplaySystem displaySystem, int nIndices, bool indices32bit)
3475 OGLIndices oglIndices = OGLIndices { };
3478 oglIndices.indices = (void *)(indices32bit ? new uint32[nIndices] : new uint16[nIndices]);
3480 glGenBuffersARB( 1, &oglIndices.buffer);
3481 oglIndices.nIndices = nIndices;
3486 void UnlockIndices(DisplaySystem displaySystem, OGLIndices oglIndices, bool indices32bit, int nIndices)
3490 glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, oglIndices.buffer);
3491 glBufferDataARB( GL_ELEMENT_ARRAY_BUFFER_ARB, nIndices * (indices32bit ? sizeof(uint32) : sizeof(uint16)),
3492 oglIndices.indices, GL_STATIC_DRAW_ARB);
3493 glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
3497 uint16 * LockIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
3500 return oglIndices.indices;
3503 void SelectMesh(Display display, Mesh mesh)
3505 //Logf("SelectMesh\n");
3507 #if !defined( __ANDROID__) && !defined(__APPLE__)
3508 if(display.display3D.mesh && glUnlockArraysEXT)
3509 glUnlockArraysEXT();
3513 OGLDisplay oglDisplay = display.driverData;
3514 OGLMesh oglMesh = mesh.data;
3516 // *** Vertex Stream ***
3517 glEnableClientState(GL_VERTEX_ARRAY);
3518 if(!display.display3D.collectingHits && oglMesh)
3521 glBindBufferARB(GL_ARRAY_BUFFER_ARB, oglMesh.vertices );
3522 glVertexPointer(3, mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT, 0, glBindBufferARB ? null : mesh.vertices);
3524 // *** Normals Stream ***
3527 glEnableClientState(GL_NORMAL_ARRAY);
3529 glBindBufferARB(GL_ARRAY_BUFFER_ARB, oglMesh.normals);
3530 glNormalPointer(mesh.flags.doubleNormals ? GL_DOUBLE : GL_FLOAT, 0, glBindBufferARB ? null : mesh.normals);
3533 glDisableClientState(GL_NORMAL_ARRAY);
3535 // *** Texture Coordinates Stream ***
3538 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
3540 glBindBufferARB( GL_ARRAY_BUFFER_ARB, oglMesh.texCoords);
3541 glTexCoordPointer(2, GL_FLOAT, 0, glBindBufferARB ? null : mesh.texCoords);
3544 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
3546 // *** Color Stream ***
3549 glEnableClientState(GL_COLOR_ARRAY);
3551 glBindBufferARB( GL_ARRAY_BUFFER_ARB, oglMesh.colors);
3552 glColorPointer(4, GL_FLOAT, 0, glBindBufferARB ? null : mesh.colors);
3555 glDisableClientState(GL_COLOR_ARRAY);
3561 glBindBufferARB( GL_ARRAY_BUFFER_ARB, 0);
3562 glVertexPointer(3,mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT,0,mesh.vertices);
3563 if(mesh.normals && !display.display3D.collectingHits)
3565 glEnableClientState(GL_NORMAL_ARRAY);
3566 glNormalPointer(mesh.flags.doubleNormals ? GL_DOUBLE : GL_FLOAT, 0, mesh.normals);
3569 glDisableClientState(GL_NORMAL_ARRAY);
3570 if(mesh.texCoords && !display.display3D.collectingHits)
3572 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
3573 glTexCoordPointer(2, GL_FLOAT, 0, mesh.texCoords);
3576 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
3577 if(mesh.colors && !display.display3D.collectingHits)
3579 glEnableClientState(GL_COLOR_ARRAY);
3580 glColorPointer(4, GL_FLOAT, 0, mesh.colors);
3583 glDisableClientState(GL_COLOR_ARRAY);
3586 #if !defined(__ANDROID__) && !defined(__APPLE__)
3587 if(glLockArraysEXT) glLockArraysEXT(0, mesh.nVertices);
3590 else if(glBindBufferARB)
3591 glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
3594 void DrawPrimitives(Display display, PrimitiveSingle * primitive, Mesh mesh)
3596 OGLDisplay oglDisplay = display.driverData;
3597 //Logf("DrawPrimitives\n");
3599 if(primitive->type.vertexRange)
3600 glDrawArrays(primitiveTypes[primitive->type.primitiveType], primitive->first, primitive->nVertices);
3603 // *** Hoping the data won't be uploaded at all (Won't really work if another group of the mesh is using the mesh ) ***
3604 // HACK TO SPEED THINGS UP...
3605 if(primitive->nIndices < (mesh.nVertices >> 2) && !primitive->type.indices32bit)
3608 glBegin(primitiveTypes[primitive->type.primitiveType]);
3611 OGLIndices oglIndices = primitive->data;
3612 MeshFeatures flags = mesh.flags;
3613 for(c = 0; c<primitive->nIndices; c++)
3615 short index = ((short *) oglIndices.indices)[c];
3616 if(flags.normals) glNormal3fv((float *)&mesh.normals[index]);
3617 if(flags.texCoords1) glTexCoord2fv((float *)&mesh.texCoords[index]);
3618 if(flags.colors) glColor4fv((float *)&mesh.colors[index]);
3619 glVertex3fv((float *)&mesh.vertices[index]);
3626 OGLIndices oglIndices = primitive->data;
3628 if(!display.display3D.collectingHits && glBindBufferARB && oglIndices)
3630 glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, oglIndices.buffer);
3631 glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
3632 primitive->type.indices32bit ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT, 0);
3633 glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
3636 glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
3637 primitive->type.indices32bit ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT, oglIndices.indices);
3639 glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
3640 primitive->type.indices32bit ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT, primitive->indices);
3645 void PushMatrix(Display display)
3650 void PopMatrix(Display display, bool setMatrix)
3655 void SetTransform(Display display, Matrix transMatrix, bool viewSpace, bool useCamera)
3657 Matrix matrix = transMatrix;
3658 Camera camera = useCamera ? display.display3D.camera : null;
3663 glScalef(1.0f, 1.0f, -1.0f);
3668 matrix.m[3][0] - camera.cPosition.x,
3669 matrix.m[3][1] - camera.cPosition.y,
3670 matrix.m[3][2] - camera.cPosition.z);
3682 glMultMatrixd(matrix.array);
3687 public void UseSingleGLContext(bool useSingle)
3689 useSingleGLContext = useSingle;