void KRenderTarget::CreateRenderTargetArray(uint32 num_slices, DXGI_FORMAT tex_format, int32 width, int32 height, const float clear_color[4] /*= 0*/)
{
// Create the renderTargetTexture
CD3DX12_RESOURCE_DESC texDesc(
D3D12_RESOURCE_DIMENSION_TEXTURE2D,
0, // alignment
width, height, num_slices,
1, // mip levels
tex_format,
1, 0, // sample count/quality
D3D12_TEXTURE_LAYOUT_UNKNOWN,
D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET);
// Performance tip: Tell the runtime at resource creation the desired clear value.
D3D12_CLEAR_VALUE clearValue;
clearValue.Format = tex_format;
if (clear_color == 0)
{
float clearColor[] = { 0, 0, 0, 1 };
memcpy(&clearValue.Color[0], &clearColor[0], 4 * sizeof(float));
}
else
memcpy(&clearValue.Color[0], &clear_color[0], 4 * sizeof(float));
shared_context.gfx_device->GetDevice()->CreateCommittedResource(
&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT, 0, 0),
D3D12_HEAP_FLAG_NONE,
&texDesc,
D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE,
&clearValue,
IID_PPV_ARGS(&m_RTResource));
D3D12_RENDER_TARGET_VIEW_DESC RTVDesc;
ZeroMemory(&RTVDesc, sizeof(RTVDesc));
RTVDesc.Format = tex_format;
RTVDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DARRAY;
RTVDesc.Texture2DArray.ArraySize = num_slices;
m_RTVCPUHandle = shared_context.gfx_device->GetDescHeapRTV()->GetNewCPUHandle();
m_RTVGPUHandle = shared_context.gfx_device->GetDescHeapRTV()->GetGPUHandleAtHead();
shared_context.gfx_device->GetDevice()->CreateRenderTargetView(m_RTResource, &RTVDesc, m_RTVCPUHandle);
D3D12_SHADER_RESOURCE_VIEW_DESC SRVDesc;
ZeroMemory(&SRVDesc, sizeof(SRVDesc));
SRVDesc.Format = tex_format;
SRVDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DARRAY;
SRVDesc.Texture2DArray.ArraySize = num_slices;
SRVDesc.Texture2DArray.MipLevels = 1;
SRVDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
m_SRVCPUHandle = shared_context.gfx_device->GetDescHeapCBV_SRV()->GetNewCPUHandle();
m_SRVGPUHandle = shared_context.gfx_device->GetDescHeapCBV_SRV()->GetGPUHandleAtHead();
shared_context.gfx_device->GetDevice()->CreateShaderResourceView(m_RTResource, &SRVDesc, m_SRVCPUHandle);
}
/*
-----------------------------------------------------------------------------
TextureManager
-----------------------------------------------------------------------------
*/
rxTextureManager::rxTextureManager()
{
gCore.resources->SetManager( Asset_Texture2D, this );
// Create a 1x1 texture filled with white color.
{
const DXGI_FORMAT textureFormat = DXGI_FORMAT_R8G8B8A8_UNORM;
const UINT textureWidth = 1;
const UINT textureHeight = 1;
DX11::Texture2DDescription texDesc( textureFormat, textureWidth, textureHeight );
texDesc
.ArraySize_(1)
.MipLevels_(1)
.SampleCount_(1)
.SampleQuality_(0)
.Usage_(D3D11_USAGE_IMMUTABLE)
.BindFlags_(D3D11_BIND_SHADER_RESOURCE)
.CPUAccessFlags_(0)
;
R8G8B8A8 whiteColorRGBA;
whiteColorRGBA.asU32 = BITS_ALL;
D3D11_SUBRESOURCE_DATA initialData;
initialData.pSysMem = &whiteColorRGBA;
initialData.SysMemPitch = sizeof whiteColorRGBA;
initialData.SysMemSlicePitch = nil;
ID3D11Device* pD3DDevice = GetD3DDevice();
dxchk(pD3DDevice->CreateTexture2D(
&texDesc, &initialData, c_cast(ID3D11Texture2D**) &m_defaultTexture.pTexture.Ptr
));
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
D3D_GetTexture2D_ShaderResourceView_Desc( textureFormat, srvDesc );
dxchk(pD3DDevice->CreateShaderResourceView(
m_defaultTexture.pTexture, &srvDesc, &m_defaultTexture.pSRV.Ptr
));
}
}
//static
void Pi::CreateRenderTarget(const Uint16 width, const Uint16 height)
{
/* @fluffyfreak here's a rendertarget implementation you can use for oculusing and other things. It's pretty simple:
- fill out a RenderTargetDesc struct and call Renderer::CreateRenderTarget
- pass target to Renderer::SetRenderTarget to start rendering to texture
- set up viewport, clear etc, then draw as usual
- SetRenderTarget(0) to resume render to screen
- you can access the attached texture with GetColorTexture to use it with a material
You can reuse the same target with multiple textures.
In that case, leave the color format to NONE so the initial texture is not created, then use SetColorTexture to attach your own.
*/
#if USE_RTT
Graphics::RenderStateDesc rsd;
rsd.depthTest = false;
rsd.depthWrite = false;
rsd.blendMode = Graphics::BLEND_SOLID;
quadRenderState = Pi::renderer->CreateRenderState(rsd);
Graphics::TextureDescriptor texDesc(
Graphics::TEXTURE_RGBA_8888,
vector2f(width, height),
Graphics::LINEAR_CLAMP, false, false, 0);
Pi::renderTexture.Reset(Pi::renderer->CreateTexture(texDesc));
Pi::renderQuad.reset(new Graphics::Drawables::TexturedQuad(
Pi::renderer, Pi::renderTexture.Get(),
vector2f(0.0f, 0.0f), vector2f(float(Graphics::GetScreenWidth()), float(Graphics::GetScreenHeight())),
quadRenderState));
// Complete the RT description so we can request a buffer.
// NB: we don't want it to create use a texture because we share it with the textured quad created above.
Graphics::RenderTargetDesc rtDesc(
width,
height,
Graphics::TEXTURE_NONE, // don't create a texture
Graphics::TEXTURE_DEPTH,
false);
Pi::renderTarget = Pi::renderer->CreateRenderTarget(rtDesc);
Pi::renderTarget->SetColorTexture(Pi::renderTexture.Get());
#endif
}
void GLTexture2D::Load()
{
auto fileOptions = GetParameters();
auto filename = application->GetConfig().resourceBase + "/" + fileOptions[0];
if (!boost::filesystem::exists(filename)) {
LOG(ERROR) << "File \"" << filename.c_str() << L"\" cannot be opened.";
throw resource_loading_error() << ::boost::errinfo_file_name(filename) << resid_info(id)
<< errdesc_info("Cannot open include file.");
}
auto format = FreeImage_GetFileType(filename.c_str());
auto flags = 0;
if (format == FIF_JPEG) {
flags = JPEG_ACCURATE;
} else if (format == FIF_TARGA) {
flags = TARGA_LOAD_RGB888;
}
auto bitmap = FreeImage_Load(format, filename.c_str(), flags);
auto bitmap32 = FreeImage_ConvertTo32Bits(bitmap);
auto width = FreeImage_GetWidth(bitmap32);
auto height = FreeImage_GetHeight(bitmap32);
auto redMask = FreeImage_GetRedMask(bitmap32);
auto greenMask = FreeImage_GetGreenMask(bitmap32);
auto blueMask = FreeImage_GetBlueMask(bitmap32);
void* data = FreeImage_GetBits(bitmap32);
GLenum fmt = GL_RGBA;
if (redMask > greenMask && greenMask > blueMask) fmt = GL_BGRA;
auto internalFmt = GL_RGBA8;
for (unsigned int i = 1; i < fileOptions.size(); ++i) {
boost::trim(fileOptions[i]);
if (fileOptions[i] == "sRGB" && application->GetConfig().useSRGB) internalFmt = GL_SRGB8_ALPHA8;
}
TextureDescriptor texDesc(4, internalFmt, fmt, GL_UNSIGNED_BYTE);
texture = std::make_unique<GLTexture>(width, height, texDesc, data);
FreeImage_Unload(bitmap32);
FreeImage_Unload(bitmap);
Resource::Load();
}
// Load the sample assets.
void D3D12Multithreading::LoadAssets()
{
// Create the root signature.
{
CD3DX12_DESCRIPTOR_RANGE ranges[4]; // Perfomance TIP: Order from most frequent to least frequent.
ranges[0].Init(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 2, 1); // 2 frequently changed diffuse + normal textures - using registers t1 and t2.
ranges[1].Init(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 0); // 1 frequently changed constant buffer.
ranges[2].Init(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 1, 0); // 1 infrequently changed shadow texture - starting in register t0.
ranges[3].Init(D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER, 2, 0); // 2 static samplers.
CD3DX12_ROOT_PARAMETER rootParameters[4];
rootParameters[0].InitAsDescriptorTable(1, &ranges[0], D3D12_SHADER_VISIBILITY_PIXEL);
rootParameters[1].InitAsDescriptorTable(1, &ranges[1], D3D12_SHADER_VISIBILITY_ALL);
rootParameters[2].InitAsDescriptorTable(1, &ranges[2], D3D12_SHADER_VISIBILITY_PIXEL);
rootParameters[3].InitAsDescriptorTable(1, &ranges[3], D3D12_SHADER_VISIBILITY_PIXEL);
CD3DX12_ROOT_SIGNATURE_DESC rootSignatureDesc;
rootSignatureDesc.Init(_countof(rootParameters), rootParameters, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);
ComPtr<ID3DBlob> signature;
ComPtr<ID3DBlob> error;
ThrowIfFailed(D3D12SerializeRootSignature(&rootSignatureDesc, D3D_ROOT_SIGNATURE_VERSION_1, &signature, &error));
ThrowIfFailed(m_device->CreateRootSignature(0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS(&m_rootSignature)));
}
// Create the pipeline state, which includes loading shaders.
{
ComPtr<ID3DBlob> vertexShader;
ComPtr<ID3DBlob> pixelShader;
#ifdef _DEBUG
// Enable better shader debugging with the graphics debugging tools.
UINT compileFlags = D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION;
#else
UINT compileFlags = D3DCOMPILE_OPTIMIZATION_LEVEL3;
#endif
ThrowIfFailed(D3DCompileFromFile(GetAssetFullPath(L"shaders.hlsl").c_str(), nullptr, nullptr, "VSMain", "vs_5_0", compileFlags, 0, &vertexShader, nullptr));
ThrowIfFailed(D3DCompileFromFile(GetAssetFullPath(L"shaders.hlsl").c_str(), nullptr, nullptr, "PSMain", "ps_5_0", compileFlags, 0, &pixelShader, nullptr));
D3D12_INPUT_LAYOUT_DESC inputLayoutDesc;
inputLayoutDesc.pInputElementDescs = SampleAssets::StandardVertexDescription;
inputLayoutDesc.NumElements = _countof(SampleAssets::StandardVertexDescription);
CD3DX12_DEPTH_STENCIL_DESC depthStencilDesc(D3D12_DEFAULT);
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL;
depthStencilDesc.StencilEnable = FALSE;
// Describe and create the PSO for rendering the scene.
D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc = {};
psoDesc.InputLayout = inputLayoutDesc;
psoDesc.pRootSignature = m_rootSignature.Get();
psoDesc.VS = { reinterpret_cast<UINT8*>(vertexShader->GetBufferPointer()), vertexShader->GetBufferSize() };
psoDesc.PS = { reinterpret_cast<UINT8*>(pixelShader->GetBufferPointer()), pixelShader->GetBufferSize() };
psoDesc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT);
psoDesc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT);
psoDesc.DepthStencilState = depthStencilDesc;
psoDesc.SampleMask = UINT_MAX;
psoDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
psoDesc.NumRenderTargets = 1;
psoDesc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM;
psoDesc.DSVFormat = DXGI_FORMAT_D32_FLOAT;
psoDesc.SampleDesc.Count = 1;
ThrowIfFailed(m_device->CreateGraphicsPipelineState(&psoDesc, IID_PPV_ARGS(&m_pipelineState)));
// Alter the description and create the PSO for rendering
// the shadow map. The shadow map does not use a pixel
// shader or render targets.
psoDesc.PS.pShaderBytecode = 0;
psoDesc.PS.BytecodeLength = 0;
psoDesc.RTVFormats[0] = DXGI_FORMAT_UNKNOWN;
psoDesc.NumRenderTargets = 0;
ThrowIfFailed(m_device->CreateGraphicsPipelineState(&psoDesc, IID_PPV_ARGS(&m_pipelineStateShadowMap)));
}
// Create temporary command list for initial GPU setup.
ComPtr<ID3D12GraphicsCommandList> commandList;
ThrowIfFailed(m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, m_commandAllocator.Get(), m_pipelineState.Get(), IID_PPV_ARGS(&commandList)));
// Create render target views (RTVs).
CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle(m_rtvHeap->GetCPUDescriptorHandleForHeapStart());
for (UINT i = 0; i < FrameCount; i++)
{
ThrowIfFailed(m_swapChain->GetBuffer(i, IID_PPV_ARGS(&m_renderTargets[i])));
m_device->CreateRenderTargetView(m_renderTargets[i].Get(), nullptr, rtvHandle);
rtvHandle.Offset(1, m_rtvDescriptorSize);
}
// Create the depth stencil.
{
CD3DX12_RESOURCE_DESC shadowTextureDesc(
D3D12_RESOURCE_DIMENSION_TEXTURE2D,
0,
static_cast<UINT>(m_viewport.Width),
static_cast<UINT>(m_viewport.Height),
1,
1,
DXGI_FORMAT_D32_FLOAT,
1,
0,
D3D12_TEXTURE_LAYOUT_UNKNOWN,
D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL | D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE);
D3D12_CLEAR_VALUE clearValue; // Performance tip: Tell the runtime at resource creation the desired clear value.
clearValue.Format = DXGI_FORMAT_D32_FLOAT;
clearValue.DepthStencil.Depth = 1.0f;
clearValue.DepthStencil.Stencil = 0;
ThrowIfFailed(m_device->CreateCommittedResource(
&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT),
D3D12_HEAP_FLAG_NONE,
&shadowTextureDesc,
D3D12_RESOURCE_STATE_DEPTH_WRITE,
&clearValue,
IID_PPV_ARGS(&m_depthStencil)));
// Create the depth stencil view.
m_device->CreateDepthStencilView(m_depthStencil.Get(), nullptr, m_dsvHeap->GetCPUDescriptorHandleForHeapStart());
}
// Load scene assets.
UINT fileSize = 0;
UINT8* pAssetData;
ThrowIfFailed(ReadDataFromFile(GetAssetFullPath(SampleAssets::DataFileName).c_str(), &pAssetData, &fileSize));
// Create the vertex buffer.
{
ThrowIfFailed(m_device->CreateCommittedResource(
&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT),
D3D12_HEAP_FLAG_NONE,
&CD3DX12_RESOURCE_DESC::Buffer(SampleAssets::VertexDataSize),
D3D12_RESOURCE_STATE_COPY_DEST,
nullptr,
IID_PPV_ARGS(&m_vertexBuffer)));
{
ThrowIfFailed(m_device->CreateCommittedResource(
&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD),
D3D12_HEAP_FLAG_NONE,
&CD3DX12_RESOURCE_DESC::Buffer(SampleAssets::VertexDataSize),
D3D12_RESOURCE_STATE_GENERIC_READ,
nullptr,
IID_PPV_ARGS(&m_vertexBufferUpload)));
// Copy data to the upload heap and then schedule a copy
// from the upload heap to the vertex buffer.
D3D12_SUBRESOURCE_DATA vertexData = {};
vertexData.pData = pAssetData + SampleAssets::VertexDataOffset;
vertexData.RowPitch = SampleAssets::VertexDataSize;
vertexData.SlicePitch = vertexData.RowPitch;
PIXBeginEvent(commandList.Get(), 0, L"Copy vertex buffer data to default resource...");
UpdateSubresources<1>(commandList.Get(), m_vertexBuffer.Get(), m_vertexBufferUpload.Get(), 0, 0, 1, &vertexData);
commandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(m_vertexBuffer.Get(), D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER));
PIXEndEvent(commandList.Get());
}
// Initialize the vertex buffer view.
m_vertexBufferView.BufferLocation = m_vertexBuffer->GetGPUVirtualAddress();
m_vertexBufferView.SizeInBytes = SampleAssets::VertexDataSize;
m_vertexBufferView.StrideInBytes = SampleAssets::StandardVertexStride;
}
// Create the index buffer.
{
ThrowIfFailed(m_device->CreateCommittedResource(
&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT),
D3D12_HEAP_FLAG_NONE,
&CD3DX12_RESOURCE_DESC::Buffer(SampleAssets::IndexDataSize),
D3D12_RESOURCE_STATE_COPY_DEST,
nullptr,
IID_PPV_ARGS(&m_indexBuffer)));
{
ThrowIfFailed(m_device->CreateCommittedResource(
&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD),
D3D12_HEAP_FLAG_NONE,
&CD3DX12_RESOURCE_DESC::Buffer(SampleAssets::IndexDataSize),
D3D12_RESOURCE_STATE_GENERIC_READ,
nullptr,
IID_PPV_ARGS(&m_indexBufferUpload)));
// Copy data to the upload heap and then schedule a copy
// from the upload heap to the index buffer.
D3D12_SUBRESOURCE_DATA indexData = {};
indexData.pData = pAssetData + SampleAssets::IndexDataOffset;
indexData.RowPitch = SampleAssets::IndexDataSize;
indexData.SlicePitch = indexData.RowPitch;
PIXBeginEvent(commandList.Get(), 0, L"Copy index buffer data to default resource...");
UpdateSubresources<1>(commandList.Get(), m_indexBuffer.Get(), m_indexBufferUpload.Get(), 0, 0, 1, &indexData);
commandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(m_indexBuffer.Get(), D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_INDEX_BUFFER));
PIXEndEvent(commandList.Get());
}
// Initialize the index buffer view.
m_indexBufferView.BufferLocation = m_indexBuffer->GetGPUVirtualAddress();
m_indexBufferView.SizeInBytes = SampleAssets::IndexDataSize;
m_indexBufferView.Format = SampleAssets::StandardIndexFormat;
}
// Create shader resources.
{
// Get the CBV SRV descriptor size for the current device.
const UINT cbvSrvDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
// Get a handle to the start of the descriptor heap.
CD3DX12_CPU_DESCRIPTOR_HANDLE cbvSrvHandle(m_cbvSrvHeap->GetCPUDescriptorHandleForHeapStart());
{
// Describe and create 2 null SRVs. Null descriptors are needed in order
// to achieve the effect of an "unbound" resource.
D3D12_SHADER_RESOURCE_VIEW_DESC nullSrvDesc = {};
nullSrvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
nullSrvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
nullSrvDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
nullSrvDesc.Texture2D.MipLevels = 1;
nullSrvDesc.Texture2D.MostDetailedMip = 0;
nullSrvDesc.Texture2D.ResourceMinLODClamp = 0.0f;
m_device->CreateShaderResourceView(nullptr, &nullSrvDesc, cbvSrvHandle);
cbvSrvHandle.Offset(cbvSrvDescriptorSize);
m_device->CreateShaderResourceView(nullptr, &nullSrvDesc, cbvSrvHandle);
cbvSrvHandle.Offset(cbvSrvDescriptorSize);
}
// Create each texture and SRV descriptor.
const UINT srvCount = _countof(SampleAssets::Textures);
PIXBeginEvent(commandList.Get(), 0, L"Copy diffuse and normal texture data to default resources...");
for (int i = 0; i < srvCount; i++)
{
// Describe and create a Texture2D.
const SampleAssets::TextureResource &tex = SampleAssets::Textures[i];
CD3DX12_RESOURCE_DESC texDesc(
D3D12_RESOURCE_DIMENSION_TEXTURE2D,
0,
tex.Width,
tex.Height,
1,
static_cast<UINT16>(tex.MipLevels),
tex.Format,
1,
0,
D3D12_TEXTURE_LAYOUT_UNKNOWN,
D3D12_RESOURCE_FLAG_NONE);
ThrowIfFailed(m_device->CreateCommittedResource(
&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT),
D3D12_HEAP_FLAG_NONE,
&texDesc,
D3D12_RESOURCE_STATE_COPY_DEST,
nullptr,
IID_PPV_ARGS(&m_textures[i])));
{
const UINT subresourceCount = texDesc.DepthOrArraySize * texDesc.MipLevels;
UINT64 uploadBufferSize = GetRequiredIntermediateSize(m_textures[i].Get(), 0, subresourceCount);
ThrowIfFailed(m_device->CreateCommittedResource(
&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD),
D3D12_HEAP_FLAG_NONE,
&CD3DX12_RESOURCE_DESC::Buffer(uploadBufferSize),
D3D12_RESOURCE_STATE_GENERIC_READ,
nullptr,
IID_PPV_ARGS(&m_textureUploads[i])));
// Copy data to the intermediate upload heap and then schedule a copy
// from the upload heap to the Texture2D.
D3D12_SUBRESOURCE_DATA textureData = {};
textureData.pData = pAssetData + tex.Data->Offset;
textureData.RowPitch = tex.Data->Pitch;
textureData.SlicePitch = tex.Data->Size;
UpdateSubresources(commandList.Get(), m_textures[i].Get(), m_textureUploads[i].Get(), 0, 0, subresourceCount, &textureData);
commandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(m_textures[i].Get(), D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE));
}
// Describe and create an SRV.
D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
srvDesc.Format = tex.Format;
srvDesc.Texture2D.MipLevels = tex.MipLevels;
srvDesc.Texture2D.MostDetailedMip = 0;
srvDesc.Texture2D.ResourceMinLODClamp = 0.0f;
m_device->CreateShaderResourceView(m_textures[i].Get(), &srvDesc, cbvSrvHandle);
// Move to the next descriptor slot.
cbvSrvHandle.Offset(cbvSrvDescriptorSize);
}
PIXEndEvent(commandList.Get());
}
free(pAssetData);
// Create the samplers.
{
// Get the sampler descriptor size for the current device.
const UINT samplerDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER);
// Get a handle to the start of the descriptor heap.
CD3DX12_CPU_DESCRIPTOR_HANDLE samplerHandle(m_samplerHeap->GetCPUDescriptorHandleForHeapStart());
// Describe and create the wrapping sampler, which is used for
// sampling diffuse/normal maps.
D3D12_SAMPLER_DESC wrapSamplerDesc = {};
wrapSamplerDesc.Filter = D3D12_FILTER_MIN_MAG_MIP_LINEAR;
wrapSamplerDesc.AddressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP;
wrapSamplerDesc.AddressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP;
wrapSamplerDesc.AddressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP;
wrapSamplerDesc.MinLOD = 0;
wrapSamplerDesc.MaxLOD = D3D12_FLOAT32_MAX;
wrapSamplerDesc.MipLODBias = 0.0f;
wrapSamplerDesc.MaxAnisotropy = 1;
wrapSamplerDesc.ComparisonFunc = D3D12_COMPARISON_FUNC_ALWAYS;
wrapSamplerDesc.BorderColor[0] = wrapSamplerDesc.BorderColor[1] = wrapSamplerDesc.BorderColor[2] = wrapSamplerDesc.BorderColor[3] = 0;
m_device->CreateSampler(&wrapSamplerDesc, samplerHandle);
// Move the handle to the next slot in the descriptor heap.
samplerHandle.Offset(samplerDescriptorSize);
// Describe and create the point clamping sampler, which is
// used for the shadow map.
D3D12_SAMPLER_DESC clampSamplerDesc = {};
clampSamplerDesc.Filter = D3D12_FILTER_MIN_MAG_MIP_POINT;
clampSamplerDesc.AddressU = D3D12_TEXTURE_ADDRESS_MODE_CLAMP;
clampSamplerDesc.AddressV = D3D12_TEXTURE_ADDRESS_MODE_CLAMP;
clampSamplerDesc.AddressW = D3D12_TEXTURE_ADDRESS_MODE_CLAMP;
clampSamplerDesc.MipLODBias = 0.0f;
clampSamplerDesc.MaxAnisotropy = 1;
clampSamplerDesc.ComparisonFunc = D3D12_COMPARISON_FUNC_ALWAYS;
clampSamplerDesc.BorderColor[0] = clampSamplerDesc.BorderColor[1] = clampSamplerDesc.BorderColor[2] = clampSamplerDesc.BorderColor[3] = 0;
clampSamplerDesc.MinLOD = 0;
clampSamplerDesc.MaxLOD = D3D12_FLOAT32_MAX;
m_device->CreateSampler(&clampSamplerDesc, samplerHandle);
}
// Create lights.
for (int i = 0; i < NumLights; i++)
{
// Set up each of the light positions and directions (they all start
// in the same place).
m_lights[i].position = { 0.0f, 15.0f, -30.0f, 1.0f };
m_lights[i].direction = { 0.0, 0.0f, 1.0f, 0.0f };
m_lights[i].falloff = { 800.0f, 1.0f, 0.0f, 1.0f };
m_lights[i].color = { 0.7f, 0.7f, 0.7f, 1.0f };
XMVECTOR eye = XMLoadFloat4(&m_lights[i].position);
XMVECTOR at = XMVectorAdd(eye, XMLoadFloat4(&m_lights[i].direction));
XMVECTOR up = { 0, 1, 0 };
m_lightCameras[i].Set(eye, at, up);
}
// Close the command list and use it to execute the initial GPU setup.
ThrowIfFailed(commandList->Close());
ID3D12CommandList* ppCommandLists[] = { commandList.Get() };
m_commandQueue->ExecuteCommandLists(_countof(ppCommandLists), ppCommandLists);
// Create frame resources.
for (int i = 0; i < FrameCount; i++)
{
m_frameResources[i] = new FrameResource(m_device.Get(), m_pipelineState.Get(), m_pipelineStateShadowMap.Get(), m_dsvHeap.Get(), m_cbvSrvHeap.Get(), &m_viewport, i);
m_frameResources[i]->WriteConstantBuffers(&m_viewport, &m_camera, m_lightCameras, m_lights);
}
m_currentFrameResourceIndex = 0;
m_pCurrentFrameResource = m_frameResources[m_currentFrameResourceIndex];
// Create synchronization objects and wait until assets have been uploaded to the GPU.
{
ThrowIfFailed(m_device->CreateFence(m_fenceValue, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&m_fence)));
m_fenceValue++;
// Create an event handle to use for frame synchronization.
m_fenceEvent = CreateEventEx(nullptr, FALSE, FALSE, EVENT_ALL_ACCESS);
if (m_fenceEvent == nullptr)
{
ThrowIfFailed(HRESULT_FROM_WIN32(GetLastError()));
}
// Wait for the command list to execute; we are reusing the same command
// list in our main loop but for now, we just want to wait for setup to
// complete before continuing.
// Signal and increment the fence value.
const UINT64 fenceToWaitFor = m_fenceValue;
ThrowIfFailed(m_commandQueue->Signal(m_fence.Get(), fenceToWaitFor));
m_fenceValue++;
// Wait until the fence is completed.
ThrowIfFailed(m_fence->SetEventOnCompletion(fenceToWaitFor, m_fenceEvent));
WaitForSingleObject(m_fenceEvent, INFINITE);
}
}
void CRenderCaptureDX::BeginRender()
{
ID3D11DeviceContext* pContext = g_Windowing.Get3D11Context();
ID3D11Device* pDevice = g_Windowing.Get3D11Device();
CD3D11_QUERY_DESC queryDesc(D3D11_QUERY_EVENT);
if (!m_asyncChecked)
{
m_asyncSupported = SUCCEEDED(pDevice->CreateQuery(&queryDesc, nullptr));
if (m_flags & CAPTUREFLAG_CONTINUOUS)
{
if (!m_asyncSupported)
CLog::Log(LOGWARNING, "CRenderCaptureDX: D3D11_QUERY_OCCLUSION not supported, performance might suffer");
if (!UseOcclusionQuery())
CLog::Log(LOGWARNING, "CRenderCaptureDX: D3D11_QUERY_OCCLUSION disabled, performance might suffer");
}
m_asyncChecked = true;
}
HRESULT result;
if (m_surfaceWidth != m_width || m_surfaceHeight != m_height)
{
SAFE_RELEASE(m_renderSurface);
SAFE_RELEASE(m_copySurface);
CD3D11_TEXTURE2D_DESC texDesc(DXGI_FORMAT_B8G8R8A8_UNORM, m_width, m_height, 1, 1, D3D11_BIND_RENDER_TARGET);
result = pDevice->CreateTexture2D(&texDesc, nullptr, &m_renderTexture);
if (FAILED(result))
{
CLog::Log(LOGERROR, "CRenderCaptureDX::BeginRender: CreateTexture2D (RENDER_TARGET) failed %s",
g_Windowing.GetErrorDescription(result).c_str());
SetState(CAPTURESTATE_FAILED);
return;
}
CD3D11_RENDER_TARGET_VIEW_DESC rtDesc(D3D11_RTV_DIMENSION_TEXTURE2D);
result = pDevice->CreateRenderTargetView(m_renderTexture, &rtDesc, &m_renderSurface);
if (FAILED(result))
{
CLog::Log(LOGERROR, "CRenderCaptureDX::BeginRender: CreateRenderTargetView failed %s",
g_Windowing.GetErrorDescription(result).c_str());
SetState(CAPTURESTATE_FAILED);
return;
}
texDesc.BindFlags = 0;
texDesc.Usage = D3D11_USAGE_STAGING;
texDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
result = pDevice->CreateTexture2D(&texDesc, nullptr, &m_copySurface);
if (FAILED(result))
{
CLog::Log(LOGERROR, "CRenderCaptureDX::BeginRender: CreateTexture2D (USAGE_STAGING) failed %s",
g_Windowing.GetErrorDescription(result).c_str());
SetState(CAPTURESTATE_FAILED);
return;
}
m_surfaceWidth = m_width;
m_surfaceHeight = m_height;
}
if (m_bufferSize != m_width * m_height * 4)
{
m_bufferSize = m_width * m_height * 4;
av_freep(&m_pixels);
m_pixels = (uint8_t*)av_malloc(m_bufferSize);
}
pContext->OMSetRenderTargets(1, &m_renderSurface, nullptr);
if (m_asyncSupported && UseOcclusionQuery())
{
//generate an occlusion query if we don't have one
if (!m_query)
{
result = pDevice->CreateQuery(&queryDesc, &m_query);
if (FAILED(result))
{
CLog::Log(LOGERROR, "CRenderCaptureDX::BeginRender: CreateQuery failed %s",
g_Windowing.GetErrorDescription(result).c_str());
m_asyncSupported = false;
SAFE_RELEASE(m_query);
}
}
}
else
{
//don't use an occlusion query, clean up any old one
SAFE_RELEASE(m_query);
}
}
