@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/assets/shader/utils/GenerayRandomDir.d.ts

@@ -0,0 +1 @@
+export declare let GenerayRandomDir: string;

package/dist/src/assets/shader/utils/GenerayRandomDir.js

@@ -0,0 +1,22 @@
+export let GenerayRandomDir = /*wgsl*/ `
+    fn madfrac(A:f32, B:f32)-> f32 {
+        return A*B-floor(A*B) ;
+    }
+
+    fn sampleRandomDir(count:u32,SAMPLE_COUNT:u32) -> vec3<f32>{
+    var ray_dir = sphericalFibonacci(f32((count)), f32(SAMPLE_COUNT) );
+    return normalize(ray_dir) ;
+    }
+
+    fn sphericalFibonacci( i : f32 ,  n : f32 ) -> vec3<f32>{
+        const PHI = sqrt(5.0) * 0.5 + 0.5;
+        let phi = 2.0 * PI * madfrac(i, PHI - 1);
+        let cosTheta = 1.0 - (2.0 * i + 1.0) * (1.0 / n);
+        let sinTheta = sqrt(saturate(1.0 - cosTheta*cosTheta));
+
+        return vec3<f32>(
+            cos(phi) * sinTheta,
+            sin(phi) * sinTheta,
+            cosTheta);
+    }
+`;

package/dist/src/components/AtmosphericComponent.d.ts

@@ -0,0 +1,28 @@
+import { Transform } from "./Transform";
+import { SkyRenderer } from "./renderer/SkyRenderer";
+export declare class AtmosphericComponent extends SkyRenderer {
+    private _atmosphericScatteringSky;
+    private _onChange;
+    private _relatedTransform;
+    private _historyData;
+    get sunX(): number;
+    set sunX(value: number);
+    get sunY(): number;
+    set sunY(value: number);
+    get eyePos(): number;
+    set eyePos(value: number);
+    get sunRadius(): number;
+    set sunRadius(value: number);
+    get sunRadiance(): number;
+    set sunRadiance(value: number);
+    get sunBrightness(): number;
+    set sunBrightness(value: number);
+    get displaySun(): boolean;
+    set displaySun(value: boolean);
+    init(): void;
+    start(view?: any): void;
+    get relativeTransform(): Transform;
+    set relativeTransform(value: Transform);
+    onUpdate(view?: any): void;
+    destroy(force?: boolean): void;
+}

package/dist/src/components/AtmosphericComponent.js

