Renamed gl_state to gl_rend_state

src/CRE/GL/array_buffer.cpp

@@ -4,11 +4,11 @@
 */
 
 #include "array_buffer.hpp"
-#include "../gl_state.hpp"
+#include "../gl_rend_state.hpp"
 
 namespace GL {
     void ArrayBuffer::Bind(bool force) {
-        gl_state_bind_array_buffer(buffer, force);
+        gl_rend_state.bind_array_buffer(buffer, force);
     }
 
     void ArrayBuffer::Create(size_t size) {
@@ -21,7 +21,7 @@ namespace GL {
         }
         else {
             glGenBuffers(1, &buffer);
-            gl_state_bind_array_buffer(buffer, true);
+            gl_rend_state.bind_array_buffer(buffer, true);
             if (GL_VERSION_4_4)
                 glBufferStorage(GL_ARRAY_BUFFER, (GLsizeiptr)size,
                     0, GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT);
@@ -41,7 +41,7 @@ namespace GL {
         }
         else {
             glGenBuffers(1, &buffer);
-            gl_state_bind_array_buffer(buffer, true);
+            gl_rend_state.bind_array_buffer(buffer, true);
             if (GL_VERSION_4_4)
                 glBufferStorage(GL_ARRAY_BUFFER, (GLsizeiptr)size, data,
                     dynamic ? GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT : 0);
@@ -66,7 +66,7 @@ namespace GL {
         if (GL_VERSION_4_5)
             data = glMapNamedBuffer(buffer, GL_WRITE_ONLY);
         else {
-            gl_state_bind_array_buffer(buffer);
+            gl_rend_state.bind_array_buffer(buffer);
             data = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
         }
 
@@ -77,7 +77,7 @@ namespace GL {
             glUnmapNamedBuffer(buffer);
         else {
             glUnmapBuffer(GL_ARRAY_BUFFER);
-            gl_state_bind_array_buffer(0);
+            gl_rend_state.bind_array_buffer(0);
         }
         return 0;
     }
@@ -90,7 +90,7 @@ namespace GL {
             glUnmapNamedBuffer(buffer);
         else {
             glUnmapBuffer(GL_ARRAY_BUFFER);
-            gl_state_bind_array_buffer(0);
+            gl_rend_state.bind_array_buffer(0);
         }
     }
 
@@ -101,7 +101,7 @@ namespace GL {
         if (GL_VERSION_4_5)
             glNamedBufferSubData(buffer, (GLsizeiptr)offset, (GLsizeiptr)size, data);
         else {
-            gl_state_bind_array_buffer(buffer);
+            gl_rend_state.bind_array_buffer(buffer);
             glBufferSubData(GL_ARRAY_BUFFER, (GLsizeiptr)offset, (GLsizeiptr)size, data);
         }
     }

src/CRE/GL/element_array_buffer.cpp

@@ -4,11 +4,11 @@
 */
 
 #include "element_array_buffer.hpp"
-#include "../gl_state.hpp"
+#include "../gl_rend_state.hpp"
 
 namespace GL {
     void ElementArrayBuffer::Bind(bool force) {
-        gl_state_bind_element_array_buffer(buffer, force);
+        gl_rend_state.bind_element_array_buffer(buffer, force);
     }
 
     void ElementArrayBuffer::Create(size_t size) {
@@ -21,7 +21,7 @@ namespace GL {
         }
         else {
             glGenBuffers(1, &buffer);
-            gl_state_bind_element_array_buffer(buffer, true);
+            gl_rend_state.bind_element_array_buffer(buffer, true);
             if (GL_VERSION_4_4)
                 glBufferStorage(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)size,
                     0, GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT);
@@ -41,7 +41,7 @@ namespace GL {
         }
         else {
             glGenBuffers(1, &buffer);
-            gl_state_bind_element_array_buffer(buffer, true);
+            gl_rend_state.bind_element_array_buffer(buffer, true);
             if (GL_VERSION_4_4)
                 glBufferStorage(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)size, data,
                     dynamic ? GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT : 0);
@@ -66,7 +66,7 @@ namespace GL {
         if (GL_VERSION_4_5)
             data = glMapNamedBuffer(buffer, GL_WRITE_ONLY);
         else {
-            gl_state_bind_element_array_buffer(buffer);
+            gl_rend_state.bind_element_array_buffer(buffer);
             data = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
         }
 
@@ -77,7 +77,7 @@ namespace GL {
             glUnmapNamedBuffer(buffer);
         else {
             glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
-            gl_state_bind_element_array_buffer(0);
+            gl_rend_state.bind_element_array_buffer(0);
         }
         return 0;
     }
@@ -90,7 +90,7 @@ namespace GL {
             glUnmapNamedBuffer(buffer);
         else {
             glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
-            gl_state_bind_element_array_buffer(0);
+            gl_rend_state.bind_element_array_buffer(0);
         }
     }
 
@@ -101,7 +101,7 @@ namespace GL {
         if (GL_VERSION_4_5)
             glNamedBufferSubData(buffer, (GLsizeiptr)offset, (GLsizeiptr)size, data);
         else {
-            gl_state_bind_element_array_buffer(buffer);
+            gl_rend_state.bind_element_array_buffer(buffer);
             glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)offset, (GLsizeiptr)size, data);
         }
     }

src/CRE/GL/shader_storage_buffer.cpp

@@ -4,11 +4,11 @@
 */
 
 #include "shader_storage_buffer.hpp"
-#include "../gl_state.hpp"
+#include "../gl_rend_state.hpp"
 
 namespace GL {
     void ShaderStorageBuffer::Bind(int32_t index, bool force) {
-        gl_state_bind_shader_storage_buffer_base(index, buffer, force);
+        gl_rend_state.bind_shader_storage_buffer_base(index, buffer, force);
     }
 
     void ShaderStorageBuffer::Create(size_t size) {
@@ -21,7 +21,7 @@ namespace GL {
         }
         else {
             glGenBuffers(1, &buffer);
-            gl_state_bind_shader_storage_buffer(buffer, true);
+            gl_rend_state.bind_shader_storage_buffer(buffer, true);
             if (GL_VERSION_4_4)
                 glBufferStorage(GL_SHADER_STORAGE_BUFFER, (GLsizeiptr)size,
                     0, GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT);
@@ -41,7 +41,7 @@ namespace GL {
         }
         else {
             glGenBuffers(1, &buffer);
-            gl_state_bind_shader_storage_buffer(buffer, true);
+            gl_rend_state.bind_shader_storage_buffer(buffer, true);
             if (GL_VERSION_4_4)
                 glBufferStorage(GL_SHADER_STORAGE_BUFFER, (GLsizeiptr)size, data,
                     dynamic ? GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT : 0);
@@ -66,7 +66,7 @@ namespace GL {
         if (GL_VERSION_4_5)
             data = glMapNamedBuffer(buffer, GL_WRITE_ONLY);
         else {
-            gl_state_bind_shader_storage_buffer(buffer);
+            gl_rend_state.bind_shader_storage_buffer(buffer);
             data = glMapBuffer(GL_SHADER_STORAGE_BUFFER, GL_WRITE_ONLY);
         }
 
@@ -77,7 +77,7 @@ namespace GL {
             glUnmapNamedBuffer(buffer);
         else {
             glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
-            gl_state_bind_shader_storage_buffer(0);
+            gl_rend_state.bind_shader_storage_buffer(0);
         }
         return 0;
     }
@@ -90,7 +90,7 @@ namespace GL {
             glUnmapNamedBuffer(buffer);
         else {
             glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
-            gl_state_bind_shader_storage_buffer(0);
+            gl_rend_state.bind_shader_storage_buffer(0);
         }
     }
 
@@ -101,7 +101,7 @@ namespace GL {
         if (GL_VERSION_4_5)
             glNamedBufferSubData(buffer, (GLsizeiptr)offset, (GLsizeiptr)size, data);
         else {
-            gl_state_bind_shader_storage_buffer(buffer);
+            gl_rend_state.bind_shader_storage_buffer(buffer);
             glBufferSubData(GL_SHADER_STORAGE_BUFFER, (GLsizeiptr)offset, (GLsizeiptr)size, data);
         }
     }

src/CRE/GL/uniform_buffer.cpp

@@ -4,11 +4,11 @@
 */
 
 #include "uniform_buffer.hpp"
-#include "../gl_state.hpp"
+#include "../gl_rend_state.hpp"
 
 namespace GL {
     void UniformBuffer::Bind(int32_t index, bool force) {
-        gl_state_bind_uniform_buffer_base(index, buffer, force);
+        gl_rend_state.bind_uniform_buffer_base(index, buffer, force);
     }
 
     void UniformBuffer::Create(size_t size) {
@@ -21,7 +21,7 @@ namespace GL {
         }
         else {
             glGenBuffers(1, &buffer);
-            gl_state_bind_uniform_buffer(buffer, true);
+            gl_rend_state.bind_uniform_buffer(buffer, true);
             if (GL_VERSION_4_4)
                 glBufferStorage(GL_UNIFORM_BUFFER, (GLsizeiptr)size,
                     0, GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT);
@@ -41,7 +41,7 @@ namespace GL {
         }
         else {
             glGenBuffers(1, &buffer);
-            gl_state_bind_uniform_buffer(buffer, true);
+            gl_rend_state.bind_uniform_buffer(buffer, true);
             if (GL_VERSION_4_4)
                 glBufferStorage(GL_UNIFORM_BUFFER, (GLsizeiptr)size, data,
                     dynamic ? GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT : 0);
@@ -66,7 +66,7 @@ namespace GL {
         if (GL_VERSION_4_5)
             data = glMapNamedBuffer(buffer, GL_WRITE_ONLY);
         else {
-            gl_state_bind_uniform_buffer(buffer);
+            gl_rend_state.bind_uniform_buffer(buffer);
             data = glMapBuffer(GL_UNIFORM_BUFFER, GL_WRITE_ONLY);
         }
 
@@ -77,7 +77,7 @@ namespace GL {
             glUnmapNamedBuffer(buffer);
         else {
             glUnmapBuffer(GL_UNIFORM_BUFFER);
-            gl_state_bind_uniform_buffer(0);
+            gl_rend_state.bind_uniform_buffer(0);
         }
         return 0;
     }
@@ -90,7 +90,7 @@ namespace GL {
             glUnmapNamedBuffer(buffer);
         else {
             glUnmapBuffer(GL_UNIFORM_BUFFER);
-            gl_state_bind_uniform_buffer(0);
+            gl_rend_state.bind_uniform_buffer(0);
         }
     }
 
@@ -101,7 +101,7 @@ namespace GL {
         if (GL_VERSION_4_5)
             glNamedBufferSubData(buffer, (GLsizeiptr)offset, (GLsizeiptr)size, data);
         else {
-            gl_state_bind_uniform_buffer(buffer);
+            gl_rend_state.bind_uniform_buffer(buffer);
             glBufferSubData(GL_UNIFORM_BUFFER, (GLsizeiptr)offset, (GLsizeiptr)size, data);
         }
     }

src/CRE/Glitter/file_reader.cpp

@@ -12,7 +12,7 @@
 #include "../data.hpp"
 #include "../object.hpp"
 #if SHARED_GLITTER_BUFFER
-#include "../gl_state.hpp"
+#include "../gl_rend_state.hpp"
 #endif
 
 namespace Glitter {

src/CRE/Glitter/glitter.cpp

@@ -4,7 +4,7 @@
 */
 
 #include "glitter.hpp"
-#include "../gl_state.hpp"
+#include "../gl_rend_state.hpp"
 
 namespace Glitter {
     const float_t min_emission = 0.01f;
@@ -271,7 +271,7 @@ namespace Glitter {
         buffer = force_malloc<Buffer>(max_count);
 
         glGenVertexArrays(1, &vao);
-        gl_state_bind_vertex_array(vao, true);
+        gl_rend_state.bind_vertex_array(vao, true);
 
         static const GLsizei buffer_size = sizeof(Buffer);
 
@@ -304,10 +304,10 @@ namespace Glitter {
         glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, buffer_size,
             (void*)offsetof(Buffer, color));
 
-        gl_state_bind_array_buffer(0);
-        gl_state_bind_vertex_array(0);
+        gl_rend_state.bind_array_buffer(0);
+        gl_rend_state.bind_vertex_array(0);
         if (is_quad)
-            gl_state_bind_element_array_buffer(0);
+            gl_rend_state.bind_element_array_buffer(0);
     }
 
     void DeleteBuffer(Buffer*& buffer, GLuint& vao, GL::ArrayBuffer& vbo, GL::ElementArrayBuffer& ebo) {

src/CRE/Glitter/particle_manager.cpp

@@ -284,10 +284,10 @@ namespace Glitter {
             i->Disp(this, disp_type);
         }
 
-        gl_state_bind_vertex_array(0);
-        gl_state_disable_blend();
-        gl_state_enable_cull_face();
-        gl_state_disable_depth_test();
+        gl_rend_state.bind_vertex_array(0);
+        gl_rend_state.disable_blend();
+        gl_rend_state.enable_cull_face();
+        gl_rend_state.disable_depth_test();
     }
 
     void GltParticleManager::FreeEffects() {

src/CRE/Glitter/render_scene.cpp

@@ -4,7 +4,7 @@
 */
 
 #include "glitter.hpp"
-#include "../gl_state.hpp"
+#include "../gl_rend_state.hpp"
 #include "../render_context.hpp"
 #include "../shader.hpp"
 #include "../shader_ft.hpp"
@@ -995,8 +995,8 @@ namespace Glitter {
             break;
         }
 
-        gl_state_set_blend_func(blend_src, blend_dst);
-        gl_state_set_blend_equation(GL_FUNC_ADD);
+        gl_rend_state.set_blend_func(blend_src, blend_dst);
+        gl_rend_state.set_blend_equation(GL_FUNC_ADD);
 
         GLuint texture = rctx_ptr->empty_texture_2d->glid;
         GLuint mask_texture = rctx_ptr->empty_texture_2d->glid;
@@ -1028,8 +1028,8 @@ namespace Glitter {
             uniform_value[U_TEXTURE_BLEND] = 0;
         }
 
-        gl_state_active_bind_texture_2d(0, texture);
-        gl_state_active_bind_texture_2d(1, mask_texture);
+        gl_rend_state.active_bind_texture_2d(0, texture);
+        gl_rend_state.active_bind_texture_2d(1, mask_texture);
 
         switch (rend_group->type) {
         case PARTICLE_QUAD:
@@ -1045,55 +1045,55 @@ namespace Glitter {
                 break;
             }
 
-            gl_state_enable_depth_test();
+            gl_rend_state.enable_depth_test();
 
             if (alpha_test) {
                 uniform_value[U_ALPHA_TEST] = 1;
                 rctx_ptr->set_batch_alpha_threshold(0.5f);
                 uniform_value[U_ALPHA_BLEND] = 1;
-                gl_state_set_depth_mask(GL_TRUE);
-                gl_state_disable_blend();
+                gl_rend_state.set_depth_mask(GL_TRUE);
+                gl_rend_state.disable_blend();
             }
             else if (rend_group->disp_type) {
                 uniform_value[U_ALPHA_TEST] = 0;
                 uniform_value[U_ALPHA_BLEND] = 2;
-                gl_state_set_depth_mask(GL_FALSE);
-                gl_state_enable_blend();
+                gl_rend_state.set_depth_mask(GL_FALSE);
+                gl_rend_state.enable_blend();
             }
             else {
                 uniform_value[U_ALPHA_TEST] = 0;
                 uniform_value[U_ALPHA_BLEND] = 0;
-                gl_state_set_depth_mask(GL_TRUE);
-                gl_state_disable_blend();
+                gl_rend_state.set_depth_mask(GL_TRUE);
+                gl_rend_state.disable_blend();
             }
 
             if (rend_group->draw_type == DIRECTION_BILLBOARD) {
-                gl_state_enable_cull_face();
-                gl_state_set_cull_face_mode(GL_BACK);
+                gl_rend_state.enable_cull_face();
+                gl_rend_state.set_cull_face_mode(GL_BACK);
             }
             else
-                gl_state_disable_cull_face();
+                gl_rend_state.disable_cull_face();
             break;
         case PARTICLE_LINE:
             uniform_value[U_ALPHA_TEST] = 0;
             uniform_value[U_ALPHA_BLEND] = 2;
             uniform_value[U_FOG_STAGE] = 0;
 
-            gl_state_enable_depth_test();
-            gl_state_set_depth_mask(GL_FALSE);
-            gl_state_enable_blend();
-            gl_state_enable_cull_face();
-            gl_state_set_cull_face_mode(GL_BACK);
+            gl_rend_state.enable_depth_test();
+            gl_rend_state.set_depth_mask(GL_FALSE);
+            gl_rend_state.enable_blend();
+            gl_rend_state.enable_cull_face();
+            gl_rend_state.set_cull_face_mode(GL_BACK);
             break;
         case PARTICLE_LOCUS:
             uniform_value[U_ALPHA_TEST] = 0;
             uniform_value[U_ALPHA_BLEND] = 2;
             uniform_value[U_FOG_STAGE] = 0;
 
-            gl_state_enable_depth_test();
-            gl_state_set_depth_mask(GL_FALSE);
-            gl_state_enable_blend();
-            gl_state_disable_cull_face();
+            gl_rend_state.enable_depth_test();
+            gl_rend_state.set_depth_mask(GL_FALSE);
+            gl_rend_state.enable_blend();
+            gl_rend_state.disable_cull_face();
             break;
         }
 
@@ -1102,18 +1102,18 @@ namespace Glitter {
         rctx_ptr->glitter_batch_ubo.Bind(3);
         switch (rend_group->type) {
         case PARTICLE_QUAD:
-            gl_state_bind_vertex_array(rend_group->vao);
+            gl_rend_state.bind_vertex_array(rend_group->vao);
             shaders_ft.enable_primitive_restart();
             shaders_ft.draw_elements(GL_TRIANGLE_STRIP, (GLsizei)(5 * rend_group->disp - 1), GL_UNSIGNED_INT, 0);
             shaders_ft.disable_primitive_restart();
             break;
         case PARTICLE_LINE:
-            gl_state_bind_vertex_array(rend_group->vao);
+            gl_rend_state.bind_vertex_array(rend_group->vao);
             for (std::pair<GLint, GLsizei>& i : rend_group->draw_list)
                 shaders_ft.draw_arrays(GL_LINE_STRIP, i.first, i.second);
             break;
         case PARTICLE_LOCUS:
-            gl_state_bind_vertex_array(rend_group->vao);
+            gl_rend_state.bind_vertex_array(rend_group->vao);
             for (std::pair<GLint, GLsizei>& i : rend_group->draw_list)
                 shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, i.first, i.second);
             break;
@@ -1975,8 +1975,8 @@ namespace Glitter {
             break;
         }
 
-        gl_state_set_blend_func(blend_src, blend_dst);
-        gl_state_set_blend_equation(GL_FUNC_ADD);
+        gl_rend_state.set_blend_func(blend_src, blend_dst);
+        gl_rend_state.set_blend_equation(GL_FUNC_ADD);
 
         GLuint texture = rctx_ptr->empty_texture_2d->glid;
         GLuint mask_texture = rctx_ptr->empty_texture_2d->glid;
@@ -2008,8 +2008,8 @@ namespace Glitter {
             uniform_value[U_TEXTURE_BLEND] = 0;
         }
 
-        gl_state_active_bind_texture_2d(0, texture);
-        gl_state_active_bind_texture_2d(1, mask_texture);
+        gl_rend_state.active_bind_texture_2d(0, texture);
+        gl_rend_state.active_bind_texture_2d(1, mask_texture);
 
         switch (rend_group->fog_type) {
         default:
@@ -2024,54 +2024,54 @@ namespace Glitter {
         }
 
         if (!(rend_group->flags & PARTICLE_DEPTH_TEST))
-            gl_state_enable_depth_test();
+            gl_rend_state.enable_depth_test();
         else
-            gl_state_disable_depth_test();
+            gl_rend_state.disable_depth_test();
 
         if (alpha_test) {
             uniform_value[U_ALPHA_TEST] = 1;
             rctx_ptr->set_batch_alpha_threshold(0.5f);
             uniform_value[U_ALPHA_BLEND] = rend_group->disp_type ? 3 : 1;
-            gl_state_set_depth_mask(GL_TRUE);
-            gl_state_disable_blend();
+            gl_rend_state.set_depth_mask(GL_TRUE);
+            gl_rend_state.disable_blend();
         }
         else if (rend_group->disp_type) {
             uniform_value[U_ALPHA_TEST] = 0;
             uniform_value[U_ALPHA_BLEND] = 2;
-            gl_state_set_depth_mask(GL_FALSE);
-            gl_state_enable_blend();
+            gl_rend_state.set_depth_mask(GL_FALSE);
+            gl_rend_state.enable_blend();
         }
         else {
             uniform_value[U_ALPHA_TEST] = 0;
             uniform_value[U_ALPHA_BLEND] = 0;
-            gl_state_set_depth_mask(GL_TRUE);
-            gl_state_disable_blend();
+            gl_rend_state.set_depth_mask(GL_TRUE);
+            gl_rend_state.disable_blend();
         }
 
         if (rend_group->draw_type == DIRECTION_BILLBOARD && !rend_group->use_culling) {
-            gl_state_enable_cull_face();
-            gl_state_set_cull_face_mode(GL_BACK);
+            gl_rend_state.enable_cull_face();
+            gl_rend_state.set_cull_face_mode(GL_BACK);
         }
         else
-            gl_state_disable_cull_face();
+            gl_rend_state.disable_cull_face();
 
         shaders_ft.set(SHADER_FT_GLITTER_PT);
         rctx_ptr->set_glitter_render_data();
         rctx_ptr->glitter_batch_ubo.Bind(3);
         switch (rend_group->type) {
         case PARTICLE_QUAD:
-            gl_state_bind_vertex_array(rend_group->vao);
+            gl_rend_state.bind_vertex_array(rend_group->vao);
             shaders_ft.enable_primitive_restart();
             shaders_ft.draw_elements(GL_TRIANGLE_STRIP, (GLsizei)(5 * rend_group->disp - 1), GL_UNSIGNED_INT, 0);
             shaders_ft.disable_primitive_restart();
             break;
         case PARTICLE_LINE:
-            gl_state_bind_vertex_array(rend_group->vao);
+            gl_rend_state.bind_vertex_array(rend_group->vao);
             for (std::pair<GLint, GLsizei>& i : rend_group->draw_list)
                 shaders_ft.draw_arrays(GL_LINE_STRIP, i.first, i.second);
             break;
         case PARTICLE_LOCUS:
-            gl_state_bind_vertex_array(rend_group->vao);
+            gl_rend_state.bind_vertex_array(rend_group->vao);
             for (std::pair<GLint, GLsizei>& i : rend_group->draw_list)
                 shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, i.first, i.second);
             break;

src/CRE/Vulkan/gl_wrap.hpp

@@ -129,14 +129,14 @@ namespace Vulkan {
         static gl_sampler* get(GLuint program);
     };
 
-    struct gl_state_rect {
+    struct gl_rend_state_rect {
         GLint x;
         GLint y;
         GLsizei width;
         GLsizei height;
     };
 
-    struct gl_state_struct {
+    struct gl_rend_state_struct {
         vec4 clear_color;
         float_t clear_depth;
         int32_t clear_stencil;
@@ -180,7 +180,7 @@ namespace Vulkan {
         GLboolean multisample;
         GLboolean primitive_restart;
         GLuint primitive_restart_index;
-        gl_state_rect scissor_box;
+        gl_rend_state_rect scissor_box;
         GLboolean scissor_test;
         GLboolean stencil_test;
         GLenum stencil_func;
@@ -190,9 +190,9 @@ namespace Vulkan {
         GLuint stencil_mask;
         GLint stencil_ref;
         GLuint stencil_value_mask;
-        gl_state_rect viewport;
+        gl_rend_state_rect viewport;
 
-        gl_state_struct();
+        gl_rend_state_struct();
     };
 
     struct gl_storage_buffer {

src/CRE/clear_color.cpp

@@ -4,7 +4,7 @@
 */
 
 #include "clear_color.hpp"
-#include "gl_state.hpp"
+#include "gl_rend_state.hpp"
 
 color4u8 clear_color;
 bool set_clear_color;

src/CRE/effect.cpp

@@ -15,7 +15,7 @@
 #include "app_system_detail.hpp"
 #include "auth_3d.hpp"
 #include "data.hpp"
-#include "gl_state.hpp"
+#include "gl_rend_state.hpp"
 #include "random.hpp"
 #include "render_texture.hpp"
 #include "render_context.hpp"
@@ -1284,12 +1284,12 @@ void leaf_particle_draw() {
         &shader_data.g_lit_dir, &shader_data.g_lit_luce, 0, 0);
     leaf_particle_scene_ubo.WriteMemory(shader_data);
 
-    gl_state_active_bind_texture_2d(0, tex->glid);
+    gl_rend_state.active_bind_texture_2d(0, tex->glid);
     shaders_ft.set(SHADER_FT_LEAF_PT);
     leaf_particle_scene_ubo.Bind(0);
-    gl_state_bind_vertex_array(leaf_ptcl_vao);
+    gl_rend_state.bind_vertex_array(leaf_ptcl_vao);
     shaders_ft.draw_elements(GL_TRIANGLES, count / 4 * 6, GL_UNSIGNED_INT, 0);
-    gl_state_bind_vertex_array(0);
+    gl_rend_state.bind_vertex_array(0);
 }
 
 void rain_particle_draw() {
@@ -1323,11 +1323,11 @@ void rain_particle_draw() {
     scene_shader_data.g_range_offset = { range_offset.x, range_offset.y, range_offset.z, 0.0f };
     rain_particle_scene_ubo.WriteMemory(scene_shader_data);
 
-    gl_state_enable_blend();
-    gl_state_set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-    gl_state_enable_depth_test();
-    gl_state_set_depth_mask(GL_FALSE);
-    gl_state_active_bind_texture_2d(0, tex->glid);
+    gl_rend_state.enable_blend();
+    gl_rend_state.set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    gl_rend_state.enable_depth_test();
+    gl_rend_state.set_depth_mask(GL_FALSE);
+    gl_rend_state.active_bind_texture_2d(0, tex->glid);
     shaders_ft.set(SHADER_FT_RAIN);
 
     float_t tangent_sign = -rain->psize.x;
@@ -1341,7 +1341,7 @@ void rain_particle_draw() {
     rain_particle_scene_ubo.Bind(0);
     rain_particle_batch_ubo.Bind(1);
     rain_ssbo.Bind(0);
-    gl_state_bind_vertex_array(rctx_ptr->common_vao);
+    gl_rend_state.bind_vertex_array(rctx_ptr->common_vao);
     for (int32_t i = 0; i < 8; i++, first += count) {
         particle_data& data = rain_ptcl_data[i];
         vec3 pos_offset = data.position / range;
@@ -1355,10 +1355,10 @@ void rain_particle_draw() {
         rain_particle_batch_ubo.WriteMemory(batch_shader_data);
         shaders_ft.draw_arrays(GL_TRIANGLES, first, count);
     }
-    gl_state_bind_vertex_array(0);
-    gl_state_active_bind_texture_2d(0, 0);
-    gl_state_set_depth_mask(GL_TRUE);
-    gl_state_disable_blend();
+    gl_rend_state.bind_vertex_array(0);
+    gl_rend_state.active_bind_texture_2d(0, 0);
+    gl_rend_state.set_depth_mask(GL_TRUE);
+    gl_rend_state.disable_blend();
 }
 
 void particle_draw() {
@@ -1392,9 +1392,9 @@ void particle_draw() {
 
     shaders_ft.set(SHADER_FT_PARTICL);
     particle_scene_ubo.Bind(0);
-    gl_state_bind_vertex_array(ptcl_vao);
+    gl_rend_state.bind_vertex_array(ptcl_vao);
     shaders_ft.draw_arrays(GL_TRIANGLES, 0, count);
-    gl_state_bind_vertex_array(0);
+    gl_rend_state.bind_vertex_array(0);
 }
 
 void snow_particle_draw() {
@@ -1408,10 +1408,10 @@ void snow_particle_draw() {
     stage_param_snow* snow = stage_param_data_snow_current;
     draw_pass_set_camera();
 
-    gl_state_enable_blend();
-    gl_state_set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-    gl_state_enable_depth_test();
-    gl_state_set_depth_mask(GL_FALSE);
+    gl_rend_state.enable_blend();
+    gl_rend_state.set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    gl_rend_state.enable_depth_test();
+    gl_rend_state.set_depth_mask(GL_FALSE);
 
     float_t point_attenuation = powf(tanf((float_t)rctx_ptr->camera->get_fov()
         * 0.5f * DEG_TO_RAD_FLOAT) * 3.4f, 2.0f) * 0.1f;
@@ -1444,9 +1444,9 @@ void snow_particle_draw() {
     snow_batch.start_vertex_location.x = 0;
     snow_particle_batch_ubo.WriteMemory(snow_batch);
 
-    gl_state_active_bind_texture_2d(0, tex->glid);
-    gl_state_active_bind_texture_2d(1, rctx_ptr->render.rend_texture[0].GetDepthTex());
-    gl_state_bind_vertex_array(rctx_ptr->common_vao);
+    gl_rend_state.active_bind_texture_2d(0, tex->glid);
+    gl_rend_state.active_bind_texture_2d(1, rctx_ptr->render.rend_texture[0].GetDepthTex());
+    gl_rend_state.bind_vertex_array(rctx_ptr->common_vao);
 
     uniform_value[U_SNOW_PARTICLE] = 0;
     shaders_ft.set(SHADER_FT_SNOW_PT);
@@ -1491,13 +1491,13 @@ void snow_particle_draw() {
         first += count;
     }
 
-    gl_state_bind_vertex_array(0);
-    gl_state_active_bind_texture_2d(1, 0);
-    gl_state_active_bind_texture_2d(0, 0);
+    gl_rend_state.bind_vertex_array(0);
+    gl_rend_state.active_bind_texture_2d(1, 0);
+    gl_rend_state.active_bind_texture_2d(0, 0);
 
-    gl_state_disable_depth_test();
-    gl_state_set_depth_mask(GL_TRUE);
-    gl_state_disable_blend();
+    gl_rend_state.disable_depth_test();
+    gl_rend_state.set_depth_mask(GL_TRUE);
+    gl_rend_state.disable_blend();
 }
 
 void star_catalog_draw() {
@@ -2287,16 +2287,16 @@ void EffectFogRing::draw() {
     rctx->draw_state->set_fog_height(true);
     RenderTexture& rt = rctx->render_manager->get_render_texture(8);
     rt.Bind();
-    gl_state_set_viewport(0, 0,
+    gl_rend_state.set_viewport(0, 0,
         rt.color_texture->get_width_align_mip_level(),
         rt.color_texture->get_height_align_mip_level());
     glClearColor(density_offset, density_offset, density_offset, 1.0f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     if (rctx->disp_manager->get_obj_count(mdl::OBJ_TYPE_USER))
         rctx->disp_manager->draw(mdl::OBJ_TYPE_USER);
-    gl_state_bind_framebuffer(0);
+    gl_rend_state.bind_framebuffer(0);
     rctx->render_manager->set_effect_texture(rt.color_texture);
-    gl_state_get_error();
+    gl_get_error_print();
 }
 
 void EffectFogRing::init_particle_data() {
@@ -3076,7 +3076,7 @@ void EffectRipple::clear_tex() {
         glClearColor(0.0f, 0.0f, 0.0f, v5);
         rt->Bind();
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-        gl_state_bind_framebuffer(0);
+        gl_rend_state.bind_framebuffer(0);
     }
 
     glClearColor(clear_color.x, clear_color.y, clear_color.z, clear_color.w);
@@ -3122,7 +3122,7 @@ void EffectRipple::draw() {
     if (!stage_set)
         return;
 
-    gl_state_disable_cull_face();
+    gl_rend_state.disable_cull_face();
 
     render_context* rctx = rctx_ptr;
 
@@ -3138,22 +3138,22 @@ void EffectRipple::draw() {
 
         rt[(counter + 1) % 3]->Bind();
 
-        gl_state_rect viewport_rect = gl_state_get_viewport();
+        gl_rend_state_rect viewport_rect = gl_rend_state.get_viewport();
 
         int32_t width = rt[0]->GetWidth();
         int32_t height = rt[0]->GetHeight();
 
-        gl_state_set_viewport(1, 1, width - 2, height - 2);
+        gl_rend_state.set_viewport(1, 1, width - 2, height - 2);
 
         draw_pass_set_camera();
         glClear(GL_DEPTH_BUFFER_BIT);
         if (rctx->disp_manager->get_obj_count(mdl::OBJ_TYPE_USER)) {
-            gl_state_active_bind_texture_2d(7, rt[counter % 3]->GetColorTex());
+            gl_rend_state.active_bind_texture_2d(7, rt[counter % 3]->GetColorTex());
             rctx->disp_manager->draw(mdl::OBJ_TYPE_USER);
-            gl_state_active_bind_texture_2d(7, 0);
+            gl_rend_state.active_bind_texture_2d(7, 0);
         }
 
-        gl_state_bind_framebuffer(0);
+        gl_rend_state.bind_framebuffer(0);
 
         params.field_8 = 0.0005f;
         params.field_C = 0.97f;
@@ -3164,7 +3164,7 @@ void EffectRipple::draw() {
 
         sub_1403B6ED0(rt[(counter + 2) % 3], rt[(counter + 1) % 3], rt[counter % 3], params);
 
-        gl_state_set_viewport(viewport_rect);
+        gl_rend_state.set_viewport(viewport_rect);
 
         sub_1403584A0(rt[(counter + 2) % 3]);
 
@@ -3180,7 +3180,7 @@ void EffectRipple::draw() {
 
     update = false;
 
-    gl_state_enable_cull_face();
+    gl_rend_state.enable_cull_face();
 }
 
 void EffectRipple::reset() {
@@ -3301,7 +3301,7 @@ void EffectRipple::sub_1403584A0(RenderTexture* rt) {
     field_BB8.Bind();
 
     image_filter_scale(&field_BB8, rt->color_texture);
-    gl_state_bind_framebuffer(0);
+    gl_rend_state.bind_framebuffer(0);
 }
 
 void EffectRipple::sub_140358690() {
@@ -4081,20 +4081,20 @@ void water_particle::draw(mat4* mat) {
     scene_shader_data.g_size_in_projection.w = 60.0;
     water_particle_scene_ubo.WriteMemory(scene_shader_data);
 
-    gl_state_disable_cull_face();
+    gl_rend_state.disable_cull_face();
     shaders_ft.set(SHADER_FT_W_PTCL);
 
-    gl_state_bind_vertex_array(rctx_ptr->common_vao);
+    gl_rend_state.bind_vertex_array(rctx_ptr->common_vao);
     water_particle_scene_ubo.Bind(0);
     ssbo.Bind(0);
     texture* tex = texture_manager_get_texture(splash_tex_id);
     if (tex)
-        gl_state_active_bind_texture_2d(0, tex->glid);
+        gl_rend_state.active_bind_texture_2d(0, tex->glid);
     shaders_ft.draw_arrays(GL_TRIANGLES, 0, count * 6);
-    gl_state_bind_vertex_array(0);
+    gl_rend_state.bind_vertex_array(0);
 
     shader::unbind();
-    gl_state_enable_cull_face();
+    gl_rend_state.enable_cull_face();
 }
 
 void water_particle::free() {
@@ -5034,27 +5034,27 @@ void star_catalog_milky_way::draw(const mat4& vp, const mat4& mat, texture* tex,
     scene_shader_data.g_transform[3] = temp.row3;
     scene_ubo.WriteMemory(scene_shader_data);
 
-    gl_state_enable_cull_face();
-    gl_state_disable_blend();
-    gl_state_set_depth_mask(GL_FALSE);
-    gl_state_active_bind_texture_2d(0, tex->glid);
-    gl_state_bind_sampler(0, sampler);
-    gl_state_enable_primitive_restart();
-    gl_state_set_primitive_restart_index(restart_index);
+    gl_rend_state.enable_cull_face();
+    gl_rend_state.disable_blend();
+    gl_rend_state.set_depth_mask(GL_FALSE);
+    gl_rend_state.active_bind_texture_2d(0, tex->glid);
+    gl_rend_state.bind_sampler(0, sampler);
+    gl_rend_state.enable_primitive_restart();
+    gl_rend_state.set_primitive_restart_index(restart_index);
     uniform_value[U_STAR] = 1;
     shaders_ft.set(SHADER_FT_STAR);
 
-    gl_state_bind_vertex_array(vao);
+    gl_rend_state.bind_vertex_array(vao);
     scene_ubo.Bind(0);
     shaders_ft.draw_elements(GL_TRIANGLE_STRIP, idx_count, GL_UNSIGNED_SHORT, 0);
-    gl_state_bind_vertex_array(0);
+    gl_rend_state.bind_vertex_array(0);
 
-    gl_state_bind_sampler(0, 0);
-    gl_state_active_bind_texture_2d(0, 0);
-    gl_state_disable_primitive_restart();
-    gl_state_set_depth_mask(GL_TRUE);
-    gl_state_enable_blend();
-    gl_state_disable_cull_face();
+    gl_rend_state.bind_sampler(0, 0);
+    gl_rend_state.active_bind_texture_2d(0, 0);
+    gl_rend_state.disable_primitive_restart();
+    gl_rend_state.set_depth_mask(GL_TRUE);
+    gl_rend_state.enable_blend();
+    gl_rend_state.disable_cull_face();
 }
 
 void star_catalog_milky_way::reset() {
@@ -5130,11 +5130,11 @@ void star_catalog::draw() {
 
     uniform_value[U_STAR] = 0;
     shaders_ft.set(SHADER_FT_STAR);
-    gl_state_enable_blend();
-    gl_state_set_blend_func(GL_ONE, GL_ONE);
-    gl_state_enable_depth_test();
-    gl_state_set_depth_mask(false);
-    gl_state_bind_vertex_array(rctx_ptr->common_vao);
+    gl_rend_state.enable_blend();
+    gl_rend_state.set_blend_func(GL_ONE, GL_ONE);
+    gl_rend_state.enable_depth_test();
+    gl_rend_state.set_depth_mask(false);
+    gl_rend_state.bind_vertex_array(rctx_ptr->common_vao);
     for (int32_t i = 0; i < 2; i++) {
         stage_param_star_modifiers& modifiers = stage_param_data.modifiers[i];
 
@@ -5153,16 +5153,16 @@ void star_catalog::draw() {
         batch_ubo.Bind(1);
         stars_ssbo.Bind(0);
         if (i) {
-            gl_state_active_bind_texture_2d(0, star_b_tex->glid);
+            gl_rend_state.active_bind_texture_2d(0, star_b_tex->glid);
             shaders_ft.draw_arrays(GL_TRIANGLES, 0, star_b_count * 6);
         }
         else {
-            gl_state_active_bind_texture_2d(0, star_tex->glid);
+            gl_rend_state.active_bind_texture_2d(0, star_tex->glid);
             shaders_ft.draw_arrays(GL_TRIANGLES, 0, star_count * 6);
         }
     }
-    gl_state_active_bind_texture_2d(0, 0);
-    gl_state_bind_vertex_array(0);
+    gl_rend_state.active_bind_texture_2d(0, 0);
+    gl_rend_state.bind_vertex_array(0);
 
 }
 
@@ -5579,15 +5579,15 @@ static void draw_fog_particle(EffectFogRing* data, mat4* mat) {
         return;
 
     shaders_ft.set(SHADER_FT_FOGPTCL);
-    gl_state_enable_blend();
+    gl_rend_state.enable_blend();
     texture* tex = texture_manager_get_texture(data->tex_id);
     if (tex)
-        gl_state_active_bind_texture_2d(0, tex->glid);
-    gl_state_bind_vertex_array(rctx_ptr->common_vao);
+        gl_rend_state.active_bind_texture_2d(0, tex->glid);
+    gl_rend_state.bind_vertex_array(rctx_ptr->common_vao);
     data->ssbo.Bind(0);
     shaders_ft.draw_arrays(GL_TRIANGLES, 0, data->num_vtx);
-    gl_state_bind_vertex_array(0);
-    gl_state_disable_blend();
+    gl_rend_state.bind_vertex_array(0);
+    gl_rend_state.disable_blend();
     shader::unbind();
 }
 
@@ -5633,9 +5633,9 @@ static void draw_ripple_particles(ripple_struct* data, mat4* mat) {
     uniform_value[U_RIPPLE] = data->ripple_uniform;
     uniform_value[U_RIPPLE_EMIT] = data->ripple_emit_uniform;
 
-    gl_state_begin_event("EffectRipple::Impl::draw_ripple_particles");
-    gl_state_set_color_mask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);
-    gl_state_bind_vertex_array(rctx_ptr->common_vao);
+    gl_rend_state.begin_event("EffectRipple::Impl::draw_ripple_particles");
+    gl_rend_state.set_color_mask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);
+    gl_rend_state.bind_vertex_array(rctx_ptr->common_vao);
 
     shaders_ft.set(SHADER_FT_RIPEMIT);
     ripple_emit_scene_ubo.Bind(0);
@@ -5644,9 +5644,9 @@ static void draw_ripple_particles(ripple_struct* data, mat4* mat) {
 
     shader::unbind();
 
-    gl_state_bind_vertex_array(0);
-    gl_state_set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-    gl_state_end_event();
+    gl_rend_state.bind_vertex_array(0);
+    gl_rend_state.set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+    gl_rend_state.end_event();
 }
 
 static void draw_water_particle(water_particle* data, mat4* mat) {
@@ -6561,7 +6561,7 @@ static void sub_1403B6ED0(RenderTexture* a1, RenderTexture* a2, RenderTexture* a
     else
         uniform_value[U_RIPPLE] = 0;
     sub_1403B6F60(a1->color_texture, a2->color_texture, a3->color_texture, params);
-    gl_state_bind_framebuffer(0);
+    gl_rend_state.bind_framebuffer(0);
 }
 
 static void sub_1403B6F60(texture* a1, texture* a2, texture* a3, ripple_emit_params& params) {
@@ -6571,8 +6571,8 @@ static void sub_1403B6F60(texture* a1, texture* a2, texture* a3, ripple_emit_par
     int32_t width = a2->width;
     int32_t height = a2->height;
 
-    gl_state_rect viewport_rect = gl_state_get_viewport();
-    gl_state_set_viewport(1, 1, width - 2, height - 2);
+    gl_rend_state_rect viewport_rect = gl_rend_state.get_viewport();
+    gl_rend_state.set_viewport(1, 1, width - 2, height - 2);
 
     ripple_scene_shader_data ripple_scene = {};
     ripple_scene.g_transform = {
@@ -6586,16 +6586,16 @@ static void sub_1403B6F60(texture* a1, texture* a2, texture* a3, ripple_emit_par
     ripple_batch.g_params = { params.wake_attn, 0.0f, 0.0f, 0.0f };
     ripple_batch_ubo.WriteMemory(ripple_batch);
 
-    gl_state_bind_vertex_array(rctx_ptr->common_vao);
+    gl_rend_state.bind_vertex_array(rctx_ptr->common_vao);
     shaders_ft.set(SHADER_FT_RIPPLE);
     ripple_scene_ubo.Bind(0);
     ripple_batch_ubo.Bind(1);
-    gl_state_active_bind_texture_2d(0, a2->glid);
-    gl_state_active_bind_texture_2d(1, a3->glid);
+    gl_rend_state.active_bind_texture_2d(0, a2->glid);
+    gl_rend_state.active_bind_texture_2d(1, a3->glid);
     shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4);
-    gl_state_active_bind_texture_2d(1, 0);
-    gl_state_active_bind_texture_2d(0, 0);
-    gl_state_bind_vertex_array(0);
+    gl_rend_state.active_bind_texture_2d(1, 0);
+    gl_rend_state.active_bind_texture_2d(0, 0);
+    gl_rend_state.bind_vertex_array(0);
 
-    gl_state_set_viewport(viewport_rect);
+    gl_rend_state.set_viewport(viewport_rect);
 }

src/CRE/gl_rend_state.cpp

@@ -0,0 +1,570 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "gl_rend_state.hpp"
+
+gl_rend_state_struct gl_rend_state;
+
+void gl_rend_state_struct::active_bind_texture_2d(int32_t index, GLuint texture, bool force) {
+    if (force || texture_binding_2d[index] != texture) {
+        if (force || active_texture_index != index) {
+            glActiveTexture((GLenum)(GL_TEXTURE0 + index));
+            active_texture_index = (GLuint)index;
+        }
+        glBindTexture(GL_TEXTURE_2D, texture);
+        texture_binding_2d[index] = texture;
+    }
+}
+
+void gl_rend_state_struct::active_bind_texture_cube_map(int32_t index, GLuint texture, bool force) {
+    if (force || texture_binding_cube_map[index] != texture) {
+        if (force || active_texture_index != index) {
+            glActiveTexture((GLenum)(GL_TEXTURE0 + index));
+            active_texture_index = (GLuint)index;
+        }
+        glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
+        texture_binding_cube_map[index] = texture;
+    }
+}
+
+void gl_rend_state_struct::active_texture(size_t index, bool force) {
+    if (force || active_texture_index != index) {
+        glActiveTexture((GLenum)(GL_TEXTURE0 + index));
+        active_texture_index = (GLuint)index;
+    }
+}
+
+void gl_rend_state_struct::bind_framebuffer(GLuint framebuffer, bool force) {
+    if (force || read_framebuffer_binding != framebuffer
+        || draw_framebuffer_binding != framebuffer) {
+        glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
+        read_framebuffer_binding = framebuffer;
+        draw_framebuffer_binding = framebuffer;
+    }
+}
+
+void gl_rend_state_struct::bind_read_framebuffer(GLuint framebuffer, bool force) {
+    if (force || read_framebuffer_binding != framebuffer) {
+        glBindFramebuffer(GL_READ_FRAMEBUFFER, framebuffer);
+        read_framebuffer_binding = framebuffer;
+    }
+}
+
+void gl_rend_state_struct::bind_draw_framebuffer(GLuint framebuffer, bool force) {
+    if (force || draw_framebuffer_binding != framebuffer) {
+        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebuffer);
+        draw_framebuffer_binding = framebuffer;
+    }
+}
+
+void gl_rend_state_struct::bind_vertex_array(GLuint array, bool force) {
+    if (force || vertex_array_binding != array) {
+        glBindVertexArray(array);
+        vertex_array_binding = array;
+    }
+}
+
+void gl_rend_state_struct::bind_array_buffer(GLuint buffer, bool force) {
+    if (force || array_buffer_binding != buffer) {
+        glBindBuffer(GL_ARRAY_BUFFER, buffer);
+        array_buffer_binding = buffer;
+    }
+}
+
+void gl_rend_state_struct::bind_element_array_buffer(GLuint buffer, bool force) {
+    if (force || element_array_buffer_binding != buffer) {
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
+        element_array_buffer_binding = buffer;
+    }
+}
+
+void gl_rend_state_struct::bind_uniform_buffer(GLuint buffer, bool force) {
+    if (force || uniform_buffer_binding != buffer) {
+        glBindBuffer(GL_UNIFORM_BUFFER, buffer);
+        uniform_buffer_binding = buffer;
+    }
+}
+
+void gl_rend_state_struct::bind_uniform_buffer_base(GLuint index, GLuint buffer, bool force) {
+    if (force || uniform_buffer_bindings[index] != buffer) {
+        glBindBufferBase(GL_UNIFORM_BUFFER, index, buffer);
+        uniform_buffer_binding = buffer;
+        uniform_buffer_bindings[index] = buffer;
+        uniform_buffer_offsets[index] = 0;
+        uniform_buffer_sizes[index] = -1;
+    }
+}
+
+void gl_rend_state_struct::bind_uniform_buffer_range(GLuint index,
+    GLuint buffer, GLintptr offset, GLsizeiptr size, bool force) {
+    if (force || uniform_buffer_bindings[index] != buffer
+        || uniform_buffer_offsets[index] != offset
+        || uniform_buffer_sizes[index] != size) {
+        glBindBufferRange(GL_UNIFORM_BUFFER, index, buffer, offset, size);
+        uniform_buffer_binding = buffer;
+        uniform_buffer_bindings[index] = buffer;
+        uniform_buffer_offsets[index] = offset;
+        uniform_buffer_sizes[index] = size;
+    }
+}
+
+void gl_rend_state_struct::bind_shader_storage_buffer(GLuint buffer, bool force) {
+    if (force || shader_storage_buffer_binding != buffer) {
+        glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer);
+        shader_storage_buffer_binding = buffer;
+    }
+}
+
+void gl_rend_state_struct::bind_shader_storage_buffer_base(GLuint index, GLuint buffer, bool force) {
+    if (force || shader_storage_buffer_bindings[index] != buffer) {
+        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, index, buffer);
+        shader_storage_buffer_binding = buffer;
+        shader_storage_buffer_bindings[index] = buffer;
+        shader_storage_buffer_offsets[index] = 0;
+        shader_storage_buffer_sizes[index] = -1;
+    }
+}
+
+void gl_rend_state_struct::bind_shader_storage_buffer_range(GLuint index,
+    GLuint buffer, GLintptr offset, GLsizeiptr size, bool force) {
+    if (force || shader_storage_buffer_bindings[index] != buffer
+        || shader_storage_buffer_offsets[index] != offset
+        || shader_storage_buffer_sizes[index] != size) {
+        glBindBufferRange(GL_SHADER_STORAGE_BUFFER, index, buffer, offset, size);
+        shader_storage_buffer_binding = buffer;
+        shader_storage_buffer_bindings[index] = buffer;
+        shader_storage_buffer_offsets[index] = offset;
+        shader_storage_buffer_sizes[index] = size;
+    }
+}
+
+void gl_rend_state_struct::bind_texture_2d(GLuint texture, bool force) {
+    if (texture_binding_2d[active_texture_index] != texture) {
+        glBindTexture(GL_TEXTURE_2D, texture);
+        texture_binding_2d[active_texture_index] = texture;
+    }
+}
+
+void gl_rend_state_struct::bind_texture_cube_map(GLuint texture, bool force) {
+    if (force || texture_binding_cube_map[active_texture_index] != texture) {
+        glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
+        texture_binding_cube_map[active_texture_index] = texture;
+    }
+}
+
+void gl_rend_state_struct::bind_sampler(int32_t index, GLuint sampler, bool force) {
+    if (force || sampler_binding[index] != sampler) {
+        glBindSampler(index, sampler);
+        sampler_binding[index] = sampler;
+    }
+}
+
+bool gl_rend_state_struct::check_uniform_buffer_binding() {
+    return uniform_buffer_binding != 0;
+}
+
+bool gl_rend_state_struct::check_uniform_buffer_binding_base(size_t index) {
+    return uniform_buffer_bindings[index] != 0;
+}
+
+bool gl_rend_state_struct::check_shader_storage_buffer_binding() {
+    return shader_storage_buffer_binding != 0;
+}
+
+bool gl_rend_state_struct::check_shader_storage_buffer_binding_base(size_t index) {
+    return shader_storage_buffer_bindings[index] != 0;
+}
+
+bool gl_rend_state_struct::check_texture_binding_2d(size_t index) {
+    return texture_binding_2d[index] != 0;
+}
+
+bool gl_rend_state_struct::check_texture_binding_cube_map(size_t index) {
+    return texture_binding_cube_map[index] != 0;
+}
+
+bool gl_rend_state_struct::check_sampler_binding(int32_t index, GLuint sampler) {
+    return sampler_binding[index] != 0;
+}
+
+void gl_rend_state_struct::disable_blend(bool force) {
+    if (force || blend) {
+        glDisable(GL_BLEND);
+        blend = GL_FALSE;
+    }
+}
+
+void gl_rend_state_struct::disable_cull_face(bool force) {
+    if (force || cull_face) {
+        glDisable(GL_CULL_FACE);
+        cull_face = GL_FALSE;
+    }
+}
+
+void gl_rend_state_struct::disable_depth_test(bool force) {
+    if (force || depth_test) {
+        glDisable(GL_DEPTH_TEST);
+        depth_test = GL_FALSE;
+    }
+}
+
+void gl_rend_state_struct::disable_multisample(bool force) {
+    if (force || multisample) {
+        glDisable(GL_MULTISAMPLE);
+        multisample = GL_FALSE;
+    }
+}
+
+void gl_rend_state_struct::disable_primitive_restart(bool force) {
+    if (force || primitive_restart) {
+        glDisable(GL_PRIMITIVE_RESTART);
+        primitive_restart = GL_FALSE;
+    }
+}
+
+void gl_rend_state_struct::disable_scissor_test(bool force) {
+    if (force || scissor_test) {
+        glDisable(GL_SCISSOR_TEST);
+        scissor_test = GL_FALSE;
+    }
+}
+
+void gl_rend_state_struct::disable_stencil_test(bool force) {
+    if (force || stencil_test) {
+        glDisable(GL_STENCIL_TEST);
+        stencil_test = GL_FALSE;
+    }
+}
+
+void gl_rend_state_struct::enable_blend(bool force) {
+    if (force || !blend) {
+        glEnable(GL_BLEND);
+        blend = GL_TRUE;
+    }
+}
+
+void gl_rend_state_struct::enable_cull_face(bool force) {
+    if (force || !cull_face) {
+        glEnable(GL_CULL_FACE);
+        cull_face = GL_TRUE;
+    }
+}
+
+void gl_rend_state_struct::enable_depth_test(bool force) {
+    if (force || !depth_test) {
+        glEnable(GL_DEPTH_TEST);
+        depth_test = GL_TRUE;
+    }
+}
+
+void gl_rend_state_struct::enable_multisample(bool force) {
+    if (force || !multisample) {
+        glEnable(GL_MULTISAMPLE);
+        multisample = GL_TRUE;
+    }
+}
+
+void gl_rend_state_struct::enable_primitive_restart(bool force) {
+    if (force || !primitive_restart) {
+        glEnable(GL_PRIMITIVE_RESTART);
+        primitive_restart = GL_TRUE;
+    }
+}
+
+void gl_rend_state_struct::enable_scissor_test(bool force) {
+    if (force || !scissor_test) {
+        glEnable(GL_SCISSOR_TEST);
+        scissor_test = GL_TRUE;
+    }
+}
+
+void gl_rend_state_struct::enable_stencil_test(bool force) {
+    if (force || !stencil_test) {
+        glEnable(GL_STENCIL_TEST);
+        stencil_test = GL_TRUE;
+    }
+}
+
+void gl_rend_state_struct::get() {
+    glGetIntegerv(GL_CURRENT_PROGRAM, (GLint*)&program);
+    GLenum active_texture = GL_TEXTURE0;
+    glGetIntegerv(GL_ACTIVE_TEXTURE, (GLint*)&active_texture);
+    active_texture_index = active_texture - GL_TEXTURE0;
+
+    if (GLAD_GL_VERSION_4_5) {
+        for (GLuint i = 0; i < 32; i++) {
+            glGetIntegeri_v(GL_TEXTURE_BINDING_2D, i, (GLint*)&texture_binding_2d[i]);
+            glGetIntegeri_v(GL_TEXTURE_BINDING_CUBE_MAP, i, (GLint*)&texture_binding_cube_map[i]);
+            glGetIntegeri_v(GL_SAMPLER_BINDING, i, (GLint*)&sampler_binding[i]);
+        }
+    }
+    else {
+        for (GLuint i = 0; i < 32; i++) {
+            glActiveTexture((GLenum)(GL_TEXTURE0 + i));
+            glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*)&texture_binding_2d[i]);
+            glGetIntegerv(GL_TEXTURE_BINDING_CUBE_MAP, (GLint*)&texture_binding_cube_map[i]);
+            glGetIntegerv(GL_SAMPLER_BINDING, (GLint*)&sampler_binding[i]);
+        }
+        glActiveTexture(active_texture);
+    }
+
+    glGetBooleanv(GL_BLEND, &blend);
+    glGetIntegerv(GL_BLEND_SRC_RGB, (GLint*)&blend_src_rgb);
+    glGetIntegerv(GL_BLEND_SRC_ALPHA, (GLint*)&blend_src_alpha);
+    glGetIntegerv(GL_BLEND_DST_RGB, (GLint*)&blend_dst_rgb);
+    glGetIntegerv(GL_BLEND_DST_ALPHA, (GLint*)&blend_dst_alpha);
+    glGetIntegerv(GL_BLEND_EQUATION_RGB, (GLint*)&blend_mode_rgb);
+    glGetIntegerv(GL_BLEND_EQUATION_ALPHA, (GLint*)&blend_mode_alpha);
+
+    glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, (GLint*)&read_framebuffer_binding);
+    glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, (GLint*)&draw_framebuffer_binding);
+    glGetIntegerv(GL_VERTEX_ARRAY_BINDING, (GLint*)&vertex_array_binding);
+    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, (GLint*)&array_buffer_binding);
+    glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, (GLint*)&element_array_buffer_binding);
+
+    glGetIntegerv(GL_UNIFORM_BUFFER_BINDING, (GLint*)&uniform_buffer_binding);
+    for (GLuint i = 0; i < 14; i++) {
+        glGetIntegeri_v(GL_UNIFORM_BUFFER_BINDING, i, (GLint*)&uniform_buffer_bindings[i]);
+        glGetInteger64i_v(GL_UNIFORM_BUFFER_START, i, (GLint64*)&uniform_buffer_offsets[i]);
+        glGetInteger64i_v(GL_UNIFORM_BUFFER_SIZE, i, (GLint64*)&uniform_buffer_sizes[i]);
+    }
+
+    glGetIntegerv(GL_SHADER_STORAGE_BUFFER_BINDING, (GLint*)&shader_storage_buffer_binding);
+    for (GLuint i = 0; i < 14; i++) {
+        glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_BINDING, i, (GLint*)&shader_storage_buffer_bindings[i]);
+        glGetInteger64i_v(GL_SHADER_STORAGE_BUFFER_START, i, (GLint64*)&shader_storage_buffer_offsets[i]);
+        glGetInteger64i_v(GL_SHADER_STORAGE_BUFFER_SIZE, i, (GLint64*)&shader_storage_buffer_sizes[i]);
+    }
+
+    glGetBooleanv(GL_COLOR_WRITEMASK, color_mask);
+    glGetBooleanv(GL_CULL_FACE, &cull_face);
+    glGetIntegerv(GL_CULL_FACE_MODE, (GLint*)&cull_face_mode);
+    glGetBooleanv(GL_DEPTH_TEST, &depth_test);
+    glGetIntegerv(GL_DEPTH_FUNC, (GLint*)&depth_func);
+    glGetBooleanv(GL_DEPTH_WRITEMASK, &depth_mask);
+    glGetFloatv(GL_LINE_WIDTH, &line_width);
+    glGetBooleanv(GL_MULTISAMPLE, &multisample);
+    glGetBooleanv(GL_PRIMITIVE_RESTART, &primitive_restart);
+    glGetIntegerv(GL_PRIMITIVE_RESTART_INDEX, (GLint*)&primitive_restart_index);
+    glGetIntegerv(GL_SCISSOR_BOX, (GLint*)&scissor_box);
+    glGetBooleanv(GL_SCISSOR_TEST, &scissor_test);
+    glGetBooleanv(GL_STENCIL_TEST, &stencil_test);
+    glGetIntegerv(GL_STENCIL_FUNC, (GLint*)&stencil_func);
+    glGetIntegerv(GL_STENCIL_VALUE_MASK, (GLint*)&stencil_value_mask);
+    glGetIntegerv(GL_STENCIL_FAIL, (GLint*)&stencil_fail);
+    glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, (GLint*)&stencil_dpfail);
+    glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, (GLint*)&stencil_dppass);
+    glGetIntegerv(GL_STENCIL_REF, &stencil_ref);
+    glGetIntegerv(GL_STENCIL_WRITEMASK, (GLint*)&stencil_mask);
+    glGetIntegerv(GL_VIEWPORT, (GLint*)&viewport);
+
+    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+    polygon_mode = GL_FILL;
+}
+
+GLuint gl_rend_state_struct::get_program() {
+    return program;
+}
+
+gl_rend_state_rect gl_rend_state_struct::get_scissor() {
+    return scissor_box;
+}
+
+void gl_rend_state_struct::get_scissor(GLint& x, GLint& y, GLsizei& width, GLsizei& height) {
+    x = scissor_box.x;
+    y = scissor_box.y;
+    width = scissor_box.width;
+    height = scissor_box.height;
+}
+
+gl_rend_state_rect gl_rend_state_struct::get_viewport() {
+    return viewport;
+}
+
+void gl_rend_state_struct::get_viewport(GLint& x, GLint& y, GLsizei& width, GLsizei& height) {
+    x = viewport.x;
+    y = viewport.y;
+    width = viewport.width;
+    height = viewport.height;
+}
+
+void gl_rend_state_struct::set_blend_func(GLenum src, GLenum dst, bool force) {
+    if (force || blend_src_rgb != src || blend_dst_rgb != dst
+        || blend_src_alpha != GL_ONE || blend_dst_alpha != GL_ONE_MINUS_SRC_ALPHA) {
+        glBlendFuncSeparate(src, dst, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+        blend_src_rgb = src;
+        blend_dst_rgb = dst;
+        blend_src_alpha = GL_ONE;
+        blend_dst_alpha = GL_ONE_MINUS_SRC_ALPHA;
+    }
+}
+
+void gl_rend_state_struct::set_blend_func_separate(GLenum src_rgb, GLenum dst_rgb,
+    GLenum src_alpha, GLenum dst_alpha, bool force) {
+    if (force || blend_src_rgb != src_rgb || blend_dst_rgb != dst_rgb
+        || blend_src_alpha != src_alpha || blend_dst_alpha != dst_alpha) {
+        glBlendFuncSeparate(src_rgb, dst_rgb, src_alpha, dst_alpha);
+        blend_src_rgb = src_rgb;
+        blend_dst_rgb = dst_rgb;
+        blend_src_alpha = src_alpha;
+        blend_dst_alpha = dst_alpha;
+    }
+}
+
+void gl_rend_state_struct::set_blend_equation(GLenum mode, bool force) {
+    if (force || blend_mode_rgb != mode || blend_mode_alpha != mode) {
+        glBlendEquationSeparate(mode, mode);
+        blend_mode_rgb = mode;
+        blend_mode_alpha = mode;
+    }
+}
+
+void gl_rend_state_struct::set_blend_equation_separate(GLenum mode_rgb, GLenum mode_alpha, bool force) {
+    if (force || blend_mode_rgb != mode_rgb || blend_mode_alpha != mode_alpha) {
+        glBlendEquationSeparate(mode_rgb, mode_alpha);
+        blend_mode_rgb = mode_rgb;
+        blend_mode_alpha = mode_alpha;
+    }
+}
+
+void gl_rend_state_struct::set_color_mask(GLboolean red, GLboolean green,
+    GLboolean blue, GLboolean alpha, bool force) {
+    if (force || color_mask[0] != red || color_mask[1] != green
+        || color_mask[2] != blue || color_mask[3] != alpha) {
+        glColorMask(red, green, blue, alpha);
+        color_mask[0] = red;
+        color_mask[1] = green;
+        color_mask[2] = blue;
+        color_mask[3] = alpha;
+    }
+}
+
+void gl_rend_state_struct::set_cull_face_mode(GLenum mode, bool force) {
+    if (force || cull_face_mode != mode) {
+        glCullFace(mode);
+        cull_face_mode = mode;
+    }
+}
+
+void gl_rend_state_struct::set_depth_func(GLenum func, bool force) {
+    if (force || depth_func != func) {
+        glDepthFunc(func);
+        depth_func = func;
+    }
+}
+
+void gl_rend_state_struct::set_depth_mask(GLboolean flag, bool force) {
+    if (force || depth_mask != flag) {
+        glDepthMask(flag);
+        depth_mask = flag;
+    }
+}
+
+void gl_rend_state_struct::set_line_width(GLfloat width, bool force) {
+    if (force || line_width != width) {
+        glLineWidth(width);
+        line_width = width;
+    }
+}
+
+void gl_rend_state_struct::set_polygon_mode(GLenum face, GLenum mode, bool force) {
+    switch (face) {
+    case GL_FRONT:
+        if (force || polygon_mode != mode) {
+            glPolygonMode(GL_FRONT, mode);
+            polygon_mode = mode;
+        }
+        break;
+    case GL_BACK:
+        if (force || polygon_mode != mode) {
+            glPolygonMode(GL_BACK, mode);
+            polygon_mode = mode;
+        }
+        break;
+    case GL_FRONT_AND_BACK:
+        if (force || polygon_mode != mode) {
+            glPolygonMode(GL_FRONT_AND_BACK, mode);
+            polygon_mode = mode;
+        }
+        break;
+    }
+}
+
+void gl_rend_state_struct::set_primitive_restart_index(GLuint index, bool force) {
+    if (force || primitive_restart_index != index) {
+        glPrimitiveRestartIndex(index);
+        primitive_restart_index = index;
+    }
+}
+
+void gl_rend_state_struct::set_scissor(const gl_rend_state_rect& rect, bool force) {
+    if (force || scissor_box.x != rect.x || scissor_box.y != rect.y
+        || scissor_box.width != rect.width || scissor_box.height != rect.height) {
+        glScissor(rect.x, rect.y, rect.width, rect.height);
+        scissor_box = rect;
+    }
+}
+
+void gl_rend_state_struct::set_scissor(GLint x, GLint y, GLsizei width, GLsizei height, bool force) {
+    if (force || scissor_box.x != x || scissor_box.y != y
+        || scissor_box.width != width || scissor_box.height != height) {
+        glScissor(x, y, width, height);
+        scissor_box.x = x;
+        scissor_box.y = y;
+        scissor_box.width = width;
+        scissor_box.height = height;
+    }
+}
+
+void gl_rend_state_struct::set_stencil_func(GLenum func, GLint ref, GLuint mask, bool force) {
+    if (force || stencil_func != func || stencil_ref != ref || stencil_value_mask != mask) {
+        glStencilFunc(func, ref, mask);
+        stencil_func = func;
+        stencil_ref = ref;
+        stencil_value_mask = mask;
+    }
+}
+
+void gl_rend_state_struct::set_stencil_mask(GLuint mask, bool force) {
+    if (force || stencil_mask != mask) {
+        glStencilMask(mask);
+        stencil_mask = mask;
+    }
+}
+
+void gl_rend_state_struct::set_stencil_op(GLenum sfail, GLenum dpfail, GLenum dppass, bool force) {
+    if (force || stencil_fail != sfail || stencil_dpfail != dpfail || stencil_dppass != dppass) {
+        glStencilOp(sfail, dpfail, dppass);
+        stencil_fail = sfail;
+        stencil_dpfail = dpfail;
+        stencil_dppass = dppass;
+    }
+}
+
+void gl_rend_state_struct::set_viewport(const gl_rend_state_rect& rect, bool force) {
+    if (force || viewport.x != rect.x || viewport.y != rect.y
+        || viewport.width != rect.width || viewport.height != rect.height) {
+        glViewport(rect.x, rect.y, rect.width, rect.height);
+        viewport = rect;
+    }
+}
+
+void gl_rend_state_struct::set_viewport(GLint x, GLint y, GLsizei width, GLsizei height, bool force) {
+    if (force || viewport.x != x || viewport.y != y
+        || viewport.width != width || viewport.height != height) {
+        glViewport(x, y, width, height);
+        viewport.x = x;
+        viewport.y = y;
+        viewport.width = width;
+        viewport.height = height;
+    }
+}
+
+void gl_rend_state_struct::use_program(GLuint program, bool force) {
+    if (force || this->program != program) {
+        glUseProgram(program);
+        this->program = program;
+    }
+}

src/CRE/gl_rend_state.hpp

@@ -0,0 +1,147 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include "../KKdLib/default.hpp"
+#include "gl.hpp"
+
+struct gl_rend_state_rect {
+    GLint x;
+    GLint y;
+    GLsizei width;
+    GLsizei height;
+};
+
+struct gl_rend_state_struct {
+    GLuint program;
+    GLuint active_texture_index;
+    GLuint texture_binding_2d[32];
+    GLuint texture_binding_cube_map[32];
+    GLuint sampler_binding[32];
+    GLboolean blend;
+    GLenum blend_src_rgb;
+    GLenum blend_src_alpha;
+    GLenum blend_dst_rgb;
+    GLenum blend_dst_alpha;
+    GLenum blend_mode_rgb;
+    GLenum blend_mode_alpha;
+    GLuint read_framebuffer_binding;
+    GLuint draw_framebuffer_binding;
+    GLuint vertex_array_binding;
+    GLuint array_buffer_binding;
+    GLuint element_array_buffer_binding;
+    GLuint uniform_buffer_binding;
+    GLuint uniform_buffer_bindings[14];
+    GLintptr uniform_buffer_offsets[14];
+    GLsizeiptr uniform_buffer_sizes[14];
+    GLuint shader_storage_buffer_binding;
+    GLuint shader_storage_buffer_bindings[14];
+    GLintptr shader_storage_buffer_offsets[14];
+    GLsizeiptr shader_storage_buffer_sizes[14];
+    GLboolean color_mask[4];
+    GLboolean cull_face;
+    GLenum cull_face_mode;
+    GLboolean depth_test;
+    GLenum depth_func;
+    GLboolean depth_mask;
+    GLfloat line_width;
+    GLenum polygon_mode;
+    GLboolean multisample;
+    GLboolean primitive_restart;
+    GLuint primitive_restart_index;
+    gl_rend_state_rect scissor_box;
+    GLboolean scissor_test;
+    GLboolean stencil_test;
+    GLenum stencil_func;
+    GLenum stencil_fail;
+    GLenum stencil_dpfail;
+    GLenum stencil_dppass;
+    GLuint stencil_mask;
+    GLint stencil_ref;
+    GLuint stencil_value_mask;
+    gl_rend_state_rect viewport;
+
+    void active_bind_texture_2d(int32_t index, GLuint texture, bool force = false);
+    void active_bind_texture_cube_map(int32_t index, GLuint texture, bool force = false);
+    void active_texture(size_t index, bool force = false);
+    void bind_framebuffer(GLuint framebuffer, bool force = false);
+    void bind_read_framebuffer(GLuint framebuffer, bool force = false);
+    void bind_draw_framebuffer(GLuint framebuffer, bool force = false);
+    void bind_vertex_array(GLuint array, bool force = false);
+    void bind_array_buffer(GLuint buffer, bool force = false);
+    void bind_element_array_buffer(GLuint buffer, bool force = false);
+    void bind_uniform_buffer(GLuint buffer, bool force = false);
+    void bind_uniform_buffer_base(GLuint index, GLuint buffer, bool force = false);
+    void bind_uniform_buffer_range(GLuint index,
+        GLuint buffer, GLintptr offset, GLsizeiptr size, bool force = false);
+    void bind_shader_storage_buffer(GLuint buffer, bool force = false);
+    void bind_shader_storage_buffer_base(GLuint index, GLuint buffer, bool force = false);
+    void bind_shader_storage_buffer_range(GLuint index,
+        GLuint buffer, GLintptr offset, GLsizeiptr size, bool force = false);
+    void bind_texture_2d(GLuint texture, bool force = false);
+    void bind_texture_cube_map(GLuint texture, bool force = false);
+    void bind_sampler(int32_t index, GLuint sampler, bool force = false);
+    bool check_uniform_buffer_binding();
+    bool check_uniform_buffer_binding_base(size_t index);
+    bool check_shader_storage_buffer_binding();
+    bool check_shader_storage_buffer_binding_base(size_t index);
+    bool check_texture_binding_2d(size_t index);
+    bool check_texture_binding_cube_map(size_t index);
+    bool check_sampler_binding(int32_t index, GLuint sampler);
+    void disable_blend(bool force = false);
+    void disable_cull_face(bool force = false);
+    void disable_depth_test(bool force = false);
+    void disable_multisample(bool force = false);
+    void disable_primitive_restart(bool force = false);
+    void disable_scissor_test(bool force = false);
+    void disable_stencil_test(bool force = false);
+    void enable_blend(bool force = false);
+    void enable_cull_face(bool force = false);
+    void enable_depth_test(bool force = false);
+    void enable_multisample(bool force = false);
+    void enable_primitive_restart(bool force = false);
+    void enable_scissor_test(bool force = false);
+    void enable_stencil_test(bool force = false);
+    void get();
+    GLuint get_program();
+    gl_rend_state_rect get_scissor();
+    void get_scissor(GLint& x, GLint& y, GLsizei& width, GLsizei& height);
+    gl_rend_state_rect get_viewport();
+    void get_viewport(GLint& x, GLint& y, GLsizei& width, GLsizei& height);
+    void set_blend_func(GLenum src, GLenum dst, bool force = false);
+    void set_blend_func_separate(GLenum src_rgb, GLenum dst_rgb,
+        GLenum src_alpha, GLenum dst_alpha, bool force = false);
+    void set_blend_equation(GLenum mode, bool force = false);
+    void set_blend_equation_separate(
+        GLenum mode_rgb, GLenum mode_alpha, bool force = false);
+    void set_color_mask(GLboolean red, GLboolean green,
+        GLboolean blue, GLboolean alpha, bool force = false);
+    void set_cull_face_mode(GLenum mode, bool force = false);
+    void set_depth_func(GLenum func, bool force = false);
+    void set_depth_mask(GLboolean flag, bool force = false);
+    void set_line_width(GLfloat width, bool force = false);
+    void set_polygon_mode(GLenum face, GLenum mode, bool force = false);
+    void set_primitive_restart_index(GLuint index, bool force = false);
+    void set_scissor(const gl_rend_state_rect& rect, bool force = false);
+    void set_scissor(GLint x, GLint y, GLsizei width, GLsizei height, bool force = false);
+    void set_stencil_func(GLenum func, GLint ref, GLuint mask, bool force = false);
+    void set_stencil_mask(GLuint mask, bool force = false);
+    void set_stencil_op(GLenum sfail, GLenum dpfail, GLenum dppass, bool force = false);
+    void set_viewport(const gl_rend_state_rect& rect, bool force = false);
+    void set_viewport(GLint x, GLint y, GLsizei width, GLsizei height, bool force = false);
+    void use_program(GLuint program, bool force = false);
+
+    template <size_t size>
+    inline void begin_event(const char(&str)[size]) {
+        glPushDebugGroup(GL_DEBUG_SOURCE_APPLICATION, 0, (GLsizei)(size - 1), str);
+    }
+
+    inline void end_event() {
+        glPopDebugGroup();
+    }
+};
+
+extern gl_rend_state_struct gl_rend_state;

src/CRE/gl_state.cpp

@@ -1,585 +0,0 @@
-/*
-    by korenkonder
-    GitHub/GitLab: korenkonder
-*/
-
-#include "gl_state.hpp"
-
-gl_state_struct gl_state;
-
-void gl_state_active_bind_texture_2d(int32_t index, GLuint texture, bool force) {
-    if (force || gl_state.texture_binding_2d[index] != texture) {
-        if (force || gl_state.active_texture_index != index) {
-            glActiveTexture((GLenum)(GL_TEXTURE0 + index));
-            gl_state.active_texture_index = (GLuint)index;
-        }
-        glBindTexture(GL_TEXTURE_2D, texture);
-        gl_state.texture_binding_2d[index] = texture;
-    }
-}
-
-void gl_state_active_bind_texture_cube_map(int32_t index, GLuint texture, bool force) {
-    if (force || gl_state.texture_binding_cube_map[index] != texture) {
-        if (force || gl_state.active_texture_index != index) {
-            glActiveTexture((GLenum)(GL_TEXTURE0 + index));
-            gl_state.active_texture_index = (GLuint)index;
-        }
-        glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
-        gl_state.texture_binding_cube_map[index] = texture;
-    }
-}
-
-void gl_state_active_texture(size_t index, bool force) {
-    if (force || gl_state.active_texture_index != index) {
-        glActiveTexture((GLenum)(GL_TEXTURE0 + index));
-        gl_state.active_texture_index = (GLuint)index;
-    }
-}
-
-void gl_state_bind_framebuffer(GLuint framebuffer, bool force) {
-    if (force || gl_state.read_framebuffer_binding != framebuffer
-        || gl_state.draw_framebuffer_binding != framebuffer) {
-        glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
-        gl_state.read_framebuffer_binding = framebuffer;
-        gl_state.draw_framebuffer_binding = framebuffer;
-    }
-}
-
-void gl_state_bind_read_framebuffer(GLuint framebuffer, bool force) {
-    if (force || gl_state.read_framebuffer_binding != framebuffer) {
-        glBindFramebuffer(GL_READ_FRAMEBUFFER, framebuffer);
-        gl_state.read_framebuffer_binding = framebuffer;
-    }
-}
-
-void gl_state_bind_draw_framebuffer(GLuint framebuffer, bool force) {
-    if (force || gl_state.draw_framebuffer_binding != framebuffer) {
-        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebuffer);
-        gl_state.draw_framebuffer_binding = framebuffer;
-    }
-}
-
-void gl_state_bind_vertex_array(GLuint array, bool force) {
-    if (force || gl_state.vertex_array_binding != array) {
-        glBindVertexArray(array);
-        gl_state.vertex_array_binding = array;
-    }
-}
-
-void gl_state_bind_array_buffer(GLuint buffer, bool force) {
-    if (force || gl_state.array_buffer_binding != buffer) {
-        glBindBuffer(GL_ARRAY_BUFFER, buffer);
-        gl_state.array_buffer_binding = buffer;
-    }
-}
-
-void gl_state_bind_element_array_buffer(GLuint buffer, bool force) {
-    if (force || gl_state.element_array_buffer_binding != buffer) {
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
-        gl_state.element_array_buffer_binding = buffer;
-    }
-}
-
-void gl_state_bind_uniform_buffer(GLuint buffer, bool force) {
-    if (force || gl_state.uniform_buffer_binding != buffer) {
-        glBindBuffer(GL_UNIFORM_BUFFER, buffer);
-        gl_state.uniform_buffer_binding = buffer;
-    }
-}
-
-void gl_state_bind_uniform_buffer_base(GLuint index, GLuint buffer, bool force) {
-    if (force || gl_state.uniform_buffer_bindings[index] != buffer) {
-        glBindBufferBase(GL_UNIFORM_BUFFER, index, buffer);
-        gl_state.uniform_buffer_binding = buffer;
-        gl_state.uniform_buffer_bindings[index] = buffer;
-        gl_state.uniform_buffer_offsets[index] = 0;
-        gl_state.uniform_buffer_sizes[index] = -1;
-    }
-}
-
-void gl_state_bind_uniform_buffer_range(GLuint index,
-    GLuint buffer, GLintptr offset, GLsizeiptr size, bool force) {
-    if (force || gl_state.uniform_buffer_bindings[index] != buffer
-        || gl_state.uniform_buffer_offsets[index] != offset
-        || gl_state.uniform_buffer_sizes[index] != size) {
-        glBindBufferRange(GL_UNIFORM_BUFFER, index, buffer, offset, size);
-        gl_state.uniform_buffer_binding = buffer;
-        gl_state.uniform_buffer_bindings[index] = buffer;
-        gl_state.uniform_buffer_offsets[index] = offset;
-        gl_state.uniform_buffer_sizes[index] = size;
-    }
-}
-
-void gl_state_bind_shader_storage_buffer(GLuint buffer, bool force) {
-    if (force || gl_state.shader_storage_buffer_binding != buffer) {
-        glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer);
-        gl_state.shader_storage_buffer_binding = buffer;
-    }
-}
-
-void gl_state_bind_shader_storage_buffer_base(GLuint index, GLuint buffer, bool force) {
-    if (force || gl_state.shader_storage_buffer_bindings[index] != buffer) {
-        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, index, buffer);
-        gl_state.shader_storage_buffer_binding = buffer;
-        gl_state.shader_storage_buffer_bindings[index] = buffer;
-        gl_state.shader_storage_buffer_offsets[index] = 0;
-        gl_state.shader_storage_buffer_sizes[index] = -1;
-    }
-}
-
-void gl_state_bind_shader_storage_buffer_range(GLuint index,
-    GLuint buffer, GLintptr offset, GLsizeiptr size, bool force) {
-    if (force || gl_state.shader_storage_buffer_bindings[index] != buffer
-        || gl_state.shader_storage_buffer_offsets[index] != offset
-        || gl_state.shader_storage_buffer_sizes[index] != size) {
-        glBindBufferRange(GL_SHADER_STORAGE_BUFFER, index, buffer, offset, size);
-        gl_state.shader_storage_buffer_binding = buffer;
-        gl_state.shader_storage_buffer_bindings[index] = buffer;
-        gl_state.shader_storage_buffer_offsets[index] = offset;
-        gl_state.shader_storage_buffer_sizes[index] = size;
-    }
-}
-
-void gl_state_bind_texture_2d(GLuint texture, bool force) {
-    if (gl_state.texture_binding_2d[gl_state.active_texture_index] != texture) {
-        glBindTexture(GL_TEXTURE_2D, texture);
-        gl_state.texture_binding_2d[gl_state.active_texture_index] = texture;
-    }
-}
-
-void gl_state_bind_texture_cube_map(GLuint texture, bool force) {
-    if (force || gl_state.texture_binding_cube_map[gl_state.active_texture_index] != texture) {
-        glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
-        gl_state.texture_binding_cube_map[gl_state.active_texture_index] = texture;
-    }
-}
-
-void gl_state_bind_sampler(int32_t index, GLuint sampler, bool force) {
-    if (force || gl_state.sampler_binding[index] != sampler) {
-        glBindSampler(index, sampler);
-        gl_state.sampler_binding[index] = sampler;
-    }
-}
-
-bool gl_state_check_uniform_buffer_binding() {
-    return gl_state.uniform_buffer_binding != 0;
-}
-
-bool gl_state_check_uniform_buffer_binding_base(size_t index) {
-    return gl_state.uniform_buffer_bindings[index] != 0;
-}
-
-bool gl_state_check_shader_storage_buffer_binding() {
-    return gl_state.shader_storage_buffer_binding != 0;
-}
-
-bool gl_state_check_shader_storage_buffer_binding_base(size_t index) {
-    return gl_state.shader_storage_buffer_bindings[index] != 0;
-}
-
-bool gl_state_check_texture_binding_2d(size_t index) {
-    return gl_state.texture_binding_2d[index] != 0;
-}
-
-bool gl_state_check_texture_binding_cube_map(size_t index) {
-    return gl_state.texture_binding_cube_map[index] != 0;
-}
-
-bool gl_state_check_sampler_binding(int32_t index, GLuint sampler) {
-    return gl_state.sampler_binding[index] != 0;
-}
-
-void gl_state_disable_blend(bool force) {
-    if (force || gl_state.blend) {
-        glDisable(GL_BLEND);
-        gl_state.blend = GL_FALSE;
-    }
-}
-
-void gl_state_disable_cull_face(bool force) {
-    if (force || gl_state.cull_face) {
-        glDisable(GL_CULL_FACE);
-        gl_state.cull_face = GL_FALSE;
-    }
-}
-
-void gl_state_disable_depth_test(bool force) {
-    if (force || gl_state.depth_test) {
-        glDisable(GL_DEPTH_TEST);
-        gl_state.depth_test = GL_FALSE;
-    }
-}
-
-void gl_state_disable_multisample(bool force) {
-    if (force || gl_state.multisample) {
-        glDisable(GL_MULTISAMPLE);
-        gl_state.multisample = GL_FALSE;
-    }
-}
-
-void gl_state_disable_primitive_restart(bool force) {
-    if (force || gl_state.primitive_restart) {
-        glDisable(GL_PRIMITIVE_RESTART);
-        gl_state.primitive_restart = GL_FALSE;
-    }
-}
-
-void gl_state_disable_scissor_test(bool force) {
-    if (force || gl_state.scissor_test) {
-        glDisable(GL_SCISSOR_TEST);
-        gl_state.scissor_test = GL_FALSE;
-    }
-}
-
-void gl_state_disable_stencil_test(bool force) {
-    if (force || gl_state.stencil_test) {
-        glDisable(GL_STENCIL_TEST);
-        gl_state.stencil_test = GL_FALSE;
-    }
-}
-
-void gl_state_enable_blend(bool force) {
-    if (force || !gl_state.blend) {
-        glEnable(GL_BLEND);
-        gl_state.blend = GL_TRUE;
-    }
-}
-
-void gl_state_enable_cull_face(bool force) {
-    if (force || !gl_state.cull_face) {
-        glEnable(GL_CULL_FACE);
-        gl_state.cull_face = GL_TRUE;
-    }
-}
-
-void gl_state_enable_depth_test(bool force) {
-    if (force || !gl_state.depth_test) {
-        glEnable(GL_DEPTH_TEST);
-        gl_state.depth_test = GL_TRUE;
-    }
-}
-
-void gl_state_enable_multisample(bool force) {
-    if (force || !gl_state.multisample) {
-        glEnable(GL_MULTISAMPLE);
-        gl_state.multisample = GL_TRUE;
-    }
-}
-
-void gl_state_enable_primitive_restart(bool force) {
-    if (force || !gl_state.primitive_restart) {
-        glEnable(GL_PRIMITIVE_RESTART);
-        gl_state.primitive_restart = GL_TRUE;
-    }
-}
-
-void gl_state_enable_scissor_test(bool force) {
-    if (force || !gl_state.scissor_test) {
-        glEnable(GL_SCISSOR_TEST);
-        gl_state.scissor_test = GL_TRUE;
-    }
-}
-
-void gl_state_enable_stencil_test(bool force) {
-    if (force || !gl_state.stencil_test) {
-        glEnable(GL_STENCIL_TEST);
-        gl_state.stencil_test = GL_TRUE;
-    }
-}
-
-void gl_state_get() {
-    glGetIntegerv(GL_CURRENT_PROGRAM, (GLint*)&gl_state.program);
-    GLenum active_texture = GL_TEXTURE0;
-    glGetIntegerv(GL_ACTIVE_TEXTURE, (GLint*)&active_texture);
-    gl_state.active_texture_index = active_texture - GL_TEXTURE0;
-
-    if (GLAD_GL_VERSION_4_5) {
-        for (GLuint i = 0; i < 32; i++) {
-            glGetIntegeri_v(GL_TEXTURE_BINDING_2D, i, (GLint*)&gl_state.texture_binding_2d[i]);
-            glGetIntegeri_v(GL_TEXTURE_BINDING_CUBE_MAP, i, (GLint*)&gl_state.texture_binding_cube_map[i]);
-            glGetIntegeri_v(GL_SAMPLER_BINDING, i, (GLint*)&gl_state.sampler_binding[i]);
-        }
-    }
-    else {
-        for (GLuint i = 0; i < 32; i++) {
-            glActiveTexture((GLenum)(GL_TEXTURE0 + i));
-            glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*)&gl_state.texture_binding_2d[i]);
-            glGetIntegerv(GL_TEXTURE_BINDING_CUBE_MAP, (GLint*)&gl_state.texture_binding_cube_map[i]);
-            glGetIntegerv(GL_SAMPLER_BINDING, (GLint*)&gl_state.sampler_binding[i]);
-        }
-        glActiveTexture(active_texture);
-    }
-
-    glGetBooleanv(GL_BLEND, &gl_state.blend);
-    glGetIntegerv(GL_BLEND_SRC_RGB, (GLint*)&gl_state.blend_src_rgb);
-    glGetIntegerv(GL_BLEND_SRC_ALPHA, (GLint*)&gl_state.blend_src_alpha);
-    glGetIntegerv(GL_BLEND_DST_RGB, (GLint*)&gl_state.blend_dst_rgb);
-    glGetIntegerv(GL_BLEND_DST_ALPHA, (GLint*)&gl_state.blend_dst_alpha);
-    glGetIntegerv(GL_BLEND_EQUATION_RGB, (GLint*)&gl_state.blend_mode_rgb);
-    glGetIntegerv(GL_BLEND_EQUATION_ALPHA, (GLint*)&gl_state.blend_mode_alpha);
-
-    glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, (GLint*)&gl_state.read_framebuffer_binding);
-    glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, (GLint*)&gl_state.draw_framebuffer_binding);
-    glGetIntegerv(GL_VERTEX_ARRAY_BINDING, (GLint*)&gl_state.vertex_array_binding);
-    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, (GLint*)&gl_state.array_buffer_binding);
-    glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, (GLint*)&gl_state.element_array_buffer_binding);
-
-    glGetIntegerv(GL_UNIFORM_BUFFER_BINDING, (GLint*)&gl_state.uniform_buffer_binding);
-    for (GLuint i = 0; i < 14; i++) {
-        glGetIntegeri_v(GL_UNIFORM_BUFFER_BINDING, i, (GLint*)&gl_state.uniform_buffer_bindings[i]);
-        glGetInteger64i_v(GL_UNIFORM_BUFFER_START, i, (GLint64*)&gl_state.uniform_buffer_offsets[i]);
-        glGetInteger64i_v(GL_UNIFORM_BUFFER_SIZE, i, (GLint64*)&gl_state.uniform_buffer_sizes[i]);
-    }
-
-    glGetIntegerv(GL_SHADER_STORAGE_BUFFER_BINDING, (GLint*)&gl_state.shader_storage_buffer_binding);
-    for (GLuint i = 0; i < 14; i++) {
-        glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_BINDING, i, (GLint*)&gl_state.shader_storage_buffer_bindings[i]);
-        glGetInteger64i_v(GL_SHADER_STORAGE_BUFFER_START, i, (GLint64*)&gl_state.shader_storage_buffer_offsets[i]);
-        glGetInteger64i_v(GL_SHADER_STORAGE_BUFFER_SIZE, i, (GLint64*)&gl_state.shader_storage_buffer_sizes[i]);
-    }
-
-    glGetBooleanv(GL_COLOR_WRITEMASK, gl_state.color_mask);
-    glGetBooleanv(GL_CULL_FACE, &gl_state.cull_face);
-    glGetIntegerv(GL_CULL_FACE_MODE, (GLint*)&gl_state.cull_face_mode);
-    glGetBooleanv(GL_DEPTH_TEST, &gl_state.depth_test);
-    glGetIntegerv(GL_DEPTH_FUNC, (GLint*)&gl_state.depth_func);
-    glGetBooleanv(GL_DEPTH_WRITEMASK, &gl_state.depth_mask);
-    glGetFloatv(GL_LINE_WIDTH, &gl_state.line_width);
-    glGetBooleanv(GL_MULTISAMPLE, &gl_state.multisample);
-    glGetBooleanv(GL_PRIMITIVE_RESTART, &gl_state.primitive_restart);
-    glGetIntegerv(GL_PRIMITIVE_RESTART_INDEX, (GLint*)&gl_state.primitive_restart_index);
-    glGetIntegerv(GL_SCISSOR_BOX, (GLint*)&gl_state.scissor_box);
-    glGetBooleanv(GL_SCISSOR_TEST, &gl_state.scissor_test);
-    glGetBooleanv(GL_STENCIL_TEST, &gl_state.stencil_test);
-    glGetIntegerv(GL_STENCIL_FUNC, (GLint*)&gl_state.stencil_func);
-    glGetIntegerv(GL_STENCIL_VALUE_MASK, (GLint*)&gl_state.stencil_value_mask);
-    glGetIntegerv(GL_STENCIL_FAIL, (GLint*)&gl_state.stencil_fail);
-    glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, (GLint*)&gl_state.stencil_dpfail);
-    glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, (GLint*)&gl_state.stencil_dppass);
-    glGetIntegerv(GL_STENCIL_REF, &gl_state.stencil_ref);
-    glGetIntegerv(GL_STENCIL_WRITEMASK, (GLint*)&gl_state.stencil_mask);
-    glGetIntegerv(GL_VIEWPORT, (GLint*)&gl_state.viewport);
-
-    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-    gl_state.polygon_mode = GL_FILL;
-}
-
-void gl_state_get_all_gl_errors() {
-    GLenum error;
-    while (error = glGetError())
-        printf_debug("GL Error: 0x%04X\n", error);
-}
-
-GLenum gl_state_get_error() {
-    GLenum error = glGetError();
-    if (error)
-        printf_debug("GL Error: 0x%04X\n", error);
-    return error;
-}
-
-GLuint gl_state_get_program() {
-    return gl_state.program;
-}
-
-gl_state_rect gl_state_get_scissor() {
-    return gl_state.scissor_box;
-}
-
-void gl_state_get_scissor(GLint& x, GLint& y, GLsizei& width, GLsizei& height) {
-    x = gl_state.scissor_box.x;
-    y = gl_state.scissor_box.y;
-    width = gl_state.scissor_box.width;
-    height = gl_state.scissor_box.height;
-}
-
-gl_state_rect gl_state_get_viewport() {
-    return gl_state.viewport;
-}
-
-void gl_state_get_viewport(GLint& x, GLint& y, GLsizei& width, GLsizei& height) {
-    x = gl_state.viewport.x;
-    y = gl_state.viewport.y;
-    width = gl_state.viewport.width;
-    height = gl_state.viewport.height;
-}
-
-void gl_state_set_blend_func(GLenum src, GLenum dst, bool force) {
-    if (force || gl_state.blend_src_rgb != src || gl_state.blend_dst_rgb != dst
-        || gl_state.blend_src_alpha != GL_ONE || gl_state.blend_dst_alpha != GL_ONE_MINUS_SRC_ALPHA) {
-        glBlendFuncSeparate(src, dst, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
-        gl_state.blend_src_rgb = src;
-        gl_state.blend_dst_rgb = dst;
-        gl_state.blend_src_alpha = GL_ONE;
-        gl_state.blend_dst_alpha = GL_ONE_MINUS_SRC_ALPHA;
-    }
-}
-
-void gl_state_set_blend_func_separate(GLenum src_rgb, GLenum dst_rgb,
-    GLenum src_alpha, GLenum dst_alpha, bool force) {
-    if (force || gl_state.blend_src_rgb != src_rgb || gl_state.blend_dst_rgb != dst_rgb
-        || gl_state.blend_src_alpha != src_alpha || gl_state.blend_dst_alpha != dst_alpha) {
-        glBlendFuncSeparate(src_rgb, dst_rgb, src_alpha, dst_alpha);
-        gl_state.blend_src_rgb = src_rgb;
-        gl_state.blend_dst_rgb = dst_rgb;
-        gl_state.blend_src_alpha = src_alpha;
-        gl_state.blend_dst_alpha = dst_alpha;
-    }
-}
-
-void gl_state_set_blend_equation(GLenum mode, bool force) {
-    if (force || gl_state.blend_mode_rgb != mode || gl_state.blend_mode_alpha != mode) {
-        glBlendEquationSeparate(mode, mode);
-        gl_state.blend_mode_rgb = mode;
-        gl_state.blend_mode_alpha = mode;
-    }
-}
-
-void gl_state_set_blend_equation_separate(GLenum mode_rgb, GLenum mode_alpha, bool force) {
-    if (force || gl_state.blend_mode_rgb != mode_rgb || gl_state.blend_mode_alpha != mode_alpha) {
-        glBlendEquationSeparate(mode_rgb, mode_alpha);
-        gl_state.blend_mode_rgb = mode_rgb;
-        gl_state.blend_mode_alpha = mode_alpha;
-    }
-}
-
-void gl_state_set_color_mask(GLboolean red, GLboolean green,
-    GLboolean blue, GLboolean alpha, bool force) {
-    if (force || gl_state.color_mask[0] != red || gl_state.color_mask[1] != green
-        || gl_state.color_mask[2] != blue || gl_state.color_mask[3] != alpha) {
-        glColorMask(red, green, blue, alpha);
-        gl_state.color_mask[0] = red;
-        gl_state.color_mask[1] = green;
-        gl_state.color_mask[2] = blue;
-        gl_state.color_mask[3] = alpha;
-    }
-}
-
-void gl_state_set_cull_face_mode(GLenum mode, bool force) {
-    if (force || gl_state.cull_face_mode != mode) {
-        glCullFace(mode);
-        gl_state.cull_face_mode = mode;
-    }
-}
-
-void gl_state_set_depth_func(GLenum func, bool force) {
-    if (force || gl_state.depth_func != func) {
-        glDepthFunc(func);
-        gl_state.depth_func = func;
-    }
-}
-
-void gl_state_set_depth_mask(GLboolean flag, bool force) {
-    if (force || gl_state.depth_mask != flag) {
-        glDepthMask(flag);
-        gl_state.depth_mask = flag;
-    }
-}
-
-void gl_state_set_line_width(GLfloat width, bool force) {
-    if (force || gl_state.line_width != width) {
-        glLineWidth(width);
-        gl_state.line_width = width;
-    }
-}
-
-void gl_state_set_polygon_mode(GLenum face, GLenum mode, bool force) {
-    switch (face) {
-    case GL_FRONT:
-        if (force || gl_state.polygon_mode != mode) {
-            glPolygonMode(GL_FRONT, mode);
-            gl_state.polygon_mode = mode;
-        }
-        break;
-    case GL_BACK:
-        if (force || gl_state.polygon_mode != mode) {
-            glPolygonMode(GL_BACK, mode);
-            gl_state.polygon_mode = mode;
-        }
-        break;
-    case GL_FRONT_AND_BACK:
-        if (force || gl_state.polygon_mode != mode) {
-            glPolygonMode(GL_FRONT_AND_BACK, mode);
-            gl_state.polygon_mode = mode;
-        }
-        break;
-    }
-}
-
-void gl_state_set_primitive_restart_index(GLuint index, bool force) {
-    if (force || gl_state.primitive_restart_index != index) {
-        glPrimitiveRestartIndex(index);
-        gl_state.primitive_restart_index = index;
-    }
-}
-
-void gl_state_set_scissor(const gl_state_rect& rect, bool force) {
-    if (force || gl_state.scissor_box.x != rect.x || gl_state.scissor_box.y != rect.y
-        || gl_state.scissor_box.width != rect.width || gl_state.scissor_box.height != rect.height) {
-        glScissor(rect.x, rect.y, rect.width, rect.height);
-        gl_state.scissor_box = rect;
-    }
-}
-
-void gl_state_set_scissor(GLint x, GLint y, GLsizei width, GLsizei height, bool force) {
-    if (force || gl_state.scissor_box.x != x || gl_state.scissor_box.y != y
-        || gl_state.scissor_box.width != width || gl_state.scissor_box.height != height) {
-        glScissor(x, y, width, height);
-        gl_state.scissor_box.x = x;
-        gl_state.scissor_box.y = y;
-        gl_state.scissor_box.width = width;
-        gl_state.scissor_box.height = height;
-    }
-}
-
-void gl_state_set_stencil_func(GLenum func, GLint ref, GLuint mask, bool force) {
-    if (force || gl_state.stencil_func != func
-        || gl_state.stencil_ref != ref || gl_state.stencil_value_mask != mask) {
-        glStencilFunc(func, ref, mask);
-        gl_state.stencil_func = func;
-        gl_state.stencil_ref = ref;
-        gl_state.stencil_value_mask = mask;
-    }
-}
-
-void gl_state_set_stencil_mask(GLuint mask, bool force) {
-    if (force || gl_state.stencil_mask != mask) {
-        glStencilMask(mask);
-        gl_state.stencil_mask = mask;
-    }
-}
-
-void gl_state_set_stencil_op(GLenum sfail, GLenum dpfail, GLenum dppass, bool force) {
-    if (force || gl_state.stencil_fail != sfail
-        || gl_state.stencil_dpfail != dpfail || gl_state.stencil_dppass != dppass) {
-        glStencilOp(sfail, dpfail, dppass);
-        gl_state.stencil_fail = sfail;
-        gl_state.stencil_dpfail = dpfail;
-        gl_state.stencil_dppass = dppass;
-    }
-}
-
-void gl_state_set_viewport(const gl_state_rect& rect, bool force) {
-    if (force || gl_state.viewport.x != rect.x || gl_state.viewport.y != rect.y
-        || gl_state.viewport.width != rect.width || gl_state.viewport.height != rect.height) {
-        glViewport(rect.x, rect.y, rect.width, rect.height);
-        gl_state.viewport = rect;
-    }
-}
-
-void gl_state_set_viewport(GLint x, GLint y, GLsizei width, GLsizei height, bool force) {
-    if (force || gl_state.viewport.x != x || gl_state.viewport.y != y
-        || gl_state.viewport.width != width || gl_state.viewport.height != height) {
-        glViewport(x, y, width, height);
-        gl_state.viewport.x = x;
-        gl_state.viewport.y = y;
-        gl_state.viewport.width = width;
-        gl_state.viewport.height = height;
-    }
-}
-
-void gl_state_use_program(GLuint program, bool force) {
-    if (force || gl_state.program != program) {
-        glUseProgram(program);
-        gl_state.program = program;
-    }
-}

src/CRE/gl_state.hpp

@@ -1,149 +0,0 @@
-/*
-    by korenkonder
-    GitHub/GitLab: korenkonder
-*/
-
-#pragma once
-
-#include "../KKdLib/default.hpp"
-#include "gl.hpp"
-
-struct gl_state_rect {
-    GLint x;
-    GLint y;
-    GLsizei width;
-    GLsizei height;
-};
-
-struct gl_state_struct {
-    GLuint program;
-    GLuint active_texture_index;
-    GLuint texture_binding_2d[32];
-    GLuint texture_binding_cube_map[32];
-    GLuint sampler_binding[32];
-    GLboolean blend;
-    GLenum blend_src_rgb;
-    GLenum blend_src_alpha;
-    GLenum blend_dst_rgb;
-    GLenum blend_dst_alpha;
-    GLenum blend_mode_rgb;
-    GLenum blend_mode_alpha;
-    GLuint read_framebuffer_binding;
-    GLuint draw_framebuffer_binding;
-    GLuint vertex_array_binding;
-    GLuint array_buffer_binding;
-    GLuint element_array_buffer_binding;
-    GLuint uniform_buffer_binding;
-    GLuint uniform_buffer_bindings[14];
-    GLintptr uniform_buffer_offsets[14];
-    GLsizeiptr uniform_buffer_sizes[14];
-    GLuint shader_storage_buffer_binding;
-    GLuint shader_storage_buffer_bindings[14];
-    GLintptr shader_storage_buffer_offsets[14];
-    GLsizeiptr shader_storage_buffer_sizes[14];
-    GLboolean color_mask[4];
-    GLboolean cull_face;
-    GLenum cull_face_mode;
-    GLboolean depth_test;
-    GLenum depth_func;
-    GLboolean depth_mask;
-    GLfloat line_width;
-    GLenum polygon_mode;
-    GLboolean multisample;
-    GLboolean primitive_restart;
-    GLuint primitive_restart_index;
-    gl_state_rect scissor_box;
-    GLboolean scissor_test;
-    GLboolean stencil_test;
-    GLenum stencil_func;
-    GLenum stencil_fail;
-    GLenum stencil_dpfail;
-    GLenum stencil_dppass;
-    GLuint stencil_mask;
-    GLint stencil_ref;
-    GLuint stencil_value_mask;
-    gl_state_rect viewport;
-};
-
-extern gl_state_struct gl_state;
-
-extern void gl_state_active_bind_texture_2d(int32_t index, GLuint texture, bool force = false);
-extern void gl_state_active_bind_texture_cube_map(int32_t index, GLuint texture, bool force = false);
-extern void gl_state_active_texture(size_t index, bool force = false);
-extern void gl_state_bind_framebuffer(GLuint framebuffer, bool force = false);
-extern void gl_state_bind_read_framebuffer(GLuint framebuffer, bool force = false);
-extern void gl_state_bind_draw_framebuffer(GLuint framebuffer, bool force = false);
-extern void gl_state_bind_vertex_array(GLuint array, bool force = false);
-extern void gl_state_bind_array_buffer(GLuint buffer, bool force = false);
-extern void gl_state_bind_element_array_buffer(GLuint buffer, bool force = false);
-extern void gl_state_bind_uniform_buffer(GLuint buffer, bool force = false);
-extern void gl_state_bind_uniform_buffer_base(GLuint index, GLuint buffer, bool force = false);
-extern void gl_state_bind_uniform_buffer_range(GLuint index,
-    GLuint buffer, GLintptr offset, GLsizeiptr size, bool force = false);
-extern void gl_state_bind_shader_storage_buffer(GLuint buffer, bool force = false);
-extern void gl_state_bind_shader_storage_buffer_base(GLuint index, GLuint buffer, bool force = false);
-extern void gl_state_bind_shader_storage_buffer_range(GLuint index,
-    GLuint buffer, GLintptr offset, GLsizeiptr size, bool force = false);
-extern void gl_state_bind_texture_2d(GLuint texture, bool force = false);
-extern void gl_state_bind_texture_cube_map(GLuint texture, bool force = false);
-extern void gl_state_bind_sampler(int32_t index, GLuint sampler, bool force = false);
-extern bool gl_state_check_uniform_buffer_binding();
-extern bool gl_state_check_uniform_buffer_binding_base(size_t index);
-extern bool gl_state_check_shader_storage_buffer_binding();
-extern bool gl_state_check_shader_storage_buffer_binding_base(size_t index);
-extern bool gl_state_check_texture_binding_2d(size_t index);
-extern bool gl_state_check_texture_binding_cube_map(size_t index);
-extern bool gl_state_check_sampler_binding(int32_t index, GLuint sampler);
-extern void gl_state_disable_blend(bool force = false);
-extern void gl_state_disable_cull_face(bool force = false);
-extern void gl_state_disable_depth_test(bool force = false);
-extern void gl_state_disable_multisample(bool force = false);
-extern void gl_state_disable_primitive_restart(bool force = false);
-extern void gl_state_disable_scissor_test(bool force = false);
-extern void gl_state_disable_stencil_test(bool force = false);
-extern void gl_state_enable_blend(bool force = false);
-extern void gl_state_enable_cull_face(bool force = false);
-extern void gl_state_enable_depth_test(bool force = false);
-extern void gl_state_enable_multisample(bool force = false);
-extern void gl_state_enable_primitive_restart(bool force = false);
-extern void gl_state_enable_scissor_test(bool force = false);
-extern void gl_state_enable_stencil_test(bool force = false);
-extern void gl_state_get();
-extern void gl_state_get_all_gl_errors();
-extern GLenum gl_state_get_error();
-extern GLuint gl_state_get_program();
-extern gl_state_rect gl_state_get_scissor();
-extern void gl_state_get_scissor(GLint& x, GLint& y, GLsizei& width, GLsizei& height);
-extern gl_state_rect gl_state_get_viewport();
-extern void gl_state_get_viewport(GLint& x, GLint& y, GLsizei& width, GLsizei& height);
-extern void gl_state_set_blend_func(GLenum src, GLenum dst, bool force = false);
-extern void gl_state_set_blend_func_separate(GLenum src_rgb, GLenum dst_rgb,
-    GLenum src_alpha, GLenum dst_alpha, bool force = false);
-extern void gl_state_set_blend_equation(GLenum mode, bool force = false);
-extern void gl_state_set_blend_equation_separate(
-    GLenum mode_rgb, GLenum mode_alpha, bool force = false);
-extern void gl_state_set_color_mask(GLboolean red, GLboolean green,
-    GLboolean blue, GLboolean alpha, bool force = false);
-extern void gl_state_set_cull_face_mode(GLenum mode, bool force = false);
-extern void gl_state_set_depth_func(GLenum func, bool force = false);
-extern void gl_state_set_depth_mask(GLboolean flag, bool force = false);
-extern void gl_state_set_line_width(GLfloat width, bool force = false);
-extern void gl_state_set_polygon_mode(GLenum face, GLenum mode, bool force = false);
-extern void gl_state_set_primitive_restart_index(GLuint index, bool force = false);
-extern void gl_state_set_scissor(const gl_state_rect& rect, bool force = false);
-extern void gl_state_set_scissor(GLint x, GLint y, GLsizei width, GLsizei height, bool force = false);
-extern void gl_state_set_stencil_func(GLenum func, GLint ref, GLuint mask, bool force = false);
-extern void gl_state_set_stencil_mask(GLuint mask, bool force = false);
-extern void gl_state_set_stencil_op(GLenum sfail, GLenum dpfail, GLenum dppass, bool force = false);
-extern void gl_state_set_viewport(const gl_state_rect& rect, bool force = false);
-extern void gl_state_set_viewport(GLint x, GLint y, GLsizei width, GLsizei height, bool force = false);
-extern void gl_state_use_program(GLuint program, bool force = false);
-
-template <size_t size>
-inline void gl_state_begin_event(const char(&str)[size]) {
-    glPushDebugGroup(GL_DEBUG_SOURCE_APPLICATION, 0, (GLsizei)(size - 1), str);
-}
-
-inline void gl_state_end_event() {
-    glPopDebugGroup();
-}

src/CRE/light_param.cpp

@@ -157,7 +157,7 @@ void light_param_data_storage_data_set_ibl() {
     };
 
     for (int32_t i = 0; i < 5; i++)
-        gl_state_active_bind_texture_cube_map(ibl_texture_index[i],
+        gl_rend_state.active_bind_texture_cube_map(ibl_texture_index[i],
             light_param_data_storage_data->textures[i]);
 }
 

src/CRE/mdl/disp_manager.cpp

@@ -2105,12 +2105,12 @@ namespace mdl {
         void(*func)(render_context * rctx, const ObjSubMeshArgs * args) = draw_sub_mesh_default;
 
         for (int32_t i = 0; i < 5; i++)
-            gl_state_active_bind_texture_2d(i, rctx->empty_texture_2d->glid);
-        gl_state_active_bind_texture_cube_map(5, rctx->empty_texture_cube_map->glid);
-        gl_state_active_texture(0);
-        gl_state_set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+            gl_rend_state.active_bind_texture_2d(i, rctx->empty_texture_2d->glid);
+        gl_rend_state.active_bind_texture_cube_map(5, rctx->empty_texture_cube_map->glid);
+        gl_rend_state.active_texture(0);
+        gl_rend_state.set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
         uniform_value_reset();
-        gl_state_get();
+        gl_rend_state.get();
 
         switch (type) {
         case OBJ_TYPE_TRANSLUCENT:
@@ -2118,7 +2118,7 @@ namespace mdl {
             if (depth_mask)
                 func = draw_sub_mesh_translucent;
             else
-                gl_state_set_depth_mask(GL_FALSE);
+                gl_rend_state.set_depth_mask(GL_FALSE);
 
             alpha_test = 1;
             min_alpha = 0.0f;
@@ -2137,12 +2137,12 @@ namespace mdl {
             break;
         case OBJ_TYPE_TYPE_6:
             func = draw_sub_mesh_translucent;
-            gl_state_set_color_mask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+            gl_rend_state.set_color_mask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
             rctx->draw_state->shader_index = SHADER_FT_SIL;
             break;
         case OBJ_TYPE_TYPE_7:
             func = draw_sub_mesh_translucent;
-            gl_state_set_color_mask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+            gl_rend_state.set_color_mask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
             rctx->draw_state->shader_index = SHADER_FT_SIL;
 
             alpha_test = 1;
@@ -2150,7 +2150,7 @@ namespace mdl {
             alpha_threshold = 0.99999994f;
             break;
         case OBJ_TYPE_REFLECT_CHARA_OPAQUE:
-            gl_state_set_cull_face_mode(GL_FRONT);
+            gl_rend_state.set_cull_face_mode(GL_FRONT);
 
             if (!reflect_draw) {
                 if (reflect)
@@ -2160,7 +2160,7 @@ namespace mdl {
             }
             break;
         case OBJ_TYPE_REFLECT_CHARA_TRANSLUCENT:
-            gl_state_set_cull_face_mode(GL_FRONT);
+            gl_rend_state.set_cull_face_mode(GL_FRONT);
 
             min_alpha = 0.0f;
 
@@ -2172,7 +2172,7 @@ namespace mdl {
             }
             break;
         case OBJ_TYPE_REFLECT_CHARA_TRANSPARENT:
-            gl_state_set_cull_face_mode(GL_FRONT);
+            gl_rend_state.set_cull_face_mode(GL_FRONT);
 
             alpha_test = 1;
             min_alpha = 0.1f;
@@ -2190,18 +2190,18 @@ namespace mdl {
             alpha_threshold = 0.5f;
 
             if (reflect_draw)
-                gl_state_set_cull_face_mode(GL_FRONT);
+                gl_rend_state.set_cull_face_mode(GL_FRONT);
             else if (!reflect_texture_mask)
                 func = draw_sub_mesh_reflect_reflect_map;
             break;
         case OBJ_TYPE_REFLECT_TRANSLUCENT:
-            gl_state_set_depth_mask(GL_FALSE);
+            gl_rend_state.set_depth_mask(GL_FALSE);
 
             min_alpha = 0.0f;
             alpha_threshold = 0.0f;
 
             if (reflect_draw)
-                gl_state_set_cull_face_mode(GL_FRONT);
+                gl_rend_state.set_cull_face_mode(GL_FRONT);
             break;
         case OBJ_TYPE_REFLECT_TRANSPARENT:
             alpha_test = 1;
@@ -2209,10 +2209,10 @@ namespace mdl {
             alpha_threshold = 0.5f;
 
             if (reflect_draw)
-                gl_state_set_cull_face_mode(GL_FRONT);
+                gl_rend_state.set_cull_face_mode(GL_FRONT);
             break;
         case OBJ_TYPE_REFRACT_TRANSLUCENT:
-            gl_state_set_depth_mask(GL_FALSE);
+            gl_rend_state.set_depth_mask(GL_FALSE);
 
             min_alpha = 0.0f;
             alpha_threshold = 0.0f;
@@ -2226,7 +2226,7 @@ namespace mdl {
             func = draw_sub_mesh_sss;
 
             if (reflect_draw)
-                gl_state_set_cull_face_mode(GL_FRONT);
+                gl_rend_state.set_cull_face_mode(GL_FRONT);
             break;
         case OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_1:
         case OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_2:
@@ -2238,7 +2238,7 @@ namespace mdl {
         case OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_1:
         case OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_2:
         case OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_3:
-            gl_state_set_depth_mask(GL_FALSE);
+            gl_rend_state.set_depth_mask(GL_FALSE);
 
             alpha_test = 1;
             min_alpha = 0.0f;
@@ -2295,53 +2295,53 @@ namespace mdl {
         case OBJ_TYPE_TRANSLUCENT:
         case OBJ_TYPE_TRANSLUCENT_SORT_BY_RADIUS:
             if (!depth_mask)
-                gl_state_set_depth_mask(GL_TRUE);
+                gl_rend_state.set_depth_mask(GL_TRUE);
             break;
         case OBJ_TYPE_TYPE_6:
         case OBJ_TYPE_TYPE_7:
             rctx_ptr->draw_state->shader_index = -1;
-            gl_state_set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+            gl_rend_state.set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
             break;
         case OBJ_TYPE_REFLECT_CHARA_OPAQUE:
         case OBJ_TYPE_REFLECT_CHARA_TRANSLUCENT:
         case OBJ_TYPE_REFLECT_CHARA_TRANSPARENT:
-            gl_state_set_cull_face_mode(GL_BACK);
+            gl_rend_state.set_cull_face_mode(GL_BACK);
             break;
         case OBJ_TYPE_REFLECT_OPAQUE:
             if (reflect_draw)
-                gl_state_set_cull_face_mode(GL_FRONT);
+                gl_rend_state.set_cull_face_mode(GL_FRONT);
             break;
         case OBJ_TYPE_REFLECT_TRANSLUCENT:
             if (reflect_draw)
-                gl_state_set_cull_face_mode(GL_FRONT);
-            gl_state_set_depth_mask(GL_TRUE);
+                gl_rend_state.set_cull_face_mode(GL_FRONT);
+            gl_rend_state.set_depth_mask(GL_TRUE);
             break;
         case OBJ_TYPE_REFLECT_TRANSPARENT:
             if (reflect_draw)
-                gl_state_set_cull_face_mode(GL_FRONT);
+                gl_rend_state.set_cull_face_mode(GL_FRONT);
             break;
         case OBJ_TYPE_REFRACT_TRANSLUCENT:
             if (reflect_draw)
-                gl_state_set_cull_face_mode(GL_FRONT);
-            gl_state_set_depth_mask(GL_TRUE);
+                gl_rend_state.set_cull_face_mode(GL_FRONT);
+            gl_rend_state.set_depth_mask(GL_TRUE);
             break;
         case OBJ_TYPE_SSS:
             if (reflect_draw)
-                gl_state_set_cull_face_mode(GL_BACK);
+                gl_rend_state.set_cull_face_mode(GL_BACK);
             break;
         case OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_1:
         case OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_2:
         case OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_3:
-            gl_state_set_depth_mask(GL_TRUE);
+            gl_rend_state.set_depth_mask(GL_TRUE);
             break;
         }
 
         uniform_value_reset();
-        gl_state_bind_vertex_array(0);
+        gl_rend_state.bind_vertex_array(0);
         shader::unbind();
-        gl_state_set_blend_func(GL_ONE, GL_ZERO);
+        gl_rend_state.set_blend_func(GL_ONE, GL_ZERO);
         for (int32_t i = 0; i < 5; i++)
-            gl_state_bind_sampler(i, 0);
+            gl_rend_state.bind_sampler(i, 0);
     }
 
     void DispManager::draw(mdl::ObjTypeLocal type, int32_t depth_mask, bool reflect_texture_mask) {
@@ -2356,19 +2356,19 @@ namespace mdl {
         void(*func)(render_context * rctx, const ObjSubMeshArgs * args) = draw_sub_mesh_default;
 
         for (int32_t i = 0; i < 5; i++)
-            gl_state_active_bind_texture_2d(i, rctx->empty_texture_2d->glid);
-        gl_state_active_bind_texture_cube_map(5, rctx->empty_texture_cube_map->glid);
-        gl_state_active_texture(0);
-        gl_state_set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+            gl_rend_state.active_bind_texture_2d(i, rctx->empty_texture_2d->glid);
+        gl_rend_state.active_bind_texture_cube_map(5, rctx->empty_texture_cube_map->glid);
+        gl_rend_state.active_texture(0);
+        gl_rend_state.set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
         uniform_value_reset();
-        gl_state_get();
+        gl_rend_state.get();
 
         switch (type) {
         case OBJ_TYPE_LOCAL_TRANSLUCENT:
             if (depth_mask)
                 func = draw_sub_mesh_translucent;
             else
-                gl_state_set_depth_mask(GL_FALSE);
+                gl_rend_state.set_depth_mask(GL_FALSE);
 
             alpha_test = 1;
             min_alpha = 0.0f;
@@ -2399,16 +2399,16 @@ namespace mdl {
         switch (type) {
         case OBJ_TYPE_LOCAL_TRANSLUCENT:
             if (!depth_mask)
-                gl_state_set_depth_mask(GL_TRUE);
+                gl_rend_state.set_depth_mask(GL_TRUE);
             break;
         }
 
         uniform_value_reset();
-        gl_state_bind_vertex_array(0);
+        gl_rend_state.bind_vertex_array(0);
         shader::unbind();
-        gl_state_set_blend_func(GL_ONE, GL_ZERO);
+        gl_rend_state.set_blend_func(GL_ONE, GL_ZERO);
         for (int32_t i = 0; i < 5; i++)
-            gl_state_bind_sampler(i, 0);
+            gl_rend_state.bind_sampler(i, 0);
     }
 
     void DispManager::draw(mdl::ObjTypeReflect type, int32_t depth_mask, bool reflect_texture_mask) {
@@ -2424,25 +2424,25 @@ namespace mdl {
         void(*func)(render_context * rctx, const ObjSubMeshArgs * args) = draw_sub_mesh_default;
 
         for (int32_t i = 0; i < 5; i++)
-            gl_state_active_bind_texture_2d(i, rctx->empty_texture_2d->glid);
-        gl_state_active_bind_texture_cube_map(5, rctx->empty_texture_cube_map->glid);
-        gl_state_active_texture(0);
-        gl_state_set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+            gl_rend_state.active_bind_texture_2d(i, rctx->empty_texture_2d->glid);
+        gl_rend_state.active_bind_texture_cube_map(5, rctx->empty_texture_cube_map->glid);
+        gl_rend_state.active_texture(0);
+        gl_rend_state.set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
         uniform_value_reset();
-        gl_state_get();
+        gl_rend_state.get();
 
         switch (type) {
         case OBJ_TYPE_REFLECT_TRANSLUCENT_SORT_BY_RADIUS:
             if (depth_mask)
                 func = draw_sub_mesh_translucent;
             else
-                gl_state_set_depth_mask(GL_FALSE);
+                gl_rend_state.set_depth_mask(GL_FALSE);
 
             alpha_test = 1;
             min_alpha = 0.0f;
             alpha_threshold = 0.0f;
 
-            gl_state_set_cull_face_mode(GL_FRONT);
+            gl_rend_state.set_cull_face_mode(GL_FRONT);
             break;
         }
         rctx->set_batch_alpha_threshold(alpha_threshold);
@@ -2464,16 +2464,16 @@ namespace mdl {
         switch (type) {
         case OBJ_TYPE_REFLECT_TRANSLUCENT_SORT_BY_RADIUS:
             if (!depth_mask)
-                gl_state_set_cull_face_mode(GL_BACK);
+                gl_rend_state.set_cull_face_mode(GL_BACK);
             break;
         }
 
         uniform_value_reset();
-        gl_state_bind_vertex_array(0);
+        gl_rend_state.bind_vertex_array(0);
         shader::unbind();
-        gl_state_set_blend_func(GL_ONE, GL_ZERO);
+        gl_rend_state.set_blend_func(GL_ONE, GL_ZERO);
         for (int32_t i = 0; i < 5; i++)
-            gl_state_bind_sampler(i, 0);
+            gl_rend_state.bind_sampler(i, 0);
     }
 
     /*void DispManager::draw_show_vector(ObjType type, int32_t show_vector) {
@@ -2483,12 +2483,12 @@ namespace mdl {
         render_context* rctx = rctx_ptr;
 
         for (int32_t i = 0; i < 5; i++)
-            gl_state_active_bind_texture_2d(i, rctx->empty_texture_2d);
-        gl_state_active_bind_texture_cube_map(5, rctx->empty_texture_cube_map);
-        gl_state_active_texture(0);
-        gl_state_set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+            gl_rend_state.active_bind_texture_2d(i, rctx->empty_texture_2d);
+        gl_rend_state.active_bind_texture_cube_map(5, rctx->empty_texture_cube_map);
+        gl_rend_state.active_texture(0);
+        gl_rend_state.set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
         uniform_value_reset();
-        gl_state_get();
+        gl_rend_state.get();
 
         for (ObjData*& i : obj[type]) {
             switch (i->type) {
@@ -2503,7 +2503,7 @@ namespace mdl {
             } break;
             }
         }
-        gl_state_set_blend_func(GL_ONE, GL_ZERO);
+        gl_rend_state.set_blend_func(GL_ONE, GL_ZERO);
     }*/
 
     void DispManager::entry_list(ObjType type, ObjData* data) {

src/CRE/mdl/draw_object.cpp

@@ -108,7 +108,7 @@ namespace mdl {
         else
             rctx->set_batch_blend_color_offset_color(color, 0.0f);
 
-        gl_state_bind_vertex_array(vao);
+        gl_rend_state.bind_vertex_array(vao);
         //rctx->set_shader(SHADER_FT_SIMPLE);
         rctx->set_shader(etc->constant ? SHADER_FT_CONSTANT : SHADER_FT_SIMPLE);
         rctx->set_render_data();
@@ -117,11 +117,11 @@ namespace mdl {
             shaders_ft.draw_elements(GL_TRIANGLES, etc->count, GL_UNSIGNED_INT, 0);
             break;
         case mdl::ETC_OBJ_GRID:
-            gl_state_set_line_width(0.2f);
+            gl_rend_state.set_line_width(0.2f);
             shaders_ft.draw_arrays(GL_LINES, 0, etc->count);
-            gl_state_set_line_width(2.0f);
+            gl_rend_state.set_line_width(2.0f);
             shaders_ft.draw_arrays(GL_LINES, (GLint)etc->count, 4);
-            gl_state_set_line_width(1.0f);
+            gl_rend_state.set_line_width(1.0f);
             break;
         case mdl::ETC_OBJ_CUBE:
             if (etc->data.sphere.wire)
@@ -188,9 +188,9 @@ namespace mdl {
                 if (rctx->get_shared_storage_uniform_buffer_data(
                     (size_t)args->mats, buffer, offset, size, !!GLAD_GL_VERSION_4_3))
                     if (GLAD_GL_VERSION_4_3)
-                        gl_state_bind_shader_storage_buffer_range(0, buffer, (GLintptr)offset, (GLsizeiptr)size);
+                        gl_rend_state.bind_shader_storage_buffer_range(0, buffer, (GLintptr)offset, (GLsizeiptr)size);
                     else
-                        gl_state_bind_uniform_buffer_range(6, buffer, (GLintptr)offset, (GLsizeiptr)size);
+                        gl_rend_state.bind_uniform_buffer_range(6, buffer, (GLintptr)offset, (GLsizeiptr)size);
             }
             else {
                 vec4* g_joint_transforms = rctx->data.buffer_skinning_data.g_joint_transforms;
@@ -213,7 +213,7 @@ namespace mdl {
             rctx->set_batch_worlds(mat4_identity);
 
             uniform_value[U_SKINNING] = 1;
-            gl_state_bind_vertex_array(vao);
+            gl_rend_state.bind_vertex_array(vao);
             func(rctx, args);
             uniform_value[U_SKINNING] = 0;
         }
@@ -227,7 +227,7 @@ namespace mdl {
                 _mat = *mat;
 
             uniform_value[U_SKINNING] = 0;
-            gl_state_bind_vertex_array(vao);
+            gl_rend_state.bind_vertex_array(vao);
             if (func != draw_sub_mesh_default || !args->instances_count) {
                 draw_object_model_mat_load(rctx, _mat);
                 func(rctx, args);
@@ -422,7 +422,7 @@ namespace mdl {
 
         draw_object_vertex_attrib_set_default(rctx, args);
         if (args->material->material.attrib.m.double_sided)
-            gl_state_disable_cull_face();
+            gl_rend_state.disable_cull_face();
 
         GLuint tex_id = -1;
         int32_t tex_index = 0;
@@ -463,7 +463,7 @@ namespace mdl {
                 if (tex_id == -1)
                     tex_id = rctx->empty_texture_2d->glid;
 
-                gl_state_active_bind_texture_2d(tex_index, tex_id);
+                gl_rend_state.active_bind_texture_2d(tex_index, tex_id);
 
                 int32_t wrap_s;
                 if (texdata->attrib.m.mirror_u)
@@ -482,7 +482,7 @@ namespace mdl {
                     wrap_t = 0;
 
                 texture* tex = texture_manager_get_texture(::texture_id(0x00, texture_id));
-                gl_state_bind_sampler(tex_index, rctx->samplers[(wrap_t * 3 + wrap_s) * 2
+                gl_rend_state.bind_sampler(tex_index, rctx->samplers[(wrap_t * 3 + wrap_s) * 2
                     + (!tex || tex->max_mipmap_level > 0 ? 1 : 0)]);
             }
         }
@@ -498,9 +498,9 @@ namespace mdl {
                 sub_mesh->index_offset);
 
         if (tex_id != -1)
-            gl_state_active_bind_texture_2d(tex_index, rctx->empty_texture_2d->glid);
+            gl_rend_state.active_bind_texture_2d(tex_index, rctx->empty_texture_2d->glid);
 
-        gl_state_enable_cull_face();
+        gl_rend_state.enable_cull_face();
         draw_object_vertex_attrib_reset_default(args);
 
         if (rctx->draw_state->shader_index != -1)
@@ -594,7 +594,7 @@ static bool draw_object_blend_set(render_context* rctx,
             }
         }
     }
-    gl_state_set_blend_func(src_blend_factor, dst_blend_factor);
+    gl_rend_state.set_blend_func(src_blend_factor, dst_blend_factor);
     return dst_blend_factor == GL_ONE;
 }
 
@@ -632,17 +632,17 @@ static void draw_object_chara_color_fog_set(render_context* rctx, const mdl::Obj
 
 static void draw_object_material_reset_default(const obj_material_data* mat_data) {
     if (mat_data) {
-        gl_state_enable_cull_face();
+        gl_rend_state.enable_cull_face();
         obj_material_attrib_member attrib = mat_data->material.attrib.m;
         if ((attrib.alpha_texture || attrib.alpha_material) && !attrib.punch_through)
-            gl_state_set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+            gl_rend_state.set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     }
     uniform_value_reset();
 }
 
 static void draw_object_material_reset_reflect(render_context* rctx) {
-    gl_state_active_bind_texture_2d(0, rctx->empty_texture_2d->glid);
-    gl_state_enable_cull_face();
+    gl_rend_state.active_bind_texture_2d(0, rctx->empty_texture_2d->glid);
+    gl_rend_state.enable_cull_face();
     uniform_value_reset();
 }
 
@@ -713,11 +713,11 @@ static void draw_object_material_set_default(render_context* rctx, const mdl::Ob
         }
 
         if (tex_type == OBJ_MATERIAL_TEXTURE_ENVIRONMENT_CUBE) {
-            gl_state_active_bind_texture_cube_map(tex_index, tex_id);
-            gl_state_bind_sampler(tex_index, 0);
+            gl_rend_state.active_bind_texture_cube_map(tex_index, tex_id);
+            gl_rend_state.bind_sampler(tex_index, 0);
         }
         else {
-            gl_state_active_bind_texture_2d(tex_index, tex_id);
+            gl_rend_state.active_bind_texture_2d(tex_index, tex_id);
 
             int32_t wrap_s;
             if (texdata->attrib.m.mirror_u)
@@ -736,7 +736,7 @@ static void draw_object_material_set_default(render_context* rctx, const mdl::Ob
                 wrap_t = 0;
 
             texture* tex = texture_manager_get_texture(texture_id);
-            gl_state_bind_sampler(tex_index, rctx->samplers[(wrap_t * 3 + wrap_s) * 2
+            gl_rend_state.bind_sampler(tex_index, rctx->samplers[(wrap_t * 3 + wrap_s) * 2
                 + (!tex || tex->max_mipmap_level > 0 ? 1 : 0)]);
         }
 
@@ -761,7 +761,7 @@ static void draw_object_material_set_default(render_context* rctx, const mdl::Ob
     }
 
     if (material->material.attrib.m.double_sided) {
-        gl_state_disable_cull_face();
+        gl_rend_state.disable_cull_face();
         if (!material->material.attrib.m.normal_dir_light)
             uniform_value[U0B] = 1;
     }
@@ -901,7 +901,7 @@ static void draw_object_material_set_reflect(render_context* rctx, const mdl::Ob
     const obj_material_data* material = args->material;
     const std::vector<GLuint>* textures = args->textures;
     if (material->material.attrib.m.double_sided)
-        gl_state_disable_cull_face();
+        gl_rend_state.disable_cull_face();
 
     const obj_material_texture_data* texdata = material->material.texdata;
     for (int32_t i = 0; i < 1; i++, texdata++) {
@@ -924,7 +924,7 @@ static void draw_object_material_set_reflect(render_context* rctx, const mdl::Ob
         if (tex_id == -1)
             tex_id = rctx->empty_texture_2d->glid;
 
-        gl_state_active_bind_texture_2d(i, tex_id);
+        gl_rend_state.active_bind_texture_2d(i, tex_id);
 
         int32_t wrap_s;
         if (texdata->attrib.m.mirror_u)
@@ -943,7 +943,7 @@ static void draw_object_material_set_reflect(render_context* rctx, const mdl::Ob
             wrap_t = 0;
 
         texture* tex = texture_manager_get_texture(texture_id);
-        gl_state_bind_sampler(i, rctx->samplers[(wrap_t * 3 + wrap_s) * 2
+        gl_rend_state.bind_sampler(i, rctx->samplers[(wrap_t * 3 + wrap_s) * 2
             + (!tex || tex->max_mipmap_level > 0 ? 1 : 0)]);
     }
 
@@ -1043,7 +1043,7 @@ static void draw_object_vertex_attrib_reset_default(const mdl::ObjSubMeshArgs* a
     /*if (args->instances_count)
         uniform_value[U_INSTANCE] = 0;*/
 
-    gl_state_active_texture(0);
+    gl_rend_state.active_texture(0);
 }
 
 static void draw_object_vertex_attrib_reset_reflect(const mdl::ObjSubMeshArgs* args) {
@@ -1058,7 +1058,7 @@ static void draw_object_vertex_attrib_reset_reflect(const mdl::ObjSubMeshArgs* a
         uniform_value[U_MORPH_COLOR] = 0;
     }
 
-    gl_state_active_texture(0);
+    gl_rend_state.active_texture(0);
 }
 
 static void draw_object_vertex_attrib_set_default(render_context* rctx, const mdl::ObjSubMeshArgs* args) {

src/CRE/object.cpp

@@ -12,7 +12,7 @@
 #include "../KKdLib/msgpack.hpp"
 #include "../KKdLib/str_utils.hpp"
 #include "data.hpp"
-#include "gl_state.hpp"
+#include "gl_rend_state.hpp"
 #include "render_context.hpp"
 #include "shader_ft.hpp"
 #include <list>

src/CRE/render.cpp

@@ -5,7 +5,7 @@
 
 #include "render.hpp"
 #include "rob/rob.hpp"
-#include "gl_state.hpp"
+#include "gl_rend_state.hpp"
 #include "render_context.hpp"
 #include "shader_ft.hpp"
 #include "stage.hpp"
@@ -135,7 +135,7 @@ namespace rndr {
         render_context* rctx = rctx_ptr;
 
         for (int32_t i = 0; i < 8; i++)
-            gl_state_bind_sampler(i, 0);
+            gl_rend_state.bind_sampler(i, 0);
 
         dof->apply(&rend_texture[0], &rctx_ptr->render_buffer);
 
@@ -163,9 +163,9 @@ namespace rndr {
             else
                 uniform_value[U_REDUCE] = 0;
 
-            gl_state_set_viewport(0, 0, t->width, t->height);
-            gl_state_active_bind_texture_2d(0, taa_tex[taa_texture_selector]->glid);
-            gl_state_bind_sampler(0, rctx->render_samplers[0]);
+            gl_rend_state.set_viewport(0, 0, t->width, t->height);
+            gl_rend_state.active_bind_texture_2d(0, taa_tex[taa_texture_selector]->glid);
+            gl_rend_state.bind_sampler(0, rctx->render_samplers[0]);
             shaders_ft.set(SHADER_FT_REDUCE);
             draw_quad(render_post_width[0], render_post_height[0],
                 render_post_width_scale, render_post_height_scale,
@@ -185,7 +185,7 @@ namespace rndr {
         if (taa_blend < 0.0f || taa_blend >= 1.0f)
             taa_texture = taa_texture_selector;
         else {
-            gl_state_begin_event("taa_or_blur");
+            gl_rend_state.begin_event("taa_or_blur");
             bool blur;
             GLuint sampler;
             if (taa_blend > 0.99f) {
@@ -199,13 +199,13 @@ namespace rndr {
 
             taa_texture = 2;
             taa_buffer[2].Bind();
-            gl_state_set_viewport(0, 0, render_width[0], render_height[0]);
-            gl_state_active_bind_texture_2d(0, taa_tex[taa_texture_selector]->glid);
-            gl_state_bind_sampler(0, sampler);
+            gl_rend_state.set_viewport(0, 0, render_width[0], render_height[0]);
+            gl_rend_state.active_bind_texture_2d(0, taa_tex[taa_texture_selector]->glid);
+            gl_rend_state.bind_sampler(0, sampler);
 
             if (blur) {
-                gl_state_active_bind_texture_2d(2, rend_texture[0].depth_texture->glid);
-                gl_state_bind_sampler(2, sampler);
+                gl_rend_state.active_bind_texture_2d(2, rend_texture[0].depth_texture->glid);
+                gl_rend_state.bind_sampler(2, sampler);
 
                 mat4 mat;
                 mat4_invert(&cam_view_projection, &mat);
@@ -224,8 +224,8 @@ namespace rndr {
                 int32_t taa_texture_selector = this->taa_texture_selector + 1;
                 if (taa_texture_selector > taa)
                     taa_texture_selector = 0;
-                gl_state_active_bind_texture_2d(1, taa_tex[taa_texture_selector]->glid);
-                gl_state_bind_sampler(1, sampler);
+                gl_rend_state.active_bind_texture_2d(1, taa_tex[taa_texture_selector]->glid);
+                gl_rend_state.bind_sampler(1, sampler);
                 uniform_value[U_REDUCE] = 5;
             }
 
@@ -234,7 +234,7 @@ namespace rndr {
             draw_quad(render_post_width[0], render_post_height[0],
                 render_post_width_scale, render_post_height_scale,
                 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, taa_blend);
-            gl_state_end_event();
+            gl_rend_state.end_event();
         }
 
         if (taa) {
@@ -245,10 +245,10 @@ namespace rndr {
         }
 
         rctx->screen_buffer.Bind();
-        gl_state_set_viewport(0, 0, rctx->sprite_width, rctx->sprite_height);
+        gl_rend_state.set_viewport(0, 0, rctx->sprite_width, rctx->sprite_height);
         if (ssaa) {
-            gl_state_active_bind_texture_2d(0, taa_tex[taa_texture]->glid);
-            gl_state_bind_sampler(0, rctx->render_samplers[0]);
+            gl_rend_state.active_bind_texture_2d(0, taa_tex[taa_texture]->glid);
+            gl_rend_state.bind_sampler(0, rctx->render_samplers[0]);
             uniform_value[U_ALPHA_MASK] = ss_alpha_mask ? 1 : 0;
             uniform_value[U_REDUCE] = 0;
             shaders_ft.set(SHADER_FT_REDUCE);
@@ -258,11 +258,11 @@ namespace rndr {
             uniform_value[U_ALPHA_MASK] = 0;
         }
         else {
-            gl_state_active_bind_texture_2d(0, taa_tex[taa_texture]->glid);
+            gl_rend_state.active_bind_texture_2d(0, taa_tex[taa_texture]->glid);
             if (mag_filter == MAG_FILTER_NEAREST)
-                gl_state_bind_sampler(0, rctx->render_samplers[1]);
+                gl_rend_state.bind_sampler(0, rctx->render_samplers[1]);
             else
-                gl_state_bind_sampler(0, rctx->render_samplers[0]);
+                gl_rend_state.bind_sampler(0, rctx->render_samplers[0]);
 
             switch (mag_filter) {
             case MAG_FILTER_NEAREST:
@@ -292,7 +292,7 @@ namespace rndr {
         shader::unbind();
 
         for (int32_t i = 0; i < 8; i++)
-            gl_state_bind_sampler(i, 0);
+            gl_rend_state.bind_sampler(i, 0);
     }
 
     void Render::bind_render_texture(bool aet_back) {
@@ -302,18 +302,18 @@ namespace rndr {
         }
         else
             rend_texture[0].Bind();
-        gl_state_set_viewport(0, 0, render_width[0], render_height[0]);
+        gl_rend_state.set_viewport(0, 0, render_width[0], render_height[0]);
     }
 
     void Render::calc_exposure_chara_data(camera* cam) {
         shader::unbind();
 
-        gl_state_set_color_mask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
-        gl_state_set_depth_mask(GL_FALSE);
-        gl_state_disable_cull_face();
+        gl_rend_state.set_color_mask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+        gl_rend_state.set_depth_mask(GL_FALSE);
+        gl_rend_state.disable_cull_face();
 
         shaders_ft.set(SHADER_FT_SUN_NO_TEXTURED);
-        gl_state_bind_vertex_array(rctx_ptr->common_vao);
+        gl_rend_state.bind_vertex_array(rctx_ptr->common_vao);
         rctx_ptr->sun_quad_ubo.Bind(0);
 
         ExposureCharaData* chara_data = exposure_chara_data;
@@ -363,11 +363,11 @@ namespace rndr {
             }
         }
 
-        gl_state_bind_vertex_array(0);
+        gl_rend_state.bind_vertex_array(0);
 
-        gl_state_set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-        gl_state_set_depth_mask(GL_TRUE);
-        gl_state_enable_cull_face();
+        gl_rend_state.set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+        gl_rend_state.set_depth_mask(GL_TRUE);
+        gl_rend_state.enable_cull_face();
     }
 
     void Render::calc_projection_matrix(mat4* mat, float_t fov, float_t aspect, float_t z_near, float_t z_far,
@@ -406,7 +406,7 @@ namespace rndr {
 
         rctx_ptr->quad_ubo.WriteMemory(quad);
         rctx_ptr->quad_ubo.Bind(0);
-        gl_state_bind_vertex_array(rctx_ptr->common_vao);
+        gl_rend_state.bind_vertex_array(rctx_ptr->common_vao);
         shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4);
     }
 
@@ -471,9 +471,9 @@ namespace rndr {
         sun_quad_shader_data shader_data = {};
         shader_data.g_emission = emission;
 
-        gl_state_active_bind_texture_2d(0, tex);
+        gl_rend_state.active_bind_texture_2d(0, tex);
         shaders_ft.set(SHADER_FT_SUN);
-        gl_state_bind_vertex_array(rctx_ptr->common_vao);
+        gl_rend_state.bind_vertex_array(rctx_ptr->common_vao);
         rctx_ptr->sun_quad_ubo.Bind(0);
 
         int32_t query_index = (lens_flare_query_index + 1) % 3;
@@ -486,9 +486,9 @@ namespace rndr {
         if (lens_flare_query_data[next_query_index] == -1)
             lens_flare_query_data[next_query_index] = 0;
 
-        gl_state_set_color_mask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
-        gl_state_set_depth_mask(GL_FALSE);
-        gl_state_disable_cull_face();
+        gl_rend_state.set_color_mask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+        gl_rend_state.set_depth_mask(GL_FALSE);
+        gl_rend_state.disable_cull_face();
 
         mat4 mat;
         mat4_mul_translate(&cam->view, &position, &mat);
@@ -523,9 +523,9 @@ namespace rndr {
         shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4);
         glEndQuery(GL_SAMPLES_PASSED);
 
-        gl_state_set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-        gl_state_set_depth_mask(GL_TRUE);
-        gl_state_enable_cull_face();
+        gl_rend_state.set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+        gl_rend_state.set_depth_mask(GL_TRUE);
+        gl_rend_state.enable_cull_face();
 
         if (lens_shaft_query_data[query_index] != -1) {
             int32_t res = 0;
@@ -542,9 +542,9 @@ namespace rndr {
         }
 
         if (emission.x + emission.y + emission.z > 0.0f) {
-            gl_state_enable_blend();
-            gl_state_set_blend_func(GL_ONE, GL_ONE);
-            gl_state_set_depth_mask(GL_FALSE);
+            gl_rend_state.enable_blend();
+            gl_rend_state.set_blend_func(GL_ONE, GL_ONE);
+            gl_rend_state.set_depth_mask(GL_FALSE);
 
             mat4_mul_translate(&cam->view, &position, &mat);
             mat4_clear_rot(&mat, &mat);
@@ -560,13 +560,13 @@ namespace rndr {
 
             shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4);
 
-            gl_state_disable_blend();
-            gl_state_set_blend_func(GL_ONE, GL_ZERO);
-            gl_state_set_depth_mask(GL_TRUE);
+            gl_rend_state.disable_blend();
+            gl_rend_state.set_blend_func(GL_ONE, GL_ZERO);
+            gl_rend_state.set_depth_mask(GL_TRUE);
         }
 
-        gl_state_active_bind_texture_2d(0, 0);
-        gl_state_bind_vertex_array(0);
+        gl_rend_state.active_bind_texture_2d(0, 0);
+        gl_rend_state.bind_vertex_array(0);
 
         if (lens_flare_appear_power <= 0.01f)
             lens_flare_appear_power = 0.0f;
@@ -1100,13 +1100,13 @@ namespace rndr {
             texture* tex = task_movie_get_texture();
             if (tex) {
                 movie_textures[0].Bind();
-                gl_state_active_bind_texture_2d(0, tex->glid);
-                gl_state_bind_sampler(0, rctx_ptr->render_samplers[0]);
-                gl_state_set_viewport(0, 0, movie_textures_data[0]->width, movie_textures_data[0]->height);
+                gl_rend_state.active_bind_texture_2d(0, tex->glid);
+                gl_rend_state.bind_sampler(0, rctx_ptr->render_samplers[0]);
+                gl_rend_state.set_viewport(0, 0, movie_textures_data[0]->width, movie_textures_data[0]->height);
                 uniform_value[U_REDUCE] = 0;
                 shaders_ft.set(SHADER_FT_REDUCE);
                 draw_quad(tex->width, tex->height, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
-                gl_state_bind_framebuffer(0);
+                gl_rend_state.bind_framebuffer(0);
             }
         }
     }
@@ -1427,9 +1427,9 @@ namespace rndr {
         shaders_ft.set(SHADER_FT_REDUCE);
         for (int32_t i = 1; i < downsample_count - 1; i++) {
             rend_texture[i].Bind();
-            gl_state_active_bind_texture_2d(0, rend_texture[i - 1].GetColorTex());
-            gl_state_bind_sampler(0, rctx->render_samplers[0]);
-            gl_state_set_viewport(0, 0, render_width[i], render_height[i]);
+            gl_rend_state.active_bind_texture_2d(0, rend_texture[i - 1].GetColorTex());
+            gl_rend_state.bind_sampler(0, rctx->render_samplers[0]);
+            gl_rend_state.set_viewport(0, 0, render_width[i], render_height[i]);
             draw_quad(
                 render_post_width[i - 1], render_post_height[i - 1],
                 render_post_width_scale, render_post_height_scale,
@@ -1440,18 +1440,18 @@ namespace rndr {
         shaders_ft.set(SHADER_FT_REDUCE);
 
         int32_t downsample = max_def(downsample_count - 2, 0);
-        gl_state_set_viewport(0, 0, reduce_width[0], reduce_height[0]);
+        gl_rend_state.set_viewport(0, 0, reduce_width[0], reduce_height[0]);
         reduce_texture[0].Bind();
-        gl_state_active_bind_texture_2d(0, rend_texture[downsample].GetColorTex());
-        gl_state_bind_sampler(0, rctx->render_samplers[0]);
+        gl_rend_state.active_bind_texture_2d(0, rend_texture[downsample].GetColorTex());
+        gl_rend_state.bind_sampler(0, rctx->render_samplers[0]);
         draw_quad(
             render_post_width[downsample], render_post_height[downsample],
             render_post_width_scale, render_post_height_scale,
             0.0f, 0.0f, 1.0f, 1.1f, 1.1f, 1.1f, 0.0f);
 
         downsample_texture.Bind();
-        gl_state_active_bind_texture_2d(0, reduce_tex[0]->glid);
-        gl_state_bind_sampler(0, rctx->render_samplers[2]);
+        gl_rend_state.active_bind_texture_2d(0, reduce_tex[0]->glid);
+        gl_rend_state.bind_sampler(0, rctx->render_samplers[2]);
         for (int32_t i = 1; i < 5; i++) {
             float_t scale;
             if (i == 4) {
@@ -1466,11 +1466,11 @@ namespace rndr {
                 shaders_ft.set(SHADER_FT_REDUCE);
             }
 
-            gl_state_set_viewport(0, 0, reduce_width[i], reduce_height[i]);
+            gl_rend_state.set_viewport(0, 0, reduce_width[i], reduce_height[i]);
             draw_quad(reduce_width[i - 1], reduce_height[i - 1],
                 1.0f, 1.0f, 0.0f, 0.0f, scale, 1.0f, 1.0f, 1.0f, 1.0f);
-            gl_state_active_bind_texture_2d(0, reduce_tex[i]->glid);
-            gl_state_bind_sampler(0, rctx->render_samplers[2]);
+            gl_rend_state.active_bind_texture_2d(0, reduce_tex[i]->glid);
+            gl_rend_state.bind_sampler(0, rctx->render_samplers[2]);
             glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, reduce_width[i], reduce_height[i]);
         }
     }
@@ -1551,11 +1551,11 @@ namespace rndr {
     }
 
     void Render::apply_mlaa(int32_t destination, int32_t source, int32_t ss_alpha_mask) {
-        gl_state_begin_event("PostProcess::mlaa");
+        gl_rend_state.begin_event("PostProcess::mlaa");
         if (mlaa) {
             mlaa_buffer.Bind();
-            gl_state_active_bind_texture_2d(0, taa_tex[source]->glid);
-            gl_state_bind_sampler(0, rctx_ptr->render_samplers[1]);
+            gl_rend_state.active_bind_texture_2d(0, taa_tex[source]->glid);
+            gl_rend_state.bind_sampler(0, rctx_ptr->render_samplers[1]);
             uniform_value[U_MLAA] = 0;
             shaders_ft.set(SHADER_FT_MLAA);
             draw_quad(render_post_width[0], render_post_height[0],
@@ -1563,10 +1563,10 @@ namespace rndr {
                 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
 
             temp_buffer.Bind();
-            gl_state_active_bind_texture_2d(0, mlaa_buffer.GetColorTex());
-            gl_state_active_bind_texture_2d(1, mlaa_area_texture);
-            gl_state_bind_sampler(0, rctx_ptr->render_samplers[0]);
-            gl_state_bind_sampler(1, rctx_ptr->render_samplers[3]);
+            gl_rend_state.active_bind_texture_2d(0, mlaa_buffer.GetColorTex());
+            gl_rend_state.active_bind_texture_2d(1, mlaa_area_texture);
+            gl_rend_state.bind_sampler(0, rctx_ptr->render_samplers[0]);
+            gl_rend_state.bind_sampler(1, rctx_ptr->render_samplers[3]);
             uniform_value[U_MLAA] = 1;
             uniform_value[U_MLAA_SEARCH] = 2;
             shaders_ft.set(SHADER_FT_MLAA);
@@ -1575,10 +1575,10 @@ namespace rndr {
                 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
 
             taa_buffer[destination].Bind();
-            gl_state_active_bind_texture_2d(0, taa_tex[source]->glid);
-            gl_state_active_bind_texture_2d(1, temp_buffer.GetColorTex());
-            gl_state_bind_sampler(0, rctx_ptr->render_samplers[1]);
-            gl_state_bind_sampler(1, rctx_ptr->render_samplers[1]);
+            gl_rend_state.active_bind_texture_2d(0, taa_tex[source]->glid);
+            gl_rend_state.active_bind_texture_2d(1, temp_buffer.GetColorTex());
+            gl_rend_state.bind_sampler(0, rctx_ptr->render_samplers[1]);
+            gl_rend_state.bind_sampler(1, rctx_ptr->render_samplers[1]);
             uniform_value[U_MLAA] = 2;
             uniform_value[U_ALPHA_MASK] = ss_alpha_mask ? 1 : 0;
             shaders_ft.set(SHADER_FT_MLAA);
@@ -1586,26 +1586,26 @@ namespace rndr {
                 render_post_width_scale, render_post_height_scale,
                 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
             uniform_value[U_ALPHA_MASK] = 0;
-            gl_state_active_bind_texture_2d(0, 0);
-            gl_state_active_bind_texture_2d(1, 0);
+            gl_rend_state.active_bind_texture_2d(0, 0);
+            gl_rend_state.active_bind_texture_2d(1, 0);
         }
         else {
             taa_buffer[destination].Bind();
-            gl_state_active_bind_texture_2d(0, taa_tex[source]->glid);
-            gl_state_bind_sampler(0, rctx_ptr->render_samplers[1]);
+            gl_rend_state.active_bind_texture_2d(0, taa_tex[source]->glid);
+            gl_rend_state.bind_sampler(0, rctx_ptr->render_samplers[1]);
             uniform_value[U_REDUCE] = 0;
             shaders_ft.set(SHADER_FT_REDUCE);
             draw_quad(render_post_width[0], render_post_height[0],
                 render_post_width_scale, render_post_height_scale,
                 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
         }
-        gl_state_end_event();
+        gl_rend_state.end_event();
     }
 
     void Render::apply_tone_map(texture* light_proj_tex, int32_t npr_param) {
         render_context* rctx = rctx_ptr;
 
-        gl_state_begin_event("PostProcess::tone_map");
+        gl_rend_state.begin_event("PostProcess::tone_map");
 
         update_tone_map_lut();
 
@@ -1639,21 +1639,21 @@ namespace rndr {
         shader_data.g_texcoord_transforms[2] = { 1.0f, 0.0f, 0.0f, 0.0f };
         shader_data.g_texcoord_transforms[3] = { 0.0f, 1.0f, 0.0f, 0.0f };
 
-        gl_state_active_bind_texture_2d(0, rend_texture[0].GetColorTex());
-        gl_state_bind_sampler(0, rctx->render_samplers[1]);
-        gl_state_active_bind_texture_2d(1, reduce_tex_draw);
-        gl_state_bind_sampler(1, rctx->render_samplers[2]);
-        gl_state_active_bind_texture_2d(2, tonemap_lut_texture);
-        gl_state_bind_sampler(2, rctx->render_samplers[0]);
-        gl_state_active_bind_texture_2d(3, exposure_tex);
-        gl_state_bind_sampler(3, rctx->render_samplers[3]);
+        gl_rend_state.active_bind_texture_2d(0, rend_texture[0].GetColorTex());
+        gl_rend_state.bind_sampler(0, rctx->render_samplers[1]);
+        gl_rend_state.active_bind_texture_2d(1, reduce_tex_draw);
+        gl_rend_state.bind_sampler(1, rctx->render_samplers[2]);
+        gl_rend_state.active_bind_texture_2d(2, tonemap_lut_texture);
+        gl_rend_state.bind_sampler(2, rctx->render_samplers[0]);
+        gl_rend_state.active_bind_texture_2d(3, exposure_tex);
+        gl_rend_state.bind_sampler(3, rctx->render_samplers[3]);
 
         if (lens_flare_texture) {
             const float_t aspect = (float_t)height / (float_t)width;
 
             uniform_value[U_FLARE] = 1;
-            gl_state_active_bind_texture_2d(4, lens_flare_texture);
-            gl_state_bind_sampler(4, rctx->render_samplers[2]);
+            gl_rend_state.active_bind_texture_2d(4, lens_flare_texture);
+            gl_rend_state.bind_sampler(4, rctx->render_samplers[2]);
 
             mat4 mat;
             mat4_translate(0.5f, 0.5f, 0.0f, &mat);
@@ -1669,8 +1669,8 @@ namespace rndr {
 
             if (lens_shaft_scale < 50.0f) {
                 uniform_value[U_FLARE] = 2;
-                gl_state_active_bind_texture_2d(5, lens_shaft_texture);
-                gl_state_bind_sampler(5, rctx->render_samplers[2]);
+                gl_rend_state.active_bind_texture_2d(5, lens_shaft_texture);
+                gl_rend_state.bind_sampler(5, rctx->render_samplers[2]);
 
                 mat4_translate(0.5f, 0.5f, 0.0f, &mat);
                 mat4_scale_rot(&mat, lens_shaft_scale, lens_shaft_scale, 1.0f, &mat);
@@ -1684,18 +1684,18 @@ namespace rndr {
                 shader_data.g_texcoord_transforms[7] = mat.row1;
             }
             else {
-                gl_state_active_bind_texture_2d(5, rctx->empty_texture_2d->glid);
-                gl_state_bind_sampler(5, rctx->render_samplers[2]);
+                gl_rend_state.active_bind_texture_2d(5, rctx->empty_texture_2d->glid);
+                gl_rend_state.bind_sampler(5, rctx->render_samplers[2]);
 
                 shader_data.g_texcoord_transforms[6] = { 1.0f, 0.0f, 0.0f, 0.0f };
                 shader_data.g_texcoord_transforms[7] = { 0.0f, 1.0f, 0.0f, 0.0f };
             }
         }
         else {
-            gl_state_active_bind_texture_2d(4, rctx->empty_texture_2d->glid);
-            gl_state_bind_sampler(4, rctx->render_samplers[2]);
-            gl_state_active_bind_texture_2d(5, rctx->empty_texture_2d->glid);
-            gl_state_bind_sampler(5, rctx->render_samplers[2]);
+            gl_rend_state.active_bind_texture_2d(4, rctx->empty_texture_2d->glid);
+            gl_rend_state.bind_sampler(4, rctx->render_samplers[2]);
+            gl_rend_state.active_bind_texture_2d(5, rctx->empty_texture_2d->glid);
+            gl_rend_state.bind_sampler(5, rctx->render_samplers[2]);
 
             shader_data.g_texcoord_transforms[4] = { 1.0f, 0.0f, 0.0f, 0.0f };
             shader_data.g_texcoord_transforms[5] = { 0.0f, 1.0f, 0.0f, 0.0f };
@@ -1704,38 +1704,38 @@ namespace rndr {
         }
 
         if (aet_back) {
-            gl_state_active_bind_texture_2d(6, aet_back_tex->glid);
-            gl_state_bind_sampler(6, rctx->render_samplers[2]);
+            gl_rend_state.active_bind_texture_2d(6, aet_back_tex->glid);
+            gl_rend_state.bind_sampler(6, rctx->render_samplers[2]);
             uniform_value[U_AET_BACK] = 1;
         }
 
         if (light_proj_tex) {
             uniform_value[U_LIGHT_PROJ] = 1;
-            gl_state_active_bind_texture_2d(7, light_proj_tex->glid);
-            gl_state_bind_sampler(7, rctx->render_samplers[2]);
+            gl_rend_state.active_bind_texture_2d(7, light_proj_tex->glid);
+            gl_rend_state.bind_sampler(7, rctx->render_samplers[2]);
 
             shader_data.g_flare_coef.z = 1.0f;
         }
         else {
-            gl_state_active_bind_texture_2d(7, rctx->empty_texture_2d->glid);
-            gl_state_bind_sampler(7, rctx->render_samplers[2]);
+            gl_rend_state.active_bind_texture_2d(7, rctx->empty_texture_2d->glid);
+            gl_rend_state.bind_sampler(7, rctx->render_samplers[2]);
         }
 
         if (aet_back && npr_param == 1) {
-            gl_state_active_bind_texture_2d(14, rend_texture[0].GetDepthTex());
-            gl_state_bind_sampler(14, rctx->render_samplers[1]);
+            gl_rend_state.active_bind_texture_2d(14, rend_texture[0].GetDepthTex());
+            gl_rend_state.bind_sampler(14, rctx->render_samplers[1]);
         }
 
         rctx->tone_map_ubo.WriteMemory(shader_data);
 
-        gl_state_set_viewport(0, 0, render_width[0], render_height[0]);
+        gl_rend_state.set_viewport(0, 0, render_width[0], render_height[0]);
         taa_buffer[2].Bind();
         shaders_ft.set(SHADER_FT_TONEMAP);
         rctx->tone_map_ubo.Bind(1);
-        gl_state_bind_vertex_array(rctx->common_vao);
+        gl_rend_state.bind_vertex_array(rctx->common_vao);
         shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4);
-        gl_state_active_bind_texture_2d(2, 0);
-        gl_state_end_event();
+        gl_rend_state.active_bind_texture_2d(2, 0);
+        gl_rend_state.end_event();
     }
 
     void Render::calc_exposure(camera* cam) {
@@ -1845,21 +1845,21 @@ namespace rndr {
                     exposure_measure.g_spot_coefficients[i * 8 + j] = chara_data->spot_coefficients[j];
             rctx->exposure_measure_ubo.WriteMemory(exposure_measure);
 
-            gl_state_set_viewport(0, 0, 32, 1);
+            gl_rend_state.set_viewport(0, 0, 32, 1);
             downsample_texture.Bind();
 
             uniform_value[U_EXPOSURE] = 1;
             shaders_ft.set(SHADER_FT_EXPOSURE);
             rctx->exposure_measure_ubo.Bind(1);
-            gl_state_active_bind_texture_2d(0, reduce_tex[4]->glid);
-            gl_state_active_bind_texture_2d(1, reduce_tex[2]->glid);
-            gl_state_bind_sampler(0, rctx->render_samplers[2]);
-            gl_state_bind_sampler(1, rctx->render_samplers[2]);
+            gl_rend_state.active_bind_texture_2d(0, reduce_tex[4]->glid);
+            gl_rend_state.active_bind_texture_2d(1, reduce_tex[2]->glid);
+            gl_rend_state.bind_sampler(0, rctx->render_samplers[2]);
+            gl_rend_state.bind_sampler(1, rctx->render_samplers[2]);
             draw_quad(1, 1, 1.0f, 1.0f,
                 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
 
-            gl_state_active_bind_texture_2d(0, exposure_history->glid);
-            gl_state_bind_sampler(0, rctx->render_samplers[2]);
+            gl_rend_state.active_bind_texture_2d(0, exposure_history->glid);
+            gl_rend_state.bind_sampler(0, rctx->render_samplers[2]);
             if (reset_exposure)
                 glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 32, 1);
             else
@@ -1867,12 +1867,12 @@ namespace rndr {
             exposure_history_counter = (exposure_history_counter + 1) % 32;
         }
 
-        gl_state_set_viewport(0, 0, 1, 1);
+        gl_rend_state.set_viewport(0, 0, 1, 1);
         exposure_texture.Bind();
         uniform_value[U_EXPOSURE] = 2;
         shaders_ft.set(SHADER_FT_EXPOSURE);
-        gl_state_active_bind_texture_2d(0, exposure_history->glid);
-        gl_state_bind_sampler(0, rctx->render_samplers[0]);
+        gl_rend_state.active_bind_texture_2d(0, exposure_history->glid);
+        gl_rend_state.bind_sampler(0, rctx->render_samplers[0]);
         draw_quad(1, 1, 1.0f, 1.0f,
             0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
     }
@@ -1947,14 +1947,14 @@ namespace rndr {
 
                 texture* dst_tex = j.texture;
 
-                gl_state_active_bind_texture_2d(0, j.type == FRAME_TEXTURE_PRE_PP ? pre_pp_tex : post_pp_tex);
-                gl_state_bind_sampler(0, rctx_ptr->render_samplers[0]);
-                gl_state_set_viewport(0, 0, dst_tex->width, dst_tex->height);
+                gl_rend_state.active_bind_texture_2d(0, j.type == FRAME_TEXTURE_PRE_PP ? pre_pp_tex : post_pp_tex);
+                gl_rend_state.bind_sampler(0, rctx_ptr->render_samplers[0]);
+                gl_rend_state.set_viewport(0, 0, dst_tex->width, dst_tex->height);
                 uniform_value[U_REDUCE] = 0;
                 shaders_ft.set(SHADER_FT_REDUCE);
                 draw_quad(dst_tex->width, dst_tex->height,
                     1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
-                gl_state_bind_framebuffer(0);
+                gl_rend_state.bind_framebuffer(0);
             }
 
             if (&i - frame_texture)
@@ -2054,21 +2054,21 @@ namespace rndr {
 
         rctx_ptr->lens_ghost_vbo.UnmapMemory();
 
-        gl_state_set_viewport(0, 0, render_width[0], render_height[0]);
+        gl_rend_state.set_viewport(0, 0, render_width[0], render_height[0]);
         rend_texture[0].Bind();
-        gl_state_enable_blend();
-        gl_state_set_blend_func(GL_ONE, GL_ONE);
+        gl_rend_state.enable_blend();
+        gl_rend_state.set_blend_func(GL_ONE, GL_ONE);
 
         uniform_value[U_REDUCE] = 4;
         shaders_ft.set(SHADER_FT_REDUCE);
-        gl_state_active_bind_texture_2d(0, lens_ghost_texture);
-        gl_state_bind_sampler(0, rctx_ptr->render_samplers[0]);
-        gl_state_bind_vertex_array(rctx_ptr->lens_ghost_vao);
+        gl_rend_state.active_bind_texture_2d(0, lens_ghost_texture);
+        gl_rend_state.bind_sampler(0, rctx_ptr->render_samplers[0]);
+        gl_rend_state.bind_vertex_array(rctx_ptr->lens_ghost_vao);
         shaders_ft.draw_arrays(GL_TRIANGLES, 0, (GLsizei)(lens_ghost_count * 6LL));
-        gl_state_bind_vertex_array(0);
+        gl_rend_state.bind_vertex_array(0);
 
-        gl_state_disable_blend();
-        gl_state_set_blend_func(GL_ONE, GL_ZERO);
+        gl_rend_state.disable_blend();
+        gl_rend_state.set_blend_func(GL_ONE, GL_ZERO);
     }
 
     void Render::generate_mlaa_area_texture() {
@@ -2099,18 +2099,18 @@ namespace rndr {
 
         downsample_texture.Bind();
         for (int32_t i = 1; i < 4; i++) {
-            gl_state_set_viewport(0, 0, reduce_width[i], reduce_height[i]);
-            gl_state_active_bind_texture_2d(0, reduce_tex[i]->glid);
-            gl_state_bind_sampler(0, rctx->render_samplers[2]);
+            gl_rend_state.set_viewport(0, 0, reduce_width[i], reduce_height[i]);
+            gl_rend_state.active_bind_texture_2d(0, reduce_tex[i]->glid);
+            gl_rend_state.bind_sampler(0, rctx->render_samplers[2]);
             draw_quad(reduce_width[i], reduce_height[i],
                 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f);
             glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, reduce_width[i], reduce_height[i]);
         }
 
         for (int32_t i = 1; i < 4; i++) {
-            gl_state_set_viewport(0, 0, reduce_width[i], reduce_height[i]);
-            gl_state_active_bind_texture_2d(0, reduce_tex[i]->glid);
-            gl_state_bind_sampler(0, rctx->render_samplers[2]);
+            gl_rend_state.set_viewport(0, 0, reduce_width[i], reduce_height[i]);
+            gl_rend_state.active_bind_texture_2d(0, reduce_tex[i]->glid);
+            gl_rend_state.bind_sampler(0, rctx->render_samplers[2]);
             draw_quad(reduce_width[i], reduce_height[i],
                 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f);
             glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, reduce_width[i], reduce_height[i]);
@@ -2119,9 +2119,9 @@ namespace rndr {
         uniform_value[U_GAUSS] = 1;
         shaders_ft.set(SHADER_FT_GAUSS);
 
-        gl_state_set_viewport(0, 0, reduce_width[0], reduce_height[0]);
-        gl_state_active_bind_texture_2d(0, reduce_tex[0]->glid);
-        gl_state_bind_sampler(0, rctx->render_samplers[2]);
+        gl_rend_state.set_viewport(0, 0, reduce_width[0], reduce_height[0]);
+        gl_rend_state.active_bind_texture_2d(0, reduce_tex[0]->glid);
+        gl_rend_state.bind_sampler(0, rctx->render_samplers[2]);
         draw_quad(reduce_width[0], reduce_height[0],
             1.0f, 1.0f, 0.0f, 0.0f, 1.0f,
             intensity.x * 0.5f, intensity.y * 0.5f, intensity.z * 0.5f, 1.0f);
@@ -2129,16 +2129,16 @@ namespace rndr {
         uniform_value[U_REDUCE] = 7;
         shaders_ft.set(SHADER_FT_REDUCE);
 
-        gl_state_set_viewport(0, 0, reduce_width[0], reduce_height[0]);
+        gl_rend_state.set_viewport(0, 0, reduce_width[0], reduce_height[0]);
         reduce_texture[0].Bind();
-        gl_state_active_bind_texture_2d(0, downsample_texture.GetColorTex());
-        gl_state_active_bind_texture_2d(1, reduce_tex[1]->glid);
-        gl_state_active_bind_texture_2d(2, reduce_tex[2]->glid);
-        gl_state_active_bind_texture_2d(3, reduce_tex[3]->glid);
-        gl_state_bind_sampler(0, rctx->render_samplers[2]);
-        gl_state_bind_sampler(1, rctx->render_samplers[2]);
-        gl_state_bind_sampler(2, rctx->render_samplers[2]);
-        gl_state_bind_sampler(3, rctx->render_samplers[2]);
+        gl_rend_state.active_bind_texture_2d(0, downsample_texture.GetColorTex());
+        gl_rend_state.active_bind_texture_2d(1, reduce_tex[1]->glid);
+        gl_rend_state.active_bind_texture_2d(2, reduce_tex[2]->glid);
+        gl_rend_state.active_bind_texture_2d(3, reduce_tex[3]->glid);
+        gl_rend_state.bind_sampler(0, rctx->render_samplers[2]);
+        gl_rend_state.bind_sampler(1, rctx->render_samplers[2]);
+        gl_rend_state.bind_sampler(2, rctx->render_samplers[2]);
+        gl_rend_state.bind_sampler(3, rctx->render_samplers[2]);
         draw_quad(reduce_width[3], reduce_height[3],
             1.0f, 1.0f, 0.0f, 0.0f, 0.25f, 0.15f, 0.25f, 0.25f, 0.25f);
         reduce_tex_draw = reduce_tex[0]->glid;
@@ -2180,7 +2180,7 @@ namespace rndr {
             glTextureSubImage2D(tonemap_lut_texture, 0, 0, 0,
                 16 * TONE_MAP_SAT_GAMMA_SAMPLES, 1, GL_RG, GL_FLOAT, tex_data);
         else {
-            gl_state_bind_texture_2d(tonemap_lut_texture);
+            gl_rend_state.bind_texture_2d(tonemap_lut_texture);
             glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
                 16 * TONE_MAP_SAT_GAMMA_SAMPLES, 1, GL_RG, GL_FLOAT, tex_data);
         }

src/CRE/render_context.cpp

@@ -107,8 +107,8 @@ void sss_data::init() {
 }
 
 void sss_data::set_texture(int32_t texture_index) {
-    gl_state_active_bind_texture_2d(16, textures[texture_index].GetColorTex());
-    gl_state_active_texture(0);
+    gl_rend_state.active_bind_texture_2d(16, textures[texture_index].GetColorTex());
+    gl_rend_state.active_texture(0);
 }
 
 light_proj::light_proj(int32_t width, int32_t height) : enable(), texture_id() {
@@ -136,9 +136,9 @@ bool light_proj::set() {
     static const GLfloat depth_clear = 1.0f;
 
     shadow_texture[0].Bind();
-    gl_state_set_viewport(0, 0, 2048, 512);
-    gl_state_enable_depth_test();
-    gl_state_set_depth_mask(GL_TRUE);
+    gl_rend_state.set_viewport(0, 0, 2048, 512);
+    gl_rend_state.enable_depth_test();
+    gl_rend_state.set_depth_mask(GL_TRUE);
     glClearBufferfv(GL_COLOR, 0, (float_t*)&color_clear);
     glClearBufferfv(GL_DEPTH, 0, &depth_clear);
 
@@ -150,8 +150,8 @@ bool light_proj::set() {
     else {
         draw_texture.Bind();
         draw_texture.SetViewport();
-        gl_state_enable_depth_test();
-        gl_state_set_depth_mask(GL_TRUE);
+        gl_rend_state.enable_depth_test();
+        gl_rend_state.set_depth_mask(GL_TRUE);
         glClearBufferfv(GL_COLOR, 0, (float_t*)&color_clear);
         glClearBufferfv(GL_DEPTH, 0, &depth_clear);
     }
@@ -1144,20 +1144,22 @@ void render_context::pre_proc() {
                 if (!i.offset)
                     continue;
 
-                size_t align = align_val(i.offset, sv_min_storage_buffer_alignment) - i.offset;
+                const size_t size = align_val(i.offset, sv_min_uniform_buffer_alignment);
+                const size_t align = size - i.offset;
                 if (align)
                     memset((void*)((size_t)i.data + i.offset), 0, align);
-                i.buffer.WriteMemory(0, i.size, i.data);
+                i.buffer.WriteMemory(0, size, i.data);
             }
 
         for (render_context::shared_uniform_buffer& i : shared_uniform_buffers) {
             if (!i.offset)
                 continue;
 
-            size_t align = align_val(i.offset, sv_min_uniform_buffer_alignment) - i.offset;
+            const size_t size = align_val(i.offset, sv_min_uniform_buffer_alignment);
+            const size_t align = size - i.offset;
             if (align)
                 memset((void*)((size_t)i.data + i.offset), 0, align);
-            i.buffer.WriteMemory(0, i.size, i.data);
+            i.buffer.WriteMemory(0, size, i.data);
         }
     }
 }

src/CRE/render_texture.cpp

@@ -28,11 +28,11 @@ int32_t RenderTexture::Bind(int32_t index) {
     if (index < 0 || index > max_level)
         return -1;
 
-    gl_state_bind_framebuffer(fbos[index]);
+    gl_rend_state.bind_framebuffer(fbos[index]);
     if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
         return -1;
 
-    gl_state_get_error();
+    gl_get_error_print();
     return 0;
 }
 
@@ -123,22 +123,22 @@ int32_t RenderTexture::Init(int32_t width, int32_t height,
 }
 
 /*int32_t RenderTexture::InitDepthRenderbuffer(GLenum internal_format, int32_t width, int32_t height) {
-    gl_state_bind_framebuffer(fbos[0]);
+    gl_rend_state.bind_framebuffer(fbos[0]);
     glGenRenderbuffers(1, &depth_rbo);
     glBindRenderbuffer(GL_RENDERBUFFER, depth_rbo);
     glRenderbufferStorage(GL_RENDERBUFFER, internal_format, width, height);
     glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth_rbo);
-    gl_state_bind_framebuffer(0);
+    gl_rend_state.bind_framebuffer(0);
     return -(glGetError() != GL_ZERO);
 }
 
 int32_t RenderTexture::InitStencilRenderbuffer(GLenum internal_format, int32_t width, int32_t height) {
-    gl_state_bind_framebuffer(fbos[0]);
+    gl_rend_state.bind_framebuffer(fbos[0]);
     glGenRenderbuffers(1, &stencil_rbo);
     glBindRenderbuffer(GL_RENDERBUFFER, stencil_rbo);
     glRenderbufferStorage(GL_RENDERBUFFER, internal_format, width, height);
     glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, stencil_rbo);
-    gl_state_bind_framebuffer(0);
+    gl_rend_state.bind_framebuffer(0);
     return -(glGetError() != GL_ZERO);
 }*/
 
@@ -159,7 +159,7 @@ void render_texture_counter_reset() {
 static int32_t render_texture_init_framebuffer(RenderTexture* rt, int32_t max_level) {
     rt->fbos = force_malloc<GLuint>(max_level + 1LL);
     glGenFramebuffers(max_level + 1, rt->fbos);
-    return -(gl_state_get_error() != GL_ZERO);
+    return -(gl_get_error_print() != GL_ZERO);
 }
 
 static int32_t render_texture_set_framebuffer_texture(RenderTexture* rt,
@@ -167,22 +167,22 @@ static int32_t render_texture_set_framebuffer_texture(RenderTexture* rt,
     if (level < 0 || level > rt->max_level)
         return -1;
 
-    gl_state_bind_framebuffer(rt->fbos[level]);
-    gl_state_get_error();
+    gl_rend_state.bind_framebuffer(rt->fbos[level]);
+    gl_get_error_print();
 
     if (color_texture) {
         glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, color_texture, level);
-        gl_state_get_error();
+        gl_get_error_print();
         glDrawBuffer(GL_COLOR_ATTACHMENT0);
         glReadBuffer(GL_COLOR_ATTACHMENT0);
     }
     else {
         glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, 0, 0);
-        gl_state_get_error();
+        gl_get_error_print();
         glDrawBuffer(GL_ZERO);
         glReadBuffer(GL_ZERO);
     }
-    gl_state_get_error();
+    gl_get_error_print();
 
     if (!level) {
         GLenum attechment = stencil ? GL_DEPTH_STENCIL_ATTACHMENT : GL_DEPTH_ATTACHMENT;
@@ -194,13 +194,13 @@ static int32_t render_texture_set_framebuffer_texture(RenderTexture* rt,
         }*/
         else
             glFramebufferTexture(GL_FRAMEBUFFER, attechment, 0, 0);
-        gl_state_get_error();
+        gl_get_error_print();
     }
 
     int32_t ret = 0;
     if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
         ret = -1;
-    gl_state_bind_framebuffer(0);
-    gl_state_get_error();
+    gl_rend_state.bind_framebuffer(0);
+    gl_get_error_print();
     return ret;
 }

src/CRE/render_texture.hpp

@@ -6,7 +6,7 @@
 #pragma once
 
 #include "shared.hpp"
-#include "gl_state.hpp"
+#include "gl_rend_state.hpp"
 #include "texture.hpp"
 
 struct RenderTexture {
@@ -47,7 +47,7 @@ struct RenderTexture {
     };
 
     inline void SetViewport() {
-        gl_state_set_viewport(0, 0, GetWidth(), GetHeight());
+        gl_rend_state.set_viewport(0, 0, GetWidth(), GetHeight());
     };
 };
 

src/CRE/renderer/dof.cpp

@@ -5,7 +5,7 @@
 
 #include "dof.hpp"
 #include "../rob/rob.hpp"
-#include "../gl_state.hpp"
+#include "../gl_rend_state.hpp"
 #include "../shader_ft.hpp"
 
 struct dof_common_shader_data {
@@ -176,16 +176,16 @@ namespace renderer {
     void DOF3::apply_f2(RenderTexture* rt, RenderTexture* buf_rt, GLuint color_texture,
         GLuint depth_texture, float_t min_distance, float_t max_distance, float_t fov,
         float_t focus, float_t focus_range, float_t fuzzing_range, float_t ratio) {
-        gl_state_begin_event("renderer::DOF3::apply_f2");
-        gl_state_disable_blend();
-        gl_state_set_depth_mask(GL_FALSE);
-        gl_state_set_depth_func(GL_ALWAYS);
+        gl_rend_state.begin_event("renderer::DOF3::apply_f2");
+        gl_rend_state.disable_blend();
+        gl_rend_state.set_depth_mask(GL_FALSE);
+        gl_rend_state.set_depth_func(GL_ALWAYS);
         update_data(min_distance, max_distance,
             fov, focus, 0.0f, 1.0f, focus_range, fuzzing_range, ratio);
 
         uniform_value[U_DOF] = 1;
 
-        gl_state_bind_vertex_array(vao);
+        gl_rend_state.bind_vertex_array(vao);
         render_tiles(depth_texture, true);
         downsample(color_texture, depth_texture, true);
         apply_main_filter(true);
@@ -193,26 +193,26 @@ namespace renderer {
 
         shader::unbind();
         for (int32_t i = 0; i < 8; i++) {
-            gl_state_bind_sampler(i, 0);
-            gl_state_active_bind_texture_2d(i, 0);
+            gl_rend_state.bind_sampler(i, 0);
+            gl_rend_state.active_bind_texture_2d(i, 0);
         }
-        gl_state_bind_vertex_array(0);
-        gl_state_end_event();
+        gl_rend_state.bind_vertex_array(0);
+        gl_rend_state.end_event();
     }
 
     void DOF3::apply_physical(RenderTexture* rt, RenderTexture* buf_rt, GLuint color_texture,
         GLuint depth_texture, float_t min_distance, float_t max_distance,
         float_t focus, float_t focal_length, float_t fov, float_t f_number) {
-        gl_state_begin_event("renderer::DOF3::apply_physical");
-        gl_state_disable_blend();
-        gl_state_set_depth_mask(GL_FALSE);
-        gl_state_set_depth_func(GL_ALWAYS);
+        gl_rend_state.begin_event("renderer::DOF3::apply_physical");
+        gl_rend_state.disable_blend();
+        gl_rend_state.set_depth_mask(GL_FALSE);
+        gl_rend_state.set_depth_func(GL_ALWAYS);
         update_data(min_distance, max_distance,
             fov, focus, focal_length, f_number, 0.0f, 0.1f, 0.0f);
 
         uniform_value[U_DOF] = 0;
 
-        gl_state_bind_vertex_array(vao);
+        gl_rend_state.bind_vertex_array(vao);
         render_tiles(depth_texture, false);
         downsample(color_texture, depth_texture, false);
         apply_main_filter(false);
@@ -220,93 +220,93 @@ namespace renderer {
 
         shader::unbind();
         for (int32_t i = 0; i < 8; i++) {
-            gl_state_bind_sampler(i, 0);
-            gl_state_active_bind_texture_2d(i, 0);
+            gl_rend_state.bind_sampler(i, 0);
+            gl_rend_state.active_bind_texture_2d(i, 0);
         }
-        gl_state_bind_vertex_array(0);
-        gl_state_end_event();
+        gl_rend_state.bind_vertex_array(0);
+        gl_rend_state.end_event();
     }
 
     void DOF3::render_tiles(GLuint depth_texture, bool f2) {
-        gl_state_begin_event("renderer::DOF3::render_tiles");
+        gl_rend_state.begin_event("renderer::DOF3::render_tiles");
         fbo[0].bind_buffer();
-        gl_state_set_viewport(0, 0, fbo[0].width, fbo[0].height);
+        gl_rend_state.set_viewport(0, 0, fbo[0].width, fbo[0].height);
         uniform_value[U_DOF_STAGE] = 0;
         shaders_ft.set(SHADER_FT_DOF);
         common_ubo.Bind(0);
-        gl_state_active_bind_texture_2d(0, depth_texture);
-        gl_state_bind_sampler(0, samplers[1]);
+        gl_rend_state.active_bind_texture_2d(0, depth_texture);
+        gl_rend_state.bind_sampler(0, samplers[1]);
         shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4);
 
         fbo[1].bind_buffer();
-        gl_state_set_viewport(0, 0, fbo[1].width, fbo[1].height);
+        gl_rend_state.set_viewport(0, 0, fbo[1].width, fbo[1].height);
         uniform_value[U_DOF_STAGE] = 1;
         shaders_ft.set(SHADER_FT_DOF);
-        gl_state_active_bind_texture_2d(0, textures[0]);
-        gl_state_bind_sampler(0, samplers[1]);
+        gl_rend_state.active_bind_texture_2d(0, textures[0]);
+        gl_rend_state.bind_sampler(0, samplers[1]);
         shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4);
-        gl_state_end_event();
+        gl_rend_state.end_event();
     }
 
     void DOF3::downsample(GLuint color_texture, GLuint depth_texture, bool f2) {
-        gl_state_begin_event("renderer::DOF3::downsample");
+        gl_rend_state.begin_event("renderer::DOF3::downsample");
         fbo[2].bind_buffer();
-        gl_state_set_viewport(0, 0, fbo[2].width, fbo[2].height);
+        gl_rend_state.set_viewport(0, 0, fbo[2].width, fbo[2].height);
         uniform_value[U_DOF_STAGE] = 2;
         shaders_ft.set(SHADER_FT_DOF);
         common_ubo.Bind(0);
-        gl_state_active_bind_texture_2d(0, depth_texture);
-        gl_state_bind_sampler(0, samplers[1]);
-        gl_state_active_bind_texture_2d(1, color_texture);
-        gl_state_bind_sampler(1, samplers[0]);
-        gl_state_active_bind_texture_2d(2, textures[1]);
-        gl_state_bind_sampler(2, samplers[1]);
+        gl_rend_state.active_bind_texture_2d(0, depth_texture);
+        gl_rend_state.bind_sampler(0, samplers[1]);
+        gl_rend_state.active_bind_texture_2d(1, color_texture);
+        gl_rend_state.bind_sampler(1, samplers[0]);
+        gl_rend_state.active_bind_texture_2d(2, textures[1]);
+        gl_rend_state.bind_sampler(2, samplers[1]);
         shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4);
-        gl_state_end_event();
+        gl_rend_state.end_event();
     }
 
     void DOF3::apply_main_filter(bool f2) {
-        gl_state_begin_event("renderer::DOF3::apply_main_filter");
+        gl_rend_state.begin_event("renderer::DOF3::apply_main_filter");
         fbo[3].bind_buffer();
-        gl_state_set_viewport(0, 0, fbo[3].width, fbo[3].height);
+        gl_rend_state.set_viewport(0, 0, fbo[3].width, fbo[3].height);
         uniform_value[U_DOF_STAGE] = 3;
         shaders_ft.set(SHADER_FT_DOF);
         common_ubo.Bind(0);
         texcoords_ubo.Bind(1);
-        gl_state_active_bind_texture_2d(0, textures[3]);
-        gl_state_bind_sampler(0, samplers[1]);
-        gl_state_active_bind_texture_2d(1, textures[2]);
-        gl_state_bind_sampler(1, samplers[1]);
-        gl_state_active_bind_texture_2d(2, textures[1]);
-        gl_state_bind_sampler(2, samplers[1]);
+        gl_rend_state.active_bind_texture_2d(0, textures[3]);
+        gl_rend_state.bind_sampler(0, samplers[1]);
+        gl_rend_state.active_bind_texture_2d(1, textures[2]);
+        gl_rend_state.bind_sampler(1, samplers[1]);
+        gl_rend_state.active_bind_texture_2d(2, textures[1]);
+        gl_rend_state.bind_sampler(2, samplers[1]);
         shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4);
-        gl_state_end_event();
+        gl_rend_state.end_event();
     }
 
     void DOF3::upsample(RenderTexture* rt, RenderTexture* buf_rt,
         GLuint color_texture, GLuint depth_texture, bool f2) {
-        gl_state_begin_event("renderer::DOF3::upsample");
+        gl_rend_state.begin_event("renderer::DOF3::upsample");
         buf_rt->Bind();
-        gl_state_set_viewport(0, 0, width, height);
+        gl_rend_state.set_viewport(0, 0, width, height);
         uniform_value[U_DOF_STAGE] = 4;
         shaders_ft.set(SHADER_FT_DOF);
         common_ubo.Bind(0);
-        gl_state_active_bind_texture_2d(0, textures[4]);
-        gl_state_bind_sampler(0, samplers[1]);
-        gl_state_active_bind_texture_2d(1, textures[5]);
-        gl_state_bind_sampler(1, samplers[1]);
-        gl_state_active_bind_texture_2d(2, textures[1]);
-        gl_state_bind_sampler(2, samplers[1]);
-        gl_state_active_bind_texture_2d(3, color_texture);
-        gl_state_bind_sampler(3, samplers[1]);
-        gl_state_active_bind_texture_2d(4, depth_texture);
-        gl_state_bind_sampler(4, samplers[1]);
+        gl_rend_state.active_bind_texture_2d(0, textures[4]);
+        gl_rend_state.bind_sampler(0, samplers[1]);
+        gl_rend_state.active_bind_texture_2d(1, textures[5]);
+        gl_rend_state.bind_sampler(1, samplers[1]);
+        gl_rend_state.active_bind_texture_2d(2, textures[1]);
+        gl_rend_state.bind_sampler(2, samplers[1]);
+        gl_rend_state.active_bind_texture_2d(3, color_texture);
+        gl_rend_state.bind_sampler(3, samplers[1]);
+        gl_rend_state.active_bind_texture_2d(4, depth_texture);
+        gl_rend_state.bind_sampler(4, samplers[1]);
         shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4);
 
         glCopyImageSubData(
             buf_rt->GetColorTex(), GL_TEXTURE_2D, 0, 0, 0, 0,
             rt->GetColorTex(), GL_TEXTURE_2D, 0, 0, 0, 0, width, height, 1);
-        gl_state_end_event();
+        gl_rend_state.end_event();
     }
 
     void DOF3::init_textures(int32_t width, int32_t height) {

src/CRE/renderer/fbo.cpp

@@ -4,7 +4,7 @@
 */
 
 #include "fbo.hpp"
-#include "../gl_state.hpp"
+#include "../gl_rend_state.hpp"
 
 namespace renderer {
     FBO::FBO() : flags(), width(), height(), buffer(), count(), textures() {
@@ -41,7 +41,7 @@ namespace renderer {
             textures[count] = depth_texture;
 
         glGenFramebuffers(1, &buffer);
-        gl_state_bind_framebuffer(buffer, true);
+        gl_rend_state.bind_framebuffer(buffer, true);
         for (int32_t i = 0; i < count; i++)
             glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, textures[i], 0);
 
@@ -53,7 +53,7 @@ namespace renderer {
             color_attachments[i] = GL_COLOR_ATTACHMENT0 + i;
         glDrawBuffers(count, color_attachments);
         glCheckFramebufferStatus(GL_FRAMEBUFFER);
-        gl_state_bind_framebuffer(0);
+        gl_rend_state.bind_framebuffer(0);
     }
 #pragma warning(pop)
 

src/CRE/renderer/fbo.hpp

@@ -5,7 +5,7 @@
 
 #pragma once
 
-#include "../gl_state.hpp"
+#include "../gl_rend_state.hpp"
 #include "../shared.hpp"
 
 namespace renderer {
@@ -29,7 +29,7 @@ namespace renderer {
         void free();
 
         inline void bind_buffer() {
-            gl_state_bind_framebuffer(buffer);
+            gl_rend_state.bind_framebuffer(buffer);
         }
     };
 }

src/CRE/renderer/transparency.cpp

@@ -5,7 +5,7 @@
 
 #include "transparency.hpp"
 #include "../../KKdLib/str_utils.hpp"
-#include "../gl_state.hpp"
+#include "../gl_rend_state.hpp"
 #include "../render_context.hpp"
 #include "../shader_ft.hpp"
 
@@ -44,16 +44,16 @@ namespace renderer {
         shader_data.g_opacity = { alpha, 0.0f, 0.0f, 0.0f };
         rctx_ptr->transparency_batch_ubo.WriteMemory(shader_data);
 
-        gl_state_disable_blend();
-        gl_state_disable_depth_test();
+        gl_rend_state.disable_blend();
+        gl_rend_state.disable_depth_test();
         rctx_ptr->render_buffer.Bind();
         shaders_ft.set(SHADER_FT_TRANSPARENCY);
         rctx_ptr->transparency_batch_ubo.Bind(0);
-        gl_state_active_bind_texture_2d(0, fbo.textures[0]);
-        gl_state_active_bind_texture_2d(1, rt->GetColorTex());
-        gl_state_bind_vertex_array(vao);
+        gl_rend_state.active_bind_texture_2d(0, fbo.textures[0]);
+        gl_rend_state.active_bind_texture_2d(1, rt->GetColorTex());
+        gl_rend_state.bind_vertex_array(vao);
         shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4);
-        gl_state_enable_depth_test();
+        gl_rend_state.enable_depth_test();
 
         glCopyImageSubData(rctx_ptr->render_buffer.GetColorTex(), GL_TEXTURE_2D, 0, 0, 0, 0,
             rt->GetColorTex(), GL_TEXTURE_2D, 0, 0, 0, 0, fbo.width, fbo.height, 1);
@@ -63,7 +63,7 @@ namespace renderer {
         glCopyImageSubData(texture, GL_TEXTURE_2D, 0, 0, 0, 0,
             fbo.textures[0], GL_TEXTURE_2D, 0, 0, 0, 0, fbo.width, fbo.height, 1);
         fbo.bind_buffer();
-        gl_state_set_viewport(0, 0, fbo.width, fbo.height);
+        gl_rend_state.set_viewport(0, 0, fbo.width, fbo.height);
     }
 
     void Transparency::resize(GLuint color_texture, GLuint depth_texture, int32_t width, int32_t height) {

src/CRE/shader.cpp

@@ -13,7 +13,8 @@
 #include "Vulkan/gl_wrap.hpp"
 #include "Vulkan/Manager.hpp"
 #include "Vulkan/ShaderModule.hpp"
-#include "gl_state.hpp"
+#include "gl_rend_state.hpp"
+#include "shared.hpp"
 #include <shlobj_core.h>
 
 struct program_binary {
@@ -69,7 +70,7 @@ int32_t shader::bind(shader_set_data* set, uint32_t sub_index) {
     GLuint program = sub_shader->programs[unival_shad];
     set->curr_program = program;
 
-    gl_state_use_program(program);
+    gl_rend_state.use_program(program);
     return 0;
 }
 
@@ -489,7 +490,7 @@ char* shader::parse_include(char* data, farc* f) {
 }
 
 void shader::unbind() {
-    gl_state_use_program(0);
+    gl_rend_state.use_program(0);
 }
 
 shader_set_data::shader_set_data() : size(), shaders(), curr_program(), primitive_restart(),
@@ -1110,13 +1111,13 @@ void shader_set_data::load(farc* f, bool ignore_cache,
                                 if (programs[k] && samplers.size()) {
                                     GLuint program = programs[k];
 
-                                    gl_state_use_program(program);
+                                    gl_rend_state.use_program(program);
                                     for (auto& i : samplers) {
                                         GLint loc = glGetUniformLocation(program, i.second.c_str());
                                         if (loc != -1)
                                             glUniform1i(loc, i.first);
                                     }
-                                    gl_state_use_program(0);
+                                    gl_rend_state.use_program(0);
                                 }
 
                                 if (programs[k] && uniforms.size()) {
@@ -1175,13 +1176,13 @@ void shader_set_data::load(farc* f, bool ignore_cache,
                             if (programs[0] && samplers.size()) {
                                 GLuint program = programs[0];
 
-                                gl_state_use_program(program);
+                                gl_rend_state.use_program(program);
                                 for (auto& i : samplers) {
                                     GLint loc = glGetUniformLocation(program, i.second.c_str());
                                     if (loc != -1)
                                         glUniform1i(loc, i.first);
                                 }
-                                gl_state_use_program(0);
+                                gl_rend_state.use_program(0);
                             }
 
                             if (programs[0] && uniforms.size()) {
@@ -1439,7 +1440,7 @@ static GLuint shader_compile(const char* vert, const char* frag, const char* vp,
         return 0;
     }
     else {
-        gl_state_get_all_gl_errors();
+        gl_get_error_all_print();
         return program;
     }
 }
@@ -1513,13 +1514,13 @@ static GLuint shader_compile_binary(const char* vert, const char* frag, const ch
         return 0;
     }
     else {
-        gl_state_get_all_gl_errors();
+        gl_get_error_all_print();
 
         GLenum binary_format = 0x0;
         GLsizei length = 0;
         while (*buffer_size < 0x7FFFFFF) {
             glGetProgramBinary(program, *buffer_size, &length, &binary_format, *binary);
-            if (!gl_state_get_error())
+            if (!gl_get_error_print())
                 break;
 
             free_def(*binary);
@@ -1570,11 +1571,11 @@ static bool shader_update_data(shader_set_data* set) {
         return false;
 
     if (set->primitive_restart) {
-        gl_state_enable_primitive_restart();
-        gl_state_set_primitive_restart_index(set->primitive_restart_index);
+        gl_rend_state.enable_primitive_restart();
+        gl_rend_state.set_primitive_restart_index(set->primitive_restart_index);
     }
     else
-        gl_state_disable_primitive_restart();
+        gl_rend_state.disable_primitive_restart();
 
     return true;
 }

src/CRE/shader_dev.cpp

@@ -5,7 +5,7 @@
 
 #include "shader_dev.hpp"
 #include "../KKdLib/str_utils.hpp"
-#include "gl_state.hpp"
+#include "gl_rend_state.hpp"
 #include "random.hpp"
 #include "render_context.hpp"
 

src/CRE/shader_ft.cpp

@@ -6,7 +6,7 @@
 #include "shader_ft.hpp"
 #include "../KKdLib/str_utils.hpp"
 #include "app_system_detail.hpp"
-#include "gl_state.hpp"
+#include "gl_rend_state.hpp"
 #include "random.hpp"
 #include "render_context.hpp"
 

src/CRE/shadow.cpp

@@ -37,7 +37,7 @@ void Shadow::clear_textures() {
             glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
             glClear(GL_COLOR_BUFFER_BIT);
         }
-    gl_state_bind_framebuffer(0);
+    gl_rend_state.bind_framebuffer(0);
 }
 
 void Shadow::ctrl() {
@@ -113,7 +113,7 @@ int32_t Shadow::init() {
     GLint swizzle[] = { GL_RED, GL_RED, GL_RED, GL_ONE };
     glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzle);
     glBindTexture(GL_TEXTURE_2D, 0);
-    gl_state_get_error();
+    gl_get_error_print();
     return 0;
 }
 

src/CRE/shared.cpp

@@ -4,13 +4,26 @@
 */
 
 #include "shared.hpp"
-#include "gl_state.hpp"
+#include "gl_rend_state.hpp"
 
 void fbo_blit(GLuint src_fbo, GLuint dst_fbo,
     GLint src_x, GLint src_y, GLint src_width, GLint src_height,
     GLint dst_x, GLint dst_y, GLint dst_width, GLint dst_height, GLbitfield mask, GLenum filter) {
-    gl_state_bind_read_framebuffer(src_fbo);
-    gl_state_bind_draw_framebuffer(dst_fbo);
+    gl_rend_state.bind_read_framebuffer(src_fbo);
+    gl_rend_state.bind_draw_framebuffer(dst_fbo);
     glBlitFramebuffer(src_x, src_y, src_x + src_width, src_y + src_height,
         dst_x, dst_y, dst_x + dst_width, dst_y + dst_height, mask, filter);
 }
+
+void gl_get_error_all_print() {
+    GLenum error;
+    while (error = glGetError())
+        printf_debug("GL Error: 0x%04X\n", error);
+}
+
+GLenum gl_get_error_print() {
+    GLenum error = glGetError();
+    if (error)
+        printf_debug("GL Error: 0x%04X\n", error);
+    return error;
+}

src/CRE/shared.hpp

@@ -21,3 +21,6 @@ enum blur_filter_mode {
 extern void fbo_blit(GLuint src_fbo, GLuint dst_fbo,
     GLint src_x, GLint src_y, GLint src_width, GLint src_height,
     GLint dst_x, GLint dst_y, GLint dst_width, GLint dst_height, GLbitfield mask, GLenum filter);
+
+extern void gl_get_error_all_print();
+extern GLenum gl_get_error_print();

src/CRE/sprite.cpp

@@ -785,7 +785,7 @@ namespace spr {
         if (index == 2 && resolution_mode != RESOLUTION_MODE_MAX)
             res_window_get()->resolution_mode = resolution_mode;
 
-        gl_state_rect viewport_rect = gl_state_get_viewport();
+        gl_rend_state_rect viewport_rect = gl_rend_state.get_viewport();
 
         for (int32_t i = 0; i < 2; i++) {
             auto reqlist = this->reqlist[index][i];
@@ -826,7 +826,7 @@ namespace spr {
                 y_min = (int32_t)min.y;
                 x_max = (int32_t)(max.x - min.x);
                 y_max = (int32_t)(max.y - min.y);
-                gl_state_set_viewport(x_min, y_min, x_max, y_max);
+                gl_rend_state.set_viewport(x_min, y_min, x_max, y_max);
             }
             else {
                 view_projection = vp;
@@ -861,12 +861,12 @@ namespace spr {
             rctx->sprite_scene_ubo.WriteMemory(shader_data);
             rctx->sprite_scene_ubo.Bind(0);
 
-            gl_state_bind_vertex_array(render_data.vao);
+            gl_rend_state.bind_vertex_array(render_data.vao);
             for (uint32_t j = SPR_PRIO_MAX; j; j--, reqlist++)
                 for (SprArgs& k : *reqlist)
                     if (k.sprite_draw_param_index >= 0)
                         draw_sprite(this, rctx, k, mat, x_min, y_min, x_max, y_max, overlay_tex);
-            gl_state_bind_vertex_array(0);
+            gl_rend_state.bind_vertex_array(0);
         }
 
         if (index == 2 && resolution_mode != RESOLUTION_MODE_MAX)
@@ -1796,7 +1796,7 @@ namespace spr {
         int32_t combiner = 0;
         if (draw_param.attrib.m.enable_blend) {
             if (draw_param.attrib.m.blend == 5) {
-                gl_state_active_bind_texture_2d(7, overlay_tex->glid);
+                gl_rend_state.active_bind_texture_2d(7, overlay_tex->glid);
                 draw_sprite_copy_overlay_texture(rctx, args, mat, draw_param.vtx, x_min, y_min, x_max, y_max);
                 combiner = 2;
             }
@@ -1805,11 +1805,11 @@ namespace spr {
 
             const GLenum* blend = spr_blend_param[draw_param.attrib.m.blend];
 
-            gl_state_enable_blend();
-            gl_state_set_blend_func_separate(blend[0], blend[1], blend[2], blend[3]);
+            gl_rend_state.enable_blend();
+            gl_rend_state.set_blend_func_separate(blend[0], blend[1], blend[2], blend[3]);
         }
         else
-            gl_state_disable_blend();
+            gl_rend_state.disable_blend();
 
         if (draw_param.shader == SHADER_FT_SPRITE) {
             int32_t tex_0_type = 0;
@@ -1838,21 +1838,21 @@ namespace spr {
         }
 
         if (draw_param.textures[0]) {
-            gl_state_active_bind_texture_2d(0, draw_param.textures[0]->glid);
-            gl_state_bind_sampler(0, rctx->sprite_samplers[draw_param.attrib.m.sampler]);
+            gl_rend_state.active_bind_texture_2d(0, draw_param.textures[0]->glid);
+            gl_rend_state.bind_sampler(0, rctx->sprite_samplers[draw_param.attrib.m.sampler]);
 
             if (draw_param.textures[1]) {
-                gl_state_active_bind_texture_2d(1, draw_param.textures[1]->glid);
-                gl_state_bind_sampler(1, rctx->sprite_samplers[draw_param.attrib.m.sampler]);
+                gl_rend_state.active_bind_texture_2d(1, draw_param.textures[1]->glid);
+                gl_rend_state.bind_sampler(1, rctx->sprite_samplers[draw_param.attrib.m.sampler]);
             }
-            else if (!gl_state.texture_binding_2d[1])
-                gl_state_active_bind_texture_2d(1, rctx->empty_texture_2d->glid);
+            else if (!gl_rend_state.texture_binding_2d[1])
+                gl_rend_state.active_bind_texture_2d(1, rctx->empty_texture_2d->glid);
         }
         else {
-            if (!gl_state.texture_binding_2d[0])
-                gl_state_active_bind_texture_2d(0, rctx->empty_texture_2d->glid);
-            if (!gl_state.texture_binding_2d[1])
-                gl_state_active_bind_texture_2d(1, rctx->empty_texture_2d->glid);
+            if (!gl_rend_state.texture_binding_2d[0])
+                gl_rend_state.active_bind_texture_2d(0, rctx->empty_texture_2d->glid);
+            if (!gl_rend_state.texture_binding_2d[1])
+                gl_rend_state.active_bind_texture_2d(1, rctx->empty_texture_2d->glid);
         }
 
         shaders_ft.set(draw_param.shader);
@@ -1864,13 +1864,13 @@ namespace spr {
     }
 
     static void draw_sprite_begin(render_context* rctx) {
-        gl_state_disable_blend();
-        gl_state_active_bind_texture_2d(0, rctx->empty_texture_2d->glid);
-        gl_state_bind_sampler(0, 0);
-        gl_state_active_bind_texture_2d(1, rctx->empty_texture_2d->glid);
-        gl_state_bind_sampler(1, 0);
-        gl_state_bind_sampler(7, 0);
-        gl_state_set_blend_func_separate(GL_ONE, GL_ZERO, GL_ONE, GL_ZERO);
+        gl_rend_state.disable_blend();
+        gl_rend_state.active_bind_texture_2d(0, rctx->empty_texture_2d->glid);
+        gl_rend_state.bind_sampler(0, 0);
+        gl_rend_state.active_bind_texture_2d(1, rctx->empty_texture_2d->glid);
+        gl_rend_state.bind_sampler(1, 0);
+        gl_rend_state.bind_sampler(7, 0);
+        gl_rend_state.set_blend_func_separate(GL_ONE, GL_ZERO, GL_ONE, GL_ZERO);
     }
 
     static void draw_sprite_copy_overlay_texture(render_context* rctx, const SprArgs& args, const mat4& mat,
@@ -1929,20 +1929,20 @@ namespace spr {
         const int32_t width = x_max - x_min + 1;
         const int32_t height = y_max - y_min + 1;
         if (width * height > 0) {
-            gl_state_active_texture(7);
+            gl_rend_state.active_texture(7);
             glCopyTexSubImage2D(GL_TEXTURE_2D, 0, x_min, y_min, x_min, y_min, width, height);
         }
     }
 
     static void draw_sprite_end() {
-        gl_state_disable_blend();
-        gl_state_active_bind_texture_2d(0, 0);
-        gl_state_bind_sampler(0, 0);
-        gl_state_active_bind_texture_2d(1, 0);
-        gl_state_bind_sampler(1, 0);
-        gl_state_active_bind_texture_2d(7, 0);
-        gl_state_bind_sampler(7, 0);
-        gl_state_set_blend_func_separate(GL_ONE, GL_ZERO, GL_ONE, GL_ZERO);
+        gl_rend_state.disable_blend();
+        gl_rend_state.active_bind_texture_2d(0, 0);
+        gl_rend_state.bind_sampler(0, 0);
+        gl_rend_state.active_bind_texture_2d(1, 0);
+        gl_rend_state.bind_sampler(1, 0);
+        gl_rend_state.active_bind_texture_2d(7, 0);
+        gl_rend_state.bind_sampler(7, 0);
+        gl_rend_state.set_blend_func_separate(GL_ONE, GL_ZERO, GL_ONE, GL_ZERO);
         shader::unbind();
     }
 

src/CRE/sprite.hpp

@@ -17,7 +17,7 @@
 #include "render_context.hpp"
 #include "resolution_mode.hpp"
 #include "texture.hpp"
-#include "gl_state.hpp"
+#include "gl_rend_state.hpp"
 
 #define BREAK_SPRITE_VERTEX_LIMIT (1)
 

src/CRE/texture.cpp

@@ -4,7 +4,8 @@
 */
 
 #include "texture.hpp"
-#include "gl_state.hpp"
+#include "gl_rend_state.hpp"
+#include "shared.hpp"
 #include "static_var.hpp"
 
 static void texture_bind(GLenum target, GLuint texture);
@@ -117,7 +118,7 @@ void texture_apply_color_tone(const texture* chg_tex,
             glTexSubImage2D(chg_tex->target, i, 0, 0, width, height,
                 GL_RGB, GL_UNSIGNED_SHORT_5_6_5, data);
         }
-        gl_state_get_error();
+        gl_get_error_print();
         free_def(data);
     }
     texture_bind(org_tex->target, 0);
@@ -145,7 +146,7 @@ texture* texture_create_copy_texture(texture_id id, texture* org_tex) {
             glGetCompressedTexImage(org_tex->target, i, data);
         else
             glGetTexImage(org_tex->target, i, format, type, data);
-        gl_state_get_error();
+        gl_get_error_print();
         vec_data.push_back(data);
     }
     texture_bind(org_tex->target, 0);
@@ -198,7 +199,7 @@ texture* texture_create_copy_texture_apply_color_tone(
         }
         else
             glGetTexImage(org_tex->target, i, format, type, data);
-        gl_state_get_error();
+        gl_get_error_print();
         vec_data.push_back(data);
     }
     texture_bind(org_tex->target, 0);
@@ -599,7 +600,7 @@ inline static GLuint texture_get_working_internal_format(GLuint internal_format)
 
 static int32_t texture_load_pixels(GLenum target, GLenum internal_format,
     int32_t width, int32_t height, int32_t level, const void* data) {
-    gl_state_get_all_gl_errors();
+    gl_get_error_all_print();
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
     switch (internal_format) {
     case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
@@ -618,7 +619,7 @@ static int32_t texture_load_pixels(GLenum target, GLenum internal_format,
         glTexImage2D(target, level, internal_format, width, height, 0, format, type, data);
     } break;
     }
-    return -(gl_state_get_error() != GL_ZERO);
+    return -(gl_get_error_print() != GL_ZERO);
 }
 
 static texture* texture_load_tex(texture_id id, GLenum target,

src/ReDIVA/app.cpp

@@ -25,7 +25,7 @@
 #include "../CRE/effect.hpp"
 #include "../CRE/file_handler.hpp"
 #include "../CRE/font.hpp"
-#include "../CRE/gl_state.hpp"
+#include "../CRE/gl_rend_state.hpp"
 #include "../CRE/hand_item.hpp"
 #include "../CRE/light_param.hpp"
 #include "../CRE/mdata_manager.hpp"
@@ -449,12 +449,12 @@ int32_t app_main(const app_init_struct& ais) {
 #if !(BAKE_PNG || BAKE_VIDEO)
             glfwGetFramebufferSize(window, &width, &height);
 #endif
-            gl_state_set_viewport(0, 0, width, height);
-            gl_state_disable_blend();
-            gl_state_disable_depth_test();
-            gl_state_set_depth_mask(GL_FALSE);
-            gl_state_disable_cull_face();
-            gl_state_disable_stencil_test();
+            gl_rend_state.set_viewport(0, 0, width, height);
+            gl_rend_state.disable_blend();
+            gl_rend_state.disable_depth_test();
+            gl_rend_state.set_depth_mask(GL_FALSE);
+            gl_rend_state.disable_cull_face();
+            gl_rend_state.disable_stencil_test();
 
             glfwSwapInterval(0);
 
@@ -527,8 +527,8 @@ bool app_render_data::load() {
         d3d_gl_handle = wglDXOpenDeviceNV(d3d_device);
 #endif
 
-    gl_state_get_error();
-    gl_state_set_viewport(0, 0, width, height);
+    gl_get_error_print();
+    gl_rend_state.set_viewport(0, 0, width, height);
 
 #if DISPLAY_IBL
     const float_t box_vertices[] = {
@@ -576,7 +576,7 @@ bool app_render_data::load() {
     };
 
     glGenVertexArrays(1, &ibl_vao);
-    gl_state_bind_vertex_array(ibl_vao, true);
+    gl_rend_state.bind_vertex_array(ibl_vao, true);
 
     ibl_vbo.Create(sizeof(box_vertices), box_vertices);
     ibl_vbo.Bind(true);
@@ -584,8 +584,8 @@ bool app_render_data::load() {
     glEnableVertexAttribArray(0);
     glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float_t) * 3, (void*)0);
 
-    gl_state_bind_array_buffer(0);
-    gl_state_bind_vertex_array(0);
+    gl_rend_state.bind_array_buffer(0);
+    gl_rend_state.bind_vertex_array(0);
 
     cubemap_display_ubo.Create(sizeof(cubemap_display_batch_shader_data));
 #endif
@@ -748,7 +748,7 @@ static render_context* render_context_load() {
     render_context* rctx = new render_context;
     rctx_ptr = rctx;
 
-    gl_state_get();
+    gl_rend_state.get();
 
     data_struct* aft_data = &data_list[DATA_AFT];
     aet_database* aft_aet_db = &aft_data->data_ft.aet_db;
@@ -1386,12 +1386,12 @@ static void render_context_ctrl(render_context* rctx) {
     camera* cam = rctx->camera;
 
     for (int32_t i = 0; i < 32; i++) {
-        if (!gl_state_check_texture_binding_2d(i) && !gl_state_check_texture_binding_cube_map(i))
+        if (!gl_rend_state.check_texture_binding_2d(i) && !gl_rend_state.check_texture_binding_cube_map(i))
             continue;
 
-        gl_state_active_bind_texture_2d(i, 0);
-        gl_state_active_bind_texture_cube_map(i, 0);
-        gl_state_bind_sampler(i, 0);
+        gl_rend_state.active_bind_texture_2d(i, 0);
+        gl_rend_state.active_bind_texture_cube_map(i, 0);
+        gl_rend_state.bind_sampler(i, 0);
     }
 
     global_context_menu = true;
@@ -1536,23 +1536,23 @@ static void render_context_disp(render_context* rctx) {
     static const GLint stencil_clear = 0;
 
     for (int32_t i = 0; i < 32; i++) {
-        if (!gl_state_check_texture_binding_2d(i) && !gl_state_check_texture_binding_cube_map(i))
+        if (!gl_rend_state.check_texture_binding_2d(i) && !gl_rend_state.check_texture_binding_cube_map(i))
             continue;
 
-        gl_state_active_bind_texture_2d(i, 0);
-        gl_state_active_bind_texture_cube_map(i, 0);
-        gl_state_bind_sampler(i, 0);
+        gl_rend_state.active_bind_texture_2d(i, 0);
+        gl_rend_state.active_bind_texture_cube_map(i, 0);
+        gl_rend_state.bind_sampler(i, 0);
     }
 
-    gl_state_bind_framebuffer(0);
-    gl_state_set_depth_mask(GL_TRUE);
-    gl_state_set_stencil_mask(0xFF);
+    gl_rend_state.bind_framebuffer(0);
+    gl_rend_state.set_depth_mask(GL_TRUE);
+    gl_rend_state.set_stencil_mask(0xFF);
     glClearBufferfv(GL_COLOR, 0, (float_t*)&color_clear);
     glClearDepthf(depth_clear);
-    gl_state_set_stencil_mask(0x00);
-    gl_state_set_depth_mask(GL_FALSE);
+    gl_rend_state.set_stencil_mask(0x00);
+    gl_rend_state.set_depth_mask(GL_FALSE);
 
-    gl_state_set_viewport(0, 0, internal_3d_res.x, internal_3d_res.y);
+    gl_rend_state.set_viewport(0, 0, internal_3d_res.x, internal_3d_res.y);
 
     rctx->disp();
 
@@ -1579,11 +1579,11 @@ static void render_context_disp(render_context* rctx) {
 
         rctx_ptr->glitter_batch_ubo.Bind(3);
         shaders_dev.set(SHADER_DEV_CUBEMAP_DISPLAY);
-        gl_state_bind_vertex_array(ibl_vao);
-        gl_state_active_bind_texture_cube_map(0,
+        gl_rend_state.bind_vertex_array(ibl_vao);
+        gl_rend_state.active_bind_texture_cube_map(0,
             light_param_data_storage_data_get_ibl_texture(max_def(ibl_index - 1, 0)));
         shaders_dev.draw_arrays(GL_TRIANGLES, 0, 36);
-        gl_state_bind_vertex_array(0);
+        gl_rend_state.bind_vertex_array(0);
     }
 #endif
 
@@ -1591,14 +1591,14 @@ static void render_context_disp(render_context* rctx) {
         Vulkan::end_render_pass(Vulkan::current_command_buffer);
 
 #if BAKE_PNG || BAKE_VIDEO
-        gl_state_set_viewport(0, 0, rctx->screen_width, rctx->screen_height);
+        gl_rend_state.set_viewport(0, 0, rctx->screen_width, rctx->screen_height);
 #else
-        gl_state_set_viewport(rctx->screen_x_offset, rctx->screen_y_offset,
+        gl_rend_state.set_viewport(rctx->screen_x_offset, rctx->screen_y_offset,
             rctx->sprite_width, rctx->sprite_height);
 #endif
 
-        gl_state_bind_framebuffer(0);
-        gl_state_active_bind_texture_2d(0, rctx->screen_buffer.GetColorTex());
+        gl_rend_state.bind_framebuffer(0);
+        gl_rend_state.active_bind_texture_2d(0, rctx->screen_buffer.GetColorTex());
         uniform_value[U_ALPHA_MASK] = 0;
         uniform_value[U_REDUCE] = 0;
         shaders_ft.set(SHADER_FT_REDUCE);

src/ReDIVA/data_edit/glitter_editor.cpp

@@ -17,7 +17,6 @@
 #include "../../CRE/app_system_detail.hpp"
 #include "../../CRE/camera.hpp"
 #include "../../CRE/data.hpp"
-#include "../../CRE/gl_state.hpp"
 #include "../../CRE/render_context.hpp"
 #include "../../CRE/stage.hpp"
 #include "../../CRE/static_var.hpp"

src/ReDIVA/x_pv_game.cpp

@@ -6336,11 +6336,11 @@ struct d3d_gl_fbo_tex_struct {
             handle = wglDXRegisterObjectNV(d3d_gl_handle, d3d_tex,
                 gl_tex, GL_TEXTURE_2D, WGL_ACCESS_READ_WRITE_NV);
         else {
-            gl_state_bind_texture_2d(gl_tex);
+            gl_rend_state.bind_texture_2d(gl_tex);
             ::texture* tex = rctx_ptr->screen_buffer.color_texture;
             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8,
                 tex->width, tex->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
-            gl_state_bind_texture_2d(0);
+            gl_rend_state.bind_texture_2d(0);
         }
 
         glGenFramebuffers(1, &gl_fbo);
@@ -6348,9 +6348,9 @@ struct d3d_gl_fbo_tex_struct {
             return;
 
         lock();
-        gl_state_bind_framebuffer(gl_fbo);
+        gl_rend_state.bind_framebuffer(gl_fbo);
         glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, gl_tex, 0);
-        gl_state_bind_framebuffer(0);
+        gl_rend_state.bind_framebuffer(0);
         unlock();
     }
 
@@ -6468,9 +6468,9 @@ bool x_pv_game::ctrl() {
             D3D11_MAPPED_SUBRESOURCE mapped_res = {};
             if (SUCCEEDED(d3d_device_context->Map(d3d_gl_fbo_tex.d3d_tex,
                 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_res))) {
-                gl_state_bind_texture_2d(d3d_gl_fbo_tex.gl_tex);
+                gl_rend_state.bind_texture_2d(d3d_gl_fbo_tex.gl_tex);
                 glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, nvenc_temp_pixels.data());
-                gl_state_bind_texture_2d(0);
+                gl_rend_state.bind_texture_2d(0);
 
                 uint8_t* src = (uint8_t*)nvenc_temp_pixels.data();
                 uint8_t* dst = (uint8_t*)mapped_res.pData;
@@ -6491,9 +6491,9 @@ bool x_pv_game::ctrl() {
             D3D11_MAPPED_SUBRESOURCE mapped_alpha_res = {};
             if (SUCCEEDED(d3d_device_context->Map(d3d_gl_alpha_fbo_tex.d3d_tex,
                 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_alpha_res))) {
-                gl_state_bind_texture_2d(d3d_gl_alpha_fbo_tex.gl_tex);
+                gl_rend_state.bind_texture_2d(d3d_gl_alpha_fbo_tex.gl_tex);
                 glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, nvenc_temp_pixels.data());
-                gl_state_bind_texture_2d(0);
+                gl_rend_state.bind_texture_2d(0);
 
                 uint8_t* src = (uint8_t*)nvenc_temp_pixels.data();
                 uint8_t* dst = (uint8_t*)mapped_alpha_res.pData;
@@ -6524,9 +6524,9 @@ bool x_pv_game::ctrl() {
 #elif BAKE_PNG
         std::vector<uint8_t> temp_pixels;
         temp_pixels.resize((size_t)width * (size_t)height * 4 * sizeof(uint8_t));
-        gl_state_bind_texture_2d(tex->glid);
+        gl_rend_state.bind_texture_2d(tex->glid);
         glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, temp_pixels.data());
-        gl_state_bind_texture_2d(0);
+        gl_rend_state.bind_texture_2d(0);
 
         std::vector<uint8_t> pixels;
         pixels.resize((size_t)width * (size_t)height * 4 * sizeof(uint8_t));
@@ -8183,16 +8183,16 @@ void x_pv_game::basic() {
 #if BAKE_VIDEO
         d3d_gl_fbo_tex.lock();
 
-        gl_state_bind_framebuffer(d3d_gl_fbo_tex.gl_fbo);
-        gl_state_active_bind_texture_2d(0, tex->glid);
-        gl_state_bind_sampler(0, rctx_ptr->render_samplers[1]);
+        gl_rend_state.bind_framebuffer(d3d_gl_fbo_tex.gl_fbo);
+        gl_rend_state.active_bind_texture_2d(0, tex->glid);
+        gl_rend_state.bind_sampler(0, rctx_ptr->render_samplers[1]);
 
 #if BAKE_VIDEO_ALPHA
         GLint swizzle_rgb1[] = { GL_RED, GL_GREEN, GL_BLUE, GL_ONE };
         glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzle_rgb1);
 #endif
 
-        gl_state_set_viewport(0, 0, width, height);
+        gl_rend_state.set_viewport(0, 0, width, height);
         if (nvenc_rgb)
             shaders_dev.set(SHADER_DEV_CONVERT_RGB);
         else
@@ -8216,7 +8216,7 @@ void x_pv_game::basic() {
 
         rctx_ptr->quad_ubo.WriteMemory(quad);
         rctx_ptr->quad_ubo.Bind(0);
-        gl_state_bind_vertex_array(rctx_ptr->common_vao);
+        gl_rend_state.bind_vertex_array(rctx_ptr->common_vao);
         shaders_dev.draw_arrays(GL_TRIANGLE_STRIP, 0, 4);
 
 #if BAKE_VIDEO_ALPHA
@@ -8224,24 +8224,24 @@ void x_pv_game::basic() {
         glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzle_rgba);
 #endif
 
-        gl_state_bind_sampler(0, 0);
-        gl_state_bind_texture_2d(0);
-        gl_state_bind_framebuffer(0);
+        gl_rend_state.bind_sampler(0, 0);
+        gl_rend_state.bind_texture_2d(0);
+        gl_rend_state.bind_framebuffer(0);
 
         d3d_gl_fbo_tex.unlock();
 
 #if BAKE_VIDEO_ALPHA
         d3d_gl_alpha_fbo_tex.lock();
 
-        gl_state_bind_framebuffer(d3d_gl_alpha_fbo_tex.gl_fbo);
-        gl_state_active_bind_texture_2d(0, tex->glid);
+        gl_rend_state.bind_framebuffer(d3d_gl_alpha_fbo_tex.gl_fbo);
+        gl_rend_state.active_bind_texture_2d(0, tex->glid);
 
         if (nvenc_rgb) {
             GLint swizzle_aaa1[] = { GL_ALPHA, GL_ALPHA, GL_ALPHA, GL_ONE };
             glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzle_aaa1);
         }
 
-        gl_state_set_viewport(0, 0, width, height);
+        gl_rend_state.set_viewport(0, 0, width, height);
         if (nvenc_rgb) {
             uniform_value[U_REDUCE] = 0;
             shaders_ft.set(SHADER_FT_REDUCE);
@@ -8254,8 +8254,8 @@ void x_pv_game::basic() {
         if (nvenc_rgb)
             glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzle_rgba);
 
-        gl_state_bind_texture_2d(0);
-        gl_state_bind_framebuffer(0);
+        gl_rend_state.bind_texture_2d(0);
+        gl_rend_state.bind_framebuffer(0);
 
         d3d_gl_alpha_fbo_tex.unlock();
 #endif