@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/setting/post/BloomSetting.d.ts

@@ -0,0 +1,11 @@
+export type BloomSetting = {
+    enable?: boolean;
+    downSampleStep: number;
+    downSampleBlurSize: number;
+    downSampleBlurSigma: number;
+    upSampleBlurSize: number;
+    upSampleBlurSigma: number;
+    luminanceThreshole: number;
+    bloomIntensity: number;
+    hdr: number;
+};

package/dist/src/setting/post/BloomSetting.js

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

package/dist/src/setting/post/DepthOfViewSetting.d.ts

@@ -0,0 +1,7 @@
+export type DepthOfViewSetting = {
+    enable: boolean;
+    iterationCount: number;
+    pixelOffset: number;
+    near: number;
+    far: number;
+};

package/dist/src/setting/post/DepthOfViewSetting.js

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

package/dist/src/setting/post/GTAOSetting.d.ts

@@ -0,0 +1,11 @@
+export type GTAOSetting = {
+    enable: boolean;
+    maxDistance: number;
+    maxPixel: number;
+    darkFactor: number;
+    rayMarchSegment: number;
+    multiBounce: boolean;
+    usePosFloat32: boolean;
+    blendColor: boolean;
+    debug: boolean;
+};

package/dist/src/setting/post/GTAOSetting.js

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

package/dist/src/setting/post/GlobalFogSetting.d.ts

@@ -0,0 +1,19 @@
+import { Color } from "../../math/Color";
+export type GlobalFogSetting = {
+    debug: any;
+    enable: boolean;
+    fogType: number;
+    fogHeightScale: number;
+    start: number;
+    end: number;
+    density: number;
+    ins: number;
+    skyFactor: number;
+    skyRoughness: number;
+    overrideSkyFactor: number;
+    fogColor: Color;
+    falloff: number;
+    rayLength: number;
+    scatteringExponent: number;
+    dirHeightLine: number;
+};

package/dist/src/setting/post/GlobalFogSetting.js

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

package/dist/src/setting/post/GodRaySetting.d.ts

@@ -0,0 +1,7 @@
+export type GodRaySetting = {
+    enable?: boolean;
+    blendColor: boolean;
+    rayMarchCount: number;
+    scatteringExponent: number;
+    intensity: number;
+};

package/dist/src/setting/post/GodRaySetting.js

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

package/dist/src/setting/post/OutlineSetting.d.ts

@@ -0,0 +1,10 @@
+export type OutlineSetting = {
+    enable: boolean;
+    groupCount: number;
+    outlinePixel: number;
+    fadeOutlinePixel: number;
+    strength: number;
+    useAddMode: boolean;
+    textureScale: number;
+    debug: boolean;
+};

package/dist/src/setting/post/OutlineSetting.js

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

package/dist/src/setting/post/SSRSetting.d.ts

@@ -0,0 +1,12 @@
+export type SSRSetting = {
+    debug: any;
+    enable: boolean;
+    pixelRatio: number;
+    fadeEdgeRatio: number;
+    rayMarchRatio: number;
+    fadeDistanceMin: number;
+    fadeDistanceMax: number;
+    roughnessThreshold: number;
+    powDotRN: number;
+    mixThreshold: number;
+};

package/dist/src/setting/post/SSRSetting.js

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

package/dist/src/setting/post/TAASetting.d.ts

@@ -0,0 +1,9 @@
+export type TAASetting = {
+    enable: boolean;
+    jitterSeedCount: number;
+    blendFactor: number;
+    temporalJitterScale: number;
+    sharpFactor: number;
+    sharpPreBlurFactor: number;
+    debug: boolean;
+};

package/dist/src/setting/post/TAASetting.js

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

package/dist/src/shape/BoxGeometry.d.ts

@@ -0,0 +1,28 @@
+import { GeometryBase } from "../core/geometry/GeometryBase";
+/**
+ * Box geometry
+ * @group Geometry
+ */
+export declare class BoxGeometry extends GeometryBase {
+    /**
+     * box width
+     */
+    width: number;
+    /**
+     * box height
+     */
+    height: number;
+    /**
+     * box depth
+     */
+    depth: number;
+    /**
+     *
+     * @constructor
+     * @param width {number} box width, default value is 1
+     * @param height {number} box height, default value is 1
+     * @param depth {number} box depth, default value is 1
+     */
+    constructor(width?: number, height?: number, depth?: number);
+    private initVertex;
+}

package/dist/src/shape/BoxGeometry.js

