Main Page | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Globals

pge::GPUProgram Class Reference

#include <GPUProgram.h>


Public Member Functions

 GPUProgram (const std::string &vertexSourceFile, const std::string &fragmentSourceFile)
virtual ~GPUProgram (void)
void bind (void)
void release (void)
void passUniform1i (char *name, int value)
void passUniform1f (char *name, float value)
void passUniform3f (char *name, float v1, float v2, float v3)
void passUniform3f (char *name, Vector3f value)
void passUniform4f (char *name, float v1, float v2, float v3, float v4)
void passUniform4f (char *name, Vector4f value)
void passUniformMatrix4f (char *name, float *value)

Private Member Functions

bool createPrograms (void)
std::string loadProgram (const std::string &filename)
void printLog (GLhandleARB handle)

Private Attributes

std::string m_vertexSource
std::string m_fragmentSource
GLhandleARB m_programObject
GLhandleARB m_vertexShader
GLhandleARB m_fragmentShader


Constructor & Destructor Documentation

pge::GPUProgram::GPUProgram const std::string &  vertexSourceFile,
const std::string &  fragmentSourceFile
 

Definition at line 19 of file GPUProgram.cpp.

References createPrograms(), loadProgram(), m_fragmentSource, and m_vertexSource.

00019                                                                                                      {
00020                 m_vertexSource = loadProgram(vertexSourceFile);
00021                 m_fragmentSource = loadProgram(fragmentSourceFile);
00022 
00023                 if(!createPrograms()) {
00024                         printf("Error: [%s] Could not create shader objects (%s).\n", __FILE__, vertexSourceFile.c_str());
00025                 }
00026         }

Here is the call graph for this function:

pge::GPUProgram::~GPUProgram void   )  [virtual]
 

Definition at line 34 of file GPUProgram.cpp.

References m_fragmentShader, m_programObject, and m_vertexShader.

00034                                     {
00035                 glDeleteObjectARB(m_vertexShader);
00036                 glDeleteObjectARB(m_fragmentShader);
00037                 glDeleteObjectARB(m_programObject);
00038         }


Member Function Documentation

void pge::GPUProgram::bind void   ) 
 

Definition at line 46 of file GPUProgram.cpp.

References m_programObject.

Referenced by pge::ShaderObject::bind(), pge::LightShader::preRender(), pge::GPUWater::render(), pge::GPUFire::render(), pge::BloomEffect::renderBlur(), and pge::BloomEffect::renderBrightPass().

00046                                   {
00047                 glUseProgramObjectARB(m_programObject);
00048         }

bool pge::GPUProgram::createPrograms void   )  [private]
 

Definition at line 189 of file GPUProgram.cpp.

References m_fragmentShader, m_fragmentSource, m_programObject, m_vertexShader, m_vertexSource, and printLog().

Referenced by GPUProgram().

