Merge branch 'instancing-pt2'

10 files changed, 65 insertions, 74 deletions

diff --git a/game/scenary/foliage.cpp b/game/scenary/foliage.cpp
index 35be051..0913c6e 100644
--- a/game/scenary/foliage.cpp
+++ b/game/scenary/foliage.cpp
@@ -26,14 +26,15 @@ Foliage::render(const SceneShader & shader) const
 		if (texture) {
 			texture->bind();
 		}
-		glBindVertexArray(instanceVAO);
-		glDrawElementsInstanced(
-				bodyMesh->type(), bodyMesh->count(), GL_UNSIGNED_INT, nullptr, static_cast<GLsizei>(count));
-		glBindVertexArray(0);
+		bodyMesh->DrawInstanced(instanceVAO, static_cast<GLsizei>(count));
 	}
 }
 
 void
-Foliage::shadows(const ShadowMapper &) const
+Foliage::shadows(const ShadowMapper & mapper) const
 {
+	if (const auto count = instances.count()) {
+		mapper.dynamicPointInst.use();
+		bodyMesh->DrawInstanced(instanceVAO, static_cast<GLsizei>(count));
+	}
 }
diff --git a/game/scenary/plant.cpp b/game/scenary/plant.cpp
index 678d4a7..2a79807 100644
--- a/game/scenary/plant.cpp
+++ b/game/scenary/plant.cpp
@@ -1,7 +1,7 @@
 #include "plant.h"
+#include "location.hpp"
 
-Plant::Plant(std::shared_ptr<const Foliage> type, Location position) :
-	type {std::move(type)},
-	location {this->type->instances.acquire(glm::translate(position.pos) * rotate_ypr(position.rot))}
+Plant::Plant(std::shared_ptr<const Foliage> type, const Location & position) :
+	type {std::move(type)}, location {this->type->instances.acquire(position.getTransform())}
 {
 }
diff --git a/game/scenary/plant.h b/game/scenary/plant.h
index 77c5979..82ab0e5 100644
--- a/game/scenary/plant.h
+++ b/game/scenary/plant.h
@@ -2,9 +2,8 @@
 
 #include "foliage.h"
 #include "game/worldobject.h"
-#include "location.hpp"
-#include "maths.h"
-#include <glm/gtx/transform.hpp>
+
+class Location;
 
 class Plant : public WorldObject {
 	std::shared_ptr<const Foliage> type;
@@ -16,5 +15,5 @@ class Plant : public WorldObject {
 	}
 
 public:
-	Plant(std::shared_ptr<const Foliage> type, Location position);
+	Plant(std::shared_ptr<const Foliage> type, const Location & position);
 };
diff --git a/game/vehicles/railVehicle.cpp b/game/vehicles/railVehicle.cpp
index 77907be..b77b93c 100644
--- a/game/vehicles/railVehicle.cpp
+++ b/game/vehicles/railVehicle.cpp
@@ -11,22 +11,14 @@
 #include <memory>
 #include <ray.hpp>
 
-RailVehicle::RailVehicle(RailVehicleClassPtr rvc) : rvClass {std::move(rvc)}
+RailVehicle::RailVehicle(RailVehicleClassPtr rvc) :
+	rvClass {std::move(rvc)}, location {rvClass->instancesBody}, bogies {
+																		 rvClass->instancesBogies.front(),
+																		 rvClass->instancesBogies.back(),
+																 }
 {
-	bogies.front().pos.y = rvClass->wheelBase / 2.F;
-	bogies.back().pos.y = -bogies.front().pos.y;
-}
-
-void
-RailVehicle::render(const SceneShader & shader) const
-{
-	rvClass->render(shader, location, bogies);
-}
-
-void
-RailVehicle::shadows(const ShadowMapper & shadowMapper) const
-{
-	rvClass->shadows(shadowMapper, location, bogies);
+	bogies.front().setPosition({0, rvClass->wheelBase / 2.F, 0});
+	bogies.back().setPosition({0, -bogies.front().position().y, 0});
 }
 
 void
@@ -35,9 +27,8 @@ RailVehicle::move(const Train * t, float & trailBy)
 	const auto overhang {(rvClass->length - rvClass->wheelBase) / 2};
 	const auto & b1Pos = bogies[0] = t->getBogiePosition(t->linkDist, trailBy += overhang);
 	const auto & b2Pos = bogies[1] = t->getBogiePosition(t->linkDist, trailBy += rvClass->wheelBase);
