diff --git a/vphysics-physx/convert.cpp b/vphysics-physx/convert.cpp
index 52041043..5bc2865e 100644
--- a/vphysics-physx/convert.cpp
+++ b/vphysics-physx/convert.cpp
@@ -259,89 +259,15 @@ static const IVP_U_Matrix *GetTmpObjectMatrix( IVP_Real_Object *pObject )
 
 void TransformIVPToLocal( const IVP_U_Point &pointIn, IVP_U_Point &pointOut, IVP_Real_Object *pObject, bool translate )
 {
-#if USE_CACHE_OBJECT
-	IVP_Cache_Object *cache = pObject->get_cache_object_no_lock();
-
-	if ( translate )
-	{
-		cache->transform_position_to_object_coords( &pointIn, &pointOut );
-	}
-	else
-	{
-		cache->transform_vector_to_object_coords( &pointIn, &pointOut );
-	}
-#else
-	const IVP_U_Matrix *pMatrix = GetTmpObjectMatrix( pObject );
-	if ( translate )
-	{
-		pMatrix->inline_vimult4( &pointIn, &pointOut );
-	}
-	else
-	{
-		pMatrix->inline_vimult3( &pointIn, &pointOut );
-	}
-#endif
 }
 
 
 void TransformLocalToIVP( const IVP_U_Point &pointIn, IVP_U_Point &pointOut, IVP_Real_Object *pObject, bool translate )
 {
-#if USE_CACHE_OBJECT
-	IVP_Cache_Object *cache = pObject->get_cache_object_no_lock();
-
-	if ( translate )
-	{
-		IVP_U_Float_Point floatPointIn;
-		floatPointIn.set( &pointIn );
-		cache->transform_position_to_world_coords( &floatPointIn, &pointOut );
-	}
-	else
-	{
-		cache->transform_vector_to_world_coords( &pointIn, &pointOut );
-	}
-#else
-	const IVP_U_Matrix *pMatrix = GetTmpObjectMatrix( pObject );
-
-	if ( translate )
-	{
-		pMatrix->inline_vmult4( &pointIn, &pointOut );
-	}
-	else
-	{
-		pMatrix->inline_vmult3( &pointIn, &pointOut );
-	}
-#endif
 }
 
 void TransformLocalToIVP( const IVP_U_Float_Point &pointIn, IVP_U_Point &pointOut, IVP_Real_Object *pObject, bool translate )
 {
-#if USE_CACHE_OBJECT
-	IVP_Cache_Object *cache = pObject->get_cache_object_no_lock();
-
-	if ( translate )
-	{
-		cache->transform_position_to_world_coords( &pointIn, &pointOut );
-	}
-	else
-	{
-		IVP_U_Point doublePointIn;
-		doublePointIn.set( &pointIn );
-		cache->transform_vector_to_world_coords( &doublePointIn, &pointOut );
-	}
-#else
-	const IVP_U_Matrix *pMatrix = GetTmpObjectMatrix( pObject );
-	IVP_U_Float_Point out;
-
-	if ( translate )
-	{
-		pMatrix->inline_vmult4( &pointIn, &out );
-	}
-	else
-	{
-		pMatrix->inline_vmult3( &pointIn, &out );
-	}
-	pointOut.set( &out );
-#endif
 }
 
 void TransformLocalToIVP( const IVP_U_Float_Point &pointIn, IVP_U_Float_Point &pointOut, IVP_Real_Object *pObject, bool translate )
diff --git a/vphysics-physx/main.cpp b/vphysics-physx/main.cpp
index 6210c028..2d185d0f 100644
--- a/vphysics-physx/main.cpp
+++ b/vphysics-physx/main.cpp
@@ -11,8 +11,9 @@
 #include "vphysics/collision_set.h"
 #include "tier1/tier1.h"
 #include "ivu_vhash.hxx"
+#include "PxPhysicsAPI.h"
 
-
+using namespace physx;
 
 #if defined(_WIN32) && !defined(_X360)
 #define WIN32_LEAN_AND_MEAN
@@ -29,39 +30,24 @@ static void ivu_string_print_function( const char *str )
 	Msg("%s", str);
 }
 
-#if defined(_WIN32) && !defined(_XBOX)
-//HMODULE	gPhysicsDLLHandle;
-
-#pragma warning (disable:4100)
-
-BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
+class PhysErrorCallback : public PxErrorCallback
 {
- 	if ( fdwReason == DLL_PROCESS_ATTACH )
+public:
+	virtual void reportError(PxErrorCode::Enum code, const char* message, const char* file,
+		int line)
 	{
-//		ivp_set_message_print_function( ivu_string_print_function );
+		// error processing implementation
+		Warning("Px: %s %s:%d\n", message, file, line);
+    }
+};
 
-		MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false );
-		// store out module handle
-		//gPhysicsDLLHandle = (HMODULE)hinstDLL;
-	}
-	else if ( fdwReason == DLL_PROCESS_DETACH )
-	{
-	}
-	return TRUE;
-}
-
-#endif		// _WIN32
-
-#ifdef POSIX
-void __attribute__ ((constructor)) vphysics_init(void);
-void vphysics_init(void)
-{
-//	ivp_set_message_print_function( ivu_string_print_function );
-
-	MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false );
-}
-#endif
+PhysErrorCallback gPxErrorCallback;
+PxDefaultAllocator gPxAllocatorCallback;
 
+PxFoundation *gPxFoundation = NULL;
+PxPvd *gPxPvd = NULL;
+PxPhysics *gPxPhysics = NULL;
+PxCooking *gPxCooking = NULL;
 
 // simple 32x32 bit array
 class CPhysicsCollisionSet : public IPhysicsCollisionSet
@@ -102,6 +88,8 @@ class CPhysicsInterface : public CTier1AppSystem<IPhysics>
 {
 public:
 	CPhysicsInterface() : m_pCollisionSetHash(NULL) {}
+	virtual InitReturnVal_t Init();
+	virtual void Shutdown();
 	virtual void *QueryInterface( const char *pInterfaceName );
 	virtual	IPhysicsEnvironment *CreateEnvironment( void );
 	virtual void DestroyEnvironment( IPhysicsEnvironment *pEnvironment );
@@ -112,6 +100,7 @@ public:
 	virtual IPhysicsCollisionSet *FindCollisionSet( unsigned int id );
 	virtual void DestroyAllCollisionSets();
 
+	typedef CTier1AppSystem<IPhysics> BaseClass;
 private:
 	CUtlVector<IPhysicsEnvironment *>	m_envList;
 	CUtlVector<CPhysicsCollisionSet>	m_collisionSets;
@@ -126,6 +115,60 @@ static CPhysicsInterface g_MainDLLInterface;
 IPhysics *g_PhysicsInternal = &g_MainDLLInterface;
 EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CPhysicsInterface, IPhysics, VPHYSICS_INTERFACE_VERSION, g_MainDLLInterface );
 
+#define PVD_HOST "localhost"
+
+InitReturnVal_t CPhysicsInterface::Init()
+{
+	InitReturnVal_t nRetVal = BaseClass::Init();
+	if ( nRetVal != INIT_OK )
+		return nRetVal;
+
+	bool recordMemoryAllocations = true;
+
+	MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false );
+
+	gPxFoundation = PxCreateFoundation(PX_PHYSICS_VERSION, gPxAllocatorCallback, gPxErrorCallback);
+
+	if( !gPxFoundation )
+	{
+		Error("PxCreateFoundation failed!\n");
+		return INIT_FAILED;
+	}
+
+	gPxPvd = PxCreatePvd(*gPxFoundation);
+	PxPvdTransport* transport = PxDefaultPvdSocketTransportCreate(PVD_HOST, 5425, 10000);
+	if(transport)
+		Msg("PxDefaultPvdSocketTransportCreate success\n");
+
+	gPxPvd->connect(*transport,PxPvdInstrumentationFlag::eALL);
+
+	gPxPhysics = PxCreatePhysics(PX_PHYSICS_VERSION, *gPxFoundation, PxTolerancesScale(), recordMemoryAllocations, gPxPvd);
+
+	if( !gPxPhysics )
+	{
+		Error("PxCreatePhysics failed!\n");
+		return INIT_FAILED;
+	}
+
+	gPxCooking = PxCreateCooking(PX_PHYSICS_VERSION, *gPxFoundation	, PxCookingParams(PxTolerancesScale()));
+
+
+	return INIT_OK;
+}
+
+
+void CPhysicsInterface::Shutdown()
+{
+	if( gPxPhysics )
+		gPxPhysics->release();
+
+	if( gPxFoundation )
+		gPxFoundation->release();
+
+
+	BaseClass::Shutdown( );
+}
+
 
 //-----------------------------------------------------------------------------
 // Query interface
@@ -218,25 +261,3 @@ void CPhysicsInterface::DestroyAllCollisionSets()
 	m_pCollisionSetHash = NULL;
 }
 
