// shadow_add2.fx

    #ifndef ZBIASOFFSET
    #define ZBIASOFFSET 1.0f
    #endif

            const float shadowMapFilterSizeN = 1;

            #ifdef USE_SHADOWMAP_CSMN
                    #include "shadow_csm.fx"
            #else
                    #ifdef USE_SHADOWMAP_DYNLMN

                    #else
                    #ifdef USE_SHADOWMAP_STLMN
                    #else
                            const float4x4 ShadowMapViewProjN;

                            float4 GetShadowCoordsAndEpsilonN(float4 pWorld,float smdata)
                            {
                                    float4 ProjCoords = mul(pWorld,ShadowMapViewProjN);
                                    ProjCoords.xy /= ProjCoords.w;
                                    return float4(ProjCoords.xyz,shadowMapEpsilon);
                            }

                            #include "shadow_simple_common.fx"

                            #ifndef SMShadowedOutput
                                    #define SMShadowedOutput
                                    #define OutputShadowCoords(p)
                                    #define InputShadowMap(p,check) GetShadowMap(p,0,check)
                            #endif
                    #endif
                    #endif

            #endif

    texture ShadowMapN;
    sampler2D shadowmapN = sampler_state
    {
            Texture = (ShadowMapN);

            #ifdef USE_SHADOWMAP_NODEPTHN
                            MAGFILTER = LINEAR;
                            MINFILTER =  LINEAR;
                            MIPFILTER =  NONE;
            #else
                    #ifndef USE_SHADOWMAP_VARIANCEN
                            MAGFILTER = POINT;
                            MINFILTER =  POINT;
                            MIPFILTER =  NONE;
                    #else
                            MAGFILTER = LINEAR;
                            MINFILTER =  LINEAR;
                            MIPFILTER =  LINEAR;
                    #endif
            #endif

                    AddressU = Border;
                    AddressV = Border;
                    BorderColor = 0xFFFFFFFF;
    };

            #ifdef USE_SHADOWMAP_PCFN
            #include "shadow_pcf.fx"
            #endif

            #ifdef USE_SHADOWMAP_VARIANCEN
            #include "shadow_variance.fx"
            #endif


            float getShadowMapN(float4 pWorld, float smdata=0, float check=1)
            {
                    #ifdef USE_SHADOWMAP_DYNLMN
                            //return tex2D(shadowmapN, pWorld.xz/64+0.5f).x;
                            float4 dynlm = tex2D(shadowmapN, pWorld.xz/64+0.5f);
                            if (pWorld.y <= dynlm.g*2.5f )
                            {
                                    return dynlm.r;
                            }
                            else
                            {
                                    return 1.0f;
                            }
                    #else
                    #ifdef USE_SHADOWMAP_STLMN
                            return tex2D(shadowmapN, pWorld.xz/64+0.5f).x;
                    #else

                    #ifdef USE_SHADOWMAP_NOISEN
                            float x = pWorld.x * pWorld.z * pWorld.y *1000;
                            x = fmod(x, 13) * fmod(x, 123);
                            float dx = (fmod(x, 0.01) / 8) * shadowMapFilterSizeN;
                            float4 ProjCoords = GetShadowCoordsAndEpsilonN(pWorld,smdata);//,dx); // wtf was that?
                            ProjCoords.xy += dx;
                    #else
                            float4 ProjCoords = GetShadowCoordsAndEpsilonN(pWorld,smdata);
                    #endif
                            if ((ProjCoords.x<0)||(ProjCoords.x>1)||(ProjCoords.y<0)||(ProjCoords.y>1)) return 1;
                            ProjCoords.z *= ZBIASOFFSET;

                    #ifdef USE_SHADOWMAP_VARIANCEN
                            #ifndef USE_SHADOWMAP_PCFN
                                    // Variance, no PCF
                                    return getVarianceN(ProjCoords,check);
                            #else
                                    // Variance + PCF
                                    //return getVariancePCF(ProjCoords,shadowMapFilterSizeN);
                                    return getVarianceN(ProjCoords,check);
                            #endif
                    #else
                            #ifndef USE_SHADOWMAP_PCFN
                                    // No filtering at all
                                    #ifdef USE_SHADOWMAP_NODEPTHN
                                            #ifdef USE_SHADOWMAP_CLAMPN
                                              //return 1-(tex2D(shadowmapN, ProjCoords).x < 1);
                                              float sm = tex2D(shadowmapN, ProjCoords).x;
                                            #ifdef USE_SHADOWMAP_CSMN
                                                    if (smdata > 1) sm=1;
                                            #endif
                                              return sm*sm*sm;
                                            #else
                                              return tex2D(shadowmapN, ProjCoords).x;
                                            #endif
                                    #else
                                            return (tex2D(shadowmapN, ProjCoords).x >= ProjCoords.z-ProjCoords.w);
                                    #endif
                            #else
                                    // PCF
                                    return getPCFN(ProjCoords,shadowMapFilterSizeN,check);
                            #endif
                    #endif

                    #endif // end static lm
                    #endif // end dynamic lm

            }