Example #1
0
        /// <summary>
        /// Generate a HalfEdgeMesh of a Cube.
        /// </summary>
        /// <param name="origin">The Origin of the Cube.</param>
        /// <param name="size">The Size of the Cube.</param>
        /// <param name="sides">Defines which Sides of the Cube should be generated (default = All Sides).</param>
        /// <param name="calculateNormals">Calculate Vertex Normals or not.</param>
        /// <returns>The generated HalfEdgeMesh.</returns>
        public static HalfEdgeMesh GenerateCube(Vector origin,
                                                float size = 1, CubeSides sides = CubeSides.All, bool calculateNormals = false)
        {
            var vertices = new List <Vertex>()
            {
                new Vertex(origin.X, origin.Y, origin.Z),
                new Vertex(1 * size + origin.X, origin.Y, origin.Z),
                new Vertex(1 * size + origin.X, 1 * size + origin.Y, origin.Z),
                new Vertex(origin.X, 1 * size + origin.Y, origin.Z),
                new Vertex(origin.X, origin.Y, 1 * size + origin.Z),
                new Vertex(1 * size + origin.X, origin.Y, 1 * size + origin.Z),
                new Vertex(1 * size + origin.X, 1 * size + origin.Y, 1 * size + origin.Z),
                new Vertex(origin.X, 1 * size + origin.Y, 1 * size + origin.Z),
            };

            var triangles = new List <Triangle>();

            if (sides.HasFlag(CubeSides.NegativeZ))
            {
                triangles.Add(new Triangle(0, 2, 1));
                triangles.Add(new Triangle(0, 3, 2));
            }
            if (sides.HasFlag(CubeSides.PositiveZ))
            {
                triangles.Add(new Triangle(4, 5, 6));
                triangles.Add(new Triangle(4, 6, 7));
            }
            if (sides.HasFlag(CubeSides.NegativeY))
            {
                triangles.Add(new Triangle(0, 1, 5));
                triangles.Add(new Triangle(0, 5, 4));
            }
            if (sides.HasFlag(CubeSides.PositiveX))
            {
                triangles.Add(new Triangle(1, 2, 6));
                triangles.Add(new Triangle(1, 6, 5));
            }
            if (sides.HasFlag(CubeSides.PositiveY))
            {
                triangles.Add(new Triangle(2, 3, 7));
                triangles.Add(new Triangle(2, 7, 6));
            }
            if (sides.HasFlag(CubeSides.NegativeX))
            {
                triangles.Add(new Triangle(3, 0, 4));
                triangles.Add(new Triangle(3, 4, 7));
            }

            var mesh = new HalfEdgeMesh(vertices, triangles);

            if (calculateNormals)
            {
                mesh.CalculateVertexNormals();
            }

            return(mesh);
        }
