public void GenerateChunks(MangoFogOrientation orientation)
        {
            if (!doChunks)
            {
                if (orientation == MangoFogOrientation.Perspective3D)
                {
                    trueRootChunkPosition = new Vector3(rootChunkPosition.x, fogRenderHeightPosition, rootChunkPosition.z);
                    InstantiateChunk(trueRootChunkPosition);
                }
                else
                {
                    trueRootChunkPosition = new Vector3(rootChunkPosition.x, rootChunkPosition.y, fogRenderHeightPosition);
                    InstantiateChunk(trueRootChunkPosition);
                }
            }
            else
            if (orientation == MangoFogOrientation.Perspective3D)
            {
                for (int y = -(chunkSquared); y < (chunkSquared); ++y)
                {
                    for (int x = -(chunkSquared); x < (chunkSquared); ++x)
                    {
                        InstantiateChunk(new Vector3((x * chunkSize), fogRenderHeightPosition, (y * chunkSize)) + rootChunkPosition);
                    }
                }
            }
            else
            {
                for (int y = -(chunkSquared); y < (chunkSquared); ++y)
                {
                    for (int x = -(chunkSquared); x < (chunkSquared); ++x)
                    {
                        InstantiateChunk(new Vector3((x * chunkSize), (y * chunkSize), fogRenderHeightPosition) + rootChunkPosition);
                    }
                }
            }

            MangoFogChunk.changeStates = new int[chunksCreated];

            //loop through chunks and start them.
            foreach (KeyValuePair <Vector3, MangoFogChunk> chunk in chunks)
            {
                chunk.Value.StartChunk();
            }

            if (debugModeEnabled)
            {
                Debug.Log("Mango Fog Instance Generated Chunks.");
            }
        }
        /// <summary>
        /// Initializes the chunk
        /// </summary>
        public void Init()
        {
            orientation      = MangoFogInstance.Instance.orientation;
            chunkSize        = MangoFogInstance.Instance.chunkSize;
            textureSize      = MangoFogInstance.Instance.textureQualityPerChunk;
            updateFrequency  = MangoFogInstance.Instance.updateFrequency;
            textureBlendTime = MangoFogInstance.Instance.textureBlendTime;
            blurIterations   = MangoFogInstance.Instance.blurIterations;

            Vector3 boundsMultiplier        = MangoFogInstance.Instance.chunkBoundsMultiplier;
            int     fogRenderHeightPosition = MangoFogInstance.Instance.fogRenderHeightPosition;
            float   boundsDepth             = MangoFogInstance.Instance.boundsDepth;

            clampBlendFactor = MangoFogInstance.Instance.clampBlendFactorToTextureTime;

            chunkTransform = transform;
            chunkOrigin    = transform.position;
            chunkPosition  = transform.position;
            chunkOrigin.x -= chunkSize * 0.5f;

            var originOrientation =
                orientation == MangoFogOrientation.Perspective3D ? chunkOrigin.z -= chunkSize * 0.5f : chunkOrigin.y -= chunkSize * 0.5f;

            Vector3 rendererRotation =
                orientation == MangoFogOrientation.Perspective3D ? MangoFogInstance.Instance.Perspective3DRenderRotation : MangoFogInstance.Instance.Orthographic2DRenderRotation;
            float   rendererScale       = chunkSize / MangoFogInstance.Instance.meshScaleDivisor * MangoFogInstance.Instance.meshScalePostMultiplier;
            Vector3 rendererScaleVector = new Vector3(rendererScale, rendererScale, 1f);

            //handle the renderer
            fogRenderer.SetChunk(this);
            fogRenderer.SetDrawMode(MangoFogInstance.Instance.drawMode);
            fogRenderer.SetColors(MangoFogInstance.Instance.unexploredColor, MangoFogInstance.Instance.exploredColor);
            fogRenderer.SetMesh(MangoFogInstance.Instance.fogMesh);
            fogRenderer.transform.position = transform.position;

            if (MangoFogInstance.Instance.drawMode == MangoDrawMode.GPU)
            {
                fogRenderer.ConstructMeshMatrix(transform.position, rendererScaleVector, Quaternion.Euler(rendererRotation.x, rendererRotation.y, rendererRotation.z));
            }
            else
            {
                fogRenderer.transform.position    = transform.position;
                fogRenderer.transform.eulerAngles = rendererRotation;
                fogRenderer.transform.localScale  = rendererScaleVector;
            }

            //init the renderer
            fogRenderer.Init();

            textureSizeSquared = textureSize * textureSize;
            buffer0            = new Color32[textureSizeSquared];
            buffer1            = new Color32[textureSizeSquared];
            buffer2            = new Color32[textureSizeSquared];

            bounds = orientation == MangoFogOrientation.Perspective3D ?
                     new Bounds(transform.position, new Vector3(chunkSize * boundsMultiplier.x, (fogRenderHeightPosition + boundsDepth), chunkSize * boundsMultiplier.z)) :
                     new Bounds(transform.position, new Vector3(chunkSize * boundsMultiplier.x, chunkSize * boundsMultiplier.y, fogRenderHeightPosition + boundsDepth));

            mHeights = new int[textureSize, textureSize];

            chunk3DSize = orientation == MangoFogOrientation.Perspective3D ?
                          new Vector3(chunkSize, MangoFogInstance.Instance.heightRange.y - MangoFogInstance.Instance.heightRange.x, chunkSize) :
                          new Vector3(chunkSize, chunkSize, MangoFogInstance.Instance.heightRange.y - MangoFogInstance.Instance.heightRange.x);

            CreateGrid();
        }