public Texture( TextureTarget target )
        {
            TextureTarget = target;

            myID = -1;
            myLoaded = false;
        }

 public static void Bind(int textureUnit, TextureTarget target, uint textureID)
 {
     GL.ActiveTexture(TextureUnit.Texture0 + textureUnit);
     if (BindedTextures[textureUnit] == textureID) return; // on jo bindattu
     BindedTextures[textureUnit] = textureID;
     GL.BindTexture(target, textureID);
 }

 public void Upload(TextureTarget target, Region2D region)
 {
     GL.TexImage3D(target, 0, InternalFormat,
                     Size.Width, Size.Height, Depth,
                     0, Format, Type,
                     IntPtr.Zero);
 }

        protected TextureBase(TextureTarget target)
        {
            Target = target;
            Name = GL.GenTexture();

            Utilities.CheckGL();
        }

 Int32 Build1DMipmapLevel(TextureTarget target, Int32 internalFormat, Int32 width, PixelFormat format, PixelType type, Int32 level, Int32 @base, Int32 max, IntPtr data)
 {
     unsafe
     {
         return Delegates.gluBuild1DMipmapLevels((TextureTarget)target, (Int32)internalFormat, (Int32)width, (PixelFormat)format, (PixelType)type, (Int32)level, (Int32)@base, (Int32)max, (IntPtr)data);
     }
 }

 Int32 Build1DMipmap(TextureTarget target, Int32 internalFormat, Int32 width, PixelFormat format, PixelType type, IntPtr data)
 {
     unsafe
     {
         return Delegates.gluBuild1DMipmaps((TextureTarget)target, (Int32)internalFormat, (Int32)width, (PixelFormat)format, (PixelType)type, (IntPtr)data);
     }
 }

 internal void Activate(TextureTarget target, bool useMipmaps = false)
 {
   switch (this.Filter)
   {
     case TextureFilter.Linear:
       GL.TexParameter(target, TextureParameterName.TextureMinFilter, useMipmaps ? 9987 : 9729);
       GL.TexParameter(target, TextureParameterName.TextureMagFilter, 9729);
       break;
     case TextureFilter.Point:
       GL.TexParameter(target, TextureParameterName.TextureMinFilter, useMipmaps ? 9984 : 9728);
       GL.TexParameter(target, TextureParameterName.TextureMagFilter, 9728);
       break;
     case TextureFilter.Anisotropic:
       GL.TexParameter(target, TextureParameterName.TextureMinFilter, useMipmaps ? 9987 : 9729);
       GL.TexParameter(target, TextureParameterName.TextureMagFilter, 9729);
       break;
     case TextureFilter.MinLinearMagPointMipLinear:
       GL.TexParameter(target, TextureParameterName.TextureMinFilter, useMipmaps ? 9987 : 9729);
       GL.TexParameter(target, TextureParameterName.TextureMagFilter, 9728);
       break;
     default:
       throw new NotImplementedException();
   }
   GL.TexParameter(target, TextureParameterName.TextureWrapS, this.GetWrapMode(this.AddressU));
   GL.TexParameter(target, TextureParameterName.TextureWrapT, this.GetWrapMode(this.AddressV));
 }

 public GLTexture(int id, int width, int height, PixelFormatDescriptor pixelFormat, TextureTarget dimension)
 {
     Id = id;
     Width = width;
     Height = height;
     PixelFormat = pixelFormat;
     Dimension = dimension;
 }

 /// <summary>
 ///
 /// </summary>
 public void Initialize(uint unit, TextureTarget target)
 {
     if (!this.initialized)
     {
         this.DoInitialize(unit, target);
         this.initialized = true;
     }
 }

		protected TextureBase(TextureTarget target)
		{
			// set texture target
			mTextureTarget = target;

			// generate texture id
			GL.GenTextures (1, out mTextureId);
		}

 public Texture(int id, int width, int height, TextureTarget target, PixelInternalFormat format)
 {
     Width = width;
     Height = height;
     ID = id;
     TextureTarget = target;
     PixelInternalFormat = format;
 }

 public static unsafe void TexImage2D( TextureTarget target, int level, int internalformat, int width, int height, int border, PixelFormat format, byte[] pixels )
 {
     fixed (byte *pix = &pixels[0])
     {
         OpenGLNative.TexImage2D( target, level, internalformat, width, height, border, format, PixelType.UnsignedByte,
                                  pix );
     }
 }

        public void SwitchFace(TextureTarget face)
        {
            if(!Generated)
                Generate();
            GL.FramebufferTexture2D(FramebufferTarget.Framebuffer, FramebufferAttachment.ColorAttachment0, face, TexColor, 0);

            GL.DrawBuffer(DrawBufferMode.ColorAttachment0);
        }

 /// <summary>
 /// Texture.
 /// </summary>
 /// <param name="target"></param>
 /// <param name="imageBuilder"></param>
 /// <param name="parameters"></param>
 /// <param name="mipmapFiltering"></param>
 public Texture(
     TextureTarget target,
     ImageFiller imageBuilder,
     SamplerParameters parameters,
     MipmapFilter mipmapFiltering = MipmapFilter.LinearMipmapLinear)
     : this(target, imageBuilder, new FakeSampler(parameters, mipmapFiltering))
 {
 }

 public void SwitchCamera(TextureTarget face)
 {
     if(!Generated)
         Generate();
     var proj = FacesCameras[face].GetProjectionMatrix();
     FacesCameras[face].Transformation.SetPosition(Transformation.GetPosition());
     FacesCameras[face].SetProjectionMatrix(proj);
     Camera.Current = FacesCameras[face];
 }

        public Texture2DGL3x(Texture2DDescription description, TextureTarget textureTarget)
        {
            if (description.Width <= 0)
            {
                throw new ArgumentOutOfRangeException("description.Width", "description.Width must be greater than zero.");
            }

            if (description.Height <= 0)
            {
                throw new ArgumentOutOfRangeException("description.Height", "description.Height must be greater than zero.");
            }

            if (description.GenerateMipmaps)
            {
                if (textureTarget == TextureTarget.TextureRectangle)
                {
                    throw new ArgumentException("description.GenerateMipmaps cannot be true for texture rectangles.", "description");
                }
                
                if (!TextureUtility.IsPowerOfTwo(Convert.ToUInt32(description.Width)))
                {
                    throw new ArgumentException("When description.GenerateMipmaps is true, the width must be a power of two.", "description");
                }

                if (!TextureUtility.IsPowerOfTwo(Convert.ToUInt32(description.Height)))
                {
                    throw new ArgumentException("When description.GenerateMipmaps is true, the height must be a power of two.", "description");
                }
            }
            
            _name = new TextureNameGL3x();
            _target = textureTarget;
            _description = description;
            _lastTextureUnit = OpenTKTextureUnit.Texture0 + (Device.NumberOfTextureUnits - 1);

            //
            // TexImage2D is just used to allocate the texture so a PBO can't be bound.
            //
            WritePixelBufferGL3x.UnBind();
            BindToLastTextureUnit();
            GL.TexImage2D(_target, 0,
                TypeConverterGL3x.To(description.TextureFormat),
                description.Width,
                description.Height,
                0,
                TypeConverterGL3x.TextureToPixelFormat(description.TextureFormat),   
                TypeConverterGL3x.TextureToPixelType(description.TextureFormat),
                new IntPtr());

            //
            // Default sampler, compatiable when attaching a non-mimapped 
            // texture to a frame buffer object.
            //
            ApplySampler(Device.TextureSamplers.LinearClamp);

            GC.AddMemoryPressure(description.ApproximateSizeInBytes);
        }

        protected Texture(TextureTarget type, PixelInternalFormat format, OpenTK.Graphics.OpenGL.PixelFormat format2, int num) {
            ID = GL.GenTexture();

            Type = type;
            Format = format;
            Number = num;

            Activate();

        }

        protected Texture(IOpenGL30 gl, TextureTarget target)
        {
            var newHandle = gl.GenTexture();
            if(newHandle == 0u)
                throw new NoHandleCreatedException();

            Target = target;
            this._gl = gl;
            Handle = newHandle;
        }

		public GLTexture(string name, TextureTarget type, int width, int height)
		{
			#if ENABLE_PROFILING
			allocatedTextureCounter++;
			allocatedTextureNames.Add(this, name);
			#endif

			this.type = type;
			this.width = width;
			this.height = height;
		}

 /// <summary>
 /// texture's settings.
 /// </summary>
 /// <param name="unit">OpenGL.GL_TEXTURE0 etc.</param>
 /// <param name="target"></param>
 public override void Bind(uint unit, TextureTarget target)
 {
     /* Clamping to edges is important to prevent artifacts when scaling */
     OpenGL.TexParameteri((uint)target, OpenGL.GL_TEXTURE_WRAP_R, (int)this.parameters.wrapR);
     OpenGL.TexParameteri((uint)target, OpenGL.GL_TEXTURE_WRAP_S, (int)this.parameters.wrapS);
     OpenGL.TexParameteri((uint)target, OpenGL.GL_TEXTURE_WRAP_T, (int)this.parameters.wrapT);
     /* Linear filtering usually looks best for text */
     OpenGL.TexParameteri((uint)target, OpenGL.GL_TEXTURE_MIN_FILTER, (int)this.parameters.minFilter);
     OpenGL.TexParameteri((uint)target, OpenGL.GL_TEXTURE_MAG_FILTER, (int)this.parameters.magFilter);
     // TODO: mipmap filter not working yet.
 }