Init

physx/source/geomutils/include/GuBox.h

@@ -0,0 +1,246 @@
+//
+// 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-2021 NVIDIA Corporation. All rights reserved.
+// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
+// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
+
+#ifndef GU_BOX_H
+#define GU_BOX_H
+
+/** \addtogroup geomutils
+@{
+*/
+
+#include "foundation/PxTransform.h"
+#include "foundation/PxMat33.h"
+#include "common/PxPhysXCommonConfig.h"
+#include "CmPhysXCommon.h"
+#include "CmScaling.h"
+
+namespace physx
+{
+namespace Gu
+{
+	class Capsule;
+
+	PX_PHYSX_COMMON_API void computeOBBPoints(PxVec3* PX_RESTRICT pts, const PxVec3& center, const PxVec3& extents, const PxVec3& base0, const PxVec3& base1, const PxVec3& base2);
+
+
+	/**
+	\brief Represents an oriented bounding box. 
+
+	As a center point, extents(radii) and a rotation. i.e. the center of the box is at the center point, 
+	the box is rotated around this point with the rotation and it is 2*extents in width, height and depth.
+	*/
+
+	/**
+	Box geometry
+
+	The rot member describes the world space orientation of the box.
+	The center member gives the world space position of the box.
+	The extents give the local space coordinates of the box corner in the positive octant.
+	Dimensions of the box are: 2*extent.
+	Transformation to world space is: worldPoint = rot * localPoint + center
+	Transformation to local space is: localPoint = T(rot) * (worldPoint - center)
+	Where T(M) denotes the transpose of M.
+	*/
+#if PX_VC 
+    #pragma warning(push)
+	#pragma warning( disable : 4251 ) // class needs to have dll-interface to be used by clients of class
+#endif
+	class PX_PHYSX_COMMON_API Box
+	{
+	public:
+		/**
+		\brief Constructor
+		*/
+		PX_FORCE_INLINE Box()
+		{
+		}
+
+		/**
+		\brief Constructor
+
+		\param origin Center of the OBB
+		\param extent Extents/radii of the obb.
+		\param base rotation to apply to the obb.
+		*/
+		//! Construct from center, extent and rotation
+		PX_FORCE_INLINE Box(const PxVec3& origin, const PxVec3& extent, const PxMat33& base) : rot(base), center(origin), extents(extent)
+		{}
+
+		//! Copy constructor
+		PX_FORCE_INLINE Box(const Box& other) : rot(other.rot), center(other.center), extents(other.extents)
+		{}
+
+		/**
+		\brief Destructor
+		*/
+		PX_FORCE_INLINE ~Box()
+		{
+		}
+
+		//! Assignment operator
+		PX_FORCE_INLINE const Box& operator=(const Box& other)
+		{
+			rot		= other.rot;
+			center	= other.center;
+			extents	= other.extents;
+			return *this;
+		}
+
+		/**
+		\brief Setups an empty box.
+		*/
+		PX_INLINE void setEmpty()
+		{
+			center = PxVec3(0);
+			extents = PxVec3(-PX_MAX_REAL, -PX_MAX_REAL, -PX_MAX_REAL);
+			rot = PxMat33(PxIdentity);
+		}
+
+		/**
+		\brief Checks the box is valid.
+
+		\return	true if the box is valid
+		*/
+		PX_INLINE bool isValid() const
+		{
+			// Consistency condition for (Center, Extents) boxes: Extents >= 0.0f
+			if(extents.x < 0.0f)	return false;
+			if(extents.y < 0.0f)	return false;
+			if(extents.z < 0.0f)	return false;
+			return true;
+		}
+
+/////////////
+		PX_FORCE_INLINE	void	setAxes(const PxVec3& axis0, const PxVec3& axis1, const PxVec3& axis2)
+		{
+			rot.column0 = axis0;
+			rot.column1 = axis1;
+			rot.column2 = axis2;
+		}
+
+		PX_FORCE_INLINE	PxVec3	rotate(const PxVec3& src)	const
+		{
+			return rot * src;
+		}
+
+		PX_FORCE_INLINE	PxVec3	rotateInv(const PxVec3& src)	const
+		{
+			return rot.transformTranspose(src);
+		}
+
+		PX_FORCE_INLINE	PxVec3	transform(const PxVec3& src)	const
+		{
+			return rot * src + center;
+		}
+
+		PX_FORCE_INLINE	PxTransform getTransform()	const
+		{
+			return PxTransform(center, PxQuat(rot));
+		}
+
+		PX_INLINE PxVec3 computeAABBExtent() const
+		{
+			const PxReal a00 = PxAbs(rot[0][0]);
+			const PxReal a01 = PxAbs(rot[0][1]);
+			const PxReal a02 = PxAbs(rot[0][2]);
+
+			const PxReal a10 = PxAbs(rot[1][0]);
+			const PxReal a11 = PxAbs(rot[1][1]);
+			const PxReal a12 = PxAbs(rot[1][2]);
+
+			const PxReal a20 = PxAbs(rot[2][0]);
+			const PxReal a21 = PxAbs(rot[2][1]);
+			const PxReal a22 = PxAbs(rot[2][2]);
+
+			const PxReal ex = extents.x;
+			const PxReal ey = extents.y;
+			const PxReal ez = extents.z;
+
+			return PxVec3(	a00 * ex + a10 * ey + a20 * ez,
+							a01 * ex + a11 * ey + a21 * ez,
+							a02 * ex + a12 * ey + a22 * ez);
+		}
+
+		/**
+		Computes the obb points.
+		\param		pts	[out] 8 box points
+		*/
+		PX_FORCE_INLINE void computeBoxPoints(PxVec3* PX_RESTRICT pts) const
+		{
+			Gu::computeOBBPoints(pts, center, extents, rot.column0, rot.column1, rot.column2);
+		}
+
+		void create(const Gu::Capsule& capsule);
+
+		PxMat33	rot;
+		PxVec3	center;
+		PxVec3	extents;
+	};
+	PX_COMPILE_TIME_ASSERT(sizeof(Gu::Box) == 60);
+
+	//! A padded version of Gu::Box, to safely load its data using SIMD
+	class BoxPadded : public Box
+	{
+	public:
+		PX_FORCE_INLINE BoxPadded()		{}
+		PX_FORCE_INLINE ~BoxPadded()	{}
+		PxU32	padding;
+	};
+	PX_COMPILE_TIME_ASSERT(sizeof(Gu::BoxPadded) == 64);
+
+	//! Transforms a shape space AABB to a vertex space AABB (conservative).
+	PX_FORCE_INLINE void computeVertexSpaceAABB(Gu::Box& vertexSpaceOBB, const PxBounds3& worldBounds, const PxTransform& world2Shape, const Cm::FastVertex2ShapeScaling& scaling, bool idtScaleMesh)
+	{
+		PX_ASSERT(!worldBounds.isEmpty());
+		const PxBounds3 boundsInMesh = PxBounds3::transformFast(world2Shape, worldBounds);	// transform bounds from world to shape (excluding mesh scale)
+
+		vertexSpaceOBB.rot = PxMat33(PxIdentity);
+		if(idtScaleMesh)
+		{
+			vertexSpaceOBB.center = boundsInMesh.getCenter();
+			vertexSpaceOBB.extents = boundsInMesh.getExtents();
+		}
+		else
+		{
+			const PxBounds3 bounds = PxBounds3::basisExtent(scaling.getShape2VertexSkew() * boundsInMesh.getCenter(), scaling.getShape2VertexSkew(), boundsInMesh.getExtents());
+			vertexSpaceOBB.center = bounds.getCenter();
+			vertexSpaceOBB.extents = bounds.getExtents();
+		}
+	}
+
+#if PX_VC 
+     #pragma warning(pop) 
+#endif
+
+}
+
+}
+
+/** @} */
+#endif

