@hology/core 0.0.27 → 0.0.30

package/dist/effects/vfx/behaviours.d.ts

@@ -0,0 +1,26 @@
+import { Behaviour, Emitter, Particle, EasingFunction } from "three-nebula";
+/**
+ * Rotate position around an axis.
+ */
+export declare class RotatePosition extends Behaviour {
+    private axis;
+    private angle;
+    constructor(axis: THREE.Vector3, angle: number);
+    private axis3D;
+    mutate(target: Particle | Emitter, time: number, index: number): void;
+}
+export declare class LinearDamping extends Behaviour {
+    private factor;
+    constructor(factor: number);
+    mutate(target: Particle | Emitter, time: number, index: number): void;
+}
+export declare class MoveOverLife extends Behaviour {
+    private x;
+    private y;
+    private z;
+    private displacement;
+    private initial;
+    constructor(x: number, y: number, z: number, easing?: EasingFunction);
+    initialize(particle: Particle): void;
+    mutate(target: Particle | Emitter, time: number, index: number): void;
+}

package/dist/effects/vfx/behaviours.js

@@ -0,0 +1,5 @@
+import{Behaviour as i,Vector3D as t,ease as s}from"three-nebula";export class RotatePosition extends i{constructor(i,s){super(),this.axis=i,this.angle=s,this.axis3D=new t(this.axis.x,this.axis.y,this.axis.z)}mutate(i,t,s){this.energize(i,t),i.position.sub(i.parent.position),i.position.applyAxisAngle(this.axis3D,this.angle*t),i.position.add(i.parent.position)}}export class LinearDamping extends i{constructor(i){super(),this.factor=i}mutate(i,t,s){this.energize(i,t);const o=e.copy(i.velocity).multiplyScalar(-this.factor*t);i.velocity.add(o)}}const e=new t;export class MoveOverLife extends i{constructor(i,t,e,o=s.easeLinear){super(void 0,o,void 0,!0),this.x=i,this.y=t,this.z=e}initialize(i){i.transform.initialPos=i.position.clone()}mutate(i,t,s){this.energize(i,t);const e=i.transform.initialPos,o=1-this.energy;i.position.x=e.x+this.x*o,i.position.y=e.y+this.y*o,i.position.z=e.z+this.z*o}}
+/*
+ * Copyright (©) 2023. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/effects/vfx/index.d.ts

@@ -0,0 +1,2 @@
+export * from './vfx-asset';
+export * from './vfx-materializer';

package/dist/effects/vfx/index.js

@@ -0,0 +1,5 @@
+export*from"./vfx-asset";export*from"./vfx-materializer";
+/*
+ * Copyright (©) 2023. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/effects/vfx/initializsers.d.ts

@@ -0,0 +1,44 @@
+import { Vector3 } from "three";
+import Initializer, { Emitter, Particle } from "three-nebula";
+export declare class Rotation extends Initializer {
+    private rotation;
+    constructor(rotation: Vector3);
+    init(emitter: Emitter, particle: Particle): void;
+}
+export declare class InitialScale extends Initializer {
+    private scale;
+    constructor(scale: number);
+    init(emitter: Emitter, particle: Particle): void;
+}
+export declare class AdditiveVelocity extends Initializer {
+    private velocity;
+    constructor(velocity: Vector3);
+    init(emitter: Emitter, particle: Particle): void;
+}
+export declare class RandomDirection extends Initializer {
+    private speed;
+    constructor(speed: number);
+    init(emitter: Emitter, particle: Particle): void;
+}
+/**
+ * Restrict randomness with two vectors
+ */
+export declare class RandomComponentsDirection extends Initializer {
+    private speed;
+    private min;
+    private max;
+    private x;
+    private y;
+    private z;
+    constructor(speed: number, min: Vector3, max: Vector3);
+    init(emitter: Emitter, particle: Particle): void;
+}
+export declare class RandomVelocity extends Initializer {
+    private min;
+    private max;
+    private x;
+    private y;
+    private z;
+    constructor(min: Vector3, max: Vector3);
+    init(emitter: Emitter, particle: Particle): void;
+}

package/dist/effects/vfx/initializsers.js

