//--------------------------------------------------------------------
// * Go through the asset set and determine the model count in it
// * Create data structures for all the models in the asset set
// * For each model create the axis aligned bounding box triangle
// vertex and index list
//--------------------------------------------------------------------
void AABBoxRasterizerScalar::CreateTransformedAABBoxes(CPUTAssetSet **pAssetSet, UINT numAssetSets)
{
for(UINT assetId = 0; assetId < numAssetSets; assetId++)
{
for(UINT nodeId = 0; nodeId < pAssetSet[assetId]->GetAssetCount(); nodeId++)
{
CPUTRenderNode* pRenderNode = NULL;
CPUTResult result = pAssetSet[assetId]->GetAssetByIndex(nodeId, &pRenderNode);
ASSERT((CPUT_SUCCESS == result), _L ("Failed getting asset by index"));
if(pRenderNode->IsModel())
{
mNumModels++;
}
pRenderNode->Release();
}
}
mpVisible[0] = new bool[mNumModels];
mpVisible[1] = new bool[mNumModels];
mpTransformedAABBox = new TransformedAABBoxScalar[mNumModels];
mpModels = new CPUTModelDX11 *[mNumModels];
mpInsideFrustum[0] = new bool[mNumModels];
mpInsideFrustum[1] = new bool[mNumModels];
mpNumTriangles = new UINT[mNumModels];
for(UINT assetId = 0, modelId = 0; assetId < numAssetSets; assetId++)
{
for(UINT nodeId = 0; nodeId < pAssetSet[assetId]->GetAssetCount(); nodeId++)
{
CPUTRenderNode* pRenderNode = NULL;
CPUTResult result = pAssetSet[assetId]->GetAssetByIndex(nodeId, &pRenderNode);
ASSERT((CPUT_SUCCESS == result), _L ("Failed getting asset by index"));
if(pRenderNode->IsModel())
{
CPUTModelDX11 *pModel = (CPUTModelDX11*)pRenderNode;
pModel = (CPUTModelDX11*)pRenderNode;
mpModels[modelId] = pModel;
pModel->AddRef();
mpTransformedAABBox[modelId].CreateAABBVertexIndexList(pModel);
mpNumTriangles[modelId] = 0;
for(int meshId = 0; meshId < pModel->GetMeshCount(); meshId++)
{
mpNumTriangles[modelId] += pModel->GetMesh(meshId)->GetTriangleCount();
}
modelId++;
}
pRenderNode->Release();
}
}
}
//------------------------------------------------------------------------
// Go through the list of models in the asset set and render only those
// models that are marked as visible by the software occlusion culling test
//-------------------------------------------------------------------------
void AABBoxRasterizerScalar::Render(CPUTAssetSet **pAssetSet,
CPUTRenderParametersDX &renderParams,
UINT numAssetSets,
UINT idx)
{
int count = 0;
int triCount = 0;
CPUTModelDX11::ResetFCullCount();
BoxTestSetupScalar setup;
setup.Init(mViewMatrix[idx], mProjMatrix[idx], viewportMatrix, mpCamera[idx], mOccludeeSizeThreshold);
float4x4 cumulativeMatrix;
for(UINT assetId = 0, modelId = 0; assetId < numAssetSets; assetId++)
{
for(UINT nodeId = 0; nodeId< pAssetSet[assetId]->GetAssetCount(); nodeId++)
{
CPUTRenderNode* pRenderNode = NULL;
CPUTResult result = pAssetSet[assetId]->GetAssetByIndex(nodeId, &pRenderNode);
ASSERT((CPUT_SUCCESS == result), _L ("Failed getting asset by index"));
if(pRenderNode->IsModel())
{
if(!mpTransformedAABBox[modelId].IsTooSmall(setup, cumulativeMatrix))
{
CPUTModelDX11* model = (CPUTModelDX11*)pRenderNode;
ASSERT((model != NULL), _L("model is NULL"));
model = (CPUTModelDX11*)pRenderNode;
model->Render(renderParams);
count++;
triCount += mpNumTriangles[modelId];
}
modelId++;
}
pRenderNode->Release();
}
}
mNumFCullCount = CPUTModelDX11::GetFCullCount();
mNumCulled[idx] = mNumModels - count;
mNumTrisRendered = triCount;
}
//--------------------------------------------------------------------
// * Go through the asset set and determine the model count in it
// * Create data structures for all the models in the asset set
// * For each model create the place holders for the transformed vertices
//--------------------------------------------------------------------
void DepthBufferRasterizerScalar::CreateTransformedModels(CPUTAssetSet **mpAssetSet, UINT numAssetSets)
{
for(UINT assetId = 0; assetId < numAssetSets; assetId++)
{
for(UINT nodeId = 0; nodeId < mpAssetSet[assetId]->GetAssetCount(); nodeId++)
{
CPUTRenderNode* pRenderNode = NULL;
CPUTResult result = mpAssetSet[assetId]->GetAssetByIndex(nodeId, &pRenderNode);
ASSERT((CPUT_SUCCESS == result), _L ("Failed getting asset by index"));
if(pRenderNode->IsModel())
{
mNumModels1++;
}
pRenderNode->Release();
}
}
mpTransformedModels1 = new TransformedModelScalar[mNumModels1];
mpXformedPosOffset1 = new UINT[mNumModels1];
mpStartV1 = new UINT[mNumModels1 + 1];
mpStartT1 = new UINT[mNumModels1 + 1];
mpModelIndexA[0] = new UINT[mNumModels1];
mpModelIndexA[1] = new UINT[mNumModels1];
UINT modelId = 0;
for(UINT assetId = 0; assetId < numAssetSets; assetId++)
{
for(UINT nodeId = 0; nodeId< mpAssetSet[assetId]->GetAssetCount(); nodeId++)
{
CPUTRenderNode* pRenderNode = NULL;
CPUTResult result = mpAssetSet[assetId]->GetAssetByIndex(nodeId, &pRenderNode);
ASSERT((CPUT_SUCCESS == result), _L ("Failed getting asset by index"));
if(pRenderNode->IsModel())
{
CPUTModelDX11* model = (CPUTModelDX11*)pRenderNode;
ASSERT((model != NULL), _L("model is NULL"));
model = (CPUTModelDX11*)pRenderNode;
mpTransformedModels1[modelId].CreateTransformedMeshes(model);
mpXformedPosOffset1[modelId] = mpTransformedModels1[modelId].GetNumVertices();
mpStartV1[modelId] = mNumVertices1;
mNumVertices1 += mpTransformedModels1[modelId].GetNumVertices();
mpStartT1[modelId] = mNumTriangles1;
mNumTriangles1 += mpTransformedModels1[modelId].GetNumTriangles();
modelId++;
}
pRenderNode->Release();
}
}
mpStartV1[modelId] = mNumVertices1;
mpStartT1[modelId] = mNumTriangles1;
//multiply by 4 for x, y, z, w
mpXformedPos[0] = new float[mNumVertices1 * 4];
mpXformedPos[1] = new float[mNumVertices1 * 4];
for(UINT i = 0; i < mNumModels1; i++)
{
mpTransformedModels1[i].SetXformedPos((float4*)&mpXformedPos[0][mpStartV1[i] * 4],
(float4*)&mpXformedPos[1][mpStartV1[i] * 4],
mpStartV1[i]);
}
}