
RagDoll Simulation을 구현한다.
Show Flag, Stat을 지원한다. 디버깅용 Physic Body 렌더링을 지원한다.
// Ragdoll
structRagdollBone
{
const char* name;
PxVec3 offset; // 부모로부터의 위치
PxVec3 halfSize; // Capsule or box 크기
int parentIndex; // -1이면 루트
PxRigidDynamic* body = nullptr;
PxJoint* joint = nullptr;
};
RagdollBone bones[] = {
// name, offset size parent
{"pelvis", PxVec3(0, 5, 0), PxVec3(0.2f, 0.3f, 0.2f), -1},
{"spine", PxVec3(0, 0.6f, 0), PxVec3(0.2f, 0.4f, 0.2f), 0},
{"head", PxVec3(0, 0.8f, 0), PxVec3(0.2f, 0.3f, 0.2f), 1},
};
voidCreateRagdoll(const PxVec3& worldRoot)
{
for (int i = 0; i < _countof(bones); ++i)
{
RagdollBone& bone = bones[i];
// 부모의 위치 기준으로 위치 계산
PxVec3 parentPos = (bone.parentIndex >= 0) ? bones[bone.parentIndex].body->getGlobalPose().p : worldRoot;
PxVec3 bonePos = parentPos + bone.offset;
// 바디 생성
PxTransformpose(bonePos);
PxRigidDynamic* body = gPhysics->createRigidDynamic(pose);
PxShape* shape = gPhysics->createShape(PxCapsuleGeometry(bone.halfSize.x, bone.halfSize.y), *gMaterial);
body->attachShape(*shape);
PxRigidBodyExt::updateMassAndInertia(*body, 1.0f);
gScene->addActor(*body);
bone.body = body;
// 조인트 연결
if (bone.parentIndex >= 0)
{
RagdollBone& parent = bones[bone.parentIndex];
PxTransform localFrameParent = PxTransform(parent.body->getGlobalPose().getInverse() * PxTransform(bonePos));
PxTransform localFrameChild = PxTransform(PxVec3(0));
PxD6Joint* joint = PxD6JointCreate(*gPhysics, parent.body, localFrameParent, bone.body, localFrameChild);
// 각도 제한 설정
joint->setMotion(PxD6Axis::eTWIST, PxD6Motion::eLIMITED);
joint->setMotion(PxD6Axis::eSWING1, PxD6Motion::eLIMITED);
joint->setMotion(PxD6Axis::eSWING2, PxD6Motion::eLIMITED);
joint->setTwistLimit(PxJointAngularLimitPair(-PxPi/4, PxPi/4));
joint->setSwingLimit(PxJointLimitCone(PxPi/6, PxPi/6));
bone.joint = joint;
}
}
}
voidSimulate(float dt)
{
gScene->simulate(dt);
gScene->fetchResults(true);
// Ragdoll 본들 위치 업데이트
for (auto& bone : bones)
{
if (bone.body)
{
PxTransform t = bone.body->getGlobalPose();
PxMat44m(t);
// 여기에 worldMatrix 계산해서 메시 렌더링용으로 넘겨주면 됨
}
}
}
나만의 자동차를 구현하세요.
// Car // PxVehicleDrive4WRawInputData // PxVehicleWheels // PxVehicleDrive4W // PxFixedSizeLookupTable // PxVehicleSuspensionRaycasts // PxVehicleUpdates
Depth of Field를 구현하세요.
Show Flag를 지원한다.
float blurAmount = saturate(abs(pixelDepth - focusDepth) / focusRange);
Engine Core (눈에 안 보이는 세상)
PhysX SDK를 빌드한다.
Clone PhysX 4.1 SDK https://github.com/NVIDIAGameWorks/PhysX/tree/4.1
Visual Studio 2022 Support
Replace physx/generate_projects.bat
Replace physx/buildtools/cmake_generate_projects.py
Run generate_projects.bat
Open physx/compiler/vc17win64/PhysXSDK.sln
PhysX SDK를 자체 엔진에 통합한다.
// Integration code for PhysX 4.1
#include <PxPhysicsAPI.h>#include <d3d11.h>#include <DirectXMath.h>#include <vector>usingnamespace physx;
usingnamespace DirectX;
// PhysX 전역
PxDefaultAllocator gAllocator;
PxDefaultErrorCallback gErrorCallback;
PxFoundation* gFoundation = nullptr;
PxPhysics* gPhysics = nullptr;
PxScene* gScene = nullptr;
PxMaterial* gMaterial = nullptr;
PxDefaultCpuDispatcher* gDispatcher = nullptr;
// 게임 오브젝트
structGameObject {
PxRigidDynamic* rigidBody = nullptr;
XMMATRIX worldMatrix = XMMatrixIdentity();
voidUpdateFromPhysics() {
PxTransform t = rigidBody->getGlobalPose();
PxMat44mat(t);
worldMatrix = XMLoadFloat4x4(reinterpret_cast<const XMFLOAT4X4*>(&mat));
}
};
std::vector<GameObject> gObjects;
voidInitPhysX() {
gFoundation = PxCreateFoundation(PX_PHYSICS_VERSION, gAllocator, gErrorCallback);
gPhysics = PxCreatePhysics(PX_PHYSICS_VERSION, *gFoundation, PxTolerancesScale());
gMaterial = gPhysics->createMaterial(0.5f, 0.5f, 0.6f);
PxSceneDescsceneDesc(gPhysics->getTolerancesScale());
sceneDesc.gravity = PxVec3(0, -9.81f, 0);
gDispatcher = PxDefaultCpuDispatcherCreate(2);
sceneDesc.cpuDispatcher = gDispatcher;
sceneDesc.filterShader = PxDefaultSimulationFilterShader;
gScene = gPhysics->createScene(sceneDesc);
}
GameObjectCreateBox(const PxVec3& pos, const PxVec3& halfExtents) {
GameObject obj;
PxTransformpose(pos);
obj.rigidBody = gPhysics->createRigidDynamic(pose);
PxShape* shape = gPhysics->createShape(PxBoxGeometry(halfExtents), *gMaterial);
obj.rigidBody->attachShape(*shape);
PxRigidBodyExt::updateMassAndInertia(*obj.rigidBody, 10.0f);
gScene->addActor(*obj.rigidBody);
obj.UpdateFromPhysics();
return obj;
}
voidSimulate(float dt) {
gScene->simulate(dt);
gScene->fetchResults(true);
for (auto& obj : gObjects) obj.UpdateFromPhysics();
}
// 렌더링은 생략 – worldMatrix를 사용해 D3D11에서 월드 행렬로 렌더링
intmain() {
InitPhysX();
// 박스 생성
gObjects.push_back(CreateBox(PxVec3(0, 5, 0), PxVec3(1,1,1)));
// 메인 루프 예시
while (true) {
Simulate(1.0f / 60.0f);
// Render(gObjects[i].worldMatrix); // ← 너의 렌더링 코드에 맞춰 사용
}
return 0;
}
// Data Structure and Wrapper
PxVec3 = FVector
PxQuat = FQuat
PxTransform = FTransform
PxRaycastHit = FHitResult
PxOverlapHit = FOverlapResult
PxSweepHit = FSweepResult
PxFilterData = FMaskFilter
PxMaterial = UPhysicalMaterial
PxShape = FBodyInstance
PxRigidActor = FBodyInstance
PxRigidDynamic = FBodyInstance
PxRigidStatic = FBodyInstance
PxJoint = FConstraintInstance
PxScene = UWorld->GetPhysicsScene()
FBodyInstance* Instance =new FBodyInstance(OwnerComp, ...);
PxActor* Body = gPhysics->createRigidDynamic(...);
Body->userData = (void*)Instance;
AActor* Actor = ((BodyInstance*)Body->userData)->OwnerComponent->GetOwner();
structFBodyInstance
{
UPrimitiveComponent* OwnerComponent;
};
// Event Callback
classMySimulationEventCallback :public PxSimulationEventCallback
{
public:
voidonContact(const PxContactPairHeader& pairHeader,
const PxContactPair* pairs,
PxU32 nbPairs)override
{
PxRigidActor* actorA = pairHeader.actors[0];
PxRigidActor* actorB = pairHeader.actors[1];
void* dataA = actorA->userData;
void* dataB = actorB->userData;
for (PxU32 i = 0; i < nbPairs; ++i)
{
const PxContactPair& cp = pairs[i];
// cp.shapes[0], cp.contactCount, cp.flags, etc...
}
}
virtual voidonTrigger(PxTriggerPair* pairs, PxU32 count)override {}
virtual voidonConstraintBreak(PxConstraintInfo* constraints, PxU32 count)override {}
virtual voidonWake(PxActor** actors, PxU32 count)override {}
virtual voidonSleep(PxActor** actors, PxU32 count)override {}
virtual voidonAdvance(const PxRigidBody* const*, const PxTransform*, const PxU32)override {}
};
MySimulationEventCallback* gMyCallback =new MySimulationEventCallback();
PxSceneDescsceneDesc(gPhysics->getTolerancesScale());
sceneDesc.simulationEventCallback = gMyCallback;
gScene = gPhysics->createScene(sceneDesc);
// Multithread support
#define SCOPED_READ_LOCK(scene) PxSceneReadLock scopedReadLock(scene);
PxScene* gScene = nullptr;
PxDefaultCpuDispatcher* gDispatcher = nullptr;
structGameObject {
PxRigidDynamic* rigidBody = nullptr;
XMMATRIX worldMatrix = XMMatrixIdentity();
voidUpdateFromPhysics() {
// Thread safe
SCOPED_READ_LOCK(*gScene);
PxTransform t = rigidBody->getGlobalPose();
PxMat44mat(t);
worldMatrix = XMLoadFloat4x4(reinterpret_cast<const XMFLOAT4X4*>(&mat));
}
};
// Thread pool
gDispatcher = PxDefaultCpuDispatcherCreate(4); // 4 threads
PxSceneDescsceneDesc(gPhysics->getTolerancesScale());
...
sceneDesc.cpuDispatcher = gDispatcher;
// Flags regarding multithread
sceneDesc.flags |= PxSceneFlag::eENABLE_ACTIVE_ACTORS;
sceneDesc.flags |= PxSceneFlag::eENABLE_CCD;
sceneDesc.flags |= PxSceneFlag::eENABLE_PCM;
gScene = gPhysics->createScene(sceneDesc);
// Loop
voidSimulate(float dt) {
gScene->simulate(dt);
gScene->fetchResults(true);
for (auto& obj : gObjects) obj.UpdateFromPhysics();
}
UPhysicsAsset 클래스를 구현한다.
// UE_5.x/Engine/Source/Developer/PhysicsUtilities/Private/PhysicsAssetUtils.cpp
// UE_5.x/Engine/Source/Runtime/Engine/Classes/PhysicsEngine/SphereElem.h
structFKAggregateGeom
{
TArray<FKSphereElem> SphereElems;
TArray<FKBoxElem> BoxElems;
TArray<FKSphylElem> SphylElems;
TArray<FKConvexElem> ConvexElems;
};
classUBodySetupCore :public UObject
{
FName BoneName;
};
classUBodySetup :public UBodySetupCore
{
// DisplayName = Primitives
structFKAggregateGeom AggGeom;
};
classUPhysicsAsset :public UObject
{
TArray<UBodySetup*> BodySetup;
};
StaticMesh와 SkeletalMesh에 Physic Body를 구현한다.
classUSkeletalMesh :public USkinnedAsset
{
UPhysicsAsset* PhysicsAsset;
};
classUStaticMesh :public UStreamableRenderAsset
{
UBodySetup* BodySetup;
};
classUPrimitiveComponent :public USceneComponent
{
FBodyInstance BodyInstance;
};
classUSkeletalMeshComponent :public USkinnedMeshComponent
{
/** Array of FBodyInstance objects, storing per-instance state about about each body. */
TArray<structFBodyInstance*> Bodies;
/** Array of FConstraintInstance structs, storing per-instance state about each constraint. */
TArray<structFConstraintInstance*> Constraints;
};
// USkeletalMeshComponent::InstantiatePhysicsAssetBodies_Internal
// void UActorComponent::CreatePhysicsState