Revert r7421 and r7422.

Should fix issue 4413.


git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@7592 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
NeoBrainX
2011-06-11 19:37:21 +00:00
parent e5210de9d5
commit 8244efcc02
42 changed files with 1647 additions and 1420 deletions

View File

@ -19,6 +19,7 @@
#include "VideoConfig.h"
#include "D3DBase.h"
#include "D3DShader.h"
namespace DX11
@ -28,149 +29,217 @@ namespace D3D
{
// bytecode->shader
SharedPtr<ID3D11VertexShader> CreateVertexShaderFromByteCode(const void* bytecode, unsigned int len)
ID3D11VertexShader* CreateVertexShaderFromByteCode(const void* bytecode, unsigned int len)
{
ID3D11VertexShader* v_shader = nullptr;
HRESULT hr = D3D::g_device->CreateVertexShader(bytecode, len, NULL, &v_shader);
ID3D11VertexShader* v_shader;
HRESULT hr = D3D::device->CreateVertexShader(bytecode, len, NULL, &v_shader);
if (FAILED(hr))
PanicAlert("CreateVertexShaderFromByteCode failed from %p (size %d) at %s %d\n",
bytecode, len, __FILE__, __LINE__);
return SharedPtr<ID3D11VertexShader>::FromPtr(v_shader);
{
PanicAlert("CreateVertexShaderFromByteCode failed from %p (size %d) at %s %d\n", bytecode, len, __FILE__, __LINE__);
v_shader = NULL;
}
return v_shader;
}
// bytecode->shader
SharedPtr<ID3D11GeometryShader> CreateGeometryShaderFromByteCode(const void* bytecode, unsigned int len)
// code->bytecode
bool CompileVertexShader(const char* code, unsigned int len, D3DBlob** blob)
{
ID3D11GeometryShader* g_shader = nullptr;
HRESULT hr = D3D::g_device->CreateGeometryShader(bytecode, len, NULL, &g_shader);
if (FAILED(hr))
PanicAlert("CreateGeometryShaderFromByteCode failed from %p (size %d) at %s %d\n",
bytecode, len, __FILE__, __LINE__);
return SharedPtr<ID3D11GeometryShader>::FromPtr(g_shader);
}
// bytecode->shader
SharedPtr<ID3D11PixelShader> CreatePixelShaderFromByteCode(const void* bytecode, unsigned int len)
{
ID3D11PixelShader* p_shader = nullptr;
HRESULT hr = D3D::g_device->CreatePixelShader(bytecode, len, NULL, &p_shader);
if (FAILED(hr))
PanicAlert("CreatePixelShaderFromByteCode failed at %s %d\n", __FILE__, __LINE__);
return SharedPtr<ID3D11PixelShader>::FromPtr(p_shader);
}
static SharedPtr<ID3D10Blob> CompileShader(const char* code, unsigned int len,
const char* ver_str, const D3D_SHADER_MACRO* pDefines = NULL)
{
static const UINT shader_compilation_flags = D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY
ID3D10Blob* shaderBuffer = NULL;
ID3D10Blob* errorBuffer = NULL;
#if defined(_DEBUG) || defined(DEBUGFAST)
| D3D10_SHADER_DEBUG | D3D10_SHADER_WARNINGS_ARE_ERRORS;
UINT flags = D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY|D3D10_SHADER_DEBUG|D3D10_SHADER_WARNINGS_ARE_ERRORS;
#else
| D3D10_SHADER_OPTIMIZATION_LEVEL3 | D3D10_SHADER_SKIP_VALIDATION;
UINT flags = D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY|D3D10_SHADER_OPTIMIZATION_LEVEL3|D3D10_SHADER_SKIP_VALIDATION;
#endif
ID3D10Blob* shaderBuffer = nullptr;
ID3D10Blob* errorBuffer = nullptr;
HRESULT hr = PD3DX11CompileFromMemory(code, len, NULL, pDefines, NULL, "main", ver_str,
shader_compilation_flags, 0, NULL, &shaderBuffer, &errorBuffer, NULL);
if (FAILED(hr) && g_ActiveConfig.bShowShaderErrors)
{
std::string msg = (const char*)errorBuffer->GetBufferPointer();
msg += "\n\n";
msg += ver_str;
msg += "\n\n";
msg += code;
MessageBoxA(0, msg.c_str(), "Error compiling shader", MB_ICONERROR);
}
HRESULT hr = PD3DX11CompileFromMemory(code, len, NULL, NULL, NULL, "main", D3D::VertexShaderVersionString(),
flags, 0, NULL, &shaderBuffer, &errorBuffer, NULL);
if (errorBuffer)
{
INFO_LOG(VIDEO, "Shader %s compiler messages:\n%s\n", ver_str,
INFO_LOG(VIDEO, "Vertex shader compiler messages:\n%s\n",
(const char*)errorBuffer->GetBufferPointer());
}
if (FAILED(hr))
{
if (g_ActiveConfig.bShowShaderErrors)
{
std::string msg = (char*)errorBuffer->GetBufferPointer();
msg += "\n\n";
msg += D3D::VertexShaderVersionString();
msg += "\n\n";
msg += code;
MessageBoxA(0, msg.c_str(), "Error compiling vertex shader", MB_ICONERROR);
}
*blob = NULL;
errorBuffer->Release();
}
return SharedPtr<ID3D10Blob>::FromPtr(shaderBuffer);
else
{
*blob = new D3DBlob(shaderBuffer);
shaderBuffer->Release();
}
return SUCCEEDED(hr);
}
// code->bytecode
SharedPtr<ID3D10Blob> CompileVertexShader(const char* code, unsigned int len)
// bytecode->shader
ID3D11GeometryShader* CreateGeometryShaderFromByteCode(const void* bytecode, unsigned int len)
{
return CompileShader(code, len, D3D::VertexShaderVersionString());
ID3D11GeometryShader* g_shader;
HRESULT hr = D3D::device->CreateGeometryShader(bytecode, len, NULL, &g_shader);
if (FAILED(hr))
{
PanicAlert("CreateGeometryShaderFromByteCode failed from %p (size %d) at %s %d\n", bytecode, len, __FILE__, __LINE__);
g_shader = NULL;
}
return g_shader;
}
// code->bytecode
SharedPtr<ID3D10Blob> CompileGeometryShader(const char* code, unsigned int len,
bool CompileGeometryShader(const char* code, unsigned int len, D3DBlob** blob,
const D3D_SHADER_MACRO* pDefines)
{
return CompileShader(code, len, D3D::GeometryShaderVersionString(), pDefines);
ID3D10Blob* shaderBuffer = NULL;
ID3D10Blob* errorBuffer = NULL;
#if defined(_DEBUG) || defined(DEBUGFAST)
UINT flags = D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY|D3D10_SHADER_DEBUG|D3D10_SHADER_WARNINGS_ARE_ERRORS;
#else
UINT flags = D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY|D3D10_SHADER_OPTIMIZATION_LEVEL3|D3D10_SHADER_SKIP_VALIDATION;
#endif
HRESULT hr = PD3DX11CompileFromMemory(code, len, NULL, pDefines, NULL, "main", D3D::GeometryShaderVersionString(),
flags, 0, NULL, &shaderBuffer, &errorBuffer, NULL);
if (errorBuffer)
{
INFO_LOG(VIDEO, "Geometry shader compiler messages:\n%s\n",
(const char*)errorBuffer->GetBufferPointer());
}
if (FAILED(hr))
{
if (g_ActiveConfig.bShowShaderErrors)
{
std::string msg = (char*)errorBuffer->GetBufferPointer();
msg += "\n\n";
msg += D3D::GeometryShaderVersionString();
msg += "\n\n";
msg += code;
MessageBoxA(0, msg.c_str(), "Error compiling geometry shader", MB_ICONERROR);
}
*blob = NULL;
errorBuffer->Release();
}
else
{
*blob = new D3DBlob(shaderBuffer);
shaderBuffer->Release();
}
return SUCCEEDED(hr);
}
// bytecode->shader
ID3D11PixelShader* CreatePixelShaderFromByteCode(const void* bytecode, unsigned int len)
{
ID3D11PixelShader* p_shader;
HRESULT hr = D3D::device->CreatePixelShader(bytecode, len, NULL, &p_shader);
if (FAILED(hr))
{
PanicAlert("CreatePixelShaderFromByteCode failed at %s %d\n", __FILE__, __LINE__);
p_shader = NULL;
}
return p_shader;
}
// code->bytecode
SharedPtr<ID3D10Blob> CompilePixelShader(const char* code, unsigned int len,
bool CompilePixelShader(const char* code, unsigned int len, D3DBlob** blob,
const D3D_SHADER_MACRO* pDefines)
{
return CompileShader(code, len, D3D::PixelShaderVersionString(), pDefines);
}
ID3D10Blob* shaderBuffer = NULL;
ID3D10Blob* errorBuffer = NULL;
SharedPtr<ID3D11VertexShader> CompileAndCreateVertexShader(const char* code, unsigned int len,
SharedPtr<ID3D10Blob>* bytecode)
{
auto const blob = CompileVertexShader(code, len);
if (blob)
#if defined(_DEBUG) || defined(DEBUGFAST)
UINT flags = D3D10_SHADER_DEBUG|D3D10_SHADER_WARNINGS_ARE_ERRORS;
#else
UINT flags = D3D10_SHADER_OPTIMIZATION_LEVEL3;
#endif
HRESULT hr = PD3DX11CompileFromMemory(code, len, NULL, pDefines, NULL, "main", D3D::PixelShaderVersionString(),
flags, 0, NULL, &shaderBuffer, &errorBuffer, NULL);
if (errorBuffer)
{
if (bytecode)
*bytecode = blob;
return CreateVertexShaderFromByteCode(blob->GetBufferPointer(), (unsigned int)blob->GetBufferSize());
INFO_LOG(VIDEO, "Pixel shader compiler messages:\n%s",
(const char*)errorBuffer->GetBufferPointer());
}
if (FAILED(hr))
{
if (g_ActiveConfig.bShowShaderErrors)
{
std::string msg = (char*)errorBuffer->GetBufferPointer();
msg += "\n\n";
msg += D3D::PixelShaderVersionString();
msg += "\n\n";
msg += code;
MessageBoxA(0, msg.c_str(), "Error compiling pixel shader", MB_ICONERROR);
}
*blob = NULL;
errorBuffer->Release();
}
else
{
PanicAlert("Failed to compile and create vertex shader from %p (size %d) at %s %d\n",
code, len, __FILE__, __LINE__);
return SharedPtr<ID3D11VertexShader>::FromPtr(nullptr);
*blob = new D3DBlob(shaderBuffer);
shaderBuffer->Release();
}
return SUCCEEDED(hr);
}
SharedPtr<ID3D11GeometryShader> CompileAndCreateGeometryShader(const char* code, unsigned int len,
const D3D_SHADER_MACRO* pDefines, SharedPtr<ID3D10Blob>* bytecode)
ID3D11VertexShader* CompileAndCreateVertexShader(const char* code,
unsigned int len)
{
auto const blob = CompileGeometryShader(code, len, pDefines);
if (blob)
D3DBlob* blob = NULL;
if (CompileVertexShader(code, len, &blob))
{
if (bytecode)
*bytecode = blob;
return CreateGeometryShaderFromByteCode(blob->GetBufferPointer(), (unsigned int)blob->GetBufferSize());
}
else
{
PanicAlert("Failed to compile and create geometry shader from %p (size %d) at %s %d\n",
code, len, __FILE__, __LINE__);
return SharedPtr<ID3D11GeometryShader>::FromPtr(nullptr);
ID3D11VertexShader* v_shader = CreateVertexShaderFromByteCode(blob);
blob->Release();
return v_shader;
}
PanicAlert("Failed to compile and create vertex shader from %p (size %d) at %s %d\n", code, len, __FILE__, __LINE__);
return NULL;
}
SharedPtr<ID3D11PixelShader> CompileAndCreatePixelShader(const char* code, unsigned int len,
const D3D_SHADER_MACRO* pDefines, SharedPtr<ID3D10Blob>* bytecode)
ID3D11GeometryShader* CompileAndCreateGeometryShader(const char* code,
unsigned int len, const D3D_SHADER_MACRO* pDefines)
{
auto const blob = CompilePixelShader(code, len, pDefines);
D3DBlob* blob = NULL;
if (CompileGeometryShader(code, len, &blob, pDefines))
{
ID3D11GeometryShader* g_shader = CreateGeometryShaderFromByteCode(blob);
blob->Release();
return g_shader;
}
PanicAlert("Failed to compile and create geometry shader from %p (size %d) at %s %d\n", code, len, __FILE__, __LINE__);
return NULL;
}
ID3D11PixelShader* CompileAndCreatePixelShader(const char* code,
unsigned int len)
{
D3DBlob* blob = NULL;
CompilePixelShader(code, len, &blob);
if (blob)
{
if (bytecode)
*bytecode = blob;
return CreatePixelShaderFromByteCode(blob->GetBufferPointer(), (unsigned int)blob->GetBufferSize());
}
else
{
PanicAlert("Failed to compile and create pixel shader, %s %d\n", __FILE__, __LINE__);
return SharedPtr<ID3D11PixelShader>::FromPtr(nullptr);
ID3D11PixelShader* p_shader = CreatePixelShaderFromByteCode(blob);
blob->Release();
return p_shader;
}
PanicAlert("Failed to compile and create pixel shader, %s %d\n", __FILE__, __LINE__);
return NULL;
}
} // namespace