// Use this for initialization
    void Start()
    {
        //******** Create water mesh ********
        waterMeshFilter = GetComponent <MeshFilter>();
        GenerateWaterMesh.GenerateWater(waterMeshFilter, waterWidth, gridSpacing);
        //Need a box collider so the mouse can interact with the water
        BoxCollider boxCollider = GetComponent <BoxCollider>();

        boxCollider.size = new Vector3(waterWidth, 0.1f, waterWidth);

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

        //Get water mesh and its vertice
        waterMesh    = waterMeshFilter.mesh;
        meshVertices = new List <Vector3>();
        waterMesh.GetVertices(meshVertices);
        verticePerRow = (int)Mathf.Sqrt(meshVertices.Count);
        //Initialization
        source        = new float[verticePerRow, verticePerRow];
        obstruction   = new float[verticePerRow, verticePerRow];
        data          = new RenderTexture(verticePerRow, verticePerRow, 24);
        data.format   = RenderTextureFormat.ARGBFloat;
        kernel        = new RenderTexture(2 * P + 1, 2 * P + 1, 24);
        kernel.format = RenderTextureFormat.ARGBFloat;

        for (int c = 0, i = 0; c < verticePerRow; c++)
        {
            for (int r = 0; r < verticePerRow; r++, i++)
            {
                if (c == 0 || c == verticePerRow - 1 || r == 0 || r == verticePerRow - 1)
                {
                    obstruction[c, r] = 0f;
                }
                else
                {
                    obstruction[c, r] = 1f;
                }
            }
        }
        ApplyFloatsToRT(storedKernelArray, kernel);

        //Set shader parameters
        waterMat = GetComponent <Renderer>().material;
        waveUpdateMat.SetTexture("_kernel", kernel);
        waveUpdateMat.SetFloat("kernelSize", P);

        //Multiple render target
        mrts = new MRT[2];
        for (int i = 0, n = mrts.Length; i < n; i++)
        {
            mrts[i] = new MRT(verticePerRow, verticePerRow);
        }
    }
    // Use this for initialization
    void Start()
    {
        //Get the controllerScripts
        GameObject gameController = GameObject.FindGameObjectWithTag("GameController");

        worldScript = gameController.GetComponent <WorldController> ();

        //Get and update seabed mesh
        seabedMesh = this.GetComponent <MeshFilter>().mesh;
        GenerateWaterMesh.GenerateWater(this.GetComponent <MeshFilter>(), worldScript.width, 0.5f, 0.0f);
        seabedMesh = this.GetComponent <MeshFilter>().mesh;

        this.transform.position = new Vector3(0.0f, -worldScript.height, 0.0f);
    }
    void Start()
    {
        //Get the controllerScripts
        GameObject gameController = GameObject.FindGameObjectWithTag("GameController");

        waveScript  = gameController.GetComponent <WaveController>();
        worldScript = gameController.GetComponent <WorldController> ();

        //Get the water mesh
        waterMesh = this.GetComponent <MeshFilter>().mesh;
        GenerateWaterMesh.GenerateWater(this.GetComponent <MeshFilter>(), worldScript.width, 0.5f, 0.0f);
        waterMesh = this.GetComponent <MeshFilter>().mesh;

        originalVertices = waterMesh.vertices;
    }
    // Use this for initialization
    void Start()
    {
        //Create water mesh
        waterMeshFilter = this.GetComponent <MeshFilter>();
        GenerateWaterMesh.GenerateWater(waterMeshFilter, waterWidth, gridSpacing);
        List <Vector3[]> height_tmp = GenerateWaterMesh.vertices2dArray;

        waterMesh = waterMeshFilter.mesh;
        //Need a box collider so the mouse can interact with the water
        BoxCollider boxCollider = this.GetComponent <BoxCollider>();

        boxCollider.size = new Vector3(waterWidth, 0.1f, waterWidth);

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

        //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;

        //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;
                }
            }
        }
    }
Esempio n. 5
0
    void Start()
    {
        waterMeshFilter = this.GetComponent <MeshFilter>();

        List <Vector3[]> height_tmp = GenerateWaterMesh.GenerateWater(waterMeshFilter, waterWidth, gridSpacing);

        waterMesh = waterMeshFilter.mesh;

        BoxCollider boxCollider = this.GetComponent <BoxCollider>();

        boxCollider.center = new Vector3(waterWidth / 2f, 0f, waterWidth / 2f);
        boxCollider.size   = new Vector3(waterWidth, 0.1f, waterWidth);

        transform.position = new Vector3(-waterWidth / 2f, 0f, -waterWidth / 2f);

        storedKernelArray = new float[P * 2 + 1, P * 2 + 1];
        PrecomputeKernelValues();

        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;

        //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;
                }
            }
        }
    }