@@ -0,0 +1,5 @@
+import{Vector3 as t}from"three";import i,{Span as e}from"three-nebula";export class Rotation extends i{constructor(t){super(),this.rotation=t}init(t,i){"number"!=typeof i.rotation&&i.rotation.copy(this.rotation)}}export class InitialScale extends i{constructor(t){super(),this.scale=t}init(t,i){i.scale=this.scale}}export class AdditiveVelocity extends i{constructor(t){super(),this.velocity=t}init(t,i){i.velocity.x+=this.velocity.x,i.velocity.y+=this.velocity.y,i.velocity.z+=this.velocity.z}}export class RandomDirection extends i{constructor(t){super(),this.speed=t}init(t,i){s.set(2*Math.random()-1,2*Math.random()-1,2*Math.random()-1).normalize().multiplyScalar(this.speed),i.velocity.x+=s.x,i.velocity.y+=s.y,i.velocity.z+=s.z}}export class RandomComponentsDirection extends i{constructor(t,i,s){super(),this.speed=t,this.min=i,this.max=s,this.x=new e(this.min.x,this.max.x),this.y=new e(this.min.y,this.max.y),this.z=new e(this.min.z,this.max.z)}init(t,i){s.set(this.x.getValue(),this.y.getValue(),this.z.getValue()).normalize().multiplyScalar(this.speed),i.velocity.x+=s.x,i.velocity.y+=s.y,i.velocity.z+=s.z}}export class RandomVelocity extends i{constructor(t,i){super(),this.min=t,this.max=i,this.x=new e(this.min.x,this.max.x),this.y=new e(this.min.y,this.max.y),this.z=new e(this.min.z,this.max.z)}init(t,i){i.velocity.x+=this.x.getValue(),i.velocity.y+=this.y.getValue(),i.velocity.z+=this.z.getValue()}}const s=new t;
+/*
+ * Copyright (©) 2023. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/effects/vfx/rates.d.ts

@@ -0,0 +1,6 @@
+import { Rate } from "three-nebula";
+export { Rate } from 'three-nebula';
+export declare class OnceRate extends Rate {
+    constructor(count?: number);
+    restart(): void;
+}

package/dist/effects/vfx/rates.js

@@ -0,0 +1,5 @@
+import{Rate as e}from"three-nebula";export{Rate}from"three-nebula";export class OnceRate extends e{constructor(e=1){super(e,1/0)}restart(){this.nextTime=0}}
+/*
+ * Copyright (©) 2023. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/effects/vfx/vfx-actor.d.ts

@@ -0,0 +1,27 @@
+import { BaseActor } from "../../gameplay";
+import { VfxAsset } from "../../scene/model";
+export declare class VfxActor extends BaseActor {
+    /**
+     * A multiplier for the speed of the visual effect.
+     */
+    timescale: number;
+    paused: boolean;
+    private system;
+    private disposeSystem;
+    private sourceAsset;
+    private assetLoader;
+    private world;
+    /**
+     * Replace visual effect with its definition in an asset
+     */
+    fromAsset(asset: VfxAsset): Promise<void>;
+    play(): void;
+    pause(): void;
+    stop(): void;
+    restart(): void;
+    private _worldPos;
+    private max;
+    onUpdate(deltaTime: number): void;
+    getParticleCount(): any;
+    onEndPlay(): void;
+}

package/dist/effects/vfx/vfx-actor.js

@@ -0,0 +1,5 @@
+import{__awaiter as t,__decorate as s}from"tslib";import{Actor as e,BaseActor as i,AssetLoader as o,inject as r,World as a}from"../../gameplay";import{Rate as h}from"three-nebula";import{OnceRate as m}from"./rates";import{materializeVfx as l}from"./vfx-materializer";import*as d from"three";let n=class extends i{constructor(){super(...arguments),this.timescale=1,this.paused=!1,this.assetLoader=r(o),this.world=r(a),this._worldPos=new d.Vector3,this.max=0}fromAsset(s){return t(this,void 0,void 0,(function*(){null!=this.system&&(this.system.destroy(),this.system.emitters.forEach((t=>t.reset()))),this.sourceAsset=s,this.disposeSystem&&this.disposeSystem();const{system:t,dispose:e}=yield l(s,this.world.scene,{getMaterial:t=>this.assetLoader.getMaterialByAssetId(t),getTexture:t=>this.assetLoader.getTextureByAssetId(t),getMesh:t=>this.assetLoader.getModelByAssetId(t).then((t=>t.scene))});this.system=t,this.disposeSystem=e}))}play(){this.paused=!1;this.system.emitters.every((t=>t.dead))&&this.restart()}pause(){this.paused=!0}stop(){this.system.emitters.forEach((t=>{const s=t.rate;s instanceof h&&(console.log("set rate to infinity",s),s.nextTime=1/0)}))}restart(){for(const t of this.system.emitters){t.removeAllParticles();const s=t.rate;s.nextTime=0,s instanceof m&&s.restart()}}onUpdate(t){var s,e;this.paused||(this.object.getWorldPosition(this._worldPos),null===(s=this.system)||void 0===s||s.emitters.forEach((t=>{t.setPosition(this._worldPos)})),null===(e=this.system)||void 0===e||e.update(t*this.timescale))}getParticleCount(){var t,s;return null!==(s=null===(t=this.system)||void 0===t?void 0:t.getCount())&&void 0!==s?s:0}onEndPlay(){this.stop(),console.log("end play"),null!=this.disposeSystem&&this.disposeSystem()}};n=s([e()],n);export{n as VfxActor};
+/*
+ * Copyright (©) 2023. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/effects/vfx/vfx-asset.d.ts

@@ -0,0 +1,99 @@
+import { LibraryShapeType } from "../../scene/objects/shapes";
+import { AssetId, CustomParamValue, SerializedParamType } from "../../scene/model";
+import { LibraryVfxBehaviourType, LibraryVfxInitalizerType } from './vfx-defs';
+import * as THREE from "three";
+export type OnceRateData = {
+    type: 'once';
+    count: number;
+};
+export type ContinuousRateData = {
+    type: 'continuous';
+    count: number;
+    time: number;
+};
+export type RateData = OnceRateData | ContinuousRateData;
+export type InitializerData = {
+    id: string;
+    type: LibraryVfxInitalizerType;
+    params: Record<string, CustomParamValue>;
+};
+export interface BehaviourData {
+    id: string;
+    type: LibraryVfxBehaviourType;
+    params: Record<string, CustomParamValue>;
+}
+export type Vector3Data = [number, number, number];
+export declare const BlendingModes: readonly ["additive", "subtractive", "multiply", "normal"];
+export type BlendingMode = (typeof BlendingModes)[number];
+export declare const ThreeBlendingMode: {
+    normal: THREE.Blending;
+    additive: THREE.Blending;
+    subtractive: THREE.Blending;
+    multiply: THREE.Blending;
+};
+export type SpriteOutput = {
+    type: 'sprite';
+    texture: string;
+    color: string;
+    blendingMode: BlendingMode;
+};
+export type MeshOutput = {
+    type: 'mesh';
+    assetId: AssetId;
+};
+export type ShapeOutput = {
+    type: 'shape';
+    shape: LibraryShapeType;
+    params: Record<string, CustomParamValue>;
+    material: AssetId;
+};
+export type EmitterOutput = SpriteOutput | MeshOutput | ShapeOutput;
+export type EmitterData = {
+    id: string;
+    name: string;
+    rate: RateData;
+    position: Vector3Data;
+    rotation: Vector3Data;
+    initializers: InitializerData[];
+    behaviours: BehaviourData[];
+    children?: EmitterData[];
+    output: EmitterOutput;
+};
+export type VfxAssetData = {
+    /**
+     * Whether particles position should be relative to local space as opposed to world space.
+     * It is usually not realistic that particles moves along with it's parent object but
+     * it can be useful for certain effects.
+     */
+    localSpace?: boolean;
+    emitters: EmitterData[];
+};
+export declare function EmitterDataConstructor(): {
+    id: string;
+    name: string;
+    rate: {
+        type: "continuous";
+        count: number;
+        time: number;
+    };
+    position: [number, number, number];
+    rotation: [number, number, number];
+    initializers: {
+        id: string;
+        type: "lifetime";
+        params: {
+            duration: {
+                type: SerializedParamType.Number;
+                value: number;
+            };
+        };
+    }[];
+    behaviours: any[];
+    children: any[];
+    output: {
+        type: "sprite";
+        texture: any;
+        color: string;
+        blendingMode: "normal";
+    };
+};

