@fps-games/vfx 0.1.1 → 0.3.3

package/packages/effects/weapon-trail/index.ts

@@ -1,313 +0,0 @@
-// 武器挥砍拖尾(移植自 axe_and_bear OrbitingAxe 的 ribbon 拖尾, 自定义着色器 + trail_wedge 贴图)。
-// 库版:每帧采样「挂载点 root 实时世界坐标 + 可选轨道偏移」,按弧长重采样成固定点数,世界空间重建 ribbon。
-// 双层(细白亮芯 + 宽柔光晕)+ GlowLayer 辉光 + 能量流动高光带 + 刃头火花。持续型(默认无限循环)。
-import { Mesh } from '@babylonjs/core/Meshes/mesh';
-import { VertexData } from '@babylonjs/core/Meshes/mesh.vertexData';
-import { VertexBuffer } from '@babylonjs/core/Buffers/buffer';
-import { ShaderMaterial } from '@babylonjs/core/Materials/shaderMaterial';
-import { Effect } from '@babylonjs/core/Materials/effect';
-import { Texture } from '@babylonjs/core/Materials/Textures/texture';
-import { Color3, Color4 } from '@babylonjs/core/Maths/math.color';
-import { Vector3 } from '@babylonjs/core/Maths/math.vector';
-import { Constants } from '@babylonjs/core/Engines/constants';
-import { GlowLayer } from '@babylonjs/core/Layers/glowLayer';
-import { ParticleSystem } from '@babylonjs/core/Particles/particleSystem';
-import type { Scene } from '@babylonjs/core/scene';
-import type { VfxColorValue, VfxEffectPackage, VfxParamValues } from '../../types';
-import { LIFETIME_DEBUG_PARAMS, LIFETIME_DEFAULTS, scheduleLifetime, makeFlareTexture } from '../space-shared';
-import trailTextureUrl from './assets/textures/trail_wedge.png?url';
-
-interface WeaponTrailParams extends VfxParamValues {
-  lifetimeMode: string; lifetime: number;
-  orientation: string;
-  orbitRadius: number; orbitSpeed: number; height: number;
-  trailLength: number; worldLength: number; width: number; coreWidth: number;
-  tailFadeStrength: number; tailFadeExponent: number;
-  opacity: number; saturation: number; contrast: number;
-  bright: number; bloom: number; blendMode: string; flowSpeed: number; sparkRate: number;
-  tint: VfxColorValue;
-}
-
-const DEFAULT_PARAMS: WeaponTrailParams = {
-  ...LIFETIME_DEFAULTS,
-  orientation: 'horizontal',
-  orbitRadius: 1.6, orbitSpeed: 7, height: 0,
-  trailLength: 16, worldLength: 4.0, width: 1.01, coreWidth: 0.4,
-  tailFadeStrength: 0.58, tailFadeExponent: 1.35,
-  opacity: 1.35, saturation: 1.45, contrast: 1.32,
-  bright: 1.35, bloom: 0.9, blendMode: 'add', flowSpeed: 5, sparkRate: 20,
-  tint: { r: 0.4, g: 0.85, b: 1 }, // 青色能量,配新武器发光风
-};
-
-const TRAIL_VERTEX = `precision highp float;
-attribute vec3 position;
-attribute vec2 uv;
-attribute vec4 color;
-uniform mat4 worldViewProjection;
-varying vec2 vUv;
-varying vec4 vColor;
-void main(){ gl_Position = worldViewProjection * vec4(position, 1.0); vUv = uv; vColor = color; }`;
-
-const TRAIL_FRAGMENT = `precision highp float;
-varying vec2 vUv;
-varying vec4 vColor;
-uniform sampler2D mainTex;
-uniform vec3 uTint;
-uniform float uSaturation;
-uniform float uContrast;
-uniform float uAlphaScale;
-uniform float uAlphaPower;
-uniform float uBright;
-uniform float uTime;
-uniform float uFlowSpeed;
-void main(){
-  vec4 base = texture2D(mainTex, vUv);
-  vec3 color = base.rgb * uTint;
-  float luminance = dot(color, vec3(0.299, 0.587, 0.114));
-  color = mix(vec3(luminance), color, uSaturation);
-  color = (color - 0.5) * uContrast + 0.5;
-  color = clamp(color, 0.0, 1.0) * uBright;          // HDR 亮度 → 过曝白核,辉光更强
-  // 能量流动:一条高光带沿长度(头→尾)滚动
-  float phase = fract(vUv.x * 2.0 - uTime * uFlowSpeed);
-  float band = smoothstep(0.0, 0.12, phase) * (1.0 - smoothstep(0.12, 0.4, phase));
-  color *= 1.0 + band * 0.6 * step(0.0001, uFlowSpeed);
-  float alpha = pow(clamp(base.a, 0.0, 1.0), uAlphaPower) * vColor.a * uAlphaScale;
-  gl_FragColor = vec4(color, clamp(alpha, 0.0, 1.0));
-}`;
-
-let shadersRegistered = false;
-function registerShaders(): void {
-  if (shadersRegistered) return;
-  Effect.ShadersStore['vfxWeaponTrailVertexShader'] = TRAIL_VERTEX;
-  Effect.ShadersStore['vfxWeaponTrailFragmentShader'] = TRAIL_FRAGMENT;
-  shadersRegistered = true;
-}
-
-interface Sample { position: Vector3; widthAxis: Vector3; }
-function sample(): Sample { return { position: new Vector3(), widthAxis: new Vector3(0, 1, 0) }; }
-function copySample(src: Sample, dst: Sample): void { dst.position.copyFrom(src.position); dst.widthAxis.copyFrom(src.widthAxis); }
-function lerpSample(a: Sample, b: Sample, t: number, dst: Sample): void {
-  Vector3.LerpToRef(a.position, b.position, t, dst.position);
-  Vector3.LerpToRef(a.widthAxis, b.widthAxis, t, dst.widthAxis);
-  if (dst.widthAxis.lengthSquared() > 1e-6) dst.widthAxis.normalize();
-}
-
-export const weaponTrailEffectPackage: VfxEffectPackage<WeaponTrailParams> = {
-  id: 'weapon-trail',
-  nameZh: '武器拖尾',
-  debugAnchor: 'player',
-  defaultParams: DEFAULT_PARAMS,
-  debugParams: [
-    ...LIFETIME_DEBUG_PARAMS,
-    { key: 'orientation', label: '拖尾朝向', kind: 'enum', options: [
-      { value: 'horizontal', label: '水平面' }, { value: 'vertical', label: '竖直' },
-    ] },
-    { key: 'orbitRadius', label: '环绕半径', kind: 'scale', min: 0, max: 5, step: 0.05 },
-    { key: 'orbitSpeed', label: '环绕速度', kind: 'number', min: 0, max: 20, step: 0.1 },
-    { key: 'height', label: '高度', kind: 'number', min: -2, max: 3, step: 0.05 },
-    { key: 'trailLength', label: '拖尾段数', kind: 'number', min: 4, max: 48, step: 1 },
-    { key: 'worldLength', label: '拖尾长度', kind: 'scale', min: 0.5, max: 12, step: 0.1 },
-    { key: 'width', label: '拖尾宽度', kind: 'scale', min: 0.1, max: 4, step: 0.01 },
-    { key: 'coreWidth', label: '亮芯宽度比', kind: 'number', min: 0, max: 1, step: 0.01 },
-    { key: 'tailFadeStrength', label: '尾部淡出强度', kind: 'number', min: 0, max: 1, step: 0.01 },
-    { key: 'tailFadeExponent', label: '尾部淡出曲线', kind: 'number', min: 0.2, max: 4, step: 0.05 },
-    { key: 'opacity', label: '透明度', kind: 'opacity', min: 0, max: 3, step: 0.01 },
-    { key: 'saturation', label: '饱和度', kind: 'number', min: 0, max: 3, step: 0.01 },
-    { key: 'contrast', label: '对比度', kind: 'number', min: 0, max: 3, step: 0.01 },
-    { key: 'bright', label: '亮度(HDR)', kind: 'number', min: 0.2, max: 4, step: 0.05 },
-    { key: 'bloom', label: '辉光强度', kind: 'number', min: 0, max: 3, step: 0.05 },
-    { key: 'blendMode', label: '混合模式', kind: 'enum', options: [
-      { value: 'add', label: '加色(能量光)' }, { value: 'combine', label: '正常(实心刃)' },
-    ] },
-    { key: 'flowSpeed', label: '能量流动速度', kind: 'number', min: 0, max: 4, step: 0.05 },
-    { key: 'sparkRate', label: '刃头火花/秒', kind: 'number', min: 0, max: 80, step: 1 },
-    { key: 'tint', label: '颜色', kind: 'color' },
-  ],
-
-  create({ scene, root, position, params }) {
-    root.position.copyFrom(position);
-    registerShaders();
-    const blend = params.blendMode === 'combine' ? Constants.ALPHA_COMBINE : Constants.ALPHA_ADD;
-
-    const tex = new Texture(trailTextureUrl, scene, true, false);
-    tex.hasAlpha = true; tex.wrapU = Texture.CLAMP_ADDRESSMODE; tex.wrapV = Texture.CLAMP_ADDRESSMODE;
-
-    function makeMat(name: string, tint: Color3, bright: number): ShaderMaterial {
-      const m = new ShaderMaterial(name, scene, { vertex: 'vfxWeaponTrail', fragment: 'vfxWeaponTrail' }, {
-        attributes: ['position', 'uv', 'color'],
-        uniforms: ['worldViewProjection', 'uTint', 'uSaturation', 'uContrast', 'uAlphaScale', 'uAlphaPower', 'uBright', 'uTime', 'uFlowSpeed'],
-        samplers: ['mainTex'], needAlphaBlending: true,
-      });
-      m.setTexture('mainTex', tex);
-      m.setColor3('uTint', tint);
-      m.setFloat('uSaturation', params.saturation);
-      m.setFloat('uContrast', params.contrast);
-      m.setFloat('uAlphaScale', params.opacity);
-      m.setFloat('uAlphaPower', 0.82);
-      m.setFloat('uBright', bright);
-      m.setFloat('uTime', 0);
-      m.setFloat('uFlowSpeed', params.flowSpeed);
-      m.alphaMode = blend; m.backFaceCulling = false; m.disableDepthWrite = true; m.fogEnabled = false;
-      return m;
-    }
-    const tintC = new Color3(params.tint.r, params.tint.g, params.tint.b);
-    const coreC = Color3.Lerp(tintC, new Color3(1, 1, 1), 0.75);     // 亮芯偏白
-    const outerMat = makeMat('vfx_weaponTrail_outerMat', tintC, params.bright);
-    const hasCore = params.coreWidth > 0.001;
-    const coreMat = hasCore ? makeMat('vfx_weaponTrail_coreMat', coreC, params.bright * 1.6) : null;
-
-    function makeMesh(name: string, mat: ShaderMaterial, ai: number): Mesh {
-      const m = new Mesh(name, scene);
-      m.material = mat; m.isPickable = false; m.alwaysSelectAsActiveMesh = true;
-      m.useVertexColors = true; m.hasVertexAlpha = true; m.renderingGroupId = 0; m.alphaIndex = ai;
-      return m;
-    }
-    const outer = makeMesh('vfx_weaponTrail_outer', outerMat, 10);
-    const core = hasCore ? makeMesh('vfx_weaponTrail_core', coreMat!, 11) : null;
-
-    // 辉光:作用域仅限本拖尾的 GlowLayer,用拖尾自身 shader 输出做辉光源
-    let glow: GlowLayer | null = null;
-    if (params.bloom > 0) {
-      glow = new GlowLayer('vfx_weaponTrail_glow', scene, { blurKernelSize: 48 });
-      glow.intensity = params.bloom;
-      glow.addIncludedOnlyMesh(outer); glow.referenceMeshToUseItsOwnMaterial(outer);
-      if (core) { glow.addIncludedOnlyMesh(core); glow.referenceMeshToUseItsOwnMaterial(core); }
-    }
-
-    // 刃头能量火花:加色径向辉光粒子,发射点跟随拖尾头部
-    let sparkPs: ParticleSystem | null = null;
-    const sparkEmitter = new Vector3();
-    if (params.sparkRate > 0) {
-      const c255 = `${Math.round(params.tint.r * 255)},${Math.round(params.tint.g * 255)},${Math.round(params.tint.b * 255)}`;
-      const flare = makeFlareTexture(scene, 'vfx_weaponTrail_sparkTex', '255,255,255', c255);
-      sparkPs = new ParticleSystem('vfx_weaponTrail_sparks', 160, scene);
-      sparkPs.particleTexture = flare;
-      sparkPs.emitter = sparkEmitter;
-      sparkPs.minSize = 0.07; sparkPs.maxSize = 0.26;
-      sparkPs.minLifeTime = 0.12; sparkPs.maxLifeTime = 0.4;
-      sparkPs.emitRate = params.sparkRate;
-      sparkPs.blendMode = ParticleSystem.BLENDMODE_ADD;
-      sparkPs.minEmitPower = 0.6; sparkPs.maxEmitPower = 2.4;
-      sparkPs.direction1 = new Vector3(-1, -0.6, -1); sparkPs.direction2 = new Vector3(1, 0.6, 1);
-      sparkPs.gravity = new Vector3(0, -3, 0);
-      sparkPs.color1 = new Color4(params.tint.r, params.tint.g, params.tint.b, 1);
-      sparkPs.color2 = new Color4(1, 1, 1, 1);
-      sparkPs.colorDead = new Color4(params.tint.r, params.tint.g, params.tint.b, 0);
-      sparkPs.start();
-    }
-
-    const targetCount = Math.max(2, Math.round(params.trailLength));
-    const raw: Sample[] = [];
-    const points: Sample[] = [];
-    for (let i = 0; i < 96; i++) raw.push(sample());
-    for (let i = 0; i < targetCount; i++) points.push(sample());
-    let rawCount = 0, angle = 0, time = 0;
-    let outerInit = false, coreInit = false;
-    const cur = sample();
-    const mountPos = new Vector3();
-    const lastWidthAxis = new Vector3(0, 0, 1);
-    const tmpDir = new Vector3();
-    const UP = new Vector3(0, 1, 0);
-    const positions: number[] = [], uvs: number[] = [], colors: number[] = [], indices: number[] = [];
-
-    function sampleEmitter(out: Sample): void {
-      const c = Math.cos(angle), s = Math.sin(angle);
-      // 跟随挂载点:每帧读 root 实时世界坐标(宿主移动/挂骨骼即跟随),叠加可选轨道偏移
-      out.position.set(
-        mountPos.x + c * params.orbitRadius,
-        mountPos.y + params.height,
-        mountPos.z + s * params.orbitRadius,
-      );
-      if (params.orientation === 'vertical') { out.widthAxis.set(0, 1, 0); return; }
-      // 水平:宽度轴 = 上 × 运动方向(水平且垂直于真实路径)→ 轨道时=径向,跟随时垂直于挥动方向
-      if (rawCount > 0) {
-        tmpDir.set(out.position.x - raw[0].position.x, out.position.y - raw[0].position.y, out.position.z - raw[0].position.z);
-        if (tmpDir.lengthSquared() > 1e-8) {
-          Vector3.CrossToRef(UP, tmpDir, out.widthAxis);
-          if (out.widthAxis.lengthSquared() > 1e-8) { out.widthAxis.normalize(); lastWidthAxis.copyFrom(out.widthAxis); return; }
-        }
-      }
-      out.widthAxis.copyFrom(lastWidthAxis);   // 静止/首帧:沿用上次朝向,带子不塌
-    }
-
-    function resample(): void {
-      if (rawCount <= 0) return;
-      const target = params.worldLength;
-      let seg = 0, distBefore = 0;
-      for (let i = 0; i < targetCount; i++) {
-        const t = points[i];
-        if (i === 0 || rawCount === 1) { copySample(raw[0], t); continue; }
-        const targetDist = target * (i / (targetCount - 1));
-        let found = false;
-        while (seg < rawCount - 1) {
-          const l = raw[seg], r = raw[seg + 1];
-          const segLen = Vector3.Distance(l.position, r.position);
-          if (segLen <= 1e-5) { seg++; continue; }
-          if (distBefore + segLen >= targetDist) { lerpSample(l, r, Math.min(1, Math.max(0, (targetDist - distBefore) / segLen)), t); found = true; break; }
-          distBefore += segLen; seg++;
-        }
-        if (!found) copySample(raw[rawCount - 1], t);
-      }
-    }
-
-    // 从 points 重建 ribbon 几何(世界空间),halfWidth 决定层宽
-    function buildRibbon(mesh: Mesh, halfWidth: number, wasInit: boolean): boolean {
-      positions.length = 0; uvs.length = 0; colors.length = 0; indices.length = 0;
-      for (let i = 0; i < targetCount; i++) {
-        const s = points[i];
-        const t = i / (targetCount - 1);
-        const u = t * 0.97 + 0.015;
-        const alpha = Math.max(0, 1 - Math.pow(t, params.tailFadeExponent) * params.tailFadeStrength);
-        const ox = s.widthAxis.x * halfWidth, oy = s.widthAxis.y * halfWidth, oz = s.widthAxis.z * halfWidth;
-        positions.push(s.position.x + ox, s.position.y + oy, s.position.z + oz, s.position.x - ox, s.position.y - oy, s.position.z - oz);
-        uvs.push(u, 0, u, 1);
-        colors.push(1, 1, 1, alpha, 1, 1, 1, alpha);
-        if (i < targetCount - 1) { const b = i * 2; indices.push(b, b + 1, b + 2, b + 1, b + 3, b + 2); }
-      }
-      if (!wasInit) {
-        const vd = new VertexData(); vd.positions = positions; vd.indices = indices; vd.uvs = uvs; vd.colors = colors; vd.hasVertexAlpha = true;
-        vd.applyToMesh(mesh, true); mesh.refreshBoundingInfo(true);
-        return true;
-      }
-      mesh.updateVerticesData(VertexBuffer.PositionKind, positions, true, false);
-      mesh.updateVerticesData(VertexBuffer.UVKind, uvs, true, false);
-      mesh.updateVerticesData(VertexBuffer.ColorKind, colors, true, false);
-      return true;
-    }
-
-    const observer = scene.onBeforeRenderObservable.add(() => {
-      const dt = Math.min(scene.getEngine().getDeltaTime() / 1000, 0.05);
-      time += dt; angle += params.orbitSpeed * dt;
-      root.computeWorldMatrix(true);
-      mountPos.copyFrom(root.getAbsolutePosition());
-      sampleEmitter(cur);
-      if (rawCount === 0 || Vector3.Distance(cur.position, raw[0].position) > 0.0005) {
-        for (let i = Math.min(rawCount, raw.length - 1); i > 0; i--) copySample(raw[i - 1], raw[i]);
-        copySample(cur, raw[0]);
-        rawCount = Math.min(rawCount + 1, raw.length);
-      }
-      resample();
-      const halfW = params.width * 0.5;
-      outerInit = buildRibbon(outer, halfW, outerInit);
-      if (core) coreInit = buildRibbon(core, halfW * params.coreWidth, coreInit);
-      outerMat.setFloat('uTime', time);
-      coreMat?.setFloat('uTime', time);
-      if (sparkPs) sparkEmitter.copyFrom(points[0].position);   // 火花发射点 = 拖尾头部(刃)
-    });
-
-    let disposed = false;
-    let ltTimer = 0;
-    const dispose = (): void => {
-      if (disposed) return; disposed = true;
-      if (ltTimer) window.clearTimeout(ltTimer);
-      scene.onBeforeRenderObservable.remove(observer);
-      sparkPs?.stop(); sparkPs?.dispose();
-      glow?.dispose();
-      outer.dispose(); outerMat.dispose();
-      core?.dispose(); coreMat?.dispose();
-      tex.dispose(); root.dispose();
-    };
-    ltTimer = scheduleLifetime(params, dispose);
-    return { root, dispose };
-  },
-};

