[[FX]]
<!--
// =================================================================================================
   Model Shader
   
   Supported Flags:
      _F01_Skinning
      _F02_NormalMapping
      _F03_ParallaxMapping
// =================================================================================================
-->

<Context id="ATTRIBPASS">
   <Shaders vertex="VS_GENERAL" fragment="FS_ATTRIBPASS" />
</Context>

<Context id="SHADOWMAP">
   <Shaders vertex="VS_SHADOWMAP" fragment="FS_SHADOWMAP" />
</Context>

<Context id="LIGHTING">
   <RenderConfig writeDepth="false" blendMode="ADD" />
   <Shaders vertex="VS_GENERAL" fragment="FS_LIGHTING" />
</Context>

<Context id="AMBIENT">
   <Shaders vertex="VS_GENERAL" fragment="FS_AMBIENT" />
</Context>
      

[[VS_GENERAL]]
// =================================================================================================

#ifdef _F03_ParallaxMapping
   #define _F02_NormalMapping
#endif

#include "utilityLib/vertCommon.glsl"

#ifdef _F01_Skinning
   #include "utilityLib/vertSkinning.glsl"
#endif

uniform vec3 viewer;
attribute vec2 texCoords0;
attribute vec3 normal;

#ifdef _F02_NormalMapping
   attribute vec3 tangent, bitangent;
#endif

varying vec4 pos, vsPos;
varying vec2 texCoords;

#ifdef _F02_NormalMapping
   varying mat3 tsbMat;
#else
   varying vec3 tsbNormal;
#endif
#ifdef _F03_ParallaxMapping
   varying vec3 eyeTS;
#endif


void main( void )
{
#ifdef _F01_Skinning
   mat4 skinningMat = calcSkinningMat();
   mat3 skinningMatVec = getSkinningMatVec( skinningMat );
#endif
   
   // Calculate normal
#ifdef _F01_Skinning
   vec3 _normal = calcWorldVec( skinVec( normal, skinningMatVec ) );
#else
   vec3 _normal = calcWorldVec( normal );
#endif

   // Calculate tangent and bitangent
#ifdef _F02_NormalMapping
   #ifdef _F01_Skinning
      vec3 _tangent = calcWorldVec( skinVec( tangent, skinningMatVec ) );
      vec3 _bitangent = calcWorldVec( skinVec( bitangent, skinningMatVec ) );
   #else
      vec3 _tangent = calcWorldVec( tangent );
      vec3 _bitangent = calcWorldVec( bitangent );
   #endif
   
   tsbMat = calcTanToWorldMat( _tangent, _bitangent, _normal );
#else
   tsbNormal = _normal;
#endif

   // Calculate world space position
#ifdef _F01_Skinning   
   pos = calcWorldPos( skinPos( gl_Vertex, skinningMat ) );
#else
   pos = calcWorldPos( gl_Vertex );
#endif

   vsPos = calcViewPos( pos );

   // Calculate tangent space eye vector
#ifdef _F03_ParallaxMapping
   eyeTS = calcTanVec( viewer - pos.xyz, _tangent, _bitangent, _normal );
#endif
   
   // Calculate texture coordinates and clip space position
   texCoords = texCoords0;
   gl_Position = gl_ModelViewProjectionMatrix * pos;
}


[[FS_ATTRIBPASS]]
// =================================================================================================

#ifdef _F03_ParallaxMapping
   #define _F02_NormalMapping
#endif

#include "utilityLib/fragDeferredWrite.glsl" />

uniform sampler2D tex0;

#ifdef _F02_NormalMapping
   uniform sampler2D tex1;
#endif

varying vec4 pos;
varying vec2 texCoords;

#ifdef _F02_NormalMapping
   varying mat3 tsbMat;
#else
   varying vec3 tsbNormal;
#endif
#ifdef _F03_ParallaxMapping
   varying vec3 eyeTS;
#endif

void main( void )
{
   vec3 newCoords = vec3( texCoords, 0 );
   
#ifdef _F03_ParallaxMapping   
   const float plxScale = 0.03;
   const float plxBias = -0.015;
   
   // Iterative parallax mapping
   vec3 eye = normalize( eyeTS );
   for( int i = 0; i < 4; ++i )
   {
      vec4 nmap = texture2D( tex1, newCoords.st );
      float height = nmap.a * plxScale + plxBias;
      newCoords += (height - newCoords.p) * nmap.z * eye;
   }
#endif

   vec3 albedo = texture2D( tex0, newCoords.st ).rgb;
   
#ifdef _F02_NormalMapping
   vec3 normalMap = texture2D( tex1, newCoords.st ).rgb * 2.0 - 1.0;
   vec3 normal = tsbMat * normalMap;
#else
   vec3 normal = tsbNormal;
#endif

   vec3 newPos = pos.xyz;

#ifdef _F03_ParallaxMapping
   newPos += vec3( 0.0, newCoords.p, 0.0 );
#endif
   
   setMatID( 1.0 );
   setPos( newPos );
   setNormal( normalize( normal ) );
   setAlbedo( albedo );
   setSpecMask( 0.1 );
}

-      std::string &depCode = _includes[i].first->assembleCode();
+      std::string depCode = _includes[i].first->assembleCode();

Shader Porting Notes

- Create a new file with the extension .shader
- Add a new section [[FX]] at the beginning

- For each context $CCC in your old shader
    - Create new code sections after the FX section for the vertex and fragment shaders, e.g.
     [[VS_$CCC]]
     [[FS_$CCC]]
    
     Please note that with the new system it is possible to share code sections between contexts, so if the vertex shader is the same for all contexts, it is enough to have a single code section for it. It is also not required that the shaders have VS or FS as prefix. This is just a suggestion.
    
   - Copy the old shader code into the new sections
      - The content of the <DefCode> blocks can just be copy&pasted
      - The <InsCode code="$CODE"> blocks simply become #include "$CODE"
   
   - Create a new XML Context element in the FX section:
      <Context id="CCC">
        <Shaders vertex="VS_CCC" fragment="FS_CCC" />
      </Context>
    
   - Copy the XML RenderConfig node of the old Context to the new Context

- Declare all of your custom uniforms in the FX section. You can give them default values if desired.

- Add sampler declarations for all used custom textures. You are no longer required to name the GLSL samplers tex0 to tex11 but can have an arbitrary name. Please take a look at the sample shaders, they show quite clearly how things are done now.

- Be aware of the fact that you can use #ifdefs now to write an übershader. This can help to merge many different shader files into a single one.

// Samplers
sampler albedoMap = sampler_state
{
   Address = Clamp;
   Filter = Bilinear;
};

// Uniforms
float4 myUniform <
   string UIDesc = "This is my uniform";
> = {0.5, 0.5, 0, 0};

// Contexts
context AMBIENT
{
   VertexShader = compile GLSL VS_GENERAL;
   PixelShader = compile GLSL FS_AMBIENT;
}