Fix Thunderscope hanging during sim tests and recompile shaders when OpenGL context changes (UBC-Thunderbots#3526)

* Fix Thunderscope hanging during sim tests and force recompilation of shaders between runs

* Monkey patch ShaderProgram.program to recompile shaders when OpenGL context changes

* Add return docstring

* [pre-commit.ci lite] apply automatic fixes

* Revert "[pre-commit.ci lite] apply automatic fixes"

This reverts commit b16342a.

---------

Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>

Author: williamckha

src/software/thunderscope/common/proto_configuration_widget.py

@@ -77,23 +77,11 @@ def __init__(
         layout.addWidget(self.search_query)
         layout.addWidget(self.param_tree)
 
-        self.run_onetime_async(
-            ProtoConfigurationWidget.DELAYED_CONFIGURATION_TIMEOUT_S,
+        QTimer.singleShot(
+            int(self.DELAYED_CONFIGURATION_TIMEOUT_S * MILLISECONDS_PER_SECOND),
             self.send_proto_to_fullsystem,
         )
 
-    def run_onetime_async(self, time_in_seconds: float, func: Callable) -> None:
-        """Starting a timer that runs a given function after a given
-        amount of seconds one time asynchronously.
-
-        :time_in_seconds: the amount of time in seconds
-        :func: the function that is going to be ran
-        """
-        self.timer = QTimer()
-        self.timer.setSingleShot(True)
-        self.timer.timeout.connect(func)
-        self.timer.start(round(time_in_seconds * MILLISECONDS_PER_SECOND))
-
     def create_widget(self) -> tuple[QHBoxLayout, QHBoxLayout]:
         """Creating widgets that are used to load, save parameters
 

src/software/thunderscope/gl/graphics/gl_robot.py

@@ -11,38 +11,6 @@
 import numpy as np
 
 
-ROBOT_SHADER = shaders.ShaderProgram(
-    "robot-shader",
-    [
-        shaders.VertexShader("""
-            varying vec3 normal;
-            void main() {
-                // find vertex normals and positions
-                normal = normalize(gl_Normal);
-                gl_FrontColor = gl_Color;
-                gl_BackColor = gl_Color;
-                gl_Position = ftransform();
-            }
-        """),
-        shaders.FragmentShader("""
-            varying vec3 normal;
-            void main() {
-                // create an alternate robot color (blue becomes teal, yellow becomes orange)
-                vec3 color = gl_Color.rgb;
-                vec3 color_bright = vec3(color.r, 0.65, color.b);
-
-                // this is the vector pointing forward from the robot
-                vec3 front = vec3(-1.0, 1.0, 0.0);
-
-                // mix colors depending on proximity of the face to the front of the robot
-                float fac = pow(max(dot(normal, front), 0.0), 0.5);
-                gl_FragColor = vec4(mix(color, color_bright, fac), 1.0);
-            }
-        """),
-    ],
-)
-
-
 class GLRobot(GLMeshItem):
     """Displays a 3D mesh representing a robot"""
 
@@ -61,7 +29,7 @@ def __init__(
             meshdata=self.__get_mesh_data(),
             color=color,
             smooth=False,
-            shader=ROBOT_SHADER,
+            shader="robotShader",
         )
 
         self.x = 0
@@ -130,3 +98,45 @@ def __get_mesh_data(self) -> MeshData:
             vertexes=np.array(points),
             faces=np.array(faces),
         )
+
+
+def init_robot_shader():
+    """Adds a shader (robotShader) for rendering robots to the
+    global list of shaders. The front of the robot is brightened
+    to make it easier to see which way they're facing.
+    """
+    shaders.Shaders.append(
+        shaders.ShaderProgram(
+            "robotShader",
+            [
+                shaders.VertexShader("""
+                varying vec3 normal;
+                void main() {
+                    // find vertex normals and positions
+                    normal = normalize(gl_Normal);
+                    gl_FrontColor = gl_Color;
+                    gl_BackColor = gl_Color;
+                    gl_Position = ftransform();
+                }
+            """),
+                shaders.FragmentShader("""
+                varying vec3 normal;
+                void main() {
+                    // create an alternate robot color (blue becomes teal, yellow becomes orange)
+                    vec3 color = gl_Color.rgb;
+                    vec3 color_bright = vec3(color.r, 0.65, color.b);
+    
+                    // this is the vector pointing forward from the robot
+                    vec3 front = vec3(-1.0, 1.0, 0.0);
+    
+                    // mix colors depending on proximity of the face to the front of the robot
+                    float fac = pow(max(dot(normal, front), 0.0), 0.5);
+                    gl_FragColor = vec4(mix(color, color_bright, fac), 1.0);
+                }
+            """),
+            ],
+        )
+    )
+
+
+init_robot_shader()

src/software/thunderscope/gl/helpers/gl_patches.py

@@ -1,5 +1,8 @@
 from pyqtgraph.opengl.GLGraphicsItem import GLGraphicsItem
 from pyqtgraph.opengl.GLViewWidget import GLViewMixin
+from pyqtgraph.opengl.shaders import ShaderProgram
+from pyqtgraph.Qt import QtGui
+from typing import Callable
 
 
 def GLGraphicsItem_setParentItem_patched(self, parent: GLGraphicsItem) -> None:
@@ -66,6 +69,27 @@ def GLViewMixin_removeItem_patched(self, item: GLGraphicsItem) -> None:
     self.update()
 
 
+def ShaderProgram_program_patched(original: Callable) -> Callable:
+    """Returns a patched version of ShaderProgram.program that forces
+    recompilation of the shader program when the OpenGL context changes.
+
+    :param original: the original ShaderProgram.program method
+    :return: the patched ShaderProgram.program method
+    """
+
+    def patched(self):
+        ctx = QtGui.QOpenGLContext.currentContext()
+        if not hasattr(self, "gl_ctx") or self.gl_ctx != ctx:
+            self.gl_ctx = ctx
+            self.prog = None
+            for shader in self.shaders:
+                shader.compiled = None
+        return original(self)
+
+    return patched
+
+
 GLGraphicsItem.setParentItem = GLGraphicsItem_setParentItem_patched
 GLViewMixin.addItem = GLViewMixin_addItem_patched
 GLViewMixin.removeItem = GLViewMixin_removeItem_patched
+ShaderProgram.program = ShaderProgram_program_patched(ShaderProgram.program)

src/software/thunderscope/thunderscope.py

@@ -40,9 +40,6 @@ def __init__(
             The interval in milliseconds to refresh all the widgets.
         """
         self.refresh_interval_ms = refresh_interval_ms
-        self.refresh_timers = []
-
-        self.tabs = QTabWidget()
 
         # ProtoUnixIOs
         #
@@ -59,13 +56,9 @@ def __init__(
 
         # initialize proto unix io map with initial values or default if not provided
         self.proto_unix_io_map = config.proto_unix_io_map
-        self.tab_dock_map = {}
 
-        # iterate through each tab and add one by one
-        for tab in config.tabs:
-            self.tab_dock_map[tab.name] = tab.dock_area
-            self.tabs.addTab(tab.dock_area, tab.name)
-            self.register_refresh_function(tab.refresh)
+        self.tabs = QTabWidget()
+        self.tab_dock_map = {}
 
         self.window = QMainWindow()
         self.window.setCentralWidget(self.tabs)
@@ -74,6 +67,11 @@ def __init__(
         )
         self.window.setWindowTitle("Thunderscope")
 
+        for tab in config.tabs:
+            self.tab_dock_map[tab.name] = tab.dock_area
+            self.tabs.addTab(tab.dock_area, tab.name)
+            self.register_refresh_function(tab.refresh)
+
         # Load the layout file if it exists
         path = layout_path if layout_path else LAST_OPENED_LAYOUT_PATH
         try:
@@ -197,15 +195,17 @@ def register_refresh_function(self, refresh_func: Callable[[], None]) -> None:
 
         :param refresh_func: The function to call at refresh_interval_ms
         """
-        refresh_timer = QtCore.QTimer()
+        refresh_timer = QtCore.QTimer(parent=self.window)
         refresh_timer.setTimerType(QtCore.Qt.TimerType.PreciseTimer)
         refresh_timer.timeout.connect(lambda: refresh_func())
         refresh_timer.start(self.refresh_interval_ms)
 
-        self.refresh_timers.append(refresh_timer)
-
     def show(self) -> None:
-        """Show the main window"""
+        """Show the main window.
+
+        This method will start the Qt event loop and block until the
+        window is closed.
+        """
         self.window.showMaximized()
         pyqtgraph.exec()
 
@@ -214,5 +214,13 @@ def is_open(self) -> bool:
         return self.window.isVisible()
 
     def close(self) -> None:
-        """Close the main window"""
+        """Close the main window.
+
+        Once the window is closed, it will be deleted from memory to
+        prevent it from lingering around and interfering with any new
+        Thunderscope instances we may create. Therefore, you should NOT
+        attempt to reopen the window after it has been closed since the
+        reference to it will be invalid.
+        """
+        self.window.setAttribute(QtCore.Qt.WA_DeleteOnClose)
         QtCore.QTimer.singleShot(0, self.window.close)