sparcoon 0.4.0 → 0.4.1

package/dist/materials/FXDiffuseMaterial/FXDiffuseMaterial.Internal.d.ts

@@ -18,6 +18,6 @@ export interface FXScatterUniforms {
         value: number;
     };
 }
-export declare function buildFXDiffuseMaterial(varyings: Record<string, GLTypeInfo>, blending: Blending, useAlphaHashing: boolean, alphaTest: number, albedoNodes: readonly (FXColorNode | FXTextureNode)[], normalNodes: readonly (FXTextureNode | FXNormalNode)[], emissionNodes: readonly (FXColorNode | FXTextureNode)[], scatterUniforms?: FXScatterUniforms, shadowSensitivity?: {
+export declare function buildFXDiffuseMaterial(varyings: Record<string, GLTypeInfo>, blending: Blending, useAlphaHashing: boolean, alphaTest: number, premultipliedAlpha: boolean, albedoNodes: readonly (FXColorNode | FXTextureNode)[], normalNodes: readonly (FXTextureNode | FXNormalNode)[], emissionNodes: readonly (FXColorNode | FXTextureNode)[], scatterUniforms?: FXScatterUniforms, shadowSensitivity?: {
     value: number;
-}, premultipliedAlpha?: boolean): MeshLambertMaterial;
+}): MeshLambertMaterial;

package/dist/materials/FXDiffuseMaterial/FXDiffuseMaterial.Internal.js

@@ -37,7 +37,7 @@ function wrapShadowCalls(source, uniformName) {
     }
     return result;
 }
