@rings-webgpu/core 1.0.6 → 1.0.7

package/dist/types/gfx/renderJob/passRenderer/preDepth/ZCullingCompute.d.ts

@@ -0,0 +1,12 @@
+import { Scene3D } from "../../../../core/Scene3D";
+import { ComputeGPUBuffer } from "../../../graphics/webGpu/core/buffer/ComputeGPUBuffer";
+import { Texture } from "../../../graphics/webGpu/core/texture/Texture";
+import { ComputeShader } from "../../../graphics/webGpu/shader/ComputeShader";
+import { OcclusionSystem } from "../../occlusion/OcclusionSystem";
+export declare class ZCullingCompute {
+    computeShader: ComputeShader;
+    visibleBuffer: ComputeGPUBuffer;
+    texture: Texture;
+    constructor();
+    compute(scene: Scene3D, occlusionSystem: OcclusionSystem): void;
+}

package/dist/types/gfx/renderJob/passRenderer/shadow/PointLightShadowRenderer.d.ts

@@ -0,0 +1,32 @@
+import { Camera3D } from "../../../../core/Camera3D";
+import { CubeCamera } from "../../../../core/CubeCamera";
+import { VirtualTexture } from "../../../../textures/VirtualTexture";
+import { OcclusionSystem } from "../../occlusion/OcclusionSystem";
+import { RendererBase } from "../RendererBase";
+import { RenderNode } from "../../../../components/renderer/RenderNode";
+import { View3D } from "../../../../core/View3D";
+import { DepthCubeArrayTexture } from "../../../../textures/DepthCubeArrayTexture";
+import { ILight } from "../../../../components/lights/ILight";
+import { RenderContext } from "../RenderContext";
+import { ClusterLightingBuffer } from "../cluster/ClusterLightingBuffer";
+type CubeShadowMapInfo = {
+    cubeCamera: CubeCamera;
+    depthTexture: VirtualTexture[];
+    renderContext: RenderContext[];
+};
+export declare class PointLightShadowRenderer extends RendererBase {
+    shadowPassCount: number;
+    private _forceUpdate;
+    private _shadowCameraDic;
+    shadowCamera: Camera3D;
+    cubeArrayTexture: DepthCubeArrayTexture;
+    colorTexture: VirtualTexture;
+    shadowSize: number;
+    constructor();
+    getShadowCamera(view: View3D, lightBase: ILight): CubeShadowMapInfo;
+    render(view: View3D, occlusionSystem: OcclusionSystem): void;
+    private renderSceneOnce;
+    protected drawShadowRenderNodes(view: View3D, shadowCamera: Camera3D, renderContext: RenderContext, nodes: RenderNode[], occlusionSystem: OcclusionSystem): void;
+    drawNodes(view: View3D, camera: Camera3D, renderContext: RenderContext, nodes: RenderNode[], occlusionSystem: OcclusionSystem, clusterLightingBuffer: ClusterLightingBuffer): void;
+}
+export {};

package/dist/types/gfx/renderJob/passRenderer/shadow/ShadowMapPassRenderer.d.ts

@@ -0,0 +1,27 @@
+import { RenderNode } from "../../../../components/renderer/RenderNode";
+import { Camera3D } from "../../../../core/Camera3D";
+import { View3D } from "../../../../core/View3D";
+import { Depth2DTextureArray } from "../../../../textures/Depth2DTextureArray";
+import { OcclusionSystem } from "../../occlusion/OcclusionSystem";
+import { RendererPassState } from "../state/RendererPassState";
+import { RendererBase } from "../RendererBase";
+import { ClusterLightingBuffer } from "../cluster/ClusterLightingBuffer";
+export declare class ShadowMapPassRenderer extends RendererBase {
+    shadowPassCount: number;
+    depth2DArrayTexture: Depth2DTextureArray;
+    rendererPassStates: RendererPassState[];
+    private _forceUpdate;
+    constructor();
+    setShadowMap(size: number, cascades: number): void;
+    render(view: View3D, occlusionSystem: OcclusionSystem): void;
+    private copyDepthTexture;
+    private _shadowPos;
+    private _shadowCameraTarget;
+    private poseShadowCamera;
+    compute(): void;
+    private renderShadow;
+    protected renderShadowBundleOp(view: View3D, shadowCamera: Camera3D, state: RendererPassState): any[];
+    protected renderShadowBundleTr(view: View3D, shadowCamera: Camera3D, state: RendererPassState): any[];
+    protected recordShadowRenderBundleNode(view: View3D, shadowCamera: Camera3D, encoder: any, nodes: RenderNode[], clusterLightingBuffer?: ClusterLightingBuffer): void;
+    protected drawShadowRenderNodes(view: View3D, shadowCamera: Camera3D, encoder: GPURenderPassEncoder, nodes: RenderNode[], clusterLightingBuffer?: ClusterLightingBuffer): void;
+}

