Question

I am making (another) MineCraft clone, and I’ve run into an interesting problem. I have a public enum that lists all the cube types a particular cube can be, and I have a 3d array that holds cubes. Each cube has a specific type, and I iterate through this array to get the vertices for each cube, then pass those vertices to a vertex buffer designated for a particular cube type. When I create a random array of cubes, or a single cube, and tell it what texture it should be everything draws as expected. I’m now trying to figure out how to draw a random “surface” of grass cubes, and fill everything below those on the y-axis with dirt cubes. The strangest thing is happening though, the top most cube is dirt and it fills all the bottom ones with grass cubes! When I disable the loop to fill the underground with dirt, the top most cube is displaying grass as intended.

Here is what I believe to be the relevant parts of the code. Here is where the cube type is set:

            // Create a random surface level
        Perlin perlin = new Perlin();

        for (int x = 0; x < Game.ChunkWidth_X; x++)
        {
            for (int z = 0; z < Game.ChunkDepth_Z; z++)
            {
                double XVal = Convert.ToDouble(x) * 1.1;
                double ZVal = Convert.ToDouble(z) * 1.1;
                double YVal = Game.ChunkHeight_Y / 2 * 1.1;

                double PerlinValue = perlin.GetValue(XVal, YVal, ZVal);
                int YVal_new = Convert.ToInt32(YVal + (PerlinValue * 10));
                if (YVal_new > Game.ChunkHeight_Y - 1) { YVal_new = Game.ChunkHeight_Y - 1; }
                if (YVal_new < 0) { YVal_new = 0; }

                // Set the grass cube
                Cube NewCube = new Cube(new Vector3(0.5f, 0.5f, 0.5f), new Vector3(x, YVal_new, z));
                NewCube.cubeType = CubeType.Grass;
                CubeGrid[x, YVal_new, z] = NewCube;

                // Fill below it with dirt
                for (int y = YVal_new - 1; y >= 0; y--)
                {
                    Cube NewCube2 = new Cube(new Vector3(0.5f, 0.5f, 0.5f), new Vector3(x, y, z));
                    NewCube2.cubeType = CubeType.Dirt;
                    CubeGrid[x, y, z] = NewCube2;
                }

                // Fill above it with air
                for (int y = YVal_new + 1; y < Game.ChunkHeight_Y; y++)
                {
                    Cube NewCube2 = new Cube(new Vector3(0.5f, 0.5f, 0.5f), new Vector3(x, y, z));
                    NewCube2.cubeType = CubeType.Air;
                    CubeGrid[x, y, z] = NewCube2;
                }

            }
        }

This is where I pull the vertices to put into the appropriate buffer:

            Dictionary<CubeType, List<VertexPositionNormalTexture>> DrawableVertices = new Dictionary<CubeType, List<VertexPositionNormalTexture>>();

        // Get the proper vertices for each cube type and put in the appropriate dictionary
        for (int x = 0; x < Game.ChunkWidth_X; x++)
        { 
            for (int z = 0; z < Game.ChunkDepth_Z; z++)
            {
                for (int y = 0; y < Game.ChunkHeight_Y; y++)
                {
                    CubeGrid[x,y,z].CreateVertices();
                    string test = CubeGrid[x, y, z].cubeType.ToString();

                    foreach (VertexPositionNormalTexture TargetVertex in CubeGrid[x, y, z].DisplayableVertices)
                    {
                        if (!DrawableVertices.ContainsKey(CubeGrid[x, y, z].cubeType))
                        {
                            List<VertexPositionNormalTexture> NewList = new List<VertexPositionNormalTexture>();
                            NewList.Add(TargetVertex);
                            DrawableVertices.Add(CubeGrid[x, y, z].cubeType, NewList);
                        }
                        else
                        {
                            DrawableVertices[CubeGrid[x, y, z].cubeType].Add(TargetVertex);
                        }
                    }
                }
            }
        }

Here is the second part of it:

            foreach (KeyValuePair<CubeType, List<VertexPositionNormalTexture>> KVP in DrawableVertices)
        {
            VertexBuffer cubeBuffer = new VertexBuffer(device, typeof(VertexPositionNormalTexture), KVP.Value.Count, BufferUsage.WriteOnly);
            cubeBuffer.SetData(KVP.Value.ToArray());

            // Update our collection of vertex buffers
            CubeType_VertexBuffers[KVP.Key] = cubeBuffer;

            // Get the triangle count for the buffer
            CubeType_TriangleCount[KVP.Key] = KVP.Value.Count / 3;

        }

Lastly, here is my draw:

            // Go through each vertex buffer we have created, and draw it.
        foreach (KeyValuePair<CubeType, VertexBuffer> KVP in CubeType_VertexBuffers)
        {
            foreach (EffectPass pass in testEffect.CurrentTechnique.Passes)
            {
                if (CubeType_TriangleCount[KVP.Key] > 0) // if this buffer has triangles, draw it.
                {
                    pass.Apply();
                    testEffect.View = camera.ViewMatrix;
                    testEffect.TextureEnabled = true;
                    testEffect.Projection = camera.ProjectionMatrix;
                    testEffect.World = worldMatrix;
                    testEffect.Texture = CubeType_Texture[KVP.Key];

                    device.SetVertexBuffer(KVP.Value);
                    device.DrawPrimitives(PrimitiveType.TriangleList, 0, CubeType_TriangleCount[KVP.Key]);
                }
            }
        }


        base.Draw(gameTime);

The weirdest thing is that when I manually set cube types everything draws with the proper texture as expected. What other things should I try to troubleshoot? I tried making a specific effect for each cube type to no avail.

Answer 1

After trying a bunch of random things in desperation, I found a fix for this. It turns out that if you use the same BasicEffect for different textures, it only uses the last texture assigned to it. I was iterating through a list of VertexBuffers and assigning a different texture for each one. By the time everything made it over to the video card, only the last texture used was rendered, or so it appears.

The solution was to create a separate BasicEffect for each texture I needed and assign only the VertexBuffers needed to the particular BasicEffect.