コード例 #1
0
        /// <summary>
        /// Combines an array of GeometryPrimitives into a single primitive.
        /// The order and all characteristics of the vertices are preserved.
        /// </summary>
        /// <param name="primitives"></param>
        /// <returns></returns>
        public static GeometryPrimitive Combine(GeometryPrimitive[] primitives)
        {
            int numVertices = 0;
            int numIndices = 0;

            for (int i = 0; i < primitives.Length; i++)
            {
                numVertices += primitives[i].Vertices.Length;
                numIndices += primitives[i].Indices.Length;
            }

            GeometryPrimitive output = new GeometryPrimitive();

            output.Vertices = new VertexPositionNormalTexture[numVertices];
            output.Indices = new int[numIndices];

            int vertIndex = 0;
            int indIndex = 0;

            for (int i = 0; i < primitives.Length; i++)
            {
                for (int j = 0; j < primitives[i].Vertices.Length; j++)
                    output.Vertices[j + vertIndex] = primitives[i].Vertices[j];

                for (int j = 0; j < primitives[i].Indices.Length; j++)
                    output.Indices[j + indIndex] = primitives[i].Indices[j] + vertIndex;

                vertIndex += primitives[i].Vertices.Length;
                indIndex += primitives[i].Indices.Length;
            }

            return output;
        }
コード例 #2
0
ファイル: ScootBlock.cs プロジェクト: rodya-mirov/Voxelist
        public static void LoadContent(Game game)
        {
            entityPrimitive = GeometryPrimitive.Make3DRectangle(
                Vector3.One * buffer, Vector3.One * size,
                Vector2.Zero, new Vector2(1.0f, 1.0f),
                true, true, true, true, true, true);

            texture = game.Content.Load<Texture2D>("Textures/Cubes/Dirt");
        }
コード例 #3
0
ファイル: Chunk.cs プロジェクト: rodya-mirov/Voxelist
        /// <summary>
        /// Recalculates the Visual geometry for the Chunk.  The supplied chunks can be null;
        /// if not, will be used for visual occlusion (if null, will be assumed see-through).
        /// </summary>
        public void RecalculateVisualGeometry()
        {
            Chunk leftChunk, rightChunk, forwardChunk, backwardChunk;
            LoadNeighborChunks(out leftChunk, out rightChunk, out forwardChunk, out backwardChunk);

            GeometryPrimitive[] newCombinedPrimitives = new GeometryPrimitive[BlockHandler.TotalNumberOfTextures];
            int[] newCombinedVerticesCount = new int[BlockHandler.TotalNumberOfTextures];
            int[] newCombinedTrianglesCount = new int[BlockHandler.TotalNumberOfTextures];
            bool[] newUsesTextureIndex = new bool[BlockHandler.TotalNumberOfTextures];

            float visualXMin = GameConstants.CHUNK_X_WIDTH;
            float visualXMax = 0;

            float visualYMin = GameConstants.CHUNK_Y_HEIGHT;
            float visualYMax = 0;

            float visualZMin = GameConstants.CHUNK_Z_LENGTH;
            float visualZMax = 0;

            for (int textureIndex = 0; textureIndex < BlockHandler.TotalNumberOfTextures; textureIndex++)
            {
                List<GeometryPrimitive> buildingBlocks = new List<GeometryPrimitive>();

                for (int x = 0; x < GameConstants.CHUNK_X_WIDTH; x++)
                {
                    for (int y = 0; y < GameConstants.CHUNK_Y_HEIGHT; y++)
                    {
                        for (int z = 0; z < GameConstants.CHUNK_Z_LENGTH; z++)
                        {
                            Block relevantBlock = this[x, y, z];

                            if (!BlockHandler.IsVisible(relevantBlock) || BlockHandler.TextureIndex(relevantBlock) != textureIndex)
                                continue;

                            bool includeFrontFace, includeBackFace;
                            bool includeTopFace, includeBottomFace;
                            bool includeLeftFace, includeRightFace;

                            MakeOcclusionTags(x, y, z,
                                out includeFrontFace, out includeBackFace,
                                out includeTopFace, out includeBottomFace,
                                out includeLeftFace, out includeRightFace,
                                leftChunk, rightChunk,
                                forwardChunk, backwardChunk);

                            bool hasVisibleFace = (includeTopFace || includeBottomFace || includeBackFace || includeFrontFace || includeRightFace || includeLeftFace);

                            if (!hasVisibleFace)
                                continue;

                            visualXMin = MathHelper.Min(visualXMin, x);
                            visualXMax = MathHelper.Max(visualXMax, x + 1);

                            visualYMin = MathHelper.Min(visualYMin, y);
                            visualYMax = MathHelper.Max(visualYMax, y + 1);

                            visualZMin = MathHelper.Min(visualZMin, z);
                            visualZMax = MathHelper.Max(visualZMax, z + 1);

                            GeometryPrimitive drawingPrimitive = BlockHandler.DrawingPrimitive(relevantBlock,
                                includeFrontFace, includeBackFace, includeTopFace, includeBottomFace,
                                includeLeftFace, includeRightFace);

                            if (drawingPrimitive.Vertices.Length > 0)
                                buildingBlocks.Add(drawingPrimitive.Translate(new Vector3(x, y, z)));
                        }
                    }
                }

                GeometryPrimitive[] primitivesArray = new GeometryPrimitive[buildingBlocks.Count];
                buildingBlocks.CopyTo(primitivesArray);

                newUsesTextureIndex[textureIndex] = (primitivesArray.Length > 0);

                if (newUsesTextureIndex[textureIndex])
                {
                    newCombinedPrimitives[textureIndex] = GeometryPrimitive.Combine(primitivesArray);
                }
            }

            lock (this)
            {
                combinedPrimitives = newCombinedPrimitives;
                usesTextureIndex = newUsesTextureIndex;

                visualBoundingBox = new BoundingBox(
                    new Vector3(visualXMin, visualYMin, visualZMin),
                    new Vector3(visualXMax, visualYMax, visualZMax));
            }
        }
