rhodonite 0.4.2 → 0.5.2

package/dist/esm/foundation/materials/nodes/ProjectionMatrixShaderNode.d.ts

@@ -1,4 +1,4 @@
-import AbstractShaderNode from '../core/AbstractShaderNode';
-export default class ProjectionMatrixShaderNode extends AbstractShaderNode {
-    constructor();
-}
+import AbstractShaderNode from '../core/AbstractShaderNode';
+export default class ProjectionMatrixShaderNode extends AbstractShaderNode {
+    constructor();
+}

package/dist/esm/foundation/materials/nodes/ScalarToVector4ShaderNode.d.ts

@@ -1,4 +1,4 @@
-import AbstractShaderNode from '../core/AbstractShaderNode';
-export default class ScalarToVector4ShaderNode extends AbstractShaderNode {
-    constructor();
-}
+import AbstractShaderNode from '../core/AbstractShaderNode';
+export default class ScalarToVector4ShaderNode extends AbstractShaderNode {
+    constructor();
+}

package/dist/esm/foundation/materials/nodes/TextureFetchMaterialNode.d.ts

@@ -1,6 +1,6 @@
-import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-export default class TextureFetchMaterialNode extends AbstractMaterialNode {
-    generalTextureMaterialNodeUID?: ShaderSemanticsClass;
-    constructor();
-}
+import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
+import AbstractMaterialNode from '../core/AbstractMaterialNode';
+export default class TextureFetchMaterialNode extends AbstractMaterialNode {
+    generalTextureMaterialNodeUID?: ShaderSemanticsClass;
+    constructor();
+}

package/dist/esm/foundation/materials/nodes/UniformDataShaderNode.d.ts

@@ -1,8 +1,8 @@
-import { CompositionTypeEnum } from '../../definitions/CompositionType';
-import { ComponentTypeEnum } from '../../definitions/ComponentType';
-import AbstractShaderNode from '../core/AbstractShaderNode';
-export default class UniformDataShaderNode extends AbstractShaderNode {
-    constructor(compositionType: CompositionTypeEnum, componentType: ComponentTypeEnum);
-    setDefaultInputValue(inputName: string, value: any): void;
-    setUniformDataName(value: any): void;
-}
+import { CompositionTypeEnum } from '../../definitions/CompositionType';
+import { ComponentTypeEnum } from '../../definitions/ComponentType';
+import AbstractShaderNode from '../core/AbstractShaderNode';
+export default class UniformDataShaderNode extends AbstractShaderNode {
+    constructor(compositionType: CompositionTypeEnum, componentType: ComponentTypeEnum);
+    setDefaultInputValue(inputName: string, value: any): void;
+    setUniformDataName(value: any): void;
+}

package/dist/esm/foundation/materials/nodes/VaryingInVariableShaderNode.d.ts

@@ -1,7 +1,7 @@
-import { CompositionTypeEnum } from '../../definitions/CompositionType';
-import { ComponentTypeEnum } from '../../definitions/ComponentType';
-import AbstractShaderNode from '../core/AbstractShaderNode';
-export default class VaryingInVariableShaderNode extends AbstractShaderNode {
-    constructor(compositionType: CompositionTypeEnum, componentType: ComponentTypeEnum);
-    setVaryingVariableName(value: any): void;
-}
+import { CompositionTypeEnum } from '../../definitions/CompositionType';
+import { ComponentTypeEnum } from '../../definitions/ComponentType';
+import AbstractShaderNode from '../core/AbstractShaderNode';
+export default class VaryingInVariableShaderNode extends AbstractShaderNode {
+    constructor(compositionType: CompositionTypeEnum, componentType: ComponentTypeEnum);
+    setVaryingVariableName(value: any): void;
+}

package/dist/esm/foundation/materials/nodes/VaryingOutVariableShaderNode.d.ts

