shaders.c

Go to the documentation of this file.

// shaders.c

#include <windows.h>

#include <commctrl.h>
#include <gl\gl.h>
#include <gl\glu.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <io.h>
#include <fcntl.h>
#include <string.h>

#define __gl2_main_
#include "..\gl2.h"

#include "shaders.h"

#define N_PROGRAMS_MAX 30

static GLuint vertList[N_PROGRAMS_MAX], fragList[N_PROGRAMS_MAX], progList[N_PROGRAMS_MAX];
static BOOL PluginsActiveID[N_PROGRAMS_MAX];
static BOOL bShadersLoaded=FALSE,bFailed=FALSE;

#define nPrograms 8
static char *ProgramListD[nPrograms]={"NULL","DPhong1","Dphong2","Dnoise","Dmapping","accum",NULL,NULL};
static char *ProgramListR[nPrograms]={"NULL","RPhong1","Rphong2","Rnoise","Rmapping","accum","ground","sky"};
static char *ProgramListT[nPrograms]={"NULL","TPhong1","Tphong2","Tnoise","Tmapping","accum","ground","sky"};

static char OFXroot[512];

static BOOL bTour=FALSE;

void ShadersInitTour(char *root){
  bTour=TRUE;
  ShadersInit(root,FALSE);
}

void ShadersInit(char *root, BOOL preview){
 int i;
 char folder[512]; 
 GLint status;
 char *vs1;
 char *fs1;
 char *list;
 bShadersLoaded=TRUE;
 for(i=0;i<N_PROGRAMS_MAX;i++)PluginsActiveID[i]=FALSE;
 strcpy(folder,root);
 strcpy(OFXroot,root);
 strcat(folder,"shaders\\");
 for(i=1;i<nPrograms;i++){
   PluginsActiveID[i]=TRUE;
   vs1=NULL; fs1=NULL;
   vertList[i] = -1;   fragList[i] = -1;   progList[i] = -1;
   if(bTour)list=ProgramListT[i];
   else list=(preview ? ProgramListD[i]: ProgramListR[i]);
   if(list == NULL)continue;
   if(gl2ReadShaderSource(list,folder, &vs1, &fs1) == 1 &&
     vs1 != NULL && fs1 != NULL){
     vertList[i] = glCreateShader(GL_VERTEX_SHADER);
     fragList[i] = glCreateShader(GL_FRAGMENT_SHADER);
     glShaderSource(vertList[i], 1, &vs1,NULL);
     glShaderSource(fragList[i], 1, &fs1,NULL);
     if(i != 5){
       glCompileShader(vertList[i]);
       glGetShaderiv(vertList[i],GL_COMPILE_STATUS,&status);
       if(status == GL_FALSE){MessageBox(NULL,"Error in Vertex shader",NULL,MB_OK); bFailed=TRUE;}
     } 
     glCompileShader(fragList[i]);
     glGetShaderiv(fragList[i],GL_COMPILE_STATUS,&status);
     if(status == GL_FALSE){MessageBox(NULL,"Error in Fragment shader",NULL,MB_OK); bFailed=TRUE;}
     progList[i] = glCreateProgram();
     if(i != 5)glAttachShader(progList[i],vertList[i]);
     glAttachShader(progList[i],fragList[i]);
     glLinkProgram(progList[i]);
   }
   else bShadersLoaded=FALSE;
   if(vs1 != NULL)free(vs1);
   if(fs1 != NULL)free(fs1);
 }
 if(!bShadersLoaded){
  MessageBox(NULL,"Could Not Load Shader Programs",NULL,MB_OK);
  bFailed=TRUE;
 }
}

static int GetNextPluginProgramID(void){
 int i; 
 for(i=nPrograms;i<N_PROGRAMS_MAX;i++)if(!PluginsActiveID[i])return i;
 return -1;
}

int LoadAndCompileShader(char *name){ // for plugin shaders
 BOOL bSucceeded=TRUE;
 char *vs1=NULL,*fs1=NULL;
 char folder[512];
 int id;
 GLint status;
 if(!bShadersLoaded)return -1;  // Only proceed if using OpenGL renderer and internal shaders loaded
 strcpy(folder,OFXroot);
 strcat(folder,"textures\\");
 if((id=GetNextPluginProgramID()) < 0)return -1;
 if(gl2ReadShaderSourceFunction(name,folder, "lighting", &vs1, &fs1) == 1 &&
    vs1 != NULL && fs1 != NULL){
   vertList[id] = glCreateShader(GL_VERTEX_SHADER);
   fragList[id] = glCreateShader(GL_FRAGMENT_SHADER);
   glShaderSource(vertList[id], 1, &vs1,NULL);
   glShaderSource(fragList[id], 1, &fs1,NULL);
   glCompileShader(vertList[id]);
   glGetShaderiv(vertList[id],GL_COMPILE_STATUS,&status);
   if(status == GL_FALSE){MessageBox(NULL,"Error in Plugin Vertex shader",name,MB_OK); bSucceeded=FALSE;}
   glCompileShader(fragList[id]);
   glGetShaderiv(fragList[id],GL_COMPILE_STATUS,&status);
   if(status == GL_FALSE){MessageBox(NULL,"Error in Plugin Fragment shader",name,MB_OK); bSucceeded=FALSE;}
   progList[id] = glCreateProgram();
   glAttachShader(progList[id],vertList[id]);
   glAttachShader(progList[id],fragList[id]);
   glLinkProgram(progList[id]);
 }
 else bSucceeded=FALSE;
 if(vs1 != NULL)free(vs1);
 if(fs1 != NULL)free(fs1);
 if(!bSucceeded)return -1;
 PluginsActiveID[id]=TRUE;   
 return id;
}

