class Debugger(RPObject):

    """ This class manages the onscreen control, and displays statistics. """

    def __init__(self, pipeline):
        RPObject.__init__(self)
        self.debug("Creating debugger")
        self.pipeline = pipeline
        self.analyzer = SceneGraphAnalyzer()

        self.fullscreen_node = Globals.base.pixel2d.attach_new_node("rp_debugger")
        self.create_components()
        self.init_keybindings()

        if self.advanced_info:
            Globals.base.doMethodLater(
                0.5, lambda task: self.collect_scene_data(), "RPDebugger_collectSceneData_initial")
        
        Globals.base.doMethodLater(0.1, self.update_stats, "RPDebugger_updateStats")

    @property
    def advanced_info(self):
        return self.pipeline.settings["pipeline.advanced_debugging_info"]

    def create_components(self):
        """ Creates the gui components """

        self.debugger_width = 460
        self.debugger_visible = False
        self.debugger_interval = None

        self.create_stats()
        self.create_hints()

        self.pipeline_logo = Sprite(
            image="/$$rp/data/gui/pipeline_logo_text.png", x=30, y=30,
            parent=self.fullscreen_node)

        if self.advanced_info:
            self.exposure_node = self.fullscreen_node.attach_new_node("ExposureWidget")
            self.exposure_widget = ExposureWidget(self.pipeline, self.exposure_node)

        self.fps_node = self.fullscreen_node.attach_new_node("FPSChart")
        self.fps_node.set_pos(Vec3(21, 1, -108 - 40))
        self.fps_widget = FPSChart(self.pipeline, self.fps_node)

        self.pixel_widget = PixelInspector(self.pipeline)
        self.buffer_viewer = BufferViewer(self.pipeline, self.fullscreen_node)
        self.pipe_viewer = PipeViewer(self.pipeline, self.fullscreen_node)
        self.rm_selector = RenderModeSelector(self.pipeline, self.fullscreen_node)
        self.error_msg_handler = ErrorMessageDisplay()

        self.handle_window_resize()

    def update(self):
        """ Updates the gui """
        self.error_msg_handler.update()
        self.pixel_widget.update()

    def collect_scene_data(self, task=None):
        """ Analyzes the scene graph to provide useful information """
        self.analyzer.clear()
        for geom_node in Globals.base.render.find_all_matches("**/+GeomNode"):
            self.analyzer.add_node(geom_node.node())
        if task:
            return task.again

    def create_stats(self):
        """ Creates the stats overlay """
        self.overlay_node = Globals.base.aspect2d.attach_new_node("Overlay")
        self.debug_lines = []

        num_lines = 6 if self.advanced_info else 1
        for i in range(num_lines):
            self.debug_lines.append(TextNode(
                pos=Vec2(0, -i * 0.046), parent=self.overlay_node, align="right", color=Vec3(0.7, 1, 1)))
        self.debug_lines[0].color = Vec4(1, 1, 0, 1)

    def create_hints(self):
        """ Creates the hints like keybindings and when reloading shaders """
        self.hint_reloading = Sprite(
            image="/$$rp/data/gui/shader_reload_hint.png",
            parent=self.fullscreen_node)
        self.set_reload_hint_visible(False)

        self.python_warning = None
        if not NATIVE_CXX_LOADED:
            # Warning when using the python version
            self.python_warning = Sprite(
                image="/$$rp/data/gui/python_warning.png",
                parent=self.fullscreen_node)
            Sequence(
                self.python_warning.color_scale_interval(
                    0.7, Vec4(0.3, 1, 1, 0.7), blendType="easeOut"),
                self.python_warning.color_scale_interval(
                    0.7, Vec4(1, 1, 1, 1.0), blendType="easeOut"),
            ).loop()

        # Keybinding hints
        self.keybinding_instructions = Sprite(
            image="/$$rp/data/gui/keybindings.png",
            parent=self.fullscreen_node, any_filter=False)

    def set_reload_hint_visible(self, flag):
        """ Sets whether the shader reload hint is visible """
        if flag:
            self.hint_reloading.show()
        else:
            self.hint_reloading.hide()

    def handle_window_resize(self):
        """ Handles the window resize, repositions the GUI elements to fit on
        screen. """
        # When using small resolutions, scale the GUI so its still useable,
        # otherwise the sub-windows are bigger than the main window
        self.gui_scale = max(0.65, min(1.0, Globals.native_resolution.x / 1920.0))
        self.fullscreen_node.set_scale(self.gui_scale)

        if self.advanced_info:
            self.exposure_node.set_pos(
                Globals.native_resolution.x // self.gui_scale - 200,
                1, -Globals.native_resolution.y // self.gui_scale + 120)
        self.hint_reloading.set_pos(
            float((Globals.native_resolution.x) // 2) / self.gui_scale - 465 // 2, 220)
        self.keybinding_instructions.set_pos(
            30, Globals.native_resolution.y // self.gui_scale - 510.0,)
        self.overlay_node.set_pos(Globals.base.get_aspect_ratio() - 0.07, 1, 1.0 - 0.07)
        if self.python_warning:
            self.python_warning.set_pos(
                (Globals.native_resolution.x // self.gui_scale - 1054) // 2,
                (Globals.native_resolution.y // self.gui_scale - 118 - 40))

        for text in self.debug_lines:
            text.set_pixel_size(16 * max(0.8, self.gui_scale))

        self.buffer_viewer.center_on_screen()
        self.pipe_viewer.center_on_screen()
        self.rm_selector.center_on_screen()

    def init_keybindings(self):
        """ Inits the debugger keybindings """
        Globals.base.accept("v", self.buffer_viewer.toggle)
        Globals.base.accept("c", self.pipe_viewer.toggle)
        Globals.base.accept("z", self.rm_selector.toggle)
        Globals.base.accept("f5", self.toggle_gui_visible)
        Globals.base.accept("f6", self.toggle_keybindings_visible)
        Globals.base.accept("r", self.pipeline.reload_shaders)
        Globals.base.accept("m", self.start_material_editor)

    def start_material_editor(self):
        """ Starts the material editor """
        self.debug("Starting material editor")
        pth = sys.executable
        editor = os.path.dirname(os.path.realpath(__file__))
        editor = os.path.join(editor, "..", "..", "toolkit", "material_editor", "main.py")
        subprocess.Popen([pth, editor], shell=True)        

    def toggle_gui_visible(self):
        """ Shows / Hides the gui """

        if not self.fullscreen_node.is_hidden():
            self.fullscreen_node.hide()
            self.overlay_node.hide()
            self.error_msg_handler.hide()
        else:
            self.fullscreen_node.show()
            self.overlay_node.show()
            self.error_msg_handler.show()

    def toggle_keybindings_visible(self):
        """ Shows / Hides the FPS graph """
        if not self.keybinding_instructions.is_hidden():
            self.keybinding_instructions.hide()
        else:
            self.keybinding_instructions.show()

    def update_stats(self, task=None):
        """ Updates the stats overlay """
        clock = Globals.clock
        self.debug_lines[0].text = "{:3.0f} fps  |  {:3.1f} ms  |  {:3.1f} ms max".format(
            clock.get_average_frame_rate(),
            1000.0 / max(0.001, clock.get_average_frame_rate()),
            clock.get_max_frame_duration() * 1000.0)

        if not self.advanced_info:
            return task.again if task else None

        text = "{:4d} states |  {:4d} transforms "
        text += "|  {:4d} cmds |  {:4d} lights |  {:4d} shadows "
        text += "|  {:5.1f}% atlas usage"
        self.debug_lines[1].text = text.format(
            RenderState.get_num_states(), TransformState.get_num_states(),
            self.pipeline.light_mgr.cmd_queue.num_processed_commands,
            self.pipeline.light_mgr.num_lights,
            self.pipeline.light_mgr.num_shadow_sources,
            self.pipeline.light_mgr.shadow_atlas_coverage)

        text = "Internal:  {:3.0f} MB VRAM |  {:5d} img |  {:5d} tex |  "
        text += "{:5d} fbos |  {:3d} plugins |  {:2d}  views  ({:2d} active)"
        tex_memory, tex_count = self.buffer_viewer.stage_information

        views, active_views = 0, 0
        for target in RenderTarget.REGISTERED_TARGETS:
            if not target.create_default_region:
                num_regions = target.internal_buffer.get_num_display_regions()
                for i, region in enumerate(target.internal_buffer.get_display_regions()):
                    # Skip overlay display region
                    if i == 0 and num_regions > 1:
                        continue
                    views += 1
                    active_views += 1 if target.active and region.active else 0

        self.debug_lines[2].text = text.format(
            tex_memory / (1024**2), len(Image.REGISTERED_IMAGES), tex_count,
            RenderTarget.NUM_ALLOCATED_BUFFERS,
            len(self.pipeline.plugin_mgr.enabled_plugins),
            views, active_views)

        text = "Scene:   {:4.0f} MB VRAM |  {:3d} tex |  {:4d} geoms "
        text += "|  {:4d} nodes |  {:7,.0f} vertices"
        scene_tex_size = 0
        for tex in TexturePool.find_all_textures():
            scene_tex_size += tex.estimate_texture_memory()

        self.debug_lines[3].text = text.format(
            scene_tex_size / (1024**2),
            len(TexturePool.find_all_textures()),
            self.analyzer.get_num_geoms(),
            self.analyzer.get_num_nodes(),
            self.analyzer.get_num_vertices(),
        )

        sun_vector = Vec3(0)
        if self.pipeline.plugin_mgr.is_plugin_enabled("scattering"):
            sun_vector = self.pipeline.plugin_mgr.instances["scattering"].sun_vector

        text = "Time:  {} ({:1.3f}) |  Sun  {:0.2f} {:0.2f} {:0.2f}"
        text += " |  X {:3.1f}  Y {:3.1f}  Z {:3.1f}"
        text += " |  {:2d} tasks |  scheduled: {:2d}"
        self.debug_lines[4].text = text.format(
            self.pipeline.daytime_mgr.formatted_time,
            self.pipeline.daytime_mgr.time,
            sun_vector.x, sun_vector.y, sun_vector.z,
            Globals.base.camera.get_x(Globals.base.render),
            Globals.base.camera.get_y(Globals.base.render),
            Globals.base.camera.get_z(Globals.base.render),
            self.pipeline.task_scheduler.num_tasks,
            self.pipeline.task_scheduler.num_scheduled_tasks,)

        text = "Scene shadows:  "
        if "pssm" in self.pipeline.plugin_mgr.enabled_plugins:
            focus = self.pipeline.plugin_mgr.instances["pssm"].scene_shadow_stage.last_focus
            if focus is not None:
                text += "{:3.1f} {:3.1f} {:3.1f} r {:3.1f}".format(
                    focus[0].x, focus[0].y, focus[0].z, focus[1])
            else:
                text += "none"
        else:
            text += "inactive"

        text += "   |  HPR  ({:3.1f}, {:3.1f}, {:3.1f})  |   {:4d} x {:4d} pixels @ {:3.1f} %"
        text += "   |  {:3d} x {:3d} tiles"
        self.debug_lines[5].text = text.format(
            Globals.base.camera.get_h(Globals.base.render),
            Globals.base.camera.get_p(Globals.base.render),
            Globals.base.camera.get_r(Globals.base.render),
            Globals.native_resolution.x,
            Globals.native_resolution.y,
            self.pipeline.settings["pipeline.resolution_scale"] * 100.0,
            self.pipeline.light_mgr.num_tiles.x,
            self.pipeline.light_mgr.num_tiles.y,)
        if task:
            return task.again
Exemple #2
0
class Debugger(RPObject):
    """ This class manages the onscreen gui and """
    def __init__(self, pipeline):
        RPObject.__init__(self)
        self.debug("Creating debugger")
        self._pipeline = pipeline
        self._analyzer = SceneGraphAnalyzer()

        self._load_config()
        self._fullscreen_node = Globals.base.pixel2d.attach_new_node(
            "PipelineDebugger")
        self._create_components()
        self._init_keybindings()
        self._init_notify()

        Globals.base.doMethodLater(0.5,
                                   lambda task: self._collect_scene_data(),
                                   "RPDebugger_collectSceneData_initial")
        Globals.base.doMethodLater(0.1, self._update_stats,
                                   "RPDebugger_updateStats")

    def _load_config(self):
        """ Loads the gui configuration from config/debugging.yaml """

    def _create_components(self):
        """ Creates the gui components """

        # When using small resolutions, scale the GUI so its still useable,
        # otherwise the sub-windows are bigger than the main window
        scale_factor = min(1.0, Globals.base.win.get_x_size() / 1920.0)
        self._fullscreen_node.set_scale(scale_factor)
        self._gui_scale = scale_factor

        # Component values
        self._debugger_width = 460

        # Create states
        self._debugger_visible = False

        # Create intervals
        self._debugger_interval = None

        # Create the actual GUI
        self._create_topbar()
        self._create_stats()
        self._create_hints()

        self._exposure_node = self._fullscreen_node.attach_new_node(
            "ExposureWidget")
        self._exposure_node.set_pos(
            Globals.base.win.get_x_size() / self._gui_scale - 200, 1,
            -Globals.base.win.get_y_size() / self._gui_scale + 120)
        self._exposure_widget = ExposureWidget(self._pipeline,
                                               self._exposure_node)

        self._fps_node = self._fullscreen_node.attach_new_node("FPSChart")
        self._fps_node.set_pos(Vec3(21, 1, -108 - 40))
        self._fps_widget = FPSChart(self._pipeline, self._fps_node)

        self._pixel_widget = PixelInspector(self._pipeline)

        self._buffer_viewer = BufferViewer(self._pipeline,
                                           self._fullscreen_node)
        self._pipe_viewer = PipeViewer(self._pipeline, self._fullscreen_node)
        self._rm_selector = RenderModeSelector(self._pipeline,
                                               self._fullscreen_node)

    def _init_notify(self):
        """ Inits the notify stream which gets all output from panda and parses
        it """
        self._error_msg_handler = ErrorMessageDisplay()

    def update(self):
        """ Updates the gui """
        self._error_msg_handler.update()
        self._pixel_widget.update()

    def get_error_msg_handler(self):
        """ Returns the error message handler """
        return self._error_msg_handler

    def _create_topbar(self):
        """ Creates the topbar """
        self._pipeline_logo = Sprite(
            image="/$$rp/data/gui/pipeline_logo_text.png",
            x=30,
            y=30,
            parent=self._fullscreen_node)

    def _collect_scene_data(self, task=None):
        """ Analyzes the scene graph to provide useful information """
        self._analyzer.clear()
        for geom_node in Globals.base.render.find_all_matches("**/+GeomNode"):
            self._analyzer.add_node(geom_node.node())
        if task:
            return task.again

    def _create_stats(self):
        """ Creates the stats overlay """
        self._overlay_node = Globals.base.aspect2d.attach_new_node("Overlay")
        self._overlay_node.set_pos(Globals.base.get_aspect_ratio() - 0.07, 1,
                                   1.0 - 0.07)
        self._debug_lines = []
        for i in range(6):
            self._debug_lines.append(
                TextNode(pos=Vec2(0, -i * 0.046),
                         parent=self._overlay_node,
                         pixel_size=16,
                         align="right",
                         color=Vec3(1)))

    def _create_hints(self):
        """ Creates the hints like keybindings and when reloading shaders """
        self._hint_reloading = Sprite(
            image="/$$rp/data/gui/shader_reload_hint.png",
            x=float((Globals.base.win.get_x_size()) // 2) / self._gui_scale -
            465 // 2,
            y=220,
            parent=self._fullscreen_node)
        self.set_reload_hint_visible(False)

        if not NATIVE_CXX_LOADED:
            # Warning when using the python version
            python_warning = Sprite(
                image="/$$rp/data/gui/python_warning.png",
                x=((Globals.base.win.get_x_size() / self._gui_scale) - 1054) //
                2,
                y=(Globals.base.win.get_y_size() / self._gui_scale) - 118 - 40,
                parent=self._fullscreen_node)

            Sequence(
                python_warning.color_scale_interval(0.7,
                                                    Vec4(0.3, 1, 1, 0.7),
                                                    blendType="easeOut"),
                python_warning.color_scale_interval(0.7,
                                                    Vec4(1, 1, 1, 1.0),
                                                    blendType="easeOut"),
            ).loop()

        # Keybinding hints
        self._keybinding_instructions = Sprite(
            image="/$$rp/data/gui/keybindings.png",
            x=30,
            y=Globals.base.win.get_y_size() // self._gui_scale - 510.0,
            parent=self._fullscreen_node,
            any_filter=False)

    def _update_stats(self, task=None):
        """ Updates the stats overlay """
        clock = Globals.clock
        self._debug_lines[
            0].text = "{:3.0f} fps  |  {:3.1f} ms  |  {:3.1f} ms max".format(
                clock.get_average_frame_rate(),
                1000.0 / max(0.001, clock.get_average_frame_rate()),
                clock.get_max_frame_duration() * 1000.0)

        text = "{:4d} render states  |  {:4d} transforms"
        text += "  |  {:4d} commands  |  {:4d} lights  |  {:5d} shadow sources  "
        text += "|  {:3.1f}% atlas usage"
        self._debug_lines[1].text = text.format(
            RenderState.get_num_states(), TransformState.get_num_states(),
            self._pipeline.light_mgr.cmd_queue.num_processed_commands,
            self._pipeline.light_mgr.num_lights,
            self._pipeline.light_mgr.num_shadow_sources,
            self._pipeline.light_mgr.shadow_atlas_coverage)

        text = "Pipeline:   {:3.0f} MiB VRAM  |  {:5d} images  |  {:5d} textures  |  "
        text += "{:5d} render targets  |  {:3d} plugins  | {:2d}  views  ({:2d} active)"
        tex_memory, tex_count = self._buffer_viewer.stage_information

        views, active_views = 0, 0
        for target in RenderTarget.REGISTERED_TARGETS:
            if not target.create_default_region:
                num_regions = target.internal_buffer.get_num_display_regions()
                for i, region in enumerate(
                        target.internal_buffer.get_display_regions()):
                    if i == 0 and num_regions > 1:
                        # Skip overlay display region
                        continue
                    views += 1
                    active_views += 1 if target.active and region.active else 0

        self._debug_lines[2].text = text.format(
            tex_memory / (1024**2), len(Image.REGISTERED_IMAGES), tex_count,
            RenderTarget.NUM_ALLOCATED_BUFFERS,
            len(self._pipeline.plugin_mgr.enabled_plugins), views,
            active_views)

        text = "Scene:   {:4.0f} MiB VRAM  |  {:3d} textures  |  {:4d} geoms  "
        text += "|  {:4d} nodes  |  {:7,.0f} vertices  |  {:5.0f} MiB vTX data  "
        scene_tex_size = 0
        for tex in TexturePool.find_all_textures():
            scene_tex_size += tex.estimate_texture_memory()

        self._debug_lines[3].text = text.format(
            scene_tex_size / (1024**2),
            len(TexturePool.find_all_textures()),
            self._analyzer.get_num_geoms(),
            self._analyzer.get_num_nodes(),
            self._analyzer.get_num_vertices(),
            self._analyzer.get_vertex_data_size() / (1024**2),
        )

        sun_vector = Vec3(0)
        if self._pipeline.plugin_mgr.is_plugin_enabled("scattering"):
            sun_vector = self._pipeline.plugin_mgr.instances[
                "scattering"].sun_vector

        text = "{} ({:1.3f})  |  {:0.2f} {:0.2f} {:0.2f}  |  {:3d} daytime settings  |  X {:3.1f}  Y {:3.1f}  Z {:3.1f}"
        text += "    |  Total tasks:  {:2d}   |   scheduled: {:2d}"
        self._debug_lines[4].text = text.format(
            self._pipeline.daytime_mgr.formatted_time,
            self._pipeline.daytime_mgr.time,
            sun_vector.x,
            sun_vector.y,
            sun_vector.z,
            len(self._pipeline.plugin_mgr.day_settings),
            Globals.base.camera.get_x(Globals.base.render),
            Globals.base.camera.get_y(Globals.base.render),
            Globals.base.camera.get_z(Globals.base.render),
            self._pipeline.task_scheduler.num_tasks,
            self._pipeline.task_scheduler.num_scheduled_tasks,
        )

        text = "Scene shadows:  "
        if "pssm" in self._pipeline.plugin_mgr.enabled_plugins:
            focus = self._pipeline.plugin_mgr.instances[
                "pssm"].scene_shadow_stage.last_focus
            if focus is not None:
                text += "{:3.1f} {:3.1f} {:3.1f} r {:3.1f}".format(
                    focus[0].x, focus[0].y, focus[0].z, focus[1])
            else:
                text += "none"
        else:
            text += "inactive"

        text += "  |  H {:3.1f} P {:3.1f} R {:3.1f}"

        self._debug_lines[5].text = text.format(
            Globals.base.camera.get_h(Globals.base.render),
            Globals.base.camera.get_p(Globals.base.render),
            Globals.base.camera.get_r(Globals.base.render),
        )

        if task:
            return task.again

    def set_reload_hint_visible(self, flag):
        """ Sets whether the shader reload hint is visible """
        if flag:
            self._hint_reloading.show()
        else:
            self._hint_reloading.hide()

    def _init_keybindings(self):
        """ Inits the debugger keybindings """
        Globals.base.accept("v", self._buffer_viewer.toggle)
        Globals.base.accept("c", self._pipe_viewer.toggle)
        Globals.base.accept("z", self._rm_selector.toggle)
        Globals.base.accept("f5", self._toggle_gui_visible)
        Globals.base.accept("f6", self._toggle_fps_visible)

    def _toggle_gui_visible(self):
        """ Shows / Hides the gui """

        if not self._fullscreen_node.is_hidden():
            self._fullscreen_node.hide()
            self._overlay_node.hide()
        else:
            self._fullscreen_node.show()
            self._overlay_node.show()

    def _toggle_fps_visible(self):
        """ Shows / Hides the FPS graph """
        if not self._fps_node.is_hidden():
            self._fps_node.hide()
        else:
            self._fps_node.show()
class Debugger(RPObject):

    """ This class manages the onscreen gui and """

    def __init__(self, pipeline):
        RPObject.__init__(self)
        self.debug("Creating debugger")
        self._pipeline = pipeline
        self._analyzer = SceneGraphAnalyzer()

        self._load_config()
        self._fullscreen_node = Globals.base.pixel2d.attach_new_node(
            "PipelineDebugger")
        self._create_components()
        self._init_keybindings()
        self._init_notify()

        Globals.base.doMethodLater(
            0.5, lambda task: self._collect_scene_data(), "RPDebugger_collectSceneData_initial")
        Globals.base.doMethodLater(0.1, self._update_stats, "RPDebugger_updateStats")

    def _load_config(self):
        """ Loads the gui configuration from config/debugging.yaml """
        

    def _create_components(self):
        """ Creates the gui components """

        # When using small resolutions, scale the GUI so its still useable,
        # otherwise the sub-windows are bigger than the main window
        scale_factor = min(1.0, Globals.base.win.get_x_size() / 1920.0)
        self._fullscreen_node.set_scale(scale_factor)
        self._gui_scale = scale_factor

        # Component values
        self._debugger_width = 460

        # Create states
        self._debugger_visible = False

        # Create intervals
        self._debugger_interval = None

        # Create the actual GUI
        self._create_topbar()
        self._create_stats()
        self._create_hints()

        self._exposure_node = self._fullscreen_node.attach_new_node("ExposureWidget")
        self._exposure_node.set_pos(
            Globals.base.win.get_x_size() / self._gui_scale - 200,
            1, -Globals.base.win.get_y_size() / self._gui_scale + 120)
        self._exposure_widget = ExposureWidget(self._pipeline, self._exposure_node)

        self._fps_node = self._fullscreen_node.attach_new_node("FPSChart")
        self._fps_node.set_pos(Vec3(21, 1, -108 - 40))
        self._fps_widget = FPSChart(self._pipeline, self._fps_node)

        self._pixel_widget = PixelInspector(self._pipeline)

        self._buffer_viewer = BufferViewer(self._pipeline, self._fullscreen_node)
        self._pipe_viewer = PipeViewer(self._pipeline, self._fullscreen_node)
        self._rm_selector = RenderModeSelector(self._pipeline, self._fullscreen_node)

    def _init_notify(self):
        """ Inits the notify stream which gets all output from panda and parses
        it """
        self._error_msg_handler = ErrorMessageDisplay()

    def update(self):
        """ Updates the gui """
        self._error_msg_handler.update()
        self._pixel_widget.update()

    def get_error_msg_handler(self):
        """ Returns the error message handler """
        return self._error_msg_handler

    def _create_topbar(self):
        """ Creates the topbar """
        self._pipeline_logo = Sprite(
            image="/$$rp/data/gui/pipeline_logo_text.png", x=30, y=50,
            parent=self._fullscreen_node)

    def _collect_scene_data(self, task=None):
        """ Analyzes the scene graph to provide useful information """
        self._analyzer.clear()
        for geom_node in Globals.base.render.find_all_matches("**/+GeomNode"):
            self._analyzer.add_node(geom_node.node())
        if task:
            return task.again

    def _create_stats(self):
        """ Creates the stats overlay """
        self._overlay_node = Globals.base.aspect2d.attach_new_node("Overlay")
        self._overlay_node.set_pos(Globals.base.get_aspect_ratio() - 0.07, 1, 1.0 - 0.07)
        self._debug_lines = []
        for i in range(5):
            self._debug_lines.append(TextNode(
                pos=Vec2(0, -i * 0.046), parent=self._overlay_node,
                pixel_size=16, align="right", color=Vec3(1)))

    def _create_hints(self):
        """ Creates the hints like keybindings and when reloading shaders """
        self._hint_reloading = Sprite(
            image="/$$rp/data/gui/shader_reload_hint.png",
            x=float((Globals.base.win.get_x_size()) // 2) / self._gui_scale - 465 // 2, y=220,
            parent=self._fullscreen_node)
        self.set_reload_hint_visible(False)

        if not NATIVE_CXX_LOADED:
            # Warning when using the python version
            python_warning = Sprite(
                image="/$$rp/data/gui/python_warning.png",
                x=((Globals.base.win.get_x_size()/self._gui_scale) - 1054) // 2,
                y=(Globals.base.win.get_y_size()/self._gui_scale) - 118 - 40,
                parent=self._fullscreen_node)

            Sequence(
                python_warning.color_scale_interval(0.7, Vec4(0.3, 1, 1, 0.7), blendType="easeOut"),
                python_warning.color_scale_interval(0.7, Vec4(1, 1, 1, 1.0), blendType="easeOut"),
            ).loop()

        # Keybinding hints
        self._keybinding_instructions = Sprite(
            image="/$$rp/data/gui/keybindings.png", x=30,
            y=Globals.base.win.get_y_size()//self._gui_scale - 510.0,
            parent=self._fullscreen_node, any_filter=False)

    def _update_stats(self, task=None):
        """ Updates the stats overlay """
        clock = Globals.clock
        self._debug_lines[0].text = "{:3.0f} fps  |  {:3.1f} ms  |  {:3.1f} ms max".format(
            clock.get_average_frame_rate(),
            1000.0 / max(0.001, clock.get_average_frame_rate()),
            clock.get_max_frame_duration() * 1000.0)

        text = "{:4d} render states  |  {:4d} transforms"
        text += "  |  {:4d} commands  |  {:4d} lights  |  {:5d} shadow sources  "
        text += "|  {:3.1f}% atlas usage"
        self._debug_lines[1].text = text.format(
            RenderState.get_num_states(), TransformState.get_num_states(),
            self._pipeline.light_mgr.cmd_queue.num_processed_commands,
            self._pipeline.light_mgr.num_lights,
            self._pipeline.light_mgr.num_shadow_sources,
            self._pipeline.light_mgr.shadow_atlas_coverage)

        text = "Pipeline:   {:3.0f} MiB VRAM  |  {:5d} images  |  {:5d} textures  |  "
        text += "{:5d} render targets  |  {:3d} plugins"
        tex_memory, tex_count = self._buffer_viewer.stage_information
        self._debug_lines[2].text = text.format(
            tex_memory / (1024**2), len(Image.REGISTERED_IMAGES), tex_count,
            RenderTarget.NUM_ALLOCATED_BUFFERS,
            len(self._pipeline.plugin_mgr.enabled_plugins))

        text = "Scene:   {:4.0f} MiB VRAM  |  {:3d} textures  |  {:4d} geoms  "
        text += "|  {:4d} nodes  |  {:7,.0f} vertices  |  {:5.0f} MiB vTX data  "
        scene_tex_size = 0
        for tex in TexturePool.find_all_textures():
            scene_tex_size += tex.estimate_texture_memory()

        self._debug_lines[3].text = text.format(
            scene_tex_size / (1024**2),
            len(TexturePool.find_all_textures()),
            self._analyzer.get_num_geoms(),
            self._analyzer.get_num_nodes(),
            self._analyzer.get_num_vertices(),
            self._analyzer.get_vertex_data_size() / (1024**2),
        )

        sun_vector = Vec3(0)
        if self._pipeline.plugin_mgr.is_plugin_enabled("scattering"):
            sun_vector = self._pipeline.plugin_mgr.instances["scattering"].sun_vector

        text = "{} ({:1.3f})  |  {:0.2f} {:0.2f} {:0.2f}  |  {:3d} daytime settings  |  X {:3.1f}  Y {:3.1f}  Z {:3.1f}"
        text += "    |  Total tasks:  {:2d}   |   scheduled: {:2d}"
        self._debug_lines[4].text = text.format(
            self._pipeline.daytime_mgr.formatted_time,
            self._pipeline.daytime_mgr.time,
            sun_vector.x, sun_vector.y, sun_vector.z,
            len(self._pipeline.plugin_mgr.day_settings),
            Globals.base.camera.get_x(Globals.base.render),
            Globals.base.camera.get_y(Globals.base.render),
            Globals.base.camera.get_z(Globals.base.render),
            self._pipeline.task_scheduler.num_tasks,
            self._pipeline.task_scheduler.num_scheduled_tasks,
        )

        if task:
            return task.again

    def set_reload_hint_visible(self, flag):
        """ Sets whether the shader reload hint is visible """
        if flag:
            self._hint_reloading.show()
        else:
            self._hint_reloading.hide()

    def _init_keybindings(self):
        """ Inits the debugger keybindings """
        Globals.base.accept("v", self._buffer_viewer.toggle)
        Globals.base.accept("c", self._pipe_viewer.toggle)
        Globals.base.accept("z", self._rm_selector.toggle)
        Globals.base.accept("f5", self._toggle_gui_visible)
        Globals.base.accept("f6", self._toggle_fps_visible)

    def _toggle_gui_visible(self):
        """ Shows / Hides the gui """

        if not self._fullscreen_node.is_hidden():
            self._fullscreen_node.hide()
            self._overlay_node.hide()
        else:
            self._fullscreen_node.show()
            self._overlay_node.show()

    def _toggle_fps_visible(self):
        """ Shows / Hides the FPS graph """
        if not self._fps_node.is_hidden():
            self._fps_node.hide()
        else:
            self._fps_node.show()
class Debugger(RPObject):

    """ This class manages the onscreen gui and """

    def __init__(self, pipeline):
        RPObject.__init__(self)
        self.debug("Creating debugger")
        self._pipeline = pipeline
        self._analyzer = SceneGraphAnalyzer()

        self._load_config()
        self._fullscreen_node = Globals.base.pixel2d.attach_new_node(
            "PipelineDebugger")
        self._create_components()
        self._init_keybindings()
        self._init_notify()

        Globals.base.doMethodLater(
            0.5, lambda task: self._collect_scene_data(), "RPDebugger_collectSceneData_initial")
        Globals.base.doMethodLater(0.1, self._update_stats, "RPDebugger_updateStats")

    def _load_config(self):
        """ Loads the gui configuration from config/debugging.yaml """
        self._config = load_yaml_file("/$$rpconfig/debugging.yaml")

    def _create_components(self):
        """ Creates the gui components """

        # When using small resolutions, scale the GUI so its still useable,
        # otherwise the sub-windows are bigger than the main window
        scale_factor = min(1.0, Globals.base.win.get_x_size() / 1920.0)
        self._fullscreen_node.set_scale(scale_factor)
        self._gui_scale = scale_factor

        # Component values
        self._debugger_width = 460

        # Create states
        self._debugger_visible = False

        # Create intervals
        self._debugger_interval = None

        # Create the actual GUI
        self._create_debugger()
        self._create_topbar()
        self._create_stats()
        self._create_hints()

        self._exposure_node = self._fullscreen_node.attach_new_node("ExposureWidget")
        self._exposure_node.set_pos(
            Globals.base.win.get_x_size() / self._gui_scale - 200,
            1, -Globals.base.win.get_y_size() / self._gui_scale + 120)
        self._exposure_widget = ExposureWidget(self._pipeline, self._exposure_node)

        self._fps_node = Globals.base.pixel2d.attach_new_node("FPSChart")
        self._fps_node.set_pos(Vec3(21, 1, -108) * scale_factor)
        self._fps_node.set_scale(scale_factor)
        self._fps_widget = FPSChart(self._pipeline, self._fps_node)

        self._pixel_widget = PixelInspector(self._pipeline)

        self._buffer_viewer = BufferViewer(self._pipeline, self._fullscreen_node)
        self._pipe_viewer = PipeViewer(self._pipeline, self._fullscreen_node)

    def _init_notify(self):
        """ Inits the notify stream which gets all output from panda and parses
        it """
        self._error_msg_handler = ErrorMessageDisplay()

    def update(self):
        """ Updates the gui """
        self._error_msg_handler.update()
        self._pixel_widget.update()

    def get_error_msg_handler(self):
        """ Returns the error message handler """
        return self._error_msg_handler

    def _create_topbar(self):
        """ Creates the topbar """
        self._pipeline_logo = Sprite(
            image="/$$rp/data/gui/pipeline_logo_text.png", x=30, y=30,
            parent=self._fullscreen_node)

    def _collect_scene_data(self, task=None):
        """ Analyzes the scene graph to provide useful information """
        self._analyzer.clear()
        for geom_node in Globals.base.render.find_all_matches("**/+GeomNode"):
            self._analyzer.add_node(geom_node.node())
        if task:
            return task.again

    def _create_stats(self):
        """ Creates the stats overlay """
        self._overlay_node = Globals.base.aspect2d.attach_new_node("Overlay")
        self._overlay_node.set_pos(Globals.base.get_aspect_ratio() - 0.07, 1, 1.0 - 0.07)
        self._debug_lines = []
        for i in range(5):
            self._debug_lines.append(TextNode(
                pos=Vec2(0, -i * 0.046), parent=self._overlay_node,
                pixel_size=16, align="right", color=Vec3(1)))

    def _create_hints(self):
        """ Creates the hints like keybindings and when reloading shaders """
        self._hint_reloading = Sprite(
            image="/$$rp/data/gui/shader_reload_hint.png",
            x=float((Globals.base.win.get_x_size()) // 2) / self._gui_scale - 465 // 2, y=220,
            parent=self._fullscreen_node)
        self.set_reload_hint_visible(False)

        if not NATIVE_CXX_LOADED:
            # Warning when using the python version
            python_warning = Sprite(
                image="/$$rp/data/gui/python_warning.png",
                x=((Globals.base.win.get_x_size()/self._gui_scale) - 1054) // 2,
                y=(Globals.base.win.get_y_size()/self._gui_scale) - 118 - 40,
                parent=self._fullscreen_node)

            Sequence(
                python_warning.color_scale_interval(0.7, Vec4(0.3, 1, 1, 0.7), blendType="easeOut"),
                python_warning.color_scale_interval(0.7, Vec4(1, 1, 1, 1.0), blendType="easeOut"),
            ).loop()

        # Keybinding hints
        self._keybinding_instructions = Sprite(
            image="/$$rp/data/gui/keybindings.png", x=30,
            y=Globals.base.win.get_y_size()//self._gui_scale - 510.0,
            parent=self._fullscreen_node, any_filter=False)

    def _update_stats(self, task=None):
        """ Updates the stats overlay """
        clock = Globals.clock
        self._debug_lines[0].text = "{:3.0f} fps  |  {:3.1f} ms  |  {:3.1f} ms max".format(
            clock.get_average_frame_rate(),
            1000.0 / max(0.001, clock.get_average_frame_rate()),
            clock.get_max_frame_duration() * 1000.0)

        text = "{:4d} render states  |  {:4d} transforms"
        text += "  |  {:4d} commands  |  {:4d} lights  |  {:5d} shadow sources  "
        text += "|  {:3.1f}% atlas usage"
        self._debug_lines[1].text = text.format(
            RenderState.get_num_states(), TransformState.get_num_states(),
            self._pipeline.light_mgr.cmd_queue.num_processed_commands,
            self._pipeline.light_mgr.num_lights,
            self._pipeline.light_mgr.num_shadow_sources,
            self._pipeline.light_mgr.shadow_atlas_coverage)

        text = "Pipeline:   {:3.0f} MiB VRAM  |  {:5d} images  |  {:5d} textures  |  "
        text += "{:5d} render targets  |  {:3d} plugins"
        tex_memory, tex_count = self._buffer_viewer.stage_information
        self._debug_lines[2].text = text.format(
            tex_memory / (1024**2), len(Image.REGISTERED_IMAGES), tex_count,
            RenderTarget.NUM_ALLOCATED_BUFFERS,
            len(self._pipeline.plugin_mgr.enabled_plugins))

        text = "Scene:   {:4.0f} MiB VRAM  |  {:3d} textures  |  {:4d} geoms  "
        text += "|  {:4d} nodes  |  {:7,.0f} vertices  |  {:5.0f} MiB vTX data  "
        scene_tex_size = 0
        for tex in TexturePool.find_all_textures():
            scene_tex_size += tex.estimate_texture_memory()

        self._debug_lines[3].text = text.format(
            scene_tex_size / (1024**2),
            len(TexturePool.find_all_textures()),
            self._analyzer.get_num_geoms(),
            self._analyzer.get_num_nodes(),
            self._analyzer.get_num_vertices(),
            self._analyzer.get_vertex_data_size() / (1024**2),
        )

        text = "{} ({:1.3f})  |  {:3d} daytime settings  |  X {:3.1f}  Y {:3.1f}  Z {:3.1f}"
        self._debug_lines[4].text = text.format(
            self._pipeline.daytime_mgr.formatted_time,
            self._pipeline.daytime_mgr.time,
            len(self._pipeline.plugin_mgr.day_settings),
            Globals.base.camera.get_x(Globals.base.render),
            Globals.base.camera.get_y(Globals.base.render),
            Globals.base.camera.get_z(Globals.base.render),)

        if task:
            return task.again

    def _create_debugger(self):
        """ Creates the debugger contents """
        self._debugger_node = self._fullscreen_node.attach_new_node("DebuggerNode")
        self._debugger_node.set_pos(30, 0, -Globals.base.win.get_y_size()//self._gui_scale + 820.0)
        self._debugger_bg_img = Sprite(
            image="/$$rp/data/gui/debugger_background.png", x=0, y=0,
            parent=self._debugger_node, any_filter=False)
        self._create_debugger_content()

    def set_reload_hint_visible(self, flag):
        """ Sets whether the shader reload hint is visible """
        if flag:
            self._hint_reloading.show()
        else:
            self._hint_reloading.hide()


    def _create_debugger_content(self):
        """ Internal method to create the content of the debugger """

        debugger_content = self._debugger_node.attach_new_node("DebuggerContent")
        debugger_content.set_z(-20)
        debugger_content.set_x(20)

        render_modes = [("Default", "", False, "")]

        # Read modes from configuration
        for mode in self._config["render_modes"]:
            data = [mode["name"], mode["key"]]
            data.append("cxx_only" in mode and mode["cxx_only"])
            data.append(mode["requires"] if "requires" in mode else "")
            render_modes.append(data)

        collection = CheckboxCollection()

        for idx, (mode, mode_id, requires_cxx, requires_plugin) in enumerate(render_modes):
            offs_y = idx * 24 + 45
            offs_x = 0
            enabled = True
            if requires_cxx and not NATIVE_CXX_LOADED:
                enabled = False

            if requires_plugin:
                if not self._pipeline.plugin_mgr.is_plugin_enabled(requires_plugin):
                    enabled = False

            box = LabeledCheckbox(
                parent=debugger_content, x=offs_x, y=offs_y, text=mode.upper(),
                text_color=Vec3(0.4), radio=True, chb_checked=(mode == "Default"),
                chb_callback=partial(self._set_render_mode, mode_id),
                text_size=14, expand_width=230, enabled=enabled)
            collection.add(box.checkbox)

    def _set_render_mode(self, mode_id, value):
        """ Callback which gets called when a render mode got selected """
        if not value:
            return

        # Clear old defines
        self._pipeline.stage_mgr.remove_define_if(lambda name: name.startswith("_RM__"))

        if mode_id == "":
            self._pipeline.stage_mgr.defines["ANY_DEBUG_MODE"] = 0
        else:
            self._pipeline.stage_mgr.defines["ANY_DEBUG_MODE"] = 1
            self._pipeline.stage_mgr.define["_RM_" + mode_id] = 1

        # Reload all shaders
        self._pipeline.reload_shaders()

    def _init_keybindings(self):
        """ Inits the debugger keybindings """
        Globals.base.accept("v", self._buffer_viewer.toggle)
        Globals.base.accept("c", self._pipe_viewer.toggle)
        Globals.base.accept("f5", self._toggle_gui_visible)
        Globals.base.accept("f6", self._toggle_fps_visible)

    def _toggle_gui_visible(self):
        """ Shows / Hides the gui """
        if not self._fullscreen_node.is_hidden():
            self._fullscreen_node.hide()
            self._overlay_node.hide()
        else:
            self._fullscreen_node.show()
            self._overlay_node.show()

    def _toggle_fps_visible(self):
        """ Shows / Hides the FPS graph """
        if not self._fps_node.is_hidden():
            self._fps_node.hide()
        else:
            self._fps_node.show()