コード例 #4
0
        /// <summary>
        /// This constructs a 3D rectangle (interval in 3-space if you prefer) with the 
        /// specified "minimal corner" and size vector.  Minimal corner means the point where
        /// x, y, and z are all lowest, and size should be a strictly positive vector in all
        /// components.
        /// 
        /// There are a big pile of optional bools, indicating which (if any) faces to include.
        /// </summary>
        /// <param name="minimalCorner">Corner where x, y, and z are minimal.</param>
        /// <param name="size">Positive vector expressing the x, y, and z size.</param>
        /// <param name="textureMinimalCorner">Where the relevant part of the texture starts, in UV coordinates.</param>
        /// <param name="textureSize">How big the relevant part of the texture is, in UV coordinates.</param>
        /// <returns></returns>
        public static GeometryPrimitive Make3DRectangle(Vector3 minimalCorner, Vector3 size,
            Vector2 textureMinimalCorner, Vector2 textureSize,
            bool includeFrontFace, bool includeBackFace,
            bool includeTopFace, bool includeBottomFace,
            bool includeLeftFace, bool includeRightFace)
        {
            int faceCount = 0;

            if (includeFrontFace) faceCount++;
            if (includeBackFace) faceCount++;
            if (includeTopFace) faceCount++;
            if (includeBottomFace) faceCount++;
            if (includeLeftFace) faceCount++;
            if (includeRightFace) faceCount++;

            //physical dimensions
            float xmin = minimalCorner.X;
            float xmid = minimalCorner.X + (size.X / 2.0f);
            float xmax = minimalCorner.X + size.X;

            float xSize = size.X;

            float ymin = minimalCorner.Y;
            float ymid = minimalCorner.Y + (size.Y / 2.0f);
            float ymax = minimalCorner.Y + size.Y;

            float ySize = size.Y;

            float zmin = minimalCorner.Z;
            float zmid = minimalCorner.Z + (size.Z / 2.0f);
            float zmax = minimalCorner.Z + size.Z;

            float zSize = size.Z;

            //texture dimensions
            float texIncX = textureSize.X * 0.25f; //texture increment x
            float texIncY = textureSize.Y * 0.25f;  //texture increment y

            Vector2 faceTextureSize = new Vector2(texIncX, texIncY);

            //and now for the geometry!
            GeometryPrimitive[] faces = new GeometryPrimitive[faceCount];

            int faceIndex = 0;

            //Front face
            if (includeFrontFace)
            {
                faces[faceIndex++] = GeometryPrimitive.MakeRectangle(
                    new Vector3(xmid, ymid, zmin),
                    Vector3.Forward, Vector3.Up,
                    new Vector2(texIncX, 2.0f * texIncY) + textureMinimalCorner,
                    faceTextureSize,
                    xSize, ySize);
            }

            //Back face
            if (includeBackFace)
            {
                faces[faceIndex++] = GeometryPrimitive.MakeRectangle(
                    new Vector3(xmid, ymid, zmax),
                    Vector3.Backward, Vector3.Down,
                    new Vector2(texIncX, 0) + textureMinimalCorner,
                    faceTextureSize,
                    xSize, ySize);
            }

            //top face
            if (includeTopFace)
            {
                faces[faceIndex++] = GeometryPrimitive.MakeRectangle(
                    new Vector3(xmid, ymax, zmid),
                    Vector3.Up, Vector3.Forward,
                    new Vector2(texIncX, texIncY) + textureMinimalCorner,
                    faceTextureSize,
                    xSize, zSize);
            }

            //bottom face
            if (includeBottomFace)
            {
                faces[faceIndex++] = GeometryPrimitive.MakeRectangle(
                    new Vector3(xmid, ymin, zmid),
                    Vector3.Down, Vector3.Forward,
                    new Vector2(texIncX, 3.0f * texIncY) + textureMinimalCorner,
                    faceTextureSize,
                    xSize, zSize);
            }

            //left face
            if (includeLeftFace)
            {
                faces[faceIndex++] = GeometryPrimitive.MakeRectangle(
                    new Vector3(xmin, ymid, zmid),
                    Vector3.Left, Vector3.Forward,
                    new Vector2(0, texIncY) + textureMinimalCorner,
                    faceTextureSize,
                    ySize, zSize);
            }

            //right face
            if (includeRightFace)
            {
                faces[faceIndex++] = GeometryPrimitive.MakeRectangle(
                    new Vector3(xmax, ymid, zmid),
                    Vector3.Right, Vector3.Forward,
                    new Vector2(2.0f * texIncX, texIncY) + textureMinimalCorner,
                    faceTextureSize,
                    ySize, zSize);
            }

            return GeometryPrimitive.Combine(faces);
        }