@@ -0,0 +1,141 @@
+import { AtmosphericScatteringSky, AtmosphericScatteringSkySetting, } from "../textures/AtmosphericScatteringSky";
+import { SkyRenderer } from "./renderer/SkyRenderer";
+class HistoryData {
+    constructor() {
+        this.reset();
+    }
+    reset() {
+        this.rotateX = this.rotateY = this.sunX = this.sunY = Number.MAX_VALUE;
+        return this;
+    }
+    isRotateChange(rx, ry) {
+        return (Math.abs(this.rotateX - rx) >= 0.001 ||
+            Math.abs(this.rotateY - ry) >= 0.001);
+    }
+    isSkyChange(x, y) {
+        return Math.abs(this.sunX - x) >= 0.001 || Math.abs(this.sunY - y) >= 0.001;
+    }
+    save(x, y, rx, ry) {
+        this.sunX = x;
+        this.sunY = y;
+        this.rotateX = rx;
+        this.rotateY = ry;
+        return this;
+    }
+}
+export class AtmosphericComponent extends SkyRenderer {
+    constructor() {
+        super(...arguments);
+        this._onChange = true;
+    }
+    get sunX() {
+        return this._atmosphericScatteringSky.setting.sunX;
+    }
+    set sunX(value) {
+        if (this._atmosphericScatteringSky.setting.sunX != value) {
+            this._atmosphericScatteringSky.setting.sunX = value;
+            this._onChange = true;
+        }
+    }
+    get sunY() {
+        return this._atmosphericScatteringSky.setting.sunY;
+    }
+    set sunY(value) {
+        if (this._atmosphericScatteringSky.setting.sunY != value) {
+            this._atmosphericScatteringSky.setting.sunY = value;
+            this._onChange = true;
+        }
+    }
+    get eyePos() {
+        return this._atmosphericScatteringSky.setting.eyePos;
+    }
+    set eyePos(value) {
+        if (this._atmosphericScatteringSky.setting.eyePos != value) {
+            this._atmosphericScatteringSky.setting.eyePos = value;
+            this._onChange = true;
+        }
+    }
+    get sunRadius() {
+        return this._atmosphericScatteringSky.setting.sunRadius;
+    }
+    set sunRadius(value) {
+        if (this._atmosphericScatteringSky.setting.sunRadius != value) {
+            this._atmosphericScatteringSky.setting.sunRadius = value;
+            this._onChange = true;
+        }
+    }
+    get sunRadiance() {
+        return this._atmosphericScatteringSky.setting.sunRadiance;
+    }
+    set sunRadiance(value) {
+        if (this._atmosphericScatteringSky.setting.sunRadiance != value) {
+            this._atmosphericScatteringSky.setting.sunRadiance = value;
+            this._onChange = true;
+        }
+    }
+    get sunBrightness() {
+        return this._atmosphericScatteringSky.setting.sunBrightness;
+    }
+    set sunBrightness(value) {
+        if (this._atmosphericScatteringSky.setting.sunBrightness != value) {
+            this._atmosphericScatteringSky.setting.sunBrightness = value;
+            this._onChange = true;
+        }
+    }
+    get displaySun() {
+        return this._atmosphericScatteringSky.setting.displaySun;
+    }
+    set displaySun(value) {
+        if (this._atmosphericScatteringSky.setting.displaySun != value) {
+            this._atmosphericScatteringSky.setting.displaySun = value;
+            this._onChange = true;
+        }
+    }
+    init() {
+        super.init();
+        this._historyData = new HistoryData();
+        this._atmosphericScatteringSky = new AtmosphericScatteringSky(new AtmosphericScatteringSkySetting());
+        let view3D = this.transform.view3D;
+        let scene = this.transform.scene3D;
+        this.map = this._atmosphericScatteringSky;
+        scene.envMap = this._atmosphericScatteringSky;
+        this.onUpdate(view3D);
+    }
+    start(view) {
+        let scene = this.transform.scene3D;
+        this.map = this._atmosphericScatteringSky;
+        scene.envMap = this._atmosphericScatteringSky;
+        super.start();
+    }
+    get relativeTransform() {
+        return this._relatedTransform;
+    }
+    set relativeTransform(value) {
+        this._relatedTransform = value;
+        this._historyData.reset();
+    }
+    onUpdate(view) {
+        if (this._relatedTransform) {
+            this._relatedTransform.rotationZ = 0;
+            if (this._historyData.isRotateChange(this._relatedTransform.rotationX, this._relatedTransform.rotationY)) {
+                this.sunX = (this._relatedTransform.rotationY + 90) / 360;
+                this.sunY = this._relatedTransform.rotationX / 180 + 0.5;
+            }
+            else if (this._historyData.isSkyChange(this.sunX, this.sunY)) {
+                this._relatedTransform.rotationY = this.sunX * 360 - 90;
+                this._relatedTransform.rotationX = (this.sunY - 0.5) * 180;
+            }
+            this._historyData.save(this.sunX, this.sunY, this._relatedTransform.rotationX, this._relatedTransform.rotationY);
+        }
+        if (this._onChange) {
+            this._onChange = false;
+            this._atmosphericScatteringSky.apply();
+        }
+    }
+    destroy(force) {
+        super.destroy(force);
+        this._atmosphericScatteringSky.destroy();
+        this._atmosphericScatteringSky = null;
+        this._onChange = null;
+    }
+}

package/dist/src/components/BillboardComponent.d.ts

@@ -0,0 +1,13 @@
+import { Camera3D } from "../core/Camera3D";
+import { Object3D } from "../core/entities/Object3D";
+import { ComponentBase } from "./ComponentBase";
+import { BillboardType } from "./gui/GUIConfig";
+export declare class BillboardComponent extends ComponentBase {
+    type: BillboardType;
+    camera: Camera3D;
+    private _cameraPosition;
+    constructor();
+    onUpdate(): void;
+    private updateBillboardMatrix;
+    cloneTo(obj: Object3D): void;
+}

package/dist/src/components/BillboardComponent.js

