Bouncing ball controlled with keyboard

Makefile

 	CPP=g++
 endif
 ifeq ($(DEBUG),1)
-	CPPFLAGS+=-g -Og
+	CPPFLAGS+=-g -Og -D_DEBUG
 else
 	CPPFLAGS+=-flto -O3
 endif

pge/include/olcPGEX_Graphics2D.h

 		class Transform2D
 		{
 		public:
-			inline Transform2D();
+			Transform2D();
 
 		public:
 			// Set this transformation to unity
-			inline void Reset();
+			void Reset();
 			// Append a rotation of fTheta radians to this transform
-			inline void Rotate(float fTheta);
+			void Rotate(float fTheta);
 			// Append a translation (ox, oy) to this transform
-			inline void Translate(float ox, float oy);
+			void Translate(float ox, float oy);
 			// Append a scaling operation (sx, sy) to this transform
-			inline void Scale(float sx, float sy);
+			void Scale(float sx, float sy);
 			// Append a shear operation (sx, sy) to this transform
-			inline void Shear(float sx, float sy);
+			void Shear(float sx, float sy);
 
-			inline void Perspective(float ox, float oy);
+		    void Perspective(float ox, float oy);
 			// Calculate the Forward Transformation of the coordinate (in_x, in_y) -> (out_x, out_y)
-			inline void Forward(float in_x, float in_y, float &out_x, float &out_y);
+			void Forward(float in_x, float in_y, float &out_x, float &out_y);
 			// Calculate the Inverse Transformation of the coordinate (in_x, in_y) -> (out_x, out_y)
-			inline void Backward(float in_x, float in_y, float &out_x, float &out_y);
+			void Backward(float in_x, float in_y, float &out_x, float &out_y);
 			// Regenerate the Inverse Transformation
-			inline void Invert();
+			void Invert();
 
 		private:
-			inline void Multiply();
+			void Multiply();
 			float matrix[4][3][3];
 			int nTargetMatrix;
 			int nSourceMatrix;
 
 	public:
 		// Draws a sprite with the transform applied
-		inline static void DrawSprite(olc::Sprite *sprite, olc::GFX2D::Transform2D &transform);
+		static void DrawSprite(olc::Sprite *sprite, olc::GFX2D::Transform2D &transform, bool centered = false);
+		static void DrawPartialSprite(olc::Sprite *sprite, int32_t ox, int32_t oy, int32_t w, int32_t h, olc::GFX2D::Transform2D &transform, bool centered = false);
 	};
 }
 

