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 glfwMonitorCallback(self):
# TODO: Test the F**K out of this!
newMonitors = glfw.get_monitors()
newMonitornames = [bytes.decode(glfw.get_monitor_name(monitor)) for monitor in newMonitors]
for monitorName in self.glfwWorkers:
if monitorName not in newMonitornames:
print("Monitor " + monitorName + " doesn't exist anymore, worker is now doing whatever.")
self.monitors = newMonitors
self.monitornames = newMonitornames
for monitor in self.monitors:
self.monitorDict[bytes.decode(glfw.get_monitor_name(monitor))] = monitor
def _select_monitor(self):
self.monitor = None
if SETTINGS.display in ["window", "windowed"]:
return
for monitor in glfw.get_monitors():
logger.info("* {} : {}".format(glfw.get_monitor_name(monitor),
glfw.get_video_modes(monitor)))
for monitor in glfw.get_monitors():
if glfw.get_monitor_name(
monitor
) == SETTINGS.display or SETTINGS.display == "fullscreen":
self.monitor = monitor
break
def __init__(self):
self.tcpPort = 31337
self.tcpsocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.tcpsocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.tcpsocket.bind(("0.0.0.0", self.tcpPort))
self.tcpsocket.listen(10)
self.discoverysocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.discoverysocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
1)
self.discoverysocket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST,
1)
self.glfwWorkers = {}
self.controllerConn = None
self.controllerAddr = None
self.outbuf = "" # IO buffer for controller
self.inbuf = ""
self.monitors = glfw.get_monitors()
for monitor in glfw.get_monitors():
self.glfwWorkers[bytes.decode(
glfw.get_monitor_name(monitor))] = glfwWorker(monitor)
def __init__(self, monitor):
self.monitor = monitor
self.window = None
self.availableModules = {}
self.sheetdata = {}
self.sheetObjects = {}
self.nodedataJar = {}
self.currentSheet = None
self.sheetInitId = None
self.sheetLoopId = None
# --- Runtime variables
self.width = 1
self.height = 1
self.state = "stop"
self.time = glfw.get_time()
self.deltatime = 1
self.fbo = None
self.fbotexture = None
self.monitorname = bytes.decode(glfw.get_monitor_name(self.monitor))
def parse(self,
monitorptr: ctypes.POINTER(ctypes.POINTER(glfw._GLFWmonitor))):
self.monitorptr: ctypes.POINTER(ctypes.POINTER(
glfw._GLFWmonitor)) = monitorptr
self.vidmodes = glfw.get_video_modes(self.monitorptr)
self.name = glfw.get_monitor_name(self.monitorptr)
def _select_video_mode(self):
""" Selects the monitor resolution whose width is the immediately higher than the stitcher resolution
"""
resolutions = list(reversed(glfw.get_video_modes(self.monitor)))
self.video_mode = None
for refresh_rate in [30, 29, 60, 59]:
for resolution in resolutions:
if resolution[0][0] < self.width:
break
if resolution[2] == refresh_rate:
self.video_mode = resolution
if self.video_mode:
break
if not self.video_mode:
logger.info(
"No matching resolution found, using highest available")
self.video_mode = resolutions[0]
mode = str(self.video_mode[0][0]) + "x" + str(self.video_mode[0][1])
rate = str(self.video_mode[2])
subprocess.call([
"xrandr", "--output",
glfw.get_monitor_name(self.monitor), "--mode", mode, "--rate", rate
])
time.sleep(1)
def _monitor_event(self, monitor, event):
name = glfw.get_monitor_name(monitor)
if event == glfw.DISCONNECTED:
logger.info("Unplugged monitor {}".format(name))
else:
logger.info("Plugged monitor {}".format(name))
self.pano_renderer.enableOutput(False)
if self.output_window:
glfw.hide_window(self.output_window)
async .delay(SWITCH_DELAY, self.open_output_window)
def move_window_to_monitor(window, monitor_name):
monitors = glfw.get_monitors()
monitor = None
for m in monitors:
if glfw.get_monitor_name(m) == monitor_name:
monitor = m
if monitor is not None:
glfw.set_window_pos(window, *glfw.get_monitor_pos(monitor))
return True
else:
return False
def sendMonitorsReply(self, msgid):
self.monitors = glfw.get_monitors()
msg = {
"msgid":
uuid.uuid4().int,
"msgtype":
"reply",
"refid":
msgid,
"replydata": [
bytes.decode(glfw.get_monitor_name(monitor))
for monitor in self.monitors
]
}
self.sendMessage(msg)
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 __init__(self, index, gl_handle):
self.__gl_handle = gl_handle
self.__name = glfw.get_monitor_name(gl_handle).decode("utf-8")
self.__index = index
def main():
if not glfw.init():
raise RuntimeError('Failed to initialize GLFW')
version = glfw.get_version_string().decode('ASCII')
print('GLFW', version)
monitors = glfw.get_monitors()
for i, monitor in enumerate(monitors):
name = glfw.get_monitor_name(monitor)
primary = (glfw.get_monitor_pos(monitor) ==
glfw.get_monitor_pos(glfw.get_primary_monitor()))
print('Monitor #{}: {}{}'.format(i, name.decode('utf8'),
' (primary)' if primary else ''))
width_mm, height_mm = glfw.get_monitor_physical_size(monitor)
diag_mm = math.sqrt(width_mm*width_mm + height_mm*height_mm)
print('Diagonal: {:.1f}"'.format(diag_mm / 25.4))
mode = glfw.get_video_mode(monitor)
print('Video mode: {}x{} {}Hz {}'.format(mode.size.width, mode.size.height,
mode.refresh_rate, mode.bits))
xscale, yscale = glfw.get_monitor_content_scale(monitor)
print('Scale: {}|{}'.format(xscale, yscale))
print('Virtual position:', glfw.get_monitor_pos(monitor))
print('Work ares:', glfw.get_monitor_workarea(monitor))
for mode in glfw.get_video_modes(monitor):
print('Supported: {}x{} {}Hz {}'.format(mode.size.width, mode.size.height,
mode.refresh_rate, mode.bits))
print(mode)
print()
glfw.window_hint(glfw.RESIZABLE, True)
glfw.window_hint(glfw.STENCIL_BITS, 8)
glfw.window_hint(glfw.CLIENT_API, glfw.OPENGL_API)
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 6)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
monitor = glfw.get_primary_monitor()
mode = glfw.get_video_mode(monitor)
window = glfw.create_window(640, 480, 'Title', None, None)
# window = glfw.create_window(mode.size.width, mode.size.height, 'Title', monitor, None)
if window is None:
glfw.terminate()
raise RuntimeError('Failed to create a window')
# glfw.set_window_monitor(window, monitor, 0, 0, mode.size.width, mode.size.height, mode.refresh_rate)
width, height = glfw.get_window_size(window)
print('Window size: {}x{}'.format(width, height))
print('Frame size:', glfw.get_window_frame_size(window))
width, height = glfw.get_framebuffer_size(window)
print('Framebuffer size: {}x{}'.format(width, height))
print('Client API:', glfw.get_window_attrib(window, glfw.CLIENT_API))
version_major = glfw.get_window_attrib(window, glfw.CONTEXT_VERSION_MAJOR)
version_minor = glfw.get_window_attrib(window, glfw.CONTEXT_VERSION_MINOR)
revision = glfw.get_window_attrib(window, glfw.CONTEXT_REVISION)
print('Version: {}.{} rev{}'.format(version_major, version_minor, revision))
glfw.make_context_current(window)
renderer = Renderer(window)
while not glfw.window_should_close(window):
GL.glClear(GL.GL_COLOR_BUFFER_BIT)
renderer.render()
glfw.swap_buffers(window)
glfw.poll_events()
glfw.terminate()
def get_monitors_idx_list():
monitors = [glfw.get_monitor_name(m) for m in glfw.get_monitors()]
return range(len(monitors)), monitors
def run(self):
# See if there are any incoming connections
rlist, wlist, elist = select([self.tcpsocket, self.udpsock], [], [], 0)
if rlist:
for sock in rlist:
if sock == self.tcpsocket:
conn, addr = self.tcpsocket.accept()
if self.controllerConn is not None:
rlist, wlist, elist = select([], [conn], [], 0)
if wlist:
conn.send(b'{"status": ["error", 1], "message": "Already got controller."}\n')
print("Rejecting connection from " + str(self.controllerAddr) + ".")
conn.close()
else:
print("Accepting connection from " + str(self.controllerAddr) + ".")
self.controllerConn = conn
self.controllerAddr = addr
conn.send(b'{"status": ["ok", 1], "message": "Connection accepted."}\n')
elif sock == self.udpsock:
data, addr = sock.recvfrom(4096)
try:
msg = bytes.decode(data)
msgdecoded = json.loads(msg)
if "bpm" in msgdecoded:
for worker in self.glfwWorkers:
self.glfwWorkers[worker].beatlow = True
self.glfwWorkers[worker].beatmid = False
self.glfwWorkers[worker].beathigh = False
self.glfwWorkers[worker].bpm = msgdecoded["bpm"]
if "cmd" in msgdecoded and "data" in msgdecoded:
pass
except:
raise
# See if anything is to be sent to controller
if self.outBuf:
wlist = [self.controllerConn]
else:
wlist = []
if self.controllerConn is not None:
rlist = [self.controllerConn]
else:
rlist = []
rlist, wlist, elist = select(rlist, wlist, [], 0)
if rlist:
incomingData = self.controllerConn.recv(1024)
if not incomingData: # AKA connection is dead
print("Connection from " + str(self.controllerAddr) + " died.")
self.controllerConn.close()
self.controllerConn = None
self.controllerAddr = None
else: # Append incoming message to the commandbuf to be parsed later
try:
self.messageBuf += bytes.decode(incomingData)
except UnicodeDecodeError:
self.sendError("""Error: Failed decoding message from controller as unicode:
----- MESSAGE: -----
""" + str(incomingData) + """
-- MESSAGE END --""", None)
if wlist:
self.controllerConn.send(str.encode(self.outBuf))
self.parseMessageBuf()
for key in self.glfwWorkers:
try:
with Timeout(1):
self.glfwWorkers[key].run()
except Timeout.Timeout:
print("Error: run() for worker '" + bytes.decode(glfw.get_monitor_name(self.glfwWorkers[key].monitor)) + "' timed out after 1 second.") # TODO: send error message to controller
def main():
glfw.init()
glfw.window_hint(glfw.RESIZABLE, False)
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 6)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
w = glfw.create_window(800, 600, 'Window Title', None, None)
glfw.make_context_current(w)
###############
face = freetype.Face("/usr/share/fonts/TTF/IBMPlexSans-Regular.ttf")
# Figure out DPI's of different monitors
# Perhaps take these into account if you care, as well as window scale.
# But what if your window is split across screens?
for monitor in glfw.get_monitors():
name = glfw.get_monitor_name(monitor).decode('utf8')
pw, ph = glfw.get_monitor_physical_size(monitor)
videomode = glfw.get_video_mode(monitor) # in mm
vw, vh = videomode.size.width, videomode.size.height
# print(name, 25.4*vw/pw, 25.4*vh/ph) # convert to pixels per inch
print(name, (1 / 72) * 25.4 * vw / pw,
(1 / 72) * 25.4 * vh / ph) # pixels per point
# Set char size via physical size calculation
# width, height in 1/64 of points
# A point is one 1/72 of an inch. My monitors have 1.35 to 1.84 pixels per point.
# Device resolution in dots per inch.
# pixel_size = point_size * resolution / 72
# face.set_char_size(width=16*64) #,height=0,hres=72,vres=72
# Set size of EM square via pixels directly
face.set_pixel_sizes(20, 0)
baseline_height = 20 * face.height / face.units_per_EM
print(baseline_height)
###############
# disable byte-alignment restriction
# normally, textures need to occupy a multiple of 4 in memory
# but glyphs are single-color so they don't satisfy this
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glyphs = {}
for i in range(face.num_glyphs):
face.load_glyph(i) #flags=FT_LOAD_RENDER - renders glyph after loading
texture = glGenTextures(1)
# all of these numbers are pixels*64 by default
# so divide by 64 to make these just pixels
glyphs[i] = {
"texture": texture,
"w": face.glyph.metrics.width / 64,
"h": face.glyph.metrics.height / 64,
"hori": {
"advance": face.glyph.metrics.horiAdvance / 64,
"bearingX": face.glyph.metrics.horiBearingX / 64,
"bearingY": face.glyph.metrics.horiBearingY / 64,
},
"vert": {
"advance": face.glyph.metrics.vertAdvance / 64,
"bearingX": face.glyph.metrics.vertBearingX / 64,
"bearingY": face.glyph.metrics.vertBearingY / 64,
}
}
bitmap = face.glyph.bitmap
glBindTexture(GL_TEXTURE_2D, texture)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, bitmap.width, bitmap.rows, 0,
GL_RED, GL_UNSIGNED_BYTE, bitmap.buffer)
# target, level, internalformat, width, height, border=0, format, type,data
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
GL_CLAMP_TO_EDGE) # these two seem
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
GL_CLAMP_TO_EDGE) # to be optional
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
##################
shaderProgram = make_shader_program()
glUseProgram(shaderProgram)
posParamsUniform = glGetUniformLocation(shaderProgram, "posParams")
def set_pos(x, y, dx, dy):
s = 1
glUniform4f(posParamsUniform, s * x, s * y, s * dx, s * dy)
# location, count, transpose, value
vao = glGenVertexArrays(1)
glBindVertexArray(vao)
vbo = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, vbo)
# two triangles to make a rectangle
# coordinates are in screen space
# to get texture coordinates to x->x and y->1-y
vertices = [0.0, 1.0] + [0.0,0.0] + [1.0,0.0] +\
[0.0, 1.0] + [1.0,0.0] + [1.0,1.0]
glBufferData(GL_ARRAY_BUFFER, len(vertices)*ctypes.sizeof(ctypes.c_float), \
(ctypes.c_float*len(vertices))(*vertices), GL_STATIC_DRAW)
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, ctypes.c_void_p(0))
glEnableVertexAttribArray(0)
glEnable(GL_BLEND) # need this because the shader uses alphas
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
fbsize = {}
fbsize["w"], fbsize["h"] = glfw.get_framebuffer_size(w)
while not glfw.window_should_close(w):
glClearColor(0.0, 0.0, 0.0, 1.0)
glClear(GL_COLOR_BUFFER_BIT)
x, y = -1.0, 1.0
y -= baseline_height * 2 / fbsize["h"]
for i in range(face.num_glyphs):
bx = glyphs[i]["hori"]["bearingX"] * 2 / fbsize["w"]
by = glyphs[i]["hori"]["bearingY"] * 2 / fbsize["h"]
width = glyphs[i]["w"] * 2 / fbsize["w"]
height = glyphs[i]["h"] * 2 / fbsize["h"]
set_pos(x + bx, y + by - height, width, height)
x += glyphs[i]["hori"]["advance"] * 2 / fbsize["w"]
glBindTexture(GL_TEXTURE_2D, glyphs[i]["texture"])
glDrawArrays(GL_TRIANGLES, 0, 6)
if i + 1 < face.num_glyphs:
x += face.get_kerning(i, i + 1).x
if x + glyphs[i +
1]["hori"]["advance"] * 2 / fbsize["w"] >= 1.0:
x = -1.0
y -= baseline_height * 2 / fbsize["h"]
if y <= -1.0:
break
glfw.swap_buffers(w)
glfw.poll_events()
glDeleteBuffers(1, vbo)
glDeleteVertexArrays(1, vao)
glDeleteProgram(shaderProgram)
glfw.terminate()