-function buildFXDiffuseMaterial(varyings, blending, useAlphaHashing, alphaTest, albedoNodes, normalNodes, emissionNodes, scatterUniforms, shadowSensitivity, premultipliedAlpha) {
+function buildFXDiffuseMaterial(varyings, blending, useAlphaHashing, alphaTest, premultipliedAlpha, albedoNodes, normalNodes, emissionNodes, scatterUniforms, shadowSensitivity) {
     const useScatter = scatterUniforms !== undefined;
     const useShadowSensitivity = shadowSensitivity !== undefined;
     const attributeDeclarations = [];

package/dist/materials/FXDiffuseMaterial/FXDiffuseMaterial.d.ts

@@ -13,14 +13,12 @@ export interface FXDiffuseMaterialOptions extends FXMaterialOptions {
     forwardScatterStrength: number;
     backScatterStrength: number;
     shadowSensitivity: number;
-    premultipliedAlpha: boolean;
 }
 export declare class FXDiffuseMaterial extends FXMaterial {
     private readonly normalNodes;
     private readonly emissionNodes;
     private readonly scatterUniforms;
     private readonly shadowSensitivity;
-    private readonly premultipliedAlpha;
     constructor(options?: Partial<FXDiffuseMaterialOptions>);
     destroy(): void;
 }

package/dist/materials/FXDiffuseMaterial/FXDiffuseMaterial.js

@@ -22,7 +22,6 @@ class FXDiffuseMaterial extends FXMaterial {
                 }
                 : undefined;
         this._private_shadowSensitivity = { value: options.shadowSensitivity ?? 1 };
-        this._private_premultipliedAlpha = options.premultipliedAlpha ?? false;
     }
     destroy() {
         super.destroy();
@@ -35,7 +34,7 @@ class FXDiffuseMaterial extends FXMaterial {
     }
     /** @internal */
     buildThreeMaterial(varyings) {
-        return buildFXDiffuseMaterial(varyings, this.blending, this.useAlphaHashing, this.alphaTest, this.albedoNodes, this._private_normalNodes, this._private_emissionNodes, this._private_scatterUniforms, this._private_shadowSensitivity, this._private_premultipliedAlpha);
+        return buildFXDiffuseMaterial(varyings, this.blending, this.useAlphaHashing, this.alphaTest, this.premultipliedAlpha, this.albedoNodes, this._private_normalNodes, this._private_emissionNodes, this._private_scatterUniforms, this._private_shadowSensitivity);
     }
 }
 

package/dist/materials/FXMaterial/FXMaterial.d.ts

@@ -2,19 +2,20 @@ import type { Blending, MeshDistanceMaterial } from "three";
 import type { FXColorNode } from "../../nodes/color/FXColorNode";
 import type { FXTextureNode } from "../../nodes/texture/FXTextureNode";
 export interface FXMaterialOptions {
-    albedoNodes?: (FXColorNode | FXTextureNode)[];
-    blending?: Blending;
-    useAlphaHashing?: boolean;
-    alphaTest?: number;
-    depthAlphaTest?: number;
-    useDepthAlphaHash?: boolean;
-    useSphericalDepth?: boolean;
+    albedoNodes: (FXColorNode | FXTextureNode)[];
+    blending: Blending;
+    useAlphaHashing: boolean;
+    alphaTest: number;
+    depthAlphaTest: number;
+    useDepthAlphaHash: boolean;
+    useSphericalDepth: boolean;
+    premultipliedAlpha: boolean;
 }
 export declare abstract class FXMaterial {
     private readonly depthAlphaTest;
     private readonly useDepthAlphaHash;
     private readonly useSphericalDepth;
-    constructor(options?: FXMaterialOptions);
+    constructor(options?: Partial<FXMaterialOptions>);
     destroy(): void;
     buildDistanceMaterial(): MeshDistanceMaterial;
 }

package/dist/materials/FXMaterial/FXMaterial.js

@@ -8,6 +8,8 @@ class FXMaterial {
         this.blending = options.blending ?? NormalBlending;
         this.useAlphaHashing = options.useAlphaHashing ?? false;
         this.alphaTest = options.alphaTest ?? 0.0075;
+        this.premultipliedAlpha =
+            (options.useAlphaHashing === undefined && options.premultipliedAlpha) ?? true;
         this._private_depthAlphaTest = options.depthAlphaTest ?? 0.5;
         this._private_useDepthAlphaHash = options.useDepthAlphaHash ?? false;
         this._private_useSphericalDepth = options.useSphericalDepth ?? true;

package/dist/materials/FXUnlitMaterial/FXUnlitMaterial.Internal.d.ts

@@ -3,4 +3,4 @@ import { MeshBasicMaterial } from "three";
 import type { GLTypeInfo } from "../../instancedParticle/shared";
 import type { FXColorNode } from "../../nodes/color/FXColorNode";
 import type { FXTextureNode } from "../../nodes/texture/FXTextureNode";
-export declare function buildFXUnlitMaterial(varyings: Record<string, GLTypeInfo>, blending: Blending, useAlphaHashing: boolean, alphaTest: number, albedoNodes: readonly (FXColorNode | FXTextureNode)[]): MeshBasicMaterial;
+export declare function buildFXUnlitMaterial(varyings: Record<string, GLTypeInfo>, blending: Blending, useAlphaHashing: boolean, alphaTest: number, premultipliedAlpha: boolean, albedoNodes: readonly (FXColorNode | FXTextureNode)[]): MeshBasicMaterial;

package/dist/materials/FXUnlitMaterial/FXUnlitMaterial.Internal.js

@@ -1,7 +1,7 @@
 import { MeshBasicMaterial, DoubleSide } from 'three';
 import { PARTICLE_DEFINES } from '../../miscellaneous/miscellaneous.js';
 
-function buildFXUnlitMaterial(varyings, blending, useAlphaHashing, alphaTest, albedoNodes) {
+function buildFXUnlitMaterial(varyings, blending, useAlphaHashing, alphaTest, premultipliedAlpha, albedoNodes) {
     const attributeDeclarations = [];
     const varyingDeclarations = [];
     const vertexAssignments = [];
@@ -21,6 +21,7 @@ function buildFXUnlitMaterial(varyings, blending, useAlphaHashing, alphaTest, al
         side: DoubleSide,
         forceSinglePass: true,
         alphaTest,
+        premultipliedAlpha,
     });
     material.onBeforeCompile = (shader) => {
         const vertexPreamble = [

package/dist/materials/FXUnlitMaterial/FXUnlitMaterial.d.ts

@@ -2,5 +2,5 @@ import type { FXMaterialOptions } from "../FXMaterial/FXMaterial";
 import { FXMaterial } from "../FXMaterial/FXMaterial";
 export type FXUnlitMaterialOptions = FXMaterialOptions;
 export declare class FXUnlitMaterial extends FXMaterial {
-    constructor(options?: FXUnlitMaterialOptions);
+    constructor(options?: Partial<FXUnlitMaterialOptions>);
 }

package/dist/materials/FXUnlitMaterial/FXUnlitMaterial.js

@@ -7,7 +7,7 @@ class FXUnlitMaterial extends FXMaterial {
     }
     /** @internal */
     buildThreeMaterial(varyings) {
-        return buildFXUnlitMaterial(varyings, this.blending, this.useAlphaHashing, this.alphaTest, this.albedoNodes);
+        return buildFXUnlitMaterial(varyings, this.blending, this.useAlphaHashing, this.alphaTest, this.premultipliedAlpha, this.albedoNodes);
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sparcoon",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "",
   "keywords": [
     "particles",