@spiffcommerce/preview 3.6.2-rc.8 → 4.0.0

package/dist/dynamicTexture.esm.js

@@ -1,105 +0,0 @@
-import { E as Engine } from './engine.esm.js';
-import { P as PBRMaterial } from './pbrMaterial.esm.js';
-import { D as DynamicTexture } from './dynamicTexture.esm2.js';
-import { T as Texture } from './helperFunctions.esm.js';
-import { RenderingConfiguration } from './renderConstants.esm.js';
-import './webRequest.esm.js';
-import './math.color.esm.js';
-import './hdrFilteringFunctions.esm.js';
-import './pbrBRDFFunctions.esm.js';
-import './math.axis.esm.js';
-import './math.path.esm.js';
-import './material.esm2.js';
-import './node.esm.js';
-import './compatibilityOptions.esm.js';
-import './bumpVertex.esm.js';
-import './effectFallbacks.esm.js';
-import './math.size.esm.js';
-
-/**
- * Iterates through the given panels and
- * attaches a dynamic texture to the relevant material in the array. This allows changes
- * on the panel to be represented on a 3D model.
- * @param materials The materials to search for the relevant material in. Supply scene.materials if you want to search all materials.
- * @param scene The scene to search for materials in.
- * @param renderableContexts A list of canvas panels associated to the current workflow.
- * @param existingTextures Any generated textures will be stored in this map against the panel name they relate to.
- * @param materialPrefix An optional prefix to apply to the material name when searching for the relevant material.
- * Materials attached to a ModelContainer should all be prefixed with the id of the container.
- */
-function attachDynamicTextures(materials, scene, renderableContexts, existingTextures, materialPrefix = '') {
-    renderableContexts.forEach((context) => {
-        const contextID = context.getID();
-        const contextName = context.getName();
-        const renderDims = RenderingConfiguration.getDynamicTextureResolution();
-        // Find any materials in the supplied array with the name of
-        // this layout and are included in our filter if one is provided.
-        const targetMaterials = materials.filter((mat) => {
-            return mat.name === materialPrefix + contextName;
-        });
-        targetMaterials.forEach((mat) => {
-            const curDynamicTexture = existingTextures.get(contextID);
-            const invertYAxis = false;
-            if (!curDynamicTexture) {
-                const newTexture = createDynamicTexture(contextName, scene, renderDims.width, renderDims.height);
-                existingTextures.set(contextID, newTexture);
-                context.setStaticContext(newTexture.getContext());
-                applyDynamicTexture(mat, newTexture);
-                newTexture.onLoadObservable.addOnce(() => {
-                    newTexture.update(invertYAxis);
-                });
-            }
-            else {
-                applyDynamicTexture(mat, curDynamicTexture);
-                curDynamicTexture.update(invertYAxis);
-            }
-        });
-    });
-}
-/**
- * Construct a new dynamic texture to listen for changes to a panel.
- * @param scene The screen the resource will be associated to.
- * @param layoutKey The key for the layout this dynamic texture relates to.
- * @param RenderableContextService The canvas service, used to pull the layout with the given key.
- */
-function createDynamicTexture(name, scene, width, height) {
-    const dynamicTex = new DynamicTexture(name, { width, height }, scene, RenderingConfiguration.shouldMipMap(), Texture.TRILINEAR_SAMPLINGMODE, Engine.TEXTUREFORMAT_RGBA);
-    const ctx = dynamicTex.getContext();
-    if (ctx) {
-        ctx.fillStyle = '#f5f5f5';
-        ctx.fillRect(0, 0, width, height);
-        dynamicTex.update();
-    }
-    return dynamicTex;
-}
-/**
- * Applies a given dynamic texture to a target material.
- * @param mat The material to apply to.
- * @param dynamicTexture The dynamic texture we want to apply.
- */
-function applyDynamicTexture(mat, dynamicTexture) {
-    if (mat instanceof PBRMaterial) {
-        const pbrMat = mat;
-        const albedoTexture = pbrMat.albedoTexture;
-        if (albedoTexture) {
-            dynamicTexture.wrapU = albedoTexture.wrapU;
-            dynamicTexture.wrapV = albedoTexture.wrapV;
-        }
-        else {
-            dynamicTexture.wrapU = 1;
-            dynamicTexture.wrapV = 1;
-        }
-        pbrMat.albedoTexture = dynamicTexture;
-    }
-    else {
-        const standardMat = mat;
-        const diffuseTexture = standardMat.diffuseTexture;
-        if (diffuseTexture) {
-            dynamicTexture.wrapU = diffuseTexture.wrapU;
-            dynamicTexture.wrapV = diffuseTexture.wrapV;
-        }
-        standardMat.diffuseTexture = dynamicTexture;
-    }
-}
-
-export { attachDynamicTextures };