@@ -0,0 +1,30 @@
+import { Vector3 } from "../math/Vector3";
+import { ComponentBase } from "./ComponentBase";
+import { BillboardType } from "./gui/GUIConfig";
+export class BillboardComponent extends ComponentBase {
+    constructor() {
+        super();
+        this._cameraPosition = new Vector3();
+    }
+    onUpdate() {
+        if (this.enable && this.transform.view3D.camera) {
+            this.updateBillboardMatrix();
+        }
+    }
+    updateBillboardMatrix() {
+        let camera = this.transform.view3D.camera;
+        this._cameraPosition.copyFrom(camera.transform.back);
+        if (this.type == BillboardType.BillboardXYZ) {
+        }
+        else if (this.type == BillboardType.BillboardY) {
+            this._cameraPosition.y = 0;
+        }
+        this._cameraPosition.normalize();
+        this._cameraPosition.add(this.object3D.localPosition, this._cameraPosition);
+        this.transform.lookAt(this.object3D.localPosition, this._cameraPosition, camera.transform.up);
+    }
+    cloneTo(obj) {
+        let component = obj.addComponent(BillboardComponent);
+        component.type = this.type;
+    }
+}

package/dist/src/components/ColliderComponent.d.ts

@@ -0,0 +1,15 @@
+import { View3D } from "..";
+import { Ray } from "../math/Ray";
+import { ComponentBase } from "./ComponentBase";
+import { ColliderShape, HitInfo } from "./shape/ColliderShape";
+export declare class ColliderComponent extends ComponentBase {
+    private _shape;
+    constructor();
+    start(): void;
+    onEnable(view?: View3D): void;
+    onDisable(view?: View3D): void;
+    get shape(): ColliderShape;
+    set shape(value: ColliderShape);
+    rayPick(ray: Ray): HitInfo;
+    beforeDestroy(force?: boolean): void;
+}

package/dist/src/components/ColliderComponent.js

@@ -0,0 +1,39 @@
+import { ComponentCollect } from "..";
+import { Engine3D } from "../Engine3D";
+import { ComponentBase } from "./ComponentBase";
+import { BoxColliderShape } from "./shape/BoxColliderShape";
+export class ColliderComponent extends ComponentBase {
+    constructor() {
+        super();
+        this._shape = new BoxColliderShape();
+    }
+    start() {
+        if (Engine3D.setting.pick.mode == `pixel`) {
+            this.transform.scene3D.view.pickFire.mouseEnableMap.set(this.transform.worldMatrix.index, this);
+        }
+    }
+    onEnable(view) {
+        ComponentCollect.bindEnablePick(view, this, null);
+    }
+    onDisable(view) {
+        ComponentCollect.unBindEnablePick(view, this);
+    }
+    get shape() {
+        return this._shape;
+    }
+    set shape(value) {
+        this._shape = value;
+    }
+    rayPick(ray) {
+        if (this._enable) {
+            return this._shape.rayPick(ray, this.transform.worldMatrix);
+        }
+        return null;
+    }
+    beforeDestroy(force) {
+        if (Engine3D.setting.pick.mode == `pixel`) {
+            this.transform.scene3D.view.pickFire.mouseEnableMap.delete(this.transform.worldMatrix.index);
+        }
+        super.beforeDestroy(force);
+    }
+}

package/dist/src/components/ComponentBase.d.ts

@@ -0,0 +1,43 @@
+import { View3D } from "../core/View3D";
+import { Object3D } from "../core/entities/Object3D";
+import { CEventDispatcher } from "../event/CEventDispatcher";
+import { IComponent } from "./IComponent";
+import { Transform } from "./Transform";
+export declare class ComponentBase implements IComponent {
+    object3D: Object3D;
+    protected _eventDispatcher: CEventDispatcher;
+    get eventDispatcher(): CEventDispatcher;
+    set eventDispatcher(value: CEventDispatcher);
+    protected _enable: boolean;
+    private __isStart;
+    isDestroyed: boolean;
+    get isStart(): boolean;
+    get transform(): Transform;
+    set enable(value: boolean);
+    get enable(): boolean;
+    private __init;
+    private __start;
+    private __stop;
+    init(param?: any): void;
+    start(): void;
+    stop(): void;
+    onEnable?(view?: View3D): any;
+    onDisable?(view?: View3D): any;
+    onUpdate?(view?: View3D): any;
+    onLateUpdate?(view?: View3D): any;
+    onBeforeUpdate?(view?: View3D): any;
+    onCompute?(view?: View3D, command?: GPUCommandEncoder): any;
+    onGraphic?(view?: View3D): any;
+    onParentChange?(lastParent?: Object3D, currentParent?: Object3D): any;
+    onAddChild?(child: Object3D): any;
+    onRemoveChild?(child: Object3D): any;
+    cloneTo(obj: Object3D): void;
+    copyComponent(from: this): this;
+    private _onUpdate;
+    private _onLateUpdate;
+    private _onBeforeUpdate;
+    private _onCompute;
+    private _onGraphic;
+    beforeDestroy(force?: boolean): void;
+    destroy(force?: boolean): void;
+}

