@luminocity/lemonate-engine 15.2.2 → 15.2.3

package/dist/items/MaterialItem.js

@@ -1,1762 +0,0 @@
-// -----------------------------------------------------------------------------------------------------------
-//  __         ______     __    __     ______     __   __     ______     ______   ______
-// /\ \       /\  ___\   /\ "-./  \   /\  __ \   /\ "-.\ \   /\  __ \   /\__  _\ /\  ___\
-// \ \ \____  \ \  __\   \ \ \-./\ \  \ \ \/\ \  \ \ \-.  \  \ \  __ \  \/_/\ \/ \ \  __\
-//  \ \_____\  \ \_____\  \ \_\ \ \_\  \ \_____\  \ \_\\"\_\  \ \_\ \_\    \ \_\  \ \_____\
-//   \/_____/   \/_____/   \/_/  \/_/   \/_____/   \/_/ \/_/   \/_/\/_/     \/_/   \/_____/
-//
-//
-// Copyright 2023- Luminocity AG
-//
-// "Hadouken!" - Street Fighter series (1987–)
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this software
-// and associated documentation files (the “Software”), to deal in the Software without restriction,
-// including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
-// and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
-// subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all copies or substantial
-// portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
-// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-// -----------------------------------------------------------------------------------------------------------
-import { ImageOwningItem } from './base/ImageOwningItem';
-import { MeshPhysicalMaterial, ShaderMaterial, PointsMaterial, MeshBasicMaterial, MeshNormalMaterial, MeshToonMaterial, MeshMatcapMaterial, MeshLambertMaterial, MeshPhongMaterial, ObjectSpaceNormalMap, TangentSpaceNormalMap, MultiplyOperation, MixOperation, AddOperation, Vector2, NoBlending, NormalBlending, AdditiveBlending, SubtractiveBlending, MultiplyBlending, CustomBlending, FrontSide, BackSide, DoubleSide, NeverDepth, AlwaysDepth, LessDepth, LessEqualDepth, GreaterEqualDepth, GreaterDepth, NotEqualDepth, AddEquation, SubtractEquation, ReverseSubtractEquation, MinEquation, MaxEquation, ZeroFactor, OneFactor, SrcColorFactor, OneMinusSrcColorFactor, SrcAlphaFactor, OneMinusSrcAlphaFactor, DstAlphaFactor, OneMinusDstAlphaFactor, DstColorFactor, OneMinusDstColorFactor, SrcAlphaSaturateFactor, ClampToEdgeWrapping } from "three";
-import { LoadingState } from "@/LoadingState";
-import { ItemState } from './Item';
-const DEFAULT_VERTEX_SHADER = `
-  void main() {
-    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-  }
-`;
-const DEFAULT_PIXEL_SHADER = `
-  void main() {
-    gl_FragColor = vec4(1.0);
-  }
-`;
-export class MaterialItem extends ImageOwningItem {
-    material;
-    pixelShader;
-    vertexShader;
-    constructor(item, engine, renderer, lodMode) {
-        super(item, engine, renderer, lodMode, "material");
-    }
-    getType() {
-        return "Material";
-    }
-    getObject() {
-        return this.material;
-    }
-    _setTextureLinkDefault(linkUsage, mappingPrefix) {
-        this.setLinkItemDefault(linkUsage, null);
-        this._setMappingSetupDefaults(mappingPrefix || linkUsage);
-    }
-    setFieldInstanceDefaults() {
-        // Color Fields
-        // ---------------------------------------------------------------------------------
-        this.setFieldValueDefault("DiffuseColor", { r: 255, g: 255, b: 255, a: 255 });
-        this.setFieldValueDefault("EmissiveColor", { r: 0, g: 0, b: 0, a: 255 });
-        this.setFieldValueDefault("SheenColor", { r: 0, g: 0, b: 0, a: 255 });
-        this.setFieldValueDefault("AttenuationColor", { r: 255, g: 255, b: 255, a: 255 });
-        this.setFieldValueDefault("SpecularColor", { r: 255, g: 255, b: 255, a: 255 });
-        this.setFieldValueDefault("EmissionColor", { r: 255, g: 255, b: 255, a: 255 });
-        // Links
-        // ---------------------------------------------------------------------------------
-        this.setLinkItemDefault("Environment", null);
-        this._setTextureLinkDefault("Albedo");
-        this._setTextureLinkDefault("Alpha");
-        this._setTextureLinkDefault("Gradient");
-        this._setTextureLinkDefault("Metalness");
-        this._setTextureLinkDefault("Roughness");
-        this._setTextureLinkDefault("Normal");
-        this._setTextureLinkDefault("AmbientOcclusion");
-        this._setTextureLinkDefault("Emissive");
-        this._setTextureLinkDefault("Displacement");
-        this._setTextureLinkDefault("TransmissionMap", "Transmission");
-        this._setTextureLinkDefault("ClearcoatMap", "Clearcoat");
-        this._setTextureLinkDefault("ClearcoatNormalMap", "ClearcoatNormal");
-        this._setTextureLinkDefault("ClearcoatRoughnessMap", "ClearcoatRoughness");
-        this._setTextureLinkDefault("SheenRoughnessMap", "SheenRoughness");
-        this._setTextureLinkDefault("SheenColorMap", "SheenColor");
-        this._setTextureLinkDefault("SpecularIntensityMap", "SpecularIntensity");
-        this._setTextureLinkDefault("SpecularColorMap", "SpecularColor");
-        this._setTextureLinkDefault("ThicknessMap", "Thickness");
-        this._setTextureLinkDefault("LightMap", "LightMap");
-        this._setTextureLinkDefault("SpecularMap", "Specular");
-        this._setTextureLinkDefault("MatcapMap", "Matcap");
-        this.setLinkItemDefault("VertexShader", null);
-        this.setLinkItemDefault("PixelShader", null);
-        // Floats, Ints, Enums, etc.
-        // ---------------------------------------------------------------------------------
-        this.setFieldValueDefault("MaterialType", "Physical");
-        this.setFieldValueDefault("AmbientOcclusionIntensity", 1);
-        this.setFieldValueDefault("ClearcoatLevel", 0);
-        this.setFieldValueDefault("ClearcoatRoughness", 0);
-        this.setFieldValueDefault("ClearcoatNormalScale2d", { x: 1, y: 1 });
-        this.setFieldValueDefault("NormalType", "TangentSpace");
-        this.setFieldValueDefault("Reflectivity", 0.5);
-        this.setFieldValueDefault("NormalScale2d", { x: 1, y: 1 });
-        this.setFieldValueDefault("EnvironmentIntensity", 1);
-        this.setFieldValueDefault("EmissiveIntensity", 1);
-        this.setFieldValueDefault("DisplacementScale", 1);
-        this.setFieldValueDefault("DisplacementBias", 0);
-        this.setFieldValueDefault("Transmission", 0);
-        this.setFieldValueDefault("IndexOfRefraction", 1.5);
-        this.setFieldValueDefault("AttenuationDistance", 1000);
-        this.setFieldValueDefault("Sheen", 0);
-        this.setFieldValueDefault("SheenRoughness", 0);
-        this.setFieldValueDefault("Thickness", 0);
-        this.setFieldValueDefault("PointSize", 1);
-        this.setFieldValueDefault("PointSizeAttenuation", true);
-        this.setFieldValueDefault("VertexColors", false);
-        this.setFieldValueDefault("AlphaTest", 0);
-        this.setFieldValueDefault("Blending", "Normal");
-        this.setFieldValueDefault("BlendSrc", "Source alpha");
-        this.setFieldValueDefault("BlendDest", "One minus source alpha");
-        this.setFieldValueDefault("BlendEquation", "Add");
-        this.setFieldValueDefault("FlatShading", false);
-        this.setFieldValueDefault("Transparent", false);
-        this.setFieldValueDefault("DepthTest", true);
-        this.setFieldValueDefault("DepthWrite", true);
-        this.setFieldValueDefault("DepthMode", "Less/equal");
-        this.setFieldValueDefault("Opacity", 1);
-        this.setFieldValueDefault("Culling", "Back");
-        this.setFieldValueDefault("RoughnessIntensity", 1);
-        this.setFieldValueDefault("MetalnessIntensity", 1);
-        this.setFieldValueDefault("SpecularIntensity", 1);
-        this.setFieldValueDefault("LightMapIntensity", 1);
-        this.setFieldValueDefault("RefractionRatio", 0.98);
-        this.setFieldValueDefault("SurfaceEnvironmentCombination", "Multiply");
-        this.setFieldValueDefault("Wireframe", false);
-        this.setFieldValueDefault("Shininess", 30);
-    }
-    _enumerateChildren() {
-        return [
-            this._getChildOrLinkItem("albedoMapTexture", "Albedo"),
-            this._getChildOrLinkItem("alphaMapTexture", "Alpha"),
-            this._getChildOrLinkItem("gradientMapTexture", "Gradient"),
-            this._getChildOrLinkItem("sheenRoughnessMapTexture", "SheenRoughnessMap"),
-            this._getChildOrLinkItem("sheenColorMapTexture", "SheenColorMap"),
-            this._getChildOrLinkItem("specularIntensityMapTexture", "SpecularIntensityMap"),
-            this._getChildOrLinkItem("specularColorMapTexture", "SpecularColorMap"),
-            this._getChildOrLinkItem("thicknessMapTexture", "ThicknessMap"),
-            this._getChildOrLinkItem("metalnessMapTexture", "Metalness"),
-            this._getChildOrLinkItem("roughnessMapTexture", "Roughness"),
-            this._getChildOrLinkItem("normalMapTexture", "Normal"),
-            this._getChildOrLinkItem("ambientOcclusionMapTexture", "AmbientOcclusion"),
-            this._getChildOrLinkItem("environmentMapTexture", "Environment"),
-            this._getChildOrLinkItem("emissiveMapTexture", "Emissive"),
-            this._getChildOrLinkItem("displacementMapTexture", "Displacement"),
-            this._getChildOrLinkItem("transmissionMapTexture", "TransmissionMap"),
-            this._getChildOrLinkItem("clearcoatMapTexture", "Clearcoat"),
-            this._getChildOrLinkItem("clearcoatNormalMapTexture", "ClearcoatNormalMap"),
-            this._getChildOrLinkItem("clearcoatRoughnessMapTexture", "ClearcoatRoughnessMap"),
-            this._getChildOrLinkItem("lightMapTexture", "LightMap"),
-            this._getChildOrLinkItem("specularMapTexture", "SpecularMap"),
-            this._getChildOrLinkItem("matcapMapTexture", "MatcapMap"),
-            this._getChildOrLinkItem("vertexShader", "VertexShader"),
-            this._getChildOrLinkItem("pixelShader", "PixelShader"),
-        ];
-    }
-    async create() {
-        this.destroy();
-        await this._createThreeJsMaterial();
-        this.state = ItemState.Created;
-        this._loadingManagerProgress(LoadingState.CREATED);
-        return this;
-    }
-    async load() {
-        this._loadingManagerProgress(LoadingState.LOADING);
-        await this.setProperties();
-        this.state = ItemState.Finished;
-        this._loadingManagerProgress(LoadingState.DONE);
-    }
-    async setProperties() {
-        if (!this.material)
-            return;
-        const materialType = this.getFieldValue("MaterialType");
-        // Color Fields
-        // ---------------------------------------------------------------------------------
-        const diffuseColor = this.getFieldValue("DiffuseColor");
-        const emissiveColor = this.getFieldValue("EmissiveColor");
-        const sheenColor = this.getFieldValue("SheenColor");
-        const attenuationColor = this.getFieldValue('AttenuationColor');
-        const emissionColor = this.getFieldValue("EmissionColor");
-        // Links
-        // ---------------------------------------------------------------------------------
-        const albedoItem = this.getFieldValue("Albedo");
-        const alphaItem = this.getFieldValue("Alpha");
-        const metalnessItem = this.getFieldValue("Metalness");
-        const roughnessItem = this.getFieldValue("Roughness");
-        const normalItem = this.getFieldValue("Normal");
-        const ambientOcclusionItem = this.getFieldValue("AmbientOcclusion");
-        const environmentItem = this.getFieldValue("Environment");
-        const emissiveItem = this.getFieldValue("Emissive");
-        const displacementItem = this.getFieldValue("Displacement");
-        const transmissionItem = this.getFieldValue("TransmissionMap");
-        const clearcoatItem = this.getFieldValue("ClearcoatMap");
-        const clearcoatNormalItem = this.getFieldValue("ClearcoatNormalMap");
-        const clearcoatRoughnessItem = this.getFieldValue("ClearcoatRoughnessMap");
-        const sheenRoughnessItem = this.getFieldValue('SheenRoughnessMap');
-        const sheenColorItem = this.getFieldValue('SheenColorMap');
-        const specularIntensityItem = this.getFieldValue('SpecularIntensityMap');
-        const specularColorItem = this.getFieldValue('SpecularColorMap');
-        const thicknessItem = this.getFieldValue('ThicknessMap');
-        const lightMapItem = this.getFieldValue('LightMap');
-        const specularMapItem = this.getFieldValue('SpecularMap');
-        const gradientItem = this.getFieldValue("Gradient");
-        const matcapItem = this.getFieldValue("Matcap");
-        // Floats, Ints, Enums, etc.
-        // ---------------------------------------------------------------------------------
-        const ambientOcclusionIntensity = this.getFieldValue("AmbientOcclusionIntensity");
-        const clearcoatLevel = this.getFieldValue("ClearcoatLevel");
-        const clearcoatRoughness = this.getFieldValue("ClearcoatRoughness");
-        const clearcoatNormalScale = this.getFieldValue("ClearcoatNormalScale2d");
-        const normalType = this.getFieldValue("NormalType");
-        const reflectivity = this.getFieldValue("Reflectivity");
-        const normalScale = this.getFieldValue("NormalScale2d");
-        const environmentIntensity = this.getFieldValue("EnvironmentIntensity");
-        const emissiveIntensity = this.getFieldValue("EmissiveIntensity");
-        const displacementScale = this.getFieldValue("DisplacementScale");
-        const displacementBias = this.getFieldValue("DisplacementBias");
-        const transmission = this.getFieldValue("Transmission");
-        const indexOfRefraction = this.getFieldValue("IndexOfRefraction");
-        const attenuationDistance = this.getFieldValue('AttenuationDistance');
-        const sheen = this.getFieldValue('Sheen');
-        const sheenRoughness = this.getFieldValue('SheenRoughness');
-        const thickness = this.getFieldValue('Thickness');
-        const specularColor = this.getFieldValue("SpecularColor");
-        const specularIntensity = this.getFieldValue('SpecularIntensity');
-        const roughnessIntensity = this.getFieldValue("RoughnessIntensity");
-        const metalnessIntensity = this.getFieldValue("MetalnessIntensity");
-        const lightMapIntensity = this.getFieldValue('LightMapIntensity');
-        const pointSize = this.getFieldValue("PointSize");
-        const pointSizeAttenuation = this.getFieldValue("PointSizeAttenuation");
-        const vertexColors = this.getFieldValue("VertexColors");
-        const alphaTest = this.getFieldValue("AlphaTest");
-        const blending = this.getFieldValue("Blending");
-        const blendSource = this.getFieldValue("BlendSrc");
-        const blendDest = this.getFieldValue("BlendDest");
-        const blendEquation = this.getFieldValue("BlendEquation");
-        const flatShading = this.getFieldValue("FlatShading");
-        const transparent = this.getFieldValue("Transparent");
-        const depthTest = this.getFieldValue("DepthTest");
-        const depthWrite = this.getFieldValue("DepthWrite");
-        const depthMode = this.getFieldValue("DepthMode");
-        const opacity = this.getFieldValue("Opacity");
-        const culling = this.getFieldValue("Culling");
-        const surfaceEnvCombination = this.getFieldValue("SurfaceEnvironmentCombination");
-        const refractionRatio = this.getFieldValue("RefractionRatio");
-        const wireframe = this.getFieldValue("Wireframe");
-        const shininess = this.getFieldValue("Shininess");
-        const promises = [];
-        // Properties for all materials
-        this.material.vertexColors = vertexColors;
-        this.material.opacity = opacity;
-        this.material.transparent = transparent;
-        this.material.alphaTest = alphaTest;
-        this.material.depthTest = depthTest;
-        this.material.depthWrite = depthWrite;
-        this.setBlending(blending);
-        this.setCulling(culling);
-        this.setBlendSource(blendSource);
-        this.setBlendDest(blendDest);
-        this.setBlendEquation(blendEquation);
-        this.setDepthMode(depthMode);
-        // MeshStandardMaterial properties
-        if (materialType === "Physical" && this.material instanceof MeshPhysicalMaterial) {
-            this.material.color = this.toColorObjRgba(diffuseColor, 0xffffff);
-            this.material.roughness = roughnessIntensity;
-            this.material.metalness = metalnessIntensity;
-            this.material.lightMapIntensity = lightMapIntensity;
-            this.material.aoMapIntensity = ambientOcclusionIntensity;
-            this.material.emissive = this.toColorObjRgba(emissiveColor, 0x000000);
-            this.material.emissiveIntensity = emissiveIntensity;
-            this.material.normalScale = new Vector2(normalScale.x, normalScale.y);
-            this.material.displacementScale = displacementScale;
-            this.material.displacementBias = displacementBias;
-            this.material.envMapIntensity = environmentIntensity;
-            this.material.flatShading = flatShading;
-            this.material.wireframe = wireframe;
-            this.setNormalType(normalType);
-            if (albedoItem)
-                promises.push(this.setAlbedoMapItem(albedoItem));
-            if (lightMapItem)
-                promises.push(this.setLightMapItem(lightMapItem));
-            if (ambientOcclusionItem)
-                promises.push(this.setAmbientOcclusionMapItem(ambientOcclusionItem));
-            if (emissiveItem)
-                promises.push(this.setEmissiveMapItem(emissiveItem));
-            if (normalItem)
-                promises.push(this.setNormalMapItem(normalItem));
-            if (displacementItem)
-                promises.push(this.setDisplacementMapItem(displacementItem));
-            if (roughnessItem)
-                promises.push(this.setRoughnessMapItem(roughnessItem));
-            if (metalnessItem)
-                promises.push(this.setMetalnessMapItem(metalnessItem));
-            if (alphaItem)
-                promises.push(this.setAlphaMapItem(alphaItem));
-            if (environmentItem)
-                promises.push(this.setEnvironmentMapItem(environmentItem));
-        }
-        // MeshPhysicalMaterial properties
-        if (materialType === "Physical" && this.material instanceof MeshPhysicalMaterial) {
-            this.material.clearcoatRoughness = clearcoatRoughness;
-            this.material.clearcoatNormalScale = new Vector2(clearcoatNormalScale.x, clearcoatNormalScale.y);
-            this.material.ior = indexOfRefraction;
-            //@ts-ignore
-            this.material.reflectivity = reflectivity;
-            this.material.sheenColor = this.toColorObjRgba(sheenColor, 0xffffff);
-            this.material.sheenRoughness = sheenRoughness || 0;
-            this.material.thickness = thickness || 0;
-            this.material.attenuationDistance = attenuationDistance || Infinity;
-            this.material.attenuationColor = this.toColorObjRgba(attenuationColor, 0xffffff);
-            this.material.specularIntensity = specularIntensity;
-            this.material.specularColor = this.toColorObjRgba(specularColor, 0xffffff);
-            this.material.sheen = sheen || 0;
-            this.material.clearcoat = clearcoatLevel;
-            this.material.transmission = transmission;
-            if (clearcoatItem)
-                promises.push(this.setClearcoatMapItem(clearcoatItem));
-            if (clearcoatRoughnessItem)
-                promises.push(this.setClearcoatRoughnessMapItem(clearcoatRoughnessItem));
-            if (clearcoatNormalItem)
-                promises.push(this.setClearcoatNormalMapItem(clearcoatNormalItem));
-            if (sheenColorItem)
-                promises.push(this.setSheenColorMapItem(sheenColorItem));
-            if (transmissionItem)
-                promises.push(this.setTransmissionMapItem(transmissionItem));
-            if (thicknessItem)
-                promises.push(this.setThicknessMapItem(thicknessItem));
-            if (specularIntensityItem)
-                promises.push(this.setSpecularIntensityMapItem(specularIntensityItem));
-            if (specularColorItem)
-                promises.push(this.setSpecularColorMapItem(specularColorItem));
-            if (sheenRoughnessItem)
-                promises.push(this.setSheenRoughnessMapItem(sheenRoughnessItem));
-        }
-        // PointsMaterial properties
-        if (materialType === "Point" && this.material instanceof PointsMaterial) {
-            this.material.color = this.toColorObjRgba(diffuseColor, 0xffffff);
-            this.material.size = pointSize / 1000;
-            this.material.sizeAttenuation = pointSizeAttenuation;
-            if (albedoItem)
-                promises.push(this.setAlbedoMapItem(albedoItem));
-            if (alphaItem)
-                promises.push(this.setAlphaMapItem(alphaItem));
-        }
-        // MeshBasicMaterial properties
-        if (materialType === "Basic" && this.material instanceof MeshBasicMaterial) {
-            this.material.color = this.toColorObjRgba(emissionColor, 0xffffff);
-            this.material.aoMapIntensity = ambientOcclusionIntensity;
-            this.material.lightMapIntensity = lightMapIntensity;
-            this.material.reflectivity = reflectivity;
-            this.material.refractionRatio = refractionRatio;
-            this.material.wireframe = wireframe;
-            this.setCombineMode(surfaceEnvCombination);
-            if (alphaItem)
-                promises.push(this.setAlphaMapItem(alphaItem));
-            if (ambientOcclusionItem)
-                promises.push(this.setAmbientOcclusionMapItem(ambientOcclusionItem));
-            if (environmentItem)
-                promises.push(this.setEnvironmentMapItem(environmentItem));
-            if (lightMapItem)
-                promises.push(this.setLightMapItem(lightMapItem));
-            if (albedoItem)
-                promises.push(this.setAlbedoMapItem(albedoItem));
-            if (specularMapItem)
-                promises.push(this.setSpecularMapItem(specularMapItem));
-        }
-        // MeshNormalMaterial properties
-        if (materialType === "Normal" && this.material instanceof MeshNormalMaterial) {
-            this.material.displacementScale = displacementScale;
-            this.material.displacementBias = displacementBias;
-            this.material.flatShading = flatShading;
-            this.material.normalScale = new Vector2(normalScale.x, normalScale.y);
-            this.material.wireframe = wireframe;
-            this.setNormalType(normalType);
-            if (displacementItem)
-                promises.push(this.setDisplacementMapItem(displacementItem));
-            if (normalItem)
-                promises.push(this.setNormalMapItem(normalItem));
-        }
-        // MeshToonMaterial properties
-        if (materialType === "Toon" && this.material instanceof MeshToonMaterial) {
-            this.material.aoMapIntensity = ambientOcclusionIntensity;
-            this.material.color = this.toColorObjRgba(diffuseColor, 0xffffff);
-            this.material.displacementScale = displacementScale;
-            this.material.displacementBias = displacementBias;
-            this.material.emissive = this.toColorObjRgba(emissiveColor, 0x000000);
-            this.material.emissiveIntensity = emissiveIntensity;
-            this.material.lightMapIntensity = lightMapIntensity;
-            this.material.normalScale = new Vector2(normalScale.x, normalScale.y);
-            this.material.wireframe = wireframe;
-            this.setNormalType(normalType);
-            if (emissiveItem)
-                promises.push(this.setEmissiveMapItem(emissiveItem));
-            if (displacementItem)
-                promises.push(this.setDisplacementMapItem(displacementItem));
-            if (ambientOcclusionItem)
-                promises.push(this.setAmbientOcclusionMapItem(ambientOcclusionItem));
-            if (alphaItem)
-                promises.push(this.setAlphaMapItem(alphaItem));
-            if (gradientItem)
-                promises.push(this.setGradientMapItem(gradientItem));
-            if (lightMapItem)
-                promises.push(this.setLightMapItem(lightMapItem));
-            if (albedoItem)
-                promises.push(this.setAlbedoMapItem(albedoItem));
-            if (normalItem)
-                promises.push(this.setNormalMapItem(normalItem));
-        }
-        // MeshMatcapMaterial properties
-        if (materialType === "Matcap" && this.material instanceof MeshMatcapMaterial) {
-            this.material.color = this.toColorObjRgba(diffuseColor, 0xffffff);
-            this.material.displacementScale = displacementScale;
-            this.material.displacementBias = displacementBias;
-            this.material.flatShading = flatShading;
-            this.material.normalScale = new Vector2(normalScale.x, normalScale.y);
-            this.setNormalType(normalType);
-            if (displacementItem)
-                promises.push(this.setDisplacementMapItem(displacementItem));
-            if (alphaItem)
-                promises.push(this.setAlphaMapItem(alphaItem));
-            if (albedoItem)
-                promises.push(this.setAlbedoMapItem(albedoItem));
-            if (matcapItem)
-                promises.push(this.setMatcapMapItem(matcapItem));
-            if (normalItem)
-                promises.push(this.setNormalMapItem(normalItem));
-        }
-        // MeshLambertMaterial properties
-        if (materialType === "Lambert" && this.material instanceof MeshLambertMaterial) {
-            this.material.aoMapIntensity = ambientOcclusionIntensity;
-            this.material.color = this.toColorObjRgba(diffuseColor, 0xffffff);
-            this.material.displacementScale = displacementScale;
-            this.material.displacementBias = displacementBias;
-            this.material.emissive = this.toColorObjRgba(emissiveColor, 0x000000);
-            this.material.emissiveIntensity = emissiveIntensity;
-            this.material.flatShading = flatShading;
-            this.material.lightMapIntensity = lightMapIntensity;
-            this.material.normalScale = new Vector2(normalScale.x, normalScale.y);
-            this.material.reflectivity = reflectivity;
-            this.material.refractionRatio = refractionRatio;
-            this.material.wireframe = wireframe;
-            this.setNormalType(normalType);
-            this.setCombineMode(surfaceEnvCombination);
-            if (ambientOcclusionItem)
-                promises.push(this.setAmbientOcclusionMapItem(ambientOcclusionItem));
-            if (alphaItem)
-                promises.push(this.setAlphaMapItem(alphaItem));
-            if (displacementItem)
-                promises.push(this.setDisplacementMapItem(displacementItem));
-            if (emissiveItem)
-                promises.push(this.setEmissiveMapItem(emissiveItem));
-            if (environmentItem)
-                promises.push(this.setEnvironmentMapItem(environmentItem));
-            if (lightMapItem)
-                promises.push(this.setLightMapItem(lightMapItem));
-            if (normalItem)
-                promises.push(this.setNormalMapItem(normalItem));
-            if (albedoItem)
-                promises.push(this.setAlbedoMapItem(albedoItem));
-            if (specularMapItem)
-                promises.push(this.setSpecularMapItem(specularMapItem));
-        }
-        // MesehPhongMaterial properties
-        if (materialType === "Phong" && this.material instanceof MeshPhongMaterial) {
-            this.material.aoMapIntensity = ambientOcclusionIntensity;
-            this.material.color = this.toColorObjRgba(diffuseColor, 0xffffff);
-            this.material.displacementScale = displacementScale;
-            this.material.displacementBias = displacementBias;
-            this.material.emissive = this.toColorObjRgba(emissiveColor, 0x000000);
-            this.material.emissiveIntensity = emissiveIntensity;
-            this.material.flatShading = flatShading;
-            this.material.lightMapIntensity = lightMapIntensity;
-            this.material.normalScale = new Vector2(normalScale.x, normalScale.y);
-            this.material.reflectivity = reflectivity;
-            this.material.refractionRatio = refractionRatio;
-            this.material.wireframe = wireframe;
-            this.material.specular = this.toColorObjRgba(specularColor, 0xffffff);
-            this.material.shininess = shininess;
-            this.setNormalType(normalType);
-            this.setCombineMode(surfaceEnvCombination);
-            if (ambientOcclusionItem)
-                promises.push(this.setAmbientOcclusionMapItem(ambientOcclusionItem));
-            if (displacementItem)
-                promises.push(this.setDisplacementMapItem(displacementItem));
-            if (alphaItem)
-                promises.push(this.setAlphaMapItem(alphaItem));
-            if (emissiveItem)
-                promises.push(this.setEmissiveMapItem(emissiveItem));
-            if (environmentItem)
-                promises.push(this.setEnvironmentMapItem(environmentItem));
-            if (lightMapItem)
-                promises.push(this.setLightMapItem(lightMapItem));
-            if (normalItem)
-                promises.push(this.setNormalMapItem(normalItem));
-            if (albedoItem)
-                promises.push(this.setAlbedoMapItem(albedoItem));
-            if (specularMapItem)
-                promises.push(this.setSpecularMapItem(specularMapItem));
-        }
-        if (materialType === "Shader" && this.material instanceof ShaderMaterial) {
-            this.material.wireframe = wireframe;
-        }
-        return Promise.all(promises);
-    }
-    async destroy() {
-        if (this.material) {
-            // activate all channels first if any are deactivated
-            this.setAlbedoActive(true);
-            this.setNormalActive(true);
-            this.setMetalnessActive(true);
-            this.setRoughnessActive(true);
-            this.setAmbientOcclusionActive(true);
-            this.setEnvironmentActive(true);
-            this.setGradientActive(true);
-            this.setSpecularMapActive(true);
-            this.setMatcapActive(true);
-            this.renderer.removeMaterial(this);
-            this.material.dispose();
-            this.material = undefined;
-        }
-        this.unloadShaders();
-        this.unloadMap("AlbedoMap");
-        this.unloadMap("LightMap");
-        this.unloadMap("AmbientOcclusionMap");
-        this.unloadMap("EmissiveMap");
-        this.unloadMap("NormalMap");
-        this.unloadMap("DisplacementMap");
-        this.unloadMap("RoughnessMap");
-        this.unloadMap("MetalnessMap");
-        this.unloadMap("AlphaMap");
-        this.unloadMap("EnvironmentMap");
-        this.unloadMap("ClearcoatMap");
-        this.unloadMap("ClearcoatRoughnessMap");
-        this.unloadMap("ClearcoatNormalMap");
-        this.unloadMap("SheenColorMap");
-        this.unloadMap("TransmissionMap");
-        this.unloadMap("ThicknessMap");
-        this.unloadMap("SpecularIntensityMap");
-        this.unloadMap("SpecularColorMap");
-        this.unloadMap("SheenRoughnessMap");
-        this.unloadMap("SpecularMap");
-        this.unloadMap("GradientMap");
-        this.unloadMap("MatcapMap");
-        this.state = ItemState.Destroyed;
-    }
-    unloadMap(mapName) {
-        const textureName = `${mapName}Texture`;
-        if (!this[textureName])
-            return;
-        this.engine.loadingManager.unload(this.getId(), this[textureName]);
-        this[textureName] = null;
-    }
-    unloadShaders() {
-        this.unloadPixelShader();
-        this.unloadVertexShader();
-    }
-    unloadPixelShader() {
-        if (!this.pixelShader)
-            return;
-        this.engine.loadingManager.unload(this.getId(), this.pixelShader);
-        this.pixelShader.$off('item:objectUpdated', this.setPixelShaderCode, this);
-        this.pixelShader = undefined;
-    }
-    unloadVertexShader() {
-        if (!this.vertexShader)
-            return;
-        this.engine.loadingManager.unload(this.getId(), this.vertexShader);
-        this.vertexShader.$off('item:objectUpdated', this.setVertexShaderCode, this);
-        this.vertexShader = undefined;
-    }
-    async loadShaders() {
-        const p1 = this.loadPixelShader();
-        const p2 = this.loadVertexShader();
-        return Promise.all([p1, p2]);
-    }
-    async loadPixelShader(value) {
-        const pixelShader = value === undefined ? this.getFieldValue("PixelShader") : value;
-        if (pixelShader) {
-            this.pixelShader = await this.engine.loadingManager.loadPixelShader(this.getId(), pixelShader);
-            this.pixelShader.$on('item:objectUpdated', this.setPixelShaderCode, this);
-        }
-    }
-    async loadVertexShader(value) {
-        const vertexShader = value === undefined ? this.getFieldValue("VertexShader") : value;
-        if (vertexShader) {
-            this.vertexShader = await this.engine.loadingManager.loadVertexShader(this.getId(), vertexShader);
-            this.vertexShader.$on('item:objectUpdated', this.setVertexShaderCode, this);
-        }
-    }
-    recreateThreeJsMaterial = async () => {
-        await this._createThreeJsMaterial();
-        await this.setProperties();
-        this.update();
-        this.state = ItemState.Finished;
-    };
-    async _createThreeJsMaterial() {
-        let newMaterial;
-        if (this.material) {
-            this.destroy();
-        }
-        await this.loadShaders();
-        const materialType = this.getFieldValue("MaterialType");
-        switch (materialType) {
-            case "Physical":
-                newMaterial = new MeshPhysicalMaterial();
-                break;
-            case "Point":
-                newMaterial = new PointsMaterial();
-                break;
-            case "Shader":
-                newMaterial = this.createShaderMaterial();
-                break;
-            case "Basic":
-                newMaterial = new MeshBasicMaterial();
-                break;
-            case "Normal":
-                newMaterial = new MeshNormalMaterial();
-                break;
-            case "Toon":
-                newMaterial = new MeshToonMaterial();
-                break;
-            case "Matcap":
-                newMaterial = new MeshMatcapMaterial();
-                break;
-            case "Lambert":
-                newMaterial = new MeshLambertMaterial();
-                break;
-            case "Phong":
-                newMaterial = new MeshPhongMaterial();
-                break;
-            default:
-                console.warn("Material type not supported: ", materialType);
-                console.warn("Defaulting to physical material.");
-                newMaterial = new MeshPhysicalMaterial();
-        }
-        this.material = newMaterial;
-        this.renderer.addMaterial(this);
-        this.$emit('item:objectUpdated', this);
-    }
-    createShaderMaterial() {
-        const psCode = this.pixelShader ? this.pixelShader.getCode() : DEFAULT_PIXEL_SHADER;
-        const vsCode = this.vertexShader ? this.vertexShader.getCode() : DEFAULT_VERTEX_SHADER;
-        const newMaterial = new ShaderMaterial({
-            uniforms: {
-                iTime: { value: 0.0 },
-                iResolution: { value: new Vector2() }
-            },
-            vertexShader: vsCode,
-            fragmentShader: psCode
-        });
-        return newMaterial;
-    }
-    setVertexShaderCode = () => {
-        if (!this.material || !(this.material instanceof ShaderMaterial))
-            return;
-        this.material.vertexShader = this.vertexShader ? this.vertexShader.getCode() : DEFAULT_VERTEX_SHADER;
-        this.material.needsUpdate = true;
-    };
-    setPixelShaderCode = () => {
-        if (!this.material || !(this.material instanceof ShaderMaterial))
-            return;
-        this.material.fragmentShader = this.pixelShader ? this.pixelShader.getCode() : DEFAULT_PIXEL_SHADER;
-        this.material.needsUpdate = true;
-    };
-    getChannels() {
-        return [
-            {
-                name: "albedo",
-                displayName: "Albedo",
-                active: this.isAlbedoMapSet()
-            },
-            {
-                name: "alpha",
-                displayName: "Alpha",
-                active: this.isAlphaMapSet()
-            },
-            {
-                name: "normal",
-                displayName: "Normal",
-                active: this.isNormalMapSet()
-            },
-            {
-                name: "roughness",
-                displayName: "Roughness",
-                active: this.isRoughnessMapSet()
-            },
-            {
-                name: "metalness",
-                displayName: "Metalness",
-                active: this.isMetalnessMapSet()
-            },
-            {
-                name: "ambientOcclusion",
-                displayName: "Ambient Occlusion",
-                active: this.isAmbientOcclusionMapSet()
-            },
-            {
-                name: "emissive",
-                displayName: "Emissive",
-                active: this.isEmissiveMapSet()
-            },
-            {
-                name: "displacement",
-                displayName: "Displacement",
-                active: this.isDisplacementMapSet()
-            },
-            {
-                name: "transmission",
-                displayName: "Transmission",
-                active: this.isTransmissionMapSet()
-            },
-            {
-                name: "clearcoat",
-                displayName: "Clearcoat",
-                active: this.isClearcoatMapSet()
-            },
-            {
-                name: "clearcoatNormal",
-                displayName: "Clearcoat Normal",
-                active: this.isClearcoatNormalMapSet()
-            },
-            {
-                name: "clearcoatRoughness",
-                displayName: "Clearcoat Roughness",
-                active: this.isClearcoatRoughnessMapSet()
-            },
-            {
-                name: "environment",
-                displayName: "Environment",
-                active: this.isEnvironmentMapSet()
-            },
-            {
-                name: "sheenRoughness",
-                displayName: "Sheen Roughness",
-                active: this.isSheenRoughnessMapSet()
-            },
-            {
-                name: "sheenColor",
-                displayName: "Sheen Color",
-                active: this.isSheenColorMapSet()
-            },
-            {
-                name: "specularColor",
-                displayName: "Specular Color",
-                active: this.isSpecularColorMapSet()
-            },
-            {
-                name: "specularIntensity",
-                displayName: "Specular Intensity",
-                active: this.isSpecularIntensityMapSet()
-            },
-            {
-                name: "thickness",
-                displayName: "Thickness",
-                active: this.isThicknessMapSet()
-            },
-            {
-                name: "lightMap",
-                displayName: "LightMap",
-                active: this.isLightMapSet()
-            },
-            {
-                name: "gradient",
-                displayName: "Gradient",
-                active: this.isGradientMapSet()
-            },
-            {
-                name: "matcap",
-                displayName: "Matcap",
-                active: this.isMatcapMapSet()
-            }
-        ];
-    }
-    setChannelActive(channel, value) {
-        switch (channel) {
-            case "albedo":
-                this.setAlbedoActive(value);
-                break;
-            case "alpha":
-                this.setAlphaActive(value);
-                break;
-            case "normal":
-                this.setNormalActive(value);
-                break;
-            case "roughness":
-                this.setRoughnessActive(value);
-                break;
-            case "metalness":
-                this.setMetalnessActive(value);
-                break;
-            case "ambientOcclusion":
-                this.setAmbientOcclusionActive(value);
-                break;
-            case "emissive":
-                this.setEmissiveActive(value);
-                break;
-            case "displacement":
-                this.setDisplacementActive(value);
-                break;
-            case "transmission":
-                this.setTransmissionActive(value);
-                break;
-            case "clearcoat":
-                this.setClearcoatActive(value);
-                break;
-            case "clearcoatNormal":
-                this.setClearcoatNormalActive(value);
-                break;
-            case "clearcoatRoughness":
-                this.setClearcoatRoughnessActive(value);
-                break;
-            case "environment":
-                this.setEnvironmentActive(value);
-                break;
-            case "sheenRoughness":
-                this.setSheenRoughnessActive(value);
-                break;
-            case "sheenColor":
-                this.setSheenColorActive(value);
-                break;
-            case "specularColor":
-                this.setSpecularColorActive(value);
-                break;
-            case "specularIntensity":
-                this.setSpecularIntensityActive(value);
-                break;
-            case "thickness":
-                this.setThicknessActive(value);
-                break;
-            case "lightMap":
-                this.setLightMapActive(value);
-                break;
-            case "gradient":
-                this.setGradientActive(value);
-                break;
-            case "matcap":
-                this.setMatcapActive(value);
-                break;
-            default:
-                console.error("Invalid channel: ", channel);
-                break;
-        }
-    }
-    update() {
-        if (this.material) {
-            this.material.needsUpdate = true;
-        }
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  ALBEDO METHODS
-    // ------------------------------------------------------------------------------------------------
-    isAlbedoMapSet() {
-        return this._isMapSet("map");
-    }
-    async setAlbedoMapItem(item) {
-        return this._setMapItem(item, "setAlbedoMap", undefined, true);
-    }
-    setAlbedoMap(texture) {
-        this._setMap(texture, "albedoMapTexture", "map", undefined, "albedo", undefined, "Albedo");
-    }
-    getAlbedoMap() {
-        return this._getMap("albedoMapTexture", "map");
-    }
-    setAlbedoActive(value) {
-        this._setMapActive(value, "map", "savedAlbedo");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  ALPHA METHODS
-    // ------------------------------------------------------------------------------------------------
-    isAlphaMapSet() {
-        return this._isMapSet("alphaMap");
-    }
-    async setAlphaMapItem(item) {
-        return this._setMapItem(item, "setAlphaMap");
-    }
-    setAlphaMap(texture) {
-        this._setMap(texture, "alphaMapTexture", "alphaMap", undefined, "alpha", undefined, "Alpha");
-    }
-    getAlphaMap() {
-        return this._getMap("alphaMapTexture", "alphaMap");
-    }
-    setAlphaActive(value) {
-        this._setMapActive(value, "alphaMap", "savedAlpha");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  GRADIENT METHODS
-    // ------------------------------------------------------------------------------------------------
-    isGradientMapSet() {
-        return this._isMapSet("gradientMap");
-    }
-    async setGradientMapItem(item) {
-        this._setMapItem(item, "setGradientMap");
-    }
-    setGradientMap(texture) {
-        this._setMap(texture, "gradientMapTexture", "gradientMap", ClampToEdgeWrapping, "gradient", undefined, "Gradient");
-    }
-    getGradientMap() {
-        return this._getMap("gradientMapTexture", "gradientMap");
-    }
-    setGradientActive(value) {
-        this._setMapActive(value, "gradientMap", "savedGradient");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  MATCAP METHODS
-    // ------------------------------------------------------------------------------------------------
-    isMatcapMapSet() {
-        return this._isMapSet("matcap");
-    }
-    async setMatcapMapItem(item) {
-        this._setMapItem(item, "setMatcap");
-    }
-    setMatcap(texture) {
-        this._setMap(texture, "matcapMapTexture", "matcap", ClampToEdgeWrapping, "matcap", undefined, "Matcap");
-    }
-    getMatcapMap() {
-        return this._getMap("matcapMapTexture", "matcap");
-    }
-    setMatcapActive(value) {
-        this._setMapActive(value, "matcap", "savedMatcap");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  NORMAL METHODS
-    // ------------------------------------------------------------------------------------------------
-    isNormalMapSet() {
-        return this._isMapSet("normalMap");
-    }
-    async setNormalMapItem(item) {
-        return this._setMapItem(item, "setNormalMap");
-    }
-    setNormalMap(texture) {
-        this._setMap(texture, "normalMapTexture", "normalMap", undefined, "normal", undefined, "Normal");
-    }
-    getNormalMap() {
-        return this._getMap("normalMapTexture", "normalMap");
-    }
-    setNormalActive(value) {
-        this._setMapActive(value, "normalMap", "savedNormal");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  METALNESS METHODS
-    // ------------------------------------------------------------------------------------------------
-    isMetalnessMapSet() {
-        return this._isMapSet("metalnessMap");
-    }
-    async setMetalnessMapItem(item) {
-        return this._setMapItem(item, "setMetalnessMap");
-    }
-    setMetalnessMap(texture) {
-        this._setMap(texture, "metalnessMapTexture", "metalnessMap", undefined, "metalness", undefined, "Metalness");
-    }
-    getMetalnessMap() {
-        return this._getMap("metalnessMapTexture", "metalnessMap");
-    }
-    setMetalnessActive(value) {
-        this._setMapActive(value, "metalnessMap", "savedMetalness");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  ROUGHNESS METHODS
-    // ------------------------------------------------------------------------------------------------
-    isRoughnessMapSet() {
-        return this._isMapSet("roughnessMap");
-    }
-    async setRoughnessMapItem(item) {
-        return this._setMapItem(item, "setRoughnessMap");
-    }
-    setRoughnessMap(texture) {
-        this._setMap(texture, "roughnessMapTexture", "roughnessMap", undefined, "roughness", undefined, "Roughness");
-    }
-    getRoughnessMap() {
-        return this._getMap("roughnessMapTexture", "roughnessMap");
-    }
-    setRoughnessActive(value) {
-        this._setMapActive(value, "roughnessMap", "savedRoughness");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  AMBIENT OCCLUSION METHODS
-    // ------------------------------------------------------------------------------------------------
-    isAmbientOcclusionMapSet() {
-        return this._isMapSet("aoMap");
-    }
-    async setAmbientOcclusionMapItem(item) {
-        return this._setMapItem(item, "setAmbientOcclusionMap");
-    }
-    setAmbientOcclusionMap(texture) {
-        this._setMap(texture, "ambientOcclusionMapTexture", "aoMap", undefined, "ambientocclusion", undefined, "AmbientOcclusion");
-    }
-    getAmbientOcclusionMap() {
-        return this._getMap("ambientOcclusionMapTexture", "aoMap");
-    }
-    setAmbientOcclusionActive(value) {
-        this._setMapActive(value, "aoMap", "savedAmbientOcclusion");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  ENVIRONMENT METHODS
-    // ------------------------------------------------------------------------------------------------
-    isEnvironmentMapSet() {
-        return this._isMapSet("envMap");
-    }
-    async setEnvironmentMapItem(item) {
-        return this._setMapItem(item, "setEnvironmentMap", true);
-    }
-    setEnvironmentMap(texture) {
-        this._setMap(texture, "environmentMapTexture", "envMap", ClampToEdgeWrapping, "environment");
-    }
-    getEnvironmentMap() {
-        return this._getMap("environmentMapTexture", "envMap");
-    }
-    setEnvironmentActive(value) {
-        this._setMapActive(value, "envMap", "savedEnvironment");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  EMISSIVE METHODS
-    // ------------------------------------------------------------------------------------------------
-    isEmissiveMapSet() {
-        return this._isMapSet("emissiveMap");
-    }
-    async setEmissiveMapItem(item) {
-        return this._setMapItem(item, "setEmissiveMap");
-    }
-    setEmissiveMap(texture) {
-        this._setMap(texture, "emissiveMapTexture", "emissiveMap", undefined, "emissive", undefined, "Emissive");
-    }
-    getEmissiveMap() {
-        return this._getMap("emissiveMapTexture", "emissiveMap");
-    }
-    setEmissiveActive(value) {
-        this._setMapActive(value, "emissiveMap", "savedEmissive");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  DISPLACEMENT METHODS
-    // ------------------------------------------------------------------------------------------------
-    isDisplacementMapSet() {
-        return this._isMapSet("displacementMap");
-    }
-    async setDisplacementMapItem(item) {
-        return this._setMapItem(item, "setDisplacementMap");
-    }
-    setDisplacementMap(texture) {
-        this._setMap(texture, "displacementMapTexture", "displacementMap", undefined, "displacement", undefined, "Displacement");
-    }
-    getDisplacementMap() {
-        return this._getMap("displacementMapTexture", "displacementMap");
-    }
-    setDisplacementActive(value) {
-        this._setMapActive(value, "displacementMap", "savedDisplacement");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  TRANSMISSION METHODS
-    // ------------------------------------------------------------------------------------------------
-    isTransmissionMapSet() {
-        return this._isMapSet("transmissionMap");
-    }
-    async setTransmissionMapItem(item) {
-        return this._setMapItem(item, "setTransmissionMap");
-    }
-    setTransmissionMap(texture) {
-        this._setMap(texture, "transmissionMapTexture", "transmissionMap", undefined, "transmissionMap", undefined, "Transmission");
-    }
-    getTransmissionMap() {
-        return this._getMap("transmissionMapTexture", "transmissionMap");
-    }
-    setTransmissionActive(value) {
-        this._setMapActive(value, "transmissionMap", "savedTransmission");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  CLEARCOAT METHODS
-    // ------------------------------------------------------------------------------------------------
-    isClearcoatMapSet() {
-        return this._isMapSet("clearcoatMap");
-    }
-    async setClearcoatMapItem(item) {
-        return this._setMapItem(item, "setClearcoatMap");
-    }
-    setClearcoatMap(texture) {
-        this._setMap(texture, "clearcoatMapTexture", "clearcoatMap", undefined, "clearcoatMap", undefined, "Clearcoat");
-    }
-    getClearcoatMap() {
-        return this._getMap("clearcoatMapTexture", "clearcoatMap");
-    }
-    setClearcoatActive(value) {
-        this._setMapActive(value, "clearcoatMap", "savedClearcoat");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  CLEARCOAT NORMAL METHODS
-    // ------------------------------------------------------------------------------------------------
-    isClearcoatNormalMapSet() {
-        return this._isMapSet("clearcoatNormalMap");
-    }
-    async setClearcoatNormalMapItem(item) {
-        return this._setMapItem(item, "setClearcoatNormalMap");
-    }
-    setClearcoatNormalMap(texture) {
-        this._setMap(texture, "clearcoatNormalMapTexture", "clearcoatNormalMap", undefined, "clearcoatNormalMap", undefined, "ClearcoatNormal");
-    }
-    getClearcoatNormalMap() {
-        return this._getMap("clearcoatNormalMapTexture", "clearcoatNormalMap");
-    }
-    setClearcoatNormalActive(value) {
-        this._setMapActive(value, "clearcoatNormalMap", "savedClearcoatNormal");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  CLEARCOAT ROUGHNESS METHODS
-    // ------------------------------------------------------------------------------------------------
-    isClearcoatRoughnessMapSet() {
-        return this._isMapSet("clearcoatRoughnessMap");
-    }
-    async setClearcoatRoughnessMapItem(item) {
-        return this._setMapItem(item, "setClearcoatRoughnessMap");
-    }
-    setClearcoatRoughnessMap(texture) {
-        this._setMap(texture, "clearcoatRoughnessMapTexture", "clearcoatRoughnessMap", undefined, "clearcoatRoughnessMap", undefined, "ClearcoatRoughness");
-    }
-    getClearcoatRoughnessMap() {
-        return this._getMap("clearcoatRoughnessMapTexture", "clearcoatRoughnessMap");
-    }
-    setClearcoatRoughnessActive(value) {
-        this._setMapActive(value, "clearcoatRoughnessMap", "savedClearcoatRoughness");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  SHEEN ROUGHNESS METHODS
-    // ------------------------------------------------------------------------------------------------
-    isSheenRoughnessMapSet() {
-        return this._isMapSet("sheenRoughnessMap");
-    }
-    async setSheenRoughnessMapItem(item) {
-        return this._setMapItem(item, "setSheenRoughnessMap");
-    }
-    setSheenRoughnessMap(texture) {
-        this._setMap(texture, "sheenRoughnessMapTexture", "sheenRoughnessMap", undefined, "sheenRoughnessMap", undefined, "SheenRoughness");
-    }
-    getSheenRoughnessMap() {
-        return this._getMap("sheenRoughnessMapTexture", "sheenRoughnessMap");
-    }
-    setSheenRoughnessActive(value) {
-        this._setMapActive(value, "sheenRoughnessMap", "savedSheenRoughness");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  SHEEN COLOR METHODS
-    // ------------------------------------------------------------------------------------------------
-    isSheenColorMapSet() {
-        return this._isMapSet("sheenColorMap");
-    }
-    async setSheenColorMapItem(item) {
-        return this._setMapItem(item, "setSheenColorMap");
-    }
-    setSheenColorMap(texture) {
-        this._setMap(texture, "sheenColorMapTexture", "sheenColorMap", undefined, "sheenColorMap", undefined, "SheenColor");
-    }
-    getSheenColorMap() {
-        return this._getMap("sheenColorMapTexture", "sheenColorMap");
-    }
-    setSheenColorActive(value) {
-        this._setMapActive(value, "sheenColorMap", "savedSheenColor");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  SPECULAR COLOR METHODS
-    // ------------------------------------------------------------------------------------------------
-    isSpecularColorMapSet() {
-        return this._isMapSet("specularColorMap");
-    }
-    async setSpecularColorMapItem(item) {
-        return this._setMapItem(item, "setSpecularColorMap");
-    }
-    setSpecularColorMap(texture) {
-        this._setMap(texture, "specularColorMapTexture", "specularColorMap", undefined, "specularColorMap", undefined, "SpecularColor");
-    }
-    getSpecularColorMap() {
-        return this._getMap("specularColorMapTexture", "specularColorMap");
-    }
-    setSpecularColorActive(value) {
-        this._setMapActive(value, "specularColorMap", "savedSpecularColor");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  SPECULAR INTENSITY METHODS
-    // ------------------------------------------------------------------------------------------------
-    isSpecularIntensityMapSet() {
-        return this._isMapSet("specularIntensityMap");
-    }
-    async setSpecularIntensityMapItem(item) {
-        return this._setMapItem(item, "setSpecularIntensityMap");
-    }
-    setSpecularIntensityMap(texture) {
-        this._setMap(texture, "specularIntensityMapTexture", "specularIntensityMap", undefined, "specularIntensityMap", undefined, "SpecularIntensity");
-    }
-    getSpecularIntensityMap() {
-        return this._getMap("specularIntensityMapTexture", "specularIntensityMap");
-    }
-    setSpecularIntensityActive(value) {
-        this._setMapActive(value, "specularIntensityMap", "savedSpecularIntensity");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  THICKNESS METHODS
-    // ------------------------------------------------------------------------------------------------
-    isThicknessMapSet() {
-        return this._isMapSet("thicknessMap");
-    }
-    async setThicknessMapItem(item) {
-        return this._setMapItem(item, "setThicknessMap");
-    }
-    setThicknessMap(texture) {
-        this._setMap(texture, "thicknessMapTexture", "thicknessMap", undefined, "thicknessMap", undefined, "Thickness");
-    }
-    getThicknessMap() {
-        return this._getMap("thicknessMapTexture", "thicknessMap");
-    }
-    setThicknessActive(value) {
-        this._setMapActive(value, "thicknessMap", "savedThickness");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  LIGHTMAP METHODS
-    // ------------------------------------------------------------------------------------------------
-    isLightMapSet() {
-        return this._isMapSet("lightMap");
-    }
-    async setLightMapItem(item) {
-        return this._setMapItem(item, "setLightMap");
-    }
-    setLightMap(texture) {
-        this._setMap(texture, "lightMapTexture", "lightMap", undefined, "lightMap", undefined, "LightMap");
-    }
-    getLightMap() {
-        return this._getMap("lightMapTexture", "lightMap");
-    }
-    setLightMapActive(value) {
-        this._setMapActive(value, "lightMap", "savedLightMap");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  SPECULAR MAP METHODS
-    // ------------------------------------------------------------------------------------------------
-    isSpecularMapSet() {
-        return this._isMapSet("specularMap");
-    }
-    async setSpecularMapItem(item) {
-        return this._setMapItem(item, "setSpecularMap");
-    }
-    setSpecularMap(texture) {
-        this._setMap(texture, "specularMapTexture", "specularMap", undefined, "specularMap", undefined, "Specular");
-    }
-    getSpecularMap() {
-        return this._getMap("specularMapTexture", "specularMap");
-    }
-    setSpecularMapActive(value) {
-        this._setMapActive(value, "specularMap", "savedSpecularMap");
-    }
-    // ------------------------------------------------------------------------------------------------
-    //  SHADER METHODS
-    // ------------------------------------------------------------------------------------------------
-    setWireframe(enabled) {
-        if (this.material && "wireframe" in this.material) {
-            this.material.wireframe = enabled;
-        }
-    }
-    setNormalType(normalType) {
-        if (this.material && "normalMapType" in this.material) {
-            switch (normalType) {
-                case "ObjectSpace":
-                    this.material.normalMapType = ObjectSpaceNormalMap;
-                    break;
-                case "TangentSpace":
-                    this.material.normalMapType = TangentSpaceNormalMap;
-                    break;
-                default:
-                    console.error("Material.setNormalType(): Unknown normal type: " + normalType);
-                    break;
-            }
-        }
-    }
-    setDepthMode(depthMode) {
-        if (this.material) {
-            switch (depthMode) {
-                case "Never":
-                    this.material.depthMode = NeverDepth;
-                    break;
-                case "Always":
-                    this.material.depthMode = AlwaysDepth;
-                    break;
-                case "Less":
-                    this.material.depthMode = LessDepth;
-                    break;
-                case "Less/equal":
-                    this.material.depthMode = LessEqualDepth;
-                    break;
-                case "Greater/equal":
-                    this.material.depthMode = GreaterEqualDepth;
-                    break;
-                case "Greater":
-                    this.material.depthMode = GreaterDepth;
-                    break;
-                case "Not equal":
-                    this.material.depthMode = NotEqualDepth;
-                    break;
-                default:
-                    console.error("Material.setCulling(): Unknown depth mode: " + depthMode);
-                    break;
-            }
-        }
-    }
-    setCulling(culling) {
-        if (this.material) {
-            switch (culling) {
-                case "Front":
-                    this.material.side = BackSide;
-                    break;
-                case "Back":
-                    this.material.side = FrontSide;
-                    break;
-                case "Off":
-                    this.material.side = DoubleSide;
-                    break;
-                default:
-                    console.error("Material.setCulling(): Unknown cull mode: " + culling);
-                    break;
-            }
-        }
-    }
-    setBlending(blending) {
-        if (this.material) {
-            switch (blending) {
-                case "None":
-                    this.material.blending = NoBlending;
-                    this.material.premultipliedAlpha = false;
-                    break;
-                case "Normal":
-                    this.material.blending = NormalBlending;
-                    this.material.premultipliedAlpha = false;
-                    break;
-                case "Additive":
-                    this.material.blending = AdditiveBlending;
-                    this.material.premultipliedAlpha = false;
-                    break;
-                case "Subtractive":
-                    this.material.blending = SubtractiveBlending;
-                    this.material.premultipliedAlpha = true;
-                    break;
-                case "Multiply":
-                    this.material.blending = MultiplyBlending;
-                    this.material.premultipliedAlpha = true;
-                    break;
-                case "Custom":
-                    this.material.blending = CustomBlending;
-                    this.material.premultipliedAlpha = false;
-                    break;
-                default:
-                    console.error("Material.setBlending(): Unknown blend mode: " + blending);
-                    break;
-            }
-        }
-    }
-    setBlendSource(blendSource) {
-        if (this.material) {
-            switch (blendSource) {
-                case "Zero":
-                    this.material.blendSrc = ZeroFactor;
-                    break;
-                case "One":
-                    this.material.blendSrc = OneFactor;
-                    break;
-                case "Source color":
-                    this.material.blendSrc = SrcColorFactor;
-                    break;
-                case "One minus source color":
-                    this.material.blendSrc = OneMinusSrcColorFactor;
-                    break;
-                case "Source alpha":
-                    this.material.blendSrc = SrcAlphaFactor;
-                    break;
-                case "One minus source alpha":
-                    this.material.blendSrc = OneMinusSrcAlphaFactor;
-                    break;
-                case "Destination alpha":
-                    this.material.blendSrc = DstAlphaFactor;
-                    break;
-                case "One minus destination alpha":
-                    this.material.blendSrc = OneMinusDstAlphaFactor;
-                    break;
-                case "Destination color":
-                    this.material.blendSrc = DstColorFactor;
-                    break;
-                case "One minus destination color":
-                    this.material.blendSrc = OneMinusDstColorFactor;
-                    break;
-                case "Source alpha saturate":
-                    this.material.blendSrc = SrcAlphaSaturateFactor;
-                    break;
-                default:
-                    console.error("Material.setBlendSource(): Unknown blend source: " + blendSource);
-                    break;
-            }
-        }
-    }
-    setBlendDest(blendDest) {
-        if (this.material) {
-            switch (blendDest) {
-                case "Zero":
-                    this.material.blendDst = ZeroFactor;
-                    break;
-                case "One":
-                    this.material.blendDst = OneFactor;
-                    break;
-                case "Source color":
-                    this.material.blendDst = SrcColorFactor;
-                    break;
-                case "One minus source color":
-                    this.material.blendDst = OneMinusSrcColorFactor;
-                    break;
-                case "Source alpha":
-                    this.material.blendDst = SrcAlphaFactor;
-                    break;
-                case "One minus source alpha":
-                    this.material.blendDst = OneMinusSrcAlphaFactor;
-                    break;
-                case "Destination alpha":
-                    this.material.blendDst = DstAlphaFactor;
-                    break;
-                case "One minus destination alpha":
-                    this.material.blendDst = OneMinusDstAlphaFactor;
-                    break;
-                case "Destination color":
-                    this.material.blendDst = DstColorFactor;
-                    break;
-                case "One minus destination color":
-                    this.material.blendDst = OneMinusDstColorFactor;
-                    break;
-                default:
-                    console.error("Material.setBlendDest(): Unknown blend dest: " + blendDest);
-                    break;
-            }
-        }
-    }
-    setBlendEquation(blendEquation) {
-        if (this.material) {
-            switch (blendEquation) {
-                case "Add":
-                    this.material.blendEquation = AddEquation;
-                    break;
-                case "Subtract":
-                    this.material.blendEquation = SubtractEquation;
-                    break;
-                case "Reverse subtract":
-                    this.material.blendEquation = ReverseSubtractEquation;
-                    break;
-                case "Min":
-                    this.material.blendEquation = MinEquation;
-                    break;
-                case "Max":
-                    this.material.blendEquation = MaxEquation;
-                    break;
-                default:
-                    console.error("Material.setBlendEquation(): Unknown blend equation: " + blendEquation);
-                    break;
-            }
-        }
-    }
-    setCombineMode(combineMode) {
-        if (this.material && "combine" in this.material) {
-            switch (combineMode) {
-                case "Multiply":
-                    this.material.combine = MultiplyOperation;
-                    break;
-                case "Mix":
-                    this.material.combine = MixOperation;
-                    break;
-                case "Add":
-                    this.material.combine = AddOperation;
-                    break;
-                default:
-                    console.error("Material.setCombineMode(): Unknown combine mode: " + combineMode);
-                    break;
-            }
-        }
-    }
-    setSpecularColor(value) {
-        if (!this.material)
-            return;
-        const materialType = this.getFieldValue("MaterialType");
-        if (materialType === "Phong") {
-            this.material.specular = this.toColorObjRgba(value, 0x111111);
-        }
-        else {
-            this.material.specularColor = this.toColorObjRgba(value, 0xffffff);
-        }
-    }
-    updateEvent(field, value) {
-        if (!this.material) {
-            return;
-        }
-        super.updateEvent(field, value);
-        switch (field) {
-            case "MaterialType":
-                this.recreateThreeJsMaterial();
-                break;
-            case "AttenuationColor":
-                this.material.attenuationColor = this.toColorObjRgba(value, 0xffffff);
-                break;
-            case "AttenuationDistance":
-                this.material.attenuationDistance = value;
-                break;
-            case "DiffuseColor":
-                this.material.color = this.toColorObjRgba(value, 0xffffff);
-                break;
-            case "EmissiveColor":
-                this.material.emissive = this.toColorObjRgba(value, 0x000000);
-                break;
-            case "Sheen":
-                this.material.sheen = value;
-                break;
-            case "SheenColor":
-                this.material.sheenColor = this.toColorObjRgba(value, 0xffffff);
-                break;
-            case "SheenColorMap":
-                this.setSheenColorMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "SheenRoughness":
-                this.material.sheenRoughness = value;
-                break;
-            case "SheenRoughnessMap":
-                this.setSheenRoughnessMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "Albedo":
-                this.setAlbedoMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "Alpha":
-                this.setAlphaMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "Metalness":
-                this.setMetalnessMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "Roughness":
-                this.setRoughnessMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "SpecularIntensity":
-                this.material.specularIntensity = value;
-                break;
-            case "SpecularIntensityMap":
-                this.setSpecularIntensityMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "SpecularColor":
-                this.setSpecularColor(value);
-                break;
-            case "SpecularColorMap":
-                this.setSpecularColorMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "Thickness":
-                this.material.thickness = value;
-                break;
-            case "ThicknessMap":
-                this.setThicknessMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "LightMapIntensity":
-                this.material.lightMapIntensity = value;
-                break;
-            case "LightMap":
-                this.setLightMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "Normal":
-                this.setNormalMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "AmbientOcclusion":
-                this.setAmbientOcclusionMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "Environment":
-                this.setEnvironmentMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "Emissive":
-                this.setEmissiveMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "Displacement":
-                this.setDisplacementMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "TransmissionMap":
-                this.setTransmissionMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "ClearcoatMap":
-                this.setClearcoatMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "ClearcoatNormalMap":
-                this.setClearcoatNormalMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "ClearcoatRoughnessMap":
-                this.setClearcoatRoughnessMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "VertexShader":
-                this.unloadVertexShader();
-                this.loadVertexShader(value).then(this.setVertexShaderCode);
-                break;
-            case "PixelShader":
-                this.unloadPixelShader();
-                this.loadPixelShader(value).then(this.setPixelShaderCode);
-                break;
-            case "AmbientOcclusionIntensity":
-                this.material.aoMapIntensity = value;
-                break;
-            case "ClearcoatLevel":
-                this.material.clearcoat = value;
-                break;
-            case "ClearcoatRoughness":
-                this.material.clearcoatRoughness = value;
-                break;
-            case "ClearcoatNormalScale2d":
-                this.material.clearcoatNormalScale = new Vector2(value.x, value.y);
-                break;
-            case "NormalType":
-                this.setNormalType(value);
-                break;
-            case "IndexOfRefraction":
-                this.material.ior = value;
-                break;
-            case "Transmission":
-                this.material.transmission = value;
-                break;
-            case "Reflectivity":
-                this.material.reflectivity = value;
-                break;
-            case "NormalScale2d":
-                this.material.normalScale = new Vector2(value.x, value.y);
-                break;
-            case "RoughnessIntensity":
-                this.material.roughness = value;
-                break;
-            case "MetalnessIntensity":
-                this.material.metalness = value;
-                break;
-            case "EnvironmentIntensity":
-                this.material.envMapIntensity = value;
-                break;
-            case "EmissiveIntensity":
-                this.material.emissiveIntensity = value;
-                break;
-            case "DisplacementScale":
-                this.material.displacementScale = value;
-                break;
-            case "DisplacementBias":
-                this.material.displacementBias = value;
-                break;
-            case "PointSize":
-                this.material.size = value / 1000;
-                break;
-            case "PointSizeAttenuation":
-                this.material.sizeAttenuation = value;
-                break;
-            case "VertexColors":
-                this.material.vertexColors = value;
-                break;
-            case "AlphaTest":
-                this.material.alphaTest = value;
-                break;
-            case "Blending":
-                this.setBlending(value);
-                break;
-            case "BlendSrc":
-                this.setBlendSource(value);
-                break;
-            case "BlendDest":
-                this.setBlendDest(value);
-                break;
-            case "BlendEquation":
-                this.setBlendEquation(value);
-                break;
-            case "FlatShading":
-                this.material.flatShading = value;
-                break;
-            case "Transparent":
-                this.material.transparent = value;
-                break;
-            case "DepthTest":
-                this.material.depthTest = value;
-                break;
-            case "DepthWrite":
-                this.material.depthWrite = value;
-                break;
-            case "DepthMode":
-                this.setDepthMode(value);
-                break;
-            case "Opacity":
-                this.material.opacity = value;
-                break;
-            case "Culling":
-                this.setCulling(value);
-                break;
-            case "SurfaceEnvironmentCombination":
-                this.setCombineMode(value);
-                break;
-            case "RefractionRatio":
-                this.material.refractionRatio = value;
-                break;
-            case "Wireframe":
-                this.material.wireframe = value;
-                break;
-            case "EmissionColor":
-                this.material.color = this.toColorObjRgba(value, 0xffffff);
-                break;
-            case "SpecularMap":
-                this.setSpecularMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "Gradient":
-                this.setGradientMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "Matcap":
-                this.setMatcapMapItem(value).catch(function (err) {
-                    console.error(err);
-                });
-                break;
-            case "Shininess":
-                this.material.shininess = value;
-                break;
-        }
-        if (this.material)
-            this.material.needsUpdate = true;
-    }
-}
-//# sourceMappingURL=MaterialItem.js.map