Merge pull request #7 from hatkirby/es-rewrite

The ECS rewrite exceeds the original branch in functionality, so it is time to merge it in.

84 files changed, 5950 insertions, 9214 deletions

@@ -0,0 +1,35 @@
+#include "animation.h"
+
+AnimationSet::AnimationSet(
+  Texture texture,
+  int frameWidth,
+  int frameHeight,
+  int framesAcross) :
+    texture_(std::move(texture)),
+    frameWidth_(frameWidth),
+    frameHeight_(frameHeight),
+    framesAcross_(framesAcross)
+{
+}
+
+void AnimationSet::emplaceAnimation(
+  std::string animation,
+  size_t firstFrame,
+  size_t numFrames,
+  size_t delay)
+{
+  animations_.emplace(
+    std::piecewise_construct,
+    std::make_tuple(animation),
+    std::make_tuple(firstFrame, numFrames, delay));
+}
+
+Rectangle AnimationSet::getFrameRect(int frame) const
+{
+  return {
+    frameWidth_ * (frame % framesAcross_),
+    frameHeight_ * (frame / framesAcross_),
+    frameWidth_,
+    frameHeight_
+  };
+}
@@ -0,0 +1,100 @@
+#ifndef ANIMATION_H_74EB0901
+#define ANIMATION_H_74EB0901
+
+#include "renderer/texture.h"
+#include <string>
+#include <map>
+#include <stdexcept>
+
+class Animation {
+public:
+
+  Animation(
+    size_t firstFrame,
+    size_t numFrames,
+    size_t delay) :
+      firstFrame_(firstFrame),
+      numFrames_(numFrames),
+      delay_(delay)
+  {
+  }
+
+  inline size_t getFirstFrame() const
+  {
+    return firstFrame_;
+  }
+
+  inline size_t getNumFrames() const
+  {
+    return numFrames_;
+  }
+
+  inline size_t getDelay() const
+  {
+    return delay_;
+  }
+
+private:
+
+  size_t firstFrame_;
+  size_t numFrames_;
+  size_t delay_;
+};
+
+class AnimationSet {
+public:
+
+  AnimationSet(
+    Texture texture,
+    int frameWidth,
+    int frameHeight,
+    int framesAcross);
+
+  void emplaceAnimation(
+    std::string animation,
+    size_t firstFrame,
+    size_t numFrames,
+    size_t delay);
+
+  inline const Animation& getAnimation(std::string animation) const
+  {
+    if (!animations_.count(animation))
+    {
+      throw std::invalid_argument("Animation does not exist");
+    }
+
+    return animations_.at(animation);
+  }
+
+  inline const Texture& getTexture() const
+  {
+    return texture_;
+  }
+
+  inline int getFrameWidth() const
+  {
+    return frameWidth_;
+  }
+
+  inline int getFrameHeight() const
+  {
+    return frameHeight_;
+  }
+
+  inline int getFramesAcross() const
+  {
+    return framesAcross_;
+  }
+
+  Rectangle getFrameRect(int frame) const;
+
+private:
+
+  std::map<std::string, Animation> animations_;
+  Texture texture_;
+  int frameWidth_;
+  int frameHeight_;
+  int framesAcross_;
+};
+
+#endif /* end of include guard: ANIMATION_H_74EB0901 */
@@ -0,0 +1,11 @@
+#ifndef COMPONENT_H_F0CE4573
+#define COMPONENT_H_F0CE4573
+
+class Component {
+public:
+
+  virtual ~Component() = default;
+
+};
+
+#endif /* end of include guard: COMPONENT_H_F0CE4573 */
@@ -1,142 +0,0 @@
-#include "ai.h"
-#include <cstdlib>
-#include "entity.h"
-
-void AIActionContainer::addAction(std::shared_ptr<AIAction> action)
-{
-  actions.push_back(action);
-}
-
-void AIActionContainer::start(Game& game, Entity& entity)
-{
-  currentAction = begin(actions);
-  
-  if (currentAction != end(actions))
-  {
-    (*currentAction)->start(game, entity);
-  }
-}
-
-void AIActionContainer::perform(Game& game, Entity& entity, double dt)
-{
-  if (!isDone())
-  {
-    (*currentAction)->perform(game, entity, dt);
-  
-    if ((*currentAction)->isDone())
-    {
-      currentAction++;
-      
-      if (!isDone())
-      {
-        (*currentAction)->start(game, entity);
-      }
-    }
-  }
-}
-
-bool AIActionContainer::isDone() const
-{
-  return currentAction == end(actions);
-}
-
-AI::AI(int chance)
-{
-  this->chance = chance;
-}
-
-int AI::getChance() const
-{
-  return chance;
-}
-
-AI& AIComponent::emplaceAI(int chance)
-{
-  maxChance += chance;
-  ais.emplace_back(chance);
-  
-  return ais.back();
-}
-
-void AIComponent::tick(Game& game, Entity& entity, double dt)
-{
-  if (currentAI == nullptr)
-  {
-    int toChoose = rand() % maxChance;
-    for (auto& ai : ais)
-    {
-      if (toChoose < ai.getChance())
-      {
-        currentAI = &ai;
-        break;
-      } else {
-        toChoose -= ai.getChance();
-      }
-    }
-    
-    if (currentAI != nullptr)
-    {
-      currentAI->start(game, entity);
-    }
-  }
-  
-  if (currentAI != nullptr)
-  {
-    currentAI->perform(game, entity, dt);
-  
-    if (currentAI->isDone())
-    {
-      currentAI = nullptr;
-    }
-  }
-}
-
-MoveAIAction::MoveAIAction(Direction dir, int len, int speed)
-{
-  this->dir = dir;
-  this->len = len;
-  this->speed = speed;
-}
-
-void MoveAIAction::start(Game& game, Entity& entity)
-{
-  remaining = len;
-}
-
-void MoveAIAction::perform(Game&, Entity& entity, double dt)
-{
-  double dist = dt * speed;
-  remaining -= dist;
-  
-  switch (dir)
-  {
-    case Direction::Left:
-    {
-      entity.position.first -= dist;
-      break;
-    }
-    
-    case Direction::Right:
-    {
-      entity.position.first += dist;
-      break;
-    }
-    
-    case Direction::Up:
-    {
-      entity.position.second -= dist;
-      break;
-    }
-    
-    case Direction::Down:
-    {
-      entity.position.second += dist;
-      break;
-    }
-  }
-}
-
-bool MoveAIAction::isDone() const
-{
-  return remaining <= 0.0;
-}
@@ -1,73 +0,0 @@
-#ifndef AI_H
-#define AI_H
-
-#include <list>
-#include <map>
-#include <string>
-#include <memory>
-
-#include "entity.h"
-
-class AIAction {
-  public:
-    virtual void start(Game& game, Entity& entity) = 0;
-    virtual void perform(Game& game, Entity& entity, double dt) = 0;
-    virtual bool isDone() const = 0;
-};
-
-class AIActionContainer {
-  public:
-    void addAction(std::shared_ptr<AIAction> action);
-    virtual void start(Game& game, Entity& entity);
-    virtual void perform(Game& game, Entity& entity, double dt);
-    virtual bool isDone() const;
-  
-  private:
-    std::list<std::shared_ptr<AIAction>> actions;
-    std::list<std::shared_ptr<AIAction>>::iterator currentAction {end(actions)};
-};
-
-class AI : public AIActionContainer {
-  public:
-    AI(int chance);
-    
-    int getChance() const;
-    
-  private:
-    int chance;
-};
-
-class AIComponent : public Component {
-  public:
-    AI& emplaceAI(int chance);
-    void tick(Game& game, Entity& entity, double dt);
-
-  private:
-    int maxChance = 0;
-    std::list<AI> ais;
-    AI* currentAI = nullptr;
-};
-
-class MoveAIAction : public AIAction {
-  public:
-    enum class Direction {
-      Left,
-      Right,
-      Up,
-      Down
-    };
-    
-    MoveAIAction(Direction dir, int len, int speed);
-    
-    void start(Game& game, Entity& entity);
-    void perform(Game& game, Entity& entity, double dt);
-    bool isDone() const;
-    
-  private:
-    Direction dir;
-    int len;
-    int speed;
-    double remaining;
-};
-
-#endif /* end of include guard: AI_H */
@@ -0,0 +1,93 @@
+#ifndef SPRITE_RENDERABLE_H_D3AACBBF
+#define SPRITE_RENDERABLE_H_D3AACBBF
+
+#include "component.h"
+#include "animation.h"
+#include <string>
+
+class AnimatableComponent : public Component {
+public:
+
+  /**
+   * Constructor for initializing the animation set, because it is not default
+   * constructible.
+   */
+  AnimatableComponent(
+    AnimationSet animationSet) :
+      animationSet(std::move(animationSet))
+  {
+  }
+
+  /**
+   * The animation set that this entity will use -- an object describing the
+   * different animations that can be used to render the entity.
+   *
+   * @managed_by RealizingSystem
+   */
+  AnimationSet animationSet;
+
+  /**
+   * The name of the currently active animation.
+   *
+   * @managed_by AnimatingSystem
+   */
+  std::string animation;
+
+  /**
+   * For prototypes, the name of the original animation.
+   *
+   * @managed_by RealizingSystem
+   */
+  std::string origAnimation;
+
+  /**
+   * Helper method for accessing the currently active animation.
+   */
+  inline const Animation& getAnimation() const
+  {
+    return animationSet.getAnimation(animation);
+  }
+
+  /**
+   * The frame of animation that is currently being rendered.
+   *
+   * @managed_by AnimatingSystem
+   */
+  size_t frame = 0;
+
+  /**
+   * The amount of time (in game frames) before the animation is advanced.
+   *
+   * @managed_by AnimatingSystem
+   */
+  size_t countdown = 0;
+
+  /**
+   * This option allows to give the sprite a "flickering" effect (as in, it is
+   * not rendered in some frames).
+   */
+  bool flickering = false;
+
+  /**
+   * Used for the flickering effect.
+   *
+   * @managed_by AnimatingSystem
+   */
+  size_t flickerTimer = 0;
+
+  /**
+   * If enabled, this will prevent the sprite's animation from progressing (but
+   * will not affect things such as placement on screen and flickering).
+   */
+  bool frozen = false;
+
+  /**
+   * If this flag is disabled, the entity will be ignored by the animating
+   * system.
+   *
+   * @managed_by RealizingSystem
+   */
+  bool active = false;
+};
+
+#endif /* end of include guard: SPRITE_RENDERABLE_H_D3AACBBF */
@@ -0,0 +1,34 @@
+#ifndef AUTOMATABLE_H_FACB42A5
+#define AUTOMATABLE_H_FACB42A5
+
+#include "component.h"
+#include "entity_manager.h"
+
+class AutomatableComponent : public Component {
+public:
+
+  using id_type = EntityManager::id_type;
+
+  /**
+   * Controls what script will be run as this entity's behavior. It should refer
+   * to a table in the global namespace of the script engine state, and that
+   * table should contain a function called "Behavior".
+   */
+  std::string table;
+
+  /**
+   * Whether or not the behavior script is running.
+   *
+   * @managed_by ScriptingSystem
+   */
+  bool running = false;
+
+  /**
+   * The entity ID of the running script, if there is one.
+   *
+   * @managed_by ScriptingSystem
+   */
+  id_type script;
+};
+
+#endif /* end of include guard: AUTOMATABLE_H_FACB42A5 */
@@ -0,0 +1,92 @@
+#ifndef CONTROLLABLE_H_4E0B85B4
+#define CONTROLLABLE_H_4E0B85B4
+
+#include "component.h"
+#include "renderer/gl.h"
+
+class ControllableComponent : public Component {
+public:
+
+  inline int getLeftKey() const
+  {
+    return leftKey_;
+  }
+
+  inline void setLeftKey(int k)
+  {
+    leftKey_ = k;
+  }
+
+  inline int getRightKey() const
+  {
+    return rightKey_;
+  }
+
+  inline void setRightKey(int k)
+  {
+    rightKey_ = k;
+  }
+
+  inline int getJumpKey() const
+  {
+    return jumpKey_;
+  }
+
+  inline void setJumpKey(int k)
+  {
+    jumpKey_ = k;
+  }
+
+  inline int getDropKey() const
+  {
+    return dropKey_;
+  }
+
+  inline void setDropKey(int k)
+  {
+    dropKey_ = k;
+  }
+
+  inline bool isFrozen() const
+  {
+    return frozen_;
+  }
+
+  inline void setFrozen(bool f)
+  {
+    frozen_ = f;
+  }
+
+  inline bool isHoldingLeft() const
+  {
+    return holdingLeft_;
+  }
+
+  inline void setHoldingLeft(bool f)
+  {
+    holdingLeft_ = f;
+  }
+
+  inline bool isHoldingRight() const
+  {
+    return holdingRight_;
+  }
+
+  inline void setHoldingRight(bool f)
+  {
+    holdingRight_ = f;
+  }
+
+private:
+
+  int leftKey_ = GLFW_KEY_LEFT;
+  int rightKey_ = GLFW_KEY_RIGHT;
+  int jumpKey_ = GLFW_KEY_UP;
+  int dropKey_ = GLFW_KEY_DOWN;
+
+  bool frozen_ = false;
+  bool holdingLeft_ = false;
+  bool holdingRight_ = false;
+};
+
+#endif /* end of include guard: CONTROLLABLE_H_4E0B85B4 */
@@ -1,241 +0,0 @@
-#include "map_collision.h"
-#include "map.h"
-#include "game.h"
-#include "consts.h"
-
-MapCollisionComponent::MapCollisionComponent(const Map& map) : map(map)
-{
-  addCollision(-6, 0, MAP_HEIGHT*TILE_HEIGHT, Direction::left, collisionFromMoveType(map.getAdjacent(Map::MoveDir::Left).type));
-  addCollision(GAME_WIDTH+6, 0, MAP_HEIGHT*TILE_HEIGHT, Direction::right, collisionFromMoveType(map.getAdjacent(Map::MoveDir::Right).type));
-  addCollision(-6, 0, GAME_WIDTH, Direction::up, collisionFromMoveType(map.getAdjacent(Map::MoveDir::Up).type));
-  addCollision(MAP_HEIGHT*TILE_HEIGHT+6, 0, GAME_WIDTH, Direction::down, collisionFromMoveType(map.getAdjacent(Map::MoveDir::Down).type));
-  
-  for (int i=0; i<MAP_WIDTH*MAP_HEIGHT; i++)
-  {
-    int x = i % MAP_WIDTH;
-    int y = i / MAP_WIDTH;
-    int tile = map.getMapdata()[i];
-    
-    if ((tile > 0) && (tile < 28) && (!((tile >= 5) && (tile <= 7))))
-    {
-      addCollision(x*TILE_WIDTH, y*TILE_HEIGHT, (y+1)*TILE_HEIGHT, Direction::right, Collision::Type::wall);
-      addCollision((x+1)*TILE_WIDTH, y*TILE_HEIGHT, (y+1)*TILE_HEIGHT, Direction::left, Collision::Type::wall);
-      addCollision(y*TILE_HEIGHT, x*TILE_WIDTH, (x+1)*TILE_WIDTH, Direction::down, Collision::Type::wall);
-      addCollision((y+1)*TILE_HEIGHT, x*TILE_WIDTH, (x+1)*TILE_WIDTH, Direction::up, Collision::Type::wall);
-    } else if ((tile >= 5) && (tile <= 7))
-    {
-      addCollision(y*TILE_HEIGHT, x*TILE_WIDTH, (x+1)*TILE_WIDTH, Direction::down, Collision::Type::platform);
-    } else if (tile == 42)
-    {
-      addCollision(y*TILE_HEIGHT, x*TILE_WIDTH, (x+1)*TILE_WIDTH, Direction::down, Collision::Type::danger);
-    }
-  }
-}
-
-void MapCollisionComponent::addCollision(double axis, double lower, double
-   upper, Direction dir, Collision::Type type)
-{
-  std::list<Collision>::iterator it;
-  
-  switch (dir)
-  {
-    case Direction::up:
-      it = up_collisions.begin();
-      for (; it!=up_collisions.end(); it++)
-      {
-        if (it->axis < axis) break;
-      }
-    
-      up_collisions.insert(it, {axis, lower, upper, type});
-      
-      break;
-    case Direction::down:
-      it = down_collisions.begin();
-      for (; it!=down_collisions.end(); it++)
-      {
-        if (it->axis > axis) break;
-      }
-    
-      down_collisions.insert(it, {axis, lower, upper, type});
-      
-      break;
-    case Direction::left:
-      it = left_collisions.begin();
-      for (; it!=left_collisions.end(); it++)
-      {
-        if (it->axis < axis) break;
-      }
-  
-      left_collisions.insert(it, {axis, lower, upper, type});
-      
-      break;
-    case Direction::right:
-      it = right_collisions.begin();
-      for (; it!=right_collisions.end(); it++)
-      {
-        if (it->axis > axis) break;
-      }
-  
-      right_collisions.insert(it, {axis, lower, upper, type});
-      
-      break;
-  }
-}
-
-void MapCollisionComponent::detectCollision(Game& game, Entity&, Entity& collider, std::pair<double, double> old_position)
-{
-  if (collider.position.first < old_position.first)
-  {
-    for (auto collision : left_collisions)
-    {
-      if (collision.axis > old_position.first) continue;
-      if (collision.axis < collider.position.first) break;
-  
-      if ((old_position.second+collider.size.second > collision.lower) && (old_position.second < collision.upper))
-      {
-        // We have a collision!
-        processCollision(game, collider, collision, Direction::left, old_position);
-    
-        break;
-      }
-    }
-  } else if (collider.position.first > old_position.first)
-  {
-    for (auto collision : right_collisions)
-    {
-      if (collision.axis < old_position.first+collider.size.first) continue;
-      if (collision.axis > collider.position.first+collider.size.first) break;
-  
-      if ((old_position.second+collider.size.second > collision.lower) && (old_position.second < collision.upper))
-      {
-        // We have a collision!
-        processCollision(game, collider, collision, Direction::right, old_position);
-    
-        break;
-      }
-    }
-  }
-  
-  if (collider.position.second < old_position.second)
-  {
-    for (auto collision : up_collisions)
-    {
-      if (collision.axis > old_position.second) continue;
-      if (collision.axis < collider.position.second) break;
-  
-      if ((collider.position.first+collider.size.first > collision.lower) && (collider.position.first < collision.upper))
-      {
-        // We have a collision!
-        processCollision(game, collider, collision, Direction::up, old_position);
-    
-        break;
-      }
-    }
-  } else if (collider.position.second > old_position.second)
-  {
-    for (auto collision : down_collisions)
-    {
-      if (collision.axis < old_position.second+collider.size.second) continue;
-      if (collision.axis > collider.position.second+collider.size.second) break;
-
-      if ((collider.position.first+collider.size.first > collision.lower) && (collider.position.first < collision.upper))
-      {
-        // We have a collision!
-        processCollision(game, collider, collision, Direction::down, old_position);
-        
-        break;
-      }
-    }
-  }
-}
-
-void MapCollisionComponent::processCollision(Game& game, Entity& collider, Collision collision, Direction dir, std::pair<double, double> old_position)
-{
-  if (collision.type == Collision::Type::wall)
-  {
-    if (dir == Direction::left)
-    {
-      collider.position.first = collision.axis;
-      
-      Message msg(Message::Type::setHorizontalVelocity);
-      msg.velocity = 0.0;
-      collider.send(game, msg);
-    } else if (dir == Direction::right)
-    {
-      collider.position.first = collision.axis - collider.size.first;
-
-      Message msg(Message::Type::setHorizontalVelocity);
-      msg.velocity = 0.0;
-      collider.send(game, msg);
-    } else if (dir == Direction::up)
-    {
-      collider.position.second = collision.axis;
-
-      Message msg(Message::Type::setVerticalVelocity);
-      msg.velocity = 0.0;
-      collider.send(game, msg);
-    } else if (dir == Direction::down)
-    {
-      collider.position.second = collision.axis - collider.size.second;
-      collider.send(game, Message::Type::hitTheGround);
-    }
-  } else if (collision.type == Collision::Type::wrap)
-  {
-    if (dir == Direction::left)
-    {
-      collider.position.first = GAME_WIDTH-collider.size.first/2;
-    } else if (dir == Direction::right)
-    {
-      collider.position.first = -collider.size.first/2;
-    } else if (dir == Direction::up)
-    {
-      collider.position.second = GAME_HEIGHT-collider.size.second/2-1;
-    } else if (dir == Direction::down)
-    {
-      collider.position.second = -collider.size.second/2;
-    }
-  } else if (collision.type == Collision::Type::teleport)
-  {
-    if (dir == Direction::left)
-    {
-      game.loadMap(game.getWorld().getMap(map.getAdjacent(Map::MoveDir::Left).map), std::make_pair(GAME_WIDTH-collider.size.first/2, old_position.second));
-    } else if (dir == Direction::right)
-    {
-      game.loadMap(game.getWorld().getMap(map.getAdjacent(Map::MoveDir::Right).map), std::make_pair(-collider.size.first/2, old_position.second));
-    } else if (dir == Direction::up)
-    {
-      game.loadMap(game.getWorld().getMap(map.getAdjacent(Map::MoveDir::Up).map), std::make_pair(old_position.first, MAP_HEIGHT*TILE_HEIGHT-collider.size.second/2));
-    } else if (dir == Direction::down)
-    {
-      game.loadMap(game.getWorld().getMap(map.getAdjacent(Map::MoveDir::Down).map), std::make_pair(old_position.first, -collider.size.second/2));
-    }
-  } else if (collision.type == Collision::Type::reverse)
-  {
-    // TODO reverse
-    if (dir == Direction::right)
-    {
-      collider.position.first = collision.axis - collider.size.first;
-      collider.send(game, Message::Type::walkLeft);
-    }
-  } else if (collision.type == Collision::Type::platform)
-  {
-    Message msg(Message::Type::drop);
-    msg.dropAxis = collision.axis;
-
-    collider.send(game, msg);
-  } else if (collision.type == Collision::Type::danger)
-  {
-    game.playerDie();
-  }
-}
-
-MapCollisionComponent::Collision::Type MapCollisionComponent::collisionFromMoveType(Map::MoveType type)
-{
-  switch (type)
-  {
-    case Map::MoveType::Wall: return Collision::Type::wall;
-    case Map::MoveType::Wrap: return Collision::Type::wrap;
-    case Map::MoveType::Warp: return Collision::Type::teleport;
-    case Map::MoveType::ReverseWarp: return Collision::Type::reverse;
-  }
-}
@@ -1,47 +0,0 @@
-#ifndef MAP_COLLISION_H
-#define MAP_COLLISION_H
-
-#include "entity.h"
-#include "map.h"
-#include <list>
-
-class Game;
-
-class MapCollisionComponent : public Component {
-  public:
-    MapCollisionComponent(const Map& map);
-    void detectCollision(Game& game, Entity& entity, Entity& collider, std::pair<double, double> old_position);
-    
-  private:
-    enum class Direction {
-      up, left, down, right
-    };
-
-    struct Collision {
-      enum class Type {
-        wall,
-        wrap,
-        teleport,
-        reverse,
-        platform,
-        danger
-      };
-      
-      double axis;
-      double lower;
-      double upper;
-      Type type;
-    };
-    
-    void addCollision(double axis, double lower, double upper, Direction dir, Collision::Type type);
-    void processCollision(Game& game, Entity& collider, Collision collision, Direction dir, std::pair<double, double> old_position);
-    Collision::Type collisionFromMoveType(Map::MoveType type);
-    
-    std::list<Collision> left_collisions;
-    std::list<Collision> right_collisions;
-    std::list<Collision> up_collisions;
-    std::list<Collision> down_collisions;
-    const Map& map;
-};
-
-#endif
@@ -1,40 +0,0 @@
-#include "map_render.h"
-#include "map.h"
-#include "game.h"
-#include "consts.h"
-
-MapRenderComponent::MapRenderComponent(const Map& map) : screen(GAME_WIDTH, GAME_HEIGHT)
-{
-  screen.fill(screen.entirety(), 0, 0, 0);
-  
-  Texture tiles("res/tiles.png");
-  
-  for (int i=0; i<MAP_WIDTH*MAP_HEIGHT; i++)
-  {
-    int tile = map.getMapdata()[i];
-    int x = i % MAP_WIDTH;
-    int y = i / MAP_WIDTH;
-    Rectangle dst {x*TILE_WIDTH, y*TILE_HEIGHT, TILE_WIDTH, TILE_HEIGHT};
-    Rectangle src {tile%8*TILE_WIDTH, tile/8*TILE_HEIGHT, TILE_WIDTH, TILE_HEIGHT};
-
-    if (tile > 0)
-    {
-      screen.blit(tiles, src, dst);
-    }
-  }
-  
-  Texture font("res/font.bmp");
-  std::string map_name = map.getTitle();
-  int start_x = (40/2) - (map_name.length()/2);
-  for (size_t i=0; i<map_name.length(); i++)
-  {
-    Rectangle srcRect {map_name[i] % 16 * 8, map_name[i] / 16 * 8, 8, 8};
-    Rectangle dstRect {(start_x + (int)i)*8, 24*8, 8, 8};
-    screen.blit(font, srcRect, dstRect);
-  }
-}
-
-void MapRenderComponent::render(Game&, Entity&, Texture& buffer)
-{
-  buffer.blit(screen, screen.entirety(), buffer.entirety());
-}
@@ -1,19 +0,0 @@
-#ifndef MAP_RENDER_H
-#define MAP_RENDER_H
-
-#include "entity.h"
-#include "renderer.h"
-
-class Map;
-class Game;
-
-class MapRenderComponent : public Component {
-  public:
-    MapRenderComponent(const Map& map);
-    void render(Game& game, Entity& entity, Texture& buffer);
-    
-  private:
-    Texture screen;
-};
-
-#endif
@@ -0,0 +1,152 @@
+#ifndef MAPPABLE_H_0B0316FB
+#define MAPPABLE_H_0B0316FB
+
+#include <map>
+#include <string>
+#include <vector>
+#include <list>
+#include "component.h"
+#include "renderer/texture.h"
+#include "components/ponderable.h"
+#include "entity_manager.h"
+
+class MappableComponent : public Component {
+public:
+
+  using id_type = EntityManager::id_type;
+
+  /**
+   * Helper type that stores information about map adjacency.
+   */
+  class Adjacent {
+  public:
+
+    enum class Type {
+      wall,
+      wrap,
+      warp,
+      reverse
+    };
+
+    Adjacent(
+      Type type = Type::wall,
+      size_t mapId = 0) :
+        type(type),
+        mapId(mapId)
+    {
+    }
+
+    Type type;
+    size_t mapId;
+  };
+
+  /**
+   * Helper type that stores information about collision boundaries.
+   */
+  class Boundary {
+  public:
+
+    using Type = PonderableComponent::Collision;
+
+    Boundary(
+      double axis,
+      double lower,
+      double upper,
+      Type type) :
+        axis(axis),
+        lower(lower),
+        upper(upper),
+        type(type)
+    {
+    }
+
+    double axis;
+    double lower;
+    double upper;
+    Type type;
+  };
+
+  /**
+   * Helper types for efficient storage and lookup of collision boundaries.
+   */
+  using asc_boundaries_type =
+    std::multimap<
+      double,
+      const Boundary,
+      std::less<double>>;
+
+  using desc_boundaries_type =
+    std::multimap<
+      double,
+      const Boundary,
+      std::greater<double>>;
+
+  /**
+   * Constructor for initializing the tileset and font attributes, as they are
+   * not default constructible.
+   */
+  MappableComponent(
+    Texture tileset,
+    Texture font) :
+      tileset(std::move(tileset)),
+      font(std::move(font))
+  {
+  }
+
+  /**
+   * The ID of the map in the world definition that this entity represents.
+   *
+   * @managed_by RealizingSystem
+   */
+  size_t mapId;
+
+  /**
+   * The title of the map, which is displayed at the bottom of the screen.
+   */
+  std::string title;
+
+  /**
+   * The map data.
+   *
+   * @managed_by RealizingSystem
+   */
+  std::vector<int> tiles;
+
+  /**
+   * These objects describe the behavior of the four edges of the map.
+   *
+   * @managed_by RealizingSystem
+   */
+  Adjacent leftAdjacent;
+  Adjacent rightAdjacent;
+  Adjacent upAdjacent;
+  Adjacent downAdjacent;
+
+  /**
+   * Collision boundaries, for detecting when a ponderable entity is colliding
+   * with the environment.
+   *
+   * @managed_by MappingSystem
+   */
+  desc_boundaries_type leftBoundaries;
+  asc_boundaries_type rightBoundaries;
+  desc_boundaries_type upBoundaries;
+  asc_boundaries_type downBoundaries;
+
+  /**
+   * The list of entities representing the objects owned by the map.
+   *
+   * @managed_by RealizingSystem
+   */
+  std::list<id_type> objects;
+
+  /**
+   * The tilesets for the map and the map name.
+   *
+   * TODO: These probably do not belong here.
+   */
+  Texture tileset;
+  Texture font;
+};
+
+#endif /* end of include guard: MAPPABLE_H_0B0316FB */
@@ -0,0 +1,69 @@
+#ifndef ORIENTABLE_H_EDB6C4A1
+#define ORIENTABLE_H_EDB6C4A1
+
+#include "component.h"
+
+class OrientableComponent : public Component {
+public:
+
+  enum class WalkState {
+    still,
+    left,
+    right
+  };
+
+  enum class DropState {
+    none,
+    ready,
+    active
+  };
+
+  inline bool isFacingRight() const
+  {
+    return facingRight_;
+  }
+
+  inline void setFacingRight(bool v)
+  {
+    facingRight_ = v;
+  }
+
+  inline WalkState getWalkState() const
+  {
+    return walkState_;
+  }
+
+  inline void setWalkState(WalkState v)
+  {
+    walkState_ = v;
+  }
+
+  inline bool isJumping() const
+  {
+    return jumping_;
+  }
+
+  inline void setJumping(bool v)
+  {
+    jumping_ = v;
+  }
+
+  inline DropState getDropState() const
+  {
+    return dropState_;
+  }
+
+  inline void setDropState(DropState v)
+  {
+    dropState_ = v;
+  }
+
+private:
+
+  bool facingRight_ = false;
+  WalkState walkState_ = WalkState::still;
+  bool jumping_ = false;
+  DropState dropState_ = DropState::none;
+};
+
+#endif /* end of include guard: ORIENTABLE_H_EDB6C4A1 */
@@ -1,66 +0,0 @@
-#include "physics_body.h"
-#include "game.h"
-#include "consts.h"
-
-void PhysicsBodyComponent::receive(Game&, Entity&, const Message& msg)
-{
-  if (msg.type == Message::Type::walkLeft)
-  {
-    velocity.first = -90;
-  } else if (msg.type == Message::Type::walkRight)
-  {
-    velocity.first = 90;
-  } else if (msg.type == Message::Type::stopWalking)
-  {
-    velocity.first = 0.0;
-  } else if (msg.type == Message::Type::setHorizontalVelocity)
-  {
-    velocity.first = msg.velocity;
-  } else if (msg.type == Message::Type::setVerticalVelocity)
-  {
-    velocity.second = msg.velocity;
-  }
-}
-
-void PhysicsBodyComponent::tick(Game&, Entity& entity, double dt)
-{
-  // Accelerate
-  velocity.first += accel.first * dt;
-  velocity.second += accel.second * dt;
-  
-  // Terminal velocity
-#define TERMINAL_VELOCITY_X (2 * TILE_WIDTH * FRAMES_PER_SECOND)
-#define TERMINAL_VELOCITY_Y (2 * TILE_HEIGHT * FRAMES_PER_SECOND)
-  if (velocity.first < -TERMINAL_VELOCITY_X) velocity.first = -TERMINAL_VELOCITY_X;
-  if (velocity.first > TERMINAL_VELOCITY_X) velocity.first = TERMINAL_VELOCITY_X;
-  if (velocity.second < -TERMINAL_VELOCITY_Y) velocity.second = -TERMINAL_VELOCITY_Y;
-  if (velocity.second > TERMINAL_VELOCITY_Y) velocity.second = TERMINAL_VELOCITY_Y;
-  
-  // Do the movement
-  entity.position.first += velocity.first * dt;
-  entity.position.second += velocity.second * dt;
-}
-
-void PhysicsBodyComponent::detectCollision(Game& game, Entity& entity, Entity& collider, std::pair<double, double> old_position)
-{
-  // If already colliding, do nothing!
-  if ((old_position.first + collider.size.first > entity.position.first)
-    && (old_position.first < entity.position.first + entity.size.first)
-    && (old_position.second + collider.size.second > entity.position.second)
-    && (old_position.second < entity.position.second + entity.size.second))
-  {
-    return;
-  }
-  
-  // If newly colliding, SHOCK AND HORROR!
-  if ((collider.position.first + collider.size.first > entity.position.first)
-    && (collider.position.first < entity.position.first + entity.size.first)
-    && (collider.position.second + collider.size.second > entity.position.second)
-    && (collider.position.second < entity.position.second + entity.size.second))
-  {
-    Message msg(Message::Type::collision);
-    msg.collisionEntity = &collider;
-    
-    entity.send(game, msg);
-  }
-}
@@ -1,20 +0,0 @@
-#ifndef PHYSICS_BODY_H
-#define PHYSICS_BODY_H
-
-#include "entity.h"
-#include <utility>
-
-class Game;
-
-class PhysicsBodyComponent : public Component {
-  public:
-    void receive(Game& game, Entity& entity, const Message& msg);
-    void tick(Game& game, Entity& entity, double dt);
-    void detectCollision(Game& game, Entity& entity, Entity& collider, std::pair<double, double> old_position);
-    
-  protected:    
-    std::pair<double, double> velocity;
-    std::pair<double, double> accel;
-};
-
-#endif
@@ -0,0 +1,35 @@
+#ifndef PLAYABLE_H_DDC566C3
+#define PLAYABLE_H_DDC566C3
+
+#include "component.h"
+#include "entity_manager.h"
+#include "vector.h"
+
+class PlayableComponent : public Component {
+public:
+
+  using id_type = EntityManager::id_type;
+
+  /**
+   * The entity ID of the map that the player is on.
+   *
+   * @managed_by PlayingSystem
+   */
+  id_type mapId;
+
+  /**
+   * The map ID and coordinates of the location that the player will spawn after
+   * dying. Note that the map ID here is a world description map ID, not an
+   * entity ID.
+   *
+   * @managed_by PlayingSystem
+   */
+  size_t checkpointMapId;
+  vec2d checkpointPos;
+
+  bool checkpointMapObject = false;
+  size_t checkpointMapObjectIndex;
+
+};
+
+#endif /* end of include guard: PLAYABLE_H_DDC566C3 */
@@ -1,118 +0,0 @@
-#include "player_physics.h"
-#include "muxer.h"
-#include "game.h"
-#include "consts.h"
-
-#define JUMP_VELOCITY(h, l) (-2 * (h) / (l))
-#define JUMP_GRAVITY(h, l) (2 * ((h) / (l)) / (l))
-
-PlayerPhysicsComponent::PlayerPhysicsComponent()
-{
-  jump_velocity = JUMP_VELOCITY(TILE_HEIGHT*4.5, 0.3);
-  jump_gravity = JUMP_GRAVITY(TILE_HEIGHT*4.5, 0.3);
-  jump_gravity_short = JUMP_GRAVITY(TILE_HEIGHT*3.5, 0.233);
-  
-  accel.second = jump_gravity_short;
-}
-
-void PlayerPhysicsComponent::receive(Game&, Entity& entity, const Message& msg)
-{
-  if (msg.type == Message::Type::walkLeft)
-  {
-    velocity.first = -90;
-    direction = -1;
-  } else if (msg.type == Message::Type::walkRight)
-  {
-    velocity.first = 90;
-    direction = 1;
-  } else if (msg.type == Message::Type::stopWalking)
-  {
-    velocity.first = 0.0;
-    direction = 0;
-  } else if (msg.type == Message::Type::setHorizontalVelocity)
-  {
-    velocity.first = msg.velocity;
-  } else if (msg.type == Message::Type::setVerticalVelocity)
-  {
-    velocity.second = msg.velocity;
-  } else if (msg.type == Message::Type::hitTheGround)
-  {
-    if (isFalling)
-    {
-      playSound("res/Randomize27.wav", 0.05);
-      isFalling = false;
-    }
-    
-    velocity.second = 0.0;
-  } else if (msg.type == Message::Type::jump)
-  {
-    playSound("res/Randomize87.wav", 0.25);
-    
-    velocity.second = jump_velocity;
-    accel.second = jump_gravity;
-  } else if (msg.type == Message::Type::stopJump)
-  {
-    accel.second = jump_gravity_short;
-  } else if (msg.type == Message::Type::canDrop)
-  {
-    canDrop = true;
-  } else if (msg.type == Message::Type::cantDrop)
-  {
-    canDrop = false;
-  } else if (msg.type == Message::Type::drop)
-  {
-    if (canDrop)
-    {
-      canDrop = false;
-    } else {
-      entity.position.second = msg.dropAxis - entity.size.second;
-      velocity.second = 0;
-    }
-  } else if (msg.type == Message::Type::die)
-  {
-    frozen = true;
-  } else if (msg.type == Message::Type::stopDying)
-  {
-    frozen = false;
-  }
-}
-
-void PlayerPhysicsComponent::tick(Game& game, Entity& entity, double dt)
-{
-  // If frozen, do nothing
-  if (frozen)
-  {
-    return;
-  }
-  
-  // Continue walking even if blocked earlier
-  if (velocity.first == 0)
-  {
-    if (direction < 0)
-    {
-      velocity.first = -90;
-    } else if (direction > 0)
-    {
-      velocity.first = 90;
-    }
-  }
-  
-  // Increase gravity at the height of jump
-  if ((accel.second == jump_gravity) && (velocity.second >= 0))
-  {
-    accel.second = jump_gravity_short;
-  }
-  
-  // Do the movement
-  std::pair<double, double> old_position = entity.position;
-  PhysicsBodyComponent::tick(game, entity, dt);
-    
-  // Check for collisions
-  game.detectCollision(entity, old_position);
-  
-  // Are we moving due to gravity?
-  if (velocity.second != 0.0)
-  {
-    isFalling = true;
-  }
-}
@@ -1,25 +0,0 @@
-#ifndef PLAYER_PHYSICS_H
-#define PLAYER_PHYSICS_H
-
-#include "entity.h"
-#include "physics_body.h"
-
-class Game;
-
-class PlayerPhysicsComponent : public PhysicsBodyComponent {
-  public:
-    PlayerPhysicsComponent();
-    void tick(Game& game, Entity& entity, double dt);
-    void receive(Game& game, Entity& entity, const Message& msg);
-    
-  private:
-    double jump_velocity;
-    double jump_gravity;
-    double jump_gravity_short;
-    int direction = 0;
-    bool canDrop = false;
-    bool frozen = false;
-    bool isFalling = false;
-};
-
-#endif
@@ -1,60 +0,0 @@
-#include "player_sprite.h"
-
-PlayerSpriteComponent::PlayerSpriteComponent() : sprite("res/Starla.png")
-{
-  
-}
-
-void PlayerSpriteComponent::render(Game&, Entity& entity, Texture& buffer)
-{
-  animFrame++;
-  
-  int frame = 0;
-  if (isMoving)
-  {
-    frame += 2;
-    
-    if (animFrame % 20 < 10)
-    {
-      frame += 2;
-    }
-  }
-  
-  if (facingLeft)
-  {
-    frame++;
-  }
-  
-  double alpha = 1.0;
-  if (dying && (animFrame % 4 < 2))
-  {
-    alpha = 0.0;
-  }
-  
-  Rectangle src_rect {frame*10, 0, 10, 12};
-  Rectangle dst_rect {(int) entity.position.first, (int) entity.position.second, entity.size.first, entity.size.second};
-  buffer.blit(sprite, src_rect, dst_rect, alpha);
-}
-
-void PlayerSpriteComponent::receive(Game&, Entity&, const Message& msg)
-{
-  if (msg.type == Message::Type::walkLeft)
-  {
-    facingLeft = true;
-    isMoving = true;
-  } else if (msg.type == Message::Type::walkRight)
-  {
-    facingLeft = false;
-    isMoving = true;
-  } else if (msg.type == Message::Type::stopWalking)
-  {
-    isMoving = false;
-  } else if (msg.type == Message::Type::die)
-  {
-    dying = true;
-    isMoving = false;
-  } else if (msg.type == Message::Type::stopDying)
-  {
-    dying = false;
-  }
-}
@@ -1,23 +0,0 @@
-#ifndef PLAYER_SPRITE_H
-#define PLAYER_SPRITE_H
-
-#include "entity.h"
-#include "renderer.h"
-
-class Game;
-
-class PlayerSpriteComponent : public Component {
-  public:
-    PlayerSpriteComponent();
-    void render(Game& game, Entity& entity, Texture& buffer);
-    void receive(Game& game, Entity& entity, const Message& msg);
-    
-  private:
-    Texture sprite;
-    int animFrame = 0;
-    bool facingLeft = false;
-    bool isMoving = false;
-    bool dying = false;
-};
-
-#endif
@@ -0,0 +1,131 @@
+#ifndef TANGIBLE_H_746DB3EE
+#define TANGIBLE_H_746DB3EE
+
+#include <set>
+#include "component.h"
+#include "entity_manager.h"
+#include "vector.h"
+#include "direction.h"
+
+class PonderableComponent : public Component {
+public:
+
+  using id_type = EntityManager::id_type;
+
+  /**
+   * List of different types of physical bodies.
+   *
+   * vacuumed     - Default.
+   * freefalling  - The body will be treated as if there were a downward force
+   *                of gravity being exerted onto it. The body will also exhibit
+   *                terminal velocity (that is, its downward velocity will be
+   *                capped at a constant value).
+   */
+  enum class Type {
+    vacuumed,
+    freefalling
+  };
+
+  /**
+   * List of different types of collidable surfaces.
+   */
+  enum class Collision {
+    wall,
+    platform,
+    adjacency,
+    warp,
+    danger,
+    event
+  };
+
+  /**
+   * Constructor for initializing the body type, which is a constant.
+   */
+  PonderableComponent(Type type) : type(type)
+  {
+  }
+
+  /**
+   * The velocity of the body.
+   */
+  vec2d vel = { 0.0, 0.0 };
+
+  /**
+   * The acceleration of the body.
+   */
+  vec2d accel = { 0.0, 0.0 };
+
+  /**
+   * The type of physical body that the entity is meant to assume. The body will
+   * be acted upon differently based on this. See the enumeration above for more
+   * details.
+   *
+   * @managed_by PonderingSystem
+   */
+  const Type type;
+
+  /**
+   * Whether or not a freefalling body is in contact with the ground.
+   *
+   * @managed_by PonderingSystem
+   */
+  bool grounded = false;
+
+  /**
+   * Whether or not a freefalling body is being ferried by another body.
+   *
+   * @managed_by PonderingSystem
+   */
+  bool ferried = false;
+
+  /**
+   * The entity that is ferrying this body, if there is one.
+   *
+   * @managed_by PonderingSystem
+   */
+  id_type ferry;
+
+  /**
+   * The side of the ferry that the body is resting on, if there is one.
+   *
+   * @managed_by PonderingSystem
+   */
+  Direction ferrySide;
+
+  /**
+   * The bodies that are being ferried by this body.
+   *
+   * @managed_by PonderingSystem
+   */
+  std::set<id_type> passengers;
+
+  /**
+   * If enabled, this will prevent the body from moving and accelerating. The
+   * velocity and position of the body can still be affected by sources external
+   * to the PonderingSystem. Enabling this will cause applicable bodies to
+   * become ungrounded and unferried.
+   */
+  bool frozen = false;
+
+  /**
+   * If disabled, collision detection for this body will not be performed and
+   * other bodies will ignore it. Disabling this will cause applicable bodies to
+   * become ungrounded and unferried.
+   */
+  bool collidable = true;
+
+  /**
+   * The effect that colliding with this body has.
+   */
+  Collision colliderType = Collision::wall;
+
+  /**
+   * If this flag is disabled, the entity will be ignored by the pondering
+   * system.
+   *
+   * @managed_by RealizingSystem
+   */
+  bool active = false;
+};
+
+#endif /* end of include guard: TANGIBLE_H_746DB3EE */
@@ -0,0 +1,23 @@
+#ifndef PROTOTYPABLE_H_817F2205
+#define PROTOTYPABLE_H_817F2205
+
+#include "component.h"
+#include "entity_manager.h"
+
+class PrototypableComponent : public Component {
+public:
+
+  using id_type = EntityManager::id_type;
+
+  /**
+   * The index of the object in the map definition.
+   */
+  size_t mapObjectIndex;
+
+  /**
+   * The name of the prototype that the object was spawned from.
+   */
+  std::string prototypeId;
+};
+
+#endif /* end of include guard: PROTOTYPABLE_H_817F2205 */
@@ -0,0 +1,51 @@
+#ifndef AUTOMATABLE_H_3D519131
+#define AUTOMATABLE_H_3D519131
+
+#include "component.h"
+#include <sol.hpp>
+#include <memory>
+#include "entity_manager.h"
+
+class RunnableComponent : public Component {
+public:
+
+  using id_type = EntityManager::id_type;
+
+  /**
+   * A Lua stack where the entity's script is running.
+   *
+   * NOTE: This object is called a thread, but there is no multi-threading going
+   * on.
+   *
+   * @managed_by ScriptingSystem
+   */
+  std::unique_ptr<sol::thread> runner;
+
+  /**
+   * An entry point to the script running in the runner thread.
+   *
+   * @managed_by ScriptingSystem
+   */
+  std::unique_ptr<sol::coroutine> callable;
+
+  /**
+   * Whether or not this entity represents a behavior script. A behavior script
+   * usually does not terminate on its own, and can be terminated at will by
+   * another system, usually when the automatable entity leaves the active map.
+   *
+   * @managed_by ScriptingSystem
+   */
+  bool behavior = false;
+
+  /**
+   * If this is a behavior script, this is the ID of the automatable entity that
+   * the behavior belongs to. This is required so that the ScriptingSystem can
+   * notify the automatable entity if the behavior script terminates by itself,
+   * and that it shouldn't attempt to terminate it.
+   *
+   * @managed_by ScriptingSystem
+   */
+  id_type actor;
+};
+
+#endif /* end of include guard: AUTOMATABLE_H_3D519131 */
@@ -0,0 +1,21 @@
+#ifndef SCHEDULABLE_H_1DA3FA2A
+#define SCHEDULABLE_H_1DA3FA2A
+
+#include "component.h"
+#include <tuple>
+#include <list>
+#include <functional>
+#include "entity_manager.h"
+
+class SchedulableComponent : public Component {
+public:
+
+  using id_type = EntityManager::id_type;
+
+  using Callback = std::function<void(id_type)>;
+  using Action = std::tuple<double, Callback>;
+
+  std::list<Action> actions;
+};
+
+#endif /* end of include guard: SCHEDULABLE_H_1DA3FA2A */
@@ -1,14 +0,0 @@
-#include "simple_collider.h"
-
-SimpleColliderComponent::SimpleColliderComponent(std::function<void (Game& game, Entity& collider)> callback) : callback(callback)
-{
-  
-}
-
-void SimpleColliderComponent::receive(Game& game, Entity&, const Message& msg)
-{
-  if (msg.type == Message::Type::collision)
-  {
-    callback(game, *msg.collisionEntity);
-  }
-}
@@ -1,18 +0,0 @@
-#ifndef SIMPLE_COLLIDER_H
-#define SIMPLE_COLLIDER_H
-
-#include "entity.h"
-#include <functional>
-
-class Game;
-
-class SimpleColliderComponent : public Component {
-  public:
-    SimpleColliderComponent(std::function<void (Game& game, Entity& collider)> callback);
-    void receive(Game& game, Entity& entity, const Message& msg);
-    
-  private:
-    std::function<void (Game& game, Entity& collider)> callback;
-};
-
-#endif
@@ -1,11 +0,0 @@
-#include "static_image.h"
-
-StaticImageComponent::StaticImageComponent(const char* filename) : sprite(Texture(filename))
-{
-  
-}
-
-void StaticImageComponent::render(Game&, Entity& entity, Texture& buffer)
-{
-  buffer.blit(sprite, sprite.entirety(), {(int) entity.position.first, (int) entity.position.second, entity.size.first, entity.size.second});
-}
@@ -1,18 +0,0 @@
-#ifndef STATIC_IMAGE_H
-#define STATIC_IMAGE_H
-
-#include "entity.h"
-#include "renderer.h"
-
-class Game;
-
-class StaticImageComponent : public Component {
-  public:
-    StaticImageComponent(const char* filename);
-    void render(Game& game, Entity& entity, Texture& buffer);
-    
-  private:
-    Texture sprite;
-};
-
-#endif
@@ -0,0 +1,35 @@
+#ifndef LOCATABLE_H_39E526CA
+#define LOCATABLE_H_39E526CA
+
+#include "component.h"
+#include "vector.h"
+
+class TransformableComponent : public Component {
+public:
+
+  /**
+   * The coordinates of the entity.
+   *
+   * Note that ponderable entities sometimes have special behavior related to
+   * their coordinates, specifically that ferried bodies will behave oddly if
+   * their coordinates are changed outside of the PonderingSystem. Before doing
+   * so, use PonderingSystem::unferry on the body to ensure that it is not
+   * ferried.
+   */
+  vec2d pos;
+
+  /**
+   * The size of the entity.
+   */
+  vec2i size;
+
+  /**
+   * For prototypes, the original coordinates and size of the entity.
+   *
+   * @managed_by RealizingSystem
+   */
+  vec2d origPos;
+  vec2i origSize;
+};
+
+#endif /* end of include guard: LOCATABLE_H_39E526CA */
@@ -1,100 +0,0 @@
-#include "user_movement.h"
-#include "renderer.h"
-
-void UserMovementComponent::input(Game& game, Entity& entity, int key, int action)
-{
-  if (action == GLFW_PRESS)
-  {
-    if (key == GLFW_KEY_LEFT)
-    {
-      holdingLeft = true;
-      
-      if (!frozen)
-      {
-        entity.send(game, Message::Type::walkLeft);
-      }
-    } else if (key == GLFW_KEY_RIGHT)
-    {
-      holdingRight = true;
-      
-      if (!frozen)
-      {
-        entity.send(game, Message::Type::walkRight);
-      }
-    } else if (key == GLFW_KEY_UP)
-    {
-      if (!frozen)
-      {
-        entity.send(game, Message::Type::jump);
-      }
-    } else if (key == GLFW_KEY_DOWN)
-    {
-      if (!frozen)
-      {
-        entity.send(game, Message::Type::canDrop);
-      }
-    }
-  } else if (action == GLFW_RELEASE)
-  {
-    if (key == GLFW_KEY_LEFT)
-    {
-      holdingLeft = false;
-      
-      if (!frozen)
-      {
-        if (holdingRight)
-        {
-          entity.send(game, Message::Type::walkRight);
-        } else {
-          entity.send(game, Message::Type::stopWalking);
-        }
-      }
-    } else if (key == GLFW_KEY_RIGHT)
-    {
-      holdingRight = false;
-      
-      if (!frozen)
-      {
-        if (holdingLeft)
-        {
-          entity.send(game, Message::Type::walkLeft);
-        } else {
-          entity.send(game, Message::Type::stopWalking);
-        }
-      }
-    } else if (key == GLFW_KEY_DOWN)
-    {
-      if (!frozen)
-      {
-        entity.send(game, Message::Type::cantDrop);
-      }
-    } else if (key == GLFW_KEY_UP)
-    {
-      if (!frozen)
-      {
-        entity.send(game, Message::Type::stopJump);
-      }
-    }
-  }
-}
-
-void UserMovementComponent::receive(Game& game, Entity& entity, const Message& msg)
-{
-  if (msg.type == Message::Type::die)
-  {
-    frozen = true;
-    
-    entity.send(game, Message::Type::stopWalking);
-  } else if (msg.type == Message::Type::stopDying)
-  {
-    frozen = false;
-    
-    if (holdingLeft)
-    {
-      entity.send(game, Message::Type::walkLeft);
-    } else if (holdingRight)
-    {
-      entity.send(game, Message::Type::walkRight);
-    }
-  }
-}
@@ -1,19 +0,0 @@
-#ifndef USER_MOVEMENT_H
-#define USER_MOVEMENT_H
-
-#include "entity.h"
-
-class Game;
-
-class UserMovementComponent : public Component {
-  public:
-    void input(Game& game, Entity& entity, int key, int action);
-    void receive(Game&, Entity&, const Message& msg);
-      
-  private:
-    bool holdingLeft = false;
-    bool holdingRight = false;
-    bool frozen = false;
-};
-
-#endif
@@ -7,8 +7,21 @@ const int GAME_WIDTH = 320;
 const int GAME_HEIGHT = 200;
 const int MAP_WIDTH = GAME_WIDTH/TILE_WIDTH;
 const int MAP_HEIGHT = GAME_HEIGHT/TILE_HEIGHT - 1;
+const int WALL_GAP = 5;
+const int TILESET_COLS = 8;
+const int FONT_COLS = 16;
 
 const int FRAMES_PER_SECOND = 60;
 const double SECONDS_PER_FRAME = 1.0 / FRAMES_PER_SECOND;
 
+#define CALC_VELOCITY(h, l) (-2 * (h) / (l))
+#define CALC_GRAVITY(h, l) (2 * ((h) / (l)) / (l))
+
+const double NORMAL_GRAVITY = CALC_GRAVITY(TILE_HEIGHT*3.5, 0.233);
+const double JUMP_GRAVITY = CALC_GRAVITY(TILE_HEIGHT*4.5, 0.3);
+const double JUMP_VELOCITY = CALC_VELOCITY(TILE_HEIGHT*4.5, 0.3);
+
+const double WALK_SPEED = 90;
+const double TERMINAL_VELOCITY = 240;
+
 #endif
@@ -0,0 +1,11 @@
+#ifndef DIRECTION_H_9C49EAFD
+#define DIRECTION_H_9C49EAFD
+
+enum class Direction {
+  left,
+  right,
+  up,
+  down
+};
+
+#endif /* end of include guard: DIRECTION_H_9C49EAFD */
@@ -1,46 +0,0 @@
-#include "entity.h"
-
-void Entity::addComponent(std::shared_ptr<Component> c)
-{
-  components.push_back(c);
-}
-
-void Entity::send(Game& game, const Message& msg)
-{
-  for (auto component : components)
-  {
-    component->receive(game, *this, msg);
-  }
-}
-
-void Entity::tick(Game& game, double dt)
-{
-  for (auto component : components)
-  {
-    component->tick(game, *this, dt);
-  }
-}
-
-void Entity::input(Game& game, int key, int action)
-{
-  for (auto component : components)
-  {
-    component->input(game, *this, key, action);
-  }
-}
-
-void Entity::render(Game& game, Texture& buffer)
-{
-  for (auto component : components)
-  {
-    component->render(game, *this, buffer);
-  }
-}
-
-void Entity::detectCollision(Game& game, Entity& collider, std::pair<double, double> old_position)
-{
-  for (auto component : components)
-  {
-    component->detectCollision(game, *this, collider, old_position);
-  }
-}
@@ -1,64 +0,0 @@
-#ifndef ENTITY_H
-#define ENTITY_H
-
-#include <list>
-#include "renderer.h"
-
-class Game;
-class Map;
-class Entity;
-class Component;
-
-class Message {
-  public:
-    enum class Type {
-      walkLeft,
-      walkRight,
-      stopWalking,
-      setHorizontalVelocity,
-      setVerticalVelocity,
-      collision,
-      jump,
-      stopJump,
-      drop,
-      canDrop,
-      cantDrop,
-      die,
-      stopDying,
-      hitTheGround
-    };
-    
-    Message(Type type) : type(type) {}
-    
-    Type type;
-    Entity* collisionEntity;
-    int dropAxis;
-    double velocity;
-};
-
-class Entity {
-  public:
-    void addComponent(std::shared_ptr<Component> c);
-    void send(Game& game, const Message& msg);
-    void tick(Game& game, double dt);
-    void input(Game& game, int key, int action);
-    void render(Game& game, Texture& buffer);
-    void detectCollision(Game& game, Entity& collider, std::pair<double, double> old_position);
-    
-    std::pair<double, double> position;
-    std::pair<int, int> size;
-    
-  private:
-    std::list<std::shared_ptr<Component>> components;
-};
-
-class Component {
-  public:
-    virtual void receive(Game&, Entity&, const Message&) {}
-    virtual void render(Game&, Entity&, Texture&) {}
-    virtual void tick(Game&, Entity&, double) {}
-    virtual void input(Game&, Entity&, int, int) {}
-    virtual void detectCollision(Game&, Entity&, Entity&, std::pair<double, double>) {}
-};
-
-#endif
@@ -0,0 +1,39 @@
+#ifndef ENTITY_MANAGER_CPP_42D78C22
+#define ENTITY_MANAGER_CPP_42D78C22
+
+#include "entity_manager.h"
+
+template <>
+std::set<EntityManager::id_type> EntityManager::getEntitiesWithComponents<>(
+  std::set<std::type_index>& componentTypes) const
+{
+  if (cachedComponents.count(componentTypes) == 1)
+  {
+    return cachedComponents[componentTypes];
+  }
+
+  std::set<id_type>& cache = cachedComponents[componentTypes];
+  for (id_type entity = 0; entity < entities.size(); entity++)
+  {
+    const EntityData& data = entities[entity];
+    bool cacheEntity = true;
+
+    for (auto& componentType : componentTypes)
+    {
+      if (data.components.count(componentType) == 0)
+      {
+        cacheEntity = false;
+        break;
+      }
+    }
+
+    if (cacheEntity)
+    {
+      cache.insert(entity);
+    }
+  }
+
+  return cache;
+}
+
+#endif /* end of include guard: ENTITY_MANAGER_CPP_42D78C22 */
@@ -0,0 +1,230 @@
+#ifndef ENTITY_MANAGER_H_C5832F11
+#define ENTITY_MANAGER_H_C5832F11
+
+#include <map>
+#include <vector>
+#include <typeindex>
+#include <set>
+#include <stdexcept>
+#include "component.h"
+#include "util.h"
+
+class EntityManager {
+private:
+
+  struct EntityData {
+    std::map<std::type_index, std::unique_ptr<Component>> components;
+  };
+
+  using database_type = std::vector<EntityData>;
+
+public:
+
+  using id_type = database_type::size_type;
+
+private:
+
+  database_type entities;
+  std::vector<bool> slotAvailable;
+  std::set<id_type> allEntities;
+
+  mutable std::map<std::set<std::type_index>, std::set<id_type>>
+    cachedComponents;
+
+  id_type nextEntityID = 0;
+
+  template <class T, class... R>
+  std::set<id_type> getEntitiesWithComponentsHelper(
+    std::set<std::type_index>& componentTypes) const
+  {
+    componentTypes.insert(typeid(T));
+
+    return getEntitiesWithComponents<R...>(componentTypes);
+  }
+
+  template <class... R>
+  std::set<id_type> getEntitiesWithComponents(
+    std::set<std::type_index>& componentTypes) const
+  {
+    return getEntitiesWithComponentsHelper<R...>(componentTypes);
+  }
+
+public:
+
+  EntityManager() = default;
+
+  EntityManager(const EntityManager& copy) = delete;
+
+  id_type emplaceEntity()
+  {
+    if (nextEntityID >= entities.size())
+    {
+      // If the database is saturated, add a new element for the new entity.
+      entities.emplace_back();
+      slotAvailable.push_back(false);
+      allEntities.insert(nextEntityID);
+
+      return nextEntityID++;
+    } else {
+      // If there is an available slot in the database, use it.
+      id_type id = nextEntityID++;
+      slotAvailable[id] = false;
+      allEntities.insert(id);
+
+      // Fast forward the next available slot pointer to an available slot.
+      while ((nextEntityID < entities.size()) && !slotAvailable[nextEntityID])
+      {
+        nextEntityID++;
+      }
+
+      return id;
+    }
+  }
+
+  void deleteEntity(id_type entity)
+  {
+    if ((entity >= entities.size()) || slotAvailable[entity])
+    {
+      throw std::invalid_argument("Cannot delete non-existent entity");
+    }
+
+    // Uncache components
+    for (auto& cache : cachedComponents)
+    {
+      cache.second.erase(entity);
+    }
+
+    allEntities.erase(entity);
+
+    // Destroy the data
+    entities[entity].components.clear();
+
+    // Mark the slot as available
+    slotAvailable[entity] = true;
+
+    if (entity < nextEntityID)
+    {
+      nextEntityID = entity;
+    }
+  }
+
+  template <class T, class... Args>
+  T& emplaceComponent(id_type entity, Args&&... args)
+  {
+    if ((entity >= entities.size()) || slotAvailable[entity])
+    {
+      throw std::invalid_argument("Cannot get non-existent entity");
+    }
+
+    EntityData& data = entities[entity];
+    std::type_index componentType = typeid(T);
+
+    if (data.components.count(componentType))
+    {
+      throw std::invalid_argument("Cannot emplace already-existent component");
+    }
+
+    // Initialize the component
+    std::unique_ptr<T> ptr(new T(std::forward<Args>(args)...));
+    T& component = *ptr;
+    data.components[componentType] = std::move(ptr);
+
+    // Invalidate related caches
+    erase_if(
+      cachedComponents,
+      [&componentType] (
+        std::pair<const std::set<std::type_index>, std::set<id_type>>& cache) {
+          return cache.first.count(componentType) == 1;
+        });
+
+    return component;
+  }
+
+  template <class T>
+  void removeComponent(id_type entity)
+  {
+    if ((entity >= entities.size()) || slotAvailable[entity])
+    {
+      throw std::invalid_argument("Cannot get non-existent entity");
+    }
+
+    EntityData& data = entities[entity];
+    std::type_index componentType = typeid(T);
+
+    if (!data.components.count(componentType))
+    {
+      throw std::invalid_argument("Cannot delete non-existent component");
+    }
+
+    // Destroy the component
+    data.components.erase(componentType);
+
+    // Uncache the component
+    for (auto& cache : cachedComponents)
+    {
+      if (cache.first.count(componentType) == 1)
+      {
+        cache.second.erase(entity);
+      }
+    }
+  }
+
+  template <class T>
+  const T& getComponent(id_type entity) const
+  {
+    if ((entity >= entities.size()) || slotAvailable[entity])
+    {
+      throw std::invalid_argument("Cannot get non-existent entity");
+    }
+
+    const EntityData& data = entities[entity];
+    std::type_index componentType = typeid(T);
+
+    if (!data.components.count(componentType))
+    {
+      throw std::invalid_argument("Cannot get non-existent component");
+    }
+
+    return *dynamic_cast<const T*>(data.components.at(componentType).get());
+  }
+
+  template <class T>
+  T& getComponent(id_type entity)
+  {
+    return const_cast<T&>(
+      static_cast<const EntityManager&>(*this).getComponent<T>(entity));
+  }
+
+  template <class T>
+  bool hasComponent(id_type entity) const
+  {
+    if ((entity >= entities.size()) || slotAvailable[entity])
+    {
+      throw std::invalid_argument("Cannot get non-existent entity");
+    }
+
+    const EntityData& data = entities[entity];
+    std::type_index componentType = typeid(T);
+
+    return data.components.count(componentType);
+  }
+
+  template <class... R>
+  std::set<id_type> getEntitiesWithComponents() const
+  {
+    std::set<std::type_index> componentTypes;
+
+    return getEntitiesWithComponentsHelper<R...>(componentTypes);
+  }
+
+  const std::set<id_type>& getEntities() const
+  {
+    return allEntities;
+  }
+};
+
+template <>
+std::set<EntityManager::id_type> EntityManager::getEntitiesWithComponents<>(
+  std::set<std::type_index>& componentTypes) const;
+
+#endif /* end of include guard: ENTITY_MANAGER_H_C5832F11 */
@@ -1,182 +0,0 @@
-#include "entityfactory.h"
-#include <libxml/parser.h>
-#include "muxer.h"
-#include <cstdio>
-#include <map>
-#include <list>
-#include "components/static_image.h"
-#include "components/simple_collider.h"
-#include "components/physics_body.h"
-#include "components/ai.h"
-#include "game.h"
-
-void parseEntityAIData(AI& ai, xmlNodePtr node, const std::map<std::string, int>& items)
-{
-  xmlChar* key;
-  
-  for (xmlNodePtr aiNode = node->xmlChildrenNode; aiNode != NULL; aiNode = aiNode->next)
-  {
-    if (!xmlStrcmp(aiNode->name, (xmlChar*) "move"))
-    {
-      MoveAIAction::Direction dir;
-      int len;
-      int speed;
-      
-      key = xmlGetProp(aiNode, (xmlChar*) "direction");
-      if (key == 0) exit(2);
-      if (!xmlStrcmp(key, (xmlChar*) "left"))
-      {
-        dir = MoveAIAction::Direction::Left;
-      } else if (!xmlStrcmp(key, (xmlChar*) "right"))
-      {
-        dir = MoveAIAction::Direction::Right;
-      } else if (!xmlStrcmp(key, (xmlChar*) "up"))
-      {
-        dir = MoveAIAction::Direction::Up;
-      } else if (!xmlStrcmp(key, (xmlChar*) "down"))
-      {
-        dir = MoveAIAction::Direction::Down;
-      } else {
-        exit(2);
-      }
-      xmlFree(key);
-      
-      key = xmlGetProp(aiNode, (xmlChar*) "length");
-      if (key != 0)
-      {
-        len = atoi((char*) key);
-      } else {
-        key = xmlGetProp(aiNode, (xmlChar*) "length-var");
-        if (key == 0) exit(2);
-        std::string varName = (char*) key;
-        len = items.at(varName);
-      }
-      xmlFree(key);
-      
-      key = xmlGetProp(aiNode, (xmlChar*) "speed");
-      if (key != 0)
-      {
-        speed = atoi((char*) key);
-      } else {
-        key = xmlGetProp(aiNode, (xmlChar*) "speed-var");
-        if (key == 0) exit(2);
-        std::string varName = (char*) key;
-        speed = items.at(varName);
-      }
-      xmlFree(key);
-      
-      ai.addAction(std::make_shared<MoveAIAction>(dir, len, speed));
-    } else if (!xmlStrcmp(aiNode->name, (xmlChar*) "switch"))
-    {
-      key = xmlGetProp(aiNode, (xmlChar*) "item");
-      if (key == 0) exit(2);
-      std::string switchItem = (char*) key;
-      xmlFree(key);
-      
-      for (xmlNodePtr switchNode = aiNode->xmlChildrenNode; switchNode != NULL; switchNode = switchNode->next)
-      {
-        if (!xmlStrcmp(switchNode->name, (xmlChar*) "case"))
-        {
-          key = xmlGetProp(switchNode, (xmlChar*) "value");
-          if (key == 0) exit(2);
-          int caseValue = atoi((char*) key);
-          xmlFree(key);
-          
-          if (items.at(switchItem) == caseValue)
-          {
-            parseEntityAIData(ai, switchNode, items);
-          }
-        }
-      }
-    }
-  }
-}
-
-std::shared_ptr<Entity> EntityFactory::createNamedEntity(const std::string name, const std::map<std::string, int>& items)
-{
-  xmlDocPtr doc = xmlParseFile("res/entities.xml");
-  if (doc == nullptr)
-  {
-    fprintf(stderr, "Error reading entities\n");
-    exit(-1);
-  }
-
-  xmlNodePtr top = xmlDocGetRootElement(doc);
-  if (top == nullptr)
-  {
-    fprintf(stderr, "Empty entities file\n");
-    exit(-1);
-  }
-
-  if (xmlStrcmp(top->name, (const xmlChar*) "entities"))
-  {
-    fprintf(stderr, "Invalid entities definition\n");
-    exit(-1);
-  }
-  
-  auto entity = std::make_shared<Entity>();
-
-  xmlChar* key;
-  for (xmlNodePtr node = top->xmlChildrenNode; node != NULL; node = node->next)
-  {
-    if (!xmlStrcmp(node->name, (xmlChar*) "entity"))
-    {
-      key = xmlGetProp(node, (xmlChar*) "id");
-      if (key == 0) exit(-1);
-      std::string entityID = (char*) key;
-      xmlFree(key);
-      
-      if (entityID == name)
-      {
-        key = xmlGetProp(node, (xmlChar*) "sprite");
-        if (key == 0) exit(-1);
-        auto spriteComponent = std::make_shared<StaticImageComponent>((char*) key);
-        entity->addComponent(spriteComponent);
-        xmlFree(key);
-        
-        auto physicsComponent = std::make_shared<PhysicsBodyComponent>();
-        entity->addComponent(physicsComponent);
-      
-        key = xmlGetProp(node, (xmlChar*) "width");
-        if (key == 0) exit(-1);
-        entity->size.first = atoi((char*) key);
-        xmlFree(key);
-      
-        key = xmlGetProp(node, (xmlChar*) "height");
-        if (key == 0) exit(-1);
-        entity->size.second = atoi((char*) key);
-        xmlFree(key);
-        
-        bool addAI = false;
-        auto aiComponent = std::make_shared<AIComponent>();
-        
-        for (xmlNodePtr entityNode = node->xmlChildrenNode; entityNode != NULL; entityNode = entityNode->next)
-        {
-          if (!xmlStrcmp(entityNode->name, (xmlChar*) "ai"))
-          {
-            addAI = true;
-            
-            xmlChar* chanceKey = xmlGetProp(entityNode, (xmlChar*) "chance");
-            if (chanceKey == 0) exit(2);
-            int chance = atoi((char*) chanceKey);
-            xmlFree(chanceKey);
-            
-            AI& ai = aiComponent->emplaceAI(chance);
-            parseEntityAIData(ai, entityNode, items);
-          }
-        }
-        
-        if (addAI)
-        {
-          entity->addComponent(aiComponent);
-        }
-        
-        break;
-      }
-    }
-  }
-
-  xmlFreeDoc(doc);
-  
-  return entity;
-}
@@ -1,15 +0,0 @@
-#ifndef ENTITYFACTORY_H
-#define ENTITYFACTORY_H
-
-#include <string>
-#include <map>
-
-class Entity;
-class Map;
-
-class EntityFactory {
-  public:
-    static std::shared_ptr<Entity> createNamedEntity(const std::string name, const std::map<std::string, int>& items);
-};
-
-#endif
@@ -1,178 +1,78 @@
 #include "game.h"
-#include <cstdlib>
-#include "renderer.h"
-#include "muxer.h"
-#include "map.h"
-#include "components/user_movement.h"
-#include "components/player_physics.h"
-#include "components/player_sprite.h"
-#include "components/map_render.h"
-#include "components/map_collision.h"
+#include "systems/controlling.h"
+#include "systems/pondering.h"
+#include "systems/animating.h"
+#include "systems/mapping.h"
+#include "systems/orienting.h"
+#include "systems/playing.h"
+#include "systems/scheduling.h"
+#include "systems/realizing.h"
+#include "systems/scripting.h"
 #include "consts.h"
 
-Game::Game(const char* mapfile) : world(mapfile)
-{ 
-  // Set up entities
-  player = std::make_shared<Entity>();
-  player->position = world.getStartingPosition();
-  player->size = std::make_pair(10.0,12.0);
-  
-  auto player_input = std::make_shared<UserMovementComponent>();
-  player->addComponent(player_input);
-  
-  auto player_physics = std::make_shared<PlayerPhysicsComponent>();
-  player->addComponent(player_physics);
-  
-  auto player_anim = std::make_shared<PlayerSpriteComponent>();
-  player->addComponent(player_anim);
-  
-  const Map& startingMap = world.getStartingMap();
-  save = {&startingMap, player->position};
-  
-  loadMap(startingMap, player->position);
-}
-
 void key_callback(GLFWwindow* window, int key, int, int action, int)
 {
-  Game* game = (Game*) glfwGetWindowUserPointer(window);
-  
-  if ((key == GLFW_KEY_ESCAPE) && (action == GLFW_PRESS))
-  {
-    game->shouldQuit = true;
-  }
-  
-  for (auto entity : game->entities)
+  Game& game = *static_cast<Game*>(glfwGetWindowUserPointer(window));
+
+  if ((action == GLFW_PRESS) && (key == GLFW_KEY_ESCAPE))
   {
-    entity->input(*game, key, action);
+    game.shouldQuit_ = true;
+
+    return;
   }
+
+  game.systemManager_.input(key, action);
 }
 
-void Game::execute(GLFWwindow* window)
+Game::Game(std::mt19937& rng) : rng_(rng)
 {
+  systemManager_.emplaceSystem<PlayingSystem>(*this);
+  systemManager_.emplaceSystem<SchedulingSystem>(*this);
+  systemManager_.emplaceSystem<ControllingSystem>(*this);
+  systemManager_.emplaceSystem<ScriptingSystem>(*this);
+  systemManager_.emplaceSystem<OrientingSystem>(*this);
+  systemManager_.emplaceSystem<PonderingSystem>(*this);
+  systemManager_.emplaceSystem<MappingSystem>(*this);
+  systemManager_.emplaceSystem<AnimatingSystem>(*this);
+
+  systemManager_.emplaceSystem<RealizingSystem>(*this,
+    "res/maps.xml",
+    "res/entities.xml");
+
+  systemManager_.getSystem<PlayingSystem>().initPlayer();
+
   glfwSwapInterval(1);
-  glfwSetWindowUserPointer(window, this);
-  glfwSetKeyCallback(window, key_callback);
-  
-  Texture buffer(GAME_WIDTH, GAME_HEIGHT);
+  glfwSetWindowUserPointer(renderer_.getWindow().getHandle(), this);
+  glfwSetKeyCallback(renderer_.getWindow().getHandle(), key_callback);
+}
 
+void Game::execute()
+{
   double lastTime = glfwGetTime();
   const double dt = 0.01;
   double accumulator = 0.0;
-  
-  while (!(shouldQuit || glfwWindowShouldClose(window)))
+  Texture texture(GAME_WIDTH, GAME_HEIGHT);
+
+  while (!(shouldQuit_ ||
+    glfwWindowShouldClose(renderer_.getWindow().getHandle())))
   {
     double currentTime = glfwGetTime();
     double frameTime = currentTime - lastTime;
     lastTime = currentTime;
-    
-    // Should we load a new world?
-    if (newWorld)
-    {
-      newWorld = false;
-      entities.clear();
-      entities = std::move(nextEntities);
-      
-      player->position = nextPosition;
-    }
-    
-    // Handle input
+
     glfwPollEvents();
-    
-    // Tick!
+
     accumulator += frameTime;
     while (accumulator >= dt)
     {
-      for (auto entity : entities)
-      {
-        entity->tick(*this, dt);
-      }
-      
+      systemManager_.tick(dt);
+
       accumulator -= dt;
     }
-    
-    // Do any scheduled tasks
-    for (auto& task : scheduled)
-    {
-      task.first -= frameTime;
-      
-      if (task.first <= 0)
-      {
-        task.second();
-      }
-    }
-    
-    scheduled.remove_if([] (std::pair<double, std::function<void ()>> value) { return value.first <= 0; });
-  
-    // Do rendering
-    buffer.fill(buffer.entirety(), 0, 0, 0);
-    for (auto entity : entities)
-    {
-      entity->render(*this, buffer);
-    }
 
-    buffer.renderScreen();
+    // Render
+    renderer_.fill(texture, texture.entirety(), 0, 0, 0);
+    systemManager_.render(texture);
+    renderer_.renderScreen(texture);
   }
 }
-
-void Game::loadMap(const Map& map, std::pair<double, double> position)
-{
-  auto mapEn = std::make_shared<Entity>();
-  
-  auto map_render = std::make_shared<MapRenderComponent>(map);
-  mapEn->addComponent(map_render);
-  
-  auto map_collision = std::make_shared<MapCollisionComponent>(map);
-  mapEn->addComponent(map_collision);
-  
-  // Map in the back, player on top, rest of entities in between
-  nextEntities.clear();
-  nextEntities.push_back(mapEn);
-  map.createEntities(nextEntities);
-  nextEntities.push_back(player);
-  
-  newWorld = true;
-  
-  currentMap = &map;
-  nextPosition = position;
-}
-
-void Game::detectCollision(Entity& collider, std::pair<double, double> old_position)
-{
-  for (auto entity : entities)
-  {
-    entity->detectCollision(*this, collider, old_position);
-  }
-}
-
-void Game::saveGame()
-{
-  save = {currentMap, player->position};
-}
-
-void Game::schedule(double time, std::function<void ()> callback)
-{
-  scheduled.emplace_front(time, std::move(callback));
-}
-
-void Game::playerDie()
-{
-  player->send(*this, Message::Type::die);
-  
-  playSound("res/Hit_Hurt5.wav", 0.25);
-  
-  schedule(0.75, [&] () {
-    if (*currentMap != *save.map)
-    {
-      loadMap(*save.map, save.position);
-    } else {
-      player->position = save.position;
-    }
-    
-    player->send(*this, Message::Type::stopDying);
-  });
-}
-
-const World& Game::getWorld() const
-{
-  return world;
-}
@@ -1,45 +1,52 @@
-#ifndef GAME_H
-#define GAME_H
-
-#include <memory>
-#include <functional>
-#include <list>
-#include <map>
-#include "map.h"
-#include "world.h"
-
-class Entity;
-struct GLFWwindow;
-
-struct Savefile {
-  const Map* map;
-  std::pair<double, double> position;
-};
+#ifndef GAME_H_1014DDC9
+#define GAME_H_1014DDC9
+
+#include <random>
+#include "entity_manager.h"
+#include "system_manager.h"
+#include "renderer/renderer.h"
 
 class Game {
-  public:
-    Game(const char* maps);
-    void execute(GLFWwindow* window);
-    void loadMap(const Map& map, std::pair<double, double> position);
-    void detectCollision(Entity& collider, std::pair<double, double> old_position);
-    void saveGame();
-    void schedule(double time, std::function<void ()> callback);
-    void playerDie();
-    const World& getWorld() const;
-    
-  private:
-    friend void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods);
-
-    std::list<std::shared_ptr<Entity>> entities;
-    std::list<std::shared_ptr<Entity>> nextEntities;
-    std::pair<double, double> nextPosition;
-    bool newWorld;
-    std::shared_ptr<Entity> player;
-    const Map* currentMap;
-    Savefile save;
-    std::list<std::pair<double, std::function<void ()>>> scheduled;
-    bool shouldQuit = false;
-    World world;
+public:
+
+  Game(std::mt19937& rng);
+
+  void execute();
+
+  inline std::mt19937& getRng()
+  {
+    return rng_;
+  }
+
+  inline Renderer& getRenderer()
+  {
+    return renderer_;
+  }
+
+  inline EntityManager& getEntityManager()
+  {
+    return entityManager_;
+  }
+
+  inline SystemManager& getSystemManager()
+  {
+    return systemManager_;
+  }
+
+  friend void key_callback(
+    GLFWwindow* window,
+    int key,
+    int scancode,
+    int action,
+    int mods);
+
+private:
+
+  std::mt19937 rng_;
+  Renderer renderer_;
+  SystemManager systemManager_;
+  EntityManager entityManager_;
+  bool shouldQuit_ = false;
 };
 
-#endif
+#endif /* end of include guard: GAME_H_1014DDC9 */
@@ -1,25 +1,18 @@
-#include <ctime>
-#include <list>
-#include "renderer.h"
-#include <cstdlib>
-#include "game.h"
+#include <random>
 #include "muxer.h"
+#include "game.h"
 
 int main()
 {
-  srand(time(NULL));
-  
-  GLFWwindow* window = initRenderer();
+  std::random_device randomDevice;
+  std::mt19937 rng(randomDevice());
+
   initMuxer();
-  
-  // Put this in a block so game goes out of scope before we destroy the renderer
-  {
-    Game game {"res/maps.xml"};
-    game.execute(window);
-  }
-  
+
+  Game game(rng);
+  game.execute();
+
   destroyMuxer();
-  destroyRenderer();
-  
+
   return 0;
 }
@@ -1,151 +0,0 @@
-#include "map.h"
-#include <cstdlib>
-#include <cstring>
-#include <map>
-#include "entityfactory.h"
-#include "entity.h"
-#include "game.h"
-#include "consts.h"
-
-Map::Map(int id)
-{
-  this->id = id;
-  mapdata = (int*) calloc(1, sizeof(int));
-}
-
-Map::Map(const Map& map)
-{
-  mapdata = (int*) malloc(MAP_WIDTH*MAP_HEIGHT*sizeof(int));
-  memcpy(mapdata, map.mapdata, MAP_WIDTH*MAP_HEIGHT*sizeof(int));
-  
-  id = map.id;
-  title = map.title;
-  adjacents = map.adjacents;
-  entities = map.entities;
-}
-
-Map::Map(Map&& map) : Map()
-{
-  swap(*this, map);
-}
-
-Map::~Map()
-{
-  free(mapdata);
-}
-
-Map& Map::operator= (Map map)
-{
-  swap(*this, map);
-  
-  return *this;
-}
-
-void swap(Map& first, Map& second)
-{
-  std::swap(first.mapdata, second.mapdata);
-  std::swap(first.title, second.title);
-  std::swap(first.adjacents, second.adjacents);
-  std::swap(first.id, second.id);
-  std::swap(first.entities, second.entities);
-}
-
-int Map::getID() const
-{
-  return id;
-}
-
-const int* Map::getMapdata() const
-{
-  return mapdata;
-}
-
-std::string Map::getTitle() const
-{
-  return title;
-}
-
-void Map::createEntities(std::list<std::shared_ptr<Entity>>& entities) const
-{
-  for (auto data : this->entities)
-  {
-    auto entity = EntityFactory::createNamedEntity(data.name, data.items);
-    entity->position = data.position;
-    
-    entities.push_back(entity);
-  }
-}
-
-bool Map::operator==(const Map& other) const
-{
-  return id == other.id;
-}
-
-bool Map::operator!=(const Map& other) const
-{
-  return id != other.id;
-}
-
-Map::MoveType Map::moveTypeForShort(std::string str)
-{
-  if (str == "wrap") return MoveType::Wrap;
-  if (str == "warp") return MoveType::Warp;
-  if (str == "reverseWarp") return MoveType::ReverseWarp;
-  
-  return MoveType::Wall;
-}
-
-Map::MoveDir Map::moveDirForShort(std::string str)
-{
-  if (str == "right") return MoveDir::Right;
-  if (str == "up") return MoveDir::Up;
-  if (str == "down") return MoveDir::Down;
-  
-  return MoveDir::Left;
-}
-
-static const Map::Adjacent defaultAdjacent {};
-const Map::Adjacent& Map::getAdjacent(MoveDir dir) const
-{
-  if (adjacents.count(dir) > 0)
-  {
-    return adjacents.at(dir);
-  } else {
-    return defaultAdjacent;
-  }
-}
-
-bool Map::moveTypeTakesMap(MoveType type)
-{
-  switch (type)
-  {
-    case MoveType::Wall: return false;
-    case MoveType::Wrap: return false;
-    case MoveType::Warp: return true;
-    case MoveType::ReverseWarp: return true;
-  }
-}
-
-void Map::setMapdata(int* mapdata)
-{
-  free(this->mapdata);
-  this->mapdata = mapdata;
-}
-
-void Map::setTitle(std::string title)
-{
-  this->title = title;
-}
-
-void Map::setAdjacent(MoveDir dir, MoveType type, int map)
-{
-  Adjacent& cur = adjacents[dir];
-  cur.type = type;
-  if (map != -1) cur.map = map;
-}
-
-void Map::addEntity(EntityData& data)
-{
-  entities.push_back(data);
-}
-
@@ -1,70 +0,0 @@
-#ifndef MAP_H
-#define MAP_H
-
-#include <string>
-#include <list>
-#include <map>
-
-class Entity;
-
-class Map {
-  public:
-    Map(int id);
-    Map() : Map(-1) {}
-    Map(const Map& map);
-    Map(Map&& map);
-    ~Map();
-    Map& operator= (Map other);
-    friend void swap(Map& first, Map& second);
-    
-    enum class MoveType {
-      Wall,
-      Wrap,
-      Warp,
-      ReverseWarp
-    };
-    
-    enum class MoveDir {
-      Left,
-      Right,
-      Up,
-      Down
-    };
-    
-    struct EntityData {
-      std::string name;
-      std::pair<int, int> position;
-      std::map<std::string, int> items;
-    };
-    
-    struct Adjacent {
-      MoveType type = MoveType::Wall;
-      int map = -1;
-    };
-    
-    static MoveType moveTypeForShort(std::string str);
-    static MoveDir moveDirForShort(std::string str);
-    static bool moveTypeTakesMap(MoveType type);
-    
-    int getID() const;
-    const int* getMapdata() const;
-    std::string getTitle() const;
-    const Adjacent& getAdjacent(MoveDir dir) const;
-    
-    void createEntities(std::list<std::shared_ptr<Entity>>& entities) const;
-    bool operator==(const Map& other) const;
-    bool operator!=(const Map& other) const;
-    
-    void setMapdata(int* mapdata);
-    void setTitle(std::string title);
-    void setAdjacent(MoveDir dir, MoveType type, int map);
-    void addEntity(EntityData& data);
-  private:
-    int* mapdata;
-    std::string title;
-    int id;
-    std::list<EntityData> entities;
-    std::map<MoveDir, Adjacent> adjacents;
-};
-
-#endif
@@ -4,6 +4,9 @@
 #include <portaudio.h>
 #include <list>
 #include <cmath>
+#include <vector>
+#include <stdexcept>
+#include <sstream>
 
 #define SAMPLE_RATE (44100)
 #define DELAY_IN_SECS (0.075)
@@ -17,11 +20,14 @@ const int delaySize = SAMPLE_RATE * DELAY_IN_SECS;
 class Sound {
   public:
     Sound(const char* filename, float vol);
-    ~Sound();
-    
-    float* ptr;
+
+    inline bool isDone() const
+    {
+      return pos >= data.size();
+    }
+
+    std::vector<float> data;
     unsigned long pos;
-    unsigned long len;
     float vol;
 };
 
@@ -45,29 +51,29 @@ int paMuxerCallback(const void*, void* outputBuffer, unsigned long framesPerBuff
 {
   Muxer* muxer = (Muxer*) userData;
   float* out = (float*) outputBuffer;
-  
+
   for (unsigned long i = 0; i<framesPerBuffer; i++)
   {
     float in = 0.0;
-    
+
     for (auto& sound : muxer->playing)
     {
-      if (sound.pos < sound.len)
+      if (sound.pos < sound.data.size())
       {
-        in += sound.ptr[sound.pos++] * sound.vol;
+        in += sound.data[sound.pos++] * sound.vol;
       }
     }
-    
+
     if (in >  1) in = 1;
     if (in < -1) in = -1;
-    
+
     float sample = muxer->delay[muxer->delayPos] * GAIN;
     muxer->delay[muxer->delayPos] = in + (muxer->delay[muxer->delayPos] * FEEDBACK);
     muxer->delayPos++;
     if (muxer->delayPos > delaySize) muxer->delayPos = 0;
     *out++ = (in * DRY) + (sample * WET);
   }
-  
+
   return 0;
 }
 
@@ -76,11 +82,11 @@ static Muxer* muxer;
 void initMuxer()
 {
   muxer = new Muxer();
-  
+
   dealWithPaError(Pa_Initialize());
   dealWithPaError(Pa_OpenDefaultStream(&muxer->stream, 0, 1, paFloat32, SAMPLE_RATE, paFramesPerBufferUnspecified, paMuxerCallback, muxer));
   dealWithPaError(Pa_StartStream(muxer->stream));
-  
+
   muxer->delay = (float*) calloc(delaySize, sizeof(float));
 }
 
@@ -89,7 +95,7 @@ void destroyMuxer()
   dealWithPaError(Pa_AbortStream(muxer->stream));
   dealWithPaError(Pa_CloseStream(muxer->stream));
   dealWithPaError(Pa_Terminate());
-  
+
   free(muxer->delay);
   delete muxer;
   muxer = 0;
@@ -98,8 +104,8 @@ void destroyMuxer()
 void playSound(const char* filename, float vol)
 {
   // First, clear out any sounds that have finished playing
-  muxer->playing.remove_if([] (Sound& value) { return value.pos >= value.len; });
-  
+  muxer->playing.remove_if([] (Sound& value) { return value.isDone(); });
+
   // Then, add the new sound
   muxer->playing.emplace_back(filename, vol);
 }
@@ -110,21 +116,18 @@ Sound::Sound(const char* filename, float vol)
   SNDFILE* file = sf_open(filename, SFM_READ, &info);
   if (file == nullptr)
   {
-    printf("LibSndFile error: %s\n", sf_strerror(file));
-    exit(-1);
+    std::ostringstream errmsg;
+    errmsg << "LibSndFile error: ";
+    errmsg << sf_strerror(file);
+
+    throw std::logic_error(errmsg.str());
   }
-  
-  ptr = (float*) malloc(info.frames * info.channels * sizeof(float));
-  len = info.frames * info.channels;
+
+  data.resize(info.frames * info.channels);
   pos = 0;
   this->vol = vol;
-  
-  sf_readf_float(file, ptr, info.frames);
-  
-  sf_close(file);
-}
 
-Sound::~Sound()
-{
-  free(ptr);
+  sf_readf_float(file, data.data(), info.frames);
+
+  sf_close(file);
 }
@@ -1,861 +0,0 @@
-#include "renderer.h"
-#include <string>
-#include <fstream>
-#include <vector>
-#include <cstdio>
-#include <cstring>
-#include <cstdlib>
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include "consts.h"
-
-// include stb_image
-#define STB_IMAGE_IMPLEMENTATION
-#define STBI_ONLY_PNG
-#define STBI_ONLY_BMP
-#include "stb_image.h"
-
-static bool rendererInitialized = false;
-
-static GLFWwindow* window;
-
-static GLuint generic_framebuffer; // The framebuffer
-static GLuint bloom_framebuffer;
-static GLuint bloom_depthbuffer;
-static int buffer_width = 1024;
-static int buffer_height = 768;
-
-static GLuint ntscShader; // The NTSC shader
-static GLuint finalShader; // The passthrough shader
-static GLuint blitShader; // The blitting shader
-static GLuint fillShader; // The fill shader
-static GLuint bloom1Shader;
-static GLuint bloom2Shader;
-
-// The buffers for the NTSC rendering process
-static GLuint renderedTex1;
-static GLuint renderedTex2;
-static GLuint renderedTexBufs[2];
-static int curBuf;
-static GLuint artifactsTex;
-static GLuint scanlinesTex;
-static GLuint preBloomTex;
-static GLuint bloomPassTex1;
-static GLuint bloomPassTex2;
-
-// The VAO
-static GLuint VertexArrayID;
-
-// A plane that fills the renderbuffer
-static GLuint quad_vertexbuffer;
-
-// Buffers for the mesh
-static GLuint mesh_vertexbuffer;
-static GLuint mesh_uvbuffer;
-static GLuint mesh_normalbuffer;
-static int mesh_numvertices;
-
-GLuint LoadShaders(const char* vertex_file_path, const char* fragment_file_path)
-{ 
-    // Create the shaders
-    GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
-    GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
- 
-    // Read the Vertex Shader code from the file
-    std::string VertexShaderCode;
-    std::ifstream VertexShaderStream(vertex_file_path, std::ios::in);
-    if(VertexShaderStream.is_open())
-    {
-        std::string Line = "";
-        while(getline(VertexShaderStream, Line))
-            VertexShaderCode += "\n" + Line;
-        VertexShaderStream.close();
-    }
- 
-    // Read the Fragment Shader code from the file
-    std::string FragmentShaderCode;
-    std::ifstream FragmentShaderStream(fragment_file_path, std::ios::in);
-    if(FragmentShaderStream.is_open()){
-        std::string Line = "";
-        while(getline(FragmentShaderStream, Line))
-            FragmentShaderCode += "\n" + Line;
-        FragmentShaderStream.close();
-    }
- 
-    GLint Result = GL_FALSE;
-    int InfoLogLength;
- 
-    // Compile Vertex Shader
-    printf("Compiling shader : %s\n", vertex_file_path);
-    char const * VertexSourcePointer = VertexShaderCode.c_str();
-    glShaderSource(VertexShaderID, 1, &VertexSourcePointer , nullptr);
-    glCompileShader(VertexShaderID);
- 
-    // Check Vertex Shader
-    glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result);
-    glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
-    std::vector<char> VertexShaderErrorMessage(InfoLogLength);
-    glGetShaderInfoLog(VertexShaderID, InfoLogLength, nullptr, &VertexShaderErrorMessage[0]);
-    fprintf(stdout, "%s\n", &VertexShaderErrorMessage[0]);
- 
-    // Compile Fragment Shader
-    printf("Compiling shader : %s\n", fragment_file_path);
-    char const * FragmentSourcePointer = FragmentShaderCode.c_str();
-    glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer , nullptr);
-    glCompileShader(FragmentShaderID);
- 
-    // Check Fragment Shader
-    glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
-    glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
-    std::vector<char> FragmentShaderErrorMessage(InfoLogLength);
-    glGetShaderInfoLog(FragmentShaderID, InfoLogLength, nullptr, &FragmentShaderErrorMessage[0]);
-    fprintf(stdout, "%s\n", &FragmentShaderErrorMessage[0]);
- 
-    // Link the program
-    fprintf(stdout, "Linking program\n");
-    GLuint ProgramID = glCreateProgram();
-    glAttachShader(ProgramID, VertexShaderID);
-    glAttachShader(ProgramID, FragmentShaderID);
-    glLinkProgram(ProgramID);
- 
-    // Check the program
-    glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
-    glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
-    std::vector<char> ProgramErrorMessage( glm::max(InfoLogLength, int(1)) );
-    glGetProgramInfoLog(ProgramID, InfoLogLength, nullptr, &ProgramErrorMessage[0]);
-    fprintf(stdout, "%s\n", &ProgramErrorMessage[0]);
- 
-    glDeleteShader(VertexShaderID);
-    glDeleteShader(FragmentShaderID);
- 
-    return ProgramID;
-}
-
-void flipImageData(unsigned char* data, int width, int height, int comps)
-{
-  unsigned char* data_copy = (unsigned char*) malloc(width*height*comps*sizeof(unsigned char));
-  memcpy(data_copy, data, width*height*comps);
-  
-  int row_size = width * comps;
-  
-  for (int i=0;i<height;i++)
-  {
-    memcpy(data + (row_size*i), data_copy + (row_size*(height-i-1)), row_size);
-  }
-  
-  free(data_copy);
-}
-
-void loadMesh(const char* filename, std::vector<glm::vec3>& out_vertices, std::vector<glm::vec2>& out_uvs, std::vector<glm::vec3>& out_normals)
-{
-  FILE* file = fopen(filename, "r");
-  if (file == nullptr)
-  {
-    fprintf(stderr, "Could not open mesh file %s\n", filename);
-    exit(1);
-  }
-  
-  std::vector<glm::vec3> temp_vertices;
-  std::vector<glm::vec2> temp_uvs;
-  std::vector<glm::vec3> temp_normals;
-  
-  for (;;)
-  {
-    char lineHeader[256];
-    int res = fscanf(file, "%s", lineHeader);
-    if (res == EOF)
-    {
-      break;
-    }
-    
-    if (!strncmp(lineHeader, "v", 2))
-    {
-      glm::vec3 vertex;
-      fscanf(file, "%f %f %f\n", &vertex.x,&vertex.y,&vertex.z);
-      temp_vertices.push_back(vertex);
-    } else if (!strncmp(lineHeader, "vt", 3))
-    {
-      glm::vec2 uv;
-      fscanf(file, "%f %f\n", &uv.x, &uv.y);
-      temp_uvs.push_back(uv);
-    } else if (!strncmp(lineHeader, "vn", 3))
-    {
-      glm::vec3 normal;
-      fscanf(file, "%f %f %f\n", &normal.x, &normal.y, &normal.z);
-      temp_normals.push_back(normal);
-    } else if (!strncmp(lineHeader, "f", 2))
-    {
-      int vertexIDs[3], uvIDs[3], normalIDs[3];
-      fscanf(file, "%d/%d/%d %d/%d/%d %d/%d/%d\n", &vertexIDs[0], &uvIDs[0], &normalIDs[0], &vertexIDs[1], &uvIDs[1], &normalIDs[1], &vertexIDs[2], &uvIDs[2], &normalIDs[2]);
-      
-      for (int i=0; i<3; i++)
-      {
-        out_vertices.push_back(temp_vertices[vertexIDs[i] - 1]);
-        out_uvs.push_back(temp_uvs[uvIDs[i] - 1]);
-        out_normals.push_back(temp_normals[normalIDs[i] - 1]);
-      }
-    }
-  }
-}
-
-void setFramebufferSize(GLFWwindow* w, int width, int height)
-{
-  buffer_width = width;
-  buffer_height = height;
-  
-  glDeleteFramebuffers(1, &bloom_framebuffer);
-  glDeleteRenderbuffers(1, &bloom_depthbuffer);
-  
-  glGenFramebuffers(1, &bloom_framebuffer);
-  glBindFramebuffer(GL_FRAMEBUFFER, bloom_framebuffer);
-  GLenum DrawBuffers[1] = {GL_COLOR_ATTACHMENT1};
-  glDrawBuffers(1, DrawBuffers);
-  
-  glGenRenderbuffers(1, &bloom_depthbuffer);
-  glBindRenderbuffer(GL_RENDERBUFFER, bloom_depthbuffer);
-  glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height);
-  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, bloom_depthbuffer);
-  
-  glDeleteTextures(1, &preBloomTex);
-  glDeleteTextures(1, &bloomPassTex1);
-  glDeleteTextures(1, &bloomPassTex2);
-  
-  glGenTextures(1, &preBloomTex);
-  glBindTexture(GL_TEXTURE_2D, preBloomTex);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_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);
-  
-  glGenTextures(1, &bloomPassTex1);
-  glBindTexture(GL_TEXTURE_2D, bloomPassTex1);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width/4, height/4, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_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);
-  
-  glGenTextures(1, &bloomPassTex2);
-  glBindTexture(GL_TEXTURE_2D, bloomPassTex2);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width/4, height/4, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_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);
-}
-
-GLFWwindow* initRenderer()
-{
-  if (rendererInitialized)
-  {
-    fprintf(stderr, "Renderer already initialized\n");
-    exit(-1);
-  }
-  
-  // Initialize GLFW
-  if (!glfwInit())
-  {
-    fprintf(stderr, "Failed to initialize GLFW\n");
-    exit(-1);
-  }
-  
-  glfwWindowHint(GLFW_SAMPLES, 4); // 4x antialiasing
-  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); // We want version 3.3
-  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
-  glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // Mac requires this
-  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-  
-  // Create a window
-  window = glfwCreateWindow(1024, 768, "Aromatherapy", nullptr, nullptr);
-  if (window == nullptr)
-  {
-    fprintf(stderr, "Failed to open GLFW window\n");
-    glfwTerminate();
-    exit(-1);
-  }
-  
-  glfwMakeContextCurrent(window);
-  glewExperimental = true; // Needed in core profile
-  if (glewInit() != GLEW_OK)
-  {
-    fprintf(stderr, "Failed to initialize GLEW\n");
-    exit(-1);
-  }
-  
-  glfwSetFramebufferSizeCallback(window, &setFramebufferSize);
-  
-  // Set up vertex array object
-  glGenVertexArrays(1, &VertexArrayID);
-  glBindVertexArray(VertexArrayID);
-  
-  // Enable depth testing
-  glEnable(GL_DEPTH_TEST);
-  glDepthFunc(GL_LESS);
-  
-  // Enable blending
-  glEnable(GL_BLEND);
-  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-  
-  // Set up the framebuffer
-  glGenFramebuffers(1, &generic_framebuffer);
-  glBindFramebuffer(GL_FRAMEBUFFER, generic_framebuffer);
-  GLenum DrawBuffers[1] = {GL_COLOR_ATTACHMENT0};
-  glDrawBuffers(1, DrawBuffers);
-  
-  glGenFramebuffers(1, &bloom_framebuffer);
-  glBindFramebuffer(GL_FRAMEBUFFER, bloom_framebuffer);
-  GLenum DrawBuffers2[1] = {GL_COLOR_ATTACHMENT1};
-  glDrawBuffers(1, DrawBuffers2);
-  
-  glGenRenderbuffers(1, &bloom_depthbuffer);
-  glBindRenderbuffer(GL_RENDERBUFFER, bloom_depthbuffer);
-  glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, 1024, 768);
-  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, bloom_depthbuffer);
-  
-  // Set up the NTSC rendering buffers
-  glGenTextures(1, &renderedTex1);
-  glBindTexture(GL_TEXTURE_2D, renderedTex1);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, GAME_WIDTH, GAME_HEIGHT, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-  renderedTexBufs[0] = renderedTex1;
-  
-  glGenTextures(1, &renderedTex2);
-  glBindTexture(GL_TEXTURE_2D, renderedTex2);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, GAME_WIDTH, GAME_HEIGHT, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-  renderedTexBufs[1] = renderedTex2;
-  
-  // Set up bloom rendering buffers
-  glGenTextures(1, &preBloomTex);
-  glBindTexture(GL_TEXTURE_2D, preBloomTex);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1024, 768, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_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);
-  
-  glGenTextures(1, &bloomPassTex1);
-  glBindTexture(GL_TEXTURE_2D, bloomPassTex1);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1024/4, 768/4, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_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);
-  
-  glGenTextures(1, &bloomPassTex2);
-  glBindTexture(GL_TEXTURE_2D, bloomPassTex2);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1024/4, 768/4, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_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);
-  
-  curBuf = 0;
-  
-  // Load the mesh!
-  std::vector<glm::vec3> mesh_vertices;
-  std::vector<glm::vec2> mesh_uvs;
-  std::vector<glm::vec3> mesh_normals;
-  loadMesh("res/monitor-old.obj", mesh_vertices, mesh_uvs, mesh_normals);
-  
-  mesh_numvertices = mesh_vertices.size();
-  
-  glGenBuffers(1, &mesh_vertexbuffer);
-  glBindBuffer(GL_ARRAY_BUFFER, mesh_vertexbuffer);
-  glBufferData(GL_ARRAY_BUFFER, mesh_vertices.size() * sizeof(glm::vec3), &mesh_vertices[0], GL_STATIC_DRAW);
-  
-  glGenBuffers(1, &mesh_uvbuffer);
-  glBindBuffer(GL_ARRAY_BUFFER, mesh_uvbuffer);
-  glBufferData(GL_ARRAY_BUFFER, mesh_uvs.size() * sizeof(glm::vec3), &mesh_uvs[0], GL_STATIC_DRAW);
-  
-  glGenBuffers(1, &mesh_normalbuffer);
-  glBindBuffer(GL_ARRAY_BUFFER, mesh_normalbuffer);
-  glBufferData(GL_ARRAY_BUFFER, mesh_normals.size() * sizeof(glm::vec3), &mesh_normals[0], GL_STATIC_DRAW);
-  
-  // Load the vertices of a flat surface
-  GLfloat g_quad_vertex_buffer_data[] = { 
-                -1.0f, -1.0f, 0.0f,
-                 1.0f, -1.0f, 0.0f,
-                -1.0f,  1.0f, 0.0f,
-                -1.0f,  1.0f, 0.0f,
-                 1.0f, -1.0f, 0.0f,
-                 1.0f,  1.0f, 0.0f,
-        };
-
-  glGenBuffers(1, &quad_vertexbuffer);
-  glBindBuffer(GL_ARRAY_BUFFER, quad_vertexbuffer);
-  glBufferData(GL_ARRAY_BUFFER, sizeof(g_quad_vertex_buffer_data), g_quad_vertex_buffer_data, GL_STATIC_DRAW);
-  
-  glGenTextures(1, &artifactsTex);
-  glBindTexture(GL_TEXTURE_2D, artifactsTex);
-  int atdw, atdh;
-  unsigned char* artifactsTex_data = stbi_load("res/artifacts.bmp", &atdw, &atdh, 0, 3);
-  flipImageData(artifactsTex_data, atdw, atdh, 3);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, atdw, atdh, 0, GL_RGB, GL_UNSIGNED_BYTE, artifactsTex_data);
-  stbi_image_free(artifactsTex_data);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
-  glGenerateMipmap(GL_TEXTURE_2D);
-  
-  glGenTextures(1, &scanlinesTex);
-  glBindTexture(GL_TEXTURE_2D, scanlinesTex);
-  int stdw, stdh;
-  unsigned char* scanlinesTex_data = stbi_load("res/scanlines_333.bmp", &stdw, &stdh, 0, 3);
-  flipImageData(scanlinesTex_data, stdw, stdh, 3);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, atdw, atdh, 0, GL_RGB, GL_UNSIGNED_BYTE, scanlinesTex_data);
-  stbi_image_free(scanlinesTex_data);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
-  glGenerateMipmap(GL_TEXTURE_2D);
-  
-  // Load the shaders
-  ntscShader = LoadShaders("shaders/ntsc.vertex", "shaders/ntsc.fragment");
-  finalShader = LoadShaders("shaders/final.vertex", "shaders/final.fragment");
-  blitShader = LoadShaders("shaders/blit.vertex", "shaders/blit.fragment");
-  fillShader = LoadShaders("shaders/fill.vertex", "shaders/fill.fragment");
-  bloom1Shader = LoadShaders("shaders/bloom1.vertex", "shaders/bloom1.fragment");
-  bloom2Shader = LoadShaders("shaders/bloom2.vertex", "shaders/bloom2.fragment");
-  
-  rendererInitialized = true;
-  
-  return window;
-}
-
-void destroyRenderer()
-{
-  if (!rendererInitialized)
-  {
-    fprintf(stderr, "Renderer not initialized\n");
-    exit(-1);
-  }
-  
-  // Delete the plane buffer
-  glDeleteBuffers(1, &quad_vertexbuffer);
-  glDeleteBuffers(1, &mesh_vertexbuffer);
-  glDeleteBuffers(1, &mesh_uvbuffer);
-  glDeleteBuffers(1, &mesh_normalbuffer);
-  
-  // Delete the shaders
-  glDeleteProgram(ntscShader);
-  glDeleteProgram(finalShader);
-  glDeleteProgram(blitShader);
-  glDeleteProgram(fillShader);
-  glDeleteProgram(bloom1Shader);
-  glDeleteProgram(bloom2Shader);
-  
-  // Delete the NTSC rendering buffers
-  glDeleteTextures(1, &renderedTex1);
-  glDeleteTextures(1, &renderedTex2);
-  glDeleteTextures(1, &artifactsTex);
-  glDeleteTextures(1, &scanlinesTex);
-  glDeleteTextures(1, &preBloomTex);
-  glDeleteTextures(1, &bloomPassTex1);
-  glDeleteTextures(1, &bloomPassTex2);
-  
-  // Delete the framebuffer
-  glDeleteRenderbuffers(1, &bloom_depthbuffer);
-  glDeleteFramebuffers(1, &bloom_framebuffer);
-  glDeleteFramebuffers(1, &generic_framebuffer);
-  
-  // Delete the VAO
-  glDeleteVertexArrays(1, &VertexArrayID);
-  
-  // Kill the window
-  glfwTerminate();
-  
-  rendererInitialized = false;
-}
-
-Texture::Texture(int width, int height)
-{
-  if (!rendererInitialized)
-  {
-    fprintf(stderr, "Renderer not initialized\n");
-    exit(-1);
-  }
-  
-  this->width = width;
-  this->height = height;
-  
-  glGenTextures(1, &texID);
-  glBindTexture(GL_TEXTURE_2D, texID);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-}
-
-Texture::Texture(const char* filename)
-{
-  if (!rendererInitialized)
-  {
-    fprintf(stderr, "Renderer not initialized\n");
-    exit(-1);
-  }
-  
-  glGenTextures(1, &texID);
-  glBindTexture(GL_TEXTURE_2D, texID);
-  unsigned char* data = stbi_load(filename, &width, &height, 0, 4);
-  flipImageData(data, width, height, 4);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  stbi_image_free(data);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-}
-
-Texture::Texture(const Texture& tex)
-{
-  if (!rendererInitialized)
-  {
-    fprintf(stderr, "Renderer not initialized\n");
-    exit(-1);
-  }
-  
-  width = tex.width;
-  height = tex.height;
-  
-  unsigned char* data = (unsigned char*) malloc(4 * width * height);
-  glBindTexture(GL_TEXTURE_2D, tex.texID);
-  glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  
-  glGenTextures(1, &texID);
-  glBindTexture(GL_TEXTURE_2D, texID);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  
-  free(data);
-}
-
-Texture::Texture(Texture&& tex) : Texture(0, 0)
-{
-  swap(*this, tex);
-}
-
-Texture::~Texture()
-{
-  if (!rendererInitialized)
-  {
-    fprintf(stderr, "Renderer not initialized\n");
-    exit(-1);
-  }
-  
-  glDeleteTextures(1, &texID);
-}
-
-Texture& Texture::operator= (Texture tex)
-{
-  swap(*this, tex);
-  
-  return *this;
-}
-
-void swap(Texture& tex1, Texture& tex2)
-{
-  std::swap(tex1.width, tex2.width);
-  std::swap(tex1.height, tex2.height);
-  std::swap(tex1.texID, tex2.texID);
-}
-
-void Texture::fill(Rectangle dstrect, int r, int g, int b)
-{
-  if (!rendererInitialized)
-  {
-    fprintf(stderr, "Renderer not initialized\n");
-    exit(-1);
-  }
-  
-  // Target the framebuffer
-  glBindFramebuffer(GL_FRAMEBUFFER, generic_framebuffer);
-  glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texID, 0);
-  
-  // Set up the vertex attributes
-  GLfloat minx = (GLfloat) dstrect.x / width * 2.0 - 1.0;
-  GLfloat miny = -((GLfloat) dstrect.y / height * 2.0 - 1.0);
-  GLfloat maxx = (GLfloat) (dstrect.x + dstrect.w) / width * 2.0 - 1.0;
-  GLfloat maxy = -((GLfloat) (dstrect.y + dstrect.h) / height * 2.0 - 1.0);
-  
-  GLfloat vertexbuffer_data[] = {
-    minx, miny,
-    maxx, miny,
-    maxx, maxy,
-    minx, miny,
-    minx, maxy,
-    maxx, maxy
-  };
-  GLuint vertexbuffer;
-  glGenBuffers(1, &vertexbuffer);
-  glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
-  glBufferData(GL_ARRAY_BUFFER, sizeof(vertexbuffer_data), vertexbuffer_data, GL_STATIC_DRAW);
-  glEnableVertexAttribArray(0);
-  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
-  
-  glViewport(0, 0, width, height);
-  glClear(GL_DEPTH_BUFFER_BIT);
-  glUseProgram(fillShader);
-  glUniform3f(glGetUniformLocation(fillShader, "vecColor"), r / 255.0, g / 255.0, b / 255.0);
-  
-  glDrawArrays(GL_TRIANGLES, 0, 6);
-  
-  glDisableVertexAttribArray(0);
-  glDeleteBuffers(1, &vertexbuffer);
-}
-
-void Texture::blit(const Texture& srctex, Rectangle srcrect, Rectangle dstrect, double alpha)
-{
-  if (!rendererInitialized)
-  {
-    fprintf(stderr, "Renderer not initialized\n");
-    exit(-1);
-  }
-  
-  alpha = glm::clamp(alpha, 0.0, 1.0);
-  
-  // Target the framebuffer
-  glBindFramebuffer(GL_FRAMEBUFFER, generic_framebuffer);
-  glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texID, 0);
-  
-  // Set up the vertex attributes
-  GLfloat minx = (GLfloat) dstrect.x / width * 2.0 - 1.0;
-  GLfloat miny = -((GLfloat) dstrect.y / height * 2.0 - 1.0);
-  GLfloat maxx = (GLfloat) (dstrect.x + dstrect.w) / width * 2.0 - 1.0;
-  GLfloat maxy = -((GLfloat) (dstrect.y + dstrect.h) / height * 2.0 - 1.0);
-  
-  GLfloat vertexbuffer_data[] = {
-    minx, miny,
-    maxx, miny,
-    minx, maxy,
-    maxx, maxy
-  };
-  GLuint vertexbuffer;
-  glGenBuffers(1, &vertexbuffer);
-  glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
-  glBufferData(GL_ARRAY_BUFFER, sizeof(vertexbuffer_data), vertexbuffer_data, GL_STATIC_DRAW);
-  glEnableVertexAttribArray(0);
-  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
-  
-  GLfloat minu = (GLfloat) srcrect.x / srctex.width;
-  GLfloat minv = 1 - ((GLfloat) srcrect.y / srctex.height);
-  GLfloat maxu = (GLfloat) (srcrect.x + srcrect.w) / srctex.width;
-  GLfloat maxv = 1 - ((GLfloat) (srcrect.y + srcrect.h) / srctex.height);
-  
-  GLfloat texcoordbuffer_data[] = {
-    minu, minv,
-    maxu, minv,
-    minu, maxv,
-    maxu, maxv
-  };
-  GLuint texcoordbuffer;
-  glGenBuffers(1, &texcoordbuffer);
-  glBindBuffer(GL_ARRAY_BUFFER, texcoordbuffer);
-  glBufferData(GL_ARRAY_BUFFER, sizeof(texcoordbuffer_data), texcoordbuffer_data, GL_STATIC_DRAW);
-  glEnableVertexAttribArray(1);
-  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
-  
-  // Set up the shader
-  glUseProgram(blitShader);
-  glClear(GL_DEPTH_BUFFER_BIT);
-  glViewport(0, 0, width, height);
-  
-  glActiveTexture(GL_TEXTURE0);
-  glBindTexture(GL_TEXTURE_2D, srctex.texID);
-  glUniform1i(glGetUniformLocation(blitShader, "srctex"), 0);
-  glUniform1f(glGetUniformLocation(blitShader, "alpha"), alpha);
-  
-  // Blit!
-  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-  
-  // Unload everything
-  glDisableVertexAttribArray(1);
-  glDisableVertexAttribArray(0);
-  glDeleteBuffers(1, &texcoordbuffer);
-  glDeleteBuffers(1, &vertexbuffer);
-}
-
-void bloomPass1(GLuint srcTex, GLuint dstTex, bool horizontal, glm::vec2 srcRes, glm::vec2 dstRes)
-{
-  glBindFramebuffer(GL_FRAMEBUFFER, generic_framebuffer);
-  glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, dstTex, 0);
-  glViewport(0,0,dstRes.x,dstRes.y);
-  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-  glUseProgram(bloom1Shader);
-  
-  glActiveTexture(GL_TEXTURE0);
-  glBindTexture(GL_TEXTURE_2D, srcTex);
-  glUniform1i(glGetUniformLocation(bloom1Shader, "inTex"), 0);
-  
-  glm::vec2 offset = glm::vec2(0.0);
-  if (horizontal)
-  {
-    offset.x = 1.2/srcRes.x;
-  } else {
-    offset.y = 1.2/srcRes.y;
-  }
-  
-  glUniform2f(glGetUniformLocation(bloom1Shader, "offset"), offset.x, offset.y);
-  
-  glEnableVertexAttribArray(0);
-  glBindBuffer(GL_ARRAY_BUFFER, quad_vertexbuffer);
-  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
-  glDrawArrays(GL_TRIANGLES, 0, 6);
-  glDisableVertexAttribArray(0);
-}
-
-void Texture::renderScreen() const
-{
-  if (!rendererInitialized)
-  {
-    fprintf(stderr, "Renderer not initialized\n");
-    exit(-1);
-  }
-  
-  // First we're going to composite our frame with the previous frame
-  // We start by setting up the framebuffer
-  glBindFramebuffer(GL_FRAMEBUFFER, generic_framebuffer);
-  glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, renderedTexBufs[curBuf], 0);
-  
-  // Set up the shader
-  glViewport(0,0,GAME_WIDTH,GAME_HEIGHT);
-  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-  glUseProgram(ntscShader);
-  
-  // Use the current frame texture, nearest neighbor and clamped to edge
-  glActiveTexture(GL_TEXTURE0);
-  glBindTexture(GL_TEXTURE_2D, texID);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  glUniform1i(glGetUniformLocation(ntscShader, "curFrameSampler"), 0);
-  
-  // Use the previous frame composite texture, nearest neighbor and clamped to edge
-  glActiveTexture(GL_TEXTURE1);
-  glBindTexture(GL_TEXTURE_2D, renderedTexBufs[(curBuf + 1) % 2]);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  glUniform1i(glGetUniformLocation(ntscShader, "prevFrameSampler"), 1);
-  
-  // Load the NTSC artifact texture
-  glActiveTexture(GL_TEXTURE2);
-  glBindTexture(GL_TEXTURE_2D, artifactsTex);
-  glUniform1i(glGetUniformLocation(ntscShader, "NTSCArtifactSampler"), 2);
-  glUniform1f(glGetUniformLocation(ntscShader, "NTSCLerp"), curBuf * 1.0);
-  
-  if ((rand() % 60) == 0)
-  {
-    // Change the 0.0 to a 1.0 or a 10.0 for a glitchy effect!
-    glUniform1f(glGetUniformLocation(ntscShader, "Tuning_NTSC"), 0.0);
-  } else {
-    glUniform1f(glGetUniformLocation(ntscShader, "Tuning_NTSC"), 0.0);
-  }
-  
-  // Render our composition
-  glEnableVertexAttribArray(0);
-  glBindBuffer(GL_ARRAY_BUFFER, quad_vertexbuffer);
-  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
-  glDrawArrays(GL_TRIANGLES, 0, 6);
-  glDisableVertexAttribArray(0);
-
-  // We're going to render the screen now
-  glBindFramebuffer(GL_FRAMEBUFFER, bloom_framebuffer);
-  glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, preBloomTex, 0);
-  glViewport(0,0,buffer_width,buffer_height);
-  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-  glUseProgram(finalShader);
-  
-  // Use the composited frame texture, linearly filtered and filling in black for the border
-  glActiveTexture(GL_TEXTURE0);
-  glBindTexture(GL_TEXTURE_2D, renderedTexBufs[curBuf]);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
-  float border_color[] = {0.0f, 0.0f, 0.0f, 1.0f};
-  glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_color);
-        glGenerateMipmap(GL_TEXTURE_2D);
-  glUniform1i(glGetUniformLocation(finalShader, "rendertex"), 0);
-  
-  // Use the scanlines texture
-  glActiveTexture(GL_TEXTURE1);
-  glBindTexture(GL_TEXTURE_2D, scanlinesTex);
-  glUniform1i(glGetUniformLocation(finalShader, "scanlinestex"), 1);
-  
-  // Initialize the MVP matrices
-  glm::mat4 p_matrix = glm::perspective(glm::radians(25.0f), (float) buffer_width / (float) buffer_height, 0.1f, 100.0f);
-  glm::mat4 v_matrix = glm::lookAt(glm::vec3(3.75,0,0), glm::vec3(0,0,0), glm::vec3(0,1,0));
-  glm::mat4 m_matrix = glm::mat4(1.0);
-  glm::mat4 mvp_matrix = p_matrix * v_matrix * m_matrix;
-  
-  glUniformMatrix4fv(glGetUniformLocation(finalShader, "MVP"), 1, GL_FALSE, &mvp_matrix[0][0]);
-  glUniformMatrix4fv(glGetUniformLocation(finalShader, "worldMat"), 1, GL_FALSE, &m_matrix[0][0]);
-  glUniform2f(glGetUniformLocation(finalShader, "resolution"), buffer_width, buffer_height);
-  glUniform1f(glGetUniformLocation(finalShader, "iGlobalTime"), glfwGetTime());
-  glUniform3f(glGetUniformLocation(finalShader, "frameColor"), 0.76f, 0.78f, 0.81f);
-  
-  glEnableVertexAttribArray(0);
-  glBindBuffer(GL_ARRAY_BUFFER, mesh_vertexbuffer);
-  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
-  
-  glEnableVertexAttribArray(1);
-  glBindBuffer(GL_ARRAY_BUFFER, mesh_normalbuffer);
-  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
-  
-  glEnableVertexAttribArray(2);
-  glBindBuffer(GL_ARRAY_BUFFER, mesh_uvbuffer);
-  glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
-  
-  glDrawArrays(GL_TRIANGLES, 0, mesh_numvertices);
-  glDisableVertexAttribArray(2);
-  glDisableVertexAttribArray(1);
-  glDisableVertexAttribArray(0);
-  
-  // First pass of bloom!
-  glm::vec2 buffer_size = glm::vec2(buffer_width, buffer_height);
-  bloomPass1(preBloomTex, bloomPassTex1, true, buffer_size, buffer_size / 4.0f);
-  bloomPass1(bloomPassTex1, bloomPassTex2, false, buffer_size / 4.0f, buffer_size / 4.0f);
-  
-  // Do the second pass of bloom and render to screen
-  glBindFramebuffer(GL_FRAMEBUFFER, 0);
-  glViewport(0, 0, buffer_width, buffer_height);
-  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-  glUseProgram(bloom2Shader);
-  
-  glActiveTexture(GL_TEXTURE0);
-  glBindTexture(GL_TEXTURE_2D, preBloomTex);
-  glUniform1i(glGetUniformLocation(bloom2Shader, "clearTex"), 0);
-  
-  glActiveTexture(GL_TEXTURE1);
-  glBindTexture(GL_TEXTURE_2D, bloomPassTex2);
-  glUniform1i(glGetUniformLocation(bloom2Shader, "blurTex"), 1);
-  
-  glUniform1f(glGetUniformLocation(bloom2Shader, "iGlobalTime"), glfwGetTime());
-  
-  glEnableVertexAttribArray(0);
-  glBindBuffer(GL_ARRAY_BUFFER, quad_vertexbuffer);
-  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
-  glDrawArrays(GL_TRIANGLES, 0, 6);
-  glDisableVertexAttribArray(0);
-  
-  glfwSwapBuffers(window);
-  
-  curBuf = (curBuf + 1) % 2;
-}
-
-Rectangle Texture::entirety() const
-{
-  return {0, 0, width, height};
-}
@@ -1,37 +0,0 @@
-#include <GL/glew.h>
-#include <GLFW/glfw3.h>
-
-#ifndef RENDERER_H
-#define RENDERER_H
-
-struct Rectangle {
-  int x;
-  int y;
-  int w;
-  int h;
-};
-
-class Texture {
-  public:
-    Texture(int width, int height);
-    Texture(const char* file);
-    Texture(const Texture& tex);
-    Texture(Texture&& tex);
-    ~Texture();
-    Texture& operator= (Texture tex);
-    friend void swap(Texture& tex1, Texture& tex2);
-    void fill(Rectangle loc, int r, int g, int b);
-    void blit(const Texture& src, Rectangle srcrect, Rectangle dstrect, double alpha = 1.0);
-    void renderScreen() const;
-    Rectangle entirety() const;
-    
-  private:
-    GLuint texID;
-    int width;
-    int height;
-};
-
-GLFWwindow* initRenderer();
-void destroyRenderer();
-
-#endif
@@ -0,0 +1,7 @@
+#ifndef GL_H_3EE4A268
+#define GL_H_3EE4A268
+
+#include <GL/glew.h>
+#include <GLFW/glfw3.h>
+
+#endif /* end of include guard: GL_H_3EE4A268 */
@@ -0,0 +1,109 @@
+#include "mesh.h"
+#include <fstream>
+#include <vector>
+#include <map>
+#include <glm/glm.hpp>
+#include "util.h"
+
+Mesh::Mesh(std::string filename)
+{
+  std::ifstream meshfile(filename);
+  if (!meshfile.is_open())
+  {
+    throw std::invalid_argument("Could not open mesh file");
+  }
+
+  std::vector<glm::vec3> tempVertices;
+  std::vector<glm::vec2> tempUvs;
+  std::vector<glm::vec3> tempNormals;
+
+  std::vector<glm::vec3> outVertices;
+  std::vector<glm::vec2> outUvs;
+  std::vector<glm::vec3> outNormals;
+  std::map<element, unsigned short> elementIds;
+  std::vector<unsigned short> indices;
+
+  while (meshfile)
+  {
+    std::string linetype;
+    meshfile >> linetype;
+
+    if (linetype == "v")
+    {
+      glm::vec3 vertex;
+      meshfile >> vertex.x >> vertex.y >> vertex.z;
+
+      tempVertices.push_back(std::move(vertex));
+    } else if (linetype == "vt")
+    {
+      glm::vec2 uv;
+      meshfile >> uv.x >> uv.y;
+
+      tempUvs.push_back(std::move(uv));
+    } else if (linetype == "vn")
+    {
+      glm::vec3 normal;
+      meshfile >> normal.x >> normal.y >> normal.z;
+
+      tempNormals.push_back(std::move(normal));
+    } else if (linetype == "f")
+    {
+      element elements[3];
+
+      meshfile
+        >> elements[0].vertexId >> chlit('/')
+        >> elements[0].uvId >> chlit('/')
+        >> elements[0].normalId
+        >> elements[1].vertexId >> chlit('/')
+        >> elements[1].uvId >> chlit('/')
+        >> elements[1].normalId
+        >> elements[2].vertexId >> chlit('/')
+        >> elements[2].uvId >> chlit('/')
+        >> elements[2].normalId;
+
+      for (size_t i = 0; i < 3; i++)
+      {
+        if (!elementIds.count(elements[i]))
+        {
+          elementIds[elements[i]] = outVertices.size();
+
+          outVertices.push_back(tempVertices[elements[i].vertexId - 1]);
+          outUvs.push_back(tempUvs[elements[i].uvId - 1]);
+          outNormals.push_back(tempNormals[elements[i].normalId - 1]);
+        }
+
+        indices.push_back(elementIds[elements[i]]);
+      }
+    }
+  }
+
+  glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer_.getId());
+  glBufferData(
+    GL_ARRAY_BUFFER,
+    outVertices.size() * sizeof(glm::vec3),
+    outVertices.data(),
+    GL_STATIC_DRAW);
+
+  glBindBuffer(GL_ARRAY_BUFFER, uvBuffer_.getId());
+  glBufferData(
+    GL_ARRAY_BUFFER,
+    outUvs.size() * sizeof(glm::vec2),
+    outUvs.data(),
+    GL_STATIC_DRAW);
+
+  glBindBuffer(GL_ARRAY_BUFFER, normalBuffer_.getId());
+  glBufferData(
+    GL_ARRAY_BUFFER,
+    outNormals.size() * sizeof(glm::vec3),
+    outNormals.data(),
+    GL_STATIC_DRAW);
+
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer_.getId());
+  glBufferData(
+    GL_ELEMENT_ARRAY_BUFFER,
+    indices.size() * sizeof(unsigned short),
+    indices.data(),
+    GL_STATIC_DRAW);
+
+  indexCount_ = indices.size();
+}
@@ -0,0 +1,62 @@
+#ifndef MESH_H_76B72E12
+#define MESH_H_76B72E12
+
+#include <string>
+#include "gl.h"
+#include "wrappers.h"
+
+class Mesh {
+public:
+
+  Mesh(std::string filename);
+
+  Mesh(const Mesh& other) = delete;
+  Mesh& operator=(const Mesh& other) = delete;
+
+  inline GLuint getVertexBufferId() const
+  {
+    return vertexBuffer_.getId();
+  }
+
+  inline GLuint getUvBufferId() const
+  {
+    return uvBuffer_.getId();
+  }
+
+  inline GLuint getNormalBufferId() const
+  {
+    return normalBuffer_.getId();
+  }
+
+  inline GLuint getIndexBufferId() const
+  {
+    return indexBuffer_.getId();
+  }
+
+  inline size_t getIndexCount() const
+  {
+    return indexCount_;
+  }
+
+private:
+
+  struct element {
+    size_t vertexId;
+    size_t uvId;
+    size_t normalId;
+
+    bool operator<(const element& other) const
+    {
+      return std::tie(vertexId, uvId, normalId) <
+        std::tie(other.vertexId, other.uvId, other.normalId);
+    }
+  };
+
+  GLBuffer vertexBuffer_;
+  GLBuffer uvBuffer_;
+  GLBuffer normalBuffer_;
+  GLBuffer indexBuffer_;
+  size_t indexCount_;
+};
+
+#endif /* end of include guard: MESH_H_76B72E12 */
@@ -0,0 +1,630 @@
+#include "renderer.h"
+#include <glm/gtc/matrix_transform.hpp>
+#include <stb_image.h>
+#include "consts.h"
+#include "game.h"
+#include "texture.h"
+
+void setFramebufferSize(GLFWwindow* w, int width, int height)
+{
+  Game& game = *static_cast<Game*>(glfwGetWindowUserPointer(w));
+  Renderer& renderer = game.getRenderer();
+
+  renderer.width_ = width;
+  renderer.height_ = height;
+
+  renderer.bloomFb_ = {};
+  renderer.bloomDepth_ = {};
+  renderer.preBloomTex_ = {};
+  renderer.bloomPassTex1_ = {};
+  renderer.bloomPassTex2_ = {};
+
+  renderer.initializeFramebuffers();
+}
+
+bool Renderer::singletonInitialized_ = false;
+
+Renderer::Window::Window()
+{
+  // Initialize GLFW
+  if (!glfwInit())
+  {
+    throw std::runtime_error("Failed to initialize GLFW");
+  }
+
+  glfwWindowHint(GLFW_SAMPLES, 4); // 4x antialiasing
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); // We want version 3.3
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+  glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // Mac requires this
+  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+
+  // Create a window
+  window_ = glfwCreateWindow(1024, 768, "Aromatherapy", nullptr, nullptr);
+  if (window_ == nullptr)
+  {
+    throw std::runtime_error("Failed to open GLFW window");
+  }
+
+  glfwMakeContextCurrent(window_);
+
+  glewExperimental = true; // Needed in core profile
+  if (glewInit() != GLEW_OK)
+  {
+    throw std::runtime_error("Failed to initialize GLEW");
+  }
+
+  glfwSetFramebufferSizeCallback(window_, &setFramebufferSize);
+}
+
+Renderer::Window::~Window()
+{
+  glfwTerminate();
+}
+
+Renderer::Renderer() :
+  monitor_("res/monitor-old.obj"),
+  ntscShader_("ntsc"),
+  finalShader_("final"),
+  blitShader_("blit"),
+  fillShader_("fill"),
+  bloom1Shader_("bloom1"),
+  bloom2Shader_("bloom2")
+{
+  if (singletonInitialized_)
+  {
+    throw std::logic_error("Singleton renderer already initialized");
+  }
+
+  singletonInitialized_ = true;
+
+  // Set up vertex array object
+  glBindVertexArray(vao_.getId());
+
+  // Enable depth testing
+  glEnable(GL_DEPTH_TEST);
+  glDepthFunc(GL_LESS);
+
+  // Enable blending
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+  // Set up the rendering buffers and textures
+  glfwGetFramebufferSize(window_.getHandle(), &width_, &height_);
+
+  initializeFramebuffers();
+
+  // Load the vertices of a flat surface
+  GLfloat g_quad_vertex_buffer_data[] = {
+                -1.0f, -1.0f, 0.0f,
+                 1.0f, -1.0f, 0.0f,
+                -1.0f,  1.0f, 0.0f,
+                -1.0f,  1.0f, 0.0f,
+                 1.0f, -1.0f, 0.0f,
+                 1.0f,  1.0f, 0.0f,
+        };
+
+  glBindBuffer(GL_ARRAY_BUFFER, quadBuffer_.getId());
+  glBufferData(
+    GL_ARRAY_BUFFER,
+    sizeof(GLfloat) * 18,
+    g_quad_vertex_buffer_data,
+    GL_STATIC_DRAW);
+
+  // Load NTSC artifacts
+  int atdw, atdh;
+  unsigned char* artifactsData =
+    stbi_load("res/artifacts.bmp", &atdw, &atdh, 0, 3);
+
+  flipImageData(artifactsData, atdw, atdh, 3);
+
+  glBindTexture(GL_TEXTURE_2D, artifactsTex_.getId());
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGB,
+    atdw,
+    atdh,
+    0,
+    GL_RGB,
+    GL_UNSIGNED_BYTE,
+    artifactsData);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(
+    GL_TEXTURE_2D,
+    GL_TEXTURE_MIN_FILTER,
+    GL_NEAREST_MIPMAP_NEAREST);
+
+  glGenerateMipmap(GL_TEXTURE_2D);
+  stbi_image_free(artifactsData);
+
+  // Load NTSC scanlines
+  unsigned char* scanlinesData =
+    stbi_load("res/scanlines_333.bmp", &atdw, &atdh, 0, 3);
+
+  flipImageData(scanlinesData, atdw, atdh, 3);
+
+  glBindTexture(GL_TEXTURE_2D, scanlinesTex_.getId());
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGB,
+    atdw,
+    atdh,
+    0,
+    GL_RGB,
+    GL_UNSIGNED_BYTE,
+    scanlinesData);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(
+    GL_TEXTURE_2D,
+    GL_TEXTURE_MIN_FILTER,
+    GL_NEAREST_MIPMAP_NEAREST);
+
+  glGenerateMipmap(GL_TEXTURE_2D);
+  stbi_image_free(scanlinesData);
+}
+
+void Renderer::initializeFramebuffers()
+{
+  // Set up the framebuffer
+  glBindFramebuffer(GL_FRAMEBUFFER, genericFb_.getId());
+  GLenum DrawBuffers[1] = {GL_COLOR_ATTACHMENT0};
+  glDrawBuffers(1, DrawBuffers);
+
+  // Set up the bloom framebuffer and depthbuffer
+  glBindFramebuffer(GL_FRAMEBUFFER, bloomFb_.getId());
+  GLenum DrawBuffers2[1] = {GL_COLOR_ATTACHMENT1};
+  glDrawBuffers(1, DrawBuffers2);
+
+  glBindRenderbuffer(GL_RENDERBUFFER, bloomDepth_.getId());
+  glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width_, height_);
+  glFramebufferRenderbuffer(
+    GL_FRAMEBUFFER,
+    GL_DEPTH_ATTACHMENT,
+    GL_RENDERBUFFER,
+    bloomDepth_.getId());
+
+  // Set up the NTSC rendering buffers
+  glBindTexture(GL_TEXTURE_2D, renderPages_[0].getId());
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGB,
+    GAME_WIDTH,
+    GAME_HEIGHT,
+    0,
+    GL_RGB,
+    GL_UNSIGNED_BYTE,
+    0);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+  glBindTexture(GL_TEXTURE_2D, renderPages_[1].getId());
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGB,
+    GAME_WIDTH,
+    GAME_HEIGHT,
+    0,
+    GL_RGB,
+    GL_UNSIGNED_BYTE,
+    0);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+  // Set up bloom rendering buffers
+  glBindTexture(GL_TEXTURE_2D, preBloomTex_.getId());
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGB,
+    width_,
+    height_,
+    0,
+    GL_RGB,
+    GL_UNSIGNED_BYTE,
+    0);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_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);
+
+  glBindTexture(GL_TEXTURE_2D, bloomPassTex1_.getId());
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGB,
+    width_ / 4,
+    height_ / 4,
+    0,
+    GL_RGB,
+    GL_UNSIGNED_BYTE,
+    0);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_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);
+
+  glBindTexture(GL_TEXTURE_2D, bloomPassTex2_.getId());
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGB,
+    width_ / 4,
+    height_ / 4,
+    0,
+    GL_RGB,
+    GL_UNSIGNED_BYTE,
+    0);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_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);
+}
+
+Renderer::~Renderer()
+{
+  singletonInitialized_ = false;
+}
+
+void Renderer::fill(Texture& tex, Rectangle dstrect, int r, int g, int b)
+{
+  // Target the framebuffer
+  glBindFramebuffer(GL_FRAMEBUFFER, genericFb_.getId());
+  glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex.getId(), 0);
+
+  // Set up the vertex attributes
+  int width = tex.getWidth();
+  int height = tex.getHeight();
+
+  GLfloat minx = (GLfloat) dstrect.x / width * 2.0 - 1.0;
+  GLfloat miny = -((GLfloat) dstrect.y / height * 2.0 - 1.0);
+  GLfloat maxx = (GLfloat) (dstrect.x + dstrect.w) / width * 2.0 - 1.0;
+  GLfloat maxy = -((GLfloat) (dstrect.y + dstrect.h) / height * 2.0 - 1.0);
+
+  GLfloat vertexData[] = {
+    minx, miny,
+    maxx, miny,
+    maxx, maxy,
+    minx, miny,
+    minx, maxy,
+    maxx, maxy
+  };
+
+  GLBuffer vertexBuffer;
+  glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer.getId());
+  glBufferData(
+    GL_ARRAY_BUFFER,
+    sizeof(GLfloat) * 12,
+    vertexData, GL_STATIC_DRAW);
+
+  glEnableVertexAttribArray(0);
+  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+  glViewport(0, 0, tex.getWidth(), tex.getHeight());
+  glClear(GL_DEPTH_BUFFER_BIT);
+
+  fillShader_.use();
+  glUniform3f(
+    fillShader_.getUniformLocation("vecColor"),
+    r / 255.0,
+    g / 255.0,
+    b / 255.0);
+
+  glDrawArrays(GL_TRIANGLES, 0, 6);
+
+  glDisableVertexAttribArray(0);
+}
+
+void Renderer::blit(
+  const Texture& src,
+  Texture& dst,
+  Rectangle srcrect,
+  Rectangle dstrect,
+  double alpha)
+{
+  alpha = glm::clamp(alpha, 0.0, 1.0);
+
+  // Target the framebuffer
+  glBindFramebuffer(GL_FRAMEBUFFER, genericFb_.getId());
+  glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, dst.getId(), 0);
+
+  // Set up the vertex attributes
+  int width = dst.getWidth();
+  int height = dst.getHeight();
+
+  GLfloat minx = (GLfloat) dstrect.x / width * 2.0 - 1.0;
+  GLfloat miny = -((GLfloat) dstrect.y / height * 2.0 - 1.0);
+  GLfloat maxx = (GLfloat) (dstrect.x + dstrect.w) / width * 2.0 - 1.0;
+  GLfloat maxy = -((GLfloat) (dstrect.y + dstrect.h) / height * 2.0 - 1.0);
+
+  GLfloat vertexData[] = {
+    minx, miny,
+    maxx, miny,
+    minx, maxy,
+    maxx, maxy
+  };
+
+  GLBuffer vertexBuffer;
+  glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer.getId());
+  glBufferData(
+    GL_ARRAY_BUFFER,
+    sizeof(GLfloat) * 8,
+    vertexData,
+    GL_STATIC_DRAW);
+
+  glEnableVertexAttribArray(0);
+  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+  GLfloat minu = (GLfloat) srcrect.x / src.getWidth();
+  GLfloat minv = 1 - ((GLfloat) srcrect.y / src.getHeight());
+  GLfloat maxu = (GLfloat) (srcrect.x + srcrect.w) / src.getWidth();
+  GLfloat maxv = 1 - ((GLfloat) (srcrect.y + srcrect.h) / src.getHeight());
+
+  GLfloat uvData[] = {
+    minu, minv,
+    maxu, minv,
+    minu, maxv,
+    maxu, maxv
+  };
+
+  GLBuffer uvBuffer;
+  glBindBuffer(GL_ARRAY_BUFFER, uvBuffer.getId());
+  glBufferData(
+    GL_ARRAY_BUFFER,
+    sizeof(GLfloat) * 8,
+    uvData,
+    GL_STATIC_DRAW);
+
+  glEnableVertexAttribArray(1);
+  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+  // Set up the shader
+  blitShader_.use();
+  glClear(GL_DEPTH_BUFFER_BIT);
+  glViewport(0, 0, dst.getWidth(), dst.getHeight());
+
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, src.getId());
+  glUniform1i(blitShader_.getUniformLocation("srctex"), 0);
+  glUniform1f(blitShader_.getUniformLocation("alpha"), alpha);
+
+  // Blit!
+  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+  // Unload everything
+  glDisableVertexAttribArray(1);
+  glDisableVertexAttribArray(0);
+}
+
+void Renderer::bloomPass1(
+  const GLTexture& src,
+  GLTexture& dst,
+  bool horizontal,
+  glm::vec2 srcRes,
+  glm::vec2 dstRes)
+{
+  glBindFramebuffer(GL_FRAMEBUFFER, genericFb_.getId());
+  glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, dst.getId(), 0);
+  glViewport(0,0,dstRes.x,dstRes.y);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  bloom1Shader_.use();
+
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, src.getId());
+  glUniform1i(bloom1Shader_.getUniformLocation("inTex"), 0);
+
+  glm::vec2 offset = glm::vec2(0.0);
+  if (horizontal)
+  {
+    offset.x = 1.2/srcRes.x;
+  } else {
+    offset.y = 1.2/srcRes.y;
+  }
+
+  glUniform2f(bloom1Shader_.getUniformLocation("offset"), offset.x, offset.y);
+
+  glEnableVertexAttribArray(0);
+  glBindBuffer(GL_ARRAY_BUFFER, quadBuffer_.getId());
+  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+  glDrawArrays(GL_TRIANGLES, 0, 6);
+  glDisableVertexAttribArray(0);
+}
+
+void Renderer::renderScreen(const Texture& tex)
+{
+  // First we're going to composite our frame with the previous frame
+  // We start by setting up the framebuffer
+  glBindFramebuffer(GL_FRAMEBUFFER, genericFb_.getId());
+  glFramebufferTexture(
+    GL_FRAMEBUFFER,
+    GL_COLOR_ATTACHMENT0,
+    renderPages_[curBuf_].getId(),
+    0);
+
+  // Set up the shader
+  glViewport(0,0,GAME_WIDTH,GAME_HEIGHT);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  ntscShader_.use();
+
+  // Use the current frame texture, nearest neighbor and clamped to edge
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, tex.getId());
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glUniform1i(ntscShader_.getUniformLocation("curFrameSampler"), 0);
+
+  // Use the previous frame composite texture, nearest neighbor and clamped to
+  // edge
+  glActiveTexture(GL_TEXTURE1);
+  glBindTexture(GL_TEXTURE_2D, renderPages_[(curBuf_ + 1) % 2].getId());
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glUniform1i(ntscShader_.getUniformLocation("prevFrameSampler"), 1);
+
+  // Load the NTSC artifact texture
+  glActiveTexture(GL_TEXTURE2);
+  glBindTexture(GL_TEXTURE_2D, artifactsTex_.getId());
+  glUniform1i(ntscShader_.getUniformLocation("NTSCArtifactSampler"), 2);
+  glUniform1f(ntscShader_.getUniformLocation("NTSCLerp"), curBuf_ * 1.0);
+
+  // Change the 0.0 to a 1.0 or a 10.0 for a glitchy effect!
+  glUniform1f(ntscShader_.getUniformLocation("Tuning_NTSC"), 0.0);
+
+  // Render our composition
+  glEnableVertexAttribArray(0);
+  glBindBuffer(GL_ARRAY_BUFFER, quadBuffer_.getId());
+  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+  glDrawArrays(GL_TRIANGLES, 0, 6);
+  glDisableVertexAttribArray(0);
+
+  // We're going to render the screen now
+  glBindFramebuffer(GL_FRAMEBUFFER, bloomFb_.getId());
+  glFramebufferTexture(
+    GL_FRAMEBUFFER,
+    GL_COLOR_ATTACHMENT1,
+    preBloomTex_.getId(),
+    0);
+
+  glViewport(0,0,width_,height_);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  finalShader_.use();
+
+  // Use the composited frame texture, linearly filtered and filling in black
+  // for the border
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, renderPages_[curBuf_].getId());
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+
+  float borderColor[] = {0.0f, 0.0f, 0.0f, 1.0f};
+  glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
+
+        glGenerateMipmap(GL_TEXTURE_2D);
+  glUniform1i(finalShader_.getUniformLocation("rendertex"), 0);
+
+  // Use the scanlines texture
+  glActiveTexture(GL_TEXTURE1);
+  glBindTexture(GL_TEXTURE_2D, scanlinesTex_.getId());
+  glUniform1i(finalShader_.getUniformLocation("scanlinestex"), 1);
+
+  // Initialize the MVP matrices
+  glm::mat4 p_matrix = glm::perspective(
+    glm::radians(25.0f),
+    static_cast<float>(width_) / static_cast<float>(height_),
+    0.1f,
+    100.0f);
+
+  glm::mat4 v_matrix = glm::lookAt(
+    glm::vec3(3.75,0,0), // Camera
+    glm::vec3(0,0,0),    // Center
+    glm::vec3(0,1,0));   // Up
+
+  glm::mat4 m_matrix = glm::mat4(1.0);
+  glm::mat4 mvp_matrix = p_matrix * v_matrix * m_matrix;
+
+  glUniformMatrix4fv(
+    finalShader_.getUniformLocation("MVP"),
+    1,
+    GL_FALSE,
+    &mvp_matrix[0][0]);
+
+  glUniformMatrix4fv(
+    finalShader_.getUniformLocation("worldMat"),
+    1,
+    GL_FALSE,
+    &m_matrix[0][0]);
+
+  glUniform2f(finalShader_.getUniformLocation("resolution"), width_, height_);
+  glUniform1f(finalShader_.getUniformLocation("iGlobalTime"), glfwGetTime());
+
+  glUniform3f(
+    finalShader_.getUniformLocation("frameColor"),
+    0.76f,
+    0.78f,
+    0.81f);
+
+  glEnableVertexAttribArray(0);
+  glBindBuffer(GL_ARRAY_BUFFER, monitor_.getVertexBufferId());
+  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+  glEnableVertexAttribArray(1);
+  glBindBuffer(GL_ARRAY_BUFFER, monitor_.getNormalBufferId());
+  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+  glEnableVertexAttribArray(2);
+  glBindBuffer(GL_ARRAY_BUFFER, monitor_.getUvBufferId());
+  glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, monitor_.getIndexBufferId());
+  glDrawElements(
+    GL_TRIANGLES,
+    monitor_.getIndexCount(),
+    GL_UNSIGNED_SHORT,
+    nullptr);
+
+  glDisableVertexAttribArray(2);
+  glDisableVertexAttribArray(1);
+  glDisableVertexAttribArray(0);
+
+  // First pass of bloom!
+  glm::vec2 bufferSize = glm::vec2(width_, height_);
+
+  bloomPass1(
+    preBloomTex_,
+    bloomPassTex1_,
+    true,
+    bufferSize,
+    bufferSize / 4.0f);
+
+  bloomPass1(
+    bloomPassTex1_,
+    bloomPassTex2_,
+    false,
+    bufferSize / 4.0f,
+    bufferSize / 4.0f);
+
+  // Do the second pass of bloom and render to screen
+  glBindFramebuffer(GL_FRAMEBUFFER, 0);
+  glViewport(0, 0, width_, height_);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  bloom2Shader_.use();
+
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, preBloomTex_.getId());
+  glUniform1i(bloom2Shader_.getUniformLocation("clearTex"), 0);
+
+  glActiveTexture(GL_TEXTURE1);
+  glBindTexture(GL_TEXTURE_2D, bloomPassTex2_.getId());
+  glUniform1i(bloom2Shader_.getUniformLocation("blurTex"), 1);
+
+  glUniform1f(bloom2Shader_.getUniformLocation("iGlobalTime"), glfwGetTime());
+
+  glEnableVertexAttribArray(0);
+  glBindBuffer(GL_ARRAY_BUFFER, quadBuffer_.getId());
+  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+  glDrawArrays(GL_TRIANGLES, 0, 6);
+  glDisableVertexAttribArray(0);
+
+  glfwSwapBuffers(window_.getHandle());
+
+  curBuf_ = (curBuf_ + 1) % 2;
+}
@@ -0,0 +1,114 @@
+#ifndef RENDERER_H
+#define RENDERER_H
+
+#include "gl.h"
+#include "wrappers.h"
+#include "mesh.h"
+#include "shader.h"
+#include <glm/glm.hpp>
+
+class Texture;
+struct Rectangle;
+
+class Renderer {
+public:
+
+  class Window {
+  public:
+
+    Window();
+
+    Window(const Window& other) = delete;
+    Window& operator=(const Window& other) = delete;
+
+    ~Window();
+
+    inline GLFWwindow* getHandle()
+    {
+      return window_;
+    }
+
+  private:
+
+    GLFWwindow* window_;
+  };
+
+  static inline bool isSingletonInitialized()
+  {
+    return singletonInitialized_;
+  }
+
+  Renderer();
+
+  Renderer(const Renderer& other) = delete;
+  Renderer& operator=(const Renderer& other) = delete;
+
+  ~Renderer();
+
+  inline Window& getWindow()
+  {
+    return window_;
+  }
+
+  void fill(
+    Texture& tex,
+    Rectangle loc,
+    int r,
+    int g,
+    int b);
+
+  void blit(
+    const Texture& src,
+    Texture& dst,
+    Rectangle srcrect,
+    Rectangle dstrect,
+    double alpha = 1.0);
+
+  void renderScreen(const Texture& tex);
+
+private:
+
+  friend void setFramebufferSize(GLFWwindow* w, int width, int height);
+
+  void initializeFramebuffers();
+
+  void bloomPass1(
+    const GLTexture& src,
+    GLTexture& dst,
+    bool horizontal,
+    glm::vec2 srcRes,
+    glm::vec2 dstRes);
+
+  static bool singletonInitialized_;
+
+  Window window_;
+  GLVertexArray vao_;
+
+  GLFramebuffer genericFb_;
+  GLFramebuffer bloomFb_;
+  GLRenderbuffer bloomDepth_;
+
+  GLTexture renderPages_[2];
+  GLTexture preBloomTex_;
+  GLTexture bloomPassTex1_;
+  GLTexture bloomPassTex2_;
+
+  Mesh monitor_;
+  GLBuffer quadBuffer_;
+
+  GLTexture artifactsTex_;
+  GLTexture scanlinesTex_;
+
+  Shader ntscShader_;
+  Shader finalShader_;
+  Shader blitShader_;
+  Shader fillShader_;
+  Shader bloom1Shader_;
+  Shader bloom2Shader_;
+
+  size_t curBuf_ = 0;
+  int width_;
+  int height_;
+};
+
+#endif
@@ -0,0 +1,84 @@
+#include "shader.h"
+#include <fstream>
+#include <vector>
+#include "util.h"
+
+Shader::Shader(std::string name)
+{
+  GLShader vertexShader(GL_VERTEX_SHADER);
+  GLShader fragmentShader(GL_FRAGMENT_SHADER);
+
+  std::ifstream vertexFile("shaders/" + name + ".vertex");
+  std::ifstream fragmentFile("shaders/" + name + ".fragment");
+
+  std::string vertexCode(slurp(vertexFile));
+  std::string fragmentCode(slurp(fragmentFile));
+
+  const char* vertexCodePtr = vertexCode.c_str();
+  const char* fragmentCodePtr = fragmentCode.c_str();
+
+  glShaderSource(vertexShader.getId(), 1, &vertexCodePtr, nullptr);
+  glShaderSource(fragmentShader.getId(), 1, &fragmentCodePtr, nullptr);
+
+  glCompileShader(vertexShader.getId());
+  glCompileShader(fragmentShader.getId());
+
+#ifdef DEBUG
+  GLint result = GL_FALSE;
+  int infoLogLength;
+
+  glGetShaderiv(vertexShader.getId(), GL_COMPILE_STATUS, &result);
+
+  if (result == GL_FALSE)
+  {
+    glGetShaderiv(vertexShader.getId(), GL_INFO_LOG_LENGTH, &infoLogLength);
+
+    std::vector<char> errMsg(infoLogLength);
+    glGetShaderInfoLog(
+      vertexShader.getId(),
+      infoLogLength,
+      nullptr,
+      errMsg.data());
+
+    throw std::gl_error("Could not compile shader", errMsg.data());
+  }
+
+  glGetShaderiv(fragmentShader.getId(), GL_COMPILE_STATUS, &result);
+
+  if (result == GL_FALSE)
+  {
+    glGetShaderiv(fragmentShader.getId(), GL_INFO_LOG_LENGTH, &infoLogLength);
+
+    std::vector<char> errMsg(infoLogLength);
+    glGetShaderInfoLog(
+      fragmentShader.getId(),
+      infoLogLength,
+      nullptr,
+      errMsg.data());
+
+    throw std::gl_error("Could not compile shader", errMsg.data());
+  }
+#endif
+
+  glAttachShader(program_.getId(), vertexShader.getId());
+  glAttachShader(program_.getId(), fragmentShader.getId());
+  glLinkProgram(program_.getId());
+
+#ifdef DEBUG
+  glGetProgramiv(program_.getId(), GL_LINK_STATUS, &result);
+
+  if (result == GL_FALSE)
+  {
+    glGetProgramiv(program_.getId(), GL_INFO_LOG_LENGTH, &infoLogLength);
+
+    std::vector<char> errMsg(infoLogLength);
+    glGetProgramInfoLog(
+      program_.getId(),
+      infoLogLength,
+      nullptr,
+      errMsg.data());
+
+    throw std::gl_error("Could not link shader program", errMsg.data());
+  }
+#endif
+}
@@ -0,0 +1,58 @@
+#ifndef SHADER_H_25115B63
+#define SHADER_H_25115B63
+
+#include <string>
+#include <stdexcept>
+#include "gl.h"
+#include "wrappers.h"
+
+class gl_error : public std::logic_error {
+public:
+
+  gl_error(
+    const char* msg,
+    std::string info) :
+      std::logic_error(msg),
+      info_(std::move(info))
+  {
+  }
+
+  gl_error(
+    std::string& msg,
+    std::string info) :
+      std::logic_error(msg),
+      info_(std::move(info))
+  {
+  }
+
+  inline const std::string& getInfo() const
+  {
+    return info_;
+  }
+
+private:
+
+  std::string info_;
+};
+
+class Shader {
+public:
+
+  Shader(std::string name);
+
+  inline void use()
+  {
+    glUseProgram(program_.getId());
+  }
+
+  inline GLint getUniformLocation(const GLchar* name)
+  {
+    return glGetUniformLocation(program_.getId(), name);
+  }
+
+private:
+
+  GLProgram program_;
+};
+
+#endif /* end of include guard: SHADER_H_25115B63 */
@@ -0,0 +1,120 @@
+#include "texture.h"
+#include <stdexcept>
+#include <stb_image.h>
+#include "renderer.h"
+#include "util.h"
+
+Texture::Texture(
+  int width,
+  int height) :
+    width_(width),
+    height_(height)
+{
+  if (!Renderer::isSingletonInitialized())
+  {
+    throw std::logic_error("Renderer needs to be initialized");
+  }
+
+  glBindTexture(GL_TEXTURE_2D, texture_.getId());
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGBA,
+    width_,
+    height_,
+    0,
+    GL_RGBA,
+    GL_UNSIGNED_BYTE,
+    0);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+}
+
+Texture::Texture(const char* filename)
+{
+  if (!Renderer::isSingletonInitialized())
+  {
+    throw std::logic_error("Renderer needs to be initialized");
+  }
+
+  glBindTexture(GL_TEXTURE_2D, texture_.getId());
+  unsigned char* data = stbi_load(filename, &width_, &height_, 0, 4);
+  flipImageData(data, width_, height_, 4);
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGBA,
+    width_,
+    height_,
+    0,
+    GL_RGBA,
+    GL_UNSIGNED_BYTE,
+    data);
+
+  stbi_image_free(data);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+}
+
+Texture::Texture(
+  const Texture& tex) :
+    width_(tex.width_),
+    height_(tex.height_)
+{
+  if (!Renderer::isSingletonInitialized())
+  {
+    throw std::logic_error("Renderer needs to be initialized");
+  }
+
+  unsigned char* data = new unsigned char[4 * width_ * height_];
+  glBindTexture(GL_TEXTURE_2D, tex.getId());
+  glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
+
+  glBindTexture(GL_TEXTURE_2D, texture_.getId());
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGBA,
+    width_,
+    height_,
+    0,
+    GL_RGBA,
+    GL_UNSIGNED_BYTE,
+    data);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+
+  delete[] data;
+}
+
+Texture::Texture(Texture&& tex) : Texture(0, 0)
+{
+  swap(*this, tex);
+}
+
+Texture& Texture::operator= (Texture tex)
+{
+  swap(*this, tex);
+
+  return *this;
+}
+
+void swap(Texture& tex1, Texture& tex2)
+{
+  std::swap(tex1.width_, tex2.width_);
+  std::swap(tex1.height_, tex2.height_);
+  std::swap(tex1.texture_, tex2.texture_);
+}
+
+Rectangle Texture::entirety() const
+{
+  return {0, 0, width_, height_};
+}
@@ -0,0 +1,52 @@
+#ifndef TEXTURE_H_84EC6DF6
+#define TEXTURE_H_84EC6DF6
+
+#include "wrappers.h"
+
+struct Rectangle {
+  int x;
+  int y;
+  int w;
+  int h;
+};
+
+class Texture {
+public:
+
+  Texture(int width, int height);
+
+  Texture(const char* file);
+
+  Texture(const Texture& tex);
+
+  Texture(Texture&& tex);
+
+  Texture& operator= (Texture tex);
+
+  friend void swap(Texture& tex1, Texture& tex2);
+
+  Rectangle entirety() const;
+
+  inline GLuint getId() const
+  {
+    return texture_.getId();
+  }
+
+  inline int getWidth() const
+  {
+    return width_;
+  }
+
+  inline int getHeight() const
+  {
+    return height_;
+  }
+
+private:
+
+  GLTexture texture_;
+  int width_;
+  int height_;
+};
+
+#endif /* end of include guard: TEXTURE_H_84EC6DF6 */
@@ -0,0 +1,273 @@
+#ifndef WRAPPERS_H_1EE0965B
+#define WRAPPERS_H_1EE0965B
+
+#include "gl.h"
+#include <utility>
+
+class GLVertexArray {
+public:
+
+  GLVertexArray()
+  {
+    glGenVertexArrays(1, &id_);
+  }
+
+  GLVertexArray(const GLVertexArray& other) = delete;
+  GLVertexArray& operator=(const GLVertexArray& other) = delete;
+
+  GLVertexArray(GLVertexArray&& other) : GLVertexArray()
+  {
+    std::swap(id_, other.id_);
+  }
+
+  GLVertexArray& operator=(GLVertexArray&& other)
+  {
+    std::swap(id_, other.id_);
+
+    return *this;
+  }
+
+  ~GLVertexArray()
+  {
+    glDeleteVertexArrays(1, &id_);
+  }
+
+  inline GLuint getId() const
+  {
+    return id_;
+  }
+
+private:
+
+  GLuint id_;
+};
+
+class GLFramebuffer {
+public:
+
+  GLFramebuffer()
+  {
+    glGenFramebuffers(1, &id_);
+  }
+
+  GLFramebuffer(const GLFramebuffer& other) = delete;
+  GLFramebuffer& operator=(const GLFramebuffer& other) = delete;
+
+  GLFramebuffer(GLFramebuffer&& other) : GLFramebuffer()
+  {
+    std::swap(id_, other.id_);
+  }
+
+  GLFramebuffer& operator=(GLFramebuffer&& other)
+  {
+    std::swap(id_, other.id_);
+
+    return *this;
+  }
+
+  ~GLFramebuffer()
+  {
+    glDeleteFramebuffers(1, &id_);
+  }
+
+  inline GLuint getId() const
+  {
+    return id_;
+  }
+
+private:
+
+  GLuint id_;
+};
+
+class GLRenderbuffer {
+public:
+
+  GLRenderbuffer()
+  {
+    glGenRenderbuffers(1, &id_);
+  }
+
+  GLRenderbuffer(const GLRenderbuffer& other) = delete;
+  GLRenderbuffer& operator=(const GLRenderbuffer& other) = delete;
+
+  GLRenderbuffer(GLRenderbuffer&& other) : GLRenderbuffer()
+  {
+    std::swap(id_, other.id_);
+  }
+
+  GLRenderbuffer& operator=(GLRenderbuffer&& other)
+  {
+    std::swap(id_, other.id_);
+
+    return *this;
+  }
+
+  ~GLRenderbuffer()
+  {
+    glDeleteRenderbuffers(1, &id_);
+  }
+
+  inline GLuint getId() const
+  {
+    return id_;
+  }
+
+private:
+
+  GLuint id_;
+};
+
+class GLBuffer {
+public:
+
+  GLBuffer()
+  {
+    glGenBuffers(1, &id_);
+  }
+
+  GLBuffer(const GLBuffer& other) = delete;
+  GLBuffer& operator=(const GLBuffer& other) = delete;
+
+  GLBuffer(GLBuffer&& other) : GLBuffer()
+  {
+    std::swap(id_, other.id_);
+  }
+
+  GLBuffer& operator=(GLBuffer&& other)
+  {
+    std::swap(id_, other.id_);
+
+    return *this;
+  }
+
+  ~GLBuffer()
+  {
+    glDeleteBuffers(1, &id_);
+  }
+
+  inline GLuint getId() const
+  {
+    return id_;
+  }
+
+private:
+
+  GLuint id_;
+};
+
+class GLTexture {
+public:
+
+  GLTexture()
+  {
+    glGenTextures(1, &id_);
+  }
+
+  GLTexture(const GLTexture& other) = delete;
+  GLTexture& operator=(const GLTexture& other) = delete;
+
+  GLTexture(GLTexture&& other) : GLTexture()
+  {
+    std::swap(id_, other.id_);
+  }
+
+  GLTexture& operator=(GLTexture&& other)
+  {
+    std::swap(id_, other.id_);
+
+    return *this;
+  }
+
+  ~GLTexture()
+  {
+    glDeleteTextures(1, &id_);
+  }
+
+  inline GLuint getId() const
+  {
+    return id_;
+  }
+
+private:
+
+  GLuint id_;
+};
+
+class GLShader {
+public:
+
+  GLShader(GLenum type)
+  {
+    id_ = glCreateShader(type);
+  }
+
+  GLShader(const GLShader& other) = delete;
+  GLShader& operator=(const GLShader& other) = delete;
+
+  GLShader(GLShader&& other) : GLShader(GL_VERTEX_SHADER)
+  {
+    std::swap(id_, other.id_);
+  }
+
+  GLShader& operator=(GLShader&& other)
+  {
+    std::swap(id_, other.id_);
+
+    return *this;
+  }
+
+  ~GLShader()
+  {
+    glDeleteShader(id_);
+  }
+
+  inline GLuint getId() const
+  {
+    return id_;
+  }
+
+private:
+
+  GLuint id_;
+};
+
+class GLProgram {
+public:
+
+  GLProgram()
+  {
+    id_ = glCreateProgram();
+  }
+
+  GLProgram(const GLProgram& other) = delete;
+  GLProgram& operator=(const GLProgram& other) = delete;
+
+  GLProgram(GLProgram&& other) : GLProgram()
+  {
+    std::swap(id_, other.id_);
+  }
+
+  GLProgram& operator=(GLProgram&& other)
+  {
+    std::swap(id_, other.id_);
+
+    return *this;
+  }
+
+  ~GLProgram()
+  {
+    glDeleteProgram(id_);
+  }
+
+  inline GLuint getId() const
+  {
+    return id_;
+  }
+
+private:
+
+  GLuint id_;
+};
+
+#endif /* end of include guard: WRAPPERS_H_1EE0965B */
@@ -1,6326 +0,0 @@
-/* stb_image - v2.02 - public domain image loader - http://nothings.org/stb_image.h
-                                     no warranty implied; use at your own risk
-
-   Do this:
-      #define STB_IMAGE_IMPLEMENTATION
-   before you include this file in *one* C or C++ file to create the implementation.
-
-   // i.e. it should look like this:
-   #include ...
-   #include ...
-   #include ...
-   #define STB_IMAGE_IMPLEMENTATION
-   #include "stb_image.h"
-
-   You can #define STBI_ASSERT(x) before the #include to avoid using assert.h.
-   And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free
-
-
-   QUICK NOTES:
-      Primarily of interest to game developers and other people who can
-          avoid problematic images and only need the trivial interface
-
-      JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib)
-      PNG 1/2/4/8-bit-per-channel (16 bpc not supported)
-
-      TGA (not sure what subset, if a subset)
-      BMP non-1bpp, non-RLE
-      PSD (composited view only, no extra channels)
-
-      GIF (*comp always reports as 4-channel)
-      HDR (radiance rgbE format)
-      PIC (Softimage PIC)
-      PNM (PPM and PGM binary only)
-
-      - decode from memory or through FILE (define STBI_NO_STDIO to remove code)
-      - decode from arbitrary I/O callbacks
-      - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON)
-
-   Full documentation under "DOCUMENTATION" below.
-
-
-   Revision 2.00 release notes:
-
-      - Progressive JPEG is now supported.
-
-      - PPM and PGM binary formats are now supported, thanks to Ken Miller.
-
-      - x86 platforms now make use of SSE2 SIMD instructions for
-        JPEG decoding, and ARM platforms can use NEON SIMD if requested.
-        This work was done by Fabian "ryg" Giesen. SSE2 is used by
-        default, but NEON must be enabled explicitly; see docs.
-
-        With other JPEG optimizations included in this version, we see
-        2x speedup on a JPEG on an x86 machine, and a 1.5x speedup
-        on a JPEG on an ARM machine, relative to previous versions of this
-        library. The same results will not obtain for all JPGs and for all
-        x86/ARM machines. (Note that progressive JPEGs are significantly
-        slower to decode than regular JPEGs.) This doesn't mean that this
-        is the fastest JPEG decoder in the land; rather, it brings it
-        closer to parity with standard libraries. If you want the fastest
-        decode, look elsewhere. (See "Philosophy" section of docs below.)
-
-        See final bullet items below for more info on SIMD.
-
-      - Added STBI_MALLOC, STBI_REALLOC, and STBI_FREE macros for replacing
-        the memory allocator. Unlike other STBI libraries, these macros don't
-        support a context parameter, so if you need to pass a context in to
-        the allocator, you'll have to store it in a global or a thread-local
-        variable.
-
-      - Split existing STBI_NO_HDR flag into two flags, STBI_NO_HDR and
-        STBI_NO_LINEAR.
-            STBI_NO_HDR:     suppress implementation of .hdr reader format
-            STBI_NO_LINEAR:  suppress high-dynamic-range light-linear float API
-
-      - You can suppress implementation of any of the decoders to reduce
-        your code footprint by #defining one or more of the following
-        symbols before creating the implementation.
-
-            STBI_NO_JPEG
-            STBI_NO_PNG
-            STBI_NO_BMP
-            STBI_NO_PSD
-            STBI_NO_TGA
-            STBI_NO_GIF
-            STBI_NO_HDR
-            STBI_NO_PIC
-            STBI_NO_PNM   (.ppm and .pgm)
-
-      - You can request *only* certain decoders and suppress all other ones
-        (this will be more forward-compatible, as addition of new decoders
-        doesn't require you to disable them explicitly):
-
-            STBI_ONLY_JPEG
-            STBI_ONLY_PNG
-            STBI_ONLY_BMP
-            STBI_ONLY_PSD
-            STBI_ONLY_TGA
-            STBI_ONLY_GIF
-            STBI_ONLY_HDR
-            STBI_ONLY_PIC
-            STBI_ONLY_PNM   (.ppm and .pgm)
-
-         Note that you can define multiples of these, and you will get all
-         of them ("only x" and "only y" is interpreted to mean "only x&y").
-
-       - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still
-         want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB
-
-      - Compilation of all SIMD code can be suppressed with
-            #define STBI_NO_SIMD
-        It should not be necessary to disable SIMD unless you have issues
-        compiling (e.g. using an x86 compiler which doesn't support SSE
-        intrinsics or that doesn't support the method used to detect
-        SSE2 support at run-time), and even those can be reported as
-        bugs so I can refine the built-in compile-time checking to be
-        smarter.
-
-      - The old STBI_SIMD system which allowed installing a user-defined
-        IDCT etc. has been removed. If you need this, don't upgrade. My
-        assumption is that almost nobody was doing this, and those who
-        were will find the built-in SIMD more satisfactory anyway.
-
-      - RGB values computed for JPEG images are slightly different from
-        previous versions of stb_image. (This is due to using less
-        integer precision in SIMD.) The C code has been adjusted so
-        that the same RGB values will be computed regardless of whether
-        SIMD support is available, so your app should always produce
-        consistent results. But these results are slightly different from
-        previous versions. (Specifically, about 3% of available YCbCr values
-        will compute different RGB results from pre-1.49 versions by +-1;
-        most of the deviating values are one smaller in the G channel.)
-
-      - If you must produce consistent results with previous versions of
-        stb_image, #define STBI_JPEG_OLD and you will get the same results
-        you used to; however, you will not get the SIMD speedups for
-        the YCbCr-to-RGB conversion step (although you should still see
-        significant JPEG speedup from the other changes).
-
-        Please note that STBI_JPEG_OLD is a temporary feature; it will be
-        removed in future versions of the library. It is only intended for
-        near-term back-compatibility use.
-
-
-   Latest revision history:
-      2.02  (2015-01-19) fix incorrect assert, fix warning
-      2.01  (2015-01-17) fix various warnings
-      2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG
-      2.00  (2014-12-25) optimize JPEG, including x86 SSE2 & ARM NEON SIMD
-                         progressive JPEG
-                         PGM/PPM support
-                         STBI_MALLOC,STBI_REALLOC,STBI_FREE
-                         STBI_NO_*, STBI_ONLY_*
-                         GIF bugfix
-      1.48  (2014-12-14) fix incorrectly-named assert()
-      1.47  (2014-12-14) 1/2/4-bit PNG support (both grayscale and paletted)
-                         optimize PNG
-                         fix bug in interlaced PNG with user-specified channel count
-      1.46  (2014-08-26) fix broken tRNS chunk in non-paletted PNG
-      1.45  (2014-08-16) workaround MSVC-ARM internal compiler error by wrapping malloc
-
-   See end of file for full revision history.
-
-
- ============================    Contributors    =========================
-
- Image formats                                Bug fixes & warning fixes
-    Sean Barrett (jpeg, png, bmp)                Marc LeBlanc
-    Nicolas Schulz (hdr, psd)                    Christpher Lloyd
-    Jonathan Dummer (tga)                        Dave Moore
-    Jean-Marc Lienher (gif)                      Won Chun
-    Tom Seddon (pic)                             the Horde3D community
-    Thatcher Ulrich (psd)                        Janez Zemva
-    Ken Miller (pgm, ppm)                        Jonathan Blow
-                                                 Laurent Gomila
-                                                 Aruelien Pocheville
- Extensions, features                            Ryamond Barbiero
-    Jetro Lauha (stbi_info)                      David Woo
-    Martin "SpartanJ" Golini (stbi_info)         Martin Golini
-    James "moose2000" Brown (iPhone PNG)         Roy Eltham
-    Ben "Disch" Wenger (io callbacks)            Luke Graham
-    Omar Cornut (1/2/4-bit PNG)                  Thomas Ruf
-                                                 John Bartholomew
-                                                 Ken Hamada
- Optimizations & bugfixes                        Cort Stratton
-    Fabian "ryg" Giesen                          Blazej Dariusz Roszkowski
-    Arseny Kapoulkine                            Thibault Reuille
-                                                 Paul Du Bois
-                                                 Guillaume George
-  If your name should be here but                Jerry Jansson
-  isn't, let Sean know.                          Hayaki Saito
-                                                 Johan Duparc
-                                                 Ronny Chevalier
-                                                 Michal Cichon
-                                                 Tero Hanninen
-                                                 Sergio Gonzalez
-                                                 Cass Everitt
-                                                 Engin Manap
-
-License:
-   This software is in the public domain. Where that dedication is not
-   recognized, you are granted a perpetual, irrevocable license to copy
-   and modify this file however you want.
-
-*/
-
-#ifndef STBI_INCLUDE_STB_IMAGE_H
-#define STBI_INCLUDE_STB_IMAGE_H
-
-// DOCUMENTATION
-//
-// Limitations:
-//    - no 16-bit-per-channel PNG
-//    - no 12-bit-per-channel JPEG
-//    - no JPEGs with arithmetic coding
-//    - no 1-bit BMP
-//    - GIF always returns *comp=4
-//
-// Basic usage (see HDR discussion below for HDR usage):
-//    int x,y,n;
-//    unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
-//    // ... process data if not NULL ...
-//    // ... x = width, y = height, n = # 8-bit components per pixel ...
-//    // ... replace '0' with '1'..'4' to force that many components per pixel
-//    // ... but 'n' will always be the number that it would have been if you said 0
-//    stbi_image_free(data)
-//
-// Standard parameters:
-//    int *x       -- outputs image width in pixels
-//    int *y       -- outputs image height in pixels
-//    int *comp    -- outputs # of image components in image file
-//    int req_comp -- if non-zero, # of image components requested in result
-//
-// The return value from an image loader is an 'unsigned char *' which points
-// to the pixel data, or NULL on an allocation failure or if the image is
-// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels,
-// with each pixel consisting of N interleaved 8-bit components; the first
-// pixel pointed to is top-left-most in the image. There is no padding between
-// image scanlines or between pixels, regardless of format. The number of
-// components N is 'req_comp' if req_comp is non-zero, or *comp otherwise.
-// If req_comp is non-zero, *comp has the number of components that _would_
-// have been output otherwise. E.g. if you set req_comp to 4, you will always
-// get RGBA output, but you can check *comp to see if it's trivially opaque
-// because e.g. there were only 3 channels in the source image.
-//
-// An output image with N components has the following components interleaved
-// in this order in each pixel:
-//
-//     N=#comp     components
-//       1           grey
-//       2           grey, alpha
-//       3           red, green, blue
-//       4           red, green, blue, alpha
-//
-// If image loading fails for any reason, the return value will be NULL,
-// and *x, *y, *comp will be unchanged. The function stbi_failure_reason()
-// can be queried for an extremely brief, end-user unfriendly explanation
-// of why the load failed. Define STBI_NO_FAILURE_STRINGS to avoid
-// compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
-// more user-friendly ones.
-//
-// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
-//
-// ===========================================================================
-//
-// Philosophy
-//
-// stb libraries are designed with the following priorities:
-//
-//    1. easy to use
-//    2. easy to maintain
-//    3. good performance
-//
-// Sometimes I let "good performance" creep up in priority over "easy to maintain",
-// and for best performance I may provide less-easy-to-use APIs that give higher
-// performance, in addition to the easy to use ones. Nevertheless, it's important
-// to keep in mind that from the standpoint of you, a client of this library,
-// all you care about is #1 and #3, and stb libraries do not emphasize #3 above all.
-//
-// Some secondary priorities arise directly from the first two, some of which
-// make more explicit reasons why performance can't be emphasized.
-//
-//    - Portable ("ease of use")
-//    - Small footprint ("easy to maintain")
-//    - No dependencies ("ease of use")
-//
-// ===========================================================================
-//
-// I/O callbacks
-//
-// I/O callbacks allow you to read from arbitrary sources, like packaged
-// files or some other source. Data read from callbacks are processed
-// through a small internal buffer (currently 128 bytes) to try to reduce
-// overhead.
-//
-// The three functions you must define are "read" (reads some bytes of data),
-// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).
-//
-// ===========================================================================
-//
-// SIMD support
-//
-// The JPEG decoder will try to automatically use SIMD kernels on x86 when
-// supported by the compiler. For ARM Neon support, you must explicitly
-// request it.
-//
-// (The old do-it-yourself SIMD API is no longer supported in the current
-// code.)
-//
-// On x86, SSE2 will automatically be used when available based on a run-time
-// test; if not, the generic C versions are used as a fall-back. On ARM targets,
-// the typical path is to have separate builds for NEON and non-NEON devices
-// (at least this is true for iOS and Android). Therefore, the NEON support is
-// toggled by a build flag: define STBI_NEON to get NEON loops.
-//
-// The output of the JPEG decoder is slightly different from versions where
-// SIMD support was introduced (that is, for versions before 1.49). The
-// difference is only +-1 in the 8-bit RGB channels, and only on a small
-// fraction of pixels. You can force the pre-1.49 behavior by defining
-// STBI_JPEG_OLD, but this will disable some of the SIMD decoding path
-// and hence cost some performance.
-//
-// If for some reason you do not want to use any of SIMD code, or if
-// you have issues compiling it, you can disable it entirely by
-// defining STBI_NO_SIMD.
-//
-// ===========================================================================
-//
-// HDR image support   (disable by defining STBI_NO_HDR)
-//
-// stb_image now supports loading HDR images in general, and currently
-// the Radiance .HDR file format, although the support is provided
-// generically. You can still load any file through the existing interface;
-// if you attempt to load an HDR file, it will be automatically remapped to
-// LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
-// both of these constants can be reconfigured through this interface:
-//
-//     stbi_hdr_to_ldr_gamma(2.2f);
-//     stbi_hdr_to_ldr_scale(1.0f);
-//
-// (note, do not use _inverse_ constants; stbi_image will invert them
-// appropriately).
-//
-// Additionally, there is a new, parallel interface for loading files as
-// (linear) floats to preserve the full dynamic range:
-//
-//    float *data = stbi_loadf(filename, &x, &y, &n, 0);
-//
-// If you load LDR images through this interface, those images will
-// be promoted to floating point values, run through the inverse of
-// constants corresponding to the above:
-//
-//     stbi_ldr_to_hdr_scale(1.0f);
-//     stbi_ldr_to_hdr_gamma(2.2f);
-//
-// Finally, given a filename (or an open file or memory block--see header
-// file for details) containing image data, you can query for the "most
-// appropriate" interface to use (that is, whether the image is HDR or
-// not), using:
-//
-//     stbi_is_hdr(char *filename);
-//
-// ===========================================================================
-//
-// iPhone PNG support:
-//
-// By default we convert iphone-formatted PNGs back to RGB, even though
-// they are internally encoded differently. You can disable this conversion
-// by by calling stbi_convert_iphone_png_to_rgb(0), in which case
-// you will always just get the native iphone "format" through (which
-// is BGR stored in RGB).
-//
-// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per
-// pixel to remove any premultiplied alpha *only* if the image file explicitly
-// says there's premultiplied data (currently only happens in iPhone images,
-// and only if iPhone convert-to-rgb processing is on).
-//
-
-
-#ifndef STBI_NO_STDIO
-#include <stdio.h>
-#endif // STBI_NO_STDIO
-
-#define STBI_VERSION 1
-
-enum
-{
-   STBI_default = 0, // only used for req_comp
-
-   STBI_grey       = 1,
-   STBI_grey_alpha = 2,
-   STBI_rgb        = 3,
-   STBI_rgb_alpha  = 4
-};
-
-typedef unsigned char stbi_uc;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef STB_IMAGE_STATIC
-#define STBIDEF static
-#else
-#define STBIDEF extern
-#endif
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// PRIMARY API - works on images of any type
-//
-
-//
-// load image by filename, open file, or memory buffer
-//
-
-typedef struct
-{
-   int      (*read)  (void *user,char *data,int size);   // fill 'data' with 'size' bytes.  return number of bytes actually read
-   void     (*skip)  (void *user,int n);                 // skip the next 'n' bytes, or 'unget' the last -n bytes if negative
-   int      (*eof)   (void *user);                       // returns nonzero if we are at end of file/data
-} stbi_io_callbacks;
-
-STBIDEF stbi_uc *stbi_load               (char              const *filename,           int *x, int *y, int *comp, int req_comp);
-STBIDEF stbi_uc *stbi_load_from_memory   (stbi_uc           const *buffer, int len   , int *x, int *y, int *comp, int req_comp);
-STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk  , void *user, int *x, int *y, int *comp, int req_comp);
-
-#ifndef STBI_NO_STDIO
-STBIDEF stbi_uc *stbi_load_from_file  (FILE *f,                  int *x, int *y, int *comp, int req_comp);
-// for stbi_load_from_file, file pointer is left pointing immediately after image
-#endif
-
-#ifndef STBI_NO_LINEAR
-   STBIDEF float *stbi_loadf                 (char const *filename,           int *x, int *y, int *comp, int req_comp);
-   STBIDEF float *stbi_loadf_from_memory     (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
-   STBIDEF float *stbi_loadf_from_callbacks  (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp);
-
-   #ifndef STBI_NO_STDIO
-   STBIDEF float *stbi_loadf_from_file  (FILE *f,                int *x, int *y, int *comp, int req_comp);
-   #endif
-#endif
-
-#ifndef STBI_NO_HDR
-   STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma);
-   STBIDEF void   stbi_hdr_to_ldr_scale(float scale);
-#endif
-
-#ifndef STBI_NO_LINEAR
-   STBIDEF void   stbi_ldr_to_hdr_gamma(float gamma);
-   STBIDEF void   stbi_ldr_to_hdr_scale(float scale);
-#endif // STBI_NO_HDR
-
-// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR
-STBIDEF int    stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);
-STBIDEF int    stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
-#ifndef STBI_NO_STDIO
-STBIDEF int      stbi_is_hdr          (char const *filename);
-STBIDEF int      stbi_is_hdr_from_file(FILE *f);
-#endif // STBI_NO_STDIO
-
-
-// get a VERY brief reason for failure
-// NOT THREADSAFE
-STBIDEF const char *stbi_failure_reason  (void);
-
-// free the loaded image -- this is just free()
-STBIDEF void     stbi_image_free      (void *retval_from_stbi_load);
-
-// get image dimensions & components without fully decoding
-STBIDEF int      stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
-STBIDEF int      stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);
-
-#ifndef STBI_NO_STDIO
-STBIDEF int      stbi_info            (char const *filename,     int *x, int *y, int *comp);
-STBIDEF int      stbi_info_from_file  (FILE *f,                  int *x, int *y, int *comp);
-
-#endif
-
-
-
-// for image formats that explicitly notate that they have premultiplied alpha,
-// we just return the colors as stored in the file. set this flag to force
-// unpremultiplication. results are undefined if the unpremultiply overflow.
-STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);
-
-// indicate whether we should process iphone images back to canonical format,
-// or just pass them through "as-is"
-STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);
-
-
-// ZLIB client - used by PNG, available for other purposes
-
-STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
-STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header);
-STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
-STBIDEF int   stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
-
-STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
-STBIDEF int   stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
-
-
-#ifdef __cplusplus
-}
-#endif
-
-//
-//
-////   end header file   /////////////////////////////////////////////////////
-#endif // STBI_INCLUDE_STB_IMAGE_H
-
-#ifdef STB_IMAGE_IMPLEMENTATION
-
-#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \
-  || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \
-  || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \
-  || defined(STBI_ONLY_ZLIB)
-   #ifndef STBI_ONLY_JPEG
-   #define STBI_NO_JPEG
-   #endif
-   #ifndef STBI_ONLY_PNG
-   #define STBI_NO_PNG
-   #endif
-   #ifndef STBI_ONLY_BMP
-   #define STBI_NO_BMP
-   #endif
-   #ifndef STBI_ONLY_PSD
-   #define STBI_NO_PSD
-   #endif
-   #ifndef STBI_ONLY_TGA
-   #define STBI_NO_TGA
-   #endif
-   #ifndef STBI_ONLY_GIF
-   #define STBI_NO_GIF
-   #endif
-   #ifndef STBI_ONLY_HDR
-   #define STBI_NO_HDR
-   #endif
-   #ifndef STBI_ONLY_PIC
-   #define STBI_NO_PIC
-   #endif
-   #ifndef STBI_ONLY_PNM
-   #define STBI_NO_PNM
-   #endif
-#endif
-
-#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)
-#define STBI_NO_ZLIB
-#endif
-
-
-#include <stdarg.h>
-#include <stddef.h> // ptrdiff_t on osx
-#include <stdlib.h>
-#include <string.h>
-
-#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
-#include <math.h>  // ldexp
-#endif
-
-#ifndef STBI_NO_STDIO
-#include <stdio.h>
-#endif
-
-#ifndef STBI_ASSERT
-#include <assert.h>
-#define STBI_ASSERT(x) assert(x)
-#endif
-
-
-#ifndef _MSC_VER
-   #ifdef __cplusplus
-   #define stbi_inline inline
-   #else
-   #define stbi_inline
-   #endif
-#else
-   #define stbi_inline __forceinline
-#endif
-
-
-#ifdef _MSC_VER
-typedef unsigned short stbi__uint16;
-typedef   signed short stbi__int16;
-typedef unsigned int   stbi__uint32;
-typedef   signed int   stbi__int32;
-#else
-#include <stdint.h>
-typedef uint16_t stbi__uint16;
-typedef int16_t  stbi__int16;
-typedef uint32_t stbi__uint32;
-typedef int32_t  stbi__int32;
-#endif
-
-// should produce compiler error if size is wrong
-typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
-
-#ifdef _MSC_VER
-#define STBI_NOTUSED(v)  (void)(v)
-#else
-#define STBI_NOTUSED(v)  (void)sizeof(v)
-#endif
-
-#ifdef _MSC_VER
-#define STBI_HAS_LROTL
-#endif
-
-#ifdef STBI_HAS_LROTL
-   #define stbi_lrot(x,y)  _lrotl(x,y)
-#else
-   #define stbi_lrot(x,y)  (((x) << (y)) | ((x) >> (32 - (y))))
-#endif
-
-#if defined(STBI_MALLOC) && defined(STBI_FREE) && defined(STBI_REALLOC)
-// ok
-#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC)
-// ok
-#else
-#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC."
-#endif
-
-#ifndef STBI_MALLOC
-#define STBI_MALLOC(sz)    malloc(sz)
-#define STBI_REALLOC(p,sz) realloc(p,sz)
-#define STBI_FREE(p)       free(p)
-#endif
-
-#if defined(__GNUC__) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)
-// gcc doesn't support sse2 intrinsics unless you compile with -msse2,
-// (but compiling with -msse2 allows the compiler to use SSE2 everywhere;
-// this is just broken and gcc are jerks for not fixing it properly
-// http://www.virtualdub.org/blog/pivot/entry.php?id=363 )
-#define STBI_NO_SIMD
-#endif
-
-#if !defined(STBI_NO_SIMD) && (defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86))
-#define STBI_SSE2
-#include <emmintrin.h>
-
-#ifdef _MSC_VER
-
-#if _MSC_VER >= 1400  // not VC6
-#include <intrin.h> // __cpuid
-static int stbi__cpuid3(void)
-{
-   int info[4];
-   __cpuid(info,1);
-   return info[3];
-}
-#else
-static int stbi__cpuid3(void)
-{
-   int res;
-   __asm {
-      mov  eax,1
-      cpuid
-      mov  res,edx
-   }
-   return res;
-}
-#endif
-
-#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
-
-static int stbi__sse2_available()
-{
-   int info3 = stbi__cpuid3();
-   return ((info3 >> 26) & 1) != 0;
-}
-#else // assume GCC-style if not VC++
-#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
-
-static int stbi__sse2_available()
-{
-#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 408 // GCC 4.8 or later
-   // GCC 4.8+ has a nice way to do this
-   return __builtin_cpu_supports("sse2");
-#else
-   // portable way to do this, preferably without using GCC inline ASM?
-   // just bail for now.
-   return 0;
-#endif
-}
-#endif
-#endif
-
-// ARM NEON
-#if defined(STBI_NO_SIMD) && defined(STBI_NEON)
-#undef STBI_NEON
-#endif
-
-#ifdef STBI_NEON
-#include <arm_neon.h>
-// assume GCC or Clang on ARM targets
-#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
-#endif
-
-#ifndef STBI_SIMD_ALIGN
-#define STBI_SIMD_ALIGN(type, name) type name
-#endif
-
-///////////////////////////////////////////////
-//
-//  stbi__context struct and start_xxx functions
-
-// stbi__context structure is our basic context used by all images, so it
-// contains all the IO context, plus some basic image information
-typedef struct
-{
-   stbi__uint32 img_x, img_y;
-   int img_n, img_out_n;
-
-   stbi_io_callbacks io;
-   void *io_user_data;
-
-   int read_from_callbacks;
-   int buflen;
-   stbi_uc buffer_start[128];
-
-   stbi_uc *img_buffer, *img_buffer_end;
-   stbi_uc *img_buffer_original;
-} stbi__context;
-
-
-static void stbi__refill_buffer(stbi__context *s);
-
-// initialize a memory-decode context
-static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)
-{
-   s->io.read = NULL;
-   s->read_from_callbacks = 0;
-   s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer;
-   s->img_buffer_end = (stbi_uc *) buffer+len;
-}
-
-// initialize a callback-based context
-static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)
-{
-   s->io = *c;
-   s->io_user_data = user;
-   s->buflen = sizeof(s->buffer_start);
-   s->read_from_callbacks = 1;
-   s->img_buffer_original = s->buffer_start;
-   stbi__refill_buffer(s);
-}
-
-#ifndef STBI_NO_STDIO
-
-static int stbi__stdio_read(void *user, char *data, int size)
-{
-   return (int) fread(data,1,size,(FILE*) user);
-}
-
-static void stbi__stdio_skip(void *user, int n)
-{
-   fseek((FILE*) user, n, SEEK_CUR);
-}
-
-static int stbi__stdio_eof(void *user)
-{
-   return feof((FILE*) user);
-}
-
-static stbi_io_callbacks stbi__stdio_callbacks =
-{
-   stbi__stdio_read,
-   stbi__stdio_skip,
-   stbi__stdio_eof,
-};
-
-static void stbi__start_file(stbi__context *s, FILE *f)
-{
-   stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f);
-}
-
-//static void stop_file(stbi__context *s) { }
-
-#endif // !STBI_NO_STDIO
-
-static void stbi__rewind(stbi__context *s)
-{
-   // conceptually rewind SHOULD rewind to the beginning of the stream,
-   // but we just rewind to the beginning of the initial buffer, because
-   // we only use it after doing 'test', which only ever looks at at most 92 bytes
-   s->img_buffer = s->img_buffer_original;
-}
-
-#ifndef STBI_NO_JPEG
-static int      stbi__jpeg_test(stbi__context *s);
-static stbi_uc *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
-static int      stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp);
-#endif
-
-#ifndef STBI_NO_PNG
-static int      stbi__png_test(stbi__context *s);
-static stbi_uc *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
-static int      stbi__png_info(stbi__context *s, int *x, int *y, int *comp);
-#endif
-
-#ifndef STBI_NO_BMP
-static int      stbi__bmp_test(stbi__context *s);
-static stbi_uc *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
-static int      stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp);
-#endif
-
-#ifndef STBI_NO_TGA
-static int      stbi__tga_test(stbi__context *s);
-static stbi_uc *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
-static int      stbi__tga_info(stbi__context *s, int *x, int *y, int *comp);
-#endif
-
-#ifndef STBI_NO_PSD
-static int      stbi__psd_test(stbi__context *s);
-static stbi_uc *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
-static int      stbi__psd_info(stbi__context *s, int *x, int *y, int *comp);
-#endif
-
-#ifndef STBI_NO_HDR
-static int      stbi__hdr_test(stbi__context *s);
-static float   *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
-static int      stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp);
-#endif
-
-#ifndef STBI_NO_PIC
-static int      stbi__pic_test(stbi__context *s);
-static stbi_uc *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
-static int      stbi__pic_info(stbi__context *s, int *x, int *y, int *comp);
-#endif
-
-#ifndef STBI_NO_GIF
-static int      stbi__gif_test(stbi__context *s);
-static stbi_uc *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
-static int      stbi__gif_info(stbi__context *s, int *x, int *y, int *comp);
-#endif
-
-#ifndef STBI_NO_PNM
-static int      stbi__pnm_test(stbi__context *s);
-static stbi_uc *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
-static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp);
-#endif
-
-// this is not threadsafe
-static const char *stbi__g_failure_reason;
-
-STBIDEF const char *stbi_failure_reason(void)
-{
-   return stbi__g_failure_reason;
-}
-
-static int stbi__err(const char *str)
-{
-   stbi__g_failure_reason = str;
-   return 0;
-}
-
-static void *stbi__malloc(size_t size)
-{
-    return STBI_MALLOC(size);
-}
-
-// stbi__err - error
-// stbi__errpf - error returning pointer to float
-// stbi__errpuc - error returning pointer to unsigned char
-
-#ifdef STBI_NO_FAILURE_STRINGS
-   #define stbi__err(x,y)  0
-#elif defined(STBI_FAILURE_USERMSG)
-   #define stbi__err(x,y)  stbi__err(y)
-#else
-   #define stbi__err(x,y)  stbi__err(x)
-#endif
-
-#define stbi__errpf(x,y)   ((float *) (stbi__err(x,y)?NULL:NULL))
-#define stbi__errpuc(x,y)  ((unsigned char *) (stbi__err(x,y)?NULL:NULL))
-
-STBIDEF void stbi_image_free(void *retval_from_stbi_load)
-{
-   STBI_FREE(retval_from_stbi_load);
-}
-
-#ifndef STBI_NO_LINEAR
-static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
-#endif
-
-#ifndef STBI_NO_HDR
-static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp);
-#endif
-
-static unsigned char *stbi_load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
-{
-   #ifndef STBI_NO_JPEG
-   if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp);
-   #endif
-   #ifndef STBI_NO_PNG
-   if (stbi__png_test(s))  return stbi__png_load(s,x,y,comp,req_comp);
-   #endif
-   #ifndef STBI_NO_BMP
-   if (stbi__bmp_test(s))  return stbi__bmp_load(s,x,y,comp,req_comp);
-   #endif
-   #ifndef STBI_NO_GIF
-   if (stbi__gif_test(s))  return stbi__gif_load(s,x,y,comp,req_comp);
-   #endif
-   #ifndef STBI_NO_PSD
-   if (stbi__psd_test(s))  return stbi__psd_load(s,x,y,comp,req_comp);
-   #endif
-   #ifndef STBI_NO_PIC
-   if (stbi__pic_test(s))  return stbi__pic_load(s,x,y,comp,req_comp);
-   #endif
-   #ifndef STBI_NO_PNM
-   if (stbi__pnm_test(s))  return stbi__pnm_load(s,x,y,comp,req_comp);
-   #endif
-
-   #ifndef STBI_NO_HDR
-   if (stbi__hdr_test(s)) {
-      float *hdr = stbi__hdr_load(s, x,y,comp,req_comp);
-      return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
-   }
-   #endif
-
-   #ifndef STBI_NO_TGA
-   // test tga last because it's a crappy test!
-   if (stbi__tga_test(s))
-      return stbi__tga_load(s,x,y,comp,req_comp);
-   #endif
-
-   return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt");
-}
-
-#ifndef STBI_NO_STDIO
-
-static FILE *stbi__fopen(char const *filename, char const *mode)
-{
-   FILE *f;
-#if defined(_MSC_VER) && _MSC_VER >= 1400
-   if (0 != fopen_s(&f, filename, mode))
-      f=0;
-#else
-   f = fopen(filename, mode);
-#endif
-   return f;
-}
-
-
-STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
-{
-   FILE *f = stbi__fopen(filename, "rb");
-   unsigned char *result;
-   if (!f) return stbi__errpuc("can't fopen", "Unable to open file");
-   result = stbi_load_from_file(f,x,y,comp,req_comp);
-   fclose(f);
-   return result;
-}
-
-STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   unsigned char *result;
-   stbi__context s;
-   stbi__start_file(&s,f);
-   result = stbi_load_main(&s,x,y,comp,req_comp);
-   if (result) {
-      // need to 'unget' all the characters in the IO buffer
-      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
-   }
-   return result;
-}
-#endif //!STBI_NO_STDIO
-
-STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   stbi__context s;
-   stbi__start_mem(&s,buffer,len);
-   return stbi_load_main(&s,x,y,comp,req_comp);
-}
-
-STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
-{
-   stbi__context s;
-   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
-   return stbi_load_main(&s,x,y,comp,req_comp);
-}
-
-#ifndef STBI_NO_LINEAR
-static float *stbi_loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
-{
-   unsigned char *data;
-   #ifndef STBI_NO_HDR
-   if (stbi__hdr_test(s))
-      return stbi__hdr_load(s,x,y,comp,req_comp);
-   #endif
-   data = stbi_load_main(s, x, y, comp, req_comp);
-   if (data)
-      return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
-   return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");
-}
-
-STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   stbi__context s;
-   stbi__start_mem(&s,buffer,len);
-   return stbi_loadf_main(&s,x,y,comp,req_comp);
-}
-
-STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
-{
-   stbi__context s;
-   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
-   return stbi_loadf_main(&s,x,y,comp,req_comp);
-}
-
-#ifndef STBI_NO_STDIO
-STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
-{
-   float *result;
-   FILE *f = stbi__fopen(filename, "rb");
-   if (!f) return stbi__errpf("can't fopen", "Unable to open file");
-   result = stbi_loadf_from_file(f,x,y,comp,req_comp);
-   fclose(f);
-   return result;
-}
-
-STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   stbi__context s;
-   stbi__start_file(&s,f);
-   return stbi_loadf_main(&s,x,y,comp,req_comp);
-}
-#endif // !STBI_NO_STDIO
-
-#endif // !STBI_NO_LINEAR
-
-// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is
-// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always
-// reports false!
-
-STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
-{
-   #ifndef STBI_NO_HDR
-   stbi__context s;
-   stbi__start_mem(&s,buffer,len);
-   return stbi__hdr_test(&s);
-   #else
-   STBI_NOTUSED(buffer);
-   STBI_NOTUSED(len);
-   return 0;
-   #endif
-}
-
-#ifndef STBI_NO_STDIO
-STBIDEF int      stbi_is_hdr          (char const *filename)
-{
-   FILE *f = stbi__fopen(filename, "rb");
-   int result=0;
-   if (f) {
-      result = stbi_is_hdr_from_file(f);
-      fclose(f);
-   }
-   return result;
-}
-
-STBIDEF int      stbi_is_hdr_from_file(FILE *f)
-{
-   #ifndef STBI_NO_HDR
-   stbi__context s;
-   stbi__start_file(&s,f);
-   return stbi__hdr_test(&s);
-   #else
-   return 0;
-   #endif
-}
-#endif // !STBI_NO_STDIO
-
-STBIDEF int      stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)
-{
-   #ifndef STBI_NO_HDR
-   stbi__context s;
-   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
-   return stbi__hdr_test(&s);
-   #else
-   return 0;
-   #endif
-}
-
-static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;
-static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;
-
-#ifndef STBI_NO_LINEAR
-STBIDEF void   stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }
-STBIDEF void   stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }
-#endif
-
-STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }
-STBIDEF void   stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// Common code used by all image loaders
-//
-
-enum
-{
-   STBI__SCAN_load=0,
-   STBI__SCAN_type,
-   STBI__SCAN_header
-};
-
-static void stbi__refill_buffer(stbi__context *s)
-{
-   int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
-   if (n == 0) {
-      // at end of file, treat same as if from memory, but need to handle case
-      // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file
-      s->read_from_callbacks = 0;
-      s->img_buffer = s->buffer_start;
-      s->img_buffer_end = s->buffer_start+1;
-      *s->img_buffer = 0;
-   } else {
-      s->img_buffer = s->buffer_start;
-      s->img_buffer_end = s->buffer_start + n;
-   }
-}
-
-stbi_inline static stbi_uc stbi__get8(stbi__context *s)
-{
-   if (s->img_buffer < s->img_buffer_end)
-      return *s->img_buffer++;
-   if (s->read_from_callbacks) {
-      stbi__refill_buffer(s);
-      return *s->img_buffer++;
-   }
-   return 0;
-}
-
-stbi_inline static int stbi__at_eof(stbi__context *s)
-{
-   if (s->io.read) {
-      if (!(s->io.eof)(s->io_user_data)) return 0;
-      // if feof() is true, check if buffer = end
-      // special case: we've only got the special 0 character at the end
-      if (s->read_from_callbacks == 0) return 1;
-   }
-
-   return s->img_buffer >= s->img_buffer_end;
-}
-
-static void stbi__skip(stbi__context *s, int n)
-{
-   if (s->io.read) {
-      int blen = (int) (s->img_buffer_end - s->img_buffer);
-      if (blen < n) {
-         s->img_buffer = s->img_buffer_end;
-         (s->io.skip)(s->io_user_data, n - blen);
-         return;
-      }
-   }
-   s->img_buffer += n;
-}
-
-static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
-{
-   if (s->io.read) {
-      int blen = (int) (s->img_buffer_end - s->img_buffer);
-      if (blen < n) {
-         int res, count;
-
-         memcpy(buffer, s->img_buffer, blen);
-
-         count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);
-         res = (count == (n-blen));
-         s->img_buffer = s->img_buffer_end;
-         return res;
-      }
-   }
-
-   if (s->img_buffer+n <= s->img_buffer_end) {
-      memcpy(buffer, s->img_buffer, n);
-      s->img_buffer += n;
-      return 1;
-   } else
-      return 0;
-}
-
-static int stbi__get16be(stbi__context *s)
-{
-   int z = stbi__get8(s);
-   return (z << 8) + stbi__get8(s);
-}
-
-static stbi__uint32 stbi__get32be(stbi__context *s)
-{
-   stbi__uint32 z = stbi__get16be(s);
-   return (z << 16) + stbi__get16be(s);
-}
-
-static int stbi__get16le(stbi__context *s)
-{
-   int z = stbi__get8(s);
-   return z + (stbi__get8(s) << 8);
-}
-
-static stbi__uint32 stbi__get32le(stbi__context *s)
-{
-   stbi__uint32 z = stbi__get16le(s);
-   return z + (stbi__get16le(s) << 16);
-}
-
-#define STBI__BYTECAST(x)  ((stbi_uc) ((x) & 255))  // truncate int to byte without warnings
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-//  generic converter from built-in img_n to req_comp
-//    individual types do this automatically as much as possible (e.g. jpeg
-//    does all cases internally since it needs to colorspace convert anyway,
-//    and it never has alpha, so very few cases ). png can automatically
-//    interleave an alpha=255 channel, but falls back to this for other cases
-//
-//  assume data buffer is malloced, so malloc a new one and free that one
-//  only failure mode is malloc failing
-
-static stbi_uc stbi__compute_y(int r, int g, int b)
-{
-   return (stbi_uc) (((r*77) + (g*150) +  (29*b)) >> 8);
-}
-
-static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
-{
-   int i,j;
-   unsigned char *good;
-
-   if (req_comp == img_n) return data;
-   STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
-
-   good = (unsigned char *) stbi__malloc(req_comp * x * y);
-   if (good == NULL) {
-      STBI_FREE(data);
-      return stbi__errpuc("outofmem", "Out of memory");
-   }
-
-   for (j=0; j < (int) y; ++j) {
-      unsigned char *src  = data + j * x * img_n   ;
-      unsigned char *dest = good + j * x * req_comp;
-
-      #define COMBO(a,b)  ((a)*8+(b))
-      #define CASE(a,b)   case COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
-      // convert source image with img_n components to one with req_comp components;
-      // avoid switch per pixel, so use switch per scanline and massive macros
-      switch (COMBO(img_n, req_comp)) {
-         CASE(1,2) dest[0]=src[0], dest[1]=255; break;
-         CASE(1,3) dest[0]=dest[1]=dest[2]=src[0]; break;
-         CASE(1,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=255; break;
-         CASE(2,1) dest[0]=src[0]; break;
-         CASE(2,3) dest[0]=dest[1]=dest[2]=src[0]; break;
-         CASE(2,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; break;
-         CASE(3,4) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; break;
-         CASE(3,1) dest[0]=stbi__compute_y(src[0],src[1],src[2]); break;
-         CASE(3,2) dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = 255; break;
-         CASE(4,1) dest[0]=stbi__compute_y(src[0],src[1],src[2]); break;
-         CASE(4,2) dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = src[3]; break;
-         CASE(4,3) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; break;
-         default: STBI_ASSERT(0);
-      }
-      #undef CASE
-   }
-
-   STBI_FREE(data);
-   return good;
-}
-
-#ifndef STBI_NO_LINEAR
-static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
-{
-   int i,k,n;
-   float *output = (float *) stbi__malloc(x * y * comp * sizeof(float));
-   if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); }
-   // compute number of non-alpha components
-   if (comp & 1) n = comp; else n = comp-1;
-   for (i=0; i < x*y; ++i) {
-      for (k=0; k < n; ++k) {
-         output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
-      }
-      if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f;
-   }
-   STBI_FREE(data);
-   return output;
-}
-#endif
-
-#ifndef STBI_NO_HDR
-#define stbi__float2int(x)   ((int) (x))
-static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp)
-{
-   int i,k,n;
-   stbi_uc *output = (stbi_uc *) stbi__malloc(x * y * comp);
-   if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); }
-   // compute number of non-alpha components
-   if (comp & 1) n = comp; else n = comp-1;
-   for (i=0; i < x*y; ++i) {
-      for (k=0; k < n; ++k) {
-         float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;
-         if (z < 0) z = 0;
-         if (z > 255) z = 255;
-         output[i*comp + k] = (stbi_uc) stbi__float2int(z);
-      }
-      if (k < comp) {
-         float z = data[i*comp+k] * 255 + 0.5f;
-         if (z < 0) z = 0;
-         if (z > 255) z = 255;
-         output[i*comp + k] = (stbi_uc) stbi__float2int(z);
-      }
-   }
-   STBI_FREE(data);
-   return output;
-}
-#endif
-
-//////////////////////////////////////////////////////////////////////////////
-//
-//  "baseline" JPEG/JFIF decoder
-//
-//    simple implementation
-//      - doesn't support delayed output of y-dimension
-//      - simple interface (only one output format: 8-bit interleaved RGB)
-//      - doesn't try to recover corrupt jpegs
-//      - doesn't allow partial loading, loading multiple at once
-//      - still fast on x86 (copying globals into locals doesn't help x86)
-//      - allocates lots of intermediate memory (full size of all components)
-//        - non-interleaved case requires this anyway
-//        - allows good upsampling (see next)
-//    high-quality
-//      - upsampled channels are bilinearly interpolated, even across blocks
-//      - quality integer IDCT derived from IJG's 'slow'
-//    performance
-//      - fast huffman; reasonable integer IDCT
-//      - some SIMD kernels for common paths on targets with SSE2/NEON
-//      - uses a lot of intermediate memory, could cache poorly
-
-#ifndef STBI_NO_JPEG
-
-// huffman decoding acceleration
-#define FAST_BITS   9  // larger handles more cases; smaller stomps less cache
-
-typedef struct
-{
-   stbi_uc  fast[1 << FAST_BITS];
-   // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
-   stbi__uint16 code[256];
-   stbi_uc  values[256];
-   stbi_uc  size[257];
-   unsigned int maxcode[18];
-   int    delta[17];   // old 'firstsymbol' - old 'firstcode'
-} stbi__huffman;
-
-typedef struct
-{
-   stbi__context *s;
-   stbi__huffman huff_dc[4];
-   stbi__huffman huff_ac[4];
-   stbi_uc dequant[4][64];
-   stbi__int16 fast_ac[4][1 << FAST_BITS];
-
-// sizes for components, interleaved MCUs
-   int img_h_max, img_v_max;
-   int img_mcu_x, img_mcu_y;
-   int img_mcu_w, img_mcu_h;
-
-// definition of jpeg image component
-   struct
-   {
-      int id;
-      int h,v;
-      int tq;
-      int hd,ha;
-      int dc_pred;
-
-      int x,y,w2,h2;
-      stbi_uc *data;
-      void *raw_data, *raw_coeff;
-      stbi_uc *linebuf;
-      short   *coeff;   // progressive only
-      int      coeff_w, coeff_h; // number of 8x8 coefficient blocks
-   } img_comp[4];
-
-   stbi__uint32   code_buffer; // jpeg entropy-coded buffer
-   int            code_bits;   // number of valid bits
-   unsigned char  marker;      // marker seen while filling entropy buffer
-   int            nomore;      // flag if we saw a marker so must stop
-
-   int            progressive;
-   int            spec_start;
-   int            spec_end;
-   int            succ_high;
-   int            succ_low;
-   int            eob_run;
-
-   int scan_n, order[4];
-   int restart_interval, todo;
-
-// kernels
-   void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]);
-   void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step);
-   stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs);
-} stbi__jpeg;
-
-static int stbi__build_huffman(stbi__huffman *h, int *count)
-{
-   int i,j,k=0,code;
-   // build size list for each symbol (from JPEG spec)
-   for (i=0; i < 16; ++i)
-      for (j=0; j < count[i]; ++j)
-         h->size[k++] = (stbi_uc) (i+1);
-   h->size[k] = 0;
-
-   // compute actual symbols (from jpeg spec)
-   code = 0;
-   k = 0;
-   for(j=1; j <= 16; ++j) {
-      // compute delta to add to code to compute symbol id
-      h->delta[j] = k - code;
-      if (h->size[k] == j) {
-         while (h->size[k] == j)
-            h->code[k++] = (stbi__uint16) (code++);
-         if (code-1 >= (1 << j)) return stbi__err("bad code lengths","Corrupt JPEG");
-      }
-      // compute largest code + 1 for this size, preshifted as needed later
-      h->maxcode[j] = code << (16-j);
-      code <<= 1;
-   }
-   h->maxcode[j] = 0xffffffff;
-
-   // build non-spec acceleration table; 255 is flag for not-accelerated
-   memset(h->fast, 255, 1 << FAST_BITS);
-   for (i=0; i < k; ++i) {
-      int s = h->size[i];
-      if (s <= FAST_BITS) {
-         int c = h->code[i] << (FAST_BITS-s);
-         int m = 1 << (FAST_BITS-s);
-         for (j=0; j < m; ++j) {
-            h->fast[c+j] = (stbi_uc) i;
-         }
-      }
-   }
-   return 1;
-}
-
-// build a table that decodes both magnitude and value of small ACs in
-// one go.
-static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)
-{
-   int i;
-   for (i=0; i < (1 << FAST_BITS); ++i) {
-      stbi_uc fast = h->fast[i];
-      fast_ac[i] = 0;
-      if (fast < 255) {
-         int rs = h->values[fast];
-         int run = (rs >> 4) & 15;
-         int magbits = rs & 15;
-         int len = h->size[fast];
-
-         if (magbits && len + magbits <= FAST_BITS) {
-            // magnitude code followed by receive_extend code
-            int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);
-            int m = 1 << (magbits - 1);
-            if (k < m) k += (-1 << magbits) + 1;
-            // if the result is small enough, we can fit it in fast_ac table
-            if (k >= -128 && k <= 127)
-               fast_ac[i] = (stbi__int16) ((k << 8) + (run << 4) + (len + magbits));
-         }
-      }
-   }
-}
-
-static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
-{
-   do {
-      int b = j->nomore ? 0 : stbi__get8(j->s);
-      if (b == 0xff) {
-         int c = stbi__get8(j->s);
-         if (c != 0) {
-            j->marker = (unsigned char) c;
-            j->nomore = 1;
-            return;
-         }
-      }
-      j->code_buffer |= b << (24 - j->code_bits);
-      j->code_bits += 8;
-   } while (j->code_bits <= 24);
-}
-
-// (1 << n) - 1
-static stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
-
-// decode a jpeg huffman value from the bitstream
-stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
-{
-   unsigned int temp;
-   int c,k;
-
-   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
-
-   // look at the top FAST_BITS and determine what symbol ID it is,
-   // if the code is <= FAST_BITS
-   c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
-   k = h->fast[c];
-   if (k < 255) {
-      int s = h->size[k];
-      if (s > j->code_bits)
-         return -1;
-      j->code_buffer <<= s;
-      j->code_bits -= s;
-      return h->values[k];
-   }
-
-   // naive test is to shift the code_buffer down so k bits are
-   // valid, then test against maxcode. To speed this up, we've
-   // preshifted maxcode left so that it has (16-k) 0s at the
-   // end; in other words, regardless of the number of bits, it
-   // wants to be compared against something shifted to have 16;
-   // that way we don't need to shift inside the loop.
-   temp = j->code_buffer >> 16;
-   for (k=FAST_BITS+1 ; ; ++k)
-      if (temp < h->maxcode[k])
-         break;
-   if (k == 17) {
-      // error! code not found
-      j->code_bits -= 16;
-      return -1;
-   }
-
-   if (k > j->code_bits)
-      return -1;
-
-   // convert the huffman code to the symbol id
-   c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];
-   STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);
-
-   // convert the id to a symbol
-   j->code_bits -= k;
-   j->code_buffer <<= k;
-   return h->values[c];
-}
-
-// bias[n] = (-1<<n) + 1
-static int const stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};
-
-// combined JPEG 'receive' and JPEG 'extend', since baseline
-// always extends everything it receives.
-stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
-{
-   unsigned int k;
-   int sgn;
-   if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
-
-   sgn = (stbi__int32)j->code_buffer >> 31; // sign bit is always in MSB
-   k = stbi_lrot(j->code_buffer, n);
-   j->code_buffer = k & ~stbi__bmask[n];
-   k &= stbi__bmask[n];
-   j->code_bits -= n;
-   return k + (stbi__jbias[n] & ~sgn);
-}
-
-// get some unsigned bits
-stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)
-{
-   unsigned int k;
-   if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
-   k = stbi_lrot(j->code_buffer, n);
-   j->code_buffer = k & ~stbi__bmask[n];
-   k &= stbi__bmask[n];
-   j->code_bits -= n;
-   return k;
-}
-
-stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)
-{
-   unsigned int k;
-   if (j->code_bits < 1) stbi__grow_buffer_unsafe(j);
-   k = j->code_buffer;
-   j->code_buffer <<= 1;
-   --j->code_bits;
-   return k & 0x80000000;
-}
-
-// given a value that's at position X in the zigzag stream,
-// where does it appear in the 8x8 matrix coded as row-major?
-static stbi_uc stbi__jpeg_dezigzag[64+15] =
-{
-    0,  1,  8, 16,  9,  2,  3, 10,
-   17, 24, 32, 25, 18, 11,  4,  5,
-   12, 19, 26, 33, 40, 48, 41, 34,
-   27, 20, 13,  6,  7, 14, 21, 28,
-   35, 42, 49, 56, 57, 50, 43, 36,
-   29, 22, 15, 23, 30, 37, 44, 51,
-   58, 59, 52, 45, 38, 31, 39, 46,
-   53, 60, 61, 54, 47, 55, 62, 63,
-   // let corrupt input sample past end
-   63, 63, 63, 63, 63, 63, 63, 63,
-   63, 63, 63, 63, 63, 63, 63
-};
-
-// decode one 64-entry block--
-static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi_uc *dequant)
-{
-   int diff,dc,k;
-   int t;
-
-   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
-   t = stbi__jpeg_huff_decode(j, hdc);
-   if (t < 0) return stbi__err("bad huffman code","Corrupt JPEG");
-
-   // 0 all the ac values now so we can do it 32-bits at a time
-   memset(data,0,64*sizeof(data[0]));
-
-   diff = t ? stbi__extend_receive(j, t) : 0;
-   dc = j->img_comp[b].dc_pred + diff;
-   j->img_comp[b].dc_pred = dc;
-   data[0] = (short) (dc * dequant[0]);
-
-   // decode AC components, see JPEG spec
-   k = 1;
-   do {
-      unsigned int zig;
-      int c,r,s;
-      if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
-      c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
-      r = fac[c];
-      if (r) { // fast-AC path
-         k += (r >> 4) & 15; // run
-         s = r & 15; // combined length
-         j->code_buffer <<= s;
-         j->code_bits -= s;
-         // decode into unzigzag'd location
-         zig = stbi__jpeg_dezigzag[k++];
-         data[zig] = (short) ((r >> 8) * dequant[zig]);
-      } else {
-         int rs = stbi__jpeg_huff_decode(j, hac);
-         if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
-         s = rs & 15;
-         r = rs >> 4;
-         if (s == 0) {
-            if (rs != 0xf0) break; // end block
-            k += 16;
-         } else {
-            k += r;
-            // decode into unzigzag'd location
-            zig = stbi__jpeg_dezigzag[k++];
-            data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]);
-         }
-      }
-   } while (k < 64);
-   return 1;
-}
-
-static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)
-{
-   int diff,dc;
-   int t;
-   if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
-
-   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
-
-   if (j->succ_high == 0) {
-      // first scan for DC coefficient, must be first
-      memset(data,0,64*sizeof(data[0])); // 0 all the ac values now
-      t = stbi__jpeg_huff_decode(j, hdc);
-      diff = t ? stbi__extend_receive(j, t) : 0;
-
-      dc = j->img_comp[b].dc_pred + diff;
-      j->img_comp[b].dc_pred = dc;
-      data[0] = (short) (dc << j->succ_low);
-   } else {
-      // refinement scan for DC coefficient
-      if (stbi__jpeg_get_bit(j))
-         data[0] += (short) (1 << j->succ_low);
-   }
-   return 1;
-}
-
-// @OPTIMIZE: store non-zigzagged during the decode passes,
-// and only de-zigzag when dequantizing
-static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac)
-{
-   int k;
-   if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
-
-   if (j->succ_high == 0) {
-      int shift = j->succ_low;
-
-      if (j->eob_run) {
-         --j->eob_run;
-         return 1;
-      }
-
-      k = j->spec_start;
-      do {
-         unsigned int zig;
-         int c,r,s;
-         if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
-         c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
-         r = fac[c];
-         if (r) { // fast-AC path
-            k += (r >> 4) & 15; // run
-            s = r & 15; // combined length
-            j->code_buffer <<= s;
-            j->code_bits -= s;
-            zig = stbi__jpeg_dezigzag[k++];
-            data[zig] = (short) ((r >> 8) << shift);
-         } else {
-            int rs = stbi__jpeg_huff_decode(j, hac);
-            if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
-            s = rs & 15;
-            r = rs >> 4;
-            if (s == 0) {
-               if (r < 15) {
-                  j->eob_run = (1 << r);
-                  if (r)
-                     j->eob_run += stbi__jpeg_get_bits(j, r);
-                  --j->eob_run;
-                  break;
-               }
-               k += 16;
-            } else {
-               k += r;
-               zig = stbi__jpeg_dezigzag[k++];
-               data[zig] = (short) (stbi__extend_receive(j,s) << shift);
-            }
-         }
-      } while (k <= j->spec_end);
-   } else {
-      // refinement scan for these AC coefficients
-
-      short bit = (short) (1 << j->succ_low);
-
-      if (j->eob_run) {
-         --j->eob_run;
-         for (k = j->spec_start; k <= j->spec_end; ++k) {
-            short *p = &data[stbi__jpeg_dezigzag[k]];
-            if (*p != 0)
-               if (stbi__jpeg_get_bit(j))
-                  if ((*p & bit)==0) {
-                     if (*p > 0)
-                        *p += bit;
-                     else
-                        *p -= bit;
-                  }
-         }
-      } else {
-         k = j->spec_start;
-         do {
-            int r,s;
-            int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh
-            if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
-            s = rs & 15;
-            r = rs >> 4;
-            if (s == 0) {
-               if (r < 15) {
-                  j->eob_run = (1 << r) - 1;
-                  if (r)
-                     j->eob_run += stbi__jpeg_get_bits(j, r);
-                  r = 64; // force end of block
-               } else
-                  r = 16; // r=15 is the code for 16 0s
-            } else {
-               if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG");
-               // sign bit
-               if (stbi__jpeg_get_bit(j))
-                  s = bit;
-               else
-                  s = -bit;
-            }
-
-            // advance by r
-            while (k <= j->spec_end) {
-               short *p = &data[stbi__jpeg_dezigzag[k]];
-               if (*p != 0) {
-                  if (stbi__jpeg_get_bit(j))
-                     if ((*p & bit)==0) {
-                        if (*p > 0)
-                           *p += bit;
-                        else
-                           *p -= bit;
-                     }
-                  ++k;
-               } else {
-                  if (r == 0) {
-                     if (s)
-                        data[stbi__jpeg_dezigzag[k++]] = (short) s;
-                     break;
-                  }
-                  --r;
-                  ++k;
-               }
-            }
-         } while (k <= j->spec_end);
-      }
-   }
-   return 1;
-}
-
-// take a -128..127 value and stbi__clamp it and convert to 0..255
-stbi_inline static stbi_uc stbi__clamp(int x)
-{
-   // trick to use a single test to catch both cases
-   if ((unsigned int) x > 255) {
-      if (x < 0) return 0;
-      if (x > 255) return 255;
-   }
-   return (stbi_uc) x;
-}
-
-#define stbi__f2f(x)  ((int) (((x) * 4096 + 0.5)))
-#define stbi__fsh(x)  ((x) << 12)
-
-// derived from jidctint -- DCT_ISLOW
-#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \
-   int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \
-   p2 = s2;                                    \
-   p3 = s6;                                    \
-   p1 = (p2+p3) * stbi__f2f(0.5411961f);       \
-   t2 = p1 + p3*stbi__f2f(-1.847759065f);      \
-   t3 = p1 + p2*stbi__f2f( 0.765366865f);      \
-   p2 = s0;                                    \
-   p3 = s4;                                    \
-   t0 = stbi__fsh(p2+p3);                      \
-   t1 = stbi__fsh(p2-p3);                      \
-   x0 = t0+t3;                                 \
-   x3 = t0-t3;                                 \
-   x1 = t1+t2;                                 \
-   x2 = t1-t2;                                 \
-   t0 = s7;                                    \
-   t1 = s5;                                    \
-   t2 = s3;                                    \
-   t3 = s1;                                    \
-   p3 = t0+t2;                                 \
-   p4 = t1+t3;                                 \
-   p1 = t0+t3;                                 \
-   p2 = t1+t2;                                 \
-   p5 = (p3+p4)*stbi__f2f( 1.175875602f);      \
-   t0 = t0*stbi__f2f( 0.298631336f);           \
-   t1 = t1*stbi__f2f( 2.053119869f);           \
-   t2 = t2*stbi__f2f( 3.072711026f);           \
-   t3 = t3*stbi__f2f( 1.501321110f);           \
-   p1 = p5 + p1*stbi__f2f(-0.899976223f);      \
-   p2 = p5 + p2*stbi__f2f(-2.562915447f);      \
-   p3 = p3*stbi__f2f(-1.961570560f);           \
-   p4 = p4*stbi__f2f(-0.390180644f);           \
-   t3 += p1+p4;                                \
-   t2 += p2+p3;                                \
-   t1 += p2+p4;                                \
-   t0 += p1+p3;
-
-static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])
-{
-   int i,val[64],*v=val;
-   stbi_uc *o;
-   short *d = data;
-
-   // columns
-   for (i=0; i < 8; ++i,++d, ++v) {
-      // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
-      if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0
-           && d[40]==0 && d[48]==0 && d[56]==0) {
-         //    no shortcut                 0     seconds
-         //    (1|2|3|4|5|6|7)==0          0     seconds
-         //    all separate               -0.047 seconds
-         //    1 && 2|3 && 4|5 && 6|7:    -0.047 seconds
-         int dcterm = d[0] << 2;
-         v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
-      } else {
-         STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56])
-         // constants scaled things up by 1<<12; let's bring them back
-         // down, but keep 2 extra bits of precision
-         x0 += 512; x1 += 512; x2 += 512; x3 += 512;
-         v[ 0] = (x0+t3) >> 10;
-         v[56] = (x0-t3) >> 10;
-         v[ 8] = (x1+t2) >> 10;
-         v[48] = (x1-t2) >> 10;
-         v[16] = (x2+t1) >> 10;
-         v[40] = (x2-t1) >> 10;
-         v[24] = (x3+t0) >> 10;
-         v[32] = (x3-t0) >> 10;
-      }
-   }
-
-   for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {
-      // no fast case since the first 1D IDCT spread components out
-      STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])
-      // constants scaled things up by 1<<12, plus we had 1<<2 from first
-      // loop, plus horizontal and vertical each scale by sqrt(8) so together
-      // we've got an extra 1<<3, so 1<<17 total we need to remove.
-      // so we want to round that, which means adding 0.5 * 1<<17,
-      // aka 65536. Also, we'll end up with -128 to 127 that we want
-      // to encode as 0..255 by adding 128, so we'll add that before the shift
-      x0 += 65536 + (128<<17);
-      x1 += 65536 + (128<<17);
-      x2 += 65536 + (128<<17);
-      x3 += 65536 + (128<<17);
-      // tried computing the shifts into temps, or'ing the temps to see
-      // if any were out of range, but that was slower
-      o[0] = stbi__clamp((x0+t3) >> 17);
-      o[7] = stbi__clamp((x0-t3) >> 17);
-      o[1] = stbi__clamp((x1+t2) >> 17);
-      o[6] = stbi__clamp((x1-t2) >> 17);
-      o[2] = stbi__clamp((x2+t1) >> 17);
-      o[5] = stbi__clamp((x2-t1) >> 17);
-      o[3] = stbi__clamp((x3+t0) >> 17);
-      o[4] = stbi__clamp((x3-t0) >> 17);
-   }
-}
-
-#ifdef STBI_SSE2
-// sse2 integer IDCT. not the fastest possible implementation but it
-// produces bit-identical results to the generic C version so it's
-// fully "transparent".
-static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
-{
-   // This is constructed to match our regular (generic) integer IDCT exactly.
-   __m128i row0, row1, row2, row3, row4, row5, row6, row7;
-   __m128i tmp;
-
-   // dot product constant: even elems=x, odd elems=y
-   #define dct_const(x,y)  _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))
-
-   // out(0) = c0[even]*x + c0[odd]*y   (c0, x, y 16-bit, out 32-bit)
-   // out(1) = c1[even]*x + c1[odd]*y
-   #define dct_rot(out0,out1, x,y,c0,c1) \
-      __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \
-      __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \
-      __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \
-      __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \
-      __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \
-      __m128i out1##_h = _mm_madd_epi16(c0##hi, c1)
-
-   // out = in << 12  (in 16-bit, out 32-bit)
-   #define dct_widen(out, in) \
-      __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \
-      __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)
-
-   // wide add
-   #define dct_wadd(out, a, b) \
-      __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \
-      __m128i out##_h = _mm_add_epi32(a##_h, b##_h)
-
-   // wide sub
-   #define dct_wsub(out, a, b) \
-      __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \
-      __m128i out##_h = _mm_sub_epi32(a##_h, b##_h)
-
-   // butterfly a/b, add bias, then shift by "s" and pack
-   #define dct_bfly32o(out0, out1, a,b,bias,s) \
-      { \
-         __m128i abiased_l = _mm_add_epi32(a##_l, bias); \
-         __m128i abiased_h = _mm_add_epi32(a##_h, bias); \
-         dct_wadd(sum, abiased, b); \
-         dct_wsub(dif, abiased, b); \
-         out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \
-         out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \
-      }
-
-   // 8-bit interleave step (for transposes)
-   #define dct_interleave8(a, b) \
-      tmp = a; \
-      a = _mm_unpacklo_epi8(a, b); \
-      b = _mm_unpackhi_epi8(tmp, b)
-
-   // 16-bit interleave step (for transposes)
-   #define dct_interleave16(a, b) \
-      tmp = a; \
-      a = _mm_unpacklo_epi16(a, b); \
-      b = _mm_unpackhi_epi16(tmp, b)
-
-   #define dct_pass(bias,shift) \
-      { \
-         /* even part */ \
-         dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \
-         __m128i sum04 = _mm_add_epi16(row0, row4); \
-         __m128i dif04 = _mm_sub_epi16(row0, row4); \
-         dct_widen(t0e, sum04); \
-         dct_widen(t1e, dif04); \
-         dct_wadd(x0, t0e, t3e); \
-         dct_wsub(x3, t0e, t3e); \
-         dct_wadd(x1, t1e, t2e); \
-         dct_wsub(x2, t1e, t2e); \
-         /* odd part */ \
-         dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \
-         dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \
-         __m128i sum17 = _mm_add_epi16(row1, row7); \
-         __m128i sum35 = _mm_add_epi16(row3, row5); \
-         dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \
-         dct_wadd(x4, y0o, y4o); \
-         dct_wadd(x5, y1o, y5o); \
-         dct_wadd(x6, y2o, y5o); \
-         dct_wadd(x7, y3o, y4o); \
-         dct_bfly32o(row0,row7, x0,x7,bias,shift); \
-         dct_bfly32o(row1,row6, x1,x6,bias,shift); \
-         dct_bfly32o(row2,row5, x2,x5,bias,shift); \
-         dct_bfly32o(row3,row4, x3,x4,bias,shift); \
-      }
-
-   __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f));
-   __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f));
-   __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f));
-   __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f));
-   __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f));
-   __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f));
-   __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f));
-   __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f));
-
-   // rounding biases in column/row passes, see stbi__idct_block for explanation.
-   __m128i bias_0 = _mm_set1_epi32(512);
-   __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17));
-
-   // load
-   row0 = _mm_load_si128((const __m128i *) (data + 0*8));
-   row1 = _mm_load_si128((const __m128i *) (data + 1*8));
-   row2 = _mm_load_si128((const __m128i *) (data + 2*8));
-   row3 = _mm_load_si128((const __m128i *) (data + 3*8));
-   row4 = _mm_load_si128((const __m128i *) (data + 4*8));
-   row5 = _mm_load_si128((const __m128i *) (data + 5*8));
-   row6 = _mm_load_si128((const __m128i *) (data + 6*8));
-   row7 = _mm_load_si128((const __m128i *) (data + 7*8));
-
-   // column pass
-   dct_pass(bias_0, 10);
-
-   {
-      // 16bit 8x8 transpose pass 1
-      dct_interleave16(row0, row4);
-      dct_interleave16(row1, row5);
-      dct_interleave16(row2, row6);
-      dct_interleave16(row3, row7);
-
-      // transpose pass 2
-      dct_interleave16(row0, row2);
-      dct_interleave16(row1, row3);
-      dct_interleave16(row4, row6);
-      dct_interleave16(row5, row7);
-
-      // transpose pass 3
-      dct_interleave16(row0, row1);
-      dct_interleave16(row2, row3);
-      dct_interleave16(row4, row5);
-      dct_interleave16(row6, row7);
-   }
-
-   // row pass
-   dct_pass(bias_1, 17);
-
-   {
-      // pack
-      __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7
-      __m128i p1 = _mm_packus_epi16(row2, row3);
-      __m128i p2 = _mm_packus_epi16(row4, row5);
-      __m128i p3 = _mm_packus_epi16(row6, row7);
-
-      // 8bit 8x8 transpose pass 1
-      dct_interleave8(p0, p2); // a0e0a1e1...
-      dct_interleave8(p1, p3); // c0g0c1g1...
-
-      // transpose pass 2
-      dct_interleave8(p0, p1); // a0c0e0g0...
-      dct_interleave8(p2, p3); // b0d0f0h0...
-
-      // transpose pass 3
-      dct_interleave8(p0, p2); // a0b0c0d0...
-      dct_interleave8(p1, p3); // a4b4c4d4...
-
-      // store
-      _mm_storel_epi64((__m128i *) out, p0); out += out_stride;
-      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride;
-      _mm_storel_epi64((__m128i *) out, p2); out += out_stride;
-      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride;
-      _mm_storel_epi64((__m128i *) out, p1); out += out_stride;
-      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride;
-      _mm_storel_epi64((__m128i *) out, p3); out += out_stride;
-      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e));
-   }
-
-#undef dct_const
-#undef dct_rot
-#undef dct_widen
-#undef dct_wadd
-#undef dct_wsub
-#undef dct_bfly32o
-#undef dct_interleave8
-#undef dct_interleave16
-#undef dct_pass
-}
-
-#endif // STBI_SSE2
-
-#ifdef STBI_NEON
-
-// NEON integer IDCT. should produce bit-identical
-// results to the generic C version.
-static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
-{
-   int16x8_t row0, row1, row2, row3, row4, row5, row6, row7;
-
-   int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f));
-   int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f));
-   int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f));
-   int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f));
-   int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f));
-   int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f));
-   int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f));
-   int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f));
-   int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f));
-   int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f));
-   int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f));
-   int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f));
-
-#define dct_long_mul(out, inq, coeff) \
-   int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \
-   int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff)
-
-#define dct_long_mac(out, acc, inq, coeff) \
-   int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \
-   int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff)
-
-#define dct_widen(out, inq) \
-   int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \
-   int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)
-
-// wide add
-#define dct_wadd(out, a, b) \
-   int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \
-   int32x4_t out##_h = vaddq_s32(a##_h, b##_h)
-
-// wide sub
-#define dct_wsub(out, a, b) \
-   int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \
-   int32x4_t out##_h = vsubq_s32(a##_h, b##_h)
-
-// butterfly a/b, then shift using "shiftop" by "s" and pack
-#define dct_bfly32o(out0,out1, a,b,shiftop,s) \
-   { \
-      dct_wadd(sum, a, b); \
-      dct_wsub(dif, a, b); \
-      out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \
-      out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \
-   }
-
-#define dct_pass(shiftop, shift) \
-   { \
-      /* even part */ \
-      int16x8_t sum26 = vaddq_s16(row2, row6); \
-      dct_long_mul(p1e, sum26, rot0_0); \
-      dct_long_mac(t2e, p1e, row6, rot0_1); \
-      dct_long_mac(t3e, p1e, row2, rot0_2); \
-      int16x8_t sum04 = vaddq_s16(row0, row4); \
-      int16x8_t dif04 = vsubq_s16(row0, row4); \
-      dct_widen(t0e, sum04); \
-      dct_widen(t1e, dif04); \
-      dct_wadd(x0, t0e, t3e); \
-      dct_wsub(x3, t0e, t3e); \
-      dct_wadd(x1, t1e, t2e); \
-      dct_wsub(x2, t1e, t2e); \
-      /* odd part */ \
-      int16x8_t sum15 = vaddq_s16(row1, row5); \
-      int16x8_t sum17 = vaddq_s16(row1, row7); \
-      int16x8_t sum35 = vaddq_s16(row3, row5); \
-      int16x8_t sum37 = vaddq_s16(row3, row7); \
-      int16x8_t sumodd = vaddq_s16(sum17, sum35); \
-      dct_long_mul(p5o, sumodd, rot1_0); \
-      dct_long_mac(p1o, p5o, sum17, rot1_1); \
-      dct_long_mac(p2o, p5o, sum35, rot1_2); \
-      dct_long_mul(p3o, sum37, rot2_0); \
-      dct_long_mul(p4o, sum15, rot2_1); \
-      dct_wadd(sump13o, p1o, p3o); \
-      dct_wadd(sump24o, p2o, p4o); \
-      dct_wadd(sump23o, p2o, p3o); \
-      dct_wadd(sump14o, p1o, p4o); \
-      dct_long_mac(x4, sump13o, row7, rot3_0); \
-      dct_long_mac(x5, sump24o, row5, rot3_1); \
-      dct_long_mac(x6, sump23o, row3, rot3_2); \
-      dct_long_mac(x7, sump14o, row1, rot3_3); \
-      dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \
-      dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \
-      dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \
-      dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \
-   }
-
-   // load
-   row0 = vld1q_s16(data + 0*8);
-   row1 = vld1q_s16(data + 1*8);
-   row2 = vld1q_s16(data + 2*8);
-   row3 = vld1q_s16(data + 3*8);
-   row4 = vld1q_s16(data + 4*8);
-   row5 = vld1q_s16(data + 5*8);
-   row6 = vld1q_s16(data + 6*8);
-   row7 = vld1q_s16(data + 7*8);
-
-   // add DC bias
-   row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0));
-
-   // column pass
-   dct_pass(vrshrn_n_s32, 10);
-
-   // 16bit 8x8 transpose
-   {
-// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively.
-// whether compilers actually get this is another story, sadly.
-#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }
-#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); }
-#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); }
-
-      // pass 1
-      dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6
-      dct_trn16(row2, row3);
-      dct_trn16(row4, row5);
-      dct_trn16(row6, row7);
-
-      // pass 2
-      dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4
-      dct_trn32(row1, row3);
-      dct_trn32(row4, row6);
-      dct_trn32(row5, row7);
-
-      // pass 3
-      dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0
-      dct_trn64(row1, row5);
-      dct_trn64(row2, row6);
-      dct_trn64(row3, row7);
-
-#undef dct_trn16
-#undef dct_trn32
-#undef dct_trn64
-   }
-
-   // row pass
-   // vrshrn_n_s32 only supports shifts up to 16, we need
-   // 17. so do a non-rounding shift of 16 first then follow
-   // up with a rounding shift by 1.
-   dct_pass(vshrn_n_s32, 16);
-
-   {
-      // pack and round
-      uint8x8_t p0 = vqrshrun_n_s16(row0, 1);
-      uint8x8_t p1 = vqrshrun_n_s16(row1, 1);
-      uint8x8_t p2 = vqrshrun_n_s16(row2, 1);
-      uint8x8_t p3 = vqrshrun_n_s16(row3, 1);
-      uint8x8_t p4 = vqrshrun_n_s16(row4, 1);
-      uint8x8_t p5 = vqrshrun_n_s16(row5, 1);
-      uint8x8_t p6 = vqrshrun_n_s16(row6, 1);
-      uint8x8_t p7 = vqrshrun_n_s16(row7, 1);
-
-      // again, these can translate into one instruction, but often don't.
-#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }
-#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); }
-#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); }
-
-      // sadly can't use interleaved stores here since we only write
-      // 8 bytes to each scan line!
-
-      // 8x8 8-bit transpose pass 1
-      dct_trn8_8(p0, p1);
-      dct_trn8_8(p2, p3);
-      dct_trn8_8(p4, p5);
-      dct_trn8_8(p6, p7);
-
-      // pass 2
-      dct_trn8_16(p0, p2);
-      dct_trn8_16(p1, p3);
-      dct_trn8_16(p4, p6);
-      dct_trn8_16(p5, p7);
-
-      // pass 3
-      dct_trn8_32(p0, p4);
-      dct_trn8_32(p1, p5);
-      dct_trn8_32(p2, p6);
-      dct_trn8_32(p3, p7);
-
-      // store
-      vst1_u8(out, p0); out += out_stride;
-      vst1_u8(out, p1); out += out_stride;
-      vst1_u8(out, p2); out += out_stride;
-      vst1_u8(out, p3); out += out_stride;
-      vst1_u8(out, p4); out += out_stride;
-      vst1_u8(out, p5); out += out_stride;
-      vst1_u8(out, p6); out += out_stride;
-      vst1_u8(out, p7);
-
-#undef dct_trn8_8
-#undef dct_trn8_16
-#undef dct_trn8_32
-   }
-
-#undef dct_long_mul
-#undef dct_long_mac
-#undef dct_widen
-#undef dct_wadd
-#undef dct_wsub
-#undef dct_bfly32o
-#undef dct_pass
-}
-
-#endif // STBI_NEON
-
-#define STBI__MARKER_none  0xff
-// if there's a pending marker from the entropy stream, return that
-// otherwise, fetch from the stream and get a marker. if there's no
-// marker, return 0xff, which is never a valid marker value
-static stbi_uc stbi__get_marker(stbi__jpeg *j)
-{
-   stbi_uc x;
-   if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }
-   x = stbi__get8(j->s);
-   if (x != 0xff) return STBI__MARKER_none;
-   while (x == 0xff)
-      x = stbi__get8(j->s);
-   return x;
-}
-
-// in each scan, we'll have scan_n components, and the order
-// of the components is specified by order[]
-#define STBI__RESTART(x)     ((x) >= 0xd0 && (x) <= 0xd7)
-
-// after a restart interval, stbi__jpeg_reset the entropy decoder and
-// the dc prediction
-static void stbi__jpeg_reset(stbi__jpeg *j)
-{
-   j->code_bits = 0;
-   j->code_buffer = 0;
-   j->nomore = 0;
-   j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = 0;
-   j->marker = STBI__MARKER_none;
-   j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
-   j->eob_run = 0;
-   // no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
-   // since we don't even allow 1<<30 pixels
-}
-
-static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
-{
-   stbi__jpeg_reset(z);
-   if (!z->progressive) {
-      if (z->scan_n == 1) {
-         int i,j;
-         STBI_SIMD_ALIGN(short, data[64]);
-         int n = z->order[0];
-         // non-interleaved data, we just need to process one block at a time,
-         // in trivial scanline order
-         // number of blocks to do just depends on how many actual "pixels" this
-         // component has, independent of interleaved MCU blocking and such
-         int w = (z->img_comp[n].x+7) >> 3;
-         int h = (z->img_comp[n].y+7) >> 3;
-         for (j=0; j < h; ++j) {
-            for (i=0; i < w; ++i) {
-               int ha = z->img_comp[n].ha;
-               if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;
-               z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
-               // every data block is an MCU, so countdown the restart interval
-               if (--z->todo <= 0) {
-                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
-                  // if it's NOT a restart, then just bail, so we get corrupt data
-                  // rather than no data
-                  if (!STBI__RESTART(z->marker)) return 1;
-                  stbi__jpeg_reset(z);
-               }
-            }
-         }
-         return 1;
-      } else { // interleaved
-         int i,j,k,x,y;
-         STBI_SIMD_ALIGN(short, data[64]);
-         for (j=0; j < z->img_mcu_y; ++j) {
-            for (i=0; i < z->img_mcu_x; ++i) {
-               // scan an interleaved mcu... process scan_n components in order
-               for (k=0; k < z->scan_n; ++k) {
-                  int n = z->order[k];
-                  // scan out an mcu's worth of this component; that's just determined
-                  // by the basic H and V specified for the component
-                  for (y=0; y < z->img_comp[n].v; ++y) {
-                     for (x=0; x < z->img_comp[n].h; ++x) {
-                        int x2 = (i*z->img_comp[n].h + x)*8;
-                        int y2 = (j*z->img_comp[n].v + y)*8;
-                        int ha = z->img_comp[n].ha;
-                        if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;
-                        z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data);
-                     }
-                  }
-               }
-               // after all interleaved components, that's an interleaved MCU,
-               // so now count down the restart interval
-               if (--z->todo <= 0) {
-                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
-                  if (!STBI__RESTART(z->marker)) return 1;
-                  stbi__jpeg_reset(z);
-               }
-            }
-         }
-         return 1;
-      }
-   } else {
-      if (z->scan_n == 1) {
-         int i,j;
-         int n = z->order[0];
-         // non-interleaved data, we just need to process one block at a time,
-         // in trivial scanline order
-         // number of blocks to do just depends on how many actual "pixels" this
-         // component has, independent of interleaved MCU blocking and such
-         int w = (z->img_comp[n].x+7) >> 3;
-         int h = (z->img_comp[n].y+7) >> 3;
-         for (j=0; j < h; ++j) {
-            for (i=0; i < w; ++i) {
-               short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
-               if (z->spec_start == 0) {
-                  if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
-                     return 0;
-               } else {
-                  int ha = z->img_comp[n].ha;
-                  if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha]))
-                     return 0;
-               }
-               // every data block is an MCU, so countdown the restart interval
-               if (--z->todo <= 0) {
-                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
-                  if (!STBI__RESTART(z->marker)) return 1;
-                  stbi__jpeg_reset(z);
-               }
-            }
-         }
-         return 1;
-      } else { // interleaved
-         int i,j,k,x,y;
-         for (j=0; j < z->img_mcu_y; ++j) {
-            for (i=0; i < z->img_mcu_x; ++i) {
-               // scan an interleaved mcu... process scan_n components in order
-               for (k=0; k < z->scan_n; ++k) {
-                  int n = z->order[k];
-                  // scan out an mcu's worth of this component; that's just determined
-                  // by the basic H and V specified for the component
-                  for (y=0; y < z->img_comp[n].v; ++y) {
-                     for (x=0; x < z->img_comp[n].h; ++x) {
-                        int x2 = (i*z->img_comp[n].h + x);
-                        int y2 = (j*z->img_comp[n].v + y);
-                        short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w);
-                        if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
-                           return 0;
-                     }
-                  }
-               }
-               // after all interleaved components, that's an interleaved MCU,
-               // so now count down the restart interval
-               if (--z->todo <= 0) {
-                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
-                  if (!STBI__RESTART(z->marker)) return 1;
-                  stbi__jpeg_reset(z);
-               }
-            }
-         }
-         return 1;
-      }
-   }
-}
-
-static void stbi__jpeg_dequantize(short *data, stbi_uc *dequant)
-{
-   int i;
-   for (i=0; i < 64; ++i)
-      data[i] *= dequant[i];
-}
-
-static void stbi__jpeg_finish(stbi__jpeg *z)
-{
-   if (z->progressive) {
-      // dequantize and idct the data
-      int i,j,n;
-      for (n=0; n < z->s->img_n; ++n) {
-         int w = (z->img_comp[n].x+7) >> 3;
-         int h = (z->img_comp[n].y+7) >> 3;
-         for (j=0; j < h; ++j) {
-            for (i=0; i < w; ++i) {
-               short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
-               stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]);
-               z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
-            }
-         }
-      }
-   }
-}
-
-static int stbi__process_marker(stbi__jpeg *z, int m)
-{
-   int L;
-   switch (m) {
-      case STBI__MARKER_none: // no marker found
-         return stbi__err("expected marker","Corrupt JPEG");
-
-      case 0xDD: // DRI - specify restart interval
-         if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG");
-         z->restart_interval = stbi__get16be(z->s);
-         return 1;
-
-      case 0xDB: // DQT - define quantization table
-         L = stbi__get16be(z->s)-2;
-         while (L > 0) {
-            int q = stbi__get8(z->s);
-            int p = q >> 4;
-            int t = q & 15,i;
-            if (p != 0) return stbi__err("bad DQT type","Corrupt JPEG");
-            if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG");
-            for (i=0; i < 64; ++i)
-               z->dequant[t][stbi__jpeg_dezigzag[i]] = stbi__get8(z->s);
-            L -= 65;
-         }
-         return L==0;
-
-      case 0xC4: // DHT - define huffman table
-         L = stbi__get16be(z->s)-2;
-         while (L > 0) {
-            stbi_uc *v;
-            int sizes[16],i,n=0;
-            int q = stbi__get8(z->s);
-            int tc = q >> 4;
-            int th = q & 15;
-            if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG");
-            for (i=0; i < 16; ++i) {
-               sizes[i] = stbi__get8(z->s);
-               n += sizes[i];
-            }
-            L -= 17;
-            if (tc == 0) {
-               if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0;
-               v = z->huff_dc[th].values;
-            } else {
-               if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0;
-               v = z->huff_ac[th].values;
-            }
-            for (i=0; i < n; ++i)
-               v[i] = stbi__get8(z->s);
-            if (tc != 0)
-               stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th);
-            L -= n;
-         }
-         return L==0;
-   }
-   // check for comment block or APP blocks
-   if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
-      stbi__skip(z->s, stbi__get16be(z->s)-2);
-      return 1;
-   }
-   return 0;
-}
-
-// after we see SOS
-static int stbi__process_scan_header(stbi__jpeg *z)
-{
-   int i;
-   int Ls = stbi__get16be(z->s);
-   z->scan_n = stbi__get8(z->s);
-   if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG");
-   if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG");
-   for (i=0; i < z->scan_n; ++i) {
-      int id = stbi__get8(z->s), which;
-      int q = stbi__get8(z->s);
-      for (which = 0; which < z->s->img_n; ++which)
-         if (z->img_comp[which].id == id)
-            break;
-      if (which == z->s->img_n) return 0; // no match
-      z->img_comp[which].hd = q >> 4;   if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG");
-      z->img_comp[which].ha = q & 15;   if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG");
-      z->order[i] = which;
-   }
-
-   {
-      int aa;
-      z->spec_start = stbi__get8(z->s);
-      z->spec_end   = stbi__get8(z->s); // should be 63, but might be 0
-      aa = stbi__get8(z->s);
-      z->succ_high = (aa >> 4);
-      z->succ_low  = (aa & 15);
-      if (z->progressive) {
-         if (z->spec_start > 63 || z->spec_end > 63  || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13)
-            return stbi__err("bad SOS", "Corrupt JPEG");
-      } else {
-         if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG");
-         if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG");
-         z->spec_end = 63;
-      }
-   }
-
-   return 1;
-}
-
-static int stbi__process_frame_header(stbi__jpeg *z, int scan)
-{
-   stbi__context *s = z->s;
-   int Lf,p,i,q, h_max=1,v_max=1,c;
-   Lf = stbi__get16be(s);         if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG
-   p  = stbi__get8(s);            if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
-   s->img_y = stbi__get16be(s);   if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
-   s->img_x = stbi__get16be(s);   if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires
-   c = stbi__get8(s);
-   if (c != 3 && c != 1) return stbi__err("bad component count","Corrupt JPEG");    // JFIF requires
-   s->img_n = c;
-   for (i=0; i < c; ++i) {
-      z->img_comp[i].data = NULL;
-      z->img_comp[i].linebuf = NULL;
-   }
-
-   if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG");
-
-   for (i=0; i < s->img_n; ++i) {
-      z->img_comp[i].id = stbi__get8(s);
-      if (z->img_comp[i].id != i+1)   // JFIF requires
-         if (z->img_comp[i].id != i)  // some version of jpegtran outputs non-JFIF-compliant files!
-            return stbi__err("bad component ID","Corrupt JPEG");
-      q = stbi__get8(s);
-      z->img_comp[i].h = (q >> 4);  if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG");
-      z->img_comp[i].v = q & 15;    if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG");
-      z->img_comp[i].tq = stbi__get8(s);  if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG");
-   }
-
-   if (scan != STBI__SCAN_load) return 1;
-
-   if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode");
-
-   for (i=0; i < s->img_n; ++i) {
-      if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;
-      if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;
-   }
-
-   // compute interleaved mcu info
-   z->img_h_max = h_max;
-   z->img_v_max = v_max;
-   z->img_mcu_w = h_max * 8;
-   z->img_mcu_h = v_max * 8;
-   z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;
-   z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;
-
-   for (i=0; i < s->img_n; ++i) {
-      // number of effective pixels (e.g. for non-interleaved MCU)
-      z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;
-      z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;
-      // to simplify generation, we'll allocate enough memory to decode
-      // the bogus oversized data from using interleaved MCUs and their
-      // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't
-      // discard the extra data until colorspace conversion
-      z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;
-      z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;
-      z->img_comp[i].raw_data = stbi__malloc(z->img_comp[i].w2 * z->img_comp[i].h2+15);
-
-      if (z->img_comp[i].raw_data == NULL) {
-         for(--i; i >= 0; --i) {
-            STBI_FREE(z->img_comp[i].raw_data);
-            z->img_comp[i].data = NULL;
-         }
-         return stbi__err("outofmem", "Out of memory");
-      }
-      // align blocks for idct using mmx/sse
-      z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
-      z->img_comp[i].linebuf = NULL;
-      if (z->progressive) {
-         z->img_comp[i].coeff_w = (z->img_comp[i].w2 + 7) >> 3;
-         z->img_comp[i].coeff_h = (z->img_comp[i].h2 + 7) >> 3;
-         z->img_comp[i].raw_coeff = STBI_MALLOC(z->img_comp[i].coeff_w * z->img_comp[i].coeff_h * 64 * sizeof(short) + 15);
-         z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15);
-      } else {
-         z->img_comp[i].coeff = 0;
-         z->img_comp[i].raw_coeff = 0;
-      }
-   }
-
-   return 1;
-}
-
-// use comparisons since in some cases we handle more than one case (e.g. SOF)
-#define stbi__DNL(x)         ((x) == 0xdc)
-#define stbi__SOI(x)         ((x) == 0xd8)
-#define stbi__EOI(x)         ((x) == 0xd9)
-#define stbi__SOF(x)         ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)
-#define stbi__SOS(x)         ((x) == 0xda)
-
-#define stbi__SOF_progressive(x)   ((x) == 0xc2)
-
-static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
-{
-   int m;
-   z->marker = STBI__MARKER_none; // initialize cached marker to empty
-   m = stbi__get_marker(z);
-   if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG");
-   if (scan == STBI__SCAN_type) return 1;
-   m = stbi__get_marker(z);
-   while (!stbi__SOF(m)) {
-      if (!stbi__process_marker(z,m)) return 0;
-      m = stbi__get_marker(z);
-      while (m == STBI__MARKER_none) {
-         // some files have extra padding after their blocks, so ok, we'll scan
-         if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG");
-         m = stbi__get_marker(z);
-      }
-   }
-   z->progressive = stbi__SOF_progressive(m);
-   if (!stbi__process_frame_header(z, scan)) return 0;
-   return 1;
-}
-
-// decode image to YCbCr format
-static int stbi__decode_jpeg_image(stbi__jpeg *j)
-{
-   int m;
-   j->restart_interval = 0;
-   if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0;
-   m = stbi__get_marker(j);
-   while (!stbi__EOI(m)) {
-      if (stbi__SOS(m)) {
-         if (!stbi__process_scan_header(j)) return 0;
-         if (!stbi__parse_entropy_coded_data(j)) return 0;
-         if (j->marker == STBI__MARKER_none ) {
-            // handle 0s at the end of image data from IP Kamera 9060
-            while (!stbi__at_eof(j->s)) {
-               int x = stbi__get8(j->s);
-               if (x == 255) {
-                  j->marker = stbi__get8(j->s);
-                  break;
-               } else if (x != 0) {
-                  return stbi__err("junk before marker", "Corrupt JPEG");
-               }
-            }
-            // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0
-         }
-      } else {
-         if (!stbi__process_marker(j, m)) return 0;
-      }
-      m = stbi__get_marker(j);
-   }
-   if (j->progressive)
-      stbi__jpeg_finish(j);
-   return 1;
-}
-
-// static jfif-centered resampling (across block boundaries)
-
-typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,
-                                    int w, int hs);
-
-#define stbi__div4(x) ((stbi_uc) ((x) >> 2))
-
-static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
-{
-   STBI_NOTUSED(out);
-   STBI_NOTUSED(in_far);
-   STBI_NOTUSED(w);
-   STBI_NOTUSED(hs);
-   return in_near;
-}
-
-static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
-{
-   // need to generate two samples vertically for every one in input
-   int i;
-   STBI_NOTUSED(hs);
-   for (i=0; i < w; ++i)
-      out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);
-   return out;
-}
-
-static stbi_uc*  stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
-{
-   // need to generate two samples horizontally for every one in input
-   int i;
-   stbi_uc *input = in_near;
-
-   if (w == 1) {
-      // if only one sample, can't do any interpolation
-      out[0] = out[1] = input[0];
-      return out;
-   }
-
-   out[0] = input[0];
-   out[1] = stbi__div4(input[0]*3 + input[1] + 2);
-   for (i=1; i < w-1; ++i) {
-      int n = 3*input[i]+2;
-      out[i*2+0] = stbi__div4(n+input[i-1]);
-      out[i*2+1] = stbi__div4(n+input[i+1]);
-   }
-   out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2);
-   out[i*2+1] = input[w-1];
-
-   STBI_NOTUSED(in_far);
-   STBI_NOTUSED(hs);
-
-   return out;
-}
-
-#define stbi__div16(x) ((stbi_uc) ((x) >> 4))
-
-static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
-{
-   // need to generate 2x2 samples for every one in input
-   int i,t0,t1;
-   if (w == 1) {
-      out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
-      return out;
-   }
-
-   t1 = 3*in_near[0] + in_far[0];
-   out[0] = stbi__div4(t1+2);
-   for (i=1; i < w; ++i) {
-      t0 = t1;
-      t1 = 3*in_near[i]+in_far[i];
-      out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
-      out[i*2  ] = stbi__div16(3*t1 + t0 + 8);
-   }
-   out[w*2-1] = stbi__div4(t1+2);
-
-   STBI_NOTUSED(hs);
-
-   return out;
-}
-
-#if defined(STBI_SSE2) || defined(STBI_NEON)
-static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
-{
-   // need to generate 2x2 samples for every one in input
-   int i=0,t0,t1;
-
-   if (w == 1) {
-      out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
-      return out;
-   }
-
-   t1 = 3*in_near[0] + in_far[0];
-   // process groups of 8 pixels for as long as we can.
-   // note we can't handle the last pixel in a row in this loop
-   // because we need to handle the filter boundary conditions.
-   for (; i < ((w-1) & ~7); i += 8) {
-#if defined(STBI_SSE2)
-      // load and perform the vertical filtering pass
-      // this uses 3*x + y = 4*x + (y - x)
-      __m128i zero  = _mm_setzero_si128();
-      __m128i farb  = _mm_loadl_epi64((__m128i *) (in_far + i));
-      __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i));
-      __m128i farw  = _mm_unpacklo_epi8(farb, zero);
-      __m128i nearw = _mm_unpacklo_epi8(nearb, zero);
-      __m128i diff  = _mm_sub_epi16(farw, nearw);
-      __m128i nears = _mm_slli_epi16(nearw, 2);
-      __m128i curr  = _mm_add_epi16(nears, diff); // current row
-
-      // horizontal filter works the same based on shifted vers of current
-      // row. "prev" is current row shifted right by 1 pixel; we need to
-      // insert the previous pixel value (from t1).
-      // "next" is current row shifted left by 1 pixel, with first pixel
-      // of next block of 8 pixels added in.
-      __m128i prv0 = _mm_slli_si128(curr, 2);
-      __m128i nxt0 = _mm_srli_si128(curr, 2);
-      __m128i prev = _mm_insert_epi16(prv0, t1, 0);
-      __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7);
-
-      // horizontal filter, polyphase implementation since it's convenient:
-      // even pixels = 3*cur + prev = cur*4 + (prev - cur)
-      // odd  pixels = 3*cur + next = cur*4 + (next - cur)
-      // note the shared term.
-      __m128i bias  = _mm_set1_epi16(8);
-      __m128i curs = _mm_slli_epi16(curr, 2);
-      __m128i prvd = _mm_sub_epi16(prev, curr);
-      __m128i nxtd = _mm_sub_epi16(next, curr);
-      __m128i curb = _mm_add_epi16(curs, bias);
-      __m128i even = _mm_add_epi16(prvd, curb);
-      __m128i odd  = _mm_add_epi16(nxtd, curb);
-
-      // interleave even and odd pixels, then undo scaling.
-      __m128i int0 = _mm_unpacklo_epi16(even, odd);
-      __m128i int1 = _mm_unpackhi_epi16(even, odd);
-      __m128i de0  = _mm_srli_epi16(int0, 4);
-      __m128i de1  = _mm_srli_epi16(int1, 4);
-
-      // pack and write output
-      __m128i outv = _mm_packus_epi16(de0, de1);
-      _mm_storeu_si128((__m128i *) (out + i*2), outv);
-#elif defined(STBI_NEON)
-      // load and perform the vertical filtering pass
-      // this uses 3*x + y = 4*x + (y - x)
-      uint8x8_t farb  = vld1_u8(in_far + i);
-      uint8x8_t nearb = vld1_u8(in_near + i);
-      int16x8_t diff  = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));
-      int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));
-      int16x8_t curr  = vaddq_s16(nears, diff); // current row
-
-      // horizontal filter works the same based on shifted vers of current
-      // row. "prev" is current row shifted right by 1 pixel; we need to
-      // insert the previous pixel value (from t1).
-      // "next" is current row shifted left by 1 pixel, with first pixel
-      // of next block of 8 pixels added in.
-      int16x8_t prv0 = vextq_s16(curr, curr, 7);
-      int16x8_t nxt0 = vextq_s16(curr, curr, 1);
-      int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);
-      int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7);
-
-      // horizontal filter, polyphase implementation since it's convenient:
-      // even pixels = 3*cur + prev = cur*4 + (prev - cur)
-      // odd  pixels = 3*cur + next = cur*4 + (next - cur)
-      // note the shared term.
-      int16x8_t curs = vshlq_n_s16(curr, 2);
-      int16x8_t prvd = vsubq_s16(prev, curr);
-      int16x8_t nxtd = vsubq_s16(next, curr);
-      int16x8_t even = vaddq_s16(curs, prvd);
-      int16x8_t odd  = vaddq_s16(curs, nxtd);
-
-      // undo scaling and round, then store with even/odd phases interleaved
-      uint8x8x2_t o;
-      o.val[0] = vqrshrun_n_s16(even, 4);
-      o.val[1] = vqrshrun_n_s16(odd,  4);
-      vst2_u8(out + i*2, o);
-#endif
-
-      // "previous" value for next iter
-      t1 = 3*in_near[i+7] + in_far[i+7];
-   }
-
-   t0 = t1;
-   t1 = 3*in_near[i] + in_far[i];
-   out[i*2] = stbi__div16(3*t1 + t0 + 8);
-
-   for (++i; i < w; ++i) {
-      t0 = t1;
-      t1 = 3*in_near[i]+in_far[i];
-      out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
-      out[i*2  ] = stbi__div16(3*t1 + t0 + 8);
-   }
-   out[w*2-1] = stbi__div4(t1+2);
-
-   STBI_NOTUSED(hs);
-
-   return out;
-}
-#endif
-
-static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
-{
-   // resample with nearest-neighbor
-   int i,j;
-   STBI_NOTUSED(in_far);
-   for (i=0; i < w; ++i)
-      for (j=0; j < hs; ++j)
-         out[i*hs+j] = in_near[i];
-   return out;
-}
-
-#ifdef STBI_JPEG_OLD
-// this is the same YCbCr-to-RGB calculation that stb_image has used
-// historically before the algorithm changes in 1.49
-#define float2fixed(x)  ((int) ((x) * 65536 + 0.5))
-static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)
-{
-   int i;
-   for (i=0; i < count; ++i) {
-      int y_fixed = (y[i] << 16) + 32768; // rounding
-      int r,g,b;
-      int cr = pcr[i] - 128;
-      int cb = pcb[i] - 128;
-      r = y_fixed + cr*float2fixed(1.40200f);
-      g = y_fixed - cr*float2fixed(0.71414f) - cb*float2fixed(0.34414f);
-      b = y_fixed                            + cb*float2fixed(1.77200f);
-      r >>= 16;
-      g >>= 16;
-      b >>= 16;
-      if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
-      if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
-      if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
-      out[0] = (stbi_uc)r;
-      out[1] = (stbi_uc)g;
-      out[2] = (stbi_uc)b;
-      out[3] = 255;
-      out += step;
-   }
-}
-#else
-// this is a reduced-precision calculation of YCbCr-to-RGB introduced
-// to make sure the code produces the same results in both SIMD and scalar
-#define float2fixed(x)  (((int) ((x) * 4096.0f + 0.5f)) << 8)
-static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)
-{
-   int i;
-   for (i=0; i < count; ++i) {
-      int y_fixed = (y[i] << 20) + (1<<19); // rounding
-      int r,g,b;
-      int cr = pcr[i] - 128;
-      int cb = pcb[i] - 128;
-      r = y_fixed +  cr* float2fixed(1.40200f);
-      g = y_fixed + (cr*-float2fixed(0.71414f)) + ((cb*-float2fixed(0.34414f)) & 0xffff0000);
-      b = y_fixed                               +   cb* float2fixed(1.77200f);
-      r >>= 20;
-      g >>= 20;
-      b >>= 20;
-      if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
-      if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
-      if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
-      out[0] = (stbi_uc)r;
-      out[1] = (stbi_uc)g;
-      out[2] = (stbi_uc)b;
-      out[3] = 255;
-      out += step;
-   }
-}
-#endif
-
-#if defined(STBI_SSE2) || defined(STBI_NEON)
-static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step)
-{
-   int i = 0;
-
-#ifdef STBI_SSE2
-   // step == 3 is pretty ugly on the final interleave, and i'm not convinced
-   // it's useful in practice (you wouldn't use it for textures, for example).
-   // so just accelerate step == 4 case.
-   if (step == 4) {
-      // this is a fairly straightforward implementation and not super-optimized.
-      __m128i signflip  = _mm_set1_epi8(-0x80);
-      __m128i cr_const0 = _mm_set1_epi16(   (short) ( 1.40200f*4096.0f+0.5f));
-      __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f));
-      __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f));
-      __m128i cb_const1 = _mm_set1_epi16(   (short) ( 1.77200f*4096.0f+0.5f));
-      __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128);
-      __m128i xw = _mm_set1_epi16(255); // alpha channel
-
-      for (; i+7 < count; i += 8) {
-         // load
-         __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i));
-         __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i));
-         __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i));
-         __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128
-         __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128
-
-         // unpack to short (and left-shift cr, cb by 8)
-         __m128i yw  = _mm_unpacklo_epi8(y_bias, y_bytes);
-         __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased);
-         __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased);
-
-         // color transform
-         __m128i yws = _mm_srli_epi16(yw, 4);
-         __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw);
-         __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw);
-         __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1);
-         __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1);
-         __m128i rws = _mm_add_epi16(cr0, yws);
-         __m128i gwt = _mm_add_epi16(cb0, yws);
-         __m128i bws = _mm_add_epi16(yws, cb1);
-         __m128i gws = _mm_add_epi16(gwt, cr1);
-
-         // descale
-         __m128i rw = _mm_srai_epi16(rws, 4);
-         __m128i bw = _mm_srai_epi16(bws, 4);
-         __m128i gw = _mm_srai_epi16(gws, 4);
-
-         // back to byte, set up for transpose
-         __m128i brb = _mm_packus_epi16(rw, bw);
-         __m128i gxb = _mm_packus_epi16(gw, xw);
-
-         // transpose to interleave channels
-         __m128i t0 = _mm_unpacklo_epi8(brb, gxb);
-         __m128i t1 = _mm_unpackhi_epi8(brb, gxb);
-         __m128i o0 = _mm_unpacklo_epi16(t0, t1);
-         __m128i o1 = _mm_unpackhi_epi16(t0, t1);
-
-         // store
-         _mm_storeu_si128((__m128i *) (out + 0), o0);
-         _mm_storeu_si128((__m128i *) (out + 16), o1);
-         out += 32;
-      }
-   }
-#endif
-
-#ifdef STBI_NEON
-   // in this version, step=3 support would be easy to add. but is there demand?
-   if (step == 4) {
-      // this is a fairly straightforward implementation and not super-optimized.
-      uint8x8_t signflip = vdup_n_u8(0x80);
-      int16x8_t cr_const0 = vdupq_n_s16(   (short) ( 1.40200f*4096.0f+0.5f));
-      int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f));
-      int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f));
-      int16x8_t cb_const1 = vdupq_n_s16(   (short) ( 1.77200f*4096.0f+0.5f));
-
-      for (; i+7 < count; i += 8) {
-         // load
-         uint8x8_t y_bytes  = vld1_u8(y + i);
-         uint8x8_t cr_bytes = vld1_u8(pcr + i);
-         uint8x8_t cb_bytes = vld1_u8(pcb + i);
-         int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip));
-         int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip));
-
-         // expand to s16
-         int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4));
-         int16x8_t crw = vshll_n_s8(cr_biased, 7);
-         int16x8_t cbw = vshll_n_s8(cb_biased, 7);
-
-         // color transform
-         int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0);
-         int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0);
-         int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1);
-         int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1);
-         int16x8_t rws = vaddq_s16(yws, cr0);
-         int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1);
-         int16x8_t bws = vaddq_s16(yws, cb1);
-
-         // undo scaling, round, convert to byte
-         uint8x8x4_t o;
-         o.val[0] = vqrshrun_n_s16(rws, 4);
-         o.val[1] = vqrshrun_n_s16(gws, 4);
-         o.val[2] = vqrshrun_n_s16(bws, 4);
-         o.val[3] = vdup_n_u8(255);
-
-         // store, interleaving r/g/b/a
-         vst4_u8(out, o);
-         out += 8*4;
-      }
-   }
-#endif
-
-   for (; i < count; ++i) {
-      int y_fixed = (y[i] << 20) + (1<<19); // rounding
-      int r,g,b;
-      int cr = pcr[i] - 128;
-      int cb = pcb[i] - 128;
-      r = y_fixed + cr* float2fixed(1.40200f);
-      g = y_fixed + cr*-float2fixed(0.71414f) + ((cb*-float2fixed(0.34414f)) & 0xffff0000);
-      b = y_fixed                             +   cb* float2fixed(1.77200f);
-      r >>= 20;
-      g >>= 20;
-      b >>= 20;
-      if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
-      if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
-      if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
-      out[0] = (stbi_uc)r;
-      out[1] = (stbi_uc)g;
-      out[2] = (stbi_uc)b;
-      out[3] = 255;
-      out += step;
-   }
-}
-#endif
-
-// set up the kernels
-static void stbi__setup_jpeg(stbi__jpeg *j)
-{
-   j->idct_block_kernel = stbi__idct_block;
-   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;
-   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;
-
-#ifdef STBI_SSE2
-   if (stbi__sse2_available()) {
-      j->idct_block_kernel = stbi__idct_simd;
-      #ifndef STBI_JPEG_OLD
-      j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
-      #endif
-      j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
-   }
-#endif
-
-#ifdef STBI_NEON
-   j->idct_block_kernel = stbi__idct_simd;
-   #ifndef STBI_JPEG_OLD
-   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
-   #endif
-   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
-#endif
-}
-
-// clean up the temporary component buffers
-static void stbi__cleanup_jpeg(stbi__jpeg *j)
-{
-   int i;
-   for (i=0; i < j->s->img_n; ++i) {
-      if (j->img_comp[i].raw_data) {
-         STBI_FREE(j->img_comp[i].raw_data);
-         j->img_comp[i].raw_data = NULL;
-         j->img_comp[i].data = NULL;
-      }
-      if (j->img_comp[i].raw_coeff) {
-         STBI_FREE(j->img_comp[i].raw_coeff);
-         j->img_comp[i].raw_coeff = 0;
-         j->img_comp[i].coeff = 0;
-      }
-      if (j->img_comp[i].linebuf) {
-         STBI_FREE(j->img_comp[i].linebuf);
-         j->img_comp[i].linebuf = NULL;
-      }
-   }
-}
-
-typedef struct
-{
-   resample_row_func resample;
-   stbi_uc *line0,*line1;
-   int hs,vs;   // expansion factor in each axis
-   int w_lores; // horizontal pixels pre-expansion
-   int ystep;   // how far through vertical expansion we are
-   int ypos;    // which pre-expansion row we're on
-} stbi__resample;
-
-static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
-{
-   int n, decode_n;
-   z->s->img_n = 0; // make stbi__cleanup_jpeg safe
-
-   // validate req_comp
-   if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
-
-   // load a jpeg image from whichever source, but leave in YCbCr format
-   if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; }
-
-   // determine actual number of components to generate
-   n = req_comp ? req_comp : z->s->img_n;
-
-   if (z->s->img_n == 3 && n < 3)
-      decode_n = 1;
-   else
-      decode_n = z->s->img_n;
-
-   // resample and color-convert
-   {
-      int k;
-      unsigned int i,j;
-      stbi_uc *output;
-      stbi_uc *coutput[4];
-
-      stbi__resample res_comp[4];
-
-      for (k=0; k < decode_n; ++k) {
-         stbi__resample *r = &res_comp[k];
-
-         // allocate line buffer big enough for upsampling off the edges
-         // with upsample factor of 4
-         z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3);
-         if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
-
-         r->hs      = z->img_h_max / z->img_comp[k].h;
-         r->vs      = z->img_v_max / z->img_comp[k].v;
-         r->ystep   = r->vs >> 1;
-         r->w_lores = (z->s->img_x + r->hs-1) / r->hs;
-         r->ypos    = 0;
-         r->line0   = r->line1 = z->img_comp[k].data;
-
-         if      (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;
-         else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2;
-         else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2;
-         else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel;
-         else                               r->resample = stbi__resample_row_generic;
-      }
-
-      // can't error after this so, this is safe
-      output = (stbi_uc *) stbi__malloc(n * z->s->img_x * z->s->img_y + 1);
-      if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
-
-      // now go ahead and resample
-      for (j=0; j < z->s->img_y; ++j) {
-         stbi_uc *out = output + n * z->s->img_x * j;
-         for (k=0; k < decode_n; ++k) {
-            stbi__resample *r = &res_comp[k];
-            int y_bot = r->ystep >= (r->vs >> 1);
-            coutput[k] = r->resample(z->img_comp[k].linebuf,
-                                     y_bot ? r->line1 : r->line0,
-                                     y_bot ? r->line0 : r->line1,
-                                     r->w_lores, r->hs);
-            if (++r->ystep >= r->vs) {
-               r->ystep = 0;
-               r->line0 = r->line1;
-               if (++r->ypos < z->img_comp[k].y)
-                  r->line1 += z->img_comp[k].w2;
-            }
-         }
-         if (n >= 3) {
-            stbi_uc *y = coutput[0];
-            if (z->s->img_n == 3) {
-               z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
-            } else
-               for (i=0; i < z->s->img_x; ++i) {
-                  out[0] = out[1] = out[2] = y[i];
-                  out[3] = 255; // not used if n==3
-                  out += n;
-               }
-         } else {
-            stbi_uc *y = coutput[0];
-            if (n == 1)
-               for (i=0; i < z->s->img_x; ++i) out[i] = y[i];
-            else
-               for (i=0; i < z->s->img_x; ++i) *out++ = y[i], *out++ = 255;
-         }
-      }
-      stbi__cleanup_jpeg(z);
-      *out_x = z->s->img_x;
-      *out_y = z->s->img_y;
-      if (comp) *comp  = z->s->img_n; // report original components, not output
-      return output;
-   }
-}
-
-static unsigned char *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
-{
-   stbi__jpeg j;
-   j.s = s;
-   stbi__setup_jpeg(&j);
-   return load_jpeg_image(&j, x,y,comp,req_comp);
-}
-
-static int stbi__jpeg_test(stbi__context *s)
-{
-   int r;
-   stbi__jpeg j;
-   j.s = s;
-   stbi__setup_jpeg(&j);
-   r = stbi__decode_jpeg_header(&j, STBI__SCAN_type);
-   stbi__rewind(s);
-   return r;
-}
-
-static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)
-{
-   if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {
-      stbi__rewind( j->s );
-      return 0;
-   }
-   if (x) *x = j->s->img_x;
-   if (y) *y = j->s->img_y;
-   if (comp) *comp = j->s->img_n;
-   return 1;
-}
-
-static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)
-{
-   stbi__jpeg j;
-   j.s = s;
-   return stbi__jpeg_info_raw(&j, x, y, comp);
-}
-#endif
-
-// public domain zlib decode    v0.2  Sean Barrett 2006-11-18
-//    simple implementation
-//      - all input must be provided in an upfront buffer
-//      - all output is written to a single output buffer (can malloc/realloc)
-//    performance
-//      - fast huffman
-
-#ifndef STBI_NO_ZLIB
-
-// fast-way is faster to check than jpeg huffman, but slow way is slower
-#define STBI__ZFAST_BITS  9 // accelerate all cases in default tables
-#define STBI__ZFAST_MASK  ((1 << STBI__ZFAST_BITS) - 1)
-
-// zlib-style huffman encoding
-// (jpegs packs from left, zlib from right, so can't share code)
-typedef struct
-{
-   stbi__uint16 fast[1 << STBI__ZFAST_BITS];
-   stbi__uint16 firstcode[16];
-   int maxcode[17];
-   stbi__uint16 firstsymbol[16];
-   stbi_uc  size[288];
-   stbi__uint16 value[288];
-} stbi__zhuffman;
-
-stbi_inline static int stbi__bitreverse16(int n)
-{
-  n = ((n & 0xAAAA) >>  1) | ((n & 0x5555) << 1);
-  n = ((n & 0xCCCC) >>  2) | ((n & 0x3333) << 2);
-  n = ((n & 0xF0F0) >>  4) | ((n & 0x0F0F) << 4);
-  n = ((n & 0xFF00) >>  8) | ((n & 0x00FF) << 8);
-  return n;
-}
-
-stbi_inline static int stbi__bit_reverse(int v, int bits)
-{
-   STBI_ASSERT(bits <= 16);
-   // to bit reverse n bits, reverse 16 and shift
-   // e.g. 11 bits, bit reverse and shift away 5
-   return stbi__bitreverse16(v) >> (16-bits);
-}
-
-static int stbi__zbuild_huffman(stbi__zhuffman *z, stbi_uc *sizelist, int num)
-{
-   int i,k=0;
-   int code, next_code[16], sizes[17];
-
-   // DEFLATE spec for generating codes
-   memset(sizes, 0, sizeof(sizes));
-   memset(z->fast, 0, sizeof(z->fast));
-   for (i=0; i < num; ++i)
-      ++sizes[sizelist[i]];
-   sizes[0] = 0;
-   for (i=1; i < 16; ++i)
-      STBI_ASSERT(sizes[i] <= (1 << i));
-   code = 0;
-   for (i=1; i < 16; ++i) {
-      next_code[i] = code;
-      z->firstcode[i] = (stbi__uint16) code;
-      z->firstsymbol[i] = (stbi__uint16) k;
-      code = (code + sizes[i]);
-      if (sizes[i])
-         if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt JPEG");
-      z->maxcode[i] = code << (16-i); // preshift for inner loop
-      code <<= 1;
-      k += sizes[i];
-   }
-   z->maxcode[16] = 0x10000; // sentinel
-   for (i=0; i < num; ++i) {
-      int s = sizelist[i];
-      if (s) {
-         int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];
-         stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i);
-         z->size [c] = (stbi_uc     ) s;
-         z->value[c] = (stbi__uint16) i;
-         if (s <= STBI__ZFAST_BITS) {
-            int k = stbi__bit_reverse(next_code[s],s);
-            while (k < (1 << STBI__ZFAST_BITS)) {
-               z->fast[k] = fastv;
-               k += (1 << s);
-            }
-         }
-         ++next_code[s];
-      }
-   }
-   return 1;
-}
-
-// zlib-from-memory implementation for PNG reading
-//    because PNG allows splitting the zlib stream arbitrarily,
-//    and it's annoying structurally to have PNG call ZLIB call PNG,
-//    we require PNG read all the IDATs and combine them into a single
-//    memory buffer
-
-typedef struct
-{
-   stbi_uc *zbuffer, *zbuffer_end;
-   int num_bits;
-   stbi__uint32 code_buffer;
-
-   char *zout;
-   char *zout_start;
-   char *zout_end;
-   int   z_expandable;
-
-   stbi__zhuffman z_length, z_distance;
-} stbi__zbuf;
-
-stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)
-{
-   if (z->zbuffer >= z->zbuffer_end) return 0;
-   return *z->zbuffer++;
-}
-
-static void stbi__fill_bits(stbi__zbuf *z)
-{
-   do {
-      STBI_ASSERT(z->code_buffer < (1U << z->num_bits));
-      z->code_buffer |= stbi__zget8(z) << z->num_bits;
-      z->num_bits += 8;
-   } while (z->num_bits <= 24);
-}
-
-stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)
-{
-   unsigned int k;
-   if (z->num_bits < n) stbi__fill_bits(z);
-   k = z->code_buffer & ((1 << n) - 1);
-   z->code_buffer >>= n;
-   z->num_bits -= n;
-   return k;
-}
-
-static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
-{
-   int b,s,k;
-   // not resolved by fast table, so compute it the slow way
-   // use jpeg approach, which requires MSbits at top
-   k = stbi__bit_reverse(a->code_buffer, 16);
-   for (s=STBI__ZFAST_BITS+1; ; ++s)
-      if (k < z->maxcode[s])
-         break;
-   if (s == 16) return -1; // invalid code!
-   // code size is s, so:
-   b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
-   STBI_ASSERT(z->size[b] == s);
-   a->code_buffer >>= s;
-   a->num_bits -= s;
-   return z->value[b];
-}
-
-stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
-{
-   int b,s;
-   if (a->num_bits < 16) stbi__fill_bits(a);
-   b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
-   if (b) {
-      s = b >> 9;
-      a->code_buffer >>= s;
-      a->num_bits -= s;
-      return b & 511;
-   }
-   return stbi__zhuffman_decode_slowpath(a, z);
-}
-
-static int stbi__zexpand(stbi__zbuf *z, char *zout, int n)  // need to make room for n bytes
-{
-   char *q;
-   int cur, limit;
-   z->zout = zout;
-   if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
-   cur   = (int) (z->zout     - z->zout_start);
-   limit = (int) (z->zout_end - z->zout_start);
-   while (cur + n > limit)
-      limit *= 2;
-   q = (char *) STBI_REALLOC(z->zout_start, limit);
-   if (q == NULL) return stbi__err("outofmem", "Out of memory");
-   z->zout_start = q;
-   z->zout       = q + cur;
-   z->zout_end   = q + limit;
-   return 1;
-}
-
-static int stbi__zlength_base[31] = {
-   3,4,5,6,7,8,9,10,11,13,
-   15,17,19,23,27,31,35,43,51,59,
-   67,83,99,115,131,163,195,227,258,0,0 };
-
-static int stbi__zlength_extra[31]=
-{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 };
-
-static int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
-257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
-
-static int stbi__zdist_extra[32] =
-{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
-
-static int stbi__parse_huffman_block(stbi__zbuf *a)
-{
-   char *zout = a->zout;
-   for(;;) {
-      int z = stbi__zhuffman_decode(a, &a->z_length);
-      if (z < 256) {
-         if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes
-         if (zout >= a->zout_end) {
-            if (!stbi__zexpand(a, zout, 1)) return 0;
-            zout = a->zout;
-         }
-         *zout++ = (char) z;
-      } else {
-         stbi_uc *p;
-         int len,dist;
-         if (z == 256) {
-            a->zout = zout;
-            return 1;
-         }
-         z -= 257;
-         len = stbi__zlength_base[z];
-         if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);
-         z = stbi__zhuffman_decode(a, &a->z_distance);
-         if (z < 0) return stbi__err("bad huffman code","Corrupt PNG");
-         dist = stbi__zdist_base[z];
-         if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);
-         if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG");
-         if (zout + len > a->zout_end) {
-            if (!stbi__zexpand(a, zout, len)) return 0;
-            zout = a->zout;
-         }
-         p = (stbi_uc *) (zout - dist);
-         if (dist == 1) { // run of one byte; common in images.
-            stbi_uc v = *p;
-            do *zout++ = v; while (--len);
-         } else {
-            do *zout++ = *p++; while (--len);
-         }
-      }
-   }
-}
-
-static int stbi__compute_huffman_codes(stbi__zbuf *a)
-{
-   static stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
-   stbi__zhuffman z_codelength;
-   stbi_uc lencodes[286+32+137];//padding for maximum single op
-   stbi_uc codelength_sizes[19];
-   int i,n;
-
-   int hlit  = stbi__zreceive(a,5) + 257;
-   int hdist = stbi__zreceive(a,5) + 1;
-   int hclen = stbi__zreceive(a,4) + 4;
-
-   memset(codelength_sizes, 0, sizeof(codelength_sizes));
-   for (i=0; i < hclen; ++i) {
-      int s = stbi__zreceive(a,3);
-      codelength_sizes[length_dezigzag[i]] = (stbi_uc) s;
-   }
-   if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
-
-   n = 0;
-   while (n < hlit + hdist) {
-      int c = stbi__zhuffman_decode(a, &z_codelength);
-      STBI_ASSERT(c >= 0 && c < 19);
-      if (c < 16)
-         lencodes[n++] = (stbi_uc) c;
-      else if (c == 16) {
-         c = stbi__zreceive(a,2)+3;
-         memset(lencodes+n, lencodes[n-1], c);
-         n += c;
-      } else if (c == 17) {
-         c = stbi__zreceive(a,3)+3;
-         memset(lencodes+n, 0, c);
-         n += c;
-      } else {
-         STBI_ASSERT(c == 18);
-         c = stbi__zreceive(a,7)+11;
-         memset(lencodes+n, 0, c);
-         n += c;
-      }
-   }
-   if (n != hlit+hdist) return stbi__err("bad codelengths","Corrupt PNG");
-   if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;
-   if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;
-   return 1;
-}
-
-static int stbi__parse_uncomperssed_block(stbi__zbuf *a)
-{
-   stbi_uc header[4];
-   int len,nlen,k;
-   if (a->num_bits & 7)
-      stbi__zreceive(a, a->num_bits & 7); // discard
-   // drain the bit-packed data into header
-   k = 0;
-   while (a->num_bits > 0) {
-      header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check
-      a->code_buffer >>= 8;
-      a->num_bits -= 8;
-   }
-   STBI_ASSERT(a->num_bits == 0);
-   // now fill header the normal way
-   while (k < 4)
-      header[k++] = stbi__zget8(a);
-   len  = header[1] * 256 + header[0];
-   nlen = header[3] * 256 + header[2];
-   if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG");
-   if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG");
-   if (a->zout + len > a->zout_end)
-      if (!stbi__zexpand(a, a->zout, len)) return 0;
-   memcpy(a->zout, a->zbuffer, len);
-   a->zbuffer += len;
-   a->zout += len;
-   return 1;
-}
-
-static int stbi__parse_zlib_header(stbi__zbuf *a)
-{
-   int cmf   = stbi__zget8(a);
-   int cm    = cmf & 15;
-   /* int cinfo = cmf >> 4; */
-   int flg   = stbi__zget8(a);
-   if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
-   if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
-   if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png
-   // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
-   return 1;
-}
-
-// @TODO: should statically initialize these for optimal thread safety
-static stbi_uc stbi__zdefault_length[288], stbi__zdefault_distance[32];
-static void stbi__init_zdefaults(void)
-{
-   int i;   // use <= to match clearly with spec
-   for (i=0; i <= 143; ++i)     stbi__zdefault_length[i]   = 8;
-   for (   ; i <= 255; ++i)     stbi__zdefault_length[i]   = 9;
-   for (   ; i <= 279; ++i)     stbi__zdefault_length[i]   = 7;
-   for (   ; i <= 287; ++i)     stbi__zdefault_length[i]   = 8;
-
-   for (i=0; i <=  31; ++i)     stbi__zdefault_distance[i] = 5;
-}
-
-static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
-{
-   int final, type;
-   if (parse_header)
-      if (!stbi__parse_zlib_header(a)) return 0;
-   a->num_bits = 0;
-   a->code_buffer = 0;
-   do {
-      final = stbi__zreceive(a,1);
-      type = stbi__zreceive(a,2);
-      if (type == 0) {
-         if (!stbi__parse_uncomperssed_block(a)) return 0;
-      } else if (type == 3) {
-         return 0;
-      } else {
-         if (type == 1) {
-            // use fixed code lengths
-            if (!stbi__zdefault_distance[31]) stbi__init_zdefaults();
-            if (!stbi__zbuild_huffman(&a->z_length  , stbi__zdefault_length  , 288)) return 0;
-            if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance,  32)) return 0;
-         } else {
-            if (!stbi__compute_huffman_codes(a)) return 0;
-         }
-         if (!stbi__parse_huffman_block(a)) return 0;
-      }
-   } while (!final);
-   return 1;
-}
-
-static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)
-{
-   a->zout_start = obuf;
-   a->zout       = obuf;
-   a->zout_end   = obuf + olen;
-   a->z_expandable = exp;
-
-   return stbi__parse_zlib(a, parse_header);
-}
-
-STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
-{
-   stbi__zbuf a;
-   char *p = (char *) stbi__malloc(initial_size);
-   if (p == NULL) return NULL;
-   a.zbuffer = (stbi_uc *) buffer;
-   a.zbuffer_end = (stbi_uc *) buffer + len;
-   if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
-      if (outlen) *outlen = (int) (a.zout - a.zout_start);
-      return a.zout_start;
-   } else {
-      STBI_FREE(a.zout_start);
-      return NULL;
-   }
-}
-
-STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
-{
-   return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
-}
-
-STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
-{
-   stbi__zbuf a;
-   char *p = (char *) stbi__malloc(initial_size);
-   if (p == NULL) return NULL;
-   a.zbuffer = (stbi_uc *) buffer;
-   a.zbuffer_end = (stbi_uc *) buffer + len;
-   if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
-      if (outlen) *outlen = (int) (a.zout - a.zout_start);
-      return a.zout_start;
-   } else {
-      STBI_FREE(a.zout_start);
-      return NULL;
-   }
-}
-
-STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
-{
-   stbi__zbuf a;
-   a.zbuffer = (stbi_uc *) ibuffer;
-   a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
-   if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
-      return (int) (a.zout - a.zout_start);
-   else
-      return -1;
-}
-
-STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
-{
-   stbi__zbuf a;
-   char *p = (char *) stbi__malloc(16384);
-   if (p == NULL) return NULL;
-   a.zbuffer = (stbi_uc *) buffer;
-   a.zbuffer_end = (stbi_uc *) buffer+len;
-   if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
-      if (outlen) *outlen = (int) (a.zout - a.zout_start);
-      return a.zout_start;
-   } else {
-      STBI_FREE(a.zout_start);
-      return NULL;
-   }
-}
-
-STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
-{
-   stbi__zbuf a;
-   a.zbuffer = (stbi_uc *) ibuffer;
-   a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
-   if (stbi__do_zlib(&a, obuffer, olen, 0, 0))
-      return (int) (a.zout - a.zout_start);
-   else
-      return -1;
-}
-#endif
-
-// public domain "baseline" PNG decoder   v0.10  Sean Barrett 2006-11-18
-//    simple implementation
-//      - only 8-bit samples
-//      - no CRC checking
-//      - allocates lots of intermediate memory
-//        - avoids problem of streaming data between subsystems
-//        - avoids explicit window management
-//    performance
-//      - uses stb_zlib, a PD zlib implementation with fast huffman decoding
-
-#ifndef STBI_NO_PNG
-typedef struct
-{
-   stbi__uint32 length;
-   stbi__uint32 type;
-} stbi__pngchunk;
-
-static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)
-{
-   stbi__pngchunk c;
-   c.length = stbi__get32be(s);
-   c.type   = stbi__get32be(s);
-   return c;
-}
-
-static int stbi__check_png_header(stbi__context *s)
-{
-   static stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
-   int i;
-   for (i=0; i < 8; ++i)
-      if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG");
-   return 1;
-}
-
-typedef struct
-{
-   stbi__context *s;
-   stbi_uc *idata, *expanded, *out;
-} stbi__png;
-
-
-enum {
-   STBI__F_none=0,
-   STBI__F_sub=1,
-   STBI__F_up=2,
-   STBI__F_avg=3,
-   STBI__F_paeth=4,
-   // synthetic filters used for first scanline to avoid needing a dummy row of 0s
-   STBI__F_avg_first,
-   STBI__F_paeth_first
-};
-
-static stbi_uc first_row_filter[5] =
-{
-   STBI__F_none,
-   STBI__F_sub,
-   STBI__F_none,
-   STBI__F_avg_first,
-   STBI__F_paeth_first
-};
-
-static int stbi__paeth(int a, int b, int c)
-{
-   int p = a + b - c;
-   int pa = abs(p-a);
-   int pb = abs(p-b);
-   int pc = abs(p-c);
-   if (pa <= pb && pa <= pc) return a;
-   if (pb <= pc) return b;
-   return c;
-}
-
-static stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };
-
-// create the png data from post-deflated data
-static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)
-{
-   stbi__context *s = a->s;
-   stbi__uint32 i,j,stride = x*out_n;
-   stbi__uint32 img_len, img_width_bytes;
-   int k;
-   int img_n = s->img_n; // copy it into a local for later
-
-   STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1);
-   a->out = (stbi_uc *) stbi__malloc(x * y * out_n); // extra bytes to write off the end into
-   if (!a->out) return stbi__err("outofmem", "Out of memory");
-
-   img_width_bytes = (((img_n * x * depth) + 7) >> 3);
-   img_len = (img_width_bytes + 1) * y;
-   if (s->img_x == x && s->img_y == y) {
-      if (raw_len != img_len) return stbi__err("not enough pixels","Corrupt PNG");
-   } else { // interlaced:
-      if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG");
-   }
-
-   for (j=0; j < y; ++j) {
-      stbi_uc *cur = a->out + stride*j;
-      stbi_uc *prior = cur - stride;
-      int filter = *raw++;
-      int filter_bytes = img_n;
-      int width = x;
-      if (filter > 4)
-         return stbi__err("invalid filter","Corrupt PNG");
-
-      if (depth < 8) {
-         STBI_ASSERT(img_width_bytes <= x);
-         cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place
-         filter_bytes = 1;
-         width = img_width_bytes;
-      }
-
-      // if first row, use special filter that doesn't sample previous row
-      if (j == 0) filter = first_row_filter[filter];
-
-      // handle first byte explicitly
-      for (k=0; k < filter_bytes; ++k) {
-         switch (filter) {
-            case STBI__F_none       : cur[k] = raw[k]; break;
-            case STBI__F_sub        : cur[k] = raw[k]; break;
-            case STBI__F_up         : cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break;
-            case STBI__F_avg        : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); break;
-            case STBI__F_paeth      : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0)); break;
-            case STBI__F_avg_first  : cur[k] = raw[k]; break;
-            case STBI__F_paeth_first: cur[k] = raw[k]; break;
-         }
-      }
-
-      if (depth == 8) {
-         if (img_n != out_n)
-            cur[img_n] = 255; // first pixel
-         raw += img_n;
-         cur += out_n;
-         prior += out_n;
-      } else {
-         raw += 1;
-         cur += 1;
-         prior += 1;
-      }
-
-      // this is a little gross, so that we don't switch per-pixel or per-component
-      if (depth < 8 || img_n == out_n) {
-         int nk = (width - 1)*img_n;
-         #define CASE(f) \
-             case f:     \
-                for (k=0; k < nk; ++k)
-         switch (filter) {
-            // "none" filter turns into a memcpy here; make that explicit.
-            case STBI__F_none:         memcpy(cur, raw, nk); break;
-            CASE(STBI__F_sub)          cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); break;
-            CASE(STBI__F_up)           cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break;
-            CASE(STBI__F_avg)          cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); break;
-            CASE(STBI__F_paeth)        cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); break;
-            CASE(STBI__F_avg_first)    cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); break;
-            CASE(STBI__F_paeth_first)  cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); break;
-         }
-         #undef CASE
-         raw += nk;
-      } else {
-         STBI_ASSERT(img_n+1 == out_n);
-         #define CASE(f) \
-             case f:     \
-                for (i=x-1; i >= 1; --i, cur[img_n]=255,raw+=img_n,cur+=out_n,prior+=out_n) \
-                   for (k=0; k < img_n; ++k)
-         switch (filter) {
-            CASE(STBI__F_none)         cur[k] = raw[k]; break;
-            CASE(STBI__F_sub)          cur[k] = STBI__BYTECAST(raw[k] + cur[k-out_n]); break;
-            CASE(STBI__F_up)           cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break;
-            CASE(STBI__F_avg)          cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-out_n])>>1)); break;
-            CASE(STBI__F_paeth)        cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-out_n],prior[k],prior[k-out_n])); break;
-            CASE(STBI__F_avg_first)    cur[k] = STBI__BYTECAST(raw[k] + (cur[k-out_n] >> 1)); break;
-            CASE(STBI__F_paeth_first)  cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-out_n],0,0)); break;
-         }
-         #undef CASE
-      }
-   }
-
-   // we make a separate pass to expand bits to pixels; for performance,
-   // this could run two scanlines behind the above code, so it won't
-   // intefere with filtering but will still be in the cache.
-   if (depth < 8) {
-      for (j=0; j < y; ++j) {
-         stbi_uc *cur = a->out + stride*j;
-         stbi_uc *in  = a->out + stride*j + x*out_n - img_width_bytes;
-         // unpack 1/2/4-bit into a 8-bit buffer. allows us to keep the common 8-bit path optimal at minimal cost for 1/2/4-bit
-         // png guarante byte alignment, if width is not multiple of 8/4/2 we'll decode dummy trailing data that will be skipped in the later loop
-         stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range
-
-         // note that the final byte might overshoot and write more data than desired.
-         // we can allocate enough data that this never writes out of memory, but it
-         // could also overwrite the next scanline. can it overwrite non-empty data
-         // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel.
-         // so we need to explicitly clamp the final ones
-
-         if (depth == 4) {
-            for (k=x*img_n; k >= 2; k-=2, ++in) {
-               *cur++ = scale * ((*in >> 4)       );
-               *cur++ = scale * ((*in     ) & 0x0f);
-            }
-            if (k > 0) *cur++ = scale * ((*in >> 4)       );
-         } else if (depth == 2) {
-            for (k=x*img_n; k >= 4; k-=4, ++in) {
-               *cur++ = scale * ((*in >> 6)       );
-               *cur++ = scale * ((*in >> 4) & 0x03);
-               *cur++ = scale * ((*in >> 2) & 0x03);
-               *cur++ = scale * ((*in     ) & 0x03);
-            }
-            if (k > 0) *cur++ = scale * ((*in >> 6)       );
-            if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03);
-            if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03);
-         } else if (depth == 1) {
-            for (k=x*img_n; k >= 8; k-=8, ++in) {
-               *cur++ = scale * ((*in >> 7)       );
-               *cur++ = scale * ((*in >> 6) & 0x01);
-               *cur++ = scale * ((*in >> 5) & 0x01);
-               *cur++ = scale * ((*in >> 4) & 0x01);
-               *cur++ = scale * ((*in >> 3) & 0x01);
-               *cur++ = scale * ((*in >> 2) & 0x01);
-               *cur++ = scale * ((*in >> 1) & 0x01);
-               *cur++ = scale * ((*in     ) & 0x01);
-            }
-            if (k > 0) *cur++ = scale * ((*in >> 7)       );
-            if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01);
-            if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01);
-            if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01);
-            if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01);
-            if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01);
-            if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01);
-         }
-         if (img_n != out_n) {
-            // insert alpha = 255
-            stbi_uc *cur = a->out + stride*j;
-            int i;
-            if (img_n == 1) {
-               for (i=x-1; i >= 0; --i) {
-                  cur[i*2+1] = 255;
-                  cur[i*2+0] = cur[i];
-               }
-            } else {
-               STBI_ASSERT(img_n == 3);
-               for (i=x-1; i >= 0; --i) {
-                  cur[i*4+3] = 255;
-                  cur[i*4+2] = cur[i*3+2];
-                  cur[i*4+1] = cur[i*3+1];
-                  cur[i*4+0] = cur[i*3+0];
-               }
-            }
-         }
-      }
-   }
-
-   return 1;
-}
-
-static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced)
-{
-   stbi_uc *final;
-   int p;
-   if (!interlaced)
-      return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);
-
-   // de-interlacing
-   final = (stbi_uc *) stbi__malloc(a->s->img_x * a->s->img_y * out_n);
-   for (p=0; p < 7; ++p) {
-      int xorig[] = { 0,4,0,2,0,1,0 };
-      int yorig[] = { 0,0,4,0,2,0,1 };
-      int xspc[]  = { 8,8,4,4,2,2,1 };
-      int yspc[]  = { 8,8,8,4,4,2,2 };
-      int i,j,x,y;
-      // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1
-      x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];
-      y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];
-      if (x && y) {
-         stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y;
-         if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) {
-            STBI_FREE(final);
-            return 0;
-         }
-         for (j=0; j < y; ++j) {
-            for (i=0; i < x; ++i) {
-               int out_y = j*yspc[p]+yorig[p];
-               int out_x = i*xspc[p]+xorig[p];
-               memcpy(final + out_y*a->s->img_x*out_n + out_x*out_n,
-                      a->out + (j*x+i)*out_n, out_n);
-            }
-         }
-         STBI_FREE(a->out);
-         image_data += img_len;
-         image_data_len -= img_len;
-      }
-   }
-   a->out = final;
-
-   return 1;
-}
-
-static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)
-{
-   stbi__context *s = z->s;
-   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
-   stbi_uc *p = z->out;
-
-   // compute color-based transparency, assuming we've
-   // already got 255 as the alpha value in the output
-   STBI_ASSERT(out_n == 2 || out_n == 4);
-
-   if (out_n == 2) {
-      for (i=0; i < pixel_count; ++i) {
-         p[1] = (p[0] == tc[0] ? 0 : 255);
-         p += 2;
-      }
-   } else {
-      for (i=0; i < pixel_count; ++i) {
-         if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
-            p[3] = 0;
-         p += 4;
-      }
-   }
-   return 1;
-}
-
-static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)
-{
-   stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
-   stbi_uc *p, *temp_out, *orig = a->out;
-
-   p = (stbi_uc *) stbi__malloc(pixel_count * pal_img_n);
-   if (p == NULL) return stbi__err("outofmem", "Out of memory");
-
-   // between here and free(out) below, exitting would leak
-   temp_out = p;
-
-   if (pal_img_n == 3) {
-      for (i=0; i < pixel_count; ++i) {
-         int n = orig[i]*4;
-         p[0] = palette[n  ];
-         p[1] = palette[n+1];
-         p[2] = palette[n+2];
-         p += 3;
-      }
-   } else {
-      for (i=0; i < pixel_count; ++i) {
-         int n = orig[i]*4;
-         p[0] = palette[n  ];
-         p[1] = palette[n+1];
-         p[2] = palette[n+2];
-         p[3] = palette[n+3];
-         p += 4;
-      }
-   }
-   STBI_FREE(a->out);
-   a->out = temp_out;
-
-   STBI_NOTUSED(len);
-
-   return 1;
-}
-
-static int stbi__unpremultiply_on_load = 0;
-static int stbi__de_iphone_flag = 0;
-
-STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
-{
-   stbi__unpremultiply_on_load = flag_true_if_should_unpremultiply;
-}
-
-STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
-{
-   stbi__de_iphone_flag = flag_true_if_should_convert;
-}
-
-static void stbi__de_iphone(stbi__png *z)
-{
-   stbi__context *s = z->s;
-   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
-   stbi_uc *p = z->out;
-
-   if (s->img_out_n == 3) {  // convert bgr to rgb
-      for (i=0; i < pixel_count; ++i) {
-         stbi_uc t = p[0];
-         p[0] = p[2];
-         p[2] = t;
-         p += 3;
-      }
-   } else {
-      STBI_ASSERT(s->img_out_n == 4);
-      if (stbi__unpremultiply_on_load) {
-         // convert bgr to rgb and unpremultiply
-         for (i=0; i < pixel_count; ++i) {
-            stbi_uc a = p[3];
-            stbi_uc t = p[0];
-            if (a) {
-               p[0] = p[2] * 255 / a;
-               p[1] = p[1] * 255 / a;
-               p[2] =  t   * 255 / a;
-            } else {
-               p[0] = p[2];
-               p[2] = t;
-            }
-            p += 4;
-         }
-      } else {
-         // convert bgr to rgb
-         for (i=0; i < pixel_count; ++i) {
-            stbi_uc t = p[0];
-            p[0] = p[2];
-            p[2] = t;
-            p += 4;
-         }
-      }
-   }
-}
-
-#define STBI__PNG_TYPE(a,b,c,d)  (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
-
-static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
-{
-   stbi_uc palette[1024], pal_img_n=0;
-   stbi_uc has_trans=0, tc[3];
-   stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
-   int first=1,k,interlace=0, color=0, depth=0, is_iphone=0;
-   stbi__context *s = z->s;
-
-   z->expanded = NULL;
-   z->idata = NULL;
-   z->out = NULL;
-
-   if (!stbi__check_png_header(s)) return 0;
-
-   if (scan == STBI__SCAN_type) return 1;
-
-   for (;;) {
-      stbi__pngchunk c = stbi__get_chunk_header(s);
-      switch (c.type) {
-         case STBI__PNG_TYPE('C','g','B','I'):
-            is_iphone = 1;
-            stbi__skip(s, c.length);
-            break;
-         case STBI__PNG_TYPE('I','H','D','R'): {
-            int comp,filter;
-            if (!first) return stbi__err("multiple IHDR","Corrupt PNG");
-            first = 0;
-            if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG");
-            s->img_x = stbi__get32be(s); if (s->img_x > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)");
-            s->img_y = stbi__get32be(s); if (s->img_y > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)");
-            depth = stbi__get8(s);  if (depth != 1 && depth != 2 && depth != 4 && depth != 8)  return stbi__err("1/2/4/8-bit only","PNG not supported: 1/2/4/8-bit only");
-            color = stbi__get8(s);  if (color > 6)         return stbi__err("bad ctype","Corrupt PNG");
-            if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG");
-            comp  = stbi__get8(s);  if (comp) return stbi__err("bad comp method","Corrupt PNG");
-            filter= stbi__get8(s);  if (filter) return stbi__err("bad filter method","Corrupt PNG");
-            interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG");
-            if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG");
-            if (!pal_img_n) {
-               s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
-               if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode");
-               if (scan == STBI__SCAN_header) return 1;
-            } else {
-               // if paletted, then pal_n is our final components, and
-               // img_n is # components to decompress/filter.
-               s->img_n = 1;
-               if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG");
-               // if SCAN_header, have to scan to see if we have a tRNS
-            }
-            break;
-         }
-
-         case STBI__PNG_TYPE('P','L','T','E'):  {
-            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
-            if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG");
-            pal_len = c.length / 3;
-            if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG");
-            for (i=0; i < pal_len; ++i) {
-               palette[i*4+0] = stbi__get8(s);
-               palette[i*4+1] = stbi__get8(s);
-               palette[i*4+2] = stbi__get8(s);
-               palette[i*4+3] = 255;
-            }
-            break;
-         }
-
-         case STBI__PNG_TYPE('t','R','N','S'): {
-            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
-            if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG");
-            if (pal_img_n) {
-               if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; }
-               if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG");
-               if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG");
-               pal_img_n = 4;
-               for (i=0; i < c.length; ++i)
-                  palette[i*4+3] = stbi__get8(s);
-            } else {
-               if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG");
-               if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG");
-               has_trans = 1;
-               for (k=0; k < s->img_n; ++k)
-                  tc[k] = (stbi_uc) (stbi__get16be(s) & 255) * stbi__depth_scale_table[depth]; // non 8-bit images will be larger
-            }
-            break;
-         }
-
-         case STBI__PNG_TYPE('I','D','A','T'): {
-            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
-            if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG");
-            if (scan == STBI__SCAN_header) { s->img_n = pal_img_n; return 1; }
-            if (ioff + c.length > idata_limit) {
-               stbi_uc *p;
-               if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
-               while (ioff + c.length > idata_limit)
-                  idata_limit *= 2;
-               p = (stbi_uc *) STBI_REALLOC(z->idata, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory");
-               z->idata = p;
-            }
-            if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG");
-            ioff += c.length;
-            break;
-         }
-
-         case STBI__PNG_TYPE('I','E','N','D'): {
-            stbi__uint32 raw_len, bpl;
-            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
-            if (scan != STBI__SCAN_load) return 1;
-            if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG");
-            // initial guess for decoded data size to avoid unnecessary reallocs
-            bpl = (s->img_x * depth + 7) / 8; // bytes per line, per component
-            raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */;
-            z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone);
-            if (z->expanded == NULL) return 0; // zlib should set error
-            STBI_FREE(z->idata); z->idata = NULL;
-            if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
-               s->img_out_n = s->img_n+1;
-            else
-               s->img_out_n = s->img_n;
-            if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, depth, color, interlace)) return 0;
-            if (has_trans)
-               if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0;
-            if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2)
-               stbi__de_iphone(z);
-            if (pal_img_n) {
-               // pal_img_n == 3 or 4
-               s->img_n = pal_img_n; // record the actual colors we had
-               s->img_out_n = pal_img_n;
-               if (req_comp >= 3) s->img_out_n = req_comp;
-               if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))
-                  return 0;
-            }
-            STBI_FREE(z->expanded); z->expanded = NULL;
-            return 1;
-         }
-
-         default:
-            // if critical, fail
-            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
-            if ((c.type & (1 << 29)) == 0) {
-               #ifndef STBI_NO_FAILURE_STRINGS
-               // not threadsafe
-               static char invalid_chunk[] = "XXXX PNG chunk not known";
-               invalid_chunk[0] = STBI__BYTECAST(c.type >> 24);
-               invalid_chunk[1] = STBI__BYTECAST(c.type >> 16);
-               invalid_chunk[2] = STBI__BYTECAST(c.type >>  8);
-               invalid_chunk[3] = STBI__BYTECAST(c.type >>  0);
-               #endif
-               return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type");
-            }
-            stbi__skip(s, c.length);
-            break;
-      }
-      // end of PNG chunk, read and skip CRC
-      stbi__get32be(s);
-   }
-}
-
-static unsigned char *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp)
-{
-   unsigned char *result=NULL;
-   if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
-   if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {
-      result = p->out;
-      p->out = NULL;
-      if (req_comp && req_comp != p->s->img_out_n) {
-         result = stbi__convert_format(result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
-         p->s->img_out_n = req_comp;
-         if (result == NULL) return result;
-      }
-      *x = p->s->img_x;
-      *y = p->s->img_y;
-      if (n) *n = p->s->img_out_n;
-   }
-   STBI_FREE(p->out);      p->out      = NULL;
-   STBI_FREE(p->expanded); p->expanded = NULL;
-   STBI_FREE(p->idata);    p->idata    = NULL;
-
-   return result;
-}
-
-static unsigned char *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
-{
-   stbi__png p;
-   p.s = s;
-   return stbi__do_png(&p, x,y,comp,req_comp);
-}
-
-static int stbi__png_test(stbi__context *s)
-{
-   int r;
-   r = stbi__check_png_header(s);
-   stbi__rewind(s);
-   return r;
-}
-
-static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)
-{
-   if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {
-      stbi__rewind( p->s );
-      return 0;
-   }
-   if (x) *x = p->s->img_x;
-   if (y) *y = p->s->img_y;
-   if (comp) *comp = p->s->img_n;
-   return 1;
-}
-
-static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)
-{
-   stbi__png p;
-   p.s = s;
-   return stbi__png_info_raw(&p, x, y, comp);
-}
-#endif
-
-// Microsoft/Windows BMP image
-
-#ifndef STBI_NO_BMP
-static int stbi__bmp_test_raw(stbi__context *s)
-{
-   int r;
-   int sz;
-   if (stbi__get8(s) != 'B') return 0;
-   if (stbi__get8(s) != 'M') return 0;
-   stbi__get32le(s); // discard filesize
-   stbi__get16le(s); // discard reserved
-   stbi__get16le(s); // discard reserved
-   stbi__get32le(s); // discard data offset
-   sz = stbi__get32le(s);
-   r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);
-   return r;
-}
-
-static int stbi__bmp_test(stbi__context *s)
-{
-   int r = stbi__bmp_test_raw(s);
-   stbi__rewind(s);
-   return r;
-}
-
-
-// returns 0..31 for the highest set bit
-static int stbi__high_bit(unsigned int z)
-{
-   int n=0;
-   if (z == 0) return -1;
-   if (z >= 0x10000) n += 16, z >>= 16;
-   if (z >= 0x00100) n +=  8, z >>=  8;
-   if (z >= 0x00010) n +=  4, z >>=  4;
-   if (z >= 0x00004) n +=  2, z >>=  2;
-   if (z >= 0x00002) n +=  1, z >>=  1;
-   return n;
-}
-
-static int stbi__bitcount(unsigned int a)
-{
-   a = (a & 0x55555555) + ((a >>  1) & 0x55555555); // max 2
-   a = (a & 0x33333333) + ((a >>  2) & 0x33333333); // max 4
-   a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
-   a = (a + (a >> 8)); // max 16 per 8 bits
-   a = (a + (a >> 16)); // max 32 per 8 bits
-   return a & 0xff;
-}
-
-static int stbi__shiftsigned(int v, int shift, int bits)
-{
-   int result;
-   int z=0;
-
-   if (shift < 0) v <<= -shift;
-   else v >>= shift;
-   result = v;
-
-   z = bits;
-   while (z < 8) {
-      result += v >> z;
-      z += bits;
-   }
-   return result;
-}
-
-static stbi_uc *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
-{
-   stbi_uc *out;
-   unsigned int mr=0,mg=0,mb=0,ma=0, fake_a=0;
-   stbi_uc pal[256][4];
-   int psize=0,i,j,compress=0,width;
-   int bpp, flip_vertically, pad, target, offset, hsz;
-   if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP");
-   stbi__get32le(s); // discard filesize
-   stbi__get16le(s); // discard reserved
-   stbi__get16le(s); // discard reserved
-   offset = stbi__get32le(s);
-   hsz = stbi__get32le(s);
-   if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown");
-   if (hsz == 12) {
-      s->img_x = stbi__get16le(s);
-      s->img_y = stbi__get16le(s);
-   } else {
-      s->img_x = stbi__get32le(s);
-      s->img_y = stbi__get32le(s);
-   }
-   if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP");
-   bpp = stbi__get16le(s);
-   if (bpp == 1) return stbi__errpuc("monochrome", "BMP type not supported: 1-bit");
-   flip_vertically = ((int) s->img_y) > 0;
-   s->img_y = abs((int) s->img_y);
-   if (hsz == 12) {
-      if (bpp < 24)
-         psize = (offset - 14 - 24) / 3;
-   } else {
-      compress = stbi__get32le(s);
-      if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE");
-      stbi__get32le(s); // discard sizeof
-      stbi__get32le(s); // discard hres
-      stbi__get32le(s); // discard vres
-      stbi__get32le(s); // discard colorsused
-      stbi__get32le(s); // discard max important
-      if (hsz == 40 || hsz == 56) {
-         if (hsz == 56) {
-            stbi__get32le(s);
-            stbi__get32le(s);
-            stbi__get32le(s);
-            stbi__get32le(s);
-         }
-         if (bpp == 16 || bpp == 32) {
-            mr = mg = mb = 0;
-            if (compress == 0) {
-               if (bpp == 32) {
-                  mr = 0xffu << 16;
-                  mg = 0xffu <<  8;
-                  mb = 0xffu <<  0;
-                  ma = 0xffu << 24;
-                  fake_a = 1; // @TODO: check for cases like alpha value is all 0 and switch it to 255
-                  STBI_NOTUSED(fake_a);
-               } else {
-                  mr = 31u << 10;
-                  mg = 31u <<  5;
-                  mb = 31u <<  0;
-               }
-            } else if (compress == 3) {
-               mr = stbi__get32le(s);
-               mg = stbi__get32le(s);
-               mb = stbi__get32le(s);
-               // not documented, but generated by photoshop and handled by mspaint
-               if (mr == mg && mg == mb) {
-                  // ?!?!?
-                  return stbi__errpuc("bad BMP", "bad BMP");
-               }
-            } else
-               return stbi__errpuc("bad BMP", "bad BMP");
-         }
-      } else {
-         STBI_ASSERT(hsz == 108 || hsz == 124);
-         mr = stbi__get32le(s);
-         mg = stbi__get32le(s);
-         mb = stbi__get32le(s);
-         ma = stbi__get32le(s);
-         stbi__get32le(s); // discard color space
-         for (i=0; i < 12; ++i)
-            stbi__get32le(s); // discard color space parameters
-         if (hsz == 124) {
-            stbi__get32le(s); // discard rendering intent
-            stbi__get32le(s); // discard offset of profile data
-            stbi__get32le(s); // discard size of profile data
-            stbi__get32le(s); // discard reserved
-         }
-      }
-      if (bpp < 16)
-         psize = (offset - 14 - hsz) >> 2;
-   }
-   s->img_n = ma ? 4 : 3;
-   if (req_comp && req_comp >= 3) // we can directly decode 3 or 4
-      target = req_comp;
-   else
-      target = s->img_n; // if they want monochrome, we'll post-convert
-   out = (stbi_uc *) stbi__malloc(target * s->img_x * s->img_y);
-   if (!out) return stbi__errpuc("outofmem", "Out of memory");
-   if (bpp < 16) {
-      int z=0;
-      if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); }
-      for (i=0; i < psize; ++i) {
-         pal[i][2] = stbi__get8(s);
-         pal[i][1] = stbi__get8(s);
-         pal[i][0] = stbi__get8(s);
-         if (hsz != 12) stbi__get8(s);
-         pal[i][3] = 255;
-      }
-      stbi__skip(s, offset - 14 - hsz - psize * (hsz == 12 ? 3 : 4));
-      if (bpp == 4) width = (s->img_x + 1) >> 1;
-      else if (bpp == 8) width = s->img_x;
-      else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); }
-      pad = (-width)&3;
-      for (j=0; j < (int) s->img_y; ++j) {
-         for (i=0; i < (int) s->img_x; i += 2) {
-            int v=stbi__get8(s),v2=0;
-            if (bpp == 4) {
-               v2 = v & 15;
-               v >>= 4;
-            }
-            out[z++] = pal[v][0];
-            out[z++] = pal[v][1];
-            out[z++] = pal[v][2];
-            if (target == 4) out[z++] = 255;
-            if (i+1 == (int) s->img_x) break;
-            v = (bpp == 8) ? stbi__get8(s) : v2;
-            out[z++] = pal[v][0];
-            out[z++] = pal[v][1];
-            out[z++] = pal[v][2];
-            if (target == 4) out[z++] = 255;
-         }
-         stbi__skip(s, pad);
-      }
-   } else {
-      int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;
-      int z = 0;
-      int easy=0;
-      stbi__skip(s, offset - 14 - hsz);
-      if (bpp == 24) width = 3 * s->img_x;
-      else if (bpp == 16) width = 2*s->img_x;
-      else /* bpp = 32 and pad = 0 */ width=0;
-      pad = (-width) & 3;
-      if (bpp == 24) {
-         easy = 1;
-      } else if (bpp == 32) {
-         if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
-            easy = 2;
-      }
-      if (!easy) {
-         if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
-         // right shift amt to put high bit in position #7
-         rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr);
-         gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg);
-         bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb);
-         ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma);
-      }
-      for (j=0; j < (int) s->img_y; ++j) {
-         if (easy) {
-            for (i=0; i < (int) s->img_x; ++i) {
-               unsigned char a;
-               out[z+2] = stbi__get8(s);
-               out[z+1] = stbi__get8(s);
-               out[z+0] = stbi__get8(s);
-               z += 3;
-               a = (easy == 2 ? stbi__get8(s) : 255);
-               if (target == 4) out[z++] = a;
-            }
-         } else {
-            for (i=0; i < (int) s->img_x; ++i) {
-               stbi__uint32 v = (stbi__uint32) (bpp == 16 ? stbi__get16le(s) : stbi__get32le(s));
-               int a;
-               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount));
-               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount));
-               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount));
-               a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255);
-               if (target == 4) out[z++] = STBI__BYTECAST(a);
-            }
-         }
-         stbi__skip(s, pad);
-      }
-   }
-   if (flip_vertically) {
-      stbi_uc t;
-      for (j=0; j < (int) s->img_y>>1; ++j) {
-         stbi_uc *p1 = out +      j     *s->img_x*target;
-         stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;
-         for (i=0; i < (int) s->img_x*target; ++i) {
-            t = p1[i], p1[i] = p2[i], p2[i] = t;
-         }
-      }
-   }
-
-   if (req_comp && req_comp != target) {
-      out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);
-      if (out == NULL) return out; // stbi__convert_format frees input on failure
-   }
-
-   *x = s->img_x;
-   *y = s->img_y;
-   if (comp) *comp = s->img_n;
-   return out;
-}
-#endif
-
-// Targa Truevision - TGA
-// by Jonathan Dummer
-#ifndef STBI_NO_TGA
-static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)
-{
-    int tga_w, tga_h, tga_comp;
-    int sz;
-    stbi__get8(s);                   // discard Offset
-    sz = stbi__get8(s);              // color type
-    if( sz > 1 ) {
-        stbi__rewind(s);
-        return 0;      // only RGB or indexed allowed
-    }
-    sz = stbi__get8(s);              // image type
-    // only RGB or grey allowed, +/- RLE
-    if ((sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11)) return 0;
-    stbi__skip(s,9);
-    tga_w = stbi__get16le(s);
-    if( tga_w < 1 ) {
-        stbi__rewind(s);
-        return 0;   // test width
-    }
-    tga_h = stbi__get16le(s);
-    if( tga_h < 1 ) {
-        stbi__rewind(s);
-        return 0;   // test height
-    }
-    sz = stbi__get8(s);               // bits per pixel
-    // only RGB or RGBA or grey allowed
-    if ((sz != 8) && (sz != 16) && (sz != 24) && (sz != 32)) {
-        stbi__rewind(s);
-        return 0;
-    }
-    tga_comp = sz;
-    if (x) *x = tga_w;
-    if (y) *y = tga_h;
-    if (comp) *comp = tga_comp / 8;
-    return 1;                   // seems to have passed everything
-}
-
-static int stbi__tga_test(stbi__context *s)
-{
-   int res;
-   int sz;
-   stbi__get8(s);      //   discard Offset
-   sz = stbi__get8(s);   //   color type
-   if ( sz > 1 ) return 0;   //   only RGB or indexed allowed
-   sz = stbi__get8(s);   //   image type
-   if ( (sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11) ) return 0;   //   only RGB or grey allowed, +/- RLE
-   stbi__get16be(s);      //   discard palette start
-   stbi__get16be(s);      //   discard palette length
-   stbi__get8(s);         //   discard bits per palette color entry
-   stbi__get16be(s);      //   discard x origin
-   stbi__get16be(s);      //   discard y origin
-   if ( stbi__get16be(s) < 1 ) return 0;      //   test width
-   if ( stbi__get16be(s) < 1 ) return 0;      //   test height
-   sz = stbi__get8(s);   //   bits per pixel
-   if ( (sz != 8) && (sz != 16) && (sz != 24) && (sz != 32) )
-      res = 0;
-   else
-      res = 1;
-   stbi__rewind(s);
-   return res;
-}
-
-static stbi_uc *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
-{
-   //   read in the TGA header stuff
-   int tga_offset = stbi__get8(s);
-   int tga_indexed = stbi__get8(s);
-   int tga_image_type = stbi__get8(s);
-   int tga_is_RLE = 0;
-   int tga_palette_start = stbi__get16le(s);
-   int tga_palette_len = stbi__get16le(s);
-   int tga_palette_bits = stbi__get8(s);
-   int tga_x_origin = stbi__get16le(s);
-   int tga_y_origin = stbi__get16le(s);
-   int tga_width = stbi__get16le(s);
-   int tga_height = stbi__get16le(s);
-   int tga_bits_per_pixel = stbi__get8(s);
-   int tga_comp = tga_bits_per_pixel / 8;
-   int tga_inverted = stbi__get8(s);
-   //   image data
-   unsigned char *tga_data;
-   unsigned char *tga_palette = NULL;
-   int i, j;
-   unsigned char raw_data[4];
-   int RLE_count = 0;
-   int RLE_repeating = 0;
-   int read_next_pixel = 1;
-
-   //   do a tiny bit of precessing
-   if ( tga_image_type >= 8 )
-   {
-      tga_image_type -= 8;
-      tga_is_RLE = 1;
-   }
-   /* int tga_alpha_bits = tga_inverted & 15; */
-   tga_inverted = 1 - ((tga_inverted >> 5) & 1);
-
-   //   error check
-   if ( //(tga_indexed) ||
-      (tga_width < 1) || (tga_height < 1) ||
-      (tga_image_type < 1) || (tga_image_type > 3) ||
-      ((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16) &&
-      (tga_bits_per_pixel != 24) && (tga_bits_per_pixel != 32))
-      )
-   {
-      return NULL; // we don't report this as a bad TGA because we don't even know if it's TGA
-   }
-
-   //   If I'm paletted, then I'll use the number of bits from the palette
-   if ( tga_indexed )
-   {
-      tga_comp = tga_palette_bits / 8;
-   }
-
-   //   tga info
-   *x = tga_width;
-   *y = tga_height;
-   if (comp) *comp = tga_comp;
-
-   tga_data = (unsigned char*)stbi__malloc( tga_width * tga_height * tga_comp );
-   if (!tga_data) return stbi__errpuc("outofmem", "Out of memory");
-
-   // skip to the data's starting position (offset usually = 0)
-   stbi__skip(s, tga_offset );
-
-   if ( !tga_indexed && !tga_is_RLE) {
-      for (i=0; i < tga_height; ++i) {
-         int y = tga_inverted ? tga_height -i - 1 : i;
-         stbi_uc *tga_row = tga_data + y*tga_width*tga_comp;
-         stbi__getn(s, tga_row, tga_width * tga_comp);
-      }
-   } else  {
-      //   do I need to load a palette?
-      if ( tga_indexed)
-      {
-         //   any data to skip? (offset usually = 0)
-         stbi__skip(s, tga_palette_start );
-         //   load the palette
-         tga_palette = (unsigned char*)stbi__malloc( tga_palette_len * tga_palette_bits / 8 );
-         if (!tga_palette) {
-            STBI_FREE(tga_data);
-            return stbi__errpuc("outofmem", "Out of memory");
-         }
-         if (!stbi__getn(s, tga_palette, tga_palette_len * tga_palette_bits / 8 )) {
-            STBI_FREE(tga_data);
-            STBI_FREE(tga_palette);
-            return stbi__errpuc("bad palette", "Corrupt TGA");
-         }
-      }
-      //   load the data
-      for (i=0; i < tga_width * tga_height; ++i)
-      {
-         //   if I'm in RLE mode, do I need to get a RLE stbi__pngchunk?
-         if ( tga_is_RLE )
-         {
-            if ( RLE_count == 0 )
-            {
-               //   yep, get the next byte as a RLE command
-               int RLE_cmd = stbi__get8(s);
-               RLE_count = 1 + (RLE_cmd & 127);
-               RLE_repeating = RLE_cmd >> 7;
-               read_next_pixel = 1;
-            } else if ( !RLE_repeating )
-            {
-               read_next_pixel = 1;
-            }
-         } else
-         {
-            read_next_pixel = 1;
-         }
-         //   OK, if I need to read a pixel, do it now
-         if ( read_next_pixel )
-         {
-            //   load however much data we did have
-            if ( tga_indexed )
-            {
-               //   read in 1 byte, then perform the lookup
-               int pal_idx = stbi__get8(s);
-               if ( pal_idx >= tga_palette_len )
-               {
-                  //   invalid index
-                  pal_idx = 0;
-               }
-               pal_idx *= tga_bits_per_pixel / 8;
-               for (j = 0; j*8 < tga_bits_per_pixel; ++j)
-               {
-                  raw_data[j] = tga_palette[pal_idx+j];
-               }
-            } else
-            {
-               //   read in the data raw
-               for (j = 0; j*8 < tga_bits_per_pixel; ++j)
-               {
-                  raw_data[j] = stbi__get8(s);
-               }
-            }
-            //   clear the reading flag for the next pixel
-            read_next_pixel = 0;
-         } // end of reading a pixel
-
-         // copy data
-         for (j = 0; j < tga_comp; ++j)
-           tga_data[i*tga_comp+j] = raw_data[j];
-
-         //   in case we're in RLE mode, keep counting down
-         --RLE_count;
-      }
-      //   do I need to invert the image?
-      if ( tga_inverted )
-      {
-         for (j = 0; j*2 < tga_height; ++j)
-         {
-            int index1 = j * tga_width * tga_comp;
-            int index2 = (tga_height - 1 - j) * tga_width * tga_comp;
-            for (i = tga_width * tga_comp; i > 0; --i)
-            {
-               unsigned char temp = tga_data[index1];
-               tga_data[index1] = tga_data[index2];
-               tga_data[index2] = temp;
-               ++index1;
-               ++index2;
-            }
-         }
-      }
-      //   clear my palette, if I had one
-      if ( tga_palette != NULL )
-      {
-         STBI_FREE( tga_palette );
-      }
-   }
-
-   // swap RGB
-   if (tga_comp >= 3)
-   {
-      unsigned char* tga_pixel = tga_data;
-      for (i=0; i < tga_width * tga_height; ++i)
-      {
-         unsigned char temp = tga_pixel[0];
-         tga_pixel[0] = tga_pixel[2];
-         tga_pixel[2] = temp;
-         tga_pixel += tga_comp;
-      }
-   }
-
-   // convert to target component count
-   if (req_comp && req_comp != tga_comp)
-      tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);
-
-   //   the things I do to get rid of an error message, and yet keep
-   //   Microsoft's C compilers happy... [8^(
-   tga_palette_start = tga_palette_len = tga_palette_bits =
-         tga_x_origin = tga_y_origin = 0;
-   //   OK, done
-   return tga_data;
-}
-#endif
-
-// *************************************************************************************************
-// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB
-
-#ifndef STBI_NO_PSD
-static int stbi__psd_test(stbi__context *s)
-{
-   int r = (stbi__get32be(s) == 0x38425053);
-   stbi__rewind(s);
-   return r;
-}
-
-static stbi_uc *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
-{
-   int   pixelCount;
-   int channelCount, compression;
-   int channel, i, count, len;
-   int w,h;
-   stbi_uc *out;
-
-   // Check identifier
-   if (stbi__get32be(s) != 0x38425053)   // "8BPS"
-      return stbi__errpuc("not PSD", "Corrupt PSD image");
-
-   // Check file type version.
-   if (stbi__get16be(s) != 1)
-      return stbi__errpuc("wrong version", "Unsupported version of PSD image");
-
-   // Skip 6 reserved bytes.
-   stbi__skip(s, 6 );
-
-   // Read the number of channels (R, G, B, A, etc).
-   channelCount = stbi__get16be(s);
-   if (channelCount < 0 || channelCount > 16)
-      return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image");
-
-   // Read the rows and columns of the image.
-   h = stbi__get32be(s);
-   w = stbi__get32be(s);
-
-   // Make sure the depth is 8 bits.
-   if (stbi__get16be(s) != 8)
-      return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 bit");
-
-   // Make sure the color mode is RGB.
-   // Valid options are:
-   //   0: Bitmap
-   //   1: Grayscale
-   //   2: Indexed color
-   //   3: RGB color
-   //   4: CMYK color
-   //   7: Multichannel
-   //   8: Duotone
-   //   9: Lab color
-   if (stbi__get16be(s) != 3)
-      return stbi__errpuc("wrong color format", "PSD is not in RGB color format");
-
-   // Skip the Mode Data.  (It's the palette for indexed color; other info for other modes.)
-   stbi__skip(s,stbi__get32be(s) );
-
-   // Skip the image resources.  (resolution, pen tool paths, etc)
-   stbi__skip(s, stbi__get32be(s) );
-
-   // Skip the reserved data.
-   stbi__skip(s, stbi__get32be(s) );
-
-   // Find out if the data is compressed.
-   // Known values:
-   //   0: no compression
-   //   1: RLE compressed
-   compression = stbi__get16be(s);
-   if (compression > 1)
-      return stbi__errpuc("bad compression", "PSD has an unknown compression format");
-
-   // Create the destination image.
-   out = (stbi_uc *) stbi__malloc(4 * w*h);
-   if (!out) return stbi__errpuc("outofmem", "Out of memory");
-   pixelCount = w*h;
-
-   // Initialize the data to zero.
-   //memset( out, 0, pixelCount * 4 );
-
-   // Finally, the image data.
-   if (compression) {
-      // RLE as used by .PSD and .TIFF
-      // Loop until you get the number of unpacked bytes you are expecting:
-      //     Read the next source byte into n.
-      //     If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.
-      //     Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.
-      //     Else if n is 128, noop.
-      // Endloop
-
-      // The RLE-compressed data is preceeded by a 2-byte data count for each row in the data,
-      // which we're going to just skip.
-      stbi__skip(s, h * channelCount * 2 );
-
-      // Read the RLE data by channel.
-      for (channel = 0; channel < 4; channel++) {
-         stbi_uc *p;
-
-         p = out+channel;
-         if (channel >= channelCount) {
-            // Fill this channel with default data.
-            for (i = 0; i < pixelCount; i++) *p = (channel == 3 ? 255 : 0), p += 4;
-         } else {
-            // Read the RLE data.
-            count = 0;
-            while (count < pixelCount) {
-               len = stbi__get8(s);
-               if (len == 128) {
-                  // No-op.
-               } else if (len < 128) {
-                  // Copy next len+1 bytes literally.
-                  len++;
-                  count += len;
-                  while (len) {
-                     *p = stbi__get8(s);
-                     p += 4;
-                     len--;
-                  }
-               } else if (len > 128) {
-                  stbi_uc   val;
-                  // Next -len+1 bytes in the dest are replicated from next source byte.
-                  // (Interpret len as a negative 8-bit int.)
-                  len ^= 0x0FF;
-                  len += 2;
-                  val = stbi__get8(s);
-                  count += len;
-                  while (len) {
-                     *p = val;
-                     p += 4;
-                     len--;
-                  }
-               }
-            }
-         }
-      }
-
-   } else {
-      // We're at the raw image data.  It's each channel in order (Red, Green, Blue, Alpha, ...)
-      // where each channel consists of an 8-bit value for each pixel in the image.
-
-      // Read the data by channel.
-      for (channel = 0; channel < 4; channel++) {
-         stbi_uc *p;
-
-         p = out + channel;
-         if (channel > channelCount) {
-            // Fill this channel with default data.
-            for (i = 0; i < pixelCount; i++) *p = channel == 3 ? 255 : 0, p += 4;
-         } else {
-            // Read the data.
-            for (i = 0; i < pixelCount; i++)
-               *p = stbi__get8(s), p += 4;
-         }
-      }
-   }
-
-   if (req_comp && req_comp != 4) {
-      out = stbi__convert_format(out, 4, req_comp, w, h);
-      if (out == NULL) return out; // stbi__convert_format frees input on failure
-   }
-
-   if (comp) *comp = channelCount;
-   *y = h;
-   *x = w;
-
-   return out;
-}
-#endif
-
-// *************************************************************************************************
-// Softimage PIC loader
-// by Tom Seddon
-//
-// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format
-// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/
-
-#ifndef STBI_NO_PIC
-static int stbi__pic_is4(stbi__context *s,const char *str)
-{
-   int i;
-   for (i=0; i<4; ++i)
-      if (stbi__get8(s) != (stbi_uc)str[i])
-         return 0;
-
-   return 1;
-}
-
-static int stbi__pic_test_core(stbi__context *s)
-{
-   int i;
-
-   if (!stbi__pic_is4(s,"\x53\x80\xF6\x34"))
-      return 0;
-
-   for(i=0;i<84;++i)
-      stbi__get8(s);
-
-   if (!stbi__pic_is4(s,"PICT"))
-      return 0;
-
-   return 1;
-}
-
-typedef struct
-{
-   stbi_uc size,type,channel;
-} stbi__pic_packet;
-
-static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
-{
-   int mask=0x80, i;
-
-   for (i=0; i<4; ++i, mask>>=1) {
-      if (channel & mask) {
-         if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");
-         dest[i]=stbi__get8(s);
-      }
-   }
-
-   return dest;
-}
-
-static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)
-{
-   int mask=0x80,i;
-
-   for (i=0;i<4; ++i, mask>>=1)
-      if (channel&mask)
-         dest[i]=src[i];
-}
-
-static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)
-{
-   int act_comp=0,num_packets=0,y,chained;
-   stbi__pic_packet packets[10];
-
-   // this will (should...) cater for even some bizarre stuff like having data
-    // for the same channel in multiple packets.
-   do {
-      stbi__pic_packet *packet;
-
-      if (num_packets==sizeof(packets)/sizeof(packets[0]))
-         return stbi__errpuc("bad format","too many packets");
-
-      packet = &packets[num_packets++];
-
-      chained = stbi__get8(s);
-      packet->size    = stbi__get8(s);
-      packet->type    = stbi__get8(s);
-      packet->channel = stbi__get8(s);
-
-      act_comp |= packet->channel;
-
-      if (stbi__at_eof(s))          return stbi__errpuc("bad file","file too short (reading packets)");
-      if (packet->size != 8)  return stbi__errpuc("bad format","packet isn't 8bpp");
-   } while (chained);
-
-   *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel?
-
-   for(y=0; y<height; ++y) {
-      int packet_idx;
-
-      for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {
-         stbi__pic_packet *packet = &packets[packet_idx];
-         stbi_uc *dest = result+y*width*4;
-
-         switch (packet->type) {
-            default:
-               return stbi__errpuc("bad format","packet has bad compression type");
-
-            case 0: {//uncompressed
-               int x;
-
-               for(x=0;x<width;++x, dest+=4)
-                  if (!stbi__readval(s,packet->channel,dest))
-                     return 0;
-               break;
-            }
-
-            case 1://Pure RLE
-               {
-                  int left=width, i;
-
-                  while (left>0) {
-                     stbi_uc count,value[4];
-
-                     count=stbi__get8(s);
-                     if (stbi__at_eof(s))   return stbi__errpuc("bad file","file too short (pure read count)");
-
-                     if (count > left)
-                        count = (stbi_uc) left;
-
-                     if (!stbi__readval(s,packet->channel,value))  return 0;
-
-                     for(i=0; i<count; ++i,dest+=4)
-                        stbi__copyval(packet->channel,dest,value);
-                     left -= count;
-                  }
-               }
-               break;
-
-            case 2: {//Mixed RLE
-               int left=width;
-               while (left>0) {
-                  int count = stbi__get8(s), i;
-                  if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (mixed read count)");
-
-                  if (count >= 128) { // Repeated
-                     stbi_uc value[4];
-                     int i;
-
-                     if (count==128)
-                        count = stbi__get16be(s);
-                     else
-                        count -= 127;
-                     if (count > left)
-                        return stbi__errpuc("bad file","scanline overrun");
-
-                     if (!stbi__readval(s,packet->channel,value))
-                        return 0;
-
-                     for(i=0;i<count;++i, dest += 4)
-                        stbi__copyval(packet->channel,dest,value);
-                  } else { // Raw
-                     ++count;
-                     if (count>left) return stbi__errpuc("bad file","scanline overrun");
-
-                     for(i=0;i<count;++i, dest+=4)
-                        if (!stbi__readval(s,packet->channel,dest))
-                           return 0;
-                  }
-                  left-=count;
-               }
-               break;
-            }
-         }
-      }
-   }
-
-   return result;
-}
-
-static stbi_uc *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp)
-{
-   stbi_uc *result;
-   int i, x,y;
-
-   for (i=0; i<92; ++i)
-      stbi__get8(s);
-
-   x = stbi__get16be(s);
-   y = stbi__get16be(s);
-   if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (pic header)");
-   if ((1 << 28) / x < y) return stbi__errpuc("too large", "Image too large to decode");
-
-   stbi__get32be(s); //skip `ratio'
-   stbi__get16be(s); //skip `fields'
-   stbi__get16be(s); //skip `pad'
-
-   // intermediate buffer is RGBA
-   result = (stbi_uc *) stbi__malloc(x*y*4);
-   memset(result, 0xff, x*y*4);
-
-   if (!stbi__pic_load_core(s,x,y,comp, result)) {
-      STBI_FREE(result);
-      result=0;
-   }
-   *px = x;
-   *py = y;
-   if (req_comp == 0) req_comp = *comp;
-   result=stbi__convert_format(result,4,req_comp,x,y);
-
-   return result;
-}
-
-static int stbi__pic_test(stbi__context *s)
-{
-   int r = stbi__pic_test_core(s);
-   stbi__rewind(s);
-   return r;
-}
-#endif
-
-// *************************************************************************************************
-// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb
-
-#ifndef STBI_NO_GIF
-typedef struct
-{
-   stbi__int16 prefix;
-   stbi_uc first;
-   stbi_uc suffix;
-} stbi__gif_lzw;
-
-typedef struct
-{
-   int w,h;
-   stbi_uc *out;                 // output buffer (always 4 components)
-   int flags, bgindex, ratio, transparent, eflags;
-   stbi_uc  pal[256][4];
-   stbi_uc lpal[256][4];
-   stbi__gif_lzw codes[4096];
-   stbi_uc *color_table;
-   int parse, step;
-   int lflags;
-   int start_x, start_y;
-   int max_x, max_y;
-   int cur_x, cur_y;
-   int line_size;
-} stbi__gif;
-
-static int stbi__gif_test_raw(stbi__context *s)
-{
-   int sz;
-   if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0;
-   sz = stbi__get8(s);
-   if (sz != '9' && sz != '7') return 0;
-   if (stbi__get8(s) != 'a') return 0;
-   return 1;
-}
-
-static int stbi__gif_test(stbi__context *s)
-{
-   int r = stbi__gif_test_raw(s);
-   stbi__rewind(s);
-   return r;
-}
-
-static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)
-{
-   int i;
-   for (i=0; i < num_entries; ++i) {
-      pal[i][2] = stbi__get8(s);
-      pal[i][1] = stbi__get8(s);
-      pal[i][0] = stbi__get8(s);
-      pal[i][3] = transp == i ? 0 : 255;
-   }
-}
-
-static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)
-{
-   stbi_uc version;
-   if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8')
-      return stbi__err("not GIF", "Corrupt GIF");
-
-   version = stbi__get8(s);
-   if (version != '7' && version != '9')    return stbi__err("not GIF", "Corrupt GIF");
-   if (stbi__get8(s) != 'a')                return stbi__err("not GIF", "Corrupt GIF");
-
-   stbi__g_failure_reason = "";
-   g->w = stbi__get16le(s);
-   g->h = stbi__get16le(s);
-   g->flags = stbi__get8(s);
-   g->bgindex = stbi__get8(s);
-   g->ratio = stbi__get8(s);
-   g->transparent = -1;
-
-   if (comp != 0) *comp = 4;  // can't actually tell whether it's 3 or 4 until we parse the comments
-
-   if (is_info) return 1;
-
-   if (g->flags & 0x80)
-      stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1);
-
-   return 1;
-}
-
-static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)
-{
-   stbi__gif g;
-   if (!stbi__gif_header(s, &g, comp, 1)) {
-      stbi__rewind( s );
-      return 0;
-   }
-   if (x) *x = g.w;
-   if (y) *y = g.h;
-   return 1;
-}
-
-static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
-{
-   stbi_uc *p, *c;
-
-   // recurse to decode the prefixes, since the linked-list is backwards,
-   // and working backwards through an interleaved image would be nasty
-   if (g->codes[code].prefix >= 0)
-      stbi__out_gif_code(g, g->codes[code].prefix);
-
-   if (g->cur_y >= g->max_y) return;
-
-   p = &g->out[g->cur_x + g->cur_y];
-   c = &g->color_table[g->codes[code].suffix * 4];
-
-   if (c[3] >= 128) {
-      p[0] = c[2];
-      p[1] = c[1];
-      p[2] = c[0];
-      p[3] = c[3];
-   }
-   g->cur_x += 4;
-
-   if (g->cur_x >= g->max_x) {
-      g->cur_x = g->start_x;
-      g->cur_y += g->step;
-
-      while (g->cur_y >= g->max_y && g->parse > 0) {
-         g->step = (1 << g->parse) * g->line_size;
-         g->cur_y = g->start_y + (g->step >> 1);
-         --g->parse;
-      }
-   }
-}
-
-static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
-{
-   stbi_uc lzw_cs;
-   stbi__int32 len, code;
-   stbi__uint32 first;
-   stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;
-   stbi__gif_lzw *p;
-
-   lzw_cs = stbi__get8(s);
-   clear = 1 << lzw_cs;
-   first = 1;
-   codesize = lzw_cs + 1;
-   codemask = (1 << codesize) - 1;
-   bits = 0;
-   valid_bits = 0;
-   for (code = 0; code < clear; code++) {
-      g->codes[code].prefix = -1;
-      g->codes[code].first = (stbi_uc) code;
-      g->codes[code].suffix = (stbi_uc) code;
-   }
-
-   // support no starting clear code
-   avail = clear+2;
-   oldcode = -1;
-
-   len = 0;
-   for(;;) {
-      if (valid_bits < codesize) {
-         if (len == 0) {
-            len = stbi__get8(s); // start new block
-            if (len == 0)
-               return g->out;
-         }
-         --len;
-         bits |= (stbi__int32) stbi__get8(s) << valid_bits;
-         valid_bits += 8;
-      } else {
-         stbi__int32 code = bits & codemask;
-         bits >>= codesize;
-         valid_bits -= codesize;
-         // @OPTIMIZE: is there some way we can accelerate the non-clear path?
-         if (code == clear) {  // clear code
-            codesize = lzw_cs + 1;
-            codemask = (1 << codesize) - 1;
-            avail = clear + 2;
-            oldcode = -1;
-            first = 0;
-         } else if (code == clear + 1) { // end of stream code
-            stbi__skip(s, len);
-            while ((len = stbi__get8(s)) > 0)
-               stbi__skip(s,len);
-            return g->out;
-         } else if (code <= avail) {
-            if (first) return stbi__errpuc("no clear code", "Corrupt GIF");
-
-            if (oldcode >= 0) {
-               p = &g->codes[avail++];
-               if (avail > 4096)        return stbi__errpuc("too many codes", "Corrupt GIF");
-               p->prefix = (stbi__int16) oldcode;
-               p->first = g->codes[oldcode].first;
-               p->suffix = (code == avail) ? p->first : g->codes[code].first;
-            } else if (code == avail)
-               return stbi__errpuc("illegal code in raster", "Corrupt GIF");
-
-            stbi__out_gif_code(g, (stbi__uint16) code);
-
-            if ((avail & codemask) == 0 && avail <= 0x0FFF) {
-               codesize++;
-               codemask = (1 << codesize) - 1;
-            }
-
-            oldcode = code;
-         } else {
-            return stbi__errpuc("illegal code in raster", "Corrupt GIF");
-         }
-      }
-   }
-}
-
-static void stbi__fill_gif_background(stbi__gif *g)
-{
-   int i;
-   stbi_uc *c = g->pal[g->bgindex];
-   // @OPTIMIZE: write a dword at a time
-   for (i = 0; i < g->w * g->h * 4; i += 4) {
-      stbi_uc *p  = &g->out[i];
-      p[0] = c[2];
-      p[1] = c[1];
-      p[2] = c[0];
-      p[3] = c[3];
-   }
-}
-
-// this function is designed to support animated gifs, although stb_image doesn't support it
-static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp)
-{
-   int i;
-   stbi_uc *old_out = 0;
-
-   if (g->out == 0) {
-      if (!stbi__gif_header(s, g, comp,0))     return 0; // stbi__g_failure_reason set by stbi__gif_header
-      g->out = (stbi_uc *) stbi__malloc(4 * g->w * g->h);
-      if (g->out == 0)                      return stbi__errpuc("outofmem", "Out of memory");
-      stbi__fill_gif_background(g);
-   } else {
-      // animated-gif-only path
-      if (((g->eflags & 0x1C) >> 2) == 3) {
-         old_out = g->out;
-         g->out = (stbi_uc *) stbi__malloc(4 * g->w * g->h);
-         if (g->out == 0)                   return stbi__errpuc("outofmem", "Out of memory");
-         memcpy(g->out, old_out, g->w*g->h*4);
-      }
-   }
-
-   for (;;) {
-      switch (stbi__get8(s)) {
-         case 0x2C: /* Image Descriptor */
-         {
-            stbi__int32 x, y, w, h;
-            stbi_uc *o;
-
-            x = stbi__get16le(s);
-            y = stbi__get16le(s);
-            w = stbi__get16le(s);
-            h = stbi__get16le(s);
-            if (((x + w) > (g->w)) || ((y + h) > (g->h)))
-               return stbi__errpuc("bad Image Descriptor", "Corrupt GIF");
-
-            g->line_size = g->w * 4;
-            g->start_x = x * 4;
-            g->start_y = y * g->line_size;
-            g->max_x   = g->start_x + w * 4;
-            g->max_y   = g->start_y + h * g->line_size;
-            g->cur_x   = g->start_x;
-            g->cur_y   = g->start_y;
-
-            g->lflags = stbi__get8(s);
-
-            if (g->lflags & 0x40) {
-               g->step = 8 * g->line_size; // first interlaced spacing
-               g->parse = 3;
-            } else {
-               g->step = g->line_size;
-               g->parse = 0;
-            }
-
-            if (g->lflags & 0x80) {
-               stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);
-               g->color_table = (stbi_uc *) g->lpal;
-            } else if (g->flags & 0x80) {
-               for (i=0; i < 256; ++i)  // @OPTIMIZE: stbi__jpeg_reset only the previous transparent
-                  g->pal[i][3] = 255;
-               if (g->transparent >= 0 && (g->eflags & 0x01))
-                  g->pal[g->transparent][3] = 0;
-               g->color_table = (stbi_uc *) g->pal;
-            } else
-               return stbi__errpuc("missing color table", "Corrupt GIF");
-
-            o = stbi__process_gif_raster(s, g);
-            if (o == NULL) return NULL;
-
-            if (req_comp && req_comp != 4)
-               o = stbi__convert_format(o, 4, req_comp, g->w, g->h);
-            return o;
-         }
-
-         case 0x21: // Comment Extension.
-         {
-            int len;
-            if (stbi__get8(s) == 0xF9) { // Graphic Control Extension.
-               len = stbi__get8(s);
-               if (len == 4) {
-                  g->eflags = stbi__get8(s);
-                  stbi__get16le(s); // delay
-                  g->transparent = stbi__get8(s);
-               } else {
-                  stbi__skip(s, len);
-                  break;
-               }
-            }
-            while ((len = stbi__get8(s)) != 0)
-               stbi__skip(s, len);
-            break;
-         }
-
-         case 0x3B: // gif stream termination code
-            return (stbi_uc *) s; // using '1' causes warning on some compilers
-
-         default:
-            return stbi__errpuc("unknown code", "Corrupt GIF");
-      }
-   }
-}
-
-static stbi_uc *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
-{
-   stbi_uc *u = 0;
-   stbi__gif g;
-   memset(&g, 0, sizeof(g));
-
-   u = stbi__gif_load_next(s, &g, comp, req_comp);
-   if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
-   if (u) {
-      *x = g.w;
-      *y = g.h;
-   }
-
-   return u;
-}
-
-static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)
-{
-   return stbi__gif_info_raw(s,x,y,comp);
-}
-#endif
-
-// *************************************************************************************************
-// Radiance RGBE HDR loader
-// originally by Nicolas Schulz
-#ifndef STBI_NO_HDR
-static int stbi__hdr_test_core(stbi__context *s)
-{
-   const char *signature = "#?RADIANCE\n";
-   int i;
-   for (i=0; signature[i]; ++i)
-      if (stbi__get8(s) != signature[i])
-         return 0;
-   return 1;
-}
-
-static int stbi__hdr_test(stbi__context* s)
-{
-   int r = stbi__hdr_test_core(s);
-   stbi__rewind(s);
-   return r;
-}
-
-#define STBI__HDR_BUFLEN  1024
-static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)
-{
-   int len=0;
-   char c = '\0';
-
-   c = (char) stbi__get8(z);
-
-   while (!stbi__at_eof(z) && c != '\n') {
-      buffer[len++] = c;
-      if (len == STBI__HDR_BUFLEN-1) {
-         // flush to end of line
-         while (!stbi__at_eof(z) && stbi__get8(z) != '\n')
-            ;
-         break;
-      }
-      c = (char) stbi__get8(z);
-   }
-
-   buffer[len] = 0;
-   return buffer;
-}
-
-static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
-{
-   if ( input[3] != 0 ) {
-      float f1;
-      // Exponent
-      f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
-      if (req_comp <= 2)
-         output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
-      else {
-         output[0] = input[0] * f1;
-         output[1] = input[1] * f1;
-         output[2] = input[2] * f1;
-      }
-      if (req_comp == 2) output[1] = 1;
-      if (req_comp == 4) output[3] = 1;
-   } else {
-      switch (req_comp) {
-         case 4: output[3] = 1; /* fallthrough */
-         case 3: output[0] = output[1] = output[2] = 0;
-                 break;
-         case 2: output[1] = 1; /* fallthrough */
-         case 1: output[0] = 0;
-                 break;
-      }
-   }
-}
-
-static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
-{
-   char buffer[STBI__HDR_BUFLEN];
-   char *token;
-   int valid = 0;
-   int width, height;
-   stbi_uc *scanline;
-   float *hdr_data;
-   int len;
-   unsigned char count, value;
-   int i, j, k, c1,c2, z;
-
-
-   // Check identifier
-   if (strcmp(stbi__hdr_gettoken(s,buffer), "#?RADIANCE") != 0)
-      return stbi__errpf("not HDR", "Corrupt HDR image");
-
-   // Parse header
-   for(;;) {
-      token = stbi__hdr_gettoken(s,buffer);
-      if (token[0] == 0) break;
-      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
-   }
-
-   if (!valid)    return stbi__errpf("unsupported format", "Unsupported HDR format");
-
-   // Parse width and height
-   // can't use sscanf() if we're not using stdio!
-   token = stbi__hdr_gettoken(s,buffer);
-   if (strncmp(token, "-Y ", 3))  return stbi__errpf("unsupported data layout", "Unsupported HDR format");
-   token += 3;
-   height = (int) strtol(token, &token, 10);
-   while (*token == ' ') ++token;
-   if (strncmp(token, "+X ", 3))  return stbi__errpf("unsupported data layout", "Unsupported HDR format");
-   token += 3;
-   width = (int) strtol(token, NULL, 10);
-
-   *x = width;
-   *y = height;
-
-   if (comp) *comp = 3;
-   if (req_comp == 0) req_comp = 3;
-
-   // Read data
-   hdr_data = (float *) stbi__malloc(height * width * req_comp * sizeof(float));
-
-   // Load image data
-   // image data is stored as some number of sca
-   if ( width < 8 || width >= 32768) {
-      // Read flat data
-      for (j=0; j < height; ++j) {
-         for (i=0; i < width; ++i) {
-            stbi_uc rgbe[4];
-           main_decode_loop:
-            stbi__getn(s, rgbe, 4);
-            stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);
-         }
-      }
-   } else {
-      // Read RLE-encoded data
-      scanline = NULL;
-
-      for (j = 0; j < height; ++j) {
-         c1 = stbi__get8(s);
-         c2 = stbi__get8(s);
-         len = stbi__get8(s);
-         if (c1 != 2 || c2 != 2 || (len & 0x80)) {
-            // not run-length encoded, so we have to actually use THIS data as a decoded
-            // pixel (note this can't be a valid pixel--one of RGB must be >= 128)
-            stbi_uc rgbe[4];
-            rgbe[0] = (stbi_uc) c1;
-            rgbe[1] = (stbi_uc) c2;
-            rgbe[2] = (stbi_uc) len;
-            rgbe[3] = (stbi_uc) stbi__get8(s);
-            stbi__hdr_convert(hdr_data, rgbe, req_comp);
-            i = 1;
-            j = 0;
-            STBI_FREE(scanline);
-            goto main_decode_loop; // yes, this makes no sense
-         }
-         len <<= 8;
-         len |= stbi__get8(s);
-         if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); }
-         if (scanline == NULL) scanline = (stbi_uc *) stbi__malloc(width * 4);
-
-         for (k = 0; k < 4; ++k) {
-            i = 0;
-            while (i < width) {
-               count = stbi__get8(s);
-               if (count > 128) {
-                  // Run
-                  value = stbi__get8(s);
-                  count -= 128;
-                  for (z = 0; z < count; ++z)
-                     scanline[i++ * 4 + k] = value;
-               } else {
-                  // Dump
-                  for (z = 0; z < count; ++z)
-                     scanline[i++ * 4 + k] = stbi__get8(s);
-               }
-            }
-         }
-         for (i=0; i < width; ++i)
-            stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
-      }
-      STBI_FREE(scanline);
-   }
-
-   return hdr_data;
-}
-
-static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
-{
-   char buffer[STBI__HDR_BUFLEN];
-   char *token;
-   int valid = 0;
-
-   if (strcmp(stbi__hdr_gettoken(s,buffer), "#?RADIANCE") != 0) {
-       stbi__rewind( s );
-       return 0;
-   }
-
-   for(;;) {
-      token = stbi__hdr_gettoken(s,buffer);
-      if (token[0] == 0) break;
-      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
-   }
-
-   if (!valid) {
-       stbi__rewind( s );
-       return 0;
-   }
-   token = stbi__hdr_gettoken(s,buffer);
-   if (strncmp(token, "-Y ", 3)) {
-       stbi__rewind( s );
-       return 0;
-   }
-   token += 3;
-   *y = (int) strtol(token, &token, 10);
-   while (*token == ' ') ++token;
-   if (strncmp(token, "+X ", 3)) {
-       stbi__rewind( s );
-       return 0;
-   }
-   token += 3;
-   *x = (int) strtol(token, NULL, 10);
-   *comp = 3;
-   return 1;
-}
-#endif // STBI_NO_HDR
-
-#ifndef STBI_NO_BMP
-static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)
-{
-   int hsz;
-   if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') {
-       stbi__rewind( s );
-       return 0;
-   }
-   stbi__skip(s,12);
-   hsz = stbi__get32le(s);
-   if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) {
-       stbi__rewind( s );
-       return 0;
-   }
-   if (hsz == 12) {
-      *x = stbi__get16le(s);
-      *y = stbi__get16le(s);
-   } else {
-      *x = stbi__get32le(s);
-      *y = stbi__get32le(s);
-   }
-   if (stbi__get16le(s) != 1) {
-       stbi__rewind( s );
-       return 0;
-   }
-   *comp = stbi__get16le(s) / 8;
-   return 1;
-}
-#endif
-
-#ifndef STBI_NO_PSD
-static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)
-{
-   int channelCount;
-   if (stbi__get32be(s) != 0x38425053) {
-       stbi__rewind( s );
-       return 0;
-   }
-   if (stbi__get16be(s) != 1) {
-       stbi__rewind( s );
-       return 0;
-   }
-   stbi__skip(s, 6);
-   channelCount = stbi__get16be(s);
-   if (channelCount < 0 || channelCount > 16) {
-       stbi__rewind( s );
-       return 0;
-   }
-   *y = stbi__get32be(s);
-   *x = stbi__get32be(s);
-   if (stbi__get16be(s) != 8) {
-       stbi__rewind( s );
-       return 0;
-   }
-   if (stbi__get16be(s) != 3) {
-       stbi__rewind( s );
-       return 0;
-   }
-   *comp = 4;
-   return 1;
-}
-#endif
-
-#ifndef STBI_NO_PIC
-static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)
-{
-   int act_comp=0,num_packets=0,chained;
-   stbi__pic_packet packets[10];
-
-   stbi__skip(s, 92);
-
-   *x = stbi__get16be(s);
-   *y = stbi__get16be(s);
-   if (stbi__at_eof(s))  return 0;
-   if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {
-       stbi__rewind( s );
-       return 0;
-   }
-
-   stbi__skip(s, 8);
-
-   do {
-      stbi__pic_packet *packet;
-
-      if (num_packets==sizeof(packets)/sizeof(packets[0]))
-         return 0;
-
-      packet = &packets[num_packets++];
-      chained = stbi__get8(s);
-      packet->size    = stbi__get8(s);
-      packet->type    = stbi__get8(s);
-      packet->channel = stbi__get8(s);
-      act_comp |= packet->channel;
-
-      if (stbi__at_eof(s)) {
-          stbi__rewind( s );
-          return 0;
-      }
-      if (packet->size != 8) {
-          stbi__rewind( s );
-          return 0;
-      }
-   } while (chained);
-
-   *comp = (act_comp & 0x10 ? 4 : 3);
-
-   return 1;
-}
-#endif
-
-// *************************************************************************************************
-// Portable Gray Map and Portable Pixel Map loader
-// by Ken Miller
-//
-// PGM: http://netpbm.sourceforge.net/doc/pgm.html
-// PPM: http://netpbm.sourceforge.net/doc/ppm.html
-//
-// Known limitations:
-//    Does not support comments in the header section
-//    Does not support ASCII image data (formats P2 and P3)
-//    Does not support 16-bit-per-channel
-
-#ifndef STBI_NO_PNM
-
-static int      stbi__pnm_test(stbi__context *s)
-{
-   char p, t;
-   p = (char) stbi__get8(s);
-   t = (char) stbi__get8(s);
-   if (p != 'P' || (t != '5' && t != '6')) {
-       stbi__rewind( s );
-       return 0;
-   }
-   return 1;
-}
-
-static stbi_uc *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
-{
-   stbi_uc *out;
-   if (!stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n))
-      return 0;
-   *x = s->img_x;
-   *y = s->img_y;
-   *comp = s->img_n;
-
-   out = (stbi_uc *) stbi__malloc(s->img_n * s->img_x * s->img_y);
-   if (!out) return stbi__errpuc("outofmem", "Out of memory");
-   stbi__getn(s, out, s->img_n * s->img_x * s->img_y);
-
-   if (req_comp && req_comp != s->img_n) {
-      out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
-      if (out == NULL) return out; // stbi__convert_format frees input on failure
-   }
-   return out;
-}
-
-static int      stbi__pnm_isspace(char c)
-{
-   return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
-}
-
-static void     stbi__pnm_skip_whitespace(stbi__context *s, char *c)
-{
-   while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
-      *c = (char) stbi__get8(s);
-}
-
-static int      stbi__pnm_isdigit(char c)
-{
-   return c >= '0' && c <= '9';
-}
-
-static int      stbi__pnm_getinteger(stbi__context *s, char *c)
-{
-   int value = 0;
-
-   while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {
-      value = value*10 + (*c - '0');
-      *c = (char) stbi__get8(s);
-   }
-
-   return value;
-}
-
-static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
-{
-   int maxv;
-   char c, p, t;
-
-   stbi__rewind( s );
-
-   // Get identifier
-   p = (char) stbi__get8(s);
-   t = (char) stbi__get8(s);
-   if (p != 'P' || (t != '5' && t != '6')) {
-       stbi__rewind( s );
-       return 0;
-   }
-
-   *comp = (t == '6') ? 3 : 1;  // '5' is 1-component .pgm; '6' is 3-component .ppm
-
-   c = (char) stbi__get8(s);
-   stbi__pnm_skip_whitespace(s, &c);
-
-   *x = stbi__pnm_getinteger(s, &c); // read width
-   stbi__pnm_skip_whitespace(s, &c);
-
-   *y = stbi__pnm_getinteger(s, &c); // read height
-   stbi__pnm_skip_whitespace(s, &c);
-
-   maxv = stbi__pnm_getinteger(s, &c);  // read max value
-
-   if (maxv > 255)
-      return stbi__err("max value > 255", "PPM image not 8-bit");
-   else
-      return 1;
-}
-#endif
-
-static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)
-{
-   #ifndef STBI_NO_JPEG
-   if (stbi__jpeg_info(s, x, y, comp)) return 1;
-   #endif
-
-   #ifndef STBI_NO_PNG
-   if (stbi__png_info(s, x, y, comp))  return 1;
-   #endif
-
-   #ifndef STBI_NO_GIF
-   if (stbi__gif_info(s, x, y, comp))  return 1;
-   #endif
-
-   #ifndef STBI_NO_BMP
-   if (stbi__bmp_info(s, x, y, comp))  return 1;
-   #endif
-
-   #ifndef STBI_NO_PSD
-   if (stbi__psd_info(s, x, y, comp))  return 1;
-   #endif
-
-   #ifndef STBI_NO_PIC
-   if (stbi__pic_info(s, x, y, comp))  return 1;
-   #endif
-
-   #ifndef STBI_NO_PNM
-   if (stbi__pnm_info(s, x, y, comp))  return 1;
-   #endif
-
-   #ifndef STBI_NO_HDR
-   if (stbi__hdr_info(s, x, y, comp))  return 1;
-   #endif
-
-   // test tga last because it's a crappy test!
-   #ifndef STBI_NO_TGA
-   if (stbi__tga_info(s, x, y, comp))
-       return 1;
-   #endif
-   return stbi__err("unknown image type", "Image not of any known type, or corrupt");
-}
-
-#ifndef STBI_NO_STDIO
-STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
-{
-    FILE *f = stbi__fopen(filename, "rb");
-    int result;
-    if (!f) return stbi__err("can't fopen", "Unable to open file");
-    result = stbi_info_from_file(f, x, y, comp);
-    fclose(f);
-    return result;
-}
-
-STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
-{
-   int r;
-   stbi__context s;
-   long pos = ftell(f);
-   stbi__start_file(&s, f);
-   r = stbi__info_main(&s,x,y,comp);
-   fseek(f,pos,SEEK_SET);
-   return r;
-}
-#endif // !STBI_NO_STDIO
-
-STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
-{
-   stbi__context s;
-   stbi__start_mem(&s,buffer,len);
-   return stbi__info_main(&s,x,y,comp);
-}
-
-STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)
-{
-   stbi__context s;
-   stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
-   return stbi__info_main(&s,x,y,comp);
-}
-
-#endif // STB_IMAGE_IMPLEMENTATION
-
-/*
-   revision history:
-      2.02  (2015-01-19) fix incorrect assert, fix warning
-      2.01  (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2
-      2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG
-      2.00  (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg)
-                         progressive JPEG (stb)
-                         PGM/PPM support (Ken Miller)
-                         STBI_MALLOC,STBI_REALLOC,STBI_FREE
-                         GIF bugfix -- seemingly never worked
-                         STBI_NO_*, STBI_ONLY_*
-      1.48  (2014-12-14) fix incorrectly-named assert()
-      1.47  (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb)
-                         optimize PNG (ryg)
-                         fix bug in interlaced PNG with user-specified channel count (stb)
-      1.46  (2014-08-26)
-              fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG
-      1.45  (2014-08-16)
-              fix MSVC-ARM internal compiler error by wrapping malloc
-      1.44  (2014-08-07)
-              various warning fixes from Ronny Chevalier
-      1.43  (2014-07-15)
-              fix MSVC-only compiler problem in code changed in 1.42
-      1.42  (2014-07-09)
-              don't define _CRT_SECURE_NO_WARNINGS (affects user code)
-              fixes to stbi__cleanup_jpeg path
-              added STBI_ASSERT to avoid requiring assert.h
-      1.41  (2014-06-25)
-              fix search&replace from 1.36 that messed up comments/error messages
-      1.40  (2014-06-22)
-              fix gcc struct-initialization warning
-      1.39  (2014-06-15)
-              fix to TGA optimization when req_comp != number of components in TGA;
-              fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite)
-              add support for BMP version 5 (more ignored fields)
-      1.38  (2014-06-06)
-              suppress MSVC warnings on integer casts truncating values
-              fix accidental rename of 'skip' field of I/O
-      1.37  (2014-06-04)
-              remove duplicate typedef
-      1.36  (2014-06-03)
-              convert to header file single-file library
-              if de-iphone isn't set, load iphone images color-swapped instead of returning NULL
-      1.35  (2014-05-27)
-              various warnings
-              fix broken STBI_SIMD path
-              fix bug where stbi_load_from_file no longer left file pointer in correct place
-              fix broken non-easy path for 32-bit BMP (possibly never used)
-              TGA optimization by Arseny Kapoulkine
-      1.34  (unknown)
-              use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case
-      1.33  (2011-07-14)
-              make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements
-      1.32  (2011-07-13)
-              support for "info" function for all supported filetypes (SpartanJ)
-      1.31  (2011-06-20)
-              a few more leak fixes, bug in PNG handling (SpartanJ)
-      1.30  (2011-06-11)
-              added ability to load files via callbacks to accomidate custom input streams (Ben Wenger)
-              removed deprecated format-specific test/load functions
-              removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway
-              error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha)
-              fix inefficiency in decoding 32-bit BMP (David Woo)
-      1.29  (2010-08-16)
-              various warning fixes from Aurelien Pocheville
-      1.28  (2010-08-01)
-              fix bug in GIF palette transparency (SpartanJ)
-      1.27  (2010-08-01)
-              cast-to-stbi_uc to fix warnings
-      1.26  (2010-07-24)
-              fix bug in file buffering for PNG reported by SpartanJ
-      1.25  (2010-07-17)
-              refix trans_data warning (Won Chun)
-      1.24  (2010-07-12)
-              perf improvements reading from files on platforms with lock-heavy fgetc()
-              minor perf improvements for jpeg
-              deprecated type-specific functions so we'll get feedback if they're needed
-              attempt to fix trans_data warning (Won Chun)
-      1.23    fixed bug in iPhone support
-      1.22  (2010-07-10)
-              removed image *writing* support
-              stbi_info support from Jetro Lauha
-              GIF support from Jean-Marc Lienher
-              iPhone PNG-extensions from James Brown
-              warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva)
-      1.21    fix use of 'stbi_uc' in header (reported by jon blow)
-      1.20    added support for Softimage PIC, by Tom Seddon
-      1.19    bug in interlaced PNG corruption check (found by ryg)
-      1.18 2008-08-02
-              fix a threading bug (local mutable static)
-      1.17    support interlaced PNG
-      1.16    major bugfix - stbi__convert_format converted one too many pixels
-      1.15    initialize some fields for thread safety
-      1.14    fix threadsafe conversion bug
-              header-file-only version (#define STBI_HEADER_FILE_ONLY before including)
-      1.13    threadsafe
-      1.12    const qualifiers in the API
-      1.11    Support installable IDCT, colorspace conversion routines
-      1.10    Fixes for 64-bit (don't use "unsigned long")
-              optimized upsampling by Fabian "ryg" Giesen
-      1.09    Fix format-conversion for PSD code (bad global variables!)
-      1.08    Thatcher Ulrich's PSD code integrated by Nicolas Schulz
-      1.07    attempt to fix C++ warning/errors again
-      1.06    attempt to fix C++ warning/errors again
-      1.05    fix TGA loading to return correct *comp and use good luminance calc
-      1.04    default float alpha is 1, not 255; use 'void *' for stbi_image_free
-      1.03    bugfixes to STBI_NO_STDIO, STBI_NO_HDR
-      1.02    support for (subset of) HDR files, float interface for preferred access to them
-      1.01    fix bug: possible bug in handling right-side up bmps... not sure
-              fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all
-      1.00    interface to zlib that skips zlib header
-      0.99    correct handling of alpha in palette
-      0.98    TGA loader by lonesock; dynamically add loaders (untested)
-      0.97    jpeg errors on too large a file; also catch another malloc failure
-      0.96    fix detection of invalid v value - particleman@mollyrocket forum
-      0.95    during header scan, seek to markers in case of padding
-      0.94    STBI_NO_STDIO to disable stdio usage; rename all #defines the same
-      0.93    handle jpegtran output; verbose errors
-      0.92    read 4,8,16,24,32-bit BMP files of several formats
-      0.91    output 24-bit Windows 3.0 BMP files
-      0.90    fix a few more warnings; bump version number to approach 1.0
-      0.61    bugfixes due to Marc LeBlanc, Christopher Lloyd
-      0.60    fix compiling as c++
-      0.59    fix warnings: merge Dave Moore's -Wall fixes
-      0.58    fix bug: zlib uncompressed mode len/nlen was wrong endian
-      0.57    fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available
-      0.56    fix bug: zlib uncompressed mode len vs. nlen
-      0.55    fix bug: restart_interval not initialized to 0
-      0.54    allow NULL for 'int *comp'
-      0.53    fix bug in png 3->4; speedup png decoding
-      0.52    png handles req_comp=3,4 directly; minor cleanup; jpeg comments
-      0.51    obey req_comp requests, 1-component jpegs return as 1-component,
-              on 'test' only check type, not whether we support this variant
-      0.50    first released version
-*/
\ No newline at end of file
@@ -0,0 +1,55 @@
+#ifndef SYSTEM_H_B61A8CEA
+#define SYSTEM_H_B61A8CEA
+
+#include "entity_manager.h"
+
+class Game;
+class Texture;
+
+class System {
+public:
+
+  using id_type = EntityManager::id_type;
+
+  System(Game& game) : game_(game)
+  {
+  }
+
+  virtual ~System() = default;
+
+  /**
+   * Updates the state of a system.
+   *
+   * @param dt - The amount of time in seconds that have passed since the last
+   *             update.
+   */
+  virtual void tick(double)
+  {
+  }
+
+  /**
+   * Renders to a texture.
+   *
+   * @param texture - The surface to render to.
+   */
+  virtual void render(Texture&)
+  {
+  }
+
+  /**
+   * Processes keyboard input.
+   *
+   * @param key - The relevant key.
+   *
+   * @param action - The action performed (press, released, etc).
+   */
+  virtual void input(int, int)
+  {
+  }
+
+protected:
+
+  Game& game_;
+};
+
+#endif /* end of include guard: SYSTEM_H_B61A8CEA */
@@ -0,0 +1,68 @@
+#ifndef SYSTEM_MANAGER_H_544E6056
+#define SYSTEM_MANAGER_H_544E6056
+
+#include <list>
+#include <memory>
+#include <map>
+#include <typeindex>
+#include <stdexcept>
+#include "system.h"
+
+class SystemManager {
+private:
+
+  std::list<std::unique_ptr<System>> loop;
+  std::map<std::type_index, System*> systems;
+
+public:
+
+  template <class T, class... Args>
+  void emplaceSystem(Game& game, Args&&... args)
+  {
+    std::unique_ptr<T> ptr(new T(game, std::forward<Args>(args)...));
+    std::type_index systemType = typeid(T);
+
+    systems[systemType] = ptr.get();
+    loop.push_back(std::move(ptr));
+  }
+
+  template <class T>
+  T& getSystem()
+  {
+    std::type_index systemType = typeid(T);
+
+    if (!systems.count(systemType))
+    {
+      throw std::invalid_argument("Cannot get non-existent system");
+    }
+
+    return *dynamic_cast<T*>(systems[systemType]);
+  }
+
+  void tick(double dt)
+  {
+    for (std::unique_ptr<System>& sys : loop)
+    {
+      sys->tick(dt);
+    }
+  }
+
+  virtual void render(Texture& texture)
+  {
+    for (std::unique_ptr<System>& sys : loop)
+    {
+      sys->render(texture);
+    }
+  }
+
+  virtual void input(int key, int action)
+  {
+    for (std::unique_ptr<System>& sys : loop)
+    {
+      sys->input(key, action);
+    }
+  }
+
+};
+
+#endif /* end of include guard: SYSTEM_MANAGER_H_544E6056 */
@@ -0,0 +1,103 @@
+#include "animating.h"
+#include "game.h"
+#include "components/animatable.h"
+#include "components/transformable.h"
+
+void AnimatingSystem::tick(double)
+{
+  std::set<id_type> spriteEntities =
+    game_.getEntityManager().getEntitiesWithComponents<AnimatableComponent>();
+
+  for (id_type entity : spriteEntities)
+  {
+    auto& sprite = game_.getEntityManager().
+      getComponent<AnimatableComponent>(entity);
+
+    if (sprite.active)
+    {
+      if (!sprite.frozen)
+      {
+        sprite.countdown++;
+      }
+
+      const Animation& anim = sprite.getAnimation();
+      if (sprite.countdown >= anim.getDelay())
+      {
+        sprite.frame++;
+        sprite.countdown = 0;
+
+        if (sprite.frame >= anim.getFirstFrame() + anim.getNumFrames())
+        {
+          sprite.frame = anim.getFirstFrame();
+        }
+      }
+
+      if (sprite.flickering)
+      {
+        sprite.flickerTimer = (sprite.flickerTimer + 1) % 6;
+      }
+    }
+  }
+}
+
+void AnimatingSystem::render(Texture& texture)
+{
+  std::set<id_type> spriteEntities =
+    game_.getEntityManager().getEntitiesWithComponents<
+      AnimatableComponent,
+      TransformableComponent>();
+
+  for (id_type entity : spriteEntities)
+  {
+    auto& sprite = game_.getEntityManager().
+      getComponent<AnimatableComponent>(entity);
+
+    if (sprite.active)
+    {
+      auto& transform = game_.getEntityManager().
+        getComponent<TransformableComponent>(entity);
+
+      double alpha = 1.0;
+      if (sprite.flickering && (sprite.flickerTimer < 3))
+      {
+        alpha = 0.0;
+      }
+
+      Rectangle dstrect {
+        static_cast<int>(transform.pos.x()),
+        static_cast<int>(transform.pos.y()),
+        transform.size.w(),
+        transform.size.h()};
+
+      const AnimationSet& aset = sprite.animationSet;
+      game_.getRenderer().blit(
+        aset.getTexture(),
+        texture,
+        aset.getFrameRect(sprite.frame),
+        dstrect,
+        alpha);
+    }
+  }
+}
+
+void AnimatingSystem::initPrototype(id_type entity)
+{
+  auto& sprite = game_.getEntityManager().
+    getComponent<AnimatableComponent>(entity);
+
+  startAnimation(entity, sprite.origAnimation);
+
+  sprite.countdown = 0;
+  sprite.flickering = false;
+  sprite.flickerTimer = 0;
+  sprite.frozen = false;
+}
+
+void AnimatingSystem::startAnimation(id_type entity, std::string animation)
+{
+  auto& sprite = game_.getEntityManager().
+    getComponent<AnimatableComponent>(entity);
+
+  sprite.animation = std::move(animation);
+  sprite.frame = sprite.getAnimation().getFirstFrame();
+}
@@ -0,0 +1,25 @@
+#ifndef ANIMATING_H_5BBF0094
+#define ANIMATING_H_5BBF0094
+
+#include "system.h"
+#include <string>
+#include "renderer/texture.h"
+
+class AnimatingSystem : public System {
+public:
+
+  AnimatingSystem(Game& game) : System(game)
+  {
+  }
+
+  void tick(double dt);
+
+  void render(Texture& texture);
+
+  void initPrototype(id_type entity);
+
+  void startAnimation(id_type entity, std::string animation);
+
+};
+
+#endif /* end of include guard: ANIMATING_H_5BBF0094 */
@@ -0,0 +1,136 @@
+#include "controlling.h"
+#include "game.h"
+#include "components/controllable.h"
+#include "components/orientable.h"
+#include "systems/orienting.h"
+
+void ControllingSystem::tick(double)
+{
+  while (!actions_.empty())
+  {
+    int key = actions_.front().first;
+    int action = actions_.front().second;
+
+    auto entities = game_.getEntityManager().getEntitiesWithComponents<
+      ControllableComponent,
+      OrientableComponent>();
+
+    for (auto entity : entities)
+    {
+      auto& controllable = game_.getEntityManager().
+        getComponent<ControllableComponent>(entity);
+
+      auto& orienting = game_.getSystemManager().getSystem<OrientingSystem>();
+
+      if (action == GLFW_PRESS)
+      {
+        if (key == controllable.getLeftKey())
+        {
+          controllable.setHoldingLeft(true);
+
+          if (!controllable.isFrozen())
+          {
+            orienting.moveLeft(entity);
+          }
+        } else if (key == controllable.getRightKey())
+        {
+          controllable.setHoldingRight(true);
+
+          if (!controllable.isFrozen())
+          {
+            orienting.moveRight(entity);
+          }
+        } else if (key == controllable.getJumpKey())
+        {
+          if (!controllable.isFrozen())
+          {
+            orienting.jump(entity);
+          }
+        } else if (key == controllable.getDropKey())
+        {
+          if (!controllable.isFrozen())
+          {
+            orienting.drop(entity);
+          }
+        }
+      } else if (action == GLFW_RELEASE)
+      {
+        if (key == controllable.getLeftKey())
+        {
+          controllable.setHoldingLeft(false);
+
+          if (!controllable.isFrozen())
+          {
+            if (controllable.isHoldingRight())
+            {
+              orienting.moveRight(entity);
+            } else {
+              orienting.stopWalking(entity);
+            }
+          }
+        } else if (key == controllable.getRightKey())
+        {
+          controllable.setHoldingRight(false);
+
+          if (!controllable.isFrozen())
+          {
+            if (controllable.isHoldingLeft())
+            {
+              orienting.moveLeft(entity);
+            } else {
+              orienting.stopWalking(entity);
+            }
+          }
+        } else if (key == controllable.getDropKey())
+        {
+          if (!controllable.isFrozen())
+          {
+            orienting.stopDropping(entity);
+          }
+        } else if (key == controllable.getJumpKey())
+        {
+          if (!controllable.isFrozen())
+          {
+            orienting.stopJumping(entity);
+          }
+        }
+      }
+    }
+
+    actions_.pop();
+  }
+}
+
+void ControllingSystem::input(int key, int action)
+{
+  actions_.push(std::make_pair(key, action));
+}
+
+void ControllingSystem::freeze(id_type entity)
+{
+  auto& controllable = game_.getEntityManager().
+    getComponent<ControllableComponent>(entity);
+
+  controllable.setFrozen(true);
+}
+
+void ControllingSystem::unfreeze(id_type entity)
+{
+  auto& controllable = game_.getEntityManager().
+    getComponent<ControllableComponent>(entity);
+
+  if (controllable.isFrozen())
+  {
+    controllable.setFrozen(false);
+
+    auto& orienting = game_.getSystemManager().getSystem<OrientingSystem>();
+
+    if (controllable.isHoldingLeft())
+    {
+      orienting.moveLeft(entity);
+    } else if (controllable.isHoldingRight())
+    {
+      orienting.moveRight(entity);
+    }
+  }
+}
@@ -0,0 +1,27 @@
+#ifndef CONTROLLING_H_80B1BB8D
+#define CONTROLLING_H_80B1BB8D
+
+#include "system.h"
+#include <queue>
+
+class ControllingSystem : public System {
+public:
+
+  ControllingSystem(Game& game) : System(game)
+  {
+  }
+
+  void tick(double dt);
+
+  void input(int key, int action);
+
+  void freeze(id_type entity);
+
+  void unfreeze(id_type entity);
+
+private:
+
+  std::queue<std::pair<int,int>> actions_;
+};
+
+#endif /* end of include guard: CONTROLLING_H_80B1BB8D */
@@ -0,0 +1,187 @@
+#include "mapping.h"
+#include "components/mappable.h"
+#include "systems/realizing.h"
+#include "game.h"
+#include "consts.h"
+
+template <typename Storage>
+inline void addBoundary(
+  Storage& boundaries,
+  int axis,
+  int lower,
+  int upper,
+  MappableComponent::Boundary::Type type)
+{
+  boundaries.emplace(std::piecewise_construct,
+    std::tie(axis),
+    std::tie(axis, lower, upper, type));
+}
+
+void MappingSystem::render(Texture& texture)
+{
+  id_type map =
+    game_.getSystemManager().getSystem<RealizingSystem>().getActiveMap();
+
+  auto& mappable = game_.getEntityManager().
+    getComponent<MappableComponent>(map);
+
+  for (int i = 0; i < MAP_WIDTH * MAP_HEIGHT; i++)
+  {
+    int x = i % MAP_WIDTH;
+    int y = i / MAP_WIDTH;
+    int tile = mappable.tiles[i];
+
+    if (tile > 0)
+    {
+      Rectangle dst {
+        x * TILE_WIDTH,
+        y * TILE_HEIGHT,
+        TILE_WIDTH,
+        TILE_HEIGHT};
+
+      Rectangle src {
+        (tile % TILESET_COLS) * TILE_WIDTH,
+        (tile / TILESET_COLS) * TILE_HEIGHT,
+        TILE_WIDTH,
+        TILE_HEIGHT};
+
+      game_.getRenderer().blit(
+        mappable.tileset,
+        texture,
+        std::move(src),
+        std::move(dst));
+    }
+  }
+
+  int startX = ((GAME_WIDTH / TILE_WIDTH) / 2) - (mappable.title.size() / 2);
+
+  for (size_t i = 0; i < mappable.title.size(); i++)
+  {
+    Rectangle src {
+      (mappable.title[i] % FONT_COLS) * TILE_WIDTH,
+      (mappable.title[i] / FONT_COLS) * TILE_HEIGHT,
+      TILE_WIDTH,
+      TILE_HEIGHT};
+
+    Rectangle dst {
+      (startX + static_cast<int>(i)) * TILE_WIDTH,
+      24 * TILE_HEIGHT,
+      TILE_WIDTH,
+      TILE_HEIGHT};
+
+    game_.getRenderer().blit(
+      mappable.font,
+      texture,
+      std::move(src),
+      std::move(dst));
+  }
+}
+
+void MappingSystem::generateBoundaries(id_type mapEntity)
+{
+  auto& mappable = game_.getEntityManager().
+    getComponent<MappableComponent>(mapEntity);
+
+  addBoundary(
+    mappable.leftBoundaries,
+    -WALL_GAP,
+    0,
+    MAP_HEIGHT * TILE_HEIGHT,
+    MappableComponent::Boundary::Type::adjacency);
+
+  addBoundary(
+    mappable.rightBoundaries,
+    GAME_WIDTH + WALL_GAP,
+    0,
+    MAP_HEIGHT * TILE_HEIGHT,
+    MappableComponent::Boundary::Type::adjacency);
+
+  addBoundary(
+    mappable.upBoundaries,
+    -WALL_GAP,
+    0,
+    GAME_WIDTH,
+    MappableComponent::Boundary::Type::adjacency);
+
+  addBoundary(
+    mappable.downBoundaries,
+    MAP_HEIGHT * TILE_HEIGHT + WALL_GAP,
+    0,
+    GAME_WIDTH,
+    MappableComponent::Boundary::Type::adjacency);
+
+  for (size_t i = 0; i < MAP_WIDTH * MAP_HEIGHT; i++)
+  {
+    size_t x = i % MAP_WIDTH;
+    size_t y = i / MAP_WIDTH;
+    int tile = mappable.tiles[i];
+
+    if ((tile >= 5) && (tile <= 7))
+    {
+      addBoundary(
+        mappable.downBoundaries,
+        y * TILE_HEIGHT,
+        x * TILE_WIDTH,
+        (x + 1) * TILE_WIDTH,
+        MappableComponent::Boundary::Type::platform);
+    } else if ((tile > 0) && (tile < 28))
+    {
+      addBoundary(
+        mappable.rightBoundaries,
+        x * TILE_WIDTH,
+        y * TILE_HEIGHT,
+        (y+1) * TILE_HEIGHT,
+        MappableComponent::Boundary::Type::wall);
+
+      addBoundary(
+        mappable.leftBoundaries,
+        (x+1) * TILE_WIDTH,
+        y * TILE_HEIGHT,
+        (y+1) * TILE_HEIGHT,
+        MappableComponent::Boundary::Type::wall);
+
+      addBoundary(
+        mappable.downBoundaries,
+        y * TILE_HEIGHT,
+        x * TILE_WIDTH,
+        (x+1) * TILE_WIDTH,
+        MappableComponent::Boundary::Type::wall);
+
+      addBoundary(
+        mappable.upBoundaries,
+        (y+1) * TILE_HEIGHT,
+        x * TILE_WIDTH,
+        (x+1) * TILE_WIDTH,
+        MappableComponent::Boundary::Type::wall);
+    } else if (tile == 42)
+    {
+      addBoundary(
+        mappable.rightBoundaries,
+        x * TILE_WIDTH,
+        y * TILE_HEIGHT,
+        (y+1) * TILE_HEIGHT,
+        MappableComponent::Boundary::Type::danger);
+
+      addBoundary(
+        mappable.leftBoundaries,
+        (x+1) * TILE_WIDTH,
+        y * TILE_HEIGHT,
+        (y+1) * TILE_HEIGHT,
+        MappableComponent::Boundary::Type::danger);
+
+      addBoundary(
+        mappable.downBoundaries,
+        y * TILE_HEIGHT + 1,
+        x * TILE_WIDTH,
+        (x+1) * TILE_WIDTH,
+        MappableComponent::Boundary::Type::danger);
+
+      addBoundary(
+        mappable.upBoundaries,
+        (y+1) * TILE_HEIGHT,
+        x * TILE_WIDTH,
+        (x+1) * TILE_WIDTH,
+        MappableComponent::Boundary::Type::danger);
+    }
+  }
+}
@@ -0,0 +1,19 @@
+#ifndef MAPPING_H_33FC2294
+#define MAPPING_H_33FC2294
+
+#include "system.h"
+
+class MappingSystem : public System {
+public:
+
+  MappingSystem(Game& game) : System(game)
+  {
+  }
+
+  void render(Texture& texture);
+
+  void generateBoundaries(id_type mapEntity);
+
+};
+
+#endif /* end of include guard: MAPPING_H_33FC2294 */
@@ -0,0 +1,230 @@
+#include "orienting.h"
+#include "game.h"
+#include "components/orientable.h"
+#include "components/ponderable.h"
+#include "systems/animating.h"
+#include "consts.h"
+#include "muxer.h"
+
+void OrientingSystem::tick(double)
+{
+  auto entities = game_.getEntityManager().getEntitiesWithComponents<
+    OrientableComponent,
+    PonderableComponent>();
+
+  for (id_type entity : entities)
+  {
+    auto& orientable = game_.getEntityManager().
+      getComponent<OrientableComponent>(entity);
+
+    auto& ponderable = game_.getEntityManager().
+      getComponent<PonderableComponent>(entity);
+
+    switch (orientable.getWalkState())
+    {
+      case OrientableComponent::WalkState::still:
+      {
+        ponderable.vel.x() = 0.0;
+
+        break;
+      }
+
+      case OrientableComponent::WalkState::left:
+      {
+        ponderable.vel.x() = -WALK_SPEED;
+
+        break;
+      }
+
+      case OrientableComponent::WalkState::right:
+      {
+        ponderable.vel.x() = WALK_SPEED;
+
+        break;
+      }
+    }
+
+    if (orientable.isJumping() && (ponderable.vel.y() > 0))
+    {
+      orientable.setJumping(false);
+    }
+  }
+}
+
+void OrientingSystem::moveLeft(id_type entity)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  orientable.setFacingRight(false);
+  orientable.setWalkState(OrientableComponent::WalkState::left);
+
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+  if (ponderable.grounded)
+  {
+    animating.startAnimation(entity, "walkingLeft");
+  } else {
+    animating.startAnimation(entity, "stillLeft");
+  }
+}
+
+void OrientingSystem::moveRight(id_type entity)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  orientable.setFacingRight(true);
+  orientable.setWalkState(OrientableComponent::WalkState::right);
+
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+  if (ponderable.grounded)
+  {
+    animating.startAnimation(entity, "walkingRight");
+  } else {
+    animating.startAnimation(entity, "stillRight");
+  }
+}
+
+void OrientingSystem::stopWalking(id_type entity)
+{
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  orientable.setWalkState(OrientableComponent::WalkState::still);
+
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+
+  if (orientable.isFacingRight())
+  {
+    animating.startAnimation(entity, "stillRight");
+  } else {
+    animating.startAnimation(entity, "stillLeft");
+  }
+}
+
+void OrientingSystem::jump(id_type entity)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  if (ponderable.grounded)
+  {
+    auto& orientable = game_.getEntityManager().
+      getComponent<OrientableComponent>(entity);
+
+    orientable.setJumping(true);
+
+    playSound("res/Randomize87.wav", 0.25);
+
+    ponderable.vel.y() = JUMP_VELOCITY;
+    ponderable.accel.y() = JUMP_GRAVITY;
+
+    auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+    if (orientable.isFacingRight())
+    {
+      animating.startAnimation(entity, "stillRight");
+    } else {
+      animating.startAnimation(entity, "stillLeft");
+    }
+  }
+}
+
+void OrientingSystem::stopJumping(id_type entity)
+{
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  if (orientable.isJumping())
+  {
+    orientable.setJumping(false);
+
+    auto& ponderable = game_.getEntityManager().
+      getComponent<PonderableComponent>(entity);
+
+    ponderable.accel.y() = NORMAL_GRAVITY;
+  }
+}
+
+void OrientingSystem::land(id_type entity)
+{
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+
+  switch (orientable.getWalkState())
+  {
+    case OrientableComponent::WalkState::still:
+    {
+      if (orientable.isFacingRight())
+      {
+        animating.startAnimation(entity, "stillRight");
+      } else {
+        animating.startAnimation(entity, "stillLeft");
+      }
+
+      break;
+    }
+
+    case OrientableComponent::WalkState::left:
+    {
+      animating.startAnimation(entity, "walkingLeft");
+
+      break;
+    }
+
+    case OrientableComponent::WalkState::right:
+    {
+      animating.startAnimation(entity, "walkingRight");
+
+      break;
+    }
+  }
+}
+
+void OrientingSystem::startFalling(id_type entity)
+{
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+
+  if (orientable.isFacingRight())
+  {
+    animating.startAnimation(entity, "stillRight");
+  } else {
+    animating.startAnimation(entity, "stillLeft");
+  }
+}
+
+void OrientingSystem::drop(id_type entity)
+{
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  if (ponderable.grounded
+    && (orientable.getDropState() == OrientableComponent::DropState::none))
+  {
+    orientable.setDropState(OrientableComponent::DropState::ready);
+  }
+}
+
+void OrientingSystem::stopDropping(id_type entity)
+{
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  if (orientable.getDropState() == OrientableComponent::DropState::ready)
+  {
+    orientable.setDropState(OrientableComponent::DropState::none);
+  }
+}
@@ -0,0 +1,35 @@
+#ifndef ORIENTING_H_099F0C23
+#define ORIENTING_H_099F0C23
+
+#include "system.h"
+
+class OrientingSystem : public System {
+public:
+
+  OrientingSystem(Game& game) : System(game)
+  {
+  }
+
+  void tick(double dt);
+
+  void moveLeft(id_type entity);
+
+  void moveRight(id_type entity);
+
+  void stopWalking(id_type entity);
+
+  void jump(id_type entity);
+
+  void stopJumping(id_type entity);
+
+  void land(id_type entity);
+
+  void startFalling(id_type entity);
+
+  void drop(id_type entity);
+
+  void stopDropping(id_type entity);
+
+};
+
+#endif /* end of include guard: ORIENTING_H_099F0C23 */
@@ -0,0 +1,144 @@
+#include "playing.h"
+#include "game.h"
+#include "components/transformable.h"
+#include "components/animatable.h"
+#include "components/playable.h"
+#include "components/controllable.h"
+#include "components/orientable.h"
+#include "systems/mapping.h"
+#include "systems/pondering.h"
+#include "systems/orienting.h"
+#include "systems/scheduling.h"
+#include "systems/controlling.h"
+#include "systems/animating.h"
+#include "systems/realizing.h"
+#include "animation.h"
+#include "muxer.h"
+
+void PlayingSystem::initPlayer()
+{
+  id_type player = game_.getEntityManager().emplaceEntity();
+
+  AnimationSet playerGraphics {"res/Starla.png", 10, 12, 6};
+  playerGraphics.emplaceAnimation("stillLeft", 3, 1, 1);
+  playerGraphics.emplaceAnimation("stillRight", 0, 1, 1);
+  playerGraphics.emplaceAnimation("walkingLeft", 4, 2, 10);
+  playerGraphics.emplaceAnimation("walkingRight", 1, 2, 10);
+
+  game_.getEntityManager().emplaceComponent<AnimatableComponent>(
+    player,
+    std::move(playerGraphics));
+
+  game_.getSystemManager().getSystem<AnimatingSystem>().startAnimation(
+    player,
+    "stillLeft");
+
+  auto& realizing = game_.getSystemManager().getSystem<RealizingSystem>();
+
+  auto& transformable = game_.getEntityManager().
+    emplaceComponent<TransformableComponent>(player);
+
+  transformable.pos = realizing.getStartingPos();
+  transformable.size.w() = 10;
+  transformable.size.h() = 12;
+
+  game_.getSystemManager().getSystem<PonderingSystem>().initializeBody(
+    player,
+    PonderableComponent::Type::freefalling);
+
+  game_.getEntityManager().emplaceComponent<ControllableComponent>(player);
+  game_.getEntityManager().emplaceComponent<OrientableComponent>(player);
+
+  auto& playable = game_.getEntityManager().
+    emplaceComponent<PlayableComponent>(player);
+
+  playable.mapId = realizing.getActiveMap();
+  playable.checkpointMapId = realizing.getStartingMapId();
+  playable.checkpointPos = realizing.getStartingPos();
+
+  realizing.enterActiveMap(player);
+
+  realizing.setActivePlayer(player);
+}
+
+void PlayingSystem::changeMap(
+  id_type player,
+  size_t mapId,
+  vec2d warpPos)
+{
+  auto& playable = game_.getEntityManager().
+    getComponent<PlayableComponent>(player);
+
+  auto& transformable = game_.getEntityManager().
+    getComponent<TransformableComponent>(player);
+
+  auto& pondering = game_.getSystemManager().getSystem<PonderingSystem>();
+  auto& realizing = game_.getSystemManager().getSystem<RealizingSystem>();
+
+  id_type newMapEntity = realizing.getEntityByMapId(mapId);
+
+  if (playable.mapId != newMapEntity)
+  {
+    if (playable.mapId == realizing.getActiveMap())
+    {
+      realizing.leaveActiveMap(player);
+    } else if (newMapEntity == realizing.getActiveMap())
+    {
+      realizing.enterActiveMap(player);
+    }
+
+    playable.mapId = newMapEntity;
+  }
+
+  pondering.unferry(player);
+
+  transformable.pos = warpPos;
+
+  if (realizing.getActivePlayer() == player)
+  {
+    realizing.loadMap(newMapEntity);
+  }
+}
+
+void PlayingSystem::die(id_type player)
+{
+  playSound("res/Hit_Hurt5.wav", 0.25);
+
+  auto& animatable = game_.getEntityManager().
+    getComponent<AnimatableComponent>(player);
+
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(player);
+
+  auto& controlling = game_.getSystemManager().getSystem<ControllingSystem>();
+  controlling.freeze(player);
+
+  animatable.frozen = true;
+  animatable.flickering = true;
+  ponderable.frozen = true;
+  ponderable.collidable = false;
+
+  auto& scheduling = game_.getSystemManager().getSystem<SchedulingSystem>();
+
+  scheduling.schedule(player, 0.75, [&] (id_type player) {
+    auto& playable = game_.getEntityManager().
+      getComponent<PlayableComponent>(player);
+
+    changeMap(
+      player,
+      playable.checkpointMapId,
+      playable.checkpointPos);
+
+    animatable.frozen = false;
+    animatable.flickering = false;
+    ponderable.frozen = false;
+    ponderable.collidable = true;
+
+    // Reset the walk state, and then potentially let the
+    // ControllingSystem set it again.
+    auto& orienting = game_.getSystemManager().getSystem<OrientingSystem>();
+    orienting.stopWalking(player);
+
+    controlling.unfreeze(player);
+  });
+}
@@ -0,0 +1,25 @@
+#ifndef PLAYING_H_70A54F7D
+#define PLAYING_H_70A54F7D
+
+#include "system.h"
+#include "vector.h"
+
+class PlayingSystem : public System {
+public:
+
+  PlayingSystem(Game& game) : System(game)
+  {
+  }
+
+  void initPlayer();
+
+  void changeMap(
+    id_type player,
+    size_t mapId,
+    vec2d warpPos);
+
+  void die(id_type player);
+
+};
+
+#endif /* end of include guard: PLAYING_H_70A54F7D */
@@ -0,0 +1,916 @@
+#include "pondering.h"
+#include <queue>
+#include <algorithm>
+#include "game.h"
+#include "components/ponderable.h"
+#include "components/transformable.h"
+#include "components/orientable.h"
+#include "components/mappable.h"
+#include "components/playable.h"
+#include "systems/orienting.h"
+#include "systems/playing.h"
+#include "systems/realizing.h"
+#include "systems/scripting.h"
+#include "consts.h"
+
+void PonderingSystem::tick(double dt)
+{
+  auto entities = game_.getEntityManager().getEntitiesWithComponents<
+    PonderableComponent,
+    TransformableComponent>();
+
+  for (id_type entity : entities)
+  {
+    auto& ponderable = game_.getEntityManager().
+      getComponent<PonderableComponent>(entity);
+
+    // We will recursively process ferried bodies after their ferries have been
+    // processed, so hold off on processing ferried bodies at the top level.
+    if (ponderable.ferried)
+    {
+      continue;
+    }
+
+    tickBody(entity, dt);
+  }
+}
+
+void PonderingSystem::initializeBody(
+  id_type entity,
+  PonderableComponent::Type type)
+{
+  auto& ponderable = game_.getEntityManager().
+    emplaceComponent<PonderableComponent>(entity, type);
+
+  if (type == PonderableComponent::Type::freefalling)
+  {
+    ponderable.accel.y() = NORMAL_GRAVITY;
+  }
+}
+
+void PonderingSystem::initPrototype(id_type prototype)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(prototype);
+
+  ponderable.vel.x() = 0.0;
+  ponderable.vel.y() = 0.0;
+  ponderable.accel.x() = 0.0;
+  ponderable.accel.y() = 0.0;
+  ponderable.grounded = false;
+  ponderable.frozen = false;
+  ponderable.collidable = true;
+  ponderable.ferried = false;
+  ponderable.passengers.clear();
+}
+
+void PonderingSystem::unferry(id_type entity)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  if (ponderable.ferried)
+  {
+    ponderable.ferried = false;
+
+    auto& ferryPonder = game_.getEntityManager().
+      getComponent<PonderableComponent>(ponderable.ferry);
+
+    ferryPonder.passengers.erase(entity);
+  }
+}
+
+void PonderingSystem::tickBody(
+  id_type entity,
+  double dt)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  if (!ponderable.active)
+  {
+    return;
+  }
+
+  auto& transformable = game_.getEntityManager().
+    getComponent<TransformableComponent>(entity);
+
+  // Accelerate
+  if (!ponderable.frozen)
+  {
+    ponderable.vel += ponderable.accel * dt;
+
+    if ((ponderable.type == PonderableComponent::Type::freefalling)
+      && (ponderable.vel.y() > TERMINAL_VELOCITY))
+    {
+      ponderable.vel.y() = TERMINAL_VELOCITY;
+    }
+  }
+
+  // Move
+  vec2d newPos = transformable.pos;
+
+  if (!ponderable.frozen)
+  {
+    newPos += ponderable.vel * dt;
+  }
+
+  CollisionResult result = moveBody(entity, newPos);
+
+  // Perform cleanup for orientable entites
+  bool groundedChanged = (ponderable.grounded != result.grounded);
+  ponderable.grounded = result.grounded;
+
+  if (game_.getEntityManager().hasComponent<OrientableComponent>(entity))
+  {
+    auto& orientable = game_.getEntityManager().
+      getComponent<OrientableComponent>(entity);
+
+    // Handle changes in groundedness
+    if (groundedChanged)
+    {
+      if (ponderable.grounded)
+      {
+        game_.getSystemManager().getSystem<OrientingSystem>().land(entity);
+      } else {
+        game_.getSystemManager().
+          getSystem<OrientingSystem>().startFalling(entity);
+      }
+    }
+
+    // Complete dropping, if necessary
+    if (orientable.getDropState() == OrientableComponent::DropState::active)
+    {
+      orientable.setDropState(OrientableComponent::DropState::none);
+    }
+  }
+
+  // Ferry or unferry as necessary
+  if ((ponderable.type == PonderableComponent::Type::freefalling) &&
+      groundedChanged)
+  {
+    if (ponderable.grounded &&
+        game_.getEntityManager().
+          hasComponent<PonderableComponent>(result.groundEntity))
+    {
+      // The body is now being ferried
+      auto& ferryPonder = game_.getEntityManager().
+        getComponent<PonderableComponent>(result.groundEntity);
+
+      ponderable.ferried = true;
+      ponderable.ferry = result.groundEntity;
+      ponderable.ferrySide = Direction::up;
+
+      ferryPonder.passengers.insert(entity);
+    } else if (ponderable.ferried)
+    {
+      // The body is no longer being ferried
+      unferry(entity);
+    }
+  }
+
+  // Handle ferry passengers
+  std::set<id_type> passengers = ponderable.passengers;
+
+  for (id_type passenger : passengers)
+  {
+    tickBody(passenger, dt);
+  }
+}
+
+PonderingSystem::CollisionResult PonderingSystem::moveBody(
+  id_type entity,
+  vec2d newPos)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  CollisionResult result;
+
+  if (ponderable.collidable)
+  {
+    result = detectCollisions(entity, newPos);
+  } else {
+    result.pos = newPos;
+  }
+
+  if (!ponderable.frozen)
+  {
+    auto& transformable = game_.getEntityManager().
+      getComponent<TransformableComponent>(entity);
+
+    vec2d delta = result.pos - transformable.pos;
+
+    // Move.
+    transformable.pos = result.pos;
+
+    // Stop if the entity hit a wall.
+    if (result.blockedHoriz)
+    {
+      ponderable.vel.x() = 0.0;
+    }
+
+    if (result.blockedVert)
+    {
+      ponderable.vel.y() = 0.0;
+    }
+
+    // Move ferry passengers by the appropriate amount.
+    auto passengers = ponderable.passengers;
+
+    for (id_type passenger : passengers)
+    {
+      auto& passTrans = game_.getEntityManager().
+        getComponent<TransformableComponent>(passenger);
+
+      moveBody(passenger, passTrans.pos + delta);
+    }
+
+    // Move to an adjacent map, if necessary
+    if (result.adjacentlyWarping)
+    {
+      vec2d warpPos = result.pos;
+
+      switch (result.adjWarpDir)
+      {
+        case Direction::left:
+        {
+          warpPos.x() = GAME_WIDTH + WALL_GAP - transformable.size.w();
+
+          break;
+        }
+
+        case Direction::right:
+        {
+          warpPos.x() = -WALL_GAP;
+
+          break;
+        }
+
+        case Direction::up:
+        {
+          warpPos.y() = MAP_HEIGHT * TILE_HEIGHT - transformable.size.h();
+
+          break;
+        }
+
+        case Direction::down:
+        {
+          warpPos.y() = -WALL_GAP;
+
+          break;
+        }
+      }
+
+      game_.getSystemManager().getSystem<PlayingSystem>().
+        changeMap(
+          entity,
+          result.adjWarpMapId,
+          warpPos);
+    }
+  }
+
+  return result;
+}
+
+namespace CollisionParams {
+
+  template <typename HorizVert>
+  class Desc : public HorizVert {
+  public:
+
+    inline static bool AtLeastInAxisSweep(
+      double boundaryAxis,
+      double entityAxis)
+    {
+      return (boundaryAxis >= entityAxis);
+    }
+
+    inline static bool IsPastAxis(
+      double colliderAxis,
+      double entityAxis)
+    {
+      return (colliderAxis > entityAxis);
+    }
+
+    inline static double EntityAxis(const vec2d& pos, const vec2i& size)
+    {
+      return HorizVert::AxisLower(pos);
+    }
+
+    inline static double ObjectAxis(const vec2d& pos, const vec2i& size)
+    {
+      return HorizVert::AxisUpper(pos, size);
+    }
+
+    inline static bool Closer(double left, double right)
+    {
+      return right < left;
+    }
+  };
+
+  template <typename HorizVert>
+  class Asc : public HorizVert {
+  public:
+
+    inline static bool AtLeastInAxisSweep(
+      double boundaryAxis,
+      double entityAxis)
+    {
+      return (boundaryAxis <= entityAxis);
+    }
+
+    inline static bool IsPastAxis(
+      double colliderAxis,
+      double entityAxis)
+    {
+      return (colliderAxis < entityAxis);
+    }
+
+    inline static double EntityAxis(const vec2d& pos, const vec2i& size)
+    {
+      return HorizVert::AxisUpper(pos, size);
+    }
+
+    inline static double ObjectAxis(const vec2d& pos, const vec2i& size)
+    {
+      return HorizVert::AxisLower(pos);
+    }
+
+    inline static bool Closer(double left, double right)
+    {
+      return left < right;
+    }
+  };
+
+  template <size_t Axis, size_t NonAxis>
+  class HorizVert {
+  public:
+
+    inline static double AxisLower(const vec2d& pos)
+    {
+      return pos.coords[Axis];
+    }
+
+    inline static double AxisUpper(const vec2d& pos, const vec2i& size)
+    {
+      return pos.coords[Axis] + size.coords[Axis];
+    }
+
+    inline static double NonAxisLower(const vec2d& pos)
+    {
+      return pos.coords[NonAxis];
+    }
+
+    inline static double NonAxisUpper(const vec2d& pos, const vec2i& size)
+    {
+      return pos.coords[NonAxis] + size.coords[NonAxis];
+    }
+
+  };
+
+  using Horizontal = HorizVert<0, 1>;
+  using Vertical = HorizVert<1, 0>;
+
+  template <Direction dir, typename AscDesc>
+  class DetectCollisions : public AscDesc {
+  public:
+
+    static const Direction Dir = dir;
+
+    inline static double EntityAxis(const vec2d& pos, const vec2i& size)
+    {
+      return AscDesc::EntityAxis(pos, size);
+    }
+
+    inline static double ObjectAxis(const vec2d& pos, const vec2i& size)
+    {
+      return AscDesc::ObjectAxis(pos, size);
+    }
+
+    inline static double EntityAxis(const TransformableComponent& transformable)
+    {
+      return AscDesc::EntityAxis(transformable.pos, transformable.size);
+    }
+
+    inline static double ObjectAxis(const TransformableComponent& transformable)
+    {
+      return AscDesc::ObjectAxis(transformable.pos, transformable.size);
+    }
+  };
+
+  class Left : public DetectCollisions<Direction::left, Desc<Horizontal>> {
+  public:
+
+    inline static const MappableComponent::desc_boundaries_type& MapBoundaries(
+      const MappableComponent& mappable)
+    {
+      return mappable.leftBoundaries;
+    }
+  };
+
+  class Right : public DetectCollisions<Direction::right, Asc<Horizontal>> {
+  public:
+
+    inline static const MappableComponent::asc_boundaries_type& MapBoundaries(
+      const MappableComponent& mappable)
+    {
+      return mappable.rightBoundaries;
+    }
+  };
+
+  class Up : public DetectCollisions<Direction::up, Desc<Vertical>> {
+  public:
+
+    inline static const MappableComponent::desc_boundaries_type& MapBoundaries(
+      const MappableComponent& mappable)
+    {
+      return mappable.upBoundaries;
+    }
+  };
+
+  class Down : public DetectCollisions<Direction::down, Asc<Vertical>> {
+  public:
+
+    inline static const MappableComponent::asc_boundaries_type& MapBoundaries(
+      const MappableComponent& mappable)
+    {
+      return mappable.downBoundaries;
+    }
+  };
+};
+
+PonderingSystem::CollisionResult PonderingSystem::detectCollisions(
+  id_type entity,
+  vec2d newPos)
+{
+  auto& transformable = game_.getEntityManager().
+    getComponent<TransformableComponent>(entity);
+
+  CollisionResult result;
+  result.pos.x() = newPos.x();
+  result.pos.y() = transformable.pos.y();
+
+  // Find horizontal collisions.
+  if (result.pos.x() < transformable.pos.x())
+  {
+    detectCollisionsInDirection<CollisionParams::Left>(entity, result);
+  } else if (result.pos.x() > transformable.pos.x())
+  {
+    detectCollisionsInDirection<CollisionParams::Right>(entity, result);
+  }
+
+  // Find vertical collisions
+  if (!result.stopProcessing)
+  {
+    result.pos.y() = newPos.y();
+    result.touchedWall = false;
+
+    if (result.pos.y() < transformable.pos.y())
+    {
+      detectCollisionsInDirection<CollisionParams::Up>(entity, result);
+    } else if (result.pos.y() > transformable.pos.y())
+    {
+      detectCollisionsInDirection<CollisionParams::Down>(entity, result);
+    }
+  }
+
+  return result;
+}
+
+template <typename Param>
+void PonderingSystem::detectCollisionsInDirection(
+  id_type entity,
+  CollisionResult& result)
+{
+  // Get map data.
+  id_type mapEntity =
+    game_.getSystemManager().getSystem<RealizingSystem>().getActiveMap();
+
+  auto& mappable = game_.getEntityManager().
+    getComponent<MappableComponent>(mapEntity);
+
+  // Get old location.
+  auto& transform = game_.getEntityManager().
+    getComponent<TransformableComponent>(entity);
+
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  bool boundaryCollision = false;
+
+  auto boundaries = Param::MapBoundaries(mappable);
+  auto it = boundaries.lower_bound(Param::EntityAxis(transform));
+
+  // Find the axis distance of the closest environmental boundary.
+  for (;
+      (it != std::end(boundaries)) &&
+        Param::AtLeastInAxisSweep(
+          it->first,
+          Param::EntityAxis(result.pos, transform.size));
+      it++)
+  {
+    // Check that the boundary is in range for the other axis.
+    if ((Param::NonAxisUpper(result.pos, transform.size) > it->second.lower) &&
+        (Param::NonAxisLower(result.pos) < it->second.upper))
+    {
+      // We have a collision!
+      boundaryCollision = true;
+
+      break;
+    }
+  }
+
+  // Find the results of pretending to move the entity's passengers, if there
+  // are any.
+  vec2d delta = result.pos - transform.pos;
+  std::map<id_type, CollisionResult> passResults;
+
+  for (id_type passenger : ponderable.passengers)
+  {
+    auto& passPonder = game_.getEntityManager().
+      getComponent<PonderableComponent>(passenger);
+
+    if (passPonder.ferrySide == Param::Dir)
+    {
+      auto& passTrans = game_.getEntityManager().
+        getComponent<TransformableComponent>(passenger);
+
+      passResults[passenger] =
+        detectCollisions(passenger, passTrans.pos + delta);
+    }
+  }
+
+  // Find a list of potential colliders, sorted so that the closest is
+  // first.
+  std::vector<id_type> colliders;
+
+  auto entities = game_.getEntityManager().getEntitiesWithComponents<
+    PonderableComponent,
+    TransformableComponent>();
+
+  for (id_type collider : entities)
+  {
+    // Can't collide with self.
+    if (collider == entity)
+    {
+      continue;
+    }
+
+    auto& colliderPonder = game_.getEntityManager().
+      getComponent<PonderableComponent>(collider);
+
+    // Only check objects that are active and collidable.
+    if (!colliderPonder.active || !colliderPonder.collidable)
+    {
+      continue;
+    }
+
+    // If the collider is a passenger of the entity, pretend that it has already
+    // moved.
+    auto& colliderTrans = game_.getEntityManager().
+      getComponent<TransformableComponent>(collider);
+
+    vec2d colliderPos = colliderTrans.pos;
+    vec2i colliderSize = colliderTrans.size;
+
+    if (passResults.count(collider))
+    {
+      colliderPos = passResults[collider].pos;
+    }
+
+    // Check if the entity would move into the potential collider,
+    if (Param::IsPastAxis(
+          Param::ObjectAxis(colliderPos, colliderSize),
+          Param::EntityAxis(result.pos, transform.size)) &&
+        // that it wasn't already colliding,
+        !Param::IsPastAxis(
+          Param::ObjectAxis(colliderPos, colliderSize),
+          Param::EntityAxis(transform)) &&
+        // that the position on the non-axis is in range,
+        (Param::NonAxisUpper(colliderPos, colliderSize) >
+          Param::NonAxisLower(result.pos)) &&
+        (Param::NonAxisLower(colliderPos) <
+          Param::NonAxisUpper(result.pos, transform.size)) &&
+        // and that the collider is not farther away than the environmental
+        // boundary.
+        (!boundaryCollision ||
+          Param::AtLeastInAxisSweep(
+            Param::ObjectAxis(colliderPos, colliderSize),
+            it->first)))
+    {
+      colliders.push_back(collider);
+    }
+  }
+
+  // Sort the potential colliders such that the closest to the axis of movement
+  // is first. When sorting, treat passengers of the entity as having already
+  // moved.
+  std::sort(
+    std::begin(colliders),
+    std::end(colliders),
+    [&] (id_type left, id_type right) {
+      auto& leftTrans = game_.getEntityManager().
+        getComponent<TransformableComponent>(left);
+
+      vec2d leftPos = leftTrans.pos;
+
+      if (passResults.count(left))
+      {
+        leftPos = passResults[left].pos;
+      }
+
+      auto& rightTrans = game_.getEntityManager().
+        getComponent<TransformableComponent>(right);
+
+      vec2d rightPos = rightTrans.pos;
+
+      if (passResults.count(right))
+      {
+        rightPos = passResults[right].pos;
+      }
+
+      return Param::Closer(
+        Param::ObjectAxis(leftPos, leftTrans.size),
+        Param::ObjectAxis(rightPos, rightTrans.size));
+    });
+
+  for (id_type collider : colliders)
+  {
+    auto& colliderTrans = game_.getEntityManager().
+      getComponent<TransformableComponent>(collider);
+
+    // If the collider is a passenger of the entity, pretend that it has already
+    // moved.
+    vec2d colliderPos = colliderTrans.pos;
+    vec2i colliderSize = colliderTrans.size;
+
+    if (passResults.count(collider))
+    {
+      colliderPos = passResults[collider].pos;
+    }
+
+    // Check if the entity would still move into the potential collider.
+    if (!Param::IsPastAxis(
+          Param::ObjectAxis(colliderPos, colliderSize),
+          Param::EntityAxis(result.pos, transform.size)))
+    {
+      break;
+    }
+
+    // TODO: Check if the entity is moving into one of its passengers.
+    auto& colliderPonder = game_.getEntityManager().
+      getComponent<PonderableComponent>(collider);
+
+    processCollision(
+      entity,
+      collider,
+      Param::Dir,
+      colliderPonder.colliderType,
+      Param::ObjectAxis(colliderPos, colliderSize),
+      Param::NonAxisLower(colliderPos),
+      Param::NonAxisUpper(colliderPos, colliderSize),
+      result);
+
+    if (result.stopProcessing)
+    {
+      break;
+    }
+  }
+
+  // If movement hasn't been stopped by an intermediary object, and
+  // collision checking hasn't been stopped, process the environmental
+  // boundaries closest to the entity.
+  if (!result.stopProcessing && !result.touchedWall && boundaryCollision)
+  {
+    double boundaryAxis = it->first;
+
+    for (;
+        (it != std::end(boundaries)) &&
+          (it->first == boundaryAxis);
+        it++)
+    {
+      if ((Param::NonAxisLower(result.pos) < it->second.upper) &&
+          (Param::NonAxisUpper(result.pos, transform.size) > it->second.lower))
+      {
+        processCollision(
+          entity,
+          mapEntity,
+          Param::Dir,
+          it->second.type,
+          it->first,
+          it->second.lower,
+          it->second.upper,
+          result);
+
+        if (result.stopProcessing)
+        {
+          break;
+        }
+      }
+    }
+  }
+}
+
+void PonderingSystem::processCollision(
+  id_type entity,
+  id_type collider,
+  Direction dir,
+  PonderableComponent::Collision type,
+  double axis,
+  double lower,
+  double upper,
+  CollisionResult& result)
+{
+  auto& transformable = game_.getEntityManager().
+    getComponent<TransformableComponent>(entity);
+
+  switch (type)
+  {
+    case PonderableComponent::Collision::wall:
+    {
+      result.touchedWall = true;
+
+      break;
+    }
+
+    case PonderableComponent::Collision::platform:
+    {
+      if (game_.getEntityManager().
+        hasComponent<OrientableComponent>(entity))
+      {
+        auto& orientable = game_.getEntityManager().
+          getComponent<OrientableComponent>(entity);
+
+        if (orientable.getDropState() !=
+          OrientableComponent::DropState::none)
+        {
+          orientable.setDropState(OrientableComponent::DropState::active);
+        } else {
+          result.touchedWall = true;
+        }
+      } else {
+        result.touchedWall = true;
+      }
+
+      break;
+    }
+
+    case PonderableComponent::Collision::adjacency:
+    {
+      auto& mappable = game_.getEntityManager().
+        getComponent<MappableComponent>(collider);
+
+      auto& adj = [&] () -> const MappableComponent::Adjacent& {
+          switch (dir)
+          {
+            case Direction::left: return mappable.leftAdjacent;
+            case Direction::right: return mappable.rightAdjacent;
+            case Direction::up: return mappable.upAdjacent;
+            case Direction::down: return mappable.downAdjacent;
+          }
+        }();
+
+      switch (adj.type)
+      {
+        case MappableComponent::Adjacent::Type::wall:
+        {
+          result.touchedWall = true;
+
+          break;
+        }
+
+        case MappableComponent::Adjacent::Type::wrap:
+        {
+          switch (dir)
+          {
+            case Direction::left:
+            {
+              result.pos.x() = GAME_WIDTH + WALL_GAP - transformable.size.w();
+
+              break;
+            }
+
+            case Direction::right:
+            {
+              result.pos.x() = -WALL_GAP;
+
+              break;
+            }
+
+            case Direction::up:
+            {
+              result.pos.y() =
+                MAP_HEIGHT * TILE_HEIGHT + WALL_GAP - transformable.pos.h();
+
+              break;
+            }
+
+            case Direction::down:
+            {
+              result.pos.y() = -WALL_GAP;
+
+              break;
+            }
+          }
+        }
+
+        case MappableComponent::Adjacent::Type::warp:
+        {
+          if (game_.getEntityManager().
+            hasComponent<PlayableComponent>(entity))
+          {
+            result.adjacentlyWarping = true;
+            result.adjWarpDir = dir;
+            result.adjWarpMapId = adj.mapId;
+          }
+
+          break;
+        }
+
+        case MappableComponent::Adjacent::Type::reverse:
+        {
+          // TODO: not yet implemented.
+
+          break;
+        }
+      }
+
+      break;
+    }
+
+    case PonderableComponent::Collision::danger:
+    {
+      if (game_.getEntityManager().
+        hasComponent<PlayableComponent>(entity))
+      {
+        game_.getSystemManager().getSystem<PlayingSystem>().die(entity);
+
+        result.adjacentlyWarping = false;
+      }
+
+      result.stopProcessing = true;
+
+      break;
+    }
+
+    case PonderableComponent::Collision::event:
+    {
+      if (game_.getEntityManager().
+        hasComponent<PlayableComponent>(entity))
+      {
+        game_.getSystemManager().getSystem<ScriptingSystem>().
+          onTouch(collider, entity);
+      }
+
+      break;
+    }
+
+    default:
+    {
+      // Not yet implemented.
+
+      break;
+    }
+  }
+
+  if (!result.stopProcessing && result.touchedWall)
+  {
+    switch (dir)
+    {
+      case Direction::left:
+      {
+        result.pos.x() = axis;
+        result.blockedHoriz = true;
+
+        break;
+      }
+
+      case Direction::right:
+      {
+        result.pos.x() = axis - transformable.size.w();
+        result.blockedHoriz = true;
+
+        break;
+      }
+
+      case Direction::up:
+      {
+        result.pos.y() = axis;
+        result.blockedVert = true;
+
+        break;
+      }
+
+      case Direction::down:
+      {
+        result.pos.y() = axis - transformable.size.h();
+        result.blockedVert = true;
+        result.groundEntity = collider;
+        result.grounded = true;
+
+        break;
+      }
+    }
+  }
+}
@@ -0,0 +1,81 @@
+#ifndef PONDERING_H_F2530E0E
+#define PONDERING_H_F2530E0E
+
+#include "system.h"
+#include "components/ponderable.h"
+#include "direction.h"
+#include "vector.h"
+
+class PonderingSystem : public System {
+public:
+
+  PonderingSystem(Game& game) : System(game)
+  {
+  }
+
+  void tick(double dt);
+
+  void initializeBody(id_type entity, PonderableComponent::Type type);
+
+  /**
+   * Initializes a ponderable map object from its prototype data.
+   *
+   * @requires entity is ponderable
+   * @requires entity is a map object
+   */
+  void initPrototype(id_type prototype);
+
+  /**
+   * Unferries an entity if it is a passenger of another entity. Use before
+   * moving a ponderable entity outside the PonderingSystem.
+   *
+   * @requires entity is ponderable
+   */
+  void unferry(id_type entity);
+
+private:
+
+  struct CollisionResult
+  {
+    vec2d pos;
+    bool stopProcessing = false;
+    bool touchedWall = false;
+    bool blockedHoriz = false;
+    bool blockedVert = false;
+    bool adjacentlyWarping = false;
+    Direction adjWarpDir;
+    size_t adjWarpMapId;
+    bool grounded = false;
+    id_type groundEntity;
+  };
+
+  void tickBody(
+    id_type entity,
+    double dt);
+
+  CollisionResult moveBody(
+    id_type entity,
+    vec2d newPos);
+
+  CollisionResult detectCollisions(
+    id_type entity,
+    vec2d newPos);
+
+  template <typename Param>
+  void detectCollisionsInDirection(
+    id_type entity,
+    CollisionResult& result);
+
+  void processCollision(
+    id_type entity,
+    id_type collider,
+    Direction dir,
+    PonderableComponent::Collision type,
+    double axis,
+    double lower,
+    double upper,
+    CollisionResult& result);
+
+};
+
+#endif /* end of include guard: PONDERING_H_F2530E0E */
@@ -0,0 +1,438 @@
+#include "realizing.h"
+#include <stdexcept>
+#include <libxml/parser.h>
+#include <cstring>
+#include <map>
+#include "game.h"
+#include "consts.h"
+#include "animation.h"
+#include "components/mappable.h"
+#include "components/animatable.h"
+#include "components/playable.h"
+#include "components/ponderable.h"
+#include "components/transformable.h"
+#include "components/prototypable.h"
+#include "components/automatable.h"
+#include "systems/mapping.h"
+#include "systems/animating.h"
+#include "systems/pondering.h"
+#include "systems/scripting.h"
+
+inline xmlChar* getProp(xmlNodePtr node, const char* attr)
+{
+  xmlChar* key = xmlGetProp(node, reinterpret_cast<const xmlChar*>(attr));
+  if (key == nullptr)
+  {
+    throw std::invalid_argument("Error parsing world file");
+  }
+
+  return key;
+}
+
+// TODO: neither the XML doc nor any of the emplaced entities are properly
+// destroyed if this constructor throws an exception.
+RealizingSystem::RealizingSystem(
+  Game& game,
+  std::string worldFile,
+  std::string prototypeFile) :
+    System(game),
+    worldFile_(std::move(worldFile)),
+    prototypeFile_(std::move(prototypeFile))
+{
+  auto& mapping = game_.getSystemManager().getSystem<MappingSystem>();
+
+  xmlChar* key = nullptr;
+
+  // Create a mapping between prototype names and the XML trees defining them.
+  xmlDocPtr protoXml = xmlParseFile(prototypeFile_.c_str());
+  if (protoXml == nullptr)
+  {
+    throw std::invalid_argument("Cannot find prototypes file");
+  }
+
+  xmlNodePtr protoTop = xmlDocGetRootElement(protoXml);
+  if (protoTop == nullptr)
+  {
+    throw std::invalid_argument("Error parsing prototypes file");
+  }
+
+  if (xmlStrcmp(protoTop->name, reinterpret_cast<const xmlChar*>("entities")))
+  {
+    throw std::invalid_argument("Error parsing prototypes file");
+  }
+
+  std::map<std::string, xmlNodePtr> prototypes;
+
+  for (xmlNodePtr node = protoTop->xmlChildrenNode;
+       node != nullptr;
+       node = node->next)
+  {
+    if (!xmlStrcmp(node->name, reinterpret_cast<const xmlChar*>("entity")))
+    {
+      key = getProp(node, "id");
+      std::string prototypeId = reinterpret_cast<char*>(key);
+      xmlFree(key);
+
+      prototypes[prototypeId] = node;
+    }
+  }
+
+  // Create entities from the world definition.
+  xmlDocPtr doc = xmlParseFile(worldFile_.c_str());
+  if (doc == nullptr)
+  {
+    throw std::invalid_argument("Cannot find world file");
+  }
+
+  xmlNodePtr top = xmlDocGetRootElement(doc);
+  if (top == nullptr)
+  {
+    throw std::invalid_argument("Error parsing world file");
+  }
+
+  if (xmlStrcmp(top->name, reinterpret_cast<const xmlChar*>("world")))
+  {
+    throw std::invalid_argument("Error parsing world file");
+  }
+
+  key = getProp(top, "startx");
+  startingPos_.x() = atoi(reinterpret_cast<char*>(key));
+  xmlFree(key);
+
+  key = getProp(top, "starty");
+  startingPos_.y() = atoi(reinterpret_cast<char*>(key));
+  xmlFree(key);
+
+  key = getProp(top, "startmap");
+  startingMapId_ = atoi(reinterpret_cast<char*>(key));
+  xmlFree(key);
+
+  for (xmlNodePtr node = top->xmlChildrenNode;
+    node != nullptr;
+    node = node->next)
+  {
+    if (!xmlStrcmp(node->name, reinterpret_cast<const xmlChar*>("map")))
+    {
+      id_type map = game_.getEntityManager().emplaceEntity();
+
+      auto& mappable = game_.getEntityManager().
+        emplaceComponent<MappableComponent>(map,
+          Texture("res/tiles.png"),
+          Texture("res/font.bmp"));
+
+      key = getProp(node, "id");
+      mappable.mapId = atoi(reinterpret_cast<char*>(key));
+      xmlFree(key);
+
+      key = getProp(node, "title");
+      mappable.title = reinterpret_cast<char*>(key);
+      xmlFree(key);
+
+      for (xmlNodePtr mapNode = node->xmlChildrenNode;
+        mapNode != nullptr;
+        mapNode = mapNode->next)
+      {
+        if (!xmlStrcmp(
+          mapNode->name,
+          reinterpret_cast<const xmlChar*>("environment")))
+        {
+          key = xmlNodeGetContent(mapNode);
+          if (key == nullptr)
+          {
+            throw std::invalid_argument("Error parsing world file");
+          }
+
+          mappable.tiles.clear();
+          mappable.tiles.push_back(atoi(strtok(
+            reinterpret_cast<char*>(key),
+            ",\n")));
+
+          for (size_t i = 1; i < (MAP_WIDTH * MAP_HEIGHT); i++)
+          {
+            mappable.tiles.push_back(atoi(strtok(nullptr, ",\n")));
+          }
+
+          xmlFree(key);
+        } else if (!xmlStrcmp(
+          mapNode->name,
+          reinterpret_cast<const xmlChar*>("entity")))
+        {
+          id_type mapObject = game_.getEntityManager().emplaceEntity();
+
+          key = getProp(mapNode, "type");
+          std::string prototypeId = reinterpret_cast<char*>(key);
+          xmlFree(key);
+
+          xmlNodePtr prototypeNode = prototypes[prototypeId];
+
+          // Set the coordinates from the object definition.
+          auto& transformable = game_.getEntityManager().
+            emplaceComponent<TransformableComponent>(mapObject);
+
+          key = getProp(mapNode, "x");
+          transformable.origPos.x() = atoi(reinterpret_cast<char*>(key));
+          xmlFree(key);
+
+          key = getProp(mapNode, "y");
+          transformable.origPos.y() = atoi(reinterpret_cast<char*>(key));
+          xmlFree(key);
+
+          // Set the sprite and size using the prototype definition.
+          key = getProp(prototypeNode, "sprite");
+          std::string spritePath = reinterpret_cast<char*>(key);
+          xmlFree(key);
+
+          key = getProp(prototypeNode, "width");
+          transformable.origSize.w() = atoi(reinterpret_cast<char*>(key));
+          xmlFree(key);
+
+          key = getProp(prototypeNode, "height");
+          transformable.origSize.h() = atoi(reinterpret_cast<char*>(key));
+          xmlFree(key);
+
+          AnimationSet objectAnim(
+            spritePath.c_str(),
+            transformable.origSize.w(),
+            transformable.origSize.h(),
+            1);
+
+          objectAnim.emplaceAnimation("static", 0, 1, 1);
+
+          auto& animatable = game_.getEntityManager().
+            emplaceComponent<AnimatableComponent>(
+              mapObject,
+              std::move(objectAnim));
+
+          animatable.origAnimation = "static";
+
+          // Create a physics body.
+          game_.getSystemManager().getSystem<PonderingSystem>().
+            initializeBody(mapObject, PonderableComponent::Type::vacuumed);
+
+
+
+
+
+          auto& prototypable = game_.getEntityManager().
+            emplaceComponent<PrototypableComponent>(mapObject);
+
+          prototypable.prototypeId = prototypeId;
+
+          key = getProp(mapNode, "index");
+          prototypable.mapObjectIndex = atoi(reinterpret_cast<char*>(key));
+          xmlFree(key);
+
+          if (prototypeId == "movplat")
+          {
+            auto& automatable = game_.getEntityManager().
+              emplaceComponent<AutomatableComponent>(mapObject);
+
+            automatable.table = prototypeId;
+          } else if (prototypeId == "checkpoint")
+          {
+            auto& ponderable = game_.getEntityManager().
+              getComponent<PonderableComponent>(mapObject);
+
+            ponderable.colliderType = PonderableComponent::Collision::event;
+          }
+
+          mappable.objects.push_back(mapObject);
+        } else if (!xmlStrcmp(
+          mapNode->name,
+          reinterpret_cast<const xmlChar*>("adjacent")))
+        {
+          key = getProp(mapNode, "type");
+          std::string adjTypeStr(reinterpret_cast<char*>(key));
+          xmlFree(key);
+
+          MappableComponent::Adjacent::Type adjType;
+          if (adjTypeStr == "wall")
+          {
+            adjType = MappableComponent::Adjacent::Type::wall;
+          } else if (adjTypeStr == "wrap")
+          {
+            adjType = MappableComponent::Adjacent::Type::wrap;
+          } else if (adjTypeStr == "warp")
+          {
+            adjType = MappableComponent::Adjacent::Type::warp;
+          } else if (adjTypeStr == "reverseWarp")
+          {
+            adjType = MappableComponent::Adjacent::Type::reverse;
+          } else {
+            throw std::logic_error("Invalid adjacency type");
+          }
+
+          key = getProp(mapNode, "map");
+          size_t adjMapId = atoi(reinterpret_cast<char*>(key));
+          xmlFree(key);
+
+          key = getProp(mapNode, "dir");
+          std::string adjDir(reinterpret_cast<char*>(key));
+          xmlFree(key);
+
+          if (adjDir == "left")
+          {
+            mappable.leftAdjacent = {adjType, adjMapId};
+          } else if (adjDir == "right")
+          {
+            mappable.rightAdjacent = {adjType, adjMapId};
+          } else if (adjDir == "up")
+          {
+            mappable.upAdjacent = {adjType, adjMapId};
+          } else if (adjDir == "down")
+          {
+            mappable.downAdjacent = {adjType, adjMapId};
+          } else {
+            throw std::logic_error("Invalid adjacency direction");
+          }
+        }
+      }
+
+      mapping.generateBoundaries(map);
+
+      entityByMapId_[mappable.mapId] = map;
+    }
+  }
+
+  xmlFreeDoc(doc);
+  xmlFreeDoc(protoXml);
+
+  activateMap(entityByMapId_[startingMapId_]);
+}
+
+void RealizingSystem::loadMap(id_type mapEntity)
+{
+  deactivateMap();
+  activateMap(mapEntity);
+}
+
+void RealizingSystem::deactivateMap()
+{
+  id_type oldMap = activeMap_;
+
+  auto& oldMappable = game_.getEntityManager().
+    getComponent<MappableComponent>(oldMap);
+
+  // Deactivate any map objects from the old map.
+  for (id_type prototype : oldMappable.objects)
+  {
+    leaveActiveMap(prototype);
+  }
+
+  // Deactivate players that were on the old map.
+  std::set<id_type> players =
+    game_.getEntityManager().getEntitiesWithComponents<
+      PlayableComponent>();
+
+  for (id_type player : players)
+  {
+    auto& playable = game_.getEntityManager().
+      getComponent<PlayableComponent>(player);
+
+    if (playable.mapId == oldMap)
+    {
+      leaveActiveMap(player);
+    }
+  }
+}
+
+void RealizingSystem::activateMap(id_type mapEntity)
+{
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+  auto& pondering = game_.getSystemManager().getSystem<PonderingSystem>();
+
+  std::set<id_type> players =
+    game_.getEntityManager().getEntitiesWithComponents<
+      PlayableComponent>();
+
+  activeMap_ = mapEntity;
+
+  auto& mappable = game_.getEntityManager().
+    getComponent<MappableComponent>(mapEntity);
+
+  // Initialize the new map's objects.
+  for (id_type prototype : mappable.objects)
+  {
+    if (game_.getEntityManager().
+      hasComponent<TransformableComponent>(prototype))
+    {
+      auto& transformable = game_.getEntityManager().
+        getComponent<TransformableComponent>(prototype);
+
+      transformable.pos = transformable.origPos;
+      transformable.size = transformable.origSize;
+    }
+
+    if (game_.getEntityManager().hasComponent<AnimatableComponent>(prototype))
+    {
+      animating.initPrototype(prototype);
+    }
+
+    if (game_.getEntityManager().hasComponent<PonderableComponent>(prototype))
+    {
+      pondering.initPrototype(prototype);
+    }
+
+    enterActiveMap(prototype);
+  }
+
+  // Activate any players on the map.
+  for (id_type player : players)
+  {
+    auto& playable = game_.getEntityManager().
+      getComponent<PlayableComponent>(player);
+
+    if (playable.mapId == mapEntity)
+    {
+      enterActiveMap(player);
+    }
+  }
+}
+
+void RealizingSystem::enterActiveMap(id_type entity)
+{
+  if (game_.getEntityManager().hasComponent<AnimatableComponent>(entity))
+  {
+    auto& animatable = game_.getEntityManager().
+      getComponent<AnimatableComponent>(entity);
+
+    animatable.active = true;
+  }
+
+  if (game_.getEntityManager().hasComponent<PonderableComponent>(entity))
+  {
+    auto& ponderable = game_.getEntityManager().
+      getComponent<PonderableComponent>(entity);
+
+    ponderable.active = true;
+  }
+
+  if (game_.getEntityManager().hasComponent<AutomatableComponent>(entity))
+  {
+    game_.getSystemManager().getSystem<ScriptingSystem>().startBehavior(entity);
+  }
+}
+
+void RealizingSystem::leaveActiveMap(id_type entity)
+{
+  if (game_.getEntityManager().hasComponent<AnimatableComponent>(entity))
+  {
+    auto& animatable = game_.getEntityManager().
+      getComponent<AnimatableComponent>(entity);
+
+    animatable.active = false;
+  }
+
+  if (game_.getEntityManager().hasComponent<PonderableComponent>(entity))
+  {
+    auto& ponderable = game_.getEntityManager().
+      getComponent<PonderableComponent>(entity);
+
+    ponderable.active = false;
+  }
+
+  if (game_.getEntityManager().hasComponent<AutomatableComponent>(entity))
+  {
+    game_.getSystemManager().getSystem<ScriptingSystem>().stopBehavior(entity);
+  }
+}
@@ -0,0 +1,86 @@
+#ifndef REALIZING_H_6853748C
+#define REALIZING_H_6853748C
+
+#include <string>
+#include <map>
+#include "system.h"
+#include "vector.h"
+
+class RealizingSystem : public System {
+public:
+
+  /**
+   * Constructs the realizing system.
+   *
+   * Note that this must be constructed after the following system:
+   * - Mapping
+   * - Animating
+   * - Pondering
+   * - Scripting
+   */
+  RealizingSystem(
+    Game& game,
+    std::string worldFile,
+    std::string prototypeFile);
+
+  id_type getActiveMap() const
+  {
+    return activeMap_;
+  }
+
+  int getStartingMapId() const
+  {
+    return startingMapId_;
+  }
+
+  vec2i getStartingPos() const
+  {
+    return startingPos_;
+  }
+
+  id_type getEntityByMapId(size_t mapId) const
+  {
+    return entityByMapId_.at(mapId);
+  }
+
+  id_type getActivePlayer() const
+  {
+    return activePlayer_;
+  }
+
+  void setActivePlayer(id_type entity)
+  {
+    activePlayer_ = entity;
+  }
+
+  /**
+   * Loads the given map.
+   */
+  void loadMap(id_type mapEntity);
+
+  /**
+   * Treats the given entity as part of the active map.
+   */
+  void enterActiveMap(id_type entity);
+
+  /**
+   * Stops treating the given entity as part of the active map.
+   */
+  void leaveActiveMap(id_type entity);
+
+private:
+
+  void deactivateMap();
+
+  void activateMap(id_type mapEntity);
+
+  std::string worldFile_;
+  std::string prototypeFile_;
+  int startingMapId_;
+  vec2i startingPos_;
+  std::map<size_t, id_type> entityByMapId_;
+  id_type activeMap_;
+  id_type activePlayer_;
+};
+
+#endif /* end of include guard: REALIZING_H_6853748C */
@@ -0,0 +1,54 @@
+#include "scheduling.h"
+#include "game.h"
+#include "components/schedulable.h"
+#include "util.h"
+
+void SchedulingSystem::tick(double dt)
+{
+  auto entities = game_.getEntityManager().getEntitiesWithComponents<
+    SchedulableComponent>();
+
+  for (id_type entity : entities)
+  {
+    auto& schedulable = game_.getEntityManager().
+      getComponent<SchedulableComponent>(entity);
+
+    for (auto& action : schedulable.actions)
+    {
+      std::get<0>(action) -= dt;
+
+      if (std::get<0>(action) < 0)
+      {
+        std::get<1>(action)(entity);
+      }
+    }
+
+    erase_if(schedulable.actions,
+      [] (const SchedulableComponent::Action& action) {
+        return (std::get<0>(action) < 0);
+      });
+
+    if (schedulable.actions.empty())
+    {
+      game_.getEntityManager().removeComponent<SchedulableComponent>(entity);
+    }
+  }
+}
+
+void SchedulingSystem::schedule(
+  id_type entity,
+  double length,
+  std::function<void(id_type)> action)
+{
+  if (!game_.getEntityManager().hasComponent<SchedulableComponent>(entity))
+  {
+    game_.getEntityManager().emplaceComponent<SchedulableComponent>(entity);
+  }
+
+  auto& schedulable = game_.getEntityManager().
+    getComponent<SchedulableComponent>(entity);
+
+  schedulable.actions.emplace_back(
+    length,
+    std::move(action));
+}
@@ -0,0 +1,22 @@
+#ifndef SCHEDULING_H_7B02E3E3
+#define SCHEDULING_H_7B02E3E3
+
+#include "system.h"
+
+class SchedulingSystem : public System {
+public:
+
+  SchedulingSystem(Game& game) : System(game)
+  {
+  }
+
+  void tick(double dt);
+
+  void schedule(
+    id_type entity,
+    double length,
+    std::function<void(id_type)> action);
+
+};
+
+#endif /* end of include guard: SCHEDULING_H_7B02E3E3 */
@@ -0,0 +1,257 @@
+#include "scripting.h"
+#include "game.h"
+#include "components/runnable.h"
+#include "components/ponderable.h"
+#include "components/transformable.h"
+#include "components/playable.h"
+#include "components/mappable.h"
+#include "components/prototypable.h"
+#include "components/automatable.h"
+#include "systems/realizing.h"
+#include "vector.h"
+#include "muxer.h"
+
+struct script_entity {
+  using id_type = EntityManager::id_type;
+
+  id_type id;
+
+  script_entity(id_type id) : id(id)
+  {
+  }
+};
+
+ScriptingSystem::ScriptingSystem(Game& game) : System(game)
+{
+  id_type entity = game_.getEntityManager().emplaceEntity();
+
+  engine_.open_libraries(sol::lib::base, sol::lib::coroutine);
+
+  engine_.new_usertype<vec2d>(
+    "vec2d",
+    sol::constructors<vec2d(), vec2d(double, double)>(),
+    "x", sol::property(
+      [] (vec2d& v) -> double { return v.x(); },
+      [] (vec2d& v, double x) { v.x() = x; }),
+    "y", sol::property(
+      [] (vec2d& v) -> double { return v.y(); },
+      [] (vec2d& v, double y) { v.y() = y; }));
+
+  engine_.new_usertype<vec2i>(
+    "vec2i",
+    sol::constructors<vec2i(), vec2i(int, int)>(),
+    "x", [] (vec2i& v) -> int& { return v.x(); },
+    "y", [] (vec2i& v) -> int& { return v.y(); });
+
+  engine_.new_usertype<script_entity>(
+    "entity",
+    sol::constructors<script_entity(id_type)>(),
+    "id", &script_entity::id,
+    "transformable",
+      [&] (script_entity& entity) -> TransformableComponent& {
+        return game_.getEntityManager().
+          getComponent<TransformableComponent>(entity.id);
+      },
+    "ponderable",
+      [&] (script_entity& entity) -> PonderableComponent& {
+        return game_.getEntityManager().
+          getComponent<PonderableComponent>(entity.id);
+      },
+    "mappable",
+      [&] (script_entity& entity) -> MappableComponent& {
+        return game_.getEntityManager().
+          getComponent<MappableComponent>(entity.id);
+      },
+    "playable",
+      [&] (script_entity& entity) -> PlayableComponent& {
+        return game_.getEntityManager().
+          getComponent<PlayableComponent>(entity.id);
+      },
+    "prototypable",
+      [&] (script_entity& entity) -> PrototypableComponent& {
+        return game_.getEntityManager().
+          getComponent<PrototypableComponent>(entity.id);
+      });
+
+  engine_.new_usertype<TransformableComponent>(
+    "transformable",
+    "pos", &TransformableComponent::pos);
+
+  engine_.new_usertype<PonderableComponent>(
+    "ponderable",
+    "vel", &PonderableComponent::vel,
+    "accel", &PonderableComponent::accel);
+
+  engine_.new_usertype<MappableComponent>(
+    "mappable",
+    "mapId", &MappableComponent::mapId);
+
+  engine_.new_usertype<PlayableComponent>(
+    "playable",
+    "checkpointPos", &PlayableComponent::checkpointPos,
+    "checkpointMapId", &PlayableComponent::checkpointMapId,
+    "checkpointMapObject", &PlayableComponent::checkpointMapObject,
+    "checkpointMapObjectIndex", &PlayableComponent::checkpointMapObjectIndex);
+
+  engine_.new_usertype<PrototypableComponent>(
+    "prototypable",
+    "mapObjectIndex", &PrototypableComponent::mapObjectIndex,
+    "prototypeId", &PrototypableComponent::prototypeId);
+
+  engine_.new_usertype<RealizingSystem>(
+    "realizing",
+    "activeMap", sol::property(&RealizingSystem::getActiveMap));
+
+  engine_.set_function(
+    "realizing",
+    [&] () -> RealizingSystem& {
+      return game_.getSystemManager().getSystem<RealizingSystem>();
+    });
+
+  engine_.set_function("playSound", playSound);
+
+  engine_.script_file("scripts/common.lua");
+  engine_.script_file("scripts/movplat.lua");
+  engine_.script_file("scripts/checkpoint.lua");
+}
+
+void ScriptingSystem::tick(double dt)
+{
+  auto entities = game_.getEntityManager().getEntitiesWithComponents<
+    RunnableComponent>();
+
+  for (id_type entity : entities)
+  {
+    auto& runnable = game_.getEntityManager().
+      getComponent<RunnableComponent>(entity);
+
+    if (*runnable.callable)
+    {
+      auto result = (*runnable.callable)(dt);
+      if (!result.valid())
+      {
+        sol::error e = result;
+        throw std::runtime_error(e.what());
+      }
+    }
+
+    if (!*runnable.callable)
+    {
+      killScript(entity);
+    }
+  }
+}
+
+void ScriptingSystem::killScript(id_type entity)
+{
+  auto& runnable = game_.getEntityManager().
+    getComponent<RunnableComponent>(entity);
+
+  if (runnable.behavior)
+  {
+    auto& automatable = game_.getEntityManager().
+      getComponent<AutomatableComponent>(runnable.actor);
+
+    automatable.running = false;
+  }
+
+  game_.getEntityManager().deleteEntity(entity);
+}
+
+template <typename... Args>
+sol::optional<EntityManager::id_type> ScriptingSystem::runScript(
+  std::string table,
+  std::string event,
+  id_type entity,
+  Args&&... args)
+{
+  id_type script = game_.getEntityManager().emplaceEntity();
+
+  auto& runnable = game_.getEntityManager().
+    emplaceComponent<RunnableComponent>(script);
+
+  runnable.runner =
+    std::unique_ptr<sol::thread>(
+      new sol::thread(
+        sol::thread::create(
+          engine_.lua_state())));
+
+  runnable.callable =
+    std::unique_ptr<sol::coroutine>(
+      new sol::coroutine(
+        runnable.runner->state().
+          traverse_get<sol::function>(
+            table,
+            event)));
+
+  if (!*runnable.callable)
+  {
+    throw std::runtime_error("Error running script");
+  }
+
+  auto result = (*runnable.callable)(
+    script_entity(entity),
+    std::forward<Args>(args)...);
+
+  if (!result.valid())
+  {
+    sol::error e = result;
+    throw std::runtime_error(e.what());
+  }
+
+  if (*runnable.callable)
+  {
+    return { script };
+  } else {
+    killScript(script);
+
+    return {};
+  }
+}
+
+void ScriptingSystem::startBehavior(id_type entity)
+{
+  auto& automatable = game_.getEntityManager().
+    getComponent<AutomatableComponent>(entity);
+
+  sol::optional<id_type> script =
+    runScript(
+      automatable.table,
+      "Behavior",
+      entity);
+
+  if (script)
+  {
+    automatable.script = *script;
+    automatable.running = true;
+
+    auto& runnable = game_.getEntityManager().
+      getComponent<RunnableComponent>(automatable.script);
+
+    runnable.behavior = true;
+    runnable.actor = entity;
+  }
+}
+
+void ScriptingSystem::stopBehavior(id_type entity)
+{
+  auto& automatable = game_.getEntityManager().
+    getComponent<AutomatableComponent>(entity);
+
+  if (automatable.running)
+  {
+    killScript(automatable.script);
+  }
+}
+
+void ScriptingSystem::onTouch(id_type entity, id_type player)
+{
+  auto& prototypable = game_.getEntityManager().
+    getComponent<PrototypableComponent>(entity);
+
+  runScript(
+    prototypable.prototypeId,
+    "OnTouch",
+    entity,
+    script_entity(player));
+}
@@ -0,0 +1,34 @@
+#ifndef AUTOMATING_H_E6E5D76E
+#define AUTOMATING_H_E6E5D76E
+
+#include "system.h"
+#include <sol.hpp>
+
+class ScriptingSystem : public System {
+public:
+
+  ScriptingSystem(Game& game);
+
+  void tick(double dt);
+
+  void killScript(id_type entity);
+
+  void startBehavior(id_type entity);
+
+  void stopBehavior(id_type entity);
+
+  void onTouch(id_type entity, id_type player);
+
+private:
+
+  template <typename... Args>
+  sol::optional<id_type> runScript(
+    std::string table,
+    std::string event,
+    id_type entity,
+    Args&&... args);
+
+  sol::state engine_;
+};
+
+#endif /* end of include guard: AUTOMATING_H_E6E5D76E */
@@ -0,0 +1,30 @@
+#include "util.h"
+
+std::string slurp(std::ifstream& in)
+{
+  std::stringstream sstr;
+  sstr << in.rdbuf();
+  return sstr.str();
+}
+
+void flipImageData(
+  unsigned char* data,
+  int width,
+  int height,
+  int comps)
+{
+  unsigned char* dataCopy = new unsigned char[width * height * comps];
+  memcpy(dataCopy, data, width * height * comps);
+
+  int rowSize = width * comps;
+
+  for (int i = 0; i < height; i++)
+  {
+    memcpy(
+      data + (rowSize * i),
+      dataCopy + (rowSize * (height - i - 1)),
+      rowSize);
+  }
+
+  delete[] dataCopy;
+}
@@ -0,0 +1,41 @@
+#ifndef ALGORITHMS_H_1DDC517E
+#define ALGORITHMS_H_1DDC517E
+
+#include <fstream>
+#include <sstream>
+#include <cstring>
+
+template< typename ContainerT, typename PredicateT >
+void erase_if( ContainerT& items, const PredicateT& predicate ) {
+  for( auto it = items.begin(); it != items.end(); ) {
+    if( predicate(*it) ) it = items.erase(it);
+    else ++it;
+  }
+};
+
+struct chlit
+{
+  chlit(char c) : c_(c) { }
+  char c_;
+};
+
+inline std::istream& operator>>(std::istream& is, chlit x)
+{
+  char c;
+  if (is >> c && c != x.c_)
+  {
+    is.setstate(std::iostream::failbit);
+  }
+
+  return is;
+}
+
+std::string slurp(std::ifstream& in);
+
+void flipImageData(
+  unsigned char* data,
+  int width,
+  int height,
+  int comps);
+
+#endif /* end of include guard: ALGORITHMS_H_1DDC517E */
@@ -0,0 +1,113 @@
+#ifndef COORDINATES_H_A45D34FB
+#define COORDINATES_H_A45D34FB
+
+template <typename T>
+class vec2 {
+public:
+
+  T coords[2];
+
+  vec2() : coords{0, 0}
+  {
+  }
+
+  vec2(T x, T y) : coords{x, y}
+  {
+  }
+
+  inline T& x()
+  {
+    return coords[0];
+  }
+
+  inline const T& x() const
+  {
+    return coords[0];
+  }
+
+  inline T& w()
+  {
+    return coords[0];
+  }
+
+  inline const T& w() const
+  {
+    return coords[0];
+  }
+
+  inline T& y()
+  {
+    return coords[1];
+  }
+
+  inline const T& y() const
+  {
+    return coords[1];
+  }
+
+  inline T& h()
+  {
+    return coords[1];
+  }
+
+  inline const T& h() const
+  {
+    return coords[1];
+  }
+
+  template <typename R>
+  operator vec2<R>() const
+  {
+    return vec2<R>(x(), y());
+  }
+
+  vec2 operator+(const vec2& other) const
+  {
+    return vec2(x() + other.x(), y() + other.y());
+  }
+
+  vec2& operator+=(const vec2& other)
+  {
+    x() += other.x();
+    y() += other.y();
+
+    return *this;
+  }
+
+  vec2 operator-(const vec2& other) const
+  {
+    return vec2(x() - other.x(), y() - other.y());
+  }
+
+  vec2 operator-=(const vec2& other)
+  {
+    x() -= other.x();
+    y() -= other.y();
+
+    return *this;
+  }
+
+  vec2 operator-() const
+  {
+    return vec2(-x(), -y());
+  }
+
+  vec2 operator*(T s) const
+  {
+    return vec2(x() * s, y() * s);
+  }
+
+  vec2& operator*=(T s)
+  {
+    x() *= s;
+    y() *= s;
+
+    return *this;
+  }
+
+};
+
+using vec2d = vec2<double>;
+using vec2i = vec2<int>;
+
+#endif /* end of include guard: COORDINATES_H_A45D34FB */
@@ -1,150 +0,0 @@
-#include "world.h"
-#include <libxml/parser.h>
-#include "consts.h"
-
-World::World(const char* filename)
-{
-  xmlDocPtr doc = xmlParseFile(filename);
-  if (doc == nullptr)
-  {
-    exit(2);
-  }
-  
-  xmlNodePtr top = xmlDocGetRootElement(doc);
-  if (top == nullptr)
-  {
-    exit(2);
-  }
-  
-  if (xmlStrcmp(top->name, (const xmlChar*) "world"))
-  {
-    exit(2);
-  }
-  
-  xmlChar* startxKey = xmlGetProp(top, (xmlChar*) "startx");
-  if (startxKey == 0) exit(2);
-  startX = atoi((char*) startxKey);
-  xmlFree(startxKey);
-  
-  xmlChar* startyKey = xmlGetProp(top, (xmlChar*) "starty");
-  if (startyKey == 0) exit(2);
-  startY = atoi((char*) startyKey);
-  xmlFree(startyKey);
-  
-  xmlChar* startmapKey = xmlGetProp(top, (xmlChar*) "startmap");
-  if (startxKey == 0) exit(2);
-  startMap = atoi((char*) startmapKey);
-  xmlFree(startmapKey);
-  
-  for (xmlNodePtr node = top->xmlChildrenNode; node != NULL; node = node->next)
-  {
-    if (!xmlStrcmp(node->name, (const xmlChar*) "map"))
-    {
-      xmlChar* idKey = xmlGetProp(node, (xmlChar*) "id");
-      if (idKey == 0) exit(2);
-      int theId = atoi((char*) idKey);
-      xmlFree(idKey);
-      
-      maps.emplace(theId, theId);
-      Map& map = maps[theId];
-      
-      xmlChar* titleKey = xmlGetProp(node, (xmlChar*) "title");
-      if (titleKey == 0) exit(2);
-      map.setTitle((char*) titleKey);
-      xmlFree(titleKey);
-      
-      for (xmlNodePtr mapNode = node->xmlChildrenNode; mapNode != NULL; mapNode = mapNode->next)
-      {
-        if (!xmlStrcmp(mapNode->name, (const xmlChar*) "environment"))
-        {
-          xmlChar* key = xmlNodeGetContent(mapNode);
-          int* mapdata = (int*) malloc(MAP_WIDTH*MAP_HEIGHT*sizeof(int));
-          mapdata[0] = atoi(strtok((char*) key, ",\n"));
-          for (int i=1; i<(MAP_WIDTH*MAP_HEIGHT); i++)
-          {
-            mapdata[i] = atoi(strtok(NULL, ",\n"));
-          }
-          map.setMapdata(mapdata);
-          xmlFree(key);
-        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "entity"))
-        {
-          Map::EntityData data;
-          
-          xmlChar* typeKey = xmlGetProp(mapNode, (const xmlChar*) "type");
-          if (typeKey == 0) exit(2);
-          data.name = (char*) typeKey;
-          xmlFree(typeKey);
-          
-          xmlChar* xKey = xmlGetProp(mapNode, (const xmlChar*) "x");
-          if (xKey == 0) exit(2);
-          data.position.first = atoi((char*) xKey);
-          xmlFree(xKey);
-          
-          xmlChar* yKey = xmlGetProp(mapNode, (const xmlChar*) "y");
-          if (yKey == 0) exit(2);
-          data.position.second = atoi((char*) yKey);
-          xmlFree(yKey);
-          
-          for (xmlNodePtr entityNode = mapNode->xmlChildrenNode; entityNode != NULL; entityNode = entityNode->next)
-          {
-            if (!xmlStrcmp(entityNode->name, (xmlChar*) "item"))
-            {
-              xmlChar* itemIdKey = xmlGetProp(entityNode, (const xmlChar*) "id");
-              if (itemIdKey == 0) exit(2);
-              std::string itemId = (char*) itemIdKey;
-              xmlFree(itemIdKey);
-              
-              xmlChar* itemIdVal = xmlNodeGetContent(entityNode);
-              if (itemIdVal == 0) exit(2);
-              data.items[itemId] = atoi((char*) itemIdVal);
-              xmlFree(itemIdVal);
-            }
-          }
-          
-          map.addEntity(data);
-        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "adjacent"))
-        {
-          Map::MoveDir direction;
-          Map::MoveType moveType;
-          int mapId = 0;
-          
-          xmlChar* dirKey = xmlGetProp(mapNode, (const xmlChar*) "dir");
-          if (dirKey == 0) exit(2);
-          direction = Map::moveDirForShort((char*) dirKey);
-          xmlFree(dirKey);
-          
-          xmlChar* typeKey = xmlGetProp(mapNode, (const xmlChar*) "type");
-          if (typeKey == 0) exit(2);
-          moveType = Map::moveTypeForShort((char*) typeKey);
-          xmlFree(typeKey);
-          
-          xmlChar* mapIdKey = xmlGetProp(mapNode, (const xmlChar*) "map");
-          if (mapIdKey != 0)
-          {
-            mapId = atoi((char*) mapIdKey);
-          }
-          xmlFree(mapIdKey);
-          
-          map.setAdjacent(direction, moveType, mapId);
-        }
-      }
-    }
-  }
-  
-  xmlFreeDoc(doc);
-}
-
-const Map& World::getMap(int id) const
-{
-  return maps.at(id);
-}
-
-const Map& World::getStartingMap() const
-{
-  return maps.at(startMap);
-}
-
-std::pair<int, int> World::getStartingPosition() const
-{
-  return std::make_pair(startX, startY);
-}
@@ -1,21 +0,0 @@
-#ifndef WORLD_H
-#define WORLD_H
-
-#include <map>
-#include "map.h"
-
-class World {
-  public:
-    World(const char* filename);
-    const Map& getMap(int id) const;
-    const Map& getStartingMap() const;
-    std::pair<int, int> getStartingPosition() const;
-    
-  private:
-    std::map<int, Map> maps;
-    int startMap;
-    int startX;
-    int startY;
-};
-
-#endif /* end of include guard: WORLD_H */