quick backup

[demo] / src / opengl / shader-gl.cc

diff --git a/src/opengl/shader-gl.cc b/src/opengl/shader-gl.cc
index 334a1cf..1ce36b7 100644 (file)
--- a/src/opengl/shader-gl.cc
+++ b/src/opengl/shader-gl.cc
@@ -2,6 +2,7 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "state_manager.h"
 #include "opengl/shader-gl.h"
 
 ShaderGL::ShaderGL()
@@ -29,6 +30,7 @@ bool ShaderGL::create(char *buf, unsigned int bsz, const char *fname)
                fprintf(stderr, "Unknown shader type.\n");
                return false;
        }
+       name = std::string(fname);
        sdr = glCreateShader(stype);
 
        /* compile */
@@ -73,17 +75,14 @@ void ShaderGL::destroy()
        type = SDR_UNKNOWN;
 }
 
-void ShaderGL::attach(unsigned int prog)
-{
-       glAttachShader(prog, sdr);
-}
-
 /* Shader Program */
 
 ShaderProgramGL::ShaderProgramGL()
 {
        prog = 0;
        memset(shaders, 0, sizeof shaders / sizeof *shaders);
+
+       is_linked = false;
 }
 
 ShaderProgramGL::~ShaderProgramGL()
@@ -91,29 +90,29 @@ ShaderProgramGL::~ShaderProgramGL()
        destroy();
 }
 
-void ShaderProgramGL::destroy()
+bool ShaderProgramGL::create()
 {
-       glDeleteProgram(prog);
-       prog = 0;
-
-       delete_shaders();
-}
-
-void ShaderProgramGL::delete_shaders()
-{
-       for(unsigned int i=0; i<(sizeof shaders) / (sizeof *shaders); ++i) {
-               delete shaders[i];
+       prog = glCreateProgram();
+       if(!prog) {
+               fprintf(stderr, "Failed to create shader program.\n");
+               return false;
        }
+       return true;
 }
 
 bool ShaderProgramGL::link()
 {
+       if(is_linked)
+               return true;
+
        glLinkProgram(prog);
 
        int status;
        glGetProgramiv(prog, GL_LINK_STATUS, &status);
-       if(status)
+       if(status) {
                printf("Successfully linked shader program.\n");
+               is_linked = true;
+       }
        else
                printf("Failed to link shader program.\n");
 
@@ -131,39 +130,119 @@ bool ShaderProgramGL::link()
        return status ? true : false;
 }
 
-bool ShaderProgramGL::load(const char *vfname, const char *ffname)
+bool ShaderProgramGL::use() const
 {
-       Shader *vsdr = new ShaderGL;
-       if(!vsdr->load(vfname, SDR_VERTEX)) {
-               delete vsdr;
+       if(!is_linked) { //&& !link()) {
                return false;
        }
 
-       Shader *fsdr = new ShaderGL;
-       if(!fsdr->load(ffname, SDR_FRAGMENT)) {
-               delete vsdr;
-               delete fsdr;
+       if(!prog) {
                return false;
        }
 
-       prog = glCreateProgram();
+       glUseProgram(prog);
+       return true;
+}
 
-       vsdr->attach(prog);
-       fsdr->attach(prog);
+void ShaderProgramGL::destroy()
+{
+       glDeleteProgram(prog);
+       prog = 0;
+       is_linked = false;
+}
 
-       if(!link()) {
-               delete vsdr;
-               delete fsdr;
-               glDeleteProgram(prog);
-               return false;
+void ShaderProgramGL::attach_shader(Shader *shader)
+{
+       glAttachShader(prog, ((ShaderGL *)shader)->sdr);
+       is_linked = false;
+}
+
+int ShaderProgramGL::get_uniform_location(const char *name) const
+{
+       if(!use())
+               return -1;
+
+       return glGetUniformLocation(prog, name);
+}
+
+void ShaderProgramGL::set_uniformi(int location, int value)
+{
+       if(!use() || location == -1) {
+               return;
        }
 
-       /* the order of shaders in the array is the order they have in
-       enum Type, so atm it goes like: VS, FS, ... because we have SDR_VERTEX,
-       SDR_FRAGMENT, ... */
+       glUniform1i(location, value);
+}
 
-       shaders[0] = vsdr;
-       shaders[1] = fsdr;
+void ShaderProgramGL::set_uniformi(int location, int x, int y)
+{
+       if(!use() || location == -1) {
+               return;
+       }
 
-       return true;
+       glUniform2i(location, x, y);
+}
+
+void ShaderProgramGL::set_uniformi(int location, int x, int y, int z)
+{
+       if(!use() || location == -1) {
+               return;
+       }
+
+       glUniform3i(location, x, y, z);
+}
+
+void ShaderProgramGL::set_uniformi(int location, int x, int y, int z, int w)
+{
+       if(!use() || location == -1) {
+               return;
+       }
+
+       glUniform4i(location, x, y, z, w);
+}
+
+void ShaderProgramGL::set_uniformf(int location, float value)
+{
+       if(!use() || location == -1) {
+               return;
+       }
+
+       glUniform1f(location, value);
+}
+
+void ShaderProgramGL::set_uniformf(int location, float x, float y)
+{
+       if(!use() || location == -1) {
+               return;
+       }
+
+       glUniform2f(location, x, y);
+}
+
+void ShaderProgramGL::set_uniformf(int location, float x, float y, float z)
+{
+       if(!use() || location == -1) {
+               return;
+       }
+
+       glUniform3f(location, x, y, z);
+}
+
+void ShaderProgramGL::set_uniformf(int location, float x, float y, float z, float w)
+{
+       if(!use() || location == -1) {
+               return;
+       }
+
+       glUniform4f(location, x, y, z, w);
+}
+
+void ShaderProgramGL::set_uniform_matrix(int location, const Mat4 &mat)
+{
+       if(!use() || location == -1) {
+               fprintf(stderr, "FOO\n");
+               return;
+       }
+
+       glUniformMatrix4fv(location, 1, GL_FALSE, mat[0]);
 }
\ No newline at end of file