-	
-
-// In release build, each of these libraries must contain a symbol that indicates it is also a release build
-// You MUST disable this in order to run a release vphysics.dll with a debug library.
-// This should not usually be necessary
-// #if !defined(_DEBUG) && defined(_WIN32)
-// extern int ivp_physics_lib_is_a_release_build;
-// extern int ivp_compactbuilder_lib_is_a_release_build;
-// extern int hk_base_lib_is_a_release_build;
-// extern int hk_math_lib_is_a_release_build;
-// extern int havana_constraints_lib_is_a_release_build;
-
-// void DebugTestFunction()
-// {
-// 	ivp_physics_lib_is_a_release_build = 0;
-// 	ivp_compactbuilder_lib_is_a_release_build = 0;
-// 	hk_base_lib_is_a_release_build = 0;
-// 	hk_math_lib_is_a_release_build = 0;
-// 	havana_constraints_lib_is_a_release_build = 0;
-// }
-// #endif
-
diff --git a/vphysics-physx/physics_collide.cpp b/vphysics-physx/physics_collide.cpp
index 1c2609f6..7d34142f 100644
--- a/vphysics-physx/physics_collide.cpp
+++ b/vphysics-physx/physics_collide.cpp
@@ -29,6 +29,7 @@
 
 #include "mathlib/polyhedron.h"
 #include "tier1/byteswap.h"
+#include "physics_globals.h"
 
 // memdbgon must be the last include file in a .cpp file!!!
 #include "tier0/memdbgon.h"
@@ -161,9 +162,110 @@ EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CPhysicsCollision, IPhysicsCollision, VPHYSIC
 // You can disable all of the havok Mopp collision model building by undefining this symbol
 #define ENABLE_IVP_MOPP	0
 
+struct ivpcompactledge_t {
+        DECLARE_BYTESWAP_DATADESC()
+
+        int             c_point_offset; // byte offset from 'this' to (ledge) point array
+        union {
+                int     ledgetree_node_offset;
+                int     client_data;    // if indicates a non terminal ledge
+        };
+
+        union {
+                int bf1;
+
+                struct {
+                        uint    has_chilren_flag:2;
+                        int             is_compact_flag:2;  // if false than compact ledge uses points outside this piece of memory
+                        uint    dummy:4;
+                        uint    size_div_16:24; 
+                };
+        };
+
+        short   n_triangles;
+        short   for_future_use;
+};
+
+// 48 bytes
+// Just like a btCompoundShape.
+struct ivpcompactsurface_t {
+        DECLARE_BYTESWAP_DATADESC()
+
+        float   mass_center[3];
+        float   rotation_inertia[3];
+        float   upper_limit_radius;
+
+        union {
+                int bf1; // HACK: Allow datamap to take address of this bitfield
+
+                struct {
+                        int             max_deviation : 8;
+                        int             byte_size : 24;
+                };
+        };
+
+        int             offset_ledgetree_root;
+        int             dummy[3];                       // dummy[2] is "IVPS" or 0
+};
+
+struct ivpcompactedge_t {
+        DECLARE_BYTESWAP_DATADESC()
+
+        union {
+                int bf1;
+
+                struct {
+                        uint    start_point_index:16;           // point index
+                        int             opposite_index:15;                      // rel to this // maybe extra array, 3 bits more tha>
+                        uint    is_virtual:1;
+                };
+        };
+};
+
+struct ivpcompactledgenode_t {
+        DECLARE_BYTESWAP_DATADESC()
+
+        int             offset_right_node; // (if != 0 than children
+        int             offset_compact_ledge; // (if != 0, pointer to hull that contains all subelements
+        float   center[3];      // in object_coords
+        float   radius; // size of sphere
+        unsigned char box_sizes[3];
+        unsigned char free_0;
+
+        // Functions
+
+        const ivpcompactledge_t *GetCompactLedge() const {
+                Assert(this->offset_right_node == 0);
+                return (ivpcompactledge_t *)((char *)this + this->offset_compact_ledge);
+        }
+
+        const ivpcompactledgenode_t *GetLeftSon() const {
+                Assert(this->offset_right_node);
+                return this + 1;
+        }
+
+        const ivpcompactledgenode_t *GetRightSon() const {
+                Assert(this->offset_right_node);
+                return (ivpcompactledgenode_t *)((char *)this + this->offset_right_node);
+        }
+
+        bool IsTerminal() const {
+                return (this->offset_right_node == 0);
+        }
+
+        const ivpcompactledge_t *GetCompactHull() const {
+                if (this->offset_compact_ledge)
+                        return (ivpcompactledge_t *)((char *)this + this->offset_compact_ledge);
+                else
+                        return NULL;
+        }
+};
+
+
 struct physcollideheader_t
 {
 	DECLARE_BYTESWAP_DATADESC();
+	int	size;
 	int		vphysicsID;
 	short	version;
 	short	modelType;
@@ -306,10 +408,136 @@ void OutputCollideDebugInfo( const CPhysCollide *pCollisionModel )
 	pCollisionModel->OutputDebugInfo();
 }
 
