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);
+		sizex = width;
-		glfwGetWindowSize(window, &sizex, &sizey);
+		sizey = height;
 		g_current_engine->get_gui_renderer()->on_viewport_resize(width, height);
 	}
 

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) {
+	opengl::init();
-		glfwTerminate();
-		LOG_FATAL("GLEW init failed");
-	}
 	m_mesh_renderer.reset(new GLMeshRenderer);
 	m_gui_renderer.reset(new GLGUIRenderer(this));
 }

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().