@zephyr3d/scene 0.9.21 → 0.9.23

package/dist/utility/serialization/scene/batch.js

@@ -25,13 +25,15 @@ import '../../../render/rendergraph/forward_plus_builder.js';
 import '../../../render/lightpass.js';
 import '../../../render/sky.js';
 import '../../../render/clipmap.js';
+import '../../../render/envlight.js';
 import '../../../render/dualdepthpeeling_oit.js';
 import '../../../shaders/atmosphere.js';
+import '../../../render/rendergraph/scene_render_context.js';
 import { GraphNode } from '../../../scene/graph_node.js';
 import '../../../shadow/shadowmapper.js';
 import '../../../scene/mesh.js';
-import '../../../scene/basesprite.js';
 import '../../../scene/meshdrawable.js';
+import '../../../scene/basesprite.js';
 import '../../../material/msdf_text.js';
 import '../../../scene/water.js';
 import '../../../scene/scene_node.js';

package/dist/utility/serialization/scene/batch.js.map

@@ -1 +1 @@
-{"version":3,"file":"batch.js","sources":["../../../../src/utility/serialization/scene/batch.ts"],"sourcesContent":["import { BatchGroup, GraphNode, type SceneNode } from '../../../scene';\r\nimport type { SerializableClass } from '../types';\r\n\r\n/** @internal */\r\nexport function getBatchGroupClass(): SerializableClass {\r\n  return {\r\n    ctor: BatchGroup,\r\n    parent: GraphNode,\r\n    name: 'BatchGroup',\r\n    createFunc(ctx: SceneNode) {\r\n      const batchGroup = new BatchGroup(ctx.scene!);\r\n      batchGroup.parent = ctx;\r\n      return { obj: batchGroup };\r\n    },\r\n    getProps() {\r\n      return [];\r\n    }\r\n  };\r\n}\r\n"],"names":["getBatchGroupClass","ctor","BatchGroup","parent","GraphNode","name","createFunc","ctx","batchGroup","scene","obj","getProps"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,iBACO,SAASA,kBAAAA,GAAAA;IACd,OAAO;QACLC,IAAMC,EAAAA,UAAAA;QACNC,MAAQC,EAAAA,SAAAA;QACRC,IAAM,EAAA,YAAA;AACNC,QAAAA,UAAAA,CAAAA,CAAWC,GAAc,EAAA;AACvB,YAAA,MAAMC,UAAa,GAAA,IAAIN,UAAWK,CAAAA,GAAAA,CAAIE,KAAK,CAAA;AAC3CD,YAAAA,UAAAA,CAAWL,MAAM,GAAGI,GAAAA;YACpB,OAAO;gBAAEG,GAAKF,EAAAA;AAAW,aAAA;AAC3B,SAAA;AACAG,QAAAA,QAAAA,CAAAA,GAAAA;AACE,YAAA,OAAO,EAAE;AACX;AACF,KAAA;AACF;;;;"}
+{"version":3,"file":"batch.js","sources":["../../../../src/utility/serialization/scene/batch.ts"],"sourcesContent":["import { BatchGroup, GraphNode, type SceneNode } from '../../../scene';\r\nimport type { SerializableClass } from '../types';\r\n\r\n/** @internal */\r\nexport function getBatchGroupClass(): SerializableClass {\r\n  return {\r\n    ctor: BatchGroup,\r\n    parent: GraphNode,\r\n    name: 'BatchGroup',\r\n    createFunc(ctx: SceneNode) {\r\n      const batchGroup = new BatchGroup(ctx.scene!);\r\n      batchGroup.parent = ctx;\r\n      return { obj: batchGroup };\r\n    },\r\n    getProps() {\r\n      return [];\r\n    }\r\n  };\r\n}\r\n"],"names":["getBatchGroupClass","ctor","BatchGroup","parent","GraphNode","name","createFunc","ctx","batchGroup","scene","obj","getProps"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,iBACO,SAASA,kBAAAA,GAAAA;IACd,OAAO;QACLC,IAAMC,EAAAA,UAAAA;QACNC,MAAQC,EAAAA,SAAAA;QACRC,IAAM,EAAA,YAAA;AACNC,QAAAA,UAAAA,CAAAA,CAAWC,GAAc,EAAA;AACvB,YAAA,MAAMC,UAAa,GAAA,IAAIN,UAAWK,CAAAA,GAAAA,CAAIE,KAAK,CAAA;AAC3CD,YAAAA,UAAAA,CAAWL,MAAM,GAAGI,GAAAA;YACpB,OAAO;gBAAEG,GAAKF,EAAAA;AAAW,aAAA;AAC3B,SAAA;AACAG,QAAAA,QAAAA,CAAAA,GAAAA;AACE,YAAA,OAAO,EAAE;AACX;AACF,KAAA;AACF;;;;"}

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

@@ -29,14 +29,16 @@ import '../../../render/rendergraph/forward_plus_builder.js';
 import '../../../render/lightpass.js';
 import '../../../render/sky.js';
 import '../../../render/clipmap.js';
+import '../../../render/envlight.js';
 import '../../../render/dualdepthpeeling_oit.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 '../../../render/rendergraph/scene_render_context.js';
 import { SceneNode } from '../../../scene/scene_node.js';
 import '../../../shadow/shadowmapper.js';
 import '../../../scene/mesh.js';
-import '../../../scene/basesprite.js';
 import '../../../scene/meshdrawable.js';
+import '../../../scene/basesprite.js';
 import '../../../material/msdf_text.js';
 import '../../../scene/water.js';
 import '../../../scene/particlesys.js';
@@ -277,6 +279,98 @@ import '../../../scene/raycast_visitor.js';
                     },
                     set (value) {
                         this.toneMapExposure = value.num[0];
+                    },
+                    isHidden () {
+                        return this.scene?.lightingMode === 'physical';
+                    }
+                },
+                {
+                    name: 'Aperture',
+                    type: 'float',
+                    phase: 1,
+                    default: 16,
+                    options: {
+                        label: 'Aperture (f-number)',
+                        group: 'PostProcessing/ToneMap',
+                        minValue: 0.1,
+                        maxValue: 64,
+                        animatable: true
+                    },
+                    get (value) {
+                        value.num[0] = this.aperture;
+                    },
+                    set (value) {
+                        this.aperture = value.num[0];
+                    },
+                    isHidden () {
+                        return this.scene?.lightingMode !== 'physical';
+                    }
+                },
+                {
+                    name: 'ShutterSpeed',
+                    description: 'Shutter-open time in seconds',
+                    type: 'float',
+                    phase: 1,
+                    default: 1 / 125,
+                    options: {
+                        label: 'Shutter (seconds)',
+                        group: 'PostProcessing/ToneMap',
+                        minValue: 0.000001,
+                        maxValue: 60,
+                        animatable: true
+                    },
+                    get (value) {
+                        value.num[0] = this.shutterSpeed;
+                    },
+                    set (value) {
+                        this.shutterSpeed = value.num[0];
+                    },
+                    isHidden () {
+                        return this.scene?.lightingMode !== 'physical';
+                    }
+                },
+                {
+                    name: 'ISO',
+                    type: 'float',
+                    phase: 1,
+                    default: 100,
+                    options: {
+                        group: 'PostProcessing/ToneMap',
+                        minValue: 1,
+                        maxValue: 204800,
+                        animatable: true
+                    },
+                    get (value) {
+                        value.num[0] = this.ISO;
+                    },
+                    set (value) {
+                        this.ISO = value.num[0];
+                    },
+                    isHidden () {
+                        return this.scene?.lightingMode !== 'physical';
+                    }
+                },
+                {
+                    name: 'ExposureCompensation',
+                    description: 'Exposure compensation in stops',
+                    type: 'float',
+                    phase: 1,
+                    default: 0,
+                    options: {
+                        label: 'Compensation (EV)',
+                        group: 'PostProcessing/ToneMap',
+                        minValue: -10,
+                        maxValue: 10,
+                        animatable: true
+                    },
+                    get (value) {
+                        value.num[0] = this.exposureCompensation;
+                    },
+                    set (value) {
+                        this.exposureCompensation = value.num[0];
+                    },
+                    isHidden () {
+                        return this.scene?.lightingMode !== 'physical';
                     }
                 },
                 {
@@ -437,11 +531,14 @@ import '../../../scene/raycast_visitor.js';
                 },
                 {
                     name: 'BloomThreshold',
+                    description: 'Luminance above which a pixel blooms. Under physical lighting the buffer is camera ' + 'pre-exposed, where 0.8 is roughly a white surface in direct sunlight; lower it for a ' + 'more pronounced glow.',
                     type: 'float',
                     options: {
                         animatable: true,
                         minValue: 0,
-                        maxValue: 1,
+                        // Not capped at 1: physical scenes legitimately threshold above sunlit white to
+                        // restrict blooming to genuine emitters.
+                        maxValue: 8,
                         label: 'Threshold',
                         group: 'PostProcessing/Bloom'
                     },
@@ -603,6 +700,392 @@ import '../../../scene/raycast_visitor.js';
                         return this.motionBlur;
                     }
                 },
+                {
+                    name: 'SSGIEnabled',
+                    type: 'bool',
+                    phase: 0,
+                    default: false,
+                    options: {
+                        label: 'Enabled',
+                        group: 'PostProcessing/SSGI'
+                    },
+                    get (value) {
+                        value.bool[0] = this.SSGI;
+                    },
+                    set (value) {
+                        this.SSGI = value.bool[0];
+                    }
+                },
+                {
+                    name: 'SSGIQualityPreset',
+                    type: 'string',
+                    phase: 1,
+                    default: 'quality',
+                    options: {
+                        label: 'Quality',
+                        group: 'PostProcessing/SSGI',
+                        enum: {
+                            labels: [
+                                'Quality',
+                                'Balanced',
+                                'Performance',
+                                'Custom'
+                            ],
+                            values: [
+                                'quality',
+                                'balanced',
+                                'performance',
+                                'custom'
+                            ]
+                        }
+                    },
+                    get (value) {
+                        value.str[0] = this.ssgiQualityPreset;
+                    },
+                    set (value) {
+                        this.ssgiQualityPreset = value.str[0];
+                    },
+                    isValid () {
+                        return this.SSGI;
+                    }
+                },
+                {
+                    name: 'SSGIHalfResolution',
+                    type: 'bool',
+                    phase: 2,
+                    default: false,
+                    options: {
+                        label: 'HalfResolution',
+                        group: 'PostProcessing/SSGI'
+                    },
+                    get (value) {
+                        value.bool[0] = this.ssgiHalfResolution;
+                    },
+                    set (value) {
+                        this.ssgiHalfResolution = value.bool[0];
+                    },
+                    isValid () {
+                        return this.SSGI && this.ssgiQualityPreset === 'custom';
+                    }
+                },
+                {
+                    name: 'SSGIRaysPerPixel',
+                    type: 'int',
+                    phase: 2,
+                    default: 2,
+                    options: {
+                        label: 'RaysPerPixel',
+                        group: 'PostProcessing/SSGI',
+                        minValue: 1,
+                        maxValue: 4
+                    },
+                    get (value) {
+                        value.num[0] = this.ssgiRaysPerPixel;
+                    },
+                    set (value) {
+                        this.ssgiRaysPerPixel = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSGI && this.ssgiQualityPreset === 'custom';
+                    }
+                },
+                {
+                    name: 'SSGIMaxSteps',
+                    type: 'int',
+                    phase: 2,
+                    default: 64,
+                    options: {
+                        label: 'MaxSteps',
+                        group: 'PostProcessing/SSGI',
+                        minValue: 1,
+                        maxValue: 256
+                    },
+                    get (value) {
+                        value.num[0] = this.ssgiMaxSteps;
+                    },
+                    set (value) {
+                        this.ssgiMaxSteps = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSGI && this.ssgiQualityPreset === 'custom';
+                    }
+                },
+                {
+                    name: 'SSGIDenoisePasses',
+                    type: 'int',
+                    phase: 2,
+                    default: 4,
+                    options: {
+                        label: 'DenoisePasses',
+                        group: 'PostProcessing/SSGI',
+                        minValue: 0,
+                        maxValue: 5
+                    },
+                    get (value) {
+                        value.num[0] = this.ssgiDenoisePasses;
+                    },
+                    set (value) {
+                        this.ssgiDenoisePasses = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSGI && this.ssgiQualityPreset === 'custom';
+                    }
+                },
+                {
+                    name: 'SSGIIntensity',
+                    type: 'float',
+                    phase: 1,
+                    default: 0.7,
+                    options: {
+                        label: 'Intensity',
+                        group: 'PostProcessing/SSGI',
+                        minValue: 0,
+                        maxValue: 4,
+                        animatable: true
+                    },
+                    get (value) {
+                        value.num[0] = this.ssgiIntensity;
+                    },
+                    set (value) {
+                        this.ssgiIntensity = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSGI;
+                    }
+                },
+                {
+                    name: 'SSGIAOIntensity',
+                    type: 'float',
+                    phase: 1,
+                    default: 0.8,
+                    options: {
+                        label: 'AO intensity',
+                        group: 'PostProcessing/SSGI',
+                        minValue: 0,
+                        maxValue: 1,
+                        animatable: true
+                    },
+                    get (value) {
+                        value.num[0] = this.ssgiAOIntensity;
+                    },
+                    set (value) {
+                        this.ssgiAOIntensity = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSGI;
+                    }
+                },
+                {
+                    name: 'SSGIAOPower',
+                    type: 'float',
+                    phase: 1,
+                    default: 1,
+                    options: {
+                        label: 'AO contrast',
+                        group: 'PostProcessing/SSGI',
+                        minValue: 0.01,
+                        maxValue: 4,
+                        animatable: true
+                    },
+                    get (value) {
+                        value.num[0] = this.ssgiAOPower;
+                    },
+                    set (value) {
+                        this.ssgiAOPower = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSGI;
+                    }
+                },
+                {
+                    name: 'SSGISkyOcclusion',
+                    type: 'float',
+                    phase: 1,
+                    default: 1,
+                    options: {
+                        label: 'Sky occlusion',
+                        group: 'PostProcessing/SSGI',
+                        minValue: 0,
+                        maxValue: 1,
+                        animatable: true
+                    },
+                    get (value) {
+                        value.num[0] = this.ssgiSkyOcclusion;
+                    },
+                    set (value) {
+                        this.ssgiSkyOcclusion = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSGI;
+                    }
+                },
+                {
+                    name: 'SSGIMaxDistance',
+                    type: 'float',
+                    phase: 1,
+                    default: 32,
+                    options: {
+                        label: 'MaxDistance',
+                        group: 'PostProcessing/SSGI',
+                        minValue: 0.1,
+                        maxValue: 512
+                    },
+                    get (value) {
+                        value.num[0] = this.ssgiMaxDistance;
+                    },
+                    set (value) {
+                        this.ssgiMaxDistance = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSGI;
+                    }
+                },
+                {
+                    name: 'SSGIThickness',
+                    type: 'float',
+                    phase: 1,
+                    default: 0.5,
+                    options: {
+                        label: 'Thickness',
+                        group: 'PostProcessing/SSGI',
+                        minValue: 0.001,
+                        maxValue: 8
+                    },
+                    get (value) {
+                        value.num[0] = this.ssgiThickness;
+                    },
+                    set (value) {
+                        this.ssgiThickness = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSGI;
+                    }
+                },
+                {
+                    name: 'SSGIStride',
+                    type: 'int',
+                    phase: 1,
+                    default: 1,
+                    options: {
+                        label: 'Stride',
+                        group: 'PostProcessing/SSGI',
+                        minValue: 1,
+                        maxValue: 16
+                    },
+                    get (value) {
+                        value.num[0] = this.ssgiStride;
+                    },
+                    set (value) {
+                        this.ssgiStride = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSGI;
+                    }
+                },
+                {
+                    name: 'SSGIMaxRayIntensity',
+                    description: 'Maximum ray radiance after camera exposure in physical lighting mode',
+                    type: 'float',
+                    phase: 1,
+                    default: 10,
+                    options: {
+                        label: 'MaxRayIntensity',
+                        group: 'PostProcessing/SSGI',
+                        minValue: 0,
+                        maxValue: 64
+                    },
+                    get (value) {
+                        value.num[0] = this.ssgiMaxRayIntensity;
+                    },
+                    set (value) {
+                        this.ssgiMaxRayIntensity = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSGI;
+                    }
+                },
+                {
+                    name: 'SSGITemporalEnabled',
+                    type: 'bool',
+                    phase: 1,
+                    default: true,
+                    options: {
+                        label: 'Temporal',
+                        group: 'PostProcessing/SSGI'
+                    },
+                    get (value) {
+                        value.bool[0] = this.ssgiTemporal;
+                    },
+                    set (value) {
+                        this.ssgiTemporal = value.bool[0];
+                    },
+                    isValid () {
+                        return this.SSGI;
+                    }
+                },
+                {
+                    name: 'SSGITemporalWeight',
+                    type: 'float',
+                    phase: 1,
+                    default: 0.94,
+                    options: {
+                        label: 'TemporalWeight',
+                        group: 'PostProcessing/SSGI',
+                        minValue: 0,
+                        maxValue: 0.99
+                    },
+                    get (value) {
+                        value.num[0] = this.ssgiTemporalWeight;
+                    },
+                    set (value) {
+                        this.ssgiTemporalWeight = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSGI && this.ssgiTemporal;
+                    }
+                },
+                {
+                    name: 'SSGIDepthReject',
+                    type: 'float',
+                    phase: 1,
+                    default: 0.5,
+                    options: {
+                        label: 'DepthReject',
+                        group: 'PostProcessing/SSGI',
+                        minValue: 0,
+                        maxValue: 4
+                    },
+                    get (value) {
+                        value.num[0] = this.ssgiDepthReject;
+                    },
+                    set (value) {
+                        this.ssgiDepthReject = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSGI;
+                    }
+                },
+                {
+                    name: 'SSGINormalReject',
+                    type: 'float',
+                    phase: 1,
+                    default: 0.75,
+                    options: {
+                        label: 'NormalReject',
+                        group: 'PostProcessing/SSGI',
+                        minValue: -1,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.ssgiNormalReject;
+                    },
+                    set (value) {
+                        this.ssgiNormalReject = value.num[0];
+                    },
+                    isValid () {
+                        return this.SSGI;
+                    }
+                },
                 {
                     name: 'SSREnabled',
                     type: 'bool',
@@ -1312,6 +1795,30 @@ import '../../../scene/raycast_visitor.js';
         },
         getProps () {
             return defineProps([
+                {
+                    name: 'ProjectionMode',
+                    type: 'string',
+                    phase: 0,
+                    default: 'fov',
+                    options: {
+                        enum: {
+                            labels: [
+                                'Field of View',
+                                'Physical Lens'
+                            ],
+                            values: [
+                                'fov',
+                                'physical'
+                            ]
+                        }
+                    },
+                    get (value) {
+                        value.str[0] = this.projectionMode;
+                    },
+                    set (value) {
+                        this.projectionMode = value.str[0];
+                    }
+                },
                 {
                     name: 'FovVertical',
                     type: 'float',
@@ -1325,6 +1832,95 @@ import '../../../scene/raycast_visitor.js';
                     },
                     set (value) {
                         this.fovY = value.num[0];
+                    },
+                    isHidden () {
+                        return this.projectionMode === 'physical';
+                    }
+                },
+                {
+                    name: 'FocalLength',
+                    description: 'Physical focal length in millimeters',
+                    type: 'float',
+                    default: 50,
+                    options: {
+                        minValue: 0.1,
+                        maxValue: 2000,
+                        animatable: true
+                    },
+                    get (value) {
+                        value.num[0] = this.focalLengthMm;
+                    },
+                    set (value) {
+                        this.focalLengthMm = value.num[0];
+                    },
+                    isHidden () {
+                        return this.projectionMode !== 'physical';
+                    }
+                },
+                {
+                    name: 'SensorWidth',
+                    description: 'Physical sensor width in millimeters',
+                    type: 'float',
+                    default: 36,
+                    options: {
+                        minValue: 0.1,
+                        maxValue: 200,
+                        animatable: true
+                    },
+                    get (value) {
+                        value.num[0] = this.sensorWidthMm;
+                    },
+                    set (value) {
+                        this.sensorWidthMm = value.num[0];
+                    },
+                    isHidden () {
+                        return this.projectionMode !== 'physical';
+                    }
+                },
+                {
+                    name: 'SensorHeight',
+                    description: 'Physical sensor height in millimeters',
+                    type: 'float',
+                    default: 24,
+                    options: {
+                        minValue: 0.1,
+                        maxValue: 200,
+                        animatable: true
+                    },
+                    get (value) {
+                        value.num[0] = this.sensorHeightMm;
+                    },
+                    set (value) {
+                        this.sensorHeightMm = value.num[0];
+                    },
+                    isHidden () {
+                        return this.projectionMode !== 'physical';
+                    }
+                },
+                {
+                    name: 'SensorFit',
+                    type: 'string',
+                    default: 'horizontal',
+                    options: {
+                        enum: {
+                            labels: [
+                                'Horizontal',
+                                'Vertical'
+                            ],
+                            values: [
+                                'horizontal',
+                                'vertical'
+                            ]
+                        }
+                    },
+                    get (value) {
+                        value.str[0] = this.sensorFit;
+                    },
+                    set (value) {
+                        this.sensorFit = value.str[0];
+                    },
+                    isHidden () {
+                        return this.projectionMode !== 'physical';
                     }
                 },
                 {