package/dist/src/components/ComponentBase.js

@@ -0,0 +1,141 @@
+import { CEventDispatcher } from "../event/CEventDispatcher";
+import { ComponentCollect } from "../gfx/renderJob/collect/ComponentCollect";
+export class ComponentBase {
+    constructor() {
+        this.object3D = null;
+        this._enable = true;
+        this.__isStart = false;
+        this.isDestroyed = false;
+    }
+    get eventDispatcher() {
+        this._eventDispatcher ||= new CEventDispatcher();
+        return this._eventDispatcher;
+    }
+    set eventDispatcher(value) {
+        console.error("The eventDispatcher should not be set externally!");
+    }
+    get isStart() {
+        return this.__isStart;
+    }
+    get transform() {
+        return this.object3D.transform;
+    }
+    set enable(value) {
+        if (this._enable != value) {
+            this._enable = value;
+            if (this._enable) {
+                this.onEnable?.(this.transform.view3D);
+            }
+            else {
+                this.onDisable?.(this.transform.view3D);
+            }
+        }
+    }
+    get enable() {
+        return this._enable;
+    }
+    __init(param) {
+        this.init(param);
+    }
+    __start() {
+        if (this.transform && this.transform.scene3D && this._enable) {
+            this.onEnable?.(this.transform.view3D);
+        }
+        if (this.transform && this.transform.scene3D && this.__isStart == false) {
+            this.start?.();
+            this.__isStart = true;
+        }
+        if (this.onUpdate) {
+            this._onUpdate(this.onUpdate.bind(this));
+        }
+        if (this.onLateUpdate) {
+            this._onLateUpdate(this.onLateUpdate.bind(this));
+        }
+        if (this.onBeforeUpdate) {
+            this._onBeforeUpdate(this.onBeforeUpdate.bind(this));
+        }
+        if (this.onCompute) {
+            this._onCompute(this.onCompute.bind(this));
+        }
+        if (this.onGraphic) {
+            this._onGraphic(this.onGraphic.bind(this));
+        }
+    }
+    __stop() {
+        if (this.transform && this.transform.scene3D) {
+            this.onDisable?.(this.transform.view3D);
+        }
+        this._onUpdate(null);
+        this._onLateUpdate(null);
+        this._onBeforeUpdate(null);
+        this._onCompute(null);
+        this._onGraphic(null);
+    }
+    init(param) { }
+    start() { }
+    stop() { }
+    cloneTo(obj) { }
+    copyComponent(from) {
+        return this;
+    }
+    _onUpdate(call) {
+        if (call != null) {
+            ComponentCollect.bindUpdate(this.transform.view3D, this, call);
+        }
+        else {
+            ComponentCollect.unBindUpdate(this.transform.view3D, this);
+        }
+    }
+    _onLateUpdate(call) {
+        if (call != null) {
+            ComponentCollect.bindLateUpdate(this.transform.view3D, this, call);
+        }
+        else {
+            ComponentCollect.unBindLateUpdate(this.transform.view3D, this);
+        }
+    }
+    _onBeforeUpdate(call) {
+        if (call != null) {
+            ComponentCollect.bindBeforeUpdate(this.transform.view3D, this, call);
+        }
+        else {
+            ComponentCollect.unBindBeforeUpdate(this.transform.view3D, this);
+        }
+    }
+    _onCompute(call) {
+        if (call != null) {
+            ComponentCollect.bindCompute(this.transform.view3D, this, call);
+        }
+        else {
+            ComponentCollect.unBindCompute(this.transform.view3D, this);
+        }
+    }
+    _onGraphic(call) {
+        if (call != null) {
+            ComponentCollect.bindGraphic(this.transform.view3D, this, call);
+        }
+        else {
+            ComponentCollect.unBindGraphic(this.transform.view3D, this);
+        }
+    }
+    beforeDestroy(force) {
+        ComponentCollect.removeWaitStart(this.object3D, this);
+    }
+    destroy(force) {
+        if (this.isDestroyed)
+            return;
+        this.isDestroyed = true;
+        this.enable = false;
+        this.stop();
+        this._onBeforeUpdate(null);
+        this._onUpdate(null);
+        this._onLateUpdate(null);
+        this.onEnable = null;
+        this.onDisable = null;
+        this.onUpdate = null;
+        this.onLateUpdate = null;
+        this.onBeforeUpdate = null;
+        this.onCompute = null;
+        this.onGraphic = null;
+    }
+}