コード例 #5
0
        /// <summary>
        /// Translates the given GeometryPrimitive by the specified vector.
        /// </summary>
        /// <param name="original"></param>
        /// <param name="translation"></param>
        /// <returns></returns>
        public GeometryPrimitive Translate(Vector3 translation)
        {
            GeometryPrimitive output = new GeometryPrimitive();

            output.Indices = new int[Indices.Length];
            output.Vertices = new VertexPositionNormalTexture[Vertices.Length];

            for (int i = 0; i < Indices.Length; i++)
                output.Indices[i] = Indices[i];

            for (int i = 0; i < Vertices.Length; i++)
            {
                output.Vertices[i] = Vertices[i];
                output.Vertices[i].Position += translation;
            }

            return output;
        }
コード例 #6
0
        /// <summary>
        /// Constructs a new GeometryPrimitive from this original and a scaling factor.
        /// </summary>
        /// <param name="scalingFactor"></param>
        /// <returns></returns>
        public GeometryPrimitive Scale(float scalingFactor)
        {
            GeometryPrimitive output = new GeometryPrimitive();

            output.Indices = new int[Indices.Length];
            output.Vertices = new VertexPositionNormalTexture[Vertices.Length];

            for (int i = 0; i < Indices.Length; i++)
                output.Indices[i] = Indices[i];

            for (int i = 0; i < Vertices.Length; i++)
            {
                output.Vertices[i] = Vertices[i];
                output.Vertices[i].Position *= scalingFactor;
            }

            return output;
        }
