Platformówka - jak to się robi?

#include <SDL/SDL.h>
#include <SDL/SDL_opengl.h>
#include <iostream>
#include "Renderer.h"
 
void Renderer::LoadTexture(const std::string & filename) {
  // załaduj bitmapę z pliku
  SDL_Surface* surface = SDL_LoadBMP(filename.c_str());
  if (!surface) {
    std::cerr << "Ładowanie pliku " + filename + " FAILED: " 
                 + SDL_GetError() + "\n";
    exit(1);
  }
 
  // sprawdź wymiary - czy są potęgą 2
  const int width = surface->w;
  const int height = surface->h;
  if (((width & (width - 1)) != 0) || ((height & (height - 1)) != 0)) {
    std::cerr << "Obrazek " + filename 
                 + " ma nieprawidłowe wymiary (powinny być potęgą 2): "
              << width << "x" << height << "\n";
    exit(1);
  }
 
  GLenum format;
  switch (surface->format->BytesPerPixel) {
     case 3:  format = GL_BGR;   break;
     case 4:  format = GL_BGRA;  break;
     default:  std::cerr << "Nieznany format pliku " + filename + "\n";
               exit(1);
  }
 
  glGenTextures(1, &m_texture);
  glBindTexture(GL_TEXTURE_2D, m_texture);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
  glTexImage2D(GL_TEXTURE_2D, 0, surface->format->BytesPerPixel,
               width, height, 0, format, GL_UNSIGNED_BYTE, surface->pixels);
  if (surface) {
    SDL_FreeSurface(surface);
  }
}
 
void Renderer::DrawSprite(double tex_x, double tex_y, 
                          double tex_w, double tex_h, 
                          double pos_x, double pos_y,
                          double width, double height, 
                          size_t level) {
  const double texture_w = 256.0;    // szerokość atlasu
  const double texture_h = 128.0;    // wysokość atlasu
 
  const double left = tex_x / texture_w;
  const double right = left + tex_w / texture_w;
  const double bottom = tex_y / texture_h;
  const double top = bottom - tex_h / texture_h;
  /* Obrazek ładowany jest do góry nogami, więc punkt (0,0) 
   * jest w lewym górnym rogu tekstury.
   * Stąd wynika, że w powyższym wzorze top jest poniżej bottom
   */
 
  glPushMatrix();  {
    glTranslatef(0, 0, -static_cast<int>(level));
    glBegin(GL_QUADS);  {
      glColor3f(1, 1, 1);
      glTexCoord2f(right, top);     glVertex2f(pos_x+width, pos_y+height);
      glTexCoord2f(left, top);      glVertex2f(pos_x,       pos_y+height);
      glTexCoord2f(left, bottom);   glVertex2f(pos_x,       pos_y);
      glTexCoord2f(right, bottom);  glVertex2f(pos_x+width, pos_y);
    }
    glEnd();
  }
  glPopMatrix();
}

#include "Engine.h"
#include "Sprite.h"
 
Sprite::Sprite(const SpriteConfigData& data) :
  m_data(data), m_current_frame(0), m_current_frame_duration(0.0) { }
 
void Sprite::SetCurrentFrame(size_t frame_num) {
  m_current_frame = frame_num;
  m_current_frame_duration = 0.0;  // początek tej klatki
}
 
void Sprite::Update(double dt) {
  // klatka jest wyświetlana o dt dłużej
  m_current_frame_duration += dt;
 
  // przejdź do następnej klatki jeżeli trzeba
  if (m_current_frame_duration >= m_data.frame_duration_time) {
    m_current_frame++;
    m_current_frame_duration -= m_data.frame_duration_time;
  }
 
  // sprawdź czy nastąpił koniec animacji 
  // - przejdź do klatki 0. lub ostatniej
  if (m_current_frame >= m_data.frame_count) {
    if (m_data.loop) {
      m_current_frame = 0;
    } else {
      m_current_frame = m_data.frame_count - 1;
    }
  }
}
 
void Sprite::DrawCurrentFrame(double x, double y, 
                              double width, double height) {
  Engine::Get().Renderer()->DrawSprite(
                    m_data.left + m_data.width * m_current_frame, 
                    m_data.bottom,
                    m_data.width, m_data.height, 
                    x, y, 
                    width, height, 
                    m_data.level);
}

#include "SpriteConfig.h"
#include "Renderer.h"
 
class Engine {
public:
  // zwraca instancję klasy Engine - jedyną
  static Engine& Get() {
    static Engine engine;
    return engine;
  }
 
  // inicjalizacja klasy Engine - utworzenie instancji odpowiednich klas
  void Load() {
    m_spriteConfig.reset(new SpriteConfig::SpriteConfig());
    m_renderer.reset(new Renderer::Renderer());
  }
 
  SpriteConfigPtr SpriteConfig() {  return m_spriteConfig;  }
  RendererPtr Renderer() {  return m_renderer;  }
 
private:
  SpriteConfigPtr m_spriteConfig;
  RendererPtr m_renderer;
};