@rings-webgpu/core 1.0.2 → 1.0.4

package/dist/src/core/Camera3D.js

@@ -1,534 +0,0 @@
-import { ComponentBase } from "../components/ComponentBase";
-import { Engine3D } from "../Engine3D";
-import { HaltonSeq } from "../math/HaltonSeq";
-import { MathUtil } from "../math/MathUtil";
-import { Matrix4, matrixMultiply } from "../math/Matrix4";
-import { Ray } from "../math/Ray";
-import { Rect } from "../math/Rect";
-import { Vector2 } from "../math/Vector2";
-import { Vector3 } from "../math/Vector3";
-import { CameraUtil } from "../util/CameraUtil";
-import { Frustum } from "./bound/Frustum";
-import { CameraType } from "./CameraType";
-import { webGPUContext } from "../gfx/graphics/webGpu/Context3D";
-import { FrustumCSM } from "./csm/FrustumCSM";
-import { CSM } from "./csm/CSM";
-import { CResizeEvent } from "../event/CResizeEvent";
-/**
- * Camera3D类表示3D场景中的相机组件。
- * 它支持透视投影和正交投影，并提供视锥体裁剪、阴影计算、坐标转换等功能。
- * 相机是渲染3D场景的视角，决定了场景中哪些部分会被渲染到屏幕上。
- */
-export class Camera3D extends ComponentBase {
-    get projectionMatrix() {
-        return this._projectionMatrix;
-    }
-    get enableCSM() {
-        return this._enableCSM;
-    }
-    set enableCSM(value) {
-        if (value && !this.csm) {
-            this.csm = new FrustumCSM(CSM.Cascades);
-        }
-        this._enableCSM = value;
-    }
-    /**
-     * 创建一个新的Camera3D实例
-     */
-    constructor() {
-        super();
-        /**
-         * 相机视野角度（度），用于透视投影
-         */
-        this.fov = 60;
-        /**
-         * 视口宽高比（宽度/高度）
-         */
-        this.aspect = 1;
-        /**
-         * 近裁剪面距离
-         */
-        this.near = 1;
-        /**
-         * 远裁剪面距离
-         */
-        this.far = 5000;
-        /**
-         * 正交投影左边界
-         */
-        this.left = -100;
-        /**
-         * 正交投影右边界
-         */
-        this.right = 100;
-        /**
-         * 正交投影上边界
-         */
-        this.top = 100;
-        /**
-         * 正交投影下边界
-         */
-        this.bottom = -100;
-        /**
-         * 正交投影视锥体大小
-         */
-        this.frustumSize = 100;
-        /**
-         * 相机视口矩形
-         */
-        this.viewPort = new Rect();
-        /**
-         * 球谐光照系数数组
-         */
-        this.sh = new Float32Array(36);
-        /**
-         * 标记此相机是否为阴影相机
-         */
-        this.isShadowCamera = false;
-        this._projectionMatrixInv = new Matrix4();
-        this._projectionMatrix = new Matrix4();
-        this._viewMatrix = new Matrix4();
-        this._viewMatrixInv = new Matrix4();
-        this._unprojection = new Matrix4();
-        this._pvMatrixInv = new Matrix4();
-        this._pvMatrix = new Matrix4();
-        this._enableCSM = false;
-        this.type = CameraType.perspective;
-        this.cubeShadowCameras = [];
-        this._useJitterProjection = false;
-        this._jitterFrameIndex = 0;
-        this._sampleIndex = 0;
-        this._jitterX = 0;
-        this._jitterY = 0;
-    }
-    /**
-     * 初始化相机
-     * 创建射线、视锥体和观察目标
-     * 设置视口并更新投影矩阵
-     * 监听窗口大小变化事件
-     */
-    init() {
-        super.init();
-        this._ray = new Ray();
-        this.frustum = new Frustum();
-        this.lookTarget = new Vector3(0, 0, 0);
-        // TODO: set viewport based on View3D size
-        this.viewPort.x = 0;
-        this.viewPort.y = 0;
-        this.viewPort.w = webGPUContext.presentationSize[0];
-        this.viewPort.h = webGPUContext.presentationSize[1];
-        this.updateProjection();
-        webGPUContext.addEventListener(CResizeEvent.RESIZE, this.updateProjection, this);
-    }
-    /**
-     * 根据当前相机类型更新投影矩阵
-     * 透视投影或正交投影
-     */
-    updateProjection() {
-        this.aspect = webGPUContext.aspect;
-        if (this.type == CameraType.perspective) {
-            this.perspective(this.fov, this.aspect, this.near, this.far);
-        }
-        else if (this.type == CameraType.ortho) {
-            if (this.frustumSize)
-                this.ortho(this.frustumSize, this.near, this.far);
-            else
-                this.orthoOffCenter(this.left, this.right, this.bottom, this.top, this.near, this.far);
-        }
-    }
-    /**
-     * 计算阴影偏移值，用于阴影贴图采样
-     * @param depthTexSize 深度纹理大小
-     * @returns 阴影偏移值
-     */
-    getShadowBias(depthTexSize) {
-        let sizeOnePixel = (2.0 * this.getShadowWorldExtents()) / depthTexSize;
-        let depth = this.far - this.near;
-        return sizeOnePixel / depth - Engine3D.setting.shadow.shadowBias * 0.01;
-    }
-    /**
-     * 获取阴影世界空间范围
-     * @returns 阴影世界空间范围值
-     */
-    getShadowWorldExtents() {
-        let shadowBound = Engine3D.setting.shadow.shadowBound;
-        if (!shadowBound) {
-            shadowBound = Math.round(0.05 * this.frustum.boundingBox.extents.length);
-        }
-        else {
-            shadowBound *= 0.5;
-        }
-        return shadowBound;
-    }
-    /**
-     * 获取级联阴影映射(CSM)的阴影偏移缩放因子
-     * 根据当前相机和基础相机的深度范围计算缩放因子
-     * @param shadowCamera 阴影相机
-     * @returns 阴影偏移缩放因子
-     */
-    getCSMShadowBiasScale(shadowCamera) {
-        if (shadowCamera == this)
-            return 1.0;
-        let currentSize = this.far - this.near;
-        let baseCamera = this.csm.children[0].shadowCamera;
-        let baseSize = baseCamera.far - baseCamera.near;
-        return baseSize / currentSize;
-    }
-    /**
-     * 获取级联阴影映射(CSM)指定级联的世界空间范围
-     * @param index 级联索引
-     * @returns 指定级联的世界空间范围值
-     */
-    getCSMShadowWorldExtents(index) {
-        return Math.round(this.csm.children[index].bound.extents.length);
-    }
-    /**
-     * 设置透视投影参数
-     * @param fov 视野角度（度）
-     * @param aspect 宽高比
-     * @param near 近裁剪面距离
-     * @param far 远裁剪面距离
-     */
-    perspective(fov, aspect, near, far) {
-        this.fov = fov;
-        this.aspect = aspect;
-        this.near = Math.max(0.001, near);
-        this.far = far;
-        this._projectionMatrix.perspective(this.fov, this.aspect, this.near, this.far);
-        this.type = CameraType.perspective;
-    }
-    /**
-     * 设置正交投影参数（基于尺寸）
-     * @param frustumSize 视锥体大小
-     * @param near 近裁剪面距离
-     * @param far 远裁剪面距离
-     */
-    ortho(frustumSize, near, far) {
-        this.frustumSize = frustumSize;
-        let w = frustumSize * 0.5 * this.aspect;
-        let h = frustumSize * 0.5;
-        let left = -w / 2;
-        let right = w / 2;
-        let top = h / 2;
-        let bottom = -h / 2;
-        this.orthoOffCenter(left, right, bottom, top, near, far);
-    }
-    /**
-     * 设置正交投影参数（基于边界）
-     * @param left 左边界
-     * @param right 右边界
-     * @param bottom 下边界
-     * @param top 上边界
-     * @param near 近裁剪面距离
-     * @param far 远裁剪面距离
-     */
-    orthoOffCenter(left, right, bottom, top, near, far) {
-        this.near = near;
-        this.far = far;
-        this.left = left;
-        this.right = right;
-        this.top = top;
-        this.bottom = bottom;
-        this.type = CameraType.ortho;
-        this._projectionMatrix.orthoOffCenter(this.left, this.right, this.bottom, this.top, this.near, this.far);
-    }
-    /**
-     * 获取视图矩阵
-     * 视图矩阵是相机世界矩阵的逆矩阵，用于将世界坐标转换为相机坐标
-     * @returns 视图矩阵
-     */
-    get viewMatrix() {
-        this._viewMatrix.copyFrom(this.transform.worldMatrix);
-        this._viewMatrix.invert();
-        return this._viewMatrix;
-    }
-    /**
-     * 获取阴影视图矩阵
-     * 用于阴影贴图渲染的特殊视图矩阵
-     * @returns 阴影视图矩阵
-     */
-    get shadowViewMatrix() {
-        this._viewMatrix.copyFrom(this.transform.worldMatrix);
-        this._viewMatrix.appendScale(1, 1.0, 1.0);
-        this._viewMatrix.invert();
-        return this._viewMatrix;
-    }
-    /**
-     * 将3D对象坐标转换为屏幕坐标
-     * @param n 3D对象坐标
-     * @param target 目标向量，如果为null则创建新向量
-     * @returns 屏幕坐标
-     */
-    object3DToScreenRay(n, target = null) {
-        if (!target) {
-            target = new Vector3(0, 0, 0, 1);
-        }
-        this._halfw = this.viewPort.width * 0.5;
-        this._halfh = this.viewPort.height * 0.5;
-        MathUtil.transformVector(this.viewMatrix, n, target);
-        this.project(target, target);
-        target.x = this._halfw + target.x * this._halfw;
-        target.y = this.viewPort.height - (this._halfh - target.y * this._halfh);
-        return target;
-    }
-    /**
-     * 将屏幕坐标转换为3D对象坐标
-     * @param n 屏幕坐标
-     * @param target 目标向量，如果为null则创建新向量
-     * @returns 3D对象坐标
-     */
-    screenRayToObject3D(n, target = null) {
-        if (!target) {
-            target = new Vector3();
-        }
-        this._halfw = this.viewPort.width * 0.5;
-        this._halfh = this.viewPort.height * 0.5;
-        let fScreenPtX = n.x;
-        let fScreenPtY = n.y;
-        target.x = fScreenPtX / this.viewPort.width - 0.25;
-        target.y = fScreenPtY / this.viewPort.height - 0.25;
-        this.unProject(target.x, target.y, n.z, target);
-        return target;
-    }
-    /**
-     * 获取投影-视图组合矩阵
-     * 用于将世界坐标直接转换为裁剪空间坐标
-     * @returns 投影-视图矩阵
-     */
-    get pvMatrix() {
-        matrixMultiply(this._projectionMatrix, this.viewMatrix, this._pvMatrix);
-        return this._pvMatrix;
-    }
-    /**
-     * 获取投影-世界组合矩阵的逆矩阵
-     * @returns 投影-世界矩阵的逆矩阵
-     */
-    get pvMatrix2() {
-        matrixMultiply(this._projectionMatrix, this.transform.worldMatrix, this._pvMatrix);
-        let matrix = this._pvMatrixInv.copyFrom(this.pvMatrix);
-        matrix.invert();
-        return matrix;
-    }
-    /**
-     * 获取投影-视图矩阵的逆矩阵
-     * 用于从裁剪空间坐标转换回世界坐标
-     * @returns 投影-视图矩阵的逆矩阵
-     */
-    get pvMatrixInv() {
-        let matrix = this._pvMatrixInv.copyFrom(this.pvMatrix);
-        matrix.invert();
-        return matrix;
-    }
-    /**
-     * 获取视图矩阵的逆矩阵
-     * 用于从相机空间坐标转换回世界坐标
-     * @returns 视图矩阵的逆矩阵
-     */
-    get vMatrixInv() {
-        let matrix = this._viewMatrixInv.copyFrom(this.viewMatrix);
-        matrix.invert();
-        return matrix;
-    }
-    /**
-     * 获取从相机空间到世界空间的变换矩阵
-     * @returns 相机到世界的变换矩阵
-     */
-    get cameraToWorld() {
-        let cameraToWorld = Matrix4.helpMatrix;
-        cameraToWorld.identity();
-        cameraToWorld.copyFrom(this.projectionMatrixInv);
-        cameraToWorld.multiply(this.vMatrixInv);
-        return cameraToWorld;
-    }
-    /**
-     * 获取从标准化设备坐标(NDC)到视图空间的变换矩阵
-     * @returns NDC到视图空间的变换矩阵
-     */
-    get ndcToView() {
-        let cameraToWorld = Matrix4.helpMatrix;
-        cameraToWorld.identity();
-        cameraToWorld.copyFrom(this.projectionMatrixInv);
-        return cameraToWorld;
-    }
-    /**
-     * 获取投影矩阵的逆矩阵
-     * 用于从裁剪空间坐标转换回相机空间坐标
-     * @returns 投影矩阵的逆矩阵
-     */
-    get projectionMatrixInv() {
-        this._projectionMatrixInv.copyFrom(this._projectionMatrix);
-        this._projectionMatrixInv.invert();
-        return this._projectionMatrixInv;
-    }
-    /**
-     * 将屏幕坐标反投影到世界空间
-     * @param nX 屏幕X坐标
-     * @param nY 屏幕Y坐标
-     * @param sZ 深度值
-     * @param target 目标向量，如果为null则创建新向量
-     * @returns 世界空间中的向量
-     */
-    unProject(nX, nY, sZ, target) {
-        if (!target)
-            target = new Vector3();
-        target.x = nX;
-        target.y = -nY;
-        target.z = sZ;
-        target.w = 1.0;
-        target.x *= sZ;
-        target.y *= sZ;
-        this._unprojection.copyFrom(this._projectionMatrix);
-        this._unprojection.invert();
-        MathUtil.transformVector(this._unprojection, target, target);
-        target.z = sZ;
-        return target;
-    }
-    /**
-     * 将向量从相机空间投影到裁剪空间
-     * @param n 相机空间中的向量
-     * @param target 目标向量
-     * @returns 裁剪空间中的向量
-     * @private
-     */
-    project(n, target) {
-        this._projectionMatrix.perspectiveMultiplyPoint3(n, target);
-        target.x = target.x / target.w;
-        target.y = -target.y / target.w;
-        target.z = n.z;
-        return target;
-    }
-    /**
-     * 从屏幕坐标创建射线
-     * 用于拾取和碰撞检测
-     * @param viewPortPosX 视口X坐标
-     * @param viewPortPosY 视口Y坐标
-     * @returns 从相机位置指向屏幕点的射线
-     */
-    screenPointToRay(viewPortPosX, viewPortPosY) {
-        let ray = this._ray;
-        let start = CameraUtil.UnProjection(viewPortPosX, viewPortPosY, 0.01, this);
-        let end = CameraUtil.UnProjection(viewPortPosX, viewPortPosY, 1.0, this);
-        end = end.subtract(start).normalize();
-        ray.origin.copyFrom(start);
-        // ray.dir.copyFrom(end);
-        ray.direction = end;
-        return ray;
-    }
-    /**
-     * 将屏幕坐标转换为世界坐标
-     * @param viewPortPosX 视口X坐标
-     * @param viewPortPosY 视口Y坐标
-     * @param z 深度值
-     * @returns 世界空间中的坐标
-     */
-    screenPointToWorld(viewPortPosX, viewPortPosY, z) {
-        let pos = CameraUtil.UnProjection(viewPortPosX, viewPortPosY, z, this);
-        return pos;
-    }
-    /**
-     * 将世界坐标转换为屏幕坐标
-     * @param point 世界空间中的点
-     * @param target 目标向量，如果为null则创建新向量
-     * @returns 屏幕空间中的坐标
-     */
-    worldToScreenPoint(point, target) {
-        let pos = CameraUtil.Projection(point, this, target);
-        return pos;
-    }
-    /**
-     * 使相机朝向指定目标点
-     * @param pos 相机位置
-     * @param target 目标点位置
-     * @param up 上方向向量，默认为Y轴正方向
-     */
-    lookAt(pos, target, up = Vector3.Y_AXIS) {
-        this.transform.lookAt(pos, target, up);
-        if (target)
-            this.lookTarget.copyFrom(target);
-    }
-    /**
-     * 相机更新方法，每帧调用
-     * 更新抖动投影矩阵、视锥体和级联阴影映射
-     */
-    onUpdate() {
-        if (this._useJitterProjection) {
-            this.getJitteredProjectionMatrix();
-        }
-        this.frustum.update(this.pvMatrix);
-        this.frustum.updateBoundBox(this.pvMatrixInv);
-        let shadow = Engine3D.setting.shadow;
-        this.enableCSM &&
-            this.csm?.update(this._projectionMatrix, this._pvMatrixInv, this.near, this.far, shadow);
-    }
-    get jitterFrameIndex() {
-        return this._jitterFrameIndex;
-    }
-    get jitterX() {
-        return this._jitterX;
-    }
-    get jitterY() {
-        return this._jitterY;
-    }
-    /**
-     * 启用或禁用投影抖动
-     * 用于实现时间性抗锯齿(TAA)
-     * @param value 是否启用投影抖动
-     */
-    enableJitterProjection(value) {
-        this._jitterFrameIndex = 0;
-        this._useJitterProjection = value;
-        this._haltonSeq ||= new HaltonSeq();
-        this._jitterOffsetList = [];
-        for (let i = 0; i < 32; i++) {
-            let offset = this.generateRandomOffset();
-            this._jitterOffsetList.push(offset);
-        }
-        this._jitterOffsetList.reverse();
-    }
-    /**
-     * 生成随机偏移量用于投影抖动
-     * 使用Halton序列生成低差异序列
-     * @returns 随机偏移向量
-     * @private
-     */
-    generateRandomOffset() {
-        let offset = new Vector2(HaltonSeq.get((this._sampleIndex & 1023) + 1, 2) - 0.5, HaltonSeq.get((this._sampleIndex & 1023) + 1, 3) - 0.5);
-        const k_SampleCount = 32;
-        if (++this._sampleIndex >= k_SampleCount)
-            this._sampleIndex = 0;
-        return offset;
-    }
-    /**
-     * 获取抖动后的投影矩阵
-     * 用于实现时间性抗锯齿(TAA)，通过在每一帧微调投影矩阵来实现
-     * @private
-     */
-    getJitteredProjectionMatrix() {
-        let setting = Engine3D.setting.render.postProcessing.taa;
-        let mat = this._projectionMatrix;
-        let temporalJitterScale = setting.temporalJitterScale;
-        let offsetIndex = this._jitterFrameIndex % setting.jitterSeedCount;
-        let num1 = this._jitterOffsetList[offsetIndex].x * temporalJitterScale;
-        let num2 = this._jitterOffsetList[offsetIndex].y * temporalJitterScale;
-        let jitX = mat.get(0, 2);
-        let jitY = mat.get(1, 2);
-        this._jitterX = num1 / this.viewPort.width;
-        this._jitterY = num2 / this.viewPort.height;
-        jitX += this._jitterX;
-        jitY += this._jitterY;
-        mat.set(0, 2, jitX);
-        mat.set(1, 2, jitY);
-        this._jitterFrameIndex++;
-    }
-    /**
-     * 获取相机在世界空间中的朝向向量
-     * @param target 目标向量，如果为null则创建新向量
-     * @returns 相机的朝向向量（已归一化）
-     */
-    getWorldDirection(target) {
-        target ||= new Vector3();
-        // this.transform.updateWorldMatrix();
-        const e = this.transform._worldMatrix.rawData;
-        return target.set(-e[8], -e[9], -e[10]).normalize();
-    }
-}