package/dist/effects/vfx/vfx-asset.js

@@ -0,0 +1,5 @@
+import{SerializedParamType as t}from"../../scene/model";import*as e from"three";import{randomString as i}from"../../utils/math";export const BlendingModes=["additive","subtractive","multiply","normal"];export const ThreeBlendingMode={normal:e.NormalBlending,additive:e.AdditiveBlending,subtractive:e.SubtractiveBlending,multiply:e.MultiplyBlending};export function EmitterDataConstructor(){return{id:i(),name:"Emitter",rate:{type:"continuous",count:1,time:.5},position:[0,0,0],rotation:[0,0,0],initializers:[{id:i(),type:"lifetime",params:{duration:{type:t.Number,value:1}}}],behaviours:[],children:[],output:{type:"sprite",texture:null,color:"#ffffff",blendingMode:"normal"}}}
+/*
+ * Copyright (©) 2023. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/effects/vfx/vfx-defs.d.ts

@@ -0,0 +1,207 @@
+import { Vector2, Vector3 } from "three";
+import { Behaviour } from "three-nebula";
+import Initializer from "three-nebula/src/initializer/Initializer";
+type HexColor = `#${string}`;
+export type ShapeParameterDef<T = boolean | number | string | Vector3 | Vector2 | HexColor> = {
+    type: T extends number ? 'number' : T extends HexColor ? 'color' : T extends string ? 'string' | 'select' : T extends Vector2 ? 'vec2' : T extends Vector3 ? 'vec3' : T extends boolean ? 'boolean' : never;
+    default: T;
+};
+type FloatParameterDef = ShapeParameterDef<number> & {
+    float: boolean;
+    min?: number;
+    max?: number;
+};
+export type SelectParameterDef<T> = ShapeParameterDef<T> & {
+    type: 'select';
+    opts: Readonly<T[]>;
+};
+interface InitializerDefinition {
+    build(params?: any): Initializer;
+    parameters?: Record<string, ShapeParameterDef>;
+}
+interface BehaviourDefinition {
+    build(params?: any): Behaviour;
+    parameters?: Record<string, ShapeParameterDef>;
+}
+declare abstract class BaseBevDef<T extends DefBuilder> implements BehaviourDefinition {
+    abstract parameters: any;
+    build(params?: ParamsType<T>): Behaviour;
+    abstract make(params: ParamsType<T>): Behaviour;
+}
+declare abstract class BaseIniDef<T extends DefBuilder> implements InitializerDefinition {
+    abstract parameters: any;
+    build(params?: ParamsType<T>): Initializer;
+    abstract make(params: ParamsType<T>): Initializer;
+}
+export type DefBuilder = {
+    parameters?: Record<string, ShapeParameterDef>;
+};
+type ParamsType<T extends DefBuilder> = Partial<{
+    [K in keyof T['parameters']]: T['parameters'][K]['default'];
+}>;
+declare class LifetimeDef extends BaseIniDef<LifetimeDef> {
+    parameters: {
+        duration: ShapeParameterDef<number>;
+    };
+    make(params?: ParamsType<this>): Initializer;
+}
+declare class VelocityDef extends BaseIniDef<VelocityDef> {
+    parameters: {
+        velocity: ShapeParameterDef<Vector3>;
+    };
+    make(params?: ParamsType<this>): Initializer;
+}
+declare class PositionPointDef extends BaseIniDef<PositionPointDef> {
+    parameters: {
+        position: ShapeParameterDef<Vector3>;
+    };
+    make(params?: ParamsType<this>): Initializer;
+}
+declare class PositionBoxDef extends BaseIniDef<PositionBoxDef> {
+    parameters: {
+        position: ShapeParameterDef<Vector3>;
+        dimensions: ShapeParameterDef<Vector3>;
+    };
+    make(params?: ParamsType<this>): Initializer;
+}
+declare class PositionSphereDef extends BaseIniDef<PositionBoxDef> {
+    parameters: {
+        position: ShapeParameterDef<Vector3>;
+        radius: FloatParameterDef;
+    };
+    make(params?: ParamsType<this>): Initializer;
+}
+declare class PositionLineDef extends BaseIniDef<PositionLineDef> {
+    parameters: {
+        a: ShapeParameterDef<Vector3>;
+        b: ShapeParameterDef<Vector3>;
+    };
+    make(params?: ParamsType<this>): Initializer;
+}
+declare class RandomDirectionDef extends BaseIniDef<RandomDirectionDef> {
+    parameters: {
+        speed: FloatParameterDef;
+    };
+    make(params?: ParamsType<this>): Initializer;
+}
+declare class MassDef extends BaseIniDef<MassDef> {
+    parameters: {
+        min: FloatParameterDef;
+    };
+    make(params?: ParamsType<this>): Initializer;
+}
+declare class RotationDef extends BaseIniDef<RotationDef> {
+    parameters: {
+        rotation: ShapeParameterDef<Vector3>;
+    };
+    make(params?: ParamsType<this>): Initializer;
+}
+declare class InitialScaleDef extends BaseIniDef<InitialScaleDef> {
+    parameters: {
+        scale: FloatParameterDef;
+    };
+    make(params?: ParamsType<this>): Initializer;
+}
+declare class ForceDef extends BaseBevDef<ForceDef> {
+    parameters: {
+        force: ShapeParameterDef<Vector3>;
+        ease: SelectParameterDef<string>;
+    };
+    make(params?: ParamsType<this>): Behaviour;
+}
+declare class GravityDef extends BaseBevDef<GravityDef> {
+    parameters: {
+        gravity: FloatParameterDef;
+    };
+    make(params?: ParamsType<this>): Behaviour;
+}
+declare class ScaleDef extends BaseBevDef<ScaleDef> {
+    parameters: {
+        a: FloatParameterDef;
+        b: FloatParameterDef;
+        ease: SelectParameterDef<string>;
+    };
+    make(params?: ParamsType<this>): Behaviour;
+}
+declare class RandomDriftDef extends BaseBevDef<RandomDriftDef> {
+    parameters: {
+        drift: ShapeParameterDef<Vector3>;
+        delay: FloatParameterDef;
+        ease: SelectParameterDef<string>;
+    };
+    make(params?: ParamsType<this>): Behaviour;
+}
+declare class RotateDef extends BaseBevDef<RotateDef> {
+    parameters: {
+        rotation: ShapeParameterDef<Vector3>;
+        ease: SelectParameterDef<string>;
+    };
+    make(params?: ParamsType<this>): Behaviour;
+}
+declare class ChangeColorDef extends BaseBevDef<ChangeColorDef> {
+    parameters: {
+        a: ShapeParameterDef<`#${string}`>;
+        b: ShapeParameterDef<`#${string}`>;
+        ease: SelectParameterDef<string>;
+    };
+    make(params?: ParamsType<this>): Behaviour;
+}
+declare class ChangeOpacityDef extends BaseBevDef<ChangeOpacityDef> {
+    parameters: {
+        a: FloatParameterDef;
+        b: FloatParameterDef;
+        ease: SelectParameterDef<string>;
+    };
+    make(params?: ParamsType<this>): Behaviour;
+}
+declare class VortexDef extends BaseBevDef<VortexDef> {
+    parameters: {
+        axis: ShapeParameterDef<Vector3>;
+        amount: FloatParameterDef;
+    };
+    make(params?: ParamsType<this>): Behaviour;
+}
+declare class MoveToDef extends BaseBevDef<MoveToDef> {
+    parameters: {
+        target: ShapeParameterDef<Vector3>;
+        ease: SelectParameterDef<string>;
+    };
+    make(params?: ParamsType<this>): Behaviour;
+}
+declare class LinearDampingDef extends BaseBevDef<LinearDampingDef> {
+    parameters: {
+        factor: FloatParameterDef;
+    };
+    make(params?: ParamsType<this>): Behaviour;
+}
+declare const vfxInitializsers: {
+    lifetime: LifetimeDef;
+    positionPoint: PositionPointDef;
+    positionBox: PositionBoxDef;
+    positionSphere: PositionSphereDef;
+    positionLine: PositionLineDef;
+    rotation: RotationDef;
+    scale: InitialScaleDef;
+    mass: MassDef;
+    velocity: VelocityDef;
+    randomDirection: RandomDirectionDef;
+};
+declare const vfxBehaviours: {
+    force: ForceDef;
+    gravity: GravityDef;
+    scale: ScaleDef;
+    randomDrift: RandomDriftDef;
+    rotate: RotateDef;
+    changeColor: ChangeColorDef;
+    changeOpacity: ChangeOpacityDef;
+    vortex: VortexDef;
+    moveTo: MoveToDef;
+    linearDamping: LinearDampingDef;
+};
+export type LibraryVfxInitalizerType = keyof typeof vfxInitializsers;
+export declare const VfxInitializserLibrary: Record<LibraryVfxInitalizerType, InitializerDefinition>;
+export declare const VfxInitializserLibraryKeys: ("rotation" | "scale" | "mass" | "velocity" | "lifetime" | "positionPoint" | "positionBox" | "positionSphere" | "positionLine" | "randomDirection")[];
+export type LibraryVfxBehaviourType = keyof typeof vfxBehaviours;
+export declare const VfxBehaviourLibrary: Record<LibraryVfxBehaviourType, BehaviourDefinition>;
+export declare const VfxBehaviourLibraryKeys: ("scale" | "rotate" | "force" | "gravity" | "randomDrift" | "changeColor" | "changeOpacity" | "vortex" | "moveTo" | "linearDamping")[];
+export {};

package/dist/effects/vfx/vfx-defs.js

@@ -0,0 +1,5 @@
+import{Color as e,MathUtils as r,Vector2 as t,Vector3 as s}from"three";import{Life as n,Force as a,Gravity as o,Scale as i,RandomDrift as c,Color as u,Alpha as m,Rotate as p,Mass as d,ease as l,Position as f,BoxZone as w,LineZone as x}from"three-nebula";import{LinearDamping as y,MoveOverLife as h,RotatePosition as k}from"./behaviours";import{AdditiveVelocity as b,InitialScale as v,RandomDirection as z,Rotation as g}from"./initializsers";import{SphereZone as L,PointZone as V}from"./zones";class B{build(e={}){const r=R(e,this.parameters);return this.make(r)}}class O{build(e={}){const r=R(e,this.parameters);return this.make(r)}}function T(e,r,t){return{type:"number",default:e,float:!0,min:r,max:t}}function j(e){return{type:"vec3",default:(new s).fromArray(e)}}function D(e){return{type:"color",default:e}}function I(){return{type:"select",opts:Array.from(Object.keys(l)).map((e=>e.substring(4))),default:"Linear"}}function R(e,r){const t={};for(let s in r)null==e[s]?t[s]=r[s].default:t[s]=e[s];return t}function A(e){return null!=e?l["ease"+e]:l.easeLinear}const C={lifetime:new class extends O{constructor(){var e;super(...arguments),this.parameters={duration:(e=1,{type:"number",default:e})}}make(e={}){return new n(e.duration)}},positionPoint:new class extends O{constructor(){super(...arguments),this.parameters={position:j([0,0,0])}}make(e={}){const{x:r,y:t,z:s}=e.position;return new f(new V(r,t,s))}},positionBox:new class extends O{constructor(){super(...arguments),this.parameters={position:j([0,0,0]),dimensions:j([0,0,0])}}make(e={}){const{x:r,y:t,z:s}=e.position,{x:n,y:a,z:o}=e.dimensions;return new f(new w(r,t,s,n,a,o))}},positionSphere:new class extends O{constructor(){super(...arguments),this.parameters={position:j([0,0,0]),radius:T(1)}}make(e={}){const{x:r,y:t,z:s}=e.position;return new f(new L(r,t,s,e.radius))}},positionLine:new class extends O{constructor(){super(...arguments),this.parameters={a:j([0,0,0]),b:j([0,0,1])}}make(e={}){const{x:r,y:t,z:s}=e.a,{x:n,y:a,z:o}=e.b;return new f(new x(r,t,s,n,a,o))}},rotation:new class extends O{constructor(){super(...arguments),this.parameters={rotation:j([0,0,0])}}make(e={}){const{x:r,y:t,z:n}=e.rotation;return new g(new s(r,t,n))}},scale:new class extends O{constructor(){super(...arguments),this.parameters={scale:T(1)}}make(e={}){return new v(e.scale)}},mass:new class extends O{constructor(){super(...arguments),this.parameters={min:T(1)}}make(e={}){return new d(e.min)}},velocity:new class extends O{constructor(){super(...arguments),this.parameters={velocity:j([0,0,0])}}make(e={}){const{x:r,y:t,z:n}=e.velocity;return new b(new s(r,t,n))}},randomDirection:new class extends O{constructor(){super(...arguments),this.parameters={speed:T(1)}}make(e={}){return new z(e.speed)}}},K={force:new class extends B{constructor(){super(...arguments),this.parameters={force:j([0,0,0]),ease:I()}}make(e={}){return new a(e.force.x,e.force.y,e.force.z,void 0,A(e.ease))}},gravity:new class extends B{constructor(){super(...arguments),this.parameters={gravity:T(8)}}make(e={}){return new o(e.gravity)}},scale:new class extends B{constructor(){super(...arguments),this.parameters={a:T(1),b:T(1),ease:I()}}make(e={}){return new i(e.a,e.b,void 0,A(e.ease))}},randomDrift:new class extends B{constructor(){super(...arguments),this.parameters={drift:j([1,1,1]),delay:T(0),ease:I()}}make(e={}){return new c(e.drift.x,e.drift.y,e.drift.z,e.delay,void 0,A(e.ease))}},rotate:new class extends B{constructor(){super(...arguments),this.parameters={rotation:j([1,1,1]),ease:I()}}make(e={}){const{x:t,y:s,z:n}=e.rotation;return new p(r.degToRad(t),r.degToRad(s),r.degToRad(n),void 0,A(e.ease))}},changeColor:new class extends B{constructor(){super(...arguments),this.parameters={a:D("#ffffff"),b:D("#ffffff"),ease:I()}}make(r={}){return new u(new e(r.a),new e(r.b),void 0,A(r.ease))}},changeOpacity:new class extends B{constructor(){super(...arguments),this.parameters={a:T(1,0,1),b:T(0,0,1),ease:I()}}make(e={}){return new m(e.a,e.b,void 0,A(e.ease))}},vortex:new class extends B{constructor(){super(...arguments),this.parameters={axis:j([0,1,0]),amount:T(1)}}make(e={}){return new k(e.axis,e.amount)}},moveTo:new class extends B{constructor(){super(...arguments),this.parameters={target:j([0,1,0]),ease:I()}}make(e={}){return new h(e.target.x,e.target.y,e.target.z,A(e.ease))}},linearDamping:new class extends B{constructor(){super(...arguments),this.parameters={factor:T(.1,0,1)}}make(e={}){return new y(e.factor)}}};export const VfxInitializserLibrary=C;export const VfxInitializserLibraryKeys=Object.keys(VfxInitializserLibrary);export const VfxBehaviourLibrary=K;export const VfxBehaviourLibraryKeys=Object.keys(VfxBehaviourLibrary);
+/*
+ * Copyright (©) 2023. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/effects/vfx/vfx-materializer.d.ts

@@ -0,0 +1,19 @@
+import { VfxAsset } from "../../scene/model";
+import { Object3D } from "three";
+import * as THREE from 'three';
+import System, { MeshRenderer, Rate } from "three-nebula";
+export type VfxAssetProvider = {
+    getTexture(assetId: string): Promise<THREE.Texture>;
+    getMesh(assetId: string): Promise<THREE.Object3D>;
+    getMaterial(assetId: string): Promise<THREE.Material>;
+};
+export declare function materializeVfx(asset: VfxAsset, target: Object3D, assetProvider: VfxAssetProvider): Promise<{
+    system: System;
+    dispose: () => Object3D<THREE.Event>;
+}>;
+export declare function materializeVfxOld(asset: VfxAsset, target: Object3D): {
+    system: System;
+    rate: Rate;
+    renderer: MeshRenderer;
+    dispose: () => Object3D<THREE.Event>;
+};

package/dist/effects/vfx/vfx-materializer.js

@@ -0,0 +1,5 @@
+import{__awaiter as e}from"tslib";import{Object3D as t}from"three";import*as r from"three";import a,{Behaviour as n,Body as i,BoxZone as o,Emitter as s,Force as l,Life as d,Mass as m,MeshRenderer as c,PUID as u,PointZone as p,Position as h,RadialVelocity as w,Radius as f,Rate as A,Rotate as g,Scale as y,Span as v,Vector3D as b,ease as M}from"three-nebula";import{RotatePosition as x}from"./behaviours";import{OnceRate as B}from"./rates";import{VfxBehaviourLibrary as S,VfxInitializserLibrary as I}from"./vfx-defs";import{ThreeBlendingMode as E}from"./vfx-asset";import{ShapeLibrary as P}from"../../scene/objects/shapes";import{prepareShapeParameters as R,shapeDefaultColor as Q}from"../../scene/materializer";import{particleEnergyUniformName as U,particleVelcoityUniformName as V}from"../../shader-nodes/particle";import{NodeShaderMaterial as k}from"three-shader-graph";class F extends c{scale(e){e.target instanceof r.Sprite?e.target.scale.set(e.scale*e.radius,e.scale*e.radius,1):super.scale(e)}onParticleCreated(e){e.target||(e.body||(e.body=this._body),e.target=this._targetPool.get(e.body),(e.useAlpha||e.useColor)&&(e.target instanceof r.Mesh||e.target instanceof r.Sprite&&e.target.material instanceof r.Material)&&(e.target.material.__puid=u.id(e.body.material),e.target.material=this._materialPool.get(e.target.material))),e.target&&e.target instanceof t&&(e.target.position.set(e.position.x,e.position.y,e.position.z),this.container.add(e.target))}onParticleUpdate(e){const{target:t,useAlpha:a,useColor:n,rotation:i}=e;t&&(t.position.copy(e.position),this.isThreeSprite(e)||t.rotation.set(i.x,i.y,i.z),this.scale(e),t.material instanceof r.Material&&(a&&(t.material.opacity=e.alpha,t.material.transparent=!0),n&&t.material.color.copy(e.color)))}onParticleDead(e){e.target&&e.target.material&&((e.useAlpha||e.useColor)&&this._materialPool.expire(e.target.material),this._targetPool.expire(e.target),this.container.remove(e.target),e.target=null)}}export function materializeVfx(n,o,l){return e(this,void 0,void 0,(function*(){let d=o;if(!0!==n.vfx.localSpace)for(;null!=d.parent;)d=d.parent;const m=new t;m.name="particle system",d.add(m);const c=new F(m,r),u=(new r.Mesh(new r.BoxGeometry(.3,.3,.3),new r.MeshStandardMaterial({color:16777215})),new a),p=yield Promise.all(n.vfx.emitters.map((a=>e(this,void 0,void 0,(function*(){let n,o;switch(a.rate.type){case"continuous":n=new A(a.rate.count,a.rate.time);break;case"once":n=new B(a.rate.count);break;default:console.warn(`Failed to configure rate for emitter: ${JSON.stringify(a)}`),n=new A(0,1/0)}switch(a.output.type){case"sprite":o=new i(yield function(t,a){var n,i;return e(this,void 0,void 0,(function*(){const e=null!=t.texture?yield a.getTexture(t.texture):C;var o=new r.SpriteMaterial({map:e,color:null!==(n=t.color)&&void 0!==n?n:16777215,blending:null!==(i=E[t.blendingMode])&&void 0!==i?i:r.NormalBlending,fog:!0,transparent:!0});return new r.Sprite(o)}))}(a.output,l));break;case"shape":o=new i(yield function(a,n){var i;return e(this,void 0,void 0,(function*(){const e=P[a.shape];if(null==e)return console.error(`No shape with type ${a.shape}`),new t;const o=R(null!==(i=a.params)&&void 0!==i?i:{}),s=e.geometry(o),l=null!=a.material?yield n.getMaterial(a.material):new r.MeshStandardMaterial({color:Q});return new r.Mesh(s,l)}))}(a.output,l));break;case"mesh":o=new i(yield function(r,a){return e(this,void 0,void 0,(function*(){return null==r.assetId?(console.warn("Can't use mesh as particle without asset id"),new t):a.getMesh(r.assetId)}))}(a.output,l));break;default:console.error("Failed to create particly system body: "+JSON.stringify(a))}const d=(new s).setRate(n),m=yield Promise.all(a.initializers.filter((e=>null!=I[e.type])).map((t=>e(this,void 0,void 0,(function*(){var e;const r=I[t.type],a=yield R(null!==(e=t.params)&&void 0!==e?e:{});return r.build(a)})))));m.push(o),d.addInitializers(m);const c=yield Promise.all(a.behaviours.filter((e=>null!=S[e.type])).map((t=>e(this,void 0,void 0,(function*(){var e;const r=S[t.type],a=yield R(null!==(e=t.params)&&void 0!==e?e:{});return r.build(a)})))));return c.push(new H),d.addBehaviours(c),d.emit()})))));return p.forEach((e=>u.addEmitter(e))),u.addRenderer(c).emit({onEnd:()=>{console.log("ended")}}),{system:u,dispose:()=>m.removeFromParent()}}))}const C=(new r.TextureLoader).load("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAJkSURBVHjaxJeJbusgEEW94S1L//83X18M2MSuLd2pbqc4wZGqRLrKBsyZhQHny7Jk73xVL8xpVhWrcmiB5lX+6GJ5YgQ2owbAm8oIwH1VgKZUmGcRqKGGPgtEQQAzGR8hQ59fAmhJHSAagigJ4E7GPWRXOYC6owAd1JM6wDQPADyMWUqZRMqmAojHp1Vn6EQQEgUNMJLnUjMyJsM49wygBkAPw9dVFwXRkncCIIW3GRgoTQUZn6HxCMAFEFd8TwEQ78X4rHbILoAUmeT+RFG4UhQ6MiIAE4W/UsYFjuVjAIa2nIY4q1R0GFtQWG3E84lqw2GO2QOoCKBVu0BAPgDSU0eUDjjQenNkV/AW/pWChhpMTelo1a64AOKM30vk18GzTHXCNtI/Knz3DFBgsUqBGIjTInXRY1yA9xkVoqW5tVq3pDR9A0hfF5BSARmVnh7RMDCaIdcNgbPBkgzn1Bu+SfIEFSpSBmkxyrMicb0fAEuCZrWnN89veA/4XcakrPcjBWzkTuLjlbfTQPOlBhz+HwkqqPXmPQDdrQItxE1moGof1S74j/8txk8EHhTQrAE8qlwfqS5yukm1x/rAJ9Jiaa6nyATqD78aUVBhFo8b1V4DdTXdCW+IxA1zB4JhiOhZMEWO1HqnvdoHZ4FAMIhV9REF8FiUm0jsYPEJx/Fm/N8OhH90HI9YRHesWbXXZwAShU8qThe7H8YAuJmw5yOd989uRINKRTJAhoF8jbqrHKfeCYdIISZfSq26bk/K+yO3YvfKrVgiwQBHnwt8ynPB25+M8hceTt/ybPhnryJ78+tLgAEAuCFyiQgQB30AAAAASUVORK5CYII=");export function materializeVfxOld(e,n){let u=n;if(!0!==e.vfx.localSpace)for(;null!=u.parent;)u=u.parent;const S=new t;S.name="particle system",u.add(S);const I=new c(S,r),E=new r.Mesh(new r.BoxGeometry(.3,.3,.3),new r.MeshStandardMaterial({color:16777215})),P=new A(new v(3,9),new v(.02,.15)),R=new s,Q=new a;R.setLife(4).setRate(P).addInitializers([new m(1),new f(1),new d(1),new i(E),new h(new o(.5)),new w(10,new b(0,0,1),30)]).addBehaviours([new x(new r.Vector3(0,0,1),4),new l(0,0,.1),new g("random",2.5*-Math.PI,2*Math.PI,1,M.easeOutCubic),new y(1,.2)]).emit();const U=new B,V=(new s).setLife(5).addInitializers([new m(1),new f(1),new d(3),new i(E),new h(new p(0,0,0))]).addBehaviours([new y(4,6,void 0,M.easeOutExpo)]).setRate(U).emit();return U.nextTime=0,Q.addEmitter(R).addEmitter(V).addRenderer(I).emit({onEnd:()=>{console.log("ended")}}),{system:Q,rate:P,renderer:I,dispose:()=>S.removeFromParent()}}class H extends n{initialize(e){if(e.body instanceof r.Mesh){const t=e.body.material;t instanceof k&&(null!=t.uniforms[U]||null!=t.uniforms[V])&&(e.body.material=t.clone())}}mutate(e,t,a){if(e.target instanceof r.Mesh){const t=e.target.material;t instanceof k&&(null!=t.uniforms[U]&&(t.uniforms[U].value=this.energy),null!=t.uniforms[V]&&(t.uniforms[V].value=e.velocity))}}}
+/*
+ * Copyright (©) 2023. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/effects/vfx/vfx-param.d.ts

@@ -0,0 +1,13 @@
+import { Object3D } from "three";
+import { VfxActor } from "./vfx-actor";
+export declare class VisualEffect {
+    private actor;
+    constructor(actor: VfxActor);
+    play(): void;
+    stop(): void;
+    pause(): void;
+    restart(): void;
+    set timescale(value: number);
+    get timescale(): number;
+    get object(): Object3D;
+}

package/dist/effects/vfx/vfx-param.js

@@ -0,0 +1,5 @@
+export class VisualEffect{constructor(t){this.actor=t}play(){this.actor.play()}stop(){this.actor.stop()}pause(){this.actor.pause()}restart(){this.actor.restart()}set timescale(t){this.actor.timescale=t}get timescale(){return this.actor.timescale}get object(){return this.actor.object}}
+/*
+ * Copyright (©) 2023. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/effects/vfx/zones.d.ts

@@ -0,0 +1,74 @@
+import { Vector3D } from "three-nebula";
+declare const SphereZone_base: any;
+/**
+ * A spherical zone for particles to be emitted within.
+ *
+ */
+export declare class SphereZone extends SphereZone_base {
+    private x;
+    private y;
+    private z;
+    private radius;
+    private the;
+    private phi;
+    protected random: number;
+    protected vector: Vector3D;
+    /**
+     * @constructs {SphereZone}
+     *
+     * @param {number} centerX - the sphere's center x coordinate
+     * @param {number} centerY - the sphere's center y coordinate
+     * @param {number} centerZ - the sphere's center z coordinate
+     * @param {number} radius - the sphere's radius value
+     * @return void
+     */
+    constructor(x: number, y: number, z: number, radius: number);
+    /**
+     * Returns true to indicate this is a SphereZone.
+     *
+     * @return {boolean}
+     */
+    isSphereZone(): boolean;
+    /**
+     * Sets the particle to dead if the particle collides with the sphere.
+     *
+     * @param {object} particle
+     * @return void
+     */
+    _dead(particle: any): void;
+    /**
+     * Warns that this zone does not support the _cross method.
+     *
+     * @return void
+     */
+    _cross(): void;
+    getPosition: () => Vector3D;
+    _bound: (particle: any) => void;
+}
+declare const PointZone_base: any;
+export declare class PointZone extends PointZone_base {
+    private x;
+    private y;
+    private z;
+    /**
+     * PointZone is a point zone
+     * @param {Number|Vector3D} x - the center's x value or a Vector3D Object
+     * @param {Number} y - the center's y value
+     * @param {Number} z - the center's z value
+     * @example
+     * var pointZone = new System.PointZone(0,30,10);
+     * or
+     * var pointZone = new System.PointZone(new System.Vector3D(0,30,10));
+     * @extends {Zone}
+     * @constructor
+     */
+    constructor(x: number, y: number, z: number);
+    /**
+     * Returns true to indicate this is a PointZone.
+     *
+     * @return {boolean}
+     */
+    isPointZone(): boolean;
+    getPosition(): any;
+}
+export {};

