@pheem49/mint 1.5.1 → 1.5.3

package/src/System/window_manager.js

@@ -9,12 +9,19 @@ function createWindowManager(projectRoot) {
     let tray = null;
 
     function createMainWindow() {
+        const iconPath = path.join(projectRoot, 'assets', 'icon.png');
+        const { width: screenWidth, height: screenHeight } = screen.getPrimaryDisplay().workAreaSize;
+        const windowWidth = Math.min(1360, Math.max(1180, screenWidth - 40));
+        const windowHeight = Math.min(920, Math.max(860, screenHeight - 40));
+
         mainWindow = new BrowserWindow({
-            width: 1180,
-            height: 860,
+            width: windowWidth,
+            height: windowHeight,
             minWidth: 900,
             minHeight: 680,
-            icon: path.join(projectRoot, 'assets', 'icon.png'),
+            x: Math.floor((screenWidth - windowWidth) / 2),
+            y: Math.floor((screenHeight - windowHeight) / 2),
+            icon: nativeImage.createFromPath(iconPath),
             webPreferences: {
                 preload: path.join(projectRoot, 'preload.js'),
                 nodeIntegration: false,
@@ -75,12 +82,13 @@ function createWindowManager(projectRoot) {
             return settingsWindow;
         }
 
+        const iconPath = path.join(projectRoot, 'assets', 'icon.png');
         settingsWindow = new BrowserWindow({
-            width: 720,
-            height: 620,
-            minWidth: 640,
-            minHeight: 560,
-            icon: path.join(projectRoot, 'assets', 'icon.png'),
+            width: 1020,
+            height: 720,
+            minWidth: 860,
+            minHeight: 620,
+            icon: nativeImage.createFromPath(iconPath),
             webPreferences: {
                 preload: path.join(projectRoot, 'preload-settings.js'),
                 nodeIntegration: false,

package/src/UI/live2d_manager.js

@@ -7,6 +7,36 @@ window.Live2DManager = {
     resizeObserver: null,
     lipSyncInterval: null,
     expIndex: 0,
+    interactionEnabled: true,
+    interactionStorageKey: 'mint-model-interaction-enabled',
+    accessoryStorageKey: 'mint-live2d-accessories',
+    activeAccessories: {},
+    accessoryOrder: ['glasses', 'pen', 'cat'],
+    accessoryParams: {
+        glasses: { paramId: 'Param96', label: 'Glasses' },
+        pen: { paramId: 'Param68', label: 'Pen' },
+        cat: { paramId: 'Param54', label: 'Cat Filter' }
+    },
+    pointerTrackingEnabled: true,
+    zoomMultiplier: 1,
+    interactionZoneOrigin: { x: 0.5, y: 0.58 },
+    fitModelToMount: null,
+    pointerTrackingFrame: null,
+    pointerTracking: {
+        targetX: 0,
+        targetY: 0,
+        currentX: 0,
+        currentY: 0,
+        lastMoveAt: 0
+    },
+    pointerTrackingConfig: {
+        focusX: 0.35,
+        focusY: 0.35,
+        rangeX: 0.35,
+        rangeY: 0.35,
+        smoothing: 0.18
+    },
+    baseModelPosition: null,
     lastInteractionAt: 0,
     expressionToastTimeout: null,
     expressionParamIds: [
@@ -39,6 +69,8 @@ window.Live2DManager = {
 
     async loadModel(mountEl, statusEl, shellEl) {
         this.statusEl = statusEl; // Store for later use
+        this.interactionEnabled = this.getSavedInteractionEnabled();
+        this.activeAccessories = this.getSavedAccessories();
         if (!mountEl) return;
         if (statusEl) {
             statusEl.classList.remove('is-error');
@@ -74,7 +106,7 @@ window.Live2DManager = {
 
             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
+                autoInteract: false
             });
             this.expressionToastEl = document.getElementById('expression-toast');
 
@@ -82,8 +114,9 @@ window.Live2DManager = {
             this.app.stage.addChild(this.model);
 
             // -- Interaction Setup --
-            this.model.interactive = true;
-            this.model.buttonMode = true;
+            this.setInteractionEnabled(this.interactionEnabled);
+            this.setupPointerTracking(mountEl);
+            this.applyAccessories();
 
             // Tap Interaction. This model does not define Cubism HitAreas, so use
             // normalized model coordinates to provide stable region reactions.
@@ -105,12 +138,17 @@ window.Live2DManager = {
                 const heightScale = mountHeight / Math.max(modelHeight, 1);
                 
                 // Reduced zoom to 2.0 as requested
-                const scale = Math.min(widthScale, heightScale) * 1.8;
+                const scale = Math.min(widthScale, heightScale) * 1.85 * this.zoomMultiplier;
 
                 this.model.scale.set(scale);
                 // Adjusted Y offset to 1.0 as requested
-                this.model.position.set(mountWidth / 2, mountHeight / 2 + mountHeight * 0.6);
+                this.baseModelPosition = {
+                    x: mountWidth / 2,
+                    y: mountHeight / 2 + mountHeight * 0.55
+                };
+                this.applyModelFollowOffset();
             };
+            this.fitModelToMount = fitModel;
 
             requestAnimationFrame(() => {
                 fitModel();
@@ -147,7 +185,7 @@ window.Live2DManager = {
     },
 
     handleModelTap(event) {
-        if (!this.model) return;
+        if (!this.model || !this.interactionEnabled) return;
 
         const now = Date.now();
         if (now - this.lastInteractionAt < 3000) return;
@@ -180,9 +218,9 @@ window.Live2DManager = {
         try {
             const point = this.getPointerViewportPoint(event);
             if (!point) return null;
-            const { x, y } = point;
+            const { x, y } = this.toInteractionZonePoint(point);
 
-            if (this.isPointInZone(x, y, 0.37, 0.395, 0.25, 0.13)) {
+            if (this.isPointInZone(x, y, 0.36, 0.375, 0.28, 0.12)) {
                 return {
                     id: 'face',
                     label: 'Cat Ears',
@@ -191,7 +229,7 @@ window.Live2DManager = {
                 };
             }
 
-            if (this.isPointInZone(x, y, 0.35, 0.30, 0.29, 0.09)) {
+            if (this.isPointInZone(x, y, 0.34, 0.205, 0.32, 0.155)) {
                 return {
                     id: 'head',
                     label: 'Head Pat',
@@ -200,8 +238,8 @@ window.Live2DManager = {
                 };
             }
 
-            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);
+            const isLeftHand = this.isPointInZone(x, y, 0.14, 0.70, 0.22, 0.16);
+            const isRightHand = this.isPointInZone(x, y, 0.65, 0.69, 0.23, 0.17);
             if (isLeftHand || isRightHand) {
                 return {
                     id: isLeftHand ? 'left-hand' : 'right-hand',
@@ -211,7 +249,7 @@ window.Live2DManager = {
                 };
             }
 
-            if (this.isPointInZone(x, y, 0.31, 0.76, 0.38, 0.24)) {
+            if (this.isPointInZone(x, y, 0.34, 0.74, 0.30, 0.24)) {
                 return {
                     id: 'lower-body',
                     label: 'Careful',
@@ -220,7 +258,7 @@ window.Live2DManager = {
                 };
             }
 
-            if (this.isPointInZone(x, y, 0.36, 0.55, 0.29, 0.15)) {
+            if (this.isPointInZone(x, y, 0.36, 0.53, 0.29, 0.145)) {
                 return {
                     id: 'body',
                     label: 'Shoulder Tap',
@@ -259,6 +297,17 @@ window.Live2DManager = {
         return x >= left && x <= left + width && y >= top && y <= top + height;
     },
 
+    toInteractionZonePoint(point) {
+        const scale = this.zoomMultiplier || 1;
+        if (Math.abs(scale - 1) < 0.001) return point;
+
+        const origin = this.interactionZoneOrigin;
+        return {
+            x: origin.x + (point.x - origin.x) / scale,
+            y: origin.y + (point.y - origin.y) / scale
+        };
+    },
+
     cycleExpression() {
         if (!this.model) return;
         this.expIndex = (this.expIndex + 1) % this.expressionNames.length;
@@ -271,6 +320,131 @@ window.Live2DManager = {
         this.showExpressionToast(`Expression: ${nextExp.label}`);
     },
 
+    setInteractionEnabled(isEnabled, persist = false) {
+        this.interactionEnabled = Boolean(isEnabled);
+        if (persist) {
+            this.saveInteractionEnabled(this.interactionEnabled);
+        }
+        if (!this.model) return;
+
+        this.model.interactive = this.interactionEnabled;
+        this.model.buttonMode = this.interactionEnabled;
+    },
+
+    setPointerTrackingEnabled(isEnabled) {
+        this.pointerTrackingEnabled = Boolean(isEnabled);
+        if (this.pointerTrackingEnabled) return;
+
+        this.resetPointerTrackingTarget();
+        this.pointerTracking.currentX = 0;
+        this.pointerTracking.currentY = 0;
+        this.applyModelFollowOffset();
+    },
+
+    setZoomMultiplier(multiplier) {
+        const value = Number(multiplier);
+        this.zoomMultiplier = this.clamp(Number.isFinite(value) ? value : 1, 0.78, 1.28);
+        document.documentElement.style.setProperty('--model-zone-scale', String(this.zoomMultiplier));
+        if (typeof this.fitModelToMount === 'function') {
+            this.fitModelToMount();
+        }
+    },
+
+    getSavedInteractionEnabled() {
+        try {
+            return localStorage.getItem(this.interactionStorageKey) !== 'false';
+        } catch (_) {
+            return true;
+        }
+    },
+
+    saveInteractionEnabled(isEnabled) {
+        try {
+            localStorage.setItem(this.interactionStorageKey, String(Boolean(isEnabled)));
+        } catch (_) {}
+    },
+
+    setupPointerTracking(mountEl) {
+        if (!mountEl) return;
+
+        window.addEventListener('mousemove', (event) => this.updatePointerTrackingTarget(event, mountEl));
+
+        if (!this.pointerTrackingFrame) {
+            this.pointerTrackingFrame = () => this.updatePointerTracking();
+            this.app?.ticker?.add(this.pointerTrackingFrame);
+        }
+    },
+
+    updatePointerTrackingTarget(event, mountEl) {
+        if (!this.pointerTrackingEnabled || !mountEl) return;
+
+        const rect = {
+            left: 0,
+            top: 0,
+            width: window.innerWidth || mountEl.getBoundingClientRect().width,
+            height: window.innerHeight || mountEl.getBoundingClientRect().height
+        };
+        const config = this.pointerTrackingConfig;
+        const centerX = rect.left + rect.width * config.focusX;
+        const centerY = rect.top + rect.height * config.focusY;
+        const rangeX = Math.max(rect.width * config.rangeX, 1);
+        const rangeY = Math.max(rect.height * config.rangeY, 1);
+
+        this.pointerTracking.targetX = this.clamp((event.clientX - centerX) / rangeX, -1, 1);
+        this.pointerTracking.targetY = this.clamp((event.clientY - centerY) / rangeY, -1, 1);
+        this.pointerTracking.lastMoveAt = performance.now();
+    },
+
+    resetPointerTrackingTarget() {
+        this.pointerTracking.targetX = 0;
+        this.pointerTracking.targetY = 0;
+    },
+
+    updatePointerTracking() {
+        if (!this.model || !this.pointerTrackingEnabled) return;
+
+        const tracking = this.pointerTracking;
+        const smoothing = this.pointerTrackingConfig.smoothing;
+        tracking.currentX += (tracking.targetX - tracking.currentX) * smoothing;
+        tracking.currentY += (tracking.targetY - tracking.currentY) * smoothing;
+
+        const x = tracking.currentX;
+        const y = tracking.currentY;
+        const core = this.model?.internalModel?.coreModel;
+        if (!core) return;
+
+        this.setLive2DParam(core, 'ParamAngleX', x * 18);
+        this.setLive2DParam(core, 'ParamAngleY', -y * 14);
+        this.setLive2DParam(core, 'ParamAngleZ', -x * 5);
+        this.setLive2DParam(core, 'ParamEyeBallX', x * 1.45);
+        this.setLive2DParam(core, 'ParamEyeBallY', -y * 1.35);
+        this.setLive2DParam(core, 'Param49', x * 7);
+        this.setLive2DParam(core, 'Param51', -y * 5);
+        this.setLive2DParam(core, 'Param50', -x * 3);
+        this.applyModelFollowOffset();
+    },
+
+    applyModelFollowOffset() {
+        if (!this.model || !this.baseModelPosition) return;
+
+        const x = this.pointerTracking.currentX || 0;
+        const y = this.pointerTracking.currentY || 0;
+        this.model.position.set(
+            this.baseModelPosition.x + x * 22,
+            this.baseModelPosition.y + y * 16
+        );
+    },
+
+    setLive2DParam(core, id, value) {
+        try {
+            core.setParameterValueById(id, value);
+        } catch (_) {}
+    },
+
+    clamp(value, min, max) {
+        return Math.max(min, Math.min(max, value));
+    },
+
     showExpressionToast(text, duration = 1600) {
         const toast = this.expressionToastEl || document.getElementById('expression-toast');
         if (!toast) return;
@@ -296,6 +470,7 @@ window.Live2DManager = {
 
         try {
             this.model.expression(expressionId);
+            requestAnimationFrame(() => this.applyAccessories());
         } catch (error) {
             console.error(`[Live2D] Failed to apply expression: ${expressionId}`, error);
         }
@@ -328,7 +503,64 @@ window.Live2DManager = {
         }
 
         this.resetExpressionParams();
-        requestAnimationFrame(() => this.resetExpressionParams());
+        requestAnimationFrame(() => {
+            this.resetExpressionParams();
+            this.applyAccessories();
+        });
+    },
+
+    setAccessory(accessoryId, isEnabled, persist = false) {
+        if (!this.accessoryParams[accessoryId]) return;
+
+        this.activeAccessories[accessoryId] = Boolean(isEnabled);
+        if (persist) {
+            this.saveAccessories();
+        }
+        this.applyAccessory(accessoryId);
+    },
+
+    setExclusiveAccessory(accessoryId, persist = false) {
+        const nextAccessoryId = this.accessoryParams[accessoryId] ? accessoryId : null;
+        Object.keys(this.accessoryParams).forEach(id => {
+            this.activeAccessories[id] = id === nextAccessoryId;
+        });
+        if (persist) {
+            this.saveAccessories();
+        }
+        this.applyAccessories();
+        return nextAccessoryId;
+    },
+
+    getActiveAccessoryId() {
+        return this.accessoryOrder.find(id => this.activeAccessories[id]) || null;
+    },
+
+    applyAccessories() {
+        Object.keys(this.accessoryParams).forEach(accessoryId => {
+            this.applyAccessory(accessoryId);
+        });
+    },
+
+    applyAccessory(accessoryId) {
+        const accessory = this.accessoryParams[accessoryId];
+        const core = this.model?.internalModel?.coreModel;
+        if (!accessory || !core) return;
+
+        this.setLive2DParam(core, accessory.paramId, this.activeAccessories[accessoryId] ? 1 : 0);
+    },
+
+    getSavedAccessories() {
+        try {
+            return JSON.parse(localStorage.getItem(this.accessoryStorageKey) || '{}') || {};
+        } catch (_) {
+            return {};
+        }
+    },
+
+    saveAccessories() {
+        try {
+            localStorage.setItem(this.accessoryStorageKey, JSON.stringify(this.activeAccessories));
+        } catch (_) {}
     },
 
     startLipSync() {