LegacyConsole/Patoke-4JLibs
3
0
Fork 0
mirror of https://github.com/Patoke/4JLibs.git synced 2026-06-05 15:14:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: match more names

Browse Source
This commit is contained in:
Patoke
2026-03-01 22:37:54 -03:00
parent b724041d1f
commit 0b1a1bfdd4
6 changed files with 164 additions and 209 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
Windows_Libs/Dev/Render/Renderer.h
View File

@@ -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;

168
Windows_Libs/Dev/Render/RendererCBuff.cpp
View File

@@ -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);

81
Windows_Libs/Dev/Render/RendererCore.cpp
View File

@@ -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);
}

8
Windows_Libs/Dev/Render/RendererMatrix.cpp
View File

@@ -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;

32
Windows_Libs/Dev/Render/RendererState.cpp
View File

@@ -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;
}

20
Windows_Libs/Dev/Render/RendererVertex.cpp
View File

@@ -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();