@pheem49/mint 1.4.2 → 1.5.1

package/src/System/window_manager.js

@@ -0,0 +1,212 @@
+const { app, BrowserWindow, Tray, Menu, nativeImage, screen } = require('electron');
+const path = require('path');
+
+function createWindowManager(projectRoot) {
+    let mainWindow = null;
+    let settingsWindow = null;
+    let spotlightWindow = null;
+    let widgetWindow = null;
+    let tray = null;
+
+    function createMainWindow() {
+        mainWindow = new BrowserWindow({
+            width: 1180,
+            height: 860,
+            minWidth: 900,
+            minHeight: 680,
+            icon: path.join(projectRoot, 'assets', 'icon.png'),
+            webPreferences: {
+                preload: path.join(projectRoot, 'preload.js'),
+                nodeIntegration: false,
+                contextIsolation: true,
+            },
+            frame: false,
+            transparent: true,
+            resizable: true,
+            show: false
+        });
+
+        mainWindow.loadFile(path.join(projectRoot, 'src/UI/index.html'));
+        mainWindow.on('ready-to-show', () => mainWindow.show());
+        mainWindow.on('close', (event) => {
+            if (!app.isQuiting) {
+                event.preventDefault();
+                mainWindow.hide();
+            }
+            return false;
+        });
+        mainWindow.on('focus', () => {
+            // clearFloatingUnread(); // Disabled
+        });
+        mainWindow.on('closed', () => {
+            mainWindow = null;
+        });
+
+        return mainWindow;
+    }
+
+    function createTray() {
+        const iconPath = path.join(projectRoot, 'assets', 'icon.png');
+        let icon = nativeImage.createFromPath(iconPath);
+        icon = icon.resize({ width: 16, height: 16 });
+
+        tray = new Tray(icon);
+        tray.setToolTip('Mint AI Assistant');
+        tray.setContextMenu(Menu.buildFromTemplate([
+            { label: 'Show App', click: () => { if (mainWindow) mainWindow.show(); } },
+            { label: 'Settings', click: () => { createSettingsWindow(); } },
+            { type: 'separator' },
+            {
+                label: 'Quit',
+                click: () => {
+                    app.isQuiting = true;
+                    app.quit();
+                }
+            }
+        ]));
+
+        tray.on('click', toggleMainWindow);
+        return tray;
+    }
+
+    function createSettingsWindow() {
+        if (settingsWindow) {
+            settingsWindow.focus();
+            return settingsWindow;
+        }
+
+        settingsWindow = new BrowserWindow({
+            width: 720,
+            height: 620,
+            minWidth: 640,
+            minHeight: 560,
+            icon: path.join(projectRoot, 'assets', 'icon.png'),
+            webPreferences: {
+                preload: path.join(projectRoot, 'preload-settings.js'),
+                nodeIntegration: false,
+                contextIsolation: true,
+            },
+            frame: false,
+            transparent: true,
+            resizable: true,
+            parent: mainWindow,
+        });
+        settingsWindow.loadFile(path.join(projectRoot, 'src/UI/settings.html'));
+        settingsWindow.on('closed', () => { settingsWindow = null; });
+        return settingsWindow;
+    }
+
+    function createSpotlightWindow() {
+        if (spotlightWindow) {
+            spotlightWindow.show();
+            return spotlightWindow;
+        }
+
+        const { width: screenWidth, height: screenHeight } = screen.getPrimaryDisplay().workAreaSize;
+        const windowWidth = 600;
+        const windowHeight = 80;
+
+        spotlightWindow = new BrowserWindow({
+            width: windowWidth,
+            height: windowHeight,
+            x: Math.floor((screenWidth - windowWidth) / 2),
+            y: Math.floor(screenHeight * 0.25),
+            frame: false,
+            transparent: true,
+            alwaysOnTop: true,
+            skipTaskbar: true,
+            show: false,
+            webPreferences: {
+                preload: path.join(projectRoot, 'src/UI/preload-spotlight.js'),
+                nodeIntegration: false,
+                contextIsolation: true,
+            }
+        });
+
+        spotlightWindow.loadFile(path.join(projectRoot, 'src/UI/spotlight.html'));
+        spotlightWindow.on('blur', () => spotlightWindow.hide());
+        spotlightWindow.on('closed', () => { spotlightWindow = null; });
+        return spotlightWindow;
+    }
+
+    function createWidgetWindow() {
+        if (widgetWindow) return widgetWindow;
+
+        widgetWindow = new BrowserWindow({
+            width: 150,
+            height: 150,
+            frame: false,
+            transparent: true,
+            resizable: false,
+            alwaysOnTop: true,
+            skipTaskbar: true,
+            show: true,
+            webPreferences: {
+                preload: path.join(projectRoot, 'src/UI/preload-widget.js'),
+                nodeIntegration: false,
+                contextIsolation: true
+            }
+        });
+
+        widgetWindow.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+        widgetWindow.setAlwaysOnTop(true, 'floating');
+
+        try {
+            const primaryDisplay = screen.getPrimaryDisplay();
+            const { width, x, y } = primaryDisplay.workArea;
+            widgetWindow.setPosition(x + width - 150 - 40, y + 40);
+        } catch (_) {}
+
+        widgetWindow.loadFile(path.join(projectRoot, 'src/UI/widget.html'));
+        widgetWindow.on('closed', () => { widgetWindow = null; });
+        return widgetWindow;
+    }
+
+    function toggleMainWindow() {
+        if (!mainWindow) return;
+        if (mainWindow.isVisible()) {
+            mainWindow.hide();
+        } else {
+            mainWindow.show();
+        }
+    }
+
+    function toggleSpotlightWindow() {
+        if (spotlightWindow && spotlightWindow.isVisible()) {
+            spotlightWindow.hide();
+            return;
+        }
+        createSpotlightWindow().show();
+    }
+
+    function closeWidgetWindow() {
+        if (widgetWindow && !widgetWindow.isDestroyed()) {
+            widgetWindow.close();
+            widgetWindow = null;
+        }
+    }
+
+    function ensureWidgetWindow() {
+        if (!widgetWindow || widgetWindow.isDestroyed()) {
+            createWidgetWindow();
+        }
+    }
+
+    return {
+        createMainWindow,
+        createTray,
+        createSettingsWindow,
+        createSpotlightWindow,
+        createWidgetWindow,
+        toggleMainWindow,
+        toggleSpotlightWindow,
+        closeWidgetWindow,
+        ensureWidgetWindow,
+        getMainWindow: () => mainWindow,
+        getSettingsWindow: () => settingsWindow,
+        getSpotlightWindow: () => spotlightWindow,
+        getWidgetWindow: () => widgetWindow
+    };
+}
+
+module.exports = { createWindowManager };

