PxBatchQueryDesc.h

Go to the documentation of this file.

//
// 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-2018 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 PX_PHYSICS_NX_SCENEQUERYDESC
#define PX_PHYSICS_NX_SCENEQUERYDESC

#include "PxPhysXConfig.h"
#include "PxClient.h"
#include "PxFiltering.h"
#include "PxQueryFiltering.h"
#include "foundation/PxAssert.h"

#if !PX_DOXYGEN
namespace physx
{
#endif

struct  PxSweepHit;
struct  PxRaycastHit;

struct PX_DEPRECATED PxBatchQueryStatus
{
    enum Enum
    {
        ePENDING = 0,

        eSUCCESS,

        eOVERFLOW
    };
};

template<typename HitType>
struct PX_DEPRECATED PxBatchQueryResult
{
    HitType         block;          
    HitType*        touches;        
    PxU32           nbTouches;      
    void*           userData;       
    PxU8            queryStatus;    
    bool            hasBlock;       
    PxU16           pad;            

    PX_INLINE PxU32             getNbAnyHits() const                { return nbTouches + (hasBlock ? 1 : 0); }

    PX_INLINE const HitType&    getAnyHit(const PxU32 index) const  { PX_ASSERT(index < nbTouches + (hasBlock ? 1 : 0));
                                                                        return index < nbTouches ? touches[index] : block; }
};

typedef PX_DEPRECATED PxBatchQueryResult<PxRaycastHit>  PxRaycastQueryResult;

typedef PX_DEPRECATED PxBatchQueryResult<PxSweepHit>        PxSweepQueryResult;

typedef PX_DEPRECATED PxBatchQueryResult<PxOverlapHit>  PxOverlapQueryResult;

struct PX_DEPRECATED PxBatchQueryMemory
 {
    PxRaycastQueryResult*           userRaycastResultBuffer;
 
    PxRaycastHit*                   userRaycastTouchBuffer;
 
    PxSweepQueryResult*             userSweepResultBuffer;
 
    PxSweepHit*                     userSweepTouchBuffer;
 
    PxOverlapQueryResult*           userOverlapResultBuffer;
 
    PxOverlapHit*                   userOverlapTouchBuffer;
 
    PxU32                           raycastTouchBufferSize;
 
    PxU32                           sweepTouchBufferSize;
 
    PxU32                           overlapTouchBufferSize;

    PX_FORCE_INLINE PxU32           getMaxRaycastsPerExecute() const    { return raycastResultBufferSize; }

    PX_FORCE_INLINE PxU32           getMaxSweepsPerExecute() const      { return sweepResultBufferSize; }

    PX_FORCE_INLINE PxU32           getMaxOverlapsPerExecute() const    { return overlapResultBufferSize; }

    PxBatchQueryMemory(PxU32 raycastResultBufferSize_, PxU32 sweepResultBufferSize_, PxU32 overlapResultBufferSize_) :
        userRaycastResultBuffer (NULL),
        userRaycastTouchBuffer  (NULL),
        userSweepResultBuffer   (NULL),
        userSweepTouchBuffer    (NULL),
        userOverlapResultBuffer (NULL),
        userOverlapTouchBuffer  (NULL),
        raycastTouchBufferSize  (0),
        sweepTouchBufferSize    (0),
        overlapTouchBufferSize  (0),
        raycastResultBufferSize (raycastResultBufferSize_),
        sweepResultBufferSize   (sweepResultBufferSize_),
        overlapResultBufferSize (overlapResultBufferSize_)
    {
    }

protected:
    PxU32                           raycastResultBufferSize;
    PxU32                           sweepResultBufferSize;
    PxU32                           overlapResultBufferSize;
};

class PX_DEPRECATED PxBatchQueryDesc
{
public:

    void*                           filterShaderData;

    PxU32                           filterShaderDataSize;

    PxBatchQueryPreFilterShader     preFilterShader;    

    PxBatchQueryPostFilterShader    postFilterShader;   

    PxBatchQueryMemory              queryMemory;    

    PX_INLINE                       PxBatchQueryDesc(PxU32 maxRaycastsPerExecute, PxU32 maxSweepsPerExecute, PxU32 maxOverlapsPerExecute);
    PX_INLINE bool                  isValid() const;
};


PX_INLINE PxBatchQueryDesc::PxBatchQueryDesc(PxU32 maxRaycastsPerExecute, PxU32 maxSweepsPerExecute, PxU32 maxOverlapsPerExecute) :
    filterShaderData        (NULL),
    filterShaderDataSize    (0),
    preFilterShader         (NULL),
    postFilterShader        (NULL),
    queryMemory             (maxRaycastsPerExecute, maxSweepsPerExecute, maxOverlapsPerExecute)
{
}


PX_INLINE bool PxBatchQueryDesc::isValid() const
{ 
    if ( ((filterShaderDataSize == 0) && (filterShaderData != NULL)) ||
         ((filterShaderDataSize > 0) && (filterShaderData == NULL)) )
         return false;

    return true;
}

#if !PX_DOXYGEN
} // namespace physx
#endif

#endif