00189                                             {
00190                 //
00191                 // Variables
00192                 //
00193                 GLint compileStatus;
00194                 GLint linkStatus;
00195                 GLint vertexLength;
00196                 GLint fragmentLength;
00197                 const char *vSource;
00198                 const char *fSource;
00199 
00200 
00201                 // Create shader and program objects.
00202                 m_programObject = glCreateProgramObjectARB();
00203                 m_vertexShader = glCreateShaderObjectARB(GL_VERTEX_SHADER);
00204                 m_fragmentShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER);
00205 
00206                 vertexLength = (GLint)m_vertexSource.size();
00207                 fragmentLength = (GLint)m_fragmentSource.size();
00208 
00209                 vSource = m_vertexSource.c_str();
00210                 fSource = m_fragmentSource.c_str();
00211 
00212                 // Load the shader sources.
00213                 glShaderSourceARB(m_vertexShader, 1, (const GLcharARB **)&vSource, &vertexLength);
00214                 glShaderSourceARB(m_fragmentShader, 1, (const GLcharARB **)&fSource, &fragmentLength);
00215 
00216                 // Compile shader.
00217                 glCompileShader(m_vertexShader);
00218                 printLog(m_vertexShader);
00219                 glGetObjectParameterivARB(m_vertexShader, GL_OBJECT_COMPILE_STATUS_ARB, &compileStatus);
00220                 if(compileStatus == 0) {
00221                         printf("ERROR: [%s] Could not compile vertex shader.\n", __FILE__);
00222                         return false;
00223                 }
00224 
00225                 glCompileShader(m_fragmentShader);
00226                 printLog(m_fragmentShader);
00227                 glGetObjectParameterivARB(m_fragmentShader, GL_OBJECT_COMPILE_STATUS_ARB, &compileStatus);
00228                 if(compileStatus == 0) {
00229                         printf("ERROR: [%s] Could not compile fragment shader.\n", __FILE__);
00230                         return false;
00231                 }
00232 
00233                 // Attach the shader to the programobject we created above.
00234                 glAttachObjectARB(m_programObject, m_vertexShader);
00235                 glAttachObjectARB(m_programObject, m_fragmentShader);
00236 
00237                 // Link the program object.
00238                 glLinkProgram(m_programObject);
00239                 printLog(m_programObject);
00240                 glGetObjectParameterivARB(m_programObject, GL_OBJECT_LINK_STATUS_ARB, &linkStatus);
00241                 if(linkStatus == 0) {
00242                         return false;
00243                 }
00244 
00245                 return true;
00246         }

Here is the call graph for this function:

std::string pge::GPUProgram::loadProgram const std::string &  filename  )  [private]
 

Definition at line 254 of file GPUProgram.cpp.

References MAX_LINE.

Referenced by GPUProgram().

00254                                                                    {
00255                 std::string source = "";
00256                 char temp[MAX_LINE];
00257     
00258 
00259                 std::fstream in(filename.c_str(), std::ios::in);
00260 
00261                 if(!in) {
00262                         return "";
00263                 }
00264     
00265                 while(!in.eof()) {
00266                         in.getline(temp, MAX_LINE);
00267                         source.append(temp);
00268                 }
00269     
00270                 in.close();
00271 
00272                 return source;
00273         }

void pge::GPUProgram::passUniform1f char *  name,
float  value
 

Definition at line 87 of file GPUProgram.cpp.

References m_programObject.

Referenced by pge::LightShader::preRender(), pge::GPUWater::render(), pge::GPUFire::render(), and pge::BloomEffect::renderBlur().

00087                                                               {
00088                 //
00089                 // Variables
00090                 //
00091                 int location;
00092 
00093 
00094                 location = glGetUniformLocation(m_programObject, (const GLcharARB*)name);
00095                 glUniform1f(location, value);
00096         }

void pge::GPUProgram::passUniform1i char *  name,
int  value
 

Definition at line 66 of file GPUProgram.cpp.

References m_programObject.

Referenced by pge::LightShader::preRender(), pge::GPUWater::render(), and pge::GPUFire::render().

00066                                                             {
00067                 //
00068                 // Variables
00069                 //
00070                 int location;
00071 
00072 
00073                 location = glGetUniformLocation(m_programObject, (const GLcharARB*)name);
00074                 if(location == -1) {
00075                         //printf("ERROR\n");
00076                         return;
00077                 }
00078                 glUniform1i(location, value);
00079         }

void pge::GPUProgram::passUniform3f char *  name,
Vector3f  value
 

Definition at line 121 of file GPUProgram.cpp.

References m_programObject, and pge::Vector3f::m_v.

00121                                                                  {
00122                 //
00123                 // Variables
00124                 //
00125                 int location;
00126 
00127 
00128                 location = glGetUniformLocation(m_programObject, (const GLcharARB*)name);
00129                 glUniform3f(location, value.m_v[0], value.m_v[1], value.m_v[2]);
00130         }

void pge::GPUProgram::passUniform3f char *  name,
float  v1,
float  v2,
float  v3
 

Definition at line 104 of file GPUProgram.cpp.

References m_programObject.

Referenced by pge::GPUWater::render(), and pge::GPUFire::render().