void UnloadCompiledShader(int id){
 if(!PluginsActiveID[id])return;
 if(glIsShader(vertList[id]) == GL_TRUE)glDeleteShader(vertList[id]);
 if(glIsShader(fragList[id]) == GL_TRUE)glDeleteShader(fragList[id]);
 if(glIsProgram(progList[id]) == GL_TRUE)glDeleteProgram(progList[id]);
 PluginsActiveID[id]=FALSE; 
}

void UseSingleShaderProgram(long id){
 if(id < 0)return;
 else if(id == 0)glUseProgram(0);
 else glUseProgram(progList[id]);
}

void UseShaderProgram(long id){
 if(!bShadersLoaded)return;
 if(id == 0)glUseProgram(0);
 else  glUseProgram(progList[id]);
}

void UnloadShaders(void){
 int i;
 if(!bShadersLoaded)return;
 for(i=1;i<nPrograms;i++){
   if(glIsShader(vertList[i]) == GL_TRUE)glDeleteShader(vertList[i]);
   if(glIsShader(fragList[i]) == GL_TRUE)glDeleteShader(fragList[i]);
   if(glIsProgram(progList[i]) == GL_TRUE)glDeleteProgram(progList[i]);
 }
 bShadersLoaded=FALSE;
}

void SetUniformInteger(int id, char *name, GLint val){
 GLint loc;
 if(bFailed)return;
 if((loc=glGetUniformLocation(progList[id],name)) == -1){;}
 //      MessageBox(NULL,"This variable is not in the Shader",name,MB_OK);
 else  glUniform1i(loc,val);
 
}

void SetUniformVariable(int id, char *name, GLfloat val){
 GLint loc;
 if(bFailed)return;
 if((loc=glGetUniformLocation(progList[id],name)) == -1){;}
 //       MessageBox(NULL,"This variable is not in the Shader",name,MB_OK);
 else  glUniform1f(loc,val);
}

void SetUniformVector(int id, char *name, GLfloat a, GLfloat b, GLfloat c){
 GLint loc;
 if(bFailed)return;
 if((loc=glGetUniformLocation(progList[id],name)) == -1){;}
 //      MessageBox(NULL,"This variable is not in the Shader",name,MB_OK);
 else glUniform3f(loc,a,b,c);
}

void SetUniformVector2(int id, char *name, GLfloat a, GLfloat b){
 GLint loc;
 if(bFailed)return;
 if((loc=glGetUniformLocation(progList[id],name)) == -1){;}
 //     MessageBox(NULL,"This variable is not in the Shader",name,MB_OK);
 else glUniform2f(loc,a,b);
}

void SetUniformMatrix3(int id, char *name, GLfloat m[3][3]){ // DOES NOT APPEAR TO send data to shader programs
 GLint loc;
 GLfloat mm[9];
 int i,j,k; for(i=0,k=0;i<3;i++)for(j=0;j<3;j++){mm[k]=m[i][j]; k++;}
 if(bFailed)return;
 if((loc=glGetUniformLocation(progList[id],name)) == -1)
      MessageBox(NULL,"This uniform matrix is not in the Shader",name,MB_OK);
 else  glUniformMatrix3fv(loc, 9, TRUE, mm);
}

void SetUniformMatrix4(int id, char *name, GLfloat m[4][4]){ // same as MAT3
 GLint loc;
 if(bFailed)return;
 if((loc=glGetUniformLocation(progList[id],name)) == -1)
      MessageBox(NULL,"This uniform 4 matrix is not in the Shader",name,MB_OK);
 else  glUniformMatrix3fv(loc, 16, TRUE, (GLfloat *)m);
}

void SetAttributeInteger(int id, char *name, GLshort val){
  GLint loc;
  if(bFailed)return;
  loc=glGetAttribLocation(progList[id],name);
  if(loc == -1){/*MessageBox(NULL,"This attribute is not in the Shader",name,MB_OK);*/ return;}
  glVertexAttrib1s(loc,val);
}

void SetAttributeVariable(int id, char *name, GLfloat val){
  GLint loc;
  if(bFailed)return;
  loc=glGetAttribLocation(progList[id],name);
  if(loc == -1){/*MessageBox(NULL,"This attribute is not in the Shader",name,MB_OK);*/ return;}
  glVertexAttrib1f(loc,val);
}

void SetAttributeVector(int id, char *name, GLfloat a, GLfloat b, GLfloat c){
 GLint loc;
 if(bFailed)return;
 loc=glGetAttribLocation(progList[id],name);
 if(loc == -1){/*MessageBox(NULL,"This attribute is not in the Shader",name,MB_OK);*/ return;}
 glVertexAttrib3f(loc,a,b,c);
}

void BindAttributeVector(int id, char *name, int loc){
 if(bFailed)return;
 glBindAttribLocation(progList[id],loc,name);
}

void SetAttributeVectorID(int id, int loc, GLfloat a, GLfloat b, GLfloat c){
 if(bFailed)return;
 glVertexAttrib3f(loc,a,b,c);
}

GLint GetAttibuteLocation(int id, char *name){
 GLint loc;
 if(bFailed)return -1;
 loc=glGetAttribLocation(progList[id],name);
 if(loc == -1){/*MessageBox(NULL,"This attribute is not in the Shader",name,MB_OK);*/ return -1;}
 return loc;
}