Merge pull request #2191 from yaRnMcDonuts/patch-3

Modularize PBRLighting.frag

jme3-core/src/main/resources/Common/MatDefs/Light/modular/PBRLighting.frag

@@ -0,0 +1,73 @@
+#import "Common/ShaderLib/GLSLCompat.glsllib"
+
+// enable apis and import PBRLightingUtils
+#define ENABLE_PBRLightingUtils_getWorldPosition 1
+#define ENABLE_PBRLightingUtils_getWorldNormal 1
+#define ENABLE_PBRLightingUtils_getWorldTangent 1
+#define ENABLE_PBRLightingUtils_getTexCoord 1
+#define ENABLE_PBRLightingUtils_readPBRSurface 1
+#define ENABLE_PBRLightingUtils_computeDirectLightContribution 1
+#define ENABLE_PBRLightingUtils_computeProbesContribution 1
+
+#import "Common/ShaderLib/module/pbrlighting/PBRLightingUtils.glsllib"
+
+#ifdef DEBUG_VALUES_MODE
+    uniform int m_DebugValuesMode;
+#endif
+
+uniform vec4 g_LightData[NB_LIGHTS];
+uniform vec3 g_CameraPosition;
+
+void main(){
+    vec3 wpos = PBRLightingUtils_getWorldPosition();
+    vec3 worldViewDir = normalize(g_CameraPosition - wpos);
+    
+    // Load surface data
+    PBRSurface surface=PBRLightingUtils_readPBRSurface(worldViewDir);
+    
+    // Calculate direct lights
+    for(int i = 0;i < NB_LIGHTS; i+=3){
+        vec4 lightData0 = g_LightData[i];
+        vec4 lightData1 = g_LightData[i+1];
+        vec4 lightData2 = g_LightData[i+2];    
+        PBRLightingUtils_computeDirectLightContribution(
+          lightData0, lightData1, lightData2, 
+          surface
+        );
+    }
+
+
+    // Calculate env probes
+    PBRLightingUtils_computeProbesContribution(surface);
+
+    // Put it all together
+    gl_FragColor.rgb = vec3(0.0);
+    gl_FragColor.rgb += surface.bakedLightContribution;
+    gl_FragColor.rgb += surface.directLightContribution;
+    gl_FragColor.rgb += surface.envLightContribution;
+    gl_FragColor.rgb += surface.emission;
+    gl_FragColor.a = surface.alpha;
+
+  
+    // outputs the final value of the selected layer as a color for debug purposes. 
+    #ifdef DEBUG_VALUES_MODE
+        if(m_DebugValuesMode == 0){
+            gl_FragColor.rgb = vec3(surface.albedo);
+        }
+        else if(m_DebugValuesMode == 1){
+            gl_FragColor.rgb = vec3(surface.normal);
+        }
+        else if(m_DebugValuesMode == 2){
+            gl_FragColor.rgb = vec3(surface.roughness);
+        }
+        else if(m_DebugValuesMode == 3){
+            gl_FragColor.rgb = vec3(surface.metallic);
+        }
+        else if(m_DebugValuesMode == 4){
+            gl_FragColor.rgb = surface.ao.rgb;
+        }
+        else if(m_DebugValuesMode == 5){
+            gl_FragColor.rgb = vec3(surface.emission.rgb);          
+        }        
+    #endif   
+}

jme3-core/src/main/resources/Common/MatDefs/Light/modular/PBRLighting.j3md