pge/src/olcPGEX_Graphics2D.cpp

 
 namespace olc
 {
-	void GFX2D::DrawSprite(olc::Sprite *sprite, olc::GFX2D::Transform2D &transform)
+	void GFX2D::DrawSprite(olc::Sprite *sprite, olc::GFX2D::Transform2D &transform, bool centered)
 	{
 		if (sprite == nullptr)
 			return;
 		float sx, sy;		
 		float px, py;
 
-		transform.Forward(0.0f, 0.0f, sx, sy);
+		float x0 = 0;
+		float y0 = 0;
+		if (centered) 
+		{
+			x0 += sprite->width / 2;
+			y0 += sprite->height / 2;
+		}
+
+		transform.Forward(-x0, -y0, sx, sy);
+		px = sx; py = sy;
+		sx = std::min(sx, px); sy = std::min(sy, py);
+		ex = std::max(ex, px); ey = std::max(ey, py);
+		
+		transform.Forward((float)sprite->width-x0, (float)sprite->height-y0, px, py);
+		sx = std::min(sx, px); sy = std::min(sy, py);
+		ex = std::max(ex, px); ey = std::max(ey, py);
+
+		transform.Forward(-x0, (float)sprite->height-y0, px, py);
+		sx = std::min(sx, px); sy = std::min(sy, py);
+		ex = std::max(ex, px); ey = std::max(ey, py);
+
+		transform.Forward((float)sprite->width, -y0, px, py);
+		sx = std::min(sx, px); sy = std::min(sy, py);
+		ex = std::max(ex, px); ey = std::max(ey, py);
+
+		// Perform inversion of transform if required
+		transform.Invert();
+
+		if (ex < sx) 
+			std::swap(ex, sx);
+		if (ey < sy) 
+			std::swap(ey, sy);
+
+		// Iterate through render space, and sample Sprite from suitable texel location
+		for (float i = sx; i < ex; i++)
+		{
+			for (float j = sy; j < ey; j++)
+			{
+				float ox, oy;
+				transform.Backward(i, j, ox, oy);
+				pge->Draw((int32_t)i, (int32_t)j, sprite->GetPixel((int32_t)(x0+ox+0.5f), (int32_t)(y0+oy+0.5f)));
+			}
+		}
+	}
+
+	void GFX2D::DrawPartialSprite(olc::Sprite *sprite, int32_t x0, int32_t y0, int32_t w, int32_t h, olc::GFX2D::Transform2D &transform, bool centered)
+	{
+		if (sprite == nullptr)
+			return;
+
+		// Work out bounding rectangle of sprite
+		float ex, ey;
+		float sx, sy;		
+		float px, py;
+
+		float xOff = 0;
+		float yOff = 0;
+
+		if (centered) 
+		{
+			xOff += w / 2;
+			yOff += h / 2;
+		}
+
+		transform.Forward(-xOff, -yOff, sx, sy);
 		px = sx; py = sy;
 		sx = std::min(sx, px); sy = std::min(sy, py);
 		ex = std::max(ex, px); ey = std::max(ey, py);
 		
-		transform.Forward((float)sprite->width, (float)sprite->height, px, py);
+		transform.Forward((float)w-xOff, (float)h-yOff, px, py);
 		sx = std::min(sx, px); sy = std::min(sy, py);
 		ex = std::max(ex, px); ey = std::max(ey, py);
 
-		transform.Forward(0.0f, (float)sprite->height, px, py);
+		transform.Forward(-xOff, (float)h-yOff, px, py);
 		sx = std::min(sx, px); sy = std::min(sy, py);
 		ex = std::max(ex, px); ey = std::max(ey, py);
 
-		transform.Forward((float)sprite->width, 0.0f, px, py);
+		transform.Forward((float)w, -yOff, px, py);
 		sx = std::min(sx, px); sy = std::min(sy, py);
 		ex = std::max(ex, px); ey = std::max(ey, py);
 
 			{
 				float ox, oy;
 				transform.Backward(i, j, ox, oy);
-				pge->Draw((int32_t)i, (int32_t)j, sprite->GetPixel((int32_t)(ox+0.5f), (int32_t)(oy+0.5f)));
+				pge->Draw((int32_t)i, (int32_t)j, sprite->GetPixel((int32_t)(xOff+x0+ox+0.5f), (int32_t)(yOff+y0+oy+0.5f)));
 			}
 		}
 	}

