rhodonite 0.4.2 → 0.5.2

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

@@ -1,52 +1,52 @@
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-import Material from '../core/Material';
-import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
-import { Count } from '../../../types/CommonTypes';
-export default class MToonSingleMaterialNode extends AbstractMaterialNode {
-    static readonly _Cutoff: ShaderSemanticsClass;
-    static readonly _Color: ShaderSemanticsClass;
-    static readonly _ShadeColor: ShaderSemanticsClass;
-    static readonly _MainTex: ShaderSemanticsClass;
-    static readonly _ShadeTexture: ShaderSemanticsClass;
-    static readonly _BumpScale: ShaderSemanticsClass;
-    static readonly _BumpMap: ShaderSemanticsClass;
-    static readonly _ReceiveShadowRate: ShaderSemanticsClass;
-    static readonly _ReceiveShadowTexture: ShaderSemanticsClass;
-    static readonly _ShadingGradeRate: ShaderSemanticsClass;
-    static readonly _ShadingGradeTexture: ShaderSemanticsClass;
-    static readonly _ShadeShift: ShaderSemanticsClass;
-    static readonly _ShadeToony: ShaderSemanticsClass;
-    static readonly _LightColorAttenuation: ShaderSemanticsClass;
-    static readonly _AmbientColor: ShaderSemanticsClass;
-    static readonly _RimTexture: ShaderSemanticsClass;
-    static readonly _RimColor: ShaderSemanticsClass;
-    static readonly _RimLightingMix: ShaderSemanticsClass;
-    static readonly _RimFresnelPower: ShaderSemanticsClass;
-    static readonly _RimLift: ShaderSemanticsClass;
-    static readonly _SphereAdd: ShaderSemanticsClass;
-    static readonly _EmissionColor: ShaderSemanticsClass;
-    static readonly _EmissionMap: ShaderSemanticsClass;
-    static readonly _OutlineWidthTexture: ShaderSemanticsClass;
-    static readonly _OutlineWidth: ShaderSemanticsClass;
-    static readonly _OutlineScaledMaxDistance: ShaderSemanticsClass;
-    static readonly _OutlineColor: ShaderSemanticsClass;
-    static readonly _OutlineLightingMix: ShaderSemanticsClass;
-    static readonly Aspect: ShaderSemanticsClass;
-    static readonly CameraUp: ShaderSemanticsClass;
-    static usableBlendEquationModeAlpha?: number;
-    private __OutlineWidthModeIsScreen;
-    private __floatProperties;
-    private __vectorProperties;
-    private __textureProperties;
-    constructor(isOutline: boolean, materialProperties: any, textures: any, isMorphing: boolean, isSkinning: boolean, isLighting: boolean, useTangentAttribute: boolean, debugMode: Count | undefined, makeOutputSrgb: boolean);
-    private __setTextures;
-    setMaterialParameters(material: Material, isOutline: boolean): void;
-    private static __initializeUsableBlendEquationModeAlpha;
-    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
-        material: Material;
-        shaderProgram: WebGLProgram;
-        firstTime: boolean;
-        args?: any;
-    }): void;
-    static unityBlendEnumCorrespondence(enumNumber: number): number;
-}
+import AbstractMaterialNode from '../core/AbstractMaterialNode';
+import Material from '../core/Material';
+import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
+import { Count } from '../../../types/CommonTypes';
+export default class MToonSingleMaterialNode extends AbstractMaterialNode {
+    static readonly _Cutoff: ShaderSemanticsClass;
+    static readonly _Color: ShaderSemanticsClass;
+    static readonly _ShadeColor: ShaderSemanticsClass;
+    static readonly _MainTex: ShaderSemanticsClass;
+    static readonly _ShadeTexture: ShaderSemanticsClass;
+    static readonly _BumpScale: ShaderSemanticsClass;
+    static readonly _BumpMap: ShaderSemanticsClass;
+    static readonly _ReceiveShadowRate: ShaderSemanticsClass;
+    static readonly _ReceiveShadowTexture: ShaderSemanticsClass;
+    static readonly _ShadingGradeRate: ShaderSemanticsClass;
+    static readonly _ShadingGradeTexture: ShaderSemanticsClass;
+    static readonly _ShadeShift: ShaderSemanticsClass;
+    static readonly _ShadeToony: ShaderSemanticsClass;
+    static readonly _LightColorAttenuation: ShaderSemanticsClass;
+    static readonly _AmbientColor: ShaderSemanticsClass;
+    static readonly _RimTexture: ShaderSemanticsClass;
+    static readonly _RimColor: ShaderSemanticsClass;
+    static readonly _RimLightingMix: ShaderSemanticsClass;
+    static readonly _RimFresnelPower: ShaderSemanticsClass;
+    static readonly _RimLift: ShaderSemanticsClass;
+    static readonly _SphereAdd: ShaderSemanticsClass;
+    static readonly _EmissionColor: ShaderSemanticsClass;
+    static readonly _EmissionMap: ShaderSemanticsClass;
+    static readonly _OutlineWidthTexture: ShaderSemanticsClass;
+    static readonly _OutlineWidth: ShaderSemanticsClass;
+    static readonly _OutlineScaledMaxDistance: ShaderSemanticsClass;
+    static readonly _OutlineColor: ShaderSemanticsClass;
+    static readonly _OutlineLightingMix: ShaderSemanticsClass;
+    static readonly Aspect: ShaderSemanticsClass;
+    static readonly CameraUp: ShaderSemanticsClass;
+    static usableBlendEquationModeAlpha?: number;
+    private __OutlineWidthModeIsScreen;
+    private __floatProperties;
+    private __vectorProperties;
+    private __textureProperties;
+    constructor(isOutline: boolean, materialProperties: any, textures: any, isMorphing: boolean, isSkinning: boolean, isLighting: boolean, useTangentAttribute: boolean, debugMode: Count | undefined, makeOutputSrgb: boolean);
+    private __setTextures;
+    setMaterialParameters(material: Material, isOutline: boolean): void;
+    private static __initializeUsableBlendEquationModeAlpha;
+    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+    static unityBlendEnumCorrespondence(enumNumber: number): number;
+}

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

