// Handle any control callback events
//-----------------------------------------------------------------------------
void MySample::HandleCallbackEvent( CPUTEventID Event, CPUTControlID ControlID, CPUTControl *pControl )
{
UNREFERENCED_PARAMETER(Event);
UNREFERENCED_PARAMETER(pControl);
std::string SelectedItem;
static bool resize = false;
switch(ControlID)
{
case ID_FULLSCREEN_BUTTON:
CPUTToggleFullScreenMode();
break;
default:
break;
}
MenuController_HandleCPUTEvent(Event, ControlID, pControl);
}
// Create a window context
//-----------------------------------------------------------------------------
CPUTResult CPUT_DX11::CPUTCreateWindowAndContext(const cString WindowTitle, CPUTWindowCreationParams windowParams)
{
CPUTResult result = CPUT_SUCCESS;
HEAPCHECK;
// create the window
result = MakeWindow(WindowTitle, windowParams.windowWidth, windowParams.windowHeight, windowParams.windowPositionX, windowParams.windowPositionY);
if(CPUTFAILED(result))
{
return result;
}
HEAPCHECK;
// create the DX context
result = CreateDXContext(windowParams.deviceParams);
if(CPUTFAILED(result))
{
return result;
}
CPUTModelDX11::CreateModelConstantBuffer();
HEAPCHECK;
#define ENABLE_GUI
#ifdef ENABLE_GUI
// initialize the gui controller
// Use the ResourceDirectory that was given during the Initialize() function
// to locate the GUI+font resources
CPUTGuiControllerDX11 *pGUIController = CPUTGuiControllerDX11::GetController();
cString ResourceDirectory = GetCPUTResourceDirectory();
result = pGUIController->Initialize(mpContext, ResourceDirectory);
if(CPUTFAILED(result))
{
return result;
}
// register the callback object for GUI events as our sample
CPUTGuiControllerDX11::GetController()->SetCallback(this);
#endif
HEAPCHECK;
DrawLoadingFrame();
HEAPCHECK;
// warn the user they are using the software rasterizer
if((D3D_DRIVER_TYPE_REFERENCE == mdriverType) || (D3D_DRIVER_TYPE_WARP == mdriverType))
{
CPUTOSServices::GetOSServices()->OpenMessageBox(_L("Performance warning"), _L("Your graphics hardware does not support the DirectX features required by this sample. The sample is now running using the DirectX software rasterizer."));
}
// trigger a post-create user callback event
HEAPCHECK;
Create();
HEAPCHECK;
//
// Start the timer after everything is initialized and assets have been loaded
//
mpTimer->StartTimer();
// if someone triggers the shutdown routine in on-create, exit
if(mbShutdown)
{
return result;
}
// does user want to start in fullscreen mode?
if(true == windowParams.startFullscreen)
{
result = CPUTToggleFullScreenMode();
if(CPUTFAILED(result))
{
return result;
}
}
// fill first frame with clear values so render order later is ok
const float srgbClearColor[] = { 0.0993f, 0.0993f, 0.0993f, 1.0f };
mpContext->ClearRenderTargetView( mpBackBufferRTV, srgbClearColor );
mpContext->ClearDepthStencilView(mpDepthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 0.0f, 0);
// trigger a 'resize' event
int x,y,width,height;
CPUTOSServices::GetOSServices()->GetClientDimensions(&x, &y, &width, &height);
ResizeWindow(width,height);
return result;
}
// Handle any control callback events
//-----------------------------------------------------------------------------
void MySample::HandleCallbackEvent( CPUTEventID Event, CPUTControlID ControlID, CPUTControl *pControl )
{
UNREFERENCED_PARAMETER(Event);
UNREFERENCED_PARAMETER(pControl);
cString SelectedItem;
switch(ControlID)
{
case ID_FULLSCREEN_BUTTON:
{
CPUTToggleFullScreenMode();
break;
}
case ID_RASTERIZE_TYPE:
{
TaskCleanUp();
SAFE_DELETE_ARRAY(mpDBR);
SAFE_DELETE_ARRAY(mpAABB);
UINT selectedItem;
mpTypeDropDown->GetSelectedItem(selectedItem);
if(selectedItem - 1 == 0)
{
mSOCType = SCALAR_TYPE;
if(!mEnableTasks)
{
mpDBRScalarST = new DepthBufferRasterizerScalarST;
mpDBR = mpDBRScalarST;
mpAABBScalarST = new AABBoxRasterizerScalarST;
mpAABB = mpAABBScalarST;
}
else
{
mpDBRScalarMT = new DepthBufferRasterizerScalarMT;
mpDBR = mpDBRScalarMT;
mpAABBScalarMT = new AABBoxRasterizerScalarMT;
mpAABB = mpAABBScalarMT;
}
mpCPURenderTarget[0] = mpCPURenderTargetScalar[0];
mpCPURenderTarget[1] = mpCPURenderTargetScalar[1];
mpCPUSRV[0] = mpCPUSRVScalar[0];
mpCPUSRV[1] = mpCPUSRVScalar[1];
mpShowDepthBufMtrl = mpShowDepthBufMtrlScalar;
rowPitch = SCREENW * 4;
}
else if(selectedItem - 2 == 0)
{
mSOCType = SSE_TYPE;
if(!mEnableTasks)
{
mpDBRSSEST = new DepthBufferRasterizerSSEST;
mpDBR = mpDBRSSEST;
mpAABBSSEST = new AABBoxRasterizerSSEST;
mpAABB = mpAABBSSEST;
}
else
{
mpDBRSSEMT = new DepthBufferRasterizerSSEMT;
mpDBR = mpDBRSSEMT;
mpAABBSSEMT = new AABBoxRasterizerSSEMT;
mpAABB = mpAABBSSEMT;
}
mpCPURenderTarget[0] = mpCPURenderTargetSSE[0];
mpCPURenderTarget[1] = mpCPURenderTargetSSE[1];
mpCPUSRV[0] = mpCPUSRVSSE[0];
mpCPUSRV[1] = mpCPUSRVSSE[1];
mpShowDepthBufMtrl = mpShowDepthBufMtrlSSE;
rowPitch = 2 * SCREENW * 4;
}
mpDBR->CreateTransformedModels(mpAssetSetDBR, OCCLUDER_SETS);
mpDBR->SetOccluderSizeThreshold(mOccluderSizeThreshold);
mpDBR->SetEnableFCulling(mEnableFCulling);
mpDBR->SetCamera(mpCamera, mCurrId);
mpDBR->ResetInsideFrustum();
mpAABB->CreateTransformedAABBoxes(mpAssetSetAABB, OCCLUDEE_SETS);
mpAABB->SetDepthTestTasks(mNumDepthTestTasks);
mpAABB->SetOccludeeSizeThreshold(mOccludeeSizeThreshold);
mpAABB->SetEnableFCulling(mEnableFCulling);
mpAABB->SetCamera(mpCamera, mCurrId);
mpAABB->ResetInsideFrustum();
break;
}
case ID_DEPTH_BUFFER_VISIBLE:
{
TaskCleanUp();
CPUTCheckboxState state = mpDBCheckBox->GetCheckboxState();
if(state == CPUT_CHECKBOX_CHECKED)
{
mViewDepthBuffer = true;
}
else
{
mViewDepthBuffer = false;
}
break;
}
case ID_BOUNDING_BOX_VISIBLE:
{
CPUTCheckboxState state = mpBBCheckBox->GetCheckboxState();
if(state == CPUT_CHECKBOX_CHECKED)
{
mViewBoundingBox = true;
}
else
{
mViewBoundingBox = false;
}
break;
}
case ID_ENABLE_TASKS:
{
TaskCleanUp();
SAFE_DELETE_ARRAY(mpDBR);
SAFE_DELETE_ARRAY(mpAABB);
CPUTCheckboxState state = mpTasksCheckBox->GetCheckboxState();
if(state == CPUT_CHECKBOX_CHECKED)
{
mEnableTasks = true;
mpDepthTestTaskSlider->SetVisibility(true);
mpPipelineCheckBox->SetVisibility(true);
wchar_t string[CPUT_MAX_STRING_LENGTH];
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("Depth Test Task: \t%d"), mNumDepthTestTasks);
mpDepthTestTaskSlider->SetText(string);
if(mSOCType == SCALAR_TYPE)
{
mpDBRScalarMT = new DepthBufferRasterizerScalarMT;
mpDBR = mpDBRScalarMT;
mpAABBScalarMT = new AABBoxRasterizerScalarMT;
mpAABB = mpAABBScalarMT;
}
else if(mSOCType == SSE_TYPE)
{
mpDBRSSEMT = new DepthBufferRasterizerSSEMT;
mpDBR = mpDBRSSEMT;
mpAABBSSEMT = new AABBoxRasterizerSSEMT;
mpAABB = mpAABBSSEMT;
}
mpAABB->SetDepthTestTasks(mNumDepthTestTasks);
}
else
{
mEnableTasks = false;
mpDepthTestTaskSlider->SetVisibility(false);
mpPipelineCheckBox->SetVisibility(false);
if(mSOCType == SCALAR_TYPE)
{
mpDBRScalarST = new DepthBufferRasterizerScalarST;
mpDBR = mpDBRScalarST;
mpAABBScalarST = new AABBoxRasterizerScalarST;
mpAABB = mpAABBScalarST;
}
else if(mSOCType == SSE_TYPE)
{
mpDBRSSEST = new DepthBufferRasterizerSSEST;
mpDBR = mpDBRSSEST;
mpAABBSSEST = new AABBoxRasterizerSSEST;
mpAABB = mpAABBSSEST;
}
}
mpDBR->CreateTransformedModels(mpAssetSetDBR, OCCLUDER_SETS);
mpDBR->SetOccluderSizeThreshold(mOccluderSizeThreshold);
mpDBR->SetEnableFCulling(mEnableFCulling);
mpDBR->SetCamera(mpCamera, mCurrId);
mpDBR->ResetInsideFrustum();
mpAABB->CreateTransformedAABBoxes(mpAssetSetAABB, OCCLUDEE_SETS);
mpAABB->SetOccludeeSizeThreshold(mOccludeeSizeThreshold);
mpAABB->SetEnableFCulling(mEnableFCulling);
mpAABB->SetCamera(mpCamera, mCurrId);
mpAABB->ResetInsideFrustum();
break;
}
case ID_OCCLUDER_SIZE:
{
TaskCleanUp();
float occluderSize;
mpOccluderSizeSlider->GetValue(occluderSize);
mOccluderSizeThreshold = occluderSize;
wchar_t string[CPUT_MAX_STRING_LENGTH];
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("Occluder Size Threshold: %0.4f"), mOccluderSizeThreshold);
mpOccluderSizeSlider->SetText(string);
mpDBR->SetOccluderSizeThreshold(mOccluderSizeThreshold);
break;
}
case ID_OCCLUDEE_SIZE:
{
TaskCleanUp();
float occludeeSize;
mpOccludeeSizeSlider->GetValue(occludeeSize);
mOccludeeSizeThreshold = occludeeSize;
wchar_t string[CPUT_MAX_STRING_LENGTH];
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("Occludee Size Threshold: %0.4f"), mOccludeeSizeThreshold);
mpOccludeeSizeSlider->SetText(string);
mpAABB->SetOccludeeSizeThreshold(mOccludeeSizeThreshold);
break;
}
case ID_DEPTH_TEST_TASKS:
{
TaskCleanUp();
float numDepthTestTasks;
mpDepthTestTaskSlider->GetValue(numDepthTestTasks);
mNumDepthTestTasks = (UINT)numDepthTestTasks;
wchar_t string[CPUT_MAX_STRING_LENGTH];
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("Depth Test Task: \t\t%d"), mNumDepthTestTasks);
mpDepthTestTaskSlider->SetText(string);
mpAABB->SetDepthTestTasks(mNumDepthTestTasks);
break;
}
case ID_ENABLE_CULLING:
{
TaskCleanUp();
CPUTCheckboxState state = mpCullingCheckBox->GetCheckboxState();
if(state)
{
mEnableCulling = true;
mFirstFrame = true;
}
else
{
mEnableCulling = false;
mFirstFrame = false;
memset(mpCPUDepthBuf[mCurrId], 0, SCREENW * SCREENH *4);
mpOccludersR2DBText->SetText( _L("\tDepth rasterized models: 0"));
mpOccluderRasterizedTrisText->SetText(_L("\tDepth rasterized tris: \t0"));
mpRasterizeTimeText->SetText( _L("\tDepth rasterizer time: \t0 ms"));
mpCulledText->SetText( _L("\tModels culled: \t\t0"));
mpVisibleText->SetText( _L("\tModels visible: \t\t0"));
mpCulledTrisText->SetText( _L("\tCulled tris: \t\t0"));
mpVisibleTrisText->SetText( _L("\tVisible tris: \t\t0"));
mpDepthTestTimeText->SetText(_L("\tDepth test time: \t0 ms"));
mpTotalCullTimeText->SetText(_L("\tTotal Cull time: \t0 ms"));
}
break;
}
case ID_ENABLE_FCULLING:
{
TaskCleanUp();
CPUTCheckboxState state = mpFCullingCheckBox->GetCheckboxState();
if(state)
{
mEnableFCulling = true;
}
else
{
mEnableFCulling = false;
mpDBR->ResetInsideFrustum();
mpAABB->ResetInsideFrustum();
}
mpDBR->SetEnableFCulling(mEnableFCulling);
mpAABB->SetEnableFCulling(mEnableFCulling);
break;
}
case ID_VSYNC_ON_OFF:
{
CPUTCheckboxState state = mpVsyncCheckBox->GetCheckboxState();
if(state)
{
mSyncInterval = 1;
}
else
{
mSyncInterval = 0;
}
break;
}
case ID_PIPELINE:
{
TaskCleanUp();
CPUTCheckboxState state = mpPipelineCheckBox->GetCheckboxState();
if(state)
{
mPipeline = true;
mFirstFrame = true;
}
else
{
mPipeline = false;
}
break;
}
default:
break;
}
}
// Handle keyboard events
//-----------------------------------------------------------------------------
CPUTEventHandledCode MySample::HandleKeyboardEvent(CPUTKey key)
{
static bool panelToggle = false;
CPUTEventHandledCode handled = CPUT_EVENT_UNHANDLED;
cString fileName;
CPUTGuiControllerDX11* pGUI = CPUTGetGuiController();
switch(key)
{
case KEY_F1:
panelToggle = !panelToggle;
if(panelToggle)
{
pGUI->SetActivePanel(ID_SECONDARY_PANEL);
}
else
{
pGUI->SetActivePanel(ID_MAIN_PANEL);
}
handled = CPUT_EVENT_HANDLED;
break;
case KEY_L:
{
static int cameraObjectIndex = 0;
CPUTRenderNode *pCameraList[] = { mpCamera, mpShadowCamera };
cameraObjectIndex = (++cameraObjectIndex) % (sizeof(pCameraList)/sizeof(*pCameraList));
CPUTRenderNode *pCamera = pCameraList[cameraObjectIndex];
mpCameraController->SetCamera( pCamera );
}
handled = CPUT_EVENT_HANDLED;
break;
case KEY_ESCAPE:
handled = CPUT_EVENT_HANDLED;
Shutdown();
break;
case KEY_1:
{
CPUTToggleFullScreenMode();
break;
}
case KEY_2:
{
mEnableCulling = !mEnableCulling;
CPUTCheckboxState state;
if(mEnableCulling)
{
state = CPUT_CHECKBOX_CHECKED;
}
else
{
state = CPUT_CHECKBOX_UNCHECKED;
memset(mpCPUDepthBuf[mCurrId], 0, SCREENW * SCREENH *4);
mpOccludersR2DBText->SetText( _L("\tDepth rasterized models: 0"));
mpOccluderRasterizedTrisText->SetText(_L("\tDepth rasterized tris: \t0"));
mpRasterizeTimeText->SetText( _L("\tDepth rasterizer time: \t0 ms"));
mpCulledText->SetText( _L("\tModels culled: \t\t0"));
mpVisibleText->SetText( _L("\tModels visible: \t\t0"));
mpCulledTrisText->SetText( _L("\tCulled tris: \t\t0"));
mpVisibleTrisText->SetText( _L("\tVisible tris: \t\t0"));
mpDepthTestTimeText->SetText(_L("\tDepth test time: \t0 ms"));
}
mpCullingCheckBox->SetCheckboxState(state);
break;
}
case KEY_3:
{
mEnableFCulling = !mEnableFCulling;
CPUTCheckboxState state;
if(mEnableFCulling)
{
state = CPUT_CHECKBOX_CHECKED;
}
else
{
state = CPUT_CHECKBOX_UNCHECKED;
mpDBR->ResetInsideFrustum();
mpAABB->ResetInsideFrustum();
}
mpFCullingCheckBox->SetCheckboxState(state);
break;
}
case KEY_4:
{
mViewDepthBuffer = !mViewDepthBuffer;
CPUTCheckboxState state;
if(mViewDepthBuffer)
{
state = CPUT_CHECKBOX_CHECKED;
}
else
{
state = CPUT_CHECKBOX_UNCHECKED;
}
mpDBCheckBox->SetCheckboxState(state);
break;
}
case KEY_5:
{
mViewBoundingBox = !mViewBoundingBox;
CPUTCheckboxState state;
if(mViewBoundingBox)
{
state = CPUT_CHECKBOX_CHECKED;
}
else
{
state = CPUT_CHECKBOX_UNCHECKED;
}
mpBBCheckBox->SetCheckboxState(state);
break;
}
case KEY_6:
{
TaskCleanUp();
mEnableTasks = !mEnableTasks;
CPUTCheckboxState state;
SAFE_DELETE_ARRAY(mpDBR);
SAFE_DELETE_ARRAY(mpAABB);
if(mEnableTasks)
{
state = CPUT_CHECKBOX_CHECKED;
mpPipelineCheckBox->SetVisibility(true);
mpDepthTestTaskSlider->SetVisibility(true);
wchar_t string[CPUT_MAX_STRING_LENGTH];
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("Depth Test Task: \t%d"), mNumDepthTestTasks);
mpDepthTestTaskSlider->SetText(string);
if(mSOCType == SCALAR_TYPE)
{
mpDBRScalarMT = new DepthBufferRasterizerScalarMT;
mpDBR = mpDBRScalarMT;
mpAABBScalarMT = new AABBoxRasterizerScalarMT;
mpAABB = mpAABBScalarMT;
}
else if(mSOCType == SSE_TYPE)
{
mpDBRSSEMT = new DepthBufferRasterizerSSEMT;
mpDBR = mpDBRSSEMT;
mpAABBSSEMT = new AABBoxRasterizerSSEMT;
mpAABB = mpAABBSSEMT;
}
mpAABB->SetDepthTestTasks(mNumDepthTestTasks);
}
else
{
state = CPUT_CHECKBOX_UNCHECKED;
mpPipelineCheckBox->SetVisibility(false);
mpDepthTestTaskSlider->SetVisibility(false);
if(mSOCType == SCALAR_TYPE)
{
mpDBRScalarST = new DepthBufferRasterizerScalarST;
mpDBR = mpDBRScalarST;
mpAABBScalarST = new AABBoxRasterizerScalarST;
mpAABB = mpAABBScalarST;
}
else if(mSOCType == SSE_TYPE)
{
mpDBRSSEST = new DepthBufferRasterizerSSEST;
mpDBR = mpDBRSSEST;
mpAABBSSEST = new AABBoxRasterizerSSEST;
mpAABB = mpAABBSSEST;
}
}
mpDBR->CreateTransformedModels(mpAssetSetDBR, OCCLUDER_SETS);
mpDBR->SetOccluderSizeThreshold(mOccluderSizeThreshold);
mpAABB->CreateTransformedAABBoxes(mpAssetSetAABB, OCCLUDEE_SETS);
mpAABB->SetOccludeeSizeThreshold(mOccludeeSizeThreshold);
mpTasksCheckBox->SetCheckboxState(state);
break;
}
case KEY_7:
{
if(mSyncInterval == 1)
{
mSyncInterval = 0;
}
else
{
mSyncInterval = 1;
}
CPUTCheckboxState state;
if(mSyncInterval == 1)
{
state = CPUT_CHECKBOX_CHECKED;
}
else
{
state = CPUT_CHECKBOX_UNCHECKED;
}
mpVsyncCheckBox->SetCheckboxState(state);
break;
}
case KEY_8:
{
TaskCleanUp();
mPipeline = !mPipeline;
CPUTCheckboxState state;
if(mPipeline)
{
state = CPUT_CHECKBOX_CHECKED;
}
else
{
state = CPUT_CHECKBOX_UNCHECKED;
}
mpPipelineCheckBox->SetCheckboxState(state);
break;
}
}
// pass it to the camera controller
if(handled == CPUT_EVENT_UNHANDLED)
{
handled = mpCameraController->HandleKeyboardEvent(key);
}
return handled;
}
