def start(self):
imgui.create_context()
io = imgui.get_io()
# io.fonts.add_font_default()
io.fonts.add_font_from_file_ttf(
"./res/font/Roboto-Medium.ttf", 14,
io.fonts.get_glyph_ranges_chinese_full())
io.fonts.add_font_from_file_ttf(
"./res/font/FZY3JW.ttf", 13,
io.fonts.get_glyph_ranges_chinese_full(), True)
self.window = App._impl_glfw_init()
impl = GlfwRenderer(self.window)
while not glfw.window_should_close(self.window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
# imgui.show_test_window()
self.update()
gl.glClearColor(1., 1., 1., 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(self.window)
self.main_view and self.main_view.on_close()
impl.shutdown()
glfw.terminate()
def __init__(self, gui=False, width=800, height=600, window_name='opengl'):
self.width = width
self.height = height
if not glfw.init():
raise RuntimeError('could not init glfw')
hints = ((glfw.CONTEXT_VERSION_MAJOR, 4),
(glfw.CONTEXT_VERSION_MINOR, 5), (glfw.OPENGL_PROFILE,
glfw.OPENGL_CORE_PROFILE))
for hint in hints:
glfw.window_hint(*hint)
self.window = glfw.create_window(int(self.width), int(self.height),
window_name, None, None)
glfw.make_context_current(self.window)
def viewport_func(window, width, height):
self.width = width
self.height = height
self.update_camera(update_proj=True)
self.ctx.viewport = (0, 0, self.width, self.height)
glfw.set_framebuffer_size_callback(self.window, viewport_func)
if not self.window:
glfw.terminate()
raise RuntimeError('could not create glfw window')
self.gui_impl = None
if gui:
self.gui_impl = GlfwRenderer(self.window)
self.ctx = moderngl.create_context()
self.ctx.viewport = (0, 0, self.width, self.height)
def __init__(self, gui=True, pipe=None, img=None):
self.use_imgui = gui
self.use_occt = not gui
self.please_stop = False
self.rqq = rqQueue()
self.texture_updated = False
self.prev_pos = [0, 0]
self.offscreen_view_size = [0, 0]
if self.use_imgui:
print("Creating IMGUI context")
imgui.create_context()
else:
print("IMGUI disabled")
# Create a windowed mode window and its OpenGL context
if self.use_imgui:
self.canva = glfwViewer3d()
self.canva.set_pipe(pipe)
self.canva.set_img(img)
self.canva.init_driver()
self.impl = GlfwRenderer(self.canva.window)
else:
self.canva = offscreenViewer3d()
self.canva.set_pipe(pipe)
self.canva.set_img(img)
async def async_main(window, config):
await asyncjob.start_worker()
imgui_impl = GlfwRenderer(window)
renderer = WorldRenderer()
app = StarboundMap(renderer)
frame_size = np.ones(2)
while not glfw.window_should_close(window):
glfw.poll_events()
if G.minimized: # do not render zero sized frame
continue
imgui_impl.process_inputs()
frame_size = np.array(glfw.get_framebuffer_size(window))
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
gl.glViewport(0, 0, frame_size[0], frame_size[1])
gl.glClearColor(0.1, 0.1, 0.2, 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
app.gui()
glfw.swap_buffers(window)
await asyncio.sleep(0)
config[CONFIG_WIDTH] = str(int(frame_size[0]))
config[CONFIG_HEIGHT] = str(int(frame_size[1]))
imgui_impl.shutdown()
imgui.shutdown()
def main(recfile):
imgui.create_context()
window = impl_glfw_init()
impl = GlfwRenderer(window)
slamgui = SLAMGUI(recfile)
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
if imgui.begin_main_menu_bar():
if imgui.begin_menu("File", True):
clicked_quit, _ = imgui.menu_item("Quit", 'Cmd+Q', False, True)
if clicked_quit:
exit(0)
imgui.end_menu()
imgui.end_main_menu_bar()
slamgui.render()
gl.glClearColor(0, 0, 0, 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
def app(render, width=1280, height=720, window_name="Maldives"):
"""
:param render:
:param width:
:param height:
:param window_name:
:return:
"""
imgui.create_context()
window = impl_glfw_init(width, height, window_name)
impl = GlfwRenderer(window)
while not glfw.window_should_close(window):
glfw.poll_events()
gl.glClearColor(0.3, 0.5, 0.4, 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
impl.process_inputs()
imgui.new_frame()
render()
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
def main():
window = impl_glfw_init()
impl = GlfwRenderer(window)
font_scaling_factor = fb_to_window_factor(window)
io = impl.io
# clear font atlas to avoid downscaled default font
# on highdensity screens. First font added to font
# atlas will become default font.
io.fonts.clear()
# set global font scaling
io.font_global_scale = 1. / font_scaling_factor
# dictionary of font objects from our font directory
fonts = {
os.path.split(font_path)[-1]: io.fonts.add_font_from_file_ttf(
font_path, FONT_SIZE_IN_PIXELS * font_scaling_factor,
io.fonts.get_glyph_ranges_latin())
for font_path in FONTS_DIR
}
secondary_window_main_font = random.choice(list(fonts.values()))
impl.refresh_font_texture()
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
imgui.begin("Window with multiple custom fonts", True)
imgui.text("This example showcases font usage on text() widget")
for font_name, font in fonts.items():
imgui.separator()
imgui.text("Font:{}".format(font_name))
with imgui.font(font):
imgui.text("This text uses '{}' font.".format(font_name))
imgui.end()
with imgui.font(secondary_window_main_font):
imgui.begin("Window one main custom font", True)
imgui.text("This window uses same custom font for all widgets")
imgui.end()
gl.glClearColor(1., 1., 1., 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
def __init__(self, app: ImGuiPlayerApp):
self.app = app
#initialize window and GUI
imgui.create_context()
self.window = self.impl_glfw_init()
self.impl = GlfwRenderer(self.window)
self.quit_requested = False
def makeGUI(self, gui):
""" Create the GUI context and GlfwRenderer
Args:
gui (bool): if True create the GUI context and GlfwRenderer
"""
if gui:
imgui.create_context()
self._renderer = GlfwRenderer(self.window(), True)
self._opened = True
else:
self._renderer = None
self._opened = False
def init():
global window, imgui_renderer, _ui_state
glfw.set_error_callback(error_callback)
imgui.create_context()
if not glfw.init():
print("GLFW Initialization fail!")
return
graphics_settings = configuration.get_graphics_settings()
loader_settings = configuration.get_loader_settings()
if graphics_settings is None:
print("bla")
return
screen_utils.WIDTH = graphics_settings.getint("width")
screen_utils.HEIGHT = graphics_settings.getint("height")
screen_utils.MAX_FPS = graphics_settings.getint("max_fps")
screen = None
if graphics_settings.getboolean("full_screen"):
screen = glfw.get_primary_monitor()
hints = {
glfw.DECORATED: glfw.TRUE,
glfw.RESIZABLE: glfw.FALSE,
glfw.CONTEXT_VERSION_MAJOR: 4,
glfw.CONTEXT_VERSION_MINOR: 5,
glfw.OPENGL_DEBUG_CONTEXT: glfw.TRUE,
glfw.OPENGL_PROFILE: glfw.OPENGL_CORE_PROFILE,
glfw.SAMPLES: 4,
}
window = _create_window(size=(screen_utils.WIDTH, screen_utils.HEIGHT),
pos="centered",
title="Tremor",
monitor=screen,
hints=hints,
screen_size=glfw.get_monitor_physical_size(
glfw.get_primary_monitor()))
imgui_renderer = GlfwRenderer(window, attach_callbacks=False)
glutil.log_capabilities()
glEnable(GL_CULL_FACE)
glCullFace(GL_BACK)
glEnable(GL_DEPTH_TEST)
glDepthMask(GL_TRUE)
glDepthFunc(GL_LEQUAL)
glDepthRange(0.0, 1.0)
glEnable(GL_MULTISAMPLE)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
create_branched_programs()
# create the uniforms
_create_uniforms()
# initialize all the uniforms for all the prpograms
init_all_uniforms()
def initialize(self):
imgui.create_context()
self.io = imgui.get_io()
# TODO 这些枚举搜不到，需要式再说
# io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
# io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
# self.io.config_flags |= imgui.CONFIG_NAV_ENABLE_KEYBOARD # Enable Keyboard Controls TODO cause error
window = G.appm.window_handle
self.impl = GlfwRenderer(
window, attach_callbacks=False
) # NOTE otherwise imgui will register glfw callbacks
imgui.style_colors_dark()
self.on_gui = G.appm.on_gui
self.on_gui_editor = G.editorm.on_gui
def main():
imgui.create_context()
window = impl_glfw_init()
impl = GlfwRenderer(window)
ip_address = "localhost:3333"
#imgui.set_window_font_scale(1.0)
comms = MouseSocket()
click_guard = True
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
imgui.set_next_window_size(300, 120)
imgui.set_next_window_position(10, 0)
imgui.begin("", False, imgui.WINDOW_NO_RESIZE)
changed, ip_address = imgui.input_text(label="IP:PORT",
value=ip_address,
buffer_length=30)
clicked = imgui.button(label="CONNECT")
if clicked:
comms.connect(ip_address)
max_x, max_y = glfw.get_window_size(window)
x, y = glfw.get_cursor_pos(window)
norm_x = x / max_x
norm_y = y / max_y
state = glfw.get_mouse_button(window, glfw.MOUSE_BUTTON_LEFT)
if state == glfw.PRESS:
click_guard = False
elif state == glfw.RELEASE and not click_guard:
click_guard = True
comms.send_click(norm_x, norm_y)
comms.send_mouse_coords(norm_x, norm_y)
imgui.text("Mouse Coords: {:.2f}, {:.2f}".format(norm_x, norm_y))
imgui.text("Connected: {}".format(comms.is_connected))
imgui.end()
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
def main():
imgui.create_context()
window = impl_glfw_init()
impl = GlfwRenderer(window)
_ = gl.glGenFramebuffers(1)
videoWindows = []
def dropFile(window, files):
for file in files:
videoWindows.append(VideoPlayer(file))
glfw.set_drop_callback(window, dropFile)
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
videoWindows = [x for x in videoWindows if x.open]
if len(videoWindows) > 0:
for videoWindow in videoWindows:
videoWindow.render()
else:
imgui.core.set_next_window_position(10, 10)
winw, winh = glfw.get_window_size(window)
imgui.core.set_next_window_size(winw - 20, 10)
imgui.begin("##Message",
True,
flags=imgui.WINDOW_NO_SCROLLBAR
| imgui.WINDOW_NO_RESIZE | imgui.WINDOW_NO_TITLE_BAR
| imgui.WINDOW_NO_MOVE)
imgui.text("Drop one or more video files onto this window to play")
imgui.end()
gl.glClearColor(0., 0., 0., 1.)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
for videoWindow in videoWindows:
videoWindow.terminate()
impl.shutdown()
glfw.terminate()
def main():
desktop = Desktop()
imgui.create_context()
window = core.impl_glfw_init()
impl = GlfwRenderer(window)
imgui.core.style_colors_light()
app_list = list(get_app_list())
# figure = plt.figure()
# img = Image.open('./test.png')
# texture, width, height = readImage(img)
def update():
imgui.new_frame()
if imgui.begin_main_menu_bar():
if imgui.begin_menu("System", True):
for app in app_list:
clicked, selected = imgui.menu_item(
app.__name__, '', False, True)
if clicked:
desktop.add(app())
imgui.separator()
clicked_quit, selected_quit = imgui.menu_item(
"Quit", '', False, True)
if clicked_quit:
exit(1)
imgui.end_menu()
imgui.end_main_menu_bar()
desktop.render()
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
update()
gl.glClearColor(1., 1., 1., 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
data = imgui.get_draw_data()
impl.render(data)
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
def main():
window = impl_glfw_init()
impl = GlfwRenderer(window)
box1 = box2 = box3 = True
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
if imgui.begin_main_menu_bar():
if imgui.begin_menu("File", True):
clicked_quit, selected_quit = imgui.menu_item(
"Quit", 'Cmd+Q', False, True)
if clicked_quit:
exit(1)
imgui.end_menu()
imgui.end_main_menu_bar()
imgui.begin("Scope Test")
box1 = imgui.checkbox("Checkbox", box1)[1]
with imgui.scope(2):
imgui.new_line()
imgui.text("Same name, different scope:")
box2 = imgui.checkbox("Checkbox", box2)[1]
imgui.new_line()
imgui.text("Same name, same scope:")
imgui.text("(This will not work right)")
box3 = imgui.checkbox("Checkbox", box3)[1]
imgui.end()
gl.glClearColor(1., 1., 1., 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
glfw.swap_buffers(window)
impl.shutdown()
imgui.shutdown()
glfw.terminate()
def main():
imgui.create_context()
window = impl_glfw_init()
impl = GlfwRenderer(window)
io = imgui.get_io()
jb = io.fonts.add_font_from_file_ttf(path_to_font, 30) if path_to_font is not None else None
impl.refresh_font_texture()
while not glfw.window_should_close(window):
render_frame(impl, window, jb)
impl.shutdown()
glfw.terminate()
def init(self, viewer):
self.viewer = viewer
window = Window(width=1200, height=675, name='contact modes')
window.set_on_init(self.init_win)
window.set_on_draw(self.render)
window.set_on_key_press(self.on_key_press)
window.set_on_key_release(self.on_key_release)
window.set_on_mouse_press(self.on_mouse_press)
window.set_on_mouse_drag(self.on_mouse_drag)
window.set_on_resize(self.on_resize)
viewer.add_window(window)
self.window = window
self.imgui_impl = GlfwRenderer(window.window, False)
def main():
ctx = imgui.create_context()
implot.create_context()
implot.set_imgui_context(ctx)
window = impl_glfw_init()
impl = GlfwRenderer(window)
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
if imgui.begin_main_menu_bar():
if imgui.begin_menu("File", True):
clicked_quit, selected_quit = imgui.menu_item(
"Quit", 'Cmd+Q', False, True)
if clicked_quit:
exit(1)
imgui.end_menu()
imgui.end_main_menu_bar()
imgui.begin("Custom window", True)
imgui.text("Bar")
imgui.text_ansi("B\033[31marA\033[mnsi ")
imgui.text_ansi_colored("Eg\033[31mgAn\033[msi ", 0.2, 1., 0.)
imgui.extra.text_ansi_colored("Eggs", 0.2, 1., 0.)
imgui.end()
# show_test_window()
imgui.show_test_window()
implot.show_demo_window()
gl.glClearColor(1., 1., 1., 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
def main():
window = impl_glfw_init()
imgui.create_context()
impl = GlfwRenderer(window)
plot_values = array('f', [sin(x * C) for x in range(L)])
histogram_values = array('f', [random() for _ in range(20)])
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
imgui.begin("Plot example")
imgui.plot_lines(
"Sin(t)",
plot_values,
overlay_text="SIN() over time",
# offset by one item every milisecond, plot values
# buffer its end wraps around
values_offset=int(time() * 100) % L,
# 0=autoscale => (0, 50) = (autoscale width, 50px height)
graph_size=(0, 50),
)
imgui.plot_histogram(
"histogram(random())",
histogram_values,
overlay_text="random histogram",
# offset by one item every milisecond, plot values
# buffer its end wraps around
graph_size=(0, 50),
)
imgui.end()
gl.glClearColor(1., 1., 1., 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
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 replay(fname):
imgui.create_context()
window = impl_glfw_init()
impl = GlfwRenderer(window)
replaygui = ReplayGUI(fname)
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
if imgui.begin_main_menu_bar():
if imgui.begin_menu("File", True):
clicked_quit, _ = imgui.menu_item(
"Quit", 'Cmd+Q', False, True)
if clicked_quit:
exit(0)
imgui.end_menu()
if imgui.begin_menu("View", True):
_, replaygui.show_frontview = imgui.menu_item(
"Front view", selected=replaygui.show_frontview)
imgui.end_menu()
if imgui.begin_menu("Tools", True):
clicked, _ = imgui.menu_item("Learn control params")
if clicked:
replaygui.learn_controls = True
clicked, _ = imgui.menu_item("Lap timer")
if clicked:
replaygui.lap_timer = True
imgui.end_menu()
imgui.end_main_menu_bar()
replaygui.render()
gl.glClearColor(0, 0, 0, 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
def sim():
imgui.create_context()
window = impl_glfw_init()
impl = GlfwRenderer(window)
sg = SimGUI()
t0 = time.time()
play = True
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
if imgui.begin_main_menu_bar():
if imgui.begin_menu("File", True):
clicked_quit, _ = imgui.menu_item("Quit", 'Cmd+Q', False, True)
if clicked_quit:
exit(0)
imgui.end_menu()
imgui.end_main_menu_bar()
t = time.time()
if play:
sg.step(min(t - t0, 0.03))
else:
sg.idle()
t0 = t
play = sg.render(play)
gl.glClearColor(0, 0, 0, 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
def main():
window = impl_glfw_init()
impl = GlfwRenderer(window)
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
if imgui.begin_main_menu_bar():
if imgui.begin_menu("File", True):
clicked_quit, selected_quit = imgui.menu_item(
"Quit", 'Cmd+Q', False, True)
if clicked_quit:
exit(1)
imgui.end_menu()
imgui.end_main_menu_bar()
imgui.show_test_window()
imgui.begin("Custom window", True)
imgui.text("Bar")
imgui.text_colored("Eggs", 0.2, 1., 0.)
imgui.end()
gl.glClearColor(1., 1., 1., 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
glfw.swap_buffers(window)
impl.shutdown()
imgui.shutdown()
glfw.terminate()
def initialize(self):
vertices = np.array([-0.5, -0.5, 0.0, 0.5, -0.5, 0.0, 0.0, 0.5, 0.0], dtype=np.float32)
self._vao = GL.glGenVertexArrays(1)
GL.glBindVertexArray(self._vao)
vbo = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vbo)
GL.glBufferData(GL.GL_ARRAY_BUFFER, vertices, GL.GL_STATIC_DRAW)
GL.glVertexAttribPointer(0, 3, GL.GL_FLOAT, GL.GL_FALSE, 3 * ctypes.sizeof(ctypes.c_float), None)
GL.glEnableVertexAttribArray(0)
GL.glBindVertexArray(0)
vertex_shader = Shader(GL.GL_VERTEX_SHADER, "shaders_src/hello_triangle_vertex.glsl")
fragment_shader = Shader(GL.GL_FRAGMENT_SHADER, "shaders_src/hello_triangle_frag.glsl")
self._shader_program = ShaderProgram(vertex_shader, fragment_shader)
vertex_shader.delete()
fragment_shader.delete()
imgui.create_context()
self._ui = GlfwRenderer(self._window, False)
def _init_window(self, width, height, fullscreen):
if not glfw.init():
raise Exception("glfw can not be initialized!")
monitor = None
if fullscreen:
monitor = glfw.get_primary_monitor()
self.window = glfw.create_window(width, height, "Toy", monitor, None)
if not self.window:
raise Exception("glfw window can not be created!")
glfw.set_window_pos(self.window, 50, 50)
glfw.make_context_current(self.window)
glfw.swap_interval(1)
glfw.set_window_size_callback(self.window, self._on_resize)
glfw.set_cursor_pos_callback(self.window, self._on_mouse_move)
glfw.set_scroll_callback(self.window, self._on_scroll)
imgui.create_context()
self.impl = GlfwRenderer(self.window, False)
def main():
init()
imgui.create_context()
window = impl_glfw_init()
impl = GlfwRenderer(window)
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
draw(imgui)
gl.glClearColor(1., 1., 1., 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
def main_glfw():
def glfw_init():
width, height = 1280, 720
window_name = "minimal ImGui/GLFW3 example"
if not glfw.init():
print("Could not initialize OpenGL context")
exit(1)
# 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.OPENGL_FORWARD_COMPAT, gl.GL_TRUE)
# 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 not window:
glfw.terminate()
print("Could not initialize Window")
exit(1)
return window
window = glfw_init()
impl = GlfwRenderer(window)
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
on_frame()
gl.glClearColor(1., 1., 1., 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
# Creating our shader program and telling OpenGL to use it
pipeline = ModulationTransformShaderProgram()
glUseProgram(pipeline.shaderProgram)
# Setting up the clear screen color
glClearColor(0.15, 0.15, 0.15, 1.0)
# Creating shapes on GPU memory
shapeQuad = bs.createRainbowQuad()
gpuQuad = es.GPUShape().initBuffers()
pipeline.setupVAO(gpuQuad)
gpuQuad.fillBuffers(shapeQuad.vertices, shapeQuad.indices, GL_STATIC_DRAW)
# initilize imgui context (see documentation)
imgui.create_context()
impl = GlfwRenderer(window)
# Connecting the callback function 'on_key' to handle keyboard events
# It is important to set the callback after the imgui setup
glfw.set_key_callback(window, on_key)
locationX = 0.0
locationY = 0.0
angle = 0.0
color = (1.0, 1.0, 1.0)
while not glfw.window_should_close(window):
impl.process_inputs()
# Using GLFW to check for input events
def main():
useLiveCamera = True
#gc.disable()
# # transform to convert the image to tensor
# transform = transforms.Compose([
# transforms.ToTensor()
# ])
# # initialize the model
# model = torchvision.models.detection.keypointrcnn_resnet50_fpn(pretrained=True,
# num_keypoints=17)
# # set the computation device
# device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# # load the modle on to the computation device and set to eval mode
# model.to(device).eval()
# initialize glfw
if not glfw.init():
return
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
#creating the window
window = glfw.create_window(1600, 900, "PyGLFusion", None, None)
if not window:
glfw.terminate()
return
glfw.make_context_current(window)
imgui.create_context()
impl = GlfwRenderer(window)
# rendering
glClearColor(0.2, 0.3, 0.2, 1.0)
# positions texture coords
quad = [
-1.0, -1.0, 0.0, 0.0, 0.0, 1.0, -1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0,
1.0, 1.0, -1.0, 1.0, 0.0, 0.0, 1.0
]
quad = np.array(quad, dtype=np.float32)
indices = [0, 1, 2, 2, 3, 0]
indices = np.array(indices, dtype=np.uint32)
screenVertex_shader = (Path(__file__).parent /
'shaders/ScreenQuad.vert').read_text()
screenFragment_shader = (Path(__file__).parent /
'shaders/ScreenQuad.frag').read_text()
renderShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(screenVertex_shader, GL_VERTEX_SHADER),
OpenGL.GL.shaders.compileShader(screenFragment_shader,
GL_FRAGMENT_SHADER))
# set up VAO and VBO for full screen quad drawing calls
VAO = glGenVertexArrays(1)
glBindVertexArray(VAO)
VBO = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, VBO)
glBufferData(GL_ARRAY_BUFFER, 80, quad, GL_STATIC_DRAW)
EBO = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO)
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 24, indices, GL_STATIC_DRAW)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 20, ctypes.c_void_p(0))
glEnableVertexAttribArray(0)
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 20, ctypes.c_void_p(12))
glEnableVertexAttribArray(1)
# shaders
bilateralFilter_shader = (Path(__file__).parent /
'shaders/bilateralFilter.comp').read_text()
bilateralFilterShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(bilateralFilter_shader,
GL_COMPUTE_SHADER))
alignDepthColor_shader = (Path(__file__).parent /
'shaders/alignDepthColor.comp').read_text()
alignDepthColorShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(alignDepthColor_shader,
GL_COMPUTE_SHADER))
depthToVertex_shader = (Path(__file__).parent /
'shaders/depthToVertex.comp').read_text()
depthToVertexShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(depthToVertex_shader,
GL_COMPUTE_SHADER))
vertexToNormal_shader = (Path(__file__).parent /
'shaders/vertexToNormal.comp').read_text()
vertexToNormalShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(vertexToNormal_shader,
GL_COMPUTE_SHADER))
raycast_shader = (Path(__file__).parent /
'shaders/raycast.comp').read_text()
raycastShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(raycast_shader, GL_COMPUTE_SHADER))
integrate_shader = (Path(__file__).parent /
'shaders/integrate.comp').read_text()
integrateShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(integrate_shader, GL_COMPUTE_SHADER))
trackP2P_shader = (Path(__file__).parent /
'shaders/p2pTrack.comp').read_text()
trackP2PShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(trackP2P_shader, GL_COMPUTE_SHADER))
reduceP2P_shader = (Path(__file__).parent /
'shaders/p2pReduce.comp').read_text()
reduceP2PShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(reduceP2P_shader, GL_COMPUTE_SHADER))
trackP2V_shader = (Path(__file__).parent /
'shaders/p2vTrack.comp').read_text()
trackP2VShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(trackP2V_shader, GL_COMPUTE_SHADER))
reduceP2V_shader = (Path(__file__).parent /
'shaders/p2vReduce.comp').read_text()
reduceP2VShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(reduceP2V_shader, GL_COMPUTE_SHADER))
LDLT_shader = (Path(__file__).parent / 'shaders/LDLT.comp').read_text()
LDLTShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(LDLT_shader, GL_COMPUTE_SHADER))
# Splatter
globalMapUpdate_shader = (Path(__file__).parent /
'shaders/GlobalMapUpdate.comp').read_text()
globalMapUpdateShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(globalMapUpdate_shader,
GL_COMPUTE_SHADER))
indexMapGenVert_shader = (Path(__file__).parent /
'shaders/IndexMapGeneration.vert').read_text()
indexMapGenFrag_shader = (Path(__file__).parent /
'shaders/IndexMapGeneration.frag').read_text()
IndexMapGenerationShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(indexMapGenVert_shader,
GL_VERTEX_SHADER),
OpenGL.GL.shaders.compileShader(indexMapGenFrag_shader,
GL_FRAGMENT_SHADER))
SurfaceSplattingVert_shader = (
Path(__file__).parent / 'shaders/SurfaceSplatting.vert').read_text()
SurfaceSplattingFrag_shader = (
Path(__file__).parent / 'shaders/SurfaceSplatting.frag').read_text()
SurfaceSplattingShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(SurfaceSplattingVert_shader,
GL_VERTEX_SHADER),
OpenGL.GL.shaders.compileShader(SurfaceSplattingFrag_shader,
GL_FRAGMENT_SHADER))
UnnecessaryPointRemoval_shader = (
Path(__file__).parent /
'shaders/UnnecessaryPointRemoval.comp').read_text()
UnnecessaryPointRemovalShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(UnnecessaryPointRemoval_shader,
GL_COMPUTE_SHADER))
# P2V
expm_shader = (Path(__file__).parent / 'shaders/expm.comp').read_text()
expmShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(expm_shader, GL_COMPUTE_SHADER))
d2c, c2d, K, invK, colK = camera.start(useLiveCamera)
shaderDict = {
'renderShader': renderShader,
'bilateralFilterShader': bilateralFilterShader,
'alignDepthColorShader': alignDepthColorShader,
'depthToVertexShader': depthToVertexShader,
'vertexToNormalShader': vertexToNormalShader,
'raycastVolumeShader': raycastShader,
'integrateVolumeShader': integrateShader,
'trackP2PShader': trackP2PShader,
'reduceP2PShader': reduceP2PShader,
'trackP2VShader': trackP2VShader,
'reduceP2VShader': reduceP2VShader,
'LDLTShader': LDLTShader,
'globalMapUpdate': globalMapUpdateShader,
'indexMapGeneration': IndexMapGenerationShader,
'surfaceSplatting': SurfaceSplattingShader,
'unnecessaryPointRemoval': UnnecessaryPointRemovalShader,
'expm': expmShader
}
bufferDict = {
'p2pReduction': -1,
'p2pRedOut': -1,
'p2vReduction': -1,
'p2vRedOut': -1,
'test': -1,
'outBuf': -1,
'poseBuffer': -1,
'globalMap0': -1,
'globalMap1': -1,
'atomic0': -1,
'atomic1': -1
}
textureDict = {
'rawColor': -1,
'lastColor': -1,
'nextColor': -1,
'rawDepth': -1,
'filteredDepth': -1,
'lastDepth': -1,
'nextDepth': -1,
'refVertex': -1,
'refNormal': -1,
'virtualVertex': -1,
'virtualNormal': -1,
'virtualDepth': -1,
'virtualColor': -1,
'mappingC2D': -1,
'mappingD2C': -1,
'xyLUT': -1,
'tracking': -1,
'volume': -1,
'indexMap': -1
}
fboDict = {'indexMap': -1, 'virtualFrame': -1}
# 'iters' : (2, 5, 10),
fusionConfig = {
'volSize': (128, 128, 128),
'volDim': (1.0, 1.0, 1.0),
'iters': (2, 2, 2),
'initOffset': (0, 0, 0),
'maxWeight': 100.0,
'distThresh': 0.05,
'normThresh': 0.9,
'nearPlane': 0.1,
'farPlane': 4.0,
'maxMapSize': 5000000,
'c_stable': 10.0,
'sigma': 0.6
}
cameraConfig = {
'depthWidth': 640,
'depthHeight': 576,
'colorWidth': 1920,
'colorHeight': 1080,
'd2c': d2c,
'c2d': c2d,
'depthScale': 0.001,
'K': K,
'invK': invK,
'colK': colK
}
textureDict = frame.generateTextures(textureDict, cameraConfig,
fusionConfig)
bufferDict = frame.generateBuffers(bufferDict, cameraConfig, fusionConfig)
colorMat = np.zeros(
(cameraConfig['colorHeight'], cameraConfig['colorWidth'], 3),
dtype="uint8")
useColorMat = False
integrateFlag = True
resetFlag = True
initPose = glm.mat4()
initPose[3, 0] = fusionConfig['volDim'][0] / 2.0
initPose[3, 1] = fusionConfig['volDim'][1] / 2.0
initPose[3, 2] = 0
blankResult = np.array([0, 0, 0, 0, 0, 0], dtype='float32')
glBindBuffer(GL_SHADER_STORAGE_BUFFER, bufferDict['poseBuffer'])
glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, 16 * 4,
glm.value_ptr(initPose))
glBufferSubData(GL_SHADER_STORAGE_BUFFER, 16 * 4, 16 * 4,
glm.value_ptr(glm.inverse(initPose)))
glBufferSubData(GL_SHADER_STORAGE_BUFFER, 16 * 4 * 2, 16 * 4,
glm.value_ptr(glm.mat4(1.0)))
glBufferSubData(GL_SHADER_STORAGE_BUFFER, 16 * 4 * 3, 16 * 4,
glm.value_ptr(glm.mat4(1.0)))
glBufferSubData(GL_SHADER_STORAGE_BUFFER, 16 * 4 * 4, 6 * 4, blankResult)
glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)
mouseX, mouseY = 0, 0
clickedPoint3D = glm.vec4(fusionConfig['volDim'][0] / 2.0,
fusionConfig['volDim'][1] / 2.0, 0, 0)
sliderDim = fusionConfig['volDim'][0]
#[32 64 128 256 512]
currentSize = math.log2(fusionConfig['volSize'][0]) - 5
volumeStatsChanged = False
currPose = initPose
# splatter stuff
frameCount = 0
fboDict = frame.generateFrameBuffers(fboDict, textureDict, cameraConfig)
initAtomicCount = np.array([0], dtype='uint32')
mapSize = np.array([0], dtype='uint32')
glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, bufferDict['atomic0'])
glBufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0, 4, initAtomicCount)
glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, 0)
glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, bufferDict['atomic1'])
glBufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0, 4, initAtomicCount)
glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, 0)
# aa = torch.tensor([0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0], dtype=torch.float32, device=torch.device('cuda'))
# bb = torch.tensor([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], dtype=torch.float32, device=torch.device('cuda'))
# #setup pycuda gl interop needs to be after openGL is init
# import pycuda.gl.autoinit
# import pycuda.gl
# cuda_gl = pycuda.gl
# cuda_driver = pycuda.driver
# from pycuda.compiler import SourceModule
# import pycuda
# pycuda_source_ssbo = cuda_gl.RegisteredBuffer(int(bufferDict['test']), cuda_gl.graphics_map_flags.NONE)
# sm = SourceModule("""
# __global__ void simpleCopy(float *inputArray, float *outputArray) {
# unsigned int x = blockIdx.x*blockDim.x + threadIdx.x;
# outputArray[x] = inputArray[x];
# inputArray[x] = 8008.135f;
# }
# """)
# cuda_function = sm.get_function("simpleCopy")
# mappingObj = pycuda_source_ssbo.map()
# data, size = mappingObj.device_ptr_and_size()
# cuda_function(np.intp(aa.data_ptr()), np.intp(data), block=(8, 1, 1))
# mappingObj.unmap()
# glBindBuffer(GL_SHADER_STORAGE_BUFFER, bufferDict['test'])
# tee = glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, 32)
# glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)
# teeData = np.frombuffer(tee, dtype=np.float32)
# print(teeData)
# modTensor = aa.cpu().data.numpy()
# print(modTensor)
#fusionConfig['initOffset'] = (initPose[3,0], initPose[3,1], initPose[3,2])
# LUTs
#createXYLUT(k4a, textureDict, cameraConfig) <-- bug in this
person.init()
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
sTime = time.perf_counter()
try:
capture = camera.getFrames(useLiveCamera)
if capture.color is not None:
#if useLiveCamera == False:
#if k4a.configuration["color_format"] == ImageFormat.COLOR_MJPG:
# colorMat = cv2.imdecode(capture.color, cv2.IMREAD_COLOR)
# useColorMat = True
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, textureDict['rawColor'])
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
int(cameraConfig['colorWidth']),
int(cameraConfig['colorHeight']),
(GL_RGB, GL_RGBA)[useLiveCamera],
GL_UNSIGNED_BYTE,
(capture.color, colorMat)[useColorMat])
if capture.depth is not None:
glActiveTexture(GL_TEXTURE1)
glBindTexture(GL_TEXTURE_2D, textureDict['rawDepth'])
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
int(cameraConfig['depthWidth']),
int(cameraConfig['depthHeight']), GL_RED,
GL_UNSIGNED_SHORT, capture.depth)
except EOFError:
break
# #smallMat = cv2.pyrDown(colorMat)
# start_time = time.time()
# rotMat = cv2.flip(colorMat, 0)
# pil_image = Image.fromarray(rotMat).convert('RGB')
# image = transform(pil_image)
# image = image.unsqueeze(0).to(device)
# end_time = time.time()
# print((end_time - start_time) * 1000.0)
# with torch.no_grad():
# outputs = model(image)
# output_image = utils.draw_keypoints(outputs, rotMat)
# cv2.imshow('Face detection frame', output_image)
# if cv2.waitKey(1) & 0xFF == ord('q'):
# break
person.getPose(textureDict, cameraConfig, capture.color)
frame.bilateralFilter(shaderDict, textureDict, cameraConfig)
frame.depthToVertex(shaderDict, textureDict, cameraConfig,
fusionConfig)
frame.alignDepthColor(shaderDict, textureDict, cameraConfig,
fusionConfig)
frame.vertexToNormal(shaderDict, textureDict, cameraConfig)
frame.mipmapTextures(textureDict)
#currPose = track.runP2P(shaderDict, textureDict, bufferDict, cameraConfig, fusionConfig, currPose, integrateFlag, resetFlag)
currPose = track.runP2V(shaderDict, textureDict, bufferDict,
cameraConfig, fusionConfig, currPose,
integrateFlag, resetFlag)
#mapSize = track.runSplatter(shaderDict, textureDict, bufferDict, fboDict, cameraConfig, fusionConfig, mapSize, frameCount, integrateFlag, resetFlag)
frameCount += 1
if resetFlag == True:
resetFlag = False
integrateFlag = True
imgui.begin("Menu", True)
if imgui.button("Reset"):
fusionConfig['volSize'] = (1 << (currentSize + 5), 1 <<
(currentSize + 5), 1 <<
(currentSize + 5))
fusionConfig['volDim'] = (sliderDim, sliderDim, sliderDim)
currPose, integrateFlag, resetFlag = track.reset(
textureDict, bufferDict, cameraConfig, fusionConfig,
clickedPoint3D)
volumeStatsChanged = False
if imgui.button("Integrate"):
integrateFlag = not integrateFlag
imgui.same_line()
imgui.checkbox("", integrateFlag)
changedDim, sliderDim = imgui.slider_float("dim",
sliderDim,
min_value=0.01,
max_value=5.0)
clickedSize, currentSize = imgui.combo(
"size", currentSize, ["32", "64", "128", "256", "512"])
if imgui.is_mouse_clicked():
if not imgui.is_any_item_active():
mouseX, mouseY = imgui.get_mouse_pos()
w, h = glfw.get_framebuffer_size(window)
xPos = ((mouseX % int(w / 3)) / (w / 3) *
cameraConfig['depthWidth'])
yPos = (mouseY / (h)) * cameraConfig['depthHeight']
clickedDepth = capture.depth[
int(yPos + 0.5),
int(xPos + 0.5)] * cameraConfig['depthScale']
clickedPoint3D = clickedDepth * (
cameraConfig['invK'] * glm.vec4(xPos, yPos, 1.0, 0.0))
volumeStatsChanged = True
if changedDim or clickedSize:
volumeStatsChanged = True
imgui.end()
graphics.render(VAO, window, shaderDict, textureDict)
imgui.render()
impl.render(imgui.get_draw_data())
eTime = time.perf_counter()
#print((eTime-sTime) * 1000, mapSize[0])
glfw.swap_buffers(window)
glfw.terminate()
if useLiveCamera == True:
camera.stop()
def render_snippet(
source,
file_path,
title="",
width=200,
height=200,
auto_layout=False,
output_dir='.',
click=None,
):
_patch_imgui()
# Little shim that filters out the new_frame and render commands
# so we can use them in code examples. It's simply a hoax.
lines = [
line if all([
"imgui.new_frame()" not in line, "imgui.render()" not in line,
"imgui.end_frame()" not in line
]) else "" for line in source.split('\n')
]
source = "\n".join(lines)
code = compile(source, '<str>', 'exec')
window_name = "minimal ImGui/GLFW3 example"
if not glfw.init():
print("Could not initialize OpenGL context")
exit(1)
# 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.OPENGL_FORWARD_COMPAT, gl.GL_TRUE)
# note: creating context without window is tricky so made window invisible
glfw.window_hint(glfw.VISIBLE, False)
window = glfw.create_window(int(width), int(height), window_name, None,
None)
glfw.make_context_current(window)
if not window:
glfw.terminate()
print("Could not initialize Window")
exit(1)
impl = GlfwRenderer(window)
glfw.poll_events()
# render target for framebuffer
texture = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, width, height, 0,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, None)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_NEAREST)
# create new framebuffer
offscreen_fb = gl.glGenFramebuffers(1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, offscreen_fb)
# attach texture to framebuffer
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, texture, 0)
# note: Clicking simulation is hacky as f**k and it
# requires at least three frames to be rendered:
# * 1st with mouse in position but without button pressed.
# * 2nd in roughly same posiotion of mouse to turn on hover
# mouse button starts to press but still does not trigger click.
# * 3rd in the same position with button pressed still to finally
# trigger the "clicked" state.
# note: If clicking simulation is not required we draw only one frame.
for m_state in ([None] if not click else [False, True, True]):
# note: Mouse click MUST be simulated before new_frame call!
if click:
impl.io.mouse_draw_cursor = True
simulate_click(click[0], click[1], m_state)
else:
# just make sure mouse state is clear
_clear_mouse()
impl.process_inputs()
imgui.new_frame()
with imgui.styled(imgui.STYLE_ALPHA, 1):
imgui.core.set_next_window_size(0, 0)
if auto_layout:
imgui.set_next_window_size(width - 10, height - 10)
imgui.set_next_window_position(impl.io.DisplaySize.x * 0.5,
implio.DisplaySize.y * 0.5,
1,
pivot_x=0.5,
pivot_y=0.5)
exec(code, locals(), globals())
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, offscreen_fb)
gl.glClearColor(1, 1, 1, 0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
# retrieve pixels from framebuffer and write to file
pixels = gl.glReadPixels(0, 0, width, height, gl.GL_RGBA,
gl.GL_UNSIGNED_BYTE)
image = Image.frombytes('RGBA', (width, height), pixels)
# note: glReadPixels returns lines "bottom to top" but PIL reads bytes
# top to bottom
image = image.transpose(Image.FLIP_TOP_BOTTOM)
image.save(os.path.join(output_dir, file_path))
glfw.terminate()