def main():
glfw.setErrorCallback(error_callback)
glfw.init()
glfw.windowHint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.windowHint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.windowHint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
# glfw.windowHint(glfw.RESIZABLE, gl.FALSE)
glfw.windowHint(glfw.OPENGL_FORWARD_COMPAT, 1)
window = glfw.createWindow(WIDTH, HEIGHT, "LearnOpenGL")
if window is None:
print('could not open window.')
glfw.terminate()
sys.exit()
window.makeContextCurrent()
# window.setInputMode(glfw.CURSOR, glfw.CURSOR_DISABLED)
window.setKeyCallback(key_callback)
gl.init()
err = gl.getError()
if err:
print("WINDOW OPEN ERROR:", err)
# set up the first model
armored_plate_data = objloader.load_obj(os.path.join("springtangent-model-files", "armored_plate.75.75.decimation_test7.obj"))
armored_plate_model = Model.FromJSON(armored_plate_data, InstanceData, PlateInstance)
plane_plate_data = objloader.load_obj(os.path.join("springtangent-model-files", "plane_plate.75.75.decimation_test.00.obj"))
plane_plate_model = Model.FromJSON(plane_plate_data, InstanceData, PlateInstance)
angled_plate_data = objloader.load_obj(os.path.join("springtangent-model-files", "angled_plate_plane.75.25..25.decimated.obj"))
angled_plate_model = Model.FromJSON(angled_plate_data, InstanceData, PlateInstance)
models =[armored_plate_model, plane_plate_model, angled_plate_model]
scene = Scene()
camera = Camera(name='camera', parent=scene)
# set up the data for the instances.
# 30 x 30 array of tiles, which are randomly selected among the above models
instances = {}
transforms = {}
n = 30
for i in range(n):
for j in range(n):
r = random.choice(range(4))
transform = Mat4.Translation(Vec3((i-n//2) * 2, 0.0, (j-n//2) * 2)) * Mat4.Rotation(math.pi/2.0 * r, Vec3(0.0, 1.0, 0.0))
transform_node = TransformNode3D(name='tranform.%i.%i' % (i, j), parent=scene, m=transform)
transforms[i,j] = transform_node
instance = ModelInstance(random.choice(models), model_matrix=transform, parent=transform_node, name='model.%i.%i' % (i,j))
instance.model_matrix = transform
instances[i,j] = instance
instance.r = r
framebuffer_width, framebuffer_height = window.getFramebufferSize()
camera.projection_matrix = Mat4.Perspective(45.0, framebuffer_width/framebuffer_height, 0.1, 100.0)
camera.view_matrix = Mat4.LookAt(Vec3(math.cos(time.clock()), 1.0, math.sin(time.clock())) *15.0, Vec3(0.0, 0.0, 0.0), Vec3(0.0, 1.0, 0.0))
t0 = time.perf_counter()
frames = 0
while not window.shouldClose():
glfw.pollEvents()
gl.enable(gl.DEPTH_TEST)
gl.depthFunc(gl.LEQUAL)
gl.enable(gl.CULL_FACE)
gl.cullFace(gl.BACK)
t = time.perf_counter()
framebuffer_width, framebuffer_height = window.getFramebufferSize()
camera.view_matrix = Mat4.LookAt(Vec3(math.cos(time.clock() * 0.1), 1.0, math.sin(time.clock() * 0.1)) *15.0, Vec3(0.0, 0.0, 0.0), Vec3(0.0, 1.0, 0.0))
viewport = (0, 0, framebuffer_width, framebuffer_height)
camera.render_to_viewport(viewport)
err = gl.getError()
if err:
print("ERROR:", err)
if TEST_ANIMATION:
for i in range(n):
for j in range(n):
instance = instances[i,j]
enabled = math.sin(i+j+t*10.0) > -0.8
instance.set_enabled(enabled)
if enabled:
transform_node = transforms[i,j]
y = (math.sin(t+i) + math.cos(t+j)) * 0.25
transform = Mat4.Translation(Vec3((i-n//2) * 2, y, (j-n//2) * 2)) * Mat4.Rotation(math.pi/2.0 * instance.r, Vec3(0.0, 1.0, 0.0))
transform_node.local_matrix = transform
# TODO: this should be done automatically in nodetree.graphics.Scene.update_instances
instance.instance.model_matrix = transform_node.to_mat4()
scene.update_instances()
window.swapBuffers()
frames += 1
if not frames % 100:
print("FRAME RATE:", float(frames)/(time.perf_counter() - t0))
def main():
glfw.setErrorCallback(error_callback)
glfw.init()
glfw.windowHint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.windowHint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.windowHint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.windowHint(glfw.RESIZABLE, gl.FALSE)
glfw.windowHint(glfw.OPENGL_FORWARD_COMPAT, 1)
window = glfw.createWindow(WIDTH, HEIGHT, "LearnOpenGL")
if window is None:
# print('could not open window.')
glfw.terminate()
sys.exit()
cursor = Vec2()
window_size = Vec2(WIDTH, HEIGHT)
ui = EventEmitter()
def mouse_move_callback(window, x, y):
nonlocal cursor
# print('mouse move:', window, x, y)
cursor = Vec2(x, window_size.y - y)
ui.emit('mouse_move', window, cursor)
def mouse_button_callback(window, button, action, mods):
print('mouse button:', window, button, action, mods)
ui.emit('mouse_button', window, button, action, mods)
def window_size_callback(window, width, height):
nonlocal window_size
window_size.x = width
window_size.y = height
window.makeContextCurrent()
# window.setInputMode(glfw.CURSOR, glfw.CURSOR_DISABLED)
window.setKeyCallback(key_callback)
window.setMouseButtonCallback(mouse_button_callback)
window.setCursorPosCallback(mouse_move_callback)
window.setWindowSizeCallback(window_size_callback)
gl.init()
err = gl.getError()
if err:
print("WINDOW OPEN ERROR:", err)
# pre game-loop initialization
scene = Scene()
# construct the triangle
triangle_points = Vector(Vec3)
triangle_points.append(Vec3(-0.5, -0.5, 0.0))
triangle_points.append(Vec3( 0.5, -0.5, 0.0))
triangle_points.append(Vec3(-0.5, 0.5, 0.0))
triangle_indices = Vector(c_ubyte)
triangle_indices.append(0)
triangle_indices.append(1)
triangle_indices.append(2)
triangle_attribs = BufferAttribs(sizeof(Vec3))
triangle_attribs.add(BufferAttribs.POSITION_INDEX, 3, gl.FLOAT, gl.FALSE, 0)
triangle_shader = ShaderProgram(VERTEX_SHADER_SOURCE, FRAGMENT_SHADER_SOURCE)
triangle_draw_call = DrawCall(gl.UNSIGNED_BYTE, gl.LINE_LOOP, 0, len(triangle_indices))
triangle_material = {}
triangle_mesh = Mesh(triangle_shader, triangle_draw_call, triangle_material)
triangle_model = Model(triangle_indices.get_data(), triangle_points.get_data(), triangle_attribs, [triangle_mesh], InstanceData, ItemInstance)
triangle_instance = scene.add(triangle_model, InstanceData(model_matrix=Mat4.Identity(), base_color=Vec3(1.0, 0.0, 0.0)))
# construct the reticle
RETICLE_SIZE = 0.01
reticle_points = Vector(Vec3)
reticle_points.append(Vec3(-RETICLE_SIZE * 0.5, -RETICLE_SIZE * 0.5, 0.0))
reticle_points.append(Vec3(-RETICLE_SIZE * 0.5, RETICLE_SIZE * 0.5, 0.0))
reticle_points.append(Vec3( RETICLE_SIZE * 0.5, RETICLE_SIZE * 0.5, 0.0))
reticle_points.append(Vec3( RETICLE_SIZE * 0.5, -RETICLE_SIZE * 0.5, 0.0))
reticle_indices = Vector(c_ubyte)
reticle_indices.append(0)
reticle_indices.append(1)
reticle_indices.append(2)
reticle_indices.append(3)
reticle_attribs = BufferAttribs(sizeof(Vec3))
reticle_attribs.add(BufferAttribs.POSITION_INDEX, 3, gl.FLOAT, gl.FALSE, 0)
reticle_shader = triangle_shader
reticle_draw_call = DrawCall(gl.UNSIGNED_BYTE, gl.LINE_LOOP, 0, len(reticle_indices))
reticle_material = {}
reticle_mesh = Mesh(reticle_shader, reticle_draw_call, reticle_material)
reticle_model = Model(reticle_indices.get_data(), reticle_points.get_data(), reticle_attribs, [reticle_mesh], InstanceData, ItemInstance)
# construct the AABB model
aabb = AABB3()
aabb.include_point(Vec3(0.0, 0.0, 0.0))
aabb.include_point(Vec3(0.2, 0.2, 0.2))
aabb_points = Vector(Vec3)
aabb_points.append(Vec3(aabb.min.x, aabb.min.y, aabb.min.z))
aabb_points.append(Vec3(aabb.max.x, aabb.min.y, aabb.min.z))
aabb_points.append(Vec3(aabb.min.x, aabb.max.y, aabb.min.z))
aabb_points.append(Vec3(aabb.max.x, aabb.max.y, aabb.min.z))
aabb_points.append(Vec3(aabb.min.x, aabb.min.y, aabb.max.z))
aabb_points.append(Vec3(aabb.max.x, aabb.min.y, aabb.max.z))
aabb_points.append(Vec3(aabb.min.x, aabb.max.y, aabb.max.z))
aabb_points.append(Vec3(aabb.max.x, aabb.max.y, aabb.max.z))
# lines
aabb_indices = Vector(c_ubyte)
aabb_indices.append(0)
aabb_indices.append(1)
aabb_indices.append(2)
aabb_indices.append(3)
aabb_indices.append(4)
aabb_indices.append(5)
aabb_indices.append(6)
aabb_indices.append(7)
aabb_indices.append(0)
aabb_indices.append(4)
aabb_indices.append(1)
aabb_indices.append(5)
aabb_indices.append(2)
aabb_indices.append(6)
aabb_indices.append(3)
aabb_indices.append(7)
aabb_indices.append(0)
aabb_indices.append(2)
aabb_indices.append(1)
aabb_indices.append(3)
aabb_indices.append(4)
aabb_indices.append(6)
aabb_indices.append(5)
aabb_indices.append(7)
aabb_attribs = BufferAttribs(sizeof(Vec3))
aabb_attribs.add(BufferAttribs.POSITION_INDEX, 3, gl.FLOAT, gl.FALSE, 0)
aabb_shader = triangle_shader
aabb_draw_call = DrawCall(gl.UNSIGNED_BYTE, gl.LINES, 0, len(aabb_indices))
aabb_material = {}
aabb_mesh = Mesh(aabb_shader, aabb_draw_call, aabb_material)
aabb_model = Model(aabb_indices.get_data(), aabb_points.get_data(), aabb_attribs, [aabb_mesh], InstanceData, ItemInstance)
# reticle_instances = ModelInstances(reticle_model, InstanceData, ItemInstance)
reticle_instance = scene.add(reticle_model, InstanceData(model_matrix=Mat4.Identity()))
# aabb_instances = ModelInstances(aabb_model, InstanceData, ItemInstance)
aabb_instance = scene.add(aabb_model, InstanceData(model_matrix=Mat4.Identity()))
#reticle_instance.set_enabled(False)
ray_scene = RayScene()
# ui.on('mouse_move' lambda window, cursor: scene.mouse_move(camera, viewport, cursor))
camera = Camera(scene=scene)
framebuffer_width, framebuffer_height = window.getFramebufferSize()
# camera.projection_matrix = Mat4.Identity()
camera.projection_matrix = Mat4.Perspective(45.0, framebuffer_width/framebuffer_height, 0.1, 100.0)
camera.view_matrix = Mat4.Identity()
t0 = time.perf_counter()
frames = 0
while not window.shouldClose():
glfw.pollEvents()
gl.enable(gl.DEPTH_TEST)
gl.depthFunc(gl.LEQUAL)
gl.enable(gl.CULL_FACE)
gl.cullFace(gl.BACK)
t = time.perf_counter()
err = gl.getError()
if err:
print("ERROR:", err)
# render the frame
framebuffer_width, framebuffer_height = window.getFramebufferSize()
# camera.view_matrix = Mat4.LookAt(Vec3(math.cos(time.clock() * 0.1), 1.0, math.sin(time.clock() * 0.1)) *15.0, Vec3(0.0, 0.0, 0.0), Vec3(0.0, 1.0, 0.0))
camera.view_matrix = Mat4.LookAt(
Vec3(math.cos(time.clock() * 0.1), 1.0, math.sin(time.clock() * 0.1)) *2.0,
Vec3(0.0, 0.0, 0.0),
Vec3(0.0, 1.0, 0.0)
)
viewport = (0, 0, framebuffer_width, framebuffer_height)
camera.render_to_viewport(viewport)
# not sure if this is correct when the viewport size doesn't match the framebuffer size.
ray_origin, ray_direction = camera.get_ray(cursor, viewport)
# print(ray)
result = raytri.intersect_triangle(ray_origin, ray_direction, *triangle_points)
if result:
t, u, v = result
hit_pos = triangle_points[0] * (1.0 - u - v) + triangle_points[1] * u + triangle_points[2] * v
reticle_instance.set_enabled(True)
reticle_instance.model_matrix = Mat4.Translation(hit_pos)
reticle_instance.base_color = Vec3(1.0, 1.0, 1.0)
triangle_instance.base_color = Vec3(1.0, 0.0, 0.0)
else:
reticle_instance.set_enabled(False)
triangle_instance.base_color = Vec3(1.0, 1.0, 1.0)
reticle_instance.base_color = Vec3(0.0, 0.0, 0.0)
result = raytri.hit_aabb(ray_origin, ray_direction, aabb)
if result:
aabb_instance.base_color = Vec3(1.0, 0.0, 0.0)
else:
aabb_instance.base_color = Vec3(1.0, 1.0, 1.0)
# print((ray_origin, ray_direction), result)
# update buffers
scene.update_instances()
window.swapBuffers()
frames += 1
if not frames % 100:
print("FRAME RATE:", float(frames)/(time.perf_counter() - t0))
def main():
glfw.setErrorCallback(error_callback)
glfw.init()
glfw.windowHint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.windowHint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.windowHint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
# glfw.windowHint(glfw.RESIZABLE, gl.FALSE)
glfw.windowHint(glfw.OPENGL_FORWARD_COMPAT, 1)
if ENABLE_MULTISAMPLE:
glfw.windowHint(glfw.SAMPLES, 4)
window = glfw.createWindow(WIDTH, HEIGHT, "LearnOpenGL")
if window is None:
print('could not open window.')
glfw.terminate()
sys.exit()
window.makeContextCurrent()
# window.setInputMode(glfw.CURSOR, glfw.CURSOR_DISABLED)
window.setKeyCallback(key_callback)
gl.init()
err = gl.getError()
if err:
print("WINDOW OPEN ERROR:", err)
framebuffer_width, framebuffer_height = window.getFramebufferSize()
# Framebuffers
framebuffer = gl.genFramebuffers(1)[0]
gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
# Create a color attachment texture
textureColorbuffer = generateAttachmentTexture(gl.RGB, framebuffer_width, framebuffer_height);
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, textureColorbuffer, 0)
# set up the position buffer
gPosition = gl.genTextures(1)[0]
gl.bindTexture(gl.TEXTURE_2D, gPosition)
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB16F, framebuffer_width, framebuffer_height, 0, gl.RGB, gl.FLOAT, None)
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, gPosition, 0)
# set up the normal buffer
gNormal = gl.genTextures(1)[0]
gl.bindTexture(gl.TEXTURE_2D, gNormal)
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB16F, framebuffer_width, framebuffer_height, 0, gl.RGB, gl.FLOAT, None)
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT2, gl.TEXTURE_2D, gNormal, 0)
gLight = gl.genTextures(1)[0]
gl.bindTexture(gl.TEXTURE_2D, gLight)
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB16F, framebuffer_width, framebuffer_height, 0, gl.RGB, gl.FLOAT, None)
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT3, gl.TEXTURE_2D, gLight, 0)
# - Tell OpenGL which color attachments we'll use (of this framebuffer) for rendering
attachments = [gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1, gl.COLOR_ATTACHMENT2]
gl.drawBuffers(attachments)
gDepth = gl.genTextures(1)[0]
gl.bindTexture(gl.TEXTURE_2D, gDepth)
gl.texImage2D(gl.TEXTURE_2D, 0, gl.DEPTH24_STENCIL8, framebuffer_width, framebuffer_height, 0, gl.DEPTH_STENCIL, gl.UNSIGNED_INT_24_8, None)
# gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB16F, framebuffer_width, framebuffer_height, 0, gl.RGB, gl.FLOAT, None)
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.TEXTURE_2D, gDepth, 0)
# Create a renderbuffer object for depth and stencil attachment (we won't be sampling these)
# rbo = gl.genRenderbuffers(1)[0]
# gl.bindRenderbuffer(gl.RENDERBUFFER, rbo)
# gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH24_STENCIL8, framebuffer_width, framebuffer_height); # Use a single renderbuffer object for both a depth AND stencil buffer.
# gl.bindRenderbuffer(gl.RENDERBUFFER, 0);
# gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, rbo) # Now actually attach it
# Now that we actually created the framebuffer and added all attachments we want to check if it is actually complete now
if gl.checkFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFER_COMPLETE:
print("ERROR::FRAMEBUFFER:: Framebuffer is not complete!")
gl.bindFramebuffer(gl.FRAMEBUFFER, 0)
deferred_textures = {
'screenTexture': textureColorbuffer,
'normalTexture': gNormal,
'positionTexture': gPosition,
'lightTexture': gLight,
'depthTexture': gDepth
}
scene = Scene()
camera = Camera(scene=scene)
quad_scene = Scene()
quad_camera = Camera(scene=quad_scene)
light_scene = Scene()
light_camera = Camera(scene=light_scene, clear=0)
light_camera.clear = gl.COLOR_BUFFER_BIT
light_camera.clear_color = (0.0, 0.0, 0.0, 0.0)
light_camera.projection_matrix = camera.projection_matrix = Mat4.Perspective(45.0, framebuffer_width/framebuffer_height, 0.1, 100.0)
light_camera.view_matrix = camera.view_matrix = Mat4.LookAt(Vec3(math.cos(time.clock()), 1.0, math.sin(time.clock())) *15.0, Vec3(0.0, 0.0, 0.0), Vec3(0.0, 1.0, 0.0))
# light volume model
light_volume_data = objloader.load_obj(os.path.join("springtangent-model-files", "lightsphere", "lightsphere.obj"), calculate_normals=True)
light_volume_model = Model.FromJSON(light_volume_data, PointLightInstanceData, PlateInstance)
# other models
armored_plate_data = objloader.load_obj(os.path.join("springtangent-model-files", "armored_plate.75.75.decimation_test7.obj"), calculate_normals=True)
armored_plate_model = Model.FromJSON(armored_plate_data, InstanceData, PlateInstance)
plane_plate_data = objloader.load_obj(os.path.join("springtangent-model-files", "plane_plate.75.75.decimation_test.00.obj"), calculate_normals=True)
plane_plate_model = Model.FromJSON(plane_plate_data, InstanceData, PlateInstance)
angled_plate_data = objloader.load_obj(os.path.join("springtangent-model-files", "angled_plate_plane.75.25..25.decimated.obj"), calculate_normals=True)
angled_plate_model = Model.FromJSON(angled_plate_data, InstanceData, PlateInstance)
angled_to_rounded_data = objloader.load_obj(os.path.join("springtangent-model-files", "angled_to_round_adapter.75.25.25", "angled_to_rounded_adapter.75.25.25.decimated.obj"), calculate_normals=True)
angled_to_rounded_model = Model.FromJSON(angled_to_rounded_data, InstanceData, PlateInstance)
models = [armored_plate_model, plane_plate_model, angled_plate_model, angled_to_rounded_model]
deferred_shader = ShaderProgram(GBUFFER_VERT, GBUFFER_FRAG)
deferred_light_shader = ShaderProgram(GBUFFER_LIGHT_VERT, GBUFFER_LIGHT_FRAG)
for mesh in light_volume_model.meshes:
mesh.shader = deferred_light_shader
mesh.material = deferred_textures
# replace the shader with the deferred shader in all meshes
for model in models:
for mesh in model.meshes:
mesh.shader = deferred_shader
# set up the data for the instances.
# 30 x 30 array of tiles, which are randomly selected among the above models
n = 30
instances = {}
for i in range(n):
for j in range(n):
r = random.choice(range(4))
transform = Mat4.Translation(Vec3((i-n//2) * 2, 0.0, (j-n//2) * 2)) * Mat4.Rotation(math.pi/2.0 * r, Vec3(0.0, 1.0, 0.0))
instance = scene.add(random.choice(models), InstanceData(transform))
instance.r = r
instances[i,j] = instance
nlights = 400
for i in range(nlights):
transform = Mat4.Translation(Vec3(random.uniform(-n/2, n/2), random.uniform(-1.0, 1.0), random.uniform(-n/2,n/2))) * Mat4.Scale(random.uniform(2.0, 10.0))
instance = light_scene.add(light_volume_model, PointLightInstanceData(transform, diffuse=Vec3(1.0, 1.0, 1.0), linear_attenuation=0.1, quadratic_attenutation=0.01))
# full screen rectangle
class QuadVert(Structure):
_fields_ = [
('position', Vec2),
('texcoord', Vec2)
]
quad_points = Vector(QuadVert)
quad_points.append(QuadVert(Vec2(-1.0, 1.0), Vec2(0.0, 1.0)))
quad_points.append(QuadVert(Vec2(-1.0, -1.0), Vec2(0.0, 0.0)))
quad_points.append(QuadVert(Vec2( 1.0, -1.0), Vec2(1.0, 0.0)))
quad_points.append(QuadVert(Vec2( 1.0, 1.0), Vec2(1.0, 1.0)))
quad_indices = Vector(c_ubyte)
quad_indices.append(0)
quad_indices.append(1)
quad_indices.append(2)
quad_indices.append(0)
quad_indices.append(2)
quad_indices.append(3)
quad_attribs = BufferAttribs(sizeof(QuadVert))
quad_attribs.add(BufferAttribs.POSITION_INDEX, 2, gl.FLOAT, gl.FALSE, QuadVert.position.offset)
quad_attribs.add(BufferAttribs.TEXCOORD_INDEX, 2, gl.FLOAT, gl.FALSE, QuadVert.texcoord.offset)
quad_shader = ShaderProgram(FRAMEBUFFER_VERT, FRAMEBUFFER_FRAG)
quad_draw_call = DrawCall(gl.UNSIGNED_BYTE, gl.TRIANGLES, 0, len(quad_indices))
quad_material = deferred_textures
quad_mesh = Mesh(quad_shader, quad_draw_call, quad_material)
quad_model = Model(quad_indices.get_data(), quad_points.get_data(), quad_attribs, [quad_mesh], InstanceData, PlateInstance)
# quad_instances = ModelInstances(quad_model)
quad_instance = quad_scene.add(quad_model, InstanceData(Mat4.Identity()))
gl.enable(gl.MULTISAMPLE)
t0 = time.perf_counter()
frames = 0
while not window.shouldClose():
glfw.pollEvents()
t = time.perf_counter()
# render scene to gbuffer
gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer)
gl.enable(gl.DEPTH_TEST)
gl.depthFunc(gl.LEQUAL)
gl.enable(gl.CULL_FACE)
gl.cullFace(gl.BACK)
# set up gbuffer for writing
attachments = [gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1, gl.COLOR_ATTACHMENT2]
gl.drawBuffers(attachments)
framebuffer_width, framebuffer_height = window.getFramebufferSize()
light_camera.view_matrix = camera.view_matrix = Mat4.LookAt(Vec3(math.cos(time.clock() * 0.1), 1.0, math.sin(time.clock() * 0.1)) *15.0, Vec3(0.0, 0.0, 0.0), Vec3(0.0, 1.0, 0.0))
viewport = (0, 0, framebuffer_width, framebuffer_height)
camera.render_to_viewport(viewport)
# render lights to gbuffer
gl.drawBuffer(gl.COLOR_ATTACHMENT3)
gl.depthFunc(gl.GREATER)
gl.enable(gl.CULL_FACE)
gl.cullFace(gl.FRONT)
gl.enable(gl.BLEND)
gl.blendEquation(gl.FUNC_ADD)
gl.blendFunc(gl.ONE, gl.ONE)
light_camera.render_to_viewport(viewport)
err = gl.getError()
if err:
print("ERROR:", err)
if TEST_ANIMATION:
for i in range(n):
for j in range(n):
instance = instances[i,j]
enabled = True # math.sin(i+j+t*10.0) > -0.8
# instance.set_enabled(enabled)
if enabled:
y = (math.sin(t+i) + math.cos(t+j)) * 0.25
transform = Mat4.Translation(Vec3((i-n//2) * 2, y, (j-n//2) * 2)) * Mat4.Rotation(math.pi/2.0 * instance.r, Vec3(0.0, 1.0, 0.0))
instance.model_matrix = transform
# render quad with texture
gl.bindFramebuffer(gl.FRAMEBUFFER, 0)
gl.disable(gl.BLEND)
gl.disable(gl.CULL_FACE)
gl.disable(gl.DEPTH_TEST) # We don't care about depth information when rendering a single quad
quad_camera.clear_color = (1.0, 1.0, 1.0, 1.0)
quad_camera.clear = gl.COLOR_BUFFER_BIT
quad_camera.render_to_viewport(viewport)
scene.update_instances()
quad_scene.update_instances()
light_scene.update_instances()
window.swapBuffers()
frames += 1
if not frames % 100:
print("FRAME RATE:", float(frames)/(time.perf_counter() - t0))
