jolt-ruby 1.0.0

data/ext/joltc/tests/test_skeleton.cpp

@@ -0,0 +1,370 @@
+// Copyright (c) Amer Koleci and Contributors.
+// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information.
+
+#include <gtest/gtest.h>
+#include "joltc.h"
+
+namespace BroadPhaseLayers {
+    static constexpr JPH_BroadPhaseLayer NON_MOVING = 0;
+    static constexpr JPH_BroadPhaseLayer MOVING = 1;
+    static constexpr uint32_t NUM_LAYERS = 2;
+}
+
+namespace ObjectLayers {
+    static constexpr JPH_ObjectLayer NON_MOVING = 0;
+    static constexpr JPH_ObjectLayer MOVING = 1;
+    static constexpr uint32_t NUM_LAYERS = 2;
+}
+
+class SkeletonTest : public ::testing::Test {
+protected:
+    JPH_PhysicsSystem* physicsSystem = nullptr;
+    JPH_BroadPhaseLayerInterface* bpLayer = nullptr;
+    JPH_ObjectLayerPairFilter* objPairFilter = nullptr;
+    JPH_ObjectVsBroadPhaseLayerFilter* objVsBpFilter = nullptr;
+
+    void SetUp() override {
+        ASSERT_TRUE(JPH_Init());
+
+        bpLayer = JPH_BroadPhaseLayerInterfaceTable_Create(ObjectLayers::NUM_LAYERS, BroadPhaseLayers::NUM_LAYERS);
+        JPH_BroadPhaseLayerInterfaceTable_MapObjectToBroadPhaseLayer(bpLayer, ObjectLayers::NON_MOVING, BroadPhaseLayers::NON_MOVING);
+        JPH_BroadPhaseLayerInterfaceTable_MapObjectToBroadPhaseLayer(bpLayer, ObjectLayers::MOVING, BroadPhaseLayers::MOVING);
+
+        objPairFilter = JPH_ObjectLayerPairFilterTable_Create(ObjectLayers::NUM_LAYERS);
+        JPH_ObjectLayerPairFilterTable_EnableCollision(objPairFilter, ObjectLayers::NON_MOVING, ObjectLayers::MOVING);
+        JPH_ObjectLayerPairFilterTable_EnableCollision(objPairFilter, ObjectLayers::MOVING, ObjectLayers::MOVING);
+
+        objVsBpFilter = JPH_ObjectVsBroadPhaseLayerFilterTable_Create(
+            bpLayer, BroadPhaseLayers::NUM_LAYERS,
+            objPairFilter, ObjectLayers::NUM_LAYERS);
+
+        JPH_PhysicsSystemSettings settings = {};
+        settings.maxBodies = 1024;
+        settings.maxBodyPairs = 1024;
+        settings.maxContactConstraints = 1024;
+        settings.broadPhaseLayerInterface = bpLayer;
+        settings.objectVsBroadPhaseLayerFilter = objVsBpFilter;
+        settings.objectLayerPairFilter = objPairFilter;
+
+        physicsSystem = JPH_PhysicsSystem_Create(&settings);
+    }
+
+    void TearDown() override {
+        if (physicsSystem) JPH_PhysicsSystem_Destroy(physicsSystem);
+        JPH_Shutdown();
+    }
+};
+
+// ============================================================================
+// Skeleton Tests
+// ============================================================================
+
+TEST_F(SkeletonTest, Skeleton_Create) {
+    JPH_Skeleton* skeleton = JPH_Skeleton_Create();
+    ASSERT_NE(skeleton, nullptr);
+
+    EXPECT_EQ(JPH_Skeleton_GetJointCount(skeleton), 0);
+
+    JPH_Skeleton_Destroy(skeleton);
+}
+
+TEST_F(SkeletonTest, Skeleton_AddJoint) {
+    JPH_Skeleton* skeleton = JPH_Skeleton_Create();
+
+    uint32_t rootIndex = JPH_Skeleton_AddJoint(skeleton, "root");
+    EXPECT_EQ(rootIndex, 0u);
+    EXPECT_EQ(JPH_Skeleton_GetJointCount(skeleton), 1);
+
+    uint32_t childIndex = JPH_Skeleton_AddJoint2(skeleton, "child", 0);
+    EXPECT_EQ(childIndex, 1u);
+    EXPECT_EQ(JPH_Skeleton_GetJointCount(skeleton), 2);
+
+    JPH_Skeleton_Destroy(skeleton);
+}
+
+TEST_F(SkeletonTest, Skeleton_AddJointByName) {
+    JPH_Skeleton* skeleton = JPH_Skeleton_Create();
+
+    JPH_Skeleton_AddJoint(skeleton, "root");
+    uint32_t childIndex = JPH_Skeleton_AddJoint3(skeleton, "child", "root");
+    EXPECT_EQ(childIndex, 1u);
+
+    JPH_Skeleton_Destroy(skeleton);
+}
+
+TEST_F(SkeletonTest, Skeleton_GetJoint) {
+    JPH_Skeleton* skeleton = JPH_Skeleton_Create();
+
+    JPH_Skeleton_AddJoint(skeleton, "root");
+    JPH_Skeleton_AddJoint2(skeleton, "spine", 0);
+
+    JPH_SkeletonJoint joint;
+    JPH_Skeleton_GetJoint(skeleton, 0, &joint);
+    EXPECT_STREQ(joint.name, "root");
+    EXPECT_EQ(joint.parentJointIndex, -1);
+
+    JPH_Skeleton_GetJoint(skeleton, 1, &joint);
+    EXPECT_STREQ(joint.name, "spine");
+    EXPECT_EQ(joint.parentJointIndex, 0);
+
+    JPH_Skeleton_Destroy(skeleton);
+}
+
+TEST_F(SkeletonTest, Skeleton_GetJointIndex) {
+    JPH_Skeleton* skeleton = JPH_Skeleton_Create();
+
+    JPH_Skeleton_AddJoint(skeleton, "root");
+    JPH_Skeleton_AddJoint2(skeleton, "spine", 0);
+    JPH_Skeleton_AddJoint2(skeleton, "head", 1);
+
+    EXPECT_EQ(JPH_Skeleton_GetJointIndex(skeleton, "root"), 0);
+    EXPECT_EQ(JPH_Skeleton_GetJointIndex(skeleton, "spine"), 1);
+    EXPECT_EQ(JPH_Skeleton_GetJointIndex(skeleton, "head"), 2);
+    EXPECT_EQ(JPH_Skeleton_GetJointIndex(skeleton, "nonexistent"), -1);
+
+    JPH_Skeleton_Destroy(skeleton);
+}
+
+TEST_F(SkeletonTest, Skeleton_JointsCorrectlyOrdered) {
+    JPH_Skeleton* skeleton = JPH_Skeleton_Create();
+
+    JPH_Skeleton_AddJoint(skeleton, "root");
+    JPH_Skeleton_AddJoint2(skeleton, "child", 0);
+
+    EXPECT_TRUE(JPH_Skeleton_AreJointsCorrectlyOrdered(skeleton));
+
+    JPH_Skeleton_Destroy(skeleton);
+}
+
+// ============================================================================
+// SkeletonPose Tests
+// ============================================================================
+
+TEST_F(SkeletonTest, SkeletonPose_Create) {
+    JPH_SkeletonPose* pose = JPH_SkeletonPose_Create();
+    ASSERT_NE(pose, nullptr);
+
+    JPH_SkeletonPose_Destroy(pose);
+}
+
+TEST_F(SkeletonTest, SkeletonPose_SetSkeleton) {
+    JPH_Skeleton* skeleton = JPH_Skeleton_Create();
+    JPH_Skeleton_AddJoint(skeleton, "root");
+    JPH_Skeleton_AddJoint2(skeleton, "child", 0);
+
+    JPH_SkeletonPose* pose = JPH_SkeletonPose_Create();
+    JPH_SkeletonPose_SetSkeleton(pose, skeleton);
+
+    const JPH_Skeleton* retrievedSkeleton = JPH_SkeletonPose_GetSkeleton(pose);
+    EXPECT_EQ(retrievedSkeleton, skeleton);
+    EXPECT_EQ(JPH_SkeletonPose_GetJointCount(pose), 2);
+
+    JPH_SkeletonPose_Destroy(pose);
+    JPH_Skeleton_Destroy(skeleton);
+}
+
+TEST_F(SkeletonTest, SkeletonPose_RootOffset) {
+    JPH_SkeletonPose* pose = JPH_SkeletonPose_Create();
+
+    JPH_RVec3 offset = {1.0f, 2.0f, 3.0f};
+    JPH_SkeletonPose_SetRootOffset(pose, &offset);
+
+    JPH_RVec3 result;
+    JPH_SkeletonPose_GetRootOffset(pose, &result);
+    EXPECT_FLOAT_EQ(result.x, 1.0f);
+    EXPECT_FLOAT_EQ(result.y, 2.0f);
+    EXPECT_FLOAT_EQ(result.z, 3.0f);
+
+    JPH_SkeletonPose_Destroy(pose);
+}
+
+TEST_F(SkeletonTest, SkeletonPose_JointState) {
+    JPH_Skeleton* skeleton = JPH_Skeleton_Create();
+    JPH_Skeleton_AddJoint(skeleton, "root");
+
+    JPH_SkeletonPose* pose = JPH_SkeletonPose_Create();
+    JPH_SkeletonPose_SetSkeleton(pose, skeleton);
+
+    JPH_Vec3 translation = {1.0f, 2.0f, 3.0f};
+    JPH_Quat rotation = {0.0f, 0.0f, 0.0f, 1.0f};
+    JPH_SkeletonPose_SetJointState(pose, 0, &translation, &rotation);
+
+    JPH_Vec3 outTranslation;
+    JPH_Quat outRotation;
+    JPH_SkeletonPose_GetJointState(pose, 0, &outTranslation, &outRotation);
+    EXPECT_FLOAT_EQ(outTranslation.x, 1.0f);
+    EXPECT_FLOAT_EQ(outTranslation.y, 2.0f);
+    EXPECT_FLOAT_EQ(outTranslation.z, 3.0f);
+    EXPECT_FLOAT_EQ(outRotation.w, 1.0f);
+
+    JPH_SkeletonPose_Destroy(pose);
+    JPH_Skeleton_Destroy(skeleton);
+}
+
+// ============================================================================
+// RagdollSettings Tests
+// ============================================================================
+
+TEST_F(SkeletonTest, RagdollSettings_Create) {
+    JPH_RagdollSettings* settings = JPH_RagdollSettings_Create();
+    ASSERT_NE(settings, nullptr);
+
+    JPH_RagdollSettings_Destroy(settings);
+}
+
+TEST_F(SkeletonTest, RagdollSettings_SetSkeleton) {
+    JPH_Skeleton* skeleton = JPH_Skeleton_Create();
+    JPH_Skeleton_AddJoint(skeleton, "root");
+
+    JPH_RagdollSettings* settings = JPH_RagdollSettings_Create();
+    JPH_RagdollSettings_SetSkeleton(settings, skeleton);
+
+    const JPH_Skeleton* retrievedSkeleton = JPH_RagdollSettings_GetSkeleton(settings);
+    EXPECT_EQ(retrievedSkeleton, skeleton);
+
+    JPH_RagdollSettings_Destroy(settings);
+    JPH_Skeleton_Destroy(skeleton);
+}
+
+TEST_F(SkeletonTest, RagdollSettings_Parts) {
+    JPH_RagdollSettings* settings = JPH_RagdollSettings_Create();
+
+    JPH_RagdollSettings_ResizeParts(settings, 3);
+    EXPECT_EQ(JPH_RagdollSettings_GetPartCount(settings), 3);
+
+    // Set part properties
+    JPH_SphereShape* shape = JPH_SphereShape_Create(0.5f);
+    JPH_RVec3 position = {0.0f, 1.0f, 0.0f};
+    JPH_Quat rotation = {0.0f, 0.0f, 0.0f, 1.0f};
+
+    JPH_RagdollSettings_SetPartShape(settings, 0, (JPH_Shape*)shape);
+    JPH_RagdollSettings_SetPartPosition(settings, 0, &position);
+    JPH_RagdollSettings_SetPartRotation(settings, 0, &rotation);
+    JPH_RagdollSettings_SetPartMotionType(settings, 0, JPH_MotionType_Dynamic);
+    JPH_RagdollSettings_SetPartObjectLayer(settings, 0, ObjectLayers::MOVING);
+
+    JPH_RagdollSettings_Destroy(settings);
+    JPH_Shape_Destroy((JPH_Shape*)shape);
+}
+
+// ============================================================================
+// Ragdoll Tests
+// ============================================================================
+
+TEST_F(SkeletonTest, Ragdoll_CreateSimple) {
+    // Create skeleton
+    JPH_Skeleton* skeleton = JPH_Skeleton_Create();
+    JPH_Skeleton_AddJoint(skeleton, "root");
+
+    // Create ragdoll settings
+    JPH_RagdollSettings* settings = JPH_RagdollSettings_Create();
+    JPH_RagdollSettings_SetSkeleton(settings, skeleton);
+    JPH_RagdollSettings_ResizeParts(settings, 1);
+
+    // Set up part
+    JPH_SphereShape* shape = JPH_SphereShape_Create(0.5f);
+    JPH_RVec3 position = {0.0f, 1.0f, 0.0f};
+    JPH_Quat rotation = {0.0f, 0.0f, 0.0f, 1.0f};
+
+    JPH_RagdollSettings_SetPartShape(settings, 0, (JPH_Shape*)shape);
+    JPH_RagdollSettings_SetPartPosition(settings, 0, &position);
+    JPH_RagdollSettings_SetPartRotation(settings, 0, &rotation);
+    JPH_RagdollSettings_SetPartMotionType(settings, 0, JPH_MotionType_Dynamic);
+    JPH_RagdollSettings_SetPartObjectLayer(settings, 0, ObjectLayers::MOVING);
+
+    // Create ragdoll
+    JPH_Ragdoll* ragdoll = JPH_RagdollSettings_CreateRagdoll(settings, physicsSystem, 0, 0);
+    ASSERT_NE(ragdoll, nullptr);
+
+    EXPECT_EQ(JPH_Ragdoll_GetBodyCount(ragdoll), 1);
+
+    JPH_BodyID bodyId = JPH_Ragdoll_GetBodyID(ragdoll, 0);
+    EXPECT_NE(bodyId, 0xFFFFFFFF);
+
+    JPH_Ragdoll_Destroy(ragdoll);
+    JPH_RagdollSettings_Destroy(settings);
+    JPH_Shape_Destroy((JPH_Shape*)shape);
+    JPH_Skeleton_Destroy(skeleton);
+}
+
+TEST_F(SkeletonTest, Ragdoll_AddRemoveFromPhysicsSystem) {
+    // Create skeleton
+    JPH_Skeleton* skeleton = JPH_Skeleton_Create();
+    JPH_Skeleton_AddJoint(skeleton, "root");
+
+    // Create ragdoll settings
+    JPH_RagdollSettings* settings = JPH_RagdollSettings_Create();
+    JPH_RagdollSettings_SetSkeleton(settings, skeleton);
+    JPH_RagdollSettings_ResizeParts(settings, 1);
+
+    JPH_SphereShape* shape = JPH_SphereShape_Create(0.5f);
+    JPH_RVec3 position = {0.0f, 1.0f, 0.0f};
+    JPH_Quat rotation = {0.0f, 0.0f, 0.0f, 1.0f};
+
+    JPH_RagdollSettings_SetPartShape(settings, 0, (JPH_Shape*)shape);
+    JPH_RagdollSettings_SetPartPosition(settings, 0, &position);
+    JPH_RagdollSettings_SetPartRotation(settings, 0, &rotation);
+    JPH_RagdollSettings_SetPartMotionType(settings, 0, JPH_MotionType_Dynamic);
+    JPH_RagdollSettings_SetPartObjectLayer(settings, 0, ObjectLayers::MOVING);
+
+    JPH_Ragdoll* ragdoll = JPH_RagdollSettings_CreateRagdoll(settings, physicsSystem, 0, 0);
+
+    // Add to physics system
+    JPH_Ragdoll_AddToPhysicsSystem(ragdoll, JPH_Activation_Activate, true);
+    EXPECT_TRUE(JPH_Ragdoll_IsActive(ragdoll, true));
+
+    // Remove from physics system
+    JPH_Ragdoll_RemoveFromPhysicsSystem(ragdoll, true);
+
+    JPH_Ragdoll_Destroy(ragdoll);
+    JPH_RagdollSettings_Destroy(settings);
+    JPH_Shape_Destroy((JPH_Shape*)shape);
+    JPH_Skeleton_Destroy(skeleton);
+}
+
+TEST_F(SkeletonTest, Ragdoll_GetRootTransform) {
+    JPH_Skeleton* skeleton = JPH_Skeleton_Create();
+    JPH_Skeleton_AddJoint(skeleton, "root");
+
+    JPH_RagdollSettings* settings = JPH_RagdollSettings_Create();
+    JPH_RagdollSettings_SetSkeleton(settings, skeleton);
+    JPH_RagdollSettings_ResizeParts(settings, 1);
+
+    JPH_SphereShape* shape = JPH_SphereShape_Create(0.5f);
+    JPH_RVec3 position = {1.0f, 2.0f, 3.0f};
+    JPH_Quat rotation = {0.0f, 0.0f, 0.0f, 1.0f};
+
+    JPH_RagdollSettings_SetPartShape(settings, 0, (JPH_Shape*)shape);
+    JPH_RagdollSettings_SetPartPosition(settings, 0, &position);
+    JPH_RagdollSettings_SetPartRotation(settings, 0, &rotation);
+    JPH_RagdollSettings_SetPartMotionType(settings, 0, JPH_MotionType_Dynamic);
+    JPH_RagdollSettings_SetPartObjectLayer(settings, 0, ObjectLayers::MOVING);
+
+    JPH_Ragdoll* ragdoll = JPH_RagdollSettings_CreateRagdoll(settings, physicsSystem, 0, 0);
+    JPH_Ragdoll_AddToPhysicsSystem(ragdoll, JPH_Activation_Activate, true);
+
+    JPH_RVec3 outPosition;
+    JPH_Quat outRotation;
+    JPH_Ragdoll_GetRootTransform(ragdoll, &outPosition, &outRotation, true);
+
+    EXPECT_FLOAT_EQ(outPosition.x, 1.0f);
+    EXPECT_FLOAT_EQ(outPosition.y, 2.0f);
+    EXPECT_FLOAT_EQ(outPosition.z, 3.0f);
+
+    JPH_Ragdoll_RemoveFromPhysicsSystem(ragdoll, true);
+    JPH_Ragdoll_Destroy(ragdoll);
+    JPH_RagdollSettings_Destroy(settings);
+    JPH_Shape_Destroy((JPH_Shape*)shape);
+    JPH_Skeleton_Destroy(skeleton);
+}
+
+// ============================================================================
+// SkeletonMapper Tests
+// ============================================================================
+
+TEST_F(SkeletonTest, SkeletonMapper_Create) {
+    JPH_SkeletonMapper* mapper = JPH_SkeletonMapper_Create();
+    ASSERT_NE(mapper, nullptr);
+
+    JPH_SkeletonMapper_Destroy(mapper);
+}