@@ -1,7 +1,7 @@
-import { CompositionTypeEnum } from '../../definitions/CompositionType';
-import { ComponentTypeEnum } from '../../definitions/ComponentType';
-import AbstractShaderNode from '../core/AbstractShaderNode';
-export default class VaryingOutVariableShaderNode extends AbstractShaderNode {
-    constructor(compositionType: CompositionTypeEnum, componentType: ComponentTypeEnum);
-    setVaryingVariableName(value: any): void;
-}
+import { CompositionTypeEnum } from '../../definitions/CompositionType';
+import { ComponentTypeEnum } from '../../definitions/ComponentType';
+import AbstractShaderNode from '../core/AbstractShaderNode';
+export default class VaryingOutVariableShaderNode extends AbstractShaderNode {
+    constructor(compositionType: CompositionTypeEnum, componentType: ComponentTypeEnum);
+    setVaryingVariableName(value: any): void;
+}

package/dist/esm/foundation/materials/nodes/Vector3AndScalarToVector4ShaderNode.d.ts

@@ -1,4 +1,4 @@
-import AbstractShaderNode from '../core/AbstractShaderNode';
-export default class Vector3AndScalarToVector4ShaderNode extends AbstractShaderNode {
-    constructor();
-}
+import AbstractShaderNode from '../core/AbstractShaderNode';
+export default class Vector3AndScalarToVector4ShaderNode extends AbstractShaderNode {
+    constructor();
+}

package/dist/esm/foundation/materials/nodes/ViewMatrixShaderNode.d.ts

@@ -1,4 +1,4 @@
-import AbstractShaderNode from '../core/AbstractShaderNode';
-export default class ViewMatrixShaderNode extends AbstractShaderNode {
-    constructor();
-}
+import AbstractShaderNode from '../core/AbstractShaderNode';
+export default class ViewMatrixShaderNode extends AbstractShaderNode {
+    constructor();
+}

package/dist/esm/foundation/materials/nodes/WireframeMaterialNode.d.ts

@@ -1,4 +1,4 @@
-import AbstractShaderNode from '../core/AbstractShaderNode';
-export default class WireframeMaterialNode extends AbstractShaderNode {
-    constructor();
-}
+import AbstractShaderNode from '../core/AbstractShaderNode';
+export default class WireframeMaterialNode extends AbstractShaderNode {
+    constructor();
+}

package/dist/esm/foundation/materials/nodes/WorldMatrixShaderNode.d.ts

@@ -1,4 +1,4 @@
-import AbstractShaderNode from '../core/AbstractShaderNode';
-export default class WorldMatrixShaderNode extends AbstractShaderNode {
-    constructor();
-}
+import AbstractShaderNode from '../core/AbstractShaderNode';
+export default class WorldMatrixShaderNode extends AbstractShaderNode {
+    constructor();
+}

package/dist/esm/foundation/materials/singles/ClassicShadingSingleMaterialNode.d.ts

@@ -1,16 +1,16 @@
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-import Material from '../core/Material';
-import { AlphaModeEnum } from '../../definitions/AlphaMode';
-export default class ClassicShadingSingleMaterialNode extends AbstractMaterialNode {
-    constructor({ isSkinning, isLighting, alphaMode, }: {
-        isSkinning: boolean;
-        isLighting: boolean;
-        alphaMode: AlphaModeEnum;
-    });
-    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
-        material: Material;
-        shaderProgram: WebGLProgram;
-        firstTime: boolean;
-        args?: any;
-    }): void;
-}
+import AbstractMaterialNode from '../core/AbstractMaterialNode';
+import Material from '../core/Material';
+import { AlphaModeEnum } from '../../definitions/AlphaMode';
+export default class ClassicShadingSingleMaterialNode extends AbstractMaterialNode {
+    constructor({ isSkinning, isLighting, alphaMode, }: {
+        isSkinning: boolean;
+        isLighting: boolean;
+        alphaMode: AlphaModeEnum;
+    });
+    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+}

package/dist/esm/foundation/materials/singles/ColorGradingUsingLUTsSingleMaterialNode.d.ts

