Merge branch 'overlay' into develop

# Conflicts:
#	requirements.txt

build.bat

@@ -1,2 +1,2 @@
-pyinstaller --windowed --clean --noconfirm --icon="./img/vrct_logo_mark_black.ico" --add-data "./img;img/" --add-data "./locales;locales/" --add-data "./batch;batch/" --name VRCT --add-data ".venv\Lib\site-packages\customtkinter;customtkinter/" --add-data ".venv\Lib\site-packages\zeroconf;zeroconf/" --exclude-module pandas --exclude-module matplotlib --exclude-module PyQt5 main.py
+pyinstaller --windowed --clean --noconfirm --icon="./img/vrct_logo_mark_black.ico" --add-data "./img;img/" --add-data "./fonts;fonts/" --add-data "./locales;locales/" --add-data "./batch;batch/" --name VRCT --add-data ".venv\Lib\site-packages\customtkinter;customtkinter/" --add-data ".venv\Lib\site-packages\zeroconf;zeroconf/" --add-data ".venv\Lib\site-packages\openvr;openvr/" --exclude-module pandas --exclude-module matplotlib --exclude-module PyQt5 main.py
 "C:\Program Files (x86)\NSIS\makensis.exe" installer/installer.nsi

config.py

@@ -247,6 +247,15 @@ class Config:
         if isinstance(value, bool):
             self._IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = value
 
+    @property
+    def IS_EASTER_EGG_ENABLED(self):
+        return self._IS_EASTER_EGG_ENABLED
+
+    @IS_EASTER_EGG_ENABLED.setter
+    def IS_EASTER_EGG_ENABLED(self, value):
+        if isinstance(value, bool):
+            self._IS_EASTER_EGG_ENABLED = value
+
     # Save Json Data
     ## Main Window
     @property
@@ -727,6 +736,28 @@ class Config:
             self._ENABLE_NOTICE_XSOVERLAY = value
             saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
+    @property
+    @json_serializable('ENABLE_NOTICE_OVERLAY')
+    def ENABLE_NOTICE_OVERLAY(self):
+        return self._ENABLE_NOTICE_OVERLAY
+
+    @ENABLE_NOTICE_OVERLAY.setter
+    def ENABLE_NOTICE_OVERLAY(self, value):
+        if isinstance(value, bool):
+            self._ENABLE_NOTICE_OVERLAY = value
+            saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
+
+    @property
+    @json_serializable('OVERLAY_UI_TYPE')
+    def OVERLAY_UI_TYPE(self):
+        return self._OVERLAY_UI_TYPE
+
+    @OVERLAY_UI_TYPE.setter
+    def OVERLAY_UI_TYPE(self, value):
+        if isinstance(value, str):
+            self._OVERLAY_UI_TYPE = value
+            # saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
+
     @property
     @json_serializable('ENABLE_SEND_MESSAGE_TO_VRC')
     def ENABLE_SEND_MESSAGE_TO_VRC(self):
@@ -900,6 +931,7 @@ class Config:
         self._CURRENT_SENT_MESSAGES_LOG_INDEX = 0
         self._IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = False
         self._IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = False
+        self._IS_EASTER_EGG_ENABLED = False
 
         # Save Json Data
         ## Main Window
@@ -991,6 +1023,8 @@ class Config:
         self._ENABLE_SEND_ONLY_TRANSLATED_MESSAGES = False
         self._SEND_MESSAGE_BUTTON_TYPE = "show"
         self._ENABLE_NOTICE_XSOVERLAY = False
+        self._ENABLE_NOTICE_OVERLAY = False
+        self._OVERLAY_UI_TYPE = "default"
         self._ENABLE_SEND_MESSAGE_TO_VRC = True
         self._ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC = False # Speaker2Chatbox
         self._ENABLE_SPEAKER2CHATBOX_PASS = "000000000"

controller.py

@@ -27,6 +27,11 @@ def callbackFilepathConfigFile():
 def callbackQuitVrct():
     setMainWindowGeometry()
 
