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