physx/source/geomutils/include/GuDistanceSegmentBox.h

@@ -0,0 +1,57 @@
+//
+// 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-2021 NVIDIA Corporation. All rights reserved.
+// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
+// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
+
+#ifndef GU_DISTANCE_SEGMENT_BOX_H
+#define GU_DISTANCE_SEGMENT_BOX_H
+
+#include "foundation/PxMat33.h"
+#include "GuSegment.h"
+#include "GuBox.h"
+
+namespace physx
+{
+namespace Gu
+{
+
+	//! Compute the smallest distance from the (finite) line segment to the box.
+	PX_PHYSX_COMMON_API PxReal distanceSegmentBoxSquared(	const PxVec3& segmentPoint0, const PxVec3& segmentPoint1,
+															const PxVec3& boxOrigin, const PxVec3& boxExtent, const PxMat33& boxBase,
+															PxReal* segmentParam = NULL,
+															PxVec3* boxParam = NULL);
+
+	PX_FORCE_INLINE PxReal distanceSegmentBoxSquared(const Gu::Segment& segment, const Gu::Box& box, PxReal* t = NULL, PxVec3* p = NULL)
+	{
+		return distanceSegmentBoxSquared(segment.p0, segment.p1, box.center, box.extents, box.rot, t, p);
+	}
+
+} // namespace Gu
+
+}
+
+#endif

