Don't use GLEW for loading OpenGL functions

CMakeLists.txt

@@ -71,12 +71,6 @@ if(BUILD_CLIENT)
 	include_directories(${OPENGL_INCLUDE_DIR})
 	target_link_libraries(${PROJECT_NAME} "${OPENGL_LIBRARIES}")
 
-	if(NOT GLEW_INCLUDE_DIRS OR NOT GLEW_LIBRARIES)
-		find_package(GLEW REQUIRED)
-	endif()
-	include_directories("${GLEW_INCLUDE_DIRS}")
-	target_link_libraries(${PROJECT_NAME} "${GLEW_LIBRARIES}")
-
 	if(NOT GLFW3_INCLUDE_DIR OR NOT GLFW3_LIBRARY)
 		 find_package(GLFW3 REQUIRED)
 	endif()

src/game/core.hpp

@@ -36,9 +36,6 @@
 # include <io.h>
 #endif
 
-/* GLEW */
-#include <GL/glew.h>
-
 /* GLFW */
 #include <GLFW/glfw3.h>
 

src/game/engine/engine.cpp

@@ -30,10 +30,6 @@ SOFTWARE.
 #include "game/world/chunk_renderer.hpp"
 #include "game/screens/main_menu_screen.hpp"
 
-#include "vendor/imgui.h"
-#include "vendor/imgui_impl_glfw.h"
-#include "vendor/imgui_impl_opengl3.h"
-
 using namespace polygun::renderer;
 using namespace polygun::world;
 
@@ -42,8 +38,8 @@ static int sizex = SCR_WIDTH, sizey = SCR_HEIGHT;
 namespace polygun::engine {
 	static Engine* g_current_engine = nullptr;
 	static void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
-		glViewport(0, 0, width, height);
-		glfwGetWindowSize(window, &sizex, &sizey);
+		sizex = width;
+		sizey = height;
 		g_current_engine->get_gui_renderer()->on_viewport_resize(width, height);
 	}
 

src/game/engine/greedy_meshing.cpp

