renderer: Draw multiple layers per animation.

libopenage/renderer/stages/world/object.cpp

@@ -49,10 +49,18 @@ void WorldObject::set_render_entity(const std::shared_ptr<WorldRenderEntity> &en
 }
 
 void WorldObject::fetch_updates(const time::time_t &time) {
+	// TODO: Calling this once per frame is very expensive
+	auto layer_count = this->get_required_layer_count(time);
+	if (this->layer_uniforms.size() != layer_count) {
+		// The number of layers changed, so we need to update the renderables
+		this->require_renderable = true;
+	}
+
 	if (not this->render_entity->is_changed()) {
-		// exit early because there is nothing to do
+		// exit early because there is nothing to update
 		return;
 	}
+
 	// Get data from render entity
 	this->ref_id = this->render_entity->get_id();
 	this->position.sync(this->render_entity->get_position());
@@ -168,14 +176,27 @@ const renderer::resources::MeshData WorldObject::get_mesh() {
 	return resources::MeshData::make_quad();
 }
 
-bool WorldObject::requires_renderable() {
+const Eigen::Matrix4f WorldObject::get_model_matrix() {
+	return Eigen::Matrix4f::Identity();
+}
+
+bool WorldObject::requires_renderable() const {
 	return this->require_renderable;
 }
 
 void WorldObject::clear_requires_renderable() {
 	this->require_renderable = false;
 }
 
+size_t WorldObject::get_required_layer_count(const time::time_t &time) const {
+	auto animation_info = this->animation_info.get(time);
+	if (not animation_info) {
+		return 0;
+	}
+
+	return animation_info->get_layer_count();
+}
+
 bool WorldObject::is_changed() {
 	return this->changed;
 }
@@ -184,9 +205,8 @@ void WorldObject::clear_changed_flag() {
 	this->changed = false;
 }
 
-void WorldObject::set_uniforms(const std::shared_ptr<renderer::UniformInput> &uniforms) {
-	this->layer_uniforms.clear(); // ASDF: Update instead of clear
-	this->layer_uniforms.push_back(uniforms);
+void WorldObject::set_uniforms(std::vector<std::shared_ptr<renderer::UniformInput>> &&uniforms) {
+	this->layer_uniforms = std::move(uniforms);
 }
 
 } // namespace openage::renderer::world

libopenage/renderer/stages/world/object.h

@@ -75,10 +75,19 @@ class WorldObject {
 	/**
 	 * Get the quad for creating the geometry.
 	 *
+	 * Since the object is a bunch of sprite layers, the mesh is always a quad.
+	 *
 	 * @return Mesh for creating a renderer geometry object.
 	 */
 	static const renderer::resources::MeshData get_mesh();
 
+	/**
+	 * Get the model matrix for the uniform input of a layer.
+	 *
+	 * @return Model matrix.
+	 */
+	static const Eigen::Matrix4f get_model_matrix();
+
 	/**
 	 * Check whether a new renderable needs to be created for this mesh.
 	 *
@@ -88,13 +97,20 @@ class WorldObject {
 	 *
 	 * @return true if a new renderable is required, else false.
 	 */
-	bool requires_renderable();
+	bool requires_renderable() const;
 
 	/**
 	 * Indicate to this mesh that a new renderable has been created.
 	 */
 	void clear_requires_renderable();
 
+	/**
+	 * Get the number of layers required by this object.
+	 *
+	 * @return Number of layers.
+	 */
+	size_t get_required_layer_count(const time::time_t &time) const;
+
 	/**
 	 * Check whether the object was changed by \p update().
 	 *
@@ -108,13 +124,12 @@ class WorldObject {
 	void clear_changed_flag();
 
 	/**
-	 * Set the reference to the uniform inputs of the renderable
-	 * associated with this object. Relevant uniforms are updated
-	 * when calling \p update().
+	 * Set the uniform inputs for the layers of this object.
+	 * Layer uniforms are updated on every update call.
 	 *
-	 * @param uniforms Uniform inputs of this object's renderable.
+	 * @param uniforms Uniform inputs of this object's layers.
 	 */
-	void set_uniforms(const std::shared_ptr<renderer::UniformInput> &uniforms);
+	void set_uniforms(std::vector<std::shared_ptr<renderer::UniformInput>> &&uniforms);
 
 	/**
 	 * Shader uniform IDs for setting uniform values.
@@ -175,10 +190,6 @@ class WorldObject {
 	/**
 	 * Shader uniforms for the layers of the object. Each layer corresponds to a
 	 * renderable in the render pass.
-	 *
-	 * Since all layers are sprites and share the same geometry, we can reuse the layer uniforms and
-	 * their renderables even if the animation changes. Therefore, we only need to add/remove
-	 * layers when the _number_ of layers in the animation changes.
 	 */
 	std::vector<std::shared_ptr<renderer::UniformInput>> layer_uniforms;
 

libopenage/renderer/stages/world/render_stage.cpp

@@ -60,31 +60,36 @@ void WorldRenderStage::update() {
 		obj->fetch_updates(current_time);
 		if (obj->is_changed()) {
 			if (obj->requires_renderable()) {
-				Eigen::Matrix4f model_m = Eigen::Matrix4f::Identity();
-
-				// Set uniforms that don't change or are not changed often
-				auto transform_unifs = this->display_shader->new_uniform_input(
-					"model",
-					model_m,
-					"flip_x",
-					false,
-					"flip_y",
-					false,
-					"u_id",
-					obj->get_id());
-
-				Renderable display_obj{
-					transform_unifs,
-					this->default_geometry,
-					true,
-					true,
-				};
-
-				this->render_pass->add_renderables(display_obj);
+				auto layer_count = obj->get_required_layer_count(current_time);
+				Eigen::Matrix4f model_m = obj->get_model_matrix();
+
+				std::vector<std::shared_ptr<renderer::UniformInput>> transform_unifs;
+				for (size_t i = 0; i < layer_count; i++) {
+					// Set uniforms that don't change or are not changed often
+					auto layer_unifs = this->display_shader->new_uniform_input(
+						"model",
+						model_m,
+						"flip_x",
+						false,
+						"flip_y",
+						false,
+						"u_id",
+						obj->get_id());
+
+					Renderable display_obj{
+						layer_unifs,
+						this->default_geometry,
+						true,
+						true,
+					};
+					this->render_pass->add_renderables(display_obj);
+					transform_unifs.push_back(layer_unifs);
+				}
+
 				obj->clear_requires_renderable();
 
 				// update remaining uniforms for the object
-				obj->set_uniforms(transform_unifs);
+				obj->set_uniforms(std::move(transform_unifs));
 			}
 		}
 		obj->update_uniforms(current_time);