+def callbackEnableEasterEgg():
+    config.IS_EASTER_EGG_ENABLED = True
+    config.OVERLAY_UI_TYPE = "sakura"
+    view.printToTextbox_enableEasterEgg()
+
 def setMainWindowGeometry():
     PRE_SCALING_INT = strPctToInt(view.getPreUiScaling())
     NEW_SCALING_INT = strPctToInt(config.UI_SCALING)
@@ -94,6 +99,12 @@ def sendMicMessage(message):
                     translation = f" ({translation})"
                 model.logger.info(f"[SENT] {message}{translation}")
 
+            # if config.ENABLE_NOTICE_OVERLAY is True:
+            #     overlay_image = model.createOverlayImageShort(message, translation)
+            #     model.setOverlayImage(overlay_image)
+            #     overlay_image = model.createOverlayImageLong("send", message, translation)
+            #     model.setOverlayImage(overlay_image)
+
 def startTranscriptionSendMessage():
     model.startMicTranscript(sendMicMessage, view.printToTextbox_TranscriptionSendNoDeviceError)
     view.setMainWindowAllWidgetsStatusToNormal()
@@ -146,6 +157,15 @@ def receiveSpeakerMessage(message):
                 xsoverlay_message = messageFormatter("RECEIVED", translation, message)
                 model.notificationXSOverlay(xsoverlay_message)
 
+            if model.th_overlay is None:
+                model.startOverlay()
+
+            if config.ENABLE_NOTICE_OVERLAY is True:
+                overlay_image = model.createOverlayImageShort(message, translation)
+                model.setOverlayImage(overlay_image)
+                # overlay_image = model.createOverlayImageLong("receive", message, translation)
+                # model.setOverlayImage(overlay_image)
+
             # ------------Speaker2Chatbox------------
             if config.ENABLE_SPEAKER2CHATBOX is True:
                 # send OSC message
@@ -221,6 +241,12 @@ def sendChatMessage(message):
                 osc_message = messageFormatter("SEND", translation, message)
             model.oscSendMessage(osc_message)
 
+        # if config.ENABLE_NOTICE_OVERLAY is True:
+        #     overlay_image = model.createOverlayImageShort(message, translation)
+        #     model.setOverlayImage(overlay_image)
+        #     overlay_image = model.createOverlayImageLong("send", message, translation)
+        #     model.setOverlayImage(overlay_image)
+
         # update textbox message log (Sent)
         view.printToTextbox_SentMessage(message, translation)
         if config.ENABLE_LOGGER is True:
@@ -980,6 +1006,8 @@ def createMainWindow(splash):
     # set UI and callback
     view.register(
         common_registers={
+            "callback_enable_easter_egg": callbackEnableEasterEgg,
+
             "callback_update_software": callbackUpdateSoftware,
             "callback_restart_software": callbackRestartSoftware,
             "callback_filepath_logs": callbackFilepathLogs,

locales/en.yml

@@ -18,6 +18,7 @@ main_window:
   textbox_tab_system: System
 
   textbox_system_message:
+    enabled_easter_egg: Whoa! You caught us! There is something...like...easter-egg-ish function has enabled!
     enabled_translation: Translation feature is turned on.
     disabled_translation: Translation feature is turned off.
     enabled_voice2chatbox: Transcription from the microphone has started.

model.py

@@ -26,6 +26,9 @@ 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 config import config
 
 class threadFnc(Thread):
@@ -37,7 +40,7 @@ class threadFnc(Thread):
     def stop(self):
         self._stop.set()
     def stopped(self):
-        return self._stop.isSet()
+        return self._stop.is_set()
     def run(self):
         while True:
             if self.stopped():
@@ -67,6 +70,9 @@ class Model:
         self.speaker_energy_plot_progressbar = None
         self.translator = Translator()
         self.keyword_processor = KeywordProcessor()
+        self.overlay = Overlay()
+        self.overlay_image = OverlayImage()
+        self.th_overlay = None
 
     def checkCTranslatorCTranslate2ModelWeight(self):
         return checkCTranslate2Weight(config.PATH_LOCAL, config.CTRANSLATE2_WEIGHT_TYPE)
@@ -537,4 +543,32 @@ 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
+        return self.overlay_image.create_overlay_image_short(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 setOverlayImage(self, img):
+        if self.overlay.initFlag is True:
+            self.overlay.uiMan.uiUpdate(img)
+
+    def startOverlay(self):
+        if self.overlay.initFlag is False:
+            self.overlay.init()
+        if self.overlay.initFlag is True:
+            self.th_overlay = threadFnc(self.overlay.startOverlay)
+            self.th_overlay.daemon = True
+            self.th_overlay.start()
+
+    def stopOverlay(self):
+        if isinstance(self.th_overlay, threadFnc):
+            self.th_overlay.stop()
+            self.th_overlay = None
+
 model = Model()

models/overlay/overlay.py

@@ -0,0 +1,196 @@
+import psutil
+import ctypes
+import time
+import asyncio
+import openvr
+from PIL import Image
+
+def check_steamvr_running():
+    for proc in psutil.process_iter():
+        if "vrserver" in proc.name().lower() or "vrcompositor" in 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
+    arr[1][1] = 1
+    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) normalised position of the overlay on the screen
+        """
+        self.overlay = overlayRoot
+        self.overlayKey = key
+        self.overlayName = name
+        self.settings = settings
+        pos = (self.settings['Normalised icon X position'], self.settings['Normalised icon Y position'])
+        self.handle = self.overlay.createOverlay(self.overlayKey, self.overlayName)
+
+        self.setImage(Image.new("RGBA", (1, 1), (0, 0, 0, 0))) # blank image for default
+        self.setColour(self.settings['Colour'])
+        self.setTransparency(self.settings['Transparency'])
+        self.overlay.setOverlayWidthInMeters(
+            self.handle,
+            self.settings['Normalised icon width'] * self.settings['Icon plane depth']
+        )
+
+        self.setPosition(pos)
+        self.overlay.showOverlay(self.handle)
+
+    def setImage(self, img):
+        # configure overlay appearance
+        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)
+
+    def setColour(self, col):
+        """
+        col is a 3-tuple representing (r, g, b)
+        """
+        self.overlay.setOverlayColor(self.handle, col[0], col[1], col[2])
+
+    def setTransparency(self, a):
+        self.overlay.setOverlayAlpha(self.handle, a)
+
+    def setPosition(self, pos):
+        """
+        pos is a 2-tuple representing normalised (x, y)
+        """
+        self.transform = mat34Id() # no rotation required for HMD attachment
+
+        # assign position
+        self.transform[0][3] = pos[0] * self.settings['Icon plane depth']
+        self.transform[1][3] = pos[1] * self.settings['Icon plane depth']
+        self.transform[2][3] = - self.settings['Icon plane depth']
+
+        self.overlay.setOverlayTransformTrackedDeviceRelative(
+            self.handle,
+            openvr.k_unTrackedDeviceIndex_Hmd,
+            self.transform
+        )
+
+class UIManager:
+    def __init__(self, settings):
+        self.overlay = openvr.IVROverlay()
+        self.settings = settings
+        self.overlayUI = UIElement(
+            self.overlay,
+            "VRCT",
+            "Receive UI Element",
+            self.settings,
+        )
+        self.lastUpdate = time.monotonic()
+
+    def update(self):
+        currTime = time.monotonic()
+        if self.settings['Fade interval'] != 0:
+            self.evaluateTransparencyFade(self.overlayUI, self.lastUpdate, currTime)
+
+    def uiUpdate(self, img):
+        self.overlayUI.setImage(img)
+        self.overlayUI.setTransparency(self.settings['Transparency'])
+        self.lastUpdate = time.monotonic()
+
+    def evaluateTransparencyFade(self, ui, lastUpdate, currentTime):
+        if (currentTime - lastUpdate) > self.settings['Fade time']:
+            timeThroughInterval = currentTime - lastUpdate - self.settings['Fade time']
+            fadeRatio = 1 - timeThroughInterval / self.settings['Fade interval']
+            if fadeRatio < 0:
+                fadeRatio = 0
+
+            ui.setTransparency(fadeRatio * self.settings['Transparency'])
+
+    def posUpdate(self, pos):
+        self.overlayUI.setPosition(pos)
+
+class Overlay:
+    def __init__(self):
+        self.initFlag = False
+        settings = {
+            "Colour": [1, 1, 1],
+            "Transparency": 1,
+            "Normalised icon X position": 0.0,
+            "Normalised icon Y position": -0.41,
+            "Icon plane depth": 1,
+            "Normalised icon width": 1,
+            "Fade time": 5,
+            "Fade interval": 2,
+        }
+        self.settings = settings
+
+    def init(self):
+        try:
+            if check_steamvr_running() is True:
+                openvr.init(openvr.VRApplication_Overlay)
+                self.initFlag = True
+        except Exception as e:
+            print("Could not initialise OpenVR")
+
+    async def mainLoop(self):
+        while True:
+            startTime = time.monotonic()
+            self.uiMan.update()
+
+            sleepTime = (1 / 60) - (time.monotonic() - startTime)
+            if sleepTime > 0:
+                await asyncio.sleep(sleepTime)
+
+    async def init_main(self):
+        self.uiMan = UIManager(self.settings)
+        await self.mainLoop()
+
+    def startOverlay(self):
+        asyncio.run(self.init_main())
+
+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.initFlag is False:
+        overlay.init()
+    if overlay.initFlag is True:
+        t = threadFnc(overlay.startOverlay)
+        t.start()
+
+    time.sleep(1)
+    img = overlay_image.create_overlay_image_short("こんにちは、世界！さようなら", "Japanese", "Hello,World!Goodbye", "Japanese", ui_type="sakura")
+    if overlay.initFlag is True:
+        overlay.uiMan.uiUpdate(img)
+    time.sleep(10)
+
+    img = overlay_image.create_overlay_image_short("こんにちは、世界！さようなら", "Japanese", "안녕하세요, 세계!안녕", "Korean")
+    if overlay.initFlag is True:
+        overlay.uiMan.uiUpdate(img)
+    time.sleep(10)
+
+    img = overlay_image.create_overlay_image_short("こんにちは、世界！さようなら", "Japanese", "你好世界！再见", "Chinese Simplified")
+    if overlay.initFlag is True:
+        overlay.uiMan.uiUpdate(img)
+    time.sleep(10)

models/overlay/overlay_image.py

@@ -0,0 +1,228 @@
+from os import path as os_path
+# from datetime import datetime
+from typing import Tuple
+from PIL import Image, ImageDraw, ImageFont
+
+class OverlayImage:
+    WIDTH = 1920//2
+    HEIGHT = 46//2
+    FONT_SIZE_SHORT = HEIGHT
+
+    # TEXT_COLOR_LARGE = (223, 223, 223)
+    # TEXT_COLOR_SMALL = (190, 190, 190)
+    # TEXT_COLOR_SEND = (70, 161, 146)
+    # TEXT_COLOR_RECEIVE = (220, 20, 60)
+    # TEXT_COLOR_TIME = (120, 120, 120)
+    # FONT_SIZE_LARGE = HEIGHT
+    # FONT_SIZE_SMALL = int(FONT_SIZE_LARGE * 2 / 3)
+    LANGUAGES = {
+        "Japanese": "NotoSansJP-Regular",
+        "Korean": "NotoSansKR-Regular",
+        "Chinese Simplified": "NotoSansSC-Regular",
+        "Chinese Traditional": "NotoSansTC-Regular",
+    }
+
+    def __init__(self):
+        self.log_data = []
+
+    @staticmethod
+    def concatenate_images_vertically(img1: Image, img2: Image) -> Image:
+        dst = Image.new('RGBA', (img1.width, img1.height + img2.height))
+        dst.paste(img1, (0, 0))
+        dst.paste(img2, (0, img1.height))
+        return dst
+
+    @staticmethod
+    def add_image_margin(image: Image, top: int, right: int, bottom: int, left: int, color: Tuple[int, int, int, int]) -> Image:
+        width, height = image.size
+        new_width = width + right + left
+        new_height = height + top + bottom
+        result = Image.new(image.mode, (new_width, new_height), color)
+        result.paste(image, (left, top))
+        return result
+
+    # def create_textimage(self, message_type, size, text, language):
+    #     font_size = self.FONT_SIZE_LARGE if size == "large" else self.FONT_SIZE_SMALL
+    #     text_color = self.TEXT_COLOR_LARGE if size == "large" else self.TEXT_COLOR_SMALL
+    #     anchor = "lm" if message_type == "receive" else "rm"
+    #     text_x = 0 if message_type == "receive" else self.WIDTH
+    #     align = "left" if message_type == "receive" else "right"
+
+    #     font_family = self.LANGUAGES.get(language, "NotoSansJP-Regular")
+    #     img = Image.new("RGBA", (0, 0), (0, 0, 0, 0))
+    #     draw = ImageDraw.Draw(img)
+    #     font = ImageFont.truetype(os_path.join(os_path.dirname(__file__), "fonts", f"{font_family}.ttf"), font_size)
+    #     # font = ImageFont.truetype(os_path.join("./fonts", f"{font_family}.ttf"), font_size)
+    #     text_width = draw.textlength(text, font)
+    #     character_width = text_width // len(text)
+    #     character_line_num = int(self.WIDTH // character_width)
+    #     if len(text) > character_line_num:
+    #         text = "\n".join([text[i:i+character_line_num] for i in range(0, len(text), character_line_num)])
+
+    #     n_num = len(text.split("\n")) - 1
+    #     text_height =  int(font_size*(n_num+2))
+
+    #     img = Image.new("RGBA", (self.WIDTH, text_height), (0, 0, 0, 0))
+    #     draw = ImageDraw.Draw(img)
+
+    #     text_y = text_height // 2
+
+    #     draw.multiline_text((text_x, text_y), text, text_color, anchor=anchor, stroke_width=0, font=font, align=align)
+    #     return img
+
+    # def create_textimage_message_type(self, message_type):
+    #     anchor = "lm" if message_type == "receive" else "rm"
+    #     text = "Receive" if message_type == "receive" else "Send"
+    #     text_color = self.TEXT_COLOR_RECEIVE if message_type == "receive" else self.TEXT_COLOR_SEND
+    #     text_color_time = self.TEXT_COLOR_TIME
+
+    #     now = datetime.now()
+    #     formatted_time = now.strftime("%H:%M")
+    #     font_size = self.FONT_SIZE_SMALL
+    #     img = Image.new("RGBA", (0, 0), (0, 0, 0, 0))
+    #     draw = ImageDraw.Draw(img)
+    #     font = ImageFont.truetype(os_path.join(os_path.dirname(__file__), "fonts", "NotoSansJP-Regular.ttf"), font_size)
+    #     # font = ImageFont.truetype(os_path.join("./fonts", "NotoSansJP-Regular.ttf"), font_size)
+    #     text_height = font_size*2
+    #     text_width = draw.textlength(formatted_time, font)
+    #     character_width = text_width // len(formatted_time)
+    #     img = Image.new("RGBA", (self.WIDTH, text_height), (0, 0, 0, 0))
+    #     draw = ImageDraw.Draw(img)
+    #     text_y = text_height // 2
+    #     text_time_x = 0 if message_type == "receive" else self.WIDTH - (text_width + character_width)
+    #     text_x = (text_width + character_width) if message_type == "receive" else self.WIDTH
+
+    #     draw.text((text_time_x, text_y), formatted_time, text_color_time, anchor=anchor, stroke_width=0, font=font)
+    #     draw.text((text_x, text_y), text, text_color, anchor=anchor, stroke_width=0, font=font)
+    #     return img
+
+    # def create_textbox(self, message_type, message, your_language, translation, target_language):
+    #     message_type_img = self.create_textimage_message_type(message_type)
+    #     if len(translation) > 0 and target_language is not None:
+    #         img = self.create_textimage(message_type, "small", message, your_language)
+    #         translation_img = self.create_textimage(message_type, "large",translation, target_language)
+    #         img = self.concatenate_images_vertically(img, translation_img)
+    #     else:
+    #         img = self.create_textimage(message_type, "large", message, your_language)
+    #     return self.concatenate_images_vertically(message_type_img, img)
+
+    # def create_overlay_image_long(self, message_type, message, your_language, translation="", target_language=None):
+    #     if len(self.log_data) > 10:
+    #         self.log_data.pop(0)
+
+    #     self.log_data.append(
+    #         {
+    #             "message_type":message_type,
+    #             "message":message,
+    #             "your_language":your_language,
+    #             "translation":translation,
+    #             "target_language":target_language,
+    #         }
+    #     )
+
+    #     imgs = []
+    #     for log in self.log_data:
+    #         message_type = log["message_type"]
+    #         message = log["message"]
+    #         your_language = log["your_language"]
+    #         translation = log["translation"]
+    #         target_language = log["target_language"]
+    #         img = self.create_textbox(message_type, message, your_language, translation, target_language)
+    #         imgs.append(img)
+
+    #     img = imgs[0]
+    #     for i in imgs[1:]:
+    #         img = self.concatenate_images_vertically(img, i)
+    #     img = self.add_image_margin(img, 0, 20, 0, 20, (0, 0, 0, 0))
+
+    #     width, height = img.size
+    #     background = Image.new("RGBA", (width, height), (0, 0, 0, 0))
+    #     draw = ImageDraw.Draw(background)
+    #     draw.rounded_rectangle([(0, 0), (width, height)], radius=15, fill=self.BACKGROUND_COLOR, outline=self.BACKGROUND_OUTLINE_COLOR, width=5)
+    #     img = Image.alpha_composite(background, img)
+    #     return img
+
+    def get_ui_size(self):
+        return {
+            "width": 960,
+            "height": 23,
+            "font_size": 23,
+        }
+
+    def get_ui_colors(self, ui_type):
+        match ui_type:
+            case "default":
+                background_color = (41, 42, 45, 127)
+                background_outline_color = (41, 42, 45, 127)
+                text_color = (223, 223, 223)
+            case "sakura":
+                background_color = (225, 40, 30, 20)
+                background_outline_color = (255, 255, 255, 50)
+                text_color = (223, 223, 223)
+        return {
+            "background_color": background_color,
+            "background_outline_color": background_outline_color,
+            "text_color": text_color
+        }
+
+    def create_decoration_image(self, ui_type, image_size):
+        decoration_image = Image.new("RGBA", image_size, (0, 0, 0, 0))
+        match ui_type:
+            case "default":
+                pass
+            case "sakura":
+                overlay_tl = Image.open(os_path.join(os_path.dirname(os_path.dirname(os_path.dirname(__file__))), "img", "overlay_tl_sakura.png"))
+                overlay_br = Image.open(os_path.join(os_path.dirname(os_path.dirname(os_path.dirname(__file__))), "img", "overlay_br_sakura.png"))
+                alpha = overlay_tl.getchannel("A")
+                alpha = alpha.point(lambda x: x * 0.1)
+                overlay_tl.putalpha(alpha)
+                alpha = overlay_br.getchannel("A")
+                alpha = alpha.point(lambda x: x * 0.1)
+                overlay_br.putalpha(alpha)
+                decoration_image.paste(overlay_tl, (7, 7))
+                decoration_image.paste(overlay_br, (image_size[0]-overlay_br.size[0]-7, image_size[1]-overlay_br.size[1]-7))
+        return decoration_image
+
+    def create_textbox_short(self, text, language, text_color, base_width, base_height, font_size):
+        font_family = self.LANGUAGES.get(language, "NotoSansJP-Regular")
+        img = Image.new("RGBA", (base_width, base_height), (0, 0, 0, 0))
+        draw = ImageDraw.Draw(img)
+        font = ImageFont.truetype(os_path.join(os_path.dirname(os_path.dirname(os_path.dirname(__file__))), "fonts", f"{font_family}.ttf"), font_size)
+        text_width = draw.textlength(text, font)
+        character_width = text_width // len(text)
+        character_line_num = int((base_width) // character_width) - 12
+        if len(text) > character_line_num:
+            text = "\n".join([text[i:i+character_line_num] for i in range(0, len(text), character_line_num)])
+        text_height = font_size * (len(text.split("\n")) + 1) + 20
+        img = Image.new("RGBA", (base_width, text_height), (0, 0, 0, 0))
+        draw = ImageDraw.Draw(img)
+
+        text_x = base_width // 2
+        text_y = text_height // 2
+        draw.text((text_x, text_y), text, text_color, anchor="mm", stroke_width=0, font=font, align="center")
+        return img
+
+    def create_overlay_image_short(self, message, your_language, translation="", target_language=None, ui_type="default"):
+        ui_size = self.get_ui_size()
+        height = ui_size["height"]
+        width = ui_size["width"]
+        font_size = ui_size["font_size"]
+
+        ui_colors = self.get_ui_colors(ui_type)
+        text_color = ui_colors["text_color"]
+        background_color = ui_colors["background_color"]
+        background_outline_color = ui_colors["background_outline_color"]
+
+        img = self.create_textbox_short(message, your_language, text_color, width, height, font_size)
+        if len(translation) > 0 and target_language is not None:
+            translation_img = self.create_textbox_short(translation, target_language, text_color, width, height, font_size)
+            img = self.concatenate_images_vertically(img, translation_img)
+
+        background = Image.new("RGBA", img.size, (0, 0, 0, 0))
+        draw = ImageDraw.Draw(background)
+        draw.rounded_rectangle([(0, 0), img.size], radius=30, fill=background_color, outline=background_outline_color, width=5)
+
+        decoration_image = self.create_decoration_image(ui_type, img.size)
+        background = Image.alpha_composite(background, decoration_image)
+        img = Image.alpha_composite(background, img)
+        return img

requirements.txt

@@ -12,6 +12,7 @@ transformers[torch]==4.37.2
 sentencepiece==0.1.99
 ctranslate2==4.1.0
 faster-whisper==1.0.1
+openvr==1.26.701
 translators @ git+https://github.com/misyaguziya/translators@5.8.9
 SpeechRecognition @ git+https://github.com/misyaguziya/custom_speech_recognition@3.10.2
 tinyoscquery @ git+https://github.com/cyberkitsune/tinyoscquery@0.1.2

view.py

@@ -101,6 +101,8 @@ class View():
 
         self.view_variable = SimpleNamespace(
             # Common
+            CALLBACK_ENABLE_EASTER_EGG=None,
+
             CALLBACK_RESTART_SOFTWARE=None,
             CALLBACK_UPDATE_SOFTWARE=None,
             CALLBACK_OPEN_FILEPATH_LOGS=None,
@@ -555,6 +557,8 @@ class View():
 
 
         if common_registers is not None:
+            self.view_variable.CALLBACK_ENABLE_EASTER_EGG=common_registers.get("callback_enable_easter_egg", None)
+
             self.view_variable.CALLBACK_UPDATE_SOFTWARE=common_registers.get("callback_update_software", None)
             self.view_variable.CALLBACK_RESTART_SOFTWARE=common_registers.get("callback_restart_software", None)
             self.view_variable.CALLBACK_OPEN_FILEPATH_LOGS=common_registers.get("callback_filepath_logs", None)
@@ -770,6 +774,25 @@ class View():
         self.setReceivedMessageFormat_EntryWidgets(config.RECEIVED_MESSAGE_FORMAT)
         self.setReceivedMessageFormatWithT_EntryWidgets(config.RECEIVED_MESSAGE_FORMAT_WITH_T)
 
+
+        # Set Easter Egg
+        self.count = 0
+        def clickedCounter(_e):
+            if self.count < 2:
+                self.count+=1
+                print("Easter egg count:", self.count)
+            else:
+                print("Easter egg count:", self.count, "Easter egg has enabled.")
+                callFunctionIfCallable(self.view_variable.CALLBACK_ENABLE_EASTER_EGG)
+                print(config.OVERLAY_UI_TYPE)
+
+        vrct_gui.sidebar_logo.bind(
+            "<ButtonRelease>",
+            clickedCounter,
+            "+"
+        )
+
+
         # Insert sample conversation for testing.
         # self._insertSampleConversationToTextbox()
 
@@ -1706,6 +1729,9 @@ class View():
 
 
 # Print To Textbox.
+    def printToTextbox_enableEasterEgg(self):
+        self._printToTextbox_Info(i18n.t("main_window.textbox_system_message.enabled_easter_egg"))
+
     def printToTextbox_enableTranslation(self):
         self._printToTextbox_Info(i18n.t("main_window.textbox_system_message.enabled_translation"))
     def printToTextbox_disableTranslation(self):