MCLCE/4JLibs
1
0
Fork 0
mirror of https://github.com/MCLCE/4JLibs.git synced 2026-07-18 04:40:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: add .clang_format for consistent code formatting

Browse Source
This commit is contained in:
Patoke
2026-03-01 20:03:40 -03:00
parent 67332bbc79
commit 6e6440f0f3
25 changed files with 3960 additions and 4000 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Windows_Libs/Dev/Render/4J_Render.cpp
View File

@@ -2,8 +2,11 @@
#include "4J_Render.h"
#include "Renderer.h"
C4JRender RenderManager;
void C4JRender::Tick()
{
InternalRenderManager.CBuffTick();
}
void C4JRender::UpdateGamma(unsigned short usGamma)
@@ -474,5 +477,3 @@ void C4JRender::Resume()
{
InternalRenderManager.Resume();
}
C4JRender RenderManager;

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

@@ -9,441 +9,439 @@
class Renderer
{
public:
struct Context;
struct CommandBuffer;
void Tick();
void UpdateGamma(unsigned short usGamma);
void MatrixMode(int type);
void MatrixSetIdentity();
void MatrixTranslate(float x, float y, float z);
void MatrixRotate(float angle, float x, float y, float z);
void MatrixScale(float x, float y, float z);
void MatrixPerspective(float fovy, float aspect, float zNear, float zFar);
void MatrixOrthogonal(float left, float right, float bottom, float top, float zNear, float zFar);
void MatrixPop();
void MatrixPush();
void MatrixMult(float* mat);
const float* MatrixGet(int type);
void Set_matrixDirty();
void Initialise(ID3D11Device* pDevice, IDXGISwapChain* pSwapChain);
ID3D11DeviceContext* InitialiseContext(bool fromPresent);
void StartFrame();
void DoScreenGrabOnNextPresent();
void Present();
void Clear(int flags, D3D11_RECT* pRect);
void SetClearColour(const float colourRGBA[4]);
bool IsWidescreen();
bool IsHiDef();
void CaptureThumbnail(ImageFileBuffer* pngOut);
void CaptureScreen(ImageFileBuffer* jpgOut, XSOCIAL_PREVIEWIMAGE* previewOut);
void BeginConditionalSurvey(int identifier);
void EndConditionalSurvey();
void BeginConditionalRendering(int identifier);
void EndConditionalRendering();
void DrawVertices(C4JRender::ePrimitiveType PrimitiveType, int count, void* dataIn, C4JRender::eVertexType vType, C4JRender::ePixelShaderType psType);
void DrawVertexBuffer(C4JRender::ePrimitiveType PrimitiveType, int count, ID3D11Buffer* buffer, C4JRender::eVertexType vType, C4JRender::ePixelShaderType psType);
void CBuffLockStaticCreations();
int CBuffCreate(int count);
void CBuffDelete(int first, int count);
void CBuffStart(int index, bool full);
void CBuffClear(int index);
int CBuffSize(int index);
void CBuffEnd();
bool CBuffCall(int index, bool full);
void CBuffTick();
void CBuffDeferredModeStart();
void CBuffDeferredModeEnd();
int TextureCreate();
void TextureFree(int idx);
void TextureBind(int idx);
void TextureBindVertex(int idx);
void TextureSetTextureLevels(int levels);
int TextureGetTextureLevels();
void TextureSetParam(int param, int value);
void TextureDynamicUpdateStart();
void TextureDynamicUpdateEnd();
void TextureData(int width, int height, void* data, int level, C4JRender::eTextureFormat format);
void TextureDataUpdate(int xoffset, int yoffset, int width, int height, void* data, int level);
HRESULT LoadTextureData(const char* szFilename, D3DXIMAGE_INFO* pSrcInfo, int** ppDataOut);
HRESULT LoadTextureData(BYTE* pbData, DWORD dwBytes, D3DXIMAGE_INFO* pSrcInfo, int** ppDataOut);
HRESULT SaveTextureData(const char* szFilename, D3DXIMAGE_INFO* pSrcInfo, int* ppDataOut);
HRESULT SaveTextureDataToMemory(void* pOutput, int outputCapacity, int* outputLength, int width, int height, int* ppDataIn);
void TextureGetStats();
ID3D11ShaderResourceView* TextureGetTexture(int idx);
void StateSetColour(float r, float g, float b, float a);
void StateSetDepthMask(bool enable);
void StateSetBlendEnable(bool enable);
void StateSetBlendFunc(int src, int dst);
void StateSetBlendFactor(unsigned int colour);
void StateSetAlphaFunc(int func, float param);
void StateSetDepthFunc(int func);
void StateSetFaceCull(bool enable);
void StateSetFaceCullCW(bool enable);
void StateSetLineWidth(float width);
void StateSetWriteEnable(bool red, bool green, bool blue, bool alpha);
void StateSetDepthTestEnable(bool enable);
void StateSetAlphaTestEnable(bool enable);
void StateSetDepthSlopeAndBias(float slope, float bias);
void StateSetFogEnable(bool enable);
void StateSetFogMode(int mode);
void StateSetFogNearDistance(float dist);
void StateSetFogFarDistance(float dist);
void StateSetFogDensity(float density);
void StateSetFogColour(float red, float green, float blue);
void StateSetLightingEnable(bool enable);
void StateSetVertexTextureUV(float u, float v);
void StateSetLightColour(int light, float red, float green, float blue);
void StateSetLightAmbientColour(float red, float green, float blue);
void StateSetLightDirection(int light, float x, float y, float z);
void StateSetLightEnable(int light, bool enable);
void StateSetViewport(C4JRender::eViewportType viewportType);
void StateSetEnableViewportClipPlanes(bool enable);
void StateSetTexGenCol(int col, float x, float y, float z, float w, bool eyeSpace);
void StateSetStencil(D3D11_COMPARISON_FUNC function, uint8_t stencil_ref, uint8_t stencil_func_mask, uint8_t stencil_write_mask);
void StateSetForceLOD(int LOD);
void BeginEvent(LPCWSTR eventName);
void EndEvent();
void Suspend();
bool Suspended();
void Resume();
void StateUpdate();
struct Context;
struct CommandBuffer;
void Tick();
void UpdateGamma(unsigned short usGamma);
void MatrixMode(int type);
void MatrixSetIdentity();
void MatrixTranslate(float x, float y, float z);
void MatrixRotate(float angle, float x, float y, float z);
void MatrixScale(float x, float y, float z);
void MatrixPerspective(float fovy, float aspect, float zNear, float zFar);
void MatrixOrthogonal(float left, float right, float bottom, float top, float zNear, float zFar);
void MatrixPop();
void MatrixPush();
void MatrixMult(float *mat);
const float *MatrixGet(int type);
void Set_matrixDirty();
void Initialise(ID3D11Device *pDevice, IDXGISwapChain *pSwapChain);
ID3D11DeviceContext *InitialiseContext(bool fromPresent);
void StartFrame();
void DoScreenGrabOnNextPresent();
void Present();
void Clear(int flags, D3D11_RECT *pRect);
void SetClearColour(const float colourRGBA[4]);
bool IsWidescreen();
bool IsHiDef();
void CaptureThumbnail(ImageFileBuffer *pngOut);
void CaptureScreen(ImageFileBuffer *jpgOut, XSOCIAL_PREVIEWIMAGE *previewOut);
void BeginConditionalSurvey(int identifier);
void EndConditionalSurvey();
void BeginConditionalRendering(int identifier);
void EndConditionalRendering();
void DrawVertices(C4JRender::ePrimitiveType PrimitiveType, int count, void *dataIn, C4JRender::eVertexType vType,
C4JRender::ePixelShaderType psType);
void DrawVertexBuffer(C4JRender::ePrimitiveType PrimitiveType, int count, ID3D11Buffer *buffer, C4JRender::eVertexType vType,
C4JRender::ePixelShaderType psType);
void CBuffLockStaticCreations();
int CBuffCreate(int count);
void CBuffDelete(int first, int count);
void CBuffStart(int index, bool full);
void CBuffClear(int index);
int CBuffSize(int index);
void CBuffEnd();
bool CBuffCall(int index, bool full);
void CBuffTick();
void CBuffDeferredModeStart();
void CBuffDeferredModeEnd();
int TextureCreate();
void TextureFree(int idx);
void TextureBind(int idx);
void TextureBindVertex(int idx);
void TextureSetTextureLevels(int levels);
int TextureGetTextureLevels();
void TextureSetParam(int param, int value);
void TextureDynamicUpdateStart();
void TextureDynamicUpdateEnd();
void TextureData(int width, int height, void *data, int level, C4JRender::eTextureFormat format);
void TextureDataUpdate(int xoffset, int yoffset, int width, int height, void *data, int level);
HRESULT LoadTextureData(const char *szFilename, D3DXIMAGE_INFO *pSrcInfo, int **ppDataOut);
HRESULT LoadTextureData(BYTE *pbData, DWORD dwBytes, D3DXIMAGE_INFO *pSrcInfo, int **ppDataOut);
HRESULT SaveTextureData(const char *szFilename, D3DXIMAGE_INFO *pSrcInfo, int *ppDataOut);
HRESULT SaveTextureDataToMemory(void *pOutput, int outputCapacity, int *outputLength, int width, int height, int *ppDataIn);
void TextureGetStats();
ID3D11ShaderResourceView *TextureGetTexture(int idx);
void StateSetColour(float r, float g, float b, float a);
void StateSetDepthMask(bool enable);
void StateSetBlendEnable(bool enable);
void StateSetBlendFunc(int src, int dst);
void StateSetBlendFactor(unsigned int colour);
void StateSetAlphaFunc(int func, float param);
void StateSetDepthFunc(int func);
void StateSetFaceCull(bool enable);
void StateSetFaceCullCW(bool enable);
void StateSetLineWidth(float width);
void StateSetWriteEnable(bool red, bool green, bool blue, bool alpha);
void StateSetDepthTestEnable(bool enable);
void StateSetAlphaTestEnable(bool enable);
void StateSetDepthSlopeAndBias(float slope, float bias);
void StateSetFogEnable(bool enable);
void StateSetFogMode(int mode);
void StateSetFogNearDistance(float dist);
void StateSetFogFarDistance(float dist);
void StateSetFogDensity(float density);
void StateSetFogColour(float red, float green, float blue);
void StateSetLightingEnable(bool enable);
void StateSetVertexTextureUV(float u, float v);
void StateSetLightColour(int light, float red, float green, float blue);
void StateSetLightAmbientColour(float red, float green, float blue);
void StateSetLightDirection(int light, float x, float y, float z);
void StateSetLightEnable(int light, bool enable);
void StateSetViewport(C4JRender::eViewportType viewportType);
void StateSetEnableViewportClipPlanes(bool enable);
void StateSetTexGenCol(int col, float x, float y, float z, float w, bool eyeSpace);
void StateSetStencil(D3D11_COMPARISON_FUNC function, uint8_t stencil_ref, uint8_t stencil_func_mask, uint8_t stencil_write_mask);
void StateSetForceLOD(int LOD);
void BeginEvent(LPCWSTR eventName);
void EndEvent();
void Suspend();
bool Suspended();
void Resume();
void StateUpdate();
private:
void SetupShaders();
void ConvertLinearToPng(ImageFileBuffer* pngOut, unsigned char* linearData, unsigned int width, unsigned int height);
void DrawVertexSetup(C4JRender::eVertexType vType, C4JRender::ePixelShaderType psType, C4JRender::ePrimitiveType primitiveType, int* count, bool* drawIndexed);
void UpdateTexGenState();
void UpdateLightingState();
void UpdateViewportState();
void UpdateFogState();
void UpdateTextureState(bool vertexSampler);
void MultWithStack(DirectX::XMMATRIX matrix);
ID3D11DepthStencilState* GetManagedDepthStencilState();
ID3D11BlendState* GetManagedBlendState();
ID3D11RasterizerState* GetManagedRasterizerState();
ID3D11SamplerState* GetManagedSamplerState();
void DeleteInternalBuffer(int index);
Renderer::Context& getContext();
static D3D11_PRIMITIVE_TOPOLOGY* m_Topologies;
static DXGI_FORMAT textureFormats[C4JRender::MAX_TEXTURE_FORMATS];
void SetupShaders();
void ConvertLinearToPng(ImageFileBuffer *pngOut, unsigned char *linearData, unsigned int width, unsigned int height);
void DrawVertexSetup(C4JRender::eVertexType vType, C4JRender::ePixelShaderType psType, C4JRender::ePrimitiveType primitiveType, int *count,
bool *drawIndexed);
void UpdateTexGenState();
void UpdateLightingState();
void UpdateViewportState();
void UpdateFogState();
void UpdateTextureState(bool vertexSampler);
void MultWithStack(DirectX::XMMATRIX matrix);
ID3D11DepthStencilState *GetManagedDepthStencilState();
ID3D11BlendState *GetManagedBlendState();
ID3D11RasterizerState *GetManagedRasterizerState();
ID3D11SamplerState *GetManagedSamplerState();
void DeleteInternalBuffer(int index);
Renderer::Context &getContext();
static D3D11_PRIMITIVE_TOPOLOGY *m_Topologies;
static DXGI_FORMAT textureFormats[C4JRender::MAX_TEXTURE_FORMATS];
public:
struct Texture
{
bool allocated;
ID3D11Texture2D *texture;
ID3D11ShaderResourceView *view;
DWORD textureFlags;
DWORD mipLevels;
DWORD textureFormat;
DWORD samplerParams;
};
struct Texture
{
bool allocated;
ID3D11Texture2D* texture;
ID3D11ShaderResourceView* view;
DWORD textureFlags;
DWORD mipLevels;
DWORD textureFormat;
DWORD samplerParams;
};
struct TexgenCBuffer
{
DirectX::XMMATRIX unk0;
DirectX::XMMATRIX unk1;
};
struct TexgenCBuffer
{
DirectX::XMMATRIX unk0;
DirectX::XMMATRIX unk1;
};
enum eCommandType
{
COMMAND_ADD_MATRIX,
COMMAND_ADD_VERTICES,
COMMAND_BIND_TEXTURE,
COMMAND_SET_COLOR,
COMMAND_SET_DEPTH_FUNC,
COMMAND_SET_DEPTH_MASK,
COMMAND_SET_DEPTH_TEST,
COMMAND_SET_LIGHTING_ENABLE,
COMMAND_SET_LIGHT_ENABLE,
COMMAND_SET_LIGHT_DIRECTION,
COMMAND_SET_LIGHT_COLOUR,
COMMAND_SET_LIGHT_AMBIENT_COLOUR,
COMMAND_SET_BLEND_ENABLE,
COMMAND_SET_BLEND_FUNC,
COMMAND_SET_BLEND_FACTOR,
COMMAND_SET_FACE_CULL,
};
enum eCommandType
{
COMMAND_ADD_MATRIX,
COMMAND_ADD_VERTICES,
COMMAND_BIND_TEXTURE,
COMMAND_SET_COLOR,
COMMAND_SET_DEPTH_FUNC,
COMMAND_SET_DEPTH_MASK,
COMMAND_SET_DEPTH_TEST,
COMMAND_SET_LIGHTING_ENABLE,
COMMAND_SET_LIGHT_ENABLE,
COMMAND_SET_LIGHT_DIRECTION,
COMMAND_SET_LIGHT_COLOUR,
COMMAND_SET_LIGHT_AMBIENT_COLOUR,
COMMAND_SET_BLEND_ENABLE,
COMMAND_SET_BLEND_FUNC,
COMMAND_SET_BLEND_FACTOR,
COMMAND_SET_FACE_CULL,
};
struct CommandBuffer
{
CommandBuffer(bool full);
~CommandBuffer();
void StartRecording();
void EndRecording(ID3D11Device *device);
std::uint64_t GetAllocated();
bool IsBusy();
void AddMatrix(const float *matrix);
void AddVertices(unsigned int stride, unsigned int count, void *dataIn, Renderer::Context &context);
void BindTexture(int idx);
void SetColor(float r, float g, float b, float a);
void SetDepthFunc(int func);
void SetDepthMask(bool enable);
void SetDepthTestEnable(bool enable);
void SetLightingEnable(bool enable);
void SetLightEnable(int light, bool enable);
void SetLightDirection(int light, float x, float y, float z);
void SetLightColour(int light, float r, float g, float b);
void SetLightAmbientColour(float r, float g, float b);
void SetBlendEnable(bool enable);
void SetBlendFunc(int src, int dst);
void SetBlendFactor(unsigned int factor);
void SetFaceCull(bool enable);
void Render(C4JRender::eVertexType vertexType, Renderer::Context &context, int primitiveType);
struct CommandBuffer
{
CommandBuffer(bool full);
~CommandBuffer();
void StartRecording();
void EndRecording(ID3D11Device* device);
std::uint64_t GetAllocated();
bool IsBusy();
void AddMatrix(const float* matrix);
void AddVertices(unsigned int stride, unsigned int count, void* dataIn, Renderer::Context& context);
void BindTexture(int idx);
void SetColor(float r, float g, float b, float a);
void SetDepthFunc(int func);
void SetDepthMask(bool enable);
void SetDepthTestEnable(bool enable);
void SetLightingEnable(bool enable);
void SetLightEnable(int light, bool enable);
void SetLightDirection(int light, float x, float y, float z);
void SetLightColour(int light, float r, float g, float b);
void SetLightAmbientColour(float r, float g, float b);
void SetBlendEnable(bool enable);
void SetBlendFunc(int src, int dst);
void SetBlendFactor(unsigned int factor);
void SetFaceCull(bool enable);
void Render(C4JRender::eVertexType vertexType, Renderer::Context& context, int primitiveType);
struct Command
{
Renderer::eCommandType m_command_type;
BYTE commandPadding[12];
struct Command
{
Renderer::eCommandType m_command_type;
BYTE commandPadding[12];
union
{
BYTE data[64];
union
{
BYTE data[64];
struct
{
float m_matrix[16];
// DirectX::XMMATRIX m_matrix;
} add_matrix;
struct
{
float m_matrix[16];
//DirectX::XMMATRIX m_matrix;
} add_matrix;
struct
{
unsigned int m_vertex_index_start;
unsigned int m_vertex_count;
} add_vertices;
struct
{
unsigned int m_vertex_index_start;
unsigned int m_vertex_count;
} add_vertices;
struct
{
unsigned int m_texture_index;
} bind_texture;
struct
{
unsigned int m_texture_index;
} bind_texture;
struct
{
float m_color[4];
} set_color;
struct
{
float m_color[4];
} set_color;
struct
{
int m_depth_func;
} set_depth_func;
struct
{
int m_depth_func;
} set_depth_func;
struct
{
bool m_enable;
} set_depth_mask;
struct
{
bool m_enable;
} set_depth_mask;
struct
{
bool m_enable;
} set_depth_test;
struct
{
bool m_enable;
} set_depth_test;
struct
{
bool m_enable;
} set_lighting_enable;
struct
{
bool m_enable;
} set_lighting_enable;
struct
{
int m_light_index;
bool m_enable;
} set_light_enable;
struct
{
int m_light_index;
bool m_enable;
} set_light_enable;
struct
{
int m_light_index;
float padding[3];
float m_direction[4];
} set_light_direction;
struct
{
int m_light_index;
float padding[3];
float m_direction[4];
} set_light_direction;
struct
{
int m_light_index;
float m_color[3];
} set_light_colour;
struct
{
int m_light_index;
float m_color[3];
} set_light_colour;
struct
{
BYTE padding;
float m_color[3];
} set_light_ambient_colour;
struct
{
BYTE padding;
float m_color[3];
} set_light_ambient_colour;
struct
{
bool m_enable;
} set_blend_enable;
struct
{
bool m_enable;
} set_blend_enable;
struct
{
int m_src;
int m_dst;
} set_blend_func;
struct
{
int m_src;
int m_dst;
} set_blend_func;
struct
{
unsigned int m_blend_factor;
} set_blend_factor;
struct
{
unsigned int m_blend_factor;
} set_blend_factor;
struct
{
bool m_enable;
} set_face_cull;
};
};
ID3D11Buffer *m_vertexBuffer;
void *m_vertexData;
std::uint64_t m_vertexDataLength;
std::vector<Command> m_commands;
std::uint64_t m_allocated;
BYTE isActive;
BYTE paddingAfterActive[7];
};
struct
{
bool m_enable;
} set_face_cull;
};
};
ID3D11Buffer* m_vertexBuffer;
void* m_vertexData;
std::uint64_t m_vertexDataLength;
std::vector<Command> m_commands;
std::uint64_t m_allocated;
BYTE isActive;
BYTE paddingAfterActive[7];
struct DeferredCBuff
{
Renderer::CommandBuffer *m_command_buf;
int m_vertex_index;
int m_vertex_type;
int m_primitive_type;
DirectX::XMMATRIX m_matrix;
};
struct Context
{
Context(ID3D11Device *device, ID3D11DeviceContext *deviceContext);
ID3D11DeviceContext *m_pDeviceContext;
ID3DUserDefinedAnnotation *userAnnotation;
DWORD contextStateFlags;
BYTE paddingAfterFlags[12];
DirectX::XMMATRIX matrixStacks[4][16];
bool matrixDirty[4];
DWORD matrixStackDepth[4];
DWORD matrixModeType;
DWORD boundTextureIndex;
BYTE faceCullEnabled;
BYTE depthTestEnabled;
BYTE alphaTestEnabled;
float alphaReference;
BYTE depthWriteEnabled;
BYTE fogEnabled;
BYTE paddingAfterFogFlags[2];
float fogNearDistance;
float fogFarDistance;
float fogDensity;
float fogColourRed;
float fogColourBlue;
float fogColourGreen;
DWORD fogMode;
BYTE lightingEnabled;
BYTE lightEnabled[2];
BYTE lightingDirty;
DWORD forcedLOD;
BYTE paddingAfterForceLOD[4];
DirectX::XMFLOAT4 lightDirection[2];
DirectX::XMFLOAT4 lightColour[2];
DirectX::XMFLOAT4 lightAmbientColour;
ID3D11Buffer *cbMatrix0;
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;
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;
static unsigned int s_auiWidths[MAX_MIP_LEVELS + 1];
static unsigned int s_auiHeights[MAX_MIP_LEVELS + 1];
static D3D11_INPUT_ELEMENT_DESC g_vertex_PTN_Elements_PF3_TF2_CB4_NB4_XW1[5];
static D3D11_INPUT_ELEMENT_DESC g_vertex_PTN_Elements_Compressed[2];
static D3D11_PRIMITIVE_TOPOLOGY g_topologies[C4JRender::PRIMITIVE_TYPE_COUNT];
static int totalAlloc;
static _RTL_CRITICAL_SECTION totalAllocCS;
struct DeferredCBuff
{
Renderer::CommandBuffer* m_command_buf;
int m_vertex_index;
int m_vertex_type;
int m_primitive_type;
DirectX::XMMATRIX m_matrix;
};
struct Context
{
Context(ID3D11Device* device, ID3D11DeviceContext* deviceContext);
ID3D11DeviceContext* m_pDeviceContext;
ID3DUserDefinedAnnotation* userAnnotation;
DWORD contextStateFlags;
BYTE paddingAfterFlags[12];
DirectX::XMMATRIX matrixStacks[4][16];
bool matrixDirty[4];
DWORD matrixStackDepth[4];
DWORD matrixModeType;
DWORD boundTextureIndex;
BYTE faceCullEnabled;
BYTE depthTestEnabled;
BYTE alphaTestEnabled;
float alphaReference;
BYTE depthWriteEnabled;
BYTE fogEnabled;
BYTE paddingAfterFogFlags[2];
float fogNearDistance;
float fogFarDistance;
float fogDensity;
float fogColourRed;
float fogColourBlue;
float fogColourGreen;
DWORD fogMode;
BYTE lightingEnabled;
BYTE lightEnabled[2];
BYTE lightingDirty;
DWORD forcedLOD;
BYTE paddingAfterForceLOD[4];
DirectX::XMFLOAT4 lightDirection[2];
DirectX::XMFLOAT4 lightColour[2];
DirectX::XMFLOAT4 lightAmbientColour;
ID3D11Buffer* cbMatrix0;
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;
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;
static unsigned int s_auiWidths[MAX_MIP_LEVELS + 1];
static unsigned int s_auiHeights[MAX_MIP_LEVELS + 1];
static D3D11_INPUT_ELEMENT_DESC g_vertex_PTN_Elements_PF3_TF2_CB4_NB4_XW1[5];
static D3D11_INPUT_ELEMENT_DESC g_vertex_PTN_Elements_Compressed[2];
static D3D11_PRIMITIVE_TOPOLOGY g_topologies[C4JRender::PRIMITIVE_TYPE_COUNT];
static int totalAlloc;
static _RTL_CRITICAL_SECTION totalAllocCS;
float m_fClearColor[4];
ID3D11Device* m_pDevice;
ID3D11DeviceContext* m_pDeviceContext;
IDXGISwapChain* m_pSwapChain;
ID3D11RenderTargetView* renderTargetView;
ID3D11RenderTargetView* renderTargetViews[4];
ID3D11ShaderResourceView* renderTargetShaderResourceView;
ID3D11ShaderResourceView* renderTargetShaderResourceViews[4];
ID3D11Texture2D* renderTargetTextures[4];
ID3D11DepthStencilView* depthStencilView;
ID3D11VertexShader** vertexShaderTable;
ID3D11VertexShader* screenSpaceVertexShader;
ID3D11VertexShader* screenClearVertexShader;
ID3D11PixelShader** pixelShaderTable;
ID3D11PixelShader* screenSpacePixelShader;
ID3D11PixelShader* screenClearPixelShader;
unsigned int* vertexStrideTable;
ID3D11InputLayout** inputLayoutTable;
ID3D11Buffer* quadIndexBuffer;
ID3D11Buffer* fanIndexBuffer;
DWORD defaultTextureIndex;
WORD reservedRendererWord0;
BYTE paddingAfterRendererWord0[2];
DWORD presentCount;
BYTE rendererFlag0;
BYTE paddingAfterRendererFlag0[3];
_RTL_CRITICAL_SECTION rtl_critical_section100;
DWORD activeVertexType;
DWORD activePixelType;
C4JRender::eViewportType m_ViewportType;
BYTE reservedRendererByte0;
BYTE paddingAfterViewportType[3];
Renderer::Texture m_textures[512];
DWORD backBufferWidth;
DWORD backBufferHeight;
BYTE reservedRendererByte1;
BYTE paddingAfterRendererByte1[3];
DWORD reservedRendererDword1;
void* reservedRendererPtr2;
void* reservedRendererPtr3;
uint64_t reservedRendererPtr1;
void* reservedRendererPtr4;
void* reservedRendererPtr5;
void* reservedRendererPtr6;
DWORD reservedRendererDword2;
DWORD reservedRendererDword3;
std::unordered_map<int, ID3D11BlendState*> managedBlendStates;
std::unordered_map<int, ID3D11DepthStencilState*> managedDepthStencilStates;
std::unordered_map<int, ID3D11SamplerState*> managedSamplerStates;
std::unordered_map<int, ID3D11RasterizerState*> managedRasterizerStates;
BYTE shouldScreenGrabNextFrame;
BYTE suspended;
BYTE paddingAfterSuspendState[2];
float m_fClearColor[4];
ID3D11Device *m_pDevice;
ID3D11DeviceContext *m_pDeviceContext;
IDXGISwapChain *m_pSwapChain;
ID3D11RenderTargetView *renderTargetView;
ID3D11RenderTargetView *renderTargetViews[4];
ID3D11ShaderResourceView *renderTargetShaderResourceView;
ID3D11ShaderResourceView *renderTargetShaderResourceViews[4];
ID3D11Texture2D *renderTargetTextures[4];
ID3D11DepthStencilView *depthStencilView;
ID3D11VertexShader **vertexShaderTable;
ID3D11VertexShader *screenSpaceVertexShader;
ID3D11VertexShader *screenClearVertexShader;
ID3D11PixelShader **pixelShaderTable;
ID3D11PixelShader *screenSpacePixelShader;
ID3D11PixelShader *screenClearPixelShader;
unsigned int *vertexStrideTable;
ID3D11InputLayout **inputLayoutTable;
ID3D11Buffer *quadIndexBuffer;
ID3D11Buffer *fanIndexBuffer;
DWORD defaultTextureIndex;
WORD reservedRendererWord0;
BYTE paddingAfterRendererWord0[2];
DWORD presentCount;
BYTE rendererFlag0;
BYTE paddingAfterRendererFlag0[3];
_RTL_CRITICAL_SECTION rtl_critical_section100;
DWORD activeVertexType;
DWORD activePixelType;
C4JRender::eViewportType m_ViewportType;
BYTE reservedRendererByte0;
BYTE paddingAfterViewportType[3];
Renderer::Texture m_textures[512];
DWORD backBufferWidth;
DWORD backBufferHeight;
BYTE reservedRendererByte1;
BYTE paddingAfterRendererByte1[3];
DWORD reservedRendererDword1;
void *reservedRendererPtr2;
void *reservedRendererPtr3;
uint64_t reservedRendererPtr1;
void *reservedRendererPtr4;
void *reservedRendererPtr5;
void *reservedRendererPtr6;
DWORD reservedRendererDword2;
DWORD reservedRendererDword3;
std::unordered_map<int, ID3D11BlendState *> managedBlendStates;
std::unordered_map<int, ID3D11DepthStencilState *> managedDepthStencilStates;
std::unordered_map<int, ID3D11SamplerState *> managedSamplerStates;
std::unordered_map<int, ID3D11RasterizerState *> managedRasterizerStates;
BYTE shouldScreenGrabNextFrame;
BYTE suspended;
BYTE paddingAfterSuspendState[2];
};
// Singleton

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

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

@@ -3,109 +3,109 @@
#include <cstring>
const float* Renderer::MatrixGet(int type)
const float *Renderer::MatrixGet(int type)
{
Context& context = this->getContext();
const int depth = context.matrixStackDepth[type];
return reinterpret_cast<const float*>(&context.matrixStacks[type][depth]);
Context &context = this->getContext();
const int depth = context.matrixStackDepth[type];
return reinterpret_cast<const float *>(&context.matrixStacks[type][depth]);
}
void Renderer::MatrixMode(int type)
{
Context& context = this->getContext();
context.matrixModeType = type;
Context &context = this->getContext();
context.matrixModeType = type;
}
void Renderer::MatrixMult(float* mat)
void Renderer::MatrixMult(float *mat)
{
DirectX::XMMATRIX matrix;
std::memcpy(&matrix, mat, sizeof(matrix));
this->MultWithStack(matrix);
DirectX::XMMATRIX matrix;
std::memcpy(&matrix, mat, sizeof(matrix));
this->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);
const DirectX::XMMATRIX matrix = DirectX::XMMatrixOrthographicOffCenterRH(left, right, bottom, top, zNear, zFar);
this->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);
const float fovRadians = fovy * (3.14159274f / 180.0f);
const DirectX::XMMATRIX matrix = DirectX::XMMatrixPerspectiveFovRH(fovRadians, aspect, zNear, zFar);
this->MultWithStack(matrix);
}
void Renderer::MatrixPop()
{
Context& context = this->getContext();
const int mode = context.matrixModeType;
--context.matrixStackDepth[mode];
context.matrixDirty[mode] = true;
Context &context = this->getContext();
const int mode = context.matrixModeType;
--context.matrixStackDepth[mode];
context.matrixDirty[mode] = true;
}
void Renderer::MatrixPush()
{
Context& context = this->getContext();
const int mode = context.matrixModeType;
const int depth = context.matrixStackDepth[mode];
context.matrixStacks[mode][depth + 1] = context.matrixStacks[mode][depth];
++context.matrixStackDepth[mode];
Context &context = this->getContext();
const int mode = context.matrixModeType;
const int depth = context.matrixStackDepth[mode];
context.matrixStacks[mode][depth + 1] = context.matrixStacks[mode][depth];
++context.matrixStackDepth[mode];
}
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);
const DirectX::XMVECTOR axis = DirectX::XMVectorSet(x, y, z, 0.0f);
const DirectX::XMMATRIX matrix = DirectX::XMMatrixRotationAxis(axis, angle);
this->MultWithStack(matrix);
}
void Renderer::MatrixScale(float x, float y, float z)
{
const DirectX::XMMATRIX matrix = DirectX::XMMatrixScaling(x, y, z);
this->MultWithStack(matrix);
const DirectX::XMMATRIX matrix = DirectX::XMMatrixScaling(x, y, z);
this->MultWithStack(matrix);
}
void Renderer::MatrixSetIdentity()
{
Context& context = this->getContext();
const int mode = context.matrixModeType;
const int depth = context.matrixStackDepth[mode];
context.matrixStacks[mode][depth] = DirectX::XMMatrixIdentity();
context.matrixDirty[mode] = true;
Context &context = this->getContext();
const int mode = context.matrixModeType;
const int depth = context.matrixStackDepth[mode];
context.matrixStacks[mode][depth] = DirectX::XMMatrixIdentity();
context.matrixDirty[mode] = true;
}
void Renderer::MatrixTranslate(float x, float y, float z)
{
const DirectX::XMMATRIX matrix = DirectX::XMMatrixTranslation(x, y, z);
this->MultWithStack(matrix);
const DirectX::XMMATRIX matrix = DirectX::XMMatrixTranslation(x, y, z);
this->MultWithStack(matrix);
}
void Renderer::MultWithStack(DirectX::XMMATRIX matrix)
{
Context& context = this->getContext();
const int mode = context.matrixModeType;
const int depth = context.matrixStackDepth[mode];
DirectX::XMMATRIX& current = context.matrixStacks[mode][depth];
current = DirectX::XMMatrixMultiply(matrix, current);
context.matrixDirty[mode] = true;
Context &context = this->getContext();
const int mode = context.matrixModeType;
const int depth = context.matrixStackDepth[mode];
DirectX::XMMATRIX &current = context.matrixStacks[mode][depth];
current = DirectX::XMMatrixMultiply(matrix, current);
context.matrixDirty[mode] = true;
}
void Renderer::Set_matrixDirty()
{
Context& context = this->getContext();
const DirectX::XMMATRIX identity = DirectX::XMMatrixIdentity();
Context &context = this->getContext();
const DirectX::XMMATRIX identity = DirectX::XMMatrixIdentity();
context.matrixStacks[0][0] = identity;
context.matrixStacks[1][0] = identity;
context.matrixStacks[2][0] = identity;
context.matrixStacks[3][0] = identity;
context.matrixStacks[0][0] = identity;
context.matrixStacks[1][0] = identity;
context.matrixStacks[2][0] = identity;
context.matrixStacks[3][0] = identity;
context.matrixDirty[0] = true;
context.matrixDirty[1] = true;
context.matrixDirty[2] = true;
context.matrixDirty[3] = true;
context.matrixDirty[0] = true;
context.matrixDirty[1] = true;
context.matrixDirty[2] = true;
context.matrixDirty[3] = true;
activeVertexType = 0xFFFFFFFFu;
activePixelType = 0xFFFFFFFFu;
activeVertexType = 0xFFFFFFFFu;
activePixelType = 0xFFFFFFFFu;
}

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

