diff --git a/Windows_Libs/Dev/Render/Renderer.h b/Windows_Libs/Dev/Render/Renderer.h
index 0120100..9f6ae23 100644
--- a/Windows_Libs/Dev/Render/Renderer.h
+++ b/Windows_Libs/Dev/Render/Renderer.h
@@ -4,23 +4,25 @@
 #include <unordered_map>
 #include <vector>
 
-#define MATRIX_MODE_MODELVIEW       0
-#define MATRIX_MODE_MODELVIEW_UNK1  1
-#define MATRIX_MODE_MODELVIEW_UNK2  2
-#define MATRIX_MODE_MODELVIEW_CBUFF 3
-#define MATRIX_MODE_MODELVIEW_MAX   4
+#define MATRIX_MODE_MODELVIEW            0
+#define MATRIX_MODE_MODELVIEW_PROJECTION 1
+#define MATRIX_MODE_MODELVIEW_TEXTURE    2
+#define MATRIX_MODE_MODELVIEW_CBUFF      3
+#define MATRIX_MODE_MODELVIEW_MAX        4
 
 #define STACK_TYPES    4
 #define STACK_SIZE     16
 #define MAX_MIP_LEVELS 5
 
+#define NUM_COMMAND_HANDLES 0x800000
+#define MAX_COMMAND_BUFFERS 16000
+
 class Renderer
 {
 public:
     struct Context;
     struct CommandBuffer;
 
-    void Tick();
     void UpdateGamma(unsigned short usGamma);
     void MatrixMode(int type);
     void MatrixSetIdentity();
@@ -305,7 +307,6 @@ public:
         std::vector<Command> m_commands;
         std::uint64_t m_allocated;
         BYTE isActive;
-        BYTE paddingAfterActive[7];
     };
 
     struct DeferredCBuff
@@ -326,7 +327,6 @@ public:
         ID3D11DeviceContext *m_pDeviceContext;
         ID3DUserDefinedAnnotation *userAnnotation;
         DWORD annotateDepth;
-        BYTE paddingAfterFlags[12];
         DirectX::XMMATRIX matrixStacks[MATRIX_MODE_MODELVIEW_MAX][STACK_SIZE];
         bool matrixDirty[MATRIX_MODE_MODELVIEW_MAX];
         DWORD stackPos[MATRIX_MODE_MODELVIEW_MAX];
@@ -338,7 +338,6 @@ public:
         float alphaReference;
         BYTE depthWriteEnabled;
         BYTE fogEnabled;
-        BYTE paddingAfterFogFlags[2];
         float fogNearDistance;
         float fogFarDistance;
         float fogDensity;
@@ -355,40 +354,35 @@ public:
         DirectX::XMFLOAT4 lightColour[2];
         DirectX::XMFLOAT4 lightAmbientColour;
         ID3D11Buffer *m_modelViewMatrix;
-        ID3D11Buffer *cbMatrix1;
-        ID3D11Buffer *cbMatrix2;
-        ID3D11Buffer *cbMatrix3;
-        ID3D11Buffer *cbVertexTexcoord;
-        ID3D11Buffer *cbFogParams;
-        ID3D11Buffer *cbLighting;
-        ID3D11Buffer *cbTexGen;
-        ID3D11Buffer *cbAux0;
-        ID3D11Buffer *cbAux1;
-        ID3D11Buffer *cbColour;
-        ID3D11Buffer *cbFogColour;
-        ID3D11Buffer *cbAux2;
-        ID3D11Buffer *cbAlphaTest;
-        ID3D11Buffer *cbAux3;
-        ID3D11Buffer *cbAux4;
+        ID3D11Buffer *m_localTransformMatrix;
+        ID3D11Buffer *m_projectionMatrix;
+        ID3D11Buffer *m_textureMatrix;
+        ID3D11Buffer *m_vertexTexcoordBuffer;
+        ID3D11Buffer *m_fogParamsBuffer;
+        ID3D11Buffer *m_lightingStateBuffer;
+        ID3D11Buffer *m_texGenMatricesBuffer;
+        ID3D11Buffer *m_compressedTranslationBuffer;
+        ID3D11Buffer *m_thumbnailBoundsBuffer;
+        ID3D11Buffer *m_tintColorBuffer;
+        ID3D11Buffer *m_fogColourBuffer;
+        ID3D11Buffer *m_unkColorBuffer;
+        ID3D11Buffer *m_alphaTestBuffer;
+        ID3D11Buffer *m_clearColorBuffer;
+        ID3D11Buffer *m_forcedLODBuffer;
         uint64_t dynamicVertexBase;
         DWORD dynamicVertexOffset;
-        BYTE paddingAfterDynamicOffset[4];
         ID3D11Buffer *dynamicVertexBuffer;
-        BYTE paddingBeforeTexGen[8];
         DirectX::XMMATRIX texGenMatrices[2];
         Renderer::CommandBuffer *commandBuffer;
         DWORD recordingBufferIndex;
         DWORD recordingVertexType;
         DWORD recordingPrimitiveType;
         BYTE deferredModeEnabled;
-        BYTE paddingAfterDeferredModeEnabled[3];
         std::vector<DeferredCBuff> deferredBuffers;
         D3D11_BLEND_DESC blendDesc;
         D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
         D3D11_RASTERIZER_DESC rasterizerDesc;
         float blendFactor[4];
-        DWORD reservedContext0;
-        DWORD reservedContext1;
     };
 
     static DWORD tlsIdx;
@@ -438,12 +432,12 @@ public:
     BYTE reservedRendererByte1;
     BYTE paddingAfterRendererByte1[3];
     DWORD reservedRendererDword1;
-    void *reservedRendererPtr2;
-    void *reservedRendererPtr3;
-    uint64_t reservedRendererPtr1;
-    void *reservedRendererPtr4;
-    void *reservedRendererPtr5;
-    void *reservedRendererPtr6;
+    int16_t *m_commandHandleToIndex;
+    CommandBuffer **m_commandBuffers;
+    uint8_t *m_commandPrimitiveTypes;
+    DirectX::XMMATRIX *m_commandMatrices;
+    int *m_commandIndexToHandle;
+    uint8_t *m_commandVertexTypes;
     DWORD reservedRendererDword2;
     DWORD reservedRendererDword3;
     std::unordered_map<int, ID3D11BlendState *> managedBlendStates;
