GuPruner.h

// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of NVIDIA CORPORATION nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Copyright (c) 2008-2022 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
 
#ifndef GU_PRUNER_H
#define GU_PRUNER_H
 
#include "foundation/PxUserAllocated.h"
#include "foundation/PxTransform.h"
#include "GuPrunerPayload.h"
#include "GuPrunerTypedef.h"
 
namespace physx
{
    class PxRenderOutput;
    class PxBounds3;
 
namespace Gu
{
    class ShapeData;
 
    struct PrunerRaycastCallback
    {
                        PrunerRaycastCallback()     {}
        virtual         ~PrunerRaycastCallback()    {}
 
        virtual bool    invoke(PxReal& distance, PxU32 primIndex, const PrunerPayload* payloads, const PxTransform* transforms) = 0;
    };
 
    struct PrunerOverlapCallback
    {
                        PrunerOverlapCallback()     {}
        virtual         ~PrunerOverlapCallback()    {}
 
        virtual bool    invoke(PxU32 primIndex, const PrunerPayload* payloads, const PxTransform* transforms) = 0;
    };
 
    class BasePruner : public PxUserAllocated
    {
        public:
                                        BasePruner()    {}
        virtual                         ~BasePruner()   {}
 
        // shift the origin of the pruner objects
        virtual void                    shiftOrigin(const PxVec3& shift) = 0;
 
        // additional 'internal' interface      
        virtual void                    visualize(PxRenderOutput&, PxU32, PxU32) const {}
    };
 
    class Pruner : public BasePruner
    {
        public:
                                        Pruner()    {}
        virtual                         ~Pruner()   {}
 
        virtual bool                    addObjects(PrunerHandle* results, const PxBounds3* bounds, const PrunerPayload* data, const PxTransform* transforms, PxU32 count, bool hasPruningStructure) = 0;
 
        virtual void                    removeObjects(const PrunerHandle* handles, PxU32 count, PrunerPayloadRemovalCallback* removalCallback) = 0;
 
        virtual void                    updateObjects(const PrunerHandle* handles, PxU32 count, float inflation=0.0f, const PxU32* boundsIndices=NULL, const PxBounds3* newBounds=NULL, const PxTransform32* newTransforms=NULL) = 0;
 
        virtual void                    purge() = 0;
 
        virtual void                    commit() = 0;
 
        virtual void                    merge(const void* mergeParams) = 0;
 
        virtual bool                    raycast(const PxVec3& origin, const PxVec3& unitDir, PxReal& inOutDistance, PrunerRaycastCallback&) const = 0;
        virtual bool                    overlap(const Gu::ShapeData& queryVolume, PrunerOverlapCallback&) const = 0;
        virtual bool                    sweep(const Gu::ShapeData& queryVolume, const PxVec3& unitDir, PxReal& inOutDistance, PrunerRaycastCallback&) const = 0;
 
        virtual const PrunerPayload&    getPayloadData(PrunerHandle handle, PrunerPayloadData* data=NULL) const = 0;
 
        virtual void                    preallocate(PxU32 nbEntries) = 0;
 
        virtual bool                    setTransform(PrunerHandle handle, const PxTransform& transform)      = 0;
 
        // PT: from the SQ branch, maybe temporary, unclear if a getType() function would be better etc
        virtual bool                    isDynamic() const   { return false; }
 
        virtual void                    getGlobalBounds(PxBounds3&) const   = 0;
    };
 
    class DynamicPruner : public Pruner
    {
        public:
 
        virtual void                    setRebuildRateHint(PxU32 nbStepsForRebuild) = 0;    
 
        virtual bool                    buildStep(bool synchronousCall = true) = 0;
 
        virtual bool                    prepareBuild() = 0; 
    };
}
}
 
#endif