/**
* Extract Shader Storage Buffer data from the shader
*/
void Program::ExtractStorageBlockData()
{
GLint numBlocks = 0;
glGetProgramInterfaceiv(_program, GL_SHADER_STORAGE_BLOCK, GL_ACTIVE_RESOURCES, &numBlocks);
char tempNameAR[1024];
Log("\tBuffer :")
for (int blockIdx = 0; blockIdx < numBlocks; blockIdx++)
{
std::vector<BufferVariableInfo> vars;
glGetProgramResourceName(_program, GL_SHADER_STORAGE_BLOCK, blockIdx, 1024, NULL, tempNameAR);
std::string bufferName(tempNameAR);
GLint binding = 0;
{
GLenum prop[] = { GL_BUFFER_BINDING };
glGetProgramResourceiv(_program, GL_SHADER_STORAGE_BLOCK, blockIdx, 1, prop, 1, NULL, &binding);
}
Log("\t\t" + bufferName + " index " + ToString(blockIdx) + " binding " + ToString(binding));
GLint vcount = 0;
{
GLenum prop[] = { GL_NUM_ACTIVE_VARIABLES };
glGetProgramResourceiv(_program, GL_SHADER_STORAGE_BLOCK, blockIdx, 1, prop, 1, NULL, &vcount);
}
std::vector<GLint> variables(vcount);
{
GLenum prop[] = { GL_ACTIVE_VARIABLES };
glGetProgramResourceiv(_program, GL_SHADER_STORAGE_BLOCK, blockIdx, 1, prop, vcount, NULL, &variables.front());
}
GLchar vnameAR[128] = { 0 };
for (int k = 0; k < vcount; k++)
{
GLenum propsAR[] = { GL_OFFSET, GL_TYPE, GL_ARRAY_STRIDE, GL_MATRIX_STRIDE, GL_IS_ROW_MAJOR, GL_TOP_LEVEL_ARRAY_STRIDE };
GLint paramsAR[sizeof(propsAR) / sizeof(GLenum)];
glGetProgramResourceiv(_program, GL_BUFFER_VARIABLE, variables[k], sizeof(propsAR) / sizeof(GLenum), propsAR, sizeof(paramsAR) / sizeof(GLenum), NULL, paramsAR);
glGetProgramResourceName(_program, GL_BUFFER_VARIABLE, variables[k], sizeof(vnameAR), NULL, vnameAR);
Log("\t\t\t" + std::string(vnameAR) + " offset " + ToString(paramsAR[0]) + " type " + GLUtil::GLSLTypeToStr(GLenum(paramsAR[1])) + " array stride " + ToString(paramsAR[2]) + " top level stride " + ToString(paramsAR[5]));
vars.push_back(BufferVariableInfo(std::string(vnameAR), paramsAR[0], GLenum(paramsAR[1]), paramsAR[2], paramsAR[3], GLboolean(paramsAR[4]), paramsAR[5]));
}
_buffers.insert(std::make_pair(bufferName, BufferInfo(bufferName, blockIdx, vars)));
}
}
bool CoreIrcListHelper::dispatchQuery(const NetworkId &netId, const QString &query) {
CoreNetwork *network = coreSession()->network(netId);
if(network) {
_channelLists[netId] = QList<ChannelDescription>();
network->userInputHandler()->handleList(BufferInfo(), query);
_queryTimeout[startTimer(10000)] = netId;
return true;
} else {
return false;
}
}
bool CoreIrcListHelper::dispatchQuery(const NetworkId &netId, const QString &query)
{
CoreNetwork *network = coreSession()->network(netId);
if (network) {
_channelLists[netId] = QList<ChannelDescription>();
network->userInputHandler()->handleList(BufferInfo(), query);
auto timer = std::make_shared<QBasicTimer>();
timer->start(kTimeoutMs, this);
_queryTimeoutByNetId[netId] = timer;
_queryTimeoutByTimerId[timer->timerId()] = netId;
return true;
}
else {
return false;
}
}
BufferInfo BufferInfo::fakeStatusBuffer(NetworkId networkId)
{
return BufferInfo(0, networkId, StatusBuffer);
}
void SimpleDeferredDemo::renderPost()
{
// if(1) return;
ADLASSERT( TILE_SIZE <= 16 );
int nClusterX = calcNumTiles(g_wWidth, CLUSTER_SIZE);//max2( 1, (g_wWidth/CLUSTER_SIZE)+(!(g_wWidth%CLUSTER_SIZE)?0:1) );
int nClusterY = calcNumTiles(g_wHeight, CLUSTER_SIZE);//max2( 1, (g_wHeight/CLUSTER_SIZE)+(!(g_wHeight%CLUSTER_SIZE)?0:1) );
// todo. define own constant buffer
ConstantBuffer cb;
{
cb.m_world = XMMatrixIdentity();
cb.m_view = g_ViewTr;
cb.m_projection = g_ProjectionTr;
}
{ // clear lightIdxBuffer
BufferInfo bInfo[] = { BufferInfo( &m_tileBuffer ) };
Launcher launcher( m_deviceData, &m_clearLightIdxKernel );
launcher.setBuffers( bInfo, sizeof(bInfo)/sizeof(Launcher::BufferInfo) );
// launcher.pushBackRW( m_tileBuffer );
launcher.launch1D( nClusterX*nClusterY*MAX_LIGHTS_PER_TILE_IN_32B );
}
{ // set lightIdxBuffer
BufferInfo bInfo[] = { BufferInfo( &m_lightPosBuffer, true ), BufferInfo( &m_lightColorBuffer, true ),
BufferInfo( &m_tileBuffer )
};
Launcher launcher( m_deviceData, &m_buildLightIdxKernel );
launcher.setBuffers( bInfo, sizeof(bInfo)/sizeof(Launcher::BufferInfo) );
// launcher.pushBackR( m_lightPosBuffer );
// launcher.pushBackR( m_lightColorBuffer );
// launcher.pushBackRW( m_tileBuffer );
launcher.setConst( g_constBuffer, cb );
launcher.launch1D( 64 );
}
Stopwatch dsw( m_deviceData );
dsw.start();
{ // run CS
BufferDX11<int> cBuffer;
cBuffer.m_srv = m_colorRT.m_srv;
BufferDX11<int> pBuffer;
pBuffer.m_srv = m_posRT.m_srv;
BufferDX11<int> nBuffer;
nBuffer.m_srv = m_normalRT.m_srv;
BufferInfo bInfo[] = { BufferInfo( &m_lightPosBuffer, true ), BufferInfo( &m_lightColorBuffer, true ), BufferInfo( &cBuffer, true ),
BufferInfo( &pBuffer, true ), BufferInfo( &nBuffer, true ), BufferInfo( &m_tileBuffer, true ),
BufferInfo( &m_buffer )
};
Launcher launcher( m_deviceData, &m_kernel );
launcher.setBuffers( bInfo, sizeof(bInfo)/sizeof(Launcher::BufferInfo) );
// launcher.pushBackR( m_lightPosBuffer );
// launcher.pushBackR( m_lightColorBuffer );
// launcher.pushBackR( cBuffer );
// launcher.pushBackR( pBuffer );
// launcher.pushBackR( nBuffer );
// launcher.pushBackR( m_tileBuffer );
// launcher.pushBackRW( m_buffer );
launcher.setConst( g_constBuffer, cb );
launcher.launch2D( nClusterX*TILE_SIZE, nClusterY*TILE_SIZE, TILE_SIZE, TILE_SIZE );
}
dsw.stop();
{
m_nTxtLines = 0;
sprintf_s(m_txtBuffer[m_nTxtLines++], LINE_CAPACITY, "%3.3fms", dsw.getMs());
}
//
DeviceDX11* dd = (DeviceDX11*)m_deviceData;
ID3D11RenderTargetView* pOrigRTV = NULL;
ID3D11DepthStencilView* pOrigDSV = NULL;
dd->m_context->OMGetRenderTargets( 1, &pOrigRTV, &pOrigDSV );
// release for the renderPre
pOrigRTV->Release();
pOrigDSV->Release();
{
float ClearColor[4] = { 0.f, 0.f, 0.f, 1.0f };
ID3D11RenderTargetView* aRTViews[ 1 ] = { pOrigRTV };
dd->m_context->OMSetRenderTargets( 1, aRTViews, pOrigDSV );
dd->m_context->ClearDepthStencilView( pOrigDSV, D3D11_CLEAR_DEPTH, 1.0f, 0 );
dd->m_context->ClearRenderTargetView( pOrigRTV, ClearColor );
dd->m_context->PSSetShaderResources( 0, 1, ((BufferDX11<float4>*)&m_buffer)->getSRVPtr() );
// render to screen
renderFullQuad( m_deviceData, &g_bufferToRTPixelShader, make_float4((float)g_wWidth, (float)g_wHeight, 0,0 ) );
ID3D11ShaderResourceView* ppSRVNULL[16] = { 0 };
dd->m_context->PSSetShaderResources( 0, 1, ppSRVNULL );
}
pOrigRTV->Release();
pOrigDSV->Release();
g_defaultVertexShader = m_gVShader;
g_defaultPixelShader = m_gPShader;
}
inline void reset()
{
*this = BufferInfo();
}
void BufferItem::setBufferName(const QString &name)
{
_bufferInfo = BufferInfo(_bufferInfo.bufferId(), _bufferInfo.networkId(), _bufferInfo.type(), _bufferInfo.groupId(), name);
emit dataChanged(0);
}
BoxGeometry::BoxGeometry(
String name,
const Vector3D& halfExtends,
bool addTangents,
bool patchRepresentation,
const Vector4D& texcoordScale)
: VertexBasedGeometry(name,
patchRepresentation ? VERTEX_BASED_TRIANGLE_PATCHES : VERTEX_BASED_TRIANGLES),
mHalfExtends(halfExtends)
{
BufferInfo bufferi(
name + String("BoxGeometryPositionBuffer"),
ContextTypeFlags(HOST_CONTEXT_TYPE_FLAG | OPEN_GL_CONTEXT_TYPE_FLAG),
POSITION_SEMANTICS,
TYPE_VEC4F,
6* 4 , //because of the normals, the vertices cannot be shared ;(
BufferElementInfo(4,GPU_DATA_TYPE_FLOAT,32,false),
VERTEX_ATTRIBUTE_BUFFER_TYPE,
NO_CONTEXT_TYPE
);
setAttributeBuffer(new Buffer(bufferi,false,0));
bufferi.name = name + String("BoxGeometryNormalBuffer");
bufferi.bufferSemantics = NORMAL_SEMANTICS;
setAttributeBuffer(new Buffer(bufferi,false,0));
if(addTangents)
{
bufferi.name = name + String("BoxGeometryTangentBuffer");
bufferi.bufferSemantics = TANGENT_SEMANTICS;
setAttributeBuffer( new Buffer( bufferi, false, 0 ) );
}
bufferi.name = name + String( "BoxGeometryTexCoordBuffer");
bufferi.bufferSemantics = TEXCOORD_SEMANTICS;
setAttributeBuffer(new Buffer(bufferi,false,0));
setIndexBuffer(
new Buffer(
BufferInfo(
name + String("BoxGeometryIndexBuffer"),
ContextTypeFlags(HOST_CONTEXT_TYPE_FLAG | OPEN_GL_CONTEXT_TYPE_FLAG),
INDEX_SEMANTICS,
TYPE_UINT32,
6 * 6, //6 faces * 2* triangles @ 3 verts
BufferElementInfo(1,GPU_DATA_TYPE_UINT,32,false),
VERTEX_INDEX_BUFFER_TYPE,
NO_CONTEXT_TYPE
)
)
);
Vector4D* posBuffer = reinterpret_cast<Vector4D*>(getAttributeBuffer(POSITION_SEMANTICS)->getCPUBufferHandle());
Vector4D* normalBuffer =reinterpret_cast<Vector4D*>(getAttributeBuffer(NORMAL_SEMANTICS)->getCPUBufferHandle());
Vector4D* tangentBuffer = 0;
if(addTangents) {
tangentBuffer = reinterpret_cast<Vector4D*>(getAttributeBuffer(TANGENT_SEMANTICS)->getCPUBufferHandle());
}
Vector4D* tcBuffer = reinterpret_cast<Vector4D*>(getAttributeBuffer(TEXCOORD_SEMANTICS)->getCPUBufferHandle());
unsigned int* indexBuffer = reinterpret_cast<unsigned int*>(getIndexBuffer()->getCPUBufferHandle());
//iterate over the six faces:
for(int axis=0; axis<3; axis++)
{
for(int side = 1; side >= -1; side -= 2)
{
Vector3D normal = Vector3D(axis==0?side:0,axis==1?side:0, axis==2?side:0);
Vector3D left = Vector3D(
((axis==2) || (axis ==1)) ? -side : 0,
0,
axis==0?side:0
);
Vector3D down= glm::cross(normal,left);
Vector3D tangent = left * (-1.0f);
int vertexIndexBase = 8* axis + 4*(1-(side+1)/2);
int indexIndexBase = 12* axis + 6*(1-(side+1)/2);
//lower left
posBuffer[vertexIndexBase + 0] = Vector4D( (normal + left + down)* halfExtends, 1 );
normalBuffer[vertexIndexBase + 0] = Vector4D( normal, 0 );
if(addTangents){
tangentBuffer[vertexIndexBase+0]= Vector4D( tangent, 0 );
}
tcBuffer[vertexIndexBase + 0] = Vector4D(0,0,0, 0 ) * texcoordScale;
//lower right
posBuffer[vertexIndexBase + 1] = Vector4D( (normal - left + down)* halfExtends , 1 );
normalBuffer[vertexIndexBase + 1] = Vector4D( normal, 0 );
if(addTangents){
tangentBuffer[vertexIndexBase+1]= Vector4D( tangent, 0 );
}
tcBuffer[vertexIndexBase + 1] = Vector4D(1,0,0, 0 )* texcoordScale;
//upper right
posBuffer[vertexIndexBase + 2] = Vector4D( (normal - left - down)* halfExtends , 1 );
normalBuffer[vertexIndexBase + 2] = Vector4D( normal, 0 );
if(addTangents){
tangentBuffer[vertexIndexBase+2]= Vector4D( tangent, 0 );
}
tcBuffer[vertexIndexBase + 2] = Vector4D(1,1,0, 0 )* texcoordScale;
//upper left
posBuffer[vertexIndexBase + 3] = Vector4D( (normal + left - down)* halfExtends , 1 );
normalBuffer[vertexIndexBase + 3] = Vector4D( normal, 0 );
if(addTangents){
tangentBuffer[vertexIndexBase+3]= Vector4D( tangent, 0 );
}
tcBuffer[vertexIndexBase + 3] = Vector4D(0,1,0, 0 )* texcoordScale;
indexBuffer[indexIndexBase + 0]= vertexIndexBase + 0;
indexBuffer[indexIndexBase + 1]= vertexIndexBase + 1;
indexBuffer[indexIndexBase + 2]= vertexIndexBase + 2;
indexBuffer[indexIndexBase + 3]= vertexIndexBase + 0;
indexBuffer[indexIndexBase + 4]= vertexIndexBase + 2;
indexBuffer[indexIndexBase + 5]= vertexIndexBase + 3;
// LOG<<DEBUG_LOG_LEVEL<<"VERTICES OF BOX, face "<<
// ((side>0)?"positive":"negative") <<
// ( (axis==0)
// ?" X"
// :( (axis==1)
// ?" Y"
// :" Z" ) )
//
// << ": \n";
// for(int i=0;i<4;i++)
// {
// LOG<<DEBUG_LOG_LEVEL
// <<"Index of vertex :"<<vertexIndexBase+i
// <<"; Vertex coords: "<<posBuffer[vertexIndexBase + i]
// <<"; Normal: "<<normalBuffer[vertexIndexBase + i]
// <<"; start index for face in index buffer: "<<indexIndexBase<<";\n"
// ;
// }
}
}
getAttributeBuffer(POSITION_SEMANTICS)->copyFromHostToGPU();
getAttributeBuffer(NORMAL_SEMANTICS)->copyFromHostToGPU();
if(addTangents){getAttributeBuffer(TANGENT_SEMANTICS)->copyFromHostToGPU();}
getAttributeBuffer(TEXCOORD_SEMANTICS)->copyFromHostToGPU();
getIndexBuffer()->copyFromHostToGPU();
}
void LightSourceManager::init()
{
if(
(ShaderManager::getInstance().getGlobalShaderFeatures().lightSourcesLightingFeature
== LIGHT_SOURCES_LIGHTING_FEATURE_ALL_POINT_LIGHTS )
|| (ShaderManager::getInstance().getGlobalShaderFeatures().lightSourcesLightingFeature
== LIGHT_SOURCES_LIGHTING_FEATURE_ALL_SPOT_LIGHTS )
|| (ShaderManager::getInstance().getGlobalShaderFeatures().lightSourcesLightingFeature
== LIGHT_SOURCES_LIGHTING_FEATURE_ALL_POINT_OR_SPOT_LIGHTS )
)
{
std::vector<String> memberStrings=
{
"position","diffuseColor","specularColor","direction",
"innerSpotCutOff_Radians","outerSpotCutOff_Radians","spotExponent","shadowMapLayer"
};
mLightSourceBufferMetaInfo = new UniformBufferMetaInfo(
mNumMaxLightSources,
String("LightSourceBuffer"), String("lightSources"),
memberStrings,
ShaderManager::getInstance().getUniformBufferOffsetQueryShader(false));
//queryLightSourceBufferSizeAndOffsets();
assert( (mLightSourceBufferMetaInfo->mRequiredBufferSize % BufferHelper::elementSize(TYPE_FLOAT))== 0);
mLightSourcesUniformBuffer = new Buffer(
BufferInfo(
String("LightSourceUniformBuffer"),
ContextTypeFlags(HOST_CONTEXT_TYPE_FLAG | OPEN_GL_CONTEXT_TYPE_FLAG),
LIGHT_SOURCE_BUFFER_SEMANTICS,
TYPE_FLOAT,
mLightSourceBufferMetaInfo->mRequiredBufferSize / BufferHelper::elementSize(TYPE_FLOAT),
BufferElementInfo(true),
UNIFORM_BUFFER_TYPE,
NO_CONTEXT_TYPE
),
//yes, the contents are mostly modded when moving lightsources are involved
true,
//set no data yet
0
);
}
if(ShaderManager::getInstance().getGlobalShaderFeatures().lightSourcesShadowFeature
== LIGHT_SOURCES_SHADOW_FEATURE_ALL_SPOT_LIGHTS)
{
std::vector<String> memberStrings;//empty on purpose, as the LS uniform buffer has no struct as array elements!
mShadowCameraTransformBufferMetaInfo_SMGeneration= new UniformBufferMetaInfo(
mNumMaxLightSources,
String("ShadowCameraTransformBuffer"), String("shadowCameraviewProjectionMatrices"),
memberStrings,
ShaderManager::getInstance().getUniformBufferOffsetQueryShader(true));
mShadowCameraTransformBufferMetaInfo_SMLookup= new UniformBufferMetaInfo(
mNumMaxLightSources,
String("ShadowCameraTransformBuffer"), String("shadowMapLookupMatrices"),
memberStrings,
ShaderManager::getInstance().getUniformBufferOffsetQueryShader(false));
assert("at least the buffers should have the same size" &&
(mShadowCameraTransformBufferMetaInfo_SMGeneration->mRequiredBufferSize ==
mShadowCameraTransformBufferMetaInfo_SMLookup->mRequiredBufferSize)
);
assert( (mShadowCameraTransformBufferMetaInfo_SMGeneration->mRequiredBufferSize % BufferHelper::elementSize(TYPE_MATRIX44F))== 0);
mShadowCameraTransformBuffer = new Buffer(
BufferInfo(
String("ShadowMapMatricesUniformBuffer"),
ContextTypeFlags( HOST_CONTEXT_TYPE_FLAG | OPEN_GL_CONTEXT_TYPE_FLAG),
TRANSFORMATION_MATRICES_SEMANTICS,
TYPE_MATRIX44F,
mShadowCameraTransformBufferMetaInfo_SMGeneration->mRequiredBufferSize
/ BufferHelper::elementSize(TYPE_MATRIX44F),
BufferElementInfo(true),
UNIFORM_BUFFER_TYPE,
NO_CONTEXT_TYPE
),
//yes, the contents are mostly modded when moving lightsources are involved
true,
//set no data yet
0
);
}
}
void SSShadowMapDemo::renderPost()
{
Stopwatch sw( m_deviceData );
if(1)
{
sw.start();
ConstData cb;
{
XMVECTOR v;
// cb.m_viewInv = XMMatrixInverse( &v, g_ViewTr );
// cb.m_projInv = XMMatrixInverse( &v, g_ProjectionTr );
cb.m_viewInv = XMMatrixInverse( &v, XMMatrixMultiply( g_ProjectionTr, g_ViewTr ) );
cb.m_width = g_wWidth;
cb.m_height = g_wHeight;
cb.m_shadowWeight = 0.6f/MAX_SHADOWS;
}
{ // clear
Buffer<int> normalBuffer; normalBuffer.m_srv = m_normalRT.m_srv;
BufferInfo bInfo[] = { BufferInfo( &m_shadowAccumBuffer ),
BufferInfo( &normalBuffer, true ) };
Launcher launcher( m_deviceData, &m_clearKernel );
launcher.setBuffers( bInfo, sizeof(bInfo)/sizeof(Launcher::BufferInfo) );
launcher.setConst( m_constBuffer, cb );
launcher.launch1D( g_wWidth*g_wHeight, 64 );
}
ID3D11RenderTargetView* m_rtv;
ID3D11DepthStencilView* m_dsv;
DeviceDX11* dd = (DeviceDX11*)m_deviceData;
dd->m_context->OMGetRenderTargets( 1, &m_rtv, &m_dsv );
for(int lightIdx=0; lightIdx<MAX_SHADOWS; lightIdx++)
{
XMMATRIX viewTr;
XMMATRIX projTr;
{ // render light view
dd->m_context->OMSetRenderTargets( 0, 0, m_depthBuffer[lightIdx].m_depthStencilView );
dd->m_context->ClearDepthStencilView( m_depthBuffer[lightIdx].m_depthStencilView, D3D11_CLEAR_DEPTH, 1.0f, 0 );
getMatrices<true>( m_lightPos[lightIdx], make_float4(0,0,0), make_float4(1,0,0,0), XM_PI*60.f/180.f, 1.f,
0.1f, 50.f, &viewTr, &projTr );
dispatchRenderList( g_deviceData, &g_debugRenderObj, &viewTr, &projTr );
}
{ // run compute shader for accumulation
dd->m_context->OMSetRenderTargets( 0, 0, 0 );
{
// cb.m_lightView = viewTr;
// cb.m_lightProj = projTr;
// == mul( mul( v, view ), proj ) in shader (Matrices are transposed)
cb.m_lightView = XMMatrixMultiply( projTr, viewTr );
}
Buffer<int> depthBuffer; depthBuffer.m_srv = g_depthStencil.m_srv;
Buffer<int> shadowBuffer; shadowBuffer.m_srv = m_depthBuffer[lightIdx].m_srv;
BufferInfo bInfo[] = { BufferInfo( &m_shadowAccumBuffer ),
BufferInfo( &depthBuffer, true ), BufferInfo( &shadowBuffer, true ) };
Launcher launcher( m_deviceData, &m_shadowAccmKernel );
launcher.setBuffers( bInfo, sizeof(bInfo)/sizeof(Launcher::BufferInfo) );
launcher.setConst( m_constBuffer, cb );
launcher.launch2D( g_wWidth, g_wHeight, 8, 8 );
}
}
m_rtv->Release();
m_dsv->Release();
}
else
{
ConstData cb;
{
XMVECTOR v;
// cb.m_viewInv = XMMatrixInverse( &v, g_ViewTr );
// cb.m_projInv = XMMatrixInverse( &v, g_ProjectionTr );
cb.m_viewInv = XMMatrixInverse( &v, XMMatrixMultiply( g_ProjectionTr, g_ViewTr ) );
cb.m_width = g_wWidth;
cb.m_height = g_wHeight;
cb.m_shadowWeight = 0.6f/MAX_SHADOWS;
}
{ // clear
Buffer<int> normalBuffer; normalBuffer.m_srv = m_normalRT.m_srv;
BufferInfo bInfo[] = { BufferInfo( &m_shadowAccumBuffer ),
BufferInfo( &normalBuffer, true ) };
Launcher launcher( m_deviceData, &m_clearKernel );
launcher.setBuffers( bInfo, sizeof(bInfo)/sizeof(Launcher::BufferInfo) );
launcher.setConst( m_constBuffer, cb );
launcher.launch1D( g_wWidth*g_wHeight, 64 );
}
ID3D11RenderTargetView* m_rtv;
ID3D11DepthStencilView* m_dsv;
DeviceDX11* dd = (DeviceDX11*)m_deviceData;
dd->m_context->OMGetRenderTargets( 1, &m_rtv, &m_dsv );
XMMATRIX viewTr[MAX_SHADOWS];
XMMATRIX projTr[MAX_SHADOWS];
for(int lightIdx=0; lightIdx<MAX_SHADOWS; lightIdx++)
{
{ // render light view
dd->m_context->OMSetRenderTargets( 0, 0, m_depthBuffer[lightIdx].m_depthStencilView );
dd->m_context->ClearDepthStencilView( m_depthBuffer[lightIdx].m_depthStencilView, D3D11_CLEAR_DEPTH, 1.0f, 0 );
getMatrices<true>( m_lightPos[lightIdx], make_float4(0,0,0), make_float4(1,0,0,0), XM_PI*60.f/180.f, 1.f,
0.1f, 50.f, &viewTr[lightIdx], &projTr[lightIdx] );
dispatchRenderList( g_deviceData, &g_debugRenderObj, &viewTr[lightIdx], &projTr[lightIdx] );
}
{ // run compute shader for accumulation
dd->m_context->OMSetRenderTargets( 0, 0, 0 );
cb.m_shadowIdx = lightIdx;
Buffer<int> shadowBuffer; shadowBuffer.m_srv = m_depthBuffer[lightIdx].m_srv;
BufferInfo bInfo[] = { BufferInfo( &m_lightMergedBuffer ),
BufferInfo( &shadowBuffer, true ) };
Launcher launcher( m_deviceData, &m_copyShadowMapKernel );
launcher.setBuffers( bInfo, sizeof(bInfo)/sizeof(Launcher::BufferInfo) );
launcher.setConst( m_constBuffer, cb );
launcher.launch1D( g_wWidth*g_wHeight, 64 );
}
}
{ // resolve in a shader
{
cb.m_shadowIdx = MAX_SHADOWS;
for(int i=0; i<MAX_SHADOWS; i++)
{
viewTr[i] = XMMatrixMultiply( projTr[i], viewTr[i] );
}
m_lightMatrixBuffer.write( viewTr, MAX_SHADOWS );
DeviceUtils::waitForCompletion( m_deviceData );
}
sw.start();
Buffer<int> depthBuffer; depthBuffer.m_srv = g_depthStencil.m_srv;
Buffer<int> shadowBuffer; shadowBuffer.m_srv = m_depthBuffer[0].m_srv;
BufferInfo bInfo[] = { BufferInfo( &m_shadowAccumBuffer ),
BufferInfo( &depthBuffer, true ),
BufferInfo( &m_lightMergedBuffer, true ),
BufferInfo( &m_lightMatrixBuffer, true ) };
Launcher launcher( m_deviceData, &m_shadowAccmAllKernel );
launcher.setBuffers( bInfo, sizeof(bInfo)/sizeof(Launcher::BufferInfo) );
launcher.setConst( m_constBuffer, cb );
launcher.launch2D( g_wWidth, g_wHeight, 8, 8 );
}
m_rtv->Release();
m_dsv->Release();
}
sw.stop();
{
float t = sw.getMs();
m_nTxtLines = 0;
sprintf_s(m_txtBuffer[m_nTxtLines++], LINE_CAPACITY, "%dlights, %3.2fms", MAX_SHADOWS, t);
}
resolve( &m_shadowAccumBuffer.m_srv );
// resolveTexture( (void**)&m_colorRT.m_srv );
}
void AdlPrimitivesDemo::test( Buffer<int2>& buf, int size, Stopwatch& sw )
{
Kernel* kernel = KernelManager::query( m_deviceData, "..\\..\\AdlDemos\\TestBed\\Demos\\AdlPrimitivesDemoKernel", "FillInt4Kernel" );
Buffer<int4> constBuffer( m_deviceData, 1, BufferBase::BUFFER_CONST );
int numGroups = (size+128*4-1)/(128*4);
Buffer<u32> workBuffer0( m_deviceData, numGroups*(16) );
Buffer<u32> workBuffer1( m_deviceData, numGroups*(16) );
Buffer<int2> sortBuffer( m_deviceData, size );
{
int2* host = new int2[size];
for(int i=0; i<size; i++)
{
host[i] = make_int2( getRandom(0, 0xf), i );
}
sortBuffer.write( host, size );
DeviceUtils::waitForCompletion( m_deviceData );
delete [] host;
}
int4 constData;
{
constData.x = size;
constData.y = 0;
constData.z = numGroups;
constData.w = 0;
}
sw.start();
int nThreads = size/4;
{
BufferInfo bInfo[] = { BufferInfo( &buf ), BufferInfo( &workBuffer0 ), BufferInfo( &workBuffer1 ) };
Launcher launcher( m_deviceData, kernel );
launcher.setBuffers( bInfo, sizeof(bInfo)/sizeof(Launcher::BufferInfo) );
launcher.setConst( constBuffer, constData );
launcher.launch1D( nThreads, 128 );
}
sw.split();
{
constData.w = 1;
int nThreads = size/4;
BufferInfo bInfo[] = { BufferInfo( &buf ), BufferInfo( &workBuffer0 ), BufferInfo( &workBuffer1 ) };
Launcher launcher( m_deviceData, kernel );
launcher.setBuffers( bInfo, sizeof(bInfo)/sizeof(Launcher::BufferInfo) );
launcher.setConst( constBuffer, constData );
launcher.launch1D( nThreads, 128 );
}
sw.split();
{
constData.w = 2;
int nThreads = size/4;
BufferInfo bInfo[] = { BufferInfo( &sortBuffer ), BufferInfo( &workBuffer0 ), BufferInfo( &workBuffer1 ) };
Launcher launcher( m_deviceData, kernel );
launcher.setBuffers( bInfo, sizeof(bInfo)/sizeof(Launcher::BufferInfo) );
launcher.setConst( constBuffer, constData );
launcher.launch1D( nThreads, 128 );
}
sw.stop();
{
int2* host = new int2[size];
buf.read( host, size );
DeviceUtils::waitForCompletion( m_deviceData );
for(int i=0; i<128*4-1; i++)
{
ADLASSERT( host[i].x <= host[i+1].x );
}
delete [] host;
}
{
float t[3];
sw.getMs(t, 3);
// (byte * nElems)
sprintf_s(m_txtBuffer[m_nTxtLines++], LINE_CAPACITY, "LoadStore: %3.2fGB/s (%3.2fns)", (4*8*2)*nThreads/t[0]/1000/1000, t[0]*1000.f);
sprintf_s(m_txtBuffer[m_nTxtLines++], LINE_CAPACITY, "GenHistog: %3.2fGB/s (%3.2fns)", (4*(8*2+2))*nThreads/t[1]/1000/1000, t[1]*1000.f);
sprintf_s(m_txtBuffer[m_nTxtLines++], LINE_CAPACITY, "FullSort: %3.2fGB/s (%3.2fns)", (4*(8*2+2))*nThreads/t[2]/1000/1000, t[2]*1000.f);
}
}
