Ocean map with a 3rd person

return Mathf.Sqrt (-2.0 Mathf.Log (x1)) Mathf.Cos (2.0 Mathf.PI x2);

if (!SetupOffscreenRendering()) { material_ocean.SetTexture ("_BumpMap", textureA); material_ocean.SetTextureScale ("_BumpMap", Vector2(normal_scale, normal_scale));

 material_ocean.SetTexture ("_BumpMap2", textureB);
 material_ocean.SetTextureScale ("_BumpMap2", Vector2(normal_scale, normal_scale));

}

pixelData = new Color[n_width * n_height];

// Init the water height matrix data = new ComplexF[width*height]; // lateral offset matrix to get the choppy waves data_x = new ComplexF[width*height];

// tangent t_x = new ComplexF[width*height]; t_y = new ComplexF[width*height];

n_x = new ComplexF[n_width n_height]; n_y = new ComplexF[n_width n_height];

// Geometry size g_height = height + 1;
g_width = width + 1;

tiles_LOD = new Array();

for (LOD=0;LOD<max_LOD*max_LOD;LOD++) { tiles_LOD.Add (new Array()); }

var tile; var chDist :int; // Chebychev distance
for (y=0;y<tiles_y;y++) { for (x=0;x<tiles_x;x++) {

     chDist = Mathf.Max (Mathf.Abs (tiles_y/2 - y), Mathf.Abs (tiles_x/2 - x));
     chDist = chDist > 0 ? chDist-1 : 0;
     //Debug.Log(chDist);
     cy = y-tiles_y/2;
     cx = x-tiles_x/2;
     tile = new GameObject ("Tile"+chDist);

     tile.transform.position.x = Mathf.RoundToInt(cx * size.x*s);
     tile.transform.position.y = Mathf.RoundToInt(-2.0 * chDist);
     tile.transform.position.z = Mathf.RoundToInt(cy * size.z*s);
     tile.transform.localScale.x = s;
     tile.transform.localScale.y = s;
     tile.transform.localScale.z = s;
     tile.AddComponent(MeshFilter);
     tile.AddComponent("MeshRenderer");
     tile.renderer.material = material_ocean;

     //Make child of this object, so we don't clutter up the
     //scene hierarchy more than necessary.
     tile.transform.parent = transform;

     //Also we don't want these to be drawn while doing refraction/reflection passes,
     //so we'll add the to the water layer for easy filtering.
     tile.layer = LayerMask.NameToLayer("Water");

     // Determine which LOD the tile belongs
     tiles_LOD[chDist].Add (tile.GetComponent(MeshFilter).mesh);
 }

}

// Init wave spectra. One for vertex offset and another for normal map h0 = new ComplexF[width height]; n0 = new ComplexF[n_width n_height];

// Wind restricted to one direction, reduces calculations wind = Vector2 (windx, 0.0);

// Initialize wave generator
for (y=0;y<height;y++) { for (x=0;x<width;x++) { yc = y < height / 2 ? y : -height + y; xc = x < width / 2 ? x : -width + x; vec_k = Vector2 (2.0 Mathf.PI xc / size.x, 2.0 Mathf.PI yc / size.z); h0[width y + x] = ComplexF ( GaussianRnd(x,y), GaussianRnd(x,y)) 0.707 * Mathf.Sqrt (P_spectrum (vec_k, wind)); } }

             ny = y > 0 ? n_height - y : 0;
             nx = x > 0 ? n_width - x : 0;

             n_x[n_width * y + x] = (n0[n_width * y + x] * coeffA + n0[n_width * ny + nx].GetConjugate() * coeffB) * ComplexF (0.0, -vec_k.x);               
             n_y[n_width * y + x] = (n0[n_width * y + x] * coeffA + n0[n_width * ny + nx].GetConjugate() * coeffB) * ComplexF (0.0, -vec_k.y);               
         }
     }
     Fourier.FFT2 (n_x, n_width, n_height, FourierDirection.Backward);
     Fourier.FFT2 (n_y, n_width, n_height, FourierDirection.Backward);

     for (i=0; i<n_width*n_height; i++){
         bump = Vector3 (n_x[i].Re*Mathf.Abs(n_x[i].Re), n_y[i].Re*Mathf.Abs(n_y[i].Re), n_width * n_height / scale / normal_scale * normalStrength).normalized * 0.5;
         pixelData[i] = Color (bump.x + 0.5, bump.y + 0.5, bump.z + 0.8);
         //          pixelData[i] = Color (0.5, 0.5, 1.0);           
     }
     if (idx==0) {
         textureA.SetPixels (pixelData, 0);
         textureA.Apply();
     }
     else {
         textureB.SetPixels (pixelData, 0);
         textureB.Apply();
     }
 }
 normalDone = true;

