void touchmind::layout::LayoutManager::Arrange()
{
m_layoutWorkDataMap.clear();
mw_maxLevelHeight.clear();
mw_maxLevelWidth.clear();
mw_previousLevelNode.clear();
mw_rootXOffset = 0.0f;
mw_rootYOffset = 0.0f;
AssignPosition();
_CalculateSize();
PositionTree();
}
void CSpeedTreeWrapper::RenderFronds(void) const
{
m_pSpeedTree->GetGeometry(*m_pGeometryCache, SpeedTree_FrondGeometry);
if (m_pGeometryCache->m_fFrondAlphaTestValue > 0.0f)
{
PositionTree( );
m_pDx->SetRenderState(D3DRS_ALPHAREF, DWORD(m_pGeometryCache->m_fFrondAlphaTestValue));
// if tree has fronds, draw them
if (m_pFrondIndexCounts && m_pGeometryCache->m_sFronds.m_nDiscreteLodLevel > -1 && m_pFrondIndexCounts[m_pGeometryCache->m_sFronds.m_nDiscreteLodLevel] > 0)
m_pDx->DrawIndexedPrimitive(D3DPT_TRIANGLESTRIP, 0, 0, m_pGeometryCache->m_sFronds.m_usVertexCount, 0, m_pFrondIndexCounts[m_pGeometryCache->m_sFronds.m_nDiscreteLodLevel] - 2);
}
}
void CSpeedTreeWrapper::RenderBranches(void) const
{
m_pSpeedTree->GetGeometry(*m_pGeometryCache, SpeedTree_BranchGeometry);
if (m_pGeometryCache->m_fBranchAlphaTestValue > 0.0f)
{
PositionTree( );
// set alpha test value
m_pDx->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
m_pDx->SetRenderState(D3DRS_ALPHAREF, DWORD(m_pGeometryCache->m_fBranchAlphaTestValue));
// if tree has branches at this LOD, draw them
if (m_pBranchIndexCounts && m_pGeometryCache->m_sBranches.m_nDiscreteLodLevel > -1 && m_pBranchIndexCounts[m_pGeometryCache->m_sBranches.m_nDiscreteLodLevel] > 0)
m_pDx->DrawIndexedPrimitive(D3DPT_TRIANGLESTRIP, 0, 0, m_pGeometryCache->m_sBranches.m_usVertexCount, 0, m_pBranchIndexCounts[m_pGeometryCache->m_sBranches.m_nDiscreteLodLevel] - 2);
}
}
void CSpeedTreeWrapper::RenderBillboards(void) const
{
// draw billboards in immediate mode (as close as directx gets to immediate mode)
#ifdef WRAPPER_BILLBOARD_MODE
PositionTree( );
struct SBillboardVertex
{
float fX, fY, fZ;
DWORD dColor;
float fU, fV;
};
m_pSpeedTree->GetGeometry(*m_pGeometryCache, SpeedTree_BillboardGeometry);
if (m_pGeometryCache->m_sBillboard0.m_bIsActive)
{
const float* pCoords = m_pGeometryCache->m_sBillboard0.m_pCoords;
const float* pTexCoords = m_pGeometryCache->m_sBillboard0.m_pTexCoords;
SBillboardVertex sVertex[4] =
{
{ pCoords[0], pCoords[1], pCoords[2], 0xffffff, pTexCoords[0], pTexCoords[1] },
{ pCoords[3], pCoords[4], pCoords[5], 0xffffff, pTexCoords[2], pTexCoords[3] },
{ pCoords[6], pCoords[7], pCoords[8], 0xffffff, pTexCoords[4], pTexCoords[5] },
{ pCoords[9], pCoords[10], pCoords[11], 0xffffff, pTexCoords[6], pTexCoords[7] },
};
m_pDx->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
m_pDx->SetRenderState(D3DRS_ALPHAREF, DWORD(m_pGeometryCache->m_sBillboard0.m_fAlphaTestValue));
m_pDx->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, sVertex, sizeof(SBillboardVertex));
}
// if there is a 360 degree billboard, then we need to draw the second one
if (m_pGeometryCache->m_sBillboard1.m_bIsActive)
{
const float* pCoords = m_pGeometryCache->m_sBillboard1.m_pCoords;
const float* pTexCoords = m_pGeometryCache->m_sBillboard1.m_pTexCoords;
SBillboardVertex sVertex[4] =
{
{ pCoords[0], pCoords[1], pCoords[2], 0xffffff, pTexCoords[0], pTexCoords[1] },
{ pCoords[3], pCoords[4], pCoords[5], 0xffffff, pTexCoords[2], pTexCoords[3] },
{ pCoords[6], pCoords[7], pCoords[8], 0xffffff, pTexCoords[4], pTexCoords[5] },
{ pCoords[9], pCoords[10], pCoords[11], 0xffffff, pTexCoords[6], pTexCoords[7] },
};
m_pDx->SetRenderState(D3DRS_ALPHAREF, DWORD(m_pGeometryCache->m_sBillboard1.m_fAlphaTestValue));
m_pDx->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, sVertex, sizeof(SBillboardVertex));
}
// if we have a horizontal bilboard and it is enabled, draw it too
#ifdef WRAPPER_RENDER_HORIZONTAL_BILLBOARD
if (m_pGeometryCache->m_sHorizontalBillboard.m_bIsActive)
{
const float* pCoords = m_pGeometryCache->m_sHorizontalBillboard.m_pCoords;
const float* pTexCoords = m_pGeometryCache->m_sHorizontalBillboard.m_pTexCoords;
SBillboardVertex sVertex[4] =
{
{ pCoords[0], pCoords[1], pCoords[2], pTexCoords[0], pTexCoords[1] },
{ pCoords[3], pCoords[4], pCoords[5], pTexCoords[2], pTexCoords[3] },
{ pCoords[6], pCoords[7], pCoords[8], pTexCoords[4], pTexCoords[5] },
{ pCoords[9], pCoords[10], pCoords[11], pTexCoords[6], pTexCoords[7] },
};
m_pDx->SetRenderState(D3DRS_ALPHAREF, DWORD(m_pGeometryCache->m_sHorizontalBillboard.m_fAlphaTestValue));
m_pDx->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, sVertex, sizeof(SBillboardVertex));
}
#endif
#endif
}
void CSpeedTreeWrapper::RenderLeaves(void) const
{
#ifdef WRAPPER_USE_GPU_LEAF_PLACEMENT
m_pSpeedTree->GetGeometry(*m_pGeometryCache, SpeedTree_LeafGeometry, -1, -1, 0);
#endif
m_pSpeedTree->GetGeometry(*m_pGeometryCache, SpeedTree_LeafGeometry);
// update the LOD level vertex arrays we need
#if defined(WRAPPER_USE_GPU_LEAF_PLACEMENT) && defined(WRAPPER_USE_GPU_WIND)
// do nothing
#else
#if !defined WRAPPER_USE_NO_WIND || defined WRAPPER_USE_CPU_LEAF_PLACEMENT
// might need to draw 2 LOD's
for (unsigned int i = 0; i < 2; ++i)
{
// reference to leaves structure
const CSpeedTreeRT::SGeometry::SLeaf* pLeaf = (i == 0) ? &m_pGeometryCache->m_sLeaves0 : &m_pGeometryCache->m_sLeaves1;
int unLod = pLeaf->m_nDiscreteLodLevel;
#if defined WRAPPER_USE_GPU_LEAF_PLACEMENT
if (pLeaf->m_bIsActive && !m_pLeavesUpdatedByCpu[unLod])
{
// update the centers
SFVFLeafVertex* pVertex = NULL;
m_pLeafVertexBuffer[unLod]->Lock(0, 0, reinterpret_cast<void**>(&pVertex), 0);
for (unsigned int unLeaf = 0; unLeaf < pLeaf->m_usLeafCount; ++unLeaf)
{
D3DXVECTOR3 vecCenter(&(pLeaf->m_pCenterCoords[unLeaf * 3]));
(pVertex++)->m_vPosition = vecCenter; // vertex 0
(pVertex++)->m_vPosition = vecCenter; // vertex 1
(pVertex++)->m_vPosition = vecCenter; // vertex 2
(pVertex++)->m_vPosition = vecCenter; // vertex 0
(pVertex++)->m_vPosition = vecCenter; // vertex 2
(pVertex++)->m_vPosition = vecCenter; // vertex 3
}
m_pLeafVertexBuffer[unLod]->Unlock( );
m_pLeavesUpdatedByCpu[unLod] = true;
}
#else
if (pLeaf->m_bIsActive)
{
// update the vertices
SFVFLeafVertex* pVertex = NULL;
m_pLeafVertexBuffer[unLod]->Lock(0, 0, reinterpret_cast<void**>(&pVertex),0);
for (unsigned int unLeaf = 0; unLeaf < pLeaf->m_usLeafCount; ++unLeaf)
{
D3DXVECTOR3 vecCenter(&(pLeaf->m_pCenterCoords[unLeaf * 3]));
D3DXVECTOR3 vec0(&pLeaf->m_pLeafMapCoords[unLeaf][0]);
D3DXVECTOR3 vec1(&pLeaf->m_pLeafMapCoords[unLeaf][4]);
D3DXVECTOR3 vec2(&pLeaf->m_pLeafMapCoords[unLeaf][8]);
D3DXVECTOR3 vec3(&pLeaf->m_pLeafMapCoords[unLeaf][12]);
(pVertex++)->m_vPosition = vecCenter + vec0; // vertex 0
(pVertex++)->m_vPosition = vecCenter + vec1; // vertex 1
(pVertex++)->m_vPosition = vecCenter + vec2; // vertex 2
(pVertex++)->m_vPosition = vecCenter + vec0; // vertex 0
(pVertex++)->m_vPosition = vecCenter + vec2; // vertex 2
(pVertex++)->m_vPosition = vecCenter + vec3; // vertex 3
}
m_pLeafVertexBuffer[unLod]->Unlock( );
}
#endif
}
#endif
#endif
PositionTree( );
// might need to draw 2 LOD's
for (unsigned int unLeafLevel = 0; unLeafLevel < 2; ++unLeafLevel)
{
const CSpeedTreeRT::SGeometry::SLeaf* pLeaf = (unLeafLevel == 0) ?
&m_pGeometryCache->m_sLeaves0 : pLeaf = &m_pGeometryCache->m_sLeaves1;
int unLod = pLeaf->m_nDiscreteLodLevel;
// if this LOD is active and has leaves, draw it
if (unLod > -1 && pLeaf->m_bIsActive && pLeaf->m_usLeafCount > 0)
{
m_pDx->SetStreamSource(0, m_pLeafVertexBuffer[unLod], 0, sizeof(SFVFLeafVertex));
m_pDx->SetRenderState(D3DRS_ALPHAREF, DWORD(pLeaf->m_fAlphaTestValue));
m_pDx->DrawPrimitive(D3DPT_TRIANGLELIST, 0, pLeaf->m_usLeafCount * 2);
}
}
}
