556 lines
19 KiB
Python
556 lines
19 KiB
Python
import random
|
|
import sys
|
|
|
|
from WorldProvider.WorldProvider import WorldProvider
|
|
|
|
print('64' if sys.maxsize > 2 ** 32 else '32')
|
|
|
|
from Objects.Cube.Cube import Cube
|
|
from Objects.Cuboid.Cuboid import Cuboid
|
|
from Objects.Structure import Structure, CompoundStructure
|
|
from Lights.Spotlight.Spotlight import Spotlight
|
|
from Lights.LightingManager import *
|
|
import numpy as np
|
|
import time
|
|
|
|
name = b'ball_glut'
|
|
|
|
struct = None
|
|
cstruct = None
|
|
program_id = 0
|
|
program2_id = 0
|
|
program3_id = 0
|
|
start = time.time()
|
|
frames = 0
|
|
width = 1920
|
|
height = 1080
|
|
opening = 45
|
|
l = Spotlight()
|
|
|
|
wp = None
|
|
|
|
|
|
def main():
|
|
lm = LightingManager()
|
|
# lm.addRenderStep(0,0)
|
|
# lm.addRenderStep(1,1)
|
|
# lm.removeRenderStep(0,0)
|
|
|
|
glutInit(sys.argv)
|
|
w = width
|
|
h = height
|
|
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH)
|
|
glutInitWindowSize(w, h)
|
|
glutCreateWindow(name)
|
|
# glutEnterGameMode()
|
|
|
|
print("Vendor:", glGetString(GL_VENDOR))
|
|
print("Renderer:", glGetString(GL_RENDERER))
|
|
print("Version:", glGetString(GL_VERSION))
|
|
print("GLSL:", glGetString(GL_SHADING_LANGUAGE_VERSION))
|
|
|
|
c = Cube()
|
|
cuboid = Cuboid()
|
|
|
|
glClearColor(0., 0., 0., 1.)
|
|
# glShadeModel(GL_SMOOTH)
|
|
# glDisable(GL_CULL_FACE)
|
|
glEnable(GL_CULL_FACE)
|
|
glCullFace(GL_BACK)
|
|
glEnable(GL_TEXTURE_2D)
|
|
glEnable(GL_DEPTH_TEST)
|
|
|
|
# glEnable(GL_LIGHTING)
|
|
'''lightZeroPosition = [10.,4.,10.,1.]
|
|
lightZeroColor = [0.8,1.0,0.8,1.0] #green tinged
|
|
glLightfv(GL_LIGHT0, GL_POSITION, lightZeroPosition)
|
|
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightZeroColor)
|
|
glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 0.1)
|
|
glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.05)
|
|
glEnable(GL_LIGHT0)'''
|
|
glutDisplayFunc(display)
|
|
glutReshapeFunc(resize)
|
|
glutKeyboardFunc(keyboardHandler)
|
|
glutSpecialFunc(funcKeydHandler)
|
|
'''glMatrixMode(GL_PROJECTION)
|
|
gluPerspective(40.,1.,1.,40.)
|
|
glMatrixMode(GL_MODELVIEW)'''
|
|
# gluLookAt(0,0,10,
|
|
# 0,0,0,
|
|
# 0,1,0)
|
|
# glPushMatrix()
|
|
|
|
with open('passthroughvertex.glsl', 'r') as f:
|
|
vertex_shader_string = f.read()
|
|
passthrough_vertex_shader_id = glCreateShader(GL_VERTEX_SHADER)
|
|
glShaderSource(passthrough_vertex_shader_id, vertex_shader_string)
|
|
glCompileShader(passthrough_vertex_shader_id)
|
|
if glGetShaderiv(passthrough_vertex_shader_id, GL_COMPILE_STATUS) != GL_TRUE:
|
|
raise RuntimeError(glGetShaderInfoLog(passthrough_vertex_shader_id))
|
|
|
|
with open('vertex.glsl', 'r') as f:
|
|
vertex_shader_string = f.read()
|
|
vertex_shader_id = glCreateShader(GL_VERTEX_SHADER)
|
|
glShaderSource(vertex_shader_id, vertex_shader_string)
|
|
glCompileShader(vertex_shader_id)
|
|
if glGetShaderiv(vertex_shader_id, GL_COMPILE_STATUS) != GL_TRUE:
|
|
raise RuntimeError(glGetShaderInfoLog(vertex_shader_id))
|
|
|
|
with open('texturefragment.glsl', 'r') as f:
|
|
fragment_shader_string = f.read()
|
|
texturefragment_shader_id = glCreateShader(GL_FRAGMENT_SHADER)
|
|
glShaderSource(texturefragment_shader_id, fragment_shader_string)
|
|
glCompileShader(texturefragment_shader_id)
|
|
if glGetShaderiv(texturefragment_shader_id, GL_COMPILE_STATUS) != GL_TRUE:
|
|
raise RuntimeError(glGetShaderInfoLog(texturefragment_shader_id))
|
|
|
|
with open('fragment.glsl', 'r') as f:
|
|
fragment_shader_string = f.read()
|
|
fragment_shader_id = glCreateShader(GL_FRAGMENT_SHADER)
|
|
glShaderSource(fragment_shader_id, fragment_shader_string)
|
|
glCompileShader(fragment_shader_id)
|
|
if glGetShaderiv(fragment_shader_id, GL_COMPILE_STATUS) != GL_TRUE:
|
|
raise RuntimeError(glGetShaderInfoLog(fragment_shader_id))
|
|
|
|
global program_id, program2_id, program3_id
|
|
program_id = glCreateProgram()
|
|
glAttachShader(program_id, vertex_shader_id)
|
|
glAttachShader(program_id, Cuboid.GeometryShaderId)
|
|
# glAttachShader(program_id, Cuboid.GeometryShaderId)
|
|
glAttachShader(program_id, fragment_shader_id)
|
|
# glAttachShader(program_id, l.FragmentShaderId)
|
|
glLinkProgram(program_id)
|
|
|
|
global struct, cstruct
|
|
struct = Structure()
|
|
struct.addShape(program_id, Cuboid().translate(translate(0, 0, 1)).setColor(1, 1, 0))
|
|
# struct.addShape(program_id, Cube().translate(translate(1, 1, 0)).setColor(0, 0, 1))
|
|
# struct.addShape(program_id, Cube().translate(translate(1, 0, 0)).setColor(0, 1, 0))
|
|
# struct.addShape(program_id, Cube().translate(translate(1, -1, 0)).setColor(1, 0, 0))
|
|
# struct.addShape(program_id, Cube().translate(translate(0, -1, 0)).setColor(0, 1, 0))
|
|
# struct.addShape(program_id, Cube().translate(translate(-1, -1, 0)).setColor(0, 0, 1))
|
|
# struct.addShape(program_id, Cube().translate(translate(-1, 0, 0)).setColor(0, 1, 1))
|
|
# struct.addShape(program_id, Cube().translate(translate(-1, 1, 0)).setColor(1, 1, 1))
|
|
# struct.addShape(program_id, Cube().translate(translate(0, 1, 0)).setColor(0, 0, 1))
|
|
|
|
for x_pos in range(0, 10, 1):
|
|
for y_pos in range(0, 10):
|
|
z = random.random() * 2 - 1
|
|
struct.addShape(program_id, Cuboid().translate(translate(x_pos, y_pos, z)).setColor(
|
|
random.randint(0, 100) / 100.0, random.randint(0, 100) / 100.0, random.randint(0, 100) / 100.0).setSize(
|
|
random.randint(0, 100) / 100.0, random.randint(0, 100) / 100.0, random.randint(0, 100) / 100.0
|
|
))
|
|
|
|
global wp
|
|
wp = WorldProvider({Cuboid: program_id})
|
|
|
|
for x_pos in range(0, 10):
|
|
for y_pos in range(0, 10):
|
|
for z_pos in range(0, 10):
|
|
wp.world.put_object(x_pos, y_pos, z_pos, Cuboid().setColor(
|
|
random.randint(0, 100) / 100.0, random.randint(0, 100) / 100.0, random.randint(0, 100) / 100.0).setSize(
|
|
random.randint(0, 100) / 100.0, random.randint(0, 100) / 100.0, random.randint(0, 100) / 100.0
|
|
))
|
|
|
|
# struct.clearVertexArrays()
|
|
|
|
cstruct = CompoundStructure()
|
|
cstruct.addStructure(struct)
|
|
|
|
program3_id = l.getDepthProgram(vertex_shader_id, Cuboid.GeometryShaderId)
|
|
|
|
program2_id = glCreateProgram()
|
|
glAttachShader(program2_id, passthrough_vertex_shader_id)
|
|
glAttachShader(program2_id, texturefragment_shader_id)
|
|
glLinkProgram(program2_id)
|
|
|
|
if glGetProgramiv(program_id, GL_LINK_STATUS) != GL_TRUE:
|
|
raise RuntimeError(glGetProgramInfoLog(program_id))
|
|
|
|
global vai, pbi, cbi, vai2, vai3
|
|
vai, pbi, cbi = create_vertex_buffers(np.array([0, 0, 1,
|
|
1, 1, 0,
|
|
1, 0, 0,
|
|
1, -1, 0,
|
|
0, -1, 0,
|
|
-1, -1, 0,
|
|
-1, 0, 0,
|
|
-1, 1, 0,
|
|
0, 1, 0], dtype=np.float32),
|
|
np.array([1, 1, 0,
|
|
0, 0, 1,
|
|
0, 1, 0,
|
|
1, 0, 0,
|
|
0, 1, 0,
|
|
0, 0, 1,
|
|
0, 1, 1,
|
|
1, 1, 1,
|
|
0, 0, 1], dtype=np.float32), program_id,
|
|
sizes=np.array(
|
|
[0.5, 1.5, 1.5,
|
|
0.5, 1.5, 1.5,
|
|
0.5, 1.5, 1.5], dtype=np.float32))
|
|
v = []
|
|
color = []
|
|
for i in range(-11, 12):
|
|
for j in range(-11, 12):
|
|
v.append(i)
|
|
v.append(j)
|
|
v.append(0)
|
|
color.append(1)
|
|
color.append(1)
|
|
color.append(1)
|
|
|
|
'''vai, pbi, cbi = create_vertex_buffers(np.array(v, dtype=np.float32),
|
|
np.array(color, dtype=np.float32), program_id,
|
|
sizes=np.array(
|
|
[0.5, 1.5, 1.5,
|
|
0.5, 1.5, 1.5,
|
|
0.5, 1.5, 1.5], dtype=np.float32))'''
|
|
|
|
vai2, _, _ = create_vertex_buffers(np.array([0.4, 0.4, 0,
|
|
1, 0.4, 0,
|
|
0.4, 1, 0,
|
|
0.4, 1, 0,
|
|
1, 0.4, 0,
|
|
1, 1, 0], dtype=np.float32),
|
|
np.array([0, 0, 0,
|
|
1, 0, 0,
|
|
0, 1, 0,
|
|
0, 1, 0,
|
|
1, 0, 0,
|
|
1, 1, 0], dtype=np.float32), program2_id)
|
|
vai3, _, _ = create_vertex_buffers(np.array([-1, -1, 0,
|
|
1, -1, 0,
|
|
-1, 1, 0,
|
|
-1, 1, 0,
|
|
1, -1, 0,
|
|
1, 1, 0], dtype=np.float32),
|
|
np.array([0, 0, 0,
|
|
1, 0, 0,
|
|
0, 1, 0,
|
|
0, 1, 0,
|
|
1, 0, 0,
|
|
1, 1, 0], dtype=np.float32), program2_id)
|
|
struct.render(projMatrix, rotate(rx, 0, 0))
|
|
my_timer(0)
|
|
glutMainLoop()
|
|
return
|
|
|
|
|
|
projMatrix = perspectiveMatrix(45.0, 400 / 400, 0.01, 100.0);
|
|
|
|
|
|
def check_error(message):
|
|
gl_error = glGetError()
|
|
if gl_error != GL_NO_ERROR:
|
|
print("Error: " + message)
|
|
if gluErrorString(gl_error):
|
|
print(gluErrorString(gl_error))
|
|
else:
|
|
print(hex(gl_error))
|
|
return True
|
|
return False
|
|
|
|
|
|
def create_vertex_buffers(positions, colors, program_id, sizes=np.array([])):
|
|
glEnableClientState(GL_VERTEX_ARRAY)
|
|
glEnableClientState(GL_TEXTURE_COORD_ARRAY)
|
|
glEnableClientState(GL_NORMAL_ARRAY)
|
|
glEnableClientState(GL_COLOR_ARRAY)
|
|
|
|
# global vai, pbi, cbi
|
|
tvai = GLuint(0)
|
|
tpbi = GLuint(0)
|
|
tcbi = GLuint(0)
|
|
|
|
# test = glGetString(GL_VERSION)
|
|
|
|
glGenVertexArrays(1, tvai)
|
|
glBindVertexArray(tvai)
|
|
|
|
vid = glGetAttribLocation(program_id, "in_position")
|
|
glEnableVertexAttribArray(vid)
|
|
|
|
tpbi = glGenBuffers(1)
|
|
glBindBuffer(GL_ARRAY_BUFFER, tpbi)
|
|
glBufferData(GL_ARRAY_BUFFER, positions, GL_STATIC_DRAW)
|
|
glVertexAttribPointer(vid, 3, GL_FLOAT, GL_FALSE, 0, None)
|
|
check_error("Could not create position buffer")
|
|
|
|
tcbi = glGenBuffers(1)
|
|
glBindBuffer(GL_ARRAY_BUFFER, tcbi)
|
|
glBufferData(GL_ARRAY_BUFFER, colors, GL_STATIC_DRAW)
|
|
vc = glGetAttribLocation(program_id, "MyInColor")
|
|
if vc != -1:
|
|
glEnableVertexAttribArray(vc)
|
|
glVertexAttribPointer(vc, 3, GL_FLOAT, GL_FALSE, 0, None)
|
|
check_error("Could not create color buffer")
|
|
|
|
if len(sizes) > 0:
|
|
sbi = glGenBuffers(1)
|
|
glBindBuffer(GL_ARRAY_BUFFER, sbi)
|
|
glBufferData(GL_ARRAY_BUFFER, sizes, GL_STATIC_DRAW)
|
|
vs = glGetAttribLocation(program_id, "MyInSize")
|
|
if vs != -1:
|
|
glEnableVertexAttribArray(vs)
|
|
glVertexAttribPointer(vs, 3, GL_FLOAT, GL_FALSE, 0, None)
|
|
check_error("Could not create size buffer")
|
|
|
|
glBindVertexArray(0)
|
|
return tvai, tpbi, tcbi
|
|
|
|
|
|
def clear_buffer(buffer_id):
|
|
glDisableVertexAttribArray(buffer_id)
|
|
glDeleteBuffers(1, [buffer_id])
|
|
|
|
|
|
def clear_vertex_array(va_id):
|
|
glDeleteVertexArrays(1, va_id)
|
|
check_error("Could not destroy vertex array")
|
|
|
|
|
|
vai, pbi, cbi = 0, 0, 0
|
|
vai2, pbi2, cbi2 = 0, 0, 0
|
|
vai3, pbi3, cbi3 = 0, 0, 0
|
|
rx = 0
|
|
ry = 0
|
|
|
|
|
|
def render(program_id, projMatrix, vai, x, y, z, alternateprograms=None):
|
|
global struct, cstruct, wp
|
|
|
|
cstruct.render(translate(x, y, z) * rotate(0, ry, 0, True) * projMatrix, rotate(rx, 0, 0), alternateprograms)
|
|
wp.world.render(translate(x, y, z) * rotate(0, ry, 0, True) * projMatrix, rotate(rx, 0, 0), alternateprograms)
|
|
'''
|
|
glUseProgram(program_id)
|
|
check_error("Renderingprogram is not initialized!")
|
|
|
|
projection = glGetUniformLocation(program_id, 'projModelViewMatrix')
|
|
rot = glGetUniformLocation(program_id, 'rotMatrix')
|
|
|
|
glUniformMatrix4fv(projection, 1, GL_FALSE, np.array(translate(x, y, z) * rotate(rx, 0, 0, True) * projMatrix, dtype=np.float32))
|
|
glUniformMatrix3fv(rot, 1, GL_FALSE, np.array(rotate(rx, 0, 0), dtype=np.float32))
|
|
|
|
|
|
glBindVertexArray(vai)
|
|
glDrawArrays(GL_POINTS, 0, 9)#529
|
|
check_error("Rendering problem")
|
|
|
|
glBindVertexArray(0)
|
|
glUseProgram(0)
|
|
'''
|
|
|
|
|
|
def display():
|
|
'''if time.time() - start >= 1:
|
|
print(frames+1)
|
|
global start, frames
|
|
frames = 0
|
|
start = time.time()
|
|
else:
|
|
global frames
|
|
frames += 1'''
|
|
glClearColor(0, 0, 0, 0)
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
|
|
|
|
global l
|
|
l.prepareForDepthMapping()
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
|
|
|
|
# newMat = orthogonalMatrix(10, -10, 10, -10, 10, -10) * lookAt(cx, cy, 5, 0, 0, 0, 0, 1,0) * np.identity(4)
|
|
# newMat = translate(0, 0, -10) * newMat
|
|
|
|
global projMatrix
|
|
projMatrix = perspectiveMatrix(45, float(width) / float(height), 0.01, 100.0)
|
|
|
|
newMat = translate(-cx, -cy, -5) * lookAt(0, 0, 0, cx, cy, 5, 0, 1, 0) * perspectiveMatrix(opening,
|
|
float(l.map_size) /
|
|
float(l.map_size),
|
|
0.01, 100.0)
|
|
l.pos = [-cx, -cy, -5]
|
|
l.ModelviewProjectionMatrix = newMat
|
|
l.lightColor = [1, 1, 1]
|
|
|
|
glUseProgram(program3_id)
|
|
widthid = glGetUniformLocation(program3_id, 'width')
|
|
heightid = glGetUniformLocation(program3_id, 'height')
|
|
nearid = glGetUniformLocation(program3_id, 'near')
|
|
farid = glGetUniformLocation(program3_id, 'far')
|
|
glUniform1f(nearid, 0.01)
|
|
glUniform1f(farid, 100)
|
|
glUniform1f(widthid, l.map_size)
|
|
glUniform1f(heightid, l.map_size)
|
|
|
|
altPrId = {}
|
|
altPrId[program_id] = program3_id
|
|
render(program3_id, newMat, vai, 0, 0, 0, altPrId)
|
|
glFlush()
|
|
l.finishDepthMapping()
|
|
|
|
glClearColor(0, 0, 0, 0)
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
|
|
|
|
glUseProgram(program_id)
|
|
widthid = glGetUniformLocation(program_id, 'width')
|
|
heightid = glGetUniformLocation(program_id, 'height')
|
|
nearid = glGetUniformLocation(program_id, 'near')
|
|
farid = glGetUniformLocation(program_id, 'far')
|
|
glUniform1f(nearid, 0.01)
|
|
glUniform1f(farid, 100)
|
|
glUniform1f(widthid, width)
|
|
glUniform1f(heightid, height)
|
|
|
|
lightProjModelViewMatrix = glGetUniformLocation(program_id, 'lightProjModelViewMatrix')
|
|
numLights = glGetUniformLocation(program_id, 'numLights')
|
|
lightpos = glGetUniformLocation(program_id, 'lightpos')
|
|
lightcolorid = glGetUniformLocation(program_id, 'lightColor')
|
|
|
|
glUniformMatrix4fv(lightProjModelViewMatrix, 1, GL_FALSE, np.array(l.ModelviewProjectionMatrix))
|
|
glUniform1iv(numLights, 1, 1)
|
|
glUniform3fv(lightpos, 1, l.pos)
|
|
glUniform3fv(lightcolorid, 1, l.lightColor)
|
|
|
|
texID = glGetUniformLocation(program_id, 'ShadowMaps')
|
|
glActiveTexture(GL_TEXTURE0)
|
|
glBindTexture(GL_TEXTURE_2D, l.DepthBuffer)
|
|
glUniform1iv(texID, 1, 0)
|
|
|
|
glViewport(0, 0, width, height)
|
|
render(program_id, translate(0, 0, -10) * lookAt(0, 0, 0, 0, 0, 10, 0, 1, 0) * projMatrix, vai, 0, 0, 0)
|
|
|
|
# temp, _, _ = create_vertex_buffers(np.array([cx, cy, 5], dtype=np.float32),
|
|
# np.array([1, 1, 0], dtype=np.float32), program_id)
|
|
# render(program_id, projMatrix, temp, 0, 0, -10)
|
|
# ry += 0.05
|
|
|
|
glUseProgram(program2_id)
|
|
check_error("Renderingprogram is not initialized!")
|
|
|
|
texID = glGetUniformLocation(program2_id, "Tex")
|
|
glActiveTexture(GL_TEXTURE0)
|
|
glBindTexture(GL_TEXTURE_2D, l.DepthBuffer)
|
|
glUniform1i(texID, 0)
|
|
|
|
glBindVertexArray(vai2)
|
|
glDrawArrays(GL_TRIANGLES, 0, 6)
|
|
check_error("Rendering problem")
|
|
|
|
glBindVertexArray(0)
|
|
glUseProgram(0)
|
|
glFlush()
|
|
|
|
glutSwapBuffers()
|
|
global rx
|
|
# rx += 0.025
|
|
global ry
|
|
# glutPostRedisplay()
|
|
return
|
|
|
|
|
|
cx = 0
|
|
cy = 0
|
|
|
|
|
|
# def display2():
|
|
# glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
|
|
# global l
|
|
# l.prepareForDepthMapping()
|
|
# glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
|
|
#
|
|
# newMat = orthogonalMatrix(10, -10, 10, -10, 20, 0.01) * lookAt(-cx, -cy, 1, 0, 0, 0, 0, 1, 0) * np.identity(4)
|
|
# newMat = translate(5, 0, -10) * lookAt(-5, 0, 10, 0, 0, 0, 0, 1, 0) * projMatrix
|
|
# oldMat = rotate(0, -0.5, 0, True) * projMatrix
|
|
# glUseProgram(program3_id)
|
|
# widthid = glGetUniformLocation(program3_id, 'width')
|
|
# heightid = glGetUniformLocation(program3_id, 'height')
|
|
# nearid = glGetUniformLocation(program3_id, 'near')
|
|
# farid = glGetUniformLocation(program3_id, 'far')
|
|
# glUniform1f(nearid, 0.01)
|
|
# glUniform1f(farid, 100)
|
|
# glUniform1f(widthid, width)
|
|
# glUniform1f(heightid, height)
|
|
# render(program3_id, newMat, vai, 0, 0, 0)
|
|
# glFlush()
|
|
# l.finishDepthMapping()
|
|
#
|
|
# glUseProgram(program2_id)
|
|
# check_error("Renderingprogram is not initialized!")
|
|
#
|
|
# texID = glGetUniformLocation(program2_id, "Tex")
|
|
# glActiveTexture(GL_TEXTURE0)
|
|
# glBindTexture(GL_TEXTURE_2D, l.DepthBuffer)
|
|
# glUniform1i(texID, 0)
|
|
#
|
|
# glBindVertexArray(vai3)
|
|
# glDrawArrays(GL_TRIANGLES, 0, 6)
|
|
# check_error("Rendering problem")
|
|
# glBindVertexArray(0)
|
|
# glUseProgram(0)
|
|
# glFlush()
|
|
# glutSwapBuffers()
|
|
# glutPostRedisplay()
|
|
|
|
|
|
def resize(w, h):
|
|
w = max(w, 1)
|
|
h = max(h, 1)
|
|
glViewport(0, 0, w, h)
|
|
global projMatrix
|
|
projMatrix = perspectiveMatrix(45.0, float(w) / float(h), 0.01, 100.0)
|
|
global width, height
|
|
width = w
|
|
height = h
|
|
|
|
def keyboardHandler(key: int, x: int, y: int):
|
|
if key == b'\x1b':
|
|
exit()
|
|
global rx
|
|
global cx
|
|
global cy
|
|
global opening
|
|
|
|
if key == b'+':
|
|
rx += 0.25
|
|
if key == b'-':
|
|
rx -= 0.25
|
|
|
|
if key == b'w':
|
|
cy += 0.25
|
|
if key == b's':
|
|
cy -= 0.25
|
|
|
|
if key == b'a':
|
|
cx -= 0.25
|
|
if key == b'd':
|
|
cx += 0.25
|
|
|
|
if key == b'q':
|
|
opening -= 0.25
|
|
if key == b'e':
|
|
opening += 0.25
|
|
|
|
if key == b'r':
|
|
print(cx, cy, opening)
|
|
# glutPostRedisplay()
|
|
# print(key,x,y)
|
|
|
|
|
|
def funcKeydHandler(key: int, x: int, y: int):
|
|
if key == 11:
|
|
glutFullScreenToggle()
|
|
# print(key)
|
|
|
|
|
|
def my_timer(x):
|
|
glutPostRedisplay()
|
|
glutTimerFunc(int(1000/60), my_timer, 0)
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
rx = 0
|
|
ry = 0
|
|
main()
|