@fps-games/vfx 0.1.1

package/packages/effects/wood_peel_material_test/assets/runtime/woodPeelMaterialTest.v1.js

@@ -0,0 +1,196 @@
+export const runtimeContract = {
+  id: "woodPeelMaterialTest/v1",
+  engine: "babylon",
+  exports: ["createWoodPeelMaterialTestRuntime"],
+};
+
+const PREVIEW_ROOT_NAME = "vfx_wood_peel_material_test_preview_root";
+
+function clamp01(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return 0;
+  return Math.min(1, Math.max(0, n));
+}
+
+function readNumber(value, fallback) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : fallback;
+}
+
+function readColor(BABYLON, value, fallback) {
+  if (typeof value === "string" && /^#[0-9a-f]{6}$/i.test(value)) {
+    return BABYLON.Color3.FromHexString(value);
+  }
+  if (value && typeof value === "object") {
+    const r = Number(value.r);
+    const g = Number(value.g);
+    const b = Number(value.b);
+    if (Number.isFinite(r) && Number.isFinite(g) && Number.isFinite(b)) {
+      return new BABYLON.Color3(r, g, b);
+    }
+  }
+  return fallback.clone();
+}
+
+function createWoodPeelPbrBlendPlugin(BABYLON, material, options) {
+  class WoodPeelPbrBlendPlugin extends BABYLON.MaterialPluginBase {
+    constructor() {
+      super(material, "WoodPeelPbrBlend", 210, { WOODPEEL_PBR_BLEND: false }, true, true);
+      this.peelProgress = clamp01(options.peelProgress);
+    }
+
+    isReadyForSubMesh() {
+      return true;
+    }
+
+    prepareDefines(defines) {
+      defines.WOODPEEL_PBR_BLEND = true;
+    }
+
+    bindForSubMesh(uniformBuffer) {
+      uniformBuffer.updateFloat2("woodPeelProgressBlend", this.peelProgress, Math.max(0.001, options.blendWidth));
+      uniformBuffer.updateVector3("woodPeelAxis", options.axis);
+      uniformBuffer.updateVector3("woodPeelAxisCenter", options.axisCenter);
+      uniformBuffer.updateFloat("woodPeelLogLength", options.logLength);
+      uniformBuffer.updateColor3("woodPeelBarkColor", options.barkColor);
+      uniformBuffer.updateColor3("woodPeelPeeledColor", options.peeledColor);
+    }
+
+    getUniforms() {
+      return {
+        ubo: [
+          { name: "woodPeelProgressBlend", size: 2, type: "vec2" },
+          { name: "woodPeelAxis", size: 3, type: "vec3" },
+          { name: "woodPeelAxisCenter", size: 3, type: "vec3" },
+          { name: "woodPeelLogLength", size: 1, type: "float" },
+          { name: "woodPeelBarkColor", size: 3, type: "vec3" },
+          { name: "woodPeelPeeledColor", size: 3, type: "vec3" },
+        ],
+      };
+    }
+
+    getCustomCode(shaderType) {
+      if (shaderType === "vertex") {
+        return {
+          CUSTOM_VERTEX_DEFINITIONS: `
+            varying vec3 vWoodPeelLocalPosition;
+          `,
+          CUSTOM_VERTEX_UPDATE_POSITION: `
+            vWoodPeelLocalPosition = positionUpdated;
+          `,
+        };
+      }
+      if (shaderType !== "fragment") return null;
+      return {
+        CUSTOM_FRAGMENT_DEFINITIONS: `
+          varying vec3 vWoodPeelLocalPosition;
+        `,
+        CUSTOM_FRAGMENT_UPDATE_ALBEDO: `
+          float woodPeelAxisDistance = dot(vWoodPeelLocalPosition - woodPeelAxisCenter, normalize(woodPeelAxis));
+          float woodPeelNormalizedAxis = clamp((woodPeelAxisDistance / max(woodPeelLogLength, 0.0001)) + 0.5, 0.0, 1.0);
+          float woodPeelWidth = max(woodPeelProgressBlend.y, 0.001);
+          float woodPeelHead = mix(-woodPeelWidth, 1.0 + woodPeelWidth, clamp(woodPeelProgressBlend.x, 0.0, 1.0));
+          float woodPeelPeeled = 1.0 - smoothstep(woodPeelHead - woodPeelWidth, woodPeelHead, woodPeelNormalizedAxis);
+          vec3 woodPeelBark = toLinearSpace(woodPeelBarkColor);
+          vec3 woodPeelPeeledWood = toLinearSpace(woodPeelPeeledColor);
+          surfaceAlbedo = mix(woodPeelBark, woodPeelPeeledWood, woodPeelPeeled);
+        `,
+      };
+    }
+  }
+
+  return new WoodPeelPbrBlendPlugin();
+}
+
+function createMaterial(BABYLON, scene, emitter, height, rootPosition) {
+  const material = new BABYLON.PBRMaterial(
+    "vfx_wood_peel_material_test_mat",
+    scene
+  );
+  material.albedoColor = BABYLON.Color3.White();
+  material.metallic = 0;
+  material.roughness = 0.82;
+  material.environmentIntensity = 1;
+  material.usePhysicalLightFalloff = false;
+  const plugin = createWoodPeelPbrBlendPlugin(BABYLON, material, {
+    peelProgress: emitter.peelProgress,
+    blendWidth: Math.max(0.001, readNumber(emitter.blendWidth, 0.08)),
+    axis: new BABYLON.Vector3(0, 1, 0),
+    axisCenter: new BABYLON.Vector3(rootPosition.x, rootPosition.y + height * 0.5, rootPosition.z),
+    logLength: height,
+    barkColor: readColor(BABYLON, emitter.barkColor, new BABYLON.Color3(0.76, 0.34, 0.13)),
+    peeledColor: readColor(BABYLON, emitter.peeledColor, new BABYLON.Color3(0.98, 0.79, 0.43)),
+  });
+  return { material, plugin };
+}
+
+export async function createWoodPeelMaterialTestRuntime({ BABYLON, scene, emitter }) {
+  const previous = scene.getTransformNodeByName(PREVIEW_ROOT_NAME);
+  if (previous) previous.dispose(false, true);
+
+  const height = Math.max(0.2, readNumber(emitter.height, 1.55));
+  const diameter = Math.max(0.05, readNumber(emitter.diameter, 0.42));
+  const origin = emitter.origin && typeof emitter.origin === "object"
+    ? emitter.origin
+    : { x: 0, y: 0, z: 0 };
+
+  const root = new BABYLON.TransformNode(PREVIEW_ROOT_NAME, scene);
+  root.position.set(
+    readNumber(origin.x, 0),
+    readNumber(origin.y, 0.02),
+    readNumber(origin.z, 0)
+  );
+
+  const materialHandle = createMaterial(BABYLON, scene, emitter, height, root.position);
+  const material = materialHandle.material;
+
+  const log = BABYLON.MeshBuilder.CreateCylinder(
+    "vfx_wood_peel_material_test_log",
+    {
+      height,
+      diameter,
+      tessellation: 48,
+      subdivisions: 12,
+      cap: BABYLON.Mesh.CAP_ALL,
+    },
+    scene
+  );
+  log.parent = root;
+  log.position.y = height * 0.5;
+  log.material = material;
+
+  const base = BABYLON.MeshBuilder.CreateDisc(
+    "vfx_wood_peel_material_test_floor_marker",
+    {
+      radius: diameter * 0.62,
+      tessellation: 48,
+    },
+    scene
+  );
+  base.parent = root;
+  base.rotation.x = Math.PI * 0.5;
+  base.position.y = 0.006;
+
+  const markerMaterial = new BABYLON.StandardMaterial("vfx_wood_peel_material_test_floor_marker_mat", scene);
+  markerMaterial.diffuseColor = new BABYLON.Color3(0.08, 0.12, 0.12);
+  markerMaterial.emissiveColor = new BABYLON.Color3(0.02, 0.055, 0.045);
+  markerMaterial.alpha = 0.38;
+  markerMaterial.backFaceCulling = false;
+  markerMaterial.transparencyMode = BABYLON.Material.MATERIAL_ALPHABLEND;
+  base.material = markerMaterial;
+
+  return {
+    start() {},
+    stop() {
+      root.setEnabled(false);
+    },
+    dispose() {
+      root.dispose(false, true);
+      material.dispose();
+      markerMaterial.dispose();
+    },
+    isStarted() {
+      return root.isEnabled();
+    },
+  };
+}