package/dist/dynamicTexture.esm2.js

@@ -1,238 +0,0 @@
-import { T as ThinEngine, I as InternalTexture, a as InternalTextureSource, L as Logger } from './engine.esm.js';
-import { T as Texture } from './helperFunctions.esm.js';
-
-ThinEngine.prototype.createDynamicTexture = function (width, height, generateMipMaps, samplingMode) {
-    const texture = new InternalTexture(this, InternalTextureSource.Dynamic);
-    texture.baseWidth = width;
-    texture.baseHeight = height;
-    if (generateMipMaps) {
-        width = this.needPOTTextures ? ThinEngine.GetExponentOfTwo(width, this._caps.maxTextureSize) : width;
-        height = this.needPOTTextures ? ThinEngine.GetExponentOfTwo(height, this._caps.maxTextureSize) : height;
-    }
-    //  this.resetTextureCache();
-    texture.width = width;
-    texture.height = height;
-    texture.isReady = false;
-    texture.generateMipMaps = generateMipMaps;
-    texture.samplingMode = samplingMode;
-    this.updateTextureSamplingMode(samplingMode, texture);
-    this._internalTexturesCache.push(texture);
-    return texture;
-};
-ThinEngine.prototype.updateDynamicTexture = function (texture, source, invertY, premulAlpha = false, format, forceBindTexture = false, 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-allowGPUOptimization = false) {
-    if (!texture) {
-        return;
-    }
-    const gl = this._gl;
-    const target = gl.TEXTURE_2D;
-    const wasPreviouslyBound = this._bindTextureDirectly(target, texture, true, forceBindTexture);
-    this._unpackFlipY(invertY === undefined ? texture.invertY : invertY);
-    if (premulAlpha) {
-        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, 1);
-    }
-    const textureType = this._getWebGLTextureType(texture.type);
-    const glformat = this._getInternalFormat(format ? format : texture.format);
-    const internalFormat = this._getRGBABufferInternalSizedFormat(texture.type, glformat);
-    gl.texImage2D(target, 0, internalFormat, glformat, textureType, source);
-    if (texture.generateMipMaps) {
-        gl.generateMipmap(target);
-    }
-    if (!wasPreviouslyBound) {
-        this._bindTextureDirectly(target, null);
-    }
-    if (premulAlpha) {
-        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, 0);
-    }
-    texture.isReady = true;
-};
-
-/**
- * A class extending Texture allowing drawing on a texture
- * @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/dynamicTexture
- */
-class DynamicTexture extends Texture {
-    /**
-     * Creates a DynamicTexture
-     * @param name defines the name of the texture
-     * @param options provides 3 alternatives for width and height of texture, a canvas, object with width and height properties, number for both width and height
-     * @param scene defines the scene where you want the texture
-     * @param generateMipMaps defines the use of MinMaps or not (default is false)
-     * @param samplingMode defines the sampling mode to use (default is Texture.TRILINEAR_SAMPLINGMODE)
-     * @param format defines the texture format to use (default is Engine.TEXTUREFORMAT_RGBA)
-     * @param invertY defines if the texture needs to be inverted on the y axis during loading
-     */
-    constructor(name, options, scene = null, generateMipMaps = false, samplingMode = 3, format = 5, invertY) {
-        super(null, scene, !generateMipMaps, invertY, samplingMode, undefined, undefined, undefined, undefined, format);
-        this.name = name;
-        this.wrapU = Texture.CLAMP_ADDRESSMODE;
-        this.wrapV = Texture.CLAMP_ADDRESSMODE;
-        this._generateMipMaps = generateMipMaps;
-        const engine = this._getEngine();
-        if (!engine) {
-            return;
-        }
-        if (options.getContext) {
-            this._canvas = options;
-            this._texture = engine.createDynamicTexture(options.width, options.height, generateMipMaps, samplingMode);
-        }
-        else {
-            this._canvas = engine.createCanvas(1, 1);
-            if (options.width || options.width === 0) {
-                this._texture = engine.createDynamicTexture(options.width, options.height, generateMipMaps, samplingMode);
-            }
-            else {
-                this._texture = engine.createDynamicTexture(options, options, generateMipMaps, samplingMode);
-            }
-        }
-        const textureSize = this.getSize();
-        if (this._canvas.width !== textureSize.width) {
-            this._canvas.width = textureSize.width;
-        }
-        if (this._canvas.height !== textureSize.height) {
-            this._canvas.height = textureSize.height;
-        }
-        this._context = this._canvas.getContext("2d");
-    }
-    /**
-     * Get the current class name of the texture useful for serialization or dynamic coding.
-     * @returns "DynamicTexture"
-     */
-    getClassName() {
-        return "DynamicTexture";
-    }
-    /**
-     * Gets the current state of canRescale
-     */
-    get canRescale() {
-        return true;
-    }
-    _recreate(textureSize) {
-        this._canvas.width = textureSize.width;
-        this._canvas.height = textureSize.height;
-        this.releaseInternalTexture();
-        this._texture = this._getEngine().createDynamicTexture(textureSize.width, textureSize.height, this._generateMipMaps, this.samplingMode);
-    }
-    /**
-     * Scales the texture
-     * @param ratio the scale factor to apply to both width and height
-     */
-    scale(ratio) {
-        const textureSize = this.getSize();
-        textureSize.width *= ratio;
-        textureSize.height *= ratio;
-        this._recreate(textureSize);
-    }
-    /**
-     * Resizes the texture
-     * @param width the new width
-     * @param height the new height
-     */
-    scaleTo(width, height) {
-        const textureSize = this.getSize();
-        textureSize.width = width;
-        textureSize.height = height;
-        this._recreate(textureSize);
-    }
-    /**
-     * Gets the context of the canvas used by the texture
-     * @returns the canvas context of the dynamic texture
-     */
-    getContext() {
-        return this._context;
-    }
-    /**
-     * Clears the texture
-     */
-    clear() {
-        const size = this.getSize();
-        this._context.fillRect(0, 0, size.width, size.height);
-    }
-    /**
-     * Updates the texture
-     * @param invertY defines the direction for the Y axis (default is true - y increases downwards)
-     * @param premulAlpha defines if alpha is stored as premultiplied (default is false)
-     * @param allowGPUOptimization true to allow some specific GPU optimizations (subject to engine feature "allowGPUOptimizationsForGUI" being true)
-     */
-    update(invertY, premulAlpha = false, allowGPUOptimization = false) {
-        this._getEngine().updateDynamicTexture(this._texture, this._canvas, invertY === undefined ? true : invertY, premulAlpha, this._format || undefined, undefined, allowGPUOptimization);
-    }
-    /**
-     * Draws text onto the texture
-     * @param text defines the text to be drawn
-     * @param x defines the placement of the text from the left
-     * @param y defines the placement of the text from the top when invertY is true and from the bottom when false
-     * @param font defines the font to be used with font-style, font-size, font-name
-     * @param color defines the color used for the text
-     * @param clearColor defines the color for the canvas, use null to not overwrite canvas
-     * @param invertY defines the direction for the Y axis (default is true - y increases downwards)
-     * @param update defines whether texture is immediately update (default is true)
-     */
-    drawText(text, x, y, font, color, clearColor, invertY, update = true) {
-        const size = this.getSize();
-        if (clearColor) {
-            this._context.fillStyle = clearColor;
-            this._context.fillRect(0, 0, size.width, size.height);
-        }
-        this._context.font = font;
-        if (x === null || x === undefined) {
-            const textSize = this._context.measureText(text);
-            x = (size.width - textSize.width) / 2;
-        }
-        if (y === null || y === undefined) {
-            const fontSize = parseInt(font.replace(/\D/g, ""));
-            y = size.height / 2 + fontSize / 3.65;
-        }
-        this._context.fillStyle = color || "";
-        this._context.fillText(text, x, y);
-        if (update) {
-            this.update(invertY);
-        }
-    }
-    /**
-     * Clones the texture
-     * @returns the clone of the texture.
-     */
-    clone() {
-        const scene = this.getScene();
-        if (!scene) {
-            return this;
-        }
-        const textureSize = this.getSize();
-        const newTexture = new DynamicTexture(this.name, textureSize, scene, this._generateMipMaps);
-        // Base texture
-        newTexture.hasAlpha = this.hasAlpha;
-        newTexture.level = this.level;
-        // Dynamic Texture
-        newTexture.wrapU = this.wrapU;
-        newTexture.wrapV = this.wrapV;
-        return newTexture;
-    }
-    /**
-     * Serializes the dynamic texture.  The scene should be ready before the dynamic texture is serialized
-     * @returns a serialized dynamic texture object
-     */
-    serialize() {
-        const scene = this.getScene();
-        if (scene && !scene.isReady()) {
-            Logger.Warn("The scene must be ready before serializing the dynamic texture");
-        }
-        const serializationObject = super.serialize();
-        if (DynamicTexture._IsCanvasElement(this._canvas)) {
-            serializationObject.base64String = this._canvas.toDataURL();
-        }
-        serializationObject.invertY = this._invertY;
-        serializationObject.samplingMode = this.samplingMode;
-        return serializationObject;
-    }
-    static _IsCanvasElement(canvas) {
-        return canvas.toDataURL !== undefined;
-    }
-    /** @internal */
-    _rebuild() {
-        this.update();
-    }
-}
-
-export { DynamicTexture as D };

