HRESULT TestApplication1::OnCreateDevice(ID3D10Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext)
{
HRESULT hr;
D3DXVECTOR3 vCenter(0.25767413f, -28.503521f, 111.00689f);
FLOAT fObjectRadius = 378.15607f;
D3DXMatrixTranslation(&_mCenterMesh, -vCenter.x, -vCenter.y, -vCenter.z);
D3DXMATRIXA16 m;
D3DXMatrixRotationY(&m, D3DX_PI);
_mCenterMesh *= m;
D3DXMatrixRotationX(&m, D3DX_PI / 2.0f);
_mCenterMesh *= m;
// Create our vertex input layout
_shaderutil.SetShaderName(L"Shader\\SpecularMapping_2.fx", "SpecularMapping");
_shaderutil.ShaderSetting(*pd3dDevice);
// Load the mesh
V_RETURN(_Mesh.Create(pd3dDevice, L"Model\\Sphere.sdkmesh", true));
// Setup the camera's view parameters
D3DXVECTOR3 vecEye(0.0f, 0.0f, -15.0f);
D3DXVECTOR3 vecAt(0.0f, 0.0f, -0.0f);
_camera.SetViewParams(&vecEye, &vecAt);
_camera.SetRadius(fObjectRadius * 3.0f, fObjectRadius * 0.5f, fObjectRadius * 10.0f);
return S_OK;
}
void Activate(IDirect3DDevice9 *pDevice){
SetUp3DCamera(pDevice);
D3DXMATRIX ViewMatrix, RotMatrix;
D3DXMatrixRotationY(&RotMatrix, timeGetTime()/1300.0f);
D3DXVECTOR3 vecEye(0.0f, 10.0f, -10.0f);
D3DXVec3TransformCoord(&vecEye, &vecEye, &RotMatrix);
D3DXMatrixLookAtLH(&ViewMatrix, &vecEye, &D3DXVECTOR3(0.0f, 0.0f, 0.0f), &D3DXVECTOR3(0.0f,1.0f,0.0f));
pDevice->SetTransform(D3DTS_VIEW, &ViewMatrix);
pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
pDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);
pDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
pDevice->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
}
//--------------------------------------------------------------------------------------
// 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_SettingsDlg.OnD3D9CreateDevice( pd3dDevice ) );
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 ) );
// Read the D3DX effect file
WCHAR str[MAX_PATH];
DWORD dwShaderFlags = D3DXFX_NOT_CLONEABLE | 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"DDSWithoutD3DX.fx" ) );
V_RETURN( D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, dwShaderFlags,
NULL, &g_pEffect9, NULL ) );
g_hRenderScene = g_pEffect9->GetTechniqueByName( "RenderScene" );
g_hmWorld = g_pEffect9->GetParameterByName( NULL, "g_mWorld" );
g_hmWorldViewProjection = g_pEffect9->GetParameterByName( NULL, "g_mWorldViewProjection" );
g_htxDiffuse = g_pEffect9->GetParameterByName( NULL, "g_txDiffuse" );
// Create a decl for the object data.
D3DVERTEXELEMENT9 declDesc[] =
{
{0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
{0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0},
{0, 24, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
{0xFF,0,D3DDECLTYPE_UNUSED, 0,0,0}// D3DDECL_END
};
V_RETURN( pd3dDevice->CreateVertexDeclaration( declDesc, &g_pDecl9 ) );
// Setup the camera's view parameters
D3DXVECTOR3 vecEye( 0.0f, 0.0f, -5.0f );
D3DXVECTOR3 vecAt ( 0.0f, 0.0f, 0.0f );
g_Camera.SetViewParams( &vecEye, &vecAt );
return S_OK;
}
//--------------------------------------------------------------------------------------
// Create any D3D9 resources that will live through a device reset (D3DPOOL_MANAGED)
// and aren't tied to the back buffer size
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
CDXUTIMEEditBox::Initialize( DXUTGetHWND() );
V_RETURN( g_DialogResourceManager.OnD3D9CreateDevice( pd3dDevice ) );
V_RETURN( g_SettingsDlg.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_pFont ) );
DWORD dwShaderFlags = D3DXFX_NOT_CLONEABLE;
#if defined( DEBUG ) || defined( _DEBUG )
dwShaderFlags |= D3DXSHADER_DEBUG;
#endif
#ifdef DEBUG_VS
dwShaderFlags |= D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT;
#endif
#ifdef DEBUG_PS
dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
#endif
// Read the D3DX effect file
WCHAR str[MAX_PATH];
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"CustomUI.fx" ) );
V_RETURN( D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, dwShaderFlags,
NULL, &g_pEffect, NULL ) );
g_Mesh.Create( pd3dDevice, L"misc\\cell.x" );
// Setup the camera's view parameters
D3DXVECTOR3 vecEye( 0.0f, 1.5f, -7.0f );
D3DXVECTOR3 vecAt ( 0.0f, 0.2f, 0.0f );
D3DXVECTOR3 vecUp ( 0.0f, 1.0f, 0.0f );
g_Camera.SetViewParams( &vecEye, &vecAt );
D3DXMatrixLookAtLH( &g_mView, &vecEye, &vecAt, &vecUp );
return S_OK;
}
void App::LoadSNBTerrain()
{
terrainload_ = true;
g_ConfigFiles.push_back( L"Default_Config.txt");
g_TerrainDX11Render.SetQuadTreePreviewPos(10, 290, 200, 200);
LoadScene();
// Setup the camera's view parameters
D3DXVECTOR3 vecEye( 2643.75f, 2178.89f, 2627.14f );
D3DXVECTOR3 vecAt ( 2644.52f, 2178.71f, 2627.74f );
//D3DXVECTOR3 vecEye( 150.75f, 100.89f, 150.14f );
//D3DXVECTOR3 vecAt ( 151.52f, 100.71f, 150.74f );
//g_Camera.SetViewParams( &vecEye, &vecAt );
//g_Camera.SetRotateButtons(true, false, false);
ActiveCam_->setFrom((float*)vecEye);
ActiveCam_->setTo((float*)vecAt);
ActiveCam_->setFOV(RAD2DEG(noMath::PI / 4));
ActiveCam_->setNear(CLIP_NEAR);
ActiveCam_->setFar(CLIP_FAR);
ActiveCam_->SetAspect(GetAspectRatio());
ActiveCam_->computeModelView();
ActiveCam_->ComputeProjection();
static bool bFirstTime = true;
if( bFirstTime )
{
InitTerrainRender();
bFirstTime = false;
}
g_TerrainDX11Render.OnD3D11CreateDevice( device, context );
//ResizeSNBTerrain();
D3DXCOLOR SunColor(1,1,1,1), AmbientLight(0,0,0,0);
g_TerrainDX11Render.SetSunParams(g_vDirectionOnSun, SunColor, AmbientLight);
g_TerrainDX11Render.EnableAdaptiveTriangulation(true);
}
//--------------------------------------------------------------------------------------
// 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_SettingsDlg.OnD3D9CreateDevice( pd3dDevice ) );
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 ) );
// Read the D3DX effect file
WCHAR str[MAX_PATH];
DWORD dwShaderFlags = D3DXFX_NOT_CLONEABLE;
#ifdef DEBUG_VS
dwShaderFlags |= D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT;
#endif
#ifdef DEBUG_PS
dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
#endif
#ifdef D3DXFX_LARGEADDRESS_HANDLE
dwShaderFlags |= D3DXFX_LARGEADDRESSAWARE;
#endif
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"SimpleSample.fx" ) );
V_RETURN( D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, dwShaderFlags,
NULL, &g_pEffect9, NULL ) );
g_hmWorldViewProjection = g_pEffect9->GetParameterByName( NULL, "g_mWorldViewProjection" );
g_hmWorld = g_pEffect9->GetParameterByName( NULL, "g_mWorld" );
g_hfTime = g_pEffect9->GetParameterByName( NULL, "g_fTime" );
// Setup the camera's view parameters
D3DXVECTOR3 vecEye( 0.0f, 0.0f, -5.0f );
D3DXVECTOR3 vecAt ( 0.0f, 0.0f, -0.0f );
g_Camera.SetViewParams( &vecEye, &vecAt );
return S_OK;
}
void CTextureContentView::SetDocument(CContentStudioDoc* pDoc)
{
m_pDoc = pDoc;
m_renderer.Clear();
// Handle first init?
// FirstPersonCamera
D3DXVECTOR3 vMin = D3DXVECTOR3( -1000.0f, -1000.0f, -1000.0f );
D3DXVECTOR3 vMax = D3DXVECTOR3( 1000.0f, 1000.0f, 1000.0f );
D3DXVECTOR3 vecEye( 2.0f, 0.0f, 0.0f );
D3DXVECTOR3 vecAt( 0.0f,0.0f,0.0f );
m_FirstPersonCamera.SetViewParams( &vecEye, &vecAt );
m_FirstPersonCamera.SetRotateButtons(TRUE, FALSE, FALSE);
m_FirstPersonCamera.SetScalers( 0.01f, 1 );
m_FirstPersonCamera.SetDrag( true );
m_FirstPersonCamera.SetEnableYAxisMovement( true );
m_FirstPersonCamera.SetClipToBoundary( TRUE, &vMin, &vMax );
m_FirstPersonCamera.FrameMove( 0 );
}
//--------------------------------------------------------------------------------------
// When the user changes scene, recreate these components as they are scene
// dependent.
//--------------------------------------------------------------------------------------
HRESULT CreateD3DComponents(ID3D11Device* pd3dDevice)
{
HRESULT hr;
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
V_RETURN(g_DialogResourceManager.OnD3D11CreateDevice(pd3dDevice, pd3dImmediateContext));
V_RETURN(g_D3DSettingsDlg.OnD3D11CreateDevice(pd3dDevice));
g_pTxtHelper = new CDXUTTextHelper(pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 15);
XMFLOAT3 vecEye(100.0f, 5.0f, 5.0f);
XMFLOAT3 vecAt(0.0f, 0.0f, 0.0f);
XMFLOAT3 vMin = XMFLOAT3(-1000.0f, -1000.0f, -1000.0f);
XMFLOAT3 vMax = XMFLOAT3(1000.0f, 1000.0f, 1000.0f);
g_ViewerCamera.SetViewParams(XMLoadFloat3(&vecEye), XMLoadFloat3(&vecAt));
g_ViewerCamera.SetRotateButtons(TRUE, FALSE, FALSE);
g_ViewerCamera.SetScalers(0.01f, 10.0f);
g_ViewerCamera.SetDrag(true);
g_ViewerCamera.SetEnableYAxisMovement(true);
g_ViewerCamera.SetClipToBoundary(TRUE, &vMin, &vMax);
g_ViewerCamera.FrameMove(0);
vecEye = XMFLOAT3(-320.0f, 300.0f, -220.3f);
vecAt = XMFLOAT3(0.0f, 0.0f, 0.0f);
XMFLOAT3 eyenorm = Normalize(vecEye);
g_LightCamera.SetViewParams(XMLoadFloat3(&vecEye), XMLoadFloat3(&vecAt));
g_LightCamera.SetRotateButtons(TRUE, FALSE, FALSE);
g_LightCamera.SetScalers(0.01f, 50.0f);
g_LightCamera.SetDrag(true);
g_LightCamera.SetEnableYAxisMovement(true);
g_LightCamera.SetClipToBoundary(TRUE, &vMin, &vMax);
g_LightCamera.SetProjParams(XM_PI / 4, 1.0f, 0.1f, 1000.0f);
g_LightCamera.FrameMove(0);
g_VarianceShadow.Init(pd3dDevice, pd3dImmediateContext,
g_pSelectedMesh, &g_ViewerCamera, &g_LightCamera, &g_CascadeConfig);
return S_OK;
}
//--------------------------------------------------------------------------------------
// 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_SettingsDlg.OnD3D9CreateDevice( pd3dDevice ) );
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 ) );
// Setup the camera's view parameters
D3DXVECTOR3 vecEye( 0.0f, 0.0f, 5.0f );
D3DXVECTOR3 vecAt ( 0.0f, 0.0f, 0.0f );
g_Camera.SetViewParams( &vecEye, &vecAt );
SCEMAN->SetActiveDevice( pd3dDevice );
SCEMAN->SwitchToScene( new CTestScene() );
return S_OK;
}
//--------------------------------------------------------------------------------------
// Create any D3D11 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D11CreateDevice(ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext)
{
HRESULT hr;
DXUTTRACE(L"OnD3D11CreateDevice called\n");
SetCursor(LoadCursor(0, IDC_ARROW));
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext(); // does not addref
V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice(pd3dDevice, pd3dImmediateContext) );
V_RETURN( g_SettingsDlg.OnD3D11CreateDevice(pd3dDevice) );
g_pTxtHelper = new CDXUTTextHelper(pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, g_TextLineHeight);
// Setup orbital camera
D3DXVECTOR3 vecEye(0.0f, 2.0f, 0.0f);
D3DXVECTOR3 vecAt (0.0f, 0.0f, 0.0f);
g_OrbitalCamera.SetViewParams(&vecEye, &vecAt);
g_OrbitalCamera.SetRadius(1.5f, 0.01f);
// Setup first-person camera
D3DXVECTOR3 sibenikVecEye(0.0960150138f, 0.0273544509f, -0.0185411610f);
D3DXVECTOR3 sibenikVecAt (-0.623801112f, -0.649074197f, -0.174454257f);
g_FirstPersonCamera.SetViewParams(&sibenikVecEye, &sibenikVecAt);
g_FirstPersonCamera.SetEnablePositionMovement(1);
g_FirstPersonCamera.SetScalers(0.001f, 0.05f);
// Load Scene3D.fx
g_pSceneRenderer.OnCreateDevice(pd3dDevice);
// Load meshes and bin files
LoadScenes(pd3dDevice);
GFSDK_SSAO_Status status;
status = g_AORenderer.Create(pd3dDevice);
assert(status == GFSDK_SSAO_OK);
return S_OK;
}
HRESULT CALLBACK OnCreateDevice(IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext)
{
HRESULT hr;
V_RETURN(g_DialogResourceManager.OnD3D9CreateDevice(pd3dDevice));
V_RETURN(D3DXCreateFont(pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE,
L"Arial", &g_pFont));
DWORD dwShaderFlags = 0;
#ifdef DEBUG_VS
dwShaderFlags |= D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT;
#endif
#ifdef DEBUG_PS
dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
#endif
// Create the game board's Direct3D resources
V_RETURN(g_Board.OnCreateDevice(pd3dDevice, dwShaderFlags));
std::wstring wsCurrentResourcePath;
std::wstring wsAbsoluteContentDirectoryPath = NsD3DResourceManager::Instance()->GetAbsoluteContentFolderPath();
wsCurrentResourcePath = wsAbsoluteContentDirectoryPath + L"/Shaders/Renju/textured_quad.fx";
V_RETURN(g_BackgroundQuad.Create(pd3dDevice, wsCurrentResourcePath.c_str(), dwShaderFlags));
wsCurrentResourcePath = wsAbsoluteContentDirectoryPath + L"/Textures/Renju/background.tga";
V_RETURN(g_BackgroundQuad.LoadTexture("QuadTexture", wsCurrentResourcePath.c_str()));
// Setup the camera's view parameters
D3DXVECTOR3 vecEye(0.0f, 0.0f, -5.0f);
D3DXVECTOR3 vecAt (0.0f, 0.0f, -0.0f);
g_Camera.SetViewParams(&vecEye, &vecAt);
return S_OK;
}
//--------------------------------------------------------------------------------------
// This callback function will be called immediately after the Direct3D device has been
// created, which will happen during application initialization and windowed/full screen
// toggles. This is the best location to create D3DPOOL_MANAGED resources since these
// resources need to be reloaded whenever the device is destroyed. Resources created
// here should be released in the OnDestroyDevice callback.
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
WCHAR str[MAX_PATH];
V_RETURN( g_DialogResourceManager.OnD3D9CreateDevice( pd3dDevice ) );
V_RETURN( g_SettingsDlg.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_pFont ) );
// Create the mesh and load it with data already gathered from a file
V_RETURN( g_MeshLoader.Create( pd3dDevice, L"media\\cup.obj" ) );
// Add the identified material subsets to the UI
CDXUTComboBox* pComboBox = g_SampleUI.GetComboBox( IDC_SUBSET );
pComboBox->RemoveAllItems();
pComboBox->AddItem( L"All", ( void* )( INT_PTR )-1 );
for( UINT i = 0; i < g_MeshLoader.GetNumMaterials(); i++ )
{
Material* pMaterial = g_MeshLoader.GetMaterial( i );
pComboBox->AddItem( pMaterial->strName, ( void* )( INT_PTR )i );
}
// Define DEBUG_VS and/or DEBUG_PS to debug vertex and/or pixel shaders with the
// shader debugger. Debugging vertex shaders requires either REF or software vertex
// processing, and debugging pixel shaders requires REF. The
// D3DXSHADER_FORCE_*_SOFTWARE_NOOPT flag improves the debug experience in the
// shader debugger. It enables source level debugging, prevents instruction
// reordering, prevents dead code elimination, and forces the compiler to compile
// against the next higher available software target, which ensures that the
// unoptimized shaders do not exceed the shader model limitations. Setting these
// flags will cause slower rendering since the shaders will be unoptimized and
// forced into software. See the DirectX documentation for more information about
// using the shader debugger.
DWORD dwShaderFlags = D3DXFX_NOT_CLONEABLE;
#if defined( DEBUG ) || defined( _DEBUG )
// Set the D3DXSHADER_DEBUG flag to embed debug information in the shaders.
// Setting this flag improves the shader debugging experience, but still allows
// the shaders to be optimized and to run exactly the way they will run in
// the release configuration of this program.
dwShaderFlags |= D3DXSHADER_DEBUG;
#endif
#ifdef DEBUG_VS
dwShaderFlags |= D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT;
#endif
#ifdef DEBUG_PS
dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
#endif
// Read the D3DX effect file
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"MeshFromOBJ.fx" ) );
// If this fails, there should be debug output as to
// they the .fx file failed to compile
V_RETURN( D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, dwShaderFlags,
NULL, &g_pEffect, NULL ) );
// Cache the effect handles
g_hAmbient = g_pEffect->GetParameterBySemantic( 0, "Ambient" );
g_hDiffuse = g_pEffect->GetParameterBySemantic( 0, "Diffuse" );
g_hSpecular = g_pEffect->GetParameterBySemantic( 0, "Specular" );
g_hOpacity = g_pEffect->GetParameterBySemantic( 0, "Opacity" );
g_hSpecularPower = g_pEffect->GetParameterBySemantic( 0, "SpecularPower" );
g_hLightColor = g_pEffect->GetParameterBySemantic( 0, "LightColor" );
g_hLightPosition = g_pEffect->GetParameterBySemantic( 0, "LightPosition" );
g_hCameraPosition = g_pEffect->GetParameterBySemantic( 0, "CameraPosition" );
g_hTexture = g_pEffect->GetParameterBySemantic( 0, "Texture" );
g_hTime = g_pEffect->GetParameterBySemantic( 0, "Time" );
g_hWorld = g_pEffect->GetParameterBySemantic( 0, "World" );
g_hWorldViewProjection = g_pEffect->GetParameterBySemantic( 0, "WorldViewProjection" );
// Setup the camera's view parameters
D3DXVECTOR3 vecEye( 2.0f, 1.0f, 0.0f );
D3DXVECTOR3 vecAt ( 0.0f, 0.0f, -0.0f );
g_Camera.SetViewParams( &vecEye, &vecAt );
return S_OK;
}
//--------------------------------------------------------------------------------------
// Create any D3D10 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D10CreateDevice( ID3D10Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
V_RETURN( g_DialogResourceManager.OnD3D10CreateDevice( pd3dDevice ) );
V_RETURN( g_D3DSettingsDlg.OnD3D10CreateDevice( pd3dDevice ) );
V_RETURN( D3DX10CreateFont( pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE,
L"Arial", &g_pFont10 ) );
V_RETURN( D3DX10CreateSprite( pd3dDevice, MAX_SPRITES, &g_pSprite10 ) );
V_RETURN( CDXUTDirectionWidget::StaticOnD3D10CreateDevice( pd3dDevice ) );
// Read the D3DX effect file
WCHAR str[MAX_PATH];
DWORD dwShaderFlags = D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY;
#if defined( DEBUG ) || defined( _DEBUG )
// Set the D3D10_SHADER_DEBUG flag to embed debug information in the shaders.
// Setting this flag improves the shader debugging experience, but still allows
// the shaders to be optimized and to run exactly the way they will run in
// the release configuration of this program.
dwShaderFlags |= D3D10_SHADER_DEBUG;
#endif
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"Exercise03.fx" ) );
V_RETURN( D3DX10CreateEffectFromFile( str, NULL, NULL, "fx_4_0", dwShaderFlags, 0, pd3dDevice, NULL,
NULL, &g_pEffect10, NULL, NULL ) );
// Obtain the technique handles
g_pRenderTextured = g_pEffect10->GetTechniqueByName( "RenderTextured" );
g_pRenderPiece = g_pEffect10->GetTechniqueByName( "RenderPiece" );
// Obtain the parameter handles
g_pmWorldViewProj = g_pEffect10->GetVariableByName( "g_mWorldViewProj" )->AsMatrix();
g_pmWorldView = g_pEffect10->GetVariableByName( "g_mWorldView" )->AsMatrix();
g_pmWorld = g_pEffect10->GetVariableByName( "g_mWorld" )->AsMatrix();
g_pmProj = g_pEffect10->GetVariableByName( "g_mProj" )->AsMatrix();
g_pViewSpaceLightDir = g_pEffect10->GetVariableByName( "g_ViewSpaceLightDir" )->AsVector();
g_pDiffuseTex = g_pEffect10->GetVariableByName( "g_txDiffuse" )->AsShaderResource();
// Define our vertex data layout
const D3D10_INPUT_ELEMENT_DESC layout[] =
{
{ "POS", 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 },
};
UINT numElements = sizeof( layout ) / sizeof( layout[0] );
D3D10_PASS_DESC PassDesc;
g_pRenderPiece->GetPassByIndex( 0 )->GetDesc( &PassDesc );
V_RETURN( pd3dDevice->CreateInputLayout( layout, numElements, PassDesc.pIAInputSignature,
PassDesc.IAInputSignatureSize, &g_pVertexLayout ) );
// Load our IB and VB with mesh data
V_RETURN( LoadMesh( pd3dDevice ) );
// Setup the camera's view parameters
D3DXVECTOR3 vecEye( 0.0f, 0.0f, -8.0f );
D3DXVECTOR3 vecAt( 0.0f,0.0f,0.0f );
g_Camera.SetViewParams( &vecEye, &vecAt );
return S_OK;
}
//--------------------------------------------------------------------------------------
// 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 )
{
MessageBox(0, L"We aren't using DirectX9", L"We aren't using DirectX9", 0);
exit(1);
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 ) );
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 ) );
g_LightControl.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;
}
//--------------------------------------------------------------------------------------
// Create any D3D9 resources that will live through a device reset (D3DPOOL_MANAGED)
// and aren't tied to the back buffer size
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
V_RETURN( g_DialogResourceManager.OnD3D9CreateDevice( pd3dDevice ) );
V_RETURN( g_SettingsDlg.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_pFont ) );
// Load the mesh
V_RETURN( g_Mesh.Create( pd3dDevice, L"dwarf\\dwarf.x" ) );
// Find the mesh's center, then generate a centering matrix.
IDirect3DVertexBuffer9* pVB = NULL;
V_RETURN( g_Mesh.m_pMesh->GetVertexBuffer( &pVB ) );
void* pVertices = NULL;
hr = pVB->Lock( 0, 0, &pVertices, 0 );
if( FAILED( hr ) )
{
SAFE_RELEASE( pVB );
return hr;
}
hr = D3DXComputeBoundingSphere( ( D3DXVECTOR3* )pVertices, g_Mesh.m_pMesh->GetNumVertices(),
D3DXGetFVFVertexSize( g_Mesh.m_pMesh->GetFVF() ), &g_vObjectCenter,
&g_fObjectRadius );
pVB->Unlock();
SAFE_RELEASE( pVB );
if( FAILED( hr ) )
return hr;
D3DXMatrixTranslation( &g_mCenterWorld, -g_vObjectCenter.x, -g_vObjectCenter.y, -g_vObjectCenter.z );
// Read the D3DX effect file
TCHAR str[MAX_PATH];
hr = DXUTFindDXSDKMediaFileCch( str, MAX_PATH, TEXT( "CompiledEffect.fxo" ) );
if( FAILED( hr ) )
{
MessageBox( DXUTGetHWND(), TEXT( "Could not locate \"CompiledEffect.fxo\".\n\n" )
TEXT( "This file is created as part of the project build process,\n" )
TEXT( "so the associated project must be compiled inside Visual\n" )
TEXT( "Studio before attempting to run this sample.\n\n" )
TEXT( "If receiving this error even after compiling the project,\n" )
TEXT( "it's likely there was a problem compiling the effect file.\n" )
TEXT( "Check the build log to verify the custom build step was\n" )
TEXT( "run and to look for possible fxc compile errors." ),
TEXT( "File Not Found" ), MB_OK );
return E_FAIL;
}
// Since we are loading a binary file here and this effect has already been compiled,
// you can not pass compiler flags here (for example to debug the shaders).
// To debug the shaders, you must pass these flags to the compiler that generated the
// binary (for example fxc.exe). In this sample, there are 2 extra Visual Studio configurations
// called "Debug Shaders" and "Unicode Debug Shaders" that pass the debug shader flags to fxc.exe.
V_RETURN( D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, D3DXFX_NOT_CLONEABLE, NULL, &g_pEffect, NULL ) );
// Setup the camera's view parameters
D3DXVECTOR3 vecEye( 0.0f, 0.0f, -5.0f );
D3DXVECTOR3 vecAt ( 0.0f, 0.0f, -0.0f );
g_Camera.SetViewParams( &vecEye, &vecAt );
return S_OK;
}
//--------------------------------------------------------------------------------------
// Create any D3D10 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D10CreateDevice( ID3D10Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
V_RETURN( g_DialogResourceManager.OnD3D10CreateDevice( pd3dDevice ) );
V_RETURN( g_D3DSettingsDlg.OnD3D10CreateDevice( pd3dDevice ) );
V_RETURN( D3DX10CreateFont( pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE,
L"Arial", &g_pFont10 ) );
V_RETURN( D3DX10CreateSprite( pd3dDevice, MAX_SPRITES, &g_pSprite10 ) );
V_RETURN( CDXUTDirectionWidget::StaticOnD3D10CreateDevice( pd3dDevice ) );
// Read the D3DX effect file
WCHAR str[MAX_PATH];
DWORD dwShaderFlags = D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY;
#if defined( DEBUG ) || defined( _DEBUG )
// Set the D3D10_SHADER_DEBUG flag to embed debug information in the shaders.
// Setting this flag improves the shader debugging experience, but still allows
// the shaders to be optimized and to run exactly the way they will run in
// the release configuration of this program.
dwShaderFlags |= D3D10_SHADER_DEBUG;
#endif
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"Exercise06.fx" ) );
V_RETURN( D3DX10CreateEffectFromFile( str, NULL, NULL, "fx_4_0", dwShaderFlags, 0, pd3dDevice, NULL,
NULL, &g_pEffect10, NULL, NULL ) );
// Obtain the technique handles
g_pRenderTextured = g_pEffect10->GetTechniqueByName( "RenderTextured" );
g_pGrowBranches = g_pEffect10->GetTechniqueByName( "GrowBranches" );
// Obtain the parameter handles
g_pmWorldViewProj = g_pEffect10->GetVariableByName( "g_mWorldViewProj" )->AsMatrix();
g_pmWorld = g_pEffect10->GetVariableByName( "g_mWorld" )->AsMatrix();
g_pmWorldView = g_pEffect10->GetVariableByName( "g_mWorldView" )->AsMatrix();
g_pViewSpaceLightDir = g_pEffect10->GetVariableByName( "g_ViewSpaceLightDir" )->AsVector();
g_pLengthModifier = g_pEffect10->GetVariableByName( "LengthModifier" )->AsScalar();
g_pSpreadModifier = g_pEffect10->GetVariableByName( "SpreadModifier" )->AsScalar();
g_pShrinkModifier = g_pEffect10->GetVariableByName( "ShrinkModifier" )->AsScalar();
g_pExtinctionRate = g_pEffect10->GetVariableByName( "ExtinctionRate" )->AsScalar();
g_pDiffuseTex = g_pEffect10->GetVariableByName( "g_txDiffuse" )->AsShaderResource();
g_pRandomBuf = g_pEffect10->GetVariableByName( "g_RandomBuffer" )->AsShaderResource();
// Define our vertex data layout
const D3D10_INPUT_ELEMENT_DESC layout[] =
{
{ "POS", 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 },
{ "GROWAMT", 0, DXGI_FORMAT_R32_FLOAT, 0, 32, D3D10_INPUT_PER_VERTEX_DATA, 0 },
};
D3D10_PASS_DESC PassDesc;
UINT numElements = sizeof( layout ) / sizeof( D3D10_INPUT_ELEMENT_DESC );
g_pRenderTextured->GetPassByIndex( 0 )->GetDesc( &PassDesc );
V_RETURN( pd3dDevice->CreateInputLayout( layout, numElements, PassDesc.pIAInputSignature,
PassDesc.IAInputSignatureSize, &g_pVertexLayout ) );
// Load our IB and VB with mesh data
V_RETURN( LoadMesh( pd3dDevice ) );
// Create our StreamTo and DrawFrom buffers
const UINT MaxVertices = 300000;
D3D10_BUFFER_DESC bd;
bd.Usage = D3D10_USAGE_DEFAULT;
bd.ByteWidth = MaxVertices * g_VertStride;
bd.BindFlags = D3D10_BIND_VERTEX_BUFFER | D3D10_BIND_STREAM_OUTPUT;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
V_RETURN( pd3dDevice->CreateBuffer( &bd, NULL, &g_pStreamTo ) );
V_RETURN( pd3dDevice->CreateBuffer( &bd, NULL, &g_pDrawFrom ) );
// 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_pLengthModifier->SetFloat( g_LengthModifier );
g_pSpreadModifier->SetFloat( g_SpreadModifier );
g_pShrinkModifier->SetFloat( g_ShrinkModifier );
g_pExtinctionRate->SetFloat( g_ExtinctionRate );
//-----------------------------------------------------------------------------------------
// o/__ <-- Create a buffer full of random vectors. These will be indexed by our
// | (\ tree generation algorithm to give the tree a more natural look.
//-----------------------------------------------------------------------------------------
int iNumRandValues = 1024;
srand( 200 );
//create the data
D3D10_SUBRESOURCE_DATA InitData;
InitData.pSysMem = new float[iNumRandValues * 4];
if( !InitData.pSysMem )
return E_OUTOFMEMORY;
for( int i = 0; i < iNumRandValues * 3; i++ )
{
( ( float* )InitData.pSysMem )[i] = float( ( rand() % 10000 ) - 5000 ) / 5000.0f;
}
D3D10_BUFFER_DESC bufferDesc;
bufferDesc.BindFlags = D3D10_BIND_SHADER_RESOURCE;
bufferDesc.ByteWidth = 1024 * 4 * sizeof( float );
bufferDesc.CPUAccessFlags = 0;
bufferDesc.MiscFlags = 0;
bufferDesc.Usage = D3D10_USAGE_DEFAULT;
V_RETURN( pd3dDevice->CreateBuffer( &bufferDesc, &InitData, &g_pRandomBuffer ) );
D3D10_SHADER_RESOURCE_VIEW_DESC SRVDesc;
ZeroMemory( &SRVDesc, sizeof( SRVDesc ) );
SRVDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
SRVDesc.ViewDimension = D3D10_SRV_DIMENSION_BUFFER;
SRVDesc.Buffer.ElementOffset = 0;
SRVDesc.Buffer.ElementWidth = 1024;
V_RETURN( pd3dDevice->CreateShaderResourceView( g_pRandomBuffer, &SRVDesc, &g_pRandomBufferRV ) );
SAFE_DELETE_ARRAY( InitData.pSysMem );
return S_OK;
}
//--------------------------------------------------------------------------------------
// This callback function will be called immediately after the Direct3D device has been
// created, which will happen during application initialization and windowed/full screen
// toggles. This is the best location to create D3DPOOL_MANAGED resources since these
// resources need to be reloaded whenever the device is destroyed. Resources created
// here should be released in the OnDestroyDevice callback.
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
V_RETURN( g_DialogResourceManager.OnD3D9CreateDevice( pd3dDevice ) );
V_RETURN( g_SettingsDlg.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_pFont ) );
// Load the mesh
V_RETURN( LoadMesh( pd3dDevice, L"tiny\\tiny.x", &g_pMesh ) );
D3DXVECTOR3* pData;
D3DXVECTOR3 vCenter;
FLOAT fObjectRadius;
V( g_pMesh->LockVertexBuffer( 0, ( LPVOID* )&pData ) );
V( D3DXComputeBoundingSphere( pData, g_pMesh->GetNumVertices(),
D3DXGetFVFVertexSize( g_pMesh->GetFVF() ), &vCenter, &fObjectRadius ) );
V( g_pMesh->UnlockVertexBuffer() );
D3DXMatrixTranslation( &g_mCenterWorld, -vCenter.x, -vCenter.y, -vCenter.z );
D3DXMATRIXA16 m;
D3DXMatrixRotationY( &m, D3DX_PI );
g_mCenterWorld *= m;
D3DXMatrixRotationX( &m, D3DX_PI / 2.0f );
g_mCenterWorld *= m;
V_RETURN( CDXUTDirectionWidget::StaticOnD3D9CreateDevice( pd3dDevice ) );
for( int i = 0; i < MAX_LIGHTS; i++ )
g_LightControl[i].SetRadius( fObjectRadius );
// Define DEBUG_VS and/or DEBUG_PS to debug vertex and/or pixel shaders with the
// shader debugger. Debugging vertex shaders requires either REF or software vertex
// processing, and debugging pixel shaders requires REF. The
// D3DXSHADER_FORCE_*_SOFTWARE_NOOPT flag improves the debug experience in the
// shader debugger. It enables source level debugging, prevents instruction
// reordering, prevents dead code elimination, and forces the compiler to compile
// against the next higher available software target, which ensures that the
// unoptimized shaders do not exceed the shader model limitations. Setting these
// flags will cause slower rendering since the shaders will be unoptimized and
// forced into software. See the DirectX documentation for more information about
// using the shader debugger.
DWORD dwShaderFlags = D3DXFX_NOT_CLONEABLE;
#if defined( DEBUG ) || defined( _DEBUG )
// Set the D3DXSHADER_DEBUG flag to embed debug information in the shaders.
// Setting this flag improves the shader debugging experience, but still allows
// the shaders to be optimized and to run exactly the way they will run in
// the release configuration of this program.
dwShaderFlags |= D3DXSHADER_DEBUG;
#endif
#ifdef DEBUG_VS
dwShaderFlags |= D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT;
#endif
#ifdef DEBUG_PS
dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
#endif
// Preshaders are parts of the shader that the effect system pulls out of the
// shader and runs on the host CPU. They should be used if you are GPU limited.
// The D3DXSHADER_NO_PRESHADER flag disables preshaders.
if( !g_bEnablePreshader )
dwShaderFlags |= D3DXSHADER_NO_PRESHADER;
// Read the D3DX effect file
WCHAR str[MAX_PATH];
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"BasicHLSL.fx" ) );
// If this fails, there should be debug output as to
// why the .fx file failed to compile
V_RETURN( D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, dwShaderFlags, NULL, &g_pEffect, 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_pMeshTexture ) );
// Set effect variables as needed
D3DXCOLOR colorMtrlDiffuse( 1.0f, 1.0f, 1.0f, 1.0f );
D3DXCOLOR colorMtrlAmbient( 0.35f, 0.35f, 0.35f, 0 );
V_RETURN( g_pEffect->SetValue( "g_MaterialAmbientColor", &colorMtrlAmbient, sizeof( D3DXCOLOR ) ) );
V_RETURN( g_pEffect->SetValue( "g_MaterialDiffuseColor", &colorMtrlDiffuse, sizeof( D3DXCOLOR ) ) );
V_RETURN( g_pEffect->SetTexture( "g_MeshTexture", g_pMeshTexture ) );
// 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;
}
//--------------------------------------------------------------------------------------
// Create any D3D10 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D10CreateDevice( ID3D10Device* pd3dDevice, const DXGI_SURFACE_DESC* pBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
V_RETURN( g_DialogResourceManager.OnD3D10CreateDevice( pd3dDevice ) );
V_RETURN( g_SettingsDlg.OnD3D10CreateDevice( pd3dDevice ) );
V_RETURN( D3DX10CreateFont( pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE,
L"Arial", &g_pFont10 ) );
V_RETURN( D3DX10CreateSprite( pd3dDevice, 512, &g_pSprite10 ) );
g_pTxtHelper = new CDXUTTextHelper( NULL, NULL, g_pFont10, g_pSprite10, 15 );
// Read the D3DX effect file
WCHAR str[MAX_PATH];
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"MeshFromOBJ10.fx" ) );
DWORD dwShaderFlags = D3D10_SHADER_ENABLE_STRICTNESS;
#if defined( DEBUG ) || defined( _DEBUG )
// Set the D3D10_SHADER_DEBUG flag to embed debug information in the shaders.
// Setting this flag improves the shader debugging experience, but still allows
// the shaders to be optimized and to run exactly the way they will run in
// the release configuration of this program.
dwShaderFlags |= D3D10_SHADER_DEBUG;
#endif
V_RETURN( D3DX10CreateEffectFromFile( str, NULL, NULL, "fx_4_0", dwShaderFlags, 0, pd3dDevice, NULL,
NULL, &g_pEffect10, NULL, NULL ) );
// Obtain the technique
g_pTechnique = g_pEffect10->GetTechniqueByName( "NoSpecular" );
g_ptxDiffuseVariable = g_pEffect10->GetVariableByName( "g_MeshTexture" )->AsShaderResource();
g_pAmbient = g_pEffect10->GetVariableByName( "g_vMaterialAmbient" )->AsVector();
g_pDiffuse = g_pEffect10->GetVariableByName( "g_vMaterialDiffuse" )->AsVector();
g_pSpecular = g_pEffect10->GetVariableByName( "g_vMaterialSpecular" )->AsVector();
g_pOpacity = g_pEffect10->GetVariableByName( "g_fMaterialAlpha" )->AsScalar();
g_pSpecularPower = g_pEffect10->GetVariableByName( "g_nMaterialShininess" )->AsScalar();
g_pLightColor = g_pEffect10->GetVariableByName( "g_vLightColor" )->AsVector();
g_pLightPosition = g_pEffect10->GetVariableByName( "g_vLightPosition" )->AsVector();
g_pCameraPosition = g_pEffect10->GetVariableByName( "g_vCameraPosition" )->AsVector();
g_pTime = g_pEffect10->GetVariableByName( "g_fTime" )->AsScalar();
g_pWorld = g_pEffect10->GetVariableByName( "g_mWorld" )->AsMatrix();
g_pWorldViewProjection = g_pEffect10->GetVariableByName( "g_mWorldViewProjection" )->AsMatrix();
// Define the input layout
const D3D10_INPUT_ELEMENT_DESC layout[] =
{
{ "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 },
} ;
UINT numElements = sizeof( layout ) / sizeof( layout[0] );
// Create the input layout
D3D10_PASS_DESC PassDesc;
g_pTechnique->GetPassByIndex( 0 )->GetDesc( &PassDesc );
V_RETURN( pd3dDevice->CreateInputLayout( layout, numElements, PassDesc.pIAInputSignature,
PassDesc.IAInputSignatureSize, &g_pVertexLayout ) );
pd3dDevice->IASetInputLayout( g_pVertexLayout );
// Load the mesh
V_RETURN( g_MeshLoader.Create( pd3dDevice, L"media\\cup.obj" ) );
// Add the identified subsets to the UI
CDXUTComboBox* pComboBox = g_SampleUI.GetComboBox( IDC_SUBSET );
pComboBox->RemoveAllItems();
pComboBox->AddItem( L"All", ( void* )( INT_PTR )-1 );
for ( UINT subset = 0; subset < g_MeshLoader.GetNumSubsets(); ++subset )
{
Material* pMaterial = g_MeshLoader.GetSubsetMaterial( subset );
pComboBox->AddItem( pMaterial->strName, ( void* )( INT_PTR )subset );
}
// Store the correct technique for each material
for ( UINT i = 0; i < g_MeshLoader.GetNumMaterials(); ++i )
{
Material* pMaterial = g_MeshLoader.GetMaterial( i );
const char* strTechnique = "";
if( pMaterial->pTextureRV10 && pMaterial->bSpecular )
strTechnique = "TexturedSpecular";
else if( pMaterial->pTextureRV10 && !pMaterial->bSpecular )
strTechnique = "TexturedNoSpecular";
else if( !pMaterial->pTextureRV10 && pMaterial->bSpecular )
strTechnique = "Specular";
else if( !pMaterial->pTextureRV10 && !pMaterial->bSpecular )
strTechnique = "NoSpecular";
pMaterial->pTechnique = g_pEffect10->GetTechniqueByName( strTechnique );
}
// Setup the camera's view parameters
D3DXVECTOR3 vecEye( 2.0f, 1.0f, 0.0f );
D3DXVECTOR3 vecAt ( 0.0f, 0.0f, -0.0f );
g_Camera.SetViewParams( &vecEye, &vecAt );
return S_OK;
}
//--------------------------------------------------------------------------------------
// Create any D3D10 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D10CreateDevice( ID3D10Device* pd3dDevice, const DXGI_SURFACE_DESC* pBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
V_RETURN( g_DialogResourceManager.OnD3D10CreateDevice( pd3dDevice ) );
V_RETURN( g_SettingsDlg.OnD3D10CreateDevice( pd3dDevice ) );
V_RETURN( D3DX10CreateFont( pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE,
L"Arial", &g_pFont10 ) );
V_RETURN( D3DX10CreateSprite( pd3dDevice, 512, &g_pSprite10 ) );
g_pTxtHelper = new CDXUTTextHelper( NULL, NULL, g_pFont10, g_pSprite10, 15 );
// Read the D3DX effect file
WCHAR str[MAX_PATH];
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"MeshFromOBJ10.fx" ) );
DWORD dwShaderFlags = D3D10_SHADER_ENABLE_STRICTNESS;
#if defined( DEBUG ) || defined( _DEBUG )
// Set the D3D10_SHADER_DEBUG flag to embed debug information in the shaders.
// Setting this flag improves the shader debugging experience, but still allows
// the shaders to be optimized and to run exactly the way they will run in
// the release configuration of this program.
dwShaderFlags |= D3D10_SHADER_DEBUG;
#endif
V_RETURN( D3DX10CreateEffectFromFile( str, NULL, NULL, "fx_4_0", dwShaderFlags, 0, pd3dDevice, NULL,
NULL, &g_pEffect10, NULL, NULL ) );
// Obtain the technique
g_pTechnique = g_pEffect10->GetTechniqueByName( "NoSpecular" );
g_ptxDiffuseVariable = g_pEffect10->GetVariableByName( "g_MeshTexture" )->AsShaderResource();
g_pAmbient = g_pEffect10->GetVariableByName( "g_vMaterialAmbient" )->AsVector();
g_pDiffuse = g_pEffect10->GetVariableByName( "g_vMaterialDiffuse" )->AsVector();
g_pSpecular = g_pEffect10->GetVariableByName( "g_vMaterialSpecular" )->AsVector();
g_pOpacity = g_pEffect10->GetVariableByName( "g_fMaterialAlpha" )->AsScalar();
g_pSpecularPower = g_pEffect10->GetVariableByName( "g_nMaterialShininess" )->AsScalar();
g_pLightColor = g_pEffect10->GetVariableByName( "g_vLightColor" )->AsVector();
g_pLightPosition = g_pEffect10->GetVariableByName( "g_vLightPosition" )->AsVector();
g_pCameraPosition = g_pEffect10->GetVariableByName( "g_vCameraPosition" )->AsVector();
g_pTime = g_pEffect10->GetVariableByName( "g_fTime" )->AsScalar();
g_pWorld = g_pEffect10->GetVariableByName( "g_mWorld" )->AsMatrix();
g_pWorldViewProjection = g_pEffect10->GetVariableByName( "g_mWorldViewProjection" )->AsMatrix();
// Define the input layout
const D3D10_INPUT_ELEMENT_DESC layout[] =
{
{ "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 },
} ;
UINT numElements = sizeof( layout ) / sizeof( layout[0] );
// Create the input layout
D3D10_PASS_DESC PassDesc;
g_pTechnique->GetPassByIndex( 0 )->GetDesc( &PassDesc );
V_RETURN( pd3dDevice->CreateInputLayout( layout, numElements, PassDesc.pIAInputSignature,
PassDesc.IAInputSignatureSize, &g_pVertexLayout ) );
pd3dDevice->IASetInputLayout( g_pVertexLayout );
// Load the mesh
V_RETURN( g_MeshLoader.Create( pd3dDevice, MESHFILEPATH ) );
// Add the identified subsets to the UI
CDXUTComboBox* pComboBox = g_SampleUI.GetComboBox( IDC_SUBSET );
pComboBox->RemoveAllItems();
pComboBox->AddItem( L"All", ( void* )( INT_PTR )-1 );
for ( UINT subset = 0; subset < g_MeshLoader.GetNumSubsets(); ++subset )
{
Material* pMaterial = g_MeshLoader.GetSubsetMaterial( subset );
pComboBox->AddItem( pMaterial->strName, ( void* )( INT_PTR )subset );
}
// Store the correct technique for each material
for ( UINT i = 0; i < g_MeshLoader.GetNumMaterials(); ++i )
{
Material* pMaterial = g_MeshLoader.GetMaterial( i );
const char* strTechnique = "";
if( pMaterial->pTextureRV10 && pMaterial->bSpecular )
strTechnique = "TexturedSpecular";
else if( pMaterial->pTextureRV10 && !pMaterial->bSpecular )
strTechnique = "TexturedNoSpecular";
else if( !pMaterial->pTextureRV10 && pMaterial->bSpecular )
strTechnique = "Specular";
else if( !pMaterial->pTextureRV10 && !pMaterial->bSpecular )
strTechnique = "NoSpecular";
pMaterial->pTechnique = g_pEffect10->GetTechniqueByName( strTechnique );
}
LoadRasterizerStates(pd3dDevice);
// Load the mesh into dump
g_DumpMesh = new DumpMesh(pd3dDevice, g_MeshLoader.GetMesh());
g_DumpMesh->DumpVertices();
g_DumpMesh->DumpIndices();
// Construct the mesh
g_AABBConstructor = new txAABBConstructor(pd3dDevice,g_DumpMesh->GetVertexCache(),g_DumpMesh->GetIndexCache());
g_FunctionDraw = new txFunctionMeshDisplay(pd3dDevice);
// Create a cube
//CreateCube(pd3dDevice);
//g_pBox = new Box();
//g_pBox->init(pd3dDevice, 1.0f);
//g_pBox->customizeInit(pd3dDevice, D3DXVECTOR3(0.0f,0.0f,0.0f),D3DXVECTOR3(1.0f,1.0f,1.0f));
g_Parabola = new txFunctionUVBase(-2.0,2.0,-2.0,2.0,2,2);
g_Parabola->Discrete(txUVFunctionZoo::Parabola);
g_ParabolaDis = new txFunctionDrawor(g_Parabola->GetVList(), g_Parabola->M(), g_Parabola->N(),pd3dDevice);
//g_UVImport = new txUVSurfaceImport();
//g_UVImport->ConstructSurfaceFromFile("D:\\data\\screwsurface.xyz");
//g_UVFileDisp = new txFunctionDrawor(g_UVImport->GetVList(), g_UVImport->M(), g_UVImport->N(),pd3dDevice);
std::vector<txVec3> temv;
D3DXVECTOR32txVec3(g_Parabola->GetVList(),temv);
txSurface surface(temv, g_Parabola->M(), g_Parabola->N());
txICollisionshapeMesh meshmodel(surface);
meshmodel.Build();
txPlane plane0(0,0,1,10);
std::vector<txPlane> planes;
planes.push_back(plane0);
txPlaneCollisionShape planecoll(planes);
planecoll.Collide(meshmodel);
const size_t AABBLevelCount = g_AABBConstructor->GetAABBLevelCount();
// Add the AABB Levels
CDXUTComboBox* pLevelComboBox = g_SampleUI.GetComboBox( IDC_AABBSUBLEVEL );
pLevelComboBox->RemoveAllItems();
wchar_t sz[32];
for (size_t i=0; i<AABBLevelCount-1; i++){
//itoa(i,temp,10);
swprintf(sz,31,L"%d",i);
pLevelComboBox->AddItem( sz, ( void* )( UINT64 )i );
}
// Setup the camera's view parameters
D3DXVECTOR3 vecEye( 2.0f, 1.0f, 0.0f );
D3DXVECTOR3 vecAt ( 0.0f, 0.0f, -0.0f );
g_Camera.SetViewParams( &vecEye, &vecAt );
D3D10_BLEND_DESC blendDesc = {0};
blendDesc.AlphaToCoverageEnable = false;
blendDesc.BlendEnable[0] = true;
blendDesc.SrcBlend = D3D10_BLEND_SRC_ALPHA;
blendDesc.DestBlend = D3D10_BLEND_INV_SRC_ALPHA;
blendDesc.BlendOp = D3D10_BLEND_OP_ADD;
blendDesc.SrcBlendAlpha = D3D10_BLEND_ONE;
blendDesc.DestBlendAlpha = D3D10_BLEND_ZERO;
blendDesc.BlendOpAlpha = D3D10_BLEND_OP_ADD;
blendDesc.RenderTargetWriteMask[0] = D3D10_COLOR_WRITE_ENABLE_ALL;
HR(pd3dDevice->CreateBlendState(&blendDesc, &g_TransparentBS));
return S_OK;
}
//--------------------------------------------------------------------------------------
// Create any D3D11 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice( pd3dDevice, pd3dImmediateContext ) );
V_RETURN( g_D3DSettingsDlg.OnD3D11CreateDevice( pd3dDevice ) );
g_pTxtHelper = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 15 );
g_pTxtHelper1 = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 35 );
// textures / rts
D3D11_TEXTURE2D_DESC TDesc;
TDesc.Width = UINT(g_fShadowMapWidth);
TDesc.Height = UINT(g_fShadowMapHeight);
TDesc.MipLevels = 1;
TDesc.ArraySize = 1;
TDesc.Format = DXGI_FORMAT_R16_TYPELESS;
TDesc.SampleDesc.Count = 1;
TDesc.SampleDesc.Quality = 0;
TDesc.Usage = D3D11_USAGE_DEFAULT;
TDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL | D3D11_BIND_SHADER_RESOURCE;
TDesc.CPUAccessFlags = 0;
TDesc.MiscFlags = 0;
pd3dDevice->CreateTexture2D( &TDesc, 0, &g_pRSMDepthStencilTexture);
DXUT_SetDebugName( g_pRSMDepthStencilTexture, "RSM" );
D3D11_DEPTH_STENCIL_VIEW_DESC DSVDesc;
DSVDesc.Format = DXGI_FORMAT_D16_UNORM;
DSVDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
DSVDesc.Flags = 0;
DSVDesc.Texture2D.MipSlice = 0;
pd3dDevice->CreateDepthStencilView( g_pRSMDepthStencilTexture, &DSVDesc, & g_pDepthStencilTextureDSV );
DXUT_SetDebugName( g_pDepthStencilTextureDSV, "RSM DSV" );
D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;
SRVDesc.Format = DXGI_FORMAT_R16_UNORM;
SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
SRVDesc.Texture2D.MipLevels = 1;
SRVDesc.Texture2D.MostDetailedMip = 0;
pd3dDevice->CreateShaderResourceView( g_pRSMDepthStencilTexture, &SRVDesc, &g_pDepthTextureSRV );
DXUT_SetDebugName( g_pDepthTextureSRV, "RSM SRV" );
// Setup constant buffers
D3D11_BUFFER_DESC Desc;
// Utility
Desc.Usage = D3D11_USAGE_DYNAMIC;
Desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
Desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
Desc.MiscFlags = 0;
Desc.ByteWidth = sizeof( CB_CONSTANTS );
V_RETURN( pd3dDevice->CreateBuffer( &Desc, NULL, &g_pcbConstants ) );
DXUT_SetDebugName( g_pcbConstants, "CB_CONSTANTS" );
// Load the scene mesh
WCHAR str[256];
V_RETURN( DXUTFindDXSDKMediaFileCch( str, 256, L"ColumnScene\\scene.sdkmesh" ) );
g_SceneMesh.Create( pd3dDevice, str, false );
V_RETURN( DXUTFindDXSDKMediaFileCch( str, 256, L"ColumnScene\\poles.sdkmesh" ) );
g_Poles.Create( pd3dDevice, str, false );
// Setup the camera
D3DXVECTOR3 vecEye( 0.95f, 5.83f, -14.48f );
D3DXVECTOR3 vecAt ( 0.90f, 5.44f, -13.56f );
g_Camera.SetViewParams( &vecEye, &vecAt );
D3DXVECTOR3 vecEyeL = D3DXVECTOR3( 0,0,0 );
D3DXVECTOR3 vecAtL ( 0, -0.5, 1 );
g_LCamera.SetViewParams( &vecEyeL, &vecAtL );
// Create sampler states for point and linear
// PointCmp
D3D11_SAMPLER_DESC SamDesc;
SamDesc.Filter = D3D11_FILTER_COMPARISON_MIN_MAG_MIP_POINT;
SamDesc.AddressU = D3D11_TEXTURE_ADDRESS_BORDER;
SamDesc.AddressV = D3D11_TEXTURE_ADDRESS_BORDER;
SamDesc.AddressW = D3D11_TEXTURE_ADDRESS_BORDER;
SamDesc.MipLODBias = 0.0f;
SamDesc.MaxAnisotropy = 1;
SamDesc.ComparisonFunc = D3D11_COMPARISON_LESS_EQUAL;
SamDesc.BorderColor[0] = SamDesc.BorderColor[1] = SamDesc.BorderColor[2] = SamDesc.BorderColor[3] = 1.0;
SamDesc.MinLOD = 0;
SamDesc.MaxLOD = D3D11_FLOAT32_MAX;
V_RETURN( pd3dDevice->CreateSamplerState( &SamDesc, &g_pSamplePointCmp ) );
DXUT_SetDebugName( g_pSamplePointCmp, "PointCmp" );
// Point
SamDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
SamDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
V_RETURN( pd3dDevice->CreateSamplerState( &SamDesc, &g_pSamplePoint ) );
DXUT_SetDebugName( g_pSamplePoint, "Point" );
// Linear
SamDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
SamDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
SamDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
SamDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
V_RETURN( pd3dDevice->CreateSamplerState( &SamDesc, &g_pSampleLinear ) );
DXUT_SetDebugName( g_pSampleLinear, "Linear" );
// Create a blend state to disable alpha blending
D3D11_BLEND_DESC BlendState;
ZeroMemory(&BlendState, sizeof(D3D11_BLEND_DESC));
BlendState.IndependentBlendEnable = FALSE;
BlendState.RenderTarget[0].BlendEnable = FALSE;
BlendState.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
hr = pd3dDevice->CreateBlendState(&BlendState, &g_pBlendStateNoBlend);
DXUT_SetDebugName( g_pBlendStateNoBlend, "No Blend" );
BlendState.RenderTarget[0].RenderTargetWriteMask = 0;
hr = pd3dDevice->CreateBlendState(&BlendState, &g_pBlendStateColorWritesOff);
DXUT_SetDebugName( g_pBlendStateColorWritesOff, "Color Writes Off");
return S_OK;
}
//--------------------------------------------------------------------------------------
// Create any D3D9 resources that will live through a device reset (D3DPOOL_MANAGED)
// and aren't tied to the back buffer size
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D10CreateDevice( ID3D10Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
V_RETURN( g_DialogResourceManager.OnD3D10CreateDevice( pd3dDevice ) );
V_RETURN( g_SettingsDlg.OnD3D10CreateDevice( pd3dDevice ) );
V_RETURN( D3DX10CreateFont( pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE,
L"Arial", &g_pFont10 ) );
V_RETURN( D3DX10CreateSprite( pd3dDevice, 512, &g_pSprite10 ) );
g_pTxtHelper = new CDXUTTextHelper( NULL, NULL, g_pFont10, g_pSprite10, 15 );
#define IDC_WIREFRAME 10
g_SampleUI.GetCheckBox( IDC_WIREFRAME )->SetVisible( false );
V_RETURN( LoadEffect10( pd3dDevice ) );
WCHAR str[MAX_PATH];
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"PIXWorkshop\\Terrain1.bmp" ) );
V_RETURN( g_Terrain.LoadTerrain( str, g_SqrtNumTiles, g_SidesPerTile, g_fWorldScale, g_fHeightScale, 1000, 1.0f,
2.0f ) );
ResetBalls();
// Create a Vertex Decl for the terrain and basic meshes
const D3D10_INPUT_ELEMENT_DESC basiclayout[] =
{
{ "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 },
};
D3D10_PASS_DESC PassDesc;
g_pRenderTerrain->GetPassByIndex( 0 )->GetDesc( &PassDesc );
V_RETURN( pd3dDevice->CreateInputLayout( basiclayout, sizeof( basiclayout ) / sizeof( basiclayout[0] ),
PassDesc.pIAInputSignature,
PassDesc.IAInputSignatureSize, &g_pBasicDecl10 ) );
// Create a Vertex Decl for the ball
const D3D10_INPUT_ELEMENT_DESC balllayout[] =
{
{ "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 },
{ "TEXCOORD", 1, DXGI_FORMAT_R32G32B32_FLOAT, 1, 0, D3D10_INPUT_PER_INSTANCE_DATA, 1 },
};
g_pRenderBall->GetPassByIndex( 0 )->GetDesc( &PassDesc );
V_RETURN( pd3dDevice->CreateInputLayout( balllayout, sizeof( balllayout ) / sizeof( balllayout[0] ),
PassDesc.pIAInputSignature,
PassDesc.IAInputSignatureSize, &g_pBallDecl10 ) );
// Create a Vertex Decl for the grass
const D3D10_INPUT_ELEMENT_DESC grasslayout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 1, DXGI_FORMAT_R32G32B32_FLOAT, 1, 0, D3D10_INPUT_PER_INSTANCE_DATA, 1 },
};
g_pRenderGrass->GetPassByIndex( 0 )->GetDesc( &PassDesc );
V_RETURN( pd3dDevice->CreateInputLayout( grasslayout, sizeof( grasslayout ) / sizeof( grasslayout[0] ),
PassDesc.pIAInputSignature,
PassDesc.IAInputSignatureSize, &g_pGrassDecl10 ) );
// Load terrain device objects
V_RETURN( g_Terrain.OnCreateDevice( pd3dDevice ) );
// Load a mesh
g_BallMesh.Create( pd3dDevice, L"PIXWorkshop\\lowpolysphere.sdkmesh" );
g_SkyMesh.Create( pd3dDevice, L"PIXWorkshop\\desertsky.sdkmesh" );
// Create a VB for the stream data
D3D10_BUFFER_DESC BufferDesc;
BufferDesc.ByteWidth = NUM_PLAYERS * sizeof( D3DXVECTOR3 );
BufferDesc.Usage = D3D10_USAGE_DYNAMIC;
BufferDesc.BindFlags = D3D10_BIND_VERTEX_BUFFER;
BufferDesc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
BufferDesc.MiscFlags = 0;
V_RETURN( pd3dDevice->CreateBuffer( &BufferDesc, NULL, &g_pStreamDataVB10 ) );
// Create a VB for the grass instances
BufferDesc.ByteWidth = g_SqrtNumTiles * g_SqrtNumTiles * sizeof( D3DXVECTOR3 );
V_RETURN( pd3dDevice->CreateBuffer( &BufferDesc, NULL, &g_pGrassDataVB10 ) );
// Load a texture for the mesh
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"PIXWorkshop\\Terrain1.bmp" ) );
V_RETURN( D3DX10CreateShaderResourceViewFromFile( pd3dDevice, str, NULL, NULL, &g_pHeightTexRV, NULL ) );
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"PIXWorkshop\\Terrain1_Norm.dds" ) );
V_RETURN( D3DX10CreateShaderResourceViewFromFile( pd3dDevice, str, NULL, NULL, &g_pNormalTexRV, NULL ) );
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"PIXWorkshop\\grass_v3_dark_tex.dds" ) );
V_RETURN( D3DX10CreateShaderResourceViewFromFile( pd3dDevice, str, NULL, NULL, &g_pGrassTexRV, NULL ) );
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"PIXWorkshop\\Dirt_Diff.dds" ) );
V_RETURN( D3DX10CreateShaderResourceViewFromFile( pd3dDevice, str, NULL, NULL, &g_pDirtTexRV, NULL ) );
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"PIXWorkshop\\Grass_Diff.dds" ) );
V_RETURN( D3DX10CreateShaderResourceViewFromFile( pd3dDevice, str, NULL, NULL, &g_pGroundGrassTexRV, NULL ) );
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"PIXWorkshop\\Terrain1_Mask.dds" ) );
V_RETURN( D3DX10CreateShaderResourceViewFromFile( pd3dDevice, str, NULL, NULL, &g_pMaskTexRV, NULL ) );
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"PIXWorkshop\\Terrain1_ShadeNormals.dds" ) );
V_RETURN( D3DX10CreateShaderResourceViewFromFile( pd3dDevice, str, NULL, NULL, &g_pShadeNormalTexRV, NULL ) );
// Setup the camera's view parameters
D3DXVECTOR3 vecEye( 0.0f, 20.0f, -50.0f );
D3DXVECTOR3 vecAt ( 0.0f, 5.0f, 0.0f );
g_Camera.SetViewParams( &vecEye, &vecAt );
return S_OK;
}
//------------------------------------------------------------------------
int CGraphicsLayer::CreateShader()
{
HRESULT r=0;
DWORD ShaderFlags=D3D10_SHADER_ENABLE_STRICTNESS;
ID3D10Blob *pErrors = 0;
// Compile shaders
ID3D10Blob* pBlobVS = NULL;
ID3D10Blob* pBlobHS = NULL;
ID3D10Blob* pBlobDS = NULL;
ID3D10Blob* pBlobPS = NULL;
ID3D10Blob* pBlobGS = NULL;
ID3D10Blob* pBlobGSFur = NULL;
if(CompileShaderFromFile( L"D3D11SimpleFx.hlsl", "SmoothVS", "vs_5_0", &pBlobVS )!=S_OK){return 1;}
if(CompileShaderFromFile( L"D3D11SimpleFx.hlsl", "SmoothHS", "hs_5_0", &pBlobHS )!=S_OK){return 1;}
if(CompileShaderFromFile( L"D3D11SimpleFx.hlsl", "SmoothDS", "ds_5_0", &pBlobDS )!=S_OK){return 1;}
if(CompileShaderFromFile( L"D3D11SimpleFx.hlsl", "SmoothGS", "gs_5_0", &pBlobGS )!=S_OK){return 1;}
if(CompileShaderFromFile( L"D3D11SimpleFx.hlsl", "FurGS", "gs_5_0", &pBlobGSFur )!=S_OK){return 1;}
if(CompileShaderFromFile( L"D3D11SimpleFx.hlsl", "SmoothPS", "ps_5_0", &pBlobPS )!=S_OK){return 1;}
if(m_pDevice->CreateVertexShader( pBlobVS->GetBufferPointer(), pBlobVS->GetBufferSize(), NULL, &m_pVSGouraud )!=S_OK){return 1;}
if(m_pDevice->CreateHullShader( pBlobHS->GetBufferPointer(), pBlobHS->GetBufferSize(), NULL, &m_pHSSmooth )!=S_OK){return 1;}
if(m_pDevice->CreateDomainShader( pBlobDS->GetBufferPointer(), pBlobDS->GetBufferSize(), NULL, &m_pDSSmooth )!=S_OK){return 1;}
if(m_pDevice->CreateGeometryShader( pBlobGS->GetBufferPointer(), pBlobGS->GetBufferSize(), NULL, &m_pGSSmooth )!=S_OK){return 1;}
if(m_pDevice->CreatePixelShader( pBlobPS->GetBufferPointer(), pBlobPS->GetBufferSize(), NULL, &m_pPSGouraud )!=S_OK){return 1;}
if(m_pDevice->CreateGeometryShader( pBlobGSFur->GetBufferPointer(), pBlobGSFur->GetBufferSize(), NULL, &m_pGSFur )!=S_OK){return 1;}
D3D11_INPUT_ELEMENT_DESC defaultLayout[] =
{
{"POSITION",0,DXGI_FORMAT_R32G32B32_FLOAT ,0, 0,D3D11_INPUT_PER_VERTEX_DATA,0},
};
if(m_pDevice->CreateInputLayout( defaultLayout, ARRAYSIZE( defaultLayout ), pBlobVS->GetBufferPointer(),
pBlobVS->GetBufferSize(), &m_pVertexLayout )!=S_OK){return 1;}
m_pDeviceContext->IASetInputLayout(m_pVertexLayout);
if(CreateConstantsBuffer()!=S_OK){return 1;}
D3DXMATRIX mtxWorld;
D3DXMatrixIdentity(&mtxWorld);
SetWorldMtx(mtxWorld);
D3DXMATRIX mtxView;
D3DXVECTOR3 vecEye(3.0f, 3.0f, 3.5f);
D3DXVECTOR3 vecAt(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 vecUp(0.0f, 1.0f, 0.0f);
D3DXMatrixLookAtLH(&mtxView, &vecEye, &vecAt, &vecUp);
SetViewMtx(mtxView);
D3DXMatrixPerspectiveFovLH(&m_mProj, (float)D3DX_PI * 0.5f,
m_rcScreenRect.right/(float)m_rcScreenRect.bottom, 0.1f, 50.0f);
UpdateMatrices();
}
//--------------------------------------------------------------------------------------
// This callback function will be called immediately after the Direct3D device has been
// created, which will happen during application initialization and windowed/full screen
// toggles. This is the best location to create D3DPOOL_MANAGED resources since these
// resources need to be reloaded whenever the device is destroyed. Resources created
// here should be released in the OnDestroyDevice callback.
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
V_RETURN( g_DialogResourceManager.OnD3D9CreateDevice( pd3dDevice ) );
V_RETURN( g_SettingsDlg.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_pFont ) );
// Define DEBUG_VS and/or DEBUG_PS to debug vertex and/or pixel shaders with the
// shader debugger. Debugging vertex shaders requires either REF or software vertex
// processing, and debugging pixel shaders requires REF. The
// D3DXSHADER_FORCE_*_SOFTWARE_NOOPT flag improves the debug experience in the
// shader debugger. It enables source level debugging, prevents instruction
// reordering, prevents dead code elimination, and forces the compiler to compile
// against the next higher available software target, which ensures that the
// unoptimized shaders do not exceed the shader model limitations. Setting these
// flags will cause slower rendering since the shaders will be unoptimized and
// forced into software. See the DirectX documentation for more information about
// using the shader debugger.
DWORD dwShaderFlags = D3DXFX_NOT_CLONEABLE;
#if defined( DEBUG ) || defined( _DEBUG )
// Set the D3DXSHADER_DEBUG flag to embed debug information in the shaders.
// Setting this flag improves the shader debugging experience, but still allows
// the shaders to be optimized and to run exactly the way they will run in
// the release configuration of this program.
dwShaderFlags |= D3DXSHADER_DEBUG;
#endif
#ifdef DEBUG_VS
dwShaderFlags |= D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT;
#endif
#ifdef DEBUG_PS
dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
#endif
// Determine which LDPRT texture and SH coefficient cubemap formats are supported
IDirect3D9* pD3D = DXUTGetD3D9Object();
D3DCAPS9 Caps;
pd3dDevice->GetDeviceCaps( &Caps );
D3DDISPLAYMODE DisplayMode;
pd3dDevice->GetDisplayMode( 0, &DisplayMode );
GetSupportedTextureFormat( pD3D, &Caps, DisplayMode.Format, &g_fmtTexture, &g_fmtCubeMap );
if( D3DFMT_UNKNOWN == g_fmtTexture || D3DFMT_UNKNOWN == g_fmtCubeMap )
return E_FAIL;
// Create the skybox
g_Skybox.OnCreateDevice( pd3dDevice, 50, L"Light Probes\\rnl_cross.dds", L"SkyBox.fx" );
V( D3DXSHProjectCubeMap( 6, g_Skybox.GetEnvironmentMap(), g_fSkyBoxLightSH[0], g_fSkyBoxLightSH[1],
g_fSkyBoxLightSH[2] ) );
// Now compute the SH projection of the skybox...
LPDIRECT3DCUBETEXTURE9 pSHCubeTex = NULL;
V( D3DXCreateCubeTexture( pd3dDevice, 256, 1, 0, D3DFMT_A16B16G16R16F, D3DPOOL_MANAGED, &pSHCubeTex ) );
SHCubeProj projData;
projData.Init( g_fSkyBoxLightSH[0], g_fSkyBoxLightSH[1], g_fSkyBoxLightSH[2] );
V( D3DXFillCubeTexture( pSHCubeTex, SHCubeFill, &projData ) );
g_Skybox.InitSH( pSHCubeTex );
// Read the D3DX effect file
WCHAR str[MAX_PATH];
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, TEXT( "LocalDeformablePRT.fx" ) ) );
// If this fails, there should be debug output as to they the .fx file failed to compile
V_RETURN( D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, dwShaderFlags, NULL, &g_pEffect, NULL ) );
V_RETURN( LoadTechniqueObjects( "bat" ) );
V_RETURN( g_LightControl.StaticOnD3D9CreateDevice( pd3dDevice ) );
g_LightControl.SetRadius( 2.0f );
// Setup the camera's view parameters
D3DXVECTOR3 vecEye( 0.0f, 0.0f, -5.0f );
D3DXVECTOR3 vecAt ( 0.0f, 0.0f, 0.0f );
g_Camera.SetViewParams( &vecEye, &vecAt );
// Set the model's initial orientation
D3DXQUATERNION quatRotation;
D3DXQuaternionRotationYawPitchRoll( &quatRotation, -0.5f, 0.7f, 0.0f );
g_Camera.SetWorldQuat( quatRotation );
return hr;
}
//--------------------------------------------------------------------------------------
// 디바이스 생성 함수
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
//mesh 불러와서 g_pMesh에 저장
V_RETURN( LoadMesh( pd3dDevice, L"tiny\\tiny.x", &g_pMesh ) );
D3DXVECTOR3* pData;
D3DXVECTOR3 vCenter;
FLOAT fObjectRadius;
//메쉬를 쓸 buffer에 대한 lock
//lock은 버텍스 버퍼의 위치 값을 불러줌(어디에 있는지 상관 없이 리턴)
//첫 번째 인자가 버퍼 옵션(3= readonly)
V( g_pMesh->LockVertexBuffer( 3, ( LPVOID* )&pData ) );
//메쉬 경계값 산출 = 모든 vertex 순회
//모든 vertex순회 후 평균 계산= 중점, 가장 먼거리의 vertex가 반지름
V( D3DXComputeBoundingSphere( pData, g_pMesh->GetNumVertices(),
D3DXGetFVFVertexSize( g_pMesh->GetFVF() ), &vCenter, &fObjectRadius ) );
//buffer unlock
V( g_pMesh->UnlockVertexBuffer() );
//월드 좌표 초기 세팅
//mesh에서 받은 중앙값을 기준으로 세팅
D3DXMatrixTranslation( &g_mCenterWorld, -vCenter.x, -vCenter.y, -vCenter.z );
D3DXMATRIXA16 m;
D3DXMatrixRotationY( &m, D3DX_PI );
g_mCenterWorld *= m;
D3DXMatrixRotationX( &m, D3DX_PI / 2.0f );
g_mCenterWorld *= m;
//warping된 device객체 생성
V_RETURN( CDXUTDirectionWidget::StaticOnD3D9CreateDevice( pd3dDevice ) );
//조명 이동 형태가 구를 이루고 있는데, 해당 이동 좌표를 결정
for( int i = 0; i < MAX_LIGHTS; i++ )
g_LightControl[i].SetRadius( fObjectRadius );
//셰이더의 데이터를 메모리에 보존하지 않아 이펙트의 메모리 사용량을 50% 줄임
DWORD dwShaderFlags = D3DXFX_NOT_CLONEABLE;
//컴파일러에 미리 알려주는 preshading 옵션 추가
//그런데 우리는 init에서 g_bEnablePreshader를 true로 했으니 거치지 않음
if( !g_bEnablePreshader )
dwShaderFlags |= D3DXSHADER_NO_PRESHADER;
//이펙트 파일의 파일명을 찾고, 받아서 str에 저장(방어코드 개념)
WCHAR str[MAX_PATH];
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"BasicHLSL.fx" ) );
//str을 이용해서 실제 shader를 g_pEffect에 넣음
V_RETURN( D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, dwShaderFlags, NULL, &g_pEffect, NULL ) );
// 텍스쳐 파일명을 찾고, 받아서 str에 저장(방어코드 개념)
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"tiny\\tiny_skin.dds" ) );
//텍스쳐 불러와서 g_pMeshTexture에 저장
V_RETURN( D3DXCreateTextureFromFileEx( pd3dDevice, str, D3DX_DEFAULT, D3DX_DEFAULT,
D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED,
D3DX_DEFAULT, D3DX_DEFAULT, 0,
NULL, NULL, &g_pMeshTexture ) );
//쓸데없는 코드 같아 보임
//렌더에서 프레임마다 설정해주는 중
// //shader material에 조명 수치 적용 값(예정)
// D3DXCOLOR colorMtrlDiffuse( 1.0f, 1.0f, 1.0f, 1.0f );
// D3DXCOLOR colorMtrlAmbient( 0.35f, 0.35f, 0.35f, 0 );
//
// //shader와 준비된 설정값 바인딩 과정
// //material 조명 수치, texture 등
// V_RETURN( g_pEffect->SetValue( "g_MaterialAmbientColor", &colorMtrlAmbient, sizeof( D3DXCOLOR ) ) );
// V_RETURN( g_pEffect->SetValue( "g_MaterialDiffuseColor", &colorMtrlDiffuse, sizeof( D3DXCOLOR ) ) );
V_RETURN( g_pEffect->SetTexture( "g_MeshTexture", g_pMeshTexture ) );
//카메라 위치를 설정하는 코드
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;
}
//--------------------------------------------------------------------------------------
// Create any D3D11 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
HRESULT hr;
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice( pd3dDevice, pd3dImmediateContext ) );
V_RETURN( g_D3DSettingsDlg.OnD3D11CreateDevice( pd3dDevice ) );
g_pTxtHelper = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 15 );
// D3DXVECTOR3 vCenter( 0.25767413f, -28.503521f, 111.00689f );
FLOAT fObjectRadius = 378.15607f;
lightpos = D3DXVECTOR3(300,300,-200);
//test = new testing();
hr = test.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext);
hr = tessplane.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext);
hr = tesscube.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,80,D3DXVECTOR3(300,50,-200));//D3DXVECTOR3(300,50,-200
hr = lightsphere.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,10,lightpos);
hr = fuse.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext);
hr = board1.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,D3DXVECTOR3(300,-300,-1000));
hr = deboard.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,D3DXVECTOR3(-300,-300,-1000));
hr = geo_alien.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext);
hr = FirePart.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,80,0); //0 = fire
hr = sky.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,D3DXVECTOR3(0,0,0));
hr = buildings.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext);
hr = MissilePart.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,20,1);
g_LightControl.SetRadius( 2000 );
// Setup the camera's view parameters
D3DXVECTOR3 vecEye( 0.0f, 50.0f, -1000.0f );
D3DXVECTOR3 vecAt ( 0.0f, 0.0f, -0.0f );
g_Camera.SetRotateButtons(true,false,false);
g_Camera.SetViewParams( &vecEye, &vecAt );
g_Camera.SetEnablePositionMovement( true );
g_Camera.SetScalers( 0.005f, 500.0f );
D3D11_DEPTH_STENCIL_DESC descDS;
ZeroMemory(&descDS, sizeof(descDS));
descDS.DepthEnable = false;
descDS.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
descDS.DepthFunc = D3D11_COMPARISON_LESS;
descDS.StencilEnable = FALSE;
hr = pd3dDevice->CreateDepthStencilState( &descDS, &g_DepthState);
//setup stuff for post process
ID3DBlob* pVertexShaderBuffer = NULL;
V_RETURN( CompileShaderFromFile( L"PP1.hlsl", "VS", "vs_4_0", &pVertexShaderBuffer ) );
ID3DBlob* pPixelShaderBuffer = NULL;
V_RETURN( CompileShaderFromFile( L"PP1.hlsl", "PS", "ps_4_0", &pPixelShaderBuffer ) );
V_RETURN( pd3dDevice->CreateVertexShader( pVertexShaderBuffer->GetBufferPointer(),
pVertexShaderBuffer->GetBufferSize(), NULL, &VSPPFirstPass ) );
DXUT_SetDebugName( VSPPFirstPass, "VSPost1" );
V_RETURN( pd3dDevice->CreatePixelShader( pPixelShaderBuffer->GetBufferPointer(),
pPixelShaderBuffer->GetBufferSize(), NULL, &PSPPFirstPass ) );
DXUT_SetDebugName( PSPPFirstPass, "PSPost1" );
pVertexShaderBuffer = NULL;
V_RETURN( CompileShaderFromFile( L"Gaussblur.hlsl", "VS", "vs_4_0", &pVertexShaderBuffer ) );
pPixelShaderBuffer = NULL;
V_RETURN( CompileShaderFromFile( L"Gaussblur.hlsl", "PS", "ps_4_0", &pPixelShaderBuffer ) );
V_RETURN( pd3dDevice->CreateVertexShader( pVertexShaderBuffer->GetBufferPointer(),
pVertexShaderBuffer->GetBufferSize(), NULL, &VSPPBlur ) );
DXUT_SetDebugName( VSPPBlur, "VSBlur" );
V_RETURN( pd3dDevice->CreatePixelShader( pPixelShaderBuffer->GetBufferPointer(),
pPixelShaderBuffer->GetBufferSize(), NULL, &PSPPBlur ) );
DXUT_SetDebugName( PSPPBlur, "PSBlur" );
pVertexShaderBuffer = NULL;
V_RETURN( CompileShaderFromFile( L"bloom_combine.hlsl", "VS", "vs_4_0", &pVertexShaderBuffer ) );
pPixelShaderBuffer = NULL;
V_RETURN( CompileShaderFromFile( L"bloom_combine.hlsl", "PS", "ps_4_0", &pPixelShaderBuffer ) );
V_RETURN( pd3dDevice->CreateVertexShader( pVertexShaderBuffer->GetBufferPointer(),
pVertexShaderBuffer->GetBufferSize(), NULL, &VSPPComb ) );
DXUT_SetDebugName( VSPPComb, "VSComb" );
V_RETURN( pd3dDevice->CreatePixelShader( pPixelShaderBuffer->GetBufferPointer(),
pPixelShaderBuffer->GetBufferSize(), NULL, &PSPPComb ) );
DXUT_SetDebugName( PSPPComb, "PSComb" );
D3D11_BUFFER_DESC Desc;
Desc.Usage = D3D11_USAGE_DYNAMIC;
Desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
Desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
Desc.MiscFlags = 0;
Desc.ByteWidth = sizeof( blur_cbuffer );
V_RETURN( pd3dDevice->CreateBuffer( &Desc, NULL, &blur_cb_buffer ) );
DXUT_SetDebugName( blur_cb_buffer, "blur_cb" );
//g_Camera.SetRadius( fObjectRadius * 3.0f, fObjectRadius * 0.5f, fObjectRadius * 10.0f );
return S_OK;
}
void D3D9::InitD3D9(HWND hWnd)
{
this->hWnd = hWnd;
// Create the D3D object.
if( NULL == ( d3d_ = Direct3DCreate9( D3D_SDK_VERSION ) ) )
MessageBox(hWnd, L"Create Direct3D9 failed!", L"error!", 0) ;
ZeroMemory( &d3dpp_, sizeof(d3dpp_) );
// Get max display resolution and set it as back buffer size
D3DDISPLAYMODE displayMode ;
d3d_->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &displayMode) ;
// Initialize the max resolution width and height
screen_width_ = displayMode.Width;
screen_height_ = displayMode.Height;
if(is_fullscreen_)
{
d3dpp_.Windowed = FALSE;
d3dpp_.BackBufferWidth = displayMode.Width;
d3dpp_.BackBufferHeight = displayMode.Height;
}
else
{
d3dpp_.Windowed = TRUE;
// Get current window size and set it as back buffer size
RECT rect;
GetClientRect(hWnd, &rect);
d3dpp_.BackBufferWidth = rect.right - rect.left;
d3dpp_.BackBufferHeight = rect.bottom - rect.top;
}
// We didn't specify the back-buffer width and height, D3D will initialize it to the window width and height
d3dpp_.hDeviceWindow = hWnd;
d3dpp_.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp_.BackBufferCount = 1;
d3dpp_.BackBufferFormat = D3DFMT_X8R8G8B8;
d3dpp_.EnableAutoDepthStencil = TRUE ;
d3dpp_.AutoDepthStencilFormat = D3DFMT_D16 ;
// Create the D3DDevice
HRESULT hr = d3d_->CreateDevice(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
hWnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&d3dpp_, &d3ddevice_ );
if(FAILED(hr))
{
MessageBox(hWnd, L"Create Direct3D9 device failed!", L"error!", 0) ;
}
// Setup view matrix
D3DXVECTOR3 vecEye(0.0f, 0.0f, -10.0f);
D3DXVECTOR3 vecAt (0.0f, 0.0f, 0.0f);
D3DXVECTOR3 vecUp (0.0f, 1.0f, 0.0f) ;
camera->SetViewParams(vecEye, vecAt, vecUp);
// Setup projection matrix
float aspectRatio = (float)d3dpp_.BackBufferWidth / (float)d3dpp_.BackBufferHeight ;
camera->SetProjParams(D3DX_PI / 4, aspectRatio, 1.0f, 1000.0f) ;
ResetDevice();
}
