Performance enhancement of current rudimental 3D renderer?

[MediumSolid]

I have a severely dumbed down version (original has 2500 lines of code), of a much larger program provided here and I'm wondering if it's possible to correctly assess the culprit and increase its performance.
On my device (Win 11, i5 12600KF, AMD RX6950XT) I'm getting around 10ms per render which by itself may not seem terrible but given what's being rendered and the device at question I'd say it's pretty terrible since it basically giving me 100FPS, which is unacceptable given the circumstance.

My "educated" guess would be that it all boils down to how the rendered texture data is processed down to DPG, which is currently via dpg.set_value, which I assume is done solely on the CPU side.
If that's the case shouldn't there be a way for DPG to read from framebuffer directly or for moderngl to directly draw to the DPG texture, thus effectively bypassing previously presumed CPU intensive writing operation, if that even makes sense?

That's one issue, there's another one that I also guess has to do with the alleged infamous CPU bottleneck. Whenever I have active key handlers and I press and hold any keyboard button as I move around the scene everything slows down significantly. You can test it out yourself, by panning in the scene with middle mouse button and holding down the shift key simultaneously, you'll especially notice that the tooltip lags behind the mouse pointer.

Keep in mind that the program is multi-thread as it's supposed to be by design, setting it to main thread is not an option. Also note that everything I've described is much worse in the original program, there the constant average is 17ms and the sudden decrease in display speed is much worse during a key press, it practically comes to a full stop. Even though I took precautions on how often and in which circumstances the original program has to render, when it comes to mouse movement, trust me when I say that it pretty much has to render during most of its movement. So completely avoiding rendering during mouse movement is not an option.

It goes without saying, but the slowdowns are not reflective in the ms counter but purely visually.

TL;DR;
The program isn't performing up to my expectation. Not sure if everything is set up properly and to the best of DPG's capabilities and possibly available methods, what could I be doing wrong? Weird slow down during key input events occurs.

EDIT:
If nothing else, would switching from DPG to pyimgui be a viable and recommended option here with positive performance increase?

import threading
import time
import numpy as np
import moderngl
import dearpygui.dearpygui as dpg

# --- Vector and Matrix replacements for mathutils ---
class Vector:
    def __init__(self, values):
        self.values = np.array(values, dtype=np.float32)
    
    def __add__(self, other):
        return Vector(self.values + other.values)
    
    def __sub__(self, other):
        return Vector(self.values - other.values)
    
    def __mul__(self, scalar):
        return Vector(self.values * scalar)
    
    def __truediv__(self, scalar):
        return Vector(self.values / scalar)
    
    @property
    def x(self):
        return self.values[0]
    
    @property
    def y(self):
        return self.values[1]
    
    @property
    def z(self):
        return self.values[2] if len(self.values) > 2 else 0.0
    
    def __getitem__(self, index):
        return self.values[index]
    
    def __setitem__(self, index, value):
        self.values[index] = value
    
    def __len__(self):
        return len(self.values)
    
    def copy(self):
        return Vector(self.values.copy())
    
    def __repr__(self):
        return f"Vector({self.values})"

def translation_matrix(translation):
    x, y, z = translation
    return np.array([
        [1, 0, 0, x],
        [0, 1, 0, y],
        [0, 0, 1, z],
        [0, 0, 0, 1]
    ], dtype=np.float32)

# --- ModernGL setup ------------------------------------------------
class ModernGLContext:
    def __init__(self, width, height):
        self.ctx = moderngl.create_standalone_context(require=330)
        self.width, self.height = width, height
        self.fbo = self.ctx.framebuffer(color_attachments=[self.ctx.texture((width, height), 4)])

    def release(self):
        if hasattr(self, 'fbo') and self.fbo:
            self.fbo.release()
        if hasattr(self, 'ctx') and self.ctx:
            self.ctx.release()

# --- Shader sources --------------------------------------------------
VERTEX_SHADER = '''#version 330
uniform mat4 mvp;
uniform vec2 offset;

in vec2 in_pos;

void main() {
    gl_Position = mvp * vec4(in_pos.xy+offset, 0.0, 1.0);
}'''

FRAGMENT_SHADER = '''#version 330
out vec4 f_color;
void main() {
    f_color = vec4(0.5, 0.5, 0.8, 1.0);
}'''