physx/source/geomutils/include/GuDistanceSegmentSegment.h

@@ -0,0 +1,65 @@
+//
+// 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-2021 NVIDIA Corporation. All rights reserved.
+// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
+// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
+
+#ifndef GU_DISTANCE_SEGMENT_SEGMENT_H
+#define GU_DISTANCE_SEGMENT_SEGMENT_H
+
+#include "common/PxPhysXCommonConfig.h"
+#include "GuSegment.h"
+
+namespace physx
+{
+namespace Gu
+{
+	// This version fixes accuracy issues (e.g.  TTP 4617), but needs to do 2 square roots in order
+	// to find the normalized direction and length of the segments, and then
+	// a division in order to renormalize the output
+
+	PX_PHYSX_COMMON_API	PxReal	distanceSegmentSegmentSquared(	const PxVec3& origin0, const PxVec3& dir0, PxReal extent0,
+																const PxVec3& origin1, const PxVec3& dir1, PxReal extent1,
+																PxReal* s=NULL, PxReal* t=NULL);
+
+	PX_PHYSX_COMMON_API PxReal	distanceSegmentSegmentSquared(	const PxVec3& origin0, const PxVec3& extent0,
+																const PxVec3& origin1, const PxVec3& extent1,
+																PxReal* s=NULL, PxReal* t=NULL);
+
+	PX_FORCE_INLINE	PxReal	distanceSegmentSegmentSquared(	const Gu::Segment& segment0,
+															const Gu::Segment& segment1,
+															PxReal* s=NULL, PxReal* t=NULL)
+	{
+		return distanceSegmentSegmentSquared(	segment0.p0, segment0.computeDirection(),
+												segment1.p0, segment1.computeDirection(),
+												s, t);
+	}
+
+} // namespace Gu
+
+}
+
+#endif

physx/source/geomutils/include/GuIntersectionBoxBox.h

@@ -0,0 +1,54 @@
+//
+// 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-2021 NVIDIA Corporation. All rights reserved.
+// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
+// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
+
+#ifndef GU_INTERSECTION_BOX_BOX_H
+#define GU_INTERSECTION_BOX_BOX_H
+
+#include "foundation/PxMat33.h"
+#include "foundation/PxBounds3.h"
+#include "GuBox.h"
+
+namespace physx
+{
+namespace Gu
+{
+	PX_PHYSX_COMMON_API bool intersectOBBOBB(const PxVec3& e0, const PxVec3& c0, const PxMat33& r0, const PxVec3& e1, const PxVec3& c1, const PxMat33& r1, bool full_test);
+
+	PX_FORCE_INLINE bool intersectOBBAABB(const Gu::Box& obb, const PxBounds3& aabb)
+	{
+		PxVec3 center = aabb.getCenter();
+		PxVec3 extents = aabb.getExtents();
+		return intersectOBBOBB(obb.extents, obb.center, obb.rot, extents, center, PxMat33(PxIdentity), true);
+	}
+
+} // namespace Gu
+
+}
+
+#endif

physx/source/geomutils/include/GuIntersectionTriangleBox.h

