@webxr-jp/avatar-optimizer 0.1.0

package/dist/index.js

@@ -0,0 +1,2293 @@
+import { MToonMaterial, VRMLoaderPlugin } from '@pixiv/three-vrm';
+import { ResultAsync, safeTry, err, ok, okAsync, fromSafePromise, Result } from 'neverthrow';
+import { Mesh, SkinnedMesh, Bone, Vector3, Matrix4, Quaternion, BufferAttribute, Scene, BufferGeometry, WebGLRenderer, Color, OrthographicCamera, WebGLRenderTarget, DataTexture, RGBAFormat, UnsignedByteType, LinearFilter, RepeatWrapping, SRGBColorSpace, MeshBasicMaterial, InterleavedBufferAttribute, LinearSRGBColorSpace, NoColorSpace, PlaneGeometry, NoBlending, DoubleSide, Vector2, FloatType, NearestFilter, Skeleton, Float32BufferAttribute, Vector4 } from 'three';
+import { Packer, MaxRectsBssf } from 'rectpack-ts';
+import { SORT_AREA } from 'rectpack-ts/dist/src/sorting.js';
+import { MeshoptSimplifier } from 'meshoptimizer';
+import { MToonAtlasExporterPlugin, MToonAtlasLoaderPlugin, MToonAtlasMaterial } from '@webxr-jp/mtoon-atlas';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { initBasisEncoder } from '@webxr-jp/texture-compression';
+export { UastcQuality } from '@webxr-jp/texture-compression';
+import { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter.js';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { KTX2Loader } from 'three/examples/jsm/loaders/KTX2Loader.js';
+
+// src/avatar-optimizer.ts
+var MTOON_TEXTURE_SLOTS = [
+  "map",
+  "normalMap",
+  "emissiveMap",
+  "shadeMultiplyTexture",
+  "shadingShiftTexture",
+  "matcapTexture",
+  "rimMultiplyTexture",
+  "outlineWidthMultiplyTexture",
+  "uvAnimationMaskTexture"
+];
+var MTOON_TEXTURE_SLOT_COLOR_SPACES = {
+  map: SRGBColorSpace,
+  normalMap: NoColorSpace,
+  emissiveMap: SRGBColorSpace,
+  shadeMultiplyTexture: SRGBColorSpace,
+  shadingShiftTexture: NoColorSpace,
+  matcapTexture: SRGBColorSpace,
+  rimMultiplyTexture: SRGBColorSpace,
+  outlineWidthMultiplyTexture: NoColorSpace,
+  uvAnimationMaskTexture: NoColorSpace
+};
+var PARAMETER_LAYOUT = [
+  { id: "baseColor", texel: 0, channels: ["r", "g", "b"] },
+  { id: "opacity", texel: 0, channels: ["a"] },
+  { id: "shadeColor", texel: 1, channels: ["r", "g", "b"] },
+  { id: "shadingShiftTextureScale", texel: 1, channels: ["a"] },
+  { id: "emissiveColor", texel: 2, channels: ["r", "g", "b"] },
+  { id: "emissiveIntensity", texel: 2, channels: ["a"] },
+  { id: "matcapColor", texel: 3, channels: ["r", "g", "b"] },
+  { id: "outlineWidth", texel: 3, channels: ["a"] },
+  { id: "outlineColor", texel: 4, channels: ["r", "g", "b"] },
+  { id: "outlineLightingMix", texel: 4, channels: ["a"] },
+  { id: "parametricRimColor", texel: 5, channels: ["r", "g", "b"] },
+  { id: "parametricRimLift", texel: 5, channels: ["a"] },
+  { id: "parametricRimFresnelPower", texel: 6, channels: ["r"] },
+  { id: "shadingToony", texel: 6, channels: ["g"] },
+  { id: "rimLightingMix", texel: 6, channels: ["b"] },
+  { id: "uvAnimationRotation", texel: 6, channels: ["a"] },
+  { id: "normalScale", texel: 7, channels: ["r", "g"] },
+  { id: "uvAnimationScrollX", texel: 7, channels: ["b"] },
+  { id: "uvAnimationScrollY", texel: 7, channels: ["a"] },
+  { id: "shadingShift", texel: 8, channels: ["r"] }
+];
+function composeImagesToAtlas(layers, options) {
+  const { width, height, colorSpace = SRGBColorSpace } = options;
+  if (width <= 0 || height <= 0) {
+    return err({
+      type: "INVALID_PARAMETER",
+      message: "width, height\u306F\u6B63\u306E\u5024\u306B\u3057\u3066\u304F\u3060\u3055\u3044"
+    });
+  }
+  const renderer = createRenderer();
+  const scene = new Scene();
+  scene.background = new Color(0, 0, 0);
+  const camera = new OrthographicCamera(0, 1, 1, 0, 0.1, 1e3);
+  camera.position.z = 10;
+  const renderTarget = new WebGLRenderTarget(width, height);
+  for (const layer of layers) {
+    const mesh = createLayerMesh(layer);
+    scene.add(mesh);
+  }
+  renderer.setRenderTarget(renderTarget);
+  renderer.setClearColor(0, 0);
+  renderer.clear();
+  renderer.render(scene, camera);
+  const pixels = new Uint8Array(width * height * 4);
+  renderer.readRenderTargetPixels(renderTarget, 0, 0, width, height, pixels);
+  const tex = new DataTexture(
+    pixels,
+    width,
+    height,
+    RGBAFormat,
+    UnsignedByteType
+  );
+  tex.needsUpdate = true;
+  tex.magFilter = LinearFilter;
+  tex.minFilter = LinearFilter;
+  tex.wrapS = RepeatWrapping;
+  tex.wrapT = RepeatWrapping;
+  tex.colorSpace = colorSpace;
+  scene.traverse((obj) => {
+    if (obj instanceof Mesh) {
+      obj.geometry.dispose();
+      if (obj.material instanceof MeshBasicMaterial) {
+        obj.material.dispose();
+      }
+    }
+  });
+  renderer.dispose();
+  renderTarget.dispose();
+  layers.forEach((layer) => layer.image.dispose());
+  return ok(tex);
+}
+function createRenderer() {
+  const canvas = new OffscreenCanvas(1, 1);
+  const renderer = new WebGLRenderer({
+    canvas,
+    antialias: false,
+    alpha: true,
+    // premultipliedAlpha を無効化してアルファ値をそのまま保持
+    premultipliedAlpha: false
+  });
+  renderer.outputColorSpace = LinearSRGBColorSpace;
+  return renderer;
+}
+function createLayerMesh(layer) {
+  const texture = layer.image;
+  const uvTransform = layer.uvTransform;
+  texture.colorSpace = NoColorSpace;
+  const geometry = new PlaneGeometry();
+  const material = new MeshBasicMaterial({
+    map: texture,
+    side: DoubleSide,
+    blending: NoBlending
+  });
+  const mesh = new Mesh(geometry, material);
+  mesh.position.x = uvTransform.offset.x + uvTransform.scale.x * 0.5;
+  mesh.position.y = uvTransform.offset.y + uvTransform.scale.y * 0.5;
+  mesh.position.z = 0;
+  mesh.scale.x = uvTransform.scale.x;
+  mesh.scale.y = uvTransform.scale.y;
+  mesh.scale.z = 1;
+  return mesh;
+}
+
+// src/process/gen-atlas.ts
+var DEFAULT_ATLAS_RESOLUTION = 2048;
+function getSlotResolution(slot, options) {
+  const defaultRes = options?.defaultResolution ?? DEFAULT_ATLAS_RESOLUTION;
+  return options?.slotResolutions?.[slot] ?? defaultRes;
+}
+function generateAtlasImagesFromPatterns(materials, patternMappings, patternPlacements, options) {
+  return safeTry(function* () {
+    if (patternMappings.length !== patternPlacements.length) {
+      return err({
+        type: "INVALID_OPERATION",
+        message: "Pattern mappings and placements length mismatch"
+      });
+    }
+    const atlasMap = {};
+    for (const slot of MTOON_TEXTURE_SLOTS) {
+      const layers = [];
+      for (let i = 0; i < patternMappings.length; i++) {
+        const mapping = patternMappings[i];
+        const placement = patternPlacements[i];
+        const representativeMaterialIndex = mapping.materialIndices[0];
+        const material = materials[representativeMaterialIndex];
+        const texture = material[slot];
+        if (texture) {
+          layers.push({
+            image: texture,
+            uvTransform: placement
+          });
+        }
+      }
+      const resolution = getSlotResolution(slot, options);
+      const atlas = yield* composeImagesToAtlas(layers, {
+        width: resolution,
+        height: resolution,
+        colorSpace: MTOON_TEXTURE_SLOT_COLOR_SPACES[slot]
+      });
+      atlasMap[slot] = atlas;
+    }
+    return ok(atlasMap);
+  });
+}
+function fillNullTexturesWithAverageDimensions(textures) {
+  const validTextures = textures.filter(
+    (t) => t !== null
+  );
+  if (validTextures.length === 0) {
+    return textures.map((t) => t ?? { width: 512, height: 512 });
+  }
+  const avgWidth = validTextures.reduce((sum, t) => sum + t.width, 0) / validTextures.length;
+  const avgHeight = validTextures.reduce((sum, t) => sum + t.height, 0) / validTextures.length;
+  const roundedWidth = roundToNearestPowerOfTwo(avgWidth);
+  const roundedHeight = roundToNearestPowerOfTwo(avgHeight);
+  return textures.map(
+    (t) => t ?? { width: roundedWidth, height: roundedHeight }
+  );
+}
+function roundToNearestPowerOfTwo(value) {
+  if (value <= 0) return 512;
+  const lower = Math.pow(2, Math.floor(Math.log2(value)));
+  const upper = lower * 2;
+  return value - lower < upper - value ? lower : upper;
+}
+function createParameterTexture(materials, texelsPerSlot = 9) {
+  if (materials.length === 0) {
+    return err({
+      type: "PARAMETER_TEXTURE_FAILED",
+      message: "No materials to pack"
+    });
+  }
+  const slotCount = materials.length;
+  const width = texelsPerSlot;
+  const height = slotCount;
+  const data = new Float32Array(width * height * 4);
+  for (let slotIndex = 0; slotIndex < slotCount; slotIndex++) {
+    const material = materials[slotIndex];
+    for (const layout of PARAMETER_LAYOUT) {
+      const value = extractParameterValue(material, layout.id);
+      packParameterValue(data, slotIndex, layout, value, texelsPerSlot);
+    }
+  }
+  const texture = new DataTexture(data, width, height, RGBAFormat, FloatType);
+  texture.minFilter = NearestFilter;
+  texture.magFilter = NearestFilter;
+  texture.needsUpdate = true;
+  return ok(texture);
+}
+function packParameterValue(data, slotIndex, layout, value, texelsPerSlot) {
+  const texelIndex = layout.texel;
+  const pixelIndex = slotIndex * texelsPerSlot + texelIndex;
+  const baseOffset = pixelIndex * 4;
+  let values;
+  if (typeof value === "number") {
+    values = [value];
+  } else if ("w" in value) {
+    values = [value.x, value.y, value.z, value.w];
+  } else {
+    values = [value.x, value.y, value.z];
+  }
+  for (let i = 0; i < layout.channels.length; i++) {
+    const channel = layout.channels[i];
+    const channelOffset = channel === "r" ? 0 : channel === "g" ? 1 : channel === "b" ? 2 : 3;
+    data[baseOffset + channelOffset] = values[i] ?? 0;
+  }
+}
+function extractParameterValue(material, semanticId) {
+  switch (semanticId) {
+    case "baseColor":
+      return colorToVector3(material.color ?? new Color(1, 1, 1));
+    case "opacity":
+      return material.opacity ?? 1;
+    case "shadeColor":
+      return colorToVector3(material.shadeColorFactor ?? new Color(0, 0, 0));
+    case "emissiveColor":
+      return colorToVector3(material.emissive ?? new Color(0, 0, 0));
+    case "emissiveIntensity":
+      return material.emissiveIntensity ?? 0;
+    case "shadingShift":
+      return ((material.shadingShiftFactor ?? 0) + 1) / 2;
+    case "shadingShiftTextureScale":
+      return material.shadingShiftTextureScale ?? 1;
+    case "shadingToony":
+      return material.shadingToonyFactor ?? 0.9;
+    case "rimLightingMix":
+      return material.rimLightingMixFactor ?? 1;
+    case "matcapColor":
+      return colorToVector3(material.matcapFactor ?? new Color(1, 1, 1));
+    case "outlineWidth":
+      return material.outlineWidthFactor ?? 0;
+    case "outlineColor":
+      return colorToVector3(material.outlineColorFactor ?? new Color(0, 0, 0));
+    case "outlineLightingMix":
+      return material.outlineLightingMixFactor ?? 1;
+    case "parametricRimColor":
+      return colorToVector3(
+        material.parametricRimColorFactor ?? new Color(0, 0, 0)
+      );
+    case "parametricRimLift":
+      return material.parametricRimLiftFactor ?? 0;
+    case "parametricRimFresnelPower":
+      return material.parametricRimFresnelPowerFactor ?? 5;
+    case "uvAnimationScrollX":
+      return 0;
+    // TODO: MToonMaterialのプロパティ確認
+    case "uvAnimationScrollY":
+      return 0;
+    // TODO: MToonMaterialのプロパティ確認
+    case "uvAnimationRotation":
+      return 0;
+    // TODO: MToonMaterialのプロパティ確認
+    case "normalScale":
+      return new Vector4(1, 1, 0, 0);
+    // x, y のみ使用
+    default:
+      return 0;
+  }
+}
+function colorToVector3(color) {
+  return new Vector3(color.r, color.g, color.b);
+}
+var ATLAS_SIZE = 2048;
+var SCALE_SEARCH_EPSILON = 1e-4;
+function packTexturesWithMaxRects(sizes) {
+  if (sizes.length === 0) {
+    throw new Error("No textures to pack");
+  }
+  const packer = new Packer({
+    packAlgo: MaxRectsBssf,
+    sortAlgo: SORT_AREA,
+    rotation: true
+  });
+  packer.addBin(ATLAS_SIZE, ATLAS_SIZE);
+  sizes.forEach((size, index) => {
+    packer.addRect(size.width, size.height, String(index));
+  });
+  packer.pack();
+  const bins = packer.binList();
+  if (bins.length === 0) {
+    throw new Error("Packing failed: No bins were created");
+  }
+  const bin = bins[0];
+  const packed = bin.rectangles.map((rect) => ({
+    rid: rect.rid,
+    offset: new Vector2(rect.x / bin.width, rect.y / bin.height),
+    scale: new Vector2(rect.width / bin.width, rect.height / bin.height)
+  }));
+  packed.sort((a, b) => Number(a.rid) - Number(b.rid));
+  if (packed.length !== sizes.length) {
+    throw new Error(
+      `Packing failed: ${packed.length}/${sizes.length} textures packed. Textures do not fit in atlas.`
+    );
+  }
+  if (bins.length > 1) {
+    throw new Error(
+      `Packing failed: ${bins.length} bins required, but expected single bin. Textures do not fit in atlas.`
+    );
+  }
+  return {
+    packed
+  };
+}
+async function packTexturesWithAutoScaling(sizes) {
+  if (sizes.length === 0) {
+    throw new Error("No textures to pack");
+  }
+  const attemptPack = (scale) => {
+    const scaledSizes = scaleTextureSizes(sizes, scale);
+    return packTexturesWithMaxRects(scaledSizes);
+  };
+  try {
+    return attemptPack(1);
+  } catch {
+  }
+  const minScaleLimit = computeMinScaleLimit(sizes);
+  let lastFailedScale = 1;
+  let lastSuccessScale = null;
+  let lastSuccessResult = null;
+  let currentScale = 0.5;
+  for (let attempt = 0; attempt < 32; attempt++) {
+    if (currentScale < minScaleLimit) {
+      currentScale = minScaleLimit;
+    }
+    try {
+      const result = attemptPack(currentScale);
+      lastSuccessScale = currentScale;
+      lastSuccessResult = result;
+      break;
+    } catch {
+      lastFailedScale = currentScale;
+      if (currentScale <= minScaleLimit) {
+        throw new Error(
+          "Failed to pack textures using MaxRects algorithm. Could not fit textures even after scaling down to 1x1 pixels."
+        );
+      }
+      currentScale *= 0.5;
+    }
+  }
+  if (lastSuccessScale === null || lastSuccessResult === null) {
+    throw new Error(
+      "Failed to pack textures using MaxRects algorithm. Could not fit textures even after scaling down to 1x1 pixels."
+    );
+  }
+  if (lastFailedScale <= lastSuccessScale) {
+    return lastSuccessResult;
+  }
+  let low = lastSuccessScale;
+  let high = lastFailedScale;
+  for (let i = 0; i < 25; i++) {
+    if (Math.abs(high - low) < SCALE_SEARCH_EPSILON) {
+      break;
+    }
+    const mid = (low + high) / 2;
+    if (mid === low || mid === high) {
+      break;
+    }
+    try {
+      const result = attemptPack(mid);
+      lastSuccessScale = mid;
+      lastSuccessResult = result;
+      low = mid;
+    } catch {
+      high = mid;
+    }
+  }
+  if (lastSuccessResult === null) {
+    throw new Error(
+      "Failed to pack textures using MaxRects algorithm. Could not fit textures even after scaling down to 1x1 pixels."
+    );
+  }
+  return lastSuccessResult;
+}
+function scaleTextureSizes(originalSizes, scaleMultiplier) {
+  return originalSizes.map((size) => ({
+    width: Math.max(1, Math.floor(size.width * scaleMultiplier)),
+    height: Math.max(1, Math.floor(size.height * scaleMultiplier))
+  }));
+}
+function computeMinScaleLimit(sizes) {
+  if (sizes.length === 0) {
+    return 1;
+  }
+  const maxDimension = Math.max(
+    ...sizes.map((size) => Math.max(size.width, size.height))
+  );
+  if (maxDimension <= 0) {
+    return 1;
+  }
+  return 1 / maxDimension;
+}
+async function packTextures(sizes) {
+  return packTexturesWithAutoScaling(sizes);
+}
+
+// src/process/packing.ts
+function pack(patternMappings) {
+  return fromSafePromise(
+    (async () => {
+      const textureDescriptors = patternMappings.map((m) => m.textureDescriptor);
+      const texturesToPack = fillNullTexturesWithAverageDimensions(
+        textureDescriptors.map((d) => d.width > 0 && d.height > 0 ? d : null)
+      );
+      return await packTextures(texturesToPack);
+    })()
+  );
+}
+function buildPatternMaterialMappings(materials) {
+  const mappings = [];
+  for (let i = 0; i < materials.length; i++) {
+    const material = materials[i];
+    const pattern = extractTexturePattern(material);
+    const existingMapping = mappings.find(
+      (m) => isSamePattern(m.pattern, pattern)
+    );
+    if (existingMapping) {
+      existingMapping.materialIndices.push(i);
+    } else {
+      const mapTexture = material.map;
+      const textureDescriptor = mapTexture && hasSize(mapTexture.image) ? {
+        width: mapTexture.image.width,
+        height: mapTexture.image.height
+      } : {
+        width: 0,
+        height: 0
+      };
+      mappings.push({
+        pattern,
+        materialIndices: [i],
+        textureDescriptor
+      });
+    }
+  }
+  return mappings;
+}
+function extractTexturePattern(material) {
+  const slots = /* @__PURE__ */ new Map();
+  for (const slot of MTOON_TEXTURE_SLOTS) {
+    const texture = material[slot];
+    slots.set(slot, texture?.image ?? null);
+  }
+  return { slots };
+}
+function isSamePattern(pattern1, pattern2) {
+  for (const slot of MTOON_TEXTURE_SLOTS) {
+    const img1 = pattern1.slots.get(slot) ?? null;
+    const img2 = pattern2.slots.get(slot) ?? null;
+    if (img1 !== img2) return false;
+  }
+  return true;
+}
+function hasSize(img) {
+  return img != null && typeof img.width === "number" && typeof img.height === "number";
+}
+function cloneBufferAttribute(attr) {
+  const count = attr.count;
+  const itemSize = attr.itemSize;
+  const normalized = attr.normalized;
+  const TypedArrayConstructor = attr.array.constructor;
+  const newArray = new TypedArrayConstructor(count * itemSize);
+  if (attr instanceof InterleavedBufferAttribute) {
+    for (let i = 0; i < count; i++) {
+      for (let j = 0; j < itemSize; j++) {
+        newArray[i * itemSize + j] = attr.getComponent(i, j);
+      }
+    }
+  } else {
+    const sourceArray = attr.array;
+    for (let i = 0; i < sourceArray.length; i++) {
+      newArray[i] = sourceArray[i];
+    }
+  }
+  return new BufferAttribute(newArray, itemSize, normalized);
+}
+function editBufferAttribute(attr, editor) {
+  const cloned = cloneBufferAttribute(attr);
+  editor(cloned.array);
+  cloned.needsUpdate = true;
+  return cloned;
+}
+
+// src/util/mesh/uv.ts
+function wrapUV(uv) {
+  let x = uv.x;
+  let y = uv.y;
+  if (x < 0 || x > 1) x = x - Math.floor(x);
+  if (y < 0 || y > 1) y = y - Math.floor(y);
+  return new Vector2(x, y);
+}
+function applyUVTransform(uvArray, scaleU, scaleV, translateU, translateV, startIndex = 0, endIndex = uvArray.length) {
+  for (let i = startIndex; i < endIndex; i += 2) {
+    const oldU = uvArray[i];
+    const oldV = uvArray[i + 1];
+    const wrapped = wrapUV(new Vector2(oldU, oldV));
+    const oldUWrapped = wrapped.x;
+    const oldVWrapped = wrapped.y;
+    const newU = translateU + scaleU * oldUWrapped;
+    const newV = translateV + scaleV * oldVWrapped;
+    uvArray[i] = newU;
+    uvArray[i + 1] = newV;
+  }
+}
+function remapGeometryUVs(geometry, uvTransform) {
+  const uvAttribute = geometry.getAttribute("uv");
+  if (!uvAttribute) {
+    return err({
+      type: "ASSET_ERROR",
+      message: "UV\u30A2\u30C8\u30EA\u30D3\u30E5\u30FC\u30C8\u304C\u5B58\u5728\u3057\u307E\u305B\u3093"
+    });
+  }
+  if (!uvAttribute.array) {
+    return err({
+      type: "ASSET_ERROR",
+      message: "UV\u30A2\u30C8\u30EA\u30D3\u30E5\u30FC\u30C8\u914D\u5217\u304C\u5B58\u5728\u3057\u307E\u305B\u3093"
+    });
+  }
+  if (uvAttribute.itemSize !== 2) {
+    return err({
+      type: "ASSET_ERROR",
+      message: "UV\u30A2\u30C8\u30EA\u30D3\u30E5\u30FC\u30C8\u306E\u8981\u7D20\u6570\u304C2\u3067\u306F\u3042\u308A\u307E\u305B\u3093"
+    });
+  }
+  const newUvAttribute = editBufferAttribute(
+    uvAttribute,
+    (uvArray) => {
+      applyUVTransform(
+        uvArray,
+        uvTransform.scale.x,
+        uvTransform.scale.y,
+        uvTransform.offset.x,
+        uvTransform.offset.y
+      );
+    }
+  );
+  geometry.setAttribute("uv", newUvAttribute);
+  return ok();
+}
+
+// src/process/set-uv.ts
+function applyPlacementsToGeometries(rootNode, materialPlacementMap) {
+  const targets = /* @__PURE__ */ new Map();
+  rootNode.traverse((obj) => {
+    if (!(obj instanceof Mesh)) return;
+    if (!(obj.geometry instanceof BufferGeometry)) return;
+    let material = null;
+    if (Array.isArray(obj.material)) {
+      material = obj.material[0];
+    } else if (obj.material instanceof MToonMaterial) {
+      material = obj.material;
+    }
+    if (!(material instanceof MToonMaterial)) {
+      if (obj.material?.isMToonMaterial || Array.isArray(obj.material) && obj.material[0]?.isMToonMaterial) {
+        console.warn(
+          "Found MToonMaterial-like object but instanceof failed. This indicates a dual package hazard.",
+          obj.material
+        );
+      }
+      return;
+    }
+    const placement = materialPlacementMap.get(material);
+    if (!placement) {
+      console.warn("No placement found for material", material);
+      return;
+    }
+    const uvAttr = obj.geometry.getAttribute("uv");
+    if (uvAttr) {
+      const newUvArray = new Float32Array(uvAttr.array.length);
+      newUvArray.set(uvAttr.array);
+      const newUvAttr = new BufferAttribute(
+        newUvArray,
+        uvAttr.itemSize,
+        uvAttr.normalized
+      );
+      obj.geometry.setAttribute("uv", newUvAttr);
+    }
+    targets.set(obj.geometry, placement);
+  });
+  const results = [...targets].map(
+    (target) => remapGeometryUVs(target[0], target[1])
+  );
+  return Result.combine(results);
+}
+var DEFAULT_SIMPLIFY_OPTIONS = {
+  targetRatio: 0.5,
+  targetError: 0.01,
+  lockBorder: true,
+  uvWeight: 1,
+  normalWeight: 0.5,
+  morphTargetHandling: "skip"
+};
+async function ensureSimplifierReady() {
+  await MeshoptSimplifier.ready;
+}
+function extractAttributeData(attr) {
+  const count = attr.count;
+  const itemSize = attr.itemSize;
+  const result = new Float32Array(count * itemSize);
+  for (let i = 0; i < count; i++) {
+    for (let j = 0; j < itemSize; j++) {
+      result[i * itemSize + j] = attr.getComponent(i, j);
+    }
+  }
+  return result;
+}
+function simplifyGeometry(geometry, options = {}) {
+  return safeTry(function* () {
+    const opts = { ...DEFAULT_SIMPLIFY_OPTIONS, ...options };
+    const positionAttr = geometry.getAttribute("position");
+    if (!positionAttr) {
+      return err({
+        type: "ASSET_ERROR",
+        message: "position\u5C5E\u6027\u304C\u5B58\u5728\u3057\u307E\u305B\u3093"
+      });
+    }
+    const vertexCount = positionAttr.count;
+    let indices;
+    if (geometry.index) {
+      indices = new Uint32Array(geometry.index.array);
+    } else {
+      indices = new Uint32Array(vertexCount);
+      for (let i = 0; i < vertexCount; i++) {
+        indices[i] = i;
+      }
+    }
+    const positions = extractAttributeData(positionAttr);
+    const uvAttr = geometry.getAttribute("uv");
+    const normalAttr = geometry.getAttribute("normal");
+    const attributeWeights = [];
+    if (normalAttr) {
+      for (let i = 0; i < 3; i++) {
+        attributeWeights.push(opts.normalWeight);
+      }
+    }
+    if (uvAttr) {
+      for (let i = 0; i < 2; i++) {
+        attributeWeights.push(opts.uvWeight);
+      }
+    }
+    const rawTargetCount = Math.floor(indices.length * opts.targetRatio);
+    const targetIndexCount = Math.max(3, Math.floor(rawTargetCount / 3) * 3);
+    const flags = [];
+    if (opts.lockBorder) {
+      flags.push("LockBorder");
+    }
+    let newIndices;
+    let resultError;
+    if (attributeWeights.length > 0) {
+      const stride = attributeWeights.length;
+      const attributes = new Float32Array(vertexCount * stride);
+      for (let v = 0; v < vertexCount; v++) {
+        let offset = 0;
+        if (normalAttr) {
+          for (let j = 0; j < 3; j++) {
+            attributes[v * stride + offset + j] = normalAttr.getComponent(v, j);
+          }
+          offset += 3;
+        }
+        if (uvAttr) {
+          for (let j = 0; j < 2; j++) {
+            attributes[v * stride + offset + j] = uvAttr.getComponent(v, j);
+          }
+        }
+      }
+      [newIndices, resultError] = MeshoptSimplifier.simplifyWithAttributes(
+        indices,
+        positions,
+        3,
+        // position stride
+        attributes,
+        stride,
+        attributeWeights,
+        null,
+        // vertex_lock
+        targetIndexCount,
+        opts.targetError,
+        flags
+      );
+    } else {
+      [newIndices, resultError] = MeshoptSimplifier.simplify(
+        indices,
+        positions,
+        3,
+        targetIndexCount,
+        opts.targetError,
+        flags
+      );
+    }
+    if (newIndices.length === indices.length) {
+      return ok(geometry.clone());
+    }
+    const newGeometry = yield* rebuildGeometry(geometry, newIndices);
+    newGeometry.userData.simplifyError = resultError;
+    return ok(newGeometry);
+  });
+}
+function rebuildGeometry(originalGeometry, newIndices) {
+  return safeTry(function* () {
+    const usedVertices = /* @__PURE__ */ new Set();
+    for (let i = 0; i < newIndices.length; i++) {
+      usedVertices.add(newIndices[i]);
+    }
+    const vertexRemap = /* @__PURE__ */ new Map();
+    const sortedIndices = Array.from(usedVertices).sort((a, b) => a - b);
+    let newIndex = 0;
+    for (const oldIndex of sortedIndices) {
+      vertexRemap.set(oldIndex, newIndex++);
+    }
+    const newVertexCount = vertexRemap.size;
+    const newGeometry = new BufferGeometry();
+    const remappedIndices = new Uint32Array(newIndices.length);
+    for (let i = 0; i < newIndices.length; i++) {
+      const remapped = vertexRemap.get(newIndices[i]);
+      if (remapped === void 0) {
+        return err({
+          type: "INTERNAL_ERROR",
+          message: `\u9802\u70B9\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9\u306E\u30EA\u30DE\u30C3\u30D7\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${newIndices[i]}`
+        });
+      }
+      remappedIndices[i] = remapped;
+    }
+    newGeometry.setIndex(new BufferAttribute(remappedIndices, 1));
+    for (const name of Object.keys(originalGeometry.attributes)) {
+      const attr = originalGeometry.getAttribute(name);
+      const itemSize = attr.itemSize;
+      const normalized = attr.normalized;
+      let TypedArrayConstructor;
+      if (name === "skinIndex") {
+        TypedArrayConstructor = Uint16Array;
+      } else if (attr.array instanceof Uint8Array) {
+        TypedArrayConstructor = Uint8Array;
+      } else {
+        TypedArrayConstructor = Float32Array;
+      }
+      const newArray = new TypedArrayConstructor(newVertexCount * itemSize);
+      for (const [oldIdx, newIdx] of vertexRemap) {
+        for (let j = 0; j < itemSize; j++) {
+          newArray[newIdx * itemSize + j] = attr.array[oldIdx * itemSize + j];
+        }
+      }
+      const newAttr = new BufferAttribute(newArray, itemSize, normalized);
+      newGeometry.setAttribute(name, newAttr);
+    }
+    if (originalGeometry.groups.length > 0) {
+      newGeometry.addGroup(0, remappedIndices.length, 0);
+      if (originalGeometry.groups.length > 1) {
+        console.warn(
+          `\u8907\u6570\u30B0\u30EB\u30FC\u30D7(${originalGeometry.groups.length})\u3092\u6301\u3064\u30B8\u30AA\u30E1\u30C8\u30EA\u306F\u5358\u4E00\u30B0\u30EB\u30FC\u30D7\u306B\u7D71\u5408\u3055\u308C\u307E\u3059`
+        );
+      }
+    }
+    newGeometry.setDrawRange(0, Infinity);
+    newGeometry.computeBoundingBox();
+    newGeometry.computeBoundingSphere();
+    return ok(newGeometry);
+  });
+}
+
+// src/process/simplify.ts
+function simplifyMeshes(rootNode, excludedMeshes, options = {}) {
+  return ResultAsync.fromSafePromise(
+    simplifyMeshesAsync(rootNode, excludedMeshes, options)
+  );
+}
+async function simplifyMeshesAsync(rootNode, excludedMeshes, options) {
+  await ensureSimplifierReady();
+  const stats = {
+    processedMeshCount: 0,
+    skippedMeshCount: 0,
+    originalVertexCount: 0,
+    simplifiedVertexCount: 0,
+    originalIndexCount: 0,
+    simplifiedIndexCount: 0,
+    vertexReductionRatio: 0,
+    indexReductionRatio: 0
+  };
+  const opts = {
+    morphTargetHandling: "skip",
+    ...options
+  };
+  const meshesToProcess = [];
+  rootNode.traverse((obj) => {
+    if (!(obj instanceof Mesh)) return;
+    if (excludedMeshes.has(obj)) {
+      stats.skippedMeshCount++;
+      return;
+    }
+    if (obj.geometry.morphAttributes && Object.keys(obj.geometry.morphAttributes).length > 0) {
+      if (opts.morphTargetHandling === "skip") {
+        console.warn(`MorphTarget\u3092\u6301\u3064\u30E1\u30C3\u30B7\u30E5\u3092\u30B9\u30AD\u30C3\u30D7\u3057\u307E\u3057\u305F: ${obj.name}`);
+        stats.skippedMeshCount++;
+        return;
+      }
+    }
+    meshesToProcess.push(obj);
+  });
+  for (const mesh of meshesToProcess) {
+    const originalVertexCount = mesh.geometry.getAttribute("position")?.count ?? 0;
+    const originalIndexCount = mesh.geometry.index?.count ?? originalVertexCount;
+    stats.originalVertexCount += originalVertexCount;
+    stats.originalIndexCount += originalIndexCount;
+    const result = simplifyGeometry(mesh.geometry, options);
+    if (result.isErr()) {
+      console.warn(
+        `\u30E1\u30C3\u30B7\u30E5\u306E\u7C21\u7565\u5316\u306B\u5931\u6557\u3057\u307E\u3057\u305F (${mesh.name}): ${result.error.message}`
+      );
+      stats.skippedMeshCount++;
+      stats.originalVertexCount -= originalVertexCount;
+      stats.originalIndexCount -= originalIndexCount;
+      continue;
+    }
+    const oldGeometry = mesh.geometry;
+    mesh.geometry = result.value;
+    for (const key of Object.keys(mesh.geometry.attributes)) {
+      const attr = mesh.geometry.attributes[key];
+      if (attr) {
+        attr.needsUpdate = true;
+      }
+    }
+    if (mesh.geometry.index) {
+      mesh.geometry.index.needsUpdate = true;
+    }
+    if (mesh instanceof SkinnedMesh) {
+      if (mesh.skeleton) {
+        mesh.bind(mesh.skeleton, mesh.bindMatrix);
+      }
+    }
+    oldGeometry.dispose();
+    const newVertexCount = mesh.geometry.getAttribute("position")?.count ?? 0;
+    const newIndexCount = mesh.geometry.index?.count ?? newVertexCount;
+    stats.simplifiedVertexCount += newVertexCount;
+    stats.simplifiedIndexCount += newIndexCount;
+    stats.processedMeshCount++;
+  }
+  if (stats.originalVertexCount > 0) {
+    stats.vertexReductionRatio = 1 - stats.simplifiedVertexCount / stats.originalVertexCount;
+  }
+  if (stats.originalIndexCount > 0) {
+    stats.indexReductionRatio = 1 - stats.simplifiedIndexCount / stats.originalIndexCount;
+  }
+  return stats;
+}
+function mergeGeometriesWithSlotAttribute(meshes, materialSlotMap, slotAttributeName) {
+  if (meshes.length === 0) {
+    return err({
+      type: "ASSET_ERROR",
+      message: "\u30DE\u30FC\u30B8\u5BFE\u8C61\u306E\u30E1\u30C3\u30B7\u30E5\u304C\u3042\u308A\u307E\u305B\u3093"
+    });
+  }
+  const validMeshes = [];
+  for (const mesh of meshes) {
+    if (mesh.geometry instanceof BufferGeometry) {
+      const vertexCount = mesh.geometry.attributes.position?.count ?? 0;
+      if (vertexCount > 0) {
+        validMeshes.push({ mesh, geometry: mesh.geometry });
+      }
+    }
+  }
+  if (validMeshes.length === 0) {
+    return err({
+      type: "ASSET_ERROR",
+      message: "\u6709\u52B9\u306A\u30B8\u30AA\u30E1\u30C8\u30EA\u3092\u6301\u3064\u30E1\u30C3\u30B7\u30E5\u304C\u3042\u308A\u307E\u305B\u3093"
+    });
+  }
+  const allBones = [];
+  const boneUniqueMap = /* @__PURE__ */ new Map();
+  const hasSkinnedMesh = validMeshes.some(
+    ({ mesh }) => mesh instanceof SkinnedMesh
+  );
+  if (hasSkinnedMesh) {
+    for (const { mesh } of validMeshes) {
+      if (mesh instanceof SkinnedMesh && mesh.skeleton) {
+        for (const bone of mesh.skeleton.bones) {
+          if (!boneUniqueMap.has(bone.uuid)) {
+            boneUniqueMap.set(bone.uuid, allBones.length);
+            allBones.push(bone);
+          }
+        }
+      }
+    }
+  }
+  const transformedGeometries = [];
+  const slotData = [];
+  for (const { mesh, geometry } of validMeshes) {
+    const transformedGeometry = geometry.clone();
+    const vertexCount = geometry.attributes.position?.count ?? 0;
+    if (mesh instanceof SkinnedMesh) {
+      transformedGeometry.applyMatrix4(mesh.bindMatrix);
+      if (mesh.skeleton && transformedGeometry.attributes.skinIndex) {
+        const skinIndexAttr = transformedGeometry.attributes.skinIndex;
+        const oldBones = mesh.skeleton.bones;
+        for (let i = 0; i < skinIndexAttr.count; i++) {
+          const a = skinIndexAttr.getX(i);
+          const b = skinIndexAttr.getY(i);
+          const c = skinIndexAttr.getZ(i);
+          const d = skinIndexAttr.getW(i);
+          const newA = oldBones[a] ? boneUniqueMap.get(oldBones[a].uuid) ?? 0 : 0;
+          const newB = oldBones[b] ? boneUniqueMap.get(oldBones[b].uuid) ?? 0 : 0;
+          const newC = oldBones[c] ? boneUniqueMap.get(oldBones[c].uuid) ?? 0 : 0;
+          const newD = oldBones[d] ? boneUniqueMap.get(oldBones[d].uuid) ?? 0 : 0;
+          skinIndexAttr.setXYZW(i, newA, newB, newC, newD);
+        }
+      }
+    } else {
+      mesh.updateMatrixWorld(true);
+      transformedGeometry.applyMatrix4(mesh.matrixWorld);
+    }
+    transformedGeometry.morphAttributes = {};
+    transformedGeometry.morphTargetsRelative = false;
+    transformedGeometries.push(transformedGeometry);
+    const slotIndex = materialSlotMap.get(mesh) ?? 0;
+    for (let i = 0; i < vertexCount; i++) {
+      slotData.push(slotIndex);
+    }
+  }
+  const mergedGeometry = mergeGeometries(transformedGeometries);
+  if (hasSkinnedMesh) {
+    mergedGeometry.userData.skeleton = new Skeleton(allBones);
+  }
+  const slotArray = new Float32Array(slotData);
+  mergedGeometry.setAttribute(
+    slotAttributeName,
+    new Float32BufferAttribute(slotArray, 1)
+  );
+  return ok([mergedGeometry]);
+}
+
+// src/util/material/combine.ts
+var DEFAULT_OPTIONS = {
+  atlasSize: 2048,
+  slotAttributeName: "mtoonMaterialSlot",
+  texelsPerSlot: 9
+};
+function combineMToonMaterials(input, options = {}, excludedMeshes) {
+  let materialInfos;
+  if (input instanceof Map) {
+    materialInfos = [];
+    for (const [material, meshes] of input) {
+      materialInfos.push({
+        material,
+        meshes,
+        hasOutline: material.outlineWidthMode !== "none",
+        outlineWidthMode: material.outlineWidthMode,
+        renderMode: getRenderMode(material)
+      });
+    }
+  } else {
+    materialInfos = input;
+  }
+  return combineMToonMaterialsInternal(materialInfos, options, excludedMeshes);
+}
+function groupMaterialInfoByRenderMode(materialInfos) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const info of materialInfos) {
+    const mode = info.renderMode;
+    if (!groups.has(mode)) {
+      groups.set(mode, []);
+    }
+    groups.get(mode).push(info);
+  }
+  return groups;
+}
+function processSingleGroup(materialInfos, opts, excludedMeshes, renderMode) {
+  return safeTry(function* () {
+    const materials = materialInfos.map((info) => info.material);
+    let hasAnyOutline = false;
+    let outlineWidthMode = "worldCoordinates";
+    for (const info of materialInfos) {
+      if (info.hasOutline) {
+        hasAnyOutline = true;
+        outlineWidthMode = info.outlineWidthMode;
+        break;
+      }
+    }
+    const parameterTexture = yield* createParameterTexture(
+      materials,
+      opts.texelsPerSlot
+    );
+    const materialSlotIndex = /* @__PURE__ */ new Map();
+    materials.forEach((mat, index) => {
+      materialSlotIndex.set(mat, index);
+    });
+    const meshToSlotIndex = /* @__PURE__ */ new Map();
+    const meshesForMerge = [];
+    for (const info of materialInfos) {
+      const slotIndex = materialSlotIndex.get(info.material) ?? 0;
+      for (const mesh of info.meshes) {
+        if (excludedMeshes?.has(mesh)) continue;
+        meshToSlotIndex.set(mesh, slotIndex);
+        meshesForMerge.push(mesh);
+      }
+    }
+    const atlasMaterial = createMToonAtlasMaterial(
+      materials[0],
+      parameterTexture,
+      materials.length,
+      opts.texelsPerSlot,
+      opts.slotAttributeName,
+      renderMode
+    );
+    if (meshesForMerge.length === 0) {
+      return ok({
+        mesh: null,
+        material: atlasMaterial,
+        outlineMesh: void 0,
+        outlineMaterial: void 0,
+        materialSlotIndex,
+        meshCount: 0,
+        materialCount: materials.length
+      });
+    }
+    const mergedGeometries = yield* mergeGeometriesWithSlotAttribute(
+      meshesForMerge,
+      meshToSlotIndex,
+      opts.slotAttributeName
+    );
+    const mergedGeometry = mergedGeometries[0];
+    const { mesh: combinedMesh } = createCombinedMesh(
+      mergedGeometry,
+      atlasMaterial,
+      meshesForMerge,
+      `CombinedMToonMesh_${renderMode}`
+    );
+    let outlineMesh;
+    let outlineMaterial;
+    if (hasAnyOutline) {
+      outlineMaterial = atlasMaterial.createOutlineMaterial(
+        outlineWidthMode === "screenCoordinates" ? "screenCoordinates" : "worldCoordinates"
+      );
+      const outlineResult = createCombinedMesh(
+        mergedGeometry,
+        outlineMaterial,
+        meshesForMerge,
+        `CombinedMToonMesh_${renderMode}_Outline`
+      );
+      outlineMesh = outlineResult.mesh;
+      outlineMesh.renderOrder = combinedMesh.renderOrder - 1;
+    }
+    return ok({
+      mesh: combinedMesh,
+      material: atlasMaterial,
+      outlineMesh,
+      outlineMaterial,
+      materialSlotIndex,
+      meshCount: meshesForMerge.length,
+      materialCount: materials.length
+    });
+  });
+}
+function createCombinedMesh(geometry, material, sourceMeshes, name) {
+  const firstSkinnedMesh = sourceMeshes.find(
+    (mesh2) => mesh2 instanceof SkinnedMesh
+  );
+  let mesh;
+  if (firstSkinnedMesh) {
+    const skinnedMesh = new SkinnedMesh(geometry, material);
+    skinnedMesh.name = name;
+    if (geometry.userData.skeleton) {
+      const skeleton = geometry.userData.skeleton;
+      const identityMatrix = firstSkinnedMesh.matrixWorld.clone().identity();
+      skinnedMesh.bind(skeleton, identityMatrix);
+    } else if (firstSkinnedMesh.skeleton) {
+      const identityMatrix = firstSkinnedMesh.matrixWorld.clone().identity();
+      skinnedMesh.bind(firstSkinnedMesh.skeleton, identityMatrix);
+    }
+    mesh = skinnedMesh;
+  } else {
+    mesh = new Mesh(geometry, material);
+    mesh.name = name;
+  }
+  return { mesh, firstSkinnedMesh };
+}
+function combineMToonMaterialsInternal(materialInfos, options, excludedMeshes) {
+  return safeTry(function* () {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const groupedInfos = groupMaterialInfoByRenderMode(materialInfos);
+    const groups = /* @__PURE__ */ new Map();
+    const materialSlotIndex = /* @__PURE__ */ new Map();
+    let totalMeshCount = 0;
+    let totalMaterialCount = 0;
+    const renderModeOrder = ["opaque", "alphaTest", "transparent"];
+    for (const renderMode of renderModeOrder) {
+      const infos = groupedInfos.get(renderMode);
+      if (!infos || infos.length === 0) continue;
+      const result = yield* processSingleGroup(
+        infos,
+        opts,
+        excludedMeshes,
+        renderMode
+      );
+      groups.set(renderMode, {
+        mesh: result.mesh,
+        material: result.material,
+        outlineMesh: result.outlineMesh,
+        outlineMaterial: result.outlineMaterial
+      });
+      for (const [mat, slotIndex] of result.materialSlotIndex) {
+        materialSlotIndex.set(mat, { renderMode, slotIndex });
+      }
+      totalMeshCount += result.meshCount;
+      totalMaterialCount += result.materialCount;
+    }
+    if (groups.size === 0) {
+      return err({
+        type: "ASSET_ERROR",
+        message: "\u30DE\u30FC\u30B8\u5BFE\u8C61\u306E\u30E1\u30C3\u30B7\u30E5\u304C\u3042\u308A\u307E\u305B\u3093"
+      });
+    }
+    let resultDrawCalls = 0;
+    for (const group of groups.values()) {
+      if (group.mesh) resultDrawCalls += 1;
+      if (group.outlineMesh) resultDrawCalls += 1;
+    }
+    return ok({
+      groups,
+      materialSlotIndex,
+      statistics: {
+        originalMeshCount: totalMeshCount,
+        originalMaterialCount: totalMaterialCount,
+        reducedDrawCalls: totalMaterialCount - resultDrawCalls
+      }
+    });
+  });
+}
+function createMToonAtlasMaterial(representativeMaterial, parameterTexture, slotCount, texelsPerSlot, slotAttributeName, renderMode) {
+  const atlasedTextures = {};
+  if (representativeMaterial.map) {
+    atlasedTextures.baseColor = representativeMaterial.map;
+  }
+  if (representativeMaterial.shadeMultiplyTexture) {
+    atlasedTextures.shade = representativeMaterial.shadeMultiplyTexture;
+  }
+  if (representativeMaterial.shadingShiftTexture) {
+    atlasedTextures.shadingShift = representativeMaterial.shadingShiftTexture;
+  }
+  if (representativeMaterial.normalMap) {
+    atlasedTextures.normal = representativeMaterial.normalMap;
+  }
+  if (representativeMaterial.emissiveMap) {
+    atlasedTextures.emissive = representativeMaterial.emissiveMap;
+  }
+  if (representativeMaterial.matcapTexture) {
+    atlasedTextures.matcap = representativeMaterial.matcapTexture;
+  }
+  if (representativeMaterial.rimMultiplyTexture) {
+    atlasedTextures.rim = representativeMaterial.rimMultiplyTexture;
+  }
+  if (representativeMaterial.uvAnimationMaskTexture) {
+    atlasedTextures.uvAnimationMask = representativeMaterial.uvAnimationMaskTexture;
+  }
+  const parameterTextureDescriptor = {
+    texture: parameterTexture,
+    slotCount,
+    texelsPerSlot,
+    atlasedTextures
+  };
+  const slotAttribute = {
+    name: slotAttributeName,
+    description: "Material slot index for instancing"
+  };
+  const material = new MToonAtlasMaterial({
+    parameterTexture: parameterTextureDescriptor,
+    slotAttribute
+  });
+  if (renderMode === "transparent") {
+    material.transparent = true;
+    material.depthWrite = false;
+  } else if (renderMode === "alphaTest") {
+    material.transparent = false;
+    material.alphaTest = representativeMaterial.alphaTest;
+  } else {
+    material.transparent = false;
+  }
+  return material;
+}
+
+// src/util/material/index.ts
+function getRenderMode(material) {
+  if (material.transparent) return "transparent";
+  if (material.alphaTest > 0) return "alphaTest";
+  return "opaque";
+}
+function assignAtlasTexturesToMaterial(material, atlasMap) {
+  if (atlasMap.map) material.map = atlasMap.map;
+  if (atlasMap.normalMap) material.normalMap = atlasMap.normalMap;
+  if (atlasMap.emissiveMap) material.emissiveMap = atlasMap.emissiveMap;
+  if (atlasMap.shadeMultiplyTexture)
+    material.shadeMultiplyTexture = atlasMap.shadeMultiplyTexture;
+  if (atlasMap.shadingShiftTexture)
+    material.shadingShiftTexture = atlasMap.shadingShiftTexture;
+  if (atlasMap.rimMultiplyTexture)
+    material.rimMultiplyTexture = atlasMap.rimMultiplyTexture;
+  if (atlasMap.outlineWidthMultiplyTexture)
+    material.outlineWidthMultiplyTexture = atlasMap.outlineWidthMultiplyTexture;
+  if (atlasMap.uvAnimationMaskTexture)
+    material.uvAnimationMaskTexture = atlasMap.uvAnimationMaskTexture;
+}
+function getMToonMaterialInfoFromObject3D(rootNode) {
+  const meshes = [];
+  rootNode.traverse((obj) => {
+    if (obj instanceof Mesh) {
+      meshes.push(obj);
+    }
+  });
+  const materialInfoMap = /* @__PURE__ */ new Map();
+  for (const mesh of meshes) {
+    if (Array.isArray(mesh.material)) {
+      if (mesh.material.length === 0) continue;
+      if (!(mesh.material[0] instanceof MToonMaterial)) continue;
+      const material = mesh.material[0];
+      const hasOutline = material.outlineWidthMode !== "none";
+      const outlineWidthMode = material.outlineWidthMode;
+      if (!materialInfoMap.has(material)) {
+        materialInfoMap.set(material, {
+          meshes: [],
+          hasOutline,
+          outlineWidthMode,
+          renderMode: getRenderMode(material)
+        });
+      }
+      materialInfoMap.get(material).meshes.push(mesh);
+    } else if (mesh.material instanceof MToonMaterial) {
+      const material = mesh.material;
+      const hasOutline = material.outlineWidthMode !== "none";
+      const outlineWidthMode = material.outlineWidthMode;
+      if (!materialInfoMap.has(material)) {
+        materialInfoMap.set(material, {
+          meshes: [],
+          hasOutline,
+          outlineWidthMode,
+          renderMode: getRenderMode(material)
+        });
+      }
+      materialInfoMap.get(material).meshes.push(mesh);
+    }
+  }
+  if (materialInfoMap.size === 0) {
+    return err({
+      type: "ASSET_ERROR",
+      message: "MToonMaterial\u304C\u3042\u308A\u307E\u305B\u3093"
+    });
+  }
+  const result = [];
+  for (const [material, info] of materialInfoMap) {
+    result.push({
+      material,
+      meshes: info.meshes,
+      hasOutline: info.hasOutline,
+      outlineWidthMode: info.outlineWidthMode,
+      renderMode: info.renderMode
+    });
+  }
+  return ok(result);
+}
+
+// src/util/mesh/deleter.ts
+function deleteMesh(mesh) {
+  if (Array.isArray(mesh.material)) {
+    mesh.material.forEach((m) => m.dispose());
+  } else {
+    mesh.material.dispose();
+  }
+  mesh.geometry.dispose();
+}
+function migrateSkeletonVRM0ToVRM1(rootNode, options = {}) {
+  return safeTry(function* () {
+    const skinnedMeshes = [];
+    rootNode.traverse((obj) => {
+      if (obj instanceof SkinnedMesh) {
+        skinnedMeshes.push(obj);
+      }
+    });
+    if (skinnedMeshes.length === 0) {
+      return err({
+        type: "ASSET_ERROR",
+        message: "SkinnedMesh\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093"
+      });
+    }
+    if (!options.skipVertexRotation) {
+      rotateAllVertexBuffers(skinnedMeshes);
+    }
+    if (!options.skipBoneTransform) {
+      const allBonePositions = /* @__PURE__ */ new Map();
+      const processedSkeletons = /* @__PURE__ */ new Set();
+      for (const mesh of skinnedMeshes) {
+        const skeleton = mesh.skeleton;
+        if (!skeleton || processedSkeletons.has(skeleton)) continue;
+        processedSkeletons.add(skeleton);
+        const positions = recordBoneWorldPositions(skeleton);
+        for (const [bone, pos] of positions) {
+          if (!allBonePositions.has(bone)) {
+            allBonePositions.set(bone, pos);
+          }
+        }
+      }
+      const rotatedPositions = rotateBonePositions(allBonePositions);
+      const allRootBones = /* @__PURE__ */ new Set();
+      for (const bone of allBonePositions.keys()) {
+        let current = bone;
+        while (current.parent instanceof Bone) {
+          current = current.parent;
+        }
+        allRootBones.add(current);
+      }
+      if (allRootBones.size === 0) {
+        return err({
+          type: "ASSET_ERROR",
+          message: "\u30EB\u30FC\u30C8\u30DC\u30FC\u30F3\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093"
+        });
+      }
+      for (const rootBone of allRootBones) {
+        rebuildBoneTransforms(rootBone, rotatedPositions, options.humanoidBones);
+      }
+      processedSkeletons.forEach((skeleton) => {
+        recalculateBoneInverses(skeleton);
+      });
+    }
+    if (!options.skipBindMatrix) {
+      for (const mesh of skinnedMeshes) {
+        mesh.skeleton.calculateInverses();
+      }
+    }
+    return ok(void 0);
+  });
+}
+function rotateAllVertexBuffers(skinnedMeshes) {
+  function rotateVec3Array(array) {
+    const count = array.length / 3;
+    for (let i = 0; i < count; i++) {
+      const baseIdx = i * 3;
+      array[baseIdx + 0] = -array[baseIdx + 0];
+      array[baseIdx + 2] = -array[baseIdx + 2];
+    }
+  }
+  function rotateAndSetAttribute(geometry, attrName, attr) {
+    if (attr.itemSize !== 3) return;
+    const rotated = editBufferAttribute(attr, rotateVec3Array);
+    geometry.setAttribute(attrName, rotated);
+  }
+  const processedGeometries = /* @__PURE__ */ new Set();
+  for (const mesh of skinnedMeshes) {
+    const geometry = mesh.geometry;
+    if (processedGeometries.has(geometry)) {
+      continue;
+    }
+    processedGeometries.add(geometry);
+    const posAttr = geometry.getAttribute("position");
+    if (posAttr) {
+      rotateAndSetAttribute(geometry, "position", posAttr);
+    }
+    const normalAttr = geometry.getAttribute("normal");
+    if (normalAttr) {
+      rotateAndSetAttribute(geometry, "normal", normalAttr);
+    }
+    const morphPositions = geometry.morphAttributes.position;
+    if (morphPositions && Array.isArray(morphPositions)) {
+      for (let i = 0; i < morphPositions.length; i++) {
+        const morphAttr = morphPositions[i];
+        if (morphAttr.itemSize !== 3) continue;
+        const array = morphAttr.array;
+        rotateVec3Array(array);
+        morphAttr.needsUpdate = true;
+      }
+    }
+    const morphNormals = geometry.morphAttributes.normal;
+    if (morphNormals && Array.isArray(morphNormals)) {
+      for (let i = 0; i < morphNormals.length; i++) {
+        const morphAttr = morphNormals[i];
+        if (morphAttr.itemSize !== 3) continue;
+        const array = morphAttr.array;
+        rotateVec3Array(array);
+        morphAttr.needsUpdate = true;
+      }
+    }
+    geometry.dispatchEvent({ type: "dispose" });
+  }
+}
+function recordBoneWorldPositions(skeleton) {
+  const positions = /* @__PURE__ */ new Map();
+  if (skeleton.bones.length > 0) {
+    skeleton.bones[0].updateWorldMatrix(true, true);
+  }
+  for (const bone of skeleton.bones) {
+    const worldPos = new Vector3();
+    bone.getWorldPosition(worldPos);
+    positions.set(bone, worldPos.clone());
+  }
+  return positions;
+}
+function rotateBonePositions(positions) {
+  const rotated = /* @__PURE__ */ new Map();
+  const rotationMatrix = new Matrix4().makeRotationY(Math.PI);
+  for (const [bone, pos] of positions) {
+    const newPos = pos.clone().applyMatrix4(rotationMatrix);
+    rotated.set(bone, newPos);
+  }
+  return rotated;
+}
+function rebuildBoneTransforms(rootBone, rotatedPositions, humanoidBones) {
+  const identityQuat = new Quaternion();
+  const rotationMatrix = new Matrix4().makeRotationY(Math.PI);
+  const rotationQuat = new Quaternion().setFromRotationMatrix(rotationMatrix);
+  function processBone(bone, parentWorldMatrix2) {
+    let targetWorldPos = rotatedPositions.get(bone);
+    if (!targetWorldPos) {
+      bone.updateMatrixWorld(true);
+      const currentWorldPos = new Vector3();
+      bone.getWorldPosition(currentWorldPos);
+      targetWorldPos = currentWorldPos.applyMatrix4(rotationMatrix);
+    }
+    const parentWorldMatrixInverse = parentWorldMatrix2.clone().invert();
+    const isHumanoidBone = humanoidBones?.has(bone) ?? true;
+    if (isHumanoidBone) {
+      bone.quaternion.copy(identityQuat);
+      const parentWorldPos = new Vector3().setFromMatrixPosition(
+        parentWorldMatrix2
+      );
+      const localPos = targetWorldPos.clone().sub(parentWorldPos);
+      bone.position.copy(localPos);
+    } else {
+      const originalLocalQuat = bone.quaternion.clone();
+      const newLocalQuat = rotationQuat.clone().multiply(originalLocalQuat).multiply(rotationQuat.clone().invert());
+      bone.quaternion.copy(newLocalQuat);
+      const localPos = targetWorldPos.clone().applyMatrix4(parentWorldMatrixInverse);
+      bone.position.copy(localPos);
+    }
+    bone.updateMatrix();
+    bone.updateMatrixWorld(true);
+    for (const child of bone.children) {
+      if (child instanceof Bone) {
+        processBone(child, bone.matrixWorld);
+      }
+    }
+  }
+  let parentWorldMatrix = new Matrix4();
+  if (rootBone.parent) {
+    rootBone.parent.updateMatrixWorld(true);
+    parentWorldMatrix = rootBone.parent.matrixWorld.clone();
+  }
+  processBone(rootBone, parentWorldMatrix);
+}
+function recalculateBoneInverses(skeleton) {
+  skeleton.bones.forEach((bone) => bone.updateMatrixWorld(true));
+  skeleton.calculateInverses();
+  skeleton.computeBoneTexture();
+}
+function createVirtualTailNodes(vrm, preRecordedDirections) {
+  const createdTailNodes = [];
+  if (!vrm.springBoneManager) return createdTailNodes;
+  const springBoneManager = vrm.springBoneManager;
+  const joints = springBoneManager.joints;
+  if (!joints || joints.size === 0) return createdTailNodes;
+  joints.forEach((joint) => {
+    const bone = joint.bone;
+    if (!bone) return;
+    const hasJointChild = joint.child != null;
+    const hasBoneChild = bone.children.some(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (child) => child.type === "Bone" || child.isBone
+    );
+    if (!hasJointChild && !hasBoneChild) {
+      const tailBone = new Bone();
+      tailBone.name = `${bone.name}_tail`;
+      let direction;
+      if (preRecordedDirections?.has(bone)) {
+        direction = preRecordedDirections.get(bone).clone().multiplyScalar(0.07);
+      } else {
+        direction = new Vector3().copy(bone.position);
+        if (direction.lengthSq() > 0) {
+          direction.normalize().multiplyScalar(0.07);
+        } else {
+          direction.set(0, 0.07, 0);
+        }
+      }
+      tailBone.position.copy(direction);
+      bone.add(tailBone);
+      tailBone.updateMatrixWorld(true);
+      createdTailNodes.push(tailBone);
+    }
+  });
+  return createdTailNodes;
+}
+function rotateSpringBoneGravityDirections(vrm) {
+  if (!vrm.springBoneManager) {
+    return;
+  }
+  const springBoneManager = vrm.springBoneManager;
+  const joints = springBoneManager.joints;
+  if (!joints || joints.size === 0) {
+    return;
+  }
+  const rotationMatrix = new Matrix4().makeRotationY(Math.PI);
+  joints.forEach((joint) => {
+    const settings = joint.settings;
+    if (!settings || !settings.gravityDir) return;
+    const gravityDir = settings.gravityDir;
+    gravityDir.applyMatrix4(rotationMatrix);
+  });
+}
+function rotateSpringBoneColliderOffsets(vrm) {
+  if (!vrm.springBoneManager) {
+    return;
+  }
+  const colliders = vrm.springBoneManager.colliders;
+  if (!colliders || colliders.length === 0) {
+    return;
+  }
+  const rotationMatrix = new Matrix4().makeRotationY(Math.PI);
+  for (const collider of colliders) {
+    const shape = collider.shape;
+    const shapeAny = shape;
+    if (shapeAny.offset instanceof Vector3) {
+      shapeAny.offset.applyMatrix4(rotationMatrix);
+    }
+    if (shapeAny.tail instanceof Vector3) {
+      shapeAny.tail.applyMatrix4(rotationMatrix);
+    }
+  }
+}
+function migrateSpringBone(vrm) {
+  const tailNodes = createVirtualTailNodes(vrm);
+  rotateSpringBoneGravityDirections(vrm);
+  rotateSpringBoneColliderOffsets(vrm);
+  vrm.springBoneManager?.setInitState();
+  vrm.springBoneManager?.reset();
+  return tailNodes;
+}
+
+// src/avatar-optimizer.ts
+function optimizeModel(vrm, options = {}) {
+  return safeTry(async function* () {
+    const rootNode = vrm.scene;
+    vrm.springBoneManager?.reset();
+    const materialInfos = yield* getMToonMaterialInfoFromObject3D(rootNode);
+    const materials = materialInfos.map((info) => info.material);
+    const materialMeshMap = /* @__PURE__ */ new Map();
+    for (const info of materialInfos) {
+      materialMeshMap.set(info.material, info.meshes);
+    }
+    const patternMappings = buildPatternMaterialMappings(materials);
+    const packLayouts = yield* await pack(patternMappings);
+    const atlasMap = yield* generateAtlasImagesFromPatterns(
+      materials,
+      patternMappings,
+      packLayouts.packed,
+      options.atlas
+    );
+    const materialPlacementMap = /* @__PURE__ */ new Map();
+    patternMappings.forEach((mapping, index) => {
+      const placement = packLayouts.packed[index];
+      for (const materialIndex of mapping.materialIndices) {
+        const material = materials[materialIndex];
+        assignAtlasTexturesToMaterial(material, atlasMap);
+        materialPlacementMap.set(material, placement);
+      }
+    });
+    yield* applyPlacementsToGeometries(rootNode, materialPlacementMap);
+    const excludedMeshes = /* @__PURE__ */ new Set();
+    if (vrm.expressionManager) {
+      for (const expression of vrm.expressionManager.expressions) {
+        for (const bind of expression.binds) {
+          const bindAny = bind;
+          if (bindAny.primitives) {
+            for (const mesh of bindAny.primitives) {
+              if (mesh && mesh.isMesh) {
+                excludedMeshes.add(mesh);
+              }
+            }
+          }
+          if (bindAny.material) {
+            const meshes = materialMeshMap.get(bindAny.material);
+            if (meshes) {
+              meshes.forEach((mesh) => excludedMeshes.add(mesh));
+            }
+          }
+        }
+      }
+    }
+    let simplifyStats;
+    if (options.simplify) {
+      simplifyStats = yield* await simplifyMeshes(
+        rootNode,
+        excludedMeshes,
+        options.simplify
+      );
+    }
+    const combineResult = yield* combineMToonMaterials(
+      materialInfos,
+      {},
+      excludedMeshes
+    );
+    const firstGroup = combineResult.groups.values().next().value;
+    const slotAttributeName = firstGroup?.material.slotAttribute?.name || "mtoonMaterialSlot";
+    for (const mesh of excludedMeshes) {
+      const originalMaterial = Array.isArray(mesh.material) ? mesh.material[0] : mesh.material;
+      if (!(originalMaterial instanceof MToonMaterial)) continue;
+      const slotInfo = combineResult.materialSlotIndex.get(originalMaterial);
+      if (!slotInfo) continue;
+      const group = combineResult.groups.get(slotInfo.renderMode);
+      if (!group) continue;
+      const geometry = mesh.geometry;
+      const vertexCount = geometry.getAttribute("position").count;
+      const slotArray = new Float32Array(vertexCount).fill(slotInfo.slotIndex);
+      geometry.setAttribute(
+        slotAttributeName,
+        new BufferAttribute(slotArray, 1)
+      );
+      mesh.material = group.material;
+    }
+    const meshesToRemove = [];
+    for (const meshes of materialMeshMap.values()) {
+      for (const mesh of meshes) {
+        if (!excludedMeshes.has(mesh)) {
+          meshesToRemove.push(mesh);
+        }
+      }
+    }
+    const firstMeshParent = meshesToRemove[0]?.parent || rootNode;
+    meshesToRemove.forEach((mesh) => mesh.parent?.remove(mesh));
+    for (const mesh of meshesToRemove) {
+      deleteMesh(mesh);
+    }
+    for (const group of combineResult.groups.values()) {
+      if (group.outlineMesh) {
+        firstMeshParent.add(group.outlineMesh);
+      }
+      if (group.mesh) {
+        firstMeshParent.add(group.mesh);
+      }
+    }
+    if (options.migrateVRM0ToVRM1) {
+      const springBoneManager = vrm.springBoneManager;
+      vrm.springBoneManager = null;
+      springBoneManager?.reset();
+      const humanoidBones = /* @__PURE__ */ new Set();
+      if (vrm.humanoid) {
+        Object.values(vrm.humanoid.humanBones).forEach((humanBone) => {
+          const node = humanBone.node;
+          if (node instanceof Bone) {
+            humanoidBones.add(node);
+          }
+        });
+      }
+      yield* migrateSkeletonVRM0ToVRM1(rootNode, { humanoidBones });
+      vrm.springBoneManager = springBoneManager;
+      migrateSpringBone(vrm);
+    }
+    if (simplifyStats) {
+      combineResult.statistics.simplify = simplifyStats;
+    }
+    return ok(combineResult);
+  });
+}
+var VRMExporterPlugin = class {
+  constructor(writer) {
+    this.name = "VRMC_vrm";
+    this.vrm = null;
+    // 動的に作成されたtailノードを追跡（エクスポート後にクリーンアップするため）
+    this.createdTailNodes = [];
+    this.writer = writer;
+  }
+  setVRM(vrm) {
+    this.vrm = vrm;
+  }
+  beforeParse(input) {
+    const root = Array.isArray(input) ? input[0] : input;
+    if (!root) return;
+    root.traverse((obj) => {
+      if (obj.userData && obj.userData.vrm && !this.vrm) {
+        this.vrm = obj.userData.vrm;
+      }
+    });
+    this.createVirtualTailNodes();
+  }
+  /**
+   * SpringBone末端ジョイントに仮想tailノードを作成
+   * three-vrmと同様に、ボーン方向に7cmのオフセットを持つ仮想ノードを追加
+   */
+  createVirtualTailNodes() {
+    if (!this.vrm?.springBoneManager) return;
+    const springBoneManager = this.vrm.springBoneManager;
+    const joints = springBoneManager.joints;
+    if (!joints || joints.size === 0) return;
+    const jointsByBone = /* @__PURE__ */ new Map();
+    joints.forEach((joint) => {
+      jointsByBone.set(joint.bone, joint);
+    });
+    joints.forEach((joint) => {
+      const bone = joint.bone;
+      if (!bone) return;
+      const hasJointChild = joint.child != null;
+      const hasBoneChild = bone.children.some(
+        (child) => child.type === "Bone" || child.isBone
+      );
+      if (!hasJointChild && !hasBoneChild) {
+        const tailBone = new Bone();
+        tailBone.name = `${bone.name}_tail`;
+        const direction = new Vector3().copy(bone.position);
+        if (direction.lengthSq() > 0) {
+          direction.normalize().multiplyScalar(0.07);
+        } else {
+          direction.set(0, 0.07, 0);
+        }
+        tailBone.position.copy(direction);
+        bone.add(tailBone);
+        tailBone.updateMatrixWorld(true);
+        this.createdTailNodes.push(tailBone);
+      }
+    });
+  }
+  /**
+   * エクスポート後に作成した仮想tailノードをクリーンアップ
+   */
+  cleanupTailNodes() {
+    for (const tailNode of this.createdTailNodes) {
+      if (tailNode.parent) {
+        tailNode.parent.remove(tailNode);
+      }
+    }
+    this.createdTailNodes = [];
+  }
+  afterParse(_input) {
+    if (!this.vrm) {
+      return;
+    }
+    const json = this.writer.json;
+    const vrm = this.vrm;
+    json.extensions = json.extensions || {};
+    json.extensions.VRMC_vrm = {
+      specVersion: "1.0",
+      meta: this.exportMeta(vrm),
+      humanoid: this.exportHumanoid(vrm),
+      expressions: this.exportExpressions(vrm),
+      lookAt: this.exportLookAt(vrm),
+      firstPerson: this.exportFirstPerson(vrm)
+    };
+    json.extensionsUsed = json.extensionsUsed || [];
+    if (!json.extensionsUsed.includes("VRMC_vrm")) {
+      json.extensionsUsed.push("VRMC_vrm");
+    }
+    const springBoneExtension = this.exportSpringBone(vrm);
+    if (springBoneExtension) {
+      json.extensions.VRMC_springBone = springBoneExtension;
+      if (!json.extensionsUsed.includes("VRMC_springBone")) {
+        json.extensionsUsed.push("VRMC_springBone");
+      }
+    }
+  }
+  exportMeta(vrm) {
+    if (!vrm.meta) return void 0;
+    const meta = vrm.meta;
+    let licenseUrl = meta.licenseUrl;
+    if (!licenseUrl && meta.licenseName) {
+      const licenseMapping = {
+        Redistribution_Prohibited: "https://vrm.dev/licenses/1.0/",
+        CC0: "https://creativecommons.org/publicdomain/zero/1.0/",
+        CC_BY: "https://creativecommons.org/licenses/by/4.0/",
+        CC_BY_NC: "https://creativecommons.org/licenses/by-nc/4.0/",
+        CC_BY_SA: "https://creativecommons.org/licenses/by-sa/4.0/",
+        CC_BY_NC_SA: "https://creativecommons.org/licenses/by-nc-sa/4.0/",
+        CC_BY_ND: "https://creativecommons.org/licenses/by-nd/4.0/",
+        CC_BY_NC_ND: "https://creativecommons.org/licenses/by-nc-nd/4.0/",
+        Other: "https://vrm.dev/licenses/1.0/"
+      };
+      licenseUrl = licenseMapping[meta.licenseName] ?? "https://vrm.dev/licenses/1.0/";
+    }
+    if (!licenseUrl) {
+      licenseUrl = "https://vrm.dev/licenses/1.0/";
+    }
+    return {
+      name: meta.name ?? meta.title,
+      version: meta.version,
+      authors: meta.authors ?? (meta.author ? [meta.author] : void 0),
+      copyrightInformation: meta.copyrightInformation,
+      contactInformation: meta.contactInformation,
+      references: meta.references ?? (meta.reference ? [meta.reference] : void 0),
+      thirdPartyLicenses: meta.thirdPartyLicenses,
+      thumbnailImage: meta.thumbnailImage ? this.writer.processTexture(meta.thumbnailImage) : void 0,
+      licenseUrl,
+      avatarPermission: meta.avatarPermission ?? "onlyAuthor",
+      allowExcessivelyViolentUsage: meta.allowExcessivelyViolentUsage ?? false,
+      allowExcessivelySexualUsage: meta.allowExcessivelySexualUsage ?? false,
+      commercialUsage: meta.commercialUsage ?? "personalNonProfit",
+      allowPoliticalOrReligiousUsage: meta.allowPoliticalOrReligiousUsage ?? false,
+      allowAntisocialOrHateUsage: meta.allowAntisocialOrHateUsage ?? false,
+      creditNotation: meta.creditNotation ?? "required",
+      allowRedistribution: meta.allowRedistribution ?? false,
+      modification: meta.modification ?? "prohibited"
+    };
+  }
+  exportHumanoid(vrm) {
+    if (!vrm.humanoid) return void 0;
+    const humanBones = {};
+    Object.entries(vrm.humanoid.humanBones).forEach(([name, bone]) => {
+      if (bone && bone.node) {
+        const nodeIndex = this.writer.nodeMap.get(bone.node);
+        if (nodeIndex !== void 0) {
+          humanBones[name] = { node: nodeIndex };
+        }
+      }
+    });
+    return {
+      humanBones
+    };
+  }
+  exportExpressions(vrm) {
+    if (!vrm.expressionManager) return void 0;
+    const presetNames = /* @__PURE__ */ new Set([
+      "happy",
+      "angry",
+      "sad",
+      "relaxed",
+      "surprised",
+      "aa",
+      "ih",
+      "ou",
+      "ee",
+      "oh",
+      "blink",
+      "blinkLeft",
+      "blinkRight",
+      "lookUp",
+      "lookDown",
+      "lookLeft",
+      "lookRight",
+      "neutral"
+    ]);
+    const preset = {};
+    const custom = {};
+    if (vrm.expressionManager.expressions) {
+      vrm.expressionManager.expressions.forEach((expression) => {
+        const expr = expression;
+        const exprDef = {};
+        if (expr.isBinary) exprDef.isBinary = expr.isBinary;
+        if (expr.overrideBlink && expr.overrideBlink !== "none")
+          exprDef.overrideBlink = expr.overrideBlink;
+        if (expr.overrideLookAt && expr.overrideLookAt !== "none")
+          exprDef.overrideLookAt = expr.overrideLookAt;
+        if (expr.overrideMouth && expr.overrideMouth !== "none")
+          exprDef.overrideMouth = expr.overrideMouth;
+        const binds = expr._binds || expr.binds || [];
+        const morphTargetBinds = binds.filter(
+          (b) => b.type === "morphTarget" || b.primitives
+        );
+        if (morphTargetBinds.length > 0) {
+          const allBinds = [];
+          morphTargetBinds.forEach((bind) => {
+            const primitives = bind.primitives || [];
+            primitives.forEach((mesh) => {
+              const nodeIndex = this.writer.nodeMap.get(mesh);
+              if (nodeIndex !== void 0) {
+                allBinds.push({
+                  node: nodeIndex,
+                  index: bind.index,
+                  weight: bind.weight
+                });
+              }
+            });
+          });
+          if (allBinds.length > 0) {
+            exprDef.morphTargetBinds = allBinds;
+          }
+        }
+        if (expr.materialColorBinds && expr.materialColorBinds.length > 0) {
+          exprDef.materialColorBinds = expr.materialColorBinds.map(
+            (bind) => {
+              const materialIndex = this.writer.processMaterial(bind.material);
+              return {
+                material: materialIndex,
+                type: bind.type,
+                targetValue: bind.targetValue.toArray()
+              };
+            }
+          );
+        }
+        if (expr.textureTransformBinds && expr.textureTransformBinds.length > 0) {
+          exprDef.textureTransformBinds = expr.textureTransformBinds.map(
+            (bind) => {
+              const materialIndex = this.writer.processMaterial(bind.material);
+              return {
+                material: materialIndex,
+                scale: bind.scale.toArray(),
+                offset: bind.offset.toArray()
+              };
+            }
+          );
+        }
+        const name = expr.expressionName;
+        if (presetNames.has(name)) {
+          preset[name] = exprDef;
+        } else {
+          custom[name] = exprDef;
+        }
+      });
+    }
+    const result = { preset };
+    if (Object.keys(custom).length > 0) {
+      result.custom = custom;
+    }
+    return result;
+  }
+  exportLookAt(vrm) {
+    if (!vrm.lookAt) return void 0;
+    const lookAt = vrm.lookAt;
+    const defaultRangeMap = { inputMaxValue: 90, outputScale: 10 };
+    return {
+      offsetFromHeadBone: lookAt.offsetFromHeadBone?.toArray?.() ?? [0, 0, 0],
+      type: lookAt.applier?.type ?? "bone",
+      // 'bone' or 'expression'
+      rangeMapHorizontalInner: lookAt.rangeMapHorizontalInner ? {
+        inputMaxValue: lookAt.rangeMapHorizontalInner.inputMaxValue,
+        outputScale: lookAt.rangeMapHorizontalInner.outputScale
+      } : defaultRangeMap,
+      rangeMapHorizontalOuter: lookAt.rangeMapHorizontalOuter ? {
+        inputMaxValue: lookAt.rangeMapHorizontalOuter.inputMaxValue,
+        outputScale: lookAt.rangeMapHorizontalOuter.outputScale
+      } : defaultRangeMap,
+      rangeMapVerticalDown: lookAt.rangeMapVerticalDown ? {
+        inputMaxValue: lookAt.rangeMapVerticalDown.inputMaxValue,
+        outputScale: lookAt.rangeMapVerticalDown.outputScale
+      } : defaultRangeMap,
+      rangeMapVerticalUp: lookAt.rangeMapVerticalUp ? {
+        inputMaxValue: lookAt.rangeMapVerticalUp.inputMaxValue,
+        outputScale: lookAt.rangeMapVerticalUp.outputScale
+      } : defaultRangeMap
+    };
+  }
+  exportFirstPerson(vrm) {
+    if (!vrm.firstPerson) return void 0;
+    const meshAnnotations = [];
+    if (vrm.firstPerson.meshAnnotations) {
+      vrm.firstPerson.meshAnnotations.forEach((annotation) => {
+        const ann = annotation;
+        const mesh = ann.mesh || ann.node;
+        const nodeIndex = this.writer.nodeMap.get(mesh);
+        if (nodeIndex !== void 0) {
+          meshAnnotations.push({
+            node: nodeIndex,
+            type: ann.type
+          });
+        }
+      });
+    }
+    return {
+      meshAnnotations
+    };
+  }
+  /**
+   * VRMC_springBone 拡張をエクスポート
+   * three-vrm の VRMSpringBoneManager から SpringBone データを抽出
+   */
+  exportSpringBone(vrm) {
+    const springBoneManager = vrm.springBoneManager;
+    if (!springBoneManager) return void 0;
+    const joints = springBoneManager.joints;
+    if (!joints || joints.size === 0) return void 0;
+    const colliders = springBoneManager.colliders;
+    const colliderIndexMap = /* @__PURE__ */ new Map();
+    const colliderDefs = [];
+    colliders.forEach((collider) => {
+      const nodeIndex = this.writer.nodeMap.get(collider);
+      if (nodeIndex === void 0) return;
+      const shape = collider.shape;
+      let shapeDef;
+      if (shape.type === "sphere") {
+        shapeDef = {
+          sphere: {
+            offset: shape.offset ? [shape.offset.x, shape.offset.y, shape.offset.z] : [0, 0, 0],
+            radius: shape.radius ?? 0
+          }
+        };
+      } else if (shape.type === "capsule") {
+        shapeDef = {
+          capsule: {
+            offset: shape.offset ? [shape.offset.x, shape.offset.y, shape.offset.z] : [0, 0, 0],
+            radius: shape.radius ?? 0,
+            tail: shape.tail ? [shape.tail.x, shape.tail.y, shape.tail.z] : [0, 0, 0]
+          }
+        };
+      } else {
+        return;
+      }
+      const colliderIndex = colliderDefs.length;
+      colliderIndexMap.set(collider, colliderIndex);
+      colliderDefs.push({
+        node: nodeIndex,
+        shape: shapeDef
+      });
+    });
+    const colliderGroups = springBoneManager.colliderGroups;
+    const colliderGroupIndexMap = /* @__PURE__ */ new Map();
+    const colliderGroupDefs = [];
+    colliderGroups.forEach((group) => {
+      const colliderIndices = [];
+      group.colliders.forEach((collider) => {
+        const index = colliderIndexMap.get(collider);
+        if (index !== void 0) {
+          colliderIndices.push(index);
+        }
+      });
+      if (colliderIndices.length > 0) {
+        const groupIndex = colliderGroupDefs.length;
+        colliderGroupIndexMap.set(group, groupIndex);
+        colliderGroupDefs.push({
+          name: group.name,
+          colliders: colliderIndices
+        });
+      }
+    });
+    const springDefs = [];
+    const processedJoints = /* @__PURE__ */ new Set();
+    const jointsByBone = /* @__PURE__ */ new Map();
+    joints.forEach((joint) => {
+      jointsByBone.set(joint.bone, joint);
+    });
+    joints.forEach((joint) => {
+      if (processedJoints.has(joint)) return;
+      const parentBone = joint.bone.parent;
+      if (parentBone && jointsByBone.has(parentBone)) {
+        return;
+      }
+      const chainJoints = [];
+      let currentJoint = joint;
+      while (currentJoint && !processedJoints.has(currentJoint)) {
+        processedJoints.add(currentJoint);
+        chainJoints.push(currentJoint);
+        const childBone = currentJoint.child;
+        currentJoint = childBone ? jointsByBone.get(childBone) : null;
+      }
+      if (chainJoints.length === 0) return;
+      const jointDefs = [];
+      for (let i = 0; i < chainJoints.length; i++) {
+        const j = chainJoints[i];
+        const nodeIndex = this.writer.nodeMap.get(j.bone);
+        if (nodeIndex === void 0) continue;
+        jointDefs.push({
+          node: nodeIndex,
+          hitRadius: j.settings.hitRadius,
+          stiffness: j.settings.stiffness,
+          gravityPower: j.settings.gravityPower,
+          gravityDir: j.settings.gravityDir ? [
+            j.settings.gravityDir.x,
+            j.settings.gravityDir.y,
+            j.settings.gravityDir.z
+          ] : [0, -1, 0],
+          dragForce: j.settings.dragForce
+        });
+      }
+      const lastJoint = chainJoints[chainJoints.length - 1];
+      let tailNode = lastJoint?.child;
+      if (!tailNode && lastJoint?.bone) {
+        const boneChildren = lastJoint.bone.children.filter(
+          (child) => child.type === "Bone" || child.isBone
+        );
+        if (boneChildren.length > 0) {
+          tailNode = boneChildren[0];
+        }
+      }
+      if (tailNode) {
+        const tailNodeIndex = this.writer.nodeMap.get(tailNode);
+        if (tailNodeIndex !== void 0) {
+          jointDefs.push({
+            node: tailNodeIndex
+          });
+        }
+      }
+      if (jointDefs.length === 0) return;
+      const colliderGroupIndices = [];
+      const firstJoint = chainJoints[0];
+      if (firstJoint.colliderGroups) {
+        firstJoint.colliderGroups.forEach((group) => {
+          const index = colliderGroupIndexMap.get(group);
+          if (index !== void 0 && !colliderGroupIndices.includes(index)) {
+            colliderGroupIndices.push(index);
+          }
+        });
+      }
+      let centerNodeIndex;
+      if (firstJoint.center) {
+        centerNodeIndex = this.writer.nodeMap.get(firstJoint.center);
+      }
+      const springDef = {
+        joints: jointDefs
+      };
+      if (centerNodeIndex !== void 0) {
+        springDef.center = centerNodeIndex;
+      }
+      if (colliderGroupIndices.length > 0) {
+        springDef.colliderGroups = colliderGroupIndices;
+      }
+      springDefs.push(springDef);
+    });
+    if (springDefs.length === 0 && colliderDefs.length === 0) {
+      return void 0;
+    }
+    const result = {
+      specVersion: "1.0"
+    };
+    if (colliderDefs.length > 0) {
+      result.colliders = colliderDefs;
+    }
+    if (colliderGroupDefs.length > 0) {
+      result.colliderGroups = colliderGroupDefs;
+    }
+    if (springDefs.length > 0) {
+      result.springs = springDefs;
+    }
+    return result;
+  }
+};
+
+// src/io/export.ts
+function exportVRM(vrm, options = {}) {
+  const { binary = true, textureCompression } = options;
+  const initPromise = textureCompression ? initBasisEncoder().map(() => void 0).mapErr((err10) => ({
+    type: "EXPORT_FAILED",
+    message: `Basis WASM \u521D\u671F\u5316\u306B\u5931\u6557: ${err10.message}`
+  })) : okAsync(void 0);
+  return initPromise.andThen(
+    () => ResultAsync.fromPromise(
+      new Promise((resolve, reject) => {
+        vrm.springBoneManager?.reset();
+        vrm.springBoneManager?.setInitState();
+        const exporter = new GLTFExporter();
+        exporter.register((writer) => {
+          const plugin = new MToonAtlasExporterPlugin(writer);
+          if (textureCompression) {
+            plugin.setTextureCompressionOptions(textureCompression);
+          }
+          return plugin;
+        });
+        exporter.register((writer) => {
+          const plugin = new VRMExporterPlugin(writer);
+          plugin.setVRM(vrm);
+          return plugin;
+        });
+        const exportScene = new Scene();
+        const children = [...vrm.scene.children].filter(
+          (child) => child.name !== "VRMHumanoidRig" && !child.name.startsWith("VRMExpression")
+        );
+        children.forEach((child) => exportScene.add(child));
+        exporter.parse(
+          exportScene,
+          (result) => {
+            children.forEach((child) => vrm.scene.add(child));
+            try {
+              if (result instanceof ArrayBuffer) {
+                resolve(result);
+              } else {
+                const jsonString = JSON.stringify(result);
+                const encoder = new TextEncoder();
+                resolve(encoder.encode(jsonString).buffer);
+              }
+            } catch (err10) {
+              reject(err10);
+            }
+          },
+          (error) => {
+            children.forEach((child) => vrm.scene.add(child));
+            reject(error);
+          },
+          {
+            binary,
+            trs: false,
+            onlyVisible: true
+          }
+        );
+      }),
+      (error) => ({
+        type: "EXPORT_FAILED",
+        message: `Failed to export VRM: ${String(error)}`
+      })
+    )
+  );
+}
+var ktx2LoaderInstance = null;
+function getKTX2Loader() {
+  if (ktx2LoaderInstance) {
+    return ktx2LoaderInstance;
+  }
+  if (typeof document === "undefined" || typeof WebGLRenderingContext === "undefined") {
+    return null;
+  }
+  try {
+    const canvas = document.createElement("canvas");
+    const gl = canvas.getContext("webgl2");
+    if (!gl) {
+      console.warn(
+        "WebGL2 \u304C\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\u3002KTX2 \u30C6\u30AF\u30B9\u30C1\u30E3\u306F\u8AAD\u307F\u8FBC\u3081\u307E\u305B\u3093\u3002"
+      );
+      return null;
+    }
+    const renderer = new WebGLRenderer({
+      canvas,
+      context: gl
+    });
+    ktx2LoaderInstance = new KTX2Loader();
+    ktx2LoaderInstance.setTranscoderPath(
+      "https://cdn.jsdelivr.net/npm/three@0.175.0/examples/jsm/libs/basis/"
+    );
+    ktx2LoaderInstance.detectSupport(renderer);
+    console.log("KTX2Loader \u521D\u671F\u5316\u5B8C\u4E86");
+    renderer.dispose();
+    return ktx2LoaderInstance;
+  } catch (error) {
+    console.warn(
+      "KTX2Loader \u306E\u521D\u671F\u5316\u306B\u5931\u6557\u3057\u307E\u3057\u305F\u3002KTX2 \u30C6\u30AF\u30B9\u30C1\u30E3\u306F\u8AAD\u307F\u8FBC\u3081\u307E\u305B\u3093\u3002",
+      error
+    );
+    return null;
+  }
+}
+function loadVRM(source) {
+  return ResultAsync.fromPromise(
+    (async () => {
+      const loader = new GLTFLoader();
+      const ktx2Loader = getKTX2Loader();
+      if (ktx2Loader) {
+        loader.setKTX2Loader(ktx2Loader);
+      }
+      loader.register((parser) => new VRMLoaderPlugin(parser));
+      loader.register((parser) => new MToonAtlasLoaderPlugin(parser));
+      let gltf;
+      let blobUrl = null;
+      try {
+        if (typeof source === "string") {
+          gltf = await loader.loadAsync(source);
+        } else if (source instanceof ArrayBuffer) {
+          const blob = new Blob([source], { type: "model/gltf-binary" });
+          blobUrl = URL.createObjectURL(blob);
+          gltf = await loader.loadAsync(blobUrl);
+        } else {
+          blobUrl = URL.createObjectURL(source);
+          gltf = await loader.loadAsync(blobUrl);
+        }
+        const vrm = gltf.userData.vrm;
+        if (!vrm) {
+          throw new Error("VRM data not found in loaded file");
+        }
+        return vrm;
+      } finally {
+        if (blobUrl) {
+          URL.revokeObjectURL(blobUrl);
+        }
+      }
+    })(),
+    (error) => ({
+      type: "VRM_LOAD_FAILED",
+      message: `Failed to load VRM: ${String(error)}`
+    })
+  );
+}
+
+export { VRMExporterPlugin, createVirtualTailNodes, exportVRM, loadVRM, migrateSkeletonVRM0ToVRM1, migrateSpringBone, optimizeModel, rotateSpringBoneColliderOffsets, rotateSpringBoneGravityDirections, simplifyMeshes };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map