package/dist/effects/vfx/zones.js

@@ -0,0 +1,5 @@
+import{Vector3D as t}from"three-nebula";import{SphereZone as s}from"three-nebula";const o=Math.PI;export class SphereZone extends(Object.getPrototypeOf(s)){constructor(s,i,e,r){var h,n,a;super("SphereZone"),this.x=s,this.y=i,this.z=e,this.radius=r,this.the=0,this.phi=0,this.vector=new t,this.getPosition=(()=>{var t,s,i;return()=>(this.random=Math.random(),i=this.random*this.radius,t=o*Math.random(),s=2*o*Math.random(),this.vector.x=this.x+i*Math.sin(t)*Math.cos(s),this.vector.y=this.y+i*Math.sin(s)*Math.sin(t),this.vector.z=this.z+i*Math.cos(t),this.vector)})(),this._bound=(n=new t,a=new t,function(t){t.position.distanceTo(this)+t.radius>=this.radius&&(n.copy(t.position).sub(this).normalize(),a.copy(t.velocity),h=2*a.dot(n),t.velocity.sub(n.scalar(h)))})}isSphereZone(){return!0}_dead(t){t.position.distanceTo(this)-t.radius>this.radius&&(t.dead=!0)}_cross(){console.warn(`${this.constructor.name} does not support the _cross method`)}}export class PointZone extends(Object.getPrototypeOf(s)){constructor(t,s,o){super("PointZone"),this.x=t,this.y=s,this.z=o}isPointZone(){return!0}getPosition(){return this.vector.x=this.x,this.vector.y=this.y,this.vector.z=this.z,this.vector}}
+/*
+ * Copyright (©) 2023. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/gameplay/actors/builtin/components/character/character-movement.d.ts

@@ -1,6 +1,6 @@
 import { ActionInput, AxisInput, RotationInput } from "../../../../../gameplay/input";
 import { PhysicsSystem } from "../../../../../gameplay/services/physics/physics-system";
-import { Vector3 } from 'three';
+import { Vector3, AnimationAction } from 'three';
 import { ActorComponent } from "../../../component";
 import { CharacterMovementMode } from "./modes";
 export declare class CharacterMovementComponent extends ActorComponent {
@@ -40,7 +40,11 @@ export declare class CharacterMovementComponent extends ActorComponent {
     private cc;
     private rayTestResult;
     constructor(physicsSystem: PhysicsSystem);
+    private resetRootMotion;
+    private rootMotionInterpolant;
     onInit(): void | Promise<void>;
+    private rootMotionAction;
+    setRootMotionAction(action: AnimationAction): void;
     private getWallDirection;
     private moveTo;
     getEffectiveGravity(): number;