void ScratchPad_DrawArrow(
IScratchPad3D *pPad,
const Vector &vPos,
const Vector &vDirection,
const Vector &vColor,
float flLength,
float flLineWidth,
float flHeadWidth,
int nCylinderSegments,
int nHeadSegments,
float flArrowHeadPercentage
)
{
Vector vNormDir = vDirection;
VectorNormalize( vNormDir );
Vector vConeBase = vPos + vNormDir * (flLength * ( 1 - flArrowHeadPercentage ) );
Vector vConeEnd = vPos + vNormDir * flLength;
Vector vLightDir( -1, -1, -1 );
VectorNormalize( vLightDir ); // could precalculate this
pPad->SetRenderState( IScratchPad3D::RS_FillMode, IScratchPad3D::FillMode_Solid );
pPad->SetRenderState( IScratchPad3D::RS_ZRead, true );
ScratchPad_DrawLitCylinder( pPad, vPos, vConeBase, vColor, vColor*0.25f, vLightDir, flLineWidth, nCylinderSegments );
ScratchPad_DrawLitCone( pPad, vConeBase, vConeEnd, vColor, vColor*0.25f, vLightDir, flHeadWidth, nHeadSegments );
}
//--------------------------------------------------------------------------------------
// Render the scene using the D3D9 device
//--------------------------------------------------------------------------------------
void CALLBACK OnD3D10FrameRender( ID3D10Device* pd3dDevice, double fTime, float fElapsedTime, void* pUserContext )
{
HRESULT hr = S_OK;
float ClearColor[4] = { 0,0,0,0 };
ID3D10RenderTargetView* pRTV = DXUTGetD3D10RenderTargetView();
pd3dDevice->ClearRenderTargetView( pRTV, ClearColor );
ID3D10DepthStencilView* pDSV = DXUTGetD3D10DepthStencilView();
pd3dDevice->ClearDepthStencilView( pDSV, D3D10_CLEAR_DEPTH, 1.0, 0 );
// 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;
}
// Render the scene
{
D3DXVECTOR4 vLightDir( -1,1,-1,1 );
D3DXVec4Normalize( &vLightDir, &vLightDir );
g_pvWorldLightDir->SetFloatVector( ( float* )&vLightDir );
g_pfTime->SetFloat( ( float )fTime );
g_pfElapsedTime->SetFloat( fElapsedTime );
VisibilityCullTiles();
DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L"Render Sky" );
RenderSky( pd3dDevice );
DXUT_EndPerfEvent();
DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L"Render Terrain" );
RenderTerrain( pd3dDevice );
DXUT_EndPerfEvent();
if( g_bRenderBalls )
{
DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L"Render Balls" );
RenderBalls( pd3dDevice );
DXUT_EndPerfEvent();
}
if( g_bRenderGrass )
{
DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L"Render Grass" );
RenderGrass( pd3dDevice );
DXUT_EndPerfEvent();
}
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 ) );
DXUT_EndPerfEvent();
}
}
//--------------------------------------------------------------------------------------
// Initialize the app
//--------------------------------------------------------------------------------------
void InitApp()
{
displacement_level = 1.5;
tess_lvl = 80;
drawwire = false;
D3DXVECTOR3 vLightDir( -1, 1, -1 );
D3DXVec3Normalize( &vLightDir, &vLightDir );
g_LightControl.SetLightDirection( vLightDir );
// Initialize dialogs
g_D3DSettingsDlg.Init( &g_DialogResourceManager );
g_HUD.Init( &g_DialogResourceManager );
g_SampleUI.Init( &g_DialogResourceManager );
g_HUD.SetCallback( OnGUIEvent ); int iY = 10;
g_HUD.AddButton( IDC_TOGGLEFULLSCREEN, L"Toggle full screen", 0, iY, 170, 23 );
g_HUD.AddButton( IDC_TOGGLEREF, L"Toggle REF (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_SampleUI.SetCallback( OnGUIEvent );
iY = -30;
WCHAR sz[100];
//iY += 24;
swprintf_s( sz, L"Tessellation Level: %2.1f", tess_lvl );
g_SampleUI.AddStatic( IDC_TESSLVL_STATIC, sz, -10, iY += 26, 150, 22 );
g_SampleUI.AddSlider( IDC_TESSLVL, 10, iY += 24, 150, 22, 1, 80, tess_lvl );
iY += 14;
swprintf_s( sz, L"Displacement Level: %2.1f", displacement_level );
g_SampleUI.AddStatic( IDC_DISPLACEMENTLVL_STATIC, sz, -10, iY += 26, 150, 22 );
g_SampleUI.AddSlider( IDC_DISPLACEMENTLVL, 10, iY += 24, 150, 22, 0, 150, (float)(displacement_level)/ 100.0f );
iY += 10;
g_SampleUI.AddCheckBox( IDC_TOGGLEWIRE, L"Toggle Wires", 20, iY += 26, 150, 22, drawwire );
iY += 10;
g_SampleUI.AddCheckBox( IDC_TOGGLEDT, L"Toggle Distanced Based tesselation", -120, iY += 26, 150, 22, true );
iY += 10;
g_SampleUI.AddRadioButton( IDC_PARTITION_INTEGER, IDC_PARTITION_MODE, L"Integer", 20, iY += 26, 170, 22 );
g_SampleUI.AddRadioButton( IDC_PARTITION_FRAC_EVEN, IDC_PARTITION_MODE, L"Fractional Even", 20, iY += 26, 170, 22 );
g_SampleUI.AddRadioButton( IDC_PARTITION_FRAC_ODD, IDC_PARTITION_MODE, L"Fractional Odd", 20, iY += 26, 170, 22 );
g_SampleUI.GetRadioButton( IDC_PARTITION_INTEGER )->SetChecked( true );
iY += 10;
g_SampleUI.AddCheckBox( IDC_TOGGLEBUILDING, L"Toggle buildings", 20, iY += 26, 150, 22, true );
}
void SkinnedMesh::DrawFrame( LPD3DXFRAME pFrame )
{
DDCamera* camera = GPlayerManager->GetCamera();
if ( !camera )
return;
D3DXMATRIXA16 matProj = camera->GetMatProj();
// Set the projection matrix for the vertex shader based skinning method
if ( FAILED( m_pEffect->SetMatrix( "mViewProj", &matProj ) ) )
{
assert( false );
return;
}
// Set Light for vertex shader
// 조심해!!
// 전역 라이트 속성 가져올 것
D3DXVECTOR4 vLightDir( 0.0f, 1.0f, -1.0f, 0.0f );
D3DXVec4Normalize( &vLightDir, &vLightDir );
if ( FAILED( DDRenderer::GetInstance()->GetDevice()->SetVertexShaderConstantF( 1, (float*)&vLightDir, 1 ) ) )
{
assert( false );
return;
}
if ( FAILED( m_pEffect->SetVector( "lhtDir", &vLightDir ) ) )
{
assert( false );
return;
}
LPD3DXMESHCONTAINER pMeshContainer;
pMeshContainer = pFrame->pMeshContainer;
while ( pMeshContainer != NULL )
{
DrawMeshContainer( pMeshContainer, pFrame );
pMeshContainer = pMeshContainer->pNextMeshContainer;
}
if ( pFrame->pFrameSibling != NULL )
{
DrawFrame( pFrame->pFrameSibling );
}
if ( pFrame->pFrameFirstChild != NULL )
{
DrawFrame( pFrame->pFrameFirstChild );
}
}
void CLcXSkinIns::Render()
{
HRESULT hr=-1;
LPDIRECT3DDEVICE9 pDev = (LPDIRECT3DDEVICE9)LcDev_GetD3Device();
CLcXSkinSrc* pOrg = (CLcXSkinSrc*)m_pOrg;
ID3DXEffect* pEft = pOrg->GetEffect();
// Setup the projection matrix
D3DXMATRIX matProj;
pDev->GetTransform(D3DTS_PROJECTION, &matProj);
D3DLIGHT9 light;
D3DXVECTOR3 vecLightDirUnnormalized(0.0f, -1.0f, 1.0f);
ZeroMemory( &light, sizeof(D3DLIGHT9) );
light.Type = D3DLIGHT_DIRECTIONAL;
light.Diffuse.r = 1.0f;
light.Diffuse.g = 1.0f;
light.Diffuse.b = 1.0f;
D3DXVec3Normalize( (D3DXVECTOR3*)&light.Direction, &vecLightDirUnnormalized );
light.Position.x = 0.0f;
light.Position.y = -1.0f;
light.Position.z = 1.0f;
light.Range = 1000.0f;
pDev->SetLight(0, &light );
pDev->LightEnable(0, TRUE );
// Set Light for vertex shader
D3DXVECTOR4 vLightDir( 0.0f, 1.0f, -1.0f, 0.0f );
D3DXVec4Normalize( &vLightDir, &vLightDir );
// for HLSL
{
pEft->SetMatrix( "mViewProj", &matProj);
pEft->SetVector( "lhtDir", &vLightDir);
}
// for shader
{
// set the projection matrix for the vertex shader based skinning method
D3DXMatrixTranspose(&matProj, &matProj);
pDev->SetVertexShaderConstantF(2, (float*)&matProj, 4);
pDev->SetVertexShaderConstantF(1, (float*)&vLightDir, 1);
}
if(m_pAC)
m_pAC->AdvanceTime(m_fElapse, NULL);
pOrg->UpdateFrameMatrices(m_pFrameOrg, &m_mtWld);
pOrg->DrawFrame(m_pFrameOrg);
static D3DXMATRIX mtI(1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1);
pDev->SetTransform(D3DTS_WORLD, &mtI);
}
//-----------------------------------------------------------------------------
// Name: RestoreDeviceObjects()
// Desc: Initialize scene objects.
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::RestoreDeviceObjects()
{
// Restore the fonts
m_pFont->RestoreDeviceObjects();
HRESULT hr = S_OK;
D3DLIGHT8 light;
m_ArcBall.SetWindow( m_d3dsdBackBuffer.Width, m_d3dsdBackBuffer.Height, 2.0f );
if (m_pdeSelected != NULL)
SetProjectionMatrix();
m_pd3dDevice->SetRenderState( D3DRS_DITHERENABLE, TRUE );
m_pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE );
m_pd3dDevice->SetRenderState( D3DRS_SPECULARENABLE, FALSE );
m_pd3dDevice->SetRenderState( D3DRS_NORMALIZENORMALS, TRUE );
m_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CW );
m_pd3dDevice->SetRenderState( D3DRS_LIGHTING, TRUE );
m_pd3dDevice->SetTextureStageState( 0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR );
m_pd3dDevice->SetTextureStageState( 0, D3DTSS_MINFILTER, D3DTEXF_LINEAR );
m_pd3dDevice->SetRenderState( D3DRS_COLORVERTEX, FALSE );
// Create vertex shader for the indexed skinning
DWORD dwIndexedVertexDecl1[] =
{
D3DVSD_STREAM( 0 ),
D3DVSD_REG( 0, D3DVSDT_FLOAT3 ), // Position of first mesh
D3DVSD_REG( 2, D3DVSDT_D3DCOLOR ), // Blend indices
// D3DVSD_REG( 2, D3DVSDT_UBYTE4 ), // Blend indices
D3DVSD_REG( 3, D3DVSDT_FLOAT3 ), // Normal
D3DVSD_REG( 4, D3DVSDT_FLOAT2 ), // Tex coords
D3DVSD_END()
};
DWORD dwIndexedVertexDecl2[] =
{
D3DVSD_STREAM( 0 ),
D3DVSD_REG( 0, D3DVSDT_FLOAT3 ), // Position of first mesh
D3DVSD_REG( 1, D3DVSDT_FLOAT1 ), // Blend weights
D3DVSD_REG( 2, D3DVSDT_D3DCOLOR ), // Blend indices
// D3DVSD_REG( 2, D3DVSDT_UBYTE4 ), // Blend indices
D3DVSD_REG( 3, D3DVSDT_FLOAT3 ), // Normal
D3DVSD_REG( 4, D3DVSDT_FLOAT2 ), // Tex coords
D3DVSD_END()
};
DWORD dwIndexedVertexDecl3[] =
{
D3DVSD_STREAM( 0 ),
D3DVSD_REG( 0, D3DVSDT_FLOAT3 ), // Position of first mesh
D3DVSD_REG( 1, D3DVSDT_FLOAT2 ), // Blend weights
D3DVSD_REG( 2, D3DVSDT_D3DCOLOR ), // Blend indices
// D3DVSD_REG( 2, D3DVSDT_UBYTE4 ), // Blend indices
D3DVSD_REG( 3, D3DVSDT_FLOAT3 ), // Normal
D3DVSD_REG( 4, D3DVSDT_FLOAT2 ), // Tex coords
D3DVSD_END()
};
DWORD dwIndexedVertexDecl4[] =
{
D3DVSD_STREAM( 0 ),
D3DVSD_REG( 0, D3DVSDT_FLOAT3 ), // Position of first mesh
D3DVSD_REG( 1, D3DVSDT_FLOAT3 ), // Blend weights
D3DVSD_REG( 2, D3DVSDT_D3DCOLOR ), // Blend indices
// D3DVSD_REG( 2, D3DVSDT_UBYTE4 ), // Blend indices
D3DVSD_REG( 3, D3DVSDT_FLOAT3 ), // Normal
D3DVSD_REG( 4, D3DVSDT_FLOAT2 ), // Tex coords
D3DVSD_END()
};
DWORD* dwIndexedVertexDecl[] = {dwIndexedVertexDecl1, dwIndexedVertexDecl2, dwIndexedVertexDecl3, dwIndexedVertexDecl4};
LPD3DXBUFFER pCode;
DWORD bUseSW = D3DUSAGE_SOFTWAREPROCESSING;
if (m_d3dCaps.VertexShaderVersion >= D3DVS_VERSION(1, 1))
{
bUseSW = 0;
}
for (DWORD i = 0; i < 4; ++i)
{
// Assemble the vertex shader file
if( FAILED( hr = D3DXAssembleShaderFromResource(NULL, MAKEINTRESOURCE(IDD_SHADER1 + i), 0, NULL, &pCode, NULL ) ) )
return hr;
// Create the vertex shader
if( FAILED( hr = m_pd3dDevice->CreateVertexShader( dwIndexedVertexDecl[i],
(DWORD*)pCode->GetBufferPointer(),
&(m_dwIndexedVertexShader[i]) , bUseSW ) ) )
{
return hr;
}
pCode->Release();
}
ZeroMemory( &light, sizeof(light) );
light.Type = D3DLIGHT_DIRECTIONAL;
light.Diffuse.r = 1.0;
light.Diffuse.g = 1.0;
light.Diffuse.b = 1.0;
light.Specular.r = 0;
light.Specular.g = 0;
light.Specular.b = 0;
light.Ambient.r = 0.25;
light.Ambient.g = 0.25;
light.Ambient.b = 0.25;
light.Direction = D3DXVECTOR3( 0.0f, 0.0f, -1.0f);
hr = m_pd3dDevice->SetLight(0, &light );
if (FAILED(hr))
return E_FAIL;
hr = m_pd3dDevice->LightEnable(0, TRUE);
if (FAILED(hr))
return E_FAIL;
// Set Light for vertex shader
D3DXVECTOR4 vLightDir( 0.0f, 0.0f, 1.0f, 0.0f );
m_pd3dDevice->SetVertexShaderConstant(1, &vLightDir, 1);
return S_OK;
}
/*******************************************************************************
* Function Name : RenderScene
* Returns : true if no error occured
* Description : Main rendering loop function of the program. The shell will
* call this function every frame.
*******************************************************************************/
bool OGLESOptimizeMesh::RenderScene()
{
unsigned long ui32Time;
// Clear the depth and frame buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Time
ui32Time = PVRShellGetTime();
m_ui32TimeDiff = ui32Time - m_ui32LastTime;
m_ui32LastTime = ui32Time;
// FPS
++m_ui32FPSFrameCnt;
m_ui32FPSTimeDiff += m_ui32TimeDiff;
if(m_ui32FPSTimeDiff >= g_ui32TimeFPSUpdate)
{
m_fFPS = m_ui32FPSFrameCnt * 1000.0f / (float) m_ui32FPSTimeDiff;
m_ui32FPSFrameCnt = 0;
m_ui32FPSTimeDiff = 0;
}
// Change mode when necessary
m_ui32SwitchTimeDiff += m_ui32TimeDiff;
if((m_ui32SwitchTimeDiff > g_ui32TimeAutoSwitch) || PVRShellIsKeyPressed(PVRShellKeyNameACTION1))
{
m_ui32SwitchTimeDiff = 0;
++m_i32Page;
if(m_i32Page >= (int) m_ui32PageNo)
m_i32Page = 0;
}
PVRTVec3 From;
float fFactor;
From.x = g_fViewDistance * PVRTSIN(m_fViewAngle);
From.y = 0.0f;
From.z = g_fViewDistance * PVRTCOS(m_fViewAngle);
// Increase the rotation
fFactor = 0.005f * (float) m_ui32TimeDiff;
m_fViewAngle += fFactor;
// Ensure it doesn't grow huge and lose accuracy over time
while(m_fViewAngle > PVRT_PI)
m_fViewAngle -= PVRT_TWO_PI;
// Compute and set the matrix
m_mView = PVRTMat4::LookAtRH(From, PVRTVec3(0,0,0), PVRTVec3(0,1,0));
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(m_mView.f);
// Setup the lighting
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
PVRTVec4 vLightDir(From.x, From.y, From.z, 0);
vLightDir = vLightDir.normalize();
// Set the light direction
glLightfv(GL_LIGHT0, GL_POSITION, vLightDir.ptr());
glLightfv(GL_LIGHT0, GL_DIFFUSE, PVRTVec4(0.8f,0.8f,0.8f,1.0f).ptr());
// Draw the model
DrawModel(m_i32Page);
// Display the frame rate
CPVRTString title;
const char * pDesc;
title = PVRTStringFromFormattedStr("Optimize Mesh %.1ffps", m_fFPS);
// Print text on screen
switch(m_i32Page)
{
default:
pDesc = "Indexed Tri List: Unoptimized";
break;
case 1:
pDesc = "Indexed Tri List: Optimized (at export time)";
break;
}
m_Print3D.DisplayDefaultTitle(title.c_str(), pDesc, ePVRTPrint3DSDKLogo);
// Flush all Print3D commands
m_Print3D.Flush();
return true;
}
