@rings-webgpu/core 1.0.2 → 1.0.3

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

@@ -1,156 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,248 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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;
-}