rhodonite 0.4.2 → 0.5.2

package/dist/esm/foundation/materials/core/Material.d.ts

@@ -1,149 +1,181 @@
-import RnObject from '../../core/RnObject';
-import { AlphaModeEnum } from '../../definitions/AlphaMode';
-import AbstractMaterialNode from './AbstractMaterialNode';
-import { ShaderSemanticsEnum, ShaderSemanticsInfo, getShaderPropertyFunc } from '../../definitions/ShaderSemantics';
-import AbstractTexture from '../../textures/AbstractTexture';
-import Accessor from '../../memory/Accessor';
-import { Index, CGAPIResourceHandle, IndexOf16Bytes } from '../../../types/CommonTypes';
-/**
- * The material class.
- * This class has one or more material nodes.
- */
-export default class Material extends RnObject {
-    private __materialNodes;
-    private __fields;
-    private __fieldsForNonSystem;
-    private static __soloDatumFields;
-    private __fieldsInfo;
-    _shaderProgramUid: CGAPIResourceHandle;
-    private __alphaMode;
-    private static __shaderHashMap;
-    private static __shaderStringMap;
-    private static __materials;
-    private static __instancesByTypes;
-    private __materialTid;
-    private static __materialTidCount;
-    private static __materialTids;
-    private static __materialInstanceCountOfType;
-    private __materialSid;
-    private static __materialTypes;
-    private static __maxInstances;
-    private __materialTypeName;
-    private static __bufferViews;
-    private static __accessors;
-    cullFace: boolean;
-    cullFrontFaceCCW: boolean;
-    private __blendEquationMode;
-    private __blendEquationModeAlpha;
-    private __blendFuncSrcFactor;
-    private __blendFuncDstFactor;
-    private __blendFuncAlphaSrcFactor;
-    private __blendFuncAlphaDstFactor;
-    private __alphaToCoverage;
-    private constructor();
-    get materialTypeName(): string;
-    /**
-     * Gets materialTID.
-     */
-    get materialTID(): number;
-    get fieldsInfoArray(): ShaderSemanticsInfo[];
-    /**
-     * Creates an instance of this Material class.
-     * @param materialTypeName The material type to create.
-     * @param materialNodes_ The material nodes to add to the created material.
-     */
-    static createMaterial(materialTypeName: string, materialNodes_?: AbstractMaterialNode[]): Material;
-    static isRegisteredMaterialType(materialTypeName: string): boolean;
-    static _calcAlignedByteLength(semanticInfo: ShaderSemanticsInfo): number;
-    private static __allocateBufferView;
-    /**
-     * Registers the material type.
-     * @param materialTypeName The type name of the material.
-     * @param materialNodes The material nodes to register.
-     * @param maxInstancesNumber The maximum number to create the material instances.
-     */
-    static registerMaterial(materialTypeName: string, materialNodes: AbstractMaterialNode[], maxInstanceNumber?: number): boolean;
-    static forceRegisterMaterial(materialTypeName: string, materialNodes: AbstractMaterialNode[], maxInstanceNumber?: number): boolean;
-    static getAllMaterials(): Material[];
-    setMaterialNodes(materialNodes: AbstractMaterialNode[]): void;
-    get materialSID(): number;
-    get isSkinning(): boolean;
-    get isMorphing(): boolean;
-    get isLighting(): boolean;
-    /**
-     * @private
-     */
-    static _getPropertyIndex(semanticInfo: ShaderSemanticsInfo): number;
-    /**
-     * @private
-     */
-    static _getPropertyIndex2(shaderSemantic: ShaderSemanticsEnum, index?: Index): number;
-    initialize(): void;
-    setParameter(shaderSemantic: ShaderSemanticsEnum, value: any, index?: Index): void;
-    setTextureParameter(shaderSemantic: ShaderSemanticsEnum, value: AbstractTexture): void;
-    getParameter(shaderSemantic: ShaderSemanticsEnum): any;
-    setUniformLocations(shaderProgramUid: CGAPIResourceHandle, isUniformOnlyMode: boolean): void;
-    /**
-     * @private
-     */
-    _setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
-        material: Material;
-        shaderProgram: WebGLProgram;
-        firstTime: boolean;
-        args?: any;
-    }): void;
-    setSoloDatumParametersForGPU({ shaderProgram, firstTime, args, }: {
-        shaderProgram: WebGLProgram;
-        firstTime: boolean;
-        args?: any;
-    }): void;
-    private __setupGlobalShaderDefinition;
-    createProgramAsSingleOperation(vertexShaderMethodDefinitions_uniform: string, propertySetter: getShaderPropertyFunc, isWebGL2: boolean): number;
-    /**
-     * @private
-     * @param propertySetter
-     */
-    _getProperties(propertySetter: getShaderPropertyFunc, isWebGL2: boolean): {
-        vertexPropertiesStr: string;
-        pixelPropertiesStr: string;
-    };
-    createProgram(vertexShaderMethodDefinitions_uniform: string, propertySetter: getShaderPropertyFunc, isWebGL2: boolean): number;
-    isBlend(): boolean;
-    static getLocationOffsetOfMemberOfMaterial(materialTypeName: string, propertyIndex: Index): IndexOf16Bytes;
-    static getAccessorOfMemberOfMaterial(materialTypeName: string, propertyIndex: Index): Accessor | undefined;
-    get alphaMode(): AlphaModeEnum;
-    set alphaMode(mode: AlphaModeEnum);
-    /**
-     * Change the blendEquations
-     * This method works only if this alphaMode is the translucent
-     * @param blendEquationMode the argument of gl.blendEquation of the first argument of gl.blendEquationSeparate such as gl.FUNC_ADD
-     * @param blendEquationModeAlpha the second argument of gl.blendEquationSeparate
-     */
-    setBlendEquationMode(blendEquationMode: number, blendEquationModeAlpha?: number): void;
-    /**
-     * Change the blendFuncSeparateFactors
-     * This method works only if this alphaMode is the translucent
-     */
-    setBlendFuncSeparateFactor(blendFuncSrcFactor: number, blendFuncDstFactor: number, blendFuncAlphaSrcFactor: number, blendFuncAlphaDstFactor: number): void;
-    /**
-     * Change the blendFuncFactors
-     * This method works only if this alphaMode is the translucent
-     */
-    setBlendFuncFactor(blendFuncSrcFactor: number, blendFuncDstFactor: number): void;
-    get blendEquationMode(): number;
-    get blendEquationModeAlpha(): number;
-    get blendFuncSrcFactor(): number;
-    get blendFuncDstFactor(): number;
-    get blendFuncAlphaSrcFactor(): number;
-    get blendFuncAlphaDstFactor(): number;
-    isEmptyMaterial(): boolean;
-    getShaderSemanticInfoFromName(name: string): ShaderSemanticsInfo | undefined;
-    /**
-     * NOTE: To apply the alphaToCoverage, the output alpha value must not be fixed to constant value.
-     * However, some shaders in the Rhodonite fixes the output alpha value to 1 by setAlphaIfNotInAlphaBlendMode.
-     * So we need to improve the shader to use the alphaToCoverage.
-     * @param alphaToCoverage apply alphaToCoverage to this material or not
-     */
-    set alphaToCoverage(alphaToCoverage: boolean);
-    get alphaToCoverage(): boolean;
-}
+import RnObject from '../../core/RnObject';
+import { AlphaModeEnum } from '../../definitions/AlphaMode';
+import AbstractMaterialNode from './AbstractMaterialNode';
+import { ShaderSemanticsEnum, ShaderSemanticsInfo, getShaderPropertyFunc } from '../../definitions/ShaderSemantics';
+import AbstractTexture from '../../textures/AbstractTexture';
+import Accessor from '../../memory/Accessor';
+import { Index, CGAPIResourceHandle, IndexOf16Bytes } from '../../../types/CommonTypes';
+import { ShaderSources } from '../../../webgl/WebGLStrategy';
+import Primitive from '../../geometry/Primitive';
+declare type MaterialSID = Index;
+/**
+ * The material class.
+ * This class has one or more material nodes.
+ */
+export default class Material extends RnObject {
+    private __materialNodes;
+    private __fields;
+    private __fieldsForNonSystem;
+    private static __soloDatumFields;
+    private __fieldsInfo;
+    _shaderProgramUid: CGAPIResourceHandle;
+    private __alphaMode;
+    private static __shaderHashMap;
+    private static __shaderStringMap;
+    private static __materialMap;
+    private static __instances;
+    private static __instancesByTypes;
+    private static __materialTids;
+    private static __materialInstanceCountOfType;
+    private __materialUid;
+    private __materialTid;
+    private __materialSid;
+    private static __materialTidCount;
+    private static __materialUidCount;
+    private static __materialTypes;
+    private static __maxInstances;
+    private __materialTypeName;
+    private static __bufferViews;
+    private static __accessors;
+    private __belongPrimitives;
+    private __updatedShaderSources?;
+    cullFace: boolean;
+    cullFrontFaceCCW: boolean;
+    private __blendEquationMode;
+    private __blendEquationModeAlpha;
+    private __blendFuncSrcFactor;
+    private __blendFuncDstFactor;
+    private __blendFuncAlphaSrcFactor;
+    private __blendFuncAlphaDstFactor;
+    private __alphaToCoverage;
+    private constructor();
+    get materialTypeName(): string;
+    static getMaterialByMaterialUid(materialUid: MaterialSID): Material | undefined;
+    /**
+     * @private
+     * @param primitive
+     */
+    _addBelongPrimitive(primitive: Primitive): void;
+    _belongPrimitives(): Primitive[];
+    /**
+     * Gets materialTID.
+     */
+    get materialTID(): number;
+    get fieldsInfoArray(): ShaderSemanticsInfo[];
+    /**
+     * Creates an instance of this Material class.
+     * @param materialTypeName The material type to create.
+     * @param materialNodes_ The material nodes to add to the created material.
+     */
+    static createMaterial(materialTypeName: string, materialNodes_?: AbstractMaterialNode[]): Material;
+    static isRegisteredMaterialType(materialTypeName: string): boolean;
+    static _calcAlignedByteLength(semanticInfo: ShaderSemanticsInfo): number;
+    private static __allocateBufferView;
+    /**
+     * Registers the material type.
+     * @param materialTypeName The type name of the material.
+     * @param materialNodes The material nodes to register.
+     * @param maxInstancesNumber The maximum number to create the material instances.
+     */
+    static registerMaterial(materialTypeName: string, materialNodes: AbstractMaterialNode[], maxInstanceNumber?: number): boolean;
+    static forceRegisterMaterial(materialTypeName: string, materialNodes: AbstractMaterialNode[], maxInstanceNumber?: number): boolean;
+    static getAllMaterials(): Material[];
+    setMaterialNodes(materialNodes: AbstractMaterialNode[]): void;
+    get materialUID(): number;
+    get materialSID(): number;
+    get isSkinning(): boolean;
+    get isMorphing(): boolean;
+    get isLighting(): boolean;
+    /**
+     * @private
+     */
+    static _getPropertyIndex(semanticInfo: ShaderSemanticsInfo): number;
+    /**
+     * @private
+     */
+    static _getPropertyIndex2(shaderSemantic: ShaderSemanticsEnum, index?: Index): number;
+    initialize(): void;
+    setParameterByUniformName(uniformName: string, value: any, index?: Index): void;
+    setTextureParameterByUniformName(uniformName: string, value: any): void;
+    private __getTargetShaderSemantics;
+    setParameter(shaderSemantic: ShaderSemanticsEnum, value: any, index?: Index): void;
+    setTextureParameter(shaderSemantic: ShaderSemanticsEnum, value: AbstractTexture): void;
+    getParameter(shaderSemantic: ShaderSemanticsEnum): any;
+    setUniformLocationsOfMaterialNodes(isUniformOnlyMode: boolean): void;
+    /**
+     * return whether the shader program ready or not
+     * @returns is shader program ready or not
+     */
+    isShaderProgramReady(): boolean;
+    /**
+     * @private
+     */
+    _setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+    setSoloDatumParametersForGPU({ shaderProgram, firstTime, args, }: {
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+    private __setupGlobalShaderDefinition;
+    createProgramAsSingleOperation(vertexShaderMethodDefinitions_uniform: string, propertySetter: getShaderPropertyFunc, isWebGL2: boolean): CGAPIResourceHandle;
+    createProgramAsSingleOperationByUpdatedSources(updatedShaderSources: ShaderSources): number;
+    private __createShaderProgramWithCache;
+    private __getAttributeInfo;
+    private __outputVertexAttributeBindingInfo;
+    /**
+     * @private
+     * @param propertySetter
+     */
+    _getProperties(propertySetter: getShaderPropertyFunc, isWebGL2: boolean): {
+        vertexPropertiesStr: string;
+        pixelPropertiesStr: string;
+    };
+    createProgram(vertexShaderMethodDefinitions_uniform: string, propertySetter: getShaderPropertyFunc, isWebGL2: boolean): CGAPIResourceHandle;
+    createProgramByUpdatedSources(updatedShaderSources: ShaderSources): CGAPIResourceHandle;
+    isBlend(): boolean;
+    static getLocationOffsetOfMemberOfMaterial(materialTypeName: string, propertyIndex: Index): IndexOf16Bytes;
+    static getAccessorOfMemberOfMaterial(materialTypeName: string, propertyIndex: Index): Accessor | undefined;
+    get alphaMode(): AlphaModeEnum;
+    set alphaMode(mode: AlphaModeEnum);
+    /**
+     * Change the blendEquations
+     * This method works only if this alphaMode is the translucent
+     * @param blendEquationMode the argument of gl.blendEquation of the first argument of gl.blendEquationSeparate such as gl.FUNC_ADD
+     * @param blendEquationModeAlpha the second argument of gl.blendEquationSeparate
+     */
+    setBlendEquationMode(blendEquationMode: number, blendEquationModeAlpha?: number): void;
+    /**
+     * Change the blendFuncSeparateFactors
+     * This method works only if this alphaMode is the translucent
+     */
+    setBlendFuncSeparateFactor(blendFuncSrcFactor: number, blendFuncDstFactor: number, blendFuncAlphaSrcFactor: number, blendFuncAlphaDstFactor: number): void;
+    /**
+     * Change the blendFuncFactors
+     * This method works only if this alphaMode is the translucent
+     */
+    setBlendFuncFactor(blendFuncSrcFactor: number, blendFuncDstFactor: number): void;
+    get blendEquationMode(): number;
+    get blendEquationModeAlpha(): number;
+    get blendFuncSrcFactor(): number;
+    get blendFuncDstFactor(): number;
+    get blendFuncAlphaSrcFactor(): number;
+    get blendFuncAlphaDstFactor(): number;
+    isEmptyMaterial(): boolean;
+    getShaderSemanticInfoFromName(name: string): ShaderSemanticsInfo | undefined;
+    setupAdditionalUniformLocations(shaderSemantics: ShaderSemanticsInfo[], isUniformOnlyMode: boolean): WebGLProgram;
+    setupBasicUniformsLocations(): void;
+    /**
+     * NOTE: To apply the alphaToCoverage, the output alpha value must not be fixed to constant value.
+     * However, some shaders in the Rhodonite fixes the output alpha value to 1 by setAlphaIfNotInAlphaBlendMode.
+     * So we need to improve the shader to use the alphaToCoverage.
+     * @param alphaToCoverage apply alphaToCoverage to this material or not
+     */
+    set alphaToCoverage(alphaToCoverage: boolean);
+    get alphaToCoverage(): boolean;
+}
+export {};

package/dist/esm/foundation/materials/core/ShaderGraphResolver.d.ts

@@ -1,16 +1,16 @@
-import AbstractShaderNode from './AbstractShaderNode';
-import { ShaderTypeEnum } from '../../definitions/ShaderType';
-export default class ShaderGraphResolver {
-    static createVertexShaderCode(vertexNodes: AbstractShaderNode[]): {
-        shader: string;
-        shaderBody: string;
-    };
-    static createPixelShaderCode(pixelNodes: AbstractShaderNode[]): {
-        shader: string;
-        shaderBody: string;
-    };
-    private static __findBeginNode;
-    private static __sortTopologically;
-    static getFunctionDefinition(shaderNodes: AbstractShaderNode[], shaderType: ShaderTypeEnum): string;
-    private static __constructShaderWithNodes;
-}
+import AbstractShaderNode from './AbstractShaderNode';
+import { ShaderTypeEnum } from '../../definitions/ShaderType';
+export default class ShaderGraphResolver {
+    static createVertexShaderCode(vertexNodes: AbstractShaderNode[]): {
+        shader: string;
+        shaderBody: string;
+    };
+    static createPixelShaderCode(pixelNodes: AbstractShaderNode[]): {
+        shader: string;
+        shaderBody: string;
+    };
+    private static __findBeginNode;
+    private static __sortTopologically;
+    static getFunctionDefinition(shaderNodes: AbstractShaderNode[], shaderType: ShaderTypeEnum): string;
+    private static __constructShaderWithNodes;
+}

package/dist/esm/foundation/materials/core/ShaderityUtility.d.ts

@@ -1,32 +1,30 @@
-import { ShaderityObject } from 'shaderity';
-import { CompositionTypeEnum } from '../../definitions/CompositionType';
-import { VertexAttributeEnum } from '../../definitions/VertexAttribute';
-import { ShaderSemanticsInfo, ShaderSemanticsName } from '../../definitions/ShaderSemantics';
-import { ComponentTypeEnum } from '../../..';
-export declare type FillArgsObject = {
-    [s: string]: string;
-    WellKnownComponentTIDs?: any;
-    Config?: any;
-};
-export declare type VertexAttributesLayout = {
-    names: string[];
-    semantics: VertexAttributeEnum[];
-    compositions: CompositionTypeEnum[];
-    components: ComponentTypeEnum[];
-};
-export default class ShaderityUtility {
-    static __instance: ShaderityUtility;
-    private __shaderity;
-    private __webglResourceRepository?;
-    private constructor();
-    static getInstance(): ShaderityUtility;
-    private __removeNonStringProperties;
-    getVertexShaderBody(shaderityObject: ShaderityObject, args: FillArgsObject): string;
-    getPixelShaderBody(shaderityObject: ShaderityObject, args: FillArgsObject): string;
-    getReflection(shaderityObject: ShaderityObject): VertexAttributesLayout;
-    copyShaderityObject(obj: ShaderityObject): ShaderityObject;
-    getShaderDataRefection(shaderityObject: ShaderityObject, existingShaderInfoMap?: Map<ShaderSemanticsName, ShaderSemanticsInfo>): {
-        shaderSemanticsInfoArray: ShaderSemanticsInfo[];
-        shaderityObject: ShaderityObject;
-    };
-}
+import { ShaderityObject } from 'shaderity';
+import { ComponentTypeEnum } from '../../definitions/ComponentType';
+import { CompositionTypeEnum } from '../../definitions/CompositionType';
+import { VertexAttributeEnum } from '../../definitions/VertexAttribute';
+import { ShaderSemanticsInfo, ShaderSemanticsName } from '../../definitions/ShaderSemantics';
+export declare type FillArgsObject = {
+    [key: string]: string;
+};
+export declare type VertexAttributesLayout = {
+    names: string[];
+    semantics: VertexAttributeEnum[];
+    compositions: CompositionTypeEnum[];
+    components: ComponentTypeEnum[];
+};
+export default class ShaderityUtility {
+    static fillTemplate(shaderityObject: ShaderityObject, args: FillArgsObject): ShaderityObject;
+    static transformWebGLVersion(shaderityObject: ShaderityObject, isWebGL2: boolean): ShaderityObject;
+    static getAttributeReflection(shaderityObject: ShaderityObject): VertexAttributesLayout;
+    private static __setDefaultAttributeSemanticMap;
+    static getShaderDataRefection(shaderityObject: ShaderityObject, existingShaderInfoMap?: Map<ShaderSemanticsName, ShaderSemanticsInfo>): {
+        shaderSemanticsInfoArray: ShaderSemanticsInfo[];
+        shaderityObject: ShaderityObject;
+    };
+    private static __copyShaderityObject;
+    private static __ignoreThisUniformDeclaration;
+    private static __createShaderSemanticsInfo;
+    private static __setRhodoniteOriginalParametersTo;
+    private static __getInitialValueFromText;
+    private static __getDefaultInitialValue;
+}

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

@@ -1,6 +1,6 @@
-import AbstractShaderNode from '../core/AbstractShaderNode';
-import { CompositionTypeEnum } from '../../definitions/CompositionType';
-import { ComponentTypeEnum } from '../../definitions/ComponentType';
-export default class AddShaderNode extends AbstractShaderNode {
-    constructor(compositionType: CompositionTypeEnum, componentType: ComponentTypeEnum);
-}
+import AbstractShaderNode from '../core/AbstractShaderNode';
+import { CompositionTypeEnum } from '../../definitions/CompositionType';
+import { ComponentTypeEnum } from '../../definitions/ComponentType';
+export default class AddShaderNode extends AbstractShaderNode {
+    constructor(compositionType: CompositionTypeEnum, componentType: ComponentTypeEnum);
+}

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

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

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

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

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

@@ -1,9 +1,9 @@
-import { CompositionTypeEnum } from '../../definitions/CompositionType';
-import { ComponentTypeEnum } from '../../definitions/ComponentType';
-import AbstractShaderNode from '../core/AbstractShaderNode';
-export default class BlockBeginShaderNode extends AbstractShaderNode {
-    private __valueInputs;
-    private __valueOutputs;
-    constructor();
-    addInputAndOutput(compositionType: CompositionTypeEnum, componentType: ComponentTypeEnum): void;
-}
+import { CompositionTypeEnum } from '../../definitions/CompositionType';
+import { ComponentTypeEnum } from '../../definitions/ComponentType';
+import AbstractShaderNode from '../core/AbstractShaderNode';
+export default class BlockBeginShaderNode extends AbstractShaderNode {
+    private __valueInputs;
+    private __valueOutputs;
+    constructor();
+    addInputAndOutput(compositionType: CompositionTypeEnum, componentType: ComponentTypeEnum): void;
+}

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

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

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

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

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

@@ -1,6 +1,6 @@
-import { ComponentTypeEnum } from '../../../foundation/definitions/ComponentType';
-import { CompositionTypeEnum } from '../../../foundation/definitions/CompositionType';
-import AbstractShaderNode from '../core/AbstractShaderNode';
-export default class DotProductShaderNode extends AbstractShaderNode {
-    constructor(compositionType: CompositionTypeEnum, componentType: ComponentTypeEnum);
-}
+import { ComponentTypeEnum } from '../../../foundation/definitions/ComponentType';
+import { CompositionTypeEnum } from '../../../foundation/definitions/CompositionType';
+import AbstractShaderNode from '../core/AbstractShaderNode';
+export default class DotProductShaderNode extends AbstractShaderNode {
+    constructor(compositionType: CompositionTypeEnum, componentType: ComponentTypeEnum);
+}

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

@@ -1,6 +1,6 @@
-import AbstractShaderNode from '../core/AbstractShaderNode';
-import { CompositionTypeEnum } from '../../definitions/CompositionType';
-import { ComponentTypeEnum } from '../../definitions/ComponentType';
-export default class GreaterShaderNode extends AbstractShaderNode {
-    constructor(compositionType: CompositionTypeEnum, componentType: ComponentTypeEnum);
-}
+import AbstractShaderNode from '../core/AbstractShaderNode';
+import { CompositionTypeEnum } from '../../definitions/CompositionType';
+import { ComponentTypeEnum } from '../../definitions/ComponentType';
+export default class GreaterShaderNode extends AbstractShaderNode {
+    constructor(compositionType: CompositionTypeEnum, componentType: ComponentTypeEnum);
+}

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

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

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

@@ -1,6 +1,6 @@
-import { ComponentTypeEnum } from '../../../foundation/definitions/ComponentType';
-import { CompositionTypeEnum } from '../../../foundation/definitions/CompositionType';
-import AbstractShaderNode from '../core/AbstractShaderNode';
-export default class MultiplyShaderNode extends AbstractShaderNode {
-    constructor(lhsCompositionType: CompositionTypeEnum, lhsComponentType: ComponentTypeEnum, rhsCompositionType: CompositionTypeEnum, rhsComponentType: ComponentTypeEnum);
-}
+import { ComponentTypeEnum } from '../../../foundation/definitions/ComponentType';
+import { CompositionTypeEnum } from '../../../foundation/definitions/CompositionType';
+import AbstractShaderNode from '../core/AbstractShaderNode';
+export default class MultiplyShaderNode extends AbstractShaderNode {
+    constructor(lhsCompositionType: CompositionTypeEnum, lhsComponentType: ComponentTypeEnum, rhsCompositionType: CompositionTypeEnum, rhsComponentType: ComponentTypeEnum);
+}

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

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

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

@@ -1,6 +1,6 @@
-import { ComponentTypeEnum } from '../../../foundation/definitions/ComponentType';
-import { CompositionTypeEnum } from '../../../foundation/definitions/CompositionType';
-import AbstractShaderNode from '../core/AbstractShaderNode';
-export default class NormalizeShaderNode extends AbstractShaderNode {
-    constructor(compositionType: CompositionTypeEnum, componentType: ComponentTypeEnum);
-}
+import { ComponentTypeEnum } from '../../../foundation/definitions/ComponentType';
+import { CompositionTypeEnum } from '../../../foundation/definitions/CompositionType';
+import AbstractShaderNode from '../core/AbstractShaderNode';
+export default class NormalizeShaderNode extends AbstractShaderNode {
+    constructor(compositionType: CompositionTypeEnum, componentType: ComponentTypeEnum);
+}

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

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

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

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