MCLCE/4JLibs
1
0
Fork 0
mirror of https://github.com/MCLCE/4JLibs.git synced 2026-07-17 20:30:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: change more code conventions and clean up a bit more stuff

Browse Source
This commit is contained in:
3UR
2026-03-03 04:13:45 +10:00
parent 9938bd8ee9
commit 5b3d67063f
5 changed files with 91 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -250,17 +250,19 @@ void Renderer::CommandBuffer::Render(C4JRender::eVertexType vType, Renderer::Con
int shaderVertexType = drawVertexType;
bool matrixOverride = false;
for (std::vector<Command>::const_iterator it = m_commands.begin(); it != m_commands.end(); ++it)
for (const Command &command : m_commands)
{
const Command &command = *it;
switch (command.m_command_type)
{
case COMMAND_ADD_MATRIX:
{
if (drawVertexType == C4JRender::VERTEX_TYPE_COMPRESSED)
{
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]};
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.m_compressedTranslationBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedAux0);
memcpy(mappedAux0.pData, row, sizeof(row));
@@ -352,21 +354,21 @@ void Renderer::CommandBuffer::Render(C4JRender::eVertexType vType, Renderer::Con
}
case COMMAND_SET_DEPTH_MASK:
{
c.depthWriteEnabled = command.set_depth_mask.m_enable ? TRUE : FALSE;
c.depthWriteEnabled = command.set_depth_mask.m_enable;
c.depthStencilDesc.DepthWriteMask = command.set_depth_mask.m_enable ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO;
c.m_pDeviceContext->OMSetDepthStencilState(InternalRenderManager.GetManagedDepthStencilState(), 0);
break;
}
case COMMAND_SET_DEPTH_TEST:
{
c.depthTestEnabled = command.set_depth_test.m_enable ? TRUE : FALSE;
c.depthStencilDesc.DepthEnable = command.set_depth_test.m_enable ? TRUE : FALSE;
c.depthTestEnabled = command.set_depth_test.m_enable;
c.depthStencilDesc.DepthEnable = command.set_depth_test.m_enable;
c.m_pDeviceContext->OMSetDepthStencilState(InternalRenderManager.GetManagedDepthStencilState(), 0);
break;
}
case COMMAND_SET_LIGHTING_ENABLE:
{
c.lightingEnabled = command.set_lighting_enable.m_enable ? TRUE : FALSE;
c.lightingEnabled = command.set_lighting_enable.m_enable;
break;
}
case COMMAND_SET_LIGHT_ENABLE:
@@ -374,8 +376,8 @@ void Renderer::CommandBuffer::Render(C4JRender::eVertexType vType, Renderer::Con
const int light = command.set_light_enable.m_light_index;
if (light >= 0 && light < 2)
{
c.lightEnabled[light] = command.set_light_enable.m_enable ? TRUE : FALSE;
c.lightingDirty = TRUE;
c.lightEnabled[light] = command.set_light_enable.m_enable;
c.lightingDirty = true;
}
break;
}
@@ -388,7 +390,7 @@ void Renderer::CommandBuffer::Render(C4JRender::eVertexType vType, Renderer::Con
c.lightDirection[light].y = command.set_light_direction.m_direction[1];
c.lightDirection[light].z = command.set_light_direction.m_direction[2];
c.lightDirection[light].w = command.set_light_direction.m_direction[3];
c.lightingDirty = TRUE;
c.lightingDirty = true;
}
break;
}
@@ -401,7 +403,7 @@ void Renderer::CommandBuffer::Render(C4JRender::eVertexType vType, Renderer::Con
c.lightColour[light].y = command.set_light_colour.m_color[1];
c.lightColour[light].z = command.set_light_colour.m_color[2];
c.lightColour[light].w = 1.0f;
c.lightingDirty = TRUE;
c.lightingDirty = true;
}
break;
}
@@ -411,36 +413,36 @@ void Renderer::CommandBuffer::Render(C4JRender::eVertexType vType, Renderer::Con
c.lightAmbientColour.y = command.set_light_ambient_colour.m_color[1];
c.lightAmbientColour.z = command.set_light_ambient_colour.m_color[2];
c.lightAmbientColour.w = 1.0f;
c.lightingDirty = TRUE;
c.lightingDirty = true;
break;
}
case COMMAND_SET_BLEND_ENABLE:
{
c.blendDesc.RenderTarget[0].BlendEnable = command.set_blend_enable.m_enable ? TRUE : FALSE;
c.blendDesc.RenderTarget[0].BlendEnable = command.set_blend_enable.m_enable;
break;
}
case COMMAND_SET_BLEND_FUNC:
{
c.blendDesc.RenderTarget[0].SrcBlend = static_cast<D3D11_BLEND>(command.set_blend_func.m_src);
c.blendDesc.RenderTarget[0].DestBlend = static_cast<D3D11_BLEND>(command.set_blend_func.m_dst);
c.m_pDeviceContext->OMSetBlendState(InternalRenderManager.GetManagedBlendState(), c.blendFactor, 0xFFFFFFFFu);
c.m_pDeviceContext->OMSetBlendState(InternalRenderManager.GetManagedBlendState(), c.blendFactor, 0xFFFFFFFF);
break;
}
case COMMAND_SET_BLEND_FACTOR:
{
const unsigned int factor = command.set_blend_factor.m_blend_factor;
c.blendFactor[0] = float((factor >> 0) & 0xFFu) / 255.0f;
c.blendFactor[1] = float((factor >> 8) & 0xFFu) / 255.0f;
c.blendFactor[2] = float((factor >> 16) & 0xFFu) / 255.0f;
c.blendFactor[3] = float((factor >> 24) & 0xFFu) / 255.0f;
c.m_pDeviceContext->OMSetBlendState(InternalRenderManager.GetManagedBlendState(), c.blendFactor, 0xFFFFFFFFu);
c.blendFactor[0] = float((factor >> 0) & 0xFF) / 255.0f;
c.blendFactor[1] = float((factor >> 8) & 0xFF) / 255.0f;
c.blendFactor[2] = float((factor >> 16) & 0xFF) / 255.0f;
c.blendFactor[3] = float((factor >> 24) & 0xFF) / 255.0f;
c.m_pDeviceContext->OMSetBlendState(InternalRenderManager.GetManagedBlendState(), c.blendFactor, 0xFFFFFFFF);
break;
}
case COMMAND_SET_FACE_CULL:
{
c.rasterizerDesc.CullMode = command.set_face_cull.m_enable ? D3D11_CULL_BACK : D3D11_CULL_NONE;
c.m_pDeviceContext->RSSetState(InternalRenderManager.GetManagedRasterizerState());
c.faceCullEnabled = command.set_face_cull.m_enable ? TRUE : FALSE;
c.faceCullEnabled = command.set_face_cull.m_enable;
break;
}
default:

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

