var waterLevel : float = 0.0;
var floatHeight : float = 1.0;
var bounceDamp : float = 0.05;
var raycastHeightOffset : float = 10;

var bPoints : Transform[];

function Start () {

if (bPoints[0] == null) {
bPoints[0].transform.position = transform.position;
}

}

function FixedUpdate () {

for (var i = 0; i < bPoints.length; i++) {

var actionPoint = bPoints[i].transform.position;

var rayOrigin : Vector3 = actionPoint + Vector3(0, raycastHeightOffset, 0);
var hit : RaycastHit;
var layerMask = 1 << 4;

if (Physics.Raycast(rayOrigin, -Vector3.up, hit, Mathf.Infinity, layerMask)) {
waterLevel = hit.point.y;
}

var forceFactor = ((1f - ((actionPoint.y - waterLevel) / floatHeight)) / bPoints.length);

if (forceFactor > 0f) {
var uplift = -Physics.gravity * (forceFactor - rigidbody.velocity.y * ((bounceDamp / bPoints.length) * Time.deltaTime));
rigidbody.AddForceAtPosition(uplift, actionPoint);
}
}
}

var scale = 0.28;
var speed = 2.0;
private var baseHeight : Vector3[];
var useOriginal : boolean = false;

function Update () {
var mesh : Mesh = GetComponent(MeshFilter).mesh;

if (baseHeight == null)
baseHeight = mesh.vertices;

// gameObject.Destroy(GetComponent(MeshCollider));

var vertices = new Vector3[baseHeight.Length];
for (var i=0;i<vertices.Length;i++)
{
var vertex = baseHeight[i];

if (useOriginal) {
vertex.y += Mathf.Sin(Time.time * speed+ baseHeight[i].x + baseHeight[i].y + baseHeight[i].z) * scale;
} else {
vertex.y += Mathf.Sin(Time.time * speed+ baseHeight[i].x + baseHeight[i].y) * (scale*.5) + Mathf.Sin(Time.time * speed+ baseHeight[i].z + baseHeight[i].y) * (scale*.5);
}

vertices[i] = vertex;
}
mesh.vertices = vertices;
mesh.RecalculateNormals();

gameObject.Destroy(GetComponent(MeshCollider));

var collider : MeshCollider = GetComponent(MeshCollider);
if (collider == null) {
collider = gameObject.AddComponent(MeshCollider);
collider.isTrigger = true;
}

}

