fix motion out-of-bound bug

Author: ylxmf2005

src/renderer/WebSDK/Framework/src/motion/cubismmotion.ts

@@ -14,6 +14,7 @@ import { csmVector } from '../type/csmvector';
 import {
   CSM_ASSERT,
   CubismLogDebug,
+  CubismLogError,
   CubismLogWarning
 } from '../utils/cubismdebug';
 import { ACubismMotion, FinishedMotionCallback } from './acubismmotion';
@@ -254,14 +255,26 @@ export class CubismMotion extends ACubismMotion {
   ): CubismMotion {
     const ret = new CubismMotion();
 
-    ret.parse(buffer, size);
-    ret._sourceFrameRate = ret._motionData.fps;
-    ret._loopDurationSeconds = ret._motionData.duration;
-    ret._onFinishedMotion = onFinishedMotionHandler;
+    try {
+      ret.parse(buffer, size);
 
-    // NOTE: Editorではループありのモーション書き出しは非対応
-    // ret->_loop = (ret->_motionData->Loop > 0);
-    return ret;
+      // Check if motion data was successfully parsed
+      if (!ret._motionData) {
+        CubismLogError('Failed to parse motion data - motion data is null');
+        return null;
+      }
+
+      ret._sourceFrameRate = ret._motionData.fps;
+      ret._loopDurationSeconds = ret._motionData.duration;
+      ret._onFinishedMotion = onFinishedMotionHandler;
+
+      // NOTE: Editorではループありのモーション書き出しは非対応
+      // ret->_loop = (ret->_motionData->Loop > 0);
+      return ret;
+    } catch (error) {
+      CubismLogError(`Failed to create motion: ${error}`);
+      return null;
+    }
   }
 
   /**
@@ -767,13 +780,51 @@ export class CubismMotion extends ACubismMotion {
       CubismMotionCurve,
       true
     );
+
+    // Pre-calculate actual required sizes by analyzing the motion data
+    let totalRequiredSegments = 0;
+    let totalRequiredPoints = 0;
+
+    for (let curveCount = 0; curveCount < this._motionData.curveCount; ++curveCount) {
+      const segmentCount = json.getMotionCurveSegmentCount(curveCount);
+
+      for (let segmentPos = 0; segmentPos < segmentCount; ) {
+        totalRequiredSegments++;
+
+        if (segmentPos == 0) {
+          totalRequiredPoints += 1; // First point
+          segmentPos += 2;
+        } else {
+          const segmentType: CubismMotionSegmentType = json.getMotionCurveSegment(curveCount, segmentPos);
+
+          switch (segmentType) {
+            case CubismMotionSegmentType.CubismMotionSegmentType_Linear:
+            case CubismMotionSegmentType.CubismMotionSegmentType_Stepped:
+            case CubismMotionSegmentType.CubismMotionSegmentType_InverseStepped:
+              totalRequiredPoints += 1;
+              segmentPos += 3;
+              break;
+            case CubismMotionSegmentType.CubismMotionSegmentType_Bezier:
+              totalRequiredPoints += 3;
+              segmentPos += 7;
+              break;
+            default:
+              segmentPos += 3; // Default fallback
+              totalRequiredPoints += 1;
+              break;
+          }
+        }
+      }
+    }
+
+    // Use the calculated sizes (with a small buffer for safety)
     this._motionData.segments.updateSize(
-      json.getMotionTotalSegmentCount(),
+      totalRequiredSegments,
       CubismMotionSegment,
       true
     );
     this._motionData.points.updateSize(
-      json.getMotionTotalPointCount(),
+      totalRequiredPoints,
       CubismMotionPoint,
       true
     );
@@ -859,6 +910,13 @@ export class CubismMotion extends ACubismMotion {
             this._motionData.segments.at(totalSegmentCount).evaluate =
               linearEvaluate;
 
+            // Check if we have enough points in the array, expand if needed
+            if (totalPointCount >= this._motionData.points.getSize()) {
+              const newSize = Math.max(totalPointCount + 1, this._motionData.points.getSize() * 2);
+              CubismLogWarning(`Expanding motion points array from ${this._motionData.points.getSize()} to ${newSize} for Linear segment`);
+              this._motionData.points.updateSize(newSize, CubismMotionPoint, true);
+            }
+
             this._motionData.points.at(totalPointCount).time =
               json.getMotionCurveSegment(curveCount, segmentPosition + 1);
             this._motionData.points.at(totalPointCount).value =

src/renderer/src/hooks/canvas/use-live2d-model.ts

@@ -406,6 +406,129 @@ export const useLive2DModel = ({
     }
   }, [isPet, electronApi]);
 
+  // Expose motion debugging functions to window for console testing
+  useEffect(() => {
+    const playMotion = (motionGroup: string, motionIndex: number = 0, priority: number = 3) => {
+      const adapter = (window as any).getLAppAdapter?.();
+      if (!adapter) {
+        console.error('Live2D adapter not available');
+        return false;
+      }
+
+      const model = adapter.getModel();
+      if (!model) {
+        console.error('Live2D model not available');
+        return false;
+      }
+
+      try {
+        console.log(`Playing motion: group="${motionGroup}", index=${motionIndex}, priority=${priority}`);
+        const result = model.startMotion(motionGroup, motionIndex, priority);
+        console.log('Motion start result:', result);
+        return result;
+      } catch (error) {
+        console.error('Error playing motion:', error);
+        return false;
+      }
+    };
+
+    const playRandomMotion = (motionGroup: string, priority: number = 3) => {
+      const adapter = (window as any).getLAppAdapter?.();
+      if (!adapter) {
+        console.error('Live2D adapter not available');
+        return false;
+      }
+
+      const model = adapter.getModel();
+      if (!model) {
+        console.error('Live2D model not available');
+        return false;
+      }
+
+      try {
+        console.log(`Playing random motion from group: "${motionGroup}", priority=${priority}`);
+        const result = model.startRandomMotion(motionGroup, priority);
+        console.log('Random motion start result:', result);
+        return result;
+      } catch (error) {
+        console.error('Error playing random motion:', error);
+        return false;
+      }
+    };
+
+    const getMotionInfo = () => {
+      const adapter = (window as any).getLAppAdapter?.();
+      if (!adapter) {
+        console.error('Live2D adapter not available');
+        return null;
+      }
+
+      const model = adapter.getModel();
+      if (!model) {
+        console.error('Live2D model not available');
+        return null;
+      }
+
+      try {
+        const motionGroups = [];
+        const setting = model._modelSetting;
+        if (setting) {
+          // Get all motion groups
+          const groups = setting._json?.FileReferences?.Motions;
+          if (groups) {
+            for (const groupName in groups) {
+              const motions = groups[groupName];
+              motionGroups.push({
+                name: groupName,
+                count: motions.length,
+                motions: motions.map((motion: any, index: number) => ({
+                  index,
+                  file: motion.File
+                }))
+              });
+            }
+          }
+        }
+        
+        console.log('Available motion groups:', motionGroups);
+        return motionGroups;
+      } catch (error) {
+        console.error('Error getting motion info:', error);
+        return null;
+      }
+    };
+
+    // Expose to window for console access
+    (window as any).Live2DDebug = {
+      playMotion,
+      playRandomMotion,
+      getMotionInfo,
+      // Helper functions
+      help: () => {
+        console.log(`
+Live2D Motion Debug Functions:
+- Live2DDebug.getMotionInfo() - Get all available motion groups and their motions
+- Live2DDebug.playMotion(group, index, priority) - Play specific motion
+- Live2DDebug.playRandomMotion(group, priority) - Play random motion from group  
+- Live2DDebug.help() - Show this help
+
+Example usage:
+Live2DDebug.getMotionInfo()  // See available motions
+Live2DDebug.playMotion("", 0)  // Play first motion from default group
+Live2DDebug.playRandomMotion("")  // Play random motion from default group
+        `);
+      }
+    };
+
+    console.log('Live2D Debug functions exposed to window.Live2DDebug');
+    console.log('Type Live2DDebug.help() for usage information');
+
+    // Cleanup function
+    return () => {
+      delete (window as any).Live2DDebug;
+    };
+  }, []);
+
   return {
     position,
     isDragging,