@@ -0,0 +1,91 @@
+//
+// 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-2021 NVIDIA Corporation. All rights reserved.
+// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
+// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
+
+#ifndef GU_INTERSECTION_TRIANGLE_BOX_H
+#define GU_INTERSECTION_TRIANGLE_BOX_H
+
+#include "foundation/PxMat33.h"
+#include "common/PxPhysXCommonConfig.h"
+#include "CmPhysXCommon.h"
+
+namespace physx
+{
+namespace Gu
+{
+	class Box;
+	class BoxPadded;
+
+	/**
+	Tests if a triangle overlaps a box (AABB). This is the reference non-SIMD code.
+
+	\param center	[in] the box center
+	\param extents	[in] the box extents
+	\param p0		[in] triangle's first point
+	\param p1		[in] triangle's second point
+	\param p2		[in] triangle's third point
+	\return	true if triangle overlaps box
+	*/
+	PX_PHYSX_COMMON_API Ps::IntBool intersectTriangleBox_ReferenceCode(const PxVec3& center, const PxVec3& extents, const PxVec3& p0, const PxVec3& p1, const PxVec3& p2);
+
+	/**
+	Tests if a triangle overlaps a box (AABB). This is the optimized SIMD code.
+
+	WARNING: the function has various SIMD requirements, left to the calling code:
+	- function will load 4 bytes after 'center'. Make sure it's safe to load from there.
+	- function will load 4 bytes after 'extents'. Make sure it's safe to load from there.
+	- function will load 4 bytes after 'p0'. Make sure it's safe to load from there.
+	- function will load 4 bytes after 'p1'. Make sure it's safe to load from there.
+	- function will load 4 bytes after 'p2'. Make sure it's safe to load from there.
+	If you can't guarantee these requirements, please use the non-SIMD reference code instead.
+
+	\param center	[in] the box center. 
+	\param extents	[in] the box extents
+	\param p0		[in] triangle's first point
+	\param p1		[in] triangle's second point
+	\param p2		[in] triangle's third point
+	\return	true if triangle overlaps box
+	*/
+	PX_PHYSX_COMMON_API Ps::IntBool intersectTriangleBox_Unsafe(const PxVec3& center, const PxVec3& extents, const PxVec3& p0, const PxVec3& p1, const PxVec3& p2);
+
+	/**
+	Tests if a triangle overlaps a box (OBB).
+
+	There are currently no SIMD-related requirements for p0, p1, p2.
+
+	\param box		[in] the box
+	\param p0		[in] triangle's first point
+	\param p1		[in] triangle's second point
+	\param p2		[in] triangle's third point
+	\return	true if triangle overlaps box
+	*/
+	PX_PHYSX_COMMON_API Ps::IntBool intersectTriangleBox(const BoxPadded& box, const PxVec3& p0, const PxVec3& p1, const PxVec3& p2);
+} // namespace Gu
+}
+
+#endif

physx/source/geomutils/include/GuIntersectionTriangleBoxRef.h

