@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/core/geometry/ExtrudeGeometry.js

@@ -0,0 +1,156 @@
+import { Matrix4 } from "../../math/Matrix4";
+import { Vector3 } from "../../math/Vector3";
+import { BoundingBox } from "../bound/BoundingBox";
+import { GeometryBase } from "./GeometryBase";
+import { VertexAttributeName } from "./VertexAttributeName";
+class Section {
+    constructor(i) {
+        this.distance = 0;
+        this.index = i;
+        this.rotateShape = [];
+    }
+}
+export class ExtrudeGeometry extends GeometryBase {
+    /**
+     * 挤压几何体生成器
+     * 用于将2D形状沿3D路径挤压形成3D几何体
+     * 关于起点和终点的处理说明：
+     * 请勿手动将起点克隆到形状数组末尾
+     *
+     * closed参数说明：
+     * true - 自动闭合形状（会克隆起点到末尾）
+     * false - 保持开放形状
+     * @param shaderReflection ShaderReflection
+     */
+    build(shape, isShapeClosed, path, vScale = 1.0, uNegate = true) {
+        if (path.length < 2) {
+            throw new Error("path length is not enough");
+        }
+        this.vScale = vScale;
+        this.uNegate = uNegate;
+        shape = shape.slice(); //clone array
+        isShapeClosed && shape.push(shape[0]);
+        this.sections = this.buildSections(shape, path);
+        this.buildGeometry(shape, this.sections);
+        this.bounds = new BoundingBox(Vector3.ZERO.clone(), new Vector3(100, 100, 100));
+        return this;
+    }
+    buildSections(shape, path) {
+        let curPoint;
+        let nextPoint;
+        let normal;
+        let sections = [];
+        let sectionCount = path.length;
+        for (let i = 0; i < sectionCount; i++) {
+            let section = new Section(i);
+            curPoint = path[i];
+            nextPoint = path[i + 1];
+            section.center = curPoint.clone();
+            if (nextPoint == null) {
+                section.normal = normal.clone();
+                section.distance = 0;
+            }
+            else {
+                normal = nextPoint.subtract(curPoint);
+                section.distance = normal.length;
+                section.normal = normal.normalize();
+            }
+            sections.push(section);
+        }
+        sections[0].fixNormal = sections[0].normal.clone();
+        for (let i = 1; i < sectionCount; i++) {
+            let lastSection = sections[i - 1];
+            let curSection = sections[i];
+            curSection.fixNormal = curSection.normal
+                .add(lastSection.normal)
+                .normalize();
+        }
+        let matrixRotate = new Matrix4().identity();
+        for (let i = 0; i < sectionCount; i++) {
+            let curSection = sections[i];
+            let fromDirection;
+            let sourceShape;
+            if (i == 0) {
+                fromDirection = Vector3.UP;
+                sourceShape = shape;
+            }
+            else {
+                let lastSection = sections[i - 1];
+                fromDirection = lastSection.fixNormal;
+                sourceShape = lastSection.rotateShape;
+            }
+            Matrix4.fromToRotation(fromDirection, curSection.fixNormal, matrixRotate);
+            for (let i = 0, count = shape.length; i < count; i++) {
+                let newPoint = matrixRotate.multiplyPoint3(sourceShape[i]);
+                curSection.rotateShape.push(newPoint);
+            }
+        }
+        return sections;
+    }
+    buildGeometry(shape, sections) {
+        let sectionCount = sections.length;
+        let shapeVertexCount = shape.length;
+        let totalVertexCount = sectionCount * shapeVertexCount;
+        let segmentCount = sectionCount - 1;
+        let position_arr = new Float32Array(totalVertexCount * 3);
+        let normal_arr = new Float32Array(totalVertexCount * 3);
+        let uv_arr = new Float32Array(totalVertexCount * 2);
+        let indices_arr = new Uint32Array(segmentCount * (shapeVertexCount - 1) * 6);
+        let quadCount = shapeVertexCount - 1;
+        let vDistance = 0;
+        let uDistance = 0;
+        let uList = [0];
+        for (let i = 1; i < shapeVertexCount; i++) {
+            uDistance += shape[i - 1].subtract(shape[i]).length;
+            uList.push(uDistance);
+        }
+        for (let i = 0; i < sectionCount; i++) {
+            let section = sections[i];
+            for (let j = 0; j < shapeVertexCount; j++) {
+                let pos_offset = (i * shapeVertexCount + j) * 3;
+                let vertex = section.rotateShape[j].add(section.center);
+                position_arr[pos_offset] = vertex.x;
+                position_arr[pos_offset + 1] = vertex.y;
+                position_arr[pos_offset + 2] = vertex.z;
+                normal_arr[pos_offset + 1] = 1;
+                let uv_offset = (i * shapeVertexCount + j) * 2;
+                let u = uList[j] / uDistance;
+                uv_arr[uv_offset] = this.uNegate ? 1 - u : u;
+                uv_arr[uv_offset + 1] = vDistance * this.vScale;
+            }
+            vDistance += section.distance;
+        }
+        let index = 0;
+        for (let i = 0; i < segmentCount; i++) {
+            let vertexOffset = i * shapeVertexCount;
+            for (let j = 0; j < quadCount; j++) {
+                let vertex_rb = j;
+                let vertex_lb = j + 1;
+                let vertex_rt = vertex_rb + shapeVertexCount;
+                let vertex_lt = vertex_lb + shapeVertexCount;
+                indices_arr[index++] = vertex_rb + vertexOffset;
+                indices_arr[index++] = vertex_lb + vertexOffset;
+                indices_arr[index++] = vertex_rt + vertexOffset;
+                indices_arr[index++] = vertex_lb + vertexOffset;
+                indices_arr[index++] = vertex_lt + vertexOffset;
+                indices_arr[index++] = vertex_rt + vertexOffset;
+            }
+        }
+        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,
+        });
+        this.computeNormals();
+        return this;
+    }
+}

