Setting 'setNumSamples' on FilterPostProcessor causes SdsmDirectionalLightShadowFilter to crash.

[foxcc2021]

Test case

package test;

import com.jme3.app.SimpleApplication;
import com.jme3.light.DirectionalLight;
import com.jme3.material.Material;
import com.jme3.math.Vector3f;
import com.jme3.post.FilterPostProcessor;
import com.jme3.renderer.queue.RenderQueue;
import com.jme3.scene.Geometry;
import com.jme3.scene.shape.Box;
import com.jme3.shadow.SdsmDirectionalLightShadowFilter;

public class TestShadowCrash2 extends SimpleApplication {
    
    @Override
    public void simpleInitApp() {
        Geometry box = new Geometry("", new Box(0.5f, 0.5f, 0.5f));
        box.setMaterial(new Material(getAssetManager(), "Common/MatDefs/Light/Lighting.j3md"));
        box.setShadowMode(RenderQueue.ShadowMode.CastAndReceive);
        rootNode.attachChild(box);
        
        Geometry floor = new Geometry("", new Box(0.5f, 0.5f, 0.5f));
        floor.setMaterial(new Material(getAssetManager(), "Common/MatDefs/Light/Lighting.j3md"));
        floor.setShadowMode(RenderQueue.ShadowMode.CastAndReceive);
        floor.setLocalTranslation(0, -1, 0);
        floor.setLocalScale(5, 1, 5);
        rootNode.attachChild(floor);
        
        DirectionalLight light = new DirectionalLight(new Vector3f(-1, -1, -1));
        rootNode.addLight(light);
        
        FilterPostProcessor fpp = new FilterPostProcessor(assetManager);
        fpp.setNumSamples(2);
        viewPort.addProcessor(fpp);
        
        SdsmDirectionalLightShadowFilter shadowFilter = new SdsmDirectionalLightShadowFilter(assetManager, 512, 2);
        shadowFilter.setLight(light);
        fpp.addFilter(shadowFilter);
    }

    @Override
    public void simpleUpdate(float tpf) {
        super.simpleUpdate(tpf);
    }
    
    public static void main(String[] args) {
        TestShadowCrash2 app = new TestShadowCrash2();
        app.start();
    }
}

Error log

Feb 21, 2026 12:20:50 AM com.jme3.app.SimpleApplication start
INFO: AppSettings not set, creating default settings.
Feb 21, 2026 12:20:50 AM com.jme3.system.JmeSystemDelegate lambda$new$1
WARNING: JmeDialogsFactory implementation not found.
Feb 21, 2026 12:20:50 AM com.jme3.system.JmeDesktopSystem initialize
INFO: Running on jMonkeyEngine 3.10.0-alpha1
 * Branch: HEAD
 * Git Hash: d3efabc
 * Build Date: 2026-02-09
Feb 21, 2026 12:20:51 AM com.jme3.system.lwjgl.LwjglContext printContextInitInfo
INFO: LWJGL 3.4.0+20 context running on thread jME3 Main
 * Graphics Adapter: GLFW 3.5.0 Win32 WGL Null EGL OSMesa VisualC DLL
Feb 21, 2026 12:20:51 AM com.jme3.renderer.opengl.GLRenderer loadCapabilitiesCommon
INFO: OpenGL Renderer Information
 * Vendor: NVIDIA Corporation
 * Renderer: NVIDIA GeForce RTX 3060/PCIe/SSE2
 * OpenGL Version: 3.2.0 NVIDIA 560.94
 * GLSL Version: 1.50 NVIDIA via Cg compiler
 * Profile: Core