Shader "Main/Water(Occ)" {
Properties {
_MainAlpha ("Tansparency", Range(0.0,1.0)) = 0.5
_WaveScale ("Wave scale", Range (0.02,0.15)) = .07
_ColorControl ("Reflective color (RGB) fresnel (A) ", 2D) = "" { }
_ColorControlCube ("Reflective color cube (RGB) fresnel (A) ", Cube) = "" { TexGen CubeReflect }
_BumpMap ("Waves Normalmap ", 2D) = "" { }
WaveSpeed ("Wave speed (map1 x,y; map2 x,y)", Vector) = (19,9,-16,-7)
_MainTex ("Fallback texture", 2D) = "" { }

_Specular ("Specular", Range (0,1)) = .07
_Gloss ("Gloss", Range (0,128)) = 1
}

// -----------------------------------------------------------
// Fragment program

Subshader {
Tags {"Queue"="Transparent" "RenderType"="Transparent"}

CGPROGRAM
#pragma surface surf SimpleSpecular alpha vertex:vert
//uniform float4 _horizonColor;

uniform float _MainAlpha;
uniform float4 WaveSpeed;
uniform float _WaveScale;
uniform float4 _WaveOffset;

uniform float _Specular;
uniform float _Gloss;

sampler2D _BumpMap;
sampler2D _ColorControl;
samplerCUBE _ColorControlCube;

#include "UnityCG.cginc"

struct Input {

half2 bumpuv0 : TEXCOORD0;
half2 bumpuv1 : TEXCOORD1;
half3 vDir : TEXCOORD2;
half3 worldRefl;
INTERNAL_DATA
};

void vert (inout appdata_full v, out Input o) {
float4 s;

// scroll bump waves
float4 temp;
temp.xyzw = v.vertex.xzxz * _WaveScale / unity_Scale.w + _WaveOffset;
o.bumpuv0 = temp.xy * float2(.4, .45);
o.bumpuv1 = temp.wz;

// object space view direction
o.vDir = normalize( ObjSpaceViewDir(v.vertex) ).xzy;
}

void surf (Input IN, inout SurfaceOutput o) {

half3 bump1 = UnpackNormal(tex2D( _BumpMap, IN.bumpuv0 )).rgb;
half3 bump2 = UnpackNormal(tex2D( _BumpMap, IN.bumpuv1 )).rgb;
half3 bump = (bump1 + bump2) * 0.5;
o.Normal = bump;

half3 worldRefl = WorldReflectionVector (IN, o.Normal);
half fresnel = dot( IN.vDir, bump);
half4 water = tex2D( _ColorControl, float2(fresnel,fresnel) );
half3 R = IN.vDir - ( 2 * dot(IN.vDir, o.Normal )) * o.Normal;
half4 reflcol = texCUBE (_ColorControlCube, R);

half4 col;

col.rgb = water.rgb;
//make 0.5 into a slider eventually
col.rgb = lerp( reflcol.rgb, col.rgb, 0.5 );

col.a = _MainAlpha;

o.Albedo = 0.0;

o.Alpha = col.a;
o.Emission = col;
}

half4 LightingSimpleSpecular (SurfaceOutput s, half3 lightDir, half3 viewDir, half atten)
{
half3 h = normalize (lightDir + viewDir);

half diff = max (0, dot (s.Normal, lightDir));

float nh = max (0, dot (s.Normal, h));
float spec = pow (nh, _Gloss);

half4 c;
c.rgb = (s.Albedo * _LightColor0.rgb * diff + _LightColor0.rgb * spec) * (atten * 2) * _Specular;
//I have alpha set to 1 for debugging. Really it doesn't seem to matter what I put here
c.a = 1;
return c;
}
ENDCG
}

// -----------------------------------------------------------
// Old cards (you can ignore anything below here)

// three texture, cubemaps
Subshader {
//Tags { "RenderType"="Opaque" }
Tags {"Queue"="Transparent" "RenderType"="Transparent"}
Pass {
Color (0.5,0.5,0.5,0.5)
SetTexture [_MainTex] {
Matrix [_WaveMatrix]
combine texture * primary
}
SetTexture [_MainTex] {
Matrix [_WaveMatrix2]
combine texture * primary + previous
}
SetTexture [_ColorControlCube] {
combine texture +- previous, primary
Matrix [_Reflection]
}
}
}

// dual texture, cubemaps
Subshader {
//Tags { "RenderType"="Opaque" }
Tags {"Queue"="Transparent" "RenderType"="Transparent"}
Pass {
Color (0.5,0.5,0.5,0.5)
SetTexture [_MainTex] {
Matrix [_WaveMatrix]
combine texture
}
SetTexture [_ColorControlCube] {
combine texture +- previous, primary
Matrix [_Reflection]
}
}
}

// single texture
Subshader {
//Tags { "RenderType"="Opaque" }
Tags {"Queue"="Transparent" "RenderType"="Transparent"}
Pass {
Color (0.5,0.5,0.5,0)
SetTexture [_MainTex] {
Matrix [_WaveMatrix]
combine texture, primary
}
}
}

}