package/dist/src/core/geometry/GeometryBase.d.ts

@@ -0,0 +1,70 @@
+import { ShaderReflection } from "../../gfx/graphics/webGpu/shader/value/ShaderReflectionInfo";
+import { Vector3 } from "../../math/Vector3";
+import { BoundingBox } from "../bound/BoundingBox";
+import { VertexAttributeName } from "./VertexAttributeName";
+import { GeometryVertexBuffer } from "./GeometryVertexBuffer";
+import { GeometryIndicesBuffer } from "./GeometryIndicesBuffer";
+import { GeometryVertexType } from "./GeometryVertexType";
+import { VertexAttributeData } from "./VertexAttributeData";
+import { ArrayBufferData } from "../../gfx/graphics/webGpu/core/buffer/ArrayBufferData";
+import { BlendShapeData } from "../../loader/parser/prefab/prefabData/BlendShapeData";
+import { Matrix4 } from "../../math/Matrix4";
+export type LODDescriptor = {
+    indexStart: number;
+    indexCount: number;
+    vertexStart: number;
+    vertexCount: number;
+    firstStart: number;
+    index: number;
+    topology: number;
+};
+export declare class SubGeometry {
+    lodLevels: LODDescriptor[];
+}
+export declare class GeometryBase {
+    instanceID: string;
+    name: string;
+    subGeometries: SubGeometry[];
+    morphTargetsRelative: boolean;
+    morphTargetDictionary: {
+        [blenderName: string]: number;
+    };
+    skinNames: string[];
+    bindPose: Matrix4[];
+    blendShapeData: BlendShapeData;
+    vertexDim: number;
+    vertexCount: number;
+    private _bounds;
+    private _attributeMap;
+    private _attributes;
+    private _indicesBuffer;
+    private _vertexBuffer;
+    private _onChange;
+    private _wireframeLines;
+    constructor();
+    get indicesBuffer(): GeometryIndicesBuffer;
+    get vertexBuffer(): GeometryVertexBuffer;
+    get vertexAttributes(): string[];
+    get vertexAttributeMap(): Map<string, VertexAttributeData>;
+    get geometryType(): GeometryVertexType;
+    set geometryType(value: GeometryVertexType);
+    get bounds(): BoundingBox;
+    set bounds(value: BoundingBox);
+    addSubGeometry(...lodLevels: LODDescriptor[]): SubGeometry;
+    generate(shaderReflection: ShaderReflection): void;
+    setIndices(data: ArrayBufferData): void;
+    setAttribute(attribute: VertexAttributeName | string, data: ArrayBufferData): void;
+    getAttribute(attribute: VertexAttributeName | string): VertexAttributeData;
+    hasAttribute(attribute: VertexAttributeName | string): boolean;
+    genWireframe(): Vector3[];
+    compute(): void;
+    private static crossA;
+    private static crossB;
+    private static crossRet;
+    private static point1;
+    private static point2;
+    private static point3;
+    computeNormals(): this;
+    isPrimitive(): boolean;
+    destroy(force?: boolean): void;
+}

