コード例 #1
0
 def __init__(self):
     self.program = compileProgram(VisualizeDepthShaderVert, None, VisualizeDepthShaderFrag)
コード例 #2
0
ファイル: segment.py プロジェクト: daniel-/python-gl-engine
 def createShader(self):
     """
     creates shader for this segment.
     first the combination of used shaders is generated.
     this result has a string representation.
     if a shader with the same string representation was generated before,
     then the allready compiled shader is used, else a new one created.
     """
     
     vertData = ShaderData(); geomData = ShaderData(); fragData = ShaderData()
     
     # texture counter
     self.nextTexID = self.app.textureCounter
     # texture list
     textures = []
     # material texture colors maybe mapped to multiple targets,
     # we dont wanna iterate over the material textures in the create function,
     # so the relation will be saved in this table.
     matTextures = {}
     
     baseShaders = self.createBaseShaders(textures)
     
     # add material textures
     for i in range(len(self.material.textures)):
         tex = self.material.textures[i]
         texUnit = self.nextTexID; self.nextTexID += 1
         texData = (tex.glID, GL_TEXTURE_2D, "sampler2D", "Texture%d" % texUnit, texUnit)
         textures.append(texData)
         
         for mapTo in tex.mapTo:
             try:
                 matTextures[mapTo].append((tex, texData))
             except:
                 matTextures[mapTo] = [(tex, texData)]
     # add shadow map textures
     i = 0
     for light in self.lights:
         shadowMapArray = light.shadowMapArray
         if shadowMapArray!=None:
             texUnit = self.nextTexID; self.nextTexID += 1
             texData = (shadowMapArray.texture.glID,
                        GL_TEXTURE_2D_ARRAY,
                        shadowMapArray.textureType,
                        "shadowMap%d" % i,
                        texUnit)
             
             textures.append(texData)
             i += 1
     
     hasLight = bool(self.enabledLights)
     if hasLight:
         # uv and light shaders make only sense when light is enabled
         lightShaders = self.createLightShaders(textures, matTextures)
         norShaders = self.createNorShaders(textures, matTextures)
     uvShaders = self.createUVShaders(textures, matTextures)
     vertexShaders = self.createVertexShaders(textures, matTextures)
     colorShaders = self.createColorShaders(textures, matTextures)
     
     if self.isReflecting():
         self.reflectionHandler = self.createReflectionHandler(self.app, self,
                                                               colorShaders, textures)
     
     # get multiple vertex shader functions
     self._addShaders(baseShaders[VERT_SHADER], vertData)
     self._addShaders(vertexShaders[VERT_SHADER], vertData)
     if hasLight:
         self._addShaders(lightShaders[VERT_SHADER], vertData)
         self._addShaders(norShaders[VERT_SHADER], vertData)
     self._addShaders(uvShaders[VERT_SHADER], vertData)
     self._addShaders(colorShaders[VERT_SHADER], vertData)
     
     # get multiple geometry shader functions
     self._addShaders(baseShaders[GEOM_SHADER], geomData)
     self._addShaders(vertexShaders[GEOM_SHADER], geomData)
     
     # get multiple fragment shader functions
     self._addShaders(uvShaders[FRAG_SHADER], fragData)
     self._addShaders(baseShaders[FRAG_SHADER], fragData)
     self._addShaders(vertexShaders[FRAG_SHADER], fragData)
     self._addShaders(colorShaders[FRAG_SHADER], fragData)
     if hasLight:
         self._addShaders(norShaders[FRAG_SHADER], fragData)
         self._addShaders(lightShaders[FRAG_SHADER], fragData)
     
     # add texture sampler as uniform
     for (_, _, type, name, _) in textures:
         fragData.functions[0].addUniform(type=type, name=name)
     
     if vertData.functions == []:
         vertData.functions.append(VertShaderFunc(name=None))
     self.addShaderAttributes(vertData.functions[0])
     
     # combine all shaders into one
     (vertShader, geomShader, fragShader) = \
             combineShader(vertData.functions,
                           geomData.functions,
                           fragData.functions)
     
     # setup main function
     if fragShader!=None:
         for var in fragData.localVars.keys():
             (type, val) = fragData.localVars[var]
             fragShader.addLocalVar(type, var, val)
         for exp in fragData.exports.keys():
             fragShader.addExport(exp, fragData.exports[exp])
     if geomShader!=None:
         for var in geomData.localVars.keys():
             (type, val) = geomData.localVars[var]
             geomShader.addLocalVar(type, var, val)
         for exp in geomData.exports.keys():
             geomShader.addExport(exp, geomData.exports[exp])
     if vertShader!=None:
         for var in vertData.localVars.keys():
             (type, val) = vertData.localVars[var]
             vertShader.addLocalVar(type, var, val)
         for exp in vertData.exports.keys():
             vertShader.addExport(exp, vertData.exports[exp])
     
     # get shader string representation
     shaderStr = ""
     for shader in [vertShader, geomShader, fragShader]:
         if shader==None:
             continue
         print shader.code()
         shaderStr += str(shader) + "\n"
     
     try: # try to use allready compiled shader
         (self.shaderProgram, self.shader) = self.segmentShaders[shaderStr]
         return
     except: pass
     
     if fragShader==None and geomShader==None and vertShader==None:
         self.shaderProgram = -1
         # self.shader handles enabling/disabling the shader
         self.shader = ShaderWrapper()
     else:
         # ready to compile...
         self.shaderProgram = compileProgram(
                     vertShader, geomShader, fragShader)
         
         # self.shader handles enabling/disabling the shader
         self.shader = SegmentShader(self,
                                     self.shaderProgram,
                                     textures)
     
     self.segmentShaders[shaderStr] = (self.shaderProgram, self.shader)