Example #1
0
    public static Ground.Vertex BuildVertex(float[] vertexData)
    {
        Ground.Vertex v = new Ground.Vertex();

        v.position = new Vector3(vertexData[0], vertexData[1], vertexData[2]);
        v.normal   = Vector3.up;
        v.texCoord = new Vector2(vertexData[3], vertexData[4]);

        return(v);
    }
Example #2
0
    public void BuildMesh(GND.Mesh compiledMesh)
    {
        meshes = new Mesh[(int)Math.Ceiling(compiledMesh.waterVertCount / (float)MapRenderer.MAX_VERTICES)];

        for (int nMesh = 0; nMesh < meshes.Length; nMesh++)
        {
            List <Vector3> vertices  = new List <Vector3>();
            List <int>     triangles = new List <int>();
            List <Vector3> normals   = new List <Vector3>();
            List <Vector2> uv        = new List <Vector2>();

            float[] vertexData = new float[5];
            for (int i = 0, ended = 0; vertices.Count < MapRenderer.MAX_VERTICES && ended == 0; i++)
            {
                Ground.Vertex[] vs = new Ground.Vertex[4];
                for (int j = 0; j < 4; j++)
                {
                    var vIndex = i * 4 + j + nMesh * MapRenderer.MAX_VERTICES;

                    if (vIndex * vertexData.Length >= compiledMesh.waterMesh.Length)
                    {
                        ended = 1;
                        break;
                    }

                    Array.ConstrainedCopy(compiledMesh.waterMesh, vIndex * vertexData.Length, vertexData, 0, vertexData.Length);
                    Ground.Vertex vertex = BuildVertex(vertexData);
                    vs[j] = vertex;
                    vertices.Add(vertex.position);
                    normals.Add(vertex.normal);
                    uv.Add(vertex.texCoord);
                }

                if (ended == 0)
                {
                    triangles.AddRange(new int[] {
                        i * 4 + 0, i * 4 + 2, i * 4 + 3, //left triangle
                        i * 4 + 0, i * 4 + 1, i * 4 + 2, //right triangle
                    });
                }
            }

            Mesh mesh = new Mesh();
            mesh.vertices  = vertices.ToArray();
            mesh.triangles = triangles.ToArray();
            mesh.normals   = normals.ToArray();
            mesh.uv        = uv.ToArray();

            meshes[nMesh] = mesh;
        }

        objects = new GameObject[meshes.Length];

        renderers = new MeshRenderer[meshes.Length];

        GameObject water = new GameObject("_Water");

        water.transform.parent = MapRenderer.mapParent.transform;

        for (int i = 0; i < meshes.Length; i++)
        {
            Mesh mesh = meshes[i];

            GameObject gameObject = new GameObject("Water[" + i + "]");
            gameObject.transform.parent = water.transform;
            gameObject.layer            = 4;
            var mf = gameObject.AddComponent <MeshFilter>();
            mf.mesh = mesh;
            var mr = gameObject.AddComponent <MeshRenderer>();
            renderers[i]            = mr;
            mr.material             = material;
            mr.material.mainTexture = textures[0];

            Vector3 scale = gameObject.transform.localScale;
            scale.Set(1f, -1f, 1f);
            gameObject.transform.localScale = scale;

            objects[i] = gameObject;
        }

        material.SetFloat("Wave Height", info.waveHeight);
        material.SetFloat("Wave Pitch", info.wavePitch);
    }