@zephyr3d/scene 0.9.2 → 0.9.4

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

@@ -0,0 +1,1111 @@
+import '../../../material/shader/helper.js';
+import { LambertMaterial } from '../../../material/lambert.js';
+import { BlinnMaterial } from '../../../material/blinn.js';
+import { UnlitMaterial } from '../../../material/unlit.js';
+import { ParticleMaterial } from '../../../material/particle.js';
+import { Material } from '../../../material/material.js';
+import { MeshMaterial } from '../../../material/meshmaterial.js';
+import '../../../material/grassmaterial.js';
+import '../../../material/terrainmaterial.js';
+import '../../../material/terrain-cm.js';
+import { PBRMetallicRoughnessMaterial } from '../../../material/pbrmr.js';
+import { PBRSpecularGlossinessMaterial } from '../../../material/pbrsg.js';
+import { Vector4, Vector3 } from '@zephyr3d/base';
+import '../../../values.js';
+import { getTextureProps } from './common.js';
+
+function getPBRCommonProps(manager) {
+    return [
+        {
+            name: 'IOR',
+            type: 'float',
+            default: 1.5,
+            options: {
+                animatable: true
+            },
+            get (value) {
+                value.num[0] = this.ior;
+            },
+            set (value) {
+                this.ior = value.num[0];
+            },
+            isValid () {
+                return !this.$isInstance;
+            }
+        },
+        {
+            name: 'OcclusionStrength',
+            type: 'float',
+            phase: 2,
+            default: 1,
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 1
+            },
+            get (value) {
+                value.num[0] = this.occlusionStrength;
+            },
+            set (value) {
+                this.occlusionStrength = value.num[0];
+            },
+            isValid () {
+                return !this.$isInstance && !!this.occlusionTexture;
+            }
+        },
+        ...getTextureProps(manager, 'occlusionTexture', '2D', 0),
+        {
+            name: 'EmissiveColor',
+            type: 'rgb',
+            options: {
+                animatable: true
+            },
+            get (value) {
+                value.num[0] = this.emissiveColor.x;
+                value.num[1] = this.emissiveColor.y;
+                value.num[2] = this.emissiveColor.z;
+            },
+            set (value) {
+                this.emissiveColor = new Vector3(value.num[0], value.num[1], value.num[2]);
+            },
+            getDefaultValue () {
+                return this.$isInstance ? this.coreMaterial.emissiveColor : [
+                    0,
+                    0,
+                    0
+                ];
+            }
+        },
+        {
+            name: 'EmissiveStrength',
+            type: 'float',
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 1
+            },
+            get (value) {
+                value.num[0] = this.emissiveStrength;
+            },
+            set (value) {
+                this.emissiveStrength = value.num[0];
+            },
+            getDefaultValue () {
+                return this.$isInstance ? this.coreMaterial.emissiveStrength : 1;
+            }
+        },
+        ...getTextureProps(manager, 'emissiveTexture', '2D', 0),
+        ...getTextureProps(manager, 'specularTexture', '2D', 0),
+        {
+            name: 'Transmission',
+            type: 'bool',
+            phase: 0,
+            default: false,
+            get (value) {
+                value.bool[0] = this.transmission;
+            },
+            set (value) {
+                this.transmission = value.bool[0];
+            },
+            isValid () {
+                return !this.$isInstance;
+            }
+        },
+        {
+            name: 'TransmissionFactor',
+            type: 'float',
+            phase: 1,
+            default: 0,
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 1
+            },
+            get (value) {
+                value.num[0] = this.transmissionFactor;
+            },
+            set (value) {
+                this.transmissionFactor = value.num[0];
+            },
+            isValid () {
+                return !this.$isInstance && !!this.transmission;
+            }
+        },
+        ...getTextureProps(manager, 'transmissionTexture', '2D', 1, function() {
+            return this.transmission;
+        }),
+        {
+            name: 'ThicknessFactor',
+            type: 'float',
+            phase: 1,
+            default: 0,
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 99999
+            },
+            get (value) {
+                value.num[0] = this.thicknessFactor;
+            },
+            set (value) {
+                this.thicknessFactor = value.num[0];
+            },
+            isValid () {
+                return !this.$isInstance && !!this.transmission;
+            }
+        },
+        ...getTextureProps(manager, 'thicknessTexture', '2D', 1, function() {
+            return this.transmission;
+        }),
+        {
+            name: 'AttenuationColor',
+            type: 'rgb',
+            phase: 1,
+            default: [
+                1,
+                1,
+                1
+            ],
+            options: {
+                animatable: true
+            },
+            get (value) {
+                value.num[0] = this.attenuationColor.x;
+                value.num[1] = this.attenuationColor.y;
+                value.num[2] = this.attenuationColor.z;
+            },
+            set (value) {
+                this.attenuationColor = new Vector3(value.num[0], value.num[1], value.num[2]);
+            },
+            isValid () {
+                return !this.$isInstance && !!this.transmission;
+            }
+        },
+        {
+            name: 'AttenuationDistance',
+            type: 'float',
+            phase: 1,
+            default: 99999,
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 99999
+            },
+            get (value) {
+                value.num[0] = this.attenuationDistance;
+            },
+            set (value) {
+                this.attenuationDistance = value.num[0];
+            },
+            isValid () {
+                return !this.$isInstance && !!this.transmission;
+            }
+        },
+        {
+            name: 'Iridescence',
+            type: 'bool',
+            phase: 0,
+            default: false,
+            get (value) {
+                value.bool[0] = this.iridescence;
+            },
+            set (value) {
+                this.iridescence = value.bool[0];
+            },
+            isValid () {
+                return !this.$isInstance;
+            }
+        },
+        {
+            name: 'IridescenceFactor',
+            type: 'float',
+            phase: 1,
+            default: 0,
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 1
+            },
+            get (value) {
+                value.num[0] = this.iridescenceFactor;
+            },
+            set (value) {
+                this.iridescenceFactor = value.num[0];
+            },
+            isValid () {
+                return !this.$isInstance && !!this.iridescence;
+            }
+        },
+        ...getTextureProps(manager, 'iridescenceTexture', '2D', 1, function() {
+            return this.iridescence;
+        }),
+        {
+            name: 'IridescenceIOR',
+            type: 'float',
+            phase: 1,
+            default: 1.3,
+            options: {
+                animatable: true
+            },
+            get (value) {
+                value.num[0] = this.iridescenceIor;
+            },
+            set (value) {
+                this.iridescenceIor = value.num[0];
+            },
+            isValid () {
+                return !this.$isInstance && !!this.iridescence;
+            }
+        },
+        {
+            name: 'IridescenceThicknessMin',
+            type: 'float',
+            phase: 1,
+            default: 100,
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 1000
+            },
+            get (value) {
+                value.num[0] = this.iridescenceThicknessMin;
+            },
+            set (value) {
+                this.iridescenceThicknessMin = value.num[0];
+            },
+            isValid () {
+                return !this.$isInstance && !!this.iridescence;
+            }
+        },
+        {
+            name: 'IridescenceThicknessMax',
+            type: 'float',
+            phase: 1,
+            default: 400,
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 1000
+            },
+            get (value) {
+                value.num[0] = this.iridescenceThicknessMax;
+            },
+            set (value) {
+                this.iridescenceThicknessMax = value.num[0];
+            },
+            isValid () {
+                return !this.$isInstance && !!this.iridescence;
+            }
+        },
+        ...getTextureProps(manager, 'iridescenceThicknessTexture', '2D', 1, function() {
+            return this.iridescence;
+        }),
+        {
+            name: 'ClearCoat',
+            type: 'bool',
+            phase: 0,
+            default: false,
+            get (value) {
+                value.bool[0] = this.clearcoat;
+            },
+            set (value) {
+                this.clearcoat = value.bool[0];
+            },
+            isValid () {
+                return !this.$isInstance;
+            }
+        },
+        {
+            name: 'ClearCoatIntensity',
+            type: 'float',
+            phase: 1,
+            default: 0,
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 1
+            },
+            get (value) {
+                value.num[0] = this.clearcoatIntensity;
+            },
+            set (value) {
+                this.clearcoatIntensity = value.num[0];
+            },
+            isValid () {
+                return !this.$isInstance && !!this.clearcoat;
+            }
+        },
+        ...getTextureProps(manager, 'clearcoatIntensityTexture', '2D', 1, function() {
+            return this.clearcoat;
+        }),
+        {
+            name: 'ClearCoatRoughnessFactor',
+            type: 'float',
+            phase: 1,
+            default: 0,
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 1
+            },
+            get (value) {
+                value.num[0] = this.clearcoatRoughnessFactor;
+            },
+            set (value) {
+                this.clearcoatRoughnessFactor = value.num[0];
+            },
+            isValid () {
+                return !this.$isInstance && !!this.clearcoat;
+            }
+        },
+        ...getTextureProps(manager, 'clearcoatRoughnessTexture', '2D', 1, function() {
+            return this.clearcoat;
+        }),
+        ...getTextureProps(manager, 'clearcoatNormalTexture', '2D', 1, function() {
+            return this.clearcoat;
+        }),
+        {
+            name: 'Sheen',
+            type: 'bool',
+            phase: 0,
+            default: false,
+            get (value) {
+                value.bool[0] = this.sheen;
+            },
+            set (value) {
+                this.sheen = value.bool[0];
+            },
+            isValid () {
+                return !this.$isInstance;
+            }
+        },
+        {
+            name: 'SheenColorFactor',
+            type: 'rgb',
+            phase: 1,
+            default: [
+                0,
+                0,
+                0
+            ],
+            options: {
+                animatable: true
+            },
+            get (value) {
+                value.num[0] = this.sheenColorFactor.x;
+                value.num[1] = this.sheenColorFactor.y;
+                value.num[2] = this.sheenColorFactor.z;
+            },
+            set (value) {
+                this.sheenColorFactor = new Vector3(value.num[0], value.num[1], value.num[2]);
+            },
+            isValid () {
+                return !this.$isInstance && !!this.sheen;
+            }
+        },
+        ...getTextureProps(manager, 'sheenColorTexture', '2D', 1, function() {
+            return this.sheen;
+        }),
+        {
+            name: 'SheenRoughnessFactor',
+            type: 'float',
+            phase: 1,
+            default: 0,
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 1
+            },
+            get (value) {
+                value.num[0] = this.sheenRoughnessFactor;
+            },
+            set (value) {
+                this.sheenRoughnessFactor = value.num[0];
+            },
+            isValid () {
+                return !this.$isInstance && !!this.sheen;
+            }
+        },
+        ...getTextureProps(manager, 'sheenRoughnessTexture', '2D', 1, function() {
+            return this.sheen;
+        }),
+        ...getLitMaterialProps(manager)
+    ];
+}
+function getLitMaterialProps(manager) {
+    return [
+        ...getUnlitMaterialProps(manager),
+        {
+            name: 'vertexNormal',
+            type: 'bool',
+            default: true,
+            get (value) {
+                value.bool[0] = this.vertexNormal;
+            },
+            set (value) {
+                this.vertexNormal = value.bool[0];
+            },
+            isValid () {
+                return !this.$isInstance;
+            }
+        },
+        {
+            name: 'vertexTangent',
+            type: 'bool',
+            default: false,
+            get (value) {
+                value.bool[0] = this.vertexTangent;
+            },
+            set (value) {
+                this.vertexTangent = value.bool[0];
+            },
+            isValid () {
+                return !this.$isInstance && !!this.vertexNormal;
+            }
+        },
+        ...getTextureProps(manager, 'normalTexture', '2D', 0)
+    ];
+}
+function getUnlitMaterialProps(manager) {
+    return [
+        {
+            name: 'vertexColor',
+            type: 'bool',
+            default: false,
+            get (value) {
+                value.bool[0] = this.vertexColor;
+            },
+            set (value) {
+                this.vertexColor = value.bool[0];
+            },
+            isValid () {
+                return !this.$isInstance;
+            }
+        },
+        {
+            name: 'AlbedoColor',
+            type: 'rgba',
+            options: {
+                animatable: true
+            },
+            get (value) {
+                const color = this.albedoColor;
+                value.num[0] = color.x;
+                value.num[1] = color.y;
+                value.num[2] = color.z;
+                value.num[3] = color.w;
+            },
+            set (value) {
+                this.albedoColor = new Vector4(value.num[0], value.num[1], value.num[2], value.num[3]);
+            },
+            getDefaultValue () {
+                return this.$isInstance ? this.coreMaterial.albedoColor : [
+                    1,
+                    1,
+                    1,
+                    1
+                ];
+            }
+        },
+        ...getTextureProps(manager, 'albedoTexture', '2D', 0)
+    ];
+}
+/** @internal */ function getMeshMaterialClass() {
+    return {
+        ctor: MeshMaterial,
+        name: 'MeshMaterial',
+        createFunc (ctx, initParams) {
+            let mat = Material.findMaterialById(initParams.persistentId);
+            if (mat) {
+                return {
+                    obj: mat,
+                    loadProps: false
+                };
+            } else if (initParams.persistentId === initParams.corePersistentId) {
+                mat = new MeshMaterial();
+                mat.persistentId = initParams.persistentId;
+                return {
+                    obj: mat,
+                    loadProps: true
+                };
+            } else {
+                const coreMaterial = Material.findMaterialById(initParams.corePersistentId);
+                if (!coreMaterial) {
+                    throw new Error('Load material failed: core material not found');
+                }
+                mat = coreMaterial.createInstance();
+                mat.persistentId = initParams.persistentId;
+                return {
+                    obj: mat,
+                    loadProps: true
+                };
+            }
+        },
+        getInitParams (obj) {
+            return {
+                persistentId: obj.persistentId,
+                corePersistentId: obj.coreMaterial.persistentId
+            };
+        },
+        getProps () {
+            return [
+                {
+                    name: 'AlphaCutoff',
+                    type: 'float',
+                    default: 0,
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.alphaCutoff;
+                    },
+                    set (value) {
+                        this.alphaCutoff = value.num[0];
+                    },
+                    isValid () {
+                        return !this.$isInstance;
+                    }
+                },
+                {
+                    name: 'AlphaToCoverage',
+                    type: 'bool',
+                    default: false,
+                    get (value) {
+                        value.bool[0] = this.alphaToCoverage;
+                    },
+                    set (value) {
+                        this.alphaToCoverage = value.bool[0];
+                    },
+                    isValid () {
+                        return !this.$isInstance;
+                    }
+                },
+                {
+                    name: 'BlendMode',
+                    type: 'string',
+                    options: {
+                        enum: {
+                            labels: [
+                                'None',
+                                'Blend',
+                                'Additive'
+                            ],
+                            values: [
+                                'none',
+                                'blend',
+                                'additive'
+                            ]
+                        }
+                    },
+                    default: 'none',
+                    get (value) {
+                        value.str[0] = this.blendMode;
+                    },
+                    set (value) {
+                        this.blendMode = value.str[0];
+                    },
+                    isValid () {
+                        return !this.$isInstance;
+                    }
+                },
+                {
+                    name: 'CullMode',
+                    type: 'string',
+                    options: {
+                        enum: {
+                            labels: [
+                                'None',
+                                'Front',
+                                'Back'
+                            ],
+                            values: [
+                                'none',
+                                'front',
+                                'back'
+                            ]
+                        }
+                    },
+                    default: 'back',
+                    get (value) {
+                        value.str[0] = this.cullMode;
+                    },
+                    set (value) {
+                        this.cullMode = value.str[0];
+                    },
+                    isValid () {
+                        return !this.$isInstance;
+                    }
+                },
+                {
+                    name: 'Opacity',
+                    type: 'float',
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    default: 1,
+                    get (value) {
+                        value.num[0] = this.opacity;
+                    },
+                    set (value) {
+                        this.opacity = value.num[0];
+                    },
+                    getDefaultValue () {
+                        return this.$isInstance ? this.coreMaterial.opacity : 1;
+                    }
+                },
+                {
+                    name: 'TAAStrength',
+                    type: 'float',
+                    options: {
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    default: 15 / 16,
+                    get (value) {
+                        value.num[0] = this.TAAStrength;
+                    },
+                    set (value) {
+                        this.TAAStrength = value.num[0];
+                    },
+                    isValid () {
+                        return !this.$isInstance;
+                    }
+                }
+            ];
+        }
+    };
+}
+/** @internal */ function getParticleMaterialClass(manager) {
+    return {
+        ctor: ParticleMaterial,
+        name: 'ParticleMaterial',
+        parent: MeshMaterial,
+        createFunc (ctx, initParams) {
+            let mat = Material.findMaterialById(initParams.persistentId);
+            if (mat) {
+                return {
+                    obj: mat,
+                    loadProps: false
+                };
+            } else {
+                mat = new ParticleMaterial();
+                mat.persistentId = initParams.persistentId;
+                return {
+                    obj: mat,
+                    loadProps: true
+                };
+            }
+        },
+        getInitParams (obj) {
+            return {
+                persistentId: obj.persistentId
+            };
+        },
+        getProps () {
+            return [
+                {
+                    name: 'AlphaMap',
+                    type: 'object',
+                    default: '',
+                    isNullable () {
+                        return true;
+                    },
+                    get (value) {
+                        value.str[0] = manager.getAssetId(this.alphaMap) ?? '';
+                    },
+                    async set (value) {
+                        if (value.str[0]) {
+                            const assetId = value.str[0];
+                            let tex;
+                            try {
+                                tex = await manager.fetchTexture(assetId);
+                            } catch (err) {
+                                console.error(`Load asset failed: ${value.str[0]}: ${err}`);
+                            }
+                            if (tex?.isTexture2D()) {
+                                this.alphaMap = tex;
+                            } else {
+                                console.error('Invalid albedo texture');
+                            }
+                        }
+                    }
+                },
+                {
+                    name: 'RampMap',
+                    type: 'object',
+                    default: '',
+                    isNullable () {
+                        return true;
+                    },
+                    get (value) {
+                        value.str[0] = manager.getAssetId(this.rampMap) ?? '';
+                    },
+                    async set (value) {
+                        if (value.str[0]) {
+                            const assetId = value.str[0];
+                            let tex;
+                            try {
+                                tex = await manager.fetchTexture(assetId);
+                            } catch (err) {
+                                console.error(`Load asset failed: ${value.str[0]}: ${err}`);
+                            }
+                            if (tex?.isTexture2D()) {
+                                this.rampMap = tex;
+                            } else {
+                                console.error('Invalid albedo texture');
+                            }
+                        }
+                    }
+                }
+            ];
+        }
+    };
+}
+/** @internal */ function getUnlitMaterialClass(manager) {
+    return {
+        ctor: UnlitMaterial,
+        parent: MeshMaterial,
+        name: 'UnlitMaterial',
+        createFunc (ctx, initParams) {
+            let mat = Material.findMaterialById(initParams.persistentId);
+            if (mat) {
+                return {
+                    obj: mat,
+                    loadProps: false
+                };
+            } else if (initParams.persistentId === initParams.corePersistentId) {
+                mat = new UnlitMaterial();
+                mat.persistentId = initParams.persistentId;
+                return {
+                    obj: mat,
+                    loadProps: true
+                };
+            } else {
+                const coreMaterial = Material.findMaterialById(initParams.corePersistentId);
+                if (!coreMaterial) {
+                    throw new Error('Load material failed: core material not found');
+                }
+                mat = coreMaterial.createInstance();
+                mat.persistentId = initParams.persistentId;
+                return {
+                    obj: mat,
+                    loadProps: true
+                };
+            }
+        },
+        getInitParams (obj) {
+            return {
+                persistentId: obj.persistentId,
+                corePersistentId: obj.coreMaterial.persistentId
+            };
+        },
+        getProps () {
+            return getUnlitMaterialProps(manager);
+        }
+    };
+}
+/** @internal */ function getLambertMaterialClass(manager) {
+    return {
+        ctor: LambertMaterial,
+        parent: MeshMaterial,
+        name: 'LambertMaterial',
+        createFunc (ctx, initParams) {
+            let mat = Material.findMaterialById(initParams.persistentId);
+            if (mat) {
+                return {
+                    obj: mat,
+                    loadProps: false
+                };
+            } else if (initParams.persistentId === initParams.corePersistentId) {
+                mat = new LambertMaterial();
+                mat.persistentId = initParams.persistentId;
+                return {
+                    obj: mat,
+                    loadProps: true
+                };
+            } else {
+                const coreMaterial = Material.findMaterialById(initParams.corePersistentId);
+                if (!coreMaterial) {
+                    throw new Error('Load material failed: core material not found');
+                }
+                mat = coreMaterial.createInstance();
+                mat.persistentId = initParams.persistentId;
+                return {
+                    obj: mat,
+                    loadProps: true
+                };
+            }
+        },
+        getInitParams (obj) {
+            return {
+                persistentId: obj.persistentId,
+                corePersistentId: obj.coreMaterial.persistentId
+            };
+        },
+        getProps () {
+            return getLitMaterialProps(manager);
+        }
+    };
+}
+/** @internal */ function getBlinnMaterialClass(manager) {
+    return {
+        ctor: BlinnMaterial,
+        parent: MeshMaterial,
+        name: 'BlinnMaterial',
+        createFunc (ctx, initParams) {
+            let mat = Material.findMaterialById(initParams.persistentId);
+            if (mat) {
+                return {
+                    obj: mat,
+                    loadProps: false
+                };
+            } else if (initParams.persistentId === initParams.corePersistentId) {
+                mat = new BlinnMaterial();
+                mat.persistentId = initParams.persistentId;
+                return {
+                    obj: mat,
+                    loadProps: true
+                };
+            } else {
+                const coreMaterial = Material.findMaterialById(initParams.corePersistentId);
+                if (!coreMaterial) {
+                    throw new Error('Load material failed: core material not found');
+                }
+                mat = coreMaterial.createInstance();
+                mat.persistentId = initParams.persistentId;
+                return {
+                    obj: mat,
+                    loadProps: true
+                };
+            }
+        },
+        getInitParams (obj) {
+            return {
+                persistentId: obj.persistentId,
+                corePersistentId: obj.coreMaterial.persistentId
+            };
+        },
+        getProps () {
+            return [
+                {
+                    name: 'Shininess',
+                    type: 'float',
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 2048
+                    },
+                    get (value) {
+                        value.num[0] = this.shininess;
+                    },
+                    set (value) {
+                        this.shininess = value.num[0];
+                    },
+                    getDefaultValue () {
+                        return this.$isInstance ? this.coreMaterial.shininess : 32;
+                    }
+                },
+                ...getLitMaterialProps(manager)
+            ];
+        }
+    };
+}
+/** @internal */ function getPBRMetallicRoughnessMaterialClass(manager) {
+    return {
+        ctor: PBRMetallicRoughnessMaterial,
+        parent: MeshMaterial,
+        name: 'PBRMetallicRoughnessMaterial',
+        createFunc (ctx, initParams) {
+            let mat = Material.findMaterialById(initParams.persistentId);
+            if (mat) {
+                return {
+                    obj: mat,
+                    loadProps: false
+                };
+            } else if (initParams.persistentId === initParams.corePersistentId) {
+                mat = new PBRMetallicRoughnessMaterial();
+                mat.persistentId = initParams.persistentId;
+                return {
+                    obj: mat,
+                    loadProps: true
+                };
+            } else {
+                const coreMaterial = Material.findMaterialById(initParams.corePersistentId);
+                if (!coreMaterial) {
+                    throw new Error('Load material failed: core material not found');
+                }
+                mat = coreMaterial.createInstance();
+                mat.persistentId = initParams.persistentId;
+                return {
+                    obj: mat,
+                    loadProps: true
+                };
+            }
+        },
+        getInitParams (obj) {
+            return {
+                persistentId: obj.persistentId,
+                corePersistentId: obj.coreMaterial.persistentId
+            };
+        },
+        getProps () {
+            return [
+                {
+                    name: 'Metallic',
+                    type: 'float',
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.metallic;
+                    },
+                    set (value) {
+                        this.metallic = value.num[0];
+                    },
+                    getDefaultValue () {
+                        return this.$isInstance ? this.coreMaterial.metallic : 1;
+                    }
+                },
+                {
+                    name: 'Roughness',
+                    type: 'float',
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.roughness;
+                    },
+                    set (value) {
+                        this.roughness = value.num[0];
+                    },
+                    getDefaultValue () {
+                        return this.$isInstance ? this.coreMaterial.roughness : 1;
+                    }
+                },
+                {
+                    name: 'SpecularFactor',
+                    type: 'rgba',
+                    options: {
+                        animatable: true
+                    },
+                    get (value) {
+                        value.num[0] = this.specularFactor.x;
+                        value.num[1] = this.specularFactor.y;
+                        value.num[2] = this.specularFactor.z;
+                        value.num[3] = this.specularFactor.w;
+                    },
+                    set (value) {
+                        this.specularFactor = new Vector4(value.num[0], value.num[1], value.num[2], value.num[3]);
+                    },
+                    getDefaultValue () {
+                        return this.$isInstance ? this.coreMaterial.specularFactor : [
+                            1,
+                            1,
+                            1,
+                            1
+                        ];
+                    }
+                },
+                ...getTextureProps(manager, 'metallicRoughnessTexture', '2D', 0),
+                ...getTextureProps(manager, 'specularColorTexture', '2D', 0),
+                ...getPBRCommonProps(manager)
+            ];
+        }
+    };
+}
+/** @internal */ function getPBRSpecularGlossinessMaterialClass(manager) {
+    return {
+        ctor: PBRSpecularGlossinessMaterial,
+        name: 'PBRSpecularGlossinessMaterial',
+        parent: MeshMaterial,
+        createFunc (ctx, initParams) {
+            let mat = Material.findMaterialById(initParams.persistentId);
+            if (mat) {
+                return {
+                    obj: mat,
+                    loadProps: false
+                };
+            } else if (initParams.persistentId === initParams.corePersistentId) {
+                mat = new PBRSpecularGlossinessMaterial();
+                mat.persistentId = initParams.persistentId;
+                return {
+                    obj: mat,
+                    loadProps: true
+                };
+            } else {
+                const coreMaterial = Material.findMaterialById(initParams.corePersistentId);
+                if (!coreMaterial) {
+                    throw new Error('Load material failed: core material not found');
+                }
+                mat = coreMaterial.createInstance();
+                mat.persistentId = initParams.persistentId;
+                return {
+                    obj: mat,
+                    loadProps: true
+                };
+            }
+        },
+        getInitParams (obj) {
+            return {
+                persistentId: obj.persistentId,
+                corePersistentId: obj.coreMaterial.persistentId
+            };
+        },
+        getProps () {
+            return [
+                {
+                    name: 'SpecularFactor',
+                    type: 'rgb',
+                    options: {
+                        animatable: true
+                    },
+                    get (value) {
+                        value.num[0] = this.specularFactor.x;
+                        value.num[1] = this.specularFactor.y;
+                        value.num[2] = this.specularFactor.z;
+                    },
+                    set (value) {
+                        this.specularFactor = new Vector3(value.num[0], value.num[1], value.num[2]);
+                    },
+                    getDefaultValue () {
+                        return this.$isInstance ? this.coreMaterial.specularFactor : [
+                            1,
+                            1,
+                            1
+                        ];
+                    }
+                },
+                {
+                    name: 'GlossnessFactor',
+                    type: 'float',
+                    options: {
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.glossinessFactor;
+                    },
+                    set (value) {
+                        this.glossinessFactor = value.num[0];
+                    },
+                    getDefaultValue () {
+                        return this.$isInstance ? this.coreMaterial.glossinessFactor : 1;
+                    }
+                },
+                ...getPBRCommonProps(manager)
+            ];
+        }
+    };
+}
+
+export { getBlinnMaterialClass, getLambertMaterialClass, getMeshMaterialClass, getPBRMetallicRoughnessMaterialClass, getPBRSpecularGlossinessMaterialClass, getParticleMaterialClass, getUnlitMaterialClass };
+//# sourceMappingURL=material.js.map