diff --git a/Windows_Libs/Dev/Render/RendererCBuff.cpp b/Windows_Libs/Dev/Render/RendererCBuff.cpp
index 8269f7b..de1922a 100644
--- a/Windows_Libs/Dev/Render/RendererCBuff.cpp
+++ b/Windows_Libs/Dev/Render/RendererCBuff.cpp
@@ -11,7 +11,6 @@
 Renderer::CommandBuffer::CommandBuffer(bool full)
     : m_vertexBuffer(nullptr), m_vertexData(nullptr), m_vertexDataLength(0), m_commands(), m_allocated(0x1000), isActive(full ? 1 : 0)
 {
-    std::memset(paddingAfterActive, 0, sizeof(paddingAfterActive));
     m_vertexData = std::malloc(m_allocated);
     EnterCriticalSection(&Renderer::totalAllocCS);
     Renderer::totalAlloc += static_cast<int>(m_allocated);
@@ -265,16 +264,16 @@ void Renderer::CommandBuffer::Render(C4JRender::eVertexType vType, Renderer::Con
                 const float row[4] = {command.add_matrix.m_matrix[12], command.add_matrix.m_matrix[13], command.add_matrix.m_matrix[14],
                                       command.add_matrix.m_matrix[15]};
                 D3D11_MAPPED_SUBRESOURCE mappedAux0 = {};
-                c.m_pDeviceContext->Map(c.cbAux0, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedAux0);
+                c.m_pDeviceContext->Map(c.m_compressedTranslationBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedAux0);
                 std::memcpy(mappedAux0.pData, row, sizeof(row));
-                c.m_pDeviceContext->Unmap(c.cbAux0, 0);
+                c.m_pDeviceContext->Unmap(c.m_compressedTranslationBuffer, 0);
             }
             else
             {
                 D3D11_MAPPED_SUBRESOURCE mappedMatrix1 = {};
-                c.m_pDeviceContext->Map(c.cbMatrix1, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedMatrix1);
+                c.m_pDeviceContext->Map(c.m_localTransformMatrix, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedMatrix1);
                 std::memcpy(mappedMatrix1.pData, command.add_matrix.m_matrix, sizeof(command.add_matrix.m_matrix));
-                c.m_pDeviceContext->Unmap(c.cbMatrix1, 0);
+                c.m_pDeviceContext->Unmap(c.m_localTransformMatrix, 0);
                 matrixOverride = true;
             }
             break;
@@ -346,9 +345,9 @@ void Renderer::CommandBuffer::Render(C4JRender::eVertexType vType, Renderer::Con
         case COMMAND_SET_COLOR:
         {
             D3D11_MAPPED_SUBRESOURCE mappedColour = {};
-            c.m_pDeviceContext->Map(c.cbColour, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedColour);
+            c.m_pDeviceContext->Map(c.m_tintColorBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedColour);
             std::memcpy(mappedColour.pData, command.set_color.m_color, sizeof(command.set_color.m_color));
-            c.m_pDeviceContext->Unmap(c.cbColour, 0);
+            c.m_pDeviceContext->Unmap(c.m_tintColorBuffer, 0);
             break;
         }
         case COMMAND_SET_DEPTH_FUNC:
@@ -459,9 +458,9 @@ void Renderer::CommandBuffer::Render(C4JRender::eVertexType vType, Renderer::Con
     {
         const DirectX::XMMATRIX identity = DirectX::XMMatrixIdentity();
         D3D11_MAPPED_SUBRESOURCE mappedIdentity = {};
-        c.m_pDeviceContext->Map(c.cbMatrix1, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedIdentity);
+        c.m_pDeviceContext->Map(c.m_localTransformMatrix, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedIdentity);
         std::memcpy(mappedIdentity.pData, &identity, sizeof(identity));
-        c.m_pDeviceContext->Unmap(c.cbMatrix1, 0);
+        c.m_pDeviceContext->Unmap(c.m_localTransformMatrix, 0);
     }
 }
 
@@ -470,13 +469,12 @@ bool Renderer::CBuffCall(int index, bool full)
     EnterCriticalSection(&rtl_critical_section100);
 
     bool result = false;
-    std::int16_t *externalToInternal = static_cast<std::int16_t *>(reservedRendererPtr2);
-    const int internalIndex = externalToInternal[index];
-    if (internalIndex >= 0)
+    const int commandIndex = m_commandHandleToIndex[index];
+    if (commandIndex >= 0)
     {
         Renderer::Context &c = this->getContext();
-        const std::uint8_t vertexType = static_cast<std::uint8_t *>(reservedRendererPtr6)[internalIndex];
-        const std::uint8_t primitiveType = reinterpret_cast<std::uint8_t *>(reservedRendererPtr1)[internalIndex];
+        const std::uint8_t vertexType = m_commandVertexTypes[commandIndex];
+        const std::uint8_t primitiveType = m_commandPrimitiveTypes[commandIndex];
 
         if (full)
         {
@@ -489,22 +487,22 @@ bool Renderer::CBuffCall(int index, bool full)
                 c.matrixDirty[MATRIX_MODE_MODELVIEW] = false;
             }
 
-            if (c.matrixDirty[MATRIX_MODE_MODELVIEW_UNK1])
+            if (c.matrixDirty[MATRIX_MODE_MODELVIEW_PROJECTION])
             {
                 D3D11_MAPPED_SUBRESOURCE mappedMatrix2 = {};
-                c.m_pDeviceContext->Map(c.cbMatrix2, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedMatrix2);
-                std::memcpy(mappedMatrix2.pData, this->MatrixGet(MATRIX_MODE_MODELVIEW_UNK1), sizeof(DirectX::XMMATRIX));
-                c.m_pDeviceContext->Unmap(c.cbMatrix2, 0);
-                c.matrixDirty[MATRIX_MODE_MODELVIEW_UNK1] = false;
+                c.m_pDeviceContext->Map(c.m_projectionMatrix, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedMatrix2);
+                std::memcpy(mappedMatrix2.pData, this->MatrixGet(MATRIX_MODE_MODELVIEW_PROJECTION), sizeof(DirectX::XMMATRIX));
+                c.m_pDeviceContext->Unmap(c.m_projectionMatrix, 0);
+                c.matrixDirty[MATRIX_MODE_MODELVIEW_PROJECTION] = false;
             }
 
-            if (c.matrixDirty[MATRIX_MODE_MODELVIEW_UNK2])
+            if (c.matrixDirty[MATRIX_MODE_MODELVIEW_TEXTURE])
             {
                 D3D11_MAPPED_SUBRESOURCE mappedMatrix3 = {};
-                c.m_pDeviceContext->Map(c.cbMatrix3, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedMatrix3);
-                std::memcpy(mappedMatrix3.pData, this->MatrixGet(MATRIX_MODE_MODELVIEW_UNK2), sizeof(DirectX::XMMATRIX));
-                c.m_pDeviceContext->Unmap(c.cbMatrix3, 0);
-                c.matrixDirty[MATRIX_MODE_MODELVIEW_UNK2] = false;
+                c.m_pDeviceContext->Map(c.m_textureMatrix, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedMatrix3);
+                std::memcpy(mappedMatrix3.pData, this->MatrixGet(MATRIX_MODE_MODELVIEW_TEXTURE), sizeof(DirectX::XMMATRIX));
+                c.m_pDeviceContext->Unmap(c.m_textureMatrix, 0);
+                c.matrixDirty[MATRIX_MODE_MODELVIEW_TEXTURE] = false;
             }
 
             this->UpdateFogState();
@@ -524,9 +522,9 @@ bool Renderer::CBuffCall(int index, bool full)
             {
                 const float forcedLod[4] = {static_cast<float>(static_cast<int>(c.forcedLOD)), 0.0f, 0.0f, 0.0f};
                 D3D11_MAPPED_SUBRESOURCE mappedAux4 = {};
-                c.m_pDeviceContext->Map(c.cbAux4, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedAux4);
+                c.m_pDeviceContext->Map(c.m_forcedLODBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedAux4);
                 std::memcpy(mappedAux4.pData, forcedLod, sizeof(forcedLod));
-                c.m_pDeviceContext->Unmap(c.cbAux4, 0);
+                c.m_pDeviceContext->Unmap(c.m_forcedLODBuffer, 0);
                 pixelType = C4JRender::PIXEL_SHADER_TYPE_FORCELOD;
             }
 
@@ -551,12 +549,11 @@ bool Renderer::CBuffCall(int index, bool full)
             c.m_pDeviceContext->IASetIndexBuffer(indexBuffer, DXGI_FORMAT_R16_UINT, 0);
         }
 
-        Renderer::CommandBuffer *commandBuffer = static_cast<Renderer::CommandBuffer **>(reservedRendererPtr3)[internalIndex];
-        commandBuffer->Render(static_cast<C4JRender::eVertexType>(vertexType), c, primitiveType);
+        m_commandBuffers[commandIndex]->Render(static_cast<C4JRender::eVertexType>(vertexType), c, primitiveType);
 
         if (full)
         {
-            this->MultWithStack(static_cast<DirectX::XMMATRIX *>(reservedRendererPtr4)[internalIndex]);
+            this->MultWithStack(m_commandMatrices[commandIndex]);
             c.matrixStacks[MATRIX_MODE_MODELVIEW_CBUFF][0] = DirectX::XMMatrixIdentity();
             c.matrixDirty[MATRIX_MODE_MODELVIEW_CBUFF] = true;
         }
@@ -572,7 +569,7 @@ void Renderer::CBuffClear(int index)
 {
     EnterCriticalSection(&rtl_critical_section100);
 
-    std::int16_t *externalToInternal = static_cast<std::int16_t *>(reservedRendererPtr2);
+    std::int16_t *externalToInternal = static_cast<std::int16_t *>(m_commandHandleToIndex);
     const int internalIndex = externalToInternal[index];
     if (internalIndex >= 0)
     {
@@ -585,23 +582,19 @@ void Renderer::CBuffClear(int index)
 
 int Renderer::CBuffCreate(int count)
 {
-    const int kMaxExternalCBuffers = 0x800000;
-
     EnterCriticalSection(&rtl_critical_section100);
 
     int first = reservedRendererDword1;
-    std::int16_t *externalToInternal = static_cast<std::int16_t *>(reservedRendererPtr2);
-
-    if (first < kMaxExternalCBuffers)
+    if (first < NUM_COMMAND_HANDLES)
     {
         int probe = first;
         int end = first + count;
         while (true)
         {
-            assert(first < kMaxExternalCBuffers);
+            assert(first < NUM_COMMAND_HANDLES);
 
             int cursor = probe;
-            while (cursor < end && cursor < kMaxExternalCBuffers && externalToInternal[cursor] == static_cast<std::int16_t>(-1))
+            while (cursor < end && cursor < NUM_COMMAND_HANDLES && m_commandHandleToIndex[cursor] == static_cast<std::int16_t>(-1))
             {
                 ++cursor;
             }
@@ -614,7 +607,7 @@ int Renderer::CBuffCreate(int count)
             ++first;
             ++probe;
             ++end;
-            if (first >= kMaxExternalCBuffers || end > kMaxExternalCBuffers)
+            if (first >= NUM_COMMAND_HANDLES || end > NUM_COMMAND_HANDLES)
             {
                 first = -1;
                 break;
@@ -626,7 +619,7 @@ int Renderer::CBuffCreate(int count)
             const int allocationEnd = first + count;
             for (int i = first; i < allocationEnd; ++i)
             {
-                externalToInternal[i] = static_cast<std::int16_t>(-2);
+                m_commandHandleToIndex[i] = static_cast<std::int16_t>(-2);
             }
 
             if (reservedRendererByte1)
@@ -655,23 +648,16 @@ void Renderer::CBuffDeferredModeEnd()
     EnterCriticalSection(&rtl_critical_section100);
     c.deferredModeEnabled = 0;
 
-    std::int16_t *externalToInternal = static_cast<std::int16_t *>(reservedRendererPtr2);
-    int *internalToExternal = static_cast<int *>(reservedRendererPtr5);
-    std::uint8_t *internalVertexTypes = static_cast<std::uint8_t *>(reservedRendererPtr6);
-    std::uint8_t *internalPrimitiveTypes = reinterpret_cast<std::uint8_t *>(reservedRendererPtr1);
-    Renderer::CommandBuffer **internalBuffers = static_cast<Renderer::CommandBuffer **>(reservedRendererPtr3);
-    DirectX::XMMATRIX *internalMatrices = static_cast<DirectX::XMMATRIX *>(reservedRendererPtr4);
-
     for (std::vector<Renderer::DeferredCBuff>::const_iterator it = c.deferredBuffers.begin(); it != c.deferredBuffers.end(); ++it)
     {
         const Renderer::DeferredCBuff &deferred = *it;
-        const int existingIndex = externalToInternal[deferred.m_vertex_index];
+        const int existingIndex = m_commandHandleToIndex[deferred.m_vertex_index];
         if (existingIndex >= 0)
         {
             this->DeleteInternalBuffer(existingIndex);
         }
 
-        if (static_cast<int>(reservedRendererDword2 + reservedRendererDword3 + 10u) > 16000)
+        if (static_cast<int>(reservedRendererDword2 + reservedRendererDword3 + 10u) > MAX_COMMAND_BUFFERS)
         {
             DebugBreak();
         }
@@ -679,12 +665,12 @@ void Renderer::CBuffDeferredModeEnd()
         const int internalSlot = reservedRendererDword2;
         ++reservedRendererDword2;
 
-        externalToInternal[deferred.m_vertex_index] = static_cast<std::int16_t>(internalSlot);
-        internalToExternal[internalSlot] = deferred.m_vertex_index;
-        internalVertexTypes[internalSlot] = static_cast<std::uint8_t>(deferred.m_vertex_type);
-        internalPrimitiveTypes[internalSlot] = static_cast<std::uint8_t>(deferred.m_primitive_type);
-        internalBuffers[internalSlot] = deferred.m_command_buf;
-        internalMatrices[internalSlot] = deferred.m_matrix;
+        m_commandHandleToIndex[deferred.m_vertex_index] = static_cast<std::int16_t>(internalSlot);
+        m_commandIndexToHandle[internalSlot] = deferred.m_vertex_index;
+        m_commandVertexTypes[internalSlot] = static_cast<std::uint8_t>(deferred.m_vertex_type);
+        m_commandPrimitiveTypes[internalSlot] = static_cast<std::uint8_t>(deferred.m_primitive_type);
+        m_commandBuffers[internalSlot] = deferred.m_command_buf;
+        m_commandMatrices[internalSlot] = deferred.m_matrix;
     }
 
     c.deferredBuffers.clear();
@@ -700,17 +686,16 @@ void Renderer::CBuffDelete(int first, int count)
 {
     EnterCriticalSection(&rtl_critical_section100);
 
-    std::int16_t *externalToInternal = static_cast<std::int16_t *>(reservedRendererPtr2);
     const int end = first + count;
     for (int i = first; i < end; ++i)
     {
-        const int internalIndex = externalToInternal[i];
+        const int internalIndex = m_commandHandleToIndex[i];
         if (internalIndex >= 0)
         {
             this->DeleteInternalBuffer(internalIndex);
         }
 
-        externalToInternal[i] = static_cast<std::int16_t>(-1);
+        m_commandHandleToIndex[i] = static_cast<std::int16_t>(-1);
     }
 
     LeaveCriticalSection(&rtl_critical_section100);
@@ -737,20 +722,13 @@ void Renderer::CBuffEnd()
     }
     else
     {
-        std::int16_t *externalToInternal = static_cast<std::int16_t *>(reservedRendererPtr2);
-        int *internalToExternal = static_cast<int *>(reservedRendererPtr5);
-        std::uint8_t *internalVertexTypes = static_cast<std::uint8_t *>(reservedRendererPtr6);
-        std::uint8_t *internalPrimitiveTypes = reinterpret_cast<std::uint8_t *>(reservedRendererPtr1);
-        Renderer::CommandBuffer **internalBuffers = static_cast<Renderer::CommandBuffer **>(reservedRendererPtr3);
-        DirectX::XMMATRIX *internalMatrices = static_cast<DirectX::XMMATRIX *>(reservedRendererPtr4);
-
-        const int existingIndex = externalToInternal[c.recordingBufferIndex];
+        const int existingIndex = m_commandHandleToIndex[c.recordingBufferIndex];
         if (existingIndex >= 0)
         {
             this->DeleteInternalBuffer(existingIndex);
         }
 
-        if (static_cast<int>(reservedRendererDword2 + reservedRendererDword3 + 10u) > 16000)
+        if (static_cast<int>(reservedRendererDword2 + reservedRendererDword3 + 10u) > MAX_COMMAND_BUFFERS)
         {
             DebugBreak();
         }
@@ -758,12 +736,12 @@ void Renderer::CBuffEnd()
         const int internalSlot = reservedRendererDword2;
         ++reservedRendererDword2;
 
-        externalToInternal[c.recordingBufferIndex] = static_cast<std::int16_t>(internalSlot);
-        internalToExternal[internalSlot] = c.recordingBufferIndex;
-        internalVertexTypes[internalSlot] = static_cast<std::uint8_t>(c.recordingVertexType);
-        internalPrimitiveTypes[internalSlot] = static_cast<std::uint8_t>(c.recordingPrimitiveType);
-        internalBuffers[internalSlot] = c.commandBuffer;
-        internalMatrices[internalSlot] = c.matrixStacks[MATRIX_MODE_MODELVIEW_CBUFF][0];
+        m_commandHandleToIndex[c.recordingBufferIndex] = static_cast<std::int16_t>(internalSlot);
+        m_commandIndexToHandle[internalSlot] = c.recordingBufferIndex;
+        m_commandVertexTypes[internalSlot] = static_cast<std::uint8_t>(c.recordingVertexType);
+        m_commandPrimitiveTypes[internalSlot] = static_cast<std::uint8_t>(c.recordingPrimitiveType);
+        m_commandBuffers[internalSlot] = c.commandBuffer;
+        m_commandMatrices[internalSlot] = c.matrixStacks[MATRIX_MODE_MODELVIEW_CBUFF][0];
     }
 
     c.stackType = MATRIX_MODE_MODELVIEW;
@@ -787,10 +765,10 @@ int Renderer::CBuffSize(int index)
 
     unsigned int size = 0;
     EnterCriticalSection(&rtl_critical_section100);
-    const int internalIndex = static_cast<std::int16_t *>(reservedRendererPtr2)[index];
-    if (internalIndex >= 0)
+    const int commandIndex = m_commandHandleToIndex[index];
+    if (commandIndex >= 0)
     {
-        size = static_cast<Renderer::CommandBuffer **>(reservedRendererPtr3)[internalIndex]->GetAllocated();
+        size = m_commandBuffers[commandIndex]->GetAllocated();
     }
     LeaveCriticalSection(&rtl_critical_section100);
     return size;
@@ -812,20 +790,17 @@ void Renderer::CBuffStart(int index, bool full)
 
 void Renderer::CBuffTick()
 {
-    const int kMaxInternalCBuffers = 16000;
-
     EnterCriticalSection(&rtl_critical_section100);
 
-    Renderer::CommandBuffer **buffers = static_cast<Renderer::CommandBuffer **>(reservedRendererPtr3);
-    const int firstPending = kMaxInternalCBuffers - static_cast<int>(reservedRendererDword3);
-    for (int i = firstPending; i < kMaxInternalCBuffers; ++i)
+    const int firstPending = MAX_COMMAND_BUFFERS - static_cast<int>(reservedRendererDword3);
+    for (int i = firstPending; i < MAX_COMMAND_BUFFERS; ++i)
     {
-        Renderer::CommandBuffer *buffer = buffers[i];
+        Renderer::CommandBuffer *buffer = m_commandBuffers[i];
         if (buffer)
         {
             delete buffer;
         }
-        buffers[i] = nullptr;
+        m_commandBuffers[i] = nullptr;
     }
 
     reservedRendererDword3 = 0;
@@ -834,35 +809,26 @@ void Renderer::CBuffTick()
 
 void Renderer::DeleteInternalBuffer(int index)
 {
-    const int kMaxInternalCBuffers = 16000;
-
     EnterCriticalSection(&rtl_critical_section100);
 
-    Renderer::CommandBuffer **internalBuffers = static_cast<Renderer::CommandBuffer **>(reservedRendererPtr3);
-    DirectX::XMMATRIX *internalMatrices = static_cast<DirectX::XMMATRIX *>(reservedRendererPtr4);
-    std::uint8_t *internalVertexTypes = static_cast<std::uint8_t *>(reservedRendererPtr6);
-    std::uint8_t *internalPrimitiveTypes = reinterpret_cast<std::uint8_t *>(reservedRendererPtr1);
-    std::int16_t *externalToInternal = static_cast<std::int16_t *>(reservedRendererPtr2);
-    int *internalToExternal = static_cast<int *>(reservedRendererPtr5);
-
     ++reservedRendererDword3;
-    const int recycledSlot = kMaxInternalCBuffers - static_cast<int>(reservedRendererDword3);
+    const int recycledSlot = MAX_COMMAND_BUFFERS - static_cast<int>(reservedRendererDword3);
 
-    internalBuffers[recycledSlot] = internalBuffers[index];
-    internalMatrices[recycledSlot] = internalMatrices[index];
+    m_commandBuffers[recycledSlot] = m_commandBuffers[index];
+    m_commandMatrices[recycledSlot] = m_commandMatrices[index];
 
     if (reservedRendererDword2-- != 1)
     {
         const int lastActive = reservedRendererDword2;
 
-        internalBuffers[index] = internalBuffers[lastActive];
-        internalMatrices[index] = internalMatrices[lastActive];
-        internalVertexTypes[index] = internalVertexTypes[lastActive];
-        internalPrimitiveTypes[index] = internalPrimitiveTypes[lastActive];
+        m_commandBuffers[index] = m_commandBuffers[lastActive];
+        m_commandMatrices[index] = m_commandMatrices[lastActive];
+        m_commandVertexTypes[index] = m_commandVertexTypes[lastActive];
+        m_commandPrimitiveTypes[index] = m_commandPrimitiveTypes[lastActive];
 
-        const int externalIndex = internalToExternal[lastActive];
-        externalToInternal[externalIndex] = static_cast<std::int16_t>(index);
-        internalToExternal[index] = externalIndex;
+        const int commandIndex = m_commandIndexToHandle[lastActive];
+        m_commandHandleToIndex[commandIndex] = static_cast<std::int16_t>(index);
+        m_commandIndexToHandle[index] = commandIndex;
     }
 
     LeaveCriticalSection(&rtl_critical_section100);
diff --git a/Windows_Libs/Dev/Render/RendererCore.cpp b/Windows_Libs/Dev/Render/RendererCore.cpp
index 7fa7f56..1cd0b9e 100644
--- a/Windows_Libs/Dev/Render/RendererCore.cpp
+++ b/Windows_Libs/Dev/Render/RendererCore.cpp
@@ -49,11 +49,11 @@ Renderer::Context::Context(ID3D11Device *device, ID3D11DeviceContext *deviceCont
     : m_pDeviceContext(deviceContext), userAnnotation(nullptr), annotateDepth(0), stackType(0), textureIdx(0), faceCullEnabled(1),
       depthTestEnabled(1), alphaTestEnabled(0), alphaReference(1.0f), depthWriteEnabled(1), fogEnabled(0), fogNearDistance(0.0f),
       fogFarDistance(0.0f), fogDensity(0.0f), fogColourRed(0.0f), fogColourBlue(0.0f), fogColourGreen(0.0f), fogMode(0), lightingEnabled(0),
-      lightingDirty(0), forcedLOD(0xFFFFFFFFu), m_modelViewMatrix(nullptr), cbMatrix1(nullptr), cbMatrix2(nullptr), cbMatrix3(nullptr),
-      cbVertexTexcoord(nullptr), cbFogParams(nullptr), cbLighting(nullptr), cbTexGen(nullptr), cbAux0(nullptr), cbAux1(nullptr), cbColour(nullptr),
-      cbFogColour(nullptr), cbAux2(nullptr), cbAlphaTest(nullptr), cbAux3(nullptr), cbAux4(nullptr), dynamicVertexBase(0), dynamicVertexOffset(0),
-      dynamicVertexBuffer(nullptr), commandBuffer(nullptr), recordingBufferIndex(0), recordingVertexType(0), recordingPrimitiveType(0),
-      deferredModeEnabled(0), deferredBuffers(), reservedContext0(0), reservedContext1(0)
+      lightingDirty(0), forcedLOD(0xFFFFFFFFu), m_modelViewMatrix(nullptr), m_localTransformMatrix(nullptr), m_projectionMatrix(nullptr),
+      m_textureMatrix(nullptr), m_vertexTexcoordBuffer(nullptr), m_fogParamsBuffer(nullptr), m_lightingStateBuffer(nullptr), m_texGenMatricesBuffer(nullptr),
+      m_compressedTranslationBuffer(nullptr), m_thumbnailBoundsBuffer(nullptr), m_tintColorBuffer(nullptr), m_fogColourBuffer(nullptr), m_unkColorBuffer(nullptr), m_alphaTestBuffer(nullptr),
+      m_clearColorBuffer(nullptr), m_forcedLODBuffer(nullptr), dynamicVertexBase(0), dynamicVertexOffset(0), dynamicVertexBuffer(nullptr),
+      commandBuffer(nullptr), recordingBufferIndex(0), recordingVertexType(0), recordingPrimitiveType(0), deferredModeEnabled(0), deferredBuffers()
 {
     deviceContext->QueryInterface(IID_PPV_ARGS(&userAnnotation));
     std::memset(matrixStacks, 0, sizeof(matrixStacks));
@@ -134,46 +134,46 @@ Renderer::Context::Context(ID3D11Device *device, ID3D11DeviceContext *deviceCont
     cbDesc.ByteWidth = sizeof(DirectX::XMMATRIX);
     cbData.pSysMem = &identity;
     device->CreateBuffer(&cbDesc, &cbData, &m_modelViewMatrix);
-    device->CreateBuffer(&cbDesc, &cbData, &cbMatrix1);
-    device->CreateBuffer(&cbDesc, &cbData, &cbMatrix2);
-    device->CreateBuffer(&cbDesc, &cbData, &cbMatrix3);
+    device->CreateBuffer(&cbDesc, &cbData, &m_localTransformMatrix);
+    device->CreateBuffer(&cbDesc, &cbData, &m_projectionMatrix);
+    device->CreateBuffer(&cbDesc, &cbData, &m_textureMatrix);
 
     cbDesc.ByteWidth = sizeof(zero4);
     cbData.pSysMem = zero4;
-    device->CreateBuffer(&cbDesc, &cbData, &cbVertexTexcoord);
-    device->CreateBuffer(&cbDesc, &cbData, &cbFogParams);
+    device->CreateBuffer(&cbDesc, &cbData, &m_vertexTexcoordBuffer);
+    device->CreateBuffer(&cbDesc, &cbData, &m_fogParamsBuffer);
 
     const UINT lightingBytes = sizeof(lightDirection) + sizeof(lightColour) + sizeof(lightAmbientColour);
     cbDesc.ByteWidth = lightingBytes;
     cbData.pSysMem = lightDirection;
-    device->CreateBuffer(&cbDesc, &cbData, &cbLighting);
+    device->CreateBuffer(&cbDesc, &cbData, &m_lightingStateBuffer);
 
     cbDesc.ByteWidth = sizeof(texGenMatrices);
     cbData.pSysMem = texGenMatrices;
-    device->CreateBuffer(&cbDesc, &cbData, &cbTexGen);
+    device->CreateBuffer(&cbDesc, &cbData, &m_texGenMatricesBuffer);
 
     cbDesc.ByteWidth = sizeof(zero4);
     cbData.pSysMem = zero4;
-    device->CreateBuffer(&cbDesc, &cbData, &cbAux0);
-    device->CreateBuffer(&cbDesc, &cbData, &cbAux1);
+    device->CreateBuffer(&cbDesc, &cbData, &m_compressedTranslationBuffer);
+    device->CreateBuffer(&cbDesc, &cbData, &m_thumbnailBoundsBuffer);
 
     cbDesc.ByteWidth = sizeof(one4);
     cbData.pSysMem = one4;
-    device->CreateBuffer(&cbDesc, &cbData, &cbColour);
-    device->CreateBuffer(&cbDesc, &cbData, &cbFogColour);
-    device->CreateBuffer(&cbDesc, &cbData, &cbAux2);
+    device->CreateBuffer(&cbDesc, &cbData, &m_tintColorBuffer);
+    device->CreateBuffer(&cbDesc, &cbData, &m_fogColourBuffer);
+    device->CreateBuffer(&cbDesc, &cbData, &m_unkColorBuffer);
 
     cbDesc.ByteWidth = sizeof(alpha4);
     cbData.pSysMem = alpha4;
-    device->CreateBuffer(&cbDesc, &cbData, &cbAlphaTest);
+    device->CreateBuffer(&cbDesc, &cbData, &m_alphaTestBuffer);
 
     cbDesc.ByteWidth = sizeof(zero4);
     cbData.pSysMem = zero4;
-    device->CreateBuffer(&cbDesc, &cbData, &cbAux3);
-    device->CreateBuffer(&cbDesc, &cbData, &cbAux4);
+    device->CreateBuffer(&cbDesc, &cbData, &m_clearColorBuffer);
+    device->CreateBuffer(&cbDesc, &cbData, &m_forcedLODBuffer);
 
     deviceContext->VSSetConstantBuffers(0, 10, &m_modelViewMatrix);
-    deviceContext->PSSetConstantBuffers(0, 6, &cbColour);
+    deviceContext->PSSetConstantBuffers(0, 6, &m_tintColorBuffer);
 
     {
         void *dynamicVertexPtr = operator new[](kVertexBufferSize);
@@ -327,24 +327,19 @@ void Renderer::Initialise(ID3D11Device *pDevice, IDXGISwapChain *pSwapChain)
     m_pDeviceContext = this->InitialiseContext(true);
     m_pSwapChain = pSwapChain;
 
-    reservedRendererPtr2 = operator new[](0x1000000u);
-    reservedRendererPtr3 = operator new[](0x1F400u);
-    reservedRendererPtr4 = operator new[](0xFA000u);
-    reservedRendererPtr5 = operator new[](0xFA00u);
-    reservedRendererPtr6 = operator new[](0x3E80u);
-    {
-        void *reservedPtr = operator new[](0x3E80u);
-        reservedRendererPtr1 = reinterpret_cast<std::uint64_t>(reservedPtr);
-    }
+    m_commandHandleToIndex = new int16_t[NUM_COMMAND_HANDLES];
+    m_commandBuffers = new CommandBuffer *[MAX_COMMAND_BUFFERS];
+    m_commandMatrices = new DirectX::XMMATRIX[MAX_COMMAND_BUFFERS];
+    m_commandIndexToHandle = new int[MAX_COMMAND_BUFFERS];
+    m_commandVertexTypes = new uint8_t[MAX_COMMAND_BUFFERS];
+    m_commandPrimitiveTypes = new uint8_t[MAX_COMMAND_BUFFERS];
+
+    std::memset(m_commandHandleToIndex, 0xFF, NUM_COMMAND_HANDLES);
+    std::memset(m_commandBuffers, 0, MAX_COMMAND_BUFFERS);
+    std::memset(m_commandIndexToHandle, 0, MAX_COMMAND_BUFFERS);
+    std::memset(m_commandVertexTypes, 0, MAX_COMMAND_BUFFERS);
+    std::memset(m_commandPrimitiveTypes, 0, MAX_COMMAND_BUFFERS);
 
-    std::memset(reservedRendererPtr2, 0xFF, 0x1000000u);
-    std::memset(reservedRendererPtr3, 0, 0xFA00u);
-    std::memset(reservedRendererPtr5, 0, 0xFA00u);
-    std::memset(reservedRendererPtr6, 0, 0x3E80u);
-    {
-        void *reservedPtr = reinterpret_cast<void *>(reservedRendererPtr1);
-        std::memset(reservedPtr, 0, 0x3E80u);
-    }
     reservedRendererDword3 = 0;
 
     shouldScreenGrabNextFrame = 0;
@@ -597,9 +592,9 @@ void Renderer::SetClearColour(const float colourRGBA[4])
     if (c)
     {
         D3D11_MAPPED_SUBRESOURCE mapped = {};
-        c->m_pDeviceContext->Map(c->cbAux3, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
+        c->m_pDeviceContext->Map(c->m_clearColorBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
         std::memcpy(mapped.pData, colourRGBA, sizeof(float) * 4);
-        c->m_pDeviceContext->Unmap(c->cbAux3, 0);
+        c->m_pDeviceContext->Unmap(c->m_clearColorBuffer, 0);
     }
 }
 
@@ -677,7 +672,7 @@ void Renderer::StartFrame()
     this->StateSetAlphaTestEnable(true);
 
     c.m_pDeviceContext->VSSetConstantBuffers(0, 10, &c.m_modelViewMatrix);
-    c.m_pDeviceContext->PSSetConstantBuffers(0, 6, &c.cbColour);
+    c.m_pDeviceContext->PSSetConstantBuffers(0, 6, &c.m_tintColorBuffer);
 
     D3D11_VIEWPORT viewport = {};
     viewport.TopLeftX = 0.0f;
@@ -853,7 +848,7 @@ void Renderer::CaptureThumbnail(ImageFileBuffer *pngOut)
         c.m_pDeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
 
         D3D11_MAPPED_SUBRESOURCE mapped = {};
-        c.m_pDeviceContext->Map(c.cbAux1, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
+        c.m_pDeviceContext->Map(c.m_thumbnailBoundsBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
         float *constants = static_cast<float *>(mapped.pData);
         if (i == 0)
         {
@@ -869,7 +864,7 @@ void Renderer::CaptureThumbnail(ImageFileBuffer *pngOut)
             constants[2] = 1.0f;
             constants[3] = 1.0f;
         }
-        c.m_pDeviceContext->Unmap(c.cbAux1, 0);
+        c.m_pDeviceContext->Unmap(c.m_thumbnailBoundsBuffer, 0);
         c.m_pDeviceContext->Draw(4, 0);
     }
 
diff --git a/Windows_Libs/Dev/Render/RendererMatrix.cpp b/Windows_Libs/Dev/Render/RendererMatrix.cpp
index 7e96b43..fbd7c53 100644
--- a/Windows_Libs/Dev/Render/RendererMatrix.cpp
+++ b/Windows_Libs/Dev/Render/RendererMatrix.cpp
@@ -105,13 +105,13 @@ void Renderer::Set_matrixDirty()
     const DirectX::XMMATRIX identity = DirectX::XMMatrixIdentity();
 
     c.matrixStacks[MATRIX_MODE_MODELVIEW][0] = identity;
-    c.matrixStacks[MATRIX_MODE_MODELVIEW_UNK1][0] = identity;
-    c.matrixStacks[MATRIX_MODE_MODELVIEW_UNK2][0] = identity;
+    c.matrixStacks[MATRIX_MODE_MODELVIEW_PROJECTION][0] = identity;
+    c.matrixStacks[MATRIX_MODE_MODELVIEW_TEXTURE][0] = identity;
     c.matrixStacks[MATRIX_MODE_MODELVIEW_CBUFF][0] = identity;
 
     c.matrixDirty[MATRIX_MODE_MODELVIEW] = true;
-    c.matrixDirty[MATRIX_MODE_MODELVIEW_UNK1] = true;
-    c.matrixDirty[MATRIX_MODE_MODELVIEW_UNK2] = true;
+    c.matrixDirty[MATRIX_MODE_MODELVIEW_PROJECTION] = true;
+    c.matrixDirty[MATRIX_MODE_MODELVIEW_TEXTURE] = true;
     c.matrixDirty[MATRIX_MODE_MODELVIEW_CBUFF] = true;
 
     activeVertexType = 0xFFFFFFFFu;
diff --git a/Windows_Libs/Dev/Render/RendererState.cpp b/Windows_Libs/Dev/Render/RendererState.cpp
index 2105602..70e9bfe 100644
--- a/Windows_Libs/Dev/Render/RendererState.cpp
+++ b/Windows_Libs/Dev/Render/RendererState.cpp
@@ -222,9 +222,9 @@ void Renderer::StateSetColour(float r, float g, float b, float a)
     const float colour[4] = {r, g, b, a};
 
     D3D11_MAPPED_SUBRESOURCE mapped = {};
-    d3d11->Map(c.cbColour, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
+    d3d11->Map(c.m_tintColorBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
     std::memcpy(mapped.pData, colour, sizeof(colour));
-    d3d11->Unmap(c.cbColour, 0);
+    d3d11->Unmap(c.m_tintColorBuffer, 0);
 }
 
 void Renderer::StateSetDepthMask(bool enable)
@@ -292,9 +292,9 @@ void Renderer::StateSetAlphaFunc(int, float param)
 
     const float alpha[4] = {0.0f, 0.0f, 0.0f, c.alphaTestEnabled ? c.alphaReference : 0.0f};
     D3D11_MAPPED_SUBRESOURCE mapped = {};
-    c.m_pDeviceContext->Map(c.cbAlphaTest, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
+    c.m_pDeviceContext->Map(c.m_alphaTestBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
     std::memcpy(mapped.pData, alpha, sizeof(alpha));
-    c.m_pDeviceContext->Unmap(c.cbAlphaTest, 0);
+    c.m_pDeviceContext->Unmap(c.m_alphaTestBuffer, 0);
 }
 
 void Renderer::StateSetDepthFunc(int func)
@@ -376,9 +376,9 @@ void Renderer::StateSetAlphaTestEnable(bool enable)
 
     const float alpha[4] = {0.0f, 0.0f, 0.0f, enable ? c.alphaReference : 0.0f};
     D3D11_MAPPED_SUBRESOURCE mapped = {};
-    c.m_pDeviceContext->Map(c.cbAlphaTest, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
+    c.m_pDeviceContext->Map(c.m_alphaTestBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
     std::memcpy(mapped.pData, alpha, sizeof(alpha));
-    c.m_pDeviceContext->Unmap(c.cbAlphaTest, 0);
+    c.m_pDeviceContext->Unmap(c.m_alphaTestBuffer, 0);
 }
 
 void Renderer::StateSetDepthSlopeAndBias(float slope, float bias)
@@ -415,13 +415,13 @@ void Renderer::UpdateFogState()
     const float fogColour[4] = {c.fogColourRed, c.fogColourGreen, c.fogColourBlue, 1.0f};
 
     D3D11_MAPPED_SUBRESOURCE mapped = {};
-    d3d11->Map(c.cbFogParams, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
+    d3d11->Map(c.m_fogParamsBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
     std::memcpy(mapped.pData, fogParams, sizeof(fogParams));
-    d3d11->Unmap(c.cbFogParams, 0);
+    d3d11->Unmap(c.m_fogParamsBuffer, 0);
 
-    d3d11->Map(c.cbFogColour, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
+    d3d11->Map(c.m_fogColourBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
     std::memcpy(mapped.pData, fogColour, sizeof(fogColour));
-    d3d11->Unmap(c.cbFogColour, 0);
+    d3d11->Unmap(c.m_fogColourBuffer, 0);
 }
 
 void Renderer::StateSetVertexTextureUV(float u, float v)
@@ -430,9 +430,9 @@ void Renderer::StateSetVertexTextureUV(float u, float v)
     const float texgen[4] = {u - 1.0f, v - 1.0f, 0.0f, 0.0f};
 
     D3D11_MAPPED_SUBRESOURCE mapped = {};
-    c.m_pDeviceContext->Map(c.cbVertexTexcoord, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
+    c.m_pDeviceContext->Map(c.m_vertexTexcoordBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
     std::memcpy(mapped.pData, texgen, sizeof(texgen));
-    c.m_pDeviceContext->Unmap(c.cbVertexTexcoord, 0);
+    c.m_pDeviceContext->Unmap(c.m_vertexTexcoordBuffer, 0);
 }
 
 void Renderer::UpdateTexGenState()
@@ -440,9 +440,9 @@ void Renderer::UpdateTexGenState()
     Context &c = this->getContext();
 
     D3D11_MAPPED_SUBRESOURCE mapped = {};
-    c.m_pDeviceContext->Map(c.cbTexGen, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
+    c.m_pDeviceContext->Map(c.m_texGenMatricesBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
     std::memcpy(mapped.pData, c.texGenMatrices, sizeof(c.texGenMatrices));
-    c.m_pDeviceContext->Unmap(c.cbTexGen, 0);
+    c.m_pDeviceContext->Unmap(c.m_texGenMatricesBuffer, 0);
 }
 
 void Renderer::UpdateLightingState()
@@ -467,9 +467,9 @@ void Renderer::UpdateLightingState()
 
     const std::size_t lightingBytes = sizeof(c.lightDirection) + sizeof(c.lightColour) + sizeof(c.lightAmbientColour);
     D3D11_MAPPED_SUBRESOURCE mapped = {};
-    c.m_pDeviceContext->Map(c.cbLighting, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
+    c.m_pDeviceContext->Map(c.m_lightingStateBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
     std::memcpy(mapped.pData, c.lightDirection, lightingBytes);
-    c.m_pDeviceContext->Unmap(c.cbLighting, 0);
+    c.m_pDeviceContext->Unmap(c.m_lightingStateBuffer, 0);
 
     c.lightingDirty = 0;
 }
diff --git a/Windows_Libs/Dev/Render/RendererVertex.cpp b/Windows_Libs/Dev/Render/RendererVertex.cpp
index 6bd65db..4fbb93d 100644
--- a/Windows_Libs/Dev/Render/RendererVertex.cpp
+++ b/Windows_Libs/Dev/Render/RendererVertex.cpp
@@ -67,20 +67,20 @@ void Renderer::DrawVertexSetup(C4JRender::eVertexType vType, C4JRender::ePixelSh
         c.matrixDirty[MATRIX_MODE_MODELVIEW] = false;
     }
 
-    if (c.matrixDirty[MATRIX_MODE_MODELVIEW_UNK1])
+    if (c.matrixDirty[MATRIX_MODE_MODELVIEW_PROJECTION])
     {
-        d3d11->Map(c.cbMatrix2, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
-        std::memcpy(mapped.pData, this->MatrixGet(MATRIX_MODE_MODELVIEW_UNK1), sizeof(DirectX::XMMATRIX));
-        d3d11->Unmap(c.cbMatrix2, 0);
-        c.matrixDirty[MATRIX_MODE_MODELVIEW_UNK1] = false;
+        d3d11->Map(c.m_projectionMatrix, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
+        std::memcpy(mapped.pData, this->MatrixGet(MATRIX_MODE_MODELVIEW_PROJECTION), sizeof(DirectX::XMMATRIX));
+        d3d11->Unmap(c.m_projectionMatrix, 0);
+        c.matrixDirty[MATRIX_MODE_MODELVIEW_PROJECTION] = false;
     }
 
-    if (c.matrixDirty[MATRIX_MODE_MODELVIEW_UNK2])
+    if (c.matrixDirty[MATRIX_MODE_MODELVIEW_TEXTURE])
     {
-        d3d11->Map(c.cbMatrix3, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
-        std::memcpy(mapped.pData, this->MatrixGet(MATRIX_MODE_MODELVIEW_UNK2), sizeof(DirectX::XMMATRIX));
-        d3d11->Unmap(c.cbMatrix3, 0);
-        c.matrixDirty[MATRIX_MODE_MODELVIEW_UNK2] = false;
+        d3d11->Map(c.m_textureMatrix, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
+        std::memcpy(mapped.pData, this->MatrixGet(MATRIX_MODE_MODELVIEW_TEXTURE), sizeof(DirectX::XMMATRIX));
+        d3d11->Unmap(c.m_textureMatrix, 0);
+        c.matrixDirty[MATRIX_MODE_MODELVIEW_TEXTURE] = false;
     }
 
     this->UpdateFogState();