18 files changed, 234 insertions, 170 deletions

diff --git a/gfx/aabb.h b/gfx/aabb.h
new file mode 100644
index 0000000..ce15a0f
--- /dev/null
+++ b/gfx/aabb.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "maths.h"
+#include <algorithm>
+#include <tuple>
+
+template<Arithmetic T, glm::qualifier Q = glm::defaultp> class AxisAlignedBoundingBox {
+public:
+	using V = glm::vec<3, T, Q>;
+	AxisAlignedBoundingBox() = default;
+
+	AxisAlignedBoundingBox(const V & min, const V & max) : min {min}, max {max} { }
+
+	AxisAlignedBoundingBox &
+	operator+=(const V & point)
+	{
+		min = glm::min(min, point);
+		max = glm::max(max, point);
+		return *this;
+	}
+
+	AxisAlignedBoundingBox
+	operator-(const V & viewPoint) const
+	{
+		return {min - viewPoint, max - viewPoint};
+	}
+
+	[[nodiscard]] static AxisAlignedBoundingBox
+	fromPoints(auto && points)
+	{
+		using Limits = std::numeric_limits<T>;
+		static constexpr const auto INITIAL = std::make_pair(V {Limits::max()}, V {Limits::min()});
+		return std::make_from_tuple<AxisAlignedBoundingBox<T, Q>>(
+				std::ranges::fold_left(points, INITIAL, [](const auto & prev, const auto & point) {
+					auto & [min, max] = prev;
+					return std::make_pair(glm::min(min, point), glm::max(max, point));
+				}));
+	}
+
+	V min {}, max {};
+};
diff --git a/gfx/gl/camera.cpp b/gfx/camera.cpp
index f03e85b..3bb785d 100644
--- a/gfx/gl/camera.cpp
+++ b/gfx/camera.cpp
@@ -4,13 +4,23 @@
 #include <maths.h>
 #include <ray.h>
 
-Camera::Camera(GlobalPosition3D pos, Angle fov, Angle aspect, GlobalDistance zNear, GlobalDistance zFar) :
-	position {pos}, forward {::north}, up {::up}, near {zNear}, far {zFar}, view {},
-	projection {
-			glm::perspective(fov, aspect, static_cast<RelativeDistance>(zNear), static_cast<RelativeDistance>(zFar))},
-	viewProjection {}, inverseViewProjection {}
+Camera::Camera(GlobalPosition3D pos, Angle fov, Angle aspect, GlobalDistance near, GlobalDistance far) :
+	Camera {pos, fov, aspect, near, far, glm::lookAt({}, ::north, ::up),
+			glm::perspective(fov, aspect, static_cast<RelativeDistance>(near), static_cast<RelativeDistance>(far))}
 {
-	updateView();
+}
+
+Camera::Camera(GlobalPosition3D pos, Angle fov, Angle aspect, GlobalDistance near, GlobalDistance far,
+		const glm::mat4 & view, const glm::mat4 & projection) :
+	Frustum {pos, view, projection}, fov {fov}, aspect {aspect}, forward {::north}, up {::up}, near {near}, far {far}
+{
+}
+
+void
+Camera::setAspect(Angle aspect)
+{
+	projection = glm::perspective(fov, aspect, static_cast<RelativeDistance>(near), static_cast<RelativeDistance>(far));
+	Frustum::updateCache();
 }
 
 Ray<GlobalPosition3D>
@@ -26,9 +36,7 @@ Camera::unProject(const ScreenRelCoord & mouse) const
 void
 Camera::updateView()
 {
-	view = glm::lookAt({}, forward, up);
-	viewProjection = projection * view;
-	inverseViewProjection = glm::inverse(viewProjection);
+	Frustum::updateView(glm::lookAt({}, forward, up));
 }
 
 Direction3D
diff --git a/gfx/gl/camera.h b/gfx/camera.h
index 5c37744..b17bcbb 100644
--- a/gfx/gl/camera.h
+++ b/gfx/camera.h
@@ -1,22 +1,19 @@
 #pragma once
 
 #include "config/types.h"
