PxBatchQueryDesc.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
 *
 * NVIDIA CORPORATION and its licensors retain all intellectual property
 * and proprietary rights in and to this software, related documentation
 * and any modifications thereto.  Any use, reproduction, disclosure or
 * distribution of this software and related documentation without an express
 * license agreement from NVIDIA CORPORATION is strictly prohibited.
 */
// 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 "PxQueryReport.h"

#ifndef PX_DOXYGEN
namespace physx
{
#endif

struct  PxSweepHit;
struct  PxRaycastHit;

struct PxBatchQueryStatus
{
    enum Enum
    {
        ePENDING = 0,

        eSUCCESS,

        eOVERFLOW
    };
};

template<typename HitType>
struct 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 PxBatchQueryResult<PxRaycastHit>    PxRaycastQueryResult;

typedef PxBatchQueryResult<PxSweepHit>      PxSweepQueryResult;

typedef PxBatchQueryResult<PxOverlapHit>    PxOverlapQueryResult;

struct 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;
};

#define PX_QUERY_SPU_SHADER_LIMIT 2048

class PxBatchQueryDesc
{
public:

    void*                           filterShaderData;

    PxU32                           filterShaderDataSize;

    PxBatchQueryPreFilterShader     preFilterShader;    

    PxBatchQueryPostFilterShader    postFilterShader;   

    void*                           spuPreFilterShader;

    PxU32                           spuPreFilterShaderSize;

    void*                           spuPostFilterShader;

    PxU32                           spuPostFilterShaderSize;

    PxClientID                      ownerClient;

    PxBatchQueryMemory              queryMemory;    

    bool                            runOnSpu;

    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),
    spuPreFilterShader      (NULL),
    spuPreFilterShaderSize  (0),
    spuPostFilterShader     (NULL),
    spuPostFilterShaderSize (0),
    ownerClient             (PX_DEFAULT_CLIENT),
    queryMemory             (maxRaycastsPerExecute, maxSweepsPerExecute, maxOverlapsPerExecute),
    runOnSpu                (true)
{
}


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

#if defined(PX_PS3)

    if ( ((spuPreFilterShaderSize == 0)  && (spuPreFilterShader != NULL))  ||
         ((spuPreFilterShaderSize > 0)   && (spuPreFilterShader == NULL))  ||
         ((spuPostFilterShaderSize == 0) && (spuPostFilterShader != NULL)) ||
         ((spuPostFilterShaderSize > 0)  && (spuPostFilterShader == NULL)) )
         return false;

    if ( ((spuPreFilterShader != NULL)  && (preFilterShader == NULL)) ||
         ((spuPostFilterShader != NULL) && (postFilterShader == NULL)))
         return false;

    if ( ((spuPostFilterShaderSize + spuPreFilterShaderSize)  > 0)  &&
         ((filterShaderDataSize + spuPostFilterShaderSize + spuPreFilterShaderSize) > PX_QUERY_SPU_SHADER_LIMIT) )
         return false;

#endif

    return true;
}

#ifndef PX_DOXYGEN
} // namespace physx
#endif

#endif