OPC_TreeBuilders.cpp

Go to the documentation of this file.

/*
 *      OPCODE - Optimized Collision Detection
 *      Copyright (C) 2001 Pierre Terdiman
 *      Homepage: http://www.codercorner.com/Opcode.htm
 */













// Precompiled Header
#include "Stdafx.h"

using namespace Opcode;



bool AABBTreeOfAABBsBuilder::ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box) const
{
        // Checkings
        if(!primitives || !nb_prims)    return false;

        // Initialize global box
        global_box = mAABBArray[primitives[0]];

        // Loop through boxes
        for(udword i=1;i<nb_prims;i++)
        {
                // Update global box
                global_box.Add(mAABBArray[primitives[i]]);
        }
        return true;
}



float AABBTreeOfAABBsBuilder::GetSplittingValue(udword index, udword axis) const
{
        // For an AABB, the splitting value is the middle of the given axis,
        // i.e. the corresponding component of the center point
        return mAABBArray[index].GetCenter(axis);
}



bool AABBTreeOfTrianglesBuilder::ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box) const
{
        // Checkings
        if(!primitives || !nb_prims)    return false;

        // Initialize global box
        Point Min(MAX_FLOAT, MAX_FLOAT, MAX_FLOAT);
        Point Max(MIN_FLOAT, MIN_FLOAT, MIN_FLOAT);

        // Loop through triangles
        VertexPointers VP;
        while(nb_prims--)
        {
                // Get current triangle-vertices
                mIMesh->GetTriangle(VP, *primitives++);
                // Update global box
                Min.Min(*VP.Vertex[0]).Min(*VP.Vertex[1]).Min(*VP.Vertex[2]);
                Max.Max(*VP.Vertex[0]).Max(*VP.Vertex[1]).Max(*VP.Vertex[2]);
        }
        global_box.SetMinMax(Min, Max);
        return true;
}



float AABBTreeOfTrianglesBuilder::GetSplittingValue(udword index, udword axis) const
{
/*      // Compute center of triangle
        Point Center;
        mTriList[index].Center(mVerts, Center);
        // Return value
        return Center[axis];*/

        // Compute correct component from center of triangle
//      return  (mVerts[mTriList[index].mVRef[0]][axis]
//                      +mVerts[mTriList[index].mVRef[1]][axis]
//                      +mVerts[mTriList[index].mVRef[2]][axis])*INV3;

        VertexPointers VP;
        mIMesh->GetTriangle(VP, index);

        // Compute correct component from center of triangle
        return  ((*VP.Vertex[0])[axis]
                        +(*VP.Vertex[1])[axis]
                        +(*VP.Vertex[2])[axis])*INV3;
}



float AABBTreeOfTrianglesBuilder::GetSplittingValue(const udword* primitives, udword nb_prims, const AABB& global_box, udword axis)     const
{
        if(mSettings.mRules&SPLIT_GEOM_CENTER)
        {
                // Loop through triangles
                float SplitValue = 0.0f;
                VertexPointers VP;
                for(udword i=0;i<nb_prims;i++)
                {
                        // Get current triangle-vertices
                        mIMesh->GetTriangle(VP, primitives[i]);
                        // Update split value
                        SplitValue += (*VP.Vertex[0])[axis];
                        SplitValue += (*VP.Vertex[1])[axis];
                        SplitValue += (*VP.Vertex[2])[axis];
                }
                return SplitValue / float(nb_prims*3);
        }
        else return AABBTreeBuilder::GetSplittingValue(primitives, nb_prims, global_box, axis);
}



bool AABBTreeOfVerticesBuilder::ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box) const
{
        // Checkings
        if(!primitives || !nb_prims)    return false;

        // Initialize global box
        global_box.SetEmpty();

        // Loop through vertices
        for(udword i=0;i<nb_prims;i++)
        {
                // Update global box
                global_box.Extend(mVertexArray[primitives[i]]);
        }
        return true;
}



float AABBTreeOfVerticesBuilder::GetSplittingValue(udword index, udword axis) const
{
        // For a vertex, the splitting value is simply the vertex coordinate.
        return mVertexArray[index][axis];
}



float AABBTreeOfVerticesBuilder::GetSplittingValue(const udword* primitives, udword nb_prims, const AABB& global_box, udword axis)      const
{
        if(mSettings.mRules&SPLIT_GEOM_CENTER)
        {
                // Loop through vertices
                float SplitValue = 0.0f;
                for(udword i=0;i<nb_prims;i++)
                {
                        // Update split value
                        SplitValue += mVertexArray[primitives[i]][axis];
                }
                return SplitValue / float(nb_prims);
        }
        else return AABBTreeBuilder::GetSplittingValue(primitives, nb_prims, global_box, axis);
}