@@ -1,16 +1,16 @@
-import AbstractTexture from '../../textures/AbstractTexture';
-import { Count } from '../../../types/CommonTypes';
-import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
-import RenderPass from '../../renderer/RenderPass';
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-import Material from '../core/Material';
-export default class ColorGradingUsingLUTsSingleMaterialNode extends AbstractMaterialNode {
-    static lookupTableTexture: ShaderSemanticsClass;
-    constructor(targetRenderPass: RenderPass, colorAttachmentsNumber: Count, uri?: string, texture?: AbstractTexture);
-    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
-        material: Material;
-        shaderProgram: WebGLProgram;
-        firstTime: boolean;
-        args?: any;
-    }): void;
-}
+import AbstractTexture from '../../textures/AbstractTexture';
+import { Count } from '../../../types/CommonTypes';
+import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
+import RenderPass from '../../renderer/RenderPass';
+import AbstractMaterialNode from '../core/AbstractMaterialNode';
+import Material from '../core/Material';
+export default class ColorGradingUsingLUTsSingleMaterialNode extends AbstractMaterialNode {
+    static lookupTableTexture: ShaderSemanticsClass;
+    constructor(targetRenderPass: RenderPass, colorAttachmentsNumber: Count, uri?: string, texture?: AbstractTexture);
+    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+}

package/dist/esm/foundation/materials/singles/CustomSingleMaterialNode.d.ts

@@ -1,31 +1,30 @@
-import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-import Material from '../core/Material';
-import { ShaderityObject } from 'shaderity';
-import { AlphaModeEnum } from '../../definitions/AlphaMode';
-export default class CustomSingleMaterialNode extends AbstractMaterialNode {
-    private static __pbrCookTorranceBrdfLutDataUrlUid;
-    static BaseColorTextureTransform: ShaderSemanticsClass;
-    static BaseColorTextureRotation: ShaderSemanticsClass;
-    static NormalTextureTransform: ShaderSemanticsClass;
-    static NormalTextureRotation: ShaderSemanticsClass;
-    static MetallicRoughnessTextureTransform: ShaderSemanticsClass;
-    static MetallicRoughnessTextureRotation: ShaderSemanticsClass;
-    private static __shaderityUtility;
-    constructor({ name, isMorphing, isSkinning, isLighting, alphaMode, vertexShader, pixelShader, }: {
-        name: string;
-        isMorphing: boolean;
-        isSkinning: boolean;
-        isLighting: boolean;
-        alphaMode: AlphaModeEnum;
-        vertexShader: ShaderityObject;
-        pixelShader: ShaderityObject;
-    });
-    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
-        material: Material;
-        shaderProgram: WebGLProgram;
-        firstTime: boolean;
-        args?: any;
-    }): void;
-    private setupHdriParameters;
-}
+import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
+import AbstractMaterialNode from '../core/AbstractMaterialNode';
+import Material from '../core/Material';
+import { ShaderityObject } from 'shaderity';
+import { AlphaModeEnum } from '../../definitions/AlphaMode';
+export default class CustomSingleMaterialNode extends AbstractMaterialNode {
+    private static __pbrCookTorranceBrdfLutDataUrlUid;
+    static BaseColorTextureTransform: ShaderSemanticsClass;
+    static BaseColorTextureRotation: ShaderSemanticsClass;
+    static NormalTextureTransform: ShaderSemanticsClass;
+    static NormalTextureRotation: ShaderSemanticsClass;
+    static MetallicRoughnessTextureTransform: ShaderSemanticsClass;
+    static MetallicRoughnessTextureRotation: ShaderSemanticsClass;
+    constructor({ name, isMorphing, isSkinning, isLighting, alphaMode, vertexShader, pixelShader, }: {
+        name: string;
+        isMorphing: boolean;
+        isSkinning: boolean;
+        isLighting: boolean;
+        alphaMode: AlphaModeEnum;
+        vertexShader: ShaderityObject;
+        pixelShader: ShaderityObject;
+    });
+    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+    private setupHdriParameters;
+}

package/dist/esm/foundation/materials/singles/DepthEncodeSingleMaterialNode.d.ts