var y = 0; var x = 0;

// Build vertices and UVs var vertices = new Vector3[g_height g_width]; var tangents = new Vector4[g_height g_width]; var uv = new Vector2[g_height * g_width];

var uvScale = Vector2 (1.0 / (g_width - 1), 1.0 / (g_height - 1)); var sizeScale = Vector3 (size.x / (g_width - 1), size.y, size.z / (g_height - 1));

for (y=0;y<g_height;y++) { for (x=0;x<g_width;x++) { var vertex = Vector3 (x, 0.0, y); vertices[y * g_width + x] = Vector3.Scale (sizeScale, vertex); uv[y*g_width + x] = Vector2.Scale (Vector2 (x, y), uvScale); } }

mesh.vertices = vertices; mesh.uv = uv;

for (y=0;y<g_height;y++) { for (x=0;x<g_width;x++) { tangents[y*g_width + x] = Vector4 (1.0, 0.0, 0.0, -1.0); } } mesh.tangents = tangents;

for (LOD=0;LOD<max_LOD;LOD++) { verticesLOD = new Vector3[(height/Mathf.Pow(2,LOD)+1) (width/Mathf.Pow(2,LOD)+1)]; uvLOD = new Vector2[(height/Mathf.Pow(2,LOD)+1) (width/Mathf.Pow(2,LOD)+1)]; idx = 0;

 for (y=0;y<g_height;y+=Mathf.Pow(2,LOD)) {
     for (x=0;x<g_width;x+=Mathf.Pow(2,LOD)) {
         verticesLOD[idx] = vertices[g_width * y + x];
         uvLOD[idx++] = uv[g_width * y + x];
     }           
 }
 for (k=0;k<tiles_LOD[LOD].length;k++) {
     meshLOD = tiles_LOD[LOD][k];
     meshLOD.vertices = verticesLOD;
     meshLOD.uv = uvLOD;
 }       

}

LOD=0; // Build triangle indices: 3 indices into vertex array for each triangle for (LOD=0;LOD<max_LOD;LOD++) { index = 0; width_LOD = width / Mathf.Pow(2,LOD) +1; triangles = new int[(height/Mathf.Pow(2,LOD) width/Mathf.Pow(2,LOD)) 6]; for (y=0;y<height/Mathf.Pow(2,LOD);y++) { for (x=0;x<width/Mathf.Pow(2,LOD);x++) { // For each grid cell output two triangles triangles[index++] = (y width_LOD) + x; triangles[index++] = ((y+1) width_LOD) + x ; triangles[index++] = (y * width_LOD) + x + 1;

         triangles[index++] = ((y+1) * width_LOD) + x;
         triangles[index++] = ((y+1) * width_LOD) + x + 1;
         triangles[index++] = (y* width_LOD) + x + 1;
     }
 }
 for (k=0;k<tiles_LOD[LOD].length;k++) {
     meshLOD = tiles_LOD[LOD][k];
     meshLOD.triangles = triangles;
 }

}

//Bail out if the shader could not be compiled if (shader == null) return false;

if (!shader.isSupported) return false;

//TODO: More fail-tests?

refractionTexture = new RenderTexture(128, 128, 16); refractionTexture.wrapMode = TextureWrapMode.Clamp; refractionTexture.isPowerOfTwo = true;

reflectionTexture = new RenderTexture(128,128, 16); reflectionTexture.wrapMode = TextureWrapMode.Clamp; reflectionTexture.isPowerOfTwo = true;

//Spawn the camera we'll use for offscreen rendering (refraction/reflection) var cam : GameObject = new GameObject(); cam.name = "DeepWaterOffscreenCam"; cam.transform.parent = transform; offscreenCam = cam.AddComponent(typeof(Camera)) as Camera; offscreenCam.enabled = false; offscreenCam.fieldOfView = 60; offscreenCam.farClipPlane = 10000;

