void Game::Update(float dt)
{
m_Input->Update();
//If escape is pressed, exit program
if (m_Input->IsKeyDown(DIK_ESCAPE))
{
exit(0);
}
m_Camera->Update(dt, m_Input);
m_waveManager->Update(dt);
//Refresh anttweakbar
TwRefreshBar(m_gameTweakBar);
//Render scene
m_Graphics->Render(m_Camera, m_renderObjects, m_sky, m_waveManager, m_light);
}
int main(int argc, char** argv)
{
LoadConfigFile();
initHMD();
glfwSetErrorCallback(ErrorCallback);
if (!glfwInit())
{
exit(EXIT_FAILURE);
}
glfwWindowHint(GLFW_DEPTH_BITS, 16);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);// : GLFW_OPENGL_COMPAT_PROFILE);
//glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#ifdef _DEBUG
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
#endif
const std::string windowName = "RiftRay v" + std::string(pRiftRayVersion);
GLFWwindow* l_Window = glfwCreateWindow(g_mirrorWindowSz.x, g_mirrorWindowSz.y, windowName.c_str(), NULL, NULL);
if (!l_Window)
{
LOG_ERROR("Glfw failed to create a window. Exiting.");
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(l_Window);
glfwSetKeyCallback(l_Window, keyboard);
glfwSetMouseButtonCallback(l_Window, mouseDown);
glfwSetCursorPosCallback(l_Window, mouseMove);
glfwSetScrollCallback(l_Window, mouseWheel);
glfwSetWindowSizeCallback(l_Window, resize);
glfwSetInputMode(l_Window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
g_pMirrorWindow = l_Window;
memset(m_keyStates, 0, GLFW_KEY_LAST*sizeof(int));
FindPreferredJoystick();
glewExperimental = GL_TRUE;
if (glewInit() != GLEW_OK)
{
LOG_INFO("glewInit() error.");
exit(EXIT_FAILURE);
}
#ifdef _DEBUG
// Debug callback initialization
// Must be done *after* glew initialization.
glDebugMessageCallback(myCallback, NULL);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_MARKER, 0,
GL_DEBUG_SEVERITY_NOTIFICATION, -1 , "Start debugging");
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
#endif
#ifdef USE_ANTTWEAKBAR
TwInit(TW_OPENGL_CORE, NULL);
initAnt();
#endif
g_pScene = &g_gallery;// new ShaderGalleryScene();
if (g_pScene != NULL)
{
g_pScene->initGL();
}
g_gallery.SetHmdPositionPointer(&m_hmdRo);
g_gallery.SetHmdDirectionPointer(&m_hmdRd);
g_gallery.SetChassisPosPointer(&m_chassisPos);
g_gallery.SetChassisYawPointer(&m_chassisYaw);
g_gallery.SetHeadSizePointer(&m_headSize);
initVR();
StartShaderLoad();
glfwSwapInterval(0);
while (!glfwWindowShouldClose(l_Window))
{
glfwPollEvents();
joystick();
timestep();
#ifdef USE_ANTTWEAKBAR
TwRefreshBar(g_pMainTweakbar);
TwRefreshBar(g_pShaderTweakbar);
#endif
g_gallery.RenderPrePass();
displayHMD();
glfwSwapBuffers(l_Window);
}
exitVR();
g_pScene->exitGL();
glfwDestroyWindow(l_Window);
glfwTerminate();
exit(EXIT_SUCCESS);
}
int main(int argc, char* argv[])
{
std::cout << "VoxelAO by Kevin Ortegren, 2015" << std::endl;
bool running = true;
//Setup SDL window
SDL_SysWMinfo info;
HWND handle;
if (SDL_Init(SDL_INIT_TIMER) != 0)
{
std::cerr << "SDL_Init failed: " << SDL_GetError() << std::endl;
}
window = SDL_CreateWindow("VoxelAO", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE );
//Must init info struct with SDL version info, see documentation for explanation
SDL_VERSION(&info.version);
//If succeeded, init d3d11 and other things
if (SDL_GetWindowWMInfo(window, &info))
{
handle = info.info.win.window;
}
else
{
std::cerr << "Failed to get WMInfo: " << SDL_GetError() << std::endl;
running = false;
}
InitD3D(handle);
SetupAntTweakBar();
timer = new D3D11Timer(device, context);
{
ID3DBlob* vsblob,* psblob, *gsblob;
ID3DBlob* errblob = nullptr;
UINT flags = 0;
#ifndef _DEBUG // IF NOT DEBUG
flags |= D3DCOMPILE_OPTIMIZATION_LEVEL3;
#endif
//Create shaders
CHECKDX(D3DCompileFromFile(L"../../Assets/Shaders/simple.vertex", nullptr, nullptr, "main", "vs_5_0", flags, 0, &vsblob, nullptr));
CHECKDX(D3DCompileFromFile(L"../../Assets/Shaders/simple.pixel", nullptr, nullptr, "main", "ps_5_0", flags, 0, &psblob, nullptr));
CHECKDX(device->CreateVertexShader(vsblob->GetBufferPointer(), vsblob->GetBufferSize(), nullptr, &VS));
CHECKDX(device->CreatePixelShader(psblob->GetBufferPointer(), psblob->GetBufferSize(), nullptr, &PS));
D3D11_INPUT_ELEMENT_DESC ied[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
CHECKDX(device->CreateInputLayout(ied, 3, vsblob->GetBufferPointer(), vsblob->GetBufferSize(), &layout));
//Full screen quad shader
CHECKDX(D3DCompileFromFile(L"../../Assets/Shaders/fsq.vertex", nullptr, nullptr, "main", "vs_5_0", flags, 0, &vsblob, nullptr));
CHECKDX(D3DCompileFromFile(L"../../Assets/Shaders/fsq.pixel", nullptr, nullptr, "main", "ps_5_0", flags, 0, &psblob, &errblob));
CHECKDX(device->CreateVertexShader(vsblob->GetBufferPointer(), vsblob->GetBufferSize(), nullptr, &fsqVS));
CHECKDX(device->CreatePixelShader(psblob->GetBufferPointer(), psblob->GetBufferSize(), nullptr, &fsqPS));
CHECKDX(D3DCompileFromFile(L"../../Assets/Shaders/fsq_only_AO.pixel", nullptr, nullptr, "main", "ps_5_0", flags, 0, &psblob, &errblob));
CHECKDX(device->CreatePixelShader(psblob->GetBufferPointer(), psblob->GetBufferSize(), nullptr, &fsqOcclusionPS));
CHECKDX(D3DCompileFromFile(L"../../Assets/Shaders/fsq_no_AO.pixel", nullptr, nullptr, "main", "ps_5_0", flags, 0, &psblob, &errblob));
CHECKDX(device->CreatePixelShader(psblob->GetBufferPointer(), psblob->GetBufferSize(), nullptr, &fsqNOOcclusionPS));
D3D11_INPUT_ELEMENT_DESC iedfsq[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
CHECKDX(device->CreateInputLayout(iedfsq, 1, vsblob->GetBufferPointer(), vsblob->GetBufferSize(), &fsqlayout));
//Create voxelizer shaders
CHECKDX(D3DCompileFromFile(L"../../Assets/Shaders/voxelizing.vertex", nullptr, nullptr, "main", "vs_5_0", flags, 0, &vsblob, &errblob));
CHECKDX(D3DCompileFromFile(L"../../Assets/Shaders/voxelizing.geometry", nullptr, nullptr, "main", "gs_5_0", flags, 0, &gsblob, &errblob));
CHECKDX(D3DCompileFromFile(L"../../Assets/Shaders/voxelizing.pixel", nullptr, nullptr, "main", "ps_5_0", flags, 0, &psblob, &errblob));
CHECKDX(device->CreateVertexShader(vsblob->GetBufferPointer(), vsblob->GetBufferSize(), nullptr, &voxelVS));
CHECKDX(device->CreateGeometryShader(gsblob->GetBufferPointer(), gsblob->GetBufferSize(), nullptr, &voxelGS));
CHECKDX(device->CreatePixelShader(psblob->GetBufferPointer(), psblob->GetBufferSize(), nullptr, &voxelPS));
D3D11_INPUT_ELEMENT_DESC iedvox[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
CHECKDX(device->CreateInputLayout(ied, 3, vsblob->GetBufferPointer(), vsblob->GetBufferSize(), &voxelLayout));
vsblob->Release();
gsblob->Release();
psblob->Release();
}
{
OBJLoader objLoader;
mesh = objLoader.LoadBIN("../../Assets/Models/sponza.bin");
}
//Camera
camera.SetLens((float)M_PI_4, NEARZ, FARZ, WINDOW_WIDTH, WINDOW_HEIGHT);
{
//Init primitive spritebatch from DirectXTK
primitiveBatch = new DirectX::PrimitiveBatch<DirectX::VertexPositionColor>(context, 65536, (size_t)(65536/3));
basicEffect = new DirectX::BasicEffect(device);
basicEffect->SetProjection(XMLoadFloat4x4(&camera.GetCamData().projMat));
basicEffect->SetVertexColorEnabled(true);
void const* shaderByteCode;
size_t byteCodeLength;
basicEffect->GetVertexShaderBytecode(&shaderByteCode, &byteCodeLength);
CHECKDX(device->CreateInputLayout(DirectX::VertexPositionColor::InputElements,
DirectX::VertexPositionColor::InputElementCount,
shaderByteCode, byteCodeLength,
&basicInputLayout));
D3D11_BUFFER_DESC cbDesc;
cbDesc.ByteWidth = sizeof(CameraData);
cbDesc.Usage = D3D11_USAGE_DYNAMIC;
cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
cbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
cbDesc.MiscFlags = 0;
cbDesc.StructureByteStride = 0;
CHECKDX(device->CreateBuffer(&cbDesc, nullptr, &camConstBuffer));
D3D11_BUFFER_DESC cbkernelDesc;
cbkernelDesc.ByteWidth = sizeof(SampleKernelOptions);
cbkernelDesc.Usage = D3D11_USAGE_DYNAMIC;
cbkernelDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
cbkernelDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
cbkernelDesc.MiscFlags = 0;
cbkernelDesc.StructureByteStride = 0;
CHECKDX(device->CreateBuffer(&cbkernelDesc, nullptr, &sampleConstBuffer));
D3D11_BUFFER_DESC cbvoxelDesc;
cbvoxelDesc.ByteWidth = sizeof(VoxelOptions);
cbvoxelDesc.Usage = D3D11_USAGE_DYNAMIC;
cbvoxelDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
cbvoxelDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
cbvoxelDesc.MiscFlags = 0;
cbvoxelDesc.StructureByteStride = 0;
CHECKDX(device->CreateBuffer(&cbvoxelDesc, nullptr, &voxelOptionConstBuffer));
//Set up sampler state
D3D11_SAMPLER_DESC samplerDesc;
ZeroMemory(&samplerDesc, sizeof(samplerDesc));
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
CHECKDX(device->CreateSamplerState(&samplerDesc, &linearSamplerState));
//Rasterizer state
D3D11_RASTERIZER_DESC RSdesc;
ZeroMemory(&RSdesc, sizeof(RSdesc));
RSdesc.FillMode = D3D11_FILL_SOLID;
RSdesc.CullMode = D3D11_CULL_NONE;
RSdesc.DepthClipEnable = TRUE;
CHECKDX(device->CreateRasterizerState(&RSdesc, &RSStateSolid));
RSdesc.FillMode = D3D11_FILL_WIREFRAME;
CHECKDX(device->CreateRasterizerState(&RSdesc, &RSStateWireframe));
}
//Init voxel structure and GPU resources
{
voxelMatrix = Matrix::CreateOrthographic(VOXEL_STRUCTURE_WIDTH, VOXEL_STRUCTURE_WIDTH, 0.0f, VOXEL_STRUCTURE_WIDTH);
voxelViewProjMatrix[0] = Matrix::CreateLookAt(Vector3(-VOXEL_STRUCTURE_WIDTH/2, 0, 0), Vector3(0, 0, 0), Vector3(0, 1, 0)) * voxelMatrix;
voxelViewProjMatrix[1] = Matrix::CreateLookAt(Vector3(0, -VOXEL_STRUCTURE_WIDTH / 2, 0), Vector3(0, 0, 0), Vector3(1, 0, 0)) * voxelMatrix;
voxelViewProjMatrix[2] = Matrix::CreateLookAt(Vector3(0, 0, -VOXEL_STRUCTURE_WIDTH / 2), Vector3(0, 0, 0), Vector3(0, 1, 0)) * voxelMatrix;
D3D11_BUFFER_DESC voxmatbuffdesc;
voxmatbuffdesc.ByteWidth = 3 * sizeof(Matrix);
voxmatbuffdesc.Usage = D3D11_USAGE_IMMUTABLE;
voxmatbuffdesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
voxmatbuffdesc.CPUAccessFlags = 0;
voxmatbuffdesc.MiscFlags = 0;
voxmatbuffdesc.StructureByteStride = 0;
D3D11_SUBRESOURCE_DATA voxmatdata;
voxmatdata.pSysMem = &voxelViewProjMatrix[0];
voxmatdata.SysMemPitch = 3 * sizeof(Matrix);
voxmatdata.SysMemSlicePitch = 0;
CHECKDX(device->CreateBuffer(&voxmatbuffdesc, &voxmatdata, &voxelMatBuffer));
// CreateVoxelBuffers();
D3D11_BLEND_DESC blendDesc = { 0 };
CHECKDX(device->CreateBlendState(&blendDesc, &voxelBlendState));
}
RebuildKernel();
//RenderTarget clear color
float clearColor[] = { 1.0f, 1.0f, 0.0f, 1.0f };
//Timer
uint32 oldTime, currentTime;
float dt;
uint32 frames = 0;
float collectedTime = 0.0f;
float collectedAOTime = 0.0f;
float collectedVoxelTime = 0.0f;
currentTime = SDL_GetTicks();
while (running)
{
oldTime = currentTime;
currentTime = SDL_GetTicks();
dt = (currentTime - oldTime) / 1000.0f;
collectedTime += dt;
++frames;
if (collectedTime >= 1.0f)
{
collectedTime -= 1.0f;
FPS = frames;
AOTime = collectedAOTime / (float)frames;
voxelTime = collectedVoxelTime / (float)frames;
collectedAOTime = 0.0f;
collectedVoxelTime = 0.0f;
frames = 0;
}
running = HandleEvents();
const Uint8* keystate = SDL_GetKeyboardState(NULL);
//Check keys and move camera
if (keystate[SDL_SCANCODE_A])
camera.StrafeLeft(dt);
if (keystate[SDL_SCANCODE_D])
camera.StrafeRight(dt);
if (keystate[SDL_SCANCODE_W])
camera.MoveForward(dt);
if (keystate[SDL_SCANCODE_S])
camera.MoveBackward(dt);
if (keystate[SDL_SCANCODE_LSHIFT])
camera.MoveDown(dt);
if (keystate[SDL_SCANCODE_SPACE])
camera.MoveUp(dt);
camera.Update();
D3D11_MAPPED_SUBRESOURCE camResource;
CHECKDX(context->Map(camConstBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &camResource));
memcpy(camResource.pData, &camera.GetCamData(), sizeof(CameraData));
context->Unmap(camConstBuffer, 0);
if (sampleOptions.sizeX != prevSampleOptions.sizeX || sampleOptions.sizeY != prevSampleOptions.sizeY)
{
prevSampleOptions.sizeX = sampleOptions.sizeX;
prevSampleOptions.sizeY = sampleOptions.sizeY;
RebuildKernel();
}
D3D11_MAPPED_SUBRESOURCE kernelResource;
CHECKDX(context->Map(sampleConstBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &kernelResource));
memcpy(kernelResource.pData, &sampleOptions, sizeof(SampleKernelOptions));
context->Unmap(sampleConstBuffer, 0);
if (voxelRes != prevVoxelRes)
{
prevVoxelRes = voxelRes;
switch (voxelRes)
{
case _64:
numVoxels = 64;
break;
case _128:
numVoxels = 128;
break;
case _256:
numVoxels = 256;
break;
case _512:
numVoxels = 512;
break;
case _1024:
numVoxels = 1024;
break;
default:
break;
}
voxelOptions.count = numVoxels;
voxelOptions.width = VOXEL_STRUCTURE_WIDTH / (float)numVoxels;
voxelElementCount = numVoxels * numVoxels * (numVoxels / 32);
#ifdef ENABLE_VOXELDRAW
delete[] voxelCPUstructure;
voxelCPUstructure = new uint32[voxelElementCount];
#endif
CreateVoxelBuffers();
D3D11_MAPPED_SUBRESOURCE voxelResource;
CHECKDX(context->Map(voxelOptionConstBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &voxelResource));
memcpy(voxelResource.pData, &voxelOptions, sizeof(VoxelOptions));
context->Unmap(voxelOptionConstBuffer, 0);
}
///////////////////////
//Voxelize step
///////////////////////
ID3D11RenderTargetView* RT = voxelVoidRT.GetRenderTargetView();
context->OMSetRenderTargetsAndUnorderedAccessViews(1, &RT, 0, 1, 1, &voxelUAV, nullptr);
context->OMSetBlendState(voxelBlendState, nullptr, 0xffffffff);
context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
//Copy a null buffer to clear voxel structure. Needs to be done if having dynamic geometry
//context->CopyResource(voxelStructure, voxelClearBuffer);
D3D11_VIEWPORT voxviewPort;
ZeroMemory(&voxviewPort, sizeof(D3D11_VIEWPORT));
voxviewPort.TopLeftX = 0;
voxviewPort.TopLeftY = 0;
voxviewPort.MinDepth = 0.0f;
voxviewPort.MaxDepth = 1.0f;
voxviewPort.Width = (float)numVoxels;
voxviewPort.Height = (float)numVoxels;
context->RSSetViewports(1, &voxviewPort);
context->VSSetShader(voxelVS, 0, 0);
context->GSSetShader(voxelGS, 0, 0);
context->PSSetShader(voxelPS, 0, 0);
context->PSSetConstantBuffers(1, 1, &voxelOptionConstBuffer);
context->IASetInputLayout(voxelLayout);
context->GSSetConstantBuffers(0, 1, &voxelMatBuffer);
context->GSSetConstantBuffers(1, 1, &voxelOptionConstBuffer);
context->RSSetState(RSStateSolid);
timer->Start();
mesh->Apply();
mesh->Draw();
timer->Stop();
collectedVoxelTime += (float)timer->GetTime();
#ifdef ENABLE_VOXELDRAW
if (enableDebugDraw)
{
context->CopyResource(voxelStagingStructure, voxelStructure);
D3D11_MAPPED_SUBRESOURCE mapData;
if (context->Map(voxelStagingStructure, 0, D3D11_MAP_READ, 0, &mapData) == S_OK)
{
memcpy(voxelCPUstructure, mapData.pData, voxelElementCount * sizeof(uint32));
context->Unmap(voxelStagingStructure, 0);
}
}
#endif
/////////////////////////////
//G-buffer pass
/////////////////////////////
//Clear RTs before drawing
colorRT.Clear();
normalRT.Clear();
positionRT.Clear();
context->ClearRenderTargetView(backBuffer, clearColor);
context->ClearDepthStencilView(depthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0);
//Set Gbuffer RTs
ID3D11RenderTargetView* RTs[] = { colorRT.GetRenderTargetView(), normalRT.GetRenderTargetView(), positionRT.GetRenderTargetView() };
ID3D11RenderTargetView* RTzero[] = { 0, 0, 0 };
context->OMSetRenderTargets(3, RTs, depthStencilView);
context->OMSetBlendState(nullptr, nullptr, 0xffffffff);
//Set shaders
D3D11_VIEWPORT viewPort;
ZeroMemory(&viewPort, sizeof(D3D11_VIEWPORT));
viewPort.TopLeftX = 0;
viewPort.TopLeftY = 0;
viewPort.MinDepth = 0.0f;
viewPort.MaxDepth = 1.0f;
viewPort.Width = WINDOW_WIDTH;
viewPort.Height = WINDOW_HEIGHT;
context->RSSetViewports(1, &viewPort);
context->VSSetShader(VS, 0, 0);
context->GSSetShader(nullptr, 0, 0);
context->PSSetShader(PS, 0, 0);
context->IASetInputLayout(layout);
context->PSSetSamplers(0, 1, &linearSamplerState);
context->VSSetConstantBuffers(0, 1, &camConstBuffer);
context->RSSetState(RSStateSolid);
//Draw geometry
mesh->Apply();
mesh->DrawIndexed();
context->OMSetRenderTargets(3, RTzero, 0);
/////////////////////////////
//Draw to backbuffer, AO pass
/////////////////////////////
context->OMSetRenderTargets(1, &backBuffer, 0);
context->VSSetShader(fsqVS, 0, 0);
switch (drawMode)
{
case DRAW_NORMAL:
context->PSSetShader(fsqPS, 0, 0);
break;
case DRAW_NO_AO:
context->PSSetShader(fsqNOOcclusionPS, 0, 0);
break;
case DRAW_AO_ONLY:
context->PSSetShader(fsqOcclusionPS, 0, 0);
break;
default:
break;
}
context->IASetInputLayout(fsqlayout);
colorRT.PSSetSRV(0);
normalRT.PSSetSRV(1);
positionRT.PSSetSRV(2);
context->PSSetShaderResources(3, 1, &depthBufferView);
context->PSSetShaderResources(4, 1, &voxelSRV);
context->PSSetConstantBuffers(0, 1, &voxelSampleKernel);
context->PSSetConstantBuffers(1, 1, &sampleConstBuffer);
context->PSSetConstantBuffers(2, 1, &voxelOptionConstBuffer);
context->RSSetState(RSStateSolid);
timer->Start();
context->DrawInstanced(3, 1, 0, 0);
timer->Stop();
collectedAOTime += (float)timer->GetTime();
//Unbind depth from input
ID3D11ShaderResourceView* SRVzero[] = { 0 };
context->PSSetShaderResources(3, 1, SRVzero);
//Set up some things for DXTK, to draw some lines or other primitives
context->OMSetRenderTargets(1, &backBuffer, depthStencilView);
basicEffect->SetView(XMLoadFloat4x4(&camera.GetCamData().viewMat));
basicEffect->Apply(context);
context->IASetInputLayout(basicInputLayout);
voxelCounter = 0;
if(enableDebugDraw)
DrawVoxels(primitiveBatch);
if(enableDrawKernel)
DrawKernel(primitiveBatch);
TwRefreshBar(antbar);
TwDraw();
swapChain->Present(0, 0);
//Unbind all resources
context->PSSetShaderResources(0, 1, SRVzero);
context->PSSetShaderResources(1, 1, SRVzero);
context->PSSetShaderResources(2, 1, SRVzero);
context->PSSetShaderResources(3, 1, SRVzero);
context->PSSetShaderResources(4, 1, SRVzero);
}
std::cout << "Exiting program!" << std::endl;
//Cleanup
delete primitiveBatch;
delete basicEffect;
delete timer;
#ifdef ENABLE_VOXELDRAW
delete[] voxelCPUstructure;
#endif
depthStencilView->Release();
RSStateSolid->Release();
RSStateWireframe->Release();
voxelBlendState->Release();
voxelStagingStructure->Release();
voxelSampleKernel->Release();
voxelClearBuffer->Release();
voxelSRV->Release();
fsqVS->Release();
fsqPS->Release();
fsqOcclusionPS->Release();
fsqNOOcclusionPS->Release();
camConstBuffer->Release();
sampleConstBuffer->Release();
voxelOptionConstBuffer->Release();
depthBufferView->Release();
layout->Release();
fsqlayout->Release();
voxelLayout->Release();
linearSamplerState->Release();
VS->Release();
PS->Release();
voxelVS->Release();
voxelGS->Release();
voxelPS->Release();
voxelStructure->Release();
voxelUAV->Release();
voxelMatBuffer->Release();
swapChain->Release();
backBuffer->Release();
device->Release();
context->Release();
basicInputLayout->Release();
SDL_DestroyWindow(window);
return 0;
}
int main(int argc, char** argv)
{
LOG_INFO("RiftRay version %s", pRiftRayVersion);
#if defined(_WIN32)
LOG_INFO("Windows build.");
#elif defined(_LINUX)
LOG_INFO("Linux build.");
#elif defined(_MACOS)
LOG_INFO("MacOS build.");
#endif
bool useOpenGLCoreContext = false;
g_renderMode.outputType = RenderingMode::OVR_SDK;
#ifdef USE_CORE_CONTEXT
useOpenGLCoreContext = true;
#endif
#ifdef _LINUX
// Linux driver seems to be lagging a bit
useOpenGLCoreContext = false;
#endif
LOG_INFO("Using GLFW3 backend.");
LOG_INFO("Compiled against GLFW %i.%i.%i",
GLFW_VERSION_MAJOR,
GLFW_VERSION_MINOR,
GLFW_VERSION_REVISION);
int major, minor, revision;
glfwGetVersion(&major, &minor, &revision);
LOG_INFO("Running against GLFW %i.%i.%i", major, minor, revision);
LOG_INFO("glfwGetVersionString: %s", glfwGetVersionString());
// Command line options
for (int i=0; i<argc; ++i)
{
const std::string a = argv[i];
LOG_INFO("argv[%d]: %s", i, a.c_str());
if (!a.compare("-sdk"))
{
g_renderMode.outputType = RenderingMode::OVR_SDK;
}
else if (!a.compare("-client"))
{
g_renderMode.outputType = RenderingMode::OVR_Client;
}
else if (!a.compare("-core"))
{
useOpenGLCoreContext = true;
}
else if (!a.compare("-compat"))
{
useOpenGLCoreContext = false;
}
}
LoadConfigFile();
g_app.initHMD();
GLFWwindow* l_Window = NULL;
glfwSetErrorCallback(ErrorCallback);
if (!glfwInit())
{
exit(EXIT_FAILURE);
}
#ifdef __APPLE__
// Set the working directory to the Resources dir of the .app bundle
CFBundleRef mainBundle = CFBundleGetMainBundle();
CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(mainBundle);
char path[PATH_MAX];
CFURLGetFileSystemRepresentation(resourcesURL, TRUE, (UInt8 *)path, PATH_MAX);
CFRelease(resourcesURL);
strcat( path, "/shaders" );
struct stat sb;
if (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode))
chdir(path);
#endif
#ifndef _LINUX
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
# if defined(_MACOS)
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
# else
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
# endif
#endif //ndef _LINUX
if (useOpenGLCoreContext)
{
LOG_INFO("Using OpenGL core context.");
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
}
else
{
#ifndef _LINUX
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_COMPAT_PROFILE);
#endif
}
glfwWindowHint(GLFW_SAMPLES, 0);
#ifdef _DEBUG
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
#endif
std::string windowTitle = "RiftRay-v" + std::string(pRiftRayVersion);
#ifdef USE_OCULUSSDK
const ovrSizei sz = g_app.getHmdResolution();
const ovrVector2i pos = g_app.getHmdWindowPos();
if (g_app.UsingDebugHmd() == true)
{
// Create a normal, decorated application window
LOG_INFO("Using Debug HMD mode.");
windowTitle += "-GLFW-DebugHMD";
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), NULL, NULL);
g_app.m_dashScene.m_bDraw = false;
g_renderMode.outputType = RenderingMode::Mono_Buffered;
}
else if (g_app.UsingDirectMode())
{
LOG_INFO("Using Direct to Rift mode.");
windowTitle += "-GLFW-Direct";
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), NULL, NULL);
#if defined(_WIN32)
g_app.AttachToWindow((void*)glfwGetWin32Window(l_Window));
#endif
}
else
{
LOG_INFO("Using Extended desktop mode.");
windowTitle += "-GLFW-Extended";
glfwWindowHint(GLFW_DECORATED, 0);
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), NULL, NULL);
glfwWindowHint(GLFW_DECORATED, 1);
glfwSetWindowPos(l_Window, pos.x, pos.y);
}
resize(l_Window, sz.w, sz.h); // inform AppSkeleton of window size
#else
const glm::vec2 sz(800, 600);
// Create a normal, decorated application window
LOG_INFO("Using No VR SDK.");
windowTitle += "-GLFW-NoVRSDK";
g_renderMode.outputType = RenderingMode::Mono_Buffered;
l_Window = glfwCreateWindow(sz.x, sz.y, windowTitle.c_str(), NULL, NULL);
resize(l_Window, sz.x, sz.y); // inform AppSkeleton of window size
#endif //USE_OSVR|USE_OCULUSSDK
if (!l_Window)
{
LOG_INFO("Glfw failed to create a window. Exiting.");
glfwTerminate();
exit(EXIT_FAILURE);
}
#ifdef USE_OCULUSSDK
// Required for SDK rendering (to do the buffer swap on its own)
# if defined(_WIN32)
g_app.setWindow(glfwGetWin32Window(l_Window));
# elif defined(__linux__)
g_app.setWindow(glfwGetX11Display());
# endif
#endif
glfwMakeContextCurrent(l_Window);
glfwSetWindowSizeCallback(l_Window, resize);
glfwSetMouseButtonCallback(l_Window, mouseDown);
glfwSetCursorPosCallback(l_Window, mouseMove);
glfwSetScrollCallback(l_Window, mouseWheel);
glfwSetKeyCallback(l_Window, keyboard);
memset(m_keyStates, 0, GLFW_KEY_LAST*sizeof(int));
FindPreferredJoystick();
// Log system monitor information
const GLFWmonitor* pPrimary = glfwGetPrimaryMonitor();
int monitorCount = 0;
GLFWmonitor** ppMonitors = glfwGetMonitors(&monitorCount);
for (int i=0; i<monitorCount; ++i)
{
GLFWmonitor* pCur = ppMonitors[i];
const GLFWvidmode* mode = glfwGetVideoMode(pCur);
if (mode != NULL)
{
LOG_INFO("Monitor #%d: %dx%d @ %dHz %s",
i,
mode->width,
mode->height,
mode->refreshRate,
pCur==pPrimary ? "Primary":"");
}
}
printGLContextInfo(l_Window);
glfwMakeContextCurrent(l_Window);
g_pHMDWindow = l_Window;
// Don't forget to initialize Glew, turn glewExperimental on to
// avoid problems fetching function pointers...
glewExperimental = GL_TRUE;
const GLenum l_Result = glewInit();
if (l_Result != GLEW_OK)
{
LOG_INFO("glewInit() error.");
exit(EXIT_FAILURE);
}
#ifdef _DEBUG
// Debug callback initialization
// Must be done *after* glew initialization.
glDebugMessageCallback(myCallback, NULL);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_MARKER, 0,
GL_DEBUG_SEVERITY_NOTIFICATION, -1, "Start debugging");
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
#endif
#ifdef USE_ANTTWEAKBAR
LOG_INFO("Using AntTweakbar.");
TwInit(useOpenGLCoreContext ? TW_OPENGL_CORE : TW_OPENGL, NULL);
InitializeBar();
#endif
LOG_INFO("Calling initGL...");
g_app.initGL();
LOG_INFO("Calling initVR...");
g_app.initVR();
LOG_INFO("initVR complete.");
SetVsync(1); // default to vsync on
StartShaderLoad();
while (!glfwWindowShouldClose(l_Window))
{
const bool tapped = g_app.CheckForTapOnHmd();
if (tapped && (g_receivedFirstTap == false))
{
g_app.RecenterPose();
g_receivedFirstTap = true;
}
glfwPollEvents();
joystick();
timestep();
g_fps.OnFrame();
if (g_dynamicallyScaleFBO)
{
DynamicallyScaleFBO();
}
#ifdef USE_ANTTWEAKBAR
TwRefreshBar(g_pTweakbar);
TwRefreshBar(g_pShaderTweakbar);
#endif
displayToHMD();
#ifndef _LINUX
// Indicate FPS in window title
// This is absolute death for performance in Ubuntu Linux 12.04
{
std::ostringstream oss;
oss << windowTitle
<< " "
<< static_cast<int>(g_fps.GetFPS())
<< " fps";
glfwSetWindowTitle(l_Window, oss.str().c_str());
if (g_AuxWindow != NULL)
glfwSetWindowTitle(g_AuxWindow, oss.str().c_str());
}
#endif
const float dumpInterval = 1.f;
if (g_logDumpTimer.seconds() > dumpInterval)
{
LOG_INFO("Frame rate: %d fps", static_cast<int>(g_fps.GetFPS()));
g_logDumpTimer.reset();
}
// Optionally display to auxiliary mono view
if (g_AuxWindow != NULL)
{
glfwMakeContextCurrent(g_AuxWindow);
glClearColor(0.f, 0.f, 0.f, 0.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
///@note VAOs *cannot* be shared between contexts.
///@note GLFW windows are inextricably tied to their own unique context.
/// For these two reasons, calling draw a third time for the auxiliary window
/// is not possible. Furthermore, it is not strictly desirable for the extra
/// rendering cost.
/// Instead, we share the render target texture from the stereo render and present
/// just the left eye to the aux window.
if (g_drawToAuxWindow)
{
presentSharedFboTexture();
}
#ifdef USE_ANTTWEAKBAR
TwDraw(); ///@todo Should this go first? Will it write to a depth buffer?
#endif
glfwSwapBuffers(g_AuxWindow);
if (glfwWindowShouldClose(g_AuxWindow))
{
destroyAuxiliaryWindow(g_AuxWindow);
}
// Set context to Rift window when done
glfwMakeContextCurrent(l_Window);
}
}
g_app.exitVR();
glfwDestroyWindow(l_Window);
glfwTerminate();
exit(EXIT_SUCCESS);
}
ofxTweakbar* ofxTweakbar::refresh() {
TwRefreshBar(getBar());
return this;
}
int main(int argc, char** argv)
{
#if defined(_WIN32)
LOG_INFO("Windows build.");
#elif defined(_LINUX)
LOG_INFO("Linux build.");
#elif defined(_MACOS)
LOG_INFO("MacOS build.");
#endif
bool useOpenGLCoreContext = false;
#ifdef USE_CORE_CONTEXT
useOpenGLCoreContext = true;
#endif
g_renderMode.outputType = RenderingMode::OVR_SDK;
LOG_INFO("Using GLFW3 backend.");
LOG_INFO("Compiled against GLFW %i.%i.%i",
GLFW_VERSION_MAJOR,
GLFW_VERSION_MINOR,
GLFW_VERSION_REVISION);
int major, minor, revision;
glfwGetVersion(&major, &minor, &revision);
LOG_INFO("Running against GLFW %i.%i.%i", major, minor, revision);
LOG_INFO("glfwGetVersionString: %s", glfwGetVersionString());
// Command line options
for (int i=0; i<argc; ++i)
{
const std::string a = argv[i];
LOG_INFO("argv[%d]: %s", i, a.c_str());
if (!a.compare("-sdk"))
{
g_renderMode.outputType = RenderingMode::OVR_SDK;
}
else if (!a.compare("-client"))
{
g_renderMode.outputType = RenderingMode::OVR_Client;
}
else if (!a.compare("-core"))
{
useOpenGLCoreContext = true;
}
else if (!a.compare("-compat"))
{
useOpenGLCoreContext = false;
}
}
#ifdef USE_OCULUSSDK
g_app.initHMD();
#else
g_renderMode.outputType = RenderingMode::Mono_Buffered;
#endif
GLFWwindow* l_Window = NULL;
glfwSetErrorCallback(ErrorCallback);
if (!glfwInit())
{
exit(EXIT_FAILURE);
}
// Log system monitor information
const GLFWmonitor* pPrimary = glfwGetPrimaryMonitor();
int monitorCount = 0;
GLFWmonitor** ppMonitors = glfwGetMonitors(&monitorCount);
for (int i=0; i<monitorCount; ++i)
{
GLFWmonitor* pCur = ppMonitors[i];
const GLFWvidmode* mode = glfwGetVideoMode(pCur);
if (mode != NULL)
{
(void)pPrimary;
LOG_INFO("Monitor #%d: %dx%d @ %dHz %s",
i,
mode->width,
mode->height,
mode->refreshRate,
pCur==pPrimary ? "Primary":"");
}
}
bool swapBackBufferDims = false;
// Context setup - before window creation
glfwWindowHint(GLFW_DEPTH_BITS, 16);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, useOpenGLCoreContext ? GLFW_OPENGL_CORE_PROFILE : GLFW_OPENGL_COMPAT_PROFILE);
//glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#ifdef _DEBUG
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
#endif
#if defined(USE_OSVR)
std::string windowTitle = "";
windowTitle = PROJECT_NAME "-GLFW-Osvr";
if (g_app.UsingDebugHmd())
{
const hmdRes sz = { 800, 600 };
// Create a normal, decorated application window
LOG_INFO("Using Debug HMD mode.");
windowTitle = PROJECT_NAME "-GLFW-DebugHMD";
g_renderMode.outputType = RenderingMode::Mono_Buffered;
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), NULL, NULL);
}
else
{
const hmdRes sz = {
g_app.getHmdResolution().h,
g_app.getHmdResolution().w
};
const winPos pos = g_app.getHmdWindowPos();
g_renderMode.outputType = RenderingMode::SideBySide_Undistorted;
LOG_INFO("Using Extended desktop mode.");
windowTitle = PROJECT_NAME "-GLFW-Extended";
LOG_INFO("Creating GLFW_DECORATED window %dx%d@%d,%d", sz.w, sz.h, pos.x, pos.y);
glfwWindowHint(GLFW_DECORATED, 0);
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), NULL, NULL);
glfwWindowHint(GLFW_DECORATED, 1);
glfwSetInputMode(l_Window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetWindowPos(l_Window, pos.x, pos.y);
}
#elif defined(OVRSDK06)
std::string windowTitle = "";
LOG_INFO("Using SDK 0.6.0.0's direct mode.");
windowTitle = PROJECT_NAME "-GLFW-06-Direct";
GLFWmonitor* monitor = glfwGetPrimaryMonitor();
const GLFWvidmode* mode = glfwGetVideoMode(monitor);
ovrSizei sz;
ovrVector2i pos;
sz.w = mode->width/2;
sz.h = mode->height/2;
pos.x = 100;
pos.y = 100;
// Create just a regular window for presenting OVR SDK 0.6's mirror texture
///@todo Is it any faster with no mirror at all?
LOG_INFO("Creating window %dx%d@%d,%d", sz.w, sz.h, pos.x, pos.y);
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), NULL, NULL);
g_app.SetAppWindowSize(sz);
#else
l_Window = glfwCreateWindow(800, 600, "GLFW Oculus Rift Test", NULL, NULL);
std::string windowTitle = PROJECT_NAME;
#endif //USE_OSVR|OVRSDK06
if (!l_Window)
{
LOG_INFO("Glfw failed to create a window. Exiting.");
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(l_Window);
glfwSetWindowSizeCallback(l_Window, resize_Aux);
glfwSetMouseButtonCallback(l_Window, mouseDown_Aux);
glfwSetCursorPosCallback(l_Window, mouseMove_Aux);
glfwSetScrollCallback(l_Window, mouseWheel_Aux);
glfwSetKeyCallback(l_Window, keyboard_Aux);
memset(m_keyStates, 0, GLFW_KEY_LAST*sizeof(int));
// joysticks
for (int i = GLFW_JOYSTICK_1; i <= GLFW_JOYSTICK_LAST; ++i)
{
if (GL_FALSE == glfwJoystickPresent(i))
continue;
const char* pJoyName = glfwGetJoystickName(i);
if (pJoyName == NULL)
continue;
int numAxes = 0;
int numButtons = 0;
glfwGetJoystickAxes(i, &numAxes);
glfwGetJoystickButtons(i, &numButtons);
LOG_INFO("Glfw opened Joystick #%d: %s w/ %d axes, %d buttons", i, pJoyName, numAxes, numButtons);
if (g_joystickIdx == -1)
g_joystickIdx = i;
}
printGLContextInfo(l_Window);
glfwMakeContextCurrent(l_Window);
g_pHMDWindow = l_Window;
// Don't forget to initialize Glew, turn glewExperimental on to
// avoid problems fetching function pointers...
glewExperimental = GL_TRUE;
const GLenum l_Result = glewInit();
if (l_Result != GLEW_OK)
{
LOG_INFO("glewInit() error.");
exit(EXIT_FAILURE);
}
#ifdef _DEBUG
// Debug callback initialization
// Must be done *after* glew initialization.
glDebugMessageCallback(myCallback, NULL);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_MARKER, 0,
GL_DEBUG_SEVERITY_NOTIFICATION, -1 , "Start debugging");
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
#endif
#ifdef USE_ANTTWEAKBAR
LOG_INFO("Using AntTweakbar.");
TwInit(useOpenGLCoreContext ? TW_OPENGL_CORE : TW_OPENGL, NULL);
InitializeBar();
#endif
LOG_INFO("Calling initGL...");
g_app.initGL();
LOG_INFO("Calling initVR...");
g_app.initVR(swapBackBufferDims);
LOG_INFO("initVR(%d) complete.", swapBackBufferDims);
SetVsync(0); // SDK 0.6 requires vsync OFF
while (!glfwWindowShouldClose(l_Window))
{
g_app.CheckForTapToDismissHealthAndSafetyWarning();
glfwPollEvents();
joystick();
timestep();
g_fps.OnFrame();
if (g_dynamicallyScaleFBO)
{
DynamicallyScaleFBO();
}
#ifdef USE_ANTTWEAKBAR
TwRefreshBar(g_pTweakbar);
#endif
g_app.pre_render_pass();
displayToHMD();
#ifndef _LINUX
// Indicate FPS in window title
// This is absolute death for performance in Ubuntu Linux 12.04
{
std::ostringstream oss;
oss << windowTitle
<< " "
<< static_cast<int>(g_fps.GetFPS())
<< " fps";
glfwSetWindowTitle(l_Window, oss.str().c_str());
}
#endif
const float dumpInterval = 1.f;
if (g_logDumpTimer.seconds() > dumpInterval)
{
LOG_INFO("Frame rate: %d fps", static_cast<int>(g_fps.GetFPS()));
g_logDumpTimer.reset();
}
}
g_app.exitVR();
glfwDestroyWindow(l_Window);
glfwTerminate();
exit(EXIT_SUCCESS);
}
int main(int argc, char** argv)
{
#if defined(_WIN32)
LOG_INFO("Windows build.");
#elif defined(_LINUX)
LOG_INFO("Linux build.");
LOG_INFO("DISPLAY=%s", getenv("DISPLAY"));
#elif defined(_MACOS)
LOG_INFO("MacOS build.");
#endif
bool useOpenGLCoreContext = false;
#ifdef USE_CORE_CONTEXT
useOpenGLCoreContext = true;
#endif
g_renderMode.outputType = RenderingMode::OVR_SDK;
LOG_INFO("Using GLFW3 backend.");
LOG_INFO("Compiled against GLFW %i.%i.%i",
GLFW_VERSION_MAJOR,
GLFW_VERSION_MINOR,
GLFW_VERSION_REVISION);
int major, minor, revision;
glfwGetVersion(&major, &minor, &revision);
LOG_INFO("Running against GLFW %i.%i.%i", major, minor, revision);
LOG_INFO("glfwGetVersionString: %s", glfwGetVersionString());
// Command line options
for (int i=0; i<argc; ++i)
{
const std::string a = argv[i];
LOG_INFO("argv[%d]: %s", i, a.c_str());
if (!a.compare("-sdk"))
{
g_renderMode.outputType = RenderingMode::OVR_SDK;
}
else if (!a.compare("-client"))
{
g_renderMode.outputType = RenderingMode::OVR_Client;
}
else if (!a.compare("-core"))
{
useOpenGLCoreContext = true;
}
else if (!a.compare("-compat"))
{
useOpenGLCoreContext = false;
}
}
#ifdef USE_OCULUSSDK
g_app.initHMD();
#else
g_renderMode.outputType = RenderingMode::Mono_Buffered;
#endif
GLFWwindow* l_Window = NULL;
glfwSetErrorCallback(ErrorCallback);
if (!glfwInit())
{
exit(EXIT_FAILURE);
}
// Log system monitor information
const GLFWmonitor* pPrimary = glfwGetPrimaryMonitor();
int monitorCount = 0;
GLFWmonitor** ppMonitors = glfwGetMonitors(&monitorCount);
for (int i=0; i<monitorCount; ++i)
{
GLFWmonitor* pCur = ppMonitors[i];
const GLFWvidmode* mode = glfwGetVideoMode(pCur);
if (mode != NULL)
{
(void)pPrimary;
LOG_INFO("Monitor #%d: %dx%d @ %dHz %s",
i,
mode->width,
mode->height,
mode->refreshRate,
pCur==pPrimary ? "Primary":"");
}
}
bool swapBackBufferDims = false;
// Context setup - before window creation
glfwWindowHint(GLFW_DEPTH_BITS, 16);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, useOpenGLCoreContext ? GLFW_OPENGL_CORE_PROFILE : GLFW_OPENGL_COMPAT_PROFILE);
//glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#ifdef _DEBUG
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
#endif
#if defined(USE_OSVR)
LOG_INFO("USE_OSVR=1");
std::string windowTitle = "";
windowTitle = PROJECT_NAME "-GLFW-Osvr";
if (g_app.UsingDebugHmd())
{
const hmdRes sz = { 800, 600 };
// Create a normal, decorated application window
LOG_INFO("Using Debug HMD mode.");
windowTitle = PROJECT_NAME "-GLFW-DebugHMD";
g_renderMode.outputType = RenderingMode::Mono_Buffered;
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), NULL, NULL);
}
else
{
const hmdRes sz = {
g_app.getHmdResolution().h,
g_app.getHmdResolution().w
};
const winPos pos = g_app.getHmdWindowPos();
g_renderMode.outputType = RenderingMode::SideBySide_Undistorted;
LOG_INFO("Using Extended desktop mode.");
windowTitle = PROJECT_NAME "-GLFW-Extended";
LOG_INFO("Creating GLFW_DECORATED window %dx%d@%d,%d", sz.w, sz.h, pos.x, pos.y);
glfwWindowHint(GLFW_DECORATED, 0);
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), NULL, NULL);
glfwWindowHint(GLFW_DECORATED, 1);
glfwSetInputMode(l_Window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetWindowPos(l_Window, pos.x, pos.y);
}
#elif defined(USE_OCULUSSDK)
LOG_INFO("USE_OCULUSSDK=1");
ovrSizei sz = g_app.getHmdResolution();
const ovrVector2i pos = g_app.getHmdWindowPos();
std::string windowTitle = "";
if (g_app.UsingDebugHmd() == true)
{
// Create a normal, decorated application window
LOG_INFO("Using Debug HMD mode.");
windowTitle = PROJECT_NAME "-GLFW-DebugHMD";
g_renderMode.outputType = RenderingMode::Mono_Buffered;
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), NULL, NULL);
}
else if (g_app.UsingDirectMode())
{
// HMD active - position undecorated window to fill HMD viewport
LOG_INFO("Using Direct to Rift mode.");
windowTitle = PROJECT_NAME "-GLFW-Direct";
GLFWmonitor* monitor = glfwGetPrimaryMonitor();
const GLFWvidmode* mode = glfwGetVideoMode(monitor);
sz.w = mode->width;
sz.h = mode->height;
LOG_INFO("Creating window %dx%d@%d,%d", sz.w, sz.h, pos.x, pos.y);
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), monitor, NULL);
glfwSetInputMode(l_Window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
#ifdef _LINUX
swapBackBufferDims = true;
#endif
#if defined(_WIN32)
g_app.AttachToWindow((void*)glfwGetWin32Window(l_Window));
#endif
}
else
{
LOG_INFO("Using Extended desktop mode.");
windowTitle = PROJECT_NAME "-GLFW-Extended";
LOG_INFO("Creating GLFW_DECORATED window %dx%d@%d,%d", sz.w, sz.h, pos.x, pos.y);
glfwWindowHint(GLFW_DECORATED, 0);
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), NULL, NULL);
glfwWindowHint(GLFW_DECORATED, 1);
glfwSetInputMode(l_Window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetWindowPos(l_Window, pos.x, pos.y);
}
resize(l_Window, sz.w, sz.h); // inform AppSkeleton of window size
#else
const glm::vec2 sz(800, 600);
// Create a normal, decorated application window
LOG_INFO("Using No VR SDK.");
const std::string windowTitle = PROJECT_NAME "-GLFW-NoVRSDK";
g_renderMode.outputType = RenderingMode::Mono_Buffered;
l_Window = glfwCreateWindow(sz.x, sz.y, windowTitle.c_str(), NULL, NULL);
#endif //USE_OSVR|USE_OCULUSSDK
if (!l_Window)
{
LOG_INFO("Glfw failed to create a window. Exiting.");
glfwTerminate();
exit(EXIT_FAILURE);
}
// Required for SDK rendering (to do the buffer swap on its own)
#ifdef OVRSDK05
#if defined(_WIN32)
g_app.setWindow(glfwGetWin32Window(l_Window));
#elif defined(__linux__)
g_app.setWindow(NULL);//glfwGetX11Display());
#endif
#endif //USE_OCULUSSDK
glfwMakeContextCurrent(l_Window);
glfwSetWindowSizeCallback(l_Window, resize);
glfwSetMouseButtonCallback(l_Window, mouseDown);
glfwSetCursorPosCallback(l_Window, mouseMove);
glfwSetScrollCallback(l_Window, mouseWheel);
glfwSetKeyCallback(l_Window, keyboard);
memset(m_keyStates, 0, GLFW_KEY_LAST*sizeof(int));
// joysticks
for (int i = GLFW_JOYSTICK_1; i <= GLFW_JOYSTICK_LAST; ++i)
{
if (GL_FALSE == glfwJoystickPresent(i))
continue;
const char* pJoyName = glfwGetJoystickName(i);
if (pJoyName == NULL)
continue;
int numAxes = 0;
int numButtons = 0;
glfwGetJoystickAxes(i, &numAxes);
glfwGetJoystickButtons(i, &numButtons);
LOG_INFO("Glfw opened Joystick #%d: %s w/ %d axes, %d buttons", i, pJoyName, numAxes, numButtons);
if (g_joystickIdx == -1)
g_joystickIdx = i;
}
printGLContextInfo(l_Window);
glfwMakeContextCurrent(l_Window);
g_pHMDWindow = l_Window;
// Don't forget to initialize Glew, turn glewExperimental on to
// avoid problems fetching function pointers...
glewExperimental = GL_TRUE;
const GLenum l_Result = glewInit();
if (l_Result != GLEW_OK)
{
LOG_INFO("glewInit() error.");
exit(EXIT_FAILURE);
}
#ifdef _DEBUG
// Debug callback initialization
// Must be done *after* glew initialization.
glDebugMessageCallback(myCallback, NULL);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_MARKER, 0,
GL_DEBUG_SEVERITY_NOTIFICATION, -1 , "Start debugging");
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
#endif
#ifdef USE_ANTTWEAKBAR
LOG_INFO("Using AntTweakbar.");
TwInit(useOpenGLCoreContext ? TW_OPENGL_CORE : TW_OPENGL, NULL);
InitializeBar();
#endif
LOG_INFO("Calling initGL...");
g_app.initGL();
LOG_INFO("Calling initVR...");
g_app.initVR(swapBackBufferDims);
LOG_INFO("initVR(%d) complete.", swapBackBufferDims);
while (!glfwWindowShouldClose(l_Window))
{
g_app.CheckForTapToDismissHealthAndSafetyWarning();
glfwPollEvents();
joystick();
timestep();
g_fps.OnFrame();
if (g_dynamicallyScaleFBO)
{
DynamicallyScaleFBO();
}
#ifdef USE_ANTTWEAKBAR
TwRefreshBar(g_pTweakbar);
#endif
displayToHMD();
#ifndef _LINUX
// Indicate FPS in window title
// This is absolute death for performance in Ubuntu Linux 12.04
{
std::ostringstream oss;
oss << windowTitle
<< " "
<< static_cast<int>(g_fps.GetFPS())
<< " fps";
glfwSetWindowTitle(l_Window, oss.str().c_str());
if (g_AuxWindow != NULL)
glfwSetWindowTitle(g_AuxWindow, oss.str().c_str());
}
#endif
const float dumpInterval = 1.f;
if (g_logDumpTimer.seconds() > dumpInterval)
{
LOG_INFO("Frame rate: %d fps", static_cast<int>(g_fps.GetFPS()));
g_logDumpTimer.reset();
}
// Optionally display to auxiliary mono view
if (g_AuxWindow != NULL)
{
glfwMakeContextCurrent(g_AuxWindow);
glClearColor(0.f, 0.f, 0.f, 0.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
///@note VAOs *cannot* be shared between contexts.
///@note GLFW windows are inextricably tied to their own unique context.
/// For these two reasons, calling draw a third time for the auxiliary window
/// is not possible. Furthermore, it is not strictly desirable for the extra
/// rendering cost.
/// Instead, we share the render target texture from the stereo render and present
/// just the left eye to the aux window.
if (g_drawToAuxWindow)
{
presentSharedFboTexture();
}
#ifdef USE_ANTTWEAKBAR
TwDraw(); ///@todo Should this go first? Will it write to a depth buffer?
#endif
glfwSwapBuffers(g_AuxWindow);
if (glfwWindowShouldClose(g_AuxWindow))
{
destroyAuxiliaryWindow(g_AuxWindow);
}
// Set context to Rift window when done
glfwMakeContextCurrent(l_Window);
}
}
g_app.exitVR();
glfwDestroyWindow(l_Window);
glfwTerminate();
exit(EXIT_SUCCESS);
}
