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

package/dist/node_modules/@babylonjs/core/Engines/nullEngine.esm.js

@@ -1,697 +0,0 @@
-import { Logger as _ } from "../Misc/logger.esm.js";
-import { Engine as d } from "./engine.esm.js";
-import { InternalTexture as l, InternalTextureSource as o } from "../Materials/Textures/internalTexture.esm.js";
-import { DataBuffer as c } from "../Buffers/dataBuffer.esm.js";
-import { PerformanceConfigurator as T } from "./performanceConfigurator.esm.js";
-import { DrawWrapper as b } from "../Materials/drawWrapper.esm.js";
-import { RenderTargetWrapper as B } from "./renderTargetWrapper.esm.js";
-class S {
-  constructor() {
-    this.renderWidth = 512, this.renderHeight = 256, this.textureSize = 512, this.deterministicLockstep = !1, this.lockstepMaxSteps = 4;
-  }
-}
-class v extends d {
-  /**
-   * Gets a boolean indicating that the engine is running in deterministic lock step mode
-   * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#deterministic-lockstep
-   * @returns true if engine is in deterministic lock step mode
-   */
-  isDeterministicLockStep() {
-    return this._options.deterministicLockstep;
-  }
-  /**
-   * Gets the max steps when engine is running in deterministic lock step
-   * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#deterministic-lockstep
-   * @returns the max steps
-   */
-  getLockstepMaxSteps() {
-    return this._options.lockstepMaxSteps;
-  }
-  /**
-   * Gets the current hardware scaling level.
-   * By default the hardware scaling level is computed from the window device ratio.
-   * if level = 1 then the engine will render at the exact resolution of the canvas. If level = 0.5 then the engine will render at twice the size of the canvas.
-   * @returns a number indicating the current hardware scaling level
-   */
-  getHardwareScalingLevel() {
-    return 1;
-  }
-  constructor(e = new S()) {
-    super(null), d.Instances.push(this), e.deterministicLockstep === void 0 && (e.deterministicLockstep = !1), e.lockstepMaxSteps === void 0 && (e.lockstepMaxSteps = 4), this._options = e, T.SetMatrixPrecision(!!e.useHighPrecisionMatrix), this._caps = {
-      maxTexturesImageUnits: 16,
-      maxVertexTextureImageUnits: 16,
-      maxCombinedTexturesImageUnits: 32,
-      maxTextureSize: 512,
-      maxCubemapTextureSize: 512,
-      maxRenderTextureSize: 512,
-      maxVertexAttribs: 16,
-      maxVaryingVectors: 16,
-      maxFragmentUniformVectors: 16,
-      maxVertexUniformVectors: 16,
-      standardDerivatives: !1,
-      astc: null,
-      pvrtc: null,
-      etc1: null,
-      etc2: null,
-      bptc: null,
-      maxAnisotropy: 0,
-      uintIndices: !1,
-      fragmentDepthSupported: !1,
-      highPrecisionShaderSupported: !0,
-      colorBufferFloat: !1,
-      textureFloat: !1,
-      textureFloatLinearFiltering: !1,
-      textureFloatRender: !1,
-      textureHalfFloat: !1,
-      textureHalfFloatLinearFiltering: !1,
-      textureHalfFloatRender: !1,
-      textureLOD: !1,
-      texelFetch: !1,
-      drawBuffersExtension: !1,
-      depthTextureExtension: !1,
-      vertexArrayObject: !1,
-      instancedArrays: !1,
-      supportOcclusionQuery: !1,
-      canUseTimestampForTimerQuery: !1,
-      maxMSAASamples: 1,
-      blendMinMax: !1,
-      canUseGLInstanceID: !1,
-      canUseGLVertexID: !1,
-      supportComputeShaders: !1,
-      supportSRGBBuffers: !1,
-      supportTransformFeedbacks: !1,
-      textureMaxLevel: !1,
-      texture2DArrayMaxLayerCount: 128,
-      disableMorphTargetTexture: !1
-    }, this._features = {
-      forceBitmapOverHTMLImageElement: !1,
-      supportRenderAndCopyToLodForFloatTextures: !1,
-      supportDepthStencilTexture: !1,
-      supportShadowSamplers: !1,
-      uniformBufferHardCheckMatrix: !1,
-      allowTexturePrefiltering: !1,
-      trackUbosInFrame: !1,
-      checkUbosContentBeforeUpload: !1,
-      supportCSM: !1,
-      basisNeedsPOT: !1,
-      support3DTextures: !1,
-      needTypeSuffixInShaderConstants: !1,
-      supportMSAA: !1,
-      supportSSAO2: !1,
-      supportExtendedTextureFormats: !1,
-      supportSwitchCaseInShader: !1,
-      supportSyncTextureRead: !1,
-      needsInvertingBitmap: !1,
-      useUBOBindingCache: !1,
-      needShaderCodeInlining: !1,
-      needToAlwaysBindUniformBuffers: !1,
-      supportRenderPasses: !0,
-      supportSpriteInstancing: !1,
-      _collectUbosUpdatedInFrame: !1
-    }, _.Log(`Babylon.js v${d.Version} - Null engine`);
-    const r = typeof self < "u" ? self : typeof global < "u" ? global : window;
-    typeof URL > "u" && (r.URL = {
-      createObjectURL: function() {
-      },
-      revokeObjectURL: function() {
-      }
-    }), typeof Blob > "u" && (r.Blob = function() {
-    });
-  }
-  /**
-   * Creates a vertex buffer
-   * @param vertices the data for the vertex buffer
-   * @returns the new WebGL static buffer
-   */
-  createVertexBuffer(e) {
-    const r = new c();
-    return r.references = 1, r;
-  }
-  /**
-   * Creates a new index buffer
-   * @param indices defines the content of the index buffer
-   * @returns a new webGL buffer
-   */
-  createIndexBuffer(e) {
-    const r = new c();
-    return r.references = 1, r;
-  }
-  /**
-   * Clear the current render buffer or the current render target (if any is set up)
-   * @param color defines the color to use
-   * @param backBuffer defines if the back buffer must be cleared
-   * @param depth defines if the depth buffer must be cleared
-   * @param stencil defines if the stencil buffer must be cleared
-   */
-  clear(e, r, a, t = !1) {
-  }
-  /**
-   * Gets the current render width
-   * @param useScreen defines if screen size must be used (or the current render target if any)
-   * @returns a number defining the current render width
-   */
-  getRenderWidth(e = !1) {
-    return !e && this._currentRenderTarget ? this._currentRenderTarget.width : this._options.renderWidth;
-  }
-  /**
-   * Gets the current render height
-   * @param useScreen defines if screen size must be used (or the current render target if any)
-   * @returns a number defining the current render height
-   */
-  getRenderHeight(e = !1) {
-    return !e && this._currentRenderTarget ? this._currentRenderTarget.height : this._options.renderHeight;
-  }
-  /**
-   * Set the WebGL's viewport
-   * @param viewport defines the viewport element to be used
-   * @param requiredWidth defines the width required for rendering. If not provided the rendering canvas' width is used
-   * @param requiredHeight defines the height required for rendering. If not provided the rendering canvas' height is used
-   */
-  setViewport(e, r, a) {
-    this._cachedViewport = e;
-  }
-  createShaderProgram(e, r, a, t, n) {
-    return {
-      // eslint-disable-next-line @typescript-eslint/naming-convention
-      __SPECTOR_rebuildProgram: null
-    };
-  }
-  /**
-   * Gets the list of webGL uniform locations associated with a specific program based on a list of uniform names
-   * @param pipelineContext defines the pipeline context to use
-   * @param uniformsNames defines the list of uniform names
-   * @returns an array of webGL uniform locations
-   */
-  getUniforms(e, r) {
-    return [];
-  }
-  /**
-   * Gets the lsit of active attributes for a given webGL program
-   * @param pipelineContext defines the pipeline context to use
-   * @param attributesNames defines the list of attribute names to get
-   * @returns an array of indices indicating the offset of each attribute
-   */
-  getAttributes(e, r) {
-    return [];
-  }
-  /**
-   * Binds an effect to the webGL context
-   * @param effect defines the effect to bind
-   */
-  bindSamplers(e) {
-    this._currentEffect = null;
-  }
-  /**
-   * Activates an effect, making it the current one (ie. the one used for rendering)
-   * @param effect defines the effect to activate
-   */
-  enableEffect(e) {
-    e = e !== null && b.IsWrapper(e) ? e.effect : e, this._currentEffect = e, e && (e.onBind && e.onBind(e), e._onBindObservable && e._onBindObservable.notifyObservers(e));
-  }
-  /**
-   * Set various states to the webGL context
-   * @param culling defines culling state: true to enable culling, false to disable it
-   * @param zOffset defines the value to apply to zOffset (0 by default)
-   * @param force defines if states must be applied even if cache is up to date
-   * @param reverseSide defines if culling must be reversed (CCW if false, CW if true)
-   * @param cullBackFaces true to cull back faces, false to cull front faces (if culling is enabled)
-   * @param stencil stencil states to set
-   * @param zOffsetUnits defines the value to apply to zOffsetUnits (0 by default)
-   */
-  setState(e, r = 0, a, t = !1, n, u, f = 0) {
-  }
-  /**
-   * Set the value of an uniform to an array of int32
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param array defines the array of int32 to store
-   * @returns true if value was set
-   */
-  setIntArray(e, r) {
-    return !0;
-  }
-  /**
-   * Set the value of an uniform to an array of int32 (stored as vec2)
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param array defines the array of int32 to store
-   * @returns true if value was set
-   */
-  setIntArray2(e, r) {
-    return !0;
-  }
-  /**
-   * Set the value of an uniform to an array of int32 (stored as vec3)
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param array defines the array of int32 to store
-   * @returns true if value was set
-   */
-  setIntArray3(e, r) {
-    return !0;
-  }
-  /**
-   * Set the value of an uniform to an array of int32 (stored as vec4)
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param array defines the array of int32 to store
-   * @returns true if value was set
-   */
-  setIntArray4(e, r) {
-    return !0;
-  }
-  /**
-   * Set the value of an uniform to an array of float32
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param array defines the array of float32 to store
-   * @returns true if value was set
-   */
-  setFloatArray(e, r) {
-    return !0;
-  }
-  /**
-   * Set the value of an uniform to an array of float32 (stored as vec2)
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param array defines the array of float32 to store
-   * @returns true if value was set
-   */
-  setFloatArray2(e, r) {
-    return !0;
-  }
-  /**
-   * Set the value of an uniform to an array of float32 (stored as vec3)
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param array defines the array of float32 to store
-   * @returns true if value was set
-   */
-  setFloatArray3(e, r) {
-    return !0;
-  }
-  /**
-   * Set the value of an uniform to an array of float32 (stored as vec4)
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param array defines the array of float32 to store
-   * @returns true if value was set
-   */
-  setFloatArray4(e, r) {
-    return !0;
-  }
-  /**
-   * Set the value of an uniform to an array of number
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param array defines the array of number to store
-   * @returns true if value was set
-   */
-  setArray(e, r) {
-    return !0;
-  }
-  /**
-   * Set the value of an uniform to an array of number (stored as vec2)
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param array defines the array of number to store
-   * @returns true if value was set
-   */
-  setArray2(e, r) {
-    return !0;
-  }
-  /**
-   * Set the value of an uniform to an array of number (stored as vec3)
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param array defines the array of number to store
-   * @returns true if value was set
-   */
-  setArray3(e, r) {
-    return !0;
-  }
-  /**
-   * Set the value of an uniform to an array of number (stored as vec4)
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param array defines the array of number to store
-   * @returns true if value was set
-   */
-  setArray4(e, r) {
-    return !0;
-  }
-  /**
-   * Set the value of an uniform to an array of float32 (stored as matrices)
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param matrices defines the array of float32 to store
-   * @returns true if value was set
-   */
-  setMatrices(e, r) {
-    return !0;
-  }
-  /**
-   * Set the value of an uniform to a matrix (3x3)
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param matrix defines the Float32Array representing the 3x3 matrix to store
-   * @returns true if value was set
-   */
-  setMatrix3x3(e, r) {
-    return !0;
-  }
-  /**
-   * Set the value of an uniform to a matrix (2x2)
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param matrix defines the Float32Array representing the 2x2 matrix to store
-   * @returns true if value was set
-   */
-  setMatrix2x2(e, r) {
-    return !0;
-  }
-  /**
-   * Set the value of an uniform to a number (float)
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param value defines the float number to store
-   * @returns true if value was set
-   */
-  setFloat(e, r) {
-    return !0;
-  }
-  /**
-   * Set the value of an uniform to a vec2
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param x defines the 1st component of the value
-   * @param y defines the 2nd component of the value
-   * @returns true if value was set
-   */
-  setFloat2(e, r, a) {
-    return !0;
-  }
-  /**
-   * Set the value of an uniform to a vec3
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param x defines the 1st component of the value
-   * @param y defines the 2nd component of the value
-   * @param z defines the 3rd component of the value
-   * @returns true if value was set
-   */
-  setFloat3(e, r, a, t) {
-    return !0;
-  }
-  /**
-   * Set the value of an uniform to a boolean
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param bool defines the boolean to store
-   * @returns true if value was set
-   */
-  setBool(e, r) {
-    return !0;
-  }
-  /**
-   * Set the value of an uniform to a vec4
-   * @param uniform defines the webGL uniform location where to store the value
-   * @param x defines the 1st component of the value
-   * @param y defines the 2nd component of the value
-   * @param z defines the 3rd component of the value
-   * @param w defines the 4th component of the value
-   * @returns true if value was set
-   */
-  setFloat4(e, r, a, t, n) {
-    return !0;
-  }
-  /**
-   * Sets the current alpha mode
-   * @param mode defines the mode to use (one of the Engine.ALPHA_XXX)
-   * @param noDepthWriteChange defines if depth writing state should remains unchanged (false by default)
-   * @see https://doc.babylonjs.com/features/featuresDeepDive/materials/advanced/transparent_rendering
-   */
-  setAlphaMode(e, r = !1) {
-    this._alphaMode !== e && (this.alphaState.alphaBlend = e !== 0, r || this.setDepthWrite(e === 0), this._alphaMode = e);
-  }
-  /**
-   * Bind webGl buffers directly to the webGL context
-   * @param vertexBuffers defines the vertex buffer to bind
-   * @param indexBuffer defines the index buffer to bind
-   * @param effect defines the effect associated with the vertex buffer
-   */
-  bindBuffers(e, r, a) {
-  }
-  /**
-   * Force the entire cache to be cleared
-   * You should not have to use this function unless your engine needs to share the webGL context with another engine
-   * @param bruteForce defines a boolean to force clearing ALL caches (including stencil, detoh and alpha states)
-   */
-  wipeCaches(e) {
-    this.preventCacheWipeBetweenFrames || (this.resetTextureCache(), this._currentEffect = null, e && (this._currentProgram = null, this._stencilStateComposer.reset(), this.depthCullingState.reset(), this.alphaState.reset()), this._cachedVertexBuffers = null, this._cachedIndexBuffer = null, this._cachedEffectForVertexBuffers = null);
-  }
-  /**
-   * Send a draw order
-   * @param useTriangles defines if triangles must be used to draw (else wireframe will be used)
-   * @param indexStart defines the starting index
-   * @param indexCount defines the number of index to draw
-   * @param instancesCount defines the number of instances to draw (if instantiation is enabled)
-   */
-  draw(e, r, a, t) {
-  }
-  /**
-   * Draw a list of indexed primitives
-   * @param fillMode defines the primitive to use
-   * @param indexStart defines the starting index
-   * @param indexCount defines the number of index to draw
-   * @param instancesCount defines the number of instances to draw (if instantiation is enabled)
-   */
-  drawElementsType(e, r, a, t) {
-  }
-  /**
-   * Draw a list of unindexed primitives
-   * @param fillMode defines the primitive to use
-   * @param verticesStart defines the index of first vertex to draw
-   * @param verticesCount defines the count of vertices to draw
-   * @param instancesCount defines the number of instances to draw (if instantiation is enabled)
-   */
-  drawArraysType(e, r, a, t) {
-  }
-  /** @internal */
-  _createTexture() {
-    return {};
-  }
-  /**
-   * @internal
-   */
-  _releaseTexture(e) {
-  }
-  /**
-   * Usually called from Texture.ts.
-   * Passed information to create a WebGLTexture
-   * @param urlArg defines a value which contains one of the following:
-   * * A conventional http URL, e.g. 'http://...' or 'file://...'
-   * * A base64 string of in-line texture data, e.g. 'data:image/jpg;base64,/...'
-   * * An indicator that data being passed using the buffer parameter, e.g. 'data:mytexture.jpg'
-   * @param noMipmap defines a boolean indicating that no mipmaps shall be generated.  Ignored for compressed textures.  They must be in the file
-   * @param invertY when true, image is flipped when loaded.  You probably want true. Certain compressed textures may invert this if their default is inverted (eg. ktx)
-   * @param scene needed for loading to the correct scene
-   * @param samplingMode mode with should be used sample / access the texture (Default: Texture.TRILINEAR_SAMPLINGMODE)
-   * @param onLoad optional callback to be called upon successful completion
-   * @param onError optional callback to be called upon failure
-   * @param buffer a source of a file previously fetched as either a base64 string, an ArrayBuffer (compressed or image format), HTMLImageElement (image format), or a Blob
-   * @param fallback an internal argument in case the function must be called again, due to etc1 not having alpha capabilities
-   * @param format internal format.  Default: RGB when extension is '.jpg' else RGBA.  Ignored for compressed textures
-   * @param forcedExtension defines the extension to use to pick the right loader
-   * @param mimeType defines an optional mime type
-   * @returns a InternalTexture for assignment back into BABYLON.Texture
-   */
-  createTexture(e, r, a, t, n = 3, u = null, f = null, h = null, g = null, p = null, m = null, s) {
-    const i = new l(this, o.Url), y = String(e);
-    return i.url = y, i.generateMipMaps = !r, i.samplingMode = n, i.invertY = a, i.baseWidth = this._options.textureSize, i.baseHeight = this._options.textureSize, i.width = this._options.textureSize, i.height = this._options.textureSize, p && (i.format = p), i.isReady = !0, u && setTimeout(() => {
-      u(i);
-    }), this._internalTexturesCache.push(i), i;
-  }
-  /**
-   * @internal
-   */
-  _createHardwareRenderTargetWrapper(e, r, a) {
-    const t = new B(e, r, a, this);
-    return this._renderTargetWrapperCache.push(t), t;
-  }
-  /**
-   * Creates a new render target wrapper
-   * @param size defines the size of the texture
-   * @param options defines the options used to create the texture
-   * @returns a new render target wrapper
-   */
-  createRenderTargetTexture(e, r) {
-    const a = this._createHardwareRenderTargetWrapper(!1, !1, e), t = {};
-    r !== void 0 && typeof r == "object" ? (t.generateMipMaps = r.generateMipMaps, t.generateDepthBuffer = r.generateDepthBuffer === void 0 ? !0 : r.generateDepthBuffer, t.generateStencilBuffer = t.generateDepthBuffer && r.generateStencilBuffer, t.type = r.type === void 0 ? 0 : r.type, t.samplingMode = r.samplingMode === void 0 ? 3 : r.samplingMode) : (t.generateMipMaps = r, t.generateDepthBuffer = !0, t.generateStencilBuffer = !1, t.type = 0, t.samplingMode = 3);
-    const n = new l(this, o.RenderTarget), u = e.width || e, f = e.height || e;
-    return a._generateDepthBuffer = t.generateDepthBuffer, a._generateStencilBuffer = !!t.generateStencilBuffer, n.baseWidth = u, n.baseHeight = f, n.width = u, n.height = f, n.isReady = !0, n.samples = 1, n.generateMipMaps = !!t.generateMipMaps, n.samplingMode = t.samplingMode, n.type = t.type, this._internalTexturesCache.push(n), a;
-  }
-  /**
-   * Creates a new render target wrapper
-   * @param size defines the size of the texture
-   * @param options defines the options used to create the texture
-   * @returns a new render target wrapper
-   */
-  createRenderTargetCubeTexture(e, r) {
-    const a = this._createHardwareRenderTargetWrapper(!1, !0, e), t = Object.assign({ generateMipMaps: !0, generateDepthBuffer: !0, generateStencilBuffer: !1, type: 0, samplingMode: 3, format: 5 }, r);
-    t.generateStencilBuffer = t.generateDepthBuffer && t.generateStencilBuffer, (t.type === 1 && !this._caps.textureFloatLinearFiltering || t.type === 2 && !this._caps.textureHalfFloatLinearFiltering) && (t.samplingMode = 1), a._generateDepthBuffer = t.generateDepthBuffer, a._generateStencilBuffer = !!t.generateStencilBuffer;
-    const n = new l(this, o.RenderTarget);
-    return n.baseWidth = e, n.baseHeight = e, n.width = e, n.height = e, n.isReady = !0, n.isCube = !0, n.samples = 1, n.generateMipMaps = !!t.generateMipMaps, n.samplingMode = t.samplingMode, n.type = t.type, this._internalTexturesCache.push(n), a;
-  }
-  /**
-   * Update the sampling mode of a given texture
-   * @param samplingMode defines the required sampling mode
-   * @param texture defines the texture to update
-   */
-  updateTextureSamplingMode(e, r) {
-    r.samplingMode = e;
-  }
-  /**
-   * Creates a raw texture
-   * @param data defines the data to store in the texture
-   * @param width defines the width of the texture
-   * @param height defines the height of the texture
-   * @param format defines the format of the data
-   * @param generateMipMaps defines if the engine should generate the mip levels
-   * @param invertY defines if data must be stored with Y axis inverted
-   * @param samplingMode defines the required sampling mode (Texture.NEAREST_SAMPLINGMODE by default)
-   * @param compression defines the compression used (null by default)
-   * @param type defines the type fo the data (Engine.TEXTURETYPE_UNSIGNED_INT by default)
-   * @param creationFlags specific flags to use when creating the texture (1 for storage textures, for eg)
-   * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).
-   * @returns the raw texture inside an InternalTexture
-   */
-  createRawTexture(e, r, a, t, n, u, f, h = null, g = 0, p = 0, m = !1) {
-    const s = new l(this, o.Raw);
-    return s.baseWidth = r, s.baseHeight = a, s.width = r, s.height = a, s.format = t, s.generateMipMaps = n, s.samplingMode = f, s.invertY = u, s._compression = h, s.type = g, s._useSRGBBuffer = m, this._doNotHandleContextLost || (s._bufferView = e), s;
-  }
-  /**
-   * Update a raw texture
-   * @param texture defines the texture to update
-   * @param data defines the data to store in the texture
-   * @param format defines the format of the data
-   * @param invertY defines if data must be stored with Y axis inverted
-   * @param compression defines the compression used (null by default)
-   * @param type defines the type fo the data (Engine.TEXTURETYPE_UNSIGNED_INT by default)
-   * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).
-   */
-  updateRawTexture(e, r, a, t, n = null, u = 0, f = !1) {
-    e && (e._bufferView = r, e.format = a, e.invertY = t, e._compression = n, e.type = u, e._useSRGBBuffer = f);
-  }
-  /**
-   * Binds the frame buffer to the specified texture.
-   * @param rtWrapper The render target wrapper to render to
-   * @param faceIndex The face of the texture to render to in case of cube texture
-   * @param requiredWidth The width of the target to render to
-   * @param requiredHeight The height of the target to render to
-   * @param forceFullscreenViewport Forces the viewport to be the entire texture/screen if true
-   */
-  bindFramebuffer(e, r, a, t, n) {
-    this._currentRenderTarget && this.unBindFramebuffer(this._currentRenderTarget), this._currentRenderTarget = e, this._currentFramebuffer = null, this._cachedViewport && !n && this.setViewport(this._cachedViewport, a, t);
-  }
-  /**
-   * Unbind the current render target texture from the webGL context
-   * @param rtWrapper defines the render target wrapper to unbind
-   * @param disableGenerateMipMaps defines a boolean indicating that mipmaps must not be generated
-   * @param onBeforeUnbind defines a function which will be called before the effective unbind
-   */
-  unBindFramebuffer(e, r = !1, a) {
-    this._currentRenderTarget = null, a && a(), this._currentFramebuffer = null;
-  }
-  /**
-   * Creates a dynamic vertex buffer
-   * @param vertices the data for the dynamic vertex buffer
-   * @returns the new WebGL dynamic buffer
-   */
-  createDynamicVertexBuffer(e) {
-    const r = new c();
-    return r.references = 1, r.capacity = 1, r;
-  }
-  /**
-   * Update the content of a dynamic texture
-   * @param texture defines the texture to update
-   * @param canvas defines the canvas containing the source
-   * @param invertY defines if data must be stored with Y axis inverted
-   * @param premulAlpha defines if alpha is stored as premultiplied
-   * @param format defines the format of the data
-   */
-  updateDynamicTexture(e, r, a, t = !1, n) {
-  }
-  /**
-   * Gets a boolean indicating if all created effects are ready
-   * @returns true if all effects are ready
-   */
-  areAllEffectsReady() {
-    return !0;
-  }
-  /**
-   * @internal
-   * Get the current error code of the webGL context
-   * @returns the error code
-   * @see https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/getError
-   */
-  getError() {
-    return 0;
-  }
-  /** @internal */
-  _getUnpackAlignement() {
-    return 1;
-  }
-  /**
-   * @internal
-   */
-  _unpackFlipY(e) {
-  }
-  /**
-   * Update a dynamic index buffer
-   * @param indexBuffer defines the target index buffer
-   * @param indices defines the data to update
-   * @param offset defines the offset in the target index buffer where update should start
-   */
-  updateDynamicIndexBuffer(e, r, a = 0) {
-  }
-  /**
-   * Updates a dynamic vertex buffer.
-   * @param vertexBuffer the vertex buffer to update
-   * @param vertices the data used to update the vertex buffer
-   * @param byteOffset the byte offset of the data (optional)
-   * @param byteLength the byte length of the data (optional)
-   */
-  updateDynamicVertexBuffer(e, r, a, t) {
-  }
-  /**
-   * @internal
-   */
-  _bindTextureDirectly(e, r) {
-    return this._boundTexturesCache[this._activeChannel] !== r ? (this._boundTexturesCache[this._activeChannel] = r, !0) : !1;
-  }
-  /**
-   * @internal
-   */
-  _bindTexture(e, r) {
-    e < 0 || this._bindTextureDirectly(0, r);
-  }
-  _deleteBuffer(e) {
-  }
-  /**
-   * Force the engine to release all cached effects. This means that next effect compilation will have to be done completely even if a similar effect was already compiled
-   */
-  releaseEffects() {
-  }
-  displayLoadingUI() {
-  }
-  hideLoadingUI() {
-  }
-  set loadingUIText(e) {
-  }
-  /**
-   * @internal
-   */
-  _uploadCompressedDataToTextureDirectly(e, r, a, t, n, u = 0, f = 0) {
-  }
-  /**
-   * @internal
-   */
-  _uploadDataToTextureDirectly(e, r, a = 0, t = 0) {
-  }
-  /**
-   * @internal
-   */
-  _uploadArrayBufferViewToTexture(e, r, a = 0, t = 0) {
-  }
-  /**
-   * @internal
-   */
-  _uploadImageToTexture(e, r, a = 0, t = 0) {
-  }
-}
-export {
-  v as NullEngine,
-  S as NullEngineOptions
-};