package/dist/types/gfx/renderJob/passRenderer/state/PassType.d.ts

@@ -0,0 +1,13 @@
+export declare enum PassType {
+    COLOR = 1,
+    REFLECTION = 2,
+    POSITION = 4,
+    GRAPHIC = 8,
+    GI = 16,
+    Cluster = 32,
+    SHADOW = 64,
+    POINT_SHADOW = 128,
+    POST = 256,
+    DEPTH = 512,
+    UI = 1024
+}

package/dist/types/gfx/renderJob/passRenderer/state/RendererMask.d.ts

@@ -0,0 +1,18 @@
+export declare enum RendererMask {
+    Default = 1,
+    IgnoreDepthPass = 2,
+    Sky = 6,
+    Particle = 10,
+    SkinnedMesh = 16,
+    MorphTarget = 32,
+    Terrain = 64,
+    UI = 128,
+    Reflection = 256,
+    ReflectionDebug = 512,
+    Graphic3D = 1024
+}
+export declare class RendererMaskUtil {
+    static addMask(src: RendererMask, tag: RendererMask): RendererMask;
+    static removeMask(src: RendererMask, tag: RendererMask): RendererMask;
+    static hasMask(m1: RendererMask, m2: RendererMask): boolean;
+}

package/dist/types/gfx/renderJob/passRenderer/state/RendererPassState.d.ts

@@ -0,0 +1,27 @@
+import { Camera3D } from "../../../../core/Camera3D";
+import { RenderTexture } from "../../../../textures/RenderTexture";
+import { Texture } from "../../../graphics/webGpu/core/texture/Texture";
+import { RTDescriptor } from "../../../graphics/webGpu/descriptor/RTDescriptor";
+import { RTFrame } from "../../frame/RTFrame";
+export declare class RendererPassState {
+    label: string;
+    customSize: boolean;
+    zPreTexture: RenderTexture;
+    depthTexture: RenderTexture;
+    renderTargetTextures: GPUColorTargetState[];
+    outColor: number;
+    renderTargets: Texture[];
+    rtTextureDescriptors: RTDescriptor[];
+    irradianceBuffer: Texture[];
+    multisample: number;
+    multiTexture: GPUTexture;
+    depthViewIndex: number;
+    depthCleanValue: number;
+    isOutTarget: boolean;
+    camera3D: Camera3D;
+    rtFrame: RTFrame;
+    renderPassDescriptor: GPURenderPassDescriptor;
+    renderBundleEncoderDescriptor: GPURenderBundleEncoderDescriptor;
+    depthLoadOp: GPULoadOp;
+    getLastRenderTexture(): Texture;
+}

package/dist/types/gfx/renderJob/post/BloomPost.d.ts

@@ -0,0 +1,45 @@
+import { UniformGPUBuffer } from "../../graphics/webGpu/core/buffer/UniformGPUBuffer";
+import { ComputeShader } from "../../graphics/webGpu/shader/ComputeShader";
+import { RendererPassState } from "../passRenderer/state/RendererPassState";
+import { PostBase } from "./PostBase";
+import { View3D } from "../../../core/View3D";
+import { RTFrame } from "../frame/RTFrame";
+import { VirtualTexture } from "../../../textures/VirtualTexture";
+export declare class BloomPost extends PostBase {
+    RT_BloomUp: VirtualTexture[];
+    RT_BloomDown: VirtualTexture[];
+    RT_threshold: VirtualTexture;
+    rendererPassState: RendererPassState;
+    thresholdCompute: ComputeShader;
+    downSampleComputes: ComputeShader[];
+    upSampleComputes: ComputeShader[];
+    postCompute: ComputeShader;
+    bloomSetting: UniformGPUBuffer;
+    rtFrame: RTFrame;
+    constructor();
+    onAttach(view: View3D): void;
+    onDetach(view: View3D): void;
+    private createGUI;
+    private removeGUI;
+    get downSampleBlurSize(): number;
+    set downSampleBlurSize(value: number);
+    get downSampleBlurSigma(): number;
+    set downSampleBlurSigma(value: number);
+    get upSampleBlurSize(): number;
+    set upSampleBlurSize(value: number);
+    get upSampleBlurSigma(): number;
+    set upSampleBlurSigma(value: number);
+    get luminanceThreshole(): number;
+    set luminanceThreshole(value: number);
+    get bloomIntensity(): number;
+    set bloomIntensity(value: number);
+    get hdr(): number;
+    set hdr(value: number);
+    private createThreshouldCompute;
+    private createDownSampleComputes;
+    private createUpSampleComputes;
+    private createPostCompute;
+    private createResource;
+    render(view: View3D, command: GPUCommandEncoder): void;
+    onResize(): void;
+}

