rename engine to src

src/shader.cpp

@@ -0,0 +1,201 @@
+#include "pch.h"
+#include "log.h"
+#include "shader.h"
+
+using namespace ui;
+
+std::map<kShader, Shader> ShaderManager::m_shaders;
+Shader* ShaderManager::m_current;
+
+bool Shader::create(const char* vertex, const char* fragment)
+{
+    GLint status;
+    static char infolog[4096];
+    int infolen;
+    const GLchar* source;
+    
+    auto vs = glCreateShader(GL_VERTEX_SHADER);
+    if (!vs)
+    {
+        return false;
+    }
+    source = vertex;
+    glShaderSource(vs, 1, &source, nullptr);
+    glCompileShader(vs);
+    glGetShaderiv(vs, GL_COMPILE_STATUS, &status);
+    glGetShaderInfoLog(vs, sizeof(infolog), &infolen, infolog);
+    if (infolen > 0)
+        LOG("VERTEX SHADER:\n%s", infolog);
+    if (status == 0)
+    {
+        glDeleteShader(vs);
+        return false;
+    }
+    
+    auto fs = glCreateShader(GL_FRAGMENT_SHADER);
+    if (!fs)
+    {
+        glDeleteShader(vs);
+        return false;
+    }
+    source = fragment;
+    glShaderSource(fs, 1, &source, nullptr);
+    glCompileShader(fs);
+    glGetShaderiv(fs, GL_COMPILE_STATUS, &status);
+    glGetShaderInfoLog(fs, sizeof(infolog), &infolen, infolog);
+    if (infolen > 0)
+        LOG("FRAGMENT SHADER:\n%s", infolog);
+    if (status == 0)
+    {
+        glDeleteShader(vs);
+        glDeleteShader(fs);
+        return false;
+    }
+    
+    auto ps = glCreateProgram();
+    if (!ps)
+    {
+        glDeleteShader(vs);
+        glDeleteShader(fs);
+        return false;
+    }
+    glAttachShader(ps, vs);
+    glAttachShader(ps, fs);
+    glDeleteShader(vs);
+    glDeleteShader(fs);
+    
+    glLinkProgram(ps);
+    if (glGetAttribLocation(ps, "pos") != -1)
+        glBindAttribLocation(ps, 0, "pos");
+    
+    if (glGetAttribLocation(ps, "uvs") != -1)
+        glBindAttribLocation(ps, 1, "uvs");
+    
+    if (glGetAttribLocation(ps, "uvs2") != -1)
+        glBindAttribLocation(ps, 2, "uvs2");
+
+    if (glGetAttribLocation(ps, "col") != -1)
+        glBindAttribLocation(ps, 3, "col");
+
+    glLinkProgram(ps);
+    glGetProgramiv(ps, GL_LINK_STATUS, &status);
+    glGetProgramInfoLog(ps, sizeof(infolog), &infolen, infolog);
+    if (infolen > 0)
+        LOG("LINK SHADER:\n%s", infolog);
+    if (status == 0)
+    {
+        glDeleteProgram(ps);
+        return false;
+    }
+
+    // Parse shader uniforms
+    {
+        GLint count;
+        GLint size; // size of the variable
+        GLenum type; // type of the variable (float, vec3 or mat4, etc)
+        const GLsizei bufSize = 16; // maximum name length
+        GLchar name[bufSize]; // variable name in GLSL
+        GLsizei length; // name length
+        glGetProgramiv(ps, GL_ACTIVE_UNIFORMS, &count);
+        for (int i = 0; i < count; i++)
+        {
+            glGetActiveUniform(ps, (GLuint)i, bufSize, &length, &size, &type, name);
+            m_umap[(kShaderUniform)const_hash(name)] = glGetUniformLocation(ps, name);
+            //printf("Uniform #%d Type: %u Name: %s Loc: %d\n", i, type, name, glGetUniformLocation(ps, name));
+        }
+    }
+    
+    prog = ps;
+    
+    return true;
+}
+void Shader::use()
+{
+    glUseProgram(prog);
+}
+void Shader::u_vec4(kShaderUniform id, const glm::vec4& v)
+{
+    if (m_umap.count(id) == 0) LOG("UNIFORM vec4 %d NOT FOUND in shader %d", (int)id, (int)name)
+    else glUniform4fv(m_umap[id], 1, glm::value_ptr(v));
+}
+
+void Shader::u_vec2(kShaderUniform id, const glm::vec2& v)
+{
+    if (m_umap.count(id) == 0) LOG("UNIFORM vec2 %d NOT FOUND in shader %d", (int)id, (int)name)
+    else glUniform2fv(m_umap[id], 1, glm::value_ptr(v));
+}
+
+void Shader::u_mat4(kShaderUniform id, const glm::mat4& m)
+{
+    if (m_umap.count(id) == 0) LOG("UNIFORM mat4 %d NOT FOUND in shader %d", (int)id, (int)name)
+    else glUniformMatrix4fv(m_umap[id], 1, GL_FALSE, glm::value_ptr(m));
+}
+void Shader::u_int(kShaderUniform id, int i)
+{
+    if (m_umap.count(id) == 0)
+        LOG("UNIFORM int %d NOT FOUND in shader %d", (int)id, (int)name)
+    else
+        glUniform1i(m_umap[id], i);
+}
+void Shader::u_float(kShaderUniform id, float f)
+{
+    if (m_umap.count(id) == 0) LOG("UNIFORM float %d NOT FOUND in shader %d", (int)id, (int)name)
+    else glUniform1f(m_umap[id], f);
+}
+GLint ui::Shader::GetAttribLocation(const char* name)
+{
+    return glGetAttribLocation(prog, name);
+}
+bool ShaderManager::create(kShader id, const char* vertex, const char* fragment)
+{
+    m_shaders[id].name = id;
+    return m_shaders[id].create(vertex, fragment);
+}
+
+void ShaderManager::use(kShader id)
+{
+    m_current = &m_shaders[id];
+    m_current->use();
+}
+
+void ShaderManager::use(const char* name)
+{
+    m_current = &m_shaders[(kShader)const_hash(name)];
+    m_current->use();
+}
+
+void ShaderManager::u_vec4(kShaderUniform id, const glm::vec4& v)
+{
+    m_current->u_vec4(id, v);
+}
+
+void ShaderManager::u_vec2(kShaderUniform id, const glm::vec2& v)
+{
+    m_current->u_vec2(id, v);
+}
+
+void ShaderManager::u_mat4(kShaderUniform id, const glm::mat4& m)
+{
+    m_current->u_mat4(id, m);
+}
+
+void ShaderManager::u_int(kShaderUniform id, int i)
+{
+    m_current->u_int(id, i);
+}
+
+Shader* ui::ShaderManager::get(kShader id)
+{
+    auto it = m_shaders.find(id);
+    return (it == m_shaders.end()) ? nullptr : &it->second;
+}
+
+void ui::ShaderManager::u_float(kShaderUniform id, float f)
+{
+    m_current->u_float(id, f);
+}
+
+void ShaderManager::invalidate()
+{
+    m_shaders.clear();
+}