Texture problems

// Released to the public domain. Use, modify and relicense at will.
 
using System;
using System.Drawing;
 
using OpenTK;
using OpenTK.Graphics;
using OpenTK.Graphics.OpenGL;
using OpenTK.Audio;
using OpenTK.Audio.OpenAL;
using OpenTK.Input;
namespace BouncyBall
{
 
    class Game : GameWindow
    { 
		Vector2 move;
 
 
 
		GameObject2d ball = new GameObject2d(new Vector2(-.5f,0.5f),Color4.Gray,.01f,new Vector2(0.0f,0.0f));
 
        /// <summary>Creates a 800x600 window with the specified title.</summary>
        public Game()
            : base(800, 600, GraphicsMode.Default, "OpenTK Quick Start Sample")
        {
            VSync = VSyncMode.On;
			move = new Vector2(0.0f,0.0f);
       }
 
        /// <summary>Load resources here.</summary>
        /// <param name="e">Not used.</param>
        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);
            GL.ClearColor(0.1f, 0.2f, 0.5f, 0.0f);
			GL.Disable(EnableCap.DepthTest);
            ball.loadTexture("Ball.png");
        }
 
        /// <summary>
        /// Called when your window is resized. Set your viewport here. It is also
        /// a good place to set up your projection matrix (which probably changes
        /// along when the aspect ratio of your window).
        /// </summary>
        /// <param name="e">Not used.</param>
        protected override void OnResize(EventArgs e)
        {
            base.OnResize(e);
 
            GL.Viewport(ClientRectangle.X, ClientRectangle.Y, ClientRectangle.Width, ClientRectangle.Height);
            Matrix4 projection = Matrix4.CreateOrthographicOffCenter(0,1.3333f,0,1,-1,1);
            GL.MatrixMode(MatrixMode.Projection);
            GL.LoadMatrix(ref projection);
        }
 
        /// <summary>
        /// Called when it is time to setup the next frame. Add you game logic here.
        /// </summary>
        /// <param name="e">Contains timing information for framerate independent logic.</param>
        protected override void OnUpdateFrame(FrameEventArgs e)
        {
			base.OnUpdateFrame(e);
 
            if (Keyboard[Key.Escape])
                Exit();
 
		    ball.ApplyForce(.016666666);		
 
 
 
        }
 
        /// <summary>
        /// Called when it is time to render the next frame. Add your rendering code here.
        /// </summary>
        /// <param name="e">Contains timing information.</param>
        protected override void OnRenderFrame(FrameEventArgs e)
        {
            base.OnRenderFrame(e);
 
            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
 
            Matrix4 modelview = Matrix4.LookAt(Vector3.Zero, Vector3.UnitZ, Vector3.UnitY);
            GL.MatrixMode(MatrixMode.Modelview);
			GL.LoadMatrix(ref modelview);
 
			GL.Enable(EnableCap.Texture2D);
			GL.Enable(EnableCap.Blend);
			GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.OneMinusSrcAlpha);
 
 
			ball.Draw();
 
            SwapBuffers();
        }
 
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            // The 'using' idiom guarantees proper resource cleanup.
            // We request 30 UpdateFrame events per second, and unlimited
            // RenderFrame events (as fast as the computer can handle).
            using (Game game = new Game())
            {
                game.Run(60.0);
            }
        }
    }
}

using System;
using System.Drawing;
using OpenTK;
using OpenTK.Graphics;
using OpenTK.Graphics.OpenGL;
namespace BouncyBall
{
	public class GameObject2d
	{
		Vector2 position;
		Color4 color;
		float radius;
		Vector2 velocity;
		int textureId;
 
		public GameObject2d()
		{
			position = new Vector2(0.0f,0.0f);
			color = Color4.Green;
			radius = 10;
			velocity = new Vector2(0.0f,0.0f);
			textureId = 0;
		}
		public GameObject2d(Vector2 Position,Color4 Color,float Radius, Vector2 Velocity)
		{
			position = Position;
			color = Color;
			radius = Radius;
			velocity = Velocity;
			textureId = 0;
		}
 
		public void loadTexture(string File)
		{
			textureId = GL.GenTexture();
			GL.BindTexture(TextureTarget.Texture2D,textureId);
			Bitmap bmp = new Bitmap(File);
			System.Drawing.Imaging.BitmapData bmp_data = bmp.LockBits(new Rectangle(0,0,bmp.Width,bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly,System.Drawing.Imaging.PixelFormat.Format32bppArgb);
			GL.TexImage2D(TextureTarget.Texture2D,0,PixelInternalFormat.Rgba,bmp.Width,bmp.Height,0,OpenTK.Graphics.OpenGL.PixelFormat.Bgra,PixelType.UnsignedByte,bmp_data.Scan0);
 
			bmp.UnlockBits(bmp_data);
			GL.TexParameter(TextureTarget.Texture2D,TextureParameterName.TextureMinFilter,(int)TextureMinFilter.Linear);
			GL.TexParameter(TextureTarget.Texture2D,TextureParameterName.TextureMagFilter,(int)TextureMagFilter.Linear);
		}
 
		public void Draw()
		{
 
			GL.BindTexture(TextureTarget.Texture2D,textureId);
			GL.Color3(Color.White);
			GL.Begin(BeginMode.Quads);
			GL.TexCoord2(0,0); GL.Vertex2(-(radius) + position.X,(radius * 2) + position.Y);
			GL.TexCoord2(0,1f); GL.Vertex2((radius) + position.X,(radius * 2) + position.Y);
			GL.TexCoord2(1f,1f); GL.Vertex2((radius) + position.X,position.Y);
			GL.TexCoord2(1f,0); GL.Vertex2(-(radius) + position.X, position.Y);
            GL.End();
		}
			public void ApplyForce(double timePassed)
		{
			timePassed = timePassed / 2;
			for(int i = 0;i < 2;i++)
			{
			if(position.Y >= 0)
			{
				position.Y = (float)(-4.8*timePassed*timePassed + velocity.Y*timePassed + position.Y);
				velocity.Y = (float)(-9.8*timePassed + velocity.Y);
			}
			else
			{
				position.Y = 0;
				if(velocity.Y > 2)
					velocity.Y = 0;
				else
				velocity.Y = velocity.Y * -0.8f; //simulated elasticity
			}
			}
		}
 
	}
}