@rzmps/rzmps 1.0.0

package/build/renderers/SpriteRenderer.js

@@ -0,0 +1,456 @@
+import * as THREE from 'three';
+import Renderer from '../Renderer';
+import simple from '../assets/images/default.png';
+import UnlitSprite from '../materials/UnlitSprite';
+import BasicSprite from '../materials/BasicSprite';
+import WebGPUUnlitSprite from '../materials/WebGPUUnlitSprite';
+import WebGPUBasicSprite from '../materials/WebGPUBasicSprite';
+import evaluateDynamicNumber from '../helpers/evaluateDynamicNumber';
+import seedrandom from 'seedrandom';
+import { SpriteMaterialType } from '../enums/SpriteMaterialType';
+import { TRAIL_RENDERER_USER_DATA_KEY } from './TrailRenderer';
+export const SPRITE_RENDERER_USER_DATA_KEY = "__rzmps_spriteRenderer";
+export const SCENE_DEPTH_DATA_USER_DATA_KEY = "__rzmps_sceneDepthData";
+export const WEBGPU_SCENE_DEPTH_DATA_USER_DATA_KEY = "__rzmps_webgpuSceneDepthData";
+export const WEBGPU_SCENE_DEPTH_TEXTURE = new THREE.DepthTexture(1, 1, THREE.UnsignedIntType);
+class SpriteRenderer extends Renderer {
+    get materialOptions() { return this._materialOptions; }
+    set materialOptions(value) {
+        this._materialOptions = value;
+        this.material = this.loadMaterial(value);
+        this.points.material = this.material;
+        this.webgpuMaterial = this.loadWebGPUMaterial(value);
+        this.webgpuMesh.material = this.webgpuMaterial;
+    }
+    constructor(texture = simple, options = {}) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+        super(options);
+        this.frames = 1;
+        this.materialType = SpriteMaterialType.Unlit;
+        this.tileSize = new THREE.Vector2(0, 0);
+        this.tileMargin = new THREE.Vector2(0, 0);
+        this.gridSize = new THREE.Vector2(1, 1);
+        this.fps = 1;
+        this.randomStartFrame = false;
+        this.castShadow = false;
+        this.softParticleDistance = 0;
+        this.hiddenMaterial = new THREE.MeshBasicMaterial({
+            colorWrite: false,
+            depthWrite: false,
+            transparent: true,
+            opacity: 0,
+        });
+        this.webgpuCapacity = 10000;
+        this.matrix = new THREE.Matrix4();
+        this.quaternion = new THREE.Quaternion();
+        this.cameraQuaternion = new THREE.Quaternion();
+        this.rollQuaternion = new THREE.Quaternion();
+        this.rollAxis = new THREE.Vector3(0, 0, 1);
+        this.scaleVector = new THREE.Vector3();
+        this.color = new THREE.Color();
+        const textureLoader = new THREE.TextureLoader();
+        this.texture = typeof texture === 'string' ? textureLoader.load(texture, (tex) => {
+            if (!options.tileSize) {
+                this.tileSize = new THREE.Vector2(tex.image.naturalWidth / this.gridSize.x, tex.image.naturalHeight / this.gridSize.y);
+            }
+        }) : texture;
+        this.fps = (_a = options.fps) !== null && _a !== void 0 ? _a : 1;
+        this.alphaMap = typeof options.alphaMap === 'string'
+            ? textureLoader.load(options.alphaMap)
+            : options.alphaMap;
+        this.materialType = (_b = options.material) !== null && _b !== void 0 ? _b : this.materialType;
+        this.tileSize = new THREE.Vector2((_c = options.tileSize) === null || _c === void 0 ? void 0 : _c.x, (_d = options.tileSize) === null || _d === void 0 ? void 0 : _d.y);
+        this.tileMargin = new THREE.Vector2((_e = options.tileMargin) === null || _e === void 0 ? void 0 : _e.x, (_f = options.tileMargin) === null || _f === void 0 ? void 0 : _f.y);
+        this.gridSize = new THREE.Vector2((_h = (_g = options.gridSize) === null || _g === void 0 ? void 0 : _g.x) !== null && _h !== void 0 ? _h : 1, (_k = (_j = options.gridSize) === null || _j === void 0 ? void 0 : _j.y) !== null && _k !== void 0 ? _k : 1);
+        this.castShadow = (_l = options.castShadow) !== null && _l !== void 0 ? _l : this.castShadow;
+        this.softParticleDistance = (_p = (_m = options.softParticleDistance) !== null && _m !== void 0 ? _m : (_o = options.materialOptions) === null || _o === void 0 ? void 0 : _o.softParticleDistance) !== null && _p !== void 0 ? _p : 0;
+        this.frames = (_q = options.frames) !== null && _q !== void 0 ? _q : this.gridSize.x * this.gridSize.y;
+        this.randomStartFrame = (_r = options.randomStartFrame) !== null && _r !== void 0 ? _r : false;
+        this.geometry = new THREE.BufferGeometry();
+        // Set material options and load material
+        this._materialOptions = options.materialOptions;
+        this.material = this.loadMaterial(this._materialOptions);
+        this.points = new THREE.Points(this.geometry, this.material);
+        this.points.frustumCulled = false;
+        this.points.castShadow = this.castShadow;
+        this.points.visible = false;
+        this.points.material = this.hiddenMaterial;
+        this.webgpuGeometry = new THREE.PlaneGeometry(1, 1);
+        this.webgpuFrameAttribute = new THREE.InstancedBufferAttribute(new Float32Array(this.webgpuCapacity), 1);
+        this.webgpuAlphaAttribute = new THREE.InstancedBufferAttribute(new Float32Array(this.webgpuCapacity), 1);
+        this.webgpuGeometry.setAttribute('frame', this.webgpuFrameAttribute);
+        this.webgpuGeometry.setAttribute('instanceAlpha', this.webgpuAlphaAttribute);
+        this.webgpuMaterial = this.loadWebGPUMaterial(this._materialOptions);
+        this.webgpuMesh = new THREE.InstancedMesh(this.webgpuGeometry, this.webgpuMaterial, this.webgpuCapacity);
+        this.webgpuMesh.frustumCulled = false;
+        this.webgpuMesh.castShadow = this.castShadow;
+        this.webgpuMesh.count = 0;
+        this.webgpuMesh.visible = false;
+        this.webgpuMesh.setColorAt(0, new THREE.Color(1, 1, 1));
+        // Add user data to the points so we can recognize it elsewhere
+        this.points.userData[SPRITE_RENDERER_USER_DATA_KEY] = true;
+        this.webgpuMesh.userData[SPRITE_RENDERER_USER_DATA_KEY] = true;
+    }
+    setup(system) {
+        system.addRendererObject(this.points);
+        system.addRendererObject(this.webgpuMesh);
+        this.points.onBeforeRender = (renderer) => this.setActiveRenderer(renderer);
+        this.webgpuMesh.onBeforeRender = (renderer) => this.setActiveRenderer(renderer);
+    }
+    _update(particles, system) {
+        var _a, _b, _c, _d, _e;
+        this.setActiveRenderer(system.sceneRenderer);
+        // Update attributes
+        if (this.isWebGPURenderer(system.sceneRenderer)) {
+            this.updateWebGPUInstances(particles, system.sceneCamera, system.sceneRenderer);
+        }
+        else {
+            this.updateAttributes(particles);
+        }
+        // Should the points cast a shadow?
+        this.points.castShadow = this.castShadow;
+        this.webgpuMesh.castShadow = this.castShadow;
+        const environment = this._materialOptions && 'envMap' in this._materialOptions
+            ? (_c = (_a = this._materialOptions.envMap) !== null && _a !== void 0 ? _a : (_b = system.scene) === null || _b === void 0 ? void 0 : _b.environment) !== null && _c !== void 0 ? _c : null
+            : (_e = (_d = system.scene) === null || _d === void 0 ? void 0 : _d.environment) !== null && _e !== void 0 ? _e : null;
+        if (this.isWebGPURenderer(system.sceneRenderer)) {
+            this.updateWebGPUEnvironmentMap(environment);
+            this.updateWebGPUSoftParticles(system.sceneRenderer, system.scene, system.sceneCamera);
+            return;
+        }
+        // Set uniforms for soft particles
+        this.setUniformValue('softParticles', Boolean(this.softParticleDistance));
+        this.setUniformValue('softParticleDistance', this.softParticleDistance);
+        // Get depth texture for soft particles
+        if (!(system.sceneRenderer instanceof THREE.WebGLRenderer))
+            return;
+        if (!(system.scene instanceof THREE.Scene))
+            return;
+        if (!(system.sceneCamera instanceof THREE.Camera))
+            return;
+        const depthTexture = this.getSceneDepth(system.sceneRenderer, system.scene, system.sceneCamera);
+        const cameraNear = 'near' in system.sceneCamera ? system.sceneCamera.near : undefined;
+        const cameraFar = 'far' in system.sceneCamera ? system.sceneCamera.far : undefined;
+        const softParticles = this.softParticleDistance > 0
+            && Boolean(depthTexture)
+            && typeof cameraNear === 'number'
+            && typeof cameraFar === 'number';
+        if (softParticles && depthTexture) {
+            this.setUniformValue('softParticles', true);
+            this.setUniformValue('sceneDepthTexture', depthTexture);
+            const depthResolution = this.getUniformValue('depthResolution', () => new THREE.Vector2());
+            system.sceneRenderer.getDrawingBufferSize(depthResolution);
+            this.setUniformValue('depthCameraNear', cameraNear);
+            this.setUniformValue('depthCameraFar', cameraFar);
+        }
+        else {
+            this.setUniformValue('softParticles', false);
+        }
+        // Update environment map
+        this.updateEnvironmentMap(system.sceneRenderer, environment);
+    }
+    updateAttributes(particles) {
+        this.geometry.setAttribute('position', new THREE.BufferAttribute(new Float32Array(particles.flatMap((particle) => particle.position.toArray())), 3));
+        this.geometry.setAttribute('scale', new THREE.BufferAttribute(new Float32Array(particles.flatMap((particle) => particle.scale.toArray())), 3));
+        this.geometry.setAttribute('rotation', new THREE.BufferAttribute(new Float32Array(particles.flatMap((particle) => particle.rotation.toArray())), 3));
+        this.geometry.setAttribute('color', new THREE.BufferAttribute(new Float32Array(particles.flatMap((particle) => particle.color.toArray().concat(particle.alpha))), 4));
+        this.geometry.setAttribute('frame', new THREE.BufferAttribute(new Float32Array(particles.flatMap((particle) => this.getParticleFrame(particle))), 1));
+    }
+    destroy() {
+        var _a;
+        (_a = this.environmentRenderTarget) === null || _a === void 0 ? void 0 : _a.dispose();
+        this.environmentRenderTarget = undefined;
+        this.geometry.dispose();
+        this.material.dispose();
+        this.webgpuGeometry.dispose();
+        this.webgpuMaterial.dispose();
+        this.hiddenMaterial.dispose();
+        this.points.removeFromParent();
+        this.webgpuMesh.removeFromParent();
+    }
+    loadMaterial(options) {
+        const createMaterial = this.materialType === SpriteMaterialType.Basic ? BasicSprite : UnlitSprite;
+        return createMaterial(this.texture, Object.assign(Object.assign({}, (options !== null && options !== void 0 ? options : {})), { frames: this.frames, gridSize: this.gridSize, alphaMap: this.alphaMap, softParticleDistance: this.softParticleDistance }));
+    }
+    loadWebGPUMaterial(options) {
+        const createMaterial = this.materialType === SpriteMaterialType.Basic ? WebGPUBasicSprite : WebGPUUnlitSprite;
+        return createMaterial(this.texture, Object.assign(Object.assign({}, (options !== null && options !== void 0 ? options : {})), { frames: this.frames, gridSize: this.gridSize, alphaMap: this.alphaMap, softParticleDistance: this.softParticleDistance, sceneDepthTexture: WEBGPU_SCENE_DEPTH_TEXTURE }));
+    }
+    isWebGPURenderer(renderer) {
+        return Boolean(renderer === null || renderer === void 0 ? void 0 : renderer.isWebGPURenderer);
+    }
+    setActiveRenderer(renderer) {
+        const usingWebGPU = this.isWebGPURenderer(renderer);
+        const usingWebGL = renderer && !usingWebGPU;
+        this.points.visible = Boolean(usingWebGL);
+        this.points.material = usingWebGL ? this.material : this.hiddenMaterial;
+        this.webgpuMesh.visible = usingWebGPU;
+    }
+    updateWebGPUInstances(particles, camera, renderer) {
+        const count = Math.min(particles.length, this.webgpuCapacity);
+        this.webgpuMesh.count = count;
+        if (camera) {
+            camera.getWorldQuaternion(this.cameraQuaternion);
+        }
+        else {
+            this.cameraQuaternion.identity();
+        }
+        for (let index = 0; index < count; index += 1) {
+            const particle = particles[index];
+            this.rollQuaternion.setFromAxisAngle(this.rollAxis, particle.rotation.x);
+            this.quaternion.copy(this.cameraQuaternion).multiply(this.rollQuaternion);
+            this.scaleVector.copy(this.getWebGPUWorldScale(particle, camera, renderer));
+            this.matrix.compose(particle.position, this.quaternion, this.scaleVector);
+            this.webgpuMesh.setMatrixAt(index, this.matrix);
+            this.webgpuMesh.setColorAt(index, this.color.copy(particle.color));
+            this.webgpuFrameAttribute.setX(index, this.getParticleFrame(particle));
+            this.webgpuAlphaAttribute.setX(index, particle.alpha);
+        }
+        this.webgpuMesh.instanceMatrix.needsUpdate = true;
+        if (this.webgpuMesh.instanceColor)
+            this.webgpuMesh.instanceColor.needsUpdate = true;
+        this.webgpuFrameAttribute.needsUpdate = true;
+        this.webgpuAlphaAttribute.needsUpdate = true;
+    }
+    getWebGPUWorldScale(particle, camera, renderer) {
+        var _a, _b, _c;
+        const width = particle.scale.x;
+        const height = particle.scale.y;
+        if (!(camera instanceof THREE.PerspectiveCamera)) {
+            this.scaleVector.set(width, height, 1);
+            return this.scaleVector;
+        }
+        const drawingBufferHeight = (_c = (_a = renderer === null || renderer === void 0 ? void 0 : renderer.getDrawingBufferSize(new THREE.Vector2()).y) !== null && _a !== void 0 ? _a : (_b = renderer === null || renderer === void 0 ? void 0 : renderer.domElement) === null || _b === void 0 ? void 0 : _b.height) !== null && _c !== void 0 ? _c : 600;
+        const worldUnitsPerPointSizeUnit = 2
+            * Math.tan(THREE.MathUtils.degToRad(camera.fov) / 2)
+            * 300
+            / drawingBufferHeight;
+        this.scaleVector.set(width * worldUnitsPerPointSizeUnit, height * worldUnitsPerPointSizeUnit, 1);
+        return this.scaleVector;
+    }
+    getParticleFrame(particle) {
+        return (this.randomStartFrame
+            ? Math.floor(seedrandom(particle.id).quick() * this.frames)
+            : 0) + (Math.floor((particle.realtime / 1000) * evaluateDynamicNumber(this.fps, particle.time, particle.id)) % this.frames);
+    }
+    updateWebGPUEnvironmentMap(environment) {
+        if (this.materialType !== SpriteMaterialType.Basic)
+            return;
+        const material = this.webgpuMaterial;
+        const nextEnvironment = environment !== null && environment !== void 0 ? environment : null;
+        if (material.envMap === nextEnvironment)
+            return;
+        material.envMap = nextEnvironment;
+        material.needsUpdate = true;
+    }
+    updateWebGPUSoftParticles(renderer, scene, camera) {
+        if (!this.softParticleDistance)
+            return;
+        if (!renderer || !scene || !camera)
+            return;
+        this.getWebGPUSceneDepth(renderer, scene, camera);
+    }
+    updateEnvironmentMap(renderer, environment) {
+        var _a;
+        if (this.materialType !== SpriteMaterialType.Basic)
+            return;
+        if (environment === this.environmentSource
+            && renderer === this.environmentRenderer) {
+            return;
+        }
+        (_a = this.environmentRenderTarget) === null || _a === void 0 ? void 0 : _a.dispose();
+        this.environmentRenderTarget = undefined;
+        this.environmentSource = environment !== null && environment !== void 0 ? environment : undefined;
+        this.environmentRenderer = renderer;
+        if (!environment) {
+            this.setEnvironmentMap(null);
+            return;
+        }
+        // Already a PMREM CubeUV texture.
+        if (environment.mapping === THREE.CubeUVReflectionMapping) {
+            this.setEnvironmentMap(environment);
+            return;
+        }
+        const pmremGenerator = new THREE.PMREMGenerator(renderer);
+        let renderTarget;
+        if (environment.isCubeTexture) {
+            renderTarget =
+                pmremGenerator.fromCubemap(environment);
+        }
+        else {
+            renderTarget =
+                pmremGenerator.fromEquirectangular(environment);
+        }
+        pmremGenerator.dispose();
+        this.environmentRenderTarget = renderTarget;
+        this.setEnvironmentMap(renderTarget.texture);
+    }
+    setEnvironmentMap(environment) {
+        var _a, _b, _c, _d, _e;
+        var _f;
+        if (this.materialType !== SpriteMaterialType.Basic)
+            return;
+        this.material.uniforms.envMap.value = environment;
+        this.material.uniforms.hasEnvMap.value = environment !== null;
+        if (!environment) {
+            (_a = this.material.defines) === null || _a === void 0 ? true : delete _a.ENVMAP_TYPE_CUBE_UV;
+            (_b = this.material.defines) === null || _b === void 0 ? true : delete _b.CUBEUV_TEXEL_WIDTH;
+            (_c = this.material.defines) === null || _c === void 0 ? true : delete _c.CUBEUV_TEXEL_HEIGHT;
+            (_d = this.material.defines) === null || _d === void 0 ? true : delete _d.CUBEUV_MAX_MIP;
+            this.material.needsUpdate = true;
+            return;
+        }
+        const image = environment.source.data;
+        const imageHeight = image.height;
+        const maxMip = Math.log2(imageHeight) - 2;
+        const texelHeight = 1 / imageHeight;
+        const texelWidth = 1 / (3 * Math.max(Math.pow(2, maxMip), 7 * 16));
+        (_e = (_f = this.material).defines) !== null && _e !== void 0 ? _e : (_f.defines = {});
+        this.material.defines.ENVMAP_TYPE_CUBE_UV = '';
+        this.material.defines.CUBEUV_TEXEL_WIDTH = `${texelWidth}`;
+        this.material.defines.CUBEUV_TEXEL_HEIGHT = `${texelHeight}`;
+        this.material.defines.CUBEUV_MAX_MIP = `${maxMip}.0`;
+        this.material.needsUpdate = true;
+    }
+    setUniformValue(name, value) {
+        var _a;
+        var _b;
+        (_a = (_b = this.material.uniforms)[name]) !== null && _a !== void 0 ? _a : (_b[name] = { value });
+        this.material.uniforms[name].value = value;
+    }
+    getUniformValue(name, create) {
+        var _a;
+        var _b;
+        (_a = (_b = this.material.uniforms)[name]) !== null && _a !== void 0 ? _a : (_b[name] = { value: create() });
+        return this.material.uniforms[name].value;
+    }
+    getSceneDepth(renderer, scene, camera) {
+        var _a, _b, _c;
+        let data = scene.userData[SCENE_DEPTH_DATA_USER_DATA_KEY];
+        if (!data) {
+            const size = renderer.getDrawingBufferSize(new THREE.Vector2());
+            const depthTexture = new THREE.DepthTexture(size.x, size.y, THREE.UnsignedIntType);
+            const target = new THREE.WebGLRenderTarget(size.x, size.y, {
+                depthBuffer: true,
+                depthTexture,
+            });
+            const material = new THREE.MeshDepthMaterial({
+                depthPacking: THREE.BasicDepthPacking,
+            });
+            material.colorWrite = false;
+            data = {
+                target,
+                material,
+                frame: -1,
+                rendering: false,
+            };
+            scene.userData[SCENE_DEPTH_DATA_USER_DATA_KEY] = data;
+        }
+        if (data.rendering) {
+            return (_a = data.target.depthTexture) !== null && _a !== void 0 ? _a : undefined;
+        }
+        const frame = renderer.info.render.frame;
+        if (data.frame === frame) {
+            return (_b = data.target.depthTexture) !== null && _b !== void 0 ? _b : undefined;
+        }
+        data.frame = frame;
+        data.rendering = true;
+        const size = renderer.getDrawingBufferSize(new THREE.Vector2());
+        if (data.target.width !== size.x
+            || data.target.height !== size.y) {
+            data.target.setSize(size.x, size.y);
+        }
+        const previousTarget = renderer.getRenderTarget();
+        const previousOverrideMaterial = scene.overrideMaterial;
+        const hiddenSpriteRenderers = this.hideSpriteRenderers(scene);
+        try {
+            scene.overrideMaterial = data.material;
+            renderer.setRenderTarget(data.target);
+            renderer.clear();
+            renderer.render(scene, camera);
+            data.frame = renderer.info.render.frame;
+        }
+        finally {
+            renderer.setRenderTarget(previousTarget);
+            scene.overrideMaterial = previousOverrideMaterial;
+            this.restoreSpriteRenderers(hiddenSpriteRenderers);
+            data.rendering = false;
+        }
+        return (_c = data.target.depthTexture) !== null && _c !== void 0 ? _c : undefined;
+    }
+    getWebGPUSceneDepth(renderer, scene, camera) {
+        var _a, _b;
+        let data = scene.userData[WEBGPU_SCENE_DEPTH_DATA_USER_DATA_KEY];
+        if (!data) {
+            const size = renderer.getDrawingBufferSize(new THREE.Vector2());
+            const target = new THREE.RenderTarget(size.x, size.y, {
+                depthBuffer: true,
+                depthTexture: WEBGPU_SCENE_DEPTH_TEXTURE,
+                samples: 0,
+            });
+            const material = new THREE.MeshBasicMaterial({
+                colorWrite: false,
+                depthTest: true,
+                depthWrite: true,
+            });
+            data = {
+                target,
+                material,
+                rendering: false,
+            };
+            scene.userData[WEBGPU_SCENE_DEPTH_DATA_USER_DATA_KEY] = data;
+        }
+        if (data.rendering) {
+            return (_a = data.target.depthTexture) !== null && _a !== void 0 ? _a : undefined;
+        }
+        data.rendering = true;
+        const size = renderer.getDrawingBufferSize(new THREE.Vector2());
+        if (data.target.width !== size.x
+            || data.target.height !== size.y) {
+            data.target.setSize(size.x, size.y);
+        }
+        const previousTarget = renderer.getRenderTarget();
+        const previousOverrideMaterial = scene.overrideMaterial;
+        const hiddenParticleRenderers = this.hideParticleRenderers(scene);
+        try {
+            scene.overrideMaterial = data.material;
+            renderer.setRenderTarget(data.target);
+            renderer.clear();
+            renderer.render(scene, camera);
+        }
+        finally {
+            renderer.setRenderTarget(previousTarget);
+            scene.overrideMaterial = previousOverrideMaterial;
+            this.restoreParticleRenderers(hiddenParticleRenderers);
+            data.rendering = false;
+        }
+        return (_b = data.target.depthTexture) !== null && _b !== void 0 ? _b : undefined;
+    }
+    hideSpriteRenderers(scene) {
+        return this.hideParticleRenderers(scene, false);
+    }
+    hideParticleRenderers(scene, includeTrails = true) {
+        const hidden = [];
+        scene.traverse((object) => {
+            const isSpriteRenderer = object.userData[SPRITE_RENDERER_USER_DATA_KEY];
+            const isTrailRenderer = includeTrails && object.userData[TRAIL_RENDERER_USER_DATA_KEY];
+            if (!isSpriteRenderer && !isTrailRenderer)
+                return;
+            hidden.push({
+                object,
+                visible: object.visible,
+            });
+            object.visible = false;
+        });
+        return hidden;
+    }
+    restoreSpriteRenderers(hidden) {
+        this.restoreParticleRenderers(hidden);
+    }
+    restoreParticleRenderers(hidden) {
+        hidden.forEach(({ object, visible }) => {
+            object.visible = visible;
+        });
+    }
+}
+export default SpriteRenderer;

