def link_shaders(*shaders): """Link an arbitrary number of shaders.""" program = gl.glCreateProgram() for shader in shaders: gl.glAttachShader(program, shader) gl.glLinkProgram(program) # check linking error result = gl.glGetProgramiv(program, gl.GL_LINK_STATUS) if not(result): raise RuntimeError(gl.glGetProgramInfoLog(program)) return program
def _compile_shaders(self, shaders): for shader_type, shader_src in shaders.items(): shader_id = gl.glCreateShader(shader_type) gl.glShaderSource(shader_id, shader_src) gl.glCompileShader(shader_id) # check if compilation was successful gl.glGetShaderiv(shader_id, gl.GL_COMPILE_STATUS) info_log_len = gl.glGetShaderiv(shader_id, gl.GL_INFO_LOG_LENGTH) if info_log_len: logmsg = gl.glGetShaderInfoLog(shader_id) print(logmsg) sys.exit(10) gl.glAttachShader(self.program_id, shader_id) self.shader_ids.append(shader_id) gl.glLinkProgram(self.program_id) # check if linking was successful gl.glGetProgramiv(self.program_id, gl.GL_LINK_STATUS) info_log_len = gl.glGetProgramiv(self.program_id, gl.GL_INFO_LOG_LENGTH) if info_log_len: logmsg = gl.glGetProgramInfoLog(self.program_id) print(logmsg) sys.exit(11)
def _get_shader(path, file, shader_type, program): """ Create the shader and link shader source code :param path: Shader code path :param file: Shader code file :param shader_type: GL_VERTEX_SHADER or GL_FRAGMENT_SHADER :return: glShader """ with open(abspath(join(path, file)), mode='r') as f: shader_code = f.read() if not shader_code: raise ValueError shader = gl.glCreateShader(shader_type) info(gl.glGetError()) # Link gl.glShaderSource(shader, shader_code) info(gl.glGetError()) # Compile gl.glCompileShader(shader) info(gl.glGetError()) # Attach gl.glAttachShader(program, shader) info(gl.glGetError()) return shader
def on_initialize(self): gl.glClearColor(1,1,1,1) gl.glEnable(gl.GL_DEPTH_TEST) # Create shader program self._prog_handle = gl.glCreateProgram() # Create vertex shader shader = gl.glCreateShader(gl.GL_VERTEX_SHADER) gl.glShaderSource(shader, VERT_CODE) gl.glCompileShader(shader) status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) if not status: # We could show more useful info here, but that takes a few lines raise RuntimeError('Vertex shader did not compile.') else: gl.glAttachShader(self._prog_handle, shader) # Create fragment shader shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(shader, FRAG_CODE) gl.glCompileShader(shader) status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) if not status: # We could show more useful info here, but that takes a few lines raise RuntimeError('Fragment shader did not compile.') else: gl.glAttachShader(self._prog_handle, shader) # Link gl.glLinkProgram(self._prog_handle) status = gl.glGetProgramiv(self._prog_handle, gl.GL_LINK_STATUS) if not status: # We could show more useful info here, but that takes a few lines raise RuntimeError('Program did not link.') # Create texture im = io.cat() self._tex_handle = gl.glGenTextures(1) gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1) gl.glBindTexture(gl.GL_TEXTURE_2D, self._tex_handle) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, im.shape[1], im.shape[0], 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, im) gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) if use_buffers: # Create vertex buffer self._positions_handle = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._positions_handle) gl.glBufferData(gl.GL_ARRAY_BUFFER, positions.nbytes, positions, gl.GL_DYNAMIC_DRAW) # self._texcoords_handle = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._texcoords_handle) gl.glBufferData(gl.GL_ARRAY_BUFFER, texcoords.nbytes, texcoords, gl.GL_DYNAMIC_DRAW) # Create buffer for faces self._faces_handle = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self._faces_handle) gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, faces.nbytes, faces, gl.GL_DYNAMIC_DRAW)
def init_gl(self, force=False): if force: Program._current = None if self.program_id is not None: if not force: return vs = gl.glCreateShader(gl.GL_VERTEX_SHADER) gl.glShaderSource(vs, self.vs_src) gl.glCompileShader(vs) if not gl.glGetShaderiv(vs, gl.GL_COMPILE_STATUS): raise Exception('failed to compile vertex shader:\n%s' % gl.glGetShaderInfoLog(vs).decode()) fs = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(fs, self.fs_src) gl.glCompileShader(fs) if not gl.glGetShaderiv(fs, gl.GL_COMPILE_STATUS): raise Exception('failed to compile fragment shader:\n%s' % gl.glGetShaderInfoLog(fs).decode()) program_id = gl.glCreateProgram() gl.glAttachShader(program_id, vs) gl.glAttachShader(program_id, fs) gl.glLinkProgram(program_id) if not gl.glGetProgramiv(program_id, gl.GL_LINK_STATUS): raise Exception('failed to link program') gl.glDetachShader(program_id, vs) gl.glDetachShader(program_id, fs) self.program_id = program_id _logger.info('%s.init_gl: OK', self.__class__.__name__)
def load_shaders(): shaders = { gl.GL_VERTEX_SHADER: '''\ #version 330 core layout(location = 0) in vec3 vertexPosition_modelspace; uniform mat4 MVP; void main() { gl_Position = MVP * vec4(vertexPosition_modelspace, 1); } ''', gl.GL_FRAGMENT_SHADER: '''\ #version 330 core out vec3 color; void main() { color = vec3(1,0,0); } '''} log.debug('creating the shader program') program_id = gl.glCreateProgram() shader_ids = [] try: for shader_type, shader_src in shaders.items(): shader_id = gl.glCreateShader(shader_type) gl.glShaderSource(shader_id, shader_src) log.debug(f'compiling the {shader_type} shader') gl.glCompileShader(shader_id) # check if compilation was successful result = gl.glGetShaderiv(shader_id, gl.GL_COMPILE_STATUS) nlog = gl.glGetShaderiv(shader_id, gl.GL_INFO_LOG_LENGTH) if nlog: log_msg = gl.glGetShaderInfoLog(shader_id) log.error(log_msg) sys.exit(10) gl.glAttachShader(program_id, shader_id) shader_ids.append(shader_id) log.debug('linking shader program') gl.glLinkProgram(program_id) # check if linking was successful result = gl.glGetProgramiv(program_id, gl.GL_LINK_STATUS) nlog = gl.glGetProgramiv(program_id, gl.GL_INFO_LOG_LENGTH) if nlog: log_msg = gl.glGetProgramInfoLog(program_id) log.error(log_msg) sys.exit(11) log.debug('installing shader program into rendering state') gl.glUseProgram(program_id) yield program_id finally: log.debug('cleaning up shader program') for shader_id in shader_ids: gl.glDetachShader(program_id, shader_id) gl.glDeleteShader(shader_id) gl.glUseProgram(0) gl.glDeleteProgram(program_id)
def initShaders(self): # build vertex shader object self.vertexShader = GL.glCreateShader(GL.GL_VERTEX_SHADER) GL.glShaderSource(self.vertexShader, texture_phong_vsrc) GL.glCompileShader(self.vertexShader) result = GL.glGetShaderiv(self.vertexShader, GL.GL_COMPILE_STATUS) if result != 1: print(GL.glGetShaderInfoLog(self.vertexShader)) raise Exception("Error compiling vertex shader") # build fragment shader object self.fragmentShader = GL.glCreateShader(GL.GL_FRAGMENT_SHADER) GL.glShaderSource(self.fragmentShader, texture_phong_fsrc) GL.glCompileShader(self.fragmentShader) result = GL.glGetShaderiv(self.fragmentShader, GL.GL_COMPILE_STATUS) if result != 1: print(GL.glGetShaderInfoLog(self.fragmentShader)) raise Exception("Error compiling fragment shader") # build shader program and attach shader objects self.shaderProgram = GL.glCreateProgram() GL.glAttachShader(self.shaderProgram, self.vertexShader) GL.glAttachShader(self.shaderProgram, self.fragmentShader) GL.glLinkProgram(self.shaderProgram)
def initShader(self, vertex_shader_source_list, fragment_shader_source_list): # create program self.program = gl.glCreateProgram() # pylint: disable=E1111 #print('create program ',self.program) printOpenGLError() # vertex shader #print('compile vertex shader...') self.vs = gl.glCreateShader(gl.GL_VERTEX_SHADER) # pylint: disable=E1111 gl.glShaderSource(self.vs, vertex_shader_source_list) gl.glCompileShader(self.vs) if (gl.GL_TRUE != gl.glGetShaderiv(self.vs, gl.GL_COMPILE_STATUS)): err = gl.glGetShaderInfoLog(self.vs) raise Exception(err) gl.glAttachShader(self.program, self.vs) printOpenGLError() # fragment shader #print('compile fragment shader...') self.fs = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) # pylint: disable=E1111 gl.glShaderSource(self.fs, fragment_shader_source_list) gl.glCompileShader(self.fs) if (gl.GL_TRUE != gl.glGetShaderiv(self.fs, gl.GL_COMPILE_STATUS)): err = gl.glGetShaderInfoLog(self.fs) raise Exception(err) gl.glAttachShader(self.program, self.fs) printOpenGLError() #print('link...') gl.glLinkProgram(self.program) if (gl.GL_TRUE != gl.glGetProgramiv(self.program, gl.GL_LINK_STATUS)): err = gl.glGetShaderInfoLog(self.vs) raise Exception(err) printOpenGLError()
def link_shader_program(vertex_shader): """Create a shader program with from compiled shaders.""" program = gl.glCreateProgram() gl.glAttachShader(program, vertex_shader) gl.glLinkProgram(program) # check linking error result = gl.glGetProgramiv(program, gl.GL_LINK_STATUS) if not(result): raise RuntimeError(gl.glGetProgramInfoLog(program)) return program
def on_initialize(self, event): # Build & activate program self.program = gl.glCreateProgram() vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER) fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(vertex, vertex_code) gl.glShaderSource(fragment, fragment_code) gl.glCompileShader(vertex) gl.glCompileShader(fragment) gl.glAttachShader(self.program, vertex) gl.glAttachShader(self.program, fragment) gl.glLinkProgram(self.program) gl.glDetachShader(self.program, vertex) gl.glDetachShader(self.program, fragment) gl.glUseProgram(self.program) # Build vertex buffer n = 10000 self.data = np.zeros(n, dtype=[('lifetime', np.float32, 1), ('start', np.float32, 3), ('end', np.float32, 3)]) vbuffer = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbuffer) gl.glBufferData(gl.GL_ARRAY_BUFFER, self.data.nbytes, self.data, gl.GL_DYNAMIC_DRAW) # Bind buffer attributes stride = self.data.strides[0] offset = ctypes.c_void_p(0) loc = gl.glGetAttribLocation(self.program, "lifetime") gl.glEnableVertexAttribArray(loc) gl.glVertexAttribPointer(loc, 1, gl.GL_FLOAT, False, stride, offset) offset = ctypes.c_void_p(self.data.dtype["lifetime"].itemsize) loc = gl.glGetAttribLocation(self.program, "start") gl.glEnableVertexAttribArray(loc) gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, stride, offset) offset = ctypes.c_void_p(self.data.dtype["start"].itemsize) loc = gl.glGetAttribLocation(self.program, "end") gl.glEnableVertexAttribArray(loc) gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, stride, offset) # OpenGL initalization self.elapsed_time = 0 gl.glClearColor(0, 0, 0, 1) gl.glDisable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE) gl.glEnable(gl.GL_VERTEX_PROGRAM_POINT_SIZE) gl.glEnable(gl.GL_POINT_SPRITE) self.new_explosion() self.timer.start()
def _create_programs(programs_data): """Create the OpenGL programs.""" programs = {} for program_data in programs_data: program = gl.glCreateProgram() shaders = [] shaders_data = program_data['shaders'] for shader_data in shaders_data: shader = _create_shader_from_file(shader_data['filepath'], shader_data['type']) gl.glAttachShader(program, shader) shaders.append(shader) gl.glLinkProgram(program) if gl.glGetProgramiv(program, gl.GL_LINK_STATUS) != gl.GL_TRUE: raise RuntimeError(gl.glGetProgramInfoLog(program).decode()) for shader in shaders: gl.glDeleteShader(shader) program_name = program_data['name'] programs[program_name] = program struct = collections.namedtuple('_Programs', programs.keys()) return struct(**programs)
def initialise(self): def compileShader(handle, shader_source): gl.glShaderSource(handle, shader_source) gl.glCompileShader(handle) if not gl.glGetShaderiv(handle, gl.GL_COMPILE_STATUS): print(gl.glGetShaderInfoLog(handle)) self.program = gl.glCreateProgram() vertex_shader = gl.glCreateShader(gl.GL_VERTEX_SHADER) fragment_shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) compileShader(vertex_shader, self.vertex_str()) compileShader(fragment_shader, self.fragment_str()) gl.glAttachShader(self.program, vertex_shader) gl.glAttachShader(self.program, fragment_shader) gl.glLinkProgram(self.program) if not gl.glGetProgramiv(self.program, gl.GL_LINK_STATUS): print(gl.glGetProgramInfoLog(self.program)) gl.glDetachShader(self.program, vertex_shader) gl.glDetachShader(self.program, fragment_shader) # Request a buffer slot from GPU self.buffer = gl.glGenBuffers(1) self.VAO = gl.glGenVertexArrays(1)
def loadShaderProgram(self): # Request a program and shader slots from GPU program = gl.glCreateProgram() vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER) fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) # Set shaders source gl.glShaderSource(vertex, self.vertex_code) gl.glShaderSource(fragment, self.fragment_code) # Compile shaders gl.glCompileShader(vertex) gl.glCompileShader(fragment) print 'Vertex shader' print gl.glGetShaderInfoLog(vertex) print 'Fragment shader' print gl.glGetShaderInfoLog(fragment) # Attach shader objects to the program gl.glAttachShader(program, vertex) gl.glAttachShader(program, fragment) # Build program gl.glLinkProgram(program) # Get rid of shaders (no more needed) gl.glDetachShader(program, vertex) gl.glDetachShader(program, fragment) return program
def __init__( self, shaders, vertex_attributes=None, uniform_blocks=None, xfb_varyings=None, xfb_mode=GL.GL_INTERLEAVED_ATTRIBS, ): self.handle = GL.glCreateProgram() if self.handle == 0: raise RuntimeError("Failed to create OpenGL program.") for shader in shaders: GL.glAttachShader(self.handle, shader.handle) self.xfb_varyings = xfb_varyings if xfb_varyings is not None: varyings = (c.c_char_p * len(xfb_varyings))(*(v.name.encode() for v in self.xfb_varyings)) varyings = c.cast(varyings, c.POINTER(c.POINTER(c.c_char))) GL.glTransformFeedbackVaryings(self.handle, len(xfb_varyings), varyings, xfb_mode) self._xfb_mode = xfb_mode GL.glLinkProgram(self.handle) if GL.glGetProgramiv(self.handle, GL.GL_LINK_STATUS) == GL.GL_FALSE: log = GL.glGetProgramInfoLog(self.handle).decode() GL.glDeleteProgram(self.handle) raise RuntimeError("Failed to link program: \n\n{}".format(log)) self.uniform_blocks = {ub.name: ProgramUniformBlock.fromUniformBlock(self, ub) for ub in uniform_blocks or []} self.vertex_attributes = { v.name: ProgramVertexAttribute.fromVertexAttribute(self, v) for v in vertex_attributes or [] }
def getProgramForShadow() -> int: vertexShader = gl.glCreateShader(gl.GL_VERTEX_SHADER) with open("glsl\\shadow_vs.glsl") as file: gl.glShaderSource(vertexShader, file.read()) gl.glCompileShader(vertexShader) log_s = gl.glGetShaderInfoLog(vertexShader) if log_s: raise TypeError(log_s) fragmentShader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) with open("glsl\\shadow_fs.glsl") as file: gl.glShaderSource(fragmentShader, file.read()) gl.glCompileShader(fragmentShader) log_s = gl.glGetShaderInfoLog(fragmentShader) if log_s: raise TypeError(log_s) program = gl.glCreateProgram() gl.glAttachShader(program, vertexShader) gl.glAttachShader(program, fragmentShader) gl.glLinkProgram(program) print("Linking Log in Shadow:", gl.glGetProgramiv(program, gl.GL_LINK_STATUS)) gl.glDeleteShader(vertexShader) gl.glDeleteShader(fragmentShader) gl.glUseProgram(program) return program
def initialize_program(vertex_shader_code, fragment_shader_code): # compile shaders and store references vertex_shader_ref = OpenGLUtils.initialize_shader( vertex_shader_code, GL.GL_VERTEX_SHADER) fragment_shader_ref = OpenGLUtils.initialize_shader( fragment_shader_code, GL.GL_FRAGMENT_SHADER) # create empty program object program_ref = GL.glCreateProgram() # attach previously compiled shaders GL.glAttachShader(program_ref, vertex_shader_ref) GL.glAttachShader(program_ref, fragment_shader_ref) # link the shaders together GL.glLinkProgram(program_ref) # query if linking was successful link_sucess = GL.glGetProgramiv(program_ref, GL.GL_LINK_STATUS) if not link_sucess: # retrieve error message error_message = GL.glGetProgramInfoLog(program_ref) # free memory GL.glDeleteProgram(program_ref) # convert byte string to char string error_message = "\n" + error_message.decode("utf-8") # raise error raise Exception(error_message) return program_ref
def link(self): """Initialize the program for use.""" program = gl.glCreateProgram() # compile all the shaders for name, code in self.SHADER_TYPES.items(): source = getattr(self, name)() if source is not None: shader = gl.glCreateShader(code) gl.glShaderSource(shader, source) gl.glCompileShader(shader) success = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) if success != gl.GL_TRUE: raise RuntimeError(gl.glGetShaderInfoLog(shader)) gl.glAttachShader(program, shader) # link them into a program gl.glLinkProgram(program) success = gl.glGetProgramiv(program, gl.GL_LINK_STATUS) if success != gl.GL_TRUE: raise RuntimeError(gl.glGetProgramInfoLog(program)) self.program = program # initialize everything else as needed self.initialize_uniforms() self.initialize()
def setup_programs(gltf, shader_ids): """ Creates and links OpenGL programs for the input gltf dict, given the mapping from GLTF shader to OpenGL handle of the compiled vertex / fragment shaders. """ for program_name, program in gltf['programs'].items(): program_id = gl.glCreateProgram() gl.glAttachShader(program_id, shader_ids[program['vertexShader']]) gl.glAttachShader(program_id, shader_ids[program['fragmentShader']]) gl.glLinkProgram(program_id) gl.glDetachShader(program_id, shader_ids[program['vertexShader']]) gl.glDetachShader(program_id, shader_ids[program['fragmentShader']]) if not gl.glGetProgramiv(program_id, gl.GL_LINK_STATUS): raise Exception('failed to link program "%s"' % program_name) program['id'] = program_id program['attribute_locations'] = { attribute_name: gl.glGetAttribLocation(program_id, attribute_name) for attribute_name in program['attributes'] } if 'uniforms' in program: program['uniform_locations'] = { uniform_name: gl.glGetUniformLocation(program_id, uniform_name) for uniform_name in program['uniforms'] } else: program['uniform_locations'] = {} _logger.debug( 'linked program "%s"\n attribute locations: %s\n uniform locations: %s', program_name, program['attribute_locations'], program['uniform_locations'])
def AddStage(self, stage: int, filepath: str) -> None: if self.__compiled: Debug.Log("Tried to add shader stage to already compiled shader.", LogLevel.Warning) return try: with open(filepath, "r") as f: source = f.read() except FileNotFoundError as e: raise SpykeException( f"Cannot find shader file named '{e.filename}'") shader = GL.glCreateShader(stage) self.__stages.append(shader) GL.glShaderSource(shader, source) GL.glCompileShader(shader) infoLog = GL.glGetShaderInfoLog(shader) if len(infoLog) != 0: raise GraphicsException( f"Shader (file: '{filepath}') compilation error:\n{EnsureString(infoLog)}." ) GL.glAttachShader(self._id, shader)
def _build_shader(self, strings, shader_type): count = len(strings) if count < 1: return shader = gl.glCreateShader(shader_type) gl.glShaderSource(shader, strings) gl.glCompileShader(shader) status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) if not status: error = gl.glGetShaderInfoLog(shader) if shader_type == gl.GL_VERTEX_SHADER: err_line, err_desc = parse_shader_error(error) print_shader_error(err_desc, err_line, self.vertex_code) sys.exit() raise (ShaderException, 'Vertex compilation error') elif shader_type == gl.GL_FRAGMENT_SHADER: print error sys.exit() raise (ShaderException, 'Fragment compilation error') else: print error sys.exit() raise (ShaderException) else: gl.glAttachShader(self.handle, shader)
def setup(self, shader_sources): """Setup shaders.""" if not shader_sources: return shader_ids = {} for shader_type, source in shader_sources.items(): shader = GL.glCreateShader(shader_type) GL.glShaderSource(shader, source) GL.glCompileShader(shader) if GL.glGetShaderiv(shader, GL.GL_COMPILE_STATUS) != GL.GL_TRUE: raise RuntimeError(GL.glGetShaderInfoLog(shader).decode()) shader_ids[shader_type] = shader self.shader_sources = shader_sources self.shader_ids = shader_ids self.program_id = GL.glCreateProgram() for shader in shader_ids.values(): GL.glAttachShader(self.program_id, shader) GL.glLinkProgram(self.program_id) if GL.glGetProgramiv(self.program_id, GL.GL_LINK_STATUS) != GL.GL_TRUE: raise RuntimeError( GL.glGetProgramInfoLog(self.program_id).decode()) #GL.glUseProgram(self.program_id) return
def getProgram() -> int: vertexShader = gl.glCreateShader(gl.GL_VERTEX_SHADER) with open("glsl\\renderer_vs.glsl") as file: gl.glShaderSource(vertexShader, file.read()) gl.glCompileShader(vertexShader) log_s = gl.glGetShaderInfoLog(vertexShader) if log_s: raise TypeError(log_s) fragmentShader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) with open("glsl\\renderer_fs.glsl") as file: gl.glShaderSource(fragmentShader, file.read()) gl.glCompileShader(fragmentShader) log_s = gl.glGetShaderInfoLog(fragmentShader) if log_s: raise TypeError(log_s) program = gl.glCreateProgram() gl.glAttachShader(program, vertexShader) gl.glAttachShader(program, fragmentShader) gl.glLinkProgram(program) gl.glDeleteShader(vertexShader) gl.glDeleteShader(fragmentShader) gl.glUseProgram(program) return int( program )
def compile(cls, vertex_source, fragment_source): self = cls() self._vars = {} self._attrs = [] self._locs = {} self._vertices = [] self._shader = shaders.ShaderProgram(G.glCreateProgram()) vertex_shader = Shader.compile_shader( vertex_source, G.GL_VERTEX_SHADER) fragment_shader = Shader.compile_shader( fragment_source, G.GL_FRAGMENT_SHADER) G.glAttachShader(self._shader, vertex_shader) G.glAttachShader(self._shader, fragment_shader) all_source = '%s\n%s' % (vertex_source, fragment_source) for line in all_source.splitlines(): o = DECL.match(line.strip()) if o is not None: v = ShaderVar(o.group('name'), o.group('qual'), TYPES[o.group('type')]) self._vars[v.name] = v if v.qual == 'attribute': self._attrs.append(v) self.init_attribute_locs() G.glLinkProgram(self._shader) self._shader.check_validate() self._shader.check_linked() G.glDeleteShader(vertex_shader) G.glDeleteShader(fragment_shader) self.init_uniform_locs() return self
def shader(vs_src, frag_src): # build and compile shader program # vertex shader vertexShader = gl.glCreateShader(gl.GL_VERTEX_SHADER) gl.glShaderSource(vertexShader, vs_src) gl.glCompileShader(vertexShader) if not gl.glGetShaderiv(vertexShader, gl.GL_COMPILE_STATUS): infoLog = gl.glGetShaderInfoLog(vertexShader).decode() raise Exception("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" + infoLog) # fragment shader fragmentShader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(fragmentShader, frag_src) gl.glCompileShader(fragmentShader) if not gl.glGetShaderiv(fragmentShader, gl.GL_COMPILE_STATUS): infoLog = gl.glGetShaderInfoLog(fragmentShader).decode() raise Exception("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" + infoLog) # link shaders shaderProgram = gl.glCreateProgram() gl.glAttachShader(shaderProgram, vertexShader) gl.glAttachShader(shaderProgram, fragmentShader) gl.glLinkProgram(shaderProgram) if not gl.glGetProgramiv(shaderProgram, gl.GL_LINK_STATUS): infoLog = gl.glGetProgramInfoLog(shaderProgram).decode() raise Exception("ERROR::SHADER::PROGRAM::LINKING_FAILED\n" + infoLog) gl.glDeleteShader(vertexShader) gl.glDeleteShader(fragmentShader) return shaderProgram
def _link(self, shader, *shaderkeys): prog = gl.glCreateProgram() for name in shaderkeys: gl.glAttachShader(prog, shader[name]) if 'geometry' in shaderkeys: extgs4.glProgramParameteriEXT( prog, extgs4.GL_GEOMETRY_INPUT_TYPE_EXT, gl.GL_LINES_ADJACENCY) extgs4.glProgramParameteriEXT( prog, extgs4.GL_GEOMETRY_OUTPUT_TYPE_EXT, gl.GL_LINE_STRIP) extgs4.glProgramParameteriEXT( prog, extgs4.GL_GEOMETRY_VERTICES_OUT_EXT, 200) gl.glLinkProgram(prog) log.info( 'linked program %s: %s', shaderkeys, gl.glGetProgramInfoLog(prog) or 'success') return prog
def loadShaders(strVS, strFS): """load vertex and fragment shaders from strings""" # compile vertex shader shaderV = compileShader([strVS], gl.GL_VERTEX_SHADER) # compiler fragment shader shaderF = compileShader([strFS], gl.GL_FRAGMENT_SHADER) # create the program object program = gl.glCreateProgram() if not program: raise RunTimeError('glCreateProgram faled!') # attach shaders gl.glAttachShader(program, shaderV) gl.glAttachShader(program, shaderF) # Link the program gl.glLinkProgram(program) # Check the link status linked = gl.glGetProgramiv(program, gl.GL_LINK_STATUS) if not linked: infoLen = gl.glGetProgramiv(program, gl.GL_INFO_LOG_LENGTH) infoLog = "" if infoLen > 1: infoLog = gl.glGetProgramInfoLog(program, infoLen, None); gl.glDeleteProgram(program) raise RunTimeError("Error linking program:\n%s\n", infoLog); return program
def __init__(self, vertex, fragment): ''' :vertex String containing shader source code for the vertex shader :fragment String containing shader source code for the fragment shader ''' if False: # method 1 self.program_id = GL.glCreateProgram() vs_id = self.add_shader(vertex, GL.GL_VERTEX_SHADER) frag_id = self.add_shader(fragment, GL.GL_FRAGMENT_SHADER) GL.glAttachShader(self.program_id, vs_id) GL.glAttachShader(self.program_id, frag_id) GL.glLinkProgram(self.program_id) if GL.glGetProgramiv(self.program_id, GL.GL_LINK_STATUS) != GL.GL_TRUE: info = GL.glGetProgramInfoLog(self.program_id) GL.glDeleteProgram(self.program_id) GL.glDeleteShader(vs_id) GL.glDeleteShader(frag_id) raise RuntimeError('Error linking program: %s' % (info)) GL.glDeleteShader(vs_id) GL.glDeleteShader(frag_id) else: # method 2 vertex_shader = shaders.compileShader(vertex, GL.GL_VERTEX_SHADER) fragment_shader = shaders.compileShader(fragment, GL.GL_FRAGMENT_SHADER) self.program_id = shaders.compileProgram(vertex_shader, fragment_shader)
def getProgram() -> int: with open("shader_source\\2nd_vs.txt") as file: vertexShader = shaders.compileShader(file.read(), gl.GL_VERTEX_SHADER) log_s = gl.glGetShaderInfoLog(vertexShader).decode() if log_s: raise TypeError(log_s) with open("shader_source\\2nd_fs.txt") as file: fragmentShader = shaders.compileShader(file.read(), gl.GL_FRAGMENT_SHADER) log_s = gl.glGetShaderInfoLog(fragmentShader).decode() if log_s: raise TypeError(log_s) program = gl.glCreateProgram() gl.glAttachShader(program, vertexShader) gl.glAttachShader(program, fragmentShader) gl.glLinkProgram(program) print("Linking Log:", gl.glGetProgramiv(program, gl.GL_LINK_STATUS)) gl.glDeleteShader(vertexShader) gl.glDeleteShader(fragmentShader) gl.glUseProgram(program) return program
def program(*shaders): p = GL.glCreateProgram() for s in shaders: GL.glAttachShader(p, s) GL.glBindFragDataLocation(p, 0, 'color') GL.glLinkProgram(p) return check_shader_or_program_status(p)
def __init__(self, vertex_code, fragment_code): super().__init__(gl.glCreateProgram()) vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER) fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(vertex, vertex_code) gl.glShaderSource(fragment, fragment_code) gl.glCompileShader(vertex) if not gl.glGetShaderiv(vertex, gl.GL_COMPILE_STATUS): error = gl.glGetShaderInfoLog(vertex).decode() print(error) raise RuntimeError('Vertex shader compilation error') gl.glCompileShader(fragment) if not gl.glGetShaderiv(fragment, gl.GL_COMPILE_STATUS): error = gl.glGetShaderInfoLog(fragment).decode() print(error) raise RuntimeError('Fragment shader compilation error') # Link individual shaders to create a shader program. gl.glAttachShader(self._handle, vertex) gl.glAttachShader(self._handle, fragment) gl.glLinkProgram(self._handle) if not gl.glGetProgramiv(self._handle, gl.GL_LINK_STATUS): print(gl.glGetProgramInfoLog(self._handle)) raise RuntimeError('Linking error') # Free shader source and unlinked object code. gl.glDetachShader(self._handle, vertex) gl.glDetachShader(self._handle, fragment) gl.glDeleteShader(vertex) gl.glDeleteShader(fragment)
def getProgram(vertexShaderDir_s:str, fragmentShaderDir_s:str) -> int: vertexShader = gl.glCreateShader(gl.GL_VERTEX_SHADER) with open(vertexShaderDir_s) as file: gl.glShaderSource(vertexShader, file.read()) gl.glCompileShader(vertexShader) log_s = gl.glGetShaderInfoLog(vertexShader) if log_s: raise CompileErrorGLSL(log_s) fragmentShader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) with open(fragmentShaderDir_s) as file: gl.glShaderSource(fragmentShader, file.read()) gl.glCompileShader(fragmentShader) log_s = gl.glGetShaderInfoLog(fragmentShader) if log_s: raise CompileErrorGLSL(log_s) program = gl.glCreateProgram() gl.glAttachShader(program, vertexShader) gl.glAttachShader(program, fragmentShader) gl.glLinkProgram(program) gl.glDeleteShader(vertexShader) gl.glDeleteShader(fragmentShader) gl.glUseProgram(program) return int(program)
def setup(self, shader_sources): """Setup shaders.""" if not shader_sources: return shader_ids = {} for shader_type, source in shader_sources.items(): shader = GL.glCreateShader(shader_type) GL.glShaderSource(shader, source) GL.glCompileShader(shader) if GL.glGetShaderiv(shader, GL.GL_COMPILE_STATUS) != GL.GL_TRUE: raise RuntimeError(GL.glGetShaderInfoLog(shader).decode()) shader_ids[shader_type] = shader self.shader_sources = shader_sources self.shader_ids = shader_ids self.program_id = GL.glCreateProgram() for shader in shader_ids.values(): GL.glAttachShader(self.program_id, shader) GL.glLinkProgram(self.program_id) if GL.glGetProgramiv(self.program_id, GL.GL_LINK_STATUS) != GL.GL_TRUE: raise RuntimeError(GL.glGetProgramInfoLog(self.program_id).decode()) GL.glUseProgram(self.program_id)
def load_shaders(vertex_file_path, fragment_file_path): vertex_shader_id = GL.glCreateShader(GL.GL_VERTEX_SHADER) fragment_shader_id = GL.glCreateShader(GL.GL_FRAGMENT_SHADER) vertex_shader_file = open(vertex_file_path, 'r') vertex_shader_code = vertex_shader_file.read() vertex_shader_file.close() fragment_shader_file = open(fragment_file_path, 'r') fragment_shader_code = fragment_shader_file.read() fragment_shader_file.close() GL.glShaderSource(vertex_shader_id, vertex_shader_code) GL.glCompileShader(vertex_shader_id) if not GL.glGetShaderiv(vertex_shader_id, GL.GL_COMPILE_STATUS): raise Exception('failed to compile shader "{0}":\n' '{1}'.format(vertex_shader_id, GL.glGetShaderInfoLog(vertex_shader_id).decode())) GL.glShaderSource(fragment_shader_id, fragment_shader_code) GL.glCompileShader(fragment_shader_id) if not GL.glGetShaderiv(fragment_shader_id, GL.GL_COMPILE_STATUS): raise Exception('failed to compile shader "{0}":\n' '{1}'.format(fragment_shader_id, GL.glGetShaderInfoLog(fragment_shader_id).decode())) program_id = GL.glCreateProgram() GL.glAttachShader(program_id, vertex_shader_id) GL.glAttachShader(program_id, fragment_shader_id) GL.glLinkProgram(program_id) if not GL.glGetProgramiv(program_id, GL.GL_LINK_STATUS): raise Exception('failed to link program:\n{}'.format(GL.glGetProgramInfoLog(program_id).decode())) GL.glDeleteShader(vertex_shader_id) GL.glDeleteShader(fragment_shader_id) return program_id
def _getProgram() -> int: with open("shader_source\\2nd_vs_box.glsl") as file: vertexShader = shaders.compileShader(file.read(), gl.GL_VERTEX_SHADER) log = glf.get_shader_log(vertexShader) if log: raise TypeError(log) with open("shader_source\\2nd_fs_box.glsl") as file: fragmentShader = shaders.compileShader(file.read(), gl.GL_FRAGMENT_SHADER) log = glf.get_shader_log(fragmentShader) if log: raise TypeError(log) program = gl.glCreateProgram() gl.glAttachShader(program, vertexShader) gl.glAttachShader(program, fragmentShader) gl.glLinkProgram(program) print("Linking Log in Box:", gl.glGetProgramiv(program, gl.GL_LINK_STATUS)) gl.glDeleteShader(vertexShader) gl.glDeleteShader(fragmentShader) gl.glUseProgram(program) return program
def createShaderGL(): global program # create program program = GL.glCreateProgram() #print('create program') printOpenGLError() # vertex shader #print('compile vertex shader...') vs = GL.glCreateShader(GL.GL_VERTEX_SHADER) GL.glShaderSource(vs, [_vertex_shader_source]) GL.glCompileShader(vs) GL.glAttachShader(program, vs) printOpenGLError() # fragment shader #print('compile fragment shader...') fs = GL.glCreateShader(GL.GL_FRAGMENT_SHADER) GL.glShaderSource(fs, [_fragment_shader_source]) GL.glCompileShader(fs) GL.glAttachShader(program, fs) printOpenGLError() #print('link...') GL.glLinkProgram(program) printOpenGLError()
def init(self): shaders = { gl.GL_VERTEX_SHADER: self._vertSource, gl.GL_FRAGMENT_SHADER: self._fragSource } self.program_id = gl.glCreateProgram() shader_ids = [] for shader_type, shader_src in shaders.items(): shader_id = gl.glCreateShader(shader_type) gl.glShaderSource(shader_id, shader_src) gl.glCompileShader(shader_id) # check if compilation was successful result = gl.glGetShaderiv(shader_id, gl.GL_COMPILE_STATUS) info_log_len = gl.glGetShaderiv(shader_id, gl.GL_INFO_LOG_LENGTH) if info_log_len: logmsg = gl.glGetShaderInfoLog(shader_id) print("ERROR: ", logmsg) sys.exit(10) gl.glAttachShader(self.program_id, shader_id) shader_ids.append(shader_id) gl.glLinkProgram(self.program_id) # check if linking was successful result = gl.glGetProgramiv(self.program_id, gl.GL_LINK_STATUS) info_log_len = gl.glGetProgramiv(self.program_id, gl.GL_INFO_LOG_LENGTH) if info_log_len: logmsg = gl.glGetProgramInfoLog(self.program_id) logging.error(logmsg) sys.exit(11)
def _build_shader(self, strings, stype): ''' Actual building of the shader ''' count = len(strings) # if we have no source code, ignore this shader if count < 1: return # create the shader handle shader = gl.glCreateShader(stype) # Upload shader code gl.glShaderSource(shader, strings) # compile the shader gl.glCompileShader(shader) # retrieve the compile status status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) # if compilation failed, print the log if not status: # display the log print gl.glGetShaderInfoLog(shader) else: # all is well, so attach the shader to the program gl.glAttachShader(self.handle, shader)
def create(cls, *shaders): with contextlib.ExitStack() as ctx_mgr: # Create the shader program obj = int(gl.glCreateProgram()) if obj == 0: raise OpenGLError("Failed to create a shader program.") ctx_mgr.callback(cls._delete_program, obj) # Attach the shaders for shader in shaders: gl.glAttachShader(obj, shader.obj) # Link the shader program gl.glLinkProgram(obj) # Detach the shaders for shader in shaders: gl.glDetachShader(obj, shader.obj) # Determine the link status if not gl.glGetProgramiv(obj, gl.GL_LINK_STATUS): log_string = gl.glGetProgramInfoLog(obj) raise OpenGLError(log_string.decode("utf-8")) log = logging.getLogger("{}.{}".format(__name__, cls.__name__)) ctx_exit = ctx_mgr.pop_all() return cls(obj, log, ctx_exit)
def __init__(self, vertexShaderStr, fragmentShaderStr): ## Constructor # Compile and attach the shaders. # @param self # @param vertexShaderStr String either containing the filepath to the shader # @param fragmentShaderStr String either containing the filepath to the shader # Compile the shaders vertShader = self._compileShader(vertexShaderStr, GL.GL_VERTEX_SHADER) fragShader = self._compileShader(fragmentShaderStr, GL.GL_FRAGMENT_SHADER) # Attach self.glId = GL.glCreateProgram() GL.glAttachShader(self.glId, vertShader) GL.glAttachShader(self.glId, fragShader) # Link GL.glLinkProgram(self.glId) # Release GL.glDeleteShader(vertShader) GL.glDeleteShader(fragShader) # Check status = GL.glGetProgramiv(self.glId, GL.GL_LINK_STATUS) if not status: log = GL.glGetProgramInfoLog(self.glId).decode('ascii') GL.glDeleteProgram(self.glId) self.glId = None strError = "Shader - Shader program initialization failed : \n" + str( log) raise Exception(strError)
def _build_shader(self, strings, shader_type): ''' Actual building of the shader ''' count = len(strings) # if we have no source code, ignore this shader if count < 1: return # create the shader handle shader = gl.glCreateShader(shader_type) # Upload shader code gl.glShaderSource(shader, strings) # compile the shader gl.glCompileShader(shader) # retrieve the compile status status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) # if compilation failed, raise exception and print the log if not status: if shader_type == gl.GL_VERTEX_SHADER: raise ShaderException, \ 'Vertex compilation: ' + gl.glGetShaderInfoLog(shader) elif shader_type == gl.GL_FRAGMENT_SHADER: raise ShaderException, \ 'Fragment compilation:' + gl.glGetShaderInfoLog(shader) else: raise ShaderException, \ gl.glGetShaderInfoLog(shader) else: # all is well, so attach the shader to the program gl.glAttachShader(self.handle, shader)
def LoadShaders(vertex_file_path, fragment_file_path): vertex_shader = gl.glCreateShader(gl.GL_VERTEX_SHADER) fragment_shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) with open(vertex_file_path, "r") as f: vertex_shader_code = f.read() with open(fragment_file_path, "r") as f: fragment_shader_code = f.read() gl.glShaderSource(vertex_shader, vertex_shader_code) gl.glCompileShader(vertex_shader) result = gl.glGetShaderiv(vertex_shader, gl.GL_COMPILE_STATUS) info_log = gl.glGetShaderInfoLog(vertex_shader) print result, info_log gl.glShaderSource(fragment_shader, fragment_shader_code) gl.glCompileShader(fragment_shader) result = gl.glGetShaderiv(fragment_shader, gl.GL_COMPILE_STATUS) info_log = gl.glGetShaderInfoLog(fragment_shader) print result, info_log program = gl.glCreateProgram() gl.glAttachShader(program, vertex_shader) gl.glAttachShader(program, fragment_shader) gl.glLinkProgram(program) result = gl.glGetProgramiv(program, gl.GL_LINK_STATUS) info_log = gl.glGetProgramInfoLog(program) print result, info_log gl.glDeleteShader(vertex_shader) gl.glDeleteShader(fragment_shader) return program
def _build_shader(self, strings, stype): ''' Actual building of the shader ''' count = len(strings) # if we have no source code, ignore this shader if count < 1: return # create the shader handle shader = gl.glCreateShader(stype) # Upload shader code gl.glShaderSource(shader, strings) # compile the shader gl.glCompileShader(shader) # retrieve the compile status status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) # if compilation failed, print the log if not status: # display the log print (gl.glGetShaderInfoLog(shader)) else: # all is well, so attach the shader to the program gl.glAttachShader(self.handle, shader)
def main(): glfw.init() glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3) glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3) glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE) window = glfw.create_window(WIN_WIDTH, WIN_HEIGHT, "Hello OpenGL", None, None) if window == 0: print("failed to create window") glfw.glfwTerminate() glfw.make_context_current(window) glfw.set_framebuffer_size_callback(window, framebuffer_size_callback) vertexShader = gl.glCreateShader(gl.GL_VERTEX_SHADER) gl.glShaderSource(vertexShader, vertexShaderSource) gl.glCompileShader(vertexShader) fragmentShader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(fragmentShader, fragmentShaderSource) gl.glCompileShader(fragmentShader) shaderProgram = gl.glCreateProgram() gl.glAttachShader(shaderProgram, vertexShader) gl.glAttachShader(shaderProgram, fragmentShader) gl.glLinkProgram(shaderProgram) gl.glDeleteShader(vertexShader) gl.glDeleteShader(fragmentShader) VAO = gl.glGenVertexArrays(1) VBO = gl.glGenBuffers(1) gl.glBindVertexArray(VAO) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, VBO) gl.glBufferData(gl.GL_ARRAY_BUFFER, sys.getsizeof(vertices), vertices, gl.GL_STATIC_DRAW) gl.glVertexAttribPointer(gl.glGetAttribLocation(shaderProgram, 'aPos'), 3, gl.GL_FLOAT, gl.GL_FALSE, 12, None) gl.glEnableVertexAttribArray(0) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0) gl.glBindVertexArray(0) while not glfw.window_should_close(window): processInput(window) gl.glClearColor(0.2, 0.3, 0.3, 1.0) gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glUseProgram(shaderProgram) gl.glBindVertexArray(VAO) gl.glDrawArrays(gl.GL_TRIANGLES, 0, 3) gl.glBindVertexArray(0) glfw.swap_buffers(window) glfw.poll_events() glfw.terminate()
def __init__(self, geos, vertex_code, fragment_code): self.time = time.time() num_vertices = np.sum([len(g) for g in geos]) data = np.zeros(num_vertices, [("position", np.float32, 2), ("color", np.float32, 4)]) cs = [] vs = [] for g in geos: for c in g.colors: cs.append(c) for v in g.vertices: vs.append(v) data["color"] = cs data["position"] = vs data["position"] = 0.5 * data["position"] self.data = data glut.glutInit() glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA) glut.glutCreateWindow("Hello world!") glut.glutReshapeWindow(512,512) glut.glutReshapeFunc(self.reshape) glut.glutDisplayFunc(self.display) glut.glutIdleFunc(self.idle) glut.glutKeyboardFunc(self.keyboard) glut.glutMouseFunc(self.mouse) program = gl.glCreateProgram() vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER) fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(vertex, vertex_code) gl.glShaderSource(fragment, fragment_code) gl.glCompileShader(vertex) gl.glCompileShader(fragment) gl.glAttachShader(program, vertex) gl.glAttachShader(program, fragment) gl.glLinkProgram(program) gl.glDetachShader(program, vertex) gl.glDetachShader(program, fragment) gl.glUseProgram(program) self.buffer = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer) gl.glBufferData(gl.GL_ARRAY_BUFFER, self.data.nbytes, self.data, gl.GL_DYNAMIC_DRAW) stride = self.data.strides[0] offset = ctypes.c_void_p(0) loc = gl.glGetAttribLocation(program, "position") gl.glEnableVertexAttribArray(loc) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer) gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, stride, offset) offset = ctypes.c_void_p(self.data.dtype["position"].itemsize) loc = gl.glGetAttribLocation(program, "color") gl.glEnableVertexAttribArray(loc) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer) gl.glVertexAttribPointer(loc, 4, gl.GL_FLOAT, False, stride, offset) loc = gl.glGetUniformLocation(program, "scale") gl.glUniform1f(loc, 1.0)
def attach_shaders(self): shade_list = [] shade_list.append(self.compile(GL.GL_VERTEX_SHADER,VERT)) shade_list.append(self.compile(GL.GL_FRAGMENT_SHADER,FRAG)) for shade in shade_list: GL.glAttachShader(self.shader,shade) self.link() for shade in shade_list: GL.glDetachShader(self.shader,shade) GL.glDeleteShader(shade)
def _create(self): """ Build (link) the program and checks everything's ok. A GL context must be available to be able to build (link) """ # Check if we have something to link if not self._verts: raise ValueError("No vertex shader has been given") if not self._frags: raise ValueError("No fragment shader has been given") # Check if program has been created if self._handle <= 0: self._handle = gl.glCreateProgram() if not self._handle: raise ShaderException("Cannot create program object") # Detach any attached shaders attached = gl.glGetAttachedShaders(self._handle) for handle in attached: gl.glDetachShader(self._handle, handle) # Attach vertex and fragment shaders for shader in self._verts: shader.activate() gl.glAttachShader(self._handle, shader.handle) for shader in self._frags: shader.activate() gl.glAttachShader(self._handle, shader.handle) log("GPU: Creating program") # Link the program gl.glLinkProgram(self._handle) if not gl.glGetProgramiv(self._handle, gl.GL_LINK_STATUS): print(gl.glGetProgramInfoLog(self._handle)) raise ShaderException('Linking error') # Activate uniforms active_uniforms = [name for (name,gtype) in self.active_uniforms] for uniform in self._uniforms.values(): if uniform.name in active_uniforms: uniform.active = True else: uniform.active = False # Activate attributes active_attributes = [name for (name,gtype) in self.active_attributes] for attribute in self._attributes.values(): if attribute.name in active_attributes: attribute.active = True else: attribute.active = False
def compileProgram(*shaders): program = gl.glCreateProgram() for shader in shaders: gl.glAttachShader(program, shader) gl.glLinkProgram(program) for shader in shaders: gl.glDeleteShader(shader) return program
def attach_shaders(self,vert_file,frag_file): vert,frag = self.load_shader_files(vert_file,frag_file) shade_list = [] shade_list.append(self.compile(GL.GL_VERTEX_SHADER,vert)) shade_list.append(self.compile(GL.GL_FRAGMENT_SHADER,frag)) for shade in shade_list: GL.glAttachShader(self.shader,shade) self.link() for shade in shade_list: GL.glDetachShader(self.shader,shade) GL.glDeleteShader(shade)
def link_shader(vertex_shader, fragment_shader): """Create a shader program with from compiled shaders.""" # from http://cyrille.rossant.net/shaders-opengl/ program = gl.glCreateProgram() gl.glAttachShader(program, vertex_shader) gl.glAttachShader(program, fragment_shader) gl.glLinkProgram(program) # check linking error result = gl.glGetProgramiv(program, gl.GL_LINK_STATUS) if not(result): raise RuntimeError(gl.glGetProgramInfoLog(program)) return program
def _add_program(self, text, type): shader = gl.glCreateShader(type) if shader == 0: raise ShaderCreateError("Could not find valid memory location when adding shader") gl.glShaderSource(shader, text) gl.glCompileShader(shader) if gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) == 0: raise ShaderCreateError(gl.glGetShaderInfoLog(shader)) gl.glAttachShader(self.program, shader)
def __init__ (self, *shaders): self.testShaders = shaders self.programGl = gl.glCreateProgram () for shader in shaders: gl.glAttachShader (self.programGl, shader.shaderGl) gl.glLinkProgram (self.programGl) for shader in shaders: gl.glDetachShader (self.programGl, shader.shaderGl) gl.glUseProgram (self.programGl)
def initializeGL( self ) : # Default background color gl.glClearColor( 1, 1, 1, 1 ) # Enable depth test gl.glEnable( gl.GL_DEPTH_TEST ) # Enable face culling gl.glEnable( gl.GL_CULL_FACE ) # Enable blending function gl.glEnable( gl.GL_BLEND ) gl.glBlendFunc( gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA ) # Enable multisampling (antialiasing) gl.glEnable( gl.GL_MULTISAMPLE ) # Change point size gl.glPointSize( 5.0 ) # Compile the shaders vertex_shader = gl.glCreateShader( gl.GL_VERTEX_SHADER ) gl.glShaderSource( vertex_shader, self.vertex_shader_source ) gl.glCompileShader( vertex_shader ) fragment_shader = gl.glCreateShader( gl.GL_FRAGMENT_SHADER ) gl.glShaderSource( fragment_shader, self.fragment_shader_source ) gl.glCompileShader( fragment_shader ) # Load the shaders self.shader = gl.glCreateProgram() gl.glAttachShader( self.shader, vertex_shader ) gl.glAttachShader( self.shader, fragment_shader ) gl.glLinkProgram( self.shader ) gl.glUseProgram( self.shader ) gl.glDetachShader( self.shader, vertex_shader ) gl.glDetachShader( self.shader, fragment_shader ) gl.glDeleteShader( vertex_shader ) gl.glDeleteShader( fragment_shader ) # Initialise the projection transformation matrix self.SetProjectionMatrix() # Initialise Model-View transformation matrix self.modelview_matrix = np.identity( 4, dtype=np.float32 ) # Position the scene (camera) self.modelview_matrix[3,2] = -30.0 # Initialise viewing parameters self.point_cloud_loaded = False # Vertex array object self.vertex_array_id = gl.glGenVertexArrays( 1 ) gl.glBindVertexArray( self.vertex_array_id ) # Vertex buffer object self.vertex_buffer_id = gl.glGenBuffers( 1 ) # gl.glBindBuffer( gl.GL_ARRAY_BUFFER, self.vertex_buffer_id ) # gl.glBufferData( gl.GL_ARRAY_BUFFER, 921600, None, gl.GL_STATIC_DRAW ) # gl.glEnableVertexAttribArray( 0 ) # gl.glVertexAttribPointer( 0, 3, gl.GL_FLOAT, gl.GL_FALSE, 0, None ) # Color buffer object self.color_buffer_id = gl.glGenBuffers( 1 )
def link(self, *shader_objs): prog = gl.glCreateProgram() for shader in shader_objs: gl.glAttachShader(prog, shader) gl.glLinkProgram(prog) link_status = gl.glGetProgramiv(prog, gl.GL_LINK_STATUS) if link_status == gl.GL_FALSE: raise RuntimeError( """Link failure (%s): %s"""%( link_status, gl.glGetProgramInfoLog(prog), )) for shader in shader_objs: gl.glDeleteShader(shader) return prog
def build_program(vertex_code, fragment_code): program = gl.glCreateProgram() vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER) gl.glShaderSource(vertex, vertex_code) gl.glCompileShader(vertex) gl.glAttachShader(program, vertex) fragment = None if fragment_code is not None: fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(fragment, fragment_code) gl.glCompileShader(fragment) gl.glAttachShader(program, fragment) gl.glLinkProgram(program) success = gl.glGetProgramiv(program, gl.GL_LINK_STATUS) if success == gl.GL_FALSE: log = glGetProgramInfoLog(program) print "Linking failed!\nLog:\n'" + log + "'" raise gl.glDetachShader(program, vertex) if fragment is not None: gl.glDetachShader(program, fragment) return program
def on_initialize(self): gl.glClearColor(0,0,0,1); # Enable blending gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE) # Note: normal GL requires these lines, ES 2.0 does not from OpenGL import GL gl.glEnable(GL.GL_VERTEX_PROGRAM_POINT_SIZE) gl.glEnable(GL.GL_POINT_SPRITE) # Create shader program self._prog_handle = gl.glCreateProgram() # Create vertex shader shader = gl.glCreateShader(gl.GL_VERTEX_SHADER) gl.glShaderSource(shader, VERT_CODE) gl.glCompileShader(shader) status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) if not status: # We could show more useful info here, but that takes a few lines raise RuntimeError('Vertex shader did not compile.') else: gl.glAttachShader(self._prog_handle, shader) # Create fragment shader shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(shader, FRAG_CODE) gl.glCompileShader(shader) status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) if not status: # We could show more useful info here, but that takes a few lines raise RuntimeError('Fragment shader did not compile.') else: gl.glAttachShader(self._prog_handle, shader) # Link gl.glLinkProgram(self._prog_handle) status = gl.glGetProgramiv(self._prog_handle, gl.GL_LINK_STATUS) if not status: # We could show more useful info here, but that takes a few lines raise RuntimeError('Program did not link.') # Create texture self._tex_handle = gl.glGenTextures(1) gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1) gl.glBindTexture(gl.GL_TEXTURE_2D, self._tex_handle) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_LUMINANCE, im1.shape[1], im1.shape[0], 0, gl.GL_LUMINANCE, gl.GL_FLOAT, im1.astype(np.float32)) gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) # Create vertex buffer self._vbo_handle = gl.glGenBuffers(1)