Make it so each batch renderer can have a different scale-factor.

engine/include/game/engine/game_dispatch.hpp

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

engine/include/game/engine/scene.hpp

@@ -21,11 +21,12 @@
 namespace engine {
   class scene : public identity<scene, std::string> {
   public:
-    scene(std::string const &, std::shared_ptr<game_dispatch>);
+    scene(std::string const &, math::vec2 const &,
+          std::shared_ptr<game_dispatch>);
     virtual ~scene();
 
     virtual void update(float delta) = 0;
-    virtual void render(graphics::renderer & renderer) = 0;
+    virtual void render() = 0;
     virtual void handle_key_event(event::key_event evt);
     virtual void handle_mouse_event(event::mouse_event evt);
 
@@ -42,6 +43,7 @@ namespace engine {
                                  std::vector<collidable *> const & to);
 
   protected:
+    std::shared_ptr<graphics::renderer> renderer;
     std::vector<entity> entities;
 
     // Map from entity::collides_with -> [entity*]
@@ -50,7 +52,7 @@ namespace engine {
     std::unordered_map<collision_t, std::vector<collidable *>> collidables;
 
   private:
-    math::vec2 local_scene_dimension_;
+    math::vec2 local_bounds_;
     key_binding keys_;
     std::weak_ptr<game_dispatch> dispatch_;
   };

engine/src/fps_counter.cxx

@@ -35,5 +35,5 @@ void fps_counter::set_frame_step(env::clock::duration const & since) {
   if (++counter_ != change_after_) { return; }
   counter_ = 0;
   text_engine_->create_text_cells(
-      glyphs_, {make_vector(5.f, 680.f), make_vector(10.f, 20.f), fps(since)});
+      glyphs_, {make_vector(5.f, 780.f), make_vector(10.f, 20.f), fps(since)});
 }

engine/src/game_dispatch.cpp

@@ -16,6 +16,7 @@
 #include "game/graphics/object.hpp"
 #include "game/graphics/renderer.hpp"
 #include "game/util/env.hpp"
+#include "matrix/matrix_helpers.hpp"
 
 namespace engine {
   namespace {
@@ -26,8 +27,8 @@ namespace engine {
   }
 
   game_dispatch::game_dispatch(std::shared_ptr<graphics::renderer> renderer)
-      : renderer(renderer), screen_size(env::screen_size()),
-        minimum_frame_duration(env::fps::v60),
+      : renderer(renderer), batch_renderer(make_renderer(1.f)),
+        screen_size(env::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() {}
@@ -94,11 +95,18 @@ namespace engine {
   }
 
   void game_dispatch::render() {
-    graphics::batch_renderer batch(renderer.get());
-    batch.clear();
+    batch_renderer->clear();
     for (auto & obj : counter->glyphs()) {
-      batch.draw(obj);
+      batch_renderer->draw(obj);
     }
-    curr_scene.ptr->render(batch);
+    batch_renderer->flush();
+    curr_scene.ptr->render();
+    renderer->flush();
+  }
+
+  std::shared_ptr<graphics::renderer>
+  game_dispatch::make_renderer(float scale) const {
+    return std::make_shared<graphics::batch_renderer>(
+        renderer.get(), math::matrix::scalar(make_vector(scale, scale, 1.f)));
   }
 }

engine/src/scene.cpp

@@ -13,17 +13,28 @@
 #include "game/graphics/renderer.hpp"
 #include "game/math/common.hpp"
 #include "game/math/compare.hpp"
+#include "game/util/env.hpp"
 
 using namespace engine;
 
-scene::scene(std::string const & str, std::shared_ptr<game_dispatch> dispatch)
-    : identity<scene, std::string>(str), dispatch_(dispatch) {}
+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);
+  }
+}
 
 scene::~scene() {}
 
 bool scene::in_bounds(math::dim2::point p) const {
-  return math::between(p[0], 0.f, local_scene_dimension_[0]) &&
-         math::between(p[1], 0.f, local_scene_dimension_[1]);
+  return math::between(p[0], 0.f, local_bounds_[0]) &&
+         math::between(p[1], 0.f, local_bounds_[1]);
 }
 
 bool scene::in_bounds(collidable * c) const {
@@ -75,6 +86,6 @@ 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_scene_dimension_; }
+math::vec2 scene::size() const { return local_bounds_; }
 
 key_binding const & scene::keys() const { return keys_; }

graphics/include/game/graphics/renderer.hpp

@@ -13,6 +13,7 @@
 #include "game/graphics/graphics_fwd.h"
 #include "game/math/math_fwd.hpp"
 #include "game/util/hash.hpp"
+#include "matrix/matrix.hpp"
 #include "vector/vector.hpp"
 
 namespace graphics {
@@ -45,6 +46,8 @@ namespace graphics {
   class batch_renderer : public renderer {
   public:
     batch_renderer(renderer * impl, std::size_t batch_size = 0);
+    batch_renderer(renderer * impl, math::matr4 const &,
+                   std::size_t batch_size = 0);
     ~batch_renderer();
     std::shared_ptr<class manager const> manager() const override {
       return impl_->manager();
@@ -62,6 +65,7 @@ namespace graphics {
   private:
     renderer * impl_;
     std::unordered_map<identity<material>, std::vector<vertex>> batches_;
+    math::matr4 object_to_world_;
     std::size_t batch_size_;
     std::size_t elements_;
   };

graphics/src/renderer.cxx

@@ -26,6 +26,10 @@ renderer_impl * get_renderer_impl(driver d) {
   }
 }
 
+namespace {
+  const math::matr4 identity4 = math::matrix::identity<float, 4>();
+}
+
 direct_renderer::direct_renderer(driver d) : pimpl(::get_renderer_impl(d)) {}
 
 std::shared_ptr<class manager const> direct_renderer::manager() const {
@@ -35,7 +39,7 @@ std::shared_ptr<class manager const> direct_renderer::manager() const {
 void direct_renderer::draw(object const & obj) {
   std::vector<vertex> verts;
   vertices(verts, obj);
-  draw(obj.material, math::matr4(), verts);
+  draw(obj.material, identity4, verts);
 }
 
 void direct_renderer::draw(identity<material> material,
@@ -48,7 +52,12 @@ void direct_renderer::clear() { pimpl->clear(); }
 void direct_renderer::flush() { pimpl->flush(); }
 
 batch_renderer::batch_renderer(renderer * impl, std::size_t batch_size)
-    : impl_(impl), batches_(), batch_size_(batch_size), elements_(0) {}
+    : batch_renderer(impl, identity4, batch_size) {}
+
+batch_renderer::batch_renderer(renderer * impl, math::matr4 const & to_world,
+                               std::size_t batch_size)
+    : impl_(impl), batches_(), object_to_world_(to_world),
+      batch_size_(batch_size), elements_(0) {}
 
 batch_renderer::~batch_renderer() { flush(); }
 
@@ -71,7 +80,7 @@ void batch_renderer::draw(identity<material> material, math::matr4 const &,
 
 void batch_renderer::flush() {
   write();
-  impl_->flush();
+  //  impl_->flush();
 }
 
 void batch_renderer::check() {
@@ -80,7 +89,7 @@ void batch_renderer::check() {
 
 void batch_renderer::write() {
   for (auto & pair : batches_) {
-    impl_->draw(pair.first, math::matrix::identity<float, 4>(), pair.second);
+    impl_->draw(pair.first, object_to_world_, pair.second);
   }
   batches_.clear();
   elements_ = 0;