TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-07-13 23:54:35 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

bkup

Browse source 
still memory heap issue
This commit is contained in:
marauder2k7 2024-02-24 12:04:53 +00:00
parent 4caa54ad7e
commit 42b8748f5b
4 changed files with 121 additions and 81 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -157,6 +157,11 @@ GFXD3D11ShaderConstBuffer::~GFXD3D11ShaderConstBuffer()
{ {
delete[] i->value; delete[] i->value;
} }
mBufferMap.clear();
if (mShader)
mShader->_unlinkBuffer(this);
} }
GFXShader* GFXD3D11ShaderConstBuffer::getShader() GFXShader* GFXD3D11ShaderConstBuffer::getShader()
@ -234,7 +239,7 @@ void GFXD3D11ShaderConstBuffer::internalSet(GFXShaderConstHandle* handle, const
GFXD3D11ShaderConstHandle* _dxHandle = static_cast<GFXD3D11ShaderConstHandle*>(handle); GFXD3D11ShaderConstHandle* _dxHandle = static_cast<GFXD3D11ShaderConstHandle*>(handle);
AssertFatal(mShader == _dxHandle->mShader, "GFXD3D11ShaderConstBuffer::internalSet - Should only set handles which are owned by our shader"); AssertFatal(mShader == _dxHandle->mShader, "GFXD3D11ShaderConstBuffer::internalSet - Should only set handles which are owned by our shader");
BufferKey bufDesc(_dxHandle->mBinding, (SHADER_STAGE)_dxHandle->mStage); const BufferKey bufDesc(_dxHandle->mBinding, (SHADER_STAGE)_dxHandle->mStage);
U8* buf = mBufferMap[bufDesc] + _dxHandle->mOffset; U8* buf = mBufferMap[bufDesc] + _dxHandle->mOffset;
if (_dxHandle->mInstancingConstant) if (_dxHandle->mInstancingConstant)
@ -293,7 +298,7 @@ void GFXD3D11ShaderConstBuffer::internalSet(GFXShaderConstHandle* handle, const
GFXD3D11ShaderConstHandle* _dxHandle = static_cast<GFXD3D11ShaderConstHandle*>(handle); GFXD3D11ShaderConstHandle* _dxHandle = static_cast<GFXD3D11ShaderConstHandle*>(handle);
AssertFatal(mShader == _dxHandle->mShader, "GFXD3D11ShaderConstBuffer::internalSet - Should only set handles which are owned by our shader"); 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"); AssertFatal(!_dxHandle->mInstancingConstant, "GFXD3D11ShaderConstBuffer::internalSet - Instancing not supported for array");
BufferKey bufDesc(_dxHandle->mBinding, (SHADER_STAGE)_dxHandle->mStage); const BufferKey bufDesc(_dxHandle->mBinding, (SHADER_STAGE)_dxHandle->mStage);
U8* buf = mBufferMap[bufDesc]; U8* buf = mBufferMap[bufDesc];
const U8* fvBuffer = static_cast<const U8*>(fv.getBuffer()); const U8* fvBuffer = static_cast<const U8*>(fv.getBuffer());
for (U32 i = 0; i < fv.size(); ++i) for (U32 i = 0; i < fv.size(); ++i)
@ -313,7 +318,7 @@ 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!");
BufferKey bufDesc(_dxHandle->mBinding, (SHADER_STAGE)_dxHandle->mStage); const BufferKey bufDesc(_dxHandle->mBinding, (SHADER_STAGE)_dxHandle->mStage);
U8* buf = mBufferMap[bufDesc] + _dxHandle->mOffset; U8* buf = mBufferMap[bufDesc] + _dxHandle->mOffset;
MatrixF transposed; MatrixF transposed;
@ -372,7 +377,7 @@ 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!");
BufferKey bufDesc(_dxHandle->mBinding, (SHADER_STAGE)_dxHandle->mStage); const BufferKey bufDesc(_dxHandle->mBinding, (SHADER_STAGE)_dxHandle->mStage);
U8* buf = mBufferMap[bufDesc] ; U8* buf = mBufferMap[bufDesc] ;
@ -433,21 +438,18 @@ const String GFXD3D11ShaderConstBuffer::describeSelf() const
return ret; return ret;
} }
bool GFXD3D11ShaderConstBuffer::isDirty()
{
return true;
}
void GFXD3D11ShaderConstBuffer::addBuffer(U32 bufBindingPoint, SHADER_STAGE shaderStage, U32 size) void GFXD3D11ShaderConstBuffer::addBuffer(U32 bufBindingPoint, SHADER_STAGE shaderStage, U32 size)
{ {
BufferKey bufKey(bufBindingPoint, shaderStage); const BufferKey bufKey(bufBindingPoint, shaderStage);
BufferMap::Iterator buffer = mBufferMap.find(bufKey); BufferMap::Iterator buffer = mBufferMap.find(bufKey);
// already added? pass... // already added? pass...
if (buffer != mBufferMap.end()) if (buffer != mBufferMap.end())
return; return;
U8* buf = new U8[size];
dMemset(buf, 0, size);
// new buffer with our size. // new buffer with our size.
mBufferMap[bufKey] = new U8[size]; mBufferMap[bufKey] = buf;
} }
void GFXD3D11ShaderConstBuffer::activate( GFXD3D11ShaderConstBuffer *prevShaderBuffer ) void GFXD3D11ShaderConstBuffer::activate( GFXD3D11ShaderConstBuffer *prevShaderBuffer )
@ -461,6 +463,11 @@ void GFXD3D11ShaderConstBuffer::onShaderReload( GFXD3D11Shader *shader )
{ {
AssertFatal( shader == mShader, "GFXD3D11ShaderConstBuffer::onShaderReload is hosed!" ); AssertFatal( shader == mShader, "GFXD3D11ShaderConstBuffer::onShaderReload is hosed!" );
for (BufferMap::Iterator i = mBufferMap.begin(); i != mBufferMap.end(); i++)
{
delete[] i->value;
}
// Set the lost state. // Set the lost state.
mWasLost = true; mWasLost = true;
} }
@ -496,6 +503,10 @@ GFXD3D11Shader::~GFXD3D11Shader()
delete[] i->value; delete[] i->value;
} }
mHandles.clear();
mBuffers.clear();
for (U32 i = 0; i < 16; i++) for (U32 i = 0; i < 16; i++)
{ {
SAFE_RELEASE(mBoundConstantBuffers[i]); SAFE_RELEASE(mBoundConstantBuffers[i]);
@ -536,7 +547,7 @@ bool GFXD3D11Shader::_init()
memset(&d3dMacros[macroCount - 1], 0, sizeof(D3D_SHADER_MACRO)); memset(&d3dMacros[macroCount - 1], 0, sizeof(D3D_SHADER_MACRO));
mShaderConsts.clear(); mShaderConsts.clear();
mSamplerDescriptions.clear();
if (!mVertexFile.isEmpty() && !_compileShader( mVertexFile, SHADER_STAGE::VERTEX_SHADER, d3dMacros) ) if (!mVertexFile.isEmpty() && !_compileShader( mVertexFile, SHADER_STAGE::VERTEX_SHADER, d3dMacros) )
return false; return false;
@ -662,36 +673,37 @@ bool GFXD3D11Shader::_compileShader( const Torque::Path &filePath,
if(code != NULL) if(code != NULL)
{ {
switch (shaderStage) switch (shaderStage)
{ {
case VERTEX_SHADER: case VERTEX_SHADER:
res = D3D11DEVICE->CreateVertexShader(code->GetBufferPointer(), code->GetBufferSize(), NULL, &mVertShader); res = D3D11DEVICE->CreateVertexShader(code->GetBufferPointer(), code->GetBufferSize(), NULL, &mVertShader);
break; break;
case PIXEL_SHADER: case PIXEL_SHADER:
res = D3D11DEVICE->CreatePixelShader(code->GetBufferPointer(), code->GetBufferSize(), NULL, &mPixShader); res = D3D11DEVICE->CreatePixelShader(code->GetBufferPointer(), code->GetBufferSize(), NULL, &mPixShader);
break; break;
case GEOMETRY_SHADER: case GEOMETRY_SHADER:
break; break;
case DOMAIN_SHADER: case DOMAIN_SHADER:
break; break;
case HULL_SHADER: case HULL_SHADER:
break; break;
case COMPUTE_SHADER: case COMPUTE_SHADER:
break; break;
default: default:
break; break;
} }
if (FAILED(res)) if (FAILED(res))
{ {
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); {
if(FAILED(reflectionResult)) HRESULT reflectionResult = D3DReflect(code->GetBufferPointer(), code->GetBufferSize(), IID_ID3D11ShaderReflection, (void**)&reflectionTable);
AssertFatal(false, "D3D11Shader::_compilershader - Failed to get shader reflection table interface"); if(FAILED(reflectionResult))
} 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);
@ -704,29 +716,28 @@ bool GFXD3D11Shader::_compileShader( const Torque::Path &filePath,
bool result = code && SUCCEEDED(res); bool result = code && SUCCEEDED(res);
#ifdef TORQUE_DEBUG #ifdef TORQUE_DEBUG
//String shader;
String shader; //switch (shaderStage)
switch (shaderStage) //{
{ //case VERTEX_SHADER:
case VERTEX_SHADER: // shader = mVertexFile.getFileName();
shader = mVertexFile.getFileName(); // mVertShader->SetPrivateData(WKPDID_D3DDebugObjectName, shader.size(), shader.c_str());
mVertShader->SetPrivateData(WKPDID_D3DDebugObjectName, shader.size(), shader.c_str()); // break;
break; //case PIXEL_SHADER:
case PIXEL_SHADER: // shader = mPixelFile.getFileName();
shader = mPixelFile.getFileName(); // mPixShader->SetPrivateData(WKPDID_D3DDebugObjectName, shader.size(), shader.c_str());
mPixShader->SetPrivateData(WKPDID_D3DDebugObjectName, shader.size(), shader.c_str()); // break;
break; //case GEOMETRY_SHADER:
case GEOMETRY_SHADER: // break;
break; //case DOMAIN_SHADER:
case DOMAIN_SHADER: // break;
break; //case HULL_SHADER:
case HULL_SHADER: // break;
break; //case COMPUTE_SHADER:
case COMPUTE_SHADER: // break;
break; //default:
default: // break;
break; //}
}
#endif #endif
SAFE_RELEASE(code); SAFE_RELEASE(code);
@ -768,6 +779,9 @@ void GFXD3D11Shader::_getShaderConstants( ID3D11ShaderReflection *refTable,
constantBuffer->GetDesc(&constantBufferDesc); constantBuffer->GetDesc(&constantBufferDesc);
#ifdef D3D11_DEBUG_SPEW
Con::printf("Constant Buffer Name: %s", constantBufferDesc.Name);
#endif
// push back our const buffer as a descriptor, this also marks the start of a buffer. // push back our const buffer as a descriptor, this also marks the start of a buffer.
desc.size = constantBufferDesc.Size; desc.size = constantBufferDesc.Size;
mShaderConsts.push_back(desc); mShaderConsts.push_back(desc);
@ -783,6 +797,10 @@ void GFXD3D11Shader::_getShaderConstants( ID3D11ShaderReflection *refTable,
D3D11_SHADER_TYPE_DESC shaderTypeDesc; D3D11_SHADER_TYPE_DESC shaderTypeDesc;
bufferVar->GetType()->GetDesc(&shaderTypeDesc); bufferVar->GetType()->GetDesc(&shaderTypeDesc);
bool unusedVar = shaderVarDesc.uFlags & D3D_SVF_USED ? false : true;
if (unusedVar)
continue;
varDesc.name = String(shaderVarDesc.Name); varDesc.name = String(shaderVarDesc.Name);
if (varDesc.name.find("$") != 0) if (varDesc.name.find("$") != 0)
varDesc.name = String::ToString("$%s", varDesc.name.c_str()); varDesc.name = String::ToString("$%s", varDesc.name.c_str());
@ -795,6 +813,10 @@ void GFXD3D11Shader::_getShaderConstants( ID3D11ShaderReflection *refTable,
varDesc.shaderStage = shaderStage; varDesc.shaderStage = shaderStage;
varDesc.samplerReg = -1; varDesc.samplerReg = -1;
#ifdef D3D11_DEBUG_SPEW
Con::printf("Variable Name %s:, offset: %d, size: %d, constantDesc.Elements: %d", varDesc.name.c_str(), varDesc.StartOffset, varDesc.Size, varDesc.arraySize);
#endif
if (shaderTypeDesc.Class == D3D_SVC_SCALAR || shaderTypeDesc.Class == D3D_SVC_VECTOR) if (shaderTypeDesc.Class == D3D_SVC_SCALAR || shaderTypeDesc.Class == D3D_SVC_VECTOR)
{ {
switch (shaderTypeDesc.Type) switch (shaderTypeDesc.Type)
@ -882,7 +904,8 @@ void GFXD3D11Shader::_getShaderConstants( ID3D11ShaderReflection *refTable,
desc.samplerReg = shaderInputBind.BindPoint; desc.samplerReg = shaderInputBind.BindPoint;
desc.bindPoint = -1; desc.bindPoint = -1;
desc.shaderStage = shaderStage; desc.shaderStage = shaderStage;
mShaderConsts.push_back(desc); desc.arraySize = shaderInputBind.BindCount;
mSamplerDescriptions.push_back(desc);
} }
else if (shaderInputBind.Type == D3D_SIT_UAV_RWTYPED || else if (shaderInputBind.Type == D3D_SIT_UAV_RWTYPED ||
shaderInputBind.Type == D3D_SIT_UAV_RWSTRUCTURED || shaderInputBind.Type == D3D_SIT_UAV_RWSTRUCTURED ||
@ -943,8 +966,7 @@ void GFXD3D11Shader::_buildShaderConstantHandles()
if (desc.constType == GFXSCT_ConstBuffer) if (desc.constType == GFXSCT_ConstBuffer)
{ {
BufferKey bufKey(desc.bindPoint, (SHADER_STAGE)desc.shaderStage); const BufferKey bufKey(desc.bindPoint, (SHADER_STAGE)desc.shaderStage);
BufferMap::Iterator buffer = mBuffers.find(bufKey); BufferMap::Iterator buffer = mBuffers.find(bufKey);
// already added? pass... // already added? pass...
@ -970,8 +992,10 @@ void GFXD3D11Shader::_buildShaderConstantHandles()
mBoundConstantBuffers[desc.bindPoint] = constBuffer; mBoundConstantBuffers[desc.bindPoint] = constBuffer;
U8* buf = new U8[desc.size];
dMemset(buf, 0, desc.size);
// new buffer with our size. // new buffer with our size.
mBuffers[bufKey] = new U8[desc.size]; mBuffers[bufKey] = buf;
// do not add to handles.. // do not add to handles..
continue; continue;
@ -990,6 +1014,29 @@ void GFXD3D11Shader::_buildShaderConstantHandles()
} }
} }
for (U32 i = 0; i < mSamplerDescriptions.size(); i++)
{
GFXShaderConstDesc& desc = mSamplerDescriptions[i];
AssertFatal(desc.constType == GFXSCT_Sampler ||
desc.constType == GFXSCT_SamplerCube ||
desc.constType == GFXSCT_SamplerCubeArray ||
desc.constType == GFXSCT_SamplerTextureArray,
"GFXD3D11Shader::_buildShaderConstantHandles - Invalid samplerDescription type!");
HandleMap::Iterator handle = mHandles.find(desc.name);
// already added? reinit just in case..
// not sure if we need to do anything different with samplers.
if (handle != mHandles.end())
{
handle->value->reinit(desc);
}
else
{
mHandles[desc.name] = new GFXD3D11ShaderConstHandle(this, desc);
}
}
_buildInstancingShaderConstantHandles(); _buildInstancingShaderConstantHandles();
} }
@ -1040,9 +1087,12 @@ void GFXD3D11Shader::setConstantsFromBuffer(GFXD3D11ShaderConstBuffer* buffer)
{ {
BufferRange bufRanges[6] = {}; BufferRange bufRanges[6] = {};
D3D11_MAPPED_SUBRESOURCE pConstData;
ZeroMemory(&pConstData, sizeof(D3D11_MAPPED_SUBRESOURCE));
for (BufferMap::Iterator i = mBuffers.begin(); i != mBuffers.end(); ++i) for (BufferMap::Iterator i = mBuffers.begin(); i != mBuffers.end(); ++i)
{ {
BufferKey oldBufferDesc = i->key; const BufferKey oldBufferDesc = i->key;
U8* oldBuff = i->value; U8* oldBuff = i->value;
U8* newBuff = buffer->mBufferMap[i->key]; U8* newBuff = buffer->mBufferMap[i->key];

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

@ -29,7 +29,6 @@
#include "core/util/tDictionary.h" #include "core/util/tDictionary.h"
#include "gfx/gfxShader.h" #include "gfx/gfxShader.h"
#include "gfx/gfxResource.h" #include "gfx/gfxResource.h"
#include "gfx/genericConstBuffer.h"
#include "gfx/D3D11/gfxD3D11Device.h" #include "gfx/D3D11/gfxD3D11Device.h"
class GFXD3D11Shader; class GFXD3D11Shader;
@ -50,7 +49,7 @@ typedef CompoundKey<U32, SHADER_STAGE> BufferKey;
struct BufferRange struct BufferRange
{ {
U32 mBufMin = 0xFFFFFFFF; U32 mBufMin = U32_MAX;
U32 mBufMax = 0; U32 mBufMax = 0;
inline void addSlot(U32 slot) inline void addSlot(U32 slot)
@ -116,9 +115,6 @@ public:
/// @param mPrevShaderBuffer The previously active buffer /// @param mPrevShaderBuffer The previously active buffer
void activate(GFXD3D11ShaderConstBuffer *prevShaderBuffer); void activate(GFXD3D11ShaderConstBuffer *prevShaderBuffer);
/// Used internally by GXD3D11ShaderConstBuffer to determine if it's dirty.
bool isDirty();
void addBuffer(U32 bufBindingPoint, SHADER_STAGE shaderStage, U32 size); void addBuffer(U32 bufBindingPoint, SHADER_STAGE shaderStage, U32 size);
/// Called from GFXD3D11Shader when constants have changed and need /// Called from GFXD3D11Shader when constants have changed and need
@ -191,7 +187,6 @@ public:
virtual GFXShaderConstHandle* getShaderConstHandle(const String& name); virtual GFXShaderConstHandle* getShaderConstHandle(const String& name);
virtual GFXShaderConstHandle* findShaderConstHandle(const String& name); virtual GFXShaderConstHandle* findShaderConstHandle(const String& name);
virtual U32 getAlignmentValue(const GFXShaderConstType constType) const; virtual U32 getAlignmentValue(const GFXShaderConstType constType) const;
virtual bool getDisassembly( String &outStr ) const;
// GFXResource // GFXResource
virtual void zombify(); virtual void zombify();
@ -201,8 +196,6 @@ protected:
virtual bool _init(); virtual bool _init();
static const U32 smCompiledShaderTag;
ID3D11VertexShader *mVertShader; ID3D11VertexShader *mVertShader;
ID3D11PixelShader *mPixShader; ID3D11PixelShader *mPixShader;
@ -216,8 +209,7 @@ protected:
/// Vector of descriptions (consolidated for the getShaderConstDesc call) /// Vector of descriptions (consolidated for the getShaderConstDesc call)
Vector<GFXShaderConstDesc> mShaderConsts; Vector<GFXShaderConstDesc> mShaderConsts;
Vector<GFXShaderConstDesc> mSamplerDescriptions;
//Vector<ID3D11Buffer*> mDeviceBuffers;
// These two functions are used when compiling shaders from hlsl // These two functions are used when compiling shaders from hlsl
virtual bool _compileShader( const Torque::Path &filePath, virtual bool _compileShader( const Torque::Path &filePath,

1
Engine/source/materials/processedCustomMaterial.cpp
View file

@ -35,7 +35,6 @@
#include "materials/materialParameters.h" #include "materials/materialParameters.h"
#include "gfx/sim/gfxStateBlockData.h" #include "gfx/sim/gfxStateBlockData.h"
#include "core/util/safeDelete.h" #include "core/util/safeDelete.h"
#include "gfx/genericConstBuffer.h"
#include "console/simFieldDictionary.h" #include "console/simFieldDictionary.h"
#include "console/propertyParsing.h" #include "console/propertyParsing.h"
#include "gfx/util/screenspace.h" #include "gfx/util/screenspace.h"

1
Engine/source/materials/processedShaderMaterial.cpp
View file

@ -26,7 +26,6 @@
#include "core/util/safeDelete.h" #include "core/util/safeDelete.h"
#include "gfx/sim/cubemapData.h" #include "gfx/sim/cubemapData.h"
#include "gfx/gfxShader.h" #include "gfx/gfxShader.h"
#include "gfx/genericConstBuffer.h"
#include "gfx/gfxPrimitiveBuffer.h" #include "gfx/gfxPrimitiveBuffer.h"
#include "scene/sceneRenderState.h" #include "scene/sceneRenderState.h"
#include "shaderGen/shaderFeature.h" #include "shaderGen/shaderFeature.h"