package/packages/effects/wood-crusher-sawdust/assets/runtime/particleEmitter.v1.js

@@ -1,312 +0,0 @@
-export const runtimeId = "particleEmitter/v1";
-
-export const runtimeContract = {
-  runtimeId,
-  kind: "particleEmitter",
-  emitterFields: {
-    capacity: "Maximum Babylon particle capacity.",
-    particleTexturePath: "Package-relative particle texture path used to load the Babylon ParticleSystem.particleTexture.",
-    blendMode: "Babylon particle blend mode label: ADD, STANDARD, MULTIPLY, or ONEONE.",
-    shape: "Emitter shape definition generated by the package build stage.",
-    spriteSheet: "Optional Babylon particle spritesheet settings for atlas-based particle textures.",
-    effectScale: "Spatial scale for the whole effect; scales emitter volume, particle size, velocity, and gravity together.",
-    renderColor: "Converted particle color inputs: one base color plus RGB/alpha intensity before writing Babylon color1/color2/colorDead.",
-    alphaKeys: "Color alpha gradients sampled over normalized particle lifetime.",
-    sizeKeys: "Size gradients sampled over normalized particle lifetime.",
-  },
-  runtimeBindings: {
-    "ParticleSystem.particleTexture": "Texture loaded from emitter.particleTexturePath through urlForPackagePath.",
-    "ParticleSystem.blendMode": "Mapped from emitter.blendMode.",
-    "ParticleSystem.manualEmitCount": "emitter.manualEmitCount when emitRate is 0.",
-    "ParticleSystem.emitRate": "emitter.emitRate for sustained emitters.",
-    "ParticleSystem.shape": "Mapped from emitter.shape.type and shape parameters, then scaled by emitter.effectScale.",
-    "ParticleSystem.spriteSheet": "Applied from emitter.spriteSheet when enabled.",
-    "ParticleSystem.colorGradient": "emitter.alphaKeys applied to the final ParticleSystem.color1.",
-    "ParticleSystem.sizeGradient": "emitter.sizeKeys multiplied by emitter.maxSize and emitter.effectScale.",
-  },
-};
-
-const BABYLON_PARTICLE_UPDATE_SPEED_UNIT = 0.01;
-
-function num(value, fallback = 0) {
-  const next = Number(value);
-  return Number.isFinite(next) ? next : fallback;
-}
-
-function readColor(BABYLON, value, fallback = new BABYLON.Color4(1, 1, 1, 1)) {
-  if (!value) return fallback;
-  return new BABYLON.Color4(num(value.r, fallback.r), num(value.g, fallback.g), num(value.b, fallback.b), num(value.a, fallback.a));
-}
-
-function applyRenderColorIntensity(BABYLON, color, renderColor = {}) {
-  const colorIntensity = Math.max(0, num(renderColor.colorIntensity, 1));
-  const alphaIntensity = Math.max(0, num(renderColor.alphaIntensity, colorIntensity));
-  return new BABYLON.Color4(
-    color.r * colorIntensity,
-    color.g * colorIntensity,
-    color.b * colorIntensity,
-    Math.min(1, color.a * alphaIntensity)
-  );
-}
-
-function particleColors(BABYLON, emitter) {
-  const renderColor = emitter.renderColor;
-  const baseColor = readColor(BABYLON, renderColor?.color, new BABYLON.Color4(1, 1, 1, 1));
-  const color1 = applyRenderColorIntensity(BABYLON, baseColor, renderColor);
-  return {
-    color1,
-    color2: color1,
-    colorDead: new BABYLON.Color4(color1.r, color1.g, color1.b, 0),
-  };
-}
-
-function readVec(BABYLON, value, fallback = new BABYLON.Vector3(0, 0, 0)) {
-  if (!value) return fallback;
-  return new BABYLON.Vector3(num(value.x, fallback.x), num(value.y, fallback.y), num(value.z, fallback.z));
-}
-
-function blendMode(BABYLON, value) {
-  if (value === "STANDARD") return BABYLON.ParticleSystem.BLENDMODE_STANDARD;
-  if (value === "MULTIPLY") return BABYLON.ParticleSystem.BLENDMODE_MULTIPLY;
-  if (value === "ONEONE") return BABYLON.ParticleSystem.BLENDMODE_ONEONE;
-  return BABYLON.ParticleSystem.BLENDMODE_ADD;
-}
-
-function billboardMode(BABYLON, value) {
-  if (!value || BABYLON.ParticleSystem[value] === undefined) return undefined;
-  return BABYLON.ParticleSystem[value];
-}
-
-function effectScale(emitter) {
-  return Math.max(0.0001, num(emitter.effectScale, 1));
-}
-
-function applyRenderOrder(system, emitter) {
-  system.renderingGroupId = Math.max(0, Math.round(num(emitter.renderingGroupId, 2)));
-  system.alphaIndex = num(emitter.alphaIndex, 100);
-  if ("forceDepthWrite" in system) {
-    system.forceDepthWrite = false;
-  }
-}
-
-function isDeterministic(emitter) {
-  return emitter?.deterministic !== false && emitter?.randomize !== true;
-}
-
-function midpoint(min, max) {
-  return (min + max) * 0.5;
-}
-
-function fract(value) {
-  return value - Math.floor(value);
-}
-
-function sequence01(index, axis) {
-  if (index === 0) return 0.5;
-  const strides = [0.618033988749895, 0.414213562373095, 0.732050807568877, 0.324717957244746, 0.754877666246693, 0.569840290998053];
-  return fract(0.5 + index * strides[axis % strides.length] + axis * 0.173205080756888);
-}
-
-function lerp(min, max, t) {
-  return min + (max - min) * t;
-}
-
-function applyDeterministicBoxEmitter(BABYLON, system, direction1, direction2, boxMin, boxMax) {
-  system.minEmitBox = boxMin;
-  system.maxEmitBox = boxMax;
-  system.direction1 = direction1;
-  system.direction2 = direction2;
-
-  let positionIndex = 0;
-  let directionIndex = 0;
-
-  system.startPositionFunction = (worldMatrix, positionToUpdate, _particle, isLocal) => {
-    const index = positionIndex;
-    positionIndex += 1;
-    const x = lerp(boxMin.x, boxMax.x, sequence01(index, 0));
-    const y = lerp(boxMin.y, boxMax.y, sequence01(index, 1));
-    const z = lerp(boxMin.z, boxMax.z, sequence01(index, 2));
-    if (isLocal) positionToUpdate.set(x, y, z);
-    else BABYLON.Vector3.TransformCoordinatesFromFloatsToRef(x, y, z, worldMatrix, positionToUpdate);
-  };
-
-  system.startDirectionFunction = (worldMatrix, directionToUpdate, _particle, isLocal) => {
-    const index = directionIndex;
-    directionIndex += 1;
-    const x = lerp(direction1.x, direction2.x, sequence01(index, 3));
-    const y = lerp(direction1.y, direction2.y, sequence01(index, 4));
-    const z = lerp(direction1.z, direction2.z, sequence01(index, 5));
-    if (isLocal) directionToUpdate.set(x, y, z);
-    else BABYLON.Vector3.TransformNormalFromFloatsToRef(x, y, z, worldMatrix, directionToUpdate);
-  };
-}
-
-function applyCocosConeEmitFunctions(BABYLON, system, radius, angle, radiusRange, scale) {
-  const safeRadius = Math.max(0, radius * scale);
-  const innerSq = (safeRadius * Math.max(0, 1 - radiusRange)) ** 2;
-  const outerSq = safeRadius * safeRadius;
-  const halfAngle = Math.min(Math.PI, Math.max(0, angle));
-  const cosAngle = Math.cos(halfAngle);
-
-  system.startPositionFunction = (worldMatrix, positionToUpdate, _particle, isLocal) => {
-    const s = Math.random() * Math.PI * 2;
-    const r2 = innerSq + Math.random() * (outerSq - innerSq);
-    const r = Math.sqrt(Math.max(0, r2));
-    const lx = r * Math.cos(s);
-    const lz = r * Math.sin(s);
-    if (isLocal) positionToUpdate.set(lx, 0, lz);
-    else BABYLON.Vector3.TransformCoordinatesFromFloatsToRef(lx, 0, lz, worldMatrix, positionToUpdate);
-  };
-
-  system.startDirectionFunction = (worldMatrix, directionToUpdate, _particle, isLocal) => {
-    const phi = Math.random() * Math.PI * 2;
-    const cosTheta = 1 - Math.random() * (1 - cosAngle);
-    const sinTheta = Math.sqrt(Math.max(0, 1 - cosTheta * cosTheta));
-    const dx = sinTheta * Math.cos(phi);
-    const dy = cosTheta;
-    const dz = sinTheta * Math.sin(phi);
-    if (isLocal) directionToUpdate.set(dx, dy, dz);
-    else BABYLON.Vector3.TransformNormalFromFloatsToRef(dx, dy, dz, worldMatrix, directionToUpdate);
-  };
-}
-
-function applyEmitterShape(BABYLON, system, emitter) {
-  const scale = effectScale(emitter);
-  const shape = emitter.shape || {};
-  const type = shape.type;
-  const radius = num(shape.radius, 1);
-  const radiusRange = Math.min(1, Math.max(0, num(shape.radiusRange, 1)));
-  const angle = num(shape.angle, Math.PI / 4);
-  const direction1 = readVec(BABYLON, shape.direction1, new BABYLON.Vector3(0, 1, 0));
-  const direction2 = readVec(BABYLON, shape.direction2, new BABYLON.Vector3(0, 1, 0));
-  const boxMin = readVec(BABYLON, shape.minEmitBox, new BABYLON.Vector3(-radius * 0.5, -radius * 0.5, -radius * 0.5)).scale(scale);
-  const boxMax = readVec(BABYLON, shape.maxEmitBox, new BABYLON.Vector3(radius * 0.5, radius * 0.5, radius * 0.5)).scale(scale);
-
-  if (type === "Box") {
-    if (isDeterministic(emitter)) applyDeterministicBoxEmitter(BABYLON, system, direction1, direction2, boxMin, boxMax);
-    else system.createBoxEmitter(direction1, direction2, boxMin, boxMax);
-  } else if (type === "SphereDirected") {
-    system.createDirectedSphereEmitter(radius * scale, direction1, direction2);
-  } else if (type === "Sphere") {
-    system.createSphereEmitter(radius * scale, radiusRange);
-  } else if (type === "Hemisphere") {
-    system.createHemisphericEmitter(radius * scale, radiusRange);
-  } else if (type === "Cone") {
-    const dirSpread = direction1.subtract(direction2).lengthSquared();
-    if (dirSpread < 1e-4) {
-      system.createConeEmitter(Math.max(0.001, radius * scale), angle);
-      applyCocosConeEmitFunctions(BABYLON, system, radius, angle, radiusRange, scale);
-    } else {
-      system.createDirectedConeEmitter(Math.max(0.001, radius * scale), angle, direction1, direction2);
-    }
-  }
-}
-
-function applySpriteSheet(system, emitter) {
-  const spriteSheet = emitter.spriteSheet || {};
-  if (!spriteSheet.enabled) return;
-  const deterministic = isDeterministic(emitter);
-
-  system.isAnimationSheetEnabled = true;
-  system.spriteCellWidth = Math.max(1, Math.round(num(spriteSheet.cellWidth, 256)));
-  system.spriteCellHeight = Math.max(1, Math.round(num(spriteSheet.cellHeight, 256)));
-  system.startSpriteCellID = Math.max(0, Math.round(num(spriteSheet.startCellID, 0)));
-  system.endSpriteCellID = Math.max(system.startSpriteCellID, Math.round(num(spriteSheet.endCellID, system.startSpriteCellID)));
-  system.spriteCellChangeSpeed = Math.max(0, num(spriteSheet.cellChangeSpeed, 0));
-  system.spriteRandomStartCell = deterministic ? spriteSheet.randomStartCell === true && emitter.randomize === true : spriteSheet.randomStartCell !== false;
-}
-
-function addGradients(BABYLON, system, emitter, color1) {
-  const scale = effectScale(emitter);
-  for (const key of emitter.alphaKeys || []) {
-    const time = Math.min(1, Math.max(0, num(key.time, 0)));
-    const alpha = Math.min(1, Math.max(0, num(key.alpha, 1)));
-    system.addColorGradient?.(time, new BABYLON.Color4(color1.r, color1.g, color1.b, Math.min(1, color1.a * alpha)));
-  }
-  for (const key of emitter.sizeKeys || []) {
-    const time = Math.min(1, Math.max(0, num(key.time, 0)));
-    const size = Math.max(0.001, num(key.size, 1) * num(emitter.maxSize, 1) * scale);
-    system.addSizeGradient?.(time, size);
-  }
-}
-
-function playbackSpeed(emitter) {
-  return Math.max(0.001, num(emitter.updateSpeed, BABYLON_PARTICLE_UPDATE_SPEED_UNIT) / BABYLON_PARTICLE_UPDATE_SPEED_UNIT);
-}
-
-function runtimeDuration(emitter) {
-  return Math.max(0.1, num(emitter.runtime?.stopAfterSeconds, 3) / playbackSpeed(emitter));
-}
-
-export async function createParticleEmitterRuntime({ BABYLON, scene, emitter, index = 0, urlForPackagePath, shouldStart = false }) {
-  if (!BABYLON) throw new Error("createParticleEmitterRuntime requires BABYLON.");
-  if (!scene) throw new Error("createParticleEmitterRuntime requires scene.");
-  if (!emitter) throw new Error("createParticleEmitterRuntime requires emitter.");
-
-  const scale = effectScale(emitter);
-  const deterministic = isDeterministic(emitter);
-  const capacity = Math.max(1, Math.round(num(emitter.capacity, 100)));
-  const system = new BABYLON.ParticleSystem(`particle-emitter-${emitter.name || index}`, capacity, scene);
-  applyRenderOrder(system, emitter);
-  const textureUrl = urlForPackagePath ? urlForPackagePath(emitter.particleTexturePath) : emitter.particleTexturePath;
-  system.particleTexture = new BABYLON.Texture(textureUrl, scene);
-  system.particleTexture.hasAlpha = true;
-  system.emitter = readVec(BABYLON, emitter.origin, BABYLON.Vector3.Zero());
-  system.blendMode = blendMode(BABYLON, emitter.blendMode);
-  system.isLocal = emitter.isLocal === true;
-  const minSize = Math.max(0.001, num(emitter.minSize, 1) * scale);
-  const maxSize = Math.max(minSize, num(emitter.maxSize, minSize) * scale);
-  system.minSize = deterministic ? midpoint(minSize, maxSize) : minSize;
-  system.maxSize = deterministic ? system.minSize : maxSize;
-  const minScaleX = Math.max(0.001, num(emitter.minScaleX, 1));
-  const maxScaleX = Math.max(minScaleX, num(emitter.maxScaleX, minScaleX));
-  system.minScaleX = deterministic ? midpoint(minScaleX, maxScaleX) : minScaleX;
-  system.maxScaleX = deterministic ? system.minScaleX : maxScaleX;
-  const minScaleY = Math.max(0.001, num(emitter.minScaleY, 1));
-  const maxScaleY = Math.max(minScaleY, num(emitter.maxScaleY, minScaleY));
-  system.minScaleY = deterministic ? midpoint(minScaleY, maxScaleY) : minScaleY;
-  system.maxScaleY = deterministic ? system.minScaleY : maxScaleY;
-  const minLifeTime = Math.max(0.02, num(emitter.minLifeTime, 0.55));
-  const maxLifeTime = Math.max(minLifeTime, num(emitter.maxLifeTime, minLifeTime));
-  system.minLifeTime = deterministic ? midpoint(minLifeTime, maxLifeTime) : minLifeTime;
-  system.maxLifeTime = deterministic ? system.minLifeTime : maxLifeTime;
-  const minEmitPower = Math.max(0, num(emitter.minEmitPower, 1) * scale);
-  const maxEmitPower = Math.max(minEmitPower, num(emitter.maxEmitPower, minEmitPower) * scale);
-  system.minEmitPower = deterministic ? midpoint(minEmitPower, maxEmitPower) : minEmitPower;
-  system.maxEmitPower = deterministic ? system.minEmitPower : maxEmitPower;
-  system.updateSpeed = Math.max(0.00001, num(emitter.updateSpeed, BABYLON_PARTICLE_UPDATE_SPEED_UNIT));
-  system.gravity = readVec(BABYLON, emitter.gravity, new BABYLON.Vector3(0, -6, 0)).scale(scale);
-  system.emitRate = Math.max(0, num(emitter.emitRate, 0));
-  if (system.emitRate <= 0) system.manualEmitCount = Math.max(0, Math.round(num(emitter.manualEmitCount, 0)));
-
-  const colors = particleColors(BABYLON, emitter);
-  system.color1 = colors.color1;
-  system.color2 = colors.color2;
-  system.colorDead = colors.colorDead;
-  const minInitialRotation = num(emitter.minInitialRotation, 0);
-  const maxInitialRotation = Math.max(minInitialRotation, num(emitter.maxInitialRotation, minInitialRotation));
-  system.minInitialRotation = deterministic ? midpoint(minInitialRotation, maxInitialRotation) : minInitialRotation;
-  system.maxInitialRotation = deterministic ? system.minInitialRotation : maxInitialRotation;
-  const minAngularSpeed = num(emitter.minAngularSpeed, 0);
-  const maxAngularSpeed = Math.max(minAngularSpeed, num(emitter.maxAngularSpeed, minAngularSpeed));
-  system.minAngularSpeed = deterministic ? midpoint(minAngularSpeed, maxAngularSpeed) : minAngularSpeed;
-  system.maxAngularSpeed = deterministic ? system.minAngularSpeed : maxAngularSpeed;
-
-  const nextBillboardMode = billboardMode(BABYLON, emitter.billboardMode);
-  if (nextBillboardMode !== undefined) system.billboardMode = nextBillboardMode;
-
-  applyEmitterShape(BABYLON, system, emitter);
-  applySpriteSheet(system, emitter);
-  addGradients(BABYLON, system, emitter, system.color1);
-
-  const preview = {
-    start: () => system.start(),
-    stop: () => system.stop(),
-    dispose: () => system.dispose(),
-    isStarted: () => system.isStarted(),
-    duration: runtimeDuration(emitter),
-    system,
-  };
-  if (shouldStart) preview.start();
-  return preview;
-}

