file_path
stringlengths 21
202
| content
stringlengths 13
1.02M
| size
int64 13
1.02M
| lang
stringclasses 9
values | avg_line_length
float64 5.43
98.5
| max_line_length
int64 12
993
| alphanum_fraction
float64 0.27
0.91
|
|---|---|---|---|---|---|---|
NVIDIA-Omniverse/PhysX/physx/source/physxextensions/src/serialization/Xml/SnXmlSerializer.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-2023 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 SN_XML_SERIALIZER_H
#define SN_XML_SERIALIZER_H
#include "PxExtensionMetaDataObjects.h"
#include "SnXmlVisitorWriter.h"
namespace physx {
namespace Sn {
void writeHeightFieldSample( PxOutputStream& inStream, const PxHeightFieldSample& inSample )
{
PxU32 retval = 0;
PxU8* writePtr( reinterpret_cast< PxU8*>( &retval ) );
const PxU8* inPtr( reinterpret_cast<const PxU8*>( &inSample ) );
if ( isBigEndian() )
{
//Height field samples are a
//16 bit integer followed by two bytes.
//right now, data is 2 1 3 4
//We need a 32 bit integer that
//when read in by a LE system is 4 3 2 1.
//Thus, we need a BE integer that looks like:
//4 3 2 1
writePtr[0] = inPtr[3];
writePtr[1] = inPtr[2];
writePtr[2] = inPtr[0];
writePtr[3] = inPtr[1];
}
else
{
writePtr[0] = inPtr[0];
writePtr[1] = inPtr[1];
writePtr[2] = inPtr[2];
writePtr[3] = inPtr[3];
}
inStream << retval;
}
template<typename TDataType, typename TWriteOperator>
inline void writeStridedBufferProperty( XmlWriter& writer, MemoryBuffer& tempBuffer, const char* inPropName, const void* inData, PxU32 inStride, PxU32 inCount, PxU32 inItemsPerLine, TWriteOperator inOperator )
{
PX_ASSERT( inStride == 0 || inStride == sizeof( TDataType ) );
PX_UNUSED( inStride );
writeBuffer( writer, tempBuffer
, inItemsPerLine, reinterpret_cast<const TDataType*>( inData )
, inCount, inPropName, inOperator );
}
template<typename TDataType, typename TWriteOperator>
inline void writeStridedBufferProperty( XmlWriter& writer, MemoryBuffer& tempBuffer, const char* inPropName, const PxStridedData& inData, PxU32 inCount, PxU32 inItemsPerLine, TWriteOperator inOperator )
{
writeStridedBufferProperty<TDataType>( writer, tempBuffer, inPropName, inData.data, inData.stride, inCount, inItemsPerLine, inOperator );
}
template<typename TDataType, typename TWriteOperator>
inline void writeStridedBufferProperty( XmlWriter& writer, MemoryBuffer& tempBuffer, const char* inPropName, const PxTypedStridedData<TDataType>& inData, PxU32 inCount, PxU32 inItemsPerLine, TWriteOperator inOperator )
{
writeStridedBufferProperty<TDataType>( writer, tempBuffer, inPropName, inData.data, inData.stride, inCount, inItemsPerLine, inOperator );
}
template<typename TDataType, typename TWriteOperator>
inline void writeStridedBufferProperty( XmlWriter& writer, MemoryBuffer& tempBuffer, const char* inPropName, const PxBoundedData& inData, PxU32 inItemsPerLine, TWriteOperator inWriteOperator )
{
writeStridedBufferProperty<TDataType>( writer, tempBuffer, inPropName, inData, inData.count, inItemsPerLine, inWriteOperator );
}
template<typename TDataType, typename TWriteOperator>
inline void writeStridedBufferProperty( XmlWriter& writer, MemoryBuffer& tempBuffer, const char* inPropName, PxStrideIterator<const TDataType>& inData, PxU32 inCount, PxU32 inItemsPerLine, TWriteOperator inWriteOperator )
{
writeStrideBuffer<TDataType>(writer, tempBuffer
, inItemsPerLine, inData, PtrAccess<TDataType>
, inCount, inPropName, inData.stride(), inWriteOperator );
}
template<typename TDataType>
inline void writeStridedFlagsProperty( XmlWriter& writer, MemoryBuffer& tempBuffer, const char* inPropName, PxStrideIterator<const TDataType>& inData, PxU32 inCount, PxU32 inItemsPerLine, const PxU32ToName* inTable )
{
writeStrideFlags<TDataType>(writer, tempBuffer
, inItemsPerLine, inData, PtrAccess<TDataType>
, inCount, inPropName, inTable );
}
}
}
#endif
| 5,229 | C | 43.322034 | 222 | 0.757889 |
NVIDIA-Omniverse/PhysX/physx/source/physxextensions/src/serialization/Xml/SnRepXCollection.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-2023 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 SN_REPX_COLLECTION_H
#define SN_REPX_COLLECTION_H
#include "common/PxTolerancesScale.h"
#include "extensions/PxRepXSerializer.h"
namespace physx { namespace Sn {
struct XmlNode;
struct RepXCollectionItem
{
PxRepXObject liveObject;
XmlNode* descriptor;
RepXCollectionItem( PxRepXObject inItem = PxRepXObject(), XmlNode* inDescriptor = NULL )
: liveObject( inItem )
, descriptor( inDescriptor )
{
}
};
struct RepXDefaultEntry
{
const char* name;
const char* value;
RepXDefaultEntry( const char* pn, const char* val ) : name( pn ), value( val ){}
};
/**
* The result of adding an object to the collection.
*/
struct RepXAddToCollectionResult
{
enum Enum
{
Success,
SerializerNotFound,
InvalidParameters, //Null data passed in.
AlreadyInCollection
};
PxSerialObjectId collectionId;
Enum result;
RepXAddToCollectionResult( Enum inResult = Success, const PxSerialObjectId inId = 0 )
: collectionId( inId )
, result( inResult )
{
}
bool isValid() { return result == Success && collectionId != 0; }
};
/**
* A RepX collection contains a set of static data objects that can be transformed
* into live objects. It uses RepX serializer to do two transformations:
* live object <-> collection object (descriptor)
* collection object <-> file system.
*
* A live object is considered to be something live in the physics
* world such as a material or a rigidstatic.
*
* A collection object is a piece of data from which a live object
* of identical characteristics can be created.
*
* Clients need to pass PxCollection so that objects can resolve
* references. In addition, objects must be added in an order such that
* references can be resolved in the first place. So objects must be added
* to the collection *after* objects they are dependent upon.
*
* When deserializing from a file, the collection will allocate char*'s that will
* not be freed when the collection itself is freed. The user must be responsible
* for these character allocations.
*/
class RepXCollection
{
protected:
virtual ~RepXCollection(){}
public:
virtual void destroy() = 0;
/**
* Set the scale on this collection. The scale is saved with the collection.
*
* If the scale wasn't set, it will be invalid.
*/
virtual void setTolerancesScale( const PxTolerancesScale& inScale ) = 0;
/**
* Get the scale that was set at collection creation time or at load time.
* If this is a loaded file and the source data does not contain a scale
* this value will be invalid (PxTolerancesScale::isValid()).
*/
virtual PxTolerancesScale getTolerancesScale() const = 0;
/**
* Set the up vector on this collection. The up vector is saved with the collection.
*
* If the up vector wasn't set, it will be (0,0,0).
*/
virtual void setUpVector( const PxVec3& inUpVector ) = 0;
/**
* If the up vector wasn't set, it will be (0,0,0). Else this will be the up vector
* optionally set when the collection was created.
*/
virtual PxVec3 getUpVector() const = 0;
virtual const char* getVersion() = 0;
static const char* getLatestVersion();
//Necessary accessor functions for translation/upgrading.
virtual const RepXCollectionItem* begin() const = 0;
virtual const RepXCollectionItem* end() const = 0;
//Performs a deep copy of the repx node.
virtual XmlNode* copyRepXNode( const XmlNode* srcNode ) = 0;
virtual void addCollectionItem( RepXCollectionItem inItem ) = 0;
//Create a new repx node with this name. Its value is unset.
virtual XmlNode& createRepXNode( const char* name ) = 0;
virtual RepXCollection& createCollection( const char* inVersionStr ) = 0;
//Release this when finished.
virtual XmlReaderWriter& createNodeEditor() = 0;
virtual PxAllocatorCallback& getAllocator() = 0;
virtual bool instantiateCollection( PxRepXInstantiationArgs& inArgs, PxCollection& inPxCollection ) = 0;
virtual RepXAddToCollectionResult addRepXObjectToCollection( const PxRepXObject& inObject, PxCollection* inCollection, PxRepXInstantiationArgs& inArgs ) = 0;
/**
* Save this collection out to a file stream. Uses the RepX serialize to perform
* collection object->file conversions.
*
* /param[in] inStream Write-only stream to save collection out to.
*/
virtual void save( PxOutputStream& inStream ) = 0;
};
} }
#endif
| 6,101 | C | 34.068965 | 159 | 0.731519 |
NVIDIA-Omniverse/PhysX/physx/source/physxextensions/src/serialization/Xml/SnPxStreamOperators.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-2023 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 SN_PX_STREAM_OPERATORS_H
#define SN_PX_STREAM_OPERATORS_H
#include "foundation/PxVec3.h"
#include "foundation/PxTransform.h"
#include "foundation/PxBounds3.h"
#include "foundation/PxString.h"
#include "PxFiltering.h"
namespace physx
{
static inline PxU32 strLenght( const char* inStr )
{
return inStr ? PxU32(strlen(inStr)) : 0;
}
}
namespace physx // ADL requires we put the operators in the same namespace as the underlying type of PxOutputStream
{
inline PxOutputStream& operator << ( PxOutputStream& ioStream, const char* inString )
{
if ( inString && *inString )
{
ioStream.write( inString, PxU32(strlen(inString)) );
}
return ioStream;
}
template<typename TDataType>
inline PxOutputStream& toStream( PxOutputStream& ioStream, const char* inFormat, const TDataType inData )
{
char buffer[128] = { 0 };
Pxsnprintf( buffer, 128, inFormat, inData );
ioStream << buffer;
return ioStream;
}
struct endl_obj {};
//static endl_obj endl;
inline PxOutputStream& operator << ( PxOutputStream& ioStream, bool inData ) { ioStream << (inData ? "true" : "false"); return ioStream; }
inline PxOutputStream& operator << ( PxOutputStream& ioStream, PxI32 inData ) { return toStream( ioStream, "%d", inData ); }
inline PxOutputStream& operator << ( PxOutputStream& ioStream, PxU16 inData ) { return toStream( ioStream, "%u", PxU32(inData) ); }
inline PxOutputStream& operator << ( PxOutputStream& ioStream, PxU8 inData ) { return toStream( ioStream, "%u", PxU32(inData) ); }
inline PxOutputStream& operator << ( PxOutputStream& ioStream, char inData ) { return toStream( ioStream, "%c", inData ); }
inline PxOutputStream& operator << ( PxOutputStream& ioStream, PxU32 inData ) { return toStream( ioStream, "%u", inData ); }
inline PxOutputStream& operator << ( PxOutputStream& ioStream, PxU64 inData ) { return toStream( ioStream, "%" PX_PRIu64, inData ); }
inline PxOutputStream& operator << ( PxOutputStream& ioStream, const void* inData ) { return ioStream << static_cast<uint64_t>(size_t(inData)); }
inline PxOutputStream& operator << ( PxOutputStream& ioStream, PxF32 inData ) { return toStream( ioStream, "%g", PxF64(inData) ); }
inline PxOutputStream& operator << ( PxOutputStream& ioStream, PxF64 inData ) { return toStream( ioStream, "%g", inData ); }
inline PxOutputStream& operator << ( PxOutputStream& ioStream, endl_obj) { return ioStream << "\n"; }
inline PxOutputStream& operator << ( PxOutputStream& ioStream, const PxVec3& inData )
{
ioStream << inData[0];
ioStream << " ";
ioStream << inData[1];
ioStream << " ";
ioStream << inData[2];
return ioStream;
}
inline PxOutputStream& operator << ( PxOutputStream& ioStream, const PxQuat& inData )
{
ioStream << inData.x;
ioStream << " ";
ioStream << inData.y;
ioStream << " ";
ioStream << inData.z;
ioStream << " ";
ioStream << inData.w;
return ioStream;
}
inline PxOutputStream& operator << ( PxOutputStream& ioStream, const PxTransform& inData )
{
ioStream << inData.q;
ioStream << " ";
ioStream << inData.p;
return ioStream;
}
inline PxOutputStream& operator << ( PxOutputStream& ioStream, const PxBounds3& inData )
{
ioStream << inData.minimum;
ioStream << " ";
ioStream << inData.maximum;
return ioStream;
}
inline PxOutputStream& operator << ( PxOutputStream& ioStream, const PxFilterData& inData )
{
ioStream << inData.word0 << " " << inData.word1 << " " << inData.word2 << " " << inData.word3;
return ioStream;
}
inline PxOutputStream& operator << ( PxOutputStream& ioStream, struct PxMetaDataPlane& inData )
{
ioStream << inData.normal;
ioStream << " ";
ioStream << inData.distance;
return ioStream;
}
}
#endif
| 5,411 | C | 39.088889 | 146 | 0.716503 |
NVIDIA-Omniverse/PhysX/physx/source/physxextensions/src/serialization/Xml/SnJointRepXSerializer.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "PxMetaDataObjects.h"
#include "PxExtensionMetaDataObjects.h"
#include "ExtJointMetaDataExtensions.h"
#include "SnJointRepXSerializer.h"
namespace physx {
template<typename TJointType>
inline TJointType* createJoint( PxPhysics& physics,
PxRigidActor* actor0, const PxTransform& localFrame0,
PxRigidActor* actor1, const PxTransform& localFrame1 )
{
PX_UNUSED(physics);
PX_UNUSED(actor0);
PX_UNUSED(actor1);
PX_UNUSED(localFrame0);
PX_UNUSED(localFrame1);
return NULL;
}
template<>
inline PxD6Joint* createJoint<PxD6Joint>(PxPhysics& physics,
PxRigidActor* actor0, const PxTransform& localFrame0,
PxRigidActor* actor1, const PxTransform& localFrame1)
{
return PxD6JointCreate( physics, actor0, localFrame0, actor1, localFrame1 );
}
template<>
inline PxDistanceJoint* createJoint<PxDistanceJoint>(PxPhysics& physics,
PxRigidActor* actor0, const PxTransform& localFrame0,
PxRigidActor* actor1, const PxTransform& localFrame1)
{
return PxDistanceJointCreate( physics, actor0, localFrame0, actor1, localFrame1 );
}
template<>
inline PxContactJoint* createJoint<PxContactJoint>(PxPhysics& physics,
PxRigidActor* actor0, const PxTransform& localFrame0,
PxRigidActor* actor1, const PxTransform& localFrame1)
{
return PxContactJointCreate( physics, actor0, localFrame0, actor1, localFrame1 );
}
template<>
inline PxFixedJoint* createJoint<PxFixedJoint>(PxPhysics& physics,
PxRigidActor* actor0, const PxTransform& localFrame0,
PxRigidActor* actor1, const PxTransform& localFrame1)
{
return PxFixedJointCreate( physics, actor0, localFrame0, actor1, localFrame1 );
}
template<>
inline PxPrismaticJoint* createJoint<PxPrismaticJoint>(PxPhysics& physics,
PxRigidActor* actor0, const PxTransform& localFrame0,
PxRigidActor* actor1, const PxTransform& localFrame1)
{
return PxPrismaticJointCreate( physics, actor0, localFrame0, actor1, localFrame1 );
}
template<>
inline PxRevoluteJoint* createJoint<PxRevoluteJoint>(PxPhysics& physics,
PxRigidActor* actor0, const PxTransform& localFrame0,
PxRigidActor* actor1, const PxTransform& localFrame1)
{
return PxRevoluteJointCreate( physics, actor0, localFrame0, actor1, localFrame1 );
}
template<>
inline PxSphericalJoint* createJoint<PxSphericalJoint>(PxPhysics& physics,
PxRigidActor* actor0, const PxTransform& localFrame0,
PxRigidActor* actor1, const PxTransform& localFrame1)
{
return PxSphericalJointCreate( physics, actor0, localFrame0, actor1, localFrame1 );
}
template<typename TJointType>
PxRepXObject PxJointRepXSerializer<TJointType>::fileToObject( XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* inCollection )
{
PxRigidActor* actor0 = NULL;
PxRigidActor* actor1 = NULL;
PxTransform localPose0 = PxTransform(PxIdentity);
PxTransform localPose1 = PxTransform(PxIdentity);
bool ok = true;
if ( inReader.gotoChild( "Actors" ) )
{
ok = readReference<PxRigidActor>( inReader, *inCollection, "actor0", actor0 );
ok &= readReference<PxRigidActor>( inReader, *inCollection, "actor1", actor1 );
inReader.leaveChild();
}
TJointType* theJoint = !ok ? NULL : createJoint<TJointType>( inArgs.physics, actor0, localPose0, actor1, localPose1 );
if ( theJoint )
{
PxConstraint* constraint = theJoint->getConstraint();
PX_ASSERT( constraint );
inCollection->add( *constraint );
this->fileToObjectImpl( theJoint, inReader, inAllocator, inArgs, inCollection );
}
return PxCreateRepXObject(theJoint);
}
template<typename TJointType>
void PxJointRepXSerializer<TJointType>::objectToFileImpl( const TJointType* inObj, PxCollection* inCollection, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& )
{
writeAllProperties( inObj, inWriter, inTempBuffer, *inCollection );
}
// explicit template instantiations
template struct PxJointRepXSerializer<PxFixedJoint>;
template struct PxJointRepXSerializer<PxDistanceJoint>;
template struct PxJointRepXSerializer<PxContactJoint>;
template struct PxJointRepXSerializer<PxD6Joint>;
template struct PxJointRepXSerializer<PxPrismaticJoint>;
template struct PxJointRepXSerializer<PxRevoluteJoint>;
template struct PxJointRepXSerializer<PxSphericalJoint>;
}
| 6,185 | C++ | 41.662069 | 190 | 0.750202 |
NVIDIA-Omniverse/PhysX/physx/source/physxextensions/src/serialization/Xml/SnSimpleXmlWriter.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-2023 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 SN_SIMPLE_XML_WRITER_H
#define SN_SIMPLE_XML_WRITER_H
#include "foundation/PxArray.h"
#include "SnXmlMemoryPoolStreams.h"
namespace physx { namespace Sn {
class SimpleXmlWriter
{
public:
struct STagWatcher
{
typedef SimpleXmlWriter TXmlWriterType;
TXmlWriterType& mWriter;
STagWatcher( const STagWatcher& inOther );
STagWatcher& operator-( const STagWatcher& inOther );
STagWatcher( TXmlWriterType& inWriter, const char* inTagName )
: mWriter( inWriter )
{
mWriter.beginTag( inTagName );
}
~STagWatcher() { mWriter.endTag(); }
protected:
STagWatcher& operator=(const STagWatcher&);
};
virtual ~SimpleXmlWriter(){}
virtual void beginTag( const char* inTagname ) = 0;
virtual void endTag() = 0;
virtual void addAttribute( const char* inName, const char* inValue ) = 0;
virtual void writeContentTag( const char* inTag, const char* inContent ) = 0;
virtual void addContent( const char* inContent ) = 0;
virtual PxU32 tabCount() = 0;
private:
SimpleXmlWriter& operator=(const SimpleXmlWriter&);
};
template<typename TStreamType>
class SimpleXmlWriterImpl : public SimpleXmlWriter
{
PxProfileAllocatorWrapper mWrapper;
TStreamType& mStream;
SimpleXmlWriterImpl( const SimpleXmlWriterImpl& inOther );
SimpleXmlWriterImpl& operator=( const SimpleXmlWriterImpl& inOther );
PxProfileArray<const char*> mTags;
bool mTagOpen;
PxU32 mInitialTagDepth;
public:
SimpleXmlWriterImpl( TStreamType& inStream, PxAllocatorCallback& inAllocator, PxU32 inInitialTagDepth = 0 )
: mWrapper( inAllocator )
, mStream( inStream )
, mTags( mWrapper )
, mTagOpen( false )
, mInitialTagDepth( inInitialTagDepth )
{
}
virtual ~SimpleXmlWriterImpl()
{
while( mTags.size() )
endTag();
}
PxU32 tabCount() { return mTags.size() + mInitialTagDepth; }
void writeTabs( PxU32 inSize )
{
inSize += mInitialTagDepth;
for ( PxU32 idx =0; idx < inSize; ++idx )
mStream << "\t";
}
void beginTag( const char* inTagname )
{
closeTag();
writeTabs(mTags.size());
mTags.pushBack( inTagname );
mStream << "<" << inTagname;
mTagOpen = true;
}
void addAttribute( const char* inName, const char* inValue )
{
PX_ASSERT( mTagOpen );
mStream << " " << inName << "=" << "\"" << inValue << "\"";
}
void closeTag(bool useNewline = true)
{
if ( mTagOpen )
{
mStream << " " << ">";
if (useNewline )
mStream << "\n";
}
mTagOpen = false;
}
void doEndOpenTag()
{
mStream << "</" << mTags.back() << ">" << "\n";
}
void endTag()
{
PX_ASSERT( mTags.size() );
if ( mTagOpen )
mStream << " " << "/>" << "\n";
else
{
writeTabs(mTags.size()-1);
doEndOpenTag();
}
mTagOpen = false;
mTags.popBack();
}
static bool IsNormalizableWhitespace(char c) { return c == 0x9 || c == 0xA || c == 0xD; }
static bool IsValidXmlCharacter(char c) { return IsNormalizableWhitespace(c) || c >= 0x20; }
void addContent( const char* inContent )
{
closeTag(false);
//escape xml
for( ; *inContent; inContent++ )
{
switch (*inContent)
{
case '<':
mStream << "<";
break;
case '>':
mStream << ">";
break;
case '&':
mStream << "&";
break;
case '\'':
mStream << "'";
break;
case '"':
mStream << """;
break;
default:
if (IsValidXmlCharacter(*inContent)) {
if (IsNormalizableWhitespace(*inContent))
{
char s[32];
Pxsnprintf(s, 32, "&#x%02X;", unsigned(*inContent));
mStream << s;
}
else
mStream << *inContent;
}
break;
}
}
}
void writeContentTag( const char* inTag, const char* inContent )
{
beginTag( inTag );
addContent( inContent );
doEndOpenTag();
mTags.popBack();
}
void insertXml( const char* inXml )
{
closeTag();
mStream << inXml;
}
};
struct BeginTag
{
const char* mTagName;
BeginTag( const char* inTagName )
: mTagName( inTagName ) { }
};
struct EndTag
{
EndTag() {}
};
struct Att
{
const char* mAttName;
const char* mAttValue;
Att( const char* inAttName, const char* inAttValue )
: mAttName( inAttName )
, mAttValue( inAttValue ) { }
};
struct Content
{
const char* mContent;
Content( const char* inContent )
: mContent( inContent ) { }
};
struct ContentTag
{
const char* mTagName;
const char* mContent;
ContentTag( const char* inTagName, const char* inContent )
: mTagName( inTagName )
, mContent( inContent ) { }
};
inline SimpleXmlWriter& operator<<( SimpleXmlWriter& inWriter, const BeginTag& inTag ) { inWriter.beginTag( inTag.mTagName ); return inWriter; }
inline SimpleXmlWriter& operator<<( SimpleXmlWriter& inWriter, const EndTag& inTag ) { PX_UNUSED(inTag); inWriter.endTag(); return inWriter; }
inline SimpleXmlWriter& operator<<( SimpleXmlWriter& inWriter, const Att& inTag ) { inWriter.addAttribute(inTag.mAttName, inTag.mAttValue); return inWriter; }
inline SimpleXmlWriter& operator<<( SimpleXmlWriter& inWriter, const Content& inTag ) { inWriter.addContent(inTag.mContent); return inWriter; }
inline SimpleXmlWriter& operator<<( SimpleXmlWriter& inWriter, const ContentTag& inTag ) { inWriter.writeContentTag(inTag.mTagName, inTag.mContent); return inWriter; }
inline void writeProperty( SimpleXmlWriter& inWriter, MemoryBuffer& tempBuffer, const char* inPropName )
{
PxU8 data = 0;
tempBuffer.write( &data, sizeof(PxU8) );
inWriter.writeContentTag( inPropName, reinterpret_cast<const char*>( tempBuffer.mBuffer ) );
tempBuffer.clear();
}
template<typename TDataType>
inline void writeProperty( SimpleXmlWriter& inWriter, MemoryBuffer& tempBuffer, const char* inPropName, TDataType inValue )
{
tempBuffer << inValue;
writeProperty( inWriter, tempBuffer, inPropName );
}
} }
#endif
| 7,602 | C | 28.583657 | 168 | 0.677585 |
NVIDIA-Omniverse/PhysX/physx/source/physxextensions/src/serialization/Xml/SnRepXUpgrader.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-2023 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 SN_REPX_UPGRADER_H
#define SN_REPX_UPGRADER_H
#include "foundation/PxSimpleTypes.h"
namespace physx { namespace Sn {
class RepXCollection;
class RepXUpgrader
{
public:
//If a new collection is created, the source collection is destroyed.
//Thus you only need to release the new collection.
//This holds for all of the upgrade functions.
//So be aware, that the argument to these functions may not be valid
//after they are called, but the return value always will be valid.
static RepXCollection& upgradeCollection( RepXCollection& src );
static RepXCollection& upgrade10CollectionTo3_1Collection( RepXCollection& src );
static RepXCollection& upgrade3_1CollectionTo3_2Collection( RepXCollection& src );
static RepXCollection& upgrade3_2CollectionTo3_3Collection( RepXCollection& src );
static RepXCollection& upgrade3_3CollectionTo3_4Collection( RepXCollection& src );
static RepXCollection& upgrade3_4CollectionTo4_0Collection( RepXCollection& src );
};
} }
#endif
| 2,704 | C | 48.181817 | 84 | 0.77145 |
NVIDIA-Omniverse/PhysX/physx/source/physxextensions/src/serialization/Xml/SnXmlVisitorReader.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-2023 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 SN_XML_VISITOR_READER_H
#define SN_XML_VISITOR_READER_H
#include "foundation/PxArray.h"
#include "foundation/PxUtilities.h"
#include "RepXMetaDataPropertyVisitor.h"
#include "SnPxStreamOperators.h"
#include "SnXmlMemoryPoolStreams.h"
#include "SnXmlReader.h"
#include "SnXmlImpl.h"
#include "SnXmlMemoryAllocator.h"
#include "SnXmlStringToType.h"
namespace physx { namespace Sn {
inline PxU32 findEnumByName( const char* inName, const PxU32ToName* inTable )
{
for ( PxU32 idx = 0; inTable[idx].mName != NULL; ++idx )
{
if ( physx::Pxstricmp( inTable[idx].mName, inName ) == 0 )
return inTable[idx].mValue;
}
return 0;
}
PX_INLINE void stringToFlagsType( const char* strData, XmlMemoryAllocator& alloc, PxU32& ioType, const PxU32ToName* inTable )
{
if ( inTable == NULL )
return;
ioType = 0;
if ( strData && *strData)
{
//Destructively parse the string to get out the different flags.
char* theValue = const_cast<char*>( copyStr( &alloc, strData ) );
char* theMarker = theValue;
char* theNext = theValue;
while( theNext && *theNext )
{
++theNext;
if( *theNext == '|' )
{
*theNext = 0;
++theNext;
ioType |= static_cast< PxU32 > ( findEnumByName( theMarker, inTable ) );
theMarker = theNext;
}
}
if ( theMarker && *theMarker )
ioType |= static_cast< PxU32 > ( findEnumByName( theMarker, inTable ) );
alloc.deallocate( reinterpret_cast<PxU8*>( theValue ) );
}
}
template<typename TDataType>
PX_INLINE void stringToEnumType( const char* strData, TDataType& ioType, const PxU32ToName* inTable )
{
ioType = static_cast<TDataType>( findEnumByName( strData, inTable ) );
}
template<typename TDataType>
PX_INLINE bool readProperty( XmlReader& inReader, const char* pname, TDataType& ioType )
{
const char* value;
if ( inReader.read( pname, value ) )
{
stringToType( value, ioType );
return true;
}
return false;
}
template<typename TObjType>
inline TObjType* findReferencedObject( PxCollection& collection, PxSerialObjectId id)
{
PX_ASSERT(id > 0);
TObjType* outObject = static_cast<TObjType*>(const_cast<PxBase*>(collection.find(id)));
if (outObject == NULL)
{
PxGetFoundation().error(PxErrorCode::eINVALID_PARAMETER, PX_FL,
"PxSerialization::createCollectionFromXml: "
"Reference to ID %d cannot be resolved. Make sure externalRefs collection is specified if required and "
"check Xml file for completeness.",
id);
}
return outObject;
}
template<typename TObjType>
inline bool readReference( XmlReader& inReader, PxCollection& collection, TObjType*& outObject )
{
PxSerialObjectId theId;
const char* theValue = inReader.getCurrentItemValue();
strto( theId, theValue );
if( theId == 0)
{
// the NULL pointer is a valid pointer if the input id is 0
outObject = NULL;
return true;
}
else
{
outObject = findReferencedObject<TObjType>(collection, theId);
return outObject != NULL;
}
}
template<typename TObjType>
inline bool readReference( XmlReader& inReader, PxCollection& inCollection, const char* pname, TObjType*& outObject )
{
outObject = NULL;
PxSerialObjectId theId = 0;
if (readProperty ( inReader, pname, theId ) && theId )
{
outObject = findReferencedObject<TObjType>(inCollection, theId);
}
// the NULL pointer is a valid pointer if the input id is 0
return (outObject != NULL) || 0 == theId;
}
template<typename TEnumType, typename TStorageType>
inline bool readFlagsProperty( XmlReader& reader, XmlMemoryAllocator& allocator, const char* pname, const PxU32ToName* inConversions, PxFlags<TEnumType,TStorageType>& outFlags )
{
const char* value;
if ( reader.read( pname, value ) )
{
PxU32 tempValue = 0;
stringToFlagsType( value, allocator, tempValue, inConversions );
outFlags = PxFlags<TEnumType,TStorageType>(PxTo16(tempValue) );
return true;
}
return false;
}
template<typename TObjType, typename TReaderType, typename TInfoType>
inline void readComplexObj( TReaderType& oldVisitor, TObjType* inObj, TInfoType& info);
template<typename TObjType, typename TReaderType>
inline void readComplexObj( TReaderType& oldVisitor, TObjType* inObj);
template<typename TReaderType, typename TGeomType>
inline PxGeometry* parseGeometry( TReaderType& reader, TGeomType& /*inGeom*/)
{
PxAllocatorCallback& inAllocator = reader.mAllocator.getAllocator();
TGeomType* shape = PX_PLACEMENT_NEW((inAllocator.allocate(sizeof(TGeomType), "parseGeometry", PX_FL)), TGeomType);
PxClassInfoTraits<TGeomType> info;
readComplexObj( reader, shape);
return shape;
}
template<typename TReaderType>
inline void parseShape( TReaderType& visitor, PxGeometry*& outResult, PxArray<PxMaterial*>& outMaterials)
{
XmlReader& theReader( visitor.mReader );
PxCollection& collection = visitor.mCollection;
visitor.pushCurrentContext();
if ( visitor.gotoTopName() )
{
visitor.pushCurrentContext();
if ( visitor.gotoChild( "Materials" ) )
{
for( bool matSuccess = visitor.gotoFirstChild(); matSuccess;
matSuccess = visitor.gotoNextSibling() )
{
PxMaterial* material = NULL;
if(!readReference<PxMaterial>( theReader, collection, material ))
visitor.mHadError = true;
if ( material )
outMaterials.pushBack( material );
}
}
visitor.popCurrentContext();
visitor.pushCurrentContext();
PxPlaneGeometry plane;
PxHeightFieldGeometry heightField;
PxSphereGeometry sphere;
PxTriangleMeshGeometry mesh;
PxConvexMeshGeometry convex;
PxBoxGeometry box;
PxCapsuleGeometry capsule;
if ( visitor.gotoChild( "Geometry" ) )
{
if ( visitor.gotoFirstChild() )
{
const char* geomTypeName = visitor.getCurrentItemName();
if ( physx::Pxstricmp( geomTypeName, "PxSphereGeometry" ) == 0 ) outResult = parseGeometry(visitor, sphere);
else if ( physx::Pxstricmp( geomTypeName, "PxPlaneGeometry" ) == 0 ) outResult = parseGeometry(visitor, plane);
else if ( physx::Pxstricmp( geomTypeName, "PxCapsuleGeometry" ) == 0 ) outResult = parseGeometry(visitor, capsule);
else if ( physx::Pxstricmp( geomTypeName, "PxBoxGeometry" ) == 0 ) outResult = parseGeometry(visitor, box);
else if ( physx::Pxstricmp( geomTypeName, "PxConvexMeshGeometry" ) == 0 ) outResult = parseGeometry(visitor, convex);
else if ( physx::Pxstricmp( geomTypeName, "PxTriangleMeshGeometry" ) == 0 ) outResult = parseGeometry(visitor, mesh);
else if ( physx::Pxstricmp( geomTypeName, "PxHeightFieldGeometry" ) == 0 ) outResult = parseGeometry(visitor, heightField);
else
PX_ASSERT( false );
}
}
visitor.popCurrentContext();
}
visitor.popCurrentContext();
return;
}
template<typename TReaderType, typename TObjType>
inline void readShapesProperty( TReaderType& visitor, TObjType* inObj, const PxRigidActorShapeCollection* inProp = NULL, bool isSharedShape = false )
{
PX_UNUSED(isSharedShape);
PX_UNUSED(inProp);
XmlReader& theReader( visitor.mReader );
PxCollection& collection( visitor.mCollection );
visitor.pushCurrentContext();
if ( visitor.gotoTopName() )
{
//uggh working around the shape collection api.
//read out materials and geometry
for ( bool success = visitor.gotoFirstChild(); success;
success = visitor.gotoNextSibling() )
{
if( 0 == physx::Pxstricmp( visitor.getCurrentItemName(), "PxShapeRef" ) )
{
PxShape* shape = NULL;
if(!readReference<PxShape>( theReader, collection, shape ))
visitor.mHadError = true;
if(shape)
inObj->attachShape( *shape );
}
else
{
PxArray<PxMaterial*> materials;
PxGeometry* geometry = NULL;
parseShape( visitor, geometry, materials);
PxShape* theShape = NULL;
if ( materials.size() )
{
theShape = visitor.mArgs.physics.createShape( *geometry, materials.begin(), PxTo16(materials.size()), true );
if ( theShape )
{
readComplexObj( visitor, theShape );
if(theShape)
{
inObj->attachShape(*theShape);
collection.add( *theShape );
}
}
}
switch(geometry->getType())
{
case PxGeometryType::eSPHERE :
static_cast<PxSphereGeometry*>(geometry)->~PxSphereGeometry();
break;
case PxGeometryType::ePLANE :
static_cast<PxPlaneGeometry*>(geometry)->~PxPlaneGeometry();
break;
case PxGeometryType::eCAPSULE :
static_cast<PxCapsuleGeometry*>(geometry)->~PxCapsuleGeometry();
break;
case PxGeometryType::eBOX :
static_cast<PxBoxGeometry*>(geometry)->~PxBoxGeometry();
break;
case PxGeometryType::eCONVEXMESH :
static_cast<PxConvexMeshGeometry*>(geometry)->~PxConvexMeshGeometry();
break;
case PxGeometryType::eTRIANGLEMESH :
static_cast<PxTriangleMeshGeometry*>(geometry)->~PxTriangleMeshGeometry();
break;
case PxGeometryType::eHEIGHTFIELD :
static_cast<PxHeightFieldGeometry*>(geometry)->~PxHeightFieldGeometry();
break;
case PxGeometryType::eTETRAHEDRONMESH :
static_cast<PxTetrahedronMeshGeometry*>(geometry)->~PxTetrahedronMeshGeometry();
break;
case PxGeometryType::ePARTICLESYSTEM:
static_cast<PxParticleSystemGeometry*>(geometry)->~PxParticleSystemGeometry();
break;
case PxGeometryType::eHAIRSYSTEM:
static_cast<PxHairSystemGeometry*>(geometry)->~PxHairSystemGeometry();
break;
case PxGeometryType::eCUSTOM :
static_cast<PxCustomGeometry*>(geometry)->~PxCustomGeometry();
break;
case PxGeometryType::eGEOMETRY_COUNT:
case PxGeometryType::eINVALID:
PX_ASSERT(0);
}
visitor.mAllocator.getAllocator().deallocate(geometry);
}
}
}
visitor.popCurrentContext();
}
struct ReaderNameStackEntry : NameStackEntry
{
bool mValid;
ReaderNameStackEntry( const char* nm, bool valid ) : NameStackEntry(nm), mValid(valid) {}
};
typedef PxProfileArray<ReaderNameStackEntry> TReaderNameStack;
template<typename TObjType>
struct RepXVisitorReaderBase
{
protected:
RepXVisitorReaderBase<TObjType>& operator=(const RepXVisitorReaderBase<TObjType>&);
public:
TReaderNameStack& mNames;
PxProfileArray<PxU32>& mContexts;
PxRepXInstantiationArgs mArgs;
XmlReader& mReader;
TObjType* mObj;
XmlMemoryAllocator& mAllocator;
PxCollection& mCollection;
bool mValid;
bool& mHadError;
RepXVisitorReaderBase( TReaderNameStack& names, PxProfileArray<PxU32>& contexts, const PxRepXInstantiationArgs& args, XmlReader& reader, TObjType* obj
, XmlMemoryAllocator& alloc, PxCollection& collection, bool& hadError )
: mNames( names )
, mContexts( contexts )
, mArgs( args )
, mReader( reader )
, mObj( obj )
, mAllocator( alloc )
, mCollection( collection )
, mValid( true )
, mHadError(hadError)
{
}
RepXVisitorReaderBase( const RepXVisitorReaderBase& other )
: mNames( other.mNames )
, mContexts( other.mContexts )
, mArgs( other.mArgs )
, mReader( other.mReader )
, mObj( other.mObj )
, mAllocator( other.mAllocator )
, mCollection( other.mCollection )
, mValid( other.mValid )
, mHadError( other.mHadError )
{
}
void pushName( const char* name )
{
gotoTopName();
mNames.pushBack( ReaderNameStackEntry( name, mValid ) );
}
void pushBracketedName( const char* name ) { pushName( name ); }
void popName()
{
if ( mNames.size() )
{
if ( mNames.back().mOpen && mNames.back().mValid )
mReader.leaveChild();
mNames.popBack();
}
mValid =true;
if ( mNames.size() && mNames.back().mValid == false )
mValid = false;
}
void pushCurrentContext()
{
mContexts.pushBack( static_cast<PxU32>( mNames.size() ) );
}
void popCurrentContext()
{
if ( mContexts.size() )
{
PxU32 depth = mContexts.back();
PX_ASSERT( mNames.size() >= depth );
while( mNames.size() > depth )
popName();
mContexts.popBack();
}
}
bool updateLastEntryAfterOpen()
{
mNames.back().mValid = mValid;
mNames.back().mOpen = mValid;
return mValid;
}
bool gotoTopName()
{
if ( mNames.size() && mNames.back().mOpen == false )
{
if ( mValid )
mValid = mReader.gotoChild( mNames.back().mName );
updateLastEntryAfterOpen();
}
return mValid;
}
bool isValid() const { return mValid; }
bool gotoChild( const char* name )
{
pushName( name );
return gotoTopName();
}
bool gotoFirstChild()
{
pushName( "__child" );
if ( mValid ) mValid = mReader.gotoFirstChild();
return updateLastEntryAfterOpen();
}
bool gotoNextSibling()
{
bool retval = mValid;
if ( mValid ) retval = mReader.gotoNextSibling();
return retval;
}
const char* getCurrentItemName() { if (mValid ) return mReader.getCurrentItemName(); return ""; }
const char* topName() const
{
if ( mNames.size() ) return mNames.back().mName;
PX_ASSERT( false );
return "bad__repx__name";
}
const char* getCurrentValue()
{
const char* value = NULL;
if ( isValid() && mReader.read( topName(), value ) )
return value;
return NULL;
}
template<typename TDataType>
bool readProperty(TDataType& outType)
{
const char* value = getCurrentValue();
if ( value && *value )
{
stringToType( value, outType );
return true;
}
return false;
}
template<typename TDataType>
bool readExtendedIndexProperty(TDataType& outType)
{
const char* value = mReader.getCurrentItemValue();
if ( value && *value )
{
stringToType( value, outType );
return true;
}
return false;
}
template<typename TRefType>
bool readReference(TRefType*& outRef)
{
return physx::Sn::readReference<TRefType>( mReader, mCollection, topName(), outRef );
}
inline bool readProperty(const char*& outProp )
{
outProp = "";
const char* value = getCurrentValue();
if ( value && *value && mArgs.stringTable )
{
outProp = mArgs.stringTable->allocateStr( value );
return true;
}
return false;
}
inline bool readProperty(PxConvexMesh*& outProp )
{
return readReference<PxConvexMesh>( outProp );
}
inline bool readProperty(PxTriangleMesh*& outProp )
{
return readReference<PxTriangleMesh>( outProp );
}
inline bool readProperty(PxBVH33TriangleMesh*& outProp )
{
return readReference<PxBVH33TriangleMesh>( outProp );
}
inline bool readProperty(PxBVH34TriangleMesh*& outProp )
{
return readReference<PxBVH34TriangleMesh>( outProp );
}
inline bool readProperty(PxHeightField*& outProp )
{
return readReference<PxHeightField>( outProp );
}
inline bool readProperty( PxRigidActor *& outProp )
{
return readReference<PxRigidActor>( outProp );
}
template<typename TAccessorType>
void simpleProperty( PxU32 /*key*/, TAccessorType& inProp )
{
typedef typename TAccessorType::prop_type TPropertyType;
TPropertyType value;
if ( readProperty( value ) )
inProp.set( mObj, value );
}
template<typename TAccessorType>
void enumProperty( PxU32 /*key*/, TAccessorType& inProp, const PxU32ToName* inConversions )
{
typedef typename TAccessorType::prop_type TPropertyType;
const char* strVal = getCurrentValue();
if ( strVal && *strVal )
{
TPropertyType pval;
stringToEnumType( strVal, pval, inConversions );
inProp.set( mObj, pval );
}
}
template<typename TAccessorType>
void flagsProperty( PxU32 /*key*/, const TAccessorType& inProp, const PxU32ToName* inConversions )
{
typedef typename TAccessorType::prop_type TPropertyType;
typedef typename TPropertyType::InternalType TInternalType;
const char* strVal = getCurrentValue();
if ( strVal && *strVal )
{
PxU32 tempValue = 0;
stringToFlagsType( strVal, mAllocator, tempValue, inConversions );
inProp.set( mObj, TPropertyType(TInternalType( tempValue )));
}
}
template<typename TAccessorType, typename TInfoType>
void complexProperty( PxU32* /*key*/, const TAccessorType& inProp, TInfoType& inInfo )
{
typedef typename TAccessorType::prop_type TPropertyType;
if ( gotoTopName() )
{
TPropertyType propVal = inProp.get( mObj );
readComplexObj( *this, &propVal, inInfo );
inProp.set( mObj, propVal );
}
}
template<typename TAccessorType, typename TInfoType>
void bufferCollectionProperty( PxU32* /*key*/, const TAccessorType& inProp, TInfoType& inInfo )
{
typedef typename TAccessorType::prop_type TPropertyType;
PxInlineArray<TPropertyType,5> theData;
this->pushCurrentContext();
if ( this->gotoTopName() )
{
for ( bool success = this->gotoFirstChild(); success;
success = this->gotoNextSibling() )
{
TPropertyType propVal;
readComplexObj( *this, &propVal, inInfo );
theData.pushBack(propVal);
}
}
this->popCurrentContext();
inProp.set( mObj, theData.begin(), theData.size() );
}
template<typename TAccessorType, typename TInfoType>
void extendedIndexedProperty( PxU32* /*key*/, const TAccessorType& inProp, TInfoType& inInfo )
{
typedef typename TAccessorType::prop_type TPropertyType;
this->pushCurrentContext();
if ( this->gotoTopName() )
{
PxU32 index = 0;
for ( bool success = this->gotoFirstChild(); success;
success = this->gotoNextSibling() )
{
TPropertyType propVal;
readComplexObj( *this, &propVal, inInfo );
inProp.set(mObj, index, propVal);
++index;
}
}
this->popCurrentContext();
}
template<typename TAccessorType, typename TInfoType>
void PxFixedSizeLookupTableProperty( PxU32* /*key*/, const TAccessorType& inProp, TInfoType& inInfo )
{
typedef typename TAccessorType::prop_type TPropertyType;
const_cast<TAccessorType&>(inProp).clear( mObj );
this->pushCurrentContext();
if ( this->gotoTopName() )
{
for ( bool success = this->gotoFirstChild(); success;
success = this->gotoNextSibling() )
{
TPropertyType propXVal;
readComplexObj( *this, &propXVal, inInfo );
if(this->gotoNextSibling())
{
TPropertyType propYVal;
readComplexObj( *this, &propYVal, inInfo );
const_cast<TAccessorType&>(inProp).addPair(mObj, propXVal, propYVal);
}
}
}
this->popCurrentContext();
}
void handleShapes( const PxRigidActorShapeCollection& inProp )
{
physx::Sn::readShapesProperty( *this, mObj, &inProp );
}
void handleRigidActorGlobalPose(const PxRigidActorGlobalPosePropertyInfo& inProp)
{
PxArticulationLink* link = mObj->template is<PxArticulationLink>();
bool isReducedCoordinateLink = (link != NULL);
if (!isReducedCoordinateLink)
{
PxRepXPropertyAccessor<PxPropertyInfoName::PxRigidActor_GlobalPose, PxRigidActor, const PxTransform &, PxTransform> theAccessor(inProp);
simpleProperty(PxPropertyInfoName::PxRigidActor_GlobalPose, theAccessor);
}
}
};
template<typename TObjType>
struct RepXVisitorReader : public RepXVisitorReaderBase<TObjType>
{
RepXVisitorReader( TReaderNameStack& names, PxProfileArray<PxU32>& contexts, const PxRepXInstantiationArgs& args, XmlReader& reader, TObjType* obj
, XmlMemoryAllocator& alloc, PxCollection& collection, bool& ret)
: RepXVisitorReaderBase<TObjType>( names, contexts, args, reader, obj, alloc, collection, ret)
{
}
RepXVisitorReader( const RepXVisitorReader<TObjType>& other )
: RepXVisitorReaderBase<TObjType>( other )
{
}
};
// Specialized template to load dynamic rigid, to determine the kinematic state first
template<>
struct RepXVisitorReader<PxRigidDynamic> : public RepXVisitorReaderBase<PxRigidDynamic>
{
RepXVisitorReader( TReaderNameStack& names, PxProfileArray<PxU32>& contexts, const PxRepXInstantiationArgs& args, XmlReader& reader, PxRigidDynamic* obj
, XmlMemoryAllocator& alloc, PxCollection& collection, bool& ret)
: RepXVisitorReaderBase<PxRigidDynamic>( names, contexts, args, reader, obj, alloc, collection, ret)
{
}
RepXVisitorReader( const RepXVisitorReader<PxRigidDynamic>& other )
: RepXVisitorReaderBase<PxRigidDynamic>( other )
{
}
void handleShapes( const PxRigidActorShapeCollection& inProp )
{
// Need to read the parental actor to check if actor is kinematic
// in that case we need to apply the kinematic flag before a shape is set
XmlReaderWriter* parentReader = static_cast<XmlReaderWriter*>(mReader.getParentReader());
if(mObj)
{
const char* value;
if (parentReader->read( "RigidBodyFlags", value ))
{
if(strstr(value, "eKINEMATIC"))
{
mObj->setRigidBodyFlag(PxRigidBodyFlag::eKINEMATIC, true);
}
}
}
physx::Sn::readShapesProperty( *this, mObj, &inProp );
parentReader->release();
}
template<typename TAccessorType>
void simpleProperty( PxU32 /*key*/, TAccessorType& inProp )
{
typedef typename TAccessorType::prop_type TPropertyType;
TPropertyType value;
if (readProperty(value))
{
// If the rigid body is kinematic, we cannot set the LinearVelocity or AngularVelocity
const bool kinematic = (mObj->getRigidBodyFlags() & PxRigidBodyFlag::eKINEMATIC);
if(kinematic && (inProp.mProperty.mKey == PxPropertyInfoName::PxRigidDynamic_LinearVelocity || inProp.mProperty.mKey == PxPropertyInfoName::PxRigidDynamic_AngularVelocity))
return;
inProp.set(mObj, value );
}
}
private:
RepXVisitorReader<PxRigidDynamic>& operator=(const RepXVisitorReader<PxRigidDynamic>&);
};
template<>
struct RepXVisitorReader<PxShape> : public RepXVisitorReaderBase<PxShape>
{
RepXVisitorReader( TReaderNameStack& names, PxProfileArray<PxU32>& contexts, const PxRepXInstantiationArgs& args, XmlReader& reader, PxShape* obj
, XmlMemoryAllocator& alloc, PxCollection& collection, bool& ret )
: RepXVisitorReaderBase<PxShape>( names, contexts, args, reader, obj, alloc, collection, ret )
{
}
RepXVisitorReader( const RepXVisitorReader<PxShape>& other )
: RepXVisitorReaderBase<PxShape>( other )
{
}
void handleShapeMaterials( const PxShapeMaterialsProperty& ) //these were handled during construction.
{
}
void handleGeomProperty( const PxShapeGeomProperty& )
{
}
private:
RepXVisitorReader<PxShape>& operator=(const RepXVisitorReader<PxShape>&);
};
template<>
struct RepXVisitorReader<PxArticulationLink> : public RepXVisitorReaderBase<PxArticulationLink>
{
RepXVisitorReader( TReaderNameStack& names, PxProfileArray<PxU32>& contexts, const PxRepXInstantiationArgs& args, XmlReader& reader, PxArticulationLink* obj
, XmlMemoryAllocator& alloc, PxCollection& collection, bool& ret )
: RepXVisitorReaderBase<PxArticulationLink>( names, contexts, args, reader, obj, alloc, collection, ret )
{
}
RepXVisitorReader( const RepXVisitorReader<PxArticulationLink>& other )
: RepXVisitorReaderBase<PxArticulationLink>( other )
{
}
void handleIncomingJoint( const TIncomingJointPropType& prop )
{
pushName( "Joint" );
if ( gotoTopName() )
{
PxArticulationJointReducedCoordinate* theJoint = static_cast<PxArticulationJointReducedCoordinate*>((prop.get(mObj)));
readComplexObj(*this, theJoint);
//Add joint to PxCollection, since PxArticulation requires PxArticulationLink and joint.
mCollection.add(*theJoint);
}
popName();
}
private:
RepXVisitorReader<PxArticulationLink>& operator=(const RepXVisitorReader<PxArticulationLink>&);
};
template<typename ArticulationType>
inline void readProperty( RepXVisitorReaderBase<ArticulationType>& inSerializer, ArticulationType* inObj, const PxArticulationLinkCollectionProp&)
{
PxProfileAllocatorWrapper theWrapper( inSerializer.mAllocator.getAllocator() );
PxCollection& collection( inSerializer.mCollection );
TArticulationLinkLinkMap linkRemapMap( theWrapper );
inSerializer.pushCurrentContext();
if( inSerializer.gotoTopName() )
{
for ( bool links = inSerializer.gotoFirstChild();
links != false;
links = inSerializer.gotoNextSibling() )
{
//Need enough information to create the link...
PxSerialObjectId theParentPtr = 0;
const PxArticulationLink* theParentLink = NULL;
if ( inSerializer.mReader.read( "Parent", theParentPtr ) )
{
const TArticulationLinkLinkMap::Entry* theRemappedParent( linkRemapMap.find( theParentPtr ) );
//If we have a valid at write time, we had better have a valid parent at read time.
PX_ASSERT( theRemappedParent );
theParentLink = theRemappedParent->second;
}
PxArticulationLink* newLink = inObj->createLink( const_cast<PxArticulationLink*>( theParentLink ), PxTransform(PxIdentity) );
PxSerialObjectId theIdPtr = 0;
inSerializer.mReader.read( "Id", theIdPtr );
linkRemapMap.insert( theIdPtr, newLink );
readComplexObj( inSerializer, newLink );
//Add link to PxCollection, since PxArticulation requires PxArticulationLink and joint.
collection.add( *newLink, theIdPtr );
}
}
inSerializer.popCurrentContext();
}
template<>
struct RepXVisitorReader<PxArticulationReducedCoordinate> : public RepXVisitorReaderBase<PxArticulationReducedCoordinate>
{
RepXVisitorReader(TReaderNameStack& names, PxProfileArray<PxU32>& contexts, const PxRepXInstantiationArgs& args, XmlReader& reader, PxArticulationReducedCoordinate* obj
, XmlMemoryAllocator& alloc, PxCollection& collection, bool& ret)
: RepXVisitorReaderBase<PxArticulationReducedCoordinate>(names, contexts, args, reader, obj, alloc, collection, ret)
{}
RepXVisitorReader(const RepXVisitorReader<PxArticulationReducedCoordinate>& other)
: RepXVisitorReaderBase<PxArticulationReducedCoordinate>(other)
{}
void handleArticulationLinks(const PxArticulationLinkCollectionProp& inProp)
{
physx::Sn::readProperty(*this, mObj, inProp);
}
};
template<typename TObjType, typename TInfoType>
inline bool readAllProperties( PxRepXInstantiationArgs args, TReaderNameStack& names, PxProfileArray<PxU32>& contexts, XmlReader& reader, TObjType* obj, XmlMemoryAllocator& alloc, PxCollection& collection, TInfoType& info )
{
bool hadError = false;
RepXVisitorReader<TObjType> theReader( names, contexts, args, reader, obj, alloc, collection, hadError);
RepXPropertyFilter<RepXVisitorReader<TObjType> > theOp( theReader );
info.visitBaseProperties( theOp );
info.visitInstanceProperties( theOp );
return !hadError;
}
template<typename TObjType>
inline bool readAllProperties( PxRepXInstantiationArgs args, XmlReader& reader, TObjType* obj, XmlMemoryAllocator& alloc, PxCollection& collection )
{
PxProfileAllocatorWrapper wrapper( alloc.getAllocator() );
TReaderNameStack names( wrapper );
PxProfileArray<PxU32> contexts( wrapper );
PxClassInfoTraits<TObjType> info;
return readAllProperties( args, names, contexts, reader, obj, alloc, collection, info.Info );
}
template<typename TObjType, typename TReaderType, typename TInfoType>
inline void readComplexObj( TReaderType& oldVisitor, TObjType* inObj, TInfoType& info)
{
if(!readAllProperties( oldVisitor.mArgs, oldVisitor.mNames, oldVisitor.mContexts, oldVisitor.mReader, inObj, oldVisitor.mAllocator, oldVisitor.mCollection, info ))
oldVisitor.mHadError = true;
}
template<typename TObjType, typename TReaderType, typename TInfoType>
inline void readComplexObj( TReaderType& oldVisitor, TObjType* inObj, const TInfoType& info)
{
if(!readAllProperties( oldVisitor.mArgs, oldVisitor.mNames, oldVisitor.mContexts, oldVisitor.mReader, inObj, oldVisitor.mAllocator, oldVisitor.mCollection, info ))
oldVisitor.mHadError = true;
}
template<typename TObjType, typename TReaderType>
inline void readComplexObj( TReaderType& oldVisitor, TObjType* inObj, const PxUnknownClassInfo& /*info*/)
{
const char* value = oldVisitor.mReader.getCurrentItemValue();
if ( value && *value )
{
stringToType( value, *inObj );
return;
}
oldVisitor.mHadError = true;
}
template<typename TObjType, typename TReaderType>
inline void readComplexObj( TReaderType& oldVisitor, TObjType* inObj)
{
PxClassInfoTraits<TObjType> info;
if(!readAllProperties( oldVisitor.mArgs, oldVisitor.mNames, oldVisitor.mContexts, oldVisitor.mReader, inObj, oldVisitor.mAllocator, oldVisitor.mCollection, info.Info ))
oldVisitor.mHadError = true;
}
} }
#endif
| 30,176 | C | 32.016411 | 224 | 0.710101 |
NVIDIA-Omniverse/PhysX/physx/source/physxextensions/src/serialization/Xml/SnXmlMemoryPoolStreams.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-2023 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 SN_XML_MEMORY_POOL_STREAMS_H
#define SN_XML_MEMORY_POOL_STREAMS_H
#include "foundation/PxTransform.h"
#include "foundation/PxIO.h"
#include "SnXmlMemoryPool.h"
namespace physx {
template<typename TDataType>
struct XmlDefaultValue
{
bool force_compile_error;
};
#define XML_DEFINE_DEFAULT_VALUE(type, defVal ) \
template<> \
struct XmlDefaultValue<type> \
{ \
type getDefaultValue() { return type(defVal); } \
};
XML_DEFINE_DEFAULT_VALUE(PxU8, 0)
XML_DEFINE_DEFAULT_VALUE(PxI8, 0)
XML_DEFINE_DEFAULT_VALUE(PxU16, 0)
XML_DEFINE_DEFAULT_VALUE(PxI16, 0)
XML_DEFINE_DEFAULT_VALUE(PxU32, 0)
XML_DEFINE_DEFAULT_VALUE(PxI32, 0)
XML_DEFINE_DEFAULT_VALUE(PxU64, 0)
XML_DEFINE_DEFAULT_VALUE(PxI64, 0)
XML_DEFINE_DEFAULT_VALUE(PxF32, 0)
XML_DEFINE_DEFAULT_VALUE(PxF64, 0)
#undef XML_DEFINE_DEFAULT_VALUE
template<>
struct XmlDefaultValue<PxVec3>
{
PxVec3 getDefaultValue() { return PxVec3( 0,0,0 ); }
};
template<>
struct XmlDefaultValue<PxTransform>
{
PxTransform getDefaultValue() { return PxTransform(PxIdentity); }
};
template<>
struct XmlDefaultValue<PxQuat>
{
PxQuat getDefaultValue() { return PxQuat(PxIdentity); }
};
/**
* Mapping of PxOutputStream to a memory pool manager.
* Allows write-then-read semantics of a set of
* data. Can safely write up to 4GB of data; then you
* will silently fail...
*/
template<typename TAllocatorType>
struct MemoryBufferBase : public PxOutputStream, public PxInputStream
{
TAllocatorType* mManager;
mutable PxU32 mWriteOffset;
mutable PxU32 mReadOffset;
PxU8* mBuffer;
PxU32 mCapacity;
MemoryBufferBase( TAllocatorType* inManager )
: mManager( inManager )
, mWriteOffset( 0 )
, mReadOffset( 0 )
, mBuffer( NULL )
, mCapacity( 0 )
{
}
virtual ~MemoryBufferBase()
{
mManager->deallocate( mBuffer );
}
PxU8* releaseBuffer()
{
clear();
mCapacity = 0;
PxU8* retval(mBuffer);
mBuffer = NULL;
return retval;
}
void clear()
{
mWriteOffset = mReadOffset = 0;
}
virtual PxU32 read(void* dest, PxU32 count)
{
bool fits = ( mReadOffset + count ) <= mWriteOffset;
PX_ASSERT( fits );
if ( fits )
{
PxMemCopy( dest, mBuffer + mReadOffset, count );
mReadOffset += count;
return count;
}
return 0;
}
inline void checkCapacity( PxU32 inNewCapacity )
{
if ( mCapacity < inNewCapacity )
{
PxU32 newCapacity = 32;
while( newCapacity < inNewCapacity )
newCapacity = newCapacity << 1;
PxU8* newData( mManager->allocate( newCapacity ) );
if ( mWriteOffset )
PxMemCopy( newData, mBuffer, mWriteOffset );
mManager->deallocate( mBuffer );
mBuffer = newData;
mCapacity = newCapacity;
}
}
virtual PxU32 write(const void* src, PxU32 count)
{
checkCapacity( mWriteOffset + count );
PxMemCopy( mBuffer + mWriteOffset, src, count );
mWriteOffset += count;
return count;
}
};
class MemoryBuffer : public MemoryBufferBase<CMemoryPoolManager >
{
public:
MemoryBuffer( CMemoryPoolManager* inManager ) : MemoryBufferBase<CMemoryPoolManager >( inManager ) {}
};
}
#endif
| 4,874 | C | 27.179191 | 102 | 0.707838 |
NVIDIA-Omniverse/PhysX/physx/source/physxextensions/src/serialization/Xml/SnRepX3_1Defaults.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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
DEFINE_REPX_DEFAULT_PROPERTY("PxTolerancesScale.Length", "1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxTolerancesScale.Mass", "1000" )
DEFINE_REPX_DEFAULT_PROPERTY("PxTolerancesScale.Speed", "10" )
DEFINE_REPX_DEFAULT_PROPERTY("PxBoxGeometry.HalfExtents", "0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxSphereGeometry.Radius", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxConvexMeshGeometry.Scale.Scale", "1 1 1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxConvexMeshGeometry.Scale.Rotation", "0 0 0 1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxConvexMeshGeometry.ConvexMesh", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxTriangleMeshGeometry.Scale.Scale", "1 1 1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxTriangleMeshGeometry.Scale.Rotation", "0 0 0 1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxTriangleMeshGeometry.MeshFlags", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxTriangleMeshGeometry.TriangleMesh", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.HeightField", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.HeightScale", "1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.RowScale", "1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.ColumnScale", "1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.HeightFieldFlags", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.DynamicFriction", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.StaticFriction", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.Restitution", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.DynamicFrictionV", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.StaticFrictionV", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.DirOfAnisotropy", "1 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.Flags", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.FrictionCombineMode", "eAVERAGE" )
DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.RestitutionCombineMode", "eAVERAGE" )
DEFINE_REPX_DEFAULT_PROPERTY("PxShape.LocalPose", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxShape.SimulationFilterData", "0 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxShape.QueryFilterData", "0 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxShape.ContactOffset", "0.02" )
DEFINE_REPX_DEFAULT_PROPERTY("PxShape.RestOffset", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxShape.Flags", "eSIMULATION_SHAPE|eSCENE_QUERY_SHAPE|eVISUALIZATION" )
DEFINE_REPX_DEFAULT_PROPERTY("PxShape.Name", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.Name", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.ActorFlags", "eVISUALIZATION" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.DominanceGroup", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.OwnerClient", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.ClientBehaviorBits", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.GlobalPose", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.Name", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.ActorFlags", "eVISUALIZATION" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.DominanceGroup", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.OwnerClient", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.ClientBehaviorBits", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.GlobalPose", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.CMassLocalPose", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.Mass", "1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.MassSpaceInertiaTensor", "1 1 1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.LinearVelocity", "0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.AngularVelocity", "0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.LinearDamping", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.AngularDamping", "0.05" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.MaxAngularVelocity", "7" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.SleepThreshold", "0.005" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.SolverIterationCounts.minPositionIters", "4" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.SolverIterationCounts.minVelocityIters", "1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.ContactReportThreshold", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.RigidDynamicFlags", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.ParentPose", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.ChildPose", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TargetOrientation", "0 0 0 1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TargetVelocity", "0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.Spring", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.Damping", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.InternalCompliance", "1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.ExternalCompliance", "1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.SwingLimit.yLimit", "0.78539816339" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.SwingLimit.zLimit", "0.78539816339" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TangentialSpring", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TangentialDamping", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.SwingLimitContactDistance", "0.05" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.SwingLimitEnabled", "false" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TwistLimit.lower", "-0.78539816339" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TwistLimit.upper", "0.78539816339" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TwistLimitEnabled", "false" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TwistLimitContactDistance", "0.05" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.Name", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.ActorFlags", "eVISUALIZATION" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.DominanceGroup", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.OwnerClient", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.ClientBehaviorBits", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.GlobalPose", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.CMassLocalPose", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.Mass", "1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.MassSpaceInertiaTensor", "1 1 1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.LinearVelocity", "0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.AngularVelocity", "0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.MaxProjectionIterations", "4" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.SeparationTolerance", "0.1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.InternalDriveIterations", "4" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.ExternalDriveIterations", "4" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.SolverIterationCounts.minPositionIters", "4" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.SolverIterationCounts.minVelocityIters", "1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.SleepThreshold", "0.005" )
DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.Name", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Actors.actor0", "8887040" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Actors.actor1", "8887456" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LocalPose.eACTOR0", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LocalPose.eACTOR1", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.BreakForce.force", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.BreakForce.torque", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.ConstraintFlags", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Name", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eX", "eLOCKED" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eY", "eLOCKED" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eZ", "eLOCKED" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eTWIST", "eLOCKED" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eSWING1", "eLOCKED" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eSWING2", "eLOCKED" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.Restitution", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.Spring", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.Damping", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.ContactDistance", "0.05" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.Value", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Restitution", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Spring", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Damping", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.ContactDistance", "0.05" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Upper", "1.5708" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Lower", "-1.5708" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.Restitution", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.Spring", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.Damping", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.ContactDistance", "0.05" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.YAngle", "1.5708" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.ZAngle", "1.5708" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eX.Spring", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eX.Damping", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eX.ForceLimit", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eX.Flags", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eY.Spring", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eY.Damping", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eY.ForceLimit", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eY.Flags", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eZ.Spring", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eZ.Damping", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eZ.ForceLimit", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eZ.Flags", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSWING.Spring", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSWING.Damping", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSWING.ForceLimit", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSWING.Flags", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eTWIST.Spring", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eTWIST.Damping", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eTWIST.ForceLimit", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eTWIST.Flags", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSLERP.Spring", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSLERP.Damping", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSLERP.ForceLimit", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSLERP.Flags", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.DrivePosition", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.DriveVelocity.linear", "0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.DriveVelocity.angular", "0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.ProjectionLinearTolerance", "1e+010" )
DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.ProjectionAngularTolerance", "3.14159" )
DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.Actors.actor0", "8887040" )
DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.Actors.actor1", "8887456" )
DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.LocalPose.eACTOR0", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.LocalPose.eACTOR1", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.BreakForce.force", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.BreakForce.torque", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.ConstraintFlags", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.Name", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.ProjectionLinearTolerance", "1e+010" )
DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.ProjectionAngularTolerance", "3.14159" )
DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Actors.actor0", "8887040" )
DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Actors.actor1", "8887456" )
DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.LocalPose.eACTOR0", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.LocalPose.eACTOR1", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.BreakForce.force", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.BreakForce.torque", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.ConstraintFlags", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Name", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.MinDistance", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.MaxDistance", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Tolerance", "0.025" )
DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Spring", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Damping", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.DistanceJointFlags", "eMAX_DISTANCE_ENABLED" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Actors.actor0", "8887040" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Actors.actor1", "8887456" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.LocalPose.eACTOR0", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.LocalPose.eACTOR1", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.BreakForce.force", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.BreakForce.torque", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.ConstraintFlags", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Name", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Restitution", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Spring", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Damping", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.ContactDistance", "0.05" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Upper", "1.5708" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Lower", "-1.5708" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.DriveVelocity", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.DriveForceLimit", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.DriveGearRatio", "1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.RevoluteJointFlags", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.ProjectionLinearTolerance", "1e+010" )
DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.ProjectionAngularTolerance", "3.14159" )
DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Actors.actor0", "8887040" )
DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Actors.actor1", "8887456" )
DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.LocalPose.eACTOR0", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.LocalPose.eACTOR1", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.BreakForce.force", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.BreakForce.torque", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.ConstraintFlags", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Name", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Restitution", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Spring", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Damping", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.ContactDistance", "0.01" )
DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Upper", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Lower", "-3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.PrismaticJointFlags", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.ProjectionLinearTolerance", "1e+010" )
DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.ProjectionAngularTolerance", "3.14159" )
DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.Actors.actor0", "8887040" )
DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.Actors.actor1", "8887456" )
DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LocalPose.eACTOR0", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LocalPose.eACTOR1", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.BreakForce.force", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.BreakForce.torque", "3.40282e+038" )
DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.ConstraintFlags", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.Name", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.Restitution", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.Spring", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.Damping", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.ContactDistance", "0.05" )
DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.YAngle", "1.5708" )
DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.ZAngle", "1.5708" )
DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.SphericalJointFlags", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.ProjectionLinearTolerance", "1e+010" )
DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.Name", "" )
DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.ActorFlags", "eVISUALIZATION" )
DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.DominanceGroup", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.OwnerClient", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.ClientBehaviorBits", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.MotionConstraintScaleBias.scale", "1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.MotionConstraintScaleBias.bias", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.GlobalPose", "0 0 0 1 0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.ExternalAcceleration", "0 0 0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.DampingCoefficient", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.SolverFrequency", "1" )
DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.SleepLinearVelocity", "0" )
DEFINE_REPX_DEFAULT_PROPERTY("THEEND", "false" )
| 19,802 | C | 71.273722 | 102 | 0.773811 |
NVIDIA-Omniverse/PhysX/physx/source/physxextensions/src/serialization/Xml/SnXmlVisitorWriter.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-2023 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 SN_XML_VISITOR_WRITER_H
#define SN_XML_VISITOR_WRITER_H
#include "foundation/PxInlineArray.h"
#include "RepXMetaDataPropertyVisitor.h"
#include "SnPxStreamOperators.h"
#include "SnXmlMemoryPoolStreams.h"
#include "SnXmlWriter.h"
#include "SnXmlImpl.h"
#include "foundation/PxStrideIterator.h"
namespace physx { namespace Sn {
template<typename TDataType>
inline void writeReference( XmlWriter& writer, PxCollection& inCollection, const char* inPropName, const TDataType* inDatatype )
{
const PxBase* s = static_cast<const PxBase*>( inDatatype ) ;
if( inDatatype && !inCollection.contains( *const_cast<PxBase*>(s) ))
{
PxGetFoundation().error(PxErrorCode::eINTERNAL_ERROR, PX_FL,
"PxSerialization::serializeCollectionToXml: Reference \"%s\" could not be resolved.", inPropName);
}
PxSerialObjectId theId = 0;
if( s )
{
theId = inCollection.getId( *s );
if( theId == 0 )
theId = static_cast<uint64_t>(size_t(inDatatype));
}
writer.write( inPropName, PxCreateRepXObject( inDatatype, theId ) );
}
inline void writeProperty( XmlWriter& inWriter, MemoryBuffer& inBuffer, const char* inProp )
{
PxU8 data = 0;
inBuffer.write( &data, sizeof(PxU8) );
inWriter.write( inProp, reinterpret_cast<const char*>( inBuffer.mBuffer ) );
inBuffer.clear();
}
template<typename TDataType>
inline void writeProperty( XmlWriter& inWriter, PxCollection&, MemoryBuffer& inBuffer, const char* inPropName, TDataType inValue )
{
inBuffer << inValue;
writeProperty( inWriter, inBuffer, inPropName );
}
inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, const PxConvexMesh* inDatatype )
{
writeReference( writer, inCollection, inPropName, inDatatype );
}
inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, PxConvexMesh* inDatatype )
{
writeReference( writer, inCollection, inPropName, inDatatype );
}
inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, const PxTriangleMesh* inDatatype )
{
if (inDatatype->getConcreteType() == PxConcreteType::eTRIANGLE_MESH_BVH33)
{
const PxBVH33TriangleMesh* dataType = inDatatype->is<PxBVH33TriangleMesh>();
writeReference(writer, inCollection, inPropName, dataType);
}
else if (inDatatype->getConcreteType() == PxConcreteType::eTRIANGLE_MESH_BVH34)
{
const PxBVH34TriangleMesh* dataType = inDatatype->is<PxBVH34TriangleMesh>();
writeReference(writer, inCollection, inPropName, dataType);
}
else
{
PX_ASSERT(0);
}
}
inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, PxTriangleMesh* inDatatype )
{
if (inDatatype->getConcreteType() == PxConcreteType::eTRIANGLE_MESH_BVH33)
{
PxBVH33TriangleMesh* dataType = inDatatype->is<PxBVH33TriangleMesh>();
writeReference(writer, inCollection, inPropName, dataType);
}
else if (inDatatype->getConcreteType() == PxConcreteType::eTRIANGLE_MESH_BVH34)
{
PxBVH34TriangleMesh* dataType = inDatatype->is<PxBVH34TriangleMesh>();
writeReference(writer, inCollection, inPropName, dataType);
}
else
{
PX_ASSERT(0);
}
}
inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, const PxBVH33TriangleMesh* inDatatype )
{
writeReference( writer, inCollection, inPropName, inDatatype );
}
inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, PxBVH33TriangleMesh* inDatatype )
{
writeReference( writer, inCollection, inPropName, inDatatype );
}
inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, const PxBVH34TriangleMesh* inDatatype )
{
writeReference( writer, inCollection, inPropName, inDatatype );
}
inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, PxBVH34TriangleMesh* inDatatype )
{
writeReference( writer, inCollection, inPropName, inDatatype );
}
inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, const PxHeightField* inDatatype )
{
writeReference( writer, inCollection, inPropName, inDatatype );
}
inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, PxHeightField* inDatatype )
{
writeReference( writer, inCollection, inPropName, inDatatype );
}
inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, const PxRigidActor* inDatatype )
{
writeReference( writer, inCollection, inPropName, inDatatype );
}
inline void writeProperty(XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, PxArticulationReducedCoordinate* inDatatype)
{
writeReference(writer, inCollection, inPropName, inDatatype);
}
inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, PxRigidActor* inDatatype )
{
writeReference( writer, inCollection, inPropName, inDatatype );
}
inline void writeFlagsProperty( XmlWriter& inWriter, MemoryBuffer& tempBuf, const char* inPropName, PxU32 inFlags, const PxU32ToName* inTable )
{
if ( inTable )
{
PxU32 flagValue( inFlags );
if ( flagValue )
{
for ( PxU32 idx =0; inTable[idx].mName != NULL; ++idx )
{
if ( (inTable[idx].mValue & flagValue) == inTable[idx].mValue )
{
if ( tempBuf.mWriteOffset != 0 )
tempBuf << "|";
tempBuf << inTable[idx].mName;
}
}
writeProperty( inWriter, tempBuf, inPropName );
}
else
{
if ( tempBuf.mWriteOffset != 0 )
tempBuf << "|";
tempBuf << "0";
writeProperty( inWriter, tempBuf, inPropName );
}
}
}
inline void writeFlagsBuffer( MemoryBuffer& tempBuf, PxU32 flagValue, const PxU32ToName* inTable )
{
PX_ASSERT(inTable);
bool added = false;
if ( flagValue )
{
for ( PxU32 item =0; inTable[item].mName != NULL; ++item )
{
if ( (inTable[item].mValue & flagValue) != 0 )
{
if ( added )
tempBuf << "|";
tempBuf << inTable[item].mName;
added = true;
}
}
}
}
inline void writePxVec3( PxOutputStream& inStream, const PxVec3& inVec ) { inStream << inVec; }
template<typename TDataType>
inline const TDataType& PtrAccess( const TDataType* inPtr, PxU32 inIndex )
{
return inPtr[inIndex];
}
template<typename TDataType>
inline void BasicDatatypeWrite( PxOutputStream& inStream, const TDataType& item ) { inStream << item; }
template<typename TObjType, typename TAccessOperator, typename TWriteOperator>
inline void writeBuffer( XmlWriter& inWriter, MemoryBuffer& inTempBuffer
, PxU32 inObjPerLine, const TObjType* inObjType, TAccessOperator inAccessOperator
, PxU32 inBufSize, const char* inPropName, TWriteOperator inOperator )
{
if ( inBufSize && inObjType )
{
for ( PxU32 idx = 0; idx < inBufSize; ++idx )
{
if ( idx && ( idx % inObjPerLine == 0 ) )
inTempBuffer << "\n\t\t\t";
else
inTempBuffer << " ";
inOperator( inTempBuffer, inAccessOperator( inObjType, idx ) );
}
writeProperty( inWriter, inTempBuffer, inPropName );
}
}
template<typename TDataType, typename TAccessOperator, typename TWriteOperator>
inline void writeStrideBuffer( XmlWriter& inWriter, MemoryBuffer& inTempBuffer
, PxU32 inObjPerLine, PxStrideIterator<const TDataType>& inData, TAccessOperator inAccessOperator
, PxU32 inBufSize, const char* inPropName, PxU32 /*inStride*/, TWriteOperator inOperator )
{
#if PX_SWITCH
const auto *dat = &inData[0];
if (inBufSize && dat != NULL)
#else
if ( inBufSize && &inData[0])
#endif
{
for ( PxU32 idx = 0; idx < inBufSize; ++idx )
{
if ( idx && ( idx % inObjPerLine == 0 ) )
inTempBuffer << "\n\t\t\t";
else
inTempBuffer << " ";
inOperator( inTempBuffer, inAccessOperator( &inData[idx], 0 ) );
}
writeProperty( inWriter, inTempBuffer, inPropName );
}
}
template<typename TDataType, typename TAccessOperator>
inline void writeStrideFlags( XmlWriter& inWriter, MemoryBuffer& inTempBuffer
, PxU32 inObjPerLine, PxStrideIterator<const TDataType>& inData, TAccessOperator /*inAccessOperator*/
, PxU32 inBufSize, const char* inPropName, const PxU32ToName* inTable)
{
#if PX_SWITCH
const auto *dat = &inData[0];
if (inBufSize && dat != NULL)
#else
if ( inBufSize && &inData[0])
#endif
{
for ( PxU32 idx = 0; idx < inBufSize; ++idx )
{
writeFlagsBuffer(inTempBuffer, inData[idx], inTable);
if ( idx && ( idx % inObjPerLine == 0 ) )
inTempBuffer << "\n\t\t\t";
else
inTempBuffer << " ";
}
writeProperty( inWriter, inTempBuffer, inPropName );
}
}
template<typename TDataType, typename TWriteOperator>
inline void writeBuffer( XmlWriter& inWriter, MemoryBuffer& inTempBuffer
, PxU32 inObjPerLine, const TDataType* inBuffer
, PxU32 inBufSize, const char* inPropName, TWriteOperator inOperator )
{
writeBuffer( inWriter, inTempBuffer, inObjPerLine, inBuffer, PtrAccess<TDataType>, inBufSize, inPropName, inOperator );
}
template<typename TEnumType>
inline void writeEnumProperty( XmlWriter& inWriter, const char* inPropName, TEnumType inEnumValue, const PxU32ToName* inConversions )
{
PxU32 theValue = static_cast<PxU32>( inEnumValue );
for ( const PxU32ToName* conv = inConversions; conv->mName != NULL; ++conv )
if ( conv->mValue == theValue ) inWriter.write( inPropName, conv->mName );
}
template<typename TObjType, typename TWriterType, typename TInfoType>
inline void handleComplexObj( TWriterType& oldVisitor, const TObjType* inObj, const TInfoType& info);
template<typename TCollectionType, typename TVisitor, typename TPropType, typename TInfoType >
void handleComplexCollection( TVisitor& visitor, const TPropType& inProp, const char* childName, TInfoType& inInfo )
{
PxU32 count( inProp.size( visitor.mObj ) );
if ( count )
{
PxInlineArray<TCollectionType*,5> theData;
theData.resize( count );
inProp.get( visitor.mObj, theData.begin(), count );
for( PxU32 idx =0; idx < count; ++idx )
{
visitor.pushName( childName );
handleComplexObj( visitor, theData[idx], inInfo );
visitor.popName();
}
}
}
template<typename TCollectionType, typename TVisitor, typename TPropType, typename TInfoType >
void handleBufferCollection( TVisitor& visitor, const TPropType& inProp, const char* childName, TInfoType& inInfo )
{
PxU32 count( inProp.size( visitor.mObj ) );
if ( count )
{
PxInlineArray<TCollectionType*,5> theData;
theData.resize( count );
inProp.get( visitor.mObj, theData.begin());
for( PxU32 idx =0; idx < count; ++idx )
{
visitor.pushName( childName );
handleComplexObj( visitor, theData[idx], inInfo );
visitor.popName();
}
}
}
template<typename TVisitor>
void handleShapes( TVisitor& visitor, const PxRigidActorShapeCollection& inProp )
{
PxShapeGeneratedInfo theInfo;
PxU32 count( inProp.size( visitor.mObj ) );
if ( count )
{
PxInlineArray<PxShape*,5> theData;
theData.resize( count );
inProp.get( visitor.mObj, theData.begin(), count );
for( PxU32 idx = 0; idx < count; ++idx )
{
const PxShape* shape = theData[idx];
visitor.pushName( "PxShape" );
if( !shape->isExclusive() )
{
writeReference( visitor.mWriter, visitor.mCollection, "PxShapeRef", shape );
}
else
{
handleComplexObj( visitor, shape, theInfo );
}
visitor.popName();
}
}
}
template<typename TVisitor>
void handleShapeMaterials( TVisitor& visitor, const PxShapeMaterialsProperty& inProp )
{
PxU32 count( inProp.size( visitor.mObj ) );
if ( count )
{
PxInlineArray<PxMaterial*,5> theData;
theData.resize( count );
inProp.get( visitor.mObj, theData.begin(), count );
visitor.pushName( "PxMaterialRef" );
for( PxU32 idx =0; idx < count; ++idx )
writeReference( visitor.mWriter, visitor.mCollection, "PxMaterialRef", theData[idx] );
visitor.popName();
}
}
template<typename TObjType>
struct RepXVisitorWriterBase
{
TNameStack& mNameStack;
XmlWriter& mWriter;
const TObjType* mObj;
MemoryBuffer& mTempBuffer;
PxCollection& mCollection;
RepXVisitorWriterBase( TNameStack& ns, XmlWriter& writer, const TObjType* obj, MemoryBuffer& buf, PxCollection& collection )
: mNameStack( ns )
, mWriter( writer )
, mObj( obj )
, mTempBuffer( buf )
, mCollection( collection )
{
}
RepXVisitorWriterBase( const RepXVisitorWriterBase<TObjType>& other )
: mNameStack( other.mNameStack )
, mWriter( other.mWriter )
, mObj( other.mObj )
, mTempBuffer( other.mTempBuffer )
, mCollection( other.mCollection )
{
}
RepXVisitorWriterBase& operator=( const RepXVisitorWriterBase& ){ PX_ASSERT( false ); return *this; }
void gotoTopName()
{
if ( mNameStack.size() && mNameStack.back().mOpen == false )
{
mWriter.addAndGotoChild( mNameStack.back().mName );
mNameStack.back().mOpen = true;
}
}
void pushName( const char* inName )
{
gotoTopName();
mNameStack.pushBack( inName );
}
void pushBracketedName( const char* inName ) { pushName( inName ); }
void popName()
{
if ( mNameStack.size() )
{
if ( mNameStack.back().mOpen )
mWriter.leaveChild();
mNameStack.popBack();
}
}
const char* topName() const
{
if ( mNameStack.size() ) return mNameStack.back().mName;
PX_ASSERT( false );
return "bad__repx__name";
}
template<typename TAccessorType>
void simpleProperty( PxU32 /*key*/, TAccessorType& inProp )
{
typedef typename TAccessorType::prop_type TPropertyType;
TPropertyType propVal = inProp.get( mObj );
writeProperty( mWriter, mCollection, mTempBuffer, topName(), propVal );
}
template<typename TAccessorType>
void enumProperty( PxU32 /*key*/, TAccessorType& inProp, const PxU32ToName* inConversions )
{
writeEnumProperty( mWriter, topName(), inProp.get( mObj ), inConversions );
}
template<typename TAccessorType>
void flagsProperty( PxU32 /*key*/, const TAccessorType& inProp, const PxU32ToName* inConversions )
{
writeFlagsProperty( mWriter, mTempBuffer, topName(), inProp.get( mObj ), inConversions );
}
template<typename TAccessorType, typename TInfoType>
void complexProperty( PxU32* /*key*/, const TAccessorType& inProp, TInfoType& inInfo )
{
typedef typename TAccessorType::prop_type TPropertyType;
TPropertyType propVal = inProp.get( mObj );
handleComplexObj( *this, &propVal, inInfo );
}
template<typename TAccessorType, typename TInfoType>
void bufferCollectionProperty( PxU32* /*key*/, const TAccessorType& inProp, TInfoType& inInfo )
{
typedef typename TAccessorType::prop_type TPropertyType;
PxU32 count( inProp.size( mObj ) );
PxInlineArray<TPropertyType,5> theData;
theData.resize( count );
PxClassInfoTraits<TInfoType> theTraits;
PX_UNUSED(theTraits);
PxU32 numItems = inProp.get( mObj, theData.begin(), count );
PX_ASSERT( numItems == count );
for( PxU32 idx =0; idx < numItems; ++idx )
{
pushName( inProp.name() );
handleComplexObj( *this, &theData[idx], inInfo );
popName();
}
}
template<typename TAccessorType, typename TInfoType>
void extendedIndexedProperty( PxU32* /*key*/, const TAccessorType& inProp, TInfoType& /*inInfo */)
{
typedef typename TAccessorType::prop_type TPropertyType;
PxU32 count( inProp.size( mObj ) );
PxInlineArray<TPropertyType,5> theData;
theData.resize( count );
for(PxU32 i = 0; i < count; ++i)
{
char buffer[32] = { 0 };
sprintf( buffer, "id_%u", i );
pushName( buffer );
TPropertyType propVal = inProp.get( mObj, i );
TInfoType& infoType = PxClassInfoTraits<TPropertyType>().Info;
handleComplexObj(*this, &propVal, infoType);
popName();
}
}
template<typename TAccessorType, typename TInfoType>
void PxFixedSizeLookupTableProperty( PxU32* /*key*/, TAccessorType& inProp, TInfoType& /*inInfo */)
{
typedef typename TAccessorType::prop_type TPropertyType;
PxU32 count( inProp.size( mObj ) );
PxU32 index = 0;
for(PxU32 i = 0; i < count; ++i)
{
char buffer[32] = { 0 };
sprintf( buffer, "id_%u", index++ );
pushName( buffer );
TPropertyType propVal = inProp.getX( mObj , i);
writeProperty( mWriter, mCollection, mTempBuffer, topName(), propVal );
popName();
sprintf( buffer, "id_%u", index++ );
pushName( buffer );
propVal = inProp.getY( mObj , i);
writeProperty( mWriter, mCollection, mTempBuffer, topName(), propVal );
popName();
}
}
void handleShapes( const PxRigidActorShapeCollection& inProp )
{
physx::Sn::handleShapes( *this, inProp );
}
void handleShapeMaterials( const PxShapeMaterialsProperty& inProp )
{
physx::Sn::handleShapeMaterials( *this, inProp );
}
void handleRigidActorGlobalPose(const PxRigidActorGlobalPosePropertyInfo& inProp)
{
PxRepXPropertyAccessor<PxPropertyInfoName::PxRigidActor_GlobalPose, PxRigidActor, const PxTransform &, PxTransform> theAccessor(inProp);
simpleProperty(PxPropertyInfoName::PxRigidActor_GlobalPose, theAccessor);
}
};
template<typename TObjType>
struct RepXVisitorWriter : RepXVisitorWriterBase<TObjType>
{
RepXVisitorWriter( TNameStack& ns, XmlWriter& writer, const TObjType* obj, MemoryBuffer& buf, PxCollection& collection )
: RepXVisitorWriterBase<TObjType>( ns, writer, obj, buf, collection )
{
}
RepXVisitorWriter( const RepXVisitorWriter<TObjType>& other )
: RepXVisitorWriterBase<TObjType>( other )
{
}
};
template<>
struct RepXVisitorWriter<PxArticulationLink> : RepXVisitorWriterBase<PxArticulationLink>
{
RepXVisitorWriter( TNameStack& ns, XmlWriter& writer, const PxArticulationLink* obj, MemoryBuffer& buf, PxCollection& collection )
: RepXVisitorWriterBase<PxArticulationLink>( ns, writer, obj, buf, collection )
{
}
RepXVisitorWriter( const RepXVisitorWriter<PxArticulationLink>& other )
: RepXVisitorWriterBase<PxArticulationLink>( other )
{
}
void handleIncomingJoint( const TIncomingJointPropType& prop )
{
const PxArticulationJointReducedCoordinate* joint( prop.get( mObj ) );
if (joint)
{
pushName( "Joint" );
handleComplexObj( *this, joint, PxArticulationJointReducedCoordinateGeneratedInfo());
popName();
}
}
};
typedef PxProfileHashMap< const PxSerialObjectId, const PxArticulationLink* > TArticulationLinkLinkMap;
static void recurseAddLinkAndChildren( const PxArticulationLink* inLink, PxInlineArray<const PxArticulationLink*, 64>& ioLinks )
{
ioLinks.pushBack( inLink );
PxInlineArray<PxArticulationLink*, 8> theChildren;
PxU32 childCount( inLink->getNbChildren() );
theChildren.resize( childCount );
inLink->getChildren( theChildren.begin(), childCount );
for ( PxU32 idx = 0; idx < childCount; ++idx )
recurseAddLinkAndChildren( theChildren[idx], ioLinks );
}
template<>
struct RepXVisitorWriter<PxArticulationReducedCoordinate> : RepXVisitorWriterBase<PxArticulationReducedCoordinate>
{
TArticulationLinkLinkMap& mArticulationLinkParents;
RepXVisitorWriter(TNameStack& ns, XmlWriter& writer, const PxArticulationReducedCoordinate* inArticulation, MemoryBuffer& buf, PxCollection& collection, TArticulationLinkLinkMap* artMap = NULL)
: RepXVisitorWriterBase<PxArticulationReducedCoordinate>(ns, writer, inArticulation, buf, collection)
, mArticulationLinkParents(*artMap)
{
PxInlineArray<PxArticulationLink*, 64, PxProfileWrapperReflectionAllocator<PxArticulationLink*> > linkList(PxProfileWrapperReflectionAllocator<PxArticulationLink*>(buf.mManager->getWrapper()));
PxU32 numLinks = inArticulation->getNbLinks();
linkList.resize(numLinks);
inArticulation->getLinks(linkList.begin(), numLinks);
for (PxU32 idx = 0; idx < numLinks; ++idx)
{
const PxArticulationLink* theLink(linkList[idx]);
PxInlineArray<PxArticulationLink*, 64> theChildList;
PxU32 numChildren = theLink->getNbChildren();
theChildList.resize(numChildren);
theLink->getChildren(theChildList.begin(), numChildren);
for (PxU32 childIdx = 0; childIdx < numChildren; ++childIdx)
mArticulationLinkParents.insert(static_cast<uint64_t>(size_t(theChildList[childIdx])), theLink);
}
}
RepXVisitorWriter(const RepXVisitorWriter<PxArticulationReducedCoordinate>& other)
: RepXVisitorWriterBase<PxArticulationReducedCoordinate>(other)
, mArticulationLinkParents(other.mArticulationLinkParents)
{
}
template<typename TAccessorType, typename TInfoType>
void complexProperty(PxU32* /*key*/, const TAccessorType& inProp, TInfoType& inInfo)
{
typedef typename TAccessorType::prop_type TPropertyType;
TPropertyType propVal = inProp.get(mObj);
handleComplexObj(*this, &propVal, inInfo);
}
void writeArticulationLink(const PxArticulationLink* inLink)
{
pushName("PxArticulationLink");
gotoTopName();
const TArticulationLinkLinkMap::Entry* theParentPtr = mArticulationLinkParents.find(static_cast<uint64_t>(size_t(inLink)));
if (theParentPtr != NULL)
writeProperty(mWriter, mCollection, mTempBuffer, "Parent", theParentPtr->second);
writeProperty(mWriter, mCollection, mTempBuffer, "Id", inLink);
PxArticulationLinkGeneratedInfo info;
handleComplexObj(*this, inLink, info);
popName();
}
void handleArticulationLinks(const PxArticulationLinkCollectionProp& inProp)
{
//topologically sort the links as per my discussion with Dilip because
//links aren't guaranteed to have the parents before the children in the
//overall link list and it is unlikely to be done by beta 1.
PxU32 count(inProp.size(mObj));
if (count)
{
PxInlineArray<PxArticulationLink*, 64> theLinks;
theLinks.resize(count);
inProp.get(mObj, theLinks.begin(), count);
PxInlineArray<const PxArticulationLink*, 64> theSortedLinks;
for (PxU32 idx = 0; idx < count; ++idx)
{
const PxArticulationLink* theLink(theLinks[idx]);
if (mArticulationLinkParents.find(static_cast<uint64_t>(size_t(theLink))) == NULL)
recurseAddLinkAndChildren(theLink, theSortedLinks);
}
PX_ASSERT(theSortedLinks.size() == count);
for (PxU32 idx = 0; idx < count; ++idx)
writeArticulationLink(theSortedLinks[idx]);
popName();
}
}
private:
RepXVisitorWriter<PxArticulationReducedCoordinate>& operator=(const RepXVisitorWriter<PxArticulationReducedCoordinate>&);
};
template<>
struct RepXVisitorWriter<PxShape> : RepXVisitorWriterBase<PxShape>
{
RepXVisitorWriter( TNameStack& ns, XmlWriter& writer, const PxShape* obj, MemoryBuffer& buf, PxCollection& collection )
: RepXVisitorWriterBase<PxShape>( ns, writer, obj, buf, collection )
{
}
RepXVisitorWriter( const RepXVisitorWriter<PxShape>& other )
: RepXVisitorWriterBase<PxShape>( other )
{
}
template<typename GeometryType>
inline void writeGeomProperty( const PxShapeGeomProperty& inProp, const char* inTypeName )
{
pushName( "Geometry" );
pushName( inTypeName );
GeometryType theType;
inProp.getGeometry( mObj, theType );
PxClassInfoTraits<GeometryType> theTraits;
PxU32 count = theTraits.Info.totalPropertyCount();
if(count)
{
handleComplexObj( *this, &theType, theTraits.Info);
}
else
{
writeProperty(mWriter, mTempBuffer, inTypeName);
}
popName();
popName();
}
void handleGeomProperty( const PxShapeGeomProperty& inProp )
{
switch( mObj->getGeometry().getType() )
{
case PxGeometryType::eSPHERE: writeGeomProperty<PxSphereGeometry>( inProp, "PxSphereGeometry" ); break;
case PxGeometryType::ePLANE: writeGeomProperty<PxPlaneGeometry>( inProp, "PxPlaneGeometry" ); break;
case PxGeometryType::eCAPSULE: writeGeomProperty<PxCapsuleGeometry>( inProp, "PxCapsuleGeometry" ); break;
case PxGeometryType::eBOX: writeGeomProperty<PxBoxGeometry>( inProp, "PxBoxGeometry" ); break;
case PxGeometryType::eCONVEXMESH: writeGeomProperty<PxConvexMeshGeometry>( inProp, "PxConvexMeshGeometry" ); break;
case PxGeometryType::eTRIANGLEMESH: writeGeomProperty<PxTriangleMeshGeometry>( inProp, "PxTriangleMeshGeometry" ); break;
case PxGeometryType::eHEIGHTFIELD: writeGeomProperty<PxHeightFieldGeometry>( inProp, "PxHeightFieldGeometry" ); break;
case PxGeometryType::eTETRAHEDRONMESH: writeGeomProperty<PxTetrahedronMeshGeometry>( inProp, "PxTetrahedronMeshGeometry" ); break;
default:
PX_ASSERT( false );
}
}
};
template<typename TObjType>
inline void writeAllProperties( TNameStack& inNameStack, const TObjType* inObj, XmlWriter& writer, MemoryBuffer& buffer, PxCollection& collection )
{
RepXVisitorWriter<TObjType> newVisitor( inNameStack, writer, inObj, buffer, collection );
RepXPropertyFilter<RepXVisitorWriter<TObjType> > theOp( newVisitor );
PxClassInfoTraits<TObjType> info;
info.Info.visitBaseProperties( theOp );
info.Info.visitInstanceProperties( theOp );
}
template<typename TObjType>
inline void writeAllProperties( TNameStack& inNameStack, TObjType* inObj, XmlWriter& writer, MemoryBuffer& buffer, PxCollection& collection )
{
RepXVisitorWriter<TObjType> newVisitor( inNameStack, writer, inObj, buffer, collection );
RepXPropertyFilter<RepXVisitorWriter<TObjType> > theOp( newVisitor );
PxClassInfoTraits<TObjType> info;
info.Info.visitBaseProperties( theOp );
info.Info.visitInstanceProperties( theOp );
}
template<typename TObjType>
inline void writeAllProperties( const TObjType* inObj, XmlWriter& writer, MemoryBuffer& buffer, PxCollection& collection )
{
TNameStack theNames( buffer.mManager->getWrapper() );
writeAllProperties( theNames, inObj, writer, buffer, collection );
}
template<typename TObjType, typename TWriterType, typename TInfoType>
inline void handleComplexObj( TWriterType& oldVisitor, const TObjType* inObj, const TInfoType& /*info*/)
{
writeAllProperties( oldVisitor.mNameStack, inObj, oldVisitor.mWriter, oldVisitor.mTempBuffer, oldVisitor.mCollection );
}
template<typename TObjType, typename TWriterType>
inline void handleComplexObj( TWriterType& oldVisitor, const TObjType* inObj, const PxUnknownClassInfo& /*info*/)
{
writeProperty( oldVisitor.mWriter, oldVisitor.mCollection, oldVisitor.mTempBuffer, oldVisitor.topName(), *inObj );
}
} }
#endif
| 28,548 | C | 34.332921 | 196 | 0.722713 |
NVIDIA-Omniverse/PhysX/physx/source/physxextensions/src/serialization/Xml/SnXmlSerialization.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "SnXmlImpl.h"
#include "foundation/PxHash.h"
#include "foundation/PxHashMap.h"
#include "foundation/PxString.h"
#include "SnSimpleXmlWriter.h"
#include "foundation/PxSort.h"
#include "PsFastXml.h"
#include "SnXmlMemoryPool.h"
#include "PxExtensionMetaDataObjects.h"
#include "SnXmlVisitorWriter.h"
#include "SnXmlVisitorReader.h"
#include "SnXmlMemoryAllocator.h"
#include "SnXmlStringToType.h"
#include "SnRepXCollection.h"
#include "SnRepXUpgrader.h"
#include "../SnSerializationRegistry.h"
#include "CmCollection.h"
using namespace physx;
using namespace Sn;
using namespace physx::profile; //for the foundation wrapper system.
namespace physx { namespace Sn {
class XmlNodeWriter : public SimpleXmlWriter
{
XmlMemoryAllocatorImpl& mParseAllocator;
XmlNode* mCurrentNode;
XmlNode* mTopNode;
PxU32 mTabCount;
public:
XmlNodeWriter( XmlMemoryAllocatorImpl& inAllocator, PxU32 inTabCount = 0 )
: mParseAllocator( inAllocator )
, mCurrentNode( NULL )
, mTopNode( NULL )
, mTabCount( inTabCount )
{}
XmlNodeWriter& operator=(const XmlNodeWriter&);
virtual ~XmlNodeWriter(){}
void onNewNode( XmlNode* newNode )
{
if ( mCurrentNode != NULL )
mCurrentNode->addChild( newNode );
if ( mTopNode == NULL )
mTopNode = newNode;
mCurrentNode = newNode;
++mTabCount;
}
XmlNode* getTopNode() const { return mTopNode; }
virtual void beginTag( const char* inTagname )
{
onNewNode( allocateRepXNode( &mParseAllocator.mManager, inTagname, NULL ) );
}
virtual void endTag()
{
if ( mCurrentNode )
mCurrentNode = mCurrentNode->mParent;
if ( mTabCount )
--mTabCount;
}
virtual void addAttribute( const char*, const char* )
{
PX_ASSERT( false );
}
virtual void writeContentTag( const char* inTag, const char* inContent )
{
onNewNode( allocateRepXNode( &mParseAllocator.mManager, inTag, inContent ) );
endTag();
}
virtual void addContent( const char* inContent )
{
if ( mCurrentNode->mData )
releaseStr( &mParseAllocator.mManager, mCurrentNode->mData );
mCurrentNode->mData = copyStr( &mParseAllocator.mManager, inContent );
}
virtual PxU32 tabCount() { return mTabCount; }
};
struct XmlWriterImpl : public XmlWriter
{
PxU32 mTagDepth;
SimpleXmlWriter* mWriter;
MemoryBuffer* mMemBuffer;
XmlWriterImpl( SimpleXmlWriter* inWriter, MemoryBuffer* inMemBuffer )
: mTagDepth( 0 )
, mWriter( inWriter )
, mMemBuffer( inMemBuffer )
{
}
~XmlWriterImpl()
{
while( mTagDepth )
{
--mTagDepth;
mWriter->endTag();
}
}
virtual void write( const char* inName, const char* inData )
{
mWriter->writeContentTag( inName, inData );
}
virtual void write( const char* inName, const PxRepXObject& inLiveObject )
{
(*mMemBuffer) << inLiveObject.id;
writeProperty( *mWriter, *mMemBuffer, inName );
}
virtual void addAndGotoChild( const char* inName )
{
mWriter->beginTag( inName );
mTagDepth++;
}
virtual void leaveChild()
{
if ( mTagDepth )
{
mWriter->endTag();
--mTagDepth;
}
}
};
struct XmlParseArgs
{
XmlMemoryAllocatorImpl* mAllocator;
PxProfileArray<RepXCollectionItem>* mCollection;
XmlParseArgs( XmlMemoryAllocatorImpl* inAllocator
, PxProfileArray<RepXCollectionItem>* inCollection)
: mAllocator( inAllocator )
, mCollection( inCollection )
{
}
};
struct XmlNodeReader : public XmlReaderWriter
{
PxProfileAllocatorWrapper mWrapper;
CMemoryPoolManager& mManager;
XmlNode* mCurrentNode;
XmlNode* mTopNode;
PxProfileArray<XmlNode*> mContext;
XmlNodeReader( XmlNode* inCurrentNode, PxAllocatorCallback& inAllocator, CMemoryPoolManager& nodePoolManager )
: mWrapper( inAllocator )
, mManager( nodePoolManager )
, mCurrentNode( inCurrentNode )
, mTopNode( inCurrentNode )
, mContext( mWrapper )
{
}
//Does this node exist as data in the format.
virtual bool read( const char* inName, const char*& outData )
{
XmlNode* theChild( mCurrentNode->findChildByName( inName ) );
if ( theChild )
{
outData = theChild->mData;
return outData && *outData;
}
return false;
}
virtual bool read( const char* inName, PxSerialObjectId& outId )
{
XmlNode* theChild( mCurrentNode->findChildByName( inName ) );
if ( theChild )
{
const char* theValue( theChild->mData );
strto( outId, theValue );
return true;
}
return false;
}
virtual bool gotoChild( const char* inName )
{
XmlNode* theChild( mCurrentNode->findChildByName( inName ) );
if ( theChild )
{
mCurrentNode =theChild;
return true;
}
return false;
}
virtual bool gotoFirstChild()
{
if ( mCurrentNode->mFirstChild )
{
mCurrentNode = mCurrentNode->mFirstChild;
return true;
}
return false;
}
virtual bool gotoNextSibling()
{
if ( mCurrentNode->mNextSibling )
{
mCurrentNode = mCurrentNode->mNextSibling;
return true;
}
return false;
}
virtual PxU32 countChildren()
{
PxU32 retval= 0;
for ( XmlNode* theChild = mCurrentNode->mFirstChild; theChild != NULL; theChild = theChild->mNextSibling )
++retval;
return retval;
}
virtual const char* getCurrentItemName()
{
return mCurrentNode->mName;
}
virtual const char* getCurrentItemValue()
{
return mCurrentNode->mData;
}
virtual bool leaveChild()
{
if ( mCurrentNode != mTopNode && mCurrentNode->mParent )
{
mCurrentNode = mCurrentNode->mParent;
return true;
}
return false;
}
virtual void pushCurrentContext()
{
mContext.pushBack( mCurrentNode );
}
virtual void popCurrentContext()
{
if ( mContext.size() )
{
mCurrentNode = mContext.back();
mContext.popBack();
}
}
virtual void setNode( XmlNode& inNode )
{
mContext.clear();
mCurrentNode = &inNode;
mTopNode = mCurrentNode;
}
virtual XmlReader* getParentReader()
{
XmlReader* retval = PX_PLACEMENT_NEW((mWrapper.getAllocator().allocate(sizeof(XmlNodeReader), "createNodeEditor", PX_FL)), XmlNodeReader)
( mTopNode, mWrapper.getAllocator(), mManager );
return retval;
}
virtual void addOrGotoChild( const char* inName )
{
if ( gotoChild( inName )== false )
{
XmlNode* newNode = allocateRepXNode( &mManager, inName, NULL );
mCurrentNode->addChild( newNode );
mCurrentNode = newNode;
}
}
virtual void setCurrentItemValue( const char* inValue )
{
mCurrentNode->mData = copyStr( &mManager, inValue );
}
virtual bool removeChild( const char* name )
{
XmlNode* theChild( mCurrentNode->findChildByName( name ) );
if ( theChild )
{
releaseNodeAndChildren( &mManager, theChild );
return true;
}
return false;
}
virtual void release() { this->~XmlNodeReader(); mWrapper.getAllocator().deallocate(this); }
private:
XmlNodeReader& operator=(const XmlNodeReader&);
};
PX_INLINE void freeNodeAndChildren( XmlNode* tempNode, TMemoryPoolManager& inManager )
{
for( XmlNode* theNode = tempNode->mFirstChild; theNode != NULL; theNode = theNode->mNextSibling )
freeNodeAndChildren( theNode, inManager );
tempNode->orphan();
release( &inManager, tempNode );
}
class XmlParser : public shdfnd::FastXml::Callback
{
XmlParseArgs mParseArgs;
//For parse time only allocations
XmlMemoryAllocatorImpl& mParseAllocator;
XmlNode* mCurrentNode;
XmlNode* mTopNode;
public:
XmlParser( XmlParseArgs inArgs, XmlMemoryAllocatorImpl& inParseAllocator )
: mParseArgs( inArgs )
, mParseAllocator( inParseAllocator )
, mCurrentNode( NULL )
, mTopNode( NULL )
{
}
virtual ~XmlParser(){}
virtual bool processComment(const char* /*comment*/) { return true; }
// 'element' is the name of the element that is being closed.
// depth is the recursion depth of this element.
// Return true to continue processing the XML file.
// Return false to stop processing the XML file; leaves the read pointer of the stream right after this close tag.
// The bool 'isError' indicates whether processing was stopped due to an error, or intentionally canceled early.
virtual bool processClose(const char* /*element*/,physx::PxU32 /*depth*/,bool& isError)
{
if (NULL != mCurrentNode)
{
mCurrentNode = mCurrentNode->mParent;
return true;
}
isError = true;
return false;
}
// return true to continue processing the XML document, false to skip.
virtual bool processElement(
const char *elementName, // name of the element
const char *elementData, // element data, null if none
const shdfnd::FastXml::AttributePairs& attr, // attributes
PxI32 /*lineno*/)
{
XmlNode* newNode = allocateRepXNode( &mParseAllocator.mManager, elementName, elementData );
if ( mCurrentNode )
mCurrentNode->addChild( newNode );
mCurrentNode = newNode;
//Add the elements as children.
for( PxI32 item = 0; item < attr.getNbAttr(); item ++ )
{
XmlNode* node = allocateRepXNode( &mParseAllocator.mManager, attr.getKey(PxU32(item)), attr.getValue(PxU32(item)) );
mCurrentNode->addChild( node );
}
if ( mTopNode == NULL ) mTopNode = newNode;
return true;
}
XmlNode* getTopNode() { return mTopNode; }
virtual void * allocate(PxU32 size)
{
if ( size )
return mParseAllocator.allocate(size);
return NULL;
}
virtual void deallocate(void *mem)
{
if ( mem )
mParseAllocator.deallocate(reinterpret_cast<PxU8*>(mem));
}
private:
XmlParser& operator=(const XmlParser&);
};
struct RepXCollectionSharedData
{
PxProfileAllocatorWrapper mWrapper;
XmlMemoryAllocatorImpl mAllocator;
PxU32 mRefCount;
RepXCollectionSharedData( PxAllocatorCallback& inAllocator )
: mWrapper( inAllocator )
, mAllocator( inAllocator )
, mRefCount( 0 )
{
}
~RepXCollectionSharedData() {}
void addRef() { ++mRefCount;}
void release()
{
if ( mRefCount ) --mRefCount;
if ( !mRefCount ) { this->~RepXCollectionSharedData(); mWrapper.getAllocator().deallocate(this);}
}
};
struct SharedDataPtr
{
RepXCollectionSharedData* mData;
SharedDataPtr( RepXCollectionSharedData* inData )
: mData( inData )
{
mData->addRef();
}
SharedDataPtr( const SharedDataPtr& inOther )
: mData( inOther.mData )
{
mData->addRef();
}
SharedDataPtr& operator=( const SharedDataPtr& inOther );
~SharedDataPtr()
{
mData->release();
mData = NULL;
}
RepXCollectionSharedData* operator->() { return mData; }
const RepXCollectionSharedData* operator->() const { return mData; }
};
class RepXCollectionImpl : public RepXCollection, public PxUserAllocated
{
SharedDataPtr mSharedData;
XmlMemoryAllocatorImpl& mAllocator;
PxSerializationRegistry& mSerializationRegistry;
PxProfileArray<RepXCollectionItem> mCollection;
TMemoryPoolManager mSerializationManager;
MemoryBuffer mPropertyBuffer;
PxTolerancesScale mScale;
PxVec3 mUpVector;
const char* mVersionStr;
PxCollection* mPxCollection;
public:
RepXCollectionImpl( PxSerializationRegistry& inRegistry, PxAllocatorCallback& inAllocator, PxCollection& inPxCollection )
: mSharedData( &PX_NEW_REPX_SERIALIZER( RepXCollectionSharedData ))
, mAllocator( mSharedData->mAllocator )
, mSerializationRegistry( inRegistry )
, mCollection( mSharedData->mWrapper )
, mSerializationManager( inAllocator )
, mPropertyBuffer( &mSerializationManager )
, mScale(0.f, 0.f)
, mUpVector( 0,0,0 )
, mVersionStr( getLatestVersion() )
, mPxCollection( &inPxCollection )
{
PX_ASSERT( mScale.isValid() == false );
}
RepXCollectionImpl( PxSerializationRegistry& inRegistry, const RepXCollectionImpl& inSrc, const char* inNewVersion )
: mSharedData( inSrc.mSharedData )
, mAllocator( mSharedData->mAllocator )
, mSerializationRegistry( inRegistry )
, mCollection( mSharedData->mWrapper )
, mSerializationManager( mSharedData->mWrapper.getAllocator() )
, mPropertyBuffer( &mSerializationManager )
, mScale( inSrc.mScale )
, mUpVector( inSrc.mUpVector )
, mVersionStr( inNewVersion )
, mPxCollection( NULL )
{
}
virtual ~RepXCollectionImpl()
{
PxU32 numItems = mCollection.size();
for ( PxU32 idx = 0; idx < numItems; ++idx )
{
XmlNode* theNode = mCollection[idx].descriptor;
releaseNodeAndChildren( &mAllocator.mManager, theNode );
}
}
RepXCollectionImpl& operator=(const RepXCollectionImpl&);
virtual void destroy()
{
PxProfileAllocatorWrapper tempWrapper( mSharedData->mWrapper.getAllocator() );
this->~RepXCollectionImpl();
tempWrapper.getAllocator().deallocate(this);
}
virtual void setTolerancesScale(const PxTolerancesScale& inScale) { mScale = inScale; }
virtual PxTolerancesScale getTolerancesScale() const { return mScale; }
virtual void setUpVector( const PxVec3& inUpVector ) { mUpVector = inUpVector; }
virtual PxVec3 getUpVector() const { return mUpVector; }
PX_INLINE RepXCollectionItem findItemBySceneItem( const PxRepXObject& inObject ) const
{
//See if the object is in the collection
for ( PxU32 idx =0; idx < mCollection.size(); ++idx )
if ( mCollection[idx].liveObject.serializable == inObject.serializable )
return mCollection[idx];
return RepXCollectionItem();
}
virtual RepXAddToCollectionResult addRepXObjectToCollection( const PxRepXObject& inObject, PxCollection* inCollection, PxRepXInstantiationArgs& inArgs )
{
PX_ASSERT( inObject.serializable );
PX_ASSERT( inObject.id );
if ( inObject.serializable == NULL || inObject.id == 0 )
return RepXAddToCollectionResult( RepXAddToCollectionResult::InvalidParameters );
PxRepXSerializer* theSerializer = mSerializationRegistry.getRepXSerializer( inObject.typeName );
if ( theSerializer == NULL )
return RepXAddToCollectionResult( RepXAddToCollectionResult::SerializerNotFound );
RepXCollectionItem existing = findItemBySceneItem( inObject );
if ( existing.liveObject.serializable )
return RepXAddToCollectionResult( RepXAddToCollectionResult::AlreadyInCollection, existing.liveObject.id );
XmlNodeWriter theXmlWriter( mAllocator, 1 );
XmlWriterImpl theRepXWriter( &theXmlWriter, &mPropertyBuffer );
{
SimpleXmlWriter::STagWatcher theWatcher( theXmlWriter, inObject.typeName );
writeProperty( theXmlWriter, mPropertyBuffer, "Id", inObject.id );
theSerializer->objectToFile( inObject, inCollection, theRepXWriter, mPropertyBuffer,inArgs );
}
mCollection.pushBack( RepXCollectionItem( inObject, theXmlWriter.getTopNode() ) );
return RepXAddToCollectionResult( RepXAddToCollectionResult::Success, inObject.id );
}
virtual bool instantiateCollection( PxRepXInstantiationArgs& inArgs, PxCollection& inCollection )
{
for ( PxU32 idx =0; idx < mCollection.size(); ++idx )
{
RepXCollectionItem theItem( mCollection[idx] );
PxRepXSerializer* theSerializer = mSerializationRegistry.getRepXSerializer( theItem.liveObject.typeName );
if (theSerializer )
{
XmlNodeReader theReader( theItem.descriptor, mAllocator.getAllocator(), mAllocator.mManager );
XmlMemoryAllocatorImpl instantiationAllocator( mAllocator.getAllocator() );
PxRepXObject theLiveObject = theSerializer->fileToObject( theReader, instantiationAllocator, inArgs, &inCollection );
if (theLiveObject.isValid())
{
const PxBase* s = reinterpret_cast<const PxBase*>( theLiveObject.serializable ) ;
inCollection.add( *const_cast<PxBase*>(s), PxSerialObjectId( theItem.liveObject.id ));
}
else
return false;
}
else
{
PxGetFoundation().error(PxErrorCode::eINTERNAL_ERROR, PX_FL,
"PxSerialization::createCollectionFromXml: "
"PxRepXSerializer missing for type %s", theItem.liveObject.typeName);
return false;
}
}
return true;
}
void saveXmlNode( XmlNode* inNode, SimpleXmlWriter& inWriter )
{
XmlNode* theNode( inNode );
if ( theNode->mData && *theNode->mData && theNode->mFirstChild == NULL )
inWriter.writeContentTag( theNode->mName, theNode->mData );
else
{
inWriter.beginTag( theNode->mName );
if ( theNode->mData && *theNode->mData )
inWriter.addContent( theNode->mData );
for ( XmlNode* theChild = theNode->mFirstChild;
theChild != NULL;
theChild = theChild->mNextSibling )
saveXmlNode( theChild, inWriter );
inWriter.endTag();
}
}
virtual void save( PxOutputStream& inStream )
{
SimpleXmlWriterImpl<PxOutputStream> theWriter( inStream, mAllocator.getAllocator() );
theWriter.beginTag( "PhysXCollection" );
theWriter.addAttribute( "version", mVersionStr );
{
XmlWriterImpl theRepXWriter( &theWriter, &mPropertyBuffer );
writeProperty( theWriter, mPropertyBuffer, "UpVector", mUpVector );
theRepXWriter.addAndGotoChild( "Scale" );
writeAllProperties( &mScale, theRepXWriter, mPropertyBuffer, *mPxCollection);
theRepXWriter.leaveChild();
}
for ( PxU32 idx =0; idx < mCollection.size(); ++idx )
{
RepXCollectionItem theItem( mCollection[idx] );
XmlNode* theNode( theItem.descriptor );
saveXmlNode( theNode, theWriter );
}
}
void load( PxInputData& inFileBuf, SerializationRegistry& s )
{
inFileBuf.seek(0);
XmlParser theParser( XmlParseArgs( &mAllocator, &mCollection ), mAllocator );
shdfnd::FastXml* theFastXml = shdfnd::createFastXml( &theParser );
theFastXml->processXml( inFileBuf );
XmlNode* theTopNode = theParser.getTopNode();
if ( theTopNode != NULL )
{
{
XmlMemoryAllocatorImpl instantiationAllocator( mAllocator.getAllocator() );
XmlNodeReader theReader( theTopNode, mAllocator.getAllocator(), mAllocator.mManager );
readProperty( theReader, "UpVector", mUpVector );
if ( theReader.gotoChild( "Scale" ) )
{
readAllProperties( PxRepXInstantiationArgs( s.getPhysics() ), theReader, &mScale, instantiationAllocator, *mPxCollection);
theReader.leaveChild();
}
const char* verStr = NULL;
if ( theReader.read( "version", verStr ) )
mVersionStr = verStr;
}
for ( XmlNode* theChild = theTopNode->mFirstChild;
theChild != NULL;
theChild = theChild->mNextSibling )
{
if ( physx::Pxstricmp( theChild->mName, "scale" ) == 0
|| physx::Pxstricmp( theChild->mName, "version" ) == 0
|| physx::Pxstricmp( theChild->mName, "upvector" ) == 0 )
continue;
XmlNodeReader theReader( theChild, mAllocator.getAllocator(), mAllocator.mManager );
PxRepXObject theObject;
theObject.typeName = theChild->mName;
theObject.serializable = NULL;
PxSerialObjectId theId = 0;
theReader.read( "Id", theId );
theObject.id = theId;
mCollection.pushBack( RepXCollectionItem( theObject, theChild ) );
}
}
else
{
PxGetFoundation().error(PxErrorCode::eDEBUG_WARNING, PX_FL,
"Cannot parse any object from the input buffer, please check the input repx data.");
}
theFastXml->release();
}
virtual const char* getVersion() { return mVersionStr; }
virtual const RepXCollectionItem* begin() const
{
return mCollection.begin();
}
virtual const RepXCollectionItem* end() const
{
return mCollection.end();
}
virtual RepXCollection& createCollection( const char* inVersionStr )
{
PxAllocatorCallback& allocator = mSharedData->mWrapper.getAllocator();
RepXCollectionImpl* retval = PX_PLACEMENT_NEW((allocator.allocate(sizeof(RepXCollectionImpl), "createCollection", PX_FL)), RepXCollectionImpl) ( mSerializationRegistry, *this, inVersionStr );
return *retval;
}
//Performs a deep copy of the repx node.
virtual XmlNode* copyRepXNode( const XmlNode* srcNode )
{
return physx::Sn::copyRepXNode( &mAllocator.mManager, srcNode );
}
virtual void addCollectionItem( RepXCollectionItem inItem )
{
mCollection.pushBack( inItem );
}
virtual PxAllocatorCallback& getAllocator() { return mSharedData->mAllocator.getAllocator(); }
//Create a new repx node with this name. Its value is unset.
virtual XmlNode& createRepXNode( const char* name )
{
XmlNode* newNode = allocateRepXNode( &mSharedData->mAllocator.mManager, name, NULL );
return *newNode;
}
//Release this when finished.
virtual XmlReaderWriter& createNodeEditor()
{
PxAllocatorCallback& allocator = mSharedData->mWrapper.getAllocator();
XmlReaderWriter* retval = PX_PLACEMENT_NEW((allocator.allocate(sizeof(XmlNodeReader), "createNodeEditor", PX_FL)), XmlNodeReader) ( NULL, allocator, mAllocator.mManager );
return *retval;
}
};
const char* RepXCollection::getLatestVersion()
{
#define TOSTR_(x) #x
#define CONCAT_(a, b, c) TOSTR_(a.##b.##c)
#define MAKE_VERSION_STR(a,b,c) CONCAT_(a, b, c)
return MAKE_VERSION_STR(PX_PHYSICS_VERSION_MAJOR,PX_PHYSICS_VERSION_MINOR,PX_PHYSICS_VERSION_BUGFIX);
}
static RepXCollection* create(SerializationRegistry& s, PxAllocatorCallback& inAllocator, PxCollection& inCollection )
{
return PX_PLACEMENT_NEW((inAllocator.allocate(sizeof(RepXCollectionImpl), "RepXCollection::create", PX_FL)), RepXCollectionImpl) ( s, inAllocator, inCollection );
}
static RepXCollection* create(SerializationRegistry& s, PxInputData &data, PxAllocatorCallback& inAllocator, PxCollection& inCollection )
{
RepXCollectionImpl* theCollection = static_cast<RepXCollectionImpl*>( create(s, inAllocator, inCollection ) );
theCollection->load( data, s );
return theCollection;
}
}
bool PxSerialization::serializeCollectionToXml( PxOutputStream& outputStream, PxCollection& collection, PxSerializationRegistry& sr, const PxCookingParams* params, const PxCollection* externalRefs, PxXmlMiscParameter* inArgs )
{
if( !PxSerialization::isSerializable(collection, sr, const_cast<PxCollection*>(externalRefs)) )
return false;
bool bRet = true;
SerializationRegistry& sn = static_cast<SerializationRegistry&>(sr);
PxRepXInstantiationArgs args( sn.getPhysics(), params );
PxCollection* tmpCollection = PxCreateCollection();
PX_ASSERT(tmpCollection);
tmpCollection->add( collection );
if(externalRefs)
{
tmpCollection->add(*const_cast<PxCollection*>(externalRefs));
}
PxAllocatorCallback& allocator = *PxGetAllocatorCallback();
Sn::RepXCollection* theRepXCollection = Sn::create(sn, allocator, *tmpCollection );
if(inArgs != NULL)
{
theRepXCollection->setTolerancesScale(inArgs->scale);
theRepXCollection->setUpVector(inArgs->upVector);
}
PxU32 nbObjects = collection.getNbObjects();
if( nbObjects )
{
sortCollection( static_cast<Cm::Collection&>(collection), sn, true);
for( PxU32 i = 0; i < nbObjects; i++ )
{
PxBase& s = collection.getObject(i);
if( PxConcreteType::eSHAPE == s.getConcreteType() )
{
PxShape& shape = static_cast<PxShape&>(s);
if( shape.isExclusive() )
continue;
}
PxSerialObjectId id = collection.getId(s);
if(id == PX_SERIAL_OBJECT_ID_INVALID)
id = static_cast<PxSerialObjectId>( size_t( &s ));
PxRepXObject ro = PxCreateRepXObject( &s, id );
if ( ro.serializable == NULL || ro.id == 0 )
{
bRet = false;
break;
}
theRepXCollection->addRepXObjectToCollection( ro, tmpCollection, args );
}
}
tmpCollection->release();
theRepXCollection->save(outputStream);
theRepXCollection->destroy();
return bRet;
}
PxCollection* PxSerialization::createCollectionFromXml(PxInputData& inputData, const PxCookingParams& params, PxSerializationRegistry& sr, const PxCollection* externalRefs, PxStringTable* stringTable, PxXmlMiscParameter* outArgs)
{
SerializationRegistry& sn = static_cast<SerializationRegistry&>(sr);
PxCollection* collection = PxCreateCollection();
PX_ASSERT(collection);
if( externalRefs )
collection->add(*const_cast<PxCollection*>(externalRefs));
PxAllocatorCallback& allocator = *PxGetAllocatorCallback();
Sn::RepXCollection* theRepXCollection = Sn::create(sn, inputData, allocator, *collection);
theRepXCollection = &Sn::RepXUpgrader::upgradeCollection( *theRepXCollection );
PxRepXInstantiationArgs args( sn.getPhysics(), ¶ms, stringTable );
if( !theRepXCollection->instantiateCollection(args, *collection) )
{
collection->release();
theRepXCollection->destroy();
return NULL;
}
if( externalRefs )
collection->remove(*const_cast<PxCollection*>(externalRefs));
if(outArgs != NULL)
{
outArgs->upVector = theRepXCollection->getUpVector();
outArgs->scale = theRepXCollection->getTolerancesScale();
}
theRepXCollection->destroy();
return collection;
}
}
| 26,530 | C++ | 30.69773 | 230 | 0.705277 |
NVIDIA-Omniverse/PhysX/physx/source/physxextensions/src/serialization/Xml/SnXmlDeserializer.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-2023 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 SN_XML_DESERIALIZER_H
#define SN_XML_DESERIALIZER_H
#include "SnXmlVisitorReader.h"
namespace physx { namespace Sn {
//Definitions needed internally in the Serializer headers.
template<typename TTriIndexElem>
struct Triangle
{
TTriIndexElem mIdx0;
TTriIndexElem mIdx1;
TTriIndexElem mIdx2;
Triangle( TTriIndexElem inIdx0 = 0, TTriIndexElem inIdx1 = 0, TTriIndexElem inIdx2 = 0)
: mIdx0( inIdx0 )
, mIdx1( inIdx1 )
, mIdx2( inIdx2 )
{
}
};
struct XmlMemoryAllocateMemoryPoolAllocator
{
XmlMemoryAllocator* mAllocator;
XmlMemoryAllocateMemoryPoolAllocator( XmlMemoryAllocator* inAlloc ) : mAllocator( inAlloc ) {}
PxU8* allocate( PxU32 inSize ) { return mAllocator->allocate( inSize ); }
void deallocate( PxU8* inMem ) { mAllocator->deallocate( inMem ); }
};
inline bool isEmpty(const char *s)
{
while (*s != '\0')
{
if (!isspace(*s))
return false;
s++;
}
return true;
}
inline void strtoLong( Triangle<PxU32>& ioDatatype,const char*& ioData )
{
strto( ioDatatype.mIdx0, ioData );
strto( ioDatatype.mIdx1, ioData );
strto( ioDatatype.mIdx2, ioData );
}
inline void strtoLong( PxHeightFieldSample& ioDatatype,const char*& ioData )
{
PxU32 tempData;
strto( tempData, ioData );
if ( isBigEndian() )
{
PxU32& theItem(tempData);
PxU32 theDest = 0;
PxU8* theReadPtr( reinterpret_cast< PxU8* >( &theItem ) );
PxU8* theWritePtr( reinterpret_cast< PxU8* >( &theDest ) );
//A height field sample is a 16 bit number
//followed by two bytes.
//We write this out as a 32 bit integer, LE.
//Thus, on a big endian, we need to move the bytes
//around a bit.
//LE - 1 2 3 4
//BE - 4 3 2 1 - after convert from xml number
//Correct BE - 2 1 3 4, just like LE but with the 16 number swapped
theWritePtr[0] = theReadPtr[2];
theWritePtr[1] = theReadPtr[3];
theWritePtr[2] = theReadPtr[1];
theWritePtr[3] = theReadPtr[0];
theItem = theDest;
}
ioDatatype = *reinterpret_cast<PxHeightFieldSample*>( &tempData );
}
template<typename TDataType>
inline void readStridedFlagsProperty( XmlReader& ioReader, const char* inPropName, TDataType*& outData, PxU32& outStride, PxU32& outCount, XmlMemoryAllocator& inAllocator,
const PxU32ToName* inConversions)
{
const char* theSrcData;
outStride = sizeof( TDataType );
outData = NULL;
outCount = 0;
if ( ioReader.read( inPropName, theSrcData ) )
{
XmlMemoryAllocateMemoryPoolAllocator tempAllocator( &inAllocator );
MemoryBufferBase<XmlMemoryAllocateMemoryPoolAllocator> tempBuffer( &tempAllocator );
if ( theSrcData )
{
static PxU32 theCount = 0;
++theCount;
char* theStartData = const_cast< char*>( copyStr( &tempAllocator, theSrcData ) );
char* aData = strtok(theStartData, " \n");
while( aData )
{
TDataType tempValue;
stringToFlagsType( aData, inAllocator, tempValue, inConversions );
aData = strtok(NULL," \n");
tempBuffer.write( &tempValue, sizeof(TDataType) );
}
outData = reinterpret_cast< TDataType* >( tempBuffer.mBuffer );
outCount = tempBuffer.mWriteOffset / sizeof( TDataType );
tempAllocator.deallocate( reinterpret_cast<PxU8*>(theStartData) );
}
tempBuffer.releaseBuffer();
}
}
template<typename TDataType>
inline void readStridedBufferProperty( XmlReader& ioReader, const char* inPropName, TDataType*& outData, PxU32& outStride, PxU32& outCount, XmlMemoryAllocator& inAllocator)
{
const char* theSrcData;
outStride = sizeof( TDataType );
outData = NULL;
outCount = 0;
if ( ioReader.read( inPropName, theSrcData ) )
{
XmlMemoryAllocateMemoryPoolAllocator tempAllocator( &inAllocator );
MemoryBufferBase<XmlMemoryAllocateMemoryPoolAllocator> tempBuffer( &tempAllocator );
if ( theSrcData )
{
static PxU32 theCount = 0;
++theCount;
char* theStartData = const_cast< char*>( copyStr( &tempAllocator, theSrcData ) );
const char* theData = theStartData;
while( !isEmpty(theData) )
{
//These buffers are whitespace delimited.
TDataType theType;
strtoLong( theType, theData );
tempBuffer.write( &theType, sizeof(theType) );
}
outData = reinterpret_cast< TDataType* >( tempBuffer.mBuffer );
outCount = tempBuffer.mWriteOffset / sizeof( TDataType );
tempAllocator.deallocate( reinterpret_cast<PxU8*>(theStartData) );
}
tempBuffer.releaseBuffer();
}
}
template<typename TDataType>
inline void readStridedBufferProperty( XmlReader& ioReader, const char* inPropName, PxStridedData& ioData, PxU32& outCount, XmlMemoryAllocator& inAllocator)
{
TDataType* tempData = NULL;
readStridedBufferProperty<TDataType>( ioReader, inPropName, tempData, ioData.stride, outCount, inAllocator );
ioData.data = tempData;
}
template<typename TDataType>
inline void readStridedBufferProperty( XmlReader& ioReader, const char* inPropName, PxTypedStridedData<TDataType>& ioData, PxU32& outCount, XmlMemoryAllocator& inAllocator)
{
TDataType* tempData = NULL;
readStridedBufferProperty<TDataType>( ioReader, inPropName, tempData, ioData.stride, outCount, inAllocator );
ioData.data = reinterpret_cast<PxMaterialTableIndex*>( tempData );
}
template<typename TDataType>
inline void readStridedBufferProperty( XmlReader& ioReader, const char* inPropName, PxBoundedData& ioData, XmlMemoryAllocator& inAllocator)
{
return readStridedBufferProperty<TDataType>( ioReader, inPropName, ioData, ioData.count, inAllocator );
}
} }
#endif
| 7,210 | C | 35.419192 | 173 | 0.725936 |
NVIDIA-Omniverse/PhysX/physx/source/physxextensions/src/serialization/Xml/SnRepXSerializerImpl.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-2023 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 SN_REPX_SERIALIZER_IMPL_H
#define SN_REPX_SERIALIZER_IMPL_H
#include "foundation/PxUserAllocated.h"
#include "SnXmlVisitorWriter.h"
#include "SnXmlVisitorReader.h"
namespace physx {
using namespace Sn;
/**
* The repx serializer impl takes the raw, untyped repx extension interface
* and implements the simpler functions plus does the reinterpret-casts required
* for any object to implement the serializer safely.
*/
template<typename TLiveType>
struct RepXSerializerImpl : public PxRepXSerializer, PxUserAllocated
{
protected:
RepXSerializerImpl( const RepXSerializerImpl& inOther );
RepXSerializerImpl& operator=( const RepXSerializerImpl& inOther );
public:
PxAllocatorCallback& mAllocator;
RepXSerializerImpl( PxAllocatorCallback& inAllocator )
: mAllocator( inAllocator )
{
}
virtual const char* getTypeName() { return PxTypeInfo<TLiveType>::name(); }
virtual void objectToFile( const PxRepXObject& inLiveObject, PxCollection* inCollection, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& inArgs )
{
const TLiveType* theObj = reinterpret_cast<const TLiveType*>( inLiveObject.serializable );
objectToFileImpl( theObj, inCollection, inWriter, inTempBuffer, inArgs );
}
virtual PxRepXObject fileToObject( XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* inCollection )
{
TLiveType* theObj( allocateObject( inArgs ) );
if ( theObj )
if(fileToObjectImpl( theObj, inReader, inAllocator, inArgs, inCollection ))
return PxCreateRepXObject(theObj);
return PxRepXObject();
}
virtual void objectToFileImpl( const TLiveType* inObj, PxCollection* inCollection, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& /*inArgs*/)
{
writeAllProperties( inObj, inWriter, inTempBuffer, *inCollection );
}
virtual bool fileToObjectImpl( TLiveType* inObj, XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* inCollection )
{
return readAllProperties( inArgs, inReader, inObj, inAllocator, *inCollection );
}
virtual TLiveType* allocateObject( PxRepXInstantiationArgs& inArgs ) = 0;
};
}
#endif
| 3,942 | C | 42.32967 | 173 | 0.767377 |
NVIDIA-Omniverse/PhysX/physx/source/physxextensions/src/serialization/Xml/SnXmlImpl.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-2023 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 SN_XML_IMPL_H
#define SN_XML_IMPL_H
#include "SnXmlMemoryPool.h"
#include "foundation/PxString.h"
#include "foundation/PxMemory.h"
namespace physx { namespace Sn {
typedef CMemoryPoolManager TMemoryPoolManager;
namespace snXmlImpl {
inline PxU32 strLen( const char* inStr )
{
PxU32 len = 0;
if ( inStr )
{
while ( *inStr )
{
++len;
++inStr;
}
}
return len;
}
}
inline const char* copyStr( PxAllocatorCallback& inAllocator, const char* inStr )
{
if ( inStr && *inStr )
{
PxU32 theLen = snXmlImpl::strLen( inStr );
//The memory will never be released by repx. If you want it released, you need to pass in a custom allocator
//that tracks all allocations and releases unreleased allocations yourself.
char* dest = reinterpret_cast<char* >( inAllocator.allocate( theLen + 1, "Repx::const char*", PX_FL ) );
PxMemCopy( dest, inStr, theLen );
dest[theLen] = 0;
return dest;
}
return "";
}
template<typename TManagerType>
inline const char* copyStr( TManagerType* inMgr, const char* inStr )
{
if ( inStr && *inStr )
{
PxU32 theLen = snXmlImpl::strLen( inStr );
char* dest = reinterpret_cast<char* >( inMgr->allocate( theLen + 1 ) );
PxMemCopy( dest, inStr, theLen );
dest[theLen] = 0;
return dest;
}
return "";
}
inline void releaseStr( TMemoryPoolManager* inMgr, const char* inStr, PxU32 )
{
if ( inStr && *inStr )
{
inMgr->deallocate( reinterpret_cast< PxU8* >( const_cast<char*>( inStr ) ) );
}
}
inline void releaseStr( TMemoryPoolManager* inMgr, const char* inStr )
{
if ( inStr && *inStr )
{
PxU32 theLen = snXmlImpl::strLen( inStr );
releaseStr( inMgr, inStr, theLen );
}
}
struct XmlNode
{
const char* mName; //Never released until all collections are released
const char* mData; //Never released until all collections are released
XmlNode* mNextSibling;
XmlNode* mPreviousSibling;
XmlNode* mFirstChild;
XmlNode* mParent;
XmlNode( const XmlNode& );
XmlNode& operator=( const XmlNode& );
PX_INLINE void initPtrs()
{
mNextSibling = NULL;
mPreviousSibling = NULL;
mFirstChild = NULL;
mParent = NULL;
}
PX_INLINE XmlNode( const char* inName = "", const char* inData = "" )
: mName( inName )
, mData( inData )
{ initPtrs(); }
void addChild( XmlNode* inItem )
{
inItem->mParent = this;
if ( mFirstChild == NULL )
mFirstChild = inItem;
else
{
XmlNode* theNode = mFirstChild;
//Follow the chain till the end.
while( theNode->mNextSibling != NULL )
theNode = theNode->mNextSibling;
theNode->mNextSibling = inItem;
inItem->mPreviousSibling = theNode;
}
}
PX_INLINE XmlNode* findChildByName( const char* inName )
{
for ( XmlNode* theNode = mFirstChild; theNode; theNode = theNode->mNextSibling )
{
XmlNode* theRepXNode = theNode;
if ( physx::Pxstricmp( theRepXNode->mName, inName ) == 0 )
return theNode;
}
return NULL;
}
PX_INLINE void orphan()
{
if ( mParent )
{
if ( mParent->mFirstChild == this )
mParent->mFirstChild = mNextSibling;
}
if ( mPreviousSibling )
mPreviousSibling->mNextSibling = mNextSibling;
if ( mNextSibling )
mNextSibling->mPreviousSibling = mPreviousSibling;
if ( mFirstChild )
mFirstChild->mParent = NULL;
initPtrs();
}
};
inline XmlNode* allocateRepXNode( TMemoryPoolManager* inManager, const char* inName, const char* inData )
{
XmlNode* retval = inManager->allocate<XmlNode>();
retval->mName = copyStr( inManager, inName );
retval->mData = copyStr( inManager, inData );
return retval;
}
inline void release( TMemoryPoolManager* inManager, XmlNode* inNode )
{
//We *don't* release the strings associated with the node
//because they could be shared. Instead, we just let them 'leak'
//in some sense, at least until the memory manager itself is deleted.
//DO NOT UNCOMMENT THE LINES BELOW!!
//releaseStr( inManager, inNode->mName );
//releaseStr( inManager, inNode->mData );
inManager->deallocate( inNode );
}
static PX_INLINE void releaseNodeAndChildren( TMemoryPoolManager* inManager, XmlNode* inNode )
{
if ( inNode->mFirstChild )
{
XmlNode* childNode( inNode->mFirstChild );
while( childNode )
{
XmlNode* _node( childNode );
childNode = _node->mNextSibling;
releaseNodeAndChildren( inManager, _node );
}
}
inNode->orphan();
release( inManager, inNode );
}
static XmlNode* copyRepXNodeAndSiblings( TMemoryPoolManager* inManager, const XmlNode* inNode, XmlNode* inParent );
static XmlNode* copyRepXNode( TMemoryPoolManager* inManager, const XmlNode* inNode, XmlNode* inParent = NULL )
{
XmlNode* newNode( allocateRepXNode( inManager, NULL, NULL ) );
newNode->mName = inNode->mName; //Some light structural sharing
newNode->mData = inNode->mData; //Some light structural sharing
newNode->mParent = inParent;
if ( inNode->mFirstChild )
newNode->mFirstChild = copyRepXNodeAndSiblings( inManager, inNode->mFirstChild, newNode );
return newNode;
}
static XmlNode* copyRepXNodeAndSiblings( TMemoryPoolManager* inManager, const XmlNode* inNode, XmlNode* inParent )
{
XmlNode* sibling = inNode->mNextSibling;
if ( sibling ) sibling = copyRepXNodeAndSiblings( inManager, sibling, inParent );
XmlNode* newNode = copyRepXNode( inManager, inNode, inParent );
newNode->mNextSibling = sibling;
if ( sibling ) sibling->mPreviousSibling = newNode;
return newNode;
}
inline bool isBigEndian() { int i = 1; return *(reinterpret_cast<char*>(&i))==0; }
struct NameStackEntry
{
const char* mName;
bool mOpen;
NameStackEntry( const char* nm ) : mName( nm ), mOpen( false ) {}
};
typedef PxProfileArray<NameStackEntry> TNameStack;
} }
#endif
| 7,484 | C | 29.676229 | 116 | 0.699359 |
NVIDIA-Omniverse/PhysX/physx/source/physxextensions/src/serialization/Xml/SnRepXCoreSerializer.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "PxPhysicsAPI.h"
#include "PxMetaDataObjects.h"
#include "SnPxStreamOperators.h"
#include "foundation/PxUtilities.h"
#include "SnXmlImpl.h"
#include "SnXmlSerializer.h"
#include "SnXmlDeserializer.h"
#include "SnRepXCoreSerializer.h"
using namespace physx::Sn;
namespace physx {
typedef PxReadOnlyPropertyInfo<PxPropertyInfoName::PxArticulationLink_InboundJoint, PxArticulationLink, PxArticulationJointReducedCoordinate *> TIncomingJointPropType;
//*************************************************************
// Actual RepXSerializer implementations for PxMaterial
//*************************************************************
PxMaterial* PxMaterialRepXSerializer::allocateObject( PxRepXInstantiationArgs& inArgs )
{
return inArgs.physics.createMaterial(0, 0, 0);
}
PxRepXObject PxShapeRepXSerializer::fileToObject( XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* inCollection )
{
PxProfileAllocatorWrapper wrapper( inAllocator.getAllocator() );
TReaderNameStack names( wrapper );
PxProfileArray<PxU32> contexts( wrapper );
bool hadError = false;
RepXVisitorReader<PxShape> theVisitor( names, contexts, inArgs, inReader, NULL, inAllocator, *inCollection, hadError );
PxArray<PxMaterial*> materials;
PxGeometry* geometry = NULL;
parseShape( theVisitor, geometry, materials );
if(hadError)
return PxRepXObject();
PxShape *theShape = inArgs.physics.createShape( *geometry, materials.begin(), PxTo16(materials.size()) );
switch(geometry->getType())
{
case PxGeometryType::eSPHERE :
static_cast<PxSphereGeometry*>(geometry)->~PxSphereGeometry();
break;
case PxGeometryType::ePLANE :
static_cast<PxPlaneGeometry*>(geometry)->~PxPlaneGeometry();
break;
case PxGeometryType::eCAPSULE :
static_cast<PxCapsuleGeometry*>(geometry)->~PxCapsuleGeometry();
break;
case PxGeometryType::eBOX :
static_cast<PxBoxGeometry*>(geometry)->~PxBoxGeometry();
break;
case PxGeometryType::eCONVEXMESH :
static_cast<PxConvexMeshGeometry*>(geometry)->~PxConvexMeshGeometry();
break;
case PxGeometryType::eTRIANGLEMESH :
static_cast<PxTriangleMeshGeometry*>(geometry)->~PxTriangleMeshGeometry();
break;
case PxGeometryType::eHEIGHTFIELD :
static_cast<PxHeightFieldGeometry*>(geometry)->~PxHeightFieldGeometry();
break;
case PxGeometryType::eTETRAHEDRONMESH :
static_cast<PxTetrahedronMeshGeometry*>(geometry)->~PxTetrahedronMeshGeometry();
break;
case PxGeometryType::ePARTICLESYSTEM:
static_cast<PxParticleSystemGeometry*>(geometry)->~PxParticleSystemGeometry();
break;
case PxGeometryType::eHAIRSYSTEM:
static_cast<PxHairSystemGeometry*>(geometry)->~PxHairSystemGeometry();
break;
case PxGeometryType::eCUSTOM :
static_cast<PxCustomGeometry*>(geometry)->~PxCustomGeometry();
break;
case PxGeometryType::eGEOMETRY_COUNT:
case PxGeometryType::eINVALID:
PX_ASSERT(0);
}
inAllocator.getAllocator().deallocate(geometry);
bool ret = readAllProperties( inArgs, inReader, theShape, inAllocator, *inCollection );
return ret ? PxCreateRepXObject(theShape) : PxRepXObject();
}
//*************************************************************
// Actual RepXSerializer implementations for PxTriangleMesh
//*************************************************************
template<typename TTriIndexElem>
inline void writeTriangle( MemoryBuffer& inTempBuffer, const Triangle<TTriIndexElem>& inTriangle )
{
inTempBuffer << inTriangle.mIdx0
<< " " << inTriangle.mIdx1
<< " " << inTriangle.mIdx2;
}
PxU32 materialAccess( const PxTriangleMesh* inMesh, PxU32 inIndex ) { return inMesh->getTriangleMaterialIndex( inIndex ); }
template<typename TDataType>
void writeDatatype( MemoryBuffer& inTempBuffer, const TDataType& inType ) { inTempBuffer << inType; }
void PxBVH33TriangleMeshRepXSerializer::objectToFileImpl( const PxBVH33TriangleMesh* mesh, PxCollection* /*inCollection*/, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& inArgs )
{
bool hasMatIndex = mesh->getTriangleMaterialIndex(0) != 0xffff;
PxU32 numVertices = mesh->getNbVertices();
const PxVec3* vertices = mesh->getVertices();
writeBuffer( inWriter, inTempBuffer, 2, vertices, numVertices, "Points", writePxVec3 );
bool isU16 = mesh->getTriangleMeshFlags() & PxTriangleMeshFlag::e16_BIT_INDICES ? true : false;
PxU32 triCount = mesh->getNbTriangles();
const void* indices = mesh->getTriangles();
if ( isU16 )
writeBuffer( inWriter, inTempBuffer, 2, reinterpret_cast<const Triangle<PxU16>* >( indices ), triCount, "Triangles", writeTriangle<PxU16> );
else
writeBuffer( inWriter, inTempBuffer, 2, reinterpret_cast<const Triangle<PxU32>* >( indices ), triCount, "Triangles", writeTriangle<PxU32> );
if ( hasMatIndex )
writeBuffer( inWriter, inTempBuffer, 6, mesh, materialAccess, triCount, "materialIndices", writeDatatype<PxU32> );
//Cooked stream
PxTriangleMeshDesc meshDesc;
meshDesc.points.count = numVertices;
meshDesc.points.data = vertices;
meshDesc.points.stride = sizeof(PxVec3);
meshDesc.triangles.count = triCount;
meshDesc.triangles.data = indices;
meshDesc.triangles.stride = isU16?3*sizeof(PxU16):3*sizeof(PxU32);
if(isU16)
{
meshDesc.triangles.stride = sizeof(PxU16)*3;
meshDesc.flags |= PxMeshFlag::e16_BIT_INDICES;
}
else
{
meshDesc.triangles.stride = sizeof(PxU32)*3;
}
if(hasMatIndex)
{
PxMaterialTableIndex* materialIndices = new PxMaterialTableIndex[triCount];
for(PxU32 i = 0; i < triCount; i++)
materialIndices[i] = mesh->getTriangleMaterialIndex(i);
meshDesc.materialIndices.data = materialIndices;
meshDesc.materialIndices.stride = sizeof(PxMaterialTableIndex);
}
if(inArgs.cooker != NULL)
{
TMemoryPoolManager theManager(mAllocator);
MemoryBuffer theTempBuf( &theManager );
theTempBuf.clear();
PxCookTriangleMesh( *inArgs.cooker, meshDesc, theTempBuf );
writeBuffer( inWriter, inTempBuffer, 16, theTempBuf.mBuffer, theTempBuf.mWriteOffset, "CookedData", writeDatatype<PxU8> );
}
delete []meshDesc.materialIndices.data;
}
PxRepXObject PxBVH33TriangleMeshRepXSerializer::fileToObject( XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* /*inCollection*/ )
{
//We can't do a simple inverse; we *have* to cook data to get a mesh.
PxTriangleMeshDesc theDesc;
readStridedBufferProperty<PxVec3>( inReader, "points", theDesc.points, inAllocator);
readStridedBufferProperty<Triangle<PxU32> >( inReader, "triangles", theDesc.triangles, inAllocator);
PxU32 triCount;
readStridedBufferProperty<PxMaterialTableIndex>( inReader, "materialIndices", theDesc.materialIndices, triCount, inAllocator);
PxStridedData cookedData;
cookedData.stride = sizeof(PxU8);
PxU32 dataSize;
readStridedBufferProperty<PxU8>( inReader, "CookedData", cookedData, dataSize, inAllocator);
TMemoryPoolManager theManager(inAllocator.getAllocator());
MemoryBuffer theTempBuf( &theManager );
// PxTriangleMesh* theMesh = NULL;
PxBVH33TriangleMesh* theMesh = NULL;
if(dataSize != 0)
{
theTempBuf.write(cookedData.data, dataSize*sizeof(PxU8));
// theMesh = inArgs.physics.createTriangleMesh( theTempBuf );
theMesh = static_cast<PxBVH33TriangleMesh*>(inArgs.physics.createTriangleMesh( theTempBuf ));
}
if(theMesh == NULL)
{
PX_ASSERT(inArgs.cooker);
theTempBuf.clear();
PxCookingParams params = *inArgs.cooker;
params.midphaseDesc = PxMeshMidPhase::eBVH33;
PxCookTriangleMesh( params, theDesc, theTempBuf );
// theMesh = inArgs.physics.createTriangleMesh( theTempBuf );
theMesh = static_cast<PxBVH33TriangleMesh*>(inArgs.physics.createTriangleMesh( theTempBuf ));
}
return PxCreateRepXObject( theMesh );
}
void PxBVH34TriangleMeshRepXSerializer::objectToFileImpl( const PxBVH34TriangleMesh* mesh, PxCollection* /*inCollection*/, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& inArgs )
{
bool hasMatIndex = mesh->getTriangleMaterialIndex(0) != 0xffff;
PxU32 numVertices = mesh->getNbVertices();
const PxVec3* vertices = mesh->getVertices();
writeBuffer( inWriter, inTempBuffer, 2, vertices, numVertices, "Points", writePxVec3 );
bool isU16 = mesh->getTriangleMeshFlags() & PxTriangleMeshFlag::e16_BIT_INDICES ? true : false;
PxU32 triCount = mesh->getNbTriangles();
const void* indices = mesh->getTriangles();
if ( isU16 )
writeBuffer( inWriter, inTempBuffer, 2, reinterpret_cast<const Triangle<PxU16>* >( indices ), triCount, "Triangles", writeTriangle<PxU16> );
else
writeBuffer( inWriter, inTempBuffer, 2, reinterpret_cast<const Triangle<PxU32>* >( indices ), triCount, "Triangles", writeTriangle<PxU32> );
if ( hasMatIndex )
writeBuffer( inWriter, inTempBuffer, 6, mesh, materialAccess, triCount, "materialIndices", writeDatatype<PxU32> );
//Cooked stream
PxTriangleMeshDesc meshDesc;
meshDesc.points.count = numVertices;
meshDesc.points.data = vertices;
meshDesc.points.stride = sizeof(PxVec3);
meshDesc.triangles.count = triCount;
meshDesc.triangles.data = indices;
meshDesc.triangles.stride = isU16?3*sizeof(PxU16):3*sizeof(PxU32);
if(isU16)
{
meshDesc.triangles.stride = sizeof(PxU16)*3;
meshDesc.flags |= PxMeshFlag::e16_BIT_INDICES;
}
else
{
meshDesc.triangles.stride = sizeof(PxU32)*3;
}
if(hasMatIndex)
{
PxMaterialTableIndex* materialIndices = new PxMaterialTableIndex[triCount];
for(PxU32 i = 0; i < triCount; i++)
materialIndices[i] = mesh->getTriangleMaterialIndex(i);
meshDesc.materialIndices.data = materialIndices;
meshDesc.materialIndices.stride = sizeof(PxMaterialTableIndex);
}
if(inArgs.cooker != NULL)
{
TMemoryPoolManager theManager(mAllocator);
MemoryBuffer theTempBuf( &theManager );
theTempBuf.clear();
PxCookTriangleMesh( *inArgs.cooker, meshDesc, theTempBuf );
writeBuffer( inWriter, inTempBuffer, 16, theTempBuf.mBuffer, theTempBuf.mWriteOffset, "CookedData", writeDatatype<PxU8> );
}
delete []meshDesc.materialIndices.data;
}
PxRepXObject PxBVH34TriangleMeshRepXSerializer::fileToObject( XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* /*inCollection*/ )
{
//We can't do a simple inverse; we *have* to cook data to get a mesh.
PxTriangleMeshDesc theDesc;
readStridedBufferProperty<PxVec3>( inReader, "points", theDesc.points, inAllocator);
readStridedBufferProperty<Triangle<PxU32> >( inReader, "triangles", theDesc.triangles, inAllocator);
PxU32 triCount;
readStridedBufferProperty<PxMaterialTableIndex>( inReader, "materialIndices", theDesc.materialIndices, triCount, inAllocator);
PxStridedData cookedData;
cookedData.stride = sizeof(PxU8);
PxU32 dataSize;
readStridedBufferProperty<PxU8>( inReader, "CookedData", cookedData, dataSize, inAllocator);
TMemoryPoolManager theManager(inAllocator.getAllocator());
MemoryBuffer theTempBuf( &theManager );
// PxTriangleMesh* theMesh = NULL;
PxBVH34TriangleMesh* theMesh = NULL;
if(dataSize != 0)
{
theTempBuf.write(cookedData.data, dataSize*sizeof(PxU8));
// theMesh = inArgs.physics.createTriangleMesh( theTempBuf );
theMesh = static_cast<PxBVH34TriangleMesh*>(inArgs.physics.createTriangleMesh( theTempBuf ));
}
if(theMesh == NULL)
{
PX_ASSERT(inArgs.cooker);
theTempBuf.clear();
PxCookingParams params = *inArgs.cooker;
params.midphaseDesc = PxMeshMidPhase::eBVH34;
PxCookTriangleMesh( params, theDesc, theTempBuf );
// theMesh = inArgs.physics.createTriangleMesh( theTempBuf );
theMesh = static_cast<PxBVH34TriangleMesh*>(inArgs.physics.createTriangleMesh( theTempBuf ));
}
return PxCreateRepXObject(theMesh);
}
//*************************************************************
// Actual RepXSerializer implementations for PxHeightField
//*************************************************************
void PxHeightFieldRepXSerializer::objectToFileImpl( const PxHeightField* inHeightField, PxCollection* inCollection, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& /*inArgs*/)
{
PxHeightFieldDesc theDesc;
theDesc.nbRows = inHeightField->getNbRows();
theDesc.nbColumns = inHeightField->getNbColumns();
theDesc.format = inHeightField->getFormat();
theDesc.samples.stride = inHeightField->getSampleStride();
theDesc.samples.data = NULL;
theDesc.convexEdgeThreshold = inHeightField->getConvexEdgeThreshold();
theDesc.flags = inHeightField->getFlags();
PxU32 theCellCount = inHeightField->getNbRows() * inHeightField->getNbColumns();
PxU32 theSampleStride = sizeof( PxHeightFieldSample );
PxU32 theSampleBufSize = theCellCount * theSampleStride;
PxHeightFieldSample* theSamples = reinterpret_cast< PxHeightFieldSample*> ( inTempBuffer.mManager->allocate( theSampleBufSize ) );
inHeightField->saveCells( theSamples, theSampleBufSize );
theDesc.samples.data = theSamples;
writeAllProperties( &theDesc, inWriter, inTempBuffer, *inCollection );
writeStridedBufferProperty<PxHeightFieldSample>( inWriter, inTempBuffer, "samples", theDesc.samples, theDesc.nbRows * theDesc.nbColumns, 6, writeHeightFieldSample);
inTempBuffer.mManager->deallocate( reinterpret_cast<PxU8*>(theSamples) );
}
PxRepXObject PxHeightFieldRepXSerializer::fileToObject( XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* inCollection )
{
PX_ASSERT(inArgs.cooker);
PxHeightFieldDesc theDesc;
readAllProperties( inArgs, inReader, &theDesc, inAllocator, *inCollection );
//Now read the data...
PxU32 count = 0; //ignored becaues numRows and numColumns tells the story
readStridedBufferProperty<PxHeightFieldSample>( inReader, "samples", theDesc.samples, count, inAllocator);
PxHeightField* retval = PxCreateHeightField( theDesc, inArgs.physics.getPhysicsInsertionCallback() );
return PxCreateRepXObject(retval);
}
//*************************************************************
// Actual RepXSerializer implementations for PxConvexMesh
//*************************************************************
void PxConvexMeshRepXSerializer::objectToFileImpl( const PxConvexMesh* mesh, PxCollection* /*inCollection*/, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& inArgs )
{
writeBuffer( inWriter, inTempBuffer, 2, mesh->getVertices(), mesh->getNbVertices(), "points", writePxVec3 );
if(inArgs.cooker != NULL)
{
//Cache cooked Data
PxConvexMeshDesc theDesc;
theDesc.points.data = mesh->getVertices();
theDesc.points.stride = sizeof(PxVec3);
theDesc.points.count = mesh->getNbVertices();
theDesc.flags = PxConvexFlag::eCOMPUTE_CONVEX;
TMemoryPoolManager theManager(mAllocator);
MemoryBuffer theTempBuf( &theManager );
PxCookConvexMesh( *inArgs.cooker, theDesc, theTempBuf );
writeBuffer( inWriter, inTempBuffer, 16, theTempBuf.mBuffer, theTempBuf.mWriteOffset, "CookedData", writeDatatype<PxU8> );
}
}
//Conversion from scene object to descriptor.
PxRepXObject PxConvexMeshRepXSerializer::fileToObject( XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* /*inCollection*/)
{
PxConvexMeshDesc theDesc;
readStridedBufferProperty<PxVec3>( inReader, "points", theDesc.points, inAllocator);
theDesc.flags = PxConvexFlag::eCOMPUTE_CONVEX;
PxStridedData cookedData;
cookedData.stride = sizeof(PxU8);
PxU32 dataSize;
readStridedBufferProperty<PxU8>( inReader, "CookedData", cookedData, dataSize, inAllocator);
TMemoryPoolManager theManager(inAllocator.getAllocator());
MemoryBuffer theTempBuf( &theManager );
PxConvexMesh* theMesh = NULL;
if(dataSize != 0)
{
theTempBuf.write(cookedData.data, dataSize*sizeof(PxU8));
theMesh = inArgs.physics.createConvexMesh( theTempBuf );
}
if(theMesh == NULL)
{
PX_ASSERT(inArgs.cooker);
theTempBuf.clear();
PxCookConvexMesh( *inArgs.cooker, theDesc, theTempBuf );
theMesh = inArgs.physics.createConvexMesh( theTempBuf );
}
return PxCreateRepXObject(theMesh);
}
//*************************************************************
// Actual RepXSerializer implementations for PxRigidStatic
//*************************************************************
PxRigidStatic* PxRigidStaticRepXSerializer::allocateObject( PxRepXInstantiationArgs& inArgs )
{
return inArgs.physics.createRigidStatic( PxTransform(PxIdentity) );
}
//*************************************************************
// Actual RepXSerializer implementations for PxRigidDynamic
//*************************************************************
PxRigidDynamic* PxRigidDynamicRepXSerializer::allocateObject( PxRepXInstantiationArgs& inArgs )
{
return inArgs.physics.createRigidDynamic( PxTransform(PxIdentity) );
}
//*************************************************************
// Actual RepXSerializer implementations for PxArticulationReducedCoordinate
//*************************************************************
void PxArticulationReducedCoordinateRepXSerializer::objectToFileImpl(const PxArticulationReducedCoordinate* inObj, PxCollection* inCollection, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& /*inArgs*/)
{
TNameStack nameStack(inTempBuffer.mManager->mWrapper);
Sn::TArticulationLinkLinkMap linkMap(inTempBuffer.mManager->mWrapper);
RepXVisitorWriter<PxArticulationReducedCoordinate> writer(nameStack, inWriter, inObj, inTempBuffer, *inCollection, &linkMap);
RepXPropertyFilter<RepXVisitorWriter<PxArticulationReducedCoordinate> > theOp(writer);
visitAllProperties<PxArticulationReducedCoordinate>(theOp);
}
PxArticulationReducedCoordinate* PxArticulationReducedCoordinateRepXSerializer::allocateObject(PxRepXInstantiationArgs& inArgs) { return inArgs.physics.createArticulationReducedCoordinate(); }
//*************************************************************
// Actual RepXSerializer implementations for PxAggregate
//*************************************************************
void PxAggregateRepXSerializer::objectToFileImpl( const PxAggregate* data, PxCollection* inCollection, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& /*inArgs*/)
{
PxArticulationLink *link = NULL;
inWriter.addAndGotoChild( "Actors" );
for(PxU32 i = 0; i < data->getNbActors(); ++i)
{
PxActor* actor;
if(data->getActors(&actor, 1, i))
{
link = actor->is<PxArticulationLink>();
}
if(link && !link->getInboundJoint() )
{
writeProperty( inWriter, *inCollection, inTempBuffer, "PxArticulationRef", &link->getArticulation());
}
else if( !link )
{
PxSerialObjectId theId = 0;
theId = inCollection->getId( *actor );
if( theId == 0 )
theId = static_cast<uint64_t>(size_t(actor));
writeProperty( inWriter, *inCollection, inTempBuffer, "PxActorRef", theId );
}
}
inWriter.leaveChild( );
writeProperty( inWriter, *inCollection, inTempBuffer, "NumActors", data->getNbActors() );
writeProperty( inWriter, *inCollection, inTempBuffer, "MaxNbActors", data->getMaxNbActors() );
writeProperty(inWriter, *inCollection, inTempBuffer, "MaxNbShapes", data->getMaxNbShapes());
writeProperty( inWriter, *inCollection, inTempBuffer, "SelfCollision", data->getSelfCollision() );
writeAllProperties( data, inWriter, inTempBuffer, *inCollection );
}
PxRepXObject PxAggregateRepXSerializer::fileToObject( XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* inCollection )
{
PxU32 numActors;
readProperty( inReader, "NumActors", numActors );
PxU32 maxNbActors;
readProperty( inReader, "MaxNbActors", maxNbActors );
PxU32 maxNbShapes;
readProperty(inReader, "MaxNbShapes", maxNbShapes);
bool selfCollision;
bool ret = readProperty( inReader, "SelfCollision", selfCollision );
PxAggregate* theAggregate = inArgs.physics.createAggregate(maxNbActors, maxNbShapes, selfCollision);
ret &= readAllProperties( inArgs, inReader, theAggregate, inAllocator, *inCollection );
inReader.pushCurrentContext();
if ( inReader.gotoChild( "Actors" ) )
{
inReader.pushCurrentContext();
for( bool matSuccess = inReader.gotoFirstChild(); matSuccess;
matSuccess = inReader.gotoNextSibling() )
{
const char* actorType = inReader.getCurrentItemName();
if ( 0 == physx::Pxstricmp( actorType, "PxActorRef" ) )
{
PxActor *actor = NULL;
ret &= readReference<PxActor>( inReader, *inCollection, actor );
if(actor)
{
PxScene *currScene = actor->getScene();
if(currScene)
{
currScene->removeActor(*actor);
}
theAggregate->addActor(*actor);
}
}
else if ( 0 == physx::Pxstricmp( actorType, "PxArticulationRef" ) )
{
PxArticulationReducedCoordinate* articulation = NULL;
ret &= readReference<PxArticulationReducedCoordinate>( inReader, *inCollection, articulation );
if(articulation)
{
PxScene *currScene = articulation->getScene();
if(currScene)
{
currScene->removeArticulation(*articulation);
}
theAggregate->addArticulation(*articulation);
}
}
}
inReader.popCurrentContext();
inReader.leaveChild();
}
inReader.popCurrentContext();
return ret ? PxCreateRepXObject(theAggregate) : PxRepXObject();
}
}
| 23,216 | C++ | 40.311388 | 229 | 0.720494 |
NVIDIA-Omniverse/PhysX/physx/source/physxextensions/src/serialization/Xml/SnXmlStringToType.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-2023 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 SN_XML_STRING_TO_TYPE_H
#define SN_XML_STRING_TO_TYPE_H
#include "common/PxCoreUtilityTypes.h"
#include "PxFiltering.h"
#include "foundation/PxString.h"
#include <stdio.h>
#include <ctype.h>
//Remapping function name for gcc-based systems.
#ifndef _MSC_VER
#define _strtoui64 strtoull
#endif
namespace physx { namespace Sn {
template<typename TDataType>
struct StrToImpl
{
bool compile_error;
};
template<> struct StrToImpl<PxU64> {
//Id's (void ptrs) are written to file as unsigned
//64 bit integers, so this method gets called more
//often than one might think.
PX_INLINE void strto( PxU64& ioDatatype,const char*& ioData )
{
ioDatatype = _strtoui64( ioData, const_cast<char **>(&ioData), 10 );
}
};
PX_INLINE PxF32 strToFloat(const char *str,const char **nextScan)
{
PxF32 ret;
while ( *str && isspace(static_cast<unsigned char>(*str))) str++; // skip leading whitespace
char temp[256] = "";
char *dest = temp;
char *end = &temp[255];
const char *begin = str;
while ( *str && !isspace(static_cast<unsigned char>(*str)) && dest < end ) // copy the number up to the first whitespace or eos
{
*dest++ = *str++;
}
*dest = 0;
ret = PxF32(strtod(temp,&end));
if ( nextScan )
{
*nextScan = begin+(end-temp);
}
return ret;
}
template<> struct StrToImpl<PxU32> {
PX_INLINE void strto( PxU32& ioDatatype,const char*& ioData )
{
ioDatatype = static_cast<PxU32>( strtoul( ioData,const_cast<char **>(&ioData), 10 ) );
}
};
template<> struct StrToImpl<PxI32> {
PX_INLINE void strto( PxI32& ioDatatype,const char*& ioData )
{
ioDatatype = static_cast<PxI32>( strtoul( ioData,const_cast<char **>(&ioData), 10 ) );
}
};
template<> struct StrToImpl<PxU16> {
PX_INLINE void strto( PxU16& ioDatatype,const char*& ioData )
{
ioDatatype = static_cast<PxU16>( strtoul( ioData,const_cast<char **>(&ioData), 10 ) );
}
};
PX_INLINE void eatwhite(const char*& ioData )
{
if ( ioData )
{
while( isspace( static_cast<unsigned char>(*ioData) ) )
++ioData;
}
}
// copy the source data to the dest buffer until the first whitespace is encountered.
// Do not overflow the buffer based on the bufferLen provided.
// Advance the input 'ioData' pointer so that it sits just at the next whitespace
PX_INLINE void nullTerminateWhite(const char*& ioData,char *buffer,PxU32 bufferLen)
{
if ( ioData )
{
char *eof = buffer+(bufferLen-1);
char *dest = buffer;
while( *ioData && !isspace(static_cast<unsigned char>(*ioData)) && dest < eof )
{
*dest++ = *ioData++;
}
*dest = 0;
}
}
inline void nonNullTerminateWhite(const char*& ioData )
{
if ( ioData )
{
while( *ioData && !isspace( static_cast<unsigned char>(*ioData) ) )
++ioData;
}
}
template<> struct StrToImpl<PxF32> {
inline void strto( PxF32& ioDatatype,const char*& ioData )
{
ioDatatype = strToFloat(ioData,&ioData);
}
};
template<> struct StrToImpl<void*> {
inline void strto( void*& ioDatatype,const char*& ioData )
{
PxU64 theData;
StrToImpl<PxU64>().strto( theData, ioData );
ioDatatype = reinterpret_cast<void*>( size_t( theData ) );
}
};
template<> struct StrToImpl<physx::PxVec3> {
inline void strto( physx::PxVec3& ioDatatype,const char*& ioData )
{
StrToImpl<PxF32>().strto( ioDatatype[0], ioData );
StrToImpl<PxF32>().strto( ioDatatype[1], ioData );
StrToImpl<PxF32>().strto( ioDatatype[2], ioData );
}
};
template<> struct StrToImpl<PxU8*> {
inline void strto( PxU8*& /*ioDatatype*/,const char*& /*ioData*/)
{
}
};
template<> struct StrToImpl<bool> {
inline void strto( bool& ioType,const char*& inValue )
{
ioType = physx::Pxstricmp( inValue, "true" ) == 0 ? true : false;
}
};
template<> struct StrToImpl<PxU8> {
PX_INLINE void strto( PxU8& ioType,const char* & inValue)
{
ioType = static_cast<PxU8>( strtoul( inValue,const_cast<char **>(&inValue), 10 ) );
}
};
template<> struct StrToImpl<PxFilterData> {
PX_INLINE void strto( PxFilterData& ioType,const char*& inValue)
{
ioType.word0 = static_cast<PxU32>( strtoul( inValue,const_cast<char **>(&inValue), 10 ) );
ioType.word1 = static_cast<PxU32>( strtoul( inValue,const_cast<char **>(&inValue), 10 ) );
ioType.word2 = static_cast<PxU32>( strtoul( inValue,const_cast<char **>(&inValue), 10 ) );
ioType.word3 = static_cast<PxU32>( strtoul( inValue, NULL, 10 ) );
}
};
template<> struct StrToImpl<PxQuat> {
PX_INLINE void strto( PxQuat& ioType,const char*& inValue )
{
ioType.x = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
ioType.y = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
ioType.z = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
ioType.w = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
}
};
template<> struct StrToImpl<PxTransform> {
PX_INLINE void strto( PxTransform& ioType,const char*& inValue)
{
ioType.q.x = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
ioType.q.y = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
ioType.q.z = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
ioType.q.w = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
ioType.p[0] = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
ioType.p[1] = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
ioType.p[2] = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
}
};
template<> struct StrToImpl<PxBounds3> {
PX_INLINE void strto( PxBounds3& ioType,const char*& inValue)
{
ioType.minimum[0] = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
ioType.minimum[1] = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
ioType.minimum[2] = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
ioType.maximum[0] = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
ioType.maximum[1] = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
ioType.maximum[2] = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
}
};
template<> struct StrToImpl<PxMetaDataPlane> {
PX_INLINE void strto( PxMetaDataPlane& ioType,const char*& inValue)
{
ioType.normal.x = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
ioType.normal.y = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
ioType.normal.z = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
ioType.distance = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
}
};
template<> struct StrToImpl<PxRigidDynamic*> {
PX_INLINE void strto( PxRigidDynamic*& /*ioDatatype*/,const char*& /*ioData*/)
{
}
};
template<typename TDataType>
inline void strto( TDataType& ioType,const char*& ioData )
{
if ( ioData && *ioData ) StrToImpl<TDataType>().strto( ioType, ioData );
}
template<typename TDataType>
inline void strtoLong( TDataType& ioType,const char*& ioData )
{
if ( ioData && *ioData ) StrToImpl<TDataType>().strto( ioType, ioData );
}
template<typename TDataType>
inline void stringToType( const char* inValue, TDataType& ioType )
{
const char* theValue( inValue );
return strto( ioType, theValue );
}
} }
#endif
| 8,818 | C | 30.723021 | 129 | 0.687571 |
NVIDIA-Omniverse/PhysX/physx/source/scenequery/src/SqCompoundPruningPool.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-2023 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 SQ_COMPOUND_PRUNING_POOL_H
#define SQ_COMPOUND_PRUNING_POOL_H
#include "SqPruner.h"
#include "foundation/PxArray.h"
#include "GuPrunerMergeData.h"
#include "GuIncrementalAABBTree.h"
#include "GuAABBTreeBounds.h"
namespace physx
{
namespace Gu
{
class PruningPool;
}
namespace Sq
{
///////////////////////////////////////////////////////////////////////////////////////////////
typedef PxArray<Gu::IncrementalAABBTreeNode*> UpdateMap;
///////////////////////////////////////////////////////////////////////////////////////////////
class CompoundTree
{
public:
void updateObjectAfterManualBoundsUpdates(Gu::PrunerHandle handle);
void removeObject(Gu::PrunerHandle handle, Gu::PrunerPayloadRemovalCallback* removalCallback);
bool addObject(Gu::PrunerHandle& result, const PxBounds3& bounds, const Gu::PrunerPayload& data, const PxTransform& transform);
private:
void updateMapping(const Gu::PoolIndex poolIndex, Gu::IncrementalAABBTreeNode* node, const Gu::NodeList& changedLeaves);
public:
Gu::IncrementalAABBTree* mTree;
Gu::PruningPool* mPruningPool;
UpdateMap* mUpdateMap;
PxTransform mGlobalPose;
PxCompoundPrunerQueryFlags mFlags;
};
///////////////////////////////////////////////////////////////////////////////////////////////
class CompoundTreePool
{
public:
CompoundTreePool(PxU64 contextID);
~CompoundTreePool();
void preallocate(PxU32 newCapacity);
Gu::PoolIndex addCompound(Gu::PrunerHandle* results, const Gu::BVH& bvh, const PxBounds3& compoundBounds, const PxTransform& transform, bool isDynamic, const Gu::PrunerPayload* data, const PxTransform* transforms);
Gu::PoolIndex removeCompound(Gu::PoolIndex index, Gu::PrunerPayloadRemovalCallback* removalCallback);
void shiftOrigin(const PxVec3& shift);
PX_FORCE_INLINE const Gu::AABBTreeBounds& getCurrentAABBTreeBounds() const { return mCompoundBounds; }
PX_FORCE_INLINE const PxBounds3* getCurrentCompoundBounds() const { return mCompoundBounds.getBounds(); }
PX_FORCE_INLINE PxBounds3* getCurrentCompoundBounds() { return mCompoundBounds.getBounds(); }
PX_FORCE_INLINE const CompoundTree* getCompoundTrees() const { return mCompoundTrees; }
PX_FORCE_INLINE CompoundTree* getCompoundTrees() { return mCompoundTrees; }
PX_FORCE_INLINE PxU32 getNbObjects() const { return mNbObjects; }
private:
bool resize(PxU32 newCapacity);
PxU32 mNbObjects; //!< Current number of objects
PxU32 mMaxNbObjects; //!< Max. number of objects (capacity for mWorldBoxes, mObjects)
//!< these arrays are parallel
Gu::AABBTreeBounds mCompoundBounds; //!< List of compound world boxes, stores mNbObjects, capacity=mMaxNbObjects
CompoundTree* mCompoundTrees;
PxU64 mContextID;
};
}
}
#endif
| 4,587 | C | 39.60177 | 223 | 0.696752 |
NVIDIA-Omniverse/PhysX/physx/source/scenequery/src/SqCompoundPruningPool.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "foundation/PxAllocator.h"
#include "SqCompoundPruningPool.h"
#include "GuPruningPool.h"
#include "GuAABBTree.h"
#include "GuBVH.h"
using namespace physx;
using namespace Cm;
using namespace Gu;
using namespace Sq;
///////////////////////////////////////////////////////////////////////////////////////////////
void CompoundTree::updateObjectAfterManualBoundsUpdates(PrunerHandle handle)
{
const PxBounds3* newBounds = mPruningPool->getCurrentWorldBoxes();
const PoolIndex poolIndex = mPruningPool->getIndex(handle);
NodeList changedLeaves;
changedLeaves.reserve(8);
IncrementalAABBTreeNode* node = mTree->update((*mUpdateMap)[poolIndex], poolIndex, newBounds, changedLeaves);
// we removed node during update, need to update the mapping
updateMapping(poolIndex, node, changedLeaves);
}
///////////////////////////////////////////////////////////////////////////////////////////////
void CompoundTree::removeObject(PrunerHandle handle, PrunerPayloadRemovalCallback* removalCallback)
{
const PoolIndex poolIndex = mPruningPool->getIndex(handle); // save the pool index for removed object
const PoolIndex poolRelocatedLastIndex = mPruningPool->removeObject(handle, removalCallback); // save the lastIndex returned by removeObject
IncrementalAABBTreeNode* node = mTree->remove((*mUpdateMap)[poolIndex], poolIndex, mPruningPool->getCurrentWorldBoxes());
// if node moved to its parent
if (node && node->isLeaf())
{
for (PxU32 j = 0; j < node->getNbPrimitives(); j++)
{
const PoolIndex index = node->getPrimitives(NULL)[j];
(*mUpdateMap)[index] = node;
}
}
(*mUpdateMap)[poolIndex] = (*mUpdateMap)[poolRelocatedLastIndex];
// fix indices if we made a swap
if(poolRelocatedLastIndex != poolIndex)
mTree->fixupTreeIndices((*mUpdateMap)[poolIndex], poolRelocatedLastIndex, poolIndex);
}
///////////////////////////////////////////////////////////////////////////////////////////////
bool CompoundTree::addObject(PrunerHandle& result, const PxBounds3& bounds, const PrunerPayload& data, const PxTransform& transform)
{
mPruningPool->addObjects(&result, &bounds, &data, &transform, 1);
if (mPruningPool->mMaxNbObjects > mUpdateMap->size())
mUpdateMap->resize(mPruningPool->mMaxNbObjects);
const PoolIndex poolIndex = mPruningPool->getIndex(result);
NodeList changedLeaves;
changedLeaves.reserve(8);
IncrementalAABBTreeNode* node = mTree->insert(poolIndex, mPruningPool->getCurrentWorldBoxes(), changedLeaves);
updateMapping(poolIndex, node, changedLeaves);
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
void CompoundTree::updateMapping(const PoolIndex poolIndex, IncrementalAABBTreeNode* node, const NodeList& changedLeaves)
{
// if a node was split we need to update the node indices and also the sibling indices
if(!changedLeaves.empty())
{
if(node && node->isLeaf())
{
for(PxU32 j = 0; j < node->getNbPrimitives(); j++)
{
const PoolIndex index = node->getPrimitives(NULL)[j];
(*mUpdateMap)[index] = node;
}
}
for(PxU32 i = 0; i < changedLeaves.size(); i++)
{
IncrementalAABBTreeNode* changedNode = changedLeaves[i];
PX_ASSERT(changedNode->isLeaf());
for(PxU32 j = 0; j < changedNode->getNbPrimitives(); j++)
{
const PoolIndex index = changedNode->getPrimitives(NULL)[j];
(*mUpdateMap)[index] = changedNode;
}
}
}
else
{
(*mUpdateMap)[poolIndex] = node;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
CompoundTreePool::CompoundTreePool(PxU64 contextID) :
mNbObjects (0),
mMaxNbObjects (0),
mCompoundTrees (NULL),
mContextID (contextID)
{
}
///////////////////////////////////////////////////////////////////////////////////////////////
CompoundTreePool::~CompoundTreePool()
{
PX_FREE(mCompoundTrees);
}
///////////////////////////////////////////////////////////////////////////////////////////////
bool CompoundTreePool::resize(PxU32 newCapacity)
{
mCompoundBounds.resize(newCapacity, mNbObjects);
CompoundTree* newTrees = PX_ALLOCATE(CompoundTree, newCapacity, "IncrementalTrees*");
if(!newTrees)
return false;
// memzero, we need to set the pointers in the compound tree to NULL
PxMemZero(newTrees, sizeof(CompoundTree)*newCapacity);
if(mCompoundTrees)
PxMemCopy(newTrees, mCompoundTrees, mNbObjects*sizeof(CompoundTree));
mMaxNbObjects = newCapacity;
PX_FREE(mCompoundTrees);
mCompoundTrees = newTrees;
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
void CompoundTreePool::preallocate(PxU32 newCapacity)
{
if(newCapacity>mMaxNbObjects)
resize(newCapacity);
}
///////////////////////////////////////////////////////////////////////////////////////////////
void CompoundTreePool::shiftOrigin(const PxVec3& shift)
{
PxBounds3* bounds = mCompoundBounds.getBounds();
for(PxU32 i=0; i < mNbObjects; i++)
{
bounds[i].minimum -= shift;
bounds[i].maximum -= shift;
mCompoundTrees[i].mGlobalPose.p -= shift;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
PoolIndex CompoundTreePool::addCompound(PrunerHandle* results, const BVH& bvh, const PxBounds3& compoundBounds, const PxTransform& transform, bool isDynamic, const PrunerPayload* data, const PxTransform* transforms)
{
if(mNbObjects==mMaxNbObjects) // increase the capacity on overflow
{
if(!resize(PxMax<PxU32>(mMaxNbObjects*2, 32)))
{
// pool can return an invalid handle if memory alloc fails
PxGetFoundation().error(PxErrorCode::eOUT_OF_MEMORY, PX_FL, "CompoundTreePool::addCompound memory allocation in resize failed.");
return INVALID_PRUNERHANDLE;
}
}
PX_ASSERT(mNbObjects!=mMaxNbObjects);
const PoolIndex index = mNbObjects++;
mCompoundBounds.getBounds()[index] = compoundBounds;
const PxU32 nbObjects = bvh.getNbBounds();
CompoundTree& tree = mCompoundTrees[index];
PX_ASSERT(tree.mPruningPool == NULL);
PX_ASSERT(tree.mTree == NULL);
PX_ASSERT(tree.mUpdateMap == NULL);
tree.mGlobalPose = transform;
tree.mFlags = isDynamic ? PxCompoundPrunerQueryFlag::eDYNAMIC : PxCompoundPrunerQueryFlag::eSTATIC;
// prepare the pruning pool
PruningPool* pool = PX_NEW(PruningPool)(mContextID, TRANSFORM_CACHE_LOCAL);
pool->preallocate(nbObjects);
pool->addObjects(results, bvh.getBounds(), data, transforms, nbObjects);
tree.mPruningPool = pool;
// prepare update map
UpdateMap* map = PX_PLACEMENT_NEW(PX_ALLOC(sizeof(UpdateMap), "Update map"), UpdateMap);
map->resizeUninitialized(nbObjects);
tree.mUpdateMap = map;
IncrementalAABBTree* iTree = PX_NEW(IncrementalAABBTree);
iTree->copy(bvh, *map);
tree.mTree = iTree;
return index;
}
///////////////////////////////////////////////////////////////////////////////////////////////
PoolIndex CompoundTreePool::removeCompound(PoolIndex indexOfRemovedObject, PrunerPayloadRemovalCallback* removalCallback)
{
PX_ASSERT(mNbObjects);
// release the tree
PX_DELETE(mCompoundTrees[indexOfRemovedObject].mTree);
mCompoundTrees[indexOfRemovedObject].mUpdateMap->clear();
mCompoundTrees[indexOfRemovedObject].mUpdateMap->~PxArray();
PX_FREE(mCompoundTrees[indexOfRemovedObject].mUpdateMap);
if(removalCallback)
{
const PruningPool* pool = mCompoundTrees[indexOfRemovedObject].mPruningPool;
removalCallback->invoke(pool->getNbActiveObjects(), pool->getObjects());
}
PX_DELETE(mCompoundTrees[indexOfRemovedObject].mPruningPool);
const PoolIndex indexOfLastObject = --mNbObjects; // swap the object at last index with index
if(indexOfLastObject!=indexOfRemovedObject)
{
// PT: move last object's data to recycled spot (from removed object)
// PT: the last object has moved so we need to handle the mappings for this object
mCompoundBounds.getBounds() [indexOfRemovedObject] = mCompoundBounds.getBounds() [indexOfLastObject];
mCompoundTrees [indexOfRemovedObject] = mCompoundTrees [indexOfLastObject];
mCompoundTrees [indexOfLastObject].mPruningPool = NULL;
mCompoundTrees [indexOfLastObject].mUpdateMap = NULL;
mCompoundTrees [indexOfLastObject].mTree = NULL;
}
return indexOfLastObject;
}
| 9,880 | C++ | 35.327206 | 215 | 0.676923 |
NVIDIA-Omniverse/PhysX/physx/source/scenequery/src/SqManager.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
// PT: SQ-API LEVEL 2 (Level 1 = SqPruner.h)
// PT: this file is part of a "high-level" set of files within Sq. The SqPruner API doesn't rely on them.
// PT: this should really be at Np level but moving it to Sq allows us to share it.
#include "SqManager.h"
#include "GuSqInternal.h"
#include "GuBounds.h"
using namespace physx;
using namespace Sq;
using namespace Gu;
PrunerExt::PrunerExt() : mPruner(NULL), mDirtyList("SQmDirtyList"), mDirtyStatic(false)
{
}
PrunerExt::~PrunerExt()
{
PX_DELETE(mPruner);
}
void PrunerExt::init(Pruner* pruner)
{
mPruner = pruner;
}
void PrunerExt::preallocate(PxU32 nbShapes)
{
// if(nbShapes > mDirtyMap.size())
// mDirtyMap.resize(nbShapes);
if(mPruner)
mPruner->preallocate(nbShapes);
}
void PrunerExt::flushMemory()
{
if(!mDirtyList.size())
mDirtyList.reset();
// PT: TODO: flush bitmap here
// PT: TODO: flush pruner here?
}
void PrunerExt::addToDirtyList(PrunerHandle handle, bool dynamic, const PxTransform& transform)
{
if(mPruner)
mPruner->setTransform(handle, transform);
PxBitMap& dirtyMap = mDirtyMap;
{
if(dirtyMap.size() <= handle)
{
PxU32 size = PxMax<PxU32>(dirtyMap.size()*2, 1024);
const PxU32 minSize = handle+1;
if(minSize>size)
size = minSize*2;
dirtyMap.resize(size);
PX_ASSERT(handle<dirtyMap.size());
PX_ASSERT(!dirtyMap.test(handle));
}
}
if(!dirtyMap.test(handle))
{
dirtyMap.set(handle);
mDirtyList.pushBack(handle);
}
if(!dynamic)
mDirtyStatic = true;
}
void PrunerExt::removeFromDirtyList(PrunerHandle handle)
{
PxBitMap& dirtyMap = mDirtyMap;
// if(dirtyMap.test(handle))
if(dirtyMap.boundedTest(handle))
{
dirtyMap.reset(handle);
mDirtyList.findAndReplaceWithLast(handle);
}
// PT: if we remove the object that made us set mDirtyStatic to true, tough luck,
// we don't bother fixing that bool here. It's going to potentially cause an
// unnecessary update of the character controller's caches, which is not a big deal.
}
bool PrunerExt::processDirtyList(PxU32 index, const Adapter& adapter, float inflation)
{
const PxU32 numDirtyList = mDirtyList.size();
if(!numDirtyList)
return false;
const PrunerHandle* const prunerHandles = mDirtyList.begin();
for(PxU32 i=0; i<numDirtyList; i++)
{
const PrunerHandle handle = prunerHandles[i];
mDirtyMap.reset(handle);
// PT: we compute the new bounds and store them directly in the pruner structure to avoid copies. We delay the updateObjects() call
// to take advantage of batching.
PX_UNUSED(index);
PrunerPayloadData ppd;
const PrunerPayload& pp = mPruner->getPayloadData(handle, &ppd);
computeBounds(*ppd.mBounds, adapter.getGeometry(pp), *ppd.mTransform, 0.0f, inflation);
}
// PT: batch update happens after the loop instead of once per loop iteration
mPruner->updateObjects(prunerHandles, numDirtyList);
mDirtyList.clear();
const bool ret = mDirtyStatic;
mDirtyStatic = false;
return ret;
}
// PT: TODO: re-inline this
/*void PrunerExt::growDirtyList(PrunerHandle handle)
{
// pruners must either provide indices in order or reuse existing indices, so this 'if' is enough to ensure we have space for the new handle
// PT: TODO: fix this. There is just no need for any of it. The pruning pool itself could support the feature for free, similar to what we do
// in MBP. There would be no need for the bitmap or the dirty list array. However doing this through the virtual interface would be clumsy,
// adding the cost of virtual calls for very cheap & simple operations. It would be a lot easier to drop it and go back to what we had before.
PxBitMap& dirtyMap = mDirtyMap;
if(dirtyMap.size() <= handle)
dirtyMap.resize(PxMax<PxU32>(dirtyMap.size() * 2, 1024));
PX_ASSERT(handle<dirtyMap.size());
dirtyMap.reset(handle);
}*/
///////////////////////////////////////////////////////////////////////////////
CompoundPrunerExt::CompoundPrunerExt() :
mPruner (NULL)
{
}
CompoundPrunerExt::~CompoundPrunerExt()
{
PX_DELETE(mPruner);
}
void CompoundPrunerExt::preallocate(PxU32 nbShapes)
{
// if(nbShapes > mDirtyList.size())
// mDirtyList.reserve(nbShapes);
if(mPruner)
mPruner->preallocate(nbShapes);
}
void CompoundPrunerExt::flushMemory()
{
if(!mDirtyList.size())
mDirtyList.clear();
}
void CompoundPrunerExt::flushShapes(const Adapter& adapter, float inflation)
{
const PxU32 numDirtyList = mDirtyList.size();
if(!numDirtyList)
return;
const CompoundPair* const compoundPairs = mDirtyList.getEntries();
for(PxU32 i=0; i<numDirtyList; i++)
{
const PrunerHandle handle = compoundPairs[i].second;
const PrunerCompoundId compoundId = compoundPairs[i].first;
// PT: we compute the new bounds and store them directly in the pruner structure to avoid copies. We delay the updateObjects() call
// to take advantage of batching.
PrunerPayloadData ppd;
const PrunerPayload& pp = mPruner->getPayloadData(handle, compoundId, &ppd);
computeBounds(*ppd.mBounds, adapter.getGeometry(pp), *ppd.mTransform, 0.0f, inflation);
// A.B. not very effective, we might do better here
mPruner->updateObjectAfterManualBoundsUpdates(compoundId, handle);
}
mDirtyList.clear();
}
void CompoundPrunerExt::addToDirtyList(PrunerCompoundId compoundId, PrunerHandle handle, const PxTransform& transform)
{
if(mPruner)
mPruner->setTransform(handle, compoundId, transform);
mDirtyList.insert(CompoundPair(compoundId, handle));
}
void CompoundPrunerExt::removeFromDirtyList(PrunerCompoundId compoundId, PrunerHandle handle)
{
mDirtyList.erase(CompoundPair(compoundId, handle));
}
///////////////////////////////////////////////////////////////////////////////
#include "SqFactory.h"
#include "common/PxProfileZone.h"
#include "common/PxRenderBuffer.h"
#include "GuBVH.h"
#include "foundation/PxAlloca.h"
#include "PxSceneDesc.h" // PT: for PxSceneLimits TODO: remove
namespace
{
enum PxScenePrunerIndex
{
PX_SCENE_PRUNER_STATIC = 0,
PX_SCENE_PRUNER_DYNAMIC = 1,
PX_SCENE_COMPOUND_PRUNER = 0xffffffff,
};
}
PrunerManager::PrunerManager( PxU64 contextID, Pruner* staticPruner, Pruner* dynamicPruner,
PxU32 dynamicTreeRebuildRateHint, float inflation,
const PxSceneLimits& limits, const Adapter& adapter) :
mAdapter (adapter),
mContextID (contextID),
mStaticTimestamp (0),
mInflation (inflation)
{
mPrunerExt[PruningIndex::eSTATIC].init(staticPruner);
mPrunerExt[PruningIndex::eDYNAMIC].init(dynamicPruner);
setDynamicTreeRebuildRateHint(dynamicTreeRebuildRateHint);
mCompoundPrunerExt.mPruner = createCompoundPruner(contextID);
preallocate(PruningIndex::eSTATIC, limits.maxNbStaticShapes);
preallocate(PruningIndex::eDYNAMIC, limits.maxNbDynamicShapes);
preallocate(PxU32(PX_SCENE_COMPOUND_PRUNER), 32);
mPrunerNeedsUpdating = false;
}
PrunerManager::~PrunerManager()
{
}
void PrunerManager::preallocate(PxU32 prunerIndex, PxU32 nbShapes)
{
if(prunerIndex==PruningIndex::eSTATIC)
mPrunerExt[PruningIndex::eSTATIC].preallocate(nbShapes);
else if(prunerIndex==PruningIndex::eDYNAMIC)
mPrunerExt[PruningIndex::eDYNAMIC].preallocate(nbShapes);
else if(prunerIndex==PX_SCENE_COMPOUND_PRUNER)
mCompoundPrunerExt.preallocate(nbShapes);
}
void PrunerManager::flushMemory()
{
for(PxU32 i=0;i<PruningIndex::eCOUNT;i++)
mPrunerExt[i].flushMemory();
mCompoundPrunerExt.flushMemory();
}
PrunerData PrunerManager::addPrunerShape(const PrunerPayload& payload, bool dynamic, PrunerCompoundId compoundId, const PxBounds3& bounds, const PxTransform& transform, bool hasPruningStructure)
{
mPrunerNeedsUpdating = true;
const PxU32 index = PxU32(dynamic);
if(!index)
invalidateStaticTimestamp();
PrunerHandle handle;
if(compoundId == INVALID_COMPOUND_ID)
{
PX_ASSERT(mPrunerExt[index].pruner());
mPrunerExt[index].pruner()->addObjects(&handle, &bounds, &payload, &transform, 1, hasPruningStructure);
//mPrunerExt[index].growDirtyList(handle);
}
else
{
PX_ASSERT(mCompoundPrunerExt.pruner());
mCompoundPrunerExt.pruner()->addObject(compoundId, handle, bounds, payload, transform);
}
return createPrunerData(index, handle);
}
void PrunerManager::removePrunerShape(PrunerCompoundId compoundId, PrunerData data, PrunerPayloadRemovalCallback* removalCallback)
{
mPrunerNeedsUpdating = true;
const PxU32 index = getPrunerIndex(data);
const PrunerHandle handle = getPrunerHandle(data);
if(!index)
invalidateStaticTimestamp();
if(compoundId == INVALID_COMPOUND_ID)
{
PX_ASSERT(mPrunerExt[index].pruner());
mPrunerExt[index].removeFromDirtyList(handle);
mPrunerExt[index].pruner()->removeObjects(&handle, 1, removalCallback);
}
else
{
mCompoundPrunerExt.removeFromDirtyList(compoundId, handle);
mCompoundPrunerExt.pruner()->removeObject(compoundId, handle, removalCallback);
}
}
void PrunerManager::markForUpdate(PrunerCompoundId compoundId, PrunerData data, const PxTransform& transform)
{
mPrunerNeedsUpdating = true;
const PxU32 index = getPrunerIndex(data);
const PrunerHandle handle = getPrunerHandle(data);
if(!index)
invalidateStaticTimestamp();
if(compoundId == INVALID_COMPOUND_ID)
// PT: TODO: at this point do we still need a dirty list? we could just update the bounds directly?
mPrunerExt[index].addToDirtyList(handle, index!=0, transform);
else
mCompoundPrunerExt.addToDirtyList(compoundId, handle, transform);
}
void PrunerManager::setDynamicTreeRebuildRateHint(PxU32 rebuildRateHint)
{
mRebuildRateHint = rebuildRateHint;
for(PxU32 i=0;i<PruningIndex::eCOUNT;i++)
{
Pruner* pruner = mPrunerExt[i].pruner();
if(pruner && pruner->isDynamic())
static_cast<DynamicPruner*>(pruner)->setRebuildRateHint(rebuildRateHint);
}
}
void PrunerManager::afterSync(bool buildStep, bool commit)
{
PX_PROFILE_ZONE("Sim.sceneQueryBuildStep", mContextID);
if(!buildStep && !commit)
{
mPrunerNeedsUpdating = true;
return;
}
// flush user modified objects
flushShapes();
for(PxU32 i=0; i<PruningIndex::eCOUNT; i++)
{
Pruner* pruner = mPrunerExt[i].pruner();
if(pruner)
{
if(pruner->isDynamic())
static_cast<DynamicPruner*>(pruner)->buildStep(true);
if(commit)
pruner->commit();
}
}
mPrunerNeedsUpdating = !commit;
}
void PrunerManager::flushShapes()
{
PX_PROFILE_ZONE("SceneQuery.flushShapes", mContextID);
// must already have acquired writer lock here
const float inflation = 1.0f + mInflation;
bool mustInvalidateStaticTimestamp = false;
for(PxU32 i=0; i<PruningIndex::eCOUNT; i++)
{
if(mPrunerExt[i].processDirtyList(i, mAdapter, inflation))
mustInvalidateStaticTimestamp = true;
}
if(mustInvalidateStaticTimestamp)
invalidateStaticTimestamp();
mCompoundPrunerExt.flushShapes(mAdapter, inflation);
}
void PrunerManager::flushUpdates()
{
PX_PROFILE_ZONE("SceneQuery.flushUpdates", mContextID);
if(mPrunerNeedsUpdating)
{
// no need to take lock if manual sq update is enabled
// as flushUpdates will only be called from NpScene::flushQueryUpdates()
mSQLock.lock();
if(mPrunerNeedsUpdating)
{
flushShapes();
for(PxU32 i=0; i<PruningIndex::eCOUNT; i++)
if(mPrunerExt[i].pruner())
mPrunerExt[i].pruner()->commit();
PxMemoryBarrier();
mPrunerNeedsUpdating = false;
}
mSQLock.unlock();
}
}
void PrunerManager::forceRebuildDynamicTree(PxU32 prunerIndex)
{
PX_PROFILE_ZONE("SceneQuery.forceDynamicTreeRebuild", mContextID);
PxMutex::ScopedLock lock(mSQLock);
Pruner* pruner = mPrunerExt[prunerIndex].pruner();
if(pruner && pruner->isDynamic())
{
static_cast<DynamicPruner*>(pruner)->purge();
static_cast<DynamicPruner*>(pruner)->commit();
}
}
void* PrunerManager::prepareSceneQueriesUpdate(PruningIndex::Enum index)
{
bool retVal = false;
Pruner* pruner = mPrunerExt[index].pruner();
if(pruner && pruner->isDynamic())
retVal = static_cast<DynamicPruner*>(pruner)->prepareBuild();
return retVal ? pruner : NULL;
}
void PrunerManager::sceneQueryBuildStep(void* handle)
{
PX_PROFILE_ZONE("SceneQuery.sceneQueryBuildStep", mContextID);
Pruner* pruner = reinterpret_cast<Pruner*>(handle);
if(pruner && pruner->isDynamic())
{
const bool buildFinished = static_cast<DynamicPruner*>(pruner)->buildStep(false);
if(buildFinished)
mPrunerNeedsUpdating = true;
}
}
// PT: TODO: revisit this. Perhaps it should be the user's responsibility to call the pruner's
// visualize functions directly, when & how he wants.
void PrunerManager::visualize(PxU32 prunerIndex, PxRenderOutput& out) const
{
if(prunerIndex==PX_SCENE_PRUNER_STATIC)
{
if(getPruner(PruningIndex::eSTATIC))
getPruner(PruningIndex::eSTATIC)->visualize(out, SQ_DEBUG_VIZ_STATIC_COLOR, SQ_DEBUG_VIZ_STATIC_COLOR2);
}
else if(prunerIndex==PX_SCENE_PRUNER_DYNAMIC)
{
if(getPruner(PruningIndex::eDYNAMIC))
getPruner(PruningIndex::eDYNAMIC)->visualize(out, SQ_DEBUG_VIZ_DYNAMIC_COLOR, SQ_DEBUG_VIZ_DYNAMIC_COLOR2);
}
else if(prunerIndex==PX_SCENE_COMPOUND_PRUNER)
{
const CompoundPruner* cp = mCompoundPrunerExt.pruner();
if(cp)
cp->visualizeEx(out, SQ_DEBUG_VIZ_COMPOUND_COLOR, true, true);
}
}
void PrunerManager::shiftOrigin(const PxVec3& shift)
{
for(PxU32 i=0; i<PruningIndex::eCOUNT; i++)
mPrunerExt[i].pruner()->shiftOrigin(shift);
mCompoundPrunerExt.pruner()->shiftOrigin(shift);
}
void PrunerManager::addCompoundShape(const PxBVH& pxbvh, PrunerCompoundId compoundId, const PxTransform& compoundTransform, PrunerData* prunerData, const PrunerPayload* payloads, const PxTransform* transforms, bool isDynamic)
{
const BVH& bvh = static_cast<const BVH&>(pxbvh);
const PxU32 nbShapes = bvh.Gu::BVH::getNbBounds();
PX_ALLOCA(res, PrunerHandle, nbShapes);
PX_ASSERT(mCompoundPrunerExt.mPruner);
mCompoundPrunerExt.mPruner->addCompound(res, bvh, compoundId, compoundTransform, isDynamic, payloads, transforms);
const PxU32 index = PxU32(isDynamic);
if(!index)
invalidateStaticTimestamp();
for(PxU32 i = 0; i < nbShapes; i++)
prunerData[i] = createPrunerData(index, res[i]);
}
void PrunerManager::updateCompoundActor(PrunerCompoundId compoundId, const PxTransform& compoundTransform)
{
PX_ASSERT(mCompoundPrunerExt.mPruner);
const bool isDynamic = mCompoundPrunerExt.mPruner->updateCompound(compoundId, compoundTransform);
if(!isDynamic)
invalidateStaticTimestamp();
}
void PrunerManager::removeCompoundActor(PrunerCompoundId compoundId, PrunerPayloadRemovalCallback* removalCallback)
{
PX_ASSERT(mCompoundPrunerExt.mPruner);
const bool isDynamic = mCompoundPrunerExt.mPruner->removeCompound(compoundId, removalCallback);
if(!isDynamic)
invalidateStaticTimestamp();
}
void PrunerManager::sync(const PrunerHandle* handles, const PxU32* boundsIndices, const PxBounds3* bounds, const PxTransform32* transforms, PxU32 count, const PxBitMap& ignoredIndices)
{
if(!count)
return;
Pruner* dynamicPruner = getPruner(PruningIndex::eDYNAMIC);
if(!dynamicPruner)
return;
PxU32 startIndex = 0;
PxU32 numIndices = count;
// if shape sim map is not empty, parse the indices and skip update for the dirty one
if(ignoredIndices.count())
{
// PT: I think this codepath was used with SCB / buffered changes, but it's not needed anymore
numIndices = 0;
for(PxU32 i=0; i<count; i++)
{
// if(ignoredIndices.test(boundsIndices[i]))
if(ignoredIndices.boundedTest(boundsIndices[i]))
{
dynamicPruner->updateObjects(handles + startIndex, numIndices, mInflation, boundsIndices + startIndex, bounds, transforms);
numIndices = 0;
startIndex = i + 1;
}
else
numIndices++;
}
// PT: we fallback to the next line on purpose - no "else"
}
dynamicPruner->updateObjects(handles + startIndex, numIndices, mInflation, boundsIndices + startIndex, bounds, transforms);
}
| 17,319 | C++ | 28.965398 | 225 | 0.743519 |
NVIDIA-Omniverse/PhysX/physx/source/scenequery/src/SqCompoundPruner.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "SqCompoundPruner.h"
#include "GuSqInternal.h"
#include "GuIncrementalAABBTree.h"
#include "GuPruningPool.h"
#include "GuAABBTreeQuery.h"
#include "GuAABBTreeNode.h"
#include "GuSphere.h"
#include "GuBox.h"
#include "GuCapsule.h"
#include "GuBVH.h"
#include "GuQuery.h"
#include "GuInternal.h"
#include "common/PxRenderBuffer.h"
#include "common/PxRenderOutput.h"
#include "CmVisualization.h"
using namespace physx;
using namespace Gu;
using namespace Sq;
// PT: TODO: this is copied from SqBounds.h, should be either moved to Gu and shared or passed as a user parameter
#define SQ_PRUNER_EPSILON 0.005f
#define SQ_PRUNER_INFLATION (1.0f + SQ_PRUNER_EPSILON) // pruner test shape inflation (not narrow phase shape)
#define PARANOIA_CHECKS 0
///////////////////////////////////////////////////////////////////////////////////////////////
BVHCompoundPruner::BVHCompoundPruner(PxU64 contextID) : mCompoundTreePool(contextID), mDrawStatic(false), mDrawDynamic(false)
{
preallocate(32);
}
///////////////////////////////////////////////////////////////////////////////////////////////
BVHCompoundPruner::~BVHCompoundPruner()
{
}
///////////////////////////////////////////////////////////////////////////////////////////////
bool BVHCompoundPruner::addCompound(PrunerHandle* results, const BVH& bvh, PrunerCompoundId compoundId, const PxTransform& transform, bool isDynamic, const PrunerPayload* data, const PxTransform* transforms)
{
PX_ASSERT(bvh.getNbBounds());
const PxBounds3 compoundBounds = PxBounds3::transformFast(transform, bvh.getNodes()->mBV);
const PoolIndex poolIndex = mCompoundTreePool.addCompound(results, bvh, compoundBounds, transform, isDynamic, data, transforms);
mChangedLeaves.clear();
IncrementalAABBTreeNode* node = mMainTree.insert(poolIndex, mCompoundTreePool.getCurrentCompoundBounds(), mChangedLeaves);
updateMapping(poolIndex, node);
mActorPoolMap[compoundId] = poolIndex;
mPoolActorMap[poolIndex] = compoundId;
#if PARANOIA_CHECKS
test();
#endif
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
void BVHCompoundPruner::updateMapping(const PoolIndex poolIndex, IncrementalAABBTreeNode* node)
{
// resize mapping if needed
if(mMainTreeUpdateMap.size() <= poolIndex)
{
const PxU32 resizeSize = mMainTreeUpdateMap.size() * 2;
mMainTreeUpdateMap.resize(resizeSize);
mPoolActorMap.resize(resizeSize);
}
// if a node was split we need to update the node indices and also the sibling indices
if(!mChangedLeaves.empty())
{
if(node && node->isLeaf())
{
for(PxU32 j = 0; j < node->getNbPrimitives(); j++)
{
mMainTreeUpdateMap[node->getPrimitives(NULL)[j]] = node;
}
}
for(PxU32 i = 0; i < mChangedLeaves.size(); i++)
{
IncrementalAABBTreeNode* changedNode = mChangedLeaves[i];
PX_ASSERT(changedNode->isLeaf());
for(PxU32 j = 0; j < changedNode->getNbPrimitives(); j++)
{
mMainTreeUpdateMap[changedNode->getPrimitives(NULL)[j]] = changedNode;
}
}
}
else
{
mMainTreeUpdateMap[poolIndex] = node;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
bool BVHCompoundPruner::removeCompound(PrunerCompoundId compoundId, PrunerPayloadRemovalCallback* removalCallback)
{
const ActorIdPoolIndexMap::Entry* poolIndexEntry = mActorPoolMap.find(compoundId);
PX_ASSERT(poolIndexEntry);
bool isDynamic = false;
if(poolIndexEntry)
{
const PoolIndex poolIndex = poolIndexEntry->second;
CompoundTree& compoundTree = mCompoundTreePool.getCompoundTrees()[poolIndex];
isDynamic = compoundTree.mFlags & PxCompoundPrunerQueryFlag::eDYNAMIC;
const PoolIndex poolRelocatedLastIndex = mCompoundTreePool.removeCompound(poolIndex, removalCallback);
IncrementalAABBTreeNode* node = mMainTree.remove(mMainTreeUpdateMap[poolIndex], poolIndex, mCompoundTreePool.getCurrentCompoundBounds());
// if node moved to its parent
if(node && node->isLeaf())
{
for (PxU32 j = 0; j < node->getNbPrimitives(); j++)
{
const PoolIndex index = node->getPrimitives(NULL)[j];
mMainTreeUpdateMap[index] = node;
}
}
// fix indices if we made a swap
if(poolRelocatedLastIndex != poolIndex)
{
mMainTreeUpdateMap[poolIndex] = mMainTreeUpdateMap[poolRelocatedLastIndex];
mMainTree.fixupTreeIndices(mMainTreeUpdateMap[poolIndex], poolRelocatedLastIndex, poolIndex);
mActorPoolMap[mPoolActorMap[poolRelocatedLastIndex]] = poolIndex;
mPoolActorMap[poolIndex] = mPoolActorMap[poolRelocatedLastIndex];
}
mActorPoolMap.erase(compoundId);
}
#if PARANOIA_CHECKS
test();
#endif
return isDynamic;
}
///////////////////////////////////////////////////////////////////////////////////////////////
bool BVHCompoundPruner::updateCompound(PrunerCompoundId compoundId, const PxTransform& transform)
{
const ActorIdPoolIndexMap::Entry* poolIndexEntry = mActorPoolMap.find(compoundId);
PX_ASSERT(poolIndexEntry);
bool isDynamic = false;
if(poolIndexEntry)
{
const PxU32 poolIndex = poolIndexEntry->second;
CompoundTree& compoundTree = mCompoundTreePool.getCompoundTrees()[poolIndex];
isDynamic = compoundTree.mFlags & PxCompoundPrunerQueryFlag::eDYNAMIC;
compoundTree.mGlobalPose = transform;
PxBounds3 localBounds;
const IncrementalAABBTreeNode* node = compoundTree.mTree->getNodes();
V4StoreU(node->mBVMin, &localBounds.minimum.x);
PX_ALIGN(16, PxVec4) max4;
V4StoreA(node->mBVMax, &max4.x);
localBounds.maximum = PxVec3(max4.x, max4.y, max4.z);
const PxBounds3 compoundBounds = PxBounds3::transformFast(transform, localBounds);
mCompoundTreePool.getCurrentCompoundBounds()[poolIndex] = compoundBounds;
mChangedLeaves.clear();
IncrementalAABBTreeNode* mainTreeNode = mMainTree.update(mMainTreeUpdateMap[poolIndex], poolIndex, mCompoundTreePool.getCurrentCompoundBounds(), mChangedLeaves);
// we removed node during update, need to update the mapping
updateMapping(poolIndex, mainTreeNode);
}
#if PARANOIA_CHECKS
test();
#endif
return isDynamic;
}
///////////////////////////////////////////////////////////////////////////////////////////////
void BVHCompoundPruner::test()
{
if(mMainTree.getNodes())
{
for(PxU32 i = 0; i < mCompoundTreePool.getNbObjects(); i++)
{
mMainTree.checkTreeLeaf(mMainTreeUpdateMap[i], i);
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
void BVHCompoundPruner::release()
{
}
//////////////////////////////////////////////////////////////////////////
// Queries implementation
//////////////////////////////////////////////////////////////////////////
namespace
{
struct CompoundCallbackRaycastAdapter
{
PX_FORCE_INLINE CompoundCallbackRaycastAdapter(CompoundPrunerRaycastCallback& pcb, const CompoundTree& tree) : mCallback(pcb), mTree(tree) {}
PX_FORCE_INLINE bool invoke(PxReal& distance, PxU32 primIndex)
{
return mCallback.invoke(distance, primIndex, mTree.mPruningPool->getObjects(), mTree.mPruningPool->getTransforms(), &mTree.mGlobalPose);
}
CompoundPrunerRaycastCallback& mCallback;
const CompoundTree& mTree;
PX_NOCOPY(CompoundCallbackRaycastAdapter)
};
struct CompoundCallbackOverlapAdapter
{
PX_FORCE_INLINE CompoundCallbackOverlapAdapter(CompoundPrunerOverlapCallback& pcb, const CompoundTree& tree) : mCallback(pcb), mTree(tree) {}
PX_FORCE_INLINE bool invoke(PxU32 primIndex)
{
return mCallback.invoke(primIndex, mTree.mPruningPool->getObjects(), mTree.mPruningPool->getTransforms(), &mTree.mGlobalPose);
}
CompoundPrunerOverlapCallback& mCallback;
const CompoundTree& mTree;
PX_NOCOPY(CompoundCallbackOverlapAdapter)
};
}
template<class PrunerCallback>
struct MainTreeCompoundPrunerCallback
{
MainTreeCompoundPrunerCallback(PrunerCallback& prunerCallback, PxCompoundPrunerQueryFlags flags, const CompoundTree* compoundTrees)
: mPrunerCallback(prunerCallback), mQueryFlags(flags), mCompoundTrees(compoundTrees)
{
}
virtual ~MainTreeCompoundPrunerCallback() {}
PX_FORCE_INLINE bool filtering(const CompoundTree& compoundTree) const
{
if(!(compoundTree.mFlags & mQueryFlags) || !compoundTree.mTree->getNodes())
return true;
return false;
}
protected:
PrunerCallback& mPrunerCallback;
const PxCompoundPrunerQueryFlags mQueryFlags;
const CompoundTree* mCompoundTrees;
PX_NOCOPY(MainTreeCompoundPrunerCallback)
};
// Raycast/sweeps callback for main AABB tree
template<bool tInflate>
struct MainTreeRaycastCompoundPrunerCallback : MainTreeCompoundPrunerCallback<CompoundPrunerRaycastCallback>
{
MainTreeRaycastCompoundPrunerCallback(const PxVec3& origin, const PxVec3& unitDir, const PxVec3& extent, CompoundPrunerRaycastCallback& prunerCallback, PxCompoundPrunerQueryFlags flags, const CompoundTree* compoundTrees)
: MainTreeCompoundPrunerCallback(prunerCallback, flags, compoundTrees), mOrigin(origin), mUnitDir(unitDir), mExtent(extent)
{
}
virtual ~MainTreeRaycastCompoundPrunerCallback() {}
bool invoke(PxReal& distance, PxU32 primIndex)
{
const CompoundTree& compoundTree = mCompoundTrees[primIndex];
if(filtering(compoundTree))
return true;
// transfer to actor local space
const PxVec3 localOrigin = compoundTree.mGlobalPose.transformInv(mOrigin);
const PxVec3 localDir = compoundTree.mGlobalPose.q.rotateInv(mUnitDir);
PxVec3 localExtent = mExtent;
if(tInflate)
{
const PxBounds3 wBounds = PxBounds3::centerExtents(mOrigin, mExtent);
const PxBounds3 localBounds = PxBounds3::transformSafe(compoundTree.mGlobalPose.getInverse(), wBounds);
localExtent = localBounds.getExtents();
}
// raycast the merged tree
CompoundCallbackRaycastAdapter pcb(mPrunerCallback, compoundTree);
return AABBTreeRaycast<tInflate, true, IncrementalAABBTree, IncrementalAABBTreeNode, CompoundCallbackRaycastAdapter>()
(compoundTree.mPruningPool->getCurrentAABBTreeBounds(), *compoundTree.mTree, localOrigin, localDir, distance, localExtent, pcb);
}
PX_NOCOPY(MainTreeRaycastCompoundPrunerCallback)
private:
const PxVec3& mOrigin;
const PxVec3& mUnitDir;
const PxVec3& mExtent;
};
//////////////////////////////////////////////////////////////////////////
// raycast against the compound pruner
bool BVHCompoundPruner::raycast(const PxVec3& origin, const PxVec3& unitDir, PxReal& inOutDistance, CompoundPrunerRaycastCallback& prunerCallback, PxCompoundPrunerQueryFlags flags) const
{
bool again = true;
// search the main tree if there are nodes
if(mMainTree.getNodes())
{
const PxVec3 extent(0.0f);
// main tree callback
MainTreeRaycastCompoundPrunerCallback<false> pcb(origin, unitDir, extent, prunerCallback, flags, mCompoundTreePool.getCompoundTrees());
// traverse the main tree
again = AABBTreeRaycast<false, true, IncrementalAABBTree, IncrementalAABBTreeNode, MainTreeRaycastCompoundPrunerCallback<false> >()
(mCompoundTreePool.getCurrentAABBTreeBounds(), mMainTree, origin, unitDir, inOutDistance, extent, pcb);
}
return again;
}
//////////////////////////////////////////////////////////////////////////
// overlap main tree callback
// A.B. templated version is complicated due to test transformations, will do a callback per primitive
struct MainTreeOverlapCompoundPrunerCallback : MainTreeCompoundPrunerCallback<CompoundPrunerOverlapCallback>
{
MainTreeOverlapCompoundPrunerCallback(const ShapeData& queryVolume, CompoundPrunerOverlapCallback& prunerCallback, PxCompoundPrunerQueryFlags flags, const CompoundTree* compoundTrees)
: MainTreeCompoundPrunerCallback(prunerCallback, flags, compoundTrees), mQueryVolume(queryVolume)
{
}
virtual ~MainTreeOverlapCompoundPrunerCallback() {}
PX_NOCOPY(MainTreeOverlapCompoundPrunerCallback)
protected:
const ShapeData& mQueryVolume;
};
// OBB
struct MainTreeOBBOverlapCompoundPrunerCallback : public MainTreeOverlapCompoundPrunerCallback
{
MainTreeOBBOverlapCompoundPrunerCallback(const ShapeData& queryVolume, CompoundPrunerOverlapCallback& prunerCallback, PxCompoundPrunerQueryFlags flags, const CompoundTree* compoundTrees)
: MainTreeOverlapCompoundPrunerCallback(queryVolume, prunerCallback, flags, compoundTrees) {}
bool invoke(PxU32 primIndex)
{
const CompoundTree& compoundTree = mCompoundTrees[primIndex];
if(filtering(compoundTree))
return true;
const PxVec3 localPos = compoundTree.mGlobalPose.transformInv(mQueryVolume.getPrunerWorldPos());
const PxMat33 transfMat(compoundTree.mGlobalPose.q);
const PxMat33 localRot = transfMat.getTranspose()*mQueryVolume.getPrunerWorldRot33();
const OBBAABBTest localTest(localPos, localRot, mQueryVolume.getPrunerBoxGeomExtentsInflated());
// overlap the compound local tree
CompoundCallbackOverlapAdapter pcb(mPrunerCallback, compoundTree);
return AABBTreeOverlap<true, OBBAABBTest, IncrementalAABBTree, IncrementalAABBTreeNode, CompoundCallbackOverlapAdapter>()
(compoundTree.mPruningPool->getCurrentAABBTreeBounds(), *compoundTree.mTree, localTest, pcb);
}
PX_NOCOPY(MainTreeOBBOverlapCompoundPrunerCallback)
};
// AABB
struct MainTreeAABBOverlapCompoundPrunerCallback : public MainTreeOverlapCompoundPrunerCallback
{
MainTreeAABBOverlapCompoundPrunerCallback(const ShapeData& queryVolume, CompoundPrunerOverlapCallback& prunerCallback, PxCompoundPrunerQueryFlags flags, const CompoundTree* compoundTrees)
: MainTreeOverlapCompoundPrunerCallback(queryVolume, prunerCallback, flags, compoundTrees) {}
bool invoke(PxU32 primIndex)
{
const CompoundTree& compoundTree = mCompoundTrees[primIndex];
if(filtering(compoundTree))
return true;
const PxVec3 localPos = compoundTree.mGlobalPose.transformInv(mQueryVolume.getPrunerWorldPos());
const PxMat33 transfMat(compoundTree.mGlobalPose.q);
const PxMat33 localRot = transfMat.getTranspose()*mQueryVolume.getPrunerWorldRot33();
// A.B. we dont have the AABB in local space, either we test OBB local space or
// we retest the AABB with the worldSpace AABB of the local tree???
const OBBAABBTest localTest(localPos, localRot, mQueryVolume.getPrunerBoxGeomExtentsInflated());
// overlap the compound local tree
CompoundCallbackOverlapAdapter pcb(mPrunerCallback, compoundTree);
return AABBTreeOverlap<true, OBBAABBTest, IncrementalAABBTree, IncrementalAABBTreeNode, CompoundCallbackOverlapAdapter>()
(compoundTree.mPruningPool->getCurrentAABBTreeBounds(), *compoundTree.mTree, localTest, pcb);
}
PX_NOCOPY(MainTreeAABBOverlapCompoundPrunerCallback)
};
// Capsule
struct MainTreeCapsuleOverlapCompoundPrunerCallback : public MainTreeOverlapCompoundPrunerCallback
{
MainTreeCapsuleOverlapCompoundPrunerCallback(const ShapeData& queryVolume, CompoundPrunerOverlapCallback& prunerCallback, PxCompoundPrunerQueryFlags flags, const CompoundTree* compoundTrees)
: MainTreeOverlapCompoundPrunerCallback(queryVolume, prunerCallback, flags, compoundTrees) {}
bool invoke(PxU32 primIndex)
{
const CompoundTree& compoundTree = mCompoundTrees[primIndex];
if(filtering(compoundTree))
return true;
const PxMat33 transfMat(compoundTree.mGlobalPose.q);
const Capsule& capsule = mQueryVolume.getGuCapsule();
const CapsuleAABBTest localTest(
compoundTree.mGlobalPose.transformInv(capsule.p1),
transfMat.getTranspose()*mQueryVolume.getPrunerWorldRot33().column0,
mQueryVolume.getCapsuleHalfHeight()*2.0f, PxVec3(capsule.radius*SQ_PRUNER_INFLATION));
// overlap the compound local tree
CompoundCallbackOverlapAdapter pcb(mPrunerCallback, compoundTree);
return AABBTreeOverlap<true, CapsuleAABBTest, IncrementalAABBTree, IncrementalAABBTreeNode, CompoundCallbackOverlapAdapter>()
(compoundTree.mPruningPool->getCurrentAABBTreeBounds(), *compoundTree.mTree, localTest, pcb);
}
PX_NOCOPY(MainTreeCapsuleOverlapCompoundPrunerCallback)
};
// Sphere
struct MainTreeSphereOverlapCompoundPrunerCallback : public MainTreeOverlapCompoundPrunerCallback
{
MainTreeSphereOverlapCompoundPrunerCallback(const ShapeData& queryVolume, CompoundPrunerOverlapCallback& prunerCallback, PxCompoundPrunerQueryFlags flags, const CompoundTree* compoundTrees)
: MainTreeOverlapCompoundPrunerCallback(queryVolume, prunerCallback, flags, compoundTrees) {}
bool invoke(PxU32 primIndex)
{
const CompoundTree& compoundTree = mCompoundTrees[primIndex];
if(filtering(compoundTree))
return true;
const Sphere& sphere = mQueryVolume.getGuSphere();
const SphereAABBTest localTest(compoundTree.mGlobalPose.transformInv(sphere.center), sphere.radius);
// overlap the compound local tree
CompoundCallbackOverlapAdapter pcb(mPrunerCallback, compoundTree);
return AABBTreeOverlap<true, SphereAABBTest, IncrementalAABBTree, IncrementalAABBTreeNode, CompoundCallbackOverlapAdapter>()
(compoundTree.mPruningPool->getCurrentAABBTreeBounds(), *compoundTree.mTree, localTest, pcb);
}
PX_NOCOPY(MainTreeSphereOverlapCompoundPrunerCallback)
};
//////////////////////////////////////////////////////////////////////////
// overlap implementation
bool BVHCompoundPruner::overlap(const ShapeData& queryVolume, CompoundPrunerOverlapCallback& prunerCallback, PxCompoundPrunerQueryFlags flags) const
{
if(!mMainTree.getNodes())
return true;
bool again = true;
const Gu::AABBTreeBounds& bounds = mCompoundTreePool.getCurrentAABBTreeBounds();
switch (queryVolume.getType())
{
case PxGeometryType::eBOX:
{
if(queryVolume.isOBB())
{
const DefaultOBBAABBTest test(queryVolume);
MainTreeOBBOverlapCompoundPrunerCallback pcb(queryVolume, prunerCallback, flags, mCompoundTreePool.getCompoundTrees());
again = AABBTreeOverlap<true, OBBAABBTest, IncrementalAABBTree, IncrementalAABBTreeNode, MainTreeOBBOverlapCompoundPrunerCallback>()(bounds, mMainTree, test, pcb);
}
else
{
const DefaultAABBAABBTest test(queryVolume);
MainTreeAABBOverlapCompoundPrunerCallback pcb(queryVolume, prunerCallback, flags, mCompoundTreePool.getCompoundTrees());
again = AABBTreeOverlap<true, AABBAABBTest, IncrementalAABBTree, IncrementalAABBTreeNode, MainTreeAABBOverlapCompoundPrunerCallback>()(bounds, mMainTree, test, pcb);
}
}
break;
case PxGeometryType::eCAPSULE:
{
const DefaultCapsuleAABBTest test(queryVolume, SQ_PRUNER_INFLATION);
MainTreeCapsuleOverlapCompoundPrunerCallback pcb(queryVolume, prunerCallback, flags, mCompoundTreePool.getCompoundTrees());
again = AABBTreeOverlap<true, CapsuleAABBTest, IncrementalAABBTree, IncrementalAABBTreeNode, MainTreeCapsuleOverlapCompoundPrunerCallback >()(bounds, mMainTree, test, pcb);
}
break;
case PxGeometryType::eSPHERE:
{
const DefaultSphereAABBTest test(queryVolume);
MainTreeSphereOverlapCompoundPrunerCallback pcb(queryVolume, prunerCallback, flags, mCompoundTreePool.getCompoundTrees());
again = AABBTreeOverlap<true, SphereAABBTest, IncrementalAABBTree, IncrementalAABBTreeNode, MainTreeSphereOverlapCompoundPrunerCallback>()(bounds, mMainTree, test, pcb);
}
break;
case PxGeometryType::eCONVEXMESH:
{
const DefaultOBBAABBTest test(queryVolume);
MainTreeOBBOverlapCompoundPrunerCallback pcb(queryVolume, prunerCallback, flags, mCompoundTreePool.getCompoundTrees());
again = AABBTreeOverlap<true, OBBAABBTest, IncrementalAABBTree, IncrementalAABBTreeNode, MainTreeOBBOverlapCompoundPrunerCallback>()(bounds, mMainTree, test, pcb);
}
break;
default:
PX_ALWAYS_ASSERT_MESSAGE("unsupported overlap query volume geometry type");
}
return again;
}
///////////////////////////////////////////////////////////////////////////////////////////////
bool BVHCompoundPruner::sweep(const ShapeData& queryVolume, const PxVec3& unitDir, PxReal& inOutDistance, CompoundPrunerRaycastCallback& prunerCallback, PxCompoundPrunerQueryFlags flags) const
{
bool again = true;
if(mMainTree.getNodes())
{
const PxBounds3& aabb = queryVolume.getPrunerInflatedWorldAABB();
const PxVec3 extents = aabb.getExtents();
const PxVec3 center = aabb.getCenter();
MainTreeRaycastCompoundPrunerCallback<true> pcb(center, unitDir, extents, prunerCallback, flags, mCompoundTreePool.getCompoundTrees());
again = AABBTreeRaycast<true, true, IncrementalAABBTree, IncrementalAABBTreeNode, MainTreeRaycastCompoundPrunerCallback<true> >()
(mCompoundTreePool.getCurrentAABBTreeBounds(), mMainTree, center, unitDir, inOutDistance, extents, pcb);
}
return again;
}
///////////////////////////////////////////////////////////////////////////////////////////////
const PrunerPayload& BVHCompoundPruner::getPayloadData(PrunerHandle handle, PrunerCompoundId compoundId, PrunerPayloadData* data) const
{
const ActorIdPoolIndexMap::Entry* poolIndexEntry = mActorPoolMap.find(compoundId);
PX_ASSERT(poolIndexEntry);
return mCompoundTreePool.getCompoundTrees()[poolIndexEntry->second].mPruningPool->getPayloadData(handle, data);
}
///////////////////////////////////////////////////////////////////////////////////////////////
void BVHCompoundPruner::preallocate(PxU32 nbEntries)
{
mCompoundTreePool.preallocate(nbEntries);
mMainTreeUpdateMap.resizeUninitialized(nbEntries);
mPoolActorMap.resizeUninitialized(nbEntries);
mChangedLeaves.reserve(nbEntries);
}
///////////////////////////////////////////////////////////////////////////////////////////////
bool BVHCompoundPruner::setTransform(PrunerHandle handle, PrunerCompoundId compoundId, const PxTransform& transform)
{
const ActorIdPoolIndexMap::Entry* poolIndexEntry = mActorPoolMap.find(compoundId);
PX_ASSERT(poolIndexEntry);
return mCompoundTreePool.getCompoundTrees()[poolIndexEntry->second].mPruningPool->setTransform(handle, transform);
}
const PxTransform& BVHCompoundPruner::getTransform(PrunerCompoundId compoundId) const
{
const ActorIdPoolIndexMap::Entry* poolIndexEntry = mActorPoolMap.find(compoundId);
PX_ASSERT(poolIndexEntry);
return mCompoundTreePool.getCompoundTrees()[poolIndexEntry->second].mGlobalPose;
}
///////////////////////////////////////////////////////////////////////////////////////////////
void BVHCompoundPruner::updateObjectAfterManualBoundsUpdates(PrunerCompoundId compoundId, const PrunerHandle handle)
{
const ActorIdPoolIndexMap::Entry* poolIndexEntry = mActorPoolMap.find(compoundId);
PX_ASSERT(poolIndexEntry);
if(!poolIndexEntry)
return;
mCompoundTreePool.getCompoundTrees()[poolIndexEntry->second].updateObjectAfterManualBoundsUpdates(handle);
const PxU32 poolIndex = poolIndexEntry->second;
updateMainTreeNode(poolIndex);
}
///////////////////////////////////////////////////////////////////////////////////////////////
void BVHCompoundPruner::removeObject(PrunerCompoundId compoundId, const PrunerHandle handle, PrunerPayloadRemovalCallback* removalCallback)
{
const ActorIdPoolIndexMap::Entry* poolIndexEntry = mActorPoolMap.find(compoundId);
PX_ASSERT(poolIndexEntry);
if(!poolIndexEntry)
return;
const PxU32 poolIndex = poolIndexEntry->second;
mCompoundTreePool.getCompoundTrees()[poolIndex].removeObject(handle, removalCallback);
// edge case, we removed all objects for the compound tree, we need to remove it now completely
if(!mCompoundTreePool.getCompoundTrees()[poolIndex].mTree->getNodes())
removeCompound(compoundId, removalCallback);
else
updateMainTreeNode(poolIndex);
}
///////////////////////////////////////////////////////////////////////////////////////////////
bool BVHCompoundPruner::addObject(PrunerCompoundId compoundId, PrunerHandle& result, const PxBounds3& bounds, const PrunerPayload userData, const PxTransform& transform)
{
const ActorIdPoolIndexMap::Entry* poolIndexEntry = mActorPoolMap.find(compoundId);
PX_ASSERT(poolIndexEntry);
if(!poolIndexEntry)
return false;
mCompoundTreePool.getCompoundTrees()[poolIndexEntry->second].addObject(result, bounds, userData, transform);
const PxU32 poolIndex = poolIndexEntry->second;
updateMainTreeNode(poolIndex);
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
void BVHCompoundPruner::updateMainTreeNode(PoolIndex poolIndex)
{
PxBounds3 localBounds;
const IncrementalAABBTreeNode* node = mCompoundTreePool.getCompoundTrees()[poolIndex].mTree->getNodes();
V4StoreU(node->mBVMin, &localBounds.minimum.x);
PX_ALIGN(16, PxVec4) max4;
V4StoreA(node->mBVMax, &max4.x);
localBounds.maximum = PxVec3(max4.x, max4.y, max4.z);
const PxBounds3 compoundBounds = PxBounds3::transformFast(mCompoundTreePool.getCompoundTrees()[poolIndex].mGlobalPose, localBounds);
mCompoundTreePool.getCurrentCompoundBounds()[poolIndex] = compoundBounds;
mChangedLeaves.clear();
IncrementalAABBTreeNode* mainTreeNode = mMainTree.update(mMainTreeUpdateMap[poolIndex], poolIndex, mCompoundTreePool.getCurrentCompoundBounds(), mChangedLeaves);
// we removed node during update, need to update the mapping
updateMapping(poolIndex, mainTreeNode);
}
///////////////////////////////////////////////////////////////////////////////////////////////
void BVHCompoundPruner::shiftOrigin(const PxVec3& shift)
{
mCompoundTreePool.shiftOrigin(shift);
mMainTree.shiftOrigin(shift);
}
///////////////////////////////////////////////////////////////////////////////////////////////
namespace
{
class CompoundTreeVizCb : public DebugVizCallback
{
PX_NOCOPY(CompoundTreeVizCb)
public:
CompoundTreeVizCb(PxRenderOutput& out, const CompoundTree& tree) :
mOut (out),
mPose (tree.mGlobalPose)
{
}
virtual bool visualizeNode(const IncrementalAABBTreeNode& /*node*/, const PxBounds3& bounds)
{
if(0)
{
Cm::renderOutputDebugBox(mOut, PxBounds3::transformSafe(mPose, bounds));
}
else
{
PxVec3 pts[8];
computeBoxPoints(bounds, pts);
for(PxU32 i=0;i<8;i++)
pts[i] = mPose.transform(pts[i]);
const PxU8* edges = getBoxEdges();
for(PxU32 i=0;i<12;i++)
{
const PxVec3& p0 = pts[*edges++];
const PxVec3& p1 = pts[*edges++];
mOut.outputSegment(p0, p1);
}
}
return true;
}
PxRenderOutput& mOut;
const PxTransform& mPose;
};
class CompoundPrunerDebugVizCb : public DebugVizCallback
{
PX_NOCOPY(CompoundPrunerDebugVizCb)
public:
CompoundPrunerDebugVizCb(PxRenderOutput& out, const CompoundTree* trees, bool debugStatic, bool debugDynamic) :
mOut (out),
mTrees (trees),
mDebugVizStatic (debugStatic),
mDebugVizDynamic(debugDynamic)
{}
virtual bool visualizeNode(const IncrementalAABBTreeNode& node, const PxBounds3& /*bounds*/)
{
if(node.isLeaf())
{
PxU32 nbPrims = node.getNbPrimitives();
const PxU32* prims = node.getPrimitives(NULL);
while(nbPrims--)
{
const CompoundTree& compoundTree = mTrees[*prims++];
const bool isDynamic = compoundTree.mFlags & PxCompoundPrunerQueryFlag::eDYNAMIC;
if((mDebugVizDynamic && isDynamic) || (mDebugVizStatic && !isDynamic))
{
const PxU32 color = isDynamic ? SQ_DEBUG_VIZ_DYNAMIC_COLOR : SQ_DEBUG_VIZ_STATIC_COLOR;
CompoundTreeVizCb leafCB(mOut, compoundTree);
visualizeTree(mOut, color, compoundTree.mTree, &leafCB);
mOut << SQ_DEBUG_VIZ_COMPOUND_COLOR;
}
}
}
return false;
}
PxRenderOutput& mOut;
const CompoundTree* mTrees;
const bool mDebugVizStatic;
const bool mDebugVizDynamic;
};
}
void BVHCompoundPruner::visualize(PxRenderOutput& out, PxU32 primaryColor, PxU32 /*secondaryColor*/) const
{
if(mDrawStatic || mDrawDynamic)
{
CompoundPrunerDebugVizCb cb(out, mCompoundTreePool.getCompoundTrees(), mDrawStatic, mDrawDynamic);
visualizeTree(out, primaryColor, &mMainTree, &cb);
}
}
void BVHCompoundPruner::visualizeEx(PxRenderOutput& out, PxU32 color, bool drawStatic, bool drawDynamic) const
{
mDrawStatic = drawStatic;
mDrawDynamic = drawDynamic;
visualize(out, color, color);
}
///////////////////////////////////////////////////////////////////////////////////////////////
| 29,393 | C++ | 36.349428 | 221 | 0.72997 |
NVIDIA-Omniverse/PhysX/physx/source/scenequery/src/SqCompoundPruner.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-2023 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 SQ_COMPOUND_PRUNER_H
#define SQ_COMPOUND_PRUNER_H
#include "SqCompoundPruningPool.h"
#include "GuSqInternal.h"
#include "GuPrunerMergeData.h"
#include "GuIncrementalAABBTree.h"
#include "GuPruningPool.h"
#include "foundation/PxHashMap.h"
#include "foundation/PxArray.h"
namespace physx
{
namespace Sq
{
///////////////////////////////////////////////////////////////////////////////////////////////
typedef PxHashMap<PrunerCompoundId, Gu::PoolIndex> ActorIdPoolIndexMap;
typedef PxArray<PrunerCompoundId> PoolIndexActorIdMap;
///////////////////////////////////////////////////////////////////////////////////////////////
class BVHCompoundPruner : public CompoundPruner
{
public:
BVHCompoundPruner(PxU64 contextID);
virtual ~BVHCompoundPruner();
void release();
// BasePruner
DECLARE_BASE_PRUNER_API
//~BasePruner
// CompoundPruner
// compound level
virtual bool addCompound(Gu::PrunerHandle* results, const Gu::BVH& bvh, PrunerCompoundId compoundId, const PxTransform& transform, bool isDynamic, const Gu::PrunerPayload* data, const PxTransform* transforms);
virtual bool removeCompound(PrunerCompoundId compoundId, Gu::PrunerPayloadRemovalCallback* removalCallback);
virtual bool updateCompound(PrunerCompoundId compoundId, const PxTransform& transform);
// object level
virtual void updateObjectAfterManualBoundsUpdates(PrunerCompoundId compoundId, const Gu::PrunerHandle handle);
virtual void removeObject(PrunerCompoundId compoundId, const Gu::PrunerHandle handle, Gu::PrunerPayloadRemovalCallback* removalCallback);
virtual bool addObject(PrunerCompoundId compoundId, Gu::PrunerHandle& result, const PxBounds3& bounds, const Gu::PrunerPayload userData, const PxTransform& transform);
//queries
virtual bool raycast(const PxVec3& origin, const PxVec3& unitDir, PxReal& inOutDistance, CompoundPrunerRaycastCallback&, PxCompoundPrunerQueryFlags flags) const;
virtual bool overlap(const Gu::ShapeData& queryVolume, CompoundPrunerOverlapCallback&, PxCompoundPrunerQueryFlags flags) const;
virtual bool sweep(const Gu::ShapeData& queryVolume, const PxVec3& unitDir, PxReal& inOutDistance, CompoundPrunerRaycastCallback&, PxCompoundPrunerQueryFlags flags) const;
virtual const Gu::PrunerPayload& getPayloadData(Gu::PrunerHandle handle, PrunerCompoundId compoundId, Gu::PrunerPayloadData* data) const;
virtual void preallocate(PxU32 nbEntries);
virtual bool setTransform(Gu::PrunerHandle handle, PrunerCompoundId compoundId, const PxTransform& transform);
virtual const PxTransform& getTransform(PrunerCompoundId compoundId) const;
virtual void visualizeEx(PxRenderOutput& out, PxU32 color, bool drawStatic, bool drawDynamic) const;
// ~CompoundPruner
private:
void updateMapping(const Gu::PoolIndex poolIndex, Gu::IncrementalAABBTreeNode* node);
void updateMainTreeNode(Gu::PoolIndex index);
void test();
Gu::IncrementalAABBTree mMainTree;
UpdateMap mMainTreeUpdateMap;
CompoundTreePool mCompoundTreePool;
ActorIdPoolIndexMap mActorPoolMap;
PoolIndexActorIdMap mPoolActorMap;
Gu::NodeList mChangedLeaves;
mutable bool mDrawStatic;
mutable bool mDrawDynamic;
};
}
}
#endif
| 5,057 | C | 48.106796 | 217 | 0.733241 |
NVIDIA-Omniverse/PhysX/physx/source/scenequery/include/SqQuery.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-2023 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 SQ_QUERY_H
#define SQ_QUERY_H
// PT: SQ-API LEVEL 3 (Level 1 = SqPruner.h, Level 2 = SqManager/SqPrunerData)
// PT: this file is part of a "high-level" set of files within Sq. The SqPruner API doesn't rely on them.
// PT: this should really be at Np level but moving it to Sq allows us to share it.
#include "foundation/PxSimpleTypes.h"
#include "geometry/PxGeometryQueryFlags.h"
#include "SqManager.h"
#include "PxQueryReport.h"
#include "GuCachedFuncs.h"
namespace physx
{
class PxGeometry;
struct PxQueryFilterData;
struct PxFilterData;
class PxQueryFilterCallback;
namespace Sq
{
struct MultiQueryInput;
class PVDCapture
{
public:
PVDCapture() {}
virtual ~PVDCapture() {}
virtual bool transmitSceneQueries() = 0;
virtual void raycast(const PxVec3& origin, const PxVec3& unitDir, PxReal distance, const PxRaycastHit* hit, PxU32 hitsNum, const PxQueryFilterData& filterData, bool multipleHits) = 0;
virtual void sweep(const PxGeometry& geometry, const PxTransform& pose, const PxVec3& unitDir, PxReal distance, const PxSweepHit* hit, PxU32 hitsNum, const PxQueryFilterData& filterData, bool multipleHits) = 0;
virtual void overlap(const PxGeometry& geometry, const PxTransform& pose, const PxOverlapHit* hit, PxU32 hitsNum, const PxQueryFilterData& filterData) = 0;
};
// SceneQueries-level adapter. Augments the PrunerManager-level adapter with functions needed to perform queries.
class QueryAdapter : public Adapter
{
public:
QueryAdapter() {}
virtual ~QueryAdapter() {}
// PT: TODO: decouple from PxQueryCache?
virtual Gu::PrunerHandle findPrunerHandle(const PxQueryCache& cache, PrunerCompoundId& compoundId, PxU32& prunerIndex) const = 0;
// PT: TODO: return reference? but this version is at least consistent with getActorShape
virtual void getFilterData(const Gu::PrunerPayload& payload, PxFilterData& filterData) const = 0;
virtual void getActorShape(const Gu::PrunerPayload& payload, PxActorShape& actorShape) const = 0;
};
}
class SceneQueries
{
PX_NOCOPY(SceneQueries)
public:
SceneQueries(Sq::PVDCapture* pvd, PxU64 contextID, Gu::Pruner* staticPruner, Gu::Pruner* dynamicPruner,
PxU32 dynamicTreeRebuildRateHint, float inflation,
const PxSceneLimits& limits, const Sq::QueryAdapter& adapter);
~SceneQueries();
PX_FORCE_INLINE Sq::PrunerManager& getPrunerManagerFast() { return mSQManager; }
PX_FORCE_INLINE const Sq::PrunerManager& getPrunerManagerFast() const { return mSQManager; }
template<typename QueryHit>
bool multiQuery(
const Sq::MultiQueryInput& in,
PxHitCallback<QueryHit>& hits, PxHitFlags hitFlags, const PxQueryCache* cache,
const PxQueryFilterData& filterData, PxQueryFilterCallback* filterCall) const;
bool _raycast(
const PxVec3& origin, const PxVec3& unitDir, const PxReal distance, // Ray data
PxRaycastCallback& hitCall, PxHitFlags hitFlags,
const PxQueryFilterData& filterData, PxQueryFilterCallback* filterCall,
const PxQueryCache* cache, PxGeometryQueryFlags flags) const;
bool _sweep(
const PxGeometry& geometry, const PxTransform& pose, // GeomObject data
const PxVec3& unitDir, const PxReal distance, // Ray data
PxSweepCallback& hitCall, PxHitFlags hitFlags,
const PxQueryFilterData& filterData, PxQueryFilterCallback* filterCall,
const PxQueryCache* cache, const PxReal inflation, PxGeometryQueryFlags flags) const;
bool _overlap(
const PxGeometry& geometry, const PxTransform& transform, // GeomObject data
PxOverlapCallback& hitCall,
const PxQueryFilterData& filterData, PxQueryFilterCallback* filterCall,
const PxQueryCache* cache, PxGeometryQueryFlags flags) const;
PX_FORCE_INLINE PxU64 getContextId() const { return mSQManager.getContextId(); }
Sq::PrunerManager mSQManager;
public:
Gu::CachedFuncs mCachedFuncs;
Sq::PVDCapture* mPVD;
};
#if PX_SUPPORT_EXTERN_TEMPLATE
//explicit template instantiation declaration
extern template
bool SceneQueries::multiQuery<PxRaycastHit>(const Sq::MultiQueryInput&, PxHitCallback<PxRaycastHit>&, PxHitFlags, const PxQueryCache*, const PxQueryFilterData&, PxQueryFilterCallback*) const;
extern template
bool SceneQueries::multiQuery<PxOverlapHit>(const Sq::MultiQueryInput&, PxHitCallback<PxOverlapHit>&, PxHitFlags, const PxQueryCache*, const PxQueryFilterData&, PxQueryFilterCallback*) const;
extern template
bool SceneQueries::multiQuery<PxSweepHit>(const Sq::MultiQueryInput&, PxHitCallback<PxSweepHit>&, PxHitFlags, const PxQueryCache*, const PxQueryFilterData&, PxQueryFilterCallback*) const;
#endif
}
#endif
| 6,613 | C | 44.930555 | 212 | 0.732799 |
NVIDIA-Omniverse/PhysX/physx/source/scenequery/include/SqPrunerData.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-2023 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 SQ_PRUNER_DATA_H
#define SQ_PRUNER_DATA_H
/** \addtogroup physics
@{ */
#include "SqTypedef.h"
// PT: SQ-API LEVEL 2 (Level 1 = SqPruner.h)
// PT: this file is part of a "high-level" set of files within Sq. The SqPruner API doesn't rely on them.
// PT: this should really be at Np level but moving it to Sq allows us to share it.
namespace physx
{
namespace Sq
{
struct PruningIndex
{
enum Enum
{
eSTATIC = 0, // PT: must match PX_SCENE_PRUNER_STATIC
eDYNAMIC = 1, // PT: must match PX_SCENE_PRUNER_DYNAMIC
eCOUNT = 2
};
};
PX_FORCE_INLINE PrunerData createPrunerData(PxU32 index, Gu::PrunerHandle h) { return PrunerData((h << 1) | index); }
PX_FORCE_INLINE PxU32 getPrunerIndex(PrunerData data) { return PxU32(data & 1); }
PX_FORCE_INLINE Gu::PrunerHandle getPrunerHandle(PrunerData data) { return Gu::PrunerHandle(data >> 1); }
}
}
/** @} */
#endif
| 2,600 | C | 39.640624 | 118 | 0.734231 |
NVIDIA-Omniverse/PhysX/physx/source/scenequery/include/SqPruner.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-2023 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 SQ_PRUNER_H
#define SQ_PRUNER_H
#include "foundation/PxBounds3.h"
#include "foundation/PxUserAllocated.h"
#include "foundation/PxFlags.h"
#include "GuPruner.h"
#include "SqTypedef.h"
namespace physx
{
namespace Gu
{
class BVH;
}
namespace Sq
{
/**
\brief Compound-pruner-specific flags for scene queries.
*/
struct PxCompoundPrunerQueryFlag
{
enum Enum
{
eSTATIC = (1<<0), //!< Traverse static compounds
eDYNAMIC = (1<<1), //!< Traverse dynamic compounds
};
};
/**
\brief Flags typedef for the set of bits defined in PxCompoundPrunerQueryFlag.
*/
typedef PxFlags<PxCompoundPrunerQueryFlag::Enum,PxU32> PxCompoundPrunerQueryFlags;
PX_FLAGS_OPERATORS(PxCompoundPrunerQueryFlag::Enum,PxU32)
struct CompoundPrunerRaycastCallback
{
CompoundPrunerRaycastCallback() {}
virtual ~CompoundPrunerRaycastCallback() {}
virtual bool invoke(PxReal& distance, PxU32 primIndex, const Gu::PrunerPayload* payloads, const PxTransform* transforms, const PxTransform* compoundPose) = 0;
};
struct CompoundPrunerOverlapCallback
{
CompoundPrunerOverlapCallback() {}
virtual ~CompoundPrunerOverlapCallback() {}
virtual bool invoke(PxU32 primIndex, const Gu::PrunerPayload* payloads, const PxTransform* transforms, const PxTransform* compoundPose) = 0;
};
//////////////////////////////////////////////////////////////////////////
/**
* Pruner holding compound objects
*/
//////////////////////////////////////////////////////////////////////////
class CompoundPruner : public Gu::BasePruner
{
public:
virtual ~CompoundPruner() {}
/**
\brief Adds compound to the pruner.
\param results [out] an array for resulting handles
\param bvh [in] BVH
\param compoundId [in] compound id
\param transform [in] compound transform
\param data [in] an array of object data
\return true if success, false if internal allocation failed. The first failing add results in a INVALID_PRUNERHANDLE.
Handles are usable as indices. Each handle is either be a recycled handle returned by the client via removeObjects(),
or a fresh handle that is either zero, or one greater than the last fresh handle returned.
*/
virtual bool addCompound(Gu::PrunerHandle* results, const Gu::BVH& bvh, PrunerCompoundId compoundId, const PxTransform& transform, bool isDynamic, const Gu::PrunerPayload* data, const PxTransform* transforms) = 0;
/**
Removes compound from the pruner.
\param compoundId [in] compound to remove
*/
virtual bool removeCompound(PrunerCompoundId compoundId, Gu::PrunerPayloadRemovalCallback* removalCallback) = 0;
/**
Updates compound object
\param compoundId [in] compound to update
\param transform [in] compound transformation
*/
virtual bool updateCompound(PrunerCompoundId compoundId, const PxTransform& transform) = 0;
/**
Updates object after manually updating their bounds via "getPayload" calls.
\param compoundId [in] compound that the object belongs to
\param handle [in] the object to update
*/
virtual void updateObjectAfterManualBoundsUpdates(PrunerCompoundId compoundId, const Gu::PrunerHandle handle) = 0;
/**
Removes object from compound pruner.
\param compoundId [in] compound that the object belongs to
\param handle [in] the object to remove
*/
virtual void removeObject(PrunerCompoundId compoundId, const Gu::PrunerHandle handle, Gu::PrunerPayloadRemovalCallback* removalCallback) = 0;
/**
\brief Adds object to the pruner.
\param compoundId [in] compound that the object belongs to
\param result [out] an array for resulting handles
\param bounds [in] an array of bounds. These bounds are used as-is so they should be pre-inflated if inflation is needed.
\param userData [in] an array of object data
\return true if success, false if internal allocation failed. The first failing add results in a INVALID_PRUNERHANDLE.
*/
virtual bool addObject(PrunerCompoundId compoundId, Gu::PrunerHandle& result, const PxBounds3& bounds, const Gu::PrunerPayload userData, const PxTransform& transform) = 0;
/**
* Query functions
*
* Note: return value may disappear if PrunerCallback contains the necessary information
* currently it is still used for the dynamic pruner internally (to decide if added objects must be queried)
*/
virtual bool raycast(const PxVec3& origin, const PxVec3& unitDir, PxReal& inOutDistance, CompoundPrunerRaycastCallback&, PxCompoundPrunerQueryFlags flags) const = 0;
virtual bool overlap(const Gu::ShapeData& queryVolume, CompoundPrunerOverlapCallback&, PxCompoundPrunerQueryFlags flags) const = 0;
virtual bool sweep(const Gu::ShapeData& queryVolume, const PxVec3& unitDir, PxReal& inOutDistance, CompoundPrunerRaycastCallback&, PxCompoundPrunerQueryFlags flags) const = 0;
/**
\brief Retrieves the object's payload and data associated with the handle.
This function returns the payload associated with a given handle. Additionally it can return the
destination addresses for the object's bounds & transform. The user can then write the new bounds
and transform there, before eventually calling updateObjects().
\param[in] handle Object handle (initially returned by addObjects())
\param[in] compoundId The compound id
\param[out] data Optional location where to store the internal data associated with the payload.
\return The payload associated with the given handle.
*/
virtual const Gu::PrunerPayload& getPayloadData(Gu::PrunerHandle handle, PrunerCompoundId compoundId, Gu::PrunerPayloadData* data) const = 0;
/**
\brief Preallocate space
\param[in] nbEntries The number of entries to preallocate space for
*/
virtual void preallocate(PxU32 nbEntries) = 0;
// PT: beware, shape transform
virtual bool setTransform(Gu::PrunerHandle handle, PrunerCompoundId compoundId, const PxTransform& transform) = 0;
// PT: beware, actor transform
virtual const PxTransform& getTransform(PrunerCompoundId compoundId) const = 0;
virtual void visualizeEx(PxRenderOutput& out, PxU32 color, bool drawStatic, bool drawDynamic) const = 0;
};
}
}
#endif
| 7,785 | C | 40.195767 | 218 | 0.747848 |
NVIDIA-Omniverse/PhysX/physx/source/scenequery/include/SqManager.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-2023 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 SQ_MANAGER_H
#define SQ_MANAGER_H
// PT: SQ-API LEVEL 2 (Level 1 = SqPruner.h)
// PT: this file is part of a "high-level" set of files within Sq. The SqPruner API doesn't rely on them.
// PT: this should really be at Np level but moving it to Sq allows us to share it.
#include "common/PxPhysXCommonConfig.h"
#include "foundation/PxBitMap.h"
#include "foundation/PxArray.h"
#include "SqPruner.h"
#include "geometry/PxGeometryHelpers.h"
namespace physx
{
namespace Sq
{
// PrunerManager-level adapter
class Adapter
{
public:
Adapter() {}
virtual ~Adapter() {}
// Retrieves the PxGeometry associated with a given PrunerPayload. This will be called by
// the PrunerManager class when computing bounds.
virtual const PxGeometry& getGeometry(const Gu::PrunerPayload& payload) const = 0;
};
// PT: extended pruner structure. We might want to move the additional data to the pruner itself later.
struct PrunerExt : public PxUserAllocated
{
// private:
PrunerExt();
~PrunerExt();
void init(Gu::Pruner* pruner);
void flushMemory();
void preallocate(PxU32 nbShapes);
void addToDirtyList(Gu::PrunerHandle handle, bool dynamic, const PxTransform& transform);
void removeFromDirtyList(Gu::PrunerHandle handle);
bool processDirtyList(PxU32 index, const Adapter& adapter, float inflation);
// void growDirtyList(Gu::PrunerHandle handle);
PX_FORCE_INLINE Gu::Pruner* pruner() { return mPruner; }
PX_FORCE_INLINE const Gu::Pruner* pruner() const { return mPruner; }
Gu::Pruner* mPruner;
PxBitMap mDirtyMap;
PxArray<Gu::PrunerHandle> mDirtyList;
bool mDirtyStatic; // true if dirty list contains a static
PX_NOCOPY(PrunerExt)
friend class PrunerManager;
};
}
}
#include "foundation/PxHashSet.h"
namespace physx
{
namespace Sq
{
class CompoundPruner;
typedef PxPair<PrunerCompoundId, Gu::PrunerHandle> CompoundPair;
typedef PxCoalescedHashSet<CompoundPair > CompoundPrunerSet;
// AB: extended compound pruner structure, buffers compound shape changes and flushes them.
struct CompoundPrunerExt : public PxUserAllocated
{
// private:
CompoundPrunerExt();
~CompoundPrunerExt();
void flushMemory();
void preallocate(PxU32 nbShapes);
void flushShapes(const Adapter& adapter, float inflation);
void addToDirtyList(PrunerCompoundId compoundId, Gu::PrunerHandle handle, const PxTransform& transform);
void removeFromDirtyList(PrunerCompoundId compoundId, Gu::PrunerHandle handle);
PX_FORCE_INLINE const CompoundPruner* pruner() const { return mPruner; }
PX_FORCE_INLINE CompoundPruner* pruner() { return mPruner; }
CompoundPruner* mPruner;
CompoundPrunerSet mDirtyList;
PX_NOCOPY(CompoundPrunerExt)
friend class PrunerManager;
};
}
}
#include "foundation/PxMutex.h"
#include "SqPrunerData.h"
namespace physx
{
class PxRenderOutput;
class PxBVH;
class PxSceneLimits; // PT: TODO: decouple from PxSceneLimits
namespace Sq
{
class PrunerManager : public PxUserAllocated
{
public:
PrunerManager(PxU64 contextID, Gu::Pruner* staticPruner, Gu::Pruner* dynamicPruner,
PxU32 dynamicTreeRebuildRateHint, float inflation,
const PxSceneLimits& limits, const Adapter& adapter);
~PrunerManager();
PrunerData addPrunerShape(const Gu::PrunerPayload& payload, bool dynamic, PrunerCompoundId compoundId, const PxBounds3& bounds, const PxTransform& transform, bool hasPruningStructure=false);
void addCompoundShape(const PxBVH& bvh, PrunerCompoundId compoundId, const PxTransform& compoundTransform, PrunerData* prunerData, const Gu::PrunerPayload* payloads, const PxTransform* transforms, bool isDynamic);
void markForUpdate(PrunerCompoundId compoundId, PrunerData s, const PxTransform& transform);
void removePrunerShape(PrunerCompoundId compoundId, PrunerData shapeData, Gu::PrunerPayloadRemovalCallback* removalCallback);
PX_FORCE_INLINE const Gu::Pruner* getPruner(PruningIndex::Enum index) const { return mPrunerExt[index].mPruner; }
PX_FORCE_INLINE Gu::Pruner* getPruner(PruningIndex::Enum index) { return mPrunerExt[index].mPruner; }
PX_FORCE_INLINE const CompoundPruner* getCompoundPruner() const { return mCompoundPrunerExt.mPruner; }
PX_FORCE_INLINE PxU64 getContextId() const { return mContextID; }
void preallocate(PxU32 prunerIndex, PxU32 nbShapes);
void setDynamicTreeRebuildRateHint(PxU32 dynTreeRebuildRateHint);
PX_FORCE_INLINE PxU32 getDynamicTreeRebuildRateHint() const { return mRebuildRateHint; }
void flushUpdates();
void forceRebuildDynamicTree(PxU32 prunerIndex);
void updateCompoundActor(PrunerCompoundId compoundId, const PxTransform& compoundTransform);
void removeCompoundActor(PrunerCompoundId compoundId, Gu::PrunerPayloadRemovalCallback* removalCallback);
void* prepareSceneQueriesUpdate(PruningIndex::Enum index);
void sceneQueryBuildStep(void* handle);
void sync(const Gu::PrunerHandle* handles, const PxU32* boundsIndices, const PxBounds3* bounds, const PxTransform32* transforms, PxU32 count, const PxBitMap& ignoredIndices);
void afterSync(bool buildStep, bool commit);
void shiftOrigin(const PxVec3& shift);
void visualize(PxU32 prunerIndex, PxRenderOutput& out) const;
void flushMemory();
PX_FORCE_INLINE PxU32 getStaticTimestamp() const { return mStaticTimestamp; }
PX_FORCE_INLINE const Adapter& getAdapter() const { return mAdapter; }
private:
const Adapter& mAdapter;
PrunerExt mPrunerExt[PruningIndex::eCOUNT];
CompoundPrunerExt mCompoundPrunerExt;
const PxU64 mContextID;
PxU32 mStaticTimestamp;
PxU32 mRebuildRateHint;
const float mInflation; // SQ_PRUNER_EPSILON
PxMutex mSQLock; // to make sure only one query updates the dirty pruner structure if multiple queries run in parallel
volatile bool mPrunerNeedsUpdating;
void flushShapes();
PX_FORCE_INLINE void invalidateStaticTimestamp() { mStaticTimestamp++; }
PX_NOCOPY(PrunerManager)
};
}
}
#endif
| 8,173 | C | 40.282828 | 225 | 0.716628 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScParticleSystemSim.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
#include "foundation/PxPreprocessor.h"
#if PX_SUPPORT_GPU_PHYSX
#include "ScParticleSystemSim.h"
#include "ScParticleSystemCore.h"
#include "ScScene.h"
using namespace physx;
using namespace physx::Dy;
Sc::ParticleSystemSim::ParticleSystemSim(ParticleSystemCore& core, Scene& scene) :
ActorSim(scene, core),
mShapeSim(*this, &core.getShapeCore())
{
mLLParticleSystem = scene.createLLParticleSystem(this);
mNodeIndex = scene.getSimpleIslandManager()->addParticleSystem(mLLParticleSystem, false);
scene.getSimpleIslandManager()->activateNode(mNodeIndex);
//mCore.setSim(this);
mLLParticleSystem->setElementId(mShapeSim.getElementID());
PxParticleSystemGeometry geometry;
geometry.mSolverType = core.getSolverType();
core.getShapeCore().setGeometry(geometry);
PxsShapeCore* shapeCore = const_cast<PxsShapeCore*>(&core.getShapeCore().getCore());
mLLParticleSystem->setShapeCore(shapeCore);
}
Sc::ParticleSystemSim::~ParticleSystemSim()
{
if (!mLLParticleSystem)
return;
mScene.destroyLLParticleSystem(*mLLParticleSystem);
mScene.getSimpleIslandManager()->removeNode(mNodeIndex);
mCore.setSim(NULL);
}
void Sc::ParticleSystemSim::updateBounds()
{
mShapeSim.updateBounds();
}
void Sc::ParticleSystemSim::updateBoundsInAABBMgr()
{
mShapeSim.updateBoundsInAABBMgr();
}
PxBounds3 Sc::ParticleSystemSim::getBounds() const
{
return mShapeSim.getBounds();
}
bool Sc::ParticleSystemSim::isSleeping() const
{
return false;
}
void Sc::ParticleSystemSim::sleepCheck(PxReal dt)
{
PX_UNUSED(dt);
}
/*void Sc::ParticleSystemSim::activate()
{
activateInteractions(*this);
}
void Sc::ParticleSystemSim::deactivate()
{
deactivateInteractions(*this);
}*/
#endif //PX_SUPPORT_GPU_PHYSX
| 3,278 | C++ | 28.276785 | 90 | 0.769677 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScSimStats.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-2023 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 SC_SIM_STATS_H
#define SC_SIM_STATS_H
#include "geometry/PxGeometry.h"
#include "PxSimulationStatistics.h"
#include "foundation/PxAtomic.h"
#include "foundation/PxUserAllocated.h"
namespace physx
{
struct PxvSimStats;
namespace Sc
{
/*
Description: contains statistics for the scene.
*/
class SimStats : public PxUserAllocated
{
public:
SimStats();
void clear(); //set counters to zero
void simStart();
void readOut(PxSimulationStatistics& dest, const PxvSimStats& simStats) const;
PX_INLINE void incBroadphaseAdds()
{
numBroadPhaseAddsPending++;
}
PX_INLINE void incBroadphaseRemoves()
{
numBroadPhaseRemovesPending++;
}
private:
// Broadphase adds/removes for the current simulation step
PxU32 numBroadPhaseAdds;
PxU32 numBroadPhaseRemoves;
// Broadphase adds/removes for the next simulation step
PxU32 numBroadPhaseAddsPending;
PxU32 numBroadPhaseRemovesPending;
public:
typedef PxI32 TriggerPairCountsNonVolatile[PxGeometryType::eCONVEXMESH+1][PxGeometryType::eGEOMETRY_COUNT];
typedef volatile TriggerPairCountsNonVolatile TriggerPairCounts;
TriggerPairCounts numTriggerPairs;
PxU64 gpuMemSizeParticles;
PxU64 gpuMemSizeSoftBodies;
PxU64 gpuMemSizeFEMCloths;
PxU64 gpuMemSizeHairSystems;
};
} // namespace Sc
}
#endif
| 3,006 | C | 31.684782 | 109 | 0.768796 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScTriggerInteraction.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-2023 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 SC_TRIGGER_INTERACTION_H
#define SC_TRIGGER_INTERACTION_H
#include "ScElementSimInteraction.h"
#include "ScShapeSim.h"
#include "GuOverlapTests.h"
namespace physx
{
namespace Sc
{
class TriggerInteraction : public ElementSimInteraction
{
public:
enum TriggerFlag
{
PAIR_FLAGS_MASK = ((PxPairFlag::eNOTIFY_TOUCH_LOST << 1) - 1), // Bits where the PxPairFlags eNOTIFY_TOUCH_FOUND and eNOTIFY_TOUCH_LOST get stored
NEXT_FREE = ((PAIR_FLAGS_MASK << 1) & ~PAIR_FLAGS_MASK),
PROCESS_THIS_FRAME = (NEXT_FREE << 0), // the trigger pair is new or the pose of an actor was set -> initial processing required.
// This is important to cover cases where a static or kinematic
// (non-moving) trigger is created and overlaps with a sleeping
// object. Or for the case where a static/kinematic is teleported to a new
// location. TOUCH_FOUND should still get sent in that case.
LAST = (NEXT_FREE << 1)
};
TriggerInteraction(ShapeSimBase& triggerShape, ShapeSimBase& otherShape);
~TriggerInteraction();
PX_FORCE_INLINE Gu::TriggerCache& getTriggerCache() { return mTriggerCache; }
PX_FORCE_INLINE ShapeSimBase& getTriggerShape() const { return static_cast<ShapeSimBase&>(getElement0()); }
PX_FORCE_INLINE ShapeSimBase& getOtherShape() const { return static_cast<ShapeSimBase&>(getElement1()); }
PX_FORCE_INLINE bool lastFrameHadContacts() const { return mLastFrameHadContacts; }
PX_FORCE_INLINE void updateLastFrameHadContacts(bool hasContact) { mLastFrameHadContacts = hasContact; }
PX_FORCE_INLINE PxPairFlags getTriggerFlags() const { return PxPairFlags(mFlags & PAIR_FLAGS_MASK); }
PX_FORCE_INLINE void setTriggerFlags(PxPairFlags triggerFlags);
PX_FORCE_INLINE void raiseFlag(TriggerFlag flag) { mFlags |= flag; }
PX_FORCE_INLINE void clearFlag(TriggerFlag flag) { mFlags &= ~flag; }
PX_FORCE_INLINE PxIntBool readFlag(TriggerFlag flag) const { return PxIntBool(mFlags & flag); }
PX_FORCE_INLINE void forceProcessingThisFrame(Sc::Scene& scene);
bool onActivate(void*);
bool onDeactivate();
protected:
Gu::TriggerCache mTriggerCache;
bool mLastFrameHadContacts;
};
} // namespace Sc
PX_FORCE_INLINE void Sc::TriggerInteraction::setTriggerFlags(PxPairFlags triggerFlags)
{
PX_ASSERT(PxU32(triggerFlags) < (PxPairFlag::eDETECT_CCD_CONTACT << 1)); // to find out if a new PxPairFlag has been added in which case PAIR_FLAGS_MASK needs to get adjusted
#if PX_CHECKED
if (triggerFlags & PxPairFlag::eNOTIFY_TOUCH_PERSISTS)
{
PX_WARN_ONCE("Trigger pairs do not support PxPairFlag::eNOTIFY_TOUCH_PERSISTS events any longer.");
}
#endif
PxU32 newFlags = mFlags;
PxU32 fl = PxU32(triggerFlags) & PxU32(PxPairFlag::eNOTIFY_TOUCH_FOUND|PxPairFlag::eNOTIFY_TOUCH_LOST);
newFlags &= (~PAIR_FLAGS_MASK); // clear old flags
newFlags |= fl;
mFlags = newFlags;
}
PX_FORCE_INLINE void Sc::TriggerInteraction::forceProcessingThisFrame(Sc::Scene& scene)
{
raiseFlag(PROCESS_THIS_FRAME);
if (!readInteractionFlag(InteractionFlag::eIS_ACTIVE))
{
raiseInteractionFlag(InteractionFlag::eIS_ACTIVE);
scene.notifyInteractionActivated(this);
}
}
}
#endif
| 5,019 | C | 41.184874 | 176 | 0.725842 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScConstraintSim.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScBodySim.h"
#include "ScStaticSim.h"
#include "ScConstraintCore.h"
#include "ScConstraintSim.h"
#include "ScConstraintInteraction.h"
#include "ScElementSimInteraction.h"
using namespace physx;
using namespace Sc;
static ConstraintInteraction* createInteraction(ConstraintSim* sim, RigidCore* r0, RigidCore* r1, Scene& scene)
{
return scene.getConstraintInteractionPool()->construct( sim,
r0 ? *r0->getSim() : scene.getStaticAnchor(),
r1 ? *r1->getSim() : scene.getStaticAnchor());
}
static void releaseInteraction(ConstraintInteraction* interaction, const ConstraintSim* sim, Scene& scene)
{
if(!sim->isBroken())
interaction->destroy();
scene.getConstraintInteractionPool()->destroy(interaction);
}
Sc::ConstraintSim::ConstraintSim(ConstraintCore& core, RigidCore* r0, RigidCore* r1, Scene& scene) :
mScene (scene),
mCore (core),
mInteraction(NULL),
mFlags (0)
{
mBodies[0] = (r0 && (r0->getActorCoreType() != PxActorType::eRIGID_STATIC)) ? static_cast<BodySim*>(r0->getSim()) : 0;
mBodies[1] = (r1 && (r1->getActorCoreType() != PxActorType::eRIGID_STATIC)) ? static_cast<BodySim*>(r1->getSim()) : 0;
const PxU32 id = scene.getConstraintIDTracker().createID();
mLowLevelConstraint.index = id;
PxPinnedArray<Dy::ConstraintWriteback>& writeBackPool = scene.getDynamicsContext()->getConstraintWriteBackPool();
if(id >= writeBackPool.capacity())
writeBackPool.reserve(writeBackPool.capacity() * 2);
writeBackPool.resize(PxMax(writeBackPool.size(), id + 1));
writeBackPool[id].initialize();
if(!createLLConstraint())
return;
PxReal linBreakForce, angBreakForce;
core.getBreakForce(linBreakForce, angBreakForce);
if ((linBreakForce < PX_MAX_F32) || (angBreakForce < PX_MAX_F32))
setFlag(eBREAKABLE);
core.setSim(this);
mInteraction = createInteraction(this, r0, r1, scene);
PX_ASSERT(!mInteraction->isRegistered()); // constraint interactions must not register in the scene, there is a list of Sc::ConstraintSim instead
}
Sc::ConstraintSim::~ConstraintSim()
{
PX_ASSERT(mInteraction); // This is fine now, a body which gets removed from the scene removes all constraints automatically
PX_ASSERT(!mInteraction->isRegistered()); // constraint interactions must not register in the scene, there is a list of Sc::ConstraintSim instead
releaseInteraction(mInteraction, this, mScene);
mScene.getConstraintIDTracker().releaseID(mLowLevelConstraint.index);
destroyLLConstraint();
mCore.setSim(NULL);
}
static PX_FORCE_INLINE void setLLBodies(Dy::Constraint& c, BodySim* b0, BodySim* b1)
{
PxsRigidBody* body0 = b0 ? &b0->getLowLevelBody() : NULL;
PxsRigidBody* body1 = b1 ? &b1->getLowLevelBody() : NULL;
c.body0 = body0;
c.body1 = body1;
c.bodyCore0 = body0 ? &body0->getCore() : NULL;
c.bodyCore1 = body1 ? &body1->getCore() : NULL;
}
bool Sc::ConstraintSim::createLLConstraint()
{
ConstraintCore& core = getCore();
const PxU32 constantBlockSize = core.getConstantBlockSize();
void* constantBlock = mScene.allocateConstraintBlock(constantBlockSize);
if(!constantBlock)
return PxGetFoundation().error(PxErrorCode::eINTERNAL_ERROR, PX_FL, "Constraint: could not allocate low-level resources.");
//Ensure the constant block isn't just random data because some functions may attempt to use it before it is
//setup. Specifically pvd visualization of joints
//-CN
PxMemZero(constantBlock, constantBlockSize);
Dy::Constraint& llc = mLowLevelConstraint;
core.getBreakForce(llc.linBreakForce, llc.angBreakForce);
llc.flags = core.getFlags();
llc.constantBlockSize = PxU16(constantBlockSize);
llc.solverPrep = core.getSolverPrep();
llc.constantBlock = constantBlock;
llc.minResponseThreshold = core.getMinResponseThreshold();
//llc.index = mLowLevelConstraint.index;
setLLBodies(llc, mBodies[0], mBodies[1]);
return true;
}
void Sc::ConstraintSim::destroyLLConstraint()
{
if(mLowLevelConstraint.constantBlock)
mScene.deallocateConstraintBlock(mLowLevelConstraint.constantBlock, mLowLevelConstraint.constantBlockSize);
}
void Sc::ConstraintSim::setBodies(RigidCore* r0, RigidCore* r1)
{
PX_ASSERT(mInteraction);
releaseInteraction(mInteraction, this, mScene);
BodySim* b0 = (r0 && (r0->getActorCoreType() != PxActorType::eRIGID_STATIC)) ? static_cast<BodySim*>(r0->getSim()) : 0;
BodySim* b1 = (r1 && (r1->getActorCoreType() != PxActorType::eRIGID_STATIC)) ? static_cast<BodySim*>(r1->getSim()) : 0;
setLLBodies(mLowLevelConstraint, b0, b1);
mBodies[0] = b0;
mBodies[1] = b1;
mInteraction = createInteraction(this, r0, r1, mScene);
}
void Sc::ConstraintSim::getForce(PxVec3& lin, PxVec3& ang)
{
const PxReal recipDt = mScene.getOneOverDt();
Dy::ConstraintWriteback& solverOutput= mScene.getDynamicsContext()->getConstraintWriteBackPool()[mLowLevelConstraint.index];
lin = solverOutput.linearImpulse * recipDt;
ang = solverOutput.angularImpulse * recipDt;
}
void Sc::ConstraintSim::setBreakForceLL(PxReal linear, PxReal angular)
{
PxU8 wasBreakable = readFlag(eBREAKABLE);
PxU8 isBreakable;
if ((linear < PX_MAX_F32) || (angular < PX_MAX_F32))
isBreakable = eBREAKABLE;
else
isBreakable = 0;
if (isBreakable != wasBreakable)
{
if (isBreakable)
{
PX_ASSERT(!readFlag(eCHECK_MAX_FORCE_EXCEEDED));
setFlag(eBREAKABLE);
if (mInteraction->readInteractionFlag(InteractionFlag::eIS_ACTIVE))
mScene.addActiveBreakableConstraint(this, mInteraction);
}
else
{
if (readFlag(eCHECK_MAX_FORCE_EXCEEDED))
mScene.removeActiveBreakableConstraint(this);
clearFlag(eBREAKABLE);
}
}
mLowLevelConstraint.linBreakForce = linear;
mLowLevelConstraint.angBreakForce = angular;
}
void Sc::ConstraintSim::postFlagChange(PxConstraintFlags /*oldFlags*/, PxConstraintFlags newFlags)
{
mLowLevelConstraint.flags = newFlags;
}
| 7,497 | C++ | 35.048077 | 147 | 0.749366 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScFEMClothSim.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-2023 NVIDIA Corporation. All rights reserved.
#ifndef PX_PHYSICS_FEMCLOTH_SIM
#define PX_PHYSICS_FEMCLOTH_SIM
#include "foundation/PxPreprocessor.h"
#if PX_SUPPORT_GPU_PHYSX
#include "foundation/PxUserAllocated.h"
#include "DyFEMCloth.h"
#include "ScFEMClothCore.h"
#include "ScFEMClothShapeSim.h"
#include "ScActorSim.h" // to be deleted
namespace physx
{
namespace Sc
{
class Scene;
class FEMClothSim : public ActorSim
{
PX_NOCOPY(FEMClothSim)
public:
FEMClothSim(FEMClothCore& core, Scene& scene);
~FEMClothSim();
PX_INLINE Dy::FEMCloth* getLowLevelFEMCloth() const { return mLLFEMCloth; }
PX_INLINE FEMClothCore& getCore() const { return static_cast<FEMClothCore&>(mCore); }
virtual PxActor* getPxActor() const { return getCore().getPxActor(); }
void updateBounds();
void updateBoundsInAABBMgr();
PxBounds3 getBounds() const;
bool isSleeping() const;
PX_FORCE_INLINE bool isActive() const { return !isSleeping(); }
void setActive(bool active, bool asPartOfCreation=false);
void onSetWakeCounter();
void attachShapeCore(ShapeCore* core);
FEMClothShapeSim& getShapeSim() { return mShapeSim; }
private:
Dy::FEMCloth* mLLFEMCloth;
FEMClothShapeSim mShapeSim;
PxU32 mIslandNodeIndex;
void activate();
void deactivate();
};
} // namespace Sc
}
#endif
#endif
| 2,955 | C | 33.77647 | 89 | 0.723858 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScParticleSystemShapeSim.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
#include "foundation/PxPreprocessor.h"
#if PX_SUPPORT_GPU_PHYSX
#include "ScParticleSystemShapeSim.h"
#include "ScNPhaseCore.h"
#include "ScParticleSystemSim.h"
#include "PxsContext.h"
using namespace physx;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Sc::ParticleSystemShapeSim::ParticleSystemShapeSim(ParticleSystemSim& particleSim, const ParticleSystemShapeCore* core) :
ShapeSimBase(particleSim, core)
{
mLLShape.mBodySimIndex_GPU = PxNodeIndex(PX_INVALID_NODE);
mLLShape.mElementIndex_GPU = PX_INVALID_U32;
createLowLevelVolume();
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Sc::ParticleSystemShapeSim::~ParticleSystemShapeSim()
{
if (isInBroadPhase())
destroyLowLevelVolume();
PX_ASSERT(!isInBroadPhase());
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Sc::ParticleSystemShapeSim::getFilterInfo(PxFilterObjectAttributes& filterAttr, PxFilterData& filterData) const
{
filterAttr = 0;
setFilterObjectAttributeType(filterAttr, PxFilterObjectType::ePARTICLESYSTEM);
filterData = getBodySim().getCore().getShapeCore().getSimulationFilterData();
}
void Sc::ParticleSystemShapeSim::updateBounds()
{
Scene& scene = getScene();
PxBounds3 worldBounds = PxBounds3(PxVec3(0.f), PxVec3(0.f));
const PxReal contactOffset = getBodySim().getCore().getContactOffset();
worldBounds.fattenSafe(contactOffset); // fatten for fast moving colliders
scene.getBoundsArray().setBounds(worldBounds, getElementID());
scene.getAABBManager()->getChangedAABBMgActorHandleMap().growAndSet(getElementID());
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Sc::ParticleSystemShapeSim::updateBoundsInAABBMgr()
{
//we are updating the bound in GPU so we just need to set the actor handle in CPU to make sure
//the GPU BP will process the particles
if (!(static_cast<Sc::ParticleSystemSim&>(getActor()).getCore().getFlags() & PxParticleFlag::eDISABLE_RIGID_COLLISION))
{
Scene& scene = getScene();
scene.getAABBManager()->getChangedAABBMgActorHandleMap().growAndSet(getElementID());
scene.getAABBManager()->setGPUStateChanged();
}
}
PxBounds3 Sc::ParticleSystemShapeSim::getBounds() const
{
PxBounds3 bounds = getScene().getBoundsArray().getBounds(getElementID());
return bounds;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Sc::ParticleSystemShapeSim::createLowLevelVolume()
{
//PX_ASSERT(getWorldBounds().isFinite());
const PxU32 index = getElementID();
if (!(static_cast<Sc::ParticleSystemSim&>(getActor()).getCore().getFlags() & PxParticleFlag::eDISABLE_RIGID_COLLISION))
{
getScene().getBoundsArray().setBounds(PxBounds3(PxVec3(PX_MAX_BOUNDS_EXTENTS), PxVec3(-PX_MAX_BOUNDS_EXTENTS)), index);
mInBroadPhase = true;
}
else
getScene().getAABBManager()->reserveSpaceForBounds(index);
{
const PxU32 group = Bp::FilterGroup::eDYNAMICS_BASE + getActor().getActorID();
const PxU32 type = Bp::FilterType::PARTICLESYSTEM;
const PxReal contactOffset = getBodySim().getCore().getContactOffset();
addToAABBMgr(contactOffset, Bp::FilterGroup::Enum((group << BP_FILTERING_TYPE_SHIFT_BIT) | type), Bp::ElementType::eSHAPE);
}
// PT: TODO: what's the difference between "getContactOffset()" and "getBodySim().getCore().getContactOffset()" above?
getScene().updateContactDistance(index, getContactOffset());
PxsTransformCache& cache = getScene().getLowLevelContext()->getTransformCache();
cache.initEntry(index);
PxTransform idt(PxIdentity);
cache.setTransformCache(idt, 0, index);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Sc::ParticleSystemShapeSim::destroyLowLevelVolume()
{
if (!isInBroadPhase())
return;
Sc::Scene& scene = getScene();
PxsContactManagerOutputIterator outputs = scene.getLowLevelContext()->getNphaseImplementationContext()->getContactManagerOutputs();
scene.getNPhaseCore()->onVolumeRemoved(this, 0, outputs);
removeFromAABBMgr();
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Sc::ParticleSystemSim& Sc::ParticleSystemShapeSim::getBodySim() const
{
return static_cast<ParticleSystemSim&>(getActor());
}
#endif //PX_SUPPORT_GPU_PHYSX
| 6,690 | C++ | 41.891025 | 199 | 0.606577 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScParticleSystemShapeCore.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-2023 NVIDIA Corporation. All rights reserved.
#ifndef SC_PARTICLESYSTEM_SHAPECORE_H
#define SC_PARTICLESYSTEM_SHAPECORE_H
#include "foundation/PxPreprocessor.h"
#if PX_SUPPORT_GPU_PHYSX
#include "foundation/PxUserAllocated.h"
#include "PxvGeometry.h"
#include "foundation/PxUtilities.h"
#include "PxFiltering.h"
#include "PxShape.h"
#include "ScShapeCore.h"
#include "DyParticleSystemCore.h"
#include "common/PxRenderOutput.h"
namespace physx
{
namespace Sc
{
class Scene;
class ParticleSystemCore;
class ParticleSystemSim;
class ParticleSystemShapeCore : public Sc::ShapeCore
{
public:
// PX_SERIALIZATION
ParticleSystemShapeCore(const PxEMPTY);
//~PX_SERIALIZATION
ParticleSystemShapeCore();
~ParticleSystemShapeCore();
PX_FORCE_INLINE const Dy::ParticleSystemCore& getLLCore() const { return mLLCore; }
PX_FORCE_INLINE Dy::ParticleSystemCore& getLLCore() { return mLLCore; }
void initializeLLCoreData( PxU32 maxNeighborhood);
void addParticleBuffer(PxParticleBuffer* particleBuffer);
void removeParticleBuffer(PxParticleBuffer* particleBuffer);
PxU64 getGpuMemStat() { return mGpuMemStat; }
protected:
Dy::ParticleSystemCore mLLCore;
PxU64 mGpuMemStat;
};
} // namespace Sc
}
#endif
#endif
| 2,787 | C | 33.85 | 86 | 0.762827 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScElementSimInteraction.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-2023 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 SC_ELEMENT_SIM_INTERACTION_H
#define SC_ELEMENT_SIM_INTERACTION_H
#include "ScInteraction.h"
#include "ScElementSim.h"
namespace physx
{
namespace Sc
{
class ElementSimInteraction : public Interaction
{
public:
PX_FORCE_INLINE ElementSim& getElement0() const { return mElement0; }
PX_FORCE_INLINE ElementSim& getElement1() const { return mElement1; }
protected:
PX_INLINE ElementSimInteraction(ElementSim& element0, ElementSim& element1, InteractionType::Enum type, PxU8 flags);
~ElementSimInteraction() {}
ElementSimInteraction& operator=(const ElementSimInteraction&);
ElementSim& mElement0;
ElementSim& mElement1;
PxU32 mFlags; // PT: moved there in padding bytes, from ShapeInteraction
};
} // namespace Sc
//////////////////////////////////////////////////////////////////////////
PX_INLINE Sc::ElementSimInteraction::ElementSimInteraction(ElementSim& element0, ElementSim& element1, InteractionType::Enum type, PxU8 flags) :
Interaction (element0.getActor(), element1.getActor(), type, flags),
mElement0 (element0),
mElement1 (element1)
{
}
}
#endif
| 2,845 | C | 39.084506 | 144 | 0.732162 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScConstraintSim.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-2023 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 SC_CONSTRAINT_SIM_H
#define SC_CONSTRAINT_SIM_H
#include "foundation/PxArray.h"
#include "PxSimulationEventCallback.h"
#include "DyConstraint.h"
namespace physx
{
namespace Sc
{
class Scene;
class ConstraintInteraction;
class ConstraintCore;
class RigidCore;
class BodySim;
class RigidSim;
class ConstraintSim : public PxUserAllocated
{
PX_NOCOPY(ConstraintSim)
public:
enum Enum
{
eBREAKABLE = (1<<1), // The constraint can break
eCHECK_MAX_FORCE_EXCEEDED = (1<<2), // This constraint will get tested for breakage at the end of the sim step
eBROKEN = (1<<3)
};
ConstraintSim(ConstraintCore& core, RigidCore* r0, RigidCore* r1, Scene& scene);
~ConstraintSim();
void setBodies(RigidCore* r0, RigidCore* r1);
void setBreakForceLL(PxReal linear, PxReal angular);
PX_FORCE_INLINE void setMinResponseThresholdLL(PxReal threshold) { mLowLevelConstraint.minResponseThreshold = threshold; }
PX_FORCE_INLINE const void* getConstantsLL() const { return mLowLevelConstraint.constantBlock; }
void postFlagChange(PxConstraintFlags oldFlags, PxConstraintFlags newFlags);
PX_FORCE_INLINE const Dy::Constraint& getLowLevelConstraint() const { return mLowLevelConstraint; }
PX_FORCE_INLINE Dy::Constraint& getLowLevelConstraint() { return mLowLevelConstraint; }
PX_FORCE_INLINE ConstraintCore& getCore() const { return mCore; }
PX_FORCE_INLINE BodySim* getBody(PxU32 i) const // for static actors or world attached constraints NULL is returned
{
return mBodies[i];
}
void getForce(PxVec3& force, PxVec3& torque);
PX_FORCE_INLINE PxU8 readFlag(PxU8 flag) const { return PxU8(mFlags & flag); }
PX_FORCE_INLINE void setFlag(PxU8 flag) { mFlags |= flag; }
PX_FORCE_INLINE void clearFlag(PxU8 flag) { mFlags &= ~flag; }
PX_FORCE_INLINE PxU32 isBroken() const { return PxU32(mFlags) & ConstraintSim::eBROKEN; }
PX_FORCE_INLINE const ConstraintInteraction* getInteraction() const { return mInteraction; }
private:
bool createLLConstraint();
void destroyLLConstraint();
Dy::Constraint mLowLevelConstraint;
Scene& mScene;
ConstraintCore& mCore;
ConstraintInteraction* mInteraction; // PT: why do we have an interaction object here?
BodySim* mBodies[2];
PxU8 mFlags;
};
} // namespace Sc
}
#endif
| 4,205 | C | 40.643564 | 128 | 0.713912 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScElementSim.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScElementSim.h"
#include "ScElementSimInteraction.h"
#include "ScSimStats.h"
using namespace physx;
using namespace Sc;
static PX_FORCE_INLINE bool interactionHasElement(const Interaction* it, const ElementSim* elem)
{
if(it->readInteractionFlag(InteractionFlag::eRB_ELEMENT))
{
PX_ASSERT( (it->getType() == InteractionType::eMARKER) ||
(it->getType() == InteractionType::eOVERLAP) ||
(it->getType() == InteractionType::eTRIGGER) );
const ElementSimInteraction* ei = static_cast<const ElementSimInteraction*>(it);
if((&ei->getElement0() == elem) || (&ei->getElement1() == elem))
return true;
}
return false;
}
Sc::ElementSimInteraction* Sc::ElementSim::ElementInteractionIterator::getNext()
{
while(mInteractions!=mInteractionsLast)
{
Interaction* it = *mInteractions++;
if(interactionHasElement(it, mElement))
return static_cast<ElementSimInteraction*>(it);
}
return NULL;
}
Sc::ElementSimInteraction* Sc::ElementSim::ElementInteractionReverseIterator::getNext()
{
while(mInteractions!=mInteractionsLast)
{
Interaction* it = *--mInteractionsLast;
if(interactionHasElement(it, mElement))
return static_cast<ElementSimInteraction*>(it);
}
return NULL;
}
namespace
{
class ElemSimPtrTableStorageManager : public Cm::PtrTableStorageManager, public PxUserAllocated
{
PX_NOCOPY(ElemSimPtrTableStorageManager)
public:
ElemSimPtrTableStorageManager() {}
~ElemSimPtrTableStorageManager() {}
// PtrTableStorageManager
virtual void** allocate(PxU32 capacity) PX_OVERRIDE
{
return PX_ALLOCATE(void*, capacity, "CmPtrTable pointer array");
}
virtual void deallocate(void** addr, PxU32 /*capacity*/) PX_OVERRIDE
{
PX_FREE(addr);
}
virtual bool canReuse(PxU32 /*originalCapacity*/, PxU32 /*newCapacity*/) PX_OVERRIDE
{
return false;
}
//~PtrTableStorageManager
};
ElemSimPtrTableStorageManager gElemSimTableStorageManager;
}
static PX_FORCE_INLINE void onElementAttach(ElementSim& element, ShapeManager& manager)
{
PX_ASSERT(element.mShapeArrayIndex == 0xffffffff);
element.mShapeArrayIndex = manager.mShapes.getCount();
manager.mShapes.add(&element, gElemSimTableStorageManager);
}
void Sc::ShapeManager::onElementDetach(ElementSim& element)
{
const PxU32 index = element.mShapeArrayIndex;
PX_ASSERT(index != 0xffffffff);
PX_ASSERT(mShapes.getCount());
void** ptrs = mShapes.getPtrs();
PX_ASSERT(reinterpret_cast<ElementSim*>(ptrs[index]) == &element);
const PxU32 last = mShapes.getCount() - 1;
if (index != last)
{
ElementSim* moved = reinterpret_cast<ElementSim*>(ptrs[last]);
PX_ASSERT(moved->mShapeArrayIndex == last);
moved->mShapeArrayIndex = index;
}
mShapes.replaceWithLast(index, gElemSimTableStorageManager);
element.mShapeArrayIndex = 0xffffffff;
}
Sc::ElementSim::ElementSim(ActorSim& actor) :
mActor (actor),
mInBroadPhase (false),
mShapeArrayIndex(0xffffffff)
{
initID();
onElementAttach(*this, actor);
}
Sc::ElementSim::~ElementSim()
{
PX_ASSERT(!mInBroadPhase);
releaseID();
mActor.onElementDetach(*this);
}
void Sc::ElementSim::addToAABBMgr(PxReal contactDistance, Bp::FilterGroup::Enum group, Bp::ElementType::Enum type)
{
Sc::Scene& scene = getScene();
if(!scene.getAABBManager()->addBounds(mElementID, contactDistance, group, this, mActor.getActorCore().getAggregateID(), type))
return;
mInBroadPhase = true;
#if PX_ENABLE_SIM_STATS
scene.getStatsInternal().incBroadphaseAdds();
#else
PX_CATCH_UNDEFINED_ENABLE_SIM_STATS
#endif
}
bool Sc::ElementSim::removeFromAABBMgr()
{
PX_ASSERT(mInBroadPhase);
Sc::Scene& scene = getScene();
bool res = scene.getAABBManager()->removeBounds(mElementID);
scene.getAABBManager()->getChangedAABBMgActorHandleMap().growAndReset(mElementID);
mInBroadPhase = false;
#if PX_ENABLE_SIM_STATS
scene.getStatsInternal().incBroadphaseRemoves();
#else
PX_CATCH_UNDEFINED_ENABLE_SIM_STATS
#endif
return res;
}
| 5,601 | C++ | 31.011428 | 127 | 0.752544 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScNPhaseCore.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScNPhaseCore.h"
#include "ScShapeInteraction.h"
#include "ScTriggerInteraction.h"
#include "ScElementInteractionMarker.h"
#include "ScConstraintInteraction.h"
#include "ScSimStats.h"
using namespace physx;
using namespace Sc;
///////////////////////////////////////////////////////////////////////////////
PX_IMPLEMENT_OUTPUT_ERROR
///////////////////////////////////////////////////////////////////////////////
NPhaseCore::NPhaseCore(Scene& scene, const PxSceneDesc& sceneDesc) :
mOwnerScene (scene),
mContactReportActorPairSet ("contactReportPairSet"),
mPersistentContactEventPairList ("persistentContactEventPairs"),
mNextFramePersistentContactEventPairIndex (0),
mForceThresholdContactEventPairList ("forceThresholdContactEventPairs"),
mContactReportBuffer (sceneDesc.contactReportStreamBufferSize, (sceneDesc.flags & PxSceneFlag::eDISABLE_CONTACT_REPORT_BUFFER_RESIZE)),
mActorPairPool ("actorPairPool"),
mActorPairReportPool ("actorPairReportPool"),
mShapeInteractionPool (PxAllocatorTraits<ShapeInteraction>::Type("shapeInteractionPool"), 4096),
mTriggerInteractionPool ("triggerInteractionPool"),
mActorPairContactReportDataPool ("actorPairContactReportPool"),
mInteractionMarkerPool ("interactionMarkerPool"),
mConcludeTriggerInteractionProcessingTask (scene.getContextId(), this, "ScNPhaseCore.concludeTriggerInteractionProcessing")
{
}
NPhaseCore::~NPhaseCore()
{
// Clear pending actor pairs (waiting on contact report callback)
clearContactReportActorPairs(false);
}
PxU32 NPhaseCore::getDefaultContactReportStreamBufferSize() const
{
return mContactReportBuffer.getDefaultBufferSize();
}
ElementSimInteraction* NPhaseCore::findInteraction(const ElementSim* element0, const ElementSim* element1)
{
const PxHashMap<ElementSimKey, ElementSimInteraction*>::Entry* pair = mElementSimMap.find(ElementSimKey(element0->getElementID(), element1->getElementID()));
return pair ? pair->second : NULL;
}
void NPhaseCore::registerInteraction(ElementSimInteraction* interaction)
{
mElementSimMap.insert(ElementSimKey(interaction->getElement0().getElementID(), interaction->getElement1().getElementID()), interaction);
}
void NPhaseCore::unregisterInteraction(ElementSimInteraction* interaction)
{
mElementSimMap.erase(ElementSimKey(interaction->getElement0().getElementID(), interaction->getElement1().getElementID()));
}
void NPhaseCore::onOverlapRemoved(ElementSim* volume0, ElementSim* volume1, PxU32 ccdPass, void* elemSim, PxsContactManagerOutputIterator& outputs)
{
ElementSim* elementHi = volume1;
ElementSim* elementLo = volume0;
// No actor internal interactions
PX_ASSERT(&elementHi->getActor() != &elementLo->getActor());
// PT: TODO: get rid of 'findInteraction', cf US10491
ElementSimInteraction* interaction = elemSim ? reinterpret_cast<ElementSimInteraction*>(elemSim) : findInteraction(elementHi, elementLo);
// MS: The check below is necessary since at the moment LowLevel broadphase still tracks
// killed pairs and hence reports lost overlaps
if(interaction)
{
PxU32 flags = PxU32(PairReleaseFlag::eWAKE_ON_LOST_TOUCH);
PX_ASSERT(interaction->isElementInteraction());
releaseElementPair(static_cast<ElementSimInteraction*>(interaction), flags, NULL, ccdPass, true, outputs);
}
}
// MS: TODO: optimize this for the actor release case?
void NPhaseCore::onVolumeRemoved(ElementSim* volume, PxU32 flags, PxsContactManagerOutputIterator& outputs)
{
const PxU32 ccdPass = 0;
flags |= PairReleaseFlag::eRUN_LOST_TOUCH_LOGIC;
// Release interactions
// IMPORTANT: Iterate from the back of the list to the front as we release interactions which
// triggers a replace with last
ElementSim::ElementInteractionReverseIterator iter = volume->getElemInteractionsReverse();
ElementSimInteraction* interaction = iter.getNext();
while(interaction)
{
PX_ASSERT( (interaction->getType() == InteractionType::eMARKER) ||
(interaction->getType() == InteractionType::eOVERLAP) ||
(interaction->getType() == InteractionType::eTRIGGER) );
releaseElementPair(interaction, flags, volume, ccdPass, true, outputs);
interaction = iter.getNext();
}
}
ElementSimInteraction* NPhaseCore::createRbElementInteraction(const FilterInfo& finfo, ShapeSimBase& s0, ShapeSimBase& s1, PxsContactManager* contactManager, ShapeInteraction* shapeInteraction,
ElementInteractionMarker* interactionMarker, bool isTriggerPair)
{
ElementSimInteraction* pair = NULL;
if((finfo.filterFlags & PxFilterFlag::eSUPPRESS) == false)
{
if(!isTriggerPair)
{
PX_ASSERT(contactManager);
PX_ASSERT(shapeInteraction);
pair = createShapeInteraction(s0, s1, finfo.pairFlags, contactManager, shapeInteraction);
}
else
{
pair = createTriggerInteraction(s0, s1, finfo.pairFlags);
}
}
else
pair = createElementInteractionMarker(s0, s1, interactionMarker);
if(finfo.hasPairID)
{
// Mark the pair as a filter callback pair
pair->raiseInteractionFlag(InteractionFlag::eIS_FILTER_PAIR);
}
return pair;
}
void NPhaseCore::managerNewTouch(ShapeInteraction& interaction)
{
//(1) if the pair hasn't already been assigned, look it up!
ActorPair* actorPair = interaction.getActorPair();
if(!actorPair)
{
ShapeSim& s0 = static_cast<ShapeSim&>(interaction.getElement0());
ShapeSim& s1 = static_cast<ShapeSim&>(interaction.getElement1());
actorPair = findActorPair(&s0, &s1, interaction.isReportPair());
actorPair->incRefCount(); //It's being referenced by a new pair...
interaction.setActorPair(*actorPair);
}
}
static bool shouldSwapBodies(const ShapeSimBase& s0, const ShapeSimBase& s1)
{
/*
This tries to ensure that if one of the bodies is static or kinematic, it will be body B
There is a further optimization to force all pairs that share the same bodies to have
the same body ordering. This reduces the number of required partitions in the parallel solver.
Sorting rules are:
If bodyA is static, swap
If bodyA is rigidDynamic and bodyB is articulation, swap
If bodyA is in an earlier BP group than bodyB, swap
*/
// PT: some of these swaps are here to fulfill requirements from the solver code, and we
// will get asserts and failures without them. Some others are only optimizations.
// PT: generally speaking we want the "static" actor to be second in the pair.
// "Static" can mean either:
// - a proper static body
// - a kinematic dynamic body
// - an articulation link with a fixed base
ActorSim& rs0 = s0.getActor();
const PxActorType::Enum actorType0 = rs0.getActorType();
if(actorType0 == PxActorType::eRIGID_STATIC)
return true;
ActorSim& rs1 = s1.getActor();
const PxActorType::Enum actorType1 = rs1.getActorType();
const bool isDyna0 = actorType0 == PxActorType::eRIGID_DYNAMIC;
const bool isDyna1 = actorType1 == PxActorType::eRIGID_DYNAMIC;
if(actorType0 == PxActorType::eARTICULATION_LINK)
{
if(isDyna1 || actorType1 == PxActorType::eARTICULATION_LINK)
{
if(static_cast<BodySim&>(rs0).getLowLevelBody().mCore->fixedBaseLink)
return true;
}
}
else if(isDyna0)
{
// PT: this tries to implement this requirement: "If bodyA is rigidDynamic and bodyB is articulation, swap"
// But we do NOT do that if bodyB has a fixed base. It is unclear whether this particular swap is really needed.
if(actorType1 == PxActorType::eARTICULATION_LINK)
{
if(!static_cast<BodySim&>(rs1).getLowLevelBody().mCore->fixedBaseLink)
return true;
}
}
// PT: initial code was:
// if((actorType0 == PxActorType::eRIGID_DYNAMIC && actorType1 == PxActorType::eRIGID_DYNAMIC) && actorAKinematic)
// But actorAKinematic true implies isDyna0 true, so this is equivalent to
// if(isDyna1 && actorAKinematic)
// And we only need actorAKinematic in this expression so it's faster to move its computation inside the if:
// if(isDyna1 && isDyna0 && static_cast<BodySim&>(rs0).isKinematic())
if(isDyna1 && isDyna0 && static_cast<BodySim&>(rs0).isKinematic())
return true;
// PT: initial code was:
// if(actorType0 == actorType1 && rs0.getActorID() < rs1.getActorID() && !actorBKinematic)
// We refactor the code a bit to avoid computing actorBKinematic. We could also test actorBKinematic
// first and avoid reading actor IDs. Unclear what's best, arbitrary choice for now.
if((actorType0 == actorType1) && (rs0.getActorID() < rs1.getActorID()))
{
const bool actorBKinematic = isDyna1 && static_cast<BodySim&>(rs1).isKinematic();
if(!actorBKinematic)
return true;
}
#if PX_SUPPORT_GPU_PHYSX
// PT: using rs0.isParticleSystem() instead of isParticleSystem(actorType0) is faster.
if(actorType1 != PxActorType::eRIGID_STATIC && rs0.isParticleSystem())
return true;
#endif
return false;
}
ShapeInteraction* NPhaseCore::createShapeInteraction(ShapeSimBase& s0, ShapeSimBase& s1, PxPairFlags pairFlags, PxsContactManager* contactManager, ShapeInteraction* shapeInteraction)
{
ShapeSimBase* _s0 = &s0;
ShapeSimBase* _s1 = &s1;
if(shouldSwapBodies(s0, s1))
PxSwap(_s0, _s1);
ShapeInteraction* si = shapeInteraction ? shapeInteraction : mShapeInteractionPool.allocate();
PX_PLACEMENT_NEW(si, ShapeInteraction)(*_s0, *_s1, pairFlags, contactManager);
PX_ASSERT(si->mReportPairIndex == INVALID_REPORT_PAIR_ID);
return si;
}
TriggerInteraction* NPhaseCore::createTriggerInteraction(ShapeSimBase& s0, ShapeSimBase& s1, PxPairFlags triggerFlags)
{
ShapeSimBase* triggerShape;
ShapeSimBase* otherShape;
if(s1.getFlags() & PxShapeFlag::eTRIGGER_SHAPE)
{
triggerShape = &s1;
otherShape = &s0;
}
else
{
triggerShape = &s0;
otherShape = &s1;
}
TriggerInteraction* pair = mTriggerInteractionPool.construct(*triggerShape, *otherShape);
pair->setTriggerFlags(triggerFlags);
return pair;
}
ElementInteractionMarker* NPhaseCore::createElementInteractionMarker(ElementSim& e0, ElementSim& e1, ElementInteractionMarker* interactionMarker)
{
ElementInteractionMarker* pair = interactionMarker ? interactionMarker : mInteractionMarkerPool.allocate();
PX_PLACEMENT_NEW(pair, ElementInteractionMarker)(e0, e1, interactionMarker != NULL);
return pair;
}
ActorPair* NPhaseCore::findActorPair(ShapeSimBase* s0, ShapeSimBase* s1, PxIntBool isReportPair)
{
PX_ASSERT(!(s0->getFlags() & PxShapeFlag::eTRIGGER_SHAPE)
&& !(s1->getFlags() & PxShapeFlag::eTRIGGER_SHAPE));
ActorSim* aLess = &s0->getActor();
ActorSim* aMore = &s1->getActor();
if(aLess->getActorID() > aMore->getActorID())
PxSwap(aLess, aMore);
const BodyPairKey key(aLess->getActorID(), aMore->getActorID());
ActorPair*& actorPair = mActorPairMap[key];
if(actorPair == NULL)
{
if(!isReportPair)
actorPair = mActorPairPool.construct();
else
actorPair = mActorPairReportPool.construct(s0->getActor(), s1->getActor());
}
if(!isReportPair || actorPair->isReportPair())
return actorPair;
else
{
PxU32 size = aLess->getActorInteractionCount();
Interaction** interactions = aLess->getActorInteractions();
ActorPairReport* actorPairReport = mActorPairReportPool.construct(s0->getActor(), s1->getActor());
actorPairReport->convert(*actorPair);
while(size--)
{
Interaction* interaction = *interactions++;
if((&interaction->getActorSim0() == aMore) || (&interaction->getActorSim1() == aMore))
{
PX_ASSERT(((&interaction->getActorSim0() == aLess) || (&interaction->getActorSim1() == aLess)));
if(interaction->getType() == InteractionType::eOVERLAP)
{
ShapeInteraction* si = static_cast<ShapeInteraction*>(interaction);
if(si->getActorPair() != NULL)
si->setActorPair(*actorPairReport);
}
}
}
PX_ASSERT(!actorPair->isReportPair());
mActorPairPool.destroy(actorPair);
actorPair = actorPairReport;
}
return actorPair;
}
PX_FORCE_INLINE void NPhaseCore::destroyActorPairReport(ActorPairReport& aPair)
{
PX_ASSERT(aPair.isReportPair());
aPair.releaseContactReportData(*this);
mActorPairReportPool.destroy(&aPair);
}
ElementSimInteraction* NPhaseCore::convert(ElementSimInteraction* pair, InteractionType::Enum newType, FilterInfo& filterInfo, bool removeFromDirtyList,
PxsContactManagerOutputIterator& outputs)
{
PX_ASSERT(newType != pair->getType());
ElementSim& elementA = pair->getElement0();
ElementSim& elementB = pair->getElement1();
// Wake up the actors of the pair
if((pair->getActorSim0().getActorType() == PxActorType::eRIGID_DYNAMIC) && !(static_cast<BodySim&>(pair->getActorSim0()).isActive()))
pair->getActorSim0().internalWakeUp();
if((pair->getActorSim1().getActorType() == PxActorType::eRIGID_DYNAMIC) && !(static_cast<BodySim&>(pair->getActorSim1()).isActive()))
pair->getActorSim1().internalWakeUp();
// Since the FilterPair struct might have been re-used in the newly created interaction, we need to clear
// the filter pair marker of the old interaction to avoid that the FilterPair gets deleted by the releaseElementPair()
// call that follows.
pair->clearInteractionFlag(InteractionFlag::eIS_FILTER_PAIR);
// PT: we need to unregister the old interaction *before* creating the new one, because Sc::NPhaseCore::registerInteraction will use
// ElementSim pointers which are the same for both. Since "releaseElementPair" will call the unregister function from
// the element's dtor, we don't need to do it explicitly here. Just release the object.
releaseElementPair(pair, PairReleaseFlag::eWAKE_ON_LOST_TOUCH | PairReleaseFlag::eRUN_LOST_TOUCH_LOGIC, NULL, 0, removeFromDirtyList, outputs);
ElementSimInteraction* result = NULL;
switch(newType)
{
case InteractionType::eINVALID:
// This means the pair should get killed
break;
case InteractionType::eMARKER:
{
result = createElementInteractionMarker(elementA, elementB, NULL);
break;
}
case InteractionType::eOVERLAP:
{
result = createShapeInteraction(static_cast<ShapeSim&>(elementA), static_cast<ShapeSim&>(elementB), filterInfo.pairFlags, NULL, NULL);
break;
}
case InteractionType::eTRIGGER:
{
result = createTriggerInteraction(static_cast<ShapeSim&>(elementA), static_cast<ShapeSim&>(elementB), filterInfo.pairFlags);
break;
}
case InteractionType::eCONSTRAINTSHADER:
case InteractionType::eARTICULATION:
case InteractionType::eTRACKED_IN_SCENE_COUNT:
PX_ASSERT(0);
break;
};
if(filterInfo.hasPairID)
{
PX_ASSERT(result);
// If a filter callback pair is going to get killed, then the FilterPair struct should already have
// been deleted.
// Mark the new interaction as a filter callback pair
result->raiseInteractionFlag(InteractionFlag::eIS_FILTER_PAIR);
}
return result;
}
namespace physx
{
namespace Sc
{
static bool findTriggerContacts(TriggerInteraction* tri, bool toBeDeleted, bool volumeRemoved,
PxTriggerPair& triggerPair, TriggerPairExtraData& triggerPairExtra,
SimStats::TriggerPairCountsNonVolatile& triggerPairStats,
const PxsTransformCache& transformCache)
{
ShapeSimBase& s0 = tri->getTriggerShape();
ShapeSimBase& s1 = tri->getOtherShape();
const PxPairFlags pairFlags = tri->getTriggerFlags();
PxPairFlags pairEvent;
bool overlap;
PxU8 testForRemovedShapes = 0;
if(toBeDeleted)
{
// The trigger interaction is to lie down in its tomb, hence we know that the overlap is gone.
// What remains is to check whether the interaction was deleted because of a shape removal in
// which case we need to later check for removed shapes.
overlap = false;
if(volumeRemoved)
{
// Note: only the first removed volume can be detected when the trigger interaction is deleted but at a later point the second volume might get removed too.
testForRemovedShapes = TriggerPairFlag::eTEST_FOR_REMOVED_SHAPES;
}
}
else
{
#if PX_ENABLE_SIM_STATS
PX_ASSERT(s0.getGeometryType() < PxGeometryType::eCONVEXMESH+1); // The first has to be the trigger shape
triggerPairStats[s0.getGeometryType()][s1.getGeometryType()]++;
#else
PX_UNUSED(triggerPairStats);
PX_CATCH_UNDEFINED_ENABLE_SIM_STATS
#endif
ShapeSimBase* primitive0 = &s0;
ShapeSimBase* primitive1 = &s1;
PX_ASSERT(primitive0->getFlags() & PxShapeFlag::eTRIGGER_SHAPE
|| primitive1->getFlags() & PxShapeFlag::eTRIGGER_SHAPE);
// Reorder them if needed
if(primitive0->getGeometryType() > primitive1->getGeometryType())
PxSwap(primitive0, primitive1);
const Gu::GeomOverlapFunc overlapFunc =
Gu::getOverlapFuncTable()[primitive0->getGeometryType()][primitive1->getGeometryType()];
const PxU32 elementID0 = primitive0->getElementID();
const PxU32 elementID1 = primitive1->getElementID();
const PxTransform& globalPose0 = transformCache.getTransformCache(elementID0).transform;
const PxTransform& globalPose1 = transformCache.getTransformCache(elementID1).transform;
PX_ASSERT(overlapFunc);
overlap = overlapFunc( primitive0->getCore().getGeometry(), globalPose0,
primitive1->getCore().getGeometry(), globalPose1,
&tri->getTriggerCache(), UNUSED_OVERLAP_THREAD_CONTEXT);
}
const bool hadOverlap = tri->lastFrameHadContacts();
if(hadOverlap)
{
if(!overlap)
pairEvent = PxPairFlag::eNOTIFY_TOUCH_LOST;
}
else
{
if(overlap)
pairEvent = PxPairFlag::eNOTIFY_TOUCH_FOUND;
}
tri->updateLastFrameHadContacts(overlap);
const PxPairFlags triggeredFlags = pairEvent & pairFlags;
if(triggeredFlags)
{
triggerPair.triggerShape = s0.getPxShape();
triggerPair.otherShape = s1.getPxShape();
triggerPair.status = PxPairFlag::Enum(PxU32(pairEvent));
triggerPair.flags = PxTriggerPairFlags(testForRemovedShapes);
const ActorCore& actorCore0 = s0.getActor().getActorCore();
const ActorCore& actorCore1 = s1.getActor().getActorCore();
#if PX_SUPPORT_GPU_PHYSX
if (actorCore0.getActorCoreType() == PxActorType::eSOFTBODY)
triggerPair.triggerActor = static_cast<const SoftBodyCore&>(actorCore0).getPxActor();
else
#endif
triggerPair.triggerActor = static_cast<const RigidCore&>(actorCore0).getPxActor();
#if PX_SUPPORT_GPU_PHYSX
if (actorCore0.getActorCoreType() == PxActorType::eSOFTBODY)
triggerPair.otherActor = static_cast<const SoftBodyCore&>(actorCore1).getPxActor();
else
#endif
triggerPair.otherActor = static_cast<const RigidCore&>(actorCore1).getPxActor();
triggerPairExtra = TriggerPairExtraData(s0.getElementID(), s1.getElementID(),
actorCore0.getOwnerClient(), actorCore1.getOwnerClient());
return true;
}
return false;
}
class TriggerContactTask : public Cm::Task
{
PX_NOCOPY(TriggerContactTask)
public:
TriggerContactTask(TriggerInteraction* const* triggerPairs, PxU32 triggerPairCount, PxMutex& lock,
Scene& scene, PxsTransformCache& transformCache) :
Cm::Task (scene.getContextId()),
mTriggerPairs (triggerPairs),
mTriggerPairCount (triggerPairCount),
mLock (lock),
mScene (scene),
mTransformCache (transformCache)
{
}
virtual void runInternal()
{
SimStats::TriggerPairCountsNonVolatile triggerPairStats;
#if PX_ENABLE_SIM_STATS
PxMemZero(&triggerPairStats, sizeof(SimStats::TriggerPairCountsNonVolatile));
#else
PX_CATCH_UNDEFINED_ENABLE_SIM_STATS
#endif
PxTriggerPair triggerPair[sTriggerPairsPerTask];
TriggerPairExtraData triggerPairExtra[sTriggerPairsPerTask];
PxU32 triggerReportItemCount = 0;
for(PxU32 i=0; i < mTriggerPairCount; i++)
{
TriggerInteraction* tri = mTriggerPairs[i];
PX_ASSERT(tri->readInteractionFlag(InteractionFlag::eIS_ACTIVE));
if (findTriggerContacts(tri, false, false, triggerPair[triggerReportItemCount],
triggerPairExtra[triggerReportItemCount], triggerPairStats, mTransformCache))
{
triggerReportItemCount++;
}
}
if(triggerReportItemCount)
{
PxTriggerPair* triggerPairBuffer;
TriggerPairExtraData* triggerPairExtraBuffer;
{
PxMutex::ScopedLock lock(mLock);
mScene.reserveTriggerReportBufferSpace(triggerReportItemCount, triggerPairBuffer, triggerPairExtraBuffer);
PxMemCopy(triggerPairBuffer, triggerPair, sizeof(PxTriggerPair) * triggerReportItemCount);
PxMemCopy(triggerPairExtraBuffer, triggerPairExtra, sizeof(TriggerPairExtraData) * triggerReportItemCount);
}
}
#if PX_ENABLE_SIM_STATS
SimStats& simStats = mScene.getStatsInternal();
for(PxU32 i=0; i < PxGeometryType::eCONVEXMESH+1; i++)
{
for(PxU32 j=0; j < PxGeometryType::eGEOMETRY_COUNT; j++)
{
if(triggerPairStats[i][j] != 0)
PxAtomicAdd(&simStats.numTriggerPairs[i][j], triggerPairStats[i][j]);
}
}
#else
PX_CATCH_UNDEFINED_ENABLE_SIM_STATS
#endif
}
virtual const char* getName() const
{
return "ScNPhaseCore.triggerInteractionWork";
}
public:
static const PxU32 sTriggerPairsPerTask = 64;
private:
TriggerInteraction* const* mTriggerPairs;
const PxU32 mTriggerPairCount;
PxMutex& mLock;
Scene& mScene;
PxsTransformCache& mTransformCache;
};
} // namespace Sc
} // namespace physx
bool TriggerProcessingContext::initialize(TriggerInteraction** interactions, PxU32 pairCount, PxcScratchAllocator& allocator)
{
PX_ASSERT(!mTmpTriggerProcessingBlock);
PX_ASSERT(mTmpTriggerPairCount == 0);
PX_ASSERT(pairCount > 0);
const PxU32 taskCountWithoutRemainder = pairCount / TriggerContactTask::sTriggerPairsPerTask;
const PxU32 maxTaskCount = taskCountWithoutRemainder + 1;
const PxU32 pairPtrSize = pairCount * sizeof(TriggerInteraction*);
const PxU32 memBlockSize = pairPtrSize + (maxTaskCount * sizeof(TriggerContactTask));
PxU8* triggerProcessingBlock = reinterpret_cast<PxU8*>(allocator.alloc(memBlockSize, true));
if (triggerProcessingBlock)
{
PxMemCopy(triggerProcessingBlock, interactions, pairPtrSize); // needs to get copied because other tasks may change the source list
// while trigger overlap tests run
mTmpTriggerProcessingBlock = triggerProcessingBlock; // note: gets released in deinitialize
mTmpTriggerPairCount = pairCount;
return true;
}
else
{
outputError<PxErrorCode::eOUT_OF_MEMORY>(__LINE__, "Temporary memory for trigger pair processing could not be allocated. Trigger overlap tests will not take place.");
}
return false;
}
void TriggerProcessingContext::deinitialize(PxcScratchAllocator& allocator)
{
PX_ASSERT(mTmpTriggerProcessingBlock);
PX_ASSERT(mTmpTriggerPairCount > 0);
allocator.free(mTmpTriggerProcessingBlock);
mTmpTriggerProcessingBlock = NULL;
mTmpTriggerPairCount = 0;
}
PxBaseTask* NPhaseCore::prepareForTriggerInteractionProcessing(PxBaseTask* continuation)
{
// Triggers
TriggerInteraction** triggerInteractions = reinterpret_cast<TriggerInteraction**>(mOwnerScene.getActiveInteractions(InteractionType::eTRIGGER));
const PxU32 pairCount = mOwnerScene.getNbActiveInteractions(InteractionType::eTRIGGER);
if (pairCount > 0)
{
if (mTriggerProcessingContext.initialize(triggerInteractions, pairCount, mOwnerScene.getLowLevelContext()->getScratchAllocator()))
{
mConcludeTriggerInteractionProcessingTask.setContinuation(continuation);
return &mConcludeTriggerInteractionProcessingTask;
}
}
return NULL;
}
void NPhaseCore::processTriggerInteractions(PxBaseTask& continuation)
{
TriggerInteraction* const* triggerInteractions = mTriggerProcessingContext.getTriggerInteractions();
const PxU32 pairCount = mTriggerProcessingContext.getTriggerInteractionCount();
TriggerContactTask* triggerContactTaskBuffer = mTriggerProcessingContext.getTriggerContactTasks();
PxMutex& triggerWriteBackLock = mTriggerProcessingContext.getTriggerWriteBackLock();
PX_ASSERT(triggerInteractions);
PX_ASSERT(pairCount > 0);
PX_ASSERT(triggerContactTaskBuffer);
// PT: TASK-CREATION TAG
const bool hasMultipleThreads = mOwnerScene.getTaskManager().getCpuDispatcher()->getWorkerCount() > 1;
const bool moreThanOneBatch = pairCount > TriggerContactTask::sTriggerPairsPerTask;
const bool scheduleTasks = hasMultipleThreads && moreThanOneBatch;
// when running on a single thread, the task system seems to cause the main overhead (locking and atomic operations
// seemed less of an issue). Hence, the tasks get run directly in that case. Same if there is only one batch.
PxsTransformCache& transformCache = mOwnerScene.getLowLevelContext()->getTransformCache();
PxU32 remainder = pairCount;
while(remainder)
{
const PxU32 nb = remainder > TriggerContactTask::sTriggerPairsPerTask ? TriggerContactTask::sTriggerPairsPerTask : remainder;
remainder -= nb;
TriggerContactTask* task = triggerContactTaskBuffer;
task = PX_PLACEMENT_NEW(task, TriggerContactTask( triggerInteractions, nb, triggerWriteBackLock,
mOwnerScene, transformCache));
if(scheduleTasks)
{
task->setContinuation(&continuation);
task->removeReference();
}
else
task->runInternal();
triggerContactTaskBuffer++;
triggerInteractions += nb;
}
}
void NPhaseCore::concludeTriggerInteractionProcessing(PxBaseTask*)
{
// check if active trigger pairs can be deactivated (until woken up again)
TriggerInteraction* const* triggerInteractions = mTriggerProcessingContext.getTriggerInteractions();
const PxU32 pairCount = mTriggerProcessingContext.getTriggerInteractionCount();
PX_ASSERT(triggerInteractions);
PX_ASSERT(pairCount > 0);
for (PxU32 i = 0; i < pairCount; i++)
{
TriggerInteraction* tri = triggerInteractions[i];
PX_ASSERT(tri->readInteractionFlag(InteractionFlag::eIS_ACTIVE));
if (!(tri->readFlag(TriggerInteraction::PROCESS_THIS_FRAME)))
{
// active trigger pairs for which overlap tests were not forced should remain in the active list
// to catch transitions between overlap and no overlap
continue;
}
else
{
tri->clearFlag(TriggerInteraction::PROCESS_THIS_FRAME);
// explicitly scheduled overlap test is done (after object creation, teleport, ...). Check if trigger pair should remain active or not.
if (!tri->onActivate(NULL))
{
PX_ASSERT(tri->readInteractionFlag(InteractionFlag::eIS_ACTIVE));
// Why is the assert enough?
// Once an explicit overlap test is scheduled, the interaction can not get deactivated anymore until it got processed.
tri->clearInteractionFlag(InteractionFlag::eIS_ACTIVE);
mOwnerScene.notifyInteractionDeactivated(tri);
}
}
}
mTriggerProcessingContext.deinitialize(mOwnerScene.getLowLevelContext()->getScratchAllocator());
}
#ifdef REMOVED
class ProcessPersistentContactTask : public Cm::Task
{
Sc::NPhaseCore& mCore;
ContactReportBuffer& mBuffer;
PxMutex& mMutex;
ShapeInteraction*const* mPersistentEventPairs;
PxU32 mNbPersistentEventPairs;
PxsContactManagerOutputIterator mOutputs;
PX_NOCOPY(ProcessPersistentContactTask)
public:
ProcessPersistentContactTask(Sc::NPhaseCore& core, ContactReportBuffer& buffer, PxMutex& mutex, ShapeInteraction*const* persistentEventPairs,
PxU32 nbPersistentEventPairs, PxsContactManagerOutputIterator& outputs) : Cm::Task(0), mCore(core), mBuffer(buffer), mMutex(mutex),
mPersistentEventPairs(persistentEventPairs), mNbPersistentEventPairs(nbPersistentEventPairs), mOutputs(outputs)
{
}
virtual void runInternal()
{
PX_PROFILE_ZONE("ProcessPersistentContactTask", mCore.getScene().getContextId());
PxU32 size = mNbPersistentEventPairs;
ShapeInteraction*const* persistentEventPairs = mPersistentEventPairs;
while (size--)
{
ShapeInteraction* pair = *persistentEventPairs++;
if (size)
{
if (size > 1)
{
if (size > 2)
{
ShapeInteraction* nextPair = *(persistentEventPairs + 2);
prefetchLine(nextPair);
}
ShapeInteraction* nextPair = *(persistentEventPairs + 1);
ActorPair* aPair = nextPair->getActorPair();
prefetchLine(aPair);
prefetchLine(&nextPair->getShape0());
prefetchLine(&nextPair->getShape1());
}
ShapeInteraction* nextPair = *(persistentEventPairs);
prefetchLine(&nextPair->getShape0().getActor());
prefetchLine(&nextPair->getShape1().getActor());
}
PX_ASSERT(pair->hasTouch());
PX_ASSERT(pair->isReportPair());
const PxU32 pairFlags = pair->getPairFlags();
if ((pairFlags & PxU32(PxPairFlag::eNOTIFY_TOUCH_PERSISTS | PxPairFlag::eDETECT_DISCRETE_CONTACT)) == PxU32(PxPairFlag::eNOTIFY_TOUCH_PERSISTS | PxPairFlag::eDETECT_DISCRETE_CONTACT))
{
// do not process the pair if only eDETECT_CCD_CONTACT is enabled because at this point CCD did not run yet. Plus the current CCD implementation can not reliably provide eNOTIFY_TOUCH_PERSISTS events
// for performance reasons.
//KS - filter based on edge activity!
const ActorSim& bodySim0 = pair->getShape0().getActor();
const ActorSim& bodySim1 = pair->getShape1().getActor();
if (bodySim0.isActive() || (!bodySim1.isStaticRigid() && bodySim1.isActive()))
pair->processUserNotificationAsync(PxPairFlag::eNOTIFY_TOUCH_PERSISTS, 0, false, 0, false, mOutputs/*, &alloc*/);
}
}
}
virtual const char* getName() const
{
return "ScNPhaseCore.ProcessPersistentContactTask";
}
};
#endif
void NPhaseCore::processPersistentContactEvents(PxsContactManagerOutputIterator& outputs)
{
PX_PROFILE_ZONE("Sc::NPhaseCore::processPersistentContactEvents", mOwnerScene.getContextId());
// Go through ShapeInteractions which requested persistent contact event reports. This is necessary since there are no low level events for persistent contact.
ShapeInteraction*const* persistentEventPairs = getCurrentPersistentContactEventPairs();
PxU32 size = getCurrentPersistentContactEventPairCount();
while (size--)
{
ShapeInteraction* pair = *persistentEventPairs++;
if (size)
{
ShapeInteraction* nextPair = *persistentEventPairs;
PxPrefetchLine(nextPair);
}
ActorPair* aPair = pair->getActorPair();
PxPrefetchLine(aPair);
PX_ASSERT(pair->hasTouch());
PX_ASSERT(pair->isReportPair());
const PxU32 pairFlags = pair->getPairFlags();
if ((pairFlags & PxU32(PxPairFlag::eNOTIFY_TOUCH_PERSISTS | PxPairFlag::eDETECT_DISCRETE_CONTACT)) == PxU32(PxPairFlag::eNOTIFY_TOUCH_PERSISTS | PxPairFlag::eDETECT_DISCRETE_CONTACT))
{
// do not process the pair if only eDETECT_CCD_CONTACT is enabled because at this point CCD did not run yet. Plus the current CCD implementation can not reliably provide eNOTIFY_TOUCH_PERSISTS events
// for performance reasons.
//KS - filter based on edge activity!
const ActorSim& actorSim0= pair->getShape0().getActor();
const ActorSim& actorSim1 = pair->getShape1().getActor();
if (actorSim0.isActive() || ((!actorSim1.isStaticRigid()) && actorSim1.isActive()))
pair->processUserNotification(PxPairFlag::eNOTIFY_TOUCH_PERSISTS, 0, false, 0, false, outputs);
}
}
}
void NPhaseCore::addToDirtyInteractionList(Interaction* pair)
{
mDirtyInteractions.insert(pair);
}
void NPhaseCore::removeFromDirtyInteractionList(Interaction* pair)
{
PX_ASSERT(mDirtyInteractions.contains(pair));
mDirtyInteractions.erase(pair);
}
void NPhaseCore::updateDirtyInteractions(PxsContactManagerOutputIterator& outputs)
{
// The sleeping SIs will be updated on activation
// clow: Sleeping SIs are not awaken for visualization updates
const bool dirtyDominance = mOwnerScene.readInternalFlag(SceneInternalFlag::eSCENE_SIP_STATES_DIRTY_DOMINANCE);
const bool dirtyVisualization = mOwnerScene.readInternalFlag(SceneInternalFlag::eSCENE_SIP_STATES_DIRTY_VISUALIZATION);
if(dirtyDominance || dirtyVisualization)
{
// Update all interactions.
const PxU8 mask = PxTo8((dirtyDominance ? InteractionDirtyFlag::eDOMINANCE : 0) | (dirtyVisualization ? InteractionDirtyFlag::eVISUALIZATION : 0));
ElementSimInteraction** it = mOwnerScene.getInteractions(InteractionType::eOVERLAP);
PxU32 size = mOwnerScene.getNbInteractions(InteractionType::eOVERLAP);
while(size--)
{
ElementSimInteraction* pair = *it++;
PX_ASSERT(pair->getType() == InteractionType::eOVERLAP);
if(!pair->readInteractionFlag(InteractionFlag::eIN_DIRTY_LIST))
{
PX_ASSERT(!pair->getDirtyFlags());
static_cast<ShapeInteraction*>(pair)->updateState(mask);
}
else
pair->setDirty(mask); // the pair will get processed further below anyway, so just mark the flags dirty
}
}
// Update all interactions in the dirty list
const PxU32 dirtyItcCount = mDirtyInteractions.size();
Interaction* const* dirtyInteractions = mDirtyInteractions.getEntries();
for(PxU32 i = 0; i < dirtyItcCount; i++)
{
Interaction* refInt = dirtyInteractions[i];
Interaction* interaction = refInt;
if(interaction->isElementInteraction() && interaction->needsRefiltering())
{
ElementSimInteraction* pair = static_cast<ElementSimInteraction*>(interaction);
refInt = refilterInteraction(pair, NULL, false, outputs);
}
if(interaction == refInt) // Refiltering might convert the pair to another type and kill the old one. In that case we don't want to update the new pair since it has been updated on creation.
{
const InteractionType::Enum iType = interaction->getType();
if (iType == InteractionType::eOVERLAP)
static_cast<ShapeInteraction*>(interaction)->updateState(0);
else if (iType == InteractionType::eCONSTRAINTSHADER)
static_cast<ConstraintInteraction*>(interaction)->updateState();
interaction->setClean(false); // false because the dirty interactions list gets cleard further below
}
}
mDirtyInteractions.clear();
}
void NPhaseCore::releaseElementPair(ElementSimInteraction* pair, PxU32 flags, ElementSim* removedElement, PxU32 ccdPass, bool removeFromDirtyList, PxsContactManagerOutputIterator& outputs)
{
pair->setClean(removeFromDirtyList); // Removes the pair from the dirty interaction list etc.
if(pair->readInteractionFlag(InteractionFlag::eIS_FILTER_PAIR))
{
// Check if this is a filter callback pair
ShapeSimBase& s0 = static_cast<ShapeSimBase&>(pair->getElement0());
ShapeSimBase& s1 = static_cast<ShapeSimBase&>(pair->getElement1());
callPairLost(s0, s1, removedElement != NULL);
}
switch(pair->getType())
{
case InteractionType::eTRIGGER:
{
PxsTransformCache& transformCache = mOwnerScene.getLowLevelContext()->getTransformCache();
TriggerInteraction* tri = static_cast<TriggerInteraction*>(pair);
PxTriggerPair triggerPair;
TriggerPairExtraData triggerPairExtra;
if (findTriggerContacts(tri, true, (removedElement != NULL),
triggerPair, triggerPairExtra,
const_cast<SimStats::TriggerPairCountsNonVolatile&>(mOwnerScene.getStatsInternal().numTriggerPairs),
transformCache))
// cast away volatile-ness (this is fine since the method does not run in parallel)
{
mOwnerScene.getTriggerBufferAPI().pushBack(triggerPair);
mOwnerScene.getTriggerBufferExtraData().pushBack(triggerPairExtra);
}
mTriggerInteractionPool.destroy(tri);
}
break;
case InteractionType::eMARKER:
{
ElementInteractionMarker* interactionMarker = static_cast<ElementInteractionMarker*>(pair);
mInteractionMarkerPool.destroy(interactionMarker);
}
break;
case InteractionType::eOVERLAP:
{
ShapeInteraction* si = static_cast<ShapeInteraction*>(pair);
if(flags & PairReleaseFlag::eRUN_LOST_TOUCH_LOGIC)
lostTouchReports(si, flags, removedElement, ccdPass, outputs);
mShapeInteractionPool.destroy(si);
}
break;
case InteractionType::eCONSTRAINTSHADER:
case InteractionType::eARTICULATION:
case InteractionType::eTRACKED_IN_SCENE_COUNT:
case InteractionType::eINVALID:
PX_ASSERT(0);
return;
}
}
void NPhaseCore::lostTouchReports(ShapeInteraction* si, PxU32 flags, ElementSim* removedElement, PxU32 ccdPass, PxsContactManagerOutputIterator& outputs)
{
if(si->hasTouch())
{
if(si->isReportPair())
si->sendLostTouchReport((removedElement != NULL), ccdPass, outputs);
si->adjustCountersOnLostTouch();
}
ActorPair* aPair = si->getActorPair();
if(aPair && aPair->decRefCount() == 0)
{
RigidSim* sim0 = static_cast<RigidSim*>(&si->getActorSim0());
RigidSim* sim1 = static_cast<RigidSim*>(&si->getActorSim1());
if(sim0->getActorID() > sim1->getActorID())
PxSwap(sim0, sim1);
const BodyPairKey pair(sim0->getActorID(), sim1->getActorID());
mActorPairMap.erase(pair);
if(!aPair->isReportPair())
{
mActorPairPool.destroy(aPair);
}
else
{
ActorPairReport& apr = ActorPairReport::cast(*aPair);
destroyActorPairReport(apr);
}
}
si->clearActorPair();
if(si->hasTouch() || (!si->hasKnownTouchState()))
{
ActorSim& b0 = si->getShape0().getActor();
ActorSim& b1 = si->getShape1().getActor();
if(flags & PairReleaseFlag::eWAKE_ON_LOST_TOUCH)
{
// we rely on shape pair ordering here, where the first body is never static
// (see createShapeInteraction())
PX_ASSERT(!b0.isStaticRigid());
if (removedElement == NULL)
{
if (b1.isStaticRigid()) // no check for b0 being static, see assert further above
{
// given wake-on-lost-touch has been requested:
// if one is static, we wake up the other immediately
b0.internalWakeUp();
}
else if(!si->readFlag(ShapeInteraction::CONTACTS_RESPONSE_DISABLED))
{
mOwnerScene.addToLostTouchList(b0, b1);
}
}
else
{
// given wake-on-lost-touch has been requested:
// if an element (broadphase volume) has been removed, we wake the other actor up
PX_ASSERT((removedElement == &si->getShape0()) || (removedElement == &si->getShape1()));
if (&si->getShape0() == removedElement)
{
if (!b1.isStaticRigid())
b1.internalWakeUp();
}
else
b0.internalWakeUp(); // no check for b0 being non-static, see assert further above
}
}
}
}
void NPhaseCore::clearContactReportActorPairs(bool shrinkToZero)
{
for(PxU32 i=0; i < mContactReportActorPairSet.size(); i++)
{
//TODO: prefetch?
ActorPairReport* aPair = mContactReportActorPairSet[i];
const PxU32 refCount = aPair->getRefCount();
PX_ASSERT(aPair->isInContactReportActorPairSet());
PX_ASSERT(refCount > 0);
aPair->decRefCount(); // Reference held by contact callback
if(refCount > 1)
{
aPair->clearInContactReportActorPairSet();
}
else
{
const PxU32 actorAID = aPair->getActorAID();
const PxU32 actorBID = aPair->getActorBID();
const BodyPairKey pair(PxMin(actorAID, actorBID), PxMax(actorAID, actorBID));
mActorPairMap.erase(pair);
destroyActorPairReport(*aPair);
}
}
if(!shrinkToZero)
mContactReportActorPairSet.clear();
else
mContactReportActorPairSet.reset();
}
void NPhaseCore::addToPersistentContactEventPairs(ShapeInteraction* si)
{
// Pairs which request events which do not get triggered by the sdk and thus need to be tested actively every frame.
PX_ASSERT(si->getPairFlags() & (PxPairFlag::eNOTIFY_TOUCH_PERSISTS | ShapeInteraction::CONTACT_FORCE_THRESHOLD_PAIRS));
PX_ASSERT(si->mReportPairIndex == INVALID_REPORT_PAIR_ID);
PX_ASSERT(!si->readFlag(ShapeInteraction::IS_IN_PERSISTENT_EVENT_LIST));
PX_ASSERT(!si->readFlag(ShapeInteraction::IS_IN_FORCE_THRESHOLD_EVENT_LIST));
PX_ASSERT(si->hasTouch()); // only pairs which can from now on lose or keep contact should be in this list
si->raiseFlag(ShapeInteraction::IS_IN_PERSISTENT_EVENT_LIST);
if(mPersistentContactEventPairList.size() == mNextFramePersistentContactEventPairIndex)
{
si->mReportPairIndex = mPersistentContactEventPairList.size();
mPersistentContactEventPairList.pushBack(si);
}
else
{
//swap with first entry that will be active next frame
ShapeInteraction* firstDelayedSi = mPersistentContactEventPairList[mNextFramePersistentContactEventPairIndex];
firstDelayedSi->mReportPairIndex = mPersistentContactEventPairList.size();
mPersistentContactEventPairList.pushBack(firstDelayedSi);
si->mReportPairIndex = mNextFramePersistentContactEventPairIndex;
mPersistentContactEventPairList[mNextFramePersistentContactEventPairIndex] = si;
}
mNextFramePersistentContactEventPairIndex++;
}
void NPhaseCore::addToPersistentContactEventPairsDelayed(ShapeInteraction* si)
{
// Pairs which request events which do not get triggered by the sdk and thus need to be tested actively every frame.
PX_ASSERT(si->getPairFlags() & (PxPairFlag::eNOTIFY_TOUCH_PERSISTS | ShapeInteraction::CONTACT_FORCE_THRESHOLD_PAIRS));
PX_ASSERT(si->mReportPairIndex == INVALID_REPORT_PAIR_ID);
PX_ASSERT(!si->readFlag(ShapeInteraction::IS_IN_PERSISTENT_EVENT_LIST));
PX_ASSERT(!si->readFlag(ShapeInteraction::IS_IN_FORCE_THRESHOLD_EVENT_LIST));
PX_ASSERT(si->hasTouch()); // only pairs which can from now on lose or keep contact should be in this list
si->raiseFlag(ShapeInteraction::IS_IN_PERSISTENT_EVENT_LIST);
si->mReportPairIndex = mPersistentContactEventPairList.size();
mPersistentContactEventPairList.pushBack(si);
}
void NPhaseCore::removeFromPersistentContactEventPairs(ShapeInteraction* si)
{
PX_ASSERT(si->getPairFlags() & (PxPairFlag::eNOTIFY_TOUCH_PERSISTS | ShapeInteraction::CONTACT_FORCE_THRESHOLD_PAIRS));
PX_ASSERT(si->readFlag(ShapeInteraction::IS_IN_PERSISTENT_EVENT_LIST));
PX_ASSERT(!si->readFlag(ShapeInteraction::IS_IN_FORCE_THRESHOLD_EVENT_LIST));
PX_ASSERT(si->hasTouch()); // only pairs which could lose or keep contact should be in this list
PxU32 index = si->mReportPairIndex;
PX_ASSERT(index != INVALID_REPORT_PAIR_ID);
if(index < mNextFramePersistentContactEventPairIndex)
{
const PxU32 replaceIdx = mNextFramePersistentContactEventPairIndex - 1;
if((mNextFramePersistentContactEventPairIndex < mPersistentContactEventPairList.size()) && (index != replaceIdx))
{
// keep next frame persistent pairs at the back of the list
ShapeInteraction* tmp = mPersistentContactEventPairList[replaceIdx];
mPersistentContactEventPairList[index] = tmp;
tmp->mReportPairIndex = index;
index = replaceIdx;
}
mNextFramePersistentContactEventPairIndex--;
}
si->clearFlag(ShapeInteraction::IS_IN_PERSISTENT_EVENT_LIST);
si->mReportPairIndex = INVALID_REPORT_PAIR_ID;
mPersistentContactEventPairList.replaceWithLast(index);
if(index < mPersistentContactEventPairList.size()) // Only adjust the index if the removed SIP was not at the end of the list
mPersistentContactEventPairList[index]->mReportPairIndex = index;
}
void NPhaseCore::addToForceThresholdContactEventPairs(ShapeInteraction* si)
{
PX_ASSERT(si->getPairFlags() & ShapeInteraction::CONTACT_FORCE_THRESHOLD_PAIRS);
PX_ASSERT(si->mReportPairIndex == INVALID_REPORT_PAIR_ID);
PX_ASSERT(!si->readFlag(ShapeInteraction::IS_IN_PERSISTENT_EVENT_LIST));
PX_ASSERT(!si->readFlag(ShapeInteraction::IS_IN_FORCE_THRESHOLD_EVENT_LIST));
PX_ASSERT(si->hasTouch());
si->raiseFlag(ShapeInteraction::IS_IN_FORCE_THRESHOLD_EVENT_LIST);
si->mReportPairIndex = mForceThresholdContactEventPairList.size();
mForceThresholdContactEventPairList.pushBack(si);
}
void NPhaseCore::removeFromForceThresholdContactEventPairs(ShapeInteraction* si)
{
PX_ASSERT(si->getPairFlags() & ShapeInteraction::CONTACT_FORCE_THRESHOLD_PAIRS);
PX_ASSERT(si->readFlag(ShapeInteraction::IS_IN_FORCE_THRESHOLD_EVENT_LIST));
PX_ASSERT(!si->readFlag(ShapeInteraction::IS_IN_PERSISTENT_EVENT_LIST));
PX_ASSERT(si->hasTouch());
const PxU32 index = si->mReportPairIndex;
PX_ASSERT(index != INVALID_REPORT_PAIR_ID);
si->clearFlag(ShapeInteraction::IS_IN_FORCE_THRESHOLD_EVENT_LIST);
si->mReportPairIndex = INVALID_REPORT_PAIR_ID;
mForceThresholdContactEventPairList.replaceWithLast(index);
if(index < mForceThresholdContactEventPairList.size()) // Only adjust the index if the removed SIP was not at the end of the list
mForceThresholdContactEventPairList[index]->mReportPairIndex = index;
}
PxU8* NPhaseCore::reserveContactReportPairData(PxU32 pairCount, PxU32 extraDataSize, PxU32& bufferIndex,
ContactReportAllocationManager* alloc)
{
extraDataSize = ContactStreamManager::computeExtraDataBlockSize(extraDataSize);
return alloc ? alloc->allocate(extraDataSize + (pairCount * sizeof(ContactShapePair)), bufferIndex) : mContactReportBuffer.allocateNotThreadSafe(extraDataSize + (pairCount * sizeof(ContactShapePair)), bufferIndex);
}
PxU8* NPhaseCore::resizeContactReportPairData(PxU32 pairCount, PxU32 extraDataSize, ContactStreamManager& csm)
{
PX_ASSERT((pairCount > csm.maxPairCount) || (extraDataSize > csm.getMaxExtraDataSize()));
PX_ASSERT((csm.currentPairCount == csm.maxPairCount) || (extraDataSize > csm.getMaxExtraDataSize()));
PX_ASSERT(extraDataSize >= csm.getMaxExtraDataSize()); // we do not support stealing memory from the extra data part when the memory for pair info runs out
PxU32 bufferIndex;
PxPrefetch(mContactReportBuffer.getData(csm.bufferIndex));
extraDataSize = ContactStreamManager::computeExtraDataBlockSize(extraDataSize);
PxU8* stream = mContactReportBuffer.reallocateNotThreadSafe(extraDataSize + (pairCount * sizeof(ContactShapePair)), bufferIndex, 16, csm.bufferIndex);
PxU8* oldStream = mContactReportBuffer.getData(csm.bufferIndex);
if(stream)
{
const PxU32 maxExtraDataSize = csm.getMaxExtraDataSize();
if(csm.bufferIndex != bufferIndex)
{
if(extraDataSize <= maxExtraDataSize)
PxMemCopy(stream, oldStream, maxExtraDataSize + (csm.currentPairCount * sizeof(ContactShapePair)));
else
{
PxMemCopy(stream, oldStream, csm.extraDataSize);
PxMemCopy(stream + extraDataSize, oldStream + maxExtraDataSize, csm.currentPairCount * sizeof(ContactShapePair));
}
csm.bufferIndex = bufferIndex;
}
else if(extraDataSize > maxExtraDataSize)
PxMemMove(stream + extraDataSize, oldStream + maxExtraDataSize, csm.currentPairCount * sizeof(ContactShapePair));
if(pairCount > csm.maxPairCount)
csm.maxPairCount = PxTo16(pairCount);
if(extraDataSize > maxExtraDataSize)
csm.setMaxExtraDataSize(extraDataSize);
}
return stream;
}
ActorPairContactReportData* NPhaseCore::createActorPairContactReportData()
{
PxMutex::ScopedLock lock(mReportAllocLock);
return mActorPairContactReportDataPool.construct();
}
void NPhaseCore::releaseActorPairContactReportData(ActorPairContactReportData* data)
{
mActorPairContactReportDataPool.destroy(data);
}
| 47,491 | C++ | 36.045242 | 215 | 0.753806 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScCCD.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "common/PxProfileZone.h"
#include "ScBodySim.h"
#include "ScShapeSim.h"
#include "ScArticulationSim.h"
#include "ScScene.h"
using namespace physx;
using namespace Sc;
///////////////////////////////////////////////////////////////////////////////
void BodySim::addToSpeculativeCCDMap()
{
if(mNodeIndex.isValid())
{
if(isArticulationLink())
mScene.setSpeculativeCCDArticulationLink(mNodeIndex.index());
else
mScene.setSpeculativeCCDRigidBody(mNodeIndex.index());
}
}
void BodySim::removeFromSpeculativeCCDMap()
{
if(mNodeIndex.isValid())
{
if(isArticulationLink())
mScene.resetSpeculativeCCDArticulationLink(mNodeIndex.index());
else
mScene.resetSpeculativeCCDRigidBody(mNodeIndex.index());
}
}
// PT: TODO: consider using a non-member function for this one
void BodySim::updateContactDistance(PxReal* contactDistance, PxReal dt, const Bp::BoundsArray& boundsArray)
{
const PxsRigidBody& llBody = getLowLevelBody();
const PxRigidBodyFlags flags = llBody.getCore().mFlags;
// PT: TODO: no need to test eENABLE_SPECULATIVE_CCD if we parsed mSpeculativeCCDRigidBodyBitMap initially
if((flags & PxRigidBodyFlag::eENABLE_SPECULATIVE_CCD) && !(llBody.mInternalFlags & PxsRigidBody::eFROZEN))
{
// PT: if both CCD flags are enabled we're in "hybrid mode" and we only use speculative contacts for the angular part
const PxReal linearInflation = (flags & PxRigidBodyFlag::eENABLE_CCD) ? 0.0f : llBody.getLinearVelocity().magnitude() * dt;
const float angVelMagTimesDt = llBody.getAngularVelocity().magnitude() * dt;
PxU32 nbElems = getNbElements();
ElementSim** elems = getElements();
while(nbElems--)
{
ShapeSim* current = static_cast<ShapeSim*>(*elems++);
const PxU32 index = current->getElementID();
const PxBounds3& bounds = boundsArray.getBounds(index);
const PxReal radius = bounds.getExtents().magnitude();
//Heuristic for angular velocity...
const PxReal angularInflation = angVelMagTimesDt * radius;
contactDistance[index] = linearInflation + current->getContactOffset() + angularInflation;
}
}
}
void Sc::ArticulationSim::updateContactDistance(PxReal* contactDistance, PxReal dt, const Bp::BoundsArray& boundsArray)
{
const PxU32 size = mBodies.size();
for(PxU32 i=0; i<size; i++)
mBodies[i]->updateContactDistance(contactDistance, dt, boundsArray);
}
namespace
{
class SpeculativeCCDBaseTask : public Cm::Task
{
PX_NOCOPY(SpeculativeCCDBaseTask)
public:
const Bp::BoundsArray& mBoundsArray;
float* mContactDistances;
const float mDt;
SpeculativeCCDBaseTask(PxU64 contextID, const Bp::BoundsArray& boundsArray, PxReal* contactDistances, PxReal dt) :
Cm::Task (contextID),
mBoundsArray (boundsArray),
mContactDistances (contactDistances),
mDt (dt)
{}
};
class SpeculativeCCDContactDistanceUpdateTask : public SpeculativeCCDBaseTask
{
public:
static const PxU32 MaxBodies = 128;
BodySim* mBodySims[MaxBodies];
PxU32 mNbBodies;
SpeculativeCCDContactDistanceUpdateTask(PxU64 contextID, PxReal* contactDistances, PxReal dt, const Bp::BoundsArray& boundsArray) :
SpeculativeCCDBaseTask (contextID, boundsArray, contactDistances, dt),
mNbBodies (0)
{}
virtual void runInternal()
{
const PxU32 nb = mNbBodies;
for(PxU32 i=0; i<nb; i++)
mBodySims[i]->updateContactDistance(mContactDistances, mDt, mBoundsArray);
}
virtual const char* getName() const { return "SpeculativeCCDContactDistanceUpdateTask"; }
private:
PX_NOCOPY(SpeculativeCCDContactDistanceUpdateTask)
};
class SpeculativeCCDContactDistanceArticulationUpdateTask : public SpeculativeCCDBaseTask
{
public:
ArticulationSim* mArticulation;
SpeculativeCCDContactDistanceArticulationUpdateTask(PxU64 contextID, PxReal* contactDistances, PxReal dt, const Bp::BoundsArray& boundsArray, ArticulationSim* sim) :
SpeculativeCCDBaseTask (contextID, boundsArray, contactDistances, dt),
mArticulation (sim)
{}
virtual void runInternal()
{
mArticulation->updateContactDistance(mContactDistances, mDt, mBoundsArray);
}
virtual const char* getName() const { return "SpeculativeCCDContactDistanceArticulationUpdateTask"; }
private:
PX_NOCOPY(SpeculativeCCDContactDistanceArticulationUpdateTask)
};
}
static SpeculativeCCDContactDistanceUpdateTask* createCCDTask(Cm::FlushPool& pool, PxU64 contextID, PxReal* contactDistances, PxReal dt, const Bp::BoundsArray& boundsArray)
{
return PX_PLACEMENT_NEW(pool.allocate(sizeof(SpeculativeCCDContactDistanceUpdateTask)), SpeculativeCCDContactDistanceUpdateTask)(contextID, contactDistances, dt, boundsArray);
}
void Sc::Scene::updateContactDistances(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Scene.updateContactDistances", mContextId);
Cm::FlushPool& pool = mLLContext->getTaskPool();
IG::IslandSim& islandSim = mSimpleIslandManager->getAccurateIslandSim();
bool hasContactDistanceChanged = mHasContactDistanceChanged;
// PT: TODO: it is quite unfortunate that we cannot shortcut parsing the bitmaps. Consider switching to arrays.
// We remove sleeping bodies from the map but we never shrink it....
// PT: TODO: why do we need to involve the island manager here?
// PT: TODO: why do we do that on sleeping bodies? Why don't we use mActiveBodies?
// PxArray<BodyCore*> mActiveBodies; // Sorted: kinematic before dynamic
// ===> because we remove bodies from the bitmap in BodySim::deactivate()
//calculate contact distance for speculative CCD shapes
if(1)
{
PxBitMap::Iterator speculativeCCDIter(mSpeculativeCCDRigidBodyBitMap);
SpeculativeCCDContactDistanceUpdateTask* ccdTask = createCCDTask(pool, mContextId, mContactDistance->begin(), mDt, *mBoundsArray);
PxBitMapPinned& changedMap = mAABBManager->getChangedAABBMgActorHandleMap();
const size_t bodyOffset = PX_OFFSET_OF_RT(BodySim, getLowLevelBody());
//printf("\n");
//PxU32 count = 0;
PxU32 nbBodies = 0;
PxU32 index;
while((index = speculativeCCDIter.getNext()) != PxBitMap::Iterator::DONE)
{
PxsRigidBody* rigidBody = islandSim.getRigidBody(PxNodeIndex(index));
BodySim* bodySim = reinterpret_cast<BodySim*>(reinterpret_cast<PxU8*>(rigidBody)-bodyOffset);
if(bodySim)
{
//printf("%d\n", bodySim->getActiveListIndex());
//printf("%d: %d\n", count++, bodySim->isActive());
hasContactDistanceChanged = true;
ccdTask->mBodySims[nbBodies++] = bodySim;
// PT: ### changedMap pattern #1
// PT: TODO: isn't there a problem here? The task function will only touch the shapes whose body has the
// speculative flag and isn't frozen, but here we mark all shapes as changed no matter what.
//
// Also we test some bodySim data and one bit of each ShapeSim here, not great.
PxU32 nbElems = bodySim->getNbElements();
ElementSim** elems = bodySim->getElements();
while(nbElems--)
{
ShapeSim* sim = static_cast<ShapeSim*>(*elems++);
if(sim->getFlags() & PxShapeFlag::eSIMULATION_SHAPE)
changedMap.growAndSet(sim->getElementID());
}
// PT: TODO: better load balancing?
if(nbBodies == SpeculativeCCDContactDistanceUpdateTask::MaxBodies)
{
ccdTask->mNbBodies = nbBodies;
nbBodies = 0;
startTask(ccdTask, continuation);
if(continuation)
ccdTask = createCCDTask(pool, mContextId, mContactDistance->begin(), mDt, *mBoundsArray);
else
ccdTask->mNbBodies = 0; // PT: no need to create a new task in single-threaded mode
}
}
}
if(nbBodies)
{
ccdTask->mNbBodies = nbBodies;
startTask(ccdTask, continuation);
}
}
/* else
{
// PT: codepath without mSpeculativeCCDRigidBodyBitMap
PxU32 nb = mActiveBodies.size();
BodyCore** bodies = mActiveBodies.begin();
while(nb--)
{
const BodyCore* current = *bodies++;
BodySim* bodySim = current->getSim();
if(bodySim)
{
...
}
}
}*/
//calculate contact distance for articulation links
{
PxBitMap::Iterator articulateCCDIter(mSpeculativeCDDArticulationBitMap);
PxU32 index;
while((index = articulateCCDIter.getNext()) != PxBitMap::Iterator::DONE)
{
ArticulationSim* articulationSim = islandSim.getArticulationSim(PxNodeIndex(index));
if(articulationSim)
{
hasContactDistanceChanged = true;
if(continuation)
{
SpeculativeCCDContactDistanceArticulationUpdateTask* articulationUpdateTask = PX_PLACEMENT_NEW(pool.allocate(sizeof(SpeculativeCCDContactDistanceArticulationUpdateTask)), SpeculativeCCDContactDistanceArticulationUpdateTask)(mContextId, mContactDistance->begin(), mDt, *mBoundsArray, articulationSim);
articulationUpdateTask->setContinuation(continuation);
articulationUpdateTask->removeReference();
}
else
{
articulationSim->updateContactDistance(mContactDistance->begin(), mDt, *mBoundsArray);
}
}
}
}
mHasContactDistanceChanged = hasContactDistanceChanged;
}
///////////////////////////////////////////////////////////////////////////////
#include "ScNPhaseCore.h"
#include "ScShapeInteraction.h"
#include "PxsCCD.h"
#include "PxsSimulationController.h"
#include "CmTransformUtils.h"
void Sc::Scene::setCCDContactModifyCallback(PxCCDContactModifyCallback* callback)
{
mCCDContext->setCCDContactModifyCallback(callback);
}
PxCCDContactModifyCallback* Sc::Scene::getCCDContactModifyCallback() const
{
return mCCDContext->getCCDContactModifyCallback();
}
void Sc::Scene::setCCDMaxPasses(PxU32 ccdMaxPasses)
{
mCCDContext->setCCDMaxPasses(ccdMaxPasses);
}
PxU32 Sc::Scene::getCCDMaxPasses() const
{
return mCCDContext->getCCDMaxPasses();
}
void Sc::Scene::setCCDThreshold(PxReal t)
{
mCCDContext->setCCDThreshold(t);
}
PxReal Sc::Scene::getCCDThreshold() const
{
return mCCDContext->getCCDThreshold();
}
void Sc::Scene::collectPostSolverVelocitiesBeforeCCD()
{
if(mContactReportsNeedPostSolverVelocity)
{
ActorPairReport*const* actorPairs = mNPhaseCore->getContactReportActorPairs();
PxU32 nbActorPairs = mNPhaseCore->getNbContactReportActorPairs();
for(PxU32 i=0; i < nbActorPairs; i++)
{
if(i < (nbActorPairs - 1))
PxPrefetchLine(actorPairs[i+1]);
ActorPairReport* aPair = actorPairs[i];
ContactStreamManager& cs = aPair->getContactStreamManager();
PxU32 streamManagerFlag = cs.getFlags();
if(streamManagerFlag & ContactStreamManagerFlag::eINVALID_STREAM)
continue;
PxU8* stream = mNPhaseCore->getContactReportPairData(cs.bufferIndex);
if(i + 1 < nbActorPairs)
PxPrefetch(&(actorPairs[i+1]->getContactStreamManager()));
if(!cs.extraDataSize)
continue;
else if (streamManagerFlag & ContactStreamManagerFlag::eNEEDS_POST_SOLVER_VELOCITY)
cs.setContactReportPostSolverVelocity(stream, aPair->getActorA(), aPair->getActorB());
}
}
}
void Sc::Scene::updateCCDMultiPass(PxBaseTask* parentContinuation)
{
getCcdBodies().forceSize_Unsafe(mSimulationControllerCallback->getNbCcdBodies());
// second run of the broadphase for making sure objects we have integrated did not tunnel.
if(mPublicFlags & PxSceneFlag::eENABLE_CCD)
{
if(mContactReportsNeedPostSolverVelocity)
{
// the CCD code will overwrite the post solver body velocities, hence, we need to extract the info
// first if any CCD enabled pair requested it.
collectPostSolverVelocitiesBeforeCCD();
}
//We use 2 CCD task chains to be able to chain together an arbitrary number of ccd passes
if(mPostCCDPass.size() != 2)
{
mPostCCDPass.clear();
mUpdateCCDSinglePass.clear();
mCCDBroadPhase.clear();
mCCDBroadPhaseAABB.clear();
mPostCCDPass.reserve(2);
mUpdateCCDSinglePass.reserve(2);
mUpdateCCDSinglePass2.reserve(2);
mUpdateCCDSinglePass3.reserve(2);
mCCDBroadPhase.reserve(2);
mCCDBroadPhaseAABB.reserve(2);
for (int j = 0; j < 2; j++)
{
mPostCCDPass.pushBack(Cm::DelegateTask<Sc::Scene, &Sc::Scene::postCCDPass>(mContextId, this, "ScScene.postCCDPass"));
mUpdateCCDSinglePass.pushBack(Cm::DelegateTask<Sc::Scene, &Sc::Scene::updateCCDSinglePass>(mContextId, this, "ScScene.updateCCDSinglePass"));
mUpdateCCDSinglePass2.pushBack(Cm::DelegateTask<Sc::Scene, &Sc::Scene::updateCCDSinglePassStage2>(mContextId, this, "ScScene.updateCCDSinglePassStage2"));
mUpdateCCDSinglePass3.pushBack(Cm::DelegateTask<Sc::Scene, &Sc::Scene::updateCCDSinglePassStage3>(mContextId, this, "ScScene.updateCCDSinglePassStage3"));
mCCDBroadPhase.pushBack(Cm::DelegateTask<Sc::Scene, &Sc::Scene::ccdBroadPhase>(mContextId, this, "ScScene.ccdBroadPhase"));
mCCDBroadPhaseAABB.pushBack(Cm::DelegateTask<Sc::Scene, &Sc::Scene::ccdBroadPhaseAABB>(mContextId, this, "ScScene.ccdBroadPhaseAABB"));
}
}
//reset thread context in a place we know all tasks possibly accessing it, are in sync with. (see US6664)
mLLContext->resetThreadContexts();
mCCDContext->updateCCDBegin();
mCCDBroadPhase[0].setContinuation(parentContinuation);
mCCDBroadPhaseAABB[0].setContinuation(&mCCDBroadPhase[0]);
mCCDBroadPhase[0].removeReference();
mCCDBroadPhaseAABB[0].removeReference();
}
}
namespace
{
class UpdateCCDBoundsTask : public Cm::Task
{
Bp::BoundsArray* mBoundArray;
PxsTransformCache* mTransformCache;
BodySim** mBodySims;
PxU32 mNbToProcess;
PxI32* mNumFastMovingShapes;
public:
static const PxU32 MaxPerTask = 256;
UpdateCCDBoundsTask(PxU64 contextID, Bp::BoundsArray* boundsArray, PxsTransformCache* transformCache, BodySim** bodySims, PxU32 nbToProcess, PxI32* numFastMovingShapes) :
Cm::Task (contextID),
mBoundArray (boundsArray),
mTransformCache (transformCache),
mBodySims (bodySims),
mNbToProcess (nbToProcess),
mNumFastMovingShapes(numFastMovingShapes)
{
}
virtual const char* getName() const { return "UpdateCCDBoundsTask";}
PxIntBool updateSweptBounds(ShapeSim* sim, BodySim* body)
{
PX_ASSERT(body==sim->getBodySim());
const PxU32 elementID = sim->getElementID();
const ShapeCore& shapeCore = sim->getCore();
const PxTransform& endPose = mTransformCache->getTransformCache(elementID).transform;
const PxGeometry& shapeGeom = shapeCore.getGeometry();
const PxsRigidBody& rigidBody = body->getLowLevelBody();
const PxsBodyCore& bodyCore = body->getBodyCore().getCore();
PX_ALIGN(16, PxTransform shape2World);
Cm::getDynamicGlobalPoseAligned(rigidBody.mLastTransform, shapeCore.getShape2Actor(), bodyCore.getBody2Actor(), shape2World);
const float ccdThreshold = computeCCDThreshold(shapeGeom);
PxBounds3 bounds = Gu::computeBounds(shapeGeom, endPose);
PxIntBool isFastMoving;
if(1)
{
// PT: this alternative implementation avoids computing the start bounds for slow moving objects.
isFastMoving = (shape2World.p - endPose.p).magnitudeSquared() >= ccdThreshold * ccdThreshold ? 1 : 0;
if(isFastMoving)
{
const PxBounds3 startBounds = Gu::computeBounds(shapeGeom, shape2World);
bounds.include(startBounds);
}
}
else
{
const PxBounds3 startBounds = Gu::computeBounds(shapeGeom, shape2World);
isFastMoving = (startBounds.getCenter() - bounds.getCenter()).magnitudeSquared() >= ccdThreshold * ccdThreshold ? 1 : 0;
if(isFastMoving)
bounds.include(startBounds);
}
PX_ASSERT(bounds.minimum.x <= bounds.maximum.x
&& bounds.minimum.y <= bounds.maximum.y
&& bounds.minimum.z <= bounds.maximum.z);
mBoundArray->setBounds(bounds, elementID);
return isFastMoving;
}
virtual void runInternal()
{
PxU32 activeShapes = 0;
const PxU32 nb = mNbToProcess;
for(PxU32 i=0; i<nb; i++)
{
PxU32 isFastMoving = 0;
BodySim& bodySim = *mBodySims[i];
PxU32 nbElems = bodySim.getNbElements();
ElementSim** elems = bodySim.getElements();
while(nbElems--)
{
ShapeSim* sim = static_cast<ShapeSim*>(*elems++);
if(sim->getFlags() & PxU32(PxShapeFlag::eSIMULATION_SHAPE | PxShapeFlag::eTRIGGER_SHAPE))
{
const PxIntBool fastMovingShape = updateSweptBounds(sim, &bodySim);
activeShapes += fastMovingShape;
isFastMoving = isFastMoving | fastMovingShape;
}
}
bodySim.getLowLevelBody().getCore().isFastMoving = isFastMoving!=0;
}
PxAtomicAdd(mNumFastMovingShapes, PxI32(activeShapes));
}
};
}
void Sc::Scene::ccdBroadPhaseAABB(PxBaseTask* continuation)
{
PX_PROFILE_START_CROSSTHREAD("Sim.ccdBroadPhaseComplete", mContextId);
PX_PROFILE_ZONE("Sim.ccdBroadPhaseAABB", mContextId);
PX_UNUSED(continuation);
PxU32 currentPass = mCCDContext->getCurrentCCDPass();
Cm::FlushPool& flushPool = mLLContext->getTaskPool();
mNumFastMovingShapes = 0;
//If we are on the 1st pass or we had some sweep hits previous CCD pass, we need to run CCD again
if(currentPass == 0 || mCCDContext->getNumSweepHits())
{
PxsTransformCache& transformCache = getLowLevelContext()->getTransformCache();
for(PxU32 i = 0; i < mCcdBodies.size(); i+= UpdateCCDBoundsTask::MaxPerTask)
{
const PxU32 nbToProcess = PxMin(UpdateCCDBoundsTask::MaxPerTask, mCcdBodies.size() - i);
UpdateCCDBoundsTask* task = PX_PLACEMENT_NEW(flushPool.allocate(sizeof(UpdateCCDBoundsTask)), UpdateCCDBoundsTask)(mContextId, mBoundsArray, &transformCache, &mCcdBodies[i], nbToProcess, &mNumFastMovingShapes);
task->setContinuation(continuation);
task->removeReference();
}
}
}
void Sc::Scene::ccdBroadPhase(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Sim.ccdBroadPhase", mContextId);
PxU32 currentPass = mCCDContext->getCurrentCCDPass();
const PxU32 ccdMaxPasses = mCCDContext->getCCDMaxPasses();
mCCDPass = currentPass+1;
//If we are on the 1st pass or we had some sweep hits previous CCD pass, we need to run CCD again
if( (currentPass == 0 || mCCDContext->getNumSweepHits()) && mNumFastMovingShapes != 0)
{
const PxU32 currIndex = currentPass & 1;
const PxU32 nextIndex = 1 - currIndex;
//Initialize the CCD task chain unless this is the final pass
if(currentPass != (ccdMaxPasses - 1))
{
mCCDBroadPhase[nextIndex].setContinuation(continuation);
mCCDBroadPhaseAABB[nextIndex].setContinuation(&mCCDBroadPhase[nextIndex]);
}
mPostCCDPass[currIndex].setContinuation(currentPass == ccdMaxPasses-1 ? continuation : &mCCDBroadPhaseAABB[nextIndex]);
mUpdateCCDSinglePass3[currIndex].setContinuation(&mPostCCDPass[currIndex]);
mUpdateCCDSinglePass2[currIndex].setContinuation(&mUpdateCCDSinglePass3[currIndex]);
mUpdateCCDSinglePass[currIndex].setContinuation(&mUpdateCCDSinglePass2[currIndex]);
//Do the actual broad phase
PxBaseTask* continuationTask = &mUpdateCCDSinglePass[currIndex];
// const PxU32 numCpuTasks = continuationTask->getTaskManager()->getCpuDispatcher()->getWorkerCount();
mCCDBp = true;
mBpSecondPass.setContinuation(continuationTask);
mBpFirstPass.setContinuation(&mBpSecondPass);
mBpSecondPass.removeReference();
mBpFirstPass.removeReference();
//mAABBManager->updateAABBsAndBP(numCpuTasks, mLLContext->getTaskPool(), &mLLContext->getScratchAllocator(), false, continuationTask, NULL);
//Allow the CCD task chain to continue
mPostCCDPass[currIndex].removeReference();
mUpdateCCDSinglePass3[currIndex].removeReference();
mUpdateCCDSinglePass2[currIndex].removeReference();
mUpdateCCDSinglePass[currIndex].removeReference();
if(currentPass != (ccdMaxPasses - 1))
{
mCCDBroadPhase[nextIndex].removeReference();
mCCDBroadPhaseAABB[nextIndex].removeReference();
}
}
else if (currentPass == 0)
{
PX_PROFILE_STOP_CROSSTHREAD("Sim.ccdBroadPhaseComplete", mContextId);
mCCDContext->resetContactManagers();
}
}
void Sc::Scene::updateCCDSinglePass(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Sim.updateCCDSinglePass", mContextId);
mReportShapePairTimeStamp++; // This will makes sure that new report pairs will get created instead of re-using the existing ones.
mAABBManager->postBroadPhase(NULL, *getFlushPool());
finishBroadPhase(continuation);
const PxU32 currentPass = mCCDContext->getCurrentCCDPass() + 1; // 0 is reserved for discrete collision phase
if(currentPass == 1) // reset the handle map so we only update CCD objects from here on
{
PxBitMapPinned& changedAABBMgrActorHandles = mAABBManager->getChangedAABBMgActorHandleMap();
//changedAABBMgrActorHandles.clear();
for(PxU32 i = 0; i < mCcdBodies.size();i++)
{
// PT: ### changedMap pattern #1
PxU32 nbElems = mCcdBodies[i]->getNbElements();
ElementSim** elems = mCcdBodies[i]->getElements();
while(nbElems--)
{
ShapeSim* sim = static_cast<ShapeSim*>(*elems++);
if(sim->getFlags()&PxU32(PxShapeFlag::eSIMULATION_SHAPE | PxShapeFlag::eTRIGGER_SHAPE)) // TODO: need trigger shape here?
changedAABBMgrActorHandles.growAndSet(sim->getElementID());
}
}
}
}
void Sc::Scene::updateCCDSinglePassStage2(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Sim.updateCCDSinglePassStage2", mContextId);
postBroadPhaseStage2(continuation);
}
void Sc::Scene::updateCCDSinglePassStage3(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Sim.updateCCDSinglePassStage3", mContextId);
mReportShapePairTimeStamp++; // This will makes sure that new report pairs will get created instead of re-using the existing ones.
const PxU32 currentPass = mCCDContext->getCurrentCCDPass() + 1; // 0 is reserved for discrete collision phase
finishBroadPhaseStage2(currentPass);
PX_PROFILE_STOP_CROSSTHREAD("Sim.ccdBroadPhaseComplete", mContextId);
//reset thread context in a place we know all tasks possibly accessing it, are in sync with. (see US6664)
mLLContext->resetThreadContexts();
mCCDContext->updateCCD(mDt, continuation, mSimpleIslandManager->getAccurateIslandSim(), (mPublicFlags & PxSceneFlag::eDISABLE_CCD_RESWEEP), mNumFastMovingShapes);
}
static PX_FORCE_INLINE Sc::ShapeInteraction* getSI(PxvContactManagerTouchEvent& evt)
{
return reinterpret_cast<Sc::ShapeInteraction*>(evt.getCMTouchEventUserData());
}
void Sc::Scene::postCCDPass(PxBaseTask* /*continuation*/)
{
// - Performs sleep check
// - Updates touch flags
PxU32 currentPass = mCCDContext->getCurrentCCDPass();
PX_ASSERT(currentPass > 0); // to make sure changes to the CCD pass counting get noticed. For contact reports, 0 means discrete collision phase.
int newTouchCount, lostTouchCount, ccdTouchCount;
mLLContext->getManagerTouchEventCount(&newTouchCount, &lostTouchCount, &ccdTouchCount);
PX_ALLOCA(newTouches, PxvContactManagerTouchEvent, newTouchCount);
PX_ALLOCA(lostTouches, PxvContactManagerTouchEvent, lostTouchCount);
PX_ALLOCA(ccdTouches, PxvContactManagerTouchEvent, ccdTouchCount);
PxsContactManagerOutputIterator outputs = mLLContext->getNphaseImplementationContext()->getContactManagerOutputs();
// Note: For contact notifications it is important that the new touch pairs get processed before the lost touch pairs.
// This allows to know for sure if a pair of actors lost all touch (see eACTOR_PAIR_LOST_TOUCH).
mLLContext->fillManagerTouchEvents(newTouches, newTouchCount, lostTouches, lostTouchCount, ccdTouches, ccdTouchCount);
for(PxI32 i=0; i<newTouchCount; ++i)
{
ShapeInteraction* si = getSI(newTouches[i]);
PX_ASSERT(si);
mNPhaseCore->managerNewTouch(*si);
si->managerNewTouch(currentPass, true, outputs);
if (!si->readFlag(ShapeInteraction::CONTACTS_RESPONSE_DISABLED))
{
mSimpleIslandManager->setEdgeConnected(si->getEdgeIndex(), IG::Edge::eCONTACT_MANAGER);
}
}
for(PxI32 i=0; i<lostTouchCount; ++i)
{
ShapeInteraction* si = getSI(lostTouches[i]);
PX_ASSERT(si);
if (si->managerLostTouch(currentPass, true, outputs) && !si->readFlag(ShapeInteraction::CONTACTS_RESPONSE_DISABLED))
addToLostTouchList(si->getShape0().getActor(), si->getShape1().getActor());
mSimpleIslandManager->setEdgeDisconnected(si->getEdgeIndex());
}
for(PxI32 i=0; i<ccdTouchCount; ++i)
{
ShapeInteraction* si = getSI(ccdTouches[i]);
PX_ASSERT(si);
si->sendCCDRetouch(currentPass, outputs);
}
checkForceThresholdContactEvents(currentPass);
{
PxBitMapPinned& changedAABBMgrActorHandles = mAABBManager->getChangedAABBMgActorHandleMap();
for (PxU32 i = 0, s = mCcdBodies.size(); i < s; i++)
{
BodySim*const body = mCcdBodies[i];
if(i+8 < s)
PxPrefetch(mCcdBodies[i+8], 512);
PX_ASSERT(body->getBody2World().p.isFinite());
PX_ASSERT(body->getBody2World().q.isFinite());
body->updateCached(&changedAABBMgrActorHandles);
}
ArticulationCore* const* articList = mArticulations.getEntries();
for(PxU32 i=0;i<mArticulations.size();i++)
articList[i]->getSim()->updateCached(&changedAABBMgrActorHandles);
}
}
| 26,008 | C++ | 34.924033 | 305 | 0.747309 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScElementSim.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-2023 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 SC_ELEMENT_SIM_H
#define SC_ELEMENT_SIM_H
#include "PxFiltering.h"
#include "PxvConfig.h"
#include "ScActorSim.h"
#include "ScInteraction.h"
#include "BpAABBManager.h"
#include "ScObjectIDTracker.h"
#include "ScScene.h"
namespace physx
{
namespace Sc
{
class ElementSimInteraction;
// A ElementSim is a part of a ActorSim. It contributes to the activation framework by adding its interactions to the actor.
class ElementSim
{
PX_NOCOPY(ElementSim)
public:
class ElementInteractionIterator
{
public:
PX_FORCE_INLINE ElementInteractionIterator(const ElementSim& e, PxU32 nbInteractions, Interaction** interactions) :
mInteractions(interactions), mInteractionsLast(interactions + nbInteractions), mElement(&e) {}
ElementSimInteraction* getNext();
private:
Interaction** mInteractions;
Interaction** mInteractionsLast;
const ElementSim* mElement;
};
class ElementInteractionReverseIterator
{
public:
PX_FORCE_INLINE ElementInteractionReverseIterator(const ElementSim& e, PxU32 nbInteractions, Interaction** interactions) :
mInteractions(interactions), mInteractionsLast(interactions + nbInteractions), mElement(&e) {}
ElementSimInteraction* getNext();
private:
Interaction** mInteractions;
Interaction** mInteractionsLast;
const ElementSim* mElement;
};
ElementSim(ActorSim& actor);
protected:
~ElementSim();
public:
// Get an iterator to the interactions connected to the element
// PT: this may seem strange at first glance since the "element interactions" appear to use the "actor interactions". The thing that makes this work is hidden
// inside the iterator implementation: it does parse all the actor interactions indeed, but filters out the ones that do not contain "this", i.e. the desired element.
// So this is inefficient (parsing potentially many more interactions than needed, imagine in a large compound) but it works, and the iterator has a point - it isn't
// just the same as parsing the actor's array.
PX_FORCE_INLINE ElementInteractionIterator getElemInteractions() const { return ElementInteractionIterator(*this, mActor.getActorInteractionCount(), mActor.getActorInteractions()); }
PX_FORCE_INLINE ElementInteractionReverseIterator getElemInteractionsReverse() const { return ElementInteractionReverseIterator(*this, mActor.getActorInteractionCount(), mActor.getActorInteractions()); }
PX_FORCE_INLINE ActorSim& getActor() const { return mActor; }
PX_FORCE_INLINE Scene& getScene() const { return mActor.getScene(); }
PX_FORCE_INLINE PxU32 getElementID() const { return mElementID; }
PX_FORCE_INLINE bool isInBroadPhase() const { return mInBroadPhase; }
void addToAABBMgr(PxReal contactDistance, Bp::FilterGroup::Enum group, Bp::ElementType::Enum type);
bool removeFromAABBMgr();
PX_FORCE_INLINE void initID()
{
Scene& scene = getScene();
mElementID = scene.getElementIDPool().createID();
scene.getBoundsArray().initEntry(mElementID);
}
PX_FORCE_INLINE void releaseID()
{
getScene().getElementIDPool().releaseID(mElementID);
}
protected:
ActorSim& mActor;
PxU32 mElementID : 31; // PT: ID provided by Sc::Scene::mElementIDPool
PxU32 mInBroadPhase : 1;
public:
PxU32 mShapeArrayIndex;
};
PX_FORCE_INLINE void setFilterObjectAttributeType(PxFilterObjectAttributes& attr, PxFilterObjectType::Enum type)
{
PX_ASSERT((attr & (PxFilterObjectType::eMAX_TYPE_COUNT-1)) == 0);
attr |= type;
}
} // namespace Sc
}
#endif
| 5,424 | C | 40.730769 | 205 | 0.727692 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScArticulationTendonCore.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScArticulationTendonCore.h"
#include "ScArticulationTendonSim.h"
using namespace physx;
void Sc::ArticulationSpatialTendonCore::setStiffness(const PxReal stiffness)
{
mStiffness = stiffness;
if (mSim)
mSim->setStiffness(stiffness);
}
PxReal Sc::ArticulationSpatialTendonCore::getStiffness() const
{
return mStiffness;
}
void Sc::ArticulationSpatialTendonCore::setDamping(const PxReal damping)
{
mDamping = damping;
if (mSim)
mSim->setDamping(damping);
}
PxReal Sc::ArticulationSpatialTendonCore::getDamping() const
{
return mDamping;
}
void Sc::ArticulationSpatialTendonCore::setLimitStiffness(const PxReal stiffness)
{
mLimitStiffness = stiffness;
if (mSim)
mSim->setLimitStiffness(stiffness);
}
PxReal Sc::ArticulationSpatialTendonCore::getLimitStiffness() const
{
return mLimitStiffness;
}
void Sc::ArticulationSpatialTendonCore::setOffset(const PxReal offset)
{
mOffset = offset;
if (mSim)
mSim->setOffset(offset);
}
PxReal Sc::ArticulationSpatialTendonCore::getOffset() const
{
return mOffset;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
void Sc::ArticulationFixedTendonCore::setStiffness(const PxReal stiffness)
{
mStiffness = stiffness;
if (mSim)
mSim->setStiffness(stiffness);
}
PxReal Sc::ArticulationFixedTendonCore::getStiffness() const
{
return mStiffness;
}
void Sc::ArticulationFixedTendonCore::setDamping(const PxReal damping)
{
mDamping = damping;
if (mSim)
mSim->setDamping(damping);
}
PxReal Sc::ArticulationFixedTendonCore::getDamping() const
{
return mDamping;
}
void Sc::ArticulationFixedTendonCore::setLimitStiffness(const PxReal stiffness)
{
mLimitStiffness = stiffness;
if (mSim)
mSim->setLimitStiffness(stiffness);
}
PxReal Sc::ArticulationFixedTendonCore::getLimitStiffness() const
{
return mLimitStiffness;
}
void Sc::ArticulationFixedTendonCore::setSpringRestLength(const PxReal restLength)
{
mRestLength = restLength;
if (mSim)
mSim->setSpringRestLength(restLength);
}
PxReal Sc::ArticulationFixedTendonCore::getSpringRestLength() const
{
return mRestLength;
}
void Sc::ArticulationFixedTendonCore::setLimitRange(const PxReal lowLimit, const PxReal highLimit)
{
mLowLimit = lowLimit;
mHighLimit = highLimit;
if (mSim)
mSim->setLimitRange(lowLimit, highLimit);
}
void Sc::ArticulationFixedTendonCore::getLimitRange(PxReal& lowLimit, PxReal& highLimit) const
{
lowLimit = mLowLimit;
highLimit = mHighLimit;
}
void Sc::ArticulationFixedTendonCore::setOffset(const PxReal offset)
{
mOffset = offset;
if (mSim)
mSim->setOffset(offset);
}
PxReal Sc::ArticulationFixedTendonCore::getOffset() const
{
return mOffset;
}
| 4,389 | C++ | 25.768293 | 101 | 0.756209 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScSoftBodySim.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
#include "foundation/PxPreprocessor.h"
#if PX_SUPPORT_GPU_PHYSX
#include "ScSoftBodySim.h"
#include "ScSoftBodyCore.h"
#include "ScScene.h"
#include "PxsSimulationController.h"
using namespace physx;
using namespace physx::Dy;
Sc::SoftBodySim::SoftBodySim(SoftBodyCore& core, Scene& scene) :
ActorSim(scene, core),
mShapeSim(*this)
{
mLLSoftBody = scene.createLLSoftBody(this);
mNodeIndex = scene.getSimpleIslandManager()->addSoftBody(mLLSoftBody, false);
scene.getSimpleIslandManager()->activateNode(mNodeIndex);
mLLSoftBody->setElementId(mShapeSim.getElementID());
}
Sc::SoftBodySim::~SoftBodySim()
{
if (!mLLSoftBody)
return;
mScene.destroyLLSoftBody(*mLLSoftBody);
mScene.getSimpleIslandManager()->removeNode(mNodeIndex);
mCore.setSim(NULL);
}
void Sc::SoftBodySim::updateBounds()
{
mShapeSim.updateBounds();
}
void Sc::SoftBodySim::updateBoundsInAABBMgr()
{
mShapeSim.updateBoundsInAABBMgr();
}
PxBounds3 Sc::SoftBodySim::getBounds() const
{
return mShapeSim.getBounds();
}
bool Sc::SoftBodySim::isSleeping() const
{
IG::IslandSim& sim = mScene.getSimpleIslandManager()->getAccurateIslandSim();
return sim.getActiveNodeIndex(mNodeIndex) == PX_INVALID_NODE;
}
void Sc::SoftBodySim::onSetWakeCounter()
{
getScene().getSimulationController()->setSoftBodyWakeCounter(mLLSoftBody);
if (mLLSoftBody->getCore().wakeCounter > 0.f)
getScene().getSimpleIslandManager()->activateNode(mNodeIndex);
else
getScene().getSimpleIslandManager()->deactivateNode(mNodeIndex);
}
void Sc::SoftBodySim::attachShapeCore(ShapeCore* core)
{
mShapeSim.attachShapeCore(core);
PxsShapeCore* shapeCore = const_cast<PxsShapeCore*>(&core->getCore());
mLLSoftBody->setShapeCore(shapeCore);
}
void Sc::SoftBodySim::attachSimulationMesh(PxTetrahedronMesh* simulationMesh, PxSoftBodyAuxData* simulationState)
{
mLLSoftBody->setSimShapeCore(simulationMesh, simulationState);
}
PxTetrahedronMesh* Sc::SoftBodySim::getSimulationMesh()
{
return mLLSoftBody->getSimulationMesh();
}
PxSoftBodyAuxData* Sc::SoftBodySim::getSoftBodyAuxData()
{
return mLLSoftBody->getSoftBodyAuxData();
}
PxTetrahedronMesh* Sc::SoftBodySim::getCollisionMesh()
{
return mLLSoftBody->getCollisionMesh();
}
void Sc::SoftBodySim::enableSelfCollision()
{
if (isActive())
{
getScene().getSimulationController()->activateSoftbodySelfCollision(mLLSoftBody);
}
}
void Sc::SoftBodySim::disableSelfCollision()
{
if (isActive())
{
getScene().getSimulationController()->deactivateSoftbodySelfCollision(mLLSoftBody);
}
}
/*void Sc::SoftBodySim::activate()
{
// Activate body
//{
// PX_ASSERT((!isKinematic()) || notInScene() || readInternalFlag(InternalFlags(BF_KINEMATIC_MOVED | BF_KINEMATIC_SURFACE_VELOCITY))); // kinematics should only get activated when a target is set.
// // exception: object gets newly added, then the state change will happen later
// if (!isArticulationLink())
// {
// mLLBody.mInternalFlags &= (~PxsRigidBody::eFROZEN);
// // Put in list of activated bodies. The list gets cleared at the end of a sim step after the sleep callbacks have been fired.
// getScene().onBodyWakeUp(this);
// }
// BodyCore& core = getBodyCore();
// if (core.getFlags() & PxRigidBodyFlag::eENABLE_POSE_INTEGRATION_PREVIEW)
// {
// PX_ASSERT(!getScene().isInPosePreviewList(*this));
// getScene().addToPosePreviewList(*this);
// }
// createSqBounds();
//}
activateInteractions(*this);
}
void Sc::SoftBodySim::deactivate()
{
deactivateInteractions(*this);
// Deactivate body
//{
// PX_ASSERT((!isKinematic()) || notInScene() || !readInternalFlag(BF_KINEMATIC_MOVED)); // kinematics should only get deactivated when no target is set.
// // exception: object gets newly added, then the state change will happen later
// BodyCore& core = getBodyCore();
// if (!readInternalFlag(BF_ON_DEATHROW))
// {
// // Set velocity to 0.
// // Note: this is also fine if the method gets called because the user puts something to sleep (this behavior is documented in the API)
// PX_ASSERT(core.getWakeCounter() == 0.0f);
// const PxVec3 zero(0.0f);
// core.setLinearVelocityInternal(zero);
// core.setAngularVelocityInternal(zero);
// setForcesToDefaults(!(mLLBody.mInternalFlags & PxsRigidBody::eDISABLE_GRAVITY));
// }
// if (!isArticulationLink()) // Articulations have their own sleep logic.
// getScene().onBodySleep(this);
// if (core.getFlags() & PxRigidBodyFlag::eENABLE_POSE_INTEGRATION_PREVIEW)
// {
// PX_ASSERT(getScene().isInPosePreviewList(*this));
// getScene().removeFromPosePreviewList(*this);
// }
// destroySqBounds();
//}
}*/
PxU32 Sc::SoftBodySim::getGpuSoftBodyIndex() const
{
return mLLSoftBody->getGpuSoftBodyIndex();
}
#endif //PX_SUPPORT_GPU_PHYSX
| 6,345 | C++ | 30.415841 | 197 | 0.739007 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScArticulationJointCore.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScArticulationJointCore.h"
#include "ScArticulationCore.h"
#include "ScArticulationSim.h"
#include "ScArticulationJointSim.h"
#include "ScBodyCore.h"
#include "ScPhysics.h"
using namespace physx;
Sc::ArticulationJointCore::ArticulationJointCore(const PxTransform& parentFrame, const PxTransform& childFrame) :
mCore (parentFrame, childFrame),
mSim (NULL),
mArticulation (NULL),
mRootType (NULL),
mLLLinkIndex (0xffffffff)
{
}
Sc::ArticulationJointCore::~ArticulationJointCore()
{
PX_ASSERT(getSim() == 0);
}
void Sc::ArticulationJointCore::setSimDirty()
{
Sc::ArticulationJointSim* sim = getSim();
if(sim)
sim->setDirty();
ArticulationSim* artiSim = mArticulation->getSim();
if (artiSim && artiSim->getLLArticulationInitialized())
{
Dy::FeatherstoneArticulation* llarticulation = artiSim->getLowLevelArticulation();
llarticulation->mJcalcDirty = true;
}
}
void Sc::ArticulationJointCore::setParentPose(const PxTransform& t)
{
// AD: we check if it changed at all to avoid marking the complete articulation dirty for a jcalc.
// The jcalc internally checks these ArticulationJointCoreDirtyFlag again so we would skip most things
// but we'd still check all the joints. The same is also true for the following functions.
if (!(mCore.parentPose == t))
{
mCore.parentPose = t;
setDirty(Dy::ArticulationJointCoreDirtyFlag::eFRAME);
}
}
void Sc::ArticulationJointCore::setChildPose(const PxTransform& t)
{
if (!(mCore.childPose == t))
{
mCore.childPose = t;
setDirty(Dy::ArticulationJointCoreDirtyFlag::eFRAME);
}
}
void Sc::ArticulationJointCore::setTargetP(PxArticulationAxis::Enum axis, PxReal targetP)
{
// this sets the target position in the core.
mCore.targetP[axis] = targetP;
// this sets the target position in the ll articulation. This needs to happen immediately because we might
// look up the value using the cache API again, and that one is reading directly from the llArticulation.
ArticulationSim* artiSim = mArticulation->getSim();
if (artiSim && artiSim->getLLArticulationInitialized())
{
Dy::FeatherstoneArticulation* llarticulation = artiSim->getLowLevelArticulation();
Dy::ArticulationData& data = llarticulation->getArticulationData();
Dy::ArticulationJointCoreData* jointData = data.getJointData();
Dy::ArticulationJointCoreData& jointDatum = jointData[mLLLinkIndex];
PxReal* jointTargetPositions = data.getJointTargetPositions();
PxReal* jTargetPosition = &jointTargetPositions[jointDatum.jointOffset];
const PxU32 dofId = mCore.invDofIds[axis];
if (dofId != 0xff)
{
jTargetPosition[dofId] = targetP;
artiSim->setArticulationDirty(Dy::ArticulationDirtyFlag::eDIRTY_JOINT_TARGET_POS);
}
}
// AD: does not need setDirty - we write directly into the llArticulation and the GPU part is
// handled by setArticulationDirty.
}
void Sc::ArticulationJointCore::setTargetV(PxArticulationAxis::Enum axis, PxReal targetV)
{
// this sets the target velocity in the core.
mCore.targetV[axis] = targetV;
// this sets the target velocity in the ll articulation. This needs to happen immediately because we might
// look up the value using the cache API again, and that one is reading directly from the llArticulation.
ArticulationSim* artiSim = mArticulation->getSim();
if (artiSim && artiSim->getLLArticulationInitialized())
{
Dy::FeatherstoneArticulation* llarticulation = artiSim->getLowLevelArticulation();
Dy::ArticulationData& data = llarticulation->getArticulationData();
Dy::ArticulationJointCoreData* jointData = data.getJointData();
Dy::ArticulationJointCoreData& jointDatum = jointData[mLLLinkIndex];
PxReal* jointTargetVelocities = data.getJointTargetVelocities();
PxReal* jTargetVelocity = &jointTargetVelocities[jointDatum.jointOffset];
const PxU32 dofId = mCore.invDofIds[axis];
if (dofId != 0xff)
{
jTargetVelocity[dofId] = targetV;
artiSim->setArticulationDirty(Dy::ArticulationDirtyFlag::eDIRTY_JOINT_TARGET_VEL);
}
}
// AD: does not need setDirty - we write directly into the llArticulation and the GPU part is
// handled by setArticulationDirty.
}
void Sc::ArticulationJointCore::setArmature(PxArticulationAxis::Enum axis, PxReal armature)
{
if (mCore.armature[axis] != armature)
{
mCore.armature[axis] = armature;
setDirty(Dy::ArticulationJointCoreDirtyFlag::eARMATURE);
}
}
void Sc::ArticulationJointCore::setJointPosition(PxArticulationAxis::Enum axis, const PxReal jointPos)
{
// this sets the position in the core.
mCore.jointPos[axis] = jointPos;
// this sets the position in the ll articulation. This needs to happen immediately because we might
// look up the value using the cache API again, and that one is reading directly from the llArticulation.
ArticulationSim* artiSim = mArticulation->getSim();
if (artiSim && artiSim->getLLArticulationInitialized())
{
Dy::FeatherstoneArticulation* llarticulation = artiSim->getLowLevelArticulation();
Dy::ArticulationData& data = llarticulation->getArticulationData();
Dy::ArticulationJointCoreData* jointData = data.getJointData();
Dy::ArticulationJointCoreData& jointDatum = jointData[mLLLinkIndex];
PxReal* jointPositions = data.getJointPositions();
PxReal* jPosition = &jointPositions[jointDatum.jointOffset];
const PxU32 dofId = mCore.invDofIds[axis];
if (dofId != 0xff)
{
jPosition[dofId] = jointPos;
artiSim->setArticulationDirty(Dy::ArticulationDirtyFlag::eDIRTY_POSITIONS);
}
}
}
// AD: we need this indirection right now because we could have updated joint vel using the cache, so
// the read from the joint core might be stale.
PxReal Sc::ArticulationJointCore::getJointPosition(PxArticulationAxis::Enum axis) const
{
PxReal jointPos = mCore.jointPos[axis];
ArticulationSim* artiSim = mArticulation->getSim();
if (artiSim && artiSim->getLLArticulationInitialized())
{
const Dy::FeatherstoneArticulation* llarticulation = artiSim->getLowLevelArticulation();
const Dy::ArticulationData& data = llarticulation->getArticulationData();
const Dy::ArticulationJointCoreData* jointData = data.getJointData();
const Dy::ArticulationJointCoreData& jointDatum = jointData[mLLLinkIndex];
const PxReal* jointPositions = data.getJointPositions();
const PxReal* jPosition = &jointPositions[jointDatum.jointOffset];
const PxU32 dofId = mCore.invDofIds[axis];
if(dofId != 0xff)
jointPos = jPosition[dofId];
}
return jointPos;
}
void Sc::ArticulationJointCore::setJointVelocity(PxArticulationAxis::Enum axis, const PxReal jointVel)
{
mCore.jointVel[axis] = jointVel;
ArticulationSim* artiSim = mArticulation->getSim();
if (artiSim && artiSim->getLLArticulationInitialized())
{
Dy::FeatherstoneArticulation* llarticulation = artiSim->getLowLevelArticulation();
Dy::ArticulationData& data = llarticulation->getArticulationData();
Dy::ArticulationJointCoreData* jointData = data.getJointData();
Dy::ArticulationJointCoreData& jointDatum = jointData[mLLLinkIndex];
PxReal* jointVelocities = data.getJointVelocities();
PxReal* jVelocity = &jointVelocities[jointDatum.jointOffset];
const PxU32 dofId = mCore.invDofIds[axis];
if (dofId != 0xff)
{
jVelocity[dofId] = jointVel;
artiSim->setArticulationDirty(Dy::ArticulationDirtyFlag::eDIRTY_VELOCITIES);
}
}
}
// AD: we need this indirection right now because we could have updated joint vel using the cache, so
// the read from the joint core might be stale.
PxReal Sc::ArticulationJointCore::getJointVelocity(PxArticulationAxis::Enum axis) const
{
PxReal jointVel = mCore.jointVel[axis];
ArticulationSim* artiSim = mArticulation->getSim();
if (artiSim && artiSim->getLLArticulationInitialized())
{
const Dy::FeatherstoneArticulation* llarticulation = artiSim->getLowLevelArticulation();
const Dy::ArticulationData& data = llarticulation->getArticulationData();
const Dy::ArticulationJointCoreData* jointData = data.getJointData();
const Dy::ArticulationJointCoreData& jointDatum = jointData[mLLLinkIndex];
const PxReal* jointVelocities = data.getJointVelocities();
const PxReal* jVelocities = &jointVelocities[jointDatum.jointOffset];
const PxU32 dofId = mCore.invDofIds[axis];
if (dofId != 0xff)
jointVel = jVelocities[dofId];
}
return jointVel;
}
void Sc::ArticulationJointCore::setLimit(PxArticulationAxis::Enum axis, const PxArticulationLimit& limit)
{
mCore.initLimit(axis, limit);
setSimDirty();
}
void Sc::ArticulationJointCore::setDrive(PxArticulationAxis::Enum axis, const PxArticulationDrive& drive)
{
mCore.initDrive(axis, drive);
setSimDirty();
}
| 10,269 | C++ | 35.810036 | 113 | 0.765897 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScArticulationSensorSim.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScArticulationSensorSim.h"
#include "ScArticulationSensor.h"
#include "PxArticulationReducedCoordinate.h"
#include "ScArticulationSim.h"
#include "PxArticulationReducedCoordinate.h"
namespace physx
{
Sc::ArticulationSensorSim::ArticulationSensorSim(ArticulationSensorCore& sensorCore, Scene& scene) :
mScene(scene), mCore(sensorCore),
mLLIndex(0xffffffff)
{
sensorCore.setSim(this);
mLLSensor.mRelativePose = sensorCore.mRelativePose;
mLLSensor.mFlags = sensorCore.mFlags;
}
Sc::ArticulationSensorSim::~ArticulationSensorSim()
{
mCore.setSim(NULL);
}
const PxSpatialForce& Sc::ArticulationSensorSim::getForces() const
{
return mArticulationSim->getSensorForce(mLLIndex);
}
void Sc::ArticulationSensorSim::setRelativePose(const PxTransform& relativePose)
{
mLLSensor.mRelativePose = relativePose;
mArticulationSim->setArticulationDirty(Dy::ArticulationDirtyFlag::eDIRTY_SENSOR);
}
void Sc::ArticulationSensorSim::setFlag(const PxU16 flag)
{
mLLSensor.mFlags = flag;
mArticulationSim->setArticulationDirty(Dy::ArticulationDirtyFlag::eDIRTY_SENSOR);
}
}
| 2,808 | C++ | 36.959459 | 102 | 0.774573 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScArticulationTendonSim.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-2023 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 SC_ARTICULATION_TENDON_SIM_H
#define SC_ARTICULATION_TENDON_SIM_H
#include "foundation/PxUserAllocated.h"
#include "DyArticulationTendon.h"
namespace physx
{
namespace Sc
{
class ArticulationFixedTendonCore;
class ArticulationTendonJointCore;
class ArticulationSpatialTendonCore;
class ArticulationAttachmentCore;
class Scene;
class ArticulationJointCore;
class ArticulationSim;
class ArticulationSpatialTendonSim : public PxUserAllocated
{
PX_NOCOPY(ArticulationSpatialTendonSim)
public:
ArticulationSpatialTendonSim(ArticulationSpatialTendonCore& tendon, Scene& scene);
virtual ~ArticulationSpatialTendonSim();
void setStiffness(const PxReal stiffness);
PxReal getStiffness() const;
void setDamping(const PxReal damping);
PxReal getDamping() const;
void setLimitStiffness(const PxReal stiffness);
PxReal getLimitStiffness() const;
void setOffset(const PxReal offset);
PxReal getOffset() const;
void setAttachmentCoefficient(ArticulationAttachmentCore& core, const PxReal coefficient);
void setAttachmentRelativeOffset(ArticulationAttachmentCore& core, const PxVec3& offset);
void setAttachmentLimits(ArticulationAttachmentCore& core, const PxReal lowLimit, const PxReal highLimit);
void setAttachmentRestLength(ArticulationAttachmentCore& core, const PxReal restLength);
void addAttachment(ArticulationAttachmentCore& core);
void removeAttachment(ArticulationAttachmentCore& core);
Dy::ArticulationSpatialTendon mLLTendon;
ArticulationSpatialTendonCore& mTendonCore;
ArticulationSim* mArtiSim;
Scene& mScene;
};
class ArticulationFixedTendonSim : public PxUserAllocated
{
PX_NOCOPY(ArticulationFixedTendonSim)
public:
ArticulationFixedTendonSim(ArticulationFixedTendonCore& tendon, Scene& scene);
virtual ~ArticulationFixedTendonSim();
void setStiffness(const PxReal stiffness);
PxReal getStiffness() const;
void setDamping(const PxReal damping);
PxReal getDamping() const;
void setLimitStiffness(const PxReal stiffness);
PxReal getLimitStiffness() const;
void setOffset(const PxReal offset);
PxReal getOffset() const;
void setSpringRestLength(const PxReal restLength);
PxReal getSpringRestLength() const;
void setLimitRange(const PxReal lowLimit, const PxReal highLimit);
void getLimitRange(PxReal& lowLimit, PxReal& highLimit) const;
void addTendonJoint(ArticulationTendonJointCore& tendonJointCore);
void removeTendonJoint(ArticulationTendonJointCore& core);
void setTendonJointCoefficient(ArticulationTendonJointCore& core, const PxArticulationAxis::Enum axis, const float coefficient, const float recipCoefficient);
Dy::ArticulationFixedTendon mLLTendon;
ArticulationFixedTendonCore& mTendonCore;
ArticulationSim* mArtiSim;
Scene& mScene;
};
}//namespace Sc
}//namespace physx
#endif
| 4,709 | C | 36.983871 | 166 | 0.763219 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScContactReportBuffer.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-2023 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 SC_CONTACT_REPORT_BUFFER_H
#define SC_CONTACT_REPORT_BUFFER_H
#include "foundation/Px.h"
#include "common/PxProfileZone.h"
namespace physx
{
namespace Sc
{
class ContactReportBuffer
{
public:
PX_FORCE_INLINE ContactReportBuffer(PxU32 initialSize, bool noResizeAllowed)
: mBuffer(NULL)
,mCurrentBufferIndex(0)
,mCurrentBufferSize(initialSize)
,mDefaultBufferSize(initialSize)
,mLastBufferIndex(0)
,mAllocationLocked(noResizeAllowed)
{
mBuffer = allocateBuffer(initialSize);
PX_ASSERT(mBuffer);
}
~ContactReportBuffer()
{
PX_FREE(mBuffer);
}
PX_FORCE_INLINE void reset();
PX_FORCE_INLINE void flush();
PX_FORCE_INLINE PxU8* allocateNotThreadSafe(PxU32 size, PxU32& index, PxU32 alignment= 16);
PX_FORCE_INLINE PxU8* reallocateNotThreadSafe(PxU32 size, PxU32& index, PxU32 alignment= 16, PxU32 lastIndex = 0xFFFFFFFF);
PX_FORCE_INLINE PxU8* getData(const PxU32& index) const { return mBuffer+index; }
PX_FORCE_INLINE PxU32 getDefaultBufferSize() const {return mDefaultBufferSize;}
private:
PX_FORCE_INLINE PxU8* allocateBuffer(PxU32 size);
private:
PxU8* mBuffer;
PxU32 mCurrentBufferIndex;
PxU32 mCurrentBufferSize;
PxU32 mDefaultBufferSize;
PxU32 mLastBufferIndex;
bool mAllocationLocked;
};
} // namespace Sc
//////////////////////////////////////////////////////////////////////////
PX_FORCE_INLINE void Sc::ContactReportBuffer::reset()
{
mCurrentBufferIndex = 0;
mLastBufferIndex = 0xFFFFFFFF;
}
//////////////////////////////////////////////////////////////////////////
void Sc::ContactReportBuffer::flush()
{
mCurrentBufferIndex = 0;
mLastBufferIndex = 0xFFFFFFFF;
if(mCurrentBufferSize != mDefaultBufferSize)
{
PX_FREE(mBuffer);
mBuffer = allocateBuffer(mDefaultBufferSize);
PX_ASSERT(mBuffer);
mCurrentBufferSize = mDefaultBufferSize;
}
}
//////////////////////////////////////////////////////////////////////////
PxU8* Sc::ContactReportBuffer::allocateNotThreadSafe(PxU32 size, PxU32& index ,PxU32 alignment/* =16 */)
{
PX_ASSERT(PxIsPowerOfTwo(alignment));
// padding for alignment
PxU32 pad = ((mCurrentBufferIndex+alignment-1)&~(alignment-1)) - mCurrentBufferIndex;
index = mCurrentBufferIndex + pad;
if (index + size > mCurrentBufferSize)
{
PX_PROFILE_ZONE("ContactReportBuffer::Resize", 0);
if(mAllocationLocked)
return NULL;
PxU32 oldBufferSize = mCurrentBufferSize;
while(index + size > mCurrentBufferSize)
{
mCurrentBufferSize *= 2;
}
PxU8* tempBuffer = allocateBuffer(mCurrentBufferSize);
PxMemCopy(tempBuffer,mBuffer,oldBufferSize);
PX_FREE(mBuffer);
mBuffer = tempBuffer;
}
PxU8* ptr = mBuffer + index;
mLastBufferIndex = index;
PX_ASSERT((size_t(ptr)&(alignment-1)) == 0);
mCurrentBufferIndex += size + pad;
return ptr;
}
//////////////////////////////////////////////////////////////////////////
PxU8* Sc::ContactReportBuffer::reallocateNotThreadSafe(PxU32 size, PxU32& index ,PxU32 alignment/* =16 */, PxU32 lastIndex)
{
if(lastIndex != mLastBufferIndex)
{
return allocateNotThreadSafe(size,index,alignment);
}
else
{
mCurrentBufferIndex = mLastBufferIndex;
return allocateNotThreadSafe(size,index,alignment);
}
}
//////////////////////////////////////////////////////////////////////////
PX_FORCE_INLINE PxU8* Sc::ContactReportBuffer::allocateBuffer(PxU32 size)
{
return (static_cast<PxU8*>(PX_ALLOC(size, "ContactReportBuffer")));
}
} // namespace physx
#endif
| 5,321 | C | 29.586207 | 130 | 0.674685 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScShapeSimBase.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-2023 NVIDIA Corporation. All rights reserved.
#ifndef SC_SHAPESIM_BASE_H
#define SC_SHAPESIM_BASE_H
#include "ScElementSim.h"
#include "ScShapeCore.h"
#include "ScRigidSim.h"
#include "PxsShapeSim.h"
namespace physx
{
namespace Sc
{
PX_FORCE_INLINE PxU32 isBroadPhase(PxShapeFlags flags) { return PxU32(flags) & PxU32(PxShapeFlag::eTRIGGER_SHAPE | PxShapeFlag::eSIMULATION_SHAPE); }
class ShapeCore;
// PT: TODO: ShapeSimBase is bonkers:
// PxU32 ElementSim::mElementID
// PxU32 ElementSim::mShapeArrayIndex;
// IG::NodeIndex mLLShape::mBodySimIndex; *** GPU only
// PxU32 mLLShape::mElementIndex; *** GPU only, looks like a copy of ElementSim::mElementID
// PxU32 mLLShape::mShapeIndex; *** GPU only, looks like a copy of ElementSim::mElementID
// PxU32 ShapeSimBase::mId;
// PxU32 ShapeSimBase::mSqBoundsId;
// => do we really need 7 different IDs per shape?
class ShapeSimBase : public ElementSim
{
PX_NOCOPY(ShapeSimBase)
public:
ShapeSimBase(ActorSim& owner, const ShapeCore* core) :
ElementSim (owner),
mSqBoundsId (PX_INVALID_U32),
mPrunerIndex(PX_INVALID_U32)
{ setCore(core); }
~ShapeSimBase() { }
PX_FORCE_INLINE void setCore(const ShapeCore* core);
PX_FORCE_INLINE const ShapeCore& getCore() const;
PX_FORCE_INLINE bool isPxsCoreValid() const { return mLLShape.mShapeCore != NULL; }
PX_INLINE PxGeometryType::Enum getGeometryType() const { return getCore().getGeometryType(); }
// This is just for getting a reference for the user, so we cast away const-ness
PX_INLINE PxShape* getPxShape() const { return const_cast<PxShape*>(getCore().getPxShape()); }
PX_FORCE_INLINE PxReal getRestOffset() const { return getCore().getRestOffset(); }
PX_FORCE_INLINE PxReal getTorsionalPatchRadius() const { return getCore().getTorsionalPatchRadius(); }
PX_FORCE_INLINE PxReal getMinTorsionalPatchRadius() const { return getCore().getMinTorsionalPatchRadius(); }
PX_FORCE_INLINE PxU32 getFlags() const { return getCore().getFlags(); }
PX_FORCE_INLINE PxReal getContactOffset() const { return getCore().getContactOffset(); }
PX_FORCE_INLINE PxU32 getTransformCacheID() const { return getElementID(); }
PX_FORCE_INLINE PxU32 getSqBoundsId() const { return mSqBoundsId; }
PX_FORCE_INLINE void setSqBoundsId(PxU32 id) { mSqBoundsId = id; }
PX_FORCE_INLINE PxU32 getSqPrunerIndex() const { return mPrunerIndex; }
PX_FORCE_INLINE void setSqPrunerIndex(PxU32 index) { mPrunerIndex = index; }
PX_FORCE_INLINE PxsShapeSim& getLLShapeSim() { return mLLShape; }
void onFilterDataChange();
void onRestOffsetChange();
void onFlagChange(PxShapeFlags oldFlags);
void onResetFiltering();
void onVolumeOrTransformChange();
void onMaterialChange(); // remove when material properties are gone from PxcNpWorkUnit
void onContactOffsetChange();
void markBoundsForUpdate();
void reinsertBroadPhase();
void removeFromBroadPhase(bool wakeOnLostTouch);
void getAbsPoseAligned(PxTransform* PX_RESTRICT globalPose) const;
PX_FORCE_INLINE RigidSim& getRbSim() const { return static_cast<RigidSim&>(getActor()); }
BodySim* getBodySim() const;
PxsRigidCore& getPxsRigidCore() const;
void createSqBounds();
void destroySqBounds();
void updateCached(PxU32 transformCacheFlags, PxBitMapPinned* shapeChangedMap);
void updateCached(PxsTransformCache& transformCache, Bp::BoundsArray& boundsArray);
void updateBPGroup();
protected:
PX_FORCE_INLINE void internalAddToBroadPhase();
PX_FORCE_INLINE bool internalRemoveFromBroadPhase(bool wakeOnLostTouch = true);
void initSubsystemsDependingOnElementID();
PxsShapeSim mLLShape;
PxU32 mSqBoundsId;
PxU32 mPrunerIndex;
};
#if PX_P64_FAMILY
// PT: to compensate for the padding I removed in PxsShapeSim
PX_COMPILE_TIME_ASSERT((sizeof(ShapeSimBase) - sizeof(PxsShapeSim))>=12);
#else
// PX_COMPILE_TIME_ASSERT(32==sizeof(Sc::ShapeSim)); // after removing bounds from shapes
// PX_COMPILE_TIME_ASSERT((sizeof(Sc::ShapeSim) % 16) == 0); // aligned mem bounds are better for prefetching
#endif
PX_FORCE_INLINE void ShapeSimBase::setCore(const ShapeCore* core)
{
mLLShape.mShapeCore = core ? const_cast<PxsShapeCore*>(&core->getCore()) : NULL;
}
PX_FORCE_INLINE const ShapeCore& ShapeSimBase::getCore() const
{
return Sc::ShapeCore::getCore(*mLLShape.mShapeCore);
}
} // namespace Sc
}
#endif
| 6,400 | C | 43.144827 | 151 | 0.69125 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScPipeline.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
// PT: this file contains most Scene functions called during the simulate() call, i.e. the "pipeline" functions.
// Ideally they should be listed in the order in which they are called in the single-threaded version, to help
// understanding and following the pipeline.
#include "ScScene.h"
#include "BpBroadPhase.h"
#include "ScArticulationSim.h"
#include "ScSimStats.h"
#include "PxsCCD.h"
#if defined(__APPLE__) && defined(__POWERPC__)
#include <ppc_intrinsics.h>
#endif
#if PX_SUPPORT_GPU_PHYSX
#include "PxPhysXGpu.h"
#include "PxsKernelWrangler.h"
#include "PxsHeapMemoryAllocator.h"
#include "cudamanager/PxCudaContextManager.h"
#endif
#include "ScShapeInteraction.h"
#include "ScElementInteractionMarker.h"
#if PX_SUPPORT_GPU_PHYSX
#include "PxSoftBody.h"
#include "ScSoftBodySim.h"
#include "DySoftBody.h"
#if PX_ENABLE_FEATURES_UNDER_CONSTRUCTION
#include "PxFEMCloth.h"
#include "PxHairSystem.h"
#endif
#include "ScFEMClothSim.h"
#include "DyFEMCloth.h"
#include "ScParticleSystemSim.h"
#include "DyParticleSystem.h"
#include "ScHairSystemSim.h"
#include "DyHairSystem.h"
#endif
using namespace physx;
using namespace physx::Cm;
using namespace physx::Dy;
using namespace Sc;
PX_IMPLEMENT_OUTPUT_ERROR
///////////////////////////////////////////////////////////////////////////////
void PxcClearContactCacheStats();
void Sc::Scene::stepSetupCollide(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Sim.stepSetupCollide", mContextId);
{
PX_PROFILE_ZONE("Sim.prepareCollide", mContextId);
mReportShapePairTimeStamp++; // deleted actors/shapes should get separate pair entries in contact reports
mContactReportsNeedPostSolverVelocity = false;
getRenderBuffer().clear();
// Clear broken constraint list:
clearBrokenConstraintBuffer();
visualizeStartStep();
PxcClearContactCacheStats();
}
kinematicsSetup(continuation);
PxsContactManagerOutputIterator outputs = mLLContext->getNphaseImplementationContext()->getContactManagerOutputs();
// Update all dirty interactions
mNPhaseCore->updateDirtyInteractions(outputs);
mInternalFlags &= ~(SceneInternalFlag::eSCENE_SIP_STATES_DIRTY_DOMINANCE | SceneInternalFlag::eSCENE_SIP_STATES_DIRTY_VISUALIZATION);
}
void Sc::Scene::simulate(PxReal timeStep, PxBaseTask* continuation)
{
if(timeStep != 0.0f)
{
setElapsedTime(timeStep);
mDynamicsContext->setDt(timeStep);
mAdvanceStep.setContinuation(continuation);
stepSetupCollide(&mAdvanceStep);
mCollideStep.setContinuation(&mAdvanceStep);
mAdvanceStep.removeReference();
mCollideStep.removeReference();
}
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::collideStep(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Sim.collideQueueTasks", mContextId);
PX_PROFILE_START_CROSSTHREAD("Basic.collision", mContextId);
mStats->simStart();
mLLContext->beginUpdate();
mPostNarrowPhase.setTaskManager(*continuation->getTaskManager());
mPostNarrowPhase.addReference();
mFinalizationPhase.setTaskManager(*continuation->getTaskManager());
mFinalizationPhase.addReference();
mRigidBodyNarrowPhase.setContinuation(continuation);
mPreRigidBodyNarrowPhase.setContinuation(&mRigidBodyNarrowPhase);
mUpdateShapes.setContinuation(&mPreRigidBodyNarrowPhase);
mRigidBodyNarrowPhase.removeReference();
mPreRigidBodyNarrowPhase.removeReference();
mUpdateShapes.removeReference();
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::updateShapes(PxBaseTask* continuation)
{
//dma shapes data to gpu
mSimulationController->updateShapes(continuation);
}
///////////////////////////////////////////////////////////////////////////////
namespace
{
class DirtyShapeUpdatesTask : public Cm::Task
{
public:
static const PxU32 MaxShapes = 256;
PxsTransformCache& mCache;
Bp::BoundsArray& mBoundsArray;
ShapeSim* mShapes[MaxShapes];
PxU32 mNbShapes;
DirtyShapeUpdatesTask(PxU64 contextID, PxsTransformCache& cache, Bp::BoundsArray& boundsArray) :
Cm::Task (contextID),
mCache (cache),
mBoundsArray(boundsArray),
mNbShapes (0)
{
}
virtual void runInternal()
{
for (PxU32 a = 0; a < mNbShapes; ++a)
mShapes[a]->updateCached(mCache, mBoundsArray);
}
virtual const char* getName() const { return "DirtyShapeUpdatesTask"; }
private:
PX_NOCOPY(DirtyShapeUpdatesTask)
};
}
static DirtyShapeUpdatesTask* createDirtyShapeUpdateTask(Cm::FlushPool& pool, PxU64 contextID, PxsTransformCache& cache, Bp::BoundsArray& boundsArray)
{
return PX_PLACEMENT_NEW(pool.allocate(sizeof(DirtyShapeUpdatesTask)), DirtyShapeUpdatesTask)(contextID, cache, boundsArray);
}
void Sc::Scene::updateDirtyShapes(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Scene.updateDirtyShapes", mContextId);
// PT: it is quite unfortunate that we cannot shortcut parsing the bitmaps. We should consider switching to arrays.
//Process dirty shapeSims...
PxBitMap::Iterator dirtyShapeIter(mDirtyShapeSimMap);
PxsTransformCache& cache = mLLContext->getTransformCache();
Bp::BoundsArray& boundsArray = mAABBManager->getBoundsArray();
Cm::FlushPool& pool = mLLContext->getTaskPool();
PxBitMapPinned& changedMap = mAABBManager->getChangedAABBMgActorHandleMap();
DirtyShapeUpdatesTask* task = createDirtyShapeUpdateTask(pool, mContextId, cache, boundsArray);
// PT: TASK-CREATION TAG
bool hasDirtyShapes = false;
PxU32 nbDirtyShapes = 0;
PxU32 index;
while((index = dirtyShapeIter.getNext()) != PxBitMap::Iterator::DONE)
{
ShapeSim* shapeSim = reinterpret_cast<ShapeSim*>(mAABBManager->getUserData(index));
if(shapeSim)
{
hasDirtyShapes = true;
changedMap.growAndSet(index);
task->mShapes[nbDirtyShapes++] = shapeSim;
// PT: consider better load balancing?
if(nbDirtyShapes == DirtyShapeUpdatesTask::MaxShapes)
{
task->mNbShapes = nbDirtyShapes;
nbDirtyShapes = 0;
startTask(task, continuation);
task = createDirtyShapeUpdateTask(pool, mContextId, cache, boundsArray);
}
}
}
if(hasDirtyShapes)
{
//Setting the boundsArray and transform cache as dirty so that they get DMAd to GPU if GPU dynamics and BP are being used respectively.
//These bits are no longer set when we update the cached state for actors due to an optimization avoiding setting these dirty bits multiple times.
getBoundsArray().setChangedState();
getLowLevelContext()->getTransformCache().setChangedState();
}
if(nbDirtyShapes)
{
task->mNbShapes = nbDirtyShapes;
startTask(task, continuation);
}
// PT: we clear the map but we don't shrink it, bad because we always parse it above
mDirtyShapeSimMap.clear();
}
void Sc::Scene::preRigidBodyNarrowPhase(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Scene.preNarrowPhase", mContextId);
updateContactDistances(continuation);
updateDirtyShapes(continuation);
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::rigidBodyNarrowPhase(PxBaseTask* continuation)
{
PX_PROFILE_START_CROSSTHREAD("Basic.narrowPhase", mContextId);
mCCDPass = 0;
mPostBroadPhase3.addDependent(*continuation);
mPostBroadPhase2.setContinuation(&mPostBroadPhase3);
mPostBroadPhaseCont.setContinuation(&mPostBroadPhase2);
mPostBroadPhase.setContinuation(&mPostBroadPhaseCont);
mBroadPhase.setContinuation(&mPostBroadPhase);
mRigidBodyNPhaseUnlock.setContinuation(continuation);
mRigidBodyNPhaseUnlock.addReference();
mUpdateBoundAndShapeTask.addDependent(mBroadPhase);
mLLContext->resetThreadContexts();
mLLContext->updateContactManager(mDt, mHasContactDistanceChanged, continuation,
&mRigidBodyNPhaseUnlock, &mUpdateBoundAndShapeTask); // Starts update of contact managers
mPostBroadPhase3.removeReference();
mPostBroadPhase2.removeReference();
mPostBroadPhaseCont.removeReference();
mPostBroadPhase.removeReference();
mBroadPhase.removeReference();
mUpdateBoundAndShapeTask.removeReference();
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::updateBoundsAndShapes(PxBaseTask* /*continuation*/)
{
//if the scene doesn't use gpu dynamic and gpu broad phase and the user enables the direct API,
//the sdk will refuse to create the scene.
mSimulationController->updateBoundsAndShapes(*mAABBManager, isDirectGPUAPIInitialized());
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::broadPhase(PxBaseTask* continuation)
{
PX_PROFILE_START_CROSSTHREAD("Basic.broadPhase", mContextId);
/*mProcessLostPatchesTask.setContinuation(&mPostNarrowPhase);
mProcessLostPatchesTask.removeReference();*/
#if PX_SUPPORT_GPU_PHYSX
gpu_updateBounds();
#endif
mCCDBp = false;
mBpSecondPass.setContinuation(continuation);
mBpFirstPass.setContinuation(&mBpSecondPass);
mBpSecondPass.removeReference();
mBpFirstPass.removeReference();
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::processFoundSolverPatches(PxBaseTask* /*continuation*/)
{
PxvNphaseImplementationContext* nphase = mLLContext->getNphaseImplementationContext();
mDynamicsContext->processFoundPatches(*mSimpleIslandManager, nphase->getFoundPatchManagers(), nphase->getNbFoundPatchManagers(), nphase->getFoundPatchOutputCounts());
}
void Sc::Scene::processLostSolverPatches(PxBaseTask* /*continuation*/)
{
PxvNphaseImplementationContext* nphase = mLLContext->getNphaseImplementationContext();
mDynamicsContext->processLostPatches(*mSimpleIslandManager, nphase->getFoundPatchManagers(), nphase->getNbFoundPatchManagers(), nphase->getFoundPatchOutputCounts());
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::broadPhaseFirstPass(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Basic.broadPhaseFirstPass", mContextId);
const PxU32 numCpuTasks = continuation->getTaskManager()->getCpuDispatcher()->getWorkerCount();
mAABBManager->updateBPFirstPass(numCpuTasks, mLLContext->getTaskPool(), mHasContactDistanceChanged, continuation);
// AD: we already update the aggregate bounds above, but because we just update all the aggregates all the time,
// this should be fine here. The important thing is that we don't mix normal and aggregate bounds in the normal BP.
if (isDirectGPUAPIInitialized())
{
mSimulationController->mergeChangedAABBMgHandle();
}
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::broadPhaseSecondPass(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Basic.broadPhaseSecondPass", mContextId);
mBpUpdate.setContinuation(continuation);
mPreIntegrate.setContinuation(&mBpUpdate);
mPreIntegrate.removeReference();
mBpUpdate.removeReference();
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::preIntegrate(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Basic.preIntegrate", mContextId);
if (!mCCDBp && isUsingGpuDynamicsOrBp())
mSimulationController->preIntegrateAndUpdateBound(continuation, mGravity, mDt);
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::updateBroadPhase(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Basic.updateBroadPhase", mContextId);
PxBaseTask* rigidBodyNPhaseUnlock = mCCDPass ? NULL : &mRigidBodyNPhaseUnlock;
mAABBManager->updateBPSecondPass(&mLLContext->getScratchAllocator(), continuation);
// PT: decoupling: I moved this back from updateBPSecondPass
//if this is mCCDPass, narrowPhaseUnlockTask will be NULL
if(rigidBodyNPhaseUnlock)
rigidBodyNPhaseUnlock->removeReference();
if(!mCCDBp && isUsingGpuDynamicsOrBp())
mSimulationController->updateParticleSystemsAndSoftBodies();
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::unblockNarrowPhase(PxBaseTask*)
{
/*if (!mCCDBp && mUseGpuRigidBodies)
mSimulationController->updateParticleSystemsAndSoftBodies();*/
//
mLLContext->getNphaseImplementationContext()->startNarrowPhaseTasks();
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::postBroadPhase(PxBaseTask* continuation)
{
PX_PROFILE_START_CROSSTHREAD("Basic.postBroadPhase", mContextId);
//Notify narrow phase that broad phase has completed
mLLContext->getNphaseImplementationContext()->postBroadPhaseUpdateContactManager(continuation);
mAABBManager->postBroadPhase(continuation, *getFlushPool());
}
///////////////////////////////////////////////////////////////////////////////
class OverlapFilterTask : public Cm::Task
{
public:
static const PxU32 MaxPairs = 512;
NPhaseCore* mNPhaseCore;
const Bp::AABBOverlap* mPairs;
PxU32 mNbToProcess;
PxU32 mKeepMap[MaxPairs/32];
FilterInfo* mFinfo;
PxU32 mNbToKeep;
PxU32 mNbToSuppress;
OverlapFilterTask* mNext;
OverlapFilterTask(PxU64 contextID, NPhaseCore* nPhaseCore, FilterInfo* fInfo, const Bp::AABBOverlap* pairs, PxU32 nbToProcess) :
Cm::Task (contextID),
mNPhaseCore (nPhaseCore),
mPairs (pairs),
mNbToProcess (nbToProcess),
mFinfo (fInfo),
mNbToKeep (0),
mNbToSuppress (0),
mNext (NULL)
{
PxMemZero(mKeepMap, sizeof(mKeepMap));
}
virtual void runInternal()
{
mNPhaseCore->runOverlapFilters( mNbToProcess, mPairs, mFinfo, mNbToKeep, mNbToSuppress, mKeepMap);
}
virtual const char* getName() const { return "OverlapFilterTask"; }
};
void Sc::Scene::finishBroadPhase(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Sc::Scene::finishBroadPhase", mContextId);
{
PX_PROFILE_ZONE("Sim.processNewOverlaps", mContextId);
// PT: we process "trigger pairs" immediately, sequentially. Both the filtering and the creation of trigger
// interactions happen at the same time in onTriggerOverlapCreated.
// PT: could we drop trigger interactions or parallelize this? I am not sure why Kier decided to treat trigger
// interactions differently here, in my eyes it is pretty much the same as regular interactions, and they
// could have been kept in the same multithreaded pipeline. Regular shape interactions also call "registerInActors"
// by default, so the below comment is not very convincing - we worked around this for ShapeInteraction, we
// could have worked around this as well for TriggerInteraction.
{
//KS - these functions call "registerInActors", while OverlapFilterTask reads the list of interactions
//in an actor. This could lead to a race condition and a crash if they occur at the same time, so we
//serialize these operations
PX_PROFILE_ZONE("Sim.processNewOverlaps.createOverlapsNoShapeInteractions", mContextId);
{
PxU32 createdOverlapCount;
const Bp::AABBOverlap* PX_RESTRICT p = mAABBManager->getCreatedOverlaps(Bp::ElementType::eTRIGGER, createdOverlapCount);
if(createdOverlapCount)
{
mLLContext->getSimStats().mNbNewPairs += createdOverlapCount;
mNPhaseCore->onTriggerOverlapCreated(p, createdOverlapCount);
}
}
}
// PT: for regular shapes the code has been multithreaded and split into different parts, making it harder to follow.
// Basically this is the same code as the above for triggers, but scattered over multiple Sc::Scene functions and
// tasks. As far as I can tell the steps are:
// - "first stage" filtering (right here below)
// - "second stage" filtering and creation of ShapeInteractions in preallocateContactManagers
// - some cleanup in postBroadPhaseStage2
{
PxU32 createdOverlapCount;
const Bp::AABBOverlap* PX_RESTRICT p = mAABBManager->getCreatedOverlaps(Bp::ElementType::eSHAPE, createdOverlapCount);
// PT: removed this because it's pointless at this stage?
if(0)
{
//We allocate at least 1 element in this array to ensure that the onOverlapCreated functions don't go bang!
mPreallocatedContactManagers.reserve(1);
mPreallocatedShapeInteractions.reserve(1);
mPreallocatedInteractionMarkers.reserve(1);
mPreallocatedContactManagers.forceSize_Unsafe(1);
mPreallocatedShapeInteractions.forceSize_Unsafe(1);
mPreallocatedInteractionMarkers.forceSize_Unsafe(1);
}
mPreallocateContactManagers.setContinuation(continuation);
// PT: this is a temporary member value used to pass the OverlapFilterTasks to the next stage of the pipeline (preallocateContactManagers).
// It ideally shouldn't be a class member but just a user-data passed from one task to the next. The task manager doesn't support that though (AFAIK),
// so instead it just lies there in Sc::Scene as a class member. It's only used in finishBroadPhase & preallocateContactManagers though.
mOverlapFilterTaskHead = NULL;
if(createdOverlapCount)
{
mLLContext->getSimStats().mNbNewPairs += createdOverlapCount;
Cm::FlushPool& flushPool = mLLContext->getTaskPool();
// PT: temporary data, similar to mOverlapFilterTaskHead. Will be filled with filter info for each pair by the OverlapFilterTask.
mFilterInfo.forceSize_Unsafe(0);
mFilterInfo.reserve(createdOverlapCount);
mFilterInfo.forceSize_Unsafe(createdOverlapCount);
// PT: TASK-CREATION TAG
const PxU32 nbPairsPerTask = OverlapFilterTask::MaxPairs;
OverlapFilterTask* previousTask = NULL;
for(PxU32 a=0; a<createdOverlapCount; a+=nbPairsPerTask)
{
const PxU32 nbToProcess = PxMin(createdOverlapCount - a, nbPairsPerTask);
OverlapFilterTask* task = PX_PLACEMENT_NEW(flushPool.allocate(sizeof(OverlapFilterTask)), OverlapFilterTask)(mContextId, mNPhaseCore, mFilterInfo.begin() + a, p + a, nbToProcess);
task->setContinuation(&mPreallocateContactManagers);
task->removeReference();
// PT: setup a linked-list of OverlapFilterTasks, will be parsed in preallocateContactManagers
if(previousTask)
previousTask->mNext = task;
else
mOverlapFilterTaskHead = task;
previousTask = task;
}
}
}
mPreallocateContactManagers.removeReference();
}
}
void Sc::Scene::postBroadPhaseContinuation(PxBaseTask* continuation)
{
mAABBManager->getChangedAABBMgActorHandleMap().clear();
// - Finishes broadphase update
// - Adds new interactions (and thereby contact managers if needed)
finishBroadPhase(continuation);
}
///////////////////////////////////////////////////////////////////////////////
template<class T>
static PX_FORCE_INLINE T* markPointerAsUsed(T* ptr) { return reinterpret_cast<T*>(size_t(ptr) | 1); }
static PX_FORCE_INLINE size_t isPointerMarkedAsUsed(void* ptr) { return size_t(ptr) & 1; }
template<class T>
static PX_FORCE_INLINE T* getUsedPointer(T* ptr)
{
const size_t address = size_t(ptr);
return address & 1 ? reinterpret_cast<T*>(address & size_t(~1)) : NULL;
}
namespace
{
class OnOverlapCreatedTask : public Cm::Task
{
public:
NPhaseCore* mNPhaseCore;
const Bp::AABBOverlap* mPairs;
const FilterInfo* mFinfo;
PxsContactManager** mContactManagers;
ShapeInteraction** mShapeInteractions;
ElementInteractionMarker** mInteractionMarkers;
PxU32 mNbToProcess;
OnOverlapCreatedTask(PxU64 contextID, NPhaseCore* nPhaseCore, const Bp::AABBOverlap* pairs, const FilterInfo* fInfo, PxsContactManager** contactManagers,
ShapeInteraction** shapeInteractions, ElementInteractionMarker** interactionMarkers, PxU32 nbToProcess) :
Cm::Task (contextID),
mNPhaseCore (nPhaseCore),
mPairs (pairs),
mFinfo (fInfo),
mContactManagers (contactManagers),
mShapeInteractions (shapeInteractions),
mInteractionMarkers (interactionMarkers),
mNbToProcess (nbToProcess)
{
}
virtual void runInternal()
{
PxsContactManager** currentCm = mContactManagers;
ShapeInteraction** currentSI = mShapeInteractions;
ElementInteractionMarker** currentEI = mInteractionMarkers;
for(PxU32 i=0; i<mNbToProcess; i++)
{
const Bp::AABBOverlap& pair = mPairs[i];
ShapeSimBase* s0 = reinterpret_cast<ShapeSimBase*>(pair.mUserData1);
ShapeSimBase* s1 = reinterpret_cast<ShapeSimBase*>(pair.mUserData0);
ElementSimInteraction* interaction = mNPhaseCore->createRbElementInteraction(mFinfo[i], *s0, *s1, *currentCm, *currentSI, *currentEI, false);
if(interaction)
{
const InteractionType::Enum type = interaction->getType();
if(type == InteractionType::eOVERLAP)
{
PX_ASSERT(interaction==*currentSI);
*currentSI = markPointerAsUsed(*currentSI);
currentSI++;
if(static_cast<ShapeInteraction*>(interaction)->getContactManager())
{
PX_ASSERT(static_cast<ShapeInteraction*>(interaction)->getContactManager()==*currentCm);
*currentCm = markPointerAsUsed(*currentCm);
currentCm++;
}
}
else if(type == InteractionType::eMARKER)
{
*currentEI = markPointerAsUsed(*currentEI);
currentEI++;
}
}
}
}
virtual const char* getName() const { return "OnOverlapCreatedTask"; }
};
}
void Sc::Scene::preallocateContactManagers(PxBaseTask* continuation)
{
//Iterate over all filter tasks and work out how many pairs we need...
PxU32 totalCreatedPairs = 0;
PxU32 totalSuppressPairs = 0;
OverlapFilterTask* task = mOverlapFilterTaskHead;
while(task)
{
totalCreatedPairs += task->mNbToKeep;
totalSuppressPairs += task->mNbToSuppress;
task = task->mNext;
}
{
//We allocate at least 1 element in this array to ensure that the onOverlapCreated functions don't go bang!
// PT: this has to do with the way we dereference currentCm, currentSI and currentEI in OnOverlapCreatedTask
// before we know which type of interaction will be created. That is, we need room for at least one of each type
// even if no interaction of that type will be created.
// PT: don't we preallocate 2 to 3 times as much memory as needed here then?
// PT: also doesn't it mean we're going to allocate & deallocate ALL the interaction markers most of the time?
mPreallocatedContactManagers.forceSize_Unsafe(0);
mPreallocatedShapeInteractions.forceSize_Unsafe(0);
mPreallocatedInteractionMarkers.forceSize_Unsafe(0);
mPreallocatedContactManagers.reserve(totalCreatedPairs+1);
mPreallocatedShapeInteractions.reserve(totalCreatedPairs+1);
mPreallocatedInteractionMarkers.reserve(totalSuppressPairs+1);
mPreallocatedContactManagers.forceSize_Unsafe(totalCreatedPairs);
mPreallocatedShapeInteractions.forceSize_Unsafe(totalCreatedPairs);
mPreallocatedInteractionMarkers.forceSize_Unsafe(totalSuppressPairs);
}
PxU32 overlapCount;
Bp::AABBOverlap* PX_RESTRICT p = mAABBManager->getCreatedOverlaps(Bp::ElementType::eSHAPE, overlapCount);
if(!overlapCount)
return;
struct Local
{
static void processBatch(const PxU32 createdCurrIdx, PxU32& createdStartIdx, const PxU32 suppressedCurrIdx, PxU32& suppressedStartIdx, const PxU32 batchSize,
PxsContext* const context, NPhaseCore* const core, OnOverlapCreatedTask* const createTask, PxBaseTask* const continuation_,
PxsContactManager** const cms_, ShapeInteraction** const shapeInter_, ElementInteractionMarker** const markerIter_)
{
const PxU32 nbToCreate = createdCurrIdx - createdStartIdx;
const PxU32 nbToSuppress = suppressedCurrIdx - suppressedStartIdx;
context->getContactManagerPool().preallocate(nbToCreate, cms_ + createdStartIdx);
for (PxU32 i = 0; i < nbToCreate; ++i)
shapeInter_[createdStartIdx + i] = core->mShapeInteractionPool.allocate();
for (PxU32 i = 0; i < nbToSuppress; ++i)
markerIter_[suppressedStartIdx + i] = core->mInteractionMarkerPool.allocate();
createdStartIdx = createdCurrIdx;
suppressedStartIdx = suppressedCurrIdx;
createTask->mNbToProcess = batchSize;
startTask(createTask, continuation_);
}
};
const PxU32 nbPairsPerTask = 256;
PxsContactManager** cms = mPreallocatedContactManagers.begin();
ShapeInteraction** shapeInter = mPreallocatedShapeInteractions.begin();
ElementInteractionMarker** markerIter = mPreallocatedInteractionMarkers.begin();
Cm::FlushPool& flushPool = mLLContext->getTaskPool();
FilterInfo* fInfo = mFilterInfo.begin();
// PT: TODO: why do we create the task immediately? Why not create it only when a batch is full?
// PT: it's the same pattern as for CCD, kinematics, etc
OnOverlapCreatedTask* createTask = PX_PLACEMENT_NEW(flushPool.allocate(sizeof(OnOverlapCreatedTask)), OnOverlapCreatedTask)(mContextId, mNPhaseCore, p, fInfo, cms, shapeInter, markerIter, 0);
PxU32 batchSize = 0;
PxU32 suppressedStartIdx = 0;
PxU32 createdStartIdx = 0;
PxU32 suppressedCurrIdx = 0;
PxU32 createdCurrIdx = 0;
PxU32 currentReadIdx = 0;
PxU32 createdOverlapCount = 0;
// PT: TASK-CREATION TAG
task = mOverlapFilterTaskHead;
while(task)
{
if(task->mNbToKeep || task->mNbToSuppress)
{
for(PxU32 w = 0; w < (OverlapFilterTask::MaxPairs/32); ++w)
{
for(PxU32 b = task->mKeepMap[w]; b; b &= b-1)
{
const PxU32 index = (w<<5) + PxLowestSetBit(b);
if(createdOverlapCount < (index + currentReadIdx))
{
p[createdOverlapCount] = task->mPairs[index];
fInfo[createdOverlapCount] = task->mFinfo[index];
}
createdOverlapCount++;
batchSize++;
}
}
suppressedCurrIdx += task->mNbToSuppress;
createdCurrIdx += task->mNbToKeep;
if(batchSize >= nbPairsPerTask)
{
Local::processBatch(createdCurrIdx, createdStartIdx, suppressedCurrIdx, suppressedStartIdx, batchSize, mLLContext, mNPhaseCore, createTask, continuation, cms, shapeInter, markerIter);
createTask = PX_PLACEMENT_NEW(flushPool.allocate(sizeof(OnOverlapCreatedTask)), OnOverlapCreatedTask)(mContextId, mNPhaseCore, p + createdOverlapCount,
fInfo + createdOverlapCount, cms + createdStartIdx, shapeInter + createdStartIdx, markerIter + suppressedStartIdx, 0);
batchSize = 0;
}
}
currentReadIdx += OverlapFilterTask::MaxPairs;
task = task->mNext;
}
if(batchSize)
Local::processBatch(createdCurrIdx, createdStartIdx, suppressedCurrIdx, suppressedStartIdx, batchSize, mLLContext, mNPhaseCore, createTask, continuation, cms, shapeInter, markerIter);
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::processLostTouchPairs()
{
PX_PROFILE_ZONE("Sc::Scene::processLostTouchPairs", mContextId);
const PxU32 nb = mLostTouchPairs.size();
const SimpleBodyPair* pairs = mLostTouchPairs.begin();
for(PxU32 i=0; i<nb; ++i)
{
ActorSim* body1 = pairs[i].body1;
ActorSim* body2 = pairs[i].body2;
// If one has been deleted, we wake the other one
const PxIntBool deletedBody1 = mLostTouchPairsDeletedBodyIDs.boundedTest(pairs[i].body1ID);
const PxIntBool deletedBody2 = mLostTouchPairsDeletedBodyIDs.boundedTest(pairs[i].body2ID);
if(deletedBody1 || deletedBody2)
{
if(!deletedBody1)
body1->internalWakeUp();
if(!deletedBody2)
body2->internalWakeUp();
continue;
}
const bool b1Active = body1->isActive();
const bool b2Active = body2->isActive();
// If both are sleeping, we let them sleep
// (for example, two sleeping objects touch and the user teleports one (without waking it up))
if(!b1Active && !b2Active)
continue;
// If only one has fallen asleep, we wake them both
if(!b1Active || !b2Active)
{
body1->internalWakeUp();
body2->internalWakeUp();
}
}
mLostTouchPairs.clear();
mLostTouchPairsDeletedBodyIDs.clear();
}
void Sc::Scene::postBroadPhaseStage2(PxBaseTask* continuation)
{
// - Wakes actors that lost touch if appropriate
processLostTouchPairs();
mIslandInsertion.setContinuation(continuation);
mRegisterContactManagers.setContinuation(continuation);
mRegisterInteractions.setContinuation(continuation);
mRegisterSceneInteractions.setContinuation(continuation);
mIslandInsertion.removeReference();
mRegisterContactManagers.removeReference();
mRegisterInteractions.removeReference();
mRegisterSceneInteractions.removeReference();
//Release unused Cms back to the pool (later, this needs to be done in a thread-safe way from multiple worker threads
{
PX_PROFILE_ZONE("Sim.processNewOverlaps.release", mContextId);
{
PxU32 nb = mPreallocatedContactManagers.size();
PxsContactManager** managers = mPreallocatedContactManagers.begin();
Cm::PoolList<PxsContactManager, PxsContext>& pool = mLLContext->getContactManagerPool();
while(nb--)
{
PxsContactManager* current = *managers++;
if(!isPointerMarkedAsUsed(current))
pool.put(current);
}
}
{
PxU32 nb = mPreallocatedShapeInteractions.size();
ShapeInteraction** interactions = mPreallocatedShapeInteractions.begin();
PxPool<ShapeInteraction>& pool = mNPhaseCore->mShapeInteractionPool;
while(nb--)
{
ShapeInteraction* current = *interactions++;
if(!isPointerMarkedAsUsed(current))
pool.deallocate(current);
}
}
{
PxU32 nb = mPreallocatedInteractionMarkers.size();
ElementInteractionMarker** interactions = mPreallocatedInteractionMarkers.begin();
PxPool<ElementInteractionMarker>& pool = mNPhaseCore->mInteractionMarkerPool;
while(nb--)
{
ElementInteractionMarker* current = *interactions++;
if(!isPointerMarkedAsUsed(current))
pool.deallocate(current);
}
}
}
}
///////////////////////////////////////////////////////////////////////////////
// PT: islandInsertion / registerContactManagers / registerInteractions / registerSceneInteractions run in parallel
void Sc::Scene::islandInsertion(PxBaseTask* /*continuation*/)
{
PX_PROFILE_ZONE("Sim.processNewOverlaps.islandInsertion", mContextId);
const PxU32 nbShapeIdxCreated = mPreallocatedShapeInteractions.size();
for(PxU32 a = 0; a < nbShapeIdxCreated; ++a)
{
ShapeInteraction* interaction = getUsedPointer(mPreallocatedShapeInteractions[a]);
if(interaction)
{
PxsContactManager* contactManager = const_cast<PxsContactManager*>(interaction->getContactManager());
const ActorSim& bs0 = interaction->getShape0().getActor();
const ActorSim& bs1 = interaction->getShape1().getActor();
const PxActorType::Enum actorTypeLargest = PxMax(bs0.getActorType(), bs1.getActorType());
PxNodeIndex nodeIndexB;
if (!bs1.isStaticRigid())
nodeIndexB = bs1.getNodeIndex();
IG::Edge::EdgeType type = IG::Edge::eCONTACT_MANAGER;
#if PX_SUPPORT_GPU_PHYSX
if(actorTypeLargest == PxActorType::eSOFTBODY)
type = IG::Edge::eSOFT_BODY_CONTACT;
else if (actorTypeLargest == PxActorType::eFEMCLOTH)
type = IG::Edge::eFEM_CLOTH_CONTACT;
else if(isParticleSystem(actorTypeLargest))
type = IG::Edge::ePARTICLE_SYSTEM_CONTACT;
else if (actorTypeLargest == PxActorType::eHAIRSYSTEM)
type = IG::Edge::eHAIR_SYSTEM_CONTACT;
#endif
IG::EdgeIndex edgeIdx = mSimpleIslandManager->addContactManager(contactManager, bs0.getNodeIndex(), nodeIndexB, interaction, type);
interaction->mEdgeIndex = edgeIdx;
if(contactManager)
contactManager->getWorkUnit().mEdgeIndex = edgeIdx;
//If it is a soft body or particle overlap, treat it as a contact for now (we can hook up touch found/lost events later maybe)
if(actorTypeLargest > PxActorType::eARTICULATION_LINK)
mSimpleIslandManager->setEdgeConnected(edgeIdx, type);
}
}
// - Wakes actors that lost touch if appropriate
//processLostTouchPairs();
if(mCCDPass == 0)
mSimpleIslandManager->firstPassIslandGen();
}
///////////////////////////////////////////////////////////////////////////////
// PT: islandInsertion / registerContactManagers / registerInteractions / registerSceneInteractions run in parallel
void Sc::Scene::registerContactManagers(PxBaseTask* /*continuation*/)
{
PX_PROFILE_ZONE("Sim.processNewOverlaps.registerCms", mContextId);
// PT: we sometimes iterate over this array in vain (all ptrs are unused). Would be better
// to store used pointers maybe in the overlap created tasks, and reuse these tasks here to
// process only used pointers.
PxvNphaseImplementationContext* nphaseContext = mLLContext->getNphaseImplementationContext();
nphaseContext->lock();
//nphaseContext->registerContactManagers(mPreallocatedContactManagers.begin(), mPreallocatedContactManagers.size(), mLLContext->getContactManagerPool().getMaxUsedIndex());
const PxU32 nbCmsCreated = mPreallocatedContactManagers.size();
for(PxU32 a = 0; a < nbCmsCreated; ++a)
{
PxsContactManager* cm = getUsedPointer(mPreallocatedContactManagers[a]);
if(cm)
{
ShapeInteraction* interaction = getUsedPointer(mPreallocatedShapeInteractions[a]);
nphaseContext->registerContactManager(cm, interaction, 0, 0);
}
}
nphaseContext->unlock();
}
///////////////////////////////////////////////////////////////////////////////
// PT: islandInsertion / registerContactManagers / registerInteractions / registerSceneInteractions run in parallel
void Sc::Scene::registerInteractions(PxBaseTask* /*continuation*/)
{
PX_PROFILE_ZONE("Sim.processNewOverlaps.registerInteractions", mContextId);
const PxU32 nbShapeIdxCreated = mPreallocatedShapeInteractions.size();
for(PxU32 a = 0; a < nbShapeIdxCreated; ++a)
{
ShapeInteraction* interaction = getUsedPointer(mPreallocatedShapeInteractions[a]);
if(interaction)
{
// PT: this is similar to interaction->registerInActors(), which is usually called from
// interaction ctors.
ActorSim& actorSim0 = interaction->getActorSim0();
ActorSim& actorSim1 = interaction->getActorSim1();
actorSim0.registerInteractionInActor(interaction);
actorSim1.registerInteractionInActor(interaction);
// PT: the number of counted interactions is used for the sleeping system
if(actorSim0.isDynamicRigid())
static_cast<BodySim*>(&actorSim0)->registerCountedInteraction();
if(actorSim1.isDynamicRigid())
static_cast<BodySim*>(&actorSim1)->registerCountedInteraction();
}
}
const PxU32 nbMarkersCreated = mPreallocatedInteractionMarkers.size();
for(PxU32 a = 0; a < nbMarkersCreated; ++a)
{
ElementInteractionMarker* interaction = getUsedPointer(mPreallocatedInteractionMarkers[a]);
if(interaction)
{
// PT: no call to "interaction->onActivate()" here because it doesn't do anything
interaction->registerInActors();
}
}
}
///////////////////////////////////////////////////////////////////////////////
// PT: islandInsertion / registerContactManagers / registerInteractions / registerSceneInteractions run in parallel
void Sc::Scene::registerSceneInteractions(PxBaseTask* /*continuation*/)
{
PX_PROFILE_ZONE("Sim.processNewOverlaps.registerInteractionsScene", mContextId);
const PxU32 nbShapeIdxCreated = mPreallocatedShapeInteractions.size();
for(PxU32 a = 0; a < nbShapeIdxCreated; ++a)
{
ShapeInteraction* interaction = getUsedPointer(mPreallocatedShapeInteractions[a]);
if(interaction)
{
registerInteraction(interaction, interaction->getContactManager() != NULL);
const PxsContactManager* cm = interaction->getContactManager();
if(cm)
mLLContext->setActiveContactManager(cm, cm->getCCD());
}
}
const PxU32 nbInteractionMarkers = mPreallocatedInteractionMarkers.size();
for(PxU32 a = 0; a < nbInteractionMarkers; ++a)
{
ElementInteractionMarker* interaction = getUsedPointer(mPreallocatedInteractionMarkers[a]);
if(interaction)
registerInteraction(interaction, false);
}
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::finishBroadPhaseStage2(PxU32 ccdPass)
{
PX_PROFILE_ZONE("Sc::Scene::finishBroadPhase2", mContextId);
Bp::AABBManagerBase* aabbMgr = mAABBManager;
PxU32 nbLostPairs = 0;
for(PxU32 i=0; i<Bp::ElementType::eCOUNT; i++)
{
PxU32 destroyedOverlapCount;
aabbMgr->getDestroyedOverlaps(Bp::ElementType::Enum(i), destroyedOverlapCount);
nbLostPairs += destroyedOverlapCount;
}
mLLContext->getSimStats().mNbLostPairs += nbLostPairs;
// PT: TODO: move this to ccd file?
//KS - we need to defer processing lost overlaps until later!
if (ccdPass)
{
PX_PROFILE_ZONE("Sim.processLostOverlaps", mContextId);
PxsContactManagerOutputIterator outputs = mLLContext->getNphaseImplementationContext()->getContactManagerOutputs();
PxU32 destroyedOverlapCount;
// PT: for regular shapes
{
Bp::AABBOverlap* PX_RESTRICT p = aabbMgr->getDestroyedOverlaps(Bp::ElementType::eSHAPE, destroyedOverlapCount);
while(destroyedOverlapCount--)
{
ElementSim* volume0 = reinterpret_cast<ElementSim*>(p->mUserData0);
ElementSim* volume1 = reinterpret_cast<ElementSim*>(p->mUserData1);
//KS - this is a bit ugly. We split the "onOverlapRemoved" for shape interactions to parallelize it and that means
//that we have to call each of the individual stages of the remove here.
//First, we have to get the interaction pointer...
ElementSimInteraction* interaction = mNPhaseCore->findInteraction(volume0, volume1);
p->mPairUserData = interaction;
if(interaction)
{
if(interaction->getType() == InteractionType::eOVERLAP || interaction->getType() == InteractionType::eMARKER)
{
//If it's a standard "overlap" interaction, we have to send a lost touch report, unregister it, and destroy its manager and island gen data.
if(interaction->getType() == InteractionType::eOVERLAP)
{
ShapeInteraction* si = static_cast<ShapeInteraction*>(interaction);
mNPhaseCore->lostTouchReports(si, PxU32(PairReleaseFlag::eWAKE_ON_LOST_TOUCH), NULL, 0, outputs);
//We must check to see if we have a contact manager here. There is an edge case where actors could be put to
//sleep after discrete simulation, prior to CCD, causing their contactManager() to be destroyed. If their bounds
//also ceased overlapping, then this code will try to destroy the manager again.
if(si->getContactManager())
si->destroyManager();
si->clearIslandGenData();
}
unregisterInteraction(interaction);
}
//Then call "onOverlapRemoved" to actually free the interaction
mNPhaseCore->onOverlapRemoved(volume0, volume1, ccdPass, interaction, outputs);
}
p++;
}
}
// PT: for triggers
{
Bp::AABBOverlap* PX_RESTRICT p = aabbMgr->getDestroyedOverlaps(Bp::ElementType::eTRIGGER, destroyedOverlapCount);
while(destroyedOverlapCount--)
{
ElementSim* volume0 = reinterpret_cast<ElementSim*>(p->mUserData0);
ElementSim* volume1 = reinterpret_cast<ElementSim*>(p->mUserData1);
p->mPairUserData = NULL;
//KS - this is a bit ugly.
mNPhaseCore->onOverlapRemoved(volume0, volume1, ccdPass, NULL, outputs);
p++;
}
}
}
// - Wakes actors that lost touch if appropriate
processLostTouchPairs();
if (ccdPass)
aabbMgr->freeBuffers();
}
void Sc::Scene::postBroadPhaseStage3(PxBaseTask* /*continuation*/)
{
finishBroadPhaseStage2(0);
PX_PROFILE_STOP_CROSSTHREAD("Basic.postBroadPhase", mContextId);
PX_PROFILE_STOP_CROSSTHREAD("Basic.broadPhase", mContextId);
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::advanceStep(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Sim.solveQueueTasks", mContextId);
if(mDt != 0.0f)
{
mFinalizationPhase.addDependent(*continuation);
mFinalizationPhase.removeReference();
if(mPublicFlags & PxSceneFlag::eENABLE_CCD)
{
mUpdateCCDMultiPass.setContinuation(&mFinalizationPhase);
mAfterIntegration.setContinuation(&mUpdateCCDMultiPass);
mUpdateCCDMultiPass.removeReference();
}
else
{
mAfterIntegration.setContinuation(&mFinalizationPhase);
}
mPostSolver.setContinuation(&mAfterIntegration);
mUpdateSimulationController.setContinuation(&mPostSolver);
mUpdateDynamics.setContinuation(&mUpdateSimulationController);
mUpdateBodies.setContinuation(&mUpdateDynamics);
mSolver.setContinuation(&mUpdateBodies);
mPostIslandGen.setContinuation(&mSolver);
mIslandGen.setContinuation(&mPostIslandGen);
mPostNarrowPhase.addDependent(mIslandGen);
mPostNarrowPhase.removeReference();
mSecondPassNarrowPhase.setContinuation(&mPostNarrowPhase);
mFinalizationPhase.removeReference();
mAfterIntegration.removeReference();
mPostSolver.removeReference();
mUpdateSimulationController.removeReference();
mUpdateDynamics.removeReference();
mUpdateBodies.removeReference();
mSolver.removeReference();
mPostIslandGen.removeReference();
mIslandGen.removeReference();
mPostNarrowPhase.removeReference();
mSecondPassNarrowPhase.removeReference();
}
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::activateEdgesInternal(const IG::EdgeIndex* activatingEdges, const PxU32 nbActivatingEdges)
{
const IG::IslandSim& speculativeSim = mSimpleIslandManager->getSpeculativeIslandSim();
for(PxU32 i = 0; i < nbActivatingEdges; ++i)
{
Interaction* interaction = mSimpleIslandManager->getInteraction(activatingEdges[i]);
if(interaction && !interaction->readInteractionFlag(InteractionFlag::eIS_ACTIVE))
{
if(speculativeSim.getEdge(activatingEdges[i]).isActive())
{
const bool proceed = activateInteraction(interaction, NULL);
if(proceed && (interaction->getType() < InteractionType::eTRACKED_IN_SCENE_COUNT))
notifyInteractionActivated(interaction);
}
}
}
}
void Sc::Scene::secondPassNarrowPhase(PxBaseTask* /*continuation*/)
{
PX_PROFILE_ZONE("Sim.secondPassNarrowPhase", mContextId);
{
PX_PROFILE_ZONE("Sim.postIslandGen", mContextId);
mSimpleIslandManager->additionalSpeculativeActivation();
// wake interactions
{
PX_PROFILE_ZONE("ScScene.wakeInteractions", mContextId);
const IG::IslandSim& speculativeSim = mSimpleIslandManager->getSpeculativeIslandSim();
//KS - only wake contact managers based on speculative state to trigger contact gen. Waking actors based on accurate state
//should activate and joints.
{
//Wake speculatively based on rigid contacts, soft contacts and particle contacts
activateEdgesInternal(speculativeSim.getActivatedEdges(IG::Edge::eCONTACT_MANAGER), speculativeSim.getNbActivatedEdges(IG::Edge::eCONTACT_MANAGER));
#if PX_SUPPORT_GPU_PHYSX
activateEdgesInternal(speculativeSim.getActivatedEdges(IG::Edge::eSOFT_BODY_CONTACT), speculativeSim.getNbActivatedEdges(IG::Edge::eSOFT_BODY_CONTACT));
activateEdgesInternal(speculativeSim.getActivatedEdges(IG::Edge::eFEM_CLOTH_CONTACT), speculativeSim.getNbActivatedEdges(IG::Edge::eFEM_CLOTH_CONTACT));
activateEdgesInternal(speculativeSim.getActivatedEdges(IG::Edge::ePARTICLE_SYSTEM_CONTACT), speculativeSim.getNbActivatedEdges(IG::Edge::ePARTICLE_SYSTEM_CONTACT));
activateEdgesInternal(speculativeSim.getActivatedEdges(IG::Edge::eHAIR_SYSTEM_CONTACT), speculativeSim.getNbActivatedEdges(IG::Edge::eHAIR_SYSTEM_CONTACT));
#endif
}
}
}
mLLContext->secondPassUpdateContactManager(mDt, &mPostNarrowPhase); // Starts update of contact managers
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::releaseConstraints(bool endOfScene)
{
PX_ASSERT(mLLContext);
if(mEnableStabilization)
{
//If stabilization is enabled, we're caching contacts for next frame
if(!endOfScene)
{
//So we only clear memory (flip buffers) when not at the end-of-scene.
//This means we clear after narrow phase completed so we can
//release the previous frame's contact buffers before we enter the solve phase.
mLLContext->getNpMemBlockPool().releaseContacts();
}
}
else if(endOfScene)
{
//We now have a double-buffered pool of mem blocks so we must
//release both pools (which actually triggers the memory used this
//frame to be released
mLLContext->getNpMemBlockPool().releaseContacts();
mLLContext->getNpMemBlockPool().releaseContacts();
}
}
void Sc::Scene::postNarrowPhase(PxBaseTask* /*continuation*/)
{
setCollisionPhaseToInactive();
mHasContactDistanceChanged = false;
mLLContext->fetchUpdateContactManager(); //Sync on contact gen results!
if(!mCCDBp && isUsingGpuDynamicsOrBp())
mSimulationController->sortContacts();
releaseConstraints(false);
PX_PROFILE_STOP_CROSSTHREAD("Basic.narrowPhase", mContextId);
PX_PROFILE_STOP_CROSSTHREAD("Basic.collision", mContextId);
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::processNarrowPhaseTouchEvents()
{
PX_PROFILE_ZONE("Sim.preIslandGen", mContextId);
PxsContext* context = mLLContext;
// Update touch states from LL
PxU32 newTouchCount, lostTouchCount;
PxU32 ccdTouchCount = 0;
{
PX_PROFILE_ZONE("Sim.preIslandGen.managerTouchEvents", mContextId);
context->getManagerTouchEventCount(reinterpret_cast<PxI32*>(&newTouchCount), reinterpret_cast<PxI32*>(&lostTouchCount), NULL);
//PX_ALLOCA(newTouches, PxvContactManagerTouchEvent, newTouchCount);
//PX_ALLOCA(lostTouches, PxvContactManagerTouchEvent, lostTouchCount);
mTouchFoundEvents.forceSize_Unsafe(0);
mTouchFoundEvents.reserve(newTouchCount);
mTouchFoundEvents.forceSize_Unsafe(newTouchCount);
mTouchLostEvents.forceSize_Unsafe(0);
mTouchLostEvents.reserve(lostTouchCount);
mTouchLostEvents.forceSize_Unsafe(lostTouchCount);
context->fillManagerTouchEvents(mTouchFoundEvents.begin(), reinterpret_cast<PxI32&>(newTouchCount), mTouchLostEvents.begin(),
reinterpret_cast<PxI32&>(lostTouchCount), NULL, reinterpret_cast<PxI32&>(ccdTouchCount));
mTouchFoundEvents.forceSize_Unsafe(newTouchCount);
mTouchLostEvents.forceSize_Unsafe(lostTouchCount);
}
context->getSimStats().mNbNewTouches = newTouchCount;
context->getSimStats().mNbLostTouches = lostTouchCount;
}
void Sc::Scene::islandGen(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Sc::Scene::islandGen", mContextId);
//mLLContext->runModifiableContactManagers(); //KS - moved here so that we can get up-to-date touch found/lost events in IG
processNarrowPhaseTouchEvents();
// PT: could we merge processNarrowPhaseTouchEventsStage2 with processNarrowPhaseTouchEvents ?
mProcessFoundPatchesTask.setContinuation(continuation);
mProcessLostPatchesTask.setContinuation(&mProcessFoundPatchesTask);
mProcessLostPatchesTask.removeReference();
mProcessFoundPatchesTask.removeReference();
// extracting information for the contact callbacks must happen before the solver writes the post-solve
// velocities and positions into the solver bodies
processNarrowPhaseTouchEventsStage2(&mUpdateDynamics);
}
///////////////////////////////////////////////////////////////////////////////
static PX_FORCE_INLINE ShapeInteraction* getSI(PxvContactManagerTouchEvent& evt)
{
return reinterpret_cast<ShapeInteraction*>(evt.getCMTouchEventUserData());
}
namespace
{
class InteractionNewTouchTask : public Cm::Task
{
PxvContactManagerTouchEvent* mEvents;
const PxU32 mNbEvents;
PxsContactManagerOutputIterator mOutputs;
NPhaseCore* mNphaseCore;
public:
InteractionNewTouchTask(PxU64 contextID, PxvContactManagerTouchEvent* events, PxU32 nbEvents, PxsContactManagerOutputIterator& outputs, NPhaseCore* nPhaseCore) :
Cm::Task (contextID),
mEvents (events),
mNbEvents (nbEvents),
mOutputs (outputs),
mNphaseCore (nPhaseCore)
{
}
virtual const char* getName() const
{
return "InteractionNewTouchTask";
}
virtual void runInternal()
{
mNphaseCore->lockReports();
for(PxU32 i = 0; i < mNbEvents; ++i)
{
ShapeInteraction* si = getSI(mEvents[i]);
PX_ASSERT(si);
mNphaseCore->managerNewTouch(*si);
si->managerNewTouch(0, true, mOutputs);
}
mNphaseCore->unlockReports();
}
private:
PX_NOCOPY(InteractionNewTouchTask)
};
}
void Sc::Scene::processNarrowPhaseTouchEventsStage2(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Sc::Scene::processNarrowPhaseTouchEventsStage2", mContextId);
PxvNphaseImplementationContext* ctx = mLLContext->getNphaseImplementationContext();
PxsContactManagerOutputIterator outputs = ctx->getContactManagerOutputs();
const PxU32 newTouchCount = mTouchFoundEvents.size();
{
Cm::FlushPool& flushPool = mLLContext->getTaskPool();
// PT: why not a delegate task here? We seem to be creating a single InteractionNewTouchTask ?
InteractionNewTouchTask* task = PX_PLACEMENT_NEW(flushPool.allocate(sizeof(InteractionNewTouchTask)), InteractionNewTouchTask)(mContextId, mTouchFoundEvents.begin(), newTouchCount, outputs, mNPhaseCore);
startTask(task, continuation);
}
/*{
PX_PROFILE_ZONE("Sim.preIslandGen.newTouchesInteraction", mContextId);
for (PxU32 i = 0; i < newTouchCount; ++i)
{
ShapeInteraction* si = reinterpret_cast<ShapeInteraction*>(mTouchFoundEvents[i].userData);
PX_ASSERT(si);
mNPhaseCore->managerNewTouch(*si);
si->managerNewTouch(0, true, outputs, useAdaptiveForce);
}
}*/
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::postIslandGen(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Sim.postIslandGen", mContextId);
//
// Trigger overlap processing (1) shall run in parallel with some parts of island
// management (2) (connecting edges, running second island gen pass, object activation...)
// For this to work without clashes, the work has to be split into pieces. Things to
// keep in mind:
//
// (1) can deactivate trigger pairs while (2) can activate trigger pairs (both might
// happen for the same pair). The active interaction tracking arrays are not thread safe
// (Sc::Scene::notifyInteractionDeactivated, ::notifyInteractionActivated) plus the
// natural order is to process activation first (deactivation should be based on the
// state after activation). Thus, (1) is split into a part (1a) that does the overlap checks
// and a part (1b) that checks if trigger pairs can be deactivated. (1a) will run in parallel
// with (2). (1b) will run after (2).
// Leaves the question of what happens to the trigger pairs activated in (2)? Should those
// not get overlap processing too? The rational for why this does not seem necessary is:
// If a trigger interaction is activated, then it was inactive before. If inactive, the
// overlap state can not have changed since the end of last sim step, unless:
// - the user changed the position of one of the invovled actors or shapes
// - the user changed the geometry of one of the involved shapes
// - the pair is new
// However, for all these cases, the trigger interaction is marked in a way that enforces
// processing and the interaction gets activated too.
//
PxBaseTask* setEdgesConnectedContinuationTask = continuation;
PxBaseTask* concludingTriggerTask = mNPhaseCore->prepareForTriggerInteractionProcessing(continuation);
if (concludingTriggerTask)
{
setEdgesConnectedContinuationTask = concludingTriggerTask;
}
mSetEdgesConnectedTask.setContinuation(setEdgesConnectedContinuationTask);
mSetEdgesConnectedTask.removeReference();
// - Performs collision detection for trigger interactions
if (concludingTriggerTask)
{
mNPhaseCore->processTriggerInteractions(*concludingTriggerTask);
concludingTriggerTask->removeReference();
}
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::setEdgesConnected(PxBaseTask*)
{
PX_PROFILE_ZONE("Sim.preIslandGen.islandTouches", mContextId);
{
PX_PROFILE_ZONE("Sim.preIslandGen.setEdgesConnected", mContextId);
const PxU32 newTouchCount = mTouchFoundEvents.size();
for(PxU32 i = 0; i < newTouchCount; ++i)
{
ShapeInteraction* si = getSI(mTouchFoundEvents[i]);
// jcarius: defensive coding for OM-99507. If this assert hits, you maybe hit the same issue, please report!
if(si == NULL || si->getEdgeIndex() == IG_INVALID_EDGE)
{
outputError<PxErrorCode::eINTERNAL_ERROR>(__LINE__, "Sc::Scene::setEdgesConnected: adding an invalid edge. Skipping.");
PX_ALWAYS_ASSERT();
continue;
}
if(!si->readFlag(ShapeInteraction::CONTACTS_RESPONSE_DISABLED))
mSimpleIslandManager->setEdgeConnected(si->getEdgeIndex(), IG::Edge::eCONTACT_MANAGER);
}
}
mSimpleIslandManager->secondPassIslandGen();
wakeObjectsUp();
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::solver(PxBaseTask* continuation)
{
PX_PROFILE_START_CROSSTHREAD("Basic.rigidBodySolver", mContextId);
//Update forces per body in parallel. This can overlap with the other work in this phase.
beforeSolver(continuation);
PX_PROFILE_ZONE("Sim.postNarrowPhaseSecondPass", mContextId);
//Narrowphase is completely finished so the streams can be swapped.
mLLContext->swapStreams();
//PxsContactManagerOutputIterator outputs = this->mLLContext->getNphaseImplementationContext()->getContactManagerOutputs();
//mNPhaseCore->processPersistentContactEvents(outputs, continuation);
}
///////////////////////////////////////////////////////////////////////////////
namespace
{
class ScBeforeSolverTask : public Cm::Task
{
public:
static const PxU32 MaxBodiesPerTask = 256;
PxNodeIndex mBodies[MaxBodiesPerTask];
PxU32 mNumBodies;
const PxReal mDt;
IG::SimpleIslandManager* mIslandManager;
PxsSimulationController* mSimulationController;
public:
ScBeforeSolverTask(PxReal dt, IG::SimpleIslandManager* islandManager, PxsSimulationController* simulationController, PxU64 contextID) :
Cm::Task (contextID),
mDt (dt),
mIslandManager (islandManager),
mSimulationController (simulationController)
{
}
virtual void runInternal()
{
PX_PROFILE_ZONE("Sim.ScBeforeSolverTask", mContextID);
const IG::IslandSim& islandSim = mIslandManager->getAccurateIslandSim();
const PxU32 rigidBodyOffset = BodySim::getRigidBodyOffset();
PxsRigidBody* updatedBodySims[MaxBodiesPerTask];
PxU32 updatedBodyNodeIndices[MaxBodiesPerTask];
PxU32 nbUpdatedBodySims = 0;
PxU32 nb = mNumBodies;
const PxNodeIndex* bodies = mBodies;
while(nb--)
{
const PxNodeIndex index = *bodies++;
if(islandSim.getActiveNodeIndex(index) != PX_INVALID_NODE)
{
if(islandSim.getNode(index).mType == IG::Node::eRIGID_BODY_TYPE)
{
PxsRigidBody* body = islandSim.getRigidBody(index);
BodySim* bodySim = reinterpret_cast<BodySim*>(reinterpret_cast<PxU8*>(body) - rigidBodyOffset);
bodySim->updateForces(mDt, updatedBodySims, updatedBodyNodeIndices, nbUpdatedBodySims, NULL);
}
}
}
if(nbUpdatedBodySims)
mSimulationController->updateBodies(updatedBodySims, updatedBodyNodeIndices, nbUpdatedBodySims);
}
virtual const char* getName() const
{
return "ScScene.beforeSolver";
}
private:
PX_NOCOPY(ScBeforeSolverTask)
};
class ScArticBeforeSolverTask : public Cm::Task
{
public:
ArticulationSim* const* mArticSims;
const PxU32 mNumArticulations;
const PxReal mDt;
IG::SimpleIslandManager* mIslandManager;
public:
ScArticBeforeSolverTask(ArticulationSim* const* articSims, PxU32 nbArtics, PxReal dt, IG::SimpleIslandManager* islandManager, PxU64 contextID) :
Cm::Task(contextID),
mArticSims(articSims),
mNumArticulations(nbArtics),
mDt(dt),
mIslandManager(islandManager)
{
}
virtual void runInternal()
{
PX_PROFILE_ZONE("Sim.ScArticBeforeSolverTask", mContextID);
//const IG::IslandSim& islandSim = mIslandManager->getAccurateIslandSim();
for(PxU32 a = 0; a < mNumArticulations; ++a)
{
ArticulationSim* PX_RESTRICT articSim = mArticSims[a];
//articSim->checkResize();
articSim->updateForces(mDt);
articSim->setDirtyFlag(ArticulationSimDirtyFlag::eNONE);
}
}
virtual const char* getName() const
{
return "ScScene.ScArticBeforeSolverTask";
}
private:
PX_NOCOPY(ScArticBeforeSolverTask)
};
class ScArticBeforeSolverCCDTask : public Cm::Task
{
public:
const PxNodeIndex* const mArticIndices;
const PxU32 mNumArticulations;
const PxReal mDt;
IG::SimpleIslandManager* mIslandManager;
public:
ScArticBeforeSolverCCDTask(const PxNodeIndex* const articIndices, PxU32 nbArtics, PxReal dt, IG::SimpleIslandManager* islandManager, PxU64 contextID) :
Cm::Task(contextID),
mArticIndices(articIndices),
mNumArticulations(nbArtics),
mDt(dt),
mIslandManager(islandManager)
{
}
virtual void runInternal()
{
PX_PROFILE_ZONE("Sim.ScArticBeforeSolverCCDTask", mContextID);
const IG::IslandSim& islandSim = mIslandManager->getAccurateIslandSim();
for(PxU32 a = 0; a < mNumArticulations; ++a)
{
ArticulationSim* articSim = islandSim.getArticulationSim(mArticIndices[a]);
articSim->saveLastCCDTransform();
}
}
virtual const char* getName() const
{
return "ScScene.ScArticBeforeSolverCCDTask";
}
private:
PX_NOCOPY(ScArticBeforeSolverCCDTask)
};
}
void Sc::Scene::beforeSolver(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Sim.updateForces", mContextId);
// Note: For contact notifications it is important that force threshold checks are done after new/lost touches have been processed
// because pairs might get added to the list processed below
// Atoms that passed contact force threshold
ThresholdStream& thresholdStream = mDynamicsContext->getThresholdStream();
thresholdStream.clear();
const IG::IslandSim& islandSim = mSimpleIslandManager->getAccurateIslandSim();
const PxU32 nbActiveBodies = islandSim.getNbActiveNodes(IG::Node::eRIGID_BODY_TYPE);
mNumDeactivatingNodes[IG::Node::eRIGID_BODY_TYPE] = 0;//islandSim.getNbNodesToDeactivate(IG::Node::eRIGID_BODY_TYPE);
mNumDeactivatingNodes[IG::Node::eARTICULATION_TYPE] = 0;//islandSim.getNbNodesToDeactivate(IG::Node::eARTICULATION_TYPE);
//#if PX_SUPPORT_GPU_PHYSX
mNumDeactivatingNodes[IG::Node::eSOFTBODY_TYPE] = 0;
mNumDeactivatingNodes[IG::Node::eFEMCLOTH_TYPE] = 0;
mNumDeactivatingNodes[IG::Node::ePARTICLESYSTEM_TYPE] = 0;
mNumDeactivatingNodes[IG::Node::eHAIRSYSTEM_TYPE] = 0;
//#endif
const PxU32 MaxBodiesPerTask = ScBeforeSolverTask::MaxBodiesPerTask;
Cm::FlushPool& flushPool = mLLContext->getTaskPool();
mSimulationController->reserve(nbActiveBodies);
{
PxBitMap::Iterator iter(mVelocityModifyMap);
// PT: TASK-CREATION TAG
for (PxU32 i = iter.getNext(); i != PxBitMap::Iterator::DONE; /*i = iter.getNext()*/)
{
ScBeforeSolverTask* task = PX_PLACEMENT_NEW(flushPool.allocate(sizeof(ScBeforeSolverTask)), ScBeforeSolverTask(mDt, mSimpleIslandManager, mSimulationController, mContextId));
PxU32 count = 0;
for(; count < MaxBodiesPerTask && i != PxBitMap::Iterator::DONE; i = iter.getNext())
{
PxsRigidBody* body = islandSim.getRigidBody(PxNodeIndex(i));
bool retainsAccelerations = false;
if(body)
{
task->mBodies[count++] = PxNodeIndex(i);
retainsAccelerations = (body->mCore->mFlags & PxRigidBodyFlag::eRETAIN_ACCELERATIONS);
}
if(!retainsAccelerations)
mVelocityModifyMap.reset(i);
}
task->mNumBodies = count;
startTask(task, continuation);
}
}
// PT: TASK-CREATION TAG
const PxU32 nbArticsPerTask = 32;
const PxU32 nbDirtyArticulations = mDirtyArticulationSims.size();
ArticulationSim* const* artiSim = mDirtyArticulationSims.getEntries();
for(PxU32 a = 0; a < nbDirtyArticulations; a += nbArticsPerTask)
{
const PxU32 nbToProcess = PxMin(PxU32(nbDirtyArticulations - a), nbArticsPerTask);
ScArticBeforeSolverTask* task = PX_PLACEMENT_NEW(flushPool.allocate(sizeof(ScArticBeforeSolverTask)), ScArticBeforeSolverTask(artiSim + a, nbToProcess,
mDt, mSimpleIslandManager, mContextId));
startTask(task, continuation);
}
//if the scene has ccd flag on, we should call ScArticBeforeSolverCCDTask to copy the last transform to the current transform
if(mPublicFlags & PxSceneFlag::eENABLE_CCD)
{
//CCD
const PxU32 nbActiveArticulations = islandSim.getNbActiveNodes(IG::Node::eARTICULATION_TYPE);
const PxNodeIndex* const articIndices = islandSim.getActiveNodes(IG::Node::eARTICULATION_TYPE);
// PT: TASK-CREATION TAG
for(PxU32 a = 0; a < nbActiveArticulations; a += nbArticsPerTask)
{
const PxU32 nbToProcess = PxMin(PxU32(nbActiveArticulations - a), nbArticsPerTask);
ScArticBeforeSolverCCDTask* task = PX_PLACEMENT_NEW(flushPool.allocate(sizeof(ScArticBeforeSolverCCDTask)), ScArticBeforeSolverCCDTask(articIndices + a, nbToProcess,
mDt, mSimpleIslandManager, mContextId));
startTask(task, continuation);
}
}
// AD: need to raise dirty flags serially because the PxgBodySimManager::updateArticulation() is not thread-safe.
for (PxU32 a = 0; a < nbDirtyArticulations; ++a)
{
if (artiSim[a]->getLowLevelArticulation()->mGPUDirtyFlags & (Dy::ArticulationDirtyFlag::eDIRTY_EXT_ACCEL))
{
mSimulationController->updateArticulationExtAccel(artiSim[a]->getLowLevelArticulation(), artiSim[a]->getIslandNodeIndex());
}
}
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::updateBodies(PxBaseTask* continuation)
{
//dma bodies and articulation data to gpu
mSimulationController->updateBodies(continuation);
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::updateDynamics(PxBaseTask* continuation)
{
PX_PROFILE_START_CROSSTHREAD("Basic.dynamics", mContextId);
//Allow processLostContactsTask to run until after 2nd pass of solver completes (update bodies, run sleeping logic etc.)
mProcessLostContactsTask3.setContinuation(static_cast<PxLightCpuTask*>(continuation)->getContinuation());
mProcessLostContactsTask2.setContinuation(&mProcessLostContactsTask3);
mProcessLostContactsTask.setContinuation(&mProcessLostContactsTask2);
////dma bodies and shapes data to gpu
//mSimulationController->updateBodiesAndShapes();
mLLContext->getNpMemBlockPool().acquireConstraintMemory();
const PxU32 maxPatchCount = mLLContext->getMaxPatchCount();
mAABBManager->reallocateChangedAABBMgActorHandleMap(getElementIDPool().getMaxID());
//mNPhaseCore->processPersistentContactEvents(outputs, continuation);
PxvNphaseImplementationContext* nphase = mLLContext->getNphaseImplementationContext();
mDynamicsContext->update(*mSimpleIslandManager, continuation, &mProcessLostContactsTask,
nphase, maxPatchCount, mMaxNbArticulationLinks, mDt, mGravity, mAABBManager->getChangedAABBMgActorHandleMap());
mSimpleIslandManager->clearDestroyedEdges();
mProcessLostContactsTask3.removeReference();
mProcessLostContactsTask2.removeReference();
mProcessLostContactsTask.removeReference();
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::processLostContacts(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Sc::Scene::processLostContacts", mContextId);
mProcessNarrowPhaseLostTouchTasks.setContinuation(continuation);
mProcessNarrowPhaseLostTouchTasks.removeReference();
//mLostTouchReportsTask.setContinuation(&mProcessLostContactsTask3);
mProcessNPLostTouchEvents.setContinuation(continuation);
mProcessNPLostTouchEvents.removeReference();
{
PX_PROFILE_ZONE("Sim.findInteractionsPtrs", mContextId);
Bp::AABBManagerBase* aabbMgr = mAABBManager;
PxU32 destroyedOverlapCount;
Bp::AABBOverlap* PX_RESTRICT p = aabbMgr->getDestroyedOverlaps(Bp::ElementType::eSHAPE, destroyedOverlapCount);
while(destroyedOverlapCount--)
{
ElementSim* volume0 = reinterpret_cast<ElementSim*>(p->mUserData0);
ElementSim* volume1 = reinterpret_cast<ElementSim*>(p->mUserData1);
// PT: this looks useless on lost pairs but it is used in processLostContacts2 and processLostContacts3
// PT: it seems very questionable to store this within the BP structures at this point. If anything
// we should have stored that there when the overlap was created, and we wouldn't have to look for the
// interaction here.
p->mPairUserData = mNPhaseCore->findInteraction(volume0, volume1);
p++;
}
}
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::processNarrowPhaseLostTouchEventsIslands(PxBaseTask*)
{
PX_PROFILE_ZONE("Sc::Scene.islandLostTouches", mContextId);
const PxU32 count = mTouchLostEvents.size();
for(PxU32 i=0; i <count; ++i)
{
ShapeInteraction* si = getSI(mTouchLostEvents[i]);
mSimpleIslandManager->setEdgeDisconnected(si->getEdgeIndex());
}
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::addToLostTouchList(ActorSim& body1, ActorSim& body2)
{
PX_ASSERT(!body1.isStaticRigid());
PX_ASSERT(!body2.isStaticRigid());
SimpleBodyPair p = { &body1, &body2, body1.getActorID(), body2.getActorID() };
mLostTouchPairs.pushBack(p);
}
void Sc::Scene::processNarrowPhaseLostTouchEvents(PxBaseTask*)
{
PX_PROFILE_ZONE("Sc::Scene.processNarrowPhaseLostTouchEvents", mContextId);
PxvNphaseImplementationContext* ctx = mLLContext->getNphaseImplementationContext();
PxsContactManagerOutputIterator outputs = ctx->getContactManagerOutputs();
const PxU32 count = mTouchLostEvents.size();
for(PxU32 i=0; i<count; ++i)
{
ShapeInteraction* si = getSI(mTouchLostEvents[i]);
PX_ASSERT(si);
if(si->managerLostTouch(0, true, outputs) && !si->readFlag(ShapeInteraction::CONTACTS_RESPONSE_DISABLED))
addToLostTouchList(si->getShape0().getActor(), si->getShape1().getActor());
}
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::processLostContacts2(PxBaseTask* continuation)
{
mDestroyManagersTask.setContinuation(continuation);
mLostTouchReportsTask.setContinuation(&mDestroyManagersTask);
mLostTouchReportsTask.removeReference();
mUnregisterInteractionsTask.setContinuation(continuation);
mUnregisterInteractionsTask.removeReference();
{
PX_PROFILE_ZONE("Sim.clearIslandData", mContextId);
Bp::AABBManagerBase* aabbMgr = mAABBManager;
PxU32 destroyedOverlapCount;
{
Bp::AABBOverlap* PX_RESTRICT p = aabbMgr->getDestroyedOverlaps(Bp::ElementType::eSHAPE, destroyedOverlapCount);
while(destroyedOverlapCount--)
{
ElementSimInteraction* pair = reinterpret_cast<ElementSimInteraction*>(p->mPairUserData);
if(pair)
{
if(pair->getType() == InteractionType::eOVERLAP)
{
ShapeInteraction* si = static_cast<ShapeInteraction*>(pair);
si->clearIslandGenData();
}
}
p++;
}
}
}
mDestroyManagersTask.removeReference();
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::lostTouchReports(PxBaseTask*)
{
PX_PROFILE_ZONE("Sim.lostTouchReports", mContextId);
PxsContactManagerOutputIterator outputs = mLLContext->getNphaseImplementationContext()->getContactManagerOutputs();
mNPhaseCore->lockReports();
{
PxU32 destroyedOverlapCount;
const Bp::AABBOverlap* PX_RESTRICT p = mAABBManager->getDestroyedOverlaps(Bp::ElementType::eSHAPE, destroyedOverlapCount);
while(destroyedOverlapCount--)
{
if(p->mPairUserData)
{
ElementSimInteraction* elemInteraction = reinterpret_cast<ElementSimInteraction*>(p->mPairUserData);
if(elemInteraction->getType() == InteractionType::eOVERLAP)
mNPhaseCore->lostTouchReports(static_cast<ShapeInteraction*>(elemInteraction), PxU32(PairReleaseFlag::eWAKE_ON_LOST_TOUCH), NULL, 0, outputs);
}
p++;
}
}
mNPhaseCore->unlockReports();
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::unregisterInteractions(PxBaseTask*)
{
PX_PROFILE_ZONE("Sim.unregisterInteractions", mContextId);
PxU32 destroyedOverlapCount;
const Bp::AABBOverlap* PX_RESTRICT p = mAABBManager->getDestroyedOverlaps(Bp::ElementType::eSHAPE, destroyedOverlapCount);
while(destroyedOverlapCount--)
{
if(p->mPairUserData)
{
ElementSimInteraction* elemInteraction = reinterpret_cast<ElementSimInteraction*>(p->mPairUserData);
if(elemInteraction->getType() == InteractionType::eOVERLAP || elemInteraction->getType() == InteractionType::eMARKER)
unregisterInteraction(elemInteraction);
}
p++;
}
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::destroyManagers(PxBaseTask*)
{
PX_PROFILE_ZONE("Sim.destroyManagers", mContextId);
mPostThirdPassIslandGenTask.setContinuation(mProcessLostContactsTask3.getContinuation());
mSimpleIslandManager->thirdPassIslandGen(&mPostThirdPassIslandGenTask);
PxU32 destroyedOverlapCount;
const Bp::AABBOverlap* PX_RESTRICT p = mAABBManager->getDestroyedOverlaps(Bp::ElementType::eSHAPE, destroyedOverlapCount);
while(destroyedOverlapCount--)
{
if(p->mPairUserData)
{
ElementSimInteraction* elemInteraction = reinterpret_cast<ElementSimInteraction*>(p->mPairUserData);
if(elemInteraction->getType() == InteractionType::eOVERLAP)
{
ShapeInteraction* si = static_cast<ShapeInteraction*>(elemInteraction);
if(si->getContactManager())
si->destroyManager();
}
}
p++;
}
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::processLostContacts3(PxBaseTask* /*continuation*/)
{
{
PX_PROFILE_ZONE("Sim.processLostOverlapsStage2", mContextId);
PxsContactManagerOutputIterator outputs = mLLContext->getNphaseImplementationContext()->getContactManagerOutputs();
Bp::AABBManagerBase* aabbMgr = mAABBManager;
PxU32 destroyedOverlapCount;
// PT: for regular shapes
{
const Bp::AABBOverlap* PX_RESTRICT p = aabbMgr->getDestroyedOverlaps(Bp::ElementType::eSHAPE, destroyedOverlapCount);
while(destroyedOverlapCount--)
{
ElementSim* volume0 = reinterpret_cast<ElementSim*>(p->mUserData0);
ElementSim* volume1 = reinterpret_cast<ElementSim*>(p->mUserData1);
mNPhaseCore->onOverlapRemoved(volume0, volume1, false, p->mPairUserData, outputs);
p++;
}
}
// PT: for triggers
{
const Bp::AABBOverlap* PX_RESTRICT p = aabbMgr->getDestroyedOverlaps(Bp::ElementType::eTRIGGER, destroyedOverlapCount);
while(destroyedOverlapCount--)
{
ElementSim* volume0 = reinterpret_cast<ElementSim*>(p->mUserData0);
ElementSim* volume1 = reinterpret_cast<ElementSim*>(p->mUserData1);
mNPhaseCore->onOverlapRemoved(volume0, volume1, false, NULL, outputs);
p++;
}
}
aabbMgr->freeBuffers();
}
mPostThirdPassIslandGenTask.removeReference();
}
///////////////////////////////////////////////////////////////////////////////
/*static*/ bool deactivateInteraction(Interaction* interaction, const InteractionType::Enum type);
void Sc::Scene::postThirdPassIslandGen(PxBaseTask* /*continuation*/)
{
PX_PROFILE_ZONE("Sc::Scene::postThirdPassIslandGen", mContextId);
putObjectsToSleep();
{
PX_PROFILE_ZONE("Sc::Scene::putInteractionsToSleep", mContextId);
const IG::IslandSim& islandSim = mSimpleIslandManager->getSpeculativeIslandSim();
//KS - only deactivate contact managers based on speculative state to trigger contact gen. When the actors were deactivated based on accurate state
//joints should have been deactivated.
const PxU32 NbTypes = 5;
const IG::Edge::EdgeType types[NbTypes] = {
IG::Edge::eCONTACT_MANAGER,
IG::Edge::eSOFT_BODY_CONTACT,
IG::Edge::eFEM_CLOTH_CONTACT,
IG::Edge::ePARTICLE_SYSTEM_CONTACT,
IG::Edge::eHAIR_SYSTEM_CONTACT };
for(PxU32 t = 0; t < NbTypes; ++t)
{
const PxU32 nbDeactivatingEdges = islandSim.getNbDeactivatingEdges(types[t]);
const IG::EdgeIndex* deactivatingEdgeIds = islandSim.getDeactivatingEdges(types[t]);
for(PxU32 i = 0; i < nbDeactivatingEdges; ++i)
{
Interaction* interaction = mSimpleIslandManager->getInteraction(deactivatingEdgeIds[i]);
if(interaction && interaction->readInteractionFlag(InteractionFlag::eIS_ACTIVE))
{
if(!islandSim.getEdge(deactivatingEdgeIds[i]).isActive())
{
const InteractionType::Enum type = interaction->getType();
const bool proceed = deactivateInteraction(interaction, type);
if(proceed && (type < InteractionType::eTRACKED_IN_SCENE_COUNT))
notifyInteractionDeactivated(interaction);
}
}
}
}
}
PxvNphaseImplementationContext* implCtx = mLLContext->getNphaseImplementationContext();
PxsContactManagerOutputIterator outputs = implCtx->getContactManagerOutputs();
mNPhaseCore->processPersistentContactEvents(outputs);
}
///////////////////////////////////////////////////////////////////////////////
//This is called after solver finish
void Sc::Scene::updateSimulationController(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Sim.updateSimulationController", mContextId);
PxsTransformCache& cache = getLowLevelContext()->getTransformCache();
Bp::BoundsArray& boundArray = getBoundsArray();
PxBitMapPinned& changedAABBMgrActorHandles = mAABBManager->getChangedAABBMgActorHandleMap();
mSimulationController->gpuDmabackData(cache, boundArray, changedAABBMgrActorHandles, mPublicFlags & PxSceneFlag::eENABLE_DIRECT_GPU_API);
//for pxgdynamicscontext: copy solver body data to body core
{
PX_PROFILE_ZONE("Sim.updateBodyCore", mContextId);
mDynamicsContext->updateBodyCore(continuation);
}
//mSimulationController->update(cache, boundArray, changedAABBMgrActorHandles);
/*mProcessLostPatchesTask.setContinuation(&mFinalizationPhase);
mProcessLostPatchesTask.removeReference();*/
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::postSolver(PxBaseTask* /*continuation*/)
{
PX_PROFILE_ZONE("Sc::Scene::postSolver", mContextId);
PxcNpMemBlockPool& blockPool = mLLContext->getNpMemBlockPool();
//Merge...
mDynamicsContext->mergeResults();
blockPool.releaseConstraintMemory();
//Swap friction!
blockPool.swapFrictionStreams();
mCcdBodies.clear();
#if PX_ENABLE_SIM_STATS
mLLContext->getSimStats().mPeakConstraintBlockAllocations = blockPool.getPeakConstraintBlockCount();
#else
PX_CATCH_UNDEFINED_ENABLE_SIM_STATS
#endif
integrateKinematicPose();
{
const PxU32 size = mDirtyArticulationSims.size();
ArticulationSim* const* articSims = mDirtyArticulationSims.getEntries();
//clear the acceleration term for articulation if the application raised PxForceMode::eIMPULSE in addForce function. This change
//will make sure articulation and rigid body behave the same
const float dt = mDt;
for(PxU32 i=0; i<size; ++i)
articSims[i]->clearAcceleration(dt);
//clear the dirty articulation list
mDirtyArticulationSims.clear();
}
//afterIntegration(continuation);
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::constraintProjection(PxBaseTask* /*continuation*/)
{
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::checkForceThresholdContactEvents(PxU32 ccdPass)
{
PX_PROFILE_ZONE("Sim.checkForceThresholdContactEvents", mContextId);
// Note: For contact notifications it is important that force threshold checks are done after new/lost touches have been processed
// because pairs might get added to the list processed below
// Bodies that passed contact force threshold
PxsContactManagerOutputIterator outputs = mLLContext->getNphaseImplementationContext()->getContactManagerOutputs();
ThresholdStream& thresholdStream = mDynamicsContext->getForceChangedThresholdStream();
const PxU32 nbThresholdElements = thresholdStream.size();
for(PxU32 i = 0; i< nbThresholdElements; ++i)
{
ThresholdStreamElement& elem = thresholdStream[i];
ShapeInteraction* si = elem.shapeInteraction;
//If there is a shapeInteraction and the shapeInteraction points to a contactManager (i.e. the CM was not destroyed in parallel with the solver)
if(si)
{
PxU32 pairFlags = si->getPairFlags();
if(pairFlags & ShapeInteraction::CONTACT_FORCE_THRESHOLD_PAIRS)
{
si->swapAndClearForceThresholdExceeded();
if(elem.accumulatedForce > elem.threshold * mDt)
{
si->raiseFlag(ShapeInteraction::FORCE_THRESHOLD_EXCEEDED_NOW);
PX_ASSERT(si->hasTouch());
//If the accumulatedForce is large than the threshold in the current frame and the accumulatedForce is less than the threshold in the previous frame,
//and the user request notify for found event, we will raise eNOTIFY_THRESHOLD_FORCE_FOUND
if((!si->readFlag(ShapeInteraction::FORCE_THRESHOLD_EXCEEDED_BEFORE)) && (pairFlags & PxPairFlag::eNOTIFY_THRESHOLD_FORCE_FOUND))
si->processUserNotification(PxPairFlag::eNOTIFY_THRESHOLD_FORCE_FOUND, 0, false, ccdPass, false, outputs);
else if(si->readFlag(ShapeInteraction::FORCE_THRESHOLD_EXCEEDED_BEFORE) && (pairFlags & PxPairFlag::eNOTIFY_THRESHOLD_FORCE_PERSISTS))
si->processUserNotification(PxPairFlag::eNOTIFY_THRESHOLD_FORCE_PERSISTS, 0, false, ccdPass, false, outputs);
}
else
{
//If the accumulatedForce is less than the threshold in the current frame and the accumulatedForce is large than the threshold in the previous frame,
//and the user request notify for found event, we will raise eNOTIFY_THRESHOLD_FORCE_LOST
if(si->readFlag(ShapeInteraction::FORCE_THRESHOLD_EXCEEDED_BEFORE) && (pairFlags & PxPairFlag::eNOTIFY_THRESHOLD_FORCE_LOST))
si->processUserNotification(PxPairFlag::eNOTIFY_THRESHOLD_FORCE_LOST, 0, false, ccdPass, false, outputs);
}
}
}
}
}
void Sc::Scene::afterIntegration(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Sc::Scene::afterIntegration", mContextId);
mLLContext->getTransformCache().resetChangedState(); //Reset the changed state. If anything outside of the GPU kernels updates any shape's transforms, this will be raised again
getBoundsArray().resetChangedState();
PxsTransformCache& cache = getLowLevelContext()->getTransformCache();
Bp::BoundsArray& boundArray = getBoundsArray();
{
PX_PROFILE_ZONE("AfterIntegration::lockStage", mContextId);
mLLContext->getLock().lock();
{
PX_PROFILE_ZONE("SimController", mContextId);
mSimulationController->updateScBodyAndShapeSim(cache, boundArray, continuation);
}
const IG::IslandSim& islandSim = mSimpleIslandManager->getAccurateIslandSim();
const PxU32 rigidBodyOffset = BodySim::getRigidBodyOffset();
const PxU32 numBodiesToDeactivate = islandSim.getNbNodesToDeactivate(IG::Node::eRIGID_BODY_TYPE);
const PxNodeIndex*const deactivatingIndices = islandSim.getNodesToDeactivate(IG::Node::eRIGID_BODY_TYPE);
PxU32 previousNumBodiesToDeactivate = mNumDeactivatingNodes[IG::Node::eRIGID_BODY_TYPE];
{
PX_PROFILE_ZONE("AfterIntegration::deactivateStage", mContextId);
PxBitMapPinned& changedAABBMgrActorHandles = mAABBManager->getChangedAABBMgActorHandleMap();
for(PxU32 i = previousNumBodiesToDeactivate; i < numBodiesToDeactivate; i++)
{
PxsRigidBody* rigid = islandSim.getRigidBody(deactivatingIndices[i]);
BodySim* bodySim = reinterpret_cast<BodySim*>(reinterpret_cast<PxU8*>(rigid) - rigidBodyOffset);
//we need to set the rigid body back to the previous pose for the deactivated objects. This emulates the previous behavior where island gen ran before the solver, ensuring
//that bodies that should be deactivated this frame never reach the solver. We now run the solver in parallel with island gen, so objects that should be deactivated this frame
//still reach the solver and are integrated. However, on the frame when they should be deactivated, we roll back to their state at the beginning of the frame to ensure that the
//user perceives the same behavior as before.
PxsBodyCore& bodyCore = bodySim->getBodyCore().getCore();
//if(!islandSim.getNode(bodySim->getNodeIndex()).isActive())
rigid->setPose(rigid->getLastCCDTransform());
bodySim->updateCached(&changedAABBMgrActorHandles);
updateBodySim(*bodySim);
//solver is running in parallel with IG(so solver might solving the body which IG identify as deactivatedNodes). After we moved sleepCheck into the solver after integration, sleepChecks
//might have processed bodies that are now considered deactivated. This could have resulted in either freezing or unfreezing one of these bodies this frame, so we need to process those
//events to ensure that the SqManager's bounds arrays are consistently maintained. Also, we need to clear the frame flags for these bodies.
if(rigid->isFreezeThisFrame())
bodySim->freezeTransforms(&mAABBManager->getChangedAABBMgActorHandleMap());
//KS - the IG deactivates bodies in parallel with the solver. It appears that under certain circumstances, the solver's integration (which performs
//sleep checks) could decide that the body is no longer a candidate for sleeping on the same frame that the island gen decides to deactivate the island
//that the body is contained in. This is a rare occurrence but the behavior we want to emulate is that of IG running before solver so we should therefore
//permit the IG to make the authoritative decision over whether the body should be active or inactive.
bodyCore.wakeCounter = 0.0f;
bodyCore.linearVelocity = PxVec3(0.0f);
bodyCore.angularVelocity = PxVec3(0.0f);
rigid->clearAllFrameFlags();
}
}
updateKinematicCached(continuation);
mLLContext->getLock().unlock();
}
IG::IslandSim& islandSim = mSimpleIslandManager->getAccurateIslandSim();
const PxU32 nbActiveArticulations = islandSim.getNbActiveNodes(IG::Node::eARTICULATION_TYPE);
if(nbActiveArticulations)
mSimulationController->updateArticulationAfterIntegration(mLLContext, mAABBManager, mCcdBodies, continuation, islandSim, mDt);
const PxU32 numArticsToDeactivate = islandSim.getNbNodesToDeactivate(IG::Node::eARTICULATION_TYPE);
const PxNodeIndex*const deactivatingArticIndices = islandSim.getNodesToDeactivate(IG::Node::eARTICULATION_TYPE);
PxU32 previousNumArticsToDeactivate = mNumDeactivatingNodes[IG::Node::eARTICULATION_TYPE];
for(PxU32 i = previousNumArticsToDeactivate; i < numArticsToDeactivate; ++i)
{
ArticulationSim* artic = islandSim.getArticulationSim(deactivatingArticIndices[i]);
artic->putToSleep();
}
//PxU32 previousNumClothToDeactivate = mNumDeactivatingNodes[IG::Node::eFEMCLOTH_TYPE];
//const PxU32 numClothToDeactivate = islandSim.getNbNodesToDeactivate(IG::Node::eFEMCLOTH_TYPE);
//const IG::NodeIndex*const deactivatingClothIndices = islandSim.getNodesToDeactivate(IG::Node::eFEMCLOTH_TYPE);
//for (PxU32 i = previousNumClothToDeactivate; i < numClothToDeactivate; ++i)
//{
// FEMCloth* cloth = islandSim.getLLFEMCloth(deactivatingClothIndices[i]);
// mSimulationController->deactivateCloth(cloth);
//}
//PxU32 previousNumSoftBodiesToDeactivate = mNumDeactivatingNodes[IG::Node::eSOFTBODY_TYPE];
//const PxU32 numSoftBodiesToDeactivate = islandSim.getNbNodesToDeactivate(IG::Node::eSOFTBODY_TYPE);
//const IG::NodeIndex*const deactivatingSoftBodiesIndices = islandSim.getNodesToDeactivate(IG::Node::eSOFTBODY_TYPE);
//for (PxU32 i = previousNumSoftBodiesToDeactivate; i < numSoftBodiesToDeactivate; ++i)
//{
// Dy::SoftBody* softbody = islandSim.getLLSoftBody(deactivatingSoftBodiesIndices[i]);
// printf("after Integration: Deactivating soft body %i\n", softbody->getGpuRemapId());
// //mSimulationController->deactivateSoftbody(softbody);
// softbody->getSoftBodySim()->setActive(false, 0);
//}
PX_PROFILE_STOP_CROSSTHREAD("Basic.dynamics", mContextId);
checkForceThresholdContactEvents(0);
}
///////////////////////////////////////////////////////////////////////////////
void Sc::Scene::fireOnAdvanceCallback()
{
if(!mSimulationEventCallback)
return;
const PxU32 nbPosePreviews = mPosePreviewBodies.size();
if(!nbPosePreviews)
return;
mClientPosePreviewBodies.clear();
mClientPosePreviewBodies.reserve(nbPosePreviews);
mClientPosePreviewBuffer.clear();
mClientPosePreviewBuffer.reserve(nbPosePreviews);
const BodySim*const* PX_RESTRICT posePreviewBodies = mPosePreviewBodies.getEntries();
for(PxU32 i=0; i<nbPosePreviews; i++)
{
const BodySim& b = *posePreviewBodies[i];
if(!b.isFrozen())
{
PxsBodyCore& c = b.getBodyCore().getCore();
mClientPosePreviewBodies.pushBack(static_cast<const PxRigidBody*>(b.getPxActor()));
// PT:: tag: scalar transform*transform
mClientPosePreviewBuffer.pushBack(c.body2World * c.getBody2Actor().getInverse());
}
}
const PxU32 bodyCount = mClientPosePreviewBodies.size();
if(bodyCount)
mSimulationEventCallback->onAdvance(mClientPosePreviewBodies.begin(), mClientPosePreviewBuffer.begin(), bodyCount);
}
void Sc::Scene::finalizationPhase(PxBaseTask* /*continuation*/)
{
PX_PROFILE_ZONE("Sim.sceneFinalization", mContextId);
if(mCCDContext)
{
if(mSimulationController->mGPU) // PT: skip this on CPU, see empty CPU function called in updateBodySim
{
//KS - force simulation controller to update any bodies updated by the CCD. When running GPU simulation, this would be required
//to ensure that cached body states are updated
const PxU32 nbUpdatedBodies = mCCDContext->getNumUpdatedBodies();
PxsRigidBody*const* updatedBodies = mCCDContext->getUpdatedBodies();
const PxU32 rigidBodyOffset = BodySim::getRigidBodyOffset();
for(PxU32 a=0; a<nbUpdatedBodies; ++a)
{
BodySim* bodySim = reinterpret_cast<BodySim*>(reinterpret_cast<PxU8*>(updatedBodies[a]) - rigidBodyOffset);
updateBodySim(*bodySim);
}
}
mCCDContext->clearUpdatedBodies();
}
fireOnAdvanceCallback(); // placed here because it needs to be done after sleep check and after potential CCD passes
checkConstraintBreakage(); // Performs breakage tests on breakable constraints
PX_PROFILE_STOP_CROSSTHREAD("Basic.rigidBodySolver", mContextId);
mTaskPool.clear();
mReportShapePairTimeStamp++; // important to do this before fetchResults() is called to make sure that delayed deleted actors/shapes get
// separate pair entries in contact reports
// AD: WIP, will be gone once we removed the warm-start with sim step.
if (mPublicFlags & PxSceneFlag::eENABLE_DIRECT_GPU_API)
setDirectGPUAPIInitialized();
}
///////////////////////////////////////////////////////////////////////////////
| 87,155 | C++ | 35.074503 | 205 | 0.726522 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScShapeCore.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "foundation/PxErrorCallback.h"
#include "ScShapeSim.h"
#include "ScPhysics.h"
#include "GuConvexMesh.h"
#include "GuTriangleMesh.h"
#include "GuHeightField.h"
#include "GuTetrahedronMesh.h"
using namespace physx;
using namespace Gu;
using namespace Cm;
using namespace Sc;
static PX_FORCE_INLINE Gu::ConvexMesh& getConvexMesh(PxConvexMesh* pxcm)
{
return *static_cast<Gu::ConvexMesh*>(pxcm);
}
// PT: TODO: optimize all these data copies
void GeometryUnion::set(const PxGeometry& g)
{
// PT: preserve this field that can be used by higher-level code to store useful data
const float saved = reinterpret_cast<const PxGeometry&>(mGeometry).mTypePadding;
switch(g.getType())
{
case PxGeometryType::eBOX:
{
reinterpret_cast<PxBoxGeometry&>(mGeometry) = static_cast<const PxBoxGeometry&>(g);
}
break;
case PxGeometryType::eCAPSULE:
{
reinterpret_cast<PxCapsuleGeometry&>(mGeometry) = static_cast<const PxCapsuleGeometry&>(g);
}
break;
case PxGeometryType::eSPHERE:
{
reinterpret_cast<PxSphereGeometry&>(mGeometry) = static_cast<const PxSphereGeometry&>(g);
reinterpret_cast<PxCapsuleGeometry&>(mGeometry).halfHeight = 0.0f; //AM: make sphere geometry also castable as a zero height capsule.
}
break;
case PxGeometryType::ePLANE:
{
reinterpret_cast<PxPlaneGeometry&>(mGeometry) = static_cast<const PxPlaneGeometry&>(g);
}
break;
case PxGeometryType::eCONVEXMESH:
{
reinterpret_cast<PxConvexMeshGeometry&>(mGeometry) = static_cast<const PxConvexMeshGeometry&>(g);
reinterpret_cast<PxConvexMeshGeometryLL&>(mGeometry).gpuCompatible = ::getConvexMesh(get<PxConvexMeshGeometryLL>().convexMesh).isGpuCompatible();
}
break;
case PxGeometryType::ePARTICLESYSTEM:
{
reinterpret_cast<PxParticleSystemGeometry&>(mGeometry) = static_cast<const PxParticleSystemGeometry&>(g);
reinterpret_cast<PxParticleSystemGeometryLL&>(mGeometry).materialsLL = MaterialIndicesStruct();
}
break;
case PxGeometryType::eTRIANGLEMESH:
{
reinterpret_cast<PxTriangleMeshGeometry&>(mGeometry) = static_cast<const PxTriangleMeshGeometry&>(g);
reinterpret_cast<PxTriangleMeshGeometryLL&>(mGeometry).materialsLL = MaterialIndicesStruct();
}
break;
case PxGeometryType::eTETRAHEDRONMESH:
{
reinterpret_cast<PxTetrahedronMeshGeometry&>(mGeometry) = static_cast<const PxTetrahedronMeshGeometry&>(g);
reinterpret_cast<PxTetrahedronMeshGeometryLL&>(mGeometry).materialsLL = MaterialIndicesStruct();
}
break;
case PxGeometryType::eHEIGHTFIELD:
{
reinterpret_cast<PxHeightFieldGeometry&>(mGeometry) = static_cast<const PxHeightFieldGeometry&>(g);
reinterpret_cast<PxHeightFieldGeometryLL&>(mGeometry).materialsLL = MaterialIndicesStruct();
}
break;
case PxGeometryType::eHAIRSYSTEM:
{
reinterpret_cast<PxHairSystemGeometry&>(mGeometry) = static_cast<const PxHairSystemGeometry&>(g);
}
break;
case PxGeometryType::eCUSTOM:
{
reinterpret_cast<PxCustomGeometry&>(mGeometry) = static_cast<const PxCustomGeometry&>(g);
}
break;
case PxGeometryType::eGEOMETRY_COUNT:
case PxGeometryType::eINVALID:
PX_ALWAYS_ASSERT_MESSAGE("geometry type not handled");
break;
}
reinterpret_cast<PxGeometry&>(mGeometry).mTypePadding = saved;
}
static PxConvexMeshGeometryLL extendForLL(const PxConvexMeshGeometry& hlGeom)
{
PxConvexMeshGeometryLL llGeom;
static_cast<PxConvexMeshGeometry&>(llGeom) = hlGeom;
llGeom.gpuCompatible = hlGeom.convexMesh->isGpuCompatible();
return llGeom;
}
static PxTriangleMeshGeometryLL extendForLL(const PxTriangleMeshGeometry& hlGeom)
{
PxTriangleMeshGeometryLL llGeom;
static_cast<PxTriangleMeshGeometry&>(llGeom) = hlGeom;
llGeom.materialsLL = static_cast<const PxTriangleMeshGeometryLL&>(hlGeom).materialsLL;
return llGeom;
}
static PxHeightFieldGeometryLL extendForLL(const PxHeightFieldGeometry& hlGeom)
{
PxHeightFieldGeometryLL llGeom;
static_cast<PxHeightFieldGeometry&>(llGeom) = hlGeom;
llGeom.materialsLL = static_cast<const PxHeightFieldGeometryLL&>(hlGeom).materialsLL;
return llGeom;
}
ShapeCore::ShapeCore(const PxGeometry& geometry, PxShapeFlags shapeFlags, const PxU16* materialIndices, PxU16 materialCount, bool isExclusive,
PxShapeCoreFlag::Enum softOrClothFlags) :
mExclusiveSim(NULL)
{
mCore.mShapeCoreFlags |= PxShapeCoreFlag::eOWNS_MATERIAL_IDX_MEMORY;
if(isExclusive)
mCore.mShapeCoreFlags |= PxShapeCoreFlag::eIS_EXCLUSIVE;
mCore.mShapeCoreFlags |= softOrClothFlags;
PX_ASSERT(materialCount > 0);
const PxTolerancesScale& scale = Physics::getInstance().getTolerancesScale();
mCore.mGeometry.set(geometry);
mCore.setTransform(PxTransform(PxIdentity));
mCore.mContactOffset = 0.02f * scale.length;
mCore.mRestOffset = 0.0f;
mCore.mTorsionalRadius = 0.0f;
mCore.mMinTorsionalPatchRadius = 0.0f;
mCore.mShapeFlags = shapeFlags;
setMaterialIndices(materialIndices, materialCount);
}
// PX_SERIALIZATION
ShapeCore::ShapeCore(const PxEMPTY) :
mSimulationFilterData (PxEmpty),
mCore (PxEmpty),
mExclusiveSim (NULL)
{
mCore.mShapeCoreFlags.clear(PxShapeCoreFlag::eOWNS_MATERIAL_IDX_MEMORY);
}
//~PX_SERIALIZATION
static PX_FORCE_INLINE const MaterialIndicesStruct* getMaterials(const GeometryUnion& gu)
{
const PxGeometryType::Enum type = gu.getType();
if(type == PxGeometryType::eTRIANGLEMESH)
return &gu.get<PxTriangleMeshGeometryLL>().materialsLL;
else if(type == PxGeometryType::eHEIGHTFIELD)
return &gu.get<PxHeightFieldGeometryLL>().materialsLL;
else if(type == PxGeometryType::eTETRAHEDRONMESH)
return &gu.get<PxTetrahedronMeshGeometryLL>().materialsLL;
else if(type == PxGeometryType::ePARTICLESYSTEM)
return &gu.get<PxParticleSystemGeometryLL>().materialsLL;
else
return NULL;
}
ShapeCore::~ShapeCore()
{
if(mCore.mShapeCoreFlags.isSet(PxShapeCoreFlag::eOWNS_MATERIAL_IDX_MEMORY))
{
MaterialIndicesStruct* materialsLL = const_cast<MaterialIndicesStruct*>(getMaterials(mCore.mGeometry));
if(materialsLL)
materialsLL->deallocate();
}
}
PxU16 Sc::ShapeCore::getNbMaterialIndices() const
{
const MaterialIndicesStruct* materialsLL = getMaterials(mCore.mGeometry);
return materialsLL ? materialsLL->numIndices : 1;
}
const PxU16* Sc::ShapeCore::getMaterialIndices() const
{
const MaterialIndicesStruct* materialsLL = getMaterials(mCore.mGeometry);
return materialsLL ? materialsLL->indices : &mCore.mMaterialIndex;
}
PX_FORCE_INLINE void setMaterialsHelper(MaterialIndicesStruct& materials, const PxU16* materialIndices, PxU16 materialIndexCount, PxShapeCoreFlags& shapeCoreFlags)
{
if(materials.numIndices < materialIndexCount)
{
if(materials.indices && shapeCoreFlags.isSet(PxShapeCoreFlag::eOWNS_MATERIAL_IDX_MEMORY))
materials.deallocate();
materials.allocate(materialIndexCount);
shapeCoreFlags |= PxShapeCoreFlag::eOWNS_MATERIAL_IDX_MEMORY;
}
PxMemCopy(materials.indices, materialIndices, sizeof(PxU16)*materialIndexCount);
materials.numIndices = materialIndexCount;
}
void ShapeCore::setMaterialIndices(const PxU16* materialIndices, PxU16 materialIndexCount)
{
mCore.mMaterialIndex = materialIndices[0];
MaterialIndicesStruct* materialsLL = const_cast<MaterialIndicesStruct*>(getMaterials(mCore.mGeometry));
if(materialsLL)
setMaterialsHelper(*materialsLL, materialIndices, materialIndexCount, mCore.mShapeCoreFlags);
}
void ShapeCore::setGeometry(const PxGeometry& geom)
{
const PxGeometryType::Enum newGeomType = geom.getType();
// copy material related data to restore it after the new geometry has been set
MaterialIndicesStruct materials;
PX_ASSERT(materials.numIndices == 0);
const MaterialIndicesStruct* materialsLL = getMaterials(mCore.mGeometry);
if(materialsLL)
materials = *materialsLL;
mCore.mGeometry.set(geom);
if((newGeomType == PxGeometryType::eTRIANGLEMESH) || (newGeomType == PxGeometryType::eHEIGHTFIELD)
|| (newGeomType == PxGeometryType::eTETRAHEDRONMESH)|| (newGeomType == PxGeometryType::ePARTICLESYSTEM))
{
MaterialIndicesStruct* newMaterials = const_cast<MaterialIndicesStruct*>(getMaterials(mCore.mGeometry));
PX_ASSERT(newMaterials);
if(materials.numIndices != 0) // old type was mesh type
*newMaterials = materials;
else
{ // old type was non-mesh type
newMaterials->allocate(1);
*newMaterials->indices = mCore.mMaterialIndex;
mCore.mShapeCoreFlags |= PxShapeCoreFlag::eOWNS_MATERIAL_IDX_MEMORY;
}
}
else if((materials.numIndices != 0) && mCore.mShapeCoreFlags.isSet(PxShapeCoreFlag::eOWNS_MATERIAL_IDX_MEMORY))
{
// geometry changed to non-mesh type
materials.deallocate();
}
}
PxShape* ShapeCore::getPxShape()
{
return Sc::gOffsetTable.convertScShape2Px(this);
}
const PxShape* ShapeCore::getPxShape() const
{
return Sc::gOffsetTable.convertScShape2Px(this);
}
void ShapeCore::setContactOffset(const PxReal offset)
{
mCore.mContactOffset = offset;
ShapeSim* exclusiveSim = getExclusiveSim();
if (exclusiveSim)
{
exclusiveSim->getScene().updateContactDistance(exclusiveSim->getElementID(), offset);
}
}
// PX_SERIALIZATION
PX_FORCE_INLINE void exportExtraDataMaterials(PxSerializationContext& stream, const MaterialIndicesStruct& materials)
{
stream.alignData(PX_SERIAL_ALIGN);
stream.writeData(materials.indices, sizeof(PxU16)*materials.numIndices);
}
void ShapeCore::exportExtraData(PxSerializationContext& stream)
{
const MaterialIndicesStruct* materialsLL = getMaterials(mCore.mGeometry);
if(materialsLL)
exportExtraDataMaterials(stream, *materialsLL);
}
void ShapeCore::importExtraData(PxDeserializationContext& context)
{
MaterialIndicesStruct* materialsLL = const_cast<MaterialIndicesStruct*>(getMaterials(mCore.mGeometry));
if(materialsLL)
materialsLL->indices = context.readExtraData<PxU16, PX_SERIAL_ALIGN>(materialsLL->numIndices);
}
void ShapeCore::resolveMaterialReference(PxU32 materialTableIndex, PxU16 materialIndex)
{
if(materialTableIndex == 0)
mCore.mMaterialIndex = materialIndex;
MaterialIndicesStruct* materialsLL = const_cast<MaterialIndicesStruct*>(getMaterials(mCore.mGeometry));
if(materialsLL)
materialsLL->indices[materialTableIndex] = materialIndex;
}
void ShapeCore::resolveReferences(PxDeserializationContext& context)
{
// Resolve geometry pointers if needed
PxGeometry& geom = const_cast<PxGeometry&>(mCore.mGeometry.getGeometry());
switch(geom.getType())
{
case PxGeometryType::eCONVEXMESH:
{
PxConvexMeshGeometryLL& convexGeom = static_cast<PxConvexMeshGeometryLL&>(geom);
context.translatePxBase(convexGeom.convexMesh);
// update the hullData pointer
static_cast<PxConvexMeshGeometryLL&>(geom) = extendForLL(convexGeom);
}
break;
case PxGeometryType::eHEIGHTFIELD:
{
PxHeightFieldGeometryLL& hfGeom = static_cast<PxHeightFieldGeometryLL&>(geom);
context.translatePxBase(hfGeom.heightField);
// update hf pointers
static_cast<PxHeightFieldGeometryLL&>(geom) = extendForLL(hfGeom);
}
break;
case PxGeometryType::eTRIANGLEMESH:
{
PxTriangleMeshGeometryLL& meshGeom = static_cast<PxTriangleMeshGeometryLL&>(geom);
context.translatePxBase(meshGeom.triangleMesh);
// update mesh pointers
static_cast<PxTriangleMeshGeometryLL&>(geom) = extendForLL(meshGeom);
}
break;
case PxGeometryType::eTETRAHEDRONMESH:
case PxGeometryType::ePARTICLESYSTEM:
case PxGeometryType::eHAIRSYSTEM:
case PxGeometryType::eCUSTOM:
{
// implement
PX_ASSERT(0);
}
break;
case PxGeometryType::eSPHERE:
case PxGeometryType::ePLANE:
case PxGeometryType::eCAPSULE:
case PxGeometryType::eBOX:
case PxGeometryType::eGEOMETRY_COUNT:
case PxGeometryType::eINVALID:
break;
}
}
PxU32 ShapeCore::getInternalShapeIndex(PxsSimulationController& simulationController) const
{
return simulationController.getInternalShapeIndex(getCore());
}
//~PX_SERIALIZATION
| 13,438 | C++ | 31.858191 | 163 | 0.776678 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScParticleSystemShapeCore.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
#include "foundation/PxPreprocessor.h"
#if PX_SUPPORT_GPU_PHYSX
#include "foundation/PxErrorCallback.h"
#include "ScParticleSystemShapeCore.h"
#include "ScParticleSystemShapeSim.h"
#include "ScPhysics.h"
#include "PxvGlobals.h"
#include "PxPhysXGpu.h"
#include "cudamanager/PxCudaContextManager.h"
#include "CmVisualization.h"
using namespace physx;
using namespace Sc;
ParticleSystemShapeCore::ParticleSystemShapeCore()
: ShapeCore(PxEmpty)
, mGpuMemStat(0)
{
mSimulationFilterData = PxFilterData();
mCore = PxsShapeCore();
mCore.mShapeCoreFlags |= PxShapeCoreFlag::eOWNS_MATERIAL_IDX_MEMORY;
const PxTolerancesScale& scale = Physics::getInstance().getTolerancesScale();
mCore.setTransform(PxTransform(PxIdentity));
mCore.mContactOffset = 0.01f * scale.length;
mCore.mShapeFlags = 0;
mCore.mMaterialIndex = 0;
mCore.mMinTorsionalPatchRadius = 0.f;
mCore.mTorsionalRadius = 0.f;
mLLCore.sleepThreshold = 5e-5f * scale.speed * scale.speed;
mLLCore.wakeCounter = Physics::sWakeCounterOnCreation;
mLLCore.freezeThreshold = 5e-6f * scale.speed * scale.speed;
//TODO, make this dependend on scale?
//also set contact offset accordingly
mLLCore.restOffset = 0.1f;
const PxReal contactOffset = mLLCore.restOffset + 0.001f;
setContactOffset(contactOffset);
mLLCore.particleContactOffset = contactOffset;
mLLCore.solidRestOffset = mLLCore.restOffset;
mLLCore.fluidRestOffset = mLLCore.restOffset * 0.6f;
mLLCore.particleContactOffset_prev = FLT_MIN;
mLLCore.fluidRestOffset_prev = FLT_MIN;
mLLCore.fluidBoundaryDensityScale = 0.0f;
mLLCore.gridSizeX = 128;
mLLCore.gridSizeY = 128;
mLLCore.gridSizeZ = 128;
mLLCore.mFlags = PxParticleFlags(0);
mLLCore.solverIterationCounts = (1 << 8) | 4;
mLLCore.mWind = PxVec3(0.f);
//mLLCore.mNumUpdateSprings = 0;
mLLCore.solverType = PxParticleSolverType::ePBD;
// Sparse grid specific
mLLCore.sparseGridParams.setToDefault();
mLLCore.sparseGridParams.gridSpacing = 2.0f * mLLCore.particleContactOffset;
#if PX_ENABLE_FEATURES_UNDER_CONSTRUCTION
// FLIP specific
mLLCore.flipParams.setToDefault();
// MPM specific
mLLCore.mpmParams.setToDefault();
#endif
}
// PX_SERIALIZATION
ParticleSystemShapeCore::ParticleSystemShapeCore(const PxEMPTY)
: ShapeCore(PxEmpty)
{
}
ParticleSystemShapeCore::~ParticleSystemShapeCore()
{
}
void ParticleSystemShapeCore::addParticleBuffer(PxParticleBuffer* particleBuffer)
{
mLLCore.addParticleBuffer(particleBuffer);
}
void ParticleSystemShapeCore::removeParticleBuffer(PxParticleBuffer* particleBuffer)
{
mLLCore.removeParticleBuffer(particleBuffer);
}
void ParticleSystemShapeCore::initializeLLCoreData(PxU32 maxNeighborhood)
{
const PxTolerancesScale& scale = Sc::Physics::getInstance().getTolerancesScale();
mLLCore.mMaxNeighborhood = maxNeighborhood;
mLLCore.maxDepenetrationVelocity = 50.f * scale.length;
mLLCore.maxVelocity = 1e+6f;
}
#endif // PX_SUPPORT_GPU_PHYSX
| 4,481 | C++ | 31.014285 | 84 | 0.77929 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScMetaData.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "foundation/PxIO.h"
#include "ScActorCore.h"
#include "ScActorSim.h"
#include "ScBodyCore.h"
#include "ScStaticCore.h"
#include "ScConstraintCore.h"
#include "ScShapeCore.h"
#include "ScArticulationCore.h"
#include "ScArticulationJointCore.h"
#include "ScArticulationSensor.h"
#include "ScArticulationTendonCore.h"
#include "ScArticulationAttachmentCore.h"
#include "ScArticulationTendonJointCore.h"
using namespace physx;
using namespace Cm;
using namespace Sc;
///////////////////////////////////////////////////////////////////////////////
template <typename T> class PxMetaDataArray : public physx::PxArray<T>
{
public:
static PX_FORCE_INLINE physx::PxU32 getDataOffset() { return PX_OFFSET_OF(PxMetaDataArray<T>, mData); }
static PX_FORCE_INLINE physx::PxU32 getDataSize() { return PX_SIZE_OF(PxMetaDataArray<T>, mData); }
static PX_FORCE_INLINE physx::PxU32 getSizeOffset() { return PX_OFFSET_OF(PxMetaDataArray<T>, mSize); }
static PX_FORCE_INLINE physx::PxU32 getSizeSize() { return PX_SIZE_OF(PxMetaDataArray<T>, mSize); }
static PX_FORCE_INLINE physx::PxU32 getCapacityOffset() { return PX_OFFSET_OF(PxMetaDataArray<T>, mCapacity); }
static PX_FORCE_INLINE physx::PxU32 getCapacitySize() { return PX_SIZE_OF(PxMetaDataArray<T>, mCapacity); }
};
void Sc::ActorCore::getBinaryMetaData(PxOutputStream& stream)
{
PX_DEF_BIN_METADATA_TYPEDEF(stream, PxActorFlags, PxU8)
PX_DEF_BIN_METADATA_TYPEDEF(stream, PxDominanceGroup, PxU8)
PX_DEF_BIN_METADATA_TYPEDEF(stream, PxClientID, PxU8)
PX_DEF_BIN_METADATA_CLASS(stream, Sc::ActorCore)
PX_DEF_BIN_METADATA_ITEM(stream, Sc::ActorCore, ActorSim, mSim, PxMetaDataFlag::ePTR)
PX_DEF_BIN_METADATA_ITEM(stream, Sc::ActorCore, PxU32, mAggregateIDOwnerClient, 0)
PX_DEF_BIN_METADATA_ITEM(stream, Sc::ActorCore, PxActorFlags, mActorFlags, 0)
PX_DEF_BIN_METADATA_ITEM(stream, Sc::ActorCore, PxU8, mActorType, 0)
PX_DEF_BIN_METADATA_ITEM(stream, Sc::ActorCore, PxU8, mDominanceGroup, 0)
}
///////////////////////////////////////////////////////////////////////////////
static void getBinaryMetaData_PxsRigidCore(PxOutputStream& stream)
{
PX_DEF_BIN_METADATA_CLASS(stream, PxsRigidCore)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxTransform, body2World, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxRigidBodyFlags, mFlags, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxU16, solverIterationCounts, 0)
}
namespace
{
class ShadowPxsBodyCore : public PxsBodyCore
{
public:
static void getBinaryMetaData(PxOutputStream& stream)
{
PX_DEF_BIN_METADATA_CLASS(stream, ShadowPxsBodyCore)
PX_DEF_BIN_METADATA_BASE_CLASS(stream, ShadowPxsBodyCore, PxsRigidCore)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxTransform, body2Actor, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxReal, ccdAdvanceCoefficient, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxVec3, linearVelocity, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxReal, maxPenBias, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxVec3, angularVelocity, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxReal, contactReportThreshold, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxReal, maxAngularVelocitySq, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxReal, maxLinearVelocitySq, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxReal, linearDamping, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxReal, angularDamping, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxVec3, inverseInertia, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxReal, inverseMass, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxReal, maxContactImpulse, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxReal, sleepThreshold, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxReal, freezeThreshold, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxReal, wakeCounter, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxReal, solverWakeCounter, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxU32, numCountedInteractions, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxReal, offsetSlop, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxU8, isFastMoving, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxU8, disableGravity, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxU8, lockFlags, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsBodyCore, PxU8, fixedBaseLink, 0)
}
};
}
static void getBinaryMetaData_PxsBodyCore(PxOutputStream& stream)
{
getBinaryMetaData_PxsRigidCore(stream);
/* PX_DEF_BIN_METADATA_CLASS(stream, PxsBodyCore)
PX_DEF_BIN_METADATA_BASE_CLASS(stream, PxsBodyCore, PxsRigidCore)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxTransform, body2Actor, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxReal, ccdAdvanceCoefficient, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxVec3, linearVelocity, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxReal, maxPenBias, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxVec3, angularVelocity, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxReal, contactReportThreshold, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxReal, maxAngularVelocitySq, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxReal, maxLinearVelocitySq, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxReal, linearDamping, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxReal, angularDamping, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxVec3, inverseInertia, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxReal, inverseMass, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxReal, maxContactImpulse, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxReal, sleepThreshold, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxReal, freezeThreshold, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxReal, wakeCounter, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxReal, solverWakeCounter, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxsBodyCore, PxU32, numCountedInteractions, 0)*/
ShadowPxsBodyCore::getBinaryMetaData(stream);
PX_DEF_BIN_METADATA_TYPEDEF(stream, PxsBodyCore, ShadowPxsBodyCore)
}
/*
We need to fix the header deps by moving the API out of PhysXCore and into its own dir where other code can get to it.
[25.08.2010 18:34:57] Dilip Sequeira: In the meantime, I think it's Ok to include PxSDK.h, but you're right, we need to be very careful about include deps in that direction.
[25.08.2010 18:38:15] Dilip Sequeira: On the memory thing... PxsBodyCore has 28 bytes of padding at the end, for no reason. In addition, it has two words of padding after the velocity fields, to facilitate SIMD loads. But in fact, Vec3FromVec4 is fast enough such that unless you were using it in an inner loop (which we never are with PxsBodyCore) that padding isn't worth it.
[25.08.2010 18:38:58] Dilip Sequeira: So, we should drop the end-padding, and move the damping values to replace the velocity padding. This probably requires a bit of fixup in the places where we do SIMD writes to the velocity.
[25.08.2010 18:39:18] Dilip Sequeira: Then we're down to 92 bytes of data, and 4 bytes of padding I think.
[25.08.2010 18:50:41] Dilip Sequeira: The reason we don't want to put the sleep data there explicitly is that it isn't LL data so I'd rather not have it in an LL interface struct.
[25.08.2010 19:04:53] Gordon Yeoman nvidia: simd loads are faster when they are 16-byte aligned. I think the padding might be to ensure the second vector is also 16-byte aligned. We could drop the second 4-byte pad but dropping the 1st 4-byte pad will likely have performance implications.
[25.08.2010 19:06:22] Dilip Sequeira: We should still align the vec3s, as now - but we shouldn't use padding to do it, since there are a boatload of scalar data fields floating around in that struct too.
*/
void Sc::BodyCore::getBinaryMetaData(PxOutputStream& stream)
{
getBinaryMetaData_PxsBodyCore(stream);
PX_DEF_BIN_METADATA_TYPEDEF(stream, PxRigidBodyFlags, PxU16)
PX_DEF_BIN_METADATA_CLASS(stream, Sc::BodyCore)
PX_DEF_BIN_METADATA_BASE_CLASS(stream, Sc::BodyCore, Sc::RigidCore)
PX_DEF_BIN_METADATA_ITEM(stream, Sc::BodyCore, PxsBodyCore, mCore, 0)
}
///////////////////////////////////////////////////////////////////////////////
void Sc::ConstraintCore::getBinaryMetaData(PxOutputStream& stream)
{
PX_DEF_BIN_METADATA_TYPEDEF(stream, PxConstraintFlags, PxU16)
PX_DEF_BIN_METADATA_CLASS(stream, ConstraintCore)
PX_DEF_BIN_METADATA_ITEM(stream, ConstraintCore, PxConstraintFlags, mFlags, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ConstraintCore, PxU8, mIsDirty, 0)
PX_DEF_BIN_METADATA_ITEMS_AUTO(stream, ConstraintCore, PxU8, mPadding, PxMetaDataFlag::ePADDING)
PX_DEF_BIN_METADATA_ITEM(stream, ConstraintCore, PxVec3, mAppliedForce, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ConstraintCore, PxVec3, mAppliedTorque, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ConstraintCore, PxConstraintConnector, mConnector, PxMetaDataFlag::ePTR)
PX_DEF_BIN_METADATA_ITEM(stream, ConstraintCore, PxConstraintSolverPrep, mSolverPrep, PxMetaDataFlag::ePTR)
PX_DEF_BIN_METADATA_ITEM(stream, ConstraintCore, PxConstraintVisualize, mVisualize, PxMetaDataFlag::ePTR)
PX_DEF_BIN_METADATA_ITEM(stream, ConstraintCore, PxU32, mDataSize, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ConstraintCore, PxReal, mLinearBreakForce, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ConstraintCore, PxReal, mAngularBreakForce, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ConstraintCore, PxReal, mMinResponseThreshold, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ConstraintCore, ConstraintSim, mSim, PxMetaDataFlag::ePTR)
}
///////////////////////////////////////////////////////////////////////////////
void Sc::RigidCore::getBinaryMetaData(PxOutputStream& stream)
{
PX_DEF_BIN_METADATA_CLASS(stream, Sc::RigidCore)
PX_DEF_BIN_METADATA_BASE_CLASS(stream, Sc::RigidCore, Sc::ActorCore)
}
///////////////////////////////////////////////////////////////////////////////
void Sc::StaticCore::getBinaryMetaData(PxOutputStream& stream)
{
PX_DEF_BIN_METADATA_CLASS(stream, Sc::StaticCore)
PX_DEF_BIN_METADATA_BASE_CLASS(stream, Sc::StaticCore, Sc::RigidCore)
PX_DEF_BIN_METADATA_ITEM(stream, Sc::StaticCore, PxsRigidCore, mCore, 0)
}
///////////////////////////////////////////////////////////////////////////////
static void getBinaryMetaData_PxFilterData(PxOutputStream& stream)
{
PX_DEF_BIN_METADATA_CLASS(stream, PxFilterData)
PX_DEF_BIN_METADATA_ITEM(stream, PxFilterData, PxU32, word0, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxFilterData, PxU32, word1, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxFilterData, PxU32, word2, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxFilterData, PxU32, word3, 0)
}
namespace
{
class ShadowPxsShapeCore : public PxsShapeCore
{
public:
static void getBinaryMetaData(PxOutputStream& stream)
{
PX_DEF_BIN_METADATA_CLASS(stream, ShadowPxsShapeCore)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsShapeCore, PxTransform, mTransform, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsShapeCore, GeometryUnion, mGeometry, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsShapeCore, PxReal, mContactOffset, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsShapeCore, PxShapeFlags, mShapeFlags, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsShapeCore, PxShapeCoreFlags, mShapeCoreFlags, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsShapeCore, PxU16, mMaterialIndex, PxMetaDataFlag::eHANDLE)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsShapeCore, PxReal, mRestOffset, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsShapeCore, PxReal, mTorsionalRadius, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShadowPxsShapeCore, PxReal, mMinTorsionalPatchRadius, 0)
}
};
}
static void getBinaryMetaData_PxsShapeCore(PxOutputStream& stream)
{
ShadowPxsShapeCore::getBinaryMetaData(stream);
PX_DEF_BIN_METADATA_TYPEDEF(stream, PxsShapeCore, ShadowPxsShapeCore)
}
void Sc::ShapeCore::getBinaryMetaData(PxOutputStream& stream)
{
getBinaryMetaData_PxFilterData(stream);
getBinaryMetaData_PxsShapeCore(stream);
PX_DEF_BIN_METADATA_TYPEDEF(stream, PxShapeFlags, PxU8)
PX_DEF_BIN_METADATA_TYPEDEF(stream, PxShapeCoreFlags, PxU8)
PX_DEF_BIN_METADATA_CLASS(stream, ShapeCore)
PX_DEF_BIN_METADATA_ITEM(stream, ShapeCore, PxFilterData, mSimulationFilterData, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShapeCore, PxsShapeCore, mCore, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ShapeCore, ShapeSim, mExclusiveSim, PxMetaDataFlag::ePTR)
PX_DEF_BIN_METADATA_ITEM(stream, ShapeCore, char, mName, PxMetaDataFlag::ePTR)
PX_DEF_BIN_METADATA_EXTRA_NAME(stream, ShapeCore, mName, 0)
}
///////////////////////////////////////////////////////////////////////////////
static void getBinaryMetaData_ArticulationCore(PxOutputStream& stream)
{
PX_DEF_BIN_METADATA_CLASS(stream, Dy::ArticulationCore)
PX_DEF_BIN_METADATA_TYPEDEF(stream, PxArticulationFlags, PxU8)
PX_DEF_BIN_METADATA_ITEM(stream, Dy::ArticulationCore, PxU16, solverIterationCounts, 0)
PX_DEF_BIN_METADATA_ITEM(stream, Dy::ArticulationCore, PxArticulationFlags, flags, 0)
PX_DEF_BIN_METADATA_ITEM(stream, Dy::ArticulationCore, PxReal, sleepThreshold, 0)
PX_DEF_BIN_METADATA_ITEM(stream, Dy::ArticulationCore, PxReal, freezeThreshold, 0)
PX_DEF_BIN_METADATA_ITEM(stream, Dy::ArticulationCore, PxReal, wakeCounter, 0)
PX_DEF_BIN_METADATA_ITEM(stream, Dy::ArticulationCore, PxReal, gpuRemapIndex, 0)
PX_DEF_BIN_METADATA_ITEM(stream, Dy::ArticulationCore, PxReal, maxLinearVelocity, 0)
PX_DEF_BIN_METADATA_ITEM(stream, Dy::ArticulationCore, PxReal, maxAngularVelocity, 0)
}
void Sc::ArticulationCore::getBinaryMetaData(PxOutputStream& stream)
{
getBinaryMetaData_ArticulationCore(stream);
PX_DEF_BIN_METADATA_CLASS(stream, ArticulationCore)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationCore, ArticulationSim, mSim, PxMetaDataFlag::ePTR)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationCore, Dy::ArticulationCore, mCore, 0)
}
void Sc::ArticulationSensorCore::getBinaryMetaData(PxOutputStream& stream)
{
PX_DEF_BIN_METADATA_CLASS(stream, ArticulationSensorCore)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationSensorCore, ArticulationSensorSim, mSim, PxMetaDataFlag::ePTR)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationSensorCore, PxTransform, mRelativePose, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationSensorCore, PxU16, mFlags, 0)
}
void Sc::ArticulationAttachmentCore::getBinaryMetaData(PxOutputStream& stream)
{
PX_DEF_BIN_METADATA_CLASS(stream, ArticulationAttachmentCore)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationAttachmentCore, PxVec3, mRelativeOffset, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationAttachmentCore, ArticulationAttachmentCore, mParent, PxMetaDataFlag::ePTR)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationAttachmentCore, PxReal, mLowLimit, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationAttachmentCore, PxReal, mHighLimit, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationAttachmentCore, PxReal, mRestLength, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationAttachmentCore, PxReal, mCoefficient, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationAttachmentCore, PxU32, mLLLinkIndex, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationAttachmentCore, PxU32, mAttachmentIndex, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationAttachmentCore, ArticulationSpatialTendonSim, mTendonSim, PxMetaDataFlag::ePTR)
}
void Sc::ArticulationTendonCore::getBinaryMetaData(PxOutputStream& stream)
{
PX_DEF_BIN_METADATA_CLASS(stream, ArticulationTendonCore)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationTendonCore, PxReal, mStiffness, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationTendonCore, PxReal, mDamping, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationTendonCore, PxReal, mOffset, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationTendonCore, PxReal, mLimitStiffness, 0)
}
void Sc::ArticulationSpatialTendonCore::getBinaryMetaData(PxOutputStream& stream)
{
PX_DEF_BIN_METADATA_CLASS(stream, ArticulationSpatialTendonCore)
PX_DEF_BIN_METADATA_BASE_CLASS(stream, ArticulationSpatialTendonCore, ArticulationTendonCore)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationSpatialTendonCore, ArticulationSpatialTendonSim, mSim, PxMetaDataFlag::ePTR)
}
void Sc::ArticulationFixedTendonCore::getBinaryMetaData(PxOutputStream& stream)
{
PX_DEF_BIN_METADATA_CLASS(stream, ArticulationFixedTendonCore)
PX_DEF_BIN_METADATA_BASE_CLASS(stream, ArticulationFixedTendonCore, ArticulationTendonCore)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationFixedTendonCore, PxReal, mLowLimit, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationFixedTendonCore, PxReal, mHighLimit, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationFixedTendonCore, PxReal, mRestLength, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationFixedTendonCore, ArticulationFixedTendonSim, mSim, PxMetaDataFlag::ePTR)
}
void Sc::ArticulationTendonJointCore::getBinaryMetaData(PxOutputStream& stream)
{
PX_DEF_BIN_METADATA_TYPEDEF(stream, PxArticulationAxis, PxU32)
PX_DEF_BIN_METADATA_CLASS(stream, ArticulationTendonJointCore)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationTendonJointCore, PxArticulationAxis, axis, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationTendonJointCore, PxReal, coefficient, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationTendonJointCore, PxReal, recipCoefficient, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationTendonJointCore, PxU32, mLLLinkIndex, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationTendonJointCore, ArticulationTendonJointCore, mParent, PxMetaDataFlag::ePTR)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationTendonJointCore, PxU32, mLLTendonJointIndex, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationTendonJointCore, ArticulationFixedTendonSim, mTendonSim, PxMetaDataFlag::ePTR)
}
///////////////////////////////////////////////////////////////////////////////
static void getBinaryMetaData_ArticulationLimit(PxOutputStream& stream)
{
PX_DEF_BIN_METADATA_CLASS(stream, PxArticulationLimit)
PX_DEF_BIN_METADATA_ITEM(stream, PxArticulationLimit, PxReal, low, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxArticulationLimit, PxReal, high, 0)
}
static void getBinaryMetaData_ArticulationDrive(PxOutputStream& stream)
{
PX_DEF_BIN_METADATA_TYPEDEF(stream, PxArticulationDriveType::Enum, PxU32)
PX_DEF_BIN_METADATA_CLASS(stream, PxArticulationDrive)
PX_DEF_BIN_METADATA_ITEM(stream, PxArticulationDrive, PxReal, stiffness, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxArticulationDrive, PxReal, damping, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxArticulationDrive, PxReal, maxForce, 0)
PX_DEF_BIN_METADATA_ITEM(stream, PxArticulationDrive, PxArticulationDriveType::Enum, driveType, 0)
}
static void getBinaryMetaData_ArticulationJointCore(PxOutputStream& stream)
{
getBinaryMetaData_ArticulationLimit(stream);
getBinaryMetaData_ArticulationDrive(stream);
PX_DEF_BIN_METADATA_CLASS(stream, Dy::ArticulationJointCore)
PX_DEF_BIN_METADATA_TYPEDEF(stream, ArticulationJointCoreDirtyFlags, PxU8)
PX_DEF_BIN_METADATA_ITEM(stream, Dy::ArticulationJointCore, PxTransform, parentPose, 0)
PX_DEF_BIN_METADATA_ITEM(stream, Dy::ArticulationJointCore, PxTransform, childPose, 0)
PX_DEF_BIN_METADATA_ITEMS_AUTO(stream, Dy::ArticulationJointCore, PxArticulationLimit, limits, 0)
PX_DEF_BIN_METADATA_ITEMS_AUTO(stream, Dy::ArticulationJointCore, PxArticulationDrive, drives, 0)
PX_DEF_BIN_METADATA_ITEMS_AUTO(stream, Dy::ArticulationJointCore, PxReal, targetP, 0)
PX_DEF_BIN_METADATA_ITEMS_AUTO(stream, Dy::ArticulationJointCore, PxReal, targetV, 0)
PX_DEF_BIN_METADATA_ITEMS_AUTO(stream, Dy::ArticulationJointCore, PxReal, armature, 0)
PX_DEF_BIN_METADATA_ITEMS_AUTO(stream, Dy::ArticulationJointCore, PxReal, jointPos, 0)
PX_DEF_BIN_METADATA_ITEMS_AUTO(stream, Dy::ArticulationJointCore, PxReal, jointVel, 0)
PX_DEF_BIN_METADATA_ITEM(stream, Dy::ArticulationJointCore, PxReal, frictionCoefficient, 0)
PX_DEF_BIN_METADATA_ITEMS_AUTO(stream, Dy::ArticulationJointCore, PxU8, dofIds, 0)
PX_DEF_BIN_METADATA_ITEMS_AUTO(stream, Dy::ArticulationJointCore, PxU8, motion, 0)
PX_DEF_BIN_METADATA_ITEMS_AUTO(stream, Dy::ArticulationJointCore, PxU8, invDofIds, 0)
PX_DEF_BIN_METADATA_ITEM(stream, Dy::ArticulationJointCore, PxReal, maxJointVelocity, 0)
PX_DEF_BIN_METADATA_ITEM(stream, Dy::ArticulationJointCore, ArticulationJointCoreDirtyFlags, jointDirtyFlag, 0)
PX_DEF_BIN_METADATA_ITEM(stream, Dy::ArticulationJointCore, PxU32, jointOffset, 0)
PX_DEF_BIN_METADATA_ITEM(stream, Dy::ArticulationJointCore, PxU8, jointType, 0)
}
//
//static void getBinaryMetaData_ArticulationJointCore(PxOutputStream& stream)
//{
// getBinaryMetaData_ArticulationJointCoreBase(stream);
// PX_DEF_BIN_METADATA_CLASS(stream, Dy::ArticulationJointCore)
// PX_DEF_BIN_METADATA_BASE_CLASS(stream, Dy::ArticulationJointCore, Dy::ArticulationJointCoreBase)
//}
void Sc::ArticulationJointCore::getBinaryMetaData(PxOutputStream& stream)
{
getBinaryMetaData_ArticulationJointCore(stream);
PX_DEF_BIN_METADATA_CLASS(stream, ArticulationJointCore)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationJointCore, ArticulationJointSim, mSim, PxMetaDataFlag::ePTR)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationJointCore, Dy::ArticulationJointCore, mCore, 0)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationJointCore, Dy::ArticulationCore, mArticulation, PxMetaDataFlag::ePTR)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationJointCore, PxArticulationJointReducedCoordinate, mRootType, PxMetaDataFlag::ePTR)
PX_DEF_BIN_METADATA_ITEM(stream, ArticulationJointCore, PxU32, mLLLinkIndex, 0)
}
///////////////////////////////////////////////////////////////////////////////
/*
#define PX_DEF_BIN_METADATA_ARRAY(stream, Class, type, array) \
{ PxMetaDataEntry tmp = {"void", #array".mData", PxU32(PX_OFFSET_OF(Class, array)) + PxMetaDataArray<type>::getDataOffset(), PxMetaDataArray<type>::getDataSize(), 1, 0, PxMetaDataFlag::ePTR, 0}; PX_STORE_METADATA(stream, tmp); } \
{ PxMetaDataEntry tmp = {"PxU32", #array".mSize", PxU32(PX_OFFSET_OF(Class, array)) + PxMetaDataArray<type>::getSizeOffset(), PxMetaDataArray<type>::getSizeSize(), 1, 0, 0, 0}; PX_STORE_METADATA(stream, tmp); } \
{ PxMetaDataEntry tmp = {"PxU32", #array".mCapacity", PxU32(PX_OFFSET_OF(Class, array)) + PxMetaDataArray<type>::getCapacityOffset(), PxMetaDataArray<type>::getCapacitySize(), 1, 0, PxMetaDataFlag::eCOUNT_MASK_MSB, 0}; PX_STORE_METADATA(stream, tmp); } \
{ PxMetaDataEntry tmp = {#type, 0, PxU32(PX_OFFSET_OF(Class, array)) + PxMetaDataArray<type>::getSizeOffset(), PxMetaDataArray<type>::getSizeSize(), 0, 0, PxMetaDataFlag::eEXTRA_DATA, 0}; PX_STORE_METADATA(stream, tmp); }
*/
///////////////////////////////////////////////////////////////////////////////
void MaterialIndicesStruct::getBinaryMetaData(PxOutputStream& stream)
{
PX_DEF_BIN_METADATA_CLASS(stream, MaterialIndicesStruct)
PX_DEF_BIN_METADATA_ITEM(stream, MaterialIndicesStruct, PxU16, indices, PxMetaDataFlag::ePTR)
PX_DEF_BIN_METADATA_ITEM(stream, MaterialIndicesStruct, PxU16, numIndices, 0)
PX_DEF_BIN_METADATA_ITEM(stream, MaterialIndicesStruct, PxU16, pad, PxMetaDataFlag::ePADDING)
PX_DEF_BIN_METADATA_ITEM(stream, MaterialIndicesStruct, PxU32, gpuRemapId, 0)
//------ Extra-data ------
// indices
PX_DEF_BIN_METADATA_EXTRA_ITEMS(stream, MaterialIndicesStruct, PxU16, indices, numIndices, PxMetaDataFlag::eHANDLE, PX_SERIAL_ALIGN)
}
///////////////////////////////////////////////////////////////////////////////
void GeometryUnion::getBinaryMetaData(PxOutputStream& stream)
{
PX_DEF_BIN_METADATA_TYPEDEF(stream, PxGeometryType::Enum, PxU32)
// The various PxGeometry classes are all public, so I can't really put the meta-data function in there. And then
// I can't access their protected members. So we use the same trick as for the ShapeContainer
class ShadowConvexMeshGeometry : public PxConvexMeshGeometryLL
{
public:
static void getBinaryMetaData(PxOutputStream& stream_)
{
PX_DEF_BIN_METADATA_TYPEDEF(stream_, PxConvexMeshGeometryFlags, PxU8)
PX_DEF_BIN_METADATA_CLASS(stream_, ShadowConvexMeshGeometry)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowConvexMeshGeometry, PxGeometryType::Enum, mType, 0)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowConvexMeshGeometry, float, mTypePadding, 0)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowConvexMeshGeometry, PxMeshScale, scale, 0)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowConvexMeshGeometry, PxConvexMesh, convexMesh, PxMetaDataFlag::ePTR)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowConvexMeshGeometry, PxConvexMeshGeometryFlags, meshFlags, 0)
PX_DEF_BIN_METADATA_ITEMS(stream_, ShadowConvexMeshGeometry, PxU8, paddingFromFlags, PxMetaDataFlag::ePADDING, 3)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowConvexMeshGeometry, bool, gpuCompatible, 0)
}
};
ShadowConvexMeshGeometry::getBinaryMetaData(stream);
PX_DEF_BIN_METADATA_TYPEDEF(stream, PxConvexMeshGeometryLL, ShadowConvexMeshGeometry)
/////////////////
class ShadowTriangleMeshGeometry : public PxTriangleMeshGeometryLL
{
public:
static void getBinaryMetaData(PxOutputStream& stream_)
{
PX_DEF_BIN_METADATA_TYPEDEF(stream_, PxMeshGeometryFlags, PxU8)
PX_DEF_BIN_METADATA_CLASS(stream_, ShadowTriangleMeshGeometry)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowTriangleMeshGeometry, PxGeometryType::Enum, mType, 0)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowTriangleMeshGeometry, float, mTypePadding, 0)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowTriangleMeshGeometry, PxMeshScale, scale, 0)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowTriangleMeshGeometry, PxMeshGeometryFlags, meshFlags, 0)
PX_DEF_BIN_METADATA_ITEMS(stream_, ShadowTriangleMeshGeometry, PxU8, paddingFromFlags, PxMetaDataFlag::ePADDING, 3)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowTriangleMeshGeometry, PxTriangleMesh, triangleMesh, PxMetaDataFlag::ePTR)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowTriangleMeshGeometry, MaterialIndicesStruct, materialsLL, 0)
}
};
ShadowTriangleMeshGeometry::getBinaryMetaData(stream);
PX_DEF_BIN_METADATA_TYPEDEF(stream,PxTriangleMeshGeometryLL, ShadowTriangleMeshGeometry)
/////////////////
class ShadowHeightFieldGeometry : public PxHeightFieldGeometryLL
{
public:
static void getBinaryMetaData(PxOutputStream& stream_)
{
PX_DEF_BIN_METADATA_CLASS(stream_, ShadowHeightFieldGeometry)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowHeightFieldGeometry, PxGeometryType::Enum, mType, 0)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowHeightFieldGeometry, float, mTypePadding, 0)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowHeightFieldGeometry, PxHeightField, heightField, PxMetaDataFlag::ePTR)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowHeightFieldGeometry, PxReal, heightScale, 0)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowHeightFieldGeometry, PxReal, rowScale, 0)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowHeightFieldGeometry, PxReal, columnScale, 0)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowHeightFieldGeometry, PxMeshGeometryFlags, heightFieldFlags, 0)
PX_DEF_BIN_METADATA_ITEMS_AUTO(stream_, ShadowHeightFieldGeometry, PxU8, paddingFromFlags, PxMetaDataFlag::ePADDING)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowHeightFieldGeometry, MaterialIndicesStruct, materialsLL, 0)
}
};
ShadowHeightFieldGeometry::getBinaryMetaData(stream);
PX_DEF_BIN_METADATA_TYPEDEF(stream,PxHeightFieldGeometryLL, ShadowHeightFieldGeometry)
/////////////////
class ShadowPlaneGeometry : public PxPlaneGeometry
{
public:
static void getBinaryMetaData(PxOutputStream& stream_)
{
PX_DEF_BIN_METADATA_CLASS(stream_, ShadowPlaneGeometry)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowPlaneGeometry, PxGeometryType::Enum, mType, 0)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowPlaneGeometry, float, mTypePadding, 0)
}
};
ShadowPlaneGeometry::getBinaryMetaData(stream);
PX_DEF_BIN_METADATA_TYPEDEF(stream,PxPlaneGeometry, ShadowPlaneGeometry)
/////////////////
class ShadowSphereGeometry : public PxSphereGeometry
{
public:
static void getBinaryMetaData(PxOutputStream& stream_)
{
PX_DEF_BIN_METADATA_CLASS(stream_, ShadowSphereGeometry)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowSphereGeometry, PxGeometryType::Enum, mType, 0)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowSphereGeometry, float, mTypePadding, 0)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowSphereGeometry, PxReal, radius, 0)
}
};
ShadowSphereGeometry::getBinaryMetaData(stream);
PX_DEF_BIN_METADATA_TYPEDEF(stream, PxSphereGeometry, ShadowSphereGeometry)
/////////////////
class ShadowCapsuleGeometry : public PxCapsuleGeometry
{
public:
static void getBinaryMetaData(PxOutputStream& stream_)
{
PX_DEF_BIN_METADATA_CLASS(stream_, ShadowCapsuleGeometry)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowCapsuleGeometry, PxGeometryType::Enum, mType, 0)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowCapsuleGeometry, float, mTypePadding, 0)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowCapsuleGeometry, PxReal, radius, 0)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowCapsuleGeometry, PxReal, halfHeight, 0)
}
};
ShadowCapsuleGeometry::getBinaryMetaData(stream);
PX_DEF_BIN_METADATA_TYPEDEF(stream, PxCapsuleGeometry, ShadowCapsuleGeometry)
/////////////////
class ShadowBoxGeometry : public PxBoxGeometry
{
public:
static void getBinaryMetaData(PxOutputStream& stream_)
{
PX_DEF_BIN_METADATA_CLASS(stream_, ShadowBoxGeometry)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowBoxGeometry, PxGeometryType::Enum, mType, 0)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowBoxGeometry, float, mTypePadding, 0)
PX_DEF_BIN_METADATA_ITEM(stream_, ShadowBoxGeometry, PxVec3, halfExtents, 0)
}
};
ShadowBoxGeometry::getBinaryMetaData(stream);
PX_DEF_BIN_METADATA_TYPEDEF(stream, PxBoxGeometry, ShadowBoxGeometry)
/*
- geom union offset & size
- control type offset & size
- type-to-class mapping
*/
PX_DEF_BIN_METADATA_CLASS(stream, GeometryUnion)
PX_DEF_BIN_METADATA_UNION(stream, GeometryUnion, mGeometry)
PX_DEF_BIN_METADATA_UNION_TYPE(stream, GeometryUnion, PxSphereGeometry, PxGeometryType::eSPHERE)
PX_DEF_BIN_METADATA_UNION_TYPE(stream, GeometryUnion, PxPlaneGeometry, PxGeometryType::ePLANE)
PX_DEF_BIN_METADATA_UNION_TYPE(stream, GeometryUnion, PxCapsuleGeometry, PxGeometryType::eCAPSULE)
PX_DEF_BIN_METADATA_UNION_TYPE(stream, GeometryUnion, PxBoxGeometry, PxGeometryType::eBOX)
PX_DEF_BIN_METADATA_UNION_TYPE(stream, GeometryUnion, PxConvexMeshGeometryLL, PxGeometryType::eCONVEXMESH)
PX_DEF_BIN_METADATA_UNION_TYPE(stream, GeometryUnion, PxTriangleMeshGeometryLL,PxGeometryType::eTRIANGLEMESH)
PX_DEF_BIN_METADATA_UNION_TYPE(stream, GeometryUnion, PxHeightFieldGeometryLL, PxGeometryType::eHEIGHTFIELD)
}
| 32,907 | C++ | 51.6528 | 377 | 0.751664 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScVisualize.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScScene.h"
#include "ScNPhaseCore.h"
#include "ScShapeInteraction.h"
#include "ScConstraintSim.h"
#include "ScConstraintCore.h"
#include "CmVisualization.h"
using namespace physx;
using namespace Sc;
// PT: Sc-level visualization code has been moved to this dedicated file (like we did in NpDebugViz.cpp)
static void visualize(const ConstraintSim& sim, Cm::ConstraintImmediateVisualizer& viz, PxU32 flags, const PxTransform& idt)
{
ConstraintCore& core = sim.getCore();
if(!(core.getFlags() & PxConstraintFlag::eVISUALIZATION))
return;
const Dy::Constraint& llc = sim.getLowLevelConstraint();
PxsRigidBody* b0 = llc.body0;
PxsRigidBody* b1 = llc.body1;
const PxTransform& t0 = b0 ? b0->getPose() : idt;
const PxTransform& t1 = b1 ? b1->getPose() : idt;
core.getVisualize()(viz, llc.constantBlock, t0, t1, flags);
}
void Sc::ShapeInteraction::visualize(PxRenderOutput& out, PxsContactManagerOutputIterator& outputs,
float scale, float param_contactForce, float param_contactNormal, float param_contactError, float param_contactPoint)
{
if(mManager) // sleeping pairs have no contact points -> do not visualize
{
Sc::ActorSim* actorSim0 = &getShape0().getActor();
Sc::ActorSim* actorSim1 = &getShape1().getActor();
if(!actorSim0->isNonRigid() && !actorSim1->isNonRigid())
{
PxU32 offset;
PxU32 nextOffset = 0;
do
{
const void* contactPatches;
const void* contactPoints;
PxU32 contactDataSize;
PxU32 contactPointCount;
PxU32 contactPatchCount;
const PxReal* impulses;
offset = nextOffset;
nextOffset = getContactPointData(contactPatches, contactPoints, contactDataSize, contactPointCount, contactPatchCount, impulses, offset, outputs);
const PxU32* faceIndices = reinterpret_cast<const PxU32*>(impulses + contactPointCount);
PxContactStreamIterator iter(reinterpret_cast<const PxU8*>(contactPatches), reinterpret_cast<const PxU8*>(contactPoints), faceIndices, contactPatchCount, contactPointCount);
PxU32 i = 0;
while(iter.hasNextPatch())
{
iter.nextPatch();
while(iter.hasNextContact())
{
iter.nextContact();
if((param_contactForce != 0.0f) && impulses)
{
out << PxU32(PxDebugColor::eARGB_RED);
out.outputSegment(iter.getContactPoint(), iter.getContactPoint() + iter.getContactNormal() * (scale * param_contactForce * impulses[i]));
}
else if(param_contactNormal != 0.0f)
{
out << PxU32(PxDebugColor::eARGB_BLUE);
out.outputSegment(iter.getContactPoint(), iter.getContactPoint() + iter.getContactNormal() * (scale * param_contactNormal));
}
else if(param_contactError != 0.0f)
{
out << PxU32(PxDebugColor::eARGB_YELLOW);
out.outputSegment(iter.getContactPoint(), iter.getContactPoint() + iter.getContactNormal() * PxAbs(scale * param_contactError * PxMin(0.f, iter.getSeparation())));
}
if(param_contactPoint != 0.0f)
{
const PxReal s = scale * 0.1f;
const PxVec3& point = iter.getContactPoint();
//if (0) //temp debug to see identical contacts
// point.x += scale * 0.01f * (contactPointCount - i + 1);
out << PxU32(PxDebugColor::eARGB_RED);
out.outputSegment(point + PxVec3(-s, 0, 0), point + PxVec3(s, 0, 0));
out.outputSegment(point + PxVec3(0, -s, 0), point + PxVec3(0, s, 0));
out.outputSegment(point + PxVec3(0, 0, -s), point + PxVec3(0, 0, s));
}
i++;
}
}
} while (nextOffset != offset);
}
}
}
// Render objects before simulation starts
void Sc::Scene::visualizeStartStep()
{
PX_PROFILE_ZONE("Sim.visualizeStartStep", mContextId);
// Update from visualization parameters
if(mVisualizationParameterChanged)
{
mVisualizationParameterChanged = false;
// Update SIPs if visualization is enabled
if( getVisualizationParameter(PxVisualizationParameter::eCONTACT_POINT) || getVisualizationParameter(PxVisualizationParameter::eCONTACT_NORMAL) ||
getVisualizationParameter(PxVisualizationParameter::eCONTACT_ERROR) || getVisualizationParameter(PxVisualizationParameter::eCONTACT_FORCE))
mInternalFlags |= SceneInternalFlag::eSCENE_SIP_STATES_DIRTY_VISUALIZATION;
}
#if PX_ENABLE_DEBUG_VISUALIZATION
const PxReal scale = getVisualizationScale();
if(scale==0.0f)
{
// make sure visualization inside simulate was skipped
PX_ASSERT(getRenderBuffer().empty());
return; // early out if visualization scale is 0
}
PxRenderOutput out(getRenderBuffer());
if(getVisualizationParameter(PxVisualizationParameter::eCOLLISION_COMPOUNDS))
mAABBManager->visualize(out);
// Visualize joints
{
const float frameScale = scale * getVisualizationParameter(PxVisualizationParameter::eJOINT_LOCAL_FRAMES);
const float limitScale = scale * getVisualizationParameter(PxVisualizationParameter::eJOINT_LIMITS);
if(frameScale!=0.0f || limitScale!=0.0f)
{
Cm::ConstraintImmediateVisualizer viz(frameScale, limitScale, out);
PxU32 flags = 0;
if(frameScale!=0.0f)
flags |= PxConstraintVisualizationFlag::eLOCAL_FRAMES;
if(limitScale!=0.0f)
flags |= PxConstraintVisualizationFlag::eLIMITS;
const PxTransform idt(PxIdentity);
Sc::ConstraintCore*const * constraints = mConstraints.getEntries();
for(PxU32 i=0, size = mConstraints.size();i<size; i++)
{
ConstraintSim* sim = constraints[i]->getSim();
if(sim)
visualize(*sim, viz, flags, idt);
}
}
}
{
// PT: put common reads here to avoid doing them for each interaction
const PxReal param_contactForce = getVisualizationParameter(PxVisualizationParameter::eCONTACT_FORCE);
const PxReal param_contactNormal = getVisualizationParameter(PxVisualizationParameter::eCONTACT_NORMAL);
const PxReal param_contactError = getVisualizationParameter(PxVisualizationParameter::eCONTACT_ERROR);
const PxReal param_contactPoint = getVisualizationParameter(PxVisualizationParameter::eCONTACT_POINT);
if(param_contactForce!=0.0f || param_contactNormal!=0.0f || param_contactError!=0.0f || param_contactPoint!=0.0f)
{
PxsContactManagerOutputIterator outputs = mLLContext->getNphaseImplementationContext()->getContactManagerOutputs();
ElementSimInteraction** interactions = getActiveInteractions(InteractionType::eOVERLAP);
PxU32 nbActiveInteractions = getNbActiveInteractions(InteractionType::eOVERLAP);
while(nbActiveInteractions--)
static_cast<ShapeInteraction*>(*interactions++)->visualize( out, outputs,
scale, param_contactForce, param_contactNormal, param_contactError, param_contactPoint);
}
}
#else
PX_CATCH_UNDEFINED_ENABLE_DEBUG_VISUALIZATION
#endif
}
| 8,345 | C++ | 39.31884 | 177 | 0.731815 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScConstraintInteraction.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScConstraintInteraction.h"
#include "ScConstraintSim.h"
#include "ScBodySim.h"
#include "ScScene.h"
#include "PxsRigidBody.h"
#include "PxsSimpleIslandManager.h"
using namespace physx;
using namespace Sc;
ConstraintInteraction::ConstraintInteraction(ConstraintSim* constraint, RigidSim& r0, RigidSim& r1) :
Interaction (r0, r1, InteractionType::eCONSTRAINTSHADER, InteractionFlag::eCONSTRAINT),
mConstraint (constraint)
{
{
onActivate(NULL);
registerInActors();
}
BodySim* b0 = mConstraint->getBody(0);
BodySim* b1 = mConstraint->getBody(1);
if(b0)
b0->onConstraintAttach();
if(b1)
b1->onConstraintAttach();
IG::SimpleIslandManager* simpleIslandManager = getScene().getSimpleIslandManager();
mEdgeIndex = simpleIslandManager->addConstraint(&mConstraint->getLowLevelConstraint(), b0 ? b0->getNodeIndex() : PxNodeIndex(), b1 ? b1->getNodeIndex() : PxNodeIndex(), this);
}
ConstraintInteraction::~ConstraintInteraction()
{
PX_ASSERT(!readInteractionFlag(InteractionFlag::eIN_DIRTY_LIST));
PX_ASSERT(!getDirtyFlags());
PX_ASSERT(!mConstraint->readFlag(ConstraintSim::eCHECK_MAX_FORCE_EXCEEDED));
}
static PX_FORCE_INLINE void removeFromActiveBreakableList(ConstraintSim* constraint, Scene& s)
{
if(constraint->readFlag(ConstraintSim::eBREAKABLE | ConstraintSim::eCHECK_MAX_FORCE_EXCEEDED) == (ConstraintSim::eBREAKABLE | ConstraintSim::eCHECK_MAX_FORCE_EXCEEDED))
s.removeActiveBreakableConstraint(constraint);
}
void ConstraintInteraction::destroy()
{
setClean(true); // removes the pair from the dirty interaction list etc.
Scene& scene = getScene();
removeFromActiveBreakableList(mConstraint, scene);
if(mEdgeIndex != IG_INVALID_EDGE)
scene.getSimpleIslandManager()->removeConnection(mEdgeIndex);
mEdgeIndex = IG_INVALID_EDGE;
unregisterFromActors();
BodySim* b0 = mConstraint->getBody(0);
BodySim* b1 = mConstraint->getBody(1);
if(b0)
b0->onConstraintDetach(); // Note: Has to be done AFTER the interaction has unregistered from the actors
if(b1)
b1->onConstraintDetach(); // Note: Has to be done AFTER the interaction has unregistered from the actors
clearInteractionFlag(InteractionFlag::eIS_ACTIVE); // ensures that broken constraints do not go into the list of active breakable constraints anymore
}
void ConstraintInteraction::updateState()
{
PX_ASSERT(!mConstraint->isBroken());
PX_ASSERT(getDirtyFlags() & InteractionDirtyFlag::eBODY_KINEMATIC); // at the moment this should be the only reason for this method being called
// at least one of the bodies got switched from kinematic to dynamic. This will not have changed the sleep state of the interactions, so the
// constraint interactions are just marked dirty and processed as part of the dirty interaction update system.
//
// -> need to check whether to activate the constraint and whether constraint break testing
// is now necessary
//
// the transition from dynamic to kinematic will always trigger an onDeactivate() (because the body gets deactivated)
// and thus there is no need to consider that case here.
//
onActivate(NULL); // note: this will not activate if the necessary conditions are not met, so it can be called even if the pair has been deactivated again before the
// simulation step started
}
bool ConstraintInteraction::onActivate(void*)
{
PX_ASSERT(!mConstraint->isBroken());
BodySim* b0 = mConstraint->getBody(0);
BodySim* b1 = mConstraint->getBody(1);
const bool b0Vote = !b0 || b0->isActive();
const bool b1Vote = !b1 || b1->isActive();
const bool b0Dynamic = b0 && (!b0->isKinematic());
const bool b1Dynamic = b1 && (!b1->isKinematic());
//
// note: constraints between kinematics and kinematics/statics are always inactive and must not be activated
//
if((b0Vote || b1Vote) && (b0Dynamic || b1Dynamic))
{
raiseInteractionFlag(InteractionFlag::eIS_ACTIVE);
if(mConstraint->readFlag(ConstraintSim::eBREAKABLE | ConstraintSim::eCHECK_MAX_FORCE_EXCEEDED) == ConstraintSim::eBREAKABLE)
getScene().addActiveBreakableConstraint(mConstraint, this);
return true;
}
else
return false;
}
bool ConstraintInteraction::onDeactivate()
{
const BodySim* b0 = mConstraint->getBody(0);
const BodySim* b1 = mConstraint->getBody(1);
const bool b0Dynamic = b0 && (!b0->isKinematic());
const bool b1Dynamic = b1 && (!b1->isKinematic());
PX_ASSERT( (!b0 && b1 && !b1->isActive()) ||
(!b1 && b0 && !b0->isActive()) ||
((b0 && b1 && (!b0->isActive() || !b1->isActive()))) );
//
// note: constraints between kinematics and kinematics/statics should always get deactivated
//
if(((!b0 || !b0->isActive()) && (!b1 || !b1->isActive())) || (!b0Dynamic && !b1Dynamic))
{
removeFromActiveBreakableList(mConstraint, getScene());
clearInteractionFlag(InteractionFlag::eIS_ACTIVE);
return true;
}
else
return false;
}
| 6,538 | C++ | 37.017442 | 176 | 0.743194 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScActorSim.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-2023 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 SC_ACTOR_SIM_H
#define SC_ACTOR_SIM_H
#include "foundation/PxUserAllocated.h"
#include "CmPtrTable.h"
#include "CmUtils.h"
#include "PxActor.h"
#include "ScInteractionFlags.h"
#include "ScActorCore.h"
#include "PxsSimpleIslandManager.h"
#include "PxFiltering.h"
namespace physx
{
class PxActor;
namespace Sc
{
#define SC_NOT_IN_SCENE_INDEX 0xffffffff // the body is not in the scene yet
#define SC_NOT_IN_ACTIVE_LIST_INDEX 0xfffffffe // the body is in the scene but not in the active list
struct PxFilterObjectFlagEx : PxFilterObjectFlag
{
enum Enum
{
eRIGID_STATIC = eNEXT_FREE,
eRIGID_DYNAMIC = eNEXT_FREE<<1,
eNON_RIGID = eNEXT_FREE<<2,
eSOFTBODY = eNEXT_FREE<<3,
eFEMCLOTH = eNEXT_FREE<<4,
ePARTICLESYSTEM = eNEXT_FREE<<5,
eHAIRSYSTEM = eNEXT_FREE<<6,
eLAST = eHAIRSYSTEM
};
};
static const PxReal ScInternalWakeCounterResetValue = 20.0f*0.02f;
class Interaction;
class ElementSim;
class Scene;
class ShapeManager : public PxUserAllocated
{
public:
ShapeManager() {}
~ShapeManager() {}
PX_FORCE_INLINE PxU32 getNbElements() const
{
return mShapes.getCount();
}
PX_FORCE_INLINE ElementSim** getElements()
{
return reinterpret_cast<ElementSim**>(mShapes.getPtrs());
}
PX_FORCE_INLINE ElementSim*const* getElements() const
{
return reinterpret_cast<ElementSim*const*>(mShapes.getPtrs());
}
// void onElementAttach(ElementSim& element);
void onElementDetach(ElementSim& element);
Cm::PtrTable mShapes;
};
class ActorSim : public ShapeManager
{
friend class Scene; // the scene is allowed to set the scene array index
friend class Interaction;
PX_NOCOPY(ActorSim)
public:
enum InternalFlags
{
//BF_DISABLE_GRAVITY = 1 << 0, // Don't apply the scene's gravity
BF_HAS_STATIC_TOUCH = 1 << 1, // Set when a body is part of an island with static contacts. Needed to be able to recalculate adaptive force if this changes
BF_KINEMATIC_MOVED = 1 << 2, // Set when the kinematic was moved
BF_ON_DEATHROW = 1 << 3, // Set when the body is destroyed
BF_IS_IN_SLEEP_LIST = 1 << 4, // Set when the body is added to the list of bodies which were put to sleep
BF_IS_IN_WAKEUP_LIST = 1 << 5, // Set when the body is added to the list of bodies which were woken up
BF_SLEEP_NOTIFY = 1 << 6, // A sleep notification should be sent for this body (and not a wakeup event, even if the body is part of the woken list as well)
BF_WAKEUP_NOTIFY = 1 << 7, // A wake up notification should be sent for this body (and not a sleep event, even if the body is part of the sleep list as well)
BF_HAS_CONSTRAINTS = 1 << 8, // Set if the body has one or more constraints
BF_KINEMATIC_SETTLING = 1 << 9, // Set when the body was moved kinematically last frame
BF_KINEMATIC_SETTLING_2 = 1 << 10,
BF_KINEMATIC_MOVE_FLAGS = BF_KINEMATIC_MOVED | BF_KINEMATIC_SETTLING | BF_KINEMATIC_SETTLING_2, //Used to clear kinematic masks in 1 call
BF_KINEMATIC_SURFACE_VELOCITY = 1 << 11, //Set when the application calls setKinematicVelocity. Actor remains awake until application calls clearKinematicVelocity.
BF_IS_COMPOUND_RIGID = 1 << 12, // Set when the body is a compound actor, we dont want to set the sq bounds
// PT: WARNING: flags stored on 16-bits now.
};
ActorSim(Scene&, ActorCore&);
virtual ~ActorSim();
// Get the scene the actor resides in
PX_FORCE_INLINE Scene& getScene() const { return mScene; }
// Get the number of interactions connected to the actor
PX_FORCE_INLINE PxU32 getActorInteractionCount() const { return mInteractions.size(); }
// Get an iterator to the interactions connected to the actor
PX_FORCE_INLINE Interaction** getActorInteractions() const { return mInteractions.begin(); }
// Get the type ID of the actor
PX_FORCE_INLINE PxActorType::Enum getActorType() const { return mCore.getActorCoreType(); }
// Returns true if the actor is a dynamic rigid body (including articulation links)
PX_FORCE_INLINE PxU16 isDynamicRigid() const { return mFilterFlags & PxFilterObjectFlagEx::eRIGID_DYNAMIC; }
PX_FORCE_INLINE PxU16 isSoftBody() const { return mFilterFlags & PxFilterObjectFlagEx::eSOFTBODY; }
PX_FORCE_INLINE PxU16 isFEMCloth() const { return mFilterFlags & PxFilterObjectFlagEx::eFEMCLOTH; }
PX_FORCE_INLINE PxU16 isParticleSystem() const { return mFilterFlags & PxFilterObjectFlagEx::ePARTICLESYSTEM; }
PX_FORCE_INLINE PxU16 isHairSystem() const { return mFilterFlags & PxFilterObjectFlagEx::eHAIRSYSTEM; }
PX_FORCE_INLINE PxU16 isNonRigid() const { return mFilterFlags & PxFilterObjectFlagEx::eNON_RIGID; }
PX_FORCE_INLINE PxU16 isStaticRigid() const { return mFilterFlags & PxFilterObjectFlagEx::eRIGID_STATIC; }
virtual void postActorFlagChange(PxU32, PxU32) {}
void setActorsInteractionsDirty(InteractionDirtyFlag::Enum flag, const ActorSim* other, PxU8 interactionFlag);
PX_FORCE_INLINE ActorCore& getActorCore() const { return mCore; }
PX_FORCE_INLINE bool isActive() const { return (mActiveListIndex < SC_NOT_IN_ACTIVE_LIST_INDEX); }
PX_FORCE_INLINE PxU32 getActiveListIndex() const { return mActiveListIndex; } // if the body is active, the index is smaller than SC_NOT_IN_ACTIVE_LIST_INDEX
PX_FORCE_INLINE void setActiveListIndex(PxU32 index) { mActiveListIndex = index; }
PX_FORCE_INLINE PxU32 getActiveCompoundListIndex() const { return mActiveCompoundListIndex; } // if the body is active and is compound, the index is smaller than SC_NOT_IN_ACTIVE_LIST_INDEX
PX_FORCE_INLINE void setActiveCompoundListIndex(PxU32 index) { mActiveCompoundListIndex = index; }
PX_FORCE_INLINE PxNodeIndex getNodeIndex() const { return mNodeIndex; }
PX_FORCE_INLINE PxU32 getActorID() const { return mId; }
PX_FORCE_INLINE PxU16 getInternalFlag() const { return mInternalFlags; }
PX_FORCE_INLINE PxU16 readInternalFlag(InternalFlags flag) const { return PxU16(mInternalFlags & flag); }
PX_FORCE_INLINE void raiseInternalFlag(InternalFlags flag) { mInternalFlags |= flag; }
PX_FORCE_INLINE void clearInternalFlag(InternalFlags flag) { mInternalFlags &= ~flag; }
PX_FORCE_INLINE PxFilterObjectAttributes getFilterAttributes() const { return PxFilterObjectAttributes(mFilterFlags); }
virtual PxActor* getPxActor() const = 0;
//This can all be removed and functionality can be subsumed by the island system, removing the need for this
//virtual call and any associated work
virtual void registerCountedInteraction() {}
virtual void unregisterCountedInteraction() {}
virtual PxU32 getNumCountedInteractions() const { return 0; }
virtual void internalWakeUp(PxReal wakeCounterValue = ScInternalWakeCounterResetValue) { PX_UNUSED(wakeCounterValue); }
private:
//These are called from interaction creation/destruction
void registerInteractionInActor(Interaction* interaction);
void unregisterInteractionFromActor(Interaction* interaction);
void reallocInteractions(Sc::Interaction**& mem, PxU32& capacity, PxU32 size, PxU32 requiredMinCapacity);
protected:
// dsequeira: interaction arrays are a major cause of small allocations, so we don't want to delegate them to the heap allocator
// it's not clear this inline array is really needed, we should take it out and see whether the cache perf is worse
static const PxU32 INLINE_INTERACTION_CAPACITY = 4;
Interaction* mInlineInteractionMem[INLINE_INTERACTION_CAPACITY];
Cm::OwnedArray<Sc::Interaction*, Sc::ActorSim, PxU32, &Sc::ActorSim::reallocInteractions>
mInteractions;
Scene& mScene;
ActorCore& mCore;
// Sleeping
PxU32 mActiveListIndex; // Used by Scene to track active bodies
PxU32 mActiveCompoundListIndex; // Used by Scene to track active compound bodies
// Island manager
PxNodeIndex mNodeIndex;
PxU32 mId; // PT: ID provided by Sc::Scene::mActorIDTracker
PxU16 mInternalFlags;
PxU16 mFilterFlags; // PT: PxFilterObjectAttributes. Capturing the type information in local flags here is redundant
// but avoids reading the Core memory from the Sim object, and is also faster to test multiple types at once.
};
} // namespace Sc
}
#endif
| 10,302 | C | 44.588495 | 198 | 0.713162 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScShapeInteraction.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-2023 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 SC_SHAPE_INTERACTION_H
#define SC_SHAPE_INTERACTION_H
#include "ScElementSimInteraction.h"
#include "ScShapeSim.h"
#include "ScActorPair.h"
#include "ScScene.h"
#include "ScBodySim.h"
#include "PxsContactManager.h"
#include "PxsContext.h"
#include "PxsSimpleIslandManager.h"
#define INVALID_REPORT_PAIR_ID 0xffffffff
namespace physx
{
static PX_FORCE_INLINE bool isParticleSystem(const PxActorType::Enum actorType)
{
return actorType == PxActorType::ePBD_PARTICLESYSTEM || actorType == PxActorType::eFLIP_PARTICLESYSTEM
|| actorType == PxActorType::eMPM_PARTICLESYSTEM;
}
class PxsContactManagerOutputIterator;
namespace Sc
{
class ContactReportAllocationManager;
/*
Description: A ShapeInteraction represents a pair of objects which _may_ have contacts. Created by the broadphase
and processed by the NPhaseCore.
*/
class ShapeInteraction : public ElementSimInteraction
{
friend class NPhaseCore;
ShapeInteraction& operator=(const ShapeInteraction&);
public:
enum SiFlag
{
PAIR_FLAGS_MASK = (PxPairFlag::eNEXT_FREE - 1), // Bits where the PxPairFlags get stored
NEXT_FREE = ((PAIR_FLAGS_MASK << 1) & ~PAIR_FLAGS_MASK),
HAS_TOUCH = (NEXT_FREE << 0), // Tracks the last know touch state
HAS_NO_TOUCH = (NEXT_FREE << 1), // Tracks the last know touch state
TOUCH_KNOWN = (HAS_TOUCH | HAS_NO_TOUCH), // If none of these flags is set, the touch state is not known (for example, this is true for pairs that never ran narrowphase
CONTACTS_COLLECT_POINTS = (NEXT_FREE << 2), // The user wants to get the contact points (includes debug rendering)
CONTACTS_RESPONSE_DISABLED = (NEXT_FREE << 3), // Collision response disabled (either by the user through PxPairFlag::eSOLVE_CONTACT or because the pair has two kinematics)
CONTACT_FORCE_THRESHOLD_PAIRS = PxU32(PxPairFlag::eNOTIFY_THRESHOLD_FORCE_FOUND) | PxU32(PxPairFlag::eNOTIFY_THRESHOLD_FORCE_PERSISTS) | PxU32(PxPairFlag::eNOTIFY_THRESHOLD_FORCE_LOST),
CONTACT_REPORT_EVENTS = PxU32(PxPairFlag::eNOTIFY_TOUCH_FOUND) | PxU32(PxPairFlag::eNOTIFY_TOUCH_PERSISTS) | PxU32(PxPairFlag::eNOTIFY_TOUCH_LOST) |
PxU32(PxPairFlag::eNOTIFY_THRESHOLD_FORCE_FOUND) | PxU32(PxPairFlag::eNOTIFY_THRESHOLD_FORCE_PERSISTS) | PxU32(PxPairFlag::eNOTIFY_THRESHOLD_FORCE_LOST),
CONTACT_REPORT_EXTRA_DATA = PxU32(PxPairFlag::ePRE_SOLVER_VELOCITY) | PxU32(PxPairFlag::ePOST_SOLVER_VELOCITY) | PxU32(PxPairFlag::eCONTACT_EVENT_POSE),
FORCE_THRESHOLD_EXCEEDED_NOW = (NEXT_FREE << 4),
FORCE_THRESHOLD_EXCEEDED_BEFORE = (NEXT_FREE << 5),
FORCE_THRESHOLD_EXCEEDED_FLAGS = FORCE_THRESHOLD_EXCEEDED_NOW | FORCE_THRESHOLD_EXCEEDED_BEFORE,
IS_IN_PERSISTENT_EVENT_LIST = (NEXT_FREE << 6), // The pair is in the list of persistent contact events
WAS_IN_PERSISTENT_EVENT_LIST = (NEXT_FREE << 7), // The pair is inactive but used to be in the list of persistent contact events
IN_PERSISTENT_EVENT_LIST = IS_IN_PERSISTENT_EVENT_LIST | WAS_IN_PERSISTENT_EVENT_LIST,
IS_IN_FORCE_THRESHOLD_EVENT_LIST= (NEXT_FREE << 8), // The pair is in the list of force threshold contact events
IS_IN_CONTACT_EVENT_LIST = IS_IN_PERSISTENT_EVENT_LIST | IS_IN_FORCE_THRESHOLD_EVENT_LIST,
LL_MANAGER_RECREATE_EVENT = CONTACT_REPORT_EVENTS | CONTACTS_COLLECT_POINTS |
CONTACTS_RESPONSE_DISABLED | PxU32(PxPairFlag::eMODIFY_CONTACTS)
};
ShapeInteraction(ShapeSimBase& s1, ShapeSimBase& s2, PxPairFlags pairFlags, PxsContactManager* contactManager);
~ShapeInteraction();
// Submits to contact stream
void processUserNotification(PxU32 contactEvent, PxU16 infoFlags, bool touchLost, PxU32 ccdPass, bool useCurrentTransform,
PxsContactManagerOutputIterator& outputs); // ccdPass is 0 for discrete collision and then 1,2,... for the CCD passes
void processUserNotificationSync();
void processUserNotificationAsync(PxU32 contactEvent, PxU16 infoFlags, bool touchLost, PxU32 ccdPass, bool useCurrentTransform,
PxsContactManagerOutputIterator& outputs, ContactReportAllocationManager* alloc = NULL); // ccdPass is 0 for discrete collision and then 1,2,... for the CCD passes
void visualize( PxRenderOutput&, PxsContactManagerOutputIterator&,
float scale, float param_contactForce, float param_contactNormal, float param_contactError, float param_contactPoint
);
PxU32 getContactPointData(const void*& contactPatches, const void*& contactPoints, PxU32& contactDataSize, PxU32& contactPointCount, PxU32& patchCount, const PxReal*& impulses, PxU32 startOffset, PxsContactManagerOutputIterator& outputs);
bool managerLostTouch(PxU32 ccdPass, bool adjustCounters, PxsContactManagerOutputIterator& outputs);
void managerNewTouch(PxU32 ccdPass, bool adjustCounters, PxsContactManagerOutputIterator& outputs);
PX_FORCE_INLINE void adjustCountersOnLostTouch();
PX_FORCE_INLINE void adjustCountersOnNewTouch();
PX_FORCE_INLINE void sendCCDRetouch(PxU32 ccdPass, PxsContactManagerOutputIterator& outputs);
void setContactReportPostSolverVelocity(ContactStreamManager& cs);
PX_FORCE_INLINE void sendLostTouchReport(bool shapeVolumeRemoved, PxU32 ccdPass, PxsContactManagerOutputIterator& ouptuts);
void resetManagerCachedState() const;
PX_FORCE_INLINE ActorPair* getActorPair() const { return mActorPair; }
PX_FORCE_INLINE void setActorPair(ActorPair& aPair) { mActorPair = &aPair; }
PX_FORCE_INLINE void clearActorPair() { mActorPair = NULL; }
PX_FORCE_INLINE ActorPairReport& getActorPairReport() const { return ActorPairReport::cast(*mActorPair); }
PX_INLINE PxIntBool isReportPair() const { /*PX_ASSERT(!(PxIntBool(getPairFlags() & CONTACT_REPORT_EVENTS)) || mActorPair->isReportPair());*/ return PxIntBool(getPairFlags() & CONTACT_REPORT_EVENTS); }
PX_INLINE PxIntBool hasTouch() const { return readFlag(HAS_TOUCH); }
PX_INLINE PxIntBool hasCCDTouch() const { PX_ASSERT(mManager); return mManager->getHadCCDContact(); }
PX_INLINE void swapAndClearForceThresholdExceeded();
PX_FORCE_INLINE void raiseFlag(SiFlag flag) { mFlags |= flag; }
PX_FORCE_INLINE PxIntBool readFlag(SiFlag flag) const { return PxIntBool(mFlags & flag); }
PX_FORCE_INLINE PxU32 getPairFlags() const;
PX_FORCE_INLINE void removeFromReportPairList();
void onShapeChangeWhileSleeping(bool shapeOfDynamicChanged);
PX_FORCE_INLINE PxIntBool hasKnownTouchState() const;
bool onActivate(void* data);
bool onDeactivate();
void updateState(const PxU8 externalDirtyFlags);
const PxsContactManager* getContactManager() const { return mManager; }
void clearIslandGenData();
PX_FORCE_INLINE PxU32 getEdgeIndex() const { return mEdgeIndex; }
PX_FORCE_INLINE Sc::ShapeSimBase& getShape0() const { return static_cast<ShapeSimBase&>(getElement0()); }
PX_FORCE_INLINE Sc::ShapeSimBase& getShape1() const { return static_cast<ShapeSimBase&>(getElement1()); }
private:
ActorPair* mActorPair;
PxsContactManager* mManager;
PxU32 mContactReportStamp;
PxU32 mReportPairIndex; // Owned by NPhaseCore for its report pair list
PxU32 mEdgeIndex;
PxU16 mReportStreamIndex; // position of this pair in the contact report stream
void createManager(void* contactManager);
PX_INLINE bool updateManager(void* contactManager);
PX_INLINE void destroyManager();
PX_FORCE_INLINE bool activeManagerAllowed() const;
PX_FORCE_INLINE PxU32 getManagerContactState() const { return mFlags & LL_MANAGER_RECREATE_EVENT; }
PX_FORCE_INLINE void clearFlag(SiFlag flag) { mFlags &= ~flag; }
PX_INLINE void setFlag(SiFlag flag, bool value)
{
if (value)
raiseFlag(flag);
else
clearFlag(flag);
}
PX_FORCE_INLINE void setHasTouch() { clearFlag(HAS_NO_TOUCH); raiseFlag(HAS_TOUCH); }
PX_FORCE_INLINE void setHasNoTouch() { clearFlag(HAS_TOUCH); raiseFlag(HAS_NO_TOUCH); }
PX_FORCE_INLINE void setPairFlags(PxPairFlags flags);
PX_FORCE_INLINE void processReportPairOnActivate();
PX_FORCE_INLINE void processReportPairOnDeactivate();
// Certain SiFlag cache properties of the pair. If these properties change then the flags have to be updated.
// For example: is collision enabled for this pair? are contact points requested for this pair?
PX_FORCE_INLINE void updateFlags(const Sc::Scene&, const Sc::ActorSim&, const Sc::ActorSim&, const PxU32 pairFlags);
friend class Sc::Scene;
};
} // namespace Sc
// PT: TODO: is there a reason for force-inlining all that stuff?
PX_FORCE_INLINE void Sc::ShapeInteraction::sendLostTouchReport(bool shapeVolumeRemoved, PxU32 ccdPass, PxsContactManagerOutputIterator& outputs)
{
PX_ASSERT(hasTouch());
PX_ASSERT(isReportPair());
const PxU32 pairFlags = getPairFlags();
const PxU32 notifyTouchLost = pairFlags & PxU32(PxPairFlag::eNOTIFY_TOUCH_LOST);
const PxIntBool thresholdExceeded = readFlag(ShapeInteraction::FORCE_THRESHOLD_EXCEEDED_NOW);
const PxU32 notifyThresholdLost = thresholdExceeded ? (pairFlags & PxU32(PxPairFlag::eNOTIFY_THRESHOLD_FORCE_LOST)) : 0;
if(!notifyTouchLost && !notifyThresholdLost)
return;
PxU16 infoFlag = 0;
if(mActorPair->getTouchCount() == 1) // this code assumes that the actor pair touch count does get decremented afterwards
infoFlag |= PxContactPairFlag::eACTOR_PAIR_LOST_TOUCH;
//Lost touch is processed after solver, so we should use the previous transform to update the pose for objects if user request eCONTACT_EVENT_POSE
const bool useCurrentTransform = false;
const PxU32 triggeredFlags = notifyTouchLost | notifyThresholdLost;
PX_ASSERT(triggeredFlags);
processUserNotification(triggeredFlags, infoFlag, true, ccdPass, useCurrentTransform, outputs);
if(shapeVolumeRemoved)
{
ActorPairReport& apr = getActorPairReport();
ContactStreamManager& cs = apr.getContactStreamManager();
cs.raiseFlags(ContactStreamManagerFlag::eTEST_FOR_REMOVED_SHAPES);
}
}
PX_FORCE_INLINE void Sc::ShapeInteraction::setPairFlags(PxPairFlags flags)
{
PX_ASSERT(PxU32(flags) < PxPairFlag::eNEXT_FREE); // to find out if a new PxPairFlag has been added after eLAST instead of in front
PxU32 newFlags = mFlags;
PxU32 fl = PxU32(flags) & PAIR_FLAGS_MASK;
newFlags &= (~PAIR_FLAGS_MASK); // clear old flags
newFlags |= fl;
mFlags = newFlags;
}
// PT: returning PxU32 instead of PxPairFlags to remove LHS. Please do not undo this.
PX_FORCE_INLINE PxU32 Sc::ShapeInteraction::getPairFlags() const
{
return (mFlags & PAIR_FLAGS_MASK);
}
PX_INLINE void Sc::ShapeInteraction::swapAndClearForceThresholdExceeded()
{
PxU32 flags = mFlags;
PX_COMPILE_TIME_ASSERT(FORCE_THRESHOLD_EXCEEDED_NOW == (FORCE_THRESHOLD_EXCEEDED_BEFORE >> 1));
PxU32 nowToBefore = (flags & FORCE_THRESHOLD_EXCEEDED_NOW) << 1;
flags &= ~(FORCE_THRESHOLD_EXCEEDED_NOW | FORCE_THRESHOLD_EXCEEDED_BEFORE);
flags |= nowToBefore;
mFlags = flags;
}
PX_FORCE_INLINE void Sc::ShapeInteraction::removeFromReportPairList()
{
// this method should only get called if the pair is in the list for
// persistent or force based contact reports
PX_ASSERT(mReportPairIndex != INVALID_REPORT_PAIR_ID);
PX_ASSERT(readFlag(IS_IN_CONTACT_EVENT_LIST));
Scene& scene = getScene();
if (readFlag(IS_IN_FORCE_THRESHOLD_EVENT_LIST))
scene.getNPhaseCore()->removeFromForceThresholdContactEventPairs(this);
else
{
PX_ASSERT(readFlag(IS_IN_PERSISTENT_EVENT_LIST));
scene.getNPhaseCore()->removeFromPersistentContactEventPairs(this);
}
}
PX_INLINE bool Sc::ShapeInteraction::updateManager(void* contactManager)
{
if (activeManagerAllowed())
{
if (mManager == 0)
createManager(contactManager);
return (mManager != NULL); // creation might fail (pool reached limit, mem allocation failed etc.)
}
else
return false;
}
PX_INLINE void Sc::ShapeInteraction::destroyManager()
{
PX_ASSERT(mManager);
Scene& scene = getScene();
PxvNphaseImplementationContext* nphaseImplementationContext = scene.getLowLevelContext()->getNphaseImplementationContext();
PX_ASSERT(nphaseImplementationContext);
nphaseImplementationContext->unregisterContactManager(mManager);
/*if (mEdgeIndex != IG_INVALID_EDGE)
scene.getSimpleIslandManager()->clearEdgeRigidCM(mEdgeIndex);*/
scene.getLowLevelContext()->destroyContactManager(mManager);
mManager = 0;
}
PX_FORCE_INLINE bool Sc::ShapeInteraction::activeManagerAllowed() const
{
ShapeSimBase& shape0 = getShape0();
ShapeSimBase& shape1 = getShape1();
ActorSim& bodySim0 = shape0.getActor();
ActorSim& bodySim1 = shape1.getActor();
// the first shape always belongs to a dynamic body or soft body
#if PX_SUPPORT_GPU_PHYSX
PX_ASSERT(bodySim0.isDynamicRigid() || bodySim0.isSoftBody() || bodySim0.isFEMCloth() || bodySim0.isParticleSystem() || bodySim0.isHairSystem());
#else
PX_ASSERT(bodySim0.isDynamicRigid());
#endif
// PT: try to prevent https://omniverse-jirasw.nvidia.com/browse/OM-103695
if(!bodySim0.getNodeIndex().isValid())
return false;
const IG::IslandSim& islandSim = getScene().getSimpleIslandManager()->getSpeculativeIslandSim();
//check whether active in the speculative sim!
return (islandSim.getNode(bodySim0.getNodeIndex()).isActive() ||
(!bodySim1.isStaticRigid() && islandSim.getNode(bodySim1.getNodeIndex()).isActive()));
}
PX_FORCE_INLINE void Sc::ShapeInteraction::sendCCDRetouch(PxU32 ccdPass, PxsContactManagerOutputIterator& outputs)
{
const PxU32 pairFlags = getPairFlags();
if (pairFlags & PxPairFlag::eNOTIFY_TOUCH_CCD)
processUserNotification(PxPairFlag::eNOTIFY_TOUCH_CCD, 0, false, ccdPass, false, outputs);
}
PX_FORCE_INLINE void Sc::ShapeInteraction::adjustCountersOnLostTouch()
{
PX_ASSERT(mActorPair->getTouchCount());
mActorPair->decTouchCount();
}
PX_FORCE_INLINE void Sc::ShapeInteraction::adjustCountersOnNewTouch()
{
mActorPair->incTouchCount();
}
PX_FORCE_INLINE PxIntBool Sc::ShapeInteraction::hasKnownTouchState() const
{
// For a pair where the bodies were added asleep, the touch state is not known until narrowphase runs on the pair for the first time.
// If such a pair looses AABB overlap before, the conservative approach is to wake the bodies up. This method provides an indicator that
// this is such a pair. Note: this might also wake up objects that do not touch but that's the price to pay (unless we want to run
// overlap tests on such pairs).
if (mManager)
return mManager->touchStatusKnown();
else
return readFlag(TOUCH_KNOWN);
}
}
#endif
| 16,460 | C | 44.09863 | 248 | 0.740522 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScConstraintCore.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScConstraintCore.h"
#include "ScPhysics.h"
#include "ScConstraintSim.h"
using namespace physx;
Sc::ConstraintCore::ConstraintCore(PxConstraintConnector& connector, const PxConstraintShaderTable& shaders, PxU32 dataSize) :
mFlags (PxConstraintFlag::eDRIVE_LIMITS_ARE_FORCES),
mIsDirty (1),
mAppliedForce (PxVec3(0.0f)),
mAppliedTorque (PxVec3(0.0f)),
mConnector (&connector),
mSolverPrep (shaders.solverPrep),
mVisualize (shaders.visualize),
mDataSize (dataSize),
mLinearBreakForce (PX_MAX_F32),
mAngularBreakForce (PX_MAX_F32),
mMinResponseThreshold (0.0f),
mSim (NULL)
{
}
void Sc::ConstraintCore::setFlags(PxConstraintFlags flags)
{
PxConstraintFlags old = mFlags;
flags = flags | (old & PxConstraintFlag::eGPU_COMPATIBLE);
if(flags != old)
{
mFlags = flags;
if(mSim)
mSim->postFlagChange(old, flags);
}
}
void Sc::ConstraintCore::getForce(PxVec3& force, PxVec3& torque) const
{
if(!mSim)
{
force = PxVec3(0.0f);
torque = PxVec3(0.0f);
}
else
mSim->getForce(force, torque);
}
void Sc::ConstraintCore::setBodies(RigidCore* r0v, RigidCore* r1v)
{
if(mSim)
mSim->setBodies(r0v, r1v);
}
void Sc::ConstraintCore::setBreakForce(PxReal linear, PxReal angular)
{
mLinearBreakForce = linear;
mAngularBreakForce = angular;
if(mSim)
mSim->setBreakForceLL(linear, angular);
}
void Sc::ConstraintCore::setMinResponseThreshold(PxReal threshold)
{
mMinResponseThreshold = threshold;
if(mSim)
mSim->setMinResponseThresholdLL(threshold);
}
PxConstraint* Sc::ConstraintCore::getPxConstraint()
{
return gOffsetTable.convertScConstraint2Px(this);
}
const PxConstraint* Sc::ConstraintCore::getPxConstraint() const
{
return gOffsetTable.convertScConstraint2Px(this);
}
void Sc::ConstraintCore::breakApart()
{
// TODO: probably want to do something with the interaction here
// as well as remove the constraint from LL.
mFlags |= PxConstraintFlag::eBROKEN;
}
| 3,642 | C++ | 30.678261 | 126 | 0.750412 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScBodyCore.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScBodyCore.h"
#include "ScBodySim.h"
#include "ScPhysics.h"
#include "ScScene.h"
#include "PxsSimulationController.h"
#include "ScArticulationSim.h"
using namespace physx;
static void updateBodySim(Sc::BodyCore& bodyCore)
{
Sc::BodySim* bodySim = bodyCore.getSim();
if(bodySim)
bodySim->getScene().updateBodySim(*bodySim);
}
Sc::BodyCore::BodyCore(PxActorType::Enum type, const PxTransform& bodyPose) : RigidCore(type)
{
const PxTolerancesScale& scale = Physics::getInstance().getTolerancesScale();
const bool isDynamic = type == PxActorType::eRIGID_DYNAMIC;
const float linearDamping = isDynamic ? 0.0f : 0.05f;
const float maxLinearVelocitySq = isDynamic ? 1e32f /*PX_MAX_F32*/ : 100.f * 100.f * scale.length * scale.length;
const float maxAngularVelocitySq = isDynamic ? 100.0f * 100.0f : 50.0f * 50.0f;
mCore.init(bodyPose, PxVec3(1.0f), 1.0f, Sc::Physics::sWakeCounterOnCreation, scale.speed, linearDamping, 0.05f, maxLinearVelocitySq, maxAngularVelocitySq,
type);
}
Sc::BodyCore::~BodyCore()
{
PX_ASSERT(getSim() == 0);
}
Sc::BodySim* Sc::BodyCore::getSim() const
{
return static_cast<BodySim*>(Sc::ActorCore::getSim());
}
void Sc::BodyCore::restoreDynamicData()
{
BodySim* sim = getSim();
PX_ASSERT(sim);
const SimStateData* simStateData = sim->getSimStateData(true);
PX_ASSERT(simStateData);
PxsBodyCore& core = getCore();
simStateRestoreBodyProperties(simStateData, core);
}
//--------------------------------------------------------------
//
// BodyCore interface implementation
//
//--------------------------------------------------------------
void Sc::BodyCore::setBody2World(const PxTransform& p)
{
mCore.body2World = p;
PX_ASSERT(p.p.isFinite());
PX_ASSERT(p.q.isFinite());
BodySim* sim = getSim();
if(sim)
{
sim->postBody2WorldChange();
sim->getScene().updateBodySim(*sim);
}
}
void Sc::BodyCore::setCMassLocalPose(const PxTransform& newBody2Actor)
{
const PxTransform oldActor2World = mCore.body2World * mCore.getBody2Actor().getInverse();
const PxTransform newBody2World = oldActor2World * newBody2Actor;
PX_ASSERT(newBody2World.p.isFinite());
PX_ASSERT(newBody2World.q.isFinite());
mCore.body2World = newBody2World;
setBody2Actor(newBody2Actor);
}
void Sc::BodyCore::setLinearVelocity(const PxVec3& v, bool skipBodySimUpdate)
{
mCore.linearVelocity = v;
PX_ASSERT(!skipBodySimUpdate || (getFlags() & PxRigidBodyFlag::eKINEMATIC));
if(!skipBodySimUpdate)
updateBodySim(*this);
}
void Sc::BodyCore::setAngularVelocity(const PxVec3& v, bool skipBodySimUpdate)
{
mCore.angularVelocity = v;
PX_ASSERT(!skipBodySimUpdate || (getFlags() & PxRigidBodyFlag::eKINEMATIC));
if(!skipBodySimUpdate)
updateBodySim(*this);
}
void Sc::BodyCore::setCfmScale(PxReal cfmScale)
{
mCore.cfmScale = cfmScale;
updateBodySim(*this);
}
void Sc::BodyCore::setBody2Actor(const PxTransform& p)
{
PX_ASSERT(p.p.isFinite());
PX_ASSERT(p.q.isFinite());
mCore.setBody2Actor(p);
updateBodySim(*this);
}
void Sc::BodyCore::addSpatialAcceleration(const PxVec3* linAcc, const PxVec3* angAcc)
{
BodySim* sim = getSim();
PX_ASSERT(sim);
sim->addSpatialAcceleration(linAcc, angAcc);
}
void Sc::BodyCore::setSpatialAcceleration(const PxVec3* linAcc, const PxVec3* angAcc)
{
BodySim* sim = getSim();
PX_ASSERT(sim);
sim->setSpatialAcceleration(linAcc, angAcc);
}
void Sc::BodyCore::clearSpatialAcceleration(bool force, bool torque)
{
PX_ASSERT(force || torque);
BodySim* sim = getSim();
PX_ASSERT(sim);
sim->clearSpatialAcceleration(force, torque);
}
void Sc::BodyCore::addSpatialVelocity(const PxVec3* linVelDelta, const PxVec3* angVelDelta)
{
BodySim* sim = getSim();
PX_ASSERT(sim);
sim->addSpatialVelocity(linVelDelta, angVelDelta);
}
void Sc::BodyCore::clearSpatialVelocity(bool force, bool torque)
{
PX_ASSERT(force || torque);
BodySim* sim = getSim();
PX_ASSERT(sim);
sim->clearSpatialVelocity(force, torque);
}
PxReal Sc::BodyCore::getInverseMass() const
{
BodySim* sim = getSim();
if(!sim || (!(getFlags() & PxRigidBodyFlag::eKINEMATIC)))
{
return mCore.inverseMass;
}
else
{
const SimStateData* simStateData = sim->getSimStateData(true);
PX_ASSERT(simStateData);
PX_ASSERT(simStateData->getKinematicData());
return simStateData->getKinematicData()->backupInvMass;
}
}
void Sc::BodyCore::setInverseMass(PxReal m)
{
BodySim* sim = getSim();
if (!sim || (!(getFlags() & PxRigidBodyFlag::eKINEMATIC)))
{
mCore.inverseMass = m;
updateBodySim(*this);
}
else
{
SimStateData* simStateData = sim->getSimStateData(true);
PX_ASSERT(simStateData);
PX_ASSERT(simStateData->getKinematicData());
simStateData->getKinematicData()->backupInvMass = m;
}
}
const PxVec3& Sc::BodyCore::getInverseInertia() const
{
BodySim* sim = getSim();
if (!sim || (!(getFlags() & PxRigidBodyFlag::eKINEMATIC)))
{
return mCore.inverseInertia;
}
else
{
const SimStateData* simStateData = sim->getSimStateData(true);
PX_ASSERT(simStateData);
PX_ASSERT(simStateData->getKinematicData());
return (simStateData->getKinematicData()->backupInverseInertia);
}
}
void Sc::BodyCore::setInverseInertia(const PxVec3& i)
{
BodySim* sim = getSim();
if (!sim || (!(getFlags() & PxRigidBodyFlag::eKINEMATIC)))
{
mCore.inverseInertia = i;
updateBodySim(*this);
}
else
{
SimStateData* simStateData = sim->getSimStateData(true);
PX_ASSERT(simStateData);
PX_ASSERT(simStateData->getKinematicData());
simStateData->getKinematicData()->backupInverseInertia = i;
}
}
PxReal Sc::BodyCore::getLinearDamping() const
{
BodySim* sim = getSim();
if (!sim || (!(getFlags() & PxRigidBodyFlag::eKINEMATIC)))
{
return mCore.linearDamping;
}
else
{
const SimStateData* simStateData = sim->getSimStateData(true);
PX_ASSERT(simStateData);
PX_ASSERT(simStateData->getKinematicData());
return (simStateData->getKinematicData()->backupLinearDamping);
}
}
void Sc::BodyCore::setLinearDamping(PxReal d)
{
BodySim* sim = getSim();
if (!sim || (!(getFlags() & PxRigidBodyFlag::eKINEMATIC)))
{
mCore.linearDamping = d;
updateBodySim(*this);
}
else
{
SimStateData* simStateData = sim->getSimStateData(true);
PX_ASSERT(simStateData);
PX_ASSERT(simStateData->getKinematicData());
simStateData->getKinematicData()->backupLinearDamping = d;
}
}
PxReal Sc::BodyCore::getAngularDamping() const
{
BodySim* sim = getSim();
if (!sim || (!(getFlags() & PxRigidBodyFlag::eKINEMATIC)))
{
return mCore.angularDamping;
}
else
{
const SimStateData* simStateData = sim->getSimStateData(true);
PX_ASSERT(simStateData);
PX_ASSERT(simStateData->getKinematicData());
return (simStateData->getKinematicData()->backupAngularDamping);
}
}
void Sc::BodyCore::setAngularDamping(PxReal v)
{
BodySim* sim = getSim();
if (!sim || (!(getFlags() & PxRigidBodyFlag::eKINEMATIC)))
{
mCore.angularDamping = v;
updateBodySim(*this);
}
else
{
SimStateData* simStateData = sim->getSimStateData(true);
PX_ASSERT(simStateData);
PX_ASSERT(simStateData->getKinematicData());
simStateData->getKinematicData()->backupAngularDamping = v;
}
}
PxReal Sc::BodyCore::getMaxAngVelSq() const
{
BodySim* sim = getSim();
if (!sim || (!(getFlags() & PxRigidBodyFlag::eKINEMATIC)))
{
return mCore.maxAngularVelocitySq;
}
else
{
const SimStateData* simStateData = sim->getSimStateData(true);
PX_ASSERT(simStateData);
PX_ASSERT(simStateData->getKinematicData());
return (simStateData->getKinematicData()->backupMaxAngVelSq);
}
}
void Sc::BodyCore::setMaxAngVelSq(PxReal v)
{
BodySim* sim = getSim();
if (!sim || (!(getFlags() & PxRigidBodyFlag::eKINEMATIC)))
{
mCore.maxAngularVelocitySq = v;
updateBodySim(*this);
}
else
{
SimStateData* simStateData = sim->getSimStateData(true);
PX_ASSERT(simStateData);
PX_ASSERT(simStateData->getKinematicData());
simStateData->getKinematicData()->backupMaxAngVelSq = v;
}
}
PxReal Sc::BodyCore::getMaxLinVelSq() const
{
BodySim* sim = getSim();
if (!sim || (!(getFlags() & PxRigidBodyFlag::eKINEMATIC)))
{
return mCore.maxLinearVelocitySq;
}
else
{
const SimStateData* simStateData = sim->getSimStateData(true);
PX_ASSERT(simStateData);
PX_ASSERT(simStateData->getKinematicData());
return (simStateData->getKinematicData()->backupMaxLinVelSq);
}
}
void Sc::BodyCore::setMaxLinVelSq(PxReal v)
{
BodySim* sim = getSim();
if (!sim || (!(getFlags() & PxRigidBodyFlag::eKINEMATIC)))
{
mCore.maxLinearVelocitySq = v;
updateBodySim(*this);
}
else
{
SimStateData* simStateData = sim->getSimStateData(true);
PX_ASSERT(simStateData);
PX_ASSERT(simStateData->getKinematicData());
simStateData->getKinematicData()->backupMaxLinVelSq = v;
}
}
void Sc::BodyCore::setFlags(PxRigidBodyFlags f)
{
const PxRigidBodyFlags old = mCore.mFlags;
if(f != old)
{
const PxU32 wasKinematic = old & PxRigidBodyFlag::eKINEMATIC;
const PxU32 isKinematic = f & PxRigidBodyFlag::eKINEMATIC;
const bool switchToKinematic = ((!wasKinematic) && isKinematic);
const bool switchToDynamic = (wasKinematic && (!isKinematic));
mCore.mFlags = f;
BodySim* sim = getSim();
if (sim)
{
const PxU32 posePreviewFlag = f & PxRigidBodyFlag::eENABLE_POSE_INTEGRATION_PREVIEW;
if(PxU32(old & PxRigidBodyFlag::eENABLE_POSE_INTEGRATION_PREVIEW) != posePreviewFlag)
sim->postPosePreviewChange(posePreviewFlag);
// for those who might wonder about the complexity here:
// our current behavior is that you are not allowed to set a kinematic target unless the object is in a scene.
// Thus, the kinematic data should only be created/destroyed when we know for sure that we are in a scene.
if(switchToKinematic)
sim->switchToKinematic();
else if(switchToDynamic)
sim->switchToDynamic();
const PxU32 wasSpeculativeCCD = old & PxRigidBodyFlag::eENABLE_SPECULATIVE_CCD;
const PxU32 isSpeculativeCCD = f & PxRigidBodyFlag::eENABLE_SPECULATIVE_CCD;
if(wasSpeculativeCCD ^ isSpeculativeCCD)
{
if(wasSpeculativeCCD)
{
sim->removeFromSpeculativeCCDMap();
sim->getLowLevelBody().mInternalFlags &= (~PxsRigidBody::eSPECULATIVE_CCD);
}
else
{
//Kinematic body switch puts the body to sleep, so we do not mark the speculative CCD bitmap for this actor to true in this case.
if(!switchToKinematic)
sim->addToSpeculativeCCDMap();
sim->getLowLevelBody().mInternalFlags |= (PxsRigidBody::eSPECULATIVE_CCD);
}
}
const PxU32 wasIntegrateGyroscopic = old & PxRigidBodyFlag::eENABLE_GYROSCOPIC_FORCES;
const PxU32 isIntegrateGyroscopic = f & PxRigidBodyFlag::eENABLE_GYROSCOPIC_FORCES;
if (wasIntegrateGyroscopic ^ isIntegrateGyroscopic)
{
if(wasIntegrateGyroscopic)
sim->getLowLevelBody().mInternalFlags &= (PxsRigidBody::eENABLE_GYROSCOPIC);
else
sim->getLowLevelBody().mInternalFlags |= (PxsRigidBody::eENABLE_GYROSCOPIC);
}
const PxU32 wasRetainAccel = old & PxRigidBodyFlag::eRETAIN_ACCELERATIONS;
const PxU32 isRetainAccel = f & PxRigidBodyFlag::eRETAIN_ACCELERATIONS;
if (wasRetainAccel ^ isRetainAccel)
{
if (wasRetainAccel)
sim->getLowLevelBody().mInternalFlags &= (PxsRigidBody::eRETAIN_ACCELERATION);
else
sim->getLowLevelBody().mInternalFlags |= (PxsRigidBody::eRETAIN_ACCELERATION);
}
//Force flag change through...
sim->getScene().updateBodySim(*sim);
}
if(switchToKinematic)
putToSleep();
if(sim)
{
const PxRigidBodyFlags ktFlags(PxRigidBodyFlag::eUSE_KINEMATIC_TARGET_FOR_SCENE_QUERIES | PxRigidBodyFlag::eKINEMATIC);
const bool hadKt = (old & ktFlags) == ktFlags;
const bool hasKt = (f & ktFlags) == ktFlags;
if(hasKt && !hadKt)
sim->destroySqBounds();
else if(hadKt && !hasKt)
sim->createSqBounds();
}
}
}
void Sc::BodyCore::setMaxContactImpulse(PxReal m)
{
mCore.maxContactImpulse = m;
updateBodySim(*this);
}
void Sc::BodyCore::setOffsetSlop(PxReal slop)
{
mCore.offsetSlop = slop;
updateBodySim(*this);
}
PxNodeIndex Sc::BodyCore::getInternalIslandNodeIndex() const
{
BodySim* sim = getSim();
return sim ? sim->getNodeIndex() : PxNodeIndex(PX_INVALID_NODE);
}
void Sc::BodyCore::setWakeCounter(PxReal wakeCounter, bool forceWakeUp)
{
mCore.wakeCounter = wakeCounter;
BodySim* sim = getSim();
if(sim)
{
//wake counter change, we need to trigger dma pxgbodysim data again
sim->getScene().updateBodySim(*sim);
if ((wakeCounter > 0.0f) || forceWakeUp)
sim->wakeUp();
sim->postSetWakeCounter(wakeCounter, forceWakeUp);
}
}
void Sc::BodyCore::setSleepThreshold(PxReal t)
{
mCore.sleepThreshold = t;
updateBodySim(*this);
}
void Sc::BodyCore::setFreezeThreshold(PxReal t)
{
mCore.freezeThreshold = t;
updateBodySim(*this);
}
bool Sc::BodyCore::isSleeping() const
{
BodySim* sim = getSim();
return sim ? !sim->isActive() : true;
}
void Sc::BodyCore::putToSleep()
{
mCore.linearVelocity = PxVec3(0.0f);
mCore.angularVelocity = PxVec3(0.0f);
// important to clear all values before setting the wake counter because the values decide
// whether an object is ready to go to sleep or not.
setWakeCounter(0.0f);
BodySim* sim = getSim();
if(sim)
sim->putToSleep();
}
void Sc::BodyCore::onOriginShift(const PxVec3& shift)
{
mCore.body2World.p -= shift;
BodySim* b = getSim();
if(b)
b->onOriginShift(shift, getFlags() & PxRigidBodyFlag::eKINEMATIC); // BodySim might not exist if actor has simulation disabled (PxActorFlag::eDISABLE_SIMULATION)
}
// PT: TODO: why do we test againt NULL everywhere but not in 'isFrozen' ?
PxIntBool Sc::BodyCore::isFrozen() const
{
return getSim()->isFrozen();
}
void Sc::BodyCore::setSolverIterationCounts(PxU16 c)
{
mCore.solverIterationCounts = c;
Sc::BodySim* sim = getSim();
if (sim)
{
sim->getLowLevelBody().solverIterationCounts = c;
sim->getScene().setDynamicsDirty();
}
}
///////////////////////////////////////////////////////////////////////////////
bool Sc::BodyCore::getKinematicTarget(PxTransform& p) const
{
PX_ASSERT(mCore.mFlags & PxRigidBodyFlag::eKINEMATIC);
const BodySim* sim = getSim();
return (sim && simStateGetKinematicTarget(sim->getSimStateData_Unchecked(), p));
}
bool Sc::BodyCore::getHasValidKinematicTarget() const
{
//The use pattern for this is that we should only look for kinematic data if we know it is kinematic.
//We might look for velmod data even if it is kinematic.
BodySim* sim = getSim();
return (sim && simStateGetHasValidKinematicTarget(sim->getSimStateData_Unchecked()));
}
void Sc::BodyCore::setKinematicTarget(const PxTransform& p, PxReal wakeCounter)
{
PX_ASSERT(mCore.mFlags & PxRigidBodyFlag::eKINEMATIC);
Sc::BodySim* sim = getSim();
PX_ASSERT(sim);
sim->setKinematicTarget(p);
wakeUp(wakeCounter);
}
void Sc::BodyCore::invalidateKinematicTarget()
{
Sc::BodySim* sim = getSim();
PX_ASSERT(sim);
simStateInvalidateKinematicTarget(sim->getSimStateData_Unchecked());
}
void Sc::BodyCore::setFixedBaseLink(bool value)
{
BodySim* sim = getSim();
if(sim)
sim->getLowLevelBody().mCore->fixedBaseLink = PxU8(value);
}
void Sc::BodyCore::onRemoveKinematicFromScene()
{
PX_ASSERT(mCore.mFlags & PxRigidBodyFlag::eKINEMATIC);
PX_ASSERT(getSim() && getSim()->checkSimStateKinematicStatus(true));
// make sure that a kinematic which is not part of a scene is in the expected state
mCore.wakeCounter = 0.0f;
mCore.linearVelocity = PxVec3(0.0f);
mCore.angularVelocity = PxVec3(0.0f);
}
///////////////////////////////////////////////////////////////////////////////
| 17,153 | C++ | 26.892683 | 164 | 0.714277 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScArticulationSim.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-2023 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 SC_ARTICULATION_SIM_H
#define SC_ARTICULATION_SIM_H
#include "foundation/PxUserAllocated.h"
#include "ScArticulationCore.h"
#include "PxsSimpleIslandManager.h"
#include "DyArticulationTendon.h"
namespace physx
{
namespace Bp
{
class BoundsArray;
}
namespace Sc
{
class BodySim;
class BodyCore;
class ArticulationJointSim;
class ArticulationSpatialTendonSim;
class ArticulationFixedTendonSim;
class ArticulationSensorSim;
class ArticulationCore;
class Scene;
class ConstraintSim;
struct ArticulationSimDirtyFlag
{
enum Enum
{
eNONE = 0,
eUPDATE = 1 << 0
};
};
typedef PxFlags<ArticulationSimDirtyFlag::Enum, PxU32> ArticulationSimDirtyFlags;
class ArticulationSim : public PxUserAllocated
{
PX_NOCOPY(ArticulationSim)
public:
ArticulationSim(ArticulationCore& core,
Scene& scene,
BodyCore& root);
~ArticulationSim();
PX_FORCE_INLINE Dy::FeatherstoneArticulation* getLowLevelArticulation() const { return mLLArticulation; }
PX_FORCE_INLINE ArticulationCore& getCore() const { return mCore; }
//we don't need removeBody method anymore because when the articulation is removed from the scene, the articulation sim will
//get completely distroy and when we re-add the articulation to the scene, all the data will get recomputed
void addBody(BodySim& body,
BodySim* parent,
ArticulationJointSim* joint);
void removeBody(BodySim& body);
//we don't need removeTendon method anymore because when the articulation is removed from the scene, the articulation sim will
//get completely distroy and when we re-add the articulation to the scene, all the data will get recomputed
void addTendon(ArticulationSpatialTendonSim*);
//we don't need removeTendon method anymore because when the articulation is removed from the scene, the articulation sim will
//get completely distroy and when we re-add the articulation to the scene, all the data will get recomputed
void addTendon(ArticulationFixedTendonSim*);
//we don't need removeSensor method anymore because when the articulation is removed from the scene, the articulation sim will
//get completely distroy and when we re-add the articulation to the scene, all the data will get recomputed
void addSensor(ArticulationSensorSim* sensor, const PxU32 linkID);
void createLLStructure(); // resize LL memory if necessary
void initializeConfiguration();
void debugCheckWakeCounterOfLinks(PxReal wakeCounter) const;
void debugCheckSleepStateOfLinks(bool isSleeping) const;
bool isSleeping() const;
void internalWakeUp(PxReal wakeCounter); // called when sim sets sleep timer
void sleepCheck(PxReal dt);
void putToSleep();
void updateCCDLinks(PxArray<BodySim*>& sims);
void updateCached(PxBitMapPinned* shapehapeChangedMap);
void markShapesUpdated(PxBitMapPinned* shapeChangedMap);
void updateContactDistance(PxReal* contactDistance, PxReal dt, const Bp::BoundsArray& boundsArray);
void setActive(bool b, bool asPartOfCreation=false);
void updateForces(PxReal dt);
void saveLastCCDTransform();
void clearAcceleration(PxReal dt);
void setFixedBaseLink(bool value);
//external reduced coordinate implementation
PxU32 getDofs() const;
//This function return the dof of the inbound joint, which belong to a link with corresponding linkID
PxU32 getDof(const PxU32 linkID) const;
PxArticulationCache* createCache();
PxU32 getCacheDataSize() const;
void zeroCache(PxArticulationCache&) const;
bool applyCache(PxArticulationCache& cache, const PxArticulationCacheFlags flag) const;
void copyInternalStateToCache
(PxArticulationCache& cache, const PxArticulationCacheFlags flag, const bool isGpuSimEnabled) const;
void packJointData(const PxReal* maximum, PxReal* reduced) const;
void unpackJointData(const PxReal* reduced, PxReal* maximum) const;
void commonInit();
void computeGeneralizedGravityForce(PxArticulationCache& cache);
void computeCoriolisAndCentrifugalForce(PxArticulationCache& cache);
void computeGeneralizedExternalForce(PxArticulationCache& cache);
void computeJointAcceleration(PxArticulationCache& cache);
void computeJointForce(PxArticulationCache& cache);
void computeKinematicJacobian(const PxU32 linkID, PxArticulationCache& cache);
void computeDenseJacobian(PxArticulationCache& cache, PxU32& nRows, PxU32& nCols);
void computeCoefficientMatrix(PxArticulationCache& cache);
bool computeLambda(PxArticulationCache& cache, PxArticulationCache& rollBackCache, const PxReal* jointTorque, const PxVec3 gravity, const PxU32 maxIter);
void computeGeneralizedMassMatrix(PxArticulationCache& cache);
PxU32 getCoefficientMatrixSize() const;
void setRootLinearVelocity(const PxVec3& velocity);
void setRootAngularVelocity(const PxVec3& velocity);
PxSpatialVelocity getLinkVelocity(const PxU32 linkId) const;
PxSpatialVelocity getLinkAcceleration(const PxU32 linkId, const bool isGpuSimEnabled) const;
//internal method implementation
PX_FORCE_INLINE PxNodeIndex getIslandNodeIndex() const { return mIslandNodeIndex; }
void setGlobalPose();
PxU32 findBodyIndex(BodySim &body) const;
void setJointDirty(Dy::ArticulationJointCore& jointCore);
void addLoopConstraint(ConstraintSim* constraint);
void removeLoopConstraint(ConstraintSim* constraint);
PX_FORCE_INLINE PxU32 getMaxDepth() { return mMaxDepth; }
void setArticulationDirty(PxU32 flag);
PX_FORCE_INLINE void setDirtyFlag(ArticulationSimDirtyFlag::Enum flag) { mDirtyFlags = flag; }
PX_FORCE_INLINE ArticulationSimDirtyFlags getDirtyFlag() const { return mDirtyFlags; }
PX_FORCE_INLINE const Dy::ArticulationLink& getLink(const PxU32 linkId) const { return mLinks[linkId]; }
PxU32 getRootActorIndex() const;
const PxSpatialForce& getSensorForce(const PxU32 lowLevelIndex) const;
void updateKinematic(PxArticulationKinematicFlags flags);
void copyJointStatus(const PxU32 linkIndex);
PX_FORCE_INLINE void getLLArticulationInitialized(bool val) { mIsLLArticulationInitialized = val; }
PX_FORCE_INLINE bool getLLArticulationInitialized() { return mIsLLArticulationInitialized; }
private:
Dy::FeatherstoneArticulation* mLLArticulation;
Scene& mScene;
ArticulationCore& mCore;
PxArray<Dy::ArticulationLink> mLinks;
PxArray<BodySim*> mBodies;
PxArray<ArticulationJointSim*> mJoints;
PxArray<Dy::ArticulationSpatialTendon*> mSpatialTendons;
PxArray<Dy::ArticulationFixedTendon*> mFixedTendons;
PxArray<Dy::ArticulationSensor*> mSensors;
PxArray<PxSpatialForce> mSensorForces;
PxNodeIndex mIslandNodeIndex;
PxArray <Dy::ArticulationLoopConstraint> mLoopConstraints;
PxU32 mMaxDepth;
bool mIsLLArticulationInitialized;
ArticulationSimDirtyFlags mDirtyFlags;
};
} // namespace Sc
}
#endif
| 9,172 | C | 39.409691 | 162 | 0.727867 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScSimStateData.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-2023 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 SC_SIM_STATE_DATA_H
#define SC_SIM_STATE_DATA_H
#include "foundation/PxMemory.h"
#include "ScBodyCore.h"
namespace physx
{
namespace Sc
{
struct KinematicTransform
{
PxTransform targetPose; // The body will move to this pose over the superstep following this getting set.
PxU8 targetValid; // User set a kinematic target.
PxU8 pad[2];
PxU8 type;
};
struct Kinematic : public KinematicTransform
{
// The following members buffer the original body data to restore them when switching back to dynamic body
// (for kinematics the corresponding LowLevel properties are set to predefined values)
PxVec3 backupInverseInertia; // The inverse of the body space inertia tensor
PxReal backupInvMass; // The inverse of the body mass
PxReal backupLinearDamping; // The velocity is scaled by (1.0f - this * dt) inside integrateVelocity() every substep.
PxReal backupAngularDamping;
PxReal backupMaxAngVelSq; // The angular velocity's magnitude is clamped to this maximum value.
PxReal backupMaxLinVelSq; // The angular velocity's magnitude is clamped to this maximum value
};
PX_COMPILE_TIME_ASSERT(0 == (sizeof(Kinematic) & 0x0f));
enum VelocityModFlags
{
VMF_GRAVITY_DIRTY = (1 << 0),
VMF_ACC_DIRTY = (1 << 1),
VMF_VEL_DIRTY = (1 << 2)
};
// Important: Struct is reset in setForcesToDefaults.
struct VelocityMod
{
PxVec3 linearPerSec; // A request to change the linear velocity by this much each second. The velocity is changed by this * dt inside integrateVelocity().
PxU8 pad0[4];
PxVec3 angularPerSec;
PxU8 pad1[3];
PxU8 type;
PxVec3 linearPerStep; // A request to change the linear velocity by this much the next step. The velocity is changed inside updateForces().
PxU32 pad2;
PxVec3 angularPerStep;
PxU32 pad3;
PX_FORCE_INLINE void clear() { linearPerSec = angularPerSec = linearPerStep = angularPerStep = PxVec3(0.0f); }
PX_FORCE_INLINE void clearPerStep() { linearPerStep = angularPerStep = PxVec3(0.0f); }
PX_FORCE_INLINE const PxVec3& getLinearVelModPerSec() const { return linearPerSec; }
PX_FORCE_INLINE void accumulateLinearVelModPerSec(const PxVec3& v) { linearPerSec += v; }
PX_FORCE_INLINE void setLinearVelModPerSec(const PxVec3& v) { linearPerSec = v; }
PX_FORCE_INLINE void clearLinearVelModPerSec() { linearPerSec = PxVec3(0.0f); }
PX_FORCE_INLINE const PxVec3& getLinearVelModPerStep() const { return linearPerStep; }
PX_FORCE_INLINE void accumulateLinearVelModPerStep(const PxVec3& v) { linearPerStep += v; }
PX_FORCE_INLINE void clearLinearVelModPerStep() { linearPerStep = PxVec3(0.0f); }
PX_FORCE_INLINE const PxVec3& getAngularVelModPerSec() const { return angularPerSec; }
PX_FORCE_INLINE void accumulateAngularVelModPerSec(const PxVec3& v) { angularPerSec += v; }
PX_FORCE_INLINE void setAngularVelModPerSec(const PxVec3& v) { angularPerSec = v; }
PX_FORCE_INLINE void clearAngularVelModPerSec() { angularPerSec = PxVec3(0.0f); }
PX_FORCE_INLINE const PxVec3& getAngularVelModPerStep() const { return angularPerStep; }
PX_FORCE_INLINE void accumulateAngularVelModPerStep(const PxVec3& v) { angularPerStep += v; }
PX_FORCE_INLINE void clearAngularVelModPerStep() { angularPerStep = PxVec3(0.0f); }
};
PX_COMPILE_TIME_ASSERT(sizeof(VelocityMod) == sizeof(Kinematic));
// Structure to store data either for kinematics (target pose etc.) or for dynamics (vel and accel changes).
// note: we do not delete this object for kinematics even if no target is set.
struct SimStateData : public PxUserAllocated // TODO: may want to optimize the allocation of this further.
{
PxU8 data[sizeof(Kinematic)];
enum Enum
{
eVelMod=0,
eKine
};
SimStateData(){}
SimStateData(const PxU8 type)
{
PxMemZero(data, sizeof(Kinematic));
Kinematic* kine = reinterpret_cast<Kinematic*>(data);
kine->type = type;
}
PX_FORCE_INLINE PxU32 getType() const { const Kinematic* kine = reinterpret_cast<const Kinematic*>(data); return kine->type;}
PX_FORCE_INLINE bool isKine() const {return eKine == getType();}
PX_FORCE_INLINE bool isVelMod() const {return eVelMod == getType();}
PX_FORCE_INLINE Kinematic* getKinematicData() { Kinematic* kine = reinterpret_cast<Kinematic*>(data); PX_ASSERT(eKine == kine->type); return kine;}
PX_FORCE_INLINE VelocityMod* getVelocityModData() { VelocityMod* velmod = reinterpret_cast<VelocityMod*>(data); PX_ASSERT(eVelMod == velmod->type); return velmod;}
PX_FORCE_INLINE const Kinematic* getKinematicData() const { const Kinematic* kine = reinterpret_cast<const Kinematic*>(data); PX_ASSERT(eKine == kine->type); return kine;}
PX_FORCE_INLINE const VelocityMod* getVelocityModData() const { const VelocityMod* velmod = reinterpret_cast<const VelocityMod*>(data); PX_ASSERT(eVelMod == velmod->type); return velmod;}
};
PX_FORCE_INLINE void simStateBackupAndClearBodyProperties(SimStateData* simStateData, PxsBodyCore& core)
{
PX_ASSERT(simStateData && simStateData->isKine());
Kinematic* kine = simStateData->getKinematicData();
kine->backupLinearDamping = core.linearDamping;
kine->backupAngularDamping = core.angularDamping;
kine->backupInverseInertia = core.inverseInertia;
kine->backupInvMass = core.inverseMass;
kine->backupMaxAngVelSq = core.maxAngularVelocitySq;
kine->backupMaxLinVelSq = core.maxLinearVelocitySq;
core.inverseMass = 0.0f;
core.inverseInertia = PxVec3(0.0f);
core.linearDamping = 0.0f;
core.angularDamping = 0.0f;
core.maxAngularVelocitySq = PX_MAX_REAL;
core.maxLinearVelocitySq = PX_MAX_REAL;
}
PX_FORCE_INLINE void simStateRestoreBodyProperties(const SimStateData* simStateData, PxsBodyCore& core)
{
PX_ASSERT(simStateData && simStateData->isKine());
const Kinematic* kine = simStateData->getKinematicData();
core.inverseMass = kine->backupInvMass;
core.inverseInertia = kine->backupInverseInertia;
core.linearDamping = kine->backupLinearDamping;
core.angularDamping = kine->backupAngularDamping;
core.maxAngularVelocitySq = kine->backupMaxAngVelSq;
core.maxLinearVelocitySq = kine->backupMaxLinVelSq;
}
PX_FORCE_INLINE void simStateClearVelMod(SimStateData* simStateData)
{
if (simStateData && simStateData->isVelMod())
{
VelocityMod* velmod = simStateData->getVelocityModData();
velmod->clear();
}
}
PX_FORCE_INLINE bool simStateGetKinematicTarget(const SimStateData* simStateData, PxTransform& p)
{
if (simStateData && simStateData->isKine() && simStateData->getKinematicData()->targetValid)
{
p = simStateData->getKinematicData()->targetPose;
return true;
}
else
return false;
}
PX_FORCE_INLINE bool simStateGetHasValidKinematicTarget(const SimStateData* simStateData)
{
PX_ASSERT(!simStateData || simStateData->isKine());
return simStateData && simStateData->isKine() && simStateData->getKinematicData()->targetValid;
}
PX_FORCE_INLINE void simStateSetKinematicTarget(SimStateData* simStateData, const PxTransform& p)
{
PX_ASSERT(simStateData && simStateData->isKine());
// setting the kinematic target is only allowed if the body is part of a scene, at which point the
// mSimStateData buffer must exist
Kinematic* kine = simStateData->getKinematicData();
kine->targetPose = p;
kine->targetValid = 1;
}
PX_FORCE_INLINE void simStateInvalidateKinematicTarget(SimStateData* simStateData)
{
PX_ASSERT(simStateData && simStateData->isKine());
simStateData->getKinematicData()->targetValid = 0;
}
} // namespace Sc
} // namespace physx
#endif
| 9,395 | C | 42.906542 | 189 | 0.734114 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScIterators.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScIterators.h"
#include "ScBodySim.h"
#include "ScShapeSim.h"
#include "ScShapeInteraction.h"
using namespace physx;
///////////////////////////////////////////////////////////////////////////////
Sc::ContactIterator::Pair::Pair(const void*& contactPatches, const void*& contactPoints, PxU32 /*contactDataSize*/, const PxReal*& forces, PxU32 numContacts, PxU32 numPatches,
ShapeSimBase& shape0, ShapeSimBase& shape1, ActorSim* actor0, ActorSim* actor1)
: mIndex(0)
, mNumContacts(numContacts)
, mIter(reinterpret_cast<const PxU8*>(contactPatches), reinterpret_cast<const PxU8*>(contactPoints), reinterpret_cast<const PxU32*>(forces + numContacts), numPatches, numContacts)
, mForces(forces)
, mActor0(actor0->getPxActor())
, mActor1(actor1->getPxActor())
{
mCurrentContact.shape0 = shape0.getPxShape();
mCurrentContact.shape1 = shape1.getPxShape();
mCurrentContact.normalForceAvailable = (forces != NULL);
}
Sc::ContactIterator::Pair* Sc::ContactIterator::getNextPair()
{
PX_ASSERT(mCurrent || (mCurrent == mLast));
if(mCurrent < mLast)
{
ShapeInteraction* si = static_cast<ShapeInteraction*>(*mCurrent);
const void* contactPatches = NULL;
const void* contactPoints = NULL;
PxU32 contactDataSize = 0;
const PxReal* forces = NULL;
PxU32 numContacts = 0;
PxU32 numPatches = 0;
PxU32 nextOffset = si->getContactPointData(contactPatches, contactPoints, contactDataSize, numContacts, numPatches, forces, mOffset, *mOutputs);
if (nextOffset == mOffset)
++mCurrent;
else
mOffset = nextOffset;
mCurrentPair = Pair(contactPatches, contactPoints, contactDataSize, forces, numContacts, numPatches, si->getShape0(), si->getShape1(), &si->getActorSim0(), &si->getActorSim1());
return &mCurrentPair;
}
else
return NULL;
}
Sc::Contact* Sc::ContactIterator::Pair::getNextContact()
{
if(mIndex < mNumContacts)
{
if(!mIter.hasNextContact())
{
if(!mIter.hasNextPatch())
return NULL;
mIter.nextPatch();
}
PX_ASSERT(mIter.hasNextContact());
mIter.nextContact();
mCurrentContact.normal = mIter.getContactNormal();
mCurrentContact.point = mIter.getContactPoint();
mCurrentContact.separation = mIter.getSeparation();
mCurrentContact.normalForce = mForces ? mForces[mIndex] : 0;
mCurrentContact.faceIndex0 = mIter.getFaceIndex0();
mCurrentContact.faceIndex1 = mIter.getFaceIndex1();
mIndex++;
return &mCurrentContact;
}
return NULL;
}
///////////////////////////////////////////////////////////////////////////////
| 4,205 | C++ | 37.944444 | 179 | 0.719857 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScSoftBodyCore.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "foundation/PxPreprocessor.h"
#if PX_SUPPORT_GPU_PHYSX
#include "ScSoftBodyCore.h"
#include "ScFEMClothCore.h"
#include "ScPhysics.h"
#include "ScSoftBodySim.h"
#include "DySoftBody.h"
#include "GuTetrahedronMesh.h"
#include "GuBV4.h"
#include "geometry/PxTetrahedronMesh.h"
using namespace physx;
Sc::SoftBodyCore::SoftBodyCore() :
ActorCore(PxActorType::eSOFTBODY, PxActorFlag::eVISUALIZATION, PX_DEFAULT_CLIENT, 0),
mGpuMemStat(0)
{
const PxTolerancesScale& scale = Physics::getInstance().getTolerancesScale();
mCore.initialRotation = PxQuat(PxIdentity);
mCore.sleepThreshold = 5e-5f * scale.speed * scale.speed;
mCore.wakeCounter = Physics::sWakeCounterOnCreation;
mCore.freezeThreshold = 5e-6f * scale.speed * scale.speed;
mCore.maxPenBias = -1e32f;//-PX_MAX_F32;
mCore.solverIterationCounts = (1 << 8) | 4;
mCore.dirty = true;
mCore.mFlags = PxSoftBodyFlags(0);
mCore.mPositionInvMass = NULL;
mCore.mRestPosition = NULL;
mCore.mSimPositionInvMass = NULL;
mCore.mSimVelocity = NULL;
mCore.mKinematicTarget = NULL;
}
Sc::SoftBodyCore::~SoftBodyCore() { }
void Sc::SoftBodyCore::setMaterial(const PxU16 handle)
{
mCore.setMaterial(handle);
mCore.dirty = true;
}
void Sc::SoftBodyCore::clearMaterials()
{
mCore.clearMaterials();
mCore.dirty = true;
}
void Sc::SoftBodyCore::setFlags(PxSoftBodyFlags flags)
{
Sc::SoftBodySim* sim = getSim();
if (sim)
{
const bool wasDisabledSelfCollision = mCore.mFlags & PxSoftBodyFlag::eDISABLE_SELF_COLLISION;
const bool isDisabledSelfCollision = flags & PxSoftBodyFlag::eDISABLE_SELF_COLLISION;
if (wasDisabledSelfCollision != isDisabledSelfCollision)
{
if (isDisabledSelfCollision)
sim->disableSelfCollision();
else
sim->enableSelfCollision();
}
}
mCore.mFlags = flags;
mCore.dirty = true;
}
template <typename I>
void computeRestPoses(PxVec4* pInvMasses, PxMat33* tetraRestPoses, const I* const indices, const PxU32 nbTetra)
{
for (PxU32 i = 0; i < nbTetra; ++i)
{
const PxU32 startIndex = i * 4;
// calculate rest pose
const PxVec3 x0 = pInvMasses[indices[startIndex + 0]].getXYZ();
const PxVec3 x1 = pInvMasses[indices[startIndex + 1]].getXYZ();
const PxVec3 x2 = pInvMasses[indices[startIndex + 2]].getXYZ();
const PxVec3 x3 = pInvMasses[indices[startIndex + 3]].getXYZ();
const PxVec3 u1 = x1 - x0;
const PxVec3 u2 = x2 - x0;
const PxVec3 u3 = x3 - x0;
PxMat33 Q = PxMat33(u1, u2, u3);
tetraRestPoses[i] = Q.getInverse();
#if PX_CHECKED
const float det = Q.getDeterminant();
if (fabsf(det) <= 1.e-9f)
{
PxGetFoundation().error(PxErrorCode::eINVALID_PARAMETER, PX_FL, "computeRestPoses(): Degenerate or inverted tetrahedron\n");
}
#endif
}
}
PxFEMParameters Sc::SoftBodyCore::getParameter() const
{
return mCore.parameters;
}
void Sc::SoftBodyCore::setParameter(const PxFEMParameters parameter)
{
mCore.parameters = parameter;
mCore.dirty = true;
}
PxReal Sc::SoftBodyCore::getSleepThreshold() const
{
return mCore.sleepThreshold;
}
void Sc::SoftBodyCore::setSleepThreshold(const PxReal v)
{
mCore.sleepThreshold = v;
mCore.dirty = true;
}
PxReal Sc::SoftBodyCore::getFreezeThreshold() const
{
return mCore.freezeThreshold;
}
void Sc::SoftBodyCore::setFreezeThreshold(const PxReal v)
{
mCore.freezeThreshold = v;
mCore.dirty = true;
}
void Sc::SoftBodyCore::setSolverIterationCounts(const PxU16 c)
{
mCore.solverIterationCounts = c;
mCore.dirty = true;
}
PxReal Sc::SoftBodyCore::getWakeCounter() const
{
return mCore.wakeCounter;
}
void Sc::SoftBodyCore::setWakeCounter(const PxReal v)
{
mCore.wakeCounter = v;
mCore.dirty = true;
Sc::SoftBodySim* sim = getSim();
if (sim)
{
sim->onSetWakeCounter();
}
}
void Sc::SoftBodyCore::setWakeCounterInternal(const PxReal v)
{
mCore.wakeCounter = v;
mCore.dirty = true;
Sc::SoftBodySim* sim = getSim();
if (sim)
{
sim->onSetWakeCounter();
}
}
bool Sc::SoftBodyCore::isSleeping() const
{
Sc::SoftBodySim* sim = getSim();
return sim ? sim->isSleeping() : (mCore.wakeCounter == 0.0f);
}
void Sc::SoftBodyCore::wakeUp(PxReal wakeCounter)
{
mCore.wakeCounter = wakeCounter;
mCore.dirty = true;
}
void Sc::SoftBodyCore::putToSleep()
{
mCore.wakeCounter = 0.0f;
mCore.dirty = true;
}
PxActor* Sc::SoftBodyCore::getPxActor() const
{
return PxPointerOffset<PxActor*>(const_cast<SoftBodyCore*>(this), gOffsetTable.scCore2PxActor[getActorCoreType()]);
}
void Sc::SoftBodyCore::attachShapeCore(ShapeCore* shapeCore)
{
Sc::SoftBodySim* sim = getSim();
if (sim)
{
sim->attachShapeCore(shapeCore);
mCore.dirty = true;
}
}
void Sc::SoftBodyCore::attachSimulationMesh(PxTetrahedronMesh* simulationMesh, PxSoftBodyAuxData* simulationState)
{
Sc::SoftBodySim* sim = getSim();
if (sim)
{
sim->attachSimulationMesh(simulationMesh, simulationState);
mCore.dirty = true;
}
}
Sc::SoftBodySim* Sc::SoftBodyCore::getSim() const
{
return static_cast<Sc::SoftBodySim*>(ActorCore::getSim());
}
void Sc::SoftBodyCore::setSimulationFilterData(const PxFilterData& data)
{
mFilterData = data;
}
PxFilterData Sc::SoftBodyCore::getSimulationFilterData() const
{
return mFilterData;
}
void Sc::SoftBodyCore::addParticleFilter(Sc::ParticleSystemCore* core, PxU32 particleId, PxU32 userBufferId, PxU32 tetId)
{
Sc::SoftBodySim* sim = getSim();
if (sim)
sim->getScene().addParticleFilter(core, *sim, particleId, userBufferId, tetId);
}
void Sc::SoftBodyCore::removeParticleFilter(Sc::ParticleSystemCore* core, PxU32 particleId, PxU32 userBufferId, PxU32 tetId)
{
Sc::SoftBodySim* sim = getSim();
if (sim)
sim->getScene().removeParticleFilter(core, *sim, particleId, userBufferId, tetId);
}
PxU32 Sc::SoftBodyCore::addParticleAttachment(Sc::ParticleSystemCore* core, PxU32 particleId, PxU32 userBufferId, PxU32 tetId, const PxVec4& barycentric)
{
Sc::SoftBodySim* sim = getSim();
PxU32 handle = 0xFFFFFFFF;
if (sim)
handle = sim->getScene().addParticleAttachment(core, *sim, particleId, userBufferId, tetId, barycentric);
return handle;
}
void Sc::SoftBodyCore::removeParticleAttachment(Sc::ParticleSystemCore* core, PxU32 handle)
{
Sc::SoftBodySim* sim = getSim();
if (sim)
{
sim->getScene().removeParticleAttachment(core, *sim, handle);
setWakeCounter(ScInternalWakeCounterResetValue);
}
}
void Sc::SoftBodyCore::addRigidFilter(Sc::BodyCore* core, PxU32 vertId)
{
Sc::SoftBodySim* sim = getSim();
if (sim)
sim->getScene().addRigidFilter(core, *sim, vertId);
}
void Sc::SoftBodyCore::removeRigidFilter(Sc::BodyCore* core, PxU32 vertId)
{
Sc::SoftBodySim* sim = getSim();
if (sim)
sim->getScene().removeRigidFilter(core, *sim, vertId);
}
PxU32 Sc::SoftBodyCore::addRigidAttachment(Sc::BodyCore* core, PxU32 particleId, const PxVec3& actorSpacePose, PxConeLimitedConstraint* constraint)
{
Sc::SoftBodySim* sim = getSim();
PxU32 handle = 0xFFFFFFFF;
if(sim)
handle = sim->getScene().addRigidAttachment(core, *sim, particleId, actorSpacePose, constraint);
return handle;
}
void Sc::SoftBodyCore::removeRigidAttachment(Sc::BodyCore* core, PxU32 handle)
{
Sc::SoftBodySim* sim = getSim();
if (sim)
{
sim->getScene().removeRigidAttachment(core, *sim, handle);
setWakeCounter(ScInternalWakeCounterResetValue);
}
}
void Sc::SoftBodyCore::addTetRigidFilter(Sc::BodyCore* core, PxU32 tetIdx)
{
Sc::SoftBodySim* sim = getSim();
if (sim)
sim->getScene().addTetRigidFilter(core, *sim, tetIdx);
}
void Sc::SoftBodyCore::removeTetRigidFilter(Sc::BodyCore* core, PxU32 tetIdx)
{
Sc::SoftBodySim* sim = getSim();
if (sim)
{
sim->getScene().removeTetRigidFilter(core, *sim, tetIdx);
}
}
PxU32 Sc::SoftBodyCore::addTetRigidAttachment(Sc::BodyCore* core, PxU32 tetIdx, const PxVec4& barycentric,
const PxVec3& actorSpacePose, PxConeLimitedConstraint* constraint)
{
Sc::SoftBodySim* sim = getSim();
PxU32 handle = 0xFFFFFFFF;
if (sim)
handle = sim->getScene().addTetRigidAttachment(core, *sim, tetIdx, barycentric, actorSpacePose, constraint);
return handle;
}
void Sc::SoftBodyCore::addSoftBodyFilter(Sc::SoftBodyCore& core, PxU32 tetIdx0, PxU32 tetIdx1)
{
Sc::SoftBodySim* sim = getSim();
if (sim)
sim->getScene().addSoftBodyFilter(core, tetIdx0, *sim, tetIdx1);
}
void Sc::SoftBodyCore::removeSoftBodyFilter(Sc::SoftBodyCore& core, PxU32 tetIdx0, PxU32 tetIdx1)
{
Sc::SoftBodySim* sim = getSim();
if (sim)
sim->getScene().removeSoftBodyFilter(core, tetIdx0, *sim, tetIdx1);
}
void Sc::SoftBodyCore::addSoftBodyFilters(Sc::SoftBodyCore& core, PxU32* tetIndices0, PxU32* tetIndices1, PxU32 tetIndicesSize)
{
Sc::SoftBodySim* sim = getSim();
if (sim)
sim->getScene().addSoftBodyFilters(core, *sim, tetIndices0, tetIndices1, tetIndicesSize);
}
void Sc::SoftBodyCore::removeSoftBodyFilters(Sc::SoftBodyCore& core, PxU32* tetIndices0, PxU32* tetIndices1, PxU32 tetIndicesSize)
{
Sc::SoftBodySim* sim = getSim();
if (sim)
sim->getScene().removeSoftBodyFilters(core, *sim, tetIndices0, tetIndices1, tetIndicesSize);
}
PxU32 Sc::SoftBodyCore::addSoftBodyAttachment(Sc::SoftBodyCore& core, PxU32 tetIdx0, const PxVec4& triBarycentric0, PxU32 tetIdx1, const PxVec4& tetBarycentric1,
PxConeLimitedConstraint* constraint, PxReal constraintOffset)
{
Sc::SoftBodySim* sim = getSim();
PxU32 handle = 0xFFFFFFFF;
if (sim)
handle = sim->getScene().addSoftBodyAttachment(core, tetIdx0, triBarycentric0, *sim, tetIdx1, tetBarycentric1, constraint, constraintOffset);
return handle;
}
void Sc::SoftBodyCore::removeSoftBodyAttachment(Sc::SoftBodyCore& core, PxU32 handle)
{
Sc::SoftBodySim* sim = getSim();
setWakeCounterInternal(ScInternalWakeCounterResetValue);
core.setWakeCounterInternal(ScInternalWakeCounterResetValue);
if (sim)
sim->getScene().removeSoftBodyAttachment(core, *sim, handle);
}
void Sc::SoftBodyCore::addClothFilter(Sc::FEMClothCore& core, PxU32 triIdx, PxU32 tetIdx)
{
Sc::SoftBodySim* sim = getSim();
if (sim)
sim->getScene().addClothFilter(core, triIdx, *sim, tetIdx);
}
void Sc::SoftBodyCore::removeClothFilter(Sc::FEMClothCore& core, PxU32 triIdx, PxU32 tetIdx)
{
Sc::SoftBodySim* sim = getSim();
if (sim)
sim->getScene().removeClothFilter(core, triIdx, *sim, tetIdx);
}
void Sc::SoftBodyCore::addVertClothFilter(Sc::FEMClothCore& core, PxU32 vertIdx, PxU32 tetIdx)
{
Sc::SoftBodySim* sim = getSim();
if (sim)
sim->getScene().addVertClothFilter(core, vertIdx, *sim, tetIdx);
}
void Sc::SoftBodyCore::removeVertClothFilter(Sc::FEMClothCore& core, PxU32 vertIdx, PxU32 tetIdx)
{
Sc::SoftBodySim* sim = getSim();
if (sim)
sim->getScene().removeVertClothFilter(core, vertIdx, *sim, tetIdx);
}
PxU32 Sc::SoftBodyCore::addClothAttachment(Sc::FEMClothCore& core, PxU32 triIdx, const PxVec4& triBarycentric, PxU32 tetIdx, const PxVec4& tetBarycentric,
PxConeLimitedConstraint* constraint, PxReal constraintOffset)
{
Sc::SoftBodySim* sim = getSim();
PxU32 handle = 0xFFFFFFFF;
if (sim)
handle = sim->getScene().addClothAttachment(core, triIdx, triBarycentric, *sim, tetIdx, tetBarycentric, constraint, constraintOffset);
return handle;
}
void Sc::SoftBodyCore::removeClothAttachment(Sc::FEMClothCore& core, PxU32 handle)
{
Sc::SoftBodySim* sim = getSim();
setWakeCounter(ScInternalWakeCounterResetValue);
core.setWakeCounter(ScInternalWakeCounterResetValue);
if (sim)
sim->getScene().removeClothAttachment(core, *sim, handle);
}
PxU32 Sc::SoftBodyCore::getGpuSoftBodyIndex() const
{
const Sc::SoftBodySim* sim = getSim();
return sim ? sim->getGpuSoftBodyIndex() : 0xffffffff;
}
void Sc::SoftBodyCore::onShapeChange(ShapeCore& shape, ShapeChangeNotifyFlags notifyFlags)
{
PX_UNUSED(shape);
SoftBodySim* sim = getSim();
if (!sim)
return;
SoftBodyShapeSim& s = sim->getShapeSim();
if (notifyFlags & ShapeChangeNotifyFlag::eGEOMETRY)
s.onVolumeOrTransformChange();
if (notifyFlags & ShapeChangeNotifyFlag::eMATERIAL)
s.onMaterialChange();
if (notifyFlags & ShapeChangeNotifyFlag::eRESET_FILTERING)
s.onResetFiltering();
if (notifyFlags & ShapeChangeNotifyFlag::eSHAPE2BODY)
s.onVolumeOrTransformChange();
if (notifyFlags & ShapeChangeNotifyFlag::eFILTERDATA)
s.onFilterDataChange();
if (notifyFlags & ShapeChangeNotifyFlag::eCONTACTOFFSET)
s.onContactOffsetChange();
if (notifyFlags & ShapeChangeNotifyFlag::eRESTOFFSET)
s.onRestOffsetChange();
}
void Sc::SoftBodyCore::setKinematicTargets(const PxVec4* positions, PxSoftBodyFlags flags)
{
mCore.mKinematicTarget = positions;
if (positions != NULL)
{
mCore.mFlags |= PxSoftBodyFlags(flags & PxSoftBodyFlags(PxSoftBodyFlag::eKINEMATIC | PxSoftBodyFlag::ePARTIALLY_KINEMATIC));
}
else
{
mCore.mFlags.clear(PxSoftBodyFlag::eKINEMATIC);
mCore.mFlags.clear(PxSoftBodyFlag::ePARTIALLY_KINEMATIC);
}
mCore.dirty = true;
}
#endif //PX_SUPPORT_GPU_PHYSX
| 14,426 | C++ | 26.637931 | 161 | 0.745598 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScArticulationSim.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScArticulationSim.h"
#include "ScArticulationCore.h"
#include "ScArticulationJointSim.h"
#include "ScArticulationJointCore.h"
#include "ScBodySim.h"
#include "ScConstraintSim.h"
#include "ScArticulationTendonSim.h"
#include "ScArticulationSensorSim.h"
#include "ScArticulationSensor.h"
#include "ScScene.h"
#include "DyConstraint.h"
#include "DyFeatherstoneArticulation.h"
#include "PxsContext.h"
#include "CmSpatialVector.h"
#include "foundation/PxVecMath.h"
#include "PxsSimpleIslandManager.h"
#include "ScShapeSim.h"
#include "PxsSimulationController.h"
using namespace physx;
using namespace physx::Dy;
Sc::ArticulationSim::ArticulationSim(ArticulationCore& core, Scene& scene, BodyCore& root) :
mLLArticulation (NULL),
mScene (scene),
mCore (core),
mLinks ("ScArticulationSim::links"),
mBodies ("ScArticulationSim::bodies"),
mJoints ("ScArticulationSim::joints"),
mMaxDepth (0),
mIsLLArticulationInitialized(false)
{
mLinks.reserve(16);
mJoints.reserve(16);
mBodies.reserve(16);
mLLArticulation = mScene.createLLArticulation(this);
mIslandNodeIndex = scene.getSimpleIslandManager()->addArticulation(mLLArticulation, false);
if(!mLLArticulation)
{
PxGetFoundation().error(PxErrorCode::eINTERNAL_ERROR, PX_FL, "Articulation: could not allocate low-level resources.");
return;
}
PX_ASSERT(root.getSim());
addBody(*root.getSim(), NULL, NULL);
mCore.setSim(this);
mLLArticulation->setDyContext(mScene.getDynamicsContext());
mLLArticulation->getSolverDesc().initData(&core.getCore(), NULL);
//mLLArticulation->onUpdateSolverDesc();
}
Sc::ArticulationSim::~ArticulationSim()
{
if (!mLLArticulation)
return;
mScene.destroyLLArticulation(*mLLArticulation);
mScene.getSimpleIslandManager()->removeNode(mIslandNodeIndex);
mCore.setSim(NULL);
}
PxU32 Sc::ArticulationSim::findBodyIndex(BodySim& body) const
{
for(PxU32 i=0; i<mBodies.size(); i++)
{
if(mBodies[i]==&body)
return i;
}
PX_ASSERT(0);
return 0x80000000;
}
void Sc::ArticulationSim::addLoopConstraint(ConstraintSim* constraintSim)
{
const PxU32 size = mLoopConstraints.size();
if (size < mLoopConstraints.size())
mLoopConstraints.reserve(size*2 + 1);
BodySim* bodySim0 = constraintSim->getBody(0);
BodySim* bodySim1 = constraintSim->getBody(1);
ArticulationLoopConstraint lConstraint;
if (bodySim0)
lConstraint.linkIndex0 = findBodyIndex(*bodySim0);
else
lConstraint.linkIndex0 = 0x80000000;
if(bodySim1)
lConstraint.linkIndex1 = findBodyIndex(*bodySim1);
else
lConstraint.linkIndex1 = 0x80000000;
lConstraint.constraint = &constraintSim->getLowLevelConstraint();
mLoopConstraints.pushBack(lConstraint);
}
void Sc::ArticulationSim::removeLoopConstraint(ConstraintSim* constraintSim)
{
Dy::Constraint* constraint = &constraintSim->getLowLevelConstraint();
const PxU32 size = mLoopConstraints.size();
PxU32 index = 0;
while (index < size && mLoopConstraints[index].constraint != constraint)
++index;
if (index != size)
mLoopConstraints.replaceWithLast(index);
}
void Sc::ArticulationSim::updateCached(PxBitMapPinned* shapeChangedMap)
{
for(PxU32 i=0; i<mBodies.size(); i++)
mBodies[i]->updateCached(shapeChangedMap);
}
void Sc::ArticulationSim::markShapesUpdated(PxBitMapPinned* shapeChangedMap)
{
for (PxU32 a = 0; a < mBodies.size(); ++a)
{
PxU32 nbElems = mBodies[a]->getNbElements();
ElementSim** elems = mBodies[a]->getElements();
while (nbElems--)
{
ShapeSim* sim = static_cast<ShapeSim*>(*elems++);
if (sim->isInBroadPhase())
shapeChangedMap->growAndSet(sim->getElementID());
}
}
}
void Sc::ArticulationSim::addBody(BodySim& body, BodySim* parent, ArticulationJointSim* joint)
{
mBodies.pushBack(&body);
mJoints.pushBack(joint);
mLLArticulation->addBody();
const PxU32 index = mLinks.size();
PX_ASSERT((((index==0) && (joint == 0)) && (parent == 0)) ||
(((index!=0) && joint) && (parent && (parent->getArticulation() == this))));
ArticulationLink& link = mLinks.insert();
link.bodyCore = &body.getBodyCore().getCore();
link.children = 0;
link.mPathToRootStartIndex = 0;
link.mPathToRootCount = 0;
link.mChildrenStartIndex = 0xffffffff;
link.mNumChildren = 0;
bool shouldSleep;
bool currentlyAsleep;
const bool bodyReadyForSleep = body.checkSleepReadinessBesidesWakeCounter();
const PxReal wakeCounter = getCore().getWakeCounter();
if(parent)
{
currentlyAsleep = !mBodies[0]->isActive();
shouldSleep = currentlyAsleep && bodyReadyForSleep;
PxU32 parentIndex = findBodyIndex(*parent);
link.parent = parentIndex;
ArticulationLink& parentLink = mLinks[parentIndex];
link.pathToRoot = parentLink.pathToRoot | ArticulationBitField(1)<<index;
link.inboundJoint = &joint->getCore().getCore();
parentLink.children |= ArticulationBitField(1)<<index;
if (parentLink.mChildrenStartIndex == 0xffffffff)
parentLink.mChildrenStartIndex = index;
parentLink.mNumChildren++;
}
else
{
currentlyAsleep = (wakeCounter == 0.0f);
shouldSleep = currentlyAsleep && bodyReadyForSleep;
link.parent = DY_ARTICULATION_LINK_NONE;
link.pathToRoot = 1;
link.inboundJoint = NULL;
}
if(currentlyAsleep && !shouldSleep)
{
for(PxU32 i=0; i < (mBodies.size() - 1); i++)
mBodies[i]->internalWakeUpArticulationLink(wakeCounter);
}
body.setArticulation(this, wakeCounter, shouldSleep, index);
}
void Sc::ArticulationSim::removeBody(BodySim& body)
{
for (PxU32 i = 0; i < mBodies.size(); ++i)
{
if (mBodies[i] == &body)
{
mBodies.replaceWithLast(i);
mJoints.replaceWithLast(i);
break;
}
}
}
void Sc::ArticulationSim::addTendon(ArticulationSpatialTendonSim* tendonSim)
{
tendonSim->mArtiSim = this;
const PxU32 index = mSpatialTendons.size();
Dy::ArticulationSpatialTendon& llTendon = tendonSim->mLLTendon;
llTendon.setTendonIndex(index);
mSpatialTendons.pushBack(&llTendon);
//mSpatialTendons.pushBack(&tendonSim->mLLTendon);
}
void Sc::ArticulationSim::addTendon(ArticulationFixedTendonSim* tendonSim)
{
tendonSim->mArtiSim = this;
const PxU32 index = mFixedTendons.size();
Dy::ArticulationFixedTendon& llTendon = tendonSim->mLLTendon;
llTendon.setTendonIndex(index);
mFixedTendons.pushBack(&llTendon);
}
void Sc::ArticulationSim::addSensor(ArticulationSensorSim* sensorSim, const PxU32 linkID)
{
const PxU32 index = mSensors.size();
sensorSim->setLowLevelIndex(index);
sensorSim->mArticulationSim = this;
Dy::ArticulationSensor& llSensor = sensorSim->getLLSensor();
llSensor.mLinkID = PxU16(linkID);
mSensors.pushBack(&llSensor);
mSensorForces.insert();
mSensorForces.back().force = PxVec3(0.f);
mSensorForces.back().torque = PxVec3(0.f);
}
void Sc::ArticulationSim::createLLStructure()
{
if(!mBodies.size())
return;
mLLArticulation->setupLinks(mLinks.size(), const_cast<Dy::ArticulationLink*>(mLinks.begin()));
mLLArticulation->assignTendons(mSpatialTendons.size(), const_cast<Dy::ArticulationSpatialTendon**>(mSpatialTendons.begin()));
mLLArticulation->assignTendons(mFixedTendons.size(), const_cast<Dy::ArticulationFixedTendon**>(mFixedTendons.begin()));
mLLArticulation->assignSensors(mSensors.size(), const_cast<Dy::ArticulationSensor**>(mSensors.begin()), const_cast<PxSpatialForce*>(mSensorForces.begin()));
mIsLLArticulationInitialized = true;
}
void Sc::ArticulationSim::initializeConfiguration()
{
Dy::ArticulationData& data = mLLArticulation->getArticulationData();
mLLArticulation->jcalc(data);
mLLArticulation->mJcalcDirty = false;
Dy::ArticulationLink* links = data.getLinks();
Dy::ArticulationJointCoreData* jointData = data.getJointData();
const PxU32 linkCount = data.getLinkCount();
PxReal* jointVelocites = data.getJointVelocities();
PxReal* jointPositions = data.getJointPositions();
PxReal* jointTargetPositions = data.getJointTargetPositions();
PxReal* jointTargetVelocities = data.getJointTargetVelocities();
for (PxU32 linkID = 1; linkID < linkCount; ++linkID)
{
Dy::ArticulationLink& link = links[linkID];
Dy::ArticulationJointCore* joint = link.inboundJoint;
Dy::ArticulationJointCoreData& jointDatum = jointData[linkID];
PxReal* jPositions = &jointPositions[jointDatum.jointOffset];
PxReal* jVelocites = &jointVelocites[jointDatum.jointOffset];
PxReal* jTargetPositions = &jointTargetPositions[jointDatum.jointOffset];
PxReal* jTargetVelocities = &jointTargetVelocities[jointDatum.jointOffset];
for (PxU8 i = 0; i < jointDatum.dof; ++i)
{
const PxU32 dofId = joint->dofIds[i];
jPositions[i] = joint->jointPos[dofId];
jVelocites[i] = joint->jointVel[dofId];
jTargetPositions[i] = joint->targetP[dofId];
jTargetVelocities[i] = joint->targetV[dofId];
}
}
PxU32 flags = (Dy::ArticulationDirtyFlag::eDIRTY_POSITIONS |
Dy::ArticulationDirtyFlag::eDIRTY_VELOCITIES |
Dy::ArticulationDirtyFlag::eDIRTY_JOINT_TARGET_POS |
Dy::ArticulationDirtyFlag::eDIRTY_JOINT_TARGET_VEL);
mLLArticulation->raiseGPUDirtyFlag(Dy::ArticulationDirtyFlag::Enum(flags));
mLLArticulation->initPathToRoot();
}
void Sc::ArticulationSim::updateKinematic(PxArticulationKinematicFlags flags)
{
Dy::ArticulationData& data = mLLArticulation->getArticulationData();
if (mLLArticulation->mJcalcDirty)
{
mLLArticulation->jcalc(data);
mLLArticulation->mJcalcDirty = false;
}
if ((flags & PxArticulationKinematicFlag::ePOSITION))
{
mLLArticulation->raiseGPUDirtyFlag(Dy::ArticulationDirtyFlag::eDIRTY_POSITIONS);
mLLArticulation->teleportLinks(data);
}
if ((flags & PxArticulationKinematicFlag::ePOSITION) ||
(flags & PxArticulationKinematicFlag::eVELOCITY))
{
mLLArticulation->raiseGPUDirtyFlag(Dy::ArticulationDirtyFlag::eDIRTY_VELOCITIES);
mLLArticulation->computeLinkVelocities(data);
}
}
void Sc::ArticulationSim::copyJointStatus(const PxU32 linkID)
{
Dy::ArticulationData& data = mLLArticulation->getArticulationData();
Dy::ArticulationLink* links = data.getLinks();
Dy::ArticulationJointCoreData* jointData = data.getJointData();
Dy::ArticulationLink& link = links[linkID];
Dy::ArticulationJointCore* joint = link.inboundJoint;
Dy::ArticulationJointCoreData& jointDatum = jointData[linkID];
PxReal* jointVelocites = data.getJointVelocities();
PxReal* jointPositions = data.getJointPositions();
PxReal* jVelocities = &jointVelocites[jointDatum.jointOffset];
PxReal* jPositions = &jointPositions[jointDatum.jointOffset];
for(PxU8 i = 0; i < jointDatum.dof; ++i)
{
const PxU32 dofId = joint->dofIds[i];
joint->jointPos[dofId] = jPositions[i];
joint->jointVel[dofId] = jVelocities[i];
}
}
void Sc::ArticulationSim::updateCCDLinks(PxArray<BodySim*>& sims)
{
for (PxU32 a = 0; a < mBodies.size(); ++a)
{
if (mBodies[a]->getLowLevelBody().getCore().mFlags & PxRigidBodyFlag::eENABLE_CCD)
{
sims.pushBack(mBodies[a]);
}
}
}
void Sc::ArticulationSim::putToSleep()
{
for (PxU32 i = 0; i < mLinks.size(); i++)
{
BodySim* bodySim = mBodies[i];
PxsRigidBody& rigid = bodySim->getLowLevelBody();
PxsBodyCore& bodyCore = bodySim->getBodyCore().getCore();
//rigid.setPose(rigid.getLastCCDTransform());
//KS - the IG deactivates bodies in parallel with the solver. It appears that under certain circumstances, the solver's integration (which performs
//sleep checks) could decide that the body is no longer a candidate for sleeping on the same frame that the island gen decides to deactivate the island
//that the body is contained in. This is a rare occurrence but the behavior we want to emulate is that of IG running before solver so we should therefore
//permit the IG to make the authoritative decision over whether the body should be active or inactive.
bodyCore.wakeCounter = 0.0f;
bodyCore.linearVelocity = PxVec3(0.0f);
bodyCore.angularVelocity = PxVec3(0.0f);
rigid.clearAllFrameFlags();
//Force update
}
mScene.getSimulationController()->updateArticulation(mLLArticulation, mIslandNodeIndex);
}
void Sc::ArticulationSim::sleepCheck(PxReal dt)
{
if(!mBodies.size())
return;
#if PX_CHECKED
{
PxReal maxTimer = 0.0f, minTimer = PX_MAX_F32;
bool allActive = true, noneActive = true;
PX_UNUSED(allActive);
PX_UNUSED(noneActive);
for(PxU32 i=0;i<mLinks.size();i++)
{
PxReal timer = mBodies[i]->getBodyCore().getWakeCounter();
maxTimer = PxMax(maxTimer, timer);
minTimer = PxMin(minTimer, timer);
bool active = mBodies[i]->isActive();
allActive &= active;
noneActive &= !active;
}
// either all links are asleep, or no links are asleep
PX_ASSERT(maxTimer==0 || minTimer!=0);
PX_ASSERT(allActive || noneActive);
}
#endif
if(!mBodies[0]->isActive())
return;
const PxReal sleepThreshold = getCore().getCore().sleepThreshold;
PxReal maxTimer = 0.0f , minTimer = PX_MAX_F32;
for(PxU32 i=0;i<mLinks.size();i++)
{
const Cm::SpatialVector& motionVelocity = mLLArticulation->getMotionVelocity(i);
PxReal timer = mBodies[i]->updateWakeCounter(dt, sleepThreshold, motionVelocity);
maxTimer = PxMax(maxTimer, timer);
minTimer = PxMin(minTimer, timer);
}
mCore.setWakeCounterInternal(maxTimer);
if(maxTimer != 0.0f)
{
if(minTimer == 0.0f)
{
// make sure nothing goes to sleep unless everything does
for(PxU32 i=0;i<mLinks.size();i++)
mBodies[i]->getBodyCore().setWakeCounterFromSim(PxMax(1e-6f, mBodies[i]->getBodyCore().getWakeCounter()));
}
return;
}
for(PxU32 i=0;i<mLinks.size();i++)
{
mBodies[i]->notifyReadyForSleeping();
mBodies[i]->getLowLevelBody().resetSleepFilter();
}
mScene.getSimpleIslandManager()->deactivateNode(mIslandNodeIndex);
}
bool Sc::ArticulationSim::isSleeping() const
{
return (mBodies.size() > 0) ? (!mBodies[0]->isActive()) : true;
}
void Sc::ArticulationSim::internalWakeUp(PxReal wakeCounter)
{
if(mCore.getWakeCounter() < wakeCounter)
{
mCore.setWakeCounterInternal(wakeCounter);
for(PxU32 i=0;i<mBodies.size();i++)
mBodies[i]->internalWakeUpArticulationLink(wakeCounter);
}
}
void Sc::ArticulationSim::updateForces(PxReal dt)
{
PxU32 count = 0;
bool anyForcesApplied = false;
for(PxU32 i=0;i<mBodies.size();i++)
{
if (i+1 < mBodies.size())
{
PxPrefetchLine(mBodies[i+1],128);
PxPrefetchLine(mBodies[i+1],256);
}
anyForcesApplied |= mBodies[i]->updateForces(dt, NULL, NULL, count, &mLLArticulation->getSolverDesc().acceleration[i]);
}
if(anyForcesApplied)
mLLArticulation->raiseGPUDirtyFlag(Dy::ArticulationDirtyFlag::eDIRTY_EXT_ACCEL);
}
void Sc::ArticulationSim::clearAcceleration(PxReal dt)
{
PxU32 count = 0;
bool anyBodyRetains = false;
for (PxU32 i = 0; i < mBodies.size(); i++)
{
if (i + 1 < mBodies.size())
{
PxPrefetchLine(mBodies[i + 1], 128);
PxPrefetchLine(mBodies[i + 1], 256);
}
const bool accDirty = mBodies[i]->readVelocityModFlag(VMF_ACC_DIRTY);
// the code restores the pre-impulse state:
// if we only applied an impulse and no acceleration, we clear the acceleration here.
// if we applied an acceleration, we re-apply the acceleration terms we have in the velMod.
// we cleared out the impulse here when we pushed the data at the start of the sim.
if (!accDirty)
{
mLLArticulation->getSolverDesc().acceleration[i].linear = PxVec3(0.f);
mLLArticulation->getSolverDesc().acceleration[i].angular = PxVec3(0.f);
}
else
{
mBodies[i]->updateForces(dt, NULL, NULL, count, &mLLArticulation->getSolverDesc().acceleration[i]);
}
// we need to raise the dirty flag if retain accelerations is on
// because in that case we need to restore the acceleration without impulses. We
// can only do that using the CPU->GPU codepath because we don't distinguish between
// acceleration and impulses on the GPU.
// The flag must be raised here because we don't know at the start of the next sim step
// that the data in velMod is actually valid and the articulation would not be added
// to the dirty list.
// without retain accelerations, the accelerations are cleared directly on the GPU.
if (mBodies[i]->getFlagsFast() & PxRigidBodyFlag::eRETAIN_ACCELERATIONS)
anyBodyRetains = true;
}
if (anyBodyRetains)
{
mScene.getSimulationController()->updateArticulationExtAccel(mLLArticulation, mIslandNodeIndex);
}
}
void Sc::ArticulationSim::saveLastCCDTransform()
{
for(PxU32 i=0;i<mBodies.size();i++)
{
if (i+1 < mBodies.size())
{
PxPrefetchLine(mBodies[i+1],128);
PxPrefetchLine(mBodies[i+1],256);
}
mBodies[i]->getLowLevelBody().saveLastCCDTransform();
}
}
void Sc::ArticulationSim::setFixedBaseLink(bool value)
{
const PxU32 linkCount = mLinks.size();
if(linkCount > 0)
mLinks[0].bodyCore->fixedBaseLink = PxU8(value);
}
PxU32 Sc::ArticulationSim::getDofs() const
{
return mLLArticulation->getDofs();
}
PxU32 Sc::ArticulationSim::getDof(const PxU32 linkID) const
{
return mLLArticulation->getDof(linkID);
}
PX_COMPILE_TIME_ASSERT(sizeof(Cm::SpatialVector)==sizeof(PxSpatialForce));
PxArticulationCache* Sc::ArticulationSim::createCache()
{
return FeatherstoneArticulation::createCache(getDofs(), mLinks.size(), mSensors.size());
}
PxU32 Sc::ArticulationSim::getCacheDataSize() const
{
return FeatherstoneArticulation::getCacheDataSize(getDofs(), mLinks.size(), mSensors.size());
}
void Sc::ArticulationSim::zeroCache(PxArticulationCache& cache) const
{
const PxU32 cacheDataSize = getCacheDataSize();
PxMemZero(cache.externalForces, cacheDataSize);
}
//copy external data to internal data
bool Sc::ArticulationSim::applyCache(PxArticulationCache& cache, const PxArticulationCacheFlags flag) const
{
//checkResize();
bool shouldWake = false;
if (mLLArticulation->applyCache(cache, flag, shouldWake))
{
mScene.getSimulationController()->updateArticulation(mLLArticulation, mIslandNodeIndex);
}
return shouldWake;
}
//copy internal data to external data
void Sc::ArticulationSim::copyInternalStateToCache(PxArticulationCache& cache, const PxArticulationCacheFlags flag, const bool isGpuSimEnabled) const
{
mLLArticulation->copyInternalStateToCache(cache, flag, isGpuSimEnabled);
}
void Sc::ArticulationSim::packJointData(const PxReal* maximum, PxReal* reduced) const
{
mLLArticulation->packJointData(maximum, reduced);
}
void Sc::ArticulationSim::unpackJointData(const PxReal* reduced, PxReal* maximum) const
{
mLLArticulation->unpackJointData(reduced, maximum);
}
void Sc::ArticulationSim::commonInit()
{
mLLArticulation->initializeCommonData();
}
void Sc::ArticulationSim::computeGeneralizedGravityForce(PxArticulationCache& cache)
{
mLLArticulation->getGeneralizedGravityForce(mScene.getGravity(), cache);
}
void Sc::ArticulationSim::computeCoriolisAndCentrifugalForce(PxArticulationCache& cache)
{
mLLArticulation->getCoriolisAndCentrifugalForce(cache);
}
void Sc::ArticulationSim::computeGeneralizedExternalForce(PxArticulationCache& cache)
{
mLLArticulation->getGeneralizedExternalForce(cache);
}
void Sc::ArticulationSim::computeJointAcceleration(PxArticulationCache& cache)
{
mLLArticulation->getJointAcceleration(mScene.getGravity(), cache);
}
void Sc::ArticulationSim::computeJointForce(PxArticulationCache& cache)
{
mLLArticulation->getJointForce(cache);
}
void Sc::ArticulationSim::computeDenseJacobian(PxArticulationCache& cache, PxU32& nRows, PxU32& nCols)
{
mLLArticulation->getDenseJacobian(cache, nRows, nCols);
}
void Sc::ArticulationSim::computeCoefficientMatrix(PxArticulationCache& cache)
{
mLLArticulation->getCoefficientMatrixWithLoopJoints(mLoopConstraints.begin(), mLoopConstraints.size(), cache);
}
bool Sc::ArticulationSim::computeLambda(PxArticulationCache& cache, PxArticulationCache& initialState,
const PxReal* const jointTorque, const PxVec3 gravity, const PxU32 maxIter)
{
const PxReal invLengthScale = 1.f / mScene.getLengthScale();
return mLLArticulation->getLambda(mLoopConstraints.begin(), mLoopConstraints.size(), cache, initialState, jointTorque, gravity, maxIter, invLengthScale);
}
void Sc::ArticulationSim::computeGeneralizedMassMatrix(PxArticulationCache& cache)
{
mLLArticulation->getGeneralizedMassMatrixCRB(cache);
/*const PxU32 totalDofs = mLLArticulation->getDofs();
PxReal* massMatrix = reinterpret_cast<PxReal*>(PX_ALLOC(sizeof(PxReal) * totalDofs * totalDofs, "MassMatrix"));
PxMemCopy(massMatrix, cache.massMatrix, sizeof(PxReal)*totalDofs * totalDofs);
mLLArticulation->getGeneralizedMassMatrix(cache);
PxReal* massMatrix1 = cache.massMatrix;
for (PxU32 i = 0; i < totalDofs; ++i)
{
PxReal* row = &massMatrix1[i * totalDofs];
for (PxU32 j = 0; j < totalDofs; ++j)
{
const PxReal dif = row[j] - massMatrix[j*totalDofs + i];
PX_ASSERT (PxAbs(dif) < 2e-4f)
}
}
PX_FREE(massMatrix);*/
}
PxU32 Sc::ArticulationSim::getCoefficientMatrixSize() const
{
const PxU32 size = mLoopConstraints.size();
const PxU32 totalDofs = mLLArticulation->getDofs();
return size * totalDofs;
}
void Sc::ArticulationSim::setRootLinearVelocity(const PxVec3& velocity)
{
mLLArticulation->setRootLinearVelocity(velocity);
}
void Sc::ArticulationSim::setRootAngularVelocity(const PxVec3& velocity)
{
mLLArticulation->setRootAngularVelocity(velocity);
}
PxSpatialVelocity Sc::ArticulationSim::getLinkVelocity(const PxU32 linkId) const
{
Cm::SpatialVector vel = mLLArticulation->getLinkScalarVelocity(linkId);
return reinterpret_cast<PxSpatialVelocity&>(vel);
}
PxSpatialVelocity Sc::ArticulationSim::getLinkAcceleration(const PxU32 linkId, const bool isGpuSimEnabled) const
{
Cm::SpatialVector accel = mLLArticulation->getMotionAcceleration(linkId, isGpuSimEnabled);
return reinterpret_cast<PxSpatialVelocity&>(accel);
}
// This method allows user teleport the root links and the articulation
//system update all other links pose
void Sc::ArticulationSim::setGlobalPose()
{
mLLArticulation->teleportRootLink();
}
void Sc::ArticulationSim::setJointDirty(Dy::ArticulationJointCore& jointCore)
{
PX_UNUSED(jointCore);
mScene.getSimulationController()->updateArticulationJoint(mLLArticulation, mIslandNodeIndex);
}
void Sc::ArticulationSim::setArticulationDirty(PxU32 flag)
{
Dy::FeatherstoneArticulation* featherstoneArtic = static_cast<Dy::FeatherstoneArticulation*>(mLLArticulation);
featherstoneArtic->raiseGPUDirtyFlag(Dy::ArticulationDirtyFlag::Enum(flag));
mScene.getSimulationController()->updateArticulation(mLLArticulation, mIslandNodeIndex);
}
void Sc::ArticulationSim::debugCheckWakeCounterOfLinks(PxReal wakeCounter) const
{
PX_UNUSED(wakeCounter);
#ifdef _DEBUG
// make sure the links are in sync with the articulation
for(PxU32 i=0; i < mBodies.size(); i++)
{
PX_ASSERT(mBodies[i]->getBodyCore().getWakeCounter() == wakeCounter);
}
#endif
}
void Sc::ArticulationSim::debugCheckSleepStateOfLinks(bool isSleeping) const
{
PX_UNUSED(isSleeping);
#ifdef _DEBUG
// make sure the links are in sync with the articulation
for(PxU32 i=0; i < mBodies.size(); i++)
{
if (isSleeping)
{
PX_ASSERT(!mBodies[i]->isActive());
PX_ASSERT(mBodies[i]->getBodyCore().getWakeCounter() == 0.0f);
PX_ASSERT(mBodies[i]->checkSleepReadinessBesidesWakeCounter());
}
else
PX_ASSERT(mBodies[i]->isActive());
}
#endif
}
PxU32 Sc::ArticulationSim::getRootActorIndex() const
{
return mBodies[0]->getActorID();
}
const PxSpatialForce& Sc::ArticulationSim::getSensorForce(const PxU32 lowLevelIndex) const
{
return mSensorForces[lowLevelIndex];
}
| 24,950 | C++ | 29.465201 | 157 | 0.74994 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScActorPair.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-2023 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 SC_ACTOR_PAIR_H
#define SC_ACTOR_PAIR_H
#include "ScRigidSim.h"
#include "ScContactStream.h"
#include "ScNPhaseCore.h"
#if PX_SUPPORT_GPU_PHYSX
#include "ScSoftBodySim.h"
#endif
namespace physx
{
namespace Sc
{
class ActorPairContactReportData
{
public:
ActorPairContactReportData() :
mStrmResetStamp (0xffffffff),
mActorAID (0xffffffff),
mActorBID (0xffffffff),
mPxActorA (NULL),
mPxActorB (NULL)
{}
ContactStreamManager mContactStreamManager;
PxU32 mStrmResetStamp;
PxU32 mActorAID;
PxU32 mActorBID;
PxActor* mPxActorA;
PxActor* mPxActorB;
};
/**
\brief Class shared by all shape interactions for a pair of actors.
This base class is used if no shape pair of an actor pair has contact reports requested.
*/
class ActorPair
{
public:
enum ActorPairFlags
{
eIS_REPORT_PAIR = (1<<0),
eNEXT_FREE = (1<<1)
};
PX_FORCE_INLINE ActorPair() : mInternalFlags(0), mTouchCount(0), mRefCount(0) {}
PX_FORCE_INLINE ~ActorPair() {}
PX_FORCE_INLINE PxIntBool isReportPair() const { return (mInternalFlags & eIS_REPORT_PAIR); }
PX_FORCE_INLINE void incTouchCount() { mTouchCount++; PX_ASSERT(mTouchCount); }
PX_FORCE_INLINE void decTouchCount() { PX_ASSERT(mTouchCount); mTouchCount--; }
PX_FORCE_INLINE PxU32 getTouchCount() const { return mTouchCount; }
PX_FORCE_INLINE void incRefCount() { ++mRefCount; PX_ASSERT(mRefCount>0); }
PX_FORCE_INLINE PxU32 decRefCount() { PX_ASSERT(mRefCount>0); return --mRefCount; }
PX_FORCE_INLINE PxU32 getRefCount() const { return mRefCount; }
private:
ActorPair& operator=(const ActorPair&);
protected:
PxU16 mInternalFlags;
PxU16 mTouchCount;
PxU16 mRefCount;
PxU16 mPad; // instances of this class are stored in a pool which needs an item size of at least size_t
};
/**
\brief Class shared by all shape interactions for a pair of actors if contact reports are requested.
This class is used if at least one shape pair of an actor pair has contact reports requested.
\note If a pair of actors had contact reports requested for some of the shape interactions but all of them switch to not wanting contact reports
any longer, then the ActorPairReport instance is kept being used and won't get replaced by a simpler ActorPair instance.
*/
class ActorPairReport : public ActorPair
{
public:
enum ActorPairReportFlags
{
eIS_IN_CONTACT_REPORT_ACTOR_PAIR_SET = ActorPair::eNEXT_FREE // PT: whether the pair is already stored in the 'ContactReportActorPairSet' or not
};
PX_FORCE_INLINE ActorPairReport(ActorSim&, ActorSim&);
PX_FORCE_INLINE ~ActorPairReport();
PX_INLINE ContactStreamManager& createContactStreamManager(NPhaseCore&);
PX_FORCE_INLINE ContactStreamManager& getContactStreamManager() const { PX_ASSERT(mReportData); return mReportData->mContactStreamManager; }
PX_FORCE_INLINE ActorSim& getActorA() const { return mActorA; }
PX_FORCE_INLINE ActorSim& getActorB() const { return mActorB; }
PX_INLINE PxU32 getActorAID() const { PX_ASSERT(mReportData); return mReportData->mActorAID; }
PX_INLINE PxU32 getActorBID() const { PX_ASSERT(mReportData); return mReportData->mActorBID; }
PX_INLINE PxActor* getPxActorA() const { PX_ASSERT(mReportData); return mReportData->mPxActorA; }
PX_INLINE PxActor* getPxActorB() const { PX_ASSERT(mReportData); return mReportData->mPxActorB; }
PX_INLINE bool streamResetStamp(PxU32 cmpStamp);
PX_FORCE_INLINE PxU16 isInContactReportActorPairSet() const { return PxU16(mInternalFlags & eIS_IN_CONTACT_REPORT_ACTOR_PAIR_SET); }
PX_FORCE_INLINE void setInContactReportActorPairSet() { mInternalFlags |= eIS_IN_CONTACT_REPORT_ACTOR_PAIR_SET; }
PX_FORCE_INLINE void clearInContactReportActorPairSet() { mInternalFlags &= ~eIS_IN_CONTACT_REPORT_ACTOR_PAIR_SET; }
PX_FORCE_INLINE void createContactReportData(NPhaseCore&);
PX_FORCE_INLINE void releaseContactReportData(NPhaseCore&);
PX_FORCE_INLINE void convert(ActorPair& aPair) { PX_ASSERT(!aPair.isReportPair()); mTouchCount = PxU16(aPair.getTouchCount()); mRefCount = PxU16(aPair.getRefCount()); }
PX_FORCE_INLINE static ActorPairReport& cast(ActorPair& aPair) { PX_ASSERT(aPair.isReportPair()); return static_cast<ActorPairReport&>(aPair); }
private:
ActorPairReport& operator=(const ActorPairReport&);
ActorSim& mActorA;
ActorSim& mActorB;
ActorPairContactReportData* mReportData;
};
} // namespace Sc
PX_FORCE_INLINE Sc::ActorPairReport::ActorPairReport(ActorSim& actor0, ActorSim& actor1) : ActorPair(),
mActorA (actor0),
mActorB (actor1),
mReportData (NULL)
{
PX_ASSERT(mInternalFlags == 0);
mInternalFlags = ActorPair::eIS_REPORT_PAIR;
}
PX_FORCE_INLINE Sc::ActorPairReport::~ActorPairReport()
{
PX_ASSERT(mReportData == NULL);
}
PX_INLINE bool Sc::ActorPairReport::streamResetStamp(PxU32 cmpStamp)
{
PX_ASSERT(mReportData);
const bool ret = (cmpStamp != mReportData->mStrmResetStamp);
mReportData->mStrmResetStamp = cmpStamp;
return ret;
}
PX_INLINE Sc::ContactStreamManager& Sc::ActorPairReport::createContactStreamManager(NPhaseCore& npCore)
{
// Lazy create report data
if(!mReportData)
createContactReportData(npCore);
return mReportData->mContactStreamManager;
}
PX_FORCE_INLINE void Sc::ActorPairReport::createContactReportData(NPhaseCore& npCore)
{
PX_ASSERT(!mReportData);
Sc::ActorPairContactReportData* reportData = npCore.createActorPairContactReportData();
mReportData = reportData;
if(reportData)
{
const ActorCore& actorCoreA = mActorA.getActorCore();
const ActorCore& actorCoreB = mActorB.getActorCore();
reportData->mActorAID = mActorA.getActorID();
reportData->mActorBID = mActorB.getActorID();
#if PX_SUPPORT_GPU_PHYSX
if (mActorA.getActorType() == PxActorType::eSOFTBODY)
reportData->mPxActorA = static_cast<const SoftBodyCore&>(actorCoreA).getPxActor();
else
#endif
reportData->mPxActorA = static_cast<const RigidCore&>(actorCoreA).getPxActor();
#if PX_SUPPORT_GPU_PHYSX
if (mActorA.getActorType() == PxActorType::eSOFTBODY)
reportData->mPxActorB = static_cast<const SoftBodyCore&>(actorCoreB).getPxActor();
else
#endif
reportData->mPxActorB = static_cast<const RigidCore&>(actorCoreB).getPxActor();
}
}
PX_FORCE_INLINE void Sc::ActorPairReport::releaseContactReportData(NPhaseCore& npCore)
{
// Can't take the NPhaseCore (scene) reference from the actors since they're already gone on scene release
if(mReportData)
{
npCore.releaseActorPairContactReportData(mReportData);
mReportData = NULL;
}
}
}
#endif
| 8,326 | C | 35.52193 | 172 | 0.744896 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScBodySim.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScBodySim.h"
#include "ScShapeSim.h"
#include "ScScene.h"
#include "ScArticulationSim.h"
#include "PxsContext.h"
#include "PxsSimpleIslandManager.h"
#include "PxsSimulationController.h"
#include "ScSimStateData.h"
using namespace physx;
using namespace physx::Dy;
using namespace Sc;
#define PX_FREEZE_INTERVAL 1.5f
#define PX_FREE_EXIT_THRESHOLD 4.f
#define PX_FREEZE_TOLERANCE 0.25f
#define PX_SLEEP_DAMPING 0.5f
#define PX_FREEZE_SCALE 0.9f
static void updateBPGroup(ActorSim* sim)
{
PxU32 nbElems = sim->getNbElements();
ElementSim** elems = sim->getElements();
while (nbElems--)
{
ShapeSim* current = static_cast<ShapeSim*>(*elems++);
current->updateBPGroup();
}
}
BodySim::BodySim(Scene& scene, BodyCore& core, bool compound) :
RigidSim (scene, core),
mLLBody (&core.getCore(), PX_FREEZE_INTERVAL),
mSimStateData (NULL),
mVelModState (VMF_GRAVITY_DIRTY),
mArticulation (NULL)
{
core.getCore().numCountedInteractions = 0;
core.getCore().disableGravity = core.getActorFlags() & PxActorFlag::eDISABLE_GRAVITY;
if(core.getFlags() & PxRigidBodyFlag::eENABLE_SPECULATIVE_CCD)
mLLBody.mInternalFlags |= PxsRigidBody::eSPECULATIVE_CCD;
if(core.getFlags() & PxRigidBodyFlag::eENABLE_GYROSCOPIC_FORCES)
mLLBody.mInternalFlags |= PxsRigidBody::eENABLE_GYROSCOPIC;
if(core.getFlags() & PxRigidBodyFlag::eRETAIN_ACCELERATIONS)
mLLBody.mInternalFlags |= PxsRigidBody::eRETAIN_ACCELERATION;
// PT: don't read the core ptr we just wrote, use input param
// PT: at time of writing we get a big L2 here because even though bodycore has been prefetched, the wake counter is 160 bytes away
const bool isAwake = (core.getWakeCounter() > 0) ||
(!core.getLinearVelocity().isZero()) ||
(!core.getAngularVelocity().isZero());
const bool isKine = isKinematic();
IG::SimpleIslandManager* simpleIslandManager = scene.getSimpleIslandManager();
if(!isArticulationLink())
{
mNodeIndex = simpleIslandManager->addRigidBody(&mLLBody, isKine, isAwake);
}
else
{
if(mArticulation)
{
const PxU32 linkIndex = mArticulation->findBodyIndex(*this);
const PxNodeIndex index = mArticulation->getIslandNodeIndex();
mNodeIndex.setIndices(index.index(), linkIndex);
}
}
PX_ASSERT(mActiveListIndex == SC_NOT_IN_SCENE_INDEX);
// A.B. need to set the compound rigid flag early enough, so that we add the rigid into
// active list and do not create the shape bounds
if(compound)
raiseInternalFlag(BF_IS_COMPOUND_RIGID);
setActive(isAwake, true);
if(isAwake)
{
scene.addToActiveList(*this);
PX_ASSERT(isActive());
}
else
{
mActiveListIndex = SC_NOT_IN_ACTIVE_LIST_INDEX;
mActiveCompoundListIndex = SC_NOT_IN_ACTIVE_LIST_INDEX;
PX_ASSERT(!isActive());
simpleIslandManager->deactivateNode(mNodeIndex);
}
if(isKine)
{
initKinematicStateBase(core, true);
setupSimStateData(true);
notifyPutToSleep(); // sleep state of kinematics is fully controlled by the simulation controller not the island manager
mFilterFlags |= PxFilterObjectFlag::eKINEMATIC;
}
}
BodySim::~BodySim()
{
Scene& scene = mScene;
const bool active = isActive();
tearDownSimStateData(isKinematic());
PX_ASSERT(!mSimStateData);
// PX-4603. AD: assuming that the articulation code cleans up the dirty state in case this is an articulation link.
if (!isArticulationLink())
scene.getVelocityModifyMap().boundedReset(mNodeIndex.index());
PX_ASSERT(!readInternalFlag(BF_ON_DEATHROW)); // Before 3.0 it could happen that destroy could get called twice. Assert to make sure this is fixed.
raiseInternalFlag(BF_ON_DEATHROW);
scene.removeBody(*this);
//Articulations are represented by a single node, so they must only be removed by the articulation and not the links!
if(mArticulation == NULL && mNodeIndex.articulationLinkId() == 0) //If it wasn't an articulation link, then we can remove it
scene.getSimpleIslandManager()->removeNode(mNodeIndex);
PX_ASSERT(mActiveListIndex != SC_NOT_IN_SCENE_INDEX);
if (active)
scene.removeFromActiveList(*this);
mActiveListIndex = SC_NOT_IN_SCENE_INDEX;
mActiveCompoundListIndex = SC_NOT_IN_SCENE_INDEX;
mCore.setSim(NULL);
}
void BodySim::updateCached(PxBitMapPinned* shapeChangedMap)
{
if(!(mLLBody.mInternalFlags & PxsRigidBody::eFROZEN))
{
PxU32 nbElems = getNbElements();
ElementSim** elems = getElements();
while (nbElems--)
{
ShapeSim* current = static_cast<ShapeSim*>(*elems++);
current->updateCached(0, shapeChangedMap);
}
}
}
void BodySim::updateCached(PxsTransformCache& transformCache, Bp::BoundsArray& boundsArray)
{
PX_ASSERT(!(mLLBody.mInternalFlags & PxsRigidBody::eFROZEN)); // PT: should not be called otherwise
PxU32 nbElems = getNbElements();
ElementSim** elems = getElements();
while (nbElems--)
{
ShapeSim* current = static_cast<ShapeSim*>(*elems++);
current->updateCached(transformCache, boundsArray);
}
}
bool BodySim::setupSimStateData(bool isKinematic)
{
SimStateData* data = mSimStateData;
if(!data)
{
data = mScene.getSimStateDataPool()->construct();
if(!data)
return false;
}
if(isKinematic)
{
PX_ASSERT(!mSimStateData || !mSimStateData->isKine());
PX_PLACEMENT_NEW(data, SimStateData(SimStateData::eKine));
Kinematic* kine = data->getKinematicData();
kine->targetValid = 0;
simStateBackupAndClearBodyProperties(data, getBodyCore().getCore());
}
else
{
PX_ASSERT(!mSimStateData || !mSimStateData->isVelMod());
PX_PLACEMENT_NEW(data, SimStateData(SimStateData::eVelMod));
VelocityMod* velmod = data->getVelocityModData();
velmod->clear();
}
mSimStateData = data;
return true;
}
void BodySim::tearDownSimStateData(bool isKinematic)
{
PX_ASSERT(!mSimStateData || mSimStateData->isKine() == isKinematic);
if (mSimStateData)
{
if (isKinematic)
simStateRestoreBodyProperties(mSimStateData, getBodyCore().getCore());
mScene.getSimStateDataPool()->destroy(mSimStateData);
mSimStateData = NULL;
}
}
void BodySim::switchToKinematic()
{
setupSimStateData(true);
{
initKinematicStateBase(getBodyCore(), false);
// - interactions need to get refiltered to make sure that kinematic-kinematic and kinematic-static pairs get suppressed
// - unlike postSwitchToDynamic(), constraint interactions are not marked dirty here because a transition to kinematic will put the object asleep which in turn
// triggers onDeactivate() on the constraint pairs that are active. If such pairs get deactivated, they will get removed from the list of active breakable
// constraints automatically.
setActorsInteractionsDirty(InteractionDirtyFlag::eBODY_KINEMATIC, NULL, InteractionFlag::eFILTERABLE);
mScene.getSimpleIslandManager()->setKinematic(mNodeIndex);
updateBPGroup(this);
}
mScene.setDynamicsDirty();
mFilterFlags |= PxFilterObjectFlag::eKINEMATIC;
}
void BodySim::switchToDynamic()
{
tearDownSimStateData(true);
{
mScene.getSimpleIslandManager()->setDynamic(mNodeIndex);
setForcesToDefaults(true);
// - interactions need to get refiltered to make sure that former kinematic-kinematic and kinematic-static pairs get enabled
// - switching from kinematic to dynamic does not change the sleep state of the body. The constraint interactions are marked dirty
// to check later whether they need to be activated plus potentially tracked for constraint break testing. This special treatment
// is necessary because constraints between two kinematic bodies are considered inactive, no matter whether one of the kinematics
// is active (has a target) or not.
setActorsInteractionsDirty(InteractionDirtyFlag::eBODY_KINEMATIC, NULL, InteractionFlag::eFILTERABLE | InteractionFlag::eCONSTRAINT);
clearInternalFlag(BF_KINEMATIC_MOVE_FLAGS);
if(isActive())
mScene.swapInActiveBodyList(*this);
//
updateBPGroup(this);
}
mScene.setDynamicsDirty();
mFilterFlags &= ~PxFilterObjectFlag::eKINEMATIC;
}
void BodySim::setKinematicTarget(const PxTransform& p)
{
PX_ASSERT(getSimStateData(true));
PX_ASSERT(getSimStateData(true)->isKine());
simStateSetKinematicTarget(getSimStateData_Unchecked(), p);
PX_ASSERT(getSimStateData(true)->getKinematicData()->targetValid);
raiseInternalFlag(BF_KINEMATIC_MOVED); // Important to set this here already because trigger interactions need to have this information when being activated.
clearInternalFlag(BF_KINEMATIC_SURFACE_VELOCITY);
}
void BodySim::addSpatialAcceleration(const PxVec3* linAcc, const PxVec3* angAcc)
{
notifyAddSpatialAcceleration();
if (!mSimStateData || !mSimStateData->isVelMod())
setupSimStateData(false);
VelocityMod* velmod = mSimStateData->getVelocityModData();
if (linAcc) velmod->accumulateLinearVelModPerSec(*linAcc);
if (angAcc) velmod->accumulateAngularVelModPerSec(*angAcc);
}
void BodySim::setSpatialAcceleration(const PxVec3* linAcc, const PxVec3* angAcc)
{
notifyAddSpatialAcceleration();
if (!mSimStateData || !mSimStateData->isVelMod())
setupSimStateData(false);
VelocityMod* velmod = mSimStateData->getVelocityModData();
if (linAcc) velmod->setLinearVelModPerSec(*linAcc);
if (angAcc) velmod->setAngularVelModPerSec(*angAcc);
}
void BodySim::clearSpatialAcceleration(bool force, bool torque)
{
PX_ASSERT(force || torque);
notifyClearSpatialAcceleration();
if (mSimStateData)
{
PX_ASSERT(mSimStateData->isVelMod());
VelocityMod* velmod = mSimStateData->getVelocityModData();
if (force)
velmod->clearLinearVelModPerSec();
if (torque)
velmod->clearAngularVelModPerSec();
}
}
void BodySim::addSpatialVelocity(const PxVec3* linVelDelta, const PxVec3* angVelDelta)
{
notifyAddSpatialVelocity();
if (!mSimStateData || !mSimStateData->isVelMod())
setupSimStateData(false);
VelocityMod* velmod = mSimStateData->getVelocityModData();
if (linVelDelta)
velmod->accumulateLinearVelModPerStep(*linVelDelta);
if (angVelDelta)
velmod->accumulateAngularVelModPerStep(*angVelDelta);
}
void BodySim::clearSpatialVelocity(bool force, bool torque)
{
PX_ASSERT(force || torque);
notifyClearSpatialVelocity();
if (mSimStateData)
{
PX_ASSERT(mSimStateData->isVelMod());
VelocityMod* velmod = mSimStateData->getVelocityModData();
if (force)
velmod->clearLinearVelModPerStep();
if (torque)
velmod->clearAngularVelModPerStep();
}
}
void BodySim::raiseVelocityModFlagAndNotify(VelocityModFlags flag)
{
//The dirty flag is stored separately in the BodySim so that we query the dirty flag before going to
//the expense of querying the simStateData for the velmod values.
raiseVelocityModFlag(flag);
if (!isArticulationLink())
mScene.getVelocityModifyMap().growAndSet(getNodeIndex().index());
else
mScene.addDirtyArticulationSim(getArticulation());
}
void BodySim::postActorFlagChange(PxU32 oldFlags, PxU32 newFlags)
{
// PT: don't convert to bool if not needed
const PxU32 wasWeightless = oldFlags & PxActorFlag::eDISABLE_GRAVITY;
const PxU32 isWeightless = newFlags & PxActorFlag::eDISABLE_GRAVITY;
if (isWeightless != wasWeightless)
{
if (mVelModState == 0)
raiseVelocityModFlag(VMF_GRAVITY_DIRTY);
getBodyCore().getCore().disableGravity = isWeightless!=0;
}
}
void BodySim::postBody2WorldChange()
{
mLLBody.saveLastCCDTransform();
notifyShapesOfTransformChange();
}
void BodySim::postSetWakeCounter(PxReal t, bool forceWakeUp)
{
if ((t > 0.0f) || forceWakeUp)
notifyNotReadyForSleeping();
else
{
const bool readyForSleep = checkSleepReadinessBesidesWakeCounter();
if (readyForSleep)
notifyReadyForSleeping();
}
}
void BodySim::postPosePreviewChange(PxU32 posePreviewFlag)
{
if (isActive())
{
if (posePreviewFlag & PxRigidBodyFlag::eENABLE_POSE_INTEGRATION_PREVIEW)
mScene.addToPosePreviewList(*this);
else
mScene.removeFromPosePreviewList(*this);
}
else
PX_ASSERT(!mScene.isInPosePreviewList(*this));
}
void BodySim::activate()
{
BodyCore& core = getBodyCore();
// Activate body
{
PX_ASSERT((!isKinematic()) || notInScene() || readInternalFlag(InternalFlags(BF_KINEMATIC_MOVED | BF_KINEMATIC_SURFACE_VELOCITY))); // kinematics should only get activated when a target is set.
// exception: object gets newly added, then the state change will happen later
if(!isArticulationLink())
{
mLLBody.mInternalFlags &= (~PxsRigidBody::eFROZEN);
// Put in list of activated bodies. The list gets cleared at the end of a sim step after the sleep callbacks have been fired.
mScene.onBodyWakeUp(this);
}
if(core.getFlags() & PxRigidBodyFlag::eENABLE_POSE_INTEGRATION_PREVIEW)
{
PX_ASSERT(!mScene.isInPosePreviewList(*this));
mScene.addToPosePreviewList(*this);
}
createSqBounds();
}
activateInteractions(*this);
//set speculative CCD bit map if speculative CCD flag is on
if(core.getFlags() & PxRigidBodyFlag::eENABLE_SPECULATIVE_CCD)
addToSpeculativeCCDMap();
}
void BodySim::deactivate()
{
deactivateInteractions(*this);
BodyCore& core = getBodyCore();
// Deactivate body
{
PX_ASSERT((!isKinematic()) || notInScene() || !readInternalFlag(BF_KINEMATIC_MOVED)); // kinematics should only get deactivated when no target is set.
// exception: object gets newly added, then the state change will happen later
if(!readInternalFlag(BF_ON_DEATHROW))
{
// Set velocity to 0.
// Note: this is also fine if the method gets called because the user puts something to sleep (this behavior is documented in the API)
PX_ASSERT(core.getWakeCounter() == 0.0f);
const PxVec3 zero(0.0f);
core.setLinearVelocityInternal(zero);
core.setAngularVelocityInternal(zero);
setForcesToDefaults(!core.getCore().disableGravity);
}
if(!isArticulationLink()) // Articulations have their own sleep logic.
mScene.onBodySleep(this);
if(core.getFlags() & PxRigidBodyFlag::eENABLE_POSE_INTEGRATION_PREVIEW)
{
PX_ASSERT(mScene.isInPosePreviewList(*this));
mScene.removeFromPosePreviewList(*this);
}
destroySqBounds();
}
// reset speculative CCD bit map if speculative CCD flag is on
if(core.getFlags() & PxRigidBodyFlag::eENABLE_SPECULATIVE_CCD)
removeFromSpeculativeCCDMap();
}
void BodySim::wakeUp()
{
setActive(true);
notifyWakeUp();
}
void BodySim::putToSleep()
{
PX_ASSERT(getBodyCore().getWakeCounter() == 0.0f);
PX_ASSERT(getBodyCore().getLinearVelocity().isZero());
PX_ASSERT(getBodyCore().getAngularVelocity().isZero());
notifyClearSpatialAcceleration();
notifyClearSpatialVelocity();
simStateClearVelMod(getSimStateData_Unchecked());
setActive(false);
notifyPutToSleep();
}
void BodySim::internalWakeUp(PxReal wakeCounterValue)
{
if(mArticulation)
mArticulation->internalWakeUp(wakeCounterValue);
else
internalWakeUpBase(wakeCounterValue);
}
void BodySim::internalWakeUpArticulationLink(PxReal wakeCounterValue)
{
PX_ASSERT(mArticulation);
internalWakeUpBase(wakeCounterValue);
}
void BodySim::internalWakeUpBase(PxReal wakeCounterValue) //this one can only increase the wake counter, not decrease it, so it can't be used to put things to sleep!
{
if ((!isKinematic()) && (getBodyCore().getWakeCounter() < wakeCounterValue))
{
PX_ASSERT(wakeCounterValue > 0.0f);
getBodyCore().setWakeCounterFromSim(wakeCounterValue);
//we need to update the gpu body sim because we reset the wake counter for the body core
mScene.updateBodySim(*this);
setActive(true);
notifyWakeUp();
if(0) // PT: commented-out for PX-2197
mLLBody.mInternalFlags &= (~PxsRigidBody::eFROZEN);
}
}
void BodySim::notifyReadyForSleeping()
{
if(mArticulation == NULL)
mScene.getSimpleIslandManager()->deactivateNode(mNodeIndex);
}
void BodySim::notifyNotReadyForSleeping()
{
mScene.getSimpleIslandManager()->activateNode(mNodeIndex);
}
void BodySim::notifyWakeUp()
{
mScene.getSimpleIslandManager()->activateNode(mNodeIndex);
}
void BodySim::notifyPutToSleep()
{
mScene.getSimpleIslandManager()->putNodeToSleep(mNodeIndex);
}
//This function will be called by CPU sleepCheck code
// PT: TODO: actually this seems to be only called by the articulation sim code, while regular rigid bodies use a copy of that code in LowLevelDynamics?
PxReal BodySim::updateWakeCounter(PxReal dt, PxReal energyThreshold, const Cm::SpatialVector& motionVelocity)
{
// update the body's sleep state and
BodyCore& core = getBodyCore();
const PxReal wakeCounterResetTime = ScInternalWakeCounterResetValue;
PxReal wc = core.getWakeCounter();
{
PxVec3 bcSleepLinVelAcc = mLLBody.sleepLinVelAcc;
PxVec3 bcSleepAngVelAcc = mLLBody.sleepAngVelAcc;
if(wc < wakeCounterResetTime * 0.5f || wc < dt)
{
const PxTransform& body2World = getBody2World();
// calculate normalized energy: kinetic energy divided by mass
const PxVec3 t = core.getInverseInertia();
const PxVec3 inertia(t.x > 0.0f ? 1.0f/t.x : 1.0f, t.y > 0.0f ? 1.0f/t.y : 1.0f, t.z > 0.0f ? 1.0f/t.z : 1.0f);
PxVec3 sleepLinVelAcc = motionVelocity.linear;
PxVec3 sleepAngVelAcc = body2World.q.rotateInv(motionVelocity.angular);
bcSleepLinVelAcc += sleepLinVelAcc;
bcSleepAngVelAcc += sleepAngVelAcc;
PxReal invMass = core.getInverseMass();
if(invMass == 0.0f)
invMass = 1.0f;
const PxReal angular = bcSleepAngVelAcc.multiply(bcSleepAngVelAcc).dot(inertia) * invMass;
const PxReal linear = bcSleepLinVelAcc.magnitudeSquared();
const PxReal normalizedEnergy = 0.5f * (angular + linear);
// scale threshold by cluster factor (more contacts => higher sleep threshold)
const PxReal clusterFactor = PxReal(1 + getNumCountedInteractions());
const PxReal threshold = clusterFactor*energyThreshold;
if (normalizedEnergy >= threshold)
{
PX_ASSERT(isActive());
mLLBody.resetSleepFilter();
const float factor = threshold == 0.0f ? 2.0f : PxMin(normalizedEnergy/threshold, 2.0f);
PxReal oldWc = wc;
wc = factor * 0.5f * wakeCounterResetTime + dt * (clusterFactor - 1.0f);
core.setWakeCounterFromSim(wc);
if (oldWc == 0.0f) // for the case where a sleeping body got activated by the system (not the user) AND got processed by the solver as well
notifyNotReadyForSleeping();
return wc;
}
}
mLLBody.sleepLinVelAcc = bcSleepLinVelAcc;
mLLBody.sleepAngVelAcc = bcSleepAngVelAcc;
}
wc = PxMax(wc-dt, 0.0f);
core.setWakeCounterFromSim(wc);
return wc;
}
PX_FORCE_INLINE void BodySim::initKinematicStateBase(BodyCore&, bool asPartOfCreation)
{
PX_ASSERT(!readInternalFlag(BF_KINEMATIC_MOVED));
if (!asPartOfCreation && isActive())
mScene.swapInActiveBodyList(*this);
//mLLBody.setAccelerationV(Cm::SpatialVector::zero());
// Need to be before setting setRigidBodyFlag::KINEMATIC
}
bool BodySim::updateForces(PxReal dt, PxsRigidBody** updatedBodySims, PxU32* updatedBodyNodeIndices, PxU32& index, Cm::SpatialVector* acceleration)
{
PxVec3 linVelDt(0.0f), angVelDt(0.0f);
const bool accDirty = readVelocityModFlag(VMF_ACC_DIRTY);
const bool velDirty = readVelocityModFlag(VMF_VEL_DIRTY);
SimStateData* simStateData = NULL;
bool forceChangeApplied = false;
//if we change the logic like this, which means we don't need to have two seperate variables in the pxgbodysim to represent linAcc and angAcc. However, this
//means angAcc will be always 0
if( (accDirty || velDirty) && ((simStateData = getSimStateData(false)) != NULL) )
{
VelocityMod* velmod = simStateData->getVelocityModData();
//we don't have support for articulation yet
if (updatedBodySims)
{
updatedBodySims[index] = &getLowLevelBody();
updatedBodyNodeIndices[index++] = getNodeIndex().index();
}
if(velDirty)
{
linVelDt = velmod->getLinearVelModPerStep();
angVelDt = velmod->getAngularVelModPerStep();
}
if (accDirty)
{
linVelDt += velmod->getLinearVelModPerSec()*dt;
angVelDt += velmod->getAngularVelModPerSec()*dt;
}
if (acceleration)
{
const PxReal invDt = 1.f / dt;
acceleration->linear = linVelDt * invDt;
acceleration->angular = angVelDt * invDt;
}
else
{
getBodyCore().updateVelocities(linVelDt, angVelDt);
}
forceChangeApplied = true;
}
setForcesToDefaults(readVelocityModFlag(VMF_ACC_DIRTY));
return forceChangeApplied;
}
void BodySim::onConstraintDetach()
{
PX_ASSERT(readInternalFlag(BF_HAS_CONSTRAINTS));
PxU32 size = getActorInteractionCount();
Interaction** interactions = getActorInteractions();
unregisterCountedInteraction();
while(size--)
{
const Interaction* interaction = *interactions++;
if(interaction->getType() == InteractionType::eCONSTRAINTSHADER)
return;
}
clearInternalFlag(BF_HAS_CONSTRAINTS); // There are no other constraint interactions left
}
void BodySim::setArticulation(ArticulationSim* a, PxReal wakeCounter, bool asleep, PxU32 bodyIndex)
{
mArticulation = a;
if(a)
{
PxNodeIndex index = mArticulation->getIslandNodeIndex();
mNodeIndex.setIndices(index.index(), bodyIndex);
getBodyCore().setWakeCounterFromSim(wakeCounter);
if (getFlagsFast() & PxRigidBodyFlag::eENABLE_SPECULATIVE_CCD)
mScene.setSpeculativeCCDArticulationLink(mNodeIndex.index());
//Articulations defer registering their shapes with the nphaseContext until the IG node index is known.
{
ElementSim** current = getElements();
PxU32 nbElements = getNbElements();
while (nbElements--)
{
ShapeSim* sim = static_cast<ShapeSim*>(*current++);
mScene.getLowLevelContext()->getNphaseImplementationContext()->registerShape(mNodeIndex, sim->getCore().getCore(), sim->getElementID(), sim->getActor().getPxActor());
}
}
//Force node index into LL shapes
setBodyNodeIndex(mNodeIndex);
if (a->getCore().getArticulationFlags() & PxArticulationFlag::eDISABLE_SELF_COLLISION)
{
//We need to reset the group IDs for all shapes in this body...
ElementSim** current = getElements();
PxU32 nbElements = getNbElements();
Bp::AABBManagerBase* aabbMgr = mScene.getAABBManager();
Bp::FilterGroup::Enum rootGroup = Bp::getFilterGroup(false, a->getRootActorIndex(), false);
while (nbElements--)
{
ShapeSim* sim = static_cast<ShapeSim*>(*current++);
aabbMgr->setBPGroup(sim->getElementID(), rootGroup);
}
}
if (!asleep)
{
setActive(true);
notifyWakeUp();
}
else
{
notifyReadyForSleeping();
notifyPutToSleep();
setActive(false);
}
}
else
{
//Setting a 1 in the articulation ID to avoid returning the node Index to the node index
//manager
mNodeIndex.setIndices(PX_INVALID_NODE, 1);
}
}
void BodySim::createSqBounds()
{
if(!isActive() || usingSqKinematicTarget() || readInternalFlag(BF_IS_COMPOUND_RIGID))
return;
PX_ASSERT(!isFrozen());
PxU32 nbElems = getNbElements();
ElementSim** elems = getElements();
while (nbElems--)
{
ShapeSim* current = static_cast<ShapeSim*>(*elems++);
current->createSqBounds();
}
}
void BodySim::destroySqBounds()
{
PxU32 nbElems = getNbElements();
ElementSim** elems = getElements();
while (nbElems--)
{
ShapeSim* current = static_cast<ShapeSim*>(*elems++);
current->destroySqBounds();
}
}
void BodySim::freezeTransforms(PxBitMapPinned* shapeChangedMap)
{
PxU32 nbElems = getNbElements();
ElementSim** elems = getElements();
while (nbElems--)
{
ShapeSim* sim = static_cast<ShapeSim*>(*elems++);
sim->updateCached(PxsTransformFlag::eFROZEN, shapeChangedMap);
sim->destroySqBounds();
}
}
void BodySim::disableCompound()
{
if(isActive())
mScene.removeFromActiveCompoundBodyList(*this);
clearInternalFlag(BF_IS_COMPOUND_RIGID);
}
| 25,049 | C++ | 29.144404 | 195 | 0.742545 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScFEMClothSim.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
#include "foundation/PxPreprocessor.h"
#if PX_SUPPORT_GPU_PHYSX
#include "ScFEMClothSim.h"
#include "ScFEMClothCore.h"
#include "ScScene.h"
#include "ScInteraction.h" // to be deleted
#include "PxsSimulationController.h"
using namespace physx;
using namespace physx::Dy;
Sc::FEMClothSim::FEMClothSim(FEMClothCore& core, Scene& scene) :
ActorSim(scene, core),
mShapeSim(*this)
{
mLLFEMCloth = scene.createLLFEMCloth(this);
mNodeIndex = scene.getSimpleIslandManager()->addFEMCloth(mLLFEMCloth, false);
scene.getSimpleIslandManager()->activateNode(mNodeIndex);
mLLFEMCloth->setElementId(mShapeSim.getElementID());
}
Sc::FEMClothSim::~FEMClothSim()
{
if (!mLLFEMCloth)
return;
mScene.destroyLLFEMCloth(*mLLFEMCloth);
mScene.getSimpleIslandManager()->removeNode(mNodeIndex);
mCore.setSim(NULL);
}
void Sc::FEMClothSim::updateBounds()
{
mShapeSim.updateBounds();
}
void Sc::FEMClothSim::updateBoundsInAABBMgr()
{
mShapeSim.updateBoundsInAABBMgr();
}
PxBounds3 Sc::FEMClothSim::getBounds() const
{
return mShapeSim.getBounds();
}
bool Sc::FEMClothSim::isSleeping() const
{
IG::IslandSim& sim = mScene.getSimpleIslandManager()->getAccurateIslandSim();
return sim.getActiveNodeIndex(mNodeIndex) == PX_INVALID_NODE;
}
void Sc::FEMClothSim::onSetWakeCounter()
{
getScene().getSimulationController()->setClothWakeCounter(mLLFEMCloth);
if (mLLFEMCloth->getCore().wakeCounter > 0.f)
getScene().getSimpleIslandManager()->activateNode(mNodeIndex);
else
getScene().getSimpleIslandManager()->deactivateNode(mNodeIndex);
}
void Sc::FEMClothSim::attachShapeCore(ShapeCore* core)
{
mShapeSim.attachShapeCore(core);
PxsShapeCore* shapeCore = const_cast<PxsShapeCore*>(&core->getCore());
mLLFEMCloth->setShapeCore(shapeCore);
}
#endif //PX_SUPPORT_GPU_PHYSX
| 3,347 | C++ | 30.584905 | 78 | 0.766657 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScRigidCore.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScRigidCore.h"
#include "ScStaticCore.h"
#include "ScRigidSim.h"
#include "ScShapeSim.h"
#include "ScScene.h"
using namespace physx;
using namespace Sc;
static ShapeSim& getSimForShape(const ShapeCore& core, const ActorSim& actorSim)
{
if(core.getExclusiveSim())
{
return *core.getExclusiveSim();
}
//Must be a shared shape.
//Search backwards to emulate the behaviour of the previous linked list.
PxU32 nbElems = actorSim.getNbElements();
ElementSim*const* elems = actorSim.getElements() + (nbElems - 1);
while (nbElems--)
{
ShapeSim* sim = static_cast<ShapeSim*>(*elems--);
if (&sim->getCore() == &core)
return *sim;
}
PX_ASSERT(0); // should never fail
return *reinterpret_cast<ShapeSim*>(1);
}
RigidCore::RigidCore(const PxActorType::Enum type) : ActorCore(type, PxActorFlag::eVISUALIZATION, PX_DEFAULT_CLIENT, 0)
{
}
RigidCore::~RigidCore()
{
}
void RigidCore::addShapeToScene(ShapeCore& shapeCore)
{
RigidSim* sim = getSim();
PX_ASSERT(sim);
if(!sim)
return;
sim->getScene().addShape_(*sim, shapeCore);
}
void RigidCore::removeShapeFromScene(ShapeCore& shapeCore, bool wakeOnLostTouch)
{
RigidSim* sim = getSim();
if(!sim)
return;
ShapeSim& s = getSimForShape(shapeCore, *sim);
sim->getScene().removeShape_(s, wakeOnLostTouch);
}
void RigidCore::unregisterShapeFromNphase(Sc::ShapeCore& shapeCore)
{
RigidSim* sim = getSim();
if (!sim)
return;
ShapeSim& s = getSimForShape(shapeCore, *sim);
s.getScene().unregisterShapeFromNphase(shapeCore, s.getElementID());
}
void RigidCore::registerShapeInNphase(Sc::ShapeCore& shapeCore)
{
RigidSim* sim = getSim();
if (!sim)
return;
ShapeSim& s = getSimForShape(shapeCore, *sim);
s.getScene().registerShapeInNphase(this, shapeCore, s.getElementID());
}
void RigidCore::onShapeChange(ShapeCore& shape, ShapeChangeNotifyFlags notifyFlags)
{
RigidSim* sim = getSim();
if(!sim)
return;
ShapeSim& s = getSimForShape(shape, *sim);
if(notifyFlags & ShapeChangeNotifyFlag::eGEOMETRY)
s.onVolumeOrTransformChange();
if(notifyFlags & ShapeChangeNotifyFlag::eMATERIAL)
s.onMaterialChange();
if(notifyFlags & ShapeChangeNotifyFlag::eRESET_FILTERING)
s.onResetFiltering();
if(notifyFlags & ShapeChangeNotifyFlag::eSHAPE2BODY)
s.onVolumeOrTransformChange();
if(notifyFlags & ShapeChangeNotifyFlag::eFILTERDATA)
s.onFilterDataChange();
if(notifyFlags & ShapeChangeNotifyFlag::eCONTACTOFFSET)
s.onContactOffsetChange();
if(notifyFlags & ShapeChangeNotifyFlag::eRESTOFFSET)
s.onRestOffsetChange();
}
void RigidCore::onShapeFlagsChange(ShapeCore& shape, PxShapeFlags oldShapeFlags)
{
// DS: We pass flags to avoid searching multiple times or exposing RigidSim outside SC.
//If we start hitting this a lot we should do it
// a different way, but shape modification after insertion is rare.
RigidSim* sim = getSim();
if(!sim)
return;
ShapeSim& s = getSimForShape(shape, *sim);
s.onFlagChange(oldShapeFlags);
}
RigidSim* RigidCore::getSim() const
{
return static_cast<RigidSim*>(ActorCore::getSim());
}
PxU32 RigidCore::getRigidID() const
{
return static_cast<RigidSim*>(ActorCore::getSim())->getActorID();
}
| 4,841 | C++ | 31.28 | 119 | 0.749019 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScHairSystemSim.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-2023 NVIDIA Corporation. All rights reserved.
#ifndef SC_HAIR_SYSTEM_SIM_H
#define SC_HAIR_SYSTEM_SIM_H
#include "foundation/PxPreprocessor.h"
#if PX_SUPPORT_GPU_PHYSX
#include "DyHairSystem.h"
#include "ScHairSystemCore.h"
#include "ScHairSystemShapeSim.h"
#include "ScActorSim.h"
namespace physx
{
namespace Sc
{
class Scene;
class HairSystemSim : public ActorSim
{
PX_NOCOPY(HairSystemSim)
public:
HairSystemSim(HairSystemCore& core, Scene& scene);
~HairSystemSim();
PX_INLINE Dy::HairSystem* getLowLevelHairSystem() const { return mLLHairSystem; }
PX_INLINE HairSystemCore& getCore() const { return static_cast<HairSystemCore&>(mCore); }
virtual PxActor* getPxActor() const { return getCore().getPxActor(); }
PxBounds3 getBounds() const;
void updateBounds();
void updateBoundsInAABBMgr();
bool isSleeping() const;
bool isActive() const { return !isSleeping(); }
void setActive(bool active, bool asPartOfCreation=false);
void onSetWakeCounter();
HairSystemShapeSim& getShapeSim() { return mShapeSim; }
private:
Dy::HairSystem* mLLHairSystem;
HairSystemShapeSim mShapeSim;
// PT: as far as I can tell these are never actually called
// void activate();
// void deactivate();
};
} // namespace Sc
} // namespace physx
#endif
#endif
| 2,838 | C | 33.621951 | 92 | 0.744538 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScHairSystemCore.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
#include "foundation/PxPreprocessor.h"
#if PX_SUPPORT_GPU_PHYSX
#include "ScHairSystemCore.h"
#include "ScHairSystemSim.h"
#include "ScPhysics.h"
namespace physx
{
namespace Sc
{
HairSystemCore::HairSystemCore()
: ActorCore(PxActorType::eHAIRSYSTEM, PxActorFlag::eVISUALIZATION, PX_DEFAULT_CLIENT, 0)
{
}
HairSystemCore::~HairSystemCore() {}
void HairSystemCore::setMaterial(const PxU16 handle) { mShapeCore.getLLCore().setMaterial(handle); }
void HairSystemCore::clearMaterials() { mShapeCore.getLLCore().clearMaterials(); }
void HairSystemCore::setSleepThreshold(const PxReal v)
{
mShapeCore.getLLCore().mSleepThreshold = v;
mShapeCore.getLLCore().mDirtyFlags |= Dy::HairSystemDirtyFlag::ePARAMETERS;
}
void HairSystemCore::setSolverIterationCounts(const PxU16 c)
{
mShapeCore.getLLCore().mSolverIterationCounts = c;
mShapeCore.getLLCore().mDirtyFlags |= Dy::HairSystemDirtyFlag::ePARAMETERS;
}
void HairSystemCore::setWakeCounter(const PxReal v)
{
mShapeCore.getLLCore().mWakeCounter = v;
mShapeCore.getLLCore().mDirtyFlags |= Dy::HairSystemDirtyFlag::ePARAMETERS;
HairSystemSim* sim = getSim();
if(sim)
{
sim->onSetWakeCounter();
}
}
bool HairSystemCore::isSleeping() const
{
HairSystemSim* sim = getSim();
return sim ? sim->isSleeping() : (mShapeCore.getLLCore().mWakeCounter == 0.0f);
}
void HairSystemCore::wakeUp(PxReal wakeCounter)
{
mShapeCore.getLLCore().mWakeCounter = wakeCounter;
mShapeCore.getLLCore().mDirtyFlags |= Dy::HairSystemDirtyFlag::ePARAMETERS;
}
void HairSystemCore::putToSleep()
{
mShapeCore.getLLCore().mWakeCounter = 0.0f;
mShapeCore.getLLCore().mDirtyFlags |= Dy::HairSystemDirtyFlag::ePARAMETERS;
}
PxActor* HairSystemCore::getPxActor() const
{
return PxPointerOffset<PxActor*>(const_cast<HairSystemCore*>(this), gOffsetTable.scCore2PxActor[getActorCoreType()]);
}
HairSystemSim* HairSystemCore::getSim() const { return static_cast<HairSystemSim*>(ActorCore::getSim()); }
PxReal HairSystemCore::getContactOffset() const { return mShapeCore.getContactOffset(); }
void HairSystemCore::setContactOffset(PxReal v)
{
mShapeCore.setContactOffset(v);
HairSystemSim* sim = getSim();
if(sim)
{
sim->getScene().updateContactDistance(sim->getShapeSim().getElementID(), v);
}
}
void HairSystemCore::addAttachment(const BodySim& bodySim)
{
const HairSystemSim* sim = getSim();
if(sim)
{
sim->getScene().addAttachment(bodySim, *sim);
}
}
void HairSystemCore::removeAttachment(const BodySim& bodySim)
{
const HairSystemSim* sim = getSim();
if(sim)
{
sim->getScene().removeAttachment(bodySim, *sim);
}
}
void HairSystemCore::addAttachment(const SoftBodySim& sbSim)
{
const Sc::HairSystemSim* sim = getSim();
if(sim)
{
sim->getScene().addAttachment(sbSim, *sim);
}
}
void HairSystemCore::removeAttachment(const SoftBodySim& sbSim)
{
const Sc::HairSystemSim* sim = getSim();
if(sim)
{
sim->getScene().removeAttachment(sbSim, *sim);
}
}
void Sc::HairSystemCore::setFlags(PxHairSystemFlags flags)
{
mShapeCore.getLLCore().mParams.mFlags = flags;
mShapeCore.getLLCore().mDirtyFlags |= Dy::HairSystemDirtyFlag::ePARAMETERS;
}
} // namespace Sc
} // namespace physx
#endif // PX_SUPPORT_GPU_PHYSX
| 4,746 | C++ | 28.855346 | 118 | 0.758323 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScSleep.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScScene.h"
#include "ScArticulationSim.h"
#include "ScBodySim.h"
#include "common/PxProfileZone.h"
#include "ScActorSim.h"
#include "ScArticulationSim.h"
#if PX_SUPPORT_GPU_PHYSX
#include "ScSoftBodySim.h"
#include "ScFEMClothSim.h"
#include "ScParticleSystemSim.h"
#include "ScHairSystemSim.h"
#endif
using namespace physx;
using namespace physx::Cm;
using namespace physx::Dy;
using namespace Sc;
// PT: "setActive()" moved from ActorSim to BodySim because GPU classes silently re-implement this in a very different way (see below),
// i.e. it defeats the purpose of the virtual activate()/deactivate() functions.
void Sc::BodySim::setActive(bool active, bool asPartOfCreation)
{
PX_ASSERT(!active || isDynamicRigid()); // Currently there should be no need to activate an actor that does not take part in island generation
if(asPartOfCreation || isActive() != active)
{
PX_ASSERT(!asPartOfCreation || (getActorInteractionCount() == 0)); // On creation or destruction there should be no interactions
if(active)
{
if(!asPartOfCreation)
getScene().addToActiveList(*this); // Inactive => Active
activate();
PX_ASSERT(asPartOfCreation || isActive());
}
else
{
if(!asPartOfCreation)
getScene().removeFromActiveList(*this); // Active => Inactive
deactivate();
PX_ASSERT(asPartOfCreation || (!isActive()));
}
}
}
void Sc::ArticulationSim::setActive(bool b, bool asPartOfCreation)
{
const PxReal wakeCounter = mCore.getWakeCounter();
const PxU32 nbBodies = mBodies.size();
for(PxU32 i=0;i<nbBodies;i++)
{
if(i+1 < nbBodies)
{
PxPrefetchLine(mBodies[i+1],0);
PxPrefetchLine(mBodies[i+1],128);
}
//KS - force in the wake counter from the articulation to its links. This is required because
//GPU articulation simulation does not DMA back wake counters for each link - it just brings back a global wake counter
mBodies[i]->getBodyCore().setWakeCounterFromSim(wakeCounter);
mBodies[i]->setActive(b, asPartOfCreation);
}
}
// PT: moving all the sleeping-related implementations to the same file clearly exposes the inconsistencies between them
#if PX_SUPPORT_GPU_PHYSX
void Sc::ParticleSystemSim::setActive(bool /*active*/, bool /*asPartOfCreation*/)
{
}
void Sc::FEMClothSim::activate()
{
mScene.getSimulationController()->activateCloth(mLLFEMCloth);
activateInteractions(*this);
}
void Sc::FEMClothSim::deactivate()
{
mScene.getSimulationController()->deactivateCloth(mLLFEMCloth);
deactivateInteractions(*this);
}
void Sc::FEMClothSim::setActive(bool active, bool /*asPartOfCreation*/)
{
if(active)
activate();
else
deactivate();
}
void Sc::SoftBodySim::setActive(bool active, bool /*asPartOfCreation*/)
{
if(active)
getScene().getSimulationController()->activateSoftbody(mLLSoftBody);
else
getScene().getSimulationController()->deactivateSoftbody(mLLSoftBody);
}
void Sc::HairSystemSim::setActive(bool active, bool /*asPartOfCreation*/)
{
if(active)
getScene().getSimulationController()->activateHairSystem(mLLHairSystem);
else
getScene().getSimulationController()->deactivateHairSystem(mLLHairSystem);
}
#endif
namespace
{
struct GetRigidSim { static PX_FORCE_INLINE BodySim* getSim(const IG::Node& node) { return reinterpret_cast<BodySim*>(reinterpret_cast<PxU8*>(node.mRigidBody) - BodySim::getRigidBodyOffset()); } };
struct GetArticSim { static PX_FORCE_INLINE ArticulationSim* getSim(const IG::Node& node) { return reinterpret_cast<ArticulationSim*>(node.mLLArticulation->getUserData()); } };
#if PX_SUPPORT_GPU_PHYSX
struct GetSoftBodySim { static PX_FORCE_INLINE SoftBodySim* getSim(const IG::Node& node) { return node.mLLSoftBody->getSoftBodySim(); } };
struct GetFEMClothSim { static PX_FORCE_INLINE FEMClothSim* getSim(const IG::Node& node) { return node.mLLFEMCloth->getFEMClothSim(); } };
struct GetHairSystemSim { static PX_FORCE_INLINE HairSystemSim* getSim(const IG::Node& node) { return node.mLLHairSystem->getHairSystemSim(); } };
#endif
}
template<class SimT, class SimAccessT, const bool active>
static void setActive(PxU32& nbModified, const IG::IslandSim& islandSim, IG::Node::NodeType type)
{
PxU32 nbToProcess = active ? islandSim.getNbNodesToActivate(type) : islandSim.getNbNodesToDeactivate(type);
const PxNodeIndex* indices = active ? islandSim.getNodesToActivate(type) : islandSim.getNodesToDeactivate(type);
while(nbToProcess--)
{
const IG::Node& node = islandSim.getNode(*indices++);
PX_ASSERT(node.mType == type);
if(node.isActive()==active)
{
SimT* sim = SimAccessT::getSim(node);
if(sim)
{
sim->setActive(active);
nbModified++;
}
}
}
}
#ifdef BATCHED
namespace
{
struct SetActiveRigidSim
{
template<const bool active>
static void setActive(Scene& /*scene*/, PxU32 nbObjects, BodySim** objects)
{
if(1)
{
while(nbObjects--)
{
(*objects)->setActive(active);
objects++;
}
}
else
{
if(active)
{
// scene.addToActiveList(*this);
// activate();
// PX_ASSERT(isActive());
}
else
{
// scene.removeFromActiveList(*this);
// deactivate();
// PX_ASSERT(!isActive());
}
}
}
};
}
template<class SimT, class SimAccessT, class SetActiveBatchedT, const bool active>
static void setActiveBatched(Scene& scene, PxU32& nbModified, const IG::IslandSim& islandSim, IG::Node::NodeType type)
{
PxU32 nbToProcess = active ? islandSim.getNbNodesToActivate(type) : islandSim.getNbNodesToDeactivate(type);
const PxNodeIndex* indices = active ? islandSim.getNodesToActivate(type) : islandSim.getNodesToDeactivate(type);
PX_ALLOCA(batch, SimT*, nbToProcess);
PxU32 nb = 0;
while(nbToProcess--)
{
const IG::Node& node = islandSim.getNode(*indices++);
PX_ASSERT(node.mType == type);
if(node.isActive()==active)
{
SimT* sim = SimAccessT::getSim(node);
if(sim && sim->isActive()!=active)
batch.mPointer[nb++] = sim;
}
}
SetActiveBatchedT::setActive<active>(scene, nb, batch.mPointer);
nbModified = nb;
}
/*
Batched version would be just:
a) addToActiveList(batched objects)
b) activate(batched objects)
void Sc::ActorSim::setActive(bool active)
{
PX_ASSERT(!active || isDynamicRigid()); // Currently there should be no need to activate an actor that does not take part in island generation
if(isActive() != active)
{
if(active)
{
// Inactive => Active
getScene().addToActiveList(*this);
activate();
PX_ASSERT(isActive());
}
else
{
// Active => Inactive
getScene().removeFromActiveList(*this);
deactivate();
PX_ASSERT(!isActive());
}
}
}
*/
#endif
void Sc::Scene::putObjectsToSleep()
{
PX_PROFILE_ZONE("Sc::Scene::putObjectsToSleep", mContextId);
//Set to sleep all bodies that were in awake islands that have just been put to sleep.
const IG::IslandSim& islandSim = mSimpleIslandManager->getAccurateIslandSim();
PxU32 nbBodiesDeactivated = 0;
//setActiveBatched<BodySim, GetRigidSim, SetActiveRigidSim, false>(*this, nbBodiesDeactivated, islandSim, IG::Node::eRIGID_BODY_TYPE);
setActive<BodySim, GetRigidSim, false>(nbBodiesDeactivated, islandSim, IG::Node::eRIGID_BODY_TYPE);
setActive<ArticulationSim, GetArticSim, false>(nbBodiesDeactivated, islandSim, IG::Node::eARTICULATION_TYPE);
#if PX_SUPPORT_GPU_PHYSX
setActive<SoftBodySim, GetSoftBodySim, false>(nbBodiesDeactivated, islandSim, IG::Node::eSOFTBODY_TYPE);
setActive<FEMClothSim, GetFEMClothSim, false>(nbBodiesDeactivated, islandSim, IG::Node::eFEMCLOTH_TYPE);
setActive<HairSystemSim, GetHairSystemSim, false>(nbBodiesDeactivated, islandSim, IG::Node::eHAIRSYSTEM_TYPE);
#endif
if(nbBodiesDeactivated)
mDynamicsContext->setStateDirty(true);
}
void Sc::Scene::wakeObjectsUp()
{
PX_PROFILE_ZONE("Sc::Scene::wakeObjectsUp", mContextId);
//Wake up all bodies that were in sleeping islands that have just been hit by a moving object.
const IG::IslandSim& islandSim = mSimpleIslandManager->getAccurateIslandSim();
PxU32 nbBodiesWoken = 0;
setActive<BodySim, GetRigidSim, true>(nbBodiesWoken, islandSim, IG::Node::eRIGID_BODY_TYPE);
setActive<ArticulationSim, GetArticSim, true>(nbBodiesWoken, islandSim, IG::Node::eARTICULATION_TYPE);
#if PX_SUPPORT_GPU_PHYSX
setActive<SoftBodySim, GetSoftBodySim, true>(nbBodiesWoken, islandSim, IG::Node::eSOFTBODY_TYPE);
setActive<FEMClothSim, GetFEMClothSim, true>(nbBodiesWoken, islandSim, IG::Node::eFEMCLOTH_TYPE);
setActive<HairSystemSim, GetHairSystemSim, true>(nbBodiesWoken, islandSim, IG::Node::eHAIRSYSTEM_TYPE);
#endif
if(nbBodiesWoken)
mDynamicsContext->setStateDirty(true);
}
| 10,286 | C++ | 31.553797 | 200 | 0.73566 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScSqBoundsManager.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-2023 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 SC_SQ_BOUNDS_MANAGER_H
#define SC_SQ_BOUNDS_MANAGER_H
#include "foundation/PxUserAllocated.h"
#include "foundation/PxBitMap.h"
#include "foundation/PxArray.h"
#include "ScSqBoundsSync.h"
namespace physx
{
class PxBounds3;
namespace Sc
{
struct SqBoundsSync;
struct SqRefFinder;
class ShapeSimBase;
class SqBoundsManager0 : public PxUserAllocated
{
PX_NOCOPY(SqBoundsManager0)
public:
SqBoundsManager0();
void addSyncShape(ShapeSimBase& shape);
void removeSyncShape(ShapeSimBase& shape);
void syncBounds(SqBoundsSync& sync, SqRefFinder& finder, const PxBounds3* bounds, const PxTransform32* transforms, PxU64 contextID, const PxBitMap& ignoredIndices);
private:
PxArray<ShapeSimBase*> mShapes; //
PxArray<ScPrunerHandle> mRefs; // SQ pruner references
PxArray<PxU32> mBoundsIndices; // indices into the Sc bounds array
PxArray<ShapeSimBase*> mRefless; // shapesims without references
};
class SqBoundsManagerEx : public PxUserAllocated
{
PX_NOCOPY(SqBoundsManagerEx)
public:
SqBoundsManagerEx();
~SqBoundsManagerEx();
void addSyncShape(ShapeSimBase& shape);
void removeSyncShape(ShapeSimBase& shape);
void syncBounds(SqBoundsSync& sync, SqRefFinder& finder, const PxBounds3* bounds, const PxTransform32* transforms, PxU64 contextID, const PxBitMap& ignoredIndices);
private:
PxArray<ShapeSimBase*> mWaitingRoom;
// PT: one of the many solutions discussed in https://confluence.nvidia.com/display/~pterdiman/The+new+SQ+system
// Just to get something working. This will most likely need revisiting later.
struct PrunerSyncData : public PxUserAllocated
{
PxArray<ShapeSimBase*> mShapes; //
// PT: layout dictated by the SqPruner API here. We could consider merging these two arrays.
PxArray<ScPrunerHandle> mRefs; // SQ pruner references
PxArray<PxU32> mBoundsIndices; // indices into the Sc bounds array
};
PrunerSyncData** mPrunerSyncData;
PxU32 mPrunerSyncDataSize;
void resize(PxU32 index);
};
//class SqBoundsManager : public SqBoundsManager0
class SqBoundsManager : public SqBoundsManagerEx
{
public:
};
}
}
#endif
| 3,898 | C | 35.439252 | 170 | 0.751154 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScParticleSystemCore.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
#include "foundation/PxPreprocessor.h"
#if PX_SUPPORT_GPU_PHYSX
#include "ScParticleSystemCore.h"
#include "ScPhysics.h"
#include "ScParticleSystemSim.h"
#include "DyParticleSystem.h"
#include "PxvGlobals.h"
#include "PxPhysXGpu.h"
using namespace physx;
Sc::ParticleSystemCore::ParticleSystemCore(PxActorType::Enum actorType) :
ActorCore(actorType, PxActorFlag::eVISUALIZATION, PX_DEFAULT_CLIENT, 0)
{
}
Sc::ParticleSystemCore::~ParticleSystemCore()
{
}
Sc::ParticleSystemSim* Sc::ParticleSystemCore::getSim() const
{
return static_cast<ParticleSystemSim*>(ActorCore::getSim());
}
PxReal Sc::ParticleSystemCore::getSleepThreshold() const
{
return mShapeCore.getLLCore().sleepThreshold;//mCore.sleepThreshold;
}
void Sc::ParticleSystemCore::setSleepThreshold(const PxReal v)
{
mShapeCore.getLLCore().sleepThreshold = v;
}
PxReal Sc::ParticleSystemCore::getRestOffset() const
{
return mShapeCore.getLLCore().restOffset;
}
void Sc::ParticleSystemCore::setRestOffset(const PxReal v)
{
mShapeCore.getLLCore().restOffset = v;
}
PxReal Sc::ParticleSystemCore::getContactOffset() const
{
return mShapeCore.getContactOffset();
}
void Sc::ParticleSystemCore::setContactOffset(const PxReal v)
{
mShapeCore.setContactOffset(v);
Sc::ParticleSystemSim* sim = getSim();
if (sim)
{
sim->getScene().updateContactDistance(sim->getShapeSim().getElementID(), v);
}
}
PxReal Sc::ParticleSystemCore::getParticleContactOffset() const
{
return mShapeCore.getLLCore().particleContactOffset;
}
void Sc::ParticleSystemCore::setParticleContactOffset(const PxReal v)
{
mShapeCore.getLLCore().particleContactOffset = v;
}
PxReal Sc::ParticleSystemCore::getSolidRestOffset() const
{
return mShapeCore.getLLCore().solidRestOffset;
}
void Sc::ParticleSystemCore::setSolidRestOffset(const PxReal v)
{
mShapeCore.getLLCore().solidRestOffset = v;
}
PxReal Sc::ParticleSystemCore::getFluidRestOffset() const
{
return mShapeCore.getLLCore().fluidRestOffset;
}
void Sc::ParticleSystemCore::setFluidRestOffset(const PxReal v)
{
mShapeCore.getLLCore().fluidRestOffset = v;
}
void Sc::ParticleSystemCore::setMaxDepenetrationVelocity(const PxReal v)
{
mShapeCore.getLLCore().maxDepenetrationVelocity = v;
}
PxReal Sc::ParticleSystemCore::getMaxDepenetrationVelocity() const
{
return mShapeCore.getLLCore().maxDepenetrationVelocity;
}
void Sc::ParticleSystemCore::setMaxVelocity(const PxReal v)
{
mShapeCore.getLLCore().maxVelocity = v;
}
PxReal Sc::ParticleSystemCore::getMaxVelocity() const
{
return mShapeCore.getLLCore().maxVelocity;
}
PxParticleSystemCallback* Sc::ParticleSystemCore::getParticleSystemCallback() const
{
return mShapeCore.getLLCore().mCallback;
}
void Sc::ParticleSystemCore::setParticleSystemCallback(PxParticleSystemCallback* callback)
{
mShapeCore.getLLCore().mCallback = callback;
}
PxReal Sc::ParticleSystemCore::getFluidBoundaryDensityScale() const
{
return mShapeCore.getLLCore().fluidBoundaryDensityScale;
}
void Sc::ParticleSystemCore::setFluidBoundaryDensityScale(const PxReal v)
{
mShapeCore.getLLCore().fluidBoundaryDensityScale = v;
}
PxU32 Sc::ParticleSystemCore::getGridSizeX() const
{
return mShapeCore.getLLCore().gridSizeX;
}
void Sc::ParticleSystemCore::setGridSizeX(const PxU32 v)
{
mShapeCore.getLLCore().gridSizeX = v;
}
PxU32 Sc::ParticleSystemCore::getGridSizeY() const
{
return mShapeCore.getLLCore().gridSizeY;
}
void Sc::ParticleSystemCore::setGridSizeY(const PxU32 v)
{
mShapeCore.getLLCore().gridSizeY = v;
}
PxU32 Sc::ParticleSystemCore::getGridSizeZ() const
{
return mShapeCore.getLLCore().gridSizeZ;
}
void Sc::ParticleSystemCore::setGridSizeZ(const PxU32 v)
{
mShapeCore.getLLCore().gridSizeZ = v;
}
void Sc::ParticleSystemCore::setSolverIterationCounts(PxU16 c)
{
mShapeCore.getLLCore().solverIterationCounts = c;
}
PxReal Sc::ParticleSystemCore::getWakeCounter() const
{
return mShapeCore.getLLCore().wakeCounter;
}
void Sc::ParticleSystemCore::setWakeCounter(const PxReal v)
{
mShapeCore.getLLCore().wakeCounter = v;
}
void Sc::ParticleSystemCore::setWakeCounterInternal(const PxReal v)
{
mShapeCore.getLLCore().wakeCounter = v;
}
bool Sc::ParticleSystemCore::isSleeping() const
{
Sc::ParticleSystemSim* sim = getSim();
return sim ? sim->isSleeping() : (mShapeCore.getLLCore().wakeCounter == 0.0f);
}
void Sc::ParticleSystemCore::wakeUp(PxReal wakeCounter)
{
mShapeCore.getLLCore().wakeCounter = wakeCounter;
}
void Sc::ParticleSystemCore::putToSleep()
{
mShapeCore.getLLCore().wakeCounter = 0.0f;
}
PxActor* Sc::ParticleSystemCore::getPxActor() const
{
return PxPointerOffset<PxActor*>(const_cast<ParticleSystemCore*>(this), gOffsetTable.scCore2PxActor[getActorCoreType()]);
}
// TOFIX
void Sc::ParticleSystemCore::enableCCD(const bool enable)
{
mShapeCore.getLLCore().enableCCD = enable;
}
void Sc::ParticleSystemCore::addRigidAttachment(Sc::BodyCore* core)
{
Sc::ParticleSystemSim* sim = getSim();
if(sim)
sim->getScene().addRigidAttachment(core, *sim);
}
void Sc::ParticleSystemCore::removeRigidAttachment(Sc::BodyCore* core)
{
Sc::ParticleSystemSim* sim = getSim();
if (sim)
sim->getScene().removeRigidAttachment(core, *sim);
}
void Sc::ParticleSystemCore::setFlags(PxParticleFlags flags)
{
Sc::ParticleSystemSim* sim = getSim();
PxParticleFlags oldFlags = mShapeCore.getLLCore().mFlags;
mShapeCore.getLLCore().mFlags = flags;
if (sim)
{
bool wasRigidCollisionDisabled = oldFlags & PxParticleFlag::eDISABLE_RIGID_COLLISION;
bool isRigidCollisionDisabled = flags & PxParticleFlag::eDISABLE_RIGID_COLLISION;
if (wasRigidCollisionDisabled ^ isRigidCollisionDisabled)
{
if (wasRigidCollisionDisabled)
sim->getShapeSim().createLowLevelVolume();
else
sim->getShapeSim().destroyLowLevelVolume();
}
}
}
#endif //PX_SUPPORT_GPU_PHYSX
| 7,348 | C++ | 25.340502 | 122 | 0.773272 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScFEMClothCore.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "foundation/PxPreprocessor.h"
#if PX_SUPPORT_GPU_PHYSX
#include "ScFEMClothCore.h"
#include "ScPhysics.h"
#include "ScFEMClothSim.h"
#include "DyFEMCloth.h"
#include "GuTetrahedronMesh.h"
#include "GuBV4.h"
#include "geometry/PxTetrahedronMesh.h"
#include "cudamanager/PxCudaContextManager.h"
using namespace physx;
Sc::FEMClothCore::FEMClothCore() :
ActorCore(PxActorType::eFEMCLOTH, PxActorFlag::eVISUALIZATION, PX_DEFAULT_CLIENT, 0),
mGpuMemStat(0)
{
mCore.solverIterationCounts = (1 << 8) | 4;
mCore.dirty = true;
#if PX_ENABLE_FEATURES_UNDER_CONSTRUCTION
mCore.mFlags = PxFEMClothFlags(0);
#endif
mCore.mPositionInvMass = NULL;
mCore.mVelocity = NULL;
mCore.mRestPosition = NULL;
mCore.wakeCounter = Physics::sWakeCounterOnCreation;
}
Sc::FEMClothCore::~FEMClothCore() { }
PxFEMParameters Sc::FEMClothCore::getParameter() const
{
#if PX_ENABLE_FEATURES_UNDER_CONSTRUCTION
return mCore.parameters;
#else
return PxFEMParameters();
#endif
}
#if PX_ENABLE_FEATURES_UNDER_CONSTRUCTION
void Sc::FEMClothCore::setParameter(const PxFEMParameters& parameter)
{
mCore.parameters = parameter;
mCore.dirty = true;
}
#else
void Sc::FEMClothCore::setParameter(const PxFEMParameters&)
{
mCore.dirty = true;
}
#endif
void Sc::FEMClothCore::addRigidFilter(Sc::BodyCore* core, PxU32 vertId)
{
Sc::FEMClothSim* sim = getSim();
if (sim)
sim->getScene().addRigidFilter(core, *sim, vertId);
}
void Sc::FEMClothCore::removeRigidFilter(Sc::BodyCore* core, PxU32 vertId)
{
Sc::FEMClothSim* sim = getSim();
if (sim)
sim->getScene().removeRigidFilter(core, *sim, vertId);
}
PxU32 Sc::FEMClothCore::addRigidAttachment(Sc::BodyCore* core, PxU32 particleId, const PxVec3& actorSpacePose, PxConeLimitedConstraint* params)
{
Sc::FEMClothSim* sim = getSim();
PxU32 handle = 0xFFFFFFFF;
if (sim)
{
handle = sim->getScene().addRigidAttachment(core, *sim, particleId, actorSpacePose, params);
}
return handle;
}
void Sc::FEMClothCore::removeRigidAttachment(Sc::BodyCore* core, PxU32 handle)
{
Sc::FEMClothSim* sim = getSim();
if (sim)
{
sim->getScene().removeRigidAttachment(core, *sim, handle);
setWakeCounter(ScInternalWakeCounterResetValue);
}
}
void Sc::FEMClothCore::addTriRigidFilter(Sc::BodyCore* core, PxU32 triIdx)
{
Sc::FEMClothSim* sim = getSim();
if (sim)
sim->getScene().addTriRigidFilter(core, *sim, triIdx);
}
void Sc::FEMClothCore::removeTriRigidFilter(Sc::BodyCore* core, PxU32 triIdx)
{
Sc::FEMClothSim* sim = getSim();
if (sim)
sim->getScene().removeTriRigidFilter(core, *sim, triIdx);
}
PxU32 Sc::FEMClothCore::addTriRigidAttachment(Sc::BodyCore* core, PxU32 triIdx, const PxVec4& barycentric, const PxVec3& actorSpacePose, PxConeLimitedConstraint* constraint)
{
Sc::FEMClothSim* sim = getSim();
PxU32 handle = 0xFFFFFFFF;
if (sim)
handle = sim->getScene().addTriRigidAttachment(core, *sim, triIdx, barycentric, actorSpacePose, constraint);
return handle;
}
void Sc::FEMClothCore::removeTriRigidAttachment(Sc::BodyCore* core, PxU32 handle)
{
Sc::FEMClothSim* sim = getSim();
if (sim)
{
sim->getScene().removeTriRigidAttachment(core, *sim, handle);
setWakeCounter(ScInternalWakeCounterResetValue);
}
}
void Sc::FEMClothCore::addClothFilter(Sc::FEMClothCore* otherCore, PxU32 otherTriIdx, PxU32 triIdx)
{
Sc::FEMClothSim* sim = getSim();
if (sim)
sim->getScene().addClothFilter(*otherCore, otherTriIdx, *sim, triIdx);
}
void Sc::FEMClothCore::removeClothFilter(Sc::FEMClothCore* otherCore, PxU32 otherTriIdx, PxU32 triIdx)
{
Sc::FEMClothSim* sim = getSim();
if (sim)
sim->getScene().removeClothFilter(*otherCore, otherTriIdx, *sim, triIdx);
}
PxU32 Sc::FEMClothCore::addClothAttachment(Sc::FEMClothCore* otherCore, PxU32 otherTriIdx, const PxVec4& otherTriBarycentric, PxU32 triIdx, const PxVec4& triBarycentric)
{
Sc::FEMClothSim* sim = getSim();
PxU32 handle = 0xFFFFFFFF;
if (sim)
handle = sim->getScene().addTriClothAttachment(*otherCore, otherTriIdx, otherTriBarycentric, *sim, triIdx, triBarycentric);
return handle;
}
void Sc::FEMClothCore::removeClothAttachment(Sc::FEMClothCore* otherCore, PxU32 handle)
{
Sc::FEMClothSim* sim = getSim();
setWakeCounter(ScInternalWakeCounterResetValue);
otherCore->setWakeCounter(ScInternalWakeCounterResetValue);
if (sim)
sim->getScene().removeTriClothAttachment(*otherCore, *sim, handle);
}
void Sc::FEMClothCore::setBendingScales(const PxReal* const bendingScales, PxU32 nbElements)
{
mCore.mBendingScales.assign(bendingScales, bendingScales + nbElements);
mCore.dirty = true;
}
const PxReal* Sc::FEMClothCore::getBendingScales() const
{
return mCore.mBendingScales.empty() ? NULL : mCore.mBendingScales.begin();
}
void Sc::FEMClothCore::setSolverIterationCounts(const PxU16 c)
{
mCore.solverIterationCounts = c;
mCore.dirty = true;
}
PxActor* Sc::FEMClothCore::getPxActor() const
{
return PxPointerOffset<PxActor*>(const_cast<FEMClothCore*>(this), gOffsetTable.scCore2PxActor[getActorCoreType()]);
}
void Sc::FEMClothCore::attachShapeCore(ShapeCore* shapeCore)
{
Sc::FEMClothSim* sim = getSim();
if (sim)
sim->attachShapeCore(shapeCore);
}
PxReal Sc::FEMClothCore::getWakeCounter() const
{
return mCore.wakeCounter;
}
void Sc::FEMClothCore::setWakeCounter(const PxReal v)
{
mCore.wakeCounter = v;
mCore.dirty = true;
Sc::FEMClothSim* sim = getSim();
if (sim)
{
sim->onSetWakeCounter();
}
}
void Sc::FEMClothCore::setWakeCounterInternal(const PxReal v)
{
mCore.wakeCounter = v;
mCore.dirty = true;
Sc::FEMClothSim* sim = getSim();
if (sim)
{
sim->onSetWakeCounter();
}
}
Sc::FEMClothSim* Sc::FEMClothCore::getSim() const
{
return static_cast<Sc::FEMClothSim*>(ActorCore::getSim());
}
void Sc::FEMClothCore::setSimulationFilterData(const PxFilterData& data)
{
mFilterData = data;
}
PxFilterData Sc::FEMClothCore::getSimulationFilterData() const
{
return mFilterData;
}
#if PX_ENABLE_FEATURES_UNDER_CONSTRUCTION
void Sc::FEMClothCore::setFlags(PxFEMClothFlags flags)
{
mCore.mFlags = flags;
mCore.dirty = true;
}
#endif
void Sc::FEMClothCore::onShapeChange(ShapeCore& shape, ShapeChangeNotifyFlags notifyFlags)
{
PX_UNUSED(shape);
FEMClothSim* sim = getSim();
if (!sim)
return;
FEMClothShapeSim& s = sim->getShapeSim();
if (notifyFlags & ShapeChangeNotifyFlag::eGEOMETRY)
s.onVolumeOrTransformChange();
if (notifyFlags & ShapeChangeNotifyFlag::eMATERIAL)
s.onMaterialChange();
if (notifyFlags & ShapeChangeNotifyFlag::eRESET_FILTERING)
s.onResetFiltering();
if (notifyFlags & ShapeChangeNotifyFlag::eSHAPE2BODY)
s.onVolumeOrTransformChange();
if (notifyFlags & ShapeChangeNotifyFlag::eFILTERDATA)
s.onFilterDataChange();
if (notifyFlags & ShapeChangeNotifyFlag::eCONTACTOFFSET)
s.onContactOffsetChange();
if (notifyFlags & ShapeChangeNotifyFlag::eRESTOFFSET)
s.onRestOffsetChange();
}
#endif //PX_SUPPORT_GPU_PHYSX
| 8,547 | C++ | 27.026229 | 173 | 0.753715 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScArticulationJointSim.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScArticulationJointSim.h"
#include "ScArticulationJointCore.h"
#include "ScBodySim.h"
#include "ScScene.h"
#include "PxsRigidBody.h"
#include "ScArticulationSim.h"
#include "PxsSimpleIslandManager.h"
using namespace physx;
Sc::ArticulationJointSim::ArticulationJointSim(ArticulationJointCore& joint, ActorSim& parent, ActorSim& child) :
Interaction (parent, child, InteractionType::eARTICULATION, 0),
mCore (joint)
{
{
onActivate(NULL);
registerInActors();
}
BodySim& childBody = static_cast<BodySim&>(child),
& parentBody = static_cast<BodySim&>(parent);
parentBody.getArticulation()->addBody(childBody, &parentBody, this);
mCore.setSim(this);
}
Sc::ArticulationJointSim::~ArticulationJointSim()
{
// articulation interactions do not make use of the dirty flags yet. If they did, a setClean(true) has to be introduced here.
PX_ASSERT(!readInteractionFlag(InteractionFlag::eIN_DIRTY_LIST));
PX_ASSERT(!getDirtyFlags());
unregisterFromActors();
mCore.setSim(NULL);
}
Sc::BodySim& Sc::ArticulationJointSim::getParent() const
{
return static_cast<BodySim&>(getActorSim0());
}
Sc::BodySim& Sc::ArticulationJointSim::getChild() const
{
return static_cast<BodySim&>(getActorSim1());
}
bool Sc::ArticulationJointSim::onActivate(void*)
{
if(!(getParent().isActive() && getChild().isActive()))
return false;
raiseInteractionFlag(InteractionFlag::eIS_ACTIVE);
return true;
}
bool Sc::ArticulationJointSim::onDeactivate()
{
clearInteractionFlag(InteractionFlag::eIS_ACTIVE);
return true;
}
void Sc::ArticulationJointSim::setDirty()
{
Dy::ArticulationJointCore& llCore = mCore.getCore();
ArticulationSim* sim = mCore.getArticulation()->getSim();
sim->setJointDirty(llCore);
}
| 3,421 | C++ | 33.918367 | 126 | 0.758842 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScObjectIDTracker.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-2023 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 SC_OBJECT_ID_TRACKER_H
#define SC_OBJECT_ID_TRACKER_H
#include "CmIDPool.h"
#include "foundation/PxBitMap.h"
#include "foundation/PxUserAllocated.h"
namespace physx
{
namespace Sc
{
// PT: TODO: this has no direct dependency on "Sc". It should really be a "Cm" class.
class ObjectIDTracker : public PxUserAllocated
{
PX_NOCOPY(ObjectIDTracker)
public:
ObjectIDTracker() : mPendingReleasedIDs("objectIDTrackerIDs") {}
PX_INLINE PxU32 createID() { return mIDPool.getNewID(); }
PX_INLINE void releaseID(PxU32 id)
{
markIDAsDeleted(id);
mPendingReleasedIDs.pushBack(id);
}
PX_INLINE PxIntBool isDeletedID(PxU32 id) const { return mDeletedIDsMap.boundedTest(id); }
PX_FORCE_INLINE PxU32 getDeletedIDCount() const { return mPendingReleasedIDs.size(); }
PX_INLINE void clearDeletedIDMap() { mDeletedIDsMap.clear(); }
PX_INLINE void resizeDeletedIDMap(PxU32 id, PxU32 numIds)
{
mDeletedIDsMap.resize(id);
mPendingReleasedIDs.reserve(numIds);
}
PX_INLINE void processPendingReleases()
{
for(PxU32 i=0; i < mPendingReleasedIDs.size(); i++)
mIDPool.freeID(mPendingReleasedIDs[i]);
mPendingReleasedIDs.clear();
}
PX_INLINE void reset()
{
processPendingReleases();
mPendingReleasedIDs.reset();
// Don't free stuff in IDPool, we still need the list of free IDs
// And it does not seem worth freeing the memory of the bitmap
}
PX_INLINE PxU32 getMaxID() const
{
return mIDPool.getMaxID();
}
private:
PX_INLINE void markIDAsDeleted(PxU32 id)
{
PX_ASSERT(!isDeletedID(id));
mDeletedIDsMap.growAndSet(id);
}
Cm::IDPool mIDPool;
PxBitMap mDeletedIDsMap;
PxArray<PxU32> mPendingReleasedIDs; // Buffer for released IDs to make sure newly created objects do not re-use these IDs immediately
};
}
}
#endif
| 3,791 | C | 36.544554 | 140 | 0.688209 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScSimulationController.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScSimulationController.h"
#include "foundation/PxAllocator.h"
#include "CmTask.h"
#include "CmFlushPool.h"
#include "PxNodeIndex.h"
#include "ScArticulationSim.h"
#include "PxsContext.h"
#include "foundation/PxAllocator.h"
#include "BpAABBManager.h"
#include "DyVArticulation.h"
using namespace physx;
void Sc::SimulationController::updateScBodyAndShapeSim(PxsTransformCache& /*cache*/, Bp::BoundsArray& /*boundArray*/, PxBaseTask* continuation)
{
mCallback->updateScBodyAndShapeSim(continuation);
}
namespace
{
class UpdateArticulationAfterIntegrationTask : public Cm::Task
{
IG::IslandSim& mIslandSim;
const PxNodeIndex* const PX_RESTRICT mNodeIndices;
const PxU32 mNbArticulations;
const PxReal mDt;
PX_NOCOPY(UpdateArticulationAfterIntegrationTask)
public:
static const PxU32 NbArticulationsPerTask = 64;
UpdateArticulationAfterIntegrationTask(PxU64 contextId, PxU32 nbArticulations, PxReal dt, const PxNodeIndex* nodeIndices, IG::IslandSim& islandSim) :
Cm::Task(contextId),
mIslandSim(islandSim),
mNodeIndices(nodeIndices),
mNbArticulations(nbArticulations),
mDt(dt)
{
}
virtual void runInternal()
{
for (PxU32 i = 0; i < mNbArticulations; ++i)
{
PxNodeIndex nodeIndex = mNodeIndices[i];
//Sc::ArticulationSim* articSim = getArticulationSim(mIslandSim, nodeIndex);
Sc::ArticulationSim* articSim = mIslandSim.getArticulationSim(nodeIndex);
articSim->sleepCheck(mDt);
articSim->updateCached(NULL);
}
}
virtual const char* getName() const { return "UpdateArticulationAfterIntegrationTask"; }
};
}
//KS - TODO - parallelize this bit!!!!!
void Sc::SimulationController::updateArticulationAfterIntegration(
PxsContext* llContext,
Bp::AABBManagerBase* aabbManager,
PxArray<Sc::BodySim*>& ccdBodies,
PxBaseTask* continuation,
IG::IslandSim& islandSim,
float dt
)
{
const PxU32 nbActiveArticulations = islandSim.getNbActiveNodes(IG::Node::eARTICULATION_TYPE);
Cm::FlushPool& flushPool = llContext->getTaskPool();
const PxNodeIndex* activeArticulations = islandSim.getActiveNodes(IG::Node::eARTICULATION_TYPE);
for (PxU32 i = 0; i < nbActiveArticulations; i += UpdateArticulationAfterIntegrationTask::NbArticulationsPerTask)
{
UpdateArticulationAfterIntegrationTask* task =
PX_PLACEMENT_NEW(flushPool.allocate(sizeof(UpdateArticulationAfterIntegrationTask)), UpdateArticulationAfterIntegrationTask)(islandSim.getContextId(), PxMin(UpdateArticulationAfterIntegrationTask::NbArticulationsPerTask, PxU32(nbActiveArticulations - i)), dt,
activeArticulations + i, islandSim);
startTask(task, continuation);
}
llContext->getLock().lock();
//const IG::NodeIndex* activeArticulations = islandSim.getActiveNodes(IG::Node::eARTICULATION_TYPE);
PxBitMapPinned& changedAABBMgrActorHandles = aabbManager->getChangedAABBMgActorHandleMap();
for (PxU32 i = 0; i < nbActiveArticulations; i++)
{
Sc::ArticulationSim* articSim = islandSim.getArticulationSim(activeArticulations[i]);
//KS - check links for CCD flags and add to mCcdBodies list if required....
articSim->updateCCDLinks(ccdBodies);
articSim->markShapesUpdated(&changedAABBMgrActorHandles);
}
llContext->getLock().unlock();
}
| 4,895 | C++ | 37.551181 | 262 | 0.772012 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScInteractionFlags.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-2023 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 SC_INTERACTION_FLAGS_H
#define SC_INTERACTION_FLAGS_H
#include "foundation/Px.h"
namespace physx
{
namespace Sc
{
struct InteractionFlag // PT: TODO: use PxFlags
{
enum Enum
{
eRB_ELEMENT = (1 << 0), // Interactions between rigid body shapes
eCONSTRAINT = (1 << 1),
eFILTERABLE = (1 << 2), // Interactions that go through the filter code
eIN_DIRTY_LIST = (1 << 3), // The interaction is in the dirty list
eIS_FILTER_PAIR = (1 << 4), // The interaction is tracked by the filter callback mechanism
eIS_ACTIVE = (1 << 5)
};
};
struct InteractionDirtyFlag
{
enum Enum
{
eFILTER_STATE = (1 << 0), // All changes filtering related
eMATERIAL = (1 << 1),
eBODY_KINEMATIC = (1 << 2) | eFILTER_STATE, // A transition between dynamic and kinematic (and vice versa) require a refiltering
eDOMINANCE = (1 << 3),
eREST_OFFSET = (1 << 4),
eVISUALIZATION = (1 << 5)
};
};
} // namespace Sc
} // namespace physx
#endif
| 2,692 | C | 35.391891 | 133 | 0.71471 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScBroadphase.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScBroadphase.h"
#include "BpAABBManagerBase.h"
#include "ScShapeSim.h"
using namespace physx;
using namespace Sc;
using namespace Bp;
///////////////////////////////////////////////////////////////////////////////
BroadphaseManager::BroadphaseManager() :
mBroadPhaseCallback (NULL),
mOutOfBoundsIDs ("sceneOutOfBoundsIds")
{
}
BroadphaseManager::~BroadphaseManager()
{
}
void BroadphaseManager::prepareOutOfBoundsCallbacks(AABBManagerBase* aabbManager)
{
AABBManagerBase::OutOfBoundsData data;
if(!aabbManager->getOutOfBoundsObjects(data))
return;
PxU32 nbOut = data.mNbOutOfBoundsObjects;
void** outObjects = data.mOutOfBoundsObjects;
mOutOfBoundsIDs.clear();
while(nbOut--)
{
const ElementSim* volume = reinterpret_cast<const ElementSim*>(*outObjects++);
const Sc::ShapeSim* sim = static_cast<const Sc::ShapeSim*>(volume);
mOutOfBoundsIDs.pushBack(sim->getElementID());
}
}
bool BroadphaseManager::fireOutOfBoundsCallbacks(Bp::AABBManagerBase* aabbManager, const ObjectIDTracker& tracker)
{
AABBManagerBase::OutOfBoundsData data;
if(!aabbManager->getOutOfBoundsObjects(data))
return false;
bool outputWarning = false;
PxBroadPhaseCallback* cb = mBroadPhaseCallback;
// Actors
{
PxU32 nbOut = data.mNbOutOfBoundsObjects;
void** outObjects = data.mOutOfBoundsObjects;
for(PxU32 i=0;i<nbOut;i++)
{
ElementSim* volume = reinterpret_cast<ElementSim*>(outObjects[i]);
Sc::ShapeSim* sim = static_cast<Sc::ShapeSim*>(volume);
// PT: TODO: I'm not sure the split between prepareOutOfBoundsCallbacks / fireOutOfBoundsCallbacks
// and the test for deletion is still needed after the removal of SCB
if(tracker.isDeletedID(mOutOfBoundsIDs[i]))
continue;
if(cb)
{
ActorSim& actor = volume->getActor();
RigidSim& rigidSim = static_cast<RigidSim&>(actor);
PxActor* pxActor = rigidSim.getPxActor();
PxShape* px = sim->getPxShape();
cb->onObjectOutOfBounds(*px, *pxActor);
}
else
outputWarning = true;
}
}
// Aggregates
{
PxU32 nbOut = data.mNbOutOfBoundsAggregates;
void** outAgg = data.mOutOfBoundsAggregates;
for(PxU32 i=0;i<nbOut;i++)
{
PxAggregate* px = reinterpret_cast<PxAggregate*>(outAgg[i]);
if(cb)
cb->onObjectOutOfBounds(*px);
else
outputWarning = true;
}
}
aabbManager->clearOutOfBoundsObjects();
return outputWarning;
}
void BroadphaseManager::flush(Bp::AABBManagerBase* /*aabbManager*/)
{
mOutOfBoundsIDs.reset();
}
| 4,172 | C++ | 30.37594 | 114 | 0.731064 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScKinematics.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "common/PxProfileZone.h"
#include "ScScene.h"
#include "ScBodySim.h"
#include "ScShapeSim.h"
#include "PxsSimulationController.h"
#include "BpAABBManagerBase.h"
using namespace physx;
using namespace Sc;
//PX_IMPLEMENT_OUTPUT_ERROR
///////////////////////////////////////////////////////////////////////////////
// PT: TODO: consider using a non-member function for this one
void BodySim::calculateKinematicVelocity(PxReal oneOverDt)
{
PX_ASSERT(isKinematic());
/*------------------------------------------------\
| kinematic bodies are moved directly by the user and are not influenced by external forces
| we simply determine the distance moved since the last simulation frame and
| assign the appropriate delta to the velocity. This vel will be used to shove dynamic
| objects in the solver.
| We have to do this like so in a delayed way, because when the user sets the target pos the dt is not
| yet known.
\------------------------------------------------*/
PX_ASSERT(isActive());
BodyCore& core = getBodyCore();
if (readInternalFlag(BF_KINEMATIC_MOVED))
{
clearInternalFlag(InternalFlags(BF_KINEMATIC_SETTLING | BF_KINEMATIC_SETTLING_2));
const SimStateData* kData = getSimStateData(true);
PX_ASSERT(kData);
PX_ASSERT(kData->isKine());
PX_ASSERT(kData->getKinematicData()->targetValid);
PxVec3 linVelLL, angVelLL;
const PxTransform targetPose = kData->getKinematicData()->targetPose;
const PxTransform& currBody2World = getBody2World();
//the kinematic target pose is now the target of the body (CoM) and not the actor.
PxVec3 deltaPos = targetPose.p;
deltaPos -= currBody2World.p;
linVelLL = deltaPos * oneOverDt;
PxQuat q = targetPose.q * currBody2World.q.getConjugate();
if (q.w < 0) //shortest angle.
q = -q;
PxReal angle;
PxVec3 axis;
q.toRadiansAndUnitAxis(angle, axis);
angVelLL = axis * angle * oneOverDt;
core.getCore().linearVelocity = linVelLL;
core.getCore().angularVelocity = angVelLL;
// Moving a kinematic should trigger a wakeUp call on a higher level.
PX_ASSERT(core.getWakeCounter()>0);
PX_ASSERT(isActive());
}
else if (!readInternalFlag(BF_KINEMATIC_SURFACE_VELOCITY))
{
core.setLinearVelocity(PxVec3(0.0f), true);
core.setAngularVelocity(PxVec3(0.0f), true);
}
}
namespace
{
class ScKinematicUpdateTask : public Cm::Task
{
Sc::BodyCore*const* mKinematics;
const PxU32 mNbKinematics;
const PxReal mOneOverDt;
PX_NOCOPY(ScKinematicUpdateTask)
public:
static const PxU32 NbKinematicsPerTask = 1024;
ScKinematicUpdateTask(Sc::BodyCore*const* kinematics, PxU32 nbKinematics, PxReal oneOverDt, PxU64 contextID) :
Cm::Task(contextID), mKinematics(kinematics), mNbKinematics(nbKinematics), mOneOverDt(oneOverDt)
{
}
virtual void runInternal()
{
Sc::BodyCore*const* kinematics = mKinematics;
PxU32 nb = mNbKinematics;
const float oneOverDt = mOneOverDt;
while(nb--)
{
Sc::BodyCore* b = *kinematics++;
PX_ASSERT(b->getSim()->isKinematic());
PX_ASSERT(b->getSim()->isActive());
b->getSim()->calculateKinematicVelocity(oneOverDt);
}
}
virtual const char* getName() const
{
return "ScScene.KinematicUpdateTask";
}
};
}
void Sc::Scene::kinematicsSetup(PxBaseTask* continuation)
{
const PxU32 nbKinematics = getActiveKinematicBodiesCount();
if(!nbKinematics)
return;
BodyCore*const* kinematics = getActiveKinematicBodies();
// PT: create a copy of active bodies for the taks to operate on while the main array is
// potentially resized by operations running in parallel.
if(mActiveKinematicsCopyCapacity<nbKinematics)
{
PX_FREE(mActiveKinematicsCopy);
mActiveKinematicsCopy = PX_ALLOCATE(BodyCore*, nbKinematics, "Sc::Scene::mActiveKinematicsCopy");
mActiveKinematicsCopyCapacity = nbKinematics;
}
PxMemCopy(mActiveKinematicsCopy, kinematics, nbKinematics*sizeof(BodyCore*));
kinematics = mActiveKinematicsCopy;
Cm::FlushPool& flushPool = mLLContext->getTaskPool();
// PT: TASK-CREATION TAG
// PT: TODO: better load balancing? This will be single threaded for less than 1K kinematics
for(PxU32 i = 0; i < nbKinematics; i += ScKinematicUpdateTask::NbKinematicsPerTask)
{
ScKinematicUpdateTask* task = PX_PLACEMENT_NEW(flushPool.allocate(sizeof(ScKinematicUpdateTask)), ScKinematicUpdateTask)
(kinematics + i, PxMin(ScKinematicUpdateTask::NbKinematicsPerTask, nbKinematics - i), mOneOverDt, mContextId);
task->setContinuation(continuation);
task->removeReference();
}
if((mPublicFlags & PxSceneFlag::eENABLE_GPU_DYNAMICS))
{
// PT: running this serially for now because it's unsafe: mNPhaseCore->updateDirtyInteractions() (called after this)
// can also call mSimulationController.updateDynamic() via BodySim::internalWakeUpBase
PxU32 nb = nbKinematics;
while(nb--)
{
Sc::BodyCore* b = *kinematics++;
Sc::BodySim* bodySim = b->getSim();
PX_ASSERT(!bodySim->getArticulation());
mSimulationController->updateDynamic(NULL, bodySim->getNodeIndex());
}
}
}
///////////////////////////////////////////////////////////////////////////////
// PT: TODO: consider using a non-member function for this one
void BodySim::updateKinematicPose()
{
/*------------------------------------------------\
| kinematic bodies are moved directly by the user and are not influenced by external forces
| we simply determine the distance moved since the last simulation frame and
| assign the appropriate delta to the velocity. This vel will be used to shove dynamic
| objects in the solver.
| We have to do this like so in a delayed way, because when the user sets the target pos the dt is not
| yet known.
\------------------------------------------------*/
PX_ASSERT(isKinematic());
PX_ASSERT(isActive());
if(readInternalFlag(BF_KINEMATIC_MOVED))
{
clearInternalFlag(InternalFlags(BF_KINEMATIC_SETTLING | BF_KINEMATIC_SETTLING_2));
const SimStateData* kData = getSimStateData(true);
PX_ASSERT(kData);
PX_ASSERT(kData->isKine());
PX_ASSERT(kData->getKinematicData()->targetValid);
const PxTransform targetPose = kData->getKinematicData()->targetPose;
getBodyCore().getCore().body2World = targetPose;
}
}
namespace
{
class ScKinematicPoseUpdateTask : public Cm::Task
{
Sc::BodyCore*const* mKinematics;
const PxU32 mNbKinematics;
PX_NOCOPY(ScKinematicPoseUpdateTask)
public:
static const PxU32 NbKinematicsPerTask = 1024;
ScKinematicPoseUpdateTask(Sc::BodyCore*const* kinematics, PxU32 nbKinematics, PxU64 contextID) :
Cm::Task(contextID), mKinematics(kinematics), mNbKinematics(nbKinematics)
{
}
virtual void runInternal()
{
const PxU32 nb = mNbKinematics;
for(PxU32 a=0; a<nb; ++a)
{
if ((a + 16) < nb)
{
PxPrefetchLine(static_cast<Sc::BodyCore* const>(mKinematics[a + 16]));
if ((a + 4) < nb)
{
PxPrefetchLine(static_cast<Sc::BodyCore* const>(mKinematics[a + 4])->getSim());
PxPrefetchLine(static_cast<Sc::BodyCore* const>(mKinematics[a + 4])->getSim()->getSimStateData_Unchecked());
}
}
Sc::BodyCore* b = static_cast<Sc::BodyCore* const>(mKinematics[a]);
PX_ASSERT(b->getSim()->isKinematic());
PX_ASSERT(b->getSim()->isActive());
b->getSim()->updateKinematicPose();
}
}
virtual const char* getName() const
{
return "ScScene.ScKinematicPoseUpdateTask";
}
};
}
void Sc::Scene::integrateKinematicPose()
{
PX_PROFILE_ZONE("Sim.integrateKinematicPose", mContextId);
const PxU32 nbKinematics = getActiveKinematicBodiesCount();
BodyCore*const* kinematics = getActiveKinematicBodies();
Cm::FlushPool& flushPool = mLLContext->getTaskPool();
// PT: TASK-CREATION TAG
for(PxU32 i=0; i<nbKinematics; i+= ScKinematicPoseUpdateTask::NbKinematicsPerTask)
{
ScKinematicPoseUpdateTask* task = PX_PLACEMENT_NEW(flushPool.allocate(sizeof(ScKinematicPoseUpdateTask)), ScKinematicPoseUpdateTask)
(kinematics + i, PxMin(nbKinematics - i, ScKinematicPoseUpdateTask::NbKinematicsPerTask), mContextId);
task->setContinuation(&mAfterIntegration);
task->removeReference();
}
}
///////////////////////////////////////////////////////////////////////////////
namespace
{
class ScKinematicShapeUpdateTask : public Cm::Task
{
Sc::BodyCore*const* mKinematics;
const PxU32 mNbKinematics;
PxsTransformCache& mCache;
Bp::BoundsArray& mBoundsArray;
PX_NOCOPY(ScKinematicShapeUpdateTask)
public:
static const PxU32 NbKinematicsShapesPerTask = 1024;
ScKinematicShapeUpdateTask(Sc::BodyCore*const* kinematics, PxU32 nbKinematics, PxsTransformCache& cache, Bp::BoundsArray& boundsArray, PxU64 contextID) :
Cm::Task(contextID), mKinematics(kinematics), mNbKinematics(nbKinematics), mCache(cache), mBoundsArray(boundsArray)
{
}
virtual void runInternal()
{
const PxU32 nb = mNbKinematics;
for(PxU32 a=0; a<nb; ++a)
{
Sc::BodyCore* b = static_cast<Sc::BodyCore*>(mKinematics[a]);
PX_ASSERT(b->getSim()->isKinematic());
PX_ASSERT(b->getSim()->isActive());
b->getSim()->updateCached(mCache, mBoundsArray);
}
}
virtual const char* getName() const
{
return "ScScene.KinematicShapeUpdateTask";
}
};
}
void Sc::Scene::updateKinematicCached(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Sim.updateKinematicCached", mContextId);
const PxU32 nbKinematics = getActiveKinematicBodiesCount();
if(!nbKinematics)
return;
BodyCore*const* kinematics = getActiveKinematicBodies();
Cm::FlushPool& flushPool = mLLContext->getTaskPool();
PxU32 startIndex = 0;
PxU32 nbShapes = 0;
{
PX_PROFILE_ZONE("ShapeUpdate", mContextId);
// PT: TASK-CREATION TAG
for(PxU32 i=0; i<nbKinematics; i++)
{
Sc::BodySim* sim = static_cast<Sc::BodyCore*>(kinematics[i])->getSim();
PX_ASSERT(sim->isKinematic());
PX_ASSERT(sim->isActive());
nbShapes += sim->getNbShapes();
if (nbShapes >= ScKinematicShapeUpdateTask::NbKinematicsShapesPerTask)
{
ScKinematicShapeUpdateTask* task = PX_PLACEMENT_NEW(flushPool.allocate(sizeof(ScKinematicShapeUpdateTask)), ScKinematicShapeUpdateTask)
(kinematics + startIndex, (i + 1) - startIndex, mLLContext->getTransformCache(), *mBoundsArray, mContextId);
task->setContinuation(continuation);
task->removeReference();
startIndex = i + 1;
nbShapes = 0;
}
}
if(nbShapes)
{
ScKinematicShapeUpdateTask* task = PX_PLACEMENT_NEW(flushPool.allocate(sizeof(ScKinematicShapeUpdateTask)), ScKinematicShapeUpdateTask)
(kinematics + startIndex, nbKinematics - startIndex, mLLContext->getTransformCache(), *mBoundsArray, mContextId);
task->setContinuation(continuation);
task->removeReference();
}
}
{
PxBitMapPinned& changedAABBMap = mAABBManager->getChangedAABBMgActorHandleMap();
mLLContext->getTransformCache().setChangedState();
mBoundsArray->setChangedState();
for (PxU32 i = 0; i < nbKinematics; ++i)
{
Sc::BodySim* bodySim = static_cast<Sc::BodyCore*>(kinematics[i])->getSim();
if ((i+16) < nbKinematics)
{
PxPrefetchLine(kinematics[i + 16]);
if ((i + 8) < nbKinematics)
{
PxPrefetchLine(kinematics[i + 8]->getSim());
}
}
// PT: ### changedMap pattern #1
PxU32 nbElems = bodySim->getNbElements();
Sc::ElementSim** elems = bodySim->getElements();
while (nbElems--)
{
Sc::ShapeSim* sim = static_cast<Sc::ShapeSim*>(*elems++);
//KS - TODO - can we parallelize this? The problem with parallelizing is that it's a bit operation,
//so we would either need to use atomic operations or have some high-level concept that guarantees
//that threads don't write to the same word in the map simultaneously
if (sim->getFlags()&PxU32(PxShapeFlag::eSIMULATION_SHAPE | PxShapeFlag::eTRIGGER_SHAPE))
changedAABBMap.set(sim->getElementID());
}
mSimulationController->updateDynamic(NULL, bodySim->getNodeIndex());
}
}
}
///////////////////////////////////////////////////////////////////////////////
// PT: TODO: consider using a non-member function for this one
bool BodySim::deactivateKinematic()
{
BodyCore& core = getBodyCore();
if(readInternalFlag(BF_KINEMATIC_SETTLING_2))
{
clearInternalFlag(BF_KINEMATIC_SETTLING_2);
core.setWakeCounterFromSim(0); // For sleeping objects the wake counter must be 0. This needs to hold for kinematics too.
notifyReadyForSleeping();
notifyPutToSleep();
setActive(false);
return true;
}
else if (readInternalFlag(BF_KINEMATIC_SETTLING))
{
clearInternalFlag(BF_KINEMATIC_SETTLING);
raiseInternalFlag(BF_KINEMATIC_SETTLING_2);
}
else if (!readInternalFlag(BF_KINEMATIC_SURFACE_VELOCITY))
{
clearInternalFlag(BF_KINEMATIC_MOVED);
raiseInternalFlag(BF_KINEMATIC_SETTLING);
}
return false;
}
// PT: called during fetchResults()
void Sc::Scene::postCallbacksPreSyncKinematics()
{
PX_PROFILE_ZONE("Sim.postCallbacksPreSyncKinematics", mContextId);
// Put/prepare kinematics to/for sleep and invalidate target pose
// note: this needs to get done after the contact callbacks because
// the target might get read there.
//
PxU32 nbKinematics = getActiveKinematicBodiesCount();
BodyCore*const* kinematics = getActiveKinematicBodies();
//KS - this method must run over the kinematic actors in reverse.
while(nbKinematics--)
{
if(nbKinematics > 16)
{
PxPrefetchLine(static_cast<BodyCore*>(kinematics[nbKinematics-16]));
}
if (nbKinematics > 4)
{
PxPrefetchLine((static_cast<BodyCore*>(kinematics[nbKinematics - 4]))->getSim());
PxPrefetchLine((static_cast<BodyCore*>(kinematics[nbKinematics - 4]))->getSim()->getSimStateData_Unchecked());
}
BodyCore* b = static_cast<BodyCore*>(kinematics[nbKinematics]);
//kinematics++;
PX_ASSERT(b->getSim()->isKinematic());
PX_ASSERT(b->getSim()->isActive());
b->invalidateKinematicTarget();
b->getSim()->deactivateKinematic();
}
}
| 15,400 | C++ | 31.698514 | 154 | 0.709545 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScScene.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScPhysics.h"
#include "ScScene.h"
#include "BpBroadPhase.h"
#include "ScConstraintSim.h"
#include "ScConstraintCore.h"
#include "ScArticulationJointCore.h"
#include "ScArticulationTendonCore.h"
#include "ScArticulationSensor.h"
#include "ScArticulationSim.h"
#include "ScArticulationJointSim.h"
#include "ScArticulationTendonSim.h"
#include "ScArticulationSensorSim.h"
#include "ScConstraintInteraction.h"
#include "ScTriggerInteraction.h"
#include "ScSimStats.h"
#include "PxvGlobals.h"
#include "PxsCCD.h"
#include "ScSimulationController.h"
#include "ScSqBoundsManager.h"
#if defined(__APPLE__) && defined(__POWERPC__)
#include <ppc_intrinsics.h>
#endif
#if PX_SUPPORT_GPU_PHYSX
#include "PxPhysXGpu.h"
#include "PxsKernelWrangler.h"
#include "PxsHeapMemoryAllocator.h"
#include "cudamanager/PxCudaContextManager.h"
#endif
#include "PxsMemoryManager.h"
#include "ScShapeInteraction.h"
#if PX_SUPPORT_GPU_PHYSX
#include "PxSoftBody.h"
#include "ScSoftBodySim.h"
#include "DySoftBody.h"
#if PX_ENABLE_FEATURES_UNDER_CONSTRUCTION
#include "PxFEMCloth.h"
#include "PxHairSystem.h"
#endif
#include "ScFEMClothSim.h"
#include "DyFEMCloth.h"
#include "ScParticleSystemSim.h"
#include "DyParticleSystem.h"
#include "ScHairSystemSim.h"
#include "DyHairSystem.h"
#endif
using namespace physx;
using namespace Cm;
using namespace Dy;
using namespace Sc;
PX_IMPLEMENT_OUTPUT_ERROR
namespace physx {
namespace Sc {
class LLArticulationRCPool : public PxPool<FeatherstoneArticulation, PxAlignedAllocator<64> >
{
public:
LLArticulationRCPool() {}
};
#if PX_SUPPORT_GPU_PHYSX
class LLSoftBodyPool : public PxPool<SoftBody, PxAlignedAllocator<64> >
{
public:
LLSoftBodyPool() {}
};
class LLFEMClothPool : public PxPool<FEMCloth, PxAlignedAllocator<64> >
{
public:
LLFEMClothPool() {}
};
class LLParticleSystemPool : public PxPool<ParticleSystem, PxAlignedAllocator<64> >
{
public:
LLParticleSystemPool() {}
};
class LLHairSystemPool : public PxPool<HairSystem, PxAlignedAllocator<64> >
{
public:
LLHairSystemPool() {}
};
#endif
static const char* sFilterShaderDataMemAllocId = "SceneDesc filterShaderData";
}}
void PxcDisplayContactCacheStats();
static const bool gUseNewTaskAllocationScheme = false;
namespace
{
class ScAfterIntegrationTask : public Cm::Task
{
public:
static const PxU32 MaxTasks = 256;
private:
const PxNodeIndex* const mIndices;
const PxU32 mNumBodies;
PxsContext* mContext;
Context* mDynamicsContext;
PxsTransformCache& mCache;
Sc::Scene& mScene;
public:
ScAfterIntegrationTask(const PxNodeIndex* const indices, PxU32 numBodies, PxsContext* context, Context* dynamicsContext, PxsTransformCache& cache, Sc::Scene& scene) :
Cm::Task (scene.getContextId()),
mIndices (indices),
mNumBodies (numBodies),
mContext (context),
mDynamicsContext(dynamicsContext),
mCache (cache),
mScene (scene)
{
}
virtual void runInternal()
{
const PxU32 rigidBodyOffset = Sc::BodySim::getRigidBodyOffset();
Sc::BodySim* bpUpdates[MaxTasks];
Sc::BodySim* ccdBodies[MaxTasks];
Sc::BodySim* activateBodies[MaxTasks];
Sc::BodySim* deactivateBodies[MaxTasks];
PxU32 nbBpUpdates = 0, nbCcdBodies = 0;
IG::SimpleIslandManager& manager = *mScene.getSimpleIslandManager();
const IG::IslandSim& islandSim = manager.getAccurateIslandSim();
Bp::BoundsArray& boundsArray = mScene.getBoundsArray();
Sc::BodySim* frozen[MaxTasks], * unfrozen[MaxTasks];
PxU32 nbFrozen = 0, nbUnfrozen = 0;
PxU32 nbActivated = 0, nbDeactivated = 0;
for(PxU32 i = 0; i < mNumBodies; i++)
{
PxsRigidBody* rigid = islandSim.getRigidBody(mIndices[i]);
Sc::BodySim* bodySim = reinterpret_cast<Sc::BodySim*>(reinterpret_cast<PxU8*>(rigid) - rigidBodyOffset);
//This move to PxgPostSolveWorkerTask for the gpu dynamic
//bodySim->sleepCheck(mDt, mOneOverDt, mEnableStabilization);
PxsBodyCore& bodyCore = bodySim->getBodyCore().getCore();
//If we got in this code, then this is an active object this frame. The solver computed the new wakeCounter and we
//commit it at this stage. We need to do it this way to avoid a race condition between the solver and the island gen, where
//the island gen may have deactivated a body while the solver decided to change its wake counter.
bodyCore.wakeCounter = bodyCore.solverWakeCounter;
PxsRigidBody& llBody = bodySim->getLowLevelBody();
const PxIntBool isFrozen = bodySim->isFrozen();
if(!isFrozen)
{
bpUpdates[nbBpUpdates++] = bodySim;
// PT: TODO: remove duplicate "isFrozen" test inside updateCached
// bodySim->updateCached(NULL);
bodySim->updateCached(mCache, boundsArray);
}
if(llBody.isFreezeThisFrame() && isFrozen)
frozen[nbFrozen++] = bodySim;
else if(llBody.isUnfreezeThisFrame())
unfrozen[nbUnfrozen++] = bodySim;
if(bodyCore.mFlags & PxRigidBodyFlag::eENABLE_CCD)
ccdBodies[nbCcdBodies++] = bodySim;
if(llBody.isActivateThisFrame())
{
PX_ASSERT(!llBody.isDeactivateThisFrame());
activateBodies[nbActivated++] = bodySim;
}
else if(llBody.isDeactivateThisFrame())
{
deactivateBodies[nbDeactivated++] = bodySim;
}
llBody.clearAllFrameFlags();
}
if(nbBpUpdates)
{
mCache.setChangedState();
boundsArray.setChangedState();
}
if(nbBpUpdates>0 || nbFrozen > 0 || nbCcdBodies>0 || nbActivated>0 || nbDeactivated>0)
{
//Write active bodies to changed actor map
mContext->getLock().lock();
PxBitMapPinned& changedAABBMgrHandles = mScene.getAABBManager()->getChangedAABBMgActorHandleMap();
for(PxU32 i = 0; i < nbBpUpdates; i++)
{
// PT: ### changedMap pattern #1
PxU32 nbElems = bpUpdates[i]->getNbElements();
Sc::ElementSim** elems = bpUpdates[i]->getElements();
while (nbElems--)
{
Sc::ShapeSim* sim = static_cast<Sc::ShapeSim*>(*elems++);
// PT: TODO: what's the difference between this test and "isInBroadphase" as used in bodySim->updateCached ?
// PT: Also, shouldn't it be "isInAABBManager" rather than BP ?
if (sim->getFlags()&PxU32(PxShapeFlag::eSIMULATION_SHAPE | PxShapeFlag::eTRIGGER_SHAPE)) // TODO: need trigger shape here?
changedAABBMgrHandles.growAndSet(sim->getElementID());
}
}
PxArray<Sc::BodySim*>& sceneCcdBodies = mScene.getCcdBodies();
for (PxU32 i = 0; i < nbCcdBodies; i++)
sceneCcdBodies.pushBack(ccdBodies[i]);
for(PxU32 i=0;i<nbFrozen;i++)
{
PX_ASSERT(frozen[i]->isFrozen());
frozen[i]->freezeTransforms(&changedAABBMgrHandles);
}
for(PxU32 i=0;i<nbUnfrozen;i++)
{
PX_ASSERT(!unfrozen[i]->isFrozen());
unfrozen[i]->createSqBounds();
}
for(PxU32 i = 0; i < nbActivated; ++i)
activateBodies[i]->notifyNotReadyForSleeping();
for(PxU32 i = 0; i < nbDeactivated; ++i)
deactivateBodies[i]->notifyReadyForSleeping();
mContext->getLock().unlock();
}
}
virtual const char* getName() const
{
return "ScScene.afterIntegrationTask";
}
private:
PX_NOCOPY(ScAfterIntegrationTask)
};
class ScSimulationControllerCallback : public PxsSimulationControllerCallback
{
Sc::Scene* mScene;
public:
ScSimulationControllerCallback(Sc::Scene* scene) : mScene(scene)
{
}
virtual void updateScBodyAndShapeSim(PxBaseTask* continuation)
{
PxsContext* contextLL = mScene->getLowLevelContext();
IG::SimpleIslandManager* islandManager = mScene->getSimpleIslandManager();
Dy::Context* dynamicContext = mScene->getDynamicsContext();
Cm::FlushPool& flushPool = contextLL->getTaskPool();
const PxU32 MaxBodiesPerTask = ScAfterIntegrationTask::MaxTasks;
PxsTransformCache& cache = contextLL->getTransformCache();
const IG::IslandSim& islandSim = islandManager->getAccurateIslandSim();
/*const*/ PxU32 numBodies = islandSim.getNbActiveNodes(IG::Node::eRIGID_BODY_TYPE);
const PxNodeIndex*const nodeIndices = islandSim.getActiveNodes(IG::Node::eRIGID_BODY_TYPE);
const PxU32 rigidBodyOffset = Sc::BodySim::getRigidBodyOffset();
// PT: TASK-CREATION TAG
if(!gUseNewTaskAllocationScheme)
{
PxU32 nbShapes = 0;
PxU32 startIdx = 0;
for (PxU32 i = 0; i < numBodies; i++)
{
if (nbShapes >= MaxBodiesPerTask)
{
ScAfterIntegrationTask* task = PX_PLACEMENT_NEW(flushPool.allocate(sizeof(ScAfterIntegrationTask)), ScAfterIntegrationTask(nodeIndices + startIdx, i - startIdx,
contextLL, dynamicContext, cache, *mScene));
startTask(task, continuation);
startIdx = i;
nbShapes = 0;
}
PxsRigidBody* rigid = islandSim.getRigidBody(nodeIndices[i]);
Sc::BodySim* bodySim = reinterpret_cast<Sc::BodySim*>(reinterpret_cast<PxU8*>(rigid) - rigidBodyOffset);
nbShapes += PxMax(1u, bodySim->getNbShapes()); //Always add at least 1 shape in, even if the body has zero shapes because there is still some per-body overhead
}
if (nbShapes)
{
ScAfterIntegrationTask* task = PX_PLACEMENT_NEW(flushPool.allocate(sizeof(ScAfterIntegrationTask)), ScAfterIntegrationTask(nodeIndices + startIdx, numBodies - startIdx,
contextLL, dynamicContext, cache, *mScene));
startTask(task, continuation);
}
}
else
{
// PT:
const PxU32 numCpuTasks = continuation->getTaskManager()->getCpuDispatcher()->getWorkerCount();
PxU32 nbPerTask;
if(numCpuTasks)
nbPerTask = numBodies > numCpuTasks ? numBodies / numCpuTasks : numBodies;
else
nbPerTask = numBodies;
// PT: we need to respect that limit even with a single thread, because of hardcoded buffer limits in ScAfterIntegrationTask.
if(nbPerTask>MaxBodiesPerTask)
nbPerTask = MaxBodiesPerTask;
PxU32 start = 0;
while(numBodies)
{
const PxU32 nb = numBodies < nbPerTask ? numBodies : nbPerTask;
ScAfterIntegrationTask* task = PX_PLACEMENT_NEW(flushPool.allocate(sizeof(ScAfterIntegrationTask)), ScAfterIntegrationTask(nodeIndices+start, nb,
contextLL, dynamicContext, cache, *mScene));
start += nb;
numBodies -= nb;
startTask(task, continuation);
}
}
}
virtual PxU32 getNbCcdBodies()
{
return mScene->getCcdBodies().size();
}
};
// PT: TODO: what is this Pxg class doing here?
class PxgUpdateBodyAndShapeStatusTask : public Cm::Task
{
public:
static const PxU32 MaxTasks = 2048;
private:
const PxNodeIndex* const mNodeIndices;
const PxU32 mNumBodies;
Sc::Scene& mScene;
void** mRigidBodyLL;
PxU32* mActivatedBodies;
PxU32* mDeactivatedBodies;
PxI32& mCCDBodyWriteIndex;
public:
PxgUpdateBodyAndShapeStatusTask(const PxNodeIndex* const indices, PxU32 numBodies, void** rigidBodyLL, PxU32* activatedBodies, PxU32* deactivatedBodies, Sc::Scene& scene, PxI32& ccdBodyWriteIndex) :
Cm::Task (scene.getContextId()),
mNodeIndices (indices),
mNumBodies (numBodies),
mScene (scene),
mRigidBodyLL (rigidBodyLL),
mActivatedBodies (activatedBodies),
mDeactivatedBodies (deactivatedBodies),
mCCDBodyWriteIndex (ccdBodyWriteIndex)
{
}
virtual void runInternal()
{
IG::SimpleIslandManager& islandManager = *mScene.getSimpleIslandManager();
const IG::IslandSim& islandSim = islandManager.getAccurateIslandSim();
PxU32 nbCcdBodies = 0;
PxArray<Sc::BodySim*>& sceneCcdBodies = mScene.getCcdBodies();
Sc::BodySim* ccdBodies[MaxTasks];
const size_t bodyOffset = PX_OFFSET_OF_RT(Sc::BodySim, getLowLevelBody());
for(PxU32 i=0; i<mNumBodies; ++i)
{
const PxU32 nodeIndex = mNodeIndices[i].index();
PxsRigidBody* rigidLL = reinterpret_cast<PxsRigidBody*>(mRigidBodyLL[nodeIndex]);
PxsBodyCore* bodyCore = &rigidLL->getCore();
bodyCore->wakeCounter = bodyCore->solverWakeCounter;
//we can set the frozen/unfrozen flag in GPU, but we have copied the internalflags
//from the solverbodysleepdata to pxsbodycore, so we just need to clear the frozen flag in here
rigidLL->clearAllFrameFlags();
PX_ASSERT(mActivatedBodies[nodeIndex] <= 1);
PX_ASSERT(mDeactivatedBodies[nodeIndex] <= 1);
if(mActivatedBodies[nodeIndex])
{
PX_ASSERT(bodyCore->wakeCounter > 0.0f);
islandManager.activateNode(mNodeIndices[i]);
}
else if(mDeactivatedBodies[nodeIndex])
{
//KS - the CPU code can reset the wake counter due to lost touches in parallel with the solver, so we need to verify
//that the wakeCounter is still 0 before deactivating the node
if (bodyCore->wakeCounter == 0.0f)
{
islandManager.deactivateNode(mNodeIndices[i]);
}
}
if (bodyCore->mFlags & PxRigidBodyFlag::eENABLE_CCD)
{
PxsRigidBody* rigidBody = islandSim.getRigidBody(mNodeIndices[i]);
Sc::BodySim* bodySim = reinterpret_cast<Sc::BodySim*>(reinterpret_cast<PxU8*>(rigidBody) - bodyOffset);
ccdBodies[nbCcdBodies++] = bodySim;
}
}
if(nbCcdBodies > 0)
{
PxI32 startIndex = PxAtomicAdd(&mCCDBodyWriteIndex, PxI32(nbCcdBodies)) - PxI32(nbCcdBodies);
for(PxU32 a = 0; a < nbCcdBodies; ++a)
{
sceneCcdBodies[startIndex + a] = ccdBodies[a];
}
}
}
virtual const char* getName() const
{
return "ScScene.PxgUpdateBodyAndShapeStatusTask";
}
private:
PX_NOCOPY(PxgUpdateBodyAndShapeStatusTask)
};
#if PX_SUPPORT_GPU_PHYSX
// PT: TODO: what is this Pxg class doing here?
class PxgSimulationControllerCallback : public PxsSimulationControllerCallback
{
Sc::Scene* mScene;
PxI32 mCcdBodyWriteIndex;
public:
PxgSimulationControllerCallback(Sc::Scene* scene) : mScene(scene), mCcdBodyWriteIndex(0)
{
}
virtual void updateScBodyAndShapeSim(PxBaseTask* continuation)
{
IG::SimpleIslandManager* islandManager = mScene->getSimpleIslandManager();
PxsSimulationController* simulationController = mScene->getSimulationController();
PxsContext* contextLL = mScene->getLowLevelContext();
IG::IslandSim& islandSim = islandManager->getAccurateIslandSim();
const PxU32 numBodies = islandSim.getNbActiveNodes(IG::Node::eRIGID_BODY_TYPE);
const PxNodeIndex*const nodeIndices = islandSim.getActiveNodes(IG::Node::eRIGID_BODY_TYPE);
PxU32* activatedBodies = simulationController->getActiveBodies();
PxU32* deactivatedBodies = simulationController->getDeactiveBodies();
//PxsRigidBody** rigidBodyLL = simulationController->getRigidBodies();
void** rigidBodyLL = simulationController->getRigidBodies();
Cm::FlushPool& flushPool = contextLL->getTaskPool();
PxArray<Sc::BodySim*>& ccdBodies = mScene->getCcdBodies();
ccdBodies.forceSize_Unsafe(0);
ccdBodies.reserve(numBodies);
ccdBodies.forceSize_Unsafe(numBodies);
mCcdBodyWriteIndex = 0;
// PT: TASK-CREATION TAG
for(PxU32 i = 0; i < numBodies; i+=PxgUpdateBodyAndShapeStatusTask::MaxTasks)
{
PxgUpdateBodyAndShapeStatusTask* task = PX_PLACEMENT_NEW(flushPool.allocate(sizeof(PxgUpdateBodyAndShapeStatusTask)), PxgUpdateBodyAndShapeStatusTask(nodeIndices + i,
PxMin(PxgUpdateBodyAndShapeStatusTask::MaxTasks, numBodies - i), rigidBodyLL, activatedBodies, deactivatedBodies, *mScene, mCcdBodyWriteIndex));
task->setContinuation(continuation);
task->removeReference();
}
PxU32* unfrozenShapeIndices = simulationController->getUnfrozenShapes();
PxU32* frozenShapeIndices = simulationController->getFrozenShapes();
const PxU32 nbFrozenShapes = simulationController->getNbFrozenShapes();
const PxU32 nbUnfrozenShapes = simulationController->getNbUnfrozenShapes();
PxsShapeSim** shapeSimsLL = simulationController->getShapeSims();
const size_t shapeOffset = PX_OFFSET_OF_RT(Sc::ShapeSim, getLLShapeSim());
for(PxU32 i=0; i<nbFrozenShapes; ++i)
{
const PxU32 shapeIndex = frozenShapeIndices[i];
PxsShapeSim* shapeLL = shapeSimsLL[shapeIndex];
Sc::ShapeSim* shape = reinterpret_cast<Sc::ShapeSim*>(reinterpret_cast<PxU8*>(shapeLL) - shapeOffset);
shape->destroySqBounds();
}
for(PxU32 i=0; i<nbUnfrozenShapes; ++i)
{
const PxU32 shapeIndex = unfrozenShapeIndices[i];
PxsShapeSim* shapeLL = shapeSimsLL[shapeIndex];
Sc::ShapeSim* shape = reinterpret_cast<Sc::ShapeSim*>(reinterpret_cast<PxU8*>(shapeLL) - shapeOffset);
shape->createSqBounds();
}
if (simulationController->hasFEMCloth())
{
//KS - technically, there's a race condition calling activateNode/deactivateNode, but we know that it is
//safe because these deactivate/activate calls came from the solver. This means that we know that the
//actors are active currently, so at most we are just clearing/setting the ready for sleeping flag.
//None of the more complex logic that touching shared state will be executed.
const PxU32 nbActivatedCloth = simulationController->getNbActivatedFEMCloth();
Dy::FEMCloth** activatedCloths = simulationController->getActivatedFEMCloths();
for (PxU32 i = 0; i < nbActivatedCloth; ++i)
{
PxNodeIndex nodeIndex = activatedCloths[i]->getFEMClothSim()->getNodeIndex();
islandManager->activateNode(nodeIndex);
}
const PxU32 nbDeactivatedCloth = simulationController->getNbDeactivatedFEMCloth();
Dy::FEMCloth** deactivatedCloths = simulationController->getDeactivatedFEMCloths();
for (PxU32 i = 0; i < nbDeactivatedCloth; ++i)
{
PxNodeIndex nodeIndex = deactivatedCloths[i]->getFEMClothSim()->getNodeIndex();
islandManager->deactivateNode(nodeIndex);
}
}
if (simulationController->hasSoftBodies())
{
//KS - technically, there's a race condition calling activateNode/deactivateNode, but we know that it is
//safe because these deactivate/activate calls came from the solver. This means that we know that the
//actors are active currently, so at most we are just clearing/setting the ready for sleeping flag.
//None of the more complex logic that touching shared state will be executed.
const PxU32 nbDeactivatedSB = simulationController->getNbDeactivatedSoftbodies();
Dy::SoftBody** deactivatedSB = simulationController->getDeactivatedSoftbodies();
for (PxU32 i = 0; i < nbDeactivatedSB; ++i)
{
PxNodeIndex nodeIndex = deactivatedSB[i]->getSoftBodySim()->getNodeIndex();
islandManager->deactivateNode(nodeIndex);
}
const PxU32 nbActivatedSB = simulationController->getNbActivatedSoftbodies();
Dy::SoftBody** activatedSB = simulationController->getActivatedSoftbodies();
for (PxU32 i = 0; i < nbActivatedSB; ++i)
{
PxNodeIndex nodeIndex = activatedSB[i]->getSoftBodySim()->getNodeIndex();
islandManager->activateNode(nodeIndex);
}
}
if (simulationController->hasHairSystems())
{
// comment from KS regarding race condition applies here, too
const PxU32 nbDeactivatedHS = simulationController->getNbDeactivatedHairSystems();
Dy::HairSystem** deactivatedHS = simulationController->getDeactivatedHairSystems();
for (PxU32 i = 0; i < nbDeactivatedHS; ++i)
{
PxNodeIndex nodeIndex = deactivatedHS[i]->getHairSystemSim()->getNodeIndex();
islandManager->deactivateNode(nodeIndex);
}
const PxU32 nbActivatedHS = simulationController->getNbActivatedHairSystems();
Dy::HairSystem** activatedHS = simulationController->getActivatedHairSystems();
for (PxU32 i = 0; i < nbActivatedHS; ++i)
{
PxNodeIndex nodeIndex = activatedHS[i]->getHairSystemSim()->getNodeIndex();
islandManager->activateNode(nodeIndex);
}
}
}
virtual PxU32 getNbCcdBodies()
{
return PxU32(mCcdBodyWriteIndex);
}
};
#endif
}
static Bp::AABBManagerBase* createAABBManagerCPU(const PxSceneDesc& desc, Bp::BroadPhase* broadPhase, Bp::BoundsArray* boundsArray, PxFloatArrayPinned* contactDistances, PxVirtualAllocator& allocator, PxU64 contextID)
{
return PX_NEW(Bp::AABBManager)(*broadPhase, *boundsArray, *contactDistances,
desc.limits.maxNbAggregates, desc.limits.maxNbStaticShapes + desc.limits.maxNbDynamicShapes, allocator, contextID,
desc.kineKineFilteringMode, desc.staticKineFilteringMode);
}
#if PX_SUPPORT_GPU_PHYSX
static Bp::AABBManagerBase* createAABBManagerGPU(PxsKernelWranglerManager* kernelWrangler, PxCudaContextManager* cudaContextManager, PxsHeapMemoryAllocatorManager* heapMemoryAllocationManager,
const PxSceneDesc& desc, Bp::BroadPhase* broadPhase, Bp::BoundsArray* boundsArray, PxFloatArrayPinned* contactDistances, PxVirtualAllocator& allocator, PxU64 contextID)
{
return PxvGetPhysXGpu(true)->createGpuAABBManager(
kernelWrangler,
cudaContextManager,
desc.gpuComputeVersion,
desc.gpuDynamicsConfig,
heapMemoryAllocationManager,
*broadPhase, *boundsArray, *contactDistances,
desc.limits.maxNbAggregates, desc.limits.maxNbStaticShapes + desc.limits.maxNbDynamicShapes, allocator, contextID,
desc.kineKineFilteringMode, desc.staticKineFilteringMode);
}
#endif
Sc::Scene::Scene(const PxSceneDesc& desc, PxU64 contextID) :
mContextId (contextID),
mActiveBodies ("sceneActiveBodies"),
mActiveKinematicBodyCount (0),
mActiveDynamicBodyCount (0),
mActiveKinematicsCopy (NULL),
mActiveKinematicsCopyCapacity (0),
mPointerBlock8Pool ("scenePointerBlock8Pool"),
mPointerBlock16Pool ("scenePointerBlock16Pool"),
mPointerBlock32Pool ("scenePointerBlock32Pool"),
mLLContext (NULL),
mAABBManager (NULL),
mCCDContext (NULL),
mNumFastMovingShapes (0),
mCCDPass (0),
mSimpleIslandManager (NULL),
mDynamicsContext (NULL),
mMemoryManager (NULL),
#if PX_SUPPORT_GPU_PHYSX
mGpuWranglerManagers (NULL),
mHeapMemoryAllocationManager (NULL),
#endif
mSimulationController (NULL),
mSimulationControllerCallback (NULL),
mGravity (PxVec3(0.0f)),
mDt (0),
mOneOverDt (0),
mTimeStamp (1), // PT: has to start to 1 to fix determinism bug. I don't know why yet but it works.
mReportShapePairTimeStamp (0),
mTriggerBufferAPI ("sceneTriggerBufferAPI"),
mArticulations ("sceneArticulations"),
mBrokenConstraints ("sceneBrokenConstraints"),
mActiveBreakableConstraints ("sceneActiveBreakableConstraints"),
mMemBlock128Pool ("PxsContext ConstraintBlock128Pool"),
mMemBlock256Pool ("PxsContext ConstraintBlock256Pool"),
mMemBlock384Pool ("PxsContext ConstraintBlock384Pool"),
mNPhaseCore (NULL),
mKineKineFilteringMode (desc.kineKineFilteringMode),
mStaticKineFilteringMode (desc.staticKineFilteringMode),
mSleepBodies ("sceneSleepBodies"),
mWokeBodies ("sceneWokeBodies"),
mEnableStabilization (desc.flags & PxSceneFlag::eENABLE_STABILIZATION),
mActiveActors ("clientActiveActors"),
mFrozenActors ("clientFrozenActors"),
mClientPosePreviewBodies ("clientPosePreviewBodies"),
mClientPosePreviewBuffer ("clientPosePreviewBuffer"),
mSimulationEventCallback (NULL),
mInternalFlags (SceneInternalFlag::eSCENE_DEFAULT),
mPublicFlags (desc.flags),
mAnchorCore (PxTransform(PxIdentity)),
mStaticAnchor (NULL),
mBatchRemoveState (NULL),
mLostTouchPairs ("sceneLostTouchPairs"),
mVisualizationParameterChanged (false),
mMaxNbArticulationLinks (0),
mNbRigidStatics (0),
mNbRigidDynamics (0),
mNbRigidKinematic (0),
mSecondPassNarrowPhase (contextID, this, "ScScene.secondPassNarrowPhase"),
mPostNarrowPhase (contextID, this, "ScScene.postNarrowPhase"),
mFinalizationPhase (contextID, this, "ScScene.finalizationPhase"),
mUpdateCCDMultiPass (contextID, this, "ScScene.updateCCDMultiPass"),
mAfterIntegration (contextID, this, "ScScene.afterIntegration"),
mPostSolver (contextID, this, "ScScene.postSolver"),
mSolver (contextID, this, "ScScene.rigidBodySolver"),
mUpdateBodies (contextID, this, "ScScene.updateBodies"),
mUpdateShapes (contextID, this, "ScScene.updateShapes"),
mUpdateSimulationController (contextID, this, "ScScene.updateSimulationController"),
mUpdateDynamics (contextID, this, "ScScene.updateDynamics"),
mProcessLostContactsTask (contextID, this, "ScScene.processLostContact"),
mProcessLostContactsTask2 (contextID, this, "ScScene.processLostContact2"),
mProcessLostContactsTask3 (contextID, this, "ScScene.processLostContact3"),
mDestroyManagersTask (contextID, this, "ScScene.destroyManagers"),
mLostTouchReportsTask (contextID, this, "ScScene.lostTouchReports"),
mUnregisterInteractionsTask (contextID, this, "ScScene.unregisterInteractions"),
mProcessNarrowPhaseLostTouchTasks(contextID, this, "ScScene.processNpLostTouchTask"),
mProcessNPLostTouchEvents (contextID, this, "ScScene.processNPLostTouchEvents"),
mPostThirdPassIslandGenTask (contextID, this, "ScScene.postThirdPassIslandGenTask"),
mPostIslandGen (contextID, this, "ScScene.postIslandGen"),
mIslandGen (contextID, this, "ScScene.islandGen"),
mPreRigidBodyNarrowPhase (contextID, this, "ScScene.preRigidBodyNarrowPhase"),
mSetEdgesConnectedTask (contextID, this, "ScScene.setEdgesConnectedTask"),
mProcessLostPatchesTask (contextID, this, "ScScene.processLostSolverPatchesTask"),
mProcessFoundPatchesTask (contextID, this, "ScScene.processFoundSolverPatchesTask"),
mUpdateBoundAndShapeTask (contextID, this, "ScScene.updateBoundsAndShapesTask"),
mRigidBodyNarrowPhase (contextID, this, "ScScene.rigidBodyNarrowPhase"),
mRigidBodyNPhaseUnlock (contextID, this, "ScScene.unblockNarrowPhase"),
mPostBroadPhase (contextID, this, "ScScene.postBroadPhase"),
mPostBroadPhaseCont (contextID, this, "ScScene.postBroadPhaseCont"),
mPostBroadPhase2 (contextID, this, "ScScene.postBroadPhase2"),
mPostBroadPhase3 (contextID, this, "ScScene.postBroadPhase3"),
mPreallocateContactManagers (contextID, this, "ScScene.preallocateContactManagers"),
mIslandInsertion (contextID, this, "ScScene.islandInsertion"),
mRegisterContactManagers (contextID, this, "ScScene.registerContactManagers"),
mRegisterInteractions (contextID, this, "ScScene.registerInteractions"),
mRegisterSceneInteractions (contextID, this, "ScScene.registerSceneInteractions"),
mBroadPhase (contextID, this, "ScScene.broadPhase"),
mAdvanceStep (contextID, this, "ScScene.advanceStep"),
mCollideStep (contextID, this, "ScScene.collideStep"),
mBpFirstPass (contextID, this, "ScScene.broadPhaseFirstPass"),
mBpSecondPass (contextID, this, "ScScene.broadPhaseSecondPass"),
mBpUpdate (contextID, this, "ScScene.updateBroadPhase"),
mPreIntegrate (contextID, this, "ScScene.preIntegrate"),
mTaskPool (16384),
mTaskManager (NULL),
mCudaContextManager (desc.cudaContextManager),
mContactReportsNeedPostSolverVelocity(false),
mUseGpuDynamics(false),
mUseGpuBp (false),
mCCDBp (false),
mSimulationStage (SimulationStage::eCOMPLETE),
mPosePreviewBodies ("scenePosePreviewBodies"),
mOverlapFilterTaskHead (NULL),
mIsCollisionPhaseActive (false),
mIsDirectGPUAPIInitialized (false),
mOnSleepingStateChanged (NULL)
#if PX_SUPPORT_GPU_PHYSX
,mSoftBodies ("sceneSoftBodies"),
mFEMCloths ("sceneFEMCloths"),
mParticleSystems ("sceneParticleSystems"),
mHairSystems ("sceneHairSystems")
#endif
{
#if PX_SUPPORT_GPU_PHYSX
mLLSoftBodyPool = PX_NEW(LLSoftBodyPool);
mLLFEMClothPool = PX_NEW(LLFEMClothPool);
mLLParticleSystemPool = PX_NEW(LLParticleSystemPool);
mLLHairSystemPool = PX_NEW(LLHairSystemPool);
mWokeSoftBodyListValid = true;
mSleepSoftBodyListValid = true;
mWokeHairSystemListValid = true;
mSleepHairSystemListValid = true;
#endif
for(PxU32 type = 0; type < InteractionType::eTRACKED_IN_SCENE_COUNT; ++type)
mInteractions[type].reserve(64);
for (int i=0; i < InteractionType::eTRACKED_IN_SCENE_COUNT; ++i)
mActiveInteractionCount[i] = 0;
mStats = PX_NEW(SimStats);
mConstraintIDTracker = PX_NEW(ObjectIDTracker);
mActorIDTracker = PX_NEW(ObjectIDTracker);
mElementIDPool = PX_NEW(ObjectIDTracker);
mTriggerBufferExtraData = reinterpret_cast<TriggerBufferExtraData*>(PX_ALLOC(sizeof(TriggerBufferExtraData), "ScScene::TriggerBufferExtraData"));
PX_PLACEMENT_NEW(mTriggerBufferExtraData, TriggerBufferExtraData("ScScene::TriggerPairExtraData"));
mStaticSimPool = PX_NEW(PreallocatingPool<StaticSim>)(64, "StaticSim");
mBodySimPool = PX_NEW(PreallocatingPool<BodySim>)(64, "BodySim");
mShapeSimPool = PX_NEW(PreallocatingPool<ShapeSim>)(64, "ShapeSim");
mConstraintSimPool = PX_NEW(PxPool<ConstraintSim>)("ScScene::ConstraintSim");
mConstraintInteractionPool = PX_NEW(PxPool<ConstraintInteraction>)("ScScene::ConstraintInteraction");
mLLArticulationRCPool = PX_NEW(LLArticulationRCPool);
mSimStateDataPool = PX_NEW(PxPool<SimStateData>)("ScScene::SimStateData");
mSqBoundsManager = PX_NEW(SqBoundsManager);
mTaskManager = physx::PxTaskManager::createTaskManager(*PxGetErrorCallback(), desc.cpuDispatcher);
for(PxU32 i=0; i<PxGeometryType::eGEOMETRY_COUNT; i++)
mNbGeometries[i] = 0;
bool useGpuDynamics = false;
bool useGpuBroadphase = false;
#if PX_SUPPORT_GPU_PHYSX
if(desc.flags & PxSceneFlag::eENABLE_GPU_DYNAMICS)
{
if(!mCudaContextManager)
outputError<PxErrorCode::eDEBUG_WARNING>(__LINE__, "GPU solver pipeline failed, switching to software");
else if(mCudaContextManager->supportsArchSM30())
useGpuDynamics = true;
}
if(desc.broadPhaseType == PxBroadPhaseType::eGPU)
{
if(!mCudaContextManager)
outputError<PxErrorCode::eDEBUG_WARNING>(__LINE__, "GPU Bp pipeline failed, switching to software");
else if(mCudaContextManager->supportsArchSM30())
useGpuBroadphase = true;
}
#endif
mUseGpuDynamics = useGpuDynamics;
mUseGpuBp = useGpuBroadphase;
mLLContext = PX_NEW(PxsContext)(desc, mTaskManager, mTaskPool, mCudaContextManager, desc.contactPairSlabSize, contextID);
if (mLLContext == 0)
{
outputError<PxErrorCode::eINVALID_PARAMETER>(__LINE__, "Failed to create context!");
return;
}
mLLContext->setMaterialManager(&getMaterialManager());
#if PX_SUPPORT_GPU_PHYSX
if (useGpuBroadphase || useGpuDynamics)
{
PxPhysXGpu* physxGpu = PxvGetPhysXGpu(true);
// PT: this creates a PxgMemoryManager, whose host memory allocator is a PxgCudaHostMemoryAllocatorCallback
mMemoryManager = physxGpu->createGpuMemoryManager(mLLContext->getCudaContextManager());
mGpuWranglerManagers = physxGpu->getGpuKernelWranglerManager(mLLContext->getCudaContextManager());
// PT: this creates a PxgHeapMemoryAllocatorManager
mHeapMemoryAllocationManager = physxGpu->createGpuHeapMemoryAllocatorManager(desc.gpuDynamicsConfig.heapCapacity, mMemoryManager, desc.gpuComputeVersion);
}
else
#endif
{
// PT: this creates a PxsDefaultMemoryManager
mMemoryManager = createDefaultMemoryManager();
}
Bp::BroadPhase* broadPhase = NULL;
//Note: broadphase should be independent of AABBManager. MBP uses it to call getBPBounds but it has
//already been passed all bounds in BroadPhase::update() so should use that instead.
// PT: above comment is obsolete: MBP now doesn't call getBPBounds anymore (except in commented out code)
// and it is instead the GPU broadphase which is not independent from the GPU AABB manager.......
if(!useGpuBroadphase)
{
PxBroadPhaseType::Enum broadPhaseType = desc.broadPhaseType;
if (broadPhaseType == PxBroadPhaseType::eGPU)
broadPhaseType = PxBroadPhaseType::eABP;
broadPhase = Bp::BroadPhase::create(
broadPhaseType,
desc.limits.maxNbRegions,
desc.limits.maxNbBroadPhaseOverlaps,
desc.limits.maxNbStaticShapes,
desc.limits.maxNbDynamicShapes,
contextID);
}
#if PX_SUPPORT_GPU_PHYSX
else
{
broadPhase = PxvGetPhysXGpu(true)->createGpuBroadPhase( mGpuWranglerManagers, mLLContext->getCudaContextManager(),
desc.gpuComputeVersion, desc.gpuDynamicsConfig,
mHeapMemoryAllocationManager, contextID);
}
#endif
//create allocator
PxVirtualAllocatorCallback* allocatorCallback = mMemoryManager->getHostMemoryAllocator();
PxVirtualAllocator allocator(allocatorCallback);
mBoundsArray = PX_NEW(Bp::BoundsArray)(allocator);
mContactDistance = PX_PLACEMENT_NEW(PX_ALLOC(sizeof(PxFloatArrayPinned), "ContactDistance"), PxFloatArrayPinned)(allocator);
mHasContactDistanceChanged = false;
const bool useEnhancedDeterminism = mPublicFlags & PxSceneFlag::eENABLE_ENHANCED_DETERMINISM;
mSimpleIslandManager = PX_NEW(IG::SimpleIslandManager)(useEnhancedDeterminism, contextID);
PxvNphaseImplementationContextUsableAsFallback* cpuNphaseImplementation = createNphaseImplementationContext(*mLLContext, &mSimpleIslandManager->getAccurateIslandSim(), allocatorCallback, useGpuDynamics);
if (!useGpuDynamics)
{
if (desc.solverType == PxSolverType::ePGS)
{
mDynamicsContext = createDynamicsContext
(&mLLContext->getNpMemBlockPool(), mLLContext->getScratchAllocator(),
mLLContext->getTaskPool(), mLLContext->getSimStats(), &mLLContext->getTaskManager(), allocatorCallback, &getMaterialManager(),
mSimpleIslandManager, contextID, mEnableStabilization, useEnhancedDeterminism, desc.maxBiasCoefficient,
!!(desc.flags & PxSceneFlag::eENABLE_FRICTION_EVERY_ITERATION), desc.getTolerancesScale().length);
}
else
{
mDynamicsContext = createTGSDynamicsContext
(&mLLContext->getNpMemBlockPool(), mLLContext->getScratchAllocator(),
mLLContext->getTaskPool(), mLLContext->getSimStats(), &mLLContext->getTaskManager(), allocatorCallback, &getMaterialManager(),
mSimpleIslandManager, contextID, mEnableStabilization, useEnhancedDeterminism,
desc.getTolerancesScale().length);
}
mLLContext->setNphaseImplementationContext(cpuNphaseImplementation);
mSimulationControllerCallback = PX_NEW(ScSimulationControllerCallback)(this);
mSimulationController = PX_NEW(SimulationController)(mSimulationControllerCallback);
if (!useGpuBroadphase)
mAABBManager = createAABBManagerCPU(desc, broadPhase, mBoundsArray, mContactDistance, allocator, contextID);
#if PX_SUPPORT_GPU_PHYSX
else
mAABBManager = createAABBManagerGPU(mGpuWranglerManagers, mLLContext->getCudaContextManager(), mHeapMemoryAllocationManager, desc, broadPhase, mBoundsArray, mContactDistance, allocator, contextID);
#endif
}
else
{
#if PX_SUPPORT_GPU_PHYSX
bool directAPI = mPublicFlags & PxSceneFlag::eENABLE_DIRECT_GPU_API;
mDynamicsContext = PxvGetPhysXGpu(true)->createGpuDynamicsContext(mLLContext->getTaskPool(), mGpuWranglerManagers, mLLContext->getCudaContextManager(),
desc.gpuDynamicsConfig, mSimpleIslandManager, desc.gpuMaxNumPartitions, desc.gpuMaxNumStaticPartitions, mEnableStabilization, useEnhancedDeterminism, desc.maxBiasCoefficient, desc.gpuComputeVersion, mLLContext->getSimStats(),
mHeapMemoryAllocationManager, !!(desc.flags & PxSceneFlag::eENABLE_FRICTION_EVERY_ITERATION), desc.solverType, desc.getTolerancesScale().length, directAPI);
void* contactStreamBase = NULL;
void* patchStreamBase = NULL;
void* forceAndIndiceStreamBase = NULL;
mDynamicsContext->getDataStreamBase(contactStreamBase, patchStreamBase, forceAndIndiceStreamBase);
mLLContext->setNphaseFallbackImplementationContext(cpuNphaseImplementation);
PxvNphaseImplementationContext* gpuNphaseImplementation = PxvGetPhysXGpu(true)->createGpuNphaseImplementationContext(*mLLContext, mGpuWranglerManagers, cpuNphaseImplementation, desc.gpuDynamicsConfig, contactStreamBase, patchStreamBase,
forceAndIndiceStreamBase, getBoundsArray().getBounds(), &mSimpleIslandManager->getAccurateIslandSim(), mDynamicsContext, desc.gpuComputeVersion, mHeapMemoryAllocationManager, useGpuBroadphase);
mSimulationControllerCallback = PX_NEW(PxgSimulationControllerCallback)(this);
mSimulationController = PxvGetPhysXGpu(true)->createGpuSimulationController(mGpuWranglerManagers, mLLContext->getCudaContextManager(),
mDynamicsContext, gpuNphaseImplementation, broadPhase, useGpuBroadphase, mSimpleIslandManager, mSimulationControllerCallback, desc.gpuComputeVersion, mHeapMemoryAllocationManager,
desc.gpuDynamicsConfig.maxSoftBodyContacts, desc.gpuDynamicsConfig.maxFemClothContacts, desc.gpuDynamicsConfig.maxParticleContacts, desc.gpuDynamicsConfig.maxHairContacts);
mSimulationController->setBounds(mBoundsArray);
mDynamicsContext->setSimulationController(mSimulationController);
mLLContext->setNphaseImplementationContext(gpuNphaseImplementation);
mLLContext->mContactStreamPool = &mDynamicsContext->getContactStreamPool();
mLLContext->mPatchStreamPool = &mDynamicsContext->getPatchStreamPool();
mLLContext->mForceAndIndiceStreamPool = &mDynamicsContext->getForceStreamPool();
// PT: TODO: what's the difference between this allocator and "allocator" above?
PxVirtualAllocator tAllocator(mHeapMemoryAllocationManager->mMappedMemoryAllocators, PxsHeapStats::eBROADPHASE);
if (!useGpuBroadphase)
// PT: TODO: we're using a CUDA allocator in the CPU broadphase, and a different allocator for the bounds array?
mAABBManager = createAABBManagerCPU(desc, broadPhase, mBoundsArray, mContactDistance, tAllocator, contextID);
else
mAABBManager = createAABBManagerGPU(mGpuWranglerManagers, mLLContext->getCudaContextManager(), mHeapMemoryAllocationManager, desc, broadPhase, mBoundsArray, mContactDistance, tAllocator, contextID);
#endif
}
//Construct the bitmap of updated actors required as input to the broadphase update
if(desc.limits.maxNbBodies)
{
// PT: TODO: revisit this. Why do we handle the added/removed and updated bitmaps entirely differently, in different places? And what is this weird formula here?
mAABBManager->getChangedAABBMgActorHandleMap().resize((2*desc.limits.maxNbBodies + 256) & ~255);
}
//mLLContext->createTransformCache(mDynamicsContext->getAllocatorCallback());
mLLContext->createTransformCache(*allocatorCallback);
mLLContext->setContactDistance(mContactDistance);
mCCDContext = PX_NEW(PxsCCDContext)(mLLContext, mDynamicsContext->getThresholdStream(), *mLLContext->getNphaseImplementationContext(), desc.ccdThreshold);
setSolverBatchSize(desc.solverBatchSize);
setSolverArticBatchSize(desc.solverArticulationBatchSize);
mDynamicsContext->setFrictionOffsetThreshold(desc.frictionOffsetThreshold);
mDynamicsContext->setCCDSeparationThreshold(desc.ccdMaxSeparation);
mDynamicsContext->setCorrelationDistance(desc.frictionCorrelationDistance);
const PxTolerancesScale& scale = Physics::getInstance().getTolerancesScale();
mLLContext->setMeshContactMargin(0.01f * scale.length);
mLLContext->setToleranceLength(scale.length);
// the original descriptor uses
// bounce iff impact velocity > threshold
// but LL use
// bounce iff separation velocity < -threshold
// hence we negate here.
mDynamicsContext->setBounceThreshold(-desc.bounceThresholdVelocity);
mStaticAnchor = mStaticSimPool->construct(*this, mAnchorCore);
mNPhaseCore = PX_NEW(NPhaseCore)(*this, desc);
// Init dominance matrix
{
//init all dominance pairs such that:
//if g1 == g2, then (1.0f, 1.0f) is returned
//if g1 < g2, then (0.0f, 1.0f) is returned
//if g1 > g2, then (1.0f, 0.0f) is returned
PxU32 mask = ~PxU32(1);
for (unsigned i = 0; i < PX_MAX_DOMINANCE_GROUP; ++i, mask <<= 1)
mDominanceBitMatrix[i] = ~mask;
}
// DeterminismDebugger::begin();
mWokeBodyListValid = true;
mSleepBodyListValid = true;
//load from desc:
setLimits(desc.limits);
// Create broad phase
mBroadphaseManager.setBroadPhaseCallback(desc.broadPhaseCallback);
setGravity(desc.gravity);
setFrictionType(desc.frictionType);
setPCM(desc.flags & PxSceneFlag::eENABLE_PCM);
setContactCache(!(desc.flags & PxSceneFlag::eDISABLE_CONTACT_CACHE));
setSimulationEventCallback(desc.simulationEventCallback);
setContactModifyCallback(desc.contactModifyCallback);
setCCDContactModifyCallback(desc.ccdContactModifyCallback);
setCCDMaxPasses(desc.ccdMaxPasses);
PX_ASSERT(mNPhaseCore); // refactor paranoia
PX_ASSERT( ((desc.filterShaderData) && (desc.filterShaderDataSize > 0)) ||
(!(desc.filterShaderData) && (desc.filterShaderDataSize == 0)) );
if (desc.filterShaderData)
{
mFilterShaderData = PX_ALLOC(desc.filterShaderDataSize, sFilterShaderDataMemAllocId);
PxMemCopy(mFilterShaderData, desc.filterShaderData, desc.filterShaderDataSize);
mFilterShaderDataSize = desc.filterShaderDataSize;
mFilterShaderDataCapacity = desc.filterShaderDataSize;
}
else
{
mFilterShaderData = NULL;
mFilterShaderDataSize = 0;
mFilterShaderDataCapacity = 0;
}
mFilterShader = desc.filterShader;
mFilterCallback = desc.filterCallback;
}
void Sc::Scene::release()
{
// TODO: PT: check virtual stuff
mTimeStamp++;
//collisionSpace.purgeAllPairs();
//purgePairs();
//releaseTagData();
// We know release all the shapes before the collision space
//collisionSpace.deleteAllShapes();
//collisionSpace.release();
//DeterminismDebugger::end();
PX_FREE(mActiveKinematicsCopy);
PX_DELETE(mNPhaseCore);
PX_FREE(mFilterShaderData);
if(mStaticAnchor)
mStaticSimPool->destroy(mStaticAnchor);
// Free object IDs and the deleted object id map
postReportsCleanup();
//before the task manager
if (mLLContext)
{
if(mLLContext->getNphaseFallbackImplementationContext())
{
mLLContext->getNphaseFallbackImplementationContext()->destroy();
mLLContext->setNphaseFallbackImplementationContext(NULL);
}
if(mLLContext->getNphaseImplementationContext())
{
mLLContext->getNphaseImplementationContext()->destroy();
mLLContext->setNphaseImplementationContext(NULL);
}
}
PX_DELETE(mSqBoundsManager);
PX_DELETE(mBoundsArray);
PX_DELETE(mConstraintInteractionPool);
PX_DELETE(mConstraintSimPool);
PX_DELETE(mSimStateDataPool);
PX_DELETE(mStaticSimPool);
PX_DELETE(mShapeSimPool);
PX_DELETE(mBodySimPool);
PX_DELETE(mLLArticulationRCPool);
#if PX_SUPPORT_GPU_PHYSX
gpu_releasePools();
#endif
mTriggerBufferExtraData->~TriggerBufferExtraData();
PX_FREE(mTriggerBufferExtraData);
PX_DELETE(mElementIDPool);
PX_DELETE(mActorIDTracker);
PX_DELETE(mConstraintIDTracker);
PX_DELETE(mStats);
Bp::BroadPhase* broadPhase = mAABBManager->getBroadPhase();
mAABBManager->destroy();
PX_RELEASE(broadPhase);
PX_DELETE(mSimulationControllerCallback);
PX_DELETE(mSimulationController);
mDynamicsContext->destroy();
PX_DELETE(mCCDContext);
PX_DELETE(mSimpleIslandManager);
#if PX_SUPPORT_GPU_PHYSX
gpu_release();
#endif
PX_RELEASE(mTaskManager);
PX_DELETE(mLLContext);
mContactDistance->~PxArray();
PX_FREE(mContactDistance);
PX_DELETE(mMemoryManager);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Sc::Scene::preAllocate(PxU32 nbStatics, PxU32 nbBodies, PxU32 nbStaticShapes, PxU32 nbDynamicShapes)
{
// PT: TODO: this is only used for my addActors benchmark for now. Pre-allocate more arrays here.
mActiveBodies.reserve(PxMax<PxU32>(64,nbBodies));
mStaticSimPool->preAllocate(nbStatics);
mBodySimPool->preAllocate(nbBodies);
mShapeSimPool->preAllocate(nbStaticShapes + nbDynamicShapes);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Sc::Scene::addDirtyArticulationSim(Sc::ArticulationSim* artiSim)
{
artiSim->setDirtyFlag(ArticulationSimDirtyFlag::eUPDATE);
mDirtyArticulationSims.insert(artiSim);
}
void Sc::Scene::removeDirtyArticulationSim(Sc::ArticulationSim* artiSim)
{
artiSim->setDirtyFlag(ArticulationSimDirtyFlag::eNONE);
mDirtyArticulationSims.erase(artiSim);
}
void Sc::Scene::addToActiveList(ActorSim& actorSim)
{
PX_ASSERT(actorSim.getActiveListIndex() >= SC_NOT_IN_ACTIVE_LIST_INDEX);
ActorCore* appendedActorCore = &actorSim.getActorCore();
if (actorSim.isDynamicRigid())
{
// Sort: kinematic before dynamic
const PxU32 size = mActiveBodies.size();
PxU32 incomingBodyActiveListIndex = size; // PT: by default we append the incoming body at the end of the current array.
BodySim& bodySim = static_cast<BodySim&>(actorSim);
if (bodySim.isKinematic()) // PT: Except if incoming body is kinematic, in which case:
{
const PxU32 nbKinematics = mActiveKinematicBodyCount++; // PT: - we increase their number
if (nbKinematics != size) // PT: - if there's at least one dynamic in the array...
{
PX_ASSERT(appendedActorCore != mActiveBodies[nbKinematics]);
appendedActorCore = mActiveBodies[nbKinematics]; // PT: ...then we grab the first dynamic after the kinematics...
appendedActorCore->getSim()->setActiveListIndex(size); // PT: ...and we move that one back to the end of the array...
mActiveBodies[nbKinematics] = static_cast<BodyCore*>(&actorSim.getActorCore()); // PT: ...while the incoming kine replaces the dynamic we moved out.
incomingBodyActiveListIndex = nbKinematics; // PT: ...thus the incoming kine's index is the prev #kines.
}
}
// for active compound rigids add to separate array, so we dont have to traverse all active actors
if (bodySim.readInternalFlag(BodySim::BF_IS_COMPOUND_RIGID))
{
PX_ASSERT(actorSim.getActiveCompoundListIndex() >= SC_NOT_IN_ACTIVE_LIST_INDEX);
const PxU32 compoundIndex = mActiveCompoundBodies.size();
mActiveCompoundBodies.pushBack(static_cast<BodyCore*>(appendedActorCore));
actorSim.setActiveCompoundListIndex(compoundIndex);
}
actorSim.setActiveListIndex(incomingBodyActiveListIndex); // PT: will be 'size' or 'nbKinematics', 'dynamicIndex'
mActiveBodies.pushBack(static_cast<BodyCore*>(appendedActorCore)); // PT: will be the incoming object or the first dynamic we moved out.
}
#if PX_SUPPORT_GPU_PHYSX
else
gpu_addToActiveList(actorSim, appendedActorCore);
#endif
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static void removeFromActiveCompoundBodyList(Sc::ActorSim& actorSim, PxArray<Sc::BodyCore*>& activeCompoundBodies)
{
const PxU32 removedCompoundIndex = actorSim.getActiveCompoundListIndex();
PX_ASSERT(removedCompoundIndex < SC_NOT_IN_ACTIVE_LIST_INDEX);
actorSim.setActiveCompoundListIndex(SC_NOT_IN_ACTIVE_LIST_INDEX);
const PxU32 newCompoundSize = activeCompoundBodies.size() - 1;
if(removedCompoundIndex != newCompoundSize)
{
Sc::BodyCore* lastBody = activeCompoundBodies[newCompoundSize];
activeCompoundBodies[removedCompoundIndex] = lastBody;
lastBody->getSim()->setActiveCompoundListIndex(removedCompoundIndex);
}
activeCompoundBodies.forceSize_Unsafe(newCompoundSize);
}
void Sc::Scene::removeFromActiveCompoundBodyList(BodySim& body)
{
::removeFromActiveCompoundBodyList(body, mActiveCompoundBodies);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Sc::Scene::removeFromActiveList(ActorSim& actorSim)
{
PxU32 removedActiveIndex = actorSim.getActiveListIndex();
PX_ASSERT(removedActiveIndex < SC_NOT_IN_ACTIVE_LIST_INDEX);
actorSim.setActiveListIndex(SC_NOT_IN_ACTIVE_LIST_INDEX);
if (actorSim.isDynamicRigid())
{
PX_ASSERT(mActiveBodies[removedActiveIndex] == &actorSim.getActorCore());
const PxU32 newSize = mActiveBodies.size() - 1;
BodySim& bodySim = static_cast<BodySim&>(actorSim);
// Sort: kinematic before dynamic,
if (removedActiveIndex < mActiveKinematicBodyCount) // PT: same as 'body.isKinematic()' but without accessing the Core data
{
PX_ASSERT(mActiveKinematicBodyCount);
PX_ASSERT(bodySim.isKinematic());
const PxU32 swapIndex = --mActiveKinematicBodyCount;
if (newSize != swapIndex // PT: equal if the array only contains kinematics
&& removedActiveIndex < swapIndex) // PT: i.e. "if we don't remove the last kinematic"
{
BodyCore* swapBody = mActiveBodies[swapIndex];
swapBody->getSim()->setActiveListIndex(removedActiveIndex);
mActiveBodies[removedActiveIndex] = swapBody;
removedActiveIndex = swapIndex;
}
}
// for active compound rigids add to separate array, so we dont have to traverse all active actors
// A.B. TODO we should handle kinematic switch, no need to hold kinematic rigids in compound list
if(bodySim.readInternalFlag(BodySim::BF_IS_COMPOUND_RIGID))
::removeFromActiveCompoundBodyList(actorSim, mActiveCompoundBodies);
if (removedActiveIndex != newSize)
{
Sc::BodyCore* lastBody = mActiveBodies[newSize];
mActiveBodies[removedActiveIndex] = lastBody;
lastBody->getSim()->setActiveListIndex(removedActiveIndex);
}
mActiveBodies.forceSize_Unsafe(newSize);
}
#if PX_SUPPORT_GPU_PHYSX
else
gpu_removeFromActiveList(actorSim, removedActiveIndex);
#endif
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Sc::Scene::swapInActiveBodyList(BodySim& body)
{
PX_ASSERT(!body.isStaticRigid() && !body.isSoftBody() && !body.isFEMCloth() && !body.isParticleSystem() && !body.isHairSystem());
const PxU32 activeListIndex = body.getActiveListIndex();
PX_ASSERT(activeListIndex < SC_NOT_IN_ACTIVE_LIST_INDEX);
PxU32 swapIndex;
PxU32 newActiveKinematicBodyCount;
if(activeListIndex < mActiveKinematicBodyCount)
{
// kinematic -> dynamic
PX_ASSERT(!body.isKinematic()); // the corresponding flag gets switched before this call
PX_ASSERT(mActiveKinematicBodyCount > 0); // there has to be at least one kinematic body
swapIndex = mActiveKinematicBodyCount - 1;
newActiveKinematicBodyCount = swapIndex;
}
else
{
// dynamic -> kinematic
PX_ASSERT(body.isKinematic()); // the corresponding flag gets switched before this call
PX_ASSERT(mActiveKinematicBodyCount < mActiveBodies.size()); // there has to be at least one dynamic body
swapIndex = mActiveKinematicBodyCount;
newActiveKinematicBodyCount = swapIndex + 1;
}
BodyCore*& swapBodyRef = mActiveBodies[swapIndex];
body.setActiveListIndex(swapIndex);
BodyCore* swapBody = swapBodyRef;
swapBodyRef = &body.getBodyCore();
swapBody->getSim()->setActiveListIndex(activeListIndex);
mActiveBodies[activeListIndex] = swapBody;
mActiveKinematicBodyCount = newActiveKinematicBodyCount;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Sc::Scene::registerInteraction(ElementSimInteraction* interaction, bool active)
{
const InteractionType::Enum type = interaction->getType();
const PxU32 sceneArrayIndex = mInteractions[type].size();
interaction->setInteractionId(sceneArrayIndex);
mInteractions[type].pushBack(interaction);
if (active)
{
if (sceneArrayIndex > mActiveInteractionCount[type])
swapInteractionArrayIndices(sceneArrayIndex, mActiveInteractionCount[type], type);
mActiveInteractionCount[type]++;
}
mNPhaseCore->registerInteraction(interaction);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Sc::Scene::unregisterInteraction(ElementSimInteraction* interaction)
{
const InteractionType::Enum type = interaction->getType();
const PxU32 sceneArrayIndex = interaction->getInteractionId();
PX_ASSERT(sceneArrayIndex != PX_INVALID_INTERACTION_SCENE_ID);
// if(sceneArrayIndex==PX_INVALID_INTERACTION_SCENE_ID)
// return;
mInteractions[type].replaceWithLast(sceneArrayIndex);
interaction->setInteractionId(PX_INVALID_INTERACTION_SCENE_ID);
if (sceneArrayIndex<mInteractions[type].size()) // The removed interaction was the last one, do not reset its sceneArrayIndex
mInteractions[type][sceneArrayIndex]->setInteractionId(sceneArrayIndex);
if (sceneArrayIndex<mActiveInteractionCount[type])
{
mActiveInteractionCount[type]--;
if (mActiveInteractionCount[type]<mInteractions[type].size())
swapInteractionArrayIndices(sceneArrayIndex, mActiveInteractionCount[type], type);
}
mNPhaseCore->unregisterInteraction(interaction);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Sc::Scene::swapInteractionArrayIndices(PxU32 id1, PxU32 id2, InteractionType::Enum type)
{
PxArray<ElementSimInteraction*>& interArray = mInteractions[type];
ElementSimInteraction* interaction1 = interArray[id1];
ElementSimInteraction* interaction2 = interArray[id2];
interArray[id1] = interaction2;
interArray[id2] = interaction1;
interaction1->setInteractionId(id2);
interaction2->setInteractionId(id1);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Sc::Scene::notifyInteractionActivated(Interaction* interaction)
{
PX_ASSERT((interaction->getType() == InteractionType::eOVERLAP) || (interaction->getType() == InteractionType::eTRIGGER));
PX_ASSERT(interaction->readInteractionFlag(InteractionFlag::eIS_ACTIVE));
PX_ASSERT(interaction->getInteractionId() != PX_INVALID_INTERACTION_SCENE_ID);
const InteractionType::Enum type = interaction->getType();
PX_ASSERT(interaction->getInteractionId() >= mActiveInteractionCount[type]);
if (mActiveInteractionCount[type] < mInteractions[type].size())
swapInteractionArrayIndices(mActiveInteractionCount[type], interaction->getInteractionId(), type);
mActiveInteractionCount[type]++;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Sc::Scene::notifyInteractionDeactivated(Interaction* interaction)
{
PX_ASSERT((interaction->getType() == InteractionType::eOVERLAP) || (interaction->getType() == InteractionType::eTRIGGER));
PX_ASSERT(!interaction->readInteractionFlag(InteractionFlag::eIS_ACTIVE));
PX_ASSERT(interaction->getInteractionId() != PX_INVALID_INTERACTION_SCENE_ID);
const InteractionType::Enum type = interaction->getType();
PX_ASSERT(interaction->getInteractionId() < mActiveInteractionCount[type]);
if (mActiveInteractionCount[type] > 1)
swapInteractionArrayIndices(mActiveInteractionCount[type]-1, interaction->getInteractionId(), type);
mActiveInteractionCount[type]--;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void** Sc::Scene::allocatePointerBlock(PxU32 size)
{
PX_ASSERT(size>32 || size == 32 || size == 16 || size == 8);
void* ptr;
if(size==8)
ptr = mPointerBlock8Pool.construct();
else if(size == 16)
ptr = mPointerBlock16Pool.construct();
else if(size == 32)
ptr = mPointerBlock32Pool.construct();
else
ptr = PX_ALLOC(size * sizeof(void*), "void*");
return reinterpret_cast<void**>(ptr);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Sc::Scene::deallocatePointerBlock(void** block, PxU32 size)
{
PX_ASSERT(size>32 || size == 32 || size == 16 || size == 8);
if(size==8)
mPointerBlock8Pool.destroy(reinterpret_cast<PointerBlock8*>(block));
else if(size == 16)
mPointerBlock16Pool.destroy(reinterpret_cast<PointerBlock16*>(block));
else if(size == 32)
mPointerBlock32Pool.destroy(reinterpret_cast<PointerBlock32*>(block));
else
PX_FREE(block);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Sc::Scene::setFilterShaderData(const void* data, PxU32 dataSize)
{
PX_UNUSED(sFilterShaderDataMemAllocId);
if (data)
{
PX_ASSERT(dataSize > 0);
void* buffer;
if (dataSize <= mFilterShaderDataCapacity)
buffer = mFilterShaderData;
else
{
buffer = PX_ALLOC(dataSize, sFilterShaderDataMemAllocId);
if (buffer)
{
mFilterShaderDataCapacity = dataSize;
PX_FREE(mFilterShaderData);
}
else
{
outputError<PxErrorCode::eOUT_OF_MEMORY>(__LINE__, "Failed to allocate memory for filter shader data!");
return;
}
}
PxMemCopy(buffer, data, dataSize);
mFilterShaderData = buffer;
mFilterShaderDataSize = dataSize;
}
else
{
PX_ASSERT(dataSize == 0);
PX_FREE(mFilterShaderData);
mFilterShaderDataSize = 0;
mFilterShaderDataCapacity = 0;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//stepSetup is called in solve, but not collide
void Sc::Scene::stepSetupSolve(PxBaseTask* continuation)
{
PX_PROFILE_ZONE("Sim.stepSetupSolve", mContextId);
kinematicsSetup(continuation);
}
void Sc::Scene::advance(PxReal timeStep, PxBaseTask* continuation)
{
if(timeStep != 0.0f)
{
setElapsedTime(timeStep);
mAdvanceStep.setContinuation(continuation);
stepSetupSolve(&mAdvanceStep);
mAdvanceStep.removeReference();
}
}
void Sc::Scene::collide(PxReal timeStep, PxBaseTask* continuation)
{
mDt = timeStep;
stepSetupCollide(continuation);
mLLContext->beginUpdate();
mCollideStep.setContinuation(continuation);
mCollideStep.removeReference();
}
void Sc::Scene::endSimulation()
{
// Handle user contact filtering
// Note: Do this before the contact callbacks get fired since the filter callback might
// trigger contact reports (touch lost due to re-filtering)
mBroadphaseManager.prepareOutOfBoundsCallbacks(mAABBManager);
PxsContactManagerOutputIterator outputs = mLLContext->getNphaseImplementationContext()->getContactManagerOutputs();
mNPhaseCore->fireCustomFilteringCallbacks(outputs);
mNPhaseCore->preparePersistentContactEventListForNextFrame();
mSimulationController->releaseDeferredArticulationIds();
#if PX_SUPPORT_GPU_PHYSX
mSimulationController->releaseDeferredSoftBodyIds();
mSimulationController->releaseDeferredFEMClothIds();
mSimulationController->releaseDeferredParticleSystemIds();
mSimulationController->releaseDeferredHairSystemIds();
mAABBManager->releaseDeferredAggregateIds();
#endif
// End step / update time stamps
{
mTimeStamp++;
// INVALID_SLEEP_COUNTER is 0xffffffff. Therefore the last bit is masked. Look at Body::isForcedToSleep() for example.
// if(timeStamp==PX_INVALID_U32) timeStamp = 0; // Reserve INVALID_ID for something else
mTimeStamp &= 0x7fffffff;
mReportShapePairTimeStamp++; // to make sure that deleted shapes/actors after fetchResults() create new report pairs
}
PxcDisplayContactCacheStats();
}
void Sc::Scene::flush(bool sendPendingReports)
{
if (sendPendingReports)
{
fireQueuedContactCallbacks();
mNPhaseCore->clearContactReportStream();
mNPhaseCore->clearContactReportActorPairs(true);
fireTriggerCallbacks();
}
else
{
mNPhaseCore->clearContactReportActorPairs(true); // To clear the actor pair set
}
postReportsCleanup();
mNPhaseCore->freeContactReportStreamMemory();
mTriggerBufferAPI.reset();
mTriggerBufferExtraData->reset();
mBrokenConstraints.reset();
mBroadphaseManager.flush(mAABBManager);
clearSleepWakeBodies(); //!!! If we send out these reports on flush then this would not be necessary
mActorIDTracker->reset();
mElementIDPool->reset();
processLostTouchPairs(); // Processes the lost touch bodies
PX_ASSERT(mLostTouchPairs.size() == 0);
mLostTouchPairs.reset();
// Does not seem worth deleting the bitmap for the lost touch pair list
mActiveBodies.shrink();
for(PxU32 i=0; i < InteractionType::eTRACKED_IN_SCENE_COUNT; i++)
{
mInteractions[i].shrink();
}
//!!! TODO: look into retrieving memory from the NPhaseCore & Broadphase class (all the pools in there etc.)
mLLContext->getNpMemBlockPool().releaseUnusedBlocks();
}
// User callbacks
void Sc::Scene::setSimulationEventCallback(PxSimulationEventCallback* callback)
{
if(!mSimulationEventCallback && callback)
{
// if there was no callback before, the sleeping bodies have to be prepared for potential notification events (no shortcut possible anymore)
BodyCore* const* sleepingBodies = mSleepBodies.getEntries();
for (PxU32 i = 0; i < mSleepBodies.size(); i++)
{
sleepingBodies[i]->getSim()->raiseInternalFlag(BodySim::BF_SLEEP_NOTIFY);
}
#if PX_SUPPORT_GPU_PHYSX
gpu_setSimulationEventCallback(callback);
#endif
}
mSimulationEventCallback = callback;
}
PxSimulationEventCallback* Sc::Scene::getSimulationEventCallback() const
{
return mSimulationEventCallback;
}
void Sc::Scene::removeBody(BodySim& body) //this also notifies any connected joints!
{
BodyCore& core = body.getBodyCore();
// Remove from sleepBodies array
mSleepBodies.erase(&core);
PX_ASSERT(!mSleepBodies.contains(&core));
// Remove from wokeBodies array
mWokeBodies.erase(&core);
PX_ASSERT(!mWokeBodies.contains(&core));
if (body.isActive() && (core.getFlags() & PxRigidBodyFlag::eENABLE_POSE_INTEGRATION_PREVIEW))
removeFromPosePreviewList(body);
else
PX_ASSERT(!isInPosePreviewList(body));
markReleasedBodyIDForLostTouch(body.getActorID());
}
void Sc::Scene::addConstraint(ConstraintCore& constraint, RigidCore* body0, RigidCore* body1)
{
ConstraintSim* sim = mConstraintSimPool->construct(constraint, body0, body1, *this);
PX_UNUSED(sim);
PxNodeIndex nodeIndex0, nodeIndex1;
ActorSim* sim0 = NULL;
ActorSim* sim1 = NULL;
if (body0)
{
sim0 = body0->getSim();
nodeIndex0 = sim0->getNodeIndex();
}
if (body1)
{
sim1 = body1->getSim();
nodeIndex1 = sim1->getNodeIndex();
}
if (nodeIndex1 < nodeIndex0)
PxSwap(sim0, sim1);
mConstraintMap.insert(PxPair<const Sc::ActorSim*, const Sc::ActorSim*>(sim0, sim1), &constraint);
mConstraints.insert(&constraint);
}
void Sc::Scene::removeConstraint(ConstraintCore& constraint)
{
ConstraintSim* cSim = constraint.getSim();
if (cSim)
{
{
PxNodeIndex nodeIndex0, nodeIndex1;
const ConstraintInteraction* interaction = cSim->getInteraction();
Sc::ActorSim* bSim = &interaction->getActorSim0();
Sc::ActorSim* bSim1 = &interaction->getActorSim1();
if (bSim)
nodeIndex0 = bSim->getNodeIndex();
if (bSim1)
nodeIndex1 = bSim1->getNodeIndex();
if (nodeIndex1 < nodeIndex0)
PxSwap(bSim, bSim1);
mConstraintMap.erase(PxPair<const Sc::ActorSim*, const Sc::ActorSim*>(bSim, bSim1));
}
mConstraintSimPool->destroy(cSim);
}
mConstraints.erase(&constraint);
}
void Sc::Scene::addArticulation(ArticulationCore& articulation, BodyCore& root)
{
ArticulationSim* sim = PX_NEW(ArticulationSim)(articulation, *this, root);
if (sim && (sim->getLowLevelArticulation() == NULL))
{
PX_DELETE(sim);
return;
}
mArticulations.insert(&articulation);
addDirtyArticulationSim(sim);
}
void Sc::Scene::removeArticulation(ArticulationCore& articulation)
{
ArticulationSim* a = articulation.getSim();
Sc::ArticulationSimDirtyFlags dirtyFlags = a->getDirtyFlag();
const bool isDirty = (dirtyFlags & Sc::ArticulationSimDirtyFlag::eUPDATE);
if(isDirty)
removeDirtyArticulationSim(a);
PX_DELETE(a);
mArticulations.erase(&articulation);
}
void Sc::Scene::addArticulationJoint(ArticulationJointCore& joint, BodyCore& parent, BodyCore& child)
{
ArticulationJointSim* sim = PX_NEW(ArticulationJointSim)(joint, *parent.getSim(), *child.getSim());
PX_UNUSED(sim);
}
void Sc::Scene::removeArticulationJoint(ArticulationJointCore& joint)
{
ArticulationJointSim* sim = joint.getSim();
PX_DELETE(sim);
}
void Sc::Scene::addArticulationTendon(ArticulationSpatialTendonCore& tendon)
{
ArticulationSpatialTendonSim* sim = PX_NEW(ArticulationSpatialTendonSim)(tendon, *this);
PX_UNUSED(sim);
}
void Sc::Scene::removeArticulationTendon(ArticulationSpatialTendonCore& tendon)
{
ArticulationSpatialTendonSim* sim = tendon.getSim();
PX_DELETE(sim);
}
void Sc::Scene::addArticulationTendon(ArticulationFixedTendonCore& tendon)
{
ArticulationFixedTendonSim* sim = PX_NEW(ArticulationFixedTendonSim)(tendon, *this);
PX_UNUSED(sim);
}
void Sc::Scene::removeArticulationTendon(ArticulationFixedTendonCore& tendon)
{
ArticulationFixedTendonSim* sim = tendon.getSim();
PX_DELETE(sim);
}
void Sc::Scene::addArticulationSensor(ArticulationSensorCore& sensor)
{
ArticulationSensorSim* sim = PX_NEW(ArticulationSensorSim)(sensor, *this);
PX_UNUSED(sim);
}
void Sc::Scene::removeArticulationSensor(ArticulationSensorCore& sensor)
{
ArticulationSensorSim* sim = sensor.getSim();
PX_DELETE(sim);
}
void Sc::Scene::addArticulationSimControl(Sc::ArticulationCore& core)
{
Sc::ArticulationSim* sim = core.getSim();
if (sim)
mSimulationController->addArticulation(sim->getLowLevelArticulation(), sim->getIslandNodeIndex());
}
void Sc::Scene::removeArticulationSimControl(Sc::ArticulationCore& core)
{
Sc::ArticulationSim* sim = core.getSim();
if (sim)
mSimulationController->releaseArticulation(sim->getLowLevelArticulation(), sim->getIslandNodeIndex());
}
void* Sc::Scene::allocateConstraintBlock(PxU32 size)
{
if(size<=128)
return mMemBlock128Pool.construct();
else if(size<=256)
return mMemBlock256Pool.construct();
else if(size<=384)
return mMemBlock384Pool.construct();
else
return PX_ALLOC(size, "ConstraintBlock");
}
void Sc::Scene::deallocateConstraintBlock(void* ptr, PxU32 size)
{
if(size<=128)
mMemBlock128Pool.destroy(reinterpret_cast<MemBlock128*>(ptr));
else if(size<=256)
mMemBlock256Pool.destroy(reinterpret_cast<MemBlock256*>(ptr));
else if(size<=384)
mMemBlock384Pool.destroy(reinterpret_cast<MemBlock384*>(ptr));
else
PX_FREE(ptr);
}
void Sc::Scene::postReportsCleanup()
{
mElementIDPool->processPendingReleases();
mElementIDPool->clearDeletedIDMap();
mActorIDTracker->processPendingReleases();
mActorIDTracker->clearDeletedIDMap();
mConstraintIDTracker->processPendingReleases();
mConstraintIDTracker->clearDeletedIDMap();
mSimulationController->flush();
}
PX_COMPILE_TIME_ASSERT(sizeof(PxTransform32)==sizeof(PxsCachedTransform));
// PT: TODO: move this out of Sc? this is only called by Np
void Sc::Scene::syncSceneQueryBounds(SqBoundsSync& sync, SqRefFinder& finder)
{
const PxsTransformCache& cache = mLLContext->getTransformCache();
mSqBoundsManager->syncBounds(sync, finder, mBoundsArray->begin(), reinterpret_cast<const PxTransform32*>(cache.getTransforms()), mContextId, mDirtyShapeSimMap);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Sc::Scene::resizeReleasedBodyIDMaps(PxU32 maxActors, PxU32 numActors)
{
mLostTouchPairsDeletedBodyIDs.resize(maxActors);
mActorIDTracker->resizeDeletedIDMap(maxActors,numActors);
mElementIDPool->resizeDeletedIDMap(maxActors,numActors);
}
void Sc::Scene::finalizeContactStreamAndCreateHeader(PxContactPairHeader& header, const ActorPairReport& aPair, ContactStreamManager& cs, PxU32 removedShapeTestMask)
{
PxU8* stream = mNPhaseCore->getContactReportPairData(cs.bufferIndex);
PxU32 streamManagerFlag = cs.getFlags();
ContactShapePair* contactPairs = cs.getShapePairs(stream);
const PxU16 nbShapePairs = cs.currentPairCount;
PX_ASSERT(nbShapePairs > 0);
if (streamManagerFlag & removedShapeTestMask)
{
// At least one shape of this actor pair has been deleted. Need to traverse the contact buffer,
// find the pairs which contain deleted shapes and set the flags accordingly.
ContactStreamManager::convertDeletedShapesInContactStream(contactPairs, nbShapePairs, getElementIDPool());
}
PX_ASSERT(contactPairs);
ObjectIDTracker& ActorIDTracker = getActorIDTracker();
header.actors[0] = aPair.getPxActorA();
header.actors[1] = aPair.getPxActorB();
PxU16 headerFlags = 0;
if (ActorIDTracker.isDeletedID(aPair.getActorAID()))
headerFlags |= PxContactPairHeaderFlag::eREMOVED_ACTOR_0;
if (ActorIDTracker.isDeletedID(aPair.getActorBID()))
headerFlags |= PxContactPairHeaderFlag::eREMOVED_ACTOR_1;
header.flags = PxContactPairHeaderFlags(headerFlags);
header.pairs = reinterpret_cast<PxContactPair*>(contactPairs);
header.nbPairs = nbShapePairs;
PxU16 extraDataSize = cs.extraDataSize;
if (!extraDataSize)
header.extraDataStream = NULL;
else
{
PX_ASSERT(extraDataSize >= sizeof(ContactStreamHeader));
extraDataSize -= sizeof(ContactStreamHeader);
header.extraDataStream = stream + sizeof(ContactStreamHeader);
if (streamManagerFlag & ContactStreamManagerFlag::eNEEDS_POST_SOLVER_VELOCITY)
{
PX_ASSERT(!(headerFlags & PxTo16(PxContactPairHeaderFlag::eREMOVED_ACTOR_0 | PxContactPairHeaderFlag::eREMOVED_ACTOR_1)));
cs.setContactReportPostSolverVelocity(stream, aPair.getActorA(), aPair.getActorB());
}
}
header.extraDataStreamSize = extraDataSize;
}
const PxArray<PxContactPairHeader>& Sc::Scene::getQueuedContactPairHeaders()
{
const PxU32 removedShapeTestMask = PxU32(ContactStreamManagerFlag::eTEST_FOR_REMOVED_SHAPES);
ActorPairReport*const* actorPairs = mNPhaseCore->getContactReportActorPairs();
PxU32 nbActorPairs = mNPhaseCore->getNbContactReportActorPairs();
mQueuedContactPairHeaders.reserve(nbActorPairs);
mQueuedContactPairHeaders.clear();
for (PxU32 i = 0; i < nbActorPairs; i++)
{
if (i < (nbActorPairs - 1))
PxPrefetchLine(actorPairs[i + 1]);
ActorPairReport* aPair = actorPairs[i];
ContactStreamManager& cs = aPair->getContactStreamManager();
if (cs.getFlags() & ContactStreamManagerFlag::eINVALID_STREAM)
continue;
if (i + 1 < nbActorPairs)
PxPrefetch(&(actorPairs[i + 1]->getContactStreamManager()));
PxContactPairHeader &pairHeader = mQueuedContactPairHeaders.insert();
finalizeContactStreamAndCreateHeader(pairHeader, *aPair, cs, removedShapeTestMask);
cs.maxPairCount = cs.currentPairCount;
cs.setMaxExtraDataSize(cs.extraDataSize);
}
return mQueuedContactPairHeaders;
}
/*
Threading: called in the context of the user thread, but only after the physics thread has finished its run
*/
void Sc::Scene::fireQueuedContactCallbacks()
{
if(mSimulationEventCallback)
{
const PxU32 removedShapeTestMask = PxU32(ContactStreamManagerFlag::eTEST_FOR_REMOVED_SHAPES);
ActorPairReport*const* actorPairs = mNPhaseCore->getContactReportActorPairs();
PxU32 nbActorPairs = mNPhaseCore->getNbContactReportActorPairs();
for(PxU32 i=0; i < nbActorPairs; i++)
{
if (i < (nbActorPairs - 1))
PxPrefetchLine(actorPairs[i+1]);
ActorPairReport* aPair = actorPairs[i];
ContactStreamManager* cs = &aPair->getContactStreamManager();
if (cs == NULL || cs->getFlags() & ContactStreamManagerFlag::eINVALID_STREAM)
continue;
if (i + 1 < nbActorPairs)
PxPrefetch(&(actorPairs[i+1]->getContactStreamManager()));
PxContactPairHeader pairHeader;
finalizeContactStreamAndCreateHeader(pairHeader, *aPair, *cs, removedShapeTestMask);
mSimulationEventCallback->onContact(pairHeader, pairHeader.pairs, pairHeader.nbPairs);
// estimates for next frame
cs->maxPairCount = cs->currentPairCount;
cs->setMaxExtraDataSize(cs->extraDataSize);
}
}
}
PX_FORCE_INLINE void markDeletedShapes(Sc::ObjectIDTracker& idTracker, Sc::TriggerPairExtraData& tped, PxTriggerPair& pair)
{
PxTriggerPairFlags::InternalType flags = 0;
if (idTracker.isDeletedID(tped.shape0ID))
flags |= PxTriggerPairFlag::eREMOVED_SHAPE_TRIGGER;
if (idTracker.isDeletedID(tped.shape1ID))
flags |= PxTriggerPairFlag::eREMOVED_SHAPE_OTHER;
pair.flags = PxTriggerPairFlags(flags);
}
void Sc::Scene::fireTriggerCallbacks()
{
// triggers
const PxU32 nbTriggerPairs = mTriggerBufferAPI.size();
PX_ASSERT(nbTriggerPairs == mTriggerBufferExtraData->size());
if(nbTriggerPairs)
{
// cases to take into account:
// - no simulation/trigger shape has been removed -> no need to test shape references for removed shapes
// - simulation/trigger shapes have been removed -> test the events that have
// a marker for removed shapes set
//
const bool hasRemovedShapes = mElementIDPool->getDeletedIDCount() > 0;
if(mSimulationEventCallback)
{
if (!hasRemovedShapes)
mSimulationEventCallback->onTrigger(mTriggerBufferAPI.begin(), nbTriggerPairs);
else
{
for(PxU32 i = 0; i < nbTriggerPairs; i++)
{
PxTriggerPair& triggerPair = mTriggerBufferAPI[i];
if ((PxTriggerPairFlags::InternalType(triggerPair.flags) & TriggerPairFlag::eTEST_FOR_REMOVED_SHAPES))
markDeletedShapes(*mElementIDPool, (*mTriggerBufferExtraData)[i], triggerPair);
}
mSimulationEventCallback->onTrigger(mTriggerBufferAPI.begin(), nbTriggerPairs);
}
}
}
// PT: clear the buffer **even when there's no simulationEventCallback**.
mTriggerBufferAPI.clear();
mTriggerBufferExtraData->clear();
}
/*
Threading: called in the context of the user thread, but only after the physics thread has finished its run
*/
void Sc::Scene::fireCallbacksPostSync()
{
//
// Fire sleep & woken callbacks
//
// A body should be either in the sleep or the woken list. If it is in both, remove it from the list it was
// least recently added to.
if(!mSleepBodyListValid)
cleanUpSleepBodies();
if(!mWokeBodyListValid)
cleanUpWokenBodies();
#if PX_SUPPORT_GPU_PHYSX
const PxU32 maxGpuSizeNeeded = gpu_cleanUpSleepAndWokenBodies();
#endif
if(mSimulationEventCallback || mOnSleepingStateChanged)
{
// allocate temporary data
const PxU32 nbSleep = mSleepBodies.size();
const PxU32 nbWoken = mWokeBodies.size();
#if PX_SUPPORT_GPU_PHYSX
const PxU32 arrSize = PxMax(PxMax(nbSleep, nbWoken), maxGpuSizeNeeded);
#else
const PxU32 arrSize = PxMax(nbSleep, nbWoken);
#endif
PxActor** actors = arrSize ? reinterpret_cast<PxActor**>(PX_ALLOC(arrSize*sizeof(PxActor*), "PxActor*")) : NULL;
if(actors)
{
if(nbSleep)
{
PxU32 destSlot = 0;
BodyCore* const* sleepingBodies = mSleepBodies.getEntries();
for(PxU32 i=0; i<nbSleep; i++)
{
BodyCore* body = sleepingBodies[i];
if (body->getActorFlags() & PxActorFlag::eSEND_SLEEP_NOTIFIES)
actors[destSlot++] = body->getPxActor();
if (mOnSleepingStateChanged)
mOnSleepingStateChanged(*static_cast<physx::PxRigidDynamic*>(body->getPxActor()), true);
}
if(destSlot && mSimulationEventCallback)
mSimulationEventCallback->onSleep(actors, destSlot);
//if (PX_DBG_IS_CONNECTED())
//{
// for (PxU32 i = 0; i < nbSleep; ++i)
// {
// BodyCore* body = mSleepBodies[i];
// PX_ASSERT(body->getActorType() == PxActorType::eRIGID_DYNAMIC);
// }
//}
}
#if PX_SUPPORT_GPU_PHYSX
gpu_fireOnSleepCallback(actors);
#endif
// do the same thing for bodies that have just woken up
if(nbWoken)
{
PxU32 destSlot = 0;
BodyCore* const* wokenBodies = mWokeBodies.getEntries();
for(PxU32 i=0; i<nbWoken; i++)
{
BodyCore* body = wokenBodies[i];
if(body->getActorFlags() & PxActorFlag::eSEND_SLEEP_NOTIFIES)
actors[destSlot++] = body->getPxActor();
if (mOnSleepingStateChanged)
mOnSleepingStateChanged(*static_cast<physx::PxRigidDynamic*>(body->getPxActor()), false);
}
if(destSlot && mSimulationEventCallback)
mSimulationEventCallback->onWake(actors, destSlot);
}
#if PX_SUPPORT_GPU_PHYSX
gpu_fireOnWakeCallback(actors);
#endif
PX_FREE(actors);
}
}
clearSleepWakeBodies();
}
void Sc::Scene::postCallbacksPreSync()
{
PX_PROFILE_ZONE("Sim.postCallbackPreSync", mContextId);
// clear contact stream data
mNPhaseCore->clearContactReportStream();
mNPhaseCore->clearContactReportActorPairs(false);
postCallbacksPreSyncKinematics();
releaseConstraints(true); //release constraint blocks at the end of the frame, so user can retrieve the blocks
}
void Sc::Scene::getStats(PxSimulationStatistics& s) const
{
mStats->readOut(s, mLLContext->getSimStats());
s.nbStaticBodies = mNbRigidStatics;
s.nbDynamicBodies = mNbRigidDynamics;
s.nbKinematicBodies = mNbRigidKinematic;
s.nbArticulations = mArticulations.size();
s.nbAggregates = mAABBManager->getNbActiveAggregates();
for(PxU32 i=0; i<PxGeometryType::eGEOMETRY_COUNT; i++)
s.nbShapes[i] = mNbGeometries[i];
#if PX_SUPPORT_GPU_PHYSX
if (mHeapMemoryAllocationManager)
{
s.gpuMemHeap = mHeapMemoryAllocationManager->getDeviceMemorySize();
const PxsHeapStats& deviceHeapStats = mHeapMemoryAllocationManager->getDeviceHeapStats();
s.gpuMemHeapBroadPhase = deviceHeapStats.stats[PxsHeapStats::eBROADPHASE];
s.gpuMemHeapNarrowPhase = deviceHeapStats.stats[PxsHeapStats::eNARROWPHASE];
s.gpuMemHeapSolver = deviceHeapStats.stats[PxsHeapStats::eSOLVER];
s.gpuMemHeapArticulation = deviceHeapStats.stats[PxsHeapStats::eARTICULATION];
s.gpuMemHeapSimulation = deviceHeapStats.stats[PxsHeapStats::eSIMULATION];
s.gpuMemHeapSimulationArticulation = deviceHeapStats.stats[PxsHeapStats::eSIMULATION_ARTICULATION];
s.gpuMemHeapSimulationParticles = deviceHeapStats.stats[PxsHeapStats::eSIMULATION_PARTICLES];
s.gpuMemHeapSimulationSoftBody = deviceHeapStats.stats[PxsHeapStats::eSIMULATION_SOFTBODY];
s.gpuMemHeapSimulationFEMCloth = deviceHeapStats.stats[PxsHeapStats::eSIMULATION_FEMCLOTH];
s.gpuMemHeapSimulationHairSystem = deviceHeapStats.stats[PxsHeapStats::eSIMULATION_HAIRSYSTEM];
s.gpuMemHeapParticles = deviceHeapStats.stats[PxsHeapStats::eSHARED_PARTICLES];
s.gpuMemHeapFEMCloths = deviceHeapStats.stats[PxsHeapStats::eSHARED_FEMCLOTH];
s.gpuMemHeapSoftBodies = deviceHeapStats.stats[PxsHeapStats::eSHARED_SOFTBODY];
s.gpuMemHeapHairSystems = deviceHeapStats.stats[PxsHeapStats::eSHARED_HAIRSYSTEM];
s.gpuMemHeapOther = deviceHeapStats.stats[PxsHeapStats::eOTHER];
}
else
#endif
{
s.gpuMemHeap = 0;
s.gpuMemParticles = 0;
s.gpuMemSoftBodies = 0;
s.gpuMemFEMCloths = 0;
s.gpuMemHairSystems = 0;
s.gpuMemHeapBroadPhase = 0;
s.gpuMemHeapNarrowPhase = 0;
s.gpuMemHeapSolver = 0;
s.gpuMemHeapArticulation = 0;
s.gpuMemHeapSimulation = 0;
s.gpuMemHeapSimulationArticulation = 0;
s.gpuMemHeapSimulationParticles = 0;
s.gpuMemHeapSimulationSoftBody = 0;
s.gpuMemHeapSimulationFEMCloth = 0;
s.gpuMemHeapSimulationHairSystem = 0;
s.gpuMemHeapParticles = 0;
s.gpuMemHeapSoftBodies = 0;
s.gpuMemHeapFEMCloths = 0;
s.gpuMemHeapHairSystems = 0;
s.gpuMemHeapOther = 0;
}
}
void Sc::Scene::addShapes(NpShape *const* shapes, PxU32 nbShapes, size_t ptrOffset, RigidSim& bodySim, PxBounds3* outBounds)
{
const PxNodeIndex nodeIndex = bodySim.getNodeIndex();
PxvNphaseImplementationContext* context = mLLContext->getNphaseImplementationContext();
for(PxU32 i=0;i<nbShapes;i++)
{
// PT: TODO: drop the offsets and let me include NpShape.h from here! This is just NpShape::getCore()....
ShapeCore& sc = *reinterpret_cast<ShapeCore*>(size_t(shapes[i])+ptrOffset);
//PxBounds3* target = uninflatedBounds ? uninflatedBounds + i : uninflatedBounds;
//mShapeSimPool->construct(sim, sc, llBody, target);
ShapeSim* shapeSim = mShapeSimPool->construct(bodySim, sc);
mNbGeometries[sc.getGeometryType()]++;
mSimulationController->addShape(&shapeSim->getLLShapeSim(), shapeSim->getElementID());
if (outBounds)
outBounds[i] = mBoundsArray->getBounds(shapeSim->getElementID());
//I register the shape if its either not an articulation link or if the nodeIndex has already been
//assigned. On insertion, the articulation will not have this nodeIndex correctly assigned at this stage
if (bodySim.getActorType() != PxActorType::eARTICULATION_LINK || !nodeIndex.isStaticBody())
context->registerShape(nodeIndex, sc.getCore(), shapeSim->getElementID(), bodySim.getPxActor());
}
}
void Sc::Scene::removeShapes(Sc::RigidSim& sim, PxInlineArray<Sc::ShapeSim*, 64>& shapesBuffer , PxInlineArray<const Sc::ShapeCore*,64>& removedShapes, bool wakeOnLostTouch)
{
PxU32 nbElems = sim.getNbElements();
Sc::ElementSim** elems = sim.getElements();
while (nbElems--)
{
Sc::ShapeSim* s = static_cast<Sc::ShapeSim*>(*elems++);
// can do two 2x the allocs in the worst case, but actors with >64 shapes are not common
shapesBuffer.pushBack(s);
removedShapes.pushBack(&s->getCore());
}
for(PxU32 i=0;i<shapesBuffer.size();i++)
removeShape_(*shapesBuffer[i], wakeOnLostTouch);
}
void Sc::Scene::addStatic(StaticCore& ro, NpShape*const *shapes, PxU32 nbShapes, size_t shapePtrOffset, PxBounds3* uninflatedBounds)
{
PX_ASSERT(ro.getActorCoreType() == PxActorType::eRIGID_STATIC);
// sim objects do all the necessary work of adding themselves to broad phase,
// activation, registering with the interaction system, etc
StaticSim* sim = mStaticSimPool->construct(*this, ro);
mNbRigidStatics++;
addShapes(shapes, nbShapes, shapePtrOffset, *sim, uninflatedBounds);
}
void Sc::Scene::removeStatic(StaticCore& ro, PxInlineArray<const Sc::ShapeCore*,64>& removedShapes, bool wakeOnLostTouch)
{
PX_ASSERT(ro.getActorCoreType() == PxActorType::eRIGID_STATIC);
StaticSim* sim = ro.getSim();
if(sim)
{
if(mBatchRemoveState)
{
removeShapes(*sim, mBatchRemoveState->bufferedShapes ,removedShapes, wakeOnLostTouch);
}
else
{
PxInlineArray<Sc::ShapeSim*, 64> shapesBuffer;
removeShapes(*sim, shapesBuffer ,removedShapes, wakeOnLostTouch);
}
mStaticSimPool->destroy(static_cast<Sc::StaticSim*>(ro.getSim()));
mNbRigidStatics--;
}
}
void Sc::Scene::addBody(BodyCore& body, NpShape*const *shapes, PxU32 nbShapes, size_t shapePtrOffset, PxBounds3* outBounds, bool compound)
{
// sim objects do all the necessary work of adding themselves to broad phase,
// activation, registering with the interaction system, etc
BodySim* sim = mBodySimPool->construct(*this, body, compound);
const bool isArticulationLink = sim->isArticulationLink();
if (sim->getLowLevelBody().mCore->mFlags & PxRigidBodyFlag::eENABLE_SPECULATIVE_CCD && sim->isActive())
{
if (isArticulationLink)
{
if (sim->getNodeIndex().isValid())
mSpeculativeCDDArticulationBitMap.growAndSet(sim->getNodeIndex().index());
}
else
mSpeculativeCCDRigidBodyBitMap.growAndSet(sim->getNodeIndex().index());
}
//if rigid body is articulation link, the node index will be invalid. We should add the link to the scene after we add the
//articulation for gpu
if(sim->getNodeIndex().isValid())
mSimulationController->addDynamic(&sim->getLowLevelBody(), sim->getNodeIndex());
if(sim->getSimStateData(true) && sim->getSimStateData(true)->isKine())
mNbRigidKinematic++;
else
mNbRigidDynamics++;
addShapes(shapes, nbShapes, shapePtrOffset, *sim, outBounds);
mDynamicsContext->setStateDirty(true);
}
void Sc::Scene::removeBody(BodyCore& body, PxInlineArray<const Sc::ShapeCore*,64>& removedShapes, bool wakeOnLostTouch)
{
BodySim *sim = body.getSim();
if(sim)
{
if(mBatchRemoveState)
{
removeShapes(*sim, mBatchRemoveState->bufferedShapes, removedShapes, wakeOnLostTouch);
}
else
{
PxInlineArray<Sc::ShapeSim*, 64> shapesBuffer;
removeShapes(*sim,shapesBuffer, removedShapes, wakeOnLostTouch);
}
if(!sim->isArticulationLink())
{
//clear bit map
if(sim->getLowLevelBody().mCore->mFlags & PxRigidBodyFlag::eENABLE_SPECULATIVE_CCD)
sim->getScene().resetSpeculativeCCDRigidBody(sim->getNodeIndex().index());
}
else
{
// PT: TODO: missing call to resetSpeculativeCCDArticulationLink ?
sim->getArticulation()->removeBody(*sim);
}
if(sim->getSimStateData(true) && sim->getSimStateData(true)->isKine())
{
body.onRemoveKinematicFromScene();
mNbRigidKinematic--;
}
else
mNbRigidDynamics--;
mBodySimPool->destroy(sim);
mDynamicsContext->setStateDirty(true);
}
}
// PT: TODO: refactor with addShapes
void Sc::Scene::addShape_(RigidSim& owner, ShapeCore& shapeCore)
{
ShapeSim* sim = mShapeSimPool->construct(owner, shapeCore);
mNbGeometries[shapeCore.getGeometryType()]++;
//register shape
mSimulationController->addShape(&sim->getLLShapeSim(), sim->getElementID());
registerShapeInNphase(&owner.getRigidCore(), shapeCore, sim->getElementID());
}
// PT: TODO: refactor with removeShapes
void Sc::Scene::removeShape_(ShapeSim& shape, bool wakeOnLostTouch)
{
//BodySim* body = shape.getBodySim();
//if(body)
// body->postShapeDetach();
unregisterShapeFromNphase(shape.getCore(), shape.getElementID());
mSimulationController->removeShape(shape.getElementID());
mNbGeometries[shape.getCore().getGeometryType()]--;
shape.removeFromBroadPhase(wakeOnLostTouch);
mShapeSimPool->destroy(&shape);
}
void Sc::Scene::registerShapeInNphase(Sc::RigidCore* rigidCore, const ShapeCore& shape, const PxU32 transformCacheID)
{
RigidSim* sim = rigidCore->getSim();
if(sim)
mLLContext->getNphaseImplementationContext()->registerShape(sim->getNodeIndex(), shape.getCore(), transformCacheID, sim->getPxActor());
}
void Sc::Scene::unregisterShapeFromNphase(const ShapeCore& shape, const PxU32 transformCacheID)
{
mLLContext->getNphaseImplementationContext()->unregisterShape(shape.getCore(), transformCacheID);
}
void Sc::Scene::notifyNphaseOnUpdateShapeMaterial(const ShapeCore& shapeCore)
{
mLLContext->getNphaseImplementationContext()->updateShapeMaterial(shapeCore.getCore());
}
void Sc::Scene::startBatchInsertion(BatchInsertionState&state)
{
state.shapeSim = mShapeSimPool->allocateAndPrefetch();
state.staticSim = mStaticSimPool->allocateAndPrefetch();
state.bodySim = mBodySimPool->allocateAndPrefetch();
}
void Sc::Scene::addShapes(NpShape*const* shapes, PxU32 nbShapes, size_t ptrOffset, RigidSim& rigidSim, ShapeSim*& prefetchedShapeSim, PxBounds3* outBounds)
{
for(PxU32 i=0;i<nbShapes;i++)
{
if(i+1<nbShapes)
PxPrefetch(shapes[i+1], PxU32(ptrOffset+sizeof(Sc::ShapeCore)));
ShapeSim* nextShapeSim = mShapeSimPool->allocateAndPrefetch();
ShapeCore& sc = *PxPointerOffset<ShapeCore*>(shapes[i], ptrdiff_t(ptrOffset));
PX_PLACEMENT_NEW(prefetchedShapeSim, ShapeSim(rigidSim, sc));
const PxU32 elementID = prefetchedShapeSim->getElementID();
outBounds[i] = mBoundsArray->getBounds(elementID);
mSimulationController->addShape(&prefetchedShapeSim->getLLShapeSim(), elementID);
mLLContext->getNphaseImplementationContext()->registerShape(rigidSim.getNodeIndex(), sc.getCore(), elementID, rigidSim.getPxActor());
prefetchedShapeSim = nextShapeSim;
mNbGeometries[sc.getGeometryType()]++;
}
}
void Sc::Scene::addStatic(PxActor* actor, BatchInsertionState& s, PxBounds3* outBounds)
{
// static core has been prefetched by caller
Sc::StaticSim* sim = s.staticSim; // static core has been prefetched by the caller
const Cm::PtrTable* shapeTable = PxPointerOffset<const Cm::PtrTable*>(actor, s.staticShapeTableOffset);
void*const* shapes = shapeTable->getPtrs();
mStaticSimPool->construct(sim, *this, *PxPointerOffset<Sc::StaticCore*>(actor, s.staticActorOffset));
s.staticSim = mStaticSimPool->allocateAndPrefetch();
addShapes(reinterpret_cast<NpShape*const*>(shapes), shapeTable->getCount(), size_t(s.shapeOffset), *sim, s.shapeSim, outBounds);
mNbRigidStatics++;
}
void Sc::Scene::addBody(PxActor* actor, BatchInsertionState& s, PxBounds3* outBounds, bool compound)
{
Sc::BodySim* sim = s.bodySim; // body core has been prefetched by the caller
const Cm::PtrTable* shapeTable = PxPointerOffset<const Cm::PtrTable*>(actor, s.dynamicShapeTableOffset);
void*const* shapes = shapeTable->getPtrs();
Sc::BodyCore* bodyCore = PxPointerOffset<Sc::BodyCore*>(actor, s.dynamicActorOffset);
mBodySimPool->construct(sim, *this, *bodyCore, compound);
s.bodySim = mBodySimPool->allocateAndPrefetch();
if(sim->getLowLevelBody().mCore->mFlags & PxRigidBodyFlag::eENABLE_SPECULATIVE_CCD)
{
if(sim->isArticulationLink())
mSpeculativeCDDArticulationBitMap.growAndSet(sim->getNodeIndex().index());
else
mSpeculativeCCDRigidBodyBitMap.growAndSet(sim->getNodeIndex().index());
}
if(sim->getNodeIndex().isValid())
mSimulationController->addDynamic(&sim->getLowLevelBody(), sim->getNodeIndex());
addShapes(reinterpret_cast<NpShape*const*>(shapes), shapeTable->getCount(), size_t(s.shapeOffset), *sim, s.shapeSim, outBounds);
const SimStateData* simStateData = bodyCore->getSim()->getSimStateData(true);
if(simStateData && simStateData->isKine())
mNbRigidKinematic++;
else
mNbRigidDynamics++;
mDynamicsContext->setStateDirty(true);
}
void Sc::Scene::finishBatchInsertion(BatchInsertionState& state)
{
// a little bit lazy - we could deal with the last one in the batch specially to avoid overallocating by one.
mStaticSimPool->releasePreallocated(static_cast<Sc::StaticSim*>(state.staticSim));
mBodySimPool->releasePreallocated(static_cast<Sc::BodySim*>(state.bodySim));
mShapeSimPool->releasePreallocated(state.shapeSim);
}
// PT: TODO: why is this in Sc?
void Sc::Scene::initContactsIterator(ContactIterator& contactIterator, PxsContactManagerOutputIterator& outputs)
{
outputs = mLLContext->getNphaseImplementationContext()->getContactManagerOutputs();
ElementSimInteraction** first = mInteractions[Sc::InteractionType::eOVERLAP].begin();
contactIterator = ContactIterator(first, first + mActiveInteractionCount[Sc::InteractionType::eOVERLAP], outputs);
}
void Sc::Scene::setDominanceGroupPair(PxDominanceGroup group1, PxDominanceGroup group2, const PxDominanceGroupPair& dominance)
{
struct {
void operator()(PxU32& bits, PxDominanceGroup shift, PxReal weight)
{
if(weight != PxReal(0))
bits |= (PxU32(1) << shift);
else
bits &= ~(PxU32(1) << shift);
}
} bitsetter;
bitsetter(mDominanceBitMatrix[group1], group2, dominance.dominance0);
bitsetter(mDominanceBitMatrix[group2], group1, dominance.dominance1);
mInternalFlags |= SceneInternalFlag::eSCENE_SIP_STATES_DIRTY_DOMINANCE; //force an update on all interactions on matrix change -- very expensive but we have no choice!!
}
PxDominanceGroupPair Sc::Scene::getDominanceGroupPair(PxDominanceGroup group1, PxDominanceGroup group2) const
{
const PxU8 dom0 = PxU8((mDominanceBitMatrix[group1]>>group2) & 0x1 ? 1u : 0u);
const PxU8 dom1 = PxU8((mDominanceBitMatrix[group2]>>group1) & 0x1 ? 1u : 0u);
return PxDominanceGroupPair(dom0, dom1);
}
PxU32 Sc::Scene::getDefaultContactReportStreamBufferSize() const
{
return mNPhaseCore->getDefaultContactReportStreamBufferSize();
}
void Sc::Scene::buildActiveActors()
{
{
PxU32 numActiveBodies = 0;
BodyCore*const* PX_RESTRICT activeBodies;
if (!(getFlags() & PxSceneFlag::eEXCLUDE_KINEMATICS_FROM_ACTIVE_ACTORS))
{
numActiveBodies = getNumActiveBodies();
activeBodies = getActiveBodiesArray();
}
else
{
numActiveBodies = getActiveDynamicBodiesCount();
activeBodies = getActiveDynamicBodies();
}
mActiveActors.clear();
for (PxU32 i = 0; i < numActiveBodies; i++)
{
if (!activeBodies[i]->isFrozen())
{
PxRigidActor* ra = static_cast<PxRigidActor*>(activeBodies[i]->getPxActor());
PX_ASSERT(ra);
mActiveActors.pushBack(ra);
}
}
}
#if PX_SUPPORT_GPU_PHYSX
gpu_buildActiveActors();
#endif
}
// PT: TODO: unify buildActiveActors & buildActiveAndFrozenActors
void Sc::Scene::buildActiveAndFrozenActors()
{
{
PxU32 numActiveBodies = 0;
BodyCore*const* PX_RESTRICT activeBodies;
if (!(getFlags() & PxSceneFlag::eEXCLUDE_KINEMATICS_FROM_ACTIVE_ACTORS))
{
numActiveBodies = getNumActiveBodies();
activeBodies = getActiveBodiesArray();
}
else
{
numActiveBodies = getActiveDynamicBodiesCount();
activeBodies = getActiveDynamicBodies();
}
mActiveActors.clear();
mFrozenActors.clear();
for (PxU32 i = 0; i < numActiveBodies; i++)
{
PxRigidActor* ra = static_cast<PxRigidActor*>(activeBodies[i]->getPxActor());
PX_ASSERT(ra);
if (!activeBodies[i]->isFrozen())
mActiveActors.pushBack(ra);
else
mFrozenActors.pushBack(ra);
}
}
#if PX_SUPPORT_GPU_PHYSX
gpu_buildActiveAndFrozenActors();
#endif
}
PxActor** Sc::Scene::getActiveActors(PxU32& nbActorsOut)
{
nbActorsOut = mActiveActors.size();
if(!nbActorsOut)
return NULL;
return mActiveActors.begin();
}
void Sc::Scene::setActiveActors(PxActor** actors, PxU32 nbActors)
{
mActiveActors.forceSize_Unsafe(0);
mActiveActors.resize(nbActors);
PxMemCopy(mActiveActors.begin(), actors, sizeof(PxActor*) * nbActors);
}
PxActor** Sc::Scene::getFrozenActors(PxU32& nbActorsOut)
{
nbActorsOut = mFrozenActors.size();
if(!nbActorsOut)
return NULL;
return mFrozenActors.begin();
}
void Sc::Scene::reserveTriggerReportBufferSpace(const PxU32 pairCount, PxTriggerPair*& triggerPairBuffer, TriggerPairExtraData*& triggerPairExtraBuffer)
{
const PxU32 oldSize = mTriggerBufferAPI.size();
const PxU32 newSize = oldSize + pairCount;
const PxU32 newCapacity = PxU32(newSize * 1.5f);
mTriggerBufferAPI.reserve(newCapacity);
mTriggerBufferAPI.forceSize_Unsafe(newSize);
triggerPairBuffer = mTriggerBufferAPI.begin() + oldSize;
PX_ASSERT(oldSize == mTriggerBufferExtraData->size());
mTriggerBufferExtraData->reserve(newCapacity);
mTriggerBufferExtraData->forceSize_Unsafe(newSize);
triggerPairExtraBuffer = mTriggerBufferExtraData->begin() + oldSize;
}
template<const bool sleepOrWoke, class T>
static void clearBodies(PxCoalescedHashSet<T*>& bodies)
{
T* const* sleepingOrWokenBodies = bodies.getEntries();
const PxU32 nb = bodies.size();
for(PxU32 i=0; i<nb; i++)
{
ActorSim* body = sleepingOrWokenBodies[i]->getSim();
if(sleepOrWoke)
{
PX_ASSERT(!body->readInternalFlag(ActorSim::BF_WAKEUP_NOTIFY));
body->clearInternalFlag(ActorSim::BF_SLEEP_NOTIFY);
}
else
{
PX_ASSERT(!body->readInternalFlag(ActorSim::BF_SLEEP_NOTIFY));
body->clearInternalFlag(ActorSim::BF_WAKEUP_NOTIFY);
}
// A body can be in both lists depending on the sequence of events
body->clearInternalFlag(ActorSim::BF_IS_IN_SLEEP_LIST);
body->clearInternalFlag(ActorSim::BF_IS_IN_WAKEUP_LIST);
}
bodies.clear();
}
void Sc::Scene::clearSleepWakeBodies()
{
// Clear sleep/woken marker flags
clearBodies<true>(mSleepBodies);
clearBodies<false>(mWokeBodies);
mSleepBodies.clear();
mWokeBodies.clear();
mWokeBodyListValid = true;
mSleepBodyListValid = true;
#if PX_SUPPORT_GPU_PHYSX
gpu_clearSleepWakeBodies();
#endif
}
void Sc::Scene::onBodySleep(BodySim* body)
{
if (!mSimulationEventCallback && !mOnSleepingStateChanged)
return;
if (body->readInternalFlag(ActorSim::BF_WAKEUP_NOTIFY))
{
PX_ASSERT(!body->readInternalFlag(ActorSim::BF_SLEEP_NOTIFY));
// Body is in the list of woken bodies, hence, mark this list as dirty such that it gets cleaned up before
// being sent to the user
body->clearInternalFlag(ActorSim::BF_WAKEUP_NOTIFY);
mWokeBodyListValid = false;
}
body->raiseInternalFlag(ActorSim::BF_SLEEP_NOTIFY);
// Avoid multiple insertion (the user can do multiple transitions between asleep and awake)
if (!body->readInternalFlag(ActorSim::BF_IS_IN_SLEEP_LIST))
{
PX_ASSERT(!mSleepBodies.contains(&body->getBodyCore()));
mSleepBodies.insert(&body->getBodyCore());
body->raiseInternalFlag(ActorSim::BF_IS_IN_SLEEP_LIST);
}
}
void Sc::Scene::onBodyWakeUp(BodySim* body)
{
if(!mSimulationEventCallback && !mOnSleepingStateChanged)
return;
if (body->readInternalFlag(BodySim::BF_SLEEP_NOTIFY))
{
PX_ASSERT(!body->readInternalFlag(BodySim::BF_WAKEUP_NOTIFY));
// Body is in the list of sleeping bodies, hence, mark this list as dirty such it gets cleaned up before
// being sent to the user
body->clearInternalFlag(BodySim::BF_SLEEP_NOTIFY);
mSleepBodyListValid = false;
}
body->raiseInternalFlag(BodySim::BF_WAKEUP_NOTIFY);
// Avoid multiple insertion (the user can do multiple transitions between asleep and awake)
if (!body->readInternalFlag(BodySim::BF_IS_IN_WAKEUP_LIST))
{
PX_ASSERT(!mWokeBodies.contains(&body->getBodyCore()));
mWokeBodies.insert(&body->getBodyCore());
body->raiseInternalFlag(BodySim::BF_IS_IN_WAKEUP_LIST);
}
}
PX_INLINE void Sc::Scene::cleanUpSleepBodies()
{
BodyCore* const* bodyArray = mSleepBodies.getEntries();
PxU32 bodyCount = mSleepBodies.size();
IG::IslandSim& islandSim = mSimpleIslandManager->getAccurateIslandSim();
while (bodyCount--)
{
ActorSim* actor = bodyArray[bodyCount]->getSim();
BodySim* body = static_cast<BodySim*>(actor);
if (body->readInternalFlag(static_cast<BodySim::InternalFlags>(ActorSim::BF_WAKEUP_NOTIFY)))
{
body->clearInternalFlag(static_cast<BodySim::InternalFlags>(ActorSim::BF_IS_IN_WAKEUP_LIST));
mSleepBodies.erase(bodyArray[bodyCount]);
}
else if (islandSim.getNode(body->getNodeIndex()).isActive())
{
//This body is still active in the island simulation, so the request to deactivate the actor by the application must have failed. Recover by undoing this
mSleepBodies.erase(bodyArray[bodyCount]);
actor->internalWakeUp();
}
}
mSleepBodyListValid = true;
}
PX_INLINE void Sc::Scene::cleanUpWokenBodies()
{
cleanUpSleepOrWokenBodies(mWokeBodies, BodySim::BF_SLEEP_NOTIFY, mWokeBodyListValid);
}
PX_INLINE void Sc::Scene::cleanUpSleepOrWokenBodies(PxCoalescedHashSet<BodyCore*>& bodyList, PxU32 removeFlag, bool& validMarker)
{
// With our current logic it can happen that a body is added to the sleep as well as the woken body list in the
// same frame.
//
// Examples:
// - Kinematic is created (added to woken list) but has not target (-> deactivation -> added to sleep list)
// - Dynamic is created (added to woken list) but is forced to sleep by user (-> deactivation -> added to sleep list)
//
// This code traverses the sleep/woken body list and removes bodies which have been initially added to the given
// list but do not belong to it anymore.
BodyCore* const* bodyArray = bodyList.getEntries();
PxU32 bodyCount = bodyList.size();
while (bodyCount--)
{
BodySim* body = bodyArray[bodyCount]->getSim();
if (body->readInternalFlag(static_cast<BodySim::InternalFlags>(removeFlag)))
bodyList.erase(bodyArray[bodyCount]);
}
validMarker = true;
}
FeatherstoneArticulation* Sc::Scene::createLLArticulation(Sc::ArticulationSim* sim)
{
return mLLArticulationRCPool->construct(sim);
}
void Sc::Scene::destroyLLArticulation(FeatherstoneArticulation& articulation)
{
mLLArticulationRCPool->destroy(static_cast<Dy::FeatherstoneArticulation*>(&articulation));
}
PxU32 Sc::Scene::createAggregate(void* userData, PxU32 maxNumShapes, PxAggregateFilterHint filterHint)
{
const physx::Bp::BoundsIndex index = getElementIDPool().createID();
mBoundsArray->initEntry(index);
mLLContext->getNphaseImplementationContext()->registerAggregate(index);
#ifdef BP_USE_AGGREGATE_GROUP_TAIL
return mAABBManager->createAggregate(index, Bp::FilterGroup::eINVALID, userData, maxNumShapes, filterHint);
#else
// PT: TODO: ideally a static compound would have a static group
const PxU32 rigidId = getRigidIDTracker().createID();
const Bp::FilterGroup::Enum bpGroup = Bp::FilterGroup::Enum(rigidId + Bp::FilterGroup::eDYNAMICS_BASE);
return mAABBManager->createAggregate(index, bpGroup, userData, selfCollisions);
#endif
}
void Sc::Scene::deleteAggregate(PxU32 id)
{
Bp::BoundsIndex index;
Bp::FilterGroup::Enum bpGroup;
#ifdef BP_USE_AGGREGATE_GROUP_TAIL
if(mAABBManager->destroyAggregate(index, bpGroup, id))
{
getElementIDPool().releaseID(index);
}
#else
if(mAABBManager->destroyAggregate(index, bpGroup, id))
{
getElementIDPool().releaseID(index);
// PT: this is clumsy....
const PxU32 rigidId = PxU32(bpGroup) - Bp::FilterGroup::eDYNAMICS_BASE;
getRigidIDTracker().releaseID(rigidId);
}
#endif
}
void Sc::Scene::shiftOrigin(const PxVec3& shift)
{
// adjust low level context
mLLContext->shiftOrigin(shift);
// adjust bounds array
mBoundsArray->shiftOrigin(shift);
// adjust broadphase
mAABBManager->shiftOrigin(shift);
// adjust constraints
ConstraintCore*const * constraints = mConstraints.getEntries();
for(PxU32 i=0, size = mConstraints.size(); i < size; i++)
constraints[i]->getPxConnector()->onOriginShift(shift);
}
///////////////////////////////////////////////////////////////////////////////
// PT: onActivate() functions should be called when an interaction is activated or created, and return true if activation
// should proceed else return false (for example: joint interaction between two kinematics should not get activated)
bool Sc::activateInteraction(Sc::Interaction* interaction, void* data)
{
switch(interaction->getType())
{
case InteractionType::eOVERLAP:
return static_cast<Sc::ShapeInteraction*>(interaction)->onActivate(data);
case InteractionType::eTRIGGER:
return static_cast<Sc::TriggerInteraction*>(interaction)->onActivate(data);
case InteractionType::eMARKER:
// PT: ElementInteractionMarker::onActivate() always returns false (always inactive).
return false;
case InteractionType::eCONSTRAINTSHADER:
return static_cast<Sc::ConstraintInteraction*>(interaction)->onActivate(data);
case InteractionType::eARTICULATION:
return static_cast<Sc::ArticulationJointSim*>(interaction)->onActivate(data);
case InteractionType::eTRACKED_IN_SCENE_COUNT:
case InteractionType::eINVALID:
PX_ASSERT(0);
break;
}
return false;
}
// PT: onDeactivate() functions should be called when an interaction is deactivated, and return true if deactivation should proceed
// else return false (for example: joint interaction between two kinematics can ignore deactivation because it always is deactivated)
/*static*/ bool deactivateInteraction(Sc::Interaction* interaction, const Sc::InteractionType::Enum type)
{
switch(type)
{
case InteractionType::eOVERLAP:
return static_cast<Sc::ShapeInteraction*>(interaction)->onDeactivate();
case InteractionType::eTRIGGER:
return static_cast<Sc::TriggerInteraction*>(interaction)->onDeactivate();
case InteractionType::eMARKER:
// PT: ElementInteractionMarker::onDeactivate() always returns true.
return true;
case InteractionType::eCONSTRAINTSHADER:
return static_cast<Sc::ConstraintInteraction*>(interaction)->onDeactivate();
case InteractionType::eARTICULATION:
return static_cast<Sc::ArticulationJointSim*>(interaction)->onDeactivate();
case InteractionType::eTRACKED_IN_SCENE_COUNT:
case InteractionType::eINVALID:
PX_ASSERT(0);
break;
}
return false;
}
void Sc::activateInteractions(Sc::ActorSim& actorSim)
{
const PxU32 nbInteractions = actorSim.getActorInteractionCount();
if(!nbInteractions)
return;
Interaction** interactions = actorSim.getActorInteractions();
Scene& scene = actorSim.getScene();
for(PxU32 i=0; i<nbInteractions; ++i)
{
PxPrefetchLine(interactions[PxMin(i+1,nbInteractions-1)]);
Interaction* interaction = interactions[i];
if(!interaction->readInteractionFlag(InteractionFlag::eIS_ACTIVE))
{
const InteractionType::Enum type = interaction->getType();
const bool isNotIGControlled = type != InteractionType::eOVERLAP && type != InteractionType::eMARKER;
if(isNotIGControlled)
{
const bool proceed = activateInteraction(interaction, NULL);
if(proceed && (type < InteractionType::eTRACKED_IN_SCENE_COUNT))
scene.notifyInteractionActivated(interaction); // PT: we can reach this line for trigger interactions
}
}
}
}
void Sc::deactivateInteractions(Sc::ActorSim& actorSim)
{
const PxU32 nbInteractions = actorSim.getActorInteractionCount();
if(!nbInteractions)
return;
Interaction** interactions = actorSim.getActorInteractions();
Scene& scene = actorSim.getScene();
for(PxU32 i=0; i<nbInteractions; ++i)
{
PxPrefetchLine(interactions[PxMin(i+1,nbInteractions-1)]);
Interaction* interaction = interactions[i];
if(interaction->readInteractionFlag(InteractionFlag::eIS_ACTIVE))
{
const InteractionType::Enum type = interaction->getType();
const bool isNotIGControlled = type != InteractionType::eOVERLAP && type != InteractionType::eMARKER;
if(isNotIGControlled)
{
const bool proceed = deactivateInteraction(interaction, type);
if(proceed && (type < InteractionType::eTRACKED_IN_SCENE_COUNT))
scene.notifyInteractionDeactivated(interaction); // PT: we can reach this line for trigger interactions
}
}
}
}
Sc::ConstraintCore* Sc::Scene::findConstraintCore(const Sc::ActorSim* sim0, const Sc::ActorSim* sim1)
{
const PxNodeIndex ind0 = sim0->getNodeIndex();
const PxNodeIndex ind1 = sim1->getNodeIndex();
if(ind1 < ind0)
PxSwap(sim0, sim1);
const PxHashMap<PxPair<const Sc::ActorSim*, const Sc::ActorSim*>, Sc::ConstraintCore*>::Entry* entry = mConstraintMap.find(PxPair<const Sc::ActorSim*, const Sc::ActorSim*>(sim0, sim1));
return entry ? entry->second : NULL;
}
void Sc::Scene::updateBodySim(Sc::BodySim& bodySim)
{
Dy::FeatherstoneArticulation* arti = NULL;
Sc::ArticulationSim* artiSim = bodySim.getArticulation();
if (artiSim)
arti = artiSim->getLowLevelArticulation();
mSimulationController->updateDynamic(arti, bodySim.getNodeIndex());
}
// PT: start moving PX_SUPPORT_GPU_PHYSX bits to the end of the file. Ideally/eventually they would move to a separate class or file,
// to clearly decouple the CPU and GPU parts of the scene/pipeline.
#if PX_SUPPORT_GPU_PHYSX
void Sc::Scene::gpu_releasePools()
{
PX_DELETE(mLLSoftBodyPool);
PX_DELETE(mLLFEMClothPool);
PX_DELETE(mLLParticleSystemPool);
PX_DELETE(mLLHairSystemPool);
}
void Sc::Scene::gpu_release()
{
PX_DELETE(mHeapMemoryAllocationManager);
}
template<class T>
static void addToActiveArray(PxArray<T*>& activeArray, ActorSim& actorSim, ActorCore* core)
{
const PxU32 activeListIndex = activeArray.size();
actorSim.setActiveListIndex(activeListIndex);
activeArray.pushBack(static_cast<T*>(core));
}
void Sc::Scene::gpu_addToActiveList(ActorSim& actorSim, ActorCore* appendedActorCore)
{
if (actorSim.isSoftBody())
addToActiveArray(mActiveSoftBodies, actorSim, appendedActorCore);
else if (actorSim.isFEMCloth())
addToActiveArray(mActiveFEMCloths, actorSim, appendedActorCore);
else if (actorSim.isParticleSystem())
addToActiveArray(mActiveParticleSystems, actorSim, appendedActorCore);
else if (actorSim.isHairSystem())
addToActiveArray(mActiveHairSystems, actorSim, appendedActorCore);
}
template<class T>
static void removeFromActiveArray(PxArray<T*>& activeArray, PxU32 removedActiveIndex)
{
const PxU32 newSize = activeArray.size() - 1;
if(removedActiveIndex != newSize)
{
T* lastBody = activeArray[newSize];
activeArray[removedActiveIndex] = lastBody;
lastBody->getSim()->setActiveListIndex(removedActiveIndex);
}
activeArray.forceSize_Unsafe(newSize);
}
void Sc::Scene::gpu_removeFromActiveList(ActorSim& actorSim, PxU32 removedActiveIndex)
{
if(actorSim.isSoftBody())
removeFromActiveArray(mActiveSoftBodies, removedActiveIndex);
else if(actorSim.isFEMCloth())
removeFromActiveArray(mActiveFEMCloths, removedActiveIndex);
else if(actorSim.isParticleSystem())
removeFromActiveArray(mActiveParticleSystems, removedActiveIndex);
else if(actorSim.isHairSystem())
removeFromActiveArray(mActiveHairSystems, removedActiveIndex);
}
void Sc::Scene::gpu_clearSleepWakeBodies()
{
clearBodies<true>(mSleepSoftBodies);
clearBodies<true>(mSleepHairSystems);
clearBodies<false>(mWokeSoftBodies);
clearBodies<false>(mWokeHairSystems);
mWokeSoftBodyListValid = true;
mSleepSoftBodyListValid = true;
mWokeHairSystemListValid = true;
mSleepHairSystemListValid = true;
}
void Sc::Scene::gpu_buildActiveActors()
{
{
PxU32 numActiveSoftBodies = getNumActiveSoftBodies();
SoftBodyCore*const* PX_RESTRICT activeSoftBodies = getActiveSoftBodiesArray();
mActiveSoftBodyActors.clear();
for (PxU32 i = 0; i < numActiveSoftBodies; i++)
{
PxActor* ra = activeSoftBodies[i]->getPxActor();
mActiveSoftBodyActors.pushBack(ra);
}
}
{
PxU32 numActiveHairSystems = getNumActiveHairSystems();
HairSystemCore*const* PX_RESTRICT activeHairSystems = getActiveHairSystemsArray();
mActiveHairSystemActors.clear();
for (PxU32 i = 0; i < numActiveHairSystems; i++)
{
PxActor* ra = activeHairSystems[i]->getPxActor();
mActiveHairSystemActors.pushBack(ra);
}
}
}
void Sc::Scene::gpu_buildActiveAndFrozenActors()
{
{
PxU32 numActiveSoftBodies = getNumActiveSoftBodies();
SoftBodyCore*const* PX_RESTRICT activeSoftBodies = getActiveSoftBodiesArray();
mActiveSoftBodyActors.clear();
for (PxU32 i = 0; i < numActiveSoftBodies; i++)
{
PxActor* ra = activeSoftBodies[i]->getPxActor();
mActiveSoftBodyActors.pushBack(ra);
}
}
{
PxU32 numActiveHairSystems = getNumActiveHairSystems();
HairSystemCore*const* PX_RESTRICT activeHairSystems = getActiveHairSystemsArray();
mActiveHairSystemActors.clear();
for (PxU32 i = 0; i < numActiveHairSystems; i++)
{
PxActor* ra = activeHairSystems[i]->getPxActor();
mActiveHairSystemActors.pushBack(ra);
}
}
}
void Sc::Scene::gpu_setSimulationEventCallback(PxSimulationEventCallback* /*callback*/)
{
SoftBodyCore* const* sleepingSoftBodies = mSleepSoftBodies.getEntries();
for (PxU32 i = 0; i < mSleepSoftBodies.size(); i++)
{
sleepingSoftBodies[i]->getSim()->raiseInternalFlag(BodySim::BF_SLEEP_NOTIFY);
}
//FEMClothCore* const* sleepingFEMCloths = mSleepFEMCloths.getEntries();
//for (PxU32 i = 0; i < mSleepFEMCloths.size(); i++)
//{
// sleepingFEMCloths[i]->getSim()->raiseInternalFlag(BodySim::BF_SLEEP_NOTIFY);
//}
HairSystemCore* const* sleepingHairSystems = mSleepHairSystems.getEntries();
for (PxU32 i = 0; i < mSleepHairSystems.size(); i++)
{
sleepingHairSystems[i]->getSim()->raiseInternalFlag(BodySim::BF_SLEEP_NOTIFY);
}
}
PxU32 Sc::Scene::gpu_cleanUpSleepAndWokenBodies()
{
if (!mSleepSoftBodyListValid)
cleanUpSleepSoftBodies();
if (!mWokeBodyListValid)
cleanUpWokenSoftBodies();
if (!mSleepHairSystemListValid)
cleanUpSleepHairSystems();
if (!mWokeHairSystemListValid) // TODO(jcarius) should this be mWokeBodyListValid?
cleanUpWokenHairSystems();
const PxU32 nbHairSystemSleep = mSleepHairSystems.size();
const PxU32 nbHairSystemWoken = mWokeHairSystems.size();
const PxU32 nbSoftBodySleep = mSleepSoftBodies.size();
const PxU32 nbSoftBodyWoken = mWokeSoftBodies.size();
return PxMax(PxMax(nbSoftBodyWoken, nbHairSystemWoken), PxMax(nbSoftBodySleep, nbHairSystemSleep));
}
void Sc::Scene::gpu_fireOnSleepCallback(PxActor** actors)
{
//ML: need to create and API for the onSleep for softbody
const PxU32 nbSoftBodySleep = mSleepSoftBodies.size();
if (nbSoftBodySleep)
{
PxU32 destSlot = 0;
SoftBodyCore* const* sleepingSoftBodies = mSleepSoftBodies.getEntries();
for (PxU32 i = 0; i<nbSoftBodySleep; i++)
{
SoftBodyCore* body = sleepingSoftBodies[i];
if (body->getActorFlags() & PxActorFlag::eSEND_SLEEP_NOTIFIES)
actors[destSlot++] = body->getPxActor();
if (mOnSleepingStateChanged)
mOnSleepingStateChanged(*static_cast<physx::PxRigidDynamic*>(body->getPxActor()), true);
}
if (destSlot && mSimulationEventCallback)
mSimulationEventCallback->onSleep(actors, destSlot);
}
const PxU32 nbHairSystemSleep = mSleepHairSystems.size();
if (nbHairSystemSleep)
{
PxU32 destSlot = 0;
HairSystemCore* const* sleepingHairSystems = mSleepHairSystems.getEntries();
for (PxU32 i = 0; i<nbHairSystemSleep; i++)
{
HairSystemCore* body = sleepingHairSystems[i];
if (body->getActorFlags() & PxActorFlag::eSEND_SLEEP_NOTIFIES)
actors[destSlot++] = body->getPxActor();
if (mOnSleepingStateChanged)
mOnSleepingStateChanged(*static_cast<physx::PxRigidDynamic*>(body->getPxActor()), true);
}
if (destSlot && mSimulationEventCallback)
mSimulationEventCallback->onSleep(actors, destSlot);
}
}
void Sc::Scene::gpu_fireOnWakeCallback(PxActor** actors)
{
//ML: need to create an API for woken soft body
const PxU32 nbSoftBodyWoken = mWokeSoftBodies.size();
if (nbSoftBodyWoken)
{
PxU32 destSlot = 0;
SoftBodyCore* const* wokenSoftBodies = mWokeSoftBodies.getEntries();
for (PxU32 i = 0; i<nbSoftBodyWoken; i++)
{
SoftBodyCore* body = wokenSoftBodies[i];
if (body->getActorFlags() & PxActorFlag::eSEND_SLEEP_NOTIFIES)
actors[destSlot++] = body->getPxActor();
if (mOnSleepingStateChanged)
mOnSleepingStateChanged(*static_cast<physx::PxRigidDynamic*>(body->getPxActor()), false);
}
if (destSlot && mSimulationEventCallback)
mSimulationEventCallback->onWake(actors, destSlot);
}
const PxU32 nbHairSystemWoken = mWokeHairSystems.size();
if (nbHairSystemWoken)
{
PxU32 destSlot = 0;
HairSystemCore* const* wokenHairSystems = mWokeHairSystems.getEntries();
for (PxU32 i = 0; i<nbHairSystemWoken; i++)
{
HairSystemCore* body = wokenHairSystems[i];
if (body->getActorFlags() & PxActorFlag::eSEND_SLEEP_NOTIFIES)
actors[destSlot++] = body->getPxActor();
if (mOnSleepingStateChanged)
mOnSleepingStateChanged(*static_cast<physx::PxRigidDynamic*>(body->getPxActor()), false);
}
if (destSlot && mSimulationEventCallback)
mSimulationEventCallback->onWake(actors, destSlot);
}
}
void Sc::Scene::gpu_updateBounds()
{
//update soft bodies world bound
Sc::SoftBodyCore* const* softBodies = mSoftBodies.getEntries();
PxU32 size = mSoftBodies.size();
if (mUseGpuBp)
{
for (PxU32 i = 0; i < size; ++i)
softBodies[i]->getSim()->updateBoundsInAABBMgr();
}
else
{
for (PxU32 i = 0; i < size; ++i)
softBodies[i]->getSim()->updateBounds();
}
// update FEM-cloth world bound
Sc::FEMClothCore* const* femCloths = mFEMCloths.getEntries();
size = mFEMCloths.size();
if (mUseGpuBp)
{
for (PxU32 i = 0; i < size; ++i)
femCloths[i]->getSim()->updateBoundsInAABBMgr();
}
else
{
for (PxU32 i = 0; i < size; ++i)
femCloths[i]->getSim()->updateBounds();
}
//upate the actor handle of particle system in AABB manager
Sc::ParticleSystemCore* const* particleSystems = mParticleSystems.getEntries();
size = mParticleSystems.size();
if (mUseGpuBp)
{
for (PxU32 i = 0; i < size; ++i)
particleSystems[i]->getSim()->updateBoundsInAABBMgr();
}
else
{
for (PxU32 i = 0; i < size; ++i)
particleSystems[i]->getSim()->updateBounds();
}
//update hair system world bound
Sc::HairSystemCore* const* hairSystems = mHairSystems.getEntries();
PxU32 nHairSystems = mHairSystems.size();
if (mUseGpuBp)
{
for (PxU32 i = 0; i < nHairSystems; ++i)
hairSystems[i]->getSim()->updateBoundsInAABBMgr();
}
else
{
for (PxU32 i = 0; i < nHairSystems; ++i)
hairSystems[i]->getSim()->updateBounds();
}
}
void Sc::Scene::addSoftBody(SoftBodyCore& softBody)
{
SoftBodySim* sim = PX_NEW(SoftBodySim)(softBody, *this);
if (sim && (sim->getLowLevelSoftBody() == NULL))
{
PX_DELETE(sim);
return;
}
mSoftBodies.insert(&softBody);
mStats->gpuMemSizeSoftBodies += softBody.getGpuMemStat();
}
void Sc::Scene::removeSoftBody(SoftBodyCore& softBody)
{
SoftBodySim* a = softBody.getSim();
PX_DELETE(a);
mSoftBodies.erase(&softBody);
mStats->gpuMemSizeSoftBodies -= softBody.getGpuMemStat();
}
void Sc::Scene::addFEMCloth(FEMClothCore& femCloth)
{
FEMClothSim* sim = PX_NEW(FEMClothSim)(femCloth, *this);
if (sim && (sim->getLowLevelFEMCloth() == NULL))
{
PX_DELETE(sim);
return;
}
mFEMCloths.insert(&femCloth);
mStats->gpuMemSizeFEMCloths += femCloth.getGpuMemStat();
}
void Sc::Scene::removeFEMCloth(FEMClothCore& femCloth)
{
FEMClothSim* a = femCloth.getSim();
PX_DELETE(a);
mFEMCloths.erase(&femCloth);
mStats->gpuMemSizeFEMCloths -= femCloth.getGpuMemStat();
}
void Sc::Scene::addParticleSystem(ParticleSystemCore& particleSystem)
{
ParticleSystemSim* sim = PX_NEW(ParticleSystemSim)(particleSystem, *this);
Dy::ParticleSystem* dyParticleSystem = sim->getLowLevelParticleSystem();
if (sim && (dyParticleSystem == NULL))
{
PX_DELETE(sim);
return;
}
mParticleSystems.insert(&particleSystem);
mStats->gpuMemSizeParticles += particleSystem.getShapeCore().getGpuMemStat();
}
void Sc::Scene::removeParticleSystem(ParticleSystemCore& particleSystem)
{
ParticleSystemSim* a = particleSystem.getSim();
PX_DELETE(a);
mParticleSystems.erase(&particleSystem);
mStats->gpuMemSizeParticles -= particleSystem.getShapeCore().getGpuMemStat();
}
void Sc::Scene::addHairSystem(HairSystemCore& hairSystem)
{
HairSystemSim* sim = PX_NEW(HairSystemSim)(hairSystem, *this);
if (sim && (sim->getLowLevelHairSystem() == NULL))
{
PX_DELETE(sim);
return;
}
mHairSystems.insert(&hairSystem);
mStats->gpuMemSizeHairSystems += hairSystem.getShapeCore().getGpuMemStat();
}
void Sc::Scene::removeHairSystem(HairSystemCore& hairSystem)
{
HairSystemSim* sim = hairSystem.getSim();
PX_DELETE(sim);
mHairSystems.erase(&hairSystem);
mStats->gpuMemSizeHairSystems -= hairSystem.getShapeCore().getGpuMemStat();
}
Dy::SoftBody* Sc::Scene::createLLSoftBody(Sc::SoftBodySim* sim)
{
return mLLSoftBodyPool->construct(sim, sim->getCore().getCore());
}
void Sc::Scene::destroyLLSoftBody(Dy::SoftBody& softBody)
{
mLLSoftBodyPool->destroy(&softBody);
}
Dy::FEMCloth* Sc::Scene::createLLFEMCloth(Sc::FEMClothSim* sim)
{
return mLLFEMClothPool->construct(sim, sim->getCore().getCore());
}
void Sc::Scene::destroyLLFEMCloth(Dy::FEMCloth& femCloth)
{
mLLFEMClothPool->destroy(&femCloth);
}
Dy::ParticleSystem* Sc::Scene::createLLParticleSystem(Sc::ParticleSystemSim* sim)
{
return mLLParticleSystemPool->construct(sim->getCore().getShapeCore().getLLCore());
}
void Sc::Scene::destroyLLParticleSystem(Dy::ParticleSystem& particleSystem)
{
return mLLParticleSystemPool->destroy(&particleSystem);
}
Dy::HairSystem* Sc::Scene::createLLHairSystem(Sc::HairSystemSim* sim)
{
return mLLHairSystemPool->construct(sim, sim->getCore().getShapeCore().getLLCore());
}
void Sc::Scene::destroyLLHairSystem(Dy::HairSystem& hairSystem)
{
mLLHairSystemPool->destroy(&hairSystem);
}
void Sc::Scene::cleanUpSleepHairSystems()
{
HairSystemCore* const* hairSystemArray = mSleepHairSystems.getEntries();
PxU32 bodyCount = mSleepBodies.size();
IG::IslandSim& islandSim = mSimpleIslandManager->getAccurateIslandSim();
while (bodyCount--)
{
HairSystemSim* hairSystem = hairSystemArray[bodyCount]->getSim();
if (hairSystem->readInternalFlag(static_cast<BodySim::InternalFlags>(ActorSim::BF_WAKEUP_NOTIFY)))
{
hairSystem->clearInternalFlag(static_cast<BodySim::InternalFlags>(ActorSim::BF_IS_IN_WAKEUP_LIST));
mSleepHairSystems.erase(hairSystemArray[bodyCount]);
}
else if (islandSim.getNode(hairSystem->getNodeIndex()).isActive())
{
//This hairSystem is still active in the island simulation, so the request to deactivate the actor by the application must have failed. Recover by undoing this
mSleepHairSystems.erase(hairSystemArray[bodyCount]);
hairSystem->internalWakeUp();
}
}
mSleepBodyListValid = true;
}
void Sc::Scene::cleanUpWokenHairSystems()
{
cleanUpSleepOrWokenHairSystems(mWokeHairSystems, BodySim::BF_SLEEP_NOTIFY, mWokeHairSystemListValid);
}
void Sc::Scene::cleanUpSleepOrWokenHairSystems(PxCoalescedHashSet<HairSystemCore*>& bodyList, PxU32 removeFlag, bool& validMarker)
{
HairSystemCore* const* hairSystemArray = bodyList.getEntries();
PxU32 bodyCount = bodyList.size();
while (bodyCount--)
{
HairSystemSim* hairSystem = hairSystemArray[bodyCount]->getSim();
if (hairSystem->readInternalFlag(static_cast<BodySim::InternalFlags>(removeFlag)))
bodyList.erase(hairSystemArray[bodyCount]);
}
validMarker = true;
}
PX_INLINE void Sc::Scene::cleanUpSleepSoftBodies()
{
SoftBodyCore* const* bodyArray = mSleepSoftBodies.getEntries();
PxU32 bodyCount = mSleepBodies.size();
IG::IslandSim& islandSim = mSimpleIslandManager->getAccurateIslandSim();
while (bodyCount--)
{
SoftBodySim* body = bodyArray[bodyCount]->getSim();
if (body->readInternalFlag(static_cast<BodySim::InternalFlags>(ActorSim::BF_WAKEUP_NOTIFY)))
{
body->clearInternalFlag(static_cast<BodySim::InternalFlags>(ActorSim::BF_IS_IN_WAKEUP_LIST));
mSleepSoftBodies.erase(bodyArray[bodyCount]);
}
else if (islandSim.getNode(body->getNodeIndex()).isActive())
{
//This body is still active in the island simulation, so the request to deactivate the actor by the application must have failed. Recover by undoing this
mSleepSoftBodies.erase(bodyArray[bodyCount]);
body->internalWakeUp();
}
}
mSleepBodyListValid = true;
}
PX_INLINE void Sc::Scene::cleanUpWokenSoftBodies()
{
cleanUpSleepOrWokenSoftBodies(mWokeSoftBodies, BodySim::BF_SLEEP_NOTIFY, mWokeSoftBodyListValid);
}
PX_INLINE void Sc::Scene::cleanUpSleepOrWokenSoftBodies(PxCoalescedHashSet<SoftBodyCore*>& bodyList, PxU32 removeFlag, bool& validMarker)
{
// With our current logic it can happen that a body is added to the sleep as well as the woken body list in the
// same frame.
//
// Examples:
// - Kinematic is created (added to woken list) but has not target (-> deactivation -> added to sleep list)
// - Dynamic is created (added to woken list) but is forced to sleep by user (-> deactivation -> added to sleep list)
//
// This code traverses the sleep/woken body list and removes bodies which have been initially added to the given
// list but do not belong to it anymore.
SoftBodyCore* const* bodyArray = bodyList.getEntries();
PxU32 bodyCount = bodyList.size();
while (bodyCount--)
{
SoftBodySim* body = bodyArray[bodyCount]->getSim();
if (body->readInternalFlag(static_cast<BodySim::InternalFlags>(removeFlag)))
bodyList.erase(bodyArray[bodyCount]);
}
validMarker = true;
}
void Sc::Scene::addSoftBodySimControl(Sc::SoftBodyCore& core)
{
Sc::SoftBodySim* sim = core.getSim();
if (sim)
{
mSimulationController->addSoftBody(sim->getLowLevelSoftBody(), sim->getNodeIndex());
mLLContext->getNphaseImplementationContext()->registerShape(sim->getNodeIndex(), sim->getShapeSim().getCore().getCore(), sim->getShapeSim().getElementID(), sim->getPxActor());
}
}
void Sc::Scene::removeSoftBodySimControl(Sc::SoftBodyCore& core)
{
Sc::SoftBodySim* sim = core.getSim();
if (sim)
{
mLLContext->getNphaseImplementationContext()->unregisterShape(sim->getShapeSim().getCore().getCore(), sim->getShapeSim().getElementID());
mSimulationController->releaseSoftBody(sim->getLowLevelSoftBody());
}
}
void Sc::Scene::addFEMClothSimControl(Sc::FEMClothCore& core)
{
Sc::FEMClothSim* sim = core.getSim();
if (sim)
{
mSimulationController->addFEMCloth(sim->getLowLevelFEMCloth(), sim->getNodeIndex());
mLLContext->getNphaseImplementationContext()->registerShape(sim->getNodeIndex(), sim->getShapeSim().getCore().getCore(), sim->getShapeSim().getElementID(), sim->getPxActor(), true);
}
}
void Sc::Scene::removeFEMClothSimControl(Sc::FEMClothCore& core)
{
Sc::FEMClothSim* sim = core.getSim();
if (sim)
{
mLLContext->getNphaseImplementationContext()->unregisterShape(sim->getShapeSim().getCore().getCore(), sim->getShapeSim().getElementID(), true);
mSimulationController->releaseFEMCloth(sim->getLowLevelFEMCloth());
}
}
void Sc::Scene::addParticleFilter(Sc::ParticleSystemCore* core, SoftBodySim& sim, PxU32 particleId, PxU32 userBufferId, PxU32 tetId)
{
mSimulationController->addParticleFilter(sim.getLowLevelSoftBody(), core->getSim()->getLowLevelParticleSystem(),
particleId, userBufferId, tetId);
}
void Sc::Scene::removeParticleFilter(Sc::ParticleSystemCore* core, SoftBodySim& sim, PxU32 particleId, PxU32 userBufferId, PxU32 tetId)
{
mSimulationController->removeParticleFilter(sim.getLowLevelSoftBody(), core->getSim()->getLowLevelParticleSystem(), particleId, userBufferId, tetId);
}
PxU32 Sc::Scene::addParticleAttachment(Sc::ParticleSystemCore* core, SoftBodySim& sim, PxU32 particleId, PxU32 userBufferId, PxU32 tetId, const PxVec4& barycentric)
{
PxNodeIndex nodeIndex = core->getSim()->getNodeIndex();
PxU32 handle = mSimulationController->addParticleAttachment(sim.getLowLevelSoftBody(), core->getSim()->getLowLevelParticleSystem(),
particleId, userBufferId, tetId, barycentric, sim.isActive());
PxPair<PxU32, PxU32> pair(sim.getNodeIndex().index(), nodeIndex.index());
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
if (interaction.mCount == 0)
{
IG::EdgeIndex edgeIdx = mSimpleIslandManager->addContactManager(NULL, sim.getNodeIndex(), nodeIndex, NULL, IG::Edge::eSOFT_BODY_CONTACT);
mSimpleIslandManager->setEdgeConnected(edgeIdx, IG::Edge::eSOFT_BODY_CONTACT);
interaction.mIndex = edgeIdx;
}
interaction.mCount++;
return handle;
}
void Sc::Scene::removeParticleAttachment(Sc::ParticleSystemCore* core, SoftBodySim& sim, PxU32 handle)
{
PxNodeIndex nodeIndex = core->getSim()->getNodeIndex();
mSimulationController->removeParticleAttachment(sim.getLowLevelSoftBody(), handle);
PxPair<PxU32, PxU32> pair(sim.getNodeIndex().index(), nodeIndex.index());
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
interaction.mCount--;
if (interaction.mCount == 0)
{
mSimpleIslandManager->removeConnection(interaction.mIndex);
mParticleOrSoftBodyRigidInteractionMap.erase(pair);
}
}
void Sc::Scene::addAttachment(const Sc::SoftBodySim& sbSim, const Sc::HairSystemSim& hairSim)
{
const PxPair<PxU32, PxU32> pair(sbSim.getNodeIndex().index(), hairSim.getNodeIndex().index());
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
if (interaction.mCount == 0)
{
IG::EdgeIndex edgeIdx = mSimpleIslandManager->addContactManager(NULL, sbSim.getNodeIndex(), hairSim.getNodeIndex(), NULL, IG::Edge::eHAIR_SYSTEM_CONTACT);
mSimpleIslandManager->setEdgeConnected(edgeIdx, IG::Edge::eHAIR_SYSTEM_CONTACT);
interaction.mIndex = edgeIdx;
}
interaction.mCount++;
}
void Sc::Scene::removeAttachment(const Sc::SoftBodySim& sbSim, const Sc::HairSystemSim& hairSim)
{
const PxPair<PxU32, PxU32> pair(sbSim.getNodeIndex().index(), hairSim.getNodeIndex().index());
if(mParticleOrSoftBodyRigidInteractionMap.find(pair)) // find returns pointer to const so we cannot use it directly
{
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
PX_ASSERT(interaction.mCount > 0);
interaction.mCount--;
if(interaction.mCount == 0)
{
mSimpleIslandManager->removeConnection(interaction.mIndex);
mParticleOrSoftBodyRigidInteractionMap.erase(pair);
}
}
}
void Sc::Scene::addRigidFilter(Sc::BodyCore* core, Sc::SoftBodySim& sim, PxU32 vertId)
{
PxNodeIndex nodeIndex;
if (core)
{
nodeIndex = core->getSim()->getNodeIndex();
}
mSimulationController->addRigidFilter(sim.getLowLevelSoftBody(), nodeIndex, vertId);
}
void Sc::Scene::removeRigidFilter(Sc::BodyCore* core, Sc::SoftBodySim& sim, PxU32 vertId)
{
PxNodeIndex nodeIndex;
if (core)
{
nodeIndex = core->getSim()->getNodeIndex();
}
mSimulationController->removeRigidFilter(sim.getLowLevelSoftBody(), nodeIndex, vertId);
}
PxU32 Sc::Scene::addRigidAttachment(Sc::BodyCore* core, Sc::SoftBodySim& sim, PxU32 vertId, const PxVec3& actorSpacePose,
PxConeLimitedConstraint* constraint)
{
PxNodeIndex nodeIndex;
PxsRigidBody* body = NULL;
if (core)
{
nodeIndex = core->getSim()->getNodeIndex();
body = &core->getSim()->getLowLevelBody();
}
PxU32 handle = mSimulationController->addRigidAttachment(sim.getLowLevelSoftBody(), sim.getNodeIndex(), body,
nodeIndex, vertId, actorSpacePose, constraint, sim.isActive());
PxPair<PxU32, PxU32> pair(sim.getNodeIndex().index(), nodeIndex.index());
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
if (interaction.mCount == 0)
{
IG::EdgeIndex edgeIdx = mSimpleIslandManager->addContactManager(NULL, sim.getNodeIndex(), nodeIndex, NULL, IG::Edge::eSOFT_BODY_CONTACT);
mSimpleIslandManager->setEdgeConnected(edgeIdx, IG::Edge::eSOFT_BODY_CONTACT);
interaction.mIndex = edgeIdx;
}
interaction.mCount++;
return handle;
}
void Sc::Scene::removeRigidAttachment(Sc::BodyCore* core, Sc::SoftBodySim& sim, PxU32 handle)
{
PxNodeIndex nodeIndex;
if (core)
{
nodeIndex = core->getSim()->getNodeIndex();
}
mSimulationController->removeRigidAttachment(sim.getLowLevelSoftBody(), handle);
PxPair<PxU32, PxU32> pair(sim.getNodeIndex().index(), nodeIndex.index());
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
interaction.mCount--;
if (interaction.mCount == 0)
{
mSimpleIslandManager->removeConnection(interaction.mIndex);
mParticleOrSoftBodyRigidInteractionMap.erase(pair);
}
}
void Sc::Scene::addTetRigidFilter(Sc::BodyCore* core, Sc::SoftBodySim& sim, PxU32 tetIdx)
{
PxNodeIndex nodeIndex;
if (core)
{
nodeIndex = core->getSim()->getNodeIndex();
}
mSimulationController->addTetRigidFilter(sim.getLowLevelSoftBody(), nodeIndex, tetIdx);
}
void Sc::Scene::removeTetRigidFilter(Sc::BodyCore* core, Sc::SoftBodySim& sim, PxU32 tetIdx)
{
PxNodeIndex nodeIndex;
if (core)
{
nodeIndex = core->getSim()->getNodeIndex();
}
mSimulationController->removeTetRigidFilter(sim.getLowLevelSoftBody(), nodeIndex, tetIdx);
}
PxU32 Sc::Scene::addTetRigidAttachment(Sc::BodyCore* core, Sc::SoftBodySim& sim, PxU32 tetIdx, const PxVec4& barycentric, const PxVec3& actorSpacePose,
PxConeLimitedConstraint* constraint)
{
PxNodeIndex nodeIndex;
PxsRigidBody* body = NULL;
if (core)
{
nodeIndex = core->getSim()->getNodeIndex();
body = &core->getSim()->getLowLevelBody();
}
PxU32 handle = mSimulationController->addTetRigidAttachment(sim.getLowLevelSoftBody(), body, nodeIndex,
tetIdx, barycentric, actorSpacePose, constraint, sim.isActive());
PxPair<PxU32, PxU32> pair(sim.getNodeIndex().index(), nodeIndex.index());
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
if (interaction.mCount == 0)
{
IG::EdgeIndex edgeIdx = mSimpleIslandManager->addContactManager(NULL, sim.getNodeIndex(), nodeIndex, NULL, IG::Edge::eSOFT_BODY_CONTACT);
mSimpleIslandManager->setEdgeConnected(edgeIdx, IG::Edge::eSOFT_BODY_CONTACT);
interaction.mIndex = edgeIdx;
}
interaction.mCount++;
return handle;
}
void Sc::Scene::addSoftBodyFilter(SoftBodyCore& core, PxU32 tetIdx0, SoftBodySim& sim, PxU32 tetIdx1)
{
Sc::SoftBodySim& bSim = *core.getSim();
mSimulationController->addSoftBodyFilter(bSim.getLowLevelSoftBody(), sim.getLowLevelSoftBody(), tetIdx0, tetIdx1);
}
void Sc::Scene::removeSoftBodyFilter(SoftBodyCore& core, PxU32 tetIdx0, SoftBodySim& sim, PxU32 tetIdx1)
{
Sc::SoftBodySim& bSim = *core.getSim();
mSimulationController->removeSoftBodyFilter(bSim.getLowLevelSoftBody(), sim.getLowLevelSoftBody(), tetIdx0, tetIdx1);
}
void Sc::Scene::addSoftBodyFilters(SoftBodyCore& core, SoftBodySim& sim, PxU32* tetIndices0, PxU32* tetIndices1, PxU32 tetIndicesSize)
{
Sc::SoftBodySim& bSim = *core.getSim();
mSimulationController->addSoftBodyFilters(bSim.getLowLevelSoftBody(), sim.getLowLevelSoftBody(), tetIndices0, tetIndices1, tetIndicesSize);
}
void Sc::Scene::removeSoftBodyFilters(SoftBodyCore& core, SoftBodySim& sim, PxU32* tetIndices0, PxU32* tetIndices1, PxU32 tetIndicesSize)
{
Sc::SoftBodySim& bSim = *core.getSim();
mSimulationController->removeSoftBodyFilters(bSim.getLowLevelSoftBody(), sim.getLowLevelSoftBody(), tetIndices0, tetIndices1, tetIndicesSize);
}
PxU32 Sc::Scene::addSoftBodyAttachment(SoftBodyCore& core, PxU32 tetIdx0, const PxVec4& tetBarycentric0, Sc::SoftBodySim& sim, PxU32 tetIdx1, const PxVec4& tetBarycentric1,
PxConeLimitedConstraint* constraint, PxReal constraintOffset)
{
Sc::SoftBodySim& bSim = *core.getSim();
PxU32 handle = mSimulationController->addSoftBodyAttachment(bSim.getLowLevelSoftBody(), sim.getLowLevelSoftBody(), tetIdx0, tetIdx1,
tetBarycentric0, tetBarycentric1, constraint, constraintOffset, sim.isActive() || bSim.isActive());
PxPair<PxU32, PxU32> pair(sim.getNodeIndex().index(), bSim.getNodeIndex().index());
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
if (interaction.mCount == 0)
{
IG::EdgeIndex edgeIdx = mSimpleIslandManager->addContactManager(NULL, sim.getNodeIndex(), bSim.getNodeIndex(), NULL, IG::Edge::eSOFT_BODY_CONTACT);
mSimpleIslandManager->setEdgeConnected(edgeIdx, IG::Edge::eSOFT_BODY_CONTACT);
interaction.mIndex = edgeIdx;
}
interaction.mCount++;
return handle;
}
void Sc::Scene::removeSoftBodyAttachment(SoftBodyCore& core, Sc::SoftBodySim& sim, PxU32 handle)
{
Sc::SoftBodySim& bSim = *core.getSim();
mSimulationController->removeSoftBodyAttachment(bSim.getLowLevelSoftBody(), handle);
PxPair<PxU32, PxU32> pair(sim.getNodeIndex().index(), bSim.getNodeIndex().index());
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
interaction.mCount--;
if (interaction.mCount == 0)
{
mSimpleIslandManager->removeConnection(interaction.mIndex);
mParticleOrSoftBodyRigidInteractionMap.erase(pair);
}
}
void Sc::Scene::addClothFilter(Sc::FEMClothCore& core, PxU32 triIdx, Sc::SoftBodySim& sim, PxU32 tetIdx)
{
Sc::FEMClothSim& bSim = *core.getSim();
mSimulationController->addClothFilter(sim.getLowLevelSoftBody(), bSim.getLowLevelFEMCloth(), triIdx,tetIdx);
}
void Sc::Scene::removeClothFilter(Sc::FEMClothCore& core, PxU32 triIdx, Sc::SoftBodySim& sim, PxU32 tetIdx)
{
Sc::FEMClothSim& bSim = *core.getSim();
mSimulationController->removeClothFilter(sim.getLowLevelSoftBody(), bSim.getLowLevelFEMCloth(), triIdx, tetIdx);
}
void Sc::Scene::addVertClothFilter(Sc::FEMClothCore& core, PxU32 vertIdx, Sc::SoftBodySim& sim, PxU32 tetIdx)
{
Sc::FEMClothSim& bSim = *core.getSim();
mSimulationController->addVertClothFilter(sim.getLowLevelSoftBody(), bSim.getLowLevelFEMCloth(), vertIdx, tetIdx);
}
void Sc::Scene::removeVertClothFilter(Sc::FEMClothCore& core, PxU32 vertIdx, Sc::SoftBodySim& sim, PxU32 tetIdx)
{
Sc::FEMClothSim& bSim = *core.getSim();
mSimulationController->removeVertClothFilter(sim.getLowLevelSoftBody(), bSim.getLowLevelFEMCloth(), vertIdx, tetIdx);
}
PxU32 Sc::Scene::addClothAttachment(Sc::FEMClothCore& core, PxU32 triIdx, const PxVec4& triBarycentric, Sc::SoftBodySim& sim, PxU32 tetIdx,
const PxVec4& tetBarycentric, PxConeLimitedConstraint* constraint, PxReal constraintOffset)
{
Sc::FEMClothSim& bSim = *core.getSim();
PxU32 handle = mSimulationController->addClothAttachment(sim.getLowLevelSoftBody(), bSim.getLowLevelFEMCloth(), triIdx, triBarycentric,
tetIdx, tetBarycentric, constraint, constraintOffset, sim.isActive());
PxPair<PxU32, PxU32> pair(sim.getNodeIndex().index(), bSim.getNodeIndex().index());
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
if (interaction.mCount == 0)
{
IG::EdgeIndex edgeIdx = mSimpleIslandManager->addContactManager(NULL, sim.getNodeIndex(), bSim.getNodeIndex(), NULL, IG::Edge::eFEM_CLOTH_CONTACT);
mSimpleIslandManager->setEdgeConnected(edgeIdx, IG::Edge::eFEM_CLOTH_CONTACT);
interaction.mIndex = edgeIdx;
}
interaction.mCount++;
return handle;
}
void Sc::Scene::removeClothAttachment(Sc::FEMClothCore& core, Sc::SoftBodySim& sim, PxU32 handle)
{
PX_UNUSED(core);
Sc::FEMClothSim& bSim = *core.getSim();
mSimulationController->removeClothAttachment(sim.getLowLevelSoftBody(), handle);
PxPair<PxU32, PxU32> pair(sim.getNodeIndex().index(), bSim.getNodeIndex().index());
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
interaction.mCount--;
if (interaction.mCount == 0)
{
mSimpleIslandManager->removeConnection(interaction.mIndex);
mParticleOrSoftBodyRigidInteractionMap.erase(pair);
}
}
void Sc::Scene::addRigidFilter(Sc::BodyCore* core, Sc::FEMClothSim& sim, PxU32 vertId)
{
PxNodeIndex nodeIndex;
if (core)
{
nodeIndex = core->getSim()->getNodeIndex();
}
mSimulationController->addRigidFilter(sim.getLowLevelFEMCloth(), nodeIndex, vertId);
}
void Sc::Scene::removeRigidFilter(Sc::BodyCore* core, Sc::FEMClothSim& sim, PxU32 vertId)
{
PxNodeIndex nodeIndex;
if (core)
{
nodeIndex = core->getSim()->getNodeIndex();
}
mSimulationController->removeRigidFilter(sim.getLowLevelFEMCloth(), nodeIndex, vertId);
}
PxU32 Sc::Scene::addRigidAttachment(Sc::BodyCore* core, Sc::FEMClothSim& sim, PxU32 vertId, const PxVec3& actorSpacePose, PxConeLimitedConstraint* constraint)
{
PxNodeIndex nodeIndex;
PxsRigidBody* body = NULL;
if (core)
{
nodeIndex = core->getSim()->getNodeIndex();
body = &core->getSim()->getLowLevelBody();
}
PxU32 handle = mSimulationController->addRigidAttachment(sim.getLowLevelFEMCloth(), sim.getNodeIndex(), body, nodeIndex,
vertId, actorSpacePose, constraint, sim.isActive());
PxPair<PxU32, PxU32> pair(sim.getNodeIndex().index(), nodeIndex.index());
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
if (interaction.mCount == 0)
{
IG::EdgeIndex edgeIdx = mSimpleIslandManager->addContactManager(NULL, sim.getNodeIndex(), nodeIndex, NULL, IG::Edge::eFEM_CLOTH_CONTACT);
mSimpleIslandManager->setEdgeConnected(edgeIdx, IG::Edge::eFEM_CLOTH_CONTACT);
interaction.mIndex = edgeIdx;
}
interaction.mCount++;
return handle;
}
void Sc::Scene::removeRigidAttachment(Sc::BodyCore* core, Sc::FEMClothSim& sim, PxU32 handle)
{
PxNodeIndex nodeIndex;
if (core)
{
nodeIndex = core->getSim()->getNodeIndex();
}
mSimulationController->removeRigidAttachment(sim.getLowLevelFEMCloth(), handle);
PxPair<PxU32, PxU32> pair(sim.getNodeIndex().index(), nodeIndex.index());
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
interaction.mCount--;
if (interaction.mCount == 0)
{
mSimpleIslandManager->removeConnection(interaction.mIndex);
mParticleOrSoftBodyRigidInteractionMap.erase(pair);
}
}
void Sc::Scene::addTriRigidFilter(Sc::BodyCore* core, Sc::FEMClothSim& sim, PxU32 triIdx)
{
PxNodeIndex nodeIndex;
if (core)
{
nodeIndex = core->getSim()->getNodeIndex();
}
mSimulationController->addTriRigidFilter(sim.getLowLevelFEMCloth(), nodeIndex, triIdx);
}
void Sc::Scene::removeTriRigidFilter(Sc::BodyCore* core, Sc::FEMClothSim& sim, PxU32 triIdx)
{
PxNodeIndex nodeIndex;
if (core)
{
nodeIndex = core->getSim()->getNodeIndex();
}
mSimulationController->removeTriRigidFilter(sim.getLowLevelFEMCloth(), nodeIndex, triIdx);
}
PxU32 Sc::Scene::addTriRigidAttachment(Sc::BodyCore* core, Sc::FEMClothSim& sim, PxU32 triIdx, const PxVec4& barycentric, const PxVec3& actorSpacePose, PxConeLimitedConstraint* constraint)
{
PxNodeIndex nodeIndex;
PxsRigidBody* body = NULL;
if (core)
{
nodeIndex = core->getSim()->getNodeIndex();
body = &core->getSim()->getLowLevelBody();
}
PxU32 handle = mSimulationController->addTriRigidAttachment(sim.getLowLevelFEMCloth(), body, nodeIndex,
triIdx, barycentric, actorSpacePose, constraint, sim.isActive());
PxPair<PxU32, PxU32> pair(sim.getNodeIndex().index(), nodeIndex.index());
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
if (interaction.mCount == 0)
{
IG::EdgeIndex edgeIdx = mSimpleIslandManager->addContactManager(NULL, sim.getNodeIndex(), nodeIndex, NULL, IG::Edge::eFEM_CLOTH_CONTACT);
mSimpleIslandManager->setEdgeConnected(edgeIdx, IG::Edge::eFEM_CLOTH_CONTACT);
interaction.mIndex = edgeIdx;
}
interaction.mCount++;
return handle;
}
void Sc::Scene::removeTriRigidAttachment(Sc::BodyCore* core, Sc::FEMClothSim& sim, PxU32 handle)
{
PxNodeIndex nodeIndex;
if (core)
{
nodeIndex = core->getSim()->getNodeIndex();
}
mSimulationController->removeTriRigidAttachment(sim.getLowLevelFEMCloth(), handle);
PxPair<PxU32, PxU32> pair(sim.getNodeIndex().index(), nodeIndex.index());
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
interaction.mCount--;
if (interaction.mCount == 0)
{
mSimpleIslandManager->removeConnection(interaction.mIndex);
mParticleOrSoftBodyRigidInteractionMap.erase(pair);
}
}
void Sc::Scene::addClothFilter(FEMClothCore& core0, PxU32 triIdx0, Sc::FEMClothSim& sim1, PxU32 triIdx1)
{
Sc::FEMClothSim& sim0 = *core0.getSim();
mSimulationController->addClothFilter(sim0.getLowLevelFEMCloth(), sim1.getLowLevelFEMCloth(), triIdx0, triIdx1);
}
void Sc::Scene::removeClothFilter(FEMClothCore& core, PxU32 triIdx0, FEMClothSim& sim1, PxU32 triIdx1)
{
Sc::FEMClothSim& sim0 = *core.getSim();
mSimulationController->removeClothFilter(sim0.getLowLevelFEMCloth(), sim1.getLowLevelFEMCloth(), triIdx0, triIdx1);
}
PxU32 Sc::Scene::addTriClothAttachment(FEMClothCore& core, PxU32 triIdx0, const PxVec4& barycentric0, Sc::FEMClothSim& sim1, PxU32 triIdx1, const PxVec4& barycentric1)
{
Sc::FEMClothSim& sim0 = *core.getSim();
PxU32 handle = mSimulationController->addTriClothAttachment(sim0.getLowLevelFEMCloth(), sim1.getLowLevelFEMCloth(), triIdx0, triIdx1,
barycentric0, barycentric1, sim1.isActive() || sim0.isActive());
//return handle;
PxPair<PxU32, PxU32> pair(sim0.getNodeIndex().index(), sim1.getNodeIndex().index());
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
if (interaction.mCount == 0)
{
IG::EdgeIndex edgeIdx = mSimpleIslandManager->addContactManager(NULL, sim0.getNodeIndex(), sim1.getNodeIndex(), NULL, IG::Edge::eFEM_CLOTH_CONTACT);
mSimpleIslandManager->setEdgeConnected(edgeIdx, IG::Edge::eFEM_CLOTH_CONTACT);
interaction.mIndex = edgeIdx;
}
interaction.mCount++;
return handle;
}
void Sc::Scene::removeTriClothAttachment(FEMClothCore& core, FEMClothSim& sim1, PxU32 handle)
{
Sc::FEMClothSim& sim0 = *core.getSim();
mSimulationController->removeTriClothAttachment(sim0.getLowLevelFEMCloth(), handle);
PxPair<PxU32, PxU32> pair(sim0.getNodeIndex().index(), sim1.getNodeIndex().index());
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
interaction.mCount--;
if (interaction.mCount == 0)
{
mSimpleIslandManager->removeConnection(interaction.mIndex);
mParticleOrSoftBodyRigidInteractionMap.erase(pair);
}
}
void Sc::Scene::addParticleSystemSimControl(Sc::ParticleSystemCore& core)
{
Sc::ParticleSystemSim* sim = core.getSim();
if (sim)
{
mSimulationController->addParticleSystem(sim->getLowLevelParticleSystem(), sim->getNodeIndex(), core.getSolverType());
mLLContext->getNphaseImplementationContext()->registerShape(sim->getNodeIndex(), sim->getCore().getShapeCore().getCore(), sim->getLowLevelParticleSystem()->getElementId(), sim->getPxActor());
}
}
void Sc::Scene::removeParticleSystemSimControl(Sc::ParticleSystemCore& core)
{
Sc::ParticleSystemSim* sim = core.getSim();
if (sim)
{
mLLContext->getNphaseImplementationContext()->unregisterShape(sim->getCore().getShapeCore().getCore(), sim->getShapeSim().getElementID());
mSimulationController->releaseParticleSystem(sim->getLowLevelParticleSystem(), core.getSolverType());
}
}
void Sc::Scene::addRigidAttachment(Sc::BodyCore* core, Sc::ParticleSystemSim& sim)
{
PxNodeIndex nodeIndex;
if (core)
{
nodeIndex = core->getSim()->getNodeIndex();
}
PxPair<PxU32, PxU32> pair(sim.getNodeIndex().index(), nodeIndex.index());
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
if (interaction.mCount == 0)
{
IG::EdgeIndex edgeIdx = mSimpleIslandManager->addContactManager(NULL, sim.getNodeIndex(), nodeIndex, NULL, IG::Edge::ePARTICLE_SYSTEM_CONTACT);
mSimpleIslandManager->setEdgeConnected(edgeIdx, IG::Edge::ePARTICLE_SYSTEM_CONTACT);
interaction.mIndex = edgeIdx;
}
interaction.mCount++;
}
void Sc::Scene::removeRigidAttachment(Sc::BodyCore* core, Sc::ParticleSystemSim& sim)
{
PxNodeIndex nodeIndex;
if (core)
nodeIndex = core->getSim()->getNodeIndex();
PxPair<PxU32, PxU32> pair(sim.getNodeIndex().index(), nodeIndex.index());
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
interaction.mCount--;
if (interaction.mCount == 0)
{
mSimpleIslandManager->removeConnection(interaction.mIndex);
mParticleOrSoftBodyRigidInteractionMap.erase(pair);
}
}
void Sc::Scene::addHairSystemSimControl(Sc::HairSystemCore& core)
{
Sc::HairSystemSim* sim = core.getSim();
if (sim)
{
mSimulationController->addHairSystem(sim->getLowLevelHairSystem(), sim->getNodeIndex());
mLLContext->getNphaseImplementationContext()->registerShape(sim->getNodeIndex(), sim->getShapeSim().getCore().getCore(), sim->getShapeSim().getElementID(), sim->getPxActor());
}
}
void Sc::Scene::removeHairSystemSimControl(Sc::HairSystemCore& core)
{
Sc::HairSystemSim* sim = core.getSim();
if (sim)
{
mLLContext->getNphaseImplementationContext()->unregisterShape(sim->getShapeSim().getCore().getCore(), sim->getShapeSim().getElementID());
mSimulationController->releaseHairSystem(sim->getLowLevelHairSystem());
}
}
void Sc::Scene::addAttachment(const Sc::BodySim& bodySim, const Sc::HairSystemSim& hairSim)
{
const PxNodeIndex nodeIndex = bodySim.getNodeIndex();
const PxPair<PxU32, PxU32> pair(hairSim.getNodeIndex().index(), nodeIndex.index());
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
if (interaction.mCount == 0)
{
IG::EdgeIndex edgeIdx = mSimpleIslandManager->addContactManager(NULL, hairSim.getNodeIndex(), nodeIndex, NULL, IG::Edge::eHAIR_SYSTEM_CONTACT);
mSimpleIslandManager->setEdgeConnected(edgeIdx, IG::Edge::eHAIR_SYSTEM_CONTACT);
interaction.mIndex = edgeIdx;
}
interaction.mCount++;
}
void Sc::Scene::removeAttachment(const Sc::BodySim& bodySim, const Sc::HairSystemSim& hairSim)
{
const PxNodeIndex nodeIndex = bodySim.getNodeIndex();
const PxPair<PxU32, PxU32> pair(hairSim.getNodeIndex().index(), nodeIndex.index());
if(mParticleOrSoftBodyRigidInteractionMap.find(pair)) // find returns pointer to const so we cannot use it directly
{
ParticleOrSoftBodyRigidInteraction& interaction = mParticleOrSoftBodyRigidInteractionMap[pair];
PX_ASSERT(interaction.mCount > 0);
interaction.mCount--;
if(interaction.mCount == 0)
{
mSimpleIslandManager->removeConnection(interaction.mIndex);
mParticleOrSoftBodyRigidInteractionMap.erase(pair);
}
}
}
PxActor** Sc::Scene::getActiveSoftBodyActors(PxU32& nbActorsOut)
{
nbActorsOut = mActiveSoftBodyActors.size();
if (!nbActorsOut)
return NULL;
return mActiveSoftBodyActors.begin();
}
void Sc::Scene::setActiveSoftBodyActors(PxActor** actors, PxU32 nbActors)
{
mActiveSoftBodyActors.forceSize_Unsafe(0);
mActiveSoftBodyActors.resize(nbActors);
PxMemCopy(mActiveSoftBodyActors.begin(), actors, sizeof(PxActor*) * nbActors);
}
//PxActor** Sc::Scene::getActiveFEMClothActors(PxU32& nbActorsOut)
//{
// nbActorsOut = mActiveFEMClothActors.size();
//
// if (!nbActorsOut)
// return NULL;
//
// return mActiveFEMClothActors.begin();
//}
//
//void Sc::Scene::setActiveFEMClothActors(PxActor** actors, PxU32 nbActors)
//{
// mActiveFEMClothActors.forceSize_Unsafe(0);
// mActiveFEMClothActors.resize(nbActors);
// PxMemCopy(mActiveFEMClothActors.begin(), actors, sizeof(PxActor*) * nbActors);
//}
#endif //PX_SUPPORT_GPU_PHYSX
| 148,828 | C++ | 33.708256 | 238 | 0.738927 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScBodySim.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-2023 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 SC_BODYSIM_H
#define SC_BODYSIM_H
#include "foundation/PxUtilities.h"
#include "foundation/PxIntrinsics.h"
#include "ScRigidSim.h"
#include "PxvDynamics.h"
#include "ScBodyCore.h"
#include "ScSimStateData.h"
#include "PxRigidDynamic.h"
#include "PxsRigidBody.h"
namespace physx
{
namespace Bp
{
class BoundsArray;
}
class PxsTransformCache;
namespace Sc
{
class Scene;
class ArticulationSim;
#if PX_VC
#pragma warning(push)
#pragma warning( disable : 4324 ) // Padding was added at the end of a structure because of a __declspec(align) value.
#endif
class BodySim : public RigidSim
{
public:
BodySim(Scene&, BodyCore&, bool);
virtual ~BodySim();
void switchToKinematic();
void switchToDynamic();
PX_FORCE_INLINE const SimStateData* getSimStateData(bool isKinematic) const { return (mSimStateData && (checkSimStateKinematicStatus(isKinematic)) ? mSimStateData : NULL); }
PX_FORCE_INLINE SimStateData* getSimStateData(bool isKinematic) { return (mSimStateData && (checkSimStateKinematicStatus(isKinematic)) ? mSimStateData : NULL); }
PX_FORCE_INLINE SimStateData* getSimStateData_Unchecked() const { return mSimStateData; }
PX_FORCE_INLINE bool checkSimStateKinematicStatus(bool isKinematic) const
{
PX_ASSERT(mSimStateData);
return mSimStateData->isKine() == isKinematic;
}
void setKinematicTarget(const PxTransform& p);
void addSpatialAcceleration(const PxVec3* linAcc, const PxVec3* angAcc);
void setSpatialAcceleration(const PxVec3* linAcc, const PxVec3* angAcc);
void clearSpatialAcceleration(bool force, bool torque);
void addSpatialVelocity(const PxVec3* linVelDelta, const PxVec3* angVelDelta);
void clearSpatialVelocity(bool force, bool torque);
void updateCached(PxBitMapPinned* shapeChangedMap);
void updateCached(PxsTransformCache& transformCache, Bp::BoundsArray& boundsArray);
void updateContactDistance(PxReal* contactDistance, PxReal dt, const Bp::BoundsArray& boundsArray);
// hooks for actions in body core when it's attached to a sim object. Generally
// we get called after the attribute changed.
virtual void postActorFlagChange(PxU32 oldFlags, PxU32 newFlags) PX_OVERRIDE;
void postBody2WorldChange();
void postSetWakeCounter(PxReal t, bool forceWakeUp);
void postPosePreviewChange(PxU32 posePreviewFlag); // called when PxRigidBodyFlag::eENABLE_POSE_INTEGRATION_PREVIEW changes
PX_FORCE_INLINE const PxTransform& getBody2World() const { return getBodyCore().getCore().body2World; }
PX_FORCE_INLINE const PxTransform& getBody2Actor() const { return getBodyCore().getCore().getBody2Actor(); }
PX_FORCE_INLINE const PxsRigidBody& getLowLevelBody() const { return mLLBody; }
PX_FORCE_INLINE PxsRigidBody& getLowLevelBody() { return mLLBody; }
void setActive(bool active, bool asPartOfCreation=false);
void wakeUp(); // note: for user API call purposes only, i.e., use from BodyCore. For simulation internal purposes there is internalWakeUp().
void putToSleep();
void disableCompound();
static PxU32 getRigidBodyOffset() { return PxU32(PX_OFFSET_OF_RT(BodySim, mLLBody));}
void activate();
void deactivate();
// Kinematics
PX_FORCE_INLINE bool isKinematic() const { return getBodyCore().getFlags() & PxRigidBodyFlag::eKINEMATIC; }
PX_FORCE_INLINE bool isArticulationLink() const { return getActorType() == PxActorType::eARTICULATION_LINK; }
PX_FORCE_INLINE bool hasForcedKinematicNotif() const
{
return getBodyCore().getFlags() & (PxRigidBodyFlag::eFORCE_KINE_KINE_NOTIFICATIONS|PxRigidBodyFlag::eFORCE_STATIC_KINE_NOTIFICATIONS);
}
void calculateKinematicVelocity(PxReal oneOverDt);
void updateKinematicPose();
bool deactivateKinematic();
// Sleeping
virtual void internalWakeUp(PxReal wakeCounterValue) PX_OVERRIDE; // PT: TODO: does it need to be virtual?
void internalWakeUpArticulationLink(PxReal wakeCounterValue); // called by ArticulationSim to wake up this link
PxReal updateWakeCounter(PxReal dt, PxReal energyThreshold, const Cm::SpatialVector& motionVelocity);
void notifyReadyForSleeping(); // inform the sleep island generation system that the body is ready for sleeping
void notifyNotReadyForSleeping(); // inform the sleep island generation system that the body is not ready for sleeping
PX_FORCE_INLINE bool checkSleepReadinessBesidesWakeCounter(); // for API triggered changes to test sleep readiness
// PT: TODO: this is only used for the rigid bodies' sleep check, the implementations in derived classes look useless
virtual void registerCountedInteraction() PX_OVERRIDE { mLLBody.getCore().numCountedInteractions++; PX_ASSERT(mLLBody.getCore().numCountedInteractions); }
virtual void unregisterCountedInteraction() PX_OVERRIDE { PX_ASSERT(mLLBody.getCore().numCountedInteractions); mLLBody.getCore().numCountedInteractions--; }
// PT: TODO: this is only used for the rigid bodies' sleep check called from the articulation sim code
virtual PxU32 getNumCountedInteractions() const PX_OVERRIDE { return mLLBody.getCore().numCountedInteractions; }
PX_FORCE_INLINE PxIntBool isFrozen() const { return PxIntBool(mLLBody.mInternalFlags & PxsRigidBody::eFROZEN); }
// External velocity changes - returns true if any forces were applied to this body
bool updateForces(PxReal dt, PxsRigidBody** updatedBodySims, PxU32* updatedBodyNodeIndices, PxU32& index, Cm::SpatialVector* acceleration);
PX_FORCE_INLINE bool readVelocityModFlag(VelocityModFlags f) { return (mVelModState & f) != 0; }
// Miscellaneous
PX_FORCE_INLINE bool notInScene() const { return mActiveListIndex == SC_NOT_IN_SCENE_INDEX; }
PX_FORCE_INLINE PxU32 getNbShapes() const { return mShapes.getCount(); }
PX_FORCE_INLINE PxU32 getFlagsFast() const { return getBodyCore().getFlags(); }
PX_FORCE_INLINE BodyCore& getBodyCore() const { return static_cast<BodyCore&>(getRigidCore()); }
PX_FORCE_INLINE ArticulationSim* getArticulation() const { return mArticulation; }
void setArticulation(ArticulationSim* a, PxReal wakeCounter, bool asleep, PxU32 bodyIndex);
PX_FORCE_INLINE void onConstraintAttach() { raiseInternalFlag(BF_HAS_CONSTRAINTS); registerCountedInteraction(); }
void onConstraintDetach();
PX_FORCE_INLINE void onOriginShift(const PxVec3& shift, const bool isKinematic)
{
PX_ASSERT(!mSimStateData || checkSimStateKinematicStatus(isKinematic));
mLLBody.mLastTransform.p -= shift;
if (mSimStateData && isKinematic && mSimStateData->getKinematicData()->targetValid)
mSimStateData->getKinematicData()->targetPose.p -= shift;
}
PX_FORCE_INLINE bool usingSqKinematicTarget() const
{
const PxU32 ktFlags(PxRigidBodyFlag::eUSE_KINEMATIC_TARGET_FOR_SCENE_QUERIES | PxRigidBodyFlag::eKINEMATIC);
return (getFlagsFast()&ktFlags) == ktFlags;
}
void createSqBounds();
void destroySqBounds();
void freezeTransforms(PxBitMapPinned* shapeChangedMap);
void addToSpeculativeCCDMap();
void removeFromSpeculativeCCDMap();
private:
// Base body
PxsRigidBody mLLBody;
// External velocity changes
// VelocityMod data allocated on the fly when the user applies velocity changes
// which need to be accumulated.
// VelMod dirty flags stored in BodySim so we can save ourselves the expense of looking at
// the separate velmod data if no forces have been set.
//PxU16 mInternalFlags;
SimStateData* mSimStateData;
PxU8 mVelModState;
// Articulation
ArticulationSim* mArticulation; // NULL if not in an articulation
// Joints & joint groups
bool setupSimStateData(bool isKinematic);
void tearDownSimStateData(bool isKinematic);
void raiseVelocityModFlagAndNotify(VelocityModFlags flag);
PX_FORCE_INLINE void notifyAddSpatialAcceleration() { raiseVelocityModFlagAndNotify(VMF_ACC_DIRTY); }
PX_FORCE_INLINE void notifyClearSpatialAcceleration() { raiseVelocityModFlagAndNotify(VMF_ACC_DIRTY); }
PX_FORCE_INLINE void notifyAddSpatialVelocity() { raiseVelocityModFlagAndNotify(VMF_VEL_DIRTY); }
PX_FORCE_INLINE void notifyClearSpatialVelocity() { raiseVelocityModFlagAndNotify(VMF_VEL_DIRTY); }
PX_FORCE_INLINE void initKinematicStateBase(BodyCore&, bool asPartOfCreation);
void notifyWakeUp(); // inform the sleep island generation system that the object got woken up
void notifyPutToSleep(); // inform the sleep island generation system that the object was put to sleep
void internalWakeUpBase(PxReal wakeCounterValue);
PX_FORCE_INLINE void raiseVelocityModFlag(VelocityModFlags f) { mVelModState |= f; }
PX_FORCE_INLINE void clearVelocityModFlag(VelocityModFlags f) { mVelModState &= ~f; }
PX_FORCE_INLINE void setForcesToDefaults(bool enableGravity);
};
#if PX_VC
#pragma warning(pop)
#endif
} // namespace Sc
PX_FORCE_INLINE void Sc::BodySim::setForcesToDefaults(bool enableGravity)
{
if (!(mLLBody.mCore->mFlags & PxRigidBodyFlag::eRETAIN_ACCELERATIONS))
{
SimStateData* simStateData = getSimStateData(false);
if(simStateData)
{
VelocityMod* velmod = simStateData->getVelocityModData();
velmod->clear();
}
if (enableGravity)
mVelModState = VMF_GRAVITY_DIRTY; // We want to keep the gravity flag to make sure the acceleration gets changed to gravity-only
// in the next step (unless the application adds new forces of course)
else
mVelModState = 0;
}
else
{
SimStateData* simStateData = getSimStateData(false);
if (simStateData)
{
VelocityMod* velmod = simStateData->getVelocityModData();
velmod->clearPerStep();
}
mVelModState &= (~(VMF_VEL_DIRTY));
}
}
PX_FORCE_INLINE bool Sc::BodySim::checkSleepReadinessBesidesWakeCounter()
{
const BodyCore& bodyCore = getBodyCore();
const SimStateData* simStateData = getSimStateData(false);
const VelocityMod* velmod = simStateData ? simStateData->getVelocityModData() : NULL;
bool readyForSleep = bodyCore.getLinearVelocity().isZero() && bodyCore.getAngularVelocity().isZero();
if (readVelocityModFlag(VMF_ACC_DIRTY))
{
readyForSleep = readyForSleep && (!velmod || velmod->getLinearVelModPerSec().isZero());
readyForSleep = readyForSleep && (!velmod || velmod->getAngularVelModPerSec().isZero());
}
if (readVelocityModFlag(VMF_VEL_DIRTY))
{
readyForSleep = readyForSleep && (!velmod || velmod->getLinearVelModPerStep().isZero());
readyForSleep = readyForSleep && (!velmod || velmod->getAngularVelModPerStep().isZero());
}
return readyForSleep;
}
}
#endif
| 12,922 | C | 45.822464 | 176 | 0.715292 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScConstraintBreakage.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScScene.h"
#include "ScConstraintSim.h"
#include "ScConstraintCore.h"
#include "ScConstraintInteraction.h"
#include "common/PxProfileZone.h"
using namespace physx;
// PT: the breakable constraints are added to / removed from mActiveBreakableConstraints:
void Sc::Scene::addActiveBreakableConstraint(Sc::ConstraintSim* c, Sc::ConstraintInteraction* ci)
{
PX_ASSERT(ci && ci->readInteractionFlag(InteractionFlag::eIS_ACTIVE));
PX_UNUSED(ci);
PX_ASSERT(!mActiveBreakableConstraints.contains(c));
PX_ASSERT(!c->isBroken());
mActiveBreakableConstraints.insert(c);
c->setFlag(ConstraintSim::eCHECK_MAX_FORCE_EXCEEDED);
}
void Sc::Scene::removeActiveBreakableConstraint(Sc::ConstraintSim* c)
{
const bool exists = mActiveBreakableConstraints.erase(c);
PX_ASSERT(exists);
PX_UNUSED(exists);
c->clearFlag(ConstraintSim::eCHECK_MAX_FORCE_EXCEEDED);
}
// PT: then at runtime we parse mActiveBreakableConstraints, check for max force exceeded,
// and add broken constraints to mBrokenConstraints:
void Sc::Scene::checkConstraintBreakage()
{
PX_PROFILE_ZONE("Sim.checkConstraintBreakage", mContextId);
PxU32 count = mActiveBreakableConstraints.size();
if(!count)
return;
PxPinnedArray<Dy::ConstraintWriteback>& pool = mDynamicsContext->getConstraintWriteBackPool();
ConstraintSim* const* constraints = mActiveBreakableConstraints.getEntries();
while(count--)
{
ConstraintSim* sim = constraints[count]; // start from the back because broken constraints get removed from the list
PX_ASSERT(sim->readFlag(ConstraintSim::eCHECK_MAX_FORCE_EXCEEDED));
const Dy::ConstraintWriteback& solverOutput = pool[sim->getLowLevelConstraint().index];
if(solverOutput.broken)
{
sim->setFlag(ConstraintSim::eBROKEN);
ConstraintCore& core = sim->getCore();
if(mSimulationEventCallback)
{
PX_ASSERT(mBrokenConstraints.find(&core) == mBrokenConstraints.end());
mBrokenConstraints.pushBack(&core);
}
core.breakApart();
ConstraintInteraction* interaction = const_cast<ConstraintInteraction*>(sim->getInteraction());
interaction->destroy(); // PT: this will call removeFromActiveBreakableList above
// update related SIPs
{
ActorSim& a0 = interaction->getActorSim0();
ActorSim& a1 = interaction->getActorSim1();
ActorSim& actor = (a0.getActorInteractionCount() < a1.getActorInteractionCount()) ? a0 : a1;
actor.setActorsInteractionsDirty(InteractionDirtyFlag::eFILTER_STATE, NULL, InteractionFlag::eRB_ELEMENT);
// because broken constraints can re-enable contact response between the two bodies
}
PX_ASSERT(!sim->readFlag(ConstraintSim::eCHECK_MAX_FORCE_EXCEEDED));
}
}
}
// PT: finally mBrokenConstraints is parsed and callbacks issued:
void Sc::Scene::fireBrokenConstraintCallbacks()
{
if(!mSimulationEventCallback)
return;
const PxU32 count = mBrokenConstraints.size();
for(PxU32 i=0;i<count;i++)
{
Sc::ConstraintCore* c = mBrokenConstraints[i];
PX_ASSERT(c->getSim());
PxU32 typeID = 0xffffffff;
void* externalRef = c->getPxConnector()->getExternalReference(typeID);
PX_CHECK_MSG(typeID != 0xffffffff, "onConstraintBreak: Invalid constraint type ID.");
PxConstraintInfo constraintInfo(c->getPxConstraint(), externalRef, typeID);
mSimulationEventCallback->onConstraintBreak(&constraintInfo, 1);
}
}
| 5,014 | C++ | 37.282442 | 118 | 0.759673 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScActorSim.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScActorSim.h"
#include "ScActorCore.h"
#include "ScElementSim.h"
#include "ScScene.h"
#include "ScInteraction.h"
using namespace physx;
using namespace Sc;
static const PxFilterObjectType::Enum gFilterType[PxActorType::eACTOR_COUNT] =
{
PxFilterObjectType::eRIGID_STATIC, // PxActorType::eRIGID_STATIC
PxFilterObjectType::eRIGID_DYNAMIC, // PxActorType::eRIGID_DYNAMIC
PxFilterObjectType::eARTICULATION, // PxActorType::eARTICULATION_LINK
PxFilterObjectType::eSOFTBODY, // PxActorType::eSOFTBODY
PxFilterObjectType::eFEMCLOTH, // PxActorType::eFEMCLOTH
PxFilterObjectType::ePARTICLESYSTEM, // PxActorType::ePBD_PARTICLESYSTEM
PxFilterObjectType::ePARTICLESYSTEM, // PxActorType::eFLIP_PARTICLESYSTEM
PxFilterObjectType::ePARTICLESYSTEM, // PxActorType::eMPM_PARTICLESYSTEM
PxFilterObjectType::eHAIRSYSTEM, // PxActorType::eHAIRSYSTEM
};
static const PxU32 gFilterFlagEx[PxActorType::eACTOR_COUNT] =
{
PxFilterObjectFlagEx::eRIGID_STATIC, // PxActorType::eRIGID_STATIC
PxFilterObjectFlagEx::eRIGID_DYNAMIC, // PxActorType::eRIGID_DYNAMIC
PxFilterObjectFlagEx::eRIGID_DYNAMIC, // PxActorType::eARTICULATION_LINK
PxFilterObjectFlagEx::eNON_RIGID|PxFilterObjectFlagEx::eSOFTBODY, // PxActorType::eSOFTBODY
PxFilterObjectFlagEx::eNON_RIGID|PxFilterObjectFlagEx::eFEMCLOTH, // PxActorType::eFEMCLOTH
PxFilterObjectFlagEx::eNON_RIGID|PxFilterObjectFlagEx::ePARTICLESYSTEM, // PxActorType::ePBD_PARTICLESYSTEM
PxFilterObjectFlagEx::eNON_RIGID|PxFilterObjectFlagEx::ePARTICLESYSTEM, // PxActorType::eFLIP_PARTICLESYSTEM
PxFilterObjectFlagEx::eNON_RIGID|PxFilterObjectFlagEx::ePARTICLESYSTEM, // PxActorType::eMPM_PARTICLESYSTEM
PxFilterObjectFlagEx::eNON_RIGID|PxFilterObjectFlagEx::eHAIRSYSTEM, // PxActorType::eHAIRSYSTEM
};
// PT: if this breaks, you need to update the above table
PX_COMPILE_TIME_ASSERT(PxActorType::eACTOR_COUNT==9);
// PT: make sure that the highest flag fits into 16bit
PX_COMPILE_TIME_ASSERT(PxFilterObjectFlagEx::eLAST<=0xffff);
Sc::ActorSim::ActorSim(Scene& scene, ActorCore& core) :
mScene (scene),
mCore (core),
mActiveListIndex (SC_NOT_IN_SCENE_INDEX),
mActiveCompoundListIndex(SC_NOT_IN_SCENE_INDEX),
mNodeIndex (PX_INVALID_NODE),
mInternalFlags (0)
{
core.setSim(this);
mId = scene.getActorIDTracker().createID();
{
PX_ASSERT(gFilterType[PxActorType::eRIGID_STATIC] == PxFilterObjectType::eRIGID_STATIC);
PX_ASSERT(gFilterType[PxActorType::eRIGID_DYNAMIC] == PxFilterObjectType::eRIGID_DYNAMIC);
PX_ASSERT(gFilterType[PxActorType::eARTICULATION_LINK] == PxFilterObjectType::eARTICULATION);
PX_ASSERT(gFilterType[PxActorType::eSOFTBODY] == PxFilterObjectType::eSOFTBODY);
PX_ASSERT(gFilterType[PxActorType::eFEMCLOTH] == PxFilterObjectType::eFEMCLOTH);
PX_ASSERT(gFilterType[PxActorType::ePBD_PARTICLESYSTEM] == PxFilterObjectType::ePARTICLESYSTEM);
PX_ASSERT(gFilterType[PxActorType::eFLIP_PARTICLESYSTEM] == PxFilterObjectType::ePARTICLESYSTEM);
PX_ASSERT(gFilterType[PxActorType::eMPM_PARTICLESYSTEM] == PxFilterObjectType::ePARTICLESYSTEM);
PX_ASSERT(gFilterType[PxActorType::eHAIRSYSTEM] == PxFilterObjectType::eHAIRSYSTEM);
const PxActorType::Enum actorType = getActorType();
PxFilterObjectAttributes filterAttr = 0;
setFilterObjectAttributeType(filterAttr, gFilterType[actorType]);
filterAttr |= gFilterFlagEx[actorType];
mFilterFlags = PxTo16(filterAttr);
}
}
Sc::ActorSim::~ActorSim()
{
mInteractions.releaseMem(*this);
mScene.getActorIDTracker().releaseID(mId);
}
void Sc::ActorSim::registerInteractionInActor(Interaction* interaction)
{
const PxU32 id = mInteractions.size();
mInteractions.pushBack(interaction, *this);
interaction->setActorId(this, id);
}
void Sc::ActorSim::unregisterInteractionFromActor(Interaction* interaction)
{
const PxU32 i = interaction->getActorId(this);
PX_ASSERT(i < mInteractions.size());
mInteractions.replaceWithLast(i);
if (i<mInteractions.size())
mInteractions[i]->setActorId(this, i);
}
void Sc::ActorSim::reallocInteractions(Sc::Interaction**& mem, PxU32& capacity, PxU32 size, PxU32 requiredMinCapacity)
{
Interaction** newMem;
PxU32 newCapacity;
if(requiredMinCapacity==0)
{
newCapacity = 0;
newMem = 0;
}
else if(requiredMinCapacity<=INLINE_INTERACTION_CAPACITY)
{
newCapacity = INLINE_INTERACTION_CAPACITY;
newMem = mInlineInteractionMem;
}
else
{
newCapacity = PxNextPowerOfTwo(requiredMinCapacity-1);
newMem = reinterpret_cast<Interaction**>(mScene.allocatePointerBlock(newCapacity));
}
PX_ASSERT(newCapacity >= requiredMinCapacity && requiredMinCapacity>=size);
if(mem)
{
PxMemCopy(newMem, mem, size*sizeof(Interaction*));
if(mem!=mInlineInteractionMem)
mScene.deallocatePointerBlock(reinterpret_cast<void**>(mem), capacity);
}
capacity = newCapacity;
mem = newMem;
}
void Sc::ActorSim::setActorsInteractionsDirty(InteractionDirtyFlag::Enum flag, const ActorSim* other, PxU8 interactionFlag)
{
PxU32 size = getActorInteractionCount();
Interaction** interactions = getActorInteractions();
while(size--)
{
Interaction* interaction = *interactions++;
if((!other || other == &interaction->getActorSim0() || other == &interaction->getActorSim1()) && (interaction->readInteractionFlag(interactionFlag)))
interaction->setDirty(flag);
}
}
| 7,003 | C++ | 39.72093 | 151 | 0.772383 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScSimStats.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "foundation/PxMemory.h"
#include "ScSimStats.h"
#include "PxvSimStats.h"
#include "PxsHeapMemoryAllocator.h"
using namespace physx;
Sc::SimStats::SimStats()
{
numBroadPhaseAdds = numBroadPhaseRemoves = 0;
gpuMemSizeParticles = 0;
gpuMemSizeSoftBodies = 0;
clear();
}
void Sc::SimStats::clear()
{
#if PX_ENABLE_SIM_STATS
PxMemZero(const_cast<void*>(reinterpret_cast<volatile void*>(&numTriggerPairs)), sizeof(TriggerPairCounts));
numBroadPhaseAddsPending = numBroadPhaseRemovesPending = 0;
#else
PX_CATCH_UNDEFINED_ENABLE_SIM_STATS
#endif
}
void Sc::SimStats::simStart()
{
#if PX_ENABLE_SIM_STATS
// pending broadphase adds/removes are now the current ones
numBroadPhaseAdds = numBroadPhaseAddsPending;
numBroadPhaseRemoves = numBroadPhaseRemovesPending;
clear();
#else
PX_CATCH_UNDEFINED_ENABLE_SIM_STATS
#endif
}
void Sc::SimStats::readOut(PxSimulationStatistics& s, const PxvSimStats& simStats) const
{
#if PX_ENABLE_SIM_STATS
s = PxSimulationStatistics(); // clear stats
for(PxU32 i=0; i < PxGeometryType::eCONVEXMESH+1; i++)
{
for(PxU32 j=0; j < PxGeometryType::eGEOMETRY_COUNT; j++)
{
s.nbTriggerPairs[i][j] += PxU32(numTriggerPairs[i][j]);
if (i != j)
s.nbTriggerPairs[j][i] += PxU32(numTriggerPairs[i][j]);
}
}
s.nbBroadPhaseAdds = numBroadPhaseAdds;
s.nbBroadPhaseRemoves = numBroadPhaseRemoves;
for(PxU32 i=0; i < PxGeometryType::eGEOMETRY_COUNT; i++)
{
s.nbDiscreteContactPairs[i][i] = simStats.mNbDiscreteContactPairs[i][i];
s.nbModifiedContactPairs[i][i] = simStats.mNbModifiedContactPairs[i][i];
s.nbCCDPairs[i][i] = simStats.mNbCCDPairs[i][i];
for(PxU32 j=i+1; j < PxGeometryType::eGEOMETRY_COUNT; j++)
{
PxU32 c = simStats.mNbDiscreteContactPairs[i][j];
s.nbDiscreteContactPairs[i][j] = c;
s.nbDiscreteContactPairs[j][i] = c;
c = simStats.mNbModifiedContactPairs[i][j];
s.nbModifiedContactPairs[i][j] = c;
s.nbModifiedContactPairs[j][i] = c;
c = simStats.mNbCCDPairs[i][j];
s.nbCCDPairs[i][j] = c;
s.nbCCDPairs[j][i] = c;
}
#if PX_DEBUG
for(PxU32 j=0; j < i; j++)
{
// PxvSimStats should only use one half of the matrix
PX_ASSERT(simStats.mNbDiscreteContactPairs[i][j] == 0);
PX_ASSERT(simStats.mNbModifiedContactPairs[i][j] == 0);
PX_ASSERT(simStats.mNbCCDPairs[i][j] == 0);
}
#endif
}
s.nbDiscreteContactPairsTotal = simStats.mNbDiscreteContactPairsTotal;
s.nbDiscreteContactPairsWithCacheHits = simStats.mNbDiscreteContactPairsWithCacheHits;
s.nbDiscreteContactPairsWithContacts = simStats.mNbDiscreteContactPairsWithContacts;
s.nbActiveConstraints = simStats.mNbActiveConstraints;
s.nbActiveDynamicBodies = simStats.mNbActiveDynamicBodies;
s.nbActiveKinematicBodies = simStats.mNbActiveKinematicBodies;
s.nbAxisSolverConstraints = simStats.mNbAxisSolverConstraints;
s.peakConstraintMemory = simStats.mPeakConstraintBlockAllocations * 16 * 1024;
s.compressedContactSize = simStats.mTotalCompressedContactSize;
s.requiredContactConstraintMemory = simStats.mTotalConstraintSize;
s.nbNewPairs = simStats.mNbNewPairs;
s.nbLostPairs = simStats.mNbLostPairs;
s.nbNewTouches = simStats.mNbNewTouches;
s.nbLostTouches = simStats.mNbLostTouches;
s.nbPartitions = simStats.mNbPartitions;
s.gpuMemParticles = gpuMemSizeParticles;
s.gpuMemSoftBodies = gpuMemSizeSoftBodies;
#else
PX_CATCH_UNDEFINED_ENABLE_SIM_STATS
PX_UNUSED(s);
PX_UNUSED(simStats);
#endif
}
| 5,106 | C++ | 34.465278 | 109 | 0.75754 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScElementInteractionMarker.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-2023 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 SC_ELEMENT_INTERACTION_MARKER_H
#define SC_ELEMENT_INTERACTION_MARKER_H
#include "ScElementSimInteraction.h"
#include "ScNPhaseCore.h"
namespace physx
{
namespace Sc
{
class ElementInteractionMarker : public ElementSimInteraction
{
public:
PX_INLINE ElementInteractionMarker(ElementSim& element0, ElementSim& element1, bool createParallel/* = false*/);
~ElementInteractionMarker();
};
} // namespace Sc
PX_INLINE Sc::ElementInteractionMarker::ElementInteractionMarker(ElementSim& element0, ElementSim& element1, bool createParallel) :
ElementSimInteraction(element0, element1, InteractionType::eMARKER, InteractionFlag::eRB_ELEMENT|InteractionFlag::eFILTERABLE)
{
if(!createParallel)
{
// PT: no call to onActivate() here, interaction markers are always inactive
registerInActors();
Scene& scene = getScene();
scene.registerInteraction(this, false);
}
}
}
#endif
| 2,602 | C | 39.046153 | 131 | 0.76864 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScSqBoundsManager.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "GuPrunerTypedef.h"
#include "ScSqBoundsManager.h"
#include "ScBodySim.h"
#include "ScShapeSim.h"
#include "ScSqBoundsSync.h"
#include "common/PxProfileZone.h"
using namespace physx;
using namespace Sc;
#define INVALID_REF ScPrunerHandle(Gu::INVALID_PRUNERHANDLE)
SqBoundsManager0::SqBoundsManager0() :
mShapes ("SqBoundsManager::mShapes"),
mRefs ("SqBoundsManager::mRefs"),
mBoundsIndices ("SqBoundsManager::mBoundsIndices"),
mRefless ("SqBoundsManager::mRefless")
{
}
void SqBoundsManager0::addSyncShape(ShapeSimBase& shape)
{
PX_ASSERT(shape.getFlags() & PxShapeFlag::eSCENE_QUERY_SHAPE);
PX_ASSERT(!shape.getBodySim()->usingSqKinematicTarget());
PX_ASSERT(!shape.getBodySim()->isFrozen());
const PxU32 id = mShapes.size();
PX_ASSERT(id == mRefs.size());
PX_ASSERT(id == mBoundsIndices.size());
shape.setSqBoundsId(id);
// PT: mShapes / mRefs / mBoundsIndices are "parallel arrays". These arrays are persistent.
// mRefless is temporary/transient data to help populate mRefs each frame.
// mRefs / mBoundsIndices will be ultimately passed to updateObjects, whose API dictates the layout here.
// mShapes is not actually used for the sync, it's only here to be able to call setSqBoundsId in removeShape.
mShapes.pushBack(static_cast<Sc::ShapeSim*>(&shape));
mRefs.pushBack(INVALID_REF);
mBoundsIndices.pushBack(shape.getElementID());
mRefless.pushBack(static_cast<Sc::ShapeSim*>(&shape));
}
void SqBoundsManager0::removeSyncShape(ShapeSimBase& shape)
{
const PxU32 id = shape.getSqBoundsId();
PX_ASSERT(id!=PX_INVALID_U32);
shape.setSqBoundsId(PX_INVALID_U32);
mShapes[id] = mShapes.back();
mBoundsIndices[id] = mBoundsIndices.back();
mRefs[id] = mRefs.back();
if(id+1 != mShapes.size())
mShapes[id]->setSqBoundsId(id);
mShapes.popBack();
mRefs.popBack();
mBoundsIndices.popBack();
}
void SqBoundsManager0::syncBounds(SqBoundsSync& sync, SqRefFinder& finder, const PxBounds3* bounds, const PxTransform32* transforms, PxU64 contextID, const PxBitMap& ignoredIndices)
{
PX_PROFILE_ZONE("Sim.sceneQuerySyncBounds", contextID);
PX_UNUSED(contextID);
#if PX_DEBUG
for(PxU32 i=0;i<mShapes.size();i++)
{
const ShapeSimBase& shape = *mShapes[i];
PX_UNUSED(shape);
PX_ASSERT(shape.getFlags() & PxShapeFlag::eSCENE_QUERY_SHAPE);
PX_ASSERT(!shape.getBodySim()->usingSqKinematicTarget());
PX_ASSERT(!shape.getBodySim()->isFrozen());
}
#endif
ShapeSimBase*const * shapes = mRefless.begin();
for(PxU32 i=0, size = mRefless.size();i<size;i++)
{
const PxU32 id = shapes[i]->getSqBoundsId();
// PT:
//
// If id == PX_INVALID_U32, the shape has been removed and not re-added. Nothing to do in this case, we just ignore it.
// This case didn't previously exist since mRefless only contained valid (added) shapes. But now we left removed shapes in the
// structure, and these have an id == PX_INVALID_U32.
//
// Now if the id is valid but mRefs[id] == PX_INVALID_U32, this is a regular shape that has been added and not processed yet.
// So we process it.
//
// Finally, if both id and mRefs[id] are not PX_INVALID_U32, this is a shape that has been added, removed, and re-added. The
// array contains the same shape twice and we only need to process it once.
if(id!=PX_INVALID_U32)
{
if(mRefs[id] == INVALID_REF)
{
PxU32 prunerIndex = 0xffffffff;
mRefs[id] = finder.find(static_cast<PxRigidBody*>(shapes[i]->getBodySim()->getPxActor()), shapes[i]->getPxShape(), prunerIndex);
PX_ASSERT(prunerIndex==1);
}
}
}
mRefless.clear();
sync.sync(1, mRefs.begin(), mBoundsIndices.begin(), bounds, transforms, mShapes.size(), ignoredIndices);
}
// PT: we need to change the code so that the shape is added to the proper array during syncBounds, not during addSyncShape,
// because the pruner index is not known in addSyncShape. We could perhaps call the ref-finder directly in addSyncShape, but
// it would impose an order on the calls (the shape would need to be added to the pruners before addSyncShape is called. There's
// no such requirement with the initial code).
//
// Instead we do this:
// - in addSyncShape we just add the shape to a "waiting room", that's all.
// - adding the shape to the proper array is delayed until syncBounds. That way the prunerIndex will be available. Also we could
// then take advantage of batching, since all shapes are processed/added at the same time.
// - the only catch is that we need to ensure the previous edge-cases are still properly handled, i.e. when a shape is added then
// removed before sync is called, etc.
//
SqBoundsManagerEx::SqBoundsManagerEx() :
mWaitingRoom ("SqBoundsManagerEx::mWaitingRoom"),
mPrunerSyncData (NULL),
mPrunerSyncDataSize (0)
{
}
SqBoundsManagerEx::~SqBoundsManagerEx()
{
const PxU32 nbToGo = mPrunerSyncDataSize;
for(PxU32 i=0;i<nbToGo;i++)
{
PrunerSyncData* psd = mPrunerSyncData[i];
PX_DELETE(psd);
}
PX_FREE(mPrunerSyncData);
}
void SqBoundsManagerEx::resize(PxU32 index)
{
PxU32 size = mPrunerSyncDataSize ? mPrunerSyncDataSize*2 : 64;
const PxU32 minSize = index+1;
if(minSize>size)
size = minSize*2;
PrunerSyncData** items = PX_ALLOCATE(PrunerSyncData*, size, "PrunerSyncData");
if(mPrunerSyncData)
PxMemCopy(items, mPrunerSyncData, mPrunerSyncDataSize*sizeof(PrunerSyncData*));
PxMemZero(items+mPrunerSyncDataSize, (size-mPrunerSyncDataSize)*sizeof(PrunerSyncData*));
PX_FREE(mPrunerSyncData);
mPrunerSyncData = items;
mPrunerSyncDataSize = size;
}
void SqBoundsManagerEx::addSyncShape(ShapeSimBase& shape)
{
PX_ASSERT(shape.getFlags() & PxShapeFlag::eSCENE_QUERY_SHAPE);
PX_ASSERT(!shape.getBodySim()->usingSqKinematicTarget());
PX_ASSERT(!shape.getBodySim()->isFrozen());
PX_ASSERT(shape.getSqBoundsId()==PX_INVALID_U32);
PX_ASSERT(shape.getSqPrunerIndex()==PX_INVALID_U32);
const PxU32 id = mWaitingRoom.size();
mWaitingRoom.pushBack(&shape);
shape.setSqBoundsId(id);
shape.setSqPrunerIndex(PX_INVALID_U32);
}
void SqBoundsManagerEx::removeSyncShape(ShapeSimBase& shape)
{
const PxU32 id = shape.getSqBoundsId();
const PxU32 prunerIndex = shape.getSqPrunerIndex();
PX_ASSERT(id!=PX_INVALID_U32);
shape.setSqBoundsId(PX_INVALID_U32);
shape.setSqPrunerIndex(PX_INVALID_U32);
if(prunerIndex==PX_INVALID_U32)
{
// PT: this shape is still in the waiting room
PX_ASSERT(mWaitingRoom[id]==&shape);
mWaitingRoom[id] = mWaitingRoom.back();
if(id+1 != mWaitingRoom.size())
mWaitingRoom[id]->setSqBoundsId(id);
mWaitingRoom.popBack();
}
else
{
// PT: this shape is active
PX_ASSERT(prunerIndex<mPrunerSyncDataSize);
PrunerSyncData* psd = mPrunerSyncData[prunerIndex];
PX_ASSERT(psd);
PX_ASSERT(psd->mShapes[id]==&shape);
psd->mShapes[id] = psd->mShapes.back();
psd->mBoundsIndices[id] = psd->mBoundsIndices.back();
psd->mRefs[id] = psd->mRefs.back();
if(id+1 != psd->mShapes.size())
psd->mShapes[id]->setSqBoundsId(id);
psd->mShapes.popBack();
psd->mBoundsIndices.popBack();
psd->mRefs.popBack();
if(!psd->mShapes.size())
{
PX_DELETE(psd);
mPrunerSyncData[prunerIndex] = NULL;
}
}
}
void SqBoundsManagerEx::syncBounds(SqBoundsSync& sync, SqRefFinder& finder, const PxBounds3* bounds, const PxTransform32* transforms, PxU64 contextID, const PxBitMap& ignoredIndices)
{
PX_PROFILE_ZONE("Sim.sceneQuerySyncBounds", contextID);
PX_UNUSED(contextID);
/*
#if PX_DEBUG
for(PxU32 i=0;i<mShapeData.size();i++)
{
const ShapeSQData& shape = mShapeData[i];
PX_UNUSED(shape);
PX_ASSERT(shape.mSim->getFlags() & PxShapeFlag::eSCENE_QUERY_SHAPE);
PX_ASSERT(!shape.mSim->getBodySim()->usingSqKinematicTarget());
PX_ASSERT(!shape.mSim->getBodySim()->isFrozen());
}
#endif
*/
const PxU32 nbToGo = mWaitingRoom.size();
if(nbToGo)
{
for(PxU32 i=0;i<nbToGo;i++)
{
ShapeSimBase* sim = mWaitingRoom[i];
PX_ASSERT(i==sim->getSqBoundsId());
PX_ASSERT(PX_INVALID_U32==sim->getSqPrunerIndex());
PxU32 prunerIndex = 0xffffffff;
const ScPrunerHandle prunerHandle = finder.find(static_cast<PxRigidBody*>(sim->getBodySim()->getPxActor()), sim->getPxShape(), prunerIndex);
PX_ASSERT(prunerIndex!=0xffffffff);
if(prunerIndex>=mPrunerSyncDataSize)
resize(prunerIndex);
PrunerSyncData* psd = mPrunerSyncData[prunerIndex];
if(!psd)
{
psd = PX_NEW(PrunerSyncData);
mPrunerSyncData[prunerIndex] = psd;
}
PxArray<ShapeSimBase*>& shapes = psd->mShapes;
PxArray<ScPrunerHandle>& refs = psd->mRefs;
PxArray<PxU32>& boundsIndices = psd->mBoundsIndices;
const PxU32 id = shapes.size();
PX_ASSERT(id == refs.size());
PX_ASSERT(id == boundsIndices.size());
sim->setSqBoundsId(id);
sim->setSqPrunerIndex(prunerIndex);
// PT: mShapes / mRefs / mBoundsIndices are "parallel arrays". These arrays are persistent.
// mRefless is temporary/transient data to help populate mRefs each frame.
// mRefs / mBoundsIndices will be ultimately passed to updateObjects, whose API dictates the layout here.
// mShapes is not actually used for the sync, it's only here to be able to call setSqBoundsId in removeShape.
shapes.pushBack(sim);
refs.pushBack(prunerHandle);
boundsIndices.pushBack(sim->getElementID());
}
mWaitingRoom.clear(); // PT: TODO: optimize wasted memory here
}
// PT: TODO: optimize this
{
const PxU32 nb = mPrunerSyncDataSize;
for(PxU32 i=0;i<nb;i++)
{
PrunerSyncData* psd = mPrunerSyncData[i];
if(psd)
sync.sync(i, psd->mRefs.begin(), psd->mBoundsIndices.begin(), bounds, transforms, psd->mRefs.size(), ignoredIndices);
}
}
}
| 11,245 | C++ | 33.078788 | 182 | 0.728946 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScArticulationSensorSim.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-2023 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 SC_ARTICULATION_SENSOR_SIM_H
#define SC_ARTICULATION_SENSOR_SIM_H
#include "foundation/PxUserAllocated.h"
#include "PxArticulationReducedCoordinate.h"
#include "DyFeatherstoneArticulation.h"
namespace physx
{
namespace Sc
{
class Scene;
class ArticulationSensorCore;
class ArticulationCore;
class ArticulationSim;
class ArticulationSensorSim : public PxUserAllocated
{
PX_NOCOPY(ArticulationSensorSim)
public:
ArticulationSensorSim(Sc::ArticulationSensorCore& core, Sc::Scene& scene);
~ArticulationSensorSim();
const PxSpatialForce& getForces() const;
void setRelativePose(const PxTransform& relativePose);
void setFlag(PxU16 flag);
PX_FORCE_INLINE Sc::Scene& getScene() { return mScene; }
PX_FORCE_INLINE const Sc::Scene& getScene() const { return mScene; }
PX_FORCE_INLINE void setLowLevelIndex(const PxU32 llIndex) { mLLIndex = llIndex;}
PX_FORCE_INLINE PxU32 getLowLevelIndex() const { return mLLIndex; }
PX_FORCE_INLINE Sc::ArticulationSensorCore& getCore() { return mCore; }
PX_FORCE_INLINE const Sc::ArticulationSensorCore& getCore() const { return mCore; }
PX_FORCE_INLINE Dy::ArticulationSensor& getLLSensor() { return mLLSensor; }
Sc::Scene& mScene;
Sc::ArticulationSensorCore& mCore;
Sc::ArticulationSim* mArticulationSim;
Dy::ArticulationSensor mLLSensor;
PxU32 mLLIndex;
};
}
}
#endif //SC_ARTICULATION_SENSOR_SIM_H
| 3,096 | C | 34.597701 | 84 | 0.764535 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScInteraction.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-2023 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 SC_INTERACTION_H
#define SC_INTERACTION_H
#include "foundation/Px.h"
#include "ScInteractionFlags.h"
#include "ScActorSim.h"
#include "foundation/PxUserAllocated.h"
#include "foundation/PxUtilities.h"
namespace physx
{
#define PX_INVALID_INTERACTION_ACTOR_ID 0xffffffff
#define PX_INVALID_INTERACTION_SCENE_ID 0xffffffff
namespace Sc
{
struct InteractionType
{
enum Enum
{
eOVERLAP = 0, // corresponds to ShapeInteraction
eTRIGGER, // corresponds to TriggerInteraction
eMARKER, // corresponds to ElementInteractionMarker
eTRACKED_IN_SCENE_COUNT, // not a real type, interactions above this limit are tracked in the scene
eCONSTRAINTSHADER, // corresponds to ConstraintInteraction
eARTICULATION, // corresponds to ArticulationJointSim
eINVALID
};
};
// Interactions are used for connecting actors into activation groups. An interaction always connects exactly two actors.
// An interaction is implicitly active if at least one of the two actors it connects is active.
// PT: we need PxUserAllocated only for ArticulationJointSim, which for some reason doesn't follow the same design as the others.
// The others are allocated from pools in NphaseCore.
class Interaction : public PxUserAllocated
{
PX_NOCOPY(Interaction)
Interaction(ActorSim& actor0, ActorSim& actor1, InteractionType::Enum interactionType, PxU8 flags);
~Interaction() { PX_ASSERT(!readInteractionFlag(InteractionFlag::eIN_DIRTY_LIST)); }
public:
// Interactions automatically register themselves in the actors here
PX_FORCE_INLINE void registerInActors();
// Interactions automatically unregister themselves from the actors here
PX_FORCE_INLINE void unregisterFromActors();
PX_FORCE_INLINE ActorSim& getActorSim0() const { return mActor0; }
PX_FORCE_INLINE ActorSim& getActorSim1() const { return mActor1; }
PX_FORCE_INLINE Scene& getScene() const { return mActor0.getScene(); }
PX_FORCE_INLINE InteractionType::Enum getType() const { return InteractionType::Enum(mInteractionType); }
PX_FORCE_INLINE PxU8 readInteractionFlag(PxU8 flag) const { return PxU8(mInteractionFlags & flag); }
PX_FORCE_INLINE void raiseInteractionFlag(InteractionFlag::Enum flag) { mInteractionFlags |= flag; }
PX_FORCE_INLINE void clearInteractionFlag(InteractionFlag::Enum flag) { mInteractionFlags &= ~flag; }
/**
\brief Mark the interaction as dirty. This will put the interaction into a list that is processed once per simulation step.
@see InteractionDirtyFlag
*/
PX_FORCE_INLINE void setDirty(PxU32 dirtyFlags);
/**
\brief Clear all flags that mark the interaction as dirty and optionally remove the interaction from the list of dirty interactions.
@see InteractionDirtyFlag
*/
/*PX_FORCE_INLINE*/ void setClean(bool removeFromList);
PX_FORCE_INLINE PxIntBool needsRefiltering() const { return (getDirtyFlags() & InteractionDirtyFlag::eFILTER_STATE); }
PX_FORCE_INLINE PxIntBool isElementInteraction() const;
PX_FORCE_INLINE void setInteractionId(PxU32 id) { mSceneId = id; }
PX_FORCE_INLINE PxU32 getInteractionId() const { return mSceneId; }
PX_FORCE_INLINE bool isRegistered() const { return mSceneId != PX_INVALID_INTERACTION_SCENE_ID; }
PX_FORCE_INLINE void setActorId(ActorSim* actor, PxU32 id);
PX_FORCE_INLINE PxU32 getActorId(const ActorSim* actor) const;
PX_FORCE_INLINE PxU8 getDirtyFlags() const { return mDirtyFlags; }
private:
void addToDirtyList();
void removeFromDirtyList();
ActorSim& mActor0;
ActorSim& mActor1;
// PT: TODO: merge the 6bits of the 3 PxU8s in the top bits of the 3 PxU32s
PxU32 mSceneId; // PT: TODO: merge this with mInteractionType
// PT: TODO: are those IDs even worth caching? Since the number of interactions per actor is (or should be) small,
// we could just do a linear search and save memory here...
PxU32 mActorId0; // PT: id of this interaction within mActor0's mInteractions array
PxU32 mActorId1; // PT: id of this interaction within mActor1's mInteractions array
protected:
const PxU8 mInteractionType; // PT: stored on a byte to save space, should be InteractionType enum, 5/6 bits needed here
PxU8 mInteractionFlags; // PT: 6 bits needed here, see InteractionFlag enum
PxU8 mDirtyFlags; // PT: 6 bits needed here, see InteractionDirtyFlag enum
PxU8 mPadding8;
};
} // namespace Sc
//////////////////////////////////////////////////////////////////////////
PX_FORCE_INLINE void Sc::Interaction::registerInActors()
{
mActor0.registerInteractionInActor(this);
mActor1.registerInteractionInActor(this);
}
PX_FORCE_INLINE void Sc::Interaction::unregisterFromActors()
{
mActor0.unregisterInteractionFromActor(this);
mActor1.unregisterInteractionFromActor(this);
}
PX_FORCE_INLINE void Sc::Interaction::setActorId(ActorSim* actor, PxU32 id)
{
PX_ASSERT(id != PX_INVALID_INTERACTION_ACTOR_ID);
PX_ASSERT(&mActor0 == actor || &mActor1 == actor);
if(&mActor0 == actor)
mActorId0 = id;
else
mActorId1 = id;
}
PX_FORCE_INLINE PxU32 Sc::Interaction::getActorId(const ActorSim* actor) const
{
PX_ASSERT(&mActor0 == actor || &mActor1 == actor);
return &mActor0 == actor ? mActorId0 : mActorId1;
}
PX_FORCE_INLINE PxIntBool Sc::Interaction::isElementInteraction() const
{
const PxIntBool res = readInteractionFlag(InteractionFlag::eRB_ELEMENT);
PX_ASSERT( (res &&
((getType() == InteractionType::eOVERLAP) ||
(getType() == InteractionType::eTRIGGER) ||
(getType() == InteractionType::eMARKER))) ||
(!res &&
((getType() == InteractionType::eCONSTRAINTSHADER) ||
(getType() == InteractionType::eARTICULATION))));
return res;
}
PX_FORCE_INLINE void Sc::Interaction::setDirty(PxU32 dirtyFlags)
{
PX_ASSERT(getType() != InteractionType::eARTICULATION);
mDirtyFlags |= PxTo8(dirtyFlags);
if(!readInteractionFlag(InteractionFlag::eIN_DIRTY_LIST))
{
addToDirtyList();
raiseInteractionFlag(InteractionFlag::eIN_DIRTY_LIST);
}
}
//PX_FORCE_INLINE void Sc::Interaction::setClean(bool removeFromList)
//{
// if (readInteractionFlag(InteractionFlag::eIN_DIRTY_LIST))
// {
// if (removeFromList) // if we process all dirty interactions anyway, then we can just clear the list at the end and save the work here.
// removeFromDirtyList();
// clearInteractionFlag(InteractionFlag::eIN_DIRTY_LIST);
// }
//
// mDirtyFlags = 0;
//}
}
#endif
| 8,185 | C | 38.167464 | 139 | 0.732071 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScContactStream.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-2023 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 SC_CONTACT_STREAM_H
#define SC_CONTACT_STREAM_H
#include "foundation/Px.h"
#include "PxSimulationEventCallback.h"
#include "ScObjectIDTracker.h"
#include "ScRigidSim.h"
#include "ScStaticSim.h"
#include "ScBodySim.h"
namespace physx
{
class PxShape;
namespace Sc
{
class ActorPair;
// Internal counterpart of PxContactPair
struct ContactShapePair
{
public:
PxShape* shapes[2];
const PxU8* contactPatches;
const PxU8* contactPoints;
const PxReal* contactForces;
PxU32 requiredBufferSize;
PxU8 contactCount;
PxU8 patchCount;
PxU16 constraintStreamSize;
PxU16 flags;
PxU16 events;
PxU32 shapeID[2];
//26 (or 38 on 64bit)
};
PX_COMPILE_TIME_ASSERT(sizeof(ContactShapePair) == sizeof(PxContactPair));
struct ContactStreamManagerFlag
{
enum Enum
{
/**
\brief Need to test stream for shapes that were removed from the actor/scene
Usually this is the case when a shape gets removed from the scene, however, other operations that remove the
broadphase volume of a pair object have to be considered as well since the shape might get removed later after such an
operation. The scenarios to consider are:
\li shape gets removed (this includes raising PxActorFlag::eDISABLE_SIMULATION)
\li shape switches to eSCENE_QUERY_SHAPE only
\li shape switches to eTRIGGER_SHAPE
\li resetFiltering()
\li actor gets removed from an aggregate
*/
eTEST_FOR_REMOVED_SHAPES = (1<<0),
/**
\brief Invalid stream memory not allocated
*/
eINVALID_STREAM = (1<<1),
/**
\brief Incomplete stream will be reported
*/
eINCOMPLETE_STREAM = (1<<2),
/**
\brief The stream contains extra data with PxContactPairVelocity items where the post solver velocity needs to get written to.
Only valid for discrete collision (in CCD the post response velocity is available immediately).
*/
eNEEDS_POST_SOLVER_VELOCITY = (1<<3),
/**
\brief Marker for the next available free flag
*/
eNEXT_FREE_FLAG = (1<<4)
};
};
struct ContactStreamHeader
{
PxU16 contactPass; // marker for extra data to know when a new collison pass started (discrete collision -> CCD pass 1 -> CCD pass 2 -> ...)
PxU16 pad; // to keep the stream 4byte aligned
};
/**
\brief Contact report logic and data management.
The internal contact report stream has the following format:
ContactStreamHeader | PxContactPairIndex0 | (PxContactPairPose0, PxContactPairVelocity0) | ... | PxContactPairIndexN | (PxContactPairPoseN, PxContactPairVelocityN) | (unused memory up to maxExtraDataSize ) |
PxContactPair0 | ... | PxContactPairM | (unsued pairs up to maxPairCount)
*/
class ContactStreamManager
{
public:
PX_FORCE_INLINE ContactStreamManager() : maxPairCount(0), flags_and_maxExtraDataBlocks(0) {}
PX_FORCE_INLINE ~ContactStreamManager() {}
PX_FORCE_INLINE void reset();
PX_FORCE_INLINE PxU16 getFlags() const;
PX_FORCE_INLINE void raiseFlags(PxU16 flags);
PX_FORCE_INLINE void clearFlags(PxU16 flags);
PX_FORCE_INLINE PxU32 getMaxExtraDataSize() const;
PX_FORCE_INLINE void setMaxExtraDataSize(PxU32 size); // size in bytes (will translate into blocks internally)
PX_FORCE_INLINE Sc::ContactShapePair* getShapePairs(PxU8* contactReportPairData) const;
PX_FORCE_INLINE static void convertDeletedShapesInContactStream(ContactShapePair*, PxU32 pairCount, const ObjectIDTracker&);
PX_FORCE_INLINE static PxU32 computeExtraDataBlockCount(PxU32 extraDataSize);
PX_FORCE_INLINE static PxU32 computeExtraDataBlockSize(PxU32 extraDataSize);
PX_FORCE_INLINE static PxU16 computeContactReportExtraDataSize(PxU32 extraDataFlags, bool addHeader);
PX_FORCE_INLINE static void fillInContactReportExtraData(PxContactPairVelocity*, PxU32 index, const ActorSim&, bool isCCDPass);
PX_FORCE_INLINE static void fillInContactReportExtraData(PxContactPairPose*, PxU32 index, const ActorSim&, bool isCCDPass, const bool useCurrentTransform);
PX_FORCE_INLINE void fillInContactReportExtraData(PxU8* stream, PxU32 extraDataFlags, const ActorSim&, const ActorSim&, PxU32 ccdPass, const bool useCurrentTransform, PxU32 pairIndex, PxU32 sizeOffset);
PX_FORCE_INLINE void setContactReportPostSolverVelocity(PxU8* stream, const ActorSim&, const ActorSim&);
PxU32 bufferIndex; // marks the start of the shape pair stream of the actor pair (byte offset with respect to global contact buffer stream)
PxU16 maxPairCount; // used to reserve the same amount of memory as in the last frame (as an initial guess)
PxU16 currentPairCount; // number of shape pairs stored in the buffer
PxU16 extraDataSize; // size of the extra data section in the stream
private:
PxU16 flags_and_maxExtraDataBlocks; // used to reserve the same amount of memory as in the last frame (as an initial guess)
public:
static const PxU32 sExtraDataBlockSizePow2 = 4; // extra data gets allocated as a multiple of 2^sExtraDataBlockSizePow2 to keep memory low of this struct.
static const PxU32 sFlagMask = (ContactStreamManagerFlag::eNEXT_FREE_FLAG - 1);
static const PxU32 sMaxExtraDataShift = 4; // shift necessary to extract the maximum number of blocks allocated for extra data
PX_COMPILE_TIME_ASSERT(ContactStreamManagerFlag::eNEXT_FREE_FLAG == (1 << sMaxExtraDataShift));
};
} // namespace Sc
PX_FORCE_INLINE void Sc::ContactStreamManager::reset()
{
currentPairCount = 0;
extraDataSize = 0;
flags_and_maxExtraDataBlocks &= ~sFlagMask;
}
PX_FORCE_INLINE PxU16 Sc::ContactStreamManager::getFlags() const
{
return (flags_and_maxExtraDataBlocks & sFlagMask);
}
PX_FORCE_INLINE void Sc::ContactStreamManager::raiseFlags(PxU16 flags)
{
PX_ASSERT(flags < ContactStreamManagerFlag::eNEXT_FREE_FLAG);
flags_and_maxExtraDataBlocks |= flags;
}
PX_FORCE_INLINE void Sc::ContactStreamManager::clearFlags(PxU16 flags)
{
PX_ASSERT(flags < ContactStreamManagerFlag::eNEXT_FREE_FLAG);
PxU16 tmpFlags = getFlags();
tmpFlags &= ~flags;
flags_and_maxExtraDataBlocks &= ~sFlagMask;
raiseFlags(tmpFlags);
}
PX_FORCE_INLINE PxU32 Sc::ContactStreamManager::getMaxExtraDataSize() const
{
return PxU32((flags_and_maxExtraDataBlocks >> sMaxExtraDataShift) << sExtraDataBlockSizePow2);
}
PX_FORCE_INLINE void Sc::ContactStreamManager::setMaxExtraDataSize(PxU32 size)
{
PxU32 nbBlocks = computeExtraDataBlockCount(size);
flags_and_maxExtraDataBlocks = PxTo16((flags_and_maxExtraDataBlocks & sFlagMask) | (nbBlocks << sMaxExtraDataShift));
}
PX_FORCE_INLINE Sc::ContactShapePair* Sc::ContactStreamManager::getShapePairs(PxU8* contactReportPairData) const
{
return reinterpret_cast<Sc::ContactShapePair*>(contactReportPairData + getMaxExtraDataSize());
}
PX_FORCE_INLINE void Sc::ContactStreamManager::convertDeletedShapesInContactStream(ContactShapePair* shapePairs, PxU32 pairCount, const ObjectIDTracker& tracker)
{
for(PxU32 i=0; i < pairCount; i++)
{
ContactShapePair& csp = shapePairs[i];
PxU32 shape0ID = csp.shapeID[0];
PxU32 shape1ID = csp.shapeID[1];
PxU16 flags = csp.flags;
PX_COMPILE_TIME_ASSERT(sizeof(flags) == sizeof((reinterpret_cast<ContactShapePair*>(0))->flags));
if (tracker.isDeletedID(shape0ID))
flags |= PxContactPairFlag::eREMOVED_SHAPE_0;
if (tracker.isDeletedID(shape1ID))
flags |= PxContactPairFlag::eREMOVED_SHAPE_1;
csp.flags = flags;
}
}
PX_FORCE_INLINE PxU32 Sc::ContactStreamManager::computeExtraDataBlockCount(PxU32 extraDataSize_)
{
PxU32 nbBlocks;
if (extraDataSize_ & ((1 << sExtraDataBlockSizePow2) - 1)) // not a multiple of block size -> need one block more
nbBlocks = (extraDataSize_ >> sExtraDataBlockSizePow2) + 1;
else
nbBlocks = (extraDataSize_ >> sExtraDataBlockSizePow2);
return nbBlocks;
}
PX_FORCE_INLINE PxU32 Sc::ContactStreamManager::computeExtraDataBlockSize(PxU32 extraDataSize_)
{
return (computeExtraDataBlockCount(extraDataSize_) << sExtraDataBlockSizePow2);
}
PX_FORCE_INLINE PxU16 Sc::ContactStreamManager::computeContactReportExtraDataSize(PxU32 extraDataFlags, bool addHeader)
{
PX_ASSERT(extraDataFlags);
PxU16 extraDataSize_ = sizeof(PxContactPairIndex);
if (extraDataFlags & PxPairFlag::ePRE_SOLVER_VELOCITY)
extraDataSize_ += sizeof(PxContactPairVelocity);
if (extraDataFlags & PxPairFlag::ePOST_SOLVER_VELOCITY)
extraDataSize_ += sizeof(PxContactPairVelocity);
if (extraDataFlags & PxPairFlag::eCONTACT_EVENT_POSE)
extraDataSize_ += sizeof(PxContactPairPose);
if (addHeader)
extraDataSize_ += sizeof(ContactStreamHeader);
return extraDataSize_;
}
PX_FORCE_INLINE void Sc::ContactStreamManager::fillInContactReportExtraData(PxContactPairVelocity* cpVel, PxU32 index, const ActorSim& rs, bool isCCDPass)
{
if (rs.getActorType() != PxActorType::eRIGID_STATIC)
{
const BodySim& bs = static_cast<const BodySim&>(rs);
if ((!isCCDPass) || (cpVel->type == PxContactPairExtraDataType::ePOST_SOLVER_VELOCITY))
{
const BodyCore& bc = bs.getBodyCore();
cpVel->linearVelocity[index] = bc.getLinearVelocity();
cpVel->angularVelocity[index] = bc.getAngularVelocity();
}
else
{
PX_ASSERT(cpVel->type == PxContactPairExtraDataType::ePRE_SOLVER_VELOCITY);
const Cm::SpatialVector& vel = bs.getLowLevelBody().getPreSolverVelocities();
cpVel->linearVelocity[index] = vel.linear;
cpVel->angularVelocity[index] = vel.angular;
}
}
else
{
cpVel->linearVelocity[index] = PxVec3(0.0f);
cpVel->angularVelocity[index] = PxVec3(0.0f);
}
}
PX_FORCE_INLINE void Sc::ContactStreamManager::fillInContactReportExtraData(PxContactPairPose* cpPose, PxU32 index, const ActorSim& rs, bool isCCDPass, const bool useCurrentTransform)
{
if(rs.getActorType() != PxActorType::eRIGID_STATIC)
{
const BodySim& bs = static_cast<const BodySim&>(rs);
const BodyCore& bc = bs.getBodyCore();
const PxTransform& src = (!isCCDPass && useCurrentTransform) ? bc.getBody2World() : bs.getLowLevelBody().getLastCCDTransform();
// PT:: tag: scalar transform*transform
cpPose->globalPose[index] = src * bc.getBody2Actor().getInverse();
}
else
{
const StaticSim& ss = static_cast<const StaticSim&>(rs);
const StaticCore& sc = ss.getStaticCore();
cpPose->globalPose[index] = sc.getActor2World();
}
}
PX_FORCE_INLINE void Sc::ContactStreamManager::fillInContactReportExtraData(PxU8* stream, PxU32 extraDataFlags, const ActorSim& rs0, const ActorSim& rs1, PxU32 ccdPass, const bool useCurrentTransform,
PxU32 pairIndex, PxU32 sizeOffset)
{
ContactStreamHeader* strHeader = reinterpret_cast<ContactStreamHeader*>(stream);
strHeader->contactPass = PxTo16(ccdPass);
stream += sizeOffset;
PxU8* edStream = stream;
bool isCCDPass = (ccdPass != 0);
{
PxContactPairIndex* cpIndex = reinterpret_cast<PxContactPairIndex*>(edStream);
cpIndex->type = PxContactPairExtraDataType::eCONTACT_PAIR_INDEX;
cpIndex->index = PxTo16(pairIndex);
edStream += sizeof(PxContactPairIndex);
PX_ASSERT(edStream <= reinterpret_cast<PxU8*>(getShapePairs(stream)));
}
// Important: make sure this one is the first after the PxContactPairIndex item for discrete contacts as it needs to get filled in before the reports get sent
// (post solver velocity is not available when it gets created)
if (extraDataFlags & PxPairFlag::ePOST_SOLVER_VELOCITY)
{
PxContactPairVelocity* cpVel = reinterpret_cast<PxContactPairVelocity*>(edStream);
cpVel->type = PxContactPairExtraDataType::ePOST_SOLVER_VELOCITY;
edStream += sizeof(PxContactPairVelocity);
if (!isCCDPass)
raiseFlags(ContactStreamManagerFlag::eNEEDS_POST_SOLVER_VELOCITY); // don't know the post solver velocity yet
else
{
ContactStreamManager::fillInContactReportExtraData(cpVel, 0, rs0, true);
ContactStreamManager::fillInContactReportExtraData(cpVel, 1, rs1, true);
}
PX_ASSERT(edStream <= reinterpret_cast<PxU8*>(getShapePairs(stream)));
}
if (extraDataFlags & PxPairFlag::ePRE_SOLVER_VELOCITY)
{
PxContactPairVelocity* cpVel = reinterpret_cast<PxContactPairVelocity*>(edStream);
cpVel->type = PxContactPairExtraDataType::ePRE_SOLVER_VELOCITY;
ContactStreamManager::fillInContactReportExtraData(cpVel, 0, rs0, isCCDPass);
ContactStreamManager::fillInContactReportExtraData(cpVel, 1, rs1, isCCDPass);
edStream += sizeof(PxContactPairVelocity);
PX_ASSERT(edStream <= reinterpret_cast<PxU8*>(getShapePairs(stream)));
}
if (extraDataFlags & PxPairFlag::eCONTACT_EVENT_POSE)
{
PxContactPairPose* cpPose = reinterpret_cast<PxContactPairPose*>(edStream);
cpPose->type = PxContactPairExtraDataType::eCONTACT_EVENT_POSE;
ContactStreamManager::fillInContactReportExtraData(cpPose, 0, rs0, isCCDPass, useCurrentTransform);
ContactStreamManager::fillInContactReportExtraData(cpPose, 1, rs1, isCCDPass, useCurrentTransform);
edStream += sizeof(PxContactPairPose);
PX_ASSERT(edStream <= reinterpret_cast<PxU8*>(getShapePairs(stream)));
}
extraDataSize = PxTo16(sizeOffset + PxU32(edStream - stream));
}
PX_FORCE_INLINE void Sc::ContactStreamManager::setContactReportPostSolverVelocity(PxU8* stream, const ActorSim& rs0, const ActorSim& rs1)
{
PX_ASSERT(extraDataSize > (sizeof(ContactStreamHeader) + sizeof(PxContactPairIndex)));
PxContactPairVelocity* cpVel = reinterpret_cast<PxContactPairVelocity*>(stream + sizeof(ContactStreamHeader) + sizeof(PxContactPairIndex));
PX_ASSERT(cpVel->type == PxContactPairExtraDataType::ePOST_SOLVER_VELOCITY);
fillInContactReportExtraData(cpVel, 0, rs0, false);
fillInContactReportExtraData(cpVel, 1, rs1, false);
clearFlags(ContactStreamManagerFlag::eNEEDS_POST_SOLVER_VELOCITY);
}
}
#endif
| 15,260 | C | 36.962686 | 208 | 0.759174 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScNPhaseCore.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-2023 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 SC_NPHASE_CORE_H
#define SC_NPHASE_CORE_H
#include "foundation/PxHash.h"
#include "foundation/PxUserAllocated.h"
#include "foundation/PxHashSet.h"
#include "foundation/PxHashMap.h"
#include "foundation/PxMutex.h"
#include "foundation/PxAtomic.h"
#include "PxPhysXConfig.h"
#include "foundation/PxPool.h"
#include "PxSimulationEventCallback.h"
#include "ScTriggerPairs.h"
#include "ScScene.h"
#include "ScContactReportBuffer.h"
namespace physx
{
namespace Bp
{
struct AABBOverlap;
struct BroadPhasePair;
}
namespace Sc
{
class ActorSim;
class ElementSim;
class ShapeSimBase;
class Interaction;
class ElementSimInteraction;
class ElementInteractionMarker;
class TriggerInteraction;
class ShapeInteraction;
class ActorPair;
class ActorPairReport;
class ActorPairContactReportData;
struct ContactShapePair;
class NPhaseContext;
class ContactStreamManager;
struct FilterPair;
class FilterPairManager;
class ActorSim;
class TriggerContactTask;
struct PairReleaseFlag
{
enum Enum
{
eRUN_LOST_TOUCH_LOGIC = (1 << 0), // run the lost-touch-logic for a pair that gets removed.
eWAKE_ON_LOST_TOUCH = (1 << 1) // a pair that lost touch should check whether the actors should get woken up
};
};
/*
NPhaseCore encapsulates the near phase processing to allow multiple implementations(eg threading and non threaded).
The broadphase inserts shape pairs into the NPhaseCore, which are then processed into contact point streams.
Pairs can then be processed into AxisConstraints by the GroupSolveCore.
*/
struct BodyPairKey
{
PX_FORCE_INLINE BodyPairKey(PxU32 sim0, PxU32 sim1) : mSim0(sim0), mSim1(sim1) {}
const PxU32 mSim0;
const PxU32 mSim1;
PX_FORCE_INLINE bool operator == (const BodyPairKey& pair) const { return mSim0 == pair.mSim0 && mSim1 == pair.mSim1; }
};
PX_INLINE PxU32 PxComputeHash(const BodyPairKey& key)
{
const PxU32 add0 = key.mSim0;
const PxU32 add1 = key.mSim1;
const PxU32 base = PxU32((add0 & 0xFFFF) | (add1 << 16));
return physx::PxComputeHash(base);
}
struct ElementSimKey
{
PxU32 mID0;
PxU32 mID1;
ElementSimKey() : mID0(0xffffffff), mID1(0xffffffff)
{}
ElementSimKey(PxU32 id0, PxU32 id1)
{
if(id0 > id1)
PxSwap(id0, id1);
mID0 = id0;
mID1 = id1;
}
PX_FORCE_INLINE bool operator == (const ElementSimKey& pair) const { return mID0 == pair.mID0 && mID1 == pair.mID1; }
};
PX_INLINE PxU32 PxComputeHash(const ElementSimKey& key)
{
const PxU64 base = PxU64(key.mID0) | (PxU64(key.mID1) << 32);
return physx::PxComputeHash(base);
}
class ContactReportAllocationManager
{
PxU8* mBuffer;
PxU32 mBufferSize;
PxU32 mCurrentBufferIndex;
PxU32 mCurrentOffset;
ContactReportBuffer& mReportBuffer;
PxMutex& mMutex;
const PxU32 mBuferBlockSize;
PX_NOCOPY(ContactReportAllocationManager)
public:
ContactReportAllocationManager(ContactReportBuffer& buffer, PxMutex& mutex, const PxU32 bufferBlockSize = 16384) : mBuffer(NULL), mBufferSize(0), mCurrentBufferIndex(0),
mCurrentOffset(0), mReportBuffer(buffer), mMutex(mutex), mBuferBlockSize(bufferBlockSize)
{
}
PxU8* allocate(PxU32 size, PxU32& index, PxU32 alignment = 16u)
{
//(1) fix up offsets...
const PxU32 pad = ((mCurrentBufferIndex + alignment - 1)&~(alignment - 1)) - mCurrentBufferIndex;
PxU32 currOffset = mCurrentOffset + pad;
if ((currOffset + size) > mBufferSize)
{
const PxU32 allocSize = PxMax(size, mBuferBlockSize);
mMutex.lock();
mBuffer = mReportBuffer.allocateNotThreadSafe(allocSize, mCurrentBufferIndex, alignment);
mCurrentOffset = currOffset = 0;
mBufferSize = allocSize;
mMutex.unlock();
}
PxU8* ret = mBuffer + currOffset;
index = mCurrentBufferIndex + currOffset;
mCurrentOffset = currOffset + size;
return ret;
}
};
class TriggerProcessingContext
{
public:
TriggerProcessingContext()
: mTmpTriggerProcessingBlock(NULL)
, mTmpTriggerPairCount(0)
{
}
bool initialize(TriggerInteraction**, PxU32 pairCount, PxcScratchAllocator&);
void deinitialize(PxcScratchAllocator&);
PX_FORCE_INLINE TriggerInteraction* const* getTriggerInteractions() const
{
return reinterpret_cast<TriggerInteraction**>(mTmpTriggerProcessingBlock);
}
PX_FORCE_INLINE PxU32 getTriggerInteractionCount() const
{
return mTmpTriggerPairCount;
}
PX_FORCE_INLINE TriggerContactTask* getTriggerContactTasks()
{
const PxU32 offset = mTmpTriggerPairCount * sizeof(TriggerInteraction*);
return reinterpret_cast<TriggerContactTask*>(mTmpTriggerProcessingBlock + offset);
}
PX_FORCE_INLINE PxMutex& getTriggerWriteBackLock()
{
return mTriggerWriteBackLock;
}
private:
PxU8* mTmpTriggerProcessingBlock; // temporary memory block to process trigger pairs in parallel
// (see comment in Sc::Scene::postIslandGen too)
PxU32 mTmpTriggerPairCount;
PxMutex mTriggerWriteBackLock;
};
class NPhaseCore : public PxUserAllocated
{
PX_NOCOPY(NPhaseCore)
public:
NPhaseCore(Scene& scene, const PxSceneDesc& desc);
~NPhaseCore();
ElementSimInteraction* findInteraction(const ElementSim* element0, const ElementSim* element1);
void onTriggerOverlapCreated(const Bp::AABBOverlap* PX_RESTRICT pairs, PxU32 pairCount);
void runOverlapFilters( PxU32 nbToProcess, const Bp::AABBOverlap* PX_RESTRICT pairs, FilterInfo* PX_RESTRICT filterInfo,
PxU32& nbToKeep, PxU32& nbToSuppress, PxU32* PX_RESTRICT keepMap);
void onOverlapRemoved(ElementSim* volume0, ElementSim* volume1, PxU32 ccdPass, void* elemSim, PxsContactManagerOutputIterator& outputs);
void onVolumeRemoved(ElementSim* volume, PxU32 flags, PxsContactManagerOutputIterator& outputs);
void managerNewTouch(Sc::ShapeInteraction& interaction);
PxU32 getDefaultContactReportStreamBufferSize() const;
void fireCustomFilteringCallbacks(PxsContactManagerOutputIterator& outputs);
void addToDirtyInteractionList(Interaction* interaction);
void removeFromDirtyInteractionList(Interaction* interaction);
void updateDirtyInteractions(PxsContactManagerOutputIterator& outputs);
/**
\brief Allocate buffers for trigger overlap test.
See comment in Sc::Scene::postIslandGen for why this is split up into multiple parts.
\param[in] continuation The task to run after trigger processing.
\return The concluding trigger processing task if there is work to do, else NULL.
*/
PxBaseTask* prepareForTriggerInteractionProcessing(PxBaseTask* continuation);
// Perform trigger overlap tests.
void processTriggerInteractions(PxBaseTask& continuation);
// Deactivate trigger interactions if possible, free buffers from overlap tests and clean up.
// See comment in Sc::Scene::postIslandGen for why this is split up into multiple parts.
void concludeTriggerInteractionProcessing(PxBaseTask* continuation);
// Check candidates for persistent touch contact events and create those events if necessary.
void processPersistentContactEvents(PxsContactManagerOutputIterator& outputs);
PX_FORCE_INLINE void addToContactReportActorPairSet(ActorPairReport* pair) { mContactReportActorPairSet.pushBack(pair); }
void clearContactReportActorPairs(bool shrinkToZero);
PX_FORCE_INLINE PxU32 getNbContactReportActorPairs() const { return mContactReportActorPairSet.size(); }
PX_FORCE_INLINE ActorPairReport* const* getContactReportActorPairs() const { return mContactReportActorPairSet.begin(); }
void addToPersistentContactEventPairs(ShapeInteraction*);
void addToPersistentContactEventPairsDelayed(ShapeInteraction*);
void removeFromPersistentContactEventPairs(ShapeInteraction*);
PX_FORCE_INLINE PxU32 getCurrentPersistentContactEventPairCount() const { return mNextFramePersistentContactEventPairIndex; }
PX_FORCE_INLINE ShapeInteraction* const* getCurrentPersistentContactEventPairs() const { return mPersistentContactEventPairList.begin(); }
PX_FORCE_INLINE PxU32 getAllPersistentContactEventPairCount() const { return mPersistentContactEventPairList.size(); }
PX_FORCE_INLINE ShapeInteraction* const* getAllPersistentContactEventPairs() const { return mPersistentContactEventPairList.begin(); }
PX_FORCE_INLINE void preparePersistentContactEventListForNextFrame();
void addToForceThresholdContactEventPairs(ShapeInteraction*);
void removeFromForceThresholdContactEventPairs(ShapeInteraction*);
PX_FORCE_INLINE PxU32 getForceThresholdContactEventPairCount() const { return mForceThresholdContactEventPairList.size(); }
PX_FORCE_INLINE ShapeInteraction* const* getForceThresholdContactEventPairs() const { return mForceThresholdContactEventPairList.begin(); }
PX_FORCE_INLINE PxU8* getContactReportPairData(const PxU32& bufferIndex) const { return mContactReportBuffer.getData(bufferIndex); }
PxU8* reserveContactReportPairData(PxU32 pairCount, PxU32 extraDataSize, PxU32& bufferIndex, ContactReportAllocationManager* alloc = NULL);
PxU8* resizeContactReportPairData(PxU32 pairCount, PxU32 extraDataSize, Sc::ContactStreamManager& csm);
PX_FORCE_INLINE void clearContactReportStream() { mContactReportBuffer.reset(); } // Do not free memory at all
PX_FORCE_INLINE void freeContactReportStreamMemory() { mContactReportBuffer.flush(); }
ActorPairContactReportData* createActorPairContactReportData();
void releaseActorPairContactReportData(ActorPairContactReportData* data);
void registerInteraction(ElementSimInteraction* interaction);
void unregisterInteraction(ElementSimInteraction* interaction);
ElementSimInteraction* createRbElementInteraction(const FilterInfo& fInfo, ShapeSimBase& s0, ShapeSimBase& s1, PxsContactManager* contactManager, Sc::ShapeInteraction* shapeInteraction,
Sc::ElementInteractionMarker* interactionMarker, bool isTriggerPair);
void lockReports() { mReportAllocLock.lock(); }
void unlockReports() { mReportAllocLock.unlock(); }
private:
void callPairLost(const ShapeSimBase& s0, const ShapeSimBase& s1, bool objVolumeRemoved);
ElementSimInteraction* createTriggerElementInteraction(ShapeSimBase& s0, ShapeSimBase& s1);
// removedElement: points to the removed element (that is, the BP volume wrapper), if a pair gets removed or loses touch due to a removed element.
// NULL if not triggered by a removed element.
//
void releaseElementPair(ElementSimInteraction* pair, PxU32 flags, ElementSim* removedElement, PxU32 ccdPass, bool removeFromDirtyList, PxsContactManagerOutputIterator& outputs);
void lostTouchReports(ShapeInteraction* pair, PxU32 flags, ElementSim* removedElement, PxU32 ccdPass, PxsContactManagerOutputIterator& outputs);
ShapeInteraction* createShapeInteraction(ShapeSimBase& s0, ShapeSimBase& s1, PxPairFlags pairFlags, PxsContactManager* contactManager, Sc::ShapeInteraction* shapeInteraction);
TriggerInteraction* createTriggerInteraction(ShapeSimBase& s0, ShapeSimBase& s1, PxPairFlags triggerFlags);
ElementInteractionMarker* createElementInteractionMarker(ElementSim& e0, ElementSim& e1, ElementInteractionMarker* marker);
//------------- Filtering -------------
ElementSimInteraction* refilterInteraction(ElementSimInteraction* pair, const FilterInfo* filterInfo, bool removeFromDirtyList, PxsContactManagerOutputIterator& outputs);
//-------------------------------------
ElementSimInteraction* convert(ElementSimInteraction* pair, InteractionType::Enum type, FilterInfo& filterInfo, bool removeFromDirtyList, PxsContactManagerOutputIterator& outputs);
ActorPair* findActorPair(ShapeSimBase* s0, ShapeSimBase* s1, PxIntBool isReportPair);
PX_FORCE_INLINE void destroyActorPairReport(ActorPairReport&);
// Pooling
Scene& mOwnerScene;
PxArray<ActorPairReport*> mContactReportActorPairSet;
PxArray<ShapeInteraction*> mPersistentContactEventPairList; // Pairs which request events which do not get triggered by the sdk and thus need to be tested actively every frame.
// May also contain force threshold event pairs (see mForceThresholdContactEventPairList)
// This list is split in two, the elements in front are for the current frame, the elements at the
// back will get added next frame.
PxU32 mNextFramePersistentContactEventPairIndex; // start index of the pairs which need to get added to the persistent list for next frame
PxArray<ShapeInteraction*> mForceThresholdContactEventPairList; // Pairs which request force threshold contact events. A pair is only in this list if it does have contact.
// Note: If a pair additionally requests PxPairFlag::eNOTIFY_TOUCH_PERSISTS events, then it
// goes into mPersistentContactEventPairList instead. This allows to share the list index.
// data layout:
// ContactActorPair0_ExtraData, ContactShapePair0_0, ContactShapePair0_1, ... ContactShapePair0_N,
// ContactActorPair1_ExtraData, ContactShapePair1_0, ...
//
ContactReportBuffer mContactReportBuffer; // Shape pair information for contact reports
PxCoalescedHashSet<Interaction*> mDirtyInteractions;
// Pools
PxPool<ActorPair> mActorPairPool;
PxPool<ActorPairReport> mActorPairReportPool;
PxPool<ShapeInteraction> mShapeInteractionPool;
PxPool<TriggerInteraction> mTriggerInteractionPool;
PxPool<ActorPairContactReportData> mActorPairContactReportDataPool;
PxPool<ElementInteractionMarker> mInteractionMarkerPool;
Cm::DelegateTask<Sc::NPhaseCore, &Sc::NPhaseCore::concludeTriggerInteractionProcessing> mConcludeTriggerInteractionProcessingTask;
TriggerProcessingContext mTriggerProcessingContext;
PxHashMap<BodyPairKey, ActorPair*> mActorPairMap;
PxHashMap<ElementSimKey, ElementSimInteraction*> mElementSimMap;
PxMutex mBufferAllocLock;
PxMutex mReportAllocLock;
friend class Sc::Scene;
friend class Sc::ShapeInteraction;
};
struct FilteringContext
{
PX_NOCOPY(FilteringContext)
public:
FilteringContext(const Sc::Scene& scene) :
mFilterShader (scene.getFilterShaderFast()),
mFilterShaderData (scene.getFilterShaderDataFast()),
mFilterShaderDataSize (scene.getFilterShaderDataSizeFast()),
mFilterCallback (scene.getFilterCallbackFast()),
mKineKineFilteringMode (scene.getKineKineFilteringMode()),
mStaticKineFilteringMode(scene.getStaticKineFilteringMode())
{
}
PxSimulationFilterShader mFilterShader;
const void* mFilterShaderData;
PxU32 mFilterShaderDataSize;
PxSimulationFilterCallback* mFilterCallback;
const PxPairFilteringMode::Enum mKineKineFilteringMode;
const PxPairFilteringMode::Enum mStaticKineFilteringMode;
};
} // namespace Sc
PX_FORCE_INLINE void Sc::NPhaseCore::preparePersistentContactEventListForNextFrame()
{
// reports have been processed -> "activate" next frame candidates for persistent contact events
mNextFramePersistentContactEventPairIndex = mPersistentContactEventPairList.size();
}
}
#endif
| 16,717 | C | 39.1875 | 188 | 0.77155 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScShapeInteraction.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScShapeInteraction.h"
#if PX_SUPPORT_GPU_PHYSX
#include "ScParticleSystemSim.h"
#endif
using namespace physx;
Sc::ShapeInteraction::ShapeInteraction(ShapeSimBase& s1, ShapeSimBase& s2, PxPairFlags pairFlags, PxsContactManager* contactManager) :
ElementSimInteraction (s1, s2, InteractionType::eOVERLAP, InteractionFlag::eRB_ELEMENT|InteractionFlag::eFILTERABLE),
mActorPair (NULL),
mManager (NULL),
mContactReportStamp (PX_INVALID_U32),
mReportPairIndex (INVALID_REPORT_PAIR_ID),
mEdgeIndex (IG_INVALID_EDGE),
mReportStreamIndex (0)
{
mFlags = 0;
// The PxPairFlags get stored in the SipFlag, make sure any changes get noticed
PX_COMPILE_TIME_ASSERT(PxPairFlag::eSOLVE_CONTACT == (1<<0));
PX_COMPILE_TIME_ASSERT(PxPairFlag::eMODIFY_CONTACTS == (1<<1));
PX_COMPILE_TIME_ASSERT(PxPairFlag::eNOTIFY_TOUCH_FOUND == (1<<2));
PX_COMPILE_TIME_ASSERT(PxPairFlag::eNOTIFY_TOUCH_PERSISTS == (1<<3));
PX_COMPILE_TIME_ASSERT(PxPairFlag::eNOTIFY_TOUCH_LOST == (1<<4));
PX_COMPILE_TIME_ASSERT(PxPairFlag::eNOTIFY_TOUCH_CCD == (1<<5));
PX_COMPILE_TIME_ASSERT(PxPairFlag::eNOTIFY_THRESHOLD_FORCE_FOUND == (1<<6));
PX_COMPILE_TIME_ASSERT(PxPairFlag::eNOTIFY_THRESHOLD_FORCE_PERSISTS == (1<<7));
PX_COMPILE_TIME_ASSERT(PxPairFlag::eNOTIFY_THRESHOLD_FORCE_LOST == (1<<8));
PX_COMPILE_TIME_ASSERT(PxPairFlag::eNOTIFY_CONTACT_POINTS == (1<<9));
PX_COMPILE_TIME_ASSERT(PxPairFlag::eDETECT_DISCRETE_CONTACT == (1<<10));
PX_COMPILE_TIME_ASSERT(PxPairFlag::eDETECT_CCD_CONTACT == (1<<11));
PX_COMPILE_TIME_ASSERT(PxPairFlag::ePRE_SOLVER_VELOCITY == (1<<12));
PX_COMPILE_TIME_ASSERT(PxPairFlag::ePOST_SOLVER_VELOCITY == (1<<13));
PX_COMPILE_TIME_ASSERT(PxPairFlag::eCONTACT_EVENT_POSE == (1<<14));
PX_COMPILE_TIME_ASSERT((PAIR_FLAGS_MASK & PxPairFlag::eSOLVE_CONTACT) == PxPairFlag::eSOLVE_CONTACT);
PX_COMPILE_TIME_ASSERT((PxPairFlag::eSOLVE_CONTACT | PAIR_FLAGS_MASK) == PAIR_FLAGS_MASK);
PX_COMPILE_TIME_ASSERT((PAIR_FLAGS_MASK & PxPairFlag::eCONTACT_EVENT_POSE) == PxPairFlag::eCONTACT_EVENT_POSE);
PX_COMPILE_TIME_ASSERT((PxPairFlag::eCONTACT_EVENT_POSE | PAIR_FLAGS_MASK) == PAIR_FLAGS_MASK);
setPairFlags(pairFlags);
//Add a fresh edge to the island manager.
Scene& scene = getScene();
//Sc::BodySim* bs0 = getShape0().getBodySim();
//Sc::BodySim* bs1 = getShape1().getBodySim();
Sc::ActorSim& bs0 = getShape0().getActor();
Sc::ActorSim& bs1 = getShape1().getActor();
updateFlags(scene, bs0, bs1, pairFlags);
if(contactManager == NULL)
{
PxNodeIndex indexA, indexB;
//if(bs0) // the first shape always belongs to a dynamic body (we assert for this above)
{
indexA = bs0.getNodeIndex();
bs0.registerCountedInteraction();
}
if(!bs1.isStaticRigid())
{
indexB = bs1.getNodeIndex();
bs1.registerCountedInteraction();
}
IG::SimpleIslandManager* simpleIslandManager = scene.getSimpleIslandManager();
const PxActorType::Enum actorTypeLargest = PxMax(bs0.getActorType(), bs1.getActorType());
IG::Edge::EdgeType type = IG::Edge::eCONTACT_MANAGER;
#if PX_SUPPORT_GPU_PHYSX
if (actorTypeLargest == PxActorType::eSOFTBODY)
type = IG::Edge::eSOFT_BODY_CONTACT;
if (actorTypeLargest == PxActorType::eFEMCLOTH)
type = IG::Edge::eFEM_CLOTH_CONTACT;
else if (isParticleSystem(actorTypeLargest))
type = IG::Edge::ePARTICLE_SYSTEM_CONTACT;
else if (actorTypeLargest == PxActorType::eHAIRSYSTEM)
type = IG::Edge::eHAIR_SYSTEM_CONTACT;
#endif
mEdgeIndex = simpleIslandManager->addContactManager(NULL, indexA, indexB, this, type);
{
const bool active = onActivate(contactManager);
registerInActors();
scene.registerInteraction(this, active);
}
//If it is a soft body or particle overlap, treat it as a contact for now (we can hook up touch found/lost events later maybe)
if (actorTypeLargest > PxActorType::eARTICULATION_LINK)
simpleIslandManager->setEdgeConnected(mEdgeIndex, type);
}
else
{
onActivate(contactManager);
}
}
Sc::ShapeInteraction::~ShapeInteraction()
{
Sc::ActorSim* body0 = &getShape0().getActor();
Sc::ActorSim* body1 = &getShape1().getActor();
body0->unregisterCountedInteraction();
if (body1)
body1->unregisterCountedInteraction();
if(mManager)
destroyManager();
if(mEdgeIndex != IG_INVALID_EDGE)
{
Scene& scene = getScene();
scene.getSimpleIslandManager()->removeConnection(mEdgeIndex);
mEdgeIndex = IG_INVALID_EDGE;
scene.unregisterInteraction(this);
}
// This will remove the interaction from the actors list, which will prevent
// update calls to this actor because of Body::wakeUp below.
unregisterFromActors();
if(mReportPairIndex != INVALID_REPORT_PAIR_ID)
removeFromReportPairList();
}
void Sc::ShapeInteraction::clearIslandGenData()
{
if(mEdgeIndex != IG_INVALID_EDGE)
{
Scene& scene = getScene();
scene.getSimpleIslandManager()->removeConnection(mEdgeIndex);
mEdgeIndex = IG_INVALID_EDGE;
}
}
PX_FORCE_INLINE void Sc::ShapeInteraction::processReportPairOnActivate()
{
PX_ASSERT(isReportPair());
PX_ASSERT(mReportPairIndex == INVALID_REPORT_PAIR_ID);
if(readFlag(WAS_IN_PERSISTENT_EVENT_LIST))
{
getScene().getNPhaseCore()->addToPersistentContactEventPairs(this);
mFlags &= ~WAS_IN_PERSISTENT_EVENT_LIST;
}
}
PX_FORCE_INLINE void Sc::ShapeInteraction::processReportPairOnDeactivate()
{
PX_ASSERT(isReportPair());
PX_ASSERT(mReportPairIndex != INVALID_REPORT_PAIR_ID);
PX_COMPILE_TIME_ASSERT(IS_IN_PERSISTENT_EVENT_LIST == (WAS_IN_PERSISTENT_EVENT_LIST >> 1));
PX_ASSERT(!(readFlag(WAS_IN_PERSISTENT_EVENT_LIST)));
const PxU32 wasInPersList = (mFlags & IS_IN_PERSISTENT_EVENT_LIST) << 1;
mFlags |= wasInPersList;
removeFromReportPairList();
}
void Sc::ShapeInteraction::setContactReportPostSolverVelocity(ContactStreamManager& cs)
{
Scene& scene = getScene();
NPhaseCore* npcore = scene.getNPhaseCore();
PxU8* stream = npcore->getContactReportPairData(cs.bufferIndex);
ActorPairReport& apr = getActorPairReport();
cs.setContactReportPostSolverVelocity(stream, apr.getActorA(), apr.getActorB());
}
void Sc::ShapeInteraction::resetManagerCachedState() const
{
if(mManager)
{
Sc::Scene& scene = getScene();
PxvNphaseImplementationContext* nphaseImplementationContext = scene.getLowLevelContext()->getNphaseImplementationContext();
PX_ASSERT(nphaseImplementationContext);
mManager->resetCachedState();
nphaseImplementationContext->refreshContactManager(mManager);
}
}
/*
This method can be called from various stages in the pipeline, some of which operate before the actor has advanced its pose and some after it has advanced its pose.
Discrete touch found events operate before the pose has been updated. This is because we are using the found event to active the bodies before solve so that we can just
solve the activated bodies.
Lost touch events occur after the pose has been updated.
*/
void Sc::ShapeInteraction::processUserNotificationSync()
{
PX_ASSERT(hasTouch());
if(mManager)
PxPrefetchLine(mManager);
// make sure shape A and shape B are the same way round as the actors (in compounds they may be swapped)
// TODO: make "unswapped" a SIP flag and set it in updateState()
if(!mActorPair)
return;
NPhaseCore* npcore = getScene().getNPhaseCore();
ActorPairReport& aPairReport = getActorPairReport();
if(!aPairReport.isInContactReportActorPairSet())
{
aPairReport.setInContactReportActorPairSet();
npcore->addToContactReportActorPairSet(&aPairReport);
aPairReport.incRefCount();
}
aPairReport.createContactStreamManager(*npcore);
}
void Sc::ShapeInteraction::processUserNotificationAsync(PxU32 contactEvent, PxU16 infoFlags, bool touchLost,
PxU32 ccdPass, bool useCurrentTransform, PxsContactManagerOutputIterator& outputs, ContactReportAllocationManager* alloc)
{
contactEvent = (!ccdPass) ? contactEvent : (contactEvent | PxPairFlag::eNOTIFY_TOUCH_CCD);
if(!mActorPair)
return;
ActorPairReport& aPairReport = getActorPairReport();
Scene& scene = getScene();
NPhaseCore* npcore = scene.getNPhaseCore();
ContactStreamManager& cs = aPairReport.createContactStreamManager(*npcore);
// Prepare user notification
const PxU32 timeStamp = scene.getTimeStamp();
const PxU32 shapePairTimeStamp = scene.getReportShapePairTimeStamp();
const PxU32 pairFlags = getPairFlags();
PX_ASSERT(pairFlags & contactEvent);
const PxU32 extraDataFlags = pairFlags & CONTACT_REPORT_EXTRA_DATA;
PxU8* stream = NULL;
ContactShapePair* pairStream = NULL;
const bool unswapped = &aPairReport.getActorA() == &getShape0().getActor();
const Sc::ShapeSimBase& shapeA = unswapped ? getShape0() : getShape1();
const Sc::ShapeSimBase& shapeB = unswapped ? getShape1() : getShape0();
if(aPairReport.streamResetStamp(timeStamp))
{
PX_ASSERT(mContactReportStamp != shapePairTimeStamp); // actor pair and shape pair timestamps must both be out of sync in this case
PxU16 maxCount;
if(cs.maxPairCount != 0)
maxCount = cs.maxPairCount; // use value from previous report
else
{
// TODO: Use some kind of heuristic
maxCount = 2;
cs.maxPairCount = maxCount;
}
PxU32 maxExtraDataSize;
if(!extraDataFlags || touchLost)
{
maxExtraDataSize = 0;
cs.setMaxExtraDataSize(maxExtraDataSize);
}
else
{
PxU32 currentMaxExtraDataSize = cs.getMaxExtraDataSize();
maxExtraDataSize = ContactStreamManager::computeContactReportExtraDataSize(extraDataFlags, true);
PX_ASSERT(maxExtraDataSize > 0);
if(maxExtraDataSize <= currentMaxExtraDataSize)
maxExtraDataSize = currentMaxExtraDataSize; // use value from previous report
else
cs.setMaxExtraDataSize(maxExtraDataSize);
}
stream = npcore->reserveContactReportPairData(maxCount, maxExtraDataSize, cs.bufferIndex, alloc);
if(!maxExtraDataSize) // this is the usual case, so set it first for branch prediction
cs.reset();
else if(stream)
{
cs.reset();
PX_ASSERT(extraDataFlags);
PX_ASSERT(!touchLost);
cs.fillInContactReportExtraData(stream, extraDataFlags, aPairReport.getActorA(), aPairReport.getActorB(), ccdPass, useCurrentTransform, 0, sizeof(ContactStreamHeader));
if((extraDataFlags & PxPairFlag::ePOST_SOLVER_VELOCITY) && (pairFlags & PxPairFlag::eDETECT_CCD_CONTACT))
scene.setPostSolverVelocityNeeded();
}
}
else
{
const PxU32 currentPairCount = cs.currentPairCount;
if(currentPairCount != 0)
{
PxU8* tmpStreamPtr = npcore->getContactReportPairData(cs.bufferIndex);
if(!extraDataFlags)
stream = tmpStreamPtr; // this is the usual case, so set it first for branch prediction
else
{
if(!touchLost)
{
// - the first few shape pair events might not request extra data
// - the events so far were due to touch lost
// - multiple reports due to CCD multiple passes
// Hence, the extra data has to be created/extended now.
//
const PxU16 oldExtraDataSize = cs.extraDataSize;
PxI32 lastContactPass;
if(oldExtraDataSize)
{
ContactStreamHeader* strHeader = reinterpret_cast<ContactStreamHeader*>(tmpStreamPtr);
lastContactPass = strHeader->contactPass;
}
else
lastContactPass = -1;
if(PxI32(ccdPass) > lastContactPass) // do not send extra data mulitple times for the same contact pass
{
const PxU16 extraDataSize = PxU16(oldExtraDataSize + ContactStreamManager::computeContactReportExtraDataSize(extraDataFlags, (oldExtraDataSize == 0)));
PxU8* strPtr;
if (extraDataSize <= cs.getMaxExtraDataSize())
strPtr = tmpStreamPtr;
else
strPtr = npcore->resizeContactReportPairData(currentPairCount < cs.maxPairCount ? cs.maxPairCount : PxU32(cs.maxPairCount+1), extraDataSize, cs);
// the check for max pair count is there to avoid another potential allocation further below
if(strPtr)
{
stream = strPtr;
PxU32 sizeOffset;
if(oldExtraDataSize)
sizeOffset = oldExtraDataSize;
else
sizeOffset = sizeof(ContactStreamHeader);
cs.fillInContactReportExtraData(strPtr, extraDataFlags, aPairReport.getActorA(), aPairReport.getActorB(), ccdPass, useCurrentTransform, currentPairCount, sizeOffset);
if((extraDataFlags & PxPairFlag::ePOST_SOLVER_VELOCITY) && (pairFlags & PxPairFlag::eDETECT_CCD_CONTACT))
scene.setPostSolverVelocityNeeded();
}
else
{
stream = tmpStreamPtr;
cs.raiseFlags(ContactStreamManagerFlag::eINCOMPLETE_STREAM);
}
}
else
stream = tmpStreamPtr;
}
else
stream = tmpStreamPtr;
}
}
}
if(stream)
pairStream = cs.getShapePairs(stream);
else
{
cs.raiseFlags(ContactStreamManagerFlag::eINVALID_STREAM);
return;
}
ContactShapePair* cp;
if(mContactReportStamp != shapePairTimeStamp)
{
// this shape pair is not in the contact notification stream yet
if(cs.currentPairCount < cs.maxPairCount)
cp = pairStream + cs.currentPairCount;
else
{
const PxU32 newSize = PxU32(cs.currentPairCount + (cs.currentPairCount >> 1) + 1);
stream = npcore->resizeContactReportPairData(newSize, cs.getMaxExtraDataSize(), cs);
if(stream)
{
pairStream = cs.getShapePairs(stream);
cp = pairStream + cs.currentPairCount;
}
else
{
cs.raiseFlags(ContactStreamManagerFlag::eINCOMPLETE_STREAM);
return;
}
}
//!!! why is alignment important here? Looks almost like some refactor nonsense
PX_ASSERT(0==(reinterpret_cast<uintptr_t>(stream) & 0x0f)); // check 16Byte alignment
mReportStreamIndex = cs.currentPairCount;
cp->shapes[0] = shapeA.getPxShape();
cp->shapes[1] = shapeB.getPxShape();
cp->contactPatches = NULL;
cp->contactPoints = NULL;
cp->contactForces = NULL;
cp->contactCount = 0;
cp->patchCount = 0;
cp->constraintStreamSize = 0;
cp->requiredBufferSize = 0;
cp->flags = infoFlags;
PX_ASSERT(contactEvent <= 0xffff);
cp->events = PxU16(contactEvent);
cp->shapeID[0] = shapeA.getElementID();
cp->shapeID[1] = shapeB.getElementID();
cs.currentPairCount++;
mContactReportStamp = shapePairTimeStamp;
}
else
{
// this shape pair is in the contact notification stream already but there is a second event (can happen with force threshold reports, for example).
PX_ASSERT(mReportStreamIndex < cs.currentPairCount);
cp = &pairStream[mReportStreamIndex];
cp->events |= contactEvent;
if(touchLost && cp->events & PxPairFlag::eNOTIFY_TOUCH_PERSISTS)
cp->events &= PxU16(~PxPairFlag::eNOTIFY_TOUCH_PERSISTS);
cp->flags |= infoFlags;
}
if((getPairFlags() & PxPairFlag::eNOTIFY_CONTACT_POINTS) && mManager && (!cp->contactPatches) && !(contactEvent & PxU32(PxPairFlag::eNOTIFY_TOUCH_LOST | PxPairFlag::eNOTIFY_THRESHOLD_FORCE_LOST)))
{
const PxcNpWorkUnit& workUnit = mManager->getWorkUnit();
PxsContactManagerOutput* output = NULL;
if(workUnit.mNpIndex & PxsContactManagerBase::NEW_CONTACT_MANAGER_MASK)
output = &getScene().getLowLevelContext()->getNphaseImplementationContext()->getNewContactManagerOutput(workUnit.mNpIndex);
else
output = &outputs.getContactManager(workUnit.mNpIndex);
const PxsCCDContactHeader* ccdContactData = reinterpret_cast<const PxsCCDContactHeader*>(workUnit.ccdContacts);
const bool isCCDPass = (ccdPass != 0);
if((output->nbPatches && !isCCDPass) || (ccdContactData && (!ccdContactData->isFromPreviousPass) && isCCDPass))
{
const PxU8* contactPatchData;
const PxU8* contactPointData;
PxU32 cDataSize;
PxU32 alignedContactDataSize;
const PxReal* impulses;
PxU32 nbPoints = output->nbContacts;
PxU32 contactPatchCount = output->nbPatches;
if(!isCCDPass)
{
PX_ASSERT(0==(reinterpret_cast<const uintptr_t>(output->contactPatches) & 0x0f)); // check 16Byte alignment
contactPatchData = output->contactPatches;
contactPointData = output->contactPoints;
cDataSize = sizeof(PxContactPatch)*output->nbPatches + sizeof(PxContact)*output->nbContacts;
alignedContactDataSize = (cDataSize + 0xf) & 0xfffffff0;
impulses = output->contactForces;
}
else
{
PX_ASSERT(0==(reinterpret_cast<const uintptr_t>(ccdContactData) & 0x0f)); // check 16Byte alignment
contactPatchData = reinterpret_cast<const PxU8*>(ccdContactData) + sizeof(PxsCCDContactHeader);
contactPointData = contactPatchData + sizeof(PxContactPatch);
cDataSize = ccdContactData->contactStreamSize - sizeof(PxsCCDContactHeader);
PxU32 tmpAlignedSize = (ccdContactData->contactStreamSize + 0xf) & 0xfffffff0;
alignedContactDataSize = tmpAlignedSize - sizeof(PxsCCDContactHeader);
impulses = reinterpret_cast<const PxReal*>(contactPatchData + alignedContactDataSize);
nbPoints = 1;
contactPatchCount = 1;
}
infoFlags = cp->flags;
infoFlags |= unswapped ? 0 : PxContactPairFlag::eINTERNAL_CONTACTS_ARE_FLIPPED;
//PX_ASSERT(0==(reinterpret_cast<const uintptr_t>(impulses) & 0x0f));
const PxU32 impulseSize = impulses ? (nbPoints * sizeof(PxReal)) : 0;
if(impulseSize)
infoFlags |= PxContactPairFlag::eINTERNAL_HAS_IMPULSES;
cp->contactPatches = contactPatchData;
cp->contactPoints = contactPointData;
cp->contactCount = PxTo8(nbPoints);
cp->patchCount = PxTo8(contactPatchCount);
cp->constraintStreamSize = PxTo16(cDataSize);
cp->requiredBufferSize = alignedContactDataSize + impulseSize;
cp->contactForces = impulses;
cp->flags = infoFlags;
}
}
}
void Sc::ShapeInteraction::processUserNotification(PxU32 contactEvent, PxU16 infoFlags, bool touchLost, PxU32 ccdPass, bool useCurrentTransform, PxsContactManagerOutputIterator& outputs)
{
processUserNotificationSync();
processUserNotificationAsync(contactEvent, infoFlags, touchLost, ccdPass, useCurrentTransform, outputs);
}
PxU32 Sc::ShapeInteraction::getContactPointData(const void*& contactPatches, const void*& contactPoints, PxU32& contactDataSize, PxU32& contactPointCount, PxU32& numPatches, const PxReal*& impulses, PxU32 startOffset,
PxsContactManagerOutputIterator& outputs)
{
// Process LL generated contacts
if(mManager != NULL)
{
const PxcNpWorkUnit& workUnit = mManager->getWorkUnit();
PxsContactManagerOutput* output = NULL;
if(workUnit.mNpIndex & PxsContactManagerBase::NEW_CONTACT_MANAGER_MASK)
output = &getScene().getLowLevelContext()->getNphaseImplementationContext()->getNewContactManagerOutput(workUnit.mNpIndex);
else
output = &outputs.getContactManager(workUnit.mNpIndex);
/*const void* dcdContactPatches;
const void* dcdContactPoints;
PxU32 dcdContactPatchCount;
const PxReal* dcdImpulses;
const PxsCCDContactHeader* ccdContactStream;
PxU32 dcdContactCount = mManager->getContactPointData(dcdContactPatches, dcdContactPoints, dcdContactPatchCount, dcdImpulses, ccdContactStream);
PX_ASSERT(((dcdContactCount == 0) && (!ccdContactStream)) || ((dcdContactCount > 0) && hasTouch()) || (ccdContactStream && hasCCDTouch()));*/
const PxsCCDContactHeader* ccdContactStream = reinterpret_cast<const PxsCCDContactHeader*>(workUnit.ccdContacts);
PxU32 idx = 0;
if(output) // preventive measure for omnicrash OM-109664
{
if(output->nbContacts)
{
if(startOffset == 0)
{
contactPatches = output->contactPatches;
contactPoints = output->contactPoints;
contactDataSize = sizeof(PxContactPatch) * output->nbPatches + sizeof(PxContact) * output->nbContacts;
contactPointCount = output->nbContacts;
numPatches = output->nbPatches;
impulses = output->contactForces;
if(!ccdContactStream)
return startOffset;
else
return (startOffset + 1);
}
idx++;
}
while(ccdContactStream)
{
if(startOffset == idx)
{
const PxU8* stream = reinterpret_cast<const PxU8*>(ccdContactStream);
PxU16 streamSize = ccdContactStream->contactStreamSize;
contactPatches = stream + sizeof(PxsCCDContactHeader);
contactPoints = stream + sizeof(PxsCCDContactHeader) + sizeof(PxContactPatch);
contactDataSize = streamSize - sizeof(PxsCCDContactHeader);
contactPointCount = 1;
numPatches = 1;
impulses = reinterpret_cast<const PxReal*>(stream + ((streamSize + 0xf) & 0xfffffff0));
if(!ccdContactStream->nextStream)
return startOffset;
else
return (startOffset + 1);
}
idx++;
ccdContactStream = ccdContactStream->nextStream;
}
}
}
else
{
PxGetFoundation().error(PxErrorCode::eINTERNAL_ERROR, PX_FL, "PxsContactManagerOutput output is null!\n");
}
contactPatches = NULL;
contactPoints = NULL;
contactDataSize = 0;
contactPointCount = 0;
numPatches = 0;
impulses = NULL;
return startOffset;
}
// Note that LL will not send end touch events for managers that are destroyed while having contact
void Sc::ShapeInteraction::managerNewTouch(PxU32 ccdPass, bool adjustCounters, PxsContactManagerOutputIterator& outputs)
{
if(readFlag(HAS_TOUCH))
return; // Do not count the touch twice (for instance when recreating a manager with touch)
// We have contact this frame
setHasTouch();
if(adjustCounters)
adjustCountersOnNewTouch();
if(!isReportPair())
return;
else
{
PX_ASSERT(hasTouch());
PX_ASSERT(!readFlag(IS_IN_PERSISTENT_EVENT_LIST));
PX_ASSERT(!readFlag(IS_IN_FORCE_THRESHOLD_EVENT_LIST));
const PxU32 pairFlags = getPairFlags();
if(pairFlags & PxPairFlag::eNOTIFY_TOUCH_FOUND)
{
PxU16 infoFlag = 0;
if(mActorPair->getTouchCount() == 1) // this code assumes that the actor pair touch count does get incremented beforehand
infoFlag = PxContactPairFlag::eACTOR_PAIR_HAS_FIRST_TOUCH;
processUserNotification(PxPairFlag::eNOTIFY_TOUCH_FOUND, infoFlag, false, ccdPass, true, outputs);
}
if(pairFlags & PxPairFlag::eNOTIFY_TOUCH_PERSISTS)
{
getScene().getNPhaseCore()->addToPersistentContactEventPairsDelayed(this); // to make sure that from now on, the pairs are tested for persistent contact events
}
else if(pairFlags & ShapeInteraction::CONTACT_FORCE_THRESHOLD_PAIRS)
{
// new touch -> need to start checking for force threshold events
// Note: this code assumes that it runs before the pairs get tested for force threshold exceeded
getScene().getNPhaseCore()->addToForceThresholdContactEventPairs(this);
}
}
}
bool Sc::ShapeInteraction::managerLostTouch(PxU32 ccdPass, bool adjustCounters, PxsContactManagerOutputIterator& outputs)
{
if(!readFlag(HAS_TOUCH))
return false;
// We do not have LL contacts this frame and also we lost LL contact this frame
if(!isReportPair())
{
setHasNoTouch();
}
else
{
PX_ASSERT(hasTouch());
sendLostTouchReport(false, ccdPass, outputs);
if(readFlag(IS_IN_CONTACT_EVENT_LIST))
{
// don't need to worry about persistent/force-threshold contact events until next new touch
if(readFlag(IS_IN_FORCE_THRESHOLD_EVENT_LIST))
{
getScene().getNPhaseCore()->removeFromForceThresholdContactEventPairs(this);
}
else
{
PX_ASSERT(readFlag(IS_IN_PERSISTENT_EVENT_LIST));
getScene().getNPhaseCore()->removeFromPersistentContactEventPairs(this);
}
clearFlag(FORCE_THRESHOLD_EXCEEDED_FLAGS);
}
setHasNoTouch();
}
ActorSim& body0 = getShape0().getActor();
ActorSim& body1 = getShape1().getActor();
if(adjustCounters)
adjustCountersOnLostTouch();
if(body1.isStaticRigid())
{
body0.internalWakeUp();
return false;
}
return true;
}
PX_FORCE_INLINE void Sc::ShapeInteraction::updateFlags(const Sc::Scene& scene, const Sc::ActorSim& bs0, const Sc::ActorSim& bs1, const PxU32 pairFlags)
{
// the first shape always belongs to a dynamic body/ a soft body
bool enabled = true;
if (bs0.isDynamicRigid())
{
const Sc::BodySim& body0 = static_cast<const Sc::BodySim&>(bs0);
enabled = !body0.isKinematic();
}
if (bs1.isDynamicRigid())
{
const Sc::BodySim& body1 = static_cast<const Sc::BodySim&>(bs1);
enabled |= !body1.isKinematic();
}
// Check if collision response is disabled
enabled = enabled && (pairFlags & PxPairFlag::eSOLVE_CONTACT);
setFlag(CONTACTS_RESPONSE_DISABLED, !enabled);
// Check if contact points needed
setFlag(CONTACTS_COLLECT_POINTS, ( (pairFlags & PxPairFlag::eNOTIFY_CONTACT_POINTS) ||
(pairFlags & PxPairFlag::eMODIFY_CONTACTS) ||
scene.getVisualizationParameter(PxVisualizationParameter::eCONTACT_POINT) ||
scene.getVisualizationParameter(PxVisualizationParameter::eCONTACT_NORMAL) ||
scene.getVisualizationParameter(PxVisualizationParameter::eCONTACT_ERROR) ||
scene.getVisualizationParameter(PxVisualizationParameter::eCONTACT_FORCE)) );
}
PX_INLINE PxReal ScGetRestOffset(const Sc::ShapeSimBase& shapeSim)
{
#if PX_SUPPORT_GPU_PHYSX
if (shapeSim.getActor().isParticleSystem())
return static_cast<Sc::ParticleSystemSim&>(shapeSim.getActor()).getCore().getRestOffset();
#endif
return shapeSim.getRestOffset();
}
void Sc::ShapeInteraction::updateState(const PxU8 externalDirtyFlags)
{
const PxU32 oldContactState = getManagerContactState();
const PxU8 dirtyFlags = PxU8(getDirtyFlags() | externalDirtyFlags);
const PxU32 pairFlags = getPairFlags();
Scene& scene = getScene();
IG::SimpleIslandManager* islandManager = scene.getSimpleIslandManager();
if(dirtyFlags & (InteractionDirtyFlag::eFILTER_STATE | InteractionDirtyFlag::eVISUALIZATION))
{
Sc::ActorSim& bs0 = getShape0().getActor();
Sc::ActorSim& bs1 = getShape1().getActor();
PxIntBool wasDisabled = readFlag(CONTACTS_RESPONSE_DISABLED);
updateFlags(scene, bs0, bs1, pairFlags);
PxIntBool isDisabled = readFlag(CONTACTS_RESPONSE_DISABLED);
if(!wasDisabled && isDisabled)
{
islandManager->setEdgeDisconnected(mEdgeIndex);
}
else if(wasDisabled && !isDisabled)
{
if(readFlag(ShapeInteraction::HAS_TOUCH))
islandManager->setEdgeConnected(mEdgeIndex, IG::Edge::eCONTACT_MANAGER);
}
}
const PxU32 newContactState = getManagerContactState();
const bool recreateManager = (oldContactState != newContactState);
// No use in updating manager properties if the manager is going to be re-created or does not exist yet
if((!recreateManager) && (mManager != 0))
{
ShapeSimBase& shapeSim0 = getShape0();
ShapeSimBase& shapeSim1 = getShape1();
// Update dominance
if(dirtyFlags & InteractionDirtyFlag::eDOMINANCE)
{
Sc::ActorSim& bs0 = shapeSim0.getActor();
Sc::ActorSim& bs1 = shapeSim1.getActor();
// Static actors are in dominance group zero and must remain there
const PxDominanceGroup dom0 = bs0.getActorCore().getDominanceGroup();
const PxDominanceGroup dom1 = !bs1.isStaticRigid() ? bs1.getActorCore().getDominanceGroup() : PxDominanceGroup(0);
const PxDominanceGroupPair cdom = getScene().getDominanceGroupPair(dom0, dom1);
mManager->setDominance0(cdom.dominance0);
mManager->setDominance1(cdom.dominance1);
}
if (dirtyFlags & InteractionDirtyFlag::eBODY_KINEMATIC)
{
//Kinematic flags changed - clear flag for kinematic on the pair
Sc::ActorSim& bs1 = shapeSim1.getActor();
if (bs1.isDynamicRigid())
{
if (static_cast<BodySim&>(bs1).isKinematic())
mManager->getWorkUnit().flags |= PxcNpWorkUnitFlag::eHAS_KINEMATIC_ACTOR;
else
mManager->getWorkUnit().flags &= (~PxcNpWorkUnitFlag::eHAS_KINEMATIC_ACTOR);
}
}
// Update skin width
if(dirtyFlags & InteractionDirtyFlag::eREST_OFFSET)
mManager->setRestDistance(ScGetRestOffset(shapeSim0) + ScGetRestOffset(shapeSim1));
//we may want to only write these if they have changed, the set code is a bit painful for the integration flags because of bit unpacking + packing.
mManager->setCCD((getPairFlags() & PxPairFlag::eDETECT_CCD_CONTACT) != 0);
if(dirtyFlags)
resetManagerCachedState(); // this flushes changes through to the GPU
}
else if (readInteractionFlag(InteractionFlag::eIS_ACTIVE)) // only re-create the manager if the pair is active
{
PX_ASSERT(mManager); // if the pair is active, there has to be a manager
if (dirtyFlags & InteractionDirtyFlag::eBODY_KINEMATIC)
{
//Kinematic->dynamic transition
const IG::IslandSim& islandSim = getScene().getSimpleIslandManager()->getSpeculativeIslandSim();
//
//check whether active in the speculative sim!
const ActorSim& bodySim0 = getShape0().getActor();
const ActorSim& bodySim1 = getShape1().getActor();
if (!islandSim.getNode(bodySim0.getNodeIndex()).isActiveOrActivating() &&
(bodySim1.isStaticRigid() || !islandSim.getNode(bodySim1.getNodeIndex()).isActiveOrActivating()))
{
onDeactivate();
scene.notifyInteractionDeactivated(this);
}
else
{
//Else we are allowed to be active, so recreate
if (mEdgeIndex != IG_INVALID_EDGE)
islandManager->clearEdgeRigidCM(mEdgeIndex);
destroyManager();
createManager(NULL);
}
}
else
{
PX_ASSERT(activeManagerAllowed());
// A) This is a newly created pair
//
// B) The contact notification or processing state has changed.
// All existing managers need to be deleted and recreated with the correct flag set
// These flags can only be set at creation in LL
//KS - added this code here because it is no longer done in destroyManager() - a side-effect of the parallelization of the interaction management code
if (mEdgeIndex != IG_INVALID_EDGE)
islandManager->clearEdgeRigidCM(mEdgeIndex);
destroyManager();
createManager(NULL);
}
}
}
bool Sc::ShapeInteraction::onActivate(void* contactManager)
{
if(isReportPair())
{
// for pairs that go through a second island pass, there is the possibility that they get put to sleep again after the second pass.
// So we do not want to check for re-insertion into the persistent report pair list yet.
processReportPairOnActivate();
}
if(updateManager(contactManager))
{
raiseInteractionFlag(InteractionFlag::eIS_ACTIVE);
return true;
}
else
return false;
}
bool Sc::ShapeInteraction::onDeactivate()
{
PX_ASSERT(!getShape0().getActor().isStaticRigid() || !getShape1().getActor().isStaticRigid());
const ActorSim& bodySim0 = getShape0().getActor();
const ActorSim& bodySim1 = getShape1().getActor();
PX_ASSERT( (bodySim0.isStaticRigid() && !bodySim1.isStaticRigid() && !bodySim1.isActive()) ||
(bodySim1.isStaticRigid() && !bodySim0.isStaticRigid() && !bodySim0.isActive()) ||
((!bodySim0.isStaticRigid() && !bodySim1.isStaticRigid() && (!bodySim0.isActive() || !bodySim1.isActive()))) );
if((!bodySim0.isActive()) && (bodySim1.isStaticRigid() || !bodySim1.isActive()))
{
if(mReportPairIndex != INVALID_REPORT_PAIR_ID)
processReportPairOnDeactivate();
PX_ASSERT((mManager->getTouchStatus() > 0) == (hasTouch() > 0));
Scene& scene = getScene();
IG::SimpleIslandManager* islandManager = scene.getSimpleIslandManager();
if(mManager)
{
if((!readFlag(TOUCH_KNOWN)) && mManager->touchStatusKnown() && (!mManager->getTouchStatus()))
{
// for pairs that are inserted asleep, we do not know the touch state. If they run through narrowphase and a touch is found,
// then a managerNewTouch() call will inform this object about the found touch. However, if narrowphase detects that there
// is no touch, this object will not be informed about it. The low level manager will always know though. Now, before destroying
// the pair manager, we need to record "does not have touch" state if available.
raiseFlag(HAS_NO_TOUCH);
}
destroyManager();
if(mEdgeIndex != IG_INVALID_EDGE)
islandManager->clearEdgeRigidCM(mEdgeIndex);
}
islandManager->deactivateEdge(mEdgeIndex);
//
// We distinguish two scenarios here:
//
// A) island generation deactivates objects:
// -> the deactivated body was active
// -> narrowphase ran on this pair
// -> the touch status is known
// -> touch: the objects of the pair are in the same island
// -> no touch: the objects of the pair are in different islands
//
// As a consequence, the edge state is not changed. The assumption is that anything that could break the touch status
// from here on will have to mark the edges connected (for example if the object gets moved).
//
// B) user deactivates objects:
// -> the touch status might not be known (for example, the pose gets integrated after the solver which might cause a change
// in touch status. If the object gets put to sleep after that, we have to be conservative and mark the edge connected.
// other example: an active object gets moved by the user and then deactivated).
//
clearInteractionFlag(InteractionFlag::eIS_ACTIVE);
return true;
}
else
{
return false;
}
}
void Sc::ShapeInteraction::createManager(void* contactManager)
{
//PX_PROFILE_ZONE("ShapeInteraction.createManager", 0);
Sc::Scene& scene = getScene();
const PxU32 pairFlags = getPairFlags();
const int disableCCDContact = !(pairFlags & PxPairFlag::eDETECT_CCD_CONTACT);
PxsContactManager* manager = scene.getLowLevelContext()->createContactManager(reinterpret_cast<PxsContactManager*>(contactManager), !disableCCDContact);
PxcNpWorkUnit& mNpUnit = manager->getWorkUnit();
// Check if contact generation callback has been ordered on the pair
int contactChangeable = 0;
if(pairFlags & PxPairFlag::eMODIFY_CONTACTS)
contactChangeable = 1;
ShapeSimBase& shapeSim0 = getShape0();
ShapeSimBase& shapeSim1 = getShape1();
const PxActorType::Enum type0 = shapeSim0.getActor().getActorType();
const PxActorType::Enum type1 = shapeSim1.getActor().getActorType();
const int disableResponse = readFlag(CONTACTS_RESPONSE_DISABLED) ? 1 : 0;
const int disableDiscreteContact = !(pairFlags & PxPairFlag::eDETECT_DISCRETE_CONTACT);
const int reportContactInfo = readFlag(CONTACTS_COLLECT_POINTS);
const int hasForceThreshold = !disableResponse && (pairFlags & CONTACT_FORCE_THRESHOLD_PAIRS);
int touching;
if(readFlag(TOUCH_KNOWN))
touching = readFlag(HAS_TOUCH) ? 1 : -1;
else
touching = 0;
// Static actors are in dominance group zero and must remain there
Sc::ActorSim& bs0 = shapeSim0.getActor();
Sc::ActorSim& bs1 = shapeSim1.getActor();
const PxDominanceGroup dom0 = bs0.getActorCore().getDominanceGroup();
const PxDominanceGroup dom1 = bs1.isStaticRigid() ? PxDominanceGroup(0) : bs1.getActorCore().getDominanceGroup();
const bool kinematicActor = bs1.isDynamicRigid() ? static_cast<BodySim&>(bs1).isKinematic() : false;
const PxDominanceGroupPair cdom = scene.getDominanceGroupPair(dom0, dom1);
/*const PxI32 hasArticulations= (type0 == PxActorType::eARTICULATION_LINK) | (type1 == PxActorType::eARTICULATION_LINK)<<1;
const PxI32 hasDynamics = (type0 != PxActorType::eRIGID_STATIC) | (type1 != PxActorType::eRIGID_STATIC)<<1;*/
const PxsShapeCore* shapeCore0 = &shapeSim0.getCore().getCore();
const PxsShapeCore* shapeCore1 = &shapeSim1.getCore().getCore();
//Initialize the manager....
manager->mRigidBody0 = bs0.isDynamicRigid() ? &static_cast<BodySim&>(bs0).getLowLevelBody() : NULL;
manager->mRigidBody1 = bs1.isDynamicRigid() ? &static_cast<BodySim&>(bs1).getLowLevelBody() : NULL;
manager->mShapeInteraction = this;
mNpUnit.shapeCore0 = shapeCore0;
mNpUnit.shapeCore1 = shapeCore1;
PX_ASSERT(shapeCore0->getTransform().isValid() && shapeCore1->getTransform().isValid());
mNpUnit.rigidCore0 = !bs0.isNonRigid() ? &static_cast<ShapeSim&>(shapeSim0).getPxsRigidCore() : NULL;
mNpUnit.rigidCore1 = !bs1.isNonRigid() ? &static_cast<ShapeSim&>(shapeSim1).getPxsRigidCore() : NULL;
mNpUnit.restDistance = ScGetRestOffset(shapeSim0) + ScGetRestOffset(shapeSim1);
mNpUnit.dominance0 = cdom.dominance0;
mNpUnit.dominance1 = cdom.dominance1;
mNpUnit.geomType0 = PxU8(shapeCore0->mGeometry.getType());
mNpUnit.geomType1 = PxU8(shapeCore1->mGeometry.getType());
mNpUnit.mTransformCache0 = shapeSim0.getTransformCacheID();
mNpUnit.mTransformCache1 = shapeSim1.getTransformCacheID();
mNpUnit.mTorsionalPatchRadius = PxMax(shapeSim0.getTorsionalPatchRadius(),shapeSim1.getTorsionalPatchRadius());
mNpUnit.mMinTorsionalPatchRadius = PxMax(shapeSim0.getMinTorsionalPatchRadius(), shapeSim1.getMinTorsionalPatchRadius());
const PxReal slop0 = manager->mRigidBody0 ? manager->mRigidBody0->getCore().offsetSlop : 0.0f;
const PxReal slop1 = manager->mRigidBody1 ? manager->mRigidBody1->getCore().offsetSlop : 0.0f;
mNpUnit.mOffsetSlop = PxMax(slop0, slop1);
PxU16 wuflags = 0;
if(type0 == PxActorType::eARTICULATION_LINK)
wuflags |= PxcNpWorkUnitFlag::eARTICULATION_BODY0;
if(type1 == PxActorType::eARTICULATION_LINK)
wuflags |= PxcNpWorkUnitFlag::eARTICULATION_BODY1;
if(type0 == PxActorType::eRIGID_DYNAMIC)
wuflags |= PxcNpWorkUnitFlag::eDYNAMIC_BODY0;
if(type1 == PxActorType::eRIGID_DYNAMIC)
wuflags |= PxcNpWorkUnitFlag::eDYNAMIC_BODY1;
#if PX_SUPPORT_GPU_PHYSX
if (type0 == PxActorType::eSOFTBODY)
wuflags |= PxcNpWorkUnitFlag::eSOFT_BODY;
if (type1 == PxActorType::eSOFTBODY)
wuflags |= PxcNpWorkUnitFlag::eSOFT_BODY;
#endif
if(!disableResponse && !contactChangeable)
wuflags |= PxcNpWorkUnitFlag::eOUTPUT_CONSTRAINTS;
if(!disableDiscreteContact)
wuflags |= PxcNpWorkUnitFlag::eDETECT_DISCRETE_CONTACT;
if(kinematicActor)
wuflags |= PxcNpWorkUnitFlag::eHAS_KINEMATIC_ACTOR;
if(disableResponse)
wuflags |= PxcNpWorkUnitFlag::eDISABLE_RESPONSE;
if(!disableCCDContact)
wuflags |= PxcNpWorkUnitFlag::eDETECT_CCD_CONTACTS;
// this is just the user req: contact reports can also be generated by body thresholding
if(reportContactInfo || contactChangeable)
wuflags |= PxcNpWorkUnitFlag::eOUTPUT_CONTACTS;
if(hasForceThreshold)
wuflags |= PxcNpWorkUnitFlag::eFORCE_THRESHOLD;
if(contactChangeable)
wuflags |= PxcNpWorkUnitFlag::eMODIFIABLE_CONTACT;
mNpUnit.flags = wuflags;
manager->mFlags = PxU32(contactChangeable ? PxsContactManager::PXS_CM_CHANGEABLE : 0) | PxU32(disableCCDContact ? 0 : PxsContactManager::PXS_CM_CCD_LINEAR);
//manager->mUserData = this;
mNpUnit.mNpIndex = 0xFFffFFff;
mManager = manager;
PxU8 statusFlags = 0;
if(touching > 0)
statusFlags |= PxcNpWorkUnitStatusFlag::eHAS_TOUCH;
else if (touching < 0)
statusFlags |= PxcNpWorkUnitStatusFlag::eHAS_NO_TOUCH;
mNpUnit.statusFlags = statusFlags;
//KS - do not register the CMs here if contactManager isn't null. This implies this is a newly-found pair so we'll do that addition outside in parallel
if(contactManager == NULL)
{
scene.getSimpleIslandManager()->setEdgeRigidCM(mEdgeIndex, mManager);
PxvNphaseImplementationContext* nphaseImplementationContext = scene.getLowLevelContext()->getNphaseImplementationContext();
PX_ASSERT(nphaseImplementationContext);
nphaseImplementationContext->registerContactManager(mManager, this, touching, 0);
}
}
void Sc::ShapeInteraction::onShapeChangeWhileSleeping(bool shapeOfDynamicChanged)
{
// if an operation that can break touch status occurs, all deactivated pairs need to set the sleep island edge
// to connected to make sure that potentially joined islands get detected once parts of the island wake up.
// Active interactions can be ignored because the edges of those will be marked connected on deactivation.
if(!mManager)
{
Scene& scene = getScene();
//soft body/dynamic before static
ActorSim& body0 = getShape0().getActor();
if(shapeOfDynamicChanged && !readFlag(TOUCH_KNOWN))
{
// conservative approach: if a pair was added asleep, and a body/shape gets moved, we want to check next frame
// whether the other body should get woken up. The motivation behind this is to get a similar behavior as in
// the case where the objects fell asleep rather than have been added asleep (in that case the object will be
// woken up with one frame delay).
ActorSim& body1 = getShape1().getActor();
if(body1.isDynamicRigid() && !readFlag(ShapeInteraction::CONTACTS_RESPONSE_DISABLED)) // the first shape always belongs to a dynamic body, hence no need to test body0
scene.addToLostTouchList(body0, body1); // note: this will cause duplicate entries if the pair loses AABB overlap the next frame
}
}
}
| 41,588 | C++ | 35.771883 | 217 | 0.735982 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScHairSystemShapeCore.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-2023 NVIDIA Corporation. All rights reserved.
#ifndef SC_HAIRSYSTEM_SHAPECORE_H
#define SC_HAIRSYSTEM_SHAPECORE_H
#include "foundation/PxPreprocessor.h"
#if PX_SUPPORT_GPU_PHYSX
#include "foundation/PxUserAllocated.h"
#include "DyHairSystemCore.h"
#include "ScShapeCore.h"
#include "PxShape.h"
namespace physx
{
class PxCudaContextManager;
namespace Sc
{
class HairSystemShapeCore : public Sc::ShapeCore
{
public:
// PX_SERIALIZATION
HairSystemShapeCore(const PxEMPTY);
//~PX_SERIALIZATION
HairSystemShapeCore();
~HairSystemShapeCore();
PX_FORCE_INLINE const Dy::HairSystemCore& getLLCore() const { return mLLCore; }
PX_FORCE_INLINE Dy::HairSystemCore& getLLCore() { return mLLCore; }
void createBuffers(PxCudaContextManager* cudaContextManager);
void releaseBuffers();
PxU64& getGpuMemStat() { return mGpuMemStat; }
private:
Dy::HairSystemCore mLLCore;
PxU64 mGpuMemStat;
PxCudaContextManager* mCudaContextManager;
};
} // namespace Sc
} // namespace physx
#endif
#endif
| 2,561 | C | 34.583333 | 82 | 0.755955 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScTriggerInteraction.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScTriggerInteraction.h"
#include "ScBodySim.h"
#include "ScNPhaseCore.h"
using namespace physx;
using namespace Sc;
TriggerInteraction::TriggerInteraction( ShapeSimBase& tShape, ShapeSimBase& oShape) :
ElementSimInteraction(tShape, oShape, InteractionType::eTRIGGER, InteractionFlag::eRB_ELEMENT | InteractionFlag::eFILTERABLE),
mLastFrameHadContacts(false)
{
mFlags = PROCESS_THIS_FRAME;
// The PxPairFlags eNOTIFY_TOUCH_FOUND and eNOTIFY_TOUCH_LOST get stored and mixed up with internal flags. Make sure any breaking change gets noticed.
PX_COMPILE_TIME_ASSERT(PxPairFlag::eNOTIFY_TOUCH_FOUND < PxPairFlag::eNOTIFY_TOUCH_LOST);
PX_COMPILE_TIME_ASSERT((PAIR_FLAGS_MASK & PxPairFlag::eNOTIFY_TOUCH_FOUND) == PxPairFlag::eNOTIFY_TOUCH_FOUND);
PX_COMPILE_TIME_ASSERT((PAIR_FLAGS_MASK & PxPairFlag::eNOTIFY_TOUCH_LOST) == PxPairFlag::eNOTIFY_TOUCH_LOST);
PX_COMPILE_TIME_ASSERT(PxPairFlag::eNOTIFY_TOUCH_FOUND < 0xffff);
PX_COMPILE_TIME_ASSERT(PxPairFlag::eNOTIFY_TOUCH_LOST < 0xffff);
PX_COMPILE_TIME_ASSERT(LAST < 0xffff);
{
const bool active = onActivate(NULL);
registerInActors();
getScene().registerInteraction(this, active);
}
PX_ASSERT(getTriggerShape().getFlags() & PxShapeFlag::eTRIGGER_SHAPE);
mTriggerCache.state = Gu::TRIGGER_DISJOINT;
}
TriggerInteraction::~TriggerInteraction()
{
getScene().unregisterInteraction(this);
unregisterFromActors();
}
static bool isOneActorActive(TriggerInteraction* trigger)
{
const ActorSim& actorSim0 = trigger->getTriggerShape().getActor();
if(actorSim0.isActive() && actorSim0.isDynamicRigid())
{
const BodySim* bodySim0 = static_cast<const BodySim*>(&actorSim0);
PX_UNUSED(bodySim0);
PX_ASSERT(!bodySim0->isKinematic() || bodySim0->readInternalFlag(BodySim::BF_KINEMATIC_MOVED) ||
bodySim0->readInternalFlag(BodySim::InternalFlags(BodySim::BF_KINEMATIC_SETTLING | BodySim::BF_KINEMATIC_SETTLING_2)));
return true;
}
const ActorSim& actorSim1 = trigger->getOtherShape().getActor();
if(actorSim1.isActive() && actorSim1.isDynamicRigid())
{
const BodySim* bodySim1 = static_cast<const BodySim*>(&actorSim1);
PX_UNUSED(bodySim1);
PX_ASSERT(!bodySim1->isKinematic() || bodySim1->readInternalFlag(BodySim::BF_KINEMATIC_MOVED) ||
bodySim1->readInternalFlag(BodySim::InternalFlags(BodySim::BF_KINEMATIC_SETTLING | BodySim::BF_KINEMATIC_SETTLING_2)));
return true;
}
return false;
}
//
// Some general information about triggers and sleeping
//
// The goal is to avoid running overlap tests if both objects are sleeping.
// This is an optimization for eNOTIFY_TOUCH_LOST events since the overlap state
// can not change if both objects are sleeping. eNOTIFY_TOUCH_FOUND should be sent nonetheless.
// For this to work the following assumptions are made:
// - On creation or if the pose of an actor is set, the pair will always be checked.
// - If the scenario above does not apply, then a trigger pair can only be deactivated, if both actors are sleeping.
// - If an overlapping actor is activated/deactivated, the trigger interaction gets notified
//
bool TriggerInteraction::onActivate(void*)
{
// IMPORTANT: this method can get called concurrently from multiple threads -> make sure shared resources
// are protected (note: there are none at the moment but it might change)
if(!(readFlag(PROCESS_THIS_FRAME)))
{
if(isOneActorActive(this))
{
raiseInteractionFlag(InteractionFlag::eIS_ACTIVE);
return true;
}
else
return false;
}
else
{
raiseInteractionFlag(InteractionFlag::eIS_ACTIVE);
return true; // newly created trigger pairs should always test for overlap, no matter the sleep state
}
}
bool TriggerInteraction::onDeactivate()
{
if(!readFlag(PROCESS_THIS_FRAME))
{
if(!isOneActorActive(this))
{
clearInteractionFlag(InteractionFlag::eIS_ACTIVE);
return true;
}
else
return false;
}
else
return false;
}
| 5,608 | C++ | 39.352518 | 151 | 0.754458 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScShapeSimBase.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
#include "ScShapeSimBase.h"
#include "ScSqBoundsManager.h"
#include "ScTriggerInteraction.h"
#include "ScSimulationController.h"
#include "CmTransformUtils.h"
#include "ScShapeInteraction.h"
using namespace physx;
using namespace Sc;
// PT: keep local functions in cpp, no need to pollute the header. Don't force conversions to bool if not necessary.
static PX_FORCE_INLINE PxU32 hasTriggerFlags(PxShapeFlags flags) { return PxU32(flags) & PxU32(PxShapeFlag::eTRIGGER_SHAPE); }
void resetElementID(Scene& scene, ShapeSimBase& shapeSim)
{
PX_ASSERT(!shapeSim.isInBroadPhase());
// scene.getDirtyShapeSimMap().reset(shapeSim.getElementID());
scene.getDirtyShapeSimMap().boundedReset(shapeSim.getElementID());
if (shapeSim.getSqBoundsId() != PX_INVALID_U32)
shapeSim.destroySqBounds();
}
PX_INLINE Bp::FilterGroup::Enum getBPGroup(const ShapeSimBase& shapeSim)
{
const BodySim* bs = shapeSim.getBodySim();
const RigidSim& rbSim = shapeSim.getRbSim();
bool isKinematic = bs ? bs->isKinematic() : false;
if (isKinematic && bs->hasForcedKinematicNotif())
isKinematic = false;
return Bp::getFilterGroup(rbSim.getActorType() == PxActorType::eRIGID_STATIC, rbSim.getActorID(), isKinematic);
}
static void setElementInteractionsDirty(Sc::ElementSim& elementSim, InteractionDirtyFlag::Enum flag, PxU8 interactionFlag)
{
ElementSim::ElementInteractionIterator iter = elementSim.getElemInteractions();
ElementSimInteraction* interaction = iter.getNext();
while(interaction)
{
if(interaction->readInteractionFlag(interactionFlag))
interaction->setDirty(flag);
interaction = iter.getNext();
}
}
void ShapeSimBase::onFilterDataChange()
{
setElementInteractionsDirty(*this, InteractionDirtyFlag::eFILTER_STATE, InteractionFlag::eFILTERABLE);
}
void ShapeSimBase::onResetFiltering()
{
if (isInBroadPhase())
reinsertBroadPhase();
}
void ShapeSimBase::onMaterialChange()
{
setElementInteractionsDirty(*this, InteractionDirtyFlag::eMATERIAL, InteractionFlag::eRB_ELEMENT);
}
void ShapeSimBase::onRestOffsetChange()
{
setElementInteractionsDirty(*this, InteractionDirtyFlag::eREST_OFFSET, InteractionFlag::eRB_ELEMENT);
}
void ShapeSimBase::onContactOffsetChange()
{
if (isInBroadPhase())
getScene().getAABBManager()->setContactDistance(getElementID(), getCore().getContactOffset());
}
void ShapeSimBase::removeFromBroadPhase(bool wakeOnLostTouch)
{
if (isInBroadPhase())
internalRemoveFromBroadPhase(wakeOnLostTouch);
}
void ShapeSimBase::reinsertBroadPhase()
{
bool wasPendingInsert = false;
if (isInBroadPhase())
{
wasPendingInsert = internalRemoveFromBroadPhase();
}
// internalAddToBroadPhase();
Scene& scene = getScene();
// Scene::removeShape
{
//unregisterShapeFromNphase(shape.getCore());
// PT: "getID" is const but the addShape call used LLShape, which uses elementID, so....
scene.getSimulationController()->removeShape(getElementID());
scene.unregisterShapeFromNphase(getCore(), getElementID());
}
// Call ShapeSim dtor
{
resetElementID(scene, *this);
}
// Call ElementSim dtor - only required if this shape was not pending insert (otherwise the elementID is fine to keep)
if (!wasPendingInsert)
{
{
releaseID();
}
// Call ElementSim ctor
{
initID();
}
}
// Call ShapeSim ctor
{
initSubsystemsDependingOnElementID();
}
// Scene::addShape
{
scene.getSimulationController()->addShape(&getLLShapeSim(), getElementID());
// PT: TODO: anything else needed here?
scene.registerShapeInNphase(&getRbSim().getRigidCore(), getCore(), getElementID());
}
}
PX_FORCE_INLINE void ShapeSimBase::internalAddToBroadPhase()
{
PX_ASSERT(!isInBroadPhase());
addToAABBMgr(getCore().getContactOffset(), getBPGroup(*this), (getCore().getCore().mShapeFlags & PxShapeFlag::eTRIGGER_SHAPE) ? Bp::ElementType::eTRIGGER : Bp::ElementType::eSHAPE);
}
PX_FORCE_INLINE bool ShapeSimBase::internalRemoveFromBroadPhase(bool wakeOnLostTouch)
{
PX_ASSERT(isInBroadPhase());
bool res = removeFromAABBMgr();
Scene& scene = getScene();
PxsContactManagerOutputIterator outputs = scene.getLowLevelContext()->getNphaseImplementationContext()->getContactManagerOutputs();
scene.getNPhaseCore()->onVolumeRemoved(this, wakeOnLostTouch ? PxU32(PairReleaseFlag::eWAKE_ON_LOST_TOUCH) : 0, outputs);
return res;
}
void ShapeSimBase::initSubsystemsDependingOnElementID()
{
Scene& scScene = getScene();
Bp::BoundsArray& boundsArray = scScene.getBoundsArray();
const PxU32 index = getElementID();
PX_ALIGN(16, PxTransform absPos);
getAbsPoseAligned(&absPos);
PxsTransformCache& cache = scScene.getLowLevelContext()->getTransformCache();
cache.initEntry(index);
cache.setTransformCache(absPos, 0, index);
boundsArray.updateBounds(absPos, getCore().getGeometryUnion().getGeometry(), index);
{
PX_PROFILE_ZONE("API.simAddShapeToBroadPhase", scScene.getContextId());
if (isBroadPhase(getCore().getFlags()))
internalAddToBroadPhase();
else
scScene.getAABBManager()->reserveSpaceForBounds(index);
scScene.updateContactDistance(index, getContactOffset());
}
// if(scScene.getDirtyShapeSimMap().size() <= index)
// scScene.getDirtyShapeSimMap().resize(PxMax(index+1, (scScene.getDirtyShapeSimMap().size()+1) * 2u));
RigidSim& owner = getRbSim();
if (owner.isDynamicRigid() && static_cast<BodySim&>(owner).isActive())
createSqBounds();
// Init LL shape
{
mLLShape.mElementIndex_GPU = index;
mLLShape.mShapeCore = const_cast<PxsShapeCore*>(&getCore().getCore());
if (owner.getActorType() == PxActorType::eRIGID_STATIC)
{
mLLShape.mBodySimIndex_GPU = PxNodeIndex(PX_INVALID_NODE);
}
else
{
BodySim& bodySim = static_cast<BodySim&>(getActor());
mLLShape.mBodySimIndex_GPU = bodySim.getNodeIndex();
//mLLShape.mLocalBound = computeBounds(mCore.getGeometry(), PxTransform(PxIdentity));
}
}
}
void ShapeSimBase::getAbsPoseAligned(PxTransform* PX_RESTRICT globalPose) const
{
// PT: TODO: simplify dynamic case when shape2Actor = idt
const PxsShapeCore& shapeCore = getCore().getCore();
const PxTransform& shape2Actor = shapeCore.getTransform();
const PxTransform* actor2World = NULL;
if (getActor().getActorType() == PxActorType::eRIGID_STATIC)
{
PxsRigidCore& core = static_cast<StaticSim&>(getActor()).getStaticCore().getCore();
if (shapeCore.mShapeCoreFlags.isSet(PxShapeCoreFlag::eIDT_TRANSFORM))
{
PX_ASSERT(shape2Actor.p.isZero() && shape2Actor.q.isIdentity());
*globalPose = core.body2World;
return;
}
actor2World = &core.body2World;
}
else
{
PxsBodyCore& core = static_cast<BodySim&>(getActor()).getBodyCore().getCore();
if (!core.hasIdtBody2Actor())
{
Cm::getDynamicGlobalPoseAligned(core.body2World, shape2Actor, core.getBody2Actor(), *globalPose);
return;
}
actor2World = &core.body2World;
}
Cm::getStaticGlobalPoseAligned(*actor2World, shape2Actor, *globalPose);
}
void ShapeSimBase::onFlagChange(PxShapeFlags oldFlags)
{
const PxShapeFlags newFlags = getCore().getFlags();
const bool oldBp = isBroadPhase(oldFlags) != 0;
const bool newBp = isBroadPhase(newFlags) != 0;
// Change of collision shape flags requires removal/add to broadphase
if (oldBp != newBp)
{
if (!oldBp && newBp)
{
// A.B. if a trigger was removed and inserted within the same frame we need to reinsert
if (hasTriggerFlags(newFlags) && getScene().getAABBManager()->isMarkedForRemove(getElementID()))
reinsertBroadPhase();
else
internalAddToBroadPhase();
}
else
internalRemoveFromBroadPhase();
}
else
{
const bool wasTrigger = hasTriggerFlags(oldFlags) != 0;
const bool isTrigger = hasTriggerFlags(newFlags) != 0;
if (wasTrigger != isTrigger)
reinsertBroadPhase(); // re-insertion is necessary because trigger pairs get killed
}
const PxShapeFlags hadSq = oldFlags & PxShapeFlag::eSCENE_QUERY_SHAPE;
const PxShapeFlags hasSq = newFlags & PxShapeFlag::eSCENE_QUERY_SHAPE;
if (hasSq && !hadSq)
{
BodySim* body = getBodySim();
if (body && body->isActive())
createSqBounds();
}
else if (hadSq && !hasSq)
destroySqBounds();
getScene().getSimulationController()->reinsertShape(&getLLShapeSim(), getElementID());
}
BodySim* ShapeSimBase::getBodySim() const
{
ActorSim& a = getActor();
return a.isDynamicRigid() ? static_cast<BodySim*>(&a) : NULL;
}
PxsRigidCore& ShapeSimBase::getPxsRigidCore() const
{
ActorSim& a = getActor();
return a.isDynamicRigid() ? static_cast<BodySim&>(a).getBodyCore().getCore()
: static_cast<StaticSim&>(a).getStaticCore().getCore();
}
void ShapeSimBase::updateCached(PxU32 transformCacheFlags, PxBitMapPinned* shapeChangedMap)
{
PX_ALIGN(16, PxTransform absPose);
getAbsPoseAligned(&absPose);
Scene& scene = getScene();
const PxU32 index = getElementID();
scene.getLowLevelContext()->getTransformCache().setTransformCache(absPose, transformCacheFlags, index);
scene.getBoundsArray().updateBounds(absPose, getCore().getGeometryUnion().getGeometry(), index);
if (shapeChangedMap && isInBroadPhase())
shapeChangedMap->growAndSet(index);
}
void ShapeSimBase::updateCached(PxsTransformCache& transformCache, Bp::BoundsArray& boundsArray)
{
const PxU32 index = getElementID();
PxsCachedTransform& ct = transformCache.getTransformCache(index);
PxPrefetchLine(&ct);
getAbsPoseAligned(&ct.transform);
ct.flags = 0;
PxBounds3& b = boundsArray.begin()[index];
Gu::computeBounds(b, getCore().getGeometryUnion().getGeometry(), ct.transform, 0.0f, 1.0f);
}
void ShapeSimBase::updateBPGroup()
{
if (isInBroadPhase())
{
Sc::Scene& scene = getScene();
scene.getAABBManager()->setBPGroup(getElementID(), getBPGroup(*this));
reinsertBroadPhase();
// internalRemoveFromBroadPhase();
// internalAddToBroadPhase();
}
}
void ShapeSimBase::markBoundsForUpdate()
{
Scene& scene = getScene();
if (isInBroadPhase())
scene.getDirtyShapeSimMap().growAndSet(getElementID());
}
static PX_FORCE_INLINE void updateInteraction(Scene& scene, Interaction* i, const bool isDynamic, const bool isAsleep)
{
if (i->getType() == InteractionType::eOVERLAP)
{
ShapeInteraction* si = static_cast<ShapeInteraction*>(i);
si->resetManagerCachedState();
if (isAsleep)
si->onShapeChangeWhileSleeping(isDynamic);
}
else if (i->getType() == InteractionType::eTRIGGER)
(static_cast<TriggerInteraction*>(i))->forceProcessingThisFrame(scene); // trigger pairs need to be checked next frame
}
void ShapeSimBase::onVolumeOrTransformChange()
{
Scene& scene = getScene();
BodySim* body = getBodySim();
const bool isDynamic = (body != NULL);
const bool isAsleep = body ? !body->isActive() : true;
ElementSim::ElementInteractionIterator iter = getElemInteractions();
ElementSimInteraction* i = iter.getNext();
while (i)
{
updateInteraction(scene, i, isDynamic, isAsleep);
i = iter.getNext();
}
markBoundsForUpdate();
getScene().getSimulationController()->reinsertShape(&getLLShapeSim(), getElementID());
}
void notifyActorInteractionsOfTransformChange(ActorSim& actor)
{
bool isDynamic;
bool isAsleep;
if (actor.isDynamicRigid())
{
isDynamic = true;
isAsleep = !static_cast<BodySim&>(actor).isActive();
}
else
{
isDynamic = false;
isAsleep = true;
}
Scene& scene = actor.getScene();
PxU32 nbInteractions = actor.getActorInteractionCount();
Interaction** interactions = actor.getActorInteractions();
while (nbInteractions--)
updateInteraction(scene, *interactions++, isDynamic, isAsleep);
}
void ShapeSimBase::createSqBounds()
{
if (mSqBoundsId != PX_INVALID_U32)
return;
BodySim* bodySim = getBodySim();
PX_ASSERT(bodySim);
if (bodySim->usingSqKinematicTarget() || bodySim->isFrozen() || !bodySim->isActive() || bodySim->readInternalFlag(BodySim::BF_IS_COMPOUND_RIGID))
return;
if (getCore().getFlags() & PxShapeFlag::eSCENE_QUERY_SHAPE)
getScene().getSqBoundsManager().addSyncShape(*this);
}
void ShapeSimBase::destroySqBounds()
{
if (mSqBoundsId != PX_INVALID_U32)
getScene().getSqBoundsManager().removeSyncShape(*this);
}
| 13,518 | C++ | 29.109131 | 182 | 0.745155 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScActorCore.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScActorCore.h"
#include "ScActorSim.h"
#include "ScShapeCore.h"
#include "ScShapeSim.h"
#include "ScBodySim.h"
using namespace physx;
Sc::ActorCore::ActorCore(PxActorType::Enum actorType, PxU8 actorFlags, PxClientID owner, PxDominanceGroup dominanceGroup) :
mSim (NULL),
mAggregateIDOwnerClient ((PxU32(owner)<<24)|0x00ffffff),
mActorFlags (actorFlags),
mActorType (PxU8(actorType)),
mDominanceGroup (dominanceGroup)
{
PX_ASSERT((actorType & 0xff) == actorType);
}
Sc::ActorCore::~ActorCore()
{
}
void Sc::ActorCore::setActorFlags(PxActorFlags af)
{
const PxActorFlags old = mActorFlags;
if(af!=old)
{
mActorFlags = af;
if(mSim)
mSim->postActorFlagChange(old, af);
}
}
void Sc::ActorCore::setDominanceGroup(PxDominanceGroup g)
{
PX_ASSERT(g<128);
mDominanceGroup = g;
if(mSim)
{
//force all related interactions to refresh, so they fetch new dominance values.
mSim->setActorsInteractionsDirty(InteractionDirtyFlag::eDOMINANCE, NULL, InteractionFlag::eRB_ELEMENT);
}
}
void Sc::ActorCore::reinsertShapes()
{
PX_ASSERT(mSim);
if(!mSim)
return;
PxU32 nbElems = mSim->getNbElements();
ElementSim** elems = mSim->getElements();
while (nbElems--)
{
ShapeSim* current = static_cast<ShapeSim*>(*elems++);
current->reinsertBroadPhase();
}
}
| 3,002 | C++ | 33.125 | 123 | 0.746502 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScArticulationCore.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScArticulationCore.h"
#include "ScPhysics.h"
#include "ScBodyCore.h"
#include "ScBodySim.h"
#include "ScArticulationSim.h"
using namespace physx;
Sc::ArticulationCore::ArticulationCore() :
mSim(NULL)
{
const PxTolerancesScale& scale = Physics::getInstance().getTolerancesScale();
mCore.solverIterationCounts = 1<<8 | 4;
mCore.sleepThreshold = 5e-5f * scale.speed * scale.speed;
mCore.freezeThreshold = 5e-6f * scale.speed * scale.speed;
mCore.wakeCounter = Physics::sWakeCounterOnCreation;
mCore.gpuRemapIndex = 0xffffffff;
mCore.maxLinearVelocity = 1e+6f;
mCore.maxAngularVelocity = 1e+6f;
}
Sc::ArticulationCore::~ArticulationCore()
{
}
//--------------------------------------------------------------
//
// ArticulationCore interface implementation
//
//--------------------------------------------------------------
void Sc::ArticulationCore::setWakeCounter(const PxReal v)
{
mCore.wakeCounter = v;
if (mSim)
{
mSim->setArticulationDirty(Dy::ArticulationDirtyFlag::eDIRTY_WAKECOUNTER);
}
#ifdef _DEBUG
if(mSim)
mSim->debugCheckWakeCounterOfLinks(v);
#endif
}
void Sc::ArticulationCore::setMaxLinearVelocity(const PxReal v)
{
mCore.maxLinearVelocity = v;
if (mSim)
{
mSim->setArticulationDirty(Dy::ArticulationDirtyFlag::eDIRTY_VELOCITY_LIMITS);
}
}
void Sc::ArticulationCore::setMaxAngularVelocity(const PxReal v)
{
mCore.maxAngularVelocity = v;
if (mSim)
{
mSim->setArticulationDirty(Dy::ArticulationDirtyFlag::eDIRTY_VELOCITY_LIMITS);
}
}
bool Sc::ArticulationCore::isSleeping() const
{
return mSim ? mSim->isSleeping() : (mCore.wakeCounter == 0.0f);
}
void Sc::ArticulationCore::wakeUp(PxReal wakeCounter)
{
mCore.wakeCounter = wakeCounter;
if (mSim)
{
Dy::FeatherstoneArticulation* arti = static_cast<Dy::FeatherstoneArticulation*>(mSim->getLowLevelArticulation());
arti->setGpuDirtyFlag(Dy::ArticulationDirtyFlag::eDIRTY_WAKECOUNTER);
}
#ifdef _DEBUG
if(mSim)
mSim->debugCheckSleepStateOfLinks(false);
#endif
}
void Sc::ArticulationCore::putToSleep()
{
mCore.wakeCounter = 0.0f;
if (mSim)
{
Dy::FeatherstoneArticulation* arti = static_cast<Dy::FeatherstoneArticulation*>(mSim->getLowLevelArticulation());
arti->setGpuDirtyFlag(Dy::ArticulationDirtyFlag::eDIRTY_WAKECOUNTER);
}
#ifdef _DEBUG
if(mSim)
mSim->debugCheckSleepStateOfLinks(true);
#endif
}
void Sc::ArticulationCore::setArticulationFlags(PxArticulationFlags flags)
{
mCore.flags = flags;
if(mSim)
{
mSim->setArticulationDirty(Dy::ArticulationDirtyFlag::eDIRTY_USER_FLAGS);
const bool isFixedBaseLink = flags & PxArticulationFlag::eFIX_BASE;
mSim->setFixedBaseLink(isFixedBaseLink);
}
}
PxU32 Sc::ArticulationCore::getDofs() const
{
return mSim ? mSim->getDofs() : 0xFFFFFFFFu;
}
PxArticulationCache* Sc::ArticulationCore::createCache() const
{
return mSim ? mSim->createCache() : NULL;
}
PxU32 Sc::ArticulationCore::getCacheDataSize() const
{
return mSim ? mSim->getCacheDataSize() : 0xFFFFFFFFu;
}
void Sc::ArticulationCore::zeroCache(PxArticulationCache& cache) const
{
if(mSim)
mSim->zeroCache(cache);
}
bool Sc::ArticulationCore::applyCache(PxArticulationCache& cache, const PxArticulationCacheFlags flag) const
{
if(mSim)
return mSim->applyCache(cache, flag);
return false;
}
void Sc::ArticulationCore::copyInternalStateToCache(PxArticulationCache& cache, const PxArticulationCacheFlags flag, const bool isGpuSimEnabled) const
{
if(mSim)
mSim->copyInternalStateToCache(cache, flag, isGpuSimEnabled);
}
void Sc::ArticulationCore::packJointData(const PxReal* maximum, PxReal* reduced) const
{
if(mSim)
mSim->packJointData(maximum, reduced);
}
void Sc::ArticulationCore::unpackJointData(const PxReal* reduced, PxReal* maximum) const
{
if(mSim)
mSim->unpackJointData(reduced, maximum);
}
void Sc::ArticulationCore::commonInit() const
{
if(mSim)
mSim->commonInit();
}
void Sc::ArticulationCore::computeGeneralizedGravityForce(PxArticulationCache& cache) const
{
if(mSim)
mSim->computeGeneralizedGravityForce(cache);
}
void Sc::ArticulationCore::computeCoriolisAndCentrifugalForce(PxArticulationCache& cache) const
{
if(mSim)
mSim->computeCoriolisAndCentrifugalForce(cache);
}
void Sc::ArticulationCore::computeGeneralizedExternalForce(PxArticulationCache& cache) const
{
if(mSim)
mSim->computeGeneralizedExternalForce(cache);
}
void Sc::ArticulationCore::computeJointAcceleration(PxArticulationCache& cache) const
{
if(mSim)
mSim->computeJointAcceleration(cache);
}
void Sc::ArticulationCore::computeJointForce(PxArticulationCache& cache) const
{
if(mSim)
mSim->computeJointForce(cache);
}
void Sc::ArticulationCore::computeDenseJacobian(PxArticulationCache& cache, PxU32& nRows, PxU32& nCols) const
{
if(mSim)
mSim->computeDenseJacobian(cache, nRows, nCols);
}
void Sc::ArticulationCore::computeCoefficientMatrix(PxArticulationCache& cache) const
{
if(mSim)
mSim->computeCoefficientMatrix(cache);
}
bool Sc::ArticulationCore::computeLambda(PxArticulationCache& cache, PxArticulationCache& initialState, const PxReal* const jointTorque, const PxVec3 gravity, const PxU32 maxIter) const
{
return mSim ? mSim->computeLambda(cache, initialState, jointTorque, gravity, maxIter) : false;
}
void Sc::ArticulationCore::computeGeneralizedMassMatrix(PxArticulationCache& cache) const
{
if(mSim)
mSim->computeGeneralizedMassMatrix(cache);
}
PxU32 Sc::ArticulationCore::getCoefficientMatrixSize() const
{
return mSim ? mSim->getCoefficientMatrixSize() : 0xFFFFFFFFu;
}
PxSpatialVelocity Sc::ArticulationCore::getLinkAcceleration(const PxU32 linkId, const bool isGpuSimEnabled) const
{
return mSim ? mSim->getLinkAcceleration(linkId, isGpuSimEnabled) : PxSpatialVelocity();
}
PxU32 Sc::ArticulationCore::getGpuArticulationIndex() const
{
return mSim ? mCore.gpuRemapIndex : 0xffffffff;
}
void Sc::ArticulationCore::updateKinematic(PxArticulationKinematicFlags flags)
{
PX_ASSERT(mSim);
if (mSim)
mSim->updateKinematic(flags);
}
PxNodeIndex Sc::ArticulationCore::getIslandNodeIndex() const
{
return mSim ? mSim->getIslandNodeIndex() : PxNodeIndex(PX_INVALID_NODE);
}
void Sc::ArticulationCore::setGlobalPose()
{
if(mSim)
mSim->setGlobalPose();
}
| 7,894 | C++ | 26.604895 | 185 | 0.756651 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScArticulationTendonSim.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScArticulationTendonSim.h"
#include "ScArticulationTendonCore.h"
#include "ScArticulationAttachmentCore.h"
#include "ScArticulationTendonJointCore.h"
#include "ScArticulationJointCore.h"
#include "ScScene.h"
#include "DyArticulationTendon.h"
#include "ScArticulationSim.h"
using namespace physx;
Sc::ArticulationSpatialTendonSim::ArticulationSpatialTendonSim(ArticulationSpatialTendonCore& tendon, Scene& scene) :
mTendonCore(tendon), mScene(scene)
{
mTendonCore.setSim(this);
mLLTendon.mStiffness = tendon.mStiffness;
mLLTendon.mDamping = tendon.mDamping;
mLLTendon.mOffset = tendon.mOffset;
mLLTendon.mLimitStiffness = tendon.mLimitStiffness;
}
Sc::ArticulationSpatialTendonSim::~ArticulationSpatialTendonSim()
{
mTendonCore.setSim(NULL);
}
void Sc::ArticulationSpatialTendonSim::setStiffness(const PxReal stiffness)
{
mLLTendon.mStiffness = stiffness;
Dy::FeatherstoneArticulation* llArticulation = static_cast<Dy::FeatherstoneArticulation*>(mArtiSim->getLowLevelArticulation());
llArticulation->setGpuDirtyFlag(Dy::ArticulationDirtyFlag::eDIRTY_SPATIAL_TENDON);
}
PxReal Sc::ArticulationSpatialTendonSim::getStiffness() const
{
return mLLTendon.mStiffness;
}
void Sc::ArticulationSpatialTendonSim::setDamping(const PxReal damping)
{
mLLTendon.mDamping = damping;
Dy::FeatherstoneArticulation* llArticulation = static_cast<Dy::FeatherstoneArticulation*>(mArtiSim->getLowLevelArticulation());
llArticulation->setGpuDirtyFlag(Dy::ArticulationDirtyFlag::eDIRTY_SPATIAL_TENDON);
}
PxReal Sc::ArticulationSpatialTendonSim::getDamping() const
{
return mLLTendon.mDamping;
}
void Sc::ArticulationSpatialTendonSim::setLimitStiffness(const PxReal stiffness)
{
mLLTendon.mLimitStiffness = stiffness;
Dy::FeatherstoneArticulation* llArticulation = static_cast<Dy::FeatherstoneArticulation*>(mArtiSim->getLowLevelArticulation());
llArticulation->setGpuDirtyFlag(Dy::ArticulationDirtyFlag::eDIRTY_FIXED_TENDON);
}
PxReal Sc::ArticulationSpatialTendonSim::getLimitStiffness() const
{
return mLLTendon.mLimitStiffness;
}
void Sc::ArticulationSpatialTendonSim::setOffset(const PxReal offset)
{
mLLTendon.mOffset = offset;
Dy::FeatherstoneArticulation* llArticulation = static_cast<Dy::FeatherstoneArticulation*>(mArtiSim->getLowLevelArticulation());
llArticulation->setGpuDirtyFlag(Dy::ArticulationDirtyFlag::eDIRTY_SPATIAL_TENDON);
}
PxReal Sc::ArticulationSpatialTendonSim::getOffset() const
{
return mLLTendon.mOffset;
}
void Sc::ArticulationSpatialTendonSim::setAttachmentCoefficient(ArticulationAttachmentCore& core, const PxReal coefficient)
{
const PxU32 index = core.mAttachmentIndex;
Dy::ArticulationAttachment& attachment = mLLTendon.getAttachment(index);
attachment.coefficient = coefficient;
Dy::FeatherstoneArticulation* llArticulation = static_cast<Dy::FeatherstoneArticulation*>(mArtiSim->getLowLevelArticulation());
llArticulation->setGpuDirtyFlag(Dy::ArticulationDirtyFlag::eDIRTY_SPATIAL_TENDON_ATTACHMENT);
}
void Sc::ArticulationSpatialTendonSim::setAttachmentRelativeOffset(ArticulationAttachmentCore& core, const PxVec3& offset)
{
const PxU32 index = core.mAttachmentIndex;
Dy::ArticulationAttachment& attachment = mLLTendon.getAttachment(index);
attachment.relativeOffset = offset;
Dy::FeatherstoneArticulation* llArticulation = static_cast<Dy::FeatherstoneArticulation*>(mArtiSim->getLowLevelArticulation());
llArticulation->setGpuDirtyFlag(Dy::ArticulationDirtyFlag::eDIRTY_SPATIAL_TENDON_ATTACHMENT);
}
void Sc::ArticulationSpatialTendonSim::setAttachmentLimits(ArticulationAttachmentCore& core, const PxReal lowLimit, const PxReal highLimit)
{
const PxU32 index = core.mAttachmentIndex;
Dy::ArticulationAttachment& attachment = mLLTendon.getAttachment(index);
attachment.lowLimit = lowLimit;
attachment.highLimit = highLimit;
Dy::FeatherstoneArticulation* llArticulation = static_cast<Dy::FeatherstoneArticulation*>(mArtiSim->getLowLevelArticulation());
llArticulation->setGpuDirtyFlag(Dy::ArticulationDirtyFlag::eDIRTY_SPATIAL_TENDON_ATTACHMENT);
}
void Sc::ArticulationSpatialTendonSim::setAttachmentRestLength(ArticulationAttachmentCore& core, const PxReal restLength)
{
const PxU32 index = core.mAttachmentIndex;
Dy::ArticulationAttachment& attachment = mLLTendon.getAttachment(index);
attachment.restLength = restLength;
Dy::FeatherstoneArticulation* llArticulation = static_cast<Dy::FeatherstoneArticulation*>(mArtiSim->getLowLevelArticulation());
llArticulation->setGpuDirtyFlag(Dy::ArticulationDirtyFlag::eDIRTY_SPATIAL_TENDON_ATTACHMENT);
}
void Sc::ArticulationSpatialTendonSim::addAttachment(ArticulationAttachmentCore& core)
{
const PxU32 index = mLLTendon.getNewID();
Dy::ArticulationAttachment& attachment = mLLTendon.getAttachment(index);
attachment.relativeOffset = core.mRelativeOffset;
attachment.linkInd = PxU16(core.mLLLinkIndex);
attachment.lowLimit = core.mLowLimit;
attachment.highLimit = core.mHighLimit;
attachment.coefficient = core.mCoefficient;
attachment.myInd = index;
attachment.children = 0;
attachment.childCount = 0;
attachment.restLength = core.mRestLength;
core.mAttachmentIndex = index;
core.mTendonSim = this;
if (core.mParent)
{
const PxU32 parentIndex = core.mParent->mAttachmentIndex;
attachment.parent = parentIndex;
mLLTendon.getAttachment(parentIndex).children |= Dy::ArticulationAttachmentBitField(1) << index;
mLLTendon.getAttachment(parentIndex).childCount++;
}
else
{
attachment.parent = DY_ARTICULATION_ATTACHMENT_NONE;
}
}
void Sc::ArticulationSpatialTendonSim::removeAttachment(ArticulationAttachmentCore& core)
{
const PxU32 index = core.mAttachmentIndex;
Dy::ArticulationAttachment& attachment = mLLTendon.getAttachment(index);
PX_ASSERT(attachment.childCount == 0);
if (attachment.parent != DY_ARTICULATION_ATTACHMENT_NONE)
{
Dy::ArticulationAttachment& parent = mLLTendon.getAttachment(attachment.parent);
parent.children &= ~(Dy::ArticulationAttachmentBitField(1) << index);
parent.childCount--;
}
mLLTendon.freeID(index);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////
Sc::ArticulationFixedTendonSim::ArticulationFixedTendonSim(ArticulationFixedTendonCore& tendon, Scene& scene) :
mTendonCore(tendon), mScene(scene)
{
mTendonCore.setSim(this);
mLLTendon.mStiffness = tendon.mStiffness;
mLLTendon.mDamping = tendon.mDamping;
mLLTendon.mOffset = tendon.mOffset;
mLLTendon.mLimitStiffness = tendon.mLimitStiffness;
mLLTendon.mLowLimit = tendon.mLowLimit;
mLLTendon.mHighLimit = tendon.mHighLimit;
mLLTendon.mRestLength = tendon.mRestLength;
}
Sc::ArticulationFixedTendonSim::~ArticulationFixedTendonSim()
{
mTendonCore.setSim(NULL);
}
void Sc::ArticulationFixedTendonSim::setStiffness(const PxReal stiffness)
{
mLLTendon.mStiffness = stiffness;
Dy::FeatherstoneArticulation* llArticulation = static_cast<Dy::FeatherstoneArticulation*>(mArtiSim->getLowLevelArticulation());
llArticulation->setGpuDirtyFlag(Dy::ArticulationDirtyFlag::eDIRTY_FIXED_TENDON);
}
PxReal Sc::ArticulationFixedTendonSim::getStiffness() const
{
return mLLTendon.mStiffness;
}
void Sc::ArticulationFixedTendonSim::setDamping(const PxReal damping)
{
mLLTendon.mDamping = damping;
Dy::FeatherstoneArticulation* llArticulation = static_cast<Dy::FeatherstoneArticulation*>(mArtiSim->getLowLevelArticulation());
llArticulation->setGpuDirtyFlag(Dy::ArticulationDirtyFlag::eDIRTY_FIXED_TENDON);
}
PxReal Sc::ArticulationFixedTendonSim::getDamping() const
{
return mLLTendon.mDamping;
}
void Sc::ArticulationFixedTendonSim::setLimitStiffness(const PxReal stiffness)
{
mLLTendon.mLimitStiffness = stiffness;
Dy::FeatherstoneArticulation* llArticulation = static_cast<Dy::FeatherstoneArticulation*>(mArtiSim->getLowLevelArticulation());
llArticulation->setGpuDirtyFlag(Dy::ArticulationDirtyFlag::eDIRTY_FIXED_TENDON);
}
PxReal Sc::ArticulationFixedTendonSim::getLimitStiffness() const
{
return mLLTendon.mLimitStiffness;
}
void Sc::ArticulationFixedTendonSim::setOffset(const PxReal offset)
{
mLLTendon.mOffset = offset;
mArtiSim->setArticulationDirty(Dy::ArticulationDirtyFlag::eDIRTY_FIXED_TENDON);
}
PxReal Sc::ArticulationFixedTendonSim::getOffset() const
{
return mLLTendon.mOffset;
}
void Sc::ArticulationFixedTendonSim::setSpringRestLength(const PxReal restLength)
{
mLLTendon.mRestLength = restLength;
mArtiSim->setArticulationDirty(Dy::ArticulationDirtyFlag::eDIRTY_FIXED_TENDON);
}
PxReal Sc::ArticulationFixedTendonSim::getSpringRestLength() const
{
return mLLTendon.mRestLength;
}
void Sc::ArticulationFixedTendonSim::setLimitRange(const PxReal lowLimit, const PxReal highLimit)
{
mLLTendon.mLowLimit = lowLimit;
mLLTendon.mHighLimit = highLimit;
mArtiSim->setArticulationDirty(Dy::ArticulationDirtyFlag::eDIRTY_FIXED_TENDON);
}
void Sc::ArticulationFixedTendonSim::getLimitRange(PxReal& lowLimit, PxReal& highLimit) const
{
lowLimit = mLLTendon.mLowLimit;
highLimit = mLLTendon.mHighLimit;
}
void Sc::ArticulationFixedTendonSim::addTendonJoint(ArticulationTendonJointCore& tendonJointCore)
{
const PxU32 jointIndex = mLLTendon.getNewID();
Dy::ArticulationTendonJoint& tendonJoint = mLLTendon.getTendonJoint(jointIndex);
tendonJoint.axis = PxU16(tendonJointCore.axis);
tendonJoint.coefficient = tendonJointCore.coefficient;
tendonJoint.recipCoefficient = tendonJointCore.recipCoefficient;
tendonJoint.linkInd = PxU16(tendonJointCore.mLLLinkIndex);
tendonJoint.children = 0;
tendonJoint.childCount = 0;
tendonJointCore.mLLTendonJointIndex = jointIndex;
//tendonJointCore.mLLTendonJoint = &tendonJoint;
tendonJointCore.mTendonSim = this;
if (tendonJointCore.mParent)
{
const PxU32 parentIndex = tendonJointCore.mParent->mLLTendonJointIndex;
tendonJoint.parent = parentIndex;
mLLTendon.getTendonJoint(parentIndex).children |= Dy::ArticulationAttachmentBitField(1) << jointIndex;
mLLTendon.getTendonJoint(parentIndex).childCount++;
}
else
{
tendonJoint.parent = DY_ARTICULATION_ATTACHMENT_NONE;
}
}
void Sc::ArticulationFixedTendonSim::removeTendonJoint(ArticulationTendonJointCore& core)
{
const PxU32 index = core.mLLTendonJointIndex;
Dy::ArticulationTendonJoint& tendonJoint = mLLTendon.getTendonJoint(index);
PX_ASSERT(tendonJoint.childCount == 0);
if (tendonJoint.parent != DY_ARTICULATION_ATTACHMENT_NONE)
{
Dy::ArticulationTendonJoint& parent = mLLTendon.getTendonJoint(tendonJoint.parent);
parent.children &= ~(Dy::ArticulationAttachmentBitField(1) << index);
parent.childCount--;
}
mLLTendon.freeID(index);
}
void Sc::ArticulationFixedTendonSim::setTendonJointCoefficient(ArticulationTendonJointCore& core, const PxArticulationAxis::Enum axis, const float coefficient, const float recipCoefficient)
{
const PxU32 index = core.mLLTendonJointIndex;
Dy::ArticulationTendonJoint& tendonJoint = mLLTendon.getTendonJoint(index);
tendonJoint.axis = PxU16(axis);
tendonJoint.coefficient = coefficient;
tendonJoint.recipCoefficient = recipCoefficient;
mArtiSim->setArticulationDirty(Dy::ArticulationDirtyFlag::eDIRTY_FIXED_TENDON_JOINT);
}
| 12,802 | C++ | 33.23262 | 189 | 0.79761 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScTriggerPairs.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-2023 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 SC_TRIGGER_PAIRS_H
#define SC_TRIGGER_PAIRS_H
#include "foundation/PxArray.h"
#include "PxFiltering.h"
#include "PxClient.h"
#include "PxSimulationEventCallback.h"
namespace physx
{
class PxShape;
namespace Sc
{
struct TriggerPairFlag
{
enum Enum
{
eTEST_FOR_REMOVED_SHAPES = PxTriggerPairFlag::eNEXT_FREE // for cases where the pair got deleted because one of the shape volumes got removed from broadphase.
// This covers scenarios like volume re-insertion into broadphase as well since the shape might get removed
// after such an operation. The scenarios to consider are:
//
// - shape gets removed (this includes raising PxActorFlag::eDISABLE_SIMULATION)
// - shape switches to eSCENE_QUERY_SHAPE only
// - shape switches to eSIMULATION_SHAPE
// - resetFiltering()
// - actor gets removed from an aggregate
};
};
PX_COMPILE_TIME_ASSERT((1 << (8*sizeof(PxTriggerPairFlags::InternalType))) > TriggerPairFlag::eTEST_FOR_REMOVED_SHAPES);
struct TriggerPairExtraData
{
PX_INLINE TriggerPairExtraData() :
shape0ID(0xffffffff),
shape1ID(0xffffffff),
client0ID(0xff),
client1ID(0xff)
{
}
PX_INLINE TriggerPairExtraData(PxU32 s0ID, PxU32 s1ID,
PxClientID cl0ID, PxClientID cl1ID) :
shape0ID(s0ID),
shape1ID(s1ID),
client0ID(cl0ID),
client1ID(cl1ID)
{
}
PxU32 shape0ID;
PxU32 shape1ID;
PxClientID client0ID;
PxClientID client1ID;
};
typedef PxArray<TriggerPairExtraData> TriggerBufferExtraData;
typedef PxArray<PxTriggerPair> TriggerBufferAPI;
} // namespace Sc
}
#endif
| 3,419 | C | 35.382978 | 161 | 0.717754 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScFiltering.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScFiltering.h"
#include "ScShapeInteraction.h"
#include "ScTriggerInteraction.h"
#include "ScConstraintCore.h"
#include "ScArticulationSim.h"
using namespace physx;
using namespace Sc;
///////////////////////////////////////////////////////////////////////////////
PX_IMPLEMENT_OUTPUT_ERROR
///////////////////////////////////////////////////////////////////////////////
static PX_FORCE_INLINE PxU64 getPairID(const ShapeSimBase& s0, const ShapeSimBase& s1)
{
PxU64 id0 = PxU64(s0.getElementID());
PxU64 id1 = PxU64(s1.getElementID());
if(id1<id0)
PxSwap(id0, id1);
const PxU64 pairID = (id0<<32)|id1;
return pairID;
}
///////////////////////////////////////////////////////////////////////////////
template<const bool supportTriggers>
static PxFilterObjectAttributes getFilterObjectAttributes(const ShapeSimBase& shape)
{
const ActorSim& actorSim = shape.getActor();
PxFilterObjectAttributes filterAttr = actorSim.getFilterAttributes();
if(supportTriggers && (shape.getCore().getFlags() & PxShapeFlag::eTRIGGER_SHAPE))
filterAttr |= PxFilterObjectFlag::eTRIGGER;
#if PX_DEBUG
BodySim* b = shape.getBodySim();
if(b)
{
if(!b->isArticulationLink())
{
if(b->isKinematic())
PX_ASSERT(filterAttr & PxFilterObjectFlag::eKINEMATIC);
PX_ASSERT(PxGetFilterObjectType(filterAttr)==PxFilterObjectType::eRIGID_DYNAMIC);
}
else
{
PX_ASSERT(PxGetFilterObjectType(filterAttr)==PxFilterObjectType::eARTICULATION);
}
}
else
{
#if PX_SUPPORT_GPU_PHYSX
// For softbody and particle system, the bodySim is set to null
if(actorSim.isSoftBody())
{
PX_ASSERT(PxGetFilterObjectType(filterAttr)==PxFilterObjectType::eSOFTBODY);
}
else if(actorSim.isParticleSystem())
{
PX_ASSERT(PxGetFilterObjectType(filterAttr)==PxFilterObjectType::ePARTICLESYSTEM);
}
else if(actorSim.isFEMCloth())
{
PX_ASSERT(PxGetFilterObjectType(filterAttr)==PxFilterObjectType::eFEMCLOTH);
}
else if(actorSim.isHairSystem())
{
PX_ASSERT(PxGetFilterObjectType(filterAttr)==PxFilterObjectType::eHAIRSYSTEM);
}
else
#endif
{
PX_ASSERT(PxGetFilterObjectType(filterAttr)==PxFilterObjectType::eRIGID_STATIC);
}
}
#endif
return filterAttr;
}
///////////////////////////////////////////////////////////////////////////////
// PT: checks that the kill & suppress flags are not both set, disable kill flag if they are.
static PX_INLINE void checkFilterFlags(PxFilterFlags& filterFlags)
{
if((filterFlags & (PxFilterFlag::eKILL | PxFilterFlag::eSUPPRESS)) == (PxFilterFlag::eKILL | PxFilterFlag::eSUPPRESS))
{
#if PX_CHECKED
outputError<PxErrorCode::eDEBUG_WARNING>(__LINE__, "Filtering: eKILL and eSUPPRESS must not be set simultaneously. eSUPPRESS will be used.");
#endif
filterFlags.clear(PxFilterFlag::eKILL);
}
}
///////////////////////////////////////////////////////////////////////////////
static PX_INLINE PxPairFlags checkRbPairFlags( const ShapeSimBase& s0, const ShapeSimBase& s1, bool isKinePair,
PxPairFlags pairFlags, PxFilterFlags filterFlags, bool isNonRigid)
{
if(filterFlags & (PxFilterFlag::eSUPPRESS | PxFilterFlag::eKILL))
return pairFlags;
if(isKinePair && (pairFlags & PxPairFlag::eSOLVE_CONTACT))
{
#if PX_CHECKED
outputError<PxErrorCode::eDEBUG_WARNING>(__LINE__, "Filtering: Resolving contacts between two kinematic objects is invalid. Contacts will not get resolved.");
#endif
pairFlags.clear(PxPairFlag::eSOLVE_CONTACT);
}
if(isNonRigid && (pairFlags & PxPairFlag::eDETECT_CCD_CONTACT))
pairFlags.clear(PxPairFlag::eDETECT_CCD_CONTACT);
#if PX_CHECKED
// we want to avoid to run contact generation for pairs that should not get resolved or have no contact/trigger reports
if (!(PxU32(pairFlags) & (PxPairFlag::eSOLVE_CONTACT | ShapeInteraction::CONTACT_REPORT_EVENTS)))
outputError<PxErrorCode::eDEBUG_WARNING>(__LINE__, "Filtering: Pair with no contact/trigger reports detected, nor is PxPairFlag::eSOLVE_CONTACT set. It is recommended to suppress/kill such pairs for performance reasons.");
else if(!(pairFlags & (PxPairFlag::eDETECT_DISCRETE_CONTACT | PxPairFlag::eDETECT_CCD_CONTACT)))
outputError<PxErrorCode::eDEBUG_WARNING>(__LINE__, "Filtering: Pair did not request either eDETECT_DISCRETE_CONTACT or eDETECT_CCD_CONTACT. It is recommended to suppress/kill such pairs for performance reasons.");
if(((s0.getFlags() & PxShapeFlag::eTRIGGER_SHAPE)!=0 || (s1.getFlags() & PxShapeFlag::eTRIGGER_SHAPE)!=0) &&
(pairFlags & PxPairFlag::eTRIGGER_DEFAULT) && (pairFlags & PxPairFlag::eDETECT_CCD_CONTACT))
outputError<PxErrorCode::eDEBUG_WARNING>(__LINE__, "Filtering: CCD isn't supported on Triggers yet");
#else
PX_UNUSED(s0);
PX_UNUSED(s1);
#endif
return pairFlags;
}
///////////////////////////////////////////////////////////////////////////////
static PX_FORCE_INLINE bool createFilterInfo(FilterInfo& filterInfo, const PxFilterFlags filterFlags)
{
filterInfo = FilterInfo(filterFlags);
return true;
}
static void filterRbCollisionPairSecondStage(FilterInfo& filterInfo, const FilteringContext& context, const ShapeSimBase& s0, const ShapeSimBase& s1, bool isKinePair,
const PxFilterObjectAttributes fa0, const PxFilterObjectAttributes fa1, bool runCallbacks, bool isNonRigid)
{
// Run filter shader
const PxFilterData& fd0 = s0.getCore().getSimulationFilterData();
const PxFilterData& fd1 = s1.getCore().getSimulationFilterData();
filterInfo.filterFlags = context.mFilterShader(fa0, fd0, fa1, fd1, filterInfo.pairFlags, context.mFilterShaderData, context.mFilterShaderDataSize);
if(filterInfo.filterFlags & PxFilterFlag::eCALLBACK)
{
if(context.mFilterCallback)
{
if(!runCallbacks)
{
return;
}
else
{
// If a FilterPair is provided, then we use it, else we create a new one
// (A FilterPair is provided in the case for a pairLost()-pairFound() sequence after refiltering)
struct Local
{
static PX_FORCE_INLINE PxShape* fetchActorAndShape(const ShapeSimBase& sim, const PxFilterObjectAttributes fa, PxActor*& a)
{
a = sim.getActor().getPxActor();
#if PX_SUPPORT_GPU_PHYSX
if(PxGetFilterObjectType(fa)==PxFilterObjectType::ePARTICLESYSTEM)
return NULL; // Particle system does not have a valid shape so set it to null
#endif
PX_UNUSED(fa);
return sim.getPxShape();
}
};
PxActor* a0, *a1;
PxShape* shape0 = Local::fetchActorAndShape(s0, fa0, a0);
PxShape* shape1 = Local::fetchActorAndShape(s1, fa1, a1);
filterInfo.filterFlags = context.mFilterCallback->pairFound(getPairID(s0, s1), fa0, fd0, a0, shape0, fa1, fd1, a1, shape1, filterInfo.pairFlags);
filterInfo.hasPairID = true;
}
}
else
{
filterInfo.filterFlags.clear(PxFilterFlag::eNOTIFY);
outputError<PxErrorCode::eDEBUG_WARNING>(__LINE__, "Filtering: eCALLBACK set but no filter callback defined.");
}
}
checkFilterFlags(filterInfo.filterFlags);
const bool hasNotify = (filterInfo.filterFlags & PxFilterFlag::eNOTIFY) == PxFilterFlag::eNOTIFY;
const bool hasKill = filterInfo.filterFlags & PxFilterFlag::eKILL;
{
if(filterInfo.hasPairID && (hasKill || !hasNotify))
{
if(hasKill && hasNotify)
context.mFilterCallback->pairLost(getPairID(s0, s1), fa0, fd0, fa1, fd1, false);
if(!hasNotify)
{
// No notification, hence we don't need to treat it as a filter callback pair anymore.
// Make sure that eCALLBACK gets removed as well
filterInfo.filterFlags.clear(PxFilterFlag::eNOTIFY);
}
filterInfo.hasPairID = false;
}
}
// Sanity checks
PX_ASSERT((!hasKill) || (hasKill && (!filterInfo.hasPairID)));
PX_ASSERT((!hasNotify) || (hasNotify && filterInfo.hasPairID));
if(runCallbacks || (!(filterInfo.filterFlags & PxFilterFlag::eCALLBACK)))
filterInfo.pairFlags = checkRbPairFlags(s0, s1, isKinePair, filterInfo.pairFlags, filterInfo.filterFlags, isNonRigid);
}
static bool filterArticulationLinks(const BodySim* bs0, const BodySim* bs1)
{
//It's the same articulation, so we can filter based on flags...
const ArticulationSim* articulationSim0 = bs0->getArticulation();
const ArticulationSim* articulationSim1 = bs1->getArticulation();
if(articulationSim0 == articulationSim1)
{
if(articulationSim0->getCore().getArticulationFlags() & PxArticulationFlag::eDISABLE_SELF_COLLISION)
return true;
//check to see if one link is the parent of the other link, if so disable collision
const PxU32 linkId0 = bs0->getNodeIndex().articulationLinkId();
const PxU32 linkId1 = bs1->getNodeIndex().articulationLinkId();
if(linkId1 < linkId0)
return articulationSim0->getLink(linkId0).parent == linkId1;
else
return articulationSim1->getLink(linkId1).parent == linkId0;
}
return false;
}
static PX_FORCE_INLINE bool filterJointedBodies(const ActorSim& rbActor0, const ActorSim& rbActor1)
{
// If the bodies of the shape pair are connected by a joint, we need to check whether this connection disables the collision.
// Note: As an optimization, the dynamic bodies have a flag which specifies whether they have any constraints at all. That works
// because a constraint has at least one dynamic body and an interaction is tracked by both objects.
// PT: the BF_HAS_CONSTRAINTS flag is only raised on dynamic actors in the BodySim class, but it's not raised on static actors.
// Thus the only reliable way to use the flag (without casting to BodySim etc) is when both actors don't have the flag set, in
// which case we're sure we're not dealing with a jointed pair.
if(!rbActor0.readInternalFlag(ActorSim::BF_HAS_CONSTRAINTS) && !rbActor1.readInternalFlag(ActorSim::BF_HAS_CONSTRAINTS))
return false;
ConstraintCore* core = rbActor0.getScene().findConstraintCore(&rbActor0, &rbActor1);
return core ? !(core->getFlags() & PxConstraintFlag::eCOLLISION_ENABLED) : false;
}
static PX_FORCE_INLINE bool hasForceNotifEnabled(const BodySim* bs, PxRigidBodyFlag::Enum flag)
{
if(!bs)
return false;
const PxsRigidCore& core = bs->getBodyCore().getCore();
return core.mFlags.isSet(flag);
}
static PX_FORCE_INLINE bool validateSuppress(const BodySim* b0, const BodySim* b1, PxRigidBodyFlag::Enum flag)
{
if(hasForceNotifEnabled(b0, flag))
return false;
if(hasForceNotifEnabled(b1, flag))
return false;
return true;
}
static PX_FORCE_INLINE bool filterKinematics(const BodySim* b0, const BodySim* b1, bool kine0, bool kine1,
PxPairFilteringMode::Enum kineKineFilteringMode, PxPairFilteringMode::Enum staticKineFilteringMode)
{
const bool kinematicPair = kine0 | kine1;
if(kinematicPair)
{
if(staticKineFilteringMode != PxPairFilteringMode::eKEEP)
{
if(!b0 || !b1)
return validateSuppress(b0, b1, PxRigidBodyFlag::eFORCE_STATIC_KINE_NOTIFICATIONS);
}
if(kineKineFilteringMode != PxPairFilteringMode::eKEEP)
{
if(kine0 && kine1)
return validateSuppress(b0, b1, PxRigidBodyFlag::eFORCE_KINE_KINE_NOTIFICATIONS);
}
}
return false;
}
template<const bool runAllTests>
static bool filterRbCollisionPairShared( FilterInfo& filterInfo, bool& isNonRigid, bool& isKinePair,
const FilteringContext& context,
const ShapeSimBase& s0, const ShapeSimBase& s1,
const PxFilterObjectAttributes filterAttr0, const PxFilterObjectAttributes filterAttr1)
{
const bool kine0 = PxFilterObjectIsKinematic(filterAttr0);
const bool kine1 = PxFilterObjectIsKinematic(filterAttr1);
const ActorSim& rbActor0 = s0.getActor();
const BodySim* bs0 = NULL;
if(filterAttr0 & PxFilterObjectFlagEx::eRIGID_DYNAMIC)
bs0 = static_cast<const BodySim*>(&rbActor0);
else if(filterAttr0 & PxFilterObjectFlagEx::eNON_RIGID)
isNonRigid = true;
const ActorSim& rbActor1 = s1.getActor();
const BodySim* bs1 = NULL;
if(filterAttr1 & PxFilterObjectFlagEx::eRIGID_DYNAMIC)
bs1 = static_cast<const BodySim*>(&rbActor1);
else if(filterAttr1 & PxFilterObjectFlagEx::eNON_RIGID)
isNonRigid = true;
if(!isNonRigid && filterKinematics(bs0, bs1, kine0, kine1, context.mKineKineFilteringMode, context.mStaticKineFilteringMode))
return createFilterInfo(filterInfo, PxFilterFlag::eSUPPRESS);
if(filterJointedBodies(rbActor0, rbActor1))
return createFilterInfo(filterInfo, PxFilterFlag::eSUPPRESS);
const PxFilterObjectType::Enum filterType0 = PxGetFilterObjectType(filterAttr0);
const PxFilterObjectType::Enum filterType1 = PxGetFilterObjectType(filterAttr1);
// PT: For unknown reasons the filtering code was not the same for triggers/refiltered pairs and for regular "shape sim" pairs
// out of the BP. The tests on "runAllTests" below capture that. I did not change what the code
// was doing, although it might very well be wrong - we might want to run all these tests in both codepaths.
if(runAllTests)
{
#if PX_SUPPORT_GPU_PHYSX
if(filterType0==PxFilterObjectType::ePARTICLESYSTEM && filterType1==PxFilterObjectType::ePARTICLESYSTEM)
return createFilterInfo(filterInfo, PxFilterFlag::eKILL);
if(filterType0==PxFilterObjectType::eHAIRSYSTEM && filterType1==PxFilterObjectType::eHAIRSYSTEM )
return createFilterInfo(filterInfo, PxFilterFlag::eKILL);
#endif
}
const bool link0 = filterType0==PxFilterObjectType::eARTICULATION;
const bool link1 = filterType1==PxFilterObjectType::eARTICULATION;
if(runAllTests)
{
if(link0 ^ link1)
{
if(link0)
{
const PxU8 fixedBaseLink = bs0->getLowLevelBody().mCore->fixedBaseLink;
const bool isStaticOrKinematic = (filterType1 == PxFilterObjectType::eRIGID_STATIC) || kine1;
if(fixedBaseLink && isStaticOrKinematic)
return createFilterInfo(filterInfo, PxFilterFlag::eSUPPRESS);
}
if(link1)
{
const PxU8 fixedBaseLink = bs1->getLowLevelBody().mCore->fixedBaseLink;
const bool isStaticOrKinematic = (filterType0 == PxFilterObjectType::eRIGID_STATIC) || kine0;
if(fixedBaseLink && isStaticOrKinematic)
return createFilterInfo(filterInfo, PxFilterFlag::eSUPPRESS);
}
}
}
if(link0 && link1)
{
if(runAllTests)
{
const PxU8 fixedBaseLink0 = bs0->getLowLevelBody().mCore->fixedBaseLink;
const PxU8 fixedBaseLink1 = bs1->getLowLevelBody().mCore->fixedBaseLink;
if(fixedBaseLink0 && fixedBaseLink1)
return createFilterInfo(filterInfo, PxFilterFlag::eSUPPRESS);
}
if(filterArticulationLinks(bs0, bs1))
return createFilterInfo(filterInfo, PxFilterFlag::eKILL);
}
isKinePair = kine0 && kine1;
return false;
}
static void filterRbCollisionPair(FilterInfo& filterInfo, const FilteringContext& context, const ShapeSimBase& s0, const ShapeSimBase& s1, bool& isTriggerPair, bool runCallbacks)
{
const PxFilterObjectAttributes filterAttr0 = getFilterObjectAttributes<true>(s0);
const PxFilterObjectAttributes filterAttr1 = getFilterObjectAttributes<true>(s1);
const bool trigger0 = PxFilterObjectIsTrigger(filterAttr0);
const bool trigger1 = PxFilterObjectIsTrigger(filterAttr1);
isTriggerPair = trigger0 || trigger1;
bool isNonRigid = false;
bool isKinePair = false;
if(isTriggerPair)
{
if(trigger0 && trigger1) // trigger-trigger pairs are not supported
{
createFilterInfo(filterInfo, PxFilterFlag::eKILL);
return;
}
// PT: I think we need to do this here to properly handle kinematic triggers.
const bool kine0 = PxFilterObjectIsKinematic(filterAttr0);
const bool kine1 = PxFilterObjectIsKinematic(filterAttr1);
isKinePair = kine0 && kine1;
}
else
{
if(filterRbCollisionPairShared<false>(filterInfo, isNonRigid, isKinePair, context, s0, s1, filterAttr0, filterAttr1))
return;
}
filterRbCollisionPairSecondStage(filterInfo, context, s0, s1, isKinePair, filterAttr0, filterAttr1, runCallbacks, isNonRigid);
}
static PX_FORCE_INLINE void filterRbCollisionPairAllTests(FilterInfo& filterInfo, const FilteringContext& context, const ShapeSimBase& s0, const ShapeSimBase& s1)
{
PX_ASSERT(!(s0.getFlags() & PxShapeFlag::eTRIGGER_SHAPE));
PX_ASSERT(!(s1.getFlags() & PxShapeFlag::eTRIGGER_SHAPE));
const PxFilterObjectAttributes filterAttr0 = getFilterObjectAttributes<false>(s0);
const PxFilterObjectAttributes filterAttr1 = getFilterObjectAttributes<false>(s1);
bool isNonRigid = false;
bool isKinePair = false;
if(filterRbCollisionPairShared<true>(filterInfo, isNonRigid, isKinePair, context, s0, s1, filterAttr0, filterAttr1))
return;
filterRbCollisionPairSecondStage(filterInfo, context, s0, s1, isKinePair, filterAttr0, filterAttr1, true, isNonRigid);
}
static PX_FORCE_INLINE bool testElementSimPointers(const ElementSim* e0, const ElementSim* e1)
{
PX_ASSERT(e0);
PX_ASSERT(e1);
// PT: a bit of defensive coding added for OM-74224. In theory this should not be needed, as the broadphase is not
// supposed to return null pointers here. But there seems to be an issue somewhere, most probably in the GPU BP kernels,
// and this is an attempt at preventing a crash. We could/should remove this eventually.
if(!e0 || !e1)
return outputError<PxErrorCode::eINTERNAL_ERROR>(__LINE__, "NPhaseCore::runOverlapFilters: found null elements!");
return true;
}
static PX_FORCE_INLINE bool testShapeSimCorePointers(const ShapeSimBase* s0, const ShapeSimBase* s1)
{
bool isValid0 = s0->isPxsCoreValid();
bool isValid1 = s1->isPxsCoreValid();
PX_ASSERT(isValid0);
PX_ASSERT(isValid1);
// GW: further defensive coding added for OM-111249
// This is only a temporary / immediate solution to mitigate crashes
// Still need to root-cause what is causing null pointers here
if(!isValid0 || !isValid1)
return outputError<PxErrorCode::eINTERNAL_ERROR>(__LINE__,
"NPhaseCore::runOverlapFilters: found null PxsShapeCore pointers!");
return true;
}
// PT: called from OverlapFilterTask
void NPhaseCore::runOverlapFilters( PxU32 nbToProcess, const Bp::AABBOverlap* PX_RESTRICT pairs, FilterInfo* PX_RESTRICT filterInfo,
PxU32& nbToKeep_, PxU32& nbToSuppress_, PxU32* PX_RESTRICT keepMap
)
{
PxU32 nbToKeep = 0;
PxU32 nbToSuppress = 0;
const FilteringContext context(mOwnerScene);
for(PxU32 i=0; i<nbToProcess; i++)
{
const Bp::AABBOverlap& pair = pairs[i];
const ElementSim* e0 = reinterpret_cast<const ElementSim*>(pair.mUserData0);
const ElementSim* e1 = reinterpret_cast<const ElementSim*>(pair.mUserData1);
if(!testElementSimPointers(e0, e1))
continue;
PX_ASSERT(!findInteraction(e0, e1));
const ShapeSimBase* s0 = static_cast<const ShapeSimBase*>(e0);
const ShapeSimBase* s1 = static_cast<const ShapeSimBase*>(e1);
if(!testShapeSimCorePointers(s0, s1))
continue;
PX_ASSERT(&s0->getActor() != &s1->getActor()); // No actor internal interactions
filterInfo[i].filterFlags = PxFilterFlags(0);
filterInfo[i].pairFlags = PxPairFlags(0);
filterInfo[i].hasPairID = false;
filterRbCollisionPairAllTests(filterInfo[i], context, *s0, *s1);
const PxFilterFlags filterFlags = filterInfo[i].filterFlags;
if(!(filterFlags & PxFilterFlag::eKILL))
{
if(!(filterFlags & PxFilterFlag::eSUPPRESS))
nbToKeep++;
else
nbToSuppress++;
keepMap[i / 32] |= (1 << (i & 31));
}
}
nbToKeep_ = nbToKeep;
nbToSuppress_ = nbToSuppress;
}
ElementSimInteraction* NPhaseCore::createTriggerElementInteraction(ShapeSimBase& s0, ShapeSimBase& s1)
{
PX_ASSERT((s0.getFlags() & PxShapeFlag::eTRIGGER_SHAPE) || (s1.getFlags() & PxShapeFlag::eTRIGGER_SHAPE));
const FilteringContext context(mOwnerScene);
bool isTriggerPair;
FilterInfo filterInfo;
filterRbCollisionPair(filterInfo, context, s0, s1, isTriggerPair, false);
PX_ASSERT(isTriggerPair);
if(filterInfo.filterFlags & PxFilterFlag::eKILL)
{
PX_ASSERT(!filterInfo.hasPairID); // No filter callback pair info for killed pairs
return NULL;
}
return createRbElementInteraction(filterInfo, s0, s1, NULL, NULL, NULL, isTriggerPair);
}
void NPhaseCore::onTriggerOverlapCreated(const Bp::AABBOverlap* PX_RESTRICT pairs, PxU32 pairCount)
{
for(PxU32 i=0; i<pairCount; i++)
{
ElementSim* volume0 = reinterpret_cast<ElementSim*>(pairs[i].mUserData0);
ElementSim* volume1 = reinterpret_cast<ElementSim*>(pairs[i].mUserData1);
if(!testElementSimPointers(volume0, volume1))
continue;
PX_ASSERT(!findInteraction(volume0, volume1));
ShapeSimBase* shapeHi = static_cast<ShapeSimBase*>(volume1);
ShapeSimBase* shapeLo = static_cast<ShapeSimBase*>(volume0);
// No actor internal interactions
PX_ASSERT(&shapeHi->getActor() != &shapeLo->getActor());
// PT: this case is only for triggers these days
PX_ASSERT((shapeLo->getFlags() & PxShapeFlag::eTRIGGER_SHAPE) || (shapeHi->getFlags() & PxShapeFlag::eTRIGGER_SHAPE));
createTriggerElementInteraction(*shapeHi, *shapeLo);
}
}
void NPhaseCore::callPairLost(const ShapeSimBase& s0, const ShapeSimBase& s1, bool objVolumeRemoved)
{
const PxFilterObjectAttributes fa0 = getFilterObjectAttributes<true>(s0);
const PxFilterObjectAttributes fa1 = getFilterObjectAttributes<true>(s1);
const PxFilterData& fd0 = s0.getCore().getSimulationFilterData();
const PxFilterData& fd1 = s1.getCore().getSimulationFilterData();
mOwnerScene.getFilterCallbackFast()->pairLost(getPairID(s0, s1), fa0, fd0, fa1, fd1, objVolumeRemoved);
}
ElementSimInteraction* NPhaseCore::refilterInteraction(ElementSimInteraction* pair, const FilterInfo* filterInfo, bool removeFromDirtyList, PxsContactManagerOutputIterator& outputs)
{
const InteractionType::Enum oldType = pair->getType();
switch (oldType)
{
case InteractionType::eTRIGGER:
case InteractionType::eMARKER:
case InteractionType::eOVERLAP:
{
ShapeSimBase& s0 = static_cast<ShapeSimBase&>(pair->getElement0());
ShapeSimBase& s1 = static_cast<ShapeSimBase&>(pair->getElement1());
FilterInfo finfo;
if(filterInfo)
{
// The filter changes are provided by an outside source (the user filter callback)
finfo = *filterInfo;
PX_ASSERT(finfo.hasPairID);
if((finfo.filterFlags & PxFilterFlag::eKILL) &&
((finfo.filterFlags & PxFilterFlag::eNOTIFY) == PxFilterFlag::eNOTIFY) )
{
callPairLost(s0, s1, false);
finfo.hasPairID = false;
}
ActorSim& bs0 = s0.getActor();
ActorSim& bs1 = s1.getActor();
const bool isKinePair = PxFilterObjectIsKinematic(bs0.getFilterAttributes()) && PxFilterObjectIsKinematic(bs1.getFilterAttributes());
finfo.pairFlags = checkRbPairFlags(s0, s1, isKinePair, finfo.pairFlags, finfo.filterFlags, s0.getActor().isNonRigid() || s1.getActor().isNonRigid());
}
else
{
if(pair->readInteractionFlag(InteractionFlag::eIS_FILTER_PAIR))
callPairLost(s0, s1, false);
const FilteringContext context(mOwnerScene);
bool isTriggerPair;
filterRbCollisionPair(finfo, context, s0, s1, isTriggerPair, true);
PX_UNUSED(isTriggerPair);
}
if(pair->readInteractionFlag(InteractionFlag::eIS_FILTER_PAIR) &&
((finfo.filterFlags & PxFilterFlag::eNOTIFY) != PxFilterFlag::eNOTIFY) )
{
// The pair was a filter callback pair but not any longer
pair->clearInteractionFlag(InteractionFlag::eIS_FILTER_PAIR);
finfo.hasPairID = false;
}
struct Local
{
static InteractionType::Enum getRbElementInteractionType(const ShapeSimBase* primitive0, const ShapeSimBase* primitive1, PxFilterFlags filterFlag)
{
if(filterFlag & PxFilterFlag::eKILL)
return InteractionType::eINVALID;
if(filterFlag & PxFilterFlag::eSUPPRESS)
return InteractionType::eMARKER;
if(primitive0->getFlags() & PxShapeFlag::eTRIGGER_SHAPE
|| primitive1->getFlags() & PxShapeFlag::eTRIGGER_SHAPE)
return InteractionType::eTRIGGER;
PX_ASSERT( (primitive0->getGeometryType() != PxGeometryType::eTRIANGLEMESH) ||
(primitive1->getGeometryType() != PxGeometryType::eTRIANGLEMESH));
return InteractionType::eOVERLAP;
}
};
const InteractionType::Enum newType = Local::getRbElementInteractionType(&s0, &s1, finfo.filterFlags);
if(pair->getType() != newType) //Only convert interaction type if the type has changed
{
return convert(pair, newType, finfo, removeFromDirtyList, outputs);
}
else
{
//The pair flags might have changed, we need to forward the new ones
if(oldType == InteractionType::eOVERLAP)
{
ShapeInteraction* si = static_cast<ShapeInteraction*>(pair);
const PxU32 newPairFlags = finfo.pairFlags;
const PxU32 oldPairFlags = si->getPairFlags();
PX_ASSERT((newPairFlags & ShapeInteraction::PAIR_FLAGS_MASK) == newPairFlags);
PX_ASSERT((oldPairFlags & ShapeInteraction::PAIR_FLAGS_MASK) == oldPairFlags);
if(newPairFlags != oldPairFlags)
{
if(!(oldPairFlags & ShapeInteraction::CONTACT_REPORT_EVENTS) && (newPairFlags & ShapeInteraction::CONTACT_REPORT_EVENTS) && (si->getActorPair() == NULL || !si->getActorPair()->isReportPair()))
{
// for this actor pair there was no shape pair that requested contact reports but now there is one
// -> all the existing shape pairs need to get re-adjusted to point to an ActorPairReport instance instead.
ActorPair* actorPair = findActorPair(&s0, &s1, PxIntTrue);
if (si->getActorPair() == NULL)
{
actorPair->incRefCount();
si->setActorPair(*actorPair);
}
}
if(si->readFlag(ShapeInteraction::IN_PERSISTENT_EVENT_LIST) && (!(newPairFlags & PxPairFlag::eNOTIFY_TOUCH_PERSISTS)))
{
// the new report pair flags don't require persistent checks anymore -> remove from persistent list
// Note: The pair might get added to the force threshold list later
if(si->readFlag(ShapeInteraction::IS_IN_PERSISTENT_EVENT_LIST))
removeFromPersistentContactEventPairs(si);
else
si->clearFlag(ShapeInteraction::WAS_IN_PERSISTENT_EVENT_LIST);
}
if(newPairFlags & ShapeInteraction::CONTACT_FORCE_THRESHOLD_PAIRS)
{
PX_ASSERT((si->mReportPairIndex == INVALID_REPORT_PAIR_ID) || (!si->readFlag(ShapeInteraction::WAS_IN_PERSISTENT_EVENT_LIST)));
if(si->mReportPairIndex == INVALID_REPORT_PAIR_ID && si->readInteractionFlag(InteractionFlag::eIS_ACTIVE))
{
PX_ASSERT(!si->readFlag(ShapeInteraction::WAS_IN_PERSISTENT_EVENT_LIST)); // sanity check: an active pair should never have this flag set
if(si->hasTouch())
addToForceThresholdContactEventPairs(si);
}
}
else if((oldPairFlags & ShapeInteraction::CONTACT_FORCE_THRESHOLD_PAIRS))
{
// no force threshold events needed any longer -> clear flags
si->clearFlag(ShapeInteraction::FORCE_THRESHOLD_EXCEEDED_FLAGS);
if(si->readFlag(ShapeInteraction::IS_IN_FORCE_THRESHOLD_EVENT_LIST))
removeFromForceThresholdContactEventPairs(si);
}
}
si->setPairFlags(finfo.pairFlags);
}
else if(oldType == InteractionType::eTRIGGER)
static_cast<TriggerInteraction*>(pair)->setTriggerFlags(finfo.pairFlags);
return pair;
}
}
case InteractionType::eCONSTRAINTSHADER:
case InteractionType::eARTICULATION:
case InteractionType::eTRACKED_IN_SCENE_COUNT:
case InteractionType::eINVALID:
PX_ASSERT(0);
break;
}
return NULL;
}
void NPhaseCore::fireCustomFilteringCallbacks(PxsContactManagerOutputIterator& outputs)
{
PX_PROFILE_ZONE("Sim.fireCustomFilteringCallbacks", mOwnerScene.getContextId());
PxSimulationFilterCallback* callback = mOwnerScene.getFilterCallbackFast();
if(callback)
{
// Ask user for pair filter status changes
PxU64 pairID;
PxFilterFlags filterFlags;
PxPairFlags pairFlags;
while(callback->statusChange(pairID, pairFlags, filterFlags))
{
const PxU32 id0 = PxU32(pairID);
const PxU32 id1 = PxU32(pairID>>32);
const PxHashMap<ElementSimKey, ElementSimInteraction*>::Entry* pair = mElementSimMap.find(ElementSimKey(id0, id1));
ElementSimInteraction* ei = pair ? pair->second : NULL;
PX_ASSERT(ei);
// Check if the user tries to update a pair even though he deleted it earlier in the same frame
checkFilterFlags(filterFlags);
PX_ASSERT(ei->readInteractionFlag(InteractionFlag::eIS_FILTER_PAIR));
FilterInfo finfo;
finfo.filterFlags = filterFlags;
finfo.pairFlags = pairFlags;
finfo.hasPairID = true;
ElementSimInteraction* refInt = refilterInteraction(ei, &finfo, true, outputs);
// this gets called at the end of the simulation -> there should be no dirty interactions around
PX_ASSERT(!refInt->readInteractionFlag(InteractionFlag::eIN_DIRTY_LIST));
PX_ASSERT(!refInt->getDirtyFlags());
if((refInt == ei) && (refInt->getType() == InteractionType::eOVERLAP)) // No interaction conversion happened, the pairFlags were just updated
static_cast<ShapeInteraction*>(refInt)->updateState(InteractionDirtyFlag::eFILTER_STATE);
}
}
}
| 30,403 | C++ | 36.81592 | 224 | 0.725652 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScRigidSim.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#include "ScScene.h"
#include "ScRigidSim.h"
#include "ScShapeSim.h"
#include "PxsSimulationController.h"
using namespace physx;
using namespace Sc;
/*
PT:
The BP group ID comes from a Cm::IDPool, and ActorSim is the only class releasing the ID.
The rigid tracker ID comes from a Cm::IDPool internal to an ObjectIDTracker, and ActorSim
is the only class using it.
Thus we should:
- promote the BP group ID stuff to a "tracker" object
- use the BP group ID as a rigid ID
*/
RigidSim::RigidSim(Scene& scene, RigidCore& core) : ActorSim(scene, core)
{
}
RigidSim::~RigidSim()
{
}
void notifyActorInteractionsOfTransformChange(ActorSim& actor);
void RigidSim::notifyShapesOfTransformChange()
{
PxU32 nbElems = getNbElements();
ElementSim** elems = getElements();
while (nbElems--)
{
ShapeSim* sim = static_cast<ShapeSim*>(*elems++);
sim->markBoundsForUpdate();
}
notifyActorInteractionsOfTransformChange(*this);
}
void RigidSim::setBodyNodeIndex(const PxNodeIndex nodeIndex)
{
PxU32 nbElems = getNbElements();
ElementSim** elems = getElements();
while (nbElems--)
{
ShapeSim* sim = static_cast<ShapeSim*>(*elems++);
getScene().getSimulationController()->updateShape(sim->getLLShapeSim(), nodeIndex);
}
}
| 2,935 | C++ | 34.373494 | 90 | 0.752981 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/src/ScHairSystemShapeCore.cpp | // 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-2023 NVIDIA Corporation. All rights reserved.
#include "foundation/PxPreprocessor.h"
#if PX_SUPPORT_GPU_PHYSX
#include "foundation/PxErrorCallback.h"
#include "ScHairSystemShapeCore.h"
#include "ScHairSystemShapeSim.h"
#include "ScPhysics.h"
#include "PxvGlobals.h"
#include "PxPhysXGpu.h"
using namespace physx;
using namespace Sc;
namespace physx
{
namespace Sc
{
HairSystemShapeCore::HairSystemShapeCore()
: ShapeCore(PxEmpty)
, mGpuMemStat(0)
{
mSimulationFilterData = PxFilterData();
mCore = PxsShapeCore();
const PxTolerancesScale& scale = Physics::getInstance().getTolerancesScale();
mCore.setTransform(PxTransform(PxIdentity));
mCore.mContactOffset = 0.0f;
mCore.mRestOffset = 0.0f;
mCore.mShapeFlags = 0;
mCore.mMinTorsionalPatchRadius = 0.f;
mCore.mTorsionalRadius = 0.f;
mLLCore.mSleepThreshold = 5e-5f * scale.speed * scale.speed;
mLLCore.mWakeCounter = Physics::sWakeCounterOnCreation;
}
// PX_SERIALIZATION
HairSystemShapeCore::HairSystemShapeCore(const PxEMPTY)
: ShapeCore(PxEmpty)
{
}
HairSystemShapeCore::~HairSystemShapeCore()
{
releaseBuffers();
}
void HairSystemShapeCore::createBuffers(PxCudaContextManager* cudaContextManager)
{
mCudaContextManager = cudaContextManager;
// nothing else to do at the moment
}
void HairSystemShapeCore::releaseBuffers()
{
// nothing to do at the moment
}
} // namespace Sc
} // namespace physx
#endif // PX_SUPPORT_GPU_PHYSX
| 2,931 | C++ | 30.191489 | 81 | 0.769362 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/include/ScFEMClothCore.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-2023 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_SCP_FEMCLOTH_CORE
#define PX_PHYSICS_SCP_FEMCLOTH_CORE
#include "foundation/PxPreprocessor.h"
#if PX_SUPPORT_GPU_PHYSX
#if PX_ENABLE_FEATURES_UNDER_CONSTRUCTION
#include "PxFEMCloth.h"
#endif
#include "PxFEMParameter.h"
#include "../../lowleveldynamics/include/DyFEMClothCore.h"
#include "foundation/PxAssert.h"
#include "ScActorCore.h"
#include "ScShapeCore.h"
#include "PxFiltering.h"
#include "ScRigidCore.h" //KS - required for ShapeChangeNotifyFlags. Ideally, we should move that to a separate shared file
#include "PxConeLimitedConstraint.h"
namespace physx
{
namespace Sc
{
class FEMClothSim;
class FEMClothCore : public ActorCore
{
// PX_SERIALIZATION
public:
FEMClothCore(const PxEMPTY) : ActorCore(PxEmpty) {}
//static void getBinaryMetaData(PxOutputStream& stream);
//~PX_SERIALIZATION
FEMClothCore();
~FEMClothCore();
//---------------------------------------------------------------------------------
// External API
//---------------------------------------------------------------------------------
PxFEMParameters getParameter() const;
void setParameter(const PxFEMParameters& paramters);
void addRigidFilter(Sc::BodyCore* core, PxU32 vertId);
void removeRigidFilter(Sc::BodyCore* core, PxU32 vertId);
PxU32 addRigidAttachment(Sc::BodyCore* core, PxU32 vertId, const PxVec3& actorSpacePose, PxConeLimitedConstraint* constraint);
void removeRigidAttachment(Sc::BodyCore* core, PxU32 handle);
void addTriRigidFilter(Sc::BodyCore* core, PxU32 triIdx);
void removeTriRigidFilter(Sc::BodyCore* core, PxU32 triIdx);
PxU32 addTriRigidAttachment(Sc::BodyCore* core, PxU32 triIdx, const PxVec4& barycentric,
const PxVec3& actorSpacePose, PxConeLimitedConstraint* constraint);
void removeTriRigidAttachment(Sc::BodyCore* core, PxU32 handle);
void addClothFilter(Sc::FEMClothCore* otherCore, PxU32 otherTriIdx, PxU32 triIdx);
void removeClothFilter(Sc::FEMClothCore* otherCore, PxU32 otherTriIdx0, PxU32 triIdx);
PxU32 addClothAttachment(Sc::FEMClothCore* otherCore, PxU32 otherTriIdx, const PxVec4& otherTriBarycentric, PxU32 triIdx,
const PxVec4& triBarycentric);
void removeClothAttachment(Sc::FEMClothCore* otherCore, PxU32 handle);
#if 0 // disabled until future use.
void setDrag(const PxReal v) { mCore.drag = v; }
PxReal getDrag() const { return mCore.drag; }
void setLift(const PxReal v) { mCore.lift = v; }
PxReal getLift() const { return mCore.lift; }
void setWind(const PxVec3& wind) { mCore.wind = wind; }
PxVec3 getWind() const { return mCore.wind; }
void setAirDensity(const float airDensity) { mCore.airDensity = airDensity; }
PxReal getAirDensity() const { return mCore.airDensity; }
void setBendingActivationAngle(const PxReal angle) { mCore.mBendingActivationAngle = angle; }
PxReal getBendingActivationAngle() const { return mCore.mBendingActivationAngle; }
#endif
void setBendingScales(const PxReal* const bendingScales, PxU32 nbElements);
const PxReal* getBendingScales() const;
PxU32 getNbBendingScales() const { return mCore.mBendingScales.size(); }
void setMaxVelocity(const float maxVelocity) { mCore.maxVelocity = maxVelocity; }
PxReal getMaxVelocity() const { return mCore.maxVelocity; }
void setMaxDepenetrationVelocity(const float maxDepenetrationVelocity) { mCore.maxDepenetrationVelocity = maxDepenetrationVelocity; }
PxReal getMaxDepenetrationVelocity() const { return mCore.maxDepenetrationVelocity; }
void setNbCollisionPairUpdatesPerTimestep(const PxU32 frequency) { mCore.nbCollisionPairUpdatesPerTimestep = frequency; }
PxU32 getNbCollisionPairUpdatesPerTimestep() const { return mCore.nbCollisionPairUpdatesPerTimestep; }
void setNbCollisionSubsteps(const PxU32 frequency) { mCore.nbCollisionSubsteps = frequency; }
PxU32 getNbCollisionSubsteps() const { return mCore.nbCollisionSubsteps; }
PxU16 getSolverIterationCounts() const { return mCore.solverIterationCounts; }
void setSolverIterationCounts(PxU16 c);
PxActor* getPxActor() const;
void attachShapeCore(ShapeCore* shapeCore);
PxReal getWakeCounter() const;
void setWakeCounter(const PxReal v);
void setWakeCounterInternal(const PxReal v);
//---------------------------------------------------------------------------------
// Internal API
//---------------------------------------------------------------------------------
public:
FEMClothSim* getSim() const;
PX_FORCE_INLINE const Dy::FEMClothCore& getCore() const { return mCore; }
PX_FORCE_INLINE Dy::FEMClothCore& getCore() { return mCore; }
static PX_FORCE_INLINE FEMClothCore& getFEMClothCore(FEMClothCore& core)
{
size_t offset = PX_OFFSET_OF_RT(FEMClothCore, mCore);
return *reinterpret_cast<FEMClothCore*>(reinterpret_cast<PxU8*>(&core) - offset);
}
void setSimulationFilterData(const PxFilterData& data);
PxFilterData getSimulationFilterData() const;
#if PX_ENABLE_FEATURES_UNDER_CONSTRUCTION
PxFEMClothFlags getFlags() const { return mCore.mFlags; }
void setFlags(PxFEMClothFlags flags);
#endif
PX_FORCE_INLINE PxU64& getGpuMemStat() { return mGpuMemStat; }
void onShapeChange(ShapeCore& shape, ShapeChangeNotifyFlags notifyFlags);
private:
Dy::FEMClothCore mCore;
PxFilterData mFilterData;
PxU64 mGpuMemStat;
};
} // namespace Sc
}
#endif
#endif
| 7,376 | C | 41.396551 | 141 | 0.697939 |
NVIDIA-Omniverse/PhysX/physx/source/simulationcontroller/include/ScScene.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-2023 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 SC_SCENE_H
#define SC_SCENE_H
#include "PxPhysXConfig.h"
#include "PxScene.h"
#include "PxSimulationEventCallback.h"
#include "foundation/PxPool.h"
#include "foundation/PxHashSet.h"
#include "foundation/PxHashMap.h"
#include "CmTask.h"
#include "CmFlushPool.h"
#include "CmPreallocatingPool.h"
#include "foundation/PxBitMap.h"
#include "ScIterators.h"
#include "PxsMaterialManager.h"
#include "PxvManager.h"
#include "ScStaticCore.h"
#include "ScBodyCore.h"
#include "PxAggregate.h"
#include "PxsContext.h"
#include "PxsIslandSim.h"
#include "GuPrunerTypedef.h"
#include "DyContext.h"
#include "ScFiltering.h"
#include "ScBroadphase.h"
#include "ScInteraction.h"
#define PX_MAX_DOMINANCE_GROUP 32
class OverlapFilterTask;
namespace physx
{
class NpShape;
struct PxTriggerPair;
class PxsSimulationController;
class PxsSimulationControllerCallback;
class PxsMemoryManager;
struct PxConeLimitedConstraint;
#if PX_SUPPORT_GPU_PHYSX
class PxsKernelWranglerManager;
class PxsHeapMemoryAllocatorManager;
#endif
namespace IG
{
class SimpleIslandManager;
class NodeIndex;
typedef PxU32 EdgeIndex;
}
class PxsCCDContext;
namespace Cm
{
class IDPool;
}
namespace Bp
{
class AABBManagerBase;
class BroadPhase;
class BoundsArray;
}
namespace Dy
{
class FeatherstoneArticulation;
class Context;
#if PX_SUPPORT_GPU_PHYSX
class SoftBody;
class FEMCloth;
class ParticleSystem;
class HairSystem;
#endif
}
namespace Sc
{
class ActorSim;
class ElementSim;
class ShapeCore;
class RigidCore;
class ConstraintCore;
class ArticulationCore;
class ArticulationJointCore;
class ArticulationSpatialTendonCore;
class ArticulationFixedTendonCore;
class ArticulationSensorCore;
class LLArticulationPool;
class LLArticulationRCPool;
class LLSoftBodyPool;
class LLFEMClothPool;
class LLParticleSystemPool;
class LLHairSystemPool;
class BodyCore;
class SoftBodyCore;
class FEMClothCore;
class ParticleSystemCore;
class HairSystemCore;
class NPhaseCore;
class ConstraintInteraction;
class ElementSimInteraction;
class BodySim;
class ShapeSim;
class RigidSim;
class StaticSim;
class ConstraintSim;
struct TriggerPairExtraData;
class ObjectIDTracker;
class ActorPairReport;
class ContactStreamManager;
class SqBoundsManager;
class ShapeInteraction;
class ElementInteractionMarker;
class ArticulationSim;
class SoftBodySim;
class FEMClothSim;
class ParticleSystemSim;
class HairSystemSim;
class SimStats;
struct SimStateData;
struct BatchInsertionState
{
BodySim* bodySim;
StaticSim*staticSim;
ShapeSim* shapeSim;
ptrdiff_t staticActorOffset;
ptrdiff_t staticShapeTableOffset;
ptrdiff_t dynamicActorOffset;
ptrdiff_t dynamicShapeTableOffset;
ptrdiff_t shapeOffset;
};
struct BatchRemoveState
{
PxInlineArray<ShapeSim*, 64> bufferedShapes;
PxInlineArray<const ShapeCore*, 64> removedShapes;
};
struct SceneInternalFlag
{
enum Enum
{
eSCENE_SIP_STATES_DIRTY_DOMINANCE = (1<<1),
eSCENE_SIP_STATES_DIRTY_VISUALIZATION = (1<<2),
eSCENE_DEFAULT = 0
};
};
struct SimulationStage
{
enum Enum
{
eCOMPLETE,
eCOLLIDE,
eFETCHCOLLIDE,
eADVANCE,
eFETCHRESULT
};
};
struct SqBoundsSync;
struct SqRefFinder;
struct ParticleOrSoftBodyRigidInteraction
{
IG::EdgeIndex mIndex;
PxU32 mCount;
ParticleOrSoftBodyRigidInteraction() : mCount(0) {}
};
class Scene : public PxUserAllocated
{
struct SimpleBodyPair
{
ActorSim* body1;
ActorSim* body2;
PxU32 body1ID;
PxU32 body2ID;
};
PX_NOCOPY(Scene)
public:
Scene(const PxSceneDesc& desc, PxU64 contextID);
~Scene() {} //use release() plz.
void preAllocate(PxU32 nbStatics, PxU32 nbBodies, PxU32 nbStaticShapes, PxU32 nbDynamicShapes);
void release();
PX_FORCE_INLINE PxsSimulationController* getSimulationController() { return mSimulationController; }
PX_FORCE_INLINE const PxsSimulationController* getSimulationController() const { return mSimulationController; }
PX_FORCE_INLINE Bp::AABBManagerBase* getAABBManager() { return mAABBManager; }
PX_FORCE_INLINE const Bp::AABBManagerBase* getAABBManager() const { return mAABBManager; }
PX_FORCE_INLINE PxArray<BodySim*>& getCcdBodies() { return mCcdBodies; }
PX_FORCE_INLINE IG::SimpleIslandManager* getSimpleIslandManager() { return mSimpleIslandManager; }
PX_FORCE_INLINE const IG::SimpleIslandManager* getSimpleIslandManager() const { return mSimpleIslandManager; }
PX_FORCE_INLINE SimulationStage::Enum getSimulationStage() const { return mSimulationStage; }
PX_FORCE_INLINE void setSimulationStage(SimulationStage::Enum stage) { mSimulationStage = stage; }
PX_FORCE_INLINE PxPool<SimStateData>* getSimStateDataPool() { return mSimStateDataPool; }
PX_FORCE_INLINE PxBitMap& getDirtyShapeSimMap() { return mDirtyShapeSimMap; }
PX_FORCE_INLINE void setGravity(const PxVec3& g) { mGravity = g; }
PX_FORCE_INLINE const PxVec3& getGravity() const { return mGravity; }
PX_FORCE_INLINE void setElapsedTime(PxReal t) { mDt = t; mOneOverDt = t > 0.0f ? 1.0f/t : 0.0f; }
PX_FORCE_INLINE PxReal getOneOverDt() const { return mOneOverDt; }
// PX_FORCE_INLINE PxReal getDt() const { return mDt; }
PX_FORCE_INLINE void setLimits(const PxSceneLimits& limits) { mLimits = limits; }
PX_FORCE_INLINE const PxSceneLimits& getLimits() const { return mLimits; }
PX_FORCE_INLINE void setBatchRemove(BatchRemoveState* bs) { mBatchRemoveState = bs; }
PX_FORCE_INLINE BatchRemoveState* getBatchRemove() const { return mBatchRemoveState; }
PX_FORCE_INLINE void setMaxArticulationLinks(const PxU32 maxLinks) { mMaxNbArticulationLinks = maxLinks; }
PX_FORCE_INLINE PxU32 getMaxArticulationLinks() const { return mMaxNbArticulationLinks; }
// mDynamicsContext wrappers
PX_FORCE_INLINE Dy::Context* getDynamicsContext() { return mDynamicsContext; }
PX_FORCE_INLINE const Dy::Context* getDynamicsContext() const { return mDynamicsContext; }
PX_FORCE_INLINE void setBounceThresholdVelocity(PxReal t) { mDynamicsContext->setBounceThreshold(-t); }
PX_FORCE_INLINE PxReal getBounceThresholdVelocity() const { return -mDynamicsContext->getBounceThreshold(); }
PX_FORCE_INLINE PxSolverType::Enum getSolverType() const { return mDynamicsContext->getSolverType(); }
PX_FORCE_INLINE void setFrictionType(PxFrictionType::Enum model) { mDynamicsContext->setFrictionType(model); }
PX_FORCE_INLINE PxFrictionType::Enum getFrictionType() const { return mDynamicsContext->getFrictionType(); }
PX_FORCE_INLINE void setSolverBatchSize(PxU32 solverBatchSize) { mDynamicsContext->setSolverBatchSize(solverBatchSize); }
PX_FORCE_INLINE PxU32 getSolverBatchSize() const { return mDynamicsContext->getSolverBatchSize(); }
PX_FORCE_INLINE void setSolverArticBatchSize(PxU32 solverBatchSize) { mDynamicsContext->setSolverArticBatchSize(solverBatchSize); }
PX_FORCE_INLINE PxU32 getSolverArticBatchSize() const { return mDynamicsContext->getSolverArticBatchSize(); }
PX_FORCE_INLINE void setCCDMaxSeparation(PxReal separation) { mDynamicsContext->setCCDSeparationThreshold(separation); }
PX_FORCE_INLINE PxReal getCCDMaxSeparation() const { return mDynamicsContext->getCCDSeparationThreshold(); }
PX_FORCE_INLINE void setMaxBiasCoefficient(PxReal coeff) { mDynamicsContext->setMaxBiasCoefficient(coeff); }
PX_FORCE_INLINE PxReal getMaxBiasCoefficient() const { return mDynamicsContext->getMaxBiasCoefficient(); }
PX_FORCE_INLINE void setFrictionOffsetThreshold(PxReal t) { mDynamicsContext->setFrictionOffsetThreshold(t); }
PX_FORCE_INLINE PxReal getFrictionOffsetThreshold() const { return mDynamicsContext->getFrictionOffsetThreshold(); }
PX_FORCE_INLINE void setFrictionCorrelationDistance(PxReal t) { mDynamicsContext->setCorrelationDistance(t); }
PX_FORCE_INLINE PxReal getFrictionCorrelationDistance() const { return mDynamicsContext->getCorrelationDistance(); }
PX_FORCE_INLINE PxReal getLengthScale() const { return mDynamicsContext->getLengthScale(); }
PX_FORCE_INLINE void setDynamicsDirty() { mDynamicsContext->setStateDirty(true); }
//~mDynamicsContext wrappers
// mLLContext wrappers
PX_FORCE_INLINE PxsContext* getLowLevelContext() { return mLLContext; }
PX_FORCE_INLINE const PxsContext* getLowLevelContext() const { return mLLContext; }
PX_FORCE_INLINE Cm::FlushPool* getFlushPool() { return &mLLContext->getTaskPool(); }
PX_FORCE_INLINE void setPCM(bool enabled) { mLLContext->setPCM(enabled); }
PX_FORCE_INLINE void setContactCache(bool enabled) { mLLContext->setContactCache(enabled); }
PX_FORCE_INLINE void setContactModifyCallback(PxContactModifyCallback* callback) { mLLContext->setContactModifyCallback(callback); }
PX_FORCE_INLINE PxContactModifyCallback* getContactModifyCallback() const { return mLLContext->getContactModifyCallback(); }
PX_FORCE_INLINE void setVisualizationParameter(PxVisualizationParameter::Enum param, PxReal value)
{
mVisualizationParameterChanged = true;
mLLContext->setVisualizationParameter(param, value);
}
PX_FORCE_INLINE PxReal getVisualizationParameter(PxVisualizationParameter::Enum param) const { return mLLContext->getVisualizationParameter(param); }
PX_FORCE_INLINE void setVisualizationCullingBox(const PxBounds3& box) { mLLContext->setVisualizationCullingBox(box); }
PX_FORCE_INLINE const PxBounds3& getVisualizationCullingBox() const { return mLLContext->getVisualizationCullingBox(); }
PX_FORCE_INLINE PxReal getVisualizationScale() const { return mLLContext->getRenderScale(); }
PX_FORCE_INLINE PxRenderBuffer& getRenderBuffer() { return mLLContext->getRenderBuffer(); }
PX_FORCE_INLINE void setNbContactDataBlocks(PxU32 blockCount) { mLLContext->getNpMemBlockPool().setBlockCount(blockCount); }
PX_FORCE_INLINE PxU32 getNbContactDataBlocksUsed() const { return mLLContext->getNpMemBlockPool().getUsedBlockCount(); }
PX_FORCE_INLINE PxU32 getMaxNbContactDataBlocksUsed() const { return mLLContext->getNpMemBlockPool().getMaxUsedBlockCount(); }
PX_FORCE_INLINE PxU32 getMaxNbConstraintDataBlocksUsed() const { return mLLContext->getNpMemBlockPool().getPeakConstraintBlockCount(); }
PX_FORCE_INLINE void setScratchBlock(void* addr, PxU32 size) { mLLContext->setScratchBlock(addr, size); }
//~mLLContext wrappers
PX_FORCE_INLINE void setFlags(PxSceneFlags flags)
{
mPublicFlags = flags;
}
PX_FORCE_INLINE PxSceneFlags getFlags() const { return mPublicFlags; }
PX_FORCE_INLINE bool readInternalFlag(SceneInternalFlag::Enum flag) const { return (mInternalFlags & flag) != 0; }
void addStatic(StaticCore&, NpShape*const *shapes, PxU32 nbShapes, size_t shapePtrOffset, PxBounds3* uninflatedBounds);
void removeStatic(StaticCore&, PxInlineArray<const ShapeCore*,64>& removedShapes, bool wakeOnLostTouch);
void addBody(BodyCore&, NpShape*const *shapes, PxU32 nbShapes, size_t shapePtrOffset, PxBounds3* uninflatedBounds, bool compound);
void removeBody(BodyCore&, PxInlineArray<const ShapeCore*,64>& removedShapes, bool wakeOnLostTouch);
// Batch insertion API.
// the bounds generated here are the uninflated bounds for the shapes, *if* they are trigger or sim shapes.
// It's up to the caller to ensure the bounds array is big enough.
// Some care is required in handling these since sim and SQ tweak the bounds in slightly different ways.
void startBatchInsertion(BatchInsertionState&);
void addStatic(PxActor* actor, BatchInsertionState&, PxBounds3* outBounds);
void addBody(PxActor* actor, BatchInsertionState&, PxBounds3* outBounds, bool compound);
void finishBatchInsertion(BatchInsertionState&);
void addConstraint(ConstraintCore&, RigidCore*, RigidCore*);
void removeConstraint(ConstraintCore&);
void addArticulation(ArticulationCore&, BodyCore& root);
void removeArticulation(ArticulationCore&);
void addArticulationJoint(ArticulationJointCore&, BodyCore& parent, BodyCore& child);
void removeArticulationJoint(ArticulationJointCore&);
void addArticulationTendon(ArticulationSpatialTendonCore&);
void removeArticulationTendon(ArticulationSpatialTendonCore&);
void addArticulationTendon(ArticulationFixedTendonCore&);
void removeArticulationTendon(ArticulationFixedTendonCore&);
void addArticulationSensor(ArticulationSensorCore&);
void removeArticulationSensor(ArticulationSensorCore&);
void addArticulationSimControl(ArticulationCore& core);
void removeArticulationSimControl(ArticulationCore& core);
void updateBodySim(BodySim& sim);
PX_FORCE_INLINE PxU32 getNbArticulations() const { return mArticulations.size(); }
PX_FORCE_INLINE ArticulationCore* const* getArticulations() { return mArticulations.getEntries(); }
PX_FORCE_INLINE PxU32 getNbConstraints() const { return mConstraints.size(); }
PX_FORCE_INLINE ConstraintCore*const* getConstraints() const { return mConstraints.getEntries(); }
PX_FORCE_INLINE ConstraintCore*const* getConstraints() { return mConstraints.getEntries(); }
void initContactsIterator(ContactIterator&, PxsContactManagerOutputIterator&);
void setSimulationEventCallback(PxSimulationEventCallback* callback);
PxSimulationEventCallback* getSimulationEventCallback() const;
void setCCDContactModifyCallback(PxCCDContactModifyCallback* callback);
PxCCDContactModifyCallback* getCCDContactModifyCallback() const;
void setCCDMaxPasses(PxU32 ccdMaxPasses);
PxU32 getCCDMaxPasses() const;
void setCCDThreshold(PxReal t);
PxReal getCCDThreshold() const;
// Broad-phase management
void finishBroadPhase(PxBaseTask* continuation);
void finishBroadPhaseStage2(PxU32 ccdPass);
void preallocateContactManagers(PxBaseTask* continuation);
void islandInsertion(PxBaseTask* continuation);
void registerContactManagers(PxBaseTask* continuation);
void registerInteractions(PxBaseTask* continuation);
void registerSceneInteractions(PxBaseTask* continuation);
void secondPassNarrowPhase(PxBaseTask* continuation);
void setDominanceGroupPair(PxDominanceGroup group1, PxDominanceGroup group2, const PxDominanceGroupPair& dominance);
PxDominanceGroupPair getDominanceGroupPair(PxDominanceGroup group1, PxDominanceGroup group2) const;
// Run
void simulate(PxReal timeStep, PxBaseTask* continuation);
void advance(PxReal timeStep, PxBaseTask* continuation);
void collide(PxReal timeStep, PxBaseTask* continuation);
void endSimulation();
void flush(bool sendPendingReports);
void fireBrokenConstraintCallbacks();
void fireTriggerCallbacks();
void fireQueuedContactCallbacks();
void fireOnAdvanceCallback();
const PxArray<PxContactPairHeader>&
getQueuedContactPairHeaders();
void postCallbacksPreSync();
void postCallbacksPreSyncKinematics();
void postReportsCleanup();
void fireCallbacksPostSync();
void syncSceneQueryBounds(SqBoundsSync& sync, SqRefFinder& finder);
PxU32 getDefaultContactReportStreamBufferSize() const;
void visualizeStartStep();
// PX_ENABLE_SIM_STATS
void getStats(PxSimulationStatistics& stats) const;
PX_FORCE_INLINE SimStats& getStatsInternal() { return *mStats; }
// PX_ENABLE_SIM_STATS
void buildActiveActors();
void buildActiveAndFrozenActors();
PxActor** getActiveActors(PxU32& nbActorsOut);
void setActiveActors(PxActor** actors, PxU32 nbActors);
PxActor** getFrozenActors(PxU32& nbActorsOut);
void finalizeContactStreamAndCreateHeader(PxContactPairHeader& header,
const ActorPairReport& aPair,
ContactStreamManager& cs, PxU32 removedShapeTestMask);
PxTaskManager* getTaskManagerPtr() const { return mTaskManager; }
PxCudaContextManager* getCudaContextManager() const { return mCudaContextManager; }
void shiftOrigin(const PxVec3& shift);
PX_FORCE_INLINE bool isCollisionPhaseActive() const { return mIsCollisionPhaseActive; }
PX_FORCE_INLINE void setCollisionPhaseToActive() { PX_ASSERT(!mIsCollisionPhaseActive); mIsCollisionPhaseActive = true; }
PX_FORCE_INLINE void setCollisionPhaseToInactive() { PX_ASSERT(mIsCollisionPhaseActive); mIsCollisionPhaseActive = false; }
void addShape_(RigidSim&, ShapeCore&);
void removeShape_(ShapeSim&, bool wakeOnLostTouch);
void registerShapeInNphase(RigidCore* rigidCore, const ShapeCore& shapeCore, const PxU32 transformCacheID);
void unregisterShapeFromNphase(const ShapeCore& shapeCore, const PxU32 transformCacheID);
void notifyNphaseOnUpdateShapeMaterial(const ShapeCore& shapeCore);
// Get an array of the active actors.
PX_FORCE_INLINE BodyCore*const* getActiveBodiesArray() const { return mActiveBodies.begin(); }
PX_FORCE_INLINE PxU32 getNumActiveBodies() const { return mActiveBodies.size(); }
PX_FORCE_INLINE BodyCore*const* getActiveCompoundBodiesArray() const { return mActiveCompoundBodies.begin(); }
PX_FORCE_INLINE PxU32 getNumActiveCompoundBodies() const { return mActiveCompoundBodies.size(); }
PX_FORCE_INLINE PxU32 getNbInteractions(InteractionType::Enum type) const { return mInteractions[type].size(); }
PX_FORCE_INLINE PxU32 getNbActiveInteractions(InteractionType::Enum type) const { return mActiveInteractionCount[type]; }
// Get all interactions of a certain type
PX_FORCE_INLINE ElementSimInteraction** getInteractions(InteractionType::Enum type) { return mInteractions[type].begin(); }
PX_FORCE_INLINE ElementSimInteraction** getActiveInteractions(InteractionType::Enum type) { return mInteractions[type].begin(); }
void registerInteraction(ElementSimInteraction* interaction, bool active);
void unregisterInteraction(ElementSimInteraction* interaction);
void notifyInteractionActivated(Interaction* interaction);
void notifyInteractionDeactivated(Interaction* interaction);
// for pool management of interaction arrays, a major cause of dynamic allocation
void** allocatePointerBlock(PxU32 size);
void deallocatePointerBlock(void**, PxU32 size);
private:
// Get the number of active one-way dominator actors
PX_FORCE_INLINE PxU32 getActiveKinematicBodiesCount() const { return mActiveKinematicBodyCount; }
// Get an iterator to the active one-way dominator actors
PX_FORCE_INLINE BodyCore*const* getActiveKinematicBodies() const { return mActiveBodies.begin(); }
// Get the number of active non-kinematic actors
PX_FORCE_INLINE PxU32 getActiveDynamicBodiesCount() const { return mActiveBodies.size() - mActiveKinematicBodyCount; }
// Get the active non-kinematic actors
PX_FORCE_INLINE BodyCore*const* getActiveDynamicBodies() const { return mActiveBodies.begin() + mActiveKinematicBodyCount; }
void swapInteractionArrayIndices(PxU32 id1, PxU32 id2, InteractionType::Enum type);
public:
void addDirtyArticulationSim(ArticulationSim* artiSim);
void removeDirtyArticulationSim(ArticulationSim* artiSim);
void addToActiveList(ActorSim& actor);
void removeFromActiveList(ActorSim& actor);
void removeFromActiveCompoundBodyList(BodySim& actor);
void swapInActiveBodyList(BodySim& body); // call when an active body gets switched from dynamic to kinematic or vice versa
void addActiveBreakableConstraint(ConstraintSim*, ConstraintInteraction*);
void removeActiveBreakableConstraint(ConstraintSim*);
//the Actor should register its top level shapes with these.
void removeBody(BodySim&);
//lists of actors woken up or put to sleep last simulate
void onBodyWakeUp(BodySim* body);
void onBodySleep(BodySim* body);
PX_FORCE_INLINE bool isValid() const { return (mLLContext != NULL); }
void addToLostTouchList(ActorSim& body1, ActorSim& body2);
PxU32 createAggregate(void* userData, PxU32 maxNumShapes, PxAggregateFilterHint filterHint);
void deleteAggregate(PxU32 id);
Dy::FeatherstoneArticulation* createLLArticulation(ArticulationSim* sim);
void destroyLLArticulation(Dy::FeatherstoneArticulation&);
PX_FORCE_INLINE PxPool<ConstraintInteraction>* getConstraintInteractionPool() const { return mConstraintInteractionPool; }
public:
PX_FORCE_INLINE const PxsMaterialManager& getMaterialManager() const { return mMaterialManager; }
PX_FORCE_INLINE PxsMaterialManager& getMaterialManager() { return mMaterialManager; }
PX_FORCE_INLINE const BroadphaseManager& getBroadphaseManager() const { return mBroadphaseManager; }
PX_FORCE_INLINE BroadphaseManager& getBroadphaseManager() { return mBroadphaseManager; }
PX_FORCE_INLINE bool fireOutOfBoundsCallbacks()
{
return mBroadphaseManager.fireOutOfBoundsCallbacks(mAABBManager, *mElementIDPool);
}
// Collision filtering
void setFilterShaderData(const void* data, PxU32 dataSize);
PX_FORCE_INLINE const void* getFilterShaderDataFast() const { return mFilterShaderData; }
PX_FORCE_INLINE PxU32 getFilterShaderDataSizeFast() const { return mFilterShaderDataSize; }
PX_FORCE_INLINE PxSimulationFilterShader getFilterShaderFast() const { return mFilterShader; }
PX_FORCE_INLINE PxSimulationFilterCallback* getFilterCallbackFast() const { return mFilterCallback; }
PX_FORCE_INLINE PxPairFilteringMode::Enum getKineKineFilteringMode() const { return mKineKineFilteringMode; }
PX_FORCE_INLINE PxPairFilteringMode::Enum getStaticKineFilteringMode() const { return mStaticKineFilteringMode; }
PX_FORCE_INLINE PxU32 getTimeStamp() const { return mTimeStamp; }
PX_FORCE_INLINE PxU32 getReportShapePairTimeStamp() const { return mReportShapePairTimeStamp; }
PX_FORCE_INLINE NPhaseCore* getNPhaseCore() const { return mNPhaseCore; }
void checkConstraintBreakage();
PX_FORCE_INLINE PxArray<TriggerPairExtraData>&
getTriggerBufferExtraData() { return *mTriggerBufferExtraData; }
PX_FORCE_INLINE PxArray<PxTriggerPair>& getTriggerBufferAPI() { return mTriggerBufferAPI; }
void reserveTriggerReportBufferSpace(const PxU32 pairCount, PxTriggerPair*& triggerPairBuffer, TriggerPairExtraData*& triggerPairExtraBuffer);
PX_FORCE_INLINE ObjectIDTracker& getActorIDTracker() { return *mActorIDTracker; }
PX_FORCE_INLINE void markReleasedBodyIDForLostTouch(PxU32 id) { mLostTouchPairsDeletedBodyIDs.growAndSet(id); }
void resizeReleasedBodyIDMaps(PxU32 maxActors, PxU32 numActors);
PX_FORCE_INLINE StaticSim& getStaticAnchor() { return *mStaticAnchor; }
PX_FORCE_INLINE Bp::BoundsArray& getBoundsArray() const { return *mBoundsArray; }
PX_FORCE_INLINE void updateContactDistance(PxU32 idx, PxReal distance) { (*mContactDistance)[idx] = distance; mHasContactDistanceChanged = true; }
PX_FORCE_INLINE SqBoundsManager& getSqBoundsManager() const { return *mSqBoundsManager; }
PX_FORCE_INLINE BodyCore* const* getSleepBodiesArray(PxU32& count) { count = mSleepBodies.size(); return mSleepBodies.getEntries(); }
PX_FORCE_INLINE PxTaskManager& getTaskManager() const { PX_ASSERT(mTaskManager); return *mTaskManager; }
PX_FORCE_INLINE void setPostSolverVelocityNeeded() { mContactReportsNeedPostSolverVelocity = true; }
PX_FORCE_INLINE ObjectIDTracker& getConstraintIDTracker() { return *mConstraintIDTracker; }
PX_FORCE_INLINE ObjectIDTracker& getElementIDPool() { return *mElementIDPool; }
PX_FORCE_INLINE PxBitMap& getVelocityModifyMap() { return mVelocityModifyMap; }
void* allocateConstraintBlock(PxU32 size);
void deallocateConstraintBlock(void* addr, PxU32 size);
void stepSetupCollide(PxBaseTask* continuation);//This is very important to guarantee thread safty in the collide
PX_FORCE_INLINE void addToPosePreviewList(BodySim& b) { PX_ASSERT(!mPosePreviewBodies.contains(&b)); mPosePreviewBodies.insert(&b); }
PX_FORCE_INLINE void removeFromPosePreviewList(BodySim& b) { PX_ASSERT(mPosePreviewBodies.contains(&b)); mPosePreviewBodies.erase(&b); }
#if PX_DEBUG
PX_FORCE_INLINE bool isInPosePreviewList(BodySim& b) const { return mPosePreviewBodies.contains(&b); }
#endif
PX_FORCE_INLINE void setSpeculativeCCDRigidBody(PxU32 index) { mSpeculativeCCDRigidBodyBitMap.growAndSet(index); }
PX_FORCE_INLINE void resetSpeculativeCCDRigidBody(PxU32 index) { if(index < mSpeculativeCCDRigidBodyBitMap.size()) mSpeculativeCCDRigidBodyBitMap.reset(index); }
PX_FORCE_INLINE void setSpeculativeCCDArticulationLink(PxU32 index) { mSpeculativeCDDArticulationBitMap.growAndSet(index); }
PX_FORCE_INLINE void resetSpeculativeCCDArticulationLink(PxU32 index) { if(index < mSpeculativeCDDArticulationBitMap.size()) mSpeculativeCDDArticulationBitMap.reset(index); }
PX_FORCE_INLINE PxU64 getContextId() const { return mContextId; }
PX_FORCE_INLINE bool isUsingGpuDynamicsOrBp() const { return mUseGpuBp || mUseGpuDynamics; }
PX_FORCE_INLINE bool isUsingGpuDynamicsAndBp() const { return mUseGpuBp && mUseGpuDynamics; }
PX_FORCE_INLINE bool isUsingGpuDynamics() const { return mUseGpuDynamics; }
PX_FORCE_INLINE bool isUsingGpuBp() const { return mUseGpuBp; }
PX_FORCE_INLINE void setDirectGPUAPIInitialized() { mIsDirectGPUAPIInitialized = true; }
PX_FORCE_INLINE bool isDirectGPUAPIInitialized() const { return mIsDirectGPUAPIInitialized; }
// statistics counters increase/decrease
PX_FORCE_INLINE void increaseNumKinematicsCounter() { mNbRigidKinematic++; }
PX_FORCE_INLINE void decreaseNumKinematicsCounter() { mNbRigidKinematic--; }
PX_FORCE_INLINE void increaseNumDynamicsCounter() { mNbRigidDynamics++; }
PX_FORCE_INLINE void decreaseNumDynamicsCounter() { mNbRigidDynamics--; }
ConstraintCore* findConstraintCore(const ActorSim* sim0, const ActorSim* sim1);
//internal private methods:
private:
void activateEdgesInternal(const IG::EdgeIndex* activatingEdges, const PxU32 nbActivatingEdges);
void releaseConstraints(bool endOfScene);
PX_INLINE void clearBrokenConstraintBuffer() { mBrokenConstraints.clear(); }
/////////////////////////////////////////////////////////////
void collideStep(PxBaseTask* continuation);
void advanceStep(PxBaseTask* continuation);
// subroutines of collideStep/solveStep:
void kinematicsSetup(PxBaseTask* continuation);
void stepSetupSolve(PxBaseTask* continuation);
//void stepSetupSimulate();
void processNarrowPhaseTouchEvents();
void processNarrowPhaseTouchEventsStage2(PxBaseTask*);
void setEdgesConnected(PxBaseTask*);
void processNarrowPhaseLostTouchEvents(PxBaseTask*);
void processNarrowPhaseLostTouchEventsIslands(PxBaseTask*);
void processLostTouchPairs();
void integrateKinematicPose();
void updateKinematicCached(PxBaseTask* task);
void beforeSolver(PxBaseTask* continuation);
void checkForceThresholdContactEvents(PxU32 ccdPass);
private:
void putObjectsToSleep();
void wakeObjectsUp();
void collectPostSolverVelocitiesBeforeCCD();
void clearSleepWakeBodies(void);
PX_INLINE void cleanUpSleepBodies();
PX_INLINE void cleanUpWokenBodies();
PX_INLINE void cleanUpSleepOrWokenBodies(PxCoalescedHashSet<BodyCore*>& bodyList, PxU32 removeFlag, bool& validMarker);
private:
// Material manager
PX_ALIGN(16, PxsMaterialManager mMaterialManager);
BroadphaseManager mBroadphaseManager;
PxU64 mContextId;
PxArray<BodyCore*> mActiveBodies; // Sorted: kinematic before dynamic
PxU32 mActiveKinematicBodyCount; // Number of active kinematics. This is also the index in mActiveBodies where the active dynamic bodies start.
PxU32 mActiveDynamicBodyCount; // Number of active dynamics. This is also the index in mActiveBodies where the active soft bodies start.
PxArray<BodyCore*> mActiveCompoundBodies;
BodyCore** mActiveKinematicsCopy;
PxU32 mActiveKinematicsCopyCapacity;
// PT: this array used for:
// - debug visualization
// - processing trigger interactions
// - updating dirty interactions
PxArray<ElementSimInteraction*> mInteractions[InteractionType::eTRACKED_IN_SCENE_COUNT];
PxU32 mActiveInteractionCount[InteractionType::eTRACKED_IN_SCENE_COUNT]; // Interactions with id < activeInteractionCount are active
template <typename T, PxU32 size>
struct Block
{
PxU8 mem[sizeof(T)*size];
Block() {} // get around VS warning C4345, otherwise useless
};
typedef Block<void*, 8> PointerBlock8;
typedef Block<void*, 16> PointerBlock16;
typedef Block<void*, 32> PointerBlock32;
PxPool<PointerBlock8> mPointerBlock8Pool;
PxPool<PointerBlock16> mPointerBlock16Pool;
PxPool<PointerBlock32> mPointerBlock32Pool;
PxsContext* mLLContext;
Bp::AABBManagerBase* mAABBManager;
PxsCCDContext* mCCDContext;
PxI32 mNumFastMovingShapes;
PxU32 mCCDPass;
IG::SimpleIslandManager* mSimpleIslandManager;
Dy::Context* mDynamicsContext;
PxsMemoryManager* mMemoryManager;
#if PX_SUPPORT_GPU_PHYSX
PxsKernelWranglerManager* mGpuWranglerManagers;
PxsHeapMemoryAllocatorManager* mHeapMemoryAllocationManager;
#endif
PxsSimulationController* mSimulationController;
PxsSimulationControllerCallback* mSimulationControllerCallback;
PxSceneLimits mLimits;
PxVec3 mGravity; //!< Gravity vector
PxArray<PxContactPairHeader>
mQueuedContactPairHeaders;
//time:
//constants set with setTiming():
PxReal mDt; //delta time for current step.
PxReal mOneOverDt; //inverse of dt.
//stepping / counters:
PxU32 mTimeStamp; //Counts number of steps.
PxU32 mReportShapePairTimeStamp; //Timestamp for refreshing the shape pair report structure. Updated before delayed shape/actor deletion and before CCD passes.
//containers:
// Those ones contain shape ptrs from Actor, i.e. compound level, not subparts
PxCoalescedHashSet<ConstraintCore*> mConstraints;
Bp::BoundsArray* mBoundsArray;
PxFloatArrayPinned* mContactDistance;
bool mHasContactDistanceChanged;
SqBoundsManager* mSqBoundsManager;
PxArray<BodySim*> mCcdBodies;
PxArray<PxTriggerPair> mTriggerBufferAPI;
PxArray<TriggerPairExtraData>* mTriggerBufferExtraData;
PxCoalescedHashSet<ArticulationCore*> mArticulations;
PxCoalescedHashSet<ArticulationSim*> mDirtyArticulationSims;
PxArray<ConstraintCore*> mBrokenConstraints;
PxCoalescedHashSet<ConstraintSim*> mActiveBreakableConstraints;
// pools for joint buffers
// Fixed joint is 92 bytes, D6 is 364 bytes right now. So these three pools cover all the internal cases
typedef Block<PxU8, 128> MemBlock128;
typedef Block<PxU8, 256> MemBlock256;
typedef Block<PxU8, 384> MemBlock384;
PxPool2<MemBlock128, 8192> mMemBlock128Pool;
PxPool2<MemBlock256, 8192> mMemBlock256Pool;
PxPool2<MemBlock384, 8192> mMemBlock384Pool;
// broad phase data:
NPhaseCore* mNPhaseCore;
// Collision filtering
void* mFilterShaderData;
PxU32 mFilterShaderDataSize;
PxU32 mFilterShaderDataCapacity;
PxSimulationFilterShader mFilterShader;
PxSimulationFilterCallback* mFilterCallback;
const PxPairFilteringMode::Enum mKineKineFilteringMode;
const PxPairFilteringMode::Enum mStaticKineFilteringMode;
PxCoalescedHashSet<BodyCore*> mSleepBodies;
PxCoalescedHashSet<BodyCore*> mWokeBodies;
bool mWokeBodyListValid;
bool mSleepBodyListValid;
const bool mEnableStabilization;
PxArray<PxActor*> mActiveActors;
PxArray<PxActor*> mFrozenActors;
PxArray<const PxRigidBody*> mClientPosePreviewBodies; // buffer for bodies that requested early report of the integrated pose (eENABLE_POSE_INTEGRATION_PREVIEW).
// This buffer gets exposed to users. Is officially accessible from PxSimulationEventCallback::onAdvance()
// until the next simulate()/advance().
PxArray<PxTransform> mClientPosePreviewBuffer; // buffer of newly integrated poses for the bodies that requested a preview. This buffer gets exposed
// to users.
PxSimulationEventCallback* mSimulationEventCallback;
SimStats* mStats;
PxU32 mInternalFlags; // PT: combination of ::SceneInternalFlag, looks like only 2 bits are needed
PxSceneFlags mPublicFlags; // Copy of PxSceneDesc::flags, of type PxSceneFlag
// PT: TODO: unify names, "tracker" or "pool"?
ObjectIDTracker* mConstraintIDTracker; // PT: provides Sc::ContraintSim::mLowLevelConstraint::index
ObjectIDTracker* mActorIDTracker; // PT: provides Sc::ActorSim::mId
ObjectIDTracker* mElementIDPool; // PT: provides Sc::ElementSim::mElementID
StaticCore mAnchorCore;
StaticSim* mStaticAnchor;
Cm::PreallocatingPool<ShapeSim>* mShapeSimPool;
Cm::PreallocatingPool<StaticSim>* mStaticSimPool;
Cm::PreallocatingPool<BodySim>* mBodySimPool;
PxPool<ConstraintSim>* mConstraintSimPool;
LLArticulationRCPool* mLLArticulationRCPool;
PxHashMap<PxPair<const ActorSim*, const ActorSim*>, ConstraintCore*> mConstraintMap;
PxPool<ConstraintInteraction>* mConstraintInteractionPool;
PxPool<SimStateData>* mSimStateDataPool;
BatchRemoveState* mBatchRemoveState;
PxArray<SimpleBodyPair> mLostTouchPairs;
PxBitMap mLostTouchPairsDeletedBodyIDs; // Need to know which bodies have been deleted when processing the lost touch pair list.
// Can't use the existing rigid object ID tracker class since this map needs to be cleared at
// another point in time.
PxBitMap mVelocityModifyMap;
PxArray<PxvContactManagerTouchEvent> mTouchFoundEvents;
PxArray<PxvContactManagerTouchEvent> mTouchLostEvents;
PxBitMap mDirtyShapeSimMap;
PxU32 mDominanceBitMatrix[PX_MAX_DOMINANCE_GROUP];
bool mVisualizationParameterChanged;
PxU32 mMaxNbArticulationLinks;
// statics:
PxU32 mNbRigidStatics;
PxU32 mNbRigidDynamics;
PxU32 mNbRigidKinematic;
PxU32 mNbGeometries[PxGeometryType::eGEOMETRY_COUNT];
//IG::Node::eTYPE_COUNT
PxU32 mNumDeactivatingNodes[IG::Node::eTYPE_COUNT];
// task decomposition
void broadPhase(PxBaseTask* continuation);
void broadPhaseFirstPass(PxBaseTask* continuation);
void broadPhaseSecondPass(PxBaseTask* continuation);
void updateBroadPhase(PxBaseTask* continuation);
void preIntegrate(PxBaseTask* continuation);
void postBroadPhase(PxBaseTask* continuation);
void postBroadPhaseContinuation(PxBaseTask* continuation);
void preRigidBodyNarrowPhase(PxBaseTask* continuation);
void postBroadPhaseStage2(PxBaseTask* continuation);
void postBroadPhaseStage3(PxBaseTask* continuation);
void updateBoundsAndShapes(PxBaseTask* continuation);
void rigidBodyNarrowPhase(PxBaseTask* continuation);
void unblockNarrowPhase(PxBaseTask* continuation);
void islandGen(PxBaseTask* continuation);
void processLostSolverPatches(PxBaseTask* continuation);
void processFoundSolverPatches(PxBaseTask* continuation);
void postIslandGen(PxBaseTask* continuation);
void solver(PxBaseTask* continuation);
void updateBodies(PxBaseTask* continuation);
void updateShapes(PxBaseTask* continuation);
void updateSimulationController(PxBaseTask* continuation);
void updateDynamics(PxBaseTask* continuation);
void processLostContacts(PxBaseTask*);
void processLostContacts2(PxBaseTask*);
void processLostContacts3(PxBaseTask*);
void destroyManagers(PxBaseTask*);
void lostTouchReports(PxBaseTask*);
void unregisterInteractions(PxBaseTask*);
void postThirdPassIslandGen(PxBaseTask*);
void postSolver(PxBaseTask* continuation);
void constraintProjection(PxBaseTask* continuation);
void afterIntegration(PxBaseTask* continuation); // performs sleep check, for instance
void postCCDPass(PxBaseTask* continuation);
void ccdBroadPhaseAABB(PxBaseTask* continuation);
void ccdBroadPhase(PxBaseTask* continuation);
void updateCCDMultiPass(PxBaseTask* continuation);
void updateCCDSinglePass(PxBaseTask* continuation);
void updateCCDSinglePassStage2(PxBaseTask* continuation);
void updateCCDSinglePassStage3(PxBaseTask* continuation);
void finalizationPhase(PxBaseTask* continuation);
void postNarrowPhase(PxBaseTask* continuation);
void addShapes(NpShape*const* shapes, PxU32 nbShapes, size_t ptrOffset, RigidSim& sim, PxBounds3* outBounds);
void removeShapes(RigidSim& , PxInlineArray<ShapeSim*, 64>& , PxInlineArray<const ShapeCore*, 64>&, bool wakeOnLostTouch);
private:
void addShapes(NpShape*const* shapes, PxU32 nbShapes, size_t ptrOffset, RigidSim& sim, ShapeSim*& prefetchedShapeSim, PxBounds3* outBounds);
void updateContactDistances(PxBaseTask* continuation);
void updateDirtyShapes(PxBaseTask* continuation);
Cm::DelegateTask<Scene, &Scene::secondPassNarrowPhase> mSecondPassNarrowPhase;
Cm::DelegateFanoutTask<Scene, &Scene::postNarrowPhase> mPostNarrowPhase;
Cm::DelegateFanoutTask<Scene, &Scene::finalizationPhase> mFinalizationPhase;
Cm::DelegateTask<Scene, &Scene::updateCCDMultiPass> mUpdateCCDMultiPass;
//multi-pass ccd stuff
PxArray<Cm::DelegateTask<Scene, &Scene::updateCCDSinglePass> > mUpdateCCDSinglePass;
PxArray<Cm::DelegateTask<Scene, &Scene::updateCCDSinglePassStage2> > mUpdateCCDSinglePass2;
PxArray<Cm::DelegateTask<Scene, &Scene::updateCCDSinglePassStage3> > mUpdateCCDSinglePass3;
PxArray<Cm::DelegateTask<Scene, &Scene::ccdBroadPhaseAABB> > mCCDBroadPhaseAABB;
PxArray<Cm::DelegateTask<Scene, &Scene::ccdBroadPhase> > mCCDBroadPhase;
PxArray<Cm::DelegateTask<Scene, &Scene::postCCDPass> > mPostCCDPass;
Cm::DelegateTask<Scene, &Scene::afterIntegration> mAfterIntegration;
Cm::DelegateTask<Scene, &Scene::postSolver> mPostSolver;
Cm::DelegateTask<Scene, &Scene::solver> mSolver;
Cm::DelegateTask<Scene, &Scene::updateBodies> mUpdateBodies;
Cm::DelegateTask<Scene, &Scene::updateShapes> mUpdateShapes;
Cm::DelegateTask<Scene, &Scene::updateSimulationController> mUpdateSimulationController;
Cm::DelegateTask<Scene, &Scene::updateDynamics> mUpdateDynamics;
Cm::DelegateTask<Scene, &Scene::processLostContacts> mProcessLostContactsTask;
Cm::DelegateTask<Scene, &Scene::processLostContacts2> mProcessLostContactsTask2;
Cm::DelegateTask<Scene, &Scene::processLostContacts3> mProcessLostContactsTask3;
Cm::DelegateTask<Scene, &Scene::destroyManagers> mDestroyManagersTask;
Cm::DelegateTask<Scene, &Scene::lostTouchReports> mLostTouchReportsTask;
Cm::DelegateTask<Scene, &Scene::unregisterInteractions> mUnregisterInteractionsTask;
Cm::DelegateTask<Scene,
&Scene::processNarrowPhaseLostTouchEventsIslands> mProcessNarrowPhaseLostTouchTasks;
Cm::DelegateTask<Scene,
&Scene::processNarrowPhaseLostTouchEvents> mProcessNPLostTouchEvents;
Cm::DelegateTask<Scene, &Scene::postThirdPassIslandGen> mPostThirdPassIslandGenTask;
Cm::DelegateTask<Scene, &Scene::postIslandGen> mPostIslandGen;
Cm::DelegateTask<Scene, &Scene::islandGen> mIslandGen;
Cm::DelegateTask<Scene, &Scene::preRigidBodyNarrowPhase> mPreRigidBodyNarrowPhase;
Cm::DelegateTask<Scene, &Scene::setEdgesConnected> mSetEdgesConnectedTask;
Cm::DelegateTask<Scene, &Scene::processLostSolverPatches> mProcessLostPatchesTask;
Cm::DelegateTask<Scene, &Scene::processFoundSolverPatches> mProcessFoundPatchesTask;
Cm::DelegateFanoutTask<Scene, &Scene::updateBoundsAndShapes> mUpdateBoundAndShapeTask;
Cm::DelegateTask<Scene, &Scene::rigidBodyNarrowPhase> mRigidBodyNarrowPhase;
Cm::DelegateTask<Scene, &Scene::unblockNarrowPhase> mRigidBodyNPhaseUnlock;
Cm::DelegateTask<Scene, &Scene::postBroadPhase> mPostBroadPhase;
Cm::DelegateTask<Scene, &Scene::postBroadPhaseContinuation> mPostBroadPhaseCont;
Cm::DelegateTask<Scene, &Scene::postBroadPhaseStage2> mPostBroadPhase2;
Cm::DelegateFanoutTask<Scene, &Scene::postBroadPhaseStage3> mPostBroadPhase3;
Cm::DelegateTask<Scene, &Scene::preallocateContactManagers> mPreallocateContactManagers;
Cm::DelegateTask<Scene, &Scene::islandInsertion> mIslandInsertion;
Cm::DelegateTask<Scene, &Scene::registerContactManagers> mRegisterContactManagers;
Cm::DelegateTask<Scene, &Scene::registerInteractions> mRegisterInteractions;
Cm::DelegateTask<Scene, &Scene::registerSceneInteractions> mRegisterSceneInteractions;
Cm::DelegateTask<Scene, &Scene::broadPhase> mBroadPhase;
Cm::DelegateTask<Scene, &Scene::advanceStep> mAdvanceStep;
Cm::DelegateTask<Scene, &Scene::collideStep> mCollideStep;
Cm::DelegateTask<Scene, &Scene::broadPhaseFirstPass> mBpFirstPass;
Cm::DelegateTask<Scene, &Scene::broadPhaseSecondPass> mBpSecondPass;
Cm::DelegateTask<Scene, &Scene::updateBroadPhase> mBpUpdate;
Cm::DelegateTask<Scene, &Scene::preIntegrate> mPreIntegrate;
Cm::FlushPool mTaskPool;
PxTaskManager* mTaskManager;
PxCudaContextManager* mCudaContextManager;
bool mContactReportsNeedPostSolverVelocity;
bool mUseGpuDynamics;
bool mUseGpuBp;
bool mCCDBp;
SimulationStage::Enum mSimulationStage;
PxCoalescedHashSet<const BodySim*> mPosePreviewBodies; // list of bodies that requested early report of the integrated pose (eENABLE_POSE_INTEGRATION_PREVIEW).
PxArray<PxsContactManager*> mPreallocatedContactManagers;
PxArray<ShapeInteraction*> mPreallocatedShapeInteractions;
PxArray<ElementInteractionMarker*> mPreallocatedInteractionMarkers;
OverlapFilterTask* mOverlapFilterTaskHead; // PT: tmp data passed from finishBroadPhase to preallocateContactManagers
PxArray<FilterInfo> mFilterInfo; // PT: tmp data passed from finishBroadPhase to preallocateContactManagers
PxBitMap mSpeculativeCCDRigidBodyBitMap;
PxBitMap mSpeculativeCDDArticulationBitMap;
bool mIsCollisionPhaseActive;
// Set to true as long as collision phase is active (used as an indicator that it is OK to read object pose,
// velocity etc. compared to the solver phase where these properties might get written to).
bool mIsDirectGPUAPIInitialized;
public:
// For OmniPVD. To notify NpScene that actor's sleeping state has changed.
typedef void(*SleepingStateChangedCallback)(PxRigidDynamic&, bool);
SleepingStateChangedCallback mOnSleepingStateChanged;
// PT: moved all the GPU-related code & data here in an attempt to clearly separate the CPU/GPU bits
#if PX_SUPPORT_GPU_PHYSX
public:
void gpu_addToActiveList(ActorSim& actorSim, ActorCore* appendedActorCore);
void gpu_removeFromActiveList(ActorSim& actorSim, PxU32 removedActiveIndex);
void gpu_clearSleepWakeBodies();
void gpu_buildActiveActors();
void gpu_buildActiveAndFrozenActors();
void gpu_setSimulationEventCallback(PxSimulationEventCallback* callback);
PxU32 gpu_cleanUpSleepAndWokenBodies();
void gpu_fireOnSleepCallback(PxActor** actors);
void gpu_fireOnWakeCallback(PxActor** actors);
void gpu_updateBounds();
void gpu_releasePools();
void gpu_release();
void addSoftBody(SoftBodyCore&);
void removeSoftBody(SoftBodyCore&);
void addFEMCloth(FEMClothCore&);
void removeFEMCloth(FEMClothCore&);
void addParticleSystem(ParticleSystemCore&);
void removeParticleSystem(ParticleSystemCore&);
void addHairSystem(HairSystemCore&);
void removeHairSystem(HairSystemCore&);
PX_FORCE_INLINE PxU32 getNbSoftBodies() const { return mSoftBodies.size(); }
PX_FORCE_INLINE SoftBodyCore* const* getSoftBodies() { return mSoftBodies.getEntries(); }
PX_FORCE_INLINE PxU32 getNbFEMCloths() const { return mFEMCloths.size(); }
PX_FORCE_INLINE FEMClothCore* const* getFEMCloths() { return mFEMCloths.getEntries(); }
PX_FORCE_INLINE PxU32 getNbParticleSystems() const { return mParticleSystems.size(); }
PX_FORCE_INLINE ParticleSystemCore* const* getParticleSystems() { return mParticleSystems.getEntries(); }
PX_FORCE_INLINE PxU32 getNbHairSystems() const { return mHairSystems.size(); }
PX_FORCE_INLINE HairSystemCore* const* getHairSystems() { return mHairSystems.getEntries(); }
PX_FORCE_INLINE SoftBodyCore*const* getActiveSoftBodiesArray() const { return mActiveSoftBodies.begin(); }
PX_FORCE_INLINE PxU32 getNumActiveSoftBodies() const { return mActiveSoftBodies.size(); }
PX_FORCE_INLINE FEMClothCore*const* getActiveFEMClothsArray() const { return mActiveFEMCloths.begin(); }
PX_FORCE_INLINE PxU32 getNumActiveFEMCloths() const { return mActiveFEMCloths.size(); }
PX_FORCE_INLINE HairSystemCore*const* getActiveHairSystemsArray() const { return mActiveHairSystems.begin(); }
PX_FORCE_INLINE PxU32 getNumActiveHairSystems() const { return mActiveHairSystems.size(); }
// PT: redundant?
// Get the active soft body actors
PX_FORCE_INLINE SoftBodyCore*const* getActiveSoftBodies() const { return mActiveSoftBodies.begin(); }
PX_FORCE_INLINE SoftBodyCore*const* getSleepSoftBodiesArray(PxU32& count) { count = mSleepSoftBodies.size(); return mSleepSoftBodies.getEntries(); }
// PT: redundant?
// Get the active FEM-cloth actors
PX_FORCE_INLINE FEMClothCore*const* getActiveFEMCloths() const { return mActiveFEMCloths.begin(); }
PX_FORCE_INLINE const PxsFEMMaterialManager& getFEMMaterialManager() const { return mFEMMaterialManager; }
PX_FORCE_INLINE PxsFEMMaterialManager& getFEMMaterialManager() { return mFEMMaterialManager; }
PX_FORCE_INLINE const PxsFEMClothMaterialManager& getFEMClothMaterialManager() const { return mFEMClothMaterialManager; }
PX_FORCE_INLINE PxsFEMClothMaterialManager& getFEMClothMaterialManager() { return mFEMClothMaterialManager; }
PX_FORCE_INLINE const PxsPBDMaterialManager& getPBDMaterialManager() const { return mPBDMaterialManager; }
PX_FORCE_INLINE PxsPBDMaterialManager& getPBDMaterialManager() { return mPBDMaterialManager; }
PX_FORCE_INLINE const PxsFLIPMaterialManager& getFLIPMaterialManager() const { return mFLIPMaterialManager; }
PX_FORCE_INLINE PxsFLIPMaterialManager& getFLIPMaterialManager() { return mFLIPMaterialManager; }
PX_FORCE_INLINE const PxsMPMMaterialManager& getMPMMaterialManager() const { return mMPMMaterialManager; }
PX_FORCE_INLINE PxsMPMMaterialManager& getMPMMaterialManager() { return mMPMMaterialManager; }
Dy::SoftBody* createLLSoftBody(SoftBodySim* sim);
void destroyLLSoftBody(Dy::SoftBody& softBody);
Dy::FEMCloth* createLLFEMCloth(FEMClothSim* sim);
void destroyLLFEMCloth(Dy::FEMCloth& femCloth);
Dy::ParticleSystem* createLLParticleSystem(ParticleSystemSim* sim);
void destroyLLParticleSystem(Dy::ParticleSystem& softBody);
Dy::HairSystem* createLLHairSystem(HairSystemSim* sim);
void destroyLLHairSystem(Dy::HairSystem& hairSystem);
// PT: TODO: why inline these ones?
PX_INLINE void cleanUpSleepSoftBodies();
PX_INLINE void cleanUpWokenSoftBodies();
PX_INLINE void cleanUpSleepOrWokenSoftBodies(PxCoalescedHashSet<SoftBodyCore*>& bodyList, PxU32 removeFlag, bool& validMarker);
PX_INLINE void cleanUpSleepHairSystems();
PX_INLINE void cleanUpWokenHairSystems();
PX_INLINE void cleanUpSleepOrWokenHairSystems(PxCoalescedHashSet<HairSystemCore*>& bodyList, PxU32 removeFlag, bool& validMarker);
void addSoftBodySimControl(SoftBodyCore& core);
void removeSoftBodySimControl(SoftBodyCore& core);
void addFEMClothSimControl(FEMClothCore& core);
void removeFEMClothSimControl(FEMClothCore& core);
void addParticleSystemSimControl(ParticleSystemCore& core);
void removeParticleSystemSimControl(ParticleSystemCore& core);
void addHairSystemSimControl(HairSystemCore& core);
void removeHairSystemSimControl(HairSystemCore& core);
void addParticleFilter(Sc::ParticleSystemCore* core, SoftBodySim& sim, PxU32 particleId, PxU32 userBufferId, PxU32 tetId);
void removeParticleFilter(Sc::ParticleSystemCore* core, SoftBodySim& sim, PxU32 particleId, PxU32 userBufferId, PxU32 tetId);
PxU32 addParticleAttachment(Sc::ParticleSystemCore* core, SoftBodySim& sim, PxU32 particleId, PxU32 userBufferId, PxU32 tetId, const PxVec4& barycentric);
void removeParticleAttachment(Sc::ParticleSystemCore* core, SoftBodySim& sim, PxU32 handle);
void addRigidFilter(BodyCore* core, SoftBodySim& sim, PxU32 vertId);
void removeRigidFilter(BodyCore* core, SoftBodySim& sim, PxU32 vertId);
PxU32 addRigidAttachment(BodyCore* core, SoftBodySim& sim, PxU32 vertId, const PxVec3& actorSpacePose, PxConeLimitedConstraint* constraint);
void removeRigidAttachment(BodyCore* core, SoftBodySim& sim, PxU32 handle);
void addTetRigidFilter(BodyCore* core, SoftBodySim& sim, PxU32 tetIdx);
void removeTetRigidFilter(BodyCore* core, SoftBodySim& sim, PxU32 tetIdx);
PxU32 addTetRigidAttachment(BodyCore* core, SoftBodySim& sim, PxU32 tetIdx, const PxVec4& barycentric, const PxVec3& actorSpacePose, PxConeLimitedConstraint* constraint);
void addSoftBodyFilter(SoftBodyCore& core, PxU32 tetIdx0, SoftBodySim& sim, PxU32 tetIdx1);
void removeSoftBodyFilter(SoftBodyCore& core, PxU32 tetIdx0, SoftBodySim& sim, PxU32 tetIdx1);
void addSoftBodyFilters(SoftBodyCore& core, SoftBodySim& sim, PxU32* tetIndices0, PxU32* tetIndices1, PxU32 tetIndicesSize);
void removeSoftBodyFilters(SoftBodyCore& core, SoftBodySim& sim, PxU32* tetIndices0, PxU32* tetIndices1, PxU32 tetIndicesSize);
PxU32 addSoftBodyAttachment(SoftBodyCore& core, PxU32 tetIdx0, const PxVec4& triBarycentric0, SoftBodySim& sim, PxU32 tetIdx1, const PxVec4& tetBarycentric1, PxConeLimitedConstraint* constraint, PxReal constraintOffset);
void removeSoftBodyAttachment(SoftBodyCore& core, SoftBodySim& sim, PxU32 handle);
void addClothFilter(Sc::FEMClothCore& core, PxU32 triIdx, Sc::SoftBodySim& sim, PxU32 tetIdx);
void removeClothFilter(Sc::FEMClothCore& core, PxU32 triIdx, Sc::SoftBodySim& sim, PxU32 tetIdx);
void addVertClothFilter(Sc::FEMClothCore& core, PxU32 vertIdx, Sc::SoftBodySim& sim, PxU32 tetIdx);
void removeVertClothFilter(Sc::FEMClothCore& core, PxU32 vertIdx, Sc::SoftBodySim& sim, PxU32 tetIdx);
PxU32 addClothAttachment(FEMClothCore& core, PxU32 triIdx, const PxVec4& triBarycentric, SoftBodySim& sim, PxU32 tetIdx, const PxVec4& tetBarycentric, PxConeLimitedConstraint* constraint, PxReal constraintOffset);
void removeClothAttachment(FEMClothCore& core, SoftBodySim& sim, PxU32 handle);
void addRigidFilter(BodyCore* core, FEMClothSim& sim, PxU32 vertId);
void removeRigidFilter(BodyCore* core, FEMClothSim& sim, PxU32 vertId);
PxU32 addRigidAttachment(BodyCore* core, FEMClothSim& sim, PxU32 vertId, const PxVec3& actorSpacePose, PxConeLimitedConstraint* constraint);
void removeRigidAttachment(BodyCore* core, FEMClothSim& sim, PxU32 handle);
void addClothFilter(FEMClothCore& core0, PxU32 triIdx0, Sc::FEMClothSim& sim1, PxU32 triIdx1);
void removeClothFilter(FEMClothCore& core, PxU32 triIdx0, FEMClothSim& sim1, PxU32 triIdx1);
PxU32 addTriClothAttachment(FEMClothCore& core0, PxU32 triIdx0, const PxVec4& barycentric0, Sc::FEMClothSim& sim1, PxU32 triIdx1, const PxVec4& barycentric1);
void removeTriClothAttachment(FEMClothCore& core, FEMClothSim& sim1, PxU32 handle);
void addTriRigidFilter(BodyCore* core, FEMClothSim& sim, PxU32 triIdx);
void removeTriRigidFilter(BodyCore* core, FEMClothSim& sim, PxU32 triIdx);
PxU32 addTriRigidAttachment(BodyCore* core, FEMClothSim& sim, PxU32 triIdx, const PxVec4& barycentric, const PxVec3& actorSpacePose, PxConeLimitedConstraint* constraint);
void removeTriRigidAttachment(BodyCore* core, FEMClothSim& sim, PxU32 handle);
void addRigidAttachment(BodyCore* core, ParticleSystemSim& sim);
void removeRigidAttachment(BodyCore* core, ParticleSystemSim& sim);
void addAttachment(const BodySim& bodySim, const HairSystemSim& hairSim);
void addAttachment(const SoftBodySim& sbSim, const HairSystemSim& hairSim);
void removeAttachment(const BodySim& bodySim, const HairSystemSim& hairSim);
void removeAttachment(const SoftBodySim& sbSim, const HairSystemSim& hairSim);
PxActor** getActiveSoftBodyActors(PxU32& nbActorsOut);
void setActiveSoftBodyActors(PxActor** actors, PxU32 nbActors);
//PxActor** getActiveFEMClothActors(PxU32& nbActorsOut);
//void setActiveFEMClothActors(PxActor** actors, PxU32 nbActors);
PX_ALIGN(16, PxsFEMMaterialManager mFEMMaterialManager);
PX_ALIGN(16, PxsFEMClothMaterialManager mFEMClothMaterialManager);
PX_ALIGN(16, PxsPBDMaterialManager mPBDMaterialManager);
PX_ALIGN(16, PxsFLIPMaterialManager mFLIPMaterialManager);
PX_ALIGN(16, PxsMPMMaterialManager mMPMMaterialManager);
PxArray<SoftBodyCore*> mActiveSoftBodies;
PxArray<FEMClothCore*> mActiveFEMCloths;
PxArray<ParticleSystemCore*> mActiveParticleSystems;
PxArray<HairSystemCore*> mActiveHairSystems;
PxCoalescedHashSet<SoftBodyCore*> mSoftBodies;
PxCoalescedHashSet<FEMClothCore*> mFEMCloths;
PxCoalescedHashSet<ParticleSystemCore*> mParticleSystems;
PxCoalescedHashSet<HairSystemCore*> mHairSystems;
PxCoalescedHashSet<SoftBodyCore*> mSleepSoftBodies;
PxCoalescedHashSet<SoftBodyCore*> mWokeSoftBodies;
PxCoalescedHashSet<HairSystemCore*> mSleepHairSystems;
PxCoalescedHashSet<HairSystemCore*> mWokeHairSystems;
PxArray<PxActor*> mActiveSoftBodyActors;
PxArray<PxActor*> mActiveFEMClothActors;
PxArray<PxActor*> mActiveHairSystemActors;
LLSoftBodyPool* mLLSoftBodyPool;
LLFEMClothPool* mLLFEMClothPool;
LLParticleSystemPool* mLLParticleSystemPool;
LLHairSystemPool* mLLHairSystemPool;
PxHashMap<PxPair<PxU32, PxU32>, ParticleOrSoftBodyRigidInteraction> mParticleOrSoftBodyRigidInteractionMap;
bool mWokeSoftBodyListValid;
bool mSleepSoftBodyListValid;
bool mWokeHairSystemListValid;
bool mSleepHairSystemListValid;
#endif
};
bool activateInteraction(Interaction* interaction, void* data);
void activateInteractions(Sc::ActorSim& actorSim);
void deactivateInteractions(Sc::ActorSim& actorSim);
} // namespace Sc
}
#endif
| 59,428 | C | 48.441764 | 232 | 0.728024 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.