@@ -0,0 +1,184 @@
+import { BoundingBox } from "../core/bound/BoundingBox";
+import { GeometryBase } from "../core/geometry/GeometryBase";
+import { VertexAttributeName } from "../core/geometry/VertexAttributeName";
+import { Vector3 } from "../math/Vector3";
+/**
+ * Box geometry
+ * @group Geometry
+ */
+export class BoxGeometry extends GeometryBase {
+    /**
+     *
+     * @constructor
+     * @param width {number} box width, default value is 1
+     * @param height {number} box height, default value is 1
+     * @param depth {number} box depth, default value is 1
+     */
+    constructor(width = 1, height = 1, depth = 1) {
+        super();
+        this.width = width;
+        this.height = height;
+        this.depth = depth;
+        this.initVertex();
+    }
+    initVertex() {
+        let halfW = this.width / 2.0;
+        let halfH = this.height / 2.0;
+        let halfD = this.depth / 2.0;
+        this.bounds = new BoundingBox(Vector3.ZERO.clone(), new Vector3(this.width, this.height, this.depth));
+        let position_arr = new Float32Array([
+            //up
+            -halfW,
+            halfH,
+            halfD,
+            halfW,
+            halfH,
+            halfD,
+            halfW,
+            halfH,
+            -halfD,
+            -halfW,
+            halfH,
+            -halfD,
+            -halfW,
+            halfH,
+            halfD,
+            halfW,
+            halfH,
+            -halfD,
+            //buttom
+            halfW,
+            -halfH,
+            halfD,
+            -halfW,
+            -halfH,
+            halfD,
+            -halfW,
+            -halfH,
+            -halfD,
+            halfW,
+            -halfH,
+            -halfD,
+            halfW,
+            -halfH,
+            halfD,
+            -halfW,
+            -halfH,
+            -halfD,
+            //left
+            -halfW,
+            -halfH,
+            halfD,
+            -halfW,
+            halfH,
+            halfD,
+            -halfW,
+            halfH,
+            -halfD,
+            -halfW,
+            -halfH,
+            -halfD,
+            -halfW,
+            -halfH,
+            halfD,
+            -halfW,
+            halfH,
+            -halfD,
+            //right
+            halfW,
+            halfH,
+            halfD,
+            halfW,
+            -halfH,
+            halfD,
+            halfW,
+            -halfH,
+            -halfD,
+            halfW,
+            halfH,
+            -halfD,
+            halfW,
+            halfH,
+            halfD,
+            halfW,
+            -halfH,
+            -halfD,
+            //front
+            halfW,
+            halfH,
+            halfD,
+            -halfW,
+            halfH,
+            halfD,
+            -halfW,
+            -halfH,
+            halfD,
+            -halfW,
+            -halfH,
+            halfD,
+            halfW,
+            -halfH,
+            halfD,
+            halfW,
+            halfH,
+            halfD,
+            //back
+            halfW,
+            -halfH,
+            -halfD,
+            -halfW,
+            -halfH,
+            -halfD,
+            -halfW,
+            halfH,
+            -halfD,
+            halfW,
+            halfH,
+            -halfD,
+            halfW,
+            -halfH,
+            -halfD,
+            -halfW,
+            halfH,
+            -halfD,
+        ]);
+        let normal_arr = new Float32Array([
+            //up
+            0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0,
+            //buttom
+            0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0,
+            //left
+            -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0,
+            //right
+            1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0,
+            //front
+            0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1,
+            //back
+            0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1,
+        ]);
+        let uv_arr = new Float32Array([
+            1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1,
+            1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1,
+            0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0,
+        ]);
+        let indices_arr = [
+            0, 2, 1, 3, 5, 4, 6, 8, 7, 9, 11, 10, 12, 14, 13, 15, 17, 16, 18, 20, 19,
+            21, 23, 22, 24, 26, 25, 27, 29, 28, 30, 32, 31, 33, 35, 34,
+        ];
+        let indicesData = new Uint16Array(indices_arr.reverse());
+        this.setIndices(indicesData);
+        this.setAttribute(VertexAttributeName.position, position_arr);
+        this.setAttribute(VertexAttributeName.normal, normal_arr);
+        this.setAttribute(VertexAttributeName.uv, uv_arr);
+        this.setAttribute(VertexAttributeName.TEXCOORD_1, uv_arr);
+        this.addSubGeometry({
+            indexStart: 0,
+            indexCount: indices_arr.length,
+            vertexStart: 0,
+            vertexCount: 0,
+            firstStart: 0,
+            index: 0,
+            topology: 0,
+        });
+    }
+}