package/dist/types/gfx/renderJob/post/DepthOfFieldPost.d.ts

@@ -0,0 +1,56 @@
+import { VirtualTexture } from "../../../textures/VirtualTexture";
+import { StorageGPUBuffer } from "../../graphics/webGpu/core/buffer/StorageGPUBuffer";
+import { ComputeShader } from "../../graphics/webGpu/shader/ComputeShader";
+import { RendererPassState } from "../passRenderer/state/RendererPassState";
+import { PostBase } from "./PostBase";
+import { View3D } from "../../../core/View3D";
+import { RTFrame } from "../frame/RTFrame";
+export declare class DepthOfFieldPost extends PostBase {
+    /**
+     * @internal
+     */
+    blurTexture1: VirtualTexture;
+    /**
+     * @internal
+     */
+    blurTexture2: VirtualTexture;
+    /**
+     * @internal
+     */
+    rendererPassState: RendererPassState;
+    /**
+     * @internal
+     */
+    blurComputes: ComputeShader[];
+    /**
+     * @internal
+     */
+    blurSettings: StorageGPUBuffer[];
+    /**
+     * @internal
+     */
+    outTexture: VirtualTexture;
+    rtFrame: RTFrame;
+    constructor();
+    /**
+     * @internal
+     */
+    onAttach(view: View3D): void;
+    /**
+     * @internal
+     */
+    onDetach(view: View3D): void;
+    get pixelOffset(): number;
+    set pixelOffset(value: number);
+    get near(): number;
+    set near(value: number);
+    get far(): number;
+    set far(value: number);
+    private createBlurCompute;
+    private createResource;
+    /**
+     * @internal
+     */
+    render(view: View3D, command: GPUCommandEncoder): void;
+    onResize(): void;
+}

package/dist/types/gfx/renderJob/post/FXAAPost.d.ts

@@ -0,0 +1,18 @@
+import { PostBase } from "./PostBase";
+import { View3D } from "../../../core/View3D";
+import { ViewQuad } from "../../../core/ViewQuad";
+import { RenderTexture } from "../../../textures/RenderTexture";
+export declare class FXAAPost extends PostBase {
+    postQuad: ViewQuad;
+    renderTexture: RenderTexture;
+    constructor();
+    onResize(): void;
+    /**
+     * @internal
+     */
+    onAttach(view: View3D): void;
+    /**
+     * @internal
+     */
+    onDetach(view: View3D): void;
+}

package/dist/types/gfx/renderJob/post/GBufferPost.d.ts

@@ -0,0 +1,35 @@
+import { VirtualTexture } from "../../../textures/VirtualTexture";
+import { UniformGPUBuffer } from "../../graphics/webGpu/core/buffer/UniformGPUBuffer";
+import { ComputeShader } from "../../graphics/webGpu/shader/ComputeShader";
+import { RendererPassState } from "../passRenderer/state/RendererPassState";
+import { PostBase } from "./PostBase";
+import { View3D } from "../../../core/View3D";
+import { RTFrame } from "../frame/RTFrame";
+import { RenderTexture } from "../../../textures/RenderTexture";
+export declare class GBufferPost extends PostBase {
+    outTexture: VirtualTexture;
+    rendererPassState: RendererPassState;
+    rtFrame: RTFrame;
+    view: View3D;
+    gBufferTexture: RenderTexture;
+    testCompute: ComputeShader;
+    private _state;
+    private _state1;
+    private _state2;
+    uniformBuffer: UniformGPUBuffer;
+    currentRenderTexture: RenderTexture;
+    constructor();
+    onAttach(view: View3D): void;
+    onDetach(view: View3D): void;
+    set state(v: number);
+    get state(): number;
+    set size1(v: number);
+    get size1(): number;
+    set size2(v: number);
+    get size2(): number;
+    private createResource;
+    private createCompute;
+    render(view: View3D, command: GPUCommandEncoder): void;
+    compute(view: View3D): void;
+    onResize(): void;
+}