@@ -0,0 +1,321 @@
+MaterialDef PBR Lighting {
+
+    MaterialParameters {
+        Int BoundDrawBuffer
+
+        // Alpha threshold for fragment discarding
+        Float AlphaDiscardThreshold (AlphaTestFallOff)
+
+        //metallicity of the material
+        Float Metallic : 1.0
+        //Roughness of the material
+        Float Roughness : 1.0        
+        // Base material color
+        Color BaseColor : 1.0 1.0 1.0 1.0
+        // The emissive color of the object
+        Color Emissive        
+        // the emissive power
+        Float EmissivePower : 3.0        
+        // the emissive intensity
+        Float EmissiveIntensity : 2.0
+
+        // BaseColor map
+        Texture2D BaseColorMap
+
+        // Metallic map
+        Texture2D MetallicMap -LINEAR
+        
+        // Roughness Map
+        Texture2D RoughnessMap -LINEAR
+
+        //Metallic and Roughness are packed respectively in the b and g channel of a single map
+        // r: AO (if AoPackedInMRMap is true)
+        // g: Roughness
+        // b: Metallic
+        Texture2D MetallicRoughnessMap -LINEAR
+        
+        // Texture of the emissive parts of the material
+        Texture2D EmissiveMap
+
+        // Normal map
+        Texture2D NormalMap -LINEAR
+        // The scalar parameter applied to each normal vector of the normal map
+        Float NormalScale
+
+        //The type of normal map: -1.0 (DirectX), 1.0 (OpenGl)
+        Float NormalType : -1.0
+
+        // For Spec gloss pipeline
+        Boolean UseSpecGloss
+        Texture2D SpecularMap
+        Texture2D GlossinessMap
+        Texture2D SpecularGlossinessMap
+        Color Specular : 1.0 1.0 1.0 1.0
+        Float Glossiness : 1.0
+
+        // Parallax/height map
+        Texture2D ParallaxMap -LINEAR
+
+        // Specular-AA
+        Boolean UseSpecularAA : true
+        // screen space variance,Use the slider to set the strength of the geometric specular anti-aliasing effect between 0 and 1. Higher values produce a blurrier result with less aliasing.
+        Float SpecularAASigma
+        // clamping threshold,Use the slider to set a maximum value for the offset that HDRP subtracts from the smoothness value to reduce artifacts.
+        Float SpecularAAKappa
+
+        //Set to true if parallax map is stored in the alpha channel of the normal map
+        Boolean PackedNormalParallax   
+
+        //Sets the relief height for parallax mapping
+        Float ParallaxHeight : 0.05       
+
+        //Set to true to activate Steep Parallax mapping
+        Boolean SteepParallax
+
+        //Horizon fade
+        Boolean HorizonFade
+
+        // Set to Use Lightmap
+        Texture2D LightMap
+
+        // A scalar multiplier controlling the amount of occlusion applied.
+        // A value of `0.0` means no occlusion. A value of `1.0` means full occlusion.
+        Float AoStrength
+
+        // Set to use TexCoord2 for the lightmap sampling
+        Boolean SeparateTexCoord
+        // the light map is a grayscale ao map, only the r channel will be read.
+        Boolean LightMapAsAOMap
+        Boolean AoPackedInMRMap
+        //shadows
+        Int FilterMode
+        Boolean HardwareShadows
+
+        Texture2D ShadowMap0
+        Texture2D ShadowMap1
+        Texture2D ShadowMap2
+        Texture2D ShadowMap3
+        //pointLights
+        Texture2D ShadowMap4
+        Texture2D ShadowMap5
+        
+        Float ShadowIntensity
+        Vector4 Splits
+        Vector2 FadeInfo
+
+        Matrix4 LightViewProjectionMatrix0
+        Matrix4 LightViewProjectionMatrix1
+        Matrix4 LightViewProjectionMatrix2
+        Matrix4 LightViewProjectionMatrix3
+        //pointLight
+        Matrix4 LightViewProjectionMatrix4
+        Matrix4 LightViewProjectionMatrix5   
+        Vector3 LightPos
+        Vector3 LightDir
+
+        Float PCFEdge
+        Float ShadowMapSize
+
+        // For hardware skinning
+        Int NumberOfBones
+        Matrix4Array BoneMatrices
+
+        // For Morph animation
+        FloatArray MorphWeights
+        Int NumberOfMorphTargets
+        Int NumberOfTargetsBuffers
+                
+        // For instancing
+        Boolean UseInstancing
+
+        // For Vertex Color
+        Boolean UseVertexColor
+
+        Boolean BackfaceShadows : false
+
+        Boolean UseVertexColorsAsSunIntensity
+        Float StaticSunIntensity
+        Boolean BrightenIndoorShadows
+    
+        Int DebugValuesMode
+            // debugs the final value of the selected layer as a color output:         
+            // Layers:
+            //   0 - albedo (unshaded)
+            //   1 - normals
+            //   2 - roughness
+            //   3 - metallic
+            //   4 - ao
+            //   5 - emissive
+    }
+
+    Technique {
+        LightMode SinglePassAndImageBased
+        
+        VertexShader GLSL300 GLSL150 GLSL110:   Common/MatDefs/Light/modular/PBRLighting.vert
+        FragmentShader GLSL300 GLSL150 GLSL110: Common/MatDefs/Light/modular/PBRLighting.frag
+
+        WorldParameters {
+            WorldViewProjectionMatrix
+            CameraPosition
+            WorldMatrix
+            WorldNormalMatrix
+            ViewProjectionMatrix
+            ViewMatrix
+        }
+
+        Defines {  
+            BOUND_DRAW_BUFFER: BoundDrawBuffer       
+            BASECOLORMAP : BaseColorMap            
+            NORMALMAP : NormalMap
+            NORMALSCALE : NormalScale
+            METALLICMAP : MetallicMap
+            ROUGHNESSMAP : RoughnessMap
+            EMISSIVEMAP : EmissiveMap
+            EMISSIVE : Emissive
+            SPECGLOSSPIPELINE : UseSpecGloss
+            PARALLAXMAP : ParallaxMap
+            NORMALMAP_PARALLAX : PackedNormalParallax
+            STEEP_PARALLAX : SteepParallax
+            LIGHTMAP : LightMap
+            SEPARATE_TEXCOORD : SeparateTexCoord
+            DISCARD_ALPHA : AlphaDiscardThreshold                        
+            NUM_BONES : NumberOfBones                        
+            INSTANCING : UseInstancing
+            USE_PACKED_MR: MetallicRoughnessMap
+            USE_PACKED_SG: SpecularGlossinessMap
+            SPECULARMAP : SpecularMap
+            SPECULAR_AA : UseSpecularAA
+            SPECULAR_AA_SCREEN_SPACE_VARIANCE : SpecularAASigma
+            SPECULAR_AA_THRESHOLD : SpecularAAKappa
+            GLOSSINESSMAP : GlossinessMap
+            NORMAL_TYPE: NormalType
+            VERTEX_COLOR : UseVertexColor
+            AO_MAP: LightMapAsAOMap
+            AO_PACKED_IN_MR_MAP : AoPackedInMRMap
+            AO_STRENGTH : AoStrength
+            NUM_MORPH_TARGETS: NumberOfMorphTargets
+            NUM_TARGETS_BUFFERS: NumberOfTargetsBuffers
+            HORIZON_FADE: HorizonFade
+            USE_VERTEX_COLORS_AS_SUN_INTENSITY : UseVertexColorsAsSunIntensity
+            STATIC_SUN_INTENSITY : StaticSunIntensity
+            BRIGHTEN_INDOOR_SHADOWS : BrightenIndoorShadows
+            DEBUG_VALUES_MODE : DebugValuesMode
+        }
+    }
+
+
+    Technique PreShadow {
+
+        VertexShader   GLSL300 GLSL150 GLSL100:   Common/MatDefs/Shadow/PreShadow.vert
+        FragmentShader GLSL300 GLSL150 GLSL100: Common/MatDefs/Shadow/PreShadowPBR.frag
+
+        WorldParameters {
+            WorldViewProjectionMatrix
+            WorldViewMatrix
+            ViewProjectionMatrix
+            ViewMatrix
+        }
+
+        Defines {
+            BOUND_DRAW_BUFFER: BoundDrawBuffer
+            DISCARD_ALPHA : AlphaDiscardThreshold
+            NUM_BONES : NumberOfBones
+            INSTANCING : UseInstancing
+            NUM_MORPH_TARGETS: NumberOfMorphTargets
+            NUM_TARGETS_BUFFERS: NumberOfTargetsBuffers
+        }
+
+        ForcedRenderState {
+            FaceCull Off
+            DepthTest On
+            DepthWrite On
+            PolyOffset 5 3
+            ColorWrite Off
+        }
+
+    }
+
+
+    Technique PostShadow {
+        VertexShader   GLSL310 GLSL300 GLSL150 GLSL100:   Common/MatDefs/Shadow/PostShadow.vert
+        FragmentShader GLSL310 GLSL300 GLSL150 GLSL100: Common/MatDefs/Shadow/PostShadowPBR.frag
+
+        WorldParameters {
+            WorldViewProjectionMatrix
+            WorldMatrix
+            ViewProjectionMatrix
+            ViewMatrix
+        }
+
+        Defines {
+            BOUND_DRAW_BUFFER: BoundDrawBuffer
+            HARDWARE_SHADOWS : HardwareShadows
+            FILTER_MODE : FilterMode
+            PCFEDGE : PCFEdge
+            DISCARD_ALPHA : AlphaDiscardThreshold           
+            SHADOWMAP_SIZE : ShadowMapSize
+            FADE : FadeInfo
+            PSSM : Splits
+            POINTLIGHT : LightViewProjectionMatrix5
+            NUM_BONES : NumberOfBones
+            INSTANCING : UseInstancing
+            BACKFACE_SHADOWS: BackfaceShadows
+            NUM_MORPH_TARGETS: NumberOfMorphTargets
+            NUM_TARGETS_BUFFERS: NumberOfTargetsBuffers
+        }
+
+        ForcedRenderState {
+            Blend Modulate
+            DepthWrite Off                 
+            PolyOffset -0.1 0
+        }
+    }
+
+    Technique PreNormalPass {
+
+        VertexShader   GLSL300 GLSL150 GLSL100 :   Common/MatDefs/SSAO/normal.vert
+        FragmentShader GLSL300 GLSL150 GLSL100 : Common/MatDefs/SSAO/normal.frag
+
+        WorldParameters {
+            WorldViewProjectionMatrix
+            WorldViewMatrix
+            NormalMatrix
+            ViewProjectionMatrix
+            ViewMatrix
+        }
+
+        Defines {
+            BOUND_DRAW_BUFFER: BoundDrawBuffer
+            BASECOLORMAP_ALPHA : BaseColorMap            
+            NUM_BONES : NumberOfBones
+            INSTANCING : UseInstancing
+            NUM_MORPH_TARGETS: NumberOfMorphTargets
+            NUM_TARGETS_BUFFERS: NumberOfTargetsBuffers
+        }
+
+    }
+
+    Technique Glow {
+
+        VertexShader   GLSL300 GLSL150 GLSL100:   Common/MatDefs/Misc/Unshaded.vert
+        FragmentShader GLSL300 GLSL150 GLSL100: Common/MatDefs/Light/PBRGlow.frag
+
+        WorldParameters {
+            WorldViewProjectionMatrix
+            ViewProjectionMatrix
+            ViewMatrix
+        }
+
+        Defines {
+            HAS_EMISSIVEMAP : EmissiveMap
+            HAS_EMISSIVECOLOR : Emissive
+            BOUND_DRAW_BUFFER: BoundDrawBuffer
+            NEED_TEXCOORD1
+            NUM_BONES : NumberOfBones
+            INSTANCING : UseInstancing
+            NUM_MORPH_TARGETS: NumberOfMorphTargets
+            NUM_TARGETS_BUFFERS: NumberOfTargetsBuffers
+        }
+    }
+
+}

