diff --git a/Source/Core/Common/Src/MathUtil.h b/Source/Core/Common/Src/MathUtil.h
index da56becc42..d10540d45f 100644
--- a/Source/Core/Common/Src/MathUtil.h
+++ b/Source/Core/Common/Src/MathUtil.h
@@ -111,6 +111,13 @@ struct Rectangle
T right;
T bottom;
+ Rectangle()
+ { }
+
+ Rectangle(T theLeft, T theTop, T theRight, T theBottom)
+ : left(theLeft), top(theTop), right(theRight), bottom(theBottom)
+ { }
+
T GetWidth() const { return abs(right - left); }
T GetHeight() const { return abs(bottom - top); }
@@ -124,7 +131,7 @@ struct Rectangle
if (bottom < y2) bottom = y2;
}
- // If the rectangle is in an coordinate system with an upper-left origin,
+ // If the rectangle is in a coordinate system with an upper-left origin,
// use this Clamp.
void ClampUL(T x1, T y1, T x2, T y2)
{
diff --git a/Source/Plugins/Plugin_VideoDX11/Plugin_VideoDX11.vcxproj b/Source/Plugins/Plugin_VideoDX11/Plugin_VideoDX11.vcxproj
index b45cc18cb5..82601ff250 100644
--- a/Source/Plugins/Plugin_VideoDX11/Plugin_VideoDX11.vcxproj
+++ b/Source/Plugins/Plugin_VideoDX11/Plugin_VideoDX11.vcxproj
@@ -210,9 +210,11 @@
Create
Create
+
+
@@ -228,11 +230,13 @@
+
+
diff --git a/Source/Plugins/Plugin_VideoDX11/Plugin_VideoDX11.vcxproj.filters b/Source/Plugins/Plugin_VideoDX11/Plugin_VideoDX11.vcxproj.filters
index e78f8e53dc..0feb3c7dd0 100644
--- a/Source/Plugins/Plugin_VideoDX11/Plugin_VideoDX11.vcxproj.filters
+++ b/Source/Plugins/Plugin_VideoDX11/Plugin_VideoDX11.vcxproj.filters
@@ -45,6 +45,12 @@
Render
+
+ Render
+
+
+ Render
+
@@ -93,6 +99,12 @@
Render
+
+ Render
+
+
+ Render
+
diff --git a/Source/Plugins/Plugin_VideoDX11/Src/D3DUtil.cpp b/Source/Plugins/Plugin_VideoDX11/Src/D3DUtil.cpp
index 995a9e9a02..81a4cf96a6 100644
--- a/Source/Plugins/Plugin_VideoDX11/Src/D3DUtil.cpp
+++ b/Source/Plugins/Plugin_VideoDX11/Src/D3DUtil.cpp
@@ -587,10 +587,10 @@ void drawShadedTexSubQuad(ID3D11ShaderResourceView* texture,
float G = 1.0f / Gamma;
STSQVertex coords[4] = {
- { rDest->left , rDest->bottom, 0.0f, u1, v1, G},
- { rDest->right, rDest->bottom, 0.0f, u2, v1, G},
- { rDest->left , rDest->top , 0.0f, u1, v2, G},
- { rDest->right, rDest->top , 0.0f, u2, v2, G},
+ { rDest->left , rDest->bottom, 0.0f, u1, v2, G},
+ { rDest->right, rDest->bottom, 0.0f, u2, v2, G},
+ { rDest->left , rDest->top , 0.0f, u1, v1, G},
+ { rDest->right, rDest->top , 0.0f, u2, v1, G},
};
// only upload the data to VRAM if it changed
diff --git a/Source/Plugins/Plugin_VideoDX11/Src/FramebufferManager.cpp b/Source/Plugins/Plugin_VideoDX11/Src/FramebufferManager.cpp
index 35f6387fa0..ca00d9e74a 100644
--- a/Source/Plugins/Plugin_VideoDX11/Src/FramebufferManager.cpp
+++ b/Source/Plugins/Plugin_VideoDX11/Src/FramebufferManager.cpp
@@ -23,9 +23,13 @@
#include "PixelShaderCache.h"
#include "Render.h"
#include "VertexShaderCache.h"
+#include "XFBEncoder.h"
+#include "HW/Memmap.h"
namespace DX11 {
+static XFBEncoder s_xfbEncoder;
+
FramebufferManager::Efb FramebufferManager::m_efb;
D3DTexture2D* &FramebufferManager::GetEFBColorTexture() { return m_efb.color_tex; }
@@ -144,10 +148,14 @@ FramebufferManager::FramebufferManager()
m_efb.resolved_color_tex = NULL;
m_efb.resolved_depth_tex = NULL;
}
+
+ s_xfbEncoder.Init();
}
FramebufferManager::~FramebufferManager()
{
+ s_xfbEncoder.Shutdown();
+
SAFE_RELEASE(m_efb.color_tex);
SAFE_RELEASE(m_efb.color_temp_tex);
SAFE_RELEASE(m_efb.color_staging_buf);
@@ -160,8 +168,8 @@ FramebufferManager::~FramebufferManager()
void FramebufferManager::CopyToRealXFB(u32 xfbAddr, u32 fbWidth, u32 fbHeight, const EFBRectangle& sourceRc,float Gamma)
{
- // TODO
- PanicAlert("CopyToRealXFB not implemented, yet\n");
+ u8* dst = Memory::GetPointer(xfbAddr);
+ s_xfbEncoder.Encode(dst, fbWidth, fbHeight, sourceRc, Gamma);
}
XFBSourceBase* FramebufferManager::CreateXFBSource(unsigned int target_width, unsigned int target_height)
@@ -197,8 +205,8 @@ void XFBSource::Draw(const MathUtil::Rectangle &sourcerc,
void XFBSource::DecodeToTexture(u32 xfbAddr, u32 fbWidth, u32 fbHeight)
{
- // TODO:
- PanicAlert("RealXFB not implemented, yet\n");
+ // DX11's XFB decoder does not use this function.
+ // YUYV data is decoded in Render::Swap.
}
void XFBSource::CopyEFB(float Gamma)
diff --git a/Source/Plugins/Plugin_VideoDX11/Src/Render.cpp b/Source/Plugins/Plugin_VideoDX11/Src/Render.cpp
index e642527bd9..e2d990e87c 100644
--- a/Source/Plugins/Plugin_VideoDX11/Src/Render.cpp
+++ b/Source/Plugins/Plugin_VideoDX11/Src/Render.cpp
@@ -40,6 +40,7 @@
#include "VertexShaderCache.h"
#include "Core.h"
#include "OnFrame.h"
+#include "Television.h"
namespace DX11
{
@@ -50,6 +51,8 @@ static u32 s_LastAA = 0;
static u32 s_blendMode;
+static Television s_television;
+
ID3D11Buffer* access_efb_cbuf = NULL;
ID3D11BlendState* clearblendstates[4] = {NULL};
ID3D11DepthStencilState* cleardepthstates[3] = {NULL};
@@ -213,6 +216,8 @@ static const D3D11_TEXTURE_ADDRESS_MODE d3dClamps[4] =
void SetupDeviceObjects()
{
+ s_television.Init();
+
g_framebuffer_manager = new FramebufferManager;
HRESULT hr;
@@ -307,6 +312,8 @@ void TeardownDeviceObjects()
SAFE_RELEASE(resetblendstate);
SAFE_RELEASE(resetdepthstate);
SAFE_RELEASE(resetraststate);
+
+ s_television.Shutdown();
}
Renderer::Renderer()
@@ -930,7 +937,6 @@ void Renderer::Swap(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight,cons
// EFB is copied to XFB. In this way, flickering is reduced in games
// and seems to also give more FPS in ZTP
- if (field == FIELD_LOWER) xfbAddr -= fbWidth * 2;
u32 xfbCount = 0;
const XFBSourceBase* const* xfbSourceList = FramebufferManager::GetXFBSource(xfbAddr, fbWidth, fbHeight, xfbCount);
if ((!xfbSourceList || xfbCount == 0) && g_ActiveConfig.bUseXFB && !g_ActiveConfig.bUseRealXFB)
@@ -969,7 +975,13 @@ void Renderer::Swap(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight,cons
// activate linear filtering for the buffer copies
D3D::SetLinearCopySampler();
- if(g_ActiveConfig.bUseXFB)
+ if (g_ActiveConfig.bUseXFB && g_ActiveConfig.bUseRealXFB)
+ {
+ // TODO: Television should be used to render Virtual XFB mode as well.
+ s_television.Submit(xfbAddr, fbWidth, fbHeight);
+ s_television.Render();
+ }
+ else if(g_ActiveConfig.bUseXFB)
{
const XFBSourceBase* xfbSource;
@@ -993,8 +1005,8 @@ void Renderer::Swap(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight,cons
int xfbWidth = xfbSource->srcWidth;
int hOffset = ((s32)xfbSource->srcAddr - (s32)xfbAddr) / ((s32)fbWidth * 2);
- drawRc.bottom = 1.0f - (2.0f * (hOffset) / (float)fbHeight);
- drawRc.top = 1.0f - (2.0f * (hOffset + xfbHeight) / (float)fbHeight);
+ drawRc.top = 1.0f - (2.0f * (hOffset) / (float)fbHeight);
+ drawRc.bottom = 1.0f - (2.0f * (hOffset + xfbHeight) / (float)fbHeight);
drawRc.left = -(xfbWidth / (float)fbWidth);
drawRc.right = (xfbWidth / (float)fbWidth);
@@ -1009,8 +1021,8 @@ void Renderer::Swap(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight,cons
}
else
{
- drawRc.top = -1;
- drawRc.bottom = 1;
+ drawRc.top = 1;
+ drawRc.bottom = -1;
drawRc.left = -1;
drawRc.right = 1;
}
@@ -1026,6 +1038,7 @@ void Renderer::Swap(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight,cons
D3DTexture2D* read_texture = FramebufferManager::GetResolvedEFBColorTexture();
D3D::drawShadedTexQuad(read_texture->GetSRV(), targetRc.AsRECT(), Renderer::GetFullTargetWidth(), Renderer::GetFullTargetHeight(), PixelShaderCache::GetColorCopyProgram(false),VertexShaderCache::GetSimpleVertexShader(), VertexShaderCache::GetSimpleInputLayout(), Gamma);
}
+
// done with drawing the game stuff, good moment to save a screenshot
if (s_bScreenshot)
{
diff --git a/Source/Plugins/Plugin_VideoDX11/Src/Television.cpp b/Source/Plugins/Plugin_VideoDX11/Src/Television.cpp
new file mode 100644
index 0000000000..4fbc3be3d4
--- /dev/null
+++ b/Source/Plugins/Plugin_VideoDX11/Src/Television.cpp
@@ -0,0 +1,154 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+
+#include "Television.h"
+
+#include "VideoConfig.h"
+#include "D3DBase.h"
+#include "D3DShader.h"
+#include "D3DUtil.h"
+#include "VertexShaderCache.h"
+#include "HW/Memmap.h"
+
+namespace DX11
+{
+
+static const char YUYV_DECODER_PS[] =
+"// dolphin-emu YUYV decoder pixel shader\n"
+
+"Texture2D Tex0 : register(t0);\n"
+"sampler Samp0 : register(s0);\n"
+
+"static const float3x3 YCBCR_TO_RGB = float3x3(\n"
+ "1.164, 0.000, 1.596,\n"
+ "1.164, -0.392, -0.813,\n"
+ "1.164, 2.017, 0.000\n"
+ ");\n"
+
+"void main(out float4 ocol0 : SV_Target, in float4 pos : SV_Position, in float2 uv0 : TEXCOORD0)\n"
+"{\n"
+ "float3 sample = Tex0.Sample(Samp0, uv0).rgb;\n"
+
+ // GameCube/Wii XFB data is in YUYV format with ITU-R Rec. BT.601 color
+ // primaries, compressed to the range Y in 16..235, U and V in 16..240.
+ // We want to convert it to RGB format with sRGB color primaries, with
+ // range 0..255.
+
+ // Recover RGB components
+ "float3 yuv_601_sub = sample.grb - float3(16.0/255.0, 128.0/255.0, 128.0/255.0);\n"
+ "float3 rgb_601 = mul(YCBCR_TO_RGB, yuv_601_sub);\n"
+
+ // If we were really obsessed with accuracy, we would correct for the
+ // differing color primaries between BT.601 and sRGB. However, this may not
+ // be worth the trouble because:
+ // - BT.601 defines two sets of primaries: one for NTSC and one for PAL.
+ // - sRGB's color primaries are actually an intermediate between BT.601's
+ // NTSC and PAL primaries.
+ // - If users even noticed any difference at all, they would be confused by
+ // the slightly-different colors in the NTSC and PAL versions of the same
+ // game.
+ // - Even the game designers probably don't pay close attention to this
+ // stuff.
+ // Still, instructions on how to do it can be found at
+ //
+
+ "ocol0 = float4(rgb_601, 1);\n"
+"}\n"
+;
+
+Television::Television()
+ : m_yuyvTexture(NULL), m_yuyvTextureSRV(NULL), m_pShader(NULL)
+{ }
+
+void Television::Init()
+{
+ HRESULT hr;
+
+ // Create YUYV texture for real XFB mode
+
+ // This texture format is designed for YUYV data.
+ D3D11_TEXTURE2D_DESC t2dd = CD3D11_TEXTURE2D_DESC(
+ DXGI_FORMAT_G8R8_G8B8_UNORM, MAX_XFB_WIDTH, MAX_XFB_HEIGHT, 1, 1);
+ hr = D3D::device->CreateTexture2D(&t2dd, NULL, &m_yuyvTexture);
+ CHECK(SUCCEEDED(hr), "create tv yuyv texture");
+ D3D::SetDebugObjectName(m_yuyvTexture, "tv yuyv texture");
+
+ // Create shader resource view for YUYV texture
+
+ D3D11_SHADER_RESOURCE_VIEW_DESC srvd = CD3D11_SHADER_RESOURCE_VIEW_DESC(
+ m_yuyvTexture, D3D11_SRV_DIMENSION_TEXTURE2D,
+ DXGI_FORMAT_G8R8_G8B8_UNORM);
+ hr = D3D::device->CreateShaderResourceView(m_yuyvTexture, &srvd, &m_yuyvTextureSRV);
+ CHECK(SUCCEEDED(hr), "create tv yuyv texture srv");
+ D3D::SetDebugObjectName(m_yuyvTextureSRV, "tv yuyv texture srv");
+
+ // Create YUYV-decoding pixel shader
+
+ m_pShader = D3D::CompileAndCreatePixelShader(YUYV_DECODER_PS, sizeof(YUYV_DECODER_PS));
+ CHECK(m_pShader != NULL, "compile and create yuyv decoder pixel shader");
+ D3D::SetDebugObjectName(m_pShader, "yuyv decoder pixel shader");
+}
+
+void Television::Shutdown()
+{
+ SAFE_RELEASE(m_pShader);
+ SAFE_RELEASE(m_yuyvTextureSRV);
+ SAFE_RELEASE(m_yuyvTexture);
+}
+
+void Television::Submit(u32 xfbAddr, u32 width, u32 height)
+{
+ m_curAddr = xfbAddr;
+ m_curWidth = width;
+ m_curHeight = height;
+
+ // Load data from GameCube RAM to YUYV texture
+ u8* yuyvSrc = Memory::GetPointer(xfbAddr);
+ D3D11_BOX box = CD3D11_BOX(0, 0, 0, width, height, 1);
+ D3D::context->UpdateSubresource(m_yuyvTexture, 0, &box, yuyvSrc, 2*width, 2*width*height);
+}
+
+void Television::Render()
+{
+ if (g_ActiveConfig.bUseRealXFB && g_ActiveConfig.bUseXFB)
+ {
+ // Use real XFB mode
+ // TODO: If this is the lower field, render at a vertical offset of 1
+ // line down. We could even consider implementing a deinterlacing
+ // algorithm.
+
+ MathUtil::Rectangle sourceRc(0.f, 0.f, float(m_curWidth), float(m_curHeight));
+ MathUtil::Rectangle destRc(-1.f, 1.f, 1.f, -1.f);
+
+ D3D::drawShadedTexSubQuad(
+ m_yuyvTextureSRV, &sourceRc,
+ MAX_XFB_WIDTH, MAX_XFB_HEIGHT,
+ &destRc,
+ m_pShader,
+ VertexShaderCache::GetSimpleVertexShader(),
+ VertexShaderCache::GetSimpleInputLayout());
+ }
+ else if (g_ActiveConfig.bUseXFB)
+ {
+ // Use virtual XFB mode
+
+ // TODO: Eventually, Television should render the Virtual XFB mode
+ // display as well.
+ }
+}
+
+}
diff --git a/Source/Plugins/Plugin_VideoDX11/Src/Television.h b/Source/Plugins/Plugin_VideoDX11/Src/Television.h
new file mode 100644
index 0000000000..4b921223ec
--- /dev/null
+++ b/Source/Plugins/Plugin_VideoDX11/Src/Television.h
@@ -0,0 +1,65 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+
+#ifndef _TELEVISION_H
+#define _TELEVISION_H
+
+#include "VideoCommon.h"
+
+struct ID3D11Texture2D;
+struct ID3D11ShaderResourceView;
+struct ID3D11PixelShader;
+
+namespace DX11
+{
+
+class Television
+{
+
+public:
+
+ Television();
+
+ void Init();
+ void Shutdown();
+
+ // Submit video data to be drawn. This will change the current state of the
+ // TV. xfbAddr points to YUYV data stored in GameCube/Wii RAM, but the XFB
+ // may be virtualized when rendering so the RAM may not actually be read.
+ void Submit(u32 xfbAddr, u32 width, u32 height);
+
+ // Render the current state of the TV.
+ void Render();
+
+private:
+
+ // Properties of last Submit call
+ u32 m_curAddr;
+ u32 m_curWidth;
+ u32 m_curHeight;
+
+ // Used for real XFB mode
+
+ ID3D11Texture2D* m_yuyvTexture;
+ ID3D11ShaderResourceView* m_yuyvTextureSRV;
+ ID3D11PixelShader* m_pShader;
+
+};
+
+}
+
+#endif
diff --git a/Source/Plugins/Plugin_VideoDX11/Src/XFBEncoder.cpp b/Source/Plugins/Plugin_VideoDX11/Src/XFBEncoder.cpp
new file mode 100644
index 0000000000..cedad0a880
--- /dev/null
+++ b/Source/Plugins/Plugin_VideoDX11/Src/XFBEncoder.cpp
@@ -0,0 +1,387 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+
+#include "XFBEncoder.h"
+
+#include "D3DBase.h"
+#include "D3DBlob.h"
+#include "D3DShader.h"
+#include "Render.h"
+#include "GfxState.h"
+#include "FramebufferManager.h"
+
+namespace DX11
+{
+
+union XFBEncodeParams
+{
+ struct
+ {
+ FLOAT Width; // Width and height of encoded XFB in luma pixels
+ FLOAT Height;
+ FLOAT TexLeft; // Normalized tex coordinates of XFB source area in EFB texture
+ FLOAT TexTop;
+ FLOAT TexRight;
+ FLOAT TexBottom;
+ FLOAT Gamma;
+ };
+ // Constant buffers must be a multiple of 16 bytes in size
+ u8 pad[32]; // Pad to the next multiple of 16
+};
+
+static const char XFB_ENCODE_VS[] =
+"// dolphin-emu XFB encoder vertex shader\n"
+
+"cbuffer cbParams : register(b0)\n"
+"{\n"
+ "struct\n" // Should match XFBEncodeParams above
+ "{\n"
+ "float Width;\n"
+ "float Height;\n"
+ "float TexLeft;\n"
+ "float TexTop;\n"
+ "float TexRight;\n"
+ "float TexBottom;\n"
+ "float Gamma;\n"
+ "} Params;\n"
+"}\n"
+
+"struct Output\n"
+"{\n"
+ "float4 Pos : SV_Position;\n"
+ "float2 Coord : ENCODECOORD;\n"
+"};\n"
+
+"Output main(in float2 Pos : POSITION)\n"
+"{\n"
+ "Output result;\n"
+ "result.Pos = float4(2*Pos.x-1, -2*Pos.y+1, 0, 1);\n"
+ "result.Coord = Pos * float2(floor(Params.Width/2), Params.Height);\n"
+ "return result;\n"
+"}\n"
+;
+
+static const char XFB_ENCODE_PS[] =
+"// dolphin-emu XFB encoder pixel shader\n"
+
+"cbuffer cbParams : register(b0)\n"
+"{\n"
+ "struct\n" // Should match XFBEncodeParams above
+ "{\n"
+ "float Width;\n"
+ "float Height;\n"
+ "float TexLeft;\n"
+ "float TexTop;\n"
+ "float TexRight;\n"
+ "float TexBottom;\n"
+ "float Gamma;\n"
+ "} Params;\n"
+"}\n"
+
+"Texture2D EFBTexture : register(t0);\n"
+"sampler EFBSampler : register(s0);\n"
+
+// GameCube/Wii uses the BT.601 standard algorithm for converting to YCbCr; see
+//
+"static const float3x4 RGB_TO_YCBCR = float3x4(\n"
+ "0.257, 0.504, 0.098, 16.0/255.0,\n"
+ "-0.148, -0.291, 0.439, 128.0/255.0,\n"
+ "0.439, -0.368, -0.071, 128.0/255.0\n"
+ ");\n"
+
+"float3 SampleEFB(float2 coord)\n"
+"{\n"
+ "float2 texCoord = lerp(float2(Params.TexLeft,Params.TexTop), float2(Params.TexRight,Params.TexBottom), coord / float2(Params.Width,Params.Height));\n"
+ "return EFBTexture.Sample(EFBSampler, texCoord).rgb;\n"
+"}\n"
+
+"void main(out float4 ocol0 : SV_Target, in float4 Pos : SV_Position, in float2 Coord : ENCODECOORD)\n"
+"{\n"
+ "float2 baseCoord = Coord * float2(2,1);\n"
+ // FIXME: Shall we apply gamma here, or apply it below to the Y components?
+ // Be careful if you apply it to Y! The Y components are in the range (16..235) / 255.
+ "float3 sampleL = pow(abs(SampleEFB(baseCoord+float2(-1,0))), Params.Gamma);\n" // Left
+ "float3 sampleM = pow(abs(SampleEFB(baseCoord)), Params.Gamma);\n" // Middle
+ "float3 sampleR = pow(abs(SampleEFB(baseCoord+float2(1,0))), Params.Gamma);\n" // Right
+
+ "float3 yuvL = mul(RGB_TO_YCBCR, float4(sampleL,1));\n"
+ "float3 yuvM = mul(RGB_TO_YCBCR, float4(sampleM,1));\n"
+ "float3 yuvR = mul(RGB_TO_YCBCR, float4(sampleR,1));\n"
+
+ // The Y components correspond to two EFB pixels, while the U and V are
+ // made from a blend of three EFB pixels.
+ "float y0 = yuvM.r;\n"
+ "float y1 = yuvR.r;\n"
+ "float u0 = 0.25*yuvL.g + 0.5*yuvM.g + 0.25*yuvR.g;\n"
+ "float v0 = 0.25*yuvL.b + 0.5*yuvM.b + 0.25*yuvR.b;\n"
+
+ "ocol0 = float4(y0, u0, y1, v0);\n"
+"}\n"
+;
+
+static const D3D11_INPUT_ELEMENT_DESC QUAD_LAYOUT_DESC[] = {
+ { "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }
+};
+
+static const struct QuadVertex
+{
+ float posX;
+ float posY;
+} QUAD_VERTS[4] = { { 0, 0 }, { 1, 0 }, { 0, 1 }, { 1, 1 } };
+
+XFBEncoder::XFBEncoder()
+ : m_out(NULL), m_outRTV(NULL), m_outStage(NULL), m_encodeParams(NULL),
+ m_quad(NULL), m_vShader(NULL), m_quadLayout(NULL), m_pShader(NULL),
+ m_xfbEncodeBlendState(NULL), m_xfbEncodeDepthState(NULL),
+ m_xfbEncodeRastState(NULL), m_efbSampler(NULL)
+{ }
+
+void XFBEncoder::Init()
+{
+ HRESULT hr;
+
+ // Create output texture
+
+ // The pixel shader can generate one YUYV entry per pixel. One YUYV entry
+ // is created for every two EFB pixels.
+ D3D11_TEXTURE2D_DESC t2dd = CD3D11_TEXTURE2D_DESC(
+ DXGI_FORMAT_R8G8B8A8_UNORM, MAX_XFB_WIDTH/2, MAX_XFB_HEIGHT, 1, 1,
+ D3D11_BIND_RENDER_TARGET);
+ hr = D3D::device->CreateTexture2D(&t2dd, NULL, &m_out);
+ CHECK(SUCCEEDED(hr), "create xfb encoder output texture");
+ D3D::SetDebugObjectName(m_out, "xfb encoder output texture");
+
+ // Create output render target view
+
+ D3D11_RENDER_TARGET_VIEW_DESC rtvd = CD3D11_RENDER_TARGET_VIEW_DESC(m_out,
+ D3D11_RTV_DIMENSION_TEXTURE2D, DXGI_FORMAT_R8G8B8A8_UNORM);
+ hr = D3D::device->CreateRenderTargetView(m_out, &rtvd, &m_outRTV);
+ CHECK(SUCCEEDED(hr), "create xfb encoder output texture rtv");
+ D3D::SetDebugObjectName(m_outRTV, "xfb encoder output rtv");
+
+ // Create output staging buffer
+
+ t2dd.Usage = D3D11_USAGE_STAGING;
+ t2dd.BindFlags = 0;
+ t2dd.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+ hr = D3D::device->CreateTexture2D(&t2dd, NULL, &m_outStage);
+ CHECK(SUCCEEDED(hr), "create xfb encoder output staging buffer");
+ D3D::SetDebugObjectName(m_outStage, "xfb encoder output staging buffer");
+
+ // Create constant buffer for uploading params to shaders
+
+ D3D11_BUFFER_DESC bd = CD3D11_BUFFER_DESC(sizeof(XFBEncodeParams),
+ D3D11_BIND_CONSTANT_BUFFER);
+ hr = D3D::device->CreateBuffer(&bd, NULL, &m_encodeParams);
+ CHECK(SUCCEEDED(hr), "create xfb encode params buffer");
+ D3D::SetDebugObjectName(m_encodeParams, "xfb encoder params buffer");
+
+ // Create vertex quad
+
+ bd = CD3D11_BUFFER_DESC(sizeof(QUAD_VERTS), D3D11_BIND_VERTEX_BUFFER,
+ D3D11_USAGE_IMMUTABLE);
+ D3D11_SUBRESOURCE_DATA srd = { QUAD_VERTS, 0, 0 };
+
+ hr = D3D::device->CreateBuffer(&bd, &srd, &m_quad);
+ CHECK(SUCCEEDED(hr), "create xfb encode quad vertex buffer");
+ D3D::SetDebugObjectName(m_quad, "xfb encoder quad vertex buffer");
+
+ // Create vertex shader
+
+ D3DBlob* bytecode = NULL;
+ if (!D3D::CompileVertexShader(XFB_ENCODE_VS, sizeof(XFB_ENCODE_VS), &bytecode))
+ {
+ ERROR_LOG(VIDEO, "XFB encode vertex shader failed to compile");
+ return;
+ }
+
+ hr = D3D::device->CreateVertexShader(bytecode->Data(), bytecode->Size(), NULL, &m_vShader);
+ CHECK(SUCCEEDED(hr), "create xfb encode vertex shader");
+ D3D::SetDebugObjectName(m_vShader, "xfb encoder vertex shader");
+
+ // Create input layout for vertex quad using bytecode from vertex shader
+
+ hr = D3D::device->CreateInputLayout(QUAD_LAYOUT_DESC,
+ sizeof(QUAD_LAYOUT_DESC)/sizeof(D3D11_INPUT_ELEMENT_DESC),
+ bytecode->Data(), bytecode->Size(), &m_quadLayout);
+ CHECK(SUCCEEDED(hr), "create xfb encode quad vertex layout");
+ D3D::SetDebugObjectName(m_quadLayout, "xfb encoder quad layout");
+
+ bytecode->Release();
+
+ // Create pixel shader
+
+ m_pShader = D3D::CompileAndCreatePixelShader(XFB_ENCODE_PS, sizeof(XFB_ENCODE_PS));
+ if (!m_pShader)
+ {
+ ERROR_LOG(VIDEO, "XFB encode pixel shader failed to compile");
+ return;
+ }
+ D3D::SetDebugObjectName(m_pShader, "xfb encoder pixel shader");
+
+ // Create blend state
+
+ D3D11_BLEND_DESC bld = CD3D11_BLEND_DESC(CD3D11_DEFAULT());
+ hr = D3D::device->CreateBlendState(&bld, &m_xfbEncodeBlendState);
+ CHECK(SUCCEEDED(hr), "create xfb encode blend state");
+ D3D::SetDebugObjectName(m_xfbEncodeBlendState, "xfb encoder blend state");
+
+ // Create depth state
+
+ D3D11_DEPTH_STENCIL_DESC dsd = CD3D11_DEPTH_STENCIL_DESC(CD3D11_DEFAULT());
+ dsd.DepthEnable = FALSE;
+ hr = D3D::device->CreateDepthStencilState(&dsd, &m_xfbEncodeDepthState);
+ CHECK(SUCCEEDED(hr), "create xfb encode depth state");
+ D3D::SetDebugObjectName(m_xfbEncodeDepthState, "xfb encoder depth state");
+
+ // Create rasterizer state
+
+ D3D11_RASTERIZER_DESC rd = CD3D11_RASTERIZER_DESC(CD3D11_DEFAULT());
+ rd.CullMode = D3D11_CULL_NONE;
+ rd.DepthClipEnable = FALSE;
+ hr = D3D::device->CreateRasterizerState(&rd, &m_xfbEncodeRastState);
+ CHECK(SUCCEEDED(hr), "create xfb encode rasterizer state");
+ D3D::SetDebugObjectName(m_xfbEncodeRastState, "xfb encoder rast state");
+
+ // Create EFB texture sampler
+
+ D3D11_SAMPLER_DESC sd = CD3D11_SAMPLER_DESC(CD3D11_DEFAULT());
+ // FIXME: Should we really use point sampling here?
+ sd.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
+ hr = D3D::device->CreateSamplerState(&sd, &m_efbSampler);
+ CHECK(SUCCEEDED(hr), "create xfb encode texture sampler");
+ D3D::SetDebugObjectName(m_efbSampler, "xfb encoder texture sampler");
+}
+
+void XFBEncoder::Shutdown()
+{
+ SAFE_RELEASE(m_efbSampler);
+ SAFE_RELEASE(m_xfbEncodeRastState);
+ SAFE_RELEASE(m_xfbEncodeDepthState);
+ SAFE_RELEASE(m_xfbEncodeBlendState);
+ SAFE_RELEASE(m_pShader);
+ SAFE_RELEASE(m_quadLayout);
+ SAFE_RELEASE(m_vShader);
+ SAFE_RELEASE(m_quad);
+ SAFE_RELEASE(m_encodeParams);
+ SAFE_RELEASE(m_outStage);
+ SAFE_RELEASE(m_outRTV);
+ SAFE_RELEASE(m_out);
+}
+
+void XFBEncoder::Encode(u8* dst, u32 width, u32 height, const EFBRectangle& srcRect, float gamma)
+{
+ HRESULT hr;
+
+ // Reset API
+
+ g_renderer->ResetAPIState();
+
+ // Set up all the state for XFB encoding
+
+ D3D::context->PSSetShader(m_pShader, NULL, 0);
+ D3D::context->VSSetShader(m_vShader, NULL, 0);
+
+ D3D::stateman->PushBlendState(m_xfbEncodeBlendState);
+ D3D::stateman->PushDepthState(m_xfbEncodeDepthState);
+ D3D::stateman->PushRasterizerState(m_xfbEncodeRastState);
+ D3D::stateman->Apply();
+
+ D3D11_VIEWPORT vp = CD3D11_VIEWPORT(0.f, 0.f, FLOAT(width/2), FLOAT(height));
+ D3D::context->RSSetViewports(1, &vp);
+
+ D3D::context->IASetInputLayout(m_quadLayout);
+ D3D::context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
+ UINT stride = sizeof(QuadVertex);
+ UINT offset = 0;
+ D3D::context->IASetVertexBuffers(0, 1, &m_quad, &stride, &offset);
+
+ TargetRectangle targetRect = g_renderer->ConvertEFBRectangle(srcRect);
+
+ XFBEncodeParams params = { 0 };
+ params.Width = FLOAT(width);
+ params.Height = FLOAT(height);
+ params.TexLeft = FLOAT(targetRect.left) / g_renderer->GetFullTargetWidth();
+ params.TexTop = FLOAT(targetRect.top) / g_renderer->GetFullTargetHeight();
+ params.TexRight = FLOAT(targetRect.right) / g_renderer->GetFullTargetWidth();
+ params.TexBottom = FLOAT(targetRect.bottom) / g_renderer->GetFullTargetHeight();
+ params.Gamma = gamma;
+ D3D::context->UpdateSubresource(m_encodeParams, 0, NULL, ¶ms, 0, 0);
+
+ D3D::context->VSSetConstantBuffers(0, 1, &m_encodeParams);
+
+ D3D::context->OMSetRenderTargets(1, &m_outRTV, NULL);
+
+ ID3D11ShaderResourceView* pEFB = FramebufferManager::GetEFBColorTexture()->GetSRV();
+
+ D3D::context->PSSetConstantBuffers(0, 1, &m_encodeParams);
+ D3D::context->PSSetShaderResources(0, 1, &pEFB);
+ D3D::context->PSSetSamplers(0, 1, &m_efbSampler);
+
+ // Encode!
+
+ D3D::context->Draw(4, 0);
+
+ // Copy to staging buffer
+
+ D3D11_BOX srcBox = CD3D11_BOX(0, 0, 0, width/2, height, 1);
+ D3D::context->CopySubresourceRegion(m_outStage, 0, 0, 0, 0, m_out, 0, &srcBox);
+
+ // Clean up state
+
+ IUnknown* nullDummy = NULL;
+
+ D3D::context->PSSetSamplers(0, 1, (ID3D11SamplerState**)&nullDummy);
+ D3D::context->PSSetShaderResources(0, 1, (ID3D11ShaderResourceView**)&nullDummy);
+ D3D::context->PSSetConstantBuffers(0, 1, (ID3D11Buffer**)&nullDummy);
+
+ D3D::context->OMSetRenderTargets(0, NULL, NULL);
+
+ D3D::context->VSSetConstantBuffers(0, 1, (ID3D11Buffer**)&nullDummy);
+
+ D3D::stateman->PopRasterizerState();
+ D3D::stateman->PopDepthState();
+ D3D::stateman->PopBlendState();
+
+ D3D::context->PSSetShader(NULL, NULL, 0);
+ D3D::context->VSSetShader(NULL, NULL, 0);
+
+ // Transfer staging buffer to GameCube/Wii RAM
+
+ D3D11_MAPPED_SUBRESOURCE map = { 0 };
+ hr = D3D::context->Map(m_outStage, 0, D3D11_MAP_READ, 0, &map);
+ CHECK(SUCCEEDED(hr), "map staging buffer");
+
+ u8* src = (u8*)map.pData;
+ for (unsigned int y = 0; y < height; ++y)
+ {
+ memcpy(dst, src, 2*width);
+ dst += bpmem.copyMipMapStrideChannels*32;
+ src += map.RowPitch;
+ }
+
+ D3D::context->Unmap(m_outStage, 0);
+
+ // Restore API
+
+ g_renderer->RestoreAPIState();
+ D3D::context->OMSetRenderTargets(1,
+ &FramebufferManager::GetEFBColorTexture()->GetRTV(),
+ FramebufferManager::GetEFBDepthTexture()->GetDSV());
+}
+
+}
diff --git a/Source/Plugins/Plugin_VideoDX11/Src/XFBEncoder.h b/Source/Plugins/Plugin_VideoDX11/Src/XFBEncoder.h
new file mode 100644
index 0000000000..dba1fd20e9
--- /dev/null
+++ b/Source/Plugins/Plugin_VideoDX11/Src/XFBEncoder.h
@@ -0,0 +1,68 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+
+#ifndef _XFBENCODER_H
+#define _XFBENCODER_H
+
+#include "VideoCommon.h"
+
+struct ID3D11Texture2D;
+struct ID3D11RenderTargetView;
+struct ID3D11Buffer;
+struct ID3D11VertexShader;
+struct ID3D11PixelShader;
+struct ID3D11InputLayout;
+struct ID3D11BlendState;
+struct ID3D11DepthStencilState;
+struct ID3D11RasterizerState;
+struct ID3D11SamplerState;
+
+namespace DX11
+{
+
+class XFBEncoder
+{
+
+public:
+
+ XFBEncoder();
+
+ void Init();
+ void Shutdown();
+
+ void Encode(u8* dst, u32 width, u32 height, const EFBRectangle& srcRect, float gamma);
+
+private:
+
+ ID3D11Texture2D* m_out;
+ ID3D11RenderTargetView* m_outRTV;
+ ID3D11Texture2D* m_outStage;
+ ID3D11Buffer* m_encodeParams;
+ ID3D11Buffer* m_quad;
+ ID3D11VertexShader* m_vShader;
+ ID3D11InputLayout* m_quadLayout;
+ ID3D11PixelShader* m_pShader;
+ ID3D11BlendState* m_xfbEncodeBlendState;
+ ID3D11DepthStencilState* m_xfbEncodeDepthState;
+ ID3D11RasterizerState* m_xfbEncodeRastState;
+ ID3D11SamplerState* m_efbSampler;
+
+};
+
+}
+
+#endif
diff --git a/Source/Plugins/Plugin_VideoDX11/Src/main.cpp b/Source/Plugins/Plugin_VideoDX11/Src/main.cpp
index d77836f4e5..ebd40d8782 100644
--- a/Source/Plugins/Plugin_VideoDX11/Src/main.cpp
+++ b/Source/Plugins/Plugin_VideoDX11/Src/main.cpp
@@ -82,7 +82,7 @@ void InitBackendInfo()
g_Config.backend_info.APIType = API_D3D11;
g_Config.backend_info.bUseRGBATextures = true; // the GX formats barely match any D3D11 formats
g_Config.backend_info.bSupportsEFBToRAM = true;
- g_Config.backend_info.bSupportsRealXFB = false;
+ g_Config.backend_info.bSupportsRealXFB = true;
g_Config.backend_info.bSupports3DVision = false;
g_Config.backend_info.bAllowSignedBytes = true;
g_Config.backend_info.bSupportsDualSourceBlend = true;