@@ -0,0 +1,251 @@
+//
+// 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-2021 NVIDIA Corporation. All rights reserved.
+// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
+// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
+
+#ifndef GU_INTERSECTION_TRIANGLE_BOX_REF_H
+#define GU_INTERSECTION_TRIANGLE_BOX_REF_H
+
+#include "CmPhysXCommon.h"
+#include "foundation/PxVec3.h"
+
+
+/********************************************************/
+/* AABB-triangle overlap test code                      */
+/* by Tomas Akenine-M?r									*/
+/* Function: int triBoxOverlap(float boxcenter[3],      */
+/*          float boxhalfsize[3],float triverts[3][3]); */
+/* History:                                             */
+/*   2001-03-05: released the code in its first version */
+/*   2001-06-18: changed the order of the tests, faster */
+/*                                                      */
+/* Acknowledgement: Many thanks to Pierre Terdiman for  */
+/* suggestions and discussions on how to optimize code. */
+/* Thanks to David Hunt for finding a ">="-bug!         */
+/********************************************************/
+
+
+namespace physx
+{
+
+#define CROSS(dest,v1,v2)		\
+	dest.x=v1.y*v2.z-v1.z*v2.y;	\
+	dest.y=v1.z*v2.x-v1.x*v2.z;	\
+	dest.z=v1.x*v2.y-v1.y*v2.x; 
+
+#define DOT(v1,v2) (v1.x*v2.x+v1.y*v2.y+v1.z*v2.z)
+
+#define FINDMINMAX(x0, x1, x2, minimum, maximum)			\
+	minimum = physx::intrinsics::selectMin(x0, x1);			\
+	maximum = physx::intrinsics::selectMax(x0, x1);			\
+	minimum = physx::intrinsics::selectMin(minimum, x2);	\
+	maximum = physx::intrinsics::selectMax(maximum, x2);
+
+	static PX_CUDA_CALLABLE PX_FORCE_INLINE Ps::IntBool planeBoxOverlap(const PxVec3& normal, PxReal d, const PxVec3& maxbox)
+	{
+		PxVec3 vmin, vmax;
+
+		if (normal.x>0.0f)
+		{
+			vmin.x = -maxbox.x;
+			vmax.x = maxbox.x;
+		}
+		else
+		{
+			vmin.x = maxbox.x;
+			vmax.x = -maxbox.x;
+		}
+
+		if (normal.y>0.0f)
+		{
+			vmin.y = -maxbox.y;
+			vmax.y = maxbox.y;
+		}
+		else
+		{
+			vmin.y = maxbox.y;
+			vmax.y = -maxbox.y;
+		}
+
+		if (normal.z>0.0f)
+		{
+			vmin.z = -maxbox.z;
+			vmax.z = maxbox.z;
+		}
+		else
+		{
+			vmin.z = maxbox.z;
+			vmax.z = -maxbox.z;
+		}
+
+		if (normal.dot(vmin) + d >  0.0f) return Ps::IntFalse;
+		if (normal.dot(vmax) + d >= 0.0f) return Ps::IntTrue;
+		return Ps::IntFalse;
+	}
+
+	/*======================== X-tests ========================*/
+#define AXISTEST_X01(a, b, fa, fb)							\
+	p0 = a*v0.y - b*v0.z;									\
+	p2 = a*v2.y - b*v2.z;									\
+	minimum = physx::intrinsics::selectMin(p0, p2);			\
+	maximum = physx::intrinsics::selectMax(p0, p2);			\
+	rad = fa * extents.y + fb * extents.z;					\
+	if(minimum>rad || maximum<-rad) return Ps::IntFalse;
+
+#define AXISTEST_X2(a, b, fa, fb)							\
+	p0 = a*v0.y - b*v0.z;									\
+	p1 = a*v1.y - b*v1.z;									\
+	minimum = physx::intrinsics::selectMin(p0, p1);			\
+	maximum = physx::intrinsics::selectMax(p0, p1);			\
+	rad = fa * extents.y + fb * extents.z;					\
+	if(minimum>rad || maximum<-rad) return Ps::IntFalse;
+
+	/*======================== Y-tests ========================*/
+#define AXISTEST_Y02(a, b, fa, fb)							\
+	p0 = -a*v0.x + b*v0.z;									\
+	p2 = -a*v2.x + b*v2.z;									\
+	minimum = physx::intrinsics::selectMin(p0, p2);			\
+	maximum = physx::intrinsics::selectMax(p0, p2);			\
+	rad = fa * extents.x + fb * extents.z;					\
+	if(minimum>rad || maximum<-rad) return Ps::IntFalse;
+
+#define AXISTEST_Y1(a, b, fa, fb)							\
+	p0 = -a*v0.x + b*v0.z;									\
+	p1 = -a*v1.x + b*v1.z;									\
+	minimum = physx::intrinsics::selectMin(p0, p1);			\
+	maximum = physx::intrinsics::selectMax(p0, p1);			\
+	rad = fa * extents.x + fb * extents.z;					\
+	if(minimum>rad || maximum<-rad) return Ps::IntFalse;
+
+	/*======================== Z-tests ========================*/
+#define AXISTEST_Z12(a, b, fa, fb)							\
+	p1 = a*v1.x - b*v1.y;									\
+	p2 = a*v2.x - b*v2.y;									\
+	minimum = physx::intrinsics::selectMin(p1, p2);			\
+	maximum = physx::intrinsics::selectMax(p1, p2);			\
+	rad = fa * extents.x + fb * extents.y;					\
+	if(minimum>rad || maximum<-rad) return Ps::IntFalse;
+
+#define AXISTEST_Z0(a, b, fa, fb)							\
+	p0 = a*v0.x - b*v0.y;									\
+	p1 = a*v1.x - b*v1.y;									\
+	minimum = physx::intrinsics::selectMin(p0, p1);			\
+	maximum = physx::intrinsics::selectMax(p0, p1);			\
+	rad = fa * extents.x + fb * extents.y;					\
+	if(minimum>rad || maximum<-rad) return Ps::IntFalse;
+
+	namespace Gu
+	{
+
+		static PX_CUDA_CALLABLE PX_FORCE_INLINE Ps::IntBool intersectTriangleBox_RefImpl(const PxVec3& boxcenter, const PxVec3& extents, const PxVec3& tp0, const PxVec3& tp1, const PxVec3& tp2)
+		{
+			/*    use separating axis theorem to test overlap between triangle and box */
+			/*    need to test for overlap in these directions: */
+			/*    1) the {x,y,z}-directions (actually, since we use the AABB of the triangle */
+			/*       we do not even need to test these) */
+			/*    2) normal of the triangle */
+			/*    3) crossproduct(edge from tri, {x,y,z}-directin) */
+			/*       this gives 3x3=9 more tests */
+
+			// This is the fastest branch on Sun - move everything so that the boxcenter is in (0,0,0)
+			const PxVec3 v0 = tp0 - boxcenter;
+			const PxVec3 v1 = tp1 - boxcenter;
+			const PxVec3 v2 = tp2 - boxcenter;
+
+			// compute triangle edges
+			const PxVec3 e0 = v1 - v0;	// tri edge 0
+			const PxVec3 e1 = v2 - v1;	// tri edge 1
+			const PxVec3 e2 = v0 - v2;	// tri edge 2
+
+			float minimum, maximum, rad, p0, p1, p2;
+
+			// Bullet 3: test the 9 tests first (this was faster)
+			float fex = PxAbs(e0.x);
+			float fey = PxAbs(e0.y);
+			float fez = PxAbs(e0.z);
+			AXISTEST_X01(e0.z, e0.y, fez, fey);
+			AXISTEST_Y02(e0.z, e0.x, fez, fex);
+			AXISTEST_Z12(e0.y, e0.x, fey, fex);
+
+			fex = PxAbs(e1.x);
+			fey = PxAbs(e1.y);
+			fez = PxAbs(e1.z);
+			AXISTEST_X01(e1.z, e1.y, fez, fey);
+			AXISTEST_Y02(e1.z, e1.x, fez, fex);
+			AXISTEST_Z0(e1.y, e1.x, fey, fex);
+
+			fex = PxAbs(e2.x);
+			fey = PxAbs(e2.y);
+			fez = PxAbs(e2.z);
+			AXISTEST_X2(e2.z, e2.y, fez, fey);
+			AXISTEST_Y1(e2.z, e2.x, fez, fex);
+			AXISTEST_Z12(e2.y, e2.x, fey, fex);
+
+			// Bullet 1:
+			//  first test overlap in the {x,y,z}-directions
+			//  find minimum, maximum of the triangle each direction, and test for overlap in
+			//  that direction -- this is equivalent to testing a minimal AABB around
+			//  the triangle against the AABB
+
+			// test in X-direction
+			FINDMINMAX(v0.x, v1.x, v2.x, minimum, maximum);
+			if (minimum>extents.x || maximum<-extents.x) return Ps::IntFalse;
+
+			// test in Y-direction
+			FINDMINMAX(v0.y, v1.y, v2.y, minimum, maximum);
+			if (minimum>extents.y || maximum<-extents.y) return Ps::IntFalse;
+
+			// test in Z-direction
+			FINDMINMAX(v0.z, v1.z, v2.z, minimum, maximum);
+			if (minimum>extents.z || maximum<-extents.z) return Ps::IntFalse;
+
+			// Bullet 2:
+			//  test if the box intersects the plane of the triangle
+			//  compute plane equation of triangle: normal*x+d=0
+			PxVec3 normal;
+			CROSS(normal, e0, e1);
+			const float d = -DOT(normal, v0);	// plane eq: normal.x+d=0
+			if (!planeBoxOverlap(normal, d, extents)) return Ps::IntFalse;
+
+			return Ps::IntTrue;	// box and triangle overlaps
+		}
+	}
+
+#undef CROSS
+#undef DOT
+#undef FINDMINMAX
+#undef AXISTEST_X01
+#undef AXISTEST_X2
+#undef AXISTEST_Y02
+#undef AXISTEST_Y1
+#undef AXISTEST_Z12
+#undef AXISTEST_Z0
+
+}
+
+#endif
+