jme3-core/src/main/resources/Common/MatDefs/Light/modular/PBRLighting.vert

@@ -0,0 +1,75 @@
+#import "Common/ShaderLib/GLSLCompat.glsllib"
+#import "Common/ShaderLib/Instancing.glsllib"
+#import "Common/ShaderLib/Skinning.glsllib"
+#import "Common/ShaderLib/MorphAnim.glsllib"
+
+uniform vec4 m_BaseColor;
+uniform vec4 g_AmbientLightColor;
+varying vec2 texCoord;
+
+#ifdef SEPARATE_TEXCOORD
+  varying vec2 texCoord2;
+  attribute vec2 inTexCoord2;
+#endif
+
+varying vec4 Color;
+
+attribute vec3 inPosition;
+attribute vec2 inTexCoord;
+attribute vec3 inNormal;
+
+#if defined (VERTEX_COLOR) || defined(USE_VERTEX_COLORS_AS_SUN_INTENSITY)
+    attribute vec4 inColor;
+#endif
+
+#if defined(USE_VERTEX_COLORS_AS_SUN_INTENSITY)
+    varying vec4 vertColors;
+#endif
+
+varying vec3 wNormal;
+varying vec3 wPosition;
+
+attribute vec4 inTangent;
+varying vec4 wTangent;
+
+void main(){
+    vec4 modelSpacePos = vec4(inPosition, 1.0);
+    vec3 modelSpaceNorm = inNormal;
+    vec3 modelSpaceTan  = inTangent.xyz;
+
+    #ifdef USE_VERTEX_COLORS_AS_SUN_INTENSITY
+        vertColors = inColor;
+    #endif
+
+    #ifdef NUM_MORPH_TARGETS
+         #if defined(NORMALMAP) && !defined(VERTEX_LIGHTING)
+            Morph_Compute(modelSpacePos, modelSpaceNorm, modelSpaceTan);
+         #else
+            Morph_Compute(modelSpacePos, modelSpaceNorm);
+         #endif
+    #endif
+
+    #ifdef NUM_BONES
+         #if defined(NORMALMAP) && !defined(VERTEX_LIGHTING)
+            Skinning_Compute(modelSpacePos, modelSpaceNorm, modelSpaceTan);
+         #else
+            Skinning_Compute(modelSpacePos, modelSpaceNorm);
+         #endif
+    #endif
+
+    gl_Position = TransformWorldViewProjection(modelSpacePos);
+    texCoord = inTexCoord;
+    #ifdef SEPARATE_TEXCOORD
+       texCoord2 = inTexCoord2;
+    #endif
+
+    wPosition = TransformWorld(modelSpacePos).xyz;
+    wNormal  = TransformWorldNormal(modelSpaceNorm);
+    wTangent = vec4(TransformWorldNormal(modelSpaceTan),inTangent.w);
+
+    Color = m_BaseColor;
+    
+    #ifdef VERTEX_COLOR                    
+        Color *= inColor;
+    #endif
+}

jme3-core/src/main/resources/Common/ShaderLib/GLSLCompat.glsllib

@@ -2,6 +2,9 @@
   #ifdef FRAGMENT_SHADER
     precision highp float;
     precision highp int;
+    #if __VERSION__ >= 130
+      precision highp sampler2DArray;        
+    #endif
     precision highp sampler2DArray;
     precision highp sampler2DShadow;
     precision highp samplerCube;

jme3-core/src/main/resources/Common/ShaderLib/Math.glsllib

@@ -1,4 +1,17 @@
+#ifndef __MATH_GLSLLIB__
+#define __MATH_GLSLLIB__
+
 /// Multiplies the vector by the quaternion, then returns the resultant vector.
 vec3 Math_QuaternionMult(in vec4 quat, in vec3 vec){
 	return vec + 2.0 * cross(quat.xyz, cross(quat.xyz, vec) + quat.w * vec);
-}
+}
+
+void Math_lengthAndNormalize(in vec3 vec,out float outLength,out vec3 outNormal){
+    float dotv=dot(vec,vec);
+    float invl=inversesqrt(dotv);
+    outNormal=vec*invl;
+    outLength=invl*dotv;
+}
+
+
+#endif

jme3-core/src/main/resources/Common/ShaderLib/module/Light.glsl

@@ -0,0 +1,34 @@
+#ifndef __LIGHT_MODULE__
+#define __LIGHT_MODULE__
+
+/**
+* Defines a light
+*/
+
+
+#ifndef Light
+    #struct StdLight 
+        vec4 color;
+        vec3 position;
+        float type;
+
+        float invRadius;
+        float spotAngleCos;
+        vec3 spotDirection;
+
+        bool ready;
+        
+        float NdotL;                  // cos angle between normal and light direction
+        float NdotH;                  // cos angle between normal and half vector
+        float LdotH;                  // cos angle between light direction and half vector
+        float HdotV;                  // cos angle between view direction and half vector
+        vec3 vector;  
+        vec3 dir;
+        float fallOff;
+    #endstruct
+    #define Light StdLight
+#endif
+
+
+
+#endif

jme3-core/src/main/resources/Common/ShaderLib/module/PBRSurface.glsl