package/src/UI/live2d_manager.js

@@ -0,0 +1,368 @@
+/**
+ * Live2DManager - Encapsulates Live2D model loading, fitting, and lip-sync logic.
+ */
+window.Live2DManager = {
+    app: null,
+    model: null,
+    resizeObserver: null,
+    lipSyncInterval: null,
+    expIndex: 0,
+    lastInteractionAt: 0,
+    expressionToastTimeout: null,
+    expressionParamIds: [
+        'Param54',
+        'Param55',
+        'Param68',
+        'Param76',
+        'Param91',
+        'Param93',
+        'Param94',
+        'Param96',
+        'ParamAngleY',
+        'ParamAngleZ',
+        'ParamEyeBallX',
+        'ParamEyeBallY',
+        'ParamMouthForm',
+        'ParamMouthOpenY'
+    ],
+    expressionNames: [
+        { id: null, label: 'Normal' },
+        { id: 'Apron', label: 'Apron' },
+        { id: 'Dazed', label: 'Dazed' },
+        { id: 'Photo', label: 'Photo' },
+        { id: 'Glasses', label: 'Glasses' },
+        { id: 'Pen', label: 'Writing' },
+        { id: 'Click', label: 'Blush' },
+        { id: 'CatFilter', label: 'Cat Ears' },
+        { id: 'DazedEyes', label: 'Dazed Eyes' }
+    ],
+
+    async loadModel(mountEl, statusEl, shellEl) {
+        this.statusEl = statusEl; // Store for later use
+        if (!mountEl) return;
+        if (statusEl) {
+            statusEl.classList.remove('is-error');
+            statusEl.innerHTML = `
+                <div class="loader-dots">
+                    <span></span><span></span><span></span>
+                </div>
+                <div style="font-size: 0.7rem; opacity: 0.8; letter-spacing: 0.05em;">SYNCHRONIZING MINT...</div>
+            `;
+        }
+        if (!window.PIXI || !window.PIXI.live2d) {
+            const message = 'Live2D runtime is not available.';
+            console.error(message);
+            if (statusEl) {
+                statusEl.classList.add('is-error');
+                statusEl.textContent = message;
+            }
+            return;
+        }
+
+        try {
+            window.PIXI.live2d.Live2DModel.registerTicker(window.PIXI.Ticker);
+
+            this.app = new window.PIXI.Application({
+                autoDensity: true,
+                antialias: true,
+                backgroundAlpha: 0,
+                resizeTo: mountEl,
+                resolution: window.devicePixelRatio || 1
+            });
+
+            mountEl.prepend(this.app.view);
+
+            const modelUrl = new URL('../../models/Shiroko_Model/Shiroko/Shiroko_Core/%E9%9D%A2%E9%A5%BC0.model3.json', window.location.href).href;
+            this.model = await window.PIXI.live2d.Live2DModel.from(modelUrl, {
+                autoInteract: true
+            });
+            this.expressionToastEl = document.getElementById('expression-toast');
+
+            this.model.anchor.set(0.5, 0.5);
+            this.app.stage.addChild(this.model);
+
+            // -- Interaction Setup --
+            this.model.interactive = true;
+            this.model.buttonMode = true;
+
+            // Tap Interaction. This model does not define Cubism HitAreas, so use
+            // normalized model coordinates to provide stable region reactions.
+            this.model.on('pointertap', (e) => this.handleModelTap(e));
+            this.model.on('hit', (hitAreaNames) => {
+                console.log(`[Live2D] Runtime hit detected: ${hitAreaNames}`);
+            });
+
+            const fitModel = () => {
+                if (!this.model || !mountEl) return;
+                const mountWidth = mountEl.clientWidth || 460;
+                const mountHeight = mountEl.clientHeight || 620;
+                this.app.renderer.resize(mountWidth, mountHeight);
+
+                const internal = this.model.internalModel || {};
+                const modelWidth = internal.width || internal.originalWidth || this.model.width || 1;
+                const modelHeight = internal.height || internal.originalHeight || this.model.height || 1;
+                const widthScale = mountWidth / Math.max(modelWidth, 1);
+                const heightScale = mountHeight / Math.max(modelHeight, 1);
+                
+                // Reduced zoom to 2.0 as requested
+                const scale = Math.min(widthScale, heightScale) * 1.8;
+
+                this.model.scale.set(scale);
+                // Adjusted Y offset to 1.0 as requested
+                this.model.position.set(mountWidth / 2, mountHeight / 2 + mountHeight * 0.6);
+            };
+
+            requestAnimationFrame(() => {
+                fitModel();
+                requestAnimationFrame(fitModel);
+            });
+            this.resizeObserver = new ResizeObserver(fitModel);
+            this.resizeObserver.observe(mountEl);
+
+            shellEl?.classList.add('is-live2d-ready');
+            if (statusEl) statusEl.textContent = '';
+            this.model.motion('Idle', 0).catch(() => {});
+        } catch (error) {
+            console.error('Failed to load Live2D model:', error);
+            shellEl?.classList.remove('is-live2d-ready');
+            if (statusEl) {
+                statusEl.classList.add('is-error');
+                statusEl.textContent = `Live2D failed: ${error && error.message ? error.message : String(error)}`;
+            }
+        }
+    },
+
+    showStatus(text, duration = 2000) {
+        if (!this.statusEl) return;
+        this.statusEl.textContent = text;
+        this.statusEl.style.opacity = '1';
+        
+        if (this.statusTimeout) clearTimeout(this.statusTimeout);
+        this.statusTimeout = setTimeout(() => {
+            this.statusEl.style.opacity = '0';
+            setTimeout(() => {
+                if (this.statusEl.style.opacity === '0') this.statusEl.textContent = '';
+            }, 500);
+        }, duration);
+    },
+
+    handleModelTap(event) {
+        if (!this.model) return;
+
+        const now = Date.now();
+        if (now - this.lastInteractionAt < 3000) return;
+
+        const region = this.getInteractionRegion(event);
+        if (!region) return;
+        this.lastInteractionAt = now;
+        const expressionId = region.expression || 'Click';
+
+        console.log(`[Live2D] Interaction: ${region.id}`, region);
+        this.applyExpression(expressionId);
+        this.showStatus(region.label, 2500);
+
+        window.dispatchEvent(new CustomEvent('live2d-model-interaction', {
+            detail: {
+                region: region.id,
+                label: region.label,
+                prompt: region.prompt
+            }
+        }));
+
+        setTimeout(() => {
+            const currentIdx = this.expIndex === 0 ? 0 : this.expIndex;
+            const prevExp = this.expressionNames[currentIdx]?.id;
+            this.applyExpression(prevExp);
+        }, 2000);
+    },
+
+    getInteractionRegion(event) {
+        try {
+            const point = this.getPointerViewportPoint(event);
+            if (!point) return null;
+            const { x, y } = point;
+
+            if (this.isPointInZone(x, y, 0.37, 0.395, 0.25, 0.13)) {
+                return {
+                    id: 'face',
+                    label: 'Cat Ears',
+                    expression: 'CatFilter',
+                    prompt: 'The user poked Mint model on the cheek. Reply briefly, shyly or with a light tease. Use the same language as the user’s recent conversation; do not switch to Thai unless the user has been speaking Thai.'
+                };
+            }
+
+            if (this.isPointInZone(x, y, 0.35, 0.30, 0.29, 0.09)) {
+                return {
+                    id: 'head',
+                    label: 'Head Pat',
+                    expression: 'Dazed',
+                    prompt: 'The user patted Mint model on the head. Reply briefly in a cute, slightly shy way. Use the same language as the user’s recent conversation; do not switch to Thai unless the user has been speaking Thai.'
+                };
+            }
+
+            const isLeftHand = this.isPointInZone(x, y, 0.17, 0.65, 0.19, 0.17);
+            const isRightHand = this.isPointInZone(x, y, 0.70, 0.67, 0.17, 0.17);
+            if (isLeftHand || isRightHand) {
+                return {
+                    id: isLeftHand ? 'left-hand' : 'right-hand',
+                    label: 'Hand Tap',
+                    expression: 'Pen',
+                    prompt: 'The user tapped Mint model’s hand. Reply briefly as if ready to help or take a request. Use the same language as the user’s recent conversation; do not switch to Thai unless the user has been speaking Thai.'
+                };
+            }
+
+            if (this.isPointInZone(x, y, 0.31, 0.76, 0.38, 0.24)) {
+                return {
+                    id: 'lower-body',
+                    label: 'Careful',
+                    expression: 'Photo',
+                    prompt: 'The user touched the lower body area of Mint model. Reply briefly in a shy, playful way, similar to “hehe~ what are you playing at, that makes me blush,” then gently invite the user back to chatting or work. Use the same language as the user’s recent conversation; do not switch to Thai unless the user has been speaking Thai.'
+                };
+            }
+
+            if (this.isPointInZone(x, y, 0.36, 0.55, 0.29, 0.15)) {
+                return {
+                    id: 'body',
+                    label: 'Shoulder Tap',
+                    expression: 'Click',
+                    prompt: 'The user tapped Mint model’s body or shoulder. Reply briefly as if turning toward the user and asking what they need help with. Use the same language as the user’s recent conversation; do not switch to Thai unless the user has been speaking Thai.'
+                };
+            }
+
+            return null;
+        } catch (error) {
+            console.error('[Live2D] Failed to resolve interaction region:', error);
+            return null;
+        }
+    },
+
+    getPointerViewportPoint(event) {
+        const originalEvent = event?.data?.originalEvent;
+        const rect = this.app?.view?.getBoundingClientRect?.();
+        if (originalEvent && rect) {
+            return {
+                x: (originalEvent.clientX - rect.left) / Math.max(rect.width, 1),
+                y: (originalEvent.clientY - rect.top) / Math.max(rect.height, 1)
+            };
+        }
+
+        const globalPoint = event?.data?.global;
+        const screen = this.app?.screen;
+        if (!globalPoint || !screen) return null;
+        return {
+            x: globalPoint.x / Math.max(screen.width, 1),
+            y: globalPoint.y / Math.max(screen.height, 1)
+        };
+    },
+
+    isPointInZone(x, y, left, top, width, height) {
+        return x >= left && x <= left + width && y >= top && y <= top + height;
+    },
+
+    cycleExpression() {
+        if (!this.model) return;
+        this.expIndex = (this.expIndex + 1) % this.expressionNames.length;
+        const nextExp = this.expressionNames[this.expIndex];
+        
+        console.log(`[Live2D] Triggering expression: ${nextExp.id} (${nextExp.label})`);
+        this.applyExpression(nextExp.id);
+        
+        this.showStatus(nextExp.label);
+        this.showExpressionToast(`Expression: ${nextExp.label}`);
+    },
+
+    showExpressionToast(text, duration = 1600) {
+        const toast = this.expressionToastEl || document.getElementById('expression-toast');
+        if (!toast) return;
+
+        this.expressionToastEl = toast;
+        toast.textContent = text;
+        toast.classList.add('is-visible');
+
+        if (this.expressionToastTimeout) clearTimeout(this.expressionToastTimeout);
+        this.expressionToastTimeout = setTimeout(() => {
+            toast.classList.remove('is-visible');
+        }, duration);
+    },
+
+    applyExpression(expressionId) {
+        if (!this.model) return;
+
+        this.resetExpressionParams();
+        if (!expressionId) {
+            this.clearExpressionState();
+            return;
+        }
+
+        try {
+            this.model.expression(expressionId);
+        } catch (error) {
+            console.error(`[Live2D] Failed to apply expression: ${expressionId}`, error);
+        }
+    },
+
+    resetExpressionParams() {
+        const core = this.model?.internalModel?.coreModel;
+        if (!core) return;
+
+        this.expressionParamIds.forEach(id => {
+            try { core.setParameterValueById(id, 0); } catch (_) {}
+        });
+    },
+
+    clearExpressionState() {
+        const expressionManager =
+            this.model?.internalModel?.motionManager?.expressionManager ||
+            this.model?.internalModel?.expressionManager;
+
+        try {
+            if (expressionManager?.defaultExpression) {
+                expressionManager.currentExpression = expressionManager.defaultExpression;
+                expressionManager.reserveExpressionIndex = -1;
+                expressionManager.resetExpression();
+            } else {
+                this.model.expression(null);
+            }
+        } catch (error) {
+            console.error('[Live2D] Failed to clear expression state:', error);
+        }
+
+        this.resetExpressionParams();
+        requestAnimationFrame(() => this.resetExpressionParams());
+    },
+
+    startLipSync() {
+        if (!this.model || this.lipSyncInterval) return;
+        
+        this.model.motion('Speak', 0).catch(() => {});
+
+        this.lipSyncInterval = setInterval(() => {
+            if (!this.model) return;
+            const value = Math.random() * 0.8;
+            if (this.model.internalModel && this.model.internalModel.coreModel) {
+                const core = this.model.internalModel.coreModel;
+                const mouthIds = ['ParamMouthOpenY', 'ParamMouthOpen', 'PARAM_MOUTH_OPEN_Y'];
+                mouthIds.forEach(id => {
+                    try { core.setParameterValueById(id, value); } catch(e) {}
+                });
+            }
+        }, 80);
+    },
+
+    stopLipSync() {
+        if (this.lipSyncInterval) {
+            clearInterval(this.lipSyncInterval);
+            this.lipSyncInterval = null;
+        }
+        if (this.model) {
+            if (this.model.internalModel && this.model.internalModel.coreModel) {
+                const core = this.model.internalModel.coreModel;
+                const mouthIds = ['ParamMouthOpenY', 'ParamMouthOpen', 'PARAM_MOUTH_OPEN_Y'];
+                mouthIds.forEach(id => {
+                    try { core.setParameterValueById(id, 0); } catch(e) {}
+                });
+            }
+            this.model.motion('Idle', 0).catch(() => {});
+        }
+    }
+};