@@ -108,9 +108,9 @@ Renderer::Context::Context(ID3D11Device* device, ID3D11DeviceContext* deviceCont
stackPos[i] = 0;
}
blendDesc.AlphaToCoverageEnable = FALSE;
blendDesc.IndependentBlendEnable = FALSE;
blendDesc.RenderTarget[0].BlendEnable = FALSE;
blendDesc.AlphaToCoverageEnable = false;
blendDesc.IndependentBlendEnable = false;
blendDesc.RenderTarget[0].BlendEnable = false;
blendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
blendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_ZERO;
blendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
@@ -119,10 +119,10 @@ Renderer::Context::Context(ID3D11Device* device, ID3D11DeviceContext* deviceCont
blendDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
blendDesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
depthStencilDesc.DepthEnable = TRUE;
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = FALSE;
depthStencilDesc.StencilEnable = false;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
@@ -136,14 +136,14 @@ Renderer::Context::Context(ID3D11Device* device, ID3D11DeviceContext* deviceCont
rasterizerDesc.FillMode = D3D11_FILL_SOLID;
rasterizerDesc.CullMode = D3D11_CULL_BACK;
rasterizerDesc.FrontCounterClockwise = TRUE;
rasterizerDesc.FrontCounterClockwise = true;
rasterizerDesc.DepthBias = 0;
rasterizerDesc.DepthBiasClamp = 0.0f;
rasterizerDesc.SlopeScaledDepthBias = 0.0f;
rasterizerDesc.DepthClipEnable = TRUE;
rasterizerDesc.ScissorEnable = FALSE;
rasterizerDesc.MultisampleEnable = TRUE;
rasterizerDesc.AntialiasedLineEnable = FALSE;
rasterizerDesc.DepthClipEnable = true;
rasterizerDesc.ScissorEnable = false;
rasterizerDesc.MultisampleEnable = true;
rasterizerDesc.AntialiasedLineEnable = false;
memset(lightDirection, 0, sizeof(lightDirection));
memset(lightColour, 0, sizeof(lightColour));
@@ -233,9 +233,9 @@ void Renderer::Clear(int flags, D3D11_RECT *)
ID3D11RasterizerState *rasterizerState = NULL;
D3D11_BLEND_DESC blendDesc = {};
blendDesc.AlphaToCoverageEnable = FALSE;
blendDesc.IndependentBlendEnable = FALSE;
blendDesc.RenderTarget[0].BlendEnable = FALSE;
blendDesc.AlphaToCoverageEnable = false;
blendDesc.IndependentBlendEnable = false;
blendDesc.RenderTarget[0].BlendEnable = false;
blendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
blendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_ZERO;
blendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
@@ -246,12 +246,12 @@ void Renderer::Clear(int flags, D3D11_RECT *)
m_pDevice->CreateBlendState(&blendDesc, &blendState);
D3D11_DEPTH_STENCIL_DESC depthDesc = {};
depthDesc.DepthEnable = (flags & CLEAR_DEPTH_FLAG) ? TRUE : FALSE;
depthDesc.DepthEnable = (flags & CLEAR_DEPTH_FLAG) ? true : false;
depthDesc.DepthWriteMask = depthDesc.DepthEnable ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO;
depthDesc.DepthFunc = D3D11_COMPARISON_ALWAYS;
depthDesc.StencilEnable = FALSE;
depthDesc.StencilReadMask = 0xFFu;
depthDesc.StencilWriteMask = 0xFFu;
depthDesc.StencilEnable = false;
depthDesc.StencilReadMask = 0xFF;
depthDesc.StencilWriteMask = 0xFF;
depthDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
depthDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
@@ -265,8 +265,8 @@ void Renderer::Clear(int flags, D3D11_RECT *)
D3D11_RASTERIZER_DESC rasterDesc = {};
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.CullMode = D3D11_CULL_NONE;
rasterDesc.DepthClipEnable = TRUE;
rasterDesc.MultisampleEnable = TRUE;
rasterDesc.DepthClipEnable = true;
rasterDesc.MultisampleEnable = true;
m_pDevice->CreateRasterizerState(&rasterDesc, &rasterizerState);
c.m_pDeviceContext->VSSetShader(screenClearVertexShader, NULL, 0);
@@ -818,7 +818,7 @@ void Renderer::CaptureThumbnail(ImageFileBuffer *pngOut)
ID3D11Texture2D *stagingTexture = NULL;
D3D11_BLEND_DESC blendDesc = {};
blendDesc.RenderTarget[0].BlendEnable = FALSE;
blendDesc.RenderTarget[0].BlendEnable = false;
blendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
blendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_ZERO;
blendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
@@ -829,10 +829,10 @@ void Renderer::CaptureThumbnail(ImageFileBuffer *pngOut)
m_pDevice->CreateBlendState(&blendDesc, &blendState);
D3D11_DEPTH_STENCIL_DESC depthDesc = {};
depthDesc.DepthEnable = FALSE;
depthDesc.DepthEnable = false;
depthDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
depthDesc.DepthFunc = D3D11_COMPARISON_ALWAYS;
depthDesc.StencilEnable = FALSE;
depthDesc.StencilEnable = false;
depthDesc.StencilReadMask = 0xFF;
depthDesc.StencilWriteMask = 0xFF;
depthDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
@@ -845,8 +845,8 @@ void Renderer::CaptureThumbnail(ImageFileBuffer *pngOut)
D3D11_RASTERIZER_DESC rasterDesc = {};
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.CullMode = D3D11_CULL_NONE;
rasterDesc.DepthClipEnable = TRUE;
rasterDesc.MultisampleEnable = TRUE;
rasterDesc.DepthClipEnable = true;
rasterDesc.MultisampleEnable = true;
m_pDevice->CreateRasterizerState(&rasterDesc, &rasterizerState);
D3D11_SAMPLER_DESC samplerDesc = {};

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

@@ -5,14 +5,14 @@
const float *Renderer::MatrixGet(int type)
{
Context &c = this->getContext();
Context &c = getContext();
const int depth = c.stackPos[type];
return reinterpret_cast<const float *>(&c.matrixStacks[type][depth]);
}
void Renderer::MatrixMode(int type)
{
Context &c = this->getContext();
Context &c = getContext();
assert(type >= 0);
assert(type < STACK_TYPES);
c.stackType = type;
@@ -22,25 +22,25 @@ void Renderer::MatrixMult(float *mat)
{
DirectX::XMMATRIX matrix;
std::memcpy(&matrix, mat, sizeof(matrix));
this->MultWithStack(matrix);
MultWithStack(matrix);
}
void Renderer::MatrixOrthogonal(float left, float right, float bottom, float top, float zNear, float zFar)
{
const DirectX::XMMATRIX matrix = DirectX::XMMatrixOrthographicOffCenterRH(left, right, bottom, top, zNear, zFar);
this->MultWithStack(matrix);
MultWithStack(matrix);
}
void Renderer::MatrixPerspective(float fovy, float aspect, float zNear, float zFar)
{
const float fovRadians = fovy * (3.14159274f / 180.0f);
const DirectX::XMMATRIX matrix = DirectX::XMMatrixPerspectiveFovRH(fovRadians, aspect, zNear, zFar);
this->MultWithStack(matrix);
MultWithStack(matrix);
}
void Renderer::MatrixPop()
{
Context &c = this->getContext();
Context &c = getContext();
assert(c.stackPos[c.stackType] > 0);
@@ -51,7 +51,7 @@ void Renderer::MatrixPop()
void Renderer::MatrixPush()
{
Context &c = this->getContext();
Context &c = getContext();
assert(c.stackPos[c.stackType] < (STACK_SIZE - 1));
@@ -65,18 +65,18 @@ void Renderer::MatrixRotate(float angle, float x, float y, float z)
{
const DirectX::XMVECTOR axis = DirectX::XMVectorSet(x, y, z, 0.0f);
const DirectX::XMMATRIX matrix = DirectX::XMMatrixRotationAxis(axis, angle);
this->MultWithStack(matrix);
MultWithStack(matrix);
}
void Renderer::MatrixScale(float x, float y, float z)
{
const DirectX::XMMATRIX matrix = DirectX::XMMatrixScaling(x, y, z);
this->MultWithStack(matrix);
MultWithStack(matrix);
}
void Renderer::MatrixSetIdentity()
{
Context &c = this->getContext();
Context &c = getContext();
const int mode = c.stackType;
const int depth = c.stackPos[mode];
c.matrixStacks[mode][depth] = DirectX::XMMatrixIdentity();
@@ -86,12 +86,12 @@ void Renderer::MatrixSetIdentity()
void Renderer::MatrixTranslate(float x, float y, float z)
{
const DirectX::XMMATRIX matrix = DirectX::XMMatrixTranslation(x, y, z);
this->MultWithStack(matrix);
MultWithStack(matrix);
}
void Renderer::MultWithStack(DirectX::XMMATRIX matrix)
{
Context &c = this->getContext();
Context &c = getContext();
const int mode = c.stackType;
const int depth = c.stackPos[mode];
DirectX::XMMATRIX &current = c.matrixStacks[mode][depth];
@@ -101,7 +101,7 @@ void Renderer::MultWithStack(DirectX::XMMATRIX matrix)
void Renderer::Set_matrixDirty()
{
Context &c = this->getContext();
Context &c = getContext();
const DirectX::XMMATRIX identity = DirectX::XMMatrixIdentity();
c.matrixStacks[MATRIX_MODE_MODELVIEW][0] = identity;
@@ -114,6 +114,6 @@ void Renderer::Set_matrixDirty()
c.matrixDirty[MATRIX_MODE_MODELVIEW_TEXTURE] = true;
c.matrixDirty[MATRIX_MODE_MODELVIEW_CBUFF] = true;
activeVertexType = 0xFFFFFFFFu;
activePixelType = 0xFFFFFFFFu;
activeVertexType = -1;
activePixelType = -1;
}

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

@@ -96,7 +96,7 @@ ID3D11SamplerState *Renderer::GetManagedSamplerState()
void Renderer::StateSetFogEnable(bool enable)
{
Context &c = getContext();
c.fogEnabled = enable ? TRUE : FALSE;
c.fogEnabled = enable;
}
void Renderer::StateSetFogMode(int mode)
@@ -142,7 +142,7 @@ void Renderer::StateSetLightingEnable(bool enable)
return;
}
c.lightingEnabled = enable ? TRUE : FALSE;
c.lightingEnabled = enable;
}
void Renderer::StateSetLightColour(int light, float red, float green, float blue)
@@ -161,7 +161,7 @@ void Renderer::StateSetLightColour(int light, float red, float green, float blue
c.lightColour[light].y = green;
c.lightColour[light].z = blue;
c.lightColour[light].w = 1.0f;
c.lightingDirty = TRUE;
c.lightingDirty = true;
}
void Renderer::StateSetLightAmbientColour(float red, float green, float blue)
@@ -177,7 +177,7 @@ void Renderer::StateSetLightAmbientColour(float red, float green, float blue)
c.lightAmbientColour.y = green;
c.lightAmbientColour.z = blue;
c.lightAmbientColour.w = 1.0f;
c.lightingDirty = TRUE;
c.lightingDirty = true;
}
void Renderer::StateSetLightEnable(int light, bool enable)
@@ -192,8 +192,8 @@ void Renderer::StateSetLightEnable(int light, bool enable)
return;
}
c.lightEnabled[light] = enable ? TRUE : FALSE;
c.lightingDirty = TRUE;
c.lightEnabled[light] = enable;
c.lightingDirty = true;
}
void Renderer::StateSetColour(float r, float g, float b, float a)
@@ -225,7 +225,7 @@ void Renderer::StateSetDepthMask(bool enable)
c.depthStencilDesc.DepthWriteMask = enable ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO;
c.m_pDeviceContext->OMSetDepthStencilState(GetManagedDepthStencilState(), 0);
c.depthWriteEnabled = enable ? TRUE : FALSE;
c.depthWriteEnabled = enable;
}
void Renderer::StateSetBlendEnable(bool enable)
@@ -237,8 +237,8 @@ void Renderer::StateSetBlendEnable(bool enable)
return;
}
c.blendDesc.RenderTarget[0].BlendEnable = enable ? TRUE : FALSE;
c.m_pDeviceContext->OMSetBlendState(GetManagedBlendState(), c.blendFactor, 0xFFFFFFFFu);
c.blendDesc.RenderTarget[0].BlendEnable = enable;
c.m_pDeviceContext->OMSetBlendState(GetManagedBlendState(), c.blendFactor, 0xFFFFFFFF);
}
void Renderer::StateSetBlendFunc(int src, int dst)
@@ -252,7 +252,7 @@ void Renderer::StateSetBlendFunc(int src, int dst)
c.blendDesc.RenderTarget[0].SrcBlend = static_cast<D3D11_BLEND>(src);
c.blendDesc.RenderTarget[0].DestBlend = static_cast<D3D11_BLEND>(dst);
c.m_pDeviceContext->OMSetBlendState(GetManagedBlendState(), c.blendFactor, 0xFFFFFFFFu);
c.m_pDeviceContext->OMSetBlendState(GetManagedBlendState(), c.blendFactor, 0xFFFFFFFF);
}
void Renderer::StateSetBlendFactor(unsigned int colour)
@@ -265,11 +265,11 @@ void Renderer::StateSetBlendFactor(unsigned int colour)
}
const float scale = 255.0f;
c.blendFactor[0] = static_cast<float>((colour >> 0) & 0xFFu) / scale;
c.blendFactor[1] = static_cast<float>((colour >> 8) & 0xFFu) / scale;
c.blendFactor[2] = static_cast<float>((colour >> 16) & 0xFFu) / scale;
c.blendFactor[3] = static_cast<float>((colour >> 24) & 0xFFu) / scale;
c.m_pDeviceContext->OMSetBlendState(GetManagedBlendState(), c.blendFactor, 0xFFFFFFFFu);
c.blendFactor[0] = static_cast<float>((colour >> 0) & 0xFF) / scale;
c.blendFactor[1] = static_cast<float>((colour >> 8) & 0xFF) / scale;
c.blendFactor[2] = static_cast<float>((colour >> 16) & 0xFF) / scale;
c.blendFactor[3] = static_cast<float>((colour >> 24) & 0xFF) / scale;
c.m_pDeviceContext->OMSetBlendState(GetManagedBlendState(), c.blendFactor, 0xFFFFFFFF);
}
void Renderer::StateSetAlphaFunc(int, float param)
@@ -308,7 +308,7 @@ void Renderer::StateSetFaceCull(bool enable)
c.rasterizerDesc.CullMode = enable ? D3D11_CULL_BACK : D3D11_CULL_NONE;
c.m_pDeviceContext->RSSetState(GetManagedRasterizerState());
c.faceCullEnabled = enable ? TRUE : FALSE;
c.faceCullEnabled = enable;
}
void Renderer::StateSetFaceCullCW(bool enable)
@@ -335,7 +335,7 @@ void Renderer::StateSetWriteEnable(bool red, bool green, bool blue, bool alpha)
mask |= alpha ? 0x8 : 0;
c.blendDesc.RenderTarget[0].RenderTargetWriteMask = mask;
c.m_pDeviceContext->OMSetBlendState(GetManagedBlendState(), c.blendFactor, 0xFFFFFFFFu);
c.m_pDeviceContext->OMSetBlendState(GetManagedBlendState(), c.blendFactor, 0xFFFFFFFF);
}
void Renderer::StateSetDepthTestEnable(bool enable)
@@ -347,15 +347,15 @@ void Renderer::StateSetDepthTestEnable(bool enable)
return;
}
c.depthStencilDesc.DepthEnable = enable ? TRUE : FALSE;
c.depthStencilDesc.DepthEnable = enable;
c.m_pDeviceContext->OMSetDepthStencilState(GetManagedDepthStencilState(), 0);
c.depthTestEnabled = enable ? TRUE : FALSE;
c.depthTestEnabled = enable;
}
void Renderer::StateSetAlphaTestEnable(bool enable)
{
Context &c = getContext();
c.alphaTestEnabled = enable ? TRUE : FALSE;
c.alphaTestEnabled = enable;
const float alpha[4] = {0.0f, 0.0f, 0.0f, enable ? c.alphaReference : 0.0f};
D3D11_MAPPED_SUBRESOURCE mapped = {};
@@ -454,7 +454,7 @@ void Renderer::UpdateLightingState()
std::memcpy(mapped.pData, c.lightDirection, lightingBytes);
c.m_pDeviceContext->Unmap(c.m_lightingStateBuffer, 0);
c.lightingDirty = FALSE;
c.lightingDirty = false;
}
void Renderer::StateSetLightDirection(int light, float x, float y, float z)
@@ -476,7 +476,7 @@ void Renderer::StateSetLightDirection(int light, float x, float y, float z)
const DirectX::XMVECTOR normalized = DirectX::XMVector3Normalize(transformed);
DirectX::XMStoreFloat4(&c.lightDirection[light], normalized);
c.lightingDirty = TRUE;
c.lightingDirty = true;
}
void Renderer::StateSetViewport(C4JRender::eViewportType viewportType)
@@ -588,7 +588,7 @@ void Renderer::StateSetStencil(D3D11_COMPARISON_FUNC function, uint8_t stencil_r
Context &c = getContext();
D3D11_DEPTH_STENCIL_DESC desc = c.depthStencilDesc;
desc.StencilEnable = TRUE;
desc.StencilEnable = true;
desc.StencilReadMask = stencil_func_mask;
desc.StencilWriteMask = stencil_write_mask;
desc.FrontFace.StencilFunc = function;

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

@@ -127,22 +127,22 @@ void Renderer::DrawVertices(C4JRender::ePrimitiveType PrimitiveType, int count,
assert(vertexBytes <= Context::VERTEX_BUFFER_SIZE);
if (c.dynamicVertexOffset + vertexBytes > Context::VERTEX_BUFFER_SIZE)
c.dynamicVertexOffset = 0;
UINT vertexOffset = c.dynamicVertexOffset;
if (vertexOffset + vertexBytes > Context::VERTEX_BUFFER_SIZE)
vertexOffset = 0;
D3D11_MAPPED_SUBRESOURCE mapped = {};
const D3D11_MAP mapType = c.dynamicVertexOffset == 0 ? D3D11_MAP_WRITE_DISCARD : D3D11_MAP_WRITE_NO_OVERWRITE;
const D3D11_MAP mapType = vertexOffset == 0 ? D3D11_MAP_WRITE_DISCARD : D3D11_MAP_WRITE_NO_OVERWRITE;
const HRESULT hr = d3d11->Map(c.dynamicVertexBuffer, 0, mapType, 0, &mapped);
if (FAILED(hr))
printf("ERROR: 0x%x\n", static_cast<unsigned int>(hr));
memcpy(reinterpret_cast<std::uint8_t *>(mapped.pData) + c.dynamicVertexOffset, vertices, vertexBytes);
memcpy(reinterpret_cast<std::uint8_t *>(mapped.pData) + vertexOffset, vertices, vertexBytes);
d3d11->Unmap(c.dynamicVertexBuffer, 0);
StateUpdate();
ID3D11Buffer *dynamicBuffer = c.dynamicVertexBuffer;
const UINT vertexOffset = c.dynamicVertexOffset;
d3d11->IASetVertexBuffers(0, 1, &dynamicBuffer, &stride, &vertexOffset);
if (indexed)
@@ -150,5 +150,5 @@ void Renderer::DrawVertices(C4JRender::ePrimitiveType PrimitiveType, int count,
else
d3d11->Draw(count, 0);
c.dynamicVertexOffset += vertexBytes;
c.dynamicVertexOffset = vertexOffset + vertexBytes;
}