@@ -0,0 +1,39 @@
+#ifndef __SURFACE_MODULE__
+#define __SURFACE_MODULE__
+
+#ifndef PBRSurface
+    #struct StdPBRSurface
+        // from geometry
+        vec3 position; // position in w space
+        vec3 viewDir; // view dir in worldSpace
+        vec3 geometryNormal; // normals w/o normalmap
+        vec3 normal; // normals w/ normalmap
+        bool frontFacing; //gl_FrontFacing
+        float depth;
+
+        // from texture
+        vec3 albedo;
+        float alpha;
+        float metallic;              // metallic value at the surface
+        float roughness;
+        vec3 diffuseColor;
+        vec3 specularColor;
+        vec3 fZero;
+        vec3 ao;
+        float exposure;
+        vec3 emission;
+
+
+        // computed
+        float NdotV;
+
+        // from env
+        vec3 bakedLightContribution; // light from light map or other baked sources
+        vec3 directLightContribution; // light from direct light sources
+        vec3 envLightContribution; // light from environment 
+
+        float brightestLightStrength;
+    #endstruct
+    #define PBRSurface StdPBRSurface    
+#endif
+#endif

jme3-core/src/main/resources/Common/ShaderLib/module/pbrlighting/PBRLightingUtils.glsllib

@@ -0,0 +1,592 @@
+#ifndef __PBR_LIGHT_UTILS_MODULE__
+#define __PBR_LIGHT_UTILS_MODULE__
+
+#import "Common/ShaderLib/Math.glsllib"
+#import "Common/ShaderLib/PBR.glsllib"
+#import "Common/ShaderLib/Parallax.glsllib"
+
+#import "Common/ShaderLib/module/Light.glsl"
+#import "Common/ShaderLib/module/PBRSurface.glsl"
+
+// enable all apis
+// #define ENABLE_PBRLightingUtils_getWorldPosition 1
+// #define ENABLE_PBRLightingUtils_getWorldNormal 1
+// #define ENABLE_PBRLightingUtils_getWorldTangent 1
+// #define ENABLE_PBRLightingUtils_getTexCoord 1
+// #define ENABLE_PBRLightingUtils_newLight 1
+// #define ENABLE_PBRLightingUtils_computeLightInWorldSpace 1
+// #define ENABLE_PBRLightingUtils_readPBRSurface 1
+// #define ENABLE_PBRLightingUtils_computeDirectLight 1
+// #define ENABLE_PBRLightingUtils_computeDirectLightContribution 1
+// #define ENABLE_PBRLightingUtils_computeProbesContribution 1
+
+#if defined(ENABLE_PBRLightingUtils_readPBRSurface)||defined(ENABLE_PBRLightingUtils_getWorldPosition)
+    varying vec3 wPosition;
+#endif 
+
+#if defined(ENABLE_PBRLightingUtils_readPBRSurface)||defined(ENABLE_PBRLightingUtils_getWorldNormal)
+    varying vec3 wNormal;
+#endif 
+
+#if (defined(ENABLE_PBRLightingUtils_readPBRSurface)&&(defined(NORMALMAP)||defined(PARALLAXMAP)))||defined(ENABLE_PBRLightingUtils_getWorldTangent)
+    varying vec4 wTangent;
+#endif 
+
+#if defined(ENABLE_PBRLightingUtils_readPBRSurface)||defined(ENABLE_PBRLightingUtils_getTexCoord)
+    varying vec2 texCoord;
+    #ifdef SEPARATE_TEXCOORD
+        varying vec2 texCoord2;
+    #endif
+#endif
+
+
+
+#ifdef ENABLE_PBRLightingUtils_readPBRSurface   
+    varying vec4 Color;
+    
+    uniform vec4 g_AmbientLightColor;   
+    uniform float m_Roughness;
+    uniform float m_Metallic;
+
+
+    #ifdef BASECOLORMAP
+        uniform sampler2D m_BaseColorMap;
+    #endif
+
+    #ifdef USE_PACKED_MR
+        uniform sampler2D m_MetallicRoughnessMap;
+    #else
+        #ifdef METALLICMAP
+            uniform sampler2D m_MetallicMap;
+        #endif
+        #ifdef ROUGHNESSMAP
+            uniform sampler2D m_RoughnessMap;
+        #endif
+    #endif
+
+    #ifdef EMISSIVE
+        uniform vec4 m_Emissive;
+    #endif
+    #ifdef EMISSIVEMAP
+        uniform sampler2D m_EmissiveMap;
+    #endif
+    #if defined(EMISSIVE) || defined(EMISSIVEMAP)
+        uniform float m_EmissivePower;
+        uniform float m_EmissiveIntensity;
+    #endif 
+
+
+
+    #ifdef SPECGLOSSPIPELINE
+        uniform vec4 m_Specular;
+        uniform float m_Glossiness;
+        #ifdef USE_PACKED_SG
+            uniform sampler2D m_SpecularGlossinessMap;
+        #else
+            uniform sampler2D m_SpecularMap;
+            uniform sampler2D m_GlossinessMap;
+        #endif
+    #endif
+
+    #ifdef PARALLAXMAP
+        uniform sampler2D m_ParallaxMap;  
+    #endif
+    #if (defined(PARALLAXMAP) || (defined(NORMALMAP_PARALLAX) && defined(NORMALMAP)))
+        uniform float m_ParallaxHeight;
+    #endif
+
+    #ifdef LIGHTMAP
+        uniform sampler2D m_LightMap;
+    #endif
+
+    #ifdef AO_STRENGTH
+        uniform float m_AoStrength;
+    #endif
+    
+    #if defined(NORMALMAP) || defined(PARALLAXMAP)
+        uniform sampler2D m_NormalMap;       
+    #endif
+    #ifdef NORMALSCALE
+        uniform float m_NormalScale;
+    #endif
+
+    #ifdef DISCARD_ALPHA
+        uniform float m_AlphaDiscardThreshold;
+    #endif
+
+    #if defined(USE_VERTEX_COLORS_AS_SUN_INTENSITY)
+        varying vec4 vertColors;
+    #endif
+    #ifdef STATIC_SUN_INTENSITY
+        uniform float m_StaticSunIntensity;
+    #endif
+
+#endif
+
+#if defined(ENABLE_PBRLightingUtils_computeDirectLight) || defined(ENABLE_PBRLightingUtils_computeDirectLightContribution)
+    // Specular-AA
+    #ifdef SPECULAR_AA_SCREEN_SPACE_VARIANCE
+        uniform float m_SpecularAASigma;
+    #endif
+    #ifdef SPECULAR_AA_THRESHOLD
+        uniform float m_SpecularAAKappa;
+    #endif
+#endif
+
+
+
+
+#ifdef ENABLE_PBRLightingUtils_computeProbesContribution
+    #if NB_PROBES >= 1
+        uniform samplerCube g_PrefEnvMap;
+        uniform vec3 g_ShCoeffs[9];
+        uniform mat4 g_LightProbeData;
+    #endif
+    #if NB_PROBES >= 2
+        uniform samplerCube g_PrefEnvMap2;
+        uniform vec3 g_ShCoeffs2[9];
+        uniform mat4 g_LightProbeData2;
+    #endif
+    #if NB_PROBES == 3
+        uniform samplerCube g_PrefEnvMap3;
+        uniform vec3 g_ShCoeffs3[9];
+        uniform mat4 g_LightProbeData3;
+    #endif
+#endif
+
+#ifdef ENABLE_PBRLightingUtils_getWorldPosition
+    vec3 PBRLightingUtils_getWorldPosition(){
+        return wPosition.xyz;
+    }
+#endif
+
+#ifdef ENABLE_PBRLightingUtils_getWorldNormal
+    vec3 PBRLightingUtils_getWorldNormal(){
+        return normalize(wNormal.xyz);
+    }
+#endif
+
+#ifdef ENABLE_PBRLightingUtils_getWorldTangent
+    vec4 PBRLightingUtils_getWorldTangent(){
+        return wTangent;
+    }
+#endif
+
+#ifdef ENABLE_PBRLightingUtils_getTexCoord
+    vec2 PBRLightingUtils_getTexCoord(){
+        return texCoord;
+    }
+
+    #ifdef SEPARATE_TEXCOORD
+        vec2 PBRLightingUtils_getTexCoord2(){
+            return texCoord2;
+        }
+    #endif
+#endif
+
+
+
+#if defined(ENABLE_PBRLightingUtils_computeDirectLightContribution) || defined(ENABLE_PBRLightingUtils_newLight)
+    Light PBRLightingUtils_newLight(vec4 color, vec3 position, float type, float invRadius, float spotAngleCos, vec3 spotDirection){
+        Light l;
+        l.color = color;
+        l.position = position;
+        l.type = type;
+        l.invRadius = invRadius;
+        l.spotAngleCos = spotAngleCos;
+        l.spotDirection = spotDirection;
+        l.ready = false;
+        return l;
+    }
+#endif
+
+
+#if  defined(ENABLE_PBRLightingUtils_computeDirectLightContribution) || defined(ENABLE_PBRLightingUtils_computeLightInWorldSpace)
+    void PBRLightingUtils_computeLightInWorldSpace(vec3 worldPos,vec3 worldNormal, vec3 viewDir, inout Light light){
+        if(light.ready) return;
+
+        // lightComputeDir
+        float posLight = step(0.5, light.type);     
+        light.vector = light.position.xyz * sign(posLight - 0.5) - (worldPos * posLight); //tempVec lightVec
+
+        vec3 L; // lightDir
+        float dist;
+        Math_lengthAndNormalize(light.vector,dist,L);
+
+        float invRange=light.invRadius; // position.w
+        const float light_threshold=0.01;
+
+        #ifdef SRGB
+            light.fallOff = (1.0 - invRange * dist) / (1.0 + invRange * dist * dist); // lightDir.w
+            light.fallOff = clamp(light.fallOff, 1.0 - posLight, 1.0);
+        #else
+            light.fallOff = clamp(1.0 - invRange * dist * posLight, 0.0, 1.0);
+        #endif
+        
+        // computeSpotFalloff
+        if(light.type>1.){
+            vec3 spotdir = normalize(light.spotDirection);
+            float curAngleCos = dot(-L, spotdir);    
+            float innerAngleCos = floor(light.spotAngleCos) * 0.001;
+            float outerAngleCos = fract(light.spotAngleCos);
+            float innerMinusOuter = innerAngleCos - outerAngleCos;
+            float falloff = clamp((curAngleCos - outerAngleCos) / innerMinusOuter, 0.0, 1.0);
+            #ifdef SRGB
+                // Use quadratic falloff (notice the ^4)
+                falloff = pow(clamp((curAngleCos - outerAngleCos) / innerMinusOuter, 0.0, 1.0), 4.0);
+            #endif
+            light.fallOff*=falloff;
+        }
+
+
+        vec3 h=normalize(L+viewDir);
+        light.dir=L;
+        light.NdotL = max(dot(worldNormal, L), 0.0);
+        light.NdotH = max(dot(worldNormal, h), 0.0);
+        light.LdotH = max(dot(L, h), 0.0);
+        light.HdotV = max(dot(viewDir,h), 0.);
+    }
+#endif
+
+
+#ifdef ENABLE_PBRLightingUtils_readPBRSurface
+    PBRSurface PBRLightingUtils_readPBRSurface(    
+        in vec3 wViewDir
+    ){
+        
+        PBRSurface surface;
+        surface.position = wPosition;
+        surface.viewDir = wViewDir;
+        surface.geometryNormal = normalize(wNormal);
+
+        surface.bakedLightContribution = vec3(0);
+        surface.directLightContribution = vec3(0);
+        surface.envLightContribution = vec3(0);
+
+        #if defined(NORMALMAP) || defined(PARALLAXMAP)
+            vec3 tan = normalize(wTangent.xyz);
+            mat3 tbnMat = mat3(tan, wTangent.w * cross( surface.geometryNormal, tan), surface.geometryNormal);
+        #endif
+        
+        vec2 newTexCoord;
+        #if (defined(PARALLAXMAP) || (defined(NORMALMAP_PARALLAX) && defined(NORMALMAP)))
+            vec3 vViewDir =  wViewDir * tbnMat;  
+            #ifdef STEEP_PARALLAX
+                #ifdef NORMALMAP_PARALLAX
+                    //parallax map is stored in the alpha channel of the normal map         
+                    newTexCoord = steepParallaxOffset(m_NormalMap, vViewDir, texCoord, m_ParallaxHeight);
+                #else
+                    //parallax map is a texture
+                    newTexCoord = steepParallaxOffset(m_ParallaxMap, vViewDir, texCoord, m_ParallaxHeight);         
+                #endif
+            #else
+                #ifdef NORMALMAP_PARALLAX
+                    //parallax map is stored in the alpha channel of the normal map         
+                    newTexCoord = classicParallaxOffset(m_NormalMap, vViewDir, texCoord, m_ParallaxHeight);
+                #else
+                //parallax map is a texture
+                newTexCoord = classicParallaxOffset(m_ParallaxMap, vViewDir, texCoord, m_ParallaxHeight);
+            #endif
+        #endif
+        #else
+        newTexCoord = texCoord;    
+        #endif
+        
+        #ifdef BASECOLORMAP
+            vec4 baseColor = texture2D(m_BaseColorMap, newTexCoord) * Color;
+        #else
+            vec4 baseColor = Color;
+        #endif
+        
+        #ifdef DISCARD_ALPHA
+            if( baseColor.a < m_AlphaDiscardThreshold) discard;        
+        #endif
+
+        surface.albedo = baseColor.rgb;
+        surface.alpha = baseColor.a;
+
+        
+
+        //ao in r channel, roughness in green channel, metallic in blue channel!
+        vec3 aoRoughnessMetallicValue = vec3(1.0, 1.0, 0.0);
+        #ifdef USE_PACKED_MR
+            aoRoughnessMetallicValue = texture2D(m_MetallicRoughnessMap, newTexCoord).rgb;
+            surface.roughness = aoRoughnessMetallicValue.g * max(m_Roughness, 1e-4);
+            surface.metallic = aoRoughnessMetallicValue.b * max(m_Metallic, 0.0);
+        #else
+            #ifdef ROUGHNESSMAP
+                surface.roughness = texture2D(m_RoughnessMap, newTexCoord).r * max(m_Roughness, 1e-4);
+            #else
+                surface.roughness =  max(m_Roughness, 1e-4);
+            #endif
+            #ifdef METALLICMAP
+                surface.metallic = texture2D(m_MetallicMap, newTexCoord).r * max(m_Metallic, 0.0);
+            #else
+                surface.metallic =  max(m_Metallic, 0.0);
+            #endif
+        #endif
+    
+
+        
+        #if defined(NORMALMAP)
+            vec4 normalHeight = texture2D(m_NormalMap, newTexCoord);
+            // Note we invert directx style normal maps to opengl style
+            #ifdef NORMALSCALE
+                vec3 normal = normalize((normalHeight.xyz * vec3(2.0, NORMAL_TYPE * 2.0, 2.0) - vec3(1.0, NORMAL_TYPE * 1.0, 1.0)) * vec3(m_NormalScale, m_NormalScale, 1.0));
+            #else
+                vec3 normal = normalize((normalHeight.xyz * vec3(2.0, NORMAL_TYPE * 2.0, 2.0) - vec3(1.0, NORMAL_TYPE * 1.0, 1.0)));
+            #endif
+            surface.normal = normalize(tbnMat * normal);
+        #else 
+            surface.normal = normal;
+        #endif
+        
+        //spec gloss tex reads:
+        
+        #ifdef SPECGLOSSPIPELINE
+            #ifdef USE_PACKED_SG
+                vec4 specularColor = texture2D(m_SpecularGlossinessMap, newTexCoord);
+                float glossiness = specularColor.a * m_Glossiness;
+                specularColor *= m_Specular;
+            #else
+                #ifdef SPECULARMAP
+                    vec4 specularColor = texture2D(m_SpecularMap, newTexCoord);
+                #else
+                    vec4 specularColor = vec4(1.0);
+                #endif
+                #ifdef GLOSSINESSMAP
+                    float glossiness = texture2D(m_GlossinesMap, newTexCoord).r * m_Glossiness;
+                #else
+                    float glossiness = m_Glossiness;
+                #endif
+                specularColor *= m_Specular;
+            #endif
+            surface.diffuseColor = surface.albedo;// * (1.0 - max(max(specularColor.r, specularColor.g), specularColor.b));
+            surface.roughness = 1.0 - glossiness;
+            surface.fZero = specularColor.xyz;
+            surface.specularColor = specularColor;
+        #else
+            float specular = 0.5;
+            float nonMetalSpec = 0.08 * specular;
+            surface.specularColor = (nonMetalSpec - nonMetalSpec * surface.metallic) + surface.albedo * surface.metallic;
+            surface.diffuseColor = surface.albedo - surface.albedo * surface.metallic;
+            surface.fZero = vec3(specular);
+        #endif
+        
+
+        vec3 ao=vec3(1.0);
+        #ifdef LIGHTMAP
+            vec3 lightMapColor;
+            #ifdef SEPARATE_TEXCOORD
+                lightMapColor = texture2D(m_LightMap, texCoord2).rgb;
+            #else
+                lightMapColor = texture2D(m_LightMap, texCoord).rgb;
+            #endif               
+            #ifdef AO_MAP
+                lightMapColor.gb = lightMapColor.rr; 
+                ao = lightMapColor;
+            #else  
+                surface.bakedLightContribution +=  diffuseColor.rgb * lightMapColor;
+            #endif
+            surface.specularColor.rgb *= lightMapColor;
+        #endif
+        
+        #if defined(AO_PACKED_IN_MR_MAP) && defined(USE_PACKED_MR) 
+            ao = aoRoughnessMetallicValue.rrr; //note that this will override the AO value if it was previously read from a lightMap that is being used as AO_Map above. so don't try to use an AO map packed in metallic roughness while also using lightmap as ao map
+        #endif
+
+        #ifdef AO_STRENGTH
+            ao = 1.0 + m_AoStrength * (ao - 1.0);
+            // sanity check
+            ao = clamp(ao, 0.0, 1.0);
+        #endif
+        surface.ao=ao;
+        
+        #if defined(EMISSIVE) || defined (EMISSIVEMAP)
+            #ifdef EMISSIVEMAP
+                vec4 emissive = texture2D(m_EmissiveMap, newTexCoord);
+                #ifdef EMISSIVE
+                    emissive *= m_Emissive;
+                #endif
+            #else
+                vec4 emissive = m_Emissive;
+            #endif
+            surface.emission = emissive.rgb * pow(emissive.a, m_EmissivePower) * m_EmissiveIntensity;
+        #else 
+            surface.emission = vec3(0);
+        #endif
+        
+        #if defined(STATIC_SUN_INTENSITY)
+            surface.exposure = m_StaticSunIntensity; //single float value to indicate percentage of sunlight hitting the model (only suitable for small models or models with equal sunlight exposure accross the entire model
+        #elif defined(USE_VERTEX_COLORS_AS_SUN_INTENSITY)
+            surface.exposure = vertColors.r;    // use red channel of vertexColors for non-uniform sunlighting accross a single model
+        #else 
+            surface.exposure = 1.0; //default value
+        #endif 
+        
+        surface.frontFacing = gl_FrontFacing;
+        surface.depth = gl_FragCoord.z;
+
+
+        // surface.alphaRoughness = clamp(surface.roughness * surface.roughness, minRoughness, 1.0);
+        surface.NdotV = clamp(abs(dot(!surface.frontFacing?-surface.normal:surface.normal, surface.viewDir)), 0.001, 1.0);
+        // surface.reflectedVec = normalize(reflect(-surface.viewDir, surface.normal));
+
+        surface.brightestLightStrength=0.0;
+        return surface;
+    }
+#endif
+
+
+#if defined(ENABLE_PBRLightingUtils_computeDirectLight) || defined(ENABLE_PBRLightingUtils_computeDirectLightContribution)
+    void PBRLightingUtils_computeDirectLight(in Light light, in PBRSurface surface, inout vec3 directDiffuse, inout vec3 directSpecular, out float hdotv){
+
+        #ifdef SPECULAR_AA
+            #ifdef SPECULAR_AA_SCREEN_SPACE_VARIANCE
+                float sigma = m_SpecularAASigma;
+            #else 
+                float sigma = 1.0;
+            #endif
+            
+            #ifdef SPECULAR_AA_THRESHOLD
+                float kappa = m_SpecularAAKappa;
+            #else
+                float kappa = 0.18;
+            #endif    
+            
+            hdotv = PBR_ComputeDirectLightWithSpecularAA(
+                                    surface.normal,
+                                    light.dir.xyz, 
+                                    surface.viewDir,
+                                    light.color.rgb, 
+                                    surface.fZero, 
+                                    surface.roughness, 
+                                    sigma,
+                                    kappa, 
+                                    surface.NdotV,
+                                    directDiffuse,  
+                                    directSpecular
+                    );
+        #else
+            hdotv = PBR_ComputeDirectLight(
+                                    surface.normal, 
+                                    light.dir.xyz, 
+                                    surface.viewDir,
+                                    light.color.rgb, 
+                                    surface.fZero, 
+                                    surface.roughness, 
+                                    surface.NdotV,
+                                    directDiffuse,  
+                                    directSpecular
+                    );
+        #endif
+
+    }
+#endif
+
+ 
+#ifdef ENABLE_PBRLightingUtils_computeDirectLightContribution
+    void PBRLightingUtils_computeDirectLightContribution(
+        in vec4 lightData0, 
+        in vec4 lightData1, 
+        in vec4 lightData2,
+        inout PBRSurface surface
+    ){
+        vec4 lightColor = vec4(lightData0.rgb,1.0);
+        float lightType = lightData0.w;  
+
+        vec3 lightPosition = lightData1.xyz;
+        float lightInvRadius = lightData1.w;
+        
+        vec3 spotDirection = lightData2.xyz;
+        float spotAngleCos = lightData2.w;
+
+        Light light = PBRLightingUtils_newLight(lightColor, lightPosition, lightType, lightInvRadius, spotAngleCos, spotDirection);
+        PBRLightingUtils_computeLightInWorldSpace(surface.position, surface.normal, surface.viewDir, light);
+
+        vec3 directDiffuse;
+        vec3 directSpecular;
+        float hdotv;
+        PBRLightingUtils_computeDirectLight(light, surface, directDiffuse, directSpecular, hdotv); 
+
+        vec3 directLighting = surface.diffuseColor.rgb * directDiffuse + directSpecular;
+
+        #if defined(USE_VERTEX_COLORS_AS_SUN_INTENSITY) || defined(STATIC_SUN_INTENSITY)         
+            if(light.fallOff == 1.0){
+                directLighting.rgb *= surface.exposure;//  used to scale down how intense just the sun is indoors, and so the ambientLighting can be scaled back up indoors based on nearest pointlight intensity (ambient and direct light are 1.0 fallOff)                
+            } else{
+                surface.brightestLightStrength = max(light.fallOff, surface.brightestLightStrength);
+            }
+        #endif
+
+        surface.directLightContribution.rgb += directLighting * light.fallOff;
+    }
+#endif
+
+#ifdef ENABLE_PBRLightingUtils_computeProbesContribution
+    void PBRLightingUtils_computeProbesContribution(inout PBRSurface surface){   
+
+        #ifdef BRIGHTEN_INDOOR_SHADOWS
+            float minVertLighting = 0.0833; //enable this when using shadows, in order to brighten indoor areas (which are naturally covered from the DL shadows) so that indoor areas are not way too dark when using IndoorLighting with shadows compared to when shadows are off
+        #else
+            float minVertLighting = 0.0533;
+        #endif
+        
+        float finalLightingScale=1.0;
+        finalLightingScale = max(finalLightingScale, surface.brightestLightStrength);    
+        finalLightingScale = max(finalLightingScale, minVertLighting); //essentially just the vertColors.r (aka indoor light exposure) multiplied by the time of day scale.   
+
+
+        #if NB_PROBES > 0
+            float probeNdfSum=0;
+            float invProbeNdfSum=0;    
+            
+            #for i=1..4 ( #if NB_PROBES >= $i $0 #endif )
+                vec3 probeColor$i;
+                float probeNdf$i = renderProbe(
+                    surface.viewDir, 
+                    surface.position, 
+                    surface.normal,
+                    surface.geometryNormal,
+                    surface.roughness,
+                    vec4(surface.diffuseColor,1.0),
+                    vec4(surface.specularColor,1.0), 
+                    surface.NdotV, 
+                    surface.ao, 
+                    #if $i == 1
+                        g_LightProbeData, 
+                    #else  
+                        g_LightProbeData$i,
+                    #endif
+                    g_ShCoeffs,
+                    g_PrefEnvMap,
+                    probeColor$i
+                );
+                float probeInvNdf$i =  max(1.0 - probeNdf$i,0.0);
+                probeNdfSum += probeNdf$i;
+                invProbeNdfSum += probeInvNdf$i;
+                #ifdef USE_AMBIENT_LIGHT
+                    probeColor$i.rgb *= g_AmbientLightColor.rgb;
+                #endif
+                probeColor$i.rgb *= finalLightingScale;
+            #endfor
+
+            #if NB_PROBES > 1
+                float probeWeightSum=0;
+                #for i=1..4 ( #if NB_PROBES >= $i $0 #endif )
+                    float probeWeight$i = ((1.0 - (probeNdf$i / probeNdfSum)) / (NB_PROBES - 1)) *  ( probeInvNdf$i / invProbeNdfSum);
+                    probeWeightSum += probeWeight$i;    
+                #endfor 
+
+                #for i=1..4 ( #if NB_PROBES >= $i $0 #endif )       
+                    surface.envLightContribution.rgb += probeColor$i * clamp( probeWeight$i / probeWeightSum, 0., 1.);
+                #endfor 
+            #else
+                surface.envLightContribution.rgb += probeColor1;
+            #endif
+        #endif
+    }
+#endif
+
+
+#endif

