1 /**************************************************************************
3 * Copyright 2013-2014 RAD Game Tools and Valve Software
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 **************************************************************************/
26 // File: vogl_geranl_context_state.cpp
27 #include "vogl_common.h"
28 #include "vogl_general_context_state.h"
29 #include "vogl_console.h"
31 #include "gl_pname_defs.inc"
33 // TODO: Indexed versions of glGet's
34 // TODO: Add GL4 types
36 // TODO: current list mode?
38 //#define DEBUG_CHECK_FOR_UNPROCESSED_STATES
40 //----------------------------------------------------------------------------------------------------------------------
41 // GL get related tables
42 //----------------------------------------------------------------------------------------------------------------------
48 const char *m_pExtension;
49 GLenum m_enum_val_max;
52 static const gl_get_def g_vogl_get_defs[] =
54 // versions are encoded in bytes: 0xMMmm MM=major mm=minor
55 #define DEFINE_GL_GET(sym, min_ver, max_ver) \
57 sym, min_ver, max_ver, NULL, GL_NONE \
60 #define DEFINE_GL_GET_EXT(sym, min_ver, max_ver, ext) \
62 sym, min_ver, max_ver, ext, GL_NONE \
65 #define DEFINE_GL_INDEXED_GET(sym, min_ver, max_ver, max_sym) \
67 sym, min_ver, max_ver, NULL, max_sym \
70 #define DEFINE_GL_INDEXED_GET_EXT(sym, min_ver, max_ver, max_sym, ext) \
72 sym, min_ver, max_ver, ext, max_sym \
75 #include "gl_gets.inc"
79 #define VOGL_GET_DEF_MAX_SUPPORTED_VERSION VOGL_CREATE_GL_VERSION(4, 3, 0)
80 #define VOGL_GET_DEF_MAX_VERSION VOGL_CREATE_GL_VERSION(9, 9, 0)
82 //----------------------------------------------------------------------------------------------------------------------
83 // client active texture and active texture dependent enums
85 // "When the ARB_multitexture extension is supported, or the GL version is 1.3 or
86 // greater, the following parameters return the associated value for the active
87 // texture unit: GL_CURRENT_RASTER_TEXTURE_COORDS, GL_TEXTURE_1D,
88 // GL_TEXTURE_BINDING_1D, GL_TEXTURE_2D, GL_TEXTURE_BINDING_2D, GL_TEXTURE_3D,
89 // GL_TEXTURE_BINDING_3D, GL_TEXTURE_GEN_S, GL_TEXTURE_GEN_T, GL_TEXTURE_GEN_R,
90 // GL_TEXTURE_GEN_Q, GL_TEXTURE_MATRIX, and GL_TEXTURE_STACK_DEPTH.
91 // Likewise, the following parameters return the associated value for the active
92 // client texture unit:
93 // GL_TEXTURE_COORD_ARRAY, GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING,
94 // GL_TEXTURE_COORD_ARRAY_SIZE, GL_TEXTURE_COORD_ARRAY_STRIDE,
95 // GL_TEXTURE_COORD_ARRAY_TYPE.
96 //----------------------------------------------------------------------------------------------------------------------
97 static const GLenum g_vogl_client_active_texture_dependent_enums[] =
99 GL_TEXTURE_COORD_ARRAY,
100 GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING,
101 GL_TEXTURE_COORD_ARRAY_SIZE,
102 GL_TEXTURE_COORD_ARRAY_STRIDE,
103 GL_TEXTURE_COORD_ARRAY_TYPE,
104 GL_TEXTURE_COORD_ARRAY_POINTER
106 //----------------------------------------------------------------------------------------------------------------------
107 static const GLenum g_vogl_active_texture_dependent_enums[] =
109 // These are limited to the max # of combined texture units
111 GL_TEXTURE_BINDING_1D,
113 GL_TEXTURE_BINDING_2D,
115 GL_TEXTURE_BINDING_3D,
117 GL_TEXTURE_BINDING_CUBE_MAP,
118 GL_TEXTURE_CUBE_MAP_ARRAY,
119 GL_TEXTURE_BINDING_CUBE_MAP_ARRAY,
120 GL_TEXTURE_RECTANGLE,
121 GL_TEXTURE_BINDING_RECTANGLE,
123 GL_TEXTURE_BINDING_BUFFER,
125 GL_TEXTURE_BINDING_1D_ARRAY,
127 GL_TEXTURE_BINDING_2D_ARRAY,
128 GL_TEXTURE_2D_MULTISAMPLE,
129 GL_TEXTURE_BINDING_2D_MULTISAMPLE,
130 GL_TEXTURE_2D_MULTISAMPLE_ARRAY,
131 GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY,
132 GL_SAMPLER_BINDING, // needed here for the gets, but not the sets
134 // These are limited to the max # of texture units
135 GL_CURRENT_RASTER_TEXTURE_COORDS,
141 GL_TRANSPOSE_TEXTURE_MATRIX,
142 GL_CURRENT_TEXTURE_COORDS,
143 GL_TEXTURE_STACK_DEPTH
146 //----------------------------------------------------------------------------------------------------------------------
147 // vogl_gl_enum_is_dependent_on_active_texture
148 //----------------------------------------------------------------------------------------------------------------------
149 bool vogl_gl_enum_is_dependent_on_active_texture(GLenum enum_val)
153 return (utils::find_value_in_array(enum_val, g_vogl_active_texture_dependent_enums) >= 0);
156 //----------------------------------------------------------------------------------------------------------------------
157 // vogl_gl_enum_is_dependent_on_client_active_texture
158 //----------------------------------------------------------------------------------------------------------------------
159 bool vogl_gl_enum_is_dependent_on_client_active_texture(GLenum enum_val)
163 return (utils::find_value_in_array(enum_val, g_vogl_client_active_texture_dependent_enums) >= 0);
166 //----------------------------------------------------------------------------------------------------------------------
168 //----------------------------------------------------------------------------------------------------------------------
183 for (uint i = 0; i < VOGL_ARRAY_SIZE(g_vogl_get_defs); i++)
184 m_gl_enum_to_get_def_index.insert(g_vogl_get_defs[i].m_enum_val, i);
187 inline uint get_total() const
189 return VOGL_ARRAY_SIZE(g_vogl_get_defs);
192 inline GLenum get_enum_val(uint index) const
194 return get_desc(index).m_enum_val;
196 inline uint get_min_vers(uint index) const
198 uint packed_ver = get_desc(index).m_min_ver;
199 VOGL_ASSERT(packed_ver <= 0xFF);
200 return VOGL_CREATE_GL_VERSION(packed_ver >> 4, packed_ver & 0xF, 0);
202 inline uint get_max_vers(uint index) const
204 uint packed_ver = get_desc(index).m_max_ver;
205 VOGL_ASSERT(packed_ver <= 0xFF);
206 return VOGL_CREATE_GL_VERSION(packed_ver >> 4, packed_ver & 0xF, 0);
208 inline const char *get_extension(uint index)
210 return get_desc(index).m_pExtension;
212 inline uint get_enum_val_max(uint index) const
214 return get_desc(index).m_enum_val_max;
217 inline int find_gl_enum(GLenum enum_val) const
221 if (enum_val > cUINT32_MAX)
222 return vogl::cInvalidIndex;
224 gl_enum_to_get_def_index_hash_map::const_iterator it(m_gl_enum_to_get_def_index.find(static_cast<uint>(enum_val)));
225 if (it == m_gl_enum_to_get_def_index.end())
226 return vogl::cInvalidIndex;
231 inline bool is_gl_enum_indexed_by_client_active_texture(GLenum val) const
235 for (uint i = 0; i < VOGL_ARRAY_SIZE(g_vogl_client_active_texture_dependent_enums); i++)
236 if (g_vogl_client_active_texture_dependent_enums[i] == val)
242 typedef vogl::hash_map<GLenum, uint> gl_enum_to_get_def_index_hash_map;
243 gl_enum_to_get_def_index_hash_map m_gl_enum_to_get_def_index;
245 const gl_get_def &get_desc(uint index) const
247 return g_vogl_get_defs[vogl::math::open_range_check<uint>(index, get_total())];
251 static gl_get_desc g_get_desc;
253 //----------------------------------------------------------------------------------------------------------------------
254 // struct snapshot_context_info
255 //----------------------------------------------------------------------------------------------------------------------
256 class vogl_snapshot_context_info
259 vogl_snapshot_context_info()
263 vogl_snapshot_context_info(const vogl_context_info &context_info)
268 void init(const vogl_context_info &context_info)
272 m_can_use_glGetBooleani_v = (GL_ENTRYPOINT(glGetBooleani_v) != NULL) && (context_info.get_version() >= VOGL_GL_VERSION_3_0);
273 m_can_use_glGetIntegeri_v = (GL_ENTRYPOINT(glGetIntegeri_v) != NULL) && (context_info.get_version() >= VOGL_GL_VERSION_3_0);
274 m_can_use_glGetInteger64v = (GL_ENTRYPOINT(glGetInteger64v) != NULL) && ((context_info.get_version() >= VOGL_GL_VERSION_3_2) || context_info.supports_extension("GL_ARB_sync"));
275 m_can_use_glGetInteger64i_v = (GL_ENTRYPOINT(glGetInteger64i_v) != NULL) && (context_info.get_version() >= VOGL_GL_VERSION_3_2);
276 m_can_use_glGetFloati_v = (GL_ENTRYPOINT(glGetFloati_v) != NULL) && (context_info.get_version() >= VOGL_GL_VERSION_4_1);
277 m_can_use_glGetDoublei_v = (GL_ENTRYPOINT(glGetDoublei_v) != NULL) && ((context_info.get_version() >= VOGL_GL_VERSION_4_3) || context_info.supports_extension("GL_ARB_viewport_array"));
278 m_can_use_glGetPointerv = (GL_ENTRYPOINT(glGetPointerv) != NULL) && !context_info.is_core_profile();
280 m_max_texture_units = 0;
281 m_max_texture_coords = 0;
283 if (!context_info.is_core_profile())
285 GL_ENTRYPOINT(glGetIntegerv)(GL_MAX_TEXTURE_UNITS, &m_max_texture_units);
286 GL_ENTRYPOINT(glGetIntegerv)(GL_MAX_TEXTURE_COORDS, &m_max_texture_coords);
289 m_max_combined_texture_coords = 0;
290 GL_ENTRYPOINT(glGetIntegerv)(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &m_max_combined_texture_coords);
292 m_max_draw_buffers = 0;
293 if (context_info.get_version() >= VOGL_GL_VERSION_2_0)
295 GL_ENTRYPOINT(glGetIntegerv)(GL_MAX_DRAW_BUFFERS, &m_max_draw_buffers);
298 m_max_vertex_attribs = 0;
299 GL_ENTRYPOINT(glGetIntegerv)(GL_MAX_VERTEX_ATTRIBS, &m_max_vertex_attribs);
304 bool m_can_use_glGetBooleani_v;
305 bool m_can_use_glGetIntegeri_v;
306 bool m_can_use_glGetInteger64v;
307 bool m_can_use_glGetInteger64i_v;
308 bool m_can_use_glGetFloati_v;
309 bool m_can_use_glGetDoublei_v;
310 bool m_can_use_glGetPointerv;
312 GLint m_max_texture_units;
313 GLint m_max_texture_coords;
314 GLint m_max_combined_texture_coords;
315 GLint m_max_draw_buffers;
316 GLint m_max_vertex_attribs;
319 //----------------------------------------------------------------------------------------------------------------------
320 // vogl_general_context_state::vogl_general_context_state
321 //----------------------------------------------------------------------------------------------------------------------
322 vogl_general_context_state::vogl_general_context_state()
323 : vogl_state_vector()
328 //----------------------------------------------------------------------------------------------------------------------
329 // vogl_general_context_state::restore_buffer_binding
330 //----------------------------------------------------------------------------------------------------------------------
331 bool vogl_general_context_state::restore_buffer_binding(GLenum binding_enum, GLenum set_enum, vogl_handle_remapper &remapper) const
336 if (get(binding_enum, 0, &buffer))
338 buffer = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_BUFFERS, buffer));
340 GL_ENTRYPOINT(glBindBuffer)(set_enum, buffer);
349 //----------------------------------------------------------------------------------------------------------------------
350 // vogl_general_context_state::restore_buffer_binding_range
351 //----------------------------------------------------------------------------------------------------------------------
352 bool vogl_general_context_state::restore_buffer_binding_range(GLenum binding_enum, GLenum start_enum, GLenum size_enum, GLenum set_enum, uint index, bool indexed_variant, vogl_handle_remapper &remapper) const
356 uint64_t start, size = 0;
358 if (get(binding_enum, index, &buffer, indexed_variant) &&
359 get(start_enum, index, &start, indexed_variant) &&
360 get(size_enum, index, &size, indexed_variant))
364 buffer = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_BUFFERS, buffer));
366 if ((!start) && (!size))
368 GL_ENTRYPOINT(glBindBufferBase)(set_enum, index, buffer);
373 GL_ENTRYPOINT(glBindBufferRange)(set_enum, index, buffer, (GLintptr)start, (GLsizeiptr)size);
384 //----------------------------------------------------------------------------------------------------------------------
385 // vogl_general_context_state::can_snapshot_state
386 //----------------------------------------------------------------------------------------------------------------------
387 bool vogl_general_context_state::can_snapshot_state(const vogl_context_info &context_info, vogl_snapshot_context_info &context, uint get_desc_index)
391 const GLenum enum_val = g_get_desc.get_enum_val(get_desc_index);
392 const uint min_vers = g_get_desc.get_min_vers(get_desc_index);
393 const uint max_vers = g_get_desc.get_max_vers(get_desc_index);
394 const char *pExtension = g_get_desc.get_extension(get_desc_index);
397 if (!context_info.supports_extension(pExtension))
401 VOGL_ASSERT(min_vers >= VOGL_CREATE_GL_VERSION(1, 0, 0));
402 VOGL_ASSERT(min_vers < VOGL_CREATE_GL_VERSION(9, 9, 0));
403 VOGL_ASSERT(max_vers >= VOGL_CREATE_GL_VERSION(1, 0, 0));
404 VOGL_ASSERT(max_vers <= VOGL_CREATE_GL_VERSION(9, 9, 0));
406 if (context_info.get_version() < min_vers)
408 else if ((context_info.is_core_profile()) && (max_vers < VOGL_GET_DEF_MAX_VERSION))
410 if (context_info.get_version() > max_vers)
414 if ((enum_val >= GL_DRAW_BUFFER0) && (enum_val <= GL_DRAW_BUFFER15))
416 if (enum_val >= static_cast<GLenum>(GL_DRAW_BUFFER0 + context.m_max_draw_buffers))
423 //----------------------------------------------------------------------------------------------------------------------
424 // vogl_general_context_state::snapshot_state
425 //----------------------------------------------------------------------------------------------------------------------
426 bool vogl_general_context_state::snapshot_state(const vogl_context_info &context_info, vogl_snapshot_context_info &context, uint get_desc_index, uint index, bool indexed_variant)
430 VOGL_NOTE_UNUSED(context_info);
432 const GLenum enum_val = g_get_desc.get_enum_val(get_desc_index);
434 const char *pName = g_gl_enums.find_name(enum_val);
436 int pname_def_index = g_gl_enums.find_pname_def_index(enum_val);
437 if (pname_def_index < 0)
439 vogl_warning_printf("Unable to find pname def for GL enum %s\n", pName);
443 const gl_pname_def_t &pname_def = g_gl_pname_defs[pname_def_index];
445 VOGL_ASSERT(pname_def.m_gl_enum == enum_val);
447 bool has_get = false, has_geti = false;
448 if (pname_def.m_pFuncs[0])
450 if (!vogl_strcmp(pname_def.m_pFuncs, "glGet"))
452 else if (!vogl_strcmp(pname_def.m_pFuncs, "glGetI"))
454 else if (!vogl_strcmp(pname_def.m_pFuncs, "glGet,glGetI"))
461 console::error("%s: Unrecognized pname func \"%s\" in pname table\n", VOGL_METHOD_NAME, pname_def.m_pFuncs);
465 if (!has_get && !has_geti)
467 //printf("! %s\n", pname_def.m_pName);
471 if ((!indexed_variant) && (!has_get))
477 if ((indexed_variant) && (!has_geti))
483 vogl_state_data trial_state_data;
485 vogl_state_type state_type = static_cast<vogl_state_type>(pname_def.m_type);
487 uint n = g_gl_enums.get_pname_count(enum_val);
495 GLboolean *p = trial_state_data.init_and_get_data_ptr<GLboolean>(enum_val, index, n, state_type, indexed_variant);
498 GL_ENTRYPOINT(glGetBooleani_v)(enum_val, index, p);
502 GL_ENTRYPOINT(glGetBooleanv)(enum_val, p);
509 GLenum *p = trial_state_data.init_and_get_data_ptr<GLenum>(enum_val, index, n, state_type, indexed_variant);
512 GL_ENTRYPOINT(glGetIntegeri_v)(enum_val, index, reinterpret_cast<GLint *>(p));
516 GL_ENTRYPOINT(glGetIntegerv)(enum_val, reinterpret_cast<GLint *>(p));
519 if (enum_val == GL_CULL_FACE_MODE)
525 case GL_FRONT_AND_BACK:
529 console::error("%s: GL_CULL_FACE_MODE is 0x%X, which is not valid! Forcing it to GL_BACK.\n", VOGL_METHOD_NAME, *p);
541 int32 *p = trial_state_data.init_and_get_data_ptr<int32>(enum_val, index, n, state_type, indexed_variant);
546 GL_ENTRYPOINT(glGetIntegeri_v)(enum_val, index, p);
550 GL_ENTRYPOINT(glGetIntegerv)(enum_val, p);
553 // Sanity check to find GL_DRAW_INDIRECT_BUFFER_BINDING remapping problem.
556 case GL_ARRAY_BUFFER_BINDING:
557 case GL_ELEMENT_ARRAY_BUFFER_BINDING:
558 case GL_PIXEL_PACK_BUFFER_BINDING:
559 case GL_PIXEL_UNPACK_BUFFER_BINDING:
560 case GL_COPY_READ_BUFFER_BINDING:
561 case GL_COPY_WRITE_BUFFER_BINDING:
562 case GL_DRAW_INDIRECT_BUFFER_BINDING:
563 case GL_DISPATCH_INDIRECT_BUFFER_BINDING:
564 case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
565 case GL_UNIFORM_BUFFER_BINDING:
566 case GL_ATOMIC_COUNTER_BUFFER_BINDING:
567 case GL_SHADER_STORAGE_BUFFER_BINDING:
568 case GL_VERTEX_ARRAY_BUFFER_BINDING:
569 case GL_COLOR_ARRAY_BUFFER_BINDING:
570 case GL_INDEX_ARRAY_BUFFER_BINDING:
571 case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING:
572 case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:
573 case GL_FOG_COORD_ARRAY_BUFFER_BINDING:
574 case GL_NORMAL_ARRAY_BUFFER_BINDING:
575 case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING:
576 case GL_SAMPLER_BINDING:
577 case GL_CURRENT_QUERY:
578 case GL_CURRENT_PROGRAM:
579 case GL_PROGRAM_PIPELINE_BINDING:
580 case GL_RENDERBUFFER_BINDING:
581 case GL_READ_FRAMEBUFFER_BINDING:
582 case GL_DRAW_FRAMEBUFFER_BINDING:
583 case GL_VERTEX_ARRAY_BINDING:
584 case GL_TEXTURE_BINDING_BUFFER:
585 case GL_TEXTURE_BINDING_RECTANGLE:
586 case GL_TEXTURE_BINDING_CUBE_MAP_ARRAY:
587 case GL_TEXTURE_BINDING_CUBE_MAP:
588 case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
589 case GL_TEXTURE_BINDING_2D_MULTISAMPLE:
590 case GL_TEXTURE_BINDING_2D_ARRAY:
591 case GL_TEXTURE_BINDING_1D_ARRAY:
592 case GL_TEXTURE_BINDING_1D:
593 case GL_TEXTURE_BINDING_2D:
594 case GL_TEXTURE_BINDING_3D:
599 vogl_error_printf("%s: Driver has returned a negative handle (%i) for state %s, slamming it to 0!\n", VOGL_METHOD_NAME, handle, pname_def.m_pName);
602 else if (handle > 0xFFFF)
604 // We know this pname is unreliable on AMD right now.
605 if (enum_val == GL_DRAW_INDIRECT_BUFFER_BINDING)
607 vogl_error_printf("%s: Driver has returned a probably bogus handle (%i) for state %s, slamming it to 0!\n", VOGL_METHOD_NAME, handle, pname_def.m_pName);
612 vogl_warning_printf("%s: Driver has returned a potentially bogus handle (%i) for state %s!\n", VOGL_METHOD_NAME, handle, pname_def.m_pName);
626 if (!context.m_can_use_glGetInteger64v)
629 GLint64 *p = trial_state_data.init_and_get_data_ptr<GLint64>(enum_val, index, n, state_type, indexed_variant);
632 GL_ENTRYPOINT(glGetInteger64i_v)(enum_val, index, p);
636 GL_ENTRYPOINT(glGetInteger64v)(enum_val, p);
643 float *p = trial_state_data.init_and_get_data_ptr<float>(enum_val, index, n, state_type, indexed_variant);
646 GL_ENTRYPOINT(glGetFloati_v)(enum_val, index, p);
650 GL_ENTRYPOINT(glGetFloatv)(enum_val, p);
656 double *p = trial_state_data.init_and_get_data_ptr<double>(enum_val, index, n, state_type, indexed_variant);
659 GL_ENTRYPOINT(glGetDoublei_v)(enum_val, index, p);
663 GL_ENTRYPOINT(glGetDoublev)(enum_val, p);
669 if (!context.m_can_use_glGetPointerv)
674 // This is a legacy/compat API.
677 indexed_variant = false;
687 p[16] = (void *)0xCFCFCFCF;
689 GL_ENTRYPOINT(glGetPointerv)(enum_val, p);
691 VOGL_ASSERT(p[16] == (void *)0xCFCFCFCF);
693 uint64_t *q = trial_state_data.init_and_get_data_ptr<uint64_t>(enum_val, index, n, state_type, indexed_variant);
694 for (uint i = 0; i < n; i++)
695 q[i] = reinterpret_cast<uint64_t>(p[i]);
701 vogl_warning_printf("Unknown pname type for GL enum %s\n", pName);
706 bool gl_get_failed = vogl_check_gl_error();
709 vogl_warning_printf("Failed retrieving GL state for GL enum %s\n", pName);
713 trial_state_data.debug_check();
715 if (!insert(trial_state_data))
716 vogl_warning_printf("%s: vogl_state_vector::deserialize: Ignoring duplicate state 0x%X index %u\n", VOGL_METHOD_NAME, trial_state_data.get_enum_val(), trial_state_data.get_index());
721 //----------------------------------------------------------------------------------------------------------------------
722 // vogl_general_context_state::snapshot_active_queries
723 //----------------------------------------------------------------------------------------------------------------------
724 static const GLenum g_query_targets[] = { GL_SAMPLES_PASSED, GL_ANY_SAMPLES_PASSED, GL_TIME_ELAPSED, GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, GL_PRIMITIVES_GENERATED };
726 bool vogl_general_context_state::snapshot_active_queries(const vogl_context_info &context_info)
730 if (context_info.get_version() < VOGL_GL_VERSION_2_0)
733 //TODO: Add GL4 types
737 GL_ENTRYPOINT(glGetQueryiv)(GL_SAMPLES_PASSED, GL_CURRENT_QUERY, &handle);
739 if (!insert(vogl_state_data(GL_CURRENT_QUERY, GL_SAMPLES_PASSED, &handle, sizeof(handle), false)))
742 if (context_info.supports_extension("GL_ARB_occlusion_query2") || (context_info.get_version() >= VOGL_GL_VERSION_3_3))
745 GL_ENTRYPOINT(glGetQueryiv)(GL_ANY_SAMPLES_PASSED, GL_CURRENT_QUERY, &handle);
748 if (!insert(vogl_state_data(GL_CURRENT_QUERY, GL_ANY_SAMPLES_PASSED, &handle, sizeof(handle), false)))
752 if (context_info.supports_extension("GL_NV_transform_feedback") || (context_info.get_version() >= VOGL_GL_VERSION_3_3))
755 GL_ENTRYPOINT(glGetQueryiv)(GL_PRIMITIVES_GENERATED, GL_CURRENT_QUERY, &handle);
758 if (!insert(vogl_state_data(GL_CURRENT_QUERY, GL_PRIMITIVES_GENERATED, &handle, sizeof(handle), false)))
762 GL_ENTRYPOINT(glGetQueryiv)(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, GL_CURRENT_QUERY, &handle);
765 if (!insert(vogl_state_data(GL_CURRENT_QUERY, GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, &handle, sizeof(handle), false)))
769 if (context_info.supports_extension("GL_ARB_timer_query") || (context_info.get_version() >= VOGL_GL_VERSION_3_3))
772 GL_ENTRYPOINT(glGetQueryiv)(GL_TIME_ELAPSED, GL_CURRENT_QUERY, &handle);
775 if (!insert(vogl_state_data(GL_CURRENT_QUERY, GL_TIME_ELAPSED, &handle, sizeof(handle), false)))
782 //----------------------------------------------------------------------------------------------------------------------
783 // vogl_general_context_state::snapshot
784 //----------------------------------------------------------------------------------------------------------------------
785 bool vogl_general_context_state::snapshot(const vogl_context_info &context_info)
789 VOGL_ASSERT(context_info.is_valid());
791 bool prev_gl_error = vogl_check_gl_error();
792 VOGL_ASSERT(!prev_gl_error);
794 vogl_snapshot_context_info snapshot_context_info(context_info);
796 prev_gl_error = vogl_check_gl_error();
797 VOGL_ASSERT(!prev_gl_error);
801 for (uint get_desc_index = 0; get_desc_index < g_get_desc.get_total(); get_desc_index++)
803 const GLenum enum_val = g_get_desc.get_enum_val(get_desc_index);
805 const bool is_dependent_on_client_active_texture = vogl_gl_enum_is_dependent_on_client_active_texture(enum_val);
806 const bool is_dependent_on_active_texture = vogl_gl_enum_is_dependent_on_active_texture(enum_val);
807 if ((is_dependent_on_client_active_texture) || (is_dependent_on_active_texture))
810 if (!can_snapshot_state(context_info, snapshot_context_info, get_desc_index))
813 GLenum enum_val_max = g_get_desc.get_enum_val_max(get_desc_index);
814 if (enum_val_max == GL_NONE)
815 snapshot_state(context_info, snapshot_context_info, get_desc_index, 0, false);
818 uint max_indices = vogl_get_gl_integer(enum_val_max);
821 for (uint i = 0; i < max_indices; i++)
822 snapshot_state(context_info, snapshot_context_info, get_desc_index, i, true);
826 if (!context_info.is_core_profile())
828 // client active texture dependent glGet's
829 GLint prev_client_active_texture = 0;
830 GL_ENTRYPOINT(glGetIntegerv)(GL_CLIENT_ACTIVE_TEXTURE, &prev_client_active_texture);
832 prev_gl_error = vogl_check_gl_error();
833 VOGL_ASSERT(!prev_gl_error);
835 const uint max_client_texture_coords = snapshot_context_info.m_max_texture_coords;
836 VOGL_ASSERT(max_client_texture_coords);
838 for (uint texcoord_index = 0; texcoord_index < max_client_texture_coords; texcoord_index++)
840 GL_ENTRYPOINT(glClientActiveTexture)(GL_TEXTURE0 + texcoord_index);
842 prev_gl_error = vogl_check_gl_error();
843 VOGL_ASSERT(!prev_gl_error);
845 for (uint get_desc_index = 0; get_desc_index < g_get_desc.get_total(); get_desc_index++)
847 const GLenum enum_val = g_get_desc.get_enum_val(get_desc_index);
849 const bool is_dependent_on_client_active_texture = vogl_gl_enum_is_dependent_on_client_active_texture(enum_val);
850 if (!is_dependent_on_client_active_texture)
853 if (can_snapshot_state(context_info, snapshot_context_info, get_desc_index))
854 snapshot_state(context_info, snapshot_context_info, get_desc_index, texcoord_index, false);
858 GL_ENTRYPOINT(glClientActiveTexture)(prev_client_active_texture);
860 prev_gl_error = vogl_check_gl_error();
861 VOGL_ASSERT(!prev_gl_error);
864 // active texture dependent glGet's
865 GLint prev_active_texture = 0;
866 GL_ENTRYPOINT(glGetIntegerv)(GL_ACTIVE_TEXTURE, &prev_active_texture);
868 prev_gl_error = vogl_check_gl_error();
869 VOGL_ASSERT(!prev_gl_error);
871 // FIXME: Test on core profiles (that'll be fun)
872 const uint max_texture_coords = math::maximum<uint>(snapshot_context_info.m_max_texture_coords, snapshot_context_info.m_max_combined_texture_coords);
873 VOGL_ASSERT(max_texture_coords);
875 for (uint texcoord_index = 0; texcoord_index < max_texture_coords; texcoord_index++)
877 GL_ENTRYPOINT(glActiveTexture)(GL_TEXTURE0 + texcoord_index);
879 prev_gl_error = vogl_check_gl_error();
880 VOGL_ASSERT(!prev_gl_error);
882 for (uint get_desc_index = 0; get_desc_index < g_get_desc.get_total(); get_desc_index++)
884 const GLenum enum_val = g_get_desc.get_enum_val(get_desc_index);
886 const bool is_dependent_on_active_texture = vogl_gl_enum_is_dependent_on_active_texture(enum_val);
887 if (!is_dependent_on_active_texture)
890 // skip the stuff that's limited by the max texture coords
891 if ((enum_val == GL_CURRENT_RASTER_TEXTURE_COORDS) ||
892 (enum_val == GL_CURRENT_TEXTURE_COORDS) ||
893 (enum_val == GL_TEXTURE_GEN_S) ||
894 (enum_val == GL_TEXTURE_GEN_T) ||
895 (enum_val == GL_TEXTURE_GEN_Q) ||
896 (enum_val == GL_TEXTURE_GEN_R) ||
897 (enum_val == GL_TEXTURE_MATRIX) ||
898 (enum_val == GL_TRANSPOSE_TEXTURE_MATRIX) ||
899 (enum_val == GL_TEXTURE_STACK_DEPTH))
901 if (static_cast<int>(texcoord_index) >= snapshot_context_info.m_max_texture_coords)
905 if (can_snapshot_state(context_info, snapshot_context_info, get_desc_index))
906 snapshot_state(context_info, snapshot_context_info, get_desc_index, texcoord_index, false);
910 GL_ENTRYPOINT(glActiveTexture)(prev_active_texture);
912 snapshot_active_queries(context_info);
914 prev_gl_error = vogl_check_gl_error();
915 VOGL_ASSERT(!prev_gl_error);
920 //----------------------------------------------------------------------------------------------------------------------
921 // vogl_state_data::restore
922 // TODO: Holy methods of doom, split this up!
923 //----------------------------------------------------------------------------------------------------------------------
924 bool vogl_general_context_state::restore(const vogl_context_info &context_info, vogl_handle_remapper &remapper, vogl_persistent_restore_state &persistent_state) const
928 VOGL_ASSERT(context_info.is_valid());
930 VOGL_NOTE_UNUSED(context_info);
932 #ifdef DEBUG_CHECK_FOR_UNPROCESSED_STATES
933 vogl::vector<vogl_state_id> processed_states;
934 processed_states.reserve(m_states.size());
935 #define ADD_PROCESSED_STATE(e, i) processed_states.push_back(vogl_state_id(e, i, false));
936 #define ADD_PROCESSED_STATE_INDEXED_VARIANT(e, i) processed_states.push_back(vogl_state_id(e, i, true));
938 #define ADD_PROCESSED_STATE(e, i) \
942 #define ADD_PROCESSED_STATE_INDEXED_VARIANT(e, i) \
948 GLint prev_client_active_texture = 0;
949 if (!context_info.is_core_profile())
951 GL_ENTRYPOINT(glGetIntegerv)(GL_CLIENT_ACTIVE_TEXTURE, &prev_client_active_texture);
954 GLint prev_active_texture = 0;
955 GL_ENTRYPOINT(glGetIntegerv)(GL_ACTIVE_TEXTURE, &prev_active_texture);
957 GLint prev_array_buffer_binding = 0;
958 GL_ENTRYPOINT(glGetIntegerv)(GL_ARRAY_BUFFER_BINDING, &prev_array_buffer_binding);
962 for (const_iterator it = begin(); it != end(); ++it)
964 const vogl_state_data &state = it->second;
966 const GLenum enum_val = state.get_enum_val();
967 const uint index = state.get_index();
969 if (enum_val == GL_CLIENT_ACTIVE_TEXTURE)
971 prev_client_active_texture = state.get_element<int>(0);
972 ADD_PROCESSED_STATE(enum_val, index);
975 else if (enum_val == GL_ACTIVE_TEXTURE)
977 prev_active_texture = state.get_element<int>(0);
978 ADD_PROCESSED_STATE(enum_val, index);
981 else if (enum_val == GL_ARRAY_BUFFER_BINDING)
983 prev_array_buffer_binding = state.get_element<uint>(0);
984 prev_array_buffer_binding = static_cast<GLuint>(remapper.remap_handle(VOGL_NAMESPACE_BUFFERS, prev_array_buffer_binding));
985 ADD_PROCESSED_STATE(enum_val, index);
988 else if (enum_val == GL_SAMPLER_BINDING)
990 // sampler objects - put this here to avoid the active texture set
991 GLuint sampler_object = state.get_element<GLuint>(0);
992 sampler_object = static_cast<GLuint>(remapper.remap_handle(VOGL_NAMESPACE_SAMPLERS, sampler_object));
994 GL_ENTRYPOINT(glBindSampler)(index, sampler_object);
997 ADD_PROCESSED_STATE(enum_val, index);
1001 if (vogl_gl_enum_is_dependent_on_active_texture(enum_val))
1003 GL_ENTRYPOINT(glActiveTexture)(GL_TEXTURE0 + index);
1004 VOGL_CHECK_GL_ERROR;
1006 ADD_PROCESSED_STATE(enum_val, index);
1008 else if (vogl_gl_enum_is_dependent_on_client_active_texture(enum_val))
1010 GL_ENTRYPOINT(glClientActiveTexture)(GL_TEXTURE0 + index);
1011 VOGL_CHECK_GL_ERROR;
1013 ADD_PROCESSED_STATE(enum_val, index);
1016 if ((state.get_data_type() == cSTGLboolean) && (state.get_num_elements() == 1))
1018 // glEnableClientState/DisableClientState or glEnable/glDisable
1019 GLboolean boolean_val = state.get_element<GLboolean>(0);
1023 case GL_COLOR_ARRAY:
1024 case GL_EDGE_FLAG_ARRAY:
1025 case GL_FOG_COORD_ARRAY:
1026 case GL_INDEX_ARRAY:
1027 case GL_NORMAL_ARRAY:
1028 case GL_SECONDARY_COLOR_ARRAY:
1029 case GL_TEXTURE_COORD_ARRAY:
1030 case GL_VERTEX_ARRAY:
1033 GL_ENTRYPOINT(glEnableClientState)(enum_val);
1035 GL_ENTRYPOINT(glDisableClientState)(enum_val);
1036 ADD_PROCESSED_STATE(enum_val, index);
1040 case GL_AUTO_NORMAL:
1042 case GL_CLIP_DISTANCE0: // same as CLIP_PLANE0, etc.
1043 case GL_CLIP_DISTANCE1:
1044 case GL_CLIP_DISTANCE2:
1045 case GL_CLIP_DISTANCE3:
1046 case GL_CLIP_DISTANCE4:
1047 case GL_CLIP_DISTANCE5:
1048 case GL_CLIP_DISTANCE6:
1049 case GL_CLIP_DISTANCE7:
1050 case GL_COLOR_LOGIC_OP:
1051 case GL_COLOR_MATERIAL:
1053 case GL_COLOR_TABLE:
1054 case GL_CONVOLUTION_1D:
1055 case GL_CONVOLUTION_2D:
1057 case GL_DEBUG_OUTPUT:
1058 case GL_DEBUG_OUTPUT_SYNCHRONOUS:
1059 case GL_DEPTH_CLAMP:
1063 case GL_FRAMEBUFFER_SRGB:
1065 case GL_INDEX_LOGIC_OP:
1075 case GL_LINE_SMOOTH:
1076 case GL_LINE_STIPPLE:
1077 case GL_MAP1_COLOR_4:
1079 case GL_MAP1_NORMAL:
1080 case GL_MAP1_TEXTURE_COORD_1:
1081 case GL_MAP1_TEXTURE_COORD_2:
1082 case GL_MAP1_TEXTURE_COORD_3:
1083 case GL_MAP1_TEXTURE_COORD_4:
1084 case GL_MAP1_VERTEX_3:
1085 case GL_MAP1_VERTEX_4:
1086 case GL_MAP2_COLOR_4:
1088 case GL_MAP2_NORMAL:
1089 case GL_MAP2_TEXTURE_COORD_1:
1090 case GL_MAP2_TEXTURE_COORD_2:
1091 case GL_MAP2_TEXTURE_COORD_3:
1092 case GL_MAP2_TEXTURE_COORD_4:
1093 case GL_MAP2_VERTEX_3:
1094 case GL_MAP2_VERTEX_4:
1096 case GL_MULTISAMPLE:
1098 case GL_POINT_SMOOTH:
1099 case GL_POINT_SPRITE:
1100 case GL_POLYGON_OFFSET_FILL:
1101 case GL_POLYGON_OFFSET_LINE:
1102 case GL_POLYGON_OFFSET_POINT:
1103 case GL_POLYGON_SMOOTH:
1104 case GL_POLYGON_STIPPLE:
1105 case GL_POST_COLOR_MATRIX_COLOR_TABLE:
1106 case GL_POST_CONVOLUTION_COLOR_TABLE:
1107 case GL_PRIMITIVE_RESTART:
1108 case GL_PRIMITIVE_RESTART_FIXED_INDEX:
1109 case GL_PROGRAM_POINT_SIZE: // same as GL_VERTEX_PROGRAM_POINT_SIZE
1110 case GL_RASTERIZER_DISCARD:
1111 case GL_RESCALE_NORMAL:
1112 case GL_SAMPLE_ALPHA_TO_COVERAGE:
1113 case GL_SAMPLE_ALPHA_TO_ONE:
1114 case GL_SAMPLE_COVERAGE:
1115 case GL_SAMPLE_MASK:
1116 case GL_SAMPLE_SHADING:
1117 case GL_SCISSOR_TEST:
1118 case GL_SEPARABLE_2D:
1119 case GL_STENCIL_TEST:
1123 case GL_TEXTURE_CUBE_MAP:
1124 case GL_TEXTURE_CUBE_MAP_SEAMLESS:
1125 case GL_TEXTURE_GEN_Q:
1126 case GL_TEXTURE_GEN_R:
1127 case GL_TEXTURE_GEN_S:
1128 case GL_TEXTURE_GEN_T:
1129 case GL_VERTEX_PROGRAM_TWO_SIDE:
1130 case GL_VERTEX_PROGRAM_ARB:
1131 case GL_FRAGMENT_PROGRAM_ARB:
1134 GL_ENTRYPOINT(glEnable)(enum_val);
1136 GL_ENTRYPOINT(glDisable)(enum_val);
1137 ADD_PROCESSED_STATE(enum_val, index);
1142 GL_ENTRYPOINT(glEdgeFlag)(boolean_val);
1143 ADD_PROCESSED_STATE(enum_val, index);
1146 case GL_LIGHT_MODEL_LOCAL_VIEWER:
1147 case GL_LIGHT_MODEL_TWO_SIDE:
1149 GL_ENTRYPOINT(glLightModeli)(enum_val, boolean_val);
1150 ADD_PROCESSED_STATE(enum_val, index);
1154 case GL_MAP_STENCIL:
1156 GL_ENTRYPOINT(glPixelTransferi)(enum_val, boolean_val);
1157 ADD_PROCESSED_STATE(enum_val, index);
1160 case GL_PACK_LSB_FIRST:
1161 case GL_PACK_SWAP_BYTES:
1162 case GL_UNPACK_LSB_FIRST:
1163 case GL_UNPACK_SWAP_BYTES:
1165 GL_ENTRYPOINT(glPixelStorei)(enum_val, boolean_val);
1166 ADD_PROCESSED_STATE(enum_val, index);
1169 case GL_COLOR_WRITEMASK:
1170 case GL_DEPTH_WRITEMASK:
1171 case GL_SAMPLE_COVERAGE_INVERT:
1178 case GL_DOUBLEBUFFER:
1180 case GL_SHADER_COMPILER:
1182 // Not a user changable state
1183 ADD_PROCESSED_STATE(enum_val, index);
1188 vogl_debug_printf("%s: FIXME: Don't know how to hande boolean GLenum 0x%04X %s\n", VOGL_METHOD_NAME, enum_val, g_gl_enums.find_name(enum_val));
1193 VOGL_CHECK_GL_ERROR;
1199 case GL_VERTEX_ARRAY_BUFFER_BINDING:
1200 case GL_COLOR_ARRAY_BUFFER_BINDING:
1201 case GL_INDEX_ARRAY_BUFFER_BINDING:
1202 case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING:
1203 case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:
1204 case GL_FOG_COORD_ARRAY_BUFFER_BINDING:
1205 case GL_NORMAL_ARRAY_BUFFER_BINDING:
1206 case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING:
1208 // Client side arrays
1209 // TODO: Unfortunately, all this crap is tied to VAO state, except for client side arrays.
1211 uint client_side_array_index;
1212 for (client_side_array_index = 0; client_side_array_index < VOGL_NUM_CLIENT_SIDE_ARRAY_DESCS; client_side_array_index++)
1213 if (g_vogl_client_side_array_descs[client_side_array_index].m_get_binding == enum_val)
1216 VOGL_VERIFY(client_side_array_index < VOGL_NUM_CLIENT_SIDE_ARRAY_DESCS);
1218 const vogl_client_side_array_desc_t &array_desc = g_vogl_client_side_array_descs[client_side_array_index];
1220 uint binding = state.get_element<uint>(0);
1221 binding = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_BUFFERS, binding));
1223 int size = 0, stride = 0;
1227 bool success = get(array_desc.m_get_pointer, index, &pPtr);
1228 if ((success) && (!binding))
1230 pPtr = reinterpret_cast<void *>(remapper.remap_vertex_array_ptr(static_cast<vogl_client_side_array_desc_id_t>(client_side_array_index), index, reinterpret_cast<vogl_trace_ptr_value>(pPtr)));
1231 ADD_PROCESSED_STATE(array_desc.m_get_pointer, index);
1234 if (array_desc.m_get_size)
1236 if (!get(array_desc.m_get_size, index, &size))
1239 ADD_PROCESSED_STATE(array_desc.m_get_size, index);
1242 if (!get(array_desc.m_get_stride, index, &stride))
1245 ADD_PROCESSED_STATE(array_desc.m_get_stride, index);
1247 if (array_desc.m_get_type)
1249 if (!get(array_desc.m_get_type, index, &type))
1252 ADD_PROCESSED_STATE(array_desc.m_get_type, index);
1257 GL_ENTRYPOINT(glBindBuffer)(GL_ARRAY_BUFFER, binding);
1261 case GL_VERTEX_ARRAY_BUFFER_BINDING:
1262 GL_ENTRYPOINT(glVertexPointer)(size, type, stride, pPtr);
1264 case GL_COLOR_ARRAY_BUFFER_BINDING:
1265 GL_ENTRYPOINT(glColorPointer)(size, type, stride, pPtr);
1267 case GL_INDEX_ARRAY_BUFFER_BINDING:
1268 GL_ENTRYPOINT(glIndexPointer)(type, stride, pPtr);
1270 case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING:
1271 GL_ENTRYPOINT(glSecondaryColorPointer)(size, type, stride, pPtr);
1273 case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:
1274 GL_ENTRYPOINT(glTexCoordPointer)(size, type, stride, pPtr);
1276 case GL_FOG_COORD_ARRAY_BUFFER_BINDING:
1277 GL_ENTRYPOINT(glFogCoordPointer)(type, stride, pPtr);
1279 case GL_NORMAL_ARRAY_BUFFER_BINDING:
1280 GL_ENTRYPOINT(glNormalPointer)(type, stride, pPtr);
1282 case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING:
1283 GL_ENTRYPOINT(glEdgeFlagPointer)(stride, pPtr);
1288 VOGL_CHECK_GL_ERROR;
1290 ADD_PROCESSED_STATE(enum_val, index);
1294 case GL_TEXTURE_BINDING_1D:
1296 uint binding = state.get_element<uint>(0);
1297 binding = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_TEXTURES, binding));
1298 GL_ENTRYPOINT(glBindTexture)(GL_TEXTURE_1D, binding);
1299 VOGL_CHECK_GL_ERROR;
1300 ADD_PROCESSED_STATE(enum_val, index);
1303 case GL_TEXTURE_BINDING_2D:
1305 uint binding = state.get_element<uint>(0);
1306 binding = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_TEXTURES, binding));
1307 GL_ENTRYPOINT(glBindTexture)(GL_TEXTURE_2D, binding);
1308 VOGL_CHECK_GL_ERROR;
1309 ADD_PROCESSED_STATE(enum_val, index);
1312 case GL_TEXTURE_BINDING_3D:
1314 uint binding = state.get_element<uint>(0);
1315 binding = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_TEXTURES, binding));
1316 GL_ENTRYPOINT(glBindTexture)(GL_TEXTURE_3D, binding);
1317 VOGL_CHECK_GL_ERROR;
1318 ADD_PROCESSED_STATE(enum_val, index);
1321 case GL_TEXTURE_BINDING_1D_ARRAY:
1323 uint binding = state.get_element<uint>(0);
1324 binding = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_TEXTURES, binding));
1325 GL_ENTRYPOINT(glBindTexture)(GL_TEXTURE_1D_ARRAY, binding);
1326 VOGL_CHECK_GL_ERROR;
1327 ADD_PROCESSED_STATE(enum_val, index);
1330 case GL_TEXTURE_BINDING_2D_ARRAY:
1332 uint binding = state.get_element<uint>(0);
1333 binding = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_TEXTURES, binding));
1334 GL_ENTRYPOINT(glBindTexture)(GL_TEXTURE_2D_ARRAY, binding);
1335 VOGL_CHECK_GL_ERROR;
1336 ADD_PROCESSED_STATE(enum_val, index);
1339 case GL_TEXTURE_BINDING_2D_MULTISAMPLE:
1341 uint binding = state.get_element<uint>(0);
1342 binding = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_TEXTURES, binding));
1343 GL_ENTRYPOINT(glBindTexture)(GL_TEXTURE_2D_MULTISAMPLE, binding);
1344 VOGL_CHECK_GL_ERROR;
1345 ADD_PROCESSED_STATE(enum_val, index);
1348 case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
1350 uint binding = state.get_element<uint>(0);
1351 binding = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_TEXTURES, binding));
1352 GL_ENTRYPOINT(glBindTexture)(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, binding);
1353 VOGL_CHECK_GL_ERROR;
1354 ADD_PROCESSED_STATE(enum_val, index);
1357 case GL_TEXTURE_BINDING_CUBE_MAP:
1359 uint binding = state.get_element<uint>(0);
1360 binding = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_TEXTURES, binding));
1361 GL_ENTRYPOINT(glBindTexture)(GL_TEXTURE_CUBE_MAP, binding);
1362 VOGL_CHECK_GL_ERROR;
1363 ADD_PROCESSED_STATE(enum_val, index);
1366 case GL_TEXTURE_BINDING_CUBE_MAP_ARRAY:
1368 uint binding = state.get_element<uint>(0);
1369 binding = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_TEXTURES, binding));
1370 GL_ENTRYPOINT(glBindTexture)(GL_TEXTURE_CUBE_MAP_ARRAY, binding);
1371 VOGL_CHECK_GL_ERROR;
1372 ADD_PROCESSED_STATE(enum_val, index);
1375 case GL_TEXTURE_BINDING_RECTANGLE:
1377 uint binding = state.get_element<uint>(0);
1378 binding = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_TEXTURES, binding));
1379 GL_ENTRYPOINT(glBindTexture)(GL_TEXTURE_RECTANGLE, binding);
1380 VOGL_CHECK_GL_ERROR;
1381 ADD_PROCESSED_STATE(enum_val, index);
1384 case GL_TEXTURE_BINDING_BUFFER:
1386 uint binding = state.get_element<uint>(0);
1387 binding = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_TEXTURES, binding));
1388 GL_ENTRYPOINT(glBindTexture)(GL_TEXTURE_BUFFER, binding);
1389 VOGL_CHECK_GL_ERROR;
1390 ADD_PROCESSED_STATE(enum_val, index);
1393 } // switch (enum_val)
1395 } // if (state.m_data_type == cSTGLboolean)
1401 if (get(GL_VERTEX_ARRAY_BINDING, 0, &vao_binding))
1403 vao_binding = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_VERTEX_ARRAYS, vao_binding));
1404 GL_ENTRYPOINT(glBindVertexArray)(vao_binding);
1405 VOGL_CHECK_GL_ERROR;
1406 ADD_PROCESSED_STATE(GL_VERTEX_ARRAY_BINDING, 0);
1409 // blend func separate
1410 GLenum src_rgb, src_alpha;
1411 GLenum dst_rgb, dst_alpha;
1412 if (get(GL_BLEND_SRC_RGB, 0, &src_rgb) && get(GL_BLEND_SRC_ALPHA, 0, &src_alpha) && get(GL_BLEND_DST_RGB, 0, &dst_rgb) && get(GL_BLEND_DST_ALPHA, 0, &dst_alpha))
1414 GL_ENTRYPOINT(glBlendFuncSeparate)(src_rgb, dst_rgb, src_alpha, dst_alpha);
1415 VOGL_CHECK_GL_ERROR;
1416 ADD_PROCESSED_STATE(GL_BLEND_SRC, 0);
1417 ADD_PROCESSED_STATE(GL_BLEND_DST, 0);
1418 ADD_PROCESSED_STATE(GL_BLEND_SRC_RGB, 0);
1419 ADD_PROCESSED_STATE(GL_BLEND_SRC_ALPHA, 0);
1420 ADD_PROCESSED_STATE(GL_BLEND_DST_RGB, 0);
1421 ADD_PROCESSED_STATE(GL_BLEND_DST_ALPHA, 0);
1425 float blend_color[4];
1426 if (get(GL_BLEND_COLOR, 0, blend_color, 4))
1428 GL_ENTRYPOINT(glBlendColor)(blend_color[0], blend_color[1], blend_color[2], blend_color[3]);
1429 VOGL_CHECK_GL_ERROR;
1430 ADD_PROCESSED_STATE(GL_BLEND_COLOR, 0);
1433 // blend equation separate
1434 GLenum blend_equation_rgb = 0, blend_equation_alpha = 0;
1435 if (get(GL_BLEND_EQUATION_RGB, 0, &blend_equation_rgb) && get(GL_BLEND_EQUATION_ALPHA, 0, &blend_equation_alpha))
1437 GL_ENTRYPOINT(glBlendEquationSeparate)(blend_equation_rgb, blend_equation_alpha);
1438 VOGL_CHECK_GL_ERROR;
1439 ADD_PROCESSED_STATE(GL_BLEND_EQUATION_RGB, 0);
1440 ADD_PROCESSED_STATE(GL_BLEND_EQUATION_ALPHA, 0);
1444 float clear_color[4];
1445 if (get(GL_COLOR_CLEAR_VALUE, 0, clear_color, 4))
1447 GL_ENTRYPOINT(glClearColor)(clear_color[0], clear_color[1], clear_color[2], clear_color[3]);
1448 VOGL_CHECK_GL_ERROR;
1449 ADD_PROCESSED_STATE(GL_COLOR_CLEAR_VALUE, 0);
1453 GLenum logic_op_mode;
1454 if (get(GL_LOGIC_OP_MODE, 0, &logic_op_mode))
1456 GL_ENTRYPOINT(glLogicOp)(logic_op_mode);
1457 VOGL_CHECK_GL_ERROR;
1458 ADD_PROCESSED_STATE(GL_LOGIC_OP_MODE, 0);
1462 // TODO: Implement indexed version
1464 if (get(GL_COLOR_WRITEMASK, 0, color_mask, 4))
1466 GL_ENTRYPOINT(glColorMask)(color_mask[0], color_mask[1], color_mask[2], color_mask[3]);
1467 VOGL_CHECK_GL_ERROR;
1468 ADD_PROCESSED_STATE(GL_COLOR_WRITEMASK, 0);
1472 GLenum cull_face_mode;
1473 if (get(GL_CULL_FACE_MODE, 0, &cull_face_mode))
1475 GL_ENTRYPOINT(glCullFace)(cull_face_mode);
1476 VOGL_CHECK_GL_ERROR;
1477 ADD_PROCESSED_STATE(GL_CULL_FACE_MODE, 0);
1482 if (get(GL_FRONT_FACE, 0, &front_face))
1484 GL_ENTRYPOINT(glFrontFace)(front_face);
1485 VOGL_CHECK_GL_ERROR;
1486 ADD_PROCESSED_STATE(GL_FRONT_FACE, 0);
1489 // depth clear value
1490 double depth_clear_val;
1491 if (get(GL_DEPTH_CLEAR_VALUE, 0, &depth_clear_val))
1493 GL_ENTRYPOINT(glClearDepth)(depth_clear_val);
1494 VOGL_CHECK_GL_ERROR;
1495 ADD_PROCESSED_STATE(GL_DEPTH_CLEAR_VALUE, 0);
1498 // min sample shading
1499 float min_sample_shading;
1500 if (get(GL_MIN_SAMPLE_SHADING_VALUE, 0, &min_sample_shading))
1502 GL_ENTRYPOINT(glMinSampleShading)(min_sample_shading);
1503 VOGL_CHECK_GL_ERROR;
1504 ADD_PROCESSED_STATE(GL_MIN_SAMPLE_SHADING_VALUE, 0);
1509 if (get(GL_DEPTH_FUNC, 0, &depth_func))
1511 GL_ENTRYPOINT(glDepthFunc)(depth_func);
1512 VOGL_CHECK_GL_ERROR;
1513 ADD_PROCESSED_STATE(GL_DEPTH_FUNC, 0);
1517 double depth_range[2];
1518 if (get(GL_DEPTH_RANGE, 0, depth_range, 2))
1520 GL_ENTRYPOINT(glDepthRange)(depth_range[0], depth_range[1]);
1521 VOGL_CHECK_GL_ERROR;
1522 ADD_PROCESSED_STATE(GL_DEPTH_RANGE, 0);
1527 if (get(GL_DEPTH_WRITEMASK, 0, &depth_mask))
1529 GL_ENTRYPOINT(glDepthMask)(depth_mask != 0);
1530 VOGL_CHECK_GL_ERROR;
1531 ADD_PROCESSED_STATE(GL_DEPTH_WRITEMASK, 0);
1534 // draw framebuffer binding
1535 uint draw_framebuffer_binding = 0;
1536 if (get(GL_DRAW_FRAMEBUFFER_BINDING, 0, &draw_framebuffer_binding))
1538 draw_framebuffer_binding = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_FRAMEBUFFERS, draw_framebuffer_binding));
1540 GL_ENTRYPOINT(glBindFramebuffer)(GL_DRAW_FRAMEBUFFER, draw_framebuffer_binding);
1541 VOGL_CHECK_GL_ERROR;
1542 ADD_PROCESSED_STATE(GL_DRAW_FRAMEBUFFER_BINDING, 0);
1545 // read framebuffer binding
1546 uint read_framebuffer_binding = 0;
1547 if (get(GL_READ_FRAMEBUFFER_BINDING, 0, &read_framebuffer_binding))
1549 read_framebuffer_binding = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_FRAMEBUFFERS, read_framebuffer_binding));
1551 GL_ENTRYPOINT(glBindFramebuffer)(GL_READ_FRAMEBUFFER, read_framebuffer_binding);
1552 VOGL_CHECK_GL_ERROR;
1553 ADD_PROCESSED_STATE(GL_READ_FRAMEBUFFER_BINDING, 0);
1558 if (get(GL_DRAW_BUFFER, 0, &draw_buffer))
1560 GL_ENTRYPOINT(glDrawBuffer)(draw_buffer);
1561 VOGL_CHECK_GL_ERROR;
1562 ADD_PROCESSED_STATE(GL_DRAW_BUFFER, 0);
1566 const uint MAX_DRAW_BUFFERS = 16;
1568 GLenum draw_buffers[MAX_DRAW_BUFFERS];
1569 utils::zero_object(draw_buffers);
1571 uint draw_buffer_index;
1572 for (draw_buffer_index = 0; draw_buffer_index < MAX_DRAW_BUFFERS; draw_buffer_index++)
1574 if (!get(GL_DRAW_BUFFER0 + draw_buffer_index, 0, &draw_buffers[draw_buffer_index]))
1577 ADD_PROCESSED_STATE(GL_DRAW_BUFFER0 + draw_buffer_index, 0);
1580 if (draw_buffer_index)
1582 int num_actual_draw_buffers;
1583 for (num_actual_draw_buffers = MAX_DRAW_BUFFERS - 1; num_actual_draw_buffers >= 0; num_actual_draw_buffers--)
1584 if (draw_buffers[num_actual_draw_buffers])
1587 VOGL_ASSERT(num_actual_draw_buffers >= 0);
1588 num_actual_draw_buffers++;
1590 if (num_actual_draw_buffers == 1)
1592 GL_ENTRYPOINT(glDrawBuffer)(draw_buffers[0]);
1593 VOGL_CHECK_GL_ERROR;
1597 for (int i = 0; i < num_actual_draw_buffers; i++)
1599 VOGL_ASSERT((utils::is_not_in_set<GLenum, GLenum>(draw_buffers[i], GL_FRONT, GL_BACK, GL_LEFT, GL_RIGHT, GL_FRONT_AND_BACK)));
1602 GL_ENTRYPOINT(glDrawBuffers)(num_actual_draw_buffers, draw_buffers);
1603 VOGL_CHECK_GL_ERROR;
1608 GLenum read_buffer = 0;
1609 if (get(GL_READ_BUFFER, 0, &read_buffer))
1611 GL_ENTRYPOINT(glReadBuffer)(read_buffer);
1612 VOGL_CHECK_GL_ERROR;
1613 ADD_PROCESSED_STATE(GL_READ_BUFFER, 0);
1616 // renderbuffer binding
1617 uint renderbuffer_binding = 0;
1618 if (get(GL_RENDERBUFFER_BINDING, 0, &renderbuffer_binding))
1620 renderbuffer_binding = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_RENDER_BUFFERS, renderbuffer_binding));
1622 GL_ENTRYPOINT(glBindRenderbuffer)(GL_RENDERBUFFER, renderbuffer_binding);
1623 VOGL_CHECK_GL_ERROR;
1624 ADD_PROCESSED_STATE(GL_RENDERBUFFER_BINDING, 0);
1629 if (get(GL_LINE_WIDTH, 0, &line_width))
1631 GL_ENTRYPOINT(glLineWidth)(line_width);
1632 VOGL_CHECK_GL_ERROR;
1633 ADD_PROCESSED_STATE(GL_LINE_WIDTH, 0);
1636 // point fade threshold
1637 float point_fade_threshold_size;
1638 if (get(GL_POINT_FADE_THRESHOLD_SIZE, 0, &point_fade_threshold_size))
1640 GL_ENTRYPOINT(glPointParameterf)(GL_POINT_FADE_THRESHOLD_SIZE, point_fade_threshold_size);
1641 VOGL_CHECK_GL_ERROR;
1642 ADD_PROCESSED_STATE(GL_POINT_FADE_THRESHOLD_SIZE, 0);
1646 float point_distance_atten[3];
1647 if (get(GL_POINT_DISTANCE_ATTENUATION, 0, point_distance_atten, 3))
1649 GL_ENTRYPOINT(glPointParameterfv)(GL_POINT_DISTANCE_ATTENUATION, point_distance_atten);
1650 VOGL_CHECK_GL_ERROR;
1651 ADD_PROCESSED_STATE(GL_POINT_DISTANCE_ATTENUATION, 0);
1654 // point sprite coord origin
1655 GLenum point_sprite_coord_origin = 0;
1656 if (get(GL_POINT_SPRITE_COORD_ORIGIN, 0, &point_sprite_coord_origin))
1658 GL_ENTRYPOINT(glPointParameteri)(GL_POINT_SPRITE_COORD_ORIGIN, point_sprite_coord_origin);
1659 VOGL_CHECK_GL_ERROR;
1660 ADD_PROCESSED_STATE(GL_POINT_SPRITE_COORD_ORIGIN, 0);
1664 float point_size_min;
1665 if (get(GL_POINT_SIZE_MIN, 0, &point_size_min))
1667 GL_ENTRYPOINT(glPointParameterf)(GL_POINT_SIZE_MIN, point_size_min);
1668 VOGL_CHECK_GL_ERROR;
1669 ADD_PROCESSED_STATE(GL_POINT_SIZE_MIN, 0);
1673 float point_size_max;
1674 if (get(GL_POINT_SIZE_MAX, 0, &point_size_max))
1676 GL_ENTRYPOINT(glPointParameterf)(GL_POINT_SIZE_MAX, point_size_max);
1677 VOGL_CHECK_GL_ERROR;
1678 ADD_PROCESSED_STATE(GL_POINT_SIZE_MAX, 0);
1682 GLenum provoking_vertex = 0;
1683 if (get(GL_PROVOKING_VERTEX, 0, &provoking_vertex))
1685 GL_ENTRYPOINT(glProvokingVertex)(provoking_vertex);
1686 VOGL_CHECK_GL_ERROR;
1687 ADD_PROCESSED_STATE(GL_PROVOKING_VERTEX, 0);
1692 if (get(GL_POINT_SIZE, 0, &point_size))
1694 GL_ENTRYPOINT(glPointSize)(point_size);
1695 VOGL_CHECK_GL_ERROR;
1696 ADD_PROCESSED_STATE(GL_POINT_SIZE, 0);
1700 float polygon_offset_factor, polygon_offset_units;
1701 if (get(GL_POLYGON_OFFSET_FACTOR, 0, &polygon_offset_factor) && get(GL_POLYGON_OFFSET_UNITS, 0, &polygon_offset_units))
1703 GL_ENTRYPOINT(glPolygonOffset)(polygon_offset_factor, polygon_offset_units);
1704 VOGL_CHECK_GL_ERROR;
1705 ADD_PROCESSED_STATE(GL_POLYGON_OFFSET_FACTOR, 0);
1706 ADD_PROCESSED_STATE(GL_POLYGON_OFFSET_UNITS, 0);
1710 GLenum polygon_mode[2] = { 0, 0 };
1711 if (get(GL_POLYGON_MODE, 0, polygon_mode, 2))
1713 GL_ENTRYPOINT(glPolygonMode)(GL_FRONT, polygon_mode[0]);
1714 GL_ENTRYPOINT(glPolygonMode)(GL_BACK, polygon_mode[1]);
1715 VOGL_CHECK_GL_ERROR;
1716 ADD_PROCESSED_STATE(GL_POLYGON_MODE, 0);
1720 float sample_coverage;
1722 if (get(GL_SAMPLE_COVERAGE_VALUE, 0, &sample_coverage) && get(GL_SAMPLE_COVERAGE_INVERT, 0, &sample_invert))
1724 GL_ENTRYPOINT(glSampleCoverage)(sample_coverage, sample_invert);
1725 VOGL_CHECK_GL_ERROR;
1726 ADD_PROCESSED_STATE(GL_SAMPLE_COVERAGE_VALUE, 0);
1727 ADD_PROCESSED_STATE(GL_SAMPLE_COVERAGE_INVERT, 0);
1731 int viewport[4] = { 0, 0, 0, 0 };
1732 if (get(GL_VIEWPORT, 0, viewport, 4))
1734 GL_ENTRYPOINT(glViewport)(viewport[0], viewport[1], viewport[2], viewport[3]);
1735 VOGL_CHECK_GL_ERROR;
1736 ADD_PROCESSED_STATE(GL_VIEWPORT, 0);
1740 int scissor[4] = { 0, 0, 0, 0 };
1741 if (get(GL_SCISSOR_BOX, 0, scissor, 4))
1743 GL_ENTRYPOINT(glScissor)(scissor[0], scissor[1], scissor[2], scissor[3]);
1744 VOGL_CHECK_GL_ERROR;
1745 ADD_PROCESSED_STATE(GL_SCISSOR_BOX, 0);
1748 // stencil op separate
1749 GLenum stencil_fail = 0, stencil_dp_pass = 0, stencil_dp_fail = 0;
1750 if (get(GL_STENCIL_FAIL, 0, &stencil_fail) && get(GL_STENCIL_PASS_DEPTH_PASS, 0, &stencil_dp_pass) && get(GL_STENCIL_PASS_DEPTH_FAIL, 0, &stencil_dp_fail))
1752 GL_ENTRYPOINT(glStencilOpSeparate)(GL_FRONT, stencil_fail, stencil_dp_fail, stencil_dp_pass);
1753 VOGL_CHECK_GL_ERROR;
1754 ADD_PROCESSED_STATE(GL_STENCIL_FAIL, 0);
1755 ADD_PROCESSED_STATE(GL_STENCIL_PASS_DEPTH_PASS, 0);
1756 ADD_PROCESSED_STATE(GL_STENCIL_PASS_DEPTH_FAIL, 0);
1759 if (get(GL_STENCIL_BACK_FAIL, 0, &stencil_fail) && get(GL_STENCIL_BACK_PASS_DEPTH_PASS, 0, &stencil_dp_pass) && get(GL_STENCIL_BACK_PASS_DEPTH_FAIL, 0, &stencil_dp_fail))
1761 GL_ENTRYPOINT(glStencilOpSeparate)(GL_BACK, stencil_fail, stencil_dp_fail, stencil_dp_pass);
1762 VOGL_CHECK_GL_ERROR;
1763 ADD_PROCESSED_STATE(GL_STENCIL_BACK_FAIL, 0);
1764 ADD_PROCESSED_STATE(GL_STENCIL_BACK_PASS_DEPTH_PASS, 0);
1765 ADD_PROCESSED_STATE(GL_STENCIL_BACK_PASS_DEPTH_FAIL, 0);
1768 // stencil func separate
1769 GLenum stencil_func = 0;
1770 GLint stencil_ref = 0;
1771 GLuint stencil_mask = 0;
1773 if (get(GL_STENCIL_FUNC, 0, &stencil_func) && get(GL_STENCIL_REF, 0, &stencil_ref) && get(GL_STENCIL_VALUE_MASK, 0, &stencil_mask))
1775 GL_ENTRYPOINT(glStencilFuncSeparate)(GL_FRONT, stencil_func, stencil_ref, stencil_mask);
1776 VOGL_CHECK_GL_ERROR;
1777 ADD_PROCESSED_STATE(GL_STENCIL_FUNC, 0);
1778 ADD_PROCESSED_STATE(GL_STENCIL_REF, 0);
1779 ADD_PROCESSED_STATE(GL_STENCIL_VALUE_MASK, 0);
1782 if (get(GL_STENCIL_BACK_FUNC, 0, &stencil_func) && get(GL_STENCIL_BACK_REF, 0, &stencil_ref) && get(GL_STENCIL_BACK_VALUE_MASK, 0, &stencil_mask))
1784 GL_ENTRYPOINT(glStencilFuncSeparate)(GL_BACK, stencil_func, stencil_ref, stencil_mask);
1785 VOGL_CHECK_GL_ERROR;
1786 ADD_PROCESSED_STATE(GL_STENCIL_BACK_FUNC, 0);
1787 ADD_PROCESSED_STATE(GL_STENCIL_BACK_REF, 0);
1788 ADD_PROCESSED_STATE(GL_STENCIL_BACK_VALUE_MASK, 0);
1791 // stencil writemask separate
1792 GLuint stencil_writemask = 0;
1793 if (get(GL_STENCIL_WRITEMASK, 0, &stencil_writemask))
1795 GL_ENTRYPOINT(glStencilMaskSeparate)(GL_FRONT, stencil_writemask);
1796 VOGL_CHECK_GL_ERROR;
1797 ADD_PROCESSED_STATE(GL_STENCIL_WRITEMASK, 0);
1800 if (get(GL_STENCIL_BACK_WRITEMASK, 0, &stencil_writemask))
1802 GL_ENTRYPOINT(glStencilMaskSeparate)(GL_BACK, stencil_writemask);
1803 VOGL_CHECK_GL_ERROR;
1804 ADD_PROCESSED_STATE(GL_STENCIL_BACK_WRITEMASK, 0);
1807 GLenum color_material_face, color_material_parameter;
1808 if (get(GL_COLOR_MATERIAL_FACE, 0, &color_material_face) && get(GL_COLOR_MATERIAL_PARAMETER, 0, &color_material_parameter))
1810 GL_ENTRYPOINT(glColorMaterial)(color_material_face, color_material_parameter);
1811 VOGL_CHECK_GL_ERROR;
1812 ADD_PROCESSED_STATE(GL_COLOR_MATERIAL_FACE, 0);
1813 ADD_PROCESSED_STATE(GL_COLOR_MATERIAL_PARAMETER, 0);
1817 restore_buffer_binding(GL_COPY_READ_BUFFER_BINDING, GL_COPY_READ_BUFFER, remapper);
1818 ADD_PROCESSED_STATE(GL_COPY_READ_BUFFER_BINDING, 0);
1820 restore_buffer_binding(GL_COPY_WRITE_BUFFER_BINDING, GL_COPY_WRITE_BUFFER, remapper);
1821 ADD_PROCESSED_STATE(GL_COPY_WRITE_BUFFER_BINDING, 0);
1823 restore_buffer_binding(GL_DRAW_INDIRECT_BUFFER_BINDING, GL_DRAW_INDIRECT_BUFFER, remapper);
1824 ADD_PROCESSED_STATE(GL_DRAW_INDIRECT_BUFFER_BINDING, 0);
1826 restore_buffer_binding(GL_DISPATCH_INDIRECT_BUFFER_BINDING, GL_DISPATCH_INDIRECT_BUFFER, remapper);
1827 ADD_PROCESSED_STATE(GL_DISPATCH_INDIRECT_BUFFER_BINDING, 0);
1829 restore_buffer_binding(GL_PIXEL_PACK_BUFFER_BINDING, GL_PIXEL_PACK_BUFFER, remapper);
1830 ADD_PROCESSED_STATE(GL_PIXEL_PACK_BUFFER_BINDING, 0);
1832 restore_buffer_binding(GL_PIXEL_UNPACK_BUFFER_BINDING, GL_PIXEL_UNPACK_BUFFER, remapper);
1833 ADD_PROCESSED_STATE(GL_PIXEL_UNPACK_BUFFER_BINDING, 0);
1835 restore_buffer_binding(GL_ELEMENT_ARRAY_BUFFER_BINDING, GL_ELEMENT_ARRAY_BUFFER, remapper);
1836 ADD_PROCESSED_STATE(GL_ELEMENT_ARRAY_BUFFER_BINDING, 0);
1838 // restore transform feedback targets
1839 restore_buffer_binding(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, GL_TRANSFORM_FEEDBACK_BUFFER, remapper);
1840 ADD_PROCESSED_STATE(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, 0);
1841 for (uint i = 0; i < context_info.get_max_transform_feedback_separate_attribs(); i++)
1843 restore_buffer_binding_range(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, GL_TRANSFORM_FEEDBACK_BUFFER_START, GL_TRANSFORM_FEEDBACK_BUFFER_SIZE, GL_TRANSFORM_FEEDBACK_BUFFER, i, true, remapper);
1844 ADD_PROCESSED_STATE_INDEXED_VARIANT(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, i);
1845 ADD_PROCESSED_STATE_INDEXED_VARIANT(GL_TRANSFORM_FEEDBACK_BUFFER_START, i);
1846 ADD_PROCESSED_STATE_INDEXED_VARIANT(GL_TRANSFORM_FEEDBACK_BUFFER_SIZE, i);
1849 // restore uniform buffer binding target, and the indexed variants
1850 restore_buffer_binding(GL_UNIFORM_BUFFER_BINDING, GL_UNIFORM_BUFFER, remapper);
1851 ADD_PROCESSED_STATE(GL_UNIFORM_BUFFER_BINDING, 0);
1852 for (uint i = 0; i < context_info.get_max_uniform_buffer_bindings(); i++)
1854 restore_buffer_binding_range(GL_UNIFORM_BUFFER_BINDING, GL_UNIFORM_BUFFER_START, GL_UNIFORM_BUFFER_SIZE, GL_UNIFORM_BUFFER, i, true, remapper);
1855 ADD_PROCESSED_STATE_INDEXED_VARIANT(GL_UNIFORM_BUFFER_BINDING, i);
1856 ADD_PROCESSED_STATE_INDEXED_VARIANT(GL_UNIFORM_BUFFER_START, i);
1857 ADD_PROCESSED_STATE_INDEXED_VARIANT(GL_UNIFORM_BUFFER_SIZE, i);
1860 // TODO: these GL4 guys have indexed and offset/size variants
1861 restore_buffer_binding(GL_ATOMIC_COUNTER_BUFFER_BINDING, GL_ATOMIC_COUNTER_BUFFER, remapper);
1862 ADD_PROCESSED_STATE(GL_ATOMIC_COUNTER_BUFFER_BINDING, 0);
1864 restore_buffer_binding(GL_SHADER_STORAGE_BUFFER_BINDING, GL_SHADER_STORAGE_BUFFER, remapper);
1865 ADD_PROCESSED_STATE(GL_SHADER_STORAGE_BUFFER_BINDING, 0);
1867 // pixel transfer settings
1868 static const GLenum s_pixel_transfer_pnames[] =
1870 GL_INDEX_SHIFT, GL_INDEX_OFFSET, GL_RED_SCALE, GL_GREEN_SCALE, GL_BLUE_SCALE, GL_ALPHA_SCALE, GL_DEPTH_SCALE,
1871 GL_RED_BIAS, GL_GREEN_BIAS, GL_BLUE_BIAS, GL_ALPHA_BIAS, GL_DEPTH_BIAS, GL_POST_COLOR_MATRIX_RED_SCALE,
1872 GL_POST_COLOR_MATRIX_GREEN_SCALE, GL_POST_COLOR_MATRIX_BLUE_SCALE, GL_POST_COLOR_MATRIX_ALPHA_SCALE,
1873 GL_POST_COLOR_MATRIX_RED_BIAS, GL_POST_COLOR_MATRIX_GREEN_BIAS, GL_POST_COLOR_MATRIX_BLUE_BIAS,
1874 GL_POST_COLOR_MATRIX_ALPHA_BIAS, GL_POST_CONVOLUTION_RED_SCALE, GL_POST_CONVOLUTION_GREEN_SCALE,
1875 GL_POST_CONVOLUTION_BLUE_SCALE, GL_POST_CONVOLUTION_ALPHA_SCALE, GL_POST_CONVOLUTION_RED_BIAS,
1876 GL_POST_CONVOLUTION_GREEN_BIAS, GL_POST_CONVOLUTION_BLUE_BIAS, GL_POST_CONVOLUTION_ALPHA_BIAS
1879 for (uint i = 0; i < VOGL_ARRAY_SIZE(s_pixel_transfer_pnames); i++)
1881 GLenum enum_val = s_pixel_transfer_pnames[i];
1883 int pname_def_index = g_gl_enums.find_pname_def_index(enum_val);
1884 if (pname_def_index < 0)
1886 vogl_warning_printf("Unable to find pname def for GL enum %s\n", g_gl_enums.find_name(enum_val));
1890 const gl_pname_def_t &pname_def = g_gl_pname_defs[pname_def_index];
1892 VOGL_VERIFY(pname_def.m_count == 1);
1894 if (pname_def.m_type == cSTInt32)
1897 if (get(enum_val, 0, &val))
1899 GL_ENTRYPOINT(glPixelTransferi)(enum_val, val);
1900 VOGL_CHECK_GL_ERROR;
1901 ADD_PROCESSED_STATE(enum_val, 0);
1904 else if (pname_def.m_type == cSTFloat)
1907 if (get(enum_val, 0, &val))
1909 GL_ENTRYPOINT(glPixelTransferf)(enum_val, val);
1910 VOGL_CHECK_GL_ERROR;
1911 ADD_PROCESSED_STATE(enum_val, 0);
1921 static const GLenum s_fog_pnames[] = { GL_FOG_MODE, GL_FOG_DENSITY, GL_FOG_START, GL_FOG_END, GL_FOG_INDEX, GL_FOG_COLOR, GL_FOG_COORD_SRC };
1923 for (uint i = 0; i < VOGL_ARRAY_SIZE(s_fog_pnames); i++)
1925 GLenum enum_val = s_fog_pnames[i];
1927 int pname_def_index = g_gl_enums.find_pname_def_index(enum_val);
1928 if (pname_def_index < 0)
1930 vogl_warning_printf("Unable to find pname def for GL enum %s\n", g_gl_enums.find_name(enum_val));
1934 const gl_pname_def_t &pname_def = g_gl_pname_defs[pname_def_index];
1936 switch (pname_def.m_type)
1940 VOGL_ASSERT(pname_def.m_count <= 4);
1942 if (get(enum_val, 0, v, 4))
1944 if (pname_def.m_count > 1)
1945 GL_ENTRYPOINT(glFogfv)(enum_val, v);
1947 GL_ENTRYPOINT(glFogf)(enum_val, v[0]);
1948 VOGL_CHECK_GL_ERROR;
1949 ADD_PROCESSED_STATE(enum_val, 0);
1955 VOGL_VERIFY(pname_def.m_count == 1);
1957 if (get(enum_val, 0, &v))
1959 GL_ENTRYPOINT(glFogi)(enum_val, v);
1960 VOGL_CHECK_GL_ERROR;
1961 ADD_PROCESSED_STATE(enum_val, 0);
1967 VOGL_VERIFY(pname_def.m_count == 1);
1969 if (get(enum_val, 0, &v))
1971 GL_ENTRYPOINT(glFogi)(enum_val, v);
1972 VOGL_CHECK_GL_ERROR;
1973 ADD_PROCESSED_STATE(enum_val, 0);
1986 static GLenum s_hint_pnames[] = { GL_GENERATE_MIPMAP_HINT, GL_FOG_HINT, GL_FRAGMENT_SHADER_DERIVATIVE_HINT, GL_LINE_SMOOTH_HINT, GL_POLYGON_SMOOTH_HINT, GL_TEXTURE_COMPRESSION_HINT, GL_PERSPECTIVE_CORRECTION_HINT, GL_POINT_SMOOTH_HINT };
1987 for (uint i = 0; i < VOGL_ARRAY_SIZE(s_hint_pnames); i++)
1989 GLenum enum_val = s_hint_pnames[i];
1991 if (get(enum_val, 0, &val))
1993 GL_ENTRYPOINT(glHint)(enum_val, val);
1994 VOGL_CHECK_GL_ERROR;
1995 ADD_PROCESSED_STATE(enum_val, 0);
1999 // primitive restart index
2000 uint prim_restart_index;
2001 if (get(GL_PRIMITIVE_RESTART_INDEX, 0, &prim_restart_index))
2003 GL_ENTRYPOINT(glPrimitiveRestartIndex)(prim_restart_index);
2004 VOGL_CHECK_GL_ERROR;
2005 ADD_PROCESSED_STATE(GL_PRIMITIVE_RESTART_INDEX, 0);
2011 if (get(GL_ALPHA_TEST_FUNC, 0, &alpha_func) && get(GL_ALPHA_TEST_REF, 0, &alpha_ref))
2013 GL_ENTRYPOINT(glAlphaFunc)(alpha_func, alpha_ref);
2014 VOGL_CHECK_GL_ERROR;
2015 ADD_PROCESSED_STATE(GL_ALPHA_TEST_FUNC, 0);
2016 ADD_PROCESSED_STATE(GL_ALPHA_TEST_REF, 0);
2019 // clear index value
2021 if (get(GL_INDEX_CLEAR_VALUE, 0, &clear_index))
2023 GL_ENTRYPOINT(glClearIndex)(static_cast<float>(clear_index));
2024 VOGL_CHECK_GL_ERROR;
2025 ADD_PROCESSED_STATE(GL_INDEX_CLEAR_VALUE, 0);
2029 int index_writemask;
2030 if (get(GL_INDEX_WRITEMASK, 0, &index_writemask))
2032 GL_ENTRYPOINT(glIndexMask)(index_writemask);
2033 VOGL_CHECK_GL_ERROR;
2034 ADD_PROCESSED_STATE(GL_INDEX_WRITEMASK, 0);
2038 int line_stipple_pattern, line_stipple_repeat;
2039 if (get(GL_LINE_STIPPLE_PATTERN, 0, &line_stipple_pattern) && get(GL_LINE_STIPPLE_REPEAT, 0, &line_stipple_repeat))
2041 GL_ENTRYPOINT(glLineStipple)(line_stipple_repeat, line_stipple_pattern);
2042 VOGL_CHECK_GL_ERROR;
2043 ADD_PROCESSED_STATE(GL_LINE_STIPPLE_PATTERN, 0);
2044 ADD_PROCESSED_STATE(GL_LINE_STIPPLE_REPEAT, 0);
2049 if (get(GL_LIST_BASE, 0, &list_base))
2051 GL_ENTRYPOINT(glListBase)(list_base);
2052 VOGL_CHECK_GL_ERROR;
2053 ADD_PROCESSED_STATE(GL_LIST_BASE, 0);
2058 if (get(GL_MATRIX_MODE, 0, &matrix_mode))
2060 GL_ENTRYPOINT(glMatrixMode)(matrix_mode);
2061 VOGL_CHECK_GL_ERROR;
2062 ADD_PROCESSED_STATE(GL_MATRIX_MODE, 0);
2067 if (get(GL_SHADE_MODEL, 0, &shade_model))
2069 GL_ENTRYPOINT(glShadeModel)(shade_model);
2070 VOGL_CHECK_GL_ERROR;
2071 ADD_PROCESSED_STATE(GL_SHADE_MODEL, 0);
2075 float zoom_x, zoom_y;
2076 if (get(GL_ZOOM_X, 0, &zoom_x) && get(GL_ZOOM_Y, 0, &zoom_y))
2078 GL_ENTRYPOINT(glPixelZoom)(zoom_x, zoom_y);
2079 VOGL_CHECK_GL_ERROR;
2080 ADD_PROCESSED_STATE(GL_ZOOM_X, 0);
2081 ADD_PROCESSED_STATE(GL_ZOOM_Y, 0);
2084 // stencil clear value
2085 int stencil_clear_value;
2086 if (get(GL_STENCIL_CLEAR_VALUE, 0, &stencil_clear_value))
2088 GL_ENTRYPOINT(glClearStencil)(stencil_clear_value);
2089 VOGL_CHECK_GL_ERROR;
2090 ADD_PROCESSED_STATE(GL_STENCIL_CLEAR_VALUE, 0);
2094 static const GLenum s_pixel_store_pnames[] =
2096 GL_UNPACK_ALIGNMENT, GL_UNPACK_ROW_LENGTH, GL_UNPACK_SKIP_PIXELS, GL_UNPACK_SKIP_ROWS, GL_UNPACK_IMAGE_HEIGHT, GL_UNPACK_SKIP_IMAGES,
2097 GL_PACK_ALIGNMENT, GL_PACK_IMAGE_HEIGHT, GL_PACK_ROW_LENGTH, GL_PACK_SKIP_IMAGES, GL_PACK_SKIP_PIXELS, GL_PACK_SKIP_ROWS
2100 for (uint i = 0; i < VOGL_ARRAY_SIZE(s_pixel_store_pnames); i++)
2102 GLenum enum_val = s_pixel_store_pnames[i];
2104 int pname_def_index = g_gl_enums.find_pname_def_index(enum_val);
2105 if (pname_def_index < 0)
2107 vogl_warning_printf("Unable to find pname def for GL enum %s\n", g_gl_enums.find_name(enum_val));
2111 const gl_pname_def_t &pname_def = g_gl_pname_defs[pname_def_index];
2113 VOGL_VERIFY((pname_def.m_type == cSTInt32) && (pname_def.m_count == 1));
2116 if (get(enum_val, 0, &val))
2118 GL_ENTRYPOINT(glPixelStorei)(enum_val, val);
2119 VOGL_CHECK_GL_ERROR;
2120 ADD_PROCESSED_STATE(enum_val, 0);
2124 // program pipeline binding
2125 uint program_pipeline_binding;
2126 if (get(GL_PROGRAM_PIPELINE_BINDING, 0, &program_pipeline_binding))
2129 program_pipeline_binding = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_PIPELINES, program_pipeline_binding));
2130 GL_ENTRYPOINT(glBindProgramPipeline)(program_pipeline_binding);
2131 VOGL_CHECK_GL_ERROR;
2132 ADD_PROCESSED_STATE(GL_PROGRAM_PIPELINE_BINDING, 0);
2135 // accum clear value
2136 float accum_clear_value[4];
2137 if (get(GL_ACCUM_CLEAR_VALUE, 0, accum_clear_value, 4))
2139 GL_ENTRYPOINT(glClearAccum)(accum_clear_value[0], accum_clear_value[1], accum_clear_value[2], accum_clear_value[3]);
2140 VOGL_CHECK_GL_ERROR;
2141 ADD_PROCESSED_STATE(GL_ACCUM_CLEAR_VALUE, 0);
2144 float light_model_ambient[4];
2145 if (get(GL_LIGHT_MODEL_AMBIENT, 0, light_model_ambient, 4))
2147 GL_ENTRYPOINT(glLightModelfv)(GL_LIGHT_MODEL_AMBIENT, light_model_ambient);
2148 VOGL_CHECK_GL_ERROR;
2149 ADD_PROCESSED_STATE(GL_LIGHT_MODEL_AMBIENT, 0);
2152 GLenum light_model_color_control;
2153 if (get(GL_LIGHT_MODEL_COLOR_CONTROL, 0, &light_model_color_control))
2155 GL_ENTRYPOINT(glLightModeli)(GL_LIGHT_MODEL_COLOR_CONTROL, light_model_color_control);
2156 VOGL_CHECK_GL_ERROR;
2157 ADD_PROCESSED_STATE(GL_LIGHT_MODEL_COLOR_CONTROL, 0);
2161 uint cur_trace_program;
2162 if (get(GL_CURRENT_PROGRAM, 0, &cur_trace_program))
2164 uint cur_program = static_cast<uint>(remapper.remap_handle(VOGL_NAMESPACE_PROGRAMS, cur_trace_program));
2165 GL_ENTRYPOINT(glUseProgram)(cur_program);
2166 VOGL_CHECK_GL_ERROR;
2167 ADD_PROCESSED_STATE(GL_CURRENT_PROGRAM, 0);
2170 int attrib_stack_depth;
2171 if (get(GL_ATTRIB_STACK_DEPTH, 0, &attrib_stack_depth) && attrib_stack_depth)
2173 vogl_warning_printf("%s: Attribute stack is not empty and cannot be restored\n", VOGL_METHOD_NAME);
2174 ADD_PROCESSED_STATE(GL_ATTRIB_STACK_DEPTH, 0);
2177 int client_attrib_stack_depth;
2178 if (get(GL_CLIENT_ATTRIB_STACK_DEPTH, 0, &client_attrib_stack_depth) && client_attrib_stack_depth)
2180 vogl_warning_printf("%s: Client attribute stack is not empty and cannot be restored\n", VOGL_METHOD_NAME);
2181 ADD_PROCESSED_STATE(GL_CLIENT_ATTRIB_STACK_DEPTH, 0);
2184 int selection_buffer_size = 0;
2185 if (get(GL_SELECTION_BUFFER_SIZE, 0, &selection_buffer_size) && (selection_buffer_size))
2187 if ((!persistent_state.m_pSelect_buffer) || (!persistent_state.m_pSelect_buffer->try_resize(selection_buffer_size)))
2189 vogl_warning_printf("%s: Unable to restore selection buffer\n", VOGL_METHOD_NAME);
2193 GL_ENTRYPOINT(glSelectBuffer)(selection_buffer_size, persistent_state.m_pSelect_buffer->get_ptr());
2194 VOGL_CHECK_GL_ERROR;
2198 int name_stack_depth;
2199 if (get(GL_NAME_STACK_DEPTH, 0, &name_stack_depth) && name_stack_depth)
2201 GL_ENTRYPOINT(glRenderMode)(GL_SELECT);
2202 VOGL_CHECK_GL_ERROR;
2204 GL_ENTRYPOINT(glInitNames)();
2205 VOGL_CHECK_GL_ERROR;
2207 for (int i = 0; i < name_stack_depth; i++)
2208 GL_ENTRYPOINT(glPushName)(i + 1); // push anything
2210 VOGL_CHECK_GL_ERROR;
2212 GL_ENTRYPOINT(glRenderMode)(GL_RENDER);
2213 VOGL_CHECK_GL_ERROR;
2215 ADD_PROCESSED_STATE(GL_NAME_STACK_DEPTH, 0);
2220 if (get(GL_RENDER_MODE, 0, &render_mode))
2222 GL_ENTRYPOINT(glRenderMode)(render_mode);
2223 VOGL_CHECK_GL_ERROR;
2224 ADD_PROCESSED_STATE(GL_RENDER_MODE, 0);
2228 vec4F cur_color(0.0f);
2229 if (get(GL_CURRENT_COLOR, 0, cur_color.get_ptr(), 4))
2231 GL_ENTRYPOINT(glColor4f)(cur_color[0], cur_color[1], cur_color[2], cur_color[3]);
2232 ADD_PROCESSED_STATE(GL_CURRENT_COLOR, 0);
2235 vec3F cur_normal(0.0f);
2236 if (get(GL_CURRENT_NORMAL, 0, cur_normal.get_ptr(), 3))
2238 GL_ENTRYPOINT(glNormal3f)(cur_normal[0], cur_normal[1], cur_normal[2]);
2239 ADD_PROCESSED_STATE(GL_CURRENT_NORMAL, 0);
2242 float cur_index = 0;
2243 if (get(GL_CURRENT_INDEX, 0, &cur_index, 1))
2245 GL_ENTRYPOINT(glIndexf)(cur_index);
2246 ADD_PROCESSED_STATE(GL_CURRENT_INDEX, 0);
2249 float cur_fog_coord = 0;
2250 if (get(GL_CURRENT_FOG_COORD, 0, &cur_fog_coord, 1))
2252 GL_ENTRYPOINT(glFogCoordf)(cur_fog_coord);
2253 ADD_PROCESSED_STATE(GL_CURRENT_FOG_COORD, 0);
2256 vec4F cur_secondary_color(0.0f);
2257 if (get(GL_CURRENT_SECONDARY_COLOR, 0, cur_secondary_color.get_ptr(), 4))
2259 GL_ENTRYPOINT(glSecondaryColor3f)(cur_secondary_color[0], cur_secondary_color[1], cur_secondary_color[2]);
2260 ADD_PROCESSED_STATE(GL_CURRENT_SECONDARY_COLOR, 0);
2263 vec4F cur_raster_position(0.0f);
2264 if (get(GL_CURRENT_RASTER_POSITION, 0, cur_raster_position.get_ptr(), 4))
2266 GL_ENTRYPOINT(glRasterPos4f)(cur_raster_position[0], cur_raster_position[1], cur_raster_position[2], cur_raster_position[3]);
2267 ADD_PROCESSED_STATE(GL_CURRENT_RASTER_POSITION, 0);
2270 // I don't know what we can do about these, or if we even care.
2271 ADD_PROCESSED_STATE(GL_CURRENT_RASTER_POSITION_VALID, 0);
2272 ADD_PROCESSED_STATE(GL_CURRENT_RASTER_COLOR, 0);
2273 ADD_PROCESSED_STATE(GL_CURRENT_RASTER_DISTANCE, 0);
2274 ADD_PROCESSED_STATE(GL_CURRENT_RASTER_INDEX, 0);
2275 //ADD_PROCESSED_STATE(GL_CURRENT_RASTER_SECONDARY_COLOR, 0); // can't retrieve on AMD's v13 drivers
2277 // TODO: pixel maps?
2279 //----------------------------------------
2281 // begin any active queries
2283 for (uint i = 0; i < VOGL_ARRAY_SIZE(g_query_targets); i++)
2285 const GLenum target = g_query_targets[i];
2287 GLuint query_handle = 0;
2288 if (get(GL_CURRENT_QUERY, target, &query_handle))
2290 ADD_PROCESSED_STATE(GL_CURRENT_QUERY, target);
2294 query_handle = static_cast<GLuint>(remapper.remap_handle(VOGL_NAMESPACE_QUERIES, query_handle));
2298 GL_ENTRYPOINT(glBeginQuery)(target, query_handle);
2299 VOGL_CHECK_GL_ERROR;
2305 //----------------------------------------
2307 GL_ENTRYPOINT(glBindBuffer)(GL_ARRAY_BUFFER, prev_array_buffer_binding);
2308 VOGL_CHECK_GL_ERROR;
2310 if (!context_info.is_core_profile())
2312 GL_ENTRYPOINT(glClientActiveTexture)(prev_client_active_texture);
2313 VOGL_CHECK_GL_ERROR;
2316 GL_ENTRYPOINT(glActiveTexture)(prev_active_texture);
2317 VOGL_CHECK_GL_ERROR;
2319 #ifdef DEBUG_CHECK_FOR_UNPROCESSED_STATES
2321 #define NOTE_UNUSED(x) ADD_PROCESSED_STATE(x, 0);
2323 NOTE_UNUSED(GL_SUBPIXEL_BITS)
2324 NOTE_UNUSED(GL_VIEWPORT_SUBPIXEL_BITS)
2325 NOTE_UNUSED(GL_RED_BITS)
2326 NOTE_UNUSED(GL_INDEX_BITS)
2327 NOTE_UNUSED(GL_GREEN_BITS)
2328 NOTE_UNUSED(GL_DEPTH_BITS)
2329 NOTE_UNUSED(GL_BLUE_BITS)
2330 NOTE_UNUSED(GL_ALPHA_BITS)
2331 NOTE_UNUSED(GL_ACCUM_ALPHA_BITS)
2332 NOTE_UNUSED(GL_ACCUM_BLUE_BITS)
2333 NOTE_UNUSED(GL_ACCUM_GREEN_BITS)
2334 NOTE_UNUSED(GL_ACCUM_RED_BITS)
2335 NOTE_UNUSED(GL_STENCIL_BITS)
2336 NOTE_UNUSED(GL_ATTRIB_STACK_DEPTH)
2337 NOTE_UNUSED(GL_CLIENT_ATTRIB_STACK_DEPTH)
2338 //NOTE_UNUSED(GL_COLOR_MATRIX_STACK_DEPTH) // can't retrieve on AMD v13 drivers
2339 NOTE_UNUSED(GL_DEBUG_GROUP_STACK_DEPTH)
2340 NOTE_UNUSED(GL_MAX_ATTRIB_STACK_DEPTH)
2341 NOTE_UNUSED(GL_MAX_CLIENT_ATTRIB_STACK_DEPTH)
2342 NOTE_UNUSED(GL_MAX_COLOR_MATRIX_STACK_DEPTH)
2343 NOTE_UNUSED(GL_MAX_DEBUG_GROUP_STACK_DEPTH)
2344 NOTE_UNUSED(GL_MAX_MODELVIEW_STACK_DEPTH)
2345 NOTE_UNUSED(GL_MAX_NAME_STACK_DEPTH)
2346 NOTE_UNUSED(GL_MAX_PROJECTION_STACK_DEPTH)
2347 NOTE_UNUSED(GL_MAX_TEXTURE_STACK_DEPTH)
2348 NOTE_UNUSED(GL_MAX_3D_TEXTURE_SIZE)
2349 NOTE_UNUSED(GL_MAX_ARRAY_TEXTURE_LAYERS)
2350 NOTE_UNUSED(GL_MAX_CLIP_PLANES)
2351 NOTE_UNUSED(GL_MAX_COLOR_ATTACHMENTS)
2352 NOTE_UNUSED(GL_MAX_COLOR_TEXTURE_SAMPLES)
2353 NOTE_UNUSED(GL_MAX_COMBINED_ATOMIC_COUNTERS)
2354 NOTE_UNUSED(GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS)
2355 NOTE_UNUSED(GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS)
2356 NOTE_UNUSED(GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS)
2357 NOTE_UNUSED(GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS)
2358 NOTE_UNUSED(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS)
2359 NOTE_UNUSED(GL_MAX_COMBINED_UNIFORM_BLOCKS)
2360 NOTE_UNUSED(GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS)
2361 NOTE_UNUSED(GL_MAX_COMPUTE_ATOMIC_COUNTERS)
2362 NOTE_UNUSED(GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS)
2363 NOTE_UNUSED(GL_MAX_COMPUTE_LOCAL_INVOCATIONS)
2364 NOTE_UNUSED(GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS)
2365 NOTE_UNUSED(GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS)
2366 NOTE_UNUSED(GL_MAX_COMPUTE_UNIFORM_BLOCKS)
2367 NOTE_UNUSED(GL_MAX_COMPUTE_UNIFORM_COMPONENTS)
2368 NOTE_UNUSED(GL_MAX_CUBE_MAP_TEXTURE_SIZE)
2369 NOTE_UNUSED(GL_MAX_DEPTH_TEXTURE_SAMPLES)
2370 NOTE_UNUSED(GL_MAX_DRAW_BUFFERS)
2371 NOTE_UNUSED(GL_MAX_DUAL_SOURCE_DRAW_BUFFERS)
2372 NOTE_UNUSED(GL_MAX_ELEMENTS_INDICES)
2373 NOTE_UNUSED(GL_MAX_ELEMENTS_VERTICES)
2374 NOTE_UNUSED(GL_MAX_ELEMENT_INDEX)
2375 NOTE_UNUSED(GL_MAX_EVAL_ORDER)
2376 NOTE_UNUSED(GL_MAX_FRAGMENT_ATOMIC_COUNTERS)
2377 NOTE_UNUSED(GL_MAX_FRAGMENT_INPUT_COMPONENTS)
2378 NOTE_UNUSED(GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS)
2379 NOTE_UNUSED(GL_MAX_FRAGMENT_UNIFORM_BLOCKS)
2380 NOTE_UNUSED(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS)
2381 NOTE_UNUSED(GL_MAX_FRAGMENT_UNIFORM_VECTORS)
2382 NOTE_UNUSED(GL_MAX_FRAMEBUFFER_HEIGHT)
2383 NOTE_UNUSED(GL_MAX_FRAMEBUFFER_LAYERS)
2384 NOTE_UNUSED(GL_MAX_FRAMEBUFFER_SAMPLES)
2385 NOTE_UNUSED(GL_MAX_FRAMEBUFFER_WIDTH)
2386 NOTE_UNUSED(GL_MAX_GEOMETRY_ATOMIC_COUNTERS)
2387 NOTE_UNUSED(GL_MAX_GEOMETRY_INPUT_COMPONENTS)
2388 NOTE_UNUSED(GL_MAX_GEOMETRY_OUTPUT_COMPONENTS)
2389 NOTE_UNUSED(GL_MAX_GEOMETRY_OUTPUT_VERTICES)
2390 NOTE_UNUSED(GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS)
2391 NOTE_UNUSED(GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS)
2392 NOTE_UNUSED(GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS)
2393 NOTE_UNUSED(GL_MAX_GEOMETRY_UNIFORM_BLOCKS)
2394 NOTE_UNUSED(GL_MAX_GEOMETRY_UNIFORM_COMPONENTS)
2395 NOTE_UNUSED(GL_MAX_INTEGER_SAMPLES)
2396 NOTE_UNUSED(GL_MAX_LABEL_LENGTH)
2397 NOTE_UNUSED(GL_MAX_LIGHTS)
2398 NOTE_UNUSED(GL_MAX_LIST_NESTING)
2399 NOTE_UNUSED(GL_MAX_PIXEL_MAP_TABLE)
2400 NOTE_UNUSED(GL_MAX_PROGRAM_TEXEL_OFFSET)
2401 NOTE_UNUSED(GL_MAX_RECTANGLE_TEXTURE_SIZE)
2402 NOTE_UNUSED(GL_MAX_RENDERBUFFER_SIZE)
2403 NOTE_UNUSED(GL_MAX_SAMPLE_MASK_WORDS)
2404 NOTE_UNUSED(GL_MAX_SERVER_WAIT_TIMEOUT)
2405 NOTE_UNUSED(GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS)
2406 NOTE_UNUSED(GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS)
2407 NOTE_UNUSED(GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS)
2408 NOTE_UNUSED(GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS)
2409 NOTE_UNUSED(GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS)
2410 NOTE_UNUSED(GL_MAX_TEXTURE_BUFFER_SIZE)
2411 NOTE_UNUSED(GL_MAX_TEXTURE_COORDS)
2412 NOTE_UNUSED(GL_MAX_TEXTURE_IMAGE_UNITS)
2413 NOTE_UNUSED(GL_MAX_TEXTURE_LOD_BIAS)
2414 NOTE_UNUSED(GL_MAX_TEXTURE_SIZE)
2415 NOTE_UNUSED(GL_MAX_TEXTURE_UNITS)
2416 NOTE_UNUSED(GL_MAX_UNIFORM_BLOCK_SIZE)
2417 NOTE_UNUSED(GL_MAX_UNIFORM_BUFFER_BINDINGS)
2418 NOTE_UNUSED(GL_MAX_UNIFORM_LOCATIONS)
2419 NOTE_UNUSED(GL_MAX_VARYING_FLOATS)
2420 NOTE_UNUSED(GL_MAX_VARYING_VECTORS)
2421 NOTE_UNUSED(GL_MAX_VERTEX_ATOMIC_COUNTERS)
2422 NOTE_UNUSED(GL_MAX_VERTEX_ATTRIBS)
2423 NOTE_UNUSED(GL_MAX_VERTEX_ATTRIB_BINDINGS)
2424 NOTE_UNUSED(GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET)
2425 NOTE_UNUSED(GL_MAX_VERTEX_OUTPUT_COMPONENTS)
2426 NOTE_UNUSED(GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS)
2427 NOTE_UNUSED(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS)
2428 NOTE_UNUSED(GL_MAX_VERTEX_UNIFORM_BLOCKS)
2429 NOTE_UNUSED(GL_MAX_VERTEX_UNIFORM_COMPONENTS)
2430 NOTE_UNUSED(GL_MAX_VERTEX_UNIFORM_VECTORS)
2431 NOTE_UNUSED(GL_MAX_VIEWPORTS)
2432 NOTE_UNUSED(GL_MAX_VIEWPORT_DIMS)
2433 NOTE_UNUSED(GL_MODELVIEW_STACK_DEPTH)
2434 NOTE_UNUSED(GL_NAME_STACK_DEPTH)
2435 NOTE_UNUSED(GL_PROJECTION_STACK_DEPTH)
2436 NOTE_UNUSED(GL_COLOR_MATRIX)
2437 NOTE_UNUSED(GL_AUX_BUFFERS)
2438 NOTE_UNUSED(GL_COMPRESSED_TEXTURE_FORMATS)
2439 NOTE_UNUSED(GL_CONTEXT_FLAGS)
2440 NOTE_UNUSED(GL_FEEDBACK_BUFFER_POINTER)
2441 NOTE_UNUSED(GL_FEEDBACK_BUFFER_SIZE)
2442 NOTE_UNUSED(GL_FEEDBACK_BUFFER_TYPE)
2443 NOTE_UNUSED(GL_IMPLEMENTATION_COLOR_READ_FORMAT)
2444 NOTE_UNUSED(GL_IMPLEMENTATION_COLOR_READ_TYPE)
2445 NOTE_UNUSED(GL_LAYER_PROVOKING_VERTEX)
2446 NOTE_UNUSED(GL_MIN_MAP_BUFFER_ALIGNMENT)
2447 NOTE_UNUSED(GL_MIN_PROGRAM_TEXEL_OFFSET)
2448 NOTE_UNUSED(GL_MINOR_VERSION)
2449 NOTE_UNUSED(GL_MAJOR_VERSION)
2450 NOTE_UNUSED(GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT)
2451 NOTE_UNUSED(GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT)
2452 NOTE_UNUSED(GL_ALIASED_LINE_WIDTH_RANGE)
2453 NOTE_UNUSED(GL_ALIASED_POINT_SIZE_RANGE)
2454 NOTE_UNUSED(GL_LINE_WIDTH_GRANULARITY)
2455 NOTE_UNUSED(GL_LINE_WIDTH_RANGE)
2456 NOTE_UNUSED(GL_MAP1_GRID_DOMAIN)
2457 NOTE_UNUSED(GL_MAP1_GRID_SEGMENTS)
2458 NOTE_UNUSED(GL_MAP2_GRID_DOMAIN)
2459 NOTE_UNUSED(GL_MAP2_GRID_SEGMENTS)
2460 NOTE_UNUSED(GL_MODELVIEW_MATRIX)
2461 NOTE_UNUSED(GL_NUM_COMPRESSED_TEXTURE_FORMATS)
2462 NOTE_UNUSED(GL_NUM_EXTENSIONS)
2463 NOTE_UNUSED(GL_NUM_PROGRAM_BINARY_FORMATS)
2464 NOTE_UNUSED(GL_NUM_SHADER_BINARY_FORMATS)
2465 NOTE_UNUSED(GL_POINT_SIZE_GRANULARITY)
2466 NOTE_UNUSED(GL_POINT_SIZE_RANGE)
2467 NOTE_UNUSED(GL_POST_COLOR_MATRIX_COLOR_TABLE)
2468 NOTE_UNUSED(GL_PROGRAM_BINARY_FORMATS)
2469 NOTE_UNUSED(GL_PROJECTION_MATRIX)
2470 NOTE_UNUSED(GL_SAMPLES)
2471 NOTE_UNUSED(GL_SAMPLE_BUFFERS)
2472 NOTE_UNUSED(GL_SELECTION_BUFFER_POINTER)
2473 //NOTE_UNUSED(GL_SELECTION_BUFFER_SIZE)
2474 NOTE_UNUSED(GL_TIMESTAMP)
2475 NOTE_UNUSED(GL_TRANSPOSE_COLOR_MATRIX)
2476 NOTE_UNUSED(GL_TRANSPOSE_MODELVIEW_MATRIX)
2477 NOTE_UNUSED(GL_TRANSPOSE_PROJECTION_MATRIX)
2478 NOTE_UNUSED(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT)
2479 NOTE_UNUSED(GL_VIEWPORT_BOUNDS_RANGE)
2480 NOTE_UNUSED(GL_VIEWPORT_INDEX_PROVOKING_VERTEX)
2483 for (const_iterator it = begin(); it != end(); ++it)
2485 const vogl_state_data &state = it->second;
2488 for (i = 0; i < processed_states.size(); i++)
2489 if (state.get_id() == processed_states[i])
2492 if (i == processed_states.size())
2494 vogl_debug_printf("Didn't process state: %s index: %u indexed_variant: %u\n", g_gl_enums.find_name(state.get_enum_val()), state.get_index(), state.get_indexed_variant());
2502 bool vogl_general_context_state::remap_handles(vogl_handle_remapper &remapper)
2506 for (state_map::iterator it = m_states.begin(); it != m_states.end(); ++it)
2508 vogl_state_data &state = it->second;
2510 const GLenum enum_val = state.get_enum_val();
2511 const uint index = state.get_index();
2512 VOGL_NOTE_UNUSED(index);
2514 vogl_namespace_t handle_namespace = VOGL_NAMESPACE_INVALID;
2518 case GL_ARRAY_BUFFER_BINDING:
2519 case GL_ELEMENT_ARRAY_BUFFER_BINDING:
2520 case GL_PIXEL_PACK_BUFFER_BINDING:
2521 case GL_PIXEL_UNPACK_BUFFER_BINDING:
2522 case GL_COPY_READ_BUFFER_BINDING:
2523 case GL_COPY_WRITE_BUFFER_BINDING:
2524 case GL_DRAW_INDIRECT_BUFFER_BINDING:
2525 case GL_DISPATCH_INDIRECT_BUFFER_BINDING:
2526 case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
2527 case GL_UNIFORM_BUFFER_BINDING:
2528 case GL_ATOMIC_COUNTER_BUFFER_BINDING:
2529 case GL_SHADER_STORAGE_BUFFER_BINDING:
2531 case GL_VERTEX_ARRAY_BUFFER_BINDING:
2532 case GL_COLOR_ARRAY_BUFFER_BINDING:
2533 case GL_INDEX_ARRAY_BUFFER_BINDING:
2534 case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING:
2535 case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:
2536 case GL_FOG_COORD_ARRAY_BUFFER_BINDING:
2537 case GL_NORMAL_ARRAY_BUFFER_BINDING:
2538 case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING:
2539 handle_namespace = VOGL_NAMESPACE_BUFFERS;
2542 case GL_SAMPLER_BINDING:
2543 handle_namespace = VOGL_NAMESPACE_SAMPLERS;
2546 case GL_CURRENT_QUERY:
2547 handle_namespace = VOGL_NAMESPACE_QUERIES;
2550 case GL_CURRENT_PROGRAM:
2551 handle_namespace = VOGL_NAMESPACE_PROGRAMS;
2554 case GL_PROGRAM_PIPELINE_BINDING:
2555 handle_namespace = VOGL_NAMESPACE_PIPELINES;
2558 case GL_RENDERBUFFER_BINDING:
2559 handle_namespace = VOGL_NAMESPACE_RENDER_BUFFERS;
2562 case GL_READ_FRAMEBUFFER_BINDING:
2563 case GL_DRAW_FRAMEBUFFER_BINDING:
2564 handle_namespace = VOGL_NAMESPACE_FRAMEBUFFERS;
2567 case GL_VERTEX_ARRAY_BINDING:
2568 handle_namespace = VOGL_NAMESPACE_VERTEX_ARRAYS;
2571 case GL_TEXTURE_BINDING_BUFFER:
2572 case GL_TEXTURE_BINDING_RECTANGLE:
2573 case GL_TEXTURE_BINDING_CUBE_MAP_ARRAY:
2574 case GL_TEXTURE_BINDING_CUBE_MAP:
2575 case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
2576 case GL_TEXTURE_BINDING_2D_MULTISAMPLE:
2577 case GL_TEXTURE_BINDING_2D_ARRAY:
2578 case GL_TEXTURE_BINDING_1D_ARRAY:
2579 case GL_TEXTURE_BINDING_1D:
2580 case GL_TEXTURE_BINDING_2D:
2581 case GL_TEXTURE_BINDING_3D:
2582 handle_namespace = VOGL_NAMESPACE_TEXTURES;
2586 if (handle_namespace == VOGL_NAMESPACE_INVALID)
2589 if ((state.get_num_elements() != 1) || ((state.get_data_type() != cSTInt32) && (state.get_data_type() != cSTUInt32)))
2596 state.get_uint(&handle);
2600 handle = static_cast<GLuint>(remapper.remap_handle(handle_namespace, handle));
2602 state.get_element<GLuint>(0) = handle;
2609 // TODO: Move this to separate file
2610 vogl_polygon_stipple_state::vogl_polygon_stipple_state()
2615 utils::zero_object(m_pattern);
2618 vogl_polygon_stipple_state::~vogl_polygon_stipple_state()
2623 bool vogl_polygon_stipple_state::snapshot(const vogl_context_info &context_info)
2627 VOGL_NOTE_UNUSED(context_info);
2629 VOGL_CHECK_GL_ERROR;
2633 vogl_scoped_state_saver pixelstore_state_saver(cGSTPixelStore);
2634 vogl_reset_pixel_store_states();
2636 GL_ENTRYPOINT(glGetPolygonStipple)(m_pattern);
2637 VOGL_CHECK_GL_ERROR;
2644 bool vogl_polygon_stipple_state::restore(const vogl_context_info &context_info) const
2648 VOGL_NOTE_UNUSED(context_info);
2653 VOGL_CHECK_GL_ERROR;
2655 vogl_scoped_state_saver pixelstore_state_saver(cGSTPixelStore);
2656 vogl_reset_pixel_store_states();
2658 GL_ENTRYPOINT(glPolygonStipple)(m_pattern);
2659 VOGL_CHECK_GL_ERROR;
2664 void vogl_polygon_stipple_state::clear()
2669 utils::zero_object(m_pattern);
2672 bool vogl_polygon_stipple_state::serialize(json_node &node, vogl_blob_manager &blob_manager) const
2676 VOGL_NOTE_UNUSED(blob_manager);
2681 json_node &arr_node = node.add_array("pattern");
2682 for (uint i = 0; i < VOGL_ARRAY_SIZE(m_pattern); i++)
2683 arr_node.add_value(m_pattern[i]);
2688 bool vogl_polygon_stipple_state::deserialize(const json_node &node, const vogl_blob_manager &blob_manager)
2692 VOGL_NOTE_UNUSED(blob_manager);
2696 const json_node *pArr_node = node.find_child_array("pattern");
2700 if (!pArr_node->are_all_children_values())
2703 // An earlier version wrote the wrong size, so ignore that data.
2704 if (pArr_node->size() == VOGL_ARRAY_SIZE(m_pattern))
2706 for (uint i = 0; i < VOGL_ARRAY_SIZE(m_pattern); i++)
2707 m_pattern[i] = static_cast<uint8>(pArr_node->value_as_uint32(i));
2711 vogl_warning_printf("%s: Polygon stipple data is not valid in this older trace file so it's being ignored - please recapture (sorry)\n", VOGL_METHOD_NAME);
2719 uint vogl_polygon_stipple_state::get_num_pattern_rows() const
2724 uint32 vogl_polygon_stipple_state::get_pattern_row(uint row_index) const
2726 VOGL_ASSERT(row_index < 32);
2728 return m_pattern[4 * row_index] | (m_pattern[4 * row_index + 1] << 8U) | (m_pattern[4 * row_index + 2] << 16U) | (m_pattern[4 * row_index + 3] << 24U);