[MGFX] Shaders losing valid Semantics when porting about fna-mghistory HOT 8 CLOSED

#include "Includes/Lighting.fx"

float4x4 World;
float4x4 View;
float4x4 Projection;

bool IsWater;
float3 LightTransition;
float Time;

bool Emissive;
bool FogEnable;
bool Scrolling;

float3 ChunkPosition;
float TestOffset;

static float3 NormalLookup[6] = 
{
    float3(0,1,0),
    float3(0,-1,0),
    float3(1,0,0),
    float3(-1,0,0),
    float3(0,0,-1),
    float3(0,0,1)
};  

static float4 ShortOffset = float4(32767,32767,32767,32767);


struct VertexShaderInput
{
    float4 Position : POSITION0;    
    float4 EncodedData : TEXCOORD1;
    float4 EncodedUVs : TEXCOORD0;

};

struct VertexShaderOutput
{
    float4 Position : POSITION0;
    float Depth : TEXCOORD1;
    float2 TexCoords: TEXCOORD2;
    float2 ShadeUV : TEXCOORD3;
    float2 EmissCoord : TEXCOORD4;
    float3 WorldPosition : TEXCOORD5;
    float3 Light : TEXCOORD6;

};


Texture2D Texture;
sampler TextureSampler = sampler_state { texture = <Texture>; AddressU = clamp; AddressV = clamp;  magfilter = POINT; minfilter = POINT; mipfilter= POINT;};

Texture2D EmissiveTexture;
sampler EmissiveSampler = sampler_state { texture = <EmissiveTexture>; magfilter = LINEAR; minfilter = LINEAR; mipfilter= LINEAR; AddressU = wrap; AddressV = wrap;};


Texture2D ShadeTexture;
sampler ShadeSampler = sampler_state { texture = <ShadeTexture>; magfilter = LINEAR; minfilter = LINEAR; mipfilter= LINEAR; AddressU = WRAP; AddressV = WRAP;};


VertexShaderOutput VertexShaderFunction(VertexShaderInput input)
{
    VertexShaderOutput output;

        float wave = float4(sin(input.Position.x + Time * 4.0f), sin(input.Position.y + Time * 4.0f), sin(input.Position.x + Time * 4.0f), 0) * 0.0005;

    input.Position = lerp(input.Position, input.Position + wave, input.EncodedData.w);


    float4 worldPosition = mul(input.Position, World);



    float4 viewPosition = mul(worldPosition, View);



    output.Position = mul(viewPosition, Projection);

    float4 uvs = input.EncodedUVs;



    output.TexCoords = float2(uvs.x, uvs.y);
    output.Depth = output.Position.z;
    output.ShadeUV = float2(input.EncodedData.y, input.EncodedData.z);
    output.WorldPosition = worldPosition;
    output.EmissCoord = float2(uvs.z, uvs.w);
    output.Light = VSCalculateLighting(worldPosition) * (0.6 + (CalculateLightingFactor(NormalLookup[input.EncodedData.x], World) * 0.4));

    return output;
}

float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0
{
        // Get Diffuse
    float4 color = tex2D(TextureSampler, input.TexCoords);  
    clip(color.a - 0.5);

    input.Light *= DayLighting();

    float ao = tex2D(ShadeSampler, input.ShadeUV);

    // Faked AO

    // Add lighting to texture and multiply it by emissive texture 



    color.rgb *= lerp(saturate(input.Light) * ao, float3(1,1,1),(tex2D(TextureSampler, input.EmissCoord).r));

    // Fog
    color = CalculateFogging(input.Depth, color);

    return color;
}

technique Technique1
{
    pass Pass1
    {
        // TODO: set renderstates here.

        VertexShader = compile vs_3_0 VertexShaderFunction();
        PixelShader = compile ps_3_0 PixelShaderFunction();
    }
}


////////////////////////////// DEPTH MAP //////////////////////////////
/*
struct DepthVertexShaderOutput
{
    float4 Position : POSITION0;
    float2 TexCoord : TEXCOORD0;
    float Depth : TEXCOORD1;
    // TODO: add vertex shader outputs such as colors and texture
    // coordinates here. These values will automatically be interpolated
    // over the triangle, and provided as input to your pixel shader.
};



DepthVertexShaderOutput DepthVertexShaderFunction(VertexShaderInput input)
{
    DepthVertexShaderOutput output;

    float4 worldPosition = mul(input.Position, World);
    float4 viewPosition = mul(worldPosition, View);
    output.Position = mul(viewPosition, Projection);
    output.Depth =  1-(output.Position.z/output.Position.w);    
    output.TexCoord = float2(input.EncodedData.y, input.EncodedData.z) / 255.0;

    return output;
}

float4 DepthPixelShaderFunction(DepthVertexShaderOutput input) : COLOR0
{

    float alpha = tex2D(TextureSampler, input.TexCoord).a;

    return float4(input.Depth, input.Depth, input.Depth, alpha);
}

technique Depthmap
{
    pass Pass1
    {
                VertexShader = compile vs_2_0 DepthVertexShaderFunction();
        PixelShader = compile ps_2_0 DepthPixelShaderFunction();

    }
}*/