package/dist/src/shape/CylinderGeometry.d.ts

@@ -0,0 +1,60 @@
+import { GeometryBase } from "../core/geometry/GeometryBase";
+/**
+ * Cylinder geometry
+ * @group Geometry
+ */
+export declare class CylinderGeometry extends GeometryBase {
+    /**
+     * The radius of the top of the cylinder
+     */
+    radiusTop: number;
+    /**
+     * The radius of the bottom of the cylinder
+     */
+    radiusBottom: number;
+    /**
+     * The height of the cylinder
+     */
+    height: number;
+    /**
+     * Number of segments around the side of the cylinder
+     */
+    radialSegments: number;
+    /**
+     * The number of segments along the height of the cylindrical side
+     */
+    heightSegments: number;
+    /**
+     * Indicate whether the bottom surface of the cone is open or capped. The default value is false, which means that the bottom surface is capped by default.
+     */
+    openEnded: boolean;
+    /**
+     * Starting angle of the first segment
+     */
+    thetaStart: number;
+    /**
+     * The center angle of the circular sector on the bottom of the cylinder, with a default value of 2 * PI, makes it a complete cylinder.
+     */
+    thetaLength: number;
+    /**
+     *
+     * @constructor
+     * @param radiusTop
+     * @param radiusBottom
+     * @param height
+     * @param radialSegments
+     * @param heightSegments
+     * @param openEnded
+     * @param thetaStart
+     * @param thetaLength
+     */
+    constructor(radiusTop?: number, radiusBottom?: number, height?: number, radialSegments?: number, heightSegments?: number, openEnded?: boolean, thetaStart?: number, thetaLength?: number);
+    /**
+     * @internal
+     * @param start
+     * @param count
+     * @param index
+     */
+    private addGroup;
+    protected buildGeometry(): void;
+}

package/dist/src/shape/CylinderGeometry.js

