I'm having some problems with speed in my chunk engine. I timed it out, and in its current state it takes a total ~5 seconds per chunk to fill each face's list.

I have a check to see if each face of a block is visible and if it is not visible, it skips it and moves on.

I'm using a dictionary (unordered map) because it makes sense memorywise to just not have an entry if there is no block.

I've tracked my problem down to testing if there is an entry, and accessing an entry if it does exist. If I remove the tests to see if there is an entry in the dictionary for an adjacent block, or if the block type itself is seethrough, it runs within about 2-4 milliseconds.

so here's my question: Is there a faster way to check for an entry in a dictionary than .ContainsKey()? As an aside, I tried TryGetValue() and it doesn't really help with the speed that much.

If I remove the ContainsKey() and keep the test where it does the IsSeeThrough for each block, it halves the time, but it's still about 2-3 seconds. It only drops to 2-4ms if I remove BOTH checks.

Here is my code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using System.Runtime.InteropServices;
using OpenTK;
using OpenTK.Graphics.OpenGL;
using System.Drawing;



namespace Anabelle_Lee
{
    public enum BlockEnum
    {
        air = 0,
        dirt = 1,
    }
    [StructLayout(LayoutKind.Sequential,Pack=1)]
    public struct Coordinates<T1>
    {
        public T1 x;
        public T1 y;
        public T1 z;

        public override string ToString()
        {
            return "(" + x + "," + y + "," + z + ") : " + typeof(T1);
        }
    } 
    public struct Sides<T1>
    {
        public T1 left;
        public T1 right;
        public T1 top;
        public T1 bottom;
        public T1 front;
        public T1 back;
    }
    public class Block
    {
        public int blockType;

        public bool SeeThrough()
        {
            switch (blockType)
            {
                case 0:
                    return true;   
            }
            return false ;
        }
        public override string ToString()
        {
            return ((BlockEnum)(blockType)).ToString();
        }
    }

    class Chunk
    {
        private Dictionary<Coordinates<byte>, Block> mChunkData;  //stores the block data
        private Sides<List<Coordinates<byte>>> mVBOVertexBuffer;
        private Sides<int> mVBOHandle;
        //private bool mIsChanged;
        private const byte mCHUNKSIZE = 16;

        public Chunk()
        {
        }

        public void InitializeChunk()
        {   //create VBO references
#if DEBUG
            Console.WriteLine ("Initializing Chunk");
#endif

            mChunkData = new Dictionary<Coordinates<byte> , Block>();

            //mIsChanged = true;

            GL.GenBuffers(1, out mVBOHandle.left);
            GL.GenBuffers(1, out mVBOHandle.right);
            GL.GenBuffers(1, out mVBOHandle.top);
            GL.GenBuffers(1, out mVBOHandle.bottom);
            GL.GenBuffers(1, out mVBOHandle.front);
            GL.GenBuffers(1, out mVBOHandle.back);

            //make new list of vertexes for each face
            mVBOVertexBuffer.top    = new List<Coordinates<byte>>();
            mVBOVertexBuffer.bottom = new List<Coordinates<byte>>();
            mVBOVertexBuffer.left   = new List<Coordinates<byte>>();
            mVBOVertexBuffer.right  = new List<Coordinates<byte>>();
            mVBOVertexBuffer.front  = new List<Coordinates<byte>>();
            mVBOVertexBuffer.back   = new List<Coordinates<byte>>();

#if DEBUG
            Console.WriteLine("Chunk Initialized");
#endif
        }
        public void GenerateChunk()
        {
#if DEBUG
            Console.WriteLine("Generating Chunk");
#endif
            for (byte i = 0; i < mCHUNKSIZE; i++)
            {
                for (byte j = 0; j < mCHUNKSIZE; j++)
                {
                    for (byte k = 0; k < mCHUNKSIZE; k++)
                    {
                        Random blockLoc = new Random();
                        Coordinates<byte> randChunk = new Coordinates<byte> { x = i, y = j, z = k };

                        mChunkData.Add(randChunk, new Block());
                        mChunkData[randChunk].blockType = blockLoc.Next(0, 1);
                    }
                }
            }
#if DEBUG
            Console.WriteLine("Chunk Generated");
#endif
        }
        public void DeleteChunk()
        {   //delete VBO references
#if DEBUG
            Console.WriteLine("Deleting Chunk");
#endif

            GL.DeleteBuffers(1, ref mVBOHandle.left);
            GL.DeleteBuffers(1, ref mVBOHandle.right);
            GL.DeleteBuffers(1, ref mVBOHandle.top);
            GL.DeleteBuffers(1, ref mVBOHandle.bottom);
            GL.DeleteBuffers(1, ref mVBOHandle.front);
            GL.DeleteBuffers(1, ref mVBOHandle.back);

            //clear all vertex buffers
            ClearPolyLists();

#if DEBUG
            Console.WriteLine("Chunk Deleted");
#endif
        }