package/dist/src/core/geometry/GeometryBase.js

@@ -0,0 +1,248 @@
+import { Vector3 } from "../../math/Vector3";
+import { UUID } from "../../util/Global";
+import { BoundingBox } from "../bound/BoundingBox";
+import { VertexAttributeName } from "./VertexAttributeName";
+import { GeometryVertexBuffer } from "./GeometryVertexBuffer";
+import { GeometryIndicesBuffer } from "./GeometryIndicesBuffer";
+import { GeometryVertexType } from "./GeometryVertexType";
+export class SubGeometry {
+}
+export class GeometryBase {
+    constructor() {
+        this.subGeometries = [];
+        this.vertexCount = 0;
+        this._onChange = true;
+        this.instanceID = UUID();
+        this._attributeMap = new Map();
+        this._attributes = [];
+        this._vertexBuffer = new GeometryVertexBuffer();
+    }
+    get indicesBuffer() {
+        return this._indicesBuffer;
+    }
+    get vertexBuffer() {
+        return this._vertexBuffer;
+    }
+    get vertexAttributes() {
+        return this._attributes;
+    }
+    get vertexAttributeMap() {
+        return this._attributeMap;
+    }
+    get geometryType() {
+        return this._vertexBuffer.geometryType;
+    }
+    set geometryType(value) {
+        this._vertexBuffer.geometryType = value;
+    }
+    get bounds() {
+        if (!this._bounds) {
+            this._bounds = new BoundingBox(new Vector3(), new Vector3(1, 1, 1));
+            this._bounds.min.x = Number.MAX_VALUE;
+            this._bounds.min.y = Number.MAX_VALUE;
+            this._bounds.min.z = Number.MAX_VALUE;
+            this._bounds.max.x = -Number.MAX_VALUE;
+            this._bounds.max.y = -Number.MAX_VALUE;
+            this._bounds.max.z = -Number.MAX_VALUE;
+            let attributes = this.getAttribute(VertexAttributeName.position);
+            if (attributes && attributes.data) {
+                for (let i = 0; i < attributes.data.length / 3; i++) {
+                    const px = attributes.data[i * 3 + 0];
+                    const py = attributes.data[i * 3 + 1];
+                    const pz = attributes.data[i * 3 + 2];
+                    if (this._bounds.min.x > px) {
+                        this._bounds.min.x = px;
+                    }
+                    if (this._bounds.min.y > py) {
+                        this._bounds.min.y = py;
+                    }
+                    if (this._bounds.min.z > pz) {
+                        this._bounds.min.z = pz;
+                    }
+                    if (this._bounds.max.x < px) {
+                        this._bounds.max.x = px;
+                    }
+                    if (this._bounds.max.y < py) {
+                        this._bounds.max.y = py;
+                    }
+                    if (this._bounds.max.z < pz) {
+                        this._bounds.max.z = pz;
+                    }
+                }
+            }
+            this._bounds.setFromMinMax(this._bounds.min, this._bounds.max);
+        }
+        return this._bounds;
+    }
+    set bounds(value) {
+        this._bounds = value;
+    }
+    addSubGeometry(...lodLevels) {
+        let sub = new SubGeometry();
+        sub.lodLevels = lodLevels;
+        this.subGeometries.push(sub);
+        return sub;
+    }
+    generate(shaderReflection) {
+        if (this._onChange) {
+            this._onChange = false;
+            this._indicesBuffer.upload(this.getAttribute(VertexAttributeName.indices).data);
+            this._vertexBuffer.createVertexBuffer(this._attributeMap, shaderReflection);
+            this._vertexBuffer.updateAttributes(this._attributeMap);
+            this.vertexCount = this._vertexBuffer.vertexCount;
+        }
+    }
+    setIndices(data) {
+        if (!this._attributeMap.has(VertexAttributeName.indices)) {
+            let vertexInfo = {
+                attribute: VertexAttributeName.indices,
+                data: data,
+            };
+            this._attributeMap.set(VertexAttributeName.indices, vertexInfo);
+            this._indicesBuffer = new GeometryIndicesBuffer();
+            this._indicesBuffer.createIndicesBuffer(vertexInfo);
+        }
+    }
+    setAttribute(attribute, data) {
+        if (attribute == VertexAttributeName.indices) {
+            this.setIndices(data);
+        }
+        else {
+            let vertexInfo = {
+                attribute: attribute,
+                data: data,
+            };
+            this._attributeMap.set(attribute, vertexInfo);
+            this._attributes.push(attribute);
+        }
+    }
+    getAttribute(attribute) {
+        return this._attributeMap.get(attribute);
+    }
+    hasAttribute(attribute) {
+        return this._attributeMap.has(attribute);
+    }
+    genWireframe() {
+        if (this._wireframeLines)
+            return this._wireframeLines;
+        if (this.geometryType == GeometryVertexType.split ||
+            this.geometryType == GeometryVertexType.compose) {
+            let positionAttribute = this.getAttribute(VertexAttributeName.position);
+            let indexAttribute = this.getAttribute(VertexAttributeName.indices);
+            if (indexAttribute &&
+                positionAttribute &&
+                indexAttribute.data.length > 0) {
+                let vertexData = positionAttribute.data;
+                let lines = [];
+                for (let i = 0; i < indexAttribute.data.length / 3; i++) {
+                    const i1 = indexAttribute.data[i * 3 + 0];
+                    const i2 = indexAttribute.data[i * 3 + 1];
+                    const i3 = indexAttribute.data[i * 3 + 2];
+                    let p1 = new Vector3(vertexData[i1 * 3 + 0], vertexData[i1 * 3 + 1], vertexData[i1 * 3 + 2]);
+                    let p2 = new Vector3(vertexData[i2 * 3 + 0], vertexData[i2 * 3 + 1], vertexData[i2 * 3 + 2]);
+                    let p3 = new Vector3(vertexData[i3 * 3 + 0], vertexData[i3 * 3 + 1], vertexData[i3 * 3 + 2]);
+                    lines.push(p1, p2);
+                    lines.push(p2, p3);
+                    lines.push(p3, p1);
+                }
+                this._wireframeLines = lines;
+                return lines;
+            }
+        }
+        else if (this.geometryType == GeometryVertexType.compose_bin) {
+            let vertexAttribute = this.getAttribute(VertexAttributeName.all);
+            let strip = this.vertexDim;
+            let indexAttribute = this.getAttribute(VertexAttributeName.indices);
+            if (indexAttribute && vertexAttribute && indexAttribute.data.length > 0) {
+                let vertexData = vertexAttribute.data;
+                let lines = [];
+                for (let i = 0; i < indexAttribute.data.length / 3; i++) {
+                    const i1 = indexAttribute.data[i * 3 + 0]; // start by 0
+                    const i2 = indexAttribute.data[i * 3 + 1]; // start by 1
+                    const i3 = indexAttribute.data[i * 3 + 2]; // start by 2
+                    let p1 = new Vector3(vertexData[i1 * strip + 0], vertexData[i1 * strip + 1], vertexData[i1 * strip + 2]);
+                    let p2 = new Vector3(vertexData[i2 * strip + 0], vertexData[i2 * strip + 1], vertexData[i2 * strip + 2]);
+                    let p3 = new Vector3(vertexData[i3 * strip + 0], vertexData[i3 * strip + 1], vertexData[i3 * strip + 2]);
+                    lines.push(p1, p2);
+                    lines.push(p2, p3);
+                    lines.push(p3, p1);
+                }
+                this._wireframeLines = lines;
+                return lines;
+            }
+        }
+        return null;
+    }
+    compute() {
+        if (this._indicesBuffer) {
+            this._indicesBuffer.compute();
+        }
+        if (this._vertexBuffer) {
+            this._vertexBuffer.compute();
+        }
+    }
+    static { this.crossA = Vector3.UP.clone(); }
+    static { this.crossB = Vector3.UP.clone(); }
+    static { this.crossRet = Vector3.UP.clone(); }
+    static { this.point1 = Vector3.UP.clone(); }
+    static { this.point2 = Vector3.UP.clone(); }
+    static { this.point3 = Vector3.UP.clone(); }
+    computeNormals() {
+        let posAttrData = this.getAttribute(VertexAttributeName.position);
+        let normalAttrData = this.getAttribute(VertexAttributeName.normal);
+        let indexAttrData = this.getAttribute(VertexAttributeName.indices);
+        if (!posAttrData || !normalAttrData || !indexAttrData) {
+            return this;
+        }
+        let trianglesCount = indexAttrData.data.length / 3;
+        let point1 = GeometryBase.point1;
+        let point2 = GeometryBase.point2;
+        let point3 = GeometryBase.point3;
+        let crossA = GeometryBase.crossA;
+        let crossB = GeometryBase.crossB;
+        let crossRet = GeometryBase.crossRet;
+        for (let i = 0; i < trianglesCount; i++) {
+            let index1 = indexAttrData.data[i * 3];
+            let index2 = indexAttrData.data[i * 3 + 1];
+            let index3 = indexAttrData.data[i * 3 + 2];
+            point1.set(posAttrData.data[index1 * 3], posAttrData.data[index1 * 3 + 1], posAttrData.data[index1 * 3 + 2]);
+            point2.set(posAttrData.data[index2 * 3], posAttrData.data[index2 * 3 + 1], posAttrData.data[index2 * 3 + 2]);
+            point3.set(posAttrData.data[index3 * 3], posAttrData.data[index3 * 3 + 1], posAttrData.data[index3 * 3 + 2]);
+            Vector3.sub(point1, point2, crossA).normalize();
+            Vector3.sub(point1, point3, crossB).normalize();
+            let normal = crossA.crossProduct(crossB, crossRet).normalize();
+            normalAttrData.data[index1 * 3] =
+                normalAttrData.data[index2 * 3] =
+                    normalAttrData.data[index3 * 3] =
+                        normal.x;
+            normalAttrData.data[index1 * 3 + 1] =
+                normalAttrData.data[index2 * 3 + 1] =
+                    normalAttrData.data[index3 * 3 + 1] =
+                        normal.y;
+            normalAttrData.data[index1 * 3 + 2] =
+                normalAttrData.data[index2 * 3 + 2] =
+                    normalAttrData.data[index3 * 3 + 2] =
+                        normal.z;
+        }
+        // normal attr need to be upload
+        this._vertexBuffer.upload(VertexAttributeName.normal, normalAttrData);
+        return this;
+    }
+    isPrimitive() {
+        return false; // this.geometrySource != null && this.geometrySource.type != 'none';
+    }
+    destroy(force) {
+        this.instanceID = null;
+        this.name = null;
+        this.subGeometries = null;
+        this.morphTargetDictionary = null;
+        this._bounds.destroy();
+        this._bounds = null;
+        this._attributeMap = null;
+        this._attributes = null;
+        this._indicesBuffer.destroy();
+        this._vertexBuffer.destroy();
+        this._indicesBuffer = null;
+        this._vertexBuffer = null;
+    }
+}