//Hack to make this object considered by the renderer - first make a plane //covering the watertiles so we get a decent bounding box, then //scale all the vertices to 0 to make it invisible. gameObject.AddComponent(MeshRenderer);

renderer.material.renderQueue = 1; renderer.receiveShadows = true; renderer.castShadows = true;

var m : Mesh = new Mesh();

var verts : Vector3[] = new Vector3[4]; var uv : Vector2[] = new Vector2[4]; var n : Vector3[] = new Vector3[4]; var tris : int[] = new int[6];

var minSizeX : float = -1024; var maxSizeX : float = 1024;

var minSizeY : float = -1024; var maxSizeY : float = 1024;

verts[0] = new Vector3(minSizeX, 0.0, maxSizeY); verts[1] = new Vector3(maxSizeX, 0.0, maxSizeY); verts[2] = new Vector3(maxSizeX, 0.0, minSizeY); verts[3] = new Vector3(minSizeX, 0.0, minSizeY);

tris[0] = 0; tris[1] = 1; tris[2] = 2;

tris[3] = 2; tris[4] = 3; tris[5] = 0;

m.vertices = verts; m.uv = uv; m.normals = n; m.triangles = tris;

var mfilter : MeshFilter = gameObject.GetComponent(MeshFilter);

if (mfilter == null) mfilter = gameObject.AddComponent(MeshFilter);

mfilter.mesh = m;

m.RecalculateBounds();

//Hopefully the bounds will not be recalculated automatically verts[0] = Vector3.zero; verts[1] = Vector3.zero; verts[2] = Vector3.zero; verts[3] = Vector3.zero;

m.vertices = verts;

//Create the material and set up the texture references. material_ocean = new Material(shader);

GUI.DrawTexture (new Rect(128, 0, 128, 128), textureA, ScaleMode.StretchToFill, false); GUI.DrawTexture (new Rect(128, 128, 128, 128), textureB, ScaleMode.StretchToFill, false);

GUI.Label(new Rect(10, 10, 100, 20), "Waveheight"); scale = GUI.HorizontalSlider(new Rect(120, 10, 200, 20), scale, 0.05, 10.0); // scale=3;

     var iwkt = disp(vec_k) * Time.time;
     var coeffA = ComplexF (Mathf.Cos (iwkt), Mathf.Sin (iwkt));
     var coeffB = coeffA.GetConjugate();

     ny = y > 0 ? height - y : 0;
     nx = x > 0 ? width - x : 0;

     data[idx] = h0[idx] * coeffA + h0[width * ny + nx].GetConjugate() * coeffB;             
     t_x[idx] = data[idx] * ComplexF (0.0, vec_k.x) - data[idx] * vec_k.y;               

     // Choppy wave calcuations
     if (x + y > 0)
         data[idx] += data[idx] * vec_k.x / vec_k.magnitude;
 }

} material_ocean.SetFloat( "_BlendA",Mathf.Cos(Time.time)*0.1); material_ocean.SetFloat( "_BlendB",Mathf.Sin(Time.time)*0.5);

Fourier.FFT2 (data, width, height, FourierDirection.Backward); Fourier.FFT2 (t_x, width, height, FourierDirection.Backward);

// Get base values for vertices and uv coordinates. if (baseHeight == null) { var mesh : Mesh = baseMesh; baseHeight = mesh.vertices; baseUV = mesh.uv;

 var itemCount = baseHeight.Length;
 uvs = new Vector2[itemCount];
 vertices = new Vector3[itemCount];
 normals = new Vector3[itemCount];
 tangents = new Vector4[itemCount];

}

var vertex; var uv; var normal; var n_scale = size.x / width / scale;

var scaleA = choppy_scale / (width height); var scaleB = scale / (width height); var scaleBinv = 1.0 / scaleB;

for (i=0;i<width*height;i++) { iw = i+i/width; vertices[iw] = baseHeight[iw]; vertices[iw].x += data [i].Im scaleA; vertices[iw].y = data [i].Re scaleB;

 normals[iw] = Vector3 (t_x[i].Re, scaleBinv, t_x[i].Im).normalized;

 uv = baseUV[iw];
 uv.x = uv.x + Time.time * uv_speed;
 uvs[iw] = uv;

 if (!((i+1) % width)) {
     vertices[iw+1] = baseHeight[iw+1];
     vertices[iw+1].x += data [i+1-width].Im * scaleA;
     vertices[iw+1].y = data [i+1-width].Re * scaleB;

     normals[iw+1] = Vector3 (t_x[i+1-width].Re, scaleBinv, t_x[i+1-width].Im).normalized;

     uv = baseUV[iw+1];
     uv.x = uv.x + Time.time * uv_speed;
     uvs[iw+1] = uv;             
 }

}

