Merge branch 'overlay_reversion' into develop

# Conflicts:
#	model.py

controller.py

@@ -27,10 +27,10 @@ def callbackFilepathConfigFile():
 def callbackQuitVrct():
     setMainWindowGeometry()
 
-# def callbackEnableEasterEgg():
-#     config.IS_EASTER_EGG_ENABLED = True
-#     config.OVERLAY_UI_TYPE = "sakura"
-#     view.printToTextbox_enableEasterEgg()
+def callbackEnableEasterEgg():
+    config.IS_EASTER_EGG_ENABLED = True
+    config.OVERLAY_UI_TYPE = "sakura"
+    view.printToTextbox_enableEasterEgg()
 
 def setMainWindowGeometry():
     PRE_SCALING_INT = strPctToInt(view.getPreUiScaling())
@@ -161,14 +161,12 @@ def receiveSpeakerMessage(message):
                 xsoverlay_message = messageFormatter("RECEIVED", translation, message)
                 model.notificationXSOverlay(xsoverlay_message)
 
-            # if model.overlay.initialized is False:
-            #     model.startOverlay()
-            # else:
-            #     if config.ENABLE_OVERLAY_SMALL_LOG is True:
-            #         overlay_image = model.createOverlayImageShort(message, translation)
-            #         model.updateOverlay(overlay_image)
-            #         # overlay_image = model.createOverlayImageLong("receive", message, translation)
-            #         # model.updateOverlay(overlay_image)
+            if config.ENABLE_OVERLAY_SMALL_LOG is True:
+                if model.overlay.initialized is True:
+                    overlay_image = model.createOverlayImageShort(message, translation)
+                    model.updateOverlay(overlay_image)
+                # overlay_image = model.createOverlayImageLong("receive", message, translation)
+                # model.updateOverlay(overlay_image)
 
             # ------------Speaker2Chatbox------------
             if config.ENABLE_SPEAKER2CHATBOX is True:
@@ -427,6 +425,12 @@ def callbackToggleTranscriptionReceive(is_turned_on):
         stopThreadingTranscriptionReceiveMessage()
         view.changeTranscriptionDisplayStatus("SPEAKER_OFF")
 
+    if config.ENABLE_TRANSCRIPTION_RECEIVE is True and config.ENABLE_OVERLAY_SMALL_LOG is True:
+        if model.overlay.initialized is False and model.overlay.checkSteamvrRunning() is True:
+            model.startOverlay()
+    elif config.ENABLE_TRANSCRIPTION_RECEIVE is False:
+        pass
+
 def callbackToggleForeground(is_turned_on):
     config.ENABLE_FOREGROUND = is_turned_on
     if config.ENABLE_FOREGROUND is True:
@@ -858,44 +862,44 @@ def callbackSetWhisperWeightType(value):
         config.SELECTED_TRANSCRIPTION_ENGINE = "Google"
     view.showRestartButtonIfRequired()
 
-# # VR Tab
-# def callbackSetOverlaySettings(value, set_type:str):
-#     print("callbackSetOverlaySettings", value, set_type)
-#     pre_settings = config.OVERLAY_SETTINGS
-#     pre_settings[set_type] = value
-#     config.OVERLAY_SETTINGS = pre_settings
-#     match (set_type):
-#         case "opacity":
-#             model.updateOverlayImageOpacity()
-#         case "ui_scaling":
-#             model.updateOverlayImageUiScaling()
+# VR Tab
+def callbackSetOverlaySettings(value, set_type:str):
+    print("callbackSetOverlaySettings", value, set_type)
+    pre_settings = config.OVERLAY_SETTINGS
+    pre_settings[set_type] = value
+    config.OVERLAY_SETTINGS = pre_settings
+    match (set_type):
+        case "opacity":
+            model.updateOverlayImageOpacity()
+        case "ui_scaling":
+            model.updateOverlayImageUiScaling()
 
-# def callbackSetEnableOverlaySmallLog(value):
-#     print("callbackSetEnableOverlaySmallLog", value)
-#     config.ENABLE_OVERLAY_SMALL_LOG = value
+def callbackSetEnableOverlaySmallLog(value):
+    print("callbackSetEnableOverlaySmallLog", value)
+    config.ENABLE_OVERLAY_SMALL_LOG = value
 