src/pabloader/awoorwae.cpp

 
 namespace pabloader {
 
-bool Awoorwae::OnUserCreate() {
+bool Awoorwae::OnUserCreate()
+{
     if (!player->Load()) {
         std::cerr << "Could not load awoorwa.spr" << std::endl;
         return false;
     return true;
 }
 
-Entity::Entity(Awoorwae* game_, float x_, float y_)
+Entity::Entity(Awoorwae* game_)
     : game(game_)
-    , x(x_)
-    , y(y_)
-    , xv(50)
-    , yv(30)
-    , color(0)
 {
-    xv = 10;
-    yv = 10;
+    xv = 0;
+    yv = 30;
+    x = game->ScreenWidth() / 2;
+    y = game->ScreenHeight() / 2;
 }
 
-olc::rcode Entity::Load() 
+olc::rcode Entity::Load()
 {
     return img.LoadFromPGESprFile("res/awoorwa.spr");
 }
 
 void Entity::Update(float dt)
 {
-    x += dt * xv;
-    y += dt * yv;
+    x += xv * dt;
+    y += yv * dt;
+
+    xv *= 1 - 0.2 * dt;
+
+    if (!onGround) {
+        yv += 50 * dt;
+        yv *= 1 - 0.05 * dt;
+    }
+
+    transform.Reset();
+
+    game->DrawString(1, 1, "A,D - move; SPACE - jump", olc::CYAN);
+
+#ifdef _DEBUG
+    game->DrawString(1, 10, std::to_string(x) + " " + std::to_string(y));
+    game->DrawString(1, 18, std::to_string(xv) + " " + std::to_string(yv));
+#endif
+    bool userInput = false;
+
+    if (game->GetKey(olc::SPACE).bHeld && onGround) {
+        yv = -100;
+        userInput = true;
+    }
 
-    if (x > game->ScreenWidth() - img.width) {
-        xv *= -1.1;
-        x = game->ScreenWidth() - img.width;
+    if (game->GetKey(olc::A).bHeld) {
+        xv -= 100 * dt;
+        userInput = true;
     }
 
-    if (x < 0) {
-        xv *= -1.1;
-        x = 0;
+    if (game->GetKey(olc::D).bHeld) {
+        xv += 100 * dt;
+        userInput = true;
     }
 
-    if (y > game->ScreenHeight() - img.height) {
-        yv *= -1.1;
-        y = game->ScreenHeight() - img.height;
+    if (x > game->ScreenWidth() - img.width / 2) {
+        xv *= -0.3;
+        x = game->ScreenWidth() - img.width / 2;
     }
 
-    if (y < 0) {
-        yv *= -1.1;
-        y = 0;
+    if (x < img.width / 2) {
+        xv *= -0.3;
+        x = img.width / 2;
     }
-    color = fmodf(color + 256 * dt, 256);
+
+    if (y > game->ScreenHeight() - img.height / 4) {
+        yv *= -0.3;
+
+        if (std::abs(yv) < 2) {
+            yv = 0;
+        }
+        y = game->ScreenHeight() - img.height / 4;
+    }
+
+    onGround = y >= game->ScreenHeight() - img.height / 4;
+
+    if (!userInput && std::abs(xv) < 2) {
+        xv = 0;
+    }
+    if (xv < 0) {
+        transform.Scale(-1, 1);
+    }
+    transform.Translate(x, y);
 }
 
 void Entity::Draw()
 {
-    game->DrawSprite((int)x, (int)y, &img);
+    if (std::abs(xv) < 1) {
+        olc::GFX2D::DrawPartialSprite(&img, 0, img.height / 2, img.width, img.height / 2, transform, true);
+    } else {
+        olc::GFX2D::DrawPartialSprite(&img, 0, 0, img.width, img.height / 2, transform, true);
+    }
+#ifdef _DEBUG
+    float x, y;
+    transform.Forward(0, 0, x, y);
+    game->Draw((int)x, (int)y, olc::RED);
+#endif
 }
 }

src/pabloader/awoorwae.h

 private:
     Awoorwae* game;
     olc::Sprite img;
-    float x;
-    float y;
-    float xv;
-    float yv;
-    float color;
+    olc::GFX2D::Transform2D transform;
+    float x, y;
+    float xv, yv;
+    bool onGround = false;
 
 public:
-    Entity(Awoorwae* game_, float x_, float y_);
+    Entity(Awoorwae* game_);
 
     void Update(float dt);
     void Draw();
-    olc::rcode Load(); 
+    olc::rcode Load();
 };
 
 class Awoorwae : public olc::PixelGameEngine {
     Awoorwae()
     {
         sAppName = "Awoorwa";
-        player = new Entity(this, 128, 128);
+        player = new Entity(this);
     }
 
     ~Awoorwae()