PxFoundation* gFoundation = PxCreateFoundation(...);

PxPhysics* gPhysics = PxCreatePhysics(PX_PHYSICS_VERSION, *gFoundation, ...);

PxSerializationRegistry* sr = PxSerialization::createSerializationRegistry(*gPhysics);

PxCollection oCollection = PxCreateCollection();

// 【step.1】添加各种要导出的对象

oCollection.add(PxBase);

// 【step.2】补全依赖

PxSerialization::complete(oCollection, sr);

// 【step.3】导出

PxSerialization::serializeCollectionToBinary(..., oCollection, *sr);

TArray<FPlaneType> Planes;

TArray<FVec3Type> Vertices; //copy of the vertices that are just on the convex hull boundary

FAABB3Type LocalBoundingBox;

FConvexStructureData StructureData;

FRealType Volume;

FVec3Type CenterOfMass;

FVec3 UnitMassInertiaTensor;

FRotation3 RotationOfMass;

PxHeightFieldDesc heightFieldDesc;

heightFieldDesc.nbRows = iNumRows;

heightFieldDesc.nbColumns = iNumCols;

heightFieldDesc.format = PxHeightFieldFormat::Enum::eS16_TM; // 假设 Chaos 高度值是 32 位浮点数

heightFieldDesc.samples.data = address;

heightFieldDesc.samples.stride = sizeof(PxHeightFieldSample);

address += sizeof(PxHeightFieldSample) * iNumRows * iNumCols;

PxConvexMeshDesc convexDesc;

convexDesc.points.count = iVerticesNum;

convexDesc.points.stride = sizeof(PxVec3);

convexDesc.points.data = address;

convexDesc.flags = PxConvexFlag::eCOMPUTE_CONVEX;

address += sizeof(PxVec3) * iVerticesNum;

PxTriangleMeshDesc triangleDesc;

triangleDesc.points.count = iVerticesNum;

triangleDesc.points.stride = sizeof(PxVec3);

triangleDesc.points.data = address;

address += sizeof(PxVec3) * iVerticesNum;

bool bLarge = *reinterpret_cast<bool*>(address);

address += sizeof(bool);

if (bLarge)

{

    const PxU32 iIndexNum = *reinterpret_cast<PxU32*>(address);

    address += sizeof(PxU32);

    triangleDesc.triangles.count = iIndexNum;

    triangleDesc.triangles.stride = sizeof(PxI32) * 3;

    triangleDesc.triangles.data = address;

    address += sizeof(PxI32) * iIndexNum * 3;

}

else

{

    const PxU32 iIndexNum = *reinterpret_cast<PxU32*>(address);

    address += sizeof(PxU32);

    triangleDesc.triangles.count = iIndexNum;

    triangleDesc.triangles.stride = sizeof(PxU16) * 3;

    triangleDesc.triangles.data = address;

    address += sizeof(PxU16) * iIndexNum * 3;

    triangleDesc.flags |= PxMeshFlag::e16_BIT_INDICES;

}

// =========== shape 层面 变换（平移） ===========

FTransform LandscapeComponentTransform = pLandspaceCmp->GetComponentToWorld();

FMatrix LandscapeComponentMatrix = LandscapeComponentTransform.ToMatrixWithScale();

FVector Scale = LandscapeComponentMatrix.ExtractScaling();

FTransform LandscapeTM = FTransform::Identity;

// 镜像 —— 平移

bool bIsMirrored = LandscapeComponentMatrix.Determinant() < 0.f;

if (!bIsMirrored)

{

    LandscapeTM.SetTranslation(FVector(-pLandspaceCmp->CollisionSizeQuads * pLandspaceCmp->CollisionScale * Scale.X, 0, 0));

}

oShape.mShape.mShape.mCore.transform.q.w = LandscapeTM.GetRotation().W;

oShape.mShape.mShape.mCore.transform.q.x = LandscapeTM.GetRotation().X;

oShape.mShape.mShape.mCore.transform.q.y = LandscapeTM.GetRotation().Y;

oShape.mShape.mShape.mCore.transform.q.z = LandscapeTM.GetRotation().Z;

oShape.mShape.mShape.mCore.transform.p = LandscapeTM.GetLocation();

//scale 实际上也做了旋转

FVector FinalScale(Scale.X * pLandspaceCmp->CollisionScale, Scale.Y* pLandspaceCmp->CollisionScale, Scale.Z* LANDSCAPE_ZSCALE);

oHeightField.rowScale = FinalScale.X;

oHeightField.columnScale = FinalScale.Y;

oHeightField.heightScale = FinalScale.Z;