physx/source/geomutils/include/GuRaycastTests.h

@@ -0,0 +1,72 @@
+//
+// 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-2021 NVIDIA Corporation. All rights reserved.
+// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
+// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
+
+#ifndef GU_RAYCAST_TESTS_H
+#define GU_RAYCAST_TESTS_H
+
+#include "foundation/PxSimpleTypes.h"
+#include "geometry/PxGeometry.h"
+#include "PxQueryReport.h"
+#include "CmPhysXCommon.h"
+
+namespace physx
+{
+	// PT: TODO: why is PxHitFlag::eMESH_MULTIPLE used in the ray-vs-hf function, but not in the ray-vs-mesh function?
+
+	// PT: we use a define to be able to quickly change the signature of all raycast functions.
+	// (this also ensures they all use consistent names for passed parameters).
+	// \param[in]	geom		geometry object to raycast against
+	// \param[in]	pose		pose of geometry object
+	// \param[in]	rayOrigin	ray's origin
+	// \param[in]	rayDir		ray's unit dir
+	// \param[in]	maxDist		ray's length/max distance
+	// \param[in]	hitFlags	query behavior flags
+	// \param[in]	maxHits		max number of hits = size of 'hits' buffer
+	// \param[out]	hits		result buffer where to write raycast hits
+	#define GU_RAY_FUNC_PARAMS	const PxGeometry& geom, const PxTransform& pose,					\
+								const PxVec3& rayOrigin, const PxVec3& rayDir, PxReal maxDist,		\
+								PxHitFlags hitFlags, PxU32 maxHits, PxRaycastHit* PX_RESTRICT hits
+	namespace Gu
+	{
+		// PT: function pointer for Geom-indexed raycast functions
+		// See GU_RAY_FUNC_PARAMS for function parameters details.
+		// \return		number of hits written to 'hits' result buffer
+		// \note		there's no mechanism to report overflow. Returned number of hits is just clamped to maxHits.
+		typedef PxU32	(*RaycastFunc)		(GU_RAY_FUNC_PARAMS);
+
+		// PT: typedef for a bundle of all raycast functions, i.e. the function table itself (indexed by geom-type).
+		typedef RaycastFunc GeomRaycastTable[PxGeometryType::eGEOMETRY_COUNT];
+
+		// PT: retrieves the raycast function table (for access by external non-Gu modules)
+		PX_PHYSX_COMMON_API const GeomRaycastTable& getRaycastFuncTable();
+
+	}  // namespace Gu
+}
+
+#endif