jme3-core/src/test/java/com/jme3/shader/GLSLPreprocessorTest.java

@@ -75,4 +75,52 @@ public class GLSLPreprocessorTest {
         String sourceCheck=readAllAsString(testData.openStream());
         assertEquals(sourceCheck, processedSource);                  
     }
+
+    @Test
+    public void testStruct() throws Exception {
+            String source = "// nothing\n#struct MyStruct \n" + "  float x ;//nothing  \n" + "     float y;\n"
+                            + "#endstruct\n//nothing";
+            String processedSource = readAllAsString(
+                            Preprocessor.apply(new ByteArrayInputStream(source.getBytes("UTF-8"))));
+            System.out.println(processedSource);
+            AssetInfo testData = TestUtil.createAssetManager()
+                            .locateAsset(new AssetKey("GLSLPreprocessorTest.testStruct.validOutput"));
+            assertNotNull(testData);
+            String sourceCheck = readAllAsString(testData.openStream());
+            assertEquals(sourceCheck, processedSource);
+    }
+
+    @Test
+    public void testStructExtends() throws Exception {
+            String source = "// nothing\n#struct BaseStruct \n" + "  float x0;\n" + "  float y0;\n"
+                            + "#endstruct\n//nothing\n";
+            source += "//nothing\n#struct MyStruct extends BaseStruct \n" + "  float x;\n" + "  float y;\n"
+                            + "#endstruct\n//nothing\n";
+            String processedSource = readAllAsString(
+                            Preprocessor.apply(new ByteArrayInputStream(source.getBytes("UTF-8"))));
+            System.out.println(processedSource);
+            AssetInfo testData = TestUtil.createAssetManager()
+                            .locateAsset(new AssetKey("GLSLPreprocessorTest.testStructExtends.validOutput"));
+            assertNotNull(testData);
+            String sourceCheck = readAllAsString(testData.openStream());
+            assertEquals(sourceCheck, processedSource);
+    }
+
+    @Test
+    public void testStructExtendsMulti() throws Exception {
+            String source = "#struct BaseStruct \n" + "  float x0;\n" + "  float y0;\n" + "#endstruct\n";
+            source += "#struct BaseStruct2 \n" + "  float x1;\n" + "  float y1;\n"
+                            + "#endstruct\n//nothing\n";
+            source += "#struct MyStruct extends BaseStruct, BaseStruct2\n" + "  float x;\n" + "  float y;\n"
+                            + "#endstruct\n";
+            String processedSource = readAllAsString(
+                            Preprocessor.apply(new ByteArrayInputStream(source.getBytes("UTF-8"))));
+            System.out.println(processedSource);
+            AssetInfo testData = TestUtil.createAssetManager().locateAsset(
+                            new AssetKey("GLSLPreprocessorTest.testStructExtendsMulti.validOutput"));
+            assertNotNull(testData);
+            String sourceCheck = readAllAsString(testData.openStream());
+            assertEquals(sourceCheck, processedSource);
+    }
+
 }