+#include "frustum.h"
 #include <glm/glm.hpp>
 #include <maths.h>
 #include <ray.h>
 
-class Camera {
+class Camera : public Frustum {
 public:
-	Camera(GlobalPosition3D, Angle fov, Angle aspect, GlobalDistance zNear, GlobalDistance zFar);
-
-	[[nodiscard]] glm::mat4
-	getViewProjection() const
-	{
-		return viewProjection;
-	}
+	Camera(GlobalPosition3D position, Angle fov, Angle aspect, GlobalDistance near, GlobalDistance far);
 
 	[[nodiscard]] Ray<GlobalPosition3D> unProject(const ScreenRelCoord &) const;
 
+	void setAspect(Angle aspect);
+
 	void
 	setPosition(const GlobalPosition3D & p)
 	{
@@ -64,24 +61,17 @@ public:
 		return forward;
 	}
 
-	[[nodiscard]] auto
-	getPosition() const
-	{
-		return position;
-	}
-
 	[[nodiscard]] std::array<GlobalPosition4D, 4> extentsAtDist(GlobalDistance) const;
 
 	[[nodiscard]] static Direction3D upFromForward(const Direction3D & forward);
 
 private:
+	Camera(GlobalPosition3D position, Angle fov, Angle aspect, GlobalDistance near, GlobalDistance far,
+			const glm::mat4 & view, const glm::mat4 & projection);
 	void updateView();
 
-	GlobalPosition3D position;
+	Angle fov, aspect;
 	Direction3D forward;
 	Direction3D up;
-
 	GlobalDistance near, far;
-	glm::mat4 view, projection;
-	glm::mat4 viewProjection, inverseViewProjection;
 };
diff --git a/gfx/followCameraController.cpp b/gfx/followCameraController.cpp
index cf6da34..d7bbc0b 100644
--- a/gfx/followCameraController.cpp
+++ b/gfx/followCameraController.cpp
@@ -1,6 +1,6 @@
 #include "followCameraController.h"
 #include "game/vehicles/vehicle.h"
-#include <gfx/gl/camera.h>
+#include <gfx/camera.h>
 #include <glm/glm.hpp>
 #include <location.h>
 #include <maths.h>
diff --git a/gfx/frustum.cpp b/gfx/frustum.cpp
new file mode 100644
index 0000000..faa676d
--- /dev/null
+++ b/gfx/frustum.cpp
@@ -0,0 +1,67 @@
+#include "frustum.h"
+#include <algorithm>
+#include <collections.h>
+#include <glm/ext/matrix_transform.hpp>
+
+static constexpr auto PLANES = std::array {0, 1, 2} * std::array {-1.F, 1.F};
+
+Frustum::Frustum(const GlobalPosition3D & pos, const glm::mat4 & view, const glm::mat4 & projection) :
+	position {pos}, view {view}, projection {projection}, viewProjection {}, inverseViewProjection {}, planes {}
+{
+	updateCache();
+}
+
+void
+Frustum::updateView(const glm::mat4 & newView)
+{
+	view = newView;
+	updateCache();
+}
+
+bool
+Frustum::contains(const BoundingBox & aabb) const
+{
+	return boundByPlanes(aabb, FACES);
+}
+
+bool
+Frustum::shadedBy(const BoundingBox & aabb) const
+{
+	return boundByPlanes(aabb, FACES - 1);
+}
+
+bool
+Frustum::boundByPlanes(const BoundingBox & aabb, size_t nplanes) const
+{
+	static constexpr auto EXTENT_CORNER_IDXS = [] {
+		using Extent = GlobalPosition3D BoundingBox::*;
+		constexpr auto EXTENTS = std::array {&BoundingBox::min, &BoundingBox::max};
+		std::array<glm::vec<3, Extent>, 2ZU * 2ZU * 2ZU> out {};
+		std::ranges::copy(std::views::cartesian_product(EXTENTS, EXTENTS, EXTENTS)
+						| std::views::transform(
+								std::make_from_tuple<glm::vec<3, Extent>, std::tuple<Extent, Extent, Extent>>),
+				out.begin());
+		return out;
+	}();
+
+	const std::array<RelativePosition4D, 8> corners
+			= EXTENT_CORNER_IDXS * [relativeAabb = aabb - position](auto idxs) -> glm::vec4 {
+		return {(relativeAabb.*(idxs.x)).x, (relativeAabb.*(idxs.y)).y, (relativeAabb.*(idxs.z)).z, 1.F};
+	};
+	return std::ranges::none_of(std::span(planes).subspan(0, nplanes), [&corners](const auto & frustumPlane) {
+		return (std::ranges::all_of(corners, [&frustumPlane](const auto & corner) {
+			return glm::dot(frustumPlane, corner) < 0.F;
+		}));
+	});
+}
+
+void
+Frustum::updateCache()
+{
+	viewProjection = projection * view;
+	inverseViewProjection = glm::inverse(viewProjection);
+	std::ranges::transform(PLANES, planes.begin(), [vpt = glm::transpose(viewProjection)](const auto & idxs) {
+		const auto [idx, sgn] = idxs;
+		return vpt[3] + (vpt[idx] * sgn);
+	});
+}
diff --git a/gfx/frustum.h b/gfx/frustum.h
new file mode 100644
index 0000000..a2d90e9
--- /dev/null
+++ b/gfx/frustum.h
@@ -0,0 +1,45 @@
+#pragma once
+
+#include "aabb.h"
+#include "config/types.h"
+#include <array>
+#include <glm/mat4x4.hpp>
+
+class Frustum {
+public:
+	Frustum(const GlobalPosition3D & pos, const glm::mat4 & view, const glm::mat4 & projection);
+
+	[[nodiscard]] auto &
+	getFrustumPlanes() const
+	{
+		return planes;
+	}
+
+	[[nodiscard]] auto &
+	getViewProjection() const
+	{
+		return viewProjection;
+	}
+
+	[[nodiscard]] auto
+	getPosition() const
+	{
+		return position;
+	}
+
+	void updateView(const glm::mat4 & view);
+
+	using BoundingBox = AxisAlignedBoundingBox<GlobalDistance>;
+	[[nodiscard]] bool contains(const BoundingBox &) const;
+	[[nodiscard]] bool shadedBy(const BoundingBox &) const;
+
+protected:
+	static constexpr size_t FACES = 6;
+	void updateCache();
+	[[nodiscard]] bool boundByPlanes(const BoundingBox &, size_t nplanes) const;
+
+	GlobalPosition3D position;
+	glm::mat4 view, projection;
+	glm::mat4 viewProjection, inverseViewProjection;
+	std::array<glm::vec4, FACES> planes;
+};
diff --git a/gfx/gl/sceneProvider.cpp b/gfx/gl/sceneProvider.cpp
index 4e271db..3681c60 100644
--- a/gfx/gl/sceneProvider.cpp
+++ b/gfx/gl/sceneProvider.cpp
@@ -5,10 +5,10 @@ void
 SceneProvider::environment(const SceneShader &, const SceneRenderer & renderer) const
 {
 	renderer.setAmbientLight({0.5F, 0.5F, 0.5F});
-	renderer.setDirectionalLight({0.6F, 0.6F, 0.6F}, {{-quarter_pi, -quarter_pi}}, *this);
+	renderer.setDirectionalLight({0.6F, 0.6F, 0.6F}, {{-quarter_pi, quarter_pi}}, *this);
 }
 
 void
-SceneProvider::shadows(const ShadowMapper &) const
+SceneProvider::shadows(const ShadowMapper &, const Frustum &) const
 {
 }
diff --git a/gfx/gl/sceneProvider.h b/gfx/gl/sceneProvider.h
index f5e8e99..f6b7009 100644
--- a/gfx/gl/sceneProvider.h
+++ b/gfx/gl/sceneProvider.h
@@ -5,6 +5,7 @@
 class SceneRenderer;
 class ShadowMapper;
 class SceneShader;
+class Frustum;
 
 class SceneProvider {
 public:
@@ -12,8 +13,8 @@ public:
 	virtual ~SceneProvider() = default;
 	DEFAULT_MOVE_COPY(SceneProvider);
 
-	virtual void content(const SceneShader &) const = 0;
+	virtual void content(const SceneShader &, const Frustum &) const = 0;
 	virtual void environment(const SceneShader &, const SceneRenderer &) const;
 	virtual void lights(const SceneShader &) const = 0;
-	virtual void shadows(const ShadowMapper &) const;
+	virtual void shadows(const ShadowMapper &, const Frustum &) const;
 };
diff --git a/gfx/gl/sceneRenderer.cpp b/gfx/gl/sceneRenderer.cpp
index b2a7d78..9a4d153 100644
--- a/gfx/gl/sceneRenderer.cpp
+++ b/gfx/gl/sceneRenderer.cpp
@@ -39,7 +39,7 @@ SceneRenderer::SceneRenderer(ScreenAbsCoord s, GLuint o) :
 
 	glBindFramebuffer(GL_FRAMEBUFFER, gBuffer);
 	configuregdata(gPosition, {GL_RGB32I}, GL_RGB_INTEGER, GL_COLOR_ATTACHMENT0);
-	configuregdata(gNormal, {GL_RGB8_SNORM, GL_RGB16F}, GL_RGB, GL_COLOR_ATTACHMENT1);
+	normaliFormat = configuregdata(gNormal, {GL_RGB8_SNORM, GL_RGB16F}, GL_RGB, GL_COLOR_ATTACHMENT1);
 	configuregdata(gAlbedoSpec, {GL_RGB8}, GL_RGB, GL_COLOR_ATTACHMENT2);
 	constexpr std::array<unsigned int, 3> attachments {
 			GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2};
@@ -57,6 +57,24 @@ SceneRenderer::SceneRenderer(ScreenAbsCoord s, GLuint o) :
 }
 
 void
