void RenderArrows(float fElapsedTime)
{
WCHAR strWhite[MAX_PATH] = {26};
WCHAR strBlack[MAX_PATH] = {27};
CDXUTStatic* pStatic = NULL;
pStatic = g_WhiteArrowDialog.GetStatic(IDC_WHITESCORE);
if(pStatic != NULL)
{
pStatic->SetText(strWhite);
}
pStatic = g_BlackArrowDialog.GetStatic(IDC_BLACKSCORE);
if(pStatic != NULL)
{
pStatic->SetText(strBlack);
}
if(!g_Board.pRenjuGame->bGameIsFinished)
{
if(g_Board.pRenjuGame->activeColor == White)
{
g_WhiteArrowDialog.OnRender(fElapsedTime);
}
if(g_Board.pRenjuGame->activeColor == Black)
{
g_BlackArrowDialog.OnRender(fElapsedTime);
}
}
}
//--------------------------------------------------------------------------------------
// Handles the GUI events
//--------------------------------------------------------------------------------------
void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext )
{
switch( nControlID )
{
case IDC_TOGGLEFULLSCREEN:
DXUTToggleFullScreen(); break;
case IDC_TOGGLEREF:
DXUTToggleREF(); break;
case IDC_CHANGEDEVICE:
g_SettingsDlg.SetActive( !g_SettingsDlg.IsActive() ); break;
case IDC_ENABLE_PRESHADER:
{
g_bEnablePreshader = g_SampleUI.GetCheckBox( IDC_ENABLE_PRESHADER )->GetChecked();
if( DXUTGetD3D9Device() != NULL )
{
OnLostDevice( NULL );
OnDestroyDevice( NULL );
OnCreateDevice( DXUTGetD3D9Device(), DXUTGetD3D9BackBufferSurfaceDesc(), NULL );
OnResetDevice( DXUTGetD3D9Device(), DXUTGetD3D9BackBufferSurfaceDesc(), NULL );
}
break;
}
case IDC_ACTIVE_LIGHT:
if( !g_LightControl[g_nActiveLight].IsBeingDragged() )
{
g_nActiveLight++;
g_nActiveLight %= g_nNumActiveLights;
}
break;
case IDC_NUM_LIGHTS:
if( !g_LightControl[g_nActiveLight].IsBeingDragged() )
{
WCHAR sz[100];
swprintf_s( sz, 100, L"# Lights: %d", g_SampleUI.GetSlider( IDC_NUM_LIGHTS )->GetValue() );
g_SampleUI.GetStatic( IDC_NUM_LIGHTS_STATIC )->SetText( sz );
g_nNumActiveLights = g_SampleUI.GetSlider( IDC_NUM_LIGHTS )->GetValue();
g_nActiveLight %= g_nNumActiveLights;
}
break;
case IDC_LIGHT_SCALE:
g_fLightScale = ( float )( g_SampleUI.GetSlider( IDC_LIGHT_SCALE )->GetValue() * 0.10f );
WCHAR sz[100];
swprintf_s( sz, 100, L"Light scale: %0.2f", g_fLightScale );
g_SampleUI.GetStatic( IDC_LIGHT_SCALE_STATIC )->SetText( sz );
break;
}
}
void setVisibleCustomControls(bool visible) {
hud.GetStatic(IDC_THRESHOLD_LABEL)->SetVisible(visible);
hud.GetSlider(IDC_THRESHOLD)->SetVisible(visible);
hud.GetStatic(IDC_MAX_SEARCH_STEPS_LABEL)->SetVisible(visible);
hud.GetSlider(IDC_MAX_SEARCH_STEPS)->SetVisible(visible);
hud.GetStatic(IDC_MAX_SEARCH_STEPS_DIAG_LABEL)->SetVisible(visible);
hud.GetSlider(IDC_MAX_SEARCH_STEPS_DIAG)->SetVisible(visible);
hud.GetStatic(IDC_CORNER_ROUNDING_LABEL)->SetVisible(visible);
hud.GetSlider(IDC_CORNER_ROUNDING)->SetVisible(visible);
}
void initApp() {
hud.Init(&dialogResourceManager);
hud.SetCallback(onGUIEvent); int iY = 10;
hud.AddButton(IDC_TOGGLE_FULLSCREEN, L"Toggle full screen", 35, iY, HUD_WIDTH, 22);
iY += 24;
hud.AddComboBox(IDC_PRESET, 35, iY += 24, HUD_WIDTH, 22, 0, false);
hud.GetComboBox(IDC_PRESET)->AddItem(L"SMAA Low", (LPVOID) 0);
hud.GetComboBox(IDC_PRESET)->AddItem(L"SMAA Medium", (LPVOID) 1);
hud.GetComboBox(IDC_PRESET)->AddItem(L"SMAA High", (LPVOID) 2);
hud.GetComboBox(IDC_PRESET)->AddItem(L"SMAA Ultra", (LPVOID) 3);
hud.GetComboBox(IDC_PRESET)->AddItem(L"SMAA Custom", (LPVOID) 4);
hud.GetComboBox(IDC_PRESET)->SetSelectedByData((LPVOID) 2);
hud.AddComboBox(IDC_DETECTION_MODE, 35, iY += 24, HUD_WIDTH, 22, 0, false);
hud.GetComboBox(IDC_DETECTION_MODE)->AddItem(L"Luma edge det.", (LPVOID) 0);
hud.GetComboBox(IDC_DETECTION_MODE)->AddItem(L"Color edge det.", (LPVOID) 1);
hud.GetComboBox(IDC_DETECTION_MODE)->AddItem(L"Depth edge det.", (LPVOID) 2);
hud.AddCheckBox(IDC_ANTIALIASING, L"SMAA Anti-Aliasing", 35, iY += 24, HUD_WIDTH, 22, true);
hud.AddCheckBox(IDC_PROFILE, L"Profile", 35, iY += 24, 125, 22, false);
wstringstream s;
s << L"Threshold: " << commandlineOptions.threshold;
hud.AddStatic(IDC_THRESHOLD_LABEL, s.str().c_str(), 35, iY += 24, HUD_WIDTH, 22);
hud.AddSlider(IDC_THRESHOLD, 35, iY += 24, HUD_WIDTH, 22, 0, 100, int(100.0f * commandlineOptions.threshold / 0.5f));
hud.GetStatic(IDC_THRESHOLD_LABEL)->SetVisible(false);
hud.GetSlider(IDC_THRESHOLD)->SetVisible(false);
s = wstringstream();
s << L"Max Search Steps: " << commandlineOptions.searchSteps;
hud.AddStatic(IDC_MAX_SEARCH_STEPS_LABEL, s.str().c_str(), 35, iY += 24, HUD_WIDTH, 22);
hud.AddSlider(IDC_MAX_SEARCH_STEPS, 35, iY += 24, HUD_WIDTH, 22, 0, 100, int(100.0f * commandlineOptions.searchSteps / 98.0f));
hud.GetStatic(IDC_MAX_SEARCH_STEPS_LABEL)->SetVisible(false);
hud.GetSlider(IDC_MAX_SEARCH_STEPS)->SetVisible(false);
s = wstringstream();
s << L"Max Diag. Search Steps: " << commandlineOptions.diagSearchSteps;
hud.AddStatic(IDC_MAX_SEARCH_STEPS_DIAG_LABEL, s.str().c_str(), 35, iY += 24, HUD_WIDTH, 22);
hud.AddSlider(IDC_MAX_SEARCH_STEPS_DIAG, 35, iY += 24, HUD_WIDTH, 22, 0, 100, int(100.0f * commandlineOptions.diagSearchSteps / 20.0f));
hud.GetStatic(IDC_MAX_SEARCH_STEPS_DIAG_LABEL)->SetVisible(false);
hud.GetSlider(IDC_MAX_SEARCH_STEPS_DIAG)->SetVisible(false);
s = wstringstream();
s << L"Corner Rounding: " << commandlineOptions.cornerRounding;
hud.AddStatic(IDC_CORNER_ROUNDING_LABEL, s.str().c_str(), 35, iY += 24, HUD_WIDTH, 22);
hud.AddSlider(IDC_CORNER_ROUNDING, 35, iY += 24, HUD_WIDTH, 22, 0, 100, int(100.0f * commandlineOptions.cornerRounding / 100.0f));
hud.GetStatic(IDC_CORNER_ROUNDING_LABEL)->SetVisible(false);
hud.GetSlider(IDC_CORNER_ROUNDING)->SetVisible(false);
}
//--------------------------------------------------------------------------------------
// Create any D3D9 resources that won't live through a device reset (D3DPOOL_DEFAULT)
// or that are tied to the back buffer size
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D9ResetDevice( IDirect3DDevice9* pd3dDevice,
const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext )
{
HRESULT hr;
V_RETURN( g_DialogResourceManager.OnD3D9ResetDevice() );
V_RETURN( g_SettingsDlg.OnD3D9ResetDevice() );
// Setup the camera's projection parameters
camera->OnResetDevice(pBackBufferSurfaceDesc);
g_HUD.SetLocation( pBackBufferSurfaceDesc->Width - 350, 0 );
g_HUD.SetSize( 360, 100 );
g_HUD.GetEditBox(IDC_CMD)->SetLocation(5,pBackBufferSurfaceDesc->Height-30);
g_HUD.GetStatic(IDC_STATIC7)->SetLocation(5,pBackBufferSurfaceDesc->Height-60);
g_SampleUI.SetLocation( pBackBufferSurfaceDesc->Width - 350, 130 );
g_SampleUI.SetSize( 350, pBackBufferSurfaceDesc->Height - 130 );
//clear black part of screen
clearRect.x1 = pBackBufferSurfaceDesc->Width - 360;
clearRect.y1 = 0;
clearRect.x2 = pBackBufferSurfaceDesc->Width;
clearRect.y2 = pBackBufferSurfaceDesc->Height;
return S_OK;
}
//--------------------------------------------------------------------------------------
// Handles the GUI events
//--------------------------------------------------------------------------------------
void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl,
void* pUserContext )
{
if( g_bGuiVisible )
{
switch( nControlID )
{
case IDC_TOGGLEFULLSCREEN:
DXUTToggleFullScreen(); break;
case IDC_TOGGLEREF:
DXUTToggleREF(); break;
case IDC_CHANGEDEVICE:
g_D3DSettingsDlg.SetActive( !g_D3DSettingsDlg.IsActive() ); break;
case IDC_SUNWIDTH_SLIDER:
WCHAR temp[64];
int iVal = g_HUD.GetSlider( IDC_SUNWIDTH_SLIDER )->GetValue();
g_fSunWidth = ( float( iVal ) / 100.0f ) * 3.0f;
swprintf_s( temp, L"SunWidth = %2.2f", g_fSunWidth );
g_HUD.GetStatic( IDC_SUNWIDTH_TEXT )->SetText( temp );
break;
}
}
}
//--------------------------------------------------------------------------------------
// Handles the GUI events
//--------------------------------------------------------------------------------------
void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext )
{
switch( nControlID )
{
case IDC_TOGGLEFULLSCREEN:
DXUTToggleFullScreen(); break;
case IDC_TOGGLEREF:
DXUTToggleREF(); break;
case IDC_CHANGEDEVICE:
g_D3DSettingsDlg.SetActive( !g_D3DSettingsDlg.IsActive() ); break;
case IDC_TOGGLEWARP:
DXUTToggleWARP(); break;
case IDC_TOGGLESPIN:
{
g_bSpinning = g_SampleUI.GetCheckBox( IDC_TOGGLESPIN )->GetChecked();
break;
}
case IDC_EXPLODE_SCALE:
{
WCHAR sz[100];
g_fExplode = ( float )( g_SampleUI.GetSlider( IDC_EXPLODE_SCALE )->GetValue() * 0.01f );
swprintf_s( sz, 100, L"Explode Amount: %0.2f", g_fExplode );
g_SampleUI.GetStatic( IDC_EXPLODE_STATIC )->SetText( sz );
g_pExplodeVariable->SetFloat( g_fExplode );
break;
}
}
}
void RenderWinner(float fElapsedTime)
{
if(g_Board.pRenjuGame->winner == Black)
{
WCHAR strMessage[MAX_PATH] = L"The Black have won!";
CDXUTStatic* pStatic = NULL;
CDXUTElement* pElement = NULL;
pStatic = g_TheBlackWinnerDialog.GetStatic(IDC_THE_BLACK_WINNER_DIALOG);
if(pStatic != NULL)
{
pStatic->SetText(strMessage);
}
pElement = g_TheBlackWinnerDialog.GetDefaultElement(DXUT_CONTROL_STATIC, 0);
pElement->FontColor.Init(D3DCOLOR_ARGB(255, 255, 255, 255));
g_TheBlackWinnerDialog.OnRender(fElapsedTime);
}
else
{
if(g_Board.pRenjuGame->winner == White)
{
WCHAR strMessage[MAX_PATH] = L"The White have won!";
CDXUTStatic* pStatic = NULL;
CDXUTElement* pElement = NULL;
pStatic = g_TheWhiteWinnerDialog.GetStatic(IDC_THE_WHITE_WINNER_DIALOG);
if(pStatic != NULL)
{
pStatic->SetText(strMessage);
}
pElement = g_TheWhiteWinnerDialog.GetDefaultElement(DXUT_CONTROL_STATIC, 0);
pElement->FontColor.Init(D3DCOLOR_ARGB(255, 0, 0, 0));
g_TheWhiteWinnerDialog.OnRender(fElapsedTime);
}
}
}
//--------------------------------------------------------------------------------------
// Handle updates to the scene. This is called regardless of which D3D API is used
//--------------------------------------------------------------------------------------
void CALLBACK OnFrameMove( double fTime, float fElapsedTime, void* pUserContext )
{
manipulator->FrameMove(fElapsedTime, fTime);
if(iGradientStep != -1) GradientCalculus();
wchar_t* report = manipulator->GetReport();
if(report != NULL)
{
g_HUD.GetStatic(IDC_STATIC7)->SetText(report);
}
Pick();
}
int GradientCalculus()
{
int res = manipulator->GetLimbGradient(wcGradientLimbName,cGradientFilename,iGradientUserStep,iGradientStep);
if(res == -1)
{
iGradientStep == -1;
g_HUD.GetStatic(IDC_STATIC7)->SetText(L"Gradients processed");
}
else
{
iGradientStep++;
int dimension = (int)ceil(2.f*manipulator->GetLimbLength(wcGradientLimbName)/iGradientUserStep);
dimension = dimension*dimension*dimension;
wchar_t str[128];
swprintf(str,L"Gradient processed: %d of %d", iGradientStep, dimension);
g_HUD.GetStatic(IDC_STATIC7)->SetText(str);
}
return 0;
}
//--------------------------------------------------------------------------------------
// Handles the GUI events
//--------------------------------------------------------------------------------------
void CALLBACK OnGUIEvent(UINT nEvent, int nControlID, CDXUTControl* pControl,
void* pUserContext)
{
switch (nControlID)
{
case IDC_TOGGLEFULLSCREEN: DXUTToggleFullScreen(); break;
case IDC_TOGGLEREF: DXUTToggleREF(); break;
case IDC_CHANGEDEVICE: g_D3DSettingsDlg.SetActive(
!g_D3DSettingsDlg.IsActive()); break;
case IDC_DIFF_STEPS:
g_vsObj->diffSteps = g_SampleUI.GetSlider(IDC_DIFF_STEPS)->GetValue();
WCHAR sz[100];
StringCchPrintf(sz, 100, L"Diffusion steps: %d", g_vsObj->diffSteps);
g_SampleUI.GetStatic(IDC_DIFF_STEPS_STATIC)->SetText(sz);
break;
}
}
// Initialize the app
void InitApp()
{
// Initialize dialogs
gD3DSettingsDlg.Init(&gDialogResourceManager);
gHUD.Init(&gDialogResourceManager);
gSampleUI.Init(&gDialogResourceManager);
gHUD.SetCallback(OnGUIEvent);
int x = 0;
int y = 10;
gHUD.AddButton(IDC_TOGGLEFULLSCREEN, L"Toggle full screen", x, y, 170, 23);
gHUD.AddButton(IDC_TOGGLEREF, L"Toggle REF (F3)", x, y += 26, 170, 23, VK_F3);
gHUD.AddButton(IDC_CHANGEDEVICE, L"Change device (F2)", x, y += 26, 170, 23, VK_F2);
gHUD.SetSize( 170, 170 );
gSampleUI.SetCallback(OnGUIEvent);
x = 0;
y = 0;
gSampleUI.AddStatic(IDC_TEXT, L"", x, y, 1, 1); y += 5*22;
gSampleUI.AddComboBox(IDC_PROFILE, x, y, 226, 22); y += 26;
gSampleUI.AddCheckBox(IDC_MT, L"Multithreaded", x, y, 125, 22, gMultithreaded);
gSampleUI.AddButton(IDC_RECOMPRESS, L"Recompress", x + 131, y, 125, 22); y += 26;
gSampleUI.AddComboBox(IDC_IMAGEVIEW, x, y, 145, 22);
gSampleUI.AddCheckBox(IDC_ALPHA, L"Show Alpha", x + 151, y, 105, 22); y += 26;
gSampleUI.AddSlider(IDC_EXPOSURE, x, y, 250, 22); y += 26;
gSampleUI.AddButton(IDC_LOAD_TEXTURE, L"Load Texture", x, y, 125, 22);
gSampleUI.AddButton(IDC_SAVE_TEXTURE, L"Save Texture", x + 131, y, 125, 22); y += 26;
gSampleUI.SetSize( 276, y+150 );
{
CDXUTComboBox *comboBox = gSampleUI.GetComboBox(IDC_IMAGEVIEW);
comboBox->AddItem(L"Uncompressed", (void *)(eImageView_Uncompressed));
comboBox->AddItem(L"Compressed", (void *)(eImageView_Compressed));
//comboBox->AddItem(L"Error", (void *)(eImageView_Error));
//comboBox->AddItem(L"All", (void *)(eImageView_All));
comboBox->SetSelectedByData((void *)(gImageView));
}
gSampleUI.SendEvent(IDC_TEXT, true, gSampleUI.GetStatic(IDC_TEXT));
}
void CALLBACK on_render(ID3D11Device* device, ID3D11DeviceContext* context, double fTime, float fElapsedTime, void* pUserContext)
{
if (!enabled)
return;
// get FPS
dune::tstringstream ss;
ss << DXUTGetFPS() << L"(" << std::setprecision(2) << DXUTGetElapsedTime() * 1000 << L"ms)" << std::endl;
hud.GetStatic(IDC_FPS_COUNTER)->SetText(ss.str().c_str());
for (size_t i = 0; i < dlg_manager.m_Dialogs.size(); ++i)
{
auto h = dlg_manager.m_Dialogs[i];
// make sure HUD is rendered last
if (h != &hud)
h->OnRender(fElapsedTime);
}
hud.OnRender(fElapsedTime);
}
//--------------------------------------------------------------------------------------
// Handles the GUI events
//--------------------------------------------------------------------------------------
void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext )
{
switch( nControlID )
{
// Standard DXUT controls
case IDC_TOGGLEFULLSCREEN:
DXUTToggleFullScreen(); break;
case IDC_TOGGLEREF:
DXUTToggleREF(); break;
case IDC_CHANGEDEVICE:
g_D3DSettingsDlg.SetActive( !g_D3DSettingsDlg.IsActive() ); break;
// Custom app controls
case IDC_PATCH_SUBDIVS:
{
g_fSubdivs = g_SampleUI.GetSlider( IDC_PATCH_SUBDIVS )->GetValue() / 10.0f;
WCHAR sz[100];
swprintf_s( sz, L"Patch Divisions: %2.1f", g_fSubdivs );
g_SampleUI.GetStatic( IDC_PATCH_SUBDIVS_STATIC )->SetText( sz );
}
break;
case IDC_TOGGLE_LINES:
g_bDrawWires = g_SampleUI.GetCheckBox( IDC_TOGGLE_LINES )->GetChecked();
break;
case IDC_PARTITION_INTEGER:
g_iPartitionMode = PARTITION_INTEGER;
break;
case IDC_PARTITION_FRAC_EVEN:
g_iPartitionMode = PARTITION_FRACTIONAL_EVEN;
break;
case IDC_PARTITION_FRAC_ODD:
g_iPartitionMode = PARTITION_FRACTIONAL_ODD;
break;
}
}
//------------------------------------------------------------------------
// Name: OnChainSelect
// Desc: event handler for select one of chains
//------------------------------------------------------------------------
HRESULT OnChainSelect(int iID)
{
if(iID >= 0)
{
wchar_t str[256];
cprimitive* chain = manipulator->cube[iID];
g_SampleUI.SetVisible(true);
swprintf(str,L"You picked chain # %d",iID);
g_SampleUI.GetStatic( IDC_OBJNAME )->SetText(str);
g_SampleUI.GetSlider(IDC_WIDTH_SLIDER)->SetValue(chain->fWidth);
swprintf(str,L"%.2f",chain->fWidth);
g_SampleUI.GetEditBox( IDC_WIDTH )->SetText(str);
g_SampleUI.GetSlider(IDC_LENGTH_SLIDER)->SetValue(chain->fLength);
swprintf(str,L"%.2f",chain->fLength);
g_SampleUI.GetEditBox( IDC_LENGTH )->SetText(str);
swprintf(str,L"%.2f",chain->restrictAngleX.x);
g_SampleUI.GetEditBox( IDC_ANGLE_RESTRICT_XL )->SetText(str);
swprintf(str,L"%.2f",chain->restrictAngleX.y);
g_SampleUI.GetEditBox( IDC_ANGLE_RESTRICT_XU )->SetText(str);
swprintf(str,L"%.2f",chain->restrictAngleY.x);
g_SampleUI.GetEditBox( IDC_ANGLE_RESTRICT_YL )->SetText(str);
swprintf(str,L"%.2f",chain->restrictAngleY.y);
g_SampleUI.GetEditBox( IDC_ANGLE_RESTRICT_YU )->SetText(str);
swprintf(str,L"%.2f",chain->vOffset.x);
g_SampleUI.GetEditBox( IDC_OFFSET_X )->SetText(str);
swprintf(str,L"%.2f",chain->vOffset.y);
g_SampleUI.GetEditBox( IDC_OFFSET_Y )->SetText(str);
swprintf(str,L"%.2f",chain->vOffset.z);
g_SampleUI.GetEditBox( IDC_OFFSET_Z )->SetText(str);
swprintf(str,L"%.2f",chain->fDisplace);
g_SampleUI.GetEditBox( IDC_DISPLACE )->SetText(str);
swprintf(str,L"%.2f",chain->fDirection);
g_SampleUI.GetEditBox( IDC_DIRECTION )->SetText(str);
swprintf(str,L"%.2f",chain->fCoefficient);
g_SampleUI.GetEditBox( IDC_COEFFICIENT )->SetText(str);
swprintf(str,L"%.2f",chain->fMass);
g_SampleUI.GetEditBox( IDC_MASS )->SetText(str);
g_SampleUI.GetCheckBox( IDC_TILT )->SetChecked(chain->bTilt);
g_SampleUI.GetCheckBox( IDC_PRESSURE )->SetChecked(chain->bPressure);
g_SampleUI.GetCheckBox( IDC_LASER )->SetChecked(chain->bLaser);
swprintf(str,L"X: %.2f",chain->vAngle.x);
g_SampleUI.GetStatic( IDC_STATIC7 )->SetText(str);
swprintf(str,L"Y: %.2f",chain->vAngle.y);
g_SampleUI.GetStatic( IDC_STATIC8 )->SetText(str);
}
else
{
g_SampleUI.SetVisible(false);
}
return S_OK;
}
//--------------------------------------------------------------------------------------
// Initialize the app
//--------------------------------------------------------------------------------------
void InitApp()
{
camera = new CCamera;
manipulator = new CManipulator;
g_SettingsDlg.Init( &g_DialogResourceManager );
g_HUD.Init( &g_DialogResourceManager );
g_SampleUI.Init( &g_DialogResourceManager );
//g_HUD
g_HUD.SetCallback( OnGUIEvent );
g_HUD.AddButton( IDC_TOGGLEFULLSCREEN, L"Toggle full screen", 5, 10, 125, 22, VK_F12 );
//fonts
g_HUD.SetFont( 1, L"Arial", 20, FW_BOLD );
g_HUD.SetFont( 2, L"Arial", 16, FW_NORMAL );
g_HUD.AddEditBox( IDC_NEWFILE, L"testconfig.ini", 150, 10, 120, 30 );
g_HUD.AddButton( IDC_NEWFILE_BTN, L"New", 280, 15, 60, 20);
g_HUD.AddEditBox( IDC_LOADFILE, L"testconfig.ini", 150, 40, 120, 30 );
g_HUD.AddButton( IDC_LOADFILE_BTN, L"Load", 280, 45, 60, 20);
g_HUD.AddEditBox( IDC_SAVEFILE, L"testconfig.ini", 150, 70, 120, 30 );
g_HUD.AddButton( IDC_SAVEFILE_BTN, L"Save", 280, 75, 60, 20);
g_HUD.AddEditBox( IDC_CMD, L"", 5, 5, 300, 30 );
g_HUD.AddStatic( IDC_STATIC7, L"status", 5, 5, 300, 30 );
g_HUD.GetStatic( IDC_STATIC7 )->GetElement( 0 )->dwTextFormat = DT_LEFT;
g_HUD.GetStatic( IDC_STATIC7 )->SetTextColor( D3DCOLOR_ARGB( 255, 220, 220, 220 ) );
g_HUD.GetStatic( IDC_STATIC7 )->GetElement(0)->iFont = 2;
//g_SampleUI
g_SampleUI.SetCallback( OnGUIEvent ); int iY = 10;
g_SampleUI.SetVisible(false);
//fonts
g_SampleUI.SetFont( 1, L"Arial", 20, FW_BOLD );
g_SampleUI.SetFont( 2, L"Arial", 16, FW_NORMAL );
g_SampleUI.AddStatic( IDC_OBJNAME, L"Pick object", 0, 0, 200, 30 );
g_SampleUI.GetStatic( IDC_OBJNAME )->GetElement( 0 )->dwTextFormat = DT_LEFT;
g_SampleUI.GetStatic( IDC_OBJNAME )->SetTextColor( D3DCOLOR_ARGB( 255, 220, 220, 220 ) );
g_SampleUI.GetStatic( IDC_OBJNAME )->GetElement(0)->iFont = 1;
g_SampleUI.AddStatic( IDC_STATIC7, L"angleX:",210,0,50,30 );
g_SampleUI.GetStatic( IDC_STATIC7 )->GetElement( 0 )->dwTextFormat = DT_LEFT;
g_SampleUI.GetStatic( IDC_STATIC7 )->SetTextColor( D3DCOLOR_ARGB( 255, 220, 220, 220 ) );
g_SampleUI.GetStatic( IDC_STATIC7 )->GetElement(0)->iFont = 2;
g_SampleUI.AddStatic( IDC_STATIC8, L"angleY:",260,0,50,30 );
g_SampleUI.GetStatic( IDC_STATIC8 )->GetElement( 0 )->dwTextFormat = DT_LEFT;
g_SampleUI.GetStatic( IDC_STATIC8 )->SetTextColor( D3DCOLOR_ARGB( 255, 220, 220, 220 ) );
g_SampleUI.GetStatic( IDC_STATIC8 )->GetElement(0)->iFont = 2;
//width edit box
g_SampleUI.AddStatic( IDC_STATIC1, L"Width", 0, 50, 200, 30 );
g_SampleUI.GetStatic( IDC_STATIC1 )->GetElement( 0 )->dwTextFormat = DT_LEFT;
g_SampleUI.GetStatic( IDC_STATIC1 )->SetTextColor( D3DCOLOR_ARGB( 255, 220, 220, 220 ) );
g_SampleUI.GetStatic( IDC_STATIC1 )->GetElement(0)->iFont = 2;
g_SampleUI.AddEditBox( IDC_WIDTH, L"", 70, 45, 120, 30 );
g_SampleUI.AddSlider( IDC_WIDTH_SLIDER, 200, 50, 150, 24, 1, 75, 20, false );
//length edit box
g_SampleUI.AddStatic( IDC_STATIC2, L"Length", 0, 80, 200, 30 );
g_SampleUI.GetStatic( IDC_STATIC2 )->GetElement( 0 )->dwTextFormat = DT_LEFT;
g_SampleUI.GetStatic( IDC_STATIC2 )->SetTextColor( D3DCOLOR_ARGB( 255, 220, 220, 220 ) );
g_SampleUI.GetStatic( IDC_STATIC2 )->GetElement(0)->iFont = 2;
g_SampleUI.AddEditBox( IDC_LENGTH, L"", 70, 75, 120, 30 );
g_SampleUI.AddSlider( IDC_LENGTH_SLIDER, 200, 80, 150, 24, 1, 400, 100, false );
//angle restrictions
g_SampleUI.AddStatic( IDC_STATIC3, L"Angles restrictions", 0, 110, 200, 30 );
g_SampleUI.GetStatic( IDC_STATIC3 )->GetElement( 0 )->dwTextFormat = DT_LEFT | DT_TOP;
g_SampleUI.GetStatic( IDC_STATIC3 )->SetTextColor( D3DCOLOR_ARGB( 255, 220, 220, 220 ) );
g_SampleUI.GetStatic( IDC_STATIC3 )->GetElement(0)->iFont = 2;
g_SampleUI.AddStatic( IDC_STATIC4, L"X", 20, 130, 200, 30 );
g_SampleUI.GetStatic( IDC_STATIC4 )->GetElement( 0 )->dwTextFormat = DT_LEFT | DT_TOP;
g_SampleUI.GetStatic( IDC_STATIC4 )->SetTextColor( D3DCOLOR_ARGB( 255, 220, 220, 220 ) );
g_SampleUI.GetStatic( IDC_STATIC4 )->GetElement(0)->iFont = 2;
g_SampleUI.AddStatic( IDC_STATIC5, L"Y", 20, 160, 200, 30 );
g_SampleUI.GetStatic( IDC_STATIC5 )->GetElement( 0 )->dwTextFormat = DT_LEFT | DT_TOP;
g_SampleUI.GetStatic( IDC_STATIC5 )->SetTextColor( D3DCOLOR_ARGB( 255, 220, 220, 220 ) );
g_SampleUI.GetStatic( IDC_STATIC5 )->GetElement(0)->iFont = 2;
g_SampleUI.AddEditBox( IDC_ANGLE_RESTRICT_XL, L"", 70, 125, 100, 30 );
g_SampleUI.AddButton( IDC_ANGLE_RESTRICT_XL_BTN, L"A", 170, 130, 22, 22 );
g_SampleUI.AddEditBox( IDC_ANGLE_RESTRICT_XU, L"", 220, 125, 100, 30 );
g_SampleUI.AddButton( IDC_ANGLE_RESTRICT_XU_BTN, L"A", 320, 130, 22, 22 );
g_SampleUI.AddEditBox( IDC_ANGLE_RESTRICT_YL, L"", 70, 155, 100, 30 );
g_SampleUI.AddButton( IDC_ANGLE_RESTRICT_YL_BTN, L"A", 170, 160, 22, 22 );
g_SampleUI.AddEditBox( IDC_ANGLE_RESTRICT_YU, L"", 220, 155, 100, 30 );
g_SampleUI.AddButton( IDC_ANGLE_RESTRICT_YU_BTN, L"A", 320, 160, 22, 22 );
//add button
g_SampleUI.AddButton( IDC_ADDCHAIN, L"Add", 15, 200, 100, 22 );
g_SampleUI.AddButton( IDC_REMOVECHAIN, L"Remove", 115, 200, 100, 22 );
//offset
g_SampleUI.AddStatic( IDC_STATIC6, L"Offset", 0, 230, 70, 30 );
g_SampleUI.GetStatic( IDC_STATIC6 )->GetElement( 0 )->dwTextFormat = DT_LEFT;
g_SampleUI.GetStatic( IDC_STATIC6 )->SetTextColor( D3DCOLOR_ARGB( 255, 220, 220, 220 ) );
g_SampleUI.GetStatic( IDC_STATIC6 )->GetElement(0)->iFont = 2;
g_SampleUI.AddEditBox( IDC_OFFSET_X, L"", 70, 225, 80, 30 );
g_SampleUI.AddEditBox( IDC_OFFSET_Y, L"", 160, 225, 80, 30 );
g_SampleUI.AddEditBox( IDC_OFFSET_Z, L"", 250, 225, 80, 30 );
//physical stuff
g_SampleUI.AddStatic( IDC_STATIC6, L"Displace", 0, 265, 70, 30 );
g_SampleUI.GetStatic( IDC_STATIC6 )->GetElement( 0 )->dwTextFormat = DT_LEFT;
g_SampleUI.GetStatic( IDC_STATIC6 )->SetTextColor( D3DCOLOR_ARGB( 255, 220, 220, 220 ) );
g_SampleUI.GetStatic( IDC_STATIC6 )->GetElement(0)->iFont = 2;
g_SampleUI.AddEditBox(IDC_DISPLACE, L"", 70, 265, 80, 30);
g_SampleUI.AddStatic( IDC_STATIC6, L"Direction", 0, 305, 70, 30 );
g_SampleUI.GetStatic( IDC_STATIC6 )->GetElement( 0 )->dwTextFormat = DT_LEFT;
g_SampleUI.GetStatic( IDC_STATIC6 )->SetTextColor( D3DCOLOR_ARGB( 255, 220, 220, 220 ) );
g_SampleUI.GetStatic( IDC_STATIC6 )->GetElement(0)->iFont = 2;
g_SampleUI.AddEditBox(IDC_DIRECTION, L"", 70, 305, 80, 30);
g_SampleUI.AddStatic( IDC_STATIC6, L"Coefficient", 0, 345, 70, 30 );
g_SampleUI.GetStatic( IDC_STATIC6 )->GetElement( 0 )->dwTextFormat = DT_LEFT;
g_SampleUI.GetStatic( IDC_STATIC6 )->SetTextColor( D3DCOLOR_ARGB( 255, 220, 220, 220 ) );
g_SampleUI.GetStatic( IDC_STATIC6 )->GetElement(0)->iFont = 2;
g_SampleUI.AddEditBox(IDC_COEFFICIENT, L"", 70, 345, 80, 30);
g_SampleUI.AddStatic( IDC_STATIC6, L"Mass", 0, 385, 70, 30 );
g_SampleUI.GetStatic( IDC_STATIC6 )->GetElement( 0 )->dwTextFormat = DT_LEFT;
g_SampleUI.GetStatic( IDC_STATIC6 )->SetTextColor( D3DCOLOR_ARGB( 255, 220, 220, 220 ) );
g_SampleUI.GetStatic( IDC_STATIC6 )->GetElement(0)->iFont = 2;
g_SampleUI.AddEditBox(IDC_MASS, L"", 70, 385, 80, 30);
g_SampleUI.AddStatic( IDC_STATIC6, L"Tilt", 0, 425, 70, 30 );
g_SampleUI.GetStatic( IDC_STATIC6 )->GetElement( 0 )->dwTextFormat = DT_LEFT;
g_SampleUI.GetStatic( IDC_STATIC6 )->SetTextColor( D3DCOLOR_ARGB( 255, 220, 220, 220 ) );
g_SampleUI.GetStatic( IDC_STATIC6 )->GetElement(0)->iFont = 2;
g_SampleUI.AddCheckBox( IDC_TILT, L"", 60, 425, 30, 30 );
g_SampleUI.AddStatic( IDC_STATIC6, L"Pressure", 100, 425, 70, 30 );
g_SampleUI.GetStatic( IDC_STATIC6 )->GetElement( 0 )->dwTextFormat = DT_LEFT;
g_SampleUI.GetStatic( IDC_STATIC6 )->SetTextColor( D3DCOLOR_ARGB( 255, 220, 220, 220 ) );
g_SampleUI.GetStatic( IDC_STATIC6 )->GetElement(0)->iFont = 2;
g_SampleUI.AddCheckBox( IDC_PRESSURE, L"", 160, 425, 30, 30 );
g_SampleUI.AddStatic( IDC_STATIC6, L"Laser", 200, 425, 70, 30 );
g_SampleUI.GetStatic( IDC_STATIC6 )->GetElement( 0 )->dwTextFormat = DT_LEFT;
g_SampleUI.GetStatic( IDC_STATIC6 )->SetTextColor( D3DCOLOR_ARGB( 255, 220, 220, 220 ) );
g_SampleUI.GetStatic( IDC_STATIC6 )->GetElement(0)->iFont = 2;
g_SampleUI.AddCheckBox( IDC_LASER, L"", 260, 425, 30, 30 );
}
void CALLBACK onGUIEvent(UINT event, int controlId, CDXUTControl* control, void *userContext) {
switch(controlId) {
case IDC_TOGGLE_FULLSCREEN:
DXUTToggleFullScreen();
break;
case IDC_PRESET:
if (event == EVENT_COMBOBOX_SELECTION_CHANGED) {
SMAA::Preset selected;
selected = SMAA::Preset(int(hud.GetComboBox(IDC_PRESET)->GetSelectedData()));
onLostDevice(NULL);
onResetDevice(DXUTGetD3D9Device(), DXUTGetD3D9BackBufferSurfaceDesc(), NULL);
}
break;
case IDC_ANTIALIASING:
if (event == EVENT_CHECKBOX_CHANGED)
timer->reset();
break;
case IDC_PROFILE:
if (event == EVENT_CHECKBOX_CHANGED) {
timer->reset();
timer->setEnabled(hud.GetCheckBox(IDC_PROFILE)->GetChecked());
}
break;
case IDC_THRESHOLD:
if (event == EVENT_SLIDER_VALUE_CHANGED) {
CDXUTSlider *slider = hud.GetSlider(IDC_THRESHOLD);
int min, max;
slider->GetRange(min, max);
float scale = float(slider->GetValue()) / (max - min);
smaa->setThreshold(scale * 0.5f);
wstringstream s;
s << L"Threshold: " << scale * 0.5f;
hud.GetStatic(IDC_THRESHOLD_LABEL)->SetText(s.str().c_str());
}
break;
case IDC_MAX_SEARCH_STEPS:
if (event == EVENT_SLIDER_VALUE_CHANGED) {
CDXUTSlider *slider = hud.GetSlider(IDC_MAX_SEARCH_STEPS);
int min, max;
slider->GetRange(min, max);
float scale = float(slider->GetValue()) / (max - min);
smaa->setMaxSearchSteps(int(round(scale * 98.0f)));
wstringstream s;
s << L"Max Search Steps: " << int(round(scale * 98.0f));
hud.GetStatic(IDC_MAX_SEARCH_STEPS_LABEL)->SetText(s.str().c_str());
}
break;
case IDC_MAX_SEARCH_STEPS_DIAG:
if (event == EVENT_SLIDER_VALUE_CHANGED) {
CDXUTSlider *slider = hud.GetSlider(IDC_MAX_SEARCH_STEPS_DIAG);
int min, max;
slider->GetRange(min, max);
float scale = float(slider->GetValue()) / (max - min);
smaa->setMaxSearchStepsDiag(int(round(scale * 20.0f)));
wstringstream s;
s << L"Max Diag. Search Steps: " << int(round(scale * 20.0f));
hud.GetStatic(IDC_MAX_SEARCH_STEPS_DIAG_LABEL)->SetText(s.str().c_str());
}
break;
case IDC_CORNER_ROUNDING:
if (event == EVENT_SLIDER_VALUE_CHANGED) {
CDXUTSlider *slider = hud.GetSlider(IDC_CORNER_ROUNDING);
int min, max;
slider->GetRange(min, max);
float scale = float(slider->GetValue()) / (max - min);
smaa->setCornerRounding(scale * 100.0f);
wstringstream s;
s << L"Corner Rounding: " << scale * 100.0f;
hud.GetStatic(IDC_CORNER_ROUNDING_LABEL)->SetText(s.str().c_str());
}
break;
}
}
//--------------------------------------------------------------------------------------
// Handles the GUI events
//--------------------------------------------------------------------------------------
void CALLBACK OnGUIEvent(UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext)
{
switch (nControlID)
{
case IDC_TOGGLEFULLSCREEN: DXUTToggleFullScreen(); break;
case IDC_TOGGLEREF: DXUTToggleREF(); break;
case IDC_CHANGEDEVICE:
{
g_SettingsDlg.SetActive(!g_SettingsDlg.IsActive());
break;
}
case IDC_CHANGESCENE:
{
CDXUTComboBox* pComboBox = (CDXUTComboBox*) pControl;
g_CurrentSceneId = pComboBox->GetSelectedIndex();
break;
}
case IDC_BLUR_AO:
{
g_BlurAO = g_HUD.GetCheckBox(nControlID)->GetChecked();
break;
}
case IDC_DEINTERLEAVE:
{
g_UseDeinterleavedTexturing = g_HUD.GetCheckBox(nControlID)->GetChecked();
break;
}
case IDC_RANDOMIZE:
{
g_RandomizeSamples = g_HUD.GetCheckBox(nControlID)->GetChecked();
break;
}
case IDC_RADIUS_SLIDER:
{
g_AOParams.Radius = (float) g_HUD.GetSlider(IDC_RADIUS_SLIDER)->GetValue() * MAX_RADIUS_MULT / 100.0f;
WCHAR sz[100];
StringCchPrintf(sz, 100, UI_RADIUS_MULT L"%0.2f", g_AOParams.Radius);
g_HUD.GetStatic(IDC_RADIUS_STATIC)->SetText(sz);
break;
}
case IDC_BIAS_SLIDER:
{
g_AOParams.Bias = (float) g_HUD.GetSlider(IDC_BIAS_SLIDER)->GetValue() / 1000.f;
WCHAR sz[100];
StringCchPrintf(sz, 100, UI_AO_BIAS L"%g", g_AOParams.Bias);
g_HUD.GetStatic(IDC_BIAS_STATIC)->SetText(sz);
break;
}
case IDC_EXPONENT_SLIDER:
{
g_AOParams.PowerExponent = (float)g_HUD.GetSlider(IDC_EXPONENT_SLIDER)->GetValue() / 100.0f;
WCHAR sz[100];
StringCchPrintf(sz, 100, UI_POW_EXPONENT L"%0.2f", g_AOParams.PowerExponent);
g_HUD.GetStatic(IDC_EXPONENT_STATIC)->SetText(sz);
break;
}
case IDC_BLUR_SHARPNESS_SLIDER:
{
g_AOParams.Blur.Sharpness = (float)g_HUD.GetSlider(IDC_BLUR_SHARPNESS_SLIDER)->GetValue() / 100.0f;
WCHAR sz[100];
StringCchPrintf(sz, 100, UI_BLUR_SHARPNESS L"%0.2f", g_AOParams.Blur.Sharpness);
g_HUD.GetStatic(IDC_BLUR_SHARPNESS_STATIC)->SetText(sz);
break;
}
case IDC_PER_PIXEL_AO:
{
g_AOParams.Output.MSAAMode = GFSDK_SSAO_PER_PIXEL_AO;
break;
}
case IDC_PER_SAMPLE_AO:
{
g_AOParams.Output.MSAAMode = GFSDK_SSAO_PER_SAMPLE_AO;
break;
}
case IDC_1xMSAA:
case IDC_2xMSAA:
case IDC_4xMSAA:
case IDC_8xMSAA:
{
g_RenderTargetsDirty = true;
g_MSAACurrentSettings = nControlID - IDC_1xMSAA;
assert(g_MSAACurrentSettings >= MSAA_MODE_1X);
assert(g_MSAACurrentSettings <= MSAA_MODE_8X);
break;
}
}
}
//--------------------------------------------------------------------------------------
// Create any D3D9 resources that will live through a device reset (D3DPOOL_MANAGED)
// and aren't tied to the back buffer size
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D9CreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
V_RETURN( g_DialogResourceManager.OnD3D9CreateDevice( pd3dDevice ) );
V_RETURN( g_D3DSettingsDlg.OnD3D9CreateDevice( pd3dDevice ) );
// Initialize the font
V_RETURN( D3DXCreateFont( pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE,
L"Arial", &g_pFont9 ) );
// Load the mesh
V_RETURN( LoadMesh( pd3dDevice, L"tiny\\tiny.x", &g_pMesh9 ) );
g_SampleUI.GetStatic( IDC_NUM_LIGHTS_STATIC )->SetVisible( true );
g_SampleUI.GetSlider( IDC_NUM_LIGHTS )->SetVisible( true );
g_SampleUI.GetButton( IDC_ACTIVE_LIGHT )->SetVisible( true );
D3DXVECTOR3* pData;
D3DXVECTOR3 vCenter;
FLOAT fObjectRadius;
V( g_pMesh9->LockVertexBuffer( 0, ( LPVOID* )&pData ) );
V( D3DXComputeBoundingSphere( pData, g_pMesh9->GetNumVertices(),
D3DXGetFVFVertexSize( g_pMesh9->GetFVF() ), &vCenter, &fObjectRadius ) );
V( g_pMesh9->UnlockVertexBuffer() );
D3DXMatrixTranslation( &g_mCenterMesh, -vCenter.x, -vCenter.y, -vCenter.z );
D3DXMATRIXA16 m;
D3DXMatrixRotationY( &m, D3DX_PI );
g_mCenterMesh *= m;
D3DXMatrixRotationX( &m, D3DX_PI / 2.0f );
g_mCenterMesh *= m;
V_RETURN( CDXUTDirectionWidget::StaticOnD3D9CreateDevice( pd3dDevice ) );
for( int i = 0; i < MAX_LIGHTS; i++ )
g_LightControl[i].SetRadius( fObjectRadius );
// Read the D3DX effect file
WCHAR str[MAX_PATH];
DWORD dwShaderFlags = D3DXFX_NOT_CLONEABLE | D3DXSHADER_NO_PRESHADER | D3DXFX_LARGEADDRESSAWARE;
#ifdef DEBUG_VS
dwShaderFlags |= D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT;
#endif
#ifdef DEBUG_PS
dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
#endif
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"BasicHLSL.fx" ) );
V_RETURN( D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, dwShaderFlags, NULL, &g_pEffect9, NULL ) );
// Create the mesh texture from a file
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"tiny\\tiny_skin.dds" ) );
V_RETURN( D3DXCreateTextureFromFileEx( pd3dDevice, str, D3DX_DEFAULT, D3DX_DEFAULT,
D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED,
D3DX_DEFAULT, D3DX_DEFAULT, 0,
NULL, NULL, &g_pMeshTexture9 ) );
// Set effect variables as needed
D3DXCOLOR colorMtrlDiffuse( 1.0f, 1.0f, 1.0f, 1.0f );
D3DXCOLOR colorMtrlAmbient( 0.35f, 0.35f, 0.35f, 0 );
D3DXHANDLE hMaterialAmbientColor = g_pEffect9->GetParameterByName( NULL, "g_MaterialAmbientColor" );
D3DXHANDLE hMaterialDiffuseColor = g_pEffect9->GetParameterByName( NULL, "g_MaterialDiffuseColor" );
D3DXHANDLE hMeshTexture = g_pEffect9->GetParameterByName( NULL, "g_MeshTexture" );
V_RETURN( g_pEffect9->SetValue( hMaterialAmbientColor, &colorMtrlAmbient, sizeof( D3DXCOLOR ) ) );
V_RETURN( g_pEffect9->SetValue( hMaterialDiffuseColor, &colorMtrlDiffuse, sizeof( D3DXCOLOR ) ) );
V_RETURN( g_pEffect9->SetTexture( hMeshTexture, g_pMeshTexture9 ) );
g_hLightDir = g_pEffect9->GetParameterByName( NULL, "g_LightDir" );
g_hLightDiffuse = g_pEffect9->GetParameterByName( NULL, "g_LightDiffuse" );
g_hmWorldViewProjection = g_pEffect9->GetParameterByName( NULL, "g_mWorldViewProjection" );
g_hmWorld = g_pEffect9->GetParameterByName( NULL, "g_mWorld" );
g_hMaterialDiffuseColor = g_pEffect9->GetParameterByName( NULL, "g_MaterialDiffuseColor" );
g_hfTime = g_pEffect9->GetParameterByName( NULL, "g_fTime" );
g_hnNumLights = g_pEffect9->GetParameterByName( NULL, "g_nNumLights" );
g_hRenderSceneWithTexture1Light = g_pEffect9->GetTechniqueByName( "RenderSceneWithTexture1Light" );
g_hRenderSceneWithTexture2Light = g_pEffect9->GetTechniqueByName( "RenderSceneWithTexture2Light" );
g_hRenderSceneWithTexture3Light = g_pEffect9->GetTechniqueByName( "RenderSceneWithTexture3Light" );
// Setup the camera's view parameters
D3DXVECTOR3 vecEye( 0.0f, 0.0f, -15.0f );
D3DXVECTOR3 vecAt ( 0.0f, 0.0f, -0.0f );
g_Camera.SetViewParams( &vecEye, &vecAt );
g_Camera.SetRadius( fObjectRadius * 3.0f, fObjectRadius * 0.5f, fObjectRadius * 10.0f );
return S_OK;
}
//--------------------------------------------------------------------------------------
// This function loads a new technique and all device objects it requires.
//--------------------------------------------------------------------------------------
HRESULT LoadTechniqueObjects( const char* szMedia )
{
HRESULT hr = S_OK;
if( NULL == g_pEffect )
return D3DERR_INVALIDCALL;
IDirect3DTexture9* pTexture = NULL;
IDirect3DCubeTexture9* pCubeTexture = NULL;
IDirect3DDevice9* pDevice = DXUTGetD3D9Device();
WCHAR strFileName[MAX_PATH+1] = {0};
WCHAR strPath[MAX_PATH+1] = {0};
char strTechnique[MAX_PATH] = {0};
// Make sure the technique works
char* strComboTech = ( char* )g_SampleUI.GetComboBox( IDC_TECHNIQUE )->GetSelectedData();
strcpy_s( strTechnique, MAX_PATH, strComboTech );
bool bLDPRT = ( strTechnique && ( 0 == strcmp( strTechnique, "LDPRT" ) ) );
// If we're not a signed format, make sure we use a technnique that will unbias
if( D3DFMT_Q16W16V16U16 != g_fmtTexture && D3DFMT_Q8W8V8U8 != g_fmtTexture )
strcat_s( strTechnique, MAX_PATH, "_Unbias" );
D3DXHANDLE hTechnique = g_pEffect->GetTechniqueByName( strTechnique );
V_RETURN( g_pEffect->SetTechnique( hTechnique ) );
// Enable/disable LDPRT-only items
g_SampleUI.GetStatic( IDC_ENV_LABEL )->SetEnabled( bLDPRT );
g_SampleUI.GetSlider( IDC_ENV_SLIDER )->SetEnabled( bLDPRT );
g_SampleUI.GetSlider( IDC_RED_TRANSMIT_SLIDER )->SetEnabled( bLDPRT );
g_SampleUI.GetSlider( IDC_GREEN_TRANSMIT_SLIDER )->SetEnabled( bLDPRT );
g_SampleUI.GetSlider( IDC_BLUE_TRANSMIT_SLIDER )->SetEnabled( bLDPRT );
g_SampleUI.GetStatic( IDC_RED_TRANSMIT_LABEL )->SetEnabled( bLDPRT );
g_SampleUI.GetStatic( IDC_GREEN_TRANSMIT_LABEL )->SetEnabled( bLDPRT );
g_SampleUI.GetStatic( IDC_BLUE_TRANSMIT_LABEL )->SetEnabled( bLDPRT );
// Load the mesh
swprintf_s( strFileName, MAX_PATH, TEXT( "media\\%S" ), szMedia );
V_RETURN( LoadLDPRTData( pDevice, strFileName ) );
// Albedo texture
swprintf_s( strFileName, MAX_PATH, TEXT( "media\\%SAlbedo.dds" ), szMedia );
DXUTFindDXSDKMediaFileCch( strPath, MAX_PATH, strFileName );
V( D3DXCreateTextureFromFile( pDevice, strPath, &pTexture ) );
g_pEffect->SetTexture( "Albedo", pTexture );
SAFE_RELEASE( pTexture );
// Normal map
swprintf_s( strFileName, MAX_PATH, TEXT( "media\\%SNormalMap.dds" ), szMedia );
DXUTFindDXSDKMediaFileCch( strPath, MAX_PATH, strFileName );
V( D3DXCreateTextureFromFileEx( pDevice, strPath, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0,
g_fmtTexture, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0,
NULL, NULL, &pTexture ) );
g_pEffect->SetTexture( "NormalMap", pTexture );
SAFE_RELEASE( pTexture );
// Spherical harmonic basic functions
char* pNames[4] = {"YlmCoeff0","YlmCoeff4","YlmCoeff8","YlmCoeff12"};
for( int i = 0; i < 4; i++ )
{
D3DXCreateCubeTexture( pDevice, 32, 1, 0, g_fmtCubeMap, D3DPOOL_MANAGED, &pCubeTexture );
D3DXFillCubeTexture( pCubeTexture, myFillBF, ( LPVOID )( INT_PTR )( i * 4 ) );
g_pEffect->SetTexture( pNames[i], pCubeTexture );
SAFE_RELEASE( pCubeTexture );
}
return S_OK;
}
//--------------------------------------------------------------------------------------
// Handles the GUI events
//--------------------------------------------------------------------------------------
void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext )
{
WCHAR wszOutput[1024];
switch( nControlID )
{
case IDC_TOGGLEFULLSCREEN:
DXUTToggleFullScreen(); break;
case IDC_TOGGLEREF:
DXUTToggleREF(); break;
case IDC_CHANGEDEVICE:
g_SettingsDlg.SetActive( !g_SettingsDlg.IsActive() ); break;
case IDC_ENABLEIME:
CDXUTIMEEditBox::SetImeEnableFlag( true );
g_SampleUI.GetStatic( IDC_OUTPUT )->SetText(
L"You clicked the 'Enable IME' button.\nIME text input is enabled for IME-capable edit controls." );
break;
case IDC_DISABLEIME:
CDXUTIMEEditBox::SetImeEnableFlag( false );
g_SampleUI.GetStatic( IDC_OUTPUT )->SetText(
L"You clicked the 'Disable IME' button.\nIME text input is disabled for IME-capable edit controls." );
break;
case IDC_EDITBOX1:
case IDC_EDITBOX2:
switch( nEvent )
{
case EVENT_EDITBOX_STRING:
{
swprintf_s( wszOutput, 1024,
L"You have pressed Enter in edit control (ID %u).\nThe content of the edit control is:\n\"%s\"",
nControlID, ( ( CDXUTEditBox* )pControl )->GetText() );
g_SampleUI.GetStatic( IDC_OUTPUT )->SetText( wszOutput );
// Clear the text if needed
if( g_SampleUI.GetCheckBox( IDC_CLEAREDIT )->GetChecked() )
( ( CDXUTEditBox* )pControl )->SetText( L"" );
break;
}
case EVENT_EDITBOX_CHANGE:
{
swprintf_s( wszOutput, 1024,
L"You have changed the content of an edit control (ID %u).\nIt is now:\n\"%s\"",
nControlID, ( ( CDXUTEditBox* )pControl )->GetText() );
g_SampleUI.GetStatic( IDC_OUTPUT )->SetText( wszOutput );
break;
}
}
break;
case IDC_SLIDER:
swprintf_s( wszOutput, 1024, L"You adjusted the slider control.\nThe new value reported is %d",
( ( CDXUTSlider* )pControl )->GetValue() );
g_SampleUI.GetStatic( IDC_OUTPUT )->SetText( wszOutput );
break;
case IDC_CHECKBOX:
swprintf_s( wszOutput, 1024, L"You %s the upper check box.",
( ( CDXUTCheckBox* )pControl )->GetChecked() ? L"checked" : L"cleared" );
g_SampleUI.GetStatic( IDC_OUTPUT )->SetText( wszOutput );
break;
case IDC_CLEAREDIT:
swprintf_s( wszOutput, 1024, L"You %s the lower check box.\nNow edit controls will %s",
( ( CDXUTCheckBox* )pControl )->GetChecked() ? L"checked" : L"cleared",
( ( CDXUTCheckBox* )pControl )->GetChecked() ?
L"be cleared when you press Enter to send the text" :
L"retain the text context when you press Enter to send the text" );
g_SampleUI.GetStatic( IDC_OUTPUT )->SetText( wszOutput );
break;
case IDC_COMBOBOX:
{
DXUTComboBoxItem* pItem = ( ( CDXUTComboBox* )pControl )->GetSelectedItem();
if( pItem )
{
swprintf_s( wszOutput, 1024,
L"You selected a new item in the combobox.\nThe new item is \"%s\" and the associated data value is 0x%p",
pItem->strText, pItem->pData );
g_SampleUI.GetStatic( IDC_OUTPUT )->SetText( wszOutput );
}
break;
}
case IDC_RADIO1A:
case IDC_RADIO1B:
case IDC_RADIO1C:
swprintf_s( wszOutput, 1024,
L"You selected a new radio button in the UPPER radio group.\nThe new button is \"%s\"",
( ( CDXUTRadioButton* )pControl )->GetText() );
g_SampleUI.GetStatic( IDC_OUTPUT )->SetText( wszOutput );
break;
case IDC_RADIO2A:
case IDC_RADIO2B:
case IDC_RADIO2C:
swprintf_s( wszOutput, 1024,
L"You selected a new radio button in the LOWER radio group.\nThe new button is \"%s\"",
( ( CDXUTRadioButton* )pControl )->GetText() );
g_SampleUI.GetStatic( IDC_OUTPUT )->SetText( wszOutput );
break;
case IDC_LISTBOX:
switch( nEvent )
{
case EVENT_LISTBOX_ITEM_DBLCLK:
{
DXUTListBoxItem* pItem = ( ( CDXUTListBox* )pControl )->GetItem(
( ( CDXUTListBox* )pControl )->GetSelectedIndex( -1 ) );
swprintf_s( wszOutput, 1024,
L"You double clicked an item in the left list box. The item is\n\"%s\"",
pItem ? pItem->strText : L"" );
g_SampleUI.GetStatic( IDC_OUTPUT )->SetText( wszOutput );
break;
}
case EVENT_LISTBOX_SELECTION:
{
swprintf_s( wszOutput, 1024,
L"You changed the selection in the left list box. The selected item is %d",
( ( CDXUTListBox* )pControl )->GetSelectedIndex() );
g_SampleUI.GetStatic( IDC_OUTPUT )->SetText( wszOutput );
break;
}
}
break;
case IDC_LISTBOXM:
switch( nEvent )
{
case EVENT_LISTBOX_ITEM_DBLCLK:
{
DXUTListBoxItem* pItem = ( ( CDXUTListBox* )pControl )->GetItem(
( ( CDXUTListBox* )pControl )->GetSelectedIndex( -1 ) );
swprintf_s( wszOutput, 1024,
L"You double clicked an item in the right list box. The item is\n\"%s\"",
pItem ? pItem->strText : L"" );
g_SampleUI.GetStatic( IDC_OUTPUT )->SetText( wszOutput );
break;
}
case EVENT_LISTBOX_SELECTION:
{
swprintf_s( wszOutput, 1024,
L"You changed the selection in the right list box. The selected item(s) are\n" );
int nSelected = -1;
while( ( nSelected = ( ( CDXUTListBox* )pControl )->GetSelectedIndex( nSelected ) ) != -1 )
{
swprintf_s( wszOutput + lstrlenW( wszOutput ), 1024 - lstrlenW( wszOutput ), L"%d,",
nSelected );
}
// Remove the trailing comma if one exists.
if( wszOutput[lstrlenW( wszOutput ) - 1] == L',' )
wszOutput[lstrlenW( wszOutput ) - 1] = L'\0';
g_SampleUI.GetStatic( IDC_OUTPUT )->SetText( wszOutput );
break;
}
}
break;
}
}
//--------------------------------------------------------------------------------------
// Initialize the app
//--------------------------------------------------------------------------------------
void InitApp()
{
// Initialize dialogs
g_SettingsDlg.Init( &g_DialogResourceManager );
g_HUD.Init( &g_DialogResourceManager );
g_SampleUI.Init( &g_DialogResourceManager );
g_HUD.SetCallback( OnGUIEvent ); int iY = 10;
g_HUD.AddButton( IDC_TOGGLEFULLSCREEN, L"Toggle full screen", 35, iY, 125, 22 );
g_HUD.AddButton( IDC_TOGGLEREF, L"Toggle REF (F3)", 35, iY += 24, 125, 22 );
g_HUD.AddButton( IDC_CHANGEDEVICE, L"Change device (F2)", 35, iY += 24, 125, 22, VK_F2 );
g_SampleUI.SetCallback( OnGUIEvent );
g_SampleUI.SetFont( 1, L"Comic Sans MS", 24, FW_NORMAL );
g_SampleUI.SetFont( 2, L"Courier New", 16, FW_NORMAL );
// Static
g_SampleUI.AddStatic( IDC_STATIC, L"This is a static control.", 0, 0, 200, 30 );
g_SampleUI.AddStatic( IDC_OUTPUT,
L"This static control provides feedback for your action. It will change as you interact with the UI controls.", 20, 50, 620, 300 );
g_SampleUI.GetStatic( IDC_OUTPUT )->SetTextColor( D3DCOLOR_ARGB( 255, 255, 0, 0 ) ); // Change color to red
g_SampleUI.GetStatic( IDC_STATIC )->SetTextColor( D3DCOLOR_ARGB( 255, 0, 255, 0 ) ); // Change color to green
g_SampleUI.GetControl( IDC_OUTPUT )->GetElement( 0 )->dwTextFormat = DT_LEFT | DT_TOP | DT_WORDBREAK;
g_SampleUI.GetControl( IDC_OUTPUT )->GetElement( 0 )->iFont = 2;
g_SampleUI.GetControl( IDC_STATIC )->GetElement( 0 )->dwTextFormat = DT_CENTER | DT_VCENTER | DT_WORDBREAK;
// Buttons
g_SampleUI.AddButton( IDC_ENABLEIME, L"Enable (I)ME", 30, 390, 80, 35, L'I' );
g_SampleUI.AddButton( IDC_DISABLEIME, L"Disable I(M)E", 30, 430, 80, 35, L'M' );
// Edit box
g_SampleUI.AddEditBox( IDC_EDITBOX1, L"Edit control with default styles. Type text here and press Enter", 20, 440,
600, 32 );
// IME-enabled edit box
CDXUTIMEEditBox* pIMEEdit;
CDXUTIMEEditBox::InitDefaultElements( &g_SampleUI );
if( SUCCEEDED( CDXUTIMEEditBox::CreateIMEEditBox( &g_SampleUI, IDC_EDITBOX2,
L"IME-capable edit control with custom styles. Type and press Enter", 20, 390, 600, 45, false, &pIMEEdit ) ) )
{
g_SampleUI.AddControl( pIMEEdit );
pIMEEdit->GetElement( 0 )->iFont = 1;
pIMEEdit->GetElement( 1 )->iFont = 1;
pIMEEdit->GetElement( 9 )->iFont = 1;
pIMEEdit->GetElement( 0 )->TextureColor.Init( D3DCOLOR_ARGB( 128, 255, 255, 255 ) ); // Transparent center
pIMEEdit->SetBorderWidth( 7 );
pIMEEdit->SetTextColor( D3DCOLOR_ARGB( 255, 64, 64, 64 ) );
pIMEEdit->SetCaretColor( D3DCOLOR_ARGB( 255, 64, 64, 64 ) );
pIMEEdit->SetSelectedTextColor( D3DCOLOR_ARGB( 255, 255, 255, 255 ) );
pIMEEdit->SetSelectedBackColor( D3DCOLOR_ARGB( 255, 40, 72, 72 ) );
}
// Slider
g_SampleUI.AddSlider( IDC_SLIDER, 200, 450, 200, 24, 0, 100, 50, false );
// Checkbox
g_SampleUI.AddCheckBox( IDC_CHECKBOX, L"This is a checkbox with hotkey. Press 'C' to toggle the check state.",
170, 450, 350, 24, false, L'C', false );
g_SampleUI.AddCheckBox( IDC_CLEAREDIT,
L"This checkbox controls whether edit control text is cleared when Enter is pressed. (T)",
170, 460, 450, 24, false, L'T', false );
// Combobox
CDXUTComboBox* pCombo;
g_SampleUI.AddComboBox( IDC_COMBOBOX, 0, 0, 200, 24, L'O', false, &pCombo );
if( pCombo )
{
pCombo->SetDropHeight( 100 );
pCombo->AddItem( L"Combobox item (O)", ( LPVOID )0x11111111 );
pCombo->AddItem( L"Placeholder (O)", ( LPVOID )0x12121212 );
pCombo->AddItem( L"One more (O)", ( LPVOID )0x13131313 );
pCombo->AddItem( L"I can't get enough (O)", ( LPVOID )0x14141414 );
pCombo->AddItem( L"Ok, last one, I promise (O)", ( LPVOID )0x15151515 );
}
// Radio buttons
g_SampleUI.AddRadioButton( IDC_RADIO1A, 1, L"Radio group 1 Amy (1)", 0, 50, 220, 24, false, L'1' );
g_SampleUI.AddRadioButton( IDC_RADIO1B, 1, L"Radio group 1 Brian (2)", 0, 50, 220, 24, false, L'2' );
g_SampleUI.AddRadioButton( IDC_RADIO1C, 1, L"Radio group 1 Clark (3)", 0, 50, 220, 24, false, L'3' );
g_SampleUI.AddRadioButton( IDC_RADIO2A, 2, L"Single (4)", 0, 50, 90, 24, false, L'4' );
g_SampleUI.AddRadioButton( IDC_RADIO2B, 2, L"Double (5)", 0, 50, 90, 24, false, L'5' );
g_SampleUI.AddRadioButton( IDC_RADIO2C, 2, L"Triple (6)", 0, 50, 90, 24, false, L'6' );
// List box
g_SampleUI.AddListBox( IDC_LISTBOX, 30, 400, 200, 150, 0 );
for( int i = 0; i < 15; ++i )
{
WCHAR wszText[50];
swprintf_s( wszText, 50, L"Single-selection listbox item %d", i );
g_SampleUI.GetListBox( IDC_LISTBOX )->AddItem( wszText, ( LPVOID )( size_t )i );
}
g_SampleUI.AddListBox( IDC_LISTBOXM, 30, 400, 200, 150, CDXUTListBox::MULTISELECTION );
for( int i = 0; i < 30; ++i )
{
WCHAR wszText[50];
swprintf_s( wszText, 50, L"Multi-selection listbox item %d", i );
g_SampleUI.GetListBox( IDC_LISTBOXM )->AddItem( wszText, ( LPVOID )( size_t )i );
}
}
//--------------------------------------------------------------------------------------
// Handles the GUI events
//--------------------------------------------------------------------------------------
void CALLBACK OnGUIEvent(UINT nEvent, INT nControlID, CDXUTControl* /*pControl*/, void* /*pUserContext*/)
{
switch (nControlID)
{
case IDC_TOGGLEFULLSCREEN:
DXUTToggleFullScreen(); break;
case IDC_TOGGLEWARP:
DXUTToggleWARP(); break;
case IDC_CHANGEDEVICE:
g_D3DSettingsDlg.SetActive(!g_D3DSettingsDlg.IsActive()); break;
break;
break;
case IDC_FIT_TO_CASCADE:
g_CascadedShadow.m_eSelectedCascadesFit =
(FIT_PROJECTION_TO_CASCADES)PtrToUlong(g_FitToCascadesCombo->GetSelectedData());
break;
case IDC_FIT_TO_NEARFAR:
{
g_CascadedShadow.m_eSelectedNearFarFit =
(FIT_TO_NEAR_FAR)PtrToUlong(g_FitToNearFarCombo->GetSelectedData());
if (g_CascadedShadow.m_eSelectedNearFarFit == FIT_NEARFAR_PANCAKING)
{
g_CascadedShadow.m_eSelectedCascadeSelection = CASCADE_SELECTION_INTERVAL;
g_CascadeSelectionCombo->SetSelectedByData(ULongToPtr(CASCADE_SELECTION_INTERVAL));
}
}
break;
case IDC_CASCADE_SELECT:
{
static int iSaveLastCascadeValue = 100;
if ((CASCADE_SELECTION)PtrToUlong(g_CascadeSelectionCombo->GetSelectedData()) == CASCADE_SELECTION_MAP)
{
if ((FIT_TO_NEAR_FAR)PtrToUlong(g_FitToNearFarCombo->GetSelectedData()) == FIT_NEARFAR_PANCAKING)
{
g_FitToNearFarCombo->SetSelectedByData(ULongToPtr(FIT_NEARFAR_SCENE_AABB));
g_CascadedShadow.m_eSelectedNearFarFit = FIT_NEARFAR_SCENE_AABB;
}
g_CascadedShadow.m_iCascadePartitionsZeroToOne[g_CascadeConfig.m_nCascadeLevels - 1] = iSaveLastCascadeValue;
}
else
{
iSaveLastCascadeValue = g_CascadedShadow.m_iCascadePartitionsZeroToOne[g_CascadeConfig.m_nCascadeLevels - 1];
g_CascadedShadow.m_iCascadePartitionsZeroToOne[g_CascadeConfig.m_nCascadeLevels - 1] = 100;
}
g_CascadedShadow.m_eSelectedCascadeSelection =
(CASCADE_SELECTION)PtrToUlong(g_CascadeSelectionCombo->GetSelectedData());
g_HUD.GetSlider(IDC_CASCADELEVEL1 + g_CascadeConfig.m_nCascadeLevels - 1)->SetValue(
g_CascadedShadow.m_iCascadePartitionsZeroToOne[g_CascadeConfig.m_nCascadeLevels - 1]);
WCHAR label[16];
swprintf_s(label, L"L%d: %d", g_CascadeConfig.m_nCascadeLevels,
g_CascadedShadow.m_iCascadePartitionsZeroToOne[g_CascadeConfig.m_nCascadeLevels - 1]);
g_HUD.GetStatic(IDC_CASCADELEVEL1TEXT + g_CascadeConfig.m_nCascadeLevels - 1)->SetText(label);
}
break;
case IDC_MOVE_LIGHT_IN_TEXEL_INC:
g_bMoveLightTexelSize = !g_bMoveLightTexelSize;
g_CascadedShadow.m_bMoveLightTexelSize = g_bMoveLightTexelSize;
break;
case IDC_TOGGLEVISUALIZECASCADES:
g_bVisualizeCascades = !g_bVisualizeCascades;
break;
case IDC_PCF_SIZE:
{
INT PCFSize = g_HUD.GetSlider(IDC_PCF_SIZE)->GetValue();
PCFSize *= 2;
PCFSize -= 1;
WCHAR desc[256];
swprintf_s(desc, L"PCF Blur: %d ", PCFSize);
g_HUD.GetStatic(IDC_PCF_SIZETEXT)->SetText(desc);
g_CascadedShadow.m_iPCFBlurSize = PCFSize;
}
break;
case IDC_PCF_OFFSET_SIZE:
{
INT offset = g_HUD.GetSlider(IDC_PCF_OFFSET_SIZE)->GetValue();
FLOAT useoffset = (FLOAT)offset * 0.001f;
WCHAR desc[256];
swprintf_s(desc, L" Offset: %0.03f", useoffset);
g_HUD.GetStatic(IDC_PCF_OFFSET_SIZETEXT)->SetText(desc);
g_CascadedShadow.m_fPCFOffset = useoffset;
}
break;
case IDC_BLEND_BETWEEN_MAPS_CHECK:
if (g_HUD.GetCheckBox(IDC_BLEND_BETWEEN_MAPS_CHECK)->GetChecked())
g_CascadedShadow.m_iBlurBetweenCascades = 1;
else
g_CascadedShadow.m_iBlurBetweenCascades = 0;
break;
case IDC_BLEND_MAPS_SLIDER:
{
INT val = g_HUD.GetSlider(IDC_BLEND_MAPS_SLIDER)->GetValue();
g_CascadedShadow.m_fBlurBetweenCascadesAmount = (float)val * 0.005f;
WCHAR dta[256];
swprintf_s(dta, L"Cascade Blur %0.03f", g_CascadedShadow.m_fBlurBetweenCascadesAmount);
g_HUD.GetCheckBox(IDC_BLEND_BETWEEN_MAPS_CHECK)->SetText(dta);
}
break;
case IDC_TOGGLE_DERIVATIVE_OFFSET:
{
if (g_CascadedShadow.m_iDerivativeBasedOffset == 0)
g_CascadedShadow.m_iDerivativeBasedOffset = 1;
else
g_CascadedShadow.m_iDerivativeBasedOffset = 0;
}
break;
case IDC_BUFFER_SIZE:
{
INT value = 32 * g_HUD.GetSlider(IDC_BUFFER_SIZE)->GetValue();
INT max = 8192 / g_CascadeConfig.m_nCascadeLevels;
if (value > max)
{
value = max;
g_HUD.GetSlider(IDC_BUFFER_SIZE)->SetValue(value / 32);
}
WCHAR desc[256];
swprintf_s(desc, L"Texture Size: %d ", value);
g_HUD.GetStatic(IDC_BUFFER_SIZETEXT)->SetText(desc);
//Only tell the app to recreate buffers once the user is through moving the slider.
if (nEvent == EVENT_SLIDER_VALUE_CHANGED_UP)
{
g_CascadeConfig.m_iBufferSize = value;
}
}
break;
case IDC_SELECTED_SCENE:
{
SCENE_SELECTION ss = (SCENE_SELECTION)PtrToUlong(g_SceneSelectCombo->GetSelectedData());
if (ss == POWER_PLANT_SCENE)
{
g_pSelectedMesh = &g_MeshPowerPlant;
}
else if (ss == TEST_SCENE)
{
g_pSelectedMesh = &g_MeshTestScene;
}
DestroyD3DComponents();
CreateD3DComponents(DXUTGetD3D11Device());
UpdateViewerCameraNearFar();
}
case IDC_SELECTED_CAMERA:
{
g_CascadedShadow.m_eSelectedCamera = (CAMERA_SELECTION)
(g_CameraSelectCombo->GetSelectedIndex());
if (g_CascadedShadow.m_eSelectedCamera < 1)
{
g_pActiveCamera = &g_ViewerCamera;
}
else
{
g_pActiveCamera = &g_LightCamera;
}
}
break;
case IDC_CASCADELEVELS:
{
INT ind = 1 + g_CascadeLevelsCombo->GetSelectedIndex();
g_CascadeConfig.m_nCascadeLevels = ind;
for (INT index = 0; index < ind; ++index)
{
g_HUD.GetStatic(IDC_CASCADELEVEL1TEXT + index)->SetVisible(true);
g_HUD.GetSlider(IDC_CASCADELEVEL1 + index)->SetVisible(true);
}
for (int index = ind; index < MAX_CASCADES; ++index)
{
g_HUD.GetStatic(IDC_CASCADELEVEL1TEXT + index)->SetVisible(false);
g_HUD.GetSlider(IDC_CASCADELEVEL1 + index)->SetVisible(false);
}
INT value = 32 * g_HUD.GetSlider(IDC_BUFFER_SIZE)->GetValue();
INT max = 8192 / g_CascadeConfig.m_nCascadeLevels;
if (value > max)
{
WCHAR desc[256];
value = max;
swprintf_s(desc, L"Texture Size: %d ", value);
g_HUD.GetStatic(IDC_BUFFER_SIZETEXT)->SetText(desc);
g_HUD.GetSlider(IDC_BUFFER_SIZE)->SetValue(value / 32);
g_CascadeConfig.m_iBufferSize = value;
}
// update the selected camera based on these changes.
INT selected = g_CameraSelectCombo->GetSelectedIndex();
WCHAR dta[60];
g_CameraSelectCombo->RemoveAllItems();
swprintf_s(dta, L"Eye Camera %ld", EYE_CAMERA + 1);
g_CameraSelectCombo->AddItem(dta, ULongToPtr(EYE_CAMERA));
swprintf_s(dta, L"Light Camera %ld", LIGHT_CAMERA + 1);
g_CameraSelectCombo->AddItem(dta, ULongToPtr(LIGHT_CAMERA));
for (int index = 0; index < g_CascadeConfig.m_nCascadeLevels; ++index)
{
swprintf_s(dta, L"Cascade Cam %d", index + 1);
g_CameraSelectCombo->AddItem(dta, ULongToPtr(ORTHO_CAMERA1 + index));
}
if (selected - 1 >= ind)
{
selected = ind + 1;
}
g_CameraSelectCombo->SetSelectedByIndex(selected);
g_CascadedShadow.m_eSelectedCamera = (CAMERA_SELECTION)
(g_CameraSelectCombo->GetSelectedIndex());
if (g_CascadedShadow.m_eSelectedCamera < 1)
{
g_pActiveCamera = &g_ViewerCamera;
}
else
{
g_pActiveCamera = &g_LightCamera;
}
}
break;
case IDC_DEPTHBUFFERFORMAT:
{
SHADOW_TEXTURE_FORMAT sbt = (SHADOW_TEXTURE_FORMAT)PtrToUlong(g_DepthBufferFormatCombo->GetSelectedData());
g_CascadeConfig.m_ShadowBufferFormat = sbt;
}
break;
case IDC_CASCADELEVEL1:
case IDC_CASCADELEVEL2:
case IDC_CASCADELEVEL3:
case IDC_CASCADELEVEL4:
case IDC_CASCADELEVEL5:
case IDC_CASCADELEVEL6:
case IDC_CASCADELEVEL7:
case IDC_CASCADELEVEL8:
{
INT ind = nControlID - IDC_CASCADELEVEL1;
INT move = g_HUD.GetSlider(nControlID)->GetValue();
CDXUTSlider* selecteSlider;
CDXUTStatic* selectedStatic;
WCHAR label[16];
for (int index = 0; index < ind; ++index)
{
selecteSlider = g_HUD.GetSlider(IDC_CASCADELEVEL1 + index);
INT sVal = selecteSlider->GetValue();
if (move < sVal)
{
selecteSlider->SetValue(move);
selectedStatic = g_HUD.GetStatic(IDC_CASCADELEVEL1TEXT + index);
swprintf_s(label, L"L%d: %d", index + 1, move);
selectedStatic->SetText(label);
g_CascadedShadow.m_iCascadePartitionsZeroToOne[index] = move;
}
}
for (int index = ind; index < MAX_CASCADES; ++index)
{
selecteSlider = g_HUD.GetSlider(IDC_CASCADELEVEL1 + index);
INT sVal = selecteSlider->GetValue();
if (move >= sVal)
{
selecteSlider->SetValue(move);
selectedStatic = g_HUD.GetStatic(IDC_CASCADELEVEL1TEXT + index);
swprintf_s(label, L"L%d: %d", index + 1, move);
selectedStatic->SetText(label);
g_CascadedShadow.m_iCascadePartitionsZeroToOne[index] = move;
}
}
}
break;
}
}
//--------------------------------------------------------------------------------------
// MouseCallback
//--------------------------------------------------------------------------------------
void CALLBACK MouseProc( bool bLeftButtonDown,
bool bRightButtonDown,
bool bMiddleButtonDown,
bool bSideButton1Down,
bool bSideButton2Down,
INT nMouseWheelDelta,
INT xPos,
INT yPos,
void* pUserContext )
{
static D3DXVECTOR2 mousepos = D3DXVECTOR2(xPos, yPos);
int dx = xPos - mousepos.x;
int dy = yPos - mousepos.y;
mousepos = D3DXVECTOR2(xPos, yPos);
camera->SetRange(nMouseWheelDelta);
//move up, down, left, right
if(bLeftButtonDown && bRightButtonDown)
{
camera->Slide(D3DXVECTOR2(dx,dy));
}
//rotate
else if(bRightButtonDown)
{
camera->Rotate(D3DXVECTOR2(dx*0.003f, dy*0.003f));
}
else if(bLeftButtonDown)
{
//rotate selected chain
if(bMouseRotateX && manipulator->selectedChain != -1)
{
float MCOEFF = 0.02f;
cprimitive* cube = manipulator->cube[manipulator->selectedChain];
float newAngX;
newAngX = cube->vAngle.x + (float)dy*MCOEFF;
if(newAngX >= cube->restrictAngleX.x && newAngX <= cube->restrictAngleX.y)
cube->vAngle.x = newAngX;
wchar_t str[256];
swprintf(str,L"X: %.2f",cube->vAngle.x);
g_SampleUI.GetStatic(IDC_STATIC7)->SetText(str);
}
if(bMouseRotateY && manipulator->selectedChain != -1)
{
float MCOEFF = 0.02f;
cprimitive* cube = manipulator->cube[manipulator->selectedChain];
float newAngY;
newAngY = cube->vAngle.y + (float)dx*MCOEFF;
if(newAngY >= cube->restrictAngleY.x && newAngY <= cube->restrictAngleY.y)
cube->vAngle.y = newAngY;
wchar_t str[256];
swprintf(str,L"Y: %.2f",cube->vAngle.y);
g_SampleUI.GetStatic(IDC_STATIC8)->SetText(str);
}
}
}
// Handles the GUI events
void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext )
{
switch( nControlID )
{
case IDC_TOGGLEFULLSCREEN:
{
DXUTToggleFullScreen();
break;
}
case IDC_TOGGLEREF:
{
DXUTToggleREF();
break;
}
case IDC_CHANGEDEVICE:
{
gD3DSettingsDlg.SetActive( !gD3DSettingsDlg.IsActive() );
break;
}
case IDC_TEXT:
case IDC_EXPOSURE:
{
gLog2Exposure = (gSampleUI.GetSlider(IDC_EXPOSURE)->GetValue() / 100.0f - 0.5f) * 33.33333;
WCHAR wstr[MAX_PATH];
swprintf_s(wstr, MAX_PATH,
L"Texture Size: %d x %d\n"
L"logRGB L1: %.2f%%\n"
//L"logRGB RMSE: %.4f\n"
//L"Relative error: %.2f%%\n"
//L"mPSNR: %.2f%%\n"
L"Exposure: %.2f\n"
L"Compression Time: %0.2f ms\n"
L"Compression Rate: %0.2f Mp/s\n",
gTexWidth, gTexHeight,
gError, gLog2Exposure,
gCompTime, gCompRate);
gSampleUI.GetStatic(IDC_TEXT)->SetText(wstr);
break;
}
case IDC_MT:
{
// Shut down all previous threading abilities.
DestroyThreads();
gMultithreaded = gSampleUI.GetCheckBox(IDC_MT)->GetChecked();
if (gMultithreaded)
{
InitWin32Threads();
}
// Recompress the texture.
RecompressTexture();
gSampleUI.SendEvent(IDC_TEXT, true, gSampleUI.GetStatic(IDC_TEXT));
break;
}
case IDC_PROFILE:
{
gCompressionFunc = (CompressionFunc*)gSampleUI.GetComboBox(IDC_PROFILE)->GetSelectedData();
// Recompress the texture.
RecompressTexture();
gSampleUI.SendEvent(IDC_TEXT, true, gSampleUI.GetStatic(IDC_TEXT));
break;
}
case IDC_LOAD_TEXTURE:
{
// Store the current working directory.
TCHAR workingDirectory[MAX_PATH];
GetCurrentDirectory(MAX_PATH, workingDirectory);
// Open a file dialog.
OPENFILENAME openFileName;
WCHAR file[MAX_PATH];
file[0] = 0;
ZeroMemory(&openFileName, sizeof(OPENFILENAME));
openFileName.lStructSize = sizeof(OPENFILENAME);
openFileName.lpstrFile = file;
openFileName.nMaxFile = MAX_PATH;
openFileName.lpstrFilter = L"DDS\0*.dds\0\0";
openFileName.nFilterIndex = 1;
openFileName.lpstrInitialDir = NULL;
openFileName.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
if(GetOpenFileName(&openFileName))
{
//CreateTextures(openFileName.lpstrFile);
SAFE_RELEASE(gUncompressedSRV);
LoadTexture(openFileName.lpstrFile);
}
// Restore the working directory. GetOpenFileName changes the current working directory which causes problems with relative paths to assets.
SetCurrentDirectory(workingDirectory);
RecompressTexture();
gSampleUI.SendEvent(IDC_TEXT, true, gSampleUI.GetStatic(IDC_TEXT));
break;
}
case IDC_RECOMPRESS:
{
// Recompress the texture.
RecompressTexture();
gSampleUI.SendEvent(IDC_TEXT, true, gSampleUI.GetStatic(IDC_TEXT));
break;
}
case IDC_SAVE_TEXTURE:
{
// Store the current working directory.
TCHAR workingDirectory[MAX_PATH];
GetCurrentDirectory(MAX_PATH, workingDirectory);
// Open a file dialog.
OPENFILENAME openFileName;
WCHAR file[MAX_PATH];
file[0] = 0;
ZeroMemory(&openFileName, sizeof(OPENFILENAME));
openFileName.lStructSize = sizeof(OPENFILENAME);
openFileName.lpstrFile = file;
openFileName.nMaxFile = MAX_PATH;
openFileName.lpstrFilter = L"DDS\0*.dds\0\0";
openFileName.lpstrDefExt = L"dds";
openFileName.nFilterIndex = 1;
openFileName.lpstrInitialDir = NULL;
openFileName.Flags = OFN_PATHMUSTEXIST;
if(GetSaveFileName(&openFileName))
{
SaveTexture(gCompressedSRV,openFileName.lpstrFile);
}
// Restore the working directory. GetOpenFileName changes the current working directory which causes problems with relative paths to assets.
SetCurrentDirectory(workingDirectory);
break;
}
case IDC_IMAGEVIEW:
{
gImageView = (EImageView)(INT_PTR)gSampleUI.GetComboBox(IDC_IMAGEVIEW)->GetSelectedData();
break;
}
}
}
// Create any D3D11 resources that aren't dependent on the back buffer
HRESULT CALLBACK OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
V_RETURN(gDialogResourceManager.OnD3D11CreateDevice(pd3dDevice, pd3dImmediateContext));
V_RETURN(gD3DSettingsDlg.OnD3D11CreateDevice(pd3dDevice));
gTxtHelper = new CDXUTTextHelper(pd3dDevice, pd3dImmediateContext, &gDialogResourceManager, 15);
// Create a vertex shader.
ID3DBlob* vertexShaderBuffer = NULL;
V_RETURN(CompileShaderFromFile(L"shaders.hlsl", "PassThroughVS", "vs_4_0", &vertexShaderBuffer));
V_RETURN(pd3dDevice->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &gVertexShader));
// Create a pixel shader that renders the composite frame.
ID3DBlob* pixelShaderBuffer = NULL;
V_RETURN(CompileShaderFromFile(L"shaders.hlsl", "RenderFramePS", "ps_4_0", &pixelShaderBuffer));
V_RETURN(pd3dDevice->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &gRenderFramePS));
// Create a pixel shader that renders the error texture.
V_RETURN(CompileShaderFromFile(L"shaders.hlsl", "RenderTexturePS", "ps_4_0", &pixelShaderBuffer));
V_RETURN(pd3dDevice->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &gRenderTexturePS));
// Create a pixel shader that shows alpha
V_RETURN(CompileShaderFromFile(L"shaders.hlsl", "RenderAlphaPS", "ps_4_0", &pixelShaderBuffer));
V_RETURN(pd3dDevice->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &gRenderAlphaPS));
// Create our vertex input layout
const D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
V_RETURN(pd3dDevice->CreateInputLayout(layout, ARRAYSIZE(layout), vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &gVertexLayout));
SAFE_RELEASE(vertexShaderBuffer);
SAFE_RELEASE(pixelShaderBuffer);
// Create a vertex buffer for three textured quads.
D3DXVECTOR2 quadSize(0.32f, 0.32f);
D3DXVECTOR2 quadOrigin(-0.66f, -0.0f);
Vertex tripleQuadVertices[18];
ZeroMemory(tripleQuadVertices, sizeof(tripleQuadVertices));
for(int i = 0; i < 18; i += 6)
{
tripleQuadVertices[i].position = D3DXVECTOR3(quadOrigin.x - quadSize.x, quadOrigin.y + quadSize.y, 0.0f);
tripleQuadVertices[i].texCoord = D3DXVECTOR2(0.0f, 0.0f);
tripleQuadVertices[i + 1].position = D3DXVECTOR3(quadOrigin.x + quadSize.x, quadOrigin.y + quadSize.y, 0.0f);
tripleQuadVertices[i + 1].texCoord = D3DXVECTOR2(1.0f, 0.0f);
tripleQuadVertices[i + 2].position = D3DXVECTOR3(quadOrigin.x + quadSize.x, quadOrigin.y - quadSize.y, 0.0f);
tripleQuadVertices[i + 2].texCoord = D3DXVECTOR2(1.0f, 1.0f);
tripleQuadVertices[i + 3].position = D3DXVECTOR3(quadOrigin.x + quadSize.x, quadOrigin.y - quadSize.y, 0.0f);
tripleQuadVertices[i + 3].texCoord = D3DXVECTOR2(1.0f, 1.0f);
tripleQuadVertices[i + 4].position = D3DXVECTOR3(quadOrigin.x - quadSize.x, quadOrigin.y - quadSize.y, 0.0f);
tripleQuadVertices[i + 4].texCoord = D3DXVECTOR2(0.0f, 1.0f);
tripleQuadVertices[i + 5].position = D3DXVECTOR3(quadOrigin.x - quadSize.x, quadOrigin.y + quadSize.y, 0.0f);
tripleQuadVertices[i + 5].texCoord = D3DXVECTOR2(0.0f, 0.0f);
quadOrigin.x += 0.66f;
}
D3D11_BUFFER_DESC bufDesc;
ZeroMemory(&bufDesc, sizeof(bufDesc));
bufDesc.Usage = D3D11_USAGE_DEFAULT;
bufDesc.ByteWidth = sizeof(tripleQuadVertices);
bufDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bufDesc.CPUAccessFlags = 0;
D3D11_SUBRESOURCE_DATA data;
ZeroMemory(&data, sizeof(data));
data.pSysMem = tripleQuadVertices;
V_RETURN(pd3dDevice->CreateBuffer(&bufDesc, &data, &gVertexBuffer));
// Create a vertex buffer for a single textured quad.
quadSize = D3DXVECTOR2(1.0f, 1.0f);
quadOrigin = D3DXVECTOR2(0.0f, 0.0f);
Vertex singleQuadVertices[6];
singleQuadVertices[0].position = D3DXVECTOR3(quadOrigin.x - quadSize.x, quadOrigin.y + quadSize.y, 0.0f);
singleQuadVertices[0].texCoord = D3DXVECTOR2(0.0f, 0.0f);
singleQuadVertices[1].position = D3DXVECTOR3(quadOrigin.x + quadSize.x, quadOrigin.y + quadSize.y, 0.0f);
singleQuadVertices[1].texCoord = D3DXVECTOR2(1.0f, 0.0f);
singleQuadVertices[2].position = D3DXVECTOR3(quadOrigin.x + quadSize.x, quadOrigin.y - quadSize.y, 0.0f);
singleQuadVertices[2].texCoord = D3DXVECTOR2(1.0f, 1.0f);
singleQuadVertices[3].position = D3DXVECTOR3(quadOrigin.x + quadSize.x, quadOrigin.y - quadSize.y, 0.0f);
singleQuadVertices[3].texCoord = D3DXVECTOR2(1.0f, 1.0f);
singleQuadVertices[4].position = D3DXVECTOR3(quadOrigin.x - quadSize.x, quadOrigin.y - quadSize.y, 0.0f);
singleQuadVertices[4].texCoord = D3DXVECTOR2(0.0f, 1.0f);
singleQuadVertices[5].position = D3DXVECTOR3(quadOrigin.x - quadSize.x, quadOrigin.y + quadSize.y, 0.0f);
singleQuadVertices[5].texCoord = D3DXVECTOR2(0.0f, 0.0f);
ZeroMemory(&bufDesc, sizeof(bufDesc));
bufDesc.Usage = D3D11_USAGE_DEFAULT;
bufDesc.ByteWidth = sizeof(singleQuadVertices);
bufDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bufDesc.CPUAccessFlags = 0;
ZeroMemory(&data, sizeof(data));
data.pSysMem = singleQuadVertices;
V_RETURN(pd3dDevice->CreateBuffer(&bufDesc, &data, &gQuadVB));
// Create a constant buffer
ZeroMemory(&bufDesc, sizeof(bufDesc));
bufDesc.ByteWidth = sizeof( VS_CONSTANT_BUFFER );
bufDesc.Usage = D3D11_USAGE_DYNAMIC;
bufDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
bufDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
V_RETURN(pd3dDevice->CreateBuffer(&bufDesc, NULL, &gConstantBuffer));
// Create a sampler state
D3D11_SAMPLER_DESC SamDesc;
SamDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
SamDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
SamDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
SamDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
SamDesc.MipLODBias = 0.0f;
SamDesc.MaxAnisotropy = 1;
SamDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
SamDesc.BorderColor[0] = SamDesc.BorderColor[1] = SamDesc.BorderColor[2] = SamDesc.BorderColor[3] = 0;
SamDesc.MinLOD = 0;
SamDesc.MaxLOD = D3D11_FLOAT32_MAX;
V_RETURN(pd3dDevice->CreateSamplerState(&SamDesc, &gSamPoint));
// Load and initialize the textures.
WCHAR path[MAX_PATH];
V_RETURN(DXUTFindDXSDKMediaFileCch(path, MAX_PATH, L"Images\\Desk_21_hdr.dds"));
V_RETURN(CreateTextures(path));
// Update the UI's texture width and height.
gSampleUI.SendEvent(IDC_TEXT, true, gSampleUI.GetStatic(IDC_TEXT));
return S_OK;
}
// Render the scene using the D3D11 device
void CALLBACK OnD3D11FrameRender( ID3D11Device* pd3dDevice, ID3D11DeviceContext* pd3dImmediateContext, double fTime,
float fElapsedTime, void* pUserContext )
{
// Recompress the texture gFrameDelay frames after the app has started. This produces more accurate timing of the
// compression algorithm.
if(gFrameNum == gFrameDelay)
{
RecompressTexture();
gSampleUI.SendEvent(IDC_TEXT, true, gSampleUI.GetStatic(IDC_TEXT));
gFrameNum++;
}
else if(gFrameNum < gFrameDelay)
{
gFrameNum++;
}
// If the settings dialog is being shown, then render it instead of rendering the app's scene
if( gD3DSettingsDlg.IsActive() )
{
gD3DSettingsDlg.OnRender( fElapsedTime );
return;
}
// Clear the render target and depth stencil
float ClearColor[4] = { 0.02f, 0.02f, 0.02f, 1.0f };
ID3D11RenderTargetView* pRTV = DXUTGetD3D11RenderTargetView();
pd3dImmediateContext->ClearRenderTargetView( pRTV, ClearColor );
ID3D11DepthStencilView* pDSV = DXUTGetD3D11DepthStencilView();
pd3dImmediateContext->ClearDepthStencilView( pDSV, D3D11_CLEAR_DEPTH, 1.0, 0 );
// Set the input layout.
pd3dImmediateContext->IASetInputLayout( gVertexLayout );
// Set the vertex buffer.
UINT stride = sizeof( Vertex );
UINT offset = 0;
if (gImageView == eImageView_All)
{
pd3dImmediateContext->IASetVertexBuffers( 0, 1, &gVertexBuffer, &stride, &offset );
}
else
{
pd3dImmediateContext->IASetVertexBuffers( 0, 1, &gQuadVB, &stride, &offset );
}
// Set the primitive topology
pd3dImmediateContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
// Update the Constant Buffer
D3D11_MAPPED_SUBRESOURCE MappedResource;
pd3dImmediateContext->Map( gConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &MappedResource );
VS_CONSTANT_BUFFER* pConstData = ( VS_CONSTANT_BUFFER* )MappedResource.pData;
ZeroMemory(pConstData, sizeof(VS_CONSTANT_BUFFER));
SetView(&pConstData->mView);
pConstData->exposure = powf(2.0, gLog2Exposure);
pd3dImmediateContext->Unmap( gConstantBuffer, 0 );
// Set the shaders
ID3D11Buffer* pBuffers[1] = { gConstantBuffer };
pd3dImmediateContext->VSSetConstantBuffers( 0, 1, pBuffers );
pd3dImmediateContext->VSSetShader( gVertexShader, NULL, 0 );
if (gSampleUI.GetCheckBox(IDC_ALPHA)->GetChecked())
{
pd3dImmediateContext->PSSetShader( gRenderAlphaPS, NULL, 0 );
}
else
{
pd3dImmediateContext->PSSetShader( gRenderFramePS, NULL, 0 );
}
pd3dImmediateContext->PSSetConstantBuffers(0, 1, pBuffers );
// Set the texture sampler.
pd3dImmediateContext->PSSetSamplers( 0, 1, &gSamPoint );
// Render the textures.
if (gImageView == eImageView_Uncompressed || gImageView == eImageView_All )
{
pd3dImmediateContext->PSSetShaderResources( 0, 1, &gUncompressedSRV );
}
else if (gImageView == eImageView_Compressed)
{
pd3dImmediateContext->PSSetShaderResources( 0, 1, &gCompressedSRV );
}
else if (gImageView == eImageView_Error)
{
pd3dImmediateContext->PSSetShaderResources( 0, 1, &gErrorSRV );
}
pd3dImmediateContext->Draw( 6, 0 );
if (gImageView == eImageView_All)
{
pd3dImmediateContext->PSSetShaderResources( 0, 1, &gCompressedSRV );
pd3dImmediateContext->Draw( 6, 6 );
pd3dImmediateContext->PSSetShaderResources( 0, 1, &gErrorSRV );
pd3dImmediateContext->Draw( 6, 12 );
}
DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L"HUD / Stats" );
HRESULT hr;
V(gHUD.OnRender( fElapsedTime ));
V(gSampleUI.OnRender( fElapsedTime ));
RenderText();
DXUT_EndPerfEvent();
}
//--------------------------------------------------------------------------------------
// Handles the GUI events
//--------------------------------------------------------------------------------------
void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext )
{
switch( nControlID )
{
case IDC_TOGGLEFULLSCREEN:
DXUTToggleFullScreen(); break;
case IDC_TOGGLEREF:
DXUTToggleREF(); break;
case IDC_CHANGEDEVICE:
g_D3DSettingsDlg.SetActive( !g_D3DSettingsDlg.IsActive() ); break;
case IDC_DISPLACEMENTLVL:
{
displacement_level = g_SampleUI.GetSlider( IDC_DISPLACEMENTLVL )->GetValue()/ 100.0f;
tessplane.setdislvl(displacement_level);
WCHAR sz[100];
swprintf_s( sz, L"Displacement Level: %2.1f", displacement_level );
g_SampleUI.GetStatic( IDC_DISPLACEMENTLVL_STATIC )->SetText( sz );
}
break;
case IDC_TESSLVL:
{
tess_lvl = g_SampleUI.GetSlider( IDC_TESSLVL )->GetValue();
tessplane.setTesslvl(tess_lvl);
tesscube.set_tesslvl(tess_lvl);
fuse.set_tesslvl(tess_lvl);
WCHAR sz[100];
swprintf_s( sz, L"Tesselation Level: %2.1f", tess_lvl );
g_SampleUI.GetStatic( IDC_TESSLVL_STATIC )->SetText( sz );
}
break;
case IDC_TOGGLEBUILDING:
show_buildings = g_SampleUI.GetCheckBox( IDC_TOGGLEBUILDING )->GetChecked();
break;
case IDC_TOGGLEWIRE:
tessplane.toggleWire(g_SampleUI.GetCheckBox( IDC_TOGGLEWIRE )->GetChecked());
tesscube.toggleWire(g_SampleUI.GetCheckBox( IDC_TOGGLEWIRE )->GetChecked());
fuse.toggleWire(g_SampleUI.GetCheckBox( IDC_TOGGLEWIRE )->GetChecked());
break;
case IDC_TOGGLEDT:
tessplane.toggleDT(g_SampleUI.GetCheckBox( IDC_TOGGLEDT )->GetChecked());
break;
case IDC_PARTITION_INTEGER:
tessplane.settessmethod(0);
tesscube.settessmethod(0);
fuse.settessmethod(0);
break;
case IDC_PARTITION_FRAC_EVEN:
tessplane.settessmethod(1);
tesscube.settessmethod(1);
fuse.settessmethod(1);
break;
case IDC_PARTITION_FRAC_ODD:
tesscube.settessmethod(2);
tessplane.settessmethod(2);
fuse.settessmethod(2);
break;
}
}
//--------------------------------------------------------------------------------------
// Initialize the app
//--------------------------------------------------------------------------------------
void InitApp()
{
g_CascadeConfig.m_nCascadeLevels = 3;
g_CascadeConfig.m_iBufferSize = 1024;
g_CascadedShadow.m_iCascadePartitionsZeroToOne[0] = 5;
g_CascadedShadow.m_iCascadePartitionsZeroToOne[1] = 15;
g_CascadedShadow.m_iCascadePartitionsZeroToOne[2] = 60;
g_CascadedShadow.m_iCascadePartitionsZeroToOne[3] = 100;
g_CascadedShadow.m_iCascadePartitionsZeroToOne[4] = 100;
g_CascadedShadow.m_iCascadePartitionsZeroToOne[5] = 100;
g_CascadedShadow.m_iCascadePartitionsZeroToOne[6] = 100;
g_CascadedShadow.m_iCascadePartitionsZeroToOne[7] = 100;
// Pick some arbitrary intervals for the Cascade Maps
//g_CascadedShadow.m_iCascadePartitionsZeroToOne[0] = 2;
//g_CascadedShadow.m_iCascadePartitionsZeroToOne[1] = 4;
//g_CascadedShadow.m_iCascadePartitionsZeroToOne[2] = 6;
//g_CascadedShadow.m_iCascadePartitionsZeroToOne[3] = 9;
//g_CascadedShadow.m_iCascadePartitionsZeroToOne[4] = 13;
//g_CascadedShadow.m_iCascadePartitionsZeroToOne[5] = 26;
//g_CascadedShadow.m_iCascadePartitionsZeroToOne[6] = 36;
//g_CascadedShadow.m_iCascadePartitionsZeroToOne[7] = 70;
g_CascadedShadow.m_iCascadePartitionsMax = 100;
// Initialize dialogs
g_D3DSettingsDlg.Init(&g_DialogResourceManager);
g_HUD.Init(&g_DialogResourceManager);
g_SampleUI.Init(&g_DialogResourceManager);
g_HUD.SetCallback(OnGUIEvent); INT iY = 10;
// Add tons of GUI stuff
g_HUD.AddButton(IDC_TOGGLEFULLSCREEN, L"Toggle full screen", 0, iY, 170, 23);
g_HUD.AddButton(IDC_TOGGLEWARP, L"Toggle WARP (F3)", 0, iY += 26, 170, 23, VK_F3);
g_HUD.AddButton(IDC_CHANGEDEVICE, L"Change device (F2)", 0, iY += 26, 170, 23, VK_F2);
g_HUD.AddCheckBox(IDC_TOGGLEVISUALIZECASCADES, L"Visualize Cascades", 0, iY += 26, 170, 23, g_bVisualizeCascades, VK_F8);
g_HUD.AddComboBox(IDC_DEPTHBUFFERFORMAT, 0, iY += 26, 170, 23, VK_F10, false, &g_DepthBufferFormatCombo);
g_DepthBufferFormatCombo->AddItem(L"32 bit Buffer", ULongToPtr(CASCADE_DXGI_FORMAT_R32_TYPELESS));
g_DepthBufferFormatCombo->AddItem(L"16 bit Buffer", ULongToPtr(CASCADE_DXGI_FORMAT_R16_TYPELESS));
g_DepthBufferFormatCombo->AddItem(L"24 bit Buffer", ULongToPtr(CASCADE_DXGI_FORMAT_R24G8_TYPELESS));
SHADOW_TEXTURE_FORMAT sbt = (SHADOW_TEXTURE_FORMAT)PtrToUlong(g_DepthBufferFormatCombo->GetSelectedData());
g_CascadeConfig.m_ShadowBufferFormat = sbt;
WCHAR desc[256];
swprintf_s(desc, L"Texture Size: %d ", g_CascadeConfig.m_iBufferSize);
g_HUD.AddStatic(IDC_BUFFER_SIZETEXT, desc, 0, iY + 26, 30, 10);
g_HUD.AddSlider(IDC_BUFFER_SIZE, 0, iY += 46, 128, 15, 1, 128, g_CascadeConfig.m_iBufferSize / 32);
g_HUD.AddStatic(IDC_PCF_SIZETEXT, L"PCF Blur: 3", 0, iY + 16, 30, 10);
g_HUD.AddSlider(IDC_PCF_SIZE, 90, iY += 20, 64, 15, 1, 16, g_CascadedShadow.m_iPCFBlurSize / 2 + 1);
swprintf_s(desc, L" Offset: %0.03f", g_CascadedShadow.m_fPCFOffset);
g_HUD.AddStatic(IDC_PCF_OFFSET_SIZETEXT, desc, 0, iY + 16, 30, 10);
g_HUD.AddSlider(IDC_PCF_OFFSET_SIZE, 115, iY += 20, 50, 15, 0, 50, (INT)(g_CascadedShadow.m_fPCFOffset * 1000.0f));
swprintf_s(desc, L"Cascade Blur %0.03f", g_CascadedShadow.m_fBlurBetweenCascadesAmount);
bool bValue;
if (g_CascadedShadow.m_iBlurBetweenCascades == 0) bValue = false;
else bValue = true;
g_HUD.AddCheckBox(IDC_BLEND_BETWEEN_MAPS_CHECK, desc, 0, iY + 15, 170, 23, bValue);
g_HUD.AddSlider(IDC_BLEND_MAPS_SLIDER, 40, iY + 33, 100, 15, 0, 100, (INT)
(g_CascadedShadow.m_fBlurBetweenCascadesAmount * 2000.0f));
iY += 26;
if (g_CascadedShadow.m_iDerivativeBasedOffset == 0) bValue = false;
else bValue = true;
g_HUD.AddCheckBox(IDC_TOGGLE_DERIVATIVE_OFFSET, L"DDX, DDY offset", 0, iY += 26, 170, 23, bValue);
WCHAR dta[60];
g_HUD.AddComboBox(IDC_SELECTED_SCENE, 0, iY += 26, 170, 23, VK_F8, false, &g_SceneSelectCombo);
g_SceneSelectCombo->AddItem(L"Power Plant", ULongToPtr(POWER_PLANT_SCENE));
g_SceneSelectCombo->AddItem(L"Test Scene", ULongToPtr(TEST_SCENE));
g_HUD.AddComboBox(IDC_SELECTED_CAMERA, 0, iY += 26, 170, 23, VK_F9, false, &g_CameraSelectCombo);
swprintf_s(dta, L"Eye Camera %ld", EYE_CAMERA + 1);
g_CameraSelectCombo->AddItem(dta, ULongToPtr(EYE_CAMERA));
swprintf_s(dta, L"Light Camera %ld", LIGHT_CAMERA + 1);
g_CameraSelectCombo->AddItem(dta, ULongToPtr(LIGHT_CAMERA));
for (int index = 0; index < g_CascadeConfig.m_nCascadeLevels; ++index)
{
swprintf_s(dta, L"Cascade Cam %d", index + 1);
g_CameraSelectCombo->AddItem(dta, ULongToPtr(ORTHO_CAMERA1 + index));
}
g_HUD.AddCheckBox(IDC_MOVE_LIGHT_IN_TEXEL_INC, L"Fit Light to Texels",
0, iY += 26, 170, 23, g_bMoveLightTexelSize, VK_F8);
g_CascadedShadow.m_bMoveLightTexelSize = g_bMoveLightTexelSize;
g_HUD.AddComboBox(IDC_FIT_TO_CASCADE, 0, iY += 26, 170, 23, VK_F9, false, &g_FitToCascadesCombo);
g_FitToCascadesCombo->AddItem(L"Fit Scene", ULongToPtr(FIT_TO_SCENE));
g_FitToCascadesCombo->AddItem(L"Fit Cascades", ULongToPtr(FIT_TO_CASCADES));
g_CascadedShadow.m_eSelectedCascadesFit = FIT_TO_SCENE;
g_HUD.AddComboBox(IDC_FIT_TO_NEARFAR, 0, iY += 26, 170, 23, VK_F9, false, &g_FitToNearFarCombo);
g_FitToNearFarCombo->AddItem(L"AABB/Scene NearFar", ULongToPtr(FIT_NEARFAR_SCENE_AABB));
g_FitToNearFarCombo->AddItem(L"Pancaking", ULongToPtr(FIT_NEARFAR_PANCAKING));
g_FitToNearFarCombo->AddItem(L"0:1 NearFar", ULongToPtr(FIT_NEARFAR_ZERO_ONE));
g_FitToNearFarCombo->AddItem(L"AABB NearFar", ULongToPtr(FIT_NEARFAR_AABB));
g_CascadedShadow.m_eSelectedNearFarFit = FIT_NEARFAR_SCENE_AABB;
g_HUD.AddComboBox(IDC_CASCADE_SELECT, 0, iY += 26, 170, 23, VK_F9, false, &g_CascadeSelectionCombo);
g_CascadeSelectionCombo->AddItem(L"Map Selection", ULongToPtr(CASCADE_SELECTION_MAP));
g_CascadeSelectionCombo->AddItem(L"Interval Selection", ULongToPtr(CASCADE_SELECTION_INTERVAL));
g_CascadedShadow.m_eSelectedCascadeSelection = CASCADE_SELECTION_MAP;
g_HUD.AddComboBox(IDC_CASCADELEVELS, 0, iY += 26, 170, 23, VK_F11, false, &g_CascadeLevelsCombo);
swprintf_s(dta, L"%d Level", 1);
g_CascadeLevelsCombo->AddItem(dta, ULongToPtr(L1COMBO + 1));
for (INT index = 1; index < MAX_CASCADES; ++index)
{
swprintf_s(dta, L"%d Levels", index + 1);
g_CascadeLevelsCombo->AddItem(dta, ULongToPtr(L1COMBO + index));
}
g_CascadeLevelsCombo->SetSelectedByIndex(g_CascadeConfig.m_nCascadeLevels - 1);
INT sp = 12;
iY += 20;
WCHAR label[16];
// Color the cascade labels similar to the visualization.
D3DCOLOR tcolors[] =
{
0xFFFF0000,
0xFF00FF00,
0xFF0000FF,
0xFFFF00FF,
0xFFFFFF00,
0xFFFFFFFF,
0xFF00AAFF,
0xFFAAFFAA
};
for (INT index = 0; index < MAX_CASCADES; ++index)
{
swprintf_s(label, L"L%d: %d", (index + 1), g_CascadedShadow.m_iCascadePartitionsZeroToOne[index]);
g_HUD.AddStatic(index + IDC_CASCADELEVEL1TEXT, label, 0, iY + sp, 30, 10);
g_HUD.GetStatic(index + IDC_CASCADELEVEL1TEXT)->SetTextColor(tcolors[index]);
g_HUD.AddSlider(index + IDC_CASCADELEVEL1, 50, iY += 15, 100, 15, 0, 100, g_CascadedShadow.m_iCascadePartitionsZeroToOne[index]);
}
for (INT index = 0; index < g_CascadeConfig.m_nCascadeLevels; ++index)
{
g_HUD.GetStatic(IDC_CASCADELEVEL1TEXT + index)->SetVisible(true);
g_HUD.GetSlider(IDC_CASCADELEVEL1 + index)->SetVisible(true);
}
for (int index = g_CascadeConfig.m_nCascadeLevels; index < MAX_CASCADES; ++index)
{
g_HUD.GetStatic(IDC_CASCADELEVEL1TEXT + index)->SetVisible(false);
g_HUD.GetSlider(IDC_CASCADELEVEL1 + index)->SetVisible(false);
}
g_SampleUI.SetCallback(OnGUIEvent); iY = 10;
}