physx/source/geomutils/include/GuSIMDHelpers.h

@@ -0,0 +1,98 @@
+//
+// 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-2021 NVIDIA Corporation. All rights reserved.
+// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
+// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
+
+#ifndef GU_SIMD_HELPERS_H
+#define GU_SIMD_HELPERS_H
+
+#include "foundation/PxMat33.h"
+#include "common/PxPhysXCommonConfig.h"
+#include "geometry/PxTriangle.h"
+#include "CmPhysXCommon.h"
+#include "PsVecMath.h"
+
+namespace physx
+{
+namespace Gu
+{
+	//! A padded version of PxTriangle, to safely load its data using SIMD
+	class TrianglePadded : public PxTriangle
+	{
+	public:
+		PX_FORCE_INLINE TrianglePadded()	{}
+		PX_FORCE_INLINE ~TrianglePadded()	{}
+		PxU32	padding;
+	};
+
+	// PT: wrapper helper class to make sure we can safely load a PxVec3 using SIMD loads
+	// PT: TODO: refactor with PxVec3Pad
+	class Vec3p : public PxVec3
+	{
+		public:
+		PX_FORCE_INLINE	Vec3p()								{}
+		PX_FORCE_INLINE	~Vec3p()							{}
+		PX_FORCE_INLINE	Vec3p(const PxVec3& p) : PxVec3(p)	{}
+		PX_FORCE_INLINE	Vec3p(float f) : PxVec3(f)			{}
+		PxU32	padding;
+	};
+	PX_COMPILE_TIME_ASSERT(sizeof(Vec3p) == 16);
+
+	//! A padded version of PxMat33, to safely load its data using SIMD
+	class PxMat33Padded : public PxMat33
+	{
+	public:
+		explicit PX_FORCE_INLINE PxMat33Padded(const PxQuat& q)
+		{
+			using namespace Ps::aos;
+			const QuatV qV = V4LoadU(&q.x);
+			Vec3V column0V, column1V, column2V;
+			QuatGetMat33V(qV, column0V, column1V, column2V);
+#if defined(PX_SIMD_DISABLED) || PX_ANDROID || (PX_LINUX && (PX_ARM || PX_A64)) || (PX_UWP && (PX_ARM || PX_A64))
+			V3StoreU(column0V, column0);
+			V3StoreU(column1V, column1);
+			V3StoreU(column2V, column2);
+#else
+			V4StoreU(column0V, &column0.x);
+			V4StoreU(column1V, &column1.x);
+			V4StoreU(column2V, &column2.x);
+#endif
+		}
+		PX_FORCE_INLINE ~PxMat33Padded()				{}
+		PX_FORCE_INLINE void operator=(const PxMat33& other)
+		{
+			column0 = other.column0;
+			column1 = other.column1;
+			column2 = other.column2;
+		}
+		PxU32	padding;
+	};
+
+} // namespace Gu
+}
+
+#endif