package/packages/effects/wood_peel_material_test/index.ts

@@ -0,0 +1,11 @@
+import manifest from './wood_peel_material_test.json';
+import runtimeUrl from './assets/runtime/woodPeelMaterialTest.v1.js?url';
+import { createManifestRuntimeEffectPackage } from '../../manifestRuntimePackage';
+
+export const woodPeelMaterialTestEffectPackage = createManifestRuntimeEffectPackage({
+  id: 'wood_peel_material_test',
+  manifest,
+  assetUrls: {
+    'assets/runtime/woodPeelMaterialTest.v1.js': runtimeUrl,
+  },
+});

package/packages/effects/wood_peel_material_test/vfx-params.json

@@ -0,0 +1,9 @@
+{
+  "__generation.offsetX": 0,
+  "__generation.offsetY": 0,
+  "__generation.offsetZ": 0,
+  "wood_peel_material_test.peelProgress": 0,
+  "wood_peel_material_test.blendWidth": 0.08,
+  "wood_peel_material_test.barkColor": "#c25721",
+  "wood_peel_material_test.peeledColor": "#fac96d"
+}

package/packages/effects/wood_peel_material_test/wood_peel_material_test.json

@@ -0,0 +1,136 @@
+{
+  "schemaVersion": "vfx-effect-package/1.0",
+  "id": "build.material.wood_peel_material_test",
+  "name": {
+    "zh": "木材剥皮材质测试",
+    "en": "Wood Peel Material Test"
+  },
+  "assets": {
+    "textures": [],
+    "materials": [],
+    "meshes": [],
+    "shaders": [],
+    "sounds": [],
+    "scripts": [
+      {
+        "kind": "script",
+        "id": "wood_peel_material_test_v1",
+        "packagePath": "assets/runtime/woodPeelMaterialTest.v1.js",
+        "runtimeId": "woodPeelMaterialTest/v1",
+        "engine": "babylon",
+        "moduleFormat": "esm",
+        "exports": [
+          "createWoodPeelMaterialTestRuntime",
+          "runtimeContract"
+        ],
+        "mimeType": "text/javascript"
+      }
+    ],
+    "raw": []
+  },
+  "emitters": [
+    {
+      "name": "wood_peel_material_test_main",
+      "enabled": true,
+      "type": "WoodPeelMaterialTest",
+      "height": 1.55,
+      "diameter": 0.42,
+      "peelProgress": 0,
+      "blendWidth": 0.08,
+      "barkColor": {
+        "r": 0.76,
+        "g": 0.34,
+        "b": 0.13,
+        "a": 1
+      },
+      "peeledColor": {
+        "r": 0.98,
+        "g": 0.79,
+        "b": 0.43,
+        "a": 1
+      },
+      "runtime": {
+        "adapter": "woodPeelMaterialTest/v1",
+        "disposeOnComplete": false
+      }
+    }
+  ],
+  "runtime": {
+    "driver": "woodPeelMaterialTest",
+    "adapters": [
+      {
+        "id": "woodPeelMaterialTest/v1",
+        "engine": "babylon",
+        "entry": "assets/runtime/woodPeelMaterialTest.v1.js",
+        "moduleFormat": "esm",
+        "exports": [
+          "createWoodPeelMaterialTestRuntime",
+          "runtimeContract"
+        ]
+      }
+    ]
+  },
+  "debug": {
+    "playAnchor": "playerRight",
+    "livePreview": true
+  },
+  "tunableParams": [
+    {
+      "key": "wood_peel_material_test.peelProgress",
+      "labelZh": "剥皮进度",
+      "type": "number",
+      "default": 0,
+      "min": 0,
+      "max": 1,
+      "step": 0.01,
+      "target": {
+        "emitter": "wood_peel_material_test_main",
+        "property": "peelProgress",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "wood_peel_material_test.blendWidth",
+      "labelZh": "柔边",
+      "type": "number",
+      "default": 0.08,
+      "min": 0.001,
+      "max": 0.35,
+      "step": 0.005,
+      "target": {
+        "emitter": "wood_peel_material_test_main",
+        "property": "blendWidth",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "wood_peel_material_test.barkColor",
+      "labelZh": "带皮颜色",
+      "type": "color",
+      "default": "#c25721",
+      "target": {
+        "emitter": "wood_peel_material_test_main",
+        "property": "barkColor",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "wood_peel_material_test.peeledColor",
+      "labelZh": "去皮颜色",
+      "type": "color",
+      "default": "#fac96d",
+      "target": {
+        "emitter": "wood_peel_material_test_main",
+        "property": "peeledColor",
+        "operator": "set"
+      }
+    }
+  ],
+  "review": {
+    "status": "draft",
+    "artistNotes": [
+      "Runtime-only material preview for testing a 0-1 bottom-to-top bark peeling parameter.",
+      "This package does not change gameplay logic or scene.json static layout."
+    ]
+  }
+}

package/packages/env.particle.forest_edge_fog/assets/runtime/particleEmitter.v1.js

@@ -0,0 +1,210 @@
+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 Cocos conversion stage.",
+    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.",
+    "ParticleSystem.colorGradient": "emitter.alphaKeys applied to the final ParticleSystem.color1.",
+    "ParticleSystem.sizeGradient": "emitter.sizeKeys multiplied by emitter.maxSize.",
+  },
+};
+
+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 applyCocosConeEmitFunctions(BABYLON, system, radius, angle, radiusRange) {
+  const safeRadius = Math.max(0, radius);
+  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 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));
+  const boxMax = readVec(BABYLON, shape.maxEmitBox, new BABYLON.Vector3(radius * 0.5, radius * 0.5, radius * 0.5));
+
+  if (type === "Box") {
+    system.createBoxEmitter(direction1, direction2, boxMin, boxMax);
+  } else if (type === "SphereDirected") {
+    system.createDirectedSphereEmitter(radius, direction1, direction2);
+  } else if (type === "Sphere") {
+    system.createSphereEmitter(radius, radiusRange);
+  } else if (type === "Hemisphere") {
+    system.createHemisphericEmitter(radius, radiusRange);
+  } else if (type === "Cone") {
+    const dirSpread = direction1.subtract(direction2).lengthSquared();
+    if (dirSpread < 1e-4) {
+      system.createConeEmitter(Math.max(0.001, radius), angle);
+      applyCocosConeEmitFunctions(BABYLON, system, radius, angle, radiusRange);
+    } else {
+      system.createDirectedConeEmitter(Math.max(0.001, radius), angle, direction1, direction2);
+    }
+  }
+}
+
+function addGradients(BABYLON, system, emitter, color1) {
+  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));
+    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 capacity = Math.max(1, Math.round(num(emitter.capacity, 100)));
+  const system = new BABYLON.ParticleSystem(`particle-emitter-${emitter.name || index}`, capacity, scene);
+  const textureUrl = urlForPackagePath ? urlForPackagePath(emitter.particleTexturePath) : emitter.particleTexturePath;
+  system.particleTexture = new BABYLON.Texture(textureUrl, scene);
+  system.particleTexture.hasAlpha = true;
+  system.emitter = BABYLON.Vector3.Zero();
+  system.blendMode = blendMode(BABYLON, emitter.blendMode);
+  system.isLocal = emitter.isLocal === true;
+  system.minSize = Math.max(0.001, num(emitter.minSize, 1));
+  system.maxSize = Math.max(system.minSize, num(emitter.maxSize, system.minSize));
+  system.minScaleX = Math.max(0.001, num(emitter.minScaleX, 1));
+  system.maxScaleX = Math.max(system.minScaleX, num(emitter.maxScaleX, system.minScaleX));
+  system.minScaleY = Math.max(0.001, num(emitter.minScaleY, 1));
+  system.maxScaleY = Math.max(system.minScaleY, num(emitter.maxScaleY, system.minScaleY));
+  system.minLifeTime = Math.max(0.02, num(emitter.minLifeTime, 0.55));
+  system.maxLifeTime = Math.max(system.minLifeTime, num(emitter.maxLifeTime, system.minLifeTime));
+  system.minEmitPower = Math.max(0, num(emitter.minEmitPower, 1));
+  system.maxEmitPower = Math.max(system.minEmitPower, num(emitter.maxEmitPower, system.minEmitPower));
+  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));
+  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;
+  system.minInitialRotation = num(emitter.minInitialRotation, 0);
+  system.maxInitialRotation = num(emitter.maxInitialRotation, system.minInitialRotation);
+  system.minAngularSpeed = num(emitter.minAngularSpeed, 0);
+  system.maxAngularSpeed = num(emitter.maxAngularSpeed, system.minAngularSpeed);
+
+  const nextBillboardMode = billboardMode(BABYLON, emitter.billboardMode);
+  if (nextBillboardMode !== undefined) system.billboardMode = nextBillboardMode;
+
+  applyEmitterShape(BABYLON, 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;
+}