// Create a bounding box hierarchy from a given list of finite and
// infinite elements. Each element consists of
//
// - an infinite flag
// - a bounding box enclosing the element
// - a pointer to the structure representing the element (e.g an object)
void Build_BBox_Tree(BBOX_TREE **Root, size_t numOfFiniteObjects, BBOX_TREE **&Finite, size_t numOfInfiniteObjects, BBOX_TREE **Infinite, size_t& maxfinitecount)
{
ptrdiff_t low, high;
BBOX_TREE *cd, *root;
// This is a resonable guess at the number of finites needed.
// This array will be reallocated as needed if it isn't.
maxfinitecount = 2 * numOfFiniteObjects;
// Now do a sort on the objects, with the end result being
// a tree of objects sorted along the x, y, and z axes.
if(numOfFiniteObjects > 0)
{
low = 0;
high = numOfFiniteObjects;
while(sort_and_split(Root, Finite, &numOfFiniteObjects, low, high, maxfinitecount) == 0)
{
low = high;
high = numOfFiniteObjects;
}
// Move infinite objects in the first leaf of Root.
if(numOfInfiniteObjects > 0)
{
root = *Root;
root->Node = reinterpret_cast<BBOX_TREE **>(POV_REALLOC(root->Node, (root->Entries + 1) * sizeof(BBOX_TREE *), "composite"));
POV_MEMMOVE(&(root->Node[1]), &(root->Node[0]), root->Entries * sizeof(BBOX_TREE *));
root->Entries++;
cd = create_bbox_node(numOfInfiniteObjects);
for(size_t i = 0; i < numOfInfiniteObjects; i++)
cd->Node[i] = Infinite[i];
calc_bbox(&(cd->BBox), Infinite, 0, numOfInfiniteObjects);
root->Node[0] = cd;
calc_bbox(&(root->BBox), root->Node, 0, root->Entries);
// Root and first node are infinite.
root->Infinite = true;
root->Node[0]->Infinite = true;
}
}
else
{
// There are no finite objects and no Root was created.
// Create it now and put all infinite objects into it.
if(numOfInfiniteObjects > 0)
{
cd = create_bbox_node(numOfInfiniteObjects);
for(size_t i = 0; i < numOfInfiniteObjects; i++)
cd->Node[i] = Infinite[i];
calc_bbox(&(cd->BBox), Infinite, 0, numOfInfiniteObjects);
*Root = cd;
(*Root)->Infinite = true;
}
}
}
static void insert_hit(BCYL_INT *element, BCYL_INT *intervals, int *cnt)
{
int k;
intervals[*cnt] = *element;
for (k = 0; element->d[0] > intervals[k].d[0]; k++);
if (k < *cnt)
{
POV_MEMMOVE(&intervals[k+1], &intervals[k], (*cnt-k)*sizeof(BCYL_INT));
intervals[k] = *element;
}
(*cnt)++;
}
UCS2 *Parser::Parse_String(bool pathname, bool require)
{
UCS2 *New = NULL;
int len = 0;
EXPECT
CASE(STRING_LITERAL_TOKEN)
New = String_To_UCS2(Token.Token_String, pathname);
EXIT
END_CASE
CASE(STR_TOKEN)
New = Parse_Str(pathname);
EXIT
END_CASE
CASE(VSTR_TOKEN)
New = Parse_VStr(pathname);
EXIT
END_CASE
CASE(CONCAT_TOKEN)
New = Parse_Concat(pathname);
EXIT
END_CASE
CASE(CHR_TOKEN)
New = Parse_Chr(pathname);
EXIT
END_CASE
CASE(DATETIME_TOKEN)
New = Parse_Datetime(pathname);
EXIT
END_CASE
CASE(SUBSTR_TOKEN)
New = Parse_Substr(pathname);
EXIT
END_CASE
CASE(STRUPR_TOKEN)
New = Parse_Strupr(pathname);
EXIT
END_CASE
CASE(STRLWR_TOKEN)
New = Parse_Strlwr(pathname);
EXIT
END_CASE
CASE(STRING_ID_TOKEN)
len = UCS2_strlen(reinterpret_cast<UCS2 *>(Token.Data)) + 1;
New = reinterpret_cast<UCS2 *>(POV_MALLOC(len * sizeof(UCS2), "UCS2 String"));
POV_MEMMOVE(reinterpret_cast<void *>(New), reinterpret_cast<void *>(Token.Data), len * sizeof(UCS2));
EXIT
END_CASE
OTHERWISE
if(require)
Expectation_Error("string expression");
else
{
UNGET
EXIT
}
END_CASE
END_EXPECT
return New;
}
void Build_BBox_Tree(BBOX_TREE **Root, long numOfFiniteObjects, BBOX_TREE **&Finite, long numOfInfiniteObjects, BBOX_TREE **Infinite)
{
short i;
long low, high;
BBOX_TREE *cd, *root;
/*
* This is a resonable guess at the number of finites needed.
* This array will be reallocated as needed if it isn't.
*/
maxfinitecount = 2 * numOfFiniteObjects;
/*
* Now do a sort on the objects, with the end result being
* a tree of objects sorted along the x, y, and z axes.
*/
if (numOfFiniteObjects > 0)
{
low = 0;
high = numOfFiniteObjects;
while (sort_and_split(Root, Finite, &numOfFiniteObjects, low, high) == 0)
{
low = high;
high = numOfFiniteObjects;
Do_Cooperate(0);
}
/* Move infinite objects in the first leaf of Root. */
if (numOfInfiniteObjects > 0)
{
root = (BBOX_TREE *)(*Root);
root->Node = (BBOX_TREE **)POV_REALLOC(root->Node, (root->Entries + 1) * sizeof(BBOX_TREE *), "composite");
POV_MEMMOVE(&(root->Node[1]), &(root->Node[0]), root->Entries * sizeof(BBOX_TREE *));
root->Entries++;
cd = create_bbox_node(numOfInfiniteObjects);
for (i = 0; i < numOfInfiniteObjects; i++)
{
cd->Node[i] = Infinite[i];
}
calc_bbox(&(cd->BBox), Infinite, 0, numOfInfiniteObjects);
root->Node[0] = (BBOX_TREE *)cd;
calc_bbox(&(root->BBox), root->Node, 0, root->Entries);
/* Root and first node are infinite. */
root->Infinite = true;
root->Node[0]->Infinite = true;
}
}
else
{
/*
* There are no finite objects and no Root was created.
* Create it now and put all infinite objects into it.
*/
if (numOfInfiniteObjects > 0)
{
cd = create_bbox_node(numOfInfiniteObjects);
for (i = 0; i < numOfInfiniteObjects; i++)
{
cd->Node[i] = Infinite[i];
}
calc_bbox(&(cd->BBox), Infinite, 0, numOfInfiniteObjects);
*Root = (BBOX_TREE *)cd;
(*Root)->Infinite = true;
}
}
}