package/build/renderers/TrailRenderer.d.ts

@@ -0,0 +1,71 @@
+import * as THREE from 'three';
+import Renderer, { RendererOptions } from '../Renderer';
+import Particle from '../Particle';
+import ParticleSystem from '../ParticleSystem';
+import { DynamicValue } from '../types/DynamicValue';
+import { TrailMode } from '../enums/TrailMode';
+import { TrailTextureMode } from '../enums/TrailTextureMode';
+export declare const TRAIL_RENDERER_USER_DATA_KEY = "__rzmps_trailRenderer";
+export interface TrailRendererOptions extends RendererOptions {
+    mode: TrailMode | `${TrailMode}`;
+    textureMode: TrailTextureMode | `${TrailTextureMode}`;
+    ratio: number;
+    lifetime: DynamicValue<number>;
+    minimumVertexDistance: number;
+    dieWithParticles: boolean;
+    ribbonCount: number;
+    width: DynamicValue<number>;
+    widthOverTrail: DynamicValue<number>;
+    sizeAffectsWidth: boolean;
+    sizeAffectsLifetime: boolean;
+    inheritParticleColor: boolean;
+    colorOverLifetime: DynamicValue<THREE.Color>;
+    colorOverTrail: DynamicValue<THREE.Color>;
+    material: THREE.Material;
+    materialOptions: THREE.MeshStandardMaterialParameters;
+    castShadow: boolean;
+    receiveShadow: boolean;
+}
+declare class TrailRenderer extends Renderer {
+    mode: TrailMode;
+    ratio: number;
+    lifetime: DynamicValue<number>;
+    minimumVertexDistance: number;
+    dieWithParticles: boolean;
+    ribbonCount: number;
+    textureMode: TrailTextureMode;
+    width: DynamicValue<number>;
+    sizeAffectsWidth: boolean;
+    sizeAffectsLifetime: boolean;
+    inheritParticleColor: boolean;
+    colorOverLifetime: DynamicValue<THREE.Color>;
+    widthOverTrail: DynamicValue<number>;
+    colorOverTrail: DynamicValue<THREE.Color>;
+    geometry: THREE.BufferGeometry;
+    material: THREE.Material | THREE.Material[];
+    mesh: THREE.Mesh;
+    castShadow: boolean;
+    receiveShadow: boolean;
+    private particles;
+    private trails;
+    private elapsedTime;
+    constructor(options?: Partial<TrailRendererOptions>);
+    setup(system: ParticleSystem): void;
+    _update(particles: Particle[], system: ParticleSystem, deltaTime: number): void;
+    destroy(): void;
+    private updateParticleTrails;
+    private addTrailPoint;
+    private getPaths;
+    private getParticlePaths;
+    private getRibbonPaths;
+    private rebuildGeometry;
+    private setEmptyGeometry;
+    private appendPathGeometry;
+    private getTangent;
+    private getPerpendicular;
+    private getTextureU;
+    private getParticleSize;
+    private particleHasTrail;
+    private preprocessMaterial;
+}
+export default TrailRenderer;