        public void UpdateChunk()
        {
#if DEBUG
            Console.WriteLine("Updating Chunk");
#endif

            ClearPolyLists(); //prepare buffers

            //for every entry in mChunkData map
            foreach(KeyValuePair<Coordinates<byte>,Block> feBlockData in mChunkData)
            {
                Coordinates<byte> checkBlock = new Coordinates<byte> { x = feBlockData.Key.x, y = feBlockData.Key.y, z = feBlockData.Key.z };

                //check for polygonson the left side of the cube
                    if (checkBlock.x > 0)
                    {
                        //check to see if there is a key for current x - 1.  if not, add the vector
                        if (!IsVisible(checkBlock.x - 1, checkBlock.y, checkBlock.z))
                        {
                            //add polygon
                            AddPoly(checkBlock.x, checkBlock.y, checkBlock.z, mVBOHandle.left);
                        }
                    }
                    else
                    {
                        //polygon is far left and should be added
                        AddPoly(checkBlock.x, checkBlock.y, checkBlock.z, mVBOHandle.left);
                    }

                    //check for polygons on the right side of the cube
                    if (checkBlock.x < mCHUNKSIZE - 1)
                    {
                        if (!IsVisible(checkBlock.x + 1, checkBlock.y, checkBlock.z))
                        {
                            //add poly
                            AddPoly(checkBlock.x, checkBlock.y, checkBlock.z, mVBOHandle.right);
                        }
                    }
                    else
                    {
                        //poly for right add
                        AddPoly(checkBlock.x, checkBlock.y, checkBlock.z, mVBOHandle.right);
                    }

                    if (checkBlock.y > 0)
                    {
                        //check to see if there is a key for current x - 1.  if not, add the vector
                        if (!IsVisible(checkBlock.x, checkBlock.y - 1, checkBlock.z))
                        {
                            //add polygon
                            AddPoly(checkBlock.x, checkBlock.y, checkBlock.z, mVBOHandle.bottom);
                        }
                    }
                    else
                    {
                        //polygon is far left and should be added
                        AddPoly(checkBlock.x, checkBlock.y, checkBlock.z, mVBOHandle.bottom);
                    }

                    //check for polygons on the right side of the cube
                    if (checkBlock.y < mCHUNKSIZE - 1)
                    {
                        if (!IsVisible(checkBlock.x, checkBlock.y + 1, checkBlock.z))
                        {
                            //add poly
                            AddPoly(checkBlock.x, checkBlock.y, checkBlock.z, mVBOHandle.top);
                        }
                    }
                    else
                    {
                        //poly for right add
                        AddPoly(checkBlock.x, checkBlock.y, checkBlock.z, mVBOHandle.top);
                    }

                    if (checkBlock.z > 0)
                    {
                        //check to see if there is a key for current x - 1.  if not, add the vector
                        if (!IsVisible(checkBlock.x, checkBlock.y, checkBlock.z - 1))
                        {
                            //add polygon
                            AddPoly(checkBlock.x, checkBlock.y, checkBlock.z, mVBOHandle.back);
                        }
                    }
                    else
                    {
                        //polygon is far left and should be added
                        AddPoly(checkBlock.x, checkBlock.y, checkBlock.z, mVBOHandle.back);
                    }

                    //check for polygons on the right side of the cube
                    if (checkBlock.z < mCHUNKSIZE - 1)
                    {
                        if (!IsVisible(checkBlock.x, checkBlock.y, checkBlock.z + 1))
                        {
                            //add poly
                            AddPoly(checkBlock.x, checkBlock.y, checkBlock.z, mVBOHandle.front);
                        }
                    }
                    else
                    {
                        //poly for right add
                        AddPoly(checkBlock.x, checkBlock.y, checkBlock.z, mVBOHandle.front);
                    }


            }

            BuildBuffers();

#if DEBUG
            Console.WriteLine("Chunk Updated");
#endif
        }
        public void RenderChunk()
        {
        }