@@ -1,20 +1,20 @@
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-import Material from '../core/Material';
-import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
-export default class DepthEncodeSingleMaterialNode extends AbstractMaterialNode {
-    static zNearInner: ShaderSemanticsClass;
-    static zFarInner: ShaderSemanticsClass;
-    static isPointLight: ShaderSemanticsClass;
-    static depthPow: ShaderSemanticsClass;
-    private __lastZNear;
-    private __lastZFar;
-    constructor(depthPow: number, { isSkinning }: {
-        isSkinning: boolean;
-    });
-    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
-        material: Material;
-        shaderProgram: WebGLProgram;
-        firstTime: boolean;
-        args?: any;
-    }): void;
-}
+import AbstractMaterialNode from '../core/AbstractMaterialNode';
+import Material from '../core/Material';
+import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
+export default class DepthEncodeSingleMaterialNode extends AbstractMaterialNode {
+    static zNearInner: ShaderSemanticsClass;
+    static zFarInner: ShaderSemanticsClass;
+    static isPointLight: ShaderSemanticsClass;
+    static depthPow: ShaderSemanticsClass;
+    private __lastZNear;
+    private __lastZFar;
+    constructor(depthPow: number, { isSkinning }: {
+        isSkinning: boolean;
+    });
+    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+}

package/dist/esm/foundation/materials/singles/DetectHighLuminanceSingleMaterialNode.d.ts

@@ -1,16 +1,16 @@
-import { ShaderSemanticsEnum } from '../../definitions/ShaderSemantics';
-import RenderPass from '../../renderer/RenderPass';
-import { Count } from '../../../types/CommonTypes';
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-import Material from '../core/Material';
-export default class DetectHighLuminanceSingleMaterialNode extends AbstractMaterialNode {
-    static LuminanceCriterion: ShaderSemanticsEnum;
-    static LuminanceReduce: ShaderSemanticsEnum;
-    static FramebufferWidth: ShaderSemanticsEnum;
-    constructor(HDRRenderPass: RenderPass, colorAttachmentsNumber: Count);
-    setParametersForGPU({ material, shaderProgram, args, }: {
-        material: Material;
-        shaderProgram: WebGLProgram;
-        args?: any;
-    }): void;
-}
+import { ShaderSemanticsEnum } from '../../definitions/ShaderSemantics';
+import RenderPass from '../../renderer/RenderPass';
+import { Count } from '../../../types/CommonTypes';
+import AbstractMaterialNode from '../core/AbstractMaterialNode';
+import Material from '../core/Material';
+export default class DetectHighLuminanceSingleMaterialNode extends AbstractMaterialNode {
+    static LuminanceCriterion: ShaderSemanticsEnum;
+    static LuminanceReduce: ShaderSemanticsEnum;
+    static FramebufferWidth: ShaderSemanticsEnum;
+    constructor(HDRRenderPass: RenderPass, colorAttachmentsNumber: Count);
+    setParametersForGPU({ material, shaderProgram, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        args?: any;
+    }): void;
+}

package/dist/esm/foundation/materials/singles/EntityUIDOutputSingleMaterialNode.d.ts

@@ -1,11 +1,11 @@
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-import Material from '../core/Material';
-export default class EntityUIDOutputSingleMaterialNode extends AbstractMaterialNode {
-    constructor();
-    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
-        material: Material;
-        shaderProgram: WebGLProgram;
-        firstTime: boolean;
-        args?: any;
-    }): void;
-}
+import AbstractMaterialNode from '../core/AbstractMaterialNode';
+import Material from '../core/Material';
+export default class EntityUIDOutputSingleMaterialNode extends AbstractMaterialNode {
+    constructor();
+    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+}

package/dist/esm/foundation/materials/singles/EnvConstantSingleMaterialNode.d.ts

