void Player::Update()
{
if ( active )
{
IncrementFrame();
if ( shootCooldownLeft > 0 )
{
shootCooldownLeft -= 1;
}
}
if ( deathCooldownLeft > 0 )
{
deathCooldownLeft -= 1;
}
if ( active == false && deathCooldownLeft <= 0 )
{
active = true;
action = FLYING;
// Reset coordinates
SetCoordinates( 0, 768/2 );
}
}
void Enemy::Move( Direction dir )
{
if ( exists )
{
if ( action != ATTACKING )
{
if ( dir == LEFT )
{
direction = dir;
position.x = (int)(position.x - speed);
}
else if ( dir == RIGHT )
{
direction = dir;
position.x = (int)(position.x + speed);
}
else if ( dir == UP )
{
position.y = (int)(position.y - speed);
}
else if ( dir == DOWN )
{
position.y = (int)(position.y + speed);
}
action = WALKING;
}
IncrementFrame();
}
}
void Item::Update()
{
if ( active )
{
IncrementFrame();
Move( LEFT );
if ( coord.x < 0 - coord.w )
{
active = false;
}
}
}
void D3DPostProcessingShader::Draw(PostProcessor* p,
const TargetRectangle& dst_rect, const TargetSize& dst_size, uintptr_t dst_tex,
const TargetRectangle& src_rect, const TargetSize& src_size, uintptr_t src_tex,
uintptr_t src_depth_tex, int src_layer, float gamma)
{
D3DPostProcessor* parent = reinterpret_cast<D3DPostProcessor*>(p);
D3DTexture2D* dst_texture = reinterpret_cast<D3DTexture2D*>(dst_tex);
D3DTexture2D* src_texture = reinterpret_cast<D3DTexture2D*>(src_tex);
D3DTexture2D* src_depth_texture = reinterpret_cast<D3DTexture2D*>(src_depth_tex);
_dbg_assert_(VIDEO, m_ready && m_internal_size == src_size);
// Determine whether we can skip the final copy by writing directly to the output texture, if the last pass is not scaled.
bool skip_final_copy = !IsLastPassScaled() && (dst_texture != src_texture || !m_last_pass_uses_color_buffer) && !m_prev_frame_enabled;
// Draw each pass.
PostProcessor::InputTextureSizeArray input_sizes;
TargetRectangle output_rect = {};
TargetSize output_size;
D3D12_CPU_DESCRIPTOR_HANDLE base_sampler_cpu;
D3D12_GPU_DESCRIPTOR_HANDLE base_sampler_gpu;
int required_handles = (int)(POST_PROCESSING_MAX_TEXTURE_INPUTS * m_passes.size());
DX12::D3D::sampler_descriptor_heap_mgr->AllocateGroup(required_handles, &base_sampler_cpu, &base_sampler_gpu);
D3D12_CPU_DESCRIPTOR_HANDLE base_texture_cpu;
D3D12_GPU_DESCRIPTOR_HANDLE base_texture_gpu;
// On the first texture in the group, we need to allocate the space in the descriptor heap.
if (!DX12::D3D::gpu_descriptor_heap_mgr->AllocateTemporary(required_handles, &base_texture_cpu, &base_texture_gpu))
{
// Kick command buffer before attempting to allocate again. This is slow.
D3D::command_list_mgr->ExecuteQueuedWork();
if (!D3D::gpu_descriptor_heap_mgr->AllocateTemporary(required_handles, &base_texture_cpu, &base_texture_gpu))
{
PanicAlert("Failed to allocate temporary descriptors.");
return;
}
}
MapAndUpdateConfigurationBuffer();
for (size_t pass_index = 0; pass_index < m_passes.size(); pass_index++)
{
const RenderPassData& pass = m_passes[pass_index];
bool is_last_pass = (pass_index == m_last_pass_index);
if (!pass.enabled)
continue;
D3D12_CPU_DESCRIPTOR_HANDLE sampler_cpu = { base_sampler_cpu.ptr + pass_index * POST_PROCESSING_MAX_TEXTURE_INPUTS * D3D::sampler_descriptor_size};
D3D12_GPU_DESCRIPTOR_HANDLE sampler_gpu = { base_sampler_gpu.ptr + pass_index * POST_PROCESSING_MAX_TEXTURE_INPUTS * D3D::sampler_descriptor_size };
D3D12_CPU_DESCRIPTOR_HANDLE texture_cpu = { base_texture_cpu.ptr + pass_index * POST_PROCESSING_MAX_TEXTURE_INPUTS * D3D::resource_descriptor_size };
D3D12_GPU_DESCRIPTOR_HANDLE texture_gpu = { base_texture_gpu.ptr + pass_index * POST_PROCESSING_MAX_TEXTURE_INPUTS * D3D::resource_descriptor_size };
// Bind inputs to pipeline
for (size_t i = 0; i < pass.inputs.size(); i++)
{
const InputBinding& input = pass.inputs[i];
D3D12_CPU_DESCRIPTOR_HANDLE textureDestDescriptor;
D3DTexture2D* input_texture = nullptr;
textureDestDescriptor.ptr = texture_cpu.ptr + i * D3D::resource_descriptor_size;
switch (input.type)
{
case POST_PROCESSING_INPUT_TYPE_COLOR_BUFFER:
input_texture = src_texture;
input_sizes[i] = src_size;
break;
case POST_PROCESSING_INPUT_TYPE_DEPTH_BUFFER:
input_texture = src_depth_texture;
input_sizes[i] = src_size;
break;
case POST_PROCESSING_INPUT_TYPE_PASS_FRAME_OUTPUT:
if (m_prev_frame_enabled)
{
input_texture = reinterpret_cast<D3DTexture2D*>(GetPrevColorFrame(input.frame_index)->GetInternalObject());
input_sizes[i] = m_prev_frame_size;
}
break;
case POST_PROCESSING_INPUT_TYPE_PASS_DEPTH_FRAME_OUTPUT:
if (m_prev_depth_enabled)
{
input_texture = reinterpret_cast<D3DTexture2D*>(GetPrevDepthFrame(input.frame_index)->GetInternalObject());
input_sizes[i] = m_prev_depth_frame_size;
}
break;
default:
TextureCacheBase::TCacheEntryBase* i_texture = input.texture != nullptr ? input.texture : input.prev_texture;
if (i_texture != nullptr)
{
input_texture = reinterpret_cast<D3DTexture2D*>(i_texture->GetInternalObject());
input_sizes[i] = input.size;
}
else
{
input_texture = src_texture;
input_sizes[i] = src_size;
}
break;
}
if (input_texture)
{
input_texture->TransitionToResourceState(D3D::current_command_list, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
}
DX12::D3D::device->CopyDescriptorsSimple(
1,
textureDestDescriptor,
input_texture != nullptr ? input_texture->GetSRVCPUShadow() : DX12::D3D::null_srv_cpu_shadow,
D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV
);
D3D12_CPU_DESCRIPTOR_HANDLE destinationDescriptor;
destinationDescriptor.ptr = sampler_cpu.ptr + i * D3D::sampler_descriptor_size;
DX12::D3D::device->CopyDescriptorsSimple(
1,
destinationDescriptor,
parent->GetSamplerHandle(static_cast<UINT>(input.texture_sampler) - 1),
D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER
);
}
D3D::current_command_list->SetGraphicsRootDescriptorTable(DESCRIPTOR_TABLE_PS_SRV, texture_gpu);
D3D::current_command_list->SetGraphicsRootDescriptorTable(DESCRIPTOR_TABLE_PS_SAMPLER, sampler_gpu);
D3D::command_list_mgr->SetCommandListDirtyState(COMMAND_LIST_STATE_SAMPLERS, true);
// If this is the last pass and we can skip the final copy, write directly to output texture.
if (is_last_pass && skip_final_copy)
{
// The target rect may differ from the source.
output_rect = dst_rect;
output_size = dst_size;
dst_texture->TransitionToResourceState(D3D::current_command_list, D3D12_RESOURCE_STATE_RENDER_TARGET);
D3D::current_command_list->OMSetRenderTargets(1, &dst_texture->GetRTV(), FALSE, nullptr);
}
else
{
output_rect = PostProcessor::ScaleTargetRectangle(API_D3D11, src_rect, pass.output_scale);
output_size = pass.output_size;
reinterpret_cast<D3DTexture2D*>(pass.output_texture->GetInternalObject())->TransitionToResourceState(D3D::current_command_list, D3D12_RESOURCE_STATE_RENDER_TARGET);
D3D::current_command_list->OMSetRenderTargets(1, &reinterpret_cast<D3DTexture2D*>(pass.output_texture->GetInternalObject())->GetRTV(), FALSE, nullptr);
}
// Set viewport based on target rect
D3D::SetViewportAndScissor(output_rect.left, output_rect.top,
output_rect.GetWidth(), output_rect.GetHeight());
parent->MapAndUpdateUniformBuffer(input_sizes, output_rect, output_size, src_rect, src_size, src_layer, gamma);
// Select geometry shader based on layers
D3D12_SHADER_BYTECODE geometry_shader = {};
if (src_layer < 0 && m_internal_layers > 1)
geometry_shader = parent->GetGeometryShader();
// Draw pass
D3D::DrawShadedTexQuad(nullptr, src_rect.AsRECT(), src_size.width, src_size.height,
reinterpret_cast<RenderPassDx12Data*>(pass.shader)->m_shader_bytecode, parent->GetVertexShader(), StaticShaderCache::GetSimpleVertexShaderInputLayout(),
geometry_shader, std::max(src_layer, 0), DXGI_FORMAT_R8G8B8A8_UNORM, false, dst_texture->GetMultisampled());
}
// Copy the last pass output to the target if not done already
IncrementFrame();
if (m_prev_depth_enabled && src_depth_tex)
{
TargetRectangle dst;
dst.left = 0;
dst.right = m_prev_depth_frame_size.width;
dst.top = 0;
dst.bottom = m_prev_depth_frame_size.height;
parent->CopyTexture(dst, GetPrevDepthFrame(0)->GetInternalObject(), output_rect, src_depth_tex, src_size, src_layer, true, true);
}
if (!skip_final_copy)
{
RenderPassData& final_pass = m_passes[m_last_pass_index];
if (m_prev_frame_enabled)
{
TargetRectangle dst;
dst.left = 0;
dst.right = m_prev_frame_size.width;
dst.top = 0;
dst.bottom = m_prev_frame_size.height;
parent->CopyTexture(dst, GetPrevColorFrame(0)->GetInternalObject(), output_rect, final_pass.output_texture->GetInternalObject(), final_pass.output_size, src_layer, false, true);
}
parent->CopyTexture(dst_rect, dst_tex, output_rect, final_pass.output_texture->GetInternalObject(), final_pass.output_size, src_layer);
}
}