-#     if config.ENABLE_OVERLAY_SMALL_LOG is True:
-#         pass
-#     else:
-#         if model.overlay.initialized is True:
-#             model.clearOverlayImage()
+    if config.ENABLE_OVERLAY_SMALL_LOG is True and config.ENABLE_TRANSCRIPTION_RECEIVE is True:
+        if model.overlay.initialized is False and model.overlay.checkSteamvrRunning() is True:
+            model.startOverlay()
+    elif config.ENABLE_OVERLAY_SMALL_LOG is False:
+        pass
 
-# def callbackSetOverlaySmallLogSettings(value, set_type:str):
-#     print("callbackSetOverlaySmallLogSettings", value, set_type)
-#     pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS
-#     pre_settings[set_type] = value
-#     config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings
-#     match (set_type):
-#         case "x_pos":
-#             model.updateOverlayPosition()
-#         case "y_pos":
-#             model.updateOverlayPosition()
-#         case "depth":
-#             model.updateOverlayPosition()
-#         case "display_duration":
-#             model.updateOverlayTimes()
-#         case "fadeout_duration":
-#             model.updateOverlayTimes()
+def callbackSetOverlaySmallLogSettings(value, set_type:str):
+    print("callbackSetOverlaySmallLogSettings", value, set_type)
+    pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS
+    pre_settings[set_type] = value
+    config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings
+    match (set_type):
+        case "x_pos":
+            model.updateOverlayPosition()
+        case "y_pos":
+            model.updateOverlayPosition()
+        case "depth":
+            model.updateOverlayPosition()
+        case "display_duration":
+            model.updateOverlayTimes()
+        case "fadeout_duration":
+            model.updateOverlayTimes()
 
 # Others Tab
 def callbackSetEnableAutoClearMessageBox(value):
