@zephyr3d/scene 0.9.6 → 0.9.8

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

@@ -3,23 +3,258 @@ 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 { SubsurfaceProfile } from '../../../material/subsurfaceprofile.js';
 import '@zephyr3d/device';
 import '../../../values.js';
-import { Vector3, Vector2, Vector4 } from '@zephyr3d/base';
+import { Vector3, Vector4, Vector2 } from '@zephyr3d/base';
 import { MeshMaterial } from '../../../material/meshmaterial.js';
 import '../../../material/grassmaterial.js';
 import '../../../material/terrain-cm.js';
 import { PBRMetallicRoughnessMaterial } from '../../../material/pbrmr.js';
 import { PBRSpecularGlossinessMaterial } from '../../../material/pbrsg.js';
+import { MToonMaterial } from '../../../material/mtoon.js';
 import { PBRBluePrintMaterial } from '../../../material/pbrblueprint.js';
 import { SpriteMaterial } from '../../../material/sprite.js';
 import { StandardSpriteMaterial } from '../../../material/sprite_std.js';
-import '../../../material/msdf_text.js';
 import { SpriteBlueprintMaterial } from '../../../material/spriteblueprint.js';
 import { defineProps } from '../types.js';
 import { getMeshMaterialInstanceUniformsClass, getTextureProps } from './common.js';
 
