Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/lib/graphics/shader.cc @ 9373

Last change on this file since 9373 was 8316, checked in by bensch, 19 years ago

trunk: fixed most -Wall warnings… but there are still many missing :/

File size: 7.9 KB
RevLine 
[4744]1/*
[1853]2   orxonox - the future of 3D-vertical-scrollers
3
4   Copyright (C) 2004 orx
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
[1855]10
11   ### File Specific:
[5261]12   main-programmer: Benjamin Grauer
[1855]13   co-programmer: ...
[1853]14*/
15
[3955]16//#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_
[1853]17
[5261]18#include "shader.h"
[1853]19
[5262]20#include "stdlibincl.h"
[5273]21#include "compiler.h"
[8037]22//#include <stdio.h>
23#include <fstream>
24
[5262]25#include "debug.h"
26
[7193]27#include "util/loading/resource_manager.h"
[5262]28
[5323]29
[8037]30#ifndef PARSELINELENGTH
31#define PARSELINELENGTH     512       //!< how many chars to read at once
[5262]32#endif
33
[1856]34using namespace std;
[1853]35
[1856]36
[3245]37/**
[4838]38 * standard constructor
[3245]39*/
[7221]40Shader::Shader (const std::string& vertexShaderFile, const std::string& fragmentShaderFile)
[3365]41{
[5261]42   this->setClassID(CL_SHADER, "Shader");
[4320]43
[5261]44   this->shaderProgram = 0;
45   this->vertexShader = 0;
46   this->fragmentShader = 0;
[5262]47
[5263]48   if (GLEW_ARB_shader_objects && GLEW_ARB_shading_language_100)
[5273]49     {
50       this->shaderProgram = glCreateProgramObjectARB();
[5263]51
[7221]52       if (!vertexShaderFile.empty())
[8037]53         this->loadShaderProgramm(Shader::Vertex, vertexShaderFile);
[7221]54       if (!fragmentShaderFile.empty())
[8037]55         this->loadShaderProgramm(Shader::Fragment, fragmentShaderFile);
56
57       this->linkShaderProgram();
58
[5320]59    }
[5273]60   else
61     {
62       PRINTF(2)("Shaders are not supported on your hardware\n");
63     }
[3365]64}
[1853]65
66
[3245]67/**
[4838]68 * standard deconstructor
[5318]69 */
[5261]70Shader::~Shader ()
[3543]71{
[5322]72  if (this->shaderProgram == glGetHandleARB(GL_PROGRAM_OBJECT_ARB))
[5318]73    Shader::deactivateShader();
74
[3543]75  // delete what has to be deleted here
[8037]76  this->deleteProgram(Shader::Vertex);
77  this->deleteProgram(Shader::Fragment);
[5263]78
[5273]79  if (this->fragmentShader != 0)
[5322]80  {
81    glDetachObjectARB(this->shaderProgram, this->fragmentShader);
[5273]82    glDeleteObjectARB(this->fragmentShader);
[5322]83  }
[5273]84  if (this->vertexShader != 0)
[5322]85  {
86    glDetachObjectARB(this->shaderProgram, this->vertexShader);
[5273]87    glDeleteObjectARB(this->vertexShader);
[5322]88  }
[5273]89  if (this->shaderProgram != 0)
[5321]90  {
91    GLint status = 0;
[5322]92    //glLinkProgramARB(this->shaderProgram);
[5273]93    glDeleteObjectARB(this->shaderProgram);
[5321]94       // link error checking
95    glGetObjectParameterivARB(this->shaderProgram, GL_OBJECT_DELETE_STATUS_ARB, &status);
96    if (status == GL_INVALID_VALUE || status == GL_INVALID_OPERATION)
97      this->printError(this->shaderProgram);
98  }
[3543]99}
[5261]100
[7221]101Shader* Shader::getShader(const std::string& vertexShaderFile, const std::string& fragmentShaderFile)
[5323]102{
[6645]103  return (Shader*)ResourceManager::getInstance()->load(vertexShaderFile, SHADER,  RP_LEVEL, fragmentShaderFile);
[5323]104}
105
106bool Shader::unload(Shader* shader)
107{
108  return ResourceManager::getInstance()->unload(shader);
109}
110
[5317]111Shader* Shader::storedShader = NULL;
[5261]112
[5317]113
[8037]114bool Shader::loadShaderProgramm(Shader::Type type, const std::string& fileName)
[5261]115{
[5319]116  GLhandleARB shader = 0;
[5285]117
[8037]118  if (type != Shader::Vertex && type != Shader::Fragment)
[5261]119    return false;
[5262]120  this->deleteProgram(type);
[5261]121
122
[8037]123  std::string program;
124  if (!readShader(fileName, program))
125    return false;
[5318]126
[8037]127  if (type == Shader::Vertex && GLEW_ARB_vertex_shader)
[5262]128  {
[7221]129    this->vertexShaderFile = fileName;
[5262]130
[5269]131    shader = this->vertexShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
[5263]132  }
[5262]133
[8037]134  if (type == Shader::Fragment && GLEW_ARB_fragment_shader)
[5263]135  {
[7221]136    this->fragmentShaderFile = fileName;
[5266]137
[5269]138    shader = this->fragmentShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
[5263]139  }
[5273]140
141  if (shader != 0)
[5319]142  {
[5320]143    GLint status = 0;
[8037]144    const char* prog = program.c_str();
145
146    glShaderSourceARB(shader, 1, &prog, NULL);
[5320]147    glCompileShaderARB(shader);
148    // checking on error.
149    glGetObjectParameterivARB(shader, GL_OBJECT_COMPILE_STATUS_ARB, &status);
150    if (status == GL_INVALID_VALUE || status == GL_INVALID_OPERATION)
151      this->printError(shader);
152    else
153      glAttachObjectARB(this->shaderProgram, shader);
[5319]154  }
[8316]155  return true;
[5261]156}
157
[8037]158
159void Shader::linkShaderProgram()
[5261]160{
[8037]161  GLint status = 0;
[5266]162
[8037]163  glLinkProgramARB(this->shaderProgram);
164       // link error checking
165  glGetObjectParameterivARB(this->shaderProgram, GL_OBJECT_LINK_STATUS_ARB, &status);
166  if (status == GL_INVALID_VALUE || status == GL_INVALID_OPERATION)
167    this->printError(this->shaderProgram);
168}
[5266]169
170
[8037]171bool Shader::readShader(const std::string& fileName, std::string& output)
172{
173  char lineBuffer[PARSELINELENGTH];
[5266]174
[8037]175  std::ifstream shader;
176  shader.open(fileName.c_str());
177  if (!shader.is_open())
178    return false;
[5266]179
[5318]180
[8037]181  while (!shader.eof())
[5318]182  {
[8037]183    shader.getline(lineBuffer, PARSELINELENGTH);
184    output += lineBuffer;
185    output += "\n";
[5318]186  }
187
[8037]188
189  shader.close();
190  return true;
[5318]191}
192
193
194
[5266]195void Shader::activateShader()
196{
[5273]197  if (likely (this->shaderProgram != 0))
[5317]198  {
[5273]199    glUseProgramObjectARB(this->shaderProgram);
[5317]200    Shader::storedShader = this;
201  }
[5261]202}
[5262]203
[8255]204void Shader::bindShader(const char* name, const float* value, size_t size)
205{
206        if (likely (this->shaderProgram != 0)) {
207                glUseProgramObjectARB(this->shaderProgram);
208
209                unsigned int location = glGetUniformLocationARB(this->shaderProgram, name);
210                /* This is EXPENSIVE and should be avoided. */
211
212                if      (size == 1)  glUniform1fvARB(location, 1, value);
213                else if (size == 2)  glUniform2fvARB(location, 1, value);
214                else if (size == 3)  glUniform3fvARB(location, 1, value);
215                else if (size == 4)  glUniform4fvARB(location, 1, value);
216                else if (size == 9)  glUniformMatrix3fvARB(location, 1, false, value);
217                else if (size == 16) glUniformMatrix4fvARB(location, 1, false, value);
218
219        }
220}
221
[5266]222void Shader::deactivateShader()
223{
[5364]224 if (storedShader != NULL)
225   glUseProgramObjectARB(0);
226 Shader::storedShader = NULL;
[5266]227}
[5262]228
[5266]229
[8037]230void Shader::deleteProgram(Shader::Type type)
[5262]231{
[5335]232  GLint status = 0;
[8037]233  if (type == Shader::Vertex && this->vertexShader != 0)
[5262]234  {
[7221]235    this->vertexShaderFile = "";
[5321]236    glDetachObjectARB(this->shaderProgram, this->vertexShader);
[5263]237    glDeleteObjectARB(this->vertexShader);
[5320]238    glGetObjectParameterivARB(this->vertexShader, GL_OBJECT_DELETE_STATUS_ARB, &status);
239    if (status == GL_INVALID_VALUE || status == GL_INVALID_OPERATION)
240      Shader::printError(this->vertexShader);
[5263]241    this->vertexShader = 0;
[5262]242  }
[8037]243  else if (type == Shader::Fragment && this->fragmentShader != 0)
[5262]244  {
[7221]245    this->fragmentShaderFile = "";
[5321]246    glDetachObjectARB(this->shaderProgram, this->fragmentShader);
[5263]247    glDeleteObjectARB(this->fragmentShader);
[5320]248    glGetObjectParameterivARB(this->fragmentShader, GL_OBJECT_DELETE_STATUS_ARB, &status);
249    if (status == GL_INVALID_VALUE || status == GL_INVALID_OPERATION)
250      Shader::printError(this->fragmentShader);
[5263]251    this->fragmentShader = 0;
[5262]252  }
253  else
254    return;
255}
256
[5264]257
[5319]258void Shader::printError(GLhandleARB program)
[5264]259{
[5273]260  if (program == 0)
261    return;
262
[5267]263  int infologLength = 0;
264  int charsWritten  = 0;
265  char *infoLog;
266
267  glGetObjectParameterivARB(program, GL_OBJECT_INFO_LOG_LENGTH_ARB,
268                            &infologLength);
269
270  if (infologLength > 0)
271  {
[5283]272    infoLog = new char[infologLength+1];
[5267]273    glGetInfoLogARB(program, infologLength, &charsWritten, infoLog);
[5269]274    printf("%s\n", infoLog);
[5283]275    delete[] infoLog;
[5267]276  }
[5264]277}
278
[5333]279bool Shader::checkShaderAbility()
280{
281  if (GLEW_ARB_shader_objects &&
282      GLEW_ARB_shading_language_100 &&
283      GLEW_ARB_vertex_shader &&
284      GLEW_ARB_fragment_shader)
285    return true;
286  else
287    return false;
288}
[5264]289
[5262]290void Shader::debug() const
291{
292  PRINT(3)("Shader info: (SHADER: %d)\n", this->shaderProgram);
293  if (this->vertexShader != 0)
294  {
[5266]295/*    PRINT(3)("VertexShaderProgramm: number=%d, file='%s'\n", this->vertexShader, this->vertexShaderFile);
[5262]296    if (this->vertexShaderSource != NULL)
297      for (unsigned int i = 0; i < this->vertexShaderSource->getCount(); i++)
298        PRINT(3)("%d: %s\n", i, this->vertexShaderSource->getEntry(i));
299  }
300  if (this->fragmentShader != 0)
301  {
302    PRINT(3)("FragmentShaderProgramm: number=%d, file='%s'\n", this->fragmentShader, this->fragmentShaderFile);
303    if (this->fragmentShaderSource != NULL)
304      for (unsigned int i = 0; i < this->fragmentShaderSource->getCount(); i++)
[5266]305        PRINT(3)("%d: %s\n", i, this->fragmentShaderSource->getEntry(i));*/
[5262]306  }
307}
308
Note: See TracBrowser for help on using the repository browser.