void Direct3D::init(Input *p_pInput)
{
Logger::log(Logger::Level::INFO, "Initializing Direct3D...");
HRESULT hr = S_OK;;
m_pInput = p_pInput;
RECT rc;
GetClientRect( m_hWnd, &rc );
m_Width = rc.right - rc.left;
m_Height = rc.bottom - rc.top;
UINT createDeviceFlags = 0;
#ifdef _DEBUG
createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
D3D_DRIVER_TYPE driverType;
D3D_DRIVER_TYPE driverTypes[] =
{
D3D_DRIVER_TYPE_HARDWARE,
D3D_DRIVER_TYPE_REFERENCE,
};
UINT numDriverTypes = sizeof(driverTypes) / sizeof(driverTypes[0]);
DXGI_SWAP_CHAIN_DESC sd;
ZeroMemory( &sd, sizeof(sd) );
sd.BufferCount = 1;
sd.BufferDesc.Width = m_Width;
sd.BufferDesc.Height = m_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 | DXGI_USAGE_UNORDERED_ACCESS;
sd.OutputWindow = m_hWnd;
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.Windowed = TRUE;
D3D_FEATURE_LEVEL featureLevelsToTry[] = {
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0
};
D3D_FEATURE_LEVEL initiatedFeatureLevel;
for( UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++ )
{
driverType = driverTypes[driverTypeIndex];
hr = D3D11CreateDeviceAndSwapChain(
NULL,
driverType,
NULL,
createDeviceFlags,
featureLevelsToTry,
ARRAYSIZE(featureLevelsToTry),
D3D11_SDK_VERSION,
&sd,
&m_SwapChain,
&m_Device,
&initiatedFeatureLevel,
&m_DeviceContext);
if( SUCCEEDED( hr ) )
{
char title[256];
sprintf_s(
title,
sizeof(title),
"Direct3D 11.0 | Direct3D 11.0 device initiated with Direct3D 11 feature level"
);
SetWindowText(m_hWnd, title);
break;
}
}
if( FAILED(hr) )
{
Logger::log(Logger::Level::ERROR_L, "Initialization of Direct3D failed! Could not create Device and swapchain!" );
return;
}
//Create a render target view
ID3D11Texture2D* pBackBuffer;
hr = m_SwapChain->GetBuffer( 0, __uuidof( ID3D11Texture2D ), (LPVOID*)&pBackBuffer );
if( FAILED(hr) )
{
Logger::log(Logger::Level::ERROR_L, "Initialization of Direct3D failed! Could get buffer from swapchain!");
return;
}
// create shader unordered access view on back buffer for compute shader to write into texture
hr = m_Device->CreateUnorderedAccessView( pBackBuffer, NULL, &m_BackBufferUAV );
if( FAILED(hr) )
{
Logger::log(Logger::Level::ERROR_L, "Initialization of Direct3D failed! Could create UAV!");
return;
}
SAFE_RELEASE(pBackBuffer);
m_ComputeSys = new ComputeWrap(m_Device, m_DeviceContext);
m_Timer = new D3DTimer(m_Device, m_DeviceContext);
Logger::log(Logger::Level::INFO, "Initializing compute shaders...");
m_PrimaryShader = m_ComputeSys->CreateComputeShader("shaders/primaryraystage.fx", NULL, "main", NULL);
m_IntersectionShader = m_ComputeSys->CreateComputeShader("shaders/intersectionstage.fx", NULL, "main", NULL);
m_ColorShader = m_ComputeSys->CreateComputeShader("shaders/colorstage.fx", NULL, "main", NULL);
Logger::log(Logger::Level::INFO, "Initializing structured buffers...");
m_RayBuffer = m_ComputeSys->CreateBuffer( STRUCTURED_BUFFER, sizeof(Ray), m_Width*m_Height, true, true, nullptr, true, "Structured Buffer: RayBuffer");
m_HitDataBuffer = m_ComputeSys->CreateBuffer( STRUCTURED_BUFFER, sizeof(HitData), m_Width*m_Height, true, true, nullptr, true, "Structured Buffer: HitDataBuffer");
m_FinalColorBuffer = m_ComputeSys->CreateBuffer(STRUCTURED_BUFFER, sizeof(XMFLOAT4), m_Height*m_Width, true, true, nullptr,true, "Structured Buffer:FinalColorBuffer");
///////////////////////////////////////////////////////////////////////////////////////////
//Camera
///////////////////////////////////////////////////////////////////////////////////////////
Logger::log(Logger::Level::INFO, "Initializing camera...");
m_pCamera = std::shared_ptr<Camera>(new Camera);
XMVECTOR cameraPos = XMVectorSet(-10.f, 10.f, -10.f, 0.f);
XMVECTOR cameraDir = XMVectorSet(1.f, -1.f, 1.f, 0.f);
XMVECTOR cameraUp = XMVectorSet(0.f, 1.f, 0.f, 0.f);
m_pCamera->init(cameraPos, cameraUp, cameraDir, (float)m_Width, (float)m_Height);
m_pInput->init(m_pCamera);
///////////////////////////////////////////////////////////////////////////////////////////
//Constant Buffer
///////////////////////////////////////////////////////////////////////////////////////////
Logger::log(Logger::Level::INFO, "Initializing constant buffers...");
createConstantBuffers();
///////////////////////////////////////////////////////////////////////////////////////////
//Sphere
///////////////////////////////////////////////////////////////////////////////////////////
Logger::log(Logger::Level::INFO, "Initializing volumes...");
m_sphere.center = XMFLOAT4(10.f, 0.f, 0.f, 1.f);
m_sphere.radius = 2.f;
m_sphere.color = XMFLOAT4(1.f, 0.f, 0.f, 1.f);
m_sphere.pad = XMFLOAT2(0.f, 0.f);
m_sphere.ID = -2;
#pragma region Cube
///////////////////////////////////////////////////////////////////////////////////////////
//Cube
///////////////////////////////////////////////////////////////////////////////////////////
//Back
m_triangles[0].pos0 = XMFLOAT4( 1.f*CUBESIZE, -1.f*CUBESIZE, 1.f*CUBESIZE, 1.f);
m_triangles[0].pos1 = XMFLOAT4(-1.f*CUBESIZE, -1.f*CUBESIZE, 1.f*CUBESIZE, 1.f);
m_triangles[0].pos2 = XMFLOAT4(-1.f*CUBESIZE, 1.f*CUBESIZE, 1.f*CUBESIZE, 1.f);
m_triangles[0].normal = XMFLOAT4(0.f, 0.f, -1.f, 0.f);
m_triangles[1].pos0 = XMFLOAT4( 1.f*CUBESIZE, -1.f*CUBESIZE, 1.f*CUBESIZE, 1.f);
m_triangles[1].pos1 = XMFLOAT4(-1.f*CUBESIZE, 1.f*CUBESIZE, 1.f*CUBESIZE, 1.f);
m_triangles[1].pos2 = XMFLOAT4( 1.f*CUBESIZE, 1.f*CUBESIZE, 1.f*CUBESIZE, 1.f);
m_triangles[1].normal = XMFLOAT4(0.f, 0.f, -1.f, 0.f);
//Left
m_triangles[2].pos0 = XMFLOAT4(-1.f*CUBESIZE, -1.f*CUBESIZE, 1.f*CUBESIZE, 1.f);
m_triangles[2].pos1 = XMFLOAT4(-1.f*CUBESIZE, -1.f*CUBESIZE, -1.f*CUBESIZE, 1.f);
m_triangles[2].pos2 = XMFLOAT4(-1.f*CUBESIZE, 1.f*CUBESIZE, -1.f*CUBESIZE, 1.f);
m_triangles[2].normal = XMFLOAT4(1.f, 0.f, 0.f, 0.f);
m_triangles[3].pos0 = XMFLOAT4(-1.f*CUBESIZE, -1.f*CUBESIZE, 1.f*CUBESIZE, 1.f);
m_triangles[3].pos1 = XMFLOAT4(-1.f*CUBESIZE, 1.f*CUBESIZE, -1.f*CUBESIZE, 1.f);
m_triangles[3].pos2 = XMFLOAT4(-1.f*CUBESIZE, 1.f*CUBESIZE, 1.f*CUBESIZE, 1.f);
m_triangles[3].normal = XMFLOAT4(1.f, 0.f, 0.f, 0.f);
////Right
m_triangles[4].pos0 = XMFLOAT4( 1.f*CUBESIZE, -1.f*CUBESIZE, -1.f*CUBESIZE, 1.f);
m_triangles[4].pos1 = XMFLOAT4( 1.f*CUBESIZE, -1.f*CUBESIZE, 1.f*CUBESIZE, 1.f);
m_triangles[4].pos2 = XMFLOAT4( 1.f*CUBESIZE, 1.f*CUBESIZE, 1.f*CUBESIZE, 1.f);
m_triangles[4].normal = XMFLOAT4(-1.f, 0.f, 0.f, 0.f);
m_triangles[5].pos0 = XMFLOAT4( 1.f*CUBESIZE, -1.f*CUBESIZE, -1.f*CUBESIZE, 1.f);
m_triangles[5].pos1 = XMFLOAT4( 1.f*CUBESIZE, 1.f*CUBESIZE, 1.f*CUBESIZE, 1.f);
m_triangles[5].pos2 = XMFLOAT4( 1.f*CUBESIZE, 1.f*CUBESIZE, -1.f*CUBESIZE, 1.f);
m_triangles[5].normal = XMFLOAT4(-1.f, 0.f, 0.f, 0.f);
////Top
m_triangles[6].pos0 = XMFLOAT4( 1.f*CUBESIZE, 1.f*CUBESIZE, 1.f*CUBESIZE, 1.f);
m_triangles[6].pos1 = XMFLOAT4(-1.f*CUBESIZE, 1.f*CUBESIZE, 1.f*CUBESIZE, 1.f);
m_triangles[6].pos2 = XMFLOAT4(-1.f*CUBESIZE, 1.f*CUBESIZE, -1.f*CUBESIZE, 1.f);
m_triangles[6].normal = XMFLOAT4(0.f, -1.f, 0.f, 0.f);
m_triangles[7].pos0 = XMFLOAT4( 1.f*CUBESIZE, 1.f*CUBESIZE, 1.f*CUBESIZE, 1.f);
m_triangles[7].pos1 = XMFLOAT4(-1.f*CUBESIZE, 1.f*CUBESIZE, -1.f*CUBESIZE, 1.f);
m_triangles[7].pos2 = XMFLOAT4( 1.f*CUBESIZE, 1.f*CUBESIZE, -1.f*CUBESIZE, 1.f);
m_triangles[7].normal = XMFLOAT4(0.f, -1.f, 0.f, 0.f);
////Bottom
m_triangles[8].pos1 = XMFLOAT4( 1.f*CUBESIZE, -1.f*CUBESIZE, 1.f*CUBESIZE, 1.f);
m_triangles[8].pos0 = XMFLOAT4(-1.f*CUBESIZE, -1.f*CUBESIZE, 1.f*CUBESIZE, 1.f);
m_triangles[8].pos2 = XMFLOAT4( 1.f*CUBESIZE, -1.f*CUBESIZE, -1.f*CUBESIZE, 1.f);
m_triangles[8].normal = XMFLOAT4(0.f, 1.f, 0.f, 0.f);
m_triangles[9].pos1 = XMFLOAT4(-1.f*CUBESIZE, -1.f*CUBESIZE, 1.f*CUBESIZE, 1.f);
m_triangles[9].pos0 = XMFLOAT4(-1.f*CUBESIZE, -1.f*CUBESIZE, -1.f*CUBESIZE, 1.f);
m_triangles[9].pos2 = XMFLOAT4( 1.f*CUBESIZE, -1.f*CUBESIZE, -1.f*CUBESIZE, 1.f);
m_triangles[9].normal = XMFLOAT4(0.f, 1.f, 0.f, 0.f);
//Front
m_triangles[10].pos0 = XMFLOAT4( 1.f*CUBESIZE, -1.f*CUBESIZE, -1.f*CUBESIZE, 1.f);
m_triangles[10].pos1 = XMFLOAT4(-1.f*CUBESIZE, -1.f*CUBESIZE, -1.f*CUBESIZE, 1.f);
m_triangles[10].pos2 = XMFLOAT4(-1.f*CUBESIZE, 1.f*CUBESIZE, -1.f*CUBESIZE, 1.f);
m_triangles[10].normal = XMFLOAT4(0.f, 0.f, 1.f, 0.f);
m_triangles[11].pos0 = XMFLOAT4( 1.f*CUBESIZE, -1.f*CUBESIZE, -1.f*CUBESIZE, 1.f);
m_triangles[11].pos1 = XMFLOAT4(-1.f*CUBESIZE, 1.f*CUBESIZE, -1.f*CUBESIZE, 1.f);
m_triangles[11].pos2 = XMFLOAT4( 1.f*CUBESIZE, 1.f*CUBESIZE, -1.f*CUBESIZE, 1.f);
m_triangles[11].normal = XMFLOAT4(0.f, 0.f, 1.f, 0.f);
for(int i = 0; i < NROFTRIANGLES; i++)
{
m_triangles[i].color = XMFLOAT4(0.f, 0.5f, 0.5f, 1.f);
m_triangles[i].ID = i;
m_triangles[i].pad = 0.f;
m_triangles[i].textureCoordinate0 = XMFLOAT2(0.f, 0.f);
m_triangles[i].textureCoordinate1 = XMFLOAT2(0.f, 0.f);
m_triangles[i].textureCoordinate2 = XMFLOAT2(0.f, 0.f);
}
#pragma endregion
///////////////////////////////////////////////////////////////////////////////////////////
//Light
///////////////////////////////////////////////////////////////////////////////////////////
Logger::log(Logger::Level::INFO, "Initializing lights...");
std::srand(10);
for(int i = 0; i < NROFLIGHTS; i++)
{
float rx = ((float)(std::rand() % 64)) - 32;
float ry = ((float)(std::rand() % 64)) - 32;
float rz = ((float)(std::rand() % 64)) - 32;
m_lightList[i].pos = XMFLOAT4( rx, ry, rz, 1.f);
m_lightList[i].ambient = XMFLOAT4(0.5f, 0.5f, 0.5f, 1.f);
m_lightList[i].diffuse = XMFLOAT4(0.15f, 0.15f, 0.15f, 1.f);
m_lightList[i].range = 75.f;
m_lightList[i].pad = XMFLOAT3(0.f, 0.f, 0.f);
}
///////////////////////////////////////////////////////////////////////////////////////////
//Mesh
///////////////////////////////////////////////////////////////////////////////////////////
Logger::log(Logger::Level::INFO, "Parsing obj...");
m_mesh.loadObj("Meshi/kub.obj");
m_meshBuffer = m_ComputeSys->CreateBuffer( STRUCTURED_BUFFER, sizeof(Triangle), m_mesh.getFaces(), true, false, m_mesh.getTriangles(), false, "Structured Buffer: Mesh Texture");
D3DX11CreateShaderResourceViewFromFile(m_Device, m_mesh.getMaterial()->map_Kd.c_str(), NULL, NULL, &m_meshTexture, &hr);
m_FirstPassStruct.firstPass = 1;
std::vector<std::string> headers;
headers.push_back("Primary Ray Stage");
headers.push_back("Intersection Stage");
headers.push_back("Color Stage");
m_DataTable = DataTable(headers);
}
int main()
{
__esan::HashTable<int, int> IntTable;
assert(IntTable.size() == 0);
// Test iteration on an empty table.
int Count = 0;
for (auto Iter = IntTable.begin(); Iter != IntTable.end();
++Iter, ++Count) {
// Empty.
}
assert(Count == 0);
bool Added = IntTable.add(4, 42);
assert(Added);
assert(!IntTable.add(4, 42));
assert(IntTable.size() == 1);
int Value;
bool Found = IntTable.lookup(4, Value);
assert(Found && Value == 42);
// Test iterator.
IntTable.lock();
for (auto Iter = IntTable.begin(); Iter != IntTable.end();
++Iter, ++Count) {
assert((*Iter).Key == 4);
assert((*Iter).Data == 42);
}
IntTable.unlock();
assert(Count == 1);
assert(Count == IntTable.size());
assert(!IntTable.remove(5));
assert(IntTable.remove(4));
// Test a more complex payload.
__esan::HashTable<int, MyDataPayload> DataTable(4);
MyDataPayload NewData(new MyData("mystring"));
Added = DataTable.add(4, NewData);
assert(Added);
MyDataPayload FoundData;
Found = DataTable.lookup(4, FoundData);
assert(Found && strcmp(FoundData.Data->Buf, "mystring") == 0);
assert(!DataTable.remove(5));
assert(DataTable.remove(4));
// Test resize.
for (int i = 0; i < 4; ++i) {
MyDataPayload MoreData(new MyData("delete-at-end"));
Added = DataTable.add(i+1, MoreData);
assert(Added);
assert(!DataTable.add(i+1, MoreData));
}
for (int i = 0; i < 4; ++i) {
Found = DataTable.lookup(i+1, FoundData);
assert(Found && strcmp(FoundData.Data->Buf, "delete-at-end") == 0);
}
DataTable.lock();
Count = 0;
for (auto Iter = DataTable.begin(); Iter != DataTable.end();
++Iter, ++Count) {
int Key = (*Iter).Key;
FoundData = (*Iter).Data;
assert(Key >= 1 && Key <= 4);
assert(strcmp(FoundData.Data->Buf, "delete-at-end") == 0);
}
DataTable.unlock();
assert(Count == 4);
assert(Count == DataTable.size());
// Ensure the iterator supports a range-based for loop.
DataTable.lock();
Count = 0;
for (auto Pair : DataTable) {
assert(Pair.Key >= 1 && Pair.Key <= 4);
assert(strcmp(Pair.Data.Data->Buf, "delete-at-end") == 0);
++Count;
}
DataTable.unlock();
assert(Count == 4);
assert(Count == DataTable.size());
// Test payload freeing via smart pointer wrapper.
__esan::HashTable<MyDataPayload, MyDataPayload, true> DataKeyTable;
MyDataPayload DataA(new MyData("string AB"));
DataKeyTable.lock();
Added = DataKeyTable.add(DataA, DataA);
assert(Added);
Found = DataKeyTable.lookup(DataA, FoundData);
assert(Found && strcmp(FoundData.Data->Buf, "string AB") == 0);
MyDataPayload DataB(new MyData("string AB"));
Added = DataKeyTable.add(DataB, DataB);
assert(!Added);
DataKeyTable.remove(DataB); // Should free the DataA payload.
DataKeyTable.unlock();
// Test custom functors.
struct CustomHash {
size_t operator()(int Key) const { return Key % 4; }
};
struct CustomEqual {
bool operator()(int Key1, int Key2) const { return Key1 %4 == Key2 % 4; }
};
__esan::HashTable<int, int, false, CustomHash, CustomEqual> ModTable;
Added = ModTable.add(2, 42);
assert(Added);
Added = ModTable.add(6, 42);
assert(!Added);
fprintf(stderr, "All checks passed.\n");
return 0;
}
