@zephyr3d/scene 0.9.2 → 0.9.3

package/dist/src/utility/serialization/scene/camera.js

@@ -0,0 +1,790 @@
+import { Camera } from '../../../camera/camera.js';
+import { OrthoCamera } from '../../../camera/orthocamera.js';
+import { PerspectiveCamera } from '../../../camera/perspectivecamera.js';
+import '@zephyr3d/base';
+import { SceneNode } from '../../../scene/scene_node.js';
+import '../../../scene/raycast_visitor.js';
+import '../../../values.js';
+import '@zephyr3d/device';
+import '../../../material/shader/helper.js';
+import '../../../material/lambert.js';
+import '../../../material/blinn.js';
+import '../../../material/unlit.js';
+import '../../../material/particle.js';
+import '../../../material/meshmaterial.js';
+import '../../../material/grassmaterial.js';
+import '../../../material/terrainmaterial.js';
+import '../../../material/terrain-cm.js';
+import '../../../material/pbrmr.js';
+import '../../../material/pbrsg.js';
+import '../../../render/renderer.js';
+import '../../../render/sky.js';
+import '../../../render/clipmap.js';
+import { TAA_DEBUG_NONE, TAA_DEBUG_CURRENT_COLOR, TAA_DEBUG_HISTORY_COLOR, TAA_DEBUG_VELOCITY, TAA_DEBUG_EDGE, TAA_DEBUG_ALAPH, TAA_DEBUG_MOTION_VECTOR, TAA_DEBUG_STRENGTH } from '../../../shaders/temporal.js';
+import '../../../shaders/atmosphere.js';
+import '../../../shadow/shadowmapper.js';
+import '../../../scene/mesh.js';
+import '../../../scene/water.js';
+import '../../../scene/particlesys.js';
+import '../../../scene/batchgroup.js';
+import '../../../scene/terrain/patch.js';
+import '../../../scene/terrain/grass.js';
+import '../../../scene/terrain-cm/terrain-cm.js';
+import '../../../scene/terrain-cm/grass.js';
+
+/** @internal */ function getCameraClass() {
+    return {
+        ctor: Camera,
+        name: 'Camera',
+        parent: SceneNode,
+        createFunc (ctx) {
+            const node = new Camera(ctx.scene);
+            if (ctx instanceof SceneNode) {
+                node.parent = ctx;
+            }
+            return {
+                obj: node
+            };
+        },
+        getProps () {
+            return [
+                {
+                    name: 'HiZ',
+                    type: 'bool',
+                    default: false,
+                    get (value) {
+                        value.bool[0] = this.HiZ;
+                    },
+                    set (value) {
+                        this.HiZ = value.bool[0];
+                    }
+                },
+                {
+                    name: 'ToneMapEnabled',
+                    type: 'bool',
+                    phase: 0,
+                    default: true,
+                    options: {
+                        label: 'Enabled',
+                        group: 'PostProcessing/ToneMap'
+                    },
+                    get (value) {
+                        value.bool[0] = this.toneMap;
+                    },
+                    set (value) {
+                        this.toneMap = value.bool[0];
+                    }
+                },
+                {
+                    name: 'ToneMapExposure',
+                    type: 'float',
+                    options: {
+                        minValue: 0,
+                        maxValue: 8,
+                        label: 'Exposure',
+                        group: 'PostProcessing/ToneMap'
+                    },
+                    phase: 0,
+                    default: 1,
+                    get (value) {
+                        value.num[0] = this.toneMapExposure;
+                    },
+                    set (value) {
+                        this.toneMapExposure = value.num[0];
+                    }
+                },
+                {
+                    name: 'BloomEnabled',
+                    type: 'bool',
+                    phase: 0,
+                    default: true,
+                    options: {
+                        label: 'Enabled',
+                        group: 'PostProcessing/Bloom'
+                    },
+                    get (value) {
+                        value.bool[0] = this.bloom;
+                    },
+                    set (value) {
+                        this.bloom = value.bool[0];
+                    }
+                },
+                {
+                    name: 'BloomMaxDownsampleLevels',
+                    type: 'int',
+                    options: {
+                        minValue: 0,
+                        maxValue: 8,
+                        label: 'MaxDownsampleLevels',
+                        group: 'PostProcessing/Bloom'
+                    },
+                    phase: 0,
+                    default: 4,
+                    get (value) {
+                        value.num[0] = this.bloomMaxDownsampleLevels;
+                    },
+                    set (value) {
+                        this.bloomMaxDownsampleLevels = value.num[0];
+                    }
+                },
+                {
+                    name: 'BloomDownsampleLimit',
+                    type: 'int',
+                    options: {
+                        minValue: 2,
+                        maxValue: 64,
+                        label: 'DownsampleLimit',
+                        group: 'PostProcessing/Bloom'
+                    },
+                    phase: 0,
+                    default: 32,
+                    get (value) {
+                        value.num[0] = this.bloomDownsampleLimit;
+                    },
+                    set (value) {
+                        this.bloomDownsampleLimit = value.num[0];
+                    }
+                },
+                {
+                    name: 'BloomThreshold',
+                    type: 'float',
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1,
+                        label: 'Threshold',
+                        group: 'PostProcessing/Bloom'
+                    },
+                    phase: 0,
+                    default: 0.8,
+                    get (value) {
+                        value.num[0] = this.bloomThreshold;
+                    },
+                    set (value) {
+                        this.bloomThreshold = value.num[0];
+                    }
+                },
+                {
+                    name: 'BloomThresholdKnee',
+                    type: 'float',
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1,
+                        label: 'ThresholdKnee',
+                        group: 'PostProcessing/Bloom'
+                    },
+                    phase: 0,
+                    default: 0,
+                    get (value) {
+                        value.num[0] = this.bloomThresholdKnee;
+                    },
+                    set (value) {
+                        this.bloomThresholdKnee = value.num[0];
+                    }
+                },
+                {
+                    name: 'BloomIntensity',
+                    type: 'float',
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 8,
+                        label: 'Intensity',
+                        group: 'PostProcessing/Bloom'
+                    },
+                    phase: 0,
+                    default: 1,
+                    get (value) {
+                        value.num[0] = this.bloomIntensity;
+                    },
+                    set (value) {
+                        this.bloomIntensity = value.num[0];
+                    }
+                },
+                {
+                    name: 'FXAAEnabled',
+                    type: 'bool',
+                    phase: 0,
+                    default: true,
+                    options: {
+                        label: 'Enabled',
+                        group: 'PostProcessing/FXAA'
+                    },
+                    get (value) {
+                        value.bool[0] = this.FXAA;
+                    },
+                    set (value) {
+                        this.FXAA = value.bool[0];
+                    }
+                },
+                {
+                    name: 'TAAEnabled',
+                    type: 'bool',
+                    phase: 0,
+                    default: false,
+                    options: {
+                        label: 'Enabled',
+                        group: 'PostProcessing/TAA'
+                    },
+                    get (value) {
+                        value.bool[0] = this.TAA;
+                    },
+                    set (value) {
+                        this.TAA = value.bool[0];
+                    }
+                },
+                {
+                    name: 'TAADebug',
+                    type: 'int',
+                    phase: 1,
+                    options: {
+                        label: 'Debug',
+                        group: 'PostProcessing/TAA',
+                        enum: {
+                            labels: [
+                                'None',
+                                'Current Color',
+                                'History Color',
+                                'Velocity',
+                                'Edge',
+                                'Alpha',
+                                'Motion Vector',
+                                'Strength'
+                            ],
+                            values: [
+                                TAA_DEBUG_NONE,
+                                TAA_DEBUG_CURRENT_COLOR,
+                                TAA_DEBUG_HISTORY_COLOR,
+                                TAA_DEBUG_VELOCITY,
+                                TAA_DEBUG_EDGE,
+                                TAA_DEBUG_ALAPH,
+                                TAA_DEBUG_MOTION_VECTOR,
+                                TAA_DEBUG_STRENGTH
+                            ]
+                        }
+                    },
+                    default: TAA_DEBUG_NONE,
+                    get (value) {
+                        value.num[0] = this.TAADebug;
+                    },
+                    set (value) {
+                        this.TAADebug = value.num[0];
+                    },
+                    isValid () {
+                        return !!this.TAA;
+                    }
+                },
+                {
+                    name: 'MotionBlurEnabled',
+                    type: 'bool',
+                    phase: 0,
+                    default: false,
+                    options: {
+                        label: 'Enabled',
+                        group: 'PostProcessing/MotionBlur'
+                    },
+                    get (value) {
+                        value.bool[0] = this.motionBlur;
+                    },
+                    set (value) {
+                        this.motionBlur = value.bool[0];
+                    }
+                },
+                {
+                    name: 'MotionBlurStrength',
+                    type: 'float',
+                    phase: 1,
+                    default: 1,
+                    options: {
+                        label: 'Strength',
+                        group: 'PostProcessing/MotionBlur',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 10
+                    },
+                    get (value) {
+                        value.num[0] = this.motionBlurStrength;
+                    },
+                    set (value) {
+                        this.motionBlurStrength = value.num[0];
+                    },
+                    isValid () {
+                        return this.motionBlur;
+                    }
+                },
+                {
+                    name: 'SSREnabled',
+                    type: 'bool',
+                    phase: 0,
+                    default: false,
+                    options: {
+                        label: 'Enabled',
+                        group: 'PostProcessing/SSR'
+                    },
+                    get (value) {
+                        value.bool[0] = this.SSR;
+                    },
+                    set (value) {
+                        this.SSR = value.bool[0];
+                    }
+                },
+                {
+                    name: 'SSRMaxRoughness',
+                    type: 'float',
+                    phase: 1,
+                    default: 0.8,
+                    options: {
+                        label: 'RoughnessThreshold',
+                        group: 'PostProcessing/SSR',
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.ssrMaxRoughness;
+                    },
+                    set (value) {
+                        this.ssrMaxRoughness = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSR;
+                    }
+                },
+                {
+                    name: 'SSRRoughnessFactor',
+                    type: 'float',
+                    phase: 1,
+                    default: 1.0,
+                    options: {
+                        label: 'RoughnessFactor',
+                        group: 'PostProcessing/SSR',
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.ssrRoughnessFactor;
+                    },
+                    set (value) {
+                        this.ssrRoughnessFactor = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSR;
+                    }
+                },
+                {
+                    name: 'SSRStride',
+                    type: 'int',
+                    phase: 1,
+                    default: 2,
+                    options: {
+                        label: 'Stride',
+                        group: 'PostProcessing/SSR',
+                        minValue: 1,
+                        maxValue: 32
+                    },
+                    get (value) {
+                        value.num[0] = this.ssrStride;
+                    },
+                    set (value) {
+                        this.ssrStride = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSR && !this.HiZ;
+                    }
+                },
+                {
+                    name: 'SSRMaxDistance',
+                    type: 'float',
+                    phase: 1,
+                    default: 100,
+                    options: {
+                        label: 'MaxDistance',
+                        group: 'PostProcessing/SSR',
+                        minValue: 0,
+                        maxValue: 9999
+                    },
+                    get (value) {
+                        value.num[0] = this.ssrMaxDistance;
+                    },
+                    set (value) {
+                        this.ssrMaxDistance = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSR;
+                    }
+                },
+                {
+                    name: 'SSRMaxSteps',
+                    type: 'int',
+                    phase: 1,
+                    default: 120,
+                    options: {
+                        label: 'MaxSteps',
+                        group: 'PostProcessing/SSR',
+                        minValue: 1,
+                        maxValue: 2000
+                    },
+                    get (value) {
+                        value.num[0] = this.ssrIterations;
+                    },
+                    set (value) {
+                        this.ssrIterations = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSR;
+                    }
+                },
+                {
+                    name: 'SSRThickness',
+                    type: 'float',
+                    phase: 1,
+                    default: 0.5,
+                    options: {
+                        label: 'Thickness',
+                        group: 'PostProcessing/SSR',
+                        minValue: 0,
+                        maxValue: 8
+                    },
+                    get (value) {
+                        value.num[0] = this.ssrThickness;
+                    },
+                    set (value) {
+                        this.ssrThickness = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSR;
+                    }
+                },
+                {
+                    name: 'SSRBlurScale',
+                    phase: 1,
+                    type: 'float',
+                    default: 0.05,
+                    options: {
+                        label: 'BlurScale',
+                        group: 'PostProcessing/SSR',
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.ssrBlurScale;
+                    },
+                    set (value) {
+                        this.ssrBlurScale = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSR;
+                    }
+                },
+                {
+                    name: 'SSRBlurDepthCutoff',
+                    phase: 1,
+                    type: 'float',
+                    default: 2,
+                    options: {
+                        label: 'BlurDepthCutoff',
+                        group: 'PostProcessing/SSR',
+                        minValue: 0,
+                        maxValue: 8
+                    },
+                    get (value) {
+                        value.num[0] = this.ssrBlurDepthCutoff;
+                    },
+                    set (value) {
+                        this.ssrBlurDepthCutoff = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSR;
+                    }
+                },
+                {
+                    name: 'SSRBlurKernelSize',
+                    type: 'int',
+                    phase: 1,
+                    default: 17,
+                    options: {
+                        label: 'BlurKernelSize',
+                        group: 'PostProcessing/SSR',
+                        minValue: 1,
+                        maxValue: 65
+                    },
+                    get (value) {
+                        value.num[0] = this.ssrBlurKernelSize;
+                    },
+                    set (value) {
+                        this.ssrBlurKernelSize = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSR;
+                    }
+                },
+                {
+                    name: 'SSRBlurStdDev',
+                    type: 'float',
+                    phase: 1,
+                    default: 10,
+                    options: {
+                        label: 'BlurStdDev',
+                        group: 'PostProcessing/SSR',
+                        minValue: 0,
+                        maxValue: 100
+                    },
+                    get (value) {
+                        value.num[0] = this.ssrBlurStdDev;
+                    },
+                    set (value) {
+                        this.ssrBlurStdDev = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSR;
+                    }
+                },
+                {
+                    name: 'SSRCalcThickness',
+                    type: 'bool',
+                    phase: 1,
+                    default: false,
+                    options: {
+                        label: 'CalcThickness',
+                        group: 'PostProcessing/SSR'
+                    },
+                    get (value) {
+                        value.bool[0] = this.ssrCalcThickness;
+                    },
+                    set (value) {
+                        this.ssrCalcThickness = value.bool[0];
+                    },
+                    isValid () {
+                        return this.SSR;
+                    }
+                },
+                {
+                    name: 'SSAOEnabled',
+                    type: 'bool',
+                    phase: 0,
+                    default: false,
+                    options: {
+                        label: 'Enabled',
+                        group: 'PostProcessing/SSAO'
+                    },
+                    get (value) {
+                        value.bool[0] = this.SSAO;
+                    },
+                    set (value) {
+                        this.SSAO = value.bool[0];
+                    }
+                },
+                {
+                    name: 'SSAOScale',
+                    type: 'float',
+                    phase: 0,
+                    default: 10,
+                    options: {
+                        label: 'Scale',
+                        group: 'PostProcessing/SSAO'
+                    },
+                    get (value) {
+                        value.num[0] = this.SSAOScale;
+                    },
+                    set (value) {
+                        this.SSAOScale = value.num[0];
+                    }
+                },
+                {
+                    name: 'SSAOBias',
+                    type: 'float',
+                    phase: 0,
+                    default: 1,
+                    options: {
+                        label: 'Bias',
+                        group: 'PostProcessing/SSAO'
+                    },
+                    get (value) {
+                        value.num[0] = this.SSAOBias;
+                    },
+                    set (value) {
+                        this.SSAOBias = value.num[0];
+                    }
+                },
+                {
+                    name: 'SSAORadius',
+                    type: 'float',
+                    phase: 0,
+                    default: 100,
+                    options: {
+                        label: 'Radius',
+                        group: 'PostProcessing/SSAO'
+                    },
+                    get (value) {
+                        value.num[0] = this.SSAORadius;
+                    },
+                    set (value) {
+                        this.SSAORadius = value.num[0];
+                    }
+                },
+                {
+                    name: 'SSAOIntensity',
+                    type: 'float',
+                    phase: 0,
+                    default: 2.5,
+                    options: {
+                        label: 'Intensity',
+                        group: 'PostProcessing/SSAO'
+                    },
+                    get (value) {
+                        value.num[0] = this.SSAOIntensity * 100;
+                    },
+                    set (value) {
+                        this.SSAOIntensity = value.num[0] * 0.01;
+                    }
+                }
+            ];
+        }
+    };
+}
+/** @internal */ function getPerspectiveCameraClass() {
+    return {
+        ctor: PerspectiveCamera,
+        parent: Camera,
+        name: 'PerspectiveCamera',
+        createFunc (ctx) {
+            const node = new PerspectiveCamera(ctx.scene);
+            if (ctx instanceof SceneNode) {
+                node.parent = ctx;
+            }
+            return {
+                obj: node
+            };
+        },
+        getProps () {
+            return [
+                {
+                    name: 'FovVertical',
+                    type: 'float',
+                    default: Math.PI / 3,
+                    options: {
+                        minValue: 0,
+                        maxValue: Math.PI
+                    },
+                    get (value) {
+                        value.num[0] = this.fovY;
+                    },
+                    set (value) {
+                        this.fovY = value.num[0];
+                    }
+                },
+                {
+                    name: 'Near',
+                    type: 'float',
+                    default: 1,
+                    get (value) {
+                        value.num[0] = this.near;
+                    },
+                    set (value) {
+                        this.near = value.num[0];
+                    }
+                },
+                {
+                    name: 'Far',
+                    type: 'float',
+                    default: 1000,
+                    get (value) {
+                        value.num[0] = this.far;
+                    },
+                    set (value) {
+                        this.far = value.num[0];
+                    }
+                }
+            ];
+        }
+    };
+}
+/** @internal */ function getOrthoCameraClass() {
+    return {
+        ctor: OrthoCamera,
+        parent: Camera,
+        name: 'OrthoCamera',
+        createFunc (ctx) {
+            const node = new OrthoCamera(ctx.scene);
+            if (ctx instanceof SceneNode) {
+                node.parent = ctx;
+            }
+            return {
+                obj: node
+            };
+        },
+        getProps () {
+            return [
+                {
+                    name: 'Left',
+                    type: 'float',
+                    default: -1,
+                    get (value) {
+                        value.num[0] = this.left;
+                    },
+                    set (value) {
+                        this.left = value.num[0];
+                    }
+                },
+                {
+                    name: 'Right',
+                    type: 'float',
+                    default: 1,
+                    get (value) {
+                        value.num[0] = this.right;
+                    },
+                    set (value) {
+                        this.right = value.num[0];
+                    }
+                },
+                {
+                    name: 'Bottom',
+                    type: 'float',
+                    default: -1,
+                    get (value) {
+                        value.num[0] = this.bottom;
+                    },
+                    set (value) {
+                        this.bottom = value.num[0];
+                    }
+                },
+                {
+                    name: 'Top',
+                    type: 'float',
+                    default: 1,
+                    get (value) {
+                        value.num[0] = this.top;
+                    },
+                    set (value) {
+                        this.top = value.num[0];
+                    }
+                },
+                {
+                    name: 'Near',
+                    type: 'float',
+                    default: -1,
+                    get (value) {
+                        value.num[0] = this.near;
+                    },
+                    set (value) {
+                        this.near = value.num[0];
+                    }
+                },
+                {
+                    name: 'Far',
+                    type: 'float',
+                    default: 1,
+                    get (value) {
+                        value.num[0] = this.far;
+                    },
+                    set (value) {
+                        this.far = value.num[0];
+                    }
+                }
+            ];
+        }
+    };
+}
+
+export { getCameraClass, getOrthoCameraClass, getPerspectiveCameraClass };
+//# sourceMappingURL=camera.js.map