sa2kit 1.6.0 → 1.6.2

package/dist/mmd/index.mjs

@@ -1,7 +1,7 @@
 import '../chunk-BJTO5JO5.mjs';
 import React6, { forwardRef, useRef, useEffect, useImperativeHandle, useState, useCallback } from 'react';
 import * as THREE from 'three';
-import { OrbitControls, MMDLoader, MMDAnimationHelper } from 'three-stdlib';
+import { UnrealBloomPass, OutlineEffect, EffectComposer, RenderPass, OrbitControls, MMDLoader, MMDAnimationHelper } from 'three-stdlib';
 import { SkipBack, Pause, Play, SkipForward, Camera, Repeat, Repeat1, Shuffle, ListMusic, Music, X, Grid3x3, Settings, Minimize, Maximize, Video, Check, User, Image } from 'lucide-react';
 import { createPortal } from 'react-dom';
 
@@ -138,8 +138,37 @@ async function waitForMaterialsReady(object, renderer, scene, camera) {
   for (let i = 0; i < 3; i++) {
     await new Promise((resolve) => {
       requestAnimationFrame(() => {
-        renderer.render(scene, camera);
-        console.log(`[MMDPlayerBase]   Warmup render ${i + 1}/3`);
+        try {
+          object.traverse((obj) => {
+            if (obj.isMesh) {
+              const mesh = obj;
+              const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+              const hasMorphAttributes = mesh.geometry.morphAttributes && Object.keys(mesh.geometry.morphAttributes).length > 0;
+              materials.forEach((m) => {
+                if (!hasMorphAttributes) {
+                  m.morphTargets = false;
+                  if (mesh.geometry.morphAttributes) {
+                    mesh.geometry.morphAttributes = {};
+                  }
+                  if (mesh.morphTargetInfluences) {
+                    mesh.morphTargetInfluences = [];
+                  }
+                  if (mesh.morphTargetDictionary) {
+                    mesh.morphTargetDictionary = {};
+                  }
+                  m.needsUpdate = true;
+                }
+              });
+              if (mesh.updateMorphTargets) {
+                mesh.updateMorphTargets();
+              }
+            }
+          });
+          renderer.render(scene, camera);
+          console.log(`[MMDPlayerBase]   Warmup render ${i + 1}/3`);
+        } catch (renderError) {
+          console.warn("[MMDPlayerBase] Warmup render failed (shader error?), skipping...", renderError);
+        }
         resolve();
       });
     });
@@ -167,10 +196,15 @@ var MMDPlayerBase = forwardRef((props, ref) => {
     className,
     style
   } = props;
+  const renderEffect = props.renderEffect || stage.renderEffect || "default";
+  const outlineOptions = { ...stage.outlineOptions, ...props.outlineOptions };
+  const bloomOptions = { ...stage.bloomOptions, ...props.bloomOptions };
   const containerRef = useRef(null);
   const sceneRef = useRef(null);
   const cameraRef = useRef(null);
   const rendererRef = useRef(null);
+  const outlineEffectRef = useRef(null);
+  const composerRef = useRef(null);
   const controlsRef = useRef(null);
   const helperRef = useRef(null);
   const axesHelperRef = useRef(null);
@@ -378,10 +412,28 @@ var MMDPlayerBase = forwardRef((props, ref) => {
         }
         container.appendChild(renderer.domElement);
         rendererRef.current = renderer;
+        const effect = new OutlineEffect(renderer, {
+          defaultThickness: outlineOptions.thickness ?? 3e-3,
+          defaultColor: new THREE.Color(outlineOptions.color ?? "#000000").toArray(),
+          defaultAlpha: 1,
+          defaultKeepAlive: true
+        });
+        outlineEffectRef.current = effect;
+        const composer = new EffectComposer(renderer);
+        const renderPass = new RenderPass(scene, camera);
+        composer.addPass(renderPass);
+        const bloomPass = new UnrealBloomPass(
+          new THREE.Vector2(width, height),
+          bloomOptions.strength ?? 1,
+          bloomOptions.radius ?? 0.4,
+          bloomOptions.threshold ?? 0.8
+        );
+        composer.addPass(bloomPass);
+        composerRef.current = composer;
         const ambientLight = new THREE.AmbientLight(16777215, stage.ambientLightIntensity ?? 0.5);
         scene.add(ambientLight);
         const dirLight = new THREE.DirectionalLight(16777215, stage.directionalLightIntensity ?? 0.8);
-        dirLight.position.set(10, 20, 10);
+        dirLight.position.set(0, 10, 0);
         if (stage.enableShadow !== false) {
           dirLight.castShadow = true;
           dirLight.shadow.mapSize.width = mobileOptimization.enabled ? 1024 : 2048;
@@ -416,6 +468,9 @@ var MMDPlayerBase = forwardRef((props, ref) => {
           cameraRef.current.aspect = w / h;
           cameraRef.current.updateProjectionMatrix();
           rendererRef.current.setSize(w, h);
+          if (composerRef.current) {
+            composerRef.current.setSize(w, h);
+          }
         };
         const resizeObserver = new ResizeObserver(onResize);
         resizeObserver.observe(container);
@@ -423,7 +478,11 @@ var MMDPlayerBase = forwardRef((props, ref) => {
         onResize();
         console.log("[MMDPlayerBase] Starting render loop (animation paused)");
         animate();
-        console.log("[MMDPlayerBase] Start loading resources...", resources);
+        console.log("[MMDPlayerBase] Start loading resources...", {
+          model: resources.modelPath,
+          stage: resources.stageModelPath,
+          motion: resources.motionPath
+        });
         const loader = new MMDLoader();
         const helper = new MMDAnimationHelper({
           afterglow: 2
@@ -596,51 +655,67 @@ var MMDPlayerBase = forwardRef((props, ref) => {
             (err) => console.error("Failed to load audio:", err)
           );
         }
-        let stageMesh = null;
-        if (resources.stageModelPath) {
+        const stagePaths = Array.isArray(resources.stageModelPath) ? resources.stageModelPath : resources.stageModelPath ? [resources.stageModelPath] : [];
+        for (const stagePath of stagePaths) {
           try {
-            stageMesh = await new Promise((resolve, reject) => {
+            console.log(`[MMDPlayerBase] Loading stage from: ${stagePath}`);
+            const stageMesh = await new Promise((resolve, reject) => {
               loader.load(
-                resources.stageModelPath,
+                stagePath,
                 (mesh2) => resolve(mesh2),
-                void 0,
+                (xhr) => {
+                  if (xhr.lengthComputable) {
+                    const percent = xhr.loaded / xhr.total * 100;
+                    if (Math.round(percent) % 20 === 0) console.log(`[MMDPlayerBase] Stage loading: ${percent.toFixed(1)}%`);
+                  }
+                },
                 (err) => reject(err)
               );
             });
             if (checkCancelled()) return;
-            console.log("[MMDPlayerBase] Stage model loaded:", stageMesh);
-            stageMesh.castShadow = true;
-            stageMesh.receiveShadow = true;
-            console.log("[MMDPlayerBase] Waiting for stage materials and textures...");
-            const tempStageScene = new THREE.Scene();
-            tempStageScene.add(stageMesh);
-            await waitForMaterialsReady(stageMesh, renderer, tempStageScene, camera);
-            tempStageScene.remove(stageMesh);
+            console.log(`[MMDPlayerBase] Stage model loaded: ${stagePath}`, stageMesh);
+            stageMesh.traverse((child) => {
+              if (child instanceof THREE.Mesh) {
+                child.castShadow = true;
+                child.receiveShadow = true;
+                const mesh2 = child;
+                const materials = Array.isArray(mesh2.material) ? mesh2.material : [mesh2.material];
+                materials.forEach((m, idx) => {
+                  if (m.morphTargets) {
+                    m.morphTargets = false;
+                    m.needsUpdate = true;
+                  }
+                });
+                if (mesh2.geometry.morphAttributes) {
+                  mesh2.geometry.morphAttributes = {};
+                }
+                if (mesh2.morphTargetInfluences) {
+                  mesh2.morphTargetInfluences = [];
+                }
+              }
+            });
+            try {
+              await waitForMaterialsReady(stageMesh, renderer, scene, camera);
+            } catch (e) {
+              console.warn(`[MMDPlayerBase] Warmup error for stage ${stagePath}:`, e);
+            }
             if (checkCancelled()) return;
-            console.log("[MMDPlayerBase] \u2705 Stage materials and textures loaded");
             scene.add(stageMesh);
-            console.log("[MMDPlayerBase] \u2705 Stage added to scene (fully loaded)");
-            if (resources.stageMotionPath && stageMesh) {
-              console.log("[MMDPlayerBase] Loading stage motion:", resources.stageMotionPath);
-              const anyLoader = loader;
-              const anyHelper = helper;
-              const anyStage = stageMesh;
-              anyLoader.loadAnimation(
-                resources.stageMotionPath,
-                anyStage,
-                (stageAnimation) => {
-                  if (checkCancelled()) return;
-                  anyHelper.add(anyStage, {
-                    animation: stageAnimation
-                  });
-                  console.log("[MMDPlayerBase] \u2705 Stage motion bound successfully");
-                },
-                void 0,
-                (err) => console.error("Failed to load stage motion:", err)
-              );
+            const stageBox = new THREE.Box3().setFromObject(stageMesh);
+            const stageSize = stageBox.getSize(new THREE.Vector3());
+            if (stageSize.length() < 1) {
+              stageMesh.scale.multiplyScalar(100);
+            } else if (stageSize.y < 5) {
+              stageMesh.scale.multiplyScalar(10);
+            }
+            console.log(`[MMDPlayerBase] \u2705 Stage added: ${stagePath}`);
+            if (resources.stageMotionPath) {
+              loader.loadAnimation(resources.stageMotionPath, stageMesh, (anim) => {
+                if (!checkCancelled()) helper.add(stageMesh, { animation: anim });
+              });
             }
           } catch (err) {
-            console.error("Failed to load stage:", err);
+            console.error(`Failed to load stage ${stagePath}:`, err);
           }
         }
         if (checkCancelled()) return;
@@ -1018,6 +1093,13 @@ ${errorMessage}
       }
       if (rendererRef.current) {
         try {
+          if (composerRef.current) {
+            composerRef.current.passes.forEach((pass) => {
+              if (pass.dispose) pass.dispose();
+            });
+            composerRef.current = null;
+          }
+          outlineEffectRef.current = null;
           const renderer = rendererRef.current;
           if (renderer.renderLists) {
             renderer.renderLists.dispose();
@@ -1084,6 +1166,17 @@ ${errorMessage}
       audioRef.current.setLoop(loop);
     }
   }, [loop]);
+  useEffect(() => {
+    if (outlineEffectRef.current) ;
+    if (composerRef.current) {
+      const bloomPass = composerRef.current.passes.find((p) => p instanceof UnrealBloomPass);
+      if (bloomPass) {
+        bloomPass.strength = bloomOptions.strength ?? 1;
+        bloomPass.radius = bloomOptions.radius ?? 0.4;
+        bloomPass.threshold = bloomOptions.threshold ?? 0.8;
+      }
+    }
+  }, [bloomOptions.strength, bloomOptions.radius, bloomOptions.threshold]);
   useEffect(() => {
     if (!isReadyRef.current) return;
     if (sceneRef.current) {
@@ -1132,7 +1225,15 @@ ${errorMessage}
           latestCallbacks.current.onEnded?.();
         }
       }
-      rendererRef.current.render(sceneRef.current, cameraRef.current);
+      const useOutline = renderEffect === "outline" || renderEffect === "outline+bloom";
+      const useBloom = renderEffect === "bloom" || renderEffect === "outline+bloom";
+      if (useBloom && composerRef.current) {
+        composerRef.current.render();
+      } else if (useOutline && outlineEffectRef.current) {
+        outlineEffectRef.current.render(sceneRef.current, cameraRef.current);
+      } else {
+        rendererRef.current.render(sceneRef.current, cameraRef.current);
+      }
     }
   };
   return /* @__PURE__ */ React6.createElement(
@@ -2827,6 +2928,8 @@ var MMDVisualNovel = forwardRef(
     const [pendingNodeIndex, setPendingNodeIndex] = useState(null);
     const [showChoices, setShowChoices] = useState(false);
     const [isCameraManual, setIsCameraManual] = useState(false);
+    const [variables, setVariables] = useState({});
+    const [activeEffect, setActiveEffect] = useState(null);
     const playerRef = useRef(null);
     const containerRef = useRef(null);
     const autoTimerRef = useRef(null);
@@ -2834,6 +2937,7 @@ var MMDVisualNovel = forwardRef(
     const isStartedRef = useRef(autoStart);
     const lastAnimationTimeRef = useRef(0);
     const isVmdFinishedRef = useRef(false);
+    const effectTimerRef = useRef(null);
     const currentNode = nodes[currentNodeIndex];
     const currentDialogue = currentNode?.dialogues[currentDialogueIndex] || null;
     const addToHistory = useCallback((dialogue, nodeIndex, dialogueIndex) => {
@@ -2848,32 +2952,17 @@ var MMDVisualNovel = forwardRef(
         }
       ]);
     }, []);
-    const goToNextDialogue = useCallback(() => {
-      if (!currentNode) return;
-      if (autoTimerRef.current) {
-        clearTimeout(autoTimerRef.current);
-        autoTimerRef.current = null;
+    const triggerEffect = useCallback((effect) => {
+      if (!effect) return;
+      if (effectTimerRef.current) {
+        clearTimeout(effectTimerRef.current);
       }
-      const nextDialogueIndex = currentDialogueIndex + 1;
-      if (nextDialogueIndex < currentNode.dialogues.length && currentNode?.dialogues[nextDialogueIndex] !== void 0) {
-        const nextDialogue = currentNode.dialogues[nextDialogueIndex];
-        setCurrentDialogueIndex(nextDialogueIndex);
-        addToHistory(nextDialogue, currentNodeIndex, nextDialogueIndex);
-        onDialogueChange?.(nextDialogue, nextDialogueIndex, currentNodeIndex);
-        typingCompleteRef.current = false;
-      } else if (currentNode.choices && currentNode.choices.length > 0) {
-        setShowChoices(true);
-      } else {
-        const nextNodeIndex = currentNodeIndex + 1;
-        if (nextNodeIndex < nodes.length) {
-          goToNode(nextNodeIndex);
-        } else if (loop) {
-          goToNode(0);
-        } else {
-          onScriptComplete?.();
-        }
-      }
-    }, [currentNode, currentDialogueIndex, currentNodeIndex, nodes.length, loop, addToHistory, onDialogueChange, onScriptComplete]);
+      setActiveEffect(effect);
+      effectTimerRef.current = setTimeout(() => {
+        setActiveEffect(null);
+        effectTimerRef.current = null;
+      }, effect.duration || 1e3);
+    }, []);
     const goToNode = useCallback(
       (nodeIndex, force = false) => {
         if (nodeIndex < 0 || nodeIndex >= nodes.length) return;
@@ -2912,8 +3001,52 @@ var MMDVisualNovel = forwardRef(
           }, 100);
         }, 300);
       },
-      [nodes, isTransitioning, addToHistory, onNodeChange, onDialogueChange, currentNodeIndex, isVmdFinished]
+      [nodes, isTransitioning, addToHistory, onNodeChange, onDialogueChange, currentNodeIndex]
     );
+    const triggerNodeTransition = useCallback(() => {
+      if (!currentNode) return;
+      let nextNodeIndex = currentNodeIndex + 1;
+      if (currentNode.nextCondition) {
+        const { key, map, defaultIndex } = currentNode.nextCondition;
+        const val = variables[key];
+        if (val !== void 0 && map[val] !== void 0) {
+          nextNodeIndex = map[val];
+          console.log(`[MMDVisualNovel] Branching: ${key}=${val} -> node ${nextNodeIndex}`);
+        } else {
+          nextNodeIndex = defaultIndex;
+        }
+      }
+      if (nextNodeIndex < nodes.length && nextNodeIndex >= 0) {
+        goToNode(nextNodeIndex);
+      } else if (loop) {
+        goToNode(0);
+      } else {
+        onScriptComplete?.();
+      }
+    }, [currentNode, currentNodeIndex, nodes.length, loop, variables, goToNode, onScriptComplete]);
+    const goToNextDialogue = useCallback(() => {
+      if (!currentNode) return;
+      if (currentDialogue?.choices && currentDialogue.choices.length > 0 && !showChoices) {
+        setShowChoices(true);
+        return;
+      }
+      if (autoTimerRef.current) {
+        clearTimeout(autoTimerRef.current);
+        autoTimerRef.current = null;
+      }
+      const nextDialogueIndex = currentDialogueIndex + 1;
+      if (nextDialogueIndex < currentNode.dialogues.length && currentNode?.dialogues[nextDialogueIndex] !== void 0) {
+        const nextDialogue = currentNode.dialogues[nextDialogueIndex];
+        setCurrentDialogueIndex(nextDialogueIndex);
+        addToHistory(nextDialogue, currentNodeIndex, nextDialogueIndex);
+        onDialogueChange?.(nextDialogue, nextDialogueIndex, currentNodeIndex);
+        typingCompleteRef.current = false;
+      } else if (currentNode.choices && currentNode.choices.length > 0) {
+        setShowChoices(true);
+      } else {
+        triggerNodeTransition();
+      }
+    }, [currentNode, currentDialogue, currentDialogueIndex, currentNodeIndex, nodes.length, loop, addToHistory, onDialogueChange, onScriptComplete, showChoices, variables, goToNode, triggerNodeTransition]);
     const goToDialogue = useCallback(
       (dialogueIndex) => {
         if (!currentNode) return;
@@ -2957,6 +3090,11 @@ var MMDVisualNovel = forwardRef(
       }
       return void 0;
     }, [currentDialogue, handleTypingComplete]);
+    useEffect(() => {
+      if (currentDialogue?.effect) {
+        triggerEffect(currentDialogue.effect);
+      }
+    }, [currentNodeIndex, currentDialogueIndex, triggerEffect]);
     const toggleAutoMode = useCallback(() => {
       setIsAutoMode((prev) => !prev);
     }, []);
@@ -2992,12 +3130,17 @@ var MMDVisualNovel = forwardRef(
         getCurrentNodeIndex: () => currentNodeIndex,
         getCurrentDialogueIndex: () => currentDialogueIndex,
         getHistory: () => history,
+        getVariables: () => variables,
+        setVariable: (key, value) => {
+          setVariables((prev) => ({ ...prev, [key]: value }));
+        },
         setAutoMode: setIsAutoMode,
         skipTyping: () => {
           typingCompleteRef.current = true;
-        }
+        },
+        triggerEffect
       }),
-      [goToNode, goToDialogue, currentNodeIndex, currentDialogueIndex, history]
+      [goToNode, goToDialogue, currentNodeIndex, currentDialogueIndex, history, triggerEffect]
     );
     useEffect(() => {
       if (autoStart && currentNode && currentNode.dialogues.length > 0 && history.length === 0 && currentNode?.dialogues[0] !== void 0) {
@@ -3009,6 +3152,9 @@ var MMDVisualNovel = forwardRef(
         if (autoTimerRef.current) {
           clearTimeout(autoTimerRef.current);
         }
+        if (effectTimerRef.current) {
+          clearTimeout(effectTimerRef.current);
+        }
       };
     }, []);
     if (!currentNode) {
@@ -3081,6 +3227,38 @@ var MMDVisualNovel = forwardRef(
           }
         )
       ),
+      activeEffect && /* @__PURE__ */ React6.createElement(
+        "div",
+        {
+          className: "pointer-events-none absolute inset-0 flex items-center justify-center",
+          style: { zIndex: 999 }
+        },
+        activeEffect.type === "flash" && /* @__PURE__ */ React6.createElement(
+          "div",
+          {
+            className: "h-full w-full",
+            style: {
+              backgroundColor: activeEffect.color || "white",
+              animation: `flash-anim ${activeEffect.duration || 500}ms ease-out forwards`
+            }
+          }
+        ),
+        activeEffect.type === "gif" && activeEffect.url && /* @__PURE__ */ React6.createElement(
+          "img",
+          {
+            src: activeEffect.url,
+            alt: "effect",
+            className: activeEffect.position === "full" ? "h-full w-full object-cover" : "max-h-full max-w-full"
+          }
+        ),
+        /* @__PURE__ */ React6.createElement("style", null, `
+              @keyframes flash-anim {
+                0% { opacity: 0; }
+                25% { opacity: 1; }
+                100% { opacity: 0; }
+              }
+            `)
+      ),
       /* @__PURE__ */ React6.createElement(
         LoadingOverlay,
         {
@@ -3152,18 +3330,41 @@ var MMDVisualNovel = forwardRef(
           }
         }
       ),
-      showChoices && currentNode.choices && /* @__PURE__ */ React6.createElement(
+      showChoices && (currentDialogue?.choices || currentNode.choices) && /* @__PURE__ */ React6.createElement(
         ChoiceMenu,
         {
-          choices: currentNode.choices,
+          choices: currentDialogue?.choices || currentNode.choices,
           theme: dialogueTheme,
           onSelect: (choice) => {
+            if (choice.setVariable) {
+              const { key, value } = choice.setVariable;
+              setVariables((prev) => ({ ...prev, [key]: value }));
+              console.log(`[MMDVisualNovel] Variable set: ${key} = ${value}`);
+            }
             choice.onSelect?.();
-            if (choice.nextNodeIndex === currentNodeIndex) {
-              goToDialogue(choice.nextDialogueIndex || 0);
-              setShowChoices(false);
-            } else {
-              goToNode(choice.nextNodeIndex, true);
+            if (choice.effect) {
+              triggerEffect(choice.effect);
+            }
+            setShowChoices(false);
+            if (choice.nextNodeIndex !== void 0) {
+              if (choice.nextNodeIndex === currentNodeIndex) {
+                goToDialogue(choice.nextDialogueIndex || 0);
+              } else {
+                goToNode(choice.nextNodeIndex, true);
+              }
+            } else if (currentDialogue?.choices) {
+              const nextIdx = currentDialogueIndex + 1;
+              if (currentNode && nextIdx < currentNode.dialogues.length) {
+                const nextDialogue = currentNode.dialogues[nextIdx];
+                if (nextDialogue) {
+                  setCurrentDialogueIndex(nextIdx);
+                  addToHistory(nextDialogue, currentNodeIndex, nextIdx);
+                  onDialogueChange?.(nextDialogue, nextIdx, currentNodeIndex);
+                  typingCompleteRef.current = false;
+                }
+              } else {
+                triggerNodeTransition();
+              }
             }
           }
         }
@@ -3582,6 +3783,6 @@ var MMDMusicPlayer = forwardRef(
 );
 MMDMusicPlayer.displayName = "MMDMusicPlayer";
 
-export { DialogueBox, HistoryPanel, LoadingOverlay, LoadingScreen, MMDMusicPlayer, MMDPlayerBase, MMDPlayerEnhanced, MMDPlayerEnhancedDebugInfo, MMDPlaylist, MMDPlaylistDebugInfo, MMDVisualNovel, MusicControls, PlaylistPanel, StartScreen, TrackInfo, loadAmmo };
+export { ChoiceMenu, DialogueBox, HistoryPanel, LoadingOverlay, LoadingScreen, MMDMusicPlayer, MMDPlayerBase, MMDPlayerEnhanced, MMDPlayerEnhancedDebugInfo, MMDPlaylist, MMDPlaylistDebugInfo, MMDVisualNovel, MusicControls, PlaylistPanel, StartScreen, TrackInfo, loadAmmo };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map