Shader "Main/DR Water Simple" {              
Properties {
              _WaveScale ("Wave scale", Range (0.001,0.15)) = 0.063
              _ReflDistort ("Reflection distort", Range (0,1.5)) = 0.44
              _RefrDistort ("Refraction distort", Range (0,1.5)) = 0.40
              _RefrColor ("Refraction color", COLOR)  = ( .34, .85, .92, 1)
              _Fresnel ("Fresnel (A) ", 2D) = "" {}
              _BumpMap ("Bumpmap (RGB) ", 2D) = "" {}
              WaveSpeed ("Wave speed (map1 x,y; map2 x,y)", Vector) = (19,9,-16,-7)
              _ReflectiveColor ("Reflective color (RGB) fresnel (A) ", 2D) = "" {}
              _ReflectiveColorCube ("Reflective color cube (RGB) fresnel (A)", Cube) = "" { TexGen CubeReflect }
              _HorizonColor ("Simple water horizon color", COLOR)  = ( .172, .463, .435, 1)
              _MainTex ("Fallback texture", 2D) = "" {}
              _ReflectionTex ("Internal Reflection", 2D) = "" {}
              _RefractionTex ("Internal Refraction", 2D) = "" {}
}

// -----------------------------------------------------------
// Fragment program cards

Subshader {
              Tags {
               "WaterMode" = "Reflective"
               "Queue" = "Transparent" // foam uses -110 / original: Transparent-120
              }
              Pass {
               ZWrite Off
               ColorMask RGB
               Blend SrcAlpha OneMinusSrcAlpha
               // Blend SrcAlpha OneMinusDstAlpha
                            
CGPROGRAM
// Upgrade NOTE: excluded shader from OpenGL ES 2.0 because it uses non-square matrices
#pragma exclude_renderers gles
// Upgrade NOTE: excluded shader from Xbox360; has structs without semantics (struct v2f members ref,bumpuv,viewDirZ)
#pragma exclude_renderers xbox360
#pragma vertex vert
#pragma fragment frag
#pragma fragmentoption ARB_precision_hint_fastest              
#pragma fragmentoption ARB_fog_exp2
#pragma multi_compile WATER_REFLECTIVE WATER_SIMPLE

#if defined (WATER_REFLECTIVE)
#define HAS_REFLECTION 1
#endif

#include "UnityCG.cginc"

uniform float4 WaveSpeed;
uniform float _WaveScale;

#ifdef HAS_REFLECTION
uniform float _ReflDistort;
#endif

struct appdata {
              float4 vertex : POSITION;
              float3 normal : NORMAL;
};

struct v2f {
              float4 pos : SV_POSITION;
              #if defined (HAS_REFLECTION)
              float3 ref;
              #endif
              float2 bumpuv[2];
              float4 viewDirZ;
};              

v2f vert(appdata v)
{
              v2f o;
              o.pos = mul (UNITY_MATRIX_MVP, v.vertex);
                           
              // scroll bump waves
              float4 temp;
              temp.xyzw = (v.vertex.xzxz + _Time.x * WaveSpeed.xyzw) * _WaveScale;
              o.bumpuv[0] = temp.xy * float2(.4, .45);
              o.bumpuv[1] = temp.wz;
                           
              // object space view direction (will normalize per pixel)
              o.viewDirZ.xzy = ObjSpaceViewDir(v.vertex);
                           
              #if defined (HAS_REFLECTION)
              // calculate the reflection vector
              float3x4 mat = float3x4 (
               0.5, 0, 0, 0.5,
               0, 0.5 * _ProjectionParams.x, 0, 0.5,
               0, 0, 0, 1
              );              
              o.ref = mul (mat, o.pos);
              // increase distortion in distance a bit to make
              // the perspective decrease of distortion less pronounced
              o.viewDirZ.w = 1.0 + o.ref.z * 0.15;
              #else
              o.viewDirZ.w = 0.0;
              #endif
                           
              return o;
}

#if defined (WATER_REFLECTIVE)
sampler2D _Fresnel;
sampler2D _ReflectionTex;
#endif
#if defined (WATER_SIMPLE)
sampler2D _ReflectiveColor;
uniform float4 _HorizonColor;
#endif
sampler2D _BumpMap;

half4 frag( v2f i ) : COLOR
{
              i.viewDirZ.xyz = normalize(i.viewDirZ.xyz);
                           
              // combine two scrolling bumpmaps into one
              half3 bump1 = tex2D( _BumpMap, i.bumpuv[0] ).rgb;
              half3 bump2 = tex2D( _BumpMap, i.bumpuv[1] ).rgb;
              half3 bump = bump1 + bump2 - 1;
                           
              // fresnel factor
              half fresnelFac = dot( i.viewDirZ.xyz, bump );
                           
              // perturb reflection UVs by bumpmap, and lookup colors
                           
              #ifdef HAS_REFLECTION
              bump.xy *= i.viewDirZ.w;
              float3 uv1 = i.ref; uv1.xy += bump * _ReflDistort;
              half4 refl = tex2Dproj( _ReflectionTex, uv1 );
              half fresnel = tex2D( _Fresnel, float2(fresnelFac,fresnelFac) ).a;
              // Cg 1.5 has a bug when compiling for ps_2_0 where it does not respect
              // destination masks properly. So final color ends up being just fresnel,
              // resulting in black water on D3D. To workaround, we add just a tiny bit
              // of original alpha...
              refl.a = fresnel + refl.a * 0.01;
              return refl;
              #endif
                           
              #ifdef WATER_SIMPLE
              half4 color;
              half4 water = tex2D( _ReflectiveColor, float2(fresnelFac,fresnelFac) );
              color.rgb = lerp( water.rgb, _HorizonColor.rgb, water.a);
              color.a = water.a * _HorizonColor.a * 2;
              return color;
              #endif              
}
ENDCG

              }
}

// -----------------------------------------------------------
// Radeon 9000 cards

#warning Upgrade NOTE: SubShader commented out because of manual shader assembly
/*Subshader {
              Tags {
               "WaterMode" = "Reflective"
               "Queue" = "Transparent" // foam uses -110
              }
              Pass {
               ZWrite Off
               ColorMask RGB
               Blend SrcAlpha OneMinusSrcAlpha
                           
CGPROGRAM
// Upgrade NOTE: excluded shader from OpenGL ES 2.0 because it does not contain a surface program or both vertex and fragment programs.
#pragma exclude_renderers gles
#pragma vertex vert

#include "UnityCG.cginc"

uniform float4 WaveSpeed;
uniform float _WaveScale;
uniform float _ReflDistort;

struct appdata {
              float4 vertex : POSITION;
              float3 normal : NORMAL;
};

struct v2f {
              float4 pos : SV_POSITION;
              float2 bumpuv[2] : TEXCOORD0;
              float3 viewDir : TEXCOORD2;
              float4 ref : TEXCOORD3;
};              

v2f vert(appdata v)
{
              v2f o;
              o.pos = mul (UNITY_MATRIX_MVP, v.vertex);
                           
              // scroll bump waves
              float4 temp;
              temp.xyzw = (v.vertex.xzxz + _Time.x * WaveSpeed.xyzw) * _WaveScale;
              o.bumpuv[0] = temp.xy * float2(.4, .45);
              o.bumpuv[1] = temp.wz;
                           
              // object space view direction
              o.viewDir.xzy = normalize( ObjSpaceViewDir(v.vertex) );
                           
              // calculate the reflection vector
              float4x4 mat = float4x4 (
               .5, 0, 0,.5,
                0,.5 * _ProjectionParams.x, 0,.5,
                0, 0,.5,.5,
                0, 0, 0, 1
              );              
              o.ref = mul (mat, o.pos);
                           
              return o;
}
ENDCG

Program "" {
SubProgram {
              Keywords { "WATER_REFLECTIVE" "WATER_REFRACTIVE" }
              SetTexture [_BumpMap] { 2D }
              SetTexture [_BumpMap] { 2D }
              SetTexture [_Fresnel] { 2D }
              SetTexture [_ReflectionTex] { 2D }
              Local 0, ([_ReflDistort],0,0,0)

"!!ATIfs1.0
StartConstants;
              CONSTANT c0 = program.local[0];
EndConstants;

StartPrelimPass;
              PassTexCoord r3, t3.stq_dq; # reflection vector
              SampleMap r0, t0.str;    # bump1
              SampleMap r1, t1.str;    # bump2
              PassTexCoord r2, t2.str;
                           
              ADD r1.half, r0.bias, r1.bias;    # bump = bump1 + bump2 - 1
              DOT3 r2, r1.2x, r2;    # fresnel: dot (bump, viewer-pos)
              # add less offset because it's purely screenspace; big ones look bad
              MAD r3.rg, r1, c0.r, r3;  # uv += bump * strength; add less because it's not perspective
EndPass;

StartOutputPass;
              SampleMap r3, r3.str;  # reflection color
               SampleMap r2, r2.str;  # water color/fresnel
               MOV r0, r3;
               MUL r0.a, r2.a, r2.a; # square fresnel because water mesh is very low-poly
EndPass;
"              
}
SubProgram {
              Keywords { "WATER_SIMPLE" }
              SetTexture [_BumpMap] { 2D }
              SetTexture [_BumpMap] { 2D }
              SetTexture [_ReflectiveColor] { 2D }
              Local 0, [_HorizonColor]

"!!ATIfs1.0
StartConstants;
              CONSTANT c0 = program.local[0];
EndConstants;

StartPrelimPass;
              SampleMap r0, t0.str;
              SampleMap r1, t1.str;
              PassTexCoord r2, t2.str;
                           
              ADD r1, r0.bias, r1.bias;    # bump = bump1 + bump2 - 1
              DOT3 r2, r1, r2;   # fresnel: dot (bump, viewer-pos)
EndPass;

StartOutputPass;
               SampleMap r2, r2.str;

              #MOV r0.rgb, r2;
              LERP r0.rgb, r2.a, c0, r2;    # fade in reflection
              MOV r0.a, c0.a;
EndPass;
"              
}
}
              }
}*/

// -----------------------------------------------------------
//  Old cards

// three texture, cubemaps
Subshader {
              Tags {
               "WaterMode" = "Simple"
               "Queue" = "Transparent-120" // foam uses -110
              }
              Pass {
               ZWrite Off
               ColorMask RGB
               Blend SrcAlpha OneMinusSrcAlpha
               Color (0.5,0.5,0.5,0.3)
               SetTexture [_MainTex] {
                Matrix [_WaveMatrix]
                combine texture * primary
               }
               SetTexture [_MainTex] {
                Matrix [_WaveMatrix2]
                combine texture * primary + previous
               }
               SetTexture [_ReflectiveColorCube] {
                combine texture * previous, primary
                Matrix [_Reflection]
               }
              }
}

// single texture, cubemaps
Subshader {
              Tags {
               "WaterMode" = "Simple"
               "Queue" = "Transparent-120" // foam uses -110
              }
              Pass {
               ZWrite Off
               ColorMask RGB
               Blend SrcAlpha OneMinusSrcAlpha
               Color [_HorizonColor]
               SetTexture [_ReflectiveColorCube] {
                combine texture, primary
                Matrix [_Reflection]
               }
              }
}

// single texture
Subshader {
              Tags {
               "WaterMode" = "Simple"
               "Queue" = "Transparent-120" // foam uses -110
              }
              Pass {
               ZWrite Off
               ColorMask RGB
               Blend SrcAlpha OneMinusSrcAlpha
               Color [_HorizonColor]
               SetTexture [_MainTex] {
                Matrix [_WaveMatrix]
                combine texture, primary
               }
              }
}

}