data/ext/joltc/tests/test_vehicle.cpp

@@ -0,0 +1,319 @@
+// Copyright (c) Amer Koleci and Contributors.
+// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information.
+
+#include <gtest/gtest.h>
+#include "joltc.h"
+
+namespace BroadPhaseLayers {
+    static constexpr JPH_BroadPhaseLayer NON_MOVING = 0;
+    static constexpr JPH_BroadPhaseLayer MOVING = 1;
+    static constexpr uint32_t NUM_LAYERS = 2;
+}
+
+namespace ObjectLayers {
+    static constexpr JPH_ObjectLayer NON_MOVING = 0;
+    static constexpr JPH_ObjectLayer MOVING = 1;
+    static constexpr uint32_t NUM_LAYERS = 2;
+}
+
+class VehicleTest : public ::testing::Test {
+protected:
+    JPH_PhysicsSystem* physicsSystem = nullptr;
+    JPH_BodyInterface* bodyInterface = nullptr;
+    JPH_BroadPhaseLayerInterface* bpLayer = nullptr;
+    JPH_ObjectLayerPairFilter* objPairFilter = nullptr;
+    JPH_ObjectVsBroadPhaseLayerFilter* objVsBpFilter = nullptr;
+
+    void SetUp() override {
+        ASSERT_TRUE(JPH_Init());
+
+        bpLayer = JPH_BroadPhaseLayerInterfaceTable_Create(ObjectLayers::NUM_LAYERS, BroadPhaseLayers::NUM_LAYERS);
+        JPH_BroadPhaseLayerInterfaceTable_MapObjectToBroadPhaseLayer(bpLayer, ObjectLayers::NON_MOVING, BroadPhaseLayers::NON_MOVING);
+        JPH_BroadPhaseLayerInterfaceTable_MapObjectToBroadPhaseLayer(bpLayer, ObjectLayers::MOVING, BroadPhaseLayers::MOVING);
+
+        objPairFilter = JPH_ObjectLayerPairFilterTable_Create(ObjectLayers::NUM_LAYERS);
+        JPH_ObjectLayerPairFilterTable_EnableCollision(objPairFilter, ObjectLayers::NON_MOVING, ObjectLayers::MOVING);
+        JPH_ObjectLayerPairFilterTable_EnableCollision(objPairFilter, ObjectLayers::MOVING, ObjectLayers::MOVING);
+
+        objVsBpFilter = JPH_ObjectVsBroadPhaseLayerFilterTable_Create(
+            bpLayer, BroadPhaseLayers::NUM_LAYERS,
+            objPairFilter, ObjectLayers::NUM_LAYERS);
+
+        JPH_PhysicsSystemSettings settings = {};
+        settings.maxBodies = 1024;
+        settings.maxBodyPairs = 1024;
+        settings.maxContactConstraints = 1024;
+        settings.broadPhaseLayerInterface = bpLayer;
+        settings.objectVsBroadPhaseLayerFilter = objVsBpFilter;
+        settings.objectLayerPairFilter = objPairFilter;
+
+        physicsSystem = JPH_PhysicsSystem_Create(&settings);
+        bodyInterface = JPH_PhysicsSystem_GetBodyInterface(physicsSystem);
+    }
+
+    void TearDown() override {
+        if (physicsSystem) JPH_PhysicsSystem_Destroy(physicsSystem);
+        JPH_Shutdown();
+    }
+};
+
+// ============================================================================
+// WheelSettings Tests
+// ============================================================================
+
+TEST_F(VehicleTest, WheelSettings_Create) {
+    JPH_WheelSettings* settings = JPH_WheelSettings_Create();
+    ASSERT_NE(settings, nullptr);
+
+    JPH_WheelSettings_Destroy(settings);
+}
+
+TEST_F(VehicleTest, WheelSettings_Position) {
+    JPH_WheelSettings* settings = JPH_WheelSettings_Create();
+
+    JPH_Vec3 pos = {1.0f, 0.0f, 2.0f};
+    JPH_WheelSettings_SetPosition(settings, &pos);
+
+    JPH_Vec3 result;
+    JPH_WheelSettings_GetPosition(settings, &result);
+    EXPECT_FLOAT_EQ(result.x, 1.0f);
+    EXPECT_FLOAT_EQ(result.z, 2.0f);
+
+    JPH_WheelSettings_Destroy(settings);
+}
+
+TEST_F(VehicleTest, WheelSettings_Radius) {
+    JPH_WheelSettings* settings = JPH_WheelSettings_Create();
+
+    JPH_WheelSettings_SetRadius(settings, 0.5f);
+    EXPECT_FLOAT_EQ(JPH_WheelSettings_GetRadius(settings), 0.5f);
+
+    JPH_WheelSettings_Destroy(settings);
+}
+
+TEST_F(VehicleTest, WheelSettings_Width) {
+    JPH_WheelSettings* settings = JPH_WheelSettings_Create();
+
+    JPH_WheelSettings_SetWidth(settings, 0.3f);
+    EXPECT_FLOAT_EQ(JPH_WheelSettings_GetWidth(settings), 0.3f);
+
+    JPH_WheelSettings_Destroy(settings);
+}
+
+TEST_F(VehicleTest, WheelSettings_Suspension) {
+    JPH_WheelSettings* settings = JPH_WheelSettings_Create();
+
+    JPH_WheelSettings_SetSuspensionMinLength(settings, 0.1f);
+    JPH_WheelSettings_SetSuspensionMaxLength(settings, 0.5f);
+
+    EXPECT_FLOAT_EQ(JPH_WheelSettings_GetSuspensionMinLength(settings), 0.1f);
+    EXPECT_FLOAT_EQ(JPH_WheelSettings_GetSuspensionMaxLength(settings), 0.5f);
+
+    JPH_WheelSettings_Destroy(settings);
+}
+
+// ============================================================================
+// Wheel Tests
+// ============================================================================
+
+TEST_F(VehicleTest, Wheel_Create) {
+    JPH_WheelSettings* settings = JPH_WheelSettings_Create();
+    JPH_Wheel* wheel = JPH_Wheel_Create(settings);
+    ASSERT_NE(wheel, nullptr);
+
+    JPH_Wheel_Destroy(wheel);
+    JPH_WheelSettings_Destroy(settings);
+}
+
+TEST_F(VehicleTest, Wheel_AngularVelocity) {
+    JPH_WheelSettings* settings = JPH_WheelSettings_Create();
+    JPH_Wheel* wheel = JPH_Wheel_Create(settings);
+
+    JPH_Wheel_SetAngularVelocity(wheel, 10.0f);
+    EXPECT_FLOAT_EQ(JPH_Wheel_GetAngularVelocity(wheel), 10.0f);
+
+    JPH_Wheel_Destroy(wheel);
+    JPH_WheelSettings_Destroy(settings);
+}
+
+TEST_F(VehicleTest, Wheel_RotationAngle) {
+    JPH_WheelSettings* settings = JPH_WheelSettings_Create();
+    JPH_Wheel* wheel = JPH_Wheel_Create(settings);
+
+    JPH_Wheel_SetRotationAngle(wheel, JPH_M_PI / 4.0f);
+    EXPECT_NEAR(JPH_Wheel_GetRotationAngle(wheel), JPH_M_PI / 4.0f, 0.001f);
+
+    JPH_Wheel_Destroy(wheel);
+    JPH_WheelSettings_Destroy(settings);
+}
+
+TEST_F(VehicleTest, Wheel_SteerAngle) {
+    JPH_WheelSettings* settings = JPH_WheelSettings_Create();
+    JPH_Wheel* wheel = JPH_Wheel_Create(settings);
+
+    JPH_Wheel_SetSteerAngle(wheel, 0.1f);
+    EXPECT_FLOAT_EQ(JPH_Wheel_GetSteerAngle(wheel), 0.1f);
+
+    JPH_Wheel_Destroy(wheel);
+    JPH_WheelSettings_Destroy(settings);
+}
+
+// ============================================================================
+// VehicleCollisionTester Tests
+// ============================================================================
+
+TEST_F(VehicleTest, VehicleCollisionTesterRay_Create) {
+    JPH_Vec3 up = {0.0f, 1.0f, 0.0f};
+    JPH_VehicleCollisionTesterRay* tester = JPH_VehicleCollisionTesterRay_Create(ObjectLayers::MOVING, &up, JPH_M_PI / 4.0f);
+    ASSERT_NE(tester, nullptr);
+
+    EXPECT_EQ(JPH_VehicleCollisionTester_GetObjectLayer((JPH_VehicleCollisionTester*)tester), ObjectLayers::MOVING);
+
+    JPH_VehicleCollisionTester_Destroy((JPH_VehicleCollisionTester*)tester);
+}
+
+TEST_F(VehicleTest, VehicleCollisionTesterCastSphere_Create) {
+    JPH_Vec3 up = {0.0f, 1.0f, 0.0f};
+    JPH_VehicleCollisionTesterCastSphere* tester = JPH_VehicleCollisionTesterCastSphere_Create(ObjectLayers::MOVING, 0.1f, &up, JPH_M_PI / 4.0f);
+    ASSERT_NE(tester, nullptr);
+
+    JPH_VehicleCollisionTester_Destroy((JPH_VehicleCollisionTester*)tester);
+}
+
+TEST_F(VehicleTest, VehicleCollisionTesterCastCylinder_Create) {
+    JPH_VehicleCollisionTesterCastCylinder* tester = JPH_VehicleCollisionTesterCastCylinder_Create(ObjectLayers::MOVING, 0.05f);
+    ASSERT_NE(tester, nullptr);
+
+    JPH_VehicleCollisionTester_Destroy((JPH_VehicleCollisionTester*)tester);
+}
+
+// ============================================================================
+// VehicleEngineSettings Tests
+// ============================================================================
+
+TEST_F(VehicleTest, VehicleEngineSettings_Init) {
+    JPH_VehicleEngineSettings settings;
+    JPH_VehicleEngineSettings_Init(&settings);
+
+    EXPECT_GT(settings.maxRPM, 0.0f);
+    EXPECT_GT(settings.maxTorque, 0.0f);
+}
+
+// ============================================================================
+// VehicleDifferentialSettings Tests
+// ============================================================================
+
+TEST_F(VehicleTest, VehicleDifferentialSettings_Init) {
+    JPH_VehicleDifferentialSettings settings;
+    JPH_VehicleDifferentialSettings_Init(&settings);
+
+    // Default values should be set
+    EXPECT_GE(settings.leftWheel, -1);
+}
+
+// ============================================================================
+// VehicleTransmissionSettings Tests
+// ============================================================================
+
+TEST_F(VehicleTest, VehicleTransmissionSettings_Create) {
+    JPH_VehicleTransmissionSettings* settings = JPH_VehicleTransmissionSettings_Create();
+    ASSERT_NE(settings, nullptr);
+
+    JPH_VehicleTransmissionSettings_Destroy(settings);
+}
+
+TEST_F(VehicleTest, VehicleTransmissionSettings_Mode) {
+    JPH_VehicleTransmissionSettings* settings = JPH_VehicleTransmissionSettings_Create();
+
+    JPH_VehicleTransmissionSettings_SetMode(settings, JPH_TransmissionMode_Manual);
+    EXPECT_EQ(JPH_VehicleTransmissionSettings_GetMode(settings), JPH_TransmissionMode_Manual);
+
+    JPH_VehicleTransmissionSettings_SetMode(settings, JPH_TransmissionMode_Auto);
+    EXPECT_EQ(JPH_VehicleTransmissionSettings_GetMode(settings), JPH_TransmissionMode_Auto);
+
+    JPH_VehicleTransmissionSettings_Destroy(settings);
+}
+
+TEST_F(VehicleTest, VehicleTransmissionSettings_GearRatios) {
+    JPH_VehicleTransmissionSettings* settings = JPH_VehicleTransmissionSettings_Create();
+
+    float gears[] = {3.0f, 2.0f, 1.5f, 1.0f, 0.8f};
+    JPH_VehicleTransmissionSettings_SetGearRatios(settings, gears, 5);
+
+    EXPECT_EQ(JPH_VehicleTransmissionSettings_GetGearRatioCount(settings), 5u);
+    EXPECT_FLOAT_EQ(JPH_VehicleTransmissionSettings_GetGearRatio(settings, 0), 3.0f);
+    EXPECT_FLOAT_EQ(JPH_VehicleTransmissionSettings_GetGearRatio(settings, 4), 0.8f);
+
+    JPH_VehicleTransmissionSettings_Destroy(settings);
+}
+
+TEST_F(VehicleTest, VehicleTransmissionSettings_Timing) {
+    JPH_VehicleTransmissionSettings* settings = JPH_VehicleTransmissionSettings_Create();
+
+    JPH_VehicleTransmissionSettings_SetSwitchTime(settings, 0.5f);
+    EXPECT_FLOAT_EQ(JPH_VehicleTransmissionSettings_GetSwitchTime(settings), 0.5f);
+
+    JPH_VehicleTransmissionSettings_SetClutchReleaseTime(settings, 0.3f);
+    EXPECT_FLOAT_EQ(JPH_VehicleTransmissionSettings_GetClutchReleaseTime(settings), 0.3f);
+
+    JPH_VehicleTransmissionSettings_SetShiftUpRPM(settings, 5000.0f);
+    EXPECT_FLOAT_EQ(JPH_VehicleTransmissionSettings_GetShiftUpRPM(settings), 5000.0f);
+
+    JPH_VehicleTransmissionSettings_SetShiftDownRPM(settings, 2000.0f);
+    EXPECT_FLOAT_EQ(JPH_VehicleTransmissionSettings_GetShiftDownRPM(settings), 2000.0f);
+
+    JPH_VehicleTransmissionSettings_Destroy(settings);
+}
+
+// ============================================================================
+// WheeledVehicleControllerSettings Tests
+// ============================================================================
+
+TEST_F(VehicleTest, WheeledVehicleControllerSettings_Create) {
+    JPH_WheeledVehicleControllerSettings* settings = JPH_WheeledVehicleControllerSettings_Create();
+    ASSERT_NE(settings, nullptr);
+
+    JPH_VehicleControllerSettings_Destroy((JPH_VehicleControllerSettings*)settings);
+}
+
+TEST_F(VehicleTest, WheeledVehicleControllerSettings_Engine) {
+    JPH_WheeledVehicleControllerSettings* settings = JPH_WheeledVehicleControllerSettings_Create();
+
+    JPH_VehicleEngineSettings engineSettings;
+    JPH_VehicleEngineSettings_Init(&engineSettings);
+    engineSettings.maxRPM = 8000.0f;
+    engineSettings.maxTorque = 500.0f;
+
+    JPH_WheeledVehicleControllerSettings_SetEngine(settings, &engineSettings);
+
+    JPH_VehicleEngineSettings result;
+    JPH_WheeledVehicleControllerSettings_GetEngine(settings, &result);
+    EXPECT_FLOAT_EQ(result.maxRPM, 8000.0f);
+    EXPECT_FLOAT_EQ(result.maxTorque, 500.0f);
+
+    JPH_VehicleControllerSettings_Destroy((JPH_VehicleControllerSettings*)settings);
+}
+
+// ============================================================================
+// VehicleAntiRollBar Tests
+// ============================================================================
+
+TEST_F(VehicleTest, VehicleAntiRollBar_Init) {
+    JPH_VehicleAntiRollBar antiRollBar;
+    JPH_VehicleAntiRollBar_Init(&antiRollBar);
+
+    // Default values should be set
+    EXPECT_GE(antiRollBar.leftWheel, 0);
+}
+
+// ============================================================================
+// VehicleConstraintSettings Tests
+// ============================================================================
+
+TEST_F(VehicleTest, VehicleConstraintSettings_Init) {
+    JPH_VehicleConstraintSettings settings;
+    JPH_VehicleConstraintSettings_Init(&settings);
+
+    // Default forward should be set
+    EXPECT_FALSE(settings.forward.x == 0.0f && settings.forward.y == 0.0f && settings.forward.z == 0.0f);
+}