def render_scene(time, cam1, view, projection): # Light source: lamp light_color = glm.vec3(1, 1, 1) light_position = glm.vec3(np.cos(time), 1.5, np.sin(time)) # Ground glBindVertexArray(vao1) glUseProgram(shader_solid) model = glm.identity(4) model = glm.rotate(np.pi*0.5, glm.vec3(1, 0, 0)) * model glUniform3fv(glGetUniformLocation(shader_solid, "solid_color"), 1, glm.vec3(0, 0, 1)) glUniformMatrix4fv(glGetUniformLocation(shader_solid, "view"), 1, GL_TRUE, np.asarray(view)) glUniformMatrix4fv(glGetUniformLocation(shader_solid, "projection"), 1, GL_FALSE, np.asarray(projection)) glUniformMatrix4fv(glGetUniformLocation(shader_solid, "model"), 1, GL_TRUE, np.asarray(model)) glDrawElements(GL_TRIANGLES, len(indices1), GL_UNSIGNED_INT, None) glBindVertexArray(0) # Big Cube glBindVertexArray(vao2) glUseProgram(shader_basic_lighting) model = glm.identity(4) model = glm.translate(glm.vec3(.0, 0.5, .0)) * model # model = model * glm.rotate(1.0 * np.pi * time, glm.vec3(1, 1, 0.2)) glUniform3fv(glGetUniformLocation(shader_basic_lighting, "light_color"), 1, light_color) glUniform3fv(glGetUniformLocation(shader_basic_lighting, "light_pos"), 1, light_position) glUniform3fv(glGetUniformLocation(shader_basic_lighting, "object_color"), 1, glm.vec3(1, .5, .31)) glUniform3fv(glGetUniformLocation(shader_basic_lighting, "view_pos"), 1, cam1.position) glUniformMatrix4fv(glGetUniformLocation(shader_basic_lighting, "view"), 1, GL_TRUE, np.asarray(view)) glUniformMatrix4fv(glGetUniformLocation(shader_basic_lighting, "projection"), 1, GL_FALSE, np.asarray(projection)) glUniformMatrix4fv(glGetUniformLocation(shader_basic_lighting, "model"), 1, GL_TRUE, np.asarray(model)) glDrawArrays(GL_TRIANGLES, 0, 36) glBindVertexArray(0) # Small cube glBindVertexArray(vao2) model = glm.identity(4) model = model * glm.translate(glm.vec3(.75, .95, 0)) model = model * glm.rotate(3.0 * np.pi * time, glm.vec3(1, -.2, 0.8)) model = model * glm.scale(glm.vec3(.1, .1, 0.2)) glUniform3fv(glGetUniformLocation(shader_basic_lighting, "light_color"), 1, light_color) glUniform3fv(glGetUniformLocation(shader_basic_lighting, "light_pos"), 1, light_position) glUniform3fv(glGetUniformLocation(shader_basic_lighting, "object_color"), 1, glm.vec3(1, 0, 0)) glUniform3fv(glGetUniformLocation(shader_basic_lighting, "view_pos"), 1, cam1.position) glUniformMatrix4fv(glGetUniformLocation(shader_basic_lighting, "view"), 1, GL_TRUE, np.asarray(view)) glUniformMatrix4fv(glGetUniformLocation(shader_basic_lighting, "projection"), 1, GL_FALSE, np.asarray(projection)) glUniformMatrix4fv(glGetUniformLocation(shader_basic_lighting, "model"), 1, GL_TRUE, np.array(model)) glDrawArrays(GL_TRIANGLES, 0, 36) glBindVertexArray(0) # Lamp glUseProgram(shader_solid) glBindVertexArray(vao_lamp) model = glm.translate(light_position) model = model * glm.scale(glm.vec3(.2, .2, .2)) glUniform3fv(glGetUniformLocation(shader_solid, "solid_color"), 1, glm.vec3(1, 1, 1)) glUniformMatrix4fv(glGetUniformLocation(shader_solid, "view"), 1, GL_TRUE, np.asarray(view)) glUniformMatrix4fv(glGetUniformLocation(shader_solid, "projection"), 1, GL_FALSE, np.asarray(projection)) glUniformMatrix4fv(glGetUniformLocation(shader_solid, "model"), 1, GL_TRUE, np.asarray(model)) glDrawElements(GL_TRIANGLES, len(indices3), GL_UNSIGNED_INT, None) glBindVertexArray(0)
def display_quadrado(indiceVAO, translatarX, translatarY, translatarZ, escalarX, escalarY, escalarZ): gl.glBindVertexArray(VAO[indiceVAO]) # Cria matrizes de transformação matriz_transformacao = glm.identity(glm.mat4) # Cria matriz identidade # Quanto eu quero transladar em cada eixo vetor_translacao = glm.vec3(translatarX, translatarY, translatarZ) matriz_transformacao = glm.translate(matriz_transformacao, vetor_translacao) # Aumentar o tamanho do quadrado (escala) #escalar = 3.0 # Aplica um mesmo valor de escala em todos os eixos vetor_escala = glm.vec3(escalarX, escalarY, escalarZ) identidade = glm.mat4(1.0) matriz_escala = glm.scale(identidade, vetor_escala) matriz_transformacao = matriz_transformacao * matriz_escala # Localizacao da variavel Uniform matriz transformacao no vertex shader transformacao_loc = gl.glGetUniformLocation(shaderProgram, "transformacao") # Copia os dados da matriz de transformacao para matriz Uniform dentro do vertex shader gl.glUniformMatrix4fv(transformacao_loc, 1, gl.GL_FALSE, glm.value_ptr(matriz_transformacao)) quant_vertices = 6 gl.glDrawArrays(gl.GL_TRIANGLES, 0, quant_vertices) gl.glBindVertexArray(0) # Desvincula o VAO
def render(self, shadersDict): for entity in shadersDict: shadersDict[entity][0].use() e = entity model = entity.model glBindVertexArray(model.vao) transform = glm.identity(glm.mat4x4) transform = glm.translate(transform, glm.vec3(e.pos.x, e.pos.y, e.pos.z)) transform = glm.rotate(transform, glm.radians(e.angle_x), glm.vec3(1, 0, 0)) # x-axis transform = glm.rotate(transform, glm.radians(e.angle_y), glm.vec3(0, 1, 0)) # y-axis transform = glm.rotate(transform, glm.radians(e.angle_z), glm.vec3(0, 0, 1)) # z-axis transform = glm.scale(transform, glm.vec3(e.scale.x, e.scale.y, e.scale.z)) shadersDict[entity][0].setMatrix4f("mat_transform", transform) if shadersDict[entity][1]: glDrawElements(GL_TRIANGLES, model.indices_len, GL_UNSIGNED_INT, None) else: glDrawArrays(GL_TRIANGLES, 0, model.vertex_count)
def getView(self): self.viewMatrix = glm.identity(glm.mat4x4) self.viewMatrix = glm.rotate(self.viewMatrix, glm.radians(self.pitch), glm.vec3(1, 0, 0)) # x-axis self.viewMatrix = glm.rotate(self.viewMatrix, glm.radians(self.yaw), glm.vec3(0, 1, 0)) # y-axis self.viewMatrix = glm.rotate(self.viewMatrix, glm.radians(self.roll), glm.vec3(0, 0, 1)) # z-axis self.offsetCamera = glm.vec3(-self.x, -self.y, -self.z) self.viewMatrix = glm.translate(self.viewMatrix, self.offsetCamera) return self.viewMatrix
def abs_translate(self, x, y, z): """ Move the model by updating the model matrix ignoring object stretch :return: """ self.move_pos(x, y, z) self.model += glm.translate(glm.identity(glm.mat4), glm.vec3(x, y, z))
def __init__(self, positions, normals, indices_pos, indices_norm, modelMat=glm.identity(glm.mat4), color=(1.0, 1.0, 1.0)): Geometry.__init__(self, modelMat) self.m_gpuPos = vki.device_vector_from_numpy(positions) self.m_gpuNorm = vki.device_vector_from_numpy(normals) self.m_gpuIndPos = vki.device_vector_from_numpy(indices_pos) self.m_gpuIndNorm = vki.device_vector_from_numpy(indices_norm) self.m_blas = vki.BaseLevelAS(self.m_gpuIndPos, self.m_gpuPos) vert0 = positions[0] self.m_aabb = np.array( [vert0[0], vert0[1], vert0[2], vert0[0], vert0[1], vert0[2]], dtype=np.float32) for vert in positions: self.m_aabb[0] = min(self.m_aabb[0], vert[0]) self.m_aabb[1] = min(self.m_aabb[1], vert[1]) self.m_aabb[2] = min(self.m_aabb[2], vert[2]) self.m_aabb[3] = max(self.m_aabb[3], vert[0]) self.m_aabb[4] = max(self.m_aabb[4], vert[1]) self.m_aabb[5] = max(self.m_aabb[5], vert[2]) self.d_normMat = vki.SVMat4x4(self.m_normMat) self.d_color = Spectrum(color) self.m_cptr = SVCombine_Create( { 'indices': self.m_gpuIndNorm, 'normals': self.m_gpuNorm, 'normalMat': self.d_normMat, 'color': self.d_color }, ''' void closethit(in Comb_#hash# self, int primitiveId, in vec3 barycentrics, inout {HitInfo_Lambert} hitinfo) {{ uint i0 = get_value(self.indices, 3 * primitiveId); uint i1 = get_value(self.indices, 3 * primitiveId + 1); uint i2 = get_value(self.indices, 3 * primitiveId + 2); vec3 norm0 = get_value(self.normals, i0); vec3 norm1 = get_value(self.normals, i1); vec3 norm2 = get_value(self.normals, i2); vec3 normal = norm0 * barycentrics.x + norm1 * barycentrics.y + norm2 * barycentrics.z; normal = normalize((self.normalMat * vec4(normal, 0.0)).xyz); hitinfo.lambert.color = self.color; hitinfo.normal = normal; }} '''.format(HitInfo_Lambert=Name_HitInfo_Lambert))
def __init__(self, center, r, color, intensity): modelMat = glm.identity(glm.mat4) modelMat = glm.translate(modelMat, glm.vec3(center)) modelMat = glm.scale(modelMat, glm.vec3(r, r, r)) Sphere.__init__(self, modelMat) self.m_r = r self.d_center_radius = vki.SVVec4(glm.vec4(center[0],center[1],center[2], r)) self.d_intensity = Spectrum(glm.vec3(color)*intensity) self.m_cptr = SVCombine_Create({'center_radius': self.d_center_radius, 'intensity': self.d_intensity }, ''' void closethit(in Comb_#hash# self, in vec3 hitpoint, inout {HitInfo_UniformEmissive} hitinfo) {{ hitinfo.intensity = self.intensity; }} Spectrum sample_l(in Comb_#hash# self, in vec3 ip, inout RNGState state, inout vec3 dirToLight, inout float distance, inout float pdfw) {{ vec3 dir = self.center_radius.xyz - ip; float dis2center = length(dir); dir *= 1.0/dis2center; float factor = (dis2center - self.center_radius.w)/dis2center; float r1 = rand01(state); float r2 = rand01(state) * radians(360.0); vec3 a, b; if (abs(dir.x)>0.8) a = vec3(0.0, 1.0, 0.0); else a = vec3(1.0, 0.0, 0.0); a = normalize(cross(a, dir)); b = cross(a, dir); float v_z = 1.0 - r1 * factor; float v_xy = sqrt(1.0 - v_z*v_z); float v_x = v_xy * cos(r2); float v_y = v_xy * sin(r2); vec3 offset_dir = a*v_x + b*v_y - v_z*dir; vec3 pos = self.center_radius.xyz + offset_dir *self.center_radius.w; dirToLight = pos - ip; distance = length(dirToLight); dirToLight *= 1.0/distance; float p = 1.0/(radians(360.0)*self.center_radius.w*self.center_radius.w*factor); pdfw = p*distance*distance/dot(dirToLight, -offset_dir); return self.intensity; }} '''.format(HitInfo_UniformEmissive = Name_HitInfo_UniformEmissive))
def set_view_matrices(self): if self.field_of_view == self.FIELD_OF_VIEW_MIN: # Orthogonal view if self.constant_z_near > 0: self.z_near = self.constant_z_near else: self.z_near = self.distance - 3.0 * self.bounding_box.GetMaxExtent( ) if self.constant_z_far > 0: self.z_far = self.constant_z_far else: self.z_far = self.distance + 3.0 * self.bounding_box.GetMaxExtent( ) self.projection_matrix = np.array(glm.ortho( -self.aspect * self.view_ratio, self.aspect * self.view_ratio, -self.view_ratio, self.view_ratio, self.z_near, self.z_far), dtype=np.float32) else: # Perspective View if self.constant_z_near > 0: self.z_near = self.constant_z_near else: self.z_near = max( 0.01 * self.bounding_box.GetMaxExtent(), self.distance - 3.0 * self.bounding_box.GetMaxExtent()) if self.constant_z_far > 0: self.z_far = self.constant_z_far else: self.z_far = max( 0.01 * self.bounding_box.GetMaxExtent(), self.distance + 3.0 * self.bounding_box.GetMaxExtent()) self.projection_matrix = np.array(glm.perspective( glm.radians(self.field_of_view), self.aspect, self.z_near, self.z_far), dtype=np.float32) # scale = np.matrix(((1, 0, 0, 0), (0, 1, 0, 0), (0, 0, self.scaleZ, 0), (0, 0, 0, 1)), np.float32) # rotZ = np.array(((c, s, 0, 0), (-s, c, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1)), np.float32) # rotY = np.matrix(((0, 0, 1, 0), (0, 1, 0, 0), (-1, 0, 0, 0), (0, 0, 0, 1)), np.float32) # trans = np.matrix(((1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, (self.near - self.far) / 2, 1)), np.float32) self.eye = glm.vec3(self.eye[0], self.eye[1], self.eye[2]) self.look_at = glm.vec3(self.lookat[0], self.lookat[1], self.lookat[2]) self.view_matrix = np.array(glm.lookAt(self.eye, self.look_at, self.up), dtype=np.float32) self.model_matrix = np.array(glm.identity(glm.mat4), dtype=np.float32) # self.model_matrix = np.array(glm.rotate(glm.identity(glm.mat4), glm.radians(-55.0), glm.vec3(1.0, 0.0, 0.0)), dtype=np.float32) mv_matrix = np.matmul(self.model_matrix, self.view_matrix) self.MVP_matrix = np.matmul(mv_matrix, self.projection_matrix)
def __init__(self, modelMat=glm.identity(glm.mat4), color=(1.0, 1.0, 1.0)): Sphere.__init__(self, modelMat) self.d_normMat = vki.SVMat4x4(self.m_normMat) self.d_color = Spectrum(color) self.m_cptr = SVCombine_Create( { 'normalMat': self.d_normMat, 'color': self.d_color }, ''' void closethit(in Comb_#hash# self, in vec3 hitpoint, inout {HitInfo_Lambert} hitinfo) {{ hitinfo.lambert.color = self.color; hitinfo.normal = normalize((self.normalMat * vec4(hitpoint, 0.0)).xyz); }} '''.format(HitInfo_Lambert=Name_HitInfo_Lambert))
def __init__(self, texId, transform=glm.identity(glm.mat3)): self.m_texId = vki.SVInt32(texId) self.m_trans = vki.SVMat3x3(transform) self.m_cptr = SVCombine_Create( { 'texId': self.m_texId, 'transform': self.m_trans }, ''' Spectrum get_sky_color(in Comb_#hash# sky, in vec3 dir) { vec3 direction = sky.transform*dir; Spectrum col; from_rgb(col, texture(arr_cubemap[sky.texId], direction).rgb); return col; } ''')
def render_scene(time, cam1, view, projection): glClearColor(.8, .12, 0.32, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # Create meshes points1, normals1 = generate_height_map(nw=8, nl=8, width=4, length=4, t=1.5*time, zscale=0.6) points3, indices3 = box() vao1, vbo1, ebo1 = create_vertex_array2(coords=points1, colors=normals1) vao_lamp, _, _ = create_vertex_array2(coords=points3, indices=indices3) # Light source: lamp light_color = glm.vec3(1, 1, 1) light_position = glm.vec3(np.cos(time), 1., np.sin(time)) # Height map glBindVertexArray(vao1) glUseProgram(shader_basic_lighting) model = glm.identity(4) # model = glm.translate(glm.vec3(.0, 0.5, .0)) * model model = model * glm.rotate(-np.pi/2, glm.vec3(1, 0, 0)) glUniform3fv(glGetUniformLocation(shader_basic_lighting, "light_color"), 1, light_color) glUniform3fv(glGetUniformLocation(shader_basic_lighting, "light_pos"), 1, light_position) glUniform3fv(glGetUniformLocation(shader_basic_lighting, "object_color"), 1, glm.vec3(1, .5, .31)) glUniform3fv(glGetUniformLocation(shader_basic_lighting, "view_pos"), 1, cam1.position) glUniformMatrix4fv(glGetUniformLocation(shader_basic_lighting, "view"), 1, GL_TRUE, np.asarray(view)) glUniformMatrix4fv(glGetUniformLocation(shader_basic_lighting, "projection"), 1, GL_FALSE, np.asarray(projection)) glUniformMatrix4fv(glGetUniformLocation(shader_basic_lighting, "model"), 1, GL_TRUE, np.asarray(model)) glDrawArrays(GL_TRIANGLES, 0, len(points1)) glBindVertexArray(0) # Lamp glUseProgram(shader_solid) glBindVertexArray(vao_lamp) model = glm.translate(light_position) model = model * glm.scale(glm.vec3(.2, .2, .2)) glUniform3fv(glGetUniformLocation(shader_solid, "solid_color"), 1, glm.vec3(1, 1, 1)) glUniformMatrix4fv(glGetUniformLocation(shader_solid, "view"), 1, GL_TRUE, np.asarray(view)) glUniformMatrix4fv(glGetUniformLocation(shader_solid, "projection"), 1, GL_FALSE, np.asarray(projection)) glUniformMatrix4fv(glGetUniformLocation(shader_solid, "model"), 1, GL_TRUE, np.asarray(model)) glDrawElements(GL_TRIANGLES, len(indices3), GL_UNSIGNED_INT, None) glBindVertexArray(0)
def render_scene(time, cam1, view, projection): glClearColor(.8, .12, 0.32, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # Create meshes points3, indices3 = box() vao_lamp = VAO(attributes=[points3], indices=indices3) # Light source: lamp light_color = glm.vec3(1, 1, 1) light_position = glm.vec3(3*np.cos(time), 2., 3*np.sin(time)) # Height map # glBindVertexArray(vao1) vao1.bind() glUseProgram(shader_flat_shading) model = glm.identity(4) # model = glm.translate(glm.vec3(.0, 0.5, .0)) * model model = model * glm.rotate(-np.pi/2, glm.vec3(1, 0, 0)) glUniform1f(glGetUniformLocation(shader_flat_shading, "time"), time); glUniform3fv(glGetUniformLocation(shader_flat_shading, "light_color"), 1, light_color) glUniform3fv(glGetUniformLocation(shader_flat_shading, "light_pos"), 1, light_position) glUniform3fv(glGetUniformLocation(shader_flat_shading, "object_color"), 1, glm.vec3(1, .5, .31)) glUniform3fv(glGetUniformLocation(shader_flat_shading, "view_pos"), 1, cam1.position) glUniformMatrix4fv(glGetUniformLocation(shader_flat_shading, "view"), 1, GL_TRUE, np.asarray(view)) glUniformMatrix4fv(glGetUniformLocation(shader_flat_shading, "projection"), 1, GL_FALSE, np.asarray(projection)) glUniformMatrix4fv(glGetUniformLocation(shader_flat_shading, "model"), 1, GL_TRUE, np.asarray(model)) glDrawArrays(GL_TRIANGLES, 0, len(points1)) glBindVertexArray(0) # Lamp glUseProgram(shader_solid) vao_lamp.bind() model = glm.translate(light_position) model = model * glm.scale(glm.vec3(.2, .2, .2)) glUniform3fv(glGetUniformLocation(shader_solid, "solid_color"), 1, glm.vec3(1, 1, 1)) glUniformMatrix4fv(glGetUniformLocation(shader_solid, "view"), 1, GL_TRUE, np.asarray(view)) glUniformMatrix4fv(glGetUniformLocation(shader_solid, "projection"), 1, GL_FALSE, np.asarray(projection)) glUniformMatrix4fv(glGetUniformLocation(shader_solid, "model"), 1, GL_TRUE, np.asarray(model)) glDrawElements(GL_TRIANGLES, len(indices3), GL_UNSIGNED_INT, None) glBindVertexArray(0)
def start(self): glfw.init() glfw.window_hint(glfw.FLOATING, glfw.TRUE) self.window = glfw.create_window(400, 400, "Hello, GLFW", None, None) glfw.make_context_current(self.window) self.pressing_keys = [] glfw.set_key_callback(self.window, self.on_key) self.initialize_gl() self.cam_pos = glm.vec3(0.0, 0.0, -5.0) self.model = glm.identity(glm.mat4) self.view = glm.lookAt(self.cam_pos, glm.vec3(0.0), glm.vec3(0.0, 1.0, 0.0)) self.projection = glm.perspective(glm.radians(94.0), 1.0 / 1.0, 0.1, 100.0) self.MVP = self.projection * self.view * self.model prev_t = glfw.get_time() while not glfw.window_should_close(self.window): self.gl.clear() if self.should_recompile_vao: self.recompile_vao() t = glfw.get_time() self.uniform({"u_time": t}) self.cpu_tick(t - prev_t) prev_t = t self.verts_cs.run() self.set_mvp() self.paint_gl() glfw.poll_events() glfw.swap_buffers(self.window)
def generate(self): self.shader = ShaderProgram("./shaders/vs.glsl", "./shaders/fs.glsl") self.shader.addUniform("screen_dim") self.shader.addUniform("mat_transform") self.shader.addUniform("mat_projection") self.shader.addUniform("mat_view") self.cubeShader = ShaderProgram("./shaders/cube_vs.glsl", "./shaders/cube_fs.glsl") self.cubeShader.addUniform("mat_transform") self.cubeShader.addUniform("mat_projection") self.cubeShader.addUniform("mat_view") self.lightShader = ShaderProgram("./shaders/light_vs.glsl", "./shaders/light_fs.glsl") self.lightShader.addUniform("mat_transform") self.lightShader.addUniform("mat_projection") self.lightShader.addUniform("mat_view") # ** every shader must be added list of shader called shaders self.shaders = [self.shader, self.cubeShader, self.lightShader] self.meshes = [] self.renderer = Renderer(self.shaders) self.pos = glm.vec2(0, 0) self.angle = 0 self.transform = glm.identity(glm.mat3x3) self.model = Mesh((-1.0, -0.0), (.3, .3), "./res/image.png") self.cube_model = Cube() self.light_model = Light() # self.light_model = Light(0.5) self.e = Entity(self.model, Vector3(0, 0, 0), Vector3(0.0, 0.0, 0.0), Vector3(1, 1, 1)) self.cube_entity = Entity(self.cube_model, Vector3(-1, -1, -1), Vector3(0.0, 0.0, 0.0), Vector3(1, 1, 1)) self.light_entity = Entity(self.light_model, Vector3(-0.5, -0.5, -0.5), Vector3(0.0, 0.0, 0.0), Vector3(0.2, 0.2, 0.2)) self.shadersDict = { self.e: [self.shader, False], self.cube_entity: [self.cubeShader, True], self.light_entity: [self.lightShader, True] } precision = 3 self.cube_entities = [] r = 3 for i in range(10): x = round(uniform(-r, r), precision) y = round(uniform(-r, r), precision) z = round(uniform(-r, r), precision) self.cube_entities.append( Entity(self.cube_model, Vector3(x, y, z), Vector3(0.0, 0.0, 0.0), Vector3(0.5, 0.5, 0.5))) self.shadersDict[self.cube_entities[i]] = [self.cubeShader, True] # self.cube_entities = Entity(self.cube_model, Vector3(0,0,0), Vector3(0.0,0.0,0.0), Vector3(1,1,1)) self.camera = Camera()
sphere_light0 = fri.SphereLight((-5.0, 20.0, -5.0), 0.5, (0.5, 1.0, 0.5), 1500.0) scene.add_object(sphere_light0) sphere_light1 = fri.SphereLight((5.0, 20.0, 5.0), 0.5, (1.0, 0.5, 0.5), 1500.0) scene.add_object(sphere_light1) ''' dis_light = fri.DistanceLight((-1.0, 4.0, -1.0), (1.0, 1.0, 0.8), 5.0) scene.add_object(dis_light) ''' ''' sun_light = fri.SunLight((-1.0, 4.0, -1.0), 0.05, (1.0, 1.0, 0.8), 750.0) scene.add_object(sun_light) ''' identity = glm.identity(glm.mat4) model = glm.translate(identity, glm.vec3(0.0, -1000.0, 0.0)) model = glm.scale(model, glm.vec3(1000.0, 1000.0, 1000.0)) sphere = fri.LambertSphere(model, (0.5, 0.5, 0.5)) scene.add_object(sphere) model = glm.translate(identity, glm.vec3(0.0, 1.0, 0.0)) model = glm.scale(model, glm.vec3(0.03, 0.03, 0.03)) spider = fri.LambertMesh(positions, normals, vertex_inds, normal_inds, model, (0.1, 0.04, 0.02)) scene.add_object(spider) model = glm.translate(identity, glm.vec3(-4.0, 1.0, 3.0)) sphere = fri.LambertSphere(model, (0.4, 0.2, 0.1)) scene.add_object(sphere)
import VkInline as vki import numpy as np from PIL import Image import glm width = 800 height = 400 aabb_unit_sphere = np.array([-1.0, -1.0, -1.0, 1.0, 1.0, 1.0], dtype=np.float32) d_aabb_unit_sphere = vki.device_vector_from_numpy(aabb_unit_sphere) blas_unit_sphere = vki.BaseLevelAS(gpuAABB=d_aabb_unit_sphere) transform = glm.identity(glm.mat4) transform = glm.translate(transform, glm.vec3(0.0, 0.0, -1.0)) transform = glm.scale(transform, glm.vec3(0.5, 0.5, 0.5)) tlas = vki.TopLevelAS([[(blas_unit_sphere, transform)]]) darr_out = vki.SVVector('vec3', width * height) raytracer = vki.RayTracer(['arr_out', 'width', 'height'], ''' struct Payload { float t; vec3 color; }; layout(location = 0) rayPayloadEXT Payload payload; void main() { int x = int(gl_LaunchIDEXT.x);
colors2 = np.array([ 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, ], dtype=np.float32) vao2, vbo2, ebo2 = create_vertex_array2(coords=points2, colors=colors2, indices=indices2) shader1 = shaders.vertex_color() projection = glm.identity(4) projection = glm.perspective(80.0, 600. / 600., .1, 100.0) # projection = glm.create_perspective_projection_matrix(45.0, 600. / 600., .1, 100.0, dtype=np.float32) w, h = glfwGetFramebufferSize(window) glViewport(0, 0, w, h) # glDepthRange(-10, 10) glEnable(GL_DEPTH_TEST) # draw only if the shape is closer to the viewer glDepthFunc(GL_LESS) # smaller means closer # glPolygonMode(GL_FRONT_AND_BACK, GL_LINE) # Wireframe while not glfwWindowShouldClose(window): time = glfwGetTime() glClearColor(0.6, 0.6, 0.8, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # glClear(GL_COLOR_BUFFER_BIT)
def main(): window = create_window() shader_program, shaders, uniforms = setup_shaders() vao, vbo, ebo = setup_vertices() texture_index_diffuse = 0 texture_diffuse = load_texture('data/Gravel020_1K_Color.jpg', texture_index_diffuse) texture_index_normal = 1 texture_normal = load_texture('data/Gravel020_1K_Normal.jpg', texture_index_normal) # render setup proj_mat = glm.perspective(45.0, SCREEN_WIDTH / SCREEN_HEIGHT, 0.01, 100) view_mat = glm.lookAt(glm.vec3(0.8, 0.0, 0.8), glm.vec3(0, 0, 0), glm.vec3(0, 0, 1)) model_mat = glm.translate(glm.identity(glm.fmat4), glm.vec3(-1, 0, -1)) normal_mat = glm.inverse(model_mat * glm.transpose(view_mat)) render_parameters = {} # key callback def handle_key(window, key, scancode, action, mods): if action == glfw.PRESS: if key == glfw.KEY_ESCAPE: glfw.set_window_should_close(window, True) glfw.set_key_callback(window, handle_key) # loop until the user closes the window while not glfw.window_should_close(window): # render gl.glClearColor(0, 0, 0, 1) gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glUseProgram(shader_program) gl.glUniform1i(uniforms[DIFFUSE_TEXTURE_UNIFORM], texture_index_diffuse) gl.glUniform1i(uniforms[NORMAL_MAP_UNIFORM], texture_index_normal) gl.glActiveTexture(gl.GL_TEXTURE0 + texture_index_diffuse) gl.glBindTexture(gl.GL_TEXTURE_2D, texture_diffuse) gl.glActiveTexture(gl.GL_TEXTURE0 + texture_index_normal) gl.glBindTexture(gl.GL_TEXTURE_2D, texture_normal) gl.glUniformMatrix4fv(uniforms[PROJ_MAT_UNIFORM], 1, gl.GL_FALSE, glm.value_ptr(proj_mat)) gl.glUniformMatrix4fv(uniforms[VIEW_MAT_UNIFORM], 1, gl.GL_FALSE, glm.value_ptr(view_mat)) gl.glUniformMatrix4fv(uniforms[MODEL_MAT_UNIFORM], 1, gl.GL_FALSE, glm.value_ptr(model_mat)) gl.glUniformMatrix4fv(uniforms[NORMAL_MAT_UNIFORM], 1, gl.GL_FALSE, glm.value_ptr(normal_mat)) gl.glBindVertexArray(vao) gl.glDrawElements(gl.GL_TRIANGLES, 6, gl.GL_UNSIGNED_INT, None) gl.glBindVertexArray(0) # shader logs for i, shader in enumerate(shaders): shader_log = gl.glGetShaderInfoLog(shader) if shader_log != '': print('vertex' if shader == 1 else 'fragment') print(shader_log) glfw.swap_buffers(window) glfw.poll_events() # gl.glReadBuffer(gl.GL_FRONT) # pixels = gl.glReadPixels(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, gl.GL_RGBA, gl.GL_FLOAT) # img = np.frombuffer(pixels, np.float32) # img = img.reshape((SCREEN_WIDTH, SCREEN_HEIGHT, -1)) # img = img[::-1, :] # img = Image.fromarray(np.uint8(img * 255)).convert('RGB') # cleanup gl.glDeleteVertexArrays(1, vao) gl.glDeleteBuffers(1, vbo) gl.glDeleteBuffers(1, ebo) gl.glDeleteTextures(texture_diffuse) gl.glDeleteTextures(texture_normal) gl.glDeleteProgram(shader_program) glfw.terminate()
# view = glm.look_at(pos=glm.vec3(np.sin(time)*rad, 1.5, np.cos(time)*rad), target=glm.vec3(0, 0, 0)) # projection = glm.create_perspective_projection_matrix(45., 600. / 600., .1, 100.0, dtype=np.float32) # View via user-controlled camera object view = cam1.get_view_matrix() projection = glm.create_perspective_projection_matrix(cam1.fov, 600. / 600., .1, 100.0, dtype=np.float32) # projection = glm.create_orthogonal_projection_matrix(-3, 3, -3, 3, 0.1, 100, dtype=np.float32) # Render objects # Ground glUseProgram(shader1) glUniformMatrix4fv(glGetUniformLocation(shader1, "view"), 1, GL_TRUE, np.asarray(view)) glUniformMatrix4fv(glGetUniformLocation(shader1, "projection"), 1, GL_FALSE, np.asarray(projection)) glUniform3fv(glGetUniformLocation(shader1, "solid_color"), 1, glm.vec3(0, 0, 1)) glBindVertexArray(vao1) model = glm.identity(4) model = glm.rotate(np.pi*0.5, glm.vec3(1, 0, 0)) * model glUniformMatrix4fv(glGetUniformLocation(shader1, "model"), 1, GL_TRUE, np.asarray(model)) glDrawElements(GL_TRIANGLES, len(indices2), GL_UNSIGNED_INT, None) glBindVertexArray(0) # Big Cube glUseProgram(shader2) glBindVertexArray(vao2) glUniformMatrix4fv(glGetUniformLocation(shader2, "view"), 1, GL_TRUE, np.asarray(view)) glUniformMatrix4fv(glGetUniformLocation(shader2, "projection"), 1, GL_FALSE, np.asarray(projection)) model = glm.identity(4) model = glm.translate(glm.vec3(.0, 0.5, .0)) * model # model = model * glm.rotate(1.0 * np.pi * time, glm.vec3(1, 1, 0.2)) glUniformMatrix4fv(glGetUniformLocation(shader2, "model"), 1, GL_TRUE, np.asarray(model)) glDrawElements(GL_TRIANGLES, len(indices2), GL_UNSIGNED_INT, None)
def __init__(self, shape3d): self.model = glm.identity(glm.mat4) self.external_mat = glm.identity(glm.mat4) self.shape3d = shape3d self.x = self.y = self.z = 0 self.x_stretch = self.y_stretch = self.z_stretch = 1