package/dist/types/gfx/renderJob/post/GTAOPost.d.ts

@@ -0,0 +1,67 @@
+import { VirtualTexture } from "../../../textures/VirtualTexture";
+import { StorageGPUBuffer } from "../../graphics/webGpu/core/buffer/StorageGPUBuffer";
+import { ComputeShader } from "../../graphics/webGpu/shader/ComputeShader";
+import { RendererPassState } from "../passRenderer/state/RendererPassState";
+import { PostBase } from "./PostBase";
+import { View3D } from "../../../core/View3D";
+import { RTFrame } from "../frame/RTFrame";
+export declare class GTAOPost extends PostBase {
+    /**
+     * @internal
+     */
+    gtaoTexture: VirtualTexture;
+    /**
+     * @internal
+     */
+    rendererPassState: RendererPassState;
+    /**
+     * @internal
+     */
+    gtaoCompute: ComputeShader;
+    /**
+     * @internal
+     */
+    gtaoSetting: StorageGPUBuffer;
+    /**
+     * @internal
+     */
+    aoBuffer: StorageGPUBuffer;
+    /**
+     * @internal
+     */
+    directionsBuffer: StorageGPUBuffer;
+    /**
+     * @internal
+     */
+    directionsArray: Float32Array;
+    rtFrame: RTFrame;
+    constructor();
+    /**
+     * @internal
+     */
+    onAttach(view: View3D): void;
+    /**
+     * @internal
+     */ Render: any;
+    onDetach(view: View3D): void;
+    get maxDistance(): number;
+    set maxDistance(value: number);
+    get maxPixel(): number;
+    set maxPixel(value: number);
+    get darkFactor(): number;
+    set darkFactor(value: number);
+    get rayMarchSegment(): number;
+    set rayMarchSegment(value: number);
+    get multiBounce(): boolean;
+    set multiBounce(value: boolean);
+    get blendColor(): boolean;
+    set blendColor(value: boolean);
+    get usePosFloat32(): boolean;
+    set usePosFloat32(value: boolean);
+    private createCompute;
+    private createResource;
+    private randomCount;
+    private randomDirection;
+    render(view: View3D, command: GPUCommandEncoder): void;
+    onResize(): void;
+}

package/dist/types/gfx/renderJob/post/GlobalFog.d.ts

@@ -0,0 +1,69 @@
+import { Color } from "../../../math/Color";
+import { VirtualTexture } from "../../../textures/VirtualTexture";
+import { PostBase } from "./PostBase";
+import { View3D } from "../../../core/View3D";
+import { RTFrame } from "../frame/RTFrame";
+export declare class GlobalFog extends PostBase {
+    /**
+     * @internal
+     */
+    private fogSetting;
+    fogOpTexture: VirtualTexture;
+    private fogCompute;
+    private fogUniform;
+    private rendererPassState;
+    constructor();
+    private createCompute;
+    private uploadSetting;
+    rtFrame: RTFrame;
+    private createResource;
+    /**
+     * @internal
+     */
+    onAttach(view: View3D): void;
+    /**
+     * @internal
+     */
+    onDetach(view: View3D): void;
+    set fogType(v: number);
+    get fogType(): number;
+    set fogHeightScale(v: number);
+    get fogHeightScale(): number;
+    set start(v: number);
+    get start(): number;
+    set end(v: number);
+    get end(): number;
+    set ins(v: number);
+    get ins(): number;
+    set density(v: number);
+    get density(): number;
+    set skyRoughness(v: number);
+    get skyRoughness(): number;
+    set skyFactor(v: number);
+    get skyFactor(): number;
+    set overrideSkyFactor(v: number);
+    get overrideSkyFactor(): number;
+    /**
+     * @internal
+     */
+    get fogColor(): Color;
+    /**
+     * @internal
+     */
+    set fogColor(value: Color);
+    set falloff(v: number);
+    get falloff(): number;
+    set rayLength(v: number);
+    get rayLength(): number;
+    set scatteringExponent(v: number);
+    get scatteringExponent(): number;
+    set dirHeightLine(v: number);
+    get dirHeightLine(): number;
+    private _lastSkyTexture;
+    private getSkyTexture;
+    /**
+     * @internal
+     */
+    render(view: View3D, command: GPUCommandEncoder): void;
+    onResize(): void;
+}

