@woosh/meep-engine 2.33.34 → 2.33.38

package/engine/graphics/micron/build/PatchRepresentation.js

@@ -381,7 +381,7 @@ export class PatchRepresentation {
      *
      * @param {MicronGeometryPatch} result
      * @param {THREE.BufferGeometry} source_geometry
-     * @param {MicronVertexDataSpec} vertex_data_spec
+     * @param {VertexDataSpec} vertex_data_spec
      */
     buildMicronGeometryPatch(result, source_geometry, vertex_data_spec) {
 

package/engine/graphics/micron/build/buildMicronGeometryFromBufferGeometry.js

@@ -214,7 +214,7 @@ export async function buildMicronGeometryFromBufferGeometry(input) {
  *
  * @param {PatchRepresentation} node
  * @param {THREE.BufferGeometry} geometry
- * @param {MicronVertexDataSpec} vertex_spec
+ * @param {VertexDataSpec} vertex_spec
  * @returns {MicronGeometryPatch}
  */
 function compilePatchGraph(node, geometry, vertex_spec) {

package/engine/graphics/micron/build/fill_patch_geometry_data.js

@@ -134,7 +134,7 @@ function compute_attribute_data_converter(source, spec) {
  * @param {MicronGeometryPatch} result
  * @param {THREE.BufferGeometry} buffer_geometry
  * @param {TopoMesh} topo
- * @param {MicronVertexDataSpec} vertex_data_spec
+ * @param {VertexDataSpec} vertex_data_spec
  */
 export function fill_patch_geometry_data(result, buffer_geometry, topo, vertex_data_spec) {
     /**

package/engine/graphics/micron/format/serialization/deserialize_patch.js

@@ -6,7 +6,7 @@ import { DataType2TypedArrayConstructorMapping } from "../../../../../core/colle
  *
  * @param {BinaryBuffer} buffer
  * @param {MicronGeometryPatch} patch
- * @param {MicronVertexDataSpec} vertex_spec
+ * @param {VertexDataSpec} vertex_spec
  * @param {MicronGeometryPatch[]} patch_array
  */
 export function deserialize_patch(buffer, patch, vertex_spec, patch_array) {

package/engine/graphics/micron/format/serialization/serialize_patch.js

@@ -4,7 +4,7 @@ import { DataTypeByteSizes } from "../../../../../core/collection/table/DataType
  *
  * @param {BinaryBuffer} buffer
  * @param {MicronGeometryPatch} patch
- * @param {MicronVertexDataSpec} vertex_spec
+ * @param {VertexDataSpec} vertex_spec
  * @param {MicronGeometryPatch[]} patch_array
  */
 export function serialize_patch(buffer, patch, vertex_spec, patch_array) {

package/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -456,7 +456,7 @@ function init() {
 
     // sample_gltf_sponza();
     // sample_gltf_rts_factory();
-    sample_lucy();
+    // sample_lucy();
     // sample_gltf_hapro_2();
     // sample_gltf_hapro_1();
     // sample_gltf_broken_isiflow();
@@ -465,6 +465,9 @@ function init() {
     // gltf_sample('data/models/moicon/08-clickable-assets/model.gltf');
     // gltf_sample('data/models/moicon/05-ground-floor/model.gltf');
     // gltf_sample('data/models/moicon/isiflow_Oct_15_21/0/model.gltf');
+    // gltf_sample('moicon/29_Dec_2021_Nammo/1/model.gltf');
+    // gltf_sample('moicon/29_Dec_2021_Nammo/1-onematerial/model.gltf');
+    gltf_sample('moicon/29_Dec_2021_Nammo/2/model.gltf');
 
     document.addEventListener("mousemove", onDocumentMouseMove);
 

package/engine/graphics/micron/render/instanced/PatchDataTextures.js

@@ -26,7 +26,7 @@ const MAX_TEXTURE_SIZE = 16384;
 export class PatchDataTextures {
     /**
      *
-     * @param {MicronVertexDataSpec} spec
+     * @param {VertexDataSpec} spec
      * @param {number} [column_count]
      */
     constructor(spec, column_count = 2) {
@@ -35,7 +35,7 @@ export class PatchDataTextures {
 
         /**
          *
-         * @type {MicronVertexDataSpec}
+         * @type {VertexDataSpec}
          * @private
          */
         this.__spec = spec;
@@ -77,7 +77,7 @@ export class PatchDataTextures {
 
     /**
      *
-     * @returns {MicronVertexDataSpec}
+     * @returns {VertexDataSpec}
      */
     get spec() {
         return this.__spec;

package/engine/graphics/micron/render/instanced/ThreeInstancedAdapter.js

@@ -14,7 +14,7 @@ import { shader_rewrite_standard } from "./shader/shader_rewrite_standard.js";
 export class ThreeInstancedAdapter {
     /**
      *
-     * @param {MicronVertexDataSpec} spec
+     * @param {VertexDataSpec} spec
      */
     constructor(spec) {
         /**

package/engine/graphics/micron/render/instanced/shader/shader_rewrite_standard.js

@@ -9,7 +9,7 @@ const DEBUG_PATCHES = false;
  *
  * @param {{vertexShader,fragmentShader,uniforms:Object<IUniform>}} shader
  * @param {Object<IUniform>} uniforms
- * @param {MicronVertexDataSpec} spec
+ * @param {VertexDataSpec} spec
  * @param {number} column_count
  */
 export function shader_rewrite_standard(shader, uniforms, spec, column_count) {

package/engine/graphics/micron/render/makeThreeMeshFromVirtualGeometry.js

@@ -3,7 +3,7 @@ import { Group, Mesh } from "three";
 
 /**
  *
- * @param {MicronVertexDataSpec} spec
+ * @param {VertexDataSpec} spec
  * @param {VirtualGeometry} virtual_geometry
  * @param {THREE.Material[]} materials
  * @returns {Mesh}

package/engine/graphics/micron/render/v1/MaterialContext.js

@@ -73,29 +73,6 @@ export class MaterialContext {
         return this.instances.has(occurrence.instance_id);
     }
 
-    /**
-     * Generate a new custom cache key for three.js internal shader compilation
-     * @param {Material} material
-     * @returns {function()}
-     * @private
-     */
-    __make_custom_cache_key(material) {
-        let existingKeyMaker = material.customProgramCacheKey;
-
-        return () => {
-            let v = '';
-            const attributes = this.__vertex_spec.attributes;
-            const attribute_count = attributes.length;
-
-            for (let i = 0; i < attribute_count; i++) {
-                const a = attributes[i];
-                v += `${a.name}:${a.type}:${a.itemSize}:${a.normalized ? 1 : 0}`;
-            }
-
-            return existingKeyMaker.call(material) + v;
-        }
-    }
-
     init(gl) {
         this.adapter.__gl_context = gl;
 
@@ -105,7 +82,6 @@ export class MaterialContext {
 
         if (material[MATERIAL_FLAG] === undefined) {
             material.onBeforeCompile = composeCompile(this.material.onBeforeCompile, rewrite_material);
-            material.customProgramCacheKey = this.__make_custom_cache_key(this.material);
 
             material[MATERIAL_FLAG] = true;
             material[MATERIAL_VERTEX_DISPLACED] = true;

package/engine/graphics/micron/render/v1/MaterialVertexSpec.js

@@ -2,7 +2,7 @@ export class MaterialVertexSpec {
     constructor() {
         /**
          *
-         * @type {MicronVertexDataSpec|null}
+         * @type {VertexDataSpec|null}
          */
         this.spec = null;
         /**
@@ -34,7 +34,7 @@ export class MaterialVertexSpec {
     }
 
     /**
-     * @param {MicronVertexDataSpec} spec
+     * @param {VertexDataSpec} spec
      * @param {Material} material
      */
     static from(spec, material) {

package/engine/graphics/micron/render/v1/ThreeVirtualGeometryAdapter.js

@@ -19,7 +19,7 @@ export class ThreeVirtualGeometryAdapter {
 
         /**
          *
-         * @type {MicronVertexDataSpec}
+         * @type {VertexDataSpec}
          * @private
          */
         this.__vertex_spec = null;

package/engine/graphics/micron/render/v1/VGThreeRenderer.js

@@ -68,7 +68,7 @@ export class VGThreeRenderer {
 
     /**
      *
-     * @param {MicronVertexDataSpec} spec
+     * @param {VertexDataSpec} spec
      * @param {Material} m
      * @returns {MaterialContext}
      * @private
@@ -122,6 +122,7 @@ export class VGThreeRenderer {
         // clear contexts
         const contexts = this.__contexts_array;
         const context_count = contexts.length;
+
         for (let i = 0; i < context_count; i++) {
             const ctx = contexts[i];
 
@@ -142,8 +143,11 @@ export class VGThreeRenderer {
             }
         };
 
-        for (let i = 0; i < this.__inputs.length; i++) {
-            const input_object = this.__inputs[i];
+        const inputs = this.__inputs;
+        const input_count = inputs.length;
+
+        for (let i = 0; i < input_count; i++) {
+            const input_object = inputs[i];
 
             input_object.traverse(processObject);
         }

package/engine/graphics/particles/node-based/rendering/billboard/ParticleBillboardShader.js

@@ -42,7 +42,7 @@ export const ParticleBillboardShader = {
                 
                 #ifdef DEPTH_SOFT_ENABLED
 			    
-				vFadeDistance = 1.0 / radius;
+				    vFadeDistance = 1.0 / radius;
 				
 				#endif
                 				

package/engine/graphics/particles/particular/engine/renderers/billboard/ParticleBillboardMaterial.js

@@ -17,9 +17,9 @@ const CHUNK_LAMBERT_LIGHTING = `
 vec3 diffuse = vec3( 1.0 );
 
 GeometricContext geometry;
-geometry.position = mvPosition.xyz;
+geometry.position = -vViewPosition;
 geometry.normal = normalize( transformedNormal );
-geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );
+geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -vViewPosition.xyz );
 
 GeometricContext backGeometry;
 backGeometry.position = geometry.position;
@@ -156,28 +156,11 @@ function make_vertex_shader() {
                 varying vec2 vRotationMultiplier;
                 varying float vBlending;
                 
-                
                 #if defined(LIGHTS_ENABLED)
-                    #include <common>
-                    #include <bsdfs>
-                    #include <lights_pars_begin>
-                    
-                    struct LambertMaterial {
-                        vec3 diffuseColor;
-                    };
-                    
-                    void RE_Direct_Lambert( const in IncidentLight directLight, const in GeometricContext geometry, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {
-                        vec3 irradiance = directLight.color;
-                        reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
-                    }
-                    
-                    void RE_IndirectDiffuse_Lambert( const in vec3 irradiance, const in GeometricContext geometry, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {
-                        reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
-                    }
-                    
-                    #define RE_Direct				RE_Direct_Lambert
-                    #define RE_IndirectDiffuse		RE_IndirectDiffuse_Lambert
+                    varying vec3 vViewPosition;
                 #endif
+                    
+                
                 
                 void main() {
                    
@@ -194,10 +177,11 @@ function make_vertex_shader() {
                     
                     #if defined(LIGHTS_ENABLED)
                         vec4 mvPosition = modelViewMatrix * position4;
-                        vec3 vViewPosition = -mvPosition.xyz;
+                        vViewPosition = -mvPosition.xyz;
                         
                         vec3 transformedNormal = vec3(0.0,0.0,1.0);
-                    #else
+                        
+                        #include <worldpos_vertex>
                     #endif
                     
                     gl_Position = modelViewProjectionMatrix * position4;
@@ -222,7 +206,6 @@ function make_vertex_shader() {
                             
                         }
                     #endif
-                    //
                     
                     vRotationMultiplier = vec2( cos(rotationGlobal),sin(rotationGlobal) );
                     
@@ -238,30 +221,6 @@ function make_vertex_shader() {
                     
                     gl_PointSize = projected_radius;
                 
-                    #if defined(LIGHTS_ENABLED)
-                        vec3 vLightFront;
-                        vec3 vIndirectFront;
-                        
-                        #include <worldpos_vertex>
-                        ${CHUNK_LAMBERT_LIGHTING}
-                        
-                        LambertMaterial material = LambertMaterial(vColor.rgb);
-                        
-                        ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
-                        vec3 totalEmissiveRadiance = vec3(0.0);
-                        
-                        reflectedLight.indirectDiffuse += vIndirectFront;
-                        reflectedLight.indirectDiffuse *= BRDF_Lambert( vColor.rgb );
-                        
-                        reflectedLight.directDiffuse = vLightFront;
-                        reflectedLight.directDiffuse *= BRDF_Lambert( vColor.rgb ); // shadowmask goes here
-                        
-                        //@injection_point FORWARD_PLUS:accumulation
-                        
-                        vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
-                        
-                        vColor.rgb = outgoingLight;
-                    #endif
                     
                 }`;
 }
@@ -276,6 +235,10 @@ function make_fragment_shader() {
                 uniform float cameraFar;
                 uniform mat4 modelViewMatrix;
                 uniform mat4 projectionMatrix;
+                      
+                uniform mat4 uProjectionInverse;
+                uniform mat4 uViewInverse;
+                
                 uniform vec2 resolution;
                 
                 varying float vFadeDistance;
@@ -285,7 +248,6 @@ function make_fragment_shader() {
                 varying vec2 vRotationMultiplier;
                 varying float vBlending;
                 
-                
                 out highp vec4 pc_fragColor;
                 
                 float depthToLinear( float z ) {
@@ -334,6 +296,58 @@ function make_fragment_shader() {
                     return zFade;
                 }
                 
+                
+                #if defined(LIGHTS_ENABLED)
+                
+                    vec3 computeWorldPositionFromFragmentPosition(vec3 coord){
+                         vec4 ndc = vec4(
+                        (coord.x - 0.5) * 2.0,
+                        (coord.y - 0.5) * 2.0,
+                        (coord.z - 0.5) * 2.0,
+                        1.0);
+                    
+                        vec4 clip = uProjectionInverse * ndc;
+                        return (uViewInverse* (clip / clip.w) ).xyz;
+                    }
+                
+                    vec3 construct_spherical_normal_from_point_coord(vec2 coord){
+                        float x = coord.x * 2.0 - 1.0;
+                        float y = coord.y * 2.0 - 1.0; // note we flip Y
+                    
+                        float z = sqrt(1.0 - clamp(x*x + y*y, 0.0, 1.0));
+                    
+                        
+                        vec3 position = vec3(x, -y, z);
+                    
+                        vec3 normal = normalize(position);
+                        
+                        return normal;
+                    }
+                
+                    #include <common>
+                    #include <bsdfs>
+                    #include <lights_pars_begin>
+                    
+                    struct LambertMaterial {
+                        vec3 diffuseColor;
+                    };
+                    
+                    void RE_Direct_Lambert( const in IncidentLight directLight, const in GeometricContext geometry, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {
+                        float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
+                        vec3 irradiance =  dotNL * directLight.color;
+                        reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
+                    }
+                    
+                    void RE_IndirectDiffuse_Lambert( const in vec3 irradiance, const in GeometricContext geometry, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {
+                        reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
+                    }
+                    
+                    #define RE_Direct				RE_Direct_Lambert
+                    #define RE_IndirectDiffuse		RE_IndirectDiffuse_Lambert
+                    
+                    varying vec3 vViewPosition;
+                #endif
+                
                 void main() {
                     float fragmentDepth = gl_FragCoord.z;
                     
@@ -365,6 +379,37 @@ function make_fragment_shader() {
                     
                     vec4 texel = spriteColor * vColor;
                     
+                    #if defined(LIGHTS_ENABLED)
+                        // compute world position
+                        vec3 v_world_position = computeWorldPositionFromFragmentPosition(gl_FragCoord.xyz);
+               
+                
+                        vec3 vLightFront;
+                        vec3 vIndirectFront;
+                        
+                        vec3 transformedNormal = construct_spherical_normal_from_point_coord(gl_PointCoord.xy);
+                        
+                        ${CHUNK_LAMBERT_LIGHTING}
+                        
+                        LambertMaterial material = LambertMaterial(texel.rgb);
+                        
+                        ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
+                        vec3 totalEmissiveRadiance = vec3(0.0);
+                        
+                        reflectedLight.indirectDiffuse += vIndirectFront;
+                        reflectedLight.indirectDiffuse *= BRDF_Lambert( texel.rgb );
+                        
+                        reflectedLight.directDiffuse = vLightFront;
+                        reflectedLight.directDiffuse *= BRDF_Lambert( texel.rgb ); // shadowmask goes here
+                        
+                        //@injection_point FORWARD_PLUS:accumulation
+                        
+                        vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
+                        
+                        texel.rgb = outgoingLight;
+                    #endif
+                                    
+                    
                     // premultiply alpha
                     texel.xyz *= texel.a;
                     
@@ -379,9 +424,8 @@ function make_fragment_shader() {
                         texel *= zFade;
                     
                     #endif
-                                    
-                    pc_fragColor = texel;
                     
+                    pc_fragColor = texel;
                 }`;
 }
 
@@ -426,7 +470,9 @@ export function make_particle_billboard_shader({ lights = false } = {}) {
         resolution: {
             type: 'v2',
             value: new ThreeVector2()
-        }
+        },
+        uViewInverse: { type: 'm4', value: new Matrix4() },
+        uProjectionInverse: { type: 'm4', value: new Matrix4() },
     };
 
     if (lights) {
@@ -439,8 +485,7 @@ export function make_particle_billboard_shader({ lights = false } = {}) {
             DEPTH_READ_ENABLED: true,
             DEPTH_SOFT_ENABLED: true,
             ALIGN_DIRECTION_ENABLED: false,
-            LIGHTS_ENABLED: lights,
-            LIGHTING_VERTEX_ONLY: true
+            LIGHTS_ENABLED: lights
         },
         uniforms: uniforms,
         vertexShader: make_vertex_shader(),

package/engine/graphics/particles/particular/engine/shader/ShaderManager.js

@@ -189,7 +189,9 @@ export class ShaderManager {
             },
             cameraFar: {
                 value: 0
-            }
+            },
+            uViewInverse: { type: 'm4', value: new Matrix4() },
+            uProjectionInverse: { type: 'm4', value: new Matrix4() },
         };
 
         // debugAtlas(this.spriteAtlas.atlas, { scale: new Vector2(1, 1) });
@@ -396,6 +398,9 @@ export class ShaderManager {
         uniforms.modelViewMatrix.value = modelViewMatrix;
         uniforms.cameraNear.value = cameraNear;
         uniforms.cameraFar.value = cameraFar;
+
+        uniforms.uProjectionInverse.value.copy(camera.projectionMatrixInverse);
+        uniforms.uViewInverse.value.copy(camera.matrixWorld);
     }
 
     /**

package/engine/graphics/particles/particular/engine/utils/volume/ParticleVolume.js

@@ -123,6 +123,7 @@ export class ParticleVolume {
             "softDepth": true,
             "depthSort": false,
             "velocityAlign": false,
+            "receiveLight": true,
             "blendingMode": 0,
             "layers": [
                 {

package/engine/graphics/render/forward_plus/cluster/compute_light_data_hash_0.js

@@ -13,5 +13,5 @@ export function compute_light_data_hash_0(nodes, count) {
         hash = hash * 31 + datum;
     }
 
-    return hash & 0x7fffffff;
+    return hash >>> 0;
 }

package/engine/graphics/render/forward_plus/materials/fp_build_fragment_shader.js

@@ -15,10 +15,8 @@ const accumulation_pars = `
 const preamble = `
     ${FP_SHADER_CHUNK_PREAMBLE}
     
-    varying vec3 v_world_position;
     
-    out highp vec4 pc_fragColor;
-    #define gl_FragColor pc_fragColor
+    
     `;
 
 /**
@@ -27,7 +25,22 @@ const preamble = `
  * @returns {string}
  */
 export function fp_build_fragment_shader(base) {
-    let result = preamble + base;
+    let result = preamble;
+
+    if (base.indexOf('v_world_position') === -1) {
+        result = result + `
+        varying vec3 v_world_position;
+        `;
+    }
+
+    if (base.indexOf('#define gl_FragColor') === -1 && base.indexOf('pc_fragColor') === -1) {
+        result = result + `
+            out highp vec4 pc_fragColor;
+            #define gl_FragColor pc_fragColor
+            `;
+    }
+
+    result = result + base
 
     result = insert_after(result, '#include <lights_pars_begin>', FP_SHADER_CHUNK_DECODE_PARS);
 

package/engine/graphics/render/forward_plus/plugin/ForwardPlusRenderingPlugin.js

@@ -40,7 +40,7 @@ export class ForwardPlusRenderingPlugin extends EnginePlugin {
     async startup() {
         const lm = this.__light_manager;
 
-        lm.setTileMapResolution(16, 8, 10);
+        lm.setTileMapResolution(16, 8, 8);
 
         const graphics = this.engine.graphics;
 

package/engine/graphics/render/visibility/VisibilityComputer.js

@@ -9,6 +9,12 @@ const frustum = new Frustum();
  */
 const objectFilters = [];
 
+/**
+ *
+ * @type {function[]}
+ */
+const objectFilterExecutors = [];
+
 export const SOURCE_RENDER_LAYER_PROPERTY = '@meep-render-layer';
 
 export class VisibilityComputer {
@@ -135,12 +141,6 @@ export class VisibilityComputer {
         // clear visible set
         // this.__output.initializeUpdate();
 
-        /**
-         *
-         * @type {function[]}
-         */
-        const objectFilterExecutors = [];
-
         const filters = this.filters;
         const filterCount = filters.length;
 
@@ -151,7 +151,7 @@ export class VisibilityComputer {
 
             if (f.enabled && f.layerPredicate(layer)) {
                 objectFilters[objectFilterCount] = f;
-                objectFilterExecutors.push(f.objectPredicateExecute);
+                objectFilterExecutors[objectFilterCount] = f.objectPredicateExecute;
 
                 objectFilterCount++;
             }
@@ -165,6 +165,7 @@ export class VisibilityComputer {
             f.objectPredicateInitialize(this.__view.camera);
         }
 
+        objectFilterExecutors.length = objectFilterCount;
 
         layer.buildVisibleSet(this.__frustums, objectFilterExecutors, this.__includeObject, this);
 

package/engine/graphics/shaders/TerrainShader.js

@@ -366,27 +366,27 @@ function fragment() {
         gl_FragColor  = vec4( outgoingLight, diffuseColor.a );
       
         #if defined( TONE_MAPPING )
-            gl_FragColor.rgb = toneMapping( pc_fragColor.rgb );
+            gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );
         #endif
         
         //encode fragment
-        pc_fragColor = linearToOutputTexel( pc_fragColor );
+        gl_FragColor = linearToOutputTexel( gl_FragColor );
         #ifdef USE_FOG
             #ifdef FOG_EXP2
                 float fogFactor = 1.0 - exp( - fogDensity * fogDensity * fogDepth * fogDepth );
             #else
                 float fogFactor = smoothstep( fogNear, fogFar, fogDepth );
             #endif
-            gl_FragColor.rgb = mix( pc_fragColor.rgb, fogColor, fogFactor );
+            gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );
         #endif
         
         #ifdef PREMULTIPLIED_ALPHA
             // Get get normal blending with premultipled, use with CustomBlending, OneFactor, OneMinusSrcAlphaFactor, AddEquation.
-            gl_FragColor.rgb *= pc_fragColor.a;
+            gl_FragColor.rgb *= gl_FragColor.a;
         #endif
         
         #ifdef DITHERING
-            pc_fragColor.rgb = dithering( pc_fragColor.rgb );
+            gl_FragColor.rgb = dithering( gl_FragColor.rgb );
         #endif
     }
     `;