File diff suppressed because it is too large Load Diff

541
Windows_Libs/Dev/Render/RendererTexture.cpp
View File

@@ -11,319 +11,348 @@ DXGI_FORMAT Renderer::textureFormats[C4JRender::MAX_TEXTURE_FORMATS] = {
DXGI_FORMAT_B8G8R8A8_UNORM,
};
int Renderer::TextureCreate() {
for (int i = 0; i < 512; ++i) {
Texture &texture = m_textures[i];
if (!texture.allocated) {
texture.texture = nullptr;
texture.allocated = true;
texture.mipLevels = 1;
texture.samplerParams = 0;
return i;
int Renderer::TextureCreate()
{
for (int i = 0; i < 512; ++i)
{
Texture &texture = m_textures[i];
if (!texture.allocated)
{
texture.texture = nullptr;
texture.allocated = true;
texture.mipLevels = 1;
texture.samplerParams = 0;
return i;
}
}
}
return -1;
return -1;
}
void Renderer::TextureSetTextureLevels(int levels) {
const int boundTextureIndex = this->getContext().boundTextureIndex;
m_textures[boundTextureIndex].mipLevels = levels;
void Renderer::TextureSetTextureLevels(int levels)
{
const int boundTextureIndex = this->getContext().boundTextureIndex;
m_textures[boundTextureIndex].mipLevels = levels;
}
int Renderer::TextureGetTextureLevels() {
const int boundTextureIndex = this->getContext().boundTextureIndex;
return m_textures[boundTextureIndex].mipLevels;
int Renderer::TextureGetTextureLevels()
{
const int boundTextureIndex = this->getContext().boundTextureIndex;
return m_textures[boundTextureIndex].mipLevels;
}
void Renderer::TextureSetParam(int param, int value) {
Texture &texture = m_textures[this->getContext().boundTextureIndex];
void Renderer::TextureSetParam(int param, int value)
{
Texture &texture = m_textures[this->getContext().boundTextureIndex];
switch (param) {
case GL_TEXTURE_MIN_FILTER:
texture.samplerParams &= ~4u;
if (value == 1) {
texture.samplerParams |= 4u;
switch (param)
{
case GL_TEXTURE_MIN_FILTER:
texture.samplerParams &= ~4u;
if (value == 1)
{
texture.samplerParams |= 4u;
}
break;
case GL_TEXTURE_MAG_FILTER:
texture.samplerParams &= ~8u;
if (value == 1)
{
texture.samplerParams |= 8u;
}
break;
case GL_TEXTURE_WRAP_S:
texture.samplerParams &= ~1u;
if (value == 0)
{
texture.samplerParams |= 1u;
}
break;
case GL_TEXTURE_WRAP_T:
case 5:
texture.samplerParams &= ~2u;
if (value == 0)
{
texture.samplerParams |= 2u;
}
break;
default:
break;
}
break;
case GL_TEXTURE_MAG_FILTER:
texture.samplerParams &= ~8u;
if (value == 1) {
texture.samplerParams |= 8u;
}
break;
case GL_TEXTURE_WRAP_S:
texture.samplerParams &= ~1u;
if (value == 0) {
texture.samplerParams |= 1u;
}
break;
case GL_TEXTURE_WRAP_T:
case 5:
texture.samplerParams &= ~2u;
if (value == 0) {
texture.samplerParams |= 2u;
}
break;
default:
break;
}
}
void Renderer::TextureDynamicUpdateStart() {}
void Renderer::TextureDynamicUpdateEnd() {}
void Renderer::TextureData(int width, int height, void *data, int level,
C4JRender::eTextureFormat format) {
Renderer::Context &context = this->getContext();
Texture &texture = m_textures[context.boundTextureIndex];
texture.textureFormat = format;
void Renderer::TextureData(int width, int height, void *data, int level, C4JRender::eTextureFormat format)
{
Renderer::Context &context = this->getContext();
Texture &texture = m_textures[context.boundTextureIndex];
texture.textureFormat = format;
if (level == 0)
{
D3D11_TEXTURE2D_DESC desc = {};
desc.Width = width;
desc.Height = height;
desc.MipLevels = texture.mipLevels;
desc.ArraySize = 1;
desc.Format = textureFormats[format];
desc.SampleDesc.Count = 1;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
m_pDevice->CreateTexture2D(&desc, nullptr, &texture.texture);
m_pDevice->CreateShaderResourceView(texture.texture, nullptr, &texture.view);
}
const UINT rowPitch = width * 4u;
const UINT depthPitch = width * height * 4u;
context.m_pDeviceContext->UpdateSubresource(texture.texture, level, nullptr, data, rowPitch, depthPitch);
}
void Renderer::TextureDataUpdate(int xoffset, int yoffset, int width, int height, void *data, int level)
{
Renderer::Context &context = this->getContext();
Texture &texture = m_textures[context.boundTextureIndex];
D3D11_BOX box = {};
box.left = xoffset;
box.right = xoffset + width;
box.top = yoffset;
box.bottom = yoffset + height;
box.front = 0;
box.back = 1;
if (level == 0) {
D3D11_TEXTURE2D_DESC desc = {};
desc.Width = width;
desc.Height = height;
desc.MipLevels = texture.mipLevels;
desc.ArraySize = 1;
desc.Format = textureFormats[format];
desc.SampleDesc.Count = 1;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
m_pDevice->CreateTexture2D(&desc, nullptr, &texture.texture);
m_pDevice->CreateShaderResourceView(texture.texture, nullptr,
&texture.view);
}
texture.texture->GetDesc(&desc);
const UINT rowPitch = width * 4u;
const UINT depthPitch = width * height * 4u;
context.m_pDeviceContext->UpdateSubresource(texture.texture, level, nullptr,
data, rowPitch, depthPitch);
const UINT rowPitch = width * 4u;
const UINT depthPitch = width * height * 4u;
context.m_pDeviceContext->UpdateSubresource(texture.texture, level, &box, data, rowPitch, depthPitch);
}
void Renderer::TextureDataUpdate(int xoffset, int yoffset, int width,
int height, void *data, int level) {
Renderer::Context &context = this->getContext();
Texture &texture = m_textures[context.boundTextureIndex];
D3D11_BOX box = {};
box.left = xoffset;
box.right = xoffset + width;
box.top = yoffset;
box.bottom = yoffset + height;
box.front = 0;
box.back = 1;
D3D11_TEXTURE2D_DESC desc = {};
texture.texture->GetDesc(&desc);
const UINT rowPitch = width * 4u;
const UINT depthPitch = width * height * 4u;
context.m_pDeviceContext->UpdateSubresource(texture.texture, level, &box,
data, rowPitch, depthPitch);
}
void Renderer::TextureFree(int idx) {
Texture &texture = m_textures[idx];
texture.texture->Release();
texture.view->Release();
texture.view = nullptr;
texture.allocated = false;
texture.texture = nullptr;
void Renderer::TextureFree(int idx)
{
Texture &texture = m_textures[idx];
texture.texture->Release();
texture.view->Release();
texture.view = nullptr;
texture.allocated = false;
texture.texture = nullptr;
}
void Renderer::TextureGetStats() {}
ID3D11ShaderResourceView *Renderer::TextureGetTexture(int idx) {
if (idx < 0 || idx > 0x1FF) {
return nullptr;
}
ID3D11ShaderResourceView *Renderer::TextureGetTexture(int idx)
{
if (idx < 0 || idx > 0x1FF)
{
return nullptr;
}
const Texture &texture = m_textures[idx];
if (!texture.allocated) {
return nullptr;
}
const Texture &texture = m_textures[idx];
if (!texture.allocated)
{
return nullptr;
}
return texture.view;
return texture.view;
}
void Renderer::TextureBind(int idx) {
int textureIndex = idx;
if (textureIndex == -1) {
textureIndex = defaultTextureIndex;
}
void Renderer::TextureBind(int idx)
{
int textureIndex = idx;
if (textureIndex == -1)
{
textureIndex = defaultTextureIndex;
}
Renderer::Context &context = this->getContext();
Renderer::Context &context = this->getContext();
if (context.commandBuffer && context.commandBuffer->isActive) {
context.commandBuffer->BindTexture(textureIndex);
}
if (context.commandBuffer && context.commandBuffer->isActive)
{
context.commandBuffer->BindTexture(textureIndex);
}
context.boundTextureIndex = textureIndex;
ID3D11ShaderResourceView *const view = m_textures[textureIndex].view;
context.m_pDeviceContext->PSSetShaderResources(0, 1, &view);
this->UpdateTextureState(false);
context.boundTextureIndex = textureIndex;
ID3D11ShaderResourceView *const view = m_textures[textureIndex].view;
context.m_pDeviceContext->PSSetShaderResources(0, 1, &view);
this->UpdateTextureState(false);
}
void Renderer::TextureBindVertex(int idx) {
int textureIndex = idx;
if (textureIndex == -1) {
textureIndex = defaultTextureIndex;
}
void Renderer::TextureBindVertex(int idx)
{
int textureIndex = idx;
if (textureIndex == -1)
{
textureIndex = defaultTextureIndex;
}
Renderer::Context &context = this->getContext();
context.boundTextureIndex = textureIndex;
Renderer::Context &context = this->getContext();
context.boundTextureIndex = textureIndex;
ID3D11ShaderResourceView *const view = m_textures[textureIndex].view;
context.m_pDeviceContext->VSSetShaderResources(0, 1, &view);
this->UpdateTextureState(true);
ID3D11ShaderResourceView *const view = m_textures[textureIndex].view;
context.m_pDeviceContext->VSSetShaderResources(0, 1, &view);
this->UpdateTextureState(true);
}
void Renderer::UpdateTextureState(bool vertexSampler) {
Renderer::Context &context = this->getContext();
ID3D11SamplerState *sampler = this->GetManagedSamplerState();
void Renderer::UpdateTextureState(bool vertexSampler)
{
Renderer::Context &context = this->getContext();
ID3D11SamplerState *sampler = this->GetManagedSamplerState();
if (vertexSampler) {
context.m_pDeviceContext->VSSetSamplers(0, 1, &sampler);
} else {
context.m_pDeviceContext->PSSetSamplers(0, 1, &sampler);
}
if (vertexSampler)
{
context.m_pDeviceContext->VSSetSamplers(0, 1, &sampler);
}
else
{
context.m_pDeviceContext->PSSetSamplers(0, 1, &sampler);
}
}
HRESULT Renderer::LoadTextureData(const char *szFilename,
D3DXIMAGE_INFO *pSrcInfo, int **ppDataOut) {
if (!szFilename || !pSrcInfo || !ppDataOut) {
return -1;
}
HRESULT Renderer::LoadTextureData(const char *szFilename, D3DXIMAGE_INFO *pSrcInfo, int **ppDataOut)
{
if (!szFilename || !pSrcInfo || !ppDataOut)
{
return -1;
}
*ppDataOut = nullptr;
*ppDataOut = nullptr;
png_image image;
std::memset(&image, 0, sizeof(image));
image.version = PNG_IMAGE_VERSION;
if (!png_image_begin_read_from_file(&image, szFilename)) {
return -1;
}
png_image image;
std::memset(&image, 0, sizeof(image));
image.version = PNG_IMAGE_VERSION;
if (!png_image_begin_read_from_file(&image, szFilename))
{
return -1;
}
if (image.width == 0 || image.height == 0) {
if (image.width == 0 || image.height == 0)
{
png_image_free(&image);
return -1;
}
image.format = PNG_FORMAT_RGBA;
const png_alloc_size_t pixelCount = png_alloc_size_t(image.width) * png_alloc_size_t(image.height);
if (pixelCount == 0 || pixelCount > (std::numeric_limits<size_t>::max)() / sizeof(int))
{
png_image_free(&image);
return -1;
}
int *output = new (std::nothrow) int[size_t(pixelCount)];
if (!output)
{
png_image_free(&image);
return -1;
}
if (!png_image_finish_read(&image, nullptr, output, 0, nullptr))
{
delete[] output;
png_image_free(&image);
return -1;
}
*ppDataOut = output;
pSrcInfo->Width = image.width;
pSrcInfo->Height = image.height;
png_image_free(&image);
return -1;
}
image.format = PNG_FORMAT_RGBA;
const png_alloc_size_t pixelCount =
png_alloc_size_t(image.width) * png_alloc_size_t(image.height);
if (pixelCount == 0 ||
pixelCount > (std::numeric_limits<size_t>::max)() / sizeof(int)) {
png_image_free(&image);
return -1;
}
int *output = new (std::nothrow) int[size_t(pixelCount)];
if (!output) {
png_image_free(&image);
return -1;
}
if (!png_image_finish_read(&image, nullptr, output, 0, nullptr)) {
delete[] output;
png_image_free(&image);
return -1;
}
*ppDataOut = output;
pSrcInfo->Width = image.width;
pSrcInfo->Height = image.height;
png_image_free(&image);
return 0;
return 0;
}
HRESULT Renderer::LoadTextureData(BYTE *pbData, DWORD dwBytes,
D3DXIMAGE_INFO *pSrcInfo, int **ppDataOut) {
if (!pbData || dwBytes == 0 || !pSrcInfo || !ppDataOut) {
return -1;
}
HRESULT Renderer::LoadTextureData(BYTE *pbData, DWORD dwBytes, D3DXIMAGE_INFO *pSrcInfo, int **ppDataOut)
{
if (!pbData || dwBytes == 0 || !pSrcInfo || !ppDataOut)
{
return -1;
}
*ppDataOut = nullptr;
*ppDataOut = nullptr;
png_image image;
std::memset(&image, 0, sizeof(image));
image.version = PNG_IMAGE_VERSION;
if (!png_image_begin_read_from_memory(&image, pbData, dwBytes)) {
return -1;
}
png_image image;
std::memset(&image, 0, sizeof(image));
image.version = PNG_IMAGE_VERSION;
if (!png_image_begin_read_from_memory(&image, pbData, dwBytes))
{
return -1;
}
if (image.width == 0 || image.height == 0) {
if (image.width == 0 || image.height == 0)
{
png_image_free(&image);
return -1;
}
image.format = PNG_FORMAT_RGBA;
const png_alloc_size_t pixelCount = png_alloc_size_t(image.width) * png_alloc_size_t(image.height);
if (pixelCount == 0 || pixelCount > (std::numeric_limits<size_t>::max)() / sizeof(int))
{
png_image_free(&image);
return -1;
}
int *output = new (std::nothrow) int[size_t(pixelCount)];
if (!output)
{
png_image_free(&image);
return -1;
}
if (!png_image_finish_read(&image, nullptr, output, 0, nullptr))
{
delete[] output;
png_image_free(&image);
return -1;
}
*ppDataOut = output;
pSrcInfo->Width = image.width;
pSrcInfo->Height = image.height;
png_image_free(&image);
return -1;
}
image.format = PNG_FORMAT_RGBA;
const png_alloc_size_t pixelCount =
png_alloc_size_t(image.width) * png_alloc_size_t(image.height);
if (pixelCount == 0 ||
pixelCount > (std::numeric_limits<size_t>::max)() / sizeof(int)) {
png_image_free(&image);
return -1;
}
int *output = new (std::nothrow) int[size_t(pixelCount)];
if (!output) {
png_image_free(&image);
return -1;
}
if (!png_image_finish_read(&image, nullptr, output, 0, nullptr)) {
delete[] output;
png_image_free(&image);
return -1;
}
*ppDataOut = output;
pSrcInfo->Width = image.width;
pSrcInfo->Height = image.height;
png_image_free(&image);
return 0;
return 0;
}
HRESULT Renderer::SaveTextureData(const char *szFilename,
D3DXIMAGE_INFO *pSrcInfo, int *ppDataOut) {
png_image image = {};
image.version = PNG_IMAGE_VERSION;
image.width = pSrcInfo->Width;
image.height = pSrcInfo->Height;
image.format = PNG_FORMAT_RGBA;
HRESULT Renderer::SaveTextureData(const char *szFilename, D3DXIMAGE_INFO *pSrcInfo, int *ppDataOut)
{
png_image image = {};
image.version = PNG_IMAGE_VERSION;
image.width = pSrcInfo->Width;
image.height = pSrcInfo->Height;
image.format = PNG_FORMAT_RGBA;
png_image_write_to_file(&image, szFilename, 0, ppDataOut, 0, nullptr);
return 0;
png_image_write_to_file(&image, szFilename, 0, ppDataOut, 0, nullptr);
return 0;
}
HRESULT Renderer::SaveTextureDataToMemory(void *pOutput, int outputCapacity,
int *outputLength, int width,
int height, int *ppDataIn) {
if (!pOutput || outputCapacity <= 0 || !outputLength || width <= 0 ||
height <= 0 || !ppDataIn) {
return -1;
}
HRESULT Renderer::SaveTextureDataToMemory(void *pOutput, int outputCapacity, int *outputLength, int width, int height, int *ppDataIn)
{
if (!pOutput || outputCapacity <= 0 || !outputLength || width <= 0 || height <= 0 || !ppDataIn)
{
return -1;
}
png_image image;
std::memset(&image, 0, sizeof(image));
image.version = PNG_IMAGE_VERSION;
image.width = width;
image.height = height;
image.format = PNG_FORMAT_RGBA;
png_image image;
std::memset(&image, 0, sizeof(image));
image.version = PNG_IMAGE_VERSION;
image.width = width;
image.height = height;
image.format = PNG_FORMAT_RGBA;
png_alloc_size_t memoryBytes = static_cast<png_alloc_size_t>(outputCapacity);
if (!png_image_write_to_memory(&image, pOutput, &memoryBytes, 0, ppDataIn, 0,
nullptr)) {
*outputLength = 0;
png_alloc_size_t memoryBytes = static_cast<png_alloc_size_t>(outputCapacity);
if (!png_image_write_to_memory(&image, pOutput, &memoryBytes, 0, ppDataIn, 0, nullptr))
{
*outputLength = 0;
png_image_free(&image);
return -1;
}
*outputLength = static_cast<int>(memoryBytes);
png_image_free(&image);
return -1;
}
*outputLength = static_cast<int>(memoryBytes);
png_image_free(&image);
return 0;
return 0;
}

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

@@ -5,181 +5,169 @@
#include <cstdio>
#include <cstring>
D3D11_PRIMITIVE_TOPOLOGY* Renderer::m_Topologies = nullptr;
D3D11_PRIMITIVE_TOPOLOGY *Renderer::m_Topologies = nullptr;
void Renderer::DrawVertexBuffer(
C4JRender::ePrimitiveType PrimitiveType,
int count,
ID3D11Buffer* buffer,
C4JRender::eVertexType vType,
C4JRender::ePixelShaderType psType)
void Renderer::DrawVertexBuffer(C4JRender::ePrimitiveType PrimitiveType, int count, ID3D11Buffer *buffer, C4JRender::eVertexType vType,
C4JRender::ePixelShaderType psType)
{
Renderer::Context& context = this->getContext();
ID3D11DeviceContext* d3d11 = context.m_pDeviceContext;
Renderer::Context &context = this->getContext();
ID3D11DeviceContext *d3d11 = context.m_pDeviceContext;
int drawCount = count;
bool indexed = false;
this->DrawVertexSetup(vType, psType, PrimitiveType, &drawCount, &indexed);
this->StateUpdate();
int drawCount = count;
bool indexed = false;
this->DrawVertexSetup(vType, psType, PrimitiveType, &drawCount, &indexed);
this->StateUpdate();
const UINT stride = vertexStrideTable[vType];
const UINT offset = 0;
d3d11->IASetVertexBuffers(0, 1, &buffer, &stride, &offset);
const UINT stride = vertexStrideTable[vType];
const UINT offset = 0;
d3d11->IASetVertexBuffers(0, 1, &buffer, &stride, &offset);
if (indexed)
{
d3d11->DrawIndexed(drawCount, 0, 0);
}
else
{
d3d11->Draw(count, 0);
}
if (indexed)
{
d3d11->DrawIndexed(drawCount, 0, 0);
}
else
{
d3d11->Draw(count, 0);
}
}
void Renderer::DrawVertexSetup(
C4JRender::eVertexType vType,
C4JRender::ePixelShaderType psType,
C4JRender::ePrimitiveType PrimitiveType,
int* count,
bool* indexed)
void Renderer::DrawVertexSetup(C4JRender::eVertexType vType, C4JRender::ePixelShaderType psType, C4JRender::ePrimitiveType PrimitiveType, int *count,
bool *indexed)
{
Renderer::Context& context = this->getContext();
ID3D11DeviceContext* d3d11 = context.m_pDeviceContext;
Renderer::Context &context = this->getContext();
ID3D11DeviceContext *d3d11 = context.m_pDeviceContext;
C4JRender::eVertexType effectiveVertexType = vType;
if (effectiveVertexType == C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1 && context.lightingEnabled)
{
effectiveVertexType = C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1_LIT;
}
C4JRender::eVertexType effectiveVertexType = vType;
if (effectiveVertexType == C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1 && context.lightingEnabled)
{
effectiveVertexType = C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1_LIT;
}
if (effectiveVertexType != activeVertexType)
{
d3d11->VSSetShader(vertexShaderTable[effectiveVertexType], nullptr, 0);
d3d11->IASetInputLayout(inputLayoutTable[effectiveVertexType]);
activeVertexType = effectiveVertexType;
}
if (effectiveVertexType != activeVertexType)
{
d3d11->VSSetShader(vertexShaderTable[effectiveVertexType], nullptr, 0);
d3d11->IASetInputLayout(inputLayoutTable[effectiveVertexType]);
activeVertexType = effectiveVertexType;
}
if (psType != activePixelType)
{
d3d11->PSSetShader(pixelShaderTable[psType], nullptr, 0);
activePixelType = psType;
}
if (psType != activePixelType)
{
d3d11->PSSetShader(pixelShaderTable[psType], nullptr, 0);
activePixelType = psType;
}
D3D11_MAPPED_SUBRESOURCE mapped = {};
D3D11_MAPPED_SUBRESOURCE mapped = {};
if (context.matrixDirty[0])
{
d3d11->Map(context.cbMatrix0, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
std::memcpy(mapped.pData, this->MatrixGet(0), sizeof(DirectX::XMMATRIX));
d3d11->Unmap(context.cbMatrix0, 0);
context.matrixDirty[0] = false;
}
if (context.matrixDirty[0])
{
d3d11->Map(context.cbMatrix0, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
std::memcpy(mapped.pData, this->MatrixGet(0), sizeof(DirectX::XMMATRIX));
d3d11->Unmap(context.cbMatrix0, 0);
context.matrixDirty[0] = false;
}
if (context.matrixDirty[1])
{
d3d11->Map(context.cbMatrix2, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
std::memcpy(mapped.pData, this->MatrixGet(1), sizeof(DirectX::XMMATRIX));
d3d11->Unmap(context.cbMatrix2, 0);
context.matrixDirty[1] = false;
}
if (context.matrixDirty[1])
{
d3d11->Map(context.cbMatrix2, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
std::memcpy(mapped.pData, this->MatrixGet(1), sizeof(DirectX::XMMATRIX));
d3d11->Unmap(context.cbMatrix2, 0);
context.matrixDirty[1] = false;
}
if (context.matrixDirty[2])
{
d3d11->Map(context.cbMatrix3, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
std::memcpy(mapped.pData, this->MatrixGet(2), sizeof(DirectX::XMMATRIX));
d3d11->Unmap(context.cbMatrix3, 0);
context.matrixDirty[2] = false;
}
if (context.matrixDirty[2])
{
d3d11->Map(context.cbMatrix3, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
std::memcpy(mapped.pData, this->MatrixGet(2), sizeof(DirectX::XMMATRIX));
d3d11->Unmap(context.cbMatrix3, 0);
context.matrixDirty[2] = false;
}
this->UpdateFogState();
this->UpdateViewportState();
this->UpdateLightingState();
this->UpdateTexGenState();
this->UpdateFogState();
this->UpdateViewportState();
this->UpdateLightingState();
this->UpdateTexGenState();
d3d11->IASetPrimitiveTopology(m_Topologies[PrimitiveType]);
d3d11->IASetPrimitiveTopology(m_Topologies[PrimitiveType]);
if (PrimitiveType == C4JRender::PRIMITIVE_TYPE_QUAD_LIST)
{
d3d11->IASetIndexBuffer(quadIndexBuffer, DXGI_FORMAT_R16_UINT, 0);
*count = (*count * 6) / 4;
*indexed = true;
return;
}
if (PrimitiveType == C4JRender::PRIMITIVE_TYPE_QUAD_LIST)
{
d3d11->IASetIndexBuffer(quadIndexBuffer, DXGI_FORMAT_R16_UINT, 0);
*count = (*count * 6) / 4;
*indexed = true;
return;
}
if (PrimitiveType == C4JRender::PRIMITIVE_TYPE_TRIANGLE_FAN)
{
d3d11->IASetIndexBuffer(fanIndexBuffer, DXGI_FORMAT_R16_UINT, 0);
*count = (*count - 2) * 3;
*indexed = true;
return;
}
if (PrimitiveType == C4JRender::PRIMITIVE_TYPE_TRIANGLE_FAN)
{
d3d11->IASetIndexBuffer(fanIndexBuffer, DXGI_FORMAT_R16_UINT, 0);
*count = (*count - 2) * 3;
*indexed = true;
return;
}
d3d11->IASetIndexBuffer(nullptr, DXGI_FORMAT_R16_UINT, 0);
*indexed = false;
d3d11->IASetIndexBuffer(nullptr, DXGI_FORMAT_R16_UINT, 0);
*indexed = false;
}
void Renderer::DrawVertices(
C4JRender::ePrimitiveType PrimitiveType,
int count,
void* vertices,
C4JRender::eVertexType vType,
C4JRender::ePixelShaderType psType)
void Renderer::DrawVertices(C4JRender::ePrimitiveType PrimitiveType, int count, void *vertices, C4JRender::eVertexType vType,
C4JRender::ePixelShaderType psType)
{
Renderer::Context& context = this->getContext();
ID3D11DeviceContext* d3d11 = context.m_pDeviceContext;
Renderer::CommandBuffer* commandBuffer = context.commandBuffer;
Renderer::Context &context = this->getContext();
ID3D11DeviceContext *d3d11 = context.m_pDeviceContext;
Renderer::CommandBuffer *commandBuffer = context.commandBuffer;
if (commandBuffer != nullptr)
{
C4JRender::eVertexType effectiveVertexType = vType;
if (effectiveVertexType == C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1 && context.lightingEnabled)
{
effectiveVertexType = C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1_LIT;
}
if (commandBuffer != nullptr)
{
C4JRender::eVertexType effectiveVertexType = vType;
if (effectiveVertexType == C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1 && context.lightingEnabled)
{
effectiveVertexType = C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1_LIT;
}
context.recordingPrimitiveType = PrimitiveType;
context.recordingVertexType = effectiveVertexType;
const UINT stride = vertexStrideTable[effectiveVertexType];
commandBuffer->AddVertices(stride, static_cast<UINT>(count), vertices, context);
return;
}
context.recordingPrimitiveType = PrimitiveType;
context.recordingVertexType = effectiveVertexType;
const UINT stride = vertexStrideTable[effectiveVertexType];
commandBuffer->AddVertices(stride, static_cast<UINT>(count), vertices, context);
return;
}
int drawCount = count;
bool indexed = false;
this->DrawVertexSetup(vType, psType, PrimitiveType, &drawCount, &indexed);
int drawCount = count;
bool indexed = false;
this->DrawVertexSetup(vType, psType, PrimitiveType, &drawCount, &indexed);
const UINT stride = vertexStrideTable[vType];
const UINT copySize = stride * static_cast<UINT>(count);
if (context.dynamicVertexOffset + copySize > 0x100000u)
{
context.dynamicVertexOffset = 0;
}
const UINT stride = vertexStrideTable[vType];
const UINT copySize = stride * static_cast<UINT>(count);
if (context.dynamicVertexOffset + copySize > 0x100000u)
{
context.dynamicVertexOffset = 0;
}
D3D11_MAPPED_SUBRESOURCE mapped = {};
const D3D11_MAP mapType = context.dynamicVertexOffset == 0 ? D3D11_MAP_WRITE_DISCARD : D3D11_MAP_WRITE_NO_OVERWRITE;
const HRESULT hr = d3d11->Map(context.dynamicVertexBuffer, 0, mapType, 0, &mapped);
if (hr != 0)
{
std::printf("ERROR: 0x%x\n", static_cast<unsigned int>(hr));
}
D3D11_MAPPED_SUBRESOURCE mapped = {};
const D3D11_MAP mapType = context.dynamicVertexOffset == 0 ? D3D11_MAP_WRITE_DISCARD : D3D11_MAP_WRITE_NO_OVERWRITE;
const HRESULT hr = d3d11->Map(context.dynamicVertexBuffer, 0, mapType, 0, &mapped);
if (hr != 0)
{
std::printf("ERROR: 0x%x\n", static_cast<unsigned int>(hr));
}
std::memcpy(static_cast<std::uint8_t*>(mapped.pData) + context.dynamicVertexOffset, vertices, copySize);
d3d11->Unmap(context.dynamicVertexBuffer, 0);
std::memcpy(static_cast<std::uint8_t *>(mapped.pData) + context.dynamicVertexOffset, vertices, copySize);
d3d11->Unmap(context.dynamicVertexBuffer, 0);
this->StateUpdate();
this->StateUpdate();
ID3D11Buffer* dynamicBuffer = context.dynamicVertexBuffer;
const UINT vertexOffset = context.dynamicVertexOffset;
d3d11->IASetVertexBuffers(0, 1, &dynamicBuffer, &stride, &vertexOffset);
ID3D11Buffer *dynamicBuffer = context.dynamicVertexBuffer;
const UINT vertexOffset = context.dynamicVertexOffset;
d3d11->IASetVertexBuffers(0, 1, &dynamicBuffer, &stride, &vertexOffset);
if (indexed)
{
d3d11->DrawIndexed(drawCount, 0, 0);
}
else
{
d3d11->Draw(count, 0);
}
if (indexed)
{
d3d11->DrawIndexed(drawCount, 0, 0);
}
else
{
d3d11->Draw(count, 0);
}
context.dynamicVertexOffset += copySize;
context.dynamicVertexOffset += copySize;
}