Feb 21, 2026 12:20:51 AM com.jme3.audio.openal.ALAudioRenderer printAudioRendererInfo
INFO: Audio Renderer Information
 * Device: OpenAL Soft
 * Vendor: OpenAL Community
 * Renderer: OpenAL Soft
 * Version: 1.1 ALSOFT 1.25.0
 * Supported channels: 64
 * ALC extensions: ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE ALC_EXT_debug ALC_EXT_DEDICATED ALC_EXT_direct_context ALC_EXT_disconnect ALC_EXT_EFX ALC_EXT_thread_local_context ALC_SOFT_device_clock ALC_SOFT_HRTF ALC_SOFT_loopback ALC_SOFT_loopback_bformat ALC_SOFT_output_limiter ALC_SOFT_output_mode ALC_SOFT_pause_device ALC_SOFT_reopen_device ALC_SOFT_system_events
 * AL extensions: AL_EXT_ALAW AL_EXT_BFORMAT AL_EXT_debug AL_EXT_direct_context AL_EXT_DOUBLE AL_EXT_EXPONENT_DISTANCE AL_EXT_FLOAT32 AL_EXT_IMA4 AL_EXT_LINEAR_DISTANCE AL_EXT_MCFORMATS AL_EXT_MULAW AL_EXT_MULAW_BFORMAT AL_EXT_MULAW_MCFORMATS AL_EXT_OFFSET AL_EXT_source_distance_model AL_EXT_SOURCE_RADIUS AL_EXT_STATIC_BUFFER AL_EXT_STEREO_ANGLES AL_LOKI_quadriphonic AL_SOFT_bformat_ex AL_SOFT_bformat_hoa AL_SOFT_block_alignment AL_SOFT_buffer_length_query AL_SOFT_callback_buffer AL_SOFTX_convolution_effect AL_SOFT_deferred_updates AL_SOFT_direct_channels AL_SOFT_direct_channels_remix AL_SOFT_effect_target AL_SOFT_events AL_SOFT_gain_clamp_ex AL_SOFTX_hold_on_disconnect AL_SOFT_loop_points AL_SOFTX_map_buffer AL_SOFT_MSADPCM AL_SOFT_source_latency AL_SOFT_source_length AL_SOFTX_source_panning AL_SOFT_source_resampler AL_SOFT_source_spatialize AL_SOFT_source_start_delay AL_SOFT_UHJ AL_SOFT_UHJ_ex