var offset = g_width*(g_height-1);

for (i=0;i<g_width;i++) { vertices[i+offset] = baseHeight[i+offset]; vertices[i+offset].x += data [i%width].Im scaleA; vertices[i+offset].y = data [i%width].Re scaleB;

 normals[i+offset] = Vector3 (t_x[i%width].Re, scaleBinv, t_x[i%width].Im).normalized;

 uv = baseUV[i+offset];
 uv.x = uv.x - Time.time*uv_speed;
 uvs[i+offset] = uv;

}

for (i=0;i<g_width*g_height-1;i++) {

 //Need to preserve w in refraction/reflection mode
 if (!reflectionRefractionEnabled)
 {
     if (((i+1) % g_width) == 0) {
         tangents[i] = (vertices[i-width+1] + Vector3 (size.x, 0.0, 0.0) - vertices[i]).normalized;
     }
     else {
         tangents[i] = (vertices[i+1]-vertices[i]).normalized;
     }

     tangents[i].w = 1.0;
 }
 else
 {
     var tmp : Vector3 = Vector3.zero;

     if (((i+1) % g_width) == 0) 
     {
         tmp = (vertices[i-width+1] + Vector3 (size.x, 0.0, 0.0) - vertices[i]).normalized;
     }
     else 
     {
         tmp = (vertices[i+1]-vertices[i]).normalized;
     }

     tangents[i] = new Vector4(tmp.x, tmp.y, tmp.z, tangents[i].w);
 }

}

//In reflection mode, use tangent w for foam strength if (reflectionRefractionEnabled) { for (y = 0; y < g_height; y++) { for (x = 0; x < g_width; x++) { if (x+1 >= g_width) { tangents[x + g_width*y].w = tangents[g_width*y].w;

             continue;
         }

         if (y+1 >= g_height)
         {
             tangents[x + g_width*y].w = tangents[x].w;

             continue;
         }

         var right : Vector3 = vertices[(x+1) + g_width*y] - vertices[x + g_width*y];
         var back : Vector3 = vertices[x + g_width*y] - vertices[x + g_width*(y+1)];

         var foam : float = right.x/(size.x/g_width);


         if (foam < 0.0)
             tangents[x + g_width*y].w = 1;
         else if (foam < 0.5)
             tangents[x + g_width*y].w += 2 * Time.deltaTime;
         else
             tangents[x + g_width*y].w -= 0.5 * Time.deltaTime;

         tangents[x + g_width*y].w = Mathf.Clamp(tangents[x + g_width*y].w/foamTime, 0.0, 2.0);
     }
 }

}

tangents[g_width*g_height-1] = (vertices[g_width*g_height-1]+Vector3(size.x, 0.0, 0.0)-vertices[1]).normalized;