package/dist/src/core/geometry/GeometryIndicesBuffer.d.ts

@@ -0,0 +1,15 @@
+import { ArrayBufferData } from "../../gfx/graphics/webGpu/core/buffer/ArrayBufferData";
+import { IndicesGPUBuffer } from "../../gfx/graphics/webGpu/core/buffer/IndicesGPUBuffer";
+import { VertexAttributeData } from "./VertexAttributeData";
+export declare class GeometryIndicesBuffer {
+    uuid: string;
+    name: string;
+    indicesGPUBuffer: IndicesGPUBuffer;
+    indicesFormat: GPUIndexFormat;
+    indicesCount: number;
+    constructor();
+    createIndicesBuffer(indicesData: VertexAttributeData): void;
+    upload(data: ArrayBufferData): void;
+    compute(): void;
+    destroy(): void;
+}

package/dist/src/core/geometry/GeometryIndicesBuffer.js

@@ -0,0 +1,33 @@
+import { IndicesGPUBuffer } from "../../gfx/graphics/webGpu/core/buffer/IndicesGPUBuffer";
+/* eslint-disable */
+export class GeometryIndicesBuffer {
+    constructor() {
+        this.uuid = "";
+        this.indicesFormat = `uint16`;
+        this.indicesCount = 0;
+    }
+    createIndicesBuffer(indicesData) {
+        if (indicesData.data instanceof Uint16Array) {
+            this.indicesFormat = `uint16`;
+        }
+        else if (indicesData.data instanceof Uint32Array) {
+            this.indicesFormat = `uint32`;
+        }
+        this.indicesCount = indicesData.data.length;
+        this.indicesGPUBuffer = new IndicesGPUBuffer(indicesData.data);
+    }
+    upload(data) {
+        const buffer = data.buffer instanceof ArrayBuffer ? data.buffer : new Uint8Array(data.buffer).buffer;
+        this.indicesGPUBuffer.indicesNode.setArrayBuffer(0, buffer);
+        this.indicesGPUBuffer.apply();
+    }
+    compute() { }
+    destroy() {
+        this.uuid = null;
+        this.name = null;
+        this.indicesFormat = null;
+        this.indicesCount = null;
+        this.indicesGPUBuffer.destroy();
+        this.indicesGPUBuffer = null;
+    }
+}

