@soonspacejs/plugin-effect 2.13.17 → 2.14.0

package/dist/libs/SPE.d.ts

@@ -0,0 +1,378 @@
+export default SPE;
+export type distribution = number;
+/**
+ * An SPE.Group instance.
+ */
+export type Group = Object;
+/**
+ * A map of options to configure an SPE.Group instance.
+ */
+export type GroupOptions = {
+    /**
+     * An object describing the texture used by the group.
+     */
+    texture: {
+        value: Object;
+        frames?: Object | undefined;
+        frameCount?: number | undefined;
+        loop: number;
+    };
+    /**
+     * If no `dt` (or `deltaTime`) value is passed to this group's
+     * `tick()` function, this number will be used to move the particle
+     * simulation forward. Value in SECONDS.
+     */
+    fixedTimeStep: number;
+    /**
+     * Whether the distance a particle is from the camera should affect
+     * the particle's size.
+     */
+    hasPerspective: boolean;
+    /**
+     * Whether the particles in this group should be rendered with color, or
+     * whether the only color of particles will come from the provided texture.
+     */
+    colorize: boolean;
+    /**
+     * One of Three.js's blending modes to apply to this group's `ShaderMaterial`.
+     */
+    blending: number;
+    /**
+     * Whether these particle's should be rendered with transparency.
+     */
+    transparent: boolean;
+    /**
+     * Sets the alpha value to be used when running an alpha test on the `texture.value` property. Value between 0 and 1.
+     */
+    alphaTest: number;
+    /**
+     * Whether rendering the group has any effect on the depth buffer.
+     */
+    depthWrite: boolean;
+    /**
+     * Whether to have depth test enabled when rendering this group.
+     */
+    depthTest: boolean;
+    /**
+     * Whether this group's particles should be affected by their scene's fog.
+     */
+    fog: boolean;
+    /**
+     * The scale factor to apply to this group's particle sizes. Useful for
+     * setting particle sizes to be relative to renderer size.
+     */
+    scale: number;
+};
+/**
+ * An SPE.Emitter instance.
+ */
+export type Emitter = Object;
+/**
+ * A map of options to configure an SPE.Emitter instance.
+ */
+export type EmitterOptions = {
+    /**
+     * The default distribution this emitter should use to control
+     * its particle's spawn position and force behaviour.
+     * Must be an SPE.distributions.* value.
+     */
+    type?: number | undefined;
+    /**
+     * The total number of particles this emitter will hold. NOTE: this is not the number
+     * of particles emitted in a second, or anything like that. The number of particles
+     * emitted per-second is calculated by particleCount / maxAge (approximately!)
+     */
+    particleCount?: number | undefined;
+    /**
+     * The duration in seconds that this emitter should live for. If not specified, the emitter
+     *  will emit particles indefinitely.
+     *  NOTE: When an emitter is older than a specified duration, the emitter is NOT removed from
+     *  it's group, but rather is just marked as dead, allowing it to be reanimated at a later time
+     *  using `SPE.Emitter.prototype.enable()`.
+     */
+    duration?: number | null | undefined;
+    /**
+     * Whether this emitter should be not be simulated (true).
+     */
+    isStatic?: boolean | undefined;
+    /**
+     * A value between 0 and 1 describing what percentage of this emitter's particlesPerSecond should be
+     *  emitted, where 0 is 0%, and 1 is 100%.
+     *  For example, having an emitter with 100 particles, a maxAge of 2, yields a particlesPerSecond
+     *  value of 50. Setting `activeMultiplier` to 0.5, then, will only emit 25 particles per second (0.5 = 50%).
+     *  Values greater than 1 will emulate a burst of particles, causing the emitter to run out of particles
+     *  before it's next activation cycle.
+     */
+    activeMultiplier?: boolean | undefined;
+    /**
+     * The direction of the emitter. If value is `1`, emitter will start at beginning of particle's lifecycle.
+     *  If value is `-1`, emitter will start at end of particle's lifecycle and work it's way backwards.
+     */
+    direction?: boolean | undefined;
+    /**
+     * An object describing the particle's maximum age in seconds.
+     */
+    maxAge?: {
+        /**
+         * A number between 0 and 1 describing the amount of maxAge to apply to all particles.
+         */
+        value?: number | undefined;
+        /**
+         * A number describing the maxAge variance on a per-particle basis.
+         */
+        spread?: number | undefined;
+    } | undefined;
+    /**
+     * An object describing this emitter's position.
+     */
+    position?: {
+        /**
+         * A THREE.Vector3 instance describing this emitter's base position.
+         */
+        value?: Object | undefined;
+        /**
+         * A THREE.Vector3 instance describing this emitter's position variance on a per-particle basis.
+         *  Note that when using a SPHERE or DISC distribution, only the x-component
+         *  of this vector is used.
+         *  When using a LINE distribution, this value is the endpoint of the LINE.
+         */
+        spread?: Object | undefined;
+        /**
+         * A THREE.Vector3 instance describing the numeric multiples the particle's should
+         *  be spread out over.
+         *  Note that when using a SPHERE or DISC distribution, only the x-component
+         *  of this vector is used.
+         *  When using a LINE distribution, this property is ignored.
+         */
+        spreadClamp?: Object | undefined;
+        /**
+         * This emitter's base radius.
+         */
+        radius?: number | undefined;
+        /**
+         * A THREE.Vector3 instance describing the radius's scale in all three axes. Allows a SPHERE or DISC to be squashed or stretched.
+         */
+        radiusScale?: Object | undefined;
+        /**
+         * of the `type` option.] A specific distribution to use when radiusing particles. Overrides the `type` option.
+         */
+        distribution?: number | undefined;
+        /**
+         * When a particle is re-spawned, whether it's position should be re-randomised or not. Can incur a performance hit.
+         */
+        randomise?: boolean | undefined;
+    } | undefined;
+    /**
+     * An object describing this particle velocity.
+     */
+    velocity?: {
+        /**
+         * A THREE.Vector3 instance describing this emitter's base velocity.
+         */
+        value?: Object | undefined;
+        /**
+         * A THREE.Vector3 instance describing this emitter's velocity variance on a per-particle basis.
+         *  Note that when using a SPHERE or DISC distribution, only the x-component
+         *  of this vector is used.
+         */
+        spread?: Object | undefined;
+        /**
+         * of the `type` option.] A specific distribution to use when calculating a particle's velocity. Overrides the `type` option.
+         */
+        distribution?: number | undefined;
+        /**
+         * When a particle is re-spawned, whether it's velocity should be re-randomised or not. Can incur a performance hit.
+         */
+        randomise?: boolean | undefined;
+    } | undefined;
+    /**
+     * An object describing this particle's acceleration.
+     */
+    acceleration?: {
+        /**
+         * A THREE.Vector3 instance describing this emitter's base acceleration.
+         */
+        value?: Object | undefined;
+        /**
+         * A THREE.Vector3 instance describing this emitter's acceleration variance on a per-particle basis.
+         * Note that when using a SPHERE or DISC distribution, only the x-component
+         * of this vector is used.
+         */
+        spread?: Object | undefined;
+        /**
+         * of the `type` option.] A specific distribution to use when calculating a particle's acceleration. Overrides the `type` option.
+         */
+        distribution?: number | undefined;
+        /**
+         * When a particle is re-spawned, whether it's acceleration should be re-randomised or not. Can incur a performance hit.
+         */
+        randomise?: boolean | undefined;
+    } | undefined;
+    /**
+     * An object describing this particle drag. Drag is applied to both velocity and acceleration values.
+     */
+    drag?: {
+        /**
+         * A number between 0 and 1 describing the amount of drag to apply to all particles.
+         */
+        value?: number | undefined;
+        /**
+         * A number describing the drag variance on a per-particle basis.
+         */
+        spread?: number | undefined;
+        /**
+         * When a particle is re-spawned, whether it's drag should be re-randomised or not. Can incur a performance hit.
+         */
+        randomise?: boolean | undefined;
+    } | undefined;
+    /**
+     * This is quite a fun one! The values of this object will determine whether a particle will wiggle, or jiggle, or wave,
+     *  or shimmy, or waggle, or... Well you get the idea. The wiggle is calculated over-time, meaning that a particle will
+     *  start off with no wiggle, and end up wiggling about with the distance of the `value` specified by the time it dies.
+     *  It's quite handy to simulate fire embers, or similar effects where the particle's position should slightly change over
+     *  time, and such change isn't easily controlled by rotation, velocity, or acceleration. The wiggle is a combination of sin and cos calculations, so is circular in nature.
+     */
+    wiggle?: {
+        /**
+         * A number describing the amount of wiggle to apply to all particles. It's measured in distance.
+         */
+        value?: number | undefined;
+        /**
+         * A number describing the wiggle variance on a per-particle basis.
+         */
+        spread?: number | undefined;
+    } | undefined;
+    /**
+     * An object describing this emitter's rotation. It can either be static, or set to rotate from 0radians to the value of `rotation.value`
+     *  over a particle's lifetime. Rotation values affect both a particle's position and the forces applied to it.
+     */
+    rotation?: {
+        /**
+         * A THREE.Vector3 instance describing this emitter's axis of rotation.
+         */
+        axis?: Object | undefined;
+        /**
+         * A THREE.Vector3 instance describing the amount of variance to apply to the axis of rotation on
+         *  a per-particle basis.
+         */
+        axisSpread?: Object | undefined;
+        /**
+         * The angle of rotation, given in radians. If `rotation.static` is true, the emitter will start off rotated at this angle, and stay as such.
+         *  Otherwise, the particles will rotate from 0radians to this value over their lifetimes.
+         */
+        angle?: number | undefined;
+        /**
+         * The amount of variance in each particle's rotation angle.
+         */
+        angleSpread?: number | undefined;
+        /**
+         * Whether the rotation should be static or not.
+         */
+        static?: boolean | undefined;
+        /**
+         * value of `position.value`] A THREE.Vector3 instance describing the center point of rotation.
+         */
+        center?: Object | undefined;
+        /**
+         * When a particle is re-spawned, whether it's rotation should be re-randomised or not. Can incur a performance hit.
+         */
+        randomise?: boolean | undefined;
+    } | undefined;
+    /**
+     * An object describing a particle's color. This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
+     *  given to describe specific value changes over a particle's lifetime.
+     *  Depending on the value of SPE.valueOverLifetimeLength, if arrays of THREE.Color instances are given, then the array will be interpolated to
+     *  have a length matching the value of SPE.valueOverLifetimeLength.
+     */
+    color?: {
+        /**
+         * Either a single THREE.Color instance, or an array of THREE.Color instances to describe the color of a particle over it's lifetime.
+         */
+        value?: Object | undefined;
+        /**
+         * Either a single THREE.Vector3 instance, or an array of THREE.Vector3 instances to describe the color variance of a particle over it's lifetime.
+         */
+        spread?: Object | undefined;
+        /**
+         * When a particle is re-spawned, whether it's color should be re-randomised or not. Can incur a performance hit.
+         */
+        randomise?: boolean | undefined;
+    } | undefined;
+    /**
+     * An object describing a particle's opacity. This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
+     * given to describe specific value changes over a particle's lifetime.
+     * Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to
+     * have a length matching the value of SPE.valueOverLifetimeLength.
+     */
+    opacity?: {
+        /**
+         * Either a single number, or an array of numbers to describe the opacity of a particle over it's lifetime.
+         */
+        value?: number | undefined;
+        /**
+         * Either a single number, or an array of numbers to describe the opacity variance of a particle over it's lifetime.
+         */
+        spread?: number | undefined;
+        /**
+         * When a particle is re-spawned, whether it's opacity should be re-randomised or not. Can incur a performance hit.
+         */
+        randomise?: boolean | undefined;
+    } | undefined;
+    /**
+     * An object describing a particle's size. This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
+     *   given to describe specific value changes over a particle's lifetime.
+     *   Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to
+     *   have a length matching the value of SPE.valueOverLifetimeLength.
+     */
+    size?: {
+        /**
+         * Either a single number, or an array of numbers to describe the size of a particle over it's lifetime.
+         */
+        value?: number | undefined;
+        /**
+         * Either a single number, or an array of numbers to describe the size variance of a particle over it's lifetime.
+         */
+        spread?: number | undefined;
+        /**
+         * When a particle is re-spawned, whether it's size should be re-randomised or not. Can incur a performance hit.
+         */
+        randomise?: boolean | undefined;
+    } | undefined;
+    /**
+     * An object describing a particle's angle. The angle is a 2d-rotation, measured in radians, applied to the particle's texture.
+     *  NOTE: if a particle's texture is a sprite-sheet, this value IS IGNORED.
+     *  This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
+     *  given to describe specific value changes over a particle's lifetime.
+     *  Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to
+     *  have a length matching the value of SPE.valueOverLifetimeLength.
+     */
+    angle?: {
+        /**
+         * Either a single number, or an array of numbers to describe the angle of a particle over it's lifetime.
+         */
+        value?: number | undefined;
+        /**
+         * Either a single number, or an array of numbers to describe the angle variance of a particle over it's lifetime.
+         */
+        spread?: number | undefined;
+        /**
+         * When a particle is re-spawned, whether it's angle should be re-randomised or not. Can incur a performance hit.
+         */
+        randomise?: boolean | undefined;
+    } | undefined;
+};
+/**
+ * @typedef {Number} distribution
+ * @property {Number} SPE.distributions.BOX Values will be distributed within a box.
+ * @property {Number} SPE.distributions.SPHERE Values will be distributed within a sphere.
+ * @property {Number} SPE.distributions.DISC Values will be distributed within a 2D disc.
+ */
+/**
+ * Namespace for Shader Particle Engine.
+ *
+ * All SPE-related code sits under this namespace.
+ *
+ * @type {any}
+ * @namespace
+ */
+declare var SPE: any;

