2013-04-18 03:29:41 +00:00
|
|
|
// Copyright 2013 Dolphin Emulator Project
|
|
|
|
// Licensed under GPLv2
|
|
|
|
// Refer to the license.txt file included.
|
2010-06-13 19:50:06 +00:00
|
|
|
|
2011-01-25 16:43:08 +00:00
|
|
|
#include "RenderBase.h"
|
2010-06-13 19:50:06 +00:00
|
|
|
|
|
|
|
#include "D3DBase.h"
|
|
|
|
#include "D3DUtil.h"
|
2010-09-28 02:15:02 +00:00
|
|
|
#include "FramebufferManager.h"
|
2010-06-13 19:50:06 +00:00
|
|
|
#include "PixelShaderCache.h"
|
|
|
|
#include "TextureCache.h"
|
2011-01-25 16:43:08 +00:00
|
|
|
#include "VertexShaderCache.h"
|
2011-02-26 23:41:02 +00:00
|
|
|
#include "TextureEncoder.h"
|
|
|
|
#include "PSTextureEncoder.h"
|
|
|
|
#include "HW/Memmap.h"
|
|
|
|
#include "VideoConfig.h"
|
2010-06-13 19:50:06 +00:00
|
|
|
|
2010-10-19 22:24:27 +00:00
|
|
|
namespace DX11
|
|
|
|
{
|
|
|
|
|
2011-06-11 19:37:21 +00:00
|
|
|
static TextureEncoder* g_encoder = NULL;
|
2011-02-26 23:41:02 +00:00
|
|
|
const size_t MAX_COPY_BUFFERS = 25;
|
2011-06-11 19:37:21 +00:00
|
|
|
ID3D11Buffer* efbcopycbuf[MAX_COPY_BUFFERS] = { 0 };
|
|
|
|
|
|
|
|
TextureCache::TCacheEntry::~TCacheEntry()
|
|
|
|
{
|
|
|
|
texture->Release();
|
|
|
|
}
|
2010-06-13 19:50:06 +00:00
|
|
|
|
2010-10-19 22:24:27 +00:00
|
|
|
void TextureCache::TCacheEntry::Bind(unsigned int stage)
|
|
|
|
{
|
2011-06-11 19:37:21 +00:00
|
|
|
D3D::context->PSSetShaderResources(stage, 1, &texture->GetSRV());
|
2010-10-19 22:24:27 +00:00
|
|
|
}
|
|
|
|
|
2012-05-12 11:50:03 +00:00
|
|
|
bool TextureCache::TCacheEntry::Save(const char filename[], unsigned int level)
|
2010-10-19 22:24:27 +00:00
|
|
|
{
|
2012-05-12 11:50:03 +00:00
|
|
|
// TODO: Somehow implement this (D3DX11 doesn't support dumping individual LODs)
|
|
|
|
static bool warn_once = true;
|
|
|
|
if (level && warn_once)
|
|
|
|
{
|
|
|
|
WARN_LOG(VIDEO, "Dumping individual LOD not supported by D3D11 backend!");
|
|
|
|
warn_once = false;
|
|
|
|
return false;
|
|
|
|
}
|
2011-06-11 19:37:21 +00:00
|
|
|
return SUCCEEDED(PD3DX11SaveTextureToFileA(D3D::context, texture->GetTex(), D3DX11_IFF_PNG, filename));
|
2010-10-19 22:24:27 +00:00
|
|
|
}
|
2010-06-13 19:50:06 +00:00
|
|
|
|
2010-10-19 22:24:27 +00:00
|
|
|
void TextureCache::TCacheEntry::Load(unsigned int width, unsigned int height,
|
2012-08-10 11:13:51 +00:00
|
|
|
unsigned int expanded_width, unsigned int level)
|
2010-10-19 22:24:27 +00:00
|
|
|
{
|
|
|
|
D3D::ReplaceRGBATexture2D(texture->GetTex(), TextureCache::temp, width, height, expanded_width, level, usage);
|
|
|
|
}
|
2010-06-13 19:50:06 +00:00
|
|
|
|
2010-10-19 22:24:27 +00:00
|
|
|
TextureCache::TCacheEntryBase* TextureCache::CreateTexture(unsigned int width,
|
|
|
|
unsigned int height, unsigned int expanded_width,
|
|
|
|
unsigned int tex_levels, PC_TexFormat pcfmt)
|
2010-06-13 19:50:06 +00:00
|
|
|
{
|
2010-10-19 22:24:27 +00:00
|
|
|
D3D11_USAGE usage = D3D11_USAGE_DEFAULT;
|
|
|
|
D3D11_CPU_ACCESS_FLAG cpu_access = (D3D11_CPU_ACCESS_FLAG)0;
|
2013-02-20 11:37:01 +00:00
|
|
|
D3D11_SUBRESOURCE_DATA srdata, *data = NULL;
|
2010-10-19 22:24:27 +00:00
|
|
|
|
2010-11-24 19:13:19 +00:00
|
|
|
if (tex_levels == 1)
|
2010-06-13 19:50:06 +00:00
|
|
|
{
|
2010-10-19 22:24:27 +00:00
|
|
|
usage = D3D11_USAGE_DYNAMIC;
|
|
|
|
cpu_access = D3D11_CPU_ACCESS_WRITE;
|
2013-02-20 11:37:01 +00:00
|
|
|
|
|
|
|
srdata.pSysMem = TextureCache::temp;
|
|
|
|
srdata.SysMemPitch = 4 * expanded_width;
|
|
|
|
|
|
|
|
data = &srdata;
|
2010-06-13 19:50:06 +00:00
|
|
|
}
|
2010-10-19 22:24:27 +00:00
|
|
|
|
|
|
|
const D3D11_TEXTURE2D_DESC texdesc = CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R8G8B8A8_UNORM,
|
|
|
|
width, height, 1, tex_levels, D3D11_BIND_SHADER_RESOURCE, usage, cpu_access);
|
|
|
|
|
2011-06-11 19:37:21 +00:00
|
|
|
ID3D11Texture2D *pTexture;
|
2013-02-20 11:37:01 +00:00
|
|
|
const HRESULT hr = D3D::device->CreateTexture2D(&texdesc, data, &pTexture);
|
2011-06-11 19:37:21 +00:00
|
|
|
CHECK(SUCCEEDED(hr), "Create texture of the TextureCache");
|
2010-10-19 22:24:27 +00:00
|
|
|
|
2011-06-11 19:37:21 +00:00
|
|
|
TCacheEntry* const entry = new TCacheEntry(new D3DTexture2D(pTexture, D3D11_BIND_SHADER_RESOURCE));
|
2010-10-19 22:24:27 +00:00
|
|
|
entry->usage = usage;
|
|
|
|
|
|
|
|
// TODO: better debug names
|
2011-06-11 19:37:21 +00:00
|
|
|
D3D::SetDebugObjectName((ID3D11DeviceChild*)entry->texture->GetTex(), "a texture of the TextureCache");
|
|
|
|
D3D::SetDebugObjectName((ID3D11DeviceChild*)entry->texture->GetSRV(), "shader resource view of a texture of the TextureCache");
|
|
|
|
|
|
|
|
SAFE_RELEASE(pTexture);
|
2013-02-20 20:18:21 +00:00
|
|
|
|
|
|
|
if (tex_levels != 1)
|
|
|
|
entry->Load(width, height, expanded_width, 0);
|
2010-10-19 22:24:27 +00:00
|
|
|
|
|
|
|
return entry;
|
2010-06-13 19:50:06 +00:00
|
|
|
}
|
|
|
|
|
2011-02-26 23:41:02 +00:00
|
|
|
void TextureCache::TCacheEntry::FromRenderTarget(u32 dstAddr, unsigned int dstFormat,
|
|
|
|
unsigned int srcFormat, const EFBRectangle& srcRect,
|
|
|
|
bool isIntensity, bool scaleByHalf, unsigned int cbufid,
|
|
|
|
const float *colmat)
|
2010-06-13 19:50:06 +00:00
|
|
|
{
|
2012-01-29 19:24:23 +00:00
|
|
|
if (type != TCET_EC_DYNAMIC || g_ActiveConfig.bCopyEFBToTexture)
|
2010-10-19 22:24:27 +00:00
|
|
|
{
|
2011-02-26 23:41:02 +00:00
|
|
|
g_renderer->ResetAPIState();
|
|
|
|
|
|
|
|
// stretch picture with increased internal resolution
|
2011-12-26 16:35:27 +00:00
|
|
|
const D3D11_VIEWPORT vp = CD3D11_VIEWPORT(0.f, 0.f, (float)virtual_width, (float)virtual_height);
|
2011-06-11 19:37:21 +00:00
|
|
|
D3D::context->RSSetViewports(1, &vp);
|
2011-02-26 23:41:02 +00:00
|
|
|
|
|
|
|
// set transformation
|
|
|
|
if (NULL == efbcopycbuf[cbufid])
|
|
|
|
{
|
|
|
|
const D3D11_BUFFER_DESC cbdesc = CD3D11_BUFFER_DESC(28 * sizeof(float), D3D11_BIND_CONSTANT_BUFFER, D3D11_USAGE_DEFAULT);
|
|
|
|
D3D11_SUBRESOURCE_DATA data;
|
|
|
|
data.pSysMem = colmat;
|
2011-06-11 19:37:21 +00:00
|
|
|
HRESULT hr = D3D::device->CreateBuffer(&cbdesc, &data, &efbcopycbuf[cbufid]);
|
|
|
|
CHECK(SUCCEEDED(hr), "Create efb copy constant buffer %d", cbufid);
|
|
|
|
D3D::SetDebugObjectName((ID3D11DeviceChild*)efbcopycbuf[cbufid], "a constant buffer used in TextureCache::CopyRenderTargetToTexture");
|
2011-02-26 23:41:02 +00:00
|
|
|
}
|
2011-06-11 19:37:21 +00:00
|
|
|
D3D::context->PSSetConstantBuffers(0, 1, &efbcopycbuf[cbufid]);
|
2011-02-26 23:41:02 +00:00
|
|
|
|
|
|
|
const TargetRectangle targetSource = g_renderer->ConvertEFBRectangle(srcRect);
|
|
|
|
// TODO: try targetSource.asRECT();
|
|
|
|
const D3D11_RECT sourcerect = CD3D11_RECT(targetSource.left, targetSource.top, targetSource.right, targetSource.bottom);
|
|
|
|
|
|
|
|
// Use linear filtering if (bScaleByHalf), use point filtering otherwise
|
|
|
|
if (scaleByHalf)
|
|
|
|
D3D::SetLinearCopySampler();
|
|
|
|
else
|
|
|
|
D3D::SetPointCopySampler();
|
|
|
|
|
2011-06-11 19:37:21 +00:00
|
|
|
D3D::context->OMSetRenderTargets(1, &texture->GetRTV(), NULL);
|
2011-02-26 23:41:02 +00:00
|
|
|
|
|
|
|
// Create texture copy
|
|
|
|
D3D::drawShadedTexQuad(
|
|
|
|
(srcFormat == PIXELFMT_Z24) ? FramebufferManager::GetEFBDepthTexture()->GetSRV() : FramebufferManager::GetEFBColorTexture()->GetSRV(),
|
2011-05-12 02:14:45 +00:00
|
|
|
&sourcerect, Renderer::GetTargetWidth(), Renderer::GetTargetHeight(),
|
2011-02-26 23:41:02 +00:00
|
|
|
(srcFormat == PIXELFMT_Z24) ? PixelShaderCache::GetDepthMatrixProgram(true) : PixelShaderCache::GetColorMatrixProgram(true),
|
|
|
|
VertexShaderCache::GetSimpleVertexShader(), VertexShaderCache::GetSimpleInputLayout());
|
|
|
|
|
2011-06-11 19:37:21 +00:00
|
|
|
D3D::context->OMSetRenderTargets(1, &FramebufferManager::GetEFBColorTexture()->GetRTV(), FramebufferManager::GetEFBDepthTexture()->GetDSV());
|
2011-02-26 23:41:02 +00:00
|
|
|
|
|
|
|
g_renderer->RestoreAPIState();
|
2010-10-19 22:24:27 +00:00
|
|
|
}
|
2010-11-27 11:11:05 +00:00
|
|
|
|
2011-02-26 23:41:02 +00:00
|
|
|
if (!g_ActiveConfig.bCopyEFBToTexture)
|
|
|
|
{
|
|
|
|
u8* dst = Memory::GetPointer(dstAddr);
|
2011-12-30 00:00:34 +00:00
|
|
|
size_t encoded_size = g_encoder->Encode(dst, dstFormat, srcFormat, srcRect, isIntensity, scaleByHalf);
|
|
|
|
|
2012-06-20 14:43:13 +00:00
|
|
|
u64 hash = GetHash64(dst, (int)encoded_size, g_ActiveConfig.iSafeTextureCache_ColorSamples);
|
2011-02-26 23:41:02 +00:00
|
|
|
|
2011-12-30 00:00:34 +00:00
|
|
|
// Mark texture entries in destination address range dynamic unless caching is enabled and the texture entry is up to date
|
|
|
|
if (!g_ActiveConfig.bEFBCopyCacheEnable)
|
|
|
|
TextureCache::MakeRangeDynamic(addr, (u32)encoded_size);
|
|
|
|
else if (!TextureCache::Find(addr, hash))
|
|
|
|
TextureCache::MakeRangeDynamic(addr, (u32)encoded_size);
|
2012-06-20 14:43:13 +00:00
|
|
|
|
|
|
|
this->hash = hash;
|
2011-02-26 23:41:02 +00:00
|
|
|
}
|
2010-10-19 22:24:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TextureCache::TCacheEntryBase* TextureCache::CreateRenderTargetTexture(
|
|
|
|
unsigned int scaled_tex_w, unsigned int scaled_tex_h)
|
|
|
|
{
|
|
|
|
return new TCacheEntry(D3DTexture2D::Create(scaled_tex_w, scaled_tex_h,
|
|
|
|
(D3D11_BIND_FLAG)((int)D3D11_BIND_RENDER_TARGET | (int)D3D11_BIND_SHADER_RESOURCE),
|
|
|
|
D3D11_USAGE_DEFAULT, DXGI_FORMAT_R8G8B8A8_UNORM));
|
|
|
|
}
|
2010-06-18 18:40:58 +00:00
|
|
|
|
2010-10-19 22:24:27 +00:00
|
|
|
TextureCache::TextureCache()
|
|
|
|
{
|
2011-02-26 23:41:02 +00:00
|
|
|
// FIXME: Is it safe here?
|
2011-06-11 19:37:21 +00:00
|
|
|
g_encoder = new PSTextureEncoder;
|
|
|
|
g_encoder->Init();
|
2010-06-13 19:50:06 +00:00
|
|
|
}
|
|
|
|
|
2010-10-19 22:24:27 +00:00
|
|
|
TextureCache::~TextureCache()
|
2010-06-13 19:50:06 +00:00
|
|
|
{
|
2011-06-11 19:37:21 +00:00
|
|
|
for (unsigned int k = 0; k < MAX_COPY_BUFFERS; ++k)
|
|
|
|
SAFE_RELEASE(efbcopycbuf[k]);
|
|
|
|
|
|
|
|
g_encoder->Shutdown();
|
|
|
|
delete g_encoder;
|
|
|
|
g_encoder = NULL;
|
2010-06-13 19:50:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|