light/modules/engine/src/platform/graphics/opengl/shader.cpp

#include <engine/platform/graphics/opengl/shader.hpp>
#include <glad/gl.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/matrix.hpp>

namespace Light {

glShader::glShader(BasicFileHandle vertexFile, BasicFileHandle pixelFile): m_ShaderID(0u)
{
	// create
	m_ShaderID = glCreateProgram();

	std::string vertexSource(vertexFile.GetData(), vertexFile.GetData() + vertexFile.GetSize());
	std::string pixelSource(pixelFile.GetData(), pixelFile.GetData() + pixelFile.GetSize());

	unsigned int vertexShader = CompileShader(vertexSource, Shader::Stage::VERTEX);
	unsigned int pixelShader = CompileShader(pixelSource, Shader::Stage::PIXEL);

	// attach shaders
	glAttachShader(m_ShaderID, vertexShader);
	glAttachShader(m_ShaderID, pixelShader);

	// link shader program
	glLinkProgram(m_ShaderID);

	// delete shaders (free memory)
	glDeleteShader(vertexShader);
	glDeleteShader(pixelShader);
}

glShader::~glShader()
{
	glDeleteProgram(m_ShaderID);
}

void glShader::Bind()
{
	glUseProgram(m_ShaderID);
}

void glShader::UnBind()
{
	glUseProgram(NULL);
}

// shaderc::SpvCompilationResult glShader::CompileGLSL(BasicFileHandle file, Shader::Stage stage)
// {
// 	// compile options
// 	shaderc::CompileOptions options;
// 	options.SetTargetEnvironment(shaderc_target_env_opengl, shaderc_env_version_opengl_4_5);
// 	options.SetOptimizationLevel(shaderc_optimization_level_performance);
//
// 	// compile
// 	shaderc::Compiler compiler;
// 	shaderc::SpvCompilationResult result = compiler.CompileGlslToSpv(reinterpret_cast<const
// char*>(file.GetData()), stage == Shader::Stage::VERTEX ?
// shaderc_shader_kind::shaderc_vertex_shader : shaderc_shader_kind::shaderc_fragment_shader,
// file.GetName().c_str(), options);
//
// 	// log error
// 	if (result.GetCompilationStatus() != shaderc_compilation_status_success)
// 	{
// 		LOG(err, "Failed to compile {} shader at {}...", stage == Shader::Stage::VERTEX ? "vertex" :
// "pixel", file.GetPath()); 		LOG(err, "    {}", result.GetErrorMessage());
// 	}
//
// 	return result;
// }

unsigned int glShader::CompileShader(std::string source, Shader::Stage stage)
{
	// &(address of) needs an lvalue
	const char *lvalue_source = source.c_str();
	unsigned int shader = glCreateShader(
	    stage == Shader::Stage::VERTEX   ? GL_VERTEX_SHADER :
	    stage == Shader::Stage::PIXEL    ? GL_FRAGMENT_SHADER :
	    stage == Shader::Stage::GEOMETRY ? GL_GEOMETRY_SHADER :
	                                       NULL
	);

	// compile
	glShaderSource(shader, 1, &lvalue_source, NULL);
	glCompileShader(shader);

	// check
	int isCompiled = 0;
	glGetShaderiv(shader, GL_COMPILE_STATUS, &isCompiled);
	if (isCompiled == GL_FALSE)
	{
		int logLength = 0;
		glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLength);

		char *errorLog = (char *)alloca(logLength);
		glGetShaderInfoLog(shader, logLength, &logLength, &errorLog[0]);

		LOG(err,
		    "glShader::glShader: failed to compile {} shader:\n        {}",
		    stage == Shader::Stage::VERTEX ? "Vertex" : "Pixel",
		    errorLog);

		return NULL;
	}
#define LIGHT_OPENGL_ENABLE_SHADER_INFO_LOG
#ifdef LIGHT_OPENGL_ENABLE_SHADER_INFO_LOG
	// info log
	{
		int logLength = 0;
		glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLength);
		if (logLength)
		{
			char *infoLog = (char *)alloca(logLength);
			glGetShaderInfoLog(shader, logLength, &logLength, &infoLog[0]);

			LOG(warn, infoLog);
		}
	}
#endif

	return shader;
}

} // namespace Light