package/dist/easing.esm.js

@@ -1,130 +0,0 @@
-import './math.path.esm.js';
-
-/**
- * Base class used for every default easing function.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#easing-functions
- */
-class EasingFunction {
-    constructor() {
-        this._easingMode = EasingFunction.EASINGMODE_EASEIN;
-    }
-    /**
-     * Sets the easing mode of the current function.
-     * @param easingMode Defines the willing mode (EASINGMODE_EASEIN, EASINGMODE_EASEOUT or EASINGMODE_EASEINOUT)
-     */
-    setEasingMode(easingMode) {
-        const n = Math.min(Math.max(easingMode, 0), 2);
-        this._easingMode = n;
-    }
-    /**
-     * Gets the current easing mode.
-     * @returns the easing mode
-     */
-    getEasingMode() {
-        return this._easingMode;
-    }
-    /**
-     * @internal
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    easeInCore(gradient) {
-        throw new Error("You must implement this method");
-    }
-    /**
-     * Given an input gradient between 0 and 1, this returns the corresponding value
-     * of the easing function.
-     * @param gradient Defines the value between 0 and 1 we want the easing value for
-     * @returns the corresponding value on the curve defined by the easing function
-     */
-    ease(gradient) {
-        switch (this._easingMode) {
-            case EasingFunction.EASINGMODE_EASEIN:
-                return this.easeInCore(gradient);
-            case EasingFunction.EASINGMODE_EASEOUT:
-                return 1 - this.easeInCore(1 - gradient);
-        }
-        if (gradient >= 0.5) {
-            return (1 - this.easeInCore((1 - gradient) * 2)) * 0.5 + 0.5;
-        }
-        return this.easeInCore(gradient * 2) * 0.5;
-    }
-}
-/**
- * Interpolation follows the mathematical formula associated with the easing function.
- */
-EasingFunction.EASINGMODE_EASEIN = 0;
-/**
- * Interpolation follows 100% interpolation minus the output of the formula associated with the easing function.
- */
-EasingFunction.EASINGMODE_EASEOUT = 1;
-/**
- * Interpolation uses EaseIn for the first half of the animation and EaseOut for the second half.
- */
-EasingFunction.EASINGMODE_EASEINOUT = 2;
-/**
- * Easing function with a ease back shape (see link below).
- * @see https://easings.net/#easeInBack
- * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#easing-functions
- */
-class BackEase extends EasingFunction {
-    /**
-     * Instantiates a back ease easing
-     * @see https://easings.net/#easeInBack
-     * @param amplitude Defines the amplitude of the function
-     */
-    constructor(
-    /** Defines the amplitude of the function */
-    amplitude = 1) {
-        super();
-        this.amplitude = amplitude;
-    }
-    /**
-     * @internal
-     */
-    easeInCore(gradient) {
-        const num = Math.max(0, this.amplitude);
-        return Math.pow(gradient, 3.0) - gradient * num * Math.sin(3.1415926535897931 * gradient);
-    }
-}
-/**
- * Easing function with an exponential shape (see link below).
- * @see https://easings.net/#easeInExpo
- * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#easing-functions
- */
-class ExponentialEase extends EasingFunction {
-    /**
-     * Instantiates an exponential easing function
-     * @see https://easings.net/#easeInExpo
-     * @param exponent Defines the exponent of the function
-     */
-    constructor(
-    /** Defines the exponent of the function */
-    exponent = 2) {
-        super();
-        this.exponent = exponent;
-    }
-    /**
-     * @internal
-     */
-    easeInCore(gradient) {
-        if (this.exponent <= 0) {
-            return gradient;
-        }
-        return (Math.exp(this.exponent * gradient) - 1.0) / (Math.exp(this.exponent) - 1.0);
-    }
-}
-/**
- * Easing function with a power of 2 shape (see link below).
- * @see https://easings.net/#easeInQuad
- * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#easing-functions
- */
-class QuadraticEase extends EasingFunction {
-    /**
-     * @internal
-     */
-    easeInCore(gradient) {
-        return gradient * gradient;
-    }
-}
-
-export { BackEase as B, EasingFunction as E, QuadraticEase as Q, ExponentialEase as a };