def main():
if not glfw.init():
return
monitors = glfw.get_monitors()
print('Monitors')
print(glfw.get_monitor_name(monitors[0]))
print(glfw.get_monitor_name(monitors[1]))
print(glfw.get_video_mode(monitors[0]))
print(glfw.get_video_mode(monitors[1]))
print(glfw.get_video_modes(monitors[0]))
print(glfw.get_video_modes(monitors[1]))
window = glfw.create_window(1024, 768, "Opengl GLFW Window", monitors[1],
None)
if not window:
glfw.terminate()
return
glfw.make_context_current(window)
while not glfw.window_should_close(window):
glfw.poll_events()
glfw.swap_buffers(window)
glfw.terminate()
def center_pos(window, monitor_id, W, H):
# W, H: window dimensions
mon = glfw.get_monitors()
xpos = glfw.get_monitor_pos(mon[monitor_id])[0] + \
glfw.get_video_mode(mon[monitor_id]).size[0]/2-W/2
ypos = glfw.get_monitor_pos(mon[monitor_id])[1] + \
glfw.get_video_mode(mon[monitor_id]).size[1]/2-H/2
glfw.set_window_pos(window, int(xpos), int(ypos))
def __init__(self, parent, monitor):
self.parent = parent
self.monitor = monitor
self.running = True
self.modman = ModuleManager()
self.currentSheet = None
self.sheetObjects = {}
self.subsheets = {}
self.miscdata = {} # Special cases are ~fun~! (The f stands for "FUUUCK why did I do this?!")
self.videomode = glfw.get_video_mode(monitor)
self.window = glfw.create_window(100, 100, "Hello World", monitor, None)
#self.window = glfw.create_window(100, 100, "Hello World", None, None)
if not self.window:
raise Exception("Creating window failed")
glfw.set_window_size(self.window, self.videomode[0][0], self.videomode[0][1])
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.set_framebuffer_size_callback(self.window, self.framebufferSizeCallback)
self.deltatime = 0
self.time = glfw.get_time()
self.beatlow = False
self.beatmid = False
self.beathigh = False
self.bpm = 0
def createWindow(self):
self.videomode = glfw.get_video_mode(self.monitor)
#self.window = glfw.create_window(100, 100, "Pyree Worker （´・ω・ `)", self.monitor, None) # Fullscreen
self.window = glfw.create_window(500, 500, "Pyree Worker （´・ω・ `)",
None, None) # windowed
self.width, self.height = glfw.get_window_size(self.window)
#glfw.set_window_size(self.window, self.videomode[0][0], self.videomode[0][1])
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.make_context_current(self.window)
glfw.set_framebuffer_size_callback(self.window,
self.framebufferSizeCallback)
self.fbo = glGenFramebuffers(1)
glBindFramebuffer(GL_FRAMEBUFFER, self.fbo)
self.fbotexture = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, self.fbotexture)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, self.width, self.height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, None)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
self.fbotexture, 0)
def __init__ (self, Module, Title, Width, Height):
global Pyron
Pyron = Module
self.Module = Module
self.Title = Title
self.Width = Width
self.Height = Height
# Change the FPS later idk
FPS = 100
self._NextUpdateTime = 0
self._OneFrameTime = 1 / FPS
self._Update = None
self._Draw = None
Monitor = glfw.get_primary_monitor ()
DisplayWidth, DisplayHeight = glfw.get_video_mode (Monitor)[0]
self._Window = glfw.create_window (_Width, _Height, _Title, None, None)
if not self._Window:
glfw.terminate ()
glfw.set_window_pos (
self._Window,
(DisplayWidth - _Width) // 2,
(DisplayHeight - _Height) // 2
)
def __GetScreenInfo(self, spec):
Renderer.screenStats.width, Renderer.screenStats.height = glfw.get_framebuffer_size(
self.__handle)
vidmode = glfw.get_video_mode(glfw.get_primary_monitor())
Renderer.screenStats.refreshRate = vidmode.refresh_rate
Renderer.screenStats.vsync = spec.vsync
def __init__(self):
super().__init__()
if not glfw.init():
raise ValueError("Failed to initialize glfw")
self.check_glfw_version()
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, self.gl_version.major)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, self.gl_version.minor)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)
glfw.window_hint(glfw.RESIZABLE, self.resizable)
glfw.window_hint(glfw.DOUBLEBUFFER, True)
glfw.window_hint(glfw.DEPTH_BITS, 24)
glfw.window_hint(glfw.SAMPLES, self.samples)
monitor = None
if self.fullscreen:
# Use the primary monitors current resolution
monitor = glfw.get_primary_monitor()
mode = glfw.get_video_mode(monitor)
self.width, self.height = mode.size.width, mode.size.height
print("picked fullscreen mode:", mode)
print("Window size:", self.width, self.height)
self.window = glfw.create_window(self.width, self.height, self.title,
monitor, None)
if not self.window:
glfw.terminate()
raise ValueError("Failed to create window")
if not self.cursor:
glfw.set_input_mode(self.window, glfw.CURSOR, glfw.CURSOR_DISABLED)
# Get the actual buffer size of the window
# This is important for some displays like Apple's Retina as reported window sizes are virtual
self.buffer_width, self.buffer_height = glfw.get_framebuffer_size(
self.window)
print("Frame buffer size:", self.buffer_width, self.buffer_height)
print("Actual window size:", glfw.get_window_size(self.window))
glfw.make_context_current(self.window)
# The number of screen updates to wait from the time glfwSwapBuffers
# was called before swapping the buffers and returning
if self.vsync:
glfw.swap_interval(1)
glfw.set_key_callback(self.window, self.key_event_callback)
glfw.set_cursor_pos_callback(self.window, self.mouse_event_callback)
glfw.set_window_size_callback(self.window, self.window_resize_callback)
# Create mederngl context from existing context
self.ctx = moderngl.create_context(require=self.gl_version.code)
context.WINDOW = self
self.fbo = self.ctx.screen
self.set_default_viewport()
def _glfw_init(width=0, height=0):
window_name = 'pliky'
if not glfw.init():
print("Could not initialize OpenGL context")
exit(1)
mode = glfw.get_video_mode(glfw.get_primary_monitor())
if width == 0 or height == 0:
width = mode.size.width / 2 if width == 0 else width
height = mode.size.height / 2 if height == 0 else height
# OS X supports only forward-compatible core profiles from 3.2
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.DECORATED, False)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, gl.GL_TRUE)
print(f'Window width: {width}, height: {height}')
# Create a windowed mode window and its OpenGL context
window = glfw.create_window(int(width), int(height), window_name, None,
None)
glfw.make_context_current(window)
if window:
glfw.set_window_pos(window, int((mode.size.width - width) / 2),
int((mode.size.height - height) / 2))
else:
glfw.terminate()
print("Could not initialize Window")
exit(1)
return window
def __init__(self, **kwargs):
super().__init__(**kwargs)
if not glfw.init():
raise ValueError("Failed to initialize glfw")
# Configure the OpenGL context
glfw.window_hint(glfw.CONTEXT_CREATION_API, glfw.NATIVE_CONTEXT_API)
glfw.window_hint(glfw.CLIENT_API, glfw.OPENGL_API)
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, self.gl_version[0])
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, self.gl_version[1])
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)
glfw.window_hint(glfw.RESIZABLE, self.resizable)
glfw.window_hint(glfw.DOUBLEBUFFER, True)
glfw.window_hint(glfw.DEPTH_BITS, 24)
glfw.window_hint(glfw.SAMPLES, self.samples)
monitor = None
if self.fullscreen:
monitor = glfw.get_primary_monitor()
mode = glfw.get_video_mode(monitor)
self._width, self._height = mode.size.width, mode.size.height
glfw.window_hint(glfw.RED_BITS, mode.bits.red)
glfw.window_hint(glfw.GREEN_BITS, mode.bits.green)
glfw.window_hint(glfw.BLUE_BITS, mode.bits.blue)
glfw.window_hint(glfw.REFRESH_RATE, mode.refresh_rate)
self._window = glfw.create_window(self.width, self.height, self.title,
monitor, None)
if not self._window:
glfw.terminate()
raise ValueError("Failed to create window")
if not self.cursor:
glfw.set_input_mode(self._window, glfw.CURSOR,
glfw.CURSOR_DISABLED)
self._buffer_width, self._buffer_height = glfw.get_framebuffer_size(
self._window)
glfw.make_context_current(self._window)
if self.vsync:
glfw.swap_interval(1)
glfw.set_key_callback(self._window, self.glfw_key_event_callback)
glfw.set_cursor_pos_callback(self._window,
self.glfw_mouse_event_callback)
glfw.set_mouse_button_callback(self._window,
self.glfw_mouse_button_callback)
glfw.set_window_size_callback(self._window,
self.glfw_window_resize_callback)
if self._create_mgl_context:
self.init_mgl_context()
self.set_default_viewport()
def get_screen_coordinates_per_inch():
primary_monitor = glfw.get_primary_monitor()
primary_monitor_mode = glfw.get_video_mode(primary_monitor)
primary_monitor_width_mm = ffi.new('int*')
glfw.get_monitor_physical_size(primary_monitor, primary_monitor_width_mm,
ffi.NULL)
if primary_monitor_width_mm[0] == 0:
return kdp_per_inch
return primary_monitor_mode.width / (primary_monitor_width_mm[0] / 25.4)
def current_video_mode(self) -> "GUIMonitor.VideoMode":
gl_video_mode = glfw.get_video_mode(self.__gl_handle)
return GUIMonitor.VideoMode(
width=gl_video_mode.size.width,
height=gl_video_mode.size.height,
red_bits=gl_video_mode.bits.red,
green_bits=gl_video_mode.bits.green,
blue_bits=gl_video_mode.bits.blue,
refresh_rate=gl_video_mode.refresh_rate,
)
def __init__(self, **kwargs):
super().__init__(**kwargs)
if not glfw.init():
raise ValueError("Failed to initialize glfw")
# Configure the OpenGL context
glfw.window_hint(glfw.CONTEXT_CREATION_API, glfw.NATIVE_CONTEXT_API)
glfw.window_hint(glfw.CLIENT_API, glfw.OPENGL_API)
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, self.gl_version[0])
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, self.gl_version[1])
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)
glfw.window_hint(glfw.RESIZABLE, self.resizable)
glfw.window_hint(glfw.DOUBLEBUFFER, True)
glfw.window_hint(glfw.DEPTH_BITS, 24)
glfw.window_hint(glfw.SAMPLES, self.samples)
monitor = None
if self.fullscreen:
# Use the primary monitors current resolution
monitor = glfw.get_primary_monitor()
mode = glfw.get_video_mode(monitor)
self.width, self.height = mode.size.width, mode.size.height
# Make sure video mode switching will not happen by
# matching the desktops current video mode
glfw.window_hint(glfw.RED_BITS, mode.bits.red)
glfw.window_hint(glfw.GREEN_BITS, mode.bits.green)
glfw.window_hint(glfw.BLUE_BITS, mode.bits.blue)
glfw.window_hint(glfw.REFRESH_RATE, mode.refresh_rate)
self.window = glfw.create_window(self.width, self.height, self.title, monitor, None)
if not self.window:
glfw.terminate()
raise ValueError("Failed to create window")
if not self.cursor:
glfw.set_input_mode(self.window, glfw.CURSOR, glfw.CURSOR_DISABLED)
self.buffer_width, self.buffer_height = glfw.get_framebuffer_size(self.window)
glfw.make_context_current(self.window)
if self.vsync:
glfw.swap_interval(1)
glfw.set_key_callback(self.window, self.key_event_callback)
glfw.set_cursor_pos_callback(self.window, self.mouse_event_callback)
glfw.set_mouse_button_callback(self.window, self.mouse_button_callback)
glfw.set_window_size_callback(self.window, self.window_resize_callback)
self.ctx = moderngl.create_context(require=self.gl_version_code)
self.print_context_info()
self.set_default_viewport()
def __CreateWindowFullscreen(self, spec):
mon = glfw.get_primary_monitor()
mode = glfw.get_video_mode(mon)
glfw.window_hint(glfw.RED_BITS, mode.bits.red)
glfw.window_hint(glfw.GREEN_BITS, mode.bits.green)
glfw.window_hint(glfw.BLUE_BITS, mode.bits.blue)
glfw.window_hint(glfw.REFRESH_RATE, mode.refresh_rate)
return glfw.create_window(spec.width, spec.height, self.baseTitle, mon,
None)
def start(self):
if not glfw.init():
return
glfw.window_hint(glfw.SAMPLES, 4)
# try stereo if refresh rate is at least 100Hz
window = None
stereo_available = False
_, _, refresh_rate = glfw.get_video_mode(glfw.get_primary_monitor())
if refresh_rate >= 100:
glfw.window_hint(glfw.STEREO, 1)
window = glfw.create_window(500, 500, "Simulate", None, None)
if window:
stereo_available = True
# no stereo: try mono
if not window:
glfw.window_hint(glfw.STEREO, 0)
window = glfw.create_window(500, 500, "Simulate", None, None)
if not window:
glfw.terminate()
return
self.running = True
# Make the window's context current
glfw.make_context_current(window)
width, height = glfw.get_framebuffer_size(window)
width1, height = glfw.get_window_size(window)
self.scale = width * 1.0 / width1
self.window = window
mjlib.mjv_makeObjects(byref(self.objects), 1000)
mjlib.mjv_defaultCamera(byref(self.cam))
mjlib.mjv_defaultOption(byref(self.vopt))
mjlib.mjr_defaultOption(byref(self.ropt))
mjlib.mjr_defaultContext(byref(self.con))
if self.model:
mjlib.mjr_makeContext(self.model.ptr, byref(self.con), 150)
self.autoscale()
else:
mjlib.mjr_makeContext(None, byref(self.con), 150)
glfw.set_cursor_pos_callback(window, self.handle_mouse_move)
glfw.set_mouse_button_callback(window, self.handle_mouse_button)
glfw.set_scroll_callback(window, self.handle_scroll)
def start(self):
if not glfw.init():
return
glfw.window_hint(glfw.SAMPLES, 4)
# try stereo if refresh rate is at least 100Hz
window = None
stereo_available = False
_, _, refresh_rate = glfw.get_video_mode(glfw.get_primary_monitor())
if refresh_rate >= 100:
glfw.window_hint(glfw.STEREO, 1)
window = glfw.create_window(500, 500, "Simulate", None, None)
if window:
stereo_available = True
# no stereo: try mono
if not window:
glfw.window_hint(glfw.STEREO, 0)
window = glfw.create_window(500, 500, "Simulate", None, None)
if not window:
glfw.terminate()
return
self.running = True
# Make the window's context current
glfw.make_context_current(window)
width, height = glfw.get_framebuffer_size(window)
width1, height = glfw.get_window_size(window)
self._scale = width * 1.0 / width1
self.window = window
mjlib.mjv_makeObjects(byref(self.objects), 1000)
mjlib.mjv_defaultCamera(byref(self.cam))
mjlib.mjv_defaultOption(byref(self.vopt))
mjlib.mjr_defaultOption(byref(self.ropt))
mjlib.mjr_defaultContext(byref(self.con))
if self.model:
mjlib.mjr_makeContext(self.model.ptr, byref(self.con), 150)
self.autoscale()
else:
mjlib.mjr_makeContext(None, byref(self.con), 150)
glfw.set_cursor_pos_callback(window, self.handle_mouse_move)
glfw.set_mouse_button_callback(window, self.handle_mouse_button)
glfw.set_scroll_callback(window, self.handle_scroll)
def _toggle_fullscreen(self):
if glfw.get_window_monitor(self._window): # fullscreen to window
glfw.set_window_monitor(self._window, None, *self._window_info, 0)
else: # window to fullscreen
info = [0] * 4
info[0], info[1] = glfw.get_window_pos(self._window)
info[2], info[3] = glfw.get_window_size(self._window)
self._window_info = info
monitor = glfw.get_primary_monitor()
size = glfw.get_video_mode(monitor)[0]
glfw.set_window_monitor(self._window, monitor, 0, 0, *size, 0)
def toggle_fullscreen(self):
if self.fullscreen:
glfw.set_window_monitor(self.window, None, *self.saved_size,
util.get_opts().fps)
else:
self.saved_size = self.x, self.y, self.win_width, self.win_height
monitor = glfw.get_primary_monitor()
mode = glfw.get_video_mode(monitor)
glfw.set_window_monitor(self.window, monitor, 0, 0,
mode.size.width, mode.size.height,
mode.refresh_rate)
self.fullscreen = not self.fullscreen
def toggle_fullscreen(self):
if self.fullscreen:
glfw.set_window_monitor(self.window, None, *self.saved_size,
util.get_opts().fps)
else:
self.saved_size = self.x, self.y, self.win_width, self.win_height
monitor = glfw.get_primary_monitor()
mode = glfw.get_video_mode(monitor)
glfw.set_window_monitor(self.window, monitor, 0, 0,
mode.size.width, mode.size.height,
mode.refresh_rate)
self.fullscreen = not self.fullscreen
def open_output_window(self):
self._pause_event_loop()
# Select monitor
self._select_monitor()
# Open window
if self.monitor:
# Fullscreen
self._select_video_mode()
x, y = glfw.get_monitor_pos(self.monitor)
logger.info("Output selected : {} on {} at {},{}".format(
str(self.video_mode), glfw.get_monitor_name(self.monitor), x,
y))
w, h = self.video_mode[0]
self.pano_renderer.setViewport(w, h)
self.pano_renderer.setRefreshRate(
self._convert_rate(30), self._convert_rate(self.video_mode[2]))
if self.output_window:
glfw.set_window_monitor(self.output_window, self.monitor, x, y,
w, h, self.video_mode[2])
glfw.show_window(self.output_window)
self.pano_renderer.enableOutput(True)
else:
self._open_output_window(w, h, self.monitor, self.video_mode)
else:
# No monitor available or windowed
w = self.width / 4
h = self.height / 4
self.pano_renderer.setViewport(w, h)
monitor = glfw.get_primary_monitor()
if monitor:
rate = glfw.get_video_mode(monitor)[2]
self.pano_renderer.setRefreshRate(self._convert_rate(30),
self._convert_rate(rate))
if self.output_window:
self.pano_renderer.enableOutput(True)
glfw.show_window(self.output_window)
else:
self._open_output_window(w, h)
if not SETTINGS.display in ["window", "windowed"]:
# No monitor available
glfw.hide_window(self.output_window)
self._unpause_event_loop()
def run(self, width, height, resizable, title, background_color):
self.init_glfw()
glfw.window_hint(glfw.RESIZABLE, resizable)
window = glfw.create_window(width, height, title, None, None)
self.window = window
self.refresh_rate = glfw.get_video_mode(
glfw.get_primary_monitor()).refresh_rate
glfw.make_context_current(window)
glfw.swap_interval(1) # vsync
glfw.set_key_callback(window, self.key_callback)
glfw.set_mouse_button_callback(window, self.mouse_button_callback)
glfw.set_framebuffer_size_callback(window,
self.framebuffer_size_callback)
glfw.set_monitor_callback(self.monitor_callback)
self.reset_canvas_size(*glfw.get_framebuffer_size(window))
self.monitor_callback()
self.change_background_color(background_color)
context = self.drawy_module
context.FRAME = 0
self.sync_context_with_main()
self.reload_module(self.main_module)
try:
self.call_from_main("init", [], reraise=True)
except:
return
while not glfw.window_should_close(window):
self.reload_main_if_modified()
canvas = context._canvas
context.MOUSE_POSITION = context.Point(
*glfw.get_cursor_pos(window))
canvas.clear(self.background_color)
self.sync_context_with_main()
self.draw_frame()
canvas.flush()
glfw.swap_buffers(window)
glfw.poll_events()
context.FRAME += 1
self.gpu_context.abandonContext()
glfw.terminate()
def open_window(self):
if not self._window:
if self.fullscreen:
try:
monitor = glfw.get_monitors()[self.monitor_idx]
except Exception:
logger.warning(
"Monitor at index %s no longer availalbe using default"
% idx)
self.monitor_idx = 0
monitor = glfw.get_monitors()[self.monitor_idx]
mode = glfw.get_video_mode(monitor)
height, width = mode.size.height, mode.size.width
else:
monitor = None
height, width = 640, 480
self._window = glfw.create_window(
height,
width,
"Calibration",
monitor,
glfw.get_current_context(),
)
if not self.fullscreen:
# move to y = 31 for windows os
glfw.set_window_pos(self._window, 200, 31)
# Register callbacks
glfw.set_framebuffer_size_callback(self._window, on_resize)
glfw.set_key_callback(self._window, self.on_window_key)
glfw.set_window_close_callback(self._window, self.on_close)
glfw.set_mouse_button_callback(self._window,
self.on_window_mouse_button)
on_resize(self._window, *glfw.get_framebuffer_size(self._window))
# gl_state settings
active_window = glfw.get_current_context()
glfw.make_context_current(self._window)
basic_gl_setup()
glfw.make_context_current(active_window)
self.clicks_to_close = 5
def init():
if not glfw.init():
return
# Create window
m = glfw.get_primary_monitor()
mode = glfw.get_video_mode(m)
width = mode.size.width
height = mode.size.height
window = glfw.create_window(width, height, "Fractals", None, None)
if not window:
glfw.terminate()
exit(0)
glfw.make_context_current(window)
impl = GlfwRenderer(window)
#compile shaders
try:
mandelbrot_shader = from_files_names("fractal_v.glsl",
"mandelbrot_f.glsl")
julia_shader = from_files_names("fractal_v.glsl", "julia_f.glsl")
newton_shader = from_files_names("fractal_v.glsl", "newton_f.glsl")
except ShaderCompilationError as e:
print(e.logs)
exit()
#setup data used for window and shaders
window_dict = {
'width': width,
'height': height,
'n_iter': 100,
'b': 2,
'scalar': 4.5,
'x_off': 0,
'y_off': 0
}
window_dict = struct(window_dict)
#setep callback so they can change local variables
glfw.set_key_callback(window,
lambda *args: key_callback(window_dict, *args))
glfw.set_window_size_callback(
window, lambda *args: window_size_callback(window_dict, *args))
#quad we are drawing to
quad = pyglet.graphics.vertex_list(
4, ('v2f', (-1.0, -1.0, -1.0, 1.0, 1.0, -1.0, 1.0, 1.0)))
return window, window_dict, impl, quad, mandelbrot_shader, julia_shader, newton_shader
def __init__(self, model, data):
self._gui_lock = Lock()
self._button_left_pressed = False
self._button_right_pressed = False
self._last_mouse_x = 0
self._last_mouse_y = 0
self._paused = False
self._transparent = False
self._contacts = False
self._render_every_frame = True
self._image_idx = 0
self._image_path = "/tmp/frame_%07d.png"
self._time_per_render = 1 / 60.0
self._run_speed = 1.0
self._loop_count = 0
self._advance_by_one_step = False
self._hide_menu = False
# glfw init
glfw.init()
width, height = glfw.get_video_mode(glfw.get_primary_monitor()).size
self.window = glfw.create_window(width // 2, height // 2, "mujoco",
None, None)
glfw.make_context_current(self.window)
glfw.swap_interval(1)
framebuffer_width, framebuffer_height = glfw.get_framebuffer_size(
self.window)
window_width, _ = glfw.get_window_size(self.window)
self._scale = framebuffer_width * 1.0 / window_width
# set callbacks
glfw.set_cursor_pos_callback(self.window, self._cursor_pos_callback)
glfw.set_mouse_button_callback(self.window,
self._mouse_button_callback)
glfw.set_scroll_callback(self.window, self._scroll_callback)
glfw.set_key_callback(self.window, self._key_callback)
# get viewport
self.viewport = mujoco.MjrRect(0, 0, framebuffer_width,
framebuffer_height)
super().__init__(model, data, offscreen=False)
def init_window():
def 超融合():
glfw.window_hint(glfw.DECORATED, False)
glfw.window_hint(glfw.TRANSPARENT_FRAMEBUFFER, True)
glfw.window_hint(glfw.FLOATING, True)
glfw.init()
超融合()
glfw.window_hint(glfw.SAMPLES, 4)
# glfw.window_hint(glfw.RESIZABLE, False)
window = glfw.create_window(*Vtuber尺寸, 'Vtuber', None, None)
glfw.make_context_current(window)
monitor_size = glfw.get_video_mode(glfw.get_primary_monitor()).size
glfw.set_window_pos(window, monitor_size.width - Vtuber尺寸[0], monitor_size.height - Vtuber尺寸[1])
glViewport(0, 0, *Vtuber尺寸)
glEnable(GL_TEXTURE_2D)
glEnable(GL_BLEND)
glEnable(GL_MULTISAMPLE)
glEnable(GL_CULL_FACE)
glCullFace(GL_FRONT)
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA)
return window
def _set_fullscreen(self, value: bool) -> None:
monitor = glfw.get_primary_monitor()
mode = glfw.get_video_mode(monitor)
refresh_rate = mode.refresh_rate if self.vsync else glfw.DONT_CARE
self.resizable = not value
glfw.window_hint(glfw.RESIZABLE, self.resizable)
if value:
# enable fullscreen
self._non_fullscreen_size = self.width, self.height
self._non_fullscreen_position = self.position
glfw.set_window_monitor(
self._window,
monitor,
0,
0,
mode.size.width,
mode.size.height,
refresh_rate,
)
glfw.window_hint(glfw.RED_BITS, mode.bits.red)
glfw.window_hint(glfw.GREEN_BITS, mode.bits.green)
glfw.window_hint(glfw.BLUE_BITS, mode.bits.blue)
glfw.window_hint(glfw.REFRESH_RATE, mode.refresh_rate)
else:
# disable fullscreen
glfw.set_window_monitor(
self._window,
None,
*self._non_fullscreen_position,
*self._non_fullscreen_size,
refresh_rate
)
if self.vsync:
glfw.swap_interval(1)
else:
glfw.swap_interval(0)
def __initializeWindow(self):
if not glfw.init():
return
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 2)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, glfw.TRUE)
monitor = glfw.get_primary_monitor()
mode = glfw.get_video_mode(monitor)
self.window = glfw.create_window(Config.WINDOW_WIDTH, Config.WINDOW_HEIGHT, "My OpenGL window", None, None)
if not self.window:
glfw.terminate()
return
glfw.set_cursor_pos_callback(self.window, mouse_look_clb)
glfw.set_key_callback(self.window, key_input_clb)
#glfw.set_framebuffer_size_callback(self.window, framebuffer_size_callback)
glfw.make_context_current(self.window)
glfw.set_input_mode(self.window, glfw.CURSOR, glfw.CURSOR_DISABLED)
def __init__(self, win, *args, **kwargs):
"""Set up the backend window according the params of the PsychoPy win
Before PsychoPy 1.90.0 this code was executed in Window._setupPygame()
:param win: a PsychoPy Window (usually not fully created yet)
:param share: a PsychoPy Window to share a context with
:param bpc: list-like, bits per color (R, G, B)
:param refreshHz: int, refresh rate
:param depthBits: int, framebuffer depth bits
:param stencilBits: int, framebuffer stencil bits
:param swapInterval: int, screen updates before swapping buffers
:param winTitle: str, optional window title
"""
BaseBackend.__init__(self, win)
# window to share a context with
share_win = kwargs.get('share', None)
if share_win is not None:
if share_win.winType == 'glfw':
share_context = share_win.winHandle
else:
logging.warning(
'Cannot share a context with a non-GLFW window. Disabling.'
)
share_context = None
else:
share_context = None
if sys.platform == 'darwin' and not win.useRetina and pyglet.version >= "1.3":
raise ValueError("As of PsychoPy 1.85.3 OSX windows should all be "
"set to useRetina=True (or remove the argument). "
"Pyglet 1.3 appears to be forcing "
"us to use retina on any retina-capable screen "
"so setting to False has no effect.")
# window framebuffer configuration
win.bpc = kwargs.get('bpc', (8, 8, 8)) # nearly all displays use 8 bpc
win.refreshHz = int(kwargs.get('refreshHz', 60))
win.depthBits = int(kwargs.get('depthBits', 8))
win.stencilBits = int(kwargs.get('stencilBits', 8))
# TODO - make waitBlanking set this too, independent right now
win.swapInterval = int(kwargs.get('swapInterval', 1)) # vsync ON if 1
# get monitors, with GLFW the primary display is ALWAYS at index 0
allScrs = glfw.get_monitors()
if len(allScrs) < int(win.screen) + 1:
logging.warn("Requested an unavailable screen number - "
"using first available.")
win.screen = 0
this_screen = allScrs[win.screen]
if win.autoLog:
logging.info('configured GLFW screen %i' % win.screen)
# find a matching video mode (can we even support this configuration?)
vidmode_is_supported = False
for vidmode in glfw.get_video_modes(this_screen):
_size, _bpc, _hz = vidmode
if win._isFullScr: # size and refresh rate are ignored if windowed
has_size = _size == tuple(win.size)
has_hz = _hz == win.refreshHz
else:
has_size = has_hz = True
has_bpc = _bpc == tuple(win.bpc)
if has_size and has_bpc and has_hz:
vidmode_is_supported = True
break
_size, _bpc, _hz = glfw.get_video_mode(this_screen)
if not vidmode_is_supported:
# the requested video mode is not supported, use current
logging.warning(
("The specified video mode is not supported by this display, "
"using native mode ..."))
logging.warning(
("Overriding user video settings: size {} -> {}, bpc {} -> "
"{}, refreshHz {} -> {}".format(tuple(win.size), _size,
tuple(win.bpc), _bpc,
win.refreshHz, _hz)))
# change the window settings
win.bpc = _bpc
win.refreshHz = _hz
win.size = _size
if win._isFullScr:
use_display = this_screen
else:
use_display = None
# configure stereo
use_stereo = 0
if win.stereo:
# provide warning if stereo buffers are requested but unavailable
if not glfw.extension_supported('GL_STEREO'):
logging.warning(
'A stereo window was requested but the graphics '
'card does not appear to support GL_STEREO')
win.stereo = False
else:
use_stereo = 1
# setup multisampling
# This enables multisampling on the window backbuffer, not on other
# framebuffers.
msaa_samples = 0
if win.multiSample:
max_samples = (GL.GLint)()
GL.glGetIntegerv(GL.GL_MAX_SAMPLES, max_samples)
if (win.numSamples & (win.numSamples - 1)) != 0:
# power of two?
logging.warning(
'Invalid number of MSAA samples provided, must be '
'power of two. Disabling.')
elif 0 > win.numSamples > max_samples.value:
# check if within range
logging.warning(
'Invalid number of MSAA samples provided, outside of valid '
'range. Disabling.')
else:
msaa_samples = win.numSamples
win.multiSample = msaa_samples > 0
# disable stencil buffer
if win.allowStencil:
win.stencilBits = 0
# set buffer configuration hints
glfw.window_hint(glfw.RED_BITS, win.bpc[0])
glfw.window_hint(glfw.GREEN_BITS, win.bpc[1])
glfw.window_hint(glfw.BLUE_BITS, win.bpc[2])
glfw.window_hint(glfw.REFRESH_RATE, win.refreshHz)
glfw.window_hint(glfw.STEREO, use_stereo)
glfw.window_hint(glfw.SAMPLES, msaa_samples)
glfw.window_hint(glfw.STENCIL_BITS, win.stencilBits)
glfw.window_hint(glfw.DEPTH_BITS, win.depthBits)
# window appearance and behaviour hints
if not win.allowGUI:
glfw.window_hint(glfw.DECORATED, 0)
glfw.window_hint(glfw.AUTO_ICONIFY, 0)
# window title
title_text = str(kwargs.get('winTitle', "PsychoPy (GLFW)"))
# create the window
self.winHandle = glfw.create_window(width=win.size[0],
height=win.size[1],
title=title_text,
monitor=use_display,
share=share_context)
# set the window icon
glfw.set_window_icon(self.winHandle, 1, _WINDOW_ICON_)
# The window's user pointer maps the Python Window object to its GLFW
# representation.
glfw.set_window_user_pointer(self.winHandle, win)
glfw.make_context_current(self.winHandle) # ready to use
# set the window size to the framebuffer size
win.size = np.array(glfw.get_framebuffer_size(self.winHandle))
if win.useFBO: # check for necessary extensions
if not glfw.extension_supported('GL_EXT_framebuffer_object'):
msg = ("Trying to use a framebuffer object but "
"GL_EXT_framebuffer_object is not supported. Disabled")
logging.warn(msg)
win.useFBO = False
if not glfw.extension_supported('GL_ARB_texture_float'):
msg = ("Trying to use a framebuffer object but "
"GL_ARB_texture_float is not supported. Disabling")
logging.warn(msg)
win.useFBO = False
# Assign event callbacks, these are dispatched when 'poll_events' is
# called.
glfw.set_mouse_button_callback(self.winHandle,
event._onGLFWMouseButton)
glfw.set_scroll_callback(self.winHandle, event._onGLFWMouseScroll)
glfw.set_key_callback(self.winHandle, event._onGLFWKey)
glfw.set_char_mods_callback(self.winHandle, event._onGLFWText)
# enable vsync, GLFW has additional setting for this that might be
# useful.
glfw.swap_interval(win.swapInterval)
# give the window class GLFW specific methods
win.setMouseType = self.setMouseType
if not win.allowGUI:
self.setMouseVisibility(False)
#glfw.set_window_size_callback(self.winHandle, _onResize)
#self.winHandle.on_resize = _onResize # avoid circular reference
# TODO - handle window resizing
# Set the position of the window if not fullscreen.
if not win.pos:
# work out where the centre should be
win.pos = [(_size[0] - win.size[0]) / 2.0,
(_size[1] - win.size[1]) / 2.0]
if not win._isFullScr:
# get the virtual position of the monitor, apply offset to pos
_px, _py = glfw.get_monitor_pos(this_screen)
glfw.set_window_pos(self.winHandle, int(win.pos[0] + _px),
int(win.pos[1] + _py))
def __init__(
self,
module,
width,
height,
caption,
scale,
palette,
fps,
border_width,
border_color,
):
if glfw.get_version() < tuple(map(int, GLFW_VERSION.split("."))):
raise RuntimeError(
"glfw version is lower than {}".format(GLFW_VERSION))
if width > APP_SCREEN_MAX_SIZE or height > APP_SCREEN_MAX_SIZE:
raise ValueError("screen size is larger than {}x{}".format(
APP_SCREEN_MAX_SIZE, APP_SCREEN_MAX_SIZE))
self._module = module
self._palette = palette[:]
self._pil_palette = self._get_pil_palette(palette)
self._fps = fps
self._border_width = border_width
self._border_color = border_color
self._next_update_time = 0
self._one_frame_time = 1 / fps
self._key_state = {}
self._update = None
self._draw = None
self._capture_start = 0
self._capture_index = 0
self._capture_images = [None] * APP_GIF_CAPTURE_COUNT
self._perf_monitor_is_enabled = False
self._perf_fps_count = 0
self._perf_fps_start_time = 0
self._perf_fps = 0
self._perf_update_count = 0
self._perf_update_total_time = 0
self._perf_update_time = 0
self._perf_draw_count = 0
self._perf_draw_total_time = 0
self._perf_draw_time = 0
module.width = width
module.height = height
module.mouse_x = 0
module.mouse_y = 0
module.frame_count = 0
# initialize window
if not glfw.init():
exit()
monitor = glfw.get_primary_monitor()
display_width, display_height = glfw.get_video_mode(monitor)[0]
if scale == 0:
scale = max(
min(
(display_width // width) - APP_SCREEN_SCALE_CUTDOWN,
(display_height // height) - APP_SCREEN_SCALE_CUTDOWN,
),
APP_SCREEN_SCALE_MINIMUM,
)
window_width = width * scale + border_width
window_height = height * scale + border_width
self._window = glfw.create_window(window_width, window_height, caption,
None, None)
if not self._window:
glfw.terminate()
exit()
glfw.set_window_pos(
self._window,
(display_width - window_width) // 2,
(display_height - window_height) // 2,
)
glfw.make_context_current(self._window)
glfw.set_window_size_limits(self._window, width, height,
glfw.DONT_CARE, glfw.DONT_CARE)
self._hidpi_scale = (glfw.get_framebuffer_size(self._window)[0] /
glfw.get_window_size(self._window)[0])
self._update_viewport()
glfw.set_key_callback(self._window, self._key_callback)
glfw.set_cursor_pos_callback(self._window, self._cursor_pos_callback)
glfw.set_mouse_button_callback(self._window,
self._mouse_button_callback)
glfw.set_window_icon(self._window, 1, [self._get_icon_image()])
# initialize renderer
self._renderer = Renderer(width, height)
# initialize audio player
self._audio_player = AudioPlayer()
# export module functions
module.btn = self.btn
module.btnp = self.btnp
module.btnr = self.btnr
module.run = self.run
module.run_with_profiler = self.run_with_profiler
module.quit = self.quit
module.save = self.save
module.load = self.load
module.image = self._renderer.image
module.tilemap = self._renderer.tilemap
module.clip = self._renderer.draw_command.clip
module.pal = self._renderer.draw_command.pal
module.cls = self._renderer.draw_command.cls
module.pix = self._renderer.draw_command.pix
module.line = self._renderer.draw_command.line
module.rect = self._renderer.draw_command.rect
module.rectb = self._renderer.draw_command.rectb
module.circ = self._renderer.draw_command.circ
module.circb = self._renderer.draw_command.circb
module.blt = self._renderer.draw_command.blt
module.bltm = self._renderer.draw_command.bltm
module.text = self._renderer.draw_command.text
module.sound = self._audio_player.sound
module.play = self._audio_player.play
# module.playm = self._audio_player.playm
module.stop = self._audio_player.stop
def start(self):
logger.info('initializing glfw@%s', glfw.get_version())
glfw.set_error_callback(_glfw_error_callback)
if not glfw.init():
raise Exception('glfw failed to initialize')
window = None
if self.visible:
glfw.window_hint(glfw.SAMPLES, 4)
else:
glfw.window_hint(glfw.VISIBLE, 0);
# try stereo if refresh rate is at least 100Hz
stereo_available = False
_, _, refresh_rate = glfw.get_video_mode(glfw.get_primary_monitor())
if refresh_rate >= 100:
glfw.window_hint(glfw.STEREO, 1)
window = glfw.create_window(
self.init_width, self.init_height, "Simulate", None, None)
if window:
stereo_available = True
# no stereo: try mono
if not window:
glfw.window_hint(glfw.STEREO, 0)
window = glfw.create_window(
self.init_width, self.init_height, "Simulate", None, None)
if not window:
glfw.terminate()
return
self.running = True
# Make the window's context current
glfw.make_context_current(window)
self._init_framebuffer_object()
width, height = glfw.get_framebuffer_size(window)
width1, height = glfw.get_window_size(window)
self._scale = width * 1.0 / width1
self.window = window
mjlib.mjv_makeObjects(byref(self.objects), 1000)
mjlib.mjv_defaultCamera(byref(self.cam))
mjlib.mjv_defaultOption(byref(self.vopt))
mjlib.mjr_defaultOption(byref(self.ropt))
mjlib.mjr_defaultContext(byref(self.con))
if self.model:
mjlib.mjr_makeContext(self.model.ptr, byref(self.con), 150)
self.autoscale()
else:
mjlib.mjr_makeContext(None, byref(self.con), 150)
glfw.set_cursor_pos_callback(window, self.handle_mouse_move)
glfw.set_mouse_button_callback(window, self.handle_mouse_button)
glfw.set_scroll_callback(window, self.handle_scroll)
return False
def on_refresh():
log("Refresh")
glClear(GL_COLOR_BUFFER_BIT)
glfw.SwapBuffers()
glfw.init()
pm = glfw.get_primary_monitor()
vms = glfw.get_video_modes(pm)
print("Available video modes:\n%s\n" % "\n".join(map(str, vms)))
vm = glfw.get_video_mode(pm)
print("Desktop video mode:\n%s\n" % str(vm))
print("GLFW Version: %d.%d.%d" % glfw.get_version())
w = glfw.create_window(800, 600, 'test', None, None)
#print("OpenGL version: %d.%d.%d\n" % glfw.get_gl_version())
#glfw.ext.set_icons([(icon_data, icon_width, icon_height)])
glfw.set_window_title(w, "pyglfw test")
#glfw.disable(w, glfw.AUTO_POLL_EVENTS)
#glfw.enable(w, glfw.KEY_REPEAT)
center_x = int(vm[0][0] / 2 - glfw.get_window_size(w)[0] / 2)
center_y = int(vm[0][1] / 2 - glfw.get_window_size(w)[1] / 2)
print("new window position: {!s}, {!s}".format(center_x, center_y))
config_file = open('config.txt', 'r')
ip, port, = open('config.txt', 'r').readline().split()
player_id = registerMe('OpenGL')
t1 = threading.Thread(target=asking, daemon=True).start()
t2 = threading.Thread(target=sending, daemon=True).start()
if not glfw.init():
exit(0)
glfw.window_hint(glfw.RESIZABLE, GL_FALSE)
glfw.window_hint(glfw.SAMPLES, 8)
window = glfw.create_window(WINDOW_WIDTH, WINDOW_HEIGHT, 'agar.io', None, None)
w, h = glfw.get_video_mode(glfw.get_primary_monitor())[0]
glfw.set_window_pos(window, (w - WINDOW_WIDTH) // 2, (h - WINDOW_HEIGHT) // 2)
glfw.set_cursor_pos_callback(window, on_motion)
if not window:
glfw.terminate()
exit(0)
glfw.make_context_current(window)
glfw.swap_interval(1)
glClearColor(1., 1., 1., 1.)
glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluOrtho2D(0, WINDOW_WIDTH, WINDOW_HEIGHT, 0)
def __init__(self, win, *args, **kwargs):
"""Set up the backend window according the params of the PsychoPy win
Before PsychoPy 1.90.0 this code was executed in Window._setupPygame()
Parameters
----------
win : psychopy.visual.Window instance
PsychoPy Window (usually not fully created yet).
share : psychopy.visual.Window instance
PsychoPy Window to share a context with
bpc : array_like
Bits per color (R, G, B).
refreshHz : int
Refresh rate in Hertz.
depthBits : int,
Framebuffer (back buffer) depth bits.
swapInterval : int
Swap interval for the current OpenGL context.
stencilBits : int
Framebuffer (back buffer) stencil bits.
winTitle : str
Optional window title string.
*args
Additional position arguments.
**kwargs
Additional keyword arguments.
"""
BaseBackend.__init__(self, win)
# window to share a context with
shareWin = kwargs.get('share', None)
if shareWin is not None:
if shareWin.winType == 'glfw':
shareContext = shareWin.winHandle
else:
logging.warning(
'Cannot share a context with a non-GLFW window. Disabling.')
shareContext = None
else:
shareContext = None
if sys.platform=='darwin' and not win.useRetina and pyglet.version >= "1.3":
raise ValueError("As of PsychoPy 1.85.3 OSX windows should all be "
"set to useRetina=True (or remove the argument). "
"Pyglet 1.3 appears to be forcing "
"us to use retina on any retina-capable screen "
"so setting to False has no effect.")
# window framebuffer configuration
win.bpc = kwargs.get('bpc', (8, 8, 8)) # nearly all displays use 8 bpc
win.refreshHz = int(kwargs.get('refreshHz', 60))
win.depthBits = int(kwargs.get('depthBits', 8))
win.stencilBits = int(kwargs.get('stencilBits', 8))
# win.swapInterval = int(kwargs.get('swapInterval', 1)) # vsync ON if 1
# get monitors, with GLFW the primary display is ALWAYS at index 0
allScrs = glfw.get_monitors()
if len(allScrs) < int(win.screen) + 1:
logging.warn("Requested an unavailable screen number - "
"using first available.")
win.screen = 0
thisScreen = allScrs[win.screen]
if win.autoLog:
logging.info('configured GLFW screen %i' % win.screen)
# find a matching video mode (can we even support this configuration?)
isVidmodeSupported = False
for vidmode in glfw.get_video_modes(thisScreen):
size, bpc, hz = vidmode
if win._isFullScr: # size and refresh rate are ignored if windowed
hasSize = size == tuple(win.size)
hasHz = hz == win.refreshHz
else:
hasSize = hasHz = True
hasBpc = bpc == tuple(win.bpc)
if hasSize and hasBpc and hasHz:
isVidmodeSupported = True
break
nativeVidmode = glfw.get_video_mode(thisScreen)
if not isVidmodeSupported:
# the requested video mode is not supported, use current
logging.warning(
("The specified video mode is not supported by this display, "
"using native mode ..."))
logging.warning(
("Overriding user video settings: size {} -> {}, bpc {} -> "
"{}, refreshHz {} -> {}".format(
tuple(win.size),
nativeVidmode[0],
tuple(win.bpc),
nativeVidmode[1],
win.refreshHz,
nativeVidmode[2])))
# change the window settings
win.size, win.bpc, win.refreshHz = nativeVidmode
if win._isFullScr:
useDisplay = thisScreen
else:
useDisplay = None
# configure stereo
useStereo = 0
if win.stereo:
# provide warning if stereo buffers are requested but unavailable
if not glfw.extension_supported('GL_STEREO'):
logging.warning(
'A stereo window was requested but the graphics '
'card does not appear to support GL_STEREO')
win.stereo = False
else:
useStereo = 1
# setup multisampling
# This enables multisampling on the window backbuffer, not on other
# framebuffers.
msaaSamples = 0
if win.multiSample:
maxSamples = (GL.GLint)()
GL.glGetIntegerv(GL.GL_MAX_SAMPLES, maxSamples)
if (win.numSamples & (win.numSamples - 1)) != 0:
# power of two?
logging.warning(
'Invalid number of MSAA samples provided, must be '
'power of two. Disabling.')
elif 0 > win.numSamples > maxSamples.value:
# check if within range
logging.warning(
'Invalid number of MSAA samples provided, outside of valid '
'range. Disabling.')
else:
msaaSamples = win.numSamples
win.multiSample = msaaSamples > 0
# disable stencil buffer
if not win.allowStencil:
win.stencilBits = 0
# set buffer configuration hints
glfw.window_hint(glfw.RED_BITS, win.bpc[0])
glfw.window_hint(glfw.GREEN_BITS, win.bpc[1])
glfw.window_hint(glfw.BLUE_BITS, win.bpc[2])
glfw.window_hint(glfw.REFRESH_RATE, win.refreshHz)
glfw.window_hint(glfw.STEREO, useStereo)
glfw.window_hint(glfw.SAMPLES, msaaSamples)
glfw.window_hint(glfw.STENCIL_BITS, win.stencilBits)
glfw.window_hint(glfw.DEPTH_BITS, win.depthBits)
glfw.window_hint(glfw.AUTO_ICONIFY, 0)
# window appearance and behaviour hints
if not win.allowGUI:
glfw.window_hint(glfw.DECORATED, 0)
# create the window
self.winHandle = glfw.create_window(
width=win.size[0],
height=win.size[1],
title=str(kwargs.get('winTitle', "PsychoPy (GLFW)")),
monitor=useDisplay,
share=shareContext)
# The window's user pointer maps the Python Window object to its GLFW
# representation.
glfw.set_window_user_pointer(self.winHandle, win)
glfw.make_context_current(self.winHandle) # ready to use
# set the position of the window if not fullscreen
if not win._isFullScr:
# if no window position is specified, centre it on-screen
if win.pos is None:
size, bpc, hz = nativeVidmode
win.pos = [(size[0] - win.size[0]) / 2.0,
(size[1] - win.size[1]) / 2.0]
# get the virtual position of the monitor, apply offset to the
# window position
px, py = glfw.get_monitor_pos(thisScreen)
glfw.set_window_pos(self.winHandle,
int(win.pos[0] + px),
int(win.pos[1] + py))
elif win._isFullScr and win.pos is not None:
logging.warn("Ignoring window 'pos' in fullscreen mode.")
# set the window icon
glfw.set_window_icon(self.winHandle, 1, _WINDOW_ICON_)
# set the window size to the framebuffer size
win.size = np.array(glfw.get_framebuffer_size(self.winHandle))
if win.useFBO: # check for necessary extensions
if not glfw.extension_supported('GL_EXT_framebuffer_object'):
msg = ("Trying to use a framebuffer object but "
"GL_EXT_framebuffer_object is not supported. Disabled")
logging.warn(msg)
win.useFBO = False
if not glfw.extension_supported('GL_ARB_texture_float'):
msg = ("Trying to use a framebuffer object but "
"GL_ARB_texture_float is not supported. Disabling")
logging.warn(msg)
win.useFBO = False
# Assign event callbacks, these are dispatched when 'poll_events' is
# called.
glfw.set_mouse_button_callback(self.winHandle, event._onGLFWMouseButton)
glfw.set_scroll_callback(self.winHandle, event._onGLFWMouseScroll)
glfw.set_key_callback(self.winHandle, event._onGLFWKey)
glfw.set_char_mods_callback(self.winHandle, event._onGLFWText)
# set swap interval to manual setting, independent of waitBlanking
self.setSwapInterval(int(kwargs.get('swapInterval', 1)))
# give the window class GLFW specific methods
win.setMouseType = self.setMouseType
if not win.allowGUI:
self.setMouseVisibility(False)
def enable_full_screen(window):
display = glfw.get_primary_monitor()
videomode = glfw.get_video_mode(display)
glfw.set_window_monitor(window, display, 0, 0, videomode[0][0],
videomode[0][1], videomode[2])
def __init__(self,
width=800,
height=600,
title="QLibs window",
swap_interval=1,
hint_conf=default_hint_conf,
resizable=True,
fullscreen=False,
transparent=False):
self.width = width
self.height = height
self.resize_callback = None
self.mouse_motion_callback = None
self.mouse_button_callback = None
self.scroll_callback = None
self.key_callback = None
self.spec_key_callback = None
self.flip_mouse_y = False #flipped relatively to usual math-y representation
glfw.init()
glfw.window_hint(glfw.RESIZABLE, resizable and not fullscreen)
glfw.window_hint(glfw.TRANSPARENT_FRAMEBUFFER, transparent)
for k, v in hint_conf.items():
glfw.window_hint(k, v)
monitor = None
if fullscreen:
monitor = glfw.get_primary_monitor()
mode = glfw.get_video_mode(monitor)
width = mode.size.width
height = mode.size.height
#width = 1920
#height = 1080
glfw.window_hint(glfw.RED_BITS, mode.bits.red)
glfw.window_hint(glfw.GREEN_BITS, mode.bits.green)
glfw.window_hint(glfw.BLUE_BITS, mode.bits.blue)
glfw.window_hint(glfw.REFRESH_RATE, mode.refresh_rate)
try:
self.window = glfw.create_window(width, height, title, monitor,
None)
except glfw.GLFWError:
logger.warn(
"Provided config is unavailable, using fallback config")
glfw.default_window_hints()
for k, v in fallback_hint_conf.items():
glfw.window_hint(k, v)
self.window = glfw.create_window(width, height, title, None, None)
if fullscreen:
self.width, self.height = glfw.get_framebuffer_size(
self.window) #Required on windows
glfw.set_window_user_pointer(self.window, id(self.window))
glfw.make_context_current(self.window)
glfw.swap_interval(swap_interval)
#callbacks
glfw.set_window_size_callback(self.window, self._on_resize)
glfw.set_framebuffer_size_callback(self.window, self._update_viewport)
glfw.set_cursor_pos_callback(self.window, self._on_mouse_motion)
glfw.set_mouse_button_callback(self.window, self._on_mouse_button)
glfw.set_char_mods_callback(self.window, self._on_key_press)
glfw.set_key_callback(self.window, self._on_spec_key_press)
glfw.set_scroll_callback(self.window, self._on_scroll)
try:
self.ctx = moderngl.create_context()
except:
self.ctx = moderngl.create_context(libgl='libGL.so.1')
return False
def on_refresh():
log("Refresh")
glClear(GL_COLOR_BUFFER_BIT)
glfw.SwapBuffers()
glfw.init()
pm = glfw.get_primary_monitor()
vms = glfw.get_video_modes( pm )
print("Available video modes:\n%s\n" % "\n".join(map(str, vms)))
vm = glfw.get_video_mode( pm )
print( "Desktop video mode:\n%s\n" % str(vm) )
print( "GLFW Version: %d.%d.%d" % glfw.get_version() )
w = glfw.create_window(800, 600, 'test', None, None)
#print("OpenGL version: %d.%d.%d\n" % glfw.get_gl_version())
#glfw.ext.set_icons([(icon_data, icon_width, icon_height)])
glfw.set_window_title(w, "pyglfw test")
#glfw.disable(w, glfw.AUTO_POLL_EVENTS)
#glfw.enable(w, glfw.KEY_REPEAT)
center_x = int(vm[0][0] / 2 - glfw.get_window_size(w)[0] / 2)
center_y = int(vm[0][1] / 2 - glfw.get_window_size(w)[1] / 2)
print( "new window position: {!s}, {!s}".format(center_x, center_y) )
def __init__(
self,
module,
width,
height,
caption,
scale,
palette,
fps,
border_width,
border_color,
):
if glfw.get_version() < tuple(map(int, GLFW_VERSION.split("."))):
raise RuntimeError(
"glfw version is lower than {}".format(GLFW_VERSION))
if width > APP_SCREEN_MAX_SIZE or height > APP_SCREEN_MAX_SIZE:
raise ValueError("screen size is larger than {}x{}".format(
APP_SCREEN_MAX_SIZE, APP_SCREEN_MAX_SIZE))
global pyxel
pyxel = module
self._palette = palette[:]
self._fps = fps
self._border_width = border_width
self._border_color = border_color
self._next_update_time = 0
self._one_frame_time = 1 / fps
self._key_state = {}
self._is_mouse_visible = False
self._update = None
self._draw = None
self._capture_start = 0
self._capture_count = 0
self._capture_images = [None] * APP_GIF_CAPTURE_COUNT
self._perf_monitor_is_enabled = False
self._perf_fps_count = 0
self._perf_fps_start_time = 0
self._perf_fps = 0
self._perf_update_count = 0
self._perf_update_total_time = 0
self._perf_update_time = 0
self._perf_draw_count = 0
self._perf_draw_total_time = 0
self._perf_draw_time = 0
# exports variables
pyxel._app = self
pyxel.width = width
pyxel.height = height
pyxel.mouse_x = 0
pyxel.mouse_y = 0
pyxel.frame_count = 0
# initialize window
if not glfw.init():
exit()
monitor = glfw.get_primary_monitor()
display_width, display_height = glfw.get_video_mode(monitor)[0]
if scale == 0:
scale = max(
min(
(display_width // width) - APP_SCREEN_SCALE_CUTDOWN,
(display_height // height) - APP_SCREEN_SCALE_CUTDOWN,
),
APP_SCREEN_SCALE_MINIMUM,
)
window_width = width * scale + border_width
window_height = height * scale + border_width
self._window = glfw.create_window(window_width, window_height, caption,
None, None)
if not self._window:
glfw.terminate()
exit()
glfw.set_window_pos(
self._window,
(display_width - window_width) // 2,
(display_height - window_height) // 2,
)
glfw.make_context_current(self._window)
glfw.set_window_size_limits(self._window, width, height,
glfw.DONT_CARE, glfw.DONT_CARE)
self._hidpi_scale = (glfw.get_framebuffer_size(self._window)[0] /
glfw.get_window_size(self._window)[0])
self._update_viewport()
glfw.set_key_callback(self._window, self._key_callback)
glfw.set_mouse_button_callback(self._window,
self._mouse_button_callback)
glfw.set_window_icon(self._window, 1, [utilities.get_icon_image()])
glfw.set_input_mode(self._window, glfw.CURSOR, glfw.CURSOR_HIDDEN)
# initialize renderer
self._renderer = Renderer(width, height)
# initialize audio player
self._audio_player = AudioPlayer()
# export module functions
pyxel.btn = self.btn
pyxel.btnp = self.btnp
pyxel.btnr = self.btnr
pyxel.mouse = self.mouse
pyxel.run = self.run
pyxel.run_with_profiler = self.run_with_profiler
pyxel.quit = self.quit
pyxel.save = self.save
pyxel.load = self.load
pyxel.image = self._renderer.image
pyxel.tilemap = self._renderer.tilemap
pyxel.clip = self._renderer.draw_command.clip
pyxel.pal = self._renderer.draw_command.pal
pyxel.cls = self._renderer.draw_command.cls
pyxel.pix = self._renderer.draw_command.pix
pyxel.line = self._renderer.draw_command.line
pyxel.rect = self._renderer.draw_command.rect
pyxel.rectb = self._renderer.draw_command.rectb
pyxel.circ = self._renderer.draw_command.circ
pyxel.circb = self._renderer.draw_command.circb
pyxel.blt = self._renderer.draw_command.blt
pyxel.bltm = self._renderer.draw_command.bltm
pyxel.text = self._renderer.draw_command.text
pyxel.sound = self._audio_player.sound
pyxel.music = self._audio_player.music
pyxel.play = self._audio_player.play
pyxel.playm = self._audio_player.playm
pyxel.stop = self._audio_player.stop
# initialize mouse cursor
pyxel.image(3,
system=True).set(MOUSE_CURSOR_IMAGE_X,
MOUSE_CURSOR_IMAGE_Y, MOUSE_CURSOR_DATA)
def __init__(self, win, backendConf=None):
"""Set up the backend window according the params of the PsychoPy win
Before PsychoPy 1.90.0 this code was executed in Window._setupPygame()
Parameters
----------
win : `psychopy.visual.Window` instance
PsychoPy Window (usually not fully created yet).
backendConf : `dict` or `None`
Backend configuration options. Options are specified as a dictionary
where keys are option names and values are settings. For this
backend the following options are available:
* `share` (`psychopy.visual.Window instance`) PsychoPy Window to
share a context with.
* `refreshHz` (`int`) Refresh rate in Hertz.
* `bpc` (`array_like`) Bits per color (R, G, B).
* `swapInterval` (`int`) Swap interval for the current OpenGL
context.
* `depthBits` (`int`) Framebuffer (back buffer) depth bits.
* `stencilBits` (`int`) Framebuffer (back buffer) stencil bits.
* `winTitle` (`str`) Optional window title string.
Examples
--------
Create a window using the GLFW backend and specify custom options::
import psychopy.visual as visual
options = {'bpc': (8, 8, 8), 'depthBits': 24, 'stencilBits': 8}
win = visual.Window(winType='glfw', backendOptions=options)
"""
BaseBackend.__init__(self, win)
# if `None`, change to `dict` to extract options
backendConf = backendConf if backendConf is not None else {}
if not isinstance(backendConf, dict): # type check on options
raise TypeError(
'Object passed to `backendConf` must be type `dict`.')
# window to share a context with
shareWin = backendConf.get('share', None)
if shareWin is not None:
if shareWin.winType == 'glfw':
shareContext = shareWin.winHandle
else:
logging.warning(
'Cannot share a context with a non-GLFW window. Disabling.')
shareContext = None
else:
shareContext = None
if sys.platform=='darwin' and not win.useRetina and pyglet.version >= "1.3":
raise ValueError("As of PsychoPy 1.85.3 OSX windows should all be "
"set to useRetina=True (or remove the argument). "
"Pyglet 1.3 appears to be forcing "
"us to use retina on any retina-capable screen "
"so setting to False has no effect.")
# window framebuffer configuration
bpc = backendConf.get('bpc', (8, 8, 8))
if isinstance(bpc, int):
win.bpc = (bpc, bpc, bpc)
else:
win.bpc = bpc
win.refreshHz = int(backendConf.get('refreshHz', 60))
win.depthBits = int(backendConf.get('depthBits', 8))
win.stencilBits = int(backendConf.get('stencilBits', 8))
# win.swapInterval = int(backendConf.get('swapInterval', 1)) # vsync ON if 1
# get monitors, with GLFW the primary display is ALWAYS at index 0
allScrs = glfw.get_monitors()
if len(allScrs) < int(win.screen) + 1:
logging.warn("Requested an unavailable screen number - "
"using first available.")
win.screen = 0
thisScreen = allScrs[win.screen]
if win.autoLog:
logging.info('configured GLFW screen %i' % win.screen)
# find a matching video mode (can we even support this configuration?)
isVidmodeSupported = False
for vidmode in glfw.get_video_modes(thisScreen):
size, bpc, hz = vidmode
if win._isFullScr: # size and refresh rate are ignored if windowed
hasSize = size == tuple(win.size)
hasHz = hz == win.refreshHz
else:
hasSize = hasHz = True
hasBpc = bpc == tuple(win.bpc)
if hasSize and hasBpc and hasHz:
isVidmodeSupported = True
break
nativeVidmode = glfw.get_video_mode(thisScreen)
if not isVidmodeSupported:
# the requested video mode is not supported, use current
logging.warning(
("The specified video mode is not supported by this display, "
"using native mode ..."))
actualWidth, actualHeight = nativeVidmode.size
redBits, greenBits, blueBits = nativeVidmode.bits
# change the window settings
if win._isFullScr:
logging.warning(
("Overriding user video settings: size {} -> {}, bpc {} -> "
"{}, refreshHz {} -> {}".format(
tuple(win.size),
(actualWidth, actualHeight),
tuple(win.bpc),
(redBits, greenBits, blueBits),
win.refreshHz,
nativeVidmode.refresh_rate)))
win.clientSize = np.array((actualWidth, actualHeight), int)
else:
logging.warning(
("Overriding user video settings: bpc {} -> "
"{}, refreshHz {} -> {}".format(
tuple(win.bpc),
(redBits, greenBits, blueBits),
win.refreshHz,
nativeVidmode.refresh_rate)))
win.bpc = (redBits, greenBits, blueBits)
win.refreshHz = nativeVidmode.refresh_rate
if win._isFullScr:
useDisplay = thisScreen
else:
useDisplay = None
# configure stereo
useStereo = 0
if win.stereo:
# provide warning if stereo buffers are requested but unavailable
if not glfw.extension_supported('GL_STEREO'):
logging.warning(
'A stereo window was requested but the graphics '
'card does not appear to support GL_STEREO')
win.stereo = False
else:
useStereo = 1
# setup multisampling
# This enables multisampling on the window backbuffer, not on other
# framebuffers.
msaaSamples = 0
if win.multiSample:
maxSamples = (GL.GLint)()
GL.glGetIntegerv(GL.GL_MAX_SAMPLES, maxSamples)
if (win.numSamples & (win.numSamples - 1)) != 0:
# power of two?
logging.warning(
'Invalid number of MSAA samples provided, must be '
'power of two. Disabling.')
elif 0 > win.numSamples > maxSamples.value:
# check if within range
logging.warning(
'Invalid number of MSAA samples provided, outside of valid '
'range. Disabling.')
else:
msaaSamples = win.numSamples
win.multiSample = msaaSamples > 0
# disable stencil buffer
if not win.allowStencil:
win.stencilBits = 0
# set buffer configuration hints
glfw.window_hint(glfw.RED_BITS, win.bpc[0])
glfw.window_hint(glfw.GREEN_BITS, win.bpc[1])
glfw.window_hint(glfw.BLUE_BITS, win.bpc[2])
glfw.window_hint(glfw.REFRESH_RATE, win.refreshHz)
glfw.window_hint(glfw.STEREO, useStereo)
glfw.window_hint(glfw.SAMPLES, msaaSamples)
glfw.window_hint(glfw.STENCIL_BITS, win.stencilBits)
glfw.window_hint(glfw.DEPTH_BITS, win.depthBits)
glfw.window_hint(glfw.AUTO_ICONIFY, 0)
# window appearance and behaviour hints
if not win.allowGUI:
glfw.window_hint(glfw.DECORATED, 0)
# create the window
self.winHandle = glfw.create_window(
width=win.clientSize[0],
height=win.clientSize[1],
title=str(backendConf.get('winTitle', "PsychoPy (GLFW)")),
monitor=useDisplay,
share=shareContext)
# The window's user pointer maps the Python Window object to its GLFW
# representation.
glfw.set_window_user_pointer(self.winHandle, win)
glfw.make_context_current(self.winHandle) # ready to use
# set the position of the window if not fullscreen
if not win._isFullScr:
# if no window position is specified, centre it on-screen
if win.pos is None:
size, bpc, hz = nativeVidmode
win.pos = [(size[0] - win.clientSize[0]) / 2.0,
(size[1] - win.clientSize[1]) / 2.0]
# get the virtual position of the monitor, apply offset to the
# window position
px, py = glfw.get_monitor_pos(thisScreen)
glfw.set_window_pos(self.winHandle,
int(win.pos[0] + px),
int(win.pos[1] + py))
elif win._isFullScr and win.pos is not None:
logging.warn("Ignoring window 'pos' in fullscreen mode.")
# set the window icon
if hasattr(glfw, 'set_window_icon'):
glfw.set_window_icon(self.winHandle, 1, _WINDOW_ICON_)
# set the window size to the framebuffer size
self._frameBufferSize = np.array(glfw.get_framebuffer_size(self.winHandle))
if win.useFBO: # check for necessary extensions
if not glfw.extension_supported('GL_EXT_framebuffer_object'):
msg = ("Trying to use a framebuffer object but "
"GL_EXT_framebuffer_object is not supported. Disabled")
logging.warn(msg)
win.useFBO = False
if not glfw.extension_supported('GL_ARB_texture_float'):
msg = ("Trying to use a framebuffer object but "
"GL_ARB_texture_float is not supported. Disabling")
logging.warn(msg)
win.useFBO = False
# Assign event callbacks, these are dispatched when 'poll_events' is
# called.
glfw.set_mouse_button_callback(self.winHandle, self.onMouseButton)
glfw.set_cursor_pos_callback(self.winHandle, self.onMouseMove)
glfw.set_cursor_enter_callback(self.winHandle, self.onMouseEnter)
glfw.set_scroll_callback(self.winHandle, self.onMouseScroll)
glfw.set_key_callback(self.winHandle, event._onGLFWKey)
glfw.set_char_mods_callback(self.winHandle, event._onGLFWText)
# set swap interval to manual setting, independent of waitBlanking
self.setSwapInterval(int(backendConf.get('swapInterval', 1)))
# give the window class GLFW specific methods
win.setMouseType = self.setMouseType
if not win.allowGUI:
self.setMouseVisibility(False)