Esempio n. 6
0
    void Start()
    {
        waterMeshFilter = this.GetComponent <MeshFilter>();
        List <Vector3[]> height_tmp = GenerateWaterMesh.GenerateWater(waterMeshFilter, waterWidth, gridSpacing);

        waterMesh = waterMeshFilter.mesh;

        BoxCollider boxCollider = this.GetComponent <BoxCollider>();

        boxCollider.center = new Vector3(waterWidth / 2.0f, 0.0f, waterWidth / 2.0f);
        boxCollider.size   = new Vector3(waterWidth, 0.1f, waterWidth);

        transform.position = new Vector3(-waterWidth / 2.0f, 0f, -waterWidth / 2.0f);

        //part 2
        storedKernelArray = new float[P * 2 + 1, P * 2 + 1];
        PrecomputeKernelValues();

        //part 2.2
        height             = height_tmp.ToArray();
        previousHeight     = CloneList(height);
        verticalDerivative = CloneList(height);
        source             = CloneList(height);
        obstruction        = CloneList(height);
        heightDifference   = CloneList(height);

        unfolded_verts = new Vector3[height.Length * height.Length];
        arrayLength    = height.Length;

        //add obstructions
        for (int x = 0; x < arrayLength; x++)
        {
            for (int y = 0; y < arrayLength; y++)
            {
                if (x == 0 || x == arrayLength - 1 || y == 0 || y == arrayLength - 1)
                {
                    obstruction[x][y].y = 0f;
                }
                else
                {
                    obstruction[x][y].y = 1f;
                }
            }
        }
    }
    // Use this for initialization
    void Start()
    {
        //Need reference to the meshfilter so we can add the water
        storedKernelArray = new float[P * 2 + 1, P * 2 + 1];

        PrecomputeKernelValues();
        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);

        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;

        //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);
    }
    void Start()
    {
        //Need reference to the meshfilter so we can add the water
        waterMeshFilter = this.GetComponent <MeshFilter>();

        waterWidth = this.transform.localScale.x * 10;

        //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 isW
        this.transform.position = new Vector3(-waterWidth / 2f, this.transform.position.y, -waterWidth / 2f);

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

        PrecomputeKernelValues();

        //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;



        //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;
                }
            }
        }
    }
    void Start()
    {
        surfaceRender = this.GetComponent <Renderer>();

        //initialization wave parameters
        direction  = new Vector4[waves.Length];
        depth      = new float[waves.Length];
        amplitude  = new float[waves.Length];
        velocity   = new float[waves.Length];
        wavelength = new float[waves.Length];
        WVT        = new float[waves.Length];
        steepness  = new float[waves.Length];
        SVT        = new float[waves.Length];

        //genereate water mesh and save
        waterMeshFilter = GetComponent <MeshFilter>();
        GenerateWaterMesh.GenerateWater(waterMeshFilter, waterWidth, gridSpacing);
        waterMesh = waterMeshFilter.mesh;
        AssetDatabase.CreateAsset(waterMesh, "Assets/demo/ProceduralWater/demoMeshes/" + "demoOceanPlane" + ".asset");

        //tesselation and oceanfloor setup
        surfaceRender.sharedMaterial.DisableKeyword("OCEAN_FLOOR_ON");
        surfaceRender.sharedMaterial.DisableKeyword("TESS_ON");
        if (enableTess)
        {
            surfaceRender.sharedMaterial.EnableKeyword("TESS_ON");
        }
        if (enableOceanFloor)
        {
            List <Vector3> meshVertices = new List <Vector3>();
            waterMesh.GetVertices(meshVertices);
            float[] terrainHeight = new float[meshVertices.Count];
            for (int i = 0; i < meshVertices.Count; i++)
            {
                Vector3 world_v = transform.localToWorldMatrix.MultiplyPoint3x4(meshVertices[i]);
                terrainHeight[i] = Terrain.activeTerrain.SampleHeight(world_v);
            }
            int verticePerRow = (int)Mathf.Sqrt(meshVertices.Count);

            oceanFloor        = new RenderTexture(verticePerRow, verticePerRow, 24);
            oceanFloor.format = RenderTextureFormat.ARGBFloat;
            Texture2D tempTexture = new Texture2D(verticePerRow, verticePerRow, TextureFormat.RGBAFloat, false);
            RenderTexture.active = oceanFloor;
            tempTexture.ReadPixels(new Rect(0, 0, oceanFloor.width, oceanFloor.height), 0, 0, false);
            for (int y = 0, i = 0; y < verticePerRow; y++)
            {
                for (int x = 0; x < verticePerRow; x++, i++)
                {
                    tempTexture.SetPixel(x, y, new Color(terrainHeight[i], 0, 0, 0));
                }
            }
            tempTexture.Apply();
            RenderTexture.active = null;
            Graphics.Blit(tempTexture, oceanFloor);
            surfaceRender.sharedMaterial.SetTexture("_OceanFloor", oceanFloor);
            surfaceRender.sharedMaterial.EnableKeyword("OCEAN_FLOOR_ON");
        }

        // reflection cubemap
        GameObject CubeCam = new GameObject("CubeCam");

        CubeCam.AddComponent <Camera>();
        CubeCam.transform.position = new Vector3(0, 10, 0);
        CubeCam.transform.rotation = Quaternion.identity;
        CubeCam.GetComponent <Camera>().RenderToCubemap(reflCubemap);
        DestroyImmediate(CubeCam);
    }
    void Start()
    {
        surfaceRender = this.GetComponent <Renderer>();

        //initialize shallow wave parameters
        direction_SW  = new Vector4[shallowWaves.Length];
        depth_SW      = new float[shallowWaves.Length];
        amplitude_SW  = new float[shallowWaves.Length];
        velocity_SW   = new float[shallowWaves.Length];
        wavelength_SW = new float[shallowWaves.Length];
        WVT_SW        = new float[shallowWaves.Length];
        steepness_SW  = new float[shallowWaves.Length];
        SVT_SW        = new float[shallowWaves.Length];

        //initialize gerstner wave parameters
        direction_GW  = new Vector4[gerstnerWaves.Length];
        steepness_GW  = new float[gerstnerWaves.Length];
        amplitude_GW  = new float[gerstnerWaves.Length];
        velocity_GW   = new float[gerstnerWaves.Length];
        wavelength_GW = new float[gerstnerWaves.Length];

        //genereate water mesh and save
        waterMeshFilter = GetComponent <MeshFilter>();
        GenerateWaterMesh.GenerateWater(waterMeshFilter, waterWidth, gridSpacing);
        waterMesh = waterMeshFilter.mesh;
        #if UNITY_EDITOR
        AssetDatabase.CreateAsset(waterMesh, "Assets/demo/IntegratedWater/" + "IntegratedWaterOceanPlane" + ".asset");
        #endif

        //Need a box collider so object can interact with the water
        BoxCollider boxCollider = GetComponent <BoxCollider>();
        boxCollider.size = new Vector3(waterWidth, 0.1f, waterWidth);

        //oceanfloor setup
        surfaceRender.sharedMaterial.DisableKeyword("OCEAN_FLOOR_ON");
        if (enableOceanFloor)
        {
            List <Vector3> meshVertices = new List <Vector3>();
            waterMesh.GetVertices(meshVertices);
            Vector3[] terrainPosition = new Vector3[meshVertices.Count];
            for (int i = 0; i < meshVertices.Count; i++)
            {
                Vector3 world_v = transform.localToWorldMatrix.MultiplyPoint3x4(meshVertices[i]);
                terrainPosition[i].y = Terrain.activeTerrain.SampleHeight(world_v);
                terrainPosition[i].x = meshVertices[i].x;
                terrainPosition[i].z = meshVertices[i].z;
            }
            int verticePerRow = (int)Mathf.Sqrt(meshVertices.Count);

            oceanFloor        = new RenderTexture(verticePerRow, verticePerRow, 24);
            oceanFloor.format = RenderTextureFormat.ARGBFloat;
            Texture2D tempTexture = new Texture2D(verticePerRow, verticePerRow, TextureFormat.RGBAFloat, false);
            RenderTexture.active = oceanFloor;
            tempTexture.ReadPixels(new Rect(0, 0, oceanFloor.width, oceanFloor.height), 0, 0, false);
            for (int y = 0, i = 0; y < verticePerRow; y++)
            {
                for (int x = 0; x < verticePerRow; x++, i++)
                {
                    tempTexture.SetPixel(x, y, new Color(terrainPosition[i].x, terrainPosition[i].y, terrainPosition[i].z, 0));
                }
            }
            tempTexture.Apply();
            RenderTexture.active = null;
            Graphics.Blit(tempTexture, oceanFloor);
            surfaceRender.sharedMaterial.SetTexture("_OceanFloor", oceanFloor);
            surfaceRender.sharedMaterial.EnableKeyword("OCEAN_FLOOR_ON");
        }

        // reflection cubemap
        GameObject CubeCam = new GameObject("CubeCam");
        CubeCam.AddComponent <Camera>();
        CubeCam.transform.position = new Vector3(0, 10, 0);
        CubeCam.transform.rotation = Quaternion.identity;
        CubeCam.GetComponent <Camera>().RenderToCubemap(reflCubemap);
        DestroyImmediate(CubeCam);
    }