コード例 #7
0
        /// <summary>
        /// This is exactly like the Make3DRectangle method, including texture usage,
        /// except that all the faces are looking IN (as would be expected).  So you
        /// can hang this around the camera and that'll look fine.
        /// </summary>
        /// <param name="minimalCorner"></param>
        /// <param name="size"></param>
        /// <param name="textureMinimalCorner"></param>
        /// <param name="textureSize"></param>
        /// <returns></returns>
        public static GeometryPrimitive MakeSkybox(Vector3 minimalCorner, Vector3 size,
            Vector2 textureMinimalCorner, Vector2 textureSize)
        {
            //physical dimensions
            float xmin = minimalCorner.X;
            float xmid = minimalCorner.X + (size.X / 2.0f);
            float xmax = minimalCorner.X + size.X;

            float xSize = size.X;

            float ymin = minimalCorner.Y;
            float ymid = minimalCorner.Y + (size.Y / 2.0f);
            float ymax = minimalCorner.Y + size.Y;

            float ySize = size.Y;

            float zmin = minimalCorner.Z;
            float zmid = minimalCorner.Z + (size.Z / 2.0f);
            float zmax = minimalCorner.Z + size.Z;

            float zSize = size.Z;

            //texture dimensions
            float texIncX = textureSize.X * 0.25f; //texture increment x
            float texIncY = textureSize.Y * 0.25f;  //texture increment y

            Vector2 faceTextureSize = new Vector2(texIncX, texIncY);

            //and now for the geometry!
            GeometryPrimitive[] faces = new GeometryPrimitive[6];

            //Front face
            faces[0] = GeometryPrimitive.MakeRectangle(
                new Vector3(xmid, ymid, zmin),
                Vector3.Backward, Vector3.Up,
                new Vector2(texIncX, 2.0f * texIncY) + textureMinimalCorner,
                faceTextureSize,
                xSize, ySize);

            //Back face
            faces[1] = GeometryPrimitive.MakeRectangle(
                new Vector3(xmid, ymid, zmax),
                Vector3.Forward, Vector3.Down,
                new Vector2(texIncX, 0) + textureMinimalCorner,
                faceTextureSize,
                xSize, ySize);

            //top face
            faces[2] = GeometryPrimitive.MakeRectangle(
                new Vector3(xmid, ymax, zmid),
                Vector3.Down, Vector3.Backward,
                new Vector2(texIncX, texIncY) + textureMinimalCorner,
                faceTextureSize,
                xSize, zSize);

            //bottom face
            faces[3] = GeometryPrimitive.MakeRectangle(
                new Vector3(xmid, ymin, zmid),
                Vector3.Up, Vector3.Forward,
                new Vector2(texIncX, 3.0f * texIncY) + textureMinimalCorner,
                faceTextureSize,
                xSize, zSize);

            //left face
            faces[4] = GeometryPrimitive.MakeRectangle(
                new Vector3(xmin, ymid, zmid),
                Vector3.Right, Vector3.Backward,
                new Vector2(0, texIncY) + textureMinimalCorner,
                faceTextureSize,
                zSize, ySize);

            //right face
            faces[5] = GeometryPrimitive.MakeRectangle(
                new Vector3(xmax, ymid, zmid),
                Vector3.Left, Vector3.Backward,
                new Vector2(2.0f * texIncX, texIncY) + textureMinimalCorner,
                faceTextureSize,
                zSize, ySize);

            return GeometryPrimitive.Combine(faces);
        }
コード例 #8
0
        /// <summary>
        /// Construct a rectangle at the specified location, which displays a
        /// portion of a texture.
        /// </summary>
        /// <param name="center">The center of the rectangle.</param>
        /// <param name="normal">UNIT VECTOR facing directly out of the rectangle.
        /// If you're facing the rectangle (and you want it to be visible)
        /// then this should be pointing at you.</param>
        /// <param name="up">UNIT VECTOR pointing in the direction that should be
        /// "up" on the texture.  Messing this up may flip the texture.</param>
        /// <param name="textureCornerUL">The "upper left corner" of the relevant
        /// part of the texture in UV coordinates.</param>
        /// <param name="textureSize">The "size" of the relevant part of the
        /// texture in UV coordinates.  For clarity, note that the lower left
        /// corner should be textureCornerUL + size.</param>
        /// <param name="width">The width of the rectangle.</param>
        /// <param name="height">The height of the rectangle.</param>
        /// <returns></returns>
        public static GeometryPrimitive MakeRectangle(
            Vector3 center, Vector3 normal, Vector3 up,
            Vector2 textureCornerUL, Vector2 textureSize,
            float width, float height)
        {
            GeometryPrimitive quad = new GeometryPrimitive();

            Vector3 left = Vector3.Cross(normal, up);
            Vector3 upperCenter = center + up * (height / 2.0f);

            Vector3 upperLeft = upperCenter + left * (width / 2.0f);
            Vector3 upperRight = upperCenter - left * (width / 2.0f);

            Vector3 lowerLeft = upperLeft - up * height;
            Vector3 lowerRight = upperRight - up * height;

            Vector2 textureUL = new Vector2(textureCornerUL.X, textureCornerUL.Y);
            Vector2 textureUR = new Vector2(textureCornerUL.X + textureSize.X, textureCornerUL.Y);
            Vector2 textureDL = new Vector2(textureCornerUL.X, textureCornerUL.Y + textureSize.Y);
            Vector2 textureDR = new Vector2(textureCornerUL.X + textureSize.X, textureCornerUL.Y + textureSize.Y);

            //with all those preliminaries set up, just define the corners!
            quad.Vertices = new VertexPositionNormalTexture[4];

            quad.Vertices[0] = new VertexPositionNormalTexture(lowerLeft, normal, textureDL);
            quad.Vertices[1] = new VertexPositionNormalTexture(upperLeft, normal, textureUL);
            quad.Vertices[2] = new VertexPositionNormalTexture(lowerRight, normal, textureDR);
            quad.Vertices[3] = new VertexPositionNormalTexture(upperRight, normal, textureUR);

            quad.Indices = new int[] { 0, 1, 2, 2, 1, 3 };

            return quad;
        }