@@ -1062,7 +1066,7 @@ def createMainWindow(splash):
     # set UI and callback
     view.register(
         common_registers={
-            # "callback_enable_easter_egg": callbackEnableEasterEgg,
+            "callback_enable_easter_egg": callbackEnableEasterEgg,
 
             "callback_update_software": callbackUpdateSoftware,
             "callback_restart_software": callbackRestartSoftware,
@@ -1150,10 +1154,10 @@ def createMainWindow(splash):
             "callback_set_use_whisper_feature": callbackSetUserWhisperFeature,
             "callback_set_whisper_weight_type": callbackSetWhisperWeightType,
 
-            # # VR Tab
-            # "callback_set_overlay_settings": callbackSetOverlaySettings,
-            # "callback_set_enable_overlay_small_log": callbackSetEnableOverlaySmallLog,
-            # "callback_set_overlay_small_log_settings": callbackSetOverlaySmallLogSettings,
+            # VR Tab
+            "callback_set_overlay_settings": callbackSetOverlaySettings,
+            "callback_set_enable_overlay_small_log": callbackSetEnableOverlaySmallLog,
+            "callback_set_overlay_small_log_settings": callbackSetOverlaySmallLogSettings,
 
             # Others Tab
             "callback_set_enable_auto_clear_chatbox": callbackSetEnableAutoClearMessageBox,

model.py

@@ -26,8 +26,8 @@ from models.translation.translation_languages import translation_lang
 from models.transcription.transcription_languages import transcription_lang
 from models.translation.translation_utils import checkCTranslate2Weight
 from models.transcription.transcription_whisper import checkWhisperWeight
-# from models.overlay.overlay import Overlay
-# from models.overlay.overlay_image import OverlayImage
+from models.overlay.overlay import Overlay
+from models.overlay.overlay_image import OverlayImage
 
 from config import config
 
@@ -81,18 +81,18 @@ class Model:
         self.previous_receive_message = ""
         self.translator = Translator()
         self.keyword_processor = KeywordProcessor()
-        # self.overlay = Overlay(
-        #     config.OVERLAY_SMALL_LOG_SETTINGS["x_pos"],
-        #     config.OVERLAY_SMALL_LOG_SETTINGS["y_pos"],
-        #     config.OVERLAY_SMALL_LOG_SETTINGS["depth"],
-        #     config.OVERLAY_SMALL_LOG_SETTINGS["display_duration"],
-        #     config.OVERLAY_SMALL_LOG_SETTINGS["fadeout_duration"],
-        #     config.OVERLAY_SETTINGS["opacity"],
-        #     config.OVERLAY_SETTINGS["ui_scaling"],
-        # )
-        # self.overlay_image = OverlayImage()
-        # self.pre_overlay_message = None
-        # self.th_overlay = None
+        self.overlay = Overlay(
+            config.OVERLAY_SMALL_LOG_SETTINGS["x_pos"],
+            config.OVERLAY_SMALL_LOG_SETTINGS["y_pos"],
+            config.OVERLAY_SMALL_LOG_SETTINGS["depth"],
+            config.OVERLAY_SMALL_LOG_SETTINGS["display_duration"],
+            config.OVERLAY_SMALL_LOG_SETTINGS["fadeout_duration"],
+            config.OVERLAY_SETTINGS["opacity"],
+            config.OVERLAY_SETTINGS["ui_scaling"],
+        )
+        self.overlay_image = OverlayImage()
+        self.pre_overlay_message = None
+        self.th_overlay = None
         self.mic_audio_queue = None
         self.mic_mute_status = None
         self.mic_mute_status_check = None
@@ -651,65 +651,53 @@ class Model:
     def notificationXSOverlay(self, message):
         xsoverlayForVRCT(content=f"{message}")
 
-    # def createOverlayImageShort(self, message, translation):
-    #     your_language = config.TARGET_LANGUAGE
-    #     target_language = config.SOURCE_LANGUAGE
-    #     ui_type = config.OVERLAY_UI_TYPE
-    #     self.pre_overlay_message = {
-    #         "message" : message,
-    #         "your_language" : your_language,
-    #         "translation" : translation,
-    #         "target_language" : target_language,
-    #         "ui_type" : ui_type,
-    #     }
-    #     return self.overlay_image.createOverlayImageShort(message, your_language, translation, target_language, ui_type)
+    def createOverlayImageShort(self, message, translation):
+        your_language = config.TARGET_LANGUAGE
+        target_language = config.SOURCE_LANGUAGE
+        ui_type = config.OVERLAY_UI_TYPE
+        self.pre_overlay_message = {
+            "message" : message,
+            "your_language" : your_language,
+            "translation" : translation,
+            "target_language" : target_language,
+            "ui_type" : ui_type,
+        }
+        return self.overlay_image.createOverlayImageShort(message, your_language, translation, target_language, ui_type)
 
     # def createOverlayImageLong(self, message_type, message, translation):
     #     your_language = config.TARGET_LANGUAGE if message_type == "receive" else config.SOURCE_LANGUAGE
     #     target_language = config.SOURCE_LANGUAGE if message_type == "receive" else config.TARGET_LANGUAGE
     #     return self.overlay_image.create_overlay_image_long(message_type, message, your_language, translation, target_language)
 
-    # def clearOverlayImage(self):
-    #     if self.overlay.initialized is True:
-    #         self.overlay.uiManager.uiClear()
+    def clearOverlayImage(self):
+        self.overlay.clearImage()
 
-    # def updateOverlay(self, img):
-    #     if self.overlay.initialized is True:
-    #         self.overlay.uiManager.uiUpdate(img)
+    def updateOverlay(self, img):
+        self.overlay.updateImage(img)
 
-    # def startOverlay(self):
-    #     if self.overlay.initialized is False:
-    #         self.overlay.init()
+    def startOverlay(self):
+        self.overlay.startOverlay()
 
-    #     if self.overlay.initialized is True and self.th_overlay is None:
-    #         self.th_overlay = Thread(target=self.overlay.startOverlay)
-    #         self.th_overlay.daemon = True
-    #         self.th_overlay.start()
+    def updateOverlayPosition(self):
+        pos = (config.OVERLAY_SMALL_LOG_SETTINGS["x_pos"], config.OVERLAY_SMALL_LOG_SETTINGS["y_pos"])
+        depth = config.OVERLAY_SMALL_LOG_SETTINGS["depth"]
+        self.overlay.updatePosition(pos, depth)
 
-    # def updateOverlayPosition(self):
-    #     if self.overlay.initialized is True:
-    #         pos = (config.OVERLAY_SMALL_LOG_SETTINGS["x_pos"], config.OVERLAY_SMALL_LOG_SETTINGS["y_pos"])
-    #         self.overlay.uiManager.setPosition(pos)
-    #         depth = config.OVERLAY_SMALL_LOG_SETTINGS["depth"]
-    #         self.overlay.uiManager.setDepth(depth)
-    #         self.overlay.uiManager.posUpdate()
+    def updateOverlayTimes(self):
+        display_duration = config.OVERLAY_SMALL_LOG_SETTINGS["display_duration"]
+        self.overlay.updateDisplayDuration(display_duration)
+        fadeout_duration = config.OVERLAY_SMALL_LOG_SETTINGS["fadeout_duration"]
+        self.overlay.updateFadeoutDuration(fadeout_duration)
 
-    # def updateOverlayTimes(self):
-    #     if self.overlay.initialized is True:
-    #         display_duration = config.OVERLAY_SMALL_LOG_SETTINGS["display_duration"]
-    #         self.overlay.uiManager.setFadeTime(display_duration)
-    #         fadeout_duration = config.OVERLAY_SMALL_LOG_SETTINGS["fadeout_duration"]
-    #         self.overlay.uiManager.setFadeInterval(fadeout_duration)
-    #         self.overlay.uiManager.update()
+    def updateOverlayImageOpacity(self):
+        opacity = config.OVERLAY_SETTINGS["opacity"]
+        self.overlay.updateOpacity(opacity, with_fade=True)
 
-    # def updateOverlayImageOpacity(self):
-    #     if self.overlay.initialized is True:
-    #         opacity = config.OVERLAY_SETTINGS["opacity"]
-    #         self.overlay.uiManager.setTransparency(opacity)
+    def updateOverlayImageUiScaling(self):
+        ui_scaling = config.OVERLAY_SETTINGS["ui_scaling"]
+        self.overlay.updateUiScaling(ui_scaling)
 
-    # def updateOverlayImageUiScaling(self):
-    #     if self.overlay.initialized is True:
-    #         ui_scaling = config.OVERLAY_SETTINGS["ui_scaling"]
-    #         self.overlay.uiManager.setUiScaling(ui_scaling)
+    def stopOverlay(self):
+        self.overlay.setStopOverlay()
 
 model = Model()

models/overlay/overlay.py

@@ -1,18 +1,14 @@
-import psutil
+import os
+import ctypes
+from psutil import process_iter
+# from os import path as os_path
 import ctypes
 import time
-import asyncio
 import openvr
 from PIL import Image
+# from queue import Queue
+from threading import Thread
 
-def checkSteamvrRunning():
-    for proc in psutil.process_iter():
-        if "vrserver.exe" == proc.name().lower():
-            return True
-    return False
-
-# This code is based on the following source:
-# [GOpy](https://github.com/MeroFune/GOpy)
 def mat34Id():
     arr = openvr.HmdMatrix34_t()
     arr[0][0] = 1
@@ -20,51 +16,94 @@ def mat34Id():
     arr[2][2] = 1
     return arr
 
-class UIElement:
-    def __init__(self, overlayRoot, key: str, name: str, settings: dict = None) -> None:
-        """
-        pos is a 2-tuple representing (x, y) normalized position of the overlay on the screen
-        """
-        self.overlay = overlayRoot
-        self.overlayKey = key
-        self.overlayName = name
+class Overlay:
+    def __init__(self, x, y , depth, display_duration, fadeout_duration, opacity, ui_scaling):
+        self.initialized = False
+        settings = {
+            "color": [1, 1, 1],
+            "opacity": opacity,
+            "x_pos": x,
+            "y_pos": y,
+            "depth": depth,
+            "display_duration": display_duration,
+            "fadeout_duration": fadeout_duration,
+            "ui_scaling": ui_scaling,
+        }
         self.settings = settings
-        self.handle = self.overlay.createOverlay(self.overlayKey, self.overlayName)
+        self.system = None
+        self.overlay = None
+        self.handle = None
+        self.lastUpdate = time.monotonic()
+        self.thread_overlay = None
+        self.fadeRatio = 1
+        self.loop = True
 
-        self.setImage(Image.new("RGBA", (1, 1), (0, 0, 0, 0))) # blank image for default
-        self.setColor(self.settings['Color'])
-        self.setTransparency(self.settings['Transparency'])
-        self.overlay.setOverlayWidthInMeters(
-            self.handle,
-            self.settings['Ui_scaling']
-        )
+    def init(self):
+        try:
+            self.system = openvr.init(openvr.VRApplication_Background)
+            self.overlay = openvr.IVROverlay()
+            self.handle = self.overlay.createOverlay("Overlay_Speaker2log", "SOverlay_Speaker2log_UI")
 
-        self.updatePosition()
-        self.overlay.showOverlay(self.handle)
+            self.updateImage(Image.new("RGBA", (1, 1), (0, 0, 0, 0)))
+            self.updateColor(self.settings["color"])
+            self.updateOpacity(self.settings["opacity"])
+            self.updateUiScaling(self.settings["ui_scaling"])
+            self.updatePosition(
+                (self.settings["x_pos"], self.settings["y_pos"]),
+                self.settings["depth"]
+            )
+            self.overlay.showOverlay(self.handle)
+            self.initialized = True
+        except Exception as e:
+            print("Could not initialise OpenVR", e)
 
-    def setImage(self, img):
-        # configure overlay appearance
+    def updateImage(self, img):
         width, height = img.size
         img = img.tobytes()
         img = (ctypes.c_char * len(img)).from_buffer_copy(img)
         self.overlay.setOverlayRaw(self.handle, img, width, height, 4)
+        self.updateOpacity(self.settings["opacity"])
+        self.lastUpdate = time.monotonic()
 
-    def setColor(self, col):
+    def clearImage(self):
+        self.updateImage(Image.new("RGBA", (1, 1), (0, 0, 0, 0)))
+
+    def updateColor(self, col):
         """
         col is a 3-tuple representing (r, g, b)
         """
-        self.overlay.setOverlayColor(self.handle, col[0], col[1], col[2])
+        self.settings["color"] = col
+        r, g, b = self.settings["color"]
+        self.overlay.setOverlayColor(self.handle, r, g, b)
 
-    def setTransparency(self, a):
-        self.overlay.setOverlayAlpha(self.handle, a)
+    def updateOpacity(self, opacity, with_fade=False):
+        self.settings["opacity"] = opacity
+
+        if with_fade is True:
+            if self.fadeRatio > 0:
+                self.overlay.setOverlayAlpha(self.handle, self.fadeRatio * self.settings["opacity"])
+        else:
+            self.overlay.setOverlayAlpha(self.handle, self.settings["opacity"])
+
+    def updateUiScaling(self, ui_scaling):
+        self.settings['ui_scaling'] = ui_scaling
+        self.overlay.setOverlayWidthInMeters(self.handle, self.settings['ui_scaling'])
+
+    def updatePosition(self, pos, depth):
+        """
+        pos is a 2-tuple representing normalized (x, y)
+        depth is a float representing the depth of the icon plane
+        """
+        self.settings["x_pos"] = pos[0]
+        self.settings["y_pos"] = pos[1]
+        self.settings["depth"] = depth
 
-    def updatePosition(self):
         self.transform = mat34Id() # no rotation required for HMD attachment
 
         # assign position
-        self.transform[0][3] = self.settings["Normalized_icon_X_position"] * self.settings['Icon_plane_depth']
-        self.transform[1][3] = self.settings["Normalized_icon_Y_position"] * self.settings['Icon_plane_depth']
-        self.transform[2][3] = - self.settings['Icon_plane_depth']
+        self.transform[0][3] = self.settings["x_pos"] * self.settings['depth']
+        self.transform[1][3] = self.settings["y_pos"] * self.settings['depth']
+        self.transform[2][3] = - self.settings['depth']
 
         self.overlay.setOverlayTransformTrackedDeviceRelative(
             self.handle,
@@ -72,127 +111,11 @@ class UIElement:
             self.transform
         )
 
-    def setPosition(self, pos):
-        """
-        pos is a 2-tuple representing normalized (x, y)
-        """
-        self.settings["Normalized_icon_X_position"] = pos[0]
-        self.settings["Normalized_icon_Y_position"] = pos[1]
+    def updateDisplayDuration(self, display_duration):
+        self.settings['display_duration'] = display_duration
 
-    def setDepth(self, depth):
-        self.settings["Icon_plane_depth"] = depth
-
-    def setUiScaling(self, ui_scaling):
-        self.overlay.setOverlayWidthInMeters(
-            self.handle,
-            ui_scaling,
-        )
-
-class UIManager:
-    def __init__(self, overlay_key, overlay_name, settings):
-        self.overlay = openvr.IVROverlay()
-        self.settings = settings
-        self.overlayUI = UIElement(
-            self.overlay,
-            overlay_key,
-            overlay_name,
-            self.settings,
-        )
-        self.fadeRatio = 1
-        self.lastUpdate = time.monotonic()
-
-    def update(self):
-        currTime = time.monotonic()
-        if self.settings['Fade_interval'] != 0:
-            self.evaluateTransparencyFade(self.lastUpdate, currTime)
-
-    def uiClear(self):
-        self.overlayUI.setImage(Image.new("RGBA", (1, 1), (0, 0, 0, 0)))
-        self.overlayUI.setTransparency(self.settings['Transparency'])
-        self.lastUpdate = time.monotonic()
-
-    def uiUpdate(self, img):
-        self.overlayUI.setImage(img)
-        self.overlayUI.setTransparency(self.settings['Transparency'])
-        self.lastUpdate = time.monotonic()
-
-    def evaluateTransparencyFade(self, lastUpdate, currentTime):
-        if (currentTime - lastUpdate) > self.settings['Fade_time']:
-            timeThroughInterval = currentTime - lastUpdate - self.settings['Fade_time']
-            self.fadeRatio = 1 - timeThroughInterval / self.settings['Fade_interval']
-            if self.fadeRatio < 0:
-                self.fadeRatio = 0
-
-            self.overlayUI.setTransparency(self.fadeRatio * self.settings['Transparency'])
-
-    def posUpdate(self):
-        self.overlayUI.updatePosition()
-
-    def setPosition(self, pos):
-        self.overlayUI.setPosition(pos)
-
-    def setDepth(self, depth):
-        self.overlayUI.setDepth(depth)
-
-    def setFadeTime(self, fade_time):
-        self.settings["Fade_time"] = fade_time
-
-    def setFadeInterval(self, fade_interval):
-        self.settings["Fade_interval"] = fade_interval
-
-    def setUiScaling(self, ui_scaling):
-        self.overlayUI.setUiScaling(ui_scaling)
-
-    def setTransparency(self, transparency):
-        self.settings["Transparency"] = transparency
-        self.overlayUI.setTransparency(self.fadeRatio * self.settings['Transparency'])
-
-class Overlay:
-    def __init__(self, x, y , depth, fade_time, fade_interval, transparency, ui_scaling):
-        self.initialized = False
-        settings = {
-            "Color": [1, 1, 1],
-            "Transparency": transparency,
-            "Normalized_icon_X_position": x,
-            "Normalized_icon_Y_position": y,
-            "Icon_plane_depth": depth,
-            "Fade_time": fade_time,
-            "Fade_interval": fade_interval,
-            "Ui_scaling": ui_scaling,
-        }
-        self.settings = settings
-        self.system = None
-
-    def init(self):
-        try:
-            if checkSteamvrRunning() is True:
-                self.system = openvr.init(openvr.VRApplication_Background)
-                self.initialized = True
-        except Exception as e:
-            print("Could not initialise OpenVR")
-            print(e)
-
-    async def mainLoop(self):
-        while self.checkActive() is True:
-            startTime = time.monotonic()
-            self.uiManager.update()
-
-            sleepTime = (1 / 60) - (time.monotonic() - startTime)
-            if sleepTime > 0:
-                await asyncio.sleep(sleepTime)
-
-    async def initMain(self):
-        if self.initialized is True:
-            self.uiManager = UIManager("Overlay_Speaker2log", "SOverlay_Speaker2log_UI", self.settings)
-            await self.mainLoop()
-
-    def startOverlay(self):
-        asyncio.run(self.initMain())
-
-    def shutdown(self):
-        self.system = None
-        self.initialized = False
-        openvr.shutdown()
+    def updateFadeoutDuration(self, fadeout_duration):
+        self.settings['fadeout_duration'] = fadeout_duration
 
     def checkActive(self):
         try:
@@ -200,7 +123,6 @@ class Overlay:
                 new_event = openvr.VREvent_t()
                 while self.system.pollNextEvent(new_event):
                     if new_event.eventType == openvr.VREvent_Quit:
-                        self.shutdown()
                         return False
             return True
         except Exception as e:
@@ -208,49 +130,78 @@ class Overlay:
             print(e)
             return False
 
+    def evaluateOpacityFade(self, lastUpdate, currentTime):
+        if (currentTime - lastUpdate) > self.settings['display_duration']:
+            timeThroughInterval = currentTime - lastUpdate - self.settings['display_duration']
+            self.fadeRatio = 1 - timeThroughInterval / self.settings['fadeout_duration']
+            if self.fadeRatio < 0:
+                self.fadeRatio = 0
+            self.overlay.setOverlayAlpha(self.handle, self.fadeRatio * self.settings['opacity'])
+
+    def update(self):
+        currTime = time.monotonic()
+        if self.settings['fadeout_duration'] != 0:
+            self.evaluateOpacityFade(self.lastUpdate, currTime)
+        else:
+            self.updateOpacity(self.settings["opacity"])
+
+    def mainloop(self):
+        self.loop = True
+        while self.checkActive() is True and self.loop is True:
+            startTime = time.monotonic()
+            self.update()
+            sleepTime = (1 / 16) - (time.monotonic() - startTime)
+            if sleepTime > 0:
+                time.sleep(sleepTime)
+        self.shutdownOverlay()
+
+    def main(self):
+        self.init()
+        if self.initialized is True:
+            self.mainloop()
+
+    def startOverlay(self):
+        self.thread_overlay = Thread(target=self.main)
+        self.thread_overlay.daemon = True
+        self.thread_overlay.start()
+
+    def setStopOverlay(self):
+        self.loop = False
+
+    def shutdownOverlay(self):
+        if self.thread_overlay is not None:
+            self.thread_overlay.join()
+            self.thread_overlay = None
+        if self.overlay is not None:
+            self.overlay.destroyOverlay(self.handle)
+            self.overlay = None
+        if self.system is not None:
+            openvr.shutdown()
+            self.system = None
+        self.initialized = False
+
+    @staticmethod
+    def checkSteamvrRunning() -> bool:
+        _proc_name = "vrmonitor.exe" if os.name == 'nt' else "vrmonitor"
+        return _proc_name in (p.name() for p in process_iter())
+
 if __name__ == '__main__':
     from overlay_image import OverlayImage
-    from threading import Thread, Event
-    class threadFnc(Thread):
-        def __init__(self, fnc, end_fnc=None, daemon=True, *args, **kwargs):
-            super(threadFnc, self).__init__(daemon=daemon, *args, **kwargs)
-            self.fnc = fnc
-            self.end_fnc = end_fnc
-            self._stop = Event()
-        def stop(self):
-            self._stop.set()
-        def stopped(self):
-            return self._stop.is_set()
-        def run(self):
-            while True:
-                if self.stopped():
-                    if callable(self.end_fnc):
-                        self.end_fnc()
-                    return
-                self.fnc(*self._args, **self._kwargs)
-
-    overlay = Overlay()
     overlay_image = OverlayImage()
 
-    if overlay.initialized is False:
-        overlay.init()
-    if overlay.initialized is True:
-        t = threadFnc(overlay.startOverlay)
-        t.start()
+    for i in range(100):
+        print(i)
+        overlay = Overlay(0, 0, 1, 1, 1, 1, 1)
+        overlay.startOverlay()
+        time.sleep(1)
 
-    time.sleep(1)
-    img = overlay_image.createOverlayImageShort("こんにちは、世界！さようなら", "Japanese", "Hello,World!Goodbye", "Japanese", ui_type="sakura")
-    # img = overlay_image.createOverlayImageShort("こんにちは、世界！さようなら", "Japanese", ui_type="sakura")
-    if overlay.initialized is True:
-        overlay.uiManager.uiUpdate(img)
-    time.sleep(10)
+        # Example usage
+        img = overlay_image.createOverlayImageShort("こんにちは、世界！さようなら", "Japanese", "Hello,World!Goodbye", "Japanese", ui_type="sakura")
+        overlay.updateImage(img)
+        time.sleep(0.5)
 
-    img = overlay_image.createOverlayImageShort("こんにちは、世界！さようなら", "Japanese", "안녕하세요, 세계!안녕", "Korean")
-    if overlay.initialized is True:
-        overlay.uiManager.uiUpdate(img)
-    time.sleep(10)
+        img = overlay_image.createOverlayImageShort("こんにちは、世界！さようなら", "Japanese", "Hello,World!Goodbye", "Japanese")
+        overlay.updateImage(img)
+        time.sleep(0.5)
 
-    img = overlay_image.createOverlayImageShort("こんにちは、世界！さようなら", "Japanese", "你好世界！再见", "Chinese Simplified")
-    if overlay.initialized is True:
-        overlay.uiManager.uiUpdate(img)
-    time.sleep(10)
+        overlay.setStopOverlay()