Example #2
0
        /// <summary>
        /// Generate a HalfEdgeMesh of a Sphere.
        /// </summary>
        /// <param name="center">The Center of the Sphere.</param>
        /// <param name="radius">The Radius of the Sphere.</param>
        /// <param name="numSides">Number of Sides of the Sphere (multiply by 4 for one Ring).</param>
        /// <param name="sides">Which Sides of the Sphere should be generated.</param>
        /// <param name="calculateNormals">Calculate Vertex Normals or not.</param>
        /// <returns>The generated HalfEdgeMesh.</returns>
        public static HalfEdgeMesh GenerateSphere(Vector center,
                                                  float radius = 1, int numSides = 8, CubeSides sides = CubeSides.All, bool calculateNormals = false)
        {
            var shiftVector     = Vector.One * 0.5f;
            var mesh            = new HalfEdgeMesh();
            var sideLength      = 1f / numSides;
            var verticesPerSide = numSides + 1;
            var vertices        = new List <Vertex>();

            var bottomVertices = new List <Vertex>(verticesPerSide * verticesPerSide);
            var topVertices    = new List <Vertex>(verticesPerSide * verticesPerSide);
            var frontVertices  = new List <Vertex>(verticesPerSide * verticesPerSide);
            var backVertices   = new List <Vertex>(verticesPerSide * verticesPerSide);
            var leftVertices   = new List <Vertex>(verticesPerSide * verticesPerSide);
            var rightVertices  = new List <Vertex>(verticesPerSide * verticesPerSide);
            var idx            = 0;

            for (int z = 0; z <= numSides; z++)
            {
                for (int y = 0; y <= numSides; y++)
                {
                    for (int x = 0; x <= numSides; x++)
                    {
                        if (z == 0 || z == numSides || x == 0 || x == numSides || y == 0 || y == numSides)
                        {
                            var vertex = new Vertex(x * sideLength - 0.5f, y * sideLength - 0.5f, z * sideLength - 0.5f)
                            {
                                Index = idx,
                            };
                            if (x == 0 && sides.HasFlag(CubeSides.NegativeZ))
                            {
                                bottomVertices.Add(vertex);
                            }
                            else if (x == numSides && sides.HasFlag(CubeSides.PositiveZ))
                            {
                                topVertices.Add(vertex);
                            }

                            if (y == 0 && sides.HasFlag(CubeSides.NegativeY))
                            {
                                frontVertices.Add(vertex);
                            }
                            else if (y == numSides && sides.HasFlag(CubeSides.PositiveY))
                            {
                                backVertices.Add(vertex);
                            }

                            if (z == 0 && sides.HasFlag(CubeSides.NegativeX))
                            {
                                leftVertices.Add(vertex);
                            }
                            else if (z == numSides && sides.HasFlag(CubeSides.PositiveX))
                            {
                                rightVertices.Add(vertex);
                            }

                            vertices.Add(vertex);
                            idx++;
                        }
                        else
                        {
                            x += numSides - 2;
                        }
                    }
                }
            }

            foreach (var vertex in vertices)
            {
                var vertexVector = (Vector)vertex;
                vertexVector.Normalize();
                vertex.Position = vertexVector * radius + center;
            }
            mesh.AddVertices(vertices);

            var triangles = new List <Triangle>();

            for (int i = 0; i < numSides * numSides; i++)
            {
                idx = i + i / numSides;
                var nextIdx        = idx + 1;
                var nextRowIdx     = nextIdx + numSides;
                var nextRowNextIdx = nextRowIdx + 1;
                if (sides.HasFlag(CubeSides.NegativeZ))
                {
                    mesh.AddTriangle(new Triangle(bottomVertices[idx].Index, bottomVertices[nextRowNextIdx].Index, bottomVertices[nextIdx].Index));
                    mesh.AddTriangle(new Triangle(bottomVertices[idx].Index, bottomVertices[nextRowIdx].Index, bottomVertices[nextRowNextIdx].Index));
                }

                if (sides.HasFlag(CubeSides.PositiveZ))
                {
                    mesh.AddTriangle(new Triangle(topVertices[idx].Index, topVertices[nextIdx].Index, topVertices[nextRowNextIdx].Index));
                    mesh.AddTriangle(new Triangle(topVertices[idx].Index, topVertices[nextRowNextIdx].Index, topVertices[nextRowIdx].Index));
                }

                if (sides.HasFlag(CubeSides.NegativeY))
                {
                    mesh.AddTriangle(new Triangle(frontVertices[idx].Index, frontVertices[nextIdx].Index, frontVertices[nextRowNextIdx].Index));
                    mesh.AddTriangle(new Triangle(frontVertices[idx].Index, frontVertices[nextRowNextIdx].Index, frontVertices[nextRowIdx].Index));
                }

                if (sides.HasFlag(CubeSides.PositiveY))
                {
                    mesh.AddTriangle(new Triangle(backVertices[idx].Index, backVertices[nextRowNextIdx].Index, backVertices[nextIdx].Index));
                    mesh.AddTriangle(new Triangle(backVertices[idx].Index, backVertices[nextRowIdx].Index, backVertices[nextRowNextIdx].Index));
                }

                if (sides.HasFlag(CubeSides.NegativeX))
                {
                    mesh.AddTriangle(new Triangle(leftVertices[idx].Index, leftVertices[nextRowNextIdx].Index, leftVertices[nextIdx].Index));
                    mesh.AddTriangle(new Triangle(leftVertices[idx].Index, leftVertices[nextRowIdx].Index, leftVertices[nextRowNextIdx].Index));
                }

                if (sides.HasFlag(CubeSides.PositiveX))
                {
                    mesh.AddTriangle(new Triangle(rightVertices[idx].Index, rightVertices[nextIdx].Index, rightVertices[nextRowNextIdx].Index));
                    mesh.AddTriangle(new Triangle(rightVertices[idx].Index, rightVertices[nextRowNextIdx].Index, rightVertices[nextRowIdx].Index));
                }
            }

            if (calculateNormals)
            {
                mesh.CalculateVertexNormals();
            }

            return(mesh);
        }
Example #3
0
    private void moveCameraToRight()
    {
        current = current.right();

        Camera.main.transform.RotateAround(Vector3.zero, Vector3.up, -90f);
    }