        public void LoadChunk()
        {
#if DEBUG
            Console.WriteLine("Loading Chunk");
#endif

#if DEBUG
            Console.WriteLine("Chunk Deleted");
#endif
        }
        public void SaveChunk()
        {
#if DEBUG
            Console.WriteLine("Saving Chunk");
#endif

#if DEBUG
            Console.WriteLine("Chunk Saved");
#endif
        }

        private bool IsVisible(int pX,int pY,int pZ)
        {
       Block testBlock;
       Coordinates<byte> checkBlock = new Coordinates<byte> { x = Convert.ToByte(pX), y = Convert.ToByte(pY), z = Convert.ToByte(pZ) };
            if (mChunkData.TryGetValue(checkBlock,out testBlock ))  //if data exists
            {
                if (testBlock.SeeThrough() == true) //if existing data is not seethrough
                {
                    return true;
                }
            }
            return true;
        }
        private void AddPoly(byte pX, byte pY, byte pZ, int BufferSide)
        {
            //create temp array
            GL.BindBuffer(BufferTarget.ArrayBuffer, BufferSide);

            if (BufferSide == mVBOHandle.front)
            {
                //front face
                mVBOVertexBuffer.front.Add(new Coordinates<byte> { x = (byte)(pX)    , y = (byte)(pY + 1), z = (byte)(pZ + 1) });
                mVBOVertexBuffer.front.Add(new Coordinates<byte> { x = (byte)(pX)    , y = (byte)(pY)    , z = (byte)(pZ + 1) });
                mVBOVertexBuffer.front.Add(new Coordinates<byte> { x = (byte)(pX + 1), y = (byte)(pY)    , z = (byte)(pZ + 1) });
                mVBOVertexBuffer.front.Add(new Coordinates<byte> { x = (byte)(pX + 1), y = (byte)(pY)    , z = (byte)(pZ + 1) });
                mVBOVertexBuffer.front.Add(new Coordinates<byte> { x = (byte)(pX + 1), y = (byte)(pY + 1), z = (byte)(pZ + 1) });
                mVBOVertexBuffer.front.Add(new Coordinates<byte> { x = (byte)(pX)    , y = (byte)(pY + 1), z = (byte)(pZ + 1) });
            }
            else if (BufferSide == mVBOHandle.right)
            {
                //back face
                mVBOVertexBuffer.back.Add(new Coordinates<byte> { x = (byte)(pX + 1), y = (byte)(pY + 1), z = (byte)(pZ) });
                mVBOVertexBuffer.back.Add(new Coordinates<byte> { x = (byte)(pX + 1), y = (byte)(pY)    , z = (byte)(pZ) });
                mVBOVertexBuffer.back.Add(new Coordinates<byte> { x = (byte)(pX)    , y = (byte)(pY)    , z = (byte)(pZ) });
                mVBOVertexBuffer.back.Add(new Coordinates<byte> { x = (byte)(pX)    , y = (byte)(pY)    , z = (byte)(pZ) });
                mVBOVertexBuffer.back.Add(new Coordinates<byte> { x = (byte)(pX)    , y = (byte)(pY + 1), z = (byte)(pZ) });
                mVBOVertexBuffer.back.Add(new Coordinates<byte> { x = (byte)(pX + 1), y = (byte)(pY + 1), z = (byte)(pZ) });

            }
            else if (BufferSide == mVBOHandle.top)
            {
                //left face
                mVBOVertexBuffer.left.Add(new Coordinates<byte> { x = (byte)(pX), y = (byte)(pY + 1), z = (byte)(pZ)     });
                mVBOVertexBuffer.left.Add(new Coordinates<byte> { x = (byte)(pX), y = (byte)(pY)    , z = (byte)(pZ)     });
                mVBOVertexBuffer.left.Add(new Coordinates<byte> { x = (byte)(pX), y = (byte)(pY)    , z = (byte)(pZ + 1) });
                mVBOVertexBuffer.left.Add(new Coordinates<byte> { x = (byte)(pX), y = (byte)(pY)    , z = (byte)(pZ + 1) });
                mVBOVertexBuffer.left.Add(new Coordinates<byte> { x = (byte)(pX), y = (byte)(pY + 1), z = (byte)(pZ + 1) });
                mVBOVertexBuffer.left.Add(new Coordinates<byte> { x = (byte)(pX), y = (byte)(pY + 1), z = (byte)(pZ)     });
            }
            else if (BufferSide == mVBOHandle.bottom)
            {
                //right face
                mVBOVertexBuffer.right.Add(new Coordinates<byte> { x = (byte)(pX + 1), y = (byte)(pY + 1), z = (byte)(pZ + 1) });
                mVBOVertexBuffer.right.Add(new Coordinates<byte> { x = (byte)(pX + 1), y = (byte)(pY)    , z = (byte)(pZ + 1) });
                mVBOVertexBuffer.right.Add(new Coordinates<byte> { x = (byte)(pX + 1), y = (byte)(pY)    , z = (byte)(pZ)     });
                mVBOVertexBuffer.right.Add(new Coordinates<byte> { x = (byte)(pX + 1), y = (byte)(pY)    , z = (byte)(pZ)     });
                mVBOVertexBuffer.right.Add(new Coordinates<byte> { x = (byte)(pX + 1), y = (byte)(pY + 1), z = (byte)(pZ)     });
                mVBOVertexBuffer.right.Add(new Coordinates<byte> { x = (byte)(pX + 1), y = (byte)(pY + 1), z = (byte)(pZ + 1) });
            }
            else if (BufferSide == mVBOHandle.front)
            {
                //top face
                mVBOVertexBuffer.top.Add(new Coordinates<byte> { x = (byte)(pX)    , y = (byte)(pY + 1), z = (byte)(pZ)     });
                mVBOVertexBuffer.top.Add(new Coordinates<byte> { x = (byte)(pX)    , y = (byte)(pY + 1), z = (byte)(pZ + 1) });
                mVBOVertexBuffer.top.Add(new Coordinates<byte> { x = (byte)(pX + 1), y = (byte)(pY + 1), z = (byte)(pZ + 1) });
                mVBOVertexBuffer.top.Add(new Coordinates<byte> { x = (byte)(pX + 1), y = (byte)(pY + 1), z = (byte)(pZ + 1) });
                mVBOVertexBuffer.top.Add(new Coordinates<byte> { x = (byte)(pX + 1), y = (byte)(pY + 1), z = (byte)(pZ)     });
                mVBOVertexBuffer.top.Add(new Coordinates<byte> { x = (byte)(pX)    , y = (byte)(pY + 1), z = (byte)(pZ)     });
            }
            else if (BufferSide == mVBOHandle.back)
            {
                //bottom face
                mVBOVertexBuffer.bottom.Add(new Coordinates<byte> { x = (byte)(pX)    , y = (byte)(pY), z = (byte)(pZ + 1) });
                mVBOVertexBuffer.bottom.Add(new Coordinates<byte> { x = (byte)(pX)    , y = (byte)(pY), z = (byte)(pZ)     });
                mVBOVertexBuffer.bottom.Add(new Coordinates<byte> { x = (byte)(pX + 1), y = (byte)(pY), z = (byte)(pZ)     });
                mVBOVertexBuffer.bottom.Add(new Coordinates<byte> { x = (byte)(pX + 1), y = (byte)(pY), z = (byte)(pZ)     });
                mVBOVertexBuffer.bottom.Add(new Coordinates<byte> { x = (byte)(pX + 1), y = (byte)(pY), z = (byte)(pZ + 1) });
                mVBOVertexBuffer.bottom.Add(new Coordinates<byte> { x = (byte)(pX)    , y = (byte)(pY), z = (byte)(pZ + 1) });
            }
        }
        private void BuildBuffers()
        {
#if DEBUG
            Console.WriteLine("Building Chunk Buffers");
#endif

            GL.BindBuffer(BufferTarget.ArrayBuffer, mVBOHandle.front);
            GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(Marshal.SizeOf(new Coordinates<byte>()) * mVBOVertexBuffer.front.Count),
                          mVBOVertexBuffer.front.ToArray(), BufferUsageHint.StaticDraw);