jme3-core/src/test/resources/GLSLPreprocessorTest.testStruct.validOutput

@@ -0,0 +1,8 @@
+// nothing
+#define STRUCT_MyStruct \
+float x ; \
+float y;
+struct MyStruct { 
+STRUCT_MyStruct
+};
+//nothing

jme3-core/src/test/resources/GLSLPreprocessorTest.testStructExtends.validOutput

@@ -0,0 +1,17 @@
+// nothing
+#define STRUCT_BaseStruct \
+float x0; \
+float y0;
+struct BaseStruct { 
+STRUCT_BaseStruct
+};
+//nothing
+//nothing
+#define STRUCT_MyStruct \
+STRUCT_BaseStruct \
+float x; \
+float y;
+struct MyStruct { 
+STRUCT_MyStruct
+};
+//nothing

jme3-core/src/test/resources/GLSLPreprocessorTest.testStructExtendsMulti.validOutput

@@ -0,0 +1,21 @@
+#define STRUCT_BaseStruct \
+float x0; \
+float y0;
+struct BaseStruct { 
+STRUCT_BaseStruct
+};
+#define STRUCT_BaseStruct2 \
+float x1; \
+float y1;
+struct BaseStruct2 { 
+STRUCT_BaseStruct2
+};
+//nothing
+#define STRUCT_MyStruct \
+STRUCT_BaseStruct \
+STRUCT_BaseStruct2 \
+float x; \
+float y;
+struct MyStruct { 
+STRUCT_MyStruct
+};