+namespace ivp_compat
+{
+	struct collideheader_t
+	{
+		int		vphysicsID;
+		short	version;
+		short	modelType;
+	};
+
+	struct compactsurfaceheader_t
+	{
+		int		surfaceSize;
+		Vector	dragAxisAreas;
+		int		axisMapSize;
+	};
+
+	struct moppsurfaceheader_t
+	{
+		int moppSize;
+	};
+
+	struct compactsurface_t
+	{
+		float	mass_center[3];
+		float	rotation_inertia[3];
+		float	upper_limit_radius;
+
+		unsigned int	max_factor_surface_deviation	: 8;
+		int		        byte_size						: 24;
+		int		        offset_ledgetree_root;
+		int		        dummy[3];
+	};
+
+	struct compactmopp_t
+	{
+		float	mass_center[3];
+		float	rotation_inertia[3];
+		float	upper_limit_radius;
+
+		unsigned int max_factor_surface_deviation	: 8;
+		int          byte_size						: 24;
+		int	         offset_ledgetree_root;
+		int          offset_ledges;
+		int          size_convex_hull;
+		int	         dummy;
+	};
+
+	struct compactledge_t
+	{
+		int		c_point_offset;
+
+		union
+		{
+			int	ledgetree_node_offset;
+			int	client_data;
+		};
+
+		struct
+		{
+			uint	has_children_flag	: 2;
+			int		is_compact_flag		: 2;
+			uint	dummy				: 4;
+			uint	size_div_16			: 24; 
+		};
+
+		short	n_triangles;
+		short	for_future_use;
+	};
+
+	struct compactedge_t
+	{
+		uint    start_point_index	: 16;
+		int		opposite_index		: 15;
+		uint	is_virtual			: 1;
+	};
+
+	struct compacttriangle_t
+	{
+		uint	tri_index		: 12;
+		uint	pierce_index	: 12;
+		uint	material_index	: 7;
+		uint	is_virtual		: 1;
+		compactedge_t c_three_edges[3];
+	};
+
+	struct compactledgenode_t
+	{
+		int		offset_right_node;
+		int		offset_compact_ledge;
+		float	center[3];
+		float	radius;
+		unsigned char box_sizes[3];
+		unsigned char free_0;
+
+		const compactledge_t *GetCompactLedge() const
+		{
+			//VJoltAssert( this->offset_right_node == 0 );
+			return ( compactledge_t * )( ( char * )this + this->offset_compact_ledge );
+		}
+
+		const compactledgenode_t *GetLeftChild() const
+		{
+			//VJoltAssert( this->offset_right_node );
+			return this + 1;
+		}
+
+		const compactledgenode_t *GetRightChild() const
+		{
+			//VJoltAssert( this->offset_right_node );
+			return ( compactledgenode_t * )( ( char * )this + this->offset_right_node );
+		}
+
+		bool IsTerminal() const
+		{
+			return this->offset_right_node == 0;
+		}
+
+		const compactledge_t *GetCompactHull() const
+		{
+			if ( this->offset_compact_ledge )
+				return ( compactledge_t * )( ( char * )this + this->offset_compact_ledge );
+			else
+				return nullptr;
+		}
+	};
+}
 
 CPhysCollide *CPhysCollide::UnserializeFromBuffer( const char *pBuffer, unsigned int size, int index, bool swap )
 {
-	const physcollideheader_t *pHeader = reinterpret_cast<const physcollideheader_t *>(pBuffer);
+	const ivp_compat::collideheader_t *pHeader = reinterpret_cast<const ivp_compat::collideheader_t *>(pBuffer);
 	if ( pHeader->vphysicsID == VPHYSICS_COLLISION_ID )
 	{
 		Assert(pHeader->version == VPHYSICS_COLLISION_VERSION);
@@ -1623,39 +1851,113 @@ float CPhysicsCollision::CollideSurfaceArea( CPhysCollide *pCollide )
 	return area;
 }
 
+static void GetAllIVPEdges(const ivp_compat::compactledgenode_t *pNode, CUtlVector<const ivp_compat::compactledge_t *> *vecOut)
+{
+	if (!pNode || !vecOut) return;
+
+	if ( !pNode->IsTerminal() )
+	{
+		GetAllIVPEdges( pNode->GetRightChild(), vecOut );
+		GetAllIVPEdges( pNode->GetLeftChild(), vecOut );
+	}
+	else
+		vecOut->AddToTail( pNode->GetCompactLedge() );
+}
+
+CPhysCollide *DeserializeIVP_Poly( const ivp_compat::compactsurface_t* pSurface )
+{
+	const ivp_compat::compactledgenode_t *pFirstLedgeNode = reinterpret_cast< const ivp_compat::compactledgenode_t * >(
+			reinterpret_cast< const char * >( pSurface ) + pSurface->offset_ledgetree_root );
+
+	CUtlVector< const ivp_compat::compactledge_t * > ledges;
+	GetAllIVPEdges( pFirstLedgeNode, &ledges );
+
+	Msg("ledge count - %d\n", ledges.Count());
+
+	return NULL;
+}
+
+CPhysCollide *DeserializeIVP_Poly( const ivp_compat::collideheader_t *pCollideHeader )
+{
+	const ivp_compat::compactsurfaceheader_t *pSurfaceHeader = reinterpret_cast< const ivp_compat::compactsurfaceheader_t* >( pCollideHeader + 1 );
+	const ivp_compat::compactsurface_t *pSurface = reinterpret_cast< const ivp_compat::compactsurface_t* >( pSurfaceHeader + 1 );
+	return DeserializeIVP_Poly( pSurface );
+}
 
 // loads a set of solids into a vcollide_t
 void CPhysicsCollision::VCollideLoad( vcollide_t *pOutput, int solidCount, const char *pBuffer, int bufferSize, bool swap )
 {
 	memset( pOutput, 0, sizeof(*pOutput) );
-	int position = 0;
 
 	pOutput->solidCount = solidCount;
-	pOutput->solids = new CPhysCollide *[solidCount];
-
-	BEGIN_IVP_ALLOCATION();
+	pOutput->solids = new CPhysCollide*[ solidCount ];
 
+	const char *pCursor = pBuffer;
 	for ( int i = 0; i < solidCount; i++ )
 	{
-		int size;
-		memcpy( &size, pBuffer + position, sizeof(int) );
-		position += sizeof(int);
+		// Be safe ahead of time as so much can go wrong with
+		// this mess! :p
+		pOutput->solids[ i ] = nullptr;
 
-		char *tmpbuf = new char[size];
-		memcpy(tmpbuf, pBuffer + position, size);
+		const int solidSize = *reinterpret_cast<const int *>( pCursor );
+		pCursor += sizeof( int );
 
-		pOutput->solids[i] = CPhysCollide::UnserializeFromBuffer( tmpbuf, size, i, swap );
-		position += size;
+		const ivp_compat::collideheader_t *pCollideHeader = reinterpret_cast<const ivp_compat::collideheader_t *>( pCursor );
 
-		delete[] tmpbuf;
+		if ( pCollideHeader->vphysicsID == VPHYSICS_COLLISION_ID )
+		{
+			// This is the main path that everything falls down for a modern
+			// .phy file with the collide header.
+
+			if ( pCollideHeader->version != VPHYSICS_COLLISION_VERSION )
+				Warning( "Solid with unknown version: 0x%x, may crash!\n", pCollideHeader->version );
+
+			switch ( pCollideHeader->modelType )
+			{
+				case COLLIDE_POLY:
+					pOutput->solids[ i ] = DeserializeIVP_Poly( pCollideHeader );
+					break;
+				default:
+					Warning( "Unsupported solid type 0x%x on solid %d. Skipping...\n", (int)pCollideHeader->modelType, i );
+					break;
+			}
+		}
+		else
+		{
+			// This must be a legacy style .phy where it is just a dumped compact surface.
+			// Some props in shipping HL2 still use this format, as they have a .phy, even after their
+			// .qc had the $collisionmodel removed, as they didn't get the stale .phy in the game files deleted.
+
+			const ivp_compat::compactsurface_t *pCompactSurface = reinterpret_cast<const ivp_compat::compactsurface_t*>( pCursor );
+			const int legacyModelType = pCompactSurface->dummy[2];
+			switch ( legacyModelType )
+			{
+				case 0:
+				case IVP_COMPACT_SURFACE_ID:
+				case IVP_COMPACT_SURFACE_ID_SWAPPED:
+					pOutput->solids[i] = DeserializeIVP_Poly( pCollideHeader );
+					break;
+				default:
+					Warning( "Unsupported legacy solid type 0x%x on solid %d. Skipping...\n", legacyModelType, i);
+					break;
+			}
+		}
+
+		pCursor += solidSize;
 	}
 
-	END_IVP_ALLOCATION();
+	// The rest of the buffer is KV.
+	const int keyValuesSize = bufferSize - ( pCursor - pBuffer );
+
+	pOutput->pKeyValues = new char[ keyValuesSize + 1 ];
+	V_memcpy( pOutput->pKeyValues, pCursor, keyValuesSize );
+	pOutput->pKeyValues[ keyValuesSize ] = '\0';
+
+	pOutput->descSize = keyValuesSize;
 	pOutput->isPacked = false;
-	int keySize = bufferSize - position;
-	pOutput->pKeyValues = new char[keySize];
-	memcpy( pOutput->pKeyValues, pBuffer + position, keySize );
-	pOutput->descSize = 0;
+#ifdef GAME_ASW_OR_NEWER
+	pOutput->pUserData = nullptr;
+#endif
 }
 
 // destroys the set of solids created by VCollideCreateCPhysCollide
diff --git a/vphysics-physx/physics_constraint.cpp b/vphysics-physx/physics_constraint.cpp
index 211cfefa..2b5cb64a 100644
--- a/vphysics-physx/physics_constraint.cpp
+++ b/vphysics-physx/physics_constraint.cpp
@@ -568,24 +568,8 @@ CPhysicsConstraint::CPhysicsConstraint( CPhysicsObject *pReferenceObject, CPhysi
 	m_constraintType = CONSTRAINT_UNKNOWN;
 	m_isBreakable = false;
 
-	if ( pReferenceObject && pAttachedObject )
-	{
-		m_pObjReference = (CPhysicsObject *)pReferenceObject;
-		m_pObjAttached = (CPhysicsObject *)pAttachedObject;
-		if ( !(m_pObjReference->CallbackFlags() & CALLBACK_NEVER_DELETED) )
-		{
-			m_pObjReference->GetObject()->add_listener_object( this );
-		}
-		if ( !(m_pObjAttached->CallbackFlags() & CALLBACK_NEVER_DELETED) )
-		{
-			m_pObjAttached->GetObject()->add_listener_object( this );
-		}
-	}
-	else
-	{
-		m_pObjReference = NULL;
-		m_pObjAttached = NULL;
-	}
+	m_pObjReference = NULL;
+	m_pObjAttached = NULL;
 }
 
 // Check to see if this is a single degree of freedom joint, if so, convert to a hinge
diff --git a/vphysics-physx/physics_environment.cpp b/vphysics-physx/physics_environment.cpp
index a934c37f..1be656ad 100644
--- a/vphysics-physx/physics_environment.cpp
+++ b/vphysics-physx/physics_environment.cpp
@@ -36,6 +36,7 @@
 #include "ivp_phantom.hxx"
 #include "ivp_range_manager.hxx"
 #include "ivp_clustering_visualizer.hxx"
+#include "physics_globals.h"
 
 // memdbgon must be the last include file in a .cpp file!!!
 #include "tier0/memdbgon.h"
@@ -1113,6 +1114,18 @@ CPhysicsEnvironment::CPhysicsEnvironment( void )
 	m_fixedTimestep = true;	// try to simulate using fixed timesteps
 	m_enableConstraintNotify = false;
 
+	// PHYSX_BEGIN
+
+    PxSceneDesc sceneDesc(gPxPhysics->getTolerancesScale());
+    sceneDesc.gravity = physx::PxVec3(0.0f, -9.81f, 0.0f);
+
+    m_pPxDispatcher = PxDefaultCpuDispatcherCreate(2);
+    sceneDesc.cpuDispatcher	= m_pPxDispatcher;
+	sceneDesc.filterShader	= PxDefaultSimulationFilterShader;
+
+	m_pPxScene = gPxPhysics->createScene(sceneDesc);
+	// PHYSX_END
+
     // build a default environment
     IVP_Environment_Manager *env_manager;
     env_manager = IVP_Environment_Manager::get_environment_manager();
@@ -1440,7 +1453,8 @@ IPhysicsFluidController *CPhysicsEnvironment::CreateFluidController( IPhysicsObj
 
 IPhysicsConstraint *CPhysicsEnvironment::CreateRagdollConstraint( IPhysicsObject *pReferenceObject, IPhysicsObject *pAttachedObject, IPhysicsConstraintGroup *pGroup, const constraint_ragdollparams_t &ragdoll )
 {
-	return ::CreateRagdollConstraint( m_pPhysEnv, (CPhysicsObject *)pReferenceObject, (CPhysicsObject *)pAttachedObject, pGroup, ragdoll );
+	return NULL;
+//	return ::CreateRagdollConstraint( m_pPhysEnv, (CPhysicsObject *)pReferenceObject, (CPhysicsObject *)pAttachedObject, pGroup, ragdoll );
 }
 
 IPhysicsConstraint *CPhysicsEnvironment::CreateHingeConstraint( IPhysicsObject *pReferenceObject, IPhysicsObject *pAttachedObject, IPhysicsConstraintGroup *pGroup, const constraint_hingeparams_t &hinge )
@@ -1511,6 +1525,10 @@ void CPhysicsEnvironment::Simulate( float deltaTime )
 			deltaTime = 0.1f;
 		}
 
+		m_pPxScene->simulate(deltaTime);
+		m_pPxScene->fetchResults(true);
+
+#if 0
 		m_pCollisionSolver->EventPSI( this );
 		m_pCollisionListener->EventPSI( this );
 
@@ -1525,7 +1543,10 @@ void CPhysicsEnvironment::Simulate( float deltaTime )
 		{
 			m_pPhysEnv->simulate_time_step();
 		}
+
 		END_IVP_ALLOCATION();
+#endif
+
 		m_inSimulation = false;
 	}
 
