@spiffcommerce/preview 3.6.2-rc.6 → 3.6.2-rc.7

package/dist/material.esm.js

@@ -0,0 +1,115 @@
+import { a as Color3 } from './math.color.esm.js';
+import { MaterialEffectMode } from './types.esm.js';
+
+const textureNameMap = {
+    albedoTexture: 'albedoMap',
+    bumpTexture: 'normalMap',
+    ambientTexture: 'ambientMap',
+    emissiveTexture: 'emissionMap',
+    opacityTexture: 'alphaMap',
+    metallicTexture: 'metallicMap',
+    refractionTexture: 'refractionMap',
+};
+function calculateMaterialProperties(materialVariant, targetMaterial, assetsManager, removeWhenUndefined) {
+    const supportedTextures = [
+        'albedoTexture',
+        'bumpTexture',
+        'ambientTexture',
+        'emissiveTexture',
+        'opacityTexture',
+        'metallicTexture',
+        'refractionTexture',
+    ];
+    supportedTextures.forEach((textureName) => {
+        calculateAndApplyTextureProperties(textureName, materialVariant, targetMaterial, assetsManager, removeWhenUndefined);
+    });
+    calculateClearcoatProperties(materialVariant, targetMaterial);
+}
+function calculateAndApplyTextureProperties(textureName, materialVariant, targetMaterial, assetsManager, removeWhenUndefined) {
+    const resourceKeyForTexture = textureNameMap[textureName];
+    if (!resourceKeyForTexture) {
+        throw new Error('Unexpected texture name encountered.');
+    }
+    const textureAsset = materialVariant[resourceKeyForTexture];
+    const textureLink = textureAsset === null || textureAsset === void 0 ? void 0 : textureAsset.fileLink;
+    if (textureLink) {
+        assetsManager.addTextureTask(textureName, textureLink, false, false);
+    }
+    else if (removeWhenUndefined && targetMaterial[textureName]) {
+        targetMaterial[textureName] && targetMaterial[textureName].dispose();
+        targetMaterial[textureName] = null;
+        applyTextureSpecificChangesOnRemoval(textureName, targetMaterial);
+    }
+}
+/**
+ * Certain textures require specific behavior to be undone on removal, such
+ * as flags that would have enabled no longer desired behavior. We filter those out here.
+ * @param textureName The texture name being handled.
+ * @param targetMat The material this texture resides on.
+ */
+function applyTextureSpecificChangesOnRemoval(textureName, targetMat) {
+    if (textureName === 'opacityTexture') {
+        targetMat.useAlphaFromAlbedoTexture = true;
+    }
+    if (textureName === 'metallicTexture') {
+        targetMat.useRoughnessFromMetallicTextureAlpha = false;
+        targetMat.useRoughnessFromMetallicTextureGreen = false;
+        targetMat.useMetallnessFromMetallicTextureBlue = false;
+    }
+    if (textureName === 'refractionTexture') {
+        targetMat.subSurface.isRefractionEnabled = false;
+        targetMat.subSurface.refractionIntensity = 1;
+    }
+    if (textureName === 'emissiveTexture') {
+        targetMat.emissiveIntensity = 0;
+        targetMat.emissiveColor = new Color3(0, 0, 0);
+    }
+}
+/**
+ * Builds a callback to run after the texture has finished downloading and
+ * is ready for application to the material it targets. This function should apply any remaining
+ * properties to the material and then set the texture itself.
+ */
+function applyDownloadedTexture(textureName, targetMat, materialResource, downloadedTexture) {
+    if (textureName === 'opacityTexture') {
+        targetMat.useAlphaFromAlbedoTexture = false;
+    }
+    if (textureName === 'metallicTexture') {
+        targetMat.useRoughnessFromMetallicTextureAlpha = false;
+        targetMat.useRoughnessFromMetallicTextureGreen = true;
+        targetMat.useMetallnessFromMetallicTextureBlue = true;
+    }
+    if (textureName === 'refractionTexture') {
+        targetMat.subSurface.isRefractionEnabled = true;
+        targetMat.subSurface.refractionIntensity =
+            materialResource.refractionIntensity || 1;
+    }
+    targetMat[textureName] = downloadedTexture;
+    if (textureName === 'emissiveTexture') {
+        // TODO: Do we want these to be configurable?
+        targetMat.emissiveColor = new Color3(1, 1, 1);
+        targetMat.emissiveIntensity = 1;
+    }
+}
+/**
+ * Applies a clearcoat parameter to a material if requested.
+ * @param materialVariant The variant to read for clearcoat.
+ * @param targetMaterial The target material to be applied to.
+ */
+function calculateClearcoatProperties(materialVariant, targetMaterial) {
+    if (!materialVariant.clearCoat) {
+        return;
+    }
+    if (materialVariant.clearCoat === MaterialEffectMode.RemoveWhenSelected) {
+        targetMaterial.clearCoat.isEnabled = false;
+        targetMaterial.clearCoat.indexOfRefraction = 1.5; // Default value
+    }
+    else if (materialVariant.clearCoat === MaterialEffectMode.ApplyWhenSelected) {
+        targetMaterial.clearCoat.isEnabled = true;
+        targetMaterial.clearCoat.indexOfRefraction =
+            materialVariant.clearCoatIOR ||
+                targetMaterial.clearCoat.indexOfRefraction;
+    }
+}
+
+export { applyDownloadedTexture, calculateMaterialProperties };

package/dist/math.axis.esm.js

@@ -0,0 +1,35 @@
+import { V as Vector3 } from './webRequest.esm.js';
+
+/** Defines supported spaces */
+var Space;
+(function (Space) {
+    /** Local (object) space */
+    Space[Space["LOCAL"] = 0] = "LOCAL";
+    /** World space */
+    Space[Space["WORLD"] = 1] = "WORLD";
+    /** Bone space */
+    Space[Space["BONE"] = 2] = "BONE";
+})(Space || (Space = {}));
+/** Defines the 3 main axes */
+class Axis {
+}
+/** X axis */
+Axis.X = new Vector3(1.0, 0.0, 0.0);
+/** Y axis */
+Axis.Y = new Vector3(0.0, 1.0, 0.0);
+/** Z axis */
+Axis.Z = new Vector3(0.0, 0.0, 1.0);
+/**
+ * Defines cartesian components.
+ */
+var Coordinate;
+(function (Coordinate) {
+    /** X axis */
+    Coordinate[Coordinate["X"] = 0] = "X";
+    /** Y axis */
+    Coordinate[Coordinate["Y"] = 1] = "Y";
+    /** Z axis */
+    Coordinate[Coordinate["Z"] = 2] = "Z";
+})(Coordinate || (Coordinate = {}));
+
+export { Axis as A, Coordinate as C, Space as S };