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