# --- UV renderer using ModernGL -------------------------------------
class ModernGLViewport:
    def __init__(self, width, height):
        self.mgl_context = ModernGLContext(width, height)
        self.ctx = self.mgl_context.ctx
        self.width, self.height = width, height
        
        self.view_offset = Vector([0.0, 0.0])
        self._zoom_level = 1.0
        self.min_zoom, self.max_zoom = 0.01, 10.0
        self.aspect_ratio = 1.0

        self.prog = self.ctx.program(
            vertex_shader=VERTEX_SHADER,
            fragment_shader=FRAGMENT_SHADER
        )

        # Create a simple quad
        vertices = [-0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5, 0.5]
        indices = [0, 1, 2, 0, 2, 3]
        
        vertex_array = np.array(vertices, dtype='f4')
        index_array = np.array(indices, dtype='i4')
        
        self.vbo = self.ctx.buffer(vertex_array)
        self.ibo = self.ctx.buffer(index_array)
        self.vao = self.ctx.vertex_array(self.prog, [(self.vbo, '2f', 'in_pos')], self.ibo)

    @property
    def zoom_level(self):
        return self._zoom_level

    @zoom_level.setter
    def zoom_level(self, value):
        self._zoom_level = min(self.max_zoom, max(self.min_zoom, value))

    def ortho_projection(self, near, far, zoom_level, aspect_ratio):
        x = 2.0/(zoom_level*aspect_ratio)
        y = 2.0/(zoom_level)
        z = 2.0/(far - near)

        return np.array([
            [x,     0.0,    0.0,    0.0],
            [0.0,   y,      0.0,    0.0],
            [0.0,   0.0,    z,      0.0],
            [0.0,   0.0,    0.0,    1.0],
        ], dtype=np.float32)

    def calculate_camera_mat(self, near, far, zoom_level, aspect_ratio, offset_x, offset_y):
        proj = self.ortho_projection(near, far, zoom_level, aspect_ratio)
        view_translation = translation_matrix((offset_x, offset_y, 0.0))
        
        # Combine projection and view translation
        return proj @ view_translation

    def render(self):
        if not self.ctx:
            return None

        self.ctx.clear(0.125, 0.125, 0.125, 1.0)
        camera_mat = self.calculate_camera_mat(-100, 100, self.zoom_level, self.aspect_ratio, self.view_offset.x, self.view_offset.y)
        self.mgl_context.fbo.use()
        mvp = np.array(camera_mat.T, dtype='f4').tobytes()
        
        # Render the quad
        if self.prog and self.vao:
            self.prog['mvp'].write(mvp)
            for i in range(3600):
                x = i%60
                y = i//60
                self.prog['offset'].value = (x*1.05, y*1.05)
                self.vao.render(moderngl.TRIANGLES)
        
        # Read framebuffer        
        image_data = self.mgl_context.fbo.read(components=4, dtype='f4')
        image_np = np.frombuffer(image_data, dtype=np.float32)
        image_np = image_np.reshape((self.height, self.width, 4))
        
        return np.flipud(image_np)

    def release(self):
        if hasattr(self, 'vbo') and self.vbo:
            self.vbo.release()
        if hasattr(self, 'ibo') and self.ibo:
            self.ibo.release()
        if hasattr(self, 'vao') and self.vao:
            self.vao.release()
        if hasattr(self, 'mgl_context') and self.mgl_context:
            self.mgl_context.release()

