OpenVIII-monogame/OpenGL/Content/testShader.fx

// ==OPENGL

float4x4 World;
float4x4 View;
float4x4 Projection;
float3 camWorld;
texture ModelTexture;

float bendValue = 1.4;
float3 bendOrigin = { 0, 0, 0 };
float bendDistance = 350.0;
float3 bendVector = { 0, -0.01, 0 };

float3 skyColor = { 1.0, 1.0, 1.0 };



    //pre-set;
float Transparency = 1;
float4 fogColor =
{
    0.39215,
    0.58431,
    0.92941,
    0
};
  
sampler2D textureSampler = sampler_state
{
    Texture = (ModelTexture);
    MinFilter = Point; //Controls sampling. None, Linear, or Point.
    MagFilter = Point; //Controls sampling. None, Linear, or Point.
    MipFilter = Point; //Controls how the mips are generated. None, Linear, or Point.
    AddressU = Wrap;
    AddressV = Wrap;
};

struct VertexShaderInput
{
    float4 Position : SV_POSITION;
    float4 TexCoord : TEXCOORD0;
};

struct VertexShaderOutput
{
    float4 Position : SV_POSITION;
    float2 TextureCoordinate : TEXCOORD0;
    float4 vertPos : TEXCOORD1;
};

VertexShaderOutput VertexShaderFunction(VertexShaderInput input)
{
    VertexShaderOutput output;
    float4 worldPosition = mul(input.Position, World);

    //curve test
    float4 world = worldPosition;
    float3 bendOrigin = camWorld;
    float dist = length(world.xyz - bendOrigin);
    float newDist = dist - bendDistance;
    dist = max(0.0, newDist);
    dist = pow(dist, bendValue);
    world.xyz += dist * bendVector;


    output.vertPos = worldPosition; //that will be our position in world- however we need to get the camera position too
    worldPosition = world;
    float4 viewPosition = mul(worldPosition, View);
    float4 projectionPosition = mul(viewPosition, Projection);
    output.Position = projectionPosition;
    output.TextureCoordinate = input.TexCoord;
    return output;
}

float4 ApplyFog(float4 textureColor, float3 vertPosition, float3 camPosition)
{
    float4 fogDist = distance(vertPosition, camPosition);
    fogDist -= 250;
    fogDist /= 1800.0; //you can change that 800f to find best value
    fogDist = clamp(fogDist, 0, 0.4); //this prevents inversion of colours when at high distance;
    textureColor.xyz = lerp(textureColor.xyz, fogColor.xyz, fogDist.xyz); //we lerp the texture color to fogColor (changeable) with fogDistancw
    return textureColor;
}

void ApplyAlphaMasking(float4 textureColor)
{
    clip(textureColor.a - 0.01); //0.01 - I'm not really sure how does it work, why 0.01 magically makes it work perfectly ;-;
}

float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0
{
    float4 textureColor = tex2D(textureSampler, input.TextureCoordinate);
    float3 vertPosition = input.vertPos;
    float3 camPosition = camWorld;
    //textureColor = ApplyFog(textureColor, vertPosition, camPosition);
    ApplyAlphaMasking(textureColor);
    float4 skyColorExtension = { skyColor.rgb, Transparency };
    textureColor *= skyColorExtension;
    return textureColor;
}

float4 PixelShaderFunction_Water(VertexShaderOutput input) : COLOR0
{
    float4 textureColor = tex2D(textureSampler, input.TextureCoordinate);
    float3 vertPosition = input.vertPos;
    float3 camPosition = camWorld;
    textureColor = ApplyFog(textureColor, vertPosition, camPosition);
    ApplyAlphaMasking(textureColor);

    float4 skyColorExtension = { skyColor.rgb, Transparency };
    textureColor *= skyColorExtension;
    return textureColor;
}



technique Texture_fog_bend
{
    pass Pass1
    {
        AlphaBlendEnable = TRUE;
        SrcBlend = SRCALPHA;
        DestBlend = INVSRCALPHA;
        VertexShader = compile vs_2_0 VertexShaderFunction();
        PixelShader = compile ps_2_0 PixelShaderFunction();
    }
}

technique Texture_fog_bend_waterAnim
{
    pass Pass1
    {
        AlphaBlendEnable = TRUE;
        SrcBlend = SRCALPHA;
        DestBlend = INVSRCALPHA;
        VertexShader = compile vs_2_0 VertexShaderFunction();
        PixelShader = compile ps_2_0 PixelShaderFunction_Water();
    }
}