Source Code for Module rats.glsl

  1  #!/usr/bin/env python 
  2  """ 
  3  Class to simplify the use of GLSL programs. 
  4   
  5  Copyright (C) 2007  "Peter Roesch" <Peter.Roesch@fh-augsburg.de> 
  6   
  7  This code is licensed under the PyOpenGL License. 
  8  Details are given in the file license.txt included in this distribution. 
  9  """ 
 10  # Original notice :  
 11  #  
 12  # Class to simplify the incorporation of GLSL programs. 
 13  #  
 14  # Copyright (C) 2007  "Peter Roesch" <Peter.Roesch@fh-augsburg.de> 
 15  # 
 16  # This code is licensed under the PyOpenGL License. 
 17  # Details are given in the file license.txt included in this distribution. 
 18   
 19  import sys 
 20   
 21 -class ShaderError(Exception): 
 22      """ 
 23      Any error that might have occured that will make a shader program unusable. 
 24      """ 
 25      pass 
 26   
 27  try: 
 28      from OpenGL.GLUT import * 
 29      from OpenGL.GL import * 
 30      from OpenGL.GLU import * 
 31      from OpenGL.GL.ARB.shader_objects import * 
 32      from OpenGL.GL.ARB.fragment_shader import * 
 33      from OpenGL.GL.ARB.vertex_shader import * 
 34  except: 
 35      raise 
 36      # raise ShaderError('Error importing GL / shaders') 
 37   
 38 -class ShaderProgram(object): 
 39      """ 
 40      Manages GLSL programs. 
 41      """ 
 42 -    def __init__(self): 
 43          self._requiredExtensions = [ 
 44                  "GL_ARB_fragment_shader", 
 45                  "GL_ARB_vertex_shader", 
 46                  "GL_ARB_shader_objects", 
 47                  "GL_ARB_shading_language_100", 
 48                  "GL_ARB_vertex_shader", 
 49                  "GL_ARB_fragment_shader"] 
 50          self.checkExtensions(self._requiredExtensions) 
 51          # TODO:  
 52          if not bool(glCreateProgramObjectARB): 
 53              raise ShaderError("Impossible to create a shader program object.") 
 54          self._shaderProgramID = glCreateProgramObjectARB() 
 55          self._checkOpenGLError() 
 56          self._programReady = False 
 57          self._isEnabled = False 
 58          self._shaderObjectList = [] 
 59   
 60 -    def checkExtensions(self, extensions): 
 61          """ 
 62          Checks if all extensions in a list are present. 
 63          """ 
 64          for ext in extensions: 
 65              if not ext: 
 66                  raise ShaderError("Driver does not support extension %s." % (ext)) 
 67   
 68 -    def _checkOpenGLError(self): 
 69          """ 
 70          Checks if there are OpenGL error messages. 
 71          """ 
 72          err = glGetError() 
 73          if err != GL_NO_ERROR: 
 74              err_text = gluErrorString(err) 
 75              print(err) 
 76              print(err_text) 
 77              raise ShaderError('GLERROR: %s' % (err_text)) 
 78   
 79 -    def reset(self): 
 80          """ 
 81          Disables and removes all shader programs. 
 82          """ 
 83          for shaderID in self._shaderObjectList: 
 84              glDetachObjectARB(self._shaderProgramID, shaderID) 
 85              glDeleteObjectARB(shaderID) 
 86              self._shaderObjectList.remove(shaderID) 
 87              self._checkOpenGLError() 
 88          glDeleteObjectARB(self._shaderProgramID) 
 89          self._checkOpenGLError() 
 90          self._shaderProgramID = glCreateProgramObjectARB() 
 91          self._checkOpenGLError() 
 92          self._programReady = False 
 93   
 94 -    def addShader(self, shaderType, fileName): 
 95          """ 
 96          Reads a shader program from a file. 
 97   
 98          The program is loaded and compiled. 
 99          """ 
