def __init__(self, window_width, window_height, samples, window_title): self.window_title = window_title assert glfw.Init(), 'Glfw Init failed!' glfw.WindowHint(glfw.SAMPLES, samples) self.windowID = glfw.CreateWindow(window_width, window_height, self.window_title, None) assert self.windowID, 'Could not create Window!' glfw.MakeContextCurrent(self.windowID) assert glInitBindlessTextureNV(), 'Bindless Textures not supported!' self.framebuf_width, self.framebuf_height = glfw.GetFramebufferSize( self.windowID) def framebuffer_size_callback(window, w, h): self.framebuf_width, self.framebuf_height = w, h glfw.SetFramebufferSizeCallback(self.windowID, framebuffer_size_callback) def key_callback(window, key, scancode, action, mode): if action == glfw.PRESS: if key == glfw.KEY_ESCAPE: glfw.SetWindowShouldClose(window, True) glfw.SetKeyCallback(self.windowID, key_callback) self.previous_second = glfw.GetTime() self.frame_count = 0.0 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE) glDisable(GL_STENCIL_TEST) glDisable(GL_BLEND) glDisable(GL_CULL_FACE) glClearColor(0.0, 0.0, 0.0, 1.0) glEnable(GL_LINE_SMOOTH) glEnable(GL_POLYGON_SMOOTH)
def init_keyboard(window): glfw.SetKeyCallback(window, __on_keydown) theta = 0.0 def process_keyboard_input(dt, camera_world_matrix, cue=None): nonlocal theta theta += KB_TURN_SPEED * dt * (key_state[glfw.KEY_LEFT] - key_state[glfw.KEY_RIGHT]) sin, cos = np.sin(theta), np.cos(theta) camera_world_matrix[0, 0] = cos camera_world_matrix[0, 2] = -sin camera_world_matrix[2, 0] = sin camera_world_matrix[2, 2] = cos camera_world_matrix[3, 0] += dt * KB_MOVE_SPEED * (key_state[glfw.KEY_D] - key_state[glfw.KEY_A]) camera_world_matrix[3, 1] += dt * KB_MOVE_SPEED * (key_state[glfw.KEY_Q] - key_state[glfw.KEY_Z]) camera_world_matrix[3, 2] += dt * KB_MOVE_SPEED * (key_state[glfw.KEY_S] - key_state[glfw.KEY_W]) if cue is not None: fb = key_state[glfw.KEY_I] - key_state[glfw.KEY_K] lr = key_state[glfw.KEY_L] - key_state[glfw.KEY_J] ud = key_state[glfw.KEY_U] - key_state[glfw.KEY_M] cue.world_matrix[:3, :3] = cue.rotation.T cue.velocity = KB_CUE_MOVE_SPEED * (fb * cue.world_matrix[1, :3] + lr * cue.world_matrix[0, :3] + ud * cue.world_matrix[2, :3]) cue.position += cue.velocity * dt return process_keyboard_input
def main(): appName = 'First App' glfw.Init() glfw.WindowHint(glfw.CONTEXT_VERSION_MAJOR, 3) glfw.WindowHint(glfw.CONTEXT_VERSION_MINOR, 3) # glfw.WindowHint(glfw.OPENGL_FORWARD_COMPAT, GL_TRUE) # glfw.WindowHint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE) window = glfw.CreateWindow(800, 800, appName) glfw.SetWindowSizeCallback(window, window_size_callback) glfw.SetKeyCallback(window, key_callback) glfw.MakeContextCurrent(window) glfw.SwapInterval(1) try: initOpenGL() except Exception as e: print(e) exit(1) prevTime = time() frameCount = 0 frameTimeSum = 0 lastUpdateTime = prevTime while not glfw.WindowShouldClose(window): glfw.PollEvents() display(window) glfw.SwapBuffers(window) curTime = time() frameTime = (curTime - prevTime) # if frameTime != 0: print(1 / frameTime) sleep(0.016) if curTime - lastUpdateTime > 1: glfw.SetWindowTitle( window, '%s, FPS: %s' % (appName, str(round(frameCount / frameTimeSum)))) frameCount = 0 frameTimeSum = 0 lastUpdateTime = curTime frameTimeSum += frameTime frameCount += 1 prevTime = curTime glfw.DestroyWindow(window) glfw.Terminate()
def init(self): assert not self._initialized glfw.SetMouseButtonCallback(self._window, self._on_mouse_button) self._double_clicks.set_double_click_callback( self._on_mouse_double_click) glfw.SetScrollCallback(self._window, self._on_scroll) glfw.SetCursorPosCallback(self._window, self._on_mouse_move) glfw.SetKeyCallback(self._window, self._on_keyboard) glfw.SetDropCallback(self._window, self._on_drop) glfw.SetWindowSizeCallback(self._window, self._on_resize) glfw.SetWindowCloseCallback(self._window, lambda window: self._fps_limiter.stop()) yield from self._gl_executor.init_gl_context() yield from self._renderer.init() self._initialized = True
def setup_loop(self, scene, camera): scene.set_camera(camera) scene.update_minmax() camera.compute_matrices() print("Starting rendering...") callbacks = EventCollection(scene, camera) # register key callbacks defined in # yt.visualization.volume_rendering.input_events callbacks.add_key_callback("close_window", "escape") callbacks.add_key_callback("zoomin", "w") callbacks.add_key_callback("zoomout", "s") callbacks.add_key_callback("closeup", "z") callbacks.add_key_callback("cmap_cycle", "c") callbacks.add_key_callback("reset", "r") callbacks.add_key_callback("camera_orto", "o") callbacks.add_key_callback("camera_proj", "p") callbacks.add_key_callback("shader_max", "1") callbacks.add_key_callback("shader_proj", "2") callbacks.add_key_callback("shader_test", "3") callbacks.add_key_callback("print_limits", "g") callbacks.add_key_callback("print_help", "h") callbacks.add_key_callback("debug_buffer", "d") callbacks.add_key_callback("cmap_max_up", "right_bracket") callbacks.add_key_callback("cmap_max_down", "left_bracket") callbacks.add_key_callback("cmap_min_up", "semicolon") callbacks.add_key_callback("cmap_min_down", "apostrophe") callbacks.add_key_callback("cmap_toggle_log", "l") mouse_callbacks = MouseRotation() callbacks.add_mouse_callback( mouse_callbacks.start_rotation, glfw.MOUSE_BUTTON_LEFT ) callbacks.add_mouse_callback( mouse_callbacks.stop_rotation, glfw.MOUSE_BUTTON_LEFT, action="release" ) callbacks.add_framebuffer_callback("framebuffer_size_callback") callbacks.add_render_callback(mouse_callbacks.do_rotation) glfw.SetFramebufferSizeCallback(self.window, callbacks.framebuffer_call) glfw.SetKeyCallback(self.window, callbacks.key_call) glfw.SetMouseButtonCallback(self.window, callbacks.mouse_call) callbacks.draw = True return callbacks
def init_gl(self): if self._is_initialized: return if not glfw.Init(): raise RuntimeError("GLFW Initialization failed") glfw.WindowHint(glfw.CONTEXT_VERSION_MAJOR, 4) glfw.WindowHint(glfw.CONTEXT_VERSION_MINOR, 1) glfw.WindowHint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE) glfw.WindowHint(glfw.DOUBLEBUFFER, False) glfw.SwapInterval(0) self.window = glfw.CreateWindow(self.renderer.window_size[0], self.renderer.window_size[1], self.title) if self.window is None: glfw.Terminate() raise RuntimeError("GLFW Window creation failed") glfw.SetKeyCallback(self.window, self.key_callback) glfw.MakeContextCurrent(self.window) if self.renderer is not None: self.renderer.init_gl() self._is_initialized = True
def __init__(self): glfw.Init() #Init glfw glfw.WindowHint( glfw.CONTEXT_VERSION_MAJOR, 3) #set openGL context version to 3.3 (the latest we can support) glfw.WindowHint(glfw.CONTEXT_VERSION_MINOR, 3) glfw.WindowHint( glfw.OPENGL_FORWARD_COMPAT, GL_TRUE ) #tell OSX we don't give a shit about compatibility and want the newer GLSL versions glfw.WindowHint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE) self.width, self.height = 1440, 900 self.aspect = self.width / float(self.height) self.win = glfw.CreateWindow(self.width, self.height, "test") #self.win = glfw.CreateWindow(self.width, self.height, "test", glfw.GetPrimaryMonitor(), None) self.exitNow = False glfw.MakeContextCurrent(self.win) glViewport(0, 0, self.width, self.height) glEnable(GL_DEPTH_TEST) glClearColor(0.5, 0.5, 0.5, 1.0) #glfw.SetMouseButtonCallback(self.win, self.onMouseButton) glfw.SetKeyCallback(self.win, self.keyPressed) #glfw.SetWindowSizeCallback(self.win, self.onSize) self.objs = [] self.callbacks = {'keyPressed': [], 'keyReleased': [], 'logic': []} self.objs.append(Box(0, 0)) player = Player() self.objs.append(player) self.callbacks['keyPressed'].append(player.getCallback('keyPressed')) self.callbacks['keyReleased'].append(player.getCallback('keyReleased')) self.callbacks['logic'].append(player.getCallback('logic')) #self.callbacks['keyReleased'].append(player.getCallbacks(['keyReleased'])) for obj in self.objs: obj.geomArray = numpy.array(obj.geom, numpy.float32) obj.vao = vertex_array_object.glGenVertexArrays(1) glBindVertexArray(obj.vao) obj.vBuff = glGenBuffers(1) glBindBuffer(GL_ARRAY_BUFFER, obj.vBuff) glBufferData(GL_ARRAY_BUFFER, 4 * len(obj.geom), obj.geomArray, GL_DYNAMIC_DRAW) glEnableVertexAttribArray(0) glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 0, None) #set the size & type of the argument to the shader #compile shaders obj.vertShader = shaders.compileShader(obj.vertShaderString, GL_VERTEX_SHADER) obj.fragShader = shaders.compileShader(obj.fragShaderString, GL_FRAGMENT_SHADER) try: obj.shader = shaders.compileProgram(obj.vertShader, obj.fragShader) except (GLError, RuntimeError) as err: print err glBindVertexArray(0) #unbind our VAO self.colorOffset = 255 * 3 self.OnInit()
opengl_logger.setLevel(logging.INFO) pil_logger = logging.getLogger('PIL') pil_logger.setLevel(logging.WARNING) text_drawer = TextRenderer() glfw.Init() w, h = 800, 600 window = glfw.CreateWindow(w, h, os.path.basename(__file__)) glfw.MakeContextCurrent(window) gl.glClearColor(0.1, 0.1, 0.2, 0.0) text_drawer.init_gl() def on_keydown(window, key, scancode, action, mods): if key == glfw.KEY_ESCAPE and action == glfw.PRESS: glfw.SetWindowShouldClose(window, gl.GL_TRUE) glfw.SetKeyCallback(window, on_keydown) def on_resize(window, width, height): gl.glViewport(0, 0, width, height) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) text_drawer.set_screen_size((width, height)) glfw.SetWindowSizeCallback(window, on_resize) on_resize(window, w, h) _logger.debug('starting render loop...') nframes = 0 dt = float('inf') avg_fps = 0.0 t = lt = st = glfw.GetTime() while not glfw.WindowShouldClose(window): glfw.PollEvents()
def setup_controls(window=None, camera_world_matrix=None, move_speed=None, turn_speed=0.5, screen_capture_prefix='screen-capture'): if move_speed is None: move_speed = 1.5 * abs(camera_world_matrix[3,3] / camera_world_matrix[2,2]) _logger.debug('move_speed = %s', move_speed) _logger.info(''' KEYBOARD CONTROLS: W/S/A/D ----------- move Fwd/Bwd/Lft/Rgt Q/Z --------------- move Up/Down <-/-> (arrow keys)- turn Lft/Rgt C ----------------- capture screenshot Esc --------------- quit ''') camera_position = camera_world_matrix[3, :3] camera_rotation = camera_world_matrix[:3, :3] dposition = np.zeros(3, dtype=np.float32) rotation = np.eye(3, dtype=np.float32) key_state = defaultdict(bool) key_state_chg = defaultdict(bool) def on_keydown(window, key, scancode, action, mods): if key == glfw.KEY_ESCAPE and action == glfw.PRESS: glfw.SetWindowShouldClose(window, gl.GL_TRUE) elif action == glfw.PRESS: if not key_state[key]: key_state_chg[key] = True else: key_state_chg[key] = False key_state[key] = True elif action == glfw.RELEASE: if key_state[key]: key_state_chg[key] = True else: key_state_chg[key] = False key_state[key] = False glfw.SetKeyCallback(window, on_keydown) def on_mousedown(window, button, action, mods): pass glfw.SetMouseButtonCallback(window, on_mousedown) _capture_wait = 0.0 _num_captures = 0 def process_input(dt): nonlocal _capture_wait, _num_captures glfw.PollEvents() if _capture_wait > 0: _capture_wait -= dt elif key_state[glfw.KEY_C]: _logger.info('''capturing screen... camera position: %s''', camera_position) save_screen(window, '.'.join([screen_capture_prefix, '%03d' % _num_captures, 'png'])) _num_captures += 1 _capture_wait = 0.25 dposition[:] = 0.0 if key_state[glfw.KEY_W]: dposition[2] -= dt * move_speed if key_state[glfw.KEY_S]: dposition[2] += dt * move_speed if key_state[glfw.KEY_A]: dposition[0] -= dt * move_speed if key_state[glfw.KEY_D]: dposition[0] += dt * move_speed if key_state[glfw.KEY_Q]: dposition[1] += dt * move_speed if key_state[glfw.KEY_Z]: dposition[1] -= dt * move_speed theta = 0.0 if key_state[glfw.KEY_LEFT]: theta -= dt * turn_speed if key_state[glfw.KEY_RIGHT]: theta += dt * turn_speed if theta: rotation[0,0] = np.cos(theta) rotation[2,2] = rotation[0,0] rotation[0,2] = np.sin(theta) rotation[2,0] = -rotation[0,2] camera_rotation[...] = rotation.dot(camera_world_matrix[:3,:3]) if dposition.any(): camera_position[:] += camera_rotation.T.dot(dposition) return process_input
def add_key_callback(self, callback): if not hasattr(self, '_key_callbacks'): self._key_callbacks = [] glfw.SetKeyCallback(self._window, self.__key_callback__) self._key_callbacks.append(callback)
def view_gltf(gltf, uri_path, scene_name=None, openvr=False, window_size=None): if scene_name is None: scene_name = gltf['scene'] if window_size is None: window_size = [800, 600] window = setup_glfw(width=window_size[0], height=window_size[1], double_buffered=not openvr) def on_resize(window, width, height): window_size[0], window_size[1] = width, height glfw.SetWindowSizeCallback(window, on_resize) if openvr and OpenVRRenderer is not None: vr_renderer = OpenVRRenderer() # text_drawer = TextDrawer() gl.glClearColor(0.01, 0.01, 0.17, 1.0); shader_ids = gltfu.setup_shaders(gltf, uri_path) gltfu.setup_programs(gltf, shader_ids) gltfu.setup_textures(gltf, uri_path) gltfu.setup_buffers(gltf, uri_path) scene = gltf.scenes[scene_name] nodes = [gltf.nodes[n] for n in scene.nodes] for node in nodes: gltfu.update_world_matrices(node, gltf) camera_world_matrix = np.eye(4, dtype=np.float32) projection_matrix = np.array(matrix44.create_perspective_projection_matrix(np.rad2deg(55), window_size[0]/window_size[1], 0.1, 1000), dtype=np.float32) for node in nodes: if 'camera' in node: camera = gltf['cameras'][node['camera']] if 'perspective' in camera: perspective = camera['perspective'] projection_matrix = np.array(matrix44.create_perspective_projection_matrix(np.rad2deg(perspective['yfov']), perspective['aspectRatio'], perspective['znear'], perspective['zfar']), dtype=np.float32) elif 'orthographic' in camera: raise Exception('TODO') camera_world_matrix = node['world_matrix'] break camera_position = camera_world_matrix[3, :3] camera_rotation = camera_world_matrix[:3, :3] dposition = np.zeros(3, dtype=np.float32) rotation = np.eye(3, dtype=np.float32) key_state = defaultdict(bool) def on_keydown(window, key, scancode, action, mods): if key == glfw.KEY_ESCAPE and action == glfw.PRESS: glfw.SetWindowShouldClose(window, gl.GL_TRUE) elif action == glfw.PRESS: key_state[key] = True elif action == glfw.RELEASE: key_state[key] = False glfw.SetKeyCallback(window, on_keydown) def on_mousedown(window, button, action, mods): pass glfw.SetMouseButtonCallback(window, on_mousedown) move_speed = 2.0 turn_speed = 0.5 def process_input(dt): glfw.PollEvents() dposition[:] = 0.0 if key_state[glfw.KEY_W]: dposition[2] -= dt * move_speed if key_state[glfw.KEY_S]: dposition[2] += dt * move_speed if key_state[glfw.KEY_A]: dposition[0] -= dt * move_speed if key_state[glfw.KEY_D]: dposition[0] += dt * move_speed if key_state[glfw.KEY_Q]: dposition[1] += dt * move_speed if key_state[glfw.KEY_Z]: dposition[1] -= dt * move_speed theta = 0.0 if key_state[glfw.KEY_LEFT]: theta -= dt * turn_speed if key_state[glfw.KEY_RIGHT]: theta += dt * turn_speed rotation[0,0] = np.cos(theta) rotation[2,2] = rotation[0,0] rotation[0,2] = np.sin(theta) rotation[2,0] = -rotation[0,2] camera_rotation[...] = rotation.dot(camera_world_matrix[:3,:3]) camera_position[:] += camera_rotation.T.dot(dposition) # sort nodes from front to back to avoid overdraw (assuming opaque objects): nodes = sorted(nodes, key=lambda node: np.linalg.norm(camera_position - node['world_matrix'][3, :3])) _logger.info('starting render loop...') sys.stdout.flush() gltfu.num_draw_calls = 0 nframes = 0 lt = glfw.GetTime() dt_max = 0.0 while not glfw.WindowShouldClose(window): t = glfw.GetTime() dt = t - lt dt_max = max(dt, dt_max) lt = t process_input(dt) if openvr: vr_renderer.process_input() vr_renderer.render(gltf, nodes, window_size) else: gl.glViewport(0, 0, window_size[0], window_size[1]) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) view_matrix = np.linalg.inv(camera_world_matrix) gltfu.set_material_state.current_material = None gltfu.set_technique_state.current_technique = None for node in nodes: gltfu.draw_node(node, gltf, projection_matrix=projection_matrix, view_matrix=view_matrix) # text_drawer.draw_text("%f" % dt, color=(1.0, 1.0, 0.0, 0.0), # view_matrix=view_matrix, # projection_matrix=projection_matrix) if nframes == 0: _logger.info("num draw calls per frame: %d", gltfu.num_draw_calls) sys.stdout.flush() gltfu.num_draw_calls = 0 st = glfw.GetTime() nframes += 1 glfw.SwapBuffers(window) _logger.info('FPS (avg): %f', ((nframes - 1) / (t - st))) _logger.info('MAX FRAME RENDER TIME: %f', dt_max) sys.stdout.flush() if openvr: vr_renderer.shutdown() glfw.DestroyWindow(window) glfw.Terminate()
assert glfw.Init(), 'Glfw Init failed!' glfw.WindowHint(glfw.SAMPLES, samples) window = glfw.CreateWindow(window_width, window_height, window_title, None) assert window, 'Could not create Window!' glfw.MakeContextCurrent(window) assert glInitBindlessTextureNV(), 'Bindless Textures not supported!' framebuf_width, framebuf_height = glfw.GetFramebufferSize(window) def framebuffer_size_callback(window, w, h): global framebuf_width, framebuf_height framebuf_width, framebuf_height = w, h glfw.SetFramebufferSizeCallback(window, framebuffer_size_callback) def key_callback(window, key, scancode, action, mode): if action == glfw.PRESS: if key == glfw.KEY_ESCAPE: glfw.SetWindowShouldClose(window, True) glfw.SetKeyCallback(window, key_callback) previous_second = glfw.GetTime(); frame_count = 0.0 def update_fps_counter(window): global previous_second, frame_count current_second = glfw.GetTime() elapsed_seconds = current_second - previous_second if elapsed_seconds > 1.0: previous_second = current_second fps = float(frame_count) / float(elapsed_seconds) glfw.SetWindowTitle(window, '%s @ FPS: %.2f' % (window_title, fps)) frame_count = 0.0 frame_count += 1.0 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE) glDisable(GL_STENCIL_TEST)
def __init__(self, window_width, window_height, samples=1, window_title="", monitor=1, show_at_center=True, offscreen=False): self.window_title = window_title assert glfw.Init(), "Glfw Init failed!" glfw.WindowHint(glfw.SAMPLES, samples) if offscreen: glfw.WindowHint(glfw.VISIBLE, False) mon = glfw.GetMonitors()[monitor] if monitor != None else None self.windowID = glfw.CreateWindow(window_width, window_height, self.window_title, mon) assert self.windowID, "Could not create Window!" glfw.MakeContextCurrent(self.windowID) if not glInitBindlessTextureNV(): raise RuntimeError("Bindless Textures not supported") self.framebuf_width, self.framebuf_height = glfw.GetFramebufferSize( self.windowID) self.framebuffer_size_callback = [] def framebuffer_size_callback(window, w, h): self.framebuf_width, self.framebuf_height = w, h for callback in self.framebuffer_size_callback: callback(w, h) glfw.SetFramebufferSizeCallback(self.windowID, framebuffer_size_callback) self.key_callback = [] def key_callback(window, key, scancode, action, mode): if action == glfw.PRESS: if key == glfw.KEY_ESCAPE: glfw.SetWindowShouldClose(window, True) for callback in self.key_callback: callback(key, scancode, action, mode) glfw.SetKeyCallback(self.windowID, key_callback) self.mouse_callback = [] def mouse_callback(window, xpos, ypos): for callback in self.mouse_callback: callback(xpos, ypos) glfw.SetCursorPosCallback(self.windowID, mouse_callback) self.mouse_button_callback = [] def mouse_button_callback(window, button, action, mods): for callback in self.mouse_button_callback: callback(button, action, mods) glfw.SetMouseButtonCallback(self.windowID, mouse_button_callback) self.scroll_callback = [] def scroll_callback(window, xoffset, yoffset): for callback in self.scroll_callback: callback(xoffset, yoffset) glfw.SetScrollCallback(self.windowID, scroll_callback) self.previous_second = glfw.GetTime() self.frame_count = 0.0 if show_at_center: monitors = glfw.GetMonitors() assert monitor >= 0 and monitor < len( monitors), "Invalid monitor selected." vidMode = glfw.GetVideoMode(monitors[monitor]) glfw.SetWindowPos( self.windowID, vidMode.width / 2 - self.framebuf_width / 2, vidMode.height / 2 - self.framebuf_height / 2, )
if key == glfw.KEY_RIGHT: cam_angle_xz-=0.4 print("RIGHT") elif key == glfw.KEY_LEFT: cam_angle_xz+=0.4 print("LEFT") elif key == glfw.KEY_UP: cam_angle_xy+=0.4 print("UP") elif key == glfw.KEY_DOWN: cam_angle_xy-=0.4 print("DOWN") camera.x=cam_radius * (math.cos(cam_angle_xz)) camera.y=cam_radius * (math.sin(cam_angle_xy)) camera.z=cam_radius * (math.sin(cam_angle_xz)) glfw.SetKeyCallback(window, key_event) print(camera.x,camera.y,camera.z) while not glfw.WindowShouldClose(window): gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) #LOOK AT view=glm.lookAt(camera, glm.vec3(0, 0, 0), glm.vec3(0, 1, 0)) glize(newscene.rootnode) glfw.SwapBuffers(window) clock.tick(5) glfw.WaitEvents() glfw.Terminate()
def key_callback(self, value): self._key_callback = value if self._win: glfw.SetKeyCallback(self._win, self._key_callback)
def __init__(self, width, height, title): glfw.WindowHint(glfw.CONTEXT_VERSION_MAJOR, 4) glfw.WindowHint(glfw.CONTEXT_VERSION_MINOR, 1) glfw.WindowHint(glfw.OPENGL_FORWARD_COMPAT, 1) glfw.WindowHint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE) glfw.WindowHint(glfw.RESIZABLE, True) glfw.WindowHint(glfw.RED_BITS, 8) glfw.WindowHint(glfw.GREEN_BITS, 8) glfw.WindowHint(glfw.BLUE_BITS, 8) # glfw.WindowHint(glfw.ALPHA_BITS, 8) glfw.WindowHint(glfw.DEPTH_BITS, 24) glfw.WindowHint(glfw.STENCIL_BITS, 8) self.window = glfw.CreateWindow(width, height, title) self.framebufferSize = (width, height) f = 240 pos = np.array([3, 3, 3]) dir = np.array([-1, -1, -1]) up = np.array([0, 0, 1]) near = 0.2 far = 100 self.playerCamera = PlayerCamera(f, self.framebufferSize, pos, dir, up, near, far) self.currentCamera = self.playerCamera self.cameraLocked = True self.mainRender = None self.cairoSavePath = None def key_callback(window, key, scancode, action, mods): if (key == glfw.KEY_ESCAPE and action == glfw.PRESS): glfw.SetWindowShouldClose(window, True) if (action == glfw.PRESS and key == glfw.KEY_L): self.cameraLocked = not self.cameraLocked print 'cameraLocked:', self.cameraLocked glfw.SetInputMode(window, glfw.CURSOR, glfw.CURSOR_NORMAL if self.cameraLocked else glfw.CURSOR_DISABLED) # if not self.cameraLocked: # Ensure that locking/unlocking doesn't move the view: windowWidth, windowHeight = glfw.GetWindowSize(window) glfw.SetCursorPos(window, windowWidth / 2, windowHeight / 2) self.currentCamera.lastCursor = np.array(glfw.GetCursorPos(window), np.float32) self.currentCamera.lastUpdateTime = glfw.GetTime() if (action == glfw.PRESS and key == glfw.KEY_R): self.mainRender.renderCairo(self.playerCamera, self.cairoSavePath) pass # # print( # "keybrd: key=%s scancode=%s action=%s mods=%s" % # (key, scancode, action, mods)) def char_callback(window, char): pass # print("unichr: char=%s" % char) def scroll_callback(window, off_x, off_y): pass # print("scroll: x=%s y=%s" % (off_x, off_y)) def mouse_button_callback(window, button, action, mods): pass # print("button: button=%s action=%s mods=%s" % (button, action, mods)) def cursor_enter_callback(window, status): pass # print("cursor: status=%s" % status) def cursor_pos_callback(window, pos_x, pos_y): pass # print("curpos: x=%s y=%s" % (pos_x, pos_y)) def window_size_callback(window, wsz_w, wsz_h): pass # print("window: w=%s h=%s" % (wsz_w, wsz_h)) def window_pos_callback(window, pos_x, pos_y): pass # print("window: x=%s y=%s" % (pos_x, pos_y)) def window_close_callback(window): pass # print("should: %s" % self.should_close) def window_refresh_callback(window): pass # print("redraw") def window_focus_callback(window, status): pass # print("active: status=%s" % status) def window_iconify_callback(window, status): pass # print("hidden: status=%s" % status) def framebuffer_size_callback(window, fbs_x, fbs_y): print("buffer: x=%s y=%s" % (fbs_x, fbs_y)) self.framebufferSize = (fbs_x, fbs_y) self.playerCamera.framebufferSize = (fbs_x, fbs_y) glViewport(0, 0, self.currentCamera.framebufferSize[0], self.currentCamera.framebufferSize[1]) pass glfw.SetKeyCallback(self.window, key_callback) glfw.SetCharCallback(self.window, char_callback) glfw.SetScrollCallback(self.window, scroll_callback) glfw.SetMouseButtonCallback(self.window, mouse_button_callback) glfw.SetCursorEnterCallback(self.window, cursor_enter_callback) glfw.SetCursorPosCallback(self.window, cursor_pos_callback) glfw.SetWindowSizeCallback(self.window, window_size_callback) glfw.SetWindowPosCallback(self.window, window_pos_callback) glfw.SetWindowCloseCallback(self.window, window_close_callback) glfw.SetWindowRefreshCallback(self.window, window_refresh_callback) glfw.SetWindowFocusCallback(self.window, window_focus_callback) glfw.SetWindowIconifyCallback(self.window, window_iconify_callback) glfw.SetFramebufferSizeCallback(self.window, framebuffer_size_callback)