00104                                                                                {
00105                 //
00106                 // Variables
00107                 //
00108                 int location;
00109 
00110 
00111                 location = glGetUniformLocation(m_programObject, (const GLcharARB*)name);
00112                 glUniform3f(location, v1, v2, v3);
00113         }

void pge::GPUProgram::passUniform4f char *  name,
Vector4f  value
 

Definition at line 155 of file GPUProgram.cpp.

References m_programObject, and pge::Vector4f::m_v.

00155                                                                  {
00156                 //
00157                 // Variables
00158                 //
00159                 int location;
00160 
00161 
00162                 location = glGetUniformLocation(m_programObject, (const GLcharARB*)name);
00163                 glUniform4f(location, value.m_v[0], value.m_v[1], value.m_v[2], value.m_v[3]);
00164         }

void pge::GPUProgram::passUniform4f char *  name,
float  v1,
float  v2,
float  v3,
float  v4
 

Definition at line 138 of file GPUProgram.cpp.

References m_programObject.

Referenced by pge::LightShader::preRender(), and pge::GPUFire::render().

00138                                                                                          {
00139                 //
00140                 // Variables
00141                 //
00142                 int location;
00143 
00144 
00145                 location = glGetUniformLocation(m_programObject, (const GLcharARB*)name);
00146                 glUniform4f(location, v1, v2, v3, v4);
00147         }

void pge::GPUProgram::passUniformMatrix4f char *  name,
float *  value
 

Definition at line 172 of file GPUProgram.cpp.

References m_programObject.

00172                                                                      {
00173                 //
00174                 // Variables
00175                 //
00176                 int location;
00177 
00178 
00179                 location = glGetUniformLocation(m_programObject, (const GLcharARB*)name);
00180                 glUniformMatrix4fv(location, 16, false, value);
00181         }

void pge::GPUProgram::printLog GLhandleARB  handle  )  [private]
 

Definition at line 281 of file GPUProgram.cpp.

Referenced by createPrograms().

00281                                                     {
00282                 //
00283                 // Variables
00284                 //
00285                 int infoLength;
00286                 int len;
00287                 char *log;
00288 
00289 
00290                 infoLength = 0;
00291                 len = 0;
00292                 glGetObjectParameterivARB(handle, GL_OBJECT_INFO_LOG_LENGTH_ARB , &infoLength);
00293                 if(infoLength > 1) {
00294                         log = new char[infoLength];
00295                         glGetInfoLogARB(handle, infoLength, &len, log);
00296                         printf("INFO: [%s] Compile-log: %s\n", __FILE__, log);
00297                 }
00298         }

void pge::GPUProgram::release void   ) 
 

Definition at line 56 of file GPUProgram.cpp.

Referenced by pge::LightShader::postRender(), pge::ShaderObject::release(), pge::GPUWater::render(), pge::GPUFire::render(), pge::BloomEffect::renderBlur(), and pge::BloomEffect::renderBrightPass().

00056                                      {
00057                 glUseProgramObjectARB(0);
00058         }


Field Documentation

GLhandleARB pge::GPUProgram::m_fragmentShader [private]
 

Definition at line 76 of file GPUProgram.h.

Referenced by createPrograms(), and ~GPUProgram().

std::string pge::GPUProgram::m_fragmentSource [private]
 

Definition at line 72 of file GPUProgram.h.

Referenced by createPrograms(), and GPUProgram().

GLhandleARB pge::GPUProgram::m_programObject [private]
 

Definition at line 74 of file GPUProgram.h.

Referenced by bind(), createPrograms(), passUniform1f(), passUniform1i(), passUniform3f(), passUniform4f(), passUniformMatrix4f(), and ~GPUProgram().

GLhandleARB pge::GPUProgram::m_vertexShader [private]
 

Definition at line 75 of file GPUProgram.h.

Referenced by createPrograms(), and ~GPUProgram().

std::string pge::GPUProgram::m_vertexSource [private]
 

Definition at line 71 of file GPUProgram.h.

Referenced by createPrograms(), and GPUProgram().


The documentation for this class was generated from the following files:
Generated on Mon Oct 16 12:09:10 2006 for Phobosengine by doxygen 1.3.4