OPC_TreeBuilders.h

Go to the documentation of this file.

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



// Include Guard
#ifndef __OPC_TREEBUILDERS_H__
#define __OPC_TREEBUILDERS_H__

        enum SplittingRules
        {
                // Primitive split
                SPLIT_LARGEST_AXIS              = (1<<0),               
                SPLIT_SPLATTER_POINTS   = (1<<1),               
                SPLIT_BEST_AXIS                 = (1<<2),               
                SPLIT_BALANCED                  = (1<<3),               
                SPLIT_FIFTY                             = (1<<4),               
                // Node split
                SPLIT_GEOM_CENTER               = (1<<5),               
                //
                SPLIT_FORCE_DWORD               = 0x7fffffff
        };

        struct OPCODE_API BuildSettings
        {
                inline_ BuildSettings() : mLimit(1), mRules(SPLIT_FORCE_DWORD)  {}

                udword  mLimit;         
                udword  mRules;         
        };

        class OPCODE_API AABBTreeBuilder
        {
                public:
                                                                                                        AABBTreeBuilder() :
                                                                                                                mNbPrimitives(0),
                                                                                                                mNodeBase(null),
                                                                                                                mCount(0),
                                                                                                                mNbInvalidSplits(0)             {}
                virtual                                                                         ~AABBTreeBuilder()                      {}


                virtual                                         bool                    ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box)   const   = 0;


                virtual                                         float                   GetSplittingValue(udword index, udword axis)    const   = 0;


                virtual                                         float                   GetSplittingValue(const udword* primitives, udword nb_prims, const AABB& global_box, udword axis)       const
                                                                                                        {
                                                                                                                // Default split value = middle of the axis (using only the box)
                                                                                                                return global_box.GetCenter(axis);
                                                                                                        }


                virtual                                         BOOL                    ValidateSubdivision(const udword* primitives, udword nb_prims, const AABB& global_box)
                                                                                                        {
                                                                                                                // Check the user-defined limit
                                                                                                                if(nb_prims<=mSettings.mLimit)  return FALSE;

                                                                                                                return TRUE;
                                                                                                        }

                                                                        BuildSettings   mSettings;                      
                                                                        udword                  mNbPrimitives;          
                                                                        void*                   mNodeBase;                      
                // Stats
                inline_                                         void                    SetCount(udword nb)                             { mCount=nb;                            }
                inline_                                         void                    IncreaseCount(udword nb)                { mCount+=nb;                           }
                inline_                                         udword                  GetCount()                              const   { return mCount;                        }
                inline_                                         void                    SetNbInvalidSplits(udword nb)   { mNbInvalidSplits=nb;          }
                inline_                                         void                    IncreaseNbInvalidSplits()               { mNbInvalidSplits++;           }
                inline_                                         udword                  GetNbInvalidSplits()    const   { return mNbInvalidSplits;      }

                private:
                                                                        udword                  mCount;                         
                                                                        udword                  mNbInvalidSplits;       
        };

        class OPCODE_API AABBTreeOfVerticesBuilder : public AABBTreeBuilder
        {
                public:
                                                                                                        AABBTreeOfVerticesBuilder() : mVertexArray(null)        {}
                virtual                                                                         ~AABBTreeOfVerticesBuilder()                                            {}

                override(AABBTreeBuilder)       bool                    ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box)   const;
                override(AABBTreeBuilder)       float                   GetSplittingValue(udword index, udword axis)                                                                    const;
                override(AABBTreeBuilder)       float                   GetSplittingValue(const udword* primitives, udword nb_prims, const AABB& global_box, udword axis)       const;

                const                                           Point*                  mVertexArray;           
        };

        class OPCODE_API AABBTreeOfAABBsBuilder : public AABBTreeBuilder
        {
                public:
                                                                                                        AABBTreeOfAABBsBuilder() : mAABBArray(null)     {}
                virtual                                                                         ~AABBTreeOfAABBsBuilder()                                       {}

                override(AABBTreeBuilder)       bool                    ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box)   const;
                override(AABBTreeBuilder)       float                   GetSplittingValue(udword index, udword axis)                                                                    const;

                const                                           AABB*                   mAABBArray;                     
        };

        class OPCODE_API AABBTreeOfTrianglesBuilder : public AABBTreeBuilder
        {
                public:
                                                                                                        AABBTreeOfTrianglesBuilder() : mIMesh(null)                                                                             {}
                virtual                                                                         ~AABBTreeOfTrianglesBuilder()                                                                                                   {}

                override(AABBTreeBuilder)       bool                    ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box)   const;
                override(AABBTreeBuilder)       float                   GetSplittingValue(udword index, udword axis)                                                                    const;
                override(AABBTreeBuilder)       float                   GetSplittingValue(const udword* primitives, udword nb_prims, const AABB& global_box, udword axis)       const;

                const                           MeshInterface*                  mIMesh;                 
        };

#endif // __OPC_TREEBUILDERS_H__