@@ -0,0 +1,171 @@
+import { GeometryBase } from "../core/geometry/GeometryBase";
+import { VertexAttributeName } from "../core/geometry/VertexAttributeName";
+import { Vector2 } from "../math/Vector2";
+import { Vector3 } from "../math/Vector3";
+import { UUID } from "../util/Global";
+/**
+ * Cylinder geometry
+ * @group Geometry
+ */
+export class CylinderGeometry extends GeometryBase {
+    /**
+     *
+     * @constructor
+     * @param radiusTop
+     * @param radiusBottom
+     * @param height
+     * @param radialSegments
+     * @param heightSegments
+     * @param openEnded
+     * @param thetaStart
+     * @param thetaLength
+     */
+    constructor(radiusTop = 1, radiusBottom = 1, height = 1, radialSegments = 8, heightSegments = 8, openEnded = false, thetaStart = 0, thetaLength = Math.PI * 2) {
+        super();
+        this.radiusTop = radiusTop;
+        this.radiusBottom = radiusBottom;
+        this.height = height;
+        this.radialSegments = radialSegments;
+        this.heightSegments = heightSegments;
+        this.openEnded = openEnded;
+        this.thetaStart = thetaStart;
+        this.thetaLength = thetaLength;
+        this.instanceID = UUID();
+        this.buildGeometry();
+    }
+    /**
+     * @internal
+     * @param start
+     * @param count
+     * @param index
+     */
+    addGroup(start, count, index) {
+        this.addSubGeometry({
+            indexStart: start,
+            indexCount: count,
+            vertexStart: start,
+            vertexCount: 0,
+            firstStart: 0,
+            index: index,
+            topology: 0,
+        });
+    }
+    buildGeometry() {
+        const that = this;
+        this.radialSegments = Math.floor(this.radialSegments);
+        this.heightSegments = Math.floor(this.heightSegments);
+        const vertices = [];
+        const normals = [];
+        const uvs = [];
+        const indices = [];
+        let index = 0;
+        const indexArray = [];
+        const halfHeight = this.height / 2;
+        let groupStart = 0;
+        generateTorso();
+        if (this.openEnded === false) {
+            if (this.radiusTop > 0)
+                generateCap(true);
+            if (this.radiusBottom > 0)
+                generateCap(false);
+        }
+        let position_arr = new Float32Array(vertices);
+        let normal_arr = new Float32Array(normals);
+        let uv_arr = new Float32Array(uvs);
+        let indices_arr = new Uint16Array(indices);
+        this.setAttribute(VertexAttributeName.position, position_arr);
+        this.setAttribute(VertexAttributeName.normal, normal_arr);
+        this.setAttribute(VertexAttributeName.uv, uv_arr);
+        this.setAttribute(VertexAttributeName.TEXCOORD_1, uv_arr);
+        this.setIndices(indices_arr);
+        function generateTorso() {
+            const normal = new Vector3();
+            const vertex = new Vector3();
+            let groupCount = 0;
+            const slope = (that.radiusBottom - that.radiusTop) / that.height;
+            for (let y = 0; y <= that.heightSegments; y++) {
+                const indexRow = [];
+                const v = y / that.heightSegments;
+                const radius = v * (that.radiusBottom - that.radiusTop) + that.radiusTop;
+                for (let x = 0; x <= that.radialSegments; x++) {
+                    const u = x / that.radialSegments;
+                    let theta = u * that.thetaLength + that.thetaStart;
+                    if (x == that.radialSegments &&
+                        Math.abs(that.thetaLength - that.thetaStart) == Math.PI * 2) {
+                        theta = 0;
+                    }
+                    const sinTheta = Math.sin(theta);
+                    const cosTheta = Math.cos(theta);
+                    // vertex
+                    vertex.x = radius * sinTheta;
+                    vertex.y = -v * that.height + halfHeight;
+                    vertex.z = radius * cosTheta;
+                    vertices.push(vertex.x, vertex.y, vertex.z);
+                    // normal
+                    normal.set(sinTheta, slope, cosTheta).normalize();
+                    normals.push(normal.x, normal.y, normal.z);
+                    // uv
+                    uvs.push(u, 1 - v);
+                    indexRow.push(index++);
+                }
+                indexArray.push(indexRow);
+            }
+            for (let x = 0; x < that.radialSegments; x++) {
+                for (let y = 0; y < that.heightSegments; y++) {
+                    const a = indexArray[y][x];
+                    const b = indexArray[y + 1][x];
+                    const c = indexArray[y + 1][x + 1];
+                    const d = indexArray[y][x + 1];
+                    indices.push(a, b, d);
+                    indices.push(b, c, d);
+                    groupCount += 6;
+                }
+            }
+            that.addGroup(groupStart, groupCount, 0);
+            groupStart += groupCount;
+        }
+        function generateCap(top) {
+            const centerIndexStart = index;
+            const uv = new Vector2();
+            const vertex = new Vector3();
+            let groupCount = 0;
+            const radius = top === true ? that.radiusTop : that.radiusBottom;
+            const sign = top === true ? 1 : -1;
+            for (let x = 1; x <= that.radialSegments; x++) {
+                vertices.push(0, halfHeight * sign, 0);
+                normals.push(0, sign, 0);
+                uvs.push(0.5, 0.5);
+                index++;
+            }
+            const centerIndexEnd = index;
+            for (let x = 0; x <= that.radialSegments; x++) {
+                const u = x / that.radialSegments;
+                const theta = u * that.thetaLength + that.thetaStart;
+                const cosTheta = Math.cos(theta);
+                const sinTheta = Math.sin(theta);
+                vertex.x = radius * sinTheta;
+                vertex.y = halfHeight * sign;
+                vertex.z = radius * cosTheta;
+                vertices.push(vertex.x, vertex.y, vertex.z);
+                normals.push(0, sign, 0);
+                uv.x = cosTheta * 0.5 + 0.5;
+                uv.y = sinTheta * 0.5 * sign + 0.5;
+                uvs.push(uv.x, uv.y);
+                index++;
+            }
+            for (let x = 0; x < that.radialSegments; x++) {
+                const c = centerIndexStart + x;
+                const i = centerIndexEnd + x;
+                if (top === true) {
+                    indices.push(i, i + 1, c);
+                }
+                else {
+                    indices.push(i + 1, i, c);
+                }
+                groupCount += 3;
+            }
+            that.addGroup(groupStart, groupCount, top === true ? 1 : 2);
+            groupStart += groupCount;
+        }
+    }
+}

package/dist/src/shape/PlaneGeometry.d.ts

@@ -0,0 +1,11 @@
+import { GeometryBase } from "../core/geometry/GeometryBase";
+import { Vector3 } from "../math/Vector3";
+export declare class PlaneGeometry extends GeometryBase {
+    width: number;
+    height: number;
+    segmentW: number;
+    segmentH: number;
+    up: Vector3;
+    constructor(width: number, height: number, segmentW?: number, segmentH?: number, up?: Vector3);
+    private buildGeometry;
+}

package/dist/src/shape/PlaneGeometry.js

