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;
1046 X11Drawable glxDrawable;
1051 class OGLSurface : struct
1058 float foreground[4], background[4], bitmapMult[4];
1061 class OGLMesh : struct
1070 class OGLIndices : struct
1077 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1078 static int primitiveTypes[RenderPrimitiveType] =
1080 GL_POINTS, GL_LINES, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS, GL_QUAD_STRIP, GL_LINE_STRIP
1087 class OpenGLDisplayDriver : DisplayDriver
1089 class_property(name) = "OpenGL";
1091 bool LockSystem(DisplaySystem displaySystem)
1093 OGLSystem oglSystem = displaySystem.driverData;
1094 if(useSingleGLContext) return true;
1095 #if defined(__WIN32__)
1096 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1097 #elif defined(__unix__) || defined(__APPLE__)
1098 //if(previous) return true;
1099 // printf("Making SYSTEM current\n");
1100 #if defined(__APPLE__)
1101 glXMakeCurrent(xGlobalDisplay, oglSystem.glxDrawable, oglSystem.glContext);
1103 #if defined(__ANDROID__)
1105 glXMakeCurrent(xGlobalDisplay, oglSystem.dummyGLXPixmap /*displaySystem.window /-*DefaultRootWindow(xGlobalDisplay)*/, oglSystem.glContext);
1108 //previous = oglSystem.glContext;
1113 void UnlockSystem(DisplaySystem displaySystem)
1115 if(useSingleGLContext) return;
1116 #if defined(__WIN32__)
1117 wglMakeCurrent(null, null);
1118 #elif defined(__unix__) || defined(__APPLE__)
1119 // printf("Making NULL current\n");
1120 #if defined(__ANDROID__)
1122 glXMakeCurrent(xGlobalDisplay, None, null);
1128 bool Lock(Display display)
1130 OGLDisplay oglDisplay = display.driverData;
1131 OGLSystem oglSystem = display.displaySystem.driverData;
1133 if(useSingleGLContext) return true;
1134 #if defined(__WIN32__)
1135 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1136 #elif defined(__unix__) || defined(__APPLE__)
1137 // if(previous) glXMakeCurrent(xGlobalDisplay, None, null);
1138 // printf(" Making DISPLAY current\n");
1139 #if defined(__ANDROID__)
1141 glXMakeCurrent(xGlobalDisplay, (int)display.window, oglDisplay.glContext);
1147 void Unlock(Display display)
1149 if(useSingleGLContext) return;
1150 //printf(" Making NULL current\n");
1151 //glXMakeCurrent(xGlobalDisplay, None, null);
1153 LockSystem(display.displaySystem);
1156 void DestroyDisplay(Display display)
1158 OGLDisplay oglDisplay = display.driverData;
1162 #if defined(__WIN32__)
1163 wglMakeCurrent( null, null );
1166 wglDeleteContext(oglDisplay.glrc);
1168 if(oglDisplay.hdc && oglDisplay.pBuffer)
1169 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
1171 if(oglDisplay.pBuffer)
1172 wglDestroyPbufferARB(oglDisplay.pBuffer);
1175 ReleaseDC(display.window, oglDisplay.hdc);
1177 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
1178 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
1180 #elif defined(__unix__) || defined(__APPLE__)
1181 #if defined(__ANDROID__)
1183 if(oglDisplay.shapePixmap)
1184 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
1185 if(oglDisplay.pixmap)
1186 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1187 if(oglDisplay.image)
1189 if(oglDisplay.shminfoShape.shmid != -1)
1191 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
1192 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1193 shmdt(oglDisplay.shminfo.shmaddr);
1194 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
1197 if(oglDisplay.shapeImage)
1199 if(oglDisplay.shminfoShape.shmid != -1)
1201 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
1202 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1203 shmdt(oglDisplay.shminfoShape.shmaddr);
1204 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
1206 XDestroyImage(oglDisplay.shapeImage);
1207 oglDisplay.shapeImage = None;
1210 glXMakeCurrent(xGlobalDisplay, None, null);
1212 if(oglDisplay.glContext)
1213 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
1216 delete oglDisplay.flippingBuffer;
1218 display.driverData = null;
1222 bool CreateDisplaySystem(DisplaySystem displaySystem)
1224 bool result = false;
1225 OGLSystem oglSystem = displaySystem.driverData = OGLSystem { };
1228 oglSystem.hwnd = CreateWindow("static", null, 0,0,0,0,0,null,null,null,null);
1230 oglSystem.hdc = GetDC(oglSystem.hwnd);
1234 oglSystem.pfd.nSize = (short)sizeof(oglSystem.pfd);
1235 oglSystem.pfd.nVersion = 1;
1236 oglSystem.pfd.dwFlags = PFD_DRAW_TO_WINDOW /*PFD_DRAW_TO_BITMAP*/ | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
1237 oglSystem.pfd.iPixelType = PFD_TYPE_RGBA;
1238 oglSystem.pfd.cColorBits = 24;
1239 oglSystem.pfd.cAlphaBits = 8;
1240 oglSystem.pfd.cDepthBits = 24;
1241 oglSystem.pfd.iLayerType = PFD_MAIN_PLANE;
1243 oglSystem.format = ChoosePixelFormat(oglSystem.hdc, &oglSystem.pfd);
1244 DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1246 if(oglSystem.pfd.cColorBits > 8)
1248 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1249 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1252 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1254 // Get Pointers To The GL Functions
1255 glActiveTextureARB = (void *) wglGetProcAddress("glActiveTextureARB");
1256 glMultiTexCoord2fARB = (void *) wglGetProcAddress("glMultiTexCoord2fARB");
1257 glClientActiveTextureARB = (void *) wglGetProcAddress("glClientActiveTextureARB");
1258 glLockArraysEXT = (void *) wglGetProcAddress("glLockArraysEXT" );
1259 glUnlockArraysEXT = (void *) wglGetProcAddress("glUnlockArraysEXT");
1260 glGenBuffersARB = (void *) wglGetProcAddress("glGenBuffersARB");
1261 glBindBufferARB = (void *) wglGetProcAddress("glBindBufferARB");
1262 glBufferDataARB = (void *) wglGetProcAddress("glBufferDataARB");
1263 glMapBufferARB = (void *) wglGetProcAddress("glMapBufferARB");
1264 glUnmapBufferARB = (void *) wglGetProcAddress("glUnmapBufferARB");
1265 glDeleteBuffersARB = (void *) wglGetProcAddress("glDeleteBuffersARB");
1266 glBlendFuncSeparate = (void *) wglGetProcAddress("glBlendFuncSeparate");
1268 wglChoosePixelFormatARB = (void *) wglGetProcAddress("wglChoosePixelFormatARB");
1269 wglGetExtensionsStringARB = (void *)wglGetProcAddress("wglGetExtensionsStringARB");
1270 wglCreatePbufferARB = (void *)wglGetProcAddress("wglCreatePbufferARB");
1271 wglGetPbufferDCARB = (void *)wglGetProcAddress("wglGetPbufferDCARB");
1272 wglQueryPbufferARB = (void *)wglGetProcAddress("wglQueryPbufferARB");
1273 wglDestroyPbufferARB = (void *)wglGetProcAddress("wglDestroyPbufferARB");
1274 wglReleasePbufferDCARB = (void *)wglGetProcAddress("wglReleasePbufferDCARB");
1275 wglBindTexImageARB = (void *)wglGetProcAddress("wglBindTexImageARB");
1276 wglReleaseTexImageARB = (void *)wglGetProcAddress("wglReleaseTexImageARB");
1278 wglSwapIntervalEXT = (void *)wglGetProcAddress("wglSwapIntervalEXT");
1280 // eSystem_LoggingMode(LOG_MSGBOX, null);
1282 if(wglChoosePixelFormatARB)
1287 float fAttributes[] = {0,0};
1290 WGL_DRAW_TO_WINDOW_ARB,GL_TRUE,
1291 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1292 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
1293 WGL_COLOR_BITS_ARB,24,
1294 WGL_ALPHA_BITS_ARB,8,
1295 WGL_DEPTH_BITS_ARB,16,
1296 WGL_STENCIL_BITS_ARB,0,
1297 WGL_DOUBLE_BUFFER_ARB,GL_TRUE,
1298 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
1299 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
1303 //Log("Found wglChoosePixelFormatARB\n");
1305 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1306 if(!valid || !numFormats)
1308 //Log("Can't find 4x multi sampling\n");
1309 iAttributes[19] = 2;
1310 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1311 if(!valid || !numFormats)
1313 // Log("Can't find 2x multi sampling\n");
1314 iAttributes[16] = 0;
1315 iAttributes[17] = 0;
1316 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1319 if(valid && numFormats)
1321 oglSystem.format = pixelFormat;
1322 wglMakeCurrent(null, null);
1323 wglDeleteContext(oglSystem.glrc);
1325 // *** DescribePixelFormat does not support WGL pixel formats! ***
1326 //DescribePixelFormat(oglSystem.hdc, oglSystem.format, sizeof(oglSystem.pfd), &oglSystem.pfd);
1327 SetPixelFormat(oglSystem.hdc, oglSystem.format, &oglSystem.pfd);
1328 //Log("Successfully set pixel format\n");
1330 oglSystem.glrc = wglCreateContext(oglSystem.hdc);
1331 wglMakeCurrent(oglSystem.hdc, oglSystem.glrc);
1335 eSystem_Logf("Can't find wglChoosePixelFormatARB\n");*/
1339 wglMakeCurrent(null, null);
1341 //eSystem_DumpErrors(true);
1345 #elif defined(__unix__) || defined(__APPLE__)
1346 #if defined(__ANDROID__)
1347 egl_init_display(guiApp.desktop.windowHandle);
1351 X11Window root = RootWindow( xGlobaldisplay, DefaultScreen( xGlobaldisplay ) );
1352 XSetWindowAttributes attr;
1357 #ifndef ECERE_MINIGLX
1358 GLX_USE_GL, GLX_DEPTH_SIZE, 1,
1361 GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,
1365 oglSystem.visualInfo = glXChooseVisual( xGlobalDisplay, DefaultScreen( xGlobalDisplay ), attrList );
1366 attr.background_pixel = 0;
1367 attr.border_pixel = 0;
1368 attr.colormap = XCreateColormap( xGlobalDisplay, root, visualInfo->visual, AllocNone);
1369 attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
1370 mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
1372 oglSystem.glxDrawable = XCreateWindow( xGlboalDisplay, root, 0, 0, 1, 1, 0, visualInfo->depth, InputOutput,visualInfo->visual, mask, &attr );
1374 if(oglSystem.visualInfo)
1376 //printf("glXChooseVisual returnded a visual info\n");
1377 #if !defined(__APPLE__)
1378 oglSystem.dummyPixmap = XCreatePixmap(xGlobalDisplay, (uint)displaySystem.window, 1, 1, oglSystem.visualInfo->depth);
1379 oglSystem.dummyGLXPixmap = glXCreateGLXPixmap(xGlobalDisplay, oglSystem.visualInfo, oglSystem.dummyPixmap);
1382 oglSystem.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, null, True);
1383 // printf("Creating system Context (%x)!\n", oglSystem.glContext);
1384 if(oglSystem.glContext)
1386 //printf("Got a Context\n");
1387 #if defined(__APPLE__)
1388 glXMakeCurrent(xGlobalDisplay, oglSystem.glxDrawable, oglSystem.glContext);
1390 glXMakeCurrent(xGlobalDisplay, oglSystem.dummyGLXPixmap /*displaySystem.window /-*DefaultRootWindow(xGlobalDisplay)*/, oglSystem.glContext);
1395 glXMakeCurrent(xGlobalDisplay, None, null);
1403 displaySystem.flags.alpha = true;
1404 displaySystem.flags.flipping = true;
1405 displaySystem.pixelFormat = pixelFormat888;
1409 void DestroyDisplaySystem(DisplaySystem displaySystem)
1411 OGLSystem oglSystem = displaySystem.driverData;
1413 #if defined(__WIN32__)
1414 wglMakeCurrent( null, null );
1417 wglDeleteContext(oglSystem.glrc);
1420 ReleaseDC(oglSystem.hwnd, oglSystem.hdc);
1421 DestroyWindow(oglSystem.hwnd);
1423 #elif defined(__unix__) || defined(__APPLE__)
1424 #if defined(__ANDROID__)
1427 if(oglSystem.visualInfo)
1429 #ifdef ECERE_MINIGLX
1430 __miniglx_XFree(oglSystem.visualInfo);
1432 XFree(oglSystem.visualInfo);
1436 if(oglSystem.dummyGLXPixmap)
1437 glXDestroyGLXPixmap(xGlobalDisplay, oglSystem.dummyGLXPixmap);
1438 if(oglSystem.dummyPixmap);
1439 XFreePixmap(xGlobalDisplay, oglSystem.dummyPixmap);
1445 bool CreateDisplay(Display display)
1447 bool result = false;
1448 OGLDisplay oglDisplay = display.driverData;
1449 OGLSystem oglSystem = display.displaySystem.driverData;
1451 oglDisplay = display.driverData = OGLDisplay { };
1452 //printf("Inside CreateDisplay\n");
1454 #if defined(__WIN32__) || defined(USEPBUFFER)
1455 if(!display.alphaBlend)
1458 #if defined(__WIN32__)
1459 oglDisplay.hdc = GetDC(display.window);
1460 SetPixelFormat(oglDisplay.hdc, oglSystem.format, &oglSystem.pfd);
1461 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
1463 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
1464 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1468 ReleaseDC(display.window, oglDisplay.hdc);
1469 #elif defined(__unix__) || defined(__APPLE__)
1470 #if defined(__ANDROID__)
1472 XVisualInfo * visualInfo = null;
1476 GLX_RENDER_TYPE, GLX_RGBA_BIT,
1477 GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
1481 GLX_DOUBLEBUFFER, True,
1486 //visualInfo = glXChooseVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay), attrib);
1487 #if defined(__APPLE__)
1488 XVisualInfo template = { 0 };
1489 XWindowAttributes winAttr;
1491 XGetWindowAttributes(xGlobalDisplay, display.window, &winAttr);
1492 template.visualid = XVisualIDFromVisual(winAttr.visual);
1493 visualInfo = XGetVisualInfo(xGlobalDisplay, VisualIDMask, &template, &n);
1495 // visualInfo = oglSystem.visualInfo;
1497 visualInfo = ((XWindowData)display.windowDriverData).visual;
1501 GLXFBConfig *fbconfigs, fbconfig;
1503 fbconfigs = glXChooseFBConfig(xGlobalDisplay, DefaultScreen(xGlobalDisplay), attrib, &numfbconfigs);
1507 for (i = 0; i < numfbconfigs; i++)
1509 XRenderPictFormat * format;
1510 visualInfo = glXGetVisualFromFBConfig(xGlobalDisplay, fbconfigs[i]);
1511 if (!visualInfo) continue;
1512 format = XRenderFindVisualFormat(xGlobalDisplay, visualInfo->visual);
1513 if (!format) continue;
1515 if(format->direct.alphaMask > 0)
1517 fbconfig = fbconfigs[i];
1520 //XFree(visualInfo);
1523 if (i == numfbconfigs)
1525 fbconfig = fbconfigs[0];
1526 visualInfo = glXGetVisualFromFBConfig(xGlobalDisplay, fbconfig);
1533 //printf("visualInfo is not null\n");
1534 // printf("Creating Display Context, sharing with %x!\n", oglSystem.glContext);
1535 oglDisplay.glContext = glXCreateContext(xGlobalDisplay, visualInfo, oglSystem.glContext, True);
1536 //XFree(visualInfo);
1539 // oglDisplay.glContext = glXCreateContext(xGlobalDisplay, oglSystem.visualInfo, oglSystem.glContext, True);
1540 if(oglDisplay.glContext)
1542 //printf("CreateDisplay Got a Context\n");
1543 glXMakeCurrent(xGlobalDisplay, (int)display.window, oglDisplay.glContext);
1549 #if defined(__WIN32__) || defined(USEPBUFFER)
1555 #if !defined(__OLDX__)
1556 if(glBlendFuncSeparate)
1557 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1560 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1563 glMatrixMode(GL_MODELVIEW);
1564 glScalef(1.0f, 1.0f, -1.0f);
1565 // glTranslatef(0.375f, 0.375f, 0.0f);
1566 // glTranslatef(-0.625f, -0.625f, 0.0f);
1567 glMatrixMode(GL_PROJECTION);
1568 glShadeModel(GL_FLAT);
1570 // glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, true);
1571 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
1572 glFogi(GL_FOG_MODE, GL_EXP);
1573 glFogf(GL_FOG_DENSITY, 0);
1574 glEnable(GL_NORMALIZE);
1575 glDepthFunc(GL_LESS);
1577 glDisable(GL_MULTISAMPLE_ARB);
1579 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
1580 display.ambient = Color { 50,50,50 };
1583 if(!useSingleGLContext)
1585 #if defined(__WIN32__)
1586 wglMakeCurrent(null, null);
1587 #elif defined(__unix__) || defined(__APPLE__)
1588 #if defined(__ANDROID__)
1591 glXMakeCurrent(xGlobalDisplay, None, null);
1599 bool DisplaySize(Display display, int width, int height)
1601 OGLDisplay oglDisplay = display.driverData;
1602 OGLSystem oglSystem = display.displaySystem.driverData;
1604 bool result = false;
1606 //printf("Inside DisplaySize\n");
1607 #if defined(__WIN32__) || defined(USEPBUFFER)
1608 if(display.alphaBlend)
1610 #if defined(__WIN32__)
1611 const int attributes[]=
1613 /*WGL_TEXTURE_FORMAT_ARB, WGL_TEXTURE_RGBA_ARB,
1614 WGL_TEXTURE_TARGET_ARB, WGL_TEXTURE_2D_ARB, */0
1616 int pixelFormat = 0;
1617 if(wglChoosePixelFormatARB)
1621 float fAttributes[] = {0,0};
1624 //WGL_DRAW_TO_BITMAP_ARB, GL_TRUE,
1625 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
1626 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1627 WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
1628 WGL_COLOR_BITS_ARB,24,
1629 WGL_ALPHA_BITS_ARB,8,
1630 WGL_DEPTH_BITS_ARB,16,
1631 WGL_STENCIL_BITS_ARB,0,
1632 WGL_DOUBLE_BUFFER_ARB,GL_FALSE,
1633 WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
1634 WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
1638 //Log("Found wglChoosePixelFormatARB\n");
1640 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1641 if(!valid || !numFormats)
1643 //Log("Can't find 4x multi sampling\n");
1644 iAttributes[19] = 2;
1645 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1646 if(!valid || !numFormats)
1648 // Log("Can't find 2x multi sampling\n");
1649 iAttributes[16] = 0;
1650 iAttributes[17] = 0;
1651 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1652 if(!valid || !numFormats)
1656 WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
1657 //WGL_DRAW_TO_BITMAP_ARB,GL_TRUE,
1658 WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
1659 WGL_COLOR_BITS_ARB,24,
1660 WGL_ALPHA_BITS_ARB,8,
1661 WGL_DEPTH_BITS_ARB,16,
1664 valid = wglChoosePixelFormatARB(oglSystem.hdc,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
1668 if(valid && numFormats)
1670 wglMakeCurrent(null, null);
1674 wglMakeCurrent( null, null );
1675 wglMakeCurrent( oglDisplay.hdc, oglDisplay.glrc );
1676 if(oglDisplay.hdc && oglDisplay.pBuffer)
1677 wglReleasePbufferDCARB(oglDisplay.pBuffer, oglDisplay.hdc);
1679 wglDestroyPbufferARB(oglDisplay.pBuffer);
1681 if(!useSingleGLContext)
1682 wglMakeCurrent( null, null );
1685 wglDeleteContext(oglDisplay.glrc);
1687 oglDisplay.pBuffer = wglCreatePbufferARB(oglSystem.hdc, pixelFormat, width, height, attributes);
1688 oglDisplay.hdc = wglGetPbufferDCARB(oglDisplay.pBuffer);
1689 if((oglDisplay.glrc = wglCreateContext(oglDisplay.hdc)))
1692 HDC hdc = GetDC(display.window);
1694 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
1695 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1697 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_WIDTH_ARB, &width);
1698 //wglQueryPbufferARB(pBuffer, WGL_PBUFFER_HEIGHT_ARB, &height);
1700 // glDeleteBuffersARB(2, oglDisplay.imageBuffers);
1702 if((info = (BITMAPINFO *)new0 byte[sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*256]))
1706 if(oglDisplay.memDC) DeleteDC(oglDisplay.memDC);
1707 oglDisplay.memDC = CreateCompatibleDC(hdc);
1708 SetMapMode(oglDisplay.memDC, MM_TEXT);
1709 info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1710 info->bmiHeader.biPlanes = 1;
1711 info->bmiHeader.biCompression = BI_RGB;
1712 info->bmiHeader.biBitCount = 32; //(uint16)GetDeviceCaps(hdc, BITSPIXEL);
1713 info->bmiHeader.biWidth = width;
1714 info->bmiHeader.biHeight = height;
1715 newBitmap = CreateDIBSection(hdc, info, DIB_RGB_COLORS, &oglDisplay.picture, null, 0);
1718 SelectObject(oglDisplay.memDC, newBitmap);
1719 if(oglDisplay.memBitmap) DeleteObject(oglDisplay.memBitmap);
1722 PIXELFORMATDESCRIPTOR pfd = { 0 };
1723 pfd.nSize = (short)sizeof(pfd);
1725 pfd.dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL;
1726 pfd.iPixelType = PFD_TYPE_RGBA;
1727 pfd.cColorBits = 32;
1728 //pfd.cAlphaBits = 8;
1729 pfd.cDepthBits = 24;
1730 pfd.iLayerType = PFD_MAIN_PLANE;
1732 oglDisplay.hdc = oglDisplay.memDC;
1734 pixelFormat = ChoosePixelFormat(oglSystem.hdc, &pfd);
1735 DescribePixelFormat(oglDisplay.hdc, pixelFormat, sizeof(pfd), &pfd);
1736 SetPixelFormat(oglDisplay.hdc, pixelFormat, &pfd);
1738 oglDisplay.glrc = wglCreateContext(oglDisplay.hdc);
1739 wglShareLists(oglSystem.glrc, oglDisplay.glrc);
1740 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1745 const int imageSize = width * height * 4;
1747 glGenBuffersARB(2, oglDisplay.imageBuffers);
1749 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
1750 glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize, null, GL_STREAM_READ);
1751 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
1752 // glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, imageSize / 2, null, GL_STREAM_READ);
1755 oglDisplay.memBitmap = newBitmap;
1756 oglDisplay.stride = width;
1762 ReleaseDC(display.window, hdc);
1764 #elif defined(__unix__) || defined(__APPLE__)
1765 #if defined(__ANDROID__)
1770 GLX_DOUBLEBUFFER, True,
1776 GLX_STENCIL_SIZE, 1,
1777 //GLX_DEPTH_SIZE, 24,
1778 GLX_RENDER_TYPE, GLX_RGBA_BIT,
1779 GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT | GLX_WINDOW_BIT,
1785 GLX_PBUFFER_WIDTH, width,
1786 GLX_PBUFFER_HEIGHT, height,
1787 GLX_LARGEST_PBUFFER, False,
1791 // choose a pixel format that meets our minimum requirements
1794 GLXFBConfig *config = glXChooseFBConfig(xGlobalDisplay, DefaultScreen(xGlobalDisplay), attrib, &count);
1797 if(oglDisplay.pixmap)
1799 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1800 oglDisplay.pixmap = None;
1802 if(oglDisplay.shapePixmap)
1804 XFreePixmap(xGlobalDisplay, oglDisplay.shapePixmap);
1805 oglDisplay.shapePixmap = None;
1808 // Free Shared Memory Pixmap
1809 if(oglDisplay.image)
1811 if(oglDisplay.shminfoShape.shmid != -1)
1813 XShmDetach(xGlobalDisplay, &oglDisplay.shminfo);
1814 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1815 shmdt(oglDisplay.shminfo.shmaddr);
1816 shmctl(oglDisplay.shminfo.shmid, IPC_RMID, 0);
1818 XDestroyImage(oglDisplay.image);
1819 oglDisplay.image = None;
1821 if(oglDisplay.shapeImage)
1823 if(oglDisplay.shminfoShape.shmid != -1)
1825 XShmDetach(xGlobalDisplay, &oglDisplay.shminfoShape);
1826 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1827 shmdt(oglDisplay.shminfoShape.shmaddr);
1828 shmctl(oglDisplay.shminfoShape.shmid, IPC_RMID, 0);
1830 XDestroyImage(oglDisplay.shapeImage);
1831 oglDisplay.shapeImage = None;
1834 if(oglDisplay.windowPicture)
1835 XRenderFreePicture(xGlobalDisplay, oglDisplay.windowPicture);
1836 if(oglDisplay.pixmapPicture)
1837 XRenderFreePicture(xGlobalDisplay, oglDisplay.pixmapPicture);
1839 if(oglDisplay.pixmap)
1840 XFreePixmap(xGlobalDisplay, oglDisplay.pixmap);
1842 if(oglDisplay.glContext)
1843 glXDestroyContext(xGlobalDisplay, oglDisplay.glContext);
1844 if(oglDisplay.pBuffer)
1845 glXDestroyPbuffer(xGlobalDisplay, oglDisplay.pBuffer);
1847 oglDisplay.pBuffer = glXCreatePbuffer(xGlobalDisplay, config[0], PBattrib);
1848 if(oglDisplay.pBuffer)
1850 oglDisplay.glContext = glXCreateNewContext(xGlobalDisplay, config[0], GLX_RGBA_TYPE, oglSystem.glContext, True);
1851 if(oglDisplay.glContext)
1853 glXMakeCurrent(xGlobalDisplay, None, null);
1854 glXMakeCurrent(xGlobalDisplay, (int)display.window, oglDisplay.glContext);
1856 // Initialize Shared Memory Pixmap
1857 oglDisplay.image = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 32,
1858 ZPixmap, null, &oglDisplay.shminfo, width, height);
1859 if(oglDisplay.image)
1861 oglDisplay.shminfo.shmid = shmget(IPC_PRIVATE,
1862 oglDisplay.image->bytes_per_line * oglDisplay.image->height, IPC_CREAT|0777);
1863 if(oglDisplay.shminfo.shmid != -1)
1865 oglDisplay.shminfo.shmaddr = shmat(oglDisplay.shminfo.shmid, 0, 0);
1866 if(oglDisplay.shminfo.shmaddr != (void *)-1)
1868 oglDisplay.shminfo.readOnly = False;
1869 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfo))
1871 oglDisplay.pixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfo.shmaddr,
1872 &oglDisplay.shminfo, width, height, 32);
1874 // Initialize Shared Memory Shape Pixmap
1875 oglDisplay.shapeImage = XShmCreateImage(xGlobalDisplay, DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay)), 1,
1876 ZPixmap, null, &oglDisplay.shminfoShape, width, height);
1877 if(oglDisplay.shapeImage)
1879 oglDisplay.shminfoShape.shmid = shmget(IPC_PRIVATE,
1880 oglDisplay.shapeImage->bytes_per_line * oglDisplay.shapeImage->height, IPC_CREAT|0777);
1881 if(oglDisplay.shminfoShape.shmid != -1)
1883 oglDisplay.shminfoShape.shmaddr = shmat(oglDisplay.shminfoShape.shmid, 0, 0);
1884 if(oglDisplay.shminfoShape.shmaddr != (void *)-1)
1886 oglDisplay.shminfoShape.readOnly = False;
1887 if(XShmAttach(xGlobalDisplay, &oglDisplay.shminfoShape))
1889 oglDisplay.shapePixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, oglDisplay.shminfoShape.shmaddr,
1890 &oglDisplay.shminfoShape, width, height, 1);
1891 //oglDisplay.shapePixmap = XCreatePixmap(xGlobalDisplay, (X11Window)display.window, width, height, 1);
1894 XRenderPictureAttributes attributes = { 0 };
1895 XRenderPictFormat * format = XRenderFindStandardFormat(xGlobalDisplay, /*PictStandardRGB24*/ PictStandardARGB32);
1896 #if !defined(__APPLE__) && !defined(__OLDX__)
1897 attributes.repeat = RepeatNormal;
1899 attributes.repeat = 1;
1901 oglDisplay.pixmapPicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.pixmap, format, CPRepeat, &attributes);
1902 oglDisplay.windowPicture = XRenderCreatePicture(xGlobalDisplay, (X11Window)display.window, format, 0, &attributes);
1903 oglDisplay.shapePicture = XRenderCreatePicture(xGlobalDisplay, oglDisplay.shapePixmap,
1904 XRenderFindStandardFormat(xGlobalDisplay, PictStandardA1), 0, &attributes);
1907 oglDisplay.picture = oglDisplay.shminfo.shmaddr;
1908 oglDisplay.stride = oglDisplay.image->bytes_per_line / 4;
1925 CreateDisplay(display);
1926 #if defined(__WIN32__)
1927 wglMakeCurrent(oglDisplay.hdc, oglDisplay.glrc);
1928 #elif defined(__unix__) || defined(__APPLE__)
1929 #if defined(__ANDROID__)
1933 glXMakeCurrent(xGlobalDisplay, (int)display.window, oglDisplay.glContext);
1940 if(!result && display.alphaBlend)
1942 printf("Alpha blending windows not supported on this display\n");
1949 glViewport(0,0,width,height);
1951 glOrtho(0,width,height,0,0.0,1.0);
1952 displayWidth = display.width = width;
1953 displayHeight = display.height = height;
1955 if(!oglDisplay.flippingBuffer || oglDisplay.flipBufW < width || oglDisplay.flipBufH < height)
1957 oglDisplay.flipBufW = width;
1958 oglDisplay.flipBufH = height;
1959 oglDisplay.flippingBuffer = renew oglDisplay.flippingBuffer ColorAlpha [width * height];
1961 if(oglDisplay.flippingBuffer || !width || !height)
1967 void DisplayPosition(Display display, int x, int y)
1969 OGLDisplay oglDisplay = display.driverData;
1975 void SetPalette(Display display, ColorAlpha * palette, bool colorMatch)
1979 void RestorePalette(Display display)
1983 void StartUpdate(Display display)
1987 void EndUpdate(Display display)
1991 void Scroll(Display display, Box scroll, int x, int y, Extent dirty)
1995 void Update(Display display, Box updateBox)
1997 OGLDisplay oglDisplay = display.driverData;
1998 //Logf("DisplayScreen\n");
2002 #if defined(__WIN32__) || defined(USEPBUFFER)
2003 if(display.alphaBlend)
2005 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2006 glPixelStorei(GL_PACK_ROW_LENGTH, oglDisplay.stride);
2007 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2008 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2009 glReadPixels(0,0,display.width,display.height,GL_BGRA_EXT,GL_UNSIGNED_BYTE, oglDisplay.picture);
2012 #if defined(__WIN32__)
2014 POINT point = { oglDisplay.x, oglDisplay.y};
2015 POINT srcPoint = { 0, 0 };
2016 BLENDFUNCTION blend = { 0 };
2018 size.cx = display.width;
2019 size.cy = display.height;
2020 blend.BlendOp = AC_SRC_OVER;
2021 blend.BlendFlags = 0;
2022 blend.SourceConstantAlpha = 255;
2023 blend.AlphaFormat = AC_SRC_ALPHA;
2026 // Process partial images. Mapping the buffer waits for
2027 // outstanding DMA transfers into the buffer to finish.
2028 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2029 oglDisplay.pboMemory1 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY);
2031 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2032 // oglDisplay.pboMemory2 = (byte *)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB,GL_READ_ONLY);
2035 memcpy(oglDisplay.picture, oglDisplay.pboMemory1, display.width * display.height * 4);
2036 //memcpy(oglDisplay.picture + display.width * display.height * 4 / 2, oglDisplay.pboMemory2, display.width * display.height * 4/ 2);
2039 UpdateLayeredWindow(display.window, hdc, &point, &size, oglDisplay.memDC, &srcPoint, 0, &blend, ULW_ALPHA);
2042 // Unmap the image buffers
2043 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2044 glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2046 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2047 // glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
2049 // Bind two different buffer objects and start the glReadPixels
2050 // asynchronously. Each call will return directly after
2051 // starting the DMA transfer.
2052 glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[0]);
2053 glReadPixels(0, 0, display.width, display.height, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2055 // glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, oglDisplay.imageBuffers[1]);
2056 // glReadPixels(0, display.height/2, display.width, display.height/2, GL_BGRA, GL_UNSIGNED_BYTE, 0);
2060 #elif defined(__unix__) || defined(__APPLE__)
2061 #if defined(__ANDROID__)
2063 XTransform transform =
2066 { (int)(1.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(0 * (1 << 16)) },
2067 { (int)(0.0f), (int)(-1.0f * (1<<16)), (int)(0 * (1<<16)) },
2068 { (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)) }
2071 XRenderSetPictureTransform(xGlobalDisplay, oglDisplay.pixmapPicture, &transform);
2072 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.shapePicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2073 XRenderComposite(xGlobalDisplay, PictOpSrc, oglDisplay.pixmapPicture, None, oglDisplay.windowPicture, 0, 0, 0, 0, 0, 0, display.width, display.height);
2074 #if !defined(__APPLE__) && !defined(__OLDX__)
2075 XShapeCombineMask(xGlobalDisplay, (uint)display.window, ShapeInput, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2077 XShapeCombineMask(xGlobalDisplay, display.window, 2, 0, 0, oglDisplay.shapePixmap, ShapeSet);
2079 XFlush(xGlobalDisplay);
2087 #if defined(__WIN32__)
2088 //wglSwapLayerBuffers(oglDisplay.hdc,WGL_SWAP_MAIN_PLANE);
2089 SwapBuffers(oglDisplay.hdc);
2090 #elif defined(__unix__) || defined(__APPLE__)
2091 #if defined(__ANDROID__)
2092 eglSwapBuffers(eglDisplay, eglSurface);
2094 glXSwapBuffers(xGlobalDisplay, (int)display.window);
2098 //Logf("Out of DisplayScreen\n");
2101 void FreeBitmap(DisplaySystem displaySystem, Bitmap bitmap)
2103 glDeleteTextures(1, (int *)&bitmap.driverData);
2104 bitmap.driverData = 0;
2106 bitmap.driver = ((subclass(DisplayDriver))class(LFBDisplayDriver));
2109 bool AllocateBitmap(DisplaySystem displaySystem, Bitmap bitmap, int width, int height, int stride, PixelFormat format, bool allocatePalette)
2111 bool result = false;
2115 uint w = pow2i(Min(width, 1024)), h = pow2i(Min(height, 1024));
2116 //uint w = pow2i(Min(width, 2048)), h = pow2i(Min(height, 2048));
2117 //uint w = pow2i(Min(width, 512)), h = pow2i(Min(height, 512));
2119 glGenTextures(1, &glBitmap);
2120 glBindTexture(GL_TEXTURE_2D, glBitmap);
2122 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2124 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2125 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2127 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2128 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2130 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2132 mipMap.Allocate(null, w, h, w, pixelFormatRGBA, false);
2134 // glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2135 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2139 bitmap.driverData = (void *)glBitmap;
2140 bitmap.driver = displaySystem.driver;
2148 bool MakeDDBitmap(DisplaySystem displaySystem, Bitmap bitmap, bool mipMaps)
2150 bool result = false;
2151 OGLSystem oglSystem = displaySystem.driverData;
2153 // Pre process the bitmap... First make it 32 bit
2154 if(/*bitmap.pixelFormat == pixelFormatRGBA || */bitmap.Convert(null, pixelFormat888, null))
2157 uint w = pow2i(Min(bitmap.width, 1024)), h = pow2i(Min(bitmap.height, 1024));
2158 //uint w = pow2i(Min(bitmap.width, 512)), h = pow2i(Min(bitmap.height, 512));
2161 // Switch ARGB to RGBA
2162 //if(bitmap.format != pixelFormatRGBA)
2164 for(c=0; c<bitmap.size; c++)
2166 // ((ColorRGBA *)bitmap.picture)[c] = ((ColorAlpha *)bitmap.picture)[c];
2168 ColorAlpha color = ((ColorAlpha *)bitmap.picture)[c];
2169 ((ColorRGBA *)bitmap.picture)[c] = ColorRGBA { color.color.r, color.color.g, color.color.b, color.a };
2172 bitmap.pixelFormat = pixelFormat888;
2175 glGenTextures(1, &glBitmap);
2178 int error = glGetError();
2183 glBindTexture(GL_TEXTURE_2D, glBitmap);
2184 glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
2186 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2187 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mipMaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
2188 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2190 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
2191 //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
2193 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2194 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2196 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
2200 for(level = 0; result && (w > 1 || h > 1); level++, w >>= 1, h >>= 1)
2203 if(bitmap.width != w || bitmap.height != h)
2205 mipMap = Bitmap { };
2206 if(mipMap.Allocate(null, w, h, w, bitmap.pixelFormat, false))
2208 Surface mipSurface = mipMap.GetSurface(0,0,null);
2209 mipSurface.Filter(bitmap, 0,0,0,0, w, h, bitmap.width, bitmap.height);
2226 // glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2227 glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, mipMap.picture);
2228 //printf("Calling glTexImage2D\n");
2229 //glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &width);
2230 //printf("width = %d (Should be %d, %d)\n", width, w, h);
2231 if((error = glGetError()))
2233 //Logf("OpenGL Bitmap MakeDD error: %d...\n", error);
2234 //printf("OpenGL Bitmap MakeDD error: %d...\n", error);
2238 if(mipMap != bitmap)
2243 if(!bitmap.keepData)
2244 bitmap.driver.FreeBitmap(bitmap.displaySystem, bitmap);
2245 bitmap.driverData = (void *)glBitmap;
2246 bitmap.driver = displaySystem.driver;
2249 FreeBitmap(displaySystem, bitmap);
2250 else if(oglSystem.loadingFont)
2252 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2253 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2254 oglSystem.loadingFont = false;
2260 void ReleaseSurface(Display display, Surface surface)
2262 glDisable(GL_SCISSOR_TEST);
2263 delete surface.driverData;
2264 surface.driverData = null;
2267 bool GetBitmapSurface(DisplaySystem displaySystem, Surface surface, Bitmap bitmap, int x, int y, Box clip)
2272 bool GetSurface(Display display, Surface surface, int x,int y, Box clip)
2274 bool result = false;
2275 OGLSurface oglSurface = surface.driverData = OGLSurface { };
2277 //Logf("GetSurface\n");
2281 if(displayWidth != display.width || displayHeight != display.height)
2283 displayWidth = display.width;
2284 displayHeight = display.height;
2286 glViewport(0,0,display.width,display.height);
2288 glOrtho(0,display.width,display.height,0,0.0,1.0);
2291 surface.offset.x = x;
2292 surface.offset.y = y;
2293 surface.unclippedBox = surface.box = clip;
2294 oglSurface.bitmapMult[0] = 1;
2295 oglSurface.bitmapMult[1] = 1;
2296 oglSurface.bitmapMult[2] = 1;
2297 oglSurface.bitmapMult[3] = 1;
2299 glEnable(GL_SCISSOR_TEST);
2302 (display.height) -(y+clip.bottom)-1,
2303 clip.right-clip.left+1,
2304 clip.bottom-clip.top+1);
2310 void Clip(Display display, Surface surface, Box clip)
2319 box.Clip(surface.unclippedBox);
2323 box = surface.box = surface.unclippedBox;
2324 box.left += surface.offset.x;
2325 box.top += surface.offset.y;
2326 box.right+= surface.offset.x;
2327 box.bottom += surface.offset.y;
2330 box.left,display.height - box.bottom - 1,
2331 box.right-box.left+1, box.bottom-box.top+1);
2334 bool GrabScreen(Display display, Bitmap bitmap, int x, int y, unsigned int w, unsigned int h)
2336 bool result = false;
2337 OGLDisplay oglDisplay = display.driverData;
2338 ColorAlpha * flippingBuffer = oglDisplay.flippingBuffer;
2340 if(oglDisplay.flippingBuffer)
2342 if(bitmap.pixelFormat != pixelFormat888 || bitmap.width < w || bitmap.height < h)
2345 bitmap.Allocate(null, w,h,w, pixelFormat888, false);
2351 glPixelStorei(GL_PACK_ALIGNMENT, 4);
2352 glPixelStorei(GL_PACK_ROW_LENGTH, bitmap.stride);
2353 glPixelStorei(GL_PACK_SKIP_ROWS, 0);
2354 glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
2355 glReadPixels(x,display.height-h-y,w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, flippingBuffer);
2358 for(row = 0; row<h; row++)
2359 CopyBytesBy4(((ColorAlpha *)bitmap.picture) + row * w, ((ColorAlpha *)flippingBuffer) + (h-row-1) * w, w);
2366 void SetForeground(Display display, Surface surface, ColorAlpha color)
2368 OGLSurface oglSurface = surface.driverData;
2370 //Logf("SetForeground\n");
2372 oglSurface.foreground[0] = color.color.r/255.0f;
2373 oglSurface.foreground[1] = color.color.g/255.0f;
2374 oglSurface.foreground[2] = color.color.b/255.0f;
2375 //oglSurface.foreground[3] = 1.0f;
2376 oglSurface.foreground[3] = color.a/255.0f;
2378 //if(!oglSurface.foreground[3])printf("bug");
2381 void SetBackground(Display display, Surface surface, ColorAlpha color)
2383 OGLSurface oglSurface = surface.driverData;
2385 //Logf("SetBackground\n");
2387 oglSurface.background[0] = color.color.r/255.0f;
2388 oglSurface.background[1] = color.color.g/255.0f;
2389 oglSurface.background[2] = color.color.b/255.0f;
2390 //oglSurface.background[3] = 1.0;
2391 oglSurface.background[3] = color.a/255.0f;
2394 void SetBlitTint(Display display, Surface surface, ColorAlpha color)
2396 OGLSurface oglSurface = surface.driverData;
2398 oglSurface.bitmapMult[0] = color.color.r/255.0f;
2399 oglSurface.bitmapMult[1] = color.color.g/255.0f;
2400 oglSurface.bitmapMult[2] = color.color.b/255.0f;
2401 oglSurface.bitmapMult[3] = color.a/255.0f;
2404 ColorAlpha GetPixel(Display display, Surface surface,int x,int y)
2409 void PutPixel(Display display, Surface surface,int x,int y)
2411 OGLSurface oglSurface = surface.driverData;
2413 //Logf("PutPixel\n");
2415 glColor4fv(oglSurface.foreground);
2417 // glVertex2i(x+surface.offset.x, y+surface.offset.y);
2418 glVertex2f(x+surface.offset.x + 0.5f, y+surface.offset.y + 0.5f);
2423 void DrawLine(Display display, Surface surface, int x1, int y1, int x2, int y2)
2425 OGLSurface oglSurface = surface.driverData;
2426 if(x1 == x2) { y2++; y1--; }
2427 else if(y1 == y2) { x2++; x1--; }
2428 x1 += surface.offset.x;
2429 y1 += surface.offset.y;
2430 x2 += surface.offset.x;
2431 y2 += surface.offset.y;
2435 glColor4fv(oglSurface.foreground);
2440 glTexCoord2f(0.5f, 0);
2441 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2442 glTexCoord2f(Max(x2-x1, y2-y1) + 0.5f, 0);
2443 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2452 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2453 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2459 void Rectangle(Display display, Surface surface,int x1,int y1,int x2,int y2)
2461 OGLSurface oglSurface = surface.driverData;
2462 x1 += surface.offset.x;
2463 y1 += surface.offset.y;
2464 x2 += surface.offset.x;
2465 y2 += surface.offset.y;
2467 //Logf("Rectangle\n");
2469 glColor4fv(oglSurface.foreground);
2475 glTexCoord2f(0.5f, 0);
2476 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2477 glTexCoord2f(y2-y1 + 0.5f, 0);
2478 glVertex2f(x1 + 0.5f, y2 + 0.5f);
2480 glTexCoord2f(0.5f, 0);
2481 glVertex2f(x1 + 0.5f, y2 + 0.5f);
2482 glTexCoord2f(x2 - x1 + 0.5f, 0);
2483 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2485 glTexCoord2f(0.5f, 0);
2486 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2487 glTexCoord2f(y1 - y2 + 0.5f, 0);
2488 glVertex2f(x2 + 0.5f, y1 + 0.5f);
2490 glTexCoord2f(0.5f, 0);
2491 glVertex2f(x2 + 0.5f, y1 + 0.5f);
2492 glTexCoord2f(x1 - x2 + 0.5f, 0);
2493 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2498 glBegin(GL_LINE_LOOP);
2505 glVertex2f(x1 + 0.5f, y1 + 0.5f);
2506 glVertex2f(x1 + 0.5f, y2 + 0.5f);
2507 glVertex2f(x2 + 0.5f, y2 + 0.5f);
2508 glVertex2f(x2 + 0.5f, y1 + 0.5f);
2513 void Area(Display display, Surface surface,int x1,int y1,int x2,int y2)
2515 OGLSurface oglSurface = surface.driverData;
2518 glColor4fv(oglSurface.background);
2519 glRecti(x1+surface.offset.x, y1+surface.offset.y,
2520 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
2523 glRectf(x1+surface.offset.x, y1+surface.offset.y,
2524 x2+surface.offset.x + 1, y2+surface.offset.y + 1);
2528 void Clear(Display display, Surface surface, ClearType type)
2530 OGLDisplay oglDisplay = display.driverData;
2531 OGLSurface oglSurface = surface.driverData;
2534 if(type != depthBuffer)
2535 glClearColor(oglSurface.background[0], oglSurface.background[1], oglSurface.background[2], oglSurface.background[3]);
2536 if(type != colorBuffer && !oglDisplay.depthWrite)
2538 glDepthMask((byte)bool::true);
2540 glClear(((type != depthBuffer) ? GL_COLOR_BUFFER_BIT : 0) |
2541 ((type != colorBuffer) ? GL_DEPTH_BUFFER_BIT : 0));
2542 if(type != colorBuffer && !oglDisplay.depthWrite)
2544 glDepthMask((byte)bool::false);
2548 bool ConvertBitmap(DisplaySystem displaySystem, Bitmap bitmap, PixelFormat format, ColorAlpha * palette)
2553 void Blit(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
2555 OGLSurface oglSurface = surface.driverData;
2557 #if !defined(__OLDX__)
2558 // WHY DO WE HAVE GL_ONE HERE ?
2559 /*if(glBlendFuncSeparate && !oglSurface.writingText)
2560 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
2563 if(!oglSurface.writingText)
2565 // glTranslatef(-0.375f, -0.375f, 0.0f);
2566 glEnable(GL_TEXTURE_2D);
2567 glColor4fv(oglSurface.bitmapMult);
2569 else if(oglSurface.xOffset)
2570 glTranslatef(oglSurface.xOffset / 64.0f/*-0.375f*/, 0.0f, 0.0f);
2572 glBindTexture(GL_TEXTURE_2D, (uint)bitmap.driverData);
2577 glTexCoord2f((float)sx/ bitmap.width, (float)(sy-h)/ bitmap.height);
2578 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
2579 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy-h)/ bitmap.height);
2580 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
2581 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
2582 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
2583 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
2584 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
2589 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
2590 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
2591 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
2592 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
2593 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
2594 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
2595 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
2596 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
2599 glTexCoord2f((float)sx / bitmap.width, (float)sy/ bitmap.height);
2600 glVertex2f((float)dx+surface.offset.x, (float)dy+surface.offset.y);
2601 glTexCoord2f((float)(sx+w)/ bitmap.width, (float)sy/ bitmap.height);
2602 glVertex2f((float)dx+w+surface.offset.x, (float)dy+surface.offset.y);
2603 glTexCoord2f((float)(sx+w) / bitmap.width, (float)(sy+h)/ bitmap.height);
2604 glVertex2f((float)dx+w+surface.offset.x, (float)dy+h+surface.offset.y);
2605 glTexCoord2f((float)sx/ bitmap.width, (float)(sy+h)/ bitmap.height);
2606 glVertex2f((float)dx+surface.offset.x, (float)dy+h+surface.offset.y);
2610 if(!oglSurface.writingText)
2612 glDisable(GL_TEXTURE_2D);
2614 //glTranslatef(0.375f, 0.375f, 0.0f);
2616 else if(oglSurface.xOffset)
2617 glTranslatef(-oglSurface.xOffset / 64.0f/*+0.375f*/, 0.0f, 0.0f);
2619 #if !defined(__OLDX__)
2620 /*if(glBlendFuncSeparate && !oglSurface.writingText)
2621 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
2625 void Stretch(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
2627 OGLSurface oglSurface = surface.driverData;
2629 //glTranslatef(-0.375f, -0.375f, 0.0f);
2631 //Logf("Stretch\n");
2633 #if !defined(__OLDX__)
2634 /*if(glBlendFuncSeparate)
2635 glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
2638 glEnable(GL_TEXTURE_2D);
2639 glBindTexture(GL_TEXTURE_2D, (uint)bitmap.driverData);
2641 glColor4fv(oglSurface.bitmapMult);
2647 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
2648 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
2650 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
2651 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
2653 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
2654 glVertex2i(dx+w+surface.offset.x, dy-h+surface.offset.y);
2656 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
2657 glVertex2i(dx+surface.offset.x, dy-h+surface.offset.y);
2661 glTexCoord2f((float)(sx) / bitmap.width, (float)(sy)/ bitmap.height);
2662 glVertex2i(dx+surface.offset.x, dy+surface.offset.y);
2664 glTexCoord2f((float)(sx+sw)/ bitmap.width, (float)(sy)/ bitmap.height);
2665 glVertex2i(dx+w+surface.offset.x, dy+surface.offset.y);
2667 glTexCoord2f((float)(sx+sw) / bitmap.width, (float)(sy+sh)/ bitmap.height);
2668 glVertex2i(dx+w+surface.offset.x, dy+h+surface.offset.y);
2670 glTexCoord2f((float)(sx)/ bitmap.width, (float)(sy+sh)/ bitmap.height);
2671 glVertex2i(dx+surface.offset.x, dy+h+surface.offset.y);
2676 glDisable(GL_TEXTURE_2D);
2678 //glTranslatef(0.375f, 0.375f, 0.0f);
2679 #if !defined(__OLDX__)
2680 /*if(glBlendFuncSeparate)
2681 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);*/
2686 void Filter(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
2688 Stretch(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
2691 void StretchDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
2693 float s2dw,s2dh,d2sw,d2sh;
2694 bool flipX = false, flipY = false;
2696 //Logf("StretchDI\n");
2698 if(Sgn(w) != Sgn(sw))
2704 if(Sgn(h) != Sgn(sh))
2716 //Clip against the edges of the source
2719 dx+=(int)((0-sx) * s2dw);
2720 w-=(int)((0-sx) * s2dw);
2726 dy+=(int)((0-sy) * s2dh);
2727 h-=(int)((0-sy) * s2dh);
2732 if(sx+sw>bitmap.width-1)
2734 w-=(int)((sx+sw-(bitmap.width-1)-1)*s2dw);
2735 sw-=sx+sw-(bitmap.width-1)-1;
2737 if(sy+sh>(bitmap.height-1))
2739 h-=(int)((sy+sh-(bitmap.height-1)-1)*s2dh);
2740 sh-=sy+sh-(bitmap.height-1)-1;
2742 //Clip against the edges of the surfaceination
2743 if(dx<surface.box.left)
2746 sx+=(int)((surface.box.left-dx)*d2sw);
2747 sw-=(int)((surface.box.left-dx)*d2sw);
2748 w-=surface.box.left-dx;
2749 dx=surface.box.left;
2751 if(dy<surface.box.top)
2753 sy+=(int)((surface.box.top-dy)*d2sh);
2754 sh-=(int)((surface.box.top-dy)*d2sh);
2755 h-=surface.box.top-dy;
2758 if(dx+w>surface.box.right)
2760 //if(flip) sx+=(int)((dx+w-surface.box.right-1)*d2sw);
2761 sw-=(int)((dx+w-surface.box.right-1)*d2sw);
2762 w-=dx+w-surface.box.right-1;
2764 if(dy+h>surface.box.bottom)
2766 sh-=(int)((dy+h-surface.box.bottom-1)*d2sh);
2767 h-=dy+h-surface.box.bottom-1;
2769 if((w<=0)||(h<=0)||(sw<=0)||(sh<=0)) return;
2771 dx += surface.offset.x;
2772 dy += surface.offset.y;
2774 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
2776 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
2777 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
2778 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
2779 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
2780 glRasterPos2d(dx,dy);
2781 //glPixelZoom(flipX ? -s2dw : s2dw, flipY ? s2dh : -s2dh);
2782 glPixelZoom(s2dw, -s2dh);
2783 glDrawPixels(sw,sh,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
2784 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
2785 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
2789 void BlitDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h)
2793 //Clip against the edges of the source
2806 if(sx+w>bitmap.width-1)
2807 w-=sx+w-(bitmap.width-1)-1;
2808 if(sy+h>bitmap.height-1)
2809 h-=sy+h-(bitmap.height-1)-1;
2810 //Clip against the edges of the surfaceination
2811 if(dx<surface.box.left)
2814 sx+=surface.box.left-dx;
2815 w-=surface.box.left-dx;
2816 dx=surface.box.left;
2818 if(dy<surface.box.top)
2820 sy+=surface.box.top-dy;
2821 h-=surface.box.top-dy;
2824 if(dx+w>surface.box.right)
2826 //if(flip) sx+=dx+w-surface.box.right-1;
2827 w-=dx+w-surface.box.right-1;
2829 if(dy+h>surface.box.bottom)
2830 h-=dy+h-surface.box.bottom-1;
2834 dx += surface.offset.x;
2835 dy += surface.offset.y;
2837 if(bitmap.pixelFormat == pixelFormat888 && !bitmap.paletteShades)
2839 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
2840 glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.stride);
2841 glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx);
2842 glPixelStorei(GL_UNPACK_SKIP_ROWS, sy);
2843 glRasterPos2d(dx,dy);
2845 glDrawPixels(w,h,GL_BGRA_EXT,GL_UNSIGNED_BYTE, bitmap.picture);
2846 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
2847 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
2851 void FilterDI(Display display, Surface surface, Bitmap bitmap, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
2853 StretchDI(display, surface, bitmap, dx, dy, sx, sy, w, h, sw, sh);
2856 void UnloadFont(DisplaySystem displaySystem, Font font)
2858 ((subclass(DisplayDriver))class(LFBDisplayDriver)).UnloadFont(displaySystem, font);
2861 Font LoadFont(DisplaySystem displaySystem, char * faceName, float size, FontFlags flags)
2864 OGLSystem oglSystem = displaySystem.driverData;
2865 oglSystem.loadingFont = true;
2866 font = ((subclass(DisplayDriver))class(LFBDisplayDriver)).LoadFont(displaySystem, faceName, size, flags);
2870 void FontExtent(DisplaySystem displaySystem, Font font, char * text, int len, int * width, int * height)
2872 ((subclass(DisplayDriver))class(LFBDisplayDriver)).FontExtent(displaySystem, font, text, len, width, height);
2875 void WriteText(Display display, Surface surface, int x, int y, char * text, int len)
2877 OGLSurface oglSurface = surface.driverData;
2878 OGLSystem oglSystem = display.displaySystem.driverData;
2879 oglSystem.loadingFont = true;
2881 //glTranslatef(-0.375f, -0.375f, 0.0f);
2885 if(surface.textOpacity)
2888 FontExtent(display.displaySystem, surface.font, text, len, &w, &h);
2889 display.displaySystem.driver.Area(display, surface,x,y,x+w-1,y+h-1);
2892 oglSurface.writingText = true;
2894 glEnable(GL_TEXTURE_2D);
2895 glColor4fv(oglSurface.foreground);
2897 ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x, y, text, len);
2898 oglSurface.writingText = false;
2899 oglSystem.loadingFont = false;
2901 glDisable(GL_TEXTURE_2D);
2903 //glTranslatef(0.375f, 0.375f, 0.0f);
2906 void TextFont(Display display, Surface surface, Font font)
2908 ((subclass(DisplayDriver))class(LFBDisplayDriver)).TextFont(display, surface, font);
2911 void TextOpacity(Display display, Surface surface, bool opaque)
2913 OGLSurface oglSurface = surface.driverData;
2914 oglSurface.opaqueText = opaque;
2917 void TextExtent(Display display, Surface surface, char * text, int len, int * width, int * height)
2919 OGLSurface oglSurface = surface.driverData;
2920 OGLSystem oglSystem = display.displaySystem.driverData;
2921 oglSystem.loadingFont = true;
2922 FontExtent(display.displaySystem, oglSurface.font, text, len, width, height);
2923 oglSystem.loadingFont = false;
2926 void DrawingChar(Display display, Surface surface, char character)
2931 void LineStipple(Display display, Surface surface, uint32 stipple)
2933 //Logf("Stipple\n");
2937 #if defined(__ANDROID__)
2938 stippleEnabled = true;
2939 glesLineStipple(1, (uint16)stipple);
2941 glLineStipple(1, (uint16)stipple);
2942 glEnable(GL_LINE_STIPPLE);
2947 #if defined(__ANDROID__)
2948 stippleEnabled = false;
2949 glMatrixMode(GL_TEXTURE);
2951 glMatrixMode(GL_PROJECTION);
2952 glDisable(GL_TEXTURE_2D);
2954 glDisable(GL_LINE_STIPPLE);
2958 #if !defined(ECERE_NO3D) && !defined(ECERE_VANILLA)
2959 void SetRenderState(Display display, RenderState state, uint value)
2961 OGLDisplay oglDisplay = display.driverData;
2962 //Logf("RenderState\n");
2968 glEnable(GL_MULTISAMPLE_ARB);
2970 glDisable(GL_MULTISAMPLE_ARB);
2973 glPolygonMode(GL_FRONT_AND_BACK, ((FillModeValue)value == solid) ? GL_FILL : GL_LINE);
2976 if(value) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
2979 if(value) glDepthMask((byte)bool::true); else glDepthMask((byte)bool::false);
2980 oglDisplay.depthWrite = value;
2984 float color[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
2985 glFogfv(GL_FOG_COLOR, (float *)&color);
2989 glFogf(GL_FOG_DENSITY, *(float *)(void *)&value);
2992 if(value) glEnable(GL_BLEND); else glDisable(GL_BLEND);
2996 float ambient[4] = { ((Color)value).r/255.0f, ((Color)value).g/255.0f, ((Color)value).b/255.0f, 1.0f };
2997 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
3002 if(value) glColorMask(1,1,1,1); else glColorMask(1,1,1,0);
3007 #if defined(__WIN32__)
3008 wglSwapIntervalEXT(value ? 1 : 0);
3015 void SetLight(Display display, int id, Light light)
3017 //Logf("SetLight\n");
3021 Object lightObject = light.lightObject;
3022 float position[4] = { 0, 0, 0, 0 };
3023 float color[4] = { 0, 0, 0, 1 };
3025 glEnable(GL_LIGHT0 + id);
3027 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, (float *)&light.diffuse);
3028 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, (float *)&light.ambient);
3029 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,(float *)&light.specular);
3032 if(!light.multiplier) light.multiplier = 1.0f;
3034 color[0] = light.diffuse.r * light.multiplier;
3035 color[1] = light.diffuse.g * light.multiplier;
3036 color[2] = light.diffuse.b * light.multiplier;
3037 glLightfv(GL_LIGHT0 + id, GL_DIFFUSE, color);
3039 color[0] = light.ambient.r * light.multiplier;
3040 color[1] = light.ambient.g * light.multiplier;
3041 color[2] = light.ambient.b * light.multiplier;
3042 glLightfv(GL_LIGHT0 + id, GL_AMBIENT, color);
3043 color[0] = light.specular.r * light.multiplier;
3044 color[1] = light.specular.g * light.multiplier;
3045 color[2] = light.specular.b * light.multiplier;
3046 glLightfv(GL_LIGHT0 + id, GL_SPECULAR,color);
3050 Vector3D positionVector;
3051 if(light.flags.spot)
3053 if(lightObject.flags.root || !lightObject.parent)
3055 positionVector = lightObject.transform.position;
3056 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3060 positionVector.MultMatrix(lightObject.transform.position, lightObject.parent.matrix);
3061 if(display.display3D.camera)
3062 positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
3068 if(!light.direction.x && !light.direction.y && !light.direction.z)
3070 Vector3Df vector { 0,0,-1 };
3072 mat.RotationQuaternion(light.orientation);
3073 positionVector.MultMatrixf(vector, mat);
3077 positionVector = light.direction;
3082 position[0] = (float)positionVector.x;
3083 position[1] = (float)positionVector.y;
3084 position[2] = (float)positionVector.z;
3086 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3089 // Display Light Position
3090 glDisable(GL_LIGHTING);
3091 glDisable(GL_DEPTH_TEST);
3095 glVertex3fv(position);
3097 glEnable(GL_DEPTH_TEST);
3098 glEnable(GL_LIGHTING);
3102 if(lightObject.flags.root || !lightObject.parent)
3104 positionVector = light.target.transform.position;
3105 positionVector.Subtract(positionVector, display.camera.cPosition);
3109 positionVector.MultMatrix(light.target.transform.position,
3110 lightObject.light.target.parent.matrix);
3111 positionVector.Subtract(positionVector, display.camera.cPosition);
3114 position[0] = positionVector.x;
3115 position[1] = positionVector.y;
3116 position[2] = positionVector.z;
3118 glDisable(GL_LIGHTING);
3119 glDisable(GL_DEPTH_TEST);
3123 glVertex3fv(position);
3125 glEnable(GL_DEPTH_TEST);
3126 glEnable(GL_LIGHTING);
3129 if(light.flags.attenuation)
3131 glLightf(GL_LIGHT0 + id, GL_CONSTANT_ATTENUATION, light.Kc);
3132 glLightf(GL_LIGHT0 + id, GL_LINEAR_ATTENUATION, light.Kl);
3133 glLightf(GL_LIGHT0 + id, GL_QUADRATIC_ATTENUATION, light.Kq);
3136 if(light.flags.spot)
3139 #define MAXLIGHT 0.9
3140 float direction[4] = { (float)light.direction.x, (float)light.direction.y, (float)light.direction.z, 1 };
3141 // Figure out exponent out of the hot spot
3142 exponent = (float)(log(MAXLIGHT) / log(cos((light.hotSpot / 2))));
3144 glLightfv(GL_LIGHT0 + id, GL_SPOT_DIRECTION, direction);
3145 glLightf(GL_LIGHT0 + id, GL_SPOT_CUTOFF, (float)(light.fallOff / 2));
3146 glLightf(GL_LIGHT0 + id, GL_SPOT_EXPONENT, exponent);
3152 Vector3Df vector { 0,0,-1 };
3153 Vector3Df direction;
3156 mat.RotationQuaternion(light.orientation);
3157 direction.MultMatrix(vector, mat);
3159 position[0] = direction.x;
3160 position[1] = direction.y;
3161 position[2] = direction.z;
3163 glLightfv(GL_LIGHT0 + id, GL_POSITION, position);
3167 glDisable(GL_LIGHT0 + id);
3170 void SetCamera(Display display, Surface surface, Camera camera)
3172 OGLDisplay oglDisplay = display.driverData;
3173 //Logf("SetCamera\n");
3177 int left = surface.box.left + surface.offset.x;
3178 int top = surface.box.top + surface.offset.y;
3179 int right = surface.box.right + surface.offset.x;
3180 int bottom = surface.box.bottom + surface.offset.y;
3181 float origX = surface.offset.x + camera.origin.x;
3182 float origY = surface.offset.y + camera.origin.y;
3184 int y = display.height - bottom - 1;
3185 int w = right - left + 1;
3186 int h = bottom - top + 1;
3189 glViewport(x, y, w, h);
3191 // *** Projection Matrix ***
3192 if(!display.display3D.camera)
3195 glMatrixMode(GL_PROJECTION);
3196 if(display.display3D.collectingHits)
3198 float pickX = display.display3D.pickX + surface.offset.x;
3199 float pickY = display.height - (display.display3D.pickY + surface.offset.y) - 1;
3203 w / display.display3D.pickWidth, 0, 0, 0,
3204 0, h / display.display3D.pickHeight, 0, 0,
3206 (w + 2.0f * (x - pickX)) / display.display3D.pickWidth,
3207 (h + 2.0f * (y - pickY)) / display.display3D.pickHeight, 0, 1
3210 glLoadMatrixd(pickMatrix.array);
3215 (left - origX) * camera.zMin / camera.focalX,
3216 (right - origX) * camera.zMin / camera.focalX,
3217 (bottom - origY) * camera.zMin / camera.focalY,
3218 (top - origY) * camera.zMin / camera.focalY,
3219 camera.zMin, camera.zMax);
3221 glDisable(GL_BLEND);
3223 // *** Z Inverted Identity Matrix ***
3224 glMatrixMode(GL_MODELVIEW);
3225 if(!display.display3D.camera)
3229 glScalef(1.0f, 1.0f, -1.0f);
3231 // *** View Matrix ***
3232 glMultMatrixd(camera.viewMatrix.array);
3237 glEnable(GL_DEPTH_TEST);
3238 glEnable(GL_LIGHTING);
3239 glShadeModel(GL_SMOOTH);
3240 glDepthMask((byte)bool::true);
3241 oglDisplay.depthWrite = true;
3243 glEnable(GL_MULTISAMPLE_ARB);
3245 else if(display.display3D.camera)
3247 oglDisplay.depthWrite = false;
3248 glViewport(0,0,display.width,display.height);
3250 glDisable(GL_CULL_FACE);
3251 glDisable(GL_DEPTH_TEST);
3252 glDisable(GL_LIGHTING);
3254 glDisable(GL_TEXTURE_2D);
3255 glShadeModel(GL_FLAT);
3257 glDisable(GL_MULTISAMPLE_ARB);
3259 // *** Restore 2D MODELVIEW Matrix ***
3262 // *** Restore 2D PROJECTION Matrix ***
3263 glMatrixMode(GL_PROJECTION);
3268 glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
3271 void ApplyMaterial(Display display, Material material, Mesh mesh)
3273 //Logf("ApplyMaterial\n");
3276 if(material.flags.doubleSided)
3278 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, !material.flags.singleSideLight);
3279 glDisable(GL_CULL_FACE);
3283 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, bool::false);
3284 glEnable(GL_CULL_FACE);
3288 if(material.flags.noFog)
3294 if(material.baseMap && mesh.texCoords)
3296 Bitmap map = material.baseMap;
3297 glEnable(GL_TEXTURE_2D);
3298 glBindTexture(GL_TEXTURE_2D, (uint)map.driverData);
3300 if(material.flags.tile)
3302 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
3303 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
3307 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
3308 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
3312 glDisable(GL_TEXTURE_2D);
3314 if(mesh.flags.colors)
3316 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
3317 glEnable(GL_COLOR_MATERIAL);
3321 glDisable(GL_COLOR_MATERIAL);
3323 float color[4] = { material.diffuse.r, material.diffuse.g, material.diffuse.b, material.opacity };
3324 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
3327 float color[4] = { material.ambient.r, material.ambient.g, material.ambient.b, 0 };
3328 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
3332 float color[4] = { material.specular.r, material.specular.g, material.specular.b, 0 };
3333 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, color);
3336 float color[4] = { material.emissive.r, material.emissive.g, material.emissive.b, 0 };
3337 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, color);
3340 glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &material.power);
3343 void FreeMesh(DisplaySystem displaySystem, Mesh mesh)
3345 OGLMesh oglMesh = mesh.data;
3348 if(!mesh.flags.vertices)
3350 if(oglMesh.vertices)
3352 glDeleteBuffersARB(1, &oglMesh.vertices);
3353 oglMesh.vertices = 0;
3355 delete mesh.vertices;
3357 if(!mesh.flags.normals)
3361 glDeleteBuffersARB(1, &oglMesh.normals);
3362 oglMesh.normals = 0;
3364 delete mesh.normals;
3366 if(!mesh.flags.texCoords1)
3368 if(oglMesh.texCoords)
3370 glDeleteBuffersARB(1, &oglMesh.texCoords);
3371 oglMesh.texCoords = 0;
3373 delete mesh.texCoords;
3375 if(!mesh.flags.texCoords2)
3377 if(oglMesh.texCoords2)
3379 glDeleteBuffersARB(1, &oglMesh.texCoords2);
3380 oglMesh.texCoords2 = 0;
3383 delete mesh.texCoords2;
3386 if(!mesh.flags.colors)
3390 glDeleteBuffersARB(1, &oglMesh.colors);
3402 bool AllocateMesh(DisplaySystem displaySystem, Mesh mesh)
3404 bool result = false;
3407 mesh.data = OGLMesh { };
3410 OGLMesh oglMesh = mesh.data;
3412 if(mesh.flags.vertices && !oglMesh.vertices && !mesh.vertices)
3414 mesh.vertices = mesh.flags.doubleVertices ? (Vector3Df *)new Vector3D[mesh.nVertices] : new Vector3Df[mesh.nVertices];
3416 glGenBuffersARB(1, &oglMesh.vertices);
3418 if(mesh.flags.normals && !oglMesh.normals && !mesh.normals)
3421 glGenBuffersARB( 1, &oglMesh.normals);
3422 mesh.normals = mesh.flags.doubleNormals ? (Vector3Df *)new Vector3D[mesh.nVertices] : new Vector3Df[mesh.nVertices];
3424 if(mesh.flags.texCoords1 && !oglMesh.texCoords && !mesh.texCoords)
3427 glGenBuffersARB( 1, &oglMesh.texCoords);
3428 mesh.texCoords = new Pointf[mesh.nVertices];
3430 if(mesh.flags.colors && !oglMesh.colors && !mesh.colors)
3433 glGenBuffersARB( 1, &oglMesh.colors);
3434 mesh.colors = new ColorRGBAf[mesh.nVertices];
3441 void UnlockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
3443 OGLMesh oglMesh = mesh.data;
3444 if(!flags) flags = mesh.flags;
3448 if(!(flags.vertices) || oglMesh.vertices)
3450 glBindBufferARB( GL_ARRAY_BUFFER_ARB, oglMesh.vertices);
3451 glBufferDataARB( GL_ARRAY_BUFFER_ARB, mesh.nVertices * (mesh.flags.doubleVertices ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.vertices, GL_STATIC_DRAW_ARB );
3454 if(!(flags.normals) || oglMesh.normals)
3456 glBindBufferARB( GL_ARRAY_BUFFER_ARB, oglMesh.normals);
3457 glBufferDataARB( GL_ARRAY_BUFFER_ARB, mesh.nVertices * (mesh.flags.doubleNormals ? sizeof(Vector3D) : sizeof(Vector3Df)), mesh.normals, GL_STATIC_DRAW_ARB );
3460 if(!(flags.texCoords1) || oglMesh.texCoords)
3462 glBindBufferARB( GL_ARRAY_BUFFER_ARB, oglMesh.texCoords);
3463 glBufferDataARB( GL_ARRAY_BUFFER_ARB, mesh.nVertices * sizeof(Pointf), mesh.texCoords, GL_STATIC_DRAW_ARB );
3466 if(!(flags.colors) || oglMesh.colors)
3468 glBindBufferARB( GL_ARRAY_BUFFER_ARB, oglMesh.colors);
3469 glBufferDataARB( GL_ARRAY_BUFFER_ARB, mesh.nVertices * sizeof(ColorRGBAf), mesh.colors, GL_STATIC_DRAW_ARB );
3472 glBindBufferARB( GL_ARRAY_BUFFER_ARB, 0);
3476 bool LockMesh(DisplaySystem displaySystem, Mesh mesh, MeshFeatures flags)
3483 void FreeIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
3487 if(oglIndices.buffer)
3488 glDeleteBuffersARB(1, &oglIndices.buffer);
3489 delete oglIndices.indices;
3494 void * AllocateIndices(DisplaySystem displaySystem, int nIndices, bool indices32bit)
3496 OGLIndices oglIndices = OGLIndices { };
3499 oglIndices.indices = (void *)(indices32bit ? new uint32[nIndices] : new uint16[nIndices]);
3501 glGenBuffersARB( 1, &oglIndices.buffer);
3502 oglIndices.nIndices = nIndices;
3507 void UnlockIndices(DisplaySystem displaySystem, OGLIndices oglIndices, bool indices32bit, int nIndices)
3511 glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, oglIndices.buffer);
3512 glBufferDataARB( GL_ELEMENT_ARRAY_BUFFER_ARB, nIndices * (indices32bit ? sizeof(uint32) : sizeof(uint16)),
3513 oglIndices.indices, GL_STATIC_DRAW_ARB);
3514 glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
3518 uint16 * LockIndices(DisplaySystem displaySystem, OGLIndices oglIndices)
3521 return oglIndices.indices;
3524 void SelectMesh(Display display, Mesh mesh)
3526 //Logf("SelectMesh\n");
3528 #if !defined( __ANDROID__) && !defined(__APPLE__)
3529 if(display.display3D.mesh && glUnlockArraysEXT)
3530 glUnlockArraysEXT();
3534 OGLDisplay oglDisplay = display.driverData;
3535 OGLMesh oglMesh = mesh.data;
3537 // *** Vertex Stream ***
3538 glEnableClientState(GL_VERTEX_ARRAY);
3539 if(!display.display3D.collectingHits && oglMesh)
3542 glBindBufferARB(GL_ARRAY_BUFFER_ARB, oglMesh.vertices );
3543 glVertexPointer(3, mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT, 0, glBindBufferARB ? null : mesh.vertices);
3545 // *** Normals Stream ***
3548 glEnableClientState(GL_NORMAL_ARRAY);
3550 glBindBufferARB(GL_ARRAY_BUFFER_ARB, oglMesh.normals);
3551 glNormalPointer(mesh.flags.doubleNormals ? GL_DOUBLE : GL_FLOAT, 0, glBindBufferARB ? null : mesh.normals);
3554 glDisableClientState(GL_NORMAL_ARRAY);
3556 // *** Texture Coordinates Stream ***
3559 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
3561 glBindBufferARB( GL_ARRAY_BUFFER_ARB, oglMesh.texCoords);
3562 glTexCoordPointer(2, GL_FLOAT, 0, glBindBufferARB ? null : mesh.texCoords);
3565 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
3567 // *** Color Stream ***
3570 glEnableClientState(GL_COLOR_ARRAY);
3572 glBindBufferARB( GL_ARRAY_BUFFER_ARB, oglMesh.colors);
3573 glColorPointer(4, GL_FLOAT, 0, glBindBufferARB ? null : mesh.colors);
3576 glDisableClientState(GL_COLOR_ARRAY);
3582 glBindBufferARB( GL_ARRAY_BUFFER_ARB, 0);
3583 glVertexPointer(3,mesh.flags.doubleVertices ? GL_DOUBLE : GL_FLOAT,0,mesh.vertices);
3584 if(mesh.normals && !display.display3D.collectingHits)
3586 glEnableClientState(GL_NORMAL_ARRAY);
3587 glNormalPointer(mesh.flags.doubleNormals ? GL_DOUBLE : GL_FLOAT, 0, mesh.normals);
3590 glDisableClientState(GL_NORMAL_ARRAY);
3591 if(mesh.texCoords && !display.display3D.collectingHits)
3593 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
3594 glTexCoordPointer(2, GL_FLOAT, 0, mesh.texCoords);
3597 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
3598 if(mesh.colors && !display.display3D.collectingHits)
3600 glEnableClientState(GL_COLOR_ARRAY);
3601 glColorPointer(4, GL_FLOAT, 0, mesh.colors);
3604 glDisableClientState(GL_COLOR_ARRAY);
3607 #if !defined(__ANDROID__) && !defined(__APPLE__)
3608 if(glLockArraysEXT) glLockArraysEXT(0, mesh.nVertices);
3611 else if(glBindBufferARB)
3612 glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
3615 void DrawPrimitives(Display display, PrimitiveSingle * primitive, Mesh mesh)
3617 OGLDisplay oglDisplay = display.driverData;
3618 //Logf("DrawPrimitives\n");
3620 if(primitive->type.vertexRange)
3621 glDrawArrays(primitiveTypes[primitive->type.primitiveType], primitive->first, primitive->nVertices);
3624 // *** Hoping the data won't be uploaded at all (Won't really work if another group of the mesh is using the mesh ) ***
3625 // HACK TO SPEED THINGS UP...
3626 if(primitive->nIndices < (mesh.nVertices >> 2) && !primitive->type.indices32bit)
3629 glBegin(primitiveTypes[primitive->type.primitiveType]);
3632 OGLIndices oglIndices = primitive->data;
3633 MeshFeatures flags = mesh.flags;
3634 for(c = 0; c<primitive->nIndices; c++)
3636 short index = ((short *) oglIndices.indices)[c];
3637 if(flags.normals) glNormal3fv((float *)&mesh.normals[index]);
3638 if(flags.texCoords1) glTexCoord2fv((float *)&mesh.texCoords[index]);
3639 if(flags.colors) glColor4fv((float *)&mesh.colors[index]);
3640 glVertex3fv((float *)&mesh.vertices[index]);
3647 OGLIndices oglIndices = primitive->data;
3649 if(!display.display3D.collectingHits && glBindBufferARB && oglIndices)
3651 glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, oglIndices.buffer);
3652 glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
3653 primitive->type.indices32bit ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT, 0);
3654 glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
3657 glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
3658 primitive->type.indices32bit ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT, oglIndices.indices);
3660 glDrawElements(primitiveTypes[primitive->type.primitiveType], primitive->nIndices,
3661 primitive->type.indices32bit ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT, primitive->indices);
3666 void PushMatrix(Display display)
3671 void PopMatrix(Display display, bool setMatrix)
3676 void SetTransform(Display display, Matrix transMatrix, bool viewSpace, bool useCamera)
3678 Matrix matrix = transMatrix;
3679 Camera camera = useCamera ? display.display3D.camera : null;
3684 glScalef(1.0f, 1.0f, -1.0f);
3689 matrix.m[3][0] - camera.cPosition.x,
3690 matrix.m[3][1] - camera.cPosition.y,
3691 matrix.m[3][2] - camera.cPosition.z);
3703 glMultMatrixd(matrix.array);
3708 public void UseSingleGLContext(bool useSingle)
3710 useSingleGLContext = useSingle;