@@ -1,14 +1,14 @@
-import AbstractTexture from '../../textures/AbstractTexture';
-import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-import Material from '../core/Material';
-export default class MatCapSingleMaterialNode extends AbstractMaterialNode {
-    static MatCapTexture: ShaderSemanticsClass;
-    constructor(isSkinning: boolean, uri?: string, texture?: AbstractTexture);
-    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
-        material: Material;
-        shaderProgram: WebGLProgram;
-        firstTime: boolean;
-        args?: any;
-    }): void;
-}
+import AbstractTexture from '../../textures/AbstractTexture';
+import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
+import AbstractMaterialNode from '../core/AbstractMaterialNode';
+import Material from '../core/Material';
+export default class MatCapSingleMaterialNode extends AbstractMaterialNode {
+    static MatCapTexture: ShaderSemanticsClass;
+    constructor(isSkinning: boolean, uri?: string, texture?: AbstractTexture);
+    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+}

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

@@ -1,29 +1,29 @@
-import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
-import AbstractMaterialNode from './../core/AbstractMaterialNode';
-import Material from './../core/Material';
-export default class PbrExtendedShadingSingleMaterialNode extends AbstractMaterialNode {
-    static detailNormalTexture: ShaderSemanticsClass;
-    static detailColorTexture: ShaderSemanticsClass;
-    static diffuseTextureTransform: ShaderSemanticsClass;
-    static diffuseTextureRotation: ShaderSemanticsClass;
-    static normalTextureTransform: ShaderSemanticsClass;
-    static normalTextureRotation: ShaderSemanticsClass;
-    static detailColorTextureTransform: ShaderSemanticsClass;
-    static detailColorTextureRotation: ShaderSemanticsClass;
-    static detailNormalTextureTransform: ShaderSemanticsClass;
-    static detailNormalTextureRotation: ShaderSemanticsClass;
-    static debugDisplay: ShaderSemanticsClass;
-    private static __pbrCookTorranceBrdfLutDataUrlUid;
-    constructor({ isMorphing, isSkinning, isLighting, }: {
-        isMorphing: boolean;
-        isSkinning: boolean;
-        isLighting: boolean;
-    });
-    static initDefaultTextures(): Promise<void>;
-    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 PbrExtendedShadingSingleMaterialNode extends AbstractMaterialNode {
+    static detailNormalTexture: ShaderSemanticsClass;
+    static detailColorTexture: ShaderSemanticsClass;
+    static diffuseTextureTransform: ShaderSemanticsClass;
+    static diffuseTextureRotation: ShaderSemanticsClass;
+    static normalTextureTransform: ShaderSemanticsClass;
+    static normalTextureRotation: ShaderSemanticsClass;
+    static detailColorTextureTransform: ShaderSemanticsClass;
+    static detailColorTextureRotation: ShaderSemanticsClass;
+    static detailNormalTextureTransform: ShaderSemanticsClass;
+    static detailNormalTextureRotation: ShaderSemanticsClass;
+    static debugDisplay: ShaderSemanticsClass;
+    private static __pbrCookTorranceBrdfLutDataUrlUid;
+    constructor({ isMorphing, isSkinning, isLighting, }: {
+        isMorphing: boolean;
+        isSkinning: boolean;
+        isLighting: boolean;
+    });
+    static initDefaultTextures(): Promise<void>;
+    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+}

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

@@ -1,36 +1,36 @@
-import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-import Material from '../core/Material';
-import { AlphaModeEnum } from '../../definitions/AlphaMode';
-export default class PbrShadingSingleMaterialNode extends AbstractMaterialNode {
-    private static readonly IsOutputHDR;
-    static readonly BaseColorTextureTransform: ShaderSemanticsClass;
-    static readonly BaseColorTextureRotation: ShaderSemanticsClass;
-    static readonly NormalTextureTransform: ShaderSemanticsClass;
-    static readonly NormalTextureRotation: ShaderSemanticsClass;
-    static readonly MetallicRoughnessTextureTransform: ShaderSemanticsClass;
-    static readonly MetallicRoughnessTextureRotation: ShaderSemanticsClass;
-    static readonly NormalTexcoordIndex: ShaderSemanticsClass;
-    static readonly BaseColorTexcoordIndex: ShaderSemanticsClass;
-    static readonly MetallicRoughnessTexcoordIndex: ShaderSemanticsClass;
-    static readonly OcclusionTexcoordIndex: ShaderSemanticsClass;
-    static readonly EmissiveTexcoordIndex: ShaderSemanticsClass;
-    static readonly NormalScale: ShaderSemanticsClass;
-    static readonly OcclusionStrength: ShaderSemanticsClass;
-    constructor({ isMorphing, isSkinning, isLighting, useTangentAttribute, useNormalTexture, alphaMode, makeOutputSrgb, }: {
-        isMorphing: boolean;
-        isSkinning: boolean;
-        isLighting: boolean;
-        useTangentAttribute: boolean;
-        useNormalTexture: boolean;
-        alphaMode: AlphaModeEnum;
-        makeOutputSrgb: boolean;
-    });
-    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 { AlphaModeEnum } from '../../definitions/AlphaMode';
+export default class PbrShadingSingleMaterialNode extends AbstractMaterialNode {
+    private static readonly IsOutputHDR;
+    static readonly BaseColorTextureTransform: ShaderSemanticsClass;
+    static readonly BaseColorTextureRotation: ShaderSemanticsClass;
+    static readonly NormalTextureTransform: ShaderSemanticsClass;
+    static readonly NormalTextureRotation: ShaderSemanticsClass;
+    static readonly MetallicRoughnessTextureTransform: ShaderSemanticsClass;
+    static readonly MetallicRoughnessTextureRotation: ShaderSemanticsClass;
+    static readonly NormalTexcoordIndex: ShaderSemanticsClass;
+    static readonly BaseColorTexcoordIndex: ShaderSemanticsClass;
+    static readonly MetallicRoughnessTexcoordIndex: ShaderSemanticsClass;
+    static readonly OcclusionTexcoordIndex: ShaderSemanticsClass;
+    static readonly EmissiveTexcoordIndex: ShaderSemanticsClass;
+    static readonly NormalScale: ShaderSemanticsClass;
+    static readonly OcclusionStrength: ShaderSemanticsClass;
+    constructor({ isMorphing, isSkinning, isLighting, useTangentAttribute, useNormalTexture, alphaMode, makeOutputSrgb, }: {
+        isMorphing: boolean;
+        isSkinning: boolean;
+        isLighting: boolean;
+        useTangentAttribute: boolean;
+        useNormalTexture: boolean;
+        alphaMode: AlphaModeEnum;
+        makeOutputSrgb: boolean;
+    });
+    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+    private setupHdriParameters;
+}

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

@@ -0,0 +1,17 @@
+import AbstractMaterialNode from '../core/AbstractMaterialNode';
+import Material from '../core/Material';
+import { ShaderityObject } from 'shaderity';
+export default class ShaderitySingleMaterialNode extends AbstractMaterialNode {
+    constructor({ name, vertexShaderityObj, pixelShaderityObj, }: {
+        name: string;
+        vertexShaderityObj: ShaderityObject;
+        pixelShaderityObj: ShaderityObject;
+    });
+    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+    private static __removeUselessShaderSemantics;
+}

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

@@ -1,41 +1,41 @@
-import { ShaderSemanticsEnum, ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-import Material from '../core/Material';
-import RenderPass from '../../renderer/RenderPass';
-import { Count } from '../../../types/CommonTypes';
-export default class ShadowMapDecodeClassicSingleMaterialNode extends AbstractMaterialNode {
-    static ShadowColorFactor: ShaderSemanticsEnum;
-    static ShadowAlpha: ShaderSemanticsEnum;
-    static NonShadowAlpha: ShaderSemanticsEnum;
-    static AllowableDepthError: ShaderSemanticsEnum;
-    static zNearInner: ShaderSemanticsClass;
-    static zFarInner: ShaderSemanticsClass;
-    static DebugColorFactor: ShaderSemanticsEnum;
-    static DepthTexture: ShaderSemanticsEnum;
-    static IsPointLight: ShaderSemanticsClass;
-    private static __lastZNear;
-    private static __lastZFar;
-    private __encodedDepthRenderPass;
-    /**
-     * The constructor of the ShadowMapDecodeClassicSingleMaterialNode
-     * @param isMorphing True if the morphing is to be applied
-     * @param isSkinning True if the skeleton is to be applied
-     * @param isLighting True if the lighting is to be applied. When isLighting is false, the Shader draws the original color of the material, except for the shadow area.
-     * @param isDebugging True if the shader displays the DebugColorFactor color in areas outside of the depth map.
-     * @param colorAttachmentsNumber The index of colorAttachment in a framebuffer. The colorAttachment must have depth information drawn by the DepthEncodeSingleMaterialNode.
-     * @param encodedDepthRenderPass The render pass where the depth information from the DepthEncodeSingleMaterialNode is drawn to the frame buffer
-     */
-    constructor({ isMorphing, isSkinning, isLighting, isDebugging, colorAttachmentsNumber, }: {
-        isMorphing: boolean;
-        isSkinning: boolean;
-        isLighting: boolean;
-        isDebugging: boolean;
-        colorAttachmentsNumber: Count;
-    }, encodedDepthRenderPass: RenderPass);
-    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
-        material: Material;
-        shaderProgram: WebGLProgram;
-        firstTime: boolean;
-        args?: any;
-    }): void;
-}
+import { ShaderSemanticsEnum, ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
+import AbstractMaterialNode from '../core/AbstractMaterialNode';
+import Material from '../core/Material';
+import RenderPass from '../../renderer/RenderPass';
+import { Count } from '../../../types/CommonTypes';
+export default class ShadowMapDecodeClassicSingleMaterialNode extends AbstractMaterialNode {
+    static ShadowColorFactor: ShaderSemanticsEnum;
+    static ShadowAlpha: ShaderSemanticsEnum;
+    static NonShadowAlpha: ShaderSemanticsEnum;
+    static AllowableDepthError: ShaderSemanticsEnum;
+    static zNearInner: ShaderSemanticsClass;
+    static zFarInner: ShaderSemanticsClass;
+    static DebugColorFactor: ShaderSemanticsEnum;
+    static DepthTexture: ShaderSemanticsEnum;
+    static IsPointLight: ShaderSemanticsClass;
+    private static __lastZNear;
+    private static __lastZFar;
+    private __encodedDepthRenderPass;
+    /**
+     * The constructor of the ShadowMapDecodeClassicSingleMaterialNode
+     * @param isMorphing True if the morphing is to be applied
+     * @param isSkinning True if the skeleton is to be applied
+     * @param isLighting True if the lighting is to be applied. When isLighting is false, the Shader draws the original color of the material, except for the shadow area.
+     * @param isDebugging True if the shader displays the DebugColorFactor color in areas outside of the depth map.
+     * @param colorAttachmentsNumber The index of colorAttachment in a framebuffer. The colorAttachment must have depth information drawn by the DepthEncodeSingleMaterialNode.
+     * @param encodedDepthRenderPass The render pass where the depth information from the DepthEncodeSingleMaterialNode is drawn to the frame buffer
+     */
+    constructor({ isMorphing, isSkinning, isLighting, isDebugging, colorAttachmentsNumber, }: {
+        isMorphing: boolean;
+        isSkinning: boolean;
+        isLighting: boolean;
+        isDebugging: boolean;
+        colorAttachmentsNumber: Count;
+    }, encodedDepthRenderPass: RenderPass);
+    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+}

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

@@ -1,26 +1,26 @@
-import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-import Material from '../core/Material';
-export default class SkinPbrShadingSingleMaterialNode extends AbstractMaterialNode {
-    private static __pbrCookTorranceBrdfLutDataUrlUid;
-    private static readonly IsOutputHDR;
-    static baseColorTextureTransform: ShaderSemanticsClass;
-    static baseColorTextureRotation: ShaderSemanticsClass;
-    static normalTextureTransform: ShaderSemanticsClass;
-    static normalTextureRotation: ShaderSemanticsClass;
-    static metallicRoughnessTextureTransform: ShaderSemanticsClass;
-    static metallicRoughnessTextureRotation: ShaderSemanticsClass;
-    static pbrKelemenSzirmayKalosBrdfLutTexture: ShaderSemanticsClass;
-    constructor({ isMorphing, isSkinning, isLighting, }: {
-        isMorphing: boolean;
-        isSkinning: boolean;
-        isLighting: boolean;
-    });
-    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';
+export default class SkinPbrShadingSingleMaterialNode extends AbstractMaterialNode {
+    private static __pbrCookTorranceBrdfLutDataUrlUid;
+    private static readonly IsOutputHDR;
+    static baseColorTextureTransform: ShaderSemanticsClass;
+    static baseColorTextureRotation: ShaderSemanticsClass;
+    static normalTextureTransform: ShaderSemanticsClass;
+    static normalTextureRotation: ShaderSemanticsClass;
+    static metallicRoughnessTextureTransform: ShaderSemanticsClass;
+    static metallicRoughnessTextureRotation: ShaderSemanticsClass;
+    static pbrKelemenSzirmayKalosBrdfLutTexture: ShaderSemanticsClass;
+    constructor({ isMorphing, isSkinning, isLighting, }: {
+        isMorphing: boolean;
+        isSkinning: boolean;
+        isLighting: boolean;
+    });
+    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+    private setupHdriParameters;
+}

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

@@ -1,39 +1,39 @@
-import AbstractTexture from '../../textures/AbstractTexture';
-import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-import Material from '../core/Material';
-export default class SynthesizeHDRMaterialNode extends AbstractMaterialNode {
-    static SynthesizeCoefficient: ShaderSemanticsClass;
-    static TargetRegionTexture: ShaderSemanticsClass;
-    static SynthesizeTexture0: ShaderSemanticsClass;
-    static SynthesizeTexture1: ShaderSemanticsClass;
-    static SynthesizeTexture2: ShaderSemanticsClass;
-    static SynthesizeTexture3: ShaderSemanticsClass;
-    static SynthesizeTexture4: ShaderSemanticsClass;
-    static SynthesizeTexture5: ShaderSemanticsClass;
-    private existTargetRegion;
-    private textureNumber;
-    /**
-     * This material node uses for the glare effect and so on.
-     *
-     * If the targetRegionTexture is not specified, the shader synthesizes all the
-     * synthesizeTextures with all the pixels weighted by the synthesizeCoefficient.
-     *
-     * If the targetRegionTexture is specified, the shader synthesizes all the
-     * synthesizeTextures with weights only for the non-white pixels of
-     * targetRegionTexture (where the color is not (1.0, 1.0, 1.0, 1.0)). On the other
-     * hand, in the white area, the output value is the product of the value of each
-     * pixel in synthesizeTextures[0] and synthesizeCoefficient[0].
-     *
-     * @synthesizeTextures Textures to be synthesized. The shader supports up to six texture syntheses.
-     * @targetRegionTexture Texture to specify the area where the texture will be synthesized
-     */
-    constructor(synthesizeTextures: AbstractTexture[], targetRegionTexture?: AbstractTexture);
-    setParametersForGPU({ material, shaderProgram, args, }: {
-        material: Material;
-        shaderProgram: WebGLProgram;
-        args?: any;
-    }): void;
-    get existTargetRegionTexture(): boolean;
-    get synthesizeTextureNumber(): number;
-}
+import AbstractTexture from '../../textures/AbstractTexture';
+import { ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
+import AbstractMaterialNode from '../core/AbstractMaterialNode';
+import Material from '../core/Material';
+export default class SynthesizeHDRMaterialNode extends AbstractMaterialNode {
+    static SynthesizeCoefficient: ShaderSemanticsClass;
+    static TargetRegionTexture: ShaderSemanticsClass;
+    static SynthesizeTexture0: ShaderSemanticsClass;
+    static SynthesizeTexture1: ShaderSemanticsClass;
+    static SynthesizeTexture2: ShaderSemanticsClass;
+    static SynthesizeTexture3: ShaderSemanticsClass;
+    static SynthesizeTexture4: ShaderSemanticsClass;
+    static SynthesizeTexture5: ShaderSemanticsClass;
+    private existTargetRegion;
+    private textureNumber;
+    /**
+     * This material node uses for the glare effect and so on.
+     *
+     * If the targetRegionTexture is not specified, the shader synthesizes all the
+     * synthesizeTextures with all the pixels weighted by the synthesizeCoefficient.
+     *
+     * If the targetRegionTexture is specified, the shader synthesizes all the
+     * synthesizeTextures with weights only for the non-white pixels of
+     * targetRegionTexture (where the color is not (1.0, 1.0, 1.0, 1.0)). On the other
+     * hand, in the white area, the output value is the product of the value of each
+     * pixel in synthesizeTextures[0] and synthesizeCoefficient[0].
+     *
+     * @synthesizeTextures Textures to be synthesized. The shader supports up to six texture syntheses.
+     * @targetRegionTexture Texture to specify the area where the texture will be synthesized
+     */
+    constructor(synthesizeTextures: AbstractTexture[], targetRegionTexture?: AbstractTexture);
+    setParametersForGPU({ material, shaderProgram, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        args?: any;
+    }): void;
+    get existTargetRegionTexture(): boolean;
+    get synthesizeTextureNumber(): number;
+}

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

@@ -1,52 +1,52 @@
-import { ShaderSemanticsEnum, ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
-import AbstractMaterialNode from '../core/AbstractMaterialNode';
-import CameraComponent from '../../components/CameraComponent';
-import Material from '../core/Material';
-import RenderPass from '../../renderer/RenderPass';
-import { Count } from '../../../types/CommonTypes';
-export default class VarianceShadowMapDecodeClassicSingleMaterialNode extends AbstractMaterialNode {
-    static IsPointLight: ShaderSemanticsClass;
-    static DepthTexture: ShaderSemanticsClass;
-    static SquareDepthTexture: ShaderSemanticsClass;
-    static DepthAdjustment: ShaderSemanticsClass;
-    static TextureDepthAdjustment: ShaderSemanticsClass;
-    static MinimumVariance: ShaderSemanticsClass;
-    static LightBleedingParameter: ShaderSemanticsClass;
-    static ShadowColor: ShaderSemanticsClass;
-    static AllowableDepthError: ShaderSemanticsClass;
-    static zNearInner: ShaderSemanticsClass;
-    static zFarInner: ShaderSemanticsClass;
-    static DebugColorFactor: ShaderSemanticsEnum;
-    private static __lastZNear;
-    private static __lastZFar;
-    private __depthCameraComponent?;
-    /**
-     * The constructor of the VarianceShadowMapDecodeClassicSingleMaterialNode
-     * @param isMorphing True if the morphing is to be applied
-     * @param isSkinning True if the skeleton is to be applied
-     * @param isLighting True if the lighting is to be applied. When isLighting is false, the Shader draws the original color of the material, except for the shadow area.
-     * @param isDebugging True if the shader displays the DebugColorFactor color in areas outside of the depth map.
-     *
-     *
-     *
-     *
-     * @param colorAttachmentsNumber The index of colorAttachment in a framebuffer. The colorAttachment must have depth information drawn by the DepthEncodeSingleMaterialNode.
-     * @param encodedDepthRenderPass The render pass where the depth information from the DepthEncodeSingleMaterialNode is drawn to the frame buffer
-     */
-    constructor({ isMorphing, isSkinning, isLighting, isDebugging, colorAttachmentsNumberDepth, colorAttachmentsNumberSquareDepth, depthCameraComponent, }: {
-        isMorphing: boolean;
-        isSkinning: boolean;
-        isLighting: boolean;
-        isDebugging: boolean;
-        colorAttachmentsNumberDepth: Count;
-        colorAttachmentsNumberSquareDepth: Count;
-        depthCameraComponent?: CameraComponent;
-    }, encodedDepthRenderPasses: RenderPass[]);
-    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
-        material: Material;
-        shaderProgram: WebGLProgram;
-        firstTime: boolean;
-        args?: any;
-    }): void;
-    set depthCameraComponent(depthCameraComponent: CameraComponent);
-}
+import { ShaderSemanticsEnum, ShaderSemanticsClass } from '../../definitions/ShaderSemantics';
+import AbstractMaterialNode from '../core/AbstractMaterialNode';
+import CameraComponent from '../../components/CameraComponent';
+import Material from '../core/Material';
+import RenderPass from '../../renderer/RenderPass';
+import { Count } from '../../../types/CommonTypes';
+export default class VarianceShadowMapDecodeClassicSingleMaterialNode extends AbstractMaterialNode {
+    static IsPointLight: ShaderSemanticsClass;
+    static DepthTexture: ShaderSemanticsClass;
+    static SquareDepthTexture: ShaderSemanticsClass;
+    static DepthAdjustment: ShaderSemanticsClass;
+    static TextureDepthAdjustment: ShaderSemanticsClass;
+    static MinimumVariance: ShaderSemanticsClass;
+    static LightBleedingParameter: ShaderSemanticsClass;
+    static ShadowColor: ShaderSemanticsClass;
+    static AllowableDepthError: ShaderSemanticsClass;
+    static zNearInner: ShaderSemanticsClass;
+    static zFarInner: ShaderSemanticsClass;
+    static DebugColorFactor: ShaderSemanticsEnum;
+    private static __lastZNear;
+    private static __lastZFar;
+    private __depthCameraComponent?;
+    /**
+     * The constructor of the VarianceShadowMapDecodeClassicSingleMaterialNode
+     * @param isMorphing True if the morphing is to be applied
+     * @param isSkinning True if the skeleton is to be applied
+     * @param isLighting True if the lighting is to be applied. When isLighting is false, the Shader draws the original color of the material, except for the shadow area.
+     * @param isDebugging True if the shader displays the DebugColorFactor color in areas outside of the depth map.
+     *
+     *
+     *
+     *
+     * @param colorAttachmentsNumber The index of colorAttachment in a framebuffer. The colorAttachment must have depth information drawn by the DepthEncodeSingleMaterialNode.
+     * @param encodedDepthRenderPass The render pass where the depth information from the DepthEncodeSingleMaterialNode is drawn to the frame buffer
+     */
+    constructor({ isMorphing, isSkinning, isLighting, isDebugging, colorAttachmentsNumberDepth, colorAttachmentsNumberSquareDepth, depthCameraComponent, }: {
+        isMorphing: boolean;
+        isSkinning: boolean;
+        isLighting: boolean;
+        isDebugging: boolean;
+        colorAttachmentsNumberDepth: Count;
+        colorAttachmentsNumberSquareDepth: Count;
+        depthCameraComponent?: CameraComponent;
+    }, encodedDepthRenderPasses: RenderPass[]);
+    setParametersForGPU({ material, shaderProgram, firstTime, args, }: {
+        material: Material;
+        shaderProgram: WebGLProgram;
+        firstTime: boolean;
+        args?: any;
+    }): void;
+    set depthCameraComponent(depthCameraComponent: CameraComponent);
+}