jme3-core/src/tools/java/jme3tools/shader/Preprocessor.java

@@ -58,6 +58,7 @@ public class Preprocessor {
         String code = bos.toString("UTF-8");
 
         code = Preprocessor.forMacro(code);
+        code = Preprocessor.structMacro(code);
 
         return new ByteArrayInputStream(code.getBytes("UTF-8"));
     }
@@ -118,4 +119,96 @@ public class Preprocessor {
         return code;
     }
 
+    /**
+     * <code>
+     * #struct MyStruct extends BaseStruct, BaseStruct2
+     *  int i; 
+     *  int b; 
+     * #endstruct
+     * </code>
+     */
+    // match #struct MyStruct extends BaseStruct, BaseStruct2
+    // extends is optional
+    // private static final Pattern FOR_REGEX = Pattern
+    // .compile("([^=]+)=\\s*([0-9]+)\\s*\\.\\.\\s*([0-9]+)\\s*\\((.+)\\)");
+
+    private static final Pattern STRUCT_REGEX = Pattern
+            .compile("(\\w+)(?:\\s+extends\\s+(\\w+(?:,\\s*\\w+)*))?");
+
+    public static String structMacro(String code) {
+        StringBuilder expandedCode = new StringBuilder();
+        StringBuilder currentStruct = null;
+        String structDec = null;
+        int skip = 0;
+        String[] codeLines = code.split("\n");
+        boolean captured = false;
+        for (String line : codeLines) {
+            if (!captured) {
+                String trimmedLine = line.trim();
+                if (trimmedLine.startsWith("#struct")) {
+                    if (skip == 0) {
+                        structDec = trimmedLine;
+                        currentStruct = new StringBuilder();
+                        skip++;
+                        continue;
+                    }
+                    skip++;
+                } else if (trimmedLine.startsWith("#endstruct")) {
+                    skip--;
+                    if (skip == 0) {
+                        structDec = structDec.substring("#struct ".length()).trim();
+
+                        Matcher matcher = STRUCT_REGEX.matcher(structDec);
+                        if (matcher.matches()) {
+                            String structName = matcher.group(1);
+                            if (structName == null) structName = "";
+
+                            String extendsStructs = matcher.group(2);
+                            String extendedStructs[];
+                            if (extendsStructs != null) {
+                                extendedStructs = extendsStructs.split(",\\s*");
+                            } else {
+                                extendedStructs = new String[0];
+                            }
+                            String structBody = currentStruct.toString();
+                            if (structBody == null) structBody = "";
+                            else {
+                                // remove tail spaces
+                                structBody = structBody.replaceAll("\\s+$", "");
+                            }
+
+                            currentStruct = null;
+                            expandedCode.append("#define STRUCT_").append(structName).append(" \\\n");
+                            for (String extendedStruct : extendedStructs) {
+                                expandedCode.append("STRUCT_").append(extendedStruct).append(" \\\n");
+                            }
+                            String structBodyLines[] = structBody.split("\n");
+                            for (int i = 0; i < structBodyLines.length; i++) {
+                                String structBodyLine = structBodyLines[i];
+                                structBodyLine = structBodyLine.trim();
+                                if (structBodyLine == "") continue;
+                                // remove comments if any
+                                int commentIndex = structBodyLine.indexOf("//");
+                                if (commentIndex >= 0)
+                                    structBodyLine = structBodyLine.substring(0, commentIndex);
+                                expandedCode.append(structBodyLine);
+                                if (i < structBodyLines.length - 1) expandedCode.append(" \\");
+                                expandedCode.append("\n");
+                            }
+                            expandedCode.append("struct ").append(structName).append(" { \nSTRUCT_")
+                                    .append(structName).append("\n};\n");
+                            captured = true;
+                            continue;
+                        }
+                    }
+                }
+            }
+            if (currentStruct != null) currentStruct.append(line).append("\n");
+            else expandedCode.append(line).append("\n");
+        }
+        code = expandedCode.toString();
+        if (captured) code = structMacro(code);
+        return code;
+    }
+
 }

jme3-testdata/src/main/resources/Models/Tank/tank.j3m

@@ -1,4 +1,4 @@
-Material Tank : Common/MatDefs/Light/PBRLighting.j3md {
+Material Tank : Common/MatDefs/Light/modular/PBRLighting.j3md {
      MaterialParameters {
         
         MetallicRoughnessMap : Flip Models/Tank/Tank_Occ_Rough_Metal.png