Shader "Main/DR Water Simple1" {              
Properties {
              _WaveScale ("Wave scale", Range (0.001,0.15)) = 0.063
              _ReflDistort ("Reflection distort", Range (0,1.5)) = 0.44
              _RefrDistort ("Refraction distort", Range (0,1.5)) = 0.40
              _RefrColor ("Refraction color", COLOR)  = ( .34, .85, .92, 1)
              _Fresnel ("Fresnel (A) ", 2D) = "" {}
              _BumpMap ("Bumpmap (RGB) ", 2D) = "" {}
              WaveSpeed ("Wave speed (map1 x,y; map2 x,y)", Vector) = (19,9,-16,-7)
              _ReflectiveColor ("Reflective color (RGB) fresnel (A) ", 2D) = "" {}
              _ReflectiveColorCube ("Reflective color cube (RGB) fresnel (A)", Cube) = "" { TexGen CubeReflect }
              _HorizonColor ("Simple water horizon color", COLOR)  = ( .172, .463, .435, 1)
              _MainTex ("Fallback texture", 2D) = "" {}
              _ReflectionTex ("Internal Reflection", 2D) = "" {}
              _RefractionTex ("Internal Refraction", 2D) = "" {}
}

// -----------------------------------------------------------
// Fragment program cards

Subshader {
              Tags {
               "WaterMode" = "Refractive"
                "Queue" = "Transparent-90" // foam uses -110
               //"Queue" = "Transparent" // foam uses -110 / original: Transparent-120
              }
              Pass {
                            
CGPROGRAM
// Upgrade NOTE: excluded shader from OpenGL ES 2.0 because it uses non-square matrices
#pragma exclude_renderers gles
// Upgrade NOTE: excluded shader from Xbox360; has structs without semantics (struct v2f members ref,bumpuv,viewDirZ)
#pragma exclude_renderers xbox360
#pragma vertex vert
#pragma fragment frag
#pragma fragmentoption ARB_precision_hint_fastest              
#pragma fragmentoption ARB_fog_exp2
#pragma multi_compile WATER_REFRACTIVE

#define HAS_REFLECTION 1
#define HAS_REFRACTION 1

#include "UnityCG.cginc"

uniform float4 WaveSpeed;
uniform float _WaveScale;

uniform float _ReflDistort;
uniform float _RefrDistort;

struct appdata {
              float4 vertex : POSITION;
              float3 normal : NORMAL;
};

struct v2f {
              float4 pos : SV_POSITION;
              float3 ref;
              float2 bumpuv[2];
              float4 viewDirZ;
};              

v2f vert(appdata v)
{
              v2f o;
              o.pos = mul (UNITY_MATRIX_MVP, v.vertex);
                           
              // scroll bump waves
              float4 temp;
              temp.xyzw = (v.vertex.xzxz + _Time.x * WaveSpeed.xyzw) * _WaveScale;
              o.bumpuv[0] = temp.xy * float2(.4, .45);
              o.bumpuv[1] = temp.wz;
                           
              // object space view direction (will normalize per pixel)
              o.viewDirZ.xzy = ObjSpaceViewDir(v.vertex);
                           
              // calculate the reflection vector
              float3x4 mat = float3x4 (
               0.5, 0, 0, 0.5,
               0, 0.5 * _ProjectionParams.x, 0, 0.5,
               0, 0, 0, 1
              );              
              o.ref = mul (mat, o.pos);
                           
              // increase distortion in distance a bit to make
              // the perspective decrease of distortion less pronounced
              o.viewDirZ.w = 1.0 + o.ref.z * 0.15;
                           
              return o;
}

sampler2D _ReflectionTex;
sampler2D _Fresnel;
sampler2D _RefractionTex;
uniform float4 _RefrColor;
sampler2D _BumpMap;

half4 frag( v2f i ) : COLOR
{
              i.viewDirZ.xyz = normalize(i.viewDirZ.xyz);
                           
              // combine two scrolling bumpmaps into one
              half3 bump1 = tex2D( _BumpMap, i.bumpuv[0] ).rgb;
              half3 bump2 = tex2D( _BumpMap, i.bumpuv[1] ).rgb;
              half3 bump = bump1 + bump2 - 1;
                           
              // fresnel factor
              half fresnelFac = dot( i.viewDirZ.xyz, bump );
                           
              // perturb reflection/refraction UVs by bumpmap, and lookup colors
              bump.xy *= i.viewDirZ.w;
                           
              float3 uv1 = i.ref; uv1.xy += bump * _ReflDistort;
              half4 refl = tex2Dproj( _ReflectionTex, uv1 );
              float3 uv2 = i.ref; uv2.xy -= bump * _RefrDistort;
              half4 refr = tex2Dproj( _RefractionTex, uv2 ) * _RefrColor;
                           
              // final color is between refracted and reflected based on fresnel              
              half4 color;

              // refraction + reflection              
              half fresnel = tex2D( _Fresnel, float2(fresnelFac,fresnelFac) ).a;
              color = lerp( refr, refl, fresnel );
                           
              return color;
}
ENDCG

              }
}

Fallback Off

}