//========================================================================
// Initialize hardware for rendering. Member of AbstractRender
//========================================================================
HRESULT DX10Render::initDevice()
{
UINT createDeviceFlags = 0;
#ifdef _DEBUG
createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG;
#endif
HRESULT hr = D3D10CreateDevice(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, createDeviceFlags, D3D10_SDK_VERSION, &this->device);
if (FAILED(hr)) return hr;
DXGI_SWAP_CHAIN_DESC sd;
ZeroMemory(&sd, sizeof(sd));
sd.BufferCount = 1;
sd.BufferDesc.Width = this->resolution.width;
sd.BufferDesc.Height = this->resolution.height;
sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.BufferDesc.RefreshRate.Numerator = 60;
sd.BufferDesc.RefreshRate.Denominator = 1;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.OutputWindow = this->hWindow;
sd.SampleDesc.Count = 4;
sd.SampleDesc.Quality = 4;
sd.Windowed = !this->fullscreen;
IDXGIFactory *factory = getDeviceFactory(device);
if (factory == NULL) return E_FAIL;
hr = factory->CreateSwapChain(device, &sd, &swapChain);
if (FAILED(hr)) return hr;
factory->Release();
return S_OK;
}
//--------------------------------------------------------------------------------------
// Entry point to the program. Initializes everything and goes into a message processing
// loop. Idle time is used to render the scene.
//--------------------------------------------------------------------------------------
int _cdecl main( int NumArgs, char** ppCmdLine )
{
// Enable run-time memory check for debug builds.
#if defined(DEBUG) | defined(_DEBUG)
_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
#endif
// This may fail if Direct3D 10 isn't installed
WCHAR wszPath[MAX_PATH+1] = {0};
if( !::GetSystemDirectory( wszPath, MAX_PATH + 1 ) )
return false;
wcscat_s( wszPath, MAX_PATH, L"\\d3d10.dll" );
HMODULE hMod = LoadLibrary( wszPath );
if( NULL == hMod )
{
PrintError( "DirectX 10 is necessary to run GPUSpectrogram.\n" );
return 1;
}
FreeLibrary( hMod );
// parse the command line
if( !ParseCommandLine( ppCmdLine, NumArgs ) )
return 1;
// create a device
HRESULT hr = S_OK;
ID3D10Device* pDevice = NULL;
DWORD dwCreateFlags = 0;
#if defined(DEBUG) || defined(_DEBUG)
dwCreateFlags |= D3D10_CREATE_DEVICE_DEBUG;
#endif
hr = D3D10CreateDevice( NULL, D3D10_DRIVER_TYPE_HARDWARE, ( HMODULE )0, dwCreateFlags,
D3D10_SDK_VERSION, &pDevice );
if( FAILED( hr ) )
{
hr = D3D10CreateDevice( NULL, D3D10_DRIVER_TYPE_REFERENCE, ( HMODULE )0, dwCreateFlags,
D3D10_SDK_VERSION, &pDevice );
if( FAILED( hr ) )
{
PrintError( "A suitable D3D10 device could not be created.\n" );
return 1;
}
}
if( FAILED( InitResources( pDevice ) ) )
{
PrintError( "GPUSpectrogram encountered an error creating resources.\n" );
return 2;
}
CreateSpectrogram( pDevice );
if( FAILED( SaveSpectogramToFile( pDevice, g_strBitmapName, g_pSourceTexture ) ) )
PrintError( "GPUSpectrogram encountered an error saving the spectrogram image file.\n" );
DestroyResources();
SAFE_RELEASE( pDevice );
return 0;
}
static void test_create_device(void)
{
ID3D10Device *device;
unsigned int i;
HRESULT hr;
if (FAILED(hr = D3D10CreateDevice(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, 0, D3D10_SDK_VERSION, &device)))
{
skip("Failed to create HAL device.\n");
return;
}
ID3D10Device_Release(device);
for (i = 0; i < 100; ++i)
{
if (i == D3D10_SDK_VERSION)
continue;
hr = D3D10CreateDevice(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, 0, i, &device);
ok(hr == E_INVALIDARG, "Got unexpected hr %#x for SDK version %#x.\n", hr, i);
}
}
static IDXGIDevice *create_device(void)
{
IDXGIDevice *dxgi_device;
ID3D10Device *device;
HRESULT hr;
if (SUCCEEDED(D3D10CreateDevice(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, 0, D3D10_SDK_VERSION, &device)))
goto success;
if (SUCCEEDED(D3D10CreateDevice(NULL, D3D10_DRIVER_TYPE_WARP, NULL, 0, D3D10_SDK_VERSION, &device)))
goto success;
if (SUCCEEDED(D3D10CreateDevice(NULL, D3D10_DRIVER_TYPE_REFERENCE, NULL, 0, D3D10_SDK_VERSION, &device)))
goto success;
return NULL;
success:
hr = ID3D10Device_QueryInterface(device, &IID_IDXGIDevice, (void **)&dxgi_device);
ok(SUCCEEDED(hr), "Created device does not implement IDXGIDevice\n");
ID3D10Device_Release(device);
return dxgi_device;
}
void D3DApplication::InitDirect3D()
{
// Create the device.
UINT createDeviceFlags = 0;
#if defined(DEBUG) || defined(_DEBUG)
createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG;
#endif
HR(D3D10CreateDevice(0, m_DriverType, 0, createDeviceFlags, D3D10_SDK_VERSION, &m_pDevice));
IDXGIFactory* pFactory;
HR(CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)(&pFactory)));
// Fill out a DXGI_SWAP_CHAIN_DESC to describe our swap chain.
DXGI_SWAP_CHAIN_DESC swapChainDescription;
swapChainDescription.BufferDesc.Width = m_ClientWidth;
swapChainDescription.BufferDesc.Height = m_ClientHeight;
swapChainDescription.BufferDesc.RefreshRate.Numerator = 60;
swapChainDescription.BufferDesc.RefreshRate.Denominator = 1;
swapChainDescription.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swapChainDescription.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDescription.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
// No multisampling.
swapChainDescription.SampleDesc.Count = 1;
swapChainDescription.SampleDesc.Quality = 0;
swapChainDescription.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDescription.BufferCount = 1;
swapChainDescription.OutputWindow = m_hMainWindow;
swapChainDescription.Windowed = true;
swapChainDescription.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
swapChainDescription.Flags = 0;
HR(pFactory->CreateSwapChain(m_pDevice, &swapChainDescription, &m_pSwapChain));
HR(pFactory->MakeWindowAssociation(m_hMainWindow, DXGI_MWA_NO_WINDOW_CHANGES));
// The remaining steps that need to be carried out for d3d creation
// also need to be executed every time the window is resized. So
// just call the OnResize method here to avoid code duplication.
OnResize();
}
HRESULT WINAPI D3D10CreateDeviceAndSwapChain(IDXGIAdapter *adapter, D3D10_DRIVER_TYPE driver_type,
HMODULE swrast, UINT flags, UINT sdk_version, DXGI_SWAP_CHAIN_DESC *swapchain_desc,
IDXGISwapChain **swapchain, ID3D10Device **device)
{
IDXGIDevice *dxgi_device;
IDXGIFactory *factory;
HRESULT hr;
TRACE("adapter %p, driver_type %s, swrast %p, flags %#x, sdk_version %d,\n"
"\tswapchain_desc %p, swapchain %p, device %p\n",
adapter, debug_d3d10_driver_type(driver_type), swrast, flags, sdk_version,
swapchain_desc, swapchain, device);
hr = D3D10CreateDevice(adapter, driver_type, swrast, flags, sdk_version, device);
if (FAILED(hr))
{
WARN("Failed to create a device, returning %#x\n", hr);
*device = NULL;
return hr;
}
TRACE("Created ID3D10Device %p\n", *device);
hr = ID3D10Device_QueryInterface(*device, &IID_IDXGIDevice, (void **)&dxgi_device);
if (FAILED(hr))
{
ERR("Failed to get a dxgi device from the d3d10 device, returning %#x\n", hr);
ID3D10Device_Release(*device);
*device = NULL;
return hr;
}
hr = IDXGIDevice_GetAdapter(dxgi_device, &adapter);
IDXGIDevice_Release(dxgi_device);
if (FAILED(hr))
{
ERR("Failed to get the device adapter, returning %#x\n", hr);
ID3D10Device_Release(*device);
*device = NULL;
return hr;
}
hr = IDXGIAdapter_GetParent(adapter, &IID_IDXGIFactory, (void **)&factory);
IDXGIAdapter_Release(adapter);
if (FAILED(hr))
{
ERR("Failed to get the adapter factory, returning %#x\n", hr);
ID3D10Device_Release(*device);
*device = NULL;
return hr;
}
hr = IDXGIFactory_CreateSwapChain(factory, (IUnknown *)*device, swapchain_desc, swapchain);
IDXGIFactory_Release(factory);
if (FAILED(hr))
{
ID3D10Device_Release(*device);
*device = NULL;
WARN("Failed to create a swapchain, returning %#x\n", hr);
return hr;
}
TRACE("Created IDXGISwapChain %p\n", *swapchain);
return S_OK;
}
RenderDevice::RenderDevice(const RendererParams& p, HWND window)
{
RECT rc;
GetClientRect(window, &rc);
UINT width = rc.right - rc.left;
UINT height = rc.bottom - rc.top;
WindowWidth = width;
WindowHeight = height;
Window = window;
Params = p;
memset(UniformBuffers, 0, sizeof(UniformBuffers));
memset(CommonUniforms, 0, sizeof(CommonUniforms));
QuadVertexBuffer = NULL;
HRESULT hr = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)(&DXGIFactory.GetRawRef()));
if (FAILED(hr))
return;
// Find the adapter & output (monitor) to use for fullscreen, based on the reported name of the HMD's monitor.
if (Params.MonitorName.GetLength() > 0)
{
for(UINT AdapterIndex = 0; ; AdapterIndex++)
{
HRESULT hr = DXGIFactory->EnumAdapters(AdapterIndex, &Adapter.GetRawRef());
if (hr == DXGI_ERROR_NOT_FOUND)
break;
DXGI_ADAPTER_DESC Desc;
Adapter->GetDesc(&Desc);
UpdateMonitorOutputs();
if (FullscreenOutput)
break;
}
if (!FullscreenOutput)
Adapter = NULL;
}
if (!Adapter)
{
DXGIFactory->EnumAdapters(0, &Adapter.GetRawRef());
}
int flags = 0;
hr = D3D10CreateDevice(Adapter, D3D10_DRIVER_TYPE_HARDWARE, NULL, flags, D3D1x_(SDK_VERSION),
&Device.GetRawRef());
Context = Device;
Context->AddRef();
if (FAILED(hr))
return;
if (!RecreateSwapChain())
return;
if (Params.Fullscreen)
SwapChain->SetFullscreenState(1, FullscreenOutput);
CurRenderTarget = NULL;
for(int i = 0; i < Shader_Count; i++)
{
UniformBuffers[i] = CreateBuffer();
MaxTextureSet[i] = 0;
}
ID3D10Blob* vsData = CompileShader("vs_4_0", DirectVertexShaderSrc);
VertexShaders[VShader_MV] = *new VertexShader(this, vsData);
for(int i = 1; i < VShader_Count; i++)
{
VertexShaders[i] = *new VertexShader(this, CompileShader("vs_4_0", VShaderSrcs[i]));
}
for(int i = 0; i < FShader_Count; i++)
{
PixelShaders[i] = *new PixelShader(this, CompileShader("ps_4_0", FShaderSrcs[i]));
}
SPInt bufferSize = vsData->GetBufferSize();
const void* buffer = vsData->GetBufferPointer();
ID3D1xInputLayout** objRef = &ModelVertexIL.GetRawRef();
HRESULT validate = Device->CreateInputLayout(ModelVertexDesc, sizeof(ModelVertexDesc)/sizeof(D3D1x_(INPUT_ELEMENT_DESC)),
buffer, bufferSize, objRef);
OVR_UNUSED(validate);
Ptr<ShaderSet> gouraudShaders = *new ShaderSet();
gouraudShaders->SetShader(VertexShaders[VShader_MVP]);
gouraudShaders->SetShader(PixelShaders[FShader_Gouraud]);
DefaultFill = *new ShaderFill(gouraudShaders);
D3D1x_(BLEND_DESC) bm;
memset(&bm, 0, sizeof(bm));
bm.BlendEnable[0] = true;
bm.BlendOp = bm.BlendOpAlpha = D3D1x_(BLEND_OP_ADD);
bm.SrcBlend = bm.SrcBlendAlpha = D3D1x_(BLEND_SRC_ALPHA);
bm.DestBlend = bm.DestBlendAlpha = D3D1x_(BLEND_INV_SRC_ALPHA);
bm.RenderTargetWriteMask[0] = D3D1x_(COLOR_WRITE_ENABLE_ALL);
Device->CreateBlendState(&bm, &BlendState.GetRawRef());
D3D1x_(RASTERIZER_DESC) rs;
memset(&rs, 0, sizeof(rs));
rs.AntialiasedLineEnable = true;
rs.CullMode = D3D1x_(CULL_BACK);
rs.DepthClipEnable = true;
rs.FillMode = D3D1x_(FILL_SOLID);
Device->CreateRasterizerState(&rs, &Rasterizer.GetRawRef());
QuadVertexBuffer = CreateBuffer();
const RenderTiny::Vertex QuadVertices[] =
{ Vertex(Vector3f(0, 1, 0)), Vertex(Vector3f(1, 1, 0)),
Vertex(Vector3f(0, 0, 0)), Vertex(Vector3f(1, 0, 0)) };
QuadVertexBuffer->Data(Buffer_Vertex, QuadVertices, sizeof(QuadVertices));
SetDepthMode(0, 0);
}
int
main(int argc, char *argv[])
{
HRESULT hr;
D3D10_USAGE Usage = D3D10_USAGE_DYNAMIC;
for (int i = 1; i < argc; ++i) {
const char *arg = argv[i];
if (strcmp(arg, "-dynamic") == 0) {
Usage = D3D10_USAGE_DYNAMIC;
} else if (strcmp(arg, "-staging") == 0) {
Usage = D3D10_USAGE_STAGING;
} else {
fprintf(stderr, "error: unknown arg %s\n", arg);
exit(1);
}
}
com_ptr<IDXGIFactory> pFactory;
hr = CreateDXGIFactory(IID_IDXGIFactory, (void**)&pFactory);
if (FAILED(hr)) {
return 1;
}
com_ptr<IDXGIAdapter> pAdapter;
hr = pFactory->EnumAdapters(0, &pAdapter);
if (FAILED(hr)) {
return 1;
}
UINT Flags = 0;
if (LoadLibraryA("d3d10sdklayers")) {
Flags |= D3D10_CREATE_DEVICE_DEBUG;
}
com_ptr<ID3D10Device> pDevice;
hr = D3D10CreateDevice(pAdapter,
D3D10_DRIVER_TYPE_HARDWARE,
NULL,
Flags,
D3D10_SDK_VERSION,
&pDevice);
if (FAILED(hr)) {
return 1;
}
UINT NumBuffers = 4;
UINT NumSegments = 8;
UINT SegmentSize = 512;
D3D10_BUFFER_DESC BufferDesc;
ZeroMemory(&BufferDesc, sizeof BufferDesc);
BufferDesc.ByteWidth = NumSegments * SegmentSize;
BufferDesc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
BufferDesc.MiscFlags = 0;
BufferDesc.Usage = Usage;
if (Usage == D3D10_USAGE_STAGING) {
BufferDesc.BindFlags = 0;
} else {
BufferDesc.BindFlags = D3D10_BIND_VERTEX_BUFFER;
}
D3D10_MAP MapType = D3D10_MAP_WRITE;
for (UINT i = 0; i < NumBuffers; ++i) {
com_ptr<ID3D10Buffer> pVertexBuffer;
hr = pDevice->CreateBuffer(&BufferDesc, NULL, &pVertexBuffer);
if (FAILED(hr)) {
return 1;
}
if (Usage == D3D10_USAGE_DYNAMIC) {
MapType = D3D10_MAP_WRITE_DISCARD;
}
for (UINT j = 0; j < NumSegments; ++j) {
BYTE *pMap = NULL;
hr = pVertexBuffer->Map(MapType, 0, (void **)&pMap);
if (FAILED(hr)) {
return 1;
}
int c = (j % 255) + 1;
memset(pMap + j*SegmentSize, c, SegmentSize);
pVertexBuffer->Unmap();
if (Usage == D3D10_USAGE_DYNAMIC) {
MapType = D3D10_MAP_WRITE_NO_OVERWRITE;
}
}
pDevice->Flush();
D3D10_QUERY_DESC QueryDesc;
QueryDesc.Query = D3D10_QUERY_EVENT;
QueryDesc.MiscFlags = 0;
com_ptr<ID3D10Query> pQuery;
hr = pDevice->CreateQuery(&QueryDesc, &pQuery);
if (FAILED(hr)) {
return 1;
}
pQuery->End();
do {
hr = pQuery->GetData(NULL, 0, 0);
} while (hr == S_FALSE);
if (FAILED(hr)) {
return 1;
}
}
return 0;
}
void CD3D10Renderer::Init(HWND hWnd, bool bWindowed, int width, int height)
{
// D3D10 Device
#ifdef _DEBUG
HR(D3D10CreateDevice(0, D3D10_DRIVER_TYPE_HARDWARE, NULL, D3D10_CREATE_DEVICE_DEBUG, D3D10_SDK_VERSION, &m_pD3DDevice));
#else
HR(D3D10CreateDevice(0, D3D10_DRIVER_TYPE_HARDWARE, NULL, 0, D3D10_SDK_VERSION, &m_pD3DDevice));
#endif
// Used to create a swap chain separately
CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)(&m_pFactory) );
//CheckMultiSampleSupport();
// DXGI swap chain description (the "new" presentation params!)
ZeroMemory(&m_swapDescription, sizeof(m_swapDescription));
m_swapDescription.BufferCount = 1;
m_swapDescription.BufferDesc.Width = width;
m_swapDescription.BufferDesc.Height = height;
m_swapDescription.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
m_swapDescription.BufferDesc.RefreshRate.Numerator = 60;
m_swapDescription.BufferDesc.RefreshRate.Denominator = 1;
m_swapDescription.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
m_swapDescription.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
m_swapDescription.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
m_swapDescription.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
m_swapDescription.OutputWindow = hWnd;
m_swapDescription.SampleDesc.Count = m_MSAA.Count;
m_swapDescription.SampleDesc.Quality = m_MSAA.Quality;
m_swapDescription.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
m_swapDescription.Windowed = bWindowed;
HR(m_pFactory->CreateSwapChain(m_pD3DDevice, &m_swapDescription, &m_pD3DSwapChain));
// Create D3D10 Device and Swap Chain
//HR(D3D10CreateDeviceAndSwapChain(
// 0, // Default device adapter
// D3D10_DRIVER_TYPE_HARDWARE, // Device driver type
// NULL, // No need for software rasterizer
// D3D10_CREATE_DEVICE_DEBUG, // Debugging flags
// D3D10_SDK_VERSION, // SDK Version
// &m_swapDescription, // Swap chain description
// &m_pD3DSwapChain, // Swap chain
// &m_pD3DDevice)); // Returned D3D10 Device
//if(!CheckMultiSampleSupport())
//{
// m_MSAA.Count = 1;
// m_MSAA.Quality = 0;
//}
// Create Render Target View
HR(m_pD3DSwapChain->GetBuffer(0, __uuidof(ID3D10Texture2D), reinterpret_cast<void**>(&m_pD3DBackbuffer)));
HR(m_pD3DDevice->CreateRenderTargetView(m_pD3DBackbuffer, 0, &m_pD3DRenderTargetView));
m_pD3DBackbuffer->Release();
// Create the Depth/Stencil Buffer and View
ZeroMemory(&m_D3DDepthStencilDesc, sizeof(m_D3DDepthStencilDesc));
m_D3DDepthStencilDesc.Width = width;
m_D3DDepthStencilDesc.Height = height;
m_D3DDepthStencilDesc.MipLevels = 1;
m_D3DDepthStencilDesc.ArraySize = 1;
m_D3DDepthStencilDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
m_D3DDepthStencilDesc.SampleDesc.Count = m_MSAA.Count;
m_D3DDepthStencilDesc.SampleDesc.Quality = m_MSAA.Quality;
m_D3DDepthStencilDesc.Usage = D3D10_USAGE_DEFAULT;
m_D3DDepthStencilDesc.BindFlags = D3D10_BIND_DEPTH_STENCIL;
m_D3DDepthStencilDesc.CPUAccessFlags = 0;
m_D3DDepthStencilDesc.MiscFlags = 0;
// Bind Depth/Stencil buffer resource to pipeline
HR(m_pD3DDevice->CreateTexture2D(&m_D3DDepthStencilDesc, 0, &m_pDepthStencilBuffer));
HR(m_pD3DDevice->CreateDepthStencilView(m_pDepthStencilBuffer, 0, &m_pDepthStencilView));
// Bind views to output merger stage
m_pD3DDevice->OMSetRenderTargets(1, &m_pD3DRenderTargetView, m_pDepthStencilView);
// Set up view port
m_D3DViewport.TopLeftX = 0;
m_D3DViewport.TopLeftY = 0;
m_D3DViewport.Width = width;
m_D3DViewport.Height = height;
m_D3DViewport.MinDepth = 0.0f;
m_D3DViewport.MaxDepth = 1.0f;
m_pD3DDevice->RSSetViewports(1, &m_D3DViewport);
}
//D3D10CreateDeviceAndSwapChain
extern "C" _declspec(dllexport) HRESULT WINAPI newD3D10CreateDeviceAndSwapChain(IDXGIAdapter *adapter,
D3D10_DRIVER_TYPE DriverType,
HMODULE Software,
UINT Flags,
UINT SDKVersion,
DXGI_SWAP_CHAIN_DESC *pSwapChainDesc,
IDXGISwapChain **ppSwapChain,
ID3D10Device **ppDevice)
{
dbg("d3d10: D3D10CreateDeviceAndSwapChain 0x%08X 0x%08X", adapter, *adapter);
/*dbg("Mode: %dx%d %d.%dHz %s", pSwapChainDesc->BufferDesc.Width, pSwapChainDesc->BufferDesc.Height, pSwapChainDesc->BufferDesc.RefreshRate.Numerator, pSwapChainDesc->BufferDesc.RefreshRate.Denominator, pSwapChainDesc->Windowed?"Windowed":"Fullscreen");
dbg("Multisample: %d samples, quality %d", pSwapChainDesc->SampleDesc.Count, pSwapChainDesc->SampleDesc.Quality);
dbg("Buffers: %d (Usage %s), Swapeffect: %s", pSwapChainDesc->BufferCount, getUsageDXGI(pSwapChainDesc->BufferUsage), pSwapChainDesc->SwapEffect==DXGI_SWAP_EFFECT_DISCARD?"DISCARD":"SEQUENTIAL");
dbg("Flags: %s %s %s", pSwapChainDesc->Flags&DXGI_SWAP_CHAIN_FLAG_NONPREROTATED?"NONPREROTATED":"",
pSwapChainDesc->Flags&DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH?"ALLOW_MODE_SWITCH":"",
pSwapChainDesc->Flags&DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE?"GDI_COMPATIBLE":"");*/
HRESULT ret;
/*ret = D3D10CreateDevice(adapter,
D3D10_DRIVER_TYPE_HARDWARE,
NULL,
0,
D3D10_SDK_VERSION,
ppDevice
);*/
ret = D3D10CreateDevice(adapter,
DriverType,
Software,
Flags,
SDKVersion,
ppDevice
);
/*IDXGIAdapter1New *anew;
if(adapter->QueryInterface(IID_IDXGIAdapter, (void**) &anew) == S_OK) {
adapter = anew->getReal();
anew->Release();
}*/
IDXGIFactory1 *factory;
//IDXGIFactory1New *fnew;
//CreateDXGIFactory1()
if(adapter->GetParent(IID_IDXGIFactory, (void**) &factory) == S_OK)
{
//factory = fnew->getReal();
//fnew->Release();
dbg("d3d10: Got parent factory");
}
//ret = dllD3D10CreateDeviceAndSwapChain(anew, DriverType, Software, Flags, SDKVersion, pSwapChainDesc, ppSwapChain, ppDevice);
(*ppSwapChain) = new IDXGISwapChainNew(factory, factory, *ppDevice, pSwapChainDesc);
/*IDXGISwapChainNew *scnew;
if((*ppSwapChain)->QueryInterface(IID_IDXGISwapChainNew, (void**) &scnew) == S_OK) {
(*ppSwapChain) = scnew->getReal();
scnew->Release();
} else dbg("Booh! No real swap chain!");*/
/*if(fnew)
{
fnew->Release();
delete fnew;
fnew = NULL;
}*/
return ret;
}
bool D3D10App::initAPI(const DXGI_FORMAT backBufferFmt, const DXGI_FORMAT depthBufferFmt, const int samples, const uint flags){
backBufferFormat = backBufferFmt;
depthBufferFormat = depthBufferFmt;
msaaSamples = samples;
// if (screen >= GetSystemMetrics(SM_CMONITORS)) screen = 0;
IDXGIFactory *dxgiFactory;
if (FAILED(CreateDXGIFactory(__uuidof(IDXGIFactory), (void **) &dxgiFactory))){
ErrorMsg("Couldn't create DXGIFactory");
return false;
}
IDXGIAdapter *dxgiAdapter;
if (dxgiFactory->EnumAdapters(0, &dxgiAdapter) == DXGI_ERROR_NOT_FOUND){
ErrorMsg("No adapters found");
return false;
}
// DXGI_ADAPTER_DESC adapterDesc;
// dxgiAdapter->GetDesc(&adapterDesc);
IDXGIOutput *dxgiOutput;
if (dxgiAdapter->EnumOutputs(0, &dxgiOutput) == DXGI_ERROR_NOT_FOUND){
ErrorMsg("No outputs found");
return false;
}
DXGI_OUTPUT_DESC oDesc;
dxgiOutput->GetDesc(&oDesc);
// Find a suitable fullscreen format
int targetHz = 85;
DXGI_RATIONAL fullScreenRefresh;
int fsRefresh = 60;
fullScreenRefresh.Numerator = fsRefresh;
fullScreenRefresh.Denominator = 1;
char str[128];
uint nModes = 0;
dxgiOutput->GetDisplayModeList(backBufferFormat, 0, &nModes, NULL);
DXGI_MODE_DESC *modes = new DXGI_MODE_DESC[nModes];
dxgiOutput->GetDisplayModeList(backBufferFormat, 0, &nModes, modes);
resolution->clear();
for (uint i = 0; i < nModes; i++){
if (modes[i].Width >= 640 && modes[i].Height >= 480){
sprintf(str, "%dx%d", modes[i].Width, modes[i].Height);
int index = resolution->addItemUnique(str);
if (int(modes[i].Width) == fullscreenWidth && int(modes[i].Height) == fullscreenHeight){
int refresh = modes[i].RefreshRate.Numerator / modes[i].RefreshRate.Denominator;
if (abs(refresh - targetHz) < abs(fsRefresh - targetHz)){
fsRefresh = refresh;
fullScreenRefresh = modes[i].RefreshRate;
}
resolution->selectItem(index);
}
}
}
delete modes;
sprintf(str, "%s (%dx%d)", getTitle(), width, height);
DWORD wndFlags = 0;
int x, y, w, h;
if (fullscreen){
wndFlags |= WS_POPUP;
x = y = 0;
w = width;
h = height;
} else {
wndFlags |= WS_OVERLAPPEDWINDOW;
RECT wRect;
wRect.left = 0;
wRect.right = width;
wRect.top = 0;
wRect.bottom = height;
AdjustWindowRect(&wRect, wndFlags, FALSE);
MONITORINFO monInfo;
monInfo.cbSize = sizeof(monInfo);
GetMonitorInfo(oDesc.Monitor, &monInfo);
w = min(wRect.right - wRect.left, monInfo.rcWork.right - monInfo.rcWork.left);
h = min(wRect.bottom - wRect.top, monInfo.rcWork.bottom - monInfo.rcWork.top);
x = (monInfo.rcWork.left + monInfo.rcWork.right - w) / 2;
y = (monInfo.rcWork.top + monInfo.rcWork.bottom - h) / 2;
}
hwnd = CreateWindow("Humus", str, wndFlags, x, y, w, h, HWND_DESKTOP, NULL, hInstance, NULL);
RECT rect;
GetClientRect(hwnd, &rect);
// Create device and swap chain
DXGI_SWAP_CHAIN_DESC sd;
memset(&sd, 0, sizeof(sd));
sd.BufferDesc.Width = rect.right;
sd.BufferDesc.Height = rect.bottom;
sd.BufferDesc.Format = backBufferFormat;
sd.BufferDesc.RefreshRate = fullScreenRefresh;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.BufferCount = 1;
sd.OutputWindow = hwnd;
sd.Windowed = (BOOL) (!fullscreen);
sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
sd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
DWORD deviceFlags = D3D10_CREATE_DEVICE_SINGLETHREADED;
#ifdef _DEBUG
deviceFlags |= D3D10_CREATE_DEVICE_DEBUG;
#endif
if (FAILED(D3D10CreateDevice(dxgiAdapter, D3D10_DRIVER_TYPE_HARDWARE, NULL, deviceFlags, D3D10_SDK_VERSION, &device))){
ErrorMsg("Couldn't create D3D10 device");
return false;
}
while (msaaSamples > 0){
UINT nQuality;
if (SUCCEEDED(device->CheckMultisampleQualityLevels(backBufferFormat, msaaSamples, &nQuality)) && nQuality > 0){
if ((flags & NO_SETTING_CHANGE) == 0) antiAliasSamples = msaaSamples;
break;
} else {
msaaSamples -= 2;
}
}
sd.SampleDesc.Count = msaaSamples;
sd.SampleDesc.Quality = 0;
if (FAILED(dxgiFactory->CreateSwapChain(device, &sd, &swapChain))){
ErrorMsg("Couldn't create swapchain");
return false;
}
// We'll handle Alt-Enter ourselves thank you very much ...
dxgiFactory->MakeWindowAssociation(hwnd, DXGI_MWA_NO_WINDOW_CHANGES | DXGI_MWA_NO_ALT_ENTER);
dxgiOutput->Release();
dxgiAdapter->Release();
dxgiFactory->Release();
if (!createBuffers()) return false;
if (fullscreen){
captureMouse(!configDialog->isVisible());
}
renderer = new Direct3D10Renderer(device);
((Direct3D10Renderer *) renderer)->setFrameBuffer(backBufferRTV, depthBufferDSV);
antiAlias->selectItem(antiAliasSamples / 2);
linearClamp = renderer->addSamplerState(LINEAR, CLAMP, CLAMP, CLAMP);
defaultFont = renderer->addFont("../Textures/Fonts/Future.dds", "../Textures/Fonts/Future.font", linearClamp);
blendSrcAlpha = renderer->addBlendState(SRC_ALPHA, ONE_MINUS_SRC_ALPHA);
noDepthTest = renderer->addDepthState(false, false);
noDepthWrite = renderer->addDepthState(true, false);
cullNone = renderer->addRasterizerState(CULL_NONE);
cullBack = renderer->addRasterizerState(CULL_BACK);
cullFront = renderer->addRasterizerState(CULL_FRONT);
return true;
}
