• Main Page
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

src/render/src/Shader.cpp

Go to the documentation of this file.
00001 #include "../pch.h"
00002 
00003 #define SHADER_STRING_LENGTH 4096
00004 char shaderString[SHADER_STRING_LENGTH];
00005 
00006 Uniform::Uniform(void)
00007 : uniformLocation(-1)
00008 {
00009 }
00010 
00011 Uniform::Uniform(GLint uniformLocation)
00012 : uniformLocation(uniformLocation)
00013 {
00014         if(uniformLocation < 0)
00015                 printf("%s\n", "Invalid uniform.");
00016 }
00017 
00018 Uniform::Uniform(const Uniform& other)
00019 : uniformLocation(other.uniformLocation)
00020 {
00021 }
00022 
00023 Uniform::~Uniform(void)
00024 {
00025 }
00026 
00027 void Uniform::set1i(const int value)
00028 {
00029         glUniform1i(uniformLocation, value);
00030 }
00031 
00032 void Uniform::set1f(const float value)
00033 {
00034         glUniform1f(uniformLocation, value);
00035 }
00036 
00037 void Uniform::set2f(const float value1, const float value2)
00038 {
00039         glUniform2f(uniformLocation, value1, value2);
00040 }
00041 
00042 void Uniform::set3fv(const float3* values, int num)
00043 {
00044         glUniform3fv(uniformLocation, num, (float*)values);
00045 }
00046 
00047 void Uniform::set4fv(const float4* values, int num)
00048 {
00049         glUniform4fv(uniformLocation, num, (float*)values);
00050 }
00051 
00052 void Uniform::set3x3fv(const float3x3* values, int num)
00053 {
00054         glUniformMatrix3fv(uniformLocation, num, true, (float*)values);
00055 }
00056 
00057 void Uniform::set4x4fv(const float4x4* values, int num)
00058 {
00059         glUniformMatrix4fv(uniformLocation, num, true, (float*)values);
00060 }
00061 
00062 Shader::Shader(void)
00063 : program(0)
00064 {
00065         m_isGui = false;
00066 }
00067 
00068 Shader::Shader(const wchar* vertexShaderFilename, const wchar* pixelShaderFilename)
00069 : program(0)
00070 {
00071         init(vertexShaderFilename, pixelShaderFilename);
00072 }
00073 
00074 Shader::~Shader(void)
00075 {
00076         uninit();
00077 }
00078 
00079 bool Shader::init(const wchar* vertexShaderFilename, const wchar* pixelShaderFilename)
00080 {
00081         if(program)
00082                 return false;
00083 
00084         program = glCreateProgram();
00085 
00086         bool ok = true;
00087         GLint status;
00088 
00089         const wchar* shaderFilename[2] = {
00090                 vertexShaderFilename,
00091                 pixelShaderFilename
00092         };
00093 
00094         GLuint shaders[2] = {
00095                 glCreateShader(GL_VERTEX_SHADER),
00096                 glCreateShader(GL_FRAGMENT_SHADER)
00097         };
00098 
00099         for(int i=0; i<2; i++){
00100                 FILE* file;
00101                 if(_wfopen_s(&file, shaderFilename[i], TEXT("rb")) != 0)
00102                 {
00103                         printf("File '%s' not found.", shaderFilename[i]);
00104                         ok = false;
00105                         break;
00106                 }
00107 
00108                 size_t strLength = fread(shaderString, sizeof(char), SHADER_STRING_LENGTH, file);
00109                 
00110                 if(strLength >= SHADER_STRING_LENGTH)
00111                 {
00112                         ok = false;
00113                         fclose(file);
00114                         break;
00115                 }
00116 
00117                 shaderString[strLength] = '\0';
00118                 
00119                 GLchar* shade = (GLchar*)&shaderString;
00120 
00121                 glShaderSource(shaders[i], 1, (const GLchar**)&shade, NULL);
00122                 glCompileShader(shaders[i]);
00123                 // check for compilation errors
00124                 glGetShaderiv(shaders[i], GL_COMPILE_STATUS, &status);
00125                 if(status == GL_TRUE)
00126                 {
00127                         glAttachShader(program, shaders[i]);
00128                 }
00129                 else
00130                 {
00131                         GLsizei infosize = 0;
00132                         glGetShaderInfoLog(shaders[i], SHADER_STRING_LENGTH, &infosize, shaderString);
00133                         printf("%s", shaderString);
00134                         ok = false;
00135                         break;
00136                 }
00137         }
00138 
00139         if(ok){
00140                 glBindAttribLocation(program, POSITION, "position");
00141                 glBindAttribLocation(program, NORMAL, "normal");
00142                 glBindAttribLocation(program, TANGENT, "tangent");
00143                 glBindAttribLocation(program, BITANGENT, "binormal");
00144                 glBindAttribLocation(program, COLOR, "color");
00145                 glBindAttribLocation(program, UV, "uv");
00146                 glBindAttribLocation(program, BONES, "bones");
00147                 glBindAttribLocation(program, WEIGHTS, "weights");
00148                 glLinkProgram(program);
00149                 glGetProgramiv(program, GL_LINK_STATUS, &status);
00150                 if(status != GL_TRUE)
00151                 {
00152                         GLsizei infosize = 0;
00153                         glGetProgramInfoLog(program, SHADER_STRING_LENGTH, &infosize, shaderString);
00154                         printf("%s", shaderString);
00155                         ok = false;
00156                 }
00157         }
00158 
00159         if(ok == false)
00160         {
00161                 uninit();
00162                 return false;
00163         }
00164 
00165         return true;
00166 }
00167 
00168 void Shader::uninit(void)
00169 {
00170         if(program){
00171                 GLsizei size;
00172                 GLuint attatchedShaders[2];
00173                 glGetAttachedShaders(program, 2, &size, attatchedShaders);
00174                 // detatch and delete shaders from the program
00175                 for(int j=0; j<size; j++){
00176                         glDetachShader(program, attatchedShaders[j]);
00177                         glDeleteShader(attatchedShaders[j]);
00178                 }
00179                 glDeleteProgram(program);
00180                 program = 0;
00181         }
00182 }
00183 
00184 Uniform Shader::getUniform(const char* uniformName)
00185 {
00186         return Uniform(glGetUniformLocation(program, uniformName));
00187 }
00188 
00189 void Shader::use(void)
00190 {
00191         glUseProgram(program);
00192 }

Generated on Fri Jun 18 2010 17:48:39 for Cannonball by  doxygen 1.7.0