package/packages/effects/wood-crusher-sawdust/index.ts

@@ -1,43 +0,0 @@
-import manifest from './wood_crusher_sawdust.json';
-import runtimeUrl from './assets/runtime/particleEmitter.v1.js?url';
-import dustTextureUrl from './assets/textures/wood_crusher_sawdust_dust.png?url';
-import fiberTextureUrl from './assets/textures/wood_crusher_sawdust_fiber.png?url';
-import { createWoodSawdustEffectPackage, type WoodSawdustParams } from '../wood-sawdust-effect-factory';
-
-const DEFAULT_PARAMS: WoodSawdustParams = {
-  lifetime: 0.96,
-  scale: 1.61,
-  initialHeight: 0.35,
-  dustCount: 9,
-  fragmentCount: 6,
-  dustColor: { r: 0.8196078431372549, g: 0.6784313725490196, b: 0.45098039215686275 },
-  fragmentColor: { r: 0.7490196078431373, g: 0.4588235294117647, b: 0.2196078431372549 },
-  dustSize: 1,
-  fragmentSize: 1.77,
-  dustLifetime: 0.78,
-  fragmentLifetime: 0.91,
-  dustSpeed: 0.72,
-  fragmentSpeed: 1.63,
-  fragmentSpread: 2.4,
-};
-
-export const woodCrusherSawdustEffectPackage = createWoodSawdustEffectPackage({
-  id: 'wood-crusher-sawdust',
-  nameZh: '粉碎机木粉',
-  manifest,
-  runtimeUrl,
-  assetUrls: {
-    'assets/textures/wood_crusher_sawdust_dust.png': dustTextureUrl,
-    'assets/textures/wood_crusher_sawdust_fiber.png': fiberTextureUrl,
-  },
-  sourceEmitters: manifest.emitters,
-  dustEmitterName: 'wood_crusher_sawdust_dust',
-  fragmentEmitterName: 'wood_crusher_sawdust_fiber',
-  fragmentLabel: '细碎屑',
-  fragmentCountLabel: '细碎屑数量',
-  fragmentSizeLabel: '细碎屑大小',
-  fragmentColorLabel: '细碎屑颜色',
-  fragmentSpeedLabel: '细碎屑飞溅速度',
-  fragmentSpreadLabel: '细碎屑炸开幅度',
-  defaultParams: DEFAULT_PARAMS,
-});