package/dist/src/core/geometry/GeometryVertexBuffer.d.ts

@@ -0,0 +1,23 @@
+import { VertexGPUBuffer } from "../../gfx/graphics/webGpu/core/buffer/VertexGPUBuffer";
+import { ShaderReflection } from "../../gfx/graphics/webGpu/shader/value/ShaderReflectionInfo";
+import { VertexAttributeData } from "./VertexAttributeData";
+import { GeometryVertexType } from "./GeometryVertexType";
+import { VertexBufferLayout } from "./VertexAttribute";
+export declare class GeometryVertexBuffer {
+    vertexCount: number;
+    vertexGPUBuffer: VertexGPUBuffer;
+    geometryType: GeometryVertexType;
+    private _vertexBufferLayouts;
+    private _attributeSlotLayouts;
+    private _attributeLocation;
+    constructor();
+    get vertexBufferLayouts(): VertexBufferLayout[];
+    createVertexBuffer(vertexDataInfos: Map<string, VertexAttributeData>, shaderReflection: ShaderReflection): void;
+    private createSplitVertexBuffer;
+    private createComposeVertexBuffer;
+    private createComposBinVertexBuffer;
+    upload(attribute: string, vertexDataInfo: VertexAttributeData): void;
+    updateAttributes(vertexDataInfos: Map<string, VertexAttributeData>): void;
+    compute(): void;
+    destroy(force?: boolean): void;
+}