void Build_Bounding_Slabs(BBOX_TREE **Root)
{
long i, iFinite, iInfinite;
BBOX_TREE **Finite, **Infinite;
OBJECT *Object, *Temp;
/* Count frame level and infinite objects. */
Object = Frame.Objects;
numberOfFiniteObjects = numberOfInfiniteObjects = numberOfLightSources = 0;
while (Object != NULL)
{
if (Object->Type & LIGHT_SOURCE_OBJECT)
{
Temp = ((LIGHT_SOURCE *)Object)->Children;
numberOfLightSources++;
}
else
{
Temp = Object;
}
if (Temp != NULL)
{
if (Test_Flag(Temp, INFINITE_FLAG))
{
numberOfInfiniteObjects++;
}
else
{
numberOfFiniteObjects++;
}
}
Object = Object->Sibling;
}
/* If bounding boxes aren't used we can return. */
if (!opts.Use_Slabs ||
!(numberOfFiniteObjects + numberOfInfiniteObjects >= opts.BBox_Threshold) ||
(numberOfFiniteObjects + numberOfInfiniteObjects < 1))
{
opts.Use_Slabs = false;
return;
}
opts.Use_Slabs = true;
/*
* This is a resonable guess at the number of finites needed.
* This array will be reallocated as needed if it isn't.
*/
maxfinitecount = 2 * numberOfFiniteObjects;
/*
* Now allocate an array to hold references to these finites and
* any new composite objects we may generate.
*/
Finite = Infinite = NULL;
if (numberOfFiniteObjects > 0)
{
Finite = (BBOX_TREE **)POV_MALLOC(maxfinitecount*sizeof(BBOX_TREE *), "bounding boxes");
}
/* Create array to hold pointers to infinite objects. */
if (numberOfInfiniteObjects > 0)
{
Infinite = (BBOX_TREE **)POV_MALLOC(numberOfInfiniteObjects*sizeof(BBOX_TREE *), "bounding boxes");
}
/* Init lists. */
for (i = 0; i < numberOfFiniteObjects; i++)
{
Finite[i] = create_bbox_node(0);
}
for (i = 0; i < numberOfInfiniteObjects; i++)
{
Infinite[i] = create_bbox_node(0);
}
/* Set up finite and infinite object lists. */
iFinite = iInfinite = 0;
for (Object = Frame.Objects; Object != NULL; Object = Object->Sibling)
{
if (Object->Type & LIGHT_SOURCE_OBJECT)
{
Temp = ((LIGHT_SOURCE *)Object)->Children;
}
else
{
Temp = Object;
}
if (Temp != NULL)
{
/* Add object to the appropriate list. */
if (Test_Flag(Temp, INFINITE_FLAG))
{
Infinite[iInfinite]->Infinite = true;
Infinite[iInfinite]->BBox = Temp->BBox;
Infinite[iInfinite]->Node = (BBOX_TREE **)Temp;
iInfinite++;
}
else
{
Finite[iFinite]->BBox = Temp->BBox;
Finite[iFinite]->Node = (BBOX_TREE **)Temp;
iFinite++;
}
}
}
/*
* Now build the bounding box tree.
*/
Build_BBox_Tree(Root, numberOfFiniteObjects, Finite, numberOfInfiniteObjects, Infinite);
/* Get rid of the Finite and Infinite arrays and just use Root. */
if (Finite != NULL)
{
POV_FREE(Finite);
}
if (Infinite != NULL)
{
POV_FREE(Infinite);
}
}
void Build_Bounding_Slabs(BBOX_TREE **Root, vector<ObjectPtr>& objects, unsigned int& numberOfFiniteObjects, unsigned int& numberOfInfiniteObjects, unsigned int& numberOfLightSources)
{
ptrdiff_t iFinite, iInfinite;
BBOX_TREE **Finite, **Infinite;
ObjectPtr Temp;
size_t maxfinitecount = 0;
// Count frame level and infinite objects.
numberOfFiniteObjects = numberOfInfiniteObjects = numberOfLightSources = 0;
for(vector<ObjectPtr>::iterator i(objects.begin()); i != objects.end(); i++)
{
if((*i)->Type & LIGHT_SOURCE_OBJECT)
{
if((reinterpret_cast<LightSource *>(*i))->children.size() > 0)
{
Temp = (reinterpret_cast<LightSource *>(*i))->children[0];
numberOfLightSources++;
}
else
Temp = NULL;
}
else
Temp = (*i);
if(Temp != NULL)
{
if(Test_Flag(Temp, INFINITE_FLAG))
numberOfInfiniteObjects++;
else
numberOfFiniteObjects++;
}
}
// If bounding boxes aren't used we can return.
if(numberOfFiniteObjects + numberOfInfiniteObjects < 1)
return;
// This is a resonable guess at the number of finites needed.
// This array will be reallocated as needed if it isn't.
maxfinitecount = 2 * numberOfFiniteObjects;
// Now allocate an array to hold references to these finites and
// any new composite objects we may generate.
Finite = Infinite = NULL;
if(numberOfFiniteObjects > 0)
Finite = new BBOX_TREE* [maxfinitecount];
// Create array to hold pointers to infinite objects.
if(numberOfInfiniteObjects > 0)
Infinite = new BBOX_TREE* [numberOfInfiniteObjects];
// Init lists.
for(int i = 0; i < numberOfFiniteObjects; i++)
Finite[i] = create_bbox_node(0);
for(int i = 0; i < numberOfInfiniteObjects; i++)
Infinite[i] = create_bbox_node(0);
// Set up finite and infinite object lists.
iFinite = iInfinite = 0;
for(vector<ObjectPtr>::iterator i(objects.begin()); i != objects.end(); i++)
{
if((*i)->Type & LIGHT_SOURCE_OBJECT)
{
if((reinterpret_cast<LightSource *>(*i))->children.size() > 0)
Temp = (reinterpret_cast<LightSource *>(*i))->children[0];
else
Temp = NULL;
}
else
Temp = (*i);
if(Temp != NULL)
{
// Add object to the appropriate list.
if(Test_Flag(Temp, INFINITE_FLAG))
{
Infinite[iInfinite]->Infinite = true;
Infinite[iInfinite]->BBox = Temp->BBox;
Infinite[iInfinite]->Node = reinterpret_cast<BBOX_TREE **>(Temp);
iInfinite++;
}
else
{
Finite[iFinite]->BBox = Temp->BBox;
Finite[iFinite]->Node = reinterpret_cast<BBOX_TREE **>(Temp);
iFinite++;
}
}
}
// Now build the bounding box tree.
Build_BBox_Tree(Root, numberOfFiniteObjects, Finite, numberOfInfiniteObjects, Infinite, maxfinitecount);
// Get rid of the Finite and Infinite arrays and just use Root.
if(Finite != NULL)
delete[] Finite;
if(Infinite != NULL)
delete[] Infinite;
}