100          sourceString = open(fileName, 'r').read() 
101          self.add_shader_text(shaderType, sourceString) 
102       
103 -    def add_shader_text(self, shaderType, sourceString): 
104          """ 
105          Loads a program from string and compiles it. 
106          """ 
107          shaderHandle = glCreateShaderObjectARB(shaderType) 
108          self._checkOpenGLError() 
109          glShaderSourceARB(shaderHandle, [sourceString]) 
110          self._checkOpenGLError() 
111          glCompileShaderARB(shaderHandle) 
112          success = glGetObjectParameterivARB(shaderHandle,  
113              GL_OBJECT_COMPILE_STATUS_ARB) 
114          self._checkOpenGLError() 
115          if not success: 
116              raise ShaderError(glGetInfoLogARB(shaderHandle)) 
117          glAttachObjectARB(self._shaderProgramID, shaderHandle) 
118          self._checkOpenGLError() 
119          self._shaderObjectList.append(shaderHandle) 
120           
121 -    def linkShaders(self): 
122          """ 
123          Links compiled shader programs. 
124          """ 
125          glLinkProgramARB(self._shaderProgramID) 
126          self._checkOpenGLError() 
127          success = glGetObjectParameterivARB(self._shaderProgramID,  
128              GL_OBJECT_LINK_STATUS_ARB) 
129          if not success: 
130              raise ShaderError(glGetInfoLogARB(self._shaderProgramID)) 
131          else: 
132              self._programReady = True 
133       
134 -    def enable(self): 
135          """ 
136          Activates shader programs. 
137          """ 
138          if self._programReady: 
139              glUseProgramObjectARB(self._shaderProgramID) 
140              self._isEnabled=True 
141              self._checkOpenGLError() 
142          else: 
143              print "Shaders not compiled/linked properly, enable() failed" 
144   
145 -    def disable(self): 
146          """ 
147          De-activates shader programs. 
148          """ 
149          glUseProgramObjectARB(0) 
150          self._isEnabled=False 
151          self._checkOpenGLError() 
152   
153 -    def indexOfUniformVariable(self, variableName): 
154          """ 
155          Finds the index of a uniform variable. 
156          """ 
157          if not self._programReady: 
158              print "\nShaders not compiled/linked properly" 
159              result = -1 
160          else: 
161              result = glGetUniformLocationARB(self._shaderProgramID, variableName) 
162              self._checkOpenGLError() 
163          if result < 0: 
164              raise ShaderError('Variable "%s" not known to the shader' % (variableName)) 
165          else: 
166              return result 
167   
168 -    def indexOfVertexAttribute(self, attributeName): 
169          """ 
170          Finds the index of an attribute variable. 
171          """ 
172          if not self._programReady: 
173              print "\nShaders not compiled/linked properly" 
174              result = -1 
175          else: 
176              result = glGetAttribLocationARB(self._shaderProgramID, attributeName) 
177              self._checkOpenGLError() 
178          if result < 0: 
179              raise ShaderError('Attribute "%s" not known to the shader' % (attributeName)) 
180          else: 
181              return result 
182       
183 -    def isEnabled(self): 
184          return self._isEnabled 
185   
186 -    def glUniform3f(self, variable_name, a, b, c): 
187          if self.isEnabled(): 
188              index = self.indexOfUniformVariable(variable_name) 
189              glUniform3fARB(index, GLfloat(a), GLfloat(b), GLfloat(c)) 
190          else: 
191              raise ShaderError("You must enable this shader to modify a uniform variable.") 
192   
193 -    def glUniform1f(self, variable_name, a): 
194          if self.isEnabled(): 
195              index = self.indexOfUniformVariable(variable_name) 
196              glUniform1fARB(index, GLfloat(a)) 
197          else: 
198              raise ShaderError("You must enable this shader to modify a uniform variable.") 
199 -    def glUniform1i(self, variable_name, a): 
200          if self.isEnabled(): 
201              index = self.indexOfUniformVariable(variable_name) 
202              glUniform1iARB(index, a) 
203          else: 
204              raise ShaderError("You must enable this shader to modify a uniform variable.") 
205   
206  # test routine 
207  if __name__ == '__main__': 
208      glutInit(sys.argv) 
209      glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA) 
210      glutInitWindowSize(100, 100) 
211      glutCreateWindow("shaderProg Test") 
212      # Note: this will fail on many platforms where you must call 
213      # *after* you get an initialized glut context... 
214      Sp = ShaderProgram() 
215      Sp.addShader(GL_VERTEX_SHADER_ARB, "temperature.vert") 
216      Sp.addShader(GL_FRAGMENT_SHADER_ARB, "temperature.frag") 
217      Sp.linkShaders() 
218      print "Index of variable CoolestTemp: ", \ 
219          Sp.indexOfUniformVariable("CoolestTemp") 
220      Sp.enable() 
221      print "Index of attribute VertexTemp: ", \ 
222          Sp.indexOfVertexAttribute("VertexTemp") 
223      glVertexAttrib1fNV(Sp.indexOfVertexAttribute("VertexTemp"), 12.3) 
224      Sp.disable() 
225      Sp.reset() 
226      print 'OK' 
227