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 __init__(self, graphics: Graphics, display_ratio: float, staff: Staff): self.staff = staff self.calibration = False self.display_ratio = 1.0 / display_ratio self.ref_c4_pos = [Staff.Pos[0], staff.note_positions[60]] self.note_width = Staff.NoteWidth32nd self.reset() # Notation shader draws from 0->1 on XY, left->right, down->up shader_substitutes = { "NUM_NOTES": NoteRender.NumNotes, "NUM_KEY_SIG": KeySignature.NumAccidentals, "#define staff_pos_x 0.0": f"#define staff_pos_x {0.5 + Staff.Pos[0] * 0.5}", "#define staff_pos_y 0.5": f"#define staff_pos_y {0.5 + Staff.Pos[1] * 0.5}", "#define staff_width 1.0": f"#define staff_width {Staff.Width * 0.5}", "#define staff_note_spacing 0.03": f"#define staff_note_spacing {Staff.NoteSpacing * 0.5}" } note_shader_path = Path(__file__).parent / "ext" / "shaders" / "notes.frag" note_shader = Graphics.process_shader_source(Graphics.load_shader(note_shader_path), shader_substitutes) self.shader = Graphics.create_shader(graphics.builtin_shader(Shader.TEXTURE, ShaderType.VERTEX), note_shader) self.texture = Texture("") self.sprite = SpriteTexture(graphics, self.texture, [1.0, 1.0, 1.0, 1.0], [0.0, 0.0], [2.0, 2.0], self.shader) self.display_ratio_id = glGetUniformLocation(self.shader, "DisplayRatio") self.music_time_id = glGetUniformLocation(self.shader, "MusicTime") self.key_positions_id = glGetUniformLocation(self.shader, "KeyPositions") self.note_positions_id = glGetUniformLocation(self.shader, "NotePositions") self.note_colours_id = glGetUniformLocation(self.shader, "NoteColours") self.note_types_id = glGetUniformLocation(self.shader, "NoteTypes") self.note_decoration_id = glGetUniformLocation(self.shader, "NoteDecoration") self.note_hats_id = glGetUniformLocation(self.shader, "NoteHats") self.note_ties_id = glGetUniformLocation(self.shader, "NoteTies") self.note_extra_id = glGetUniformLocation(self.shader, "NoteExtra")
def __init__(self): super(ImageShader, self).__init__(ImageShader.imageVertex, ImageShader.imageFragment) # Get our shader entry points self.attrib_position = glGetAttribLocation(self.program, 'position') self.uniform_modelCamera = glGetUniformLocation(self.program, 'modelToCameraMatrix') self.uniform_projection = glGetUniformLocation(self.program, 'projectionMatrix') self.uniform_alpha = glGetUniformLocation(self.program, 'alpha')
def __init__(self): super(TextShader, self).__init__(TextShader.textVertex, TextShader.textFragment) # Get our shader entry points self.attrib_position = glGetAttribLocation(self.program, 'position') self.uniform_modelCamera = glGetUniformLocation(self.program, 'modelToCameraMatrix') self.uniform_projection = glGetUniformLocation(self.program, 'projectionMatrix') self.uniform_color = glGetUniformLocation(self.program, 'color') self.uniform_tex = glGetUniformLocation(self.program, 'tex') self.uniform_alpha = glGetUniformLocation(self.program, 'alpha')
def setUpC48gammaCorrection(window, monitor, gamma_grid=None): """Sets up the gamma correction for C48 Args: window (PsychoPy.Window object): A PsychoPy Window object monitor (PsychoPy.Monitor object): The current monitor being used gamma_grid (list, optional): The gamma information if it is not contained in the monitor. (gamma_rgb; b_rgb, k_rgb) """ if not hasattr(window, '_DPShaderProg'): raise Warning( "Shader not set up! make sure you call setUpShaderAndWindow before setting up gamma correction." ) return from OpenGL.GL import glUseProgram, glUniform3f, glGetUniformLocation, glUniform1i glUseProgram(window._DPShaderProg) loc = glGetUniformLocation(window._DPShaderProg, "gamma_rgb") if loc == -1: raise Warning( "The current shader is not the right shader, are you sure you are in M16 mode?" ) return if gamma_grid is None: gamma_grid = monitor.getGammaGrid() if gamma_grid is None: raise Warning( "You did not provide gamma information and your monitor does not have any." ) return gamma_rgb = [gamma_grid[1][2], gamma_grid[2][2], gamma_grid[3][2]] # gamma b_rgb = [gamma_grid[1][4], gamma_grid[2][4], gamma_grid[3][4]] # b k_rgb = [gamma_grid[1][5], gamma_grid[2][5], gamma_grid[3][5]] # k else: gamma_rgb = [gamma_grid[0][0], gamma_grid[0][1], gamma_grid[0][2]] # gamma b_rgb = [gamma_grid[1][0], gamma_grid[1][1], gamma_grid[1][2]] # b k_rgb = [gamma_grid[2][0], gamma_grid[2][1], gamma_grid[2][2]] # k glUniform3f(glGetUniformLocation(window._DPShaderProg, "b_rgb"), b_rgb[0], b_rgb[1], b_rgb[2]) glUniform3f(glGetUniformLocation(window._DPShaderProg, "k_rgb"), k_rgb[0], k_rgb[1], k_rgb[2]) glUniform3f(glGetUniformLocation(window._DPShaderProg, "gamma_rgb"), gamma_rgb[0], gamma_rgb[1], gamma_rgb[2]) glUniform1i( glGetUniformLocation(window._DPShaderProg, "gamma_correction_flag"), 1)
def draw(self, reset, modelview): """Binds the shaders and things to draw the lamp itself. Takes a reference to the 'matrix reset' function, and a modelview matrix to draw by.""" glUseProgram(shaderl) reset(shaderl) glUniformMatrix4fv(glGetUniformLocation(shaderl, 'modelmatrix'), 1, False, modelview) self.model.draw()
def GetUniformLocation(self, name): if name in self.m_UniformLocationCache: return self.m_UniformLocationCache[name] location = glGetUniformLocation(self.m_RendererID, name) if location == -1: print(f"Warning: Uniform {name} does not exist!") self.m_UniformLocationCache[name] = location return location
def bind_uniform_array(self, data, name): """Bind uniform array.""" if data.dtype.kind == 'i': uniform_binder = glUniform1iv elif data.dtype.kind == 'f': uniform_binder = glUniform1fv location = glGetUniformLocation(self.__program, name) assert location >= 0 uniform_binder(location, data.size, data.flatten())
def __init__(self, vert_path, frag_path, uniform=()): self.vert_shader = open(path.join(SHADER_DIR, vert_path)).read() self.frag_shader = open(path.join(SHADER_DIR, frag_path)).read() vert = shaders.compileShader(self.vert_shader, GL_VERTEX_SHADER) frag = shaders.compileShader(self.frag_shader, GL_FRAGMENT_SHADER) self.program = shaders.compileProgram(vert, frag) uniform = uniform if isinstance(uniform, tuple) else (uniform,) self.uniform = { i: glGetUniformLocation(self.program, i) for i in uniform }
def _setup(self): """Setup OpenGL attributes if required""" if self._vao is None: # if the opengl state has not been set self._shader = get_shader(self.context_identifier, self.shader_name) glUseProgram(self._shader) self._transform_location = glGetUniformLocation( self._shader, "transformation_matrix" ) self._texture_location = glGetUniformLocation(self._shader, "image") self._vao = glGenVertexArrays(1) # create the array glBindVertexArray(self._vao) self._vbo = glGenBuffers(1) # and the buffer glBindBuffer(GL_ARRAY_BUFFER, self._vbo) self._setup_opengl_attrs() self._change_verts() glBindVertexArray(0) glBindBuffer(GL_ARRAY_BUFFER, 0) glUseProgram(0)
def get_location(self, variable: str) -> int: """Get location of a given variable within the shader""" if variable in self._stack: return self._stack[variable] location = glGetUniformLocation(self.program, variable) if location == -1: return False self._stack[variable] = location return location
def __init__(self, graphics: Graphics, textures: TextureManager, texture: str): self.time = 0.0 self.shader = Graphics.create_shader( graphics.builtin_shader(Shader.TEXTURE_ANIM, ShaderType.VERTEX), graphics.builtin_shader(Shader.TEXTURE_ANIM, ShaderType.PIXEL) ) self.time_id = glGetUniformLocation(self.shader, "Time") self.bg = textures.create_sprite_texture(texture, [0, 0], [2, 2], self.shader)
def init_shader(self, vertex=None, fragment=None): if self.gls_pgr: glUseProgram(0) if self.gls_pgr.shader_id: glDeleteShader(self.gls_pgr.shader_id) if vertex is None: vertex = """ #version 330 attribute vec2 xy_pos; uniform vec4 xy_color; uniform vec4 xy_color1; varying vec4 frg_color; void main(void) { frg_color = xy_color; gl_Position = vec4(xy_pos,0, 1.0); } """ print vertex if fragment is None: fragment = """ #version 330 varying vec4 frg_color; void main(void) { gl_FragColor = frg_color; } """ print fragment self.gls_pgr = ShaderProgram(vertex,fragment) glUseProgram(self.gls_pgr.program_id) self.vertIndex = self.gls_pgr.attribute_location('xy_pos') #glVertexAttribPointer(self.gls_pgr.attribute_location('xy_pos'), 2, GL_FLOAT, GL_FALSE, 0, None) # Turn on this vertex attribute in the shader #glEnableVertexAttribArray(0) self.gls_id_xy_color = self.gls_pgr.uniform_location("xy_color") print self.gls_id_xy_color cid=glGetUniformLocation(self.gls_pgr.program_id,"xy_color1") print cid glUniform4fv(self.gls_id_xy_color,1, self.color)
def enableGammaCorrection(window): """Enables M16 or C48 shader gamma correction""" from OpenGL.GL import glUseProgram, glUniform3f, glGetUniformLocation, glUniform1i if not hasattr(window, '_DPShaderProg'): raise Warning( "Shader not set up! make sure you call setUpShaderAndWindow before setting up gamma correction." ) return glUseProgram(window._DPShaderProg) glUniform1i( glGetUniformLocation(window._DPShaderProg, "gamma_correction_flag"), 1)
def init_shader(self, vertex=None, fragment=None): if self.gls_pgr: glUseProgram(0) if self.gls_pgr.shader_id: glDeleteShader(self.gls_pgr.shader_id) if vertex is None: vertex = """ #version 330 attribute vec2 xy_pos; uniform vec4 xy_color; uniform vec4 xy_color1; varying vec4 frg_color; void main(void) { frg_color = xy_color; gl_Position = vec4(xy_pos,0, 1.0); } """ print vertex if fragment is None: fragment = """ #version 330 varying vec4 frg_color; void main(void) { gl_FragColor = frg_color; } """ print fragment self.gls_pgr = ShaderProgram(vertex, fragment) glUseProgram(self.gls_pgr.program_id) self.vertIndex = self.gls_pgr.attribute_location('xy_pos') #glVertexAttribPointer(self.gls_pgr.attribute_location('xy_pos'), 2, GL_FLOAT, GL_FALSE, 0, None) # Turn on this vertex attribute in the shader #glEnableVertexAttribArray(0) self.gls_id_xy_color = self.gls_pgr.uniform_location("xy_color") print self.gls_id_xy_color cid = glGetUniformLocation(self.gls_pgr.program_id, "xy_color1") print cid glUniform4fv(self.gls_id_xy_color, 1, self.color)
def uniform_location(self, name): """ Helper function to get location of an OpenGL uniform variable Parameters ---------- name : str Name of the variable for which location is to be returned Returns ------- value : int Integer describing location """ return glGetUniformLocation(self.program_id, name)
def level5_init(level, program): # 1.59 - approximate position of the eyes of a person who is 1.69 meters tall level.position = array([0, 0, 1.59, 1], dtype='float32') # looking forward in Y-axis positive direction level.orientation = array([0, 1, 0, 0], dtype='float32') level.time_start = time() level.time_checkpoint = level.time_start # get position for view matrix level.view_pos = glGetUniformLocation(program, 'view') # get position for rotating model matrix level.rotating_model_pos = glGetUniformLocation(program, 'rotating_model') # sun level.sun_color = array([1.0, 1.0, 1.0], dtype='float32') level.sun_color_pos = glGetUniformLocation(program, 'sunColor') glUniform3fv(level.sun_color_pos, 1, level.sun_color) level.sun_direction_pos = glGetUniformLocation(program, 'sunDirection') glUniform3fv(level.sun_direction_pos, 1, level.sun_direction) level.ambient_intensity = 0.2 level.ambient_intensity_pos = glGetUniformLocation(program, 'ambientIntensity') glUniform1f(level.ambient_intensity_pos, level.ambient_intensity) # initialize projection matrix once level.projection = perspective(pi / 3.5, level.screen_w / level.screen_h, 0.005, 1000000.0) level.projection_pos = glGetUniformLocation(program, 'projection') glUniformMatrix4fv(level.projection_pos, 1, GL_FALSE, level.projection)
def __init__(self, vertex_shader, fragment_shader): self.vert = vertex_shader self.frag = fragment_shader self._models_and_VAOs = [] self._program = shaders.compileProgram(self.vert.shader, self.frag.shader) self.VAOs = [] # get uniform locations self.uniforms = {} self.ins = {} for var in self.vert.vars: if var.cls == "uniform": loc = glGetUniformLocation(self._program, var.name) if loc == -1: print( "WARNING: Uniform " + var.name + " returned -1; this indicates that the var is not being used by the program." ) else: self.uniforms[var.name] = (loc, var.type) if var.cls == "in" or var.cls == "inout" or var.cls == "varying": loc = glGetAttribLocation(self._program, var.name) if loc == -1: print( "WARNING: Attribute " + var.name + " returned -1; this indicates that the var is not being used by the program." ) self.ins[var.name] = (loc, var.type) for var in self.frag.vars: if var.cls == "uniform" and var.name not in self.uniforms: loc = glGetUniformLocation(self._program, var.name) if loc == -1: print( "WARNING: Attribute " + var.name + " location returned -1; this indicates that the var is not being used by the program." ) self.uniforms[var.name] = [loc, var.type]
def compileShader(self): create_opengl_context((self.width, self.height)) glClear(GL_COLOR_BUFFER_BIT) self.shader = shaders.compileProgram(self.compileVertexShader(), self.compileFragmentShader()) self.xpos = glGetUniformLocation(self.shader, 'xpos') self.ypos = glGetUniformLocation(self.shader, 'ypos') self.vdir_x = glGetUniformLocation(self.shader, 'vdir_x') self.vdir_y = glGetUniformLocation(self.shader, 'vdir_y') self.vdir_z = glGetUniformLocation(self.shader, 'vdir_z') self.arrow_size = glGetUniformLocation(self.shader, 'size') self.res_loc = glGetUniformLocation(self.shader, 'iResolution')
def orthogonalPass(self, debugShadows=False): """ draw stuff in orthogonal projection. mainly the scene can be post processed here and some gui elements could be drawn. """ ### DRAW THE SCENE ### # TODO: post shader magic ! glUseProgram(0) # enable the scene texture # Note that texture unit 0 should be active now. glEnable(GL_TEXTURE_2D) glBindTexture(GL_TEXTURE_2D, self.sceneTexture.glID) # make sure texture matrix is set to identity glMatrixMode(GL_TEXTURE) glLoadIdentity() glMatrixMode(GL_MODELVIEW) glBegin(GL_QUADS) glTexCoord2f(0.0, 0.0) glVertex3f(0.0, 0.0, -1.0) glTexCoord2f(1.0, 0.0) glVertex3f(self.winSize[0], 0.0, -1.0) glTexCoord2f(1.0, 1.0) glVertex3f(self.winSize[0], self.winSize[1], -1.0) glTexCoord2f(0.0, 1.0) glVertex3f(0.0, self.winSize[1], -1.0) glEnd() ### DEBUG DRAWINGS ### # debug shadow maps if debugShadows: # draw the shadow maps self.visualizeDepthShader.enable() layerLoc = glGetUniformLocation(self.visualizeDepthShader.program, "layer") drawShadowMaps(self.lights, layerLoc) # reset viewport and reset to ffp glViewport(0, 0, self.winSize[0], self.winSize[1]) glUseProgram(0) glBindTexture(GL_TEXTURE_2D, 0) glDisable(GL_TEXTURE_2D) GLApp.orthogonalPass(self)
def __init__(self, vertex_shader: Union[str, None] = None, fragment_shader: Union[str, None] = None, geometry_shader: Union[str, None] = None, view_matrix_name: str = 'view_matrix', projection_matrix_name: str = 'projection_matrix', model_matrix_name: str = 'model_matrix', instanced_attribs=(), obj=None): super().__init__('Material', obj) self.__vertex_shader = vertex_shader self.__fragment_shader = fragment_shader self.__geometry_shader = geometry_shader self.__attributes: Dict[str, int] = {} self.__uniforms: Dict[str, int] = {} self.view_matrix_name = view_matrix_name self.projection_matrix_name = projection_matrix_name self.model_matrix_name = model_matrix_name self.__instanced_attribs = set(instanced_attribs) self.__attributes_values: Union[Dict[str, np.ndarray]] = {} self.__uniforms_values: Union[Dict[str, np.ndarray]] = {} self.__attributes_types = {} self.__uniforms_types = {} if self.__vertex_shader and self.__fragment_shader: program = compileProgram( *[compileShader(shader, const) for shader, const in [(self.__vertex_shader, GL_VERTEX_SHADER), (self.__fragment_shader, GL_FRAGMENT_SHADER), (self.__geometry_shader, GL_GEOMETRY_SHADER)] if shader] ) self.__program = program num_active_attribs = glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES) for u in range(num_active_attribs): name, size, type_ = glGetActiveAttrib(program, u) location = glGetAttribLocation(program, name) name = name.decode("utf-8") self.__attributes_types[name] = type_ self.__attributes[name] = location self.__attributes_values[name] = np.array([]) num_active_uniforms = glGetProgramiv(program, GL_ACTIVE_UNIFORMS) for u in range(num_active_uniforms): name, size, type_ = glGetActiveUniform(program, u) location = glGetUniformLocation(program, name) name = name.decode("utf-8") self.__uniforms_types[name] = type_ self.__uniforms[name] = location self.__uniforms_values[name] = np.array([])
def setUniformValue(self, name, *value): # 1-4 values of floats or ints(value[0] used to check the type) # or one numpy.array of floats or ints with shape (1,1)-(1,4) un_id = glGetUniformLocation(self.program_id, name) if self.__DEBUG: print "Set Uniform Vertex : ", self.vertpath print "Set Uniform Fragment : ", self.fragpath print "For '%s' name ID is %i" % (name, un_id) m = len(value) if m > 1: if isinstance(value[0], float): value = numpy.array(value, numpy.float32) else: value = numpy.array(value, numpy.int32) else: if m < 1: raise RuntimeError( "Empty uniform value! Uniform variables in shader can only have 1-4 int32/float32 elements." ) value = value[0] if isinstance(value, float): execution_command = 'GL.glUniform1f(%i, %s)' % (un_id, str(value)) exec(execution_command) return elif value.shape[0] < 1 or value.shape[0] > 4: raise RuntimeError( "Uniform variables in shader can only have 1-4 int32/float32 elements." ) if un_id >= 0 and isinstance(value, np.ndarray): # please, don't try to do it at production and be carefully at home ;) n = value.shape[0] type_label = str(value[0].dtype) type_symb = 'i' if 'int' in type_label else 'f' line = ', '.join(map(str, value)) execution_command = 'GL.glUniform%i%s(%i, %s)' % (n, type_symb, un_id, line) exec(execution_command) else: raise RuntimeError( "Uniform id: %i, \n value type : %s \n Use int32/float32 numpy arrays only!" % (un_id, str(type(value))))
def build(self, variables: Optional[List[str]] = None) -> int: """Build GLSL Shader Compile shaders and compile glsl program Args: variables: List of in/out/uniform variable names. Return: self.program """ vertex_shader = shaders.compileShader(self.vertex_shader_source, GL_VERTEX_SHADER) fragment_shader = shaders.compileShader(self.fragment_shader_source, GL_FRAGMENT_SHADER) self.program = shaders.compileProgram(vertex_shader, fragment_shader) if variables: self.variables = variables for v in self.variables: location = glGetUniformLocation(self.program, v) self._stack[v] = location return self.program
def update(self, *shaders): # TODO: for now this is actually create, not update self._shaders += shaders for shader in self._shaders: glAttachShader(self._hnd, shader.hnd) logging.info('glLinkProgram(%d)', self._hnd) glLinkProgram(self._hnd) logging.info('glGetProgramInfoLog(%d) -> %s', self._hnd, glGetProgramInfoLog(self._hnd).decode().strip()) self._uniforms = {} self._attributes = bidict() for shader in self._shaders: for name in shader.uniforms(): self._uniforms[name] = glGetUniformLocation(self._hnd, name) for name, location in shader.attributes(): if location in self._attributes.inv: raise KeyError('duplication attribute location', location, name) self._attributes[name] = location
def on_realize(self, area): # We need to make the context current if we want to # call GL API area.make_current() context = area.get_context() if (area.get_error() != None): return fragment_shader = shaders.compileShader(FRAGMENT_SOURCE, GL_FRAGMENT_SHADER) vertex_shader = shaders.compileShader(VERTEX_SOURCE, GL_VERTEX_SHADER) self.shaderContent.shader_prog = shaders.compileProgram( fragment_shader, vertex_shader) glLinkProgram(self.shaderContent.shader_prog) self.vertex_array_object = glGenVertexArrays(1) glBindVertexArray(self.vertex_array_object) # Generate buffers to hold our vertices self.vertex_buffer = glGenBuffers(1) glBindBuffer(GL_ARRAY_BUFFER, self.vertex_buffer) self.position = glGetAttribLocation(self.shaderContent.shader_prog, 'position') self.time_l = glGetUniformLocation(self.shaderContent.shader_prog, 'time') print(self.time_l) # glBindAttribLocation(self.shaderContent.shader_prog, self.time, 'time') glEnableVertexAttribArray(self.position) glVertexAttribPointer(index=self.position, size=4, type=GL_FLOAT, normalized=False, stride=0, pointer=ctypes.c_void_p(0)) glBufferData(GL_ARRAY_BUFFER, 192, self.vertices, GL_STATIC_DRAW) glBindVertexArray(0) glDisableVertexAttribArray(self.position) glBindBuffer(GL_ARRAY_BUFFER, 0) self.on_render(self.shaderContent) return True
def reload(self): """ Reload or build for the first time the uniforms cache. This can be quite expensive so it is only done on shader linking. If the shader was linked outside the api, you have to call this manually. """ prog = self.prog() if prog is None: raise RuntimeError('Shader was freed') maxlength = getattr(prog, 'max_uniform_length') name_buf = (c_char * maxlength)() name_buf_ptr = cast(name_buf, POINTER(c_char)) type_buf = GLenum(0) name_buf_length = GLint(0) buf_size = GLint(0) self.cache = {} for i in range(getattr(prog, 'uniforms_count')): name, size, type = glGetActiveUniform(prog.pid, i) name = name.decode('UTF-8') loc = glGetUniformLocation(prog.pid, name) self.cache_item_build(loc, size, name, type)
def getUniformLocation(self, name): return glGetUniformLocation(self.__programId, name)
def link_texture(self, name, number): """Link the texture to shaders.""" location = glGetUniformLocation(self.__program, name) assert location >= 0 glUniform1i(location, number)
def uniform(self, name): """Return the location integer for a uniform variable in this program""" return glGetUniformLocation(self.program, name.encode("utf_8"))
def setVec4(self, name, value): location = glGetUniformLocation(self.program, name) glUniform4fv(location, value)
def get_uniforms(program, names): return dict((name, glGetUniformLocation(program, name)) for name in names)
def uniformlocation(self, name): if name not in self.uniformlocs: self.uniformlocs[name] = glGetUniformLocation(self.program, name) return self.uniformlocs[name]
def bind_uniform_matrix(self, data, name): """Bind uniform matrix parameter.""" location = glGetUniformLocation(self.__program, name) assert location >= 0 glUniformMatrix4fv(location, 1, GL_FALSE, data.flatten())
def ubicacion(self, uniforme): """Retorna la ubicación de la vaiable uniforme en el programa. uniforme = texto del nombre de la variable""" return glGetUniformLocation(self.programa, uniforme)
def bind(self): """Bind the light values to the shader. Not the lamp shader, the other one.""" glUniform3f(glGetUniformLocation(self.model.shader, 'light.position'), *self.pos) glUniform3f(glGetUniformLocation(self.model.shader, 'light.ambient'), *self.ambient) glUniform3f(glGetUniformLocation(self.model.shader, 'light.diffuse'), *self.diffuse) glUniform3f(glGetUniformLocation(self.model.shader, 'light.specular'), *self.specular)
def setUInt(self, name, value): location = glGetUniformLocation(self.program, name) glUniform1ui(location, value)
def setFloat(self, name, value): location = glGetUniformLocation(self.program, name) glUniform1f(location, value)
def set_uniform_i(self, name, value): location = glGetUniformLocation(self.program, name) glUniform1i(location, value)
def setMat4(self, name, value): location = glGetUniformLocation(self.program, name) glUniformMatrix4fv(location, 1, GL_FALSE, value.data())
def setMat3(self, name, value): location = glGetUniformLocation(self.program, name) glUniformMatrix3fv(location, value)
def __get__(self, inst, owner): if inst not in self._values: self._values[inst] = glGetUniformLocation(inst.program, self.name) return self._values[inst]
def bind(self, shader): """Binds a bunch of GLSL Uniforms. Do try not to change their names or anything.""" glUniform3f(glGetUniformLocation(shader, 'material.ambient'), *self.ambient) glUniform3f(glGetUniformLocation(shader, 'material.diffuse'), *self.diffuse) glUniform3f(glGetUniformLocation(shader, 'material.specular'), *self.specular) glUniform1f(glGetUniformLocation(shader, 'material.shininess'), self.shininess)
def uniformLocation(self, name): return glGetUniformLocation(self.program_id, name)
def run(): #Start OpenGL and ask it for an OpenGL context pygame.init() clock = pygame.time.Clock() screen = pygame.display.set_mode(SCREEN_SIZE, pygame.HWSURFACE|pygame.OPENGL|pygame.DOUBLEBUF) #The first thing we do is print some OpenGL details and check that we have a good enough version print("OpenGL Implementation Details:") if glGetString(GL_VENDOR): print("\tGL_VENDOR: {}".format(glGetString(GL_VENDOR).decode())) if glGetString(GL_RENDERER): print("\tGL_RENDERER: {}".format(glGetString(GL_RENDERER).decode())) if glGetString(GL_VERSION): print("\tGL_VERSION: {}".format(glGetString(GL_VERSION).decode())) if glGetString(GL_SHADING_LANGUAGE_VERSION): print("\tGL_SHADING_LANGUAGE_VERSION: {}".format(glGetString(GL_SHADING_LANGUAGE_VERSION).decode())) major_version = int(glGetString(GL_VERSION).decode().split()[0].split('.')[0]) minor_version = int(glGetString(GL_VERSION).decode().split()[0].split('.')[1]) if major_version < 3 or (major_version < 3 and minor_version < 0): print("OpenGL version must be at least 3.0 (found {0})".format(glGetString(GL_VERSION).decode().split()[0])) #Now onto the OpenGL initialisation #Set up depth culling glEnable(GL_CULL_FACE) glEnable(GL_DEPTH_TEST) glDepthMask(GL_TRUE) glDepthFunc(GL_LEQUAL) glDepthRange(0.0, 1.0) #We create out shaders which do little more than set a flat colour for each face VERTEX_SHADER = shaders.compileShader(b""" #version 130 in vec4 position; in vec4 normal; uniform mat4 projectionMatrix; uniform mat4 viewMatrix; uniform mat4 modelMatrix; flat out float theColor; void main() { vec4 temp = modelMatrix * position; temp = viewMatrix * temp; gl_Position = projectionMatrix * temp; theColor = clamp(abs(dot(normalize(normal.xyz), normalize(vec3(0.9,0.1,0.5)))), 0, 1); } """, GL_VERTEX_SHADER) FRAGMENT_SHADER = shaders.compileShader(b""" #version 130 flat in float theColor; out vec4 outputColor; void main() { outputColor = vec4(1.0, 0.5, theColor, 1.0); } """, GL_FRAGMENT_SHADER) shader = shaders.compileProgram(VERTEX_SHADER, FRAGMENT_SHADER) #And then grab our attribute locations from it glBindAttribLocation(shader, 0, b"position") glBindAttribLocation(shader, 1, b"normal") #Create the Vertex Array Object to hold our volume mesh vertexArrayObject = GLuint(0) glGenVertexArrays(1, vertexArrayObject) glBindVertexArray(vertexArrayObject) #Create the index buffer object indexPositions = vbo.VBO(indices, target=GL_ELEMENT_ARRAY_BUFFER, usage=GL_STATIC_DRAW) #Create the VBO vertexPositions = vbo.VBO(vertices, usage=GL_STATIC_DRAW) #Bind our VBOs and set up our data layout specifications with indexPositions, vertexPositions: glEnableVertexAttribArray(0) glVertexAttribPointer(0, 3, GL_FLOAT, False, 6*vertices.dtype.itemsize, vertexPositions+(0*vertices.dtype.itemsize)) glEnableVertexAttribArray(1) glVertexAttribPointer(1, 3, GL_FLOAT, False, 6*vertices.dtype.itemsize, vertexPositions+(3*vertices.dtype.itemsize)) glBindVertexArray(0) glDisableVertexAttribArray(0) #Now grab out transformation martix locations modelMatrixUnif = glGetUniformLocation(shader, b"modelMatrix") viewMatrixUnif = glGetUniformLocation(shader, b"viewMatrix") projectionMatrixUnif = glGetUniformLocation(shader, b"projectionMatrix") modelMatrix = np.array([[1.0,0.0,0.0,-32.0],[0.0,1.0,0.0,-32.0],[0.0,0.0,1.0,-32.0],[0.0,0.0,0.0,1.0]], dtype='f') viewMatrix = np.array([[1.0,0.0,0.0,0.0],[0.0,1.0,0.0,0.0],[0.0,0.0,1.0,-50.0],[0.0,0.0,0.0,1.0]], dtype='f') projectionMatrix = np.array([[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]], dtype='f') #These next few lines just set up our camera frustum fovDeg = 45.0 frustumScale = 1.0 / tan(radians(fovDeg) / 2.0) zNear = 1.0 zFar = 1000.0 projectionMatrix[0][0] = frustumScale projectionMatrix[1][1] = frustumScale projectionMatrix[2][2] = (zFar + zNear) / (zNear - zFar) projectionMatrix[2][3] = -1.0 projectionMatrix[3][2] = (2 * zFar * zNear) / (zNear - zFar) #viewMatrix and projectionMatrix don't change ever so just set them once here with shader: glUniformMatrix4fv(projectionMatrixUnif, 1, GL_TRUE, projectionMatrix) glUniformMatrix4fv(viewMatrixUnif, 1, GL_TRUE, viewMatrix) #These are used to track the rotation of the volume LastFrameMousePos = (0,0) CurrentMousePos = (0,0) xRotation = 0 yRotation = 0 while True: clock.tick() for event in pygame.event.get(): if event.type == pygame.QUIT: return if event.type == pygame.KEYUP and event.key == pygame.K_ESCAPE: return if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1: CurrentMousePos = event.pos LastFrameMousePos = CurrentMousePos if event.type == pygame.MOUSEMOTION and 1 in event.buttons: CurrentMousePos = event.pos diff = (CurrentMousePos[0] - LastFrameMousePos[0], CurrentMousePos[1] - LastFrameMousePos[1]) xRotation += event.rel[0] yRotation += event.rel[1] LastFrameMousePos = CurrentMousePos glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) #Perform the rotation of the mesh moveToOrigin = np.array([[1.0,0.0,0.0,-32.0],[0.0,1.0,0.0,-32.0],[0.0,0.0,1.0,-32.0],[0.0,0.0,0.0,1.0]], dtype='f') rotateAroundX = np.array([[1.0,0.0,0.0,0.0],[0.0,cos(radians(yRotation)),-sin(radians(yRotation)),0.0],[0.0,sin(radians(yRotation)),cos(radians(yRotation)),0.0],[0.0,0.0,0.0,1.0]], dtype='f') rotateAroundY = np.array([[cos(radians(xRotation)),0.0,sin(radians(xRotation)),0.0],[0.0,1.0,0.0,0.0],[-sin(radians(xRotation)),0.0,cos(radians(xRotation)),0.0],[0.0,0.0,0.0,1.0]], dtype='f') modelMatrix = rotateAroundY.dot(rotateAroundX.dot(moveToOrigin)) with shader: glUniformMatrix4fv(modelMatrixUnif, 1, GL_TRUE, modelMatrix) glBindVertexArray(vertexArrayObject) glDrawElements(GL_TRIANGLES, len(indices), GL_UNSIGNED_INT, None) glBindVertexArray(0) # Show the screen pygame.display.flip()
def bind_uniform_vector(self, data, name): """Bind uniform vector parameter.""" location = glGetUniformLocation(self.__program, name) assert location >= 0 glUniform4f(location, *data.flatten())
def uloc(self,n): return glGetUniformLocation(self.program_id, n)
def _find_uniforms(self): from OpenGL.GL import glGetUniformLocation self._uniform_handles = { \ name: glGetUniformLocation(self._gl_handle, str(name)) \ for name in self.uniforms.keys() }