Renderer.cpp

#include "Renderer.h"

namespace ogl_lib
{
	Renderer::Renderer()
	{
		if (!glfwInit())
		{
			throw std::runtime_error("Failed to initialize GLFW");
		}
		active_shader_id_ = 0;
	}

	Renderer::~Renderer()
	{
		shutdown_opengl();
	}

	void Renderer::initialize_opengl()
	{
		if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
		{
			throw std::runtime_error("Failed to initialize GLAD");
		}
		glEnable(GL_DEPTH_TEST);
	}

	void Renderer::shutdown_opengl()
	{
		glfwTerminate();
		window_ = nullptr;
		active_shader_id_ = 0;

	}

	void Renderer::create_window(int width, int height, const char* title)
	{
		window_ = glfwCreateWindow(width, height, title, nullptr, nullptr);
		if (!window_)
		{
			throw std::runtime_error("Failed to create GLFW window");
		}
		glfwMakeContextCurrent(window_);
	}

	void Renderer::clear_screen(float r, float g, float b, float a)
	{
		glClearColor(r, g, b, a);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	}

	void Renderer::swap_buffers()
	{
		if (window_)
			glfwSwapBuffers(window_);
	}

	void Renderer::set_viewport(int x, int y, int width, int height)
	{
		glViewport(x, y, width, height);
	}
		
	std::string Renderer::read_file(const char* path) const
	{
		std::ifstream file(path);
		if (!file)
			throw std::runtime_error(std::string("Failed to open shader file: ") + path);
		std::stringstream ss;
		ss << file.rdbuf();
		return ss.str();
	}

	void Renderer::load_shader(const char* vertexPath, const char* fragmentPath)
	{
		std::string vertexCode = read_file(vertexPath);
		std::string fragmentCode = read_file(fragmentPath);

		const char* vShaderCode = vertexCode.c_str();
		const char* fShaderCode = fragmentCode.c_str();

		unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
		glShaderSource(vertexShader, 1, &vShaderCode, nullptr);
		glCompileShader(vertexShader);

		int success;
		glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
		if (!success)
		{
			char infoLog[512];
			glGetShaderInfoLog(vertexShader, 512, nullptr, infoLog);
			throw std::runtime_error(std::string("Vertex shader compilation failed: ") + infoLog);
		}

		unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
		glShaderSource(fragmentShader, 1, &fShaderCode, nullptr);
		glCompileShader(fragmentShader);

		glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
		if (!success)
		{
			char infoLog[512];
			glGetShaderInfoLog(fragmentShader, 512, nullptr, infoLog);
			throw std::runtime_error(std::string("Fragment shader compilation failed: ") + infoLog);
		}

		unsigned int shaderProgram = glCreateProgram();
		glAttachShader(shaderProgram, vertexShader);
		glAttachShader(shaderProgram, fragmentShader);
		glLinkProgram(shaderProgram);

			glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
		if (!success)
		{
			char infoLog[512];
			glGetProgramInfoLog(shaderProgram, 512, nullptr, infoLog);
			throw std::runtime_error(std::string("Shader program linking failed: ") + infoLog);
		}

		glDeleteShader(vertexShader);
		glDeleteShader(fragmentShader);

		active_shader_id_ = shaderProgram;
	}

	void Renderer::use_shader(unsigned int shaderID)
	{
		glUseProgram(shaderID);
		active_shader_id_ = shaderID;
	}

	void Renderer::set_uniform(const char* name, float value)
	{
		GLint location = glGetUniformLocation(active_shader_id_, name);
		if (location == -1)
			throw std::runtime_error(std::string("Uniform not found: ") + name);
		glUniform1f(location, value);
	}

	unsigned int Renderer::create_vertex_buffer(const float* data, size_t size)
	{
		unsigned int VBO;
		glGenBuffers(1, &VBO);
		glBindBuffer(GL_ARRAY_BUFFER, VBO);
		glBufferData(GL_ARRAY_BUFFER, size * sizeof(float), data, GL_STATIC_DRAW);
		return VBO;
	}

	void Renderer::bind_vertex_array(unsigned int vaoID)
	{
		glBindVertexArray(vaoID);
	}

	unsigned int Renderer::load_texture(const char* imagePath)
	{
		int width, height, nrChannels;
		unsigned char* data = stbi_load(imagePath, &width, &height, &nrChannels, 0);
		if (!data)
		{
			throw std::runtime_error(std::string("Failed to load texture image: ") + imagePath);
		}

		unsigned int textureID;
		glGenTextures(1, &textureID);
		glBindTexture(GL_TEXTURE_2D, textureID);

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

		GLenum format = GL_RGB;
		if (nrChannels == 1) format = GL_RED;
		else if (nrChannels == 3) format = GL_RGB;
		else if (nrChannels == 4) format = GL_RGBA;

		glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
		glGenerateMipmap(GL_TEXTURE_2D);

		stbi_image_free(data);

		return textureID;
	}

	void Renderer::bind_texture(unsigned int textureID)
	{
		glBindTexture(GL_TEXTURE_2D, textureID);
	}

	void Renderer::draw_arrays(int mode, int first, int count)
	{
		glDrawArrays(mode, first, count);
	}

	void Renderer::draw_elements(int mode, int count, int type, const void* indices)
	{
		glDrawElements(mode, count, type, indices);
	}

	void Renderer::enable_depth_test(bool enable)
	{
		if (enable)
			glEnable(GL_DEPTH_TEST);
		else
			glDisable(GL_DEPTH_TEST);
	}

	void Renderer::set_blend_mode(int mode)
	{
		glBlendFunc(GL_SRC_ALPHA, mode);
	}

	void Renderer::check_errors() const
	{
		GLenum err;
		while ((err = glGetError()) != GL_NO_ERROR)
		{
			throw std::runtime_error(std::string("OpenGL error occurred: ") + std::to_string(err));
		}
	}
}