package/dist/smoke2/getParticleSystem.d.ts

@@ -0,0 +1,5 @@
+export function getParticleSystem(params: any): {
+    points: THREE.Points<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.ShaderMaterial, THREE.Object3DEventMap>;
+    update: (timeElapsed: any) => void;
+};
+import * as THREE from 'three';

package/dist/water/index.d.ts

@@ -1,5 +1,4 @@
-import type { Texture, ColorRepresentation, ShaderMaterialParameters, Mesh } from 'three';
-import { Vector3 } from 'three';
+import { Texture, ColorRepresentation, ShaderMaterialParameters, Mesh, Vector3 } from 'three';
 import { IVector3 } from 'soonspacejs';
 export interface WaterOptions extends ShaderMaterialParameters {
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@soonspacejs/plugin-effect",
   "pluginName": "EffectPlugin",
-  "version": "2.13.17",
+  "version": "2.14.0",
   "description": "Effect plugin for SoonSpace.js",
   "main": "dist/index.esm.js",
   "module": "dist/index.esm.js",
@@ -17,8 +17,8 @@
     "@three3d/particle": "^1.0.4",
     "heatmap-ts": "^0.0.4"
   },
-  "gitHead": "8afa5fda9a0ef2c080060e7d8e71a8bf168fd4d2",
+  "gitHead": "4c85e8b7b8ad24ccb9b42f3a1826bca377c42a6d",
   "peerDependencies": {
-    "soonspacejs": "2.13.17"
+    "soonspacejs": "2.14.0"
   }
 }