2 * This file is part of OpenTTD.
3 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
8 /** @file opengl_v.cpp OpenGL video driver support. */
10 #include "../stdafx.h"
12 /* Define to disable buffer syncing. Will increase max fast forward FPS but produces artifacts. Mainly useful for performance testing. */
13 // #define NO_GL_BUFFER_SYNC
14 /* Define to allow software rendering backends. */
15 // #define GL_ALLOW_SOFTWARE_RENDERER
21 #define GL_GLEXT_PROTOTYPES
22 #if defined(__APPLE__)
23 # define GL_SILENCE_DEPRECATION
24 # include <OpenGL/gl3.h>
28 #include "../3rdparty/opengl/glext.h"
31 #include "../core/geometry_func.hpp"
32 #include "../core/mem_func.hpp"
33 #include "../core/math_func.hpp"
34 #include "../core/mem_func.hpp"
35 #include "../gfx_func.h"
37 #include "../blitter/factory.hpp"
38 #include "../zoom_func.h"
40 #include "../table/opengl_shader.h"
41 #include "../table/sprites.h"
44 #include "../safeguards.h"
47 /* Define function pointers of all OpenGL functions that we load dynamically. */
49 #define GL(function) static decltype(&function) _ ## function
54 GL(glDebugMessageControl
);
55 GL(glDebugMessageCallback
);
84 GL(glClearBufferSubData
);
92 GL(glGenVertexArrays
);
93 GL(glDeleteVertexArrays
);
94 GL(glBindVertexArray
);
101 GL(glGetProgramInfoLog
);
108 GL(glGetShaderInfoLog
);
109 GL(glGetUniformLocation
);
115 GL(glGetAttribLocation
);
116 GL(glEnableVertexAttribArray
);
117 GL(glDisableVertexAttribArray
);
118 GL(glVertexAttribPointer
);
119 GL(glBindFragDataLocation
);
124 /** A simple 2D vertex with just position and texture. */
125 struct Simple2DVertex
{
130 /** Maximum number of cursor sprites to cache. */
131 static const int MAX_CACHED_CURSORS
= 48;
133 /* static */ OpenGLBackend
*OpenGLBackend::instance
= nullptr;
135 GetOGLProcAddressProc GetOGLProcAddress
;
138 * Find a substring in a string made of space delimited elements. The substring
139 * has to match the complete element, partial matches don't count.
140 * @param string List of space delimited elements.
141 * @param substring Substring to find.
142 * @return Pointer to the start of the match or nullptr if the substring is not present.
144 const char *FindStringInExtensionList(const char *string
, const char *substring
)
147 /* Is the extension string present at all? */
148 const char *pos
= strstr(string
, substring
);
149 if (pos
== nullptr) break;
151 /* Is this a real match, i.e. are the chars before and after the matched string
152 * indeed spaces (or the start or end of the string, respectively)? */
153 const char *end
= pos
+ strlen(substring
);
154 if ((pos
== string
|| pos
[-1] == ' ') && (*end
== ' ' || *end
== '\0')) return pos
;
156 /* False hit, try again for the remaining string. */
164 * Check if an OpenGL extension is supported by the current context.
165 * @param extension The extension string to test.
166 * @return True if the extension is supported, false if not.
168 static bool IsOpenGLExtensionSupported(const char *extension
)
170 static PFNGLGETSTRINGIPROC glGetStringi
= nullptr;
171 static bool glGetStringi_loaded
= false;
173 /* Starting with OpenGL 3.0 the preferred API to get the extensions
174 * has changed. Try to load the required function once. */
175 if (!glGetStringi_loaded
) {
176 if (IsOpenGLVersionAtLeast(3, 0)) glGetStringi
= (PFNGLGETSTRINGIPROC
)GetOGLProcAddress("glGetStringi");
177 glGetStringi_loaded
= true;
180 if (glGetStringi
!= nullptr) {
181 /* New style: Each supported extension can be queried and compared independently. */
183 _glGetIntegerv(GL_NUM_EXTENSIONS
, &num_exts
);
185 for (GLint i
= 0; i
< num_exts
; i
++) {
186 const char *entry
= (const char *)glGetStringi(GL_EXTENSIONS
, i
);
187 if (strcmp(entry
, extension
) == 0) return true;
190 /* Old style: A single, space-delimited string for all extensions. */
191 return FindStringInExtensionList((const char *)_glGetString(GL_EXTENSIONS
), extension
) != nullptr;
197 static byte _gl_major_ver
= 0; ///< Major OpenGL version.
198 static byte _gl_minor_ver
= 0; ///< Minor OpenGL version.
201 * Check if the current OpenGL version is equal or higher than a given one.
202 * @param major Minimal major version.
203 * @param minor Minimal minor version.
204 * @pre OpenGL was initialized.
205 * @return True if the OpenGL version is equal or higher than the requested one.
207 bool IsOpenGLVersionAtLeast(byte major
, byte minor
)
209 return (_gl_major_ver
> major
) || (_gl_major_ver
== major
&& _gl_minor_ver
>= minor
);
213 * Try loading an OpenGL function.
214 * @tparam F Type of the function pointer.
215 * @param f Reference where to store the function pointer in.
216 * @param name Name of the function.
217 * @return True if the function could be bound.
219 template <typename F
>
220 static bool BindGLProc(F
&f
, const char *name
)
222 f
= reinterpret_cast<F
>(GetOGLProcAddress(name
));
226 /** Bind basic information functions. */
227 static bool BindBasicInfoProcs()
229 if (!BindGLProc(_glGetString
, "glGetString")) return false;
230 if (!BindGLProc(_glGetIntegerv
, "glGetIntegerv")) return false;
231 if (!BindGLProc(_glGetError
, "glGetError")) return false;
236 /** Bind OpenGL 1.0 and 1.1 functions. */
237 static bool BindBasicOpenGLProcs()
239 if (!BindGLProc(_glDisable
, "glDisable")) return false;
240 if (!BindGLProc(_glEnable
, "glEnable")) return false;
241 if (!BindGLProc(_glViewport
, "glViewport")) return false;
242 if (!BindGLProc(_glTexImage1D
, "glTexImage1D")) return false;
243 if (!BindGLProc(_glTexImage2D
, "glTexImage2D")) return false;
244 if (!BindGLProc(_glTexParameteri
, "glTexParameteri")) return false;
245 if (!BindGLProc(_glTexSubImage1D
, "glTexSubImage1D")) return false;
246 if (!BindGLProc(_glTexSubImage2D
, "glTexSubImage2D")) return false;
247 if (!BindGLProc(_glBindTexture
, "glBindTexture")) return false;
248 if (!BindGLProc(_glDeleteTextures
, "glDeleteTextures")) return false;
249 if (!BindGLProc(_glGenTextures
, "glGenTextures")) return false;
250 if (!BindGLProc(_glPixelStorei
, "glPixelStorei")) return false;
251 if (!BindGLProc(_glClear
, "glClear")) return false;
252 if (!BindGLProc(_glClearColor
, "glClearColor")) return false;
253 if (!BindGLProc(_glBlendFunc
, "glBlendFunc")) return false;
254 if (!BindGLProc(_glDrawArrays
, "glDrawArrays")) return false;
259 /** Bind texture-related extension functions. */
260 static bool BindTextureExtensions()
262 if (IsOpenGLVersionAtLeast(1, 3)) {
263 if (!BindGLProc(_glActiveTexture
, "glActiveTexture")) return false;
265 if (!BindGLProc(_glActiveTexture
, "glActiveTextureARB")) return false;
271 /** Bind vertex buffer object extension functions. */
272 static bool BindVBOExtension()
274 if (IsOpenGLVersionAtLeast(1, 5)) {
275 if (!BindGLProc(_glGenBuffers
, "glGenBuffers")) return false;
276 if (!BindGLProc(_glDeleteBuffers
, "glDeleteBuffers")) return false;
277 if (!BindGLProc(_glBindBuffer
, "glBindBuffer")) return false;
278 if (!BindGLProc(_glBufferData
, "glBufferData")) return false;
279 if (!BindGLProc(_glBufferSubData
, "glBufferSubData")) return false;
280 if (!BindGLProc(_glMapBuffer
, "glMapBuffer")) return false;
281 if (!BindGLProc(_glUnmapBuffer
, "glUnmapBuffer")) return false;
283 if (!BindGLProc(_glGenBuffers
, "glGenBuffersARB")) return false;
284 if (!BindGLProc(_glDeleteBuffers
, "glDeleteBuffersARB")) return false;
285 if (!BindGLProc(_glBindBuffer
, "glBindBufferARB")) return false;
286 if (!BindGLProc(_glBufferData
, "glBufferDataARB")) return false;
287 if (!BindGLProc(_glBufferSubData
, "glBufferSubDataARB")) return false;
288 if (!BindGLProc(_glMapBuffer
, "glMapBufferARB")) return false;
289 if (!BindGLProc(_glUnmapBuffer
, "glUnmapBufferARB")) return false;
292 if (IsOpenGLVersionAtLeast(4, 3) || IsOpenGLExtensionSupported("GL_ARB_clear_buffer_object")) {
293 BindGLProc(_glClearBufferSubData
, "glClearBufferSubData");
295 _glClearBufferSubData
= nullptr;
301 /** Bind vertex array object extension functions. */
302 static bool BindVBAExtension()
304 /* The APPLE and ARB variants have different semantics (that don't matter for us).
305 * Successfully getting pointers to one variant doesn't mean it is supported for
306 * the current context. Always check the extension strings as well. */
307 if (IsOpenGLVersionAtLeast(3, 0) || IsOpenGLExtensionSupported("GL_ARB_vertex_array_object")) {
308 if (!BindGLProc(_glGenVertexArrays
, "glGenVertexArrays")) return false;
309 if (!BindGLProc(_glDeleteVertexArrays
, "glDeleteVertexArrays")) return false;
310 if (!BindGLProc(_glBindVertexArray
, "glBindVertexArray")) return false;
311 } else if (IsOpenGLExtensionSupported("GL_APPLE_vertex_array_object")) {
312 if (!BindGLProc(_glGenVertexArrays
, "glGenVertexArraysAPPLE")) return false;
313 if (!BindGLProc(_glDeleteVertexArrays
, "glDeleteVertexArraysAPPLE")) return false;
314 if (!BindGLProc(_glBindVertexArray
, "glBindVertexArrayAPPLE")) return false;
320 /** Bind extension functions for shader support. */
321 static bool BindShaderExtensions()
323 if (IsOpenGLVersionAtLeast(2, 0)) {
324 if (!BindGLProc(_glCreateProgram
, "glCreateProgram")) return false;
325 if (!BindGLProc(_glDeleteProgram
, "glDeleteProgram")) return false;
326 if (!BindGLProc(_glLinkProgram
, "glLinkProgram")) return false;
327 if (!BindGLProc(_glUseProgram
, "glUseProgram")) return false;
328 if (!BindGLProc(_glGetProgramiv
, "glGetProgramiv")) return false;
329 if (!BindGLProc(_glGetProgramInfoLog
, "glGetProgramInfoLog")) return false;
330 if (!BindGLProc(_glCreateShader
, "glCreateShader")) return false;
331 if (!BindGLProc(_glDeleteShader
, "glDeleteShader")) return false;
332 if (!BindGLProc(_glShaderSource
, "glShaderSource")) return false;
333 if (!BindGLProc(_glCompileShader
, "glCompileShader")) return false;
334 if (!BindGLProc(_glAttachShader
, "glAttachShader")) return false;
335 if (!BindGLProc(_glGetShaderiv
, "glGetShaderiv")) return false;
336 if (!BindGLProc(_glGetShaderInfoLog
, "glGetShaderInfoLog")) return false;
337 if (!BindGLProc(_glGetUniformLocation
, "glGetUniformLocation")) return false;
338 if (!BindGLProc(_glUniform1i
, "glUniform1i")) return false;
339 if (!BindGLProc(_glUniform1f
, "glUniform1f")) return false;
340 if (!BindGLProc(_glUniform2f
, "glUniform2f")) return false;
341 if (!BindGLProc(_glUniform4f
, "glUniform4f")) return false;
343 if (!BindGLProc(_glGetAttribLocation
, "glGetAttribLocation")) return false;
344 if (!BindGLProc(_glEnableVertexAttribArray
, "glEnableVertexAttribArray")) return false;
345 if (!BindGLProc(_glDisableVertexAttribArray
, "glDisableVertexAttribArray")) return false;
346 if (!BindGLProc(_glVertexAttribPointer
, "glVertexAttribPointer")) return false;
348 /* In the ARB extension programs and shaders are in the same object space. */
349 if (!BindGLProc(_glCreateProgram
, "glCreateProgramObjectARB")) return false;
350 if (!BindGLProc(_glDeleteProgram
, "glDeleteObjectARB")) return false;
351 if (!BindGLProc(_glLinkProgram
, "glLinkProgramARB")) return false;
352 if (!BindGLProc(_glUseProgram
, "glUseProgramObjectARB")) return false;
353 if (!BindGLProc(_glGetProgramiv
, "glGetObjectParameterivARB")) return false;
354 if (!BindGLProc(_glGetProgramInfoLog
, "glGetInfoLogARB")) return false;
355 if (!BindGLProc(_glCreateShader
, "glCreateShaderObjectARB")) return false;
356 if (!BindGLProc(_glDeleteShader
, "glDeleteObjectARB")) return false;
357 if (!BindGLProc(_glShaderSource
, "glShaderSourceARB")) return false;
358 if (!BindGLProc(_glCompileShader
, "glCompileShaderARB")) return false;
359 if (!BindGLProc(_glAttachShader
, "glAttachObjectARB")) return false;
360 if (!BindGLProc(_glGetShaderiv
, "glGetObjectParameterivARB")) return false;
361 if (!BindGLProc(_glGetShaderInfoLog
, "glGetInfoLogARB")) return false;
362 if (!BindGLProc(_glGetUniformLocation
, "glGetUniformLocationARB")) return false;
363 if (!BindGLProc(_glUniform1i
, "glUniform1iARB")) return false;
364 if (!BindGLProc(_glUniform1f
, "glUniform1fARB")) return false;
365 if (!BindGLProc(_glUniform2f
, "glUniform2fARB")) return false;
366 if (!BindGLProc(_glUniform4f
, "glUniform4fARB")) return false;
368 if (!BindGLProc(_glGetAttribLocation
, "glGetAttribLocationARB")) return false;
369 if (!BindGLProc(_glEnableVertexAttribArray
, "glEnableVertexAttribArrayARB")) return false;
370 if (!BindGLProc(_glDisableVertexAttribArray
, "glDisableVertexAttribArrayARB")) return false;
371 if (!BindGLProc(_glVertexAttribPointer
, "glVertexAttribPointerARB")) return false;
374 /* Bind functions only needed when using GLSL 1.50 shaders. */
375 if (IsOpenGLVersionAtLeast(3, 0)) {
376 BindGLProc(_glBindFragDataLocation
, "glBindFragDataLocation");
377 } else if (IsOpenGLExtensionSupported("GL_EXT_gpu_shader4")) {
378 BindGLProc(_glBindFragDataLocation
, "glBindFragDataLocationEXT");
380 _glBindFragDataLocation
= nullptr;
386 /** Bind extension functions for persistent buffer mapping. */
387 static bool BindPersistentBufferExtensions()
389 /* Optional functions for persistent buffer mapping. */
390 if (IsOpenGLVersionAtLeast(3, 0)) {
391 if (!BindGLProc(_glMapBufferRange
, "glMapBufferRange")) return false;
393 if (IsOpenGLVersionAtLeast(4, 4) || IsOpenGLExtensionSupported("GL_ARB_buffer_storage")) {
394 if (!BindGLProc(_glBufferStorage
, "glBufferStorage")) return false;
396 #ifndef NO_GL_BUFFER_SYNC
397 if (IsOpenGLVersionAtLeast(3, 2) || IsOpenGLExtensionSupported("GL_ARB_sync")) {
398 if (!BindGLProc(_glClientWaitSync
, "glClientWaitSync")) return false;
399 if (!BindGLProc(_glFenceSync
, "glFenceSync")) return false;
400 if (!BindGLProc(_glDeleteSync
, "glDeleteSync")) return false;
407 /** Callback to receive OpenGL debug messages. */
408 void APIENTRY
DebugOutputCallback([[maybe_unused
]] GLenum source
, GLenum type
, [[maybe_unused
]] GLuint id
, GLenum severity
, [[maybe_unused
]] GLsizei length
, const GLchar
*message
, [[maybe_unused
]] const void *userParam
)
410 /* Make severity human readable. */
411 const char *severity_str
= "";
413 case GL_DEBUG_SEVERITY_HIGH
: severity_str
= "high"; break;
414 case GL_DEBUG_SEVERITY_MEDIUM
: severity_str
= "medium"; break;
415 case GL_DEBUG_SEVERITY_LOW
: severity_str
= "low"; break;
418 /* Make type human readable.*/
419 const char *type_str
= "Other";
421 case GL_DEBUG_TYPE_ERROR
: type_str
= "Error"; break;
422 case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR
: type_str
= "Deprecated"; break;
423 case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR
: type_str
= "Undefined behaviour"; break;
424 case GL_DEBUG_TYPE_PERFORMANCE
: type_str
= "Performance"; break;
425 case GL_DEBUG_TYPE_PORTABILITY
: type_str
= "Portability"; break;
428 Debug(driver
, 6, "OpenGL: {} ({}) - {}", type_str
, severity_str
, message
);
431 /** Enable OpenGL debug messages if supported. */
432 void SetupDebugOutput()
434 #ifndef NO_DEBUG_MESSAGES
435 if (_debug_driver_level
< 6) return;
437 if (IsOpenGLVersionAtLeast(4, 3)) {
438 BindGLProc(_glDebugMessageControl
, "glDebugMessageControl");
439 BindGLProc(_glDebugMessageCallback
, "glDebugMessageCallback");
440 } else if (IsOpenGLExtensionSupported("GL_ARB_debug_output")) {
441 BindGLProc(_glDebugMessageControl
, "glDebugMessageControlARB");
442 BindGLProc(_glDebugMessageCallback
, "glDebugMessageCallbackARB");
445 if (_glDebugMessageControl
!= nullptr && _glDebugMessageCallback
!= nullptr) {
446 /* Enable debug output. As synchronous debug output costs performance, we only enable it with a high debug level. */
447 _glEnable(GL_DEBUG_OUTPUT
);
448 if (_debug_driver_level
>= 8) _glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS
);
450 _glDebugMessageCallback(&DebugOutputCallback
, nullptr);
451 /* Enable all messages on highest debug level.*/
452 _glDebugMessageControl(GL_DONT_CARE
, GL_DONT_CARE
, GL_DONT_CARE
, 0, nullptr, _debug_driver_level
>= 9 ? GL_TRUE
: GL_FALSE
);
453 /* Get debug messages for errors and undefined/deprecated behaviour. */
454 _glDebugMessageControl(GL_DONT_CARE
, GL_DEBUG_TYPE_ERROR
, GL_DONT_CARE
, 0, nullptr, GL_TRUE
);
455 _glDebugMessageControl(GL_DONT_CARE
, GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR
, GL_DONT_CARE
, 0, nullptr, GL_TRUE
);
456 _glDebugMessageControl(GL_DONT_CARE
, GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR
, GL_DONT_CARE
, 0, nullptr, GL_TRUE
);
462 * Create and initialize the singleton back-end class.
463 * @param get_proc Callback to get an OpenGL function from the OS driver.
464 * @param screen_res Current display resolution.
465 * @return nullptr on success, error message otherwise.
467 /* static */ const char *OpenGLBackend::Create(GetOGLProcAddressProc get_proc
, const Dimension
&screen_res
)
469 if (OpenGLBackend::instance
!= nullptr) OpenGLBackend::Destroy();
471 GetOGLProcAddress
= get_proc
;
473 OpenGLBackend::instance
= new OpenGLBackend();
474 return OpenGLBackend::instance
->Init(screen_res
);
478 * Free resources and destroy singleton back-end class.
480 /* static */ void OpenGLBackend::Destroy()
482 delete OpenGLBackend::instance
;
483 OpenGLBackend::instance
= nullptr;
487 * Construct OpenGL back-end class.
489 OpenGLBackend::OpenGLBackend() : cursor_cache(MAX_CACHED_CURSORS
)
494 * Free allocated resources.
496 OpenGLBackend::~OpenGLBackend()
498 if (_glDeleteProgram
!= nullptr) {
499 _glDeleteProgram(this->remap_program
);
500 _glDeleteProgram(this->vid_program
);
501 _glDeleteProgram(this->pal_program
);
502 _glDeleteProgram(this->sprite_program
);
504 if (_glDeleteVertexArrays
!= nullptr) _glDeleteVertexArrays(1, &this->vao_quad
);
505 if (_glDeleteBuffers
!= nullptr) {
506 _glDeleteBuffers(1, &this->vbo_quad
);
507 _glDeleteBuffers(1, &this->vid_pbo
);
508 _glDeleteBuffers(1, &this->anim_pbo
);
510 if (_glDeleteTextures
!= nullptr) {
511 this->InternalClearCursorCache();
512 OpenGLSprite::Destroy();
514 _glDeleteTextures(1, &this->vid_texture
);
515 _glDeleteTextures(1, &this->anim_texture
);
516 _glDeleteTextures(1, &this->pal_texture
);
521 * Check for the needed OpenGL functionality and allocate all resources.
522 * @param screen_res Current display resolution.
523 * @return Error string or nullptr if successful.
525 const char *OpenGLBackend::Init(const Dimension
&screen_res
)
527 if (!BindBasicInfoProcs()) return "OpenGL not supported";
529 /* Always query the supported OpenGL version as the current context might have changed. */
530 const char *ver
= (const char *)_glGetString(GL_VERSION
);
531 const char *vend
= (const char *)_glGetString(GL_VENDOR
);
532 const char *renderer
= (const char *)_glGetString(GL_RENDERER
);
534 if (ver
== nullptr || vend
== nullptr || renderer
== nullptr) return "OpenGL not supported";
536 Debug(driver
, 1, "OpenGL driver: {} - {} ({})", vend
, renderer
, ver
);
538 #ifndef GL_ALLOW_SOFTWARE_RENDERER
539 /* Don't use MESA software rendering backends as they are slower than
540 * just using a non-OpenGL video driver. */
541 if (strncmp(renderer
, "llvmpipe", 8) == 0 || strncmp(renderer
, "softpipe", 8) == 0) return "Software renderer detected, not using OpenGL";
544 const char *minor
= strchr(ver
, '.');
545 _gl_major_ver
= atoi(ver
);
546 _gl_minor_ver
= minor
!= nullptr ? atoi(minor
+ 1) : 0;
549 /* Old drivers on Windows (especially if made by Intel) seem to be
550 * unstable, so cull the oldest stuff here. */
551 if (!IsOpenGLVersionAtLeast(3, 2)) return "Need at least OpenGL version 3.2 on Windows";
554 if (!BindBasicOpenGLProcs()) return "Failed to bind basic OpenGL functions.";
558 /* OpenGL 1.3 is the absolute minimum. */
559 if (!IsOpenGLVersionAtLeast(1, 3)) return "OpenGL version >= 1.3 required";
560 /* Check for non-power-of-two texture support. */
561 if (!IsOpenGLVersionAtLeast(2, 0) && !IsOpenGLExtensionSupported("GL_ARB_texture_non_power_of_two")) return "Non-power-of-two textures not supported";
562 /* Check for single element texture formats. */
563 if (!IsOpenGLVersionAtLeast(3, 0) && !IsOpenGLExtensionSupported("GL_ARB_texture_rg")) return "Single element texture formats not supported";
564 if (!BindTextureExtensions()) return "Failed to bind texture extension functions";
565 /* Check for vertex buffer objects. */
566 if (!IsOpenGLVersionAtLeast(1, 5) && !IsOpenGLExtensionSupported("ARB_vertex_buffer_object")) return "Vertex buffer objects not supported";
567 if (!BindVBOExtension()) return "Failed to bind VBO extension functions";
568 /* Check for pixel buffer objects. */
569 if (!IsOpenGLVersionAtLeast(2, 1) && !IsOpenGLExtensionSupported("GL_ARB_pixel_buffer_object")) return "Pixel buffer objects not supported";
570 /* Check for vertex array objects. */
571 if (!IsOpenGLVersionAtLeast(3, 0) && (!IsOpenGLExtensionSupported("GL_ARB_vertex_array_object") || !IsOpenGLExtensionSupported("GL_APPLE_vertex_array_object"))) return "Vertex array objects not supported";
572 if (!BindVBAExtension()) return "Failed to bind VBA extension functions";
573 /* Check for shader objects. */
574 if (!IsOpenGLVersionAtLeast(2, 0) && (!IsOpenGLExtensionSupported("GL_ARB_shader_objects") || !IsOpenGLExtensionSupported("GL_ARB_fragment_shader") || !IsOpenGLExtensionSupported("GL_ARB_vertex_shader"))) return "No shader support";
575 if (!BindShaderExtensions()) return "Failed to bind shader extension functions";
576 if (IsOpenGLVersionAtLeast(3, 2) && _glBindFragDataLocation
== nullptr) return "OpenGL claims to support version 3.2 but doesn't have glBindFragDataLocation";
578 this->persistent_mapping_supported
= IsOpenGLVersionAtLeast(3, 0) && (IsOpenGLVersionAtLeast(4, 4) || IsOpenGLExtensionSupported("GL_ARB_buffer_storage"));
579 #ifndef NO_GL_BUFFER_SYNC
580 this->persistent_mapping_supported
= this->persistent_mapping_supported
&& (IsOpenGLVersionAtLeast(3, 2) || IsOpenGLExtensionSupported("GL_ARB_sync"));
583 if (this->persistent_mapping_supported
&& !BindPersistentBufferExtensions()) {
584 Debug(driver
, 1, "OpenGL claims to support persistent buffer mapping but doesn't export all functions, not using persistent mapping.");
585 this->persistent_mapping_supported
= false;
587 if (this->persistent_mapping_supported
) Debug(driver
, 3, "OpenGL: Using persistent buffer mapping");
589 /* Check maximum texture size against screen resolution. */
590 GLint max_tex_size
= 0;
591 _glGetIntegerv(GL_MAX_TEXTURE_SIZE
, &max_tex_size
);
592 if (std::max(screen_res
.width
, screen_res
.height
) > (uint
)max_tex_size
) return "Max supported texture size is too small";
594 /* Check available texture units. */
595 GLint max_tex_units
= 0;
596 _glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS
, &max_tex_units
);
597 if (max_tex_units
< 4) return "Not enough simultaneous textures supported";
599 Debug(driver
, 2, "OpenGL shading language version: {}, texture units = {}", (const char *)_glGetString(GL_SHADING_LANGUAGE_VERSION
), (int)max_tex_units
);
601 if (!this->InitShaders()) return "Failed to initialize shaders";
603 /* Setup video buffer texture. */
604 _glGenTextures(1, &this->vid_texture
);
605 _glBindTexture(GL_TEXTURE_2D
, this->vid_texture
);
606 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
607 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
608 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAX_LEVEL
, 0);
609 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_S
, GL_CLAMP_TO_EDGE
);
610 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_T
, GL_CLAMP_TO_EDGE
);
611 _glBindTexture(GL_TEXTURE_2D
, 0);
612 if (_glGetError() != GL_NO_ERROR
) return "Can't generate video buffer texture";
614 /* Setup video buffer texture. */
615 _glGenTextures(1, &this->anim_texture
);
616 _glBindTexture(GL_TEXTURE_2D
, this->anim_texture
);
617 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
618 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
619 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAX_LEVEL
, 0);
620 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_S
, GL_CLAMP_TO_EDGE
);
621 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_T
, GL_CLAMP_TO_EDGE
);
622 _glBindTexture(GL_TEXTURE_2D
, 0);
623 if (_glGetError() != GL_NO_ERROR
) return "Can't generate animation buffer texture";
625 /* Setup palette texture. */
626 _glGenTextures(1, &this->pal_texture
);
627 _glBindTexture(GL_TEXTURE_1D
, this->pal_texture
);
628 _glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
629 _glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
630 _glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_MAX_LEVEL
, 0);
631 _glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_WRAP_S
, GL_CLAMP_TO_EDGE
);
632 _glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_WRAP_T
, GL_CLAMP_TO_EDGE
);
633 _glTexImage1D(GL_TEXTURE_1D
, 0, GL_RGBA8
, 256, 0, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, nullptr);
634 _glBindTexture(GL_TEXTURE_1D
, 0);
635 if (_glGetError() != GL_NO_ERROR
) return "Can't generate palette lookup texture";
637 /* Bind uniforms in rendering shader program. */
638 GLint tex_location
= _glGetUniformLocation(this->vid_program
, "colour_tex");
639 GLint palette_location
= _glGetUniformLocation(this->vid_program
, "palette");
640 GLint sprite_location
= _glGetUniformLocation(this->vid_program
, "sprite");
641 GLint screen_location
= _glGetUniformLocation(this->vid_program
, "screen");
642 _glUseProgram(this->vid_program
);
643 _glUniform1i(tex_location
, 0); // Texture unit 0.
644 _glUniform1i(palette_location
, 1); // Texture unit 1.
645 /* Values that result in no transform. */
646 _glUniform4f(sprite_location
, 0.0f
, 0.0f
, 1.0f
, 1.0f
);
647 _glUniform2f(screen_location
, 1.0f
, 1.0f
);
649 /* Bind uniforms in palette rendering shader program. */
650 tex_location
= _glGetUniformLocation(this->pal_program
, "colour_tex");
651 palette_location
= _glGetUniformLocation(this->pal_program
, "palette");
652 sprite_location
= _glGetUniformLocation(this->pal_program
, "sprite");
653 screen_location
= _glGetUniformLocation(this->pal_program
, "screen");
654 _glUseProgram(this->pal_program
);
655 _glUniform1i(tex_location
, 0); // Texture unit 0.
656 _glUniform1i(palette_location
, 1); // Texture unit 1.
657 _glUniform4f(sprite_location
, 0.0f
, 0.0f
, 1.0f
, 1.0f
);
658 _glUniform2f(screen_location
, 1.0f
, 1.0f
);
660 /* Bind uniforms in remap shader program. */
661 tex_location
= _glGetUniformLocation(this->remap_program
, "colour_tex");
662 palette_location
= _glGetUniformLocation(this->remap_program
, "palette");
663 GLint remap_location
= _glGetUniformLocation(this->remap_program
, "remap_tex");
664 this->remap_sprite_loc
= _glGetUniformLocation(this->remap_program
, "sprite");
665 this->remap_screen_loc
= _glGetUniformLocation(this->remap_program
, "screen");
666 this->remap_zoom_loc
= _glGetUniformLocation(this->remap_program
, "zoom");
667 this->remap_rgb_loc
= _glGetUniformLocation(this->remap_program
, "rgb");
668 _glUseProgram(this->remap_program
);
669 _glUniform1i(tex_location
, 0); // Texture unit 0.
670 _glUniform1i(palette_location
, 1); // Texture unit 1.
671 _glUniform1i(remap_location
, 2); // Texture unit 2.
673 /* Bind uniforms in sprite shader program. */
674 tex_location
= _glGetUniformLocation(this->sprite_program
, "colour_tex");
675 palette_location
= _glGetUniformLocation(this->sprite_program
, "palette");
676 remap_location
= _glGetUniformLocation(this->sprite_program
, "remap_tex");
677 GLint pal_location
= _glGetUniformLocation(this->sprite_program
, "pal");
678 this->sprite_sprite_loc
= _glGetUniformLocation(this->sprite_program
, "sprite");
679 this->sprite_screen_loc
= _glGetUniformLocation(this->sprite_program
, "screen");
680 this->sprite_zoom_loc
= _glGetUniformLocation(this->sprite_program
, "zoom");
681 this->sprite_rgb_loc
= _glGetUniformLocation(this->sprite_program
, "rgb");
682 this->sprite_crash_loc
= _glGetUniformLocation(this->sprite_program
, "crash");
683 _glUseProgram(this->sprite_program
);
684 _glUniform1i(tex_location
, 0); // Texture unit 0.
685 _glUniform1i(palette_location
, 1); // Texture unit 1.
686 _glUniform1i(remap_location
, 2); // Texture unit 2.
687 _glUniform1i(pal_location
, 3); // Texture unit 3.
688 (void)_glGetError(); // Clear errors.
690 /* Create pixel buffer object as video buffer storage. */
691 _glGenBuffers(1, &this->vid_pbo
);
692 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, this->vid_pbo
);
693 _glGenBuffers(1, &this->anim_pbo
);
694 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, this->anim_pbo
);
695 if (_glGetError() != GL_NO_ERROR
) return "Can't allocate pixel buffer for video buffer";
697 /* Prime vertex buffer with a full-screen quad and store
698 * the corresponding state in a vertex array object. */
699 static const Simple2DVertex vert_array
[] = {
701 { 1.f
, -1.f
, 1.f
, 1.f
},
702 { 1.f
, 1.f
, 1.f
, 0.f
},
703 { -1.f
, -1.f
, 0.f
, 1.f
},
704 { -1.f
, 1.f
, 0.f
, 0.f
},
708 _glGenVertexArrays(1, &this->vao_quad
);
709 _glBindVertexArray(this->vao_quad
);
711 /* Create and fill VBO. */
712 _glGenBuffers(1, &this->vbo_quad
);
713 _glBindBuffer(GL_ARRAY_BUFFER
, this->vbo_quad
);
714 _glBufferData(GL_ARRAY_BUFFER
, sizeof(vert_array
), vert_array
, GL_STATIC_DRAW
);
715 if (_glGetError() != GL_NO_ERROR
) return "Can't generate VBO for fullscreen quad";
717 /* Set vertex state. */
718 GLint loc_position
= _glGetAttribLocation(this->vid_program
, "position");
719 GLint colour_position
= _glGetAttribLocation(this->vid_program
, "colour_uv");
720 _glEnableVertexAttribArray(loc_position
);
721 _glEnableVertexAttribArray(colour_position
);
722 _glVertexAttribPointer(loc_position
, 2, GL_FLOAT
, GL_FALSE
, sizeof(Simple2DVertex
), (GLvoid
*)offsetof(Simple2DVertex
, x
));
723 _glVertexAttribPointer(colour_position
, 2, GL_FLOAT
, GL_FALSE
, sizeof(Simple2DVertex
), (GLvoid
*)offsetof(Simple2DVertex
, u
));
724 _glBindVertexArray(0);
726 /* Create resources for sprite rendering. */
727 if (!OpenGLSprite::Create()) return "Failed to create sprite rendering resources";
729 this->PrepareContext();
730 (void)_glGetError(); // Clear errors.
735 void OpenGLBackend::PrepareContext()
737 _glClearColor(0.0f
, 0.0f
, 0.0f
, 1.0f
);
738 _glDisable(GL_DEPTH_TEST
);
739 /* Enable alpha blending using the src alpha factor. */
741 _glBlendFunc(GL_SRC_ALPHA
, GL_ONE_MINUS_SRC_ALPHA
);
744 std::string
OpenGLBackend::GetDriverName()
747 /* Skipping GL_VENDOR as it tends to be "obvious" from the renderer and version data, and just makes the string pointlessly longer */
748 res
+= reinterpret_cast<const char *>(_glGetString(GL_RENDERER
));
750 res
+= reinterpret_cast<const char *>(_glGetString(GL_VERSION
));
755 * Check a shader for compilation errors and log them if necessary.
756 * @param shader Shader to check.
757 * @return True if the shader is valid.
759 static bool VerifyShader(GLuint shader
)
761 static ReusableBuffer
<char> log_buf
;
763 GLint result
= GL_FALSE
;
764 _glGetShaderiv(shader
, GL_COMPILE_STATUS
, &result
);
766 /* Output log if there is one. */
768 _glGetShaderiv(shader
, GL_INFO_LOG_LENGTH
, &log_len
);
770 _glGetShaderInfoLog(shader
, log_len
, nullptr, log_buf
.Allocate(log_len
));
771 Debug(driver
, result
!= GL_TRUE
? 0 : 2, "{}", log_buf
.GetBuffer()); // Always print on failure.
774 return result
== GL_TRUE
;
778 * Check a program for link errors and log them if necessary.
779 * @param program Program to check.
780 * @return True if the program is valid.
782 static bool VerifyProgram(GLuint program
)
784 static ReusableBuffer
<char> log_buf
;
786 GLint result
= GL_FALSE
;
787 _glGetProgramiv(program
, GL_LINK_STATUS
, &result
);
789 /* Output log if there is one. */
791 _glGetProgramiv(program
, GL_INFO_LOG_LENGTH
, &log_len
);
793 _glGetProgramInfoLog(program
, log_len
, nullptr, log_buf
.Allocate(log_len
));
794 Debug(driver
, result
!= GL_TRUE
? 0 : 2, "{}", log_buf
.GetBuffer()); // Always print on failure.
797 return result
== GL_TRUE
;
801 * Create all needed shader programs.
802 * @return True if successful, false otherwise.
804 bool OpenGLBackend::InitShaders()
806 const char *ver
= (const char *)_glGetString(GL_SHADING_LANGUAGE_VERSION
);
807 if (ver
== nullptr) return false;
809 int glsl_major
= ver
[0] - '0';
810 int glsl_minor
= ver
[2] - '0';
812 bool glsl_150
= (IsOpenGLVersionAtLeast(3, 2) || glsl_major
> 1 || (glsl_major
== 1 && glsl_minor
>= 5)) && _glBindFragDataLocation
!= nullptr;
814 /* Create vertex shader. */
815 GLuint vert_shader
= _glCreateShader(GL_VERTEX_SHADER
);
816 _glShaderSource(vert_shader
, glsl_150
? lengthof(_vertex_shader_sprite_150
) : lengthof(_vertex_shader_sprite
), glsl_150
? _vertex_shader_sprite_150
: _vertex_shader_sprite
, nullptr);
817 _glCompileShader(vert_shader
);
818 if (!VerifyShader(vert_shader
)) return false;
820 /* Create fragment shader for plain RGBA. */
821 GLuint frag_shader_rgb
= _glCreateShader(GL_FRAGMENT_SHADER
);
822 _glShaderSource(frag_shader_rgb
, glsl_150
? lengthof(_frag_shader_direct_150
) : lengthof(_frag_shader_direct
), glsl_150
? _frag_shader_direct_150
: _frag_shader_direct
, nullptr);
823 _glCompileShader(frag_shader_rgb
);
824 if (!VerifyShader(frag_shader_rgb
)) return false;
826 /* Create fragment shader for paletted only. */
827 GLuint frag_shader_pal
= _glCreateShader(GL_FRAGMENT_SHADER
);
828 _glShaderSource(frag_shader_pal
, glsl_150
? lengthof(_frag_shader_palette_150
) : lengthof(_frag_shader_palette
), glsl_150
? _frag_shader_palette_150
: _frag_shader_palette
, nullptr);
829 _glCompileShader(frag_shader_pal
);
830 if (!VerifyShader(frag_shader_pal
)) return false;
832 /* Sprite remap fragment shader. */
833 GLuint remap_shader
= _glCreateShader(GL_FRAGMENT_SHADER
);
834 _glShaderSource(remap_shader
, glsl_150
? lengthof(_frag_shader_rgb_mask_blend_150
) : lengthof(_frag_shader_rgb_mask_blend
), glsl_150
? _frag_shader_rgb_mask_blend_150
: _frag_shader_rgb_mask_blend
, nullptr);
835 _glCompileShader(remap_shader
);
836 if (!VerifyShader(remap_shader
)) return false;
838 /* Sprite fragment shader. */
839 GLuint sprite_shader
= _glCreateShader(GL_FRAGMENT_SHADER
);
840 _glShaderSource(sprite_shader
, glsl_150
? lengthof(_frag_shader_sprite_blend_150
) : lengthof(_frag_shader_sprite_blend
), glsl_150
? _frag_shader_sprite_blend_150
: _frag_shader_sprite_blend
, nullptr);
841 _glCompileShader(sprite_shader
);
842 if (!VerifyShader(sprite_shader
)) return false;
844 /* Link shaders to program. */
845 this->vid_program
= _glCreateProgram();
846 _glAttachShader(this->vid_program
, vert_shader
);
847 _glAttachShader(this->vid_program
, frag_shader_rgb
);
849 this->pal_program
= _glCreateProgram();
850 _glAttachShader(this->pal_program
, vert_shader
);
851 _glAttachShader(this->pal_program
, frag_shader_pal
);
853 this->remap_program
= _glCreateProgram();
854 _glAttachShader(this->remap_program
, vert_shader
);
855 _glAttachShader(this->remap_program
, remap_shader
);
857 this->sprite_program
= _glCreateProgram();
858 _glAttachShader(this->sprite_program
, vert_shader
);
859 _glAttachShader(this->sprite_program
, sprite_shader
);
862 /* Bind fragment shader outputs. */
863 _glBindFragDataLocation(this->vid_program
, 0, "colour");
864 _glBindFragDataLocation(this->pal_program
, 0, "colour");
865 _glBindFragDataLocation(this->remap_program
, 0, "colour");
866 _glBindFragDataLocation(this->sprite_program
, 0, "colour");
869 _glLinkProgram(this->vid_program
);
870 if (!VerifyProgram(this->vid_program
)) return false;
872 _glLinkProgram(this->pal_program
);
873 if (!VerifyProgram(this->pal_program
)) return false;
875 _glLinkProgram(this->remap_program
);
876 if (!VerifyProgram(this->remap_program
)) return false;
878 _glLinkProgram(this->sprite_program
);
879 if (!VerifyProgram(this->sprite_program
)) return false;
881 _glDeleteShader(vert_shader
);
882 _glDeleteShader(frag_shader_rgb
);
883 _glDeleteShader(frag_shader_pal
);
884 _glDeleteShader(remap_shader
);
885 _glDeleteShader(sprite_shader
);
891 * Clear the bound pixel buffer to a specific value.
892 * @param len Length of the buffer.
893 * @param data Value to set.
894 * @tparam T Pixel type.
897 static void ClearPixelBuffer(size_t len
, T data
)
899 T
*buf
= reinterpret_cast<T
*>(_glMapBuffer(GL_PIXEL_UNPACK_BUFFER
, GL_READ_WRITE
));
900 for (size_t i
= 0; i
< len
; i
++) {
903 _glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER
);
907 * Change the size of the drawing window and allocate matching resources.
908 * @param w New width of the window.
909 * @param h New height of the window.
910 * @param force Recreate resources even if size didn't change.
911 * @param False if nothing had to be done, true otherwise.
913 bool OpenGLBackend::Resize(int w
, int h
, bool force
)
915 if (!force
&& _screen
.width
== w
&& _screen
.height
== h
) return false;
917 int bpp
= BlitterFactory::GetCurrentBlitter()->GetScreenDepth();
918 int pitch
= Align(w
, 4);
919 size_t line_pixel_count
= static_cast<size_t>(pitch
) * h
;
921 _glViewport(0, 0, w
, h
);
923 _glPixelStorei(GL_UNPACK_ROW_LENGTH
, pitch
);
925 this->vid_buffer
= nullptr;
926 if (this->persistent_mapping_supported
) {
927 _glDeleteBuffers(1, &this->vid_pbo
);
928 _glGenBuffers(1, &this->vid_pbo
);
929 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, this->vid_pbo
);
930 _glBufferStorage(GL_PIXEL_UNPACK_BUFFER
, line_pixel_count
* bpp
/ 8, nullptr, GL_MAP_READ_BIT
| GL_MAP_WRITE_BIT
| GL_MAP_PERSISTENT_BIT
| GL_MAP_COHERENT_BIT
| GL_CLIENT_STORAGE_BIT
);
932 /* Re-allocate video buffer texture and backing store. */
933 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, this->vid_pbo
);
934 _glBufferData(GL_PIXEL_UNPACK_BUFFER
, line_pixel_count
* bpp
/ 8, nullptr, GL_DYNAMIC_DRAW
);
938 /* Initialize backing store alpha to opaque for 32bpp modes. */
939 Colour
black(0, 0, 0);
940 if (_glClearBufferSubData
!= nullptr) {
941 _glClearBufferSubData(GL_PIXEL_UNPACK_BUFFER
, GL_RGBA8
, 0, line_pixel_count
* bpp
/ 8, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, &black
.data
);
943 ClearPixelBuffer
<uint32_t>(line_pixel_count
, black
.data
);
945 } else if (bpp
== 8) {
946 if (_glClearBufferSubData
!= nullptr) {
948 _glClearBufferSubData(GL_PIXEL_UNPACK_BUFFER
, GL_R8
, 0, line_pixel_count
, GL_RED
, GL_UNSIGNED_BYTE
, &b
);
950 ClearPixelBuffer
<byte
>(line_pixel_count
, 0);
954 _glActiveTexture(GL_TEXTURE0
);
955 _glBindTexture(GL_TEXTURE_2D
, this->vid_texture
);
957 _glTexImage2D(GL_TEXTURE_2D
, 0, GL_R8
, w
, h
, 0, GL_RED
, GL_UNSIGNED_BYTE
, nullptr);
959 _glTexImage2D(GL_TEXTURE_2D
, 0, GL_RGBA8
, w
, h
, 0, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, nullptr);
961 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, 0);
963 /* Does this blitter need a separate animation buffer? */
964 if (BlitterFactory::GetCurrentBlitter()->NeedsAnimationBuffer()) {
965 this->anim_buffer
= nullptr;
966 if (this->persistent_mapping_supported
) {
967 _glDeleteBuffers(1, &this->anim_pbo
);
968 _glGenBuffers(1, &this->anim_pbo
);
969 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, this->anim_pbo
);
970 _glBufferStorage(GL_PIXEL_UNPACK_BUFFER
, line_pixel_count
, nullptr, GL_MAP_READ_BIT
| GL_MAP_WRITE_BIT
| GL_MAP_PERSISTENT_BIT
| GL_MAP_COHERENT_BIT
| GL_CLIENT_STORAGE_BIT
);
972 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, this->anim_pbo
);
973 _glBufferData(GL_PIXEL_UNPACK_BUFFER
, line_pixel_count
, nullptr, GL_DYNAMIC_DRAW
);
976 /* Initialize buffer as 0 == no remap. */
977 if (_glClearBufferSubData
!= nullptr) {
979 _glClearBufferSubData(GL_PIXEL_UNPACK_BUFFER
, GL_R8
, 0, line_pixel_count
, GL_RED
, GL_UNSIGNED_BYTE
, &b
);
981 ClearPixelBuffer
<byte
>(line_pixel_count
, 0);
984 _glBindTexture(GL_TEXTURE_2D
, this->anim_texture
);
985 _glTexImage2D(GL_TEXTURE_2D
, 0, GL_R8
, w
, h
, 0, GL_RED
, GL_UNSIGNED_BYTE
, nullptr);
986 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, 0);
988 if (this->anim_buffer
!= nullptr) {
989 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, this->anim_pbo
);
990 _glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER
);
991 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, 0);
992 this->anim_buffer
= nullptr;
995 /* Allocate dummy texture that always reads as 0 == no remap. */
997 _glPixelStorei(GL_UNPACK_ROW_LENGTH
, 0);
998 _glBindTexture(GL_TEXTURE_2D
, this->anim_texture
);
999 _glTexImage2D(GL_TEXTURE_2D
, 0, GL_R8
, 1, 1, 0, GL_RED
, GL_UNSIGNED_BYTE
, &dummy
);
1002 _glBindTexture(GL_TEXTURE_2D
, 0);
1004 /* Set new viewport. */
1007 _screen
.pitch
= pitch
;
1008 _screen
.dst_ptr
= nullptr;
1010 /* Update screen size in remap shader program. */
1011 _glUseProgram(this->remap_program
);
1012 _glUniform2f(this->remap_screen_loc
, (float)_screen
.width
, (float)_screen
.height
);
1014 _glClear(GL_COLOR_BUFFER_BIT
);
1020 * Update the stored palette.
1021 * @param pal Palette array with at least 256 elements.
1022 * @param first First entry to update.
1023 * @param length Number of entries to update.
1025 void OpenGLBackend::UpdatePalette(const Colour
*pal
, uint first
, uint length
)
1027 assert(first
+ length
<= 256);
1029 _glPixelStorei(GL_UNPACK_ROW_LENGTH
, 0);
1030 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, 0);
1031 _glActiveTexture(GL_TEXTURE1
);
1032 _glBindTexture(GL_TEXTURE_1D
, this->pal_texture
);
1033 _glTexSubImage1D(GL_TEXTURE_1D
, 0, first
, length
, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, pal
+ first
);
1037 * Render video buffer to the screen.
1039 void OpenGLBackend::Paint()
1041 _glClear(GL_COLOR_BUFFER_BIT
);
1043 _glDisable(GL_BLEND
);
1045 /* Blit video buffer to screen. */
1046 _glActiveTexture(GL_TEXTURE0
);
1047 _glBindTexture(GL_TEXTURE_2D
, this->vid_texture
);
1048 _glActiveTexture(GL_TEXTURE1
);
1049 _glBindTexture(GL_TEXTURE_1D
, this->pal_texture
);
1050 /* Is the blitter relying on a separate animation buffer? */
1051 if (BlitterFactory::GetCurrentBlitter()->NeedsAnimationBuffer()) {
1052 _glActiveTexture(GL_TEXTURE2
);
1053 _glBindTexture(GL_TEXTURE_2D
, this->anim_texture
);
1054 _glUseProgram(this->remap_program
);
1055 _glUniform4f(this->remap_sprite_loc
, 0.0f
, 0.0f
, 1.0f
, 1.0f
);
1056 _glUniform2f(this->remap_screen_loc
, 1.0f
, 1.0f
);
1057 _glUniform1f(this->remap_zoom_loc
, 0);
1058 _glUniform1i(this->remap_rgb_loc
, 1);
1060 _glUseProgram(BlitterFactory::GetCurrentBlitter()->GetScreenDepth() == 8 ? this->pal_program
: this->vid_program
);
1062 _glBindVertexArray(this->vao_quad
);
1063 _glDrawArrays(GL_TRIANGLE_STRIP
, 0, 4);
1065 _glEnable(GL_BLEND
);
1069 * Draw mouse cursor on screen.
1071 void OpenGLBackend::DrawMouseCursor()
1073 if (!this->cursor_in_window
) return;
1075 /* Draw cursor on screen */
1076 _cur_dpi
= &_screen
;
1077 for (uint i
= 0; i
< this->cursor_sprite_count
; ++i
) {
1078 SpriteID sprite
= this->cursor_sprite_seq
[i
].sprite
;
1080 /* Sprites are cached by PopulateCursorCache(). */
1081 if (this->cursor_cache
.Contains(sprite
)) {
1082 Sprite
*spr
= this->cursor_cache
.Get(sprite
);
1084 this->RenderOglSprite((OpenGLSprite
*)spr
->data
, this->cursor_sprite_seq
[i
].pal
,
1085 this->cursor_pos
.x
+ this->cursor_sprite_pos
[i
].x
+ UnScaleByZoom(spr
->x_offs
, ZOOM_LVL_GUI
),
1086 this->cursor_pos
.y
+ this->cursor_sprite_pos
[i
].y
+ UnScaleByZoom(spr
->y_offs
, ZOOM_LVL_GUI
),
1092 void OpenGLBackend::PopulateCursorCache()
1094 static_assert(lengthof(_cursor
.sprite_seq
) == lengthof(this->cursor_sprite_seq
));
1095 static_assert(lengthof(_cursor
.sprite_pos
) == lengthof(this->cursor_sprite_pos
));
1097 if (this->clear_cursor_cache
) {
1098 /* We have a pending cursor cache clear to do first. */
1099 this->clear_cursor_cache
= false;
1100 this->last_sprite_pal
= (PaletteID
)-1;
1102 this->InternalClearCursorCache();
1105 this->cursor_pos
= _cursor
.pos
;
1106 this->cursor_sprite_count
= _cursor
.sprite_count
;
1107 this->cursor_in_window
= _cursor
.in_window
;
1109 for (uint i
= 0; i
< _cursor
.sprite_count
; ++i
) {
1110 this->cursor_sprite_seq
[i
] = _cursor
.sprite_seq
[i
];
1111 this->cursor_sprite_pos
[i
] = _cursor
.sprite_pos
[i
];
1112 SpriteID sprite
= _cursor
.sprite_seq
[i
].sprite
;
1114 if (!this->cursor_cache
.Contains(sprite
)) {
1115 Sprite
*old
= this->cursor_cache
.Insert(sprite
, (Sprite
*)GetRawSprite(sprite
, SpriteType::Normal
, &SimpleSpriteAlloc
, this));
1116 if (old
!= nullptr) {
1117 OpenGLSprite
*gl_sprite
= (OpenGLSprite
*)old
->data
;
1118 gl_sprite
->~OpenGLSprite();
1126 * Clear all cached cursor sprites.
1128 void OpenGLBackend::InternalClearCursorCache()
1131 while ((sp
= this->cursor_cache
.Pop()) != nullptr) {
1132 OpenGLSprite
*sprite
= (OpenGLSprite
*)sp
->data
;
1133 sprite
->~OpenGLSprite();
1139 * Queue a request for cursor cache clear.
1141 void OpenGLBackend::ClearCursorCache()
1143 /* If the game loop is threaded, this function might be called
1144 * from the game thread. As we can call OpenGL functions only
1145 * on the main thread, just set a flag that is handled the next
1146 * time we prepare the cursor cache for drawing. */
1147 this->clear_cursor_cache
= true;
1151 * Get a pointer to the memory for the video driver to draw to.
1152 * @return Pointer to draw on.
1154 void *OpenGLBackend::GetVideoBuffer()
1156 #ifndef NO_GL_BUFFER_SYNC
1157 if (this->sync_vid_mapping
!= nullptr) _glClientWaitSync(this->sync_vid_mapping
, GL_SYNC_FLUSH_COMMANDS_BIT
, 100000000); // 100ms timeout.
1160 if (!this->persistent_mapping_supported
) {
1161 assert(this->vid_buffer
== nullptr);
1162 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, this->vid_pbo
);
1163 this->vid_buffer
= _glMapBuffer(GL_PIXEL_UNPACK_BUFFER
, GL_READ_WRITE
);
1164 } else if (this->vid_buffer
== nullptr) {
1165 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, this->vid_pbo
);
1166 this->vid_buffer
= _glMapBufferRange(GL_PIXEL_UNPACK_BUFFER
, 0, _screen
.pitch
* _screen
.height
* BlitterFactory::GetCurrentBlitter()->GetScreenDepth() / 8, GL_MAP_READ_BIT
| GL_MAP_WRITE_BIT
| GL_MAP_PERSISTENT_BIT
| GL_MAP_COHERENT_BIT
);
1169 return this->vid_buffer
;
1173 * Get a pointer to the memory for the separate animation buffer.
1174 * @return Pointer to draw on.
1176 uint8_t *OpenGLBackend::GetAnimBuffer()
1178 if (this->anim_pbo
== 0) return nullptr;
1180 #ifndef NO_GL_BUFFER_SYNC
1181 if (this->sync_anim_mapping
!= nullptr) _glClientWaitSync(this->sync_anim_mapping
, GL_SYNC_FLUSH_COMMANDS_BIT
, 100000000); // 100ms timeout.
1184 if (!this->persistent_mapping_supported
) {
1185 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, this->anim_pbo
);
1186 this->anim_buffer
= _glMapBuffer(GL_PIXEL_UNPACK_BUFFER
, GL_READ_WRITE
);
1187 } else if (this->anim_buffer
== nullptr) {
1188 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, this->anim_pbo
);
1189 this->anim_buffer
= _glMapBufferRange(GL_PIXEL_UNPACK_BUFFER
, 0, static_cast<GLsizeiptr
>(_screen
.pitch
) * _screen
.height
, GL_MAP_READ_BIT
| GL_MAP_WRITE_BIT
| GL_MAP_PERSISTENT_BIT
| GL_MAP_COHERENT_BIT
);
1192 return (uint8_t *)this->anim_buffer
;
1196 * Update video buffer texture after the video buffer was filled.
1197 * @param update_rect Rectangle encompassing the dirty region of the video buffer.
1199 void OpenGLBackend::ReleaseVideoBuffer(const Rect
&update_rect
)
1201 assert(this->vid_pbo
!= 0);
1203 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, this->vid_pbo
);
1204 if (!this->persistent_mapping_supported
) {
1205 _glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER
);
1206 this->vid_buffer
= nullptr;
1209 #ifndef NO_GL_BUFFER_SYNC
1210 if (this->persistent_mapping_supported
) {
1211 _glDeleteSync(this->sync_vid_mapping
);
1212 this->sync_vid_mapping
= nullptr;
1216 /* Update changed rect of the video buffer texture. */
1217 if (!IsEmptyRect(update_rect
)) {
1218 _glActiveTexture(GL_TEXTURE0
);
1219 _glBindTexture(GL_TEXTURE_2D
, this->vid_texture
);
1220 _glPixelStorei(GL_UNPACK_ROW_LENGTH
, _screen
.pitch
);
1221 if (BlitterFactory::GetCurrentBlitter()->GetScreenDepth() == 8) {
1222 _glTexSubImage2D(GL_TEXTURE_2D
, 0, update_rect
.left
, update_rect
.top
, update_rect
.right
- update_rect
.left
, update_rect
.bottom
- update_rect
.top
, GL_RED
, GL_UNSIGNED_BYTE
, (GLvoid
*)(size_t)(update_rect
.top
* _screen
.pitch
+ update_rect
.left
));
1224 _glTexSubImage2D(GL_TEXTURE_2D
, 0, update_rect
.left
, update_rect
.top
, update_rect
.right
- update_rect
.left
, update_rect
.bottom
- update_rect
.top
, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, (GLvoid
*)(size_t)(update_rect
.top
* _screen
.pitch
* 4 + update_rect
.left
* 4));
1227 #ifndef NO_GL_BUFFER_SYNC
1228 if (this->persistent_mapping_supported
) this->sync_vid_mapping
= _glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE
, 0);
1234 * Update animation buffer texture after the animation buffer was filled.
1235 * @param update_rect Rectangle encompassing the dirty region of the animation buffer.
1237 void OpenGLBackend::ReleaseAnimBuffer(const Rect
&update_rect
)
1239 if (this->anim_pbo
== 0) return;
1241 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, this->anim_pbo
);
1242 if (!this->persistent_mapping_supported
) {
1243 _glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER
);
1244 this->anim_buffer
= nullptr;
1247 #ifndef NO_GL_BUFFER_SYNC
1248 if (this->persistent_mapping_supported
) {
1249 _glDeleteSync(this->sync_anim_mapping
);
1250 this->sync_anim_mapping
= nullptr;
1254 /* Update changed rect of the video buffer texture. */
1255 if (update_rect
.left
!= update_rect
.right
) {
1256 _glActiveTexture(GL_TEXTURE0
);
1257 _glBindTexture(GL_TEXTURE_2D
, this->anim_texture
);
1258 _glPixelStorei(GL_UNPACK_ROW_LENGTH
, _screen
.pitch
);
1259 _glTexSubImage2D(GL_TEXTURE_2D
, 0, update_rect
.left
, update_rect
.top
, update_rect
.right
- update_rect
.left
, update_rect
.bottom
- update_rect
.top
, GL_RED
, GL_UNSIGNED_BYTE
, (GLvoid
*)(size_t)(update_rect
.top
* _screen
.pitch
+ update_rect
.left
));
1261 #ifndef NO_GL_BUFFER_SYNC
1262 if (this->persistent_mapping_supported
) this->sync_anim_mapping
= _glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE
, 0);
1267 /* virtual */ Sprite
*OpenGLBackend::Encode(const SpriteLoader::SpriteCollection
&sprite
, AllocatorProc
*allocator
)
1269 /* Allocate and construct sprite data. */
1270 Sprite
*dest_sprite
= (Sprite
*)allocator(sizeof(*dest_sprite
) + sizeof(OpenGLSprite
));
1272 OpenGLSprite
*gl_sprite
= (OpenGLSprite
*)dest_sprite
->data
;
1273 new (gl_sprite
) OpenGLSprite(sprite
[ZOOM_LVL_NORMAL
].width
, sprite
[ZOOM_LVL_NORMAL
].height
, sprite
[ZOOM_LVL_NORMAL
].type
== SpriteType::Font
? 1 : ZOOM_LVL_END
, sprite
[ZOOM_LVL_NORMAL
].colours
);
1275 /* Upload texture data. */
1276 for (int i
= 0; i
< (sprite
[ZOOM_LVL_NORMAL
].type
== SpriteType::Font
? 1 : ZOOM_LVL_END
); i
++) {
1277 gl_sprite
->Update(sprite
[i
].width
, sprite
[i
].height
, i
, sprite
[i
].data
);
1280 dest_sprite
->height
= sprite
[ZOOM_LVL_NORMAL
].height
;
1281 dest_sprite
->width
= sprite
[ZOOM_LVL_NORMAL
].width
;
1282 dest_sprite
->x_offs
= sprite
[ZOOM_LVL_NORMAL
].x_offs
;
1283 dest_sprite
->y_offs
= sprite
[ZOOM_LVL_NORMAL
].y_offs
;
1289 * Render a sprite to the back buffer.
1290 * @param gl_sprite Sprite to render.
1291 * @param x X position of the sprite.
1292 * @param y Y position of the sprite.
1293 * @param zoom Zoom level to use.
1295 void OpenGLBackend::RenderOglSprite(OpenGLSprite
*gl_sprite
, PaletteID pal
, int x
, int y
, ZoomLevel zoom
)
1298 bool rgb
= gl_sprite
->BindTextures();
1299 _glActiveTexture(GL_TEXTURE0
+ 1);
1300 _glBindTexture(GL_TEXTURE_1D
, this->pal_texture
);
1302 /* Set palette remap. */
1303 _glActiveTexture(GL_TEXTURE0
+ 3);
1304 if (pal
!= PAL_NONE
) {
1305 _glBindTexture(GL_TEXTURE_1D
, OpenGLSprite::pal_tex
);
1306 if (pal
!= this->last_sprite_pal
) {
1307 /* Different remap palette in use, update texture. */
1308 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, OpenGLSprite::pal_pbo
);
1309 _glPixelStorei(GL_UNPACK_ROW_LENGTH
, 0);
1311 _glBufferSubData(GL_PIXEL_UNPACK_BUFFER
, 0, 256, GetNonSprite(GB(pal
, 0, PALETTE_WIDTH
), SpriteType::Recolour
) + 1);
1312 _glTexSubImage1D(GL_TEXTURE_1D
, 0, 0, 256, GL_RED
, GL_UNSIGNED_BYTE
, nullptr);
1314 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, 0);
1316 this->last_sprite_pal
= pal
;
1319 _glBindTexture(GL_TEXTURE_1D
, OpenGLSprite::pal_identity
);
1322 /* Set up shader program. */
1323 Dimension dim
= gl_sprite
->GetSize(zoom
);
1324 _glUseProgram(this->sprite_program
);
1325 _glUniform4f(this->sprite_sprite_loc
, (float)x
, (float)y
, (float)dim
.width
, (float)dim
.height
);
1326 _glUniform1f(this->sprite_zoom_loc
, (float)zoom
);
1327 _glUniform2f(this->sprite_screen_loc
, (float)_screen
.width
, (float)_screen
.height
);
1328 _glUniform1i(this->sprite_rgb_loc
, rgb
? 1 : 0);
1329 _glUniform1i(this->sprite_crash_loc
, pal
== PALETTE_CRASH
? 1 : 0);
1331 _glBindVertexArray(this->vao_quad
);
1332 _glDrawArrays(GL_TRIANGLE_STRIP
, 0, 4);
1336 /* static */ GLuint
OpenGLSprite::dummy_tex
[] = { 0, 0 };
1337 /* static */ GLuint
OpenGLSprite::pal_identity
= 0;
1338 /* static */ GLuint
OpenGLSprite::pal_tex
= 0;
1339 /* static */ GLuint
OpenGLSprite::pal_pbo
= 0;
1342 * Create all common resources for sprite rendering.
1343 * @return True if no error occurred.
1345 /* static */ bool OpenGLSprite::Create()
1347 _glGenTextures(NUM_TEX
, OpenGLSprite::dummy_tex
);
1349 for (int t
= TEX_RGBA
; t
< NUM_TEX
; t
++) {
1350 _glBindTexture(GL_TEXTURE_2D
, OpenGLSprite::dummy_tex
[t
]);
1352 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST_MIPMAP_NEAREST
);
1353 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
1354 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAX_LEVEL
, 0);
1355 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_S
, GL_CLAMP_TO_EDGE
);
1356 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_T
, GL_CLAMP_TO_EDGE
);
1359 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, 0);
1360 _glPixelStorei(GL_UNPACK_ROW_LENGTH
, 0);
1362 /* Load dummy RGBA texture. */
1363 const Colour
rgb_pixel(0, 0, 0);
1364 _glBindTexture(GL_TEXTURE_2D
, OpenGLSprite::dummy_tex
[TEX_RGBA
]);
1365 _glTexImage2D(GL_TEXTURE_2D
, 0, GL_RGBA8
, 1, 1, 0, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, &rgb_pixel
);
1367 /* Load dummy remap texture. */
1369 _glBindTexture(GL_TEXTURE_2D
, OpenGLSprite::dummy_tex
[TEX_REMAP
]);
1370 _glTexImage2D(GL_TEXTURE_2D
, 0, GL_R8
, 1, 1, 0, GL_RED
, GL_UNSIGNED_BYTE
, &pal
);
1372 /* Create palette remap textures. */
1373 std::array
<uint8_t, 256> identity_pal
;
1374 std::iota(std::begin(identity_pal
), std::end(identity_pal
), 0);
1376 /* Permanent texture for identity remap. */
1377 _glGenTextures(1, &OpenGLSprite::pal_identity
);
1378 _glBindTexture(GL_TEXTURE_1D
, OpenGLSprite::pal_identity
);
1379 _glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
1380 _glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
1381 _glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_MAX_LEVEL
, 0);
1382 _glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_WRAP_S
, GL_CLAMP_TO_EDGE
);
1383 _glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_WRAP_T
, GL_CLAMP_TO_EDGE
);
1384 _glTexImage1D(GL_TEXTURE_1D
, 0, GL_R8
, 256, 0, GL_RED
, GL_UNSIGNED_BYTE
, identity_pal
.data());
1386 /* Dynamically updated texture for remaps. */
1387 _glGenTextures(1, &OpenGLSprite::pal_tex
);
1388 _glBindTexture(GL_TEXTURE_1D
, OpenGLSprite::pal_tex
);
1389 _glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
1390 _glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
1391 _glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_MAX_LEVEL
, 0);
1392 _glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_WRAP_S
, GL_CLAMP_TO_EDGE
);
1393 _glTexParameteri(GL_TEXTURE_1D
, GL_TEXTURE_WRAP_T
, GL_CLAMP_TO_EDGE
);
1394 _glTexImage1D(GL_TEXTURE_1D
, 0, GL_R8
, 256, 0, GL_RED
, GL_UNSIGNED_BYTE
, identity_pal
.data());
1396 /* Pixel buffer for remap updates. */
1397 _glGenBuffers(1, &OpenGLSprite::pal_pbo
);
1398 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, OpenGLSprite::pal_pbo
);
1399 _glBufferData(GL_PIXEL_UNPACK_BUFFER
, 256, identity_pal
.data(), GL_DYNAMIC_DRAW
);
1400 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, 0);
1402 return _glGetError() == GL_NO_ERROR
;
1405 /** Free all common resources for sprite rendering. */
1406 /* static */ void OpenGLSprite::Destroy()
1408 _glDeleteTextures(NUM_TEX
, OpenGLSprite::dummy_tex
);
1409 _glDeleteTextures(1, &OpenGLSprite::pal_identity
);
1410 _glDeleteTextures(1, &OpenGLSprite::pal_tex
);
1411 if (_glDeleteBuffers
!= nullptr) _glDeleteBuffers(1, &OpenGLSprite::pal_pbo
);
1415 * Create an OpenGL sprite with a palette remap part.
1416 * @param width Width of the top-level texture.
1417 * @param height Height of the top-level texture.
1418 * @param levels Number of mip-map levels.
1419 * @param components Indicates which sprite components are used.
1421 OpenGLSprite::OpenGLSprite(uint width
, uint height
, uint levels
, SpriteColourComponent components
)
1424 (void)_glGetError();
1426 this->dim
.width
= width
;
1427 this->dim
.height
= height
;
1429 MemSetT(this->tex
, 0, NUM_TEX
);
1430 _glActiveTexture(GL_TEXTURE0
);
1431 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, 0);
1433 for (int t
= TEX_RGBA
; t
< NUM_TEX
; t
++) {
1434 /* Sprite component present? */
1435 if (t
== TEX_RGBA
&& components
== SCC_PAL
) continue;
1436 if (t
== TEX_REMAP
&& (components
& SCC_PAL
) != SCC_PAL
) continue;
1438 /* Allocate texture. */
1439 _glGenTextures(1, &this->tex
[t
]);
1440 _glBindTexture(GL_TEXTURE_2D
, this->tex
[t
]);
1442 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST_MIPMAP_NEAREST
);
1443 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
1444 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAX_LEVEL
, levels
- 1);
1445 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_S
, GL_CLAMP_TO_EDGE
);
1446 _glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_T
, GL_CLAMP_TO_EDGE
);
1449 for (uint i
= 0, w
= width
, h
= height
; i
< levels
; i
++, w
/= 2, h
/= 2) {
1451 if (t
== TEX_REMAP
) {
1452 _glTexImage2D(GL_TEXTURE_2D
, i
, GL_R8
, w
, h
, 0, GL_RED
, GL_UNSIGNED_BYTE
, nullptr);
1454 _glTexImage2D(GL_TEXTURE_2D
, i
, GL_RGBA8
, w
, h
, 0, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, nullptr);
1459 assert(_glGetError() == GL_NO_ERROR
);
1462 OpenGLSprite::~OpenGLSprite()
1464 _glDeleteTextures(NUM_TEX
, this->tex
);
1468 * Update a single mip-map level with new pixel data.
1469 * @param width Width of the level.
1470 * @param height Height of the level.
1471 * @param level Mip-map level.
1472 * @param data New pixel data.
1474 void OpenGLSprite::Update(uint width
, uint height
, uint level
, const SpriteLoader::CommonPixel
* data
)
1476 static ReusableBuffer
<Colour
> buf_rgba
;
1477 static ReusableBuffer
<uint8_t> buf_pal
;
1479 _glActiveTexture(GL_TEXTURE0
);
1480 _glBindBuffer(GL_PIXEL_UNPACK_BUFFER
, 0);
1481 _glPixelStorei(GL_UNPACK_ROW_LENGTH
, 0);
1483 if (this->tex
[TEX_RGBA
] != 0) {
1484 /* Unpack pixel data */
1485 size_t size
= static_cast<size_t>(width
) * height
;
1486 Colour
*rgba
= buf_rgba
.Allocate(size
);
1487 for (size_t i
= 0; i
< size
; i
++) {
1488 rgba
[i
].r
= data
[i
].r
;
1489 rgba
[i
].g
= data
[i
].g
;
1490 rgba
[i
].b
= data
[i
].b
;
1491 rgba
[i
].a
= data
[i
].a
;
1494 _glBindTexture(GL_TEXTURE_2D
, this->tex
[TEX_RGBA
]);
1495 _glTexSubImage2D(GL_TEXTURE_2D
, level
, 0, 0, width
, height
, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, rgba
);
1498 if (this->tex
[TEX_REMAP
] != 0) {
1499 /* Unpack and align pixel data. */
1500 size_t pitch
= Align(width
, 4);
1502 uint8_t *pal
= buf_pal
.Allocate(pitch
* height
);
1503 const SpriteLoader::CommonPixel
*row
= data
;
1504 for (uint y
= 0; y
< height
; y
++, pal
+= pitch
, row
+= width
) {
1505 for (uint x
= 0; x
< width
; x
++) {
1510 _glBindTexture(GL_TEXTURE_2D
, this->tex
[TEX_REMAP
]);
1511 _glTexSubImage2D(GL_TEXTURE_2D
, level
, 0, 0, width
, height
, GL_RED
, GL_UNSIGNED_BYTE
, buf_pal
.GetBuffer());
1514 assert(_glGetError() == GL_NO_ERROR
);
1518 * Query the sprite size at a certain zoom level.
1519 * @param level The zoom level to query.
1520 * @return Sprite size at the given zoom level.
1522 inline Dimension
OpenGLSprite::GetSize(ZoomLevel level
) const
1524 Dimension sd
= { (uint
)UnScaleByZoomLower(this->dim
.width
, level
), (uint
)UnScaleByZoomLower(this->dim
.height
, level
) };
1529 * Bind textures for rendering this sprite.
1530 * @return True if the sprite has RGBA data.
1532 bool OpenGLSprite::BindTextures()
1534 _glActiveTexture(GL_TEXTURE0
);
1535 _glBindTexture(GL_TEXTURE_2D
, this->tex
[TEX_RGBA
] != 0 ? this->tex
[TEX_RGBA
] : OpenGLSprite::dummy_tex
[TEX_RGBA
]);
1536 _glActiveTexture(GL_TEXTURE0
+ 2);
1537 _glBindTexture(GL_TEXTURE_2D
, this->tex
[TEX_REMAP
] != 0 ? this->tex
[TEX_REMAP
] : OpenGLSprite::dummy_tex
[TEX_REMAP
]);
1539 return this->tex
[TEX_RGBA
] != 0;