We have in previous tutorial sections used planes as water surfaces, but they will not be good enough in this section. The problem is that we can't control the resolution of the plane, so we can't change the distance between each vertice in the plane. So first of all we need a water surface that is much more customizable.

Create a new scene, add a plane to it, and rename the plane GameObject to Water. We will later replace this plane with our own plane. Then remove the mesh collider and replace it with a box collider. We are going to interact with the water with the mouse, so we will need a collider. (You can remove the collider if you don't need to fire a raycast against the water.) When we have created the new water mesh we have to reposition the collider so it covers the new mesh. So create a new script called WaterWakesTutorial, add it to the Water GameObject, and add the following code to it.

//Mesh parameters Mesh waterMesh; MeshFilter waterMeshFilter; //The total size in m float waterWidth = 3f; //Width of one square (= distance between vertices) float gridSpacing = 0.1f; void Start() { //Need reference to the meshfilter so we can add the water waterMeshFilter = this.GetComponent<MeshFilter>(); //Create the water mesh //Don't forget to write "using System.Collections.Generic;" at the top List<Vector3[]> height_tmp = GenerateWaterMesh.GenerateWater(waterMeshFilter, waterWidth, gridSpacing); //Get a reference to the watermesh waterMesh = waterMeshFilter.mesh; //Resize box collider //Need a box collider so the mouse can interact with the water BoxCollider boxCollider = this.GetComponent<BoxCollider>(); boxCollider.center = new Vector3(waterWidth/2f, 0f, waterWidth/2f); boxCollider.size = new Vector3(waterWidth, 0.1f, waterWidth); //Center the mesh to make it easier to know where it is transform.position = new Vector3(-waterWidth/2f, 0f, -waterWidth/2f); }

Now we need the script that will create the new customizable water mesh. So create a script called GenerateWaterMesh. If you have read the previous sections of this tutorial then you will have an idea of how this script is working. It is basically first figuring out how many vertices we need based on the size of the water. Then it is building the triangles needed and adds them to an array. It also uses a second array with the coordinates of each vertice in Vector3 format. This is the array we need so we can interact with the water surface. Add the following code to GenerateWaterMesh.

public static List<Vector3[]> GenerateWater(MeshFilter waterMeshFilter, float size, float spacing) { //Determine the number of vertices per row/column (is always a square) int totalVertices = (int)Mathf.Round(size / spacing) + 1; //Vertices 2d list List<Vector3[]> vertices2dArray = new List<Vector3[]>(); //Triangles List<int> tris = new List<int>(); for (int z = 0; z < totalVertices; z++) { vertices2dArray.Add(new Vector3[totalVertices]); for (int x = 0; x < totalVertices; x++) { //Fill this array every loop Vector3 current_point = new Vector3(); //Get the corrdinates of the vertice current_point.x = x * spacing; current_point.z = z * spacing; current_point.y = 0f; //assume always at 0 vertices2dArray[z][x] = current_point; //Don't generate a triangle the first coordinate on each row if (x <= 0 || z <= 0) { continue; } //Build the triangles //Each square consists of 2 triangles //The triangle south-west of the vertice tris.Add(x + z * totalVertices); tris.Add(x + (z-1) * totalVertices); tris.Add((x-1) + (z-1) * totalVertices); //The triangle west-south of the vertice tris.Add(x + z * totalVertices); tris.Add((x-1) + (z-1) * totalVertices); tris.Add((x-1) + z * totalVertices); } } //Unfold the 2d array of verticies into a 1d array. Vector3[] unfolded_verts = new Vector3[totalVertices*totalVertices]; for (int i = 0; i < vertices2dArray.Count; i++) { //Copies all the elements of the current array to the specified array vertices2dArray[i].CopyTo(unfolded_verts, i * totalVertices); } //Generate the mesh Mesh waterMesh = new Mesh(); waterMesh.vertices = unfolded_verts; waterMesh.triangles = tris.ToArray(); //Ensure the bounding volume is correct waterMesh.RecalculateBounds(); //Update the normals to reflect the change waterMesh.RecalculateNormals(); waterMesh.name = "WaterMesh"; //Add the generated mesh to the GameObject waterMeshFilter.mesh.Clear(); waterMeshFilter.mesh = waterMesh; //Return the 2d array return vertices2dArray; }

If you now press the play button, and are in Scene view, you should see a much more detailed plane. Also add a blue color to it.

Now we can implement the iWave algorithm. Step 1 in that algorithm is to precompute the kernel values and store them in a lookup table, which is here called storedKernelArray. So add the following to the beginning of WaterWakesTutorial script:

//Water wakes parameters //Velocity damping term //Useful to help suppress numerical instabilities that can arise public float alpha = 0.9f; //P - kernel size //6 is the smallest value that gives water-like motion int P = 8; //Should be neg or the waves will move in the wrong direction float g = -9.81f; //Store the precomputed kernel values here float[,] storedKernelArray;

...and to the start method:

//Precompute the convolution kernel values storedKernelArray = new float[P * 2 + 1, P * 2 + 1]; PrecomputeKernelValues();

...and the methods that will precompute the kernel values:

//Precompute the kernel values G(k,l) void PrecomputeKernelValues() { float G_zero = CalculateG_zero(); //P - kernel size for (int k = -P; k <= P; k++) { for (int l = -P; l <= P; l++) { //Need "+ P" because we iterate from -P and not 0, which is how they are stored in the array storedKernelArray[k + P, l + P] = CalculateG((float)k,(float)l, G_zero); } } } //G(k,l) private float CalculateG(float k, float l, float G_zero) { float delta_q = 0.001f; float sigma = 1f; float r = Mathf.Sqrt(k*k + l*l); float G = 0f; for (int n = 1; n <= 10000; n++) { float q_n = ((float)n * delta_q); float q_n_square = q_n * q_n; G += q_n_square * Mathf.Exp(-sigma * q_n_square) * BesselFunction(q_n * r); } G /= G_zero; return G; } //G_zero private float CalculateG_zero() { float delta_q = 0.001f; float sigma = 1f; float G_zero = 0f; for (int n = 1; n <= 10000; n++) { float q_n_square = ((float)n * delta_q) * ((float)n * delta_q); G_zero += q_n_square * Mathf.Exp(-sigma * q_n_square); } return G_zero; } private float BesselFunction(float x) { //From http://people.math.sfu.ca/~cbm/aands/frameindex.htm //page 369 - 370 float J_zero_of_X = 0f; //Test to see if the bessel functions are valid //Has to be above -3 if (x <= -3f) { Debug.Log("smaller"); } //9.4.1 //-3 <= x <= 3 if (x <= 3f) { //Ignored the small rest term at the end J_zero_of_X = 1f - 2.2499997f * Mathf.Pow (x / 3f, 2f) + 1.2656208f * Mathf.Pow (x / 3f, 4f) - 0.3163866f * Mathf.Pow (x / 3f, 6f) + 0.0444479f * Mathf.Pow (x / 3f, 8f) - 0.0039444f * Mathf.Pow (x / 3f, 10f)+ 0.0002100f * Mathf.Pow (x / 3f, 12f); } //9.4.3 //3 <= x <= infinity else { //Ignored the small rest term at the end float f_zero = 0.79788456f - 0.00000077f * Mathf.Pow (3f / x, 1f) - 0.00552740f * Mathf.Pow (3f / x, 2f) - 0.00009512f * Mathf.Pow (3f / x, 3f) - 0.00137237f * Mathf.Pow (3f / x, 4f) - 0.00072805f * Mathf.Pow (3f / x, 5f) + 0.00014476f * Mathf.Pow (3f / x, 6f); //Ignored the small rest term at the end float theta_zero = x - 0.78539816f - 0.04166397f * Mathf.Pow (3f / x, 1f) - 0.00003954f * Mathf.Pow (3f / x, 2f) - 0.00262573f * Mathf.Pow (3f / x, 3f) - 0.00054125f * Mathf.Pow (3f / x, 4f) - 0.00029333f * Mathf.Pow (3f / x, 5f) + 0.00013558f * Mathf.Pow (3f / x, 6f); //Should be cos and not acos J_zero_of_X = Mathf.Pow(x, -1f/3f) * f_zero * Mathf.Cos(theta_zero); } return J_zero_of_X; }

Now we can implement the iWave algorithm itself by following the pseudo-code in the report. So add the following to the beginning of WaterWakesTutorial script:

//Used in the iWave loop Vector3[][] height; Vector3[][] previousHeight; Vector3[][] verticalDerivative; public Vector3[][] source; public Vector3[][] obstruction; //To update the mesh we need a 1d array public Vector3[] unfolded_verts; //To be able to add ambient waves public Vector3[][] heightDifference; //Faster to calculate this once int arrayLength; float updateTimer = 0f;

...and the following to the start method:

//Init the arrays we need //These are now filled with heights at 0 height = height_tmp.ToArray(); //Need to clone these previousHeight = CloneList(height); verticalDerivative = CloneList(height); source = CloneList(height); obstruction = CloneList(height); heightDifference = CloneList(height); //Create this once here, so we dont need to create it each update unfolded_verts = new Vector3[height.Length * height.Length]; arrayLength = height.Length;

We need to clone the arrays with the following methods, so they are not the same, because that's how c# is working. Just add this method to somewhere in the WaterWakesTutorial script:

//Clone an array and the inner array Vector3[][] CloneList(Vector3[][] arrayToClone) { //First clone the outer array Vector3[][] newArray = arrayToClone.Clone() as Vector3[][]; //Then clone the inner arrays for (int i = 0; i < newArray.Length; i++) { newArray[i] = newArray[i].Clone() as Vector3[]; } return newArray; }

The iWave algorithm is highly dependent on the time parameter in the algorithm. Sometimes when the time parameter is too high, the algorithm will be unstable and produce gigantic waves. We can adjust these gigantic waves with the velocity damping term called alpha, but only if time is constant. So in the update method we have to make sure that time is a constant. If you choose a value other than 0.02f then you might have to change alpha. Add the following to the WaterWakesTutorial script:

void Update() { //Move water wakes updateTimer += Time.deltaTime; if (updateTimer > 0.02f) { MoveWater(0.02f); updateTimer = 0f; } } //Add water wakes to the water mesh void MoveWater(float dt) { //This will update height[j][i] AddWaterWakes(dt); //Update the mesh with the new heights //Unfold the 2d array of verticies into a 1d array for (int i = 0; i < arrayLength; i++) { //Copies all the elements of the current array to the specified array heightDifference[i].CopyTo(unfolded_verts, i * heightDifference.Length); } //Add the new position of the water to the water mesh waterMesh.vertices = unfolded_verts; //Ensure the bounding volume is correct waterMesh.RecalculateBounds(); //After modifying the vertices it is often useful to update the normals to reflect the change waterMesh.RecalculateNormals(); }

Finally we can add the heart of the iWave algorithm. This method is similar to the pseudo code in the report:

//Add water wakes void AddWaterWakes(float dt) { //If strange gigantic waves happens, adjust alpha //Add sources and obstructions for (int j = 0; j < arrayLength; j++) { for (int i = 0; i < arrayLength; i++) { //Add height from source height[j][i].y += source[j][i].y; //Clear the source source[j][i].y = 0f; //Add obstruction height[j][i].y *= obstruction[j][i].y; } } //Convolve to update verticalDerivative Convolve(); //Same for all float twoMinusAlphaTimesDt = 2f - alpha * dt; float onePlusAlphaTimesDt = 1f + alpha * dt; float gravityTimesDtTimesDt = g * dt * dt; for (int j = 0; j < arrayLength; j++) { for (int i = 0; i < arrayLength; i++) { //Faster to do this once float currentHeight = height[j][i].y; //Calculate the new height float newHeight = 0f; newHeight += currentHeight * twoMinusAlphaTimesDt; newHeight -= previousHeight[j][i].y; newHeight -= gravityTimesDtTimesDt * verticalDerivative[j][i].y; newHeight /= onePlusAlphaTimesDt; //Save the old height previousHeight[j][i].y = currentHeight; //Add the new height height[j][i].y = newHeight; //If we have ambient waves we can add them here //Just replace this with a call to a method where you find the current height of the ambient wave //At the current coordinate float heightAmbientWave = 0f; heightDifference[j][i].y = heightAmbientWave + newHeight; } } }

If we are going to use obstacles, we have to set the obstacles to default values in the Start method:

//Add obstruction when the wave hits the walls for (int j = 0; j < arrayLength; j++) { for (int i = 0; i < arrayLength; i++) { if (j == 0 || j == arrayLength - 1 || i == 0 || i == arrayLength - 1) { obstruction[j][i].y = 0f; } else { obstruction[j][i].y = 1f; } } }

... and finally the "Convolve height with the kernel and put it into vertical_derivative." I'm going to try to explain what's going on here. What we will do now is to loop through all the vertices in a square with the dimension (-P,P) around the current vertice. This is similar to what Photoshop is doing when you for example sharpen an image, as explained here: Kernel (image processing).

But we also have to take into account what will happen if a section of this square is outside of the water mesh. I've currently ignored the corner values for what happens if we are outside of the water mesh. I don't think they are that important here, but feel free to add them if you want. This is also the "slow" version of this part of the algorithm. The report describes the faster algorithm, but I decided to use the slower version to make it easier to follow the report.

//Convolve to update verticalDerivative //This might seem unnecessary, but we will save one array if we are doing it before the main loop void Convolve() { for (int j = 0; j < arrayLength; j++) { for (int i = 0; i < arrayLength; i++) { float vDeriv = 0f; //Will include when k, l = 0 for (int k = -P; k <= P; k++) { for (int l = -P; l <= P; l++) { //Get the precomputed values //Need "+ P" because we iterate from -P and not 0, which is how they are stored in the array float kernelValue = storedKernelArray[k + P, l + P]; //Make sure we are within the water if (j+k >= 0 && j+k < arrayLength && i+l >= 0 && i+l < arrayLength) { vDeriv += kernelValue * height[j+k][i+l].y; } //Outside else { //Right if (j+k >= arrayLength && i+l >= 0 && i+l < arrayLength) { vDeriv += kernelValue * height[2 * arrayLength - j - k - 1][i+l].y; } //Top else if (i+l >= arrayLength && j+k >= 0 && j+k < arrayLength) { vDeriv += kernelValue * height[j+k][2 * arrayLength - i - l - 1].y; } //Left else if (j+k < 0 && i+l >= 0 && i+l < arrayLength) { vDeriv += kernelValue * height[-j-k][i+l].y; } //Bottom else if (i+l < 0 && j+k >= 0 && j+k < arrayLength) { vDeriv += kernelValue * height[j+k][-i-l].y; } } } } verticalDerivative[j][i].y = vDeriv; } } }

If you press play, you will notice that absolutely nothing happens with the water. Let's change that! We will add a method that will interact with the water if you press on the water with your mouse. This is simple. Just call the method CreateWaterWakesWithMouse() each time in the Update loop.

//Interact with the water wakes by clicking with the mouse void CreateWaterWakesWithMouse() { //Fire ray from the current mouse position if (Input.GetKey(KeyCode.Mouse0)) { RaycastHit hit; if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out hit)) { //Convert the mouse position from global to local Vector3 localPos = transform.InverseTransformPoint(hit.point); //Loop through all the vertices of the water mesh for (int j = 0; j < arrayLength; j++) { for (int i = 0; i < arrayLength; i++) { //Find the closest vertice within a certain distance from the mouse float sqrDistanceToVertice = (height[j][i] - localPos).sqrMagnitude; //If the vertice is within a certain range float sqrDistance = 0.2f * 0.2f; if (sqrDistanceToVertice < sqrDistance) { //Get a smaller value the greater the distance is to make it look better float distanceCompensator = 1 - (sqrDistanceToVertice / sqrDistance); //Add the force that now depends on how far the vertice is from the mouse source[j][i].y += -0.02f * distanceCompensator; } } } } } }

That's it! If you press play and click with your mouse somewhere on the water surface, you will create water wakes.