def compile(self): if not self.source: return False source = [] for import_lib in self.imports: if not import_lib.source: return False source.extend( import_lib.source ) source.extend( self.source ) try: if self.type == 'VERTEX': shader = GL_shaders.compileShader( source, GL_VERTEX_SHADER ) elif self.type == 'FRAGMENT': shader = GL_shaders.compileShader( source, GL_FRAGMENT_SHADER ) else: log.error( 'Unknown shader type: %s in %s', self.type, self, ) return None except RuntimeError, err: self.compileLog = err.args[0] return None
def __init__(self, width = 25.0, peak = 26.0, vertShader = 'knotvertex.vs', fragShader = 'knotfragment.fs', shaderPositionName = 'position', shaderNormalName = 'normal', shaderTexcoordName = 'texcoord'): self.peak = peak self.width = width with open(os.path.join(os.getcwd(), vertShader)) as fp: vert = fp.read() with open(os.path.join(os.getcwd(), fragShader)) as fp: frag = fp.read() try: self.program = compileProgram( compileShader(vert, GL_VERTEX_SHADER), compileShader(frag, GL_FRAGMENT_SHADER)) except RuntimeError as rte: print rte[0] raise self.positionLocation = glGetAttribLocation(self.program, shaderPositionName) self.normalLocation = glGetAttribLocation(self.program, shaderNormalName) self.texcoordLocation = glGetAttribLocation(self.program, shaderTexcoordName) self.makeDataBuffers()
def __init__(self): self.vertexshader = shaders.compileShader(""" attribute vec2 position; attribute vec4 color; uniform vec2 resolution; uniform vec2 scroll; varying vec4 v_color; void main() { vec2 p = (position + scroll) / resolution * 2.0 - 1.0; gl_Position = vec4(p.x, -p.y, 0.0, 1.0); v_color = color; }""", GL_VERTEX_SHADER) self.fragmentshader = shaders.compileShader(""" varying vec4 v_color; void main() { gl_FragColor = v_color; }""", GL_FRAGMENT_SHADER) self.shader = shaders.compileProgram( self.vertexshader, self.fragmentshader) self.vbo = glGenBuffers(1) self.vertices = [] self.vertexcount = 0 self.dirty = True
def __init__ ( self, title="title", width=640, height=480, pos_x=50, pos_y=50, vertex_shader=None, fragment_shader=None ): # initialize GLUT library ( cf. window handling, user interactions ) glutInit( sys.argv ) glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH ) # glutFullScreen() # initialize and create window glutInitWindowPosition( pos_x, pos_y ) # set upper left corner on screen glutInitWindowSize( width, height ) self.window = glutCreateWindow( title ) # register callback functions glutDisplayFunc( self.display ) # glutIdleFunc( self.display ) glutReshapeFunc( self.reshape ) # called on window creation as well glutKeyboardFunc( self.keyboard ) glutMouseFunc( self.mouse ) # specify clear values for some buffers and the shading technique to use # ( noted for explicity only, values are the defaults ) glClearColor( 0.0, 0.0, 0.0, 0.0 ) # range [0;1] glClearDepth( 1.0 ) # range [0;1] glShadeModel( GL_SMOOTH ) # GL_FLAT or GL_SMOOTH # compile shaders if vertex_shader and fragment_shader: self.shader = shaders.compileProgram ( # uses OpenGL.GL.shaders shaders.compileShader( vertex_shader, GL_VERTEX_SHADER ), shaders.compileShader( fragment_shader, GL_FRAGMENT_SHADER ) ) glUseProgram( self.shader )
def init(self): super(BasicWindow, self).init() vert_shader = compileShader(vert_shader_source, GL.GL_VERTEX_SHADER) frag_shader = compileShader(frag_shader_source, GL.GL_FRAGMENT_SHADER) self.shader = game_core.ShaderProgram(vert_shader, frag_shader) self.ndc_vao = GL.glGenVertexArrays(1) GL.glBindVertexArray(self.ndc_vao) vertex_buffer = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vertex_buffer) data = [ -1.0, -1.0, 0.0, 0.0, 1.0, 0.0, 1.0, -1.0, 0.0, ] array_type = (GL.GLfloat*len(data)) GL.glBufferData( GL.GL_ARRAY_BUFFER, len(data)*game_core.FLOAT_SIZE, array_type(*data), GL.GL_STATIC_DRAW ) GL.glEnableVertexAttribArray(0) GL.glVertexAttribPointer(0, 3, GL.GL_FLOAT, GL.GL_FALSE, 0, None) GL.glBindVertexArray(0)
def initializeShaders(): global theShaders, positionAttrib, normalAttrib, tangentAttrib,\ bitangentAttrib, uvAttrib, \ modelUnif, viewUnif, projUnif, lightUnif, \ colorSamplerUnif, normalSamplerUnif, scaleuvUnif, colorUnif theShaders = compileProgram( compileShader(strVertexShader, GL_VERTEX_SHADER), compileShader(strFragmentShader, GL_FRAGMENT_SHADER) ) positionAttrib = glGetAttribLocation(theShaders, "position") normalAttrib = glGetAttribLocation(theShaders, "normal") lightUnif = glGetUniformLocation(theShaders, "light") modelUnif = glGetUniformLocation(theShaders, "model") viewUnif = glGetUniformLocation(theShaders, "view") projUnif = glGetUniformLocation(theShaders, "projection") colorSamplerUnif = glGetUniformLocation(theShaders, "colorsampler") normalSamplerUnif = glGetUniformLocation(theShaders, "normalsampler") colorUnif = glGetUniformLocation(theShaders, "color") check("positionAttrib", positionAttrib) check("normalAttrib", normalAttrib) check("modelUnif", modelUnif) check("viewUnif", viewUnif) check("projUnif", projUnif) check("lightUnif", lightUnif) check("colorUnif", colorUnif)
def OnInit(self): VERTEX_SHADER = GLshaders.compileShader("""#version 120 void main(){ gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }""", GL.GL_VERTEX_SHADER) #Defining the vertex shader FRAGMENT_SHADER = GLshaders.compileShader("""#version 120 void main(){ gl_FragColor = vec4(0.2,1,0.5,1); }""", GL.GL_FRAGMENT_SHADER) #Defining the fragment shader myTriangle = np.array([ [ 0, 2, 0], [-3, 0, 0], [ 1, 0, 0], [ 2, 1, 0], [ 2,-2, 0], [ 4,-2, 0], [ 2, 1, 0], [ 4,-2, 0], [ 4, 1, 0] ], dtype='f') self.myShader = GLshaders.compileProgram(VERTEX_SHADER,FRAGMENT_SHADER) self.vbo = GLvbo.VBO(myTriangle)
def init(self): self.vertexbuffer = glGenBuffers(1) vertex_shader = compileShader(VERTEX_SHADER, GL_VERTEX_SHADER) fragment_shader = compileShader(FRAGMENT_SHADER, GL_FRAGMENT_SHADER) self.program = compileProgram(vertex_shader, fragment_shader) self.vertices_attr = glGetAttribLocation(self.program, b'vertices') self.t_attr = glGetUniformLocation(self.program, b't')
def __compileShaders(self): vertex_shader = shaders.compileShader(""" varying vec2 uv; varying vec3 normal; varying vec4 ecPos; void main() { uv = gl_MultiTexCoord0; ecPos = gl_ModelViewMatrix * gl_Vertex; normal = normalize(gl_NormalMatrix * gl_Normal); gl_Position = ftransform(); } """, GL_VERTEX_SHADER) fragment_shader = shaders.compileShader(""" varying vec2 uv; varying vec3 normal; varying vec4 ecPos; uniform sampler2D tex; void main() { gl_FragColor = texture2D(tex, uv); } """, GL_FRAGMENT_SHADER) self.__shaders = shaders.compileProgram(vertex_shader, fragment_shader) self.__recompileShader = False
def __init__(self, vsrc, fsrc, csrc=None): path = os.path.dirname(os.path.realpath(__file__)) + "/shaders/" with open(path + fsrc, "r") as fin: src = fin.read() fragment = shaders.compileShader(src, GL_FRAGMENT_SHADER) with open(path + vsrc, "r") as fin: src = fin.read() vertex = shaders.compileShader(src, GL_VERTEX_SHADER) if csrc: with open(path + csrc, "r") as fin: src = fin.read() print(src) compute = shaders.compileShader(src, GL_COMPUTE_SHADER) self.program = shaders.compileProgram(fragment, vertex, compute) glDeleteShader(compute) else: self.program = shaders.compileProgram(fragment, vertex) glDeleteShader(fragment) glDeleteShader(vertex) self._delete_prog = glDeleteProgram self.locations = {}
def initializeProgram(self): shaderList = [] shaderList.append(compileShader(VERTEX_SHADER, GL.GL_VERTEX_SHADER)) shaderList.append(compileShader(FRAGMENT_SHADER, GL.GL_FRAGMENT_SHADER)) self.theProgram = compileProgram(*shaderList)
def init_context(name, modelview_matrix, projection_matrix): state = get_state() with open(state["shaders"][name]['vertex_shader_path']) as f: vertex_shader_text = f.read() vertex_shader = shaders.compileShader(vertex_shader_text, GL_VERTEX_SHADER) with open(state["shaders"][name]['fragment_shader_path']) as f: fragment_shader_text = f.read() fragment_shader = shaders.compileShader(fragment_shader_text, GL_FRAGMENT_SHADER) shader = shaders.compileProgram(vertex_shader, fragment_shader) #print "init interface state: ", state position_location = glGetAttribLocation(shader, 'position') normal_location = glGetAttribLocation(shader, 'normal') color_location = glGetAttribLocation(shader, 'color') modelview_location = glGetUniformLocation(shader, 'modelViewMatrix') projection_location = glGetUniformLocation(shader, 'projectionMatrix') contexts[name] = { 'shader': shader, 'modelview': { 'location': modelview_location, 'matrix': modelview_matrix }, 'projection': { 'location': projection_location, 'matrix': projection_matrix }, 'position_location': position_location, 'color_location': color_location, 'normal_location': normal_location, 'thing': state[name] }
def compile(self): vertexCode = self.getReturnOfFirstFunction("vertexin") fragmentCode = self.getReturnOfFirstFunction("fragmentin") if vertexCode is None: vertexCode = self.defaultVertexShaderCode if fragmentCode is None: fragmentCode = self.defaultFragmentShaderCode self.vertexShaderCode = vertexCode self.fragmentShaderCode = fragmentCode try: self.fragmentShader = shaders.compileShader(self.fragmentShaderCode, GL_FRAGMENT_SHADER) except: print(traceback.print_exc()) self.fragmentShader = shaders.compileShader(self.defaultFragmentShaderCode, GL_FRAGMENT_SHADER) try: self.vertexShader = shaders.compileShader(self.vertexShaderCode, GL_VERTEX_SHADER) except: print(traceback.print_exc()) self.vertexShader = shaders.compileShader(self.defaultVertexShaderCode, GL_VERTEX_SHADER) # -- Generate Shader program if isinstance(self.fragmentShader, int) and isinstance(self.vertexShader, int): self.shaderProgram = shaders.compileProgram(self.fragmentShader, self.vertexShader) self.fireExec("execout")
def initializeProgram(self): shaderList = [] shaderList.append(compileShader(VERTEX_SHADER, GL.GL_VERTEX_SHADER)) shaderList.append(compileShader(FRAGMENT_SHADER, GL.GL_FRAGMENT_SHADER)) self.theProgram = compileProgram(*shaderList) self.positionAttrib = GL.glGetAttribLocation(self.theProgram, "position") self.colorAttrib = GL.glGetAttribLocation(self.theProgram, "color") self.modelToCameraMatrixUnif = GL.glGetUniformLocation(self.theProgram, "modelToCameraMatrix") self.cameraToClipMatrixUnif = GL.glGetUniformLocation(self.theProgram, "cameraToClipMatrix") fzNear = 1.0 fzFar = 61.0 self.cameraToClipMatrix[0, 0] = self.fFrustumScale self.cameraToClipMatrix[1, 1] = self.fFrustumScale self.cameraToClipMatrix[2, 2] = (fzFar+fzNear)/(fzNear-fzFar) self.cameraToClipMatrix[2, 3] = -1.0 self.cameraToClipMatrix[3, 2] = (2*fzFar*fzNear)/(fzNear-fzFar) GL.glUseProgram(self.theProgram) GL.glUniformMatrix4fv(self.cameraToClipMatrixUnif,1,GL.GL_FALSE,self.cameraToClipMatrix.tolist()) GL.glUseProgram(0)
def __init__(self, vert_src, frag_src, attribs): self.program = compileProgram( compileShader(vert_src, GL.GL_VERTEX_SHADER), compileShader(frag_src, GL.GL_FRAGMENT_SHADER) ) self.attrib = {} for attrib in attribs: self.attrib[attrib] = GL.glGetAttribLocation(self.program, attrib)
def load_shaders(self): self.SetCurrent(self.context) self.val = 0 # Show OpenGL Information print "Vendor: " + glGetString(GL_VENDOR) print "Renderer: " + glGetString(GL_RENDERER) print "OpenGL Version: " + glGetString(GL_VERSION) print "Shader Version: " + glGetString(GL_SHADING_LANGUAGE_VERSION) VERTEX_SHADER = shaders.compileShader("""#version 330 core layout(location = 0) in vec4 position; uniform vec2 scale; out vec2 uv; void main() { gl_Position = vec4(position.xy * scale, position.zw); uv = position.xy/2 + 0.5f; uv.y = 1 - uv.y; }""", GL_VERTEX_SHADER) FRAGMENT_SHADER = shaders.compileShader("""#version 330 core uniform sampler2D myTexture; in vec2 uv; out vec4 outputColor; void main() { outputColor = texture2D(myTexture, uv ); }""", GL_FRAGMENT_SHADER) self.program = shaders.compileProgram(VERTEX_SHADER, FRAGMENT_SHADER) self.scale = glGetUniformLocation(self.program, "scale") self.texture = glGetUniformLocation(self.program, "myTexture") return
def compile_shader(self): vertex = shaders.compileShader(self.VERTEX_SHADER, GL_VERTEX_SHADER) fragment = shaders.compileShader(self.FRAGMENT_SHADER, GL_FRAGMENT_SHADER) self.shader = shaders.compileProgram(vertex, fragment)
def OnInit(self): vertex_shader = shaders.compileShader( """ void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; } """, GL_VERTEX_SHADER) fragment_shader = shaders.compileShader( """ void main() { gl_FragColor = vec4(0, 1, 0, 1); } """, GL_FRAGMENT_SHADER) self.shader = shaders.compileProgram(vertex_shader, fragment_shader) self.vbo = vbo.VBO( array([ [0, 1, 0], [-1, -1, 0], [1, -1, 0], [2, -1, 0], [4, -1, 0], [4, 1, 0], [2, -1, 0], [4, 1, 0], [2, 1, 0] ], "f"))
def initialize(self): vertex_shader = shaders.compileShader("""#version 330 in vec3 vPosition; uniform mat4 MVP; void main() { gl_Position = MVP * vec4(vPosition, 1.0); }""", gl.GL_VERTEX_SHADER) fragment_shader = shaders.compileShader("""#version 330 void main() { gl_FragColor = vec4( 0, 1, 1, 1 ); }""", gl.GL_FRAGMENT_SHADER) self._shader = shaders.compileProgram(vertex_shader, fragment_shader) self._position_handle = 0 gl.glBindAttribLocation(self._shader, self._position_handle, b"vPosition") self._mvp_handle = gl.glGetUniformLocation(self._shader, b"MVP") self._vertex_vbo = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._vertex_vbo) gl.glBufferData(gl.GL_ARRAY_BUFFER, len(self._model._vertex_buffer), self._model._vertex_buffer, gl.GL_STATIC_DRAW) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0) self._index_vbo = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self._index_vbo) gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, len(self._model._index_buffer), self._model._index_buffer, gl.GL_STATIC_DRAW) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, 0)
def initialize_program(): global offsetUniform, perspectiveMatrixUnif, SCREENSIZE """ Instead of calling OpenGL's shader compilation functions directly (glShaderSource, glCompileShader, etc), we use PyOpenGL's wrapper functions, which are much simpler to use. """ global theProgram theProgram = compileProgram( compileShader(strVertexShader, GL.GL_VERTEX_SHADER), compileShader(strFragmentShader, GL.GL_FRAGMENT_SHADER) ) offsetUniform = GL.glGetUniformLocation(theProgram, 'offset') perspectiveMatrixUnif = GL.glGetUniformLocation(theProgram, 'perspectiveMatrix') fFrustumScale = 1.0 fzNear = 0.5 fzFar = 3.0 w,h = SCREENSIZE theMatrix = N.zeros(16, dtype=N.float32) theMatrix[0] = fFrustumScale*float(h)/float(w) theMatrix[5] = fFrustumScale theMatrix[10] = (fzFar + fzNear) / (fzNear - fzFar) theMatrix[14] = (2 * fzFar * fzNear) / (fzNear - fzFar) theMatrix[11] = -1.0 GL.glUseProgram(theProgram) GL.glUniformMatrix4fv(perspectiveMatrixUnif, 1, GL.GL_FALSE, theMatrix) GL.glUseProgram(0);
def OnInit(self): VERTEX_SHADER = shaders.compileShader("""#version 120 void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }""", GL_VERTEX_SHADER) FRAGMENT_SHADER = shaders.compileShader("""#version 120 void main(){ gl_FragColor = vec4(0,1,1,1); }""",GL_FRAGMENT_SHADER) self.shader = shaders.compileProgram(VERTEX_SHADER,FRAGMENT_SHADER) self.vbo = vbo.VBO( array([ [ 0, 2, 0], [-1,-3, 0], [ 1,-1, 0], [ 2,-1, 0], [ 4,-1, 0], [ 4, 1, 0], [ 2,-1, 0], [ 4, 1, 0], [ 2, 1, 0] ],'f') )
def initializeShaders(): global theShaders, positionAttrib theShaders = compileProgram( compileShader(strVertexShader, GL_VERTEX_SHADER), compileShader(strFragmentShader, GL_FRAGMENT_SHADER) ) positionAttrib = glGetAttribLocation(theShaders, "position")
def __init__(self, size = 0.2): self.size = size self.vertexShader = shaders.compileShader(VERTEX_SOURCE, GL_VERTEX_SHADER) self.fragmentShader = shaders.compileShader(FRAGMENT_SOURCE, GL_FRAGMENT_SHADER) self.shader = shaders.compileProgram(self.vertexShader,self.fragmentShader) self.vao = glGenVertexArrays(1) glBindVertexArray(self.vao)
def __init__(self, resolution = (400,400), maxfps = 1): #Here we set everything up initially. #This will only be executed once. #Variables with the self-prefix are variables that can be used by other functions #within this particular class. I don't know if they span across other classes but #that would be kinda wierd, no? pg.init() self.resolution, self.maxfps = resolution, maxfps pg.display.set_mode(self.resolution, pg.OPENGL|pg.DOUBLEBUF) self.running = True #Is the program running? #We setup the shader. I think you later compile the shader in a #seperate file so this won't be so cluttered try: with open("VERTEX_SHADER.txt", 'r') as fileInput: ##LOADING VERTEX_SHADER-specs FROM EXTERNAL FILE VERTEX_SHADER = GLshaders.compileShader(fileInput.read(), GL.GL_VERTEX_SHADER) del fileInput #Cleanup! except(GL.GLError, RuntimeError) as err: print("Shader compile error (VERTEX_SHADER)", err) try: with open("FRAGMENT_SHADER.txt", 'r') as fileInput: ##LOADING VERTEX_SHADER-specs FROM EXTERNAL FILE FRAGMENT_SHADER = GLshaders.compileShader(fileInput.read(), GL.GL_FRAGMENT_SHADER) del fileInput #Cleanup! except(GL.GLError, RuntimeError) as err: print("Shader compile error (FRAGMENT_SHADER)", err) #The shader is compiled. Remember! This only happens once! #So no more changes after this point! self.GLEngineShader = GLshaders.compileProgram(VERTEX_SHADER, FRAGMENT_SHADER)
def initializeShaders(): global theShaders, positionAttrib, uvAttrib, \ modelUnif, viewUnif, projUnif, \ samplerUnif, scaleuvUnif theShaders = compileProgram( compileShader(strVertexShader, GL_VERTEX_SHADER), compileShader(strFragmentShader, GL_FRAGMENT_SHADER) ) positionAttrib = glGetAttribLocation(theShaders, "position") uvAttrib = glGetAttribLocation(theShaders, "uv") modelUnif = glGetUniformLocation(theShaders, "model") viewUnif = glGetUniformLocation(theShaders, "view") projUnif = glGetUniformLocation(theShaders, "projection") samplerUnif = glGetUniformLocation(theShaders, "sampler") scaleuvUnif = glGetUniformLocation(theShaders, "scaleuv") check("positionAttrib", positionAttrib) check("uvAttrib", uvAttrib) check("modelUnif", modelUnif) check("viewUnif", viewUnif) check("projUnif", projUnif) check("samplerUnif", samplerUnif) check("scaleuvUnif", scaleuvUnif)
def initializeProgram(self): shaderList = [] shaderList.append(compileShader(VERTEX_SHADER, GL.GL_VERTEX_SHADER)) shaderList.append(compileShader(FRAGMENT_SHADER, GL.GL_FRAGMENT_SHADER)) self.theProgram = compileProgram(*shaderList) self.offsetUniform = GL.glGetUniformLocation(self.theProgram, "offset") self.perspectiveMatrixUnif = GL.glGetUniformLocation(self.theProgram, "perspectiveMatrix") fFrustumScale = 1.0 fzNear = 0.5 fzFar = 3.0 theMatrix = [0.0 for i in range(16)] theMatrix[0] = fFrustumScale theMatrix[5] = fFrustumScale theMatrix[10] = (fzFar+fzNear)/(fzNear-fzFar) theMatrix[14] = (2*fzFar*fzNear)/(fzNear-fzFar) theMatrix[11] = -1.0 GL.glUseProgram(self.theProgram) GL.glUniformMatrix4fv(self.perspectiveMatrixUnif,1,GL.GL_FALSE,theMatrix) GL.glUseProgram(0)
def OnInit( self ): VERTEX_SHADER = shaders.compileShader("""#version 120 void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }""", GL_VERTEX_SHADER) FRAGMENT_SHADER = shaders.compileShader("""#version 120 uniform vec4 color; void main() { gl_FragColor = color; }""", GL_FRAGMENT_SHADER) self.shader = shaders.compileProgram(VERTEX_SHADER,FRAGMENT_SHADER) self.vbo = vbo.VBO( array( [ [ -2,-2, 0 ], [ 2,-2, 0 ], [ 2, 2, 0 ], [ -2,-2, 0 ], [ 2, 2, 0 ], [ -2, 2, 0 ], ],'f') )
def initializeGL(self): vertexShader = shaders.compileShader(vertexShaderSource, GL_VERTEX_SHADER) fragmentShader = shaders.compileShader(fragmentShaderSource, GL_FRAGMENT_SHADER) self.__shaderProgram = shaders.compileProgram(vertexShader, fragmentShader) vertices = ffi.new("float[]", [0.5, 0.5, 0.0, 0.5, -0.5, 0.0, -0.5, -0.5, 0.0, -0.5, 0.5, 0.0]) indices = ffi.new("unsigned int[]", [0, 1, 3, 1, 2, 3]) self.__vao = glGenVertexArrays(1) vbo = glGenBuffers(1) ebo = glGenBuffers(1) glBindVertexArray(self.__vao) glBindBuffer(GL_ARRAY_BUFFER, vbo) glBufferData(GL_ARRAY_BUFFER, ffi.sizeof(vertices), cffiToCtypeArray(vertices, ctypes.c_float), GL_STATIC_DRAW) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo) glBufferData(GL_ELEMENT_ARRAY_BUFFER, ffi.sizeof(indices), cffiToCtypeArray(indices, ctypes.c_uint), GL_STATIC_DRAW) glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * ffi.sizeof("float"), None) glEnableVertexAttribArray(0) glBindBuffer(GL_ARRAY_BUFFER, 0) glBindVertexArray(0)
def shades(): """Set up the Vertex and Fragment Shaders.""" global shaderp vertex_shader = shaders.compileShader("""#version 330 core layout (location = 0) in vec3 position; layout (location = 1) in vec3 normal; layout (location = 2) in vec3 colour; layout (location = 3) in vec2 texcord; uniform mat4 projectmatrix; uniform mat4 viewmatrix; uniform mat4 modelmatrix; out vec3 ourcolour; out vec2 ourtex; void main(){ gl_Position = projectmatrix * viewmatrix * modelmatrix * vec4(position, 1.0); ourcolour = colour; ourtex = texcord; }""", GL.GL_VERTEX_SHADER) fragment_shader = shaders.compileShader("""#version 330 core in vec3 ourcolour; in vec2 ourtex; out vec4 colour; uniform sampler2D tex; void main(){ colour = texture(tex, ourtex) * vec4(ourcolour, 1.0); }""", GL.GL_FRAGMENT_SHADER) shaderp = shaders.compileProgram(vertex_shader, fragment_shader) GL.glUseProgram(shaderp)
def __init__(self, vertexProgram, fragmentProgram): super(GLShader, self).__init__() self._vertexString = vertexProgram self._fragmentString = fragmentProgram try: vertexShader = shaders.compileShader(vertexProgram, GL_VERTEX_SHADER) fragmentShader = shaders.compileShader(fragmentProgram, GL_FRAGMENT_SHADER) #shader.compileProgram tries to return the shader program as a overloaded int. But the return value of a shader does not always fit in a int (needs to be a long). So we do raw OpenGL calls. # This is to ensure that this works on intel GPU's # self._program = shaders.compileProgram(self._vertexProgram, self._fragmentProgram) self._program = glCreateProgram() glAttachShader(self._program, vertexShader) glAttachShader(self._program, fragmentShader) glLinkProgram(self._program) # Validation has to occur *after* linking glValidateProgram(self._program) if glGetProgramiv(self._program, GL_VALIDATE_STATUS) == GL_FALSE: raise RuntimeError("Validation failure: %s"%(glGetProgramInfoLog(self._program))) if glGetProgramiv(self._program, GL_LINK_STATUS) == GL_FALSE: raise RuntimeError("Link failure: %s" % (glGetProgramInfoLog(self._program))) glDeleteShader(vertexShader) glDeleteShader(fragmentShader) except RuntimeError, e: print str(e) self._program = None
def shaderFromFile(self, shaderType, shaderFile): """read shader from file and compile it""" shaderSrc = '' with open(shaderFile) as sf: shaderSrc = sf.read() return shaders.compileShader(shaderSrc, shaderType)
def gl_realize(self, area): area.make_current() if (area.get_error() is not None): return version = gl.glGetString(gl.GL_VERSION).decode().split(" ")[0] if version < "3.3": self.errorlabel.set_text( _("Warning: OpenGL {} is unsupported. Plots supports OpenGL 3.3 or greater." ).format(version)) self.errorbar.props.revealed = True self.vertex_shader = shaders.compileShader( self.vertex_template.render(), gl.GL_VERTEX_SHADER) self.update_shader() self.vbo = vbo.VBO(np.array([[-1, -1, 0], [-1, 1, 0], [1, 1, 0], [-1, -1, 0], [1, -1, 0], [1, 1, 0]], 'f'), usage="GL_STATIC_DRAW_ARB") self.vao = gl.glGenVertexArrays(1) gl.glBindVertexArray(self.vao) self.vbo.bind() self.vbo.copy_data() gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 3 * self.vbo.data.itemsize, self.vbo) gl.glEnableVertexAttribArray(0) self.vbo.unbind() gl.glBindVertexArray(0) self.text_renderer = TextRenderer()
def get_shader(src, shader_type): try: with open(src) as file: src_text = file.read() return sh.compileShader(src_text, shader_type) except Exception as exception: print('Cannot open file {0}'.format(src))
def loadShader(filename, type): shaderSource = "" with open(filename) as f: shaderSource = "".join(f.readlines()) shaderID = shaders.compileShader(shaderSource, type) return shaderID
def __compileShaders(self, path_vertex: str, path_fragment: str): """ Read and compile .glsl shaders into a shader program :param path_vertex: Path to vertex shader :param path_fragment: Path to fragment shader :return: """ with open(path_vertex, "r") as source: vertex = compileShader(source.read(), GL_VERTEX_SHADER) with open(path_fragment, "r") as source: fragment = compileShader(source.read(), GL_FRAGMENT_SHADER) shader_program = compileProgram(vertex, fragment) return shader_program
def setShaders(self, vertexShader, fragShader): if vertexShader is not None or fragShader is not None: self.active_shader = compileProgram(compileShader(vertexShader, GL_VERTEX_SHADER), compileShader(fragShader, GL_FRAGMENT_SHADER), validate=False) else: self.active_shader = None glUseProgram(self.active_shader)
def main(): if not glfw.init(): return window = glfw.create_window(1280, 760, 'Shadings', None, None) if not window: glfw.terminate() return glfw.make_context_current(window) glClearColor(0.2, 0.3, 0.2, 1.0) glEnable(GL_DEPTH_TEST) glCullFace(GL_BACK) shader = shaders.compileProgram(shaders.compileShader(vertex_shader, GL_VERTEX_SHADER), shaders.compileShader(fragment_shader, GL_FRAGMENT_SHADER)) shape = Shape('cylinder', PhongMaterial(shader, 'flat', .0, .5, .5, 0.05)) # valores default iniciais key_flags = [False, False] while not glfw.window_should_close(window): glfw.poll_events() glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) get_input(window, shape, key_flags) shape.render() glfw.swap_buffers(window) glfw.terminate()
def shader(self): if self.compiled is None: try: self.compiled = shaders.compileShader(self.code, self.shaderType) except RuntimeError as exc: ## Format compile errors a bit more nicely if len(exc.args) == 3: err, code, typ = exc.args if not err.startswith('Shader compile failure'): raise code = code[0].split('\n') err, c, msgs = err.partition(':') err = err + '\n' msgs = msgs.split('\n') errNums = [()] * len(code) for i, msg in enumerate(msgs): msg = msg.strip() if msg == '': continue m = re.match(r'(\d+\:)?\d+\((\d+)\)', msg) if m is not None: line = int(m.groups()[1]) errNums[line-1] = errNums[line-1] + (str(i+1),) #code[line-1] = '%d\t%s' % (i+1, code[line-1]) err = err + "%d %s\n" % (i+1, msg) errNums = [','.join(n) for n in errNums] maxlen = max(map(len, errNums)) code = [errNums[i] + " "*(maxlen-len(errNums[i])) + line for i, line in enumerate(code)] err = err + '\n'.join(code) raise Exception(err) else: raise return self.compiled
def init(): global _shader, _locations, _pdata if _shader: return # Generate shaders vertex_shader = shaders.compileShader(_vertex_shader_source, GL_VERTEX_SHADER) fragment_shader = shaders.compileShader(_fragment_shader_source, GL_FRAGMENT_SHADER) _shader = shaders.compileProgram(vertex_shader, fragment_shader) _locations = { "p": glGetAttribLocation(_shader, "p"), "rect": glGetUniformLocation(_shader, "rect"), "viewsize": glGetUniformLocation(_shader, "viewsize"), "angle": glGetUniformLocation(_shader, "angle"), "alpha": glGetUniformLocation(_shader, "alpha"), "texture": glGetUniformLocation(_shader, "texture"), } _pdata = [0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0]
def loadShaders(self, vertexShader, fragmentShader): vertexShaderFile = os.path.join(abPath, vertexShader) fragmentShaderFile = os.path.join(abPath, fragmentShader) vertexShaderSource = '' with open(vertexShaderFile) as vs: vertexShaderSource = vs.read() fragmentShaderSource = '' with open(fragmentShaderFile) as fg: fragmentShaderSource = fg.read() vertexShader = shaders.compileShader(vertexShaderSource, GL_VERTEX_SHADER) fragmentShader = shaders.compileShader(fragmentShaderSource, GL_FRAGMENT_SHADER) shaderProgram = shaders.compileProgram(vertexShader, fragmentShader) return shaderProgram
def __init__(self,vs,fs,uniforms,**kwds): vertexShaderHandle = compileShader(vs,GL_VERTEX_SHADER) fragmentShaderHandle = compileShader(fs,GL_FRAGMENT_SHADER) self.program = mrvCompileProgramPreValidate(vertexShaderHandle,fragmentShaderHandle) try: self.vertex = glGetAttribLocation(self.program, "vertex") except: self.program = None if not self.program: return self.uniforms = {} for key in uniforms: self.uniforms[key] = glGetUniformLocation(self.program,key) self.context = SharedContextState self.preValidateConfig() mrvCompileProgramPostValidate(self.program,vertexShaderHandle,fragmentShaderHandle) super(Shader,self).__init__(**kwds)
def __init__(self, size=(1200, 900), connected=False): self.size = size self.connected = connected GLUT.glutInit([]) GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_RGB | GLUT.GLUT_DEPTH) GLUT.glutInitWindowSize(*size) GLUT.glutInitWindowPosition(0, 0) GLUT.glutCreateWindow("Render") self.vertex_shader = shaders.compileShader(PLAIN_VERTEX_SHADER, GL.GL_VERTEX_SHADER) self.fragment_shader = shaders.compileShader(CUBEMAP_FRAGMENT_SHADER, GL.GL_FRAGMENT_SHADER)
def main(): glutInit(sys.argv) glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH) glutInitWindowSize(800, 800) glutCreateWindow('fluid') FRAGMENT_SHADER = shaders.compileShader( """#version 120 void main() { gl_FragColor = vec4( 0, 1, 0, 1 ); }""", GL_FRAGMENT_SHADER ) shader = shaders.compileProgram(FRAGMENT_SHADER) shaders.glUseProgram(shader) glutDisplayFunc(display) glutIdleFunc(display) glMatrixMode(GL_PROJECTION) gluPerspective(40.0, 1.0, 1.0, 200.0) glMatrixMode(GL_MODELVIEW) gluLookAt(0, 0, 180, 0, 0, 0, 0, 1, 0) glPushMatrix() glutMainLoop() return
def __init__(self, vertexShaderPath: str, fragmentShaderPath: str): # Get the source code from the two files. vertexShaderSource = self.readShaderFromFile(vertexShaderPath) fragmentShaderSource = self.readShaderFromFile(fragmentShaderPath) # Compile the shaders. vertexShader = shaders.compileShader(vertexShaderSource, GL_VERTEX_SHADER) fragmentShader = shaders.compileShader(fragmentShaderSource, GL_FRAGMENT_SHADER) # Create the program. self.shader = shaders.compileProgram(vertexShader, fragmentShader) # Use shader. gl.glUseProgram(self.shader)
def __init__(self): pygame.init() self.resolution = 800, 600 pygame.display.gl_set_attribute(pygame.GL_CONTEXT_PROFILE_MASK, pygame.GL_CONTEXT_PROFILE_CORE) pygame.display.gl_set_attribute(pygame.GL_CONTEXT_MAJOR_VERSION, 3) pygame.display.gl_set_attribute(pygame.GL_CONTEXT_MINOR_VERSION, 3) pygame.display.set_mode(self.resolution, DOUBLEBUF | OPENGL) pygame.display.set_caption('PyShadeToy') # Shaders self.vertex_shader = shaders.compileShader(VERTEX_SHADER, GL_VERTEX_SHADER) self.fragment_shader = shaders.compileShader(FRAGMENT_SHADER, GL_FRAGMENT_SHADER) self.shader = shaders.compileProgram(self.vertex_shader, self.fragment_shader) # Uniform variables self.uni_mouse = glGetUniformLocation(self.shader, 'iMouse') self.uni_ticks = glGetUniformLocation(self.shader, 'iTime') glUseProgram( self.shader ) # Shader program needs to be active if you send uniform variables # Resolution doesn't change. Send it once self.uni_resolution = glGetUniformLocation(self.shader, 'iResolution') glUniform2f(self.uni_resolution, *self.resolution) # Create the fullscreen quad for drawing self.vertices = array( [-1.0, -1.0, 0.0, 1.0, -1.0, 0.0, 1.0, 1.0, 0.0, -1.0, 1.0, 0.0], dtype='float32') # Generate VAO self.vao = glGenVertexArrays(1) glBindVertexArray(self.vao) # Generate VBO which is stored in the VAO state self.vbo = glGenBuffers(1) glBindBuffer(GL_ARRAY_BUFFER, self.vbo) glBufferData(GL_ARRAY_BUFFER, self.vertices, GL_STATIC_DRAW) glEnableVertexAttribArray(0) glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None) self.clock = pygame.time.Clock()
def initialize(): global VERTEX_SHADER global FRAGMENT_SHADER global shaderProgram global VAO # compile shaders and program vertexShader = shaders.compileShader(VERTEX_SHADER, GL_VERTEX_SHADER) fragmentShader = shaders.compileShader(FRAGMENT_SHADER, GL_FRAGMENT_SHADER) shaderProgram = shaders.compileProgram(vertexShader, fragmentShader) # triangle position and color """ vertexData = numpy.array([0.0, 0.5, 0.0, 1, #bovenste punt: x,y, geenideez?, ydelendoorditw? 0.5, -0.366, 0.0, 1.0,#rechtsonder: x, -0.5, -0.366, 0.0, 1.0,#linksonder 1.0, 0.0, 0.0, 1.0,#kleur1? laatste is opacity 0.0, 1.0, 0.0, 1.0,#kleur2? 0.0, 0.0, 1.0, 1.0, ],#kleur3? dtype=numpy.float32) """ vertexData = numpy.array( [ -0.5, 0.366, 0.0, 1, 0.5, 0.366, 0.0, 1.0, 0.0, -0.5, 0.0, 1.0, 0.5, 0.7, 1.0 ], #kleur3? dtype=numpy.float32) # create VAO VAO = glGenVertexArrays(1) glBindVertexArray(VAO) # create VBO VBO = glGenBuffers(1) glBindBuffer(GL_ARRAY_BUFFER, VBO) glBufferData(GL_ARRAY_BUFFER, vertexData.nbytes, vertexData, GL_STATIC_DRAW) # enable array and set up data glEnableVertexAttribArray(0) glEnableVertexAttribArray(1) glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, None) # the last parameter is a pointer # python donot have pointer, have to using ctypes glVertexAttribPointer(1, 1, GL_FLOAT, GL_FALSE, 0, ctypes.c_void_p(48)) glBindBuffer(GL_ARRAY_BUFFER, 0) glBindVertexArray(0)
def OnInit(self): VERTEX_SHADER = shaders.compileShader( open("vert.glsl", "r").read(), GL_VERTEX_SHADER) FRAGMENT_SHADER = shaders.compileShader( open("frag.glsl", "r").read(), GL_FRAGMENT_SHADER) self.shader = shaders.compileProgram(VERTEX_SHADER, FRAGMENT_SHADER) self.vbo = vbo.VBO( array([ [0, 1, 0], [-1, -1, 0], [1, -1, 0], [2, -1, 0], [4, -1, 0], [4, 1, 0], [2, -1, 0], [4, 1, 0], [2, 1, 0], ], 'f')) self.UNIFORM_LOCATIONS = { 'viewport': glGetUniformLocation(self.shader, 'viewport'), 'pointSizeThreshold': glGetUniformLocation(self.shader, 'pointSizeThreshold'), 'MaxPixelSize': glGetUniformLocation(self.shader, 'MaxPixelSize'), 'ConstantRadius': glGetUniformLocation(self.shader, 'ConstantRadius'), } self.width = 512 self.height = 512 # glViewport( 0, 0, self.width, self.height ) glClearColor(0.0, 0.0, 0.0, 0.0) # This Will Clear The Background Color To Black glClearDepth(1.0) # Enables Clearing Of The Depth Buffer glDepthFunc(GL_LESS) # The Type Of Depth Test To Do glEnable(GL_DEPTH_TEST) # Enables Depth Testing glShadeModel(GL_SMOOTH) # Enables Smooth Color Shading glMatrixMode(GL_PROJECTION) glMatrixMode(GL_MODELVIEW)
def drawLines(box1): global VERTEXT_SHADER global FRAGMEN_SHADER_2 global shaderProgram vertexshader = shaders.compileShader(VERTEX_SHADER, GL_VERTEX_SHADER) fragmentshader = shaders.compileShader(FRAGMENT_SHADER_2, GL_FRAGMENT_SHADER) shaderProgram = shaders.compileProgram(vertexshader, fragmentshader) pointList=box1.pointsAsNumbersGivenPoints( box1.getLinePoints()) triangles = np.array(pointList, dtype=np.float32) VBO = glGenBuffers(1) glBindBuffer(GL_ARRAY_BUFFER, VBO) glBufferData(GL_ARRAY_BUFFER, triangles.nbytes, triangles, GL_STATIC_DRAW) position = glGetAttribLocation(shaderProgram, 'position') glVertexAttribPointer(position, 3, GL_FLOAT, GL_FALSE, 0, None) glEnableVertexAttribArray(position) glUseProgram(shaderProgram) # glClearColor(0, 0, 0, 1) # glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # # # glEnable(GL_DEPTH_TEST) #glDepthFunc(GL_LESS) glDrawArrays(GL_LINES, 0,len(pointList)) glUseProgram(0) glutSwapBuffers()
def __init__( self, name, vertex_shader_path, fragment_shader_path, excluded_attributes=[], excluded_uniforms=[], ): self.name = name with open(vertex_shader_path, "r") as vertex_file: vertex_shader_text = vertex_file.read() vertex_shader = shaders.compileShader(vertex_shader_text, gl.GL_VERTEX_SHADER) with open(fragment_shader_path, "r") as fragment_file: fragment_shader_text = fragment_file.read() fragment_shader = shaders.compileShader(fragment_shader_text, gl.GL_FRAGMENT_SHADER) self.program = shaders.compileProgram(vertex_shader, fragment_shader) count_attributes = gl.glGetProgramiv(self.program, gl.GL_ACTIVE_ATTRIBUTES) self.attributes = {} for i in range(count_attributes): bufsize = 256 length = (ctypes.c_int * 1)() size = (ctypes.c_int * 1)() type = (ctypes.c_uint * 1)() name = ctypes.create_string_buffer(bufsize) gl.glGetActiveAttrib(self.program, i, bufsize, length, size, type, name) name = name[:length[0]].decode("utf-8") if name in excluded_attributes: continue attribute_location = gl.glGetAttribLocation(self.program, name) self.attributes[name] = attribute_location count_uniforms = gl.glGetProgramiv(self.program, gl.GL_ACTIVE_UNIFORMS) self.uniforms = {} for i in range(count_uniforms): name, size, type = gl.glGetActiveUniform(self.program, i) name = name.decode("utf-8") if name in excluded_uniforms: continue uniform_location = gl.glGetUniformLocation(self.program, name) self.uniforms[name] = uniform_location
def loadShaders(self): currentFile = inspect.getframeinfo(inspect.currentframe()).filename abPath = os.path.dirname(os.path.abspath(currentFile)) vertexShaderFile = os.path.join(abPath, '3.basic.vs') fragmentShaderFile = os.path.join(abPath, '3.basic.frag') vertexShaderSource = '' with open(vertexShaderFile) as vs: vertexShaderSource = vs.read() fragmentShaderSource = '' with open(fragmentShaderFile) as fg: fragmentShaderSource = fg.read() vertexShader = shaders.compileShader(vertexShaderSource, GL_VERTEX_SHADER) fragmentShader = shaders.compileShader(fragmentShaderSource, GL_FRAGMENT_SHADER) return vertexShader, fragmentShader
def init(): global shaderProgram global vao global vbo glClearColor(0.7, 0.7, 0.7, 1) vertex_code = readShaderFile('map.vp') fragment_code = readShaderFile('map.fp') # compile shaders and program vertexShader = shaders.compileShader(vertex_code, GL_VERTEX_SHADER) fragmentShader = shaders.compileShader(fragment_code, GL_FRAGMENT_SHADER) shaderProgram = shaders.compileProgram(vertexShader, fragmentShader) # Create and bind the Vertex Array Object vao = GLuint(0) glGenVertexArrays(1, vao) glBindVertexArray(vao) # Create and bind the Vertex Buffer Object vertices = np.array( [[0, 0, 0, 0, 0, 1], [-1, -1, 0, 1, 1, 0], [1, -1, 0, 0, 1, 0]], dtype='f') vet = [] square(-1.0, 0.5, 2.0, 1.5, vet) # streets blocks(vet) home(0.65, 0.34, 0.1, 0.1, vet) vertices = np.array(vet, dtype='f') vbo = glGenBuffers(1) glBindBuffer(GL_ARRAY_BUFFER, vbo) glBufferData(GL_ARRAY_BUFFER, vertices, GL_STATIC_DRAW) glVertexAttribPointer( 0, 3, GL_FLOAT, False, 3 * sizeof(GLfloat), ctypes.c_void_p(0)) # first 0 is the location in shader glEnableVertexAttribArray(0) # 0=location do atributo, tem que ativar todos os atributos inicialmente sao desabilitados por padrao # Note that this is allowed, the call to glVertexAttribPointer registered VBO # as the currently bound vertex buffer object so afterwards we can safely unbind glBindBuffer(GL_ARRAY_BUFFER, 0) # Unbind VAO (it's always a good thing to unbind any buffer/array to prevent strange bugs) glBindVertexArray(0)
def plotpoints(): glClear(GL_COLOR_BUFFER_BIT) vertices = [ 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 2.0, 0.0, 0.0, 1.0, 1.0, 0.0, 2.0, 1.0, 0.0, 2.0, 0.0, 0.0 ] indices = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] vertices = np.array(vertices, dtype=np.float32) indices = np.array(indices, dtype=np.uint32) shader = compileProgram(compileShader(vertex_src, GL_VERTEX_SHADER), compileShader(fragment_src, GL_FRAGMENT_SHADER)) # Vertex Buffer Object VBO = glGenBuffers(1) glBindBuffer(GL_ARRAY_BUFFER, VBO) glBufferData(GL_ARRAY_BUFFER, vertices.nbytes, vertices, GL_STATIC_DRAW) # Element Buffer Object EBO = glGenBuffers(1) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO) glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.nbytes, indices, GL_STATIC_DRAW) glEnableVertexAttribArray(0) glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 12, ctypes.c_void_p(0)) glEnableVertexAttribArray(1) glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 12, ctypes.c_void_p(12)) glUseProgram(shader) glDrawElements(GL_TRIANGLES, len(indices), GL_UNSIGNED_INT, None) # Draw points glPointSize(6.0) glBegin(GL_POINTS) for i in range(0, len(vertices), 3): glVertex3f(vertices[i], vertices[i + 1], vertices[i + 2]) glEnd() glutSwapBuffers()
def compileProgram(self, vertCode, fragCode): """ A compileProgram version that ensures we don't recompile unnecessarily. """ program = self.__cache.get((vertCode, fragCode), None) if program: return program # skip shader validation step on linux validate = 'linux' not in sys.platform.lower() program = compileProgram( shaders.compileShader(vertCode, GL_VERTEX_SHADER), shaders.compileShader(fragCode, GL_FRAGMENT_SHADER), validate=validate ) self.__cache[(vertCode, fragCode)] = program return program
def setupLine(): global lineShader VERTEX_SHADER = shaders.compileShader( """#version 120 varying vec4 vColour; void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; vColour = gl_Color; }""", GL_VERTEX_SHADER) FRAGMENT_SHADER = shaders.compileShader("""#version 120 varying vec4 vColour; void main() { gl_FragColor = vColour; }""", GL_FRAGMENT_SHADER) lineShader = shaders.compileProgram(VERTEX_SHADER,FRAGMENT_SHADER)
def prepareToRender(self): vertices = np.array([-0.6, -0.4, 0.0, 0.6, -0.4, 0.0, 0, 0.6, 0.0], dtype=np.float32) self.numberOfVertices = np.size(vertices) // floatsPerVertex self.vao = gl.glGenVertexArrays(1) gl.glBindVertexArray(self.vao) #initialize shaders with open(os.path.join(pwd, 'shaders', 'triangle.vert'), 'r') as f: vs = shaders.compileShader(f.read() , gl.GL_VERTEX_SHADER) with open(os.path.join(pwd, 'shaders', 'triangle.frag'), 'r') as f: fs = shaders.compileShader(f.read(), gl.GL_FRAGMENT_SHADER) self.shader = shaders.compileProgram(vs,fs) self.mvpMatrixLoc = gl.glGetUniformLocation(self.shader,"mvpMatrix") #send the modelspace data to the GPU vbo = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo) position = gl.glGetAttribLocation(self.shader, 'position') gl.glEnableVertexAttribArray(position) gl.glVertexAttribPointer(position, floatsPerVertex, gl.GL_FLOAT, False, 0, ctypes.c_void_p(0)) gl.glBufferData(gl.GL_ARRAY_BUFFER, glfloat_size * np.size(vertices), vertices, gl.GL_STATIC_DRAW) # reset VAO/VBO to default gl.glBindVertexArray(0) gl.glBindBuffer(gl.GL_ARRAY_BUFFER,0)
def __loadShader(fileName, type): with open(fileName) as file: shaderSource = file.read() shaderID = compileShader(shaderSource, type) if glGetShaderiv(shaderID, GL_COMPILE_STATUS) == GL_FALSE: print(glGetShaderInfoLog(shaderID, 500)) print("Error: Could not compile shader", file=sys.stderr) return shaderID
def paintGL(self): program = compileProgram(compileShader(vertex_shaded, GL_VERTEX_SHADER), compileShader(fragment_shaded, GL_FRAGMENT_SHADER)) glLinkProgram(program) vertex_pos_model_space_ID = glGetAttribLocation(program, 'vertex_pos_model_space') vertex_normal_model_space_ID = glGetAttribLocation(program, 'vertex_normal_model_space') MVP_UID = glGetUniformLocation(program, 'MVP') M_UID = glGetUniformLocation(program, 'M') V_UID = glGetUniformLocation(program, 'V') color_UID = glGetUniformLocation(program, 'color') light_intensity_UID = glGetUniformLocation(program, 'light_intensity') light_pos_world_space_UID = glGetUniformLocation(program, 'light_pos_world_space') glEnable(GL_CULL_FACE) glEnable(GL_DEPTH_TEST) glDepthFunc(GL_LESS) glClearColor(0.2, 0.3, 0.35, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) for data, indices, mesh, color in self.to_render: try: glUseProgram(program) MVP = mmul(self.projection, self.view, mesh.transform.get_matrix()) glUniformMatrix4fv(MVP_UID, 1, GL_FALSE, MVP) glUniformMatrix4fv(M_UID, 1, GL_FALSE, mesh.transform.get_matrix()) glUniformMatrix4fv(V_UID, 1, GL_FALSE, self.view) glUniform1f(light_intensity_UID, np.single(30 * self.light_intensity)) glUniform3f(color_UID, *color) glUniform3f(light_pos_world_space_UID, *np.array(self.light_pos, 'f')) data.bind() indices.bind() try: glEnableVertexAttribArray(vertex_pos_model_space_ID) glVertexAttribPointer(vertex_pos_model_space_ID, 3, GL_FLOAT, GL_FALSE, 12, data) glEnableVertexAttribArray(vertex_normal_model_space_ID) glVertexAttribPointer(vertex_normal_model_space_ID, 3, GL_FLOAT, GL_FALSE, 12, data) glDrawElements(GL_TRIANGLES, len(indices), GL_UNSIGNED_INT, indices) finally: indices.unbind() data.unbind() glDisableVertexAttribArray(vertex_pos_model_space_ID) glDisableVertexAttribArray(vertex_normal_model_space_ID) finally: glUseProgram(0)
def update_shader(self): exprs = [] for f in self.formulae: body, expr = f.expr.to_glsl() if expr: exprs.append((body, expr)) try: fragment_shader = shaders.compileShader( self.fragment_template.render(formulae=exprs), GL_FRAGMENT_SHADER) except shaders.ShaderCompilationError as e: print(e.args[0]) fragment_shader = shaders.compileShader( self.fragment_template.render(formulae=[]), GL_FRAGMENT_SHADER) #print(e.args[1][0].decode()) self.shader = shaders.compileProgram(self.vertex_shader, fragment_shader)
def make_shader_program(vertex_filename, fragment_filename): def read_file(filename): with open(filename) as fp: return fp.readlines() try: shader_program = compileProgram( compileShader(read_file(vertex_filename), gl.GL_VERTEX_SHADER), compileShader(read_file(fragment_filename), gl.GL_FRAGMENT_SHADER)) except RuntimeError as exc: args = list(exc.args) sys.stderr.write(''.join(str(a) for a in args[:-2])) # sys.stderr.write(''.join(str(a) for a in args[-2])) # sys.stderr.write(args[-1]) sys.exit(1) return shader_program
def make_program(vertex_code_file, fragment_code_file, geometry_code_file=None): vertex_code = (SHADERS_PATH / vertex_code_file).read_text() fragment_code = (SHADERS_PATH / fragment_code_file).read_text() if geometry_code_file is not None: geometry_code = (SHADERS_PATH / geometry_code_file).read_text() return shaders.compileProgram( shaders.compileShader(vertex_code, gl.GL_VERTEX_SHADER), shaders.compileShader(fragment_code, gl.GL_FRAGMENT_SHADER), shaders.compileShader(geometry_code, gl.GL_GEOMETRY_SHADER)) return shaders.compileProgram( shaders.compileShader(vertex_code, gl.GL_VERTEX_SHADER), shaders.compileShader(fragment_code, gl.GL_FRAGMENT_SHADER))