-	const auto diff = glm::normalize(b2Pos.pos - b1Pos.pos);
-	location.pos = (b1Pos.pos + b2Pos.pos) / 2.F;
-	location.rot = {vector_pitch(diff), vector_yaw(diff), 0};
+	const auto diff = glm::normalize(b2Pos.position() - b1Pos.position());
+	location.setLocation((b1Pos.position() + b2Pos.position()) / 2.F, {vector_pitch(diff), vector_yaw(diff), 0});
 	trailBy += 0.6F + overhang;
 }
 
@@ -47,7 +38,7 @@ RailVehicle::intersectRay(const Ray & ray, glm::vec2 * baryPos, float * distance
 	constexpr const auto X = 1.35F;
 	const auto Y = this->rvClass->length / 2.F;
 	constexpr const auto Z = 3.9F;
-	const auto moveBy = glm::translate(location.pos) * rotate_ypr(location.rot);
+	const auto moveBy = location.getTransform();
 	const std::array<glm::vec3, 8> cornerVertices {{
 			moveBy * glm::vec4 {-X, Y, 0, 1}, //  LFB
 			moveBy * glm::vec4 {X, Y, 0, 1}, //   RFB
diff --git a/game/vehicles/railVehicle.h b/game/vehicles/railVehicle.h
index bbf4df9..247bf66 100644
--- a/game/vehicles/railVehicle.h
+++ b/game/vehicles/railVehicle.h
@@ -1,11 +1,10 @@
 #pragma once
 
-#include "gfx/renderable.h"
+#include "gfx/gl/bufferedLocation.h"
 #include "railVehicleClass.h"
 #include <array>
 #include <game/selectable.h>
 #include <glm/glm.hpp>
-#include <location.hpp>
 #include <memory>
 #include <utility>
 
@@ -14,19 +13,16 @@ class ShadowMapper;
 class Ray;
 
 class Train;
-class RailVehicle : public Renderable, Selectable {
+class RailVehicle : Selectable {
 public:
 	explicit RailVehicle(RailVehicleClassPtr rvc);
 
 	void move(const Train *, float & trailBy);
 
-	void render(const SceneShader & shader) const override;
-	void shadows(const ShadowMapper & shadowMapper) const override;
 	[[nodiscard]] bool intersectRay(const Ray &, glm::vec2 *, float *) const override;
 
-	Location location;
-
 	RailVehicleClassPtr rvClass;
-	std::array<Location, 2> bogies;
+	BufferedLocation location;
+	std::array<BufferedLocation, 2> bogies;
 };
 using RailVehiclePtr = std::unique_ptr<RailVehicle>;
diff --git a/game/vehicles/railVehicleClass.cpp b/game/vehicles/railVehicleClass.cpp
index b7a3b1e..82a442e 100644
--- a/game/vehicles/railVehicleClass.cpp
+++ b/game/vehicles/railVehicleClass.cpp
@@ -1,6 +1,7 @@
 #include "railVehicleClass.h"
 #include "gfx/gl/sceneShader.h"
 #include "gfx/gl/shadowMapper.h"
+#include "gfx/gl/vertexArrayObject.hpp"
 #include "gfx/models/mesh.h"
 #include "gfx/models/texture.h"
 #include <algorithm>
@@ -33,30 +34,38 @@ void
 RailVehicleClass::postLoad()
 {
 	texture = getTexture();
+	bodyMesh->configureVAO(instanceVAO).addAttribs<glm::mat4>(instancesBody.bufferName(), 1);
+	bogies.front()
+			->configureVAO(instancesBogiesVAO.front())
+			.addAttribs<glm::mat4>(instancesBogies.front().bufferName(), 1);
+	bogies.back()
+			->configureVAO(instancesBogiesVAO.back())
+			.addAttribs<glm::mat4>(instancesBogies.back().bufferName(), 1);
 }
 
 void
-RailVehicleClass::render(
-		const SceneShader & shader, const Location & location, const std::array<Location, 2> & bl) const
+RailVehicleClass::render(const SceneShader & shader) const
 {
-	shader.basic.use(location);
-	if (texture) {
-		texture->bind();
-	}
-	bodyMesh->Draw();
-	for (auto b = 0U; b < bogies.size(); ++b) {
-		shader.basic.setModel(bl[b]);
-		bogies[b]->Draw();
+	if (const auto count = instancesBody.count()) {
+		if (texture) {
+			texture->bind();
+		}
+		shader.basicInst.use();
+		bodyMesh->DrawInstanced(instanceVAO, static_cast<GLsizei>(count));
+		bogies.front()->DrawInstanced(
+				instancesBogiesVAO.front(), static_cast<GLsizei>(instancesBogies.front().count()));
+		bogies.back()->DrawInstanced(instancesBogiesVAO.back(), static_cast<GLsizei>(instancesBogies.back().count()));
 	}
 }
+
 void
-RailVehicleClass::shadows(
-		const ShadowMapper & shadowMapper, const Location & location, const std::array<Location, 2> & bl) const
+RailVehicleClass::shadows(const ShadowMapper & mapper) const
 {
-	shadowMapper.dynamicPoint.use(location);
-	bodyMesh->Draw();
-	for (auto b = 0U; b < bogies.size(); ++b) {
-		shadowMapper.dynamicPoint.setModel(bl[b]);
-		bogies[b]->Draw();
+	if (const auto count = instancesBody.count()) {
+		mapper.dynamicPointInst.use();
+		bodyMesh->DrawInstanced(instanceVAO, static_cast<GLsizei>(count));
+		bogies.front()->DrawInstanced(
+				instancesBogiesVAO.front(), static_cast<GLsizei>(instancesBogies.front().count()));
+		bogies.back()->DrawInstanced(instancesBogiesVAO.back(), static_cast<GLsizei>(instancesBogies.back().count()));
 	}
 }
diff --git a/game/vehicles/railVehicleClass.h b/game/vehicles/railVehicleClass.h
index 1a52e2b..2fda8f7 100644
--- a/game/vehicles/railVehicleClass.h
+++ b/game/vehicles/railVehicleClass.h
@@ -1,7 +1,9 @@
 #pragma once
 
 #include "assetFactory/asset.h"
+#include "gfx/gl/instanceVertices.h"
 #include "gfx/models/mesh.h"
+#include "gfx/renderable.h"
 #include <array>
 #include <memory>
 #include <string>
@@ -11,10 +13,10 @@ class ShadowMapper;
 class Texture;
 class Location;
 
-class RailVehicleClass : public Asset {
+class RailVehicleClass : public Renderable, public Asset {
 public:
-	void render(const SceneShader &, const Location &, const std::array<Location, 2> &) const;
-	void shadows(const ShadowMapper &, const Location &, const std::array<Location, 2> &) const;
+	void render(const SceneShader & shader) const override;
+	void shadows(const ShadowMapper & shadowMapper) const override;
 
 	std::array<Mesh::Ptr, 2> bogies;
 	Mesh::Ptr bodyMesh;
@@ -23,9 +25,16 @@ public:
 	float length;
 	float maxSpeed;
 
+	mutable InstanceVertices<glm::mat4> instancesBody;
+	mutable std::array<InstanceVertices<glm::mat4>, 2> instancesBogies;
+
 protected:
 	friend Persistence::SelectionPtrBase<std::shared_ptr<RailVehicleClass>>;
 	bool persist(Persistence::PersistenceStore & store) override;
 	void postLoad() override;
+
+private:
+	glVertexArray instanceVAO;
+	std::array<glVertexArray, 2> instancesBogiesVAO;
 };
 using RailVehicleClassPtr = std::shared_ptr<RailVehicleClass>;
diff --git a/game/vehicles/train.cpp b/game/vehicles/train.cpp
index 0332c04..fdfc3e1 100644
--- a/game/vehicles/train.cpp
+++ b/game/vehicles/train.cpp
@@ -11,17 +11,6 @@
 
 class Ray;
 
-void
-Train::render(const SceneShader & shader) const
-{
-	apply(&Renderable::render, shader);
-}
-void
-Train::shadows(const ShadowMapper & shadowMapper) const
-{
-	apply(&Renderable::shadows, shadowMapper);
-}
-
 Location
 Train::getBogiePosition(float linkDist, float dist) const
 {
diff --git a/game/vehicles/train.h b/game/vehicles/train.h
index 91f7ddb..15e2f6e 100644
--- a/game/vehicles/train.h
+++ b/game/vehicles/train.h
@@ -27,9 +27,6 @@ public:
 		return objects.front()->location;
 	}
 
-	void render(const SceneShader & shader) const override;
-	void shadows(const ShadowMapper & shadowMapper) const override;
-
 	[[nodiscard]] bool intersectRay(const Ray &, glm::vec2 *, float *) const override;
 
 	void tick(TickDuration elapsed) override;
diff --git a/game/vehicles/vehicle.h b/game/vehicles/vehicle.h
index 3fa3092..369bd7a 100644
--- a/game/vehicles/vehicle.h
+++ b/game/vehicles/vehicle.h
@@ -12,7 +12,7 @@
 
 class Location;
 
-class Vehicle : public WorldObject, public Renderable, public Selectable {
+class Vehicle : public WorldObject, public Selectable {
 public:
 	explicit Vehicle(const Link::Ptr & link, float linkDist = 0);
 	float linkDist; // distance along current link