Texture Manager

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
using System.Drawing;
using System.Drawing.Imaging;
using OpenTK.Graphics.OpenGL;
using OpenTK;
using System.IO;
 
namespace TK3
{
    public class TexLib
    {
        //Internal variables
        static Dictionary<string, int> mTexCache; //used to link a memorisable name to a texture buffer
        public static bool mFileLog = true;
 
 
 
 
        /// <summary>
        /// Clear the Texture Buffer List
        /// Enable OpenGL states for texture mapping
        /// </summary>
        public static void Initialize()
        {
            mTexCache = new Dictionary<string, int>();
            GL.Enable(EnableCap.Texture2D);
        }
 
 
 
 
        /// <summary>
        /// Add an image to the texture cache held by OpenGL
        /// </summary>
        /// <param name="pImageName"></param>
        /// <param name="pImagePath"></param>
        public static void AddTexture(string pImageName, string pImagePath)
        {
            int mTexBuffer = default(int);
 
            //ensure there is a path specified
            if(String.IsNullOrEmpty(pImagePath))
            {
                throw new ArgumentException("TexLib Error: AddTexture() - Invalid path supplied");
            }
 
           //create Texture Buffer, store it in the last element of the texture buffers  
            mTexBuffer = GL.GenTexture();
            GL.BindTexture(TextureTarget.Texture2D, mTexBuffer);
 
            //Load BITMAP and send it to OpenGL
            Bitmap image = default(Bitmap);
            BitmapData imageData = default(BitmapData);
 
            try
            {
                //load Bitmap
                image = new Bitmap(pImagePath);
                imageData = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadOnly,
                                           System.Drawing.Imaging.PixelFormat.Format32bppArgb);
            }
            catch(ArgumentException)
            {
                throw new FileNotFoundException("TexLib error: AddTexture() - Cannot find bitmap file");
            }
 
            try
            {
                //send to OpenGL
                GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, imageData.Width, imageData.Height, 0, 
                              OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, imageData.Scan0);
 
 
                //set texture parameters
                GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
                GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
 
                image.UnlockBits(imageData);
            }
            catch (Exception)
            {
                throw new ArgumentException("TexLib Error: AddTexture() - Error binding texture to OpenGL");
            }
 
            //attach TexBuffer to dictionary
            mTexCache.Add(pImageName, mTexBuffer);    
        }
 
 
 
 
        /// <summary>
        /// Removes a texture from the cache
        /// </summary>
        /// <param name="pImageName"></param>
        public static void RemoveTexture(string pImageName)
        {
            if(mTexCache.ContainsKey(pImageName) && GL.IsTexture(mTexCache[pImageName]) )
            {
                GL.DeleteTexture(mTexCache[pImageName]);
                mTexCache.Remove(pImageName);
            }
            else
            {
                throw new KeyNotFoundException("TexLib Error: RemoveTexture() - Texture key not found");
            }
        }
 
 
 
 
        /// <summary>
        /// Clear all texture-related resources
        /// </summary>
        public static void ClearTextureCache()
        {
            foreach (KeyValuePair<string, int> feTexBuffer in mTexCache)
            {
                GL.DeleteTexture(feTexBuffer.Value);
            }
            mTexCache.Clear();    
        }
 
 
 
 
        /// <summary>
        ///Return an integer value of a texture buffer object 
        ///throws KeyNotFoundException if key can't be found
        /// </summary>
        /// <param name="pImageName"></param>
        public static int GetTexture(string pImageName)
        {
            if(mTexCache.ContainsKey(pImageName))
            {
                return mTexCache[pImageName];
            }
            else
            {
                throw new KeyNotFoundException("TexLib Error: GetTexture() - Texture key not found");
            }
        }
 
 
 
 
        /// <summary>
        /// display a list of textures cached
        /// </summary>
        /// <returns></returns>
        public static string ListTextures()
        {
            string texList = "No Textures Cached";
 
            if (mTexCache.Count > 0)
            {
                foreach (KeyValuePair<string, int> feTexBuffer in mTexCache)
                {
                    texList += feTexBuffer.Value + ": " + feTexBuffer.Key + "\n";
                }
            }
            return texList;       
       }
 
    }//END CLASS
}//END NAMESPACE