diff --git a/Source/Client/Mode/GameMode.cpp b/Source/Client/Mode/GameMode.cpp
index c1aa8cda..b8960584 100644
--- a/Source/Client/Mode/GameMode.cpp
+++ b/Source/Client/Mode/GameMode.cpp
@@ -4246,7 +4246,6 @@ void __stdcall SendMacroUserInfoPacket(std::uint16_t first, std::uint16_t second
 // OFFSET: 0x00CE0210
 // FUNCTION: fn_21329
 int CGameMode::ProcessGroundClick(int result) {
-  const RenderProjection projection = g_renderer->viewport.Projection();
   const auto drawCell = [](GroundGeometry* ground, const float* matrix, int column, int row, std::uint32_t color) {
     void** groundVtable = *reinterpret_cast<void***>(ground);
     reinterpret_cast<void(__thiscall*)(GroundGeometry*, const float*, int, int, std::uint32_t)>(groundVtable[14])(ground, matrix, column, row, color);
@@ -4258,7 +4257,7 @@ int CGameMode::ProcessGroundClick(int result) {
     if (macroFields[0x10C] == 1 && *reinterpret_cast<const int*>(macroFields + 0xEC) == 1) {
       int column = -1;
       int row = -1;
-      PickScreenTerrain(projection, g_screenWidth, g_screenHeight, this->camera->frame.eye, this->camera->frame.inverse.values, this->scene->spatial, column, row);
+      PickScreenTerrain(g_screenWidth, g_screenHeight, this->camera->frame.eye, this->camera->frame.inverse.values, this->scene->spatial, column, row);
       const int radius = *reinterpret_cast<const int*>(macroFields + 0xF4);
       for (int dx = -radius; dx <= radius; ++dx) {
         for (int dy = -radius; dy <= radius; ++dy) {
@@ -4284,7 +4283,7 @@ int CGameMode::ProcessGroundClick(int result) {
       shopSuspended = true;
       int column = -1;
       int row = -1;
-      PickScreenTerrain(projection, g_screenWidth, g_screenHeight, this->camera->frame.eye, this->camera->frame.inverse.values, this->scene->spatial, column, row);
+      PickScreenTerrain(g_screenWidth, g_screenHeight, this->camera->frame.eye, this->camera->frame.inverse.values, this->scene->spatial, column, row);
       drawCell(this->scene->ground, this->camera->frame.view.values, column, row, 0x66FF0000);
       if (g_mouse.buttons[0] == 1) {
         shop->SetSuspended(0);
@@ -4307,7 +4306,7 @@ int CGameMode::ProcessGroundClick(int result) {
 
   int column = -1;
   int row = -1;
-  if (!PickScreenTerrain(projection, g_screenWidth, g_screenHeight, this->camera->frame.eye, this->camera->frame.inverse.values, this->scene->spatial, column, row)) {
+  if (!PickScreenTerrain(g_screenWidth, g_screenHeight, this->camera->frame.eye, this->camera->frame.inverse.values, this->scene->spatial, column, row)) {
     return result;
   }
 
@@ -4651,7 +4650,7 @@ void CGameMode::ProcessInput() {
 
   if (this->scene && this->scene->player && g_renderer) {
     MarkScreenWorldOcclusion(
-      g_renderer->viewport.Projection(), this->scene->player->render.screenX, this->scene->player->render.screenY, g_renderer->viewport.uiScaleY, this->camera->frame.eye,
+      this->scene->player->render.screenX, this->scene->player->render.screenY, g_renderer->viewport.uiScaleY, this->camera->frame.eye,
       this->camera->frame.inverse.values, this->scene->player->render.position.y, this->camera->camera.distance, this->scene->spatial, *this->scene->ground,
       this->unknown_0458 != 0
     );
@@ -4689,7 +4688,7 @@ void CGameMode::ProcessInput() {
       int column = -1;
       int row = -1;
       PickScreenTerrain(
-        g_renderer->viewport.Projection(), g_mouse.x, g_mouse.y, this->camera->frame.eye, this->camera->frame.inverse.values, this->scene->spatial,
+        g_mouse.x, g_mouse.y, this->camera->frame.eye, this->camera->frame.inverse.values, this->scene->spatial,
         column, row
       );
       const TerrainHeightCell* cell = this->scene->terrain->CellAt(column, row);
diff --git a/Source/Contents/Actors/GraffiSkill.cpp b/Source/Contents/Actors/GraffiSkill.cpp
index f8584f80..6cc750d6 100644
--- a/Source/Contents/Actors/GraffiSkill.cpp
+++ b/Source/Contents/Actors/GraffiSkill.cpp
@@ -6,7 +6,6 @@
 #include "Contents/Ground/GroundGeometry.h"
 #include "Contents/World/World.h"
 #include "Render/Primitives/RenderQueues.h"
-#include "Render/Projection/RenderProjection.h"
 #include "Render/Renderer.h"
 #include "Render/TextureQuad.h"
 #include "Render/Textures/Texture.h"
diff --git a/Source/Contents/Actors/GroundScope.cpp b/Source/Contents/Actors/GroundScope.cpp
index b1ed9c33..06cf7ae7 100644
--- a/Source/Contents/Actors/GroundScope.cpp
+++ b/Source/Contents/Actors/GroundScope.cpp
@@ -7,7 +7,6 @@
 #include "Contents/Skills/SkillInfo.h"
 #include "Contents/World/World.h"
 #include "Render/Primitives/RenderQueues.h"
-#include "Render/Projection/RenderProjection.h"
 #include "Render/Renderer.h"
 #include "Render/TextureQuad.h"
 #include "Render/Textures/TextureCache.h"
diff --git a/Source/Contents/Actors/Player.cpp b/Source/Contents/Actors/Player.cpp
index cb578128..108238a2 100644
--- a/Source/Contents/Actors/Player.cpp
+++ b/Source/Contents/Actors/Player.cpp
@@ -1890,7 +1890,7 @@ void CGrannyPc::RenderCached(const matrix& view, int layer, C3dGrannyModelRes* m
           position.z = corner.y * values[5] + corner.x * values[2] + corner.z * values[8] + values[11];
         }
 
-        g_renderer->viewport.Projection().Project(&position.x, world.values, output);
+        g_renderer->viewport.Project(&position.x, world.values, output);
       }
     }
 
@@ -4158,7 +4158,7 @@ void CGrannyPc::RenderModel(
           position.z = transform.values[5] * point.y + transform.values[2] * point.x + transform.values[8] * point.z + transform.values[11];
         }
 
-        g_renderer->viewport.Projection().Project(&position.x, world.values, output);
+        g_renderer->viewport.Project(&position.x, world.values, output);
         output.u = vertex.uv[0];
         output.v = vertex.uv[1];
         const float shade = lightY * vertex.normal[1] + lightX * vertex.normal[0] + lightZ * vertex.normal[2];
diff --git a/Source/Contents/Actors/RenderObject.cpp b/Source/Contents/Actors/RenderObject.cpp
index e57772e7..95a9325f 100644
--- a/Source/Contents/Actors/RenderObject.cpp
+++ b/Source/Contents/Actors/RenderObject.cpp
@@ -3897,7 +3897,7 @@ void CGrannyCorpse3d::Render(int argument) {
         position.x = vertex.position[0];
         position.y = vertex.position[1];
         position.z = vertex.position[2];
-        g_renderer->viewport.Projection().Project(&position.x, world.values, output);
+        g_renderer->viewport.Project(&position.x, world.values, output);
         output.u = vertex.uv[0];
         output.v = vertex.uv[1];
         const float shade = lightX * vertex.normal[0] + lightY * vertex.normal[1] + lightZ * vertex.normal[2];
@@ -4086,7 +4086,7 @@ void C3dGrannyGameActor::RenderLit(int argument, const GrannyActorLight& light)
         position.x = vertex.position[0];
         position.y = vertex.position[1];
         position.z = vertex.position[2];
-        g_renderer->viewport.Projection().Project(&position.x, world.values, output);
+        g_renderer->viewport.Project(&position.x, world.values, output);
         output.u = vertex.uv[0];
         output.v = vertex.uv[1];
         const float shade = lightX * vertex.normal[0] + lightY * vertex.normal[1] + lightZ * vertex.normal[2];
@@ -4189,7 +4189,7 @@ void C3dGrannyGameActor::RenderShadowed(int argument) {
         position.x = vertex.position[0];
         position.y = vertex.position[1];
         position.z = vertex.position[2];
-        g_renderer->viewport.Projection().Project(&position.x, world.values, output);
+        g_renderer->viewport.Project(&position.x, world.values, output);
         output.u = vertex.uv[0];
         output.v = vertex.uv[1];
         const float shade = light.y * vertex.normal[1] + light.x * vertex.normal[0] + light.z * vertex.normal[2];
diff --git a/Source/Contents/Effects/Bash.cpp b/Source/Contents/Effects/Bash.cpp
index 1a6bc5cf..07199df0 100644
--- a/Source/Contents/Effects/Bash.cpp
+++ b/Source/Contents/Effects/Bash.cpp
@@ -7,7 +7,6 @@
 #include "Contents/Effects/EffectMemoryMgr.h"
 #include "Contents/Effects/Particle.h"
 #include "Render/Primitives/RenderPrimitive.h"
-#include "Render/Projection/RenderProjection.h"
 #include "Render/Renderer.h"
 #include "Render/TextureQuad.h"
 #include "Utility/Math/AffineMatrix.h"
@@ -45,7 +44,7 @@ void CBash::Slot01() {
   screen.specular = 0xFF000000;
   screen.u = 0.0f;
   screen.v = 0.0f;
-  g_renderer->viewport.Projection().Project(this->position, mode->camera->frame.view.values, screen);
+  g_renderer->viewport.Project(this->position, mode->camera->frame.view.values, screen);
   this->screenX = screen.x;
   this->screenY = screen.y - 40.0f;
 
diff --git a/Source/Contents/Effects/EffectPrimitiveMotion.cpp b/Source/Contents/Effects/EffectPrimitiveMotion.cpp
index 4fdd427a..957d042e 100644
--- a/Source/Contents/Effects/EffectPrimitiveMotion.cpp
+++ b/Source/Contents/Effects/EffectPrimitiveMotion.cpp
@@ -22,7 +22,6 @@
 #include "Utility/Math/ScalarConversion.h"
 #include "Render/Renderer.h"
 #include "Render/Primitives/RenderPrimitive.h"
-#include "Render/Projection/RenderProjection.h"
 
 #include <bit>
 #include <cmath>
@@ -4667,7 +4666,7 @@ RenderVertex TransformVert(const matrix& view, const vector3d& position) {
   vertex.specular = 0xFF000000;
   vertex.u = 0.0f;
   vertex.v = 0.0f;
-  g_renderer->viewport.Projection().Project(&position.x, view.values, vertex);
+  g_renderer->viewport.Project(&position.x, view.values, vertex);
   return vertex;
 }
 
diff --git a/Source/Contents/Effects/EffectPrimitiveRendering.cpp b/Source/Contents/Effects/EffectPrimitiveRendering.cpp
index d3b569a9..4a0cb24b 100644
--- a/Source/Contents/Effects/EffectPrimitiveRendering.cpp
+++ b/Source/Contents/Effects/EffectPrimitiveRendering.cpp
@@ -2,7 +2,6 @@
 #include "Contents/Configuration/ServiceOptions.h"
 #include "Contents/Effects/EffectPrimitiveState.h"
 #include "Contents/Actors/RenderObjectState.h"
-#include "Render/Projection/RenderProjection.h"
 #include "Render/Primitives/RenderQueues.h"
 #include "Contents/Effects/EffectPrim.h"
 #include "Contents/Effects/EffectPrimitiveMotion.h"
@@ -87,7 +86,7 @@ void CEffectPrim::DrawEffectPrimitive15(matrix& wtm) {
       const vector3d& corner = corners[indices[triangleIndex][vertexIndex]];
       const float position[3] = {corner.x + this->render.position.x, corner.y + this->render.position.y, corner.z + this->render.position.z};
       RenderVertex projected{0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-      g_renderer->viewport.Projection().Project(position, wtm.values, projected);
+      g_renderer->viewport.Project(position, wtm.values, projected);
       RenderVertex& vertex = triangle.vertices[vertexIndex];
       vertex = projected;
       vertex.diffuse = this->state.argb;
@@ -689,10 +688,10 @@ void CEffectPrim::Render(int argument) {
     case 20: {
       float position[3] = {this->render.position.x, this->render.position.y, this->render.position.z};
       RenderVertex top{0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-      g_renderer->viewport.Projection().Project(position, wtm.values, top);
+      g_renderer->viewport.Project(position, wtm.values, top);
       position[1] -= 10.0f;
       RenderVertex bottom{0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-      g_renderer->viewport.Projection().Project(position, wtm.values, bottom);
+      g_renderer->viewport.Project(position, wtm.values, bottom);
       RenderTriangle& triangle = this->state.triangles[0];
       triangle.vertices[0].x = top.x;
       triangle.vertices[2].x = bottom.x;
@@ -4911,22 +4910,21 @@ void CEffectPrim::RenderRecordQuads(matrix& wtm) {
 
   for (int index = 0; index < this->state.numSegment; ++index) {
     const EffectPrimitiveRecord& record = this->state.records[index];
-    const RenderProjection projection = g_renderer->viewport.Projection();
     RenderVertex projected{0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
 
-    projection.Project(&record.corners[0].x, wtm.values, projected);
+    g_renderer->viewport.Project(&record.corners[0].x, wtm.values, projected);
     triangle->vertices[0] = projected;
     triangle->vertices[0].diffuse = record.color;
     projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
     triangle->vertices[0].u = 0.0f;
     triangle->vertices[0].v = 1.0f;
-    projection.Project(&record.corners[1].x, wtm.values, projected);
+    g_renderer->viewport.Project(&record.corners[1].x, wtm.values, projected);
     triangle->vertices[1] = projected;
     triangle->vertices[1].diffuse = record.color;
     projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
     triangle->vertices[1].u = 1.0f;
     triangle->vertices[1].v = 1.0f;
-    projection.Project(&record.corners[2].x, wtm.values, projected);
+    g_renderer->viewport.Project(&record.corners[2].x, wtm.values, projected);
     triangle->vertices[2] = projected;
     triangle->vertices[2].diffuse = record.color;
     triangle->vertices[2].u = 0.0f;
@@ -4937,19 +4935,19 @@ void CEffectPrim::RenderRecordQuads(matrix& wtm) {
     }
 
     projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-    projection.Project(&record.corners[3].x, wtm.values, projected);
+    g_renderer->viewport.Project(&record.corners[3].x, wtm.values, projected);
     triangle->vertices[0] = projected;
     triangle->vertices[0].diffuse = record.color;
     projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
     triangle->vertices[0].u = 1.0f;
     triangle->vertices[0].v = 0.0f;
-    projection.Project(&record.corners[2].x, wtm.values, projected);
+    g_renderer->viewport.Project(&record.corners[2].x, wtm.values, projected);
     triangle->vertices[1] = projected;
     triangle->vertices[1].diffuse = record.color;
     projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
     triangle->vertices[1].u = 0.0f;
     triangle->vertices[1].v = 0.0f;
-    projection.Project(&record.corners[1].x, wtm.values, projected);
+    g_renderer->viewport.Project(&record.corners[1].x, wtm.values, projected);
     triangle->vertices[2] = projected;
     triangle->vertices[2].diffuse = record.color;
     triangle->vertices[2].u = 1.0f;
@@ -4992,23 +4990,22 @@ void CEffectPrim::RenderRecordRings(matrix& wtm) {
         world[corner][2] = x * tm[2] + y * tm[5] + tm[8] * 0.0f + tm[11] + record.position.z;
       }
 
-      const RenderProjection projection = g_renderer->viewport.Projection();
       const float uNext = uInc + 0.25f;
       RenderVertex projected{0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
 
-      projection.Project(world[0], wtm.values, projected);
+      g_renderer->viewport.Project(world[0], wtm.values, projected);
       triangle->vertices[0] = projected;
       triangle->vertices[0].diffuse = record.color;
       triangle->vertices[0].u = uInc;
       triangle->vertices[0].v = 1.0f;
       projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-      projection.Project(world[1], wtm.values, projected);
+      g_renderer->viewport.Project(world[1], wtm.values, projected);
       triangle->vertices[1] = projected;
       triangle->vertices[1].diffuse = record.color;
       triangle->vertices[1].u = uNext;
       triangle->vertices[1].v = 1.0f;
       projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-      projection.Project(world[2], wtm.values, projected);
+      g_renderer->viewport.Project(world[2], wtm.values, projected);
       triangle->vertices[2] = projected;
       triangle->vertices[2].diffuse = record.color;
       triangle->vertices[2].u = uInc;
@@ -5021,19 +5018,19 @@ void CEffectPrim::RenderRecordRings(matrix& wtm) {
       }
 
       projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-      projection.Project(world[3], wtm.values, projected);
+      g_renderer->viewport.Project(world[3], wtm.values, projected);
       triangle->vertices[0] = projected;
       triangle->vertices[0].diffuse = record.color;
       triangle->vertices[0].u = uNext;
       triangle->vertices[0].v = 0.0f;
       projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-      projection.Project(world[2], wtm.values, projected);
+      g_renderer->viewport.Project(world[2], wtm.values, projected);
       triangle->vertices[1] = projected;
       triangle->vertices[1].diffuse = record.color;
       triangle->vertices[1].u = uInc;
       triangle->vertices[1].v = 0.0f;
       projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-      projection.Project(world[1], wtm.values, projected);
+      g_renderer->viewport.Project(world[1], wtm.values, projected);
       triangle->vertices[2] = projected;
       triangle->vertices[2].diffuse = record.color;
       triangle->vertices[2].u = uNext;
@@ -5163,23 +5160,22 @@ void CEffectPrim::RenderArcBand(matrix& wtm) {
       world[corner][2] = x * tm[2] + y * tm[5] + z * tm[8] + tm[11] + position.z;
     }
 
-    const RenderProjection projection = g_renderer->viewport.Projection();
     const float uNext = uInc + 0.25f;
     RenderVertex projected{0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
 
-    projection.Project(world[0], wtm.values, projected);
+    g_renderer->viewport.Project(world[0], wtm.values, projected);
     triangle->vertices[0] = projected;
     triangle->vertices[0].diffuse = this->state.argb;
     triangle->vertices[0].u = uInc;
     triangle->vertices[0].v = 1.0f;
     projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-    projection.Project(world[1], wtm.values, projected);
+    g_renderer->viewport.Project(world[1], wtm.values, projected);
     triangle->vertices[2] = projected;
     triangle->vertices[2].diffuse = this->state.argb;
     triangle->vertices[2].u = uNext;
     triangle->vertices[2].v = 1.0f;
     projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-    projection.Project(world[2], wtm.values, projected);
+    g_renderer->viewport.Project(world[2], wtm.values, projected);
     triangle->vertices[1] = projected;
     triangle->vertices[1].diffuse = this->state.argb;
     triangle->vertices[1].u = uInc;
@@ -5190,19 +5186,19 @@ void CEffectPrim::RenderArcBand(matrix& wtm) {
     }
 
     projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-    projection.Project(world[3], wtm.values, projected);
+    g_renderer->viewport.Project(world[3], wtm.values, projected);
     triangle->vertices[2] = projected;
     triangle->vertices[2].diffuse = this->state.argb;
     triangle->vertices[2].u = uNext;
     triangle->vertices[2].v = 0.0f;
     projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-    projection.Project(world[2], wtm.values, projected);
+    g_renderer->viewport.Project(world[2], wtm.values, projected);
     triangle->vertices[1] = projected;
     triangle->vertices[1].diffuse = this->state.argb;
     triangle->vertices[1].u = uInc;
     triangle->vertices[1].v = 0.0f;
     projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-    projection.Project(world[1], wtm.values, projected);
+    g_renderer->viewport.Project(world[1], wtm.values, projected);
     triangle->vertices[0] = projected;
     triangle->vertices[0].diffuse = this->state.argb;
     triangle->vertices[0].u = uNext;
@@ -5250,24 +5246,23 @@ void CEffectPrim::RenderPyramid(matrix& wtm) {
       };
     }
 
-    const RenderProjection projection = g_renderer->viewport.Projection();
     RenderVertex projected{0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
     const float point0[3] = {corners[face][0].x + this->render.position.x, this->render.position.y + corners[face][0].y, this->render.position.z + corners[face][0].z};
-    projection.Project(point0, wtm.values, projected);
+    g_renderer->viewport.Project(point0, wtm.values, projected);
     triangle->vertices[0] = projected;
     triangle->vertices[0].diffuse = this->state.argb;
     triangle->vertices[0].u = uInc;
     triangle->vertices[0].v = 1.0f;
     const float point1[3] = {corners[face][1].x + this->render.position.x, corners[face][1].y + this->render.position.y, this->render.position.z + corners[face][1].z};
     projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-    projection.Project(point1, wtm.values, projected);
+    g_renderer->viewport.Project(point1, wtm.values, projected);
     triangle->vertices[1] = projected;
     triangle->vertices[1].diffuse = this->state.argb;
     triangle->vertices[1].u = uInc;
     triangle->vertices[1].v = 0.0f;
     const float point2[3] = {corners[face][2].x + this->render.position.x, corners[face][2].y + this->render.position.y, this->render.position.z + corners[face][2].z};
     projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-    projection.Project(point2, wtm.values, projected);
+    g_renderer->viewport.Project(point2, wtm.values, projected);
     triangle->vertices[2] = projected;
     triangle->vertices[2].diffuse = this->state.argb;
     uInc += 0.2f;
@@ -5310,21 +5305,20 @@ void CEffectPrim::RenderCrossPlanes(matrix& wtm) {
       world[corner][2] = local.x * tm[2] + local.y * tm[5] + local.z * tm[8] + tm[11] + position.z;
     }
 
-    const RenderProjection projection = g_renderer->viewport.Projection();
     RenderVertex projected{0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-    projection.Project(world[0], wtm.values, projected);
+    g_renderer->viewport.Project(world[0], wtm.values, projected);
     triangle->vertices[0] = projected;
     triangle->vertices[0].diffuse = this->state.argb;
     triangle->vertices[0].u = 0.0f;
     triangle->vertices[0].v = 1.0f;
     projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-    projection.Project(world[1], wtm.values, projected);
+    g_renderer->viewport.Project(world[1], wtm.values, projected);
     triangle->vertices[1] = projected;
     triangle->vertices[1].diffuse = this->state.argb;
     triangle->vertices[1].u = 1.0f;
     triangle->vertices[1].v = 1.0f;
     projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-    projection.Project(world[2], wtm.values, projected);
+    g_renderer->viewport.Project(world[2], wtm.values, projected);
     triangle->vertices[2] = projected;
     triangle->vertices[2].diffuse = this->state.argb;
     triangle->vertices[2].u = 0.0f;
@@ -5335,19 +5329,19 @@ void CEffectPrim::RenderCrossPlanes(matrix& wtm) {
     }
 
     projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-    projection.Project(world[3], wtm.values, projected);
+    g_renderer->viewport.Project(world[3], wtm.values, projected);
     triangle->vertices[0] = projected;
     triangle->vertices[0].diffuse = this->state.argb;
     triangle->vertices[0].u = 1.0f;
     triangle->vertices[0].v = 0.0f;
     projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-    projection.Project(world[2], wtm.values, projected);
+    g_renderer->viewport.Project(world[2], wtm.values, projected);
     triangle->vertices[1] = projected;
     triangle->vertices[1].diffuse = this->state.argb;
     triangle->vertices[1].u = 0.0f;
     triangle->vertices[1].v = 0.0f;
     projected = {0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-    projection.Project(world[1], wtm.values, projected);
+    g_renderer->viewport.Project(world[1], wtm.values, projected);
     triangle->vertices[2] = projected;
     triangle->vertices[2].diffuse = this->state.argb;
     triangle->vertices[2].u = 1.0f;
@@ -6483,7 +6477,7 @@ void CEffectPrim::RenderSphere(matrix& wtm) {
 
         for (int index = 0; index < 3; ++index) {
           RenderVertex projected{0, 0, 0, 0, 0, 0xFF000000u, 0, 0};
-          g_renderer->viewport.Projection().Project(&corners[half][index]->x, wtm.values, projected);
+          g_renderer->viewport.Project(&corners[half][index]->x, wtm.values, projected);
           triangle.vertices[index] = projected;
           triangle.vertices[index].diffuse = this->state.argb;
           triangle.vertices[index].u = us[half][index];
diff --git a/Source/Contents/Effects/NyanggrassEffect.cpp b/Source/Contents/Effects/NyanggrassEffect.cpp
index 758b95a0..20040212 100644
--- a/Source/Contents/Effects/NyanggrassEffect.cpp
+++ b/Source/Contents/Effects/NyanggrassEffect.cpp
@@ -109,7 +109,7 @@ void CMultiTexParticle::Render(int column, int row) {
 
   for (int i = 0; i < 4; ++i) {
     LightmappedVertex& vertex = this->command.vertices[i];
-    reinterpret_cast<const RenderProjection*>(g_renderer)->Project(corners[i], cameraMatrix, vertex);
+    g_renderer->viewport.Project(corners[i], cameraMatrix, vertex);
     vertex.z -= 0.000030517578125f;
     vertex.diffuse = 0xFFFFFFFF;
     vertex.u = this->uv1[i][0] + this->offsetU;
diff --git a/Source/Contents/Effects/Particle.cpp b/Source/Contents/Effects/Particle.cpp
index 6fea6409..3dd54135 100644
--- a/Source/Contents/Effects/Particle.cpp
+++ b/Source/Contents/Effects/Particle.cpp
@@ -8,7 +8,6 @@
 #include "Contents/Jobs/JobInheritance.h"
 #include "Contents/World/World.h"
 #include "Render/Primitives/RenderPrimitive.h"
-#include "Render/Projection/RenderProjection.h"
 #include "Render/Projection/RendererViewport.h"
 #include "Render/Renderer.h"
 #include "Render/TextureQuad.h"
@@ -417,7 +416,7 @@ bool CEZ2STRParticle::Process(float x, float y, float z) {
 void CEZ2STRParticle::UpdatePosition(float x, float y, float z) {
   CGameMode* mode = static_cast<CGameMode*>(g_modeMgr.GetGameMode());
   RenderVertex screen = {0, 0, 0, 0, 0, 0xFF000000, 0, 0};
-  g_renderer->viewport.Projection().Project(&this->position.x, mode->camera->frame.view.values, screen);
+  g_renderer->viewport.Project(&this->position.x, mode->camera->frame.view.values, screen);
   this->m_screen.x = screen.x + x;
   this->m_screen.y = screen.y + y;
   this->m_screen.z = screen.z + z;
@@ -499,7 +498,7 @@ void CEZ2STRParticle::RenderBillboard(EZeffectClip* clip, EZeffectTransform* tra
   combined.Compose(world, view);
   for (int i = 0; i < 4; ++i) {
     vector3d point = {vertices[i].x, vertices[i].y, vertices[i].z};
-    g_renderer->viewport.Projection().Project(&point.x, combined.values, vertices[i]);
+    g_renderer->viewport.Project(&point.x, combined.values, vertices[i]);
     vertices[i].rhw = this->depthOffset + vertices[i].rhw;
     vertices[i].z = RhwToDepth(vertices[i].rhw);
     vertices[i].u = scaleU * vertices[i].u;
@@ -669,7 +668,7 @@ void CEZ2STRParticle::RenderGround(EZeffectClip* clip, EZeffectTransform* transf
     }
     this->m_groundHeight = point.y;
 
-    g_renderer->viewport.Projection().Project(&point.x, view.values, vertices[i]);
+    g_renderer->viewport.Project(&point.x, view.values, vertices[i]);
     vertices[i].rhw = this->depthOffset + vertices[i].rhw;
     vertices[i].z = RhwToDepth(vertices[i].rhw);
     vertices[i].u = scaleU * vertices[i].u;
@@ -873,7 +872,7 @@ void CParticle::Render(bool billboard, float top, float bottom, float left, floa
   world.Compose(*local, view);
   for (int i = 0; i < 4; ++i) {
     vector3d point = {output[i].x, output[i].y, output[i].z};
-    g_renderer->viewport.Projection().Project(&point.x, world.values, output[i]);
+    g_renderer->viewport.Project(&point.x, world.values, output[i]);
     const float rhw = this->depthOffset + output[i].rhw;
     output[i].rhw = rhw;
     if (0.0f > rhw) {
diff --git a/Source/Contents/Effects/RagEffect.cpp b/Source/Contents/Effects/RagEffect.cpp
index e3492fd7..7fea7a1b 100644
--- a/Source/Contents/Effects/RagEffect.cpp
+++ b/Source/Contents/Effects/RagEffect.cpp
@@ -15,7 +15,6 @@
 #include "Contents/World/World.h"
 #include "Render/Primitives/RenderPrimitive.h"
 #include "Render/Renderer.h"
-#include "Render/Projection/RenderProjection.h"
 #include "Contents/Actors/GroundScope.h"
 #include "Render/Textures/TextureCache.h"
 #include "Resource/ResourceMgr.h"
@@ -156,7 +155,7 @@ int g_statusIconIds[100];
 // FUNCTION: fn_20039
 void CRagEffect::Endure() {
   RenderVertex screen{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
-  g_renderer->viewport.Projection().Project(
+  g_renderer->viewport.Project(
     &this->state.parent->render.position.x, static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values, screen
   );
   this->state.tlvertX = screen.x;
@@ -576,7 +575,7 @@ void CRagEffect::IceWall() {
 // FUNCTION: fn_20072
 void CRagEffect::IncAgiDex() {
   RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
-  g_renderer->viewport.Projection().Project(
+  g_renderer->viewport.Project(
     &this->state.parent->render.position.x, static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values, vertex
   );
   this->state.tlvertX = vertex.x;
@@ -634,7 +633,7 @@ void CRagEffect::IncAgiDex() {
 // FUNCTION: fn_20073
 void CRagEffect::IncAgility() {
   RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
-  g_renderer->viewport.Projection().Project(
+  g_renderer->viewport.Project(
     &this->state.parent->render.position.x, static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values, vertex
   );
   this->state.tlvertX = vertex.x;
@@ -786,7 +785,7 @@ void CRagEffect::Hit1() {
 // FUNCTION: fn_20064
 void CRagEffect::Hit2(int option) {
   RenderVertex screen{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
-  g_renderer->viewport.Projection().Project(
+  g_renderer->viewport.Project(
     &this->state.parent->render.position.x, static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values, screen
   );
   this->state.tlvertX = screen.x;
@@ -921,9 +920,9 @@ void CRagEffect::Hit3() {
 
 // OFFSET: 0x00C19980
 // FUNCTION: fn_20066
-void CRagEffect::Hit4(const RenderProjection& projection) {
+void CRagEffect::Hit4() {
   RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
-  projection.Project(&this->state.parent->render.position.x, static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values, vertex);
+  g_renderer->viewport.Project(&this->state.parent->render.position.x, static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values, vertex);
   this->state.tlvertX = vertex.x;
   this->state.tlvertY = vertex.y;
 
@@ -2160,7 +2159,7 @@ void CRagEffect::SetStateDuration(int duration) {
 // FUNCTION: fn_20103
 bool CRagEffect::Signum() {
   RenderVertex screen{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
-  g_renderer->viewport.Projection().Project(
+  g_renderer->viewport.Project(
     &this->state.parent->render.position.x, static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values, screen
   );
   this->state.tlvertX = screen.x;
@@ -7249,7 +7248,7 @@ void CRagEffect::TexturedSpreadFlat(const char* name, char kind) {
 void CRagEffect::RisingSparkles(char colorMode) {
   RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
   const float* view = static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values;
-  g_renderer->viewport.Projection().Project(&this->state.parent->render.position.x, view, vertex);
+  g_renderer->viewport.Project(&this->state.parent->render.position.x, view, vertex);
   this->state.tlvertX = vertex.x;
   this->state.tlvertY = vertex.y;
   const RenderObjectState& parent = this->state.parent->render;
@@ -7703,7 +7702,7 @@ void CRagEffect::MonsterSpriteBurst(char kind) {
 bool CRagEffect::AgilityChange(char increase, const std::string& textureName) {
   RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
   const float* view = static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values;
-  g_renderer->viewport.Projection().Project(&this->state.parent->render.position.x, view, vertex);
+  g_renderer->viewport.Project(&this->state.parent->render.position.x, view, vertex);
   this->state.tlvertX = vertex.x;
   this->state.tlvertY = vertex.y;
   const RenderObjectState& parent = this->state.parent->render;
@@ -8170,7 +8169,7 @@ void CRagEffect::AssassinCloakingClear() {
 void CRagEffect::TintedRisingSparkles(char) {
   RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
   const float* view = static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values;
-  g_renderer->viewport.Projection().Project(&this->state.parent->render.position.x, view, vertex);
+  g_renderer->viewport.Project(&this->state.parent->render.position.x, view, vertex);
   this->state.tlvertX = vertex.x;
   this->state.tlvertY = vertex.y;
   const RenderObjectState& parent = this->state.parent->render;
@@ -9501,7 +9500,7 @@ void CRagEffect::ColdHit() {
   }
 
   RenderVertex screen{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
-  g_renderer->viewport.Projection().Project(
+  g_renderer->viewport.Project(
     &this->state.parent->render.position.x, static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values, screen
   );
   this->state.tlvertX = screen.x;
@@ -9578,7 +9577,7 @@ void CRagEffect::TurnUndead() {
   }
 
   RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
-  g_renderer->viewport.Projection().Project(
+  g_renderer->viewport.Project(
     &this->state.parent->render.position.x, static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values, vertex
   );
   this->state.tlvertX = vertex.x;
@@ -10193,7 +10192,7 @@ void CRagEffect::SpawnActorHallucination() {
 // FUNCTION: fn_20085
 void CRagEffect::NapalmFragments() {
   RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
-  g_renderer->viewport.Projection().Project(
+  g_renderer->viewport.Project(
     &this->state.parent->render.position.x, static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values, vertex
   );
   this->state.tlvertX = vertex.x;
@@ -10622,7 +10621,7 @@ void CRagEffect::StoneCurseRing() {
 
   RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
   const float* view = static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values;
-  g_renderer->viewport.Projection().Project(&this->state.parent->render.position.x, view, vertex);
+  g_renderer->viewport.Project(&this->state.parent->render.position.x, view, vertex);
   this->state.tlvertX = vertex.x;
   this->state.tlvertY = vertex.y;
 
@@ -11512,7 +11511,7 @@ void CRagEffect::EarthSpike(char type) {
 void CRagEffect::Sightrasher() {
   RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
   const float* view = static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values;
-  g_renderer->viewport.Projection().Project(&this->state.parent->render.position.x, view, vertex);
+  g_renderer->viewport.Project(&this->state.parent->render.position.x, view, vertex);
   this->state.tlvertX = vertex.x;
   this->state.tlvertY = vertex.y;
 
@@ -12810,7 +12809,7 @@ void CRagEffect::Flasher() {
   }
 
   RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
-  g_renderer->viewport.Projection().Project(
+  g_renderer->viewport.Project(
     &this->state.parent->render.position.x,
     static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values,
     vertex
@@ -13098,7 +13097,7 @@ void CRagEffect::HasteUp() {
   }
 
   RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
-  g_renderer->viewport.Projection().Project(
+  g_renderer->viewport.Project(
     &this->state.parent->render.position.x, static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values, vertex
   );
   this->state.tlvertX = vertex.x;
@@ -13265,7 +13264,7 @@ void CRagEffect::RedParticleSpray(int count) {
 // FUNCTION: fn_20067
 void CRagEffect::Hit5() {
   RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
-  g_renderer->viewport.Projection().Project(
+  g_renderer->viewport.Project(
     &this->state.parent->render.position.x, static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values, vertex
   );
   this->state.tlvertX = vertex.x;
@@ -13304,7 +13303,7 @@ void CRagEffect::Hit5() {
 // FUNCTION: fn_20068
 void CRagEffect::Hit6() {
   RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
-  g_renderer->viewport.Projection().Project(
+  g_renderer->viewport.Project(
     &this->state.parent->render.position.x, static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values, vertex
   );
   this->state.tlvertX = vertex.x;
@@ -15056,7 +15055,7 @@ void CRagEffect::RenderAniClip(EZeffectClip* clip, const EZeffectTransform* tran
 void CRagEffect::SandScatter() {
   RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
   const float* view = static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values;
-  g_renderer->viewport.Projection().Project(&this->state.parent->render.position.x, view, vertex);
+  g_renderer->viewport.Project(&this->state.parent->render.position.x, view, vertex);
   this->state.tlvertX = vertex.x;
   this->state.tlvertY = vertex.y;
 
@@ -15211,7 +15210,7 @@ void CRagEffect::Sight() {
   this->render.position.z = parent.position.z;
   RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
   const float* view = static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values;
-  g_renderer->viewport.Projection().Project(&this->state.parent->render.position.x, view, vertex);
+  g_renderer->viewport.Project(&this->state.parent->render.position.x, view, vertex);
   this->state.tlvertX = vertex.x;
   this->state.tlvertY = vertex.y;
 
@@ -15258,7 +15257,7 @@ void CRagEffect::Sight() {
 void CRagEffect::AlphaCenterRise() {
   RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
   const float* view = static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values;
-  g_renderer->viewport.Projection().Project(&this->state.parent->render.position.x, view, vertex);
+  g_renderer->viewport.Project(&this->state.parent->render.position.x, view, vertex);
   this->state.tlvertX = vertex.x;
   this->state.tlvertY = vertex.y;
 
@@ -15474,7 +15473,7 @@ bool CRagEffect::StormGust() {
 // FUNCTION: fn_20031
 void CRagEffect::DecAgility() {
   RenderVertex screen{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
-  g_renderer->viewport.Projection().Project(
+  g_renderer->viewport.Project(
     &this->state.parent->render.position.x, static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values, screen
   );
   this->state.tlvertX = screen.x;
@@ -16769,7 +16768,7 @@ void CRagEffect::TexturedMagicRing(const char* name, char kind) {
 void CRagEffect::IncAgilityCenter(char kind) {
   RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
   const float* view = static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values;
-  g_renderer->viewport.Projection().Project(&this->state.parent->render.position.x, view, vertex);
+  g_renderer->viewport.Project(&this->state.parent->render.position.x, view, vertex);
   this->state.tlvertX = vertex.x;
   this->state.tlvertY = vertex.y;
   const RenderObjectState& parent = this->state.parent->render;
@@ -23285,7 +23284,7 @@ bool CRagEffect::OnProcess() {
       this->Hit3();
       break;
     case 3:
-      this->Hit4(g_renderer->viewport.Projection());
+      this->Hit4();
       break;
     case 4:
       this->Hit5();
@@ -23576,7 +23575,7 @@ bool CRagEffect::OnProcess() {
     {
       RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
       const float* view = static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values;
-      g_renderer->viewport.Projection().Project(&this->state.parent->render.position.x, view, vertex);
+      g_renderer->viewport.Project(&this->state.parent->render.position.x, view, vertex);
       this->state.tlvertX = vertex.x;
       this->state.tlvertY = vertex.y;
       const int roll = rand() % 360;
@@ -24129,7 +24128,7 @@ bool CRagEffect::OnProcess() {
     {
       RenderVertex vertex{0.0f, 0.0f, 0.0f, 0.0f, 0u, 0xFF000000u, 0.0f, 0.0f};
       const float* view = static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values;
-      g_renderer->viewport.Projection().Project(&this->state.parent->render.position.x, view, vertex);
+      g_renderer->viewport.Project(&this->state.parent->render.position.x, view, vertex);
       this->state.tlvertX = vertex.x;
       this->state.tlvertY = vertex.y;
       if (this->state.stateCnt == 0) {
diff --git a/Source/Contents/Effects/RagEffect.h b/Source/Contents/Effects/RagEffect.h
index 03e21f15..fd6df4cb 100644
--- a/Source/Contents/Effects/RagEffect.h
+++ b/Source/Contents/Effects/RagEffect.h
@@ -11,7 +11,6 @@
 
 struct EffectActor;
 class TextureCache;
-struct RenderProjection;
 struct matrix;
 
 struct CRagEffect : CRenderObject {
@@ -61,7 +60,7 @@ struct CRagEffect : CRenderObject {
   void TexturedClassChange(char kind);
   void FrostDiver(char type);
   void GrimTooth();
-  void Hit4(const RenderProjection& projection);
+  void Hit4();
   void IceWall();
   void IncAgiDex();
   void IncAgility();
diff --git a/Source/Contents/Effects/SpriteParticle.cpp b/Source/Contents/Effects/SpriteParticle.cpp
index 8c7c98a6..fc7c2688 100644
--- a/Source/Contents/Effects/SpriteParticle.cpp
+++ b/Source/Contents/Effects/SpriteParticle.cpp
@@ -219,7 +219,7 @@ void CSpriteParticle::sub_B40F30(char mode) {
       worldVertices[v].x = finalTransform.values[0] * vx + finalTransform.values[3] * vy + finalTransform.values[6] * vz + finalTransform.values[9];
       worldVertices[v].y = finalTransform.values[1] * vx + finalTransform.values[4] * vy + finalTransform.values[7] * vz + finalTransform.values[10];
       worldVertices[v].z = finalTransform.values[2] * vx + finalTransform.values[5] * vy + finalTransform.values[8] * vz + finalTransform.values[11];
-      g_renderer->viewport.Projection().Project(&worldVertices[v].x, gameMode->camera->frame.view.values, primitive->vertices[v]);
+      g_renderer->viewport.Project(&worldVertices[v].x, gameMode->camera->frame.view.values, primitive->vertices[v]);
     }
 
     if (CRenderObject* renderObject = FindRenderObject(this->unknown_02F4)) {
diff --git a/Source/Contents/Ground/GroundDecals.cpp b/Source/Contents/Ground/GroundDecals.cpp
index 0bb17187..74b3bd89 100644
--- a/Source/Contents/Ground/GroundDecals.cpp
+++ b/Source/Contents/Ground/GroundDecals.cpp
@@ -1,7 +1,6 @@
 #include "Contents/Ground/GroundGeometry.h"
 #include "Contents/Ground/GroundRendering.h"
 #include "Render/Primitives/RenderPrimitivePool.h"
-#include "Render/Projection/RenderProjection.h"
 #include "Render/Primitives/RenderQueues.h"
 #include "Render/Renderer.h"
 #include "Render/TextureQuad.h"
@@ -63,7 +62,7 @@ namespace {
     RenderPrimitive* primitive = g_renderer->primitives.Acquire();
 
     for (unsigned corner = 0; corner < 4; ++corner) {
-      g_renderer->viewport.Projection().Project(vertices[corner], matrix, primitive->vertices[corner]);
+      g_renderer->viewport.Project(vertices[corner], matrix, primitive->vertices[corner]);
       primitive->vertices[corner].z = primitive->vertices[corner].z - bias;
     }
 
@@ -155,7 +154,7 @@ void GroundGeometry::DrawTerrainOverlay(
   RenderPrimitive* primitive = g_renderer->primitives.Acquire();
 
   for (unsigned corner = 0; corner < 4; ++corner) {
-    g_renderer->viewport.Projection().Project(vertices[corner], matrix, primitive->vertices[corner]);
+    g_renderer->viewport.Project(vertices[corner], matrix, primitive->vertices[corner]);
     primitive->vertices[corner].u = static_cast<float>(corner & 1);
     primitive->vertices[corner].v = static_cast<float>(corner >> 1);
     primitive->vertices[corner].diffuse = color;
diff --git a/Source/Contents/Ground/GroundLighting.cpp b/Source/Contents/Ground/GroundLighting.cpp
index de33f455..4fc699ab 100644
--- a/Source/Contents/Ground/GroundLighting.cpp
+++ b/Source/Contents/Ground/GroundLighting.cpp
@@ -2,9 +2,9 @@
 #include "Contents/Ground/GroundRendering.h"
 #include "Contents/Configuration/ServiceOptions.h"
 #include "Contents/Effects/EffectPrim.h"
+#include "Contents/MapSkyMgr.h"
 #include "Render/Primitives/LightmappedPrimitive.h"
 #include "Render/Primitives/RenderPrimitivePool.h"
-#include "Render/Projection/RenderProjection.h"
 #include "Render/Primitives/RenderQueues.h"
 #include "Render/Renderer.h"
 #include "Render/TextureQuad.h"
@@ -14,20 +14,17 @@
 #include <bit>
 #include <cstring>
 
-// GLOBAL: gl_24589
-float g_groundColorScale[3];
-
 // OFFSET: 0x00AC1D30
 // FUNCTION: fn_17592
 void GroundGeometry::DrawLightmapped(const float* matrix, const GroundQuad& quad, bool clip) {
   RenderVertex vertices[4]{};
   float lightUV[4][2];
   float scales[3];
-  std::memcpy(scales, g_groundColorScale, sizeof(scales));
+  std::memcpy(scales, g_weatherEffect.lightColor, sizeof(scales));
 
   for (unsigned corner = 0; corner < 4; ++corner) {
     vertices[corner].specular = 0xFF000000u;
-    g_renderer->viewport.Projection().Project(quad.vertices[corner], matrix, vertices[corner]);
+    g_renderer->viewport.Project(quad.vertices[corner], matrix, vertices[corner]);
   }
 
   if (clip && !GroundQuadVisible(vertices)) {
diff --git a/Source/Contents/Ground/GroundRendering.cpp b/Source/Contents/Ground/GroundRendering.cpp
index d5073881..1f523a42 100644
--- a/Source/Contents/Ground/GroundRendering.cpp
+++ b/Source/Contents/Ground/GroundRendering.cpp
@@ -1,7 +1,6 @@
 #include "Contents/Ground/GroundGeometry.h"
 #include "Contents/Ground/GroundRendering.h"
 #include "Render/Primitives/RenderPrimitivePool.h"
-#include "Render/Projection/RenderProjection.h"
 #include "Render/Primitives/RenderQueues.h"
 #include "Render/Renderer.h"
 #include "Render/TextureQuad.h"
@@ -67,7 +66,7 @@ namespace {
 
     for (unsigned corner = 0; corner < 4; ++corner) {
       vertices[corner].specular = 0xFF000000u;
-      g_renderer->viewport.Projection().Project(quad.vertices[corner], matrix, vertices[corner]);
+      g_renderer->viewport.Project(quad.vertices[corner], matrix, vertices[corner]);
     }
 
     if (clip && !GroundQuadVisible(vertices)) {
diff --git a/Source/Contents/Ground/GroundWaterRendering.cpp b/Source/Contents/Ground/GroundWaterRendering.cpp
index d157174e..cc0c59e4 100644
--- a/Source/Contents/Ground/GroundWaterRendering.cpp
+++ b/Source/Contents/Ground/GroundWaterRendering.cpp
@@ -1,7 +1,6 @@
 #include "Contents/Ground/GroundGeometry.h"
 #include "Contents/Ground/GroundRendering.h"
 #include "Render/Primitives/RenderPrimitivePool.h"
-#include "Render/Projection/RenderProjection.h"
 #include "Render/Primitives/RenderQueues.h"
 #include "Contents/Effects/EffectPrim.h"
 #include "Render/Renderer.h"
@@ -64,7 +63,7 @@ void GroundGeometry::DrawWaterCell(
 
   for (unsigned corner = 0; corner < 4; ++corner) {
     vertices[corner].specular = 0xFF000000u;
-    g_renderer->viewport.Projection().Project(cell.corners[corner], matrix, vertices[corner]);
+    g_renderer->viewport.Project(cell.corners[corner], matrix, vertices[corner]);
   }
 
   const float firstArea = (vertices[2].x - vertices[0].x) * (vertices[1].y - vertices[0].y);
diff --git a/Source/Contents/Models/ModelActor.cpp b/Source/Contents/Models/ModelActor.cpp
index 2e0dd0cf..462f5769 100644
--- a/Source/Contents/Models/ModelActor.cpp
+++ b/Source/Contents/Models/ModelActor.cpp
@@ -256,12 +256,12 @@ void C3dActor::Update() {
 
 // OFFSET: 0x00AB7B40
 // FUNCTION: fn_17495
-void C3dActor::Draw(const float*, bool, ModelRenderContext&) {
+void C3dActor::Draw(const float*, bool) {
 }
 
 // OFFSET: 0x00AB7B50
 // FUNCTION: fn_17496
-void C3dActorV1::Draw(const float* matrix, bool clip, ModelRenderContext& context) {
+void C3dActorV1::Draw(const float* matrix, bool clip) {
   if (this->dirty == 1) {
     this->UpdateMatrix();
   }
@@ -270,7 +270,7 @@ void C3dActorV1::Draw(const float* matrix, bool clip, ModelRenderContext& contex
   std::memcpy(camera.values, matrix, sizeof(camera.values));
   struct matrix combined;
   combined.Compose(this->transform, camera);
-  this->root->Draw(combined.values, this->Reversed(), clip, this->commandMode, context);
+  this->root->Draw(combined.values, this->Reversed(), clip, this->commandMode);
 
   if (this->occlusionEnabled == 1) {
     this->Fade();
@@ -279,7 +279,7 @@ void C3dActorV1::Draw(const float* matrix, bool clip, ModelRenderContext& contex
 
 // OFFSET: 0x00AB7C40
 // FUNCTION: fn_17497
-void C3dActorV2::Draw(const float* matrix, bool clip, ModelRenderContext& context) {
+void C3dActorV2::Draw(const float* matrix, bool clip) {
   if (this->dirty == 1) {
     this->UpdateMatrix();
   }
@@ -291,7 +291,7 @@ void C3dActorV2::Draw(const float* matrix, bool clip, ModelRenderContext& contex
   const bool reversed = this->Reversed();
 
   for (C3dNodeV2* root : this->roots) {
-    root->Draw(combined.values, reversed, clip, this->commandMode, context);
+    root->Draw(combined.values, reversed, clip, this->commandMode);
 
     if (this->occlusionEnabled == 1) {
       this->Fade();
diff --git a/Source/Contents/Models/ModelActor.h b/Source/Contents/Models/ModelActor.h
index 0df53b0c..aa9a6230 100644
--- a/Source/Contents/Models/ModelActor.h
+++ b/Source/Contents/Models/ModelActor.h
@@ -17,7 +17,7 @@ public:
   virtual void Prepare(const float* direction, const float* diffuse, const float* ambient);
   virtual void Animate(double frame);
   virtual void Update();
-  virtual void Draw(const float* matrix, bool clip, ModelRenderContext& context);
+  virtual void Draw(const float* matrix, bool clip);
   virtual C3dNode* Find(const char* name);
   virtual void MarkOccluded(const float* ray);
   virtual void SetSpeed(float speed);
@@ -63,7 +63,7 @@ public:
   void Prepare(const float* direction, const float* diffuse, const float* ambient) override;
   void Animate(double frame) override;
   void Update() override;
-  void Draw(const float* matrix, bool clip, ModelRenderContext& context) override;
+  void Draw(const float* matrix, bool clip) override;
   C3dNode* Find(const char* name) override;
 
   /* 0170 */ C3dNodeV1* root;
@@ -82,7 +82,7 @@ public:
   void Prepare(const float* direction, const float* diffuse, const float* ambient) override;
   void Animate(double frame) override;
   void Update() override;
-  void Draw(const float* matrix, bool clip, ModelRenderContext& context) override;
+  void Draw(const float* matrix, bool clip) override;
   C3dNode* Find(const char* name) override;
   void SetSpeed(float speed) override;
 
diff --git a/Source/Contents/Models/ModelNode.cpp b/Source/Contents/Models/ModelNode.cpp
index 37b7b891..774d0635 100644
--- a/Source/Contents/Models/ModelNode.cpp
+++ b/Source/Contents/Models/ModelNode.cpp
@@ -42,7 +42,7 @@ void C3dNode::Animate(double) {
 
 // OFFSET: 0x00AB7D30
 // FUNCTION: fn_17498
-void C3dNode::Draw(const float*, unsigned char, bool, unsigned char, ModelRenderContext&) {
+void C3dNode::Draw(const float*, unsigned char, bool, unsigned char) {
 }
 
 // OFFSET: 0x00AB7050
diff --git a/Source/Contents/Models/ModelNode.h b/Source/Contents/Models/ModelNode.h
index 865c609b..326219d2 100644
--- a/Source/Contents/Models/ModelNode.h
+++ b/Source/Contents/Models/ModelNode.h
@@ -23,7 +23,7 @@ public:
 
   virtual void Initialize(const ModelNode& resource);
   virtual void Animate(double frame);
-  virtual void Draw(const float* matrix, unsigned char reversed, bool clip, unsigned char commandMode, ModelRenderContext& context);
+  virtual void Draw(const float* matrix, unsigned char reversed, bool clip, unsigned char commandMode);
   C3dNode* Find(const char* name);
   void OverrideColors();
   void Prepare(const float* matrix, const float* direction, const float* diffuse, const float* ambient, int shade);
@@ -49,7 +49,7 @@ public:
   ~C3dNodeV1() override;
   void Initialize(const ModelNode& resource) override;
   void Animate(double frame) override;
-  void Draw(const float* matrix, unsigned char reversed, bool clip, unsigned char commandMode, ModelRenderContext& context) override;
+  void Draw(const float* matrix, unsigned char reversed, bool clip, unsigned char commandMode) override;
 
   /* 008C */ std::vector<ModelScaleKey> scaleKeys;
   /* 0098 */ std::vector<ModelRotationKey> rotationKeys;
@@ -62,7 +62,7 @@ public:
   ~C3dNodeV2() override;
   void Initialize(const ModelNode& resource) override;
   void Animate(double frame) override;
-  void Draw(const float* matrix, unsigned char reversed, bool clip, unsigned char commandMode, ModelRenderContext& context) override;
+  void Draw(const float* matrix, unsigned char reversed, bool clip, unsigned char commandMode) override;
 
   /* 008C */ matrix resourceTransform;
   /* 00BC */ matrix localTransform;
diff --git a/Source/Contents/Models/ModelRendering.cpp b/Source/Contents/Models/ModelRendering.cpp
index dd38265d..97181026 100644
--- a/Source/Contents/Models/ModelRendering.cpp
+++ b/Source/Contents/Models/ModelRendering.cpp
@@ -2,38 +2,24 @@
 #include "Contents/Models/ModelNode.h"
 #include "Contents/Models/ModelRendering.h"
 #include "Render/Primitives/RenderCommandPool.h"
-#include "Render/Projection/RenderProjection.h"
 #include "Render/Primitives/RenderQueues.h"
 #include "Render/Primitives/RenderVertexPool.h"
+#include "Contents/Effects/EffectPrim.h"
+#include "Contents/MapSkyMgr.h"
+#include "Render/Renderer.h"
+#include "Render/TextureQuad.h"
+#include "Resource/World/WorldResource.h"
 #include "Render/Textures/Texture.h"
 
 #include "Utility/Math/ScalarConversion.h"
 #include <cstring>
 
 // INLINED
-ModelRenderContext::ModelRenderContext(
-  const RenderProjection& projection, RenderCommandPool& commands, RenderVertexPool& vertices, RenderQueues& queues, const int& width, const int& height,
-  const bool& depthAlpha, const float& depthStart, const float& depthEnd, const bool& overrideColor, const bool& integerColor, const float* overrideScale,
-  const float* colorScale
-)
-    : projection(projection), commands(commands), vertices(vertices), queues(queues), width(width), height(height), depthAlpha(depthAlpha),
-      depthStart(depthStart), depthEnd(depthEnd), overrideColor(overrideColor), integerColor(integerColor), overrideScale(overrideScale),
-      colorScale(colorScale) {
-  for (auto& vertex : this->legacyProjected) {
-    vertex.specular = 0xFF000000u;
-  }
-
-  for (auto& vertex : this->modernProjected) {
-    vertex.specular = 0xFF000000u;
-  }
-}
-
-// INLINED
-bool ModelTriangleVisible(const RenderVertex* a, const RenderVertex* b, const RenderVertex* c, const ModelRenderContext& context) {
+bool ModelTriangleVisible(const RenderVertex* a, const RenderVertex* b, const RenderVertex* c) {
   const float firstMinimumX = a->x > b->x ? b->x : a->x;
   const float minimumX = firstMinimumX > c->x ? c->x : firstMinimumX;
 
-  if (minimumX >= static_cast<float>(context.width)) {
+  if (minimumX >= static_cast<float>(g_renderer->viewport.width)) {
     return false;
   }
 
@@ -47,7 +33,7 @@ bool ModelTriangleVisible(const RenderVertex* a, const RenderVertex* b, const Re
   const float firstMinimumY = a->y > b->y ? b->y : a->y;
   const float minimumY = firstMinimumY > c->y ? c->y : firstMinimumY;
 
-  if (minimumY >= static_cast<float>(context.height)) {
+  if (minimumY >= static_cast<float>(g_renderer->viewport.height)) {
     return false;
   }
 
@@ -58,6 +44,12 @@ bool ModelTriangleVisible(const RenderVertex* a, const RenderVertex* b, const Re
 }
 
 namespace {
+  struct ProjectedVertex : RenderVertex {
+    // INLINED
+    ProjectedVertex() : RenderVertex{0, 0, 0, 0, 0, 0xFF000000u, 0, 0} {
+    }
+  };
+
   // INLINED
   unsigned Byte(float value) {
     return static_cast<unsigned>(TruncateToInt(value)) & 255u;
@@ -97,21 +89,22 @@ inline void TransformModelUV(float& u, float& v, const ModelTextureTransform& tr
 }
 
 // INLINED
-void DrawModelNode(C3dNode& node, const float* matrix, unsigned char reversed, bool clip, unsigned char commandMode, ModelRenderContext& context, bool modern) {
+void DrawModelNode(C3dNode& node, const float* matrix, unsigned char reversed, bool clip, unsigned char commandMode, RenderVertex* projected, bool modern) {
   struct matrix camera;
   std::memcpy(camera.values, matrix, sizeof(camera.values));
   struct matrix combined;
   combined.Compose(node.transform, camera);
-  const float overrideScale[3] = {context.overrideScale[0], context.overrideScale[1], context.overrideScale[2]};
-  const float colorScale[3] = {context.colorScale[0], context.colorScale[1], context.colorScale[2]};
+  float overrideScale[3];
+  std::memcpy(overrideScale, g_worldLighting.ambient, sizeof(overrideScale));
+  float colorScale[3];
+  std::memcpy(colorScale, g_weatherEffect.lightColor, sizeof(colorScale));
   const unsigned char alpha = node.model->alpha;
-  auto& projected = modern ? context.modernProjected : context.legacyProjected;
 
   for (int index = 0; index < node.mesh->vertexCount; ++index) {
-    context.projection.Project(node.mesh->vertices[index].data(), combined.values, projected[index]);
+    g_renderer->viewport.Project(node.mesh->vertices[index].data(), combined.values, projected[index]);
   }
 
-  RenderVertex* output = context.vertices.Acquire(static_cast<unsigned>(node.mesh->faceCount) * 3u);
+  RenderVertex* output = g_renderer->vertices.Acquire(static_cast<unsigned>(node.mesh->faceCount) * 3u);
   int index = 0;
 
   while (index < node.mesh->faceCount) {
@@ -125,7 +118,7 @@ void DrawModelNode(C3dNode& node, const float* matrix, unsigned char reversed, b
       const RenderVertex& a = projected[face.vertices[0]];
       const RenderVertex& b = projected[face.vertices[1]];
       const RenderVertex& c = projected[face.vertices[2]];
-      bool visible = !clip || ModelTriangleVisible(&a, &b, &c, context);
+      bool visible = !clip || ModelTriangleVisible(&a, &b, &c);
       const float left = (b.y - a.y) * (c.x - a.x);
       const float right = (c.y - a.y) * (b.x - a.x);
       const bool winding = modern ? right > left : left > right;
@@ -157,11 +150,11 @@ void DrawModelNode(C3dNode& node, const float* matrix, unsigned char reversed, b
         }
 
         for (unsigned corner = 0; corner < 3; ++corner) {
-          if (context.overrideColor) {
+          if (g_overrideColor) {
             output[corner].diffuse = Color(state.colors[corner], alpha, overrideScale);
           } else if (node.unknown_0088) {
             output[corner].diffuse = (state.colors[corner] & 0x00FFFFFFu) | 0x80000000u;
-          } else if (context.integerColor) {
+          } else if (g_weatherEffect.unknown_0001) {
             const int* values = node.faceValues.data() + index * 9u + corner * 3u;
             output[corner].diffuse = (static_cast<unsigned>(alpha) << 24) | (Byte(static_cast<float>(values[0]) * colorScale[0]) << 16) |
                                      (Byte(static_cast<float>(values[1]) * colorScale[1]) << 8) | Byte(static_cast<float>(values[2]) * colorScale[2]);
@@ -177,7 +170,7 @@ void DrawModelNode(C3dNode& node, const float* matrix, unsigned char reversed, b
     } while (index < node.mesh->faceCount && node.mesh->faces[index].texture == texture);
 
     if (output != first) {
-      RenderCommand* command = context.commands.Acquire();
+      RenderCommand* command = g_renderer->commands.Acquire();
       command->vertices = first;
       command->vertexCount = static_cast<unsigned>(output - first);
       command->texture = node.textures[texture % node.textures.size()];
@@ -187,25 +180,29 @@ void DrawModelNode(C3dNode& node, const float* matrix, unsigned char reversed, b
         flags |= 1;
       }
 
-      context.queues.Submit(command, flags, context.depthAlpha, context.depthStart, context.depthEnd);
+      g_renderer->queues.Submit(command, flags, g_renderer->fog.supported != 0, g_depthStart, g_depthEnd);
     }
   }
 
   node.unknown_0088 = 0;
 
   for (C3dNode* child : node.children) {
-    child->Draw(combined.values, reversed, clip, commandMode, context);
+    child->Draw(combined.values, reversed, clip, commandMode);
   }
 }
 
 // OFFSET: 0x00AB7D40
 // FUNCTION: fn_17499
-void C3dNodeV1::Draw(const float* matrix, unsigned char reversed, bool clip, unsigned char commandMode, ModelRenderContext& context) {
-  DrawModelNode(*this, matrix, reversed, clip, commandMode, context, false);
+void C3dNodeV1::Draw(const float* matrix, unsigned char reversed, bool clip, unsigned char commandMode) {
+  // GLOBAL: gl_24586
+  static ProjectedVertex projected[30000];
+  DrawModelNode(*this, matrix, reversed, clip, commandMode, projected, false);
 }
 
 // OFFSET: 0x00AB84B0
 // FUNCTION: fn_17500
-void C3dNodeV2::Draw(const float* matrix, unsigned char reversed, bool clip, unsigned char commandMode, ModelRenderContext& context) {
-  DrawModelNode(*this, matrix, reversed, clip, commandMode, context, true);
+void C3dNodeV2::Draw(const float* matrix, unsigned char reversed, bool clip, unsigned char commandMode) {
+  // GLOBAL: gl_24587
+  static ProjectedVertex projected[30000];
+  DrawModelNode(*this, matrix, reversed, clip, commandMode, projected, true);
 }
diff --git a/Source/Contents/Models/ModelRendering.h b/Source/Contents/Models/ModelRendering.h
index ca475cb9..7d2368b6 100644
--- a/Source/Contents/Models/ModelRendering.h
+++ b/Source/Contents/Models/ModelRendering.h
@@ -3,12 +3,6 @@
 
 #include "Render/Primitives/RenderPrimitive.h"
 
-#include <array>
-
-struct RenderProjection;
-struct RenderQueues;
-class RenderCommandPool;
-class RenderVertexPool;
 class C3dNode;
 struct ModelTextureTransform;
 
@@ -17,34 +11,9 @@ struct ModelFaceState {
   /* 000C */ float uv[3][2];
 };
 
-struct ModelRenderContext {
-  const RenderProjection& projection;
-  RenderCommandPool& commands;
-  RenderVertexPool& vertices;
-  RenderQueues& queues;
-  const int& width;
-  const int& height;
-  const bool& depthAlpha;
-  const float& depthStart;
-  const float& depthEnd;
-  const bool& overrideColor;
-  const bool& integerColor;
-  const float* overrideScale;
-  const float* colorScale;
-
-  std::array<RenderVertex, 30000> legacyProjected{};
-  std::array<RenderVertex, 30000> modernProjected{};
-
-  ModelRenderContext(
-    const RenderProjection& projection, RenderCommandPool& commands, RenderVertexPool& vertices, RenderQueues& queues, const int& width, const int& height,
-    const bool& depthAlpha, const float& depthStart, const float& depthEnd, const bool& overrideColor, const bool& integerColor, const float* overrideScale,
-    const float* colorScale
-  );
-};
-
-bool ModelTriangleVisible(const RenderVertex* a, const RenderVertex* b, const RenderVertex* c, const ModelRenderContext& context);
+bool ModelTriangleVisible(const RenderVertex* a, const RenderVertex* b, const RenderVertex* c);
 void TransformModelUV(float& u, float& v, const ModelTextureTransform& transform);
-void DrawModelNode(C3dNode& node, const float* matrix, unsigned char reversed, bool clip, unsigned char commandMode, ModelRenderContext& context, bool modern);
+void DrawModelNode(C3dNode& node, const float* matrix, unsigned char reversed, bool clip, unsigned char commandMode, RenderVertex* projected, bool modern);
 
 static_assert(sizeof(ModelFaceState) == 36);
 
diff --git a/Source/Contents/NavigationRoute.cpp b/Source/Contents/NavigationRoute.cpp
index 5904302c..4ced1bfc 100644
--- a/Source/Contents/NavigationRoute.cpp
+++ b/Source/Contents/NavigationRoute.cpp
@@ -31,7 +31,6 @@
 #include "Contents/Ground/GroundGeometry.h"
 #include "Contents/World/World.h"
 #include "Render/Primitives/RenderQueues.h"
-#include "Render/Projection/RenderProjection.h"
 #include "Render/Renderer.h"
 #include "Render/TextureQuad.h"
 
diff --git a/Source/Contents/World/SkyBox.cpp b/Source/Contents/World/SkyBox.cpp
index 476f6471..82313387 100644
--- a/Source/Contents/World/SkyBox.cpp
+++ b/Source/Contents/World/SkyBox.cpp
@@ -175,7 +175,7 @@ void CLensFlare::Render(const float* matrix, vector3d eye, vector3d target) {
     if (dot < 0.0f) {
       RenderPrimitive* primitive = g_renderer->primitives.Acquire();
       RenderVertex* vertices = primitive->vertices;
-      g_renderer->viewport.Projection().Project(&element.position.x, matrix, vertices[0]);
+      g_renderer->viewport.Project(&element.position.x, matrix, vertices[0]);
       vertices[3] = vertices[0];
       vertices[2] = vertices[0];
       vertices[1] = vertices[0];
diff --git a/Source/Contents/World/WorldModelView.cpp b/Source/Contents/World/WorldModelView.cpp
index 50d7d411..8fb4f230 100644
--- a/Source/Contents/World/WorldModelView.cpp
+++ b/Source/Contents/World/WorldModelView.cpp
@@ -133,7 +133,7 @@ int ClassifyModelView(const OrientedBounds& bounds, const ModelViewPlanes& plane
 // INLINED
 void DrawWorldModelLeaves(
   std::list<WorldSpatialTree*>& clipped, std::list<WorldSpatialTree*>& inside, const ModelViewPlanes& planes, const float* matrix, unsigned frame, int updates,
-  GroundGeometry& ground, ModelRenderContext& models, int* visibleRectangle
+  GroundGeometry& ground, int* visibleRectangle
 ) {
   visibleRectangle[0] = visibleRectangle[1] = 999;
   visibleRectangle[2] = visibleRectangle[3] = 0;
@@ -151,7 +151,7 @@ void DrawWorldModelLeaves(
       }
 
       if (visibility == 1 || visibility == 2) {
-        model->Draw(matrix, visibility == 2, models);
+        model->Draw(matrix, visibility == 2);
       }
 
       model->renderFrame = frame;
@@ -168,7 +168,7 @@ void DrawWorldModelLeaves(
       }
 
       if (model->renderFrame != frame) {
-        model->Draw(matrix, false, models);
+        model->Draw(matrix, false);
         model->renderFrame = frame;
       }
     }
diff --git a/Source/Contents/World/WorldModelView.h b/Source/Contents/World/WorldModelView.h
index 79fc2700..beafea3b 100644
--- a/Source/Contents/World/WorldModelView.h
+++ b/Source/Contents/World/WorldModelView.h
@@ -6,7 +6,6 @@
 
 struct OrientedBounds;
 struct WorldSpatialTree;
-struct ModelRenderContext;
 class GroundGeometry;
 
 struct ModelViewPlanes {
@@ -46,7 +45,7 @@ int ClassifyModelView(const OrientedBounds& bounds, const ModelViewPlanes& plane
 
 void DrawWorldModelLeaves(
   std::list<WorldSpatialTree*>& clipped, std::list<WorldSpatialTree*>& inside, const ModelViewPlanes& planes, const float* matrix, unsigned frame, int updates,
-  GroundGeometry& ground, ModelRenderContext& models, int* visibleRectangle
+  GroundGeometry& ground, int* visibleRectangle
 );
 
 extern int g_groundOverlayA;
diff --git a/Source/Contents/World/WorldOcclusion.cpp b/Source/Contents/World/WorldOcclusion.cpp
index af2cf46b..5218ba46 100644
--- a/Source/Contents/World/WorldOcclusion.cpp
+++ b/Source/Contents/World/WorldOcclusion.cpp
@@ -3,7 +3,7 @@
 #include "Contents/World/WorldOcclusion.h"
 #include "Contents/World/WorldRayQuery.h"
 #include "Contents/World/WorldSpatialTree.h"
-#include "Render/Projection/RenderProjection.h"
+#include "Render/Renderer.h"
 
 #include "Utility/Math/ScalarConversion.h"
 #include <cstring>
@@ -43,13 +43,13 @@ void MarkWorldOcclusionRay(const float* ray, float actorLimit, float groundLimit
 // OFFSET: 0x00CD5AD0
 // FUNCTION: fn_21286
 void MarkScreenWorldOcclusion(
-  const RenderProjection& projection, int screenX, int screenY, float rendererScale, const float* origin, const float* cameraMatrix, float playerHeight,
+  int screenX, int screenY, float rendererScale, const float* origin, const float* cameraMatrix, float playerHeight,
   float cameraHeight, WorldSpatialTree& root, GroundGeometry& ground, bool markGround
 ) {
   const float shifted = static_cast<float>(screenY) - rendererScale * 23.0f;
   const int y = TruncateToInt(shifted);
   float ray[6]{};
-  projection.Ray(screenX, y, origin, cameraMatrix, ray);
+  g_renderer->viewport.Ray(screenX, y, origin, cameraMatrix, ray);
   const float limit = (playerHeight + cameraHeight) - 16.0f;
   MarkWorldOcclusionRay(ray, limit, limit, root, ground, markGround);
 }
diff --git a/Source/Contents/World/WorldOcclusion.h b/Source/Contents/World/WorldOcclusion.h
index c5d3b4dc..29f9d1f8 100644
--- a/Source/Contents/World/WorldOcclusion.h
+++ b/Source/Contents/World/WorldOcclusion.h
@@ -3,12 +3,11 @@
 
 struct WorldSpatialTree;
 class GroundGeometry;
-struct RenderProjection;
 
 void MarkWorldOcclusionRay(const float* ray, float actorLimit, float groundLimit, WorldSpatialTree& root, GroundGeometry& ground, bool markGround);
 
 void MarkScreenWorldOcclusion(
-  const RenderProjection& projection, int screenX, int screenY, float rendererScale, const float* origin, const float* cameraMatrix, float playerHeight,
+  int screenX, int screenY, float rendererScale, const float* origin, const float* cameraMatrix, float playerHeight,
   float cameraHeight, WorldSpatialTree& root, GroundGeometry& ground, bool markGround
 );
 
diff --git a/Source/Contents/World/WorldTerrainPicking.cpp b/Source/Contents/World/WorldTerrainPicking.cpp
index 3224d64e..86838fac 100644
--- a/Source/Contents/World/WorldTerrainPicking.cpp
+++ b/Source/Contents/World/WorldTerrainPicking.cpp
@@ -1,17 +1,17 @@
 #include "Contents/World/WorldRayQuery.h"
 #include "Contents/World/WorldSpatialTree.h"
+#include "Render/Renderer.h"
 #include "Contents/World/WorldTerrainPicking.h"
-#include "Render/Projection/RenderProjection.h"
 #include "Resource/World/TerrainResource.h"
 
 // OFFSET: 0x00CD4060
 // FUNCTION: fn_21274
 bool PickScreenTerrain(
-  const RenderProjection& projection, int x, int y, const float* origin, const float* cameraMatrix, WorldSpatialTree& root, int& column, int& row
+  int x, int y, const float* origin, const float* cameraMatrix, WorldSpatialTree& root, int& column, int& row
 ) {
   WorldRayQuery query;
   float ray[6]{};
-  projection.Ray(x, y, origin, cameraMatrix, ray);
+  g_renderer->viewport.Ray(x, y, origin, cameraMatrix, ray);
   query.Collect(ray, &root);
   float nearest = 999999.0f;
   float result = nearest;
diff --git a/Source/Contents/World/WorldTerrainPicking.h b/Source/Contents/World/WorldTerrainPicking.h
index 50c60456..a51e9b93 100644
--- a/Source/Contents/World/WorldTerrainPicking.h
+++ b/Source/Contents/World/WorldTerrainPicking.h
@@ -2,12 +2,11 @@
 #define RAGNAROK_SOURCE_CONTENTS_WORLD_WORLDTERRAINPICKING_H
 
 struct WorldSpatialTree;
-struct RenderProjection;
 
 bool PickTerrainRay(const float* ray, WorldSpatialTree& root, int& column, int& row);
 
 bool PickScreenTerrain(
-  const RenderProjection& projection, int x, int y, const float* origin, const float* cameraMatrix, WorldSpatialTree& root, int& column, int& row
+  int x, int y, const float* origin, const float* cameraMatrix, WorldSpatialTree& root, int& column, int& row
 );
 
 #endif
diff --git a/Source/Render/Projection/RenderProjection.cpp b/Source/Render/Projection/RenderProjection.cpp
index 29738386..f5ac069c 100644
--- a/Source/Render/Projection/RenderProjection.cpp
+++ b/Source/Render/Projection/RenderProjection.cpp
@@ -1,12 +1,12 @@
 #include "Render/Primitives/LightmappedPrimitive.h"
 #include "Render/Primitives/RenderPrimitive.h"
-#include "Render/Projection/RenderProjection.h"
+#include "Render/Projection/RendererViewport.h"
 
 #include <bit>
 
 // OFFSET: 0x0055D650
 // FUNCTION: fn_02106
-void RenderProjection::Project(const float* position, const float* matrix, RenderVertex& output) const {
+void RendererViewport::Project(const float* position, const float* matrix, RenderVertex& output) const {
   const float inverseDepth = 1.0f / (((matrix[5] * position[1] + matrix[2] * position[0]) + matrix[8] * position[2]) + matrix[11]);
   output.rhw = inverseDepth;
 
@@ -25,7 +25,7 @@ void RenderProjection::Project(const float* position, const float* matrix, Rende
 
 // OFFSET: 0x0055D750
 // FUNCTION: fn_02107
-void RenderProjection::Project(const float* position, const float* matrix, LightmappedVertex& output) const {
+void RendererViewport::Project(const float* position, const float* matrix, LightmappedVertex& output) const {
   const float inverseDepth = 1.0f / (((matrix[5] * position[1] + matrix[2] * position[0]) + matrix[8] * position[2]) + matrix[11]);
   output.rhw = inverseDepth;
 
diff --git a/Source/Render/Projection/RenderProjection.h b/Source/Render/Projection/RenderProjection.h
deleted file mode 100644
index 10ccffeb..00000000
--- a/Source/Render/Projection/RenderProjection.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef RAGNAROK_SOURCE_RENDER_PROJECTION_RENDERPROJECTION_H
-#define RAGNAROK_SOURCE_RENDER_PROJECTION_RENDERPROJECTION_H
-
-struct LightmappedVertex;
-struct RenderVertex;
-
-struct RenderProjection {
-  const float& scaleX;
-  const float& scaleY;
-  const int& centerX;
-  const int& centerY;
-
-  void Project(const float* position, const float* matrix, RenderVertex& output) const;
-  void Project(const float* position, const float* matrix, LightmappedVertex& output) const;
-  void Ray(int x, int y, const float* origin, const float* matrix, float* output) const;
-};
-
-#endif
diff --git a/Source/Render/Projection/RenderRay.cpp b/Source/Render/Projection/RenderRay.cpp
index de4858c5..71015e66 100644
--- a/Source/Render/Projection/RenderRay.cpp
+++ b/Source/Render/Projection/RenderRay.cpp
@@ -1,4 +1,4 @@
-#include "Render/Projection/RenderProjection.h"
+#include "Render/Projection/RendererViewport.h"
 
 #include <bit>
 #include <cmath>
@@ -14,7 +14,7 @@ namespace {
 
 // OFFSET: 0x0055A090
 // FUNCTION: fn_02076
-void RenderProjection::Ray(int x, int y, const float* origin, const float* matrix, float* output) const {
+void RendererViewport::Ray(int x, int y, const float* origin, const float* matrix, float* output) const {
   float transform[12];
   std::memcpy(transform, matrix, sizeof(transform));
   const float horizontal = static_cast<float>(x) / static_cast<float>(this->centerX);
diff --git a/Source/Render/Projection/RendererViewport.cpp b/Source/Render/Projection/RendererViewport.cpp
index a1dd2a06..04c8eba0 100644
--- a/Source/Render/Projection/RendererViewport.cpp
+++ b/Source/Render/Projection/RendererViewport.cpp
@@ -30,8 +30,3 @@ void RendererViewport::SetSize(int columns, int rows) {
   g_tangent = g_projectionScale / this->uiScaleY;
   g_cotangent = g_projectionScale / this->uiScaleY;
 }
-
-// INLINED
-RenderProjection RendererViewport::Projection() const {
-  return {this->scaleX, this->scaleY, this->centerX, this->centerY};
-}
diff --git a/Source/Render/Projection/RendererViewport.h b/Source/Render/Projection/RendererViewport.h
index b4d67f56..bc5ee935 100644
--- a/Source/Render/Projection/RendererViewport.h
+++ b/Source/Render/Projection/RendererViewport.h
@@ -2,7 +2,6 @@
 #define RAGNAROK_SOURCE_RENDER_PROJECTION_RENDERERVIEWPORT_H
 
 #include <cstddef>
-#include "Render/Projection/RenderProjection.h"
 
 struct RendererViewport {
   /* 0004 */ float scaleX;
@@ -20,7 +19,9 @@ struct RendererViewport {
   /* 0034 */ int centerY;
 
   void SetSize(int width, int height);
-  RenderProjection Projection() const;
+  void Project(const float* position, const float* matrix, struct RenderVertex& output) const;
+  void Project(const float* position, const float* matrix, struct LightmappedVertex& output) const;
+  void Ray(int x, int y, const float* origin, const float* matrix, float* output) const;
 };
 
 extern float g_cotangent;