            GL.BindBuffer(BufferTarget.ArrayBuffer, mVBOHandle.back);
            GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(Marshal.SizeOf(new Coordinates<byte>()) * mVBOVertexBuffer.back.Count),
                          mVBOVertexBuffer.back.ToArray(), BufferUsageHint.StaticDraw);

            GL.BindBuffer(BufferTarget.ArrayBuffer, mVBOHandle.left);
            GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(Marshal.SizeOf(new Coordinates<byte>()) * mVBOVertexBuffer.left.Count),
                          mVBOVertexBuffer.left.ToArray(), BufferUsageHint.StaticDraw);

            GL.BindBuffer(BufferTarget.ArrayBuffer, mVBOHandle.right);
            GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(Marshal.SizeOf(new Coordinates<byte>()) * mVBOVertexBuffer.right.Count),
                          mVBOVertexBuffer.right.ToArray(), BufferUsageHint.StaticDraw);

            GL.BindBuffer(BufferTarget.ArrayBuffer, mVBOHandle.top);
            GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(Marshal.SizeOf(new Coordinates<byte>()) * mVBOVertexBuffer.top.Count),
                          mVBOVertexBuffer.top.ToArray(), BufferUsageHint.StaticDraw);

            GL.BindBuffer(BufferTarget.ArrayBuffer, mVBOHandle.bottom);
            GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(Marshal.SizeOf(new Coordinates<byte>()) * mVBOVertexBuffer.bottom.Count),
                          mVBOVertexBuffer.bottom.ToArray(), BufferUsageHint.StaticDraw);

            GL.BindBuffer(BufferTarget.ArrayBuffer,0);

#if DEBUG
            Console.WriteLine("Chunk Buffers Built");
#endif
        }
        private void ClearPolyLists()
        {
#if DEBUG
            Console.WriteLine("Clearing Polygon Lists");
#endif

            mVBOVertexBuffer.top.Clear();
            mVBOVertexBuffer.bottom.Clear();
            mVBOVertexBuffer.left.Clear();
            mVBOVertexBuffer.right.Clear();
            mVBOVertexBuffer.front.Clear();
            mVBOVertexBuffer.back.Clear();

#if DEBUG
            Console.WriteLine("Polygon Lists Cleared");
#endif
        }

    }//END CLASS

}//END NAMESPACE