+SceneRenderer::resize(ScreenAbsCoord newSize)
+{
+	size = newSize;
+	camera.setAspect(ratio(size));
+	const auto configuregdata = [this](const GLuint data, const GLint iformat, const GLenum format) {
+		glBindTexture(GL_TEXTURE_2D, data);
+		glTexImage2D(GL_TEXTURE_2D, 0, iformat, size.x, size.y, 0, format, GL_BYTE, nullptr);
+	};
+	configuregdata(gPosition, GL_RGB32I, GL_RGB_INTEGER);
+	configuregdata(gNormal, normaliFormat, GL_RGB);
+	configuregdata(gAlbedoSpec, GL_RGB8, GL_RGB);
+	configuregdata(gIllumination, GL_RGB8, GL_RGB);
+	glBindFramebuffer(GL_FRAMEBUFFER, gBuffer);
+	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, size.x, size.y);
+	shader.setViewPort({0, 0, size.x, size.y});
+}
+
+void
 SceneRenderer::render(const SceneProvider & scene) const
 {
 	shader.setViewProjection(camera.getPosition(), camera.getViewProjection());
@@ -71,7 +89,7 @@ SceneRenderer::render(const SceneProvider & scene) const
 	glEnable(GL_DEPTH_TEST);
 	glClearColor(0, 0, 0, 1);
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-	scene.content(shader);
+	scene.content(shader, camera);
 
 	// Environment pass -
 	// * ambient - clears illumination texture - see setAmbientLight
diff --git a/gfx/gl/sceneRenderer.h b/gfx/gl/sceneRenderer.h
index 93470f5..31f0cda 100644
--- a/gfx/gl/sceneRenderer.h
+++ b/gfx/gl/sceneRenderer.h
@@ -1,18 +1,20 @@
 #pragma once
 
-#include "camera.h"
 #include "gfx/lightDirection.h"
 #include "glArrays.h"
 #include "program.h"
 #include "sceneProvider.h"
 #include "sceneShader.h"
 #include "shadowMapper.h"
+#include <gfx/camera.h>
 #include <glm/fwd.hpp>
 
 class SceneRenderer {
 public:
 	explicit SceneRenderer(ScreenAbsCoord size, GLuint output);
 
+	void resize(ScreenAbsCoord size);
+
 	void render(const SceneProvider &) const;
 	void setAmbientLight(const RGB & colour) const;
 	void setDirectionalLight(const RGB & colour, const LightDirection & direction, const SceneProvider &) const;
@@ -25,6 +27,7 @@ protected:
 	ScreenAbsCoord size;
 	GLuint output;
 	glFrameBuffer gBuffer, gBufferIll;
+	GLint normaliFormat;
 	glTexture gPosition, gNormal, gAlbedoSpec, gIllumination;
 	glRenderBuffer depth;
 
diff --git a/gfx/gl/shaders/uiShader.fs b/gfx/gl/shaders/uiShader.fs
deleted file mode 100644
index c5f4e92..0000000
--- a/gfx/gl/shaders/uiShader.fs
+++ /dev/null
@@ -1,11 +0,0 @@
-#version 330 core
-
-in vec2 texCoord0;
-
-uniform sampler2D sampler;
-
-void
-main()
-{
-	gl_FragColor = texture(sampler, texCoord0);
-}
diff --git a/gfx/gl/shaders/uiShader.vs b/gfx/gl/shaders/uiShader.vs
deleted file mode 100644
index e9e4373..0000000
--- a/gfx/gl/shaders/uiShader.vs
+++ /dev/null
@@ -1,13 +0,0 @@
-#version 330 core
-
-in vec4 position;
-
-out vec2 texCoord0;
-uniform mat4 uiProjection;
-
-void
-main()
-{
-	gl_Position = uiProjection * vec4(position.xy, 0.0, 1.0);
-	texCoord0 = position.zw;
-}
diff --git a/gfx/gl/shaders/uiShaderFont.fs b/gfx/gl/shaders/uiShaderFont.fs
deleted file mode 100644
index a1ef6ef..0000000
--- a/gfx/gl/shaders/uiShaderFont.fs
+++ /dev/null
@@ -1,12 +0,0 @@
-#version 330 core
-
-in vec2 texCoord0;
-
-uniform sampler2D sampler;
-uniform vec3 colour;
-
-void
-main()
-{
-	gl_FragColor = vec4(colour, texture(sampler, texCoord0).r);
-}
diff --git a/gfx/gl/shadowMapper.cpp b/gfx/gl/shadowMapper.cpp
index 1b95aa3..3cb73f7 100644
--- a/gfx/gl/shadowMapper.cpp
+++ b/gfx/gl/shadowMapper.cpp
@@ -1,7 +1,7 @@
 #include "shadowMapper.h"
-#include "camera.h"
 #include "collections.h"
 #include "game/gamestate.h"
+#include "gfx/aabb.h"
 #include "gfx/gl/shaders/fs-shadowDynamicPointInstWithTextures.h"
 #include "gfx/gl/shaders/fs-shadowDynamicPointStencil.h"
 #include "gfx/gl/shaders/gs-commonShadowPoint.h"
@@ -20,7 +20,7 @@
 #include "maths.h"
 #include "sceneProvider.h"
 #include "sceneShader.h"
-#include "sorting.h"
+#include <gfx/camera.h>
 #include <glm/gtc/type_ptr.hpp>
 #include <glm/gtx/transform.hpp>
 #include <glm/matrix.hpp>
@@ -56,7 +56,7 @@ constexpr auto shadowBands
 		= []<GlobalDistance... ints>(const float scaleFactor, std::integer_sequence<GlobalDistance, ints...>) {
 			  const auto base = 10'000'000 / pow(scaleFactor, sizeof...(ints) - 1);
 			  return std::array {1, static_cast<GlobalDistance>((base * pow(scaleFactor, ints)))...};
-		  }(6.6F, std::make_integer_sequence<GlobalDistance, ShadowMapper::SHADOW_BANDS>());
+		  }(4.6F, std::make_integer_sequence<GlobalDistance, ShadowMapper::SHADOW_BANDS>());
 
 static_assert(shadowBands.front() == 1);
 static_assert(shadowBands.back() == 10'000'000);
@@ -88,7 +88,7 @@ ShadowMapper::update(const SceneProvider & scene, const LightDirection & dir, co
 
 	shadowStenciller.setLightDirection(dir);
 	for (const auto & [id, asset] : gameState->assets) {
-		if (const auto r = std::dynamic_pointer_cast<const Renderable>(asset)) {
+		if (const auto r = asset.getAs<const Renderable>()) {
 			r->updateStencil(shadowStenciller);
 		}
 	}
@@ -102,30 +102,30 @@ ShadowMapper::update(const SceneProvider & scene, const LightDirection & dir, co
 	const auto bandViewExtents = getBandViewExtents(camera, lightViewDir);
 	Definitions out;
 	Sizes sizes;
-	std::transform(bandViewExtents.begin(), std::prev(bandViewExtents.end()), std::next(bandViewExtents.begin()),
-			std::back_inserter(out),
-			[bands = bandViewExtents.size() - 2, &lightViewDir, &sizes](const auto & near, const auto & far) mutable {
-				const auto extents_minmax
-						= [extents = std::span {near.begin(), far.end()}](auto && comp, RelativeDistance extra) {
-							  const auto mm = std::minmax_element(extents.begin(), extents.end(), comp);
-							  return std::make_pair(comp.get(*mm.first) - extra, comp.get(*mm.second) + extra);
-						  };
-				const std::array extents = {extents_minmax(CompareBy {0}, 0), extents_minmax(CompareBy {1}, 0),
-						extents_minmax(CompareBy {2}, 10'000)};
-
-				const auto lightProjection = [](const auto & x, const auto & y, const auto & z) {
-					return glm::ortho(x.first, x.second, y.first, y.second, -z.second, -z.first);
-				}(extents[0], extents[1], extents[2]);
-
-				sizes.emplace_back(extents[0].second - extents[0].first, extents[1].second - extents[1].first,
-						extents[2].second - extents[2].first);
+	using ExtentsBoundingBox = AxisAlignedBoundingBox<RelativeDistance>;
+	std::ranges::transform(bandViewExtents | std::views::pairwise, std::back_inserter(out),
+			[&lightViewDir, &sizes](const auto & band) mutable {
+				const auto & [near, far] = band;
+				auto extents = ExtentsBoundingBox::fromPoints(std::span {near.begin(), far.end()});
+				extents.min.z -= 10'000.F;
+				extents.max.z += 10'000.F;
+				const auto lightProjection = glm::ortho(
+						extents.min.x, extents.max.x, extents.min.y, extents.max.y, -extents.max.z, -extents.min.z);
+				sizes.emplace_back(extents.max - extents.min);
 				return lightProjection * lightViewDir;
 			});
 	for (const auto p : std::initializer_list<const ShadowProgram *> {
 				 &landmess, &dynamicPoint, &dynamicPointInst, &dynamicPointInstWithTextures, &stencilShadowProgram}) {
 		p->setView(out, sizes, lightViewPoint);
 	}
-	scene.shadows(*this);
+	ExtentsBoundingBox extents {lightViewPoint, lightViewPoint};
+	for (const auto & point : bandViewExtents.back()) {
+		extents += point;
+	}
+	const auto lightProjection
+			= glm::ortho(extents.min.x, extents.max.x, extents.min.y, extents.max.y, -extents.max.z, -extents.min.z);
+	Frustum frustum {lightViewPoint, lightViewDir, lightProjection};
+	scene.shadows(*this, frustum);
 
 	glCullFace(GL_BACK);
 
diff --git a/gfx/gl/uiShader.cpp b/gfx/gl/uiShader.cpp
deleted file mode 100644
index 23da9dc..0000000
--- a/gfx/gl/uiShader.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "uiShader.h"
-#include "gl_traits.h"
-#include <gfx/gl/program.h>
-#include <gfx/gl/shader.h>
-#include <gfx/gl/shaders/fs-uiShader.h>
-#include <gfx/gl/shaders/fs-uiShaderFont.h>
-#include <gfx/gl/shaders/vs-uiShader.h>
-#include <glm/glm.hpp>
-#include <glm/gtc/type_ptr.hpp>
-
-UIShader::IconProgram::IconProgram(const glm::mat4 & vp) : UIProgram {vp, uiShader_vs, uiShader_fs} { }
-
-UIShader::TextProgram::TextProgram(const glm::mat4 & vp) : UIProgram {vp, uiShader_vs, uiShaderFont_fs} { }
-
-UIShader::UIShader(size_t width, size_t height) :
-	UIShader {glm::ortho<float>(0, static_cast<float>(width), 0, static_cast<float>(height))}
-{
-}
-
-UIShader::UIShader(const glm::mat4 & viewProjection) : icon {viewProjection}, text {viewProjection} { }
-
-void
-UIShader::TextProgram::use(const RGB & colour) const
-{
-	Program::use();
-	glUniform(colorLoc, colour);
-}
diff --git a/gfx/gl/uiShader.h b/gfx/gl/uiShader.h
deleted file mode 100644
index 6d00166..0000000
--- a/gfx/gl/uiShader.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#pragma once
-
-#include "config/types.h"
-#include "gl_traits.h"
-#include "program.h"
-#include <cstddef>
-#include <glad/gl.h>
-#include <glm/glm.hpp>
-#include <glm/gtc/type_ptr.hpp>
-
-class UIShader {
-public:
-	UIShader(std::size_t width, std::size_t height);
-
-private:
-	explicit UIShader(const glm::mat4 & viewProjection);
-
-	class UIProgram : public Program {
-	public:
-		template<typename... S>
-		explicit UIProgram(const glm::mat4 & vp, S &&... srcs) : Program {std::forward<S>(srcs)...}
-		{
-			const RequiredUniformLocation uiProjectionLoc {*this, "uiProjection"};
-			glUseProgram(*this);
-			glUniform(uiProjectionLoc, vp);
-		}
-	};
-
-	class IconProgram : public UIProgram {
-	public:
-		explicit IconProgram(const glm::mat4 & vp);
-		using Program::use;
-	};
-
-	class TextProgram : public UIProgram {
-	public:
-		explicit TextProgram(const glm::mat4 & vp);
-		void use(const RGB & colour) const;
-
-	private:
-		RequiredUniformLocation colorLoc {*this, "colour"};
-	};
-
-public:
-	IconProgram icon;
-	TextProgram text;
-};
diff --git a/gfx/renderable.cpp b/gfx/renderable.cpp
index 3594968..27f2459 100644
--- a/gfx/renderable.cpp
+++ b/gfx/renderable.cpp
@@ -6,7 +6,7 @@ Renderable::lights(const SceneShader &) const
 }
 
 void
-Renderable::shadows(const ShadowMapper &) const
+Renderable::shadows(const ShadowMapper &, const Frustum &) const
 {
 }
 
diff --git a/gfx/renderable.h b/gfx/renderable.h
index 83522e3..140c570 100644
--- a/gfx/renderable.h
+++ b/gfx/renderable.h
@@ -3,6 +3,7 @@
 #include <special_members.h>
 
 class SceneShader;
+class Frustum;
 class ShadowMapper;
 class ShadowStenciller;
 
@@ -12,9 +13,9 @@ public:
 	virtual ~Renderable() = default;
 	DEFAULT_MOVE_COPY(Renderable);
 
-	virtual void render(const SceneShader & shader) const = 0;
+	virtual void render(const SceneShader & shader, const Frustum &) const = 0;
 	virtual void lights(const SceneShader & shader) const;
-	virtual void shadows(const ShadowMapper & shadowMapper) const;
+	virtual void shadows(const ShadowMapper & shadowMapper, const Frustum &) const;
 
 	virtual void updateStencil(const ShadowStenciller & lightDir) const;
 };