source: GTP-Internal/trunk/App/Demos/Illum/Ocean/ocean.fx @ 1777

float4x4        viewProjMatrix;
float           time;
float3          eyePosition;
float3          eyePositionPushedBack;
float3          lightPosition;

float4x4        shipViewProjMatrix;
float4x4        shipWorldMatrix;

float3 worldCornerCar0;
float3 worldCornerCar1;
float3 worldCornerCar2;
float3 worldCornerCar3;

float4 diffuseColor;

textureCUBE environmentCubeTexture;
texture2D waterTexture;

samplerCUBE environmentCubeSampler = sampler_state
{
        texture = <environmentCubeTexture>;
        MipFilter = Linear;
        MagFilter = Linear;
        MinFilter = Linear;
         
};

sampler2D waterSampler = sampler_state
{
        texture = <waterTexture>;
        MipFilter = Linear;
        MagFilter = Linear;
        MinFilter = Linear;
        AddressU = WRAP;
        AddressV = WRAP;
}; 

//illumination calculation:
//float4 Illumination(float3 light, float3 normal, float3 view, float2 texcoord, float3 lightIntensity)
float4 Illumination(float3 light, float3 normal, float3 view, float4 diffuse, float3 lightIntensity)
{
        float3 hv = normalize(view + light);
        float costheta = dot(normal, light);
        
        if(costheta < 0)
                costheta = 0;
                
        float cosdelta = dot(hv, normal);
        if(cosdelta < 0 || costheta < 0)
                cosdelta = 0;
        
        //compute the diffuse color here using the textures... missing ATM
        float3 ks = float3(1,1,1);
        float shininess = 200;
        
        float3 color = (diffuse * costheta + ks * pow(cosdelta, shininess)) * lightIntensity;
        return float4(color,1);
        
};

float4x4 shipLocations[2];

#define WAVE_FX
#include "waves.h"
#undef WAVE_FX

struct vsOceanInput
{
        float4  pos             : POSITION;
};


struct vsOceanOutput
{
        float4 pos                      : POSITION;
        float3 normal           : NORMAL;
        float3 worldPos         : TEXCOORD0;
        float3 tangent          : TEXCOORD1;
        float3 binormal         : TEXCOORD2;
        
        float2 bumpCoord0       : TEXCOORD3;
        float2 bumpCoord1       : TEXCOORD4;
        float2 bumpCoord2       : TEXCOORD5;
        
        float  foam                     : TEXCOORD6;
};

vsOceanOutput vsOcean(vsOceanInput input)
{
        vsOceanOutput output = (vsOceanOutput)0;
        float3 inventedVariable = lerp(lerp(worldCornerCar0, worldCornerCar1, input.pos.x), lerp(worldCornerCar2, worldCornerCar3, input.pos.x), input.pos.z);
        if(inventedVariable.y * eyePositionPushedBack.y > 0) //looking above the horizon
        {
                input.pos.xyz = eyePositionPushedBack + inventedVariable * 1000000;
                input.pos.y = +1;
        }
        else
                input.pos.xyz = eyePositionPushedBack - (eyePositionPushedBack.y/inventedVariable.y) * inventedVariable;
                

        float t = fmod(time, 100.0);
        output.bumpCoord0.xy = input.pos.xz*0.006 + t*(0.02);
        output.bumpCoord1.xy = input.pos.xz*0.012 + t*(0.03);
        output.bumpCoord2.xy = input.pos.xz*0.024 + t*(0.04);

        float3 du = float3(1, 0, 0);
        float3 dv = float3(0, 0, 1);

        for (int i=0;i<NWAVES;i++)
        {
                float phase = (input.pos.x * wave[i].direction.x + input.pos.z * wave[i].direction.y) / wave[i].wavelength / 6.28 + time * sqrt(1.5915 * wave[i].wavelength);
                input.pos.xyz += evaluateWave(wave[i],phase);
                float3 da = evaluateWaveDerivative(wave[i], phase);
                du += da * wave[i].direction.x / wave[i].wavelength / 6.28;
                dv += da * wave[i].direction.y / wave[i].wavelength / 6.28;
                output.foam += da;
        }
        
        output.pos = mul(float4(input.pos.xyz, 1), viewProjMatrix);
        output.worldPos = input.pos.xyz;
        
        output.binormal = normalize(du) * 0.3;
        output.tangent  = normalize(dv) * 0.3;
        output.normal   = normalize(cross(dv,du));
        
        return output;
}