package/dist/src/components/IComponent.d.ts

@@ -0,0 +1,27 @@
+import { View3D } from "../core/View3D";
+import { Object3D } from "../core/entities/Object3D";
+import { CEventDispatcher } from "../event/CEventDispatcher";
+import { Transform } from "./Transform";
+export interface IComponent {
+    object3D: Object3D;
+    eventDispatcher: CEventDispatcher;
+    transform: Transform;
+    enable: boolean;
+    isDestroyed?: boolean;
+    init(param?: any): any;
+    start(): any;
+    stop(): any;
+    onEnable?(view?: View3D): any;
+    onDisable?(view?: View3D): any;
+    onUpdate?(view?: View3D): any;
+    onLateUpdate?(view?: View3D): any;
+    onBeforeUpdate?(view?: View3D): any;
+    onCompute?(view?: View3D, command?: GPUCommandEncoder): any;
+    onGraphic?(view?: View3D): any;
+    cloneTo(obj: Object3D): any;
+    destroy(force?: boolean): any;
+    beforeDestroy(force?: boolean): any;
+    onParentChange?(lastParent?: Object3D, currentParent?: Object3D): any;
+    onAddChild?(child: Object3D): any;
+    onRemoveChild?(child: Object3D): any;
+}

package/dist/src/components/IComponent.js

@@ -0,0 +1 @@
+export {};

package/dist/src/components/SkeletonAnimationComponent.d.ts

@@ -0,0 +1,52 @@
+import { Object3D } from "../core/entities/Object3D";
+import { StorageGPUBuffer } from "../gfx/graphics/webGpu/core/buffer/StorageGPUBuffer";
+import { ComponentBase } from "./ComponentBase";
+import { Skeleton } from "./anim/skeletonAnim/Skeleton";
+import { SkeletonAnimationClip } from "./anim/skeletonAnim/SkeletonAnimationClip";
+import { SkeletonAnimationClipState } from "./anim/skeletonAnim/SkeletonAnimationClipState";
+import { SkeletonPose } from "./anim/skeletonAnim/SkeletonPose";
+export declare class SkeletonAnimationComponent extends ComponentBase {
+    isPlaying: boolean;
+    timeScale: number;
+    protected _skeleton: Skeleton;
+    protected _clips: SkeletonAnimationClip[];
+    protected _clipStates: Map<string, SkeletonAnimationClipState>;
+    protected _mixSkeletonPose: SkeletonPose;
+    protected _mixTempSkeletonPose: SkeletonPose;
+    protected _currentClipState: SkeletonAnimationClipState;
+    protected _bindList: Array<any>;
+    protected _jointMatrixIndexTableBuffer: StorageGPUBuffer;
+    protected _crossFadeState: SkeletonAnimationCrossFadeState;
+    constructor();
+    start(): void;
+    set skeleton(value: Skeleton);
+    get skeleton(): Skeleton;
+    get finalSkeletonPose(): SkeletonPose;
+    get jointMatrixIndexTableBuffer(): StorageGPUBuffer;
+    getJointIndexTable(skinJointsName: Array<string>): Array<number>;
+    addAnimationClip(clip: SkeletonAnimationClip): void;
+    getAnimationClip(name: string): SkeletonAnimationClip;
+    getAnimationClips(): SkeletonAnimationClip[];
+    getAnimationClipState(name: string): SkeletonAnimationClipState;
+    getAnimationClipStates(): Map<string, SkeletonAnimationClipState>;
+    pause(): void;
+    resume(): void;
+    play(animName: string, speed?: number, reset?: boolean): boolean;
+    crossFade(animName: string, crossTime: number): void;
+    setAnimIsLoop(animName: string, isLoop: boolean): void;
+    addJointBind(jointName: string, obj: Object3D): void;
+    removeJointBind(obj: Object3D): void;
+    onUpdate(): void;
+    cloneTo(obj: Object3D): void;
+    protected setCurrentClipState(clipState: SkeletonAnimationClipState): void;
+}
+declare class SkeletonAnimationCrossFadeState {
+    inClip: SkeletonAnimationClipState;
+    outClip: SkeletonAnimationClipState;
+    currentTime: number;
+    crossFadeTime: number;
+    constructor(inClip: SkeletonAnimationClipState, outClip: SkeletonAnimationClipState, time: number);
+    reset(inClip: SkeletonAnimationClipState, outClip: SkeletonAnimationClipState, time: number): void;
+    update(delta: number): void;
+}
+export {};