package/dist/types/gfx/renderJob/post/GodRayPost.d.ts

@@ -0,0 +1,56 @@
+import { VirtualTexture } from "../../../textures/VirtualTexture";
+import { StorageGPUBuffer } from "../../graphics/webGpu/core/buffer/StorageGPUBuffer";
+import { ComputeShader } from "../../graphics/webGpu/shader/ComputeShader";
+import { RendererPassState } from "../passRenderer/state/RendererPassState";
+import { PostBase } from "./PostBase";
+import { View3D } from "../../../core/View3D";
+import { RTFrame } from "../frame/RTFrame";
+export declare class GodRayPost extends PostBase {
+    /**
+     * @internal
+     */
+    godRayTexture: VirtualTexture;
+    /**
+     * @internal
+     */
+    rendererPassState: RendererPassState;
+    /**
+     * @internal
+     */
+    godRayCompute: ComputeShader;
+    /**
+     * @internal
+     */
+    historyGodRayData: StorageGPUBuffer;
+    /**
+     * @internal
+     */
+    godRaySetting: StorageGPUBuffer;
+    rtFrame: RTFrame;
+    constructor();
+    /**
+     * @internal
+     */
+    onAttach(view: View3D): void;
+    /**
+     * @internal
+     */ Render: any;
+    onDetach(view: View3D): void;
+    get blendColor(): boolean;
+    set blendColor(value: boolean);
+    get rayMarchCount(): number;
+    set rayMarchCount(value: number);
+    get scatteringExponent(): number;
+    set scatteringExponent(value: number);
+    get intensity(): number;
+    set intensity(value: number);
+    private createGUI;
+    private removeGUI;
+    private createCompute;
+    private createResource;
+    onResize(): void;
+    /**
+     * @internal
+     */
+    render(view: View3D, command: GPUCommandEncoder): void;
+}

package/dist/types/gfx/renderJob/post/OutlinePost.d.ts

@@ -0,0 +1,93 @@
+import { PostBase } from "./PostBase";
+import { View3D } from "../../../core/View3D";
+export declare class OutlinePost extends PostBase {
+    /**
+     * @internal
+     */
+    private outlineTex;
+    /**
+     * @internal
+     */
+    private lowTex;
+    /**
+     * @internal
+     */
+    private rendererPassState;
+    /**
+     * @internal
+     */
+    private calcWeightCompute;
+    /**
+     * @internal
+     */
+    private outlineCompute;
+    /**
+     * @internal
+     */
+    private blendCompute;
+    /**
+     * @internal
+     */
+    private outlineSetting;
+    /**
+     * @internal
+     */
+    private slotsBuffer;
+    /**
+     * @internal
+     */
+    private slotsArray;
+    /**
+     * @internal
+     */
+    private entitiesArray;
+    /**
+     * @internal
+     */
+    private entitiesBuffer;
+    /**
+     * @internal
+     */
+    private weightBuffer;
+    /**
+     * @internal
+     */
+    private lowTexSize;
+    /**
+     * @internal
+     */
+    private oldOutlineColor;
+    /**
+     * @internal
+     */
+    private rtFrame;
+    private view;
+    constructor();
+    /**
+     * @internal
+     */
+    onAttach(view: View3D): void;
+    /**
+     * @internal
+     */
+    onDetach(view: View3D): void;
+    set outlinePixel(value: number);
+    get outlinePixel(): number;
+    set fadeOutlinePixel(value: number);
+    get fadeOutlinePixel(): number;
+    set strength(value: number);
+    get strength(): number;
+    set useAddMode(value: boolean);
+    get useAddMode(): boolean;
+    private createGUI;
+    private createCompute;
+    private createResource;
+    private fetchData;
+    private fetchOutlineData;
+    private computeList;
+    /**
+     * @internal
+     */
+    render(view: View3D, command: GPUCommandEncoder): void;
+    onResize(): void;
+}