@@ -1,14 +1,14 @@
-import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-import Material from '../core/Material';
-export default class EnvConstantSingleMaterialNode extends AbstractMaterialNode {
-    static envRotation: ShaderSemanticsClass;
-    static EnvHdriFormat: ShaderSemanticsClass;
-    constructor(makeOutputSrgb: boolean);
-    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
-        material: Material;
-        shaderProgram: WebGLProgram;
-        firstTime: boolean;
-        args?: any;
-    }): void;
-}
+import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
+import AbstractMaterialNode from '../core/AbstractMaterialNode';
+import Material from '../core/Material';
+export default class EnvConstantSingleMaterialNode extends AbstractMaterialNode {
+    static envRotation: ShaderSemanticsClass;
+    static EnvHdriFormat: ShaderSemanticsClass;
+    constructor(makeOutputSrgb: boolean);
+    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+}

package/dist/esm/foundation/materials/singles/FXAA3QualitySingleMaterialNode.d.ts

@@ -1,11 +1,11 @@
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-import Material from '../core/Material';
-export default class FXAA3QualitySingleMaterialNode extends AbstractMaterialNode {
-    constructor();
-    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
-        material: Material;
-        shaderProgram: WebGLProgram;
-        firstTime: boolean;
-        args?: any;
-    }): void;
-}
+import AbstractMaterialNode from '../core/AbstractMaterialNode';
+import Material from '../core/Material';
+export default class FXAA3QualitySingleMaterialNode extends AbstractMaterialNode {
+    constructor();
+    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+}

package/dist/esm/foundation/materials/singles/FurnaceTestSingleMaterialNode.d.ts

@@ -1,17 +1,17 @@
-import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-import Material from '../core/Material';
-export default class FurnaceTestSingleMaterialNode extends AbstractMaterialNode {
-    static mode: ShaderSemanticsClass;
-    static debugView: ShaderSemanticsClass;
-    static g_type: ShaderSemanticsClass;
-    static disable_fresnel: ShaderSemanticsClass;
-    static f0: ShaderSemanticsClass;
-    constructor();
-    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
-        material: Material;
-        shaderProgram: WebGLProgram;
-        firstTime: boolean;
-        args?: any;
-    }): void;
-}
+import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
+import AbstractMaterialNode from '../core/AbstractMaterialNode';
+import Material from '../core/Material';
+export default class FurnaceTestSingleMaterialNode extends AbstractMaterialNode {
+    static mode: ShaderSemanticsClass;
+    static debugView: ShaderSemanticsClass;
+    static g_type: ShaderSemanticsClass;
+    static disable_fresnel: ShaderSemanticsClass;
+    static f0: ShaderSemanticsClass;
+    constructor();
+    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+}

package/dist/esm/foundation/materials/singles/GammaCorrectionSingleMaterialNode.d.ts

@@ -1,11 +1,11 @@
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-import Material from '../core/Material';
-export default class GammaCorrectionSingleMaterialNode extends AbstractMaterialNode {
-    constructor();
-    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
-        material: Material;
-        shaderProgram: WebGLProgram;
-        firstTime: boolean;
-        args?: any;
-    }): void;
-}
+import AbstractMaterialNode from '../core/AbstractMaterialNode';
+import Material from '../core/Material';
+export default class GammaCorrectionSingleMaterialNode extends AbstractMaterialNode {
+    constructor();
+    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+}

package/dist/esm/foundation/materials/singles/GaussianBlurForEncodedDepthSingleMaterialNode.d.ts

