def mouse_callback(self, parent, x, y):
if self.first_mouse:
self.last_x, self.last_y = x, y
self.first_mouse = False
x_offset, y_offset = x - self.last_x, y - self.last_y
self.last_x, self.last_y = x, y
x_offset *= self.sensitivity
y_offset *= self.sensitivity
self.yaw += x_offset
self.pitch -= y_offset
if self.pitch > 89.95:
self.pitch = 89.95
if self.pitch < -89.95:
self.pitch = -89.95
direction = glm.vec3(
glm.cos(glm.radians(self.yaw)) * glm.cos(glm.radians(self.pitch)),
glm.sin(glm.radians(self.pitch)),
glm.sin(glm.radians(self.yaw)) * glm.cos(glm.radians(self.pitch)))
self.front = glm.normalize(direction)
self.move.x = direction.x / glm.cos(glm.radians(self.pitch))
self.move.z = direction.z / glm.cos(glm.radians(self.pitch))
def keyboard_d_keys(key, dx, y):
global angle, cameraFront, cameraUp, cameraPos
if not isinstance(key, int):
key = key.decode("utf-8")
front = glm.vec3(0, 0, -1)
cam_speed = 0.2
if key == GLUT_KEY_LEFT:
print("D_KEYS_L ", key)
angle -= cam_speed
front.x = glm.sin(angle)
front.z = -glm.cos(angle)
elif key == GLUT_KEY_RIGHT:
print("D_KEYS_R ", key)
angle += cam_speed
front.x = glm.sin(angle)
front.z = -glm.cos(angle)
elif key == GLUT_KEY_UP:
print("D_KEYS_U ", key)
angle += cam_speed
front.y = glm.sin(angle)
# front.z = -glm.cos(angle)
elif key == GLUT_KEY_DOWN:
print("D_KEYS_D ", key)
angle -= cam_speed
front.y = glm.sin(angle)
# front.z = -glm.cos(angle)
# cameraFront = glm.normalize(front)
cameraFront = front
glutPostRedisplay()
def update(self, delta_time): # process input self.view_ray = glm.vec3(glm.cos(self.rotation[0]) * glm.cos(self.rotation[1]), glm.sin(self.rotation[1]), glm.sin(self.rotation[0]) * glm.cos(self.rotation[1])) if delta_time * 20 > 1: self.speed = self.target_speed else: self.speed += (self.target_speed - self.speed) * delta_time * 20 multiplier = self.speed * (1, 2)[self.flying] if self.flying and self.input[1]: self.accel[1] = self.input[1] * multiplier if self.input[0] or self.input[2]: angle = self.rotation[0] - math.atan2(self.input[2], self.input[0]) + math.tau / 4 self.accel[0] = math.cos(angle) * multiplier self.accel[2] = math.sin(angle) * multiplier if not self.flying and self.input[1] > 0: self.jump() # process physics & collisions &c super().update(delta_time) self.rounded_position = [round(i) for i in self.position]
def _update_cam_unit_pos(self):
self._pitch = max(-89., min(89., self._pitch))
pitch = glm.radians(self._pitch)
yaw = glm.radians(self._yaw)
self._cam_unit_pos = glm.normalize(glm.vec3(glm.cos(yaw) * glm.cos(pitch),
glm.sin(pitch),
glm.sin(yaw) * glm.cos(pitch)))
def updateCameraVectors(self):
self.front.x = glm.cos(glm.radians(self.yaw)) * glm.cos(
glm.radians(self.pitch))
self.front.y = glm.sin(glm.radians(self.pitch))
self.front.z = glm.sin(glm.radians(self.yaw)) * glm.cos(
glm.radians(self.pitch))
self.front = glm.normalize(self.front)
self.right = glm.normalize(glm.cross(self.front, self.worldUp))
self.up = glm.normalize(glm.cross(self.right, self.front))
def _update(self):
current_frame = time.time()
self.delta = current_frame - self.last_time
self.last_time = current_frame
print(f'delta = {self.delta}')
angle = glm.radians(self.angle)
print(f'angle = {angle}')
light_x = self.light.position.x * glm.cos(angle) - self.light.position.z * glm.sin(angle)
light_z = self.light.position.z * glm.cos(angle) + self.light.position.x * glm.sin(angle)
self.light.position = glm.vec3(light_x, self.light.position.y, light_z)
self.angle += 0.5 * self.delta
def rotate_points(points_list, angle):
# passed in mesh is a list of vec3 x,y,z positions
# rotation happens around the 0,0,0 position
sizeofList = len(points_list)
i=0
# for every vec3 in mesh
while i < (sizeofList):
# simple 2d rotation about the Z axis following sum angle rule
x2=((points_list[i].x*glm.cos(angle)) - (points_list[i].y*glm.sin(angle)))
y2=((points_list[i].x*glm.sin(angle)) + (points_list[i].y*glm.cos(angle)))
points_list[i].x = int(x2)
points_list[i].y = int(y2)
i += 1
return points_list
def rotate_vector(vector, angle):
# takes a vector and returns a normalized vector adjusted by angle
# angle delivered in degrees
# simple 2d rotation about the Z axis following sum angle rule
x2 = ((vector.x * glm.cos(angle)) - (vector.y * glm.sin(angle)))
y2 = ((vector.x * glm.sin(angle)) + (vector.y * glm.cos(angle)))
# don't hold this to an int
vector.x = x2
vector.y = y2
vector = glm.normalize(vector)
return vector
def relative_move(self, right, up, forward):
'''Moves the camera relative to its own current rotation.
For instance, if the camera is facing straight down,
relative_move()ing forward would be the same as move()ing down.'''
cyaw = glm.cos(self._yaw)
syaw = glm.sin(self._yaw)
cpitch = glm.cos(self._pitch)
spitch = glm.sin(self._pitch)
croll = glm.cos(self._roll)
sroll = glm.sin(self._roll)
x = (-1 * cyaw * syaw * sroll - sroll * croll) * right
y = (-1 * syaw * spitch * sroll + cyaw * croll) * up
z = -1 * (cpitch * sroll) * forward
self._position = self._position + glm.vec3(x, y, z)
self._transm = None
self._matrix = None
def eulerToRotationMatrix(roll, pitch, yaw):
"""
ZXY顺规, Z-Roll, X-Pitch, Y-Yaw, 单位角度
参考: https://zhuanlan.zhihu.com/p/45404840
"""
c1 = glm.cos(glm.radians(yaw))
s1 = glm.sin(glm.radians(yaw))
c2 = glm.cos(glm.radians(pitch))
s2 = glm.sin(glm.radians(pitch))
c3 = glm.cos(glm.radians(roll))
s3 = glm.sin(glm.radians(roll))
matrix = glm.mat4(c1*c3+s1*s2*s3, c3*s1*s2-c1*s3, c2*s1, 0,
c2*s3, c2*c3, -s2, 0,
c1*s2*s3-s1*c3, s1*s3+c1*c3*s2, c1*c2, 0,
0, 0, 0, 1)
return matrix
def main():
# initializing glfw library
if not glfw.init():
raise Exception("glfw can not be initialized!")
# Configure the OpenGL context.
# If we are planning to use anything above 2.1 we must at least
# request a 3.3 core context to make this work across platforms.
if "Windows" in pltf.platform():
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 6)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)
else:
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 1)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)
# 4 MSAA is a good default with wide support
glfw.window_hint(glfw.SAMPLES, 4)
# creating the window
window = glfw.create_window(1280, 720, "My OpenGL window", None, None)
# check if window was created
if not window:
glfw.terminate()
raise Exception("glfw window can not be created!")
# Query the actual framebuffer size so we can set the right viewport later
# -> glViewport(0, 0, framebuffer_size[0], framebuffer_size[1])
framebuffer_size = glfw.get_framebuffer_size(window)
# set window's position
glfw.set_window_pos(window, 100, 100)
# make the context current
glfw.make_context_current(window)
# glClearColor(0.5, 0.5, 0.5, 1.0)
print("GL_RENDERER = ", glGetString(GL_RENDERER).decode("utf8"))
print("GL_VERSION = ", glGetString(GL_VERSION).decode("utf8"))
# the main application loop
while not glfw.window_should_close(window):
glfw.poll_events()
# glClear(GL_COLOR_BUFFER_BIT)
COLOR = glm.array(
glm.vec4([
glm.sin(glfw.get_time()) * 0.5 + 0.5,
glm.cos(glfw.get_time()) * 0.5 + 0.5, 0.0, 1.0
]))
glClearBufferfv(GL_COLOR, 0, COLOR.ptr)
glfw.swap_buffers(window)
# terminate glfw, free up allocated resources
glfw.terminate()
def calc_collide_rays(self, numViewDirections, length):
directions=[]
goldenRatio = (1 + glm.sqrt(5)) / 2;
angleIncrement = glm.pi() * 2 * goldenRatio;
i=0
while i < (numViewDirections):
t = i / numViewDirections;
inclination = glm.acos(1 - 2 * t);
azimuth = angleIncrement * i;
x = glm.sin(inclination) * glm.cos(azimuth);
y = glm.sin (inclination) * glm.sin(azimuth);
z = glm.cos (inclination);
directions.append(glm.vec3(x, y, z)*length)
i+=1
return directions
def draw_cylinder(x, y, z, radius, height):
px = 0
pz = 0
c_angle = 0
angle_stepsize = 0.1
glBegin(GL_QUAD_STRIP)
c_angle = 0
while c_angle < 2 * glm.pi() + 1:
px = radius * glm.cos(c_angle)
pz = radius * glm.sin(c_angle)
glVertex3f(x + px, y + height, z + pz)
glVertex3f(x + px, y, z + pz)
c_angle += angle_stepsize
glEnd()
glBegin(GL_POLYGON)
c_angle = 0
while c_angle < 2 * glm.pi():
px = radius * glm.cos(c_angle)
pz = radius * glm.sin(c_angle)
glVertex3f(x + px, y + height, z + pz)
c_angle += angle_stepsize
glEnd()
glBegin(GL_POLYGON)
c_angle = 0
while c_angle < 2 * glm.pi():
px = radius * glm.cos(c_angle)
pz = radius * glm.sin(c_angle)
glVertex3f(x + px, y + height, z + pz)
c_angle += angle_stepsize
glEnd()
glBegin(GL_POLYGON)
c_angle = 0
while c_angle < 2 * glm.pi():
px = radius * glm.cos(c_angle)
pz = radius * glm.sin(c_angle)
glVertex3f(x + px, y, z + pz)
c_angle += angle_stepsize
glEnd()
def mouse_camera(mouse_x, mouse_y):
global mouse_sensitivity, mouse_speed, angle_x, angle_y, cameraFront, old_mouse_x, old_mouse_y
angle_x -= (mouse_x - old_mouse_x) * mouse_sensitivity
angle_y -= (mouse_y - old_mouse_y) * mouse_sensitivity
if angle_y > 2:
angle_y = 2
if angle_y < 1:
angle_y = 1
front = glm.vec3()
front.x = glm.cos(angle_x) * glm.sin(angle_y)
front.z = glm.sin(angle_x) * glm.sin(angle_y)
front.y = glm.cos(angle_y)
cameraFront = front
old_mouse_x = mouse_x
old_mouse_y = mouse_y
glutPostRedisplay()
def draw_scene(self,
draw: ImageDraw.ImageDraw,
player_radians: float,
projection_plane: float,
wall_height: int,
hits: List[Hit]):
y = self.height / 2
precomputed = wall_height * projection_plane
for x, hit in enumerate(hits):
correct_distance = hit.length * glm.cos(hit.radians - player_radians)
column_height = precomputed / correct_distance
draw.line((x, y - column_height, x, y + column_height), COLOR_GRAY)
def __init__(self,
game_object: GameObject,
cut_off: Optional[float] = None,
outer_cut_off: Optional[float] = None,
light_range: Optional[float] = None,
ambient: Optional[float] = None,
diffuse: Optional[float] = None,
specular: Optional[float] = None,
color: Optional[Color] = None):
super(SpotLight, self).__init__(game_object=game_object,
light_range=light_range,
ambient=ambient,
diffuse=diffuse,
specular=specular,
color=color)
self.direction: Vector3 = game_object.transform.forward
self.cut_off: float = glm.cos(
glm.radians(12.5)) if cut_off is None else glm.cos(
glm.radians(cut_off))
self.outer_cut_off: float = glm.cos(
glm.radians(15.0)) if outer_cut_off is None else glm.cos(
glm.radians(outer_cut_off))
def ray_travers(self, ray: 'Ray') -> Hit:
current = ray.origin
while True:
tile = self._to_tile_coords(*current)
box_min = tile * self.cell_size
box_max = box_min + self.cell_size
t = self._box_ray_intersection(ray, box_min, box_max)
if self._is_out_of_range(*tile) or self.get(*tile) == self.stop_when:
length = abs(ray.origin.x - current.x) / glm.cos(ray.radians)
if not length:
length = abs(ray.origin.y - current.y) / glm.sin(ray.radians)
return Hit(abs(length), ray.radians, current)
current = ray.origin + t * ray.direction
def __init__(self, position, front, window_size):
self.pos = glm.vec3(position[0], position[1], position[2])
self.front = glm.vec3(front[0], front[1], front[2])
self.up = glm.vec3(0, 1, 0)
self.move = glm.vec3(front[0], 0, front[2])
self.sprint = False
self.sprint_press = 0
self.coords_toggle = False
self.last_x, self.last_y = window_size[0] / 2, window_size[1] / 2
self.pitch = glm.asin(self.front.y)
self.yaw = glm.acos(self.front.x / glm.cos(self.pitch))
self.sensitivity = 0.2
self.first_mouse = True
shadowProj * glm.lookAt(lightPos, lightPos + glm.vec3(0.0, 0.0, 1.0),
glm.vec3(0.0, -1.0, 0.0)))
shadowTransforms.append(
shadowProj * glm.lookAt(lightPos, lightPos + glm.vec3(0.0, 0.0, -1.0),
glm.vec3(0.0, -1.0, 0.0)))
shadowTransforms = np.array([np.array(m) for m in shadowTransforms])
import time
with window:
while not window.should_close():
# Animate
# -------
lightPos = glm.vec3(
glm.sin(time.time() * 1.6) * 2, 3,
glm.cos(time.time() * 1.6) * 2)
# shadow depth cubemap pass
# -------------------------
shadowTransforms = []
shadowTransforms.append(
shadowProj *
glm.lookAt(lightPos, lightPos + glm.vec3(1.0, 0.0, 0.0),
glm.vec3(0.0, -1.0, 0.0)))
shadowTransforms.append(
shadowProj *
glm.lookAt(lightPos, lightPos + glm.vec3(-1.0, 0.0, 0.0),
glm.vec3(0.0, -1.0, 0.0)))
shadowTransforms.append(
shadowProj *
glm.lookAt(lightPos, lightPos + glm.vec3(0.0, 1.0, 0.0),
def direction(self):
v = self.origin + 1 * glm.vec2(glm.cos(self.radians), glm.sin(self.radians))
return glm.normalize(v - self.origin)
def cut_off(self):
return glm.cos(glm.radians(self.fov / 2))
def on_draw(self, event):
print("psize" + str(self.physical_size))
print("size" + str(self.size))
if self.physical_size != self.size:
print("False")
eixt()
# Read about depth testing and changing stated in vispy here http://vispy.org/gloo.html?highlight=set_state
gloo.clear(color=[0, 0, 0, 1.0], depth=True)
# delta_time
self.current_frame = time()
self.delta_time = self.current_frame - self.last_frame
self.last_frame = self.current_frame
self.lightPos = [sin(time() - self.startTime), 1, 0]
if self.camera.bool_a:
self.camera.ProcessKeyboard(Camera_Movement.LEFT, self.delta_time)
if self.camera.bool_w:
self.camera.ProcessKeyboard(Camera_Movement.FORWARD,
self.delta_time)
if self.camera.bool_s:
self.camera.ProcessKeyboard(Camera_Movement.BACKWARD,
self.delta_time)
if self.camera.bool_d:
self.camera.ProcessKeyboard(Camera_Movement.RIGHT, self.delta_time)
self.view = self.camera.GetViewMatrix()
self.projection = glm.perspective(glm.radians(self.camera.Zoom),
builtins.width / builtins.height,
0.1, 100.0)
# vispy takes numpy array in m * n matrix form
self.view = (np.array(self.view.to_list()).astype(np.float32))
self.projection = (np.array(self.projection.to_list()).astype(
np.float32))
# reshaping to (m, n) to (1, m*n) to support data input in vispy
self.view = self.view.reshape(
(1, self.view.shape[0] * self.view.shape[1]))
self.projection = self.projection.reshape(
(1, self.projection.shape[0] * self.projection.shape[1]))
self.model = glm.mat4(1.0)
# self.model = glm.rotate(self.model, glm.radians((time() - self.startTime) * 100), glm.vec3(1,0,0))
self.model = glm.translate(self.model, self.lightPos)
self.model = (np.array(self.model.to_list()).astype(np.float32))
self.model = self.model.reshape(
(1, self.model.shape[0] * self.model.shape[1]))
# drawing light source
self.programLightSource['model'] = self.model
self.programLightSource['view'] = self.view
self.programLightSource['projection'] = self.projection
self.programLightSource['a_position'] = self.vertices / 3
self.programLightSource.draw('triangles')
# drawing normal cube
self.program['view'] = self.view
self.program['projection'] = self.projection
self.program['a_position'] = self.vertices
self.program['aNormal'] = self.aNormal
self.program['viewPos'] = self.camera.Position
self.program['texCoords'] = self.texCoord
self.program['l_ambient[0]'] = [0.2, 0.2, 0.2]
self.program['l_diffuse[0]'] = [1.0, 1.0, 1.0]
self.program['l_specular[0]'] = [1.0, 1.0, 1.0]
self.program['l_position[0]'] = self.camera.Position
self.program['l_direction[0]'] = self.camera.Front
self.program['l_constant'] = 1.0
self.program['l_linear'] = 0.09
self.program['l_quadratic'] = 0.032
self.program['l_cut_off'] = glm.cos(glm.radians(12.5))
self.program['l_outer_cut_off'] = glm.cos(glm.radians(17.5))
self.program['m_diffuse[0]'] = self.diffuse_map
self.program['m_specular[0]'] = self.specular_map
self.program['m_shininess[0]'] = 32
i = 0
for pos in self.cubePositions:
i += 1
self.model = glm.mat4(1.0)
# rotate the cube if you want
self.model = glm.translate(self.model, pos)
# self.model = glm.rotate(self.model, glm.radians(glm.radians(2000) * i / 2),
# glm.vec3(1.0, 0.3, 0.5))
self.model = (np.array(self.model.to_list()).astype(np.float32))
self.model = self.model.reshape(
(1, self.model.shape[0] * self.model.shape[1]))
self.program['model'] = self.model
self.program.draw('triangles')
self.update()
def look_at(self, point):
'Rotates the camera to look at a specific point.'
p = point - self._position
up = (-1 * glm.sin(self._yaw) * glm.sin(self._pitch) *
glm.sin(self._roll) + glm.cos(self._yaw) * glm.cos(self._roll))
self._rotm = glm.lookAt(glm.vec3(0, 0, 0), p, up)