Example #4
0
    // This function creates a cube's face and apply a texture on it, as well as a mesh filter and renderer
    public void CreateFace(CubeSides face)
    {
        // VERTICES
        // List all the coordinates of the vertices on a cube
        Vector3 vertex1 = new Vector3(0.5f, -0.5f, -0.5f);
        Vector3 vertex2 = new Vector3(0.5f, -0.5f, 0.5f);
        Vector3 vertex3 = new Vector3(0.5f, 0.5f, -0.5f);
        Vector3 vertex4 = new Vector3(0.5f, 0.5f, 0.5f);
        Vector3 vertex5 = new Vector3(-0.5f, -0.5f, -0.5f);
        Vector3 vertex6 = new Vector3(-0.5f, -0.5f, 0.5f);
        Vector3 vertex7 = new Vector3(-0.5f, 0.5f, -0.5f);
        Vector3 vertex8 = new Vector3(-0.5f, 0.5f, 0.5f);

        // UVs
        // List all the uvs on a cube
        Vector2 uvBottomLeft;
        Vector2 uvBottomRight;
        Vector2 uvTopLeft;
        Vector2 uvTopRight;

        // TEXTURES' INDEX
        // Determine wish texture to apply on each type of face, depending on
        // the world's type
        int topTopIndex    = 3 * (int)World.worldType;
        int topSideIndex   = topTopIndex + 1;
        int underSideIndex = topTopIndex + 2;

        // SETTING TEXTURES
        // Actually sets the texture on the face, depending on it's type
        if (this.isOnTheSurface && face == CubeSides.TOP)
        {
            uvBottomLeft  = this.cubeTextureInAtlas[topTopIndex, 0];
            uvBottomRight = this.cubeTextureInAtlas[topTopIndex, 1];
            uvTopLeft     = this.cubeTextureInAtlas[topTopIndex, 2];
            uvTopRight    = this.cubeTextureInAtlas[topTopIndex, 3];
        }

        else if (this.isOnTheSurface && face != CubeSides.TOP)
        {
            uvBottomLeft  = this.cubeTextureInAtlas[topSideIndex, 0];
            uvBottomRight = this.cubeTextureInAtlas[topSideIndex, 1];
            uvTopLeft     = this.cubeTextureInAtlas[topSideIndex, 2];
            uvTopRight    = this.cubeTextureInAtlas[topSideIndex, 3];
        }

        else
        {
            uvBottomLeft  = this.cubeTextureInAtlas[underSideIndex, 0];
            uvBottomRight = this.cubeTextureInAtlas[underSideIndex, 1];
            uvTopLeft     = this.cubeTextureInAtlas[underSideIndex, 2];
            uvTopRight    = this.cubeTextureInAtlas[underSideIndex, 3];
        }

        // MESH'S VARIABLES
        Vector3[] vertices  = new Vector3[4];
        Vector3[] normals   = new Vector3[4];
        Vector2[] uvs       = new Vector2[4];
        int[]     triangles = new int[6];

        // SIDES
        // Determine the mesh's variables depending on the face's type
        switch (face)
        {
        case CubeSides.BOTTOM:
            vertices = new Vector3[] { vertex6, vertex2, vertex1, vertex5 };
            normals  = new Vector3[] { Vector3.down, Vector3.down, Vector3.down, Vector3.down };
            uvs      = new Vector2[] { uvTopRight, uvTopLeft, uvBottomLeft, uvBottomRight };
            break;

        case CubeSides.TOP:
            vertices = new Vector3[] { vertex7, vertex3, vertex4, vertex8 };
            normals  = new Vector3[] { Vector3.up, Vector3.up, Vector3.up, Vector3.up };
            uvs      = new Vector2[] { uvTopRight, uvTopLeft, uvBottomLeft, uvBottomRight };
            break;

        case CubeSides.LEFT:
            vertices = new Vector3[] { vertex7, vertex8, vertex6, vertex5 };
            normals  = new Vector3[] { Vector3.left, Vector3.left, Vector3.left, Vector3.left };
            uvs      = new Vector2[] { uvTopRight, uvTopLeft, uvBottomLeft, uvBottomRight };
            break;

        case CubeSides.RIGHT:
            vertices = new Vector3[] { vertex4, vertex3, vertex1, vertex2 };
            normals  = new Vector3[] { Vector3.right, Vector3.right, Vector3.right, Vector3.right };
            uvs      = new Vector2[] { uvTopRight, uvTopLeft, uvBottomLeft, uvBottomRight };
            break;

        case CubeSides.FRONT:
            vertices = new Vector3[] { vertex8, vertex4, vertex2, vertex6 };
            normals  = new Vector3[] { Vector3.forward, Vector3.forward, Vector3.forward, Vector3.forward };
            uvs      = new Vector2[] { uvTopRight, uvTopLeft, uvBottomLeft, uvBottomRight };
            break;

        case CubeSides.BACK:
            vertices = new Vector3[] { vertex3, vertex7, vertex5, vertex1 };
            normals  = new Vector3[] { Vector3.back, Vector3.back, Vector3.back, Vector3.back };
            uvs      = new Vector2[] { uvTopRight, uvTopLeft, uvBottomLeft, uvBottomRight };
            break;
        }

        triangles = new int[] { 3, 1, 0, 3, 2, 1 };

        // MESH
        // Create a new mesh and initialize it's variables with the ones which
        // where chosen
        Mesh mesh = new Mesh
        {
            name      = "FaceMesh" + face.ToString(),
            vertices  = vertices,
            normals   = normals,
            uv        = uvs,
            triangles = triangles
        };

        mesh.RecalculateBounds();

        // Creates a game object instantiating the face
        GameObject side = new GameObject("Side");

        side.transform.position = this.position;
        side.transform.parent   = this.parent.transform;

        // Apply a mesh filter and a mesh renderer on the face
        MeshFilter meshFilter = (MeshFilter)side.AddComponent(typeof(MeshFilter));

        meshFilter.mesh = mesh;

        MeshRenderer renderer = side.AddComponent(typeof(MeshRenderer)) as MeshRenderer;

        renderer.material = this.material;
    }
Example #5
0
    private void moveCameraToLeft()
    {
        current = current.left();

        Camera.main.transform.RotateAround(Vector3.zero, Vector3.up, 90f);
    }