Do a little cleanup on the screen size calcs.

engine/include/game/engine/game_dispatch.hpp

@@ -39,7 +39,7 @@ namespace engine {
     void update();
     void render();
 
-    std::shared_ptr<graphics::renderer> make_renderer(float forScale) const;
+    std::shared_ptr<graphics::renderer> make_renderer(math::vec2 const &) const;
     void register_scene(scene_t scn);
     void activate_scene(scene_id_t const & id);
     void set_current_timestamp();
@@ -48,8 +48,8 @@ namespace engine {
     env::clock::tick next_frame();
 
   private:
-    std::shared_ptr<graphics::renderer> renderer, batch_renderer;
     math::vec2 screen_size;
+    std::shared_ptr<graphics::renderer> renderer, batch_renderer;
     env::clock::duration minimum_frame_duration;
     std::shared_ptr<text_engine> text_engine_;
     std::unique_ptr<fps_counter> counter;

engine/include/game/engine/scene.hpp

@@ -43,7 +43,8 @@ namespace engine {
                                  std::vector<collidable *> const & to);
 
   protected:
-    std::shared_ptr<graphics::renderer> renderer;
+    graphics::renderer & renderer() { return *renderer_; }
+
     std::vector<entity> entities;
 
     // Map from entity::collides_with -> [entity*]
@@ -53,6 +54,7 @@ namespace engine {
 
   private:
     math::vec2 local_bounds_;
+    std::shared_ptr<graphics::renderer> renderer_;
     key_binding keys_;
     std::weak_ptr<game_dispatch> dispatch_;
   };

engine/src/game_dispatch.cpp

@@ -27,8 +27,9 @@ namespace engine {
   }
 
   game_dispatch::game_dispatch(std::shared_ptr<graphics::renderer> renderer)
-      : renderer(renderer), batch_renderer(make_renderer(1.f)),
-        screen_size(env::screen_size()), minimum_frame_duration(env::fps::v60),
+      : screen_size(env::screen_size()), renderer(renderer),
+        batch_renderer(make_renderer(screen_size)),
+        minimum_frame_duration(env::fps::v60),
         text_engine_(new text_engine("font", renderer->manager())),
         counter(new fps_counter(text_engine_)), scenes(),
         current_timestamp(env::clock::now()), curr_scene() {}
@@ -105,7 +106,9 @@ namespace engine {
   }
 
   std::shared_ptr<graphics::renderer>
-  game_dispatch::make_renderer(float scale) const {
+  game_dispatch::make_renderer(math::vec2 const & bounds) const {
+    math::vec2 const factor = screen_size / bounds;
+    float const scale = std::min(factor[0], factor[1]);
     return std::make_shared<graphics::batch_renderer>(
         renderer.get(), math::matrix::scalar(make_vector(scale, scale, 1.f)));
   }

engine/src/scene.cpp

@@ -20,15 +20,7 @@ using namespace engine;
 scene::scene(std::string const & str, math::vec2 const & bounds,
              std::shared_ptr<game_dispatch> dispatch)
     : identity<scene, std::string>(str), local_bounds_(bounds),
-      dispatch_(dispatch) {
-  if (size()[0]) {
-    auto convert = env::screen_size() / size();
-    auto scale = std::min(convert[0], convert[1]);
-    renderer = dispatch->make_renderer(scale);
-  } else {
-    renderer = dispatch->make_renderer(1.f);
-  }
-}
+      renderer_(dispatch->make_renderer(size())), dispatch_(dispatch) {}
 
 scene::~scene() {}
 
@@ -86,6 +78,9 @@ void scene::handle_key_event(event::key_event evt) {
 
 void scene::handle_mouse_event(event::mouse_event evt) {}
 
-math::vec2 scene::size() const { return local_bounds_; }
+math::vec2 scene::size() const {
+  return (local_bounds_ == math::vec2()) ? math::vec2(env::screen_size())
+                                         : local_bounds_;
+}
 
 key_binding const & scene::keys() const { return keys_; }