VertexBufferDX11::VertexBufferDX11(int vertexSize, int numberOfVertices, void* data, DX11* dx)
{
HRESULT hr;
mDX = dx;
mVertexSize = vertexSize;
mNumberOfVertices = numberOfVertices;
D3D11_BUFFER_DESC bd;
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D11_USAGE_DYNAMIC;
bd.ByteWidth = vertexSize*numberOfVertices;
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
hr = mDX->Device()->CreateBuffer(&bd, NULL, &pVBuffer);
if(FAILED(hr))
{
MessageBox(NULL, DXGetErrorDescription(hr), TEXT("Could not create vertex buffer."), MB_OK);
}
D3D11_MAPPED_SUBRESOURCE ms;
hr = mDX->DeviceContext()->Map(pVBuffer, NULL, D3D11_MAP_WRITE_DISCARD, NULL, &ms);
if(FAILED(hr))
{
MessageBox(NULL, DXGetErrorDescription(hr), TEXT("Could not map vertex buffer."), MB_OK);
}
memcpy(ms.pData, data, numberOfVertices*vertexSize);
mDX->DeviceContext()->Unmap(pVBuffer, NULL);
}
DFORCEINLINE static void getResources(ID3D10Device *d3dDevice,
const String& prefix,
DUNORDERED_MAP <String, size_t>& mapResource,
DUNORDERED_MAP <String, size_t>& mapSampler,
ID3D10Blob* pCode){
HRESULT hr;
ID3D10ShaderReflection* pReflection = NULL;
hr = D3D10ReflectShader((void*)pCode->GetBufferPointer(),
pCode->GetBufferSize(),
&pReflection);
if (FAILED(hr))
{
DEBUG_ASSERT_MSG(0, "Shader reflection could not be obtained. Reason: " << DXGetErrorDescription(hr));
return;
}
D3D10_SHADER_DESC desc;
DX_ASSERT_MSG(pReflection->GetDesc(&desc));
//init
size_t valueOffset = 0;
//calc size
for (uint i = 0; i < desc.BoundResources; ++i)
{
D3D10_SHADER_INPUT_BIND_DESC resourceDesc;
pReflection->GetResourceBindingDesc(i, &resourceDesc);
if (resourceDesc.Type == D3D10_SIT_TEXTURE){
mapResource[prefix + '.' + resourceDesc.Name] = resourceDesc.BindPoint;
}
else if (resourceDesc.Type == D3D10_SIT_SAMPLER){
mapSampler[resourceDesc.Name] = resourceDesc.BindPoint;
}
}
}
VOID Render()
{
// Clear the back-buffer to a RED color
HRESULT hr ;
// D3DCOLOR
hr = g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0, 1.0f, 0);
if (FAILED(hr))
{
DXTRACE_ERR_MSGBOX(DXGetErrorDescription(hr), hr) ;
}
// Begin the scene
if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
{
// Set cull mode
g_pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE) ;
g_pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW) ;
g_pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW) ; // Default option
g_pd3dDevice->SetStreamSource( 0, g_pVB, 0, sizeof( ScreenVertex ) );
g_pd3dDevice->SetFVF( SCREEN_SPACE_FVF );
g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, 2 );
// End the scene
g_pd3dDevice->EndScene();
}
// Present the back-buffer contents to the display
g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
}
~DXErrorTracer()
{
if (m_hr == D3D_OK) return;
char buf[128] = "";
sprintf(buf, "%s(%d): \n%s\n", m_file, m_line, DXGetErrorDescription(m_hr));
MessageBox(NULL, buf, "d3d err", MB_OK);
}
inline static bool dxAssertMsg(HRESULT hr, const char* strcommand, const char* file, int line){
if (FAILED(hr)){
Debug::message() << "DirectX: " << DXGetErrorDescription(hr) << "\n";
Debug::doassert(0, "DirectX Render"/*strcommand*/, file, line);
return false;
}
return true;
}
const char * render_error_description( int error )
{
#ifdef __WINE__
return "";
#else
return DXGetErrorDescription(error);
#endif
}
bool CheckForError(HRESULT hr, LPCWSTR label)
{
if (FAILED(hr))
{
MessageBox(0, DXGetErrorDescription(hr), label, MB_OK | MB_ICONERROR);
return true;
}
return false;
}
DFORCEINLINE static void getContants(ID3D10Device *d3dDevice,
const String& prefix,
DUNORDERED_MAP <String, size_t>& mapVars,
ID3D10Blob* pCode,
ID3D10Buffer** pBuffer,
size_t& size){
HRESULT hr;
ID3D10ShaderReflection* pReflection = NULL;
hr = D3D10ReflectShader((void*)pCode->GetBufferPointer(),
pCode->GetBufferSize(),
&pReflection);
if (FAILED(hr))
{
DEBUG_ASSERT_MSG(0, "Shader reflection could not be obtained. Reason: " << DXGetErrorDescription(hr));
return;
}
D3D10_SHADER_DESC desc;
DX_ASSERT_MSG(pReflection->GetDesc(&desc));
//init
ID3D10ShaderReflectionConstantBuffer* pConstantBuffer = NULL;
size_t valueOffset = 0;
size = 0;
//calc size
for (uint i = 0; i < desc.ConstantBuffers; ++i)
{
pConstantBuffer = pReflection->GetConstantBufferByIndex(i);
uint count = 0;
D3D10_SHADER_BUFFER_DESC bufferDesc;
DX_ASSERT_MSG(pConstantBuffer->GetDesc(&bufferDesc));
if (bufferDesc.Type == D3D10_CT_TBUFFER)
continue;
count = bufferDesc.Variables;
ID3D10ShaderReflectionVariable* pConstant = NULL;
D3D10_SHADER_VARIABLE_DESC constantDesc;
for (uint j = 0; j < count; ++j)
{
pConstant = pConstantBuffer->GetVariableByIndex(j);
pConstant->GetDesc(&constantDesc);
mapVars[prefix + '.' + constantDesc.Name] = valueOffset;
valueOffset += constantDesc.Size;
}
}
//save size buffer
size = Math::multipleOfX(valueOffset, 16);
//
if (valueOffset)
{
(*pBuffer) = genBufferObject(d3dDevice, size);
}
}
//------------------------------------------------------------------------------//
void D3D9PixelShader::_loadShaderFromBuffer()
{
HRESULT hr ;
LPDIRECT3DDEVICE9 pD3D9Device = D3D9Renderer::getSingleton().__getD3D9Device();
hr = pD3D9Device->CreatePixelShader(static_cast<DWORD*>(mShaderBuffer->GetBufferPointer()), &mpPixelShader);
if(FAILED(hr))
{
String errMsg = DXGetErrorDescription(hr);
TITAN_EXCEPT_API("create pixel shader failed because of: " + errMsg);
}
}
std::string CVideoSyncD3D::GetErrorDescription(HRESULT hr)
{
WCHAR buff[1024];
DXGetErrorDescription(hr, buff, 1024);
std::wstring error(DXGetErrorString(hr));
std::wstring descr(buff);
std::wstring errMsgW = StringUtils::Format(L"%s: %s", error.c_str(), descr.c_str());
std::string errMsg;
g_charsetConverter.wToUTF8(errMsgW, errMsg);
return errMsg;
}
bool D3DEffect::EndPass()
{
if (!IsCreated())
return false;
const HRESULT hr = m_effect->EndPass();
if (FAILED(hr))
{
Log::Error(L"ID3DXEffect::EndPass failed, hr=%s, desc=%s",
DXGetErrorString(hr), DXGetErrorDescription(hr));
return false;
}
return true;
}
bool D3DEffect::SetTechnique(const std::string& techName)
{
if (!IsCreated())
return false;
const HRESULT hr = m_effect->SetTechnique(techName.c_str());
if (FAILED(hr))
{
Log::Error(L"SetTechnique with %s failed, hr=%s, desc=%s",
techName.c_str(), DXGetErrorString(hr), DXGetErrorDescription(hr));
return false;
}
return true;
}
bool D3DEffect::Begin(unsigned int &numPass)
{
if (!IsCreated() || m_techBegun)
return false;
const HRESULT hr = m_effect->Begin(&numPass, 0);
if (FAILED(hr))
{
Log::Error(L"ID3DXEffect::Begin failed, hr=%s, desc=%s", DXGetErrorString(hr), DXGetErrorDescription(hr));
return false;
}
m_techBegun = true;
return true;
}
bool D3DEffect::BeginPass(unsigned int pass)
{
if (!IsCreated())
return false;
const HRESULT hr = m_effect->BeginPass(pass);
if (FAILED(hr))
{
Log::Error(L"ID3DXEffect::BeginPass with pass=%u failed, hr=%s, desc=%s",
pass, DXGetErrorString(hr), DXGetErrorDescription(hr));
return false;
}
return true;
}
bool Graphics2D::CheckHR(HRESULT hr)
{
// just checks a HRESULT object from directX contains an error message
if (SUCCEEDED(hr))
return true;
// An error occured so find out what it was and output it to the output pane in Vis
OutputDebugString("\nDirectX Error Reported:\n");
OutputDebugString(DXGetErrorString(hr));
OutputDebugString(" : ");
OutputDebugString(DXGetErrorDescription(hr));
OutputDebugString("\n\n");
return false;
}
LPCSTR xrDebug::error2string (long code)
{
LPCSTR result = 0;
static string1024 desc_storage;
#ifdef _M_AMD64
#else
result = DXGetErrorDescription (code);
#endif
if (0==result)
{
FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM,0,code,0,desc_storage,sizeof(desc_storage)-1,0);
result = desc_storage;
}
return result ;
}
void CheckForDxError(const char *file, int line, HRESULT hr)
{
if (!FAILED(hr))
return;
// Get the direct X error and description
char desc[1024];
sprintf(desc,"(DX) %s - %s",DXGetErrorString(hr), DXGetErrorDescription(hr));
// Output the file and line number in the correct format + the above DX error
//char buf[2048];
//sprintf(buf,"%s(%d) : Error: %s\n", file, line, desc);
//OutputDebugString(buf);
// Cause the debugger to break here so we can fix the problem
//DebugBreak();
}
void SRRasterization::CopyToScreen()
{
g_pd3dDevice->BeginScene();
LPDIRECT3DSURFACE9 backBuffer;
HRESULT ret = g_pd3dDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &backBuffer);
D3DSURFACE_DESC surfacedesc;
HRESULT ret2 = backBuffer->GetDesc(&surfacedesc);
const TCHAR * message1 = DXGetErrorString(ret2);
const TCHAR * message2 = DXGetErrorDescription(ret2);
m_colorBuffer->CopyBufferToSurface(backBuffer);
g_pd3dDevice->EndScene();
// Present the backbuffer contents to the display
g_pd3dDevice->Present(NULL, NULL, NULL, NULL);
}
const char* DiD3D9ErrorCheck::GetResultString(HRESULT pr)
{
const int cnMaxLen = 512;
static char szResult[cnMaxLen];
szResult[ 0 ] = NULL;
if ( IsD3DResult( pr ) )
{
const char* pszString = DXGetErrorString( static_cast<HRESULT>(pr) );
const char* pszDesc = DXGetErrorDescription( static_cast<HRESULT>(pr) );
_snprintf( szResult, cnMaxLen, "%s, description : %s",
pszString,
pszDesc );
return szResult;
}
return NULL;
}
void CreateD3DDevice()
{
ZeroMemory( &g_D3DParams, sizeof( g_D3DParams ) );
RECT ClientRect;
GetClientRect( g_pHWND, &ClientRect );
g_D3DParams.Windowed = TRUE;
g_D3DParams.SwapEffect = D3DSWAPEFFECT_DISCARD;
g_D3DParams.BackBufferWidth = ClientRect.right;
g_D3DParams.BackBufferHeight = ClientRect.bottom;
g_D3DParams.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
g_D3DParams.BackBufferFormat = D3DFMT_X8R8G8B8;
//g_D3DParams.EnableAutoDepthStencil = TRUE;
//g_D3DParams.AutoDepthStencilFormat = D3DFMT_D24S8;
g_D3DParams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
HRESULT hr = g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, g_pHWND, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &g_D3DParams, &g_pD3DDevice );
if ( FAILED(hr) )
{
OutputDebugString( DXGetErrorDescription( hr ) );
return;
}
}
std::wstring GraphicsException::GetErrorDescription() const
{
std::array<wchar_t,512> wideDescription;
DXGetErrorDescription( hr,wideDescription.data(),wideDescription.size() );
return wideDescription.data();
}
/*------------------------------------
------ initScene() Funktion ------
Scene Initialsieren :D
------------------------------------*/
bool InitScene()
{
//Compiliere Shader
hr = D3DX11CompileFromFile(L"Effects.fx", NULL, NULL, "VS", "vs_5_0", 0, 0, 0, &VS_Buffer, &ErrorMsg, 0);
if (FAILED(hr))
{
if (ErrorMsg)
{
ShaderErrorOutput(ErrorMsg, "VertexShader");
}
MessageBox(NULL, DXGetErrorDescription(hr),
TEXT(" Vertexshader"), MB_OK);
return 0;
}
hr = D3DX11CompileFromFile(L"Effects.fx", NULL, NULL, "PS", "ps_5_0", 0, 0, 0, &PS_Buffer, &ErrorMsg, 0);
if (FAILED(hr))
{
if (ErrorMsg)
{
ShaderErrorOutput(ErrorMsg, "VertexShader");
}
MessageBox(NULL, DXGetErrorDescription(hr),
TEXT(" Vertexshader"), MB_OK);
return 0;
}
//Erstelle Shader
hr = d3d11Device->CreateVertexShader(VS_Buffer->GetBufferPointer(), VS_Buffer->GetBufferSize(), NULL, &VS);
hr = d3d11Device->CreatePixelShader(PS_Buffer->GetBufferPointer(), PS_Buffer->GetBufferSize(), NULL, &PS);
//Setze Shaders als aktuelle Pipeline Shader
d3d11DevCon->VSSetShader(VS, NULL, 0);
d3d11DevCon->PSSetShader(PS, NULL, 0);
//Font Stuff
//--------------------------------------------
hr = D3DX11CompileFromFile(L"Effects.fx", NULL, NULL, "FONT_VS", "vs_5_0", 0, 0, 0, &FONT_VS_Buffer, &ErrorMsg, 0);
if (FAILED(hr))
{
if (ErrorMsg)
{
ShaderErrorOutput(ErrorMsg, "VertexShader");
}
MessageBox(NULL, DXGetErrorDescription(hr),
TEXT(" Vertexshader"), MB_OK);
return 0;
}
hr = D3DX11CompileFromFile(L"Effects.fx", NULL, NULL, "FONT_PS", "ps_5_0", 0, 0, 0, &FONT_PS_Buffer, &ErrorMsg, 0);
if (FAILED(hr))
{
if (ErrorMsg)
{
ShaderErrorOutput(ErrorMsg, "VertexShader");
}
MessageBox(NULL, DXGetErrorDescription(hr),
TEXT(" Vertexshader"), MB_OK);
return 0;
}
//Erstelle Shader
hr = d3d11Device->CreateVertexShader(FONT_VS_Buffer->GetBufferPointer(), FONT_VS_Buffer->GetBufferSize(), NULL, &FONT_VS);
hr = d3d11Device->CreatePixelShader(FONT_PS_Buffer->GetBufferPointer(), FONT_PS_Buffer->GetBufferSize(), NULL, &FONT_PS);
//---------------------------------------
// Erstelle ein paar vertices Für einen Würfel 8 Ecken
Vertex v[] =
{
// Front Face
Vertex(-1.0f, -1.0f, -1.0f, 0.0f, 1.0f),
Vertex(-1.0f, 1.0f, -1.0f, 0.0f, 0.0f),
Vertex(1.0f, 1.0f, -1.0f, 1.0f, 0.0f),
Vertex(1.0f, -1.0f, -1.0f, 1.0f, 1.0f),
// Back Face
Vertex(-1.0f, -1.0f, 1.0f, 1.0f, 1.0f),
Vertex(1.0f, -1.0f, 1.0f, 0.0f, 1.0f),
Vertex(1.0f, 1.0f, 1.0f, 0.0f, 0.0f),
Vertex(-1.0f, 1.0f, 1.0f, 1.0f, 0.0f),
// Top Face
Vertex(-1.0f, 1.0f, -1.0f, 0.0f, 1.0f),
Vertex(-1.0f, 1.0f, 1.0f, 0.0f, 0.0f),
Vertex(1.0f, 1.0f, 1.0f, 1.0f, 0.0f),
Vertex(1.0f, 1.0f, -1.0f, 1.0f, 1.0f),
// Bottom Face
Vertex(-1.0f, -1.0f, -1.0f, 1.0f, 1.0f),
Vertex(1.0f, -1.0f, -1.0f, 0.0f, 1.0f),
Vertex(1.0f, -1.0f, 1.0f, 0.0f, 0.0f),
Vertex(-1.0f, -1.0f, 1.0f, 1.0f, 0.0f),
// Left Face
Vertex(-1.0f, -1.0f, 1.0f, 0.0f, 1.0f),
Vertex(-1.0f, 1.0f, 1.0f, 0.0f, 0.0f),
Vertex(-1.0f, 1.0f, -1.0f, 1.0f, 0.0f),
Vertex(-1.0f, -1.0f, -1.0f, 1.0f, 1.0f),
// Right Face
Vertex(1.0f, -1.0f, -1.0f, 1.0f, 0.0f),
Vertex(1.0f, 1.0f, -1.0f, 1.0f, 1.0f),
Vertex(1.0f, 1.0f, 1.0f, 0.0f, 1.0f),
Vertex(1.0f, -1.0f, 1.0f, 0.0f, 0.0f),
};
// Erstelle ein paar indices
DWORD indices[] = {
// Front Face
0, 1, 2,
0, 2, 3,
// Back Face
4, 5, 6,
4, 6, 7,
// Top Face
8, 9, 10,
8, 10, 11,
// Bottom Face
12, 13, 14,
12, 14, 15,
// Left Face
16, 17, 18,
16, 18, 19,
// Right Face
20, 22, 23,
20, 21, 22,
};
//Beschreibe den Vertex Buffer
D3D11_BUFFER_DESC vertexBufferDesc;
vertexBufferDesc.ByteWidth = sizeof(Vertex) * 24;
vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
vertexBufferDesc.CPUAccessFlags = 0;
vertexBufferDesc.MiscFlags = 0;
//Erstelle Datenstruktur IM VertexBuffer
D3D11_SUBRESOURCE_DATA vertexBufferData;
ZeroMemory(&vertexBufferData, sizeof(vertexBufferData));
vertexBufferData.pSysMem = v; // Daten die in den Buffer geschrieben werden
// Erstelle den VertexBuffer
hr = d3d11Device->CreateBuffer(&vertexBufferDesc, &vertexBufferData, &vertexBuffer);
//Font Stuff
//-----------------------------
vertexBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
vertexBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
vertexBufferDesc.ByteWidth = sizeof(Vertex) * 6 * numLetters;
hr = d3d11Device->CreateBuffer(&vertexBufferDesc, NULL, &fontVertexBuffer);
//-------------------------------
//Beschreibe den IndexBuffer
D3D11_BUFFER_DESC indexBufferDesc;
ZeroMemory(&indexBufferDesc, sizeof(indexBufferDesc));
indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
indexBufferDesc.ByteWidth = sizeof(DWORD) * 12 * 3;
indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
vertexBufferDesc.CPUAccessFlags = 0;
vertexBufferDesc.MiscFlags = 0;
// Erstelle Datenstruktur für IndexBuffer
D3D11_SUBRESOURCE_DATA indexBufferData;
ZeroMemory(&indexBufferData, sizeof(indexBufferData));
indexBufferData.pSysMem = indices; // Daten die in den Buffer geschrieben werden
//Erstelle Index Buffer
d3d11Device->CreateBuffer(&indexBufferDesc, &indexBufferData, &indexBuffer);
UINT stride = sizeof(Vertex);
UINT offset = 0;
//Binde den VertexBuffer an den Input Assembler
d3d11DevCon->IASetVertexBuffers(0, 2, &vertexBuffer, &stride, &offset);
//Binde den IndexBuffer an den Input Assambler
d3d11DevCon->IASetIndexBuffer(indexBuffer, DXGI_FORMAT_R32_UINT, 0);
//Erstelle Input Layout
hr = d3d11Device->CreateInputLayout(layout, 2, VS_Buffer->GetBufferPointer(), VS_Buffer->GetBufferSize(), &vertLayout);
// Binde das Layout an den Input Assembler
d3d11DevCon->IASetInputLayout(vertLayout);
//Lege die Input Topologie fest (points , triangles etc)
d3d11DevCon->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
//Erstelle den Viewport
D3D11_VIEWPORT viewport;
ZeroMemory(&viewport, sizeof(viewport));
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
viewport.Width = Width;
viewport.Height = Height;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
//Binde den Vieport an den Rasterizer
d3d11DevCon->RSSetViewports(1, &viewport);
//Beschreibe Rendering State
D3D11_RASTERIZER_DESC ccwdesc;
ZeroMemory(&ccwdesc, sizeof(D3D11_RASTERIZER_DESC));
ccwdesc.FillMode = D3D11_FILL_SOLID;
ccwdesc.CullMode = D3D11_CULL_BACK;
ccwdesc.FrontCounterClockwise = true;
D3D11_RASTERIZER_DESC cwdesc;
ZeroMemory(&cwdesc, sizeof(D3D11_RASTERIZER_DESC));
cwdesc.FillMode = D3D11_FILL_SOLID;
cwdesc.CullMode = D3D11_CULL_BACK;
cwdesc.FrontCounterClockwise = false;
D3D11_RASTERIZER_DESC noCulldesc;
ZeroMemory(&noCulldesc, sizeof(D3D11_RASTERIZER_DESC));
noCulldesc.FillMode = D3D11_FILL_SOLID;
noCulldesc.CullMode = D3D11_CULL_NONE;
// Erstelle Rendering State
hr = d3d11Device->CreateRasterizerState(&ccwdesc, &CCWcullMode);
hr = d3d11Device->CreateRasterizerState(&cwdesc, &CWcullMode);
hr = d3d11Device->CreateRasterizerState(&noCulldesc, &noCull);
//Beschreibe den ConstantBuffer
D3D11_BUFFER_DESC cbbd;
ZeroMemory(&cbbd, sizeof(D3D11_BUFFER_DESC));
cbbd.Usage = D3D11_USAGE_DEFAULT;
cbbd.ByteWidth = sizeof(cbPerObject);
cbbd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
cbbd.CPUAccessFlags = 0;
cbbd.MiscFlags = 0;
//Erstelle Buffer
hr = d3d11Device->CreateBuffer(&cbbd, NULL, &cbPerObjectBuffer);
// Lader Textur aus Datei
hr = D3DX11CreateShaderResourceViewFromFile(d3d11Device, L"./textures/Cage.png"
, NULL, NULL, &Texture, NULL);
// Erstelle Sampler Desciptor
D3D11_SAMPLER_DESC sampDesc;
ZeroMemory(&sampDesc, sizeof(sampDesc));
sampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
sampDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
sampDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
sampDesc.MinLOD = 0;
sampDesc.MaxLOD = D3D11_FLOAT32_MAX;
hr = d3d11Device->CreateSamplerState(&sampDesc, &TexSamplerState);
//Font stuff neeeeeeeeeeeeeeeeeeeeeed
//--------------------------------
hr = D3DX11CreateShaderResourceViewFromFile(d3d11Device, L"gameFont.dds", NULL
, NULL, &fontAtlas, NULL);
hr = d3d11Device->CreateSamplerState(&sampDesc, &fontAtlasSampler);
//--------------------------------------------------
// Erstelle Blend Descriptor
D3D11_BLEND_DESC blendDesc;
ZeroMemory(&blendDesc, sizeof(blendDesc));
D3D11_RENDER_TARGET_BLEND_DESC rtbd;
ZeroMemory(&rtbd, sizeof(rtbd));
rtbd.BlendEnable = true;
rtbd.SrcBlend = D3D11_BLEND_SRC_COLOR;
rtbd.DestBlend = D3D11_BLEND_BLEND_FACTOR;
rtbd.BlendOp = D3D11_BLEND_OP_ADD;
rtbd.SrcBlendAlpha = D3D11_BLEND_ONE;
rtbd.DestBlendAlpha = D3D11_BLEND_ZERO;
rtbd.BlendOpAlpha = D3D11_BLEND_OP_ADD;
rtbd.RenderTargetWriteMask = D3D10_COLOR_WRITE_ENABLE_ALL;
blendDesc.AlphaToCoverageEnable = false;
blendDesc.RenderTarget[0] = rtbd;
// Erstelle Blend State
d3d11Device->CreateBlendState(&blendDesc, &Transparency);
//Initialisiere die Kamera
camPosition = XMVectorSet(0.0f, 3.0f, -8.0f, 0.0f);
camTarget = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f);
camUp = XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);
// Initialisiere die ViewMatrix
camView = XMMatrixLookAtLH(camPosition, camTarget, camUp);
// Initialisiere die Projection Matrix
camProjection = XMMatrixPerspectiveFovLH(0.4f*3.14f, (float)Width / Height, 1.0f, 1000.0f);
return true;
}
/*------------------------------------
------ InitializeDirect3DApp() -------
Initialisiert Direct3d :D
------------------------------------*/
bool InitializeDirect3d11App(HINSTANCE hInstance)
{
//Beschreibe den BackBuffer
DXGI_MODE_DESC bufferDesc;
ZeroMemory(&bufferDesc, sizeof(DXGI_MODE_DESC));
bufferDesc.Width = Width;
bufferDesc.Height = Height;
bufferDesc.RefreshRate.Numerator = 60;
bufferDesc.RefreshRate.Denominator = 1;
bufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; //32Bit float
bufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
bufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
//Beschreibe die SwapChain
DXGI_SWAP_CHAIN_DESC swapChainDesc;
ZeroMemory(&swapChainDesc, sizeof(DXGI_SWAP_CHAIN_DESC));
swapChainDesc.BufferDesc = bufferDesc;
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.BufferCount = 1;
swapChainDesc.OutputWindow = hwnd;
swapChainDesc.Windowed = TRUE;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
//Erstelle Device und SwapChain
hr = D3D11CreateDeviceAndSwapChain(NULL,
D3D_DRIVER_TYPE_HARDWARE,
NULL,
NULL,
NULL,
NULL,
D3D11_SDK_VERSION,
&swapChainDesc,
&SwapChain,
&d3d11Device,
NULL,
&d3d11DevCon);
if (FAILED(hr))
{
MessageBox(NULL, DXGetErrorDescription(hr),
TEXT(" D3D11CreateDeviceAndSwapChain"), MB_OK);
return 0;
}
//Erstelle den BackBuffer ( Das ist eine einfache 2D Textur)
ID3D11Texture2D * BackBuffer;
hr = SwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&BackBuffer);
if (FAILED(hr))
{
MessageBox(NULL, DXGetErrorDescription(hr),
TEXT("SwapChain->GetBuffer"), MB_OK);
return 0;
}
//Erstelle das RenderTarget
hr = d3d11Device->CreateRenderTargetView(BackBuffer, NULL, &renderTargetView);
if (FAILED(hr))
{
MessageBox(NULL, DXGetErrorDescription(hr),
TEXT("d3d11Device->CreateRenderTargetView"), MB_OK);
return 0;
}
BackBuffer->Release();
//Beschreibe den DepthStencilBuffer
D3D11_TEXTURE2D_DESC depthStencilDesc;
depthStencilDesc.Width = Width;
depthStencilDesc.Height = Height;
depthStencilDesc.MipLevels = 1;
depthStencilDesc.ArraySize = 1;
depthStencilDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilDesc.SampleDesc.Count = 1;
depthStencilDesc.SampleDesc.Quality = 0;
depthStencilDesc.Usage = D3D11_USAGE_DEFAULT;
depthStencilDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthStencilDesc.CPUAccessFlags = 0;
depthStencilDesc.MiscFlags = 0;
//Erstelle den DepthStencilBuffer
d3d11Device->CreateTexture2D(&depthStencilDesc, NULL, &depthStencilBuffer);
d3d11Device->CreateDepthStencilView(depthStencilBuffer, NULL, &depthStencilView);
// Binde die RenderTargets an den Output Merger
d3d11DevCon->OMSetRenderTargets(1, &renderTargetView, NULL);
//Binde den DepthStencilView an den Output Merger
d3d11DevCon->OMSetRenderTargets(1, &renderTargetView, depthStencilView);
return true;
}
bool Renderer::initialize(int width, int height, HWND hwnd, float zNear, float zFar, int numToDraw, char* msg)
{
numDrawables = numToDraw;
useTwoSidedStencils = false;
drawables = new Drawable*[numToDraw];
dynamicDrawables = new std::vector<Drawable*>();
dynamicDrawables->clear();
dynamicDrawables->reserve(100);
hud = new HUD(width, height);
menuHandler = new MenuHandler(width, height);
d3dObject = Direct3DCreate9(D3D_SDK_VERSION);
D3DCAPS9 caps;
d3dObject->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps);
if (!(caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT))
{
LPCTSTR descr = "This program requires a video card that supports hardware vertex processing!";
strcpy_s((char*) msg, 128, descr);
return false;
}
useTwoSidedStencils = ((caps.StencilCaps & D3DSTENCILCAPS_TWOSIDED) != 0);
D3DPRESENT_PARAMETERS params;
ZeroMemory(¶ms,sizeof(D3DPRESENT_PARAMETERS));
params.Windowed = TRUE;
params.BackBufferCount= 1;
params.BackBufferFormat = D3DFMT_X8R8G8B8;
params.BackBufferWidth = width;
params.BackBufferHeight = height;
params.SwapEffect = D3DSWAPEFFECT_DISCARD;
params.hDeviceWindow = hwnd;
params.EnableAutoDepthStencil = TRUE;
params.Flags = D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL;
// VSYNC. Change to INTERVAL_IMMEDIATE to turn off VSYNC, change to INTERVAL_ONE to turn on VSYNC
params.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
// Now need to set up the depth stencil format.
D3DFORMAT formats[] = { D3DFMT_D24S8, D3DFMT_D24X4S4, D3DFMT_D24FS8 };
D3DFORMAT format = (D3DFORMAT) 0;
for (int i = 0; i < 3; i++)
{
HRESULT result = d3dObject->CheckDeviceFormat(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, D3DUSAGE_DEPTHSTENCIL,
D3DRTYPE_SURFACE, formats[i]);
if (result == D3D_OK)
{
result = d3dObject->CheckDepthStencilMatch(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, D3DFMT_X8R8G8B8, formats[i]);
if (result == D3D_OK)
{
format = formats[i];
break;
}
}
}
if (format == (D3DFORMAT) 0)
{
LPCTSTR descr = "Couldn't find a suitable depth format!";
strcpy_s((char*) msg, 128, descr);
return false;
}
params.AutoDepthStencilFormat = format;
HRESULT result = d3dObject->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
D3DCREATE_HARDWARE_VERTEXPROCESSING, ¶ms, &device);
if (FAILED(result))
{
LPCTSTR descr = DXGetErrorDescription(result);
strcpy_s((char*) msg, 128, descr);
return false;
}
device->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
device->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESS);
D3DVIEWPORT9 viewport;
viewport.Width = width;
viewport.Height = height;
viewport.MinZ = 0.0f;
viewport.MaxZ = 1.0f;
viewport.X = 0;
viewport.Y = 0;
device->SetViewport(&viewport);
float fieldOfView, screenAspect;
// Setup the projection matrix.
fieldOfView = (float)D3DX_PI / 2.5f;
screenAspect = (float)width / (float)height;
// Create the projection matrix for 3D rendering.
D3DXMatrixPerspectiveFovLH(&projectionMatrix, fieldOfView, screenAspect, zNear, zFar);
D3DXMatrixIdentity(&worldMatrix);
camera = new Camera;
device->SetRenderState(D3DRS_LIGHTING, TRUE);
device->SetRenderState(D3DRS_AMBIENT, D3DCOLOR_XRGB(100, 100, 100));
device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_MIRROR);
device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_MIRROR);
D3DLIGHT9 light; // create the light struct
D3DMATERIAL9 material; // create the material struct
ZeroMemory(&light, sizeof(light)); // clear out the light struct for use
light.Type = D3DLIGHT_DIRECTIONAL; // make the light type 'directional light'
light.Diffuse = D3DXCOLOR(0.6f, 0.6f, 0.7f, 1.0f); // set the light's color
light.Ambient = D3DXCOLOR(0.1f, 0.1f, 0.1f, 1.0f);
D3DXVec3Normalize(&lightDir, &lightDir);
light.Direction = lightDir;
device->SetLight(0, &light); // send the light struct properties to light #0
device->LightEnable(0, TRUE); // turn on light #0
ZeroMemory(&material, sizeof(D3DMATERIAL9));
material.Diffuse = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
material.Ambient = D3DXCOLOR(0.7f, 0.7f, 0.7f, 1.0f);
device->SetMaterial(&material); // set the globably-used material to &material
// Set up font stuff
D3DXCreateFont(device, 0, 10, FW_BOLD, 1, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DRAFT_QUALITY,
DEFAULT_PITCH | FF_DONTCARE, "Terminal", &font);
device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTOP_SELECTARG1);
device->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE); // Just to be safe (ignored)
device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
// Stuff for particle effects
device->SetRenderState(D3DRS_POINTSPRITEENABLE, TRUE);
device->SetRenderState(D3DRS_POINTSCALEENABLE, TRUE);
device->SetRenderState(D3DRS_POINTSCALE_A, FtoDw(0.0f));
device->SetRenderState(D3DRS_POINTSCALE_B, FtoDw(0.0f));
device->SetRenderState(D3DRS_POINTSCALE_C, FtoDw(1.0f));
device->SetRenderState(D3DRS_POINTSIZE_MIN, FtoDw(0.1f));
device->SetRenderState(D3DRS_POINTSIZE_MAX, FtoDw(1280.0f));
// Set fog
float startFog = 1.0f;
float endFog = 500.0f;
device->SetRenderState(D3DRS_FOGCOLOR, D3DCOLOR_ARGB(200,120,120,140));
device->SetRenderState(D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
device->SetRenderState(D3DRS_FOGSTART, *(DWORD *)(&startFog));
device->SetRenderState(D3DRS_FOGEND, *(DWORD *)(&endFog));
// Set up HUD
hud->initialize(device);
// Set up menu handler
menuHandler->initialize(device);
// Set up Skybox
skybox = new Skybox(device);
ShadowPoint* points;
// Set up shadow texture
device->CreateVertexBuffer(sizeof(ShadowPoint) * 4, D3DUSAGE_WRITEONLY, D3DFVF_XYZRHW | D3DFVF_DIFFUSE,
D3DPOOL_MANAGED, &shadowQuadVertexBuffer, NULL);
shadowQuadVertexBuffer->Lock(0, sizeof(ShadowPoint) * 4, (void**) &points, NULL);
points[0].position = D3DXVECTOR4(0, (FLOAT) height, 0, 1);
points[1].position = D3DXVECTOR4(0, 0, 0, 1);
points[2].position = D3DXVECTOR4((FLOAT) width, (FLOAT) height, 0, 1);
points[3].position = D3DXVECTOR4((FLOAT) width, 0, 0, 1);
points[0].color = D3DCOLOR_ARGB(180,0,0,0);
points[1].color = D3DCOLOR_ARGB(180,0,0,0);
points[2].color = D3DCOLOR_ARGB(180,0,0,0);
points[3].color = D3DCOLOR_ARGB(180,0,0,0);
shadowQuadVertexBuffer->Unlock();
smokeSystem = new SmokeSystem();
laserSystem = new LaserSystem();
return true;
}
bool IndexBuffer::Create(D3D9Device& device, const void* src, size_t srcSize)
{
if (!src || srcSize <= 0)
return false;
if (IsCreated())
return false;
if (!device.CreateIndexBuffer(srcSize, &m_indexBuff))
return false;
void* pIndices = nullptr;
const HRESULT hr = m_indexBuff->Lock(0, srcSize, (void **)&pIndices, 0);
if (FAILED(hr))
{
Log::Error(L"LPDIRECT3DINDEXBUFFER9::lock failed, hr=%s, desc=%s", DXGetErrorString(hr), DXGetErrorDescription(hr));
Destroy();
return false;
}
memcpy_s(pIndices, srcSize, src, srcSize);
m_indexBuff->Unlock();
m_numIndice = srcSize / sizeof(short);
SK_ENSURE(IsCreated());
return true;
}
bool D3DEffect::Parameter::SetValue(const Vector4& v)
{
SK_REQUIRE(m_d3dEffect && m_handle);
if (!m_d3dEffect->IsCreated())
return false;
D3DXVECTOR4 d3dv;
D3DMapping::ToD3DXVector4(v, d3dv);
const HRESULT hr = m_d3dEffect->m_effect->SetVector(m_handle, &d3dv);
if (FAILED(hr))
{
Log::Error(L"ID3DXEffect::SetVector failed, hr=%s, desc=%s", DXGetErrorString(hr), DXGetErrorDescription(hr));
return false;
}
return true;
}
bool CDx9FragmentProgram::bind(void)
{
if(!m_isLoad)
{
LPD3DXBUFFER errors;
LPD3DXBUFFER pBuffer;
DWORD dwShaderFlags = D3DXSHADER_PACKMATRIX_ROWMAJOR | D3DXSHADER_PREFER_FLOW_CONTROL;
#if defined( DEBUG ) || defined( _DEBUG )
dwShaderFlags |= D3DXSHADER_DEBUG;
#endif
HRESULT hr = D3DXCompileShader(
m_cCode.c_str(),
static_cast<uint>(m_cCode.size()),
NULL,
DX9_ShaderInclude::GetInst(),
m_sMain.c_str(),
"ps_2_0",
dwShaderFlags,
&pBuffer,
&errors,
&m_pConstTable);
if (FAILED(hr))
{
hr = D3DXCompileShader(
m_cCode.c_str(),
static_cast<uint>(m_cCode.size()),
NULL,
DX9_ShaderInclude::GetInst(),
m_sMain.c_str(),
"ps_3_0",
dwShaderFlags,
&pBuffer,
&errors,
&m_pConstTable);
if (FAILED(hr))
{
string message = "D3D9 Pixel Shader创建不成功 Errors:\n";
message.append(static_cast<const char*>(errors->GetBufferPointer()));
errors->Release();
OutputDebugString(message.c_str());
LogErr(GraphicErr::GetErrTypeStr(ShaderInit_Err),message);
return false;
}
}
SafeRelease(errors);
hr = m_pD3DDevice->CreatePixelShader((DWORD*)pBuffer->GetBufferPointer(),&m_pPixelShader);
SafeRelease(pBuffer);
if ( SUCCEEDED(hr))
{
m_Params.Create(m_pConstTable);
m_isLoad = true;
m_isNeedUpdateParameters = true;
}
else
{
stringstream ss;
ss << "CreatePixelShader失败: " << DXGetErrorDescription(hr);
LogErr(GraphicErr::GetErrTypeStr(ShaderInit_Err), ss.str());
return false;
}
}
if(!m_isActive)
{
m_isActive = true;
return SUCCEEDED(m_pD3DDevice->SetPixelShader(m_pPixelShader));
}
return true;
}
bool U2D3DXEffectShader::SetTechnique(const char* szTechnique)
{
U2ASSERT(szTechnique);
U2ASSERT(m_pD3DEffect);
D3DXHANDLE hTechnique = m_pD3DEffect->GetTechniqueByName(szTechnique);
if(0 == hTechnique)
{
FDebug("nD3D9Shader::SetTechnique(%s): technique not found in shader file %s!\n",
szTechnique, m_szFilename.Str());
return false;
}
m_bNeedSoftwareVertexProcessing = false;
HRESULT hr;
if(m_pRenderer->GetSWVertexCapable())
{
D3DXHANDLE hPass = m_pD3DEffect->GetPass(hTechnique, 0);
U2ASSERT(0 != hPass);
D3DXPASS_DESC passDesc = { 0 };
hr = m_pD3DEffect->GetPassDesc(hPass, &passDesc);
U2ASSERT(SUCCEEDED(hr));
if(passDesc.pVertexShaderFunction)
{
m_bNeedSoftwareVertexProcessing = true;
}
}
hr = m_pD3DEffect->SetTechnique(hTechnique);
if(FAILED(hr))
{
FDebug("nD3D9Shader::SetTechnique(%s) on shader %s failed! : Error Desc : %s\n", szTechnique, m_szName.Str(), DXGetErrorDescription(hr));
return false;
}
return true;
}
ETOOLS_API const char* WINAPI DX_GetErrorDescription9(HRESULT hr)
{
return DXGetErrorDescription(hr);
}
bool D3DEffect::Parameter::SetValue(const Texture& texture)
{
SK_REQUIRE(m_d3dEffect && m_handle);
if (!m_d3dEffect->IsCreated())
return false;
const HRESULT hr = m_d3dEffect->m_effect->SetTexture(m_handle, texture.GetD3D9Texture());
if (FAILED(hr))
{
Log::Error(L"ID3DXEffect::SetTexture failed, hr=%s, desc=%s", DXGetErrorString(hr), DXGetErrorDescription(hr));
return false;
}
return true;
}