Feb 21, 2026 12:20:51 AM com.jme3.audio.openal.ALAudioRenderer initEfx
INFO: Audio effect extension version: 1.0
Feb 21, 2026 12:20:51 AM com.jme3.audio.openal.ALAudioRenderer initEfx
INFO: Audio max auxiliary sends: 2
Feb 21, 2026 12:20:51 AM com.jme3.app.LegacyApplication handleError
SEVERE: Uncaught exception thrown in Thread[#33,jME3 Main,5,main]
java.lang.IllegalArgumentException: Material parameter is not defined: NumSamplesDepth
	at com.jme3.material.Material.checkSetParam(Material.java:515)
	at com.jme3.material.Material.setParam(Material.java:531)
	at com.jme3.material.Material.setInt(Material.java:726)
	at com.jme3.post.FilterPostProcessor.renderFilterChain(FilterPostProcessor.java:372)
	at com.jme3.post.FilterPostProcessor.postFrame(FilterPostProcessor.java:428)
	at com.jme3.renderer.pipeline.ForwardPipeline.pipelineRender(ForwardPipeline.java:127)
	at com.jme3.renderer.RenderManager.renderViewPort(RenderManager.java:1303)
	at com.jme3.renderer.RenderManager.render(RenderManager.java:1345)
	at com.jme3.app.SimpleApplication.update(SimpleApplication.java:361)
	at com.jme3.system.lwjgl.LwjglWindow.runLoop(LwjglWindow.java:735)
	at com.jme3.system.lwjgl.LwjglWindow.run(LwjglWindow.java:825)
	at java.base/java.lang.Thread.run(Thread.java:1583)

Feb 21, 2026 12:20:51 AM com.jme3.system.JmeSystemDelegate lambda$new$0
WARNING: JmeDialogsFactory implementation not found.
Uncaught exception thrown in Thread[#33,jME3 Main,5,main]
IllegalArgumentException: Material parameter is not defined: NumSamplesDepth
Feb 21, 2026 12:20:51 AM com.jme3.audio.openal.ALAudioRenderer destroyOpenAL
INFO: OpenAL context destroyed.

Exception: java.lang.AssertionError thrown from the UncaughtExceptionHandler in thread "jME3 Main"

Test environment： win11, java21, jMonkeyEngine 3.10.0-alpha1

[riccardobl]

The material introduced in #2578 lacks some fields needed for full support in jme filters.

[jeannekamikaze]

I'm a total noob to this project and had a go at this lured by the Easy first fix label. Plot twist: turns out it wasn't that easy.

I found it's not sufficient to just edit the material; the depth texture becomes multi-sampled, so then the SDSM shaders must be changed accordingly. Below is a patch that does this, with some TODOs:

• Where to define DEPTH_RESOLVE_MS? I see nowhere where this macro is defined.
• I have no idea how to configure the m_NumSamplesDepth uniform from a compute shader (I think it's just missing the plumbing.)
• I'm not even sure averaging the depth and running the SDSM is the right thing to do? Shadow map algorithms typically require running the algorithm on each sample and then averaging the results, not averaging the samples.

With those TODOs aside, I got pretty close:

If someone can provide some guidance on the questions above, I can try to finish this diff and put up a PR.

Thanks.

diff --git a/jme3-core/src/main/resources/Common/MatDefs/Shadow/Sdsm/FitLightFrustums.comp b/jme3-core/src/main/resources/Common/MatDefs/Shadow/Sdsm/FitLightFrustums.comp
index 191da705d..ef0cdbc53 100644
--- a/jme3-core/src/main/resources/Common/MatDefs/Shadow/Sdsm/FitLightFrustums.comp
+++ b/jme3-core/src/main/resources/Common/MatDefs/Shadow/Sdsm/FitLightFrustums.comp
@@ -1,12 +1,16 @@
 #version 430
 
+#define RESOLVE_DEPTH_MS 1 // TODO: How to define this?
+
+#import "Common/ShaderLib/MultiSample.glsllib"
+
 /**
  * Computes tight bounding boxes for each shadow cascade via min/max on lightspace locations of depth samples that fall within each cascade.
  */
 
 layout(local_size_x = 16, local_size_y = 16) in;
 
-layout(binding = 0) uniform sampler2D inputDepth;
+layout(binding = 0) uniform DEPTHTEXTURE inputDepth;
 
 layout(std430, binding = 1) readonly buffer MinMaxBuffer {
     uint gMin;
@@ -103,7 +107,7 @@ void main() {
     ivec2 gid = ivec2(gl_GlobalInvocationID.xy);
     ivec2 lid = ivec2(gl_LocalInvocationID.xy);
     uint tid = gl_LocalInvocationIndex;
-    ivec2 inputSize = textureSize(inputDepth, 0);
+    ivec2 inputSize = getTextureSize(inputDepth);
     ivec2 baseCoord = gid * 2;
 
     // Initialize local bounds to infinity
@@ -126,11 +130,11 @@ void main() {
         for (int x = 0; x < 2; x++) {
             ivec2 coord = baseCoord + ivec2(x, y);
             if (coord.x < inputSize.x && coord.y < inputSize.y) {
-                float depth = texelFetch(inputDepth, coord, 0).r;
+                float depth = fetchTexel(inputDepth, coord, m_NumSamplesDepth).r;
                 // Skip background (depth == 1.0)
                 if (depth != 1.0) {
                     // Reconstruct clip-space position from depth
-                    vec2 uv = (vec2(coord) + 0.5) / vec2(textureSize(inputDepth, 0));
+                    vec2 uv = (vec2(coord) + 0.5) / vec2(getTextureSize(inputDepth));
                     vec4 clipPos = vec4(uv * 2.0 - 1.0, depth * 2.0 - 1.0, 1.0);
 
                     // Transform to light view space
diff --git a/jme3-core/src/main/resources/Common/MatDefs/Shadow/Sdsm/ReduceDepth.comp b/jme3-core/src/main/resources/Common/MatDefs/Shadow/Sdsm/ReduceDepth.comp
index c6424c43e..ac1210b6b 100644
--- a/jme3-core/src/main/resources/Common/MatDefs/Shadow/Sdsm/ReduceDepth.comp
+++ b/jme3-core/src/main/resources/Common/MatDefs/Shadow/Sdsm/ReduceDepth.comp
@@ -1,12 +1,16 @@
 #version 430
 
+#define RESOLVE_DEPTH_MS 1 // TODO: How to define this?
+
+#import "Common/ShaderLib/MultiSample.glsllib"
+
 /**
  * Finds the global minimum/maximum values of a depth texture.
  */
 
 layout(local_size_x = 16, local_size_y = 16) in;
 
-layout(binding = 0) uniform sampler2D inputDepth;
+layout(binding = 0) uniform DEPTHTEXTURE inputDepth;
 
 layout(std430, binding = 1) buffer MinMaxBuffer {
     uint gMin;
@@ -33,7 +37,7 @@ void main() {
     ivec2 gid = ivec2(gl_GlobalInvocationID.xy);
     ivec2 lid = ivec2(gl_LocalInvocationID.xy);
     uint tid = gl_LocalInvocationIndex;
-    ivec2 inputSize = textureSize(inputDepth, 0);
+    ivec2 inputSize = getTextureSize(inputDepth);
 
     // Each thread samples a 2x2 block
     ivec2 baseCoord = gid * 2;
@@ -43,7 +47,7 @@ void main() {
         for (int x = 0; x < 2; x++) {
             ivec2 coord = baseCoord + ivec2(x, y);
             if (coord.x < inputSize.x && coord.y < inputSize.y) {
-                float depth = texelFetch(inputDepth, coord, 0).r;
+                float depth = fetchTexel(inputDepth, coord, m_NumSamplesDepth);
                 // Discard depth == 1.0 (background/sky)
                 if (depth != 1.0) {
                     minMax.x = min(minMax.x, depth);
diff --git a/jme3-core/src/main/resources/Common/MatDefs/Shadow/Sdsm/SdsmPostShadow.frag b/jme3-core/src/main/resources/Common/MatDefs/Shadow/Sdsm/SdsmPostShadow.frag
index c8a2c6405..a6e2dda5f 100644
--- a/jme3-core/src/main/resources/Common/MatDefs/Shadow/Sdsm/SdsmPostShadow.frag
+++ b/jme3-core/src/main/resources/Common/MatDefs/Shadow/Sdsm/SdsmPostShadow.frag
@@ -1,9 +1,10 @@
 #import "Common/ShaderLib/GLSLCompat.glsllib"
+#import "Common/ShaderLib/MultiSample.glsllib"
 #import "Common/ShaderLib/Shadows.glsllib"
 
 //Stripped version of the usual shadow fragment shader for SDSM; it intentionally leaves out some features.
-uniform sampler2D m_Texture;
-uniform sampler2D m_DepthTexture;
+uniform COLORTEXTURE m_Texture;
+uniform DEPTHTEXTURE m_DepthTexture;
 uniform mat4 m_ViewProjectionMatrixInverse;
 uniform vec4 m_ViewProjectionMatrixRow2;
 
@@ -43,8 +44,8 @@ float determineShadow(int index, vec4 worldPos){
 }
 
 void main() {
-    float depth = texture2D(m_DepthTexture,texCoord).r;
-    vec4 color = texture2D(m_Texture,texCoord);
+    float depth = getColor(m_DepthTexture,texCoord).r;
+    vec4 color  = getDepth(m_Texture,texCoord);
 
     //Discard shadow computation on the sky
     if(depth == 1.0){
diff --git a/jme3-core/src/main/resources/Common/MatDefs/Shadow/Sdsm/SdsmPostShadow.j3md b/jme3-core/src/main/resources/Common/MatDefs/Shadow/Sdsm/SdsmPostShadow.j3md
index 3d82b3f44..aceaa3c22 100644
--- a/jme3-core/src/main/resources/Common/MatDefs/Shadow/Sdsm/SdsmPostShadow.j3md
+++ b/jme3-core/src/main/resources/Common/MatDefs/Shadow/Sdsm/SdsmPostShadow.j3md
@@ -31,7 +31,8 @@ MaterialDef Post Shadow {
         Texture2D DepthTexture
 
         Boolean BackfaceShadows //Not used.
-        Int NumSamples //Not used.
+        Int NumSamples
+        Int NumSamplesDepth
     }
 
     Technique {
@@ -47,6 +48,8 @@ MaterialDef Post Shadow {
             FILTER_MODE : FilterMode
             PCFEDGE : PCFEdge
             SHADOWMAP_SIZE : ShadowMapSize
+            RESOLVE_MS : NumSamples
+            RESOLVE_DEPTH_MS : NumSamplesDepth
         }
     }
 }
\ No newline at end of file
diff --git a/jme3-core/src/main/resources/Common/ShaderLib/MultiSample.glsllib b/jme3-core/src/main/resources/Common/ShaderLib/MultiSample.glsllib
index 8dc1e2a72..7b163cdfd 100644
--- a/jme3-core/src/main/resources/Common/ShaderLib/MultiSample.glsllib
+++ b/jme3-core/src/main/resources/Common/ShaderLib/MultiSample.glsllib
@@ -44,21 +44,58 @@ vec4 getDepth(in sampler2DMS tex,in vec2 texC){
       return textureFetch(tex,texC,m_NumSamplesDepth);
 }
 
+ivec2 getTextureSize(in sampler2DMS tex) {
+    return textureSize(tex);
+}
+
+// TODO: Need to figure out how to pass m_NumSamplesDepth to a compute shader.
+float fetchTexel(in sampler2DMS tex, in ivec2 coord, in int numSamples) {
+    /*float sum = 0;
+    for (int i = 0; i < numSamples; ++i) {
+        sum += texelFetch(tex, coord, i).r;
+    }
+    return sum / float(numSamples);*/
+    return texelFetch(tex, coord, 0).r;
+}
 #endif
 
 vec4 fetchTextureSample(in sampler2D tex,in vec2 texC,in int sampleId){
+#if __VERSION__>=430
+    return texture(tex,texC);
+#else
     return texture2D(tex,texC);
+#endif
 }
 
 vec4 getColor(in sampler2D tex, in vec2 texC){
+#if __VERSION__>=430
+    return texture(tex,texC);
+#else
     return texture2D(tex,texC);
+#endif
 }
 
 vec4 getColorSingle(in sampler2D tex, in vec2 texC){
-    return texture2D(tex, texC);
+#if __VERSION__>=430
+    return texture(tex,texC);
+#else
+    return texture2D(tex,texC);
+#endif
 }
 
 vec4 getDepth(in sampler2D tex,in vec2 texC){
+#if __VERSION__>=430
+    return texture(tex,texC);
+#else
     return texture2D(tex,texC);
+#endif
 }
 
+ivec2 getTextureSize(in sampler2D tex) {
+    return textureSize(tex, 0);
+}
+
+
+float fetchTexel(in sampler2D tex, in ivec2 coord, in int lod) {
+    return texelFetch(tex, coord, lod).r;
+}
diff --git a/jme3-core/src/plugins/java/com/jme3/shader/plugins/GLSLLoader.java b/jme3-core/src/plugins/java/com/jme3/shader/plugins/GLSLLoader.java
index 63b8ba68c..d047f8fa8 100644
--- a/jme3-core/src/plugins/java/com/jme3/shader/plugins/GLSLLoader.java
+++ b/jme3-core/src/plugins/java/com/jme3/shader/plugins/GLSLLoader.java
@@ -108,6 +108,9 @@ public class GLSLLoader implements AssetLoader {
                     }
                 } else if (tln.startsWith("#extension ")) {
                     sbExt.append(ln).append('\n');
+                } else if (tln.startsWith("#version ")) {
+                    // #version must appear before the extensions, so treat like one.
+                    sbExt.append(ln).append('\n');
                 } else {
                     sb.append(ln).append('\n');
                 }

[jeannekamikaze]

Ok, that material seems irrelevant to compute shaders, that's why RESOLVE_DEPTH_MS is undefined in the SDSM's two compute shaders. But there also appears no way currently to tell a ComputeShader a set of defines to compile with. Moreover, whether the depth texture has multisampling is only known late when the FilterPostProcessor chain is executed. So I think SdsmFitter would have to check whether the depth target has multisampling, and if so, pass the define to the computer shaders and have them recompile. But I also don't know if I'm going down the wrong rabbit hole here, so I'll leave it there until somebody can jump in and provide some direction.

A different approach would be to resolve the multisampled depth (and colour, for filters that matter) prior to running the filters. This way the filters would not be ms-aware. But this goes back to my comment above: I'm not sure this is correct for shadow passes.

[riccardobl]

Hello, and welcome!

I may have mislabeled this. It is an easy fix for someone experienced with the engine, it is definitely not an easy first fix. I apologize for the confusion.

RESOLVE_DEPTH_MS is set automatically by the filter post processor, and you only have to define it in the matdef
eg.

jmonkeyengine/jme3-effects/src/main/resources/Common/MatDefs/Post/Fog.j3md

Line 24 in a8b89f8

RESOLVE_DEPTH_MS : NumSamplesDepth

then on the fragment shader you have some helpers in GLSLCompat that let you handle multisampling automatically
eg.
https://github.com/jMonkeyEngine/jmonkeyengine/blob/master/jme3-effects/src/main/resources/Common/MatDefs/Post/Fog.frag

But please note: this is an issue only in the final part of sdsm shadows, that is the one that puts things together in post processing, from my understanding the issue is not related to the code in compute shaders.

[foxcc2021]

This shadow effect is quite impressive, great work!
But I'm no shader expert, so I won't be able to offer any additional help

[jeannekamikaze]

from my understanding the issue is not related to the code in compute shaders.

I think it is. I kind of saw this initially from the realization that I could get the shaders back to work if I replaced the sampler2D with a sampler2DMS (or the DEPTHTEXTURE alias) and the texture()/texture2D() calls with texelFetch (can't sample a multisampled-texture.) But here is the longer explanation:

1. The demo app calls fpp.setNumSamples(2);
2. FilterPostProcessor saves the sample count. On a reshape, it re-initializes the depth texture to be multisampled here.
3. It then reinitializes all filters here, which among other things passes the depth texture downstream here.
4. The SDSM filter uses an SDSM renderer, which in updateShadowCams() calls the compute shaders here. updateShadowCams() is called from postQueue(). The compute shaders take that same depth texture as input (now multisampled).

But the logic to manage DepthTexture and NumSamplesDepth (also Texture and NumSamples, but SDSM only needs depth) in FilterPostProcessor is tied to the filter's material; the compute shaders seem to exist entirely orthogonal to the material and the logic to manage it, and so what is missing here is the plumbing to connect the multi-sampling logic with those compute shaders. #2578 appears to have added compute shaders in a way that is not completely integrated with the existing FilterPostProcessor logic.

How to go about that is beyond me right now. I think I'll leave this as is; somebody with more experience can look at it. I could also be totally wrong with the summary above.

I believe that the underlying issue here though is that setNumSamples() is exposed as a setter. In these sort of APIs there is always a trade-off between providing the flexibility to change things on the fly vs then having to manage those state changes. If the number of samples had to be given up front in the constructor to FilterPostProcessor and not allowed to change after the fact, this bug would not be much of a problem (still need to configure the compute shaders to work with multisampled depth, but not handle numSamples state changes because they wouldn't be possible.) Client code could then rebuild the entire post-processor if this parameter changed, which is an infrequent operation, as bad as it sounds. But as it stands, in order to fix this issue, one must add both that initial plumbing plus then handle changes to the multisampled state of the textures, which means recompiling those compute shaders (for best performance, the shaders should be compiled specialized to their inputs and query as few uniforms as possible.) Which kind of leads me to another tangent, but I did not see a shader cache in use; so it seems the engine would recompile the same shader unnecessarily and rely on the driver's own cache depending on the flow of state changes.

[codex128]

the compute shaders seem to exist entirely orthogonal to the material and the logic to manage it, and so what is missing here is the plumbing to connect the multi-sampling logic with those compute shaders.

This is correct. Compute shaders were added very recently (exactly for sdsm shadows, in fact), and it was decided that it wasn't worth the trouble to integrate compute shaders into the existing shader system, hence why there is no formal defines system for it. Jme4 is aiming to rectify this problem.

I think the best solution would be to manually insert the necessary defines into the shader source code when the ComputeShader is initialized. When the number of samples is changed, create and use a new ComputeShader object with different defines.

[jeannekamikaze]

Sounds good. In that case, I'll look into doing what you mentioned. It's certainly a good issue to dig into the engine.

By the way, I'm curious to read about the high-level goals of JME4 if you guys have written anything on the subject.