package/dist/types/gfx/renderJob/post/PostBase.d.ts

@@ -0,0 +1,35 @@
+import { ViewQuad } from "../../../core/ViewQuad";
+import { VirtualTexture } from "../../../textures/VirtualTexture";
+import { Texture } from "../../graphics/webGpu/core/texture/Texture";
+import { ComputeShader } from "../../../gfx/graphics/webGpu/shader/ComputeShader";
+import { PostRenderer } from "../passRenderer/post/PostRenderer";
+import { View3D } from "../../../core/View3D";
+export declare class PostBase {
+    enable: boolean;
+    postRenderer: PostRenderer;
+    protected rtViewQuad: Map<string, ViewQuad>;
+    protected virtualTexture: Map<string, VirtualTexture>;
+    constructor();
+    protected createRTTexture(name: string, rtWidth: number, rtHeight: number, format: GPUTextureFormat, useMipmap?: boolean, sampleCount?: number): import("../../..").RenderTexture;
+    protected createViewQuad(name: string, shaderName: string, outRtTexture: VirtualTexture, msaa?: number): ViewQuad;
+    protected getOutTexture(): Texture;
+    protected autoSetColorTexture(name: string, compute: ComputeShader): void;
+    /**
+     * @internal
+     */
+    compute(view: View3D): void;
+    /**
+     * @internal
+     */
+    onAttach(view: View3D): void;
+    /**
+     * @internal
+     */
+    onDetach(view: View3D): void;
+    onResize(): void;
+    /**
+     * @internal
+     */
+    render(view: View3D, command: GPUCommandEncoder): void;
+    destroy(force?: boolean): void;
+}

package/dist/types/gfx/renderJob/post/SSGIPost.d.ts

@@ -0,0 +1,67 @@
+import { VirtualTexture } from "../../../textures/VirtualTexture";
+import { StorageGPUBuffer } from "../../graphics/webGpu/core/buffer/StorageGPUBuffer";
+import { ComputeShader } from "../../graphics/webGpu/shader/ComputeShader";
+import { RendererPassState } from "../passRenderer/state/RendererPassState";
+import { PostBase } from "./PostBase";
+import { View3D } from "../../../core/View3D";
+import { RTFrame } from "../frame/RTFrame";
+import { TextureScaleCompute } from "../../generate/convert/TextureScaleCompute";
+import { RenderTexture } from "../../../textures/RenderTexture";
+import { Vector3 } from "../../..";
+export declare class SSGIPost extends PostBase {
+    /**
+     * @internal
+     */
+    outTexture: VirtualTexture;
+    newTexture: VirtualTexture;
+    oldTexture: VirtualTexture;
+    combineTexture: VirtualTexture;
+    /**
+     * @internal
+     */
+    rendererPassState: RendererPassState;
+    /**
+     * @internal
+     */
+    ssgiCompute: ComputeShader;
+    delayCompute: ComputeShader;
+    combineCompute: ComputeShader;
+    rtFrame: RTFrame;
+    textureScaleSmallCompute: TextureScaleCompute;
+    textureScaleBigCompute: TextureScaleCompute;
+    view: View3D;
+    colorTexture: RenderTexture;
+    posTexture: RenderTexture;
+    normalTexture: RenderTexture;
+    gBufferTexture: RenderTexture;
+    lastPosTexture: RenderTexture;
+    downSampleCofe: number;
+    debugChanal: string;
+    updateBuffer: StorageGPUBuffer;
+    constructor();
+    /**
+     * @internal
+     */
+    onAttach(view: View3D): void;
+    onCameraChange(oldPos: Vector3, newPos: Vector3): void;
+    /**
+     * @internal
+     */ Render: any;
+    onDetach(view: View3D): void;
+    set ins(v: number);
+    get ins(): number;
+    set delay(v: number);
+    get delay(): number;
+    set colorIns(v: number);
+    get colorIns(): number;
+    set frameCount(v: number);
+    get frameCount(): number;
+    set d1(v: number);
+    get d1(): number;
+    private createResource;
+    private createCompute;
+    render(view: View3D, command: GPUCommandEncoder): void;
+    private frame;
+    compute(view: View3D): void;
+    onResize(): void;
+}