@@ -1,7 +1,7 @@
-#include "greedy_merging.hpp"
+#include "greedy_meshing.hpp"
 
 namespace polygun::engine {
-	cuboid_list greedy_merging::merge(world::Chunk& chunk) {
+	cuboid_list greedy_meshing::merge(world::Chunk& chunk) {
 		// create copy of chunk
 		world::Chunk chunk_copy = chunk;
 
@@ -107,7 +107,7 @@ namespace polygun::engine {
 							cuboid_end_x, cuboid_end_y, cuboid_end_z,
 							last_material
 						};
-						cuboids.cuboids.push_back(cuboid_to_append);
+						cuboids.push_back(cuboid_to_append);
 
 
 						// if last cuboid is touching current cuboid, use current position as current cuboid's start position
@@ -124,6 +124,32 @@ namespace polygun::engine {
 		}
 
 		return cuboids;
+	}
+
+	static int faces_indiecies[] = {
+		0, 1, 3, 0, 3, 2, // bottom
+		0, 2, 6, 0, 6, 4, // left
+		0, 4, 5, 0, 5, 1, // back
+		4, 7, 5, 4, 6, 7, // top
+		1, 5, 7, 1, 7, 3, // right
+		2, 7, 6, 2, 3, 7, // front
+	};
+	
+	static int slice_axises_indices[] {
+		0, 3, 2, 5, 1, 4, //  bottom/top face check
+		1, 4, 2, 5, 0, 3, //  left/right face check
+		0, 3, 1, 4, 2, 5 //   back/front face check
+	};
+
+	verticies_indices greedy_meshing::generate_mesh(world::Chunk& chunk) {
+		std::vector<unsigned int> verticies;
+		std::vector<unsigned int> indices;
+
+		cuboid_list cuboids = merge(chunk);
+/*
+		for(cuboid c : cuboids) {
+			
+		}*/
 
 	}
 }

src/game/engine/greedy_meshing.hpp

@@ -26,6 +26,7 @@ SOFTWARE.
 #ifndef POLYGUN_ENGINE_GREEDY_MERGING_HPP
 #define POLYGUN_ENGINE_GREEDY_MERGING_HPP
 
+#include "../core.hpp"
 #include "game/world/chunk.hpp"
 
 namespace polygun::engine {
@@ -33,18 +34,23 @@ namespace polygun::engine {
 		int x1, y1, z1, x2, y2, z2, material;
 	};
 
-	struct cuboid_list {
-		std::vector<cuboid> cuboids;
+	struct verticies_indices {
+		std::vector<unsigned int> verticies;
+		std::vector<unsigned int> indices;
 	};
 
-	class greedy_merging {
-		public:
-			greedy_merging() = default;
-			~greedy_merging() = default;
+	typedef std::vector<cuboid> cuboid_list;
 
-			cuboid_list merge(world::Chunk& chunk);
+	class greedy_meshing {
+		public:
+			greedy_meshing() = default;
+			~greedy_meshing() = default;
+
+			verticies_indices generate_mesh(world::Chunk& chunk);
 
 		private:
+			cuboid_list merge(world::Chunk& chunk);
+
 			const int voxel_count = 32;
 			const int voxel_max_idx = voxel_count - 1;
 
@@ -53,6 +59,8 @@ namespace polygun::engine {
 			int last_material, cuboid_start_x, cuboid_end_x, cuboid_end_z, cuboid_end_y;
 			bool cuboid_ended, invalid_row, invalid_plane;
 
+			int m_cuboid_verticies[3][8];
+
 	};
 }
 

src/game/engine/player_camera.cpp

@@ -82,7 +82,7 @@ void PlayerCamera::process_movement(camera_movement direction, float delta_time)
 	m_view = glm::lookAt(m_position, m_position + m_front, m_up);
 }
 
-void PlayerCamera::process_mouse_movement(float x_offset, float y_offset, GLboolean constrain_pitch) {
+void PlayerCamera::process_mouse_movement(float x_offset, float y_offset, bool constrain_pitch) {
 	x_offset *= m_mouse_sensitivity;
 	y_offset *= m_mouse_sensitivity;
 

src/game/engine/player_camera.hpp

@@ -41,7 +41,7 @@ namespace polygun::engine {
 
 		void update(bool reset);
 		void process_movement(camera_movement direction, float delta_time);
-		void process_mouse_movement(float x_offset, float y_offset, GLboolean constrain_pitch = true);
+		void process_mouse_movement(float x_offset, float y_offset, bool constrain_pitch = true);
 		void process_mouse_scroll(float y_offset);
 
 		static void mouse_callback(GLFWwindow* window, double x_pos_in, double y_pos_in);

src/game/renderer/gl/gl_gui_renderer.cpp

@@ -35,6 +35,11 @@ GLGUIRenderer::GLGUIRenderer(MasterRenderer* master_renderer) :
 	GUIRenderer(master_renderer)
 {}
 
+void GLGUIRenderer::on_viewport_resize(int width, int height) {
+	GUIRenderer::on_viewport_resize(width, height);
+	glViewport(0, 0, width, height);
+}
+
 void GLGUIRenderer::render_texture(const glm::vec2& pos, Texture* texture, const glm::vec2& scale, float angle, const glm::vec4& color) {
 	MeshRenderer* mesh_renderer = m_master_renderer->get_mesh_renderer();
 	mesh_renderer->set_camera(&m_camera);

src/game/renderer/gl/gl_gui_renderer.hpp

@@ -32,7 +32,9 @@ namespace polygun::renderer {
 	public:
 		GLGUIRenderer(MasterRenderer* master_renderer);
 
-		void render_texture(const glm::vec2& pos, Texture* texture, const glm::vec2& scale = glm::vec2(1, 1), float angle = 0, const glm::vec4& color = glm::vec4(1, 1, 1, 1)) override;
+		virtual void on_viewport_resize(int width, int height) override;
+		
+		virtual void render_texture(const glm::vec2& pos, Texture* texture, const glm::vec2& scale = glm::vec2(1, 1), float angle = 0, const glm::vec4& color = glm::vec4(1, 1, 1, 1)) override;
 	};
 }
 

src/game/renderer/gl/gl_texture.cpp

@@ -60,7 +60,8 @@ bool GLTexture::load_from_pixel_data(const uint8_t* data, unsigned width, unsign
 	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, format, GL_UNSIGNED_BYTE, data);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-	glGenerateMipmap(GL_TEXTURE_2D);
+	if(GLEW_ARB_framebuffer_object)
+		glGenerateMipmap(GL_TEXTURE_2D);
 
 	m_width = width;
 	m_height = height;

src/game/renderer/gl/opengl.cpp

@@ -0,0 +1,122 @@
+/*
+PolyGun
+
+Copyright (c) 2023 mrkubax10 <mrkubax10@onet.pl>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+// Simple OpenGL extension loader to replace GLEW because it has some problems
+
+#include "game/renderer/gl/opengl.hpp"
+
+#define GLFW_INCLUDE_NONE
+#include <GLFW/glfw3.h>
+
+#include "common/logger.hpp"
+
+bool GLEW_ARB_vertex_array_object;
+bool GLEW_ARB_framebuffer_object;
+
+PFNGLGENVERTEXARRAYSPROC glGenVertexArrays;
+PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays;
+PFNGLBINDVERTEXARRAYPROC glBindVertexArray;
+PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer;
+PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray;
+PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray;
+PFNGLGENBUFFERSPROC glGenBuffers;
+PFNGLDELETEBUFFERSPROC glDeleteBuffers;
+PFNGLBINDBUFFERPROC glBindBuffer;
+PFNGLBUFFERDATAPROC glBufferData;
+PFNGLGENERATEMIPMAPPROC glGenerateMipmap;
+PFNGLCREATEPROGRAMPROC glCreateProgram;
+PFNGLDELETEPROGRAMPROC glDeleteProgram;
+PFNGLATTACHSHADERPROC glAttachShader;
+PFNGLDETACHSHADERPROC glDetachShader;
+PFNGLLINKPROGRAMPROC glLinkProgram;
+PFNGLUSEPROGRAMPROC glUseProgram;
+PFNGLGETPROGRAMIVPROC glGetProgramiv;
+PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog;
+PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation;
+PFNGLUNIFORM1IPROC glUniform1i;
+PFNGLUNIFORM2FPROC glUniform2f;
+PFNGLUNIFORM3FPROC glUniform3f;
+PFNGLUNIFORM4FPROC glUniform4f;
+PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv;
+PFNGLGETATTRIBLOCATIONPROC glGetAttribLocation;
+PFNGLCREATESHADERPROC glCreateShader;
+PFNGLDELETESHADERPROC glDeleteShader;
+PFNGLSHADERSOURCEPROC glShaderSource;
+PFNGLCOMPILESHADERPROC glCompileShader;
+PFNGLGETSHADERIVPROC glGetShaderiv;
+PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;
+PFNGLBINDSAMPLERPROC glBindSampler;
+PFNGLDRAWELEMENTSBASEVERTEXPROC glDrawElementsBaseVertex;
+PFNGLBLENDEQUATIONSEPARATEPROC glBlendEquationSeparate;
+PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate;
+
+void polygun::opengl::init() {
+	GLEW_ARB_vertex_array_object = glfwExtensionSupported("GL_ARB_vertex_array_object");
+	if(GLEW_ARB_vertex_array_object)
+		LOG_INFO("Vertex Array Objects are supported by GPU");
+	else
+		LOG_INFO("Vertex Array Objects aren't supported by GPU");
+	GLEW_ARB_framebuffer_object = glfwExtensionSupported("GL_ARB_framebuffer_object");
+	if(GLEW_ARB_vertex_array_object)
+		LOG_INFO("Framebuffer Objects are supported by GPU");
+	else
+		LOG_INFO("Framebuffer Objects aren't supported by GPU");
+
+	glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)glfwGetProcAddress("glGenVertexArrays");
+	glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)glfwGetProcAddress("glDeleteVertexArrays");
+	glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)glfwGetProcAddress("glBindVertexArray");
+	glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)glfwGetProcAddress("glVertexAttribPointer");
+	glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)glfwGetProcAddress("glEnableVertexAttribArray");
+	glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)glfwGetProcAddress("glDisableVertexAttribArray");
+	glGenBuffers = (PFNGLGENBUFFERSPROC)glfwGetProcAddress("glGenBuffers");
+	glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)glfwGetProcAddress("glDeleteBuffers");
+	glBindBuffer = (PFNGLBINDBUFFERPROC)glfwGetProcAddress("glBindBuffer");
+	glBufferData = (PFNGLBUFFERDATAPROC)glfwGetProcAddress("glBufferData");
+	glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)glfwGetProcAddress("glGenerateMipmap");
+	glCreateProgram = (PFNGLCREATEPROGRAMPROC)glfwGetProcAddress("glCreateProgram");
+	glDeleteProgram = (PFNGLDELETEPROGRAMPROC)glfwGetProcAddress("glDeleteProgram");
+	glAttachShader = (PFNGLATTACHSHADERPROC)glfwGetProcAddress("glAttachShader");
+	glDetachShader = (PFNGLDETACHSHADERPROC)glfwGetProcAddress("glDetachShader");
+	glLinkProgram = (PFNGLLINKPROGRAMPROC)glfwGetProcAddress("glLinkProgram");
+	glUseProgram = (PFNGLUSEPROGRAMPROC)glfwGetProcAddress("glUseProgram");
+	glGetProgramiv = (PFNGLGETPROGRAMIVPROC)glfwGetProcAddress("glGetProgramiv");
+	glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)glfwGetProcAddress("glGetProgramInfoLog");
+	glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)glfwGetProcAddress("glGetUniformLocation");
+	glUniform1i = (PFNGLUNIFORM1IPROC)glfwGetProcAddress("glUniform1i");
+	glUniform2f = (PFNGLUNIFORM2FPROC)glfwGetProcAddress("glUniform2f");
+	glUniform3f = (PFNGLUNIFORM3FPROC)glfwGetProcAddress("glUniform3f");
+	glUniform4f = (PFNGLUNIFORM4FPROC)glfwGetProcAddress("glUniform4f");
+	glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)glfwGetProcAddress("glUniformMatrix4fv");
+	glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)glfwGetProcAddress("glGetAttribLocation");
+	glCreateShader = (PFNGLCREATESHADERPROC)glfwGetProcAddress("glCreateShader");
+	glDeleteShader = (PFNGLDELETESHADERPROC)glfwGetProcAddress("glDeleteShader");
+	glShaderSource = (PFNGLSHADERSOURCEPROC)glfwGetProcAddress("glShaderSource");
+	glCompileShader = (PFNGLCOMPILESHADERPROC)glfwGetProcAddress("glCompileShader");
+	glGetShaderiv = (PFNGLGETSHADERIVPROC)glfwGetProcAddress("glGetShaderiv");
+	glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)glfwGetProcAddress("glGetShaderInfoLog");
+	glBindSampler = (PFNGLBINDSAMPLERPROC)glfwGetProcAddress("glBindSampler");
+	glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)glfwGetProcAddress("glDrawElementsBaseVertex");
+	glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)glfwGetProcAddress("glBlendEquationSeparate");
+	glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)glfwGetProcAddress("glBlendFuncSeparate");
+}

src/game/renderer/gl/opengl.hpp

@@ -26,11 +26,55 @@ SOFTWARE.
 #define POLYGUN_RENDERER_OPENGL_HPP
 
 #if defined(__apple__)
-#include <OpenGL/glew.h>
 #include <OpenGL/gl.h>
+#include <OpenGL/glext.h>
 #else
-#include <GL/glew.h>
 #include <GL/gl.h>
+#include <GL/glext.h>
 #endif
 
+namespace polygun::opengl {
+	void init();
+}
+
+extern bool GLEW_ARB_vertex_array_object;
+extern bool GLEW_ARB_framebuffer_object;
+
+extern PFNGLGENVERTEXARRAYSPROC glGenVertexArrays;
+extern PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays;
+extern PFNGLBINDVERTEXARRAYPROC glBindVertexArray;
+extern PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer;
+extern PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray;
+extern PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray;
+extern PFNGLGENBUFFERSPROC glGenBuffers;
+extern PFNGLDELETEBUFFERSPROC glDeleteBuffers;
+extern PFNGLBINDBUFFERPROC glBindBuffer;
+extern PFNGLBUFFERDATAPROC glBufferData;
+extern PFNGLGENERATEMIPMAPPROC glGenerateMipmap;
+extern PFNGLCREATEPROGRAMPROC glCreateProgram;
+extern PFNGLDELETEPROGRAMPROC glDeleteProgram;
+extern PFNGLATTACHSHADERPROC glAttachShader;
+extern PFNGLDETACHSHADERPROC glDetachShader;
+extern PFNGLLINKPROGRAMPROC glLinkProgram;
+extern PFNGLUSEPROGRAMPROC glUseProgram;
+extern PFNGLGETPROGRAMIVPROC glGetProgramiv;
+extern PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog;
+extern PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation;
+extern PFNGLUNIFORM1IPROC glUniform1i;
+extern PFNGLUNIFORM2FPROC glUniform2f;
+extern PFNGLUNIFORM3FPROC glUniform3f;
+extern PFNGLUNIFORM4FPROC glUniform4f;
+extern PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv;
+extern PFNGLGETATTRIBLOCATIONPROC glGetAttribLocation;
+extern PFNGLCREATESHADERPROC glCreateShader;
+extern PFNGLDELETESHADERPROC glDeleteShader;
+extern PFNGLSHADERSOURCEPROC glShaderSource;
+extern PFNGLCOMPILESHADERPROC glCompileShader;
+extern PFNGLGETSHADERIVPROC glGetShaderiv;
+extern PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;
+extern PFNGLBINDSAMPLERPROC glBindSampler;
+extern PFNGLDRAWELEMENTSBASEVERTEXPROC glDrawElementsBaseVertex;
+extern PFNGLBLENDEQUATIONSEPARATEPROC glBlendEquationSeparate;
+extern PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate;
+
 #endif

src/game/renderer/gui_renderer.hpp

@@ -39,7 +39,7 @@ namespace polygun::renderer {
 		GUIRenderer(MasterRenderer* master_renderer);
 		virtual ~GUIRenderer();
 
-		void on_viewport_resize(int width, int height);
+		virtual void on_viewport_resize(int width, int height);
 
 		virtual void fill_rect(const glm::vec2& pos, const glm::vec2& size, const glm::vec4& color, float angle = 0);
 		virtual void render_texture(const glm::vec2& pos, Texture* texture, const glm::vec2& scale = glm::vec2(1, 1), float angle = 0, const glm::vec4& color = glm::vec4(1, 1, 1, 1)) = 0;

src/game/renderer/master_renderer.cpp

@@ -114,10 +114,7 @@ void MasterRenderer::create_opengl_renderer(GLFWwindow* window) {
 	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
 	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
 	glfwMakeContextCurrent(window);
-	if (glewInit() != GLEW_OK) {
-		glfwTerminate();
-		LOG_FATAL("GLEW init failed");
-	}
+	opengl::init();
 	m_mesh_renderer.reset(new GLMeshRenderer);
 	m_gui_renderer.reset(new GLGUIRenderer(this));
 }

src/game/screens/game_session_screen.cpp

@@ -147,7 +147,25 @@ GameSessionScreen::GameSessionScreen(const std::string& ip, unsigned short port,
 	m_game_state(GameState::GAME_STATE_JOINING),
 	m_texture_atlas()
 {}
+/*
+	class GUIRenderer {
+	public:
+		GUIRenderer(MasterRenderer* master_renderer);
+		virtual ~GUIRenderer();
 
+		void on_viewport_resize(int width, int height);
+
+		virtual void fill_rect(const glm::vec2& pos, const glm::vec2& size, const glm::vec4& color, float angle = 0);
+		virtual void render_texture(const glm::vec2& pos, Texture* texture, const glm::vec2& scale = glm::vec2(1, 1), float angle = 0, const glm::vec4& color = glm::vec4(1, 1, 1, 1)) = 0;
+
+	protected:
+		MasterRenderer* m_master_renderer;
+		Shader* m_textured_shader;
+		Shader* m_solid_shader;
+		Mesh* m_rect_mesh;
+		OrthoCamera m_camera;
+	};
+	*/
 void GameSessionScreen::begin() {
 #if defined(BUILD_SERVER)
 	if(m_start_server) {

src/vendor/imgui_impl_opengl3.h

@@ -41,6 +41,8 @@ IMGUI_IMPL_API void     ImGui_ImplOpenGL3_DestroyDeviceObjects();
 //#define IMGUI_IMPL_OPENGL_ES2     // Auto-detected on Emscripten
 //#define IMGUI_IMPL_OPENGL_ES3     // Auto-detected on iOS/Android
 
+#define IMGUI_IMPL_OPENGL_LOADER_CUSTOM "game/renderer/gl/opengl.hpp"
+
 // Attempt to auto-detect the default Desktop GL loader based on available header files.
 // If auto-detection fails or doesn't select the same GL loader file as used by your application,
 // you are likely to get a crash in ImGui_ImplOpenGL3_Init().