def mousemove(handle, x1, y1):
nonlocal x0, y0
if glfw.get_mouse_button(window, 0):
dx = x1-x0
dy = y1-y0
self.camera.transform = glm.inverse(puregl.transform.orbit(glm.inverse(self.camera.transform), dx * 2, dy * 2))
x0, y0 = x1, y1
def _generate_nodeview_matrix2(
rsm_version: int, node: AbstractNode) -> Tuple[glm.mat4, glm.mat4]:
# Transformations which are inherited by children
local_transform_matrix = glm.mat4()
rsm_node = node.impl
# Scaling
if len(rsm_node.scale_key_frames) > 0:
local_transform_matrix = glm.scale(
local_transform_matrix,
glm.vec3(rsm_node.scale_key_frames[0].scale))
# Rotation
if len(rsm_node.rot_key_frames) > 0:
# Animated model
key_frame = rsm_node.rot_key_frames[0]
quaternion = glm.quat(key_frame.quaternion[3], key_frame.quaternion[0],
key_frame.quaternion[1], key_frame.quaternion[2])
local_transform_matrix *= glm.mat4_cast(quaternion)
else:
# Static model
local_transform_matrix = rag_mat4_mul(
local_transform_matrix, mat3tomat4(rsm_node.info.offset_matrix))
if node.parent:
parent_offset_matrix = mat3tomat4(
node.parent.impl.info.offset_matrix)
local_transform_matrix = rag_mat4_mul(
local_transform_matrix, glm.inverse(parent_offset_matrix))
# Translation
if rsm_version >= 0x203 and len(rsm_node.pos_key_frames) > 0:
key_frame = rsm_node.pos_key_frames[0]
position = glm.vec3(key_frame.position)
elif node.parent:
position = glm.vec3(rsm_node.info.offset_vector) - \
glm.vec3(node.parent.impl.info.offset_vector)
parent_offset_matrix = mat3tomat4(node.parent.impl.info.offset_matrix)
position = glm.vec3(
glm.inverse(parent_offset_matrix) * glm.vec4(position, 1.0))
else:
position = glm.vec3(rsm_node.info.offset_vector)
# Transformations which are applied only to this node
final_transform_matrix = copy.copy(local_transform_matrix)
# Reset translation transformation to `position`
final_transform_matrix[3] = glm.vec4(position, 1.0)
# Inherit transformations from ancestors
parent = node.parent
while parent:
final_transform_matrix = rag_mat4_mul(final_transform_matrix,
parent.local_transform_matrix)
parent = parent.parent
if node.parent:
parent_translation = glm.vec3(node.parent.final_transform_matrix[3])
final_transform_matrix[3] += glm.vec4(parent_translation, 0.0)
return (local_transform_matrix, final_transform_matrix)
def getCubeRay(self, wnd_pos):
ndc_xy = wnd_pos[0] * 2 / self.__vp_size[0] - 1, wnd_pos[
1] * 2 / self.__vp_size[1] - 1
cube_mv = self.__view * self.__model * self.__voxel_map.cube_model
cube_space = glm.inverse(cube_mv)
inverse_prj = glm.inverse(self.__proj)
view_dir1_h = inverse_prj * glm.vec4(*ndc_xy, 1, 1)
view_dir0_h = inverse_prj * glm.vec4(*ndc_xy, -1, 1)
view_dir = view_dir1_h.xyz / view_dir1_h.w - view_dir0_h.xyz / view_dir0_h.w
cube_origin = cube_space[3].xyz
cube_dir = glm.mat3(cube_space) * view_dir
return (cube_origin, cube_dir)
def __init__(self,
scene,
width=1280,
height=720,
title="Viewer",
floating=False,
background_color=(0, 0, 0, 1)):
# window
self.width = width
self.height = height
self.scene = scene
self.title = title
self._floating = floating
self.background_color = background_color
# threading
self.thread = None
self.lock = None
# renderer
from editor.render.graphics import PerspectiveCamera
self.camera = PerspectiveCamera(glm.mat4(1), glm.radians(39.6),
self.width / self.height, 0.1, 30)
self.camera.transform = glm.inverse(
glm.lookAt(glm.vec3(2, 3, 6), glm.vec3(0, 0, 0), glm.vec3(0, 1,
0)))
self.renderer = DeferredPBRRenderer(self.width, self.height)
def voxel_to_ray(self, x, y):
"""Return tuple with ray-origin and normalized ray-direction for input render-res x, y"""
st = glm.vec2(x / self.width, y / self.height) * 2. - 1.
if self.is_perspective():
near, far = -self.near, -self.far
else:
near, far = -1, 1
pos = self.inverse_projection_matrix * glm.vec4(st.x, st.y, near, 1)
pos /= pos.w
dirf = self.inverse_projection_matrix * glm.vec4(st.x, st.y, far, 1)
dirf /= dirf.w
dir = glm.normalize(glm.vec3(dirf - pos))
t = glm.inverse(self.transformation_matrix)
ro, rd = glm.vec3(t * pos), glm.normalize(
glm.vec3(t * glm.vec4(dir, 0)))
if self.is_perspective():
rd = -rd
if 0:
def _v(v):
return "(%s)" % ", ".join("%s" % round(x, 2) for x in v)
print("near", _v(pos), "far", _v(dirf), "ro", _v(ro), "rd", _v(rd))
return ro, rd
def __init__(self,
mode=1,
position=glm.vec3(1, 0, 0),
target=glm.vec3(0),
worldUp=glm.vec3(0, 1, 0)):
# settings
self.fpsRotationSpeed = 0.005 # speed with which the camera rotates in fps mode
self.moveSpeed = 0.125 # speed with which the camera moves in fps mode
self.tbRotationSpeed = 0.015 # speed with which the camera rotates in trackball mode
self.panSpeed = 0.006 # speed with which the camera pans in trackball mode
self.zoomSpeed = 0.25 # speed with which the camera zooms (used for Z axis in trackball mode)
self.enableAllControls = False # enable movement while in trackball mode and pan/zoom while in fps mode
self.movementSmoothing = 0.25 # higher numbers result in stronger smoothing and delayed movement
self.rotationSmoothing = 0.3 # higher numbers result in stronger smoothing and delayed rotation
self.worldUp = worldUp # worlds up vector
self.mode = mode # 0 = trackball, 1 = first person
self.movementSpeedMod = 1.0 # temporary modified movement speed, will be reset every frame
# cameras internal state (DO NOT WRITE)
self._movementInput = glm.vec3(0)
self._rotationInput = glm.vec2(0)
self._desiredTransform = Transform(
) # Transform(position) # desired transform based on inputs
self._desiredTargetDistance = 0 # desired distance along the front vector where the center for trackball mode lives
self._currentTransform = Transform(
) #Transform(position) # transform object describing orientation and position of camera
self._currentTargetDistance = 0 # distance along the front vector where the center for trackball mode lives
self.setPosition(position)
self.setTarget(target)
# variables depending on state, they are automatically updated when calling the Camera.update() (DO NOT WRITE, only read)
self.modelMatrix = self._currentTransform.mat4()
self.viewMatrix = glm.inverse(self.modelMatrix)
def pan(self, old_pos, new_pos):
inv_view = glm.inverse(self.view)
view_pos = glm.vec3(inv_view[3])
los = -glm.vec3(inv_view[2])
up = glm.vec3(inv_view[1])
wnd_from = glm.vec3(old_pos[0], old_pos[1], 1)
wnd_to = glm.vec3(new_pos[0], new_pos[1], 1)
vp_rect = glm.vec4(0, 0, self.width, self.height)
world_from = glm.unProject(wnd_from, self.view, self.proj, vp_rect)
world_to = glm.unProject(wnd_to, self.view, self.proj, vp_rect)
dir_from = glm.normalize(world_from - view_pos)
dir_to = glm.normalize(world_to - view_pos)
rot_axis = glm.normalize(glm.cross(dir_from, dir_to))
rot_angle = math.acos(glm.dot(dir_from, dir_to))
rotate = glm.rotate(glm.mat4(1), rot_angle, rot_axis)
model_rot = glm.translate(glm.mat4(1),
view_pos) * rotate * glm.translate(
glm.mat4(1), -view_pos)
self.view = self.view * model_rot
def draw_scene(self, shader):
# ----------------------------------------------------------------------
# 1. Setup shader uniforms
# ----------------------------------------------------------------------
shader.use()
# model view projection
model = glm.mat4(1.0)
shader.set_mat4('model', np.asarray(model))
view = self.camera.get_view()
shader.set_mat4('view', np.asarray(view))
ortho = self.camera.get_projection()
shader.set_mat4('projection', np.asarray(ortho))
# lighting
lightPos = np.array(self.light_pos)
shader.set_vec3('lightPos', lightPos)
shader.set_vec3('lightColor', np.array([1.0, 1.0, 1.0], 'f'))
cameraPos = glm.vec3(glm.column(glm.inverse(view), 3))
shader.set_vec3('viewPos', np.asarray(cameraPos))
# ----------------------------------------------------------------------
# 2. Draw scene
# ----------------------------------------------------------------------
glLineWidth(2)
self.system.draw(shader)
self.system.collider.draw(shader)
self.draw_grid(shader)
def render(
self,
projection: glm.mat4,
transformation: glm.mat4,
):
glEnable(GL_CULL_FACE)
glEnable(GL_DEPTH_TEST)
transforms = np.array([m.to_list() for m in self.part_transforms], dtype="float32")
transforms = transforms.flatten()
self.drawable.shader.set_uniform("u_projection", projection)
self.drawable.shader.set_uniform("u_transformation", transformation)
self.drawable.shader.set_uniform("u_transformation_inv", glm.inverse(transformation))
self.drawable.shader.set_uniform("u_part_transformation[0]", transforms)
if not self.instance_buffers:
self.drawable.prepare()
vao: VertexArrayObject = self.drawable.vao
mat = glm.mat4(1)
for i in range(4):
self.instance_buffers.append(
vao.create_attribute_buffer(
attribute_location=self.drawable.shader.attribute("a_instance_transform").location + i,
num_dimensions=4,
Type=GLfloat,
#values=[1.,0.,0.,0., 0.,1.,0.,0., 0.,0.,1.,0., 0.,0.,0.,1.],
values=mat[i],
stride=ctypes.sizeof(GLfloat) * 16,
offset=ctypes.sizeof(ctypes.c_float) * 4 * i,
divisor=1,
)
)
self.drawable.draw(num_instances=None)
def MoveOnLineOfSight(self, cursor_pos, delta):
# get viewport rectangle
#vp_rect = self.VpRect()
# get view, projection and window matrix
proj, inv_proj = self.ProjectionMat()
view, inv_view = self.ViewMat()
wnd, inv_wnd = self.WindowMat()
# get world space position on view ray
pt_wnd = glm.vec3(*cursor_pos, 1.0)
#pt_world = glm.unProject(pt_wnd, view, proj, vp_rect)
pt_h_world = inv_view * inv_proj * inv_wnd * glm.vec4(*pt_wnd, 1)
pt_world = glm.vec3(pt_h_world) / pt_h_world.w
# get view position
eye = glm.vec3(inv_view[3])
# get "zoom" direction and amount
ray_cursor = glm.normalize(pt_world - eye)
# translate view position and update view matrix
inv_view = glm.translate(glm.mat4(1), ray_cursor * delta) * inv_view
# return new view matrix
return glm.inverse(inv_view), True
def update(self, dt):
# print (self.throttle_up - self.throttle_down - .2)
accel = self.throttle_up - self.throttle_down
if not self.collider.platform:
accel -= .2
if accel:
self.collider.sleeping = False
self.collider.force.y += accel * self.vertical_force
self.animate(self.ix, self.iy, (self.throttle_up - self.throttle_down),
self.collider.platform, dt)
if not self.collider.platform and 0 in self.occupied_seats:
if abs(self.collider.vel.y) > self.max_y_vel:
self.collider.vel.y = cmp(self.collider.vel.y,
0) * self.max_y_vel
rot_mat = glm.rotate(glm.mat4(1.0), glm.radians(90 - self.angle),
glm.vec3(0, 1, 0))
local_vel = rot_mat * glm.vec4(self.collider.vel, 1)
local_vel.x += self.ix * self.accel_force * dt
local_vel.z += self.iy * self.turn_force * dt
turn_input = util.angle_diff(
self.angle, 90 - self.engine.renderer.camera.yaw) * .1
turn_force = self.turn_force * turn_input
self.angle += turn_force * dt
local_vel.z *= 1 - self.side_friction * dt
local_vel.x = min(self.max_speed, max(self.min_speed, local_vel.x))
self.collider.vel = glm.vec3(glm.inverse(rot_mat) * local_vel).xyz
def CalcViewMatrix(self):
transfrom = glm.translate(glm.mat4(1), self.position)
transfrom = glm.rotate(transfrom, glm.radians(self.rotation),
glm.vec3(0, 0, 1))
self.viewMat = glm.inverse(transfrom)
self.VP = self.projectionMat * self.viewMat
def WindowMat(self):
vp_rect = self.VpRect()
inv_wnd = glm.translate(glm.mat4(1), glm.vec3(-1, -1, -1))
inv_wnd = glm.scale(inv_wnd, glm.vec3(2 / vp_rect[2], 2 / vp_rect[3],
2))
inv_wnd = glm.translate(inv_wnd, glm.vec3(vp_rect[0], vp_rect[1], 0))
return glm.inverse(inv_wnd), inv_wnd
def getViewMatrix(self):
i = glm.mat4(1)
camTranslate = glm.translate(i, self.camPosition)
camPitch = glm.rotate(i, glm.radians( self.camRotation.x ), glm.vec3(1,0,0))
camYaw = glm.rotate(i, glm.radians( self.camRotation.y ), glm.vec3(0,1,0))
camRoll = glm.rotate(i, glm.radians( self.camRotation.z ), glm.vec3(0,0,1))
camRotate = camPitch * camYaw * camRoll
return glm.inverse( camTranslate * camRotate )
def _drawOrientationIndicator(self):
gloo.set_state(line_width=5)
# we want the rotation of the camera but not the translation
view = glm.inverse(glm.mat4_cast(self.cam._currentTransform.orientation))
view = glm.scale( view, glm.vec3(0.25))
self._oriProgram['projection'] = self._oriProjection
self._oriProgram['view'] = view
self._oriProgram.draw('lines')
def distance(self, other:"Transformation") -> float:
td = glm.distance(self.translation, other.translation)
sd = glm.distance(self.scale, other.scale)
qn : glm.Quat = glm.inverse(self.quaternion) # type: ignore
qn = qn * other.quaternion
if qn.w<0: qn = -qn
qd = glm.length(qn - glm.quat())
return td+sd+qd
def unproject(screen_point, mvp_matrix, width, height):
mvp_matrix_inv = np.array(glm.inverse(mvp_matrix), dtype=np.float32)
x = screen_point.x / width * 2.0 - 1.0
y = screen_point.y / height * 2.0 - 1.0
z = screen_point.z * 2.0 - 1.0
point = mvp_matrix_inv.dot(glm.vec4(x, y, z, 1.0))
if point[2] == 0.0:
return glm.vec4(0.0)
point /= point[2]
return glm.vec3(point[0], point[1], point[2])
def quaternion_of_rotation(rotation:glm.Mat3) -> glm.Quat:
"""
Note that R . axis = axis
RI = (R - I*999/1000)
Then RI . axis = axis/1000
Then det(RI) is going to be 1/1000 * at most 2 * at most 2
And if na is perp to axis, then RI.na = R.na - 999/1000.na, which is perp to axis
Then |R.na| < 2|na|
If RI' . RI = I, then consider v' = RI' . v for some v=(a*axis + b*na0 + c*na1)
(a'*axis + b'*na0 + c'*na1) = RI' . (a*axis + b*na0 + c*na1)
Then RI . (a'*axis + b'*na0 + c'*na1) = (a*axis + b*na0 + c*na1)
Then a'*RI.axis + b'*RI.na0 + c'*RI.na1 = a*axis + b*na0 + c*na1
Then a'/1000*axis + b'*(R.na0-0.999.na0) + c'*(R.na1-0.999.na1) = a*axis + b*na0 + c*na1
Then a = a'/1000, and
-0.999b' + b'cos(angle) + c'sin(angle) = b, etc
If we set |v| to be 1, then |v'| must be det(RI') = 1/det(RI) > 100
If angle is not close to zero, then a' / b' >> 1
This can be repeated:
v' = normalize(RI' . v)
v'' = normalize(RI' . v')
v''' = normalize(RI' . v'') etc
This gets closer and closer to the axis
"""
rot_min_id : glm.Mat3 = rotation - (0.99999 * glm.mat3()) # type: ignore
rot_min_id_i : glm.Mat3 = glm.inverse(rot_min_id) # type: ignore
for j in range(3):
v = glm.vec3()
v[j] = 1.
for i in range(10):
last_v = v
rid_i_v : glm.Vec3 = rot_min_id_i * v # type: ignore
v = glm.normalize(rid_i_v)
pass
axis = v
dist2 = glm.length2(v - last_v) # type: ignore
if dist2<0.00001: break
pass
w = glm.vec3([1.0,0,0])
if axis[0]>0.9 or axis[0]<-0.9: w = glm.vec3([0,1.0,0])
na0 : glm.Vec3 = glm.normalize(glm.cross(w, axis))
na1 : glm.Vec3 = glm.cross(axis, na0)
# Rotate w_perp_n around the axis of rotation by angle A
na0_r : glm.Vec3 = rotation * na0 # type: ignore
na1_r : glm.Vec3 = rotation * na1 # type: ignore
# Get angle of rotation
cos_angle = glm.dot(na0, na0_r)
sin_angle = -glm.dot(na0, na1_r)
angle = math.atan2(sin_angle, cos_angle)
# Set quaternion
return glm.angleAxis(angle, axis)
def getViewMatrix(self):
i = glm.mat4(1)
# View Matrix and Translation
camTranslate = glm.translate(i, self.camPos)
camPitch = glm.rotate(i, glm.radians(self.pitchCam), glm.vec3(1, 0, 0))
camYaw = glm.rotate(i, glm.radians(self.yawCam), glm.vec3(0, 1, 0))
camRoll = glm.rotate(i, glm.radians(self.rollCam), glm.vec3(0, 0, 1))
camRotate = camPitch * camYaw * camRoll
view = glm.inverse(camTranslate * camRotate)
return view
def derive_matrices(self) -> None:
btp = self.transformation.mat4()
self.ptb = glm.inverse(btp) # type: ignore
if self.parent is None:
self.mtb = glm.mat4(self.ptb)
pass
else:
self.mtb = self.ptb * self.parent.mtb
pass
for c in self.children:
c.derive_matrices()
pass
pass
def __init__(self, width=1280, height=720, title="puregl-viewer", floating=False):
self.width, self.height = width, height
self.title = title
self._floating = floating
self.events = {'on_setup':[], 'on_draw':[]}
# Handle window events
# -------------
self.camera = PerspectiveCamera(transform=glm.inverse(glm.lookAt(glm.vec3(1,1.5,4), glm.vec3(0,0,0), glm.vec3(0,1,0))),
fovy=glm.radians(48.5),
aspect=self.width/self.height,
near=0.1,
far=30)
def draw_scene(prog, projection_matrix, view_matrix):
"""Draw scen with a shader program"""
program.set_uniform(prog, 'projectionMatrix', projection_matrix)
program.set_uniform(prog, 'viewMatrix', view_matrix)
camera_pos = glm.inverse(view_matrix)[3].xyz
program.set_uniform(prog, 'cameraPos', camera_pos)
model_matrix = glm.translate(glm.mat4(1), (-1, 0.5, 0))
normal_matrix = glm.mat3(glm.transpose(glm.inverse(model_matrix)))
program.set_uniform(prog, 'modelMatrix', model_matrix)
program.set_uniform(prog, 'normalMatrix', normal_matrix)
imdraw.cube(prog)
model_matrix = glm.translate(glm.mat4(1), (1, 0, 0))
normal_matrix = glm.mat3(glm.transpose(glm.inverse(model_matrix)))
program.set_uniform(prog, 'modelMatrix', model_matrix)
program.set_uniform(prog, 'normalMatrix', normal_matrix)
imdraw.sphere(prog)
model_matrix = glm.mat4(1)
normal_matrix = glm.mat3(glm.transpose(glm.inverse(model_matrix)))
program.set_uniform(prog, 'modelMatrix', model_matrix)
program.set_uniform(prog, 'normalMatrix', normal_matrix)
imdraw.plane(prog)
def update(self, dt):
rot_mat = glm.rotate(glm.mat4(1.0), glm.radians(90 -self.angle), glm.vec3(0, 1, 0))
local_vel = rot_mat * glm.vec4(self.collider.vel, 1)
local_vel.x += self.ix * dt * 100
local_vel.z += self.iy * dt * 100
if self.ix:
turn_input = abs(self.ix) ** 1.2 * cmp(-self.ix, 0)
turn_force = abs(local_vel.x) * self.turn_force
self.angle += turn_force * turn_input * dt
local_vel.z *= 1 - self.side_friction * dt
local_vel.x = min(self.max_speed, max(self.min_speed, local_vel.x))
self.collider.vel = glm.vec3(glm.inverse(rot_mat) * local_vel).xyz
def intersect(self, ray, hit, tmin):
minverse = glm.inverse(self.matrix)
tdir4 = minverse * glm.vec4(ray.direction, 0.0)
tdir3 = tdir4.xyz
if tdir4.w != 0.0:
tdir3 = tdir3 / tdir4.w
torig4 = minverse * glm.vec4(ray.origin, 1.0)
torig3 = torig4.xyz / torig4.w
hit = self.primitive.intersect(Ray(torig3, tdir3), hit, tmin)
if hit:
hit.normal = (glm.transpose(minverse) *
glm.vec4(hit.normal, 1.0)).xyz
return hit
def render(self):
glClearColor(0.2, 0.2, 0.2, 1)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
i = glm.mat4(1)
#como las matrices vistas en Static rendering
# Model/Object matrix: translate * rotate * scale
translate = glm.translate(i, self.cubePos)
pitch = glm.rotate(i, glm.radians(0), glm.vec3(1, 0, 0))
yaw = glm.rotate(i, glm.radians(0), glm.vec3(0, 1, 0))
roll = glm.rotate(i, glm.radians(0), glm.vec3(0, 0, 1))
rotate = pitch * yaw * roll
scale = glm.scale(i, glm.vec3(1, 1, 1))
model = translate * rotate * scale
# View Matrix
# glm.lookAt( eye, center, up)
camTranslate = glm.translate(i, glm.vec3(0, 0, 3))
camPitch = glm.rotate(i, glm.radians(0), glm.vec3(1, 0, 0))
camYaw = glm.rotate(i, glm.radians(0), glm.vec3(0, 1, 0))
camRoll = glm.rotate(i, glm.radians(0), glm.vec3(0, 0, 1))
camRotate = camPitch * camYaw * camRoll
view = glm.inverse(camTranslate * camRotate)
if self.active_shader:
glUniformMatrix4fv(
glGetUniformLocation(self.active_shader, "model"), 1, GL_FALSE,
glm.value_ptr(model))
glUniformMatrix4fv(
glGetUniformLocation(self.active_shader, "view"), 1, GL_FALSE,
glm.value_ptr(view))
glUniformMatrix4fv(
glGetUniformLocation(self.active_shader, "projection"), 1,
GL_FALSE, glm.value_ptr(self.projection))
glBindVertexArray(self.VAO)
glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, None)
glBindVertexArray(0)
def render(self):
glClearColor(0.2, 0.2, 0.2, 1)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
i = glm.mat4(1)
translate = glm.translate(i, self.cube_position)
pitch = glm.rotate(i, glm.radians(0), glm.vec3(1, 0, 0))
yaw = glm.rotate(i, glm.radians(0), glm.vec3(0, 1, 0))
roll = glm.rotate(i, glm.radians(0), glm.vec3(0, 0, 1))
rotate = pitch * yaw * roll
scale = glm.scale(i, glm.vec3(1, 1, 1))
model = translate * rotate * scale
camera_translate = glm.translate(i, self.camera_position)
camera_pitch = glm.rotate(i, glm.radians(self.camera_pitch_degrees),
glm.vec3(1, 0, 0))
camera_yaw = glm.rotate(i, glm.radians(self.camera_yaw_degrees),
glm.vec3(0, 1, 0))
camera_roll = glm.rotate(i, glm.radians(self.camera_roll_degrees),
glm.vec3(0, 0, 1))
camera_rotate = camera_pitch * camera_yaw * camera_roll
view = glm.inverse(camera_translate * camera_rotate)
if self.active_shader:
glUniformMatrix4fv(
glGetUniformLocation(self.active_shader, 'model'), 1, GL_FALSE,
glm.value_ptr(model))
glUniformMatrix4fv(
glGetUniformLocation(self.active_shader, 'view'), 1, GL_FALSE,
glm.value_ptr(view))
glUniformMatrix4fv(
glGetUniformLocation(self.active_shader, 'projection'), 1,
GL_FALSE, glm.value_ptr(self.projection))
glBindVertexArray(self.VAO)
glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, None)
glBindVertexArray(0)
def draw_scene(self, shader):
# ----------------------------------------------------------------------
# 1. Setup shader uniforms
# ----------------------------------------------------------------------
shader.use()
# model view projection
model = glm.mat4(1.0)
shader.set_mat4('model', np.asarray(model))
view = self.camera.get_view()
shader.set_mat4('view', np.asarray(view))
width = self.window.width
height = self.window.height
projection = glm.perspective(glm.radians(50.0), width/height, 0.1, 100.0)
shader.set_mat4('projection', np.asarray(projection))
# lighting
lightPos = np.array(self.light_pos)
shader.set_vec3('lightPos', lightPos)
shader.set_vec3('lightColor', np.array([1.0, 1.0, 1.0], 'f'))
cameraPos = glm.vec3(glm.column(glm.inverse(view), 3))
shader.set_vec3('viewPos', np.asarray(cameraPos))
# ----------------------------------------------------------------------
# 2. Draw scene
# ----------------------------------------------------------------------
self.system.draw(shader)
# self.hand.draw(shader)
# self.baton.draw(shader)
if self.show_grid:
self.grid.draw(shader)
if self.show_contact_frames or self.show_contacts or self.show_velocities:
self.draw_contact_frames(shader)
def _compute_transform_matrices(rsm_version: int, node: AbstractNode,
is_only_node: bool,
model_bbox: BoundingBox) -> None:
if rsm_version >= 0x200:
(node.local_transform_matrix,
node.final_transform_matrix) = _generate_nodeview_matrix2(
rsm_version, node)
if node.parent:
node.gltf_transform_matrix = glm.inverse(
node.parent.final_transform_matrix
) * node.final_transform_matrix
else:
node.gltf_transform_matrix = node.final_transform_matrix
elif rsm_version >= 0x100:
node.gltf_transform_matrix = _generate_nodeview_matrix1(
rsm_version, node, is_only_node, model_bbox)
else:
raise ValueError("Invalid RSM file version")
for child in node.children:
_compute_transform_matrices(rsm_version, child, is_only_node,
model_bbox)
def reset(textureDict, bufferDict, cameraConfig, fusionConfig, clickedPoint3D):
frame.generateTextures(textureDict, cameraConfig, fusionConfig)
#generateBuffers(bufferDict, cameraConfig)
currPose = glm.mat4(1.0)
currPose = glm.translate(glm.mat4(1.0), glm.vec3(-clickedPoint3D[0] + fusionConfig['volDim'][0] / 2.0, -clickedPoint3D[1] + fusionConfig['volDim'][0] / 2.0, -clickedPoint3D[2] + fusionConfig['volDim'][0] / 2.0))
#currPose[3,0] = (fusionConfig['volDim'][0] / 2.0) - clickedPoint3D[0]
#currPose[3,1] = (fusionConfig['volDim'][1] / 2.0) - clickedPoint3D[1]
#currPose[3,2] = (fusionConfig['volDim'][2] / 2.0) - clickedPoint3D[2]
blankResult = np.array([0, 0, 0, 0, 0, 0], dtype='float32')
glBindBuffer(GL_SHADER_STORAGE_BUFFER, bufferDict['poseBuffer'])
glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, 16 * 4, glm.value_ptr(currPose))
glBufferSubData(GL_SHADER_STORAGE_BUFFER, 16 * 4, 16 * 4, glm.value_ptr(glm.inverse(currPose)))
glBufferSubData(GL_SHADER_STORAGE_BUFFER, 16 * 4 * 2, 16 * 4, glm.value_ptr(glm.mat4(1.0)))
glBufferSubData(GL_SHADER_STORAGE_BUFFER, 16 * 4 * 3, 16 * 4, glm.value_ptr(glm.mat4(1.0)))
glBufferSubData(GL_SHADER_STORAGE_BUFFER, 16 * 4 * 4, 6 * 4, blankResult)
glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)
initAtomicCount = np.array([0], dtype='uint32')
mapSize = np.array([0], dtype='uint32')
glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, bufferDict['atomic0'])
glBufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0, 4, initAtomicCount)
glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, 0)
glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, bufferDict['atomic1'])
glBufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0, 4, initAtomicCount)
glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, 0)
integrateFlag = 0
resetFlag = 1
return currPose, integrateFlag, resetFlag
def __init__(self, scene):
# window
self.width = 1024
self.height = 768
self.window = GLFWViewer(self.width, self.height, (0.2, 0.2, 0.2, 1.0))
self.camera = PerspectiveCamera(glm.inverse(self.window.view_matrix),
glm.radians(60),
self.width / self.height, 1, 30)
self.scene = scene
# assets
self.environment_image = assets.imread('hdri/Tropical_Beach_3k.hdr')
self.environment_image = assets.to_linear(self.environment_image)
# render passes
self.environment_pass = EnvironmentPass(512, 512)
self.irradiance_pass = IrradiancePass(32, 32)
self.prefilter_pass = PrefilterPass()
self.brdf_pass = BRDFPass(512, 512)
self.tonemapping_pass = TonemappingPass(self.width, self.height)
self.geometry_pass = GeometryPass(self.width, self.height,
self.draw_scene_for_geometry)
dirlight.shadowpass = DepthPass(1024, 1024, GL_FRONT,
self.draw_scene_for_shadows)
spotlight.shadowpass = DepthPass(1024, 1024, GL_FRONT,
self.draw_scene_for_shadows)
pointlight.shadowpass = CubeDepthPass(
512,
512,
GL_FRONT,
near=1,
far=15,
draw_scene=self.draw_scene_for_shadows)
self.lighting_pass = LightingPass(
self.width, self.height, lights=[dirlight, spotlight, pointlight])