+function createBlueprintOutputHiddenPredicate(_outputs) {
+    return function() {
+        return this instanceof PBRBluePrintMaterial;
+    };
+}
+function getSubsurfaceProfileClass() {
+    return {
+        ctor: SubsurfaceProfile,
+        name: 'SubsurfaceProfile',
+        getProps () {
+            return defineProps([
+                {
+                    name: 'Preset',
+                    type: 'string',
+                    default: 'skin_default',
+                    options: {
+                        label: 'LookPreset',
+                        enum: {
+                            labels: [
+                                'Skin Thin',
+                                'Skin Default',
+                                'Skin HeavyMakeup',
+                                'Wax Backlit',
+                                'Wax Soft',
+                                'Jade Backlit',
+                                'Jade Soft'
+                            ],
+                            values: [
+                                'skin_thin',
+                                'skin_default',
+                                'skin_heavy_makeup',
+                                'wax_backlit',
+                                'wax_soft',
+                                'jade_backlit',
+                                'jade_soft'
+                            ]
+                        }
+                    },
+                    get (value) {
+                        value.str[0] = this.preset;
+                    },
+                    set (value) {
+                        this.preset = value.str[0];
+                    }
+                },
+                {
+                    name: 'ScatterColor',
+                    type: 'rgb',
+                    default: [
+                        1,
+                        0.45,
+                        0.17
+                    ],
+                    options: {
+                        label: 'MeanFreePathColor',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.meanFreePathColor.x;
+                        value.num[1] = this.meanFreePathColor.y;
+                        value.num[2] = this.meanFreePathColor.z;
+                    },
+                    set (value) {
+                        this.meanFreePathColor = new Vector3(value.num[0], value.num[1], value.num[2]);
+                    }
+                },
+                {
+                    name: 'ScatterDistance',
+                    type: 'float',
+                    default: 0.92,
+                    options: {
+                        label: 'MeanFreePathDistance',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 8
+                    },
+                    get (value) {
+                        value.num[0] = this.meanFreePathDistance;
+                    },
+                    set (value) {
+                        this.meanFreePathDistance = value.num[0];
+                    }
+                },
+                {
+                    name: 'ScatterWeight',
+                    type: 'float',
+                    default: 0.82,
+                    options: {
+                        label: 'ScatterWeight',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 8
+                    },
+                    get (value) {
+                        value.num[0] = this.strength;
+                    },
+                    set (value) {
+                        this.strength = value.num[0];
+                    }
+                },
+                {
+                    name: 'ScatterScale',
+                    type: 'float',
+                    default: 0.96,
+                    options: {
+                        label: 'ScatterScale',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 8
+                    },
+                    get (value) {
+                        value.num[0] = this.scale;
+                    },
+                    set (value) {
+                        this.scale = value.num[0];
+                    }
+                },
+                {
+                    name: 'WorldUnitScale',
+                    type: 'float',
+                    default: 1,
+                    options: {
+                        label: 'WorldUnitScale',
+                        animatable: true,
+                        minValue: 0.05,
+                        maxValue: 4
+                    },
+                    get (value) {
+                        value.num[0] = this.worldUnitScale;
+                    },
+                    set (value) {
+                        this.worldUnitScale = value.num[0];
+                    }
+                },
+                {
+                    name: 'BoundaryColorBleed',
+                    type: 'float',
+                    default: 0.22,
+                    options: {
+                        label: 'BoundaryColorBleed',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.boundaryColorBleed;
+                    },
+                    set (value) {
+                        this.boundaryColorBleed = value.num[0];
+                    }
+                },
+                {
+                    name: 'TransmissionTintColor',
+                    type: 'rgb',
+                    default: [
+                        1,
+                        0.46,
+                        0.34
+                    ],
+                    options: {
+                        label: 'TransmissionTintColor',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.transmissionTintColor.x;
+                        value.num[1] = this.transmissionTintColor.y;
+                        value.num[2] = this.transmissionTintColor.z;
+                    },
+                    set (value) {
+                        this.transmissionTintColor = new Vector3(value.num[0], value.num[1], value.num[2]);
+                    }
+                },
+                {
+                    name: 'ExtinctionScale',
+                    type: 'float',
+                    default: 1.06,
+                    options: {
+                        label: 'ExtinctionScale',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 4
+                    },
+                    get (value) {
+                        value.num[0] = this.extinctionScale;
+                    },
+                    set (value) {
+                        this.extinctionScale = value.num[0];
+                    }
+                },
+                {
+                    name: 'NormalScale',
+                    type: 'float',
+                    default: 1,
+                    options: {
+                        label: 'NormalScale',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 2
+                    },
+                    get (value) {
+                        value.num[0] = this.normalScale;
+                    },
+                    set (value) {
+                        this.normalScale = value.num[0];
+                    }
+                },
+                {
+                    name: 'ScatteringDistribution',
+                    type: 'float',
+                    default: 0.6,
+                    options: {
+                        label: 'ScatteringDistribution',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.scatteringDistribution;
+                    },
+                    set (value) {
+                        this.scatteringDistribution = value.num[0];
+                    }
+                }
+            ]);
+        }
+    };
+}
 function getPBRCommonProps(manager) {
+    const supportsSSSThicknessAuthoring = function() {
+        return !this.$isInstance && !!(this.transmission || this.subsurfaceProfile);
+    };
     return defineProps([
         {
             name: 'IOR',
@@ -56,11 +291,14 @@ function getPBRCommonProps(manager) {
             set (value) {
                 this.occlusionStrength = value.num[0];
             },
+            isHidden: createBlueprintOutputHiddenPredicate(),
             isValid () {
                 return !this.$isInstance && !!this.occlusionTexture;
             }
         },
-        ...getTextureProps(manager, 'occlusionTexture', '2D', false, 0),
+        ...getTextureProps(manager, 'occlusionTexture', '2D', false, 0, undefined, [
+            'AO'
+        ]),
         {
             name: 'EmissiveColor',
             description: 'Base self-illumination color emitted by the material',
@@ -76,6 +314,7 @@ function getPBRCommonProps(manager) {
             set (value) {
                 this.emissiveColor = new Vector3(value.num[0], value.num[1], value.num[2]);
             },
+            isHidden: createBlueprintOutputHiddenPredicate(),
             getDefaultValue () {
                 return this.$isInstance ? this.coreMaterial.emissiveColor : [
                     0,
@@ -99,12 +338,36 @@ function getPBRCommonProps(manager) {
             set (value) {
                 this.emissiveStrength = value.num[0];
             },
+            isHidden: createBlueprintOutputHiddenPredicate(),
             getDefaultValue () {
                 return this.$isInstance ? this.coreMaterial.emissiveStrength : 1;
             }
         },
-        ...getTextureProps(manager, 'emissiveTexture', '2D', true, 0),
-        ...getTextureProps(manager, 'specularTexture', '2D', false, 0),
+        {
+            name: 'RectSpecularScale',
+            type: 'float',
+            options: {
+                label: 'RectSpecularScale',
+                animatable: true,
+                minValue: 0,
+                maxValue: 4
+            },
+            get (value) {
+                value.num[0] = this.rectSpecularScale;
+            },
+            set (value) {
+                this.rectSpecularScale = value.num[0];
+            },
+            getDefaultValue () {
+                return this.$isInstance ? this.coreMaterial.rectSpecularScale : 1;
+            }
+        },
+        ...getTextureProps(manager, 'emissiveTexture', '2D', true, 0, undefined, [
+            'Emissive'
+        ]),
+        ...getTextureProps(manager, 'specularTexture', '2D', false, 0, undefined, [
+            'SpecularWeight'
+        ]),
         {
             name: 'Transmission',
             description: 'If true, enables light transmission through the material',
@@ -139,11 +402,11 @@ function getPBRCommonProps(manager) {
                 this.transmissionFactor = value.num[0];
             },
             isValid () {
-                return !this.$isInstance && !!this.transmission;
+                return supportsSSSThicknessAuthoring.call(this);
             }
         },
         ...getTextureProps(manager, 'transmissionTexture', '2D', false, 1, function() {
-            return this.transmission;
+            return this.transmission || !!this.subsurfaceProfile;
         }),
         {
             name: 'ThicknessFactor',
@@ -163,11 +426,11 @@ function getPBRCommonProps(manager) {
                 this.thicknessFactor = value.num[0];
             },
             isValid () {
-                return !this.$isInstance && !!this.transmission;
+                return supportsSSSThicknessAuthoring.call(this);
             }
         },
         ...getTextureProps(manager, 'thicknessTexture', '2D', false, 1, function() {
-            return this.transmission;
+            return this.transmission || !!this.subsurfaceProfile;
         }),
         {
             name: 'AttenuationColor',
@@ -191,7 +454,7 @@ function getPBRCommonProps(manager) {
                 this.attenuationColor = new Vector3(value.num[0], value.num[1], value.num[2]);
             },
             isValid () {
-                return !this.$isInstance && !!this.transmission;
+                return supportsSSSThicknessAuthoring.call(this);
             }
         },
         {
@@ -212,7 +475,7 @@ function getPBRCommonProps(manager) {
                 this.attenuationDistance = value.num[0];
             },
             isValid () {
-                return !this.$isInstance && !!this.transmission;
+                return supportsSSSThicknessAuthoring.call(this);
             }
         },
         {
@@ -486,6 +749,7 @@ function getLitMaterialProps(manager) {
             set (value) {
                 this.vertexNormal = value.bool[0];
             },
+            isHidden: createBlueprintOutputHiddenPredicate(),
             isValid () {
                 return !this.$isInstance;
             }
@@ -501,11 +765,14 @@ function getLitMaterialProps(manager) {
             set (value) {
                 this.vertexTangent = value.bool[0];
             },
+            isHidden: createBlueprintOutputHiddenPredicate(),
             isValid () {
                 return !this.$isInstance && !!this.vertexNormal;
             }
         },
-        ...getTextureProps(manager, 'normalTexture', '2D', false, 0)
+        ...getTextureProps(manager, 'normalTexture', '2D', false, 0, undefined, [
+            'Normal'
+        ])
     ]);
 }
 function getUnlitMaterialProps(manager) {
@@ -521,6 +788,7 @@ function getUnlitMaterialProps(manager) {
             set (value) {
                 this.vertexColor = value.bool[0];
             },
+            isHidden: createBlueprintOutputHiddenPredicate(),
             isValid () {
                 return !this.$isInstance;
             }
@@ -542,6 +810,7 @@ function getUnlitMaterialProps(manager) {
             set (value) {
                 this.albedoColor = new Vector4(value.num[0], value.num[1], value.num[2], value.num[3]);
             },
+            isHidden: createBlueprintOutputHiddenPredicate(),
             getDefaultValue () {
                 return this.$isInstance ? this.coreMaterial.albedoColor : [
                     1,
@@ -551,589 +820,926 @@ function getUnlitMaterialProps(manager) {
                 ];
             }
         },
-        ...getTextureProps(manager, 'albedoTexture', '2D', true, 0)
+        ...getTextureProps(manager, 'albedoTexture', '2D', true, 0, undefined, [
+            'BaseColor',
+            'Opacity'
+        ])
     ]);
 }
-/** @internal */ function getMeshMaterialClass() {
-    return [
+function getMToonMaterialProps(manager) {
+    return defineProps([
         {
-            ctor: MeshMaterial,
-            name: 'MeshMaterial',
-            getProps () {
-                return defineProps([
-                    {
-                        name: 'AlphaCutoff',
-                        description: 'If greater then 0, pixels which have alpha smaller than alpha cutoff will be discarded',
-                        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',
-                        description: 'If true, alpha-to-coverage will be enabled',
-                        type: 'bool',
-                        default: false,
-                        get (value) {
-                            value.bool[0] = this.alphaToCoverage;
-                        },
-                        set (value) {
-                            this.alphaToCoverage = value.bool[0];
-                        },
-                        isValid () {
-                            return !this.$isInstance;
-                        }
-                    },
-                    {
-                        name: 'AlphaDither',
-                        description: 'If true, alpha-dithering will be enabled',
-                        type: 'bool',
-                        default: false,
-                        get (value) {
-                            value.bool[0] = this.alphaDither;
-                        },
-                        set (value) {
-                            this.alphaDither = value.bool[0];
-                        },
-                        isValid () {
-                            return !this.$isInstance && this.alphaCutoff > 0;
-                        }
-                    },
-                    {
-                        name: 'BlendMode',
-                        description: 'Blending mode for this material',
-                        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',
-                        description: 'Cull mode for this material',
-                        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',
-                        description: 'Opacity value for this material, no effect if blendingMode is `none`',
-                        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',
-                        description: 'TAA strength for this material',
-                        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;
-                        }
-                    }
-                ]);
+            name: 'AlbedoColor',
+            description: 'Base RGBA color of the MToon material',
+            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
+                ];
             }
         },
-        getMeshMaterialInstanceUniformsClass(MeshMaterial)
-    ];
-}
-/** @internal */ function getSpriteMaterialClass(_manager) {
-    return [
+        ...getTextureProps(manager, 'albedoTexture', '2D', true, 0),
         {
-            ctor: SpriteMaterial,
-            name: 'SpriteMaterial',
-            parent: MeshMaterial,
-            getProps () {
-                return [];
+            name: 'NormalScale',
+            description: 'Scalar applied to the MToon normal texture',
+            type: 'float',
+            phase: 1,
+            default: 1,
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 2
+            },
+            get (value) {
+                value.num[0] = this.normalScale;
+            },
+            set (value) {
+                this.normalScale = value.num[0];
+            },
+            isValid () {
+                return !this.$isInstance && !!this.normalTexture;
             }
         },
-        getMeshMaterialInstanceUniformsClass(SpriteMaterial)
-    ];
-}
-/** @internal */ function getStandardSpriteMaterialClass(manager) {
-    return [
+        ...getTextureProps(manager, 'normalTexture', '2D', false, 0),
         {
-            ctor: StandardSpriteMaterial,
-            name: 'StandardSpriteMaterial',
-            parent: SpriteMaterial,
-            getProps () {
-                return defineProps([
-                    {
-                        name: 'SpriteTexture',
-                        description: 'Texture file path for the sprite',
-                        type: 'object',
-                        default: '',
-                        options: {
-                            mimeTypes: [
-                                'image/jpeg',
-                                'image/png',
-                                'image/tga',
-                                'image/vnd.radiance',
-                                'image/x-dds',
-                                'image/webp'
-                            ]
-                        },
-                        isNullable () {
-                            return true;
-                        },
-                        get (value) {
-                            value.str[0] = manager.getAssetId(this.spriteTexture) ?? '';
-                        },
-                        async set (value) {
-                            if (!value || !value.str[0]) {
-                                this.spriteTexture = null;
-                            } else {
-                                const assetId = value.str[0];
-                                let tex;
-                                try {
-                                    tex = await manager.fetchTexture(assetId, {
-                                        linearColorSpace: false
-                                    });
-                                } catch (err) {
-                                    console.error(`Load asset failed: ${value.str[0]}: ${err}`);
-                                    tex = null;
-                                }
-                                if (tex?.isTexture2D()) {
-                                    this.spriteTexture = tex;
-                                } else {
-                                    console.error('Invalid texture type');
-                                }
-                            }
-                        },
-                        isValid () {
-                            return !this.$isInstance;
-                        }
-                    }
-                ]);
+            name: 'DoubleSidedLighting',
+            description: 'If true, MToon lighting is evaluated on both sides of the surface',
+            type: 'bool',
+            default: true,
+            get (value) {
+                value.bool[0] = this.doubleSidedLighting;
+            },
+            set (value) {
+                this.doubleSidedLighting = value.bool[0];
             }
         },
-        getMeshMaterialInstanceUniformsClass(StandardSpriteMaterial)
-    ];
-}
-/** @internal */ function getParticleMaterialClass(manager) {
-    return [
         {
-            ctor: ParticleMaterial,
-            name: 'ParticleMaterial',
-            parent: MeshMaterial,
-            getProps () {
-                return defineProps([
-                    {
-                        name: 'AlphaMap',
-                        description: 'Alpha texture file path',
-                        type: 'object',
-                        default: '',
-                        options: {
-                            mimeTypes: [
-                                'image/jpeg',
-                                'image/png',
-                                'image/tga',
-                                'image/vnd.radiance',
-                                'image/x-dds',
-                                'image/webp'
-                            ]
-                        },
-                        isNullable () {
-                            return true;
-                        },
-                        get (value) {
-                            value.str[0] = manager.getAssetId(this.alphaMap) ?? '';
-                        },
-                        async set (value) {
-                            if (!value || !value.str[0]) {
-                                this.alphaMap = null;
-                            } else {
-                                const assetId = value.str[0];
-                                let tex = null;
-                                try {
-                                    tex = await manager.fetchTexture(assetId, {
-                                        linearColorSpace: true
-                                    });
-                                } 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',
-                        description: 'Ramp texture file path',
-                        type: 'object',
-                        default: '',
-                        options: {
-                            mimeTypes: [
-                                'image/jpeg',
-                                'image/png',
-                                'image/tga',
-                                'image/vnd.radiance',
-                                'image/x-dds',
-                                'image/webp'
-                            ]
-                        },
-                        isNullable () {
-                            return true;
-                        },
-                        get (value) {
-                            value.str[0] = manager.getAssetId(this.rampMap) ?? '';
-                        },
-                        async set (value) {
-                            if (!value || !value.str[0]) {
-                                this.rampMap = null;
-                            } else {
-                                const assetId = value.str[0];
-                                let tex = null;
-                                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');
-                                }
-                            }
-                        }
-                    }
-                ]);
+            name: 'EmissiveColor',
+            description: 'Base self-illumination color emitted by the MToon material',
+            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',
+            description: 'Intensity multiplier for the MToon emissive color and texture',
+            type: 'float',
+            default: 1,
+            options: {
+                animatable: true,
+                minValue: 0
+            },
+            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', true, 0),
+        {
+            name: 'ShadeColorFactor',
+            description: 'MToon shadow-side color factor',
+            type: 'rgb',
+            default: [
+                0,
+                0,
+                0
+            ],
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 1
+            },
+            get (value) {
+                value.num[0] = this.shadeColorFactor.x;
+                value.num[1] = this.shadeColorFactor.y;
+                value.num[2] = this.shadeColorFactor.z;
+            },
+            set (value) {
+                this.shadeColorFactor = new Vector3(value.num[0], value.num[1], value.num[2]);
+            },
+            getDefaultValue () {
+                return this.$isInstance ? this.coreMaterial.shadeColorFactor : [
+                    0,
+                    0,
+                    0
+                ];
+            }
+        },
+        ...getTextureProps(manager, 'shadeMultiplyTexture', '2D', true, 0),
+        {
+            name: 'ShadingShiftFactor',
+            description: 'MToon terminator shift factor',
+            type: 'float',
+            default: 0,
+            options: {
+                animatable: true,
+                minValue: -1,
+                maxValue: 1
+            },
+            get (value) {
+                value.num[0] = this.shadingShiftFactor;
+            },
+            set (value) {
+                this.shadingShiftFactor = value.num[0];
+            },
+            getDefaultValue () {
+                return this.$isInstance ? this.coreMaterial.shadingShiftFactor : 0;
+            }
+        },
+        {
+            name: 'ShadingShiftTextureScale',
+            description: 'Scale applied to the MToon shading shift texture',
+            type: 'float',
+            phase: 1,
+            default: 1,
+            options: {
+                animatable: true
+            },
+            get (value) {
+                value.num[0] = this.shadingShiftTextureScale;
+            },
+            set (value) {
+                this.shadingShiftTextureScale = value.num[0];
+            },
+            isValid () {
+                return !this.$isInstance && !!this.shadingShiftTexture;
+            }
+        },
+        ...getTextureProps(manager, 'shadingShiftTexture', '2D', false, 0),
+        {
+            name: 'ShadingToonyFactor',
+            description: 'MToon shadow edge sharpness factor',
+            type: 'float',
+            default: 0.9,
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 0.99
+            },
+            get (value) {
+                value.num[0] = this.shadingToonyFactor;
+            },
+            set (value) {
+                this.shadingToonyFactor = value.num[0];
+            },
+            getDefaultValue () {
+                return this.$isInstance ? this.coreMaterial.shadingToonyFactor : 0.9;
+            }
+        },
+        {
+            name: 'GIEqualizationFactor',
+            description: 'MToon indirect lighting equalization factor',
+            type: 'float',
+            default: 0.9,
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 1
+            },
+            get (value) {
+                value.num[0] = this.giEqualizationFactor;
+            },
+            set (value) {
+                this.giEqualizationFactor = value.num[0];
+            },
+            getDefaultValue () {
+                return this.$isInstance ? this.coreMaterial.giEqualizationFactor : 0.9;
+            }
+        },
+        {
+            name: 'MatcapFactor',
+            description: 'MToon matcap color factor',
+            type: 'rgb',
+            default: [
+                1,
+                1,
+                1
+            ],
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 1
+            },
+            get (value) {
+                value.num[0] = this.matcapFactor.x;
+                value.num[1] = this.matcapFactor.y;
+                value.num[2] = this.matcapFactor.z;
+            },
+            set (value) {
+                this.matcapFactor = new Vector3(value.num[0], value.num[1], value.num[2]);
+            },
+            getDefaultValue () {
+                return this.$isInstance ? this.coreMaterial.matcapFactor : [
+                    1,
+                    1,
+                    1
+                ];
+            }
+        },
+        ...getTextureProps(manager, 'matcapTexture', '2D', true, 0),
+        {
+            name: 'ParametricRimColorFactor',
+            description: 'MToon parametric rim color factor',
+            type: 'rgb',
+            default: [
+                0,
+                0,
+                0
+            ],
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 1
+            },
+            get (value) {
+                value.num[0] = this.parametricRimColorFactor.x;
+                value.num[1] = this.parametricRimColorFactor.y;
+                value.num[2] = this.parametricRimColorFactor.z;
+            },
+            set (value) {
+                this.parametricRimColorFactor = new Vector3(value.num[0], value.num[1], value.num[2]);
+            },
+            getDefaultValue () {
+                return this.$isInstance ? this.coreMaterial.parametricRimColorFactor : [
+                    0,
+                    0,
+                    0
+                ];
+            }
+        },
+        {
+            name: 'ParametricRimFresnelPowerFactor',
+            description: 'MToon parametric rim Fresnel power factor',
+            type: 'float',
+            default: 5,
+            options: {
+                animatable: true,
+                minValue: 0
+            },
+            get (value) {
+                value.num[0] = this.parametricRimFresnelPowerFactor;
+            },
+            set (value) {
+                this.parametricRimFresnelPowerFactor = value.num[0];
+            },
+            getDefaultValue () {
+                return this.$isInstance ? this.coreMaterial.parametricRimFresnelPowerFactor : 5;
+            }
+        },
+        {
+            name: 'ParametricRimLiftFactor',
+            description: 'MToon parametric rim lift factor',
+            type: 'float',
+            default: 0,
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 1
+            },
+            get (value) {
+                value.num[0] = this.parametricRimLiftFactor;
+            },
+            set (value) {
+                this.parametricRimLiftFactor = value.num[0];
+            },
+            getDefaultValue () {
+                return this.$isInstance ? this.coreMaterial.parametricRimLiftFactor : 0;
+            }
+        },
+        {
+            name: 'RimLightingMixFactor',
+            description: 'MToon rim lighting mix factor',
+            type: 'float',
+            default: 1,
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 1
+            },
+            get (value) {
+                value.num[0] = this.rimLightingMixFactor;
+            },
+            set (value) {
+                this.rimLightingMixFactor = value.num[0];
+            },
+            getDefaultValue () {
+                return this.$isInstance ? this.coreMaterial.rimLightingMixFactor : 1;
+            }
+        },
+        ...getTextureProps(manager, 'rimMultiplyTexture', '2D', true, 0),
+        {
+            name: 'OutlineWidthMode',
+            description: 'MToon outline width mode',
+            type: 'string',
+            default: 'none',
+            options: {
+                enum: {
+                    labels: [
+                        'None',
+                        'World Coordinates',
+                        'Screen Coordinates'
+                    ],
+                    values: [
+                        'none',
+                        'worldCoordinates',
+                        'screenCoordinates'
+                    ]
+                }
+            },
+            get (value) {
+                value.str[0] = this.outlineWidthMode;
+            },
+            set (value) {
+                this.outlineWidthMode = value.str[0];
+            },
+            isValid () {
+                return !this.$isInstance;
+            }
+        },
+        {
+            name: 'OutlineWidthFactor',
+            description: 'MToon outline width factor',
+            type: 'float',
+            default: 0,
+            options: {
+                animatable: true,
+                minValue: 0
+            },
+            get (value) {
+                value.num[0] = this.outlineWidthFactor;
+            },
+            set (value) {
+                this.outlineWidthFactor = value.num[0];
+            },
+            isValid () {
+                return !this.$isInstance && this.outlineWidthMode !== 'none';
+            }
+        },
+        ...getTextureProps(manager, 'outlineWidthMultiplyTexture', '2D', false, 1, function() {
+            return this.outlineWidthMode !== 'none';
+        }),
+        {
+            name: 'OutlineColorFactor',
+            description: 'MToon outline color factor',
+            type: 'rgb',
+            default: [
+                0,
+                0,
+                0
+            ],
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 1
+            },
+            get (value) {
+                value.num[0] = this.outlineColorFactor.x;
+                value.num[1] = this.outlineColorFactor.y;
+                value.num[2] = this.outlineColorFactor.z;
+            },
+            set (value) {
+                this.outlineColorFactor = new Vector3(value.num[0], value.num[1], value.num[2]);
+            },
+            isValid () {
+                return !this.$isInstance && this.outlineWidthMode !== 'none';
+            }
+        },
+        {
+            name: 'OutlineLightingMixFactor',
+            description: 'MToon outline lighting mix factor',
+            type: 'float',
+            default: 1,
+            options: {
+                animatable: true,
+                minValue: 0,
+                maxValue: 1
+            },
+            get (value) {
+                value.num[0] = this.outlineLightingMixFactor;
+            },
+            set (value) {
+                this.outlineLightingMixFactor = value.num[0];
+            },
+            isValid () {
+                return !this.$isInstance && this.outlineWidthMode !== 'none';
+            }
+        },
+        {
+            name: 'OutlineUsesTangentNormals',
+            description: 'Use the tangent attribute xyz as smooth normals for MToon outline expansion',
+            type: 'boolean',
+            default: false,
+            get (value) {
+                value.bool[0] = this.outlineUsesTangentNormals;
+            },
+            set (value) {
+                this.outlineUsesTangentNormals = value.bool[0];
+            },
+            isValid () {
+                return !this.$isInstance && this.outlineWidthMode !== 'none';
+            }
+        },
+        ...getTextureProps(manager, 'uvAnimationMaskTexture', '2D', false, 0),
+        {
+            name: 'UVAnimationScrollXSpeedFactor',
+            description: 'MToon UV animation scroll speed on the X axis',
+            type: 'float',
+            default: 0,
+            options: {
+                animatable: true
+            },
+            get (value) {
+                value.num[0] = this.uvAnimationScrollXSpeedFactor;
+            },
+            set (value) {
+                this.uvAnimationScrollXSpeedFactor = value.num[0];
+            },
+            getDefaultValue () {
+                return this.$isInstance ? this.coreMaterial.uvAnimationScrollXSpeedFactor : 0;
+            }
+        },
+        {
+            name: 'UVAnimationScrollYSpeedFactor',
+            description: 'MToon UV animation scroll speed on the Y axis',
+            type: 'float',
+            default: 0,
+            options: {
+                animatable: true
+            },
+            get (value) {
+                value.num[0] = this.uvAnimationScrollYSpeedFactor;
+            },
+            set (value) {
+                this.uvAnimationScrollYSpeedFactor = value.num[0];
+            },
+            getDefaultValue () {
+                return this.$isInstance ? this.coreMaterial.uvAnimationScrollYSpeedFactor : 0;
             }
         },
-        getMeshMaterialInstanceUniformsClass(ParticleMaterial)
-    ];
+        {
+            name: 'UVAnimationRotationSpeedFactor',
+            description: 'MToon UV animation rotation speed',
+            type: 'float',
+            default: 0,
+            options: {
+                animatable: true
+            },
+            get (value) {
+                value.num[0] = this.uvAnimationRotationSpeedFactor;
+            },
+            set (value) {
+                this.uvAnimationRotationSpeedFactor = value.num[0];
+            },
+            getDefaultValue () {
+                return this.$isInstance ? this.coreMaterial.uvAnimationRotationSpeedFactor : 0;
+            }
+        },
+        {
+            name: 'TransparentWithZWrite',
+            description: 'If true, transparent MToon pixels also write depth',
+            type: 'bool',
+            default: false,
+            get (value) {
+                value.bool[0] = this.transparentWithZWrite;
+            },
+            set (value) {
+                this.transparentWithZWrite = value.bool[0];
+            },
+            isValid () {
+                return !this.$isInstance;
+            }
+        },
+        {
+            name: 'RenderQueueOffsetNumber',
+            description: 'MToon render queue offset number',
+            type: 'int',
+            default: 0,
+            options: {
+                minValue: -9,
+                maxValue: 9
+            },
+            get (value) {
+                value.num[0] = this.renderQueueOffsetNumber;
+            },
+            set (value) {
+                this.renderQueueOffsetNumber = value.num[0];
+            },
+            isValid () {
+                return !this.$isInstance;
+            }
+        }
+    ]);
 }
-/** @internal */ function getPBRBluePrintMaterialClass() {
+/** @internal */ function getMeshMaterialClass() {
     return [
         {
-            ctor: PBRBluePrintMaterial,
-            parent: MeshMaterial,
-            name: 'PBRBluePrintMaterial',
+            ctor: MeshMaterial,
+            name: 'MeshMaterial',
             getProps () {
                 return defineProps([
                     {
-                        name: 'doubleSidedLighting',
-                        description: 'If true, double-sided lighting will be enabled',
+                        name: 'AlphaCutoff',
+                        description: 'If greater then 0, pixels which have alpha smaller than alpha cutoff will be discarded',
+                        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',
+                        description: 'If true, alpha-to-coverage will be enabled',
                         type: 'bool',
                         default: false,
-                        isValid () {
-                            return !this.$isInstance && this.cullMode !== 'back';
+                        get (value) {
+                            value.bool[0] = this.alphaToCoverage;
+                        },
+                        set (value) {
+                            this.alphaToCoverage = value.bool[0];
                         },
+                        isValid () {
+                            return !this.$isInstance;
+                        }
+                    },
+                    {
+                        name: 'AlphaDither',
+                        description: 'If true, alpha-dithering will be enabled',
+                        type: 'bool',
+                        default: false,
                         get (value) {
-                            value.bool[0] = this.doubleSidedLighting;
+                            value.bool[0] = this.alphaDither;
                         },
                         set (value) {
-                            this.doubleSidedLighting = value.bool[0];
+                            this.alphaDither = value.bool[0];
+                        },
+                        isValid () {
+                            return !this.$isInstance && this.alphaCutoff > 0;
                         }
                     },
                     {
-                        name: 'Reflection',
-                        description: 'Reflection mode for the material',
+                        name: 'BlendMode',
+                        description: 'Blending mode for this material',
                         type: 'string',
-                        default: 'ggx',
                         options: {
                             enum: {
                                 labels: [
                                     'None',
-                                    'GGX',
-                                    'Anisotropic',
-                                    'Glint'
+                                    'Blend',
+                                    'Additive'
                                 ],
                                 values: [
                                     'none',
-                                    'ggx',
-                                    'anisotropic',
-                                    'glint'
+                                    'blend',
+                                    'additive'
                                 ]
                             }
                         },
+                        default: 'none',
                         get (value) {
-                            value.str[0] = this.reflectionMode;
+                            value.str[0] = this.blendMode;
                         },
                         set (value) {
-                            this.reflectionMode = value.str[0];
+                            this.blendMode = value.str[0];
                         },
-                        getDefaultValue () {
-                            return this.$isInstance ? this.coreMaterial.reflectionMode : 'ggx';
+                        isValid () {
+                            return !this.$isInstance;
                         }
                     },
                     {
-                        name: 'SubsurfaceScattering',
-                        description: 'If true, subsurface-scattering will be enabled',
+                        name: 'TransparentShadowCaster',
                         type: 'bool',
-                        phase: 0,
                         default: false,
                         get (value) {
-                            value.bool[0] = this.subsurfaceScattering;
+                            value.bool[0] = this.transparentShadowCaster;
                         },
                         set (value) {
-                            this.subsurfaceScattering = value.bool[0];
+                            this.transparentShadowCaster = value.bool[0];
                         },
                         isValid () {
-                            return !this.$isInstance;
+                            return !this.$isInstance && this.blendMode !== 'none';
                         }
                     },
                     {
-                        name: 'SubsurfaceColor',
-                        description: 'Subsurface-scattering color',
-                        type: 'rgb',
-                        phase: 1,
-                        default: [
-                            1,
-                            0.3,
-                            0.2
-                        ],
+                        name: 'ShadowAlphaCutoff',
+                        type: 'float',
+                        default: 0.5,
                         options: {
-                            animatable: true
+                            animatable: true,
+                            minValue: 0,
+                            maxValue: 1
                         },
                         get (value) {
-                            value.num[0] = this.subsurfaceColor.x;
-                            value.num[1] = this.subsurfaceColor.y;
-                            value.num[2] = this.subsurfaceColor.z;
+                            value.num[0] = this.shadowAlphaCutoff;
                         },
                         set (value) {
-                            this.subsurfaceColor = new Vector3(value.num[0], value.num[1], value.num[2]);
-                        },
-                        getDefaultValue () {
-                            return this.$isInstance ? this.coreMaterial.subsurfaceColor : [
-                                1,
-                                0.3,
-                                0.2
-                            ];
+                            this.shadowAlphaCutoff = value.num[0];
                         },
                         isValid () {
-                            return this.subsurfaceScattering;
+                            return !this.$isInstance && this.blendMode !== 'none' && this.transparentShadowCaster;
                         }
                     },
                     {
-                        name: 'SubsurfaceScale',
-                        description: 'Scale value for subsurface-scattering',
-                        type: 'float',
-                        phase: 1,
-                        default: 0.5,
+                        name: 'CullMode',
+                        description: 'Cull mode for this material',
+                        type: 'string',
                         options: {
-                            animatable: true,
-                            minValue: 0,
-                            maxValue: 8
+                            enum: {
+                                labels: [
+                                    'None',
+                                    'Front',
+                                    'Back'
+                                ],
+                                values: [
+                                    'none',
+                                    'front',
+                                    'back'
+                                ]
+                            }
                         },
+                        default: 'back',
                         get (value) {
-                            value.num[0] = this.subsurfaceScale;
+                            value.str[0] = this.cullMode;
                         },
                         set (value) {
-                            this.subsurfaceScale = value.num[0];
-                        },
-                        getDefaultValue () {
-                            return this.$isInstance ? this.coreMaterial.subsurfaceScale : 0.5;
+                            this.cullMode = value.str[0];
                         },
                         isValid () {
-                            return this.subsurfaceScattering;
+                            return !this.$isInstance;
                         }
                     },
                     {
-                        name: 'SubsurfacePower',
-                        description: 'Power value for subsurface-scattering',
+                        name: 'Opacity',
+                        description: 'Opacity value for this material, no effect if blendingMode is `none`',
                         type: 'float',
-                        phase: 1,
-                        default: 1.5,
                         options: {
                             animatable: true,
                             minValue: 0,
-                            maxValue: 16
+                            maxValue: 1
                         },
+                        default: 1,
                         get (value) {
-                            value.num[0] = this.subsurfacePower;
+                            value.num[0] = this.opacity;
                         },
                         set (value) {
-                            this.subsurfacePower = value.num[0];
+                            this.opacity = value.num[0];
                         },
+                        isHidden: createBlueprintOutputHiddenPredicate(),
                         getDefaultValue () {
-                            return this.$isInstance ? this.coreMaterial.subsurfacePower : 1.5;
-                        },
-                        isValid () {
-                            return this.subsurfaceScattering;
+                            return this.$isInstance ? this.coreMaterial.opacity : 1;
                         }
                     },
                     {
-                        name: 'SubsurfaceIntensity',
-                        description: 'Intensity value for subsurface-scattering',
+                        name: 'TAAStrength',
+                        description: 'TAA strength for this material',
                         type: 'float',
-                        phase: 1,
-                        default: 0.5,
                         options: {
-                            animatable: true,
                             minValue: 0,
-                            maxValue: 4
+                            maxValue: 1
                         },
+                        default: 15 / 16,
                         get (value) {
-                            value.num[0] = this.subsurfaceIntensity;
+                            value.num[0] = this.TAAStrength;
                         },
                         set (value) {
-                            this.subsurfaceIntensity = value.num[0];
-                        },
-                        getDefaultValue () {
-                            return this.$isInstance ? this.coreMaterial.subsurfaceIntensity : 0.5;
+                            this.TAAStrength = value.num[0];
                         },
                         isValid () {
-                            return this.subsurfaceScattering;
+                            return !this.$isInstance;
                         }
-                    },
+                    }
+                ]);
+            }
+        },
+        getMeshMaterialInstanceUniformsClass(MeshMaterial)
+    ];
+}
+/** @internal */ function getSpriteMaterialClass(_manager) {
+    return [
+        {
+            ctor: SpriteMaterial,
+            name: 'SpriteMaterial',
+            parent: MeshMaterial,
+            getProps () {
+                return [];
+            }
+        },
+        getMeshMaterialInstanceUniformsClass(SpriteMaterial)
+    ];
+}
+/** @internal */ function getStandardSpriteMaterialClass(manager) {
+    return [
+        {
+            ctor: StandardSpriteMaterial,
+            name: 'StandardSpriteMaterial',
+            parent: SpriteMaterial,
+            getProps () {
+                return defineProps([
                     {
-                        name: 'Anisotropy',
-                        description: 'Anistropy value',
-                        type: 'float',
-                        default: 0.75,
+                        name: 'SpriteTexture',
+                        description: 'Texture file path for the sprite',
+                        type: 'object',
+                        default: '',
                         options: {
-                            animatable: true,
-                            minValue: -0.95,
-                            maxValue: 0.95
+                            mimeTypes: [
+                                'image/jpeg',
+                                'image/png',
+                                'image/tga',
+                                'image/vnd.radiance',
+                                'image/x-dds',
+                                'image/webp'
+                            ]
                         },
-                        get (value) {
-                            value.num[0] = this.anisotropy;
+                        isNullable () {
+                            return true;
                         },
-                        set (value) {
-                            this.anisotropy = value.num[0];
+                        get (value) {
+                            value.str[0] = manager.getAssetId(this.spriteTexture) ?? '';
                         },
-                        getDefaultValue () {
-                            return this.$isInstance ? this.coreMaterial.anisotropy : 0.75;
+                        async set (value) {
+                            if (!value || !value.str[0]) {
+                                this.spriteTexture = null;
+                            } else {
+                                const assetId = value.str[0];
+                                let tex;
+                                try {
+                                    tex = await manager.fetchTexture(assetId, {
+                                        linearColorSpace: false
+                                    });
+                                } catch (err) {
+                                    console.error(`Load asset failed: ${value.str[0]}: ${err}`);
+                                    tex = null;
+                                }
+                                if (tex?.isTexture2D()) {
+                                    this.spriteTexture = tex;
+                                } else {
+                                    console.error('Invalid texture type');
+                                }
+                            }
                         },
                         isValid () {
-                            return this.reflectionMode === 'anisotropic';
+                            return !this.$isInstance;
                         }
-                    },
+                    }
+                ]);
+            }
+        },
+        getMeshMaterialInstanceUniformsClass(StandardSpriteMaterial)
+    ];
+}
+/** @internal */ function getParticleMaterialClass(manager) {
+    return [
+        {
+            ctor: ParticleMaterial,
+            name: 'ParticleMaterial',
+            parent: MeshMaterial,
+            getProps () {
+                return defineProps([
                     {
-                        name: 'AnisotropyDirection',
-                        description: 'Anisotropy direction',
-                        type: 'float',
-                        default: 0,
+                        name: 'AlphaMap',
+                        description: 'Alpha texture file path',
+                        type: 'object',
+                        default: '',
                         options: {
-                            animatable: true,
-                            minValue: 0,
-                            maxValue: 360
-                        },
-                        get (value) {
-                            value.num[0] = this.anisotropyDirection;
+                            mimeTypes: [
+                                'image/jpeg',
+                                'image/png',
+                                'image/tga',
+                                'image/vnd.radiance',
+                                'image/x-dds',
+                                'image/webp'
+                            ]
                         },
-                        set (value) {
-                            this.anisotropyDirection = value.num[0];
+                        isNullable () {
+                            return true;
                         },
-                        getDefaultValue () {
-                            return this.$isInstance ? this.coreMaterial.anisotropyDirection : 0;
+                        get (value) {
+                            value.str[0] = manager.getAssetId(this.alphaMap) ?? '';
                         },
-                        isValid () {
-                            return this.reflectionMode === 'anisotropic';
+                        async set (value) {
+                            if (!value || !value.str[0]) {
+                                this.alphaMap = null;
+                            } else {
+                                const assetId = value.str[0];
+                                let tex = null;
+                                try {
+                                    tex = await manager.fetchTexture(assetId, {
+                                        linearColorSpace: true
+                                    });
+                                } catch (err) {
+                                    console.error(`Load asset failed: ${value.str[0]}: ${err}`);
+                                }
+                                if (tex?.isTexture2D()) {
+                                    this.alphaMap = tex;
+                                } else {
+                                    console.error('Invalid albedo texture');
+                                }
+                            }
                         }
                     },
                     {
-                        name: 'AnisotropyDirectionScaleBias',
-                        description: 'Anisotropy direction scale bias',
-                        type: 'vec2',
-                        default: [
-                            1,
-                            0
-                        ],
+                        name: 'RampMap',
+                        description: 'Ramp texture file path',
+                        type: 'object',
+                        default: '',
                         options: {
-                            animatable: true
-                        },
-                        get (value) {
-                            value.num[0] = this.anisotropyDirectionScaleBias.x;
-                            value.num[1] = this.anisotropyDirectionScaleBias.y;
+                            mimeTypes: [
+                                'image/jpeg',
+                                'image/png',
+                                'image/tga',
+                                'image/vnd.radiance',
+                                'image/x-dds',
+                                'image/webp'
+                            ]
                         },
-                        set (value) {
-                            this.anisotropyDirectionScaleBias = new Vector2(value.num[0], value.num[1]);
+                        isNullable () {
+                            return true;
                         },
-                        getDefaultValue () {
-                            return this.$isInstance ? this.coreMaterial.anisotropyDirectionScaleBias : [
-                                1,
-                                0
-                            ];
+                        get (value) {
+                            value.str[0] = manager.getAssetId(this.rampMap) ?? '';
                         },
-                        isValid () {
-                            return this.reflectionMode === 'anisotropic';
+                        async set (value) {
+                            if (!value || !value.str[0]) {
+                                this.rampMap = null;
+                            } else {
+                                const assetId = value.str[0];
+                                let tex = null;
+                                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');
+                                }
+                            }
                         }
                     }
                 ]);
             }
         },
+        getMeshMaterialInstanceUniformsClass(ParticleMaterial)
+    ];
+}
+/** @internal */ function getPBRBluePrintMaterialClass() {
+    return [
+        {
+            ctor: PBRBluePrintMaterial,
+            parent: PBRMetallicRoughnessMaterial,
+            name: 'PBRBluePrintMaterial',
+            getProps () {
+                return defineProps([]);
+            }
+        },
         getMeshMaterialInstanceUniformsClass(PBRBluePrintMaterial)
     ];
 }
@@ -1163,6 +1769,19 @@ function getUnlitMaterialProps(manager) {
         getMeshMaterialInstanceUniformsClass(UnlitMaterial)
     ];
 }
+/** @internal */ function getMToonMaterialClass(manager) {
+    return [
+        {
+            ctor: MToonMaterial,
+            parent: MeshMaterial,
+            name: 'MToonMaterial',
+            getProps () {
+                return getMToonMaterialProps(manager);
+            }
+        },
+        getMeshMaterialInstanceUniformsClass(MToonMaterial)
+    ];
+}
 /** @internal */ function getLambertMaterialClass(manager) {
     return [
         {
@@ -1203,71 +1822,6 @@ function getUnlitMaterialProps(manager) {
                             return this.$isInstance ? this.coreMaterial.shininess : 32;
                         }
                     },
-                    {
-                        name: 'ScatterWrap',
-                        description: 'Scatter wrap for light warping',
-                        type: 'float',
-                        options: {
-                            animatable: true,
-                            minValue: 0,
-                            maxValue: 1
-                        },
-                        get (value) {
-                            value.num[0] = this.scatterWrap;
-                        },
-                        set (value) {
-                            this.scatterWrap = value.num[0];
-                        },
-                        getDefaultValue () {
-                            return this.$isInstance ? this.coreMaterial.scatterWrap : 0;
-                        }
-                    },
-                    {
-                        name: 'ScatterWidth',
-                        description: 'Scatter width for light wrapping',
-                        type: 'float',
-                        options: {
-                            animatable: true,
-                            minValue: 0,
-                            maxValue: 1
-                        },
-                        get (value) {
-                            value.num[0] = this.scatterWidth;
-                        },
-                        set (value) {
-                            this.scatterWidth = value.num[0];
-                        },
-                        getDefaultValue () {
-                            return this.$isInstance ? this.coreMaterial.scatterWidth : 0;
-                        }
-                    },
-                    {
-                        name: 'ScatterColor',
-                        description: 'Scatter color for light warping',
-                        type: 'rgb',
-                        options: {
-                            animatable: true
-                        },
-                        get (value) {
-                            value.num[0] = this.scatterColor.x;
-                            value.num[1] = this.scatterColor.y;
-                            value.num[2] = this.scatterColor.z;
-                        },
-                        set (value) {
-                            this.scatterColor = new Vector4(value.num[0], value.num[1], value.num[2], 1);
-                        },
-                        getDefaultValue () {
-                            return this.$isInstance ? [
-                                this.coreMaterial.scatterColor.x,
-                                this.coreMaterial.scatterColor.y,
-                                this.coreMaterial.scatterColor.z
-                            ] : [
-                                0,
-                                0,
-                                0
-                            ];
-                        }
-                    },
                     ...getLitMaterialProps(manager)
                 ]);
             }
@@ -1298,6 +1852,7 @@ function getUnlitMaterialProps(manager) {
                         set (value) {
                             this.metallic = value.num[0];
                         },
+                        isHidden: createBlueprintOutputHiddenPredicate(),
                         getDefaultValue () {
                             return this.$isInstance ? this.coreMaterial.metallic : 1;
                         }
@@ -1317,6 +1872,7 @@ function getUnlitMaterialProps(manager) {
                         set (value) {
                             this.roughness = value.num[0];
                         },
+                        isHidden: createBlueprintOutputHiddenPredicate(),
                         getDefaultValue () {
                             return this.$isInstance ? this.coreMaterial.roughness : 1;
                         }
@@ -1337,6 +1893,7 @@ function getUnlitMaterialProps(manager) {
                         set (value) {
                             this.specularFactor = new Vector4(value.num[0], value.num[1], value.num[2], value.num[3]);
                         },
+                        isHidden: createBlueprintOutputHiddenPredicate(),
                         getDefaultValue () {
                             return this.$isInstance ? this.coreMaterial.specularFactor : [
                                 1,
@@ -1455,130 +2012,39 @@ function getUnlitMaterialProps(manager) {
                         }
                     },
                     {
-                        name: 'SubsurfaceScattering',
+                        name: 'SubsurfaceProfile',
                         description: 'If true, enables subsurface scattering for translucent materials',
-                        type: 'bool',
-                        phase: 0,
-                        default: false,
-                        get (value) {
-                            value.bool[0] = this.subsurfaceScattering;
-                        },
-                        set (value) {
-                            this.subsurfaceScattering = value.bool[0];
-                        },
-                        isValid () {
-                            return !this.$isInstance;
-                        }
-                    },
-                    {
-                        name: 'SubsurfaceColor',
-                        description: 'Color tint of the subsurface scattering effect',
-                        type: 'rgb',
-                        phase: 1,
-                        default: [
-                            1,
-                            0.3,
-                            0.2
-                        ],
-                        options: {
-                            animatable: true
-                        },
-                        get (value) {
-                            value.num[0] = this.subsurfaceColor.x;
-                            value.num[1] = this.subsurfaceColor.y;
-                            value.num[2] = this.subsurfaceColor.z;
-                        },
-                        set (value) {
-                            this.subsurfaceColor = new Vector3(value.num[0], value.num[1], value.num[2]);
-                        },
-                        getDefaultValue () {
-                            return this.$isInstance ? this.coreMaterial.subsurfaceColor : [
-                                1,
-                                0.3,
-                                0.2
-                            ];
-                        },
-                        isValid () {
-                            return this.subsurfaceScattering;
-                        }
-                    },
-                    {
-                        name: 'SubsurfaceScale',
-                        description: 'Distance scale of the subsurface scattering effect',
-                        type: 'float',
-                        phase: 1,
-                        default: 0.5,
-                        options: {
-                            animatable: true,
-                            minValue: 0,
-                            maxValue: 8
-                        },
-                        get (value) {
-                            value.num[0] = this.subsurfaceScale;
-                        },
-                        set (value) {
-                            this.subsurfaceScale = value.num[0];
-                        },
-                        getDefaultValue () {
-                            return this.$isInstance ? this.coreMaterial.subsurfaceScale : 0.5;
-                        },
-                        isValid () {
-                            return this.subsurfaceScattering;
-                        }
-                    },
-                    {
-                        name: 'SubsurfacePower',
-                        description: 'Falloff power controlling how quickly subsurface scattering fades',
-                        type: 'float',
+                        type: 'object',
                         phase: 1,
-                        default: 1.5,
+                        default: null,
                         options: {
-                            animatable: true,
-                            minValue: 0,
-                            maxValue: 16
-                        },
-                        get (value) {
-                            value.num[0] = this.subsurfacePower;
-                        },
-                        set (value) {
-                            this.subsurfacePower = value.num[0];
-                        },
-                        getDefaultValue () {
-                            return this.$isInstance ? this.coreMaterial.subsurfacePower : 1.5;
+                            objectTypes: [
+                                SubsurfaceProfile
+                            ]
                         },
-                        isValid () {
-                            return this.subsurfaceScattering;
-                        }
-                    },
-                    {
-                        name: 'SubsurfaceIntensity',
-                        description: 'Overall intensity of the subsurface scattering effect',
-                        type: 'float',
-                        phase: 1,
-                        default: 0.5,
-                        options: {
-                            animatable: true,
-                            minValue: 0,
-                            maxValue: 4
+                        isNullable () {
+                            return true;
                         },
                         get (value) {
-                            value.num[0] = this.subsurfaceIntensity;
+                            value.object[0] = this.subsurfaceProfile;
                         },
                         set (value) {
-                            this.subsurfaceIntensity = value.num[0];
-                        },
-                        getDefaultValue () {
-                            return this.$isInstance ? this.coreMaterial.subsurfaceIntensity : 0.5;
+                            this.subsurfaceProfile = value.object[0] ?? null;
                         },
                         isValid () {
-                            return this.subsurfaceScattering;
+                            return !this.$isInstance;
                         }
                     },
                     ...getTextureProps(manager, 'subsurfaceTexture', '2D', false, 1, function() {
-                        return this.subsurfaceScattering;
+                        return !!this.subsurfaceProfile;
                     }),
-                    ...getTextureProps(manager, 'metallicRoughnessTexture', '2D', false, 0),
-                    ...getTextureProps(manager, 'specularColorTexture', '2D', true, 0),
+                    ...getTextureProps(manager, 'metallicRoughnessTexture', '2D', false, 0, undefined, [
+                        'Metallic',
+                        'Roughness'
+                    ]),
+                    ...getTextureProps(manager, 'specularColorTexture', '2D', true, 0, undefined, [
+                        'Specular'
+                    ]),
                     ...getPBRCommonProps(manager)
                 ]);
             }
@@ -1644,5 +2110,5 @@ function getUnlitMaterialProps(manager) {
     ];
 }
 
-export { getBlinnMaterialClass, getLambertMaterialClass, getMeshMaterialClass, getPBRBluePrintMaterialClass, getPBRMetallicRoughnessMaterialClass, getPBRSpecularGlossinessMaterialClass, getParticleMaterialClass, getSpriteBlueprintMaterialClass, getSpriteMaterialClass, getStandardSpriteMaterialClass, getUnlitMaterialClass };
+export { getBlinnMaterialClass, getLambertMaterialClass, getMToonMaterialClass, getMeshMaterialClass, getPBRBluePrintMaterialClass, getPBRMetallicRoughnessMaterialClass, getPBRSpecularGlossinessMaterialClass, getParticleMaterialClass, getSpriteBlueprintMaterialClass, getSpriteMaterialClass, getStandardSpriteMaterialClass, getSubsurfaceProfileClass, getUnlitMaterialClass };
 //# sourceMappingURL=material.js.map