@@ -0,0 +1,105 @@
+import { BoundingBox } from "../core/bound/BoundingBox";
+import { GeometryBase } from "../core/geometry/GeometryBase";
+import { VertexAttributeName } from "../core/geometry/VertexAttributeName";
+import { Vector3 } from "../math/Vector3";
+export class PlaneGeometry extends GeometryBase {
+    constructor(width, height, segmentW = 1, segmentH = 1, up = Vector3.Y_AXIS) {
+        super();
+        this.width = width;
+        this.height = height;
+        this.segmentW = segmentW;
+        this.segmentH = segmentH;
+        this.up = up;
+        this.buildGeometry(this.up);
+    }
+    buildGeometry(axis) {
+        var x, y;
+        var numIndices;
+        var base;
+        var tw = this.segmentW + 1;
+        var numVertices = (this.segmentH + 1) * tw;
+        this.bounds = new BoundingBox(Vector3.ZERO.clone(), new Vector3(this.width, 1.0, this.height));
+        numIndices = this.segmentH * this.segmentW * 6;
+        let vertexCount = (this.segmentW + 1) * (this.segmentH + 1);
+        let position_arr = new Float32Array(vertexCount * 3);
+        let normal_arr = new Float32Array(vertexCount * 3);
+        let uv_arr = new Float32Array(vertexCount * 2);
+        let indices_arr;
+        let totalIndexCount = this.segmentW * this.segmentH * 2 * 3;
+        if (totalIndexCount >= Uint16Array.length) {
+            indices_arr = new Uint32Array(this.segmentW * this.segmentH * 2 * 3);
+        }
+        else {
+            indices_arr = new Uint16Array(this.segmentW * this.segmentH * 2 * 3);
+        }
+        numIndices = 0;
+        var indexP = 0;
+        var indexN = 0;
+        var indexU = 0;
+        for (var yi = 0; yi <= this.segmentH; ++yi) {
+            for (var xi = 0; xi <= this.segmentW; ++xi) {
+                x = (xi / this.segmentW - 0.5) * this.width;
+                y = (yi / this.segmentH - 0.5) * this.height;
+                switch (axis) {
+                    case Vector3.Y_AXIS:
+                        position_arr[indexP++] = x;
+                        position_arr[indexP++] = 0;
+                        position_arr[indexP++] = y;
+                        normal_arr[indexN++] = 0;
+                        normal_arr[indexN++] = 1;
+                        normal_arr[indexN++] = 0;
+                        break;
+                    case Vector3.Z_AXIS:
+                        position_arr[indexP++] = x;
+                        position_arr[indexP++] = -y;
+                        position_arr[indexP++] = 0;
+                        normal_arr[indexN++] = 0;
+                        normal_arr[indexN++] = 0;
+                        normal_arr[indexN++] = 1;
+                        break;
+                    case Vector3.X_AXIS:
+                        position_arr[indexP++] = 0;
+                        position_arr[indexP++] = x;
+                        position_arr[indexP++] = y;
+                        normal_arr[indexN++] = 1;
+                        normal_arr[indexN++] = 0;
+                        normal_arr[indexN++] = 0;
+                        break;
+                    default:
+                        position_arr[indexP++] = x;
+                        position_arr[indexP++] = 0;
+                        position_arr[indexP++] = y;
+                        normal_arr[indexN++] = 0;
+                        normal_arr[indexN++] = 1;
+                        normal_arr[indexN++] = 0;
+                        break;
+                }
+                uv_arr[indexU++] = xi / this.segmentW;
+                uv_arr[indexU++] = yi / this.segmentH;
+                if (xi != this.segmentW && yi != this.segmentH) {
+                    base = xi + yi * tw;
+                    indices_arr[numIndices++] = base + 1; //1
+                    indices_arr[numIndices++] = base; //0
+                    indices_arr[numIndices++] = base + tw; //2
+                    indices_arr[numIndices++] = base + 1; //1
+                    indices_arr[numIndices++] = base + tw; //2
+                    indices_arr[numIndices++] = base + tw + 1; //3
+                }
+            }
+        }
+        this.setIndices(indices_arr);
+        this.setAttribute(VertexAttributeName.position, position_arr);
+        this.setAttribute(VertexAttributeName.normal, normal_arr);
+        this.setAttribute(VertexAttributeName.uv, uv_arr);
+        this.setAttribute(VertexAttributeName.TEXCOORD_1, uv_arr);
+        this.addSubGeometry({
+            indexStart: 0,
+            indexCount: indices_arr.length,
+            vertexStart: 0,
+            vertexCount: 0,
+            firstStart: 0,
+            index: 0,
+            topology: 0,
+        });
+    }
+}