LOD=0; for (LOD=0;LOD<max_LOD;LOD++) { var den = Mathf.Pow(2,LOD); var itemcount = (height/den+1) * (width/den+1);

 tangentsLOD = new Vector4[itemcount];
 verticesLOD = new Vector3[itemcount];
 normalsLOD = new Vector3[itemcount];
 uvLOD = new Vector2[(height/Mathf.Pow(2,LOD)+1) * (width/Mathf.Pow(2,LOD)+1)];
 idx = 0;

 for (y=0;y<g_height;y+=den) {
     for (x=0;x<g_width;x+=den) {
         idx2 = g_width * y + x;
         verticesLOD[idx] = vertices[idx2];
         uvLOD[idx] = uvs[g_width * y + x];
         tangentsLOD[idx] = tangents[idx2];
         normalsLOD[idx++] = normals[idx2];
     }           
 }
 for (k=0;k<tiles_LOD[LOD].length;k++) {
     meshLOD = tiles_LOD[LOD][k];
     meshLOD.vertices = verticesLOD;
     meshLOD.normals = normalsLOD;
     meshLOD.uv = uvLOD;
     meshLOD.tangents = tangentsLOD;
 }       

material_ocean.SetTexture("_Reflection", reflectionTexture); material_ocean.SetTexture("_Refraction", refractionTexture); material_ocean.SetTexture ("_Bump", bumpTexture); material_ocean.SetTexture("_Fresnel", fresnelTexture); material_ocean.SetTexture("_Foam", foamTexture); material_ocean.SetTexture("_MainTex", maintexTexture); material_ocean.SetVector("_Size", new Vector4(size.x, size.y, size.z, 0.0)); material_ocean.SetColor("_SurfaceColor", surfaceColor); material_ocean.SetColor("_WaterColor", waterColor); material_ocean.SetColor("_Color", mainColor); material_ocean.SetColor("_SpecColor", specularColor); material_ocean.SetColor("_Transparency", transparency); var index : int = (Time.time * framesPerSecond) % caustics.Length; causticsTexture= caustics[index]; material_ocean.SetTexture("_Caustics", causticsTexture); material_ocean.SetFloat("_RefractionLevel", refractionlevel); material_ocean.SetColor("_SunColor", sunColor); material_ocean.SetVector("_SunPosition", sunposition.transform.position); material_ocean.SetFloat("_SunPower", sunpower);

var renderCamera : Camera = mycam;

var originalWorldToCam : Matrix4x4 = renderCamera.worldToCameraMatrix;

var cullingMask : int = renderCamera.cullingMask & ~(1 << LayerMask.NameToLayer("Water"));

//Reflection pass var reflection : Matrix4x4 = Matrix4x4.zero;

//TODO: Use local plane here, not global! CameraHelper.CalculateReflectionMatrix (reflection, new Vector4(0.0, 1.0, 0.0, 0.0));

offscreenCam.transform.position = reflection.MultiplyPoint(renderCamera.transform.position); offscreenCam.transform.rotation = renderCamera.transform.rotation; offscreenCam.transform.Rotate(0,180,0); offscreenCam.worldToCameraMatrix = originalWorldToCam * reflection;

offscreenCam.cullingMask = cullingMask; offscreenCam.targetTexture = reflectionTexture; offscreenCam.clearFlags = renderCamera.clearFlags;

//Need to reverse face culling for reflection pass, since the camera //is now flipped upside/down. GL.SetRevertBackfacing (false);

var cameraSpaceClipPlane : Vector4 = CameraHelper.CameraSpacePlane(offscreenCam, Vector3.zero, Vector3.up, 1.0);

var projection : Matrix4x4 = renderCamera.projectionMatrix; var obliqueProjection : Matrix4x4 = projection;

CameraHelper.CalculateObliqueMatrix (obliqueProjection, cameraSpaceClipPlane);

//Do the actual render, with the near plane set as the clipping plane. See the //pro water source for details. offscreenCam.projectionMatrix = obliqueProjection; offscreenCam.Render();

GL.SetRevertBackfacing (false);

//Refractionpass var fog : boolean = RenderSettings.fog; var fogColor : Color = RenderSettings.fogColor; var fogDensity : float = RenderSettings.fogDensity;

RenderSettings.fog = true; RenderSettings.fogColor = Color.grey; RenderSettings.fogDensity = waterDirtyness/10;

//TODO: If we want to use this as a refraction seen from under the seaplane, // the cameraclear should be skybox. offscreenCam.clearFlags = CameraClearFlags.Color; offscreenCam.backgroundColor = Color.grey;

offscreenCam.targetTexture = refractionTexture; obliqueProjection = projection;

offscreenCam.transform.position = renderCamera.transform.position; offscreenCam.transform.rotation = renderCamera.transform.rotation; offscreenCam.worldToCameraMatrix = originalWorldToCam;

cameraSpaceClipPlane = CameraHelper.CameraSpacePlane(offscreenCam, Vector3.zero, Vector3.up, -1.0); CameraHelper.CalculateObliqueMatrix (obliqueProjection, cameraSpaceClipPlane); offscreenCam.projectionMatrix = obliqueProjection;

offscreenCam.Render();

RenderSettings.fog = fog; RenderSettings.fogColor = fogColor; RenderSettings.fogDensity = fogDensity;

offscreenCam.projectionMatrix = projection;

offscreenCam.targetTexture = null;