float4 psOcean(vsOceanOutput input) : COLOR0
{
//      return float4(input.eyeVector,1);

        half4 t0 = tex2D(waterSampler, input.bumpCoord0) * 2.0 -1.0;
        half4 t1 = tex2D(waterSampler, input.bumpCoord1) * 2.0 -1.0;
        half4 t2 = tex2D(waterSampler, input.bumpCoord2) * 2.0 -1.0;
        
        half3 N = (t0 + t1 + t2).xzy;
        
        half3x3 m;
        m[0] = input.tangent;
        m[2] = input.binormal;
        m[1] = input.normal;
        
        half3 normalWorld = mul(m, N);
        normalWorld = normalize(normalWorld);
        
//      normalWorld = input.normal; //test
        
//      return float4(normalWorld,0);
//      return float4(reflect(-normalize(input.eyeVector), normalWorld), 0);

        float3 viewDir = -normalize(eyePosition - input.worldPos);
        float3 reflDir = reflect(viewDir, normalWorld);
        // ray = worldPos + relfDir * t


        float4 reflectedColor = texCUBE(environmentCubeSampler, reflDir);
        for(int iShip=0; iShip<2; iShip++)
        {
                float3 rayOrigin = mul(shipLocations[iShip], float4(input.worldPos, 1));
                float3 rayDir = mul(shipLocations[iShip], float4(reflDir, 0));
                float3 delta = rayDir / float3(8.0, 10.0, 1.0);
                float3 alpha = rayOrigin / float3(8.0, 10.0, 1.0);
                float a = dot(delta, delta);
                float b = 2 * dot(delta, alpha);
                float c = dot(alpha, alpha) - 1;
                
                float discriminant = b*b - 4 * a * c;
                
                if(discriminant > 0)
                {
                        discriminant = sqrt(discriminant);
                        float t1 = (-b + discriminant) / 2 / a;
                        float t2 = (-b - discriminant) / 2 / a;
                        if(min(t1,t2) > 0)
                                reflectedColor = float4(1.0, 0.5, 0.0, 1.0);
                }
        }
                
        float facing = 1.0 - max(dot(-viewDir, normalWorld),0);
        
        float fresnel = .02 + .98 * pow(facing, 5);
        
        float4 shallowColor = float4 (0.34, 0.5, 0.33,0);
        float4 deepColor = float4(0.07, 0.19, 0.16,0);
        
        float4 waterColor = lerp (deepColor, shallowColor, facing);

        return reflectedColor * fresnel * 0.5 + waterColor * .75;// * (1 + max(0, -0.5 - input.foam / 6.0));
}

/***************************************************************************************************************************/
struct vsShipInput
{
        float4  pos                     : POSITION;
        float3  normal          : NORMAL0;
        float3  oceanTangent    : TEXCOORD0;
        float3  oceanBinormal   : TEXCOORD1;
        float3  shipPos : TEXCOORD2;
};

struct vsShipOutput
{
        float4 pos                      : POSITION;
        float3 normal           : NORMAL;
        float4 worldPos         : TEXCOORD1;
        float3 view                     : TEXCOORD2;
        float2 texcoords        : TEXCOORD3;            //reserved
};

vsShipOutput vsShip(vsShipInput input)
{
        vsShipOutput output = (vsShipOutput)0;

        output.worldPos = mul(input.pos, shipWorldMatrix);
        output.worldPos /= output.worldPos.w; //test the sphere ship

        float3 oceanNormal = normalize(cross(input.oceanTangent, input.oceanBinormal));
        
        output.worldPos.xyz = input.oceanTangent * output.worldPos.z + input.oceanBinormal * output.worldPos.x + oceanNormal * output.worldPos.y;
        
        output.worldPos += float4(input.shipPos, 0);
        output.view = eyePosition - output.worldPos;
        output.normal = mul(input.normal, shipWorldMatrix);
        output.pos = mul(output.worldPos, viewProjMatrix);

        return output;
};

float4 psShip(vsShipOutput input) : COLOR0
{
        float3 light = normalize(lightPosition);
        float3 normal = normalize(input.normal);
        float3 view = normalize(input.view);
        
        //Illumination: (light, normal, view, diffuse(or texture color), light intensity)
        return float4(1.0, 0.6, 0.3, 1.0);
        return Illumination(light, normal, view, float4(0.1,0.1,0.6,1), float3(3,3,3));
        
};

technique ocean
{
        pass P0
        {
                VertexShader = compile vs_3_0 vsOcean();
                PixelShader = compile ps_3_0 psOcean();
                 
        }       
};

technique ship
{
        pass P0
        {
                VertexShader = compile vs_3_0 vsShip();
                PixelShader = compile ps_3_0 psShip();
                 
        }       
};

#include "terrain.fx"