PxGeometry* TriangleMeshGeometry::ToUnmanaged()
{
PxTriangleMeshGeometry* g = new PxTriangleMeshGeometry();
g->scale = MeshScale::ToUnmanaged(this->Scale);
g->meshFlags = ToUnmanagedEnum(PxMeshGeometryFlag, this->MeshFlags);
g->triangleMesh = (this->TriangleMesh == nullptr ? NULL : this->TriangleMesh->UnmanagedPointer);
// TODO: paddingFromFlags
return g;
}
void RigidBody::ClearTorque(ForceMode mode, bool wake)
{
this->UnmanagedPointer->clearTorque(ToUnmanagedEnum(PxForceMode, mode), wake);
}
void RigidBody::AddTorque(Vector3 force, ForceMode mode, bool wake)
{
this->UnmanagedPointer->addTorque(MathUtil::Vector3ToPxVec3(force), ToUnmanagedEnum(PxForceMode, mode), wake);
}
{
this->HeightField = heightField;
this->HeightFieldFlags = flags;
this->HeightScale = heightFieldScale;
this->RowScale = rowScale;
this->ColumnScale = columnScale;
}
PxHeightFieldGeometry HeightFieldGeometry::ToUnmanaged(HeightFieldGeometry^ geom)
{
ThrowIfNull(geom, "geom");
PxHeightFieldGeometry g;
g.columnScale = geom->ColumnScale;
g.heightField = (geom->HeightField == nullptr ? NULL : geom->HeightField->UnmanagedPointer);
g.heightFieldFlags = ToUnmanagedEnum(PxMeshGeometryFlag, geom->HeightFieldFlags);
g.heightScale = geom->HeightScale;
g.rowScale = geom->RowScale;
return g;
}
HeightFieldGeometry^ HeightFieldGeometry::ToManaged(PxHeightFieldGeometry geom)
{
auto g = gcnew HeightFieldGeometry();
g->ColumnScale = geom.columnScale;
g->HeightField = ObjectTable::GetObject<PhysX::HeightField^>((intptr_t)geom.heightField);
g->HeightFieldFlags = ToManagedEnum(MeshGeometryFlag, geom.heightFieldFlags);
g->HeightScale = geom.heightScale;
g->RowScale = geom.rowScale;
return g;
void RigidBody::ClearForce(ForceMode mode)
{
this->UnmanagedPointer->clearForce(ToUnmanagedEnum(PxForceMode, mode));
}
void CapsuleController::ClimbingMode::set(CapsuleClimbingMode value)
{
this->UnmanagedPointer->setClimbingMode(ToUnmanagedEnum(PxCapsuleClimbingMode, value));
}
#include "StdAfx.h"
#include "CookingParams.h"
PxCookingParams CookingParams::ToUnmanaged(CookingParams^ params)
{
PxCookingParams p;
p.skinWidth = params->SkinWidth;
p.suppressTriangleMeshRemapTable = params->SuppressTriangleMeshRemapTable;
p.targetPlatform = ToUnmanagedEnum(PxPlatform, params->TargetPlatform);
return p;
}
CookingParams^ CookingParams::ToManaged(PxCookingParams params)
{
CookingParams^ p = gcnew CookingParams();
p->SkinWidth = params.skinWidth;
p->SuppressTriangleMeshRemapTable = params.suppressTriangleMeshRemapTable;
p->TargetPlatform = ToManagedEnum(Platform, params.targetPlatform);
return p;
}
D6JointDrive^ D6Joint::GetDrive(D6Drive index)
{
return D6JointDrive::ToManaged(this->UnmanagedPointer->getDrive(ToUnmanagedEnum(PxD6Drive, index)));
}
#include "StdAfx.h"
#include "PhysicsEnum.h"
#include "FilterData.h"
#include "RigidActor.h"
#include "SimulationFilterShaderOps.h"
#include "DefaultSimulationFilterShader.h"
DefaultSimulationFilterShader::DefaultSimulationFilterShader()
{
}
FilterFlag DefaultSimulationFilterShader::Setup(int attributes0, FilterData filterData0, int attributes1, FilterData filterData1, PairFlag pairFlags, array<Byte>^ constantBlock)
{
PxPairFlags pf = ToUnmanagedEnum(PxPairFlag, pairFlags);
auto f = PxDefaultSimulationFilterShader(
attributes0,
FilterData::ToUnmanaged(filterData0),
attributes1,
FilterData::ToUnmanaged(filterData1),
pf,
NULL,
0);
return ToManagedEnum(FilterFlag, f);
}
bool DefaultSimulationFilterShader::GetGroupCollisionFlag(int group1, int group2)
{
return PxGetGroupCollisionFlag(group1, group2);
#include "StdAfx.h"
#include "Bvh33MidphaseDesc.h"
PxBVH33MidphaseDesc Bvh33MidphaseDesc::ToUnmanaged(Bvh33MidphaseDesc^ managed)
{
PxBVH33MidphaseDesc unmanaged;
unmanaged.meshCookingHint = ToUnmanagedEnum(PxMeshCookingHint, managed->MeshCookingHint);
unmanaged.meshSizePerformanceTradeOff = managed->MeshSizePerformanceTradeOff;
return unmanaged;
}
Bvh33MidphaseDesc^ Bvh33MidphaseDesc::ToManaged(PxBVH33MidphaseDesc unmanaged)
{
auto managed = gcnew Bvh33MidphaseDesc();
managed->MeshCookingHint = ToManagedEnum(PhysX::MeshCookingHint, unmanaged.meshCookingHint);
managed->MeshSizePerformanceTradeOff = unmanaged.meshSizePerformanceTradeOff;
return managed;
}
void Bvh33MidphaseDesc::SetToDefault()
{
PxBVH33MidphaseDesc unmanaged;
unmanaged.setToDefault();
this->MeshCookingHint = ToManagedEnum(PhysX::MeshCookingHint, unmanaged.meshCookingHint);
this->MeshSizePerformanceTradeOff = unmanaged.meshSizePerformanceTradeOff;
}
bool Bvh33MidphaseDesc::IsValid()
{
return ToUnmanaged(this).isValid();
: ControllerDesc(ControllerShapeType::Capsule)
{
}
PxCapsuleControllerDesc CapsuleControllerDesc::ToUnmanaged(CapsuleControllerDesc^ desc)
{
PxCapsuleControllerDesc d;
// Populate the base classes properties
ControllerDesc::AssignToUnmanaged(desc, d);
// Assign our specific properties
d.radius = desc->Radius;
d.height = desc->Height;
d.climbingMode = ToUnmanagedEnum(PxCapsuleClimbingMode, desc->ClimbingMode);
return d;
}
CapsuleControllerDesc^ CapsuleControllerDesc::ToManaged(PxCapsuleControllerDesc desc)
{
CapsuleControllerDesc^ d = gcnew CapsuleControllerDesc();
// Populate the base classes properties
ControllerDesc::AssignToManaged(desc, d);
// Assign our specific properties
d->Radius = desc.radius;
d->Height = desc.height;
d->ClimbingMode = ToManagedEnum(CapsuleClimbingMode, desc.climbingMode);