@@ -1,27 +1,27 @@
-import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-import Material from '../core/Material';
-export default class GaussianBlurForEncodedDepthNode extends AbstractMaterialNode {
-    static GaussianKernelSize: ShaderSemanticsClass;
-    static GaussianRatio: ShaderSemanticsClass;
-    static IsHorizontal: ShaderSemanticsClass;
-    private frameBufferWidth;
-    /**
-     * GaussianBlurForEncodedDepthNode applies a Gaussian blur to the result of
-     * DepthEncodeMaterial. The blur is applied only in the vertical or horizontal
-     * direction. The direction can be changed by setting IsHorizontal in
-     * material.setParameter. To use this node, you need to set GaussianKernelSize
-     * and GaussianRatio to the appropriate values using the material.setParameter
-     * method and to set BaseColorTexture to the target texture using the
-     * material.setTextureParameter method. The GaussianKernelSize must be between
-     * 1 and 30. The GaussianRatio can be computed using the
-     * MathUtil.computeGaussianDistributionRatioWhoseSumIsOne method.
-     */
-    constructor();
-    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
-        material: Material;
-        shaderProgram: WebGLProgram;
-        firstTime: boolean;
-        args?: any;
-    }): void;
-}
+import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
+import AbstractMaterialNode from '../core/AbstractMaterialNode';
+import Material from '../core/Material';
+export default class GaussianBlurForEncodedDepthNode extends AbstractMaterialNode {
+    static GaussianKernelSize: ShaderSemanticsClass;
+    static GaussianRatio: ShaderSemanticsClass;
+    static IsHorizontal: ShaderSemanticsClass;
+    private frameBufferWidth;
+    /**
+     * GaussianBlurForEncodedDepthNode applies a Gaussian blur to the result of
+     * DepthEncodeMaterial. The blur is applied only in the vertical or horizontal
+     * direction. The direction can be changed by setting IsHorizontal in
+     * material.setParameter. To use this node, you need to set GaussianKernelSize
+     * and GaussianRatio to the appropriate values using the material.setParameter
+     * method and to set BaseColorTexture to the target texture using the
+     * material.setTextureParameter method. The GaussianKernelSize must be between
+     * 1 and 30. The GaussianRatio can be computed using the
+     * MathUtil.computeGaussianDistributionRatioWhoseSumIsOne method.
+     */
+    constructor();
+    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+}

package/dist/esm/foundation/materials/singles/GaussianBlurSingleMaterialNode.d.ts

@@ -1,27 +1,27 @@
-import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-import Material from '../core/Material';
-export default class GaussianBlurNode extends AbstractMaterialNode {
-    static GaussianKernelSize: ShaderSemanticsClass;
-    static GaussianRatio: ShaderSemanticsClass;
-    static IsHorizontal: ShaderSemanticsClass;
-    private frameBufferWidth;
-    /**
-     * GaussianBlurNode applies a Gaussian blur to a input texture. The blur is
-     * applied only in the vertical or horizontal direction. The direction can
-     * be changed by setting IsHorizontal in material.setParameter.
-     * To use this node, you need to set GaussianKernelSize and GaussianRatio
-     * to the appropriate values using the material.setParameter method and to
-     * set BaseColorTexture to the target texture using the
-     * material.setTextureParameter method. The GaussianKernelSize must be
-     * between 1 and 30. The GaussianRatio can be computed using the
-     * MathUtil.computeGaussianDistributionRatioWhoseSumIsOne method.
-     */
-    constructor();
-    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
-        material: Material;
-        shaderProgram: WebGLProgram;
-        firstTime: boolean;
-        args?: any;
-    }): void;
-}
+import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
+import AbstractMaterialNode from '../core/AbstractMaterialNode';
+import Material from '../core/Material';
+export default class GaussianBlurNode extends AbstractMaterialNode {
+    static GaussianKernelSize: ShaderSemanticsClass;
+    static GaussianRatio: ShaderSemanticsClass;
+    static IsHorizontal: ShaderSemanticsClass;
+    private frameBufferWidth;
+    /**
+     * GaussianBlurNode applies a Gaussian blur to a input texture. The blur is
+     * applied only in the vertical or horizontal direction. The direction can
+     * be changed by setting IsHorizontal in material.setParameter.
+     * To use this node, you need to set GaussianKernelSize and GaussianRatio
+     * to the appropriate values using the material.setParameter method and to
+     * set BaseColorTexture to the target texture using the
+     * material.setTextureParameter method. The GaussianKernelSize must be
+     * between 1 and 30. The GaussianRatio can be computed using the
+     * MathUtil.computeGaussianDistributionRatioWhoseSumIsOne method.
+     */
+    constructor();
+    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+}