physx/source/geomutils/include/GuSegment.h

@@ -0,0 +1,182 @@
+//
+// 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-2021 NVIDIA Corporation. All rights reserved.
+// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
+// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
+
+#ifndef GU_SEGMENT_H
+#define GU_SEGMENT_H
+/** \addtogroup geomutils
+@{
+*/
+
+#include "foundation/PxVec3.h"
+#include "Ps.h"
+#include "CmPhysXCommon.h"
+
+namespace physx
+{
+namespace Gu
+{
+
+	/**
+	\brief Represents a line segment.
+
+	Line segment geometry
+	In some cases this structure will be used to represent the infinite line that passes point0 and point1.
+	*/
+	class Segment
+	{
+	public:
+		/**
+		\brief Constructor
+		*/
+		PX_INLINE Segment()
+		{
+		}
+
+		/**
+		\brief Constructor
+		*/
+		PX_INLINE Segment(const PxVec3& _p0, const PxVec3& _p1) : p0(_p0), p1(_p1)
+		{
+		}
+
+		/**
+		\brief Copy constructor
+		*/
+		PX_INLINE Segment(const Segment& seg) : p0(seg.p0), p1(seg.p1)
+		{
+		}
+
+		/**
+		\brief Destructor
+		*/
+		PX_INLINE ~Segment()
+		{
+		}
+
+		//! Assignment operator
+		PX_INLINE Segment& operator=(const Segment& other)
+		{
+			p0 = other.p0; 
+			p1 = other.p1; 
+			return *this;
+		}
+
+		//! Equality operator
+		PX_INLINE bool operator==(const Segment& other) const
+		{
+			return (p0==other.p0 && p1==other.p1);
+		}
+
+		//! Inequality operator
+		PX_INLINE bool operator!=(const Segment& other) const
+		{
+			return (p0!=other.p0 || p1!=other.p1);
+		}
+
+		PX_INLINE const PxVec3& getOrigin() const
+		{
+			return p0;
+		}
+
+		//! Return the vector from point0 to point1
+		PX_INLINE PxVec3 computeDirection() const
+		{
+			return p1 - p0;
+		}
+
+		//! Return the vector from point0 to point1
+		PX_INLINE void computeDirection(PxVec3& dir) const
+		{
+			dir = p1 - p0;
+		}
+
+		//! Return the center of the segment segment
+		PX_INLINE PxVec3 computeCenter() const
+		{
+			return (p0 + p1)*0.5f;
+		}
+
+		PX_INLINE PxF32 computeLength() const
+		{
+			return (p1-p0).magnitude();
+		}
+
+		PX_INLINE PxF32 computeSquareLength() const
+		{
+			return (p1-p0).magnitudeSquared();
+		}
+
+		// PT: TODO: remove this one
+		//! Return the square of the length of vector from point0 to point1
+		PX_INLINE PxReal lengthSquared() const
+		{
+			return ((p1 - p0).magnitudeSquared());
+		}
+
+		// PT: TODO: remove this one
+		//! Return the length of vector from point0 to point1
+		PX_INLINE PxReal length() const
+		{
+			return ((p1 - p0).magnitude());
+		}
+
+		/*		PX_INLINE void setOriginDirection(const PxVec3& origin, const PxVec3& direction)
+		{
+		p0 = p1 = origin;
+		p1 += direction;
+		}*/
+
+		/**
+		\brief Computes a point on the segment
+
+		\param[out] pt point on segment
+		\param[in] t point's parameter [t=0 => pt = mP0, t=1 => pt = mP1]
+		*/
+		PX_INLINE void computePoint(PxVec3& pt, PxF32 t) const
+		{
+			pt = p0 + t * (p1 - p0);
+		}
+
+		// PT: TODO: remove this one
+		//! Return the point at parameter t along the line: point0 + t*(point1-point0)
+		PX_INLINE PxVec3 getPointAt(PxReal t) const
+		{
+			return (p1 - p0)*t + p0;
+		}
+
+		PxVec3	p0;		//!< Start of segment
+		PxVec3	p1;		//!< End of segment
+	};
+	PX_COMPILE_TIME_ASSERT(sizeof(Gu::Segment) == 24);
+}
+
+}
+
+/** @} */
+#endif