TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-07-15 16:44:36 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove code duplication

Browse source 
Removed code duplication, all types can be routed through the same function apart from matrices.
This commit is contained in:
marauder2k7 2024-02-25 15:26:48 +00:00
parent 8c01a1a85b
commit af29a2af0a
2 changed files with 131 additions and 142 deletions
Download patch file Download diff file Expand all files Collapse all files

265
Engine/source/gfx/D3D11/gfxD3D11Shader.cpp
View file

@ -175,34 +175,134 @@ GFXShader* GFXD3D11ShaderConstBuffer::getShader()
return mShader; return mShader;
} }
void GFXD3D11ShaderConstBuffer::setMatrix(GFXShaderConstHandle* handle, const U32 inSize, const void* data)
{
AssertFatal(handle, "GFXD3D11ShaderConstBuffer::internalSet - Handle is NULL!");
AssertFatal(handle->isValid(), "GFXD3D11ShaderConstBuffer::internalSet - Handle is not valid!");
AssertFatal(dynamic_cast<GFXD3D11ShaderConstHandle*>(handle), "GFXD3D11ShaderConstBuffer::internalSet - Incorrect const buffer type");
GFXD3D11ShaderConstHandle* _dxHandle = static_cast<GFXD3D11ShaderConstHandle*>(handle);
AssertFatal(mShader == _dxHandle->mShader, "GFXD3D11ShaderConstBuffer::internalSet - Should only set handles which are owned by our shader");
const BufferKey bufDesc(_dxHandle->mBinding, (SHADER_STAGE)_dxHandle->mStage);
U8* buf = mBufferMap[bufDesc].data;
if (_dxHandle->mDesc.constType == GFXSCT_Float4x4)
{
// Special case, we can just blast this guy.
if (dMemcmp(buf + _dxHandle->mDesc.offset, data, inSize) != 0)
{
dMemcpy(buf + _dxHandle->mDesc.offset, data, inSize);
}
return;
}
else
{
PROFILE_SCOPE(GFXD3D11ConstBufferLayout_setMatrix_not4x4);
// Figure out how big of a chunk we are copying. We're going to copy 4 columns by N rows of data
U32 csize;
switch (_dxHandle->mDesc.constType)
{
case GFXSCT_Float2x2:
csize = 24; //this takes up 16+8
break;
case GFXSCT_Float3x3:
csize = 44; //This takes up 16+16+12
break;
case GFXSCT_Float4x3:
csize = 48;
break;
default:
AssertFatal(false, "Unhandled case!");
return;
break;
}
// Loop through and copy
bool ret = false;
U8* currDestPointer = buf + _dxHandle->mDesc.offset;
const U8* currSourcePointer = static_cast<const U8*>(data);
const U8* endData = currSourcePointer + inSize;
while (currSourcePointer < endData)
{
if (dMemcmp(currDestPointer, currSourcePointer, csize) != 0)
{
dMemcpy(currDestPointer, currSourcePointer, csize);
ret = true;
}
currDestPointer += csize;
currSourcePointer += sizeof(MatrixF);
}
}
}
void GFXD3D11ShaderConstBuffer::internalSet(GFXShaderConstHandle* handle, const U32 inSize, const void* data)
{
AssertFatal(handle, "GFXD3D11ShaderConstBuffer::internalSet - Handle is NULL!");
AssertFatal(handle->isValid(), "GFXD3D11ShaderConstBuffer::internalSet - Handle is not valid!");
AssertFatal(dynamic_cast<GFXD3D11ShaderConstHandle*>(handle), "GFXD3D11ShaderConstBuffer::internalSet - Incorrect const buffer type");
GFXD3D11ShaderConstHandle* _dxHandle = static_cast<GFXD3D11ShaderConstHandle*>(handle);
AssertFatal(mShader == _dxHandle->mShader, "GFXD3D11ShaderConstBuffer::internalSet - Should only set handles which are owned by our shader");
S32 size = inSize;
switch (_dxHandle->mDesc.constType)
{
case GFXSCT_Float2x2:
case GFXSCT_Float3x3:
case GFXSCT_Float4x3:
case GFXSCT_Float4x4:
setMatrix(handle, size, data);
return;
break;
// TODO add other AlignedVector here
case GFXSCT_Float2:
if (size > sizeof(Point2F))
size = _dxHandle->mDesc.size;
default:
break;
}
const BufferKey bufDesc(_dxHandle->mBinding, (SHADER_STAGE)_dxHandle->mStage);
U8* buf = mBufferMap[bufDesc].data;
if (dMemcmp(buf + _dxHandle->mDesc.offset, data, size) != 0)
{
dMemcpy(buf + _dxHandle->mDesc.offset, data, size);
}
}
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const F32 fv) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const F32 fv)
{ {
internalSet(handle, fv); internalSet(handle, sizeof(F32), &fv);
} }
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const Point2F& fv) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const Point2F& fv)
{ {
internalSet(handle, fv); internalSet(handle, sizeof(Point2F), &fv);
} }
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const Point3F& fv) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const Point3F& fv)
{ {
internalSet(handle, fv); internalSet(handle, sizeof(Point3F), &fv);
} }
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const Point4F& fv) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const Point4F& fv)
{ {
internalSet(handle, fv); internalSet(handle, sizeof(Point4F), &fv);
} }
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const PlaneF& fv) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const PlaneF& fv)
{ {
internalSet(handle, fv); internalSet(handle, sizeof(PlaneF), &fv);
} }
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const LinearColorF& fv) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const LinearColorF& fv)
{ {
internalSet(handle, fv); internalSet(handle, sizeof(Point4F), &fv);
} }
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const S32 fv) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const S32 fv)
@ -216,103 +316,62 @@ void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const S32 fv)
if ( ((GFXD3D11ShaderConstHandle*)handle)->isSampler() ) if ( ((GFXD3D11ShaderConstHandle*)handle)->isSampler() )
return; return;
internalSet(handle, fv); internalSet(handle, sizeof(S32), &fv);
} }
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const Point2I& fv) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const Point2I& fv)
{ {
internalSet(handle, fv); internalSet(handle, sizeof(Point2I), &fv);
} }
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const Point3I& fv) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const Point3I& fv)
{ {
internalSet(handle, fv); internalSet(handle, sizeof(Point3I), &fv);
} }
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const Point4I& fv) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const Point4I& fv)
{ {
internalSet(handle, fv); internalSet(handle, sizeof(Point4I), &fv);
}
template<typename ConstType>
void GFXD3D11ShaderConstBuffer::internalSet(GFXShaderConstHandle* handle, const ConstType& param)
{
AssertFatal(handle, "GFXD3D11ShaderConstBuffer::internalSet - Handle is NULL!");
AssertFatal(handle->isValid(), "GFXD3D11ShaderConstBuffer::internalSet - Handle is not valid!");
AssertFatal(dynamic_cast<GFXD3D11ShaderConstHandle*>(handle), "GFXD3D11ShaderConstBuffer::internalSet - Incorrect const buffer type");
GFXD3D11ShaderConstHandle* _dxHandle = static_cast<GFXD3D11ShaderConstHandle*>(handle);
AssertFatal(mShader == _dxHandle->mShader, "GFXD3D11ShaderConstBuffer::internalSet - Should only set handles which are owned by our shader");
const BufferKey bufDesc(_dxHandle->mBinding, (SHADER_STAGE)_dxHandle->mStage);
U8* buf = mBufferMap[bufDesc].data;
if (_dxHandle->mInstancingConstant)
buf = mInstPtr + _dxHandle->mOffset;
dMemcpy(buf + _dxHandle->mOffset, &param, sizeof(ConstType));
}
template<typename ConstType>
void GFXD3D11ShaderConstBuffer::internalSet(GFXShaderConstHandle* handle, const AlignedArray<ConstType>& fv)
{
AssertFatal(handle, "GFXD3D11ShaderConstBuffer::internalSet - Handle is NULL!");
AssertFatal(handle->isValid(), "GFXD3D11ShaderConstBuffer::internalSet - Handle is not valid!");
AssertFatal(dynamic_cast<GFXD3D11ShaderConstHandle*>(handle), "GFXD3D11ShaderConstBuffer::internalSet - Incorrect const buffer type");
GFXD3D11ShaderConstHandle* _dxHandle = static_cast<GFXD3D11ShaderConstHandle*>(handle);
AssertFatal(mShader == _dxHandle->mShader, "GFXD3D11ShaderConstBuffer::internalSet - Should only set handles which are owned by our shader");
AssertFatal(!_dxHandle->mInstancingConstant, "GFXD3D11ShaderConstBuffer::internalSet - Instancing not supported for array");
const BufferKey bufDesc(_dxHandle->mBinding, (SHADER_STAGE)_dxHandle->mStage);
U8* buf = mBufferMap[bufDesc].data;
const U8* fvBuffer = static_cast<const U8*>(fv.getBuffer());
U32 size = fv.getElementSize() * fv.size();
if (dMemcmp(buf + _dxHandle->mOffset, fvBuffer, _dxHandle->mSize) != 0)
{
dMemcpy(buf + _dxHandle->mOffset, fvBuffer, _dxHandle->mSize);
}
} }
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray<F32>& fv) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray<F32>& fv)
{ {
internalSet(handle, fv); internalSet(handle, fv.getElementSize() * fv.size(), fv.getBuffer());
} }
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray<Point2F>& fv) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray<Point2F>& fv)
{ {
internalSet(handle, fv); internalSet(handle, fv.getElementSize() * fv.size(), fv.getBuffer());
} }
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray<Point3F>& fv) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray<Point3F>& fv)
{ {
internalSet(handle, fv); internalSet(handle, fv.getElementSize() * fv.size(), fv.getBuffer());
} }
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray<Point4F>& fv) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray<Point4F>& fv)
{ {
internalSet(handle, fv); internalSet(handle, fv.getElementSize() * fv.size(), fv.getBuffer());
} }
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray<S32>& fv) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray<S32>& fv)
{ {
internalSet(handle, fv); internalSet(handle, fv.getElementSize() * fv.size(), fv.getBuffer());
} }
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray<Point2I>& fv) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray<Point2I>& fv)
{ {
internalSet(handle, fv); internalSet(handle, fv.getElementSize() * fv.size(), fv.getBuffer());
} }
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray<Point3I>& fv) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray<Point3I>& fv)
{ {
internalSet(handle, fv); internalSet(handle, fv.getElementSize() * fv.size(), fv.getBuffer());
} }
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray<Point4I>& fv) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const AlignedArray<Point4I>& fv)
{ {
internalSet(handle, fv); internalSet(handle, fv.getElementSize() * fv.size(), fv.getBuffer());
} }
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const MatrixF& mat, const GFXShaderConstType matrixType) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const MatrixF& mat, const GFXShaderConstType matrixType)
@ -324,8 +383,6 @@ void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const MatrixF&
const GFXD3D11ShaderConstHandle* _dxHandle = static_cast<const GFXD3D11ShaderConstHandle*>(handle); const GFXD3D11ShaderConstHandle* _dxHandle = static_cast<const GFXD3D11ShaderConstHandle*>(handle);
AssertFatal(!_dxHandle->isSampler(), "Handle is sampler constant!" ); AssertFatal(!_dxHandle->isSampler(), "Handle is sampler constant!" );
AssertFatal(_dxHandle->mShader == mShader, "Mismatched shaders!"); AssertFatal(_dxHandle->mShader == mShader, "Mismatched shaders!");
const BufferKey bufDesc(_dxHandle->mBinding, (SHADER_STAGE)_dxHandle->mStage);
U8* buf = mBufferMap[bufDesc].data;
MatrixF transposed; MatrixF transposed;
if (matrixType == GFXSCT_Float4x3) if (matrixType == GFXSCT_Float4x3)
@ -346,37 +403,7 @@ void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const MatrixF&
return; return;
} }
if (matrixType == GFXSCT_Float4x4) internalSet(handle, sizeof(MatrixF), &transposed);
{
if (dMemcmp(buf + _dxHandle->mOffset, &transposed, sizeof(MatrixF)) != 0)
{
dMemcpy(buf + _dxHandle->mOffset, &transposed, sizeof(MatrixF));
}
return;
}
U32 csize;
switch (matrixType)
{
case GFXSCT_Float2x2:
csize = 24; //this takes up 16+8
break;
case GFXSCT_Float3x3:
csize = 44; //This takes up 16+16+12
break;
case GFXSCT_Float4x3:
csize = 48;
break;
default:
return;
break;
}
if (dMemcmp(buf + _dxHandle->mOffset, &transposed, csize) != 0)
{
dMemcpy(buf + _dxHandle->mOffset, &transposed, csize);
}
} }
void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const MatrixF* mat, const U32 arraySize, const GFXShaderConstType matrixType) void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const MatrixF* mat, const U32 arraySize, const GFXShaderConstType matrixType)
@ -389,10 +416,6 @@ void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const MatrixF*
AssertFatal(!_dxHandle->isSampler(), "Handle is sampler constant!"); AssertFatal(!_dxHandle->isSampler(), "Handle is sampler constant!");
AssertFatal(_dxHandle->mShader == mShader, "Mismatched shaders!"); AssertFatal(_dxHandle->mShader == mShader, "Mismatched shaders!");
const BufferKey bufDesc(_dxHandle->mBinding, (SHADER_STAGE)_dxHandle->mStage);
U8* buf = mBufferMap[bufDesc].data;
static Vector<MatrixF> transposed; static Vector<MatrixF> transposed;
if (arraySize > transposed.size()) if (arraySize > transposed.size())
transposed.setSize(arraySize); transposed.setSize(arraySize);
@ -411,39 +434,7 @@ void GFXD3D11ShaderConstBuffer::set(GFXShaderConstHandle* handle, const MatrixF*
if (_dxHandle->mInstancingConstant) if (_dxHandle->mInstancingConstant)
return; return;
if (matrixType == GFXSCT_Float4x4) internalSet(handle, sizeof(MatrixF) * arraySize, transposed.begin());
{
if (dMemcmp(buf + _dxHandle->mOffset, transposed.begin(), sizeof(MatrixF) * arraySize) != 0)
{
dMemcpy(buf + _dxHandle->mOffset, transposed.begin(), sizeof(MatrixF) * arraySize);
}
return;
}
U32 csize;
switch (matrixType)
{
case GFXSCT_Float2x2:
csize = 24; //this takes up 16+8
break;
case GFXSCT_Float3x3:
csize = 44; //This takes up 16+16+12
break;
case GFXSCT_Float4x3:
csize = 48;
break;
default:
return;
break;
}
for (int i = 0; i < arraySize; i++)
{
if (dMemcmp(buf + _dxHandle->mOffset + (i * csize), transposed[i], csize) != 0)
{
dMemcpy(buf + _dxHandle->mOffset + (i * csize), transposed[i], csize);
}
}
} }
@ -672,7 +663,7 @@ bool GFXD3D11Shader::_compileShader( const Torque::Path &filePath,
ID3D11ShaderReflection* reflectionTable = NULL; ID3D11ShaderReflection* reflectionTable = NULL;
#ifdef TORQUE_GFX_VISUAL_DEBUG //for use with NSight, GPU Perf studio, VS graphics debugger #ifdef TORQUE_GFX_VISUAL_DEBUG //for use with NSight, GPU Perf studio, VS graphics debugger
U32 flags = D3DCOMPILE_DEBUG | D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_PREFER_FLOW_CONTROL | D3DCOMPILE_SKIP_OPTIMIZATION; U32 flags = D3DCOMPILE_DEBUG | D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_PREFER_FLOW_CONTROL | D3DCOMPILE_SKIP_OPTIMIZATION;
#elif defined(TORQUE_DEBUG) //debug build #elif defined(TORQUE_DEBUG) //debug build
U32 flags = D3DCOMPILE_DEBUG | D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_WARNINGS_ARE_ERRORS; U32 flags = D3DCOMPILE_DEBUG | D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_WARNINGS_ARE_ERRORS;
#else //release build #else //release build
@ -791,15 +782,15 @@ bool GFXD3D11Shader::_compileShader( const Torque::Path &filePath,
AssertFatal(false, "D3D11Shader::_compilershader- failed to create shader"); AssertFatal(false, "D3D11Shader::_compilershader- failed to create shader");
} }
if(res == S_OK) if(res == S_OK)
{ {
HRESULT reflectionResult = D3DReflect(code->GetBufferPointer(), code->GetBufferSize(), IID_ID3D11ShaderReflection, (void**)&reflectionTable); HRESULT reflectionResult = D3DReflect(code->GetBufferPointer(), code->GetBufferSize(), IID_ID3D11ShaderReflection, (void**)&reflectionTable);
if(FAILED(reflectionResult)) if(FAILED(reflectionResult))
AssertFatal(false, "D3D11Shader::_compilershader - Failed to get shader reflection table interface"); AssertFatal(false, "D3D11Shader::_compilershader - Failed to get shader reflection table interface");
} }
if(res == S_OK) if(res == S_OK)
_getShaderConstants(reflectionTable, shaderStage); _getShaderConstants(reflectionTable, shaderStage);
if(FAILED(res) && smLogErrors) if(FAILED(res) && smLogErrors)
Con::errorf("GFXD3D11Shader::_compileShader - Unable to create shader for '%s'.", filePath.getFullPath().c_str()); Con::errorf("GFXD3D11Shader::_compileShader - Unable to create shader for '%s'.", filePath.getFullPath().c_str());

6
Engine/source/gfx/D3D11/gfxD3D11Shader.h
View file

@ -163,11 +163,9 @@ protected:
WeakRefPtr<GFXD3D11Shader> mShader; WeakRefPtr<GFXD3D11Shader> mShader;
BufferMap mBufferMap; BufferMap mBufferMap;
template<typename ConstType> void setMatrix(GFXShaderConstHandle* handle, const U32 inSize, const void* data);
void internalSet(GFXShaderConstHandle* handle, const ConstType& param); void internalSet(GFXShaderConstHandle* handle, const U32 inSize, const void* data);
template<typename ConstType>
void internalSet(GFXShaderConstHandle* handle, const AlignedArray<ConstType>& fv);
// we probably want this to be GFXDevice and not per shader. // we probably want this to be GFXDevice and not per shader.
ID3D11Buffer* mBoundConstantBuffers[16]; ID3D11Buffer* mBoundConstantBuffers[16];