diff --git a/vphysics-physx/physics_environment.h b/vphysics-physx/physics_environment.h
index 075b91c5..38f0f6ef 100644
--- a/vphysics-physx/physics_environment.h
+++ b/vphysics-physx/physics_environment.h
@@ -12,6 +12,7 @@
 #include "vphysics_interface.h"
 #include "ivu_types.hxx"
 #include "utlvector.h"
+#include "physics_globals.h"
 
 class IVP_Environment;
 class CSleepObjects;
@@ -164,6 +165,9 @@ private:
 	bool							m_queueDeleteObject;
 	bool							m_fixedTimestep;
 	bool							m_enableConstraintNotify;
+
+	PxDefaultCpuDispatcher	*m_pPxDispatcher;
+	PxScene					*m_pPxScene;
 };
 
 extern IPhysicsEnvironment *CreatePhysicsEnvironment( void );
diff --git a/vphysics-physx/physics_fluid.cpp b/vphysics-physx/physics_fluid.cpp
index 8a8ec539..aafa2252 100644
--- a/vphysics-physx/physics_fluid.cpp
+++ b/vphysics-physx/physics_fluid.cpp
@@ -189,6 +189,8 @@ CPhysicsFluidController *CreateFluidController( IVP_Environment *pEnvironment, C
 {
 	pFluidObject->BecomeTrigger();
 
+	return NULL;
+
 	IVP_Controller_Phantom *pPhantom = pFluidObject->GetObject()->get_controller_phantom();
 	if ( !pPhantom )
 		return NULL;
diff --git a/vphysics-physx/physics_friction.cpp b/vphysics-physx/physics_friction.cpp
index a6a0513a..ae235966 100644
--- a/vphysics-physx/physics_friction.cpp
+++ b/vphysics-physx/physics_friction.cpp
@@ -55,7 +55,7 @@ private:
 CFrictionSnapshot::CFrictionSnapshot( IVP_Real_Object *pObject ) : m_pObject(pObject)
 {
 	m_pDeleteList = NULL;
-	SetFrictionSynapse( pObject->get_first_friction_synapse() );
+	//SetFrictionSynapse( pObject->get_first_friction_synapse() );
 }
 
 CFrictionSnapshot::~CFrictionSnapshot()
@@ -102,12 +102,7 @@ bool CFrictionSnapshot::IsValid()
 
 IPhysicsObject *CFrictionSnapshot::GetObject( int index )
 {
-	IVP_Synapse_Friction *pFriction = m_pFriction;
-	if ( index == 1 )
-	{
-		pFriction = m_pContactPoint->get_synapse(!m_synapseIndex);
-	}
-	return static_cast<IPhysicsObject *>(pFriction->get_object()->client_data);
+	return NULL;
 }
 
 void CFrictionSnapshot::MarkContactForDelete() 
diff --git a/vphysics-physx/physics_object.cpp b/vphysics-physx/physics_object.cpp
index 4d1f3b94..6c5332d7 100644
--- a/vphysics-physx/physics_object.cpp
+++ b/vphysics-physx/physics_object.cpp
@@ -101,7 +101,7 @@ void CPhysicsObject::Init( const CPhysCollide *pCollisionModel, IVP_Real_Object
 	m_pCollide = pCollisionModel;
 	m_materialIndex = materialIndex;
 	m_pObject = pObject;
-	pObject->client_data = (void *)this;
+//	pObject->client_data = (void *)this;
 	m_pGameData = NULL;
 	m_gameFlags = 0;
 	m_gameIndex = 0;
@@ -174,18 +174,18 @@ CPhysicsObject::~CPhysicsObject( void )
 
 void CPhysicsObject::Wake( void )
 {
-	m_pObject->ensure_in_simulation();
+	//m_pObject->ensure_in_simulation();
 }
 
 void CPhysicsObject::WakeNow( void )
 {
-	m_pObject->ensure_in_simulation_now();
+	//m_pObject->ensure_in_simulation_now();
 }
 
 // supported
 void CPhysicsObject::Sleep( void )
 {
-	m_pObject->disable_simulation();
+	//m_pObject->disable_simulation();
 }
 
 
@@ -195,19 +195,19 @@ bool CPhysicsObject::IsAsleep() const
 		return false;
 
 	// double-check that we aren't pending
-	if ( m_pObject->get_core()->is_in_wakeup_vec )
-		return false;
+	//if ( m_pObject->get_core()->is_in_wakeup_vec )
+	//	return false;
 
 	return true;
 }
 
 void CPhysicsObject::NotifySleep( void )
 {
-	if ( m_sleepState == OBJ_AWAKE )
-	{
-		m_sleepState = OBJ_STARTSLEEP;
-	}
-	else
+//	if ( m_sleepState == OBJ_AWAKE )
+//	{
+//		m_sleepState = OBJ_STARTSLEEP;
+//	}
+//	else
 	{
 		// UNDONE: This fails sometimes and we get sleep calls for a sleeping object, debug?
 		//Assert(m_sleepState==OBJ_STARTSLEEP);
@@ -275,40 +275,12 @@ unsigned short CPhysicsObject::GetGameIndex() const
 
 bool CPhysicsObject::IsStatic() const
 {
-	if ( m_pObject->get_core()->physical_unmoveable )
-		return true;
-
-	return false;
+	return true;
 }
 
 
 void CPhysicsObject::EnableCollisions( bool enable )
 {
-	if ( enable )
-	{
-		m_callbacks |= CALLBACK_ENABLING_COLLISION;
-		BEGIN_IVP_ALLOCATION();
-		m_pObject->enable_collision_detection( IVP_TRUE );
-		END_IVP_ALLOCATION();
-		m_callbacks &= ~CALLBACK_ENABLING_COLLISION;
-	}
-	else
-	{
-		if ( IsCollisionEnabled() )
-		{
-			// Delete all contact points with this physics object because it's collision is becoming disabled
-			IPhysicsFrictionSnapshot *pSnapshot = CreateFrictionSnapshot();
-			while ( pSnapshot->IsValid() )
-			{
-				pSnapshot->MarkContactForDelete();
-				pSnapshot->NextFrictionData();
-			}
-			pSnapshot->DeleteAllMarkedContacts( true );
-			DestroyFrictionSnapshot( pSnapshot );
-		}
-
-		m_pObject->enable_collision_detection( IVP_FALSE );
-	}
 }
 
 void CPhysicsObject::RecheckCollisionFilter()
@@ -316,63 +288,30 @@ void CPhysicsObject::RecheckCollisionFilter()
 	if ( CallbackFlags() & CALLBACK_MARKED_FOR_DELETE )
 		return;
 
-	m_callbacks |= CALLBACK_ENABLING_COLLISION;
-	BEGIN_IVP_ALLOCATION();
-	m_pObject->recheck_collision_filter();
-	// UNDONE: do a RecheckContactPoints() here?
-	END_IVP_ALLOCATION();
-	m_callbacks &= ~CALLBACK_ENABLING_COLLISION;
 }
 
 void CPhysicsObject::RecheckContactPoints()
 {
-	IVP_Environment *pEnv = m_pObject->get_environment();
-	IVP_Collision_Filter *coll_filter = pEnv->get_collision_filter();
-	IPhysicsFrictionSnapshot *pSnapshot = CreateFrictionSnapshot();
-	while ( pSnapshot->IsValid() )
-	{
-		CPhysicsObject *pOther = static_cast<CPhysicsObject *>(pSnapshot->GetObject(1));
-		if ( !coll_filter->check_objects_for_collision_detection( m_pObject, pOther->m_pObject ) )
-		{
-			pSnapshot->MarkContactForDelete();
-		}
-		pSnapshot->NextFrictionData();
-	}
-	pSnapshot->DeleteAllMarkedContacts( true );
-	DestroyFrictionSnapshot( pSnapshot );
 }
 
 CPhysicsEnvironment	*CPhysicsObject::GetVPhysicsEnvironment()
 {
-	return (CPhysicsEnvironment *) (m_pObject->get_environment()->client_data);
+	return NULL; //(CPhysicsEnvironment *) (m_pObject->get_environment()->client_data);
 }
 
 const CPhysicsEnvironment	*CPhysicsObject::GetVPhysicsEnvironment() const
 {
-	return (CPhysicsEnvironment *) (m_pObject->get_environment()->client_data);
+	return NULL; // (CPhysicsEnvironment *) (m_pObject->get_environment()->client_data);
 }
 
 
 bool CPhysicsObject::IsControlling( const IVP_Controller *pController ) const
 {
-	IVP_Core *pCore = m_pObject->get_core();
-	for ( int i = 0; i < pCore->controllers_of_core.len(); i++ )
-	{
-		// already controlling this core?
-		if ( pCore->controllers_of_core.element_at(i) == pController )
-			return true;
-	}
-
 	return false;
 }
 
 bool CPhysicsObject::IsGravityEnabled() const
 {
-	if ( !IsStatic() )
-	{
-		return IsControlling( m_pObject->get_core()->environment->get_gravity_controller() );
-	}
-
 	return false;
 }
 
@@ -389,7 +328,7 @@ bool CPhysicsObject::IsDragEnabled() const
 
 bool CPhysicsObject::IsMotionEnabled() const
 {
-	return m_pObject->get_core()->pinned ? false : true;
+	return false;
 }
 
 
@@ -411,16 +350,6 @@ void CPhysicsObject::EnableGravity( bool enable )
 
 	if ( enable == isEnabled )
 		return;
-
-	IVP_Controller *pGravity = m_pObject->get_core()->environment->get_gravity_controller();
-	if ( enable )
-	{
-		m_pObject->get_core()->add_core_controller( pGravity );
-	}
-	else
-	{
-		m_pObject->get_core()->rem_core_controller( pGravity );
-	}
 }
 
 void CPhysicsObject::EnableDrag( bool enable )
@@ -432,17 +361,6 @@ void CPhysicsObject::EnableDrag( bool enable )
 
 	if ( enable == isEnabled )
 		return;
-
-	IVP_Controller *pDrag = GetVPhysicsEnvironment()->GetDragController();
-
-	if ( enable )
-	{
-		m_pObject->get_core()->add_core_controller( pDrag );
-	}
-	else
-	{
-		m_pObject->get_core()->rem_core_controller( pDrag );
-	}
 }
 
 
@@ -465,41 +383,6 @@ void CPhysicsObject::RecomputeDragBases()
 {
 	if ( IsStatic() || !GetCollide() )
 		return;
-
-	// Basically we are computing drag as an OBB.  Get OBB extents for projection
-	// scale those extents by appropriate mass/inertia to compute velocity directly (not force)
-	// in the controller
-	// NOTE: Compute these even if drag coefficients are zero, because the drag coefficient could change later
-
-	// Get an AABB for this object and use the area of each side as a basis for approximating cross-section area for drag
-	Vector dragMins, dragMaxs;
-	// NOTE: coordinates in/out of physcollision are in HL units, not IVP
-	// PERFORMANCE: Cache this?  Expensive.
-	physcollision->CollideGetAABB( &dragMins, &dragMaxs, GetCollide(), vec3_origin, vec3_angle );
-
-	Vector areaFractions = physcollision->CollideGetOrthographicAreas( GetCollide() );
-	Vector delta = dragMaxs - dragMins;
-	ConvertPositionToIVP( delta.x, delta.y, delta.z );
-	delta.x = fabsf(delta.x);
-	delta.y = fabsf(delta.y);
-	delta.z = fabsf(delta.z);
-	// dragBasis is now the area of each side
-	m_dragBasis.x = delta.y * delta.z * areaFractions.x;
-	m_dragBasis.y = delta.x * delta.z * areaFractions.y;
-	m_dragBasis.z = delta.x * delta.y * areaFractions.z;
-	m_dragBasis *= GetInvMass();
-
-	const IVP_U_Float_Point *pInvRI = m_pObject->get_core()->get_inv_rot_inertia();
-
-	// This angular basis is the integral of each differential drag area's torque over the whole OBB
-	// need half lengths for this integral
-	delta *= 0.5;
-	// rotation about the x axis
-	m_angDragBasis.x = areaFractions.z * AngDragIntegral( pInvRI->k[0], delta.x, delta.y, delta.z ) + areaFractions.y * AngDragIntegral( pInvRI->k[0], delta.x, delta.z, delta.y );
-	// rotation about the y axis
-	m_angDragBasis.y = areaFractions.z * AngDragIntegral( pInvRI->k[1], delta.y, delta.x, delta.z ) + areaFractions.x * AngDragIntegral( pInvRI->k[1], delta.y, delta.z, delta.x );
-	// rotation about the z axis
-	m_angDragBasis.z = areaFractions.y * AngDragIntegral( pInvRI->k[2], delta.z, delta.x, delta.y ) + areaFractions.x * AngDragIntegral( pInvRI->k[2], delta.z, delta.y, delta.x );
 }
 
 
@@ -515,10 +398,6 @@ void CPhysicsObject::EnableMotion( bool enable )
 	if ( isMoveable == enable )
 		return;
 
-	BEGIN_IVP_ALLOCATION();
-	m_pObject->set_pinned( enable ? IVP_FALSE : IVP_TRUE );
-	END_IVP_ALLOCATION();
-
 	if ( enable && IsHinged() )
 	{
 		BecomeHinged( m_hingedAxis-1 );
@@ -550,29 +429,12 @@ void CPhysicsObject::DestroyFrictionSnapshot( IPhysicsFrictionSnapshot *pSnapsho
 
 bool CPhysicsObject::IsMassCenterAtDefault() const
 {
-	// this is the actual mass center of the object as created
-	Vector massCenterHL = GetMassCenterLocalSpace();
-
-	// Get the default mass center to see if it has been changed
-	IVP_U_Float_Point massCenterIVPDefault;
-	Vector massCenterHLDefault;
-	GetObject()->get_surface_manager()->get_mass_center( &massCenterIVPDefault );
-	ConvertPositionToHL( massCenterIVPDefault, massCenterHLDefault );
-	float delta = (massCenterHLDefault - massCenterHL).Length();
-
-	return ( delta <= g_PhysicsUnits.collisionSweepIncrementalEpsilon ) ? true : false;
+	return false;
 }
 
 Vector CPhysicsObject::GetMassCenterLocalSpace() const
 {
-	if ( m_pObject->flags.shift_core_f_object_is_zero )
-		return vec3_origin;
-
-	Vector out;
-	ConvertPositionToHL( *m_pObject->get_shift_core_f_object(), out );
-	// core shift is what you add to the mass center to get the origin
-	// so we want the negative core shift (origin relative position of the mass center)
-	return -out;
+	return Vector( 0, 0, 0 );
 }
 
 
@@ -599,7 +461,7 @@ void CPhysicsObject::SetMass( float mass )
 	Assert( mass > 0 );
 
 	mass = clamp( mass, 1.f, VPHYSICS_MAX_MASS );
-	m_pObject->change_mass( mass );
+	//m_pObject->change_mass( mass );
 	SetVolume( m_volume );
 	RecomputeDragBases();
 	if ( reset )
@@ -610,71 +472,37 @@ void CPhysicsObject::SetMass( float mass )
 
 float CPhysicsObject::GetMass( void ) const
 {
-	return m_pObject->get_core()->get_mass();
+	return 0.f;
 }
 
 float CPhysicsObject::GetInvMass( void ) const
 {
-	return m_pObject->get_core()->get_inv_mass();
+	return 1.f;
 }
 
 Vector CPhysicsObject::GetInertia( void ) const
 {
-	const IVP_U_Float_Point *pRI = m_pObject->get_core()->get_rot_inertia();
-
-	Vector hlInertia;
-	ConvertDirectionToHL( *pRI, hlInertia );
-	VectorAbs( hlInertia, hlInertia );
-	return hlInertia;
+	return Vector(0, 0, 0);
 }
 
 Vector CPhysicsObject::GetInvInertia( void ) const
 {
-	const IVP_U_Float_Point *pRI = m_pObject->get_core()->get_inv_rot_inertia();
-
-	Vector hlInvInertia;
-	ConvertDirectionToHL( *pRI, hlInvInertia );
-	VectorAbs( hlInvInertia, hlInvInertia );
-	return hlInvInertia;
+	return Vector(0, 0, 0);
 }
 
 
 
 void CPhysicsObject::SetInertia( const Vector &inertia )
 {
-	IVP_U_Float_Point ri; ConvertDirectionToIVP( inertia, ri );
-	ri.k[0] = IVP_Inline_Math::fabsd(ri.k[0]);
-	ri.k[1] = IVP_Inline_Math::fabsd(ri.k[1]);
-	ri.k[2] = IVP_Inline_Math::fabsd(ri.k[2]);
-
-	m_pObject->get_core()->set_rotation_inertia( &ri );
 }
 
 
 void CPhysicsObject::GetDamping( float *speed, float *rot ) const
 {
-	IVP_Core *pCore = m_pObject->get_core();
-	if ( speed )
-	{
-		*speed = pCore->speed_damp_factor;
-	}
-	if ( rot )
-	{
-		*rot = pCore->rot_speed_damp_factor.k[0];
-	}
 }
 
 void CPhysicsObject::SetDamping( const float *speed, const float *rot )
 {
-	IVP_Core *pCore = m_pObject->get_core();
-	if ( speed )
-	{
-		pCore->speed_damp_factor = *speed;
-	}
-	if ( rot )
-	{
-		pCore->rot_speed_damp_factor.set( *rot, *rot, *rot );
-	}
 }
 
 void CPhysicsObject::SetVolume( float volume )
@@ -756,13 +584,6 @@ void CPhysicsObject::ApplyForceCenter( const Vector &forceVector )
 	if ( !IsMoveable() )
 		return;
 
-	IVP_U_Float_Point tmp;
-
-	ConvertForceImpulseToIVP( forceVector, tmp );
-	IVP_Core *core = m_pObject->get_core();
-	tmp.mult( core->get_inv_mass() );
-	m_pObject->async_add_speed_object_ws( &tmp );
-	ClampVelocity();
 }
 
 void CPhysicsObject::ApplyForceOffset( const Vector &forceVector, const Vector &worldPosition )
@@ -776,95 +597,34 @@ void CPhysicsObject::ApplyForceOffset( const Vector &forceVector, const Vector &
 	ConvertForceImpulseToIVP( forceVector, force );
 	ConvertPositionToIVP( worldPosition, pos );
 
-	IVP_Core *core = m_pObject->get_core();
-	core->async_push_core_ws( &pos, &force );
 	Wake();
 	ClampVelocity();
 }
 
 void CPhysicsObject::CalculateForceOffset( const Vector &forceVector, const Vector &worldPosition, Vector *centerForce, AngularImpulse *centerTorque ) const
 {
-	IVP_U_Point pos;
-	IVP_U_Float_Point force;
-
-	ConvertPositionToIVP( forceVector, force );
-	ConvertPositionToIVP( worldPosition, pos );
-
-	IVP_Core *core = m_pObject->get_core();
-
-	const IVP_U_Matrix *m_world_f_core = core->get_m_world_f_core_PSI();
-
-	IVP_U_Float_Point point_d_ws;
-	point_d_ws.subtract(&pos, m_world_f_core->get_position());
-
-	IVP_U_Float_Point cross_point_dir;
-
-	cross_point_dir.calc_cross_product( &point_d_ws, &force);
-	m_world_f_core->inline_vimult3( &cross_point_dir, &cross_point_dir);
-
-	ConvertAngularImpulseToHL( cross_point_dir, *centerTorque );
-	ConvertForceImpulseToHL( force, *centerForce );
 }
 
 void CPhysicsObject::CalculateVelocityOffset( const Vector &forceVector, const Vector &worldPosition, Vector *centerVelocity, AngularImpulse *centerAngularVelocity ) const
 {
-	IVP_U_Point pos;
-	IVP_U_Float_Point force;
-
-	ConvertForceImpulseToIVP( forceVector, force );
-	ConvertPositionToIVP( worldPosition, pos );
-
-	IVP_Core *core = m_pObject->get_core();
-
-	const IVP_U_Matrix *m_world_f_core = core->get_m_world_f_core_PSI();
-
-	IVP_U_Float_Point point_d_ws;
-	point_d_ws.subtract(&pos, m_world_f_core->get_position());
-
-	IVP_U_Float_Point cross_point_dir;
-
-	cross_point_dir.calc_cross_product( &point_d_ws, &force);
-	m_world_f_core->inline_vimult3( &cross_point_dir, &cross_point_dir);
-
-	cross_point_dir.set_pairwise_mult( &cross_point_dir, core->get_inv_rot_inertia());
-	ConvertAngularImpulseToHL( cross_point_dir, *centerAngularVelocity );
-	force.set_multiple( &force, core->get_inv_mass() );
-	ConvertForceImpulseToHL( force, *centerVelocity );
 }
 
 void CPhysicsObject::ApplyTorqueCenter( const AngularImpulse &torqueImpulse )
 {
 	if ( !IsMoveable() )
 		return;
-	IVP_U_Float_Point ivpTorque;
-	ConvertAngularImpulseToIVP( torqueImpulse, ivpTorque );
-	IVP_Core *core = m_pObject->get_core();
-	core->async_rot_push_core_multiple_ws( &ivpTorque, 1.0 );
+
 	Wake();
 	ClampVelocity();
 }
 
 void CPhysicsObject::GetPosition( Vector *worldPosition, QAngle *angles ) const
 {
-	IVP_U_Matrix matrix;
-	m_pObject->get_m_world_f_object_AT( &matrix );
-	if ( worldPosition )
-	{
-		ConvertPositionToHL( matrix.vv, *worldPosition );
-	}
-
-	if ( angles )
-	{
-		ConvertRotationToHL( matrix, *angles );
-	}
 }
 
 
 void CPhysicsObject::GetPositionMatrix( matrix3x4_t *positionMatrix ) const
 {
-	IVP_U_Matrix matrix;
-	m_pObject->get_m_world_f_object_AT( &matrix );
-	ConvertMatrixToHL( matrix, *positionMatrix );
 }
 
 
@@ -872,38 +632,6 @@ void CPhysicsObject::GetImplicitVelocity( Vector *velocity, AngularImpulse *angu
 {
 	if ( !velocity && !angularVelocity )
 		return;
-
-	IVP_Core *core = m_pObject->get_core();
-	if ( velocity )
-	{
-		// just convert the cached dx
-		ConvertPositionToHL( core->delta_world_f_core_psis, *velocity );
-	}
-
-	if ( angularVelocity )
-	{
-		// compute the relative transform that was actually integrated in the last psi
-		IVP_U_Quat q_core_f_core;
-		q_core_f_core.set_invert_mult( &core->q_world_f_core_last_psi, &core->q_world_f_core_next_psi);
-		
-		// now convert that to an axis/angle pair
-		Quaternion q( q_core_f_core.x, q_core_f_core.y, q_core_f_core.z, q_core_f_core.w );
-		AngularImpulse axis;
-		float angle;
-		QuaternionAxisAngle( q, axis, angle );
-
-		// scale it by the timestep to get a velocity
-		angle *= core->i_delta_time;
-
-		// ConvertDirectionToHL() - convert this ipion direction (in HL type) to HL coords
-		float tmpY = axis.z;
-		angularVelocity->z = -axis.y;
-		angularVelocity->y = tmpY;
-		angularVelocity->x = axis.x;
-
-		// now scale the axis by the angle to return the data in the correct format
-		(*angularVelocity) *= angle;
-	}
 }
 
 void CPhysicsObject::GetVelocity( Vector *velocity, AngularImpulse *angularVelocity ) const
@@ -911,45 +639,10 @@ void CPhysicsObject::GetVelocity( Vector *velocity, AngularImpulse *angularVeloc
 	if ( !velocity && !angularVelocity )
 		return;
 
-	IVP_Core *core = m_pObject->get_core();
-	if ( velocity )
-	{
-		IVP_U_Float_Point speed;
-		speed.add( &core->speed, &core->speed_change );
-		ConvertPositionToHL( speed, *velocity );
-	}
-
-	if ( angularVelocity )
-	{
-		IVP_U_Float_Point rotSpeed;
-		rotSpeed.add( &core->rot_speed, &core->rot_speed_change );
-		// xform to HL space
-		ConvertAngularImpulseToHL( rotSpeed, *angularVelocity );
-	}
 }
 
 void CPhysicsObject::GetVelocityAtPoint( const Vector &worldPosition, Vector *pVelocity ) const
 {
-	IVP_Core *core = m_pObject->get_core();
-	IVP_U_Point pos;
-	ConvertPositionToIVP( worldPosition, pos );
-
-	IVP_U_Float_Point rotSpeed;
-	rotSpeed.add( &core->rot_speed, &core->rot_speed_change );
-
-	IVP_U_Float_Point av_ws;
-	core->get_m_world_f_core_PSI()->vmult3( &rotSpeed, &av_ws);
-
-	IVP_U_Float_Point pos_rel; 	
-	pos_rel.subtract( &pos, core->get_position_PSI());
-	IVP_U_Float_Point cross;    
-	cross.inline_calc_cross_product(&av_ws,&pos_rel);
-
-	IVP_U_Float_Point speed;
-	speed.add(&core->speed, &cross);
-	speed.add(&core->speed_change);
-
-	ConvertPositionToHL( speed, *pVelocity );
 }
 
 
@@ -959,80 +652,18 @@ void CPhysicsObject::AddVelocity( const Vector *velocity, const AngularImpulse *
 	Assert(IsMoveable());
 	if ( !IsMoveable() )
 		return;
-	IVP_Core *core = m_pObject->get_core();
 
 	Wake();
-
-	if ( velocity )
-	{
-		IVP_U_Float_Point ivpVelocity;
-		ConvertPositionToIVP( *velocity, ivpVelocity );
-		core->speed_change.add( &ivpVelocity );
-	}
-
-	if ( angularVelocity )
-	{
-		IVP_U_Float_Point ivpAngularVelocity;
-		ConvertAngularImpulseToIVP( *angularVelocity, ivpAngularVelocity );
-
-		core->rot_speed_change.add(&ivpAngularVelocity);
-	}
 	ClampVelocity();
 }
 
 void CPhysicsObject::SetPosition( const Vector &worldPosition, const QAngle &angles, bool isTeleport )
 {
-	IVP_U_Quat rot;
-	IVP_U_Point pos;
 
-	if ( m_pShadow )
-	{
-		UpdateShadow( worldPosition, angles, false, 0 );
-	}
-	ConvertPositionToIVP( worldPosition, pos );
-
-	ConvertRotationToIVP( angles, rot );
-
-	if ( m_pObject->is_collision_detection_enabled() && isTeleport )
-	{
-		EnableCollisions( false );
-		m_pObject->beam_object_to_new_position( &rot, &pos, IVP_FALSE );
-		EnableCollisions( true );
-	}
-	else
-	{
-		m_pObject->beam_object_to_new_position( &rot, &pos, IVP_FALSE );
-	}
 }
 
 void CPhysicsObject::SetPositionMatrix( const matrix3x4_t& matrix, bool isTeleport )
 {
-	if ( m_pShadow )
-	{
-		Vector worldPosition;
-		QAngle angles;
-		MatrixAngles( matrix, angles );
-		MatrixGetColumn( matrix, 3, worldPosition );
-		UpdateShadow( worldPosition, angles, false, 0 );
-	}
-
-	IVP_U_Quat rot;
-	IVP_U_Matrix mat;
-
-	ConvertMatrixToIVP( matrix, mat );
-
-	rot.set_quaternion( &mat );
-
-	if ( m_pObject->is_collision_detection_enabled() && isTeleport )
-	{
-		EnableCollisions( false );
-		m_pObject->beam_object_to_new_position( &rot, &mat.vv, IVP_FALSE );
-		EnableCollisions( true );
-	}
-	else
-	{
-		m_pObject->beam_object_to_new_position( &rot, &mat.vv, IVP_FALSE );
-	}
 }
 
 void CPhysicsObject::SetVelocityInstantaneous( const Vector *velocity, const AngularImpulse *angularVelocity )
@@ -1040,44 +671,13 @@ void CPhysicsObject::SetVelocityInstantaneous( const Vector *velocity, const Ang
 	Assert(IsMoveable());
 	if ( !IsMoveable() )
 		return;
-	IVP_Core *core = m_pObject->get_core();
 
-	WakeNow();
-
-	if ( velocity )
-	{
-		ConvertPositionToIVP( *velocity, core->speed );
-		core->speed_change.set_to_zero();
-	}
-
-	if ( angularVelocity )
-	{
-		ConvertAngularImpulseToIVP( *angularVelocity, core->rot_speed );
-		core->rot_speed_change.set_to_zero();
-	}
-	ClampVelocity();
 }
 
 void CPhysicsObject::SetVelocity( const Vector *velocity, const AngularImpulse *angularVelocity )
 {
 	if ( !IsMoveable() )
 		return;
-	IVP_Core *core = m_pObject->get_core();
-
-	Wake();
-
-	if ( velocity )
-	{
-		ConvertPositionToIVP( *velocity, core->speed_change );
-		core->speed.set_to_zero();
-	}
-
-	if ( angularVelocity )
-	{
-		ConvertAngularImpulseToIVP( *angularVelocity, core->rot_speed_change );
-		core->rot_speed.set_to_zero();
-	}
-	ClampVelocity();
 }
 
 
@@ -1086,7 +686,6 @@ void CPhysicsObject::ClampVelocity()
 	if ( m_pShadow )
 		return;
 
-	m_pObject->get_core()->apply_velocity_limit();
 }
 
 void GetWorldCoordFromSynapse( IVP_Synapse_Friction *pfriction, IVP_U_Point &world )
@@ -1116,21 +715,7 @@ bool CPhysicsObject::GetContactPoint( Vector *contactPoint, IPhysicsObject **con
 
 void CPhysicsObject::SetShadow( float maxSpeed, float maxAngularSpeed, bool allowPhysicsMovement, bool allowPhysicsRotation )
 {
-	if ( m_pShadow )
-	{
-		m_pShadow->MaxSpeed( maxSpeed, maxAngularSpeed );
-	}
-	else
-	{
-		m_shadowTempGravityDisable = false;
-
-		CPhysicsEnvironment *pVEnv = GetVPhysicsEnvironment();
-		m_pShadow = pVEnv->CreateShadowController( this, allowPhysicsMovement, allowPhysicsRotation );
-		m_pShadow->MaxSpeed( maxSpeed, maxAngularSpeed );
-		// This really should be in the game code, but do this here because the game may (does) use 
-		// shadow/AI control as a collision filter indicator.
-		RecheckCollisionFilter();
-	}
+	return;
 }
 
 void CPhysicsObject::UpdateShadow( const Vector &targetPosition, const QAngle &targetAngles, bool tempDisableGravity, float timeOffset )
@@ -1302,100 +887,32 @@ void CPhysicsObject::BecomeTrigger()
 	if ( IsTrigger() )
 		return;
 
-	if ( GetShadowController() )
-	{
-		// triggers won't have the standard collisions, so the material change is no longer necessary
-		// also: This will fix problems with surfaceprops if the trigger becomes a fluid.
-		GetShadowController()->UseShadowMaterial( false );
-	}
-	EnableDrag( false );
-	EnableGravity( false );
-
-	// UNDONE: Use defaults here?  Do we want object sets by default?
-	IVP_Template_Phantom trigger;
-	trigger.manage_intruding_cores = IVP_TRUE; // manage a list of intruded objects
-	trigger.manage_sleeping_cores = IVP_TRUE; // don't untouch/touch on sleep/wake
-	trigger.dont_check_for_unmoveables = IVP_TRUE;
-	trigger.exit_policy_extra_radius = 0.1f; // relatively strict exit check [m]
-
-	bool enableCollisions = IsCollisionEnabled();
-	EnableCollisions( false );
-	BEGIN_IVP_ALLOCATION();
-	m_pObject->convert_to_phantom( &trigger );
-	END_IVP_ALLOCATION();
-	// hook up events
-	CPhysicsEnvironment *pVEnv = GetVPhysicsEnvironment();
-	pVEnv->PhantomAdd( this );
-
-
-	EnableCollisions( enableCollisions );
 }
 
 
 void CPhysicsObject::RemoveTrigger()
 {
-	IVP_Controller_Phantom *pController = m_pObject->get_controller_phantom();
-
-	// NOTE: This will remove the back-link in the object
-	delete pController;
 }
 
 
 bool CPhysicsObject::IsTrigger() const
 {
-	return m_pObject->get_controller_phantom() != NULL ? true : false;
+	return false;
 }
 
 bool CPhysicsObject::IsFluid() const
 {
-	IVP_Controller_Phantom *pController = m_pObject->get_controller_phantom();
-	if ( pController )
-	{
-		// UNDONE: Make a base class for triggers?  IPhysicsTrigger?
-		//	and derive fluids and any other triggers from that class
-		//	then you can ask that class what to do here.
-		if ( pController->client_data )
-			return true;
-	}
-
 	return false;
 }
 
 // sets the object to be hinged.  Fixed it place, but able to rotate around one axis.
 void CPhysicsObject::BecomeHinged( int localAxis )
 {
-
-	if ( IsMoveable() )
-	{
-		float savedMass = GetMass();
-
-		IVP_U_Float_Hesse *iri = (IVP_U_Float_Hesse *)m_pObject->get_core()->get_inv_rot_inertia();
-
-		float savedRI[3];
-		for ( int i = 0; i < 3; i++ )
-			savedRI[i] = iri->k[i];
-
-		SetMass( VPHYSICS_MAX_MASS );
-		IVP_U_Float_Hesse tmp = *iri;
-
-#if 0
-		for ( i = 0; i < 3; i++ )
-			tmp.k[i] = savedRI[i];
-#else
-		int localAxisIVP = ConvertCoordinateAxisToIVP(localAxis);
-		tmp.k[localAxisIVP] = savedRI[localAxisIVP];
-#endif
-
-		SetMass( savedMass );
-		*iri = tmp;
-	}
-	m_hingedAxis = localAxis+1;
 }
 
 void CPhysicsObject::RemoveHinged()
 {
 	m_hingedAxis = 0;
-	m_pObject->get_core()->calc_calc();
 }
 
 // dumps info about the object to Msg()
@@ -1453,18 +970,6 @@ void CPhysicsObject::OutputDebugInfo() const
 
 bool CPhysicsObject::IsAttachedToConstraint( bool bExternalOnly ) const
 {
-	if ( m_pObject )
-	{
-		for (int k = m_pObject->get_core()->controllers_of_core.len()-1; k>=0;k--)
-		{
-			IVP_Controller *pController = m_pObject->get_core()->controllers_of_core.element_at(k);
-			if ( pController->get_controller_priority() == IVP_CP_CONSTRAINTS )
-			{
-				if ( !bExternalOnly || IsExternalConstraint(pController, GetGameData()) )
-					return true;
-			}
-		}
-	}
 	return false;
 }
 
@@ -1565,9 +1070,9 @@ CPhysicsObject *CreatePhysicsObject( CPhysicsEnvironment *pEnvironment, const CP
 
 	BEGIN_IVP_ALLOCATION();
 
-	IVP_Polygon *realObject = pEnvironment->GetIVPEnvironment()->create_polygon(pSurman, &objectTemplate, &rotation, &pos);
+//	IVP_Polygon *realObject = pEnvironment->GetIVPEnvironment()->create_polygon(pSurman, &objectTemplate, &rotation, &pos);
 
-	pObject->Init( pCollisionModel, realObject, materialIndex, pParams->volume, pParams->dragCoefficient, pParams->dragCoefficient );
+	pObject->Init( pCollisionModel, NULL, materialIndex, pParams->volume, pParams->dragCoefficient, pParams->dragCoefficient );
 	pObject->SetGameData( pParams->pGameData );
 
 	if ( pParams->enableCollisions )
@@ -1708,7 +1213,7 @@ END_DATADESC()
 
 bool CPhysicsObject::IsCollisionEnabled() const
 {
-	return GetObject()->is_collision_detection_enabled() ? true : false;
+	return false;
 }
 
 void CPhysicsObject::WriteToTemplate( vphysics_save_cphysicsobject_t &objectTemplate )
diff --git a/vphysics-physx/physics_shadow.cpp b/vphysics-physx/physics_shadow.cpp
index fa80cd9c..f0ab30d2 100644
--- a/vphysics-physx/physics_shadow.cpp
+++ b/vphysics-physx/physics_shadow.cpp
@@ -288,29 +288,12 @@ void CPlayerController::AttachObject( void )
 {
 	m_pObject->EnableDrag( false );
 	IVP_Real_Object *pivp = m_pObject->GetObject();
-	IVP_Core *pCore = pivp->get_core();
-	m_saveRot = pCore->rot_speed_damp_factor;
-	pCore->rot_speed_damp_factor = IVP_U_Float_Point( 100, 100, 100 );
-	pCore->calc_calc();
-	BEGIN_IVP_ALLOCATION();
-	pivp->get_environment()->get_controller_manager()->add_controller_to_core( this, pCore );
-	END_IVP_ALLOCATION();
-	m_pObject->AddCallbackFlags( CALLBACK_IS_PLAYER_CONTROLLER );
 }
 
 void CPlayerController::DetachObject( void )
 {
 	if ( !m_pObject )
 		return;
-
-	IVP_Real_Object *pivp = m_pObject->GetObject();
-	IVP_Core *pCore = pivp->get_core();
-	pCore->rot_speed_damp_factor = m_saveRot;
-	pCore->calc_calc();
-	m_pObject->RemoveCallbackFlags( CALLBACK_IS_PLAYER_CONTROLLER );
-	m_pObject = NULL;
-	pivp->get_environment()->get_controller_manager()->remove_controller_from_core( this, pCore );
-	SetGround(NULL);
 }
 
 void CPlayerController::SetObject( IPhysicsObject *pObject )
@@ -360,14 +343,14 @@ void CPlayerController::StepUp( float height )
 		return;
 
 	Vector step( 0, 0, height );
-
+/*
 	IVP_Real_Object *pIVP = m_pObject->GetObject();
 	IVP_U_Quat world_f_object;
 	IVP_U_Point positionIVP, deltaIVP;
 	ConvertPositionToIVP( step, deltaIVP );
 	pIVP->get_quat_world_f_object_AT( &world_f_object, &positionIVP );
 	positionIVP.add( &deltaIVP );
-	pIVP->beam_object_to_new_position( &world_f_object, &positionIVP, IVP_TRUE );
+	pIVP->beam_object_to_new_position( &world_f_object, &positionIVP, IVP_TRUE );*/
 }
 
 void CPlayerController::Jump()
@@ -632,34 +615,6 @@ void CPlayerController::Update( const Vector& position, const Vector& velocity,
 #endif
 
 	m_currentSpeed.set( &targetSpeedIVP );
-
-	IVP_Real_Object *pivp = m_pObject->GetObject();
-	IVP_Core *pCore = pivp->get_core();
-	IVP_Environment *pEnv = pivp->get_environment();
-	pEnv->get_controller_manager()->ensure_core_in_simulation(pCore);
-
-	m_enable = true;
-	// m_onground makes this object anti-grav
-	// UNDONE: Re-evaluate this
-	m_onground = false;//onground;
-	if ( velocity.LengthSqr() <= 0.1f )
-	{
-		// no input velocity, just go where physics takes you.
-		m_enable = false;
-		ground = NULL;
-	}
-	else
-	{
-		MaxSpeed( velocity );
-	}
-
-	CPhysicsObject *pGroundObject = static_cast<CPhysicsObject *>(ground);
-	SetGround( pGroundObject );
-	if ( m_pGround )
-	{
-		const IVP_U_Matrix *pMatrix = m_pGround->GetObject()->get_core()->get_m_world_f_core_PSI();
-		pMatrix->vimult4( &m_targetPosition, &m_groundPosition );
-	}
 }
 
 void CPlayerController::MaxSpeed( const Vector &velocity )
diff --git a/vphysics-physx/trace.cpp b/vphysics-physx/trace.cpp
index 18474522..02f72176 100644
--- a/vphysics-physx/trace.cpp
+++ b/vphysics-physx/trace.cpp
@@ -413,6 +413,8 @@ public:
 
 	bool SetSingleConvex( void )
 	{
+		return false;
+
 		const IVP_Compact_Ledgetree_Node *node = m_pSurface->get_compact_ledge_tree_root();
 		if ( node->is_terminal() == IVP_TRUE )
 		{
@@ -477,6 +479,9 @@ FORCEINLINE fltx4 ConvertDirectionToIVP( const fltx4 & a )
 
 CTraceIVP::CTraceIVP( const CPhysCollide *pCollide, const Vector &origin, const QAngle &angles )
 {
+	if( !pCollide )
+		return;
+
 #if USE_COLLIDE_MAP
 	m_pCollideMap = pCollide->GetCollideMap();
 #else
@@ -1301,13 +1306,6 @@ void CTraceSolverSweptObject::DoSweep( void )
 {
 	VPROF("TraceSolver::DoSweep");
 	InitOSRay();
-
-	// iterate ledge tree of obstacle
-	const IVP_Compact_Surface *pSurface = m_obstacleIVP->m_pSurface;
-
-	const IVP_Compact_Ledgetree_Node *lt_node_root;
-	lt_node_root = pSurface->get_compact_ledge_tree_root();
-	SweepLedgeTree_r( lt_node_root );
 }
 
 void CPhysicsTrace::SweepBoxIVP( const Vector &start, const Vector &end, const Vector &mins, const Vector &maxs, const CPhysCollide *pCollide, const Vector &surfaceOrigin, const QAngle &surfaceAngles, trace_t *ptr )
@@ -2362,6 +2360,8 @@ void TraceGetAABB_r( Vector *pMins, Vector *pMaxs, const IVP_Compact_Ledgetree_N
 
 void CPhysicsTrace::GetAABB( Vector *pMins, Vector *pMaxs, const CPhysCollide *pCollide, const Vector &collideOrigin, const QAngle &collideAngles )
 {
+	return;
+
 	CTraceIVP ivp( pCollide, collideOrigin, collideAngles );
 
 	if ( ivp.SetSingleConvex() )
diff --git a/vphysics-physx/wscript b/vphysics-physx/wscript
index c10384c6..1dec04e4 100755
--- a/vphysics-physx/wscript
+++ b/vphysics-physx/wscript
@@ -17,6 +17,19 @@ def configure(conf):
 		'HAVANA_CONSTRAINTS',
 		'HAVOK_MOPP'
 	])
+
+	conf.env.append_unique('LINKFLAGS',  [
+#		"-L/home/nillerusr/projects/PhysX/physx/install/linux/PhysX/bin/linux.clang/release/"
+		"-L/home/nillerusr/projects/PhysX/physx/install/linux/PhysX/bin/linux.clang/debug/"
+	])
+
+	conf.check(lib='PhysX_static_64', uselib_store='PHYSX')
+	conf.check(lib='PhysXFoundation_static_64', uselib_store='PHYSX_FOUNDATION')
+	conf.check(lib='PhysXCommon_static_64', uselib_store='PHYSX_COMMON')
+	conf.check(lib='PhysXPvdSDK_static_64', uselib_store='PHYSX_PVD')
+	conf.check(lib='PhysXExtensions_static_64', uselib_store='PHYSX_EXT')
+	conf.check(lib='PhysXCooking_static_64', uselib_store='PHYSX_COOKING')
+
 def build(bld):
 	source = [
 		'convert.cpp',
@@ -56,12 +69,14 @@ def build(bld):
 		'../ivp/ivp_controller',
 		'../ivp/ivp_compact_builder',
 		'../ivp/havana/havok',
-		'../ivp/havana'
+		'../ivp/havana',
+		'/home/nillerusr/projects/PhysX/physx/install/linux/PhysX/include',
+		'/home/nillerusr/projects/PhysX/physx/install/linux/PxShared/include'
 	]
 
 	defines = []
 
-	libs = ['tier0','havana_constraints','hk_math','hk_base','ivp_compactbuilder','ivp_physics','tier1','tier2','vstdlib','mathlib']
+	libs = ['tier0','havana_constraints','hk_math','hk_base','ivp_compactbuilder','ivp_physics','tier1','tier2','vstdlib','mathlib', 'PHYSX', 'PHYSX_PVD', 'PHYSX_EXT', 'PHYSX_COOKING', 'PHYSX_FOUNDATION', 'PHYSX_COMMON']
 
 	install_path = bld.env.LIBDIR