# --- DPG integration ------------------------------
class SimpleViewer:
    def __init__(self):
        self.running = False
        self.viewport_dimensions = (1280, 720)
        self.mgl_viewport = None
        self.last_mouse_pos = Vector([0, 0])
        
        self.needs_redraw = True

    def start_viewer(self):
        self.running = True
        viewer_thread = threading.Thread(target=self.create_window)
        viewer_thread.daemon = True
        viewer_thread.start()

        return True

    def create_window(self):
        uv_view_dim = self.viewport_dimensions
        
        # Initialize ModernGL        
        dpg.create_context()
        dpg.create_viewport(title="Simple Viewer", width=uv_view_dim[1], height=uv_view_dim[1])
        
        self.mgl_viewport = ModernGLViewport(uv_view_dim[0], uv_view_dim[1])
        
        # Dynamic texture
        with dpg.texture_registry(show=False):
            placeholder = np.zeros((uv_view_dim[0], uv_view_dim[1], 4), dtype=np.uint8)
            self.tex_tag = dpg.add_raw_texture(uv_view_dim[0], uv_view_dim[1], placeholder.flatten(), tag="viewport_tex")

        # Main window
        with dpg.window(tag="main_window", label="Simple Viewer", width=uv_view_dim[0], height=uv_view_dim[1]):
            dpg.set_primary_window("main_window", True)
            with dpg.group(horizontal=True, tag="main_group"):
                # Left panel
                with dpg.child_window(width=225, height=-1, border=True):
                    dpg.add_text("Viewport Controls", color=(0, 200, 255))
                    dpg.add_separator()
                    dpg.add_text("Use MMB to pan")
                    dpg.add_text("Use mouse wheel to zoom")
                    dpg.add_spacer(height=20)
                    
                    # Debug info
                    dpg.add_text("Debug Info", color=(200, 0, 0))
                    self.debug_text = dpg.add_text("Render count: 0")
                    self.status_text = dpg.add_text("Status: Initializing")
                    self.render_time_text = dpg.add_text("Status: Initializing")


                with dpg.group(horizontal=True, tag="render_viewport", parent="main_group"):
                    with dpg.child_window(border=False, tag='uv_viewport', no_scrollbar=True, width=-1, height=-1, no_scroll_with_mouse=True, parent="render_viewport"):
                        with dpg.tooltip(parent=dpg.last_item()):
                            dpg.add_text(default_value="Hover Tooltip")
                        dpg.add_image("viewport_tex", tag="uv_image", parent="uv_viewport")

        # Input callbacks
        with dpg.handler_registry():
            dpg.add_mouse_wheel_handler(callback=self.viewport_mouse_wheel)
            dpg.add_mouse_click_handler(button=2, callback=self.on_mmb_click)
            dpg.add_mouse_drag_handler(button=2, callback=self.on_mmb_drag, threshold=1.0)
            dpg.add_key_press_handler(callback=self.defaul_key_call)

        dpg.set_viewport_resize_callback(callback=self.on_viewport_resize)
        dpg.setup_dearpygui()
        dpg.show_viewport()
        
        self.render_count = 0
        self.last_time = time.time()

        # Main loop
        while self.running and dpg.is_dearpygui_running():
            self.draw_viewport()
            dpg.render_dearpygui_frame()

        # Cleanup
        if self.mgl_viewport:
            self.mgl_viewport.release()
        dpg.destroy_context()

    def defaul_key_call(self, sender, app_data):
        if dpg.is_key_pressed(dpg.mvKey_LShift):
            print("Key Pressed")

    def on_viewport_resize(self, sender, app_data):
        print("Resizing viewport")
        w, h = dpg.get_item_rect_size("render_viewport")
        dpg.configure_item("uv_image", width=w, height=h)

        w = max(1.0, w)
        self.viewport_uv_dimensions = (w, h)
        
        aspect_ratio = w/h
        self.mgl_viewport.aspect_ratio = aspect_ratio
        
        self.needs_redraw = True

    # Input handlers
    def viewport_mouse_wheel(self, sender, app_data):
        if dpg.is_item_hovered('uv_viewport') and self.mgl_viewport:
            self.mgl_viewport.zoom_level = self.mgl_viewport.zoom_level * (1.1 if -app_data > 0 else 0.9)
            self.needs_redraw = True
            dpg.set_value(self.status_text, f"Status: Zoom {self.mgl_viewport.zoom_level:.2f}")

    def on_mmb_click(self, sender, app_data):
        if not dpg.is_item_hovered('uv_viewport'):
            return
        
        if dpg.is_mouse_button_clicked(2):
            mouse_pos = dpg.get_mouse_pos()
            print(f"MMB clicked {mouse_pos}")
            self.last_mouse_pos = Vector([mouse_pos[0], -mouse_pos[1]])

    def on_mmb_drag(self, sender, app_data):
        if not dpg.is_item_hovered('uv_viewport'):
            return
        print("MMB dragged")
        movement_speed = 3.0
        coords = dpg.get_mouse_pos()
        coords = Vector([coords[0], coords[1]])
        current_mouse_pos = Vector([coords[0], -coords[1]])
        delta = (current_mouse_pos - self.last_mouse_pos)/1000.0
        self.last_mouse_pos = current_mouse_pos
        
        mmb_drag = delta * movement_speed * self.mgl_viewport.zoom_level
        self.mgl_viewport.view_offset += mmb_drag
        
        self.needs_redraw = True

    def draw_viewport(self):
        if self.needs_redraw and self.mgl_viewport and self.mgl_viewport.ctx:
            start_time = time.time()

            image_data = self.mgl_viewport.render()
            if image_data is not None:
                dpg.set_value(self.tex_tag, image_data.flatten())
                render_time = (time.time() - start_time) * 1000
                self.render_count += 1
                
                if time.time() - self.last_time > 0.5:  # Update less frequently
                    dpg.set_value(self.debug_text, f"Render count: {self.render_count}")
                    dpg.set_value(self.render_time_text, f"Status: Rendered in {render_time:.1f}ms")
                    self.last_time = time.time()
            
            self.needs_redraw = False

# --- Main execution -------------------------------------------
if __name__ == "__main__":
    viewer = SimpleViewer()
    viewer.start_viewer()

[MediumSolid]

After some digging around, I've reached a subjective conclusion that there isn't unfortunately a lot more that could be done here except for switching to alternatives that offer direct reading from render textures, which is precisely what I did. In fact, I've tested two of them, pyimgui and imgui_bundle respectively. As already mentioned, both of them support direct reading from render textures, they happen to differ on the amount and type of widgets they have. For instance, pyimgui doesn't have an embedded color picker, while on the other hand imgui_bundle does. So make sure to read on their respective documentation in order to deduce which one might suit your needs best.

And yes, my rendering time reduced from 17ms down to 1.5 ms on average, which is pretty much what I've expected. And since image transfer is exclusively handled by the GPU the CPU is freed for the most part, therefore there's no more issues when invoking keyboard events.

Here's also basic rendering setup for each of the two libraries:
pyimgui_basic_rendering_scene.py
imgui_bundle_basic_rendering_scene.py

P.S
Note that these two are no way the best approach to setting up a rendering scene, so any critique is welcome. Also, both of them I believe require Microsoft Visual C++ 14.0 or higher, so make sure you install the necessary tools beforehand. Bare in mind that this all applies as of this day, in eventuality that DearPyGui3D comes into fruition, one might also want to look into that.