virtual void onPostUpdate(grp::ISkeleton* skeleton)
{
int value = g_SampleUI.GetSlider(IDC_SLIDER_ARM)->GetValue();
float arm_scale = 0.75f + value / 200.0f;
value = g_SampleUI.GetSlider(IDC_SLIDER_LEG)->GetValue();
float leg_scale = 0.75f + value / 200.0f;
value = g_SampleUI.GetSlider(IDC_SLIDER_BODY)->GetValue();
float body_scale = 0.75f + value / 200.0f;
set_bone_scale(skeleton, L"Bip L UpperArm", arm_scale);
set_bone_scale(skeleton, L"Bip L Forearm", arm_scale);
set_bone_scale(skeleton, L"Bip R UpperArm", arm_scale);
set_bone_scale(skeleton, L"Bip R Forearm", arm_scale);
set_bone_scale(skeleton, L"Bip L Thigh", leg_scale);
set_bone_scale(skeleton, L"Bip R Thigh", leg_scale);
set_bone_scale(skeleton, L"Bip L Calf", leg_scale);
set_bone_scale(skeleton, L"Bip R Calf", leg_scale);
set_bone_scale(skeleton, L"Bip Pelvis", body_scale);
set_bone_scale(skeleton, L"Bip Spine", body_scale);
set_bone_scale(skeleton, L"Bip Spine1", body_scale);
set_bone_scale(skeleton, L"Bip Spine2", body_scale);
set_bone_scale(skeleton, L"Bip Spine3", body_scale);
}
//--------------------------------------------------------------------------------------
// This callback function will be called at the end of every frame to perform all the
// rendering calls for the scene, and it will also be called if the window needs to be
// repainted. After this function has returned, DXUT will call
// IDirect3DDevice9::Present to display the contents of the next buffer in the swap chain
//--------------------------------------------------------------------------------------
void CALLBACK OnFrameRender( IDirect3DDevice9* pd3dDevice, double fTime, float fElapsedTime, void* pUserContext )
{
// If the settings dialog is being shown, then
// render it instead of rendering the app's scene
if( g_SettingsDlg.IsActive() )
{
g_SettingsDlg.OnRender( fElapsedTime );
return;
}
HRESULT hr;
// Clear the render target and the zbuffer
V( pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB( 0, 50, 50, 50 ), 1.0f, 0 ) );
// Render the scene
if( SUCCEEDED( pd3dDevice->BeginScene() ) )
{
// Get the projection & view matrix from the camera class
D3DXMATRIXA16 mViewProjection = ( *g_Camera.GetViewMatrix() ) * ( *g_Camera.GetProjMatrix() );
g_Skybox.SetDrawSH( false );
g_Skybox.Render( &mViewProjection, 1.0f, 1.0f );
V( g_pEffect->SetMatrix( "g_mViewProjection", &mViewProjection ) );
V( g_pEffect->SetFloat( "g_fTime", ( float )fTime ) );
// Set the amount of transmitted light per color channel
D3DXVECTOR3 vColorTransmit;
vColorTransmit.x = g_SampleUI.GetSlider( IDC_RED_TRANSMIT_SLIDER )->GetValue() / 1000.0f;
vColorTransmit.y = g_SampleUI.GetSlider( IDC_GREEN_TRANSMIT_SLIDER )->GetValue() / 1000.0f;
vColorTransmit.z = g_SampleUI.GetSlider( IDC_BLUE_TRANSMIT_SLIDER )->GetValue() / 1000.0f;
V( g_pEffect->SetFloatArray( "g_vColorTransmit", vColorTransmit, 3 ) );
// for Cubic degree rendering
V( g_pEffect->SetFloat( "g_fLightIntensity", g_fLightIntensity ) );
V( g_pEffect->SetFloatArray( "g_vLightDirection", g_vLightDirection, 3 * sizeof( float ) ) );
V( g_pEffect->SetFloatArray( "g_vLightCoeffsR", m_fRLC, 4 * sizeof( float ) ) );
V( g_pEffect->SetFloatArray( "g_vLightCoeffsG", m_fGLC, 4 * sizeof( float ) ) );
V( g_pEffect->SetFloatArray( "g_vLightCoeffsB", m_fBLC, 4 * sizeof( float ) ) );
pd3dDevice->SetRenderState( D3DRS_FILLMODE, g_bWireFrame ? D3DFILL_WIREFRAME : D3DFILL_SOLID );
DrawFrame( pd3dDevice, g_pFrameRoot );
DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L"HUD / Stats" ); // These events are to help PIX identify what the code is doing
RenderText();
V( g_HUD.OnRender( fElapsedTime ) );
V( g_SampleUI.OnRender( fElapsedTime ) );
V( g_LightControl.OnRender9( D3DXCOLOR( 1, 1, 1, 1 ), ( D3DXMATRIX* )g_Camera.GetViewMatrix(),
( D3DXMATRIX* )g_Camera.GetProjMatrix(), g_Camera.GetEyePt() ) );
DXUT_EndPerfEvent();
V( pd3dDevice->EndScene() );
}
}
//--------------------------------------------------------------------------------------
// 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);
}
void setAnimationWeight()
{
if (g_model == NULL)
{
return;
}
#define SET_ANIMATION_WEIGHT(a, w) \
{\
grp::IAnimation* animation = g_model->findAnimation(a);\
if (animation != NULL)\
{\
animation->setWeight(w);\
}\
}
float weight = g_SampleUI.GetSlider(IDC_SLIDER_WEIGHT)->GetValue() / 100.0f;
if (weight < 0.5f)
{
SET_ANIMATION_WEIGHT(L"fight", 2 * (0.5f - weight));
SET_ANIMATION_WEIGHT(L"walk", 2 * weight);
SET_ANIMATION_WEIGHT(L"run", 0.0f);
g_fCurSpeed = weight * WALK_SPEED * 2;
}
else
{
SET_ANIMATION_WEIGHT(L"fight", 0.0f);
SET_ANIMATION_WEIGHT(L"walk", 2 * (1.0f - weight));
SET_ANIMATION_WEIGHT(L"run", 2 * (weight - 0.5f));
g_fCurSpeed = 2 * (WALK_SPEED * (1.0f - weight) + RUN_SPEED * (weight - 0.5f));
}
}
//--------------------------------------------------------------------------------------
// 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_SLIDER_TIMESCALE:
{
int iValue = g_SampleUI.GetSlider(IDC_SLIDER_TIMESCALE)->GetValue();
if (iValue < 50)
{
g_fTimeScale = iValue / 50.0f;
}
else
{
g_fTimeScale = iValue / 10.0f - 4.0f;
}
}
break;
case IDC_SLIDER_WEIGHT:
{
if (g_model == NULL)
{
break;
}
setAnimationWeight();
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 UpdateLightingEnvironment()
{
// Gather lighting options from the HUD
g_vLightDirection = g_LightControl.GetLightDirection();
g_fLightIntensity = g_SampleUI.GetSlider( IDC_LIGHT_SLIDER )->GetValue() / 100.0f;
g_fEnvIntensity = g_SampleUI.GetSlider( IDC_ENV_SLIDER )->GetValue() / 1000.0f;
// Create the spotlight
D3DXSHEvalConeLight( D3DXSH_MAXORDER, &g_vLightDirection, D3DX_PI / 8.0f,
g_fLightIntensity, g_fLightIntensity, g_fLightIntensity,
m_fRLC, m_fGLC, m_fBLC );
float fSkybox[3][D3DXSH_MAXORDER*D3DXSH_MAXORDER];
// Scale the light probe environment contribution based on input options
D3DXSHScale( fSkybox[0], D3DXSH_MAXORDER, g_fSkyBoxLightSH[0], g_fEnvIntensity );
D3DXSHScale( fSkybox[1], D3DXSH_MAXORDER, g_fSkyBoxLightSH[1], g_fEnvIntensity );
D3DXSHScale( fSkybox[2], D3DXSH_MAXORDER, g_fSkyBoxLightSH[2], g_fEnvIntensity );
// Combine the environment and the spotlight
D3DXSHAdd( m_fRLC, D3DXSH_MAXORDER, m_fRLC, fSkybox[0] );
D3DXSHAdd( m_fGLC, D3DXSH_MAXORDER, m_fGLC, fSkybox[1] );
D3DXSHAdd( m_fBLC, D3DXSH_MAXORDER, m_fBLC, fSkybox[2] );
}
//--------------------------------------------------------------------------------------
// This callback function will be called once at the beginning of every frame. This is the
// best location for your application to handle updates to the scene, but is not
// intended to contain actual rendering calls, which should instead be placed in the
// OnFrameRender callback.
//--------------------------------------------------------------------------------------
void CALLBACK OnFrameMove( double fTime, float fElapsedTime, void* pUserContext )
{
// Update the camera's position based on user input
g_Camera.FrameMove( fElapsedTime );
UpdateLightingEnvironment();
if( g_pAnimController != NULL )
{
g_pAnimController->SetTrackSpeed( 0, g_SampleUI.GetSlider( IDC_ANIMATION_SPEED )->GetValue() / 1000.0f );
g_pAnimController->AdvanceTime( fElapsedTime, NULL );
}
UpdateFrameMatrices( g_pFrameRoot, g_Camera.GetWorldMatrix() );
}
//--------------------------------------------------------------------------------------
// 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;
}
}
//--------------------------------------------------------------------------------------
// 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;
}
}
//--------------------------------------------------------------------------------------
// 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)
{
switch(nControlID)
{
case IDC_SLIDER_TIMESCALE:
{
int iValue = g_SampleUI.GetSlider(IDC_SLIDER_TIMESCALE)->GetValue();
if (iValue < 50)
{
g_fTimeScale = iValue / 50.0f;
}
else
{
g_fTimeScale = iValue / 10.0f - 4.0f;
}
}
break;
case IDC_SLIDER_WEIGHT:
{
if (g_model == NULL)
{
break;
}
setAnimationWeight();
break;
}
case IDC_BUTTON_ATTACK:
if (g_model != NULL)
{
grp::IAnimation* fight = g_model->findAnimation(L"fight");
if (fight != NULL && fight->getWeight() == 1.0f)
{
g_model->playAnimation(L"attack", grp::ANIMATION_SINGLE);
}
else
{
g_model->playAnimation(L"attack_up", grp::ANIMATION_SINGLE);
}
}
break;
case IDC_CHECK_RAGDOLL:
if (g_SampleUI.GetCheckBox(IDC_CHECK_RAGDOLL)->GetChecked())
{
g_character->createRagdoll(g_model->getTransform());
}
else
{
g_character->destroyRagdoll();
}
break;
case IDC_CHECK_GPU_SKINNING:
{
bool enable = g_SampleUI.GetCheckBox(IDC_CHECK_GPU_SKINNING)->GetChecked();
g_character->setGpuSkinning(enable);
}
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;
}
//--------------------------------------------------------------------------------------
// Handles the GUI events
//--------------------------------------------------------------------------------------
void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext )
{
float val;
wchar_t str[512];
FILE* file2;
LPCWSTR ttext;
switch( nControlID )
{
//main menu
case IDC_TOGGLEFULLSCREEN:
DXUTToggleFullScreen();
break;
case IDC_SAVEFILE_BTN:
swprintf(str,L"./%s",g_HUD.GetEditBox( IDC_SAVEFILE )->GetText());
manipulator->SaveConfig(str);
break;
case IDC_NEWFILE_BTN:
swprintf(str,L"./%s",g_HUD.GetEditBox( IDC_NEWFILE )->GetText());
file2 = _wfopen(str,L"w+");
fclose(file2);
IniWrite(str,L"manipulator",L"chainsize",L"1");
IniWrite(str,L"chain_0",L"coefficient",L"0.8");
IniWrite(str,L"chain_0",L"direction",L"1.00");
IniWrite(str,L"chain_0",L"displace",L"-1.57");
IniWrite(str,L"chain_0",L"length",L"90.00");
IniWrite(str,L"chain_0",L"width",L"10.00");
IniWrite(str,L"chain_0",L"initangle",L"0.00 0.00");
IniWrite(str,L"chain_0",L"angle_restrict_phi",L"-3.14 3.14");
IniWrite(str,L"chain_0",L"angle_restrict_theta",L"-3.14 3.14");
IniWrite(str,L"chain_0",L"parent_index",L"-1");
IniWrite(str,L"chain_0",L"model",L"");
IniWrite(str,L"chain_0",L"offset",L"0 0 0");
IniWrite(str,L"chain_0",L"mass",L"100.00");
IniWrite(str,L"chain_0",L"tilt",L"0");
IniWrite(str,L"chain_0",L"pressure",L"0");
IniWrite(str,L"chain_0",L"laser",L"0");
manipulator->Release();
manipulator->Create(DXUTGetD3D9Device(), str);
MessageBox(0,L"Создана новая конфигурация манипулятора",L"",0);
OnChainSelect(-1);
break;
case IDC_LOADFILE_BTN:
manipulator->Release();
swprintf(str,L"./%s",g_HUD.GetEditBox( IDC_LOADFILE )->GetText());
manipulator->Create(DXUTGetD3D9Device(), str);
MessageBox(0,L"Манипулятор загружен из файла",L"",0);
OnChainSelect(-1);
break;
//dialog menu
case IDC_ADDCHAIN:
manipulator->AddChain(DXUTGetD3D9Device());
break;
case IDC_REMOVECHAIN:
manipulator->RemoveChain();
break;
case IDC_WIDTH:
switch( nEvent )
{
case EVENT_EDITBOX_STRING:
{
float fWidth;
LPCWSTR text = (( CDXUTEditBox* )pControl )->GetText();
swscanf(text, L"%f", &fWidth);
g_SampleUI.GetSlider(IDC_WIDTH_SLIDER)->SetValue(fWidth);
manipulator->cube[manipulator->selectedChain]->SetWidth(fWidth);
break;
}
}
break;
case IDC_WIDTH_SLIDER:
val = (float)( ( CDXUTSlider* )pControl )->GetValue();
manipulator->cube[manipulator->selectedChain]->SetWidth(val);
swprintf(str,L"%.2f",val);
g_SampleUI.GetEditBox( IDC_WIDTH )->SetText(str);
break;
case IDC_LENGTH:
switch( nEvent )
{
case EVENT_EDITBOX_STRING:
{
float fLength;
LPCWSTR text = (( CDXUTEditBox* )pControl )->GetText();
swscanf(text, L"%f", &fLength);
g_SampleUI.GetSlider(IDC_LENGTH_SLIDER)->SetValue(fLength);
manipulator->cube[manipulator->selectedChain]->SetLength(fLength);
break;
}
}
break;
case IDC_LENGTH_SLIDER:
val = (float)( ( CDXUTSlider* )pControl )->GetValue();
manipulator->cube[manipulator->selectedChain]->SetLength(val);
swprintf(str,L"%.2f",val);
g_SampleUI.GetEditBox( IDC_LENGTH )->SetText(str);
break;
case IDC_ANGLE_RESTRICT_XL:
case IDC_ANGLE_RESTRICT_XU:
case IDC_ANGLE_RESTRICT_YL:
case IDC_ANGLE_RESTRICT_YU:
switch( nEvent )
{
case EVENT_EDITBOX_STRING:
{
LPCWSTR text = (( CDXUTEditBox* )pControl )->GetText();
swscanf(text, L"%f", &val);
if(pControl->GetID() == IDC_ANGLE_RESTRICT_XL)
manipulator->cube[manipulator->selectedChain]->restrictAngleX.x = val;
else if(pControl->GetID() == IDC_ANGLE_RESTRICT_XU)
manipulator->cube[manipulator->selectedChain]->restrictAngleX.y = val;
else if(pControl->GetID() == IDC_ANGLE_RESTRICT_YL)
manipulator->cube[manipulator->selectedChain]->restrictAngleY.x = val;
else if(pControl->GetID() == IDC_ANGLE_RESTRICT_YU)
manipulator->cube[manipulator->selectedChain]->restrictAngleY.y = val;
break;
}
}
break;
case IDC_ANGLE_RESTRICT_XL_BTN:
swprintf(str,L"%.2f", manipulator->cube[manipulator->selectedChain]->vAngle.x);
g_SampleUI.GetEditBox( IDC_ANGLE_RESTRICT_XL )->SetText(str);
manipulator->cube[manipulator->selectedChain]->restrictAngleX.x = manipulator->cube[manipulator->selectedChain]->vAngle.x;
break;
case IDC_ANGLE_RESTRICT_XU_BTN:
swprintf(str,L"%.2f", manipulator->cube[manipulator->selectedChain]->vAngle.x);
g_SampleUI.GetEditBox( IDC_ANGLE_RESTRICT_XU )->SetText(str);
manipulator->cube[manipulator->selectedChain]->restrictAngleX.y = manipulator->cube[manipulator->selectedChain]->vAngle.x;
break;
case IDC_ANGLE_RESTRICT_YL_BTN:
swprintf(str,L"%.2f", manipulator->cube[manipulator->selectedChain]->vAngle.y);
g_SampleUI.GetEditBox( IDC_ANGLE_RESTRICT_YL )->SetText(str);
manipulator->cube[manipulator->selectedChain]->restrictAngleY.x = manipulator->cube[manipulator->selectedChain]->vAngle.y;
break;
case IDC_ANGLE_RESTRICT_YU_BTN:
swprintf(str,L"%.2f", manipulator->cube[manipulator->selectedChain]->vAngle.y);
g_SampleUI.GetEditBox( IDC_ANGLE_RESTRICT_YU )->SetText(str);
manipulator->cube[manipulator->selectedChain]->restrictAngleY.y = manipulator->cube[manipulator->selectedChain]->vAngle.y;
break;
case IDC_OFFSET_X:
case IDC_OFFSET_Y:
case IDC_OFFSET_Z:
switch( nEvent )
{
case EVENT_EDITBOX_STRING:
{
LPCWSTR text = (( CDXUTEditBox* )pControl )->GetText();
swscanf(text, L"%f", &val);
if(pControl->GetID() == IDC_OFFSET_X)
manipulator->cube[manipulator->selectedChain]->vOffset.x = val;
else if(pControl->GetID() == IDC_OFFSET_Y)
manipulator->cube[manipulator->selectedChain]->vOffset.y = val;
else if(pControl->GetID() == IDC_OFFSET_Z)
manipulator->cube[manipulator->selectedChain]->vOffset.z = val;
break;
}
}
break;
case IDC_DISPLACE:
ttext = (( CDXUTEditBox* )pControl )->GetText();
swscanf(ttext, L"%f", &val);
manipulator->cube[manipulator->selectedChain]->fDisplace = val;
break;
case IDC_DIRECTION:
ttext = (( CDXUTEditBox* )pControl )->GetText();
swscanf(ttext, L"%f", &val);
manipulator->cube[manipulator->selectedChain]->fDirection = val;
break;
case IDC_COEFFICIENT:
ttext = (( CDXUTEditBox* )pControl )->GetText();
swscanf(ttext, L"%f", &val);
manipulator->cube[manipulator->selectedChain]->fCoefficient = val;
break;
case IDC_MASS:
ttext = (( CDXUTEditBox* )pControl )->GetText();
swscanf(ttext, L"%f", &val);
manipulator->cube[manipulator->selectedChain]->fMass = val;
break;
case IDC_TILT:
manipulator->cube[manipulator->selectedChain]->bTilt = ((CDXUTCheckBox*)pControl )->GetChecked();
break;
case IDC_PRESSURE:
manipulator->cube[manipulator->selectedChain]->bPressure = ((CDXUTCheckBox*)pControl )->GetChecked();
break;
case IDC_LASER:
manipulator->cube[manipulator->selectedChain]->bLaser = ((CDXUTCheckBox*)pControl )->GetChecked();
break;
case IDC_CMD:
switch( nEvent )
{
case EVENT_EDITBOX_STRING:
ttext = (( CDXUTEditBox* )pControl )->GetText();
CMDProcess(ttext);
(( CDXUTEditBox* )pControl )->SetText(L"");
break;
case EVENT_EDITBOX_CHANGE:
break;
}
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;
}
//--------------------------------------------------------------------------------------
// 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;
}
}
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:
{
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;
}
}
}
//--------------------------------------------------------------------------------------
// Handles the GUI events
//--------------------------------------------------------------------------------------
void CALLBACK OnGUIEvent(UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext)
{
switch( nControlID )
{
case IDC_CHANGEDEVICE:
g_D3DSettingsDlg.SetActive( !g_D3DSettingsDlg.IsActive() );
break;
case IDC_LIGHT_SIZE:
break;
case IDC_SHADOW_ALGORITHM:
OldShadowAlgorithm = ShadowAlgorithm;
ShadowAlgorithm = ((CDXUTComboBox*)pControl)->GetSelectedIndex();
break;
case IDC_LIGHT_ZN:
//g_Widget.SetLightZn( (float)g_SampleUI.GetSlider(IDC_LIGHT_ZN)->GetValue()/2 );
break;
case IDC_LIGHT_ZF:
//g_Widget.SetLightZf( (float)g_SampleUI.GetSlider(IDC_LIGHT_ZF)->GetValue()+30 );
break;
case IDC_LIGHT_FOV:
//g_Widget.SetLightFov((float)g_SampleUI.GetSlider(IDC_LIGHT_FOV)->GetValue()/10);
break;
case IDC_fDefaultDepthBias:
g_fDefaultDepthBias = (float)g_SampleUI.GetSlider(IDC_fDefaultDepthBias)->GetValue()/100;
break;
case IDC_fDepthBiasHammer:
g_fDepthBiasHammer = (float)g_SampleUI.GetSlider(IDC_fDepthBiasHammer)->GetValue()/4000.0;
break;
case IDC_fDepthBiasLeftForearm:
g_fDepthBiasLeftForearm = (float)g_SampleUI.GetSlider(IDC_fDepthBiasLeftForearm)->GetValue()/4000.0;
break;
case IDC_fDepthBiasRightForearm:
g_fDepthBiasRightForearm = (float)g_SampleUI.GetSlider(IDC_fDepthBiasRightForearm)->GetValue()/4000.0;
break;
case IDC_fDepthBiasLeftShoulder:
g_fDepthBiasLeftShoulder = (float)g_SampleUI.GetSlider(IDC_fDepthBiasLeftShoulder)->GetValue()/4000.0;
break;
case IDC_fDepthBiasRightShoulder:
g_fDepthBiasRightShoulder = (float)g_SampleUI.GetSlider(IDC_fDepthBiasRightShoulder)->GetValue()/4000.0;
break;
case IDC_fDepthBiasBlackPlate:
g_fDepthBiasBlackPlate = (float)g_SampleUI.GetSlider(IDC_fDepthBiasBlackPlate)->GetValue()/4000.0;
break;
case IDC_fDepthBiasHelmet:
g_fDepthBiasHelmet = (float)g_SampleUI.GetSlider(IDC_fDepthBiasHelmet)->GetValue()/4000.0;
break;
case IDC_fDepthBiasEyes:
g_fDepthBiasEyes = (float)g_SampleUI.GetSlider(IDC_fDepthBiasEyes)->GetValue()/4000.0;
break;
case IDC_fDepthBiasBelt:
g_fDepthBiasBelt = (float)g_SampleUI.GetSlider(IDC_fDepthBiasBelt)->GetValue()/4000.0;
break;
case IDC_fDepthBiasLeftThigh:
g_fDepthBiasLeftThigh = (float)g_SampleUI.GetSlider(IDC_fDepthBiasLeftThigh)->GetValue()/4000.0;
break;
case IDC_fDepthBiasRightThigh:
g_fDepthBiasRightThigh = (float)g_SampleUI.GetSlider(IDC_fDepthBiasRightThigh)->GetValue()/4000.0;
break;
case IDC_fDepthBiasLeftShin:
g_fDepthBiasLeftShin = (float)g_SampleUI.GetSlider(IDC_fDepthBiasLeftShin)->GetValue()/4000.0;
break;
case IDC_fDepthBiasRightShin:
g_fDepthBiasRightShin = (float)g_SampleUI.GetSlider(IDC_fDepthBiasRightShin)->GetValue()/4000.0;
break;
case IDC_fDepthBiasObject0:
g_fDepthBiasObject0 = (float)g_SampleUI.GetSlider(IDC_fDepthBiasObject0)->GetValue()/4000.0;
break;
case IDC_NUM_LIGHT_SAMPLE:
g_nNumLightSample = 2*(int)g_SampleUI.GetSlider(IDC_NUM_LIGHT_SAMPLE)->GetValue();
break;
case IDC_BIAS_3RD_DEPTH:
g_f3rdDepthDelta = (float)g_SampleUI.GetSlider(IDC_BIAS_3RD_DEPTH)->GetValue()/100;
break;
case IDC_BIAS_1ST_DEPTH:
g_f1stDepthDelta = (float)g_SampleUI.GetSlider(IDC_BIAS_3RD_DEPTH)->GetValue()/500;
break;
}
}
//--------------------------------------------------------------------------------------
// Create any D3D10 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D10CreateDevice(ID3D10Device* pDev10, const DXGI_SURFACE_DESC *pBackBufferSurfaceDesc, void* pUserContext)
{
HRESULT hr;
g_pSkyBox = new S3UTSkybox();
//g_pEnvMap = new HDRCubeTexture;
V_RETURN(DXUTSetMediaSearchPath(L"..\\Source\\SoftShadows"));
V_RETURN(g_DialogResourceManager.OnD3D10CreateDevice(pDev10));
V_RETURN(g_D3DSettingsDlg.OnD3D10CreateDevice(pDev10));
V_RETURN(D3DX10CreateFont(pDev10, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, L"Arial", &g_pFont10));
g_SampleUI.GetSlider(IDC_LIGHT_SIZE)->SetValue((int)(g_fFilterSize * 200.0));
g_SampleUI.GetComboBox(IDC_SHADOW_ALGORITHM)->SetSelectedByIndex(ssmap.bAccurateShadow == true ? 0 : 1);
switch( ShadowAlgorithm )
{
case STANDARD_BP:
g_ABP.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext);
break;
case BP_MSSM_KERNEL:
g_BPMSSMKernel.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext);
break;
case STD_VSM:
g_StdVSM.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext);
break;
case MIP_VSM:
g_MipVSM.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext);
break;
case HIR_BP:
g_HBP.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext);
break;
case BP_GI:
g_BPGI.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext);
break;
case STD_PCSS:
g_PCSS.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext);
break;
default:
break;
}
g_NoShadow.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext);
g_Final.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext);
g_GBuffer.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext);
g_ScrQuadRender.OnD3D10CreateDevice(g_ABP.m_pEffect,pDev10,pBackBufferSurfaceDesc,pUserContext);
ssmap.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext);
g_Widget.OnD3D10CreateDevice( pDev10,pBackBufferSurfaceDesc,pUserContext );
g_Blender.OnD3D10CreateDevice( pDev10,pBackBufferSurfaceDesc,pUserContext );
V_RETURN(D3DX10CreateSprite(pDev10, 512, &g_pSprite10));
{//must be after g_ABP create a device,because they uses the members of g_ABP
static const D3D10_INPUT_ELEMENT_DESC scenemeshlayout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D10_INPUT_PER_VERTEX_DATA, 0 },
};
if (g_MeshLight.Create(pDev10, L"arrow.x", (D3D10_INPUT_ELEMENT_DESC*)scenemeshlayout, 3) != S_OK)
{
MessageBox(DXUTGetHWND(), L"Could not load geometry from arrow.x", L"Error", MB_OK);
exit(0);
}
D3D10_PASS_DESC PassDesc;
V_RETURN(g_NoShadow.m_pEffect->GetTechniqueByName("RenderAcc")->GetPassByIndex(0)->GetDesc(&PassDesc));
V_RETURN(pDev10->CreateInputLayout(scenemeshlayout, 3, PassDesc.pIAInputSignature, PassDesc.IAInputSignatureSize, &g_pMaxLayout));
}
LoadNewModel();
//V_RETURN( DXUTFindDXSDKMediaFileCch( g_EnvMapFilePath, MAX_PATH_STR, g_DefaultEnvMapName[0] ) );
//g_pEnvMap->OnCreateDevice(pDev10, g_EnvMapFilePath, DXGI_FORMAT_R8G8B8A8_UNORM);
g_pSkyBox->OnCreateDevice( pDev10 );
// g_pSkyBox->SetTexture( g_pEnvMap->m_TextureRV );
g_pFloatBufferSurfaceDesc.SampleDesc.Count = pBackBufferSurfaceDesc->SampleDesc.Count;
g_pFloatBufferSurfaceDesc.SampleDesc.Quality = pBackBufferSurfaceDesc->SampleDesc.Quality;
D3DXVECTOR3 vTmp = D3DXVECTOR3(1, 2, 3);
D3DXVec3Normalize(&g_vLightDir, &vTmp);
SAFE_RELEASE(g_pRenderState);
D3D10_RASTERIZER_DESC RasterizerState;
RasterizerState.FillMode = D3D10_FILL_SOLID;
RasterizerState.CullMode = D3D10_CULL_FRONT;
RasterizerState.FrontCounterClockwise = true;
RasterizerState.DepthBias = false;
RasterizerState.DepthBiasClamp = 0.1;
RasterizerState.SlopeScaledDepthBias = 0;
RasterizerState.DepthClipEnable = true;
RasterizerState.ScissorEnable = false;
RasterizerState.MultisampleEnable = false;
RasterizerState.AntialiasedLineEnable = false;
V(pDev10->CreateRasterizerState(&RasterizerState, &g_pRenderState));
SAFE_RELEASE(g_pDSState);
D3D10_DEPTH_STENCIL_DESC DSState;
ZeroMemory(&DSState, sizeof(DSState));
DSState.DepthEnable = true;
DSState.DepthWriteMask = D3D10_DEPTH_WRITE_MASK_ALL;
DSState.DepthFunc = D3D10_COMPARISON_LESS_EQUAL;
V(pDev10->CreateDepthStencilState(&DSState, &g_pDSState));
//light management
for( int light_idx = 0; light_idx < NUM_LIGHT; ++light_idx )
{
g_pLightLumiBuffer[light_idx] = new RenderObject( "RenderScreenPixelPos" );
g_pLightLumiBuffer[light_idx] ->OnD3D10CreateDevice( NULL,pDev10, pBackBufferSurfaceDesc, pUserContext);
}
g_pBlendBuffer = new RenderObject( "RenderScreenPixelPos" );
g_pBlendBuffer->OnD3D10CreateDevice( NULL,pDev10, pBackBufferSurfaceDesc, pUserContext);
g_pWidgetBuffer = new RenderObject( "RenderScreenPixelPos" );//fake tech name,we dont want to use it. We only want to utilize its buffers
g_pWidgetBuffer->OnD3D10CreateDevice( NULL,pDev10, pBackBufferSurfaceDesc, pUserContext);
//--------------------------------------------------------------------------------------------------------
return S_OK;
}
//--------------------------------------------------------------------------------------
// 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;
}