// =========== actor 层面 变换（旋转） ===========

// 坐标轴变换 —— 旋转

FTransform LandscapeComponentTransform = pLandspaceCmp->GetComponentToWorld();

FMatrix LandscapeComponentMatrix = LandscapeComponentTransform.ToMatrixWithScale();

// Reorder the axes

FVector TerrainX = LandscapeComponentMatrix.GetScaledAxis(EAxis::X);

FVector TerrainY = LandscapeComponentMatrix.GetScaledAxis(EAxis::Y);

FVector TerrainZ = LandscapeComponentMatrix.GetScaledAxis(EAxis::Z);

LandscapeComponentMatrix.SetAxis(0, TerrainX);

LandscapeComponentMatrix.SetAxis(2, TerrainY);

LandscapeComponentMatrix.SetAxis(1, TerrainZ);

// 计算位移矩阵

FTransform LandscapeComponentTransformEd = FTransform(LandscapeComponentMatrix);

oStatic.mRigidStatic.mStatic.mCore.body2World.q.w = LandscapeComponentTransformEd.GetRotation().W;

oStatic.mRigidStatic.mStatic.mCore.body2World.q.x = LandscapeComponentTransformEd.GetRotation().X;

oStatic.mRigidStatic.mStatic.mCore.body2World.q.y = LandscapeComponentTransformEd.GetRotation().Y;

oStatic.mRigidStatic.mStatic.mCore.body2World.q.z = LandscapeComponentTransformEd.GetRotation().Z;

oStatic.mRigidStatic.mStatic.mCore.body2World.p = LandscapeComponentTransformEd.GetLocation();

// =========== 绘制 HeightField（反向） ===========

struct FHeightFieldAccessor

{

    FHeightFieldAccessor(const ULandscapeHeightfieldCollisionComponent::FHeightfieldGeometryRef& InGeometryRef)

        : GeometryRef(InGeometryRef)

            , NumX(InGeometryRef.Heightfield.IsValid() ? InGeometryRef.Heightfield->GetNumCols() : 0)

            , NumY(InGeometryRef.Heightfield.IsValid() ? InGeometryRef.Heightfield->GetNumRows() : 0)

        {

        }

    float GetUnscaledHeight(int32 X, int32 Y) const

    {

        return GeometryRef.Heightfield->GetHeight(X, Y);

    }

    uint8 GetMaterialIndex(int32 X, int32 Y) const

    {

        return GeometryRef.Heightfield->GetMaterialIndex(X, Y);

    }

    const ULandscapeHeightfieldCollisionComponent::FHeightfieldGeometryRef& GeometryRef;

    int32 NumY = 0;

    int32 NumX = 0;

};

FHeightFieldAccessor Accessor(*pLandspaceCmp->HeightfieldRef.GetReference());

int RowMax = Accessor.NumX;

int ColMax = Accessor.NumY;

const bool bIsMirrored = pLandspaceCmp->GetComponentToWorld().GetDeterminant() < 0.f;

if (bIsMirrored)

{

    ColMax = Accessor.NumX;

    RowMax = Accessor.NumY;

}

oOutArc.Serialize(&RowMax, sizeof(PxU32));	// x

oOutArc.Serialize(&ColMax, sizeof(PxU32));	// z

for (int32 x = 0; x < ColMax; ++x)

{

    for (int32 y = 0; y < ColMax; ++y)

    {

        PxHeightFieldSample oSimple;

        if (bIsMirrored)

        {

            const float CurrHeight = Accessor.GetUnscaledHeight(x, y);

            const uint8 MaterialIdx = Accessor.GetMaterialIndex(x, y);

            oSimple.height = CurrHeight;

            oSimple.materialIndex0.mData = MaterialIdx;

            oSimple.materialIndex1.mData = MaterialIdx;

        }

        else

        {

            const float CurrHeight = Accessor.GetUnscaledHeight(ColMax - x - 1, y);

            const uint8 MaterialIdx = Accessor.GetMaterialIndex(ColMax - x - 1, y);

            oSimple.height = CurrHeight;

            oSimple.materialIndex0.mData = MaterialIdx;

            oSimple.materialIndex1.mData = MaterialIdx;

        }

        oOutArc.Serialize(&oSimple, sizeof(PxHeightFieldSample));

    }

}

// 序列化

s.writeData(&obj, sizeof(T));

// 反序列化

T* obj = new (address) T();

sizeof(NpShape) = 272

sizeof(NpRigidStatic) = 176

sizeof(NpRigidDynamic) = 384

sizeof(NpMaterial) = 80