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
