def setupFBOandTextures(self): self.framebufferA0 = (gl.GLuint * args["outResolution"])() self.A0_tex = gl.GLuint(0) self.A1_tex = gl.GLuint(0) self.draw_buffersA0 = (gl.GLenum * args["outResolution"])(gl.GL_COLOR_ATTACHMENT0) gl.glGenFramebuffers(args["outResolution"], self.framebufferA0) gl.glGenTextures(1, ctypes.byref(self.A0_tex)) gl.glGenTextures(1, ctypes.byref(self.A1_tex)) #create textures #A gl.glActiveTexture(gl.GL_TEXTURE0) gl.glBindTexture(gl.GL_TEXTURE_2D, self.A0_tex) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, self.dimx, self.dimy, 0, gl.GL_RGBA, gl.GL_FLOAT, self.Ap) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glActiveTexture(gl.GL_TEXTURE1) gl.glBindTexture(gl.GL_TEXTURE_3D, self.A1_tex) gl.glTexImage3D(gl.GL_TEXTURE_3D, 0, gl.GL_RED, args["outResolution"], args["outResolution"], args["outResolution"], 0, gl.GL_RED, gl.GL_FLOAT, 0) gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) #A for i in range(args["outResolution"]): gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.framebufferA0[i]) gl.glFramebufferTexture3D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_3D, self.A1_tex, 0, i) assert(gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE)
def __init__(self): self.seed() self.contactListener_keepref = FrictionDetector(self) self.world = Box2D.b2World( (0, 0), contactListener=self.contactListener_keepref) self.viewer = None self.invisible_state_window = None self.invisible_video_window = None self.road = None self.car = None self.reward = 0.0 self.prev_reward = 0.0 self.action_space = spaces.Box(np.array([-1, 0, 0]), np.array([+1, +1, +1])) # steer, gas, brake self.observation_space = spaces.Box(low=0, high=255, shape=(STATE_H, STATE_W, 3), dtype=np.uint8) #VBO stuff self.vertex_vbo_id = gl.GLuint() self.color_vbo_id = gl.GLuint() gl.glGenBuffers(1, self.vertex_vbo_id) gl.glGenBuffers(1, self.color_vbo_id) self.initialized = 0
def build_buffer(): buffer = gl.GLuint(0) gl.glGenFramebuffers(1, ctypes.byref(buffer)) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, buffer) texture = gl.GLuint(0) gl.glGenTextures(1, ctypes.byref(texture)) gl.glEnable(gl.GL_TEXTURE_2D) gl.glBindTexture(gl.GL_TEXTURE_2D, texture) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, BUF_WIDTH, BUF_HEIGHT, 0, gl.GL_RGBA, gl.GL_FLOAT, None) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, texture, 0) if (gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) != gl.GL_FRAMEBUFFER_COMPLETE): raise RuntimeError('Framebuffer incomplete !') gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) gl.glBindTexture(gl.GL_TEXTURE_2D, 0) gl.glDisable(gl.GL_TEXTURE_2D) return buffer, texture
def __init__(self, **args): super(Window, self).__init__(**args) self.vao = gl.GLuint(0) gl.glGenVertexArrays(1, ctypes.byref(self.vao)) gl.glBindVertexArray(self.vao) self.vbo = gl.GLuint(0) gl.glGenBuffers(1, ctypes.byref(self.vbo)) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.vbo) gl.glBufferData(gl.GL_ARRAY_BUFFER, ctypes.sizeof(gl.GLfloat * len(vertex_positions)), (gl.GLfloat * len(vertex_positions))(*vertex_positions), gl.GL_STATIC_DRAW) gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 0, 0) gl.glEnableVertexAttribArray(0) self.ibo = gl.GLuint(0) gl.glGenBuffers(1, self.ibo) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self.ibo) gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, ctypes.sizeof(gl.GLuint * len(indices)), (gl.GLuint * len(indices))(*indices), gl.GL_STATIC_DRAW)
def __init__(self, width, height, window, num_color_attachments=1, mapping_mode=None, provide_depth=False, provide_stencil=False): """"Create an arbitrary layer framebuffer, I'll add stencil and depthbuffers if I ever package this for resuse, in pyweek, those args are pretty much placeholders""" if mapping_mode is None: mapping_mode = gl.GL_NEAREST assert not provide_stencil, 'stencil buffer not implemented' assert not provide_depth, 'depth buffer not implemented' self.window = window self.width = width self.height = height self.bufferId = gl.GLuint(0) self.textureIds = [] self.buffer_args = [] #create the vram objects? gl.glGenFramebuffers(1, rf(self.bufferId)) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.bufferId) for bufferIndex in range(num_color_attachments): newTex = gl.GLuint(0) gl.glGenTextures(1, rf(newTex)) self.textureIds.append(newTex) gl.glBindTexture(gl.GL_TEXTURE_2D, newTex) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, width, height, 0, gl.GL_RGB, gl.GL_UNSIGNED_INT, 0) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, mapping_mode) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, mapping_mode) gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0 + bufferIndex, gl.GL_TEXTURE_2D, newTex, 0) self.buffer_args.append(gl.GL_COLOR_ATTACHMENT0 + bufferIndex) #assign one of the vram objects to the framebuffer cache? if provide_depth: self.buffer_args.append(gl.GL_DEPTH_ATTACHMENT) if provide_stencil: self.buffer_args.append(gl.GL_STENCIL_ATTACHMENT) self.buffers_provided = (gl.GLenum * len(self.buffer_args))(*self.buffer_args) gl.glDrawBuffers(len(self.buffer_args), self.buffers_provided) self.textures = [ Texture(self.width, self.height, gl.GL_TEXTURE_2D, texId.value) for texId in self.textureIds ] assert gl.glCheckFramebufferStatus( gl.GL_FRAMEBUFFER ) == gl.GL_FRAMEBUFFER_COMPLETE, "I don't know why this happened, but at least I can find out"
def _create_device_objects(self): # save state last_texture = gl.GLint() gl.glGetIntegerv(gl.GL_TEXTURE_BINDING_2D, byref(last_texture)) last_array_buffer = gl.GLint() gl.glGetIntegerv(gl.GL_ARRAY_BUFFER_BINDING, byref(last_array_buffer)) last_vertex_array = gl.GLint() gl.glGetIntegerv(gl.GL_VERTEX_ARRAY_BINDING, byref(last_vertex_array)) self._shader_handle = gl.glCreateProgram() # note: no need to store shader parts handles after linking vertex_shader = gl.glCreateShader(gl.GL_VERTEX_SHADER) fragment_shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(vertex_shader, 1, make_string_buffer(self.VERTEX_SHADER_SRC), None) gl.glShaderSource(fragment_shader, 1, make_string_buffer(self.FRAGMENT_SHADER_SRC), None) gl.glCompileShader(vertex_shader) gl.glCompileShader(fragment_shader) gl.glAttachShader(self._shader_handle, vertex_shader) gl.glAttachShader(self._shader_handle, fragment_shader) gl.glLinkProgram(self._shader_handle) # note: after linking shaders can be removed gl.glDeleteShader(vertex_shader) gl.glDeleteShader(fragment_shader) self._attrib_location_tex = gl.glGetUniformLocation(self._shader_handle, create_string_buffer(b"Texture")) self._attrib_proj_mtx = gl.glGetUniformLocation(self._shader_handle, create_string_buffer(b"ProjMtx")) self._attrib_location_position = gl.glGetAttribLocation(self._shader_handle, create_string_buffer(b"Position")) self._attrib_location_uv = gl.glGetAttribLocation(self._shader_handle, create_string_buffer(b"UV")) self._attrib_location_color = gl.glGetAttribLocation(self._shader_handle, create_string_buffer(b"Color")) self._vbo_handle = gl.GLuint() gl.glGenBuffers(1, byref(self._vbo_handle)) self._elements_handle = gl.GLuint() gl.glGenBuffers(1, byref(self._elements_handle)) self._vao_handle = gl.GLuint() gl.glGenVertexArrays(1, byref(self._vao_handle)) gl.glBindVertexArray(self._vao_handle) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._vbo_handle) gl.glEnableVertexAttribArray(self._attrib_location_position) gl.glEnableVertexAttribArray(self._attrib_location_uv) gl.glEnableVertexAttribArray(self._attrib_location_color) gl.glVertexAttribPointer(self._attrib_location_position, 2, gl.GL_FLOAT, gl.GL_FALSE, imgui.VERTEX_SIZE, c_void_p(imgui.VERTEX_BUFFER_POS_OFFSET)) gl.glVertexAttribPointer(self._attrib_location_uv, 2, gl.GL_FLOAT, gl.GL_FALSE, imgui.VERTEX_SIZE, c_void_p(imgui.VERTEX_BUFFER_UV_OFFSET)) gl.glVertexAttribPointer(self._attrib_location_color, 4, gl.GL_UNSIGNED_BYTE, gl.GL_TRUE, imgui.VERTEX_SIZE, c_void_p(imgui.VERTEX_BUFFER_COL_OFFSET)) # restore state gl.glBindTexture(gl.GL_TEXTURE_2D, cast((c_int*1)(last_texture), POINTER(c_uint)).contents) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, cast((c_int*1)(last_array_buffer), POINTER(c_uint)).contents) gl.glBindVertexArray(cast((c_int*1)(last_vertex_array), POINTER(c_uint)).contents)
def create_rectangle(center_x: float, center_y: float, width: float, height: float, color: Color, border_width: float = 0, tilt_angle: float = 0, filled=True) -> VertexBuffer: """ This function creates a rectangle using a vertex buffer object. Creating the rectangle, and then later drawing it with ``render_rectangle`` is faster than calling ``draw_rectangle``. >>> import arcade >>> arcade.open_window(800,600,"Drawing Example") >>> my_rect = arcade.create_rectangle(200, 200, 50, 50, (0, 255, 0), 3, 45) >>> arcade.render(my_rect) >>> arcade.finish_render() >>> arcade.quick_run(0.25) """ data = get_rectangle_points(center_x, center_y, width, height, tilt_angle) # print(data) vbo_id = gl.GLuint() gl.glGenBuffers(1, ctypes.pointer(vbo_id)) # Create a buffer with the data # This line of code is a bit strange. # (gl.GLfloat * len(data)) creates an array of GLfloats, one for each number # (*data) initalizes the list with the floats. *data turns the list into a # tuple. data2 = (gl.GLfloat * len(data))(*data) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo_id) gl.glBufferData(gl.GL_ARRAY_BUFFER, ctypes.sizeof(data2), data2, gl.GL_STATIC_DRAW) if filled: shape_mode = gl.GL_QUADS else: shape_mode = gl.GL_LINE_LOOP shape = VertexBuffer(vbo_id, len(data) // 2, shape_mode) # Colors shape.vbo_color_id = gl.GLuint() gl.glGenBuffers(1, ctypes.pointer(shape.vbo_color_id)) color_data = _fix_color_list((color, color, color, color)) gl_color_list = (gl.GLfloat * len(color_data))(*color_data) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, shape.vbo_color_id) gl.glBufferData(gl.GL_ARRAY_BUFFER, ctypes.sizeof(gl_color_list), gl_color_list, gl.GL_STATIC_DRAW) shape.line_width = border_width return shape
def __init__(self, ec, fill_color, line_color, line_width, line_loop): self._ec = ec self._line_width = line_width self._line_loop = line_loop # whether or not lines drawn are looped # initialize program and shaders from pyglet import gl self._program = gl.glCreateProgram() vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER) buf = create_string_buffer(tri_vert.encode('ASCII')) ptr = cast(pointer(pointer(buf)), POINTER(POINTER(c_char))) gl.glShaderSource(vertex, 1, ptr, None) gl.glCompileShader(vertex) _check_log(vertex, gl.glGetShaderInfoLog) fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) buf = create_string_buffer(tri_frag.encode('ASCII')) ptr = cast(pointer(pointer(buf)), POINTER(POINTER(c_char))) gl.glShaderSource(fragment, 1, ptr, None) gl.glCompileShader(fragment) _check_log(fragment, gl.glGetShaderInfoLog) gl.glAttachShader(self._program, vertex) gl.glAttachShader(self._program, fragment) gl.glLinkProgram(self._program) _check_log(self._program, gl.glGetProgramInfoLog) gl.glDetachShader(self._program, vertex) gl.glDetachShader(self._program, fragment) gl.glUseProgram(self._program) # Prepare buffers and bind attributes loc = gl.glGetUniformLocation(self._program, b'u_view') view = ec.window_size_pix view = np.diag([2. / view[0], 2. / view[1], 1., 1.]) view[-1, :2] = -1 view = view.astype(np.float32).ravel() gl.glUniformMatrix4fv(loc, 1, False, (c_float * 16)(*view)) self._counts = dict() self._colors = dict() self._buffers = dict() self._points = dict() self._tris = dict() for kind in ('line', 'fill'): self._counts[kind] = 0 self._colors[kind] = (0., 0., 0., 0.) self._buffers[kind] = dict(array=gl.GLuint()) gl.glGenBuffers(1, pointer(self._buffers[kind]['array'])) self._buffers['fill']['index'] = gl.GLuint() gl.glGenBuffers(1, pointer(self._buffers['fill']['index'])) gl.glUseProgram(0) self.set_fill_color(fill_color) self.set_line_color(line_color)
def createFramebuffer(width, height): """Function for setting up additional buffer""" # create a new framebuffer fboId = GL.GLuint() GL.glGenFramebuffers(1, ctypes.byref(fboId)) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, fboId) # create a texture to render to, required for warping texId = GL.GLuint() GL.glGenTextures(1, ctypes.byref(texId)) GL.glBindTexture(GL.GL_TEXTURE_2D, texId) GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR) GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR) GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA32F_ARB, int(width), int(height), 0, GL.GL_RGBA, GL.GL_FLOAT, None) GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0, GL.GL_TEXTURE_2D, texId, 0) # create a render buffer rbId = GL.GLuint() GL.glGenRenderbuffers(1, ctypes.byref(rbId)) GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, rbId) GL.glRenderbufferStorage( GL.GL_RENDERBUFFER, GL.GL_DEPTH24_STENCIL8, int(width), int(height)) GL.glFramebufferRenderbuffer( GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT, GL.GL_RENDERBUFFER, rbId) GL.glFramebufferRenderbuffer( GL.GL_FRAMEBUFFER, GL.GL_STENCIL_ATTACHMENT, GL.GL_RENDERBUFFER, rbId) GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, 0) # clear the buffer GL.glClear(GL.GL_COLOR_BUFFER_BIT) GL.glClear(GL.GL_STENCIL_BUFFER_BIT) GL.glClear(GL.GL_DEPTH_BUFFER_BIT) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0) return fboId, texId, rbId
def __init__(self, world, chunk_position): self.chunk_position = chunk_position self.position = ( # get a world-space position for the chunk self.chunk_position[0] * CHUNK_WIDTH, self.chunk_position[1] * CHUNK_HEIGHT, self.chunk_position[2] * CHUNK_LENGTH) self.world = world self.blocks = [ [ [ 0 # create an array of blocks filled with "air" (block number 0) for z in range(CHUNK_LENGTH) ] for y in range(CHUNK_HEIGHT) ] for x in range(CHUNK_WIDTH) ] # mesh variables self.has_mesh = False self.mesh_vertex_positions = [] self.mesh_tex_coords = [] self.mesh_shading_values = [] self.mesh_index_counter = 0 self.mesh_indices = [] # create vertex array object self.vao = gl.GLuint(0) gl.glGenVertexArrays(1, self.vao) gl.glBindVertexArray(self.vao) # create vertex position vbo self.vertex_position_vbo = gl.GLuint(0) gl.glGenBuffers(1, self.vertex_position_vbo) # create tex coord vbo self.tex_coord_vbo = gl.GLuint(0) gl.glGenBuffers(1, self.tex_coord_vbo) # create shading values vbo self.shading_values_vbo = gl.GLuint(0) gl.glGenBuffers(1, self.shading_values_vbo) # create index buffer object self.ibo = gl.GLuint(0) gl.glGenBuffers(1, self.ibo)
def __init__(self, vertices: np.ndarray, indices: np.ndarray, mode=None, texture=None): if mode is None: mode = gl.GL_TRIANGLES self.vertices = vertices self.indices = indices self.indices_size = indices.size self.mode = mode self.texture = texture self.vao = gl.GLuint(0) gl.glGenVertexArrays(1, ctypes.byref(self.vao)) gl.glBindVertexArray(self.vao) self.vbo = gl.GLuint(0) gl.glGenBuffers(1, ctypes.byref(self.vbo)) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.vbo) gl.glBufferData( gl.GL_ARRAY_BUFFER, # target vertices.nbytes, # size (gl.GLbyte * vertices.nbytes)(*vertices.tobytes()), # data gl.GL_STATIC_DRAW, ) # usage self.ebo = gl.GLuint(0) gl.glGenBuffers(1, ctypes.byref(self.ebo)) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self.ebo) gl.glBufferData( gl.GL_ELEMENT_ARRAY_BUFFER, indices.nbytes, (gl.GLbyte * indices.nbytes)(*indices.tobytes()), gl.GL_STATIC_DRAW, ) for ind, fld in enumerate( sorted([f for f in vertices.dtype.fields.items()], key=lambda i: i[1][1])): gl.glVertexAttribPointer( ind, # index vertices[0][fld[0]].size, # size gl.GL_FLOAT, # type gl.GL_FALSE, # normalized vertices.itemsize, # stride ctypes.c_void_p(fld[1][1]), ) # pointer gl.glEnableVertexAttribArray(ind) if texture is not None: texture_image = pyglet.image.load(texture) self.texture = texture_image.get_texture() gl.glBindVertexArray(0)
def __init__(self, **args): super().__init__(**args) # create vertex array object self.vao = gl.GLuint(0) gl.glGenVertexArrays(1, ctypes.byref(self.vao)) gl.glBindVertexArray(self.vao) # create vertex buffer object self.vbo = gl.GLuint(0) gl.glGenBuffers(1, ctypes.byref(self.vbo)) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.vbo) gl.glBufferData(gl.GL_ARRAY_BUFFER, ctypes.sizeof(gl.GLfloat * len(vertex_positions)), (gl.GLfloat * len(vertex_positions))(*vertex_positions), gl.GL_STATIC_DRAW) gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 0, 0) gl.glEnableVertexAttribArray(0) # create index buffer object self.ibo = gl.GLuint(0) gl.glGenBuffers(1, self.ibo) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self.ibo) gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, ctypes.sizeof(gl.GLuint * len(indices)), (gl.GLuint * len(indices))(*indices), gl.GL_STATIC_DRAW) # create shader self.shader = shader.Shader("vert.glsl", "frag.glsl") self.shader_matrix_location = self.shader.find_uniform( b"matrix") # get the shader matrix uniform location self.shader.use() # create matrices self.mv_matrix = matrix.Matrix() # modelview self.p_matrix = matrix.Matrix() # projection self.x = 0 # temporary variable pyglet.clock.schedule_interval( self.update, 1.0 / 60) # call update function every 60th of a second
def __init__(self, world, chunk_position): self.world = world self.modified = False self.chunk_position = chunk_position self.position = ( self.chunk_position[0] * CHUNK_WIDTH, self.chunk_position[1] * CHUNK_HEIGHT, self.chunk_position[2] * CHUNK_LENGTH) self.blocks = [[[0 for z in range(CHUNK_LENGTH)] for y in range(CHUNK_HEIGHT)] for x in range(CHUNK_WIDTH )] self.subchunks = {} for x in range(int(CHUNK_WIDTH / subchunk.SUBCHUNK_WIDTH)): for y in range(int(CHUNK_HEIGHT / subchunk.SUBCHUNK_HEIGHT)): for z in range(int(CHUNK_LENGTH / subchunk.SUBCHUNK_LENGTH)): self.subchunks[(x, y, z)] = subchunk.Subchunk(self, (x, y, z)) # mesh variables self.mesh_vertex_positions = [] self.mesh_tex_coords = [] self.mesh_shading_values = [] self.mesh_index_counter = 0 self.mesh_indices = [] # create VAO and VBO's self.vao = gl.GLuint(0) gl.glGenVertexArrays(1, self.vao) gl.glBindVertexArray(self.vao) self.vertex_position_vbo = gl.GLuint(0) gl.glGenBuffers(1, self.vertex_position_vbo) self.tex_coord_vbo = gl.GLuint(0) gl.glGenBuffers(1, self.tex_coord_vbo) self.shading_values_vbo = gl.GLuint(0) gl.glGenBuffers(1, self.shading_values_vbo) self.ibo = gl.GLuint(0) gl.glGenBuffers(1, self.ibo)
def create_image_texture(imgfile): """Create a 2D texture from an image file. """ image = pyglet.image.load(imgfile) data = image.get_data("RGBA", image.width * 4) tex = gl.GLuint() gl.glGenTextures(1, ct.pointer(tex)) gl.glBindTexture(gl.GL_TEXTURE_2D, tex) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE) gl.glTexImage2D( gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, image.width, image.height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, data, ) gl.glBindTexture(tex, 0) return tex
def data(self, buffer_type, data, offset): if buffer_type != "texture": gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffers[buffer_type]) if buffer_type == "color": offset *= 16 else: offset *= 12 gl_data = to_gl_float(data) length = len(data) * 4 gl.glBufferSubData(gl.GL_ARRAY_BUFFER, offset, length, gl_data) if buffer_type == "vertex": self.vertex_count += int(len(data) / 3) else: self.buffers["texture"] = gl.GLuint(0) gl.glGenTextures(1, self.buffers["texture"]) gl.glBindTexture(data.target, data.id) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, texture.width, texture.height, 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, texture_data)
def buffer_texture(width, height): id_ = gl.GLuint() gl.glGenTextures(1, byref(id_)) gl.glPushAttrib(gl.GL_ENABLE_BIT | gl.GL_TEXTURE_BIT) gl.glActiveTexture(gl.GL_TEXTURE0) gl.glEnable(gl.GL_TEXTURE_2D) gl.glBindTexture(gl.GL_TEXTURE_2D, id_) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) gl.glTexImage2D( gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, width, height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, (gl.GLubyte * (width*height * 4))(), ) gl.glFlush() gl.glBindTexture(gl.GL_TEXTURE_2D, 0) gl.glPopAttrib() return id_
def create_line_generic(draw_type: int, point_list: PointList, color: Color, line_width: float=1): """ This function is used by ``create_line_strip`` and ``create_line_loop``, just changing the OpenGL type for the line drawing. """ data = [] for point in point_list: data.append(point[0]) data.append(point[1]) vbo_id = gl.GLuint() gl.glGenBuffers(1, ctypes.pointer(vbo_id)) # Create a buffer with the data # This line of code is a bit strange. # (gl.GLfloat * len(data)) creates an array of GLfloats, one for each number # (*data) initalizes the list with the floats. *data turns the list into a # tuple. data2 = (gl.GLfloat * len(data))(*data) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo_id) gl.glBufferData(gl.GL_ARRAY_BUFFER, ctypes.sizeof(data2), data2, gl.GL_STATIC_DRAW) shape = VertexBuffer(vbo_id, len(data) // 2, draw_type) shape.color = color shape.line_width = line_width return shape
def __init__(self, width, height, wwidth, wheight): self.width = width self.height = height self.windowwidth = wwidth self.windowheight = wheight self.framebuffer = gl.GLuint(0) self.rendered_texture = Texture() gl.glGenFramebuffers(1, ctypes.byref(self.framebuffer)) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.framebuffer) # Set up the texture as the target for color output with self.rendered_texture: gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA32F, self.width, self.height, 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, 0) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, self.rendered_texture.name, 0) if gl.glCheckFramebufferStatus( gl.GL_FRAMEBUFFER) != gl.GL_FRAMEBUFFER_COMPLETE: raise ValueError('Framebuffer not set up completely') gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def __init__(self, ctx: "Context"): """Detect the default framebuffer""" self._ctx = ctx # TODO: Can we query this? self._samples = 0 # TODO: Maybe we should map renderbuffers? self._color_attachments = [] self._depth_attachment = None self._depth_mask = True value = c_int() gl.glGetIntegerv(gl.GL_DRAW_FRAMEBUFFER_BINDING, value) self._glo = gl.GLuint(value.value) # Query draw buffers. This will most likely return GL_BACK # value = c_int() # gl.glGetIntegerv(gl.GL_DRAW_BUFFER0, value) # print(value.value) # 1029 GL_BACK 0x405 # self._draw_buffers = (gl.GLuint * 1)(value.value) # NOTE: Don't query for now self._draw_buffers = None # Query viewport values by inspecting the scissor box values = (c_int * 4)() gl.glGetIntegerv(gl.GL_SCISSOR_BOX, values) x, y, width, height = list(values) self._viewport = x, y, width, height self._width = width self._height = height # HACK: Signal the default framebuffer having depth buffer self._depth_attachment = True
def __init__(self, env, sync=True, tps=60, aspect_ratio=None): obs = env.reset() self._image = self.get_image(obs, env) assert len(self._image.shape ) == 3 and self._image.shape[2] == 3, 'must be an RGB image' image_height, image_width = self._image.shape[:2] if aspect_ratio is None: aspect_ratio = image_width / image_height # guess a screen size that doesn't distort the image too much but also is not tiny or huge display = pyglet.canvas.get_display() screen = display.get_default_screen() max_win_width = screen.width * 0.9 max_win_height = screen.height * 0.9 win_width = image_width win_height = int(win_width / aspect_ratio) while win_width > max_win_width or win_height > max_win_height: win_width //= 2 win_height //= 2 while win_width < max_win_width / 2 and win_height < max_win_height / 2: win_width *= 2 win_height *= 2 win = pyglet.window.Window(width=win_width, height=win_height) self._key_handler = pyglet.window.key.KeyStateHandler() win.push_handlers(self._key_handler) win.on_close = self._on_close gl.glEnable(gl.GL_TEXTURE_2D) self._texture_id = gl.GLuint(0) gl.glGenTextures(1, ctypes.byref(self._texture_id)) gl.glBindTexture(gl.GL_TEXTURE_2D, self._texture_id) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA8, image_width, image_height, 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, None) self._env = env self._win = win # self._render_human = render_human self._key_previous_states = {} self._steps = 0 self._episode_steps = 0 self._episode_returns = 0 self._prev_episode_returns = 0 self._tps = tps self._sync = sync self._current_time = 0 self._sim_time = 0 self._max_sim_frames_per_update = 4
def vertex_attrib(self, name, data, size=2, stride=0, offset=0): """ Set vertex attribute data in a shader, lacks the flexibility of setting several attributes in one vertex buffer. Parameters ---------- name: the attribute name in the shader. data: a list of vertex attributes (positions, colors, ...) Example: name = "positions", data = [0, 0, 0, 1, 1, 0, 1, 1]. """ data_ctype = (gl.GLfloat * len(data))(*data) vbo_id = gl.GLuint(0) gl.glGenBuffers(1, ct.byref(vbo_id)) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo_id) gl.glBufferData(gl.GL_ARRAY_BUFFER, ct.sizeof(data_ctype), data_ctype, gl.GL_STATIC_DRAW) location = gl.glGetAttribLocation(self.program, name.encode("ascii")) gl.glEnableVertexAttribArray(location) gl.glVertexAttribPointer(location, size, gl.GL_FLOAT, gl.GL_FALSE, stride, ct.c_void_p(offset)) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0) return vbo_id
def upload(self): """Upload the local atlas data into graphics card memory """ if not self.textureID: self.textureID = gl.GLuint(0) gl.glGenTextures(1, ctypes.byref(self.textureID)) logging.debug("Uploading Texture Font {} to graphics card".format( self.name)) gl.glBindTexture(gl.GL_TEXTURE_2D, self.textureID) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) if self.format == 'alpha': gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_ALPHA, self.width, self.height, 0, gl.GL_ALPHA, gl.GL_UNSIGNED_BYTE, self.data.ctypes) else: gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, self.width, self.height, 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, self.data.ctypes) logging.debug("Upload of Texture Font {} complete".format(self.name)) gl.glBindTexture(gl.GL_TEXTURE_2D, 0)
def __init__( self, ctx, data: Optional[Any] = None, reserve: int = 0, usage: str = "static" ): """ :param Context ctx: The context this buffer belongs to :param Any data: The data this buffer should contain. It can be bytes or any object supporting the buffer protocol. :param int reserve: Create a buffer of a specific byte size :param str usage: A hit of this buffer is ``static`` or ``dynamic`` (can mostly be ignored) """ self._ctx = ctx self._glo = glo = gl.GLuint() self._size = -1 self._usage = Buffer._usages[usage] gl.glGenBuffers(1, byref(self._glo)) # print(f"glGenBuffers() -> {self._glo.value}") if self._glo.value == 0: raise RuntimeError("Cannot create Buffer object.") # print(f"glBindBuffer({self._glo.value})") gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._glo) # print(f"glBufferData(gl.GL_ARRAY_BUFFER, {self._size}, data, {self._usage})") if data is not None and len(data) > 0: self._size, data = data_to_ctypes(data) gl.glBufferData(gl.GL_ARRAY_BUFFER, self._size, data, self._usage) elif reserve > 0: self._size = reserve gl.glBufferData(gl.GL_ARRAY_BUFFER, self._size, None, self._usage) else: raise ValueError("Buffer takes byte data or number of reserved bytes") self.ctx.stats.incr("buffer") weakref.finalize(self, Buffer.release, self.ctx, glo)
def set_vertex_attrib(self, name, data): """This is an ugly way to set vertex attribute data in a shader, it lacks the flexibility of setting several attributes in one vertex buffer. name: the attribute name in the shader. data: a list of vertex attributes (positions, colors, texcoords, normals,...) example: name = 'positions', data = [(1, 1, 0), (2, 2, 1), ...] the items in data must all be 1D lists(or tuples) of the same length. """ data_flatten = [x for vertex in data for x in vertex] size = len(data[0]) data_ctype = (gl.GLfloat * len(data_flatten))(*data_flatten) vbo_id = gl.GLuint(0) gl.glGenBuffers(1, ct.byref(vbo_id)) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo_id) gl.glBufferData(gl.GL_ARRAY_BUFFER, ct.sizeof(data_ctype), data_ctype, gl.GL_STATIC_DRAW) location = gl.glGetAttribLocation(self.program, name.encode('ascii')) gl.glEnableVertexAttribArray(location) gl.glVertexAttribPointer(location, size, gl.GL_FLOAT, gl.GL_FALSE, 0, 0) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0) return vbo_id
def __init__(self, size: Tuple[int, int], component: int, data): self.width, self.height = size sized_format = (gl.GL_R8, gl.GL_RG8, gl.GL_RGB8, gl.GL_RGBA8)[component - 1] self.format = (gl.GL_R, gl.GL_RG, gl.GL_RGB, gl.GL_RGBA)[component - 1] gl.glActiveTexture(gl.GL_TEXTURE0 + 0) # If we need other texture unit... self.texture_id = texture_id = gl.GLuint() gl.glGenTextures(1, byref(self.texture_id)) if self.texture_id.value == 0: raise ShaderException("Cannot create Texture.") gl.glBindTexture(gl.GL_TEXTURE_2D, self.texture_id) gl.glPixelStorei(gl.GL_PACK_ALIGNMENT, 1) gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1) try: gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, sized_format, self.width, self.height, 0, self.format, gl.GL_UNSIGNED_BYTE, data) except gl.GLException: raise gl.GLException( f"Unable to create texture. {gl.GL_MAX_TEXTURE_SIZE} {size}") gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) weakref.finalize(self, Texture.release, texture_id)
def __init__(self, width, height, background=[255, 255, 255]): self.width = width self.height = height self.triangles = [] self.batch = Batch() self.bg_colour = background has_fbo = gl.gl_info.have_extension('GL_EXT_framebuffer_object') #setup a framebuffer self.fb = gl.GLuint() gl.glGenFramebuffersEXT(1, ctypes.byref(self.fb)) gl.glBindFramebufferEXT(gl.GL_FRAMEBUFFER_EXT, self.fb) #allocate a texture for the fb to render to tex = image.Texture.create_for_size(gl.GL_TEXTURE_2D, width, height, gl.GL_RGBA) gl.glBindTexture(gl.GL_TEXTURE_2D, tex.id) gl.glFramebufferTexture2DEXT(gl.GL_FRAMEBUFFER_EXT, gl.GL_COLOR_ATTACHMENT0_EXT, gl.GL_TEXTURE_2D, tex.id, 0) status = gl.glCheckFramebufferStatusEXT(gl.GL_FRAMEBUFFER_EXT) assert status == gl.GL_FRAMEBUFFER_COMPLETE_EXT gl.glBindFramebufferEXT(gl.GL_FRAMEBUFFER_EXT, 0) self.bg = self.batch.add( 6, gl.GL_TRIANGLES, None, ("v2i/static", (0, 0, 0, height, width, height, width, height, width, 0, 0, 0)), ("c3B/static", background * 6))
def _create_filled_with_colors(point_list, color_list, shape_mode): number_points = len(point_list) vertex_data = [] for point in point_list: vertex_data.append(point[0]) vertex_data.append(point[1]) color_data = [] for color in color_list: color_data.append(color[0] / 255.) color_data.append(color[1] / 255.) color_data.append(color[2] / 255.) if len(color) == 3: color_data.append(1.0) else: color_data.append(color[3] / 255.) vbo_vertex_id = gl.GLuint() gl.glGenBuffers(1, ctypes.pointer(vbo_vertex_id)) # Create a buffer with the data # This line of code is a bit strange. # (gl.GLfloat * len(data)) creates an array of GLfloats, one for each number # (*data) initalizes the list with the floats. *data turns the list into a # tuple. data2 = (gl.GLfloat * len(vertex_data))(*vertex_data) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo_vertex_id) gl.glBufferData(gl.GL_ARRAY_BUFFER, ctypes.sizeof(data2), data2, gl.GL_STATIC_DRAW) # Colors vbo_color_id = gl.GLuint() gl.glGenBuffers(1, ctypes.pointer(vbo_color_id)) gl_color_list = (gl.GLfloat * len(color_data))(*color_data) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo_color_id) gl.glBufferData(gl.GL_ARRAY_BUFFER, ctypes.sizeof(gl_color_list), gl_color_list, gl.GL_STATIC_DRAW) shape = VertexBuffer(vbo_vertex_id, number_points, shape_mode, vbo_color_id=vbo_color_id) return shape
def create_opengl_object(gl_gen_function, n=1): """Returns int pointing to an OpenGL texture""" handle = gl.GLuint(1) gl_gen_function(n, byref(handle)) # Create n Empty Objects if n > 1: return [handle.value + el for el in range(n)] # Return list of handle values else: return handle.value # Return handle value
def __init__(self, type, data): self.type = type self.data = data self.id = gl.GLuint() gl.glGenBuffers(1, ctypes.pointer(self.id)) self.data_ptr = (gl.GLfloat * len(data))(*data) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.id) gl.glBufferData(gl.GL_ARRAY_BUFFER, ctypes.sizeof(self.data_ptr), self.data_ptr, gl.GL_STATIC_DRAW)
def createVertexbuffer(vertexData, vertexSize=3, bufferType=GL.GL_VERTEX_ARRAY): """Create a static, single-storage Vertex Buffer Object (VBO). Parameters ---------- vertexData : :obj:`list` or :obj:`tuple` of :obj:`float` Coordinates as a 1D array of floats (e.g. [X0, Y0, Z0, X1, Y1, Z1, ...]) vertexSize : :obj:`int` Number of coordinates per-vertex, default is 3. bufferType : :obj:`int` The type of data stored in the buffer (e.g. GL_VERTEX_ARRAY, GL_TEXTURE_COORD_ARRAY, GL_NORMAL_ARRAY, etc.) Returns ------- Vertexbuffer A descriptor with vertex buffer information. Examples -------- # vertices of a triangle verts = [ 1.0, 1.0, 0.0, # v0 0.0, -1.0, 0.0, # v1 -1.0, 1.0, 0.0] # v2 # load vertices to graphics device, return a descriptor vboDesc = createVertexbuffer(verts, 3) # draw GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vboDesc.id) GL.glVertexPointer(vboDesc.vertexSize, vboDesc.dtype, 0, None) GL.glEnableClientState(vboDesc.bufferType) GL.glDrawArrays(GL.GL_TRIANGLES, 0, vboDesc.indices) GL.glFlush() """ # convert values to ctypes float array count = len(vertexData) c_array = (GL.GLfloat * count)(*vertexData) # create a vertex buffer ID vboId = GL.GLuint() GL.glGenBuffers(1, ctypes.byref(vboId)) # new vertex descriptor vboDesc = Vertexbuffer(vboId, vertexSize, count, int(count / vertexSize), GL.GL_STATIC_DRAW, bufferType, GL.GL_FLOAT) # always float # bind and upload GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vboId) GL.glBufferData(GL.GL_ARRAY_BUFFER, ctypes.sizeof(c_array), c_array, GL.GL_STATIC_DRAW) # GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0) return vboDesc