package/dist/src/core/CameraType.d.ts

@@ -1,5 +0,0 @@
-export declare enum CameraType {
-    ortho = 0,
-    perspective = 1,
-    shadow = 2
-}

package/dist/src/core/CameraType.js

@@ -1,6 +0,0 @@
-export var CameraType;
-(function (CameraType) {
-    CameraType[CameraType["ortho"] = 0] = "ortho";
-    CameraType[CameraType["perspective"] = 1] = "perspective";
-    CameraType[CameraType["shadow"] = 2] = "shadow";
-})(CameraType || (CameraType = {}));

package/dist/src/core/CubeCamera.d.ts

@@ -1,18 +0,0 @@
-import { Camera3D } from "./Camera3D";
-import { Object3D } from "./entities/Object3D";
-export declare class CubeCamera extends Object3D {
-    up_camera: Camera3D;
-    down_camera: Camera3D;
-    left_camera: Camera3D;
-    right_camera: Camera3D;
-    front_camera: Camera3D;
-    back_camera: Camera3D;
-    private _near;
-    private _far;
-    constructor(near?: number, far?: number, fov?: number, isShadow?: boolean);
-    initCubeCamera(near: number, far: number, fov?: number, isShadow?: boolean): void;
-    set near(value: number);
-    get near(): number;
-    set far(value: number);
-    get far(): number;
-}

package/dist/src/core/CubeCamera.js

@@ -1,67 +0,0 @@
-import { Vector3 } from "../math/Vector3";
-import { CameraUtil } from "../util/CameraUtil";
-import { CameraType } from "./CameraType";
-import { Object3D } from "./entities/Object3D";
-export class CubeCamera extends Object3D {
-    constructor(near = 0.001, far = 10000, fov = 90, isShadow = false) {
-        super();
-        this.initCubeCamera(near, far, fov, isShadow);
-    }
-    initCubeCamera(near, far, fov = 90, isShadow = false) {
-        this.up_camera = CameraUtil.createCamera3DObject(this, "up");
-        this.down_camera = CameraUtil.createCamera3DObject(this, "down");
-        this.left_camera = CameraUtil.createCamera3DObject(this, "left");
-        this.right_camera = CameraUtil.createCamera3DObject(this, "right");
-        this.front_camera = CameraUtil.createCamera3DObject(this, "front");
-        this.back_camera = CameraUtil.createCamera3DObject(this, "back");
-        this.up_camera.isShadowCamera = isShadow;
-        this.down_camera.isShadowCamera = isShadow;
-        this.left_camera.isShadowCamera = isShadow;
-        this.right_camera.isShadowCamera = isShadow;
-        this.front_camera.isShadowCamera = isShadow;
-        this.back_camera.isShadowCamera = isShadow;
-        let aspect = 1.0; // webGPUContext.aspect;
-        this.up_camera.perspective(fov, aspect, near, far);
-        this.up_camera.lookAt(Vector3.ZERO, Vector3.UP, Vector3.DOWN);
-        this.down_camera.perspective(fov, aspect, near, far);
-        this.down_camera.lookAt(Vector3.ZERO, Vector3.DOWN, Vector3.DOWN);
-        this.left_camera.perspective(fov, aspect, near, far);
-        this.left_camera.lookAt(Vector3.ZERO, Vector3.LEFT);
-        this.right_camera.perspective(fov, aspect, near, far);
-        this.right_camera.lookAt(Vector3.ZERO, Vector3.RIGHT);
-        this.front_camera.perspective(fov, aspect, near, far);
-        this.front_camera.lookAt(Vector3.ZERO, Vector3.FORWARD);
-        this.back_camera.perspective(fov, aspect, near, far);
-        this.back_camera.lookAt(Vector3.ZERO, Vector3.BACK);
-        this.up_camera.type = CameraType.shadow;
-        this.down_camera.type = CameraType.shadow;
-        this.left_camera.type = CameraType.shadow;
-        this.right_camera.type = CameraType.shadow;
-        this.front_camera.type = CameraType.shadow;
-        this.back_camera.type = CameraType.shadow;
-    }
-    set near(value) {
-        this._near = value;
-        this.up_camera.near = value;
-        this.down_camera.near = value;
-        this.left_camera.near = value;
-        this.right_camera.near = value;
-        this.front_camera.near = value;
-        this.back_camera.near = value;
-    }
-    get near() {
-        return this._near;
-    }
-    set far(value) {
-        this._far = value;
-        this.up_camera.far = value;
-        this.down_camera.far = value;
-        this.left_camera.far = value;
-        this.right_camera.far = value;
-        this.front_camera.far = value;
-        this.back_camera.far = value;
-    }
-    get far() {
-        return this._far;
-    }
-}

package/dist/src/core/PointShadowCubeCamera.d.ts

@@ -1,13 +0,0 @@
-import { Camera3D } from "./Camera3D";
-import { Object3D } from "./entities/Object3D";
-export declare class PointShadowCubeCamera extends Object3D {
-    up_camera: Camera3D;
-    down_camera: Camera3D;
-    left_camera: Camera3D;
-    right_camera: Camera3D;
-    front_camera: Camera3D;
-    back_camera: Camera3D;
-    set label(v: string);
-    constructor(near?: number, far?: number, fov?: number, isShadow?: boolean);
-    initCubeCamera(near: number, far: number, fov?: number, isShadow?: boolean): void;
-}