diff --git a/docs/SupportedAssetTypes.md b/docs/SupportedAssetTypes.md index f203c775..e3bf0211 100644 --- a/docs/SupportedAssetTypes.md +++ b/docs/SupportedAssetTypes.md @@ -75,7 +75,7 @@ using `Linker`): | LeaderboardDef | ✅ | ✅ | | | StructuredDataDefSet | ✅ | ✅ | The format is custom due to lacking information about original format. | | TracerDef | ✅ | ✅ | | -| VehicleDef | ✅ | ❌ | | +| VehicleDef | ✅ | ✅ | | | AddonMapEnts | ⁉️ | ❌ | MapEnts String can be exported. Binary data currently not. | ## IW5 (Call of Duty: Modern Warfare 3) @@ -120,7 +120,7 @@ using `Linker`): | LeaderboardDef | ✅ | ✅ | | | StructuredDataDefSet | ❌ | ❌ | | | TracerDef | ✅ | ✅ | | -| VehicleDef | ❌ | ❌ | | +| VehicleDef | ✅ | ✅ | | | AddonMapEnts | ⁉️ | ❌ | MapEnts String can be exported. Binary data currently not. | ## T4 (Call of Duty: World at War) diff --git a/src/Common/Game/IW5/IW5.h b/src/Common/Game/IW5/IW5.h index b6d2c619..07d6b060 100644 --- a/src/Common/Game/IW5/IW5.h +++ b/src/Common/Game/IW5/IW5.h @@ -205,6 +205,18 @@ namespace IW5 PPFT_NUM_FIELD_TYPES, }; + enum VehicleFieldType + { + VFT_TYPE = CSPFT_NUM_BASE_FIELD_TYPES, + VFT_AXLE_STEERING, + VFT_AXLE_POWER, + VFT_AXLE_BRAKING, + VFT_TROPHY_TAGS, + VFT_CAM_Z_OFFSET_MODE, + + VFT_NUM, + }; + struct AccuracyGraph { vec2_t* graphKnots; diff --git a/src/Common/Game/IW5/IW5_Assets.h b/src/Common/Game/IW5/IW5_Assets.h index 4a667b9b..4851db86 100644 --- a/src/Common/Game/IW5/IW5_Assets.h +++ b/src/Common/Game/IW5/IW5_Assets.h @@ -5173,7 +5173,8 @@ namespace IW5 VEHCAM_ZMODE_WORLD = 0x0, VEHCAM_ZMODE_VEHICLE = 0x1, VEHCAM_ZMODE_VIEW = 0x2, - VEHCAM_ZMODE_COUNT = 0x3 + + VEHCAM_ZMODE_COUNT }; struct VehiclePhysDef diff --git a/src/ObjCommon/Game/IW4/InfoString/EnumStrings.h b/src/ObjCommon/Game/IW4/InfoString/EnumStrings.h index 2a062838..21423f95 100644 --- a/src/ObjCommon/Game/IW4/InfoString/EnumStrings.h +++ b/src/ObjCommon/Game/IW4/InfoString/EnumStrings.h @@ -158,22 +158,6 @@ namespace IW4 "4:1", }; - inline const char* s_vehicleClassNames[]{ - "4 wheel", - "tank", - "plane", - "boat", - "artillery", - "helicopter", - "snowmobile", - }; - - inline const char* s_vehicleAxleTypeNames[]{ - "front", - "rear", - "all", - }; - inline const char* bounceSoundSuffixes[]{ "_default", "_bark", "_brick", "_carpet", "_cloth", "_concrete", "_dirt", "_flesh", "_foliage", "_glass", "_grass", "_gravel", "_ice", "_metal", "_mud", "_paper", "_plaster", "_rock", "_sand", "_snow", "_water", "_wood", diff --git a/src/ObjCommon/Game/IW4/Vehicle/VehicleFields.h b/src/ObjCommon/Game/IW4/Vehicle/VehicleFieldsIW4.h similarity index 99% rename from src/ObjCommon/Game/IW4/Vehicle/VehicleFields.h rename to src/ObjCommon/Game/IW4/Vehicle/VehicleFieldsIW4.h index 7e472a6a..368b1e5f 100644 --- a/src/ObjCommon/Game/IW4/Vehicle/VehicleFields.h +++ b/src/ObjCommon/Game/IW4/Vehicle/VehicleFieldsIW4.h @@ -8,7 +8,7 @@ namespace IW4 {"useHintString", offsetof(VehicleDef, useHintString), CSPFT_STRING }, {"health", offsetof(VehicleDef, health), CSPFT_INT }, {"quadBarrel", offsetof(VehicleDef, quadBarrel), CSPFT_QBOOLEAN }, - {"texureScrollScale", offsetof(VehicleDef, texScrollScale), CSPFT_FLOAT }, + {"textureScrollScale", offsetof(VehicleDef, texScrollScale), CSPFT_FLOAT }, {"topSpeed", offsetof(VehicleDef, topSpeed), CSPFT_MPH_TO_INCHES_PER_SEC}, {"accel", offsetof(VehicleDef, accel), CSPFT_MPH_TO_INCHES_PER_SEC}, {"rotRate", offsetof(VehicleDef, rotRate), CSPFT_FLOAT }, diff --git a/src/ObjCommon/Game/IW4/Vehicle/VehicleStringsIW4.h b/src/ObjCommon/Game/IW4/Vehicle/VehicleStringsIW4.h new file mode 100644 index 00000000..0f6bebb7 --- /dev/null +++ b/src/ObjCommon/Game/IW4/Vehicle/VehicleStringsIW4.h @@ -0,0 +1,24 @@ +#pragma once + +#include "Game/IW4/IW4.h" + +namespace IW4 +{ + inline const char* s_vehicleClassNames[]{ + "4 wheel", + "tank", + "plane", + "boat", + "artillery", + "helicopter", + "snowmobile", + }; + static_assert(std::extent_v == VEH_TYPE_COUNT); + + inline const char* s_vehicleAxleTypeNames[]{ + "front", + "rear", + "all", + }; + static_assert(std::extent_v == VEH_AXLE_COUNT); +} // namespace IW4 diff --git a/src/ObjCommon/Game/IW5/Vehicle/VehicleFieldsIW5.h b/src/ObjCommon/Game/IW5/Vehicle/VehicleFieldsIW5.h new file mode 100644 index 00000000..7380e6f3 --- /dev/null +++ b/src/ObjCommon/Game/IW5/Vehicle/VehicleFieldsIW5.h @@ -0,0 +1,226 @@ +#pragma once +#include "Game/IW5/IW5.h" + +namespace IW5 +{ + inline cspField_t vehicle_fields[]{ + {"type", offsetof(VehicleDef, type), VFT_TYPE }, + {"useHintString", offsetof(VehicleDef, useHintString), CSPFT_STRING }, + {"health", offsetof(VehicleDef, health), CSPFT_INT }, + {"quadBarrel", offsetof(VehicleDef, quadBarrel), CSPFT_QBOOLEAN }, + {"textureScrollScale", offsetof(VehicleDef, texScrollScale), CSPFT_FLOAT }, + {"topSpeed", offsetof(VehicleDef, topSpeed), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"accel", offsetof(VehicleDef, accel), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"rotRate", offsetof(VehicleDef, rotRate), CSPFT_FLOAT }, + {"rotAccel", offsetof(VehicleDef, rotAccel), CSPFT_FLOAT }, + {"maxBodyPitch", offsetof(VehicleDef, maxBodyPitch), CSPFT_FLOAT }, + {"maxBodyRoll", offsetof(VehicleDef, maxBodyRoll), CSPFT_FLOAT }, + {"fakeBodyStabilizer", offsetof(VehicleDef, fakeBodyStabilizer), CSPFT_QBOOLEAN }, + {"fakeBodyAccelPitch", offsetof(VehicleDef, fakeBodyAccelPitch), CSPFT_FLOAT }, + {"fakeBodyAccelRoll", offsetof(VehicleDef, fakeBodyAccelRoll), CSPFT_FLOAT }, + {"fakeBodyVelPitch", offsetof(VehicleDef, fakeBodyVelPitch), CSPFT_FLOAT }, + {"fakeBodyVelRoll", offsetof(VehicleDef, fakeBodyVelRoll), CSPFT_FLOAT }, + {"fakeBodySideVelPitch", offsetof(VehicleDef, fakeBodySideVelPitch), CSPFT_FLOAT }, + {"fakeBodyPitchStrength", offsetof(VehicleDef, fakeBodyPitchStrength), CSPFT_FLOAT }, + {"fakeBodyRollStrength", offsetof(VehicleDef, fakeBodyRollStrength), CSPFT_FLOAT }, + {"fakeBodyPitchDampening", offsetof(VehicleDef, fakeBodyPitchDampening), CSPFT_FLOAT }, + {"fakeBodyRollDampening", offsetof(VehicleDef, fakeBodyRollDampening), CSPFT_FLOAT }, + {"fakeBodyBoatRockingAmplitude", offsetof(VehicleDef, fakeBodyBoatRockingAmplitude), CSPFT_FLOAT }, + {"fakeBodyBoatRockingPeriod", offsetof(VehicleDef, fakeBodyBoatRockingPeriod), CSPFT_FLOAT }, + {"fakeBodyBoatRockingRotationPeriod", offsetof(VehicleDef, fakeBodyBoatRockingRotationPeriod), CSPFT_FLOAT }, + {"fakeBodyBoatRockingFadeoutSpeed", offsetof(VehicleDef, fakeBodyBoatRockingFadeoutSpeed), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"boatBouncingMinForce", offsetof(VehicleDef, boatBouncingMinForce), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"boatBouncingMaxForce", offsetof(VehicleDef, boatBouncingMaxForce), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"boatBouncingRate", offsetof(VehicleDef, boatBouncingRate), CSPFT_FLOAT }, + {"boatBouncingFadeinSpeed", offsetof(VehicleDef, boatBouncingFadeinSpeed), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"boatBouncingFadeoutSteeringAngle", offsetof(VehicleDef, boatBouncingFadeoutSteeringAngle), CSPFT_FLOAT }, + {"collisionDamage", offsetof(VehicleDef, collisionDamage), CSPFT_FLOAT }, + {"collisionSpeed", offsetof(VehicleDef, collisionSpeed), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"killcamZDist", offsetof(VehicleDef, killcamOffset[0]), CSPFT_FLOAT }, + {"killcamBackDist", offsetof(VehicleDef, killcamOffset[1]), CSPFT_FLOAT }, + {"killcamUpDist", offsetof(VehicleDef, killcamOffset[2]), CSPFT_FLOAT }, + {"playerProtected", offsetof(VehicleDef, playerProtected), CSPFT_QBOOLEAN }, + {"bulletDamage", offsetof(VehicleDef, bulletDamage), CSPFT_QBOOLEAN }, + {"armorPiercingDamage", offsetof(VehicleDef, armorPiercingDamage), CSPFT_QBOOLEAN }, + {"grenadeDamage", offsetof(VehicleDef, grenadeDamage), CSPFT_QBOOLEAN }, + {"projectileDamage", offsetof(VehicleDef, projectileDamage), CSPFT_QBOOLEAN }, + {"projectileSplashDamage", offsetof(VehicleDef, projectileSplashDamage), CSPFT_QBOOLEAN }, + {"heavyExplosiveDamage", offsetof(VehicleDef, heavyExplosiveDamage), CSPFT_QBOOLEAN }, + {"physicsEnabled", offsetof(VehicleDef, vehPhysDef.physicsEnabled), CSPFT_QBOOLEAN }, + {"physicsPreset", offsetof(VehicleDef, vehPhysDef.physPresetName), CSPFT_STRING }, + {"accelerationGraph", offsetof(VehicleDef, vehPhysDef.accelGraphName), CSPFT_STRING }, + {"steeringAxle", offsetof(VehicleDef, vehPhysDef.steeringAxle), VFT_AXLE_STEERING }, + {"powerAxle", offsetof(VehicleDef, vehPhysDef.powerAxle), VFT_AXLE_POWER }, + {"brakingAxle", offsetof(VehicleDef, vehPhysDef.brakingAxle), VFT_AXLE_BRAKING }, + {"reverseSpeed", offsetof(VehicleDef, vehPhysDef.reverseSpeed), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"maxVelocity", offsetof(VehicleDef, vehPhysDef.maxVelocity), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"maxPitch", offsetof(VehicleDef, vehPhysDef.maxPitch), CSPFT_FLOAT }, + {"maxRoll", offsetof(VehicleDef, vehPhysDef.maxRoll), CSPFT_FLOAT }, + {"suspensionTravelRear", offsetof(VehicleDef, vehPhysDef.suspensionTravelRear), CSPFT_FLOAT }, + {"suspensionStrengthFront", offsetof(VehicleDef, vehPhysDef.suspensionStrengthFront), CSPFT_FLOAT }, + {"suspensionDampingFront", offsetof(VehicleDef, vehPhysDef.suspensionDampingFront), CSPFT_FLOAT }, + {"suspensionStrengthRear", offsetof(VehicleDef, vehPhysDef.suspensionStrengthRear), CSPFT_FLOAT }, + {"suspensionDampingRear", offsetof(VehicleDef, vehPhysDef.suspensionDampingRear), CSPFT_FLOAT }, + {"frictionBraking", offsetof(VehicleDef, vehPhysDef.frictionBraking), CSPFT_FLOAT }, + {"frictionCoasting", offsetof(VehicleDef, vehPhysDef.frictionCoasting), CSPFT_FLOAT }, + {"frictionTopSpeed", offsetof(VehicleDef, vehPhysDef.frictionTopSpeed), CSPFT_FLOAT }, + {"frictionSide", offsetof(VehicleDef, vehPhysDef.frictionSide), CSPFT_FLOAT }, + {"frictionSideRear", offsetof(VehicleDef, vehPhysDef.frictionSideRear), CSPFT_FLOAT }, + {"velocityDependentSlip", offsetof(VehicleDef, vehPhysDef.velocityDependentSlip), CSPFT_FLOAT }, + {"rollStability", offsetof(VehicleDef, vehPhysDef.rollStability), CSPFT_FLOAT }, + {"rollResistance", offsetof(VehicleDef, vehPhysDef.rollResistance), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"pitchResistance", offsetof(VehicleDef, vehPhysDef.pitchResistance), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"yawResistance", offsetof(VehicleDef, vehPhysDef.yawResistance), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"uprightStrengthPitch", offsetof(VehicleDef, vehPhysDef.uprightStrengthPitch), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"uprightStrengthRoll", offsetof(VehicleDef, vehPhysDef.uprightStrengthRoll), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"targetAirPitch", offsetof(VehicleDef, vehPhysDef.targetAirPitch), CSPFT_FLOAT }, + {"airYawTorque", offsetof(VehicleDef, vehPhysDef.airYawTorque), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"airPitchTorque", offsetof(VehicleDef, vehPhysDef.airPitchTorque), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"minimumMomentumForCollision", offsetof(VehicleDef, vehPhysDef.minimumMomentumForCollision), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"collisionLaunchForceScale", offsetof(VehicleDef, vehPhysDef.collisionLaunchForceScale), CSPFT_FLOAT }, + {"wreckedMassScale", offsetof(VehicleDef, vehPhysDef.wreckedMassScale), CSPFT_FLOAT }, + {"wreckedBodyFriction", offsetof(VehicleDef, vehPhysDef.wreckedBodyFriction), CSPFT_FLOAT }, + {"minimumJoltForNotify", offsetof(VehicleDef, vehPhysDef.minimumJoltForNotify), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"slipThresholdFront", offsetof(VehicleDef, vehPhysDef.slipThresholdFront), CSPFT_FLOAT }, + {"slipThresholdRear", offsetof(VehicleDef, vehPhysDef.slipThresholdRear), CSPFT_FLOAT }, + {"slipFricScaleFront", offsetof(VehicleDef, vehPhysDef.slipFricScaleFront), CSPFT_FLOAT }, + {"slipFricScaleRear", offsetof(VehicleDef, vehPhysDef.slipFricScaleRear), CSPFT_FLOAT }, + {"slipFricRateFront", offsetof(VehicleDef, vehPhysDef.slipFricRateFront), CSPFT_FLOAT }, + {"slipFricRateRear", offsetof(VehicleDef, vehPhysDef.slipFricRateRear), CSPFT_FLOAT }, + {"slipYawTorque", offsetof(VehicleDef, vehPhysDef.slipYawTorque), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"boostDuration", offsetof(VehicleDef, boostDuration), CSPFT_FLOAT }, + {"boostRechargeTime", offsetof(VehicleDef, boostRechargeTime), CSPFT_FLOAT }, + {"boostAcceleration", offsetof(VehicleDef, boostAcceleration), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"suspensionTravel", offsetof(VehicleDef, suspensionTravel), CSPFT_FLOAT }, + {"maxSteeringAngle", offsetof(VehicleDef, maxSteeringAngle), CSPFT_FLOAT }, + {"steeringLerp", offsetof(VehicleDef, steeringLerp), CSPFT_FLOAT }, + {"minSteeringScale", offsetof(VehicleDef, minSteeringScale), CSPFT_FLOAT }, + {"minSteeringSpeed", offsetof(VehicleDef, minSteeringSpeed), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"vehHelicopterBoundsRadius", offsetof(VehicleDef, vehHelicopterBoundsRadius), CSPFT_FLOAT }, + {"vehHelicopterMaxSpeed", offsetof(VehicleDef, vehHelicopterMaxSpeed), CSPFT_FLOAT }, + {"vehHelicopterMaxSpeedVertical", offsetof(VehicleDef, vehHelicopterMaxSpeedVertical), CSPFT_FLOAT }, + {"vehHelicopterMaxAccel", offsetof(VehicleDef, vehHelicopterMaxAccel), CSPFT_FLOAT }, + {"vehHelicopterMaxAccelVertical", offsetof(VehicleDef, vehHelicopterMaxAccelVertical), CSPFT_FLOAT }, + {"vehHelicopterDecelerationFwd", offsetof(VehicleDef, vehHelicopterDecelerationFwd), CSPFT_FLOAT }, + {"vehHelicopterDecelerationSide", offsetof(VehicleDef, vehHelicopterDecelerationSide), CSPFT_FLOAT }, + {"vehHelicopterDecelerationUp", offsetof(VehicleDef, vehHelicopterDecelerationUp), CSPFT_FLOAT }, + {"vehHelicopterMaxYawRate", offsetof(VehicleDef, vehHelicopterMaxYawRate), CSPFT_FLOAT }, + {"vehHelicopterMaxYawAccel", offsetof(VehicleDef, vehHelicopterMaxYawAccel), CSPFT_FLOAT }, + {"vehHelicopterTiltFromVelocity", offsetof(VehicleDef, vehHelicopterTiltFromVelocity), CSPFT_FLOAT }, + {"vehHelicopterTiltFromControllerAxes", offsetof(VehicleDef, vehHelicopterTiltFromControllerAxes), CSPFT_FLOAT }, + {"vehHelicopterTiltFromAcceleration", offsetof(VehicleDef, vehHelicopterTiltFromAcceleration), CSPFT_FLOAT }, + {"vehHelicopterTiltFromDeceleration", offsetof(VehicleDef, vehHelicopterTiltFromDeceleration), CSPFT_FLOAT }, + {"vehHelicopterTiltFromFwdAndYaw_VelAtMaxTilt", offsetof(VehicleDef, vehHelicopterTiltFromFwdAndYaw_VelAtMaxTilt), CSPFT_FLOAT }, + {"vehHelicopterTiltFromFwdAndYaw", offsetof(VehicleDef, vehHelicopterTiltFromFwdAndYaw), CSPFT_FLOAT }, + {"vehHelicopterTiltMomentum", offsetof(VehicleDef, vehHelicopterTiltMomentum), CSPFT_FLOAT }, + {"vehHelicopterTiltSpeed", offsetof(VehicleDef, vehHelicopterTiltSpeed), CSPFT_FLOAT }, + {"vehHelicopterMaxPitch", offsetof(VehicleDef, vehHelicopterMaxPitch), CSPFT_FLOAT }, + {"vehHelicopterMaxRoll", offsetof(VehicleDef, vehHelicopterMaxRoll), CSPFT_FLOAT }, + {"vehHelicopterHoverSpeedThreshold", offsetof(VehicleDef, vehHelicopterHoverSpeedThreshold), CSPFT_FLOAT }, + {"vehHelicopterJitterJerkyness", offsetof(VehicleDef, vehHelicopterJitterJerkyness), CSPFT_FLOAT }, + {"vehHelicopterLookaheadTime", offsetof(VehicleDef, vehHelicopterLookaheadTime), CSPFT_FLOAT }, + {"vehHelicopterSoftCollisions", offsetof(VehicleDef, vehHelicopterSoftCollisions), CSPFT_QBOOLEAN }, + {"camLookEnabled", offsetof(VehicleDef, camLookEnabled), CSPFT_QBOOLEAN }, + {"camRelativeControl", offsetof(VehicleDef, camRelativeControl), CSPFT_QBOOLEAN }, + {"camLerp", offsetof(VehicleDef, camLerp), CSPFT_FLOAT }, + {"camHeight", offsetof(VehicleDef, camHeight), CSPFT_FLOAT }, + {"camRadius", offsetof(VehicleDef, camRadius), CSPFT_FLOAT }, + {"camPitchInfluence", offsetof(VehicleDef, camPitchInfluence), CSPFT_FLOAT }, + {"camYawInfluence", offsetof(VehicleDef, camYawInfluence), CSPFT_FLOAT }, + {"camRollInfluence", offsetof(VehicleDef, camRollInfluence), CSPFT_FLOAT }, + {"camFovIncrease", offsetof(VehicleDef, camFovIncrease), CSPFT_FLOAT }, + {"camFovOffset", offsetof(VehicleDef, camFovOffset), CSPFT_FLOAT }, + {"camFovSpeed", offsetof(VehicleDef, camFovSpeed), CSPFT_FLOAT }, + {"camReturnSpeed", offsetof(VehicleDef, camReturnSpeed), CSPFT_FLOAT }, + {"camReturnLerp", offsetof(VehicleDef, camReturnLerp), CSPFT_FLOAT }, + {"vehCam_UseGDT", offsetof(VehicleDef, vehCam_UseGDT), CSPFT_QBOOLEAN }, + {"vehCam_anglesPitch", offsetof(VehicleDef, vehCam_anglesPitch), CSPFT_FLOAT }, + {"vehCam_anglesYaw", offsetof(VehicleDef, vehCam_anglesYaw), CSPFT_FLOAT }, + {"vehCam_anglesRoll", offsetof(VehicleDef, vehCam_anglesRoll), CSPFT_FLOAT }, + {"vehCam_offsetX", offsetof(VehicleDef, vehCam_offsetX), CSPFT_FLOAT }, + {"vehCam_offsetY", offsetof(VehicleDef, vehCam_offsetY), CSPFT_FLOAT }, + {"vehCam_offsetZ", offsetof(VehicleDef, vehCam_offsetZ), CSPFT_FLOAT }, + {"vehCam_radius", offsetof(VehicleDef, vehCam_radius), CSPFT_FLOAT }, + {"vehCam_speedInfluence", offsetof(VehicleDef, vehCam_speedInfluence), CSPFT_FLOAT }, + {"vehCam_pitchTurnRate", offsetof(VehicleDef, vehCam_pitchTurnRate), CSPFT_FLOAT }, + {"vehCam_pitchClamp", offsetof(VehicleDef, vehCam_pitchClamp), CSPFT_FLOAT }, + {"vehCam_yawTurnRate", offsetof(VehicleDef, vehCam_yawTurnRate), CSPFT_FLOAT }, + {"vehCam_yawClamp", offsetof(VehicleDef, vehCam_yawClamp), CSPFT_FLOAT }, + {"vehCam_zOffsetMode", offsetof(VehicleDef, vehCam_zOffsetMode), VFT_CAM_Z_OFFSET_MODE }, + {"vehCam_anglesPitch3P", offsetof(VehicleDef, vehCam_anglesPitch3P), CSPFT_FLOAT }, + {"vehCam_anglesYaw3P", offsetof(VehicleDef, vehCam_anglesYaw3P), CSPFT_FLOAT }, + {"vehCam_anglesRoll3P", offsetof(VehicleDef, vehCam_anglesRoll3P), CSPFT_FLOAT }, + {"vehCam_offsetX3P", offsetof(VehicleDef, vehCam_offsetX3P), CSPFT_FLOAT }, + {"vehCam_offsetY3P", offsetof(VehicleDef, vehCam_offsetY3P), CSPFT_FLOAT }, + {"vehCam_offsetZ3P", offsetof(VehicleDef, vehCam_offsetZ3P), CSPFT_FLOAT }, + {"vehCam_radius3P", offsetof(VehicleDef, vehCam_radius3P), CSPFT_FLOAT }, + {"vehCam_speedInfluence3P", offsetof(VehicleDef, vehCam_speedInfluence3P), CSPFT_FLOAT }, + {"vehCam_pitchTurnRate3P", offsetof(VehicleDef, vehCam_pitchTurnRate3P), CSPFT_FLOAT }, + {"vehCam_pitchClamp3P", offsetof(VehicleDef, vehCam_pitchClamp3P), CSPFT_FLOAT }, + {"vehCam_yawTurnRate3P", offsetof(VehicleDef, vehCam_yawTurnRate3P), CSPFT_FLOAT }, + {"vehCam_yawClamp3P", offsetof(VehicleDef, vehCam_yawClamp3P), CSPFT_FLOAT }, + {"vehCam_zOffsetMode3P", offsetof(VehicleDef, vehCam_zOffsetMode3P), VFT_CAM_Z_OFFSET_MODE }, + {"turretWeaponName", offsetof(VehicleDef, turretWeaponName), CSPFT_STRING }, + {"turretHorizSpanLeft", offsetof(VehicleDef, turretHorizSpanLeft), CSPFT_FLOAT }, + {"turretHorizSpanRight", offsetof(VehicleDef, turretHorizSpanRight), CSPFT_FLOAT }, + {"turretVertSpanUp", offsetof(VehicleDef, turretVertSpanUp), CSPFT_FLOAT }, + {"turretVertSpanDown", offsetof(VehicleDef, turretVertSpanDown), CSPFT_FLOAT }, + {"turretHorizResistLeft", offsetof(VehicleDef, turretHorizResistLeft), CSPFT_FLOAT }, + {"turretHorizResistRight", offsetof(VehicleDef, turretHorizResistRight), CSPFT_FLOAT }, + {"turretVertResistUp", offsetof(VehicleDef, turretVertResistUp), CSPFT_FLOAT }, + {"turretVertResistDown", offsetof(VehicleDef, turretVertResistDown), CSPFT_FLOAT }, + {"turretRotRate", offsetof(VehicleDef, turretRotRate), CSPFT_FLOAT }, + {"turretSpinSnd", offsetof(VehicleDef, turretSpinSnd), CSPFT_SOUND }, + {"turretStopSnd", offsetof(VehicleDef, turretStopSnd), CSPFT_SOUND }, + {"trophyEnabled", offsetof(VehicleDef, trophyEnabled), CSPFT_QBOOLEAN }, + {"trophyRadius", offsetof(VehicleDef, trophyRadius), CSPFT_FLOAT }, + {"trophyInactiveRadius", offsetof(VehicleDef, trophyInactiveRadius), CSPFT_FLOAT }, + {"trophyAmmoCount", offsetof(VehicleDef, trophyAmmoCount), CSPFT_INT }, + {"trophyReloadTime", offsetof(VehicleDef, trophyReloadTime), CSPFT_FLOAT }, + {"trophyTags", offsetof(VehicleDef, trophyTags), VFT_TROPHY_TAGS }, + {"trophyExplodeFx", offsetof(VehicleDef, trophyExplodeFx), CSPFT_FX }, + {"trophyFlashFx", offsetof(VehicleDef, trophyFlashFx), CSPFT_FX }, + {"compassFriendlyIcon", offsetof(VehicleDef, compassFriendlyIcon), CSPFT_MATERIAL }, + {"compassEnemyIcon", offsetof(VehicleDef, compassEnemyIcon), CSPFT_MATERIAL }, + {"compassFriendlyAltIcon", offsetof(VehicleDef, compassFriendlyAltIcon), CSPFT_MATERIAL }, + {"compassEnemyAltIcon", offsetof(VehicleDef, compassEnemyAltIcon), CSPFT_MATERIAL }, + {"compassIconWidth", offsetof(VehicleDef, compassIconWidth), CSPFT_INT }, + {"compassIconHeight", offsetof(VehicleDef, compassIconHeight), CSPFT_INT }, + {"lowIdleSnd", offsetof(VehicleDef, idleLowSnd), CSPFT_SOUND }, + {"highIdleSnd", offsetof(VehicleDef, idleHighSnd), CSPFT_SOUND }, + {"lowEngineSnd", offsetof(VehicleDef, engineLowSnd), CSPFT_SOUND }, + {"highEngineSnd", offsetof(VehicleDef, engineHighSnd), CSPFT_SOUND }, + {"engineSndSpeed", offsetof(VehicleDef, engineSndSpeed), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"audioOriginTag", offsetof(VehicleDef, audioOriginTag), CSPFT_SCRIPT_STRING }, + {"lowIdleSndAlt", offsetof(VehicleDef, idleLowSndAlt), CSPFT_SOUND }, + {"highIdleSndAlt", offsetof(VehicleDef, idleHighSndAlt), CSPFT_SOUND }, + {"lowEngineSndAlt", offsetof(VehicleDef, engineLowSndAlt), CSPFT_SOUND }, + {"highEngineSndAlt", offsetof(VehicleDef, engineHighSndAlt), CSPFT_SOUND }, + {"engineSndSpeedAlt", offsetof(VehicleDef, engineSndSpeedAlt), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"audioOriginTagAlt", offsetof(VehicleDef, audioOriginTagAlt), CSPFT_SCRIPT_STRING }, + {"turretSpinSndAlt", offsetof(VehicleDef, turretSpinSndAlt), CSPFT_SOUND }, + {"turretStopSndAlt", offsetof(VehicleDef, turretStopSndAlt), CSPFT_SOUND }, + {"engineStartUpSnd", offsetof(VehicleDef, engineStartUpSnd), CSPFT_SOUND }, + {"engineStartUpLength", offsetof(VehicleDef, engineStartUpLength), CSPFT_MILLISECONDS }, + {"engineShutdownSnd", offsetof(VehicleDef, engineShutdownSnd), CSPFT_SOUND }, + {"engineIdleSnd", offsetof(VehicleDef, engineIdleSnd), CSPFT_SOUND }, + {"engineSustainSnd", offsetof(VehicleDef, engineSustainSnd), CSPFT_SOUND }, + {"engineRampUpSnd", offsetof(VehicleDef, engineRampUpSnd), CSPFT_SOUND }, + {"engineRampUpLength", offsetof(VehicleDef, engineRampUpLength), CSPFT_MILLISECONDS }, + {"engineRampDownSnd", offsetof(VehicleDef, engineRampDownSnd), CSPFT_SOUND }, + {"engineRampDownLength", offsetof(VehicleDef, engineRampDownLength), CSPFT_MILLISECONDS }, + {"suspensionSoftSnd", offsetof(VehicleDef, suspensionSoftSnd), CSPFT_SOUND }, + {"suspensionSoftCompression", offsetof(VehicleDef, suspensionSoftCompression), CSPFT_FLOAT }, + {"suspensionHardSnd", offsetof(VehicleDef, suspensionHardSnd), CSPFT_SOUND }, + {"suspensionHardCompression", offsetof(VehicleDef, suspensionHardCompression), CSPFT_FLOAT }, + {"collisionSnd", offsetof(VehicleDef, collisionSnd), CSPFT_SOUND }, + {"collisionBlendSpeed", offsetof(VehicleDef, collisionBlendSpeed), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"speedSnd", offsetof(VehicleDef, speedSnd), CSPFT_SOUND }, + {"speedSndBlendSpeed", offsetof(VehicleDef, speedSndBlendSpeed), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"surfaceSndPrefix", offsetof(VehicleDef, surfaceSndPrefix), CSPFT_STRING }, + {"surfaceSndBlendSpeed", offsetof(VehicleDef, surfaceSndBlendSpeed), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"slideVolume", offsetof(VehicleDef, slideVolume), CSPFT_FLOAT }, + {"slideBlendSpeed", offsetof(VehicleDef, slideBlendSpeed), CSPFT_MPH_TO_INCHES_PER_SEC}, + {"inAirPitch", offsetof(VehicleDef, inAirPitch), CSPFT_FLOAT }, + }; +} // namespace IW5 diff --git a/src/ObjCommon/Game/IW5/Vehicle/VehicleStringsIW5.h b/src/ObjCommon/Game/IW5/Vehicle/VehicleStringsIW5.h new file mode 100644 index 00000000..370c043d --- /dev/null +++ b/src/ObjCommon/Game/IW5/Vehicle/VehicleStringsIW5.h @@ -0,0 +1,33 @@ +#pragma once + +#include "Game/IW5/IW5.h" + +namespace IW5 +{ + inline const char* s_vehicleClassNames[]{ + "4 wheel", + "tank", + "plane", + "boat", + "artillery", + "helicopter", + "snowmobile", + "submarine", + "ugv", + }; + static_assert(std::extent_v == VEH_TYPE_COUNT); + + inline const char* s_vehicleAxleTypeNames[]{ + "front", + "rear", + "all", + }; + static_assert(std::extent_v == VEH_AXLE_COUNT); + + inline const char* s_vehicleCameraZOffsetModeNames[]{ + "world", + "vehicle", + "view", + }; + static_assert(std::extent_v == VEHCAM_ZMODE_COUNT); +} // namespace IW5 diff --git a/src/ObjCommon/Game/IW5/Weapon/WeaponFields.h b/src/ObjCommon/Game/IW5/Weapon/WeaponFields.h index 6dbdce66..5a31a5c8 100644 --- a/src/ObjCommon/Game/IW5/Weapon/WeaponFields.h +++ b/src/ObjCommon/Game/IW5/Weapon/WeaponFields.h @@ -952,26 +952,6 @@ namespace IW5 }; static_assert(std::extent_v == WEAPON_ICON_RATIO_COUNT); - inline const char* s_vehicleClassNames[]{ - "4 wheel", - "tank", - "plane", - "boat", - "artillery", - "helicopter", - "snowmobile", - "submarine", - "ugv", - }; - static_assert(std::extent_v == VEH_TYPE_COUNT); - - inline const char* s_vehicleAxleTypeNames[]{ - "front", - "rear", - "all", - }; - static_assert(std::extent_v == VEH_AXLE_COUNT); - inline const char* surfaceTypeSoundSuffixes[]{ "_default", "_bark", "_brick", "_carpet", "_cloth", "_concrete", "_dirt", "_flesh", "_foliage", "_glass", "_grass", "_gravel", "_ice", "_metal", "_mud", "_paper", "_plaster", "_rock", "_sand", "_snow", "_water", "_wood", diff --git a/src/ObjLoading/Game/IW4/ObjLoaderIW4.cpp b/src/ObjLoading/Game/IW4/ObjLoaderIW4.cpp index 14fa0d3f..11629bcf 100644 --- a/src/ObjLoading/Game/IW4/ObjLoaderIW4.cpp +++ b/src/ObjLoading/Game/IW4/ObjLoaderIW4.cpp @@ -11,6 +11,8 @@ #include "Game/IW4/Techset/VertexShaderLoaderIW4.h" #include "Game/IW4/Tracer/GdtLoaderTracerIW4.h" #include "Game/IW4/Tracer/RawLoaderTracerIW4.h" +#include "Game/IW4/Vehicle/GdtLoaderVehicleIW4.h" +#include "Game/IW4/Vehicle/RawLoaderVehicleIW4.h" #include "Game/IW4/Weapon/AccuracyGraphLoaderIW4.h" #include "Game/IW4/XAnim/XAnimLoaderIW4.h" #include "Game/IW4/XModel/LoaderXModelIW4.h" @@ -163,7 +165,8 @@ namespace collection.AddAssetCreator(structured_data_def::CreateLoaderIW4(memory, searchPath)); collection.AddAssetCreator(tracer::CreateRawLoaderIW4(memory, searchPath, zone)); collection.AddAssetCreator(tracer::CreateGdtLoaderIW4(memory, gdt, zone)); - // collection.AddAssetCreator(std::make_unique(memory)); + collection.AddAssetCreator(vehicle::CreateRawLoaderIW4(memory, searchPath, zone)); + collection.AddAssetCreator(vehicle::CreateGdtLoaderIW4(memory, gdt, zone)); // collection.AddAssetCreator(std::make_unique(memory)); collection.AddSubAssetCreator(weapon::CreateAccuracyGraphLoaderIW4(memory, searchPath)); diff --git a/src/ObjLoading/Game/IW5/ObjLoaderIW5.cpp b/src/ObjLoading/Game/IW5/ObjLoaderIW5.cpp index d660cd01..ac083c78 100644 --- a/src/ObjLoading/Game/IW5/ObjLoaderIW5.cpp +++ b/src/ObjLoading/Game/IW5/ObjLoaderIW5.cpp @@ -11,6 +11,8 @@ #include "Game/IW5/Techset/VertexShaderLoaderIW5.h" #include "Game/IW5/Tracer/GdtLoaderTracerIW5.h" #include "Game/IW5/Tracer/RawLoaderTracerIW5.h" +#include "Game/IW5/Vehicle/GdtLoaderVehicleIW5.h" +#include "Game/IW5/Vehicle/RawLoaderVehicleIW5.h" #include "Game/IW5/Weapon/AccuracyGraphLoaderIW5.h" #include "Game/IW5/XAnim/XAnimLoaderIW5.h" #include "Game/IW5/XModel/LoaderXModelIW5.h" @@ -174,7 +176,8 @@ namespace // collection.AddAssetCreator(std::make_unique(memory)); collection.AddAssetCreator(tracer::CreateRawLoaderIW5(memory, searchPath, zone)); collection.AddAssetCreator(tracer::CreateGdtLoaderIW5(memory, gdt, zone)); - // collection.AddAssetCreator(std::make_unique(memory)); + collection.AddAssetCreator(vehicle::CreateRawLoaderIW5(memory, searchPath, zone)); + collection.AddAssetCreator(vehicle::CreateGdtLoaderIW5(memory, gdt, zone)); // collection.AddAssetCreator(std::make_unique(memory)); collection.AddSubAssetCreator(weapon::CreateAccuracyGraphLoaderIW5(memory, searchPath)); diff --git a/src/ObjLoading/Vehicle/GdtLoaderVehicle.cpp.template b/src/ObjLoading/Vehicle/GdtLoaderVehicle.cpp.template new file mode 100644 index 00000000..4c9c65ae --- /dev/null +++ b/src/ObjLoading/Vehicle/GdtLoaderVehicle.cpp.template @@ -0,0 +1,63 @@ +#options GAME(IW4, IW5) + +#filename "Game/" + GAME + "/Vehicle/GdtLoaderVehicle" + GAME + ".cpp" + +#set LOADER_HEADER "\"GdtLoaderVehicle" + GAME + ".h\"" +#set INFO_STRING_LOADER_HEADER "\"InfoStringLoaderVehicle" + GAME + ".h\"" +#set OBJ_CONSTANTS_HEADER "\"Game/" + GAME + "/ObjConstants" + GAME + ".h\"" +#set INFO_STRING_LOADER_NAME "InfoStringLoader" + GAME +#set FACTORY_NAME "CreateGdtLoader" + GAME + +// This file was templated. +// See GdtLoaderVehicle.cpp.template. +// Do not modify, changes will be lost. + +#include LOADER_HEADER + +#include INFO_STRING_LOADER_HEADER +#include OBJ_CONSTANTS_HEADER +#include "InfoString/InfoString.h" +#include "Utils/Logging/Log.h" + +using namespace GAME; + +namespace +{ + class GdtLoaderVehicle final : public AssetCreator + { + public: + GdtLoaderVehicle(MemoryManager& memory, IGdtQueryable& gdt, Zone& zone) + : m_gdt(gdt), + m_info_string_loader(memory, zone) + { + } + + AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override + { + const auto* gdtEntry = m_gdt.GetGdtEntryByGdfAndName(GDF_FILENAME_VEHICLE, assetName); + if (gdtEntry == nullptr) + return AssetCreationResult::NoAction(); + + InfoString infoString; + if (!infoString.FromGdtProperties(*gdtEntry)) + { + con::error("Failed to read vehicle gdt entry: \"{}\"", assetName); + return AssetCreationResult::Failure(); + } + + return m_info_string_loader.CreateAsset(assetName, infoString, context); + } + + private: + IGdtQueryable& m_gdt; + vehicle::INFO_STRING_LOADER_NAME m_info_string_loader; + }; +} // namespace + +namespace vehicle +{ + std::unique_ptr> FACTORY_NAME(MemoryManager& memory, IGdtQueryable& gdt, Zone& zone) + { + return std::make_unique(memory, gdt, zone); + } +} // namespace vehicle diff --git a/src/ObjLoading/Vehicle/GdtLoaderVehicle.h.template b/src/ObjLoading/Vehicle/GdtLoaderVehicle.h.template new file mode 100644 index 00000000..672691a0 --- /dev/null +++ b/src/ObjLoading/Vehicle/GdtLoaderVehicle.h.template @@ -0,0 +1,25 @@ +#options GAME(IW4, IW5) + +#filename "Game/" + GAME + "/Vehicle/GdtLoaderVehicle" + GAME + ".h" + +#set GAME_HEADER "\"Game/" + GAME + "/" + GAME + ".h\"" +#set FACTORY_NAME "CreateGdtLoader" + GAME + +// This file was templated. +// See GdtLoaderVehicle.h.template. +// Do not modify, changes will be lost. + +#pragma once + +#include GAME_HEADER +#include "Asset/IAssetCreator.h" +#include "Gdt/IGdtQueryable.h" +#include "Utils/MemoryManager.h" +#include "Zone/Zone.h" + +#include + +namespace vehicle +{ + std::unique_ptr> FACTORY_NAME(MemoryManager& memory, IGdtQueryable& gdt, Zone& zone); +} // namespace vehicle diff --git a/src/ObjLoading/Vehicle/InfoStringLoaderVehicle.cpp.template b/src/ObjLoading/Vehicle/InfoStringLoaderVehicle.cpp.template new file mode 100644 index 00000000..4483a7cd --- /dev/null +++ b/src/ObjLoading/Vehicle/InfoStringLoaderVehicle.cpp.template @@ -0,0 +1,191 @@ +#options GAME(IW4, IW5) + +#filename "Game/" + GAME + "/Vehicle/InfoStringLoaderVehicle" + GAME + ".cpp" + +#set LOADER_HEADER "\"InfoStringLoaderVehicle" + GAME + ".h\"" +#set GAME_HEADER "\"Game/" + GAME + "/" + GAME + ".h\"" +#set INFO_STRING_CONVERTER_HEADER "\"Game/" + GAME + "/InfoString/InfoStringToStructConverter.h\"" +#set VEHICLE_FIELDS_HEADER "\"Game/" + GAME + "/Vehicle/VehicleFields" + GAME + ".h\"" +#set VEHICLE_STRINGS_HEADER "\"Game/" + GAME + "/Vehicle/VehicleStrings" + GAME + ".h\"" +#set CLASS_NAME "InfoStringLoader" + GAME + +#if GAME == "IW5" +#define FEATURE_IW5 +#endif + +// This file was templated. +// See InfoStringLoaderVehicle.cpp.template. +// Do not modify, changes will be lost. + +#include LOADER_HEADER + +#include GAME_HEADER +#include INFO_STRING_CONVERTER_HEADER +#include VEHICLE_FIELDS_HEADER +#include VEHICLE_STRINGS_HEADER +#include "Utils/Logging/Log.h" + +#include +#include +#include +#include + +using namespace GAME; + +namespace +{ + constexpr const char* SURFACE_SOUND_SUFFIXES[]{ + "_default", "_bark", "_brick", "_carpet", "_cloth", "_concrete", "_dirt", "_flesh", "_foliage", "_glass", "_grass", + "_gravel", "_ice", "_metal", "_mud", "_paper", "_plaster", "_rock", "_sand", "_snow", "_water", "_wood", + "_asphalt", "_ceramic", "_plastic", "_rubber", "_cushion", "_fruit", "_painted_metal", "_riot_shield", "_slush", + }; + + class InfoStringToVehicleConverter final : public InfoStringToStructConverter + { + bool ConvertTrophyTags(const cspField_t& field, const std::string& value) + { + std::vector valueArray; + if (!ParseAsArray(value, valueArray)) + { + con::error("Failed to parse trophy tags as array"); + return false; + } + + if (valueArray.size() > std::extent_v) + { + con::error("Cannot have more than {} trophy tags!", std::extent_v); + return false; + } + + auto* trophyTags = reinterpret_cast(reinterpret_cast(m_structure) + field.iOffset); + for (auto i = 0u; i < valueArray.size(); i++) + { + if (valueArray[i].empty()) + continue; + + const auto scriptString = m_zone_script_strings.AddOrGetScriptString(valueArray[i]); + trophyTags[i] = scriptString; + m_registration.AddScriptString(scriptString); + } + + return true; + } + + protected: + bool ConvertExtensionField(const cspField_t& field, const std::string& value) override + { + switch (static_cast(field.iFieldType)) + { + case VFT_TYPE: + return ConvertEnumInt(field.szName, value, field.iOffset, s_vehicleClassNames, std::extent_v); + + case VFT_AXLE_STEERING: + case VFT_AXLE_POWER: + case VFT_AXLE_BRAKING: + return ConvertEnumInt(field.szName, value, field.iOffset, s_vehicleAxleTypeNames, std::extent_v); + + case VFT_TROPHY_TAGS: + return ConvertTrophyTags(field, value); + +#ifdef FEATURE_IW5 + case VFT_CAM_Z_OFFSET_MODE: + return ConvertEnumInt( + field.szName, value, field.iOffset, s_vehicleCameraZOffsetModeNames, std::extent_v); +#endif + + case VFT_NUM: + default: + assert(false); + return false; + } + } + + public: + InfoStringToVehicleConverter(const InfoString& infoString, + VehicleDef& vehicle, + ZoneScriptStrings& zoneScriptStrings, + MemoryManager& memory, + AssetCreationContext& context, + AssetRegistration& registration, + const cspField_t* fields, + const size_t fieldCount) + : InfoStringToStructConverter(infoString, &vehicle, zoneScriptStrings, memory, context, registration, fields, fieldCount) + { + } + }; + + bool LoadDependencies(VehicleDef& vehicle, AssetCreationContext& context, AssetRegistration& registration) + { + if (vehicle.vehPhysDef.physPresetName && vehicle.vehPhysDef.physPresetName[0]) + { + auto* physPreset = context.LoadDependency(vehicle.vehPhysDef.physPresetName); + if (physPreset == nullptr) + { + con::error("Failed to load phys preset asset \"{}\"", vehicle.vehPhysDef.physPresetName); + return false; + } + + vehicle.vehPhysDef.physPreset = physPreset->Asset(); + registration.AddDependency(physPreset); + } + + if (vehicle.turretWeaponName && vehicle.turretWeaponName[0]) + { + auto* weapon = context.LoadDependency(vehicle.turretWeaponName); + if (weapon == nullptr) + { + con::error("Failed to load weapon asset \"{}\"", vehicle.turretWeaponName); + return false; + } + + vehicle.turretWeapon = weapon->Asset(); + registration.AddDependency(weapon); + } + + return true; + } + + void CreateSurfaceSounds(VehicleDef& vehicle, MemoryManager& memory, AssetCreationContext& context, AssetRegistration& registration) + { + if (vehicle.surfaceSndPrefix == nullptr || vehicle.surfaceSndPrefix[0] == '\0') + return; + + static_assert(std::extent_v == std::extent_v); + for (auto i = 0u; i < std::extent_v; i++) + { + const auto soundName = std::string(vehicle.surfaceSndPrefix) + SURFACE_SOUND_SUFFIXES[i]; + vehicle.surfaceSnds[i].name = memory.Alloc(); + vehicle.surfaceSnds[i].name->soundName = memory.Dup(soundName.c_str()); + registration.AddIndirectAssetReference(context.LoadIndirectAssetReference(soundName)); + } + } +} // namespace + +namespace vehicle +{ + CLASS_NAME::CLASS_NAME(MemoryManager& memory, Zone& zone) + : m_memory(memory), + m_zone(zone) + { + } + + AssetCreationResult CLASS_NAME::CreateAsset(const std::string& assetName, const InfoString& infoString, AssetCreationContext& context) + { + auto* vehicle = m_memory.Alloc(); + vehicle->name = m_memory.Dup(assetName.c_str()); + + AssetRegistration registration(assetName, vehicle); + InfoStringToVehicleConverter converter( + infoString, *vehicle, m_zone.m_script_strings, m_memory, context, registration, vehicle_fields, std::extent_v); + if (!converter.Convert() || !LoadDependencies(*vehicle, context, registration)) + { + con::error("Failed to parse vehicle: \"{}\"", assetName); + return AssetCreationResult::Failure(); + } + + vehicle->vehPhysDef.topSpeed = vehicle->topSpeed; + vehicle->vehPhysDef.suspensionTravelFront = vehicle->suspensionTravel; + CreateSurfaceSounds(*vehicle, m_memory, context, registration); + return AssetCreationResult::Success(context.AddAsset(std::move(registration))); + } +} // namespace vehicle diff --git a/src/ObjLoading/Vehicle/InfoStringLoaderVehicle.h.template b/src/ObjLoading/Vehicle/InfoStringLoaderVehicle.h.template new file mode 100644 index 00000000..b04452ac --- /dev/null +++ b/src/ObjLoading/Vehicle/InfoStringLoaderVehicle.h.template @@ -0,0 +1,33 @@ +#options GAME(IW4, IW5) + +#filename "Game/" + GAME + "/Vehicle/InfoStringLoaderVehicle" + GAME + ".h" + +#set GAME_HEADER "\"Game/" + GAME + "/" + GAME + ".h\"" +#set CLASS_NAME "InfoStringLoader" + GAME + +// This file was templated. +// See InfoStringLoaderVehicle.h.template. +// Do not modify, changes will be lost. + +#pragma once + +#include GAME_HEADER +#include "Asset/AssetCreationContext.h" +#include "Asset/AssetRegistration.h" +#include "InfoString/InfoString.h" +#include "Utils/MemoryManager.h" +#include "Zone/Zone.h" + +namespace vehicle +{ + class CLASS_NAME + { + public: + CLASS_NAME(MemoryManager& memory, Zone& zone); + AssetCreationResult CreateAsset(const std::string& assetName, const InfoString& infoString, AssetCreationContext& context); + + private: + MemoryManager& m_memory; + Zone& m_zone; + }; +} // namespace vehicle diff --git a/src/ObjLoading/Vehicle/RawLoaderVehicle.cpp.template b/src/ObjLoading/Vehicle/RawLoaderVehicle.cpp.template new file mode 100644 index 00000000..d7a6e157 --- /dev/null +++ b/src/ObjLoading/Vehicle/RawLoaderVehicle.cpp.template @@ -0,0 +1,65 @@ +#options GAME(IW4, IW5) + +#filename "Game/" + GAME + "/Vehicle/RawLoaderVehicle" + GAME + ".cpp" + +#set LOADER_HEADER "\"RawLoaderVehicle" + GAME + ".h\"" +#set INFO_STRING_LOADER_HEADER "\"InfoStringLoaderVehicle" + GAME + ".h\"" +#set OBJ_CONSTANTS_HEADER "\"Game/" + GAME + "/ObjConstants" + GAME + ".h\"" +#set INFO_STRING_LOADER_NAME "InfoStringLoader" + GAME +#set FACTORY_NAME "CreateRawLoader" + GAME + +// This file was templated. +// See RawLoaderVehicle.cpp.template. +// Do not modify, changes will be lost. + +#include LOADER_HEADER + +#include INFO_STRING_LOADER_HEADER +#include OBJ_CONSTANTS_HEADER +#include "InfoString/InfoString.h" +#include "Utils/Logging/Log.h" +#include "Vehicle/VehicleCommon.h" + +using namespace GAME; + +namespace +{ + class RawLoaderVehicle final : public AssetCreator + { + public: + RawLoaderVehicle(MemoryManager& memory, ISearchPath& searchPath, Zone& zone) + : m_search_path(searchPath), + m_info_string_loader(memory, zone) + { + } + + AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override + { + const auto fileName = vehicle::GetFileNameForAssetName(assetName); + const auto file = m_search_path.Open(fileName); + if (!file.IsOpen()) + return AssetCreationResult::NoAction(); + + InfoString infoString; + if (!infoString.FromStream(INFO_STRING_PREFIX_VEHICLE, *file.m_stream)) + { + con::error("Could not parse as info string file: \"{}\"", fileName); + return AssetCreationResult::Failure(); + } + + return m_info_string_loader.CreateAsset(assetName, infoString, context); + } + + private: + ISearchPath& m_search_path; + vehicle::INFO_STRING_LOADER_NAME m_info_string_loader; + }; +} // namespace + +namespace vehicle +{ + std::unique_ptr> FACTORY_NAME(MemoryManager& memory, ISearchPath& searchPath, Zone& zone) + { + return std::make_unique(memory, searchPath, zone); + } +} // namespace vehicle diff --git a/src/ObjLoading/Vehicle/RawLoaderVehicle.h.template b/src/ObjLoading/Vehicle/RawLoaderVehicle.h.template new file mode 100644 index 00000000..8ce15791 --- /dev/null +++ b/src/ObjLoading/Vehicle/RawLoaderVehicle.h.template @@ -0,0 +1,25 @@ +#options GAME(IW4, IW5) + +#filename "Game/" + GAME + "/Vehicle/RawLoaderVehicle" + GAME + ".h" + +#set GAME_HEADER "\"Game/" + GAME + "/" + GAME + ".h\"" +#set FACTORY_NAME "CreateRawLoader" + GAME + +// This file was templated. +// See RawLoaderVehicle.h.template. +// Do not modify, changes will be lost. + +#pragma once + +#include GAME_HEADER +#include "Asset/IAssetCreator.h" +#include "SearchPath/ISearchPath.h" +#include "Utils/MemoryManager.h" +#include "Zone/Zone.h" + +#include + +namespace vehicle +{ + std::unique_ptr> FACTORY_NAME(MemoryManager& memory, ISearchPath& searchPath, Zone& zone); +} // namespace vehicle diff --git a/src/ObjWriting/Game/IW4/ObjWriterIW4.cpp b/src/ObjWriting/Game/IW4/ObjWriterIW4.cpp index 28626bff..99945599 100644 --- a/src/ObjWriting/Game/IW4/ObjWriterIW4.cpp +++ b/src/ObjWriting/Game/IW4/ObjWriterIW4.cpp @@ -8,6 +8,7 @@ #include "Game/IW4/Techset/TechsetDumperIW4.h" #include "Game/IW4/Techset/VertexShaderDumperIW4.h" #include "Game/IW4/Tracer/TracerDumperIW4.h" +#include "Game/IW4/Vehicle/VehicleDumperIW4.h" #include "Game/IW4/XAnim/XAnimDumperIW4.h" #include "Game/IW4/XModel/XModelDumperIW4.h" #include "Leaderboard/LeaderboardJsonDumperIW4.h" @@ -24,7 +25,6 @@ #include "Sound/SndCurveDumperIW4.h" #include "StringTable/StringTableDumperIW4.h" #include "StructuredDataDef/StructuredDataDefDumperIW4.h" -#include "Vehicle/VehicleDumperIW4.h" #include "Weapon/WeaponDumperIW4.h" using namespace IW4; diff --git a/src/ObjWriting/Game/IW4/Vehicle/VehicleDumperIW4.h b/src/ObjWriting/Game/IW4/Vehicle/VehicleDumperIW4.h deleted file mode 100644 index 0de96a21..00000000 --- a/src/ObjWriting/Game/IW4/Vehicle/VehicleDumperIW4.h +++ /dev/null @@ -1,13 +0,0 @@ -#pragma once - -#include "Dumping/AbstractAssetDumper.h" -#include "Game/IW4/IW4.h" - -namespace vehicle -{ - class DumperIW4 final : public AbstractAssetDumper - { - protected: - void DumpAsset(AssetDumpingContext& context, const XAssetInfo& asset) override; - }; -} // namespace vehicle diff --git a/src/ObjWriting/Game/IW5/ObjWriterIW5.cpp b/src/ObjWriting/Game/IW5/ObjWriterIW5.cpp index 14ff1d7f..813dd6e4 100644 --- a/src/ObjWriting/Game/IW5/ObjWriterIW5.cpp +++ b/src/ObjWriting/Game/IW5/ObjWriterIW5.cpp @@ -9,6 +9,7 @@ #include "Game/IW5/Techset/TechsetDumperIW5.h" #include "Game/IW5/Techset/VertexShaderDumperIW5.h" #include "Game/IW5/Tracer/TracerDumperIW5.h" +#include "Game/IW5/Vehicle/VehicleDumperIW5.h" #include "Game/IW5/XModel/XModelDumperIW5.h" #include "Leaderboard/LeaderboardJsonDumperIW5.h" #include "LightDef/LightDefDumperIW5.h" @@ -71,6 +72,6 @@ void ObjWriter::RegisterAssetDumpers(AssetDumpingContext& context) RegisterAssetDumper(std::make_unique()); // REGISTER_DUMPER(AssetDumperStructuredDataDefSet) RegisterAssetDumper(std::make_unique()); - // REGISTER_DUMPER(AssetDumperVehicleDef) + RegisterAssetDumper(std::make_unique()); RegisterAssetDumper(std::make_unique()); } diff --git a/src/ObjWriting/Game/IW4/Vehicle/VehicleDumperIW4.cpp b/src/ObjWriting/Vehicle/VehicleDumper.cpp.template similarity index 76% rename from src/ObjWriting/Game/IW4/Vehicle/VehicleDumperIW4.cpp rename to src/ObjWriting/Vehicle/VehicleDumper.cpp.template index 6c85bd96..4eb83bcc 100644 --- a/src/ObjWriting/Game/IW4/Vehicle/VehicleDumperIW4.cpp +++ b/src/ObjWriting/Vehicle/VehicleDumper.cpp.template @@ -1,17 +1,35 @@ -#include "VehicleDumperIW4.h" +#options GAME(IW4, IW5) -#include "Game/IW4/CommonIW4.h" -#include "Game/IW4/InfoString/EnumStrings.h" -#include "Game/IW4/InfoString/InfoStringFromStructConverter.h" -#include "Game/IW4/ObjConstantsIW4.h" -#include "Game/IW4/Vehicle/VehicleFields.h" +#filename "Game/" + GAME + "/Vehicle/VehicleDumper" + GAME + ".cpp" + +#set DUMPER_HEADER "\"VehicleDumper" + GAME + ".h\"" +#set INFO_STRING_CONVERTER_HEADER "\"Game/" + GAME + "/InfoString/InfoStringFromStructConverter.h\"" +#set OBJ_CONSTANTS_HEADER "\"Game/" + GAME + "/ObjConstants" + GAME + ".h\"" +#set VEHICLE_FIELDS_HEADER "\"Game/" + GAME + "/Vehicle/VehicleFields" + GAME + ".h\"" +#set VEHICLE_STRINGS_HEADER "\"Game/" + GAME + "/Vehicle/VehicleStrings" + GAME + ".h\"" +#set CLASS_NAME "Dumper" + GAME + +#if GAME == "IW5" +#define FEATURE_IW5 +#endif + +// This file was templated. +// See VehicleDumper.cpp.template. +// Do not modify, changes will be lost. + +#include DUMPER_HEADER + +#include INFO_STRING_CONVERTER_HEADER +#include OBJ_CONSTANTS_HEADER +#include VEHICLE_FIELDS_HEADER +#include VEHICLE_STRINGS_HEADER #include "Vehicle/VehicleCommon.h" #include #include #include -using namespace IW4; +using namespace GAME; namespace { @@ -56,6 +74,13 @@ namespace break; } +#ifdef FEATURE_IW5 + case VFT_CAM_Z_OFFSET_MODE: + FillFromEnumInt( + std::string(field.szName), field.iOffset, s_vehicleCameraZOffsetModeNames, std::extent_v); + break; +#endif + case VFT_NUM: default: assert(false); @@ -93,7 +118,7 @@ namespace namespace vehicle { - void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo& asset) + void CLASS_NAME::DumpAsset(AssetDumpingContext& context, const XAssetInfo& asset) { // Only dump raw when no gdt available if (context.m_gdt) diff --git a/src/ObjWriting/Vehicle/VehicleDumper.h.template b/src/ObjWriting/Vehicle/VehicleDumper.h.template new file mode 100644 index 00000000..11240588 --- /dev/null +++ b/src/ObjWriting/Vehicle/VehicleDumper.h.template @@ -0,0 +1,24 @@ +#options GAME(IW4, IW5) + +#filename "Game/" + GAME + "/Vehicle/VehicleDumper" + GAME + ".h" + +#set GAME_HEADER "\"Game/" + GAME + "/" + GAME + ".h\"" +#set CLASS_NAME "Dumper" + GAME + +// This file was templated. +// See VehicleDumper.h.template. +// Do not modify, changes will be lost. + +#pragma once + +#include "Dumping/AbstractAssetDumper.h" +#include GAME_HEADER + +namespace vehicle +{ + class CLASS_NAME final : public AbstractAssetDumper + { + protected: + void DumpAsset(AssetDumpingContext& context, const XAssetInfo& asset) override; + }; +} // namespace vehicle diff --git a/test/ObjLoadingTests/Game/IW4/Vehicle/RawLoaderVehicleIW4Test.cpp b/test/ObjLoadingTests/Game/IW4/Vehicle/RawLoaderVehicleIW4Test.cpp new file mode 100644 index 00000000..96f81413 --- /dev/null +++ b/test/ObjLoadingTests/Game/IW4/Vehicle/RawLoaderVehicleIW4Test.cpp @@ -0,0 +1,314 @@ +#include "Game/IW4/Vehicle/RawLoaderVehicleIW4.h" + +#include "SearchPath/MockSearchPath.h" + +#include +#include + +using namespace IW4; +using namespace Catch; +using namespace std::string_literals; + +namespace +{ + XAssetInfo* GivenTestPhysPreset(const std::string& name, Zone& zone) + { + auto& memory = zone.Memory(); + auto* physPreset = memory.Alloc(); + physPreset->name = memory.Dup(name.c_str()); + return zone.m_pools.AddAsset(std::make_unique>(ASSET_TYPE_PHYSPRESET, name, physPreset)); + } + + XAssetInfo* GivenTestWeapon(const std::string& name, Zone& zone) + { + auto& memory = zone.Memory(); + auto* weapon = memory.Alloc(); + weapon->szInternalName = memory.Dup(name.c_str()); + return zone.m_pools.AddAsset(std::make_unique>(ASSET_TYPE_WEAPON, name, weapon)); + } + + IndirectAssetReference GivenTestSound(const std::string& name, Zone& zone) + { + auto& memory = zone.Memory(); + auto* sndAliasList = memory.Alloc(); + sndAliasList->aliasName = memory.Dup(name.c_str()); + + zone.m_pools.AddAsset(std::make_unique>(ASSET_TYPE_SOUND, name, sndAliasList)); + + return IndirectAssetReference(ASSET_TYPE_SOUND, name); + } + + XAssetInfo* GivenTestMaterial(const std::string& name, Zone& zone) + { + auto& memory = zone.Memory(); + auto* material = memory.Alloc(); + material->info.name = memory.Dup(name.c_str()); + return zone.m_pools.AddAsset(std::make_unique>(ASSET_TYPE_MATERIAL, name, material)); + } + + TEST_CASE("Vehicle loader restores stock raw fields (IW4)", "[iw4][vehicle][system]") + { + constexpr auto RAW_VEHICLE = + R"(VEHICLEFILE\type\4 wheel\useHintString\\health\100\quadBarrel\0\textureScrollScale\5.5\topSpeed\60.000000\accel\12.550000)" + R"(\rotRate\60\rotAccel\100\maxBodyPitch\7\maxBodyRoll\7\fakeBodyAccelPitch\0.2\fakeBodyAccelRoll\0.2\fakeBodyVelPitch\0)" + R"(\fakeBodyVelRoll\0\fakeBodySideVelPitch\0\fakeBodyPitchStrength\30\fakeBodyRollStrength\30\fakeBodyPitchDampening\3)" + R"(\fakeBodyRollDampening\3\fakeBodyBoatRockingAmplitude\5\fakeBodyBoatRockingPeriod\3\fakeBodyBoatRockingRotationPeriod\240)" + R"(\fakeBodyBoatRockingFadeoutSpeed\15.000000\boatBouncingMinForce\37.000000\boatBouncingMaxForce\37.000000\boatBouncingRate\1.5)" + R"(\boatBouncingFadeinSpeed\40.000000\boatBouncingFadeoutSteeringAngle\12\collisionDamage\200\collisionSpeed\15.000000)" + R"(\killcamZDist\50\killcamBackDist\1000\killcamUpDist\0\playerProtected\1\bulletDamage\1\armorPiercingDamage\1\grenadeDamage\1)" + R"(\projectileDamage\1\projectileSplashDamage\1\heavyExplosiveDamage\1\physicsEnabled\1\physicsPreset\vehicle_tank\accelerationGraph\tank_accel.graph)" + R"(\steeringAxle\all\powerAxle\all\brakingAxle\all\reverseSpeed\20.000000\maxVelocity\100.000000\maxPitch\60\maxRoll\60)" + R"(\suspensionTravelRear\0\suspensionStrengthFront\40\suspensionDampingFront\2\suspensionStrengthRear\40\suspensionDampingRear\2)" + R"(\frictionBraking\5\frictionCoasting\1\frictionTopSpeed\1\frictionSide\2\frictionSideRear\2\velocityDependentSlip\0.0001)" + R"(\rollStability\0.8\rollResistance\350.000000\pitchResistance\18.000000\yawResistance\350.000000\uprightStrengthPitch\10.000000)" + R"(\uprightStrengthRoll\35.000000\targetAirPitch\0\airYawTorque\1.400000\airPitchTorque\0.350000\minimumMomentumForCollision\300.000000)" + R"(\collisionLaunchForceScale\1.75\wreckedMassScale\0.1\wreckedBodyFriction\0.6\minimumJoltForNotify\2000.000000)" + R"(\slipThresholdFront\800\slipThresholdRear\400\slipFricScaleFront\0.2\slipFricScaleRear\0.1\slipFricRateFront\1\slipFricRateRear\1)" + R"(\slipYawTorque\2.800000\boostDuration\0\boostRechargeTime\0\boostAcceleration\0.000000\suspensionTravel\12\maxSteeringAngle\45)" + R"(\steeringLerp\5\minSteeringScale\1\minSteeringSpeed\0.000000\camLookEnabled\0\camLerp\8\camPitchInfluence\1\camRollInfluence\0.6)" + R"(\camFovIncrease\20\camFovOffset\4\camFovSpeed\65\turretWeaponName\sp/bradley_turret\turretHorizSpanLeft\180\turretHorizSpanRight\180)" + R"(\turretVertSpanUp\30\turretVertSpanDown\15\turretRotRate\30\turretSpinSnd\bradley_turret_spin\turretStopSnd\bradley_turret_stop)" + R"(\trophyEnabled\1\trophyRadius\450\trophyInactiveRadius\400\trophyAmmoCount\30\trophyReloadTime\1\trophyTags\tag_trophy_01_fx +tag_trophy_02_fx +tag_trophy_03_fx +tag_trophy_04_fx)" + R"(\compassFriendlyIcon\hud_minimap_harrier_green\compassEnemyIcon\hud_minimap_harrier_red\compassIconWidth\26\compassIconHeight\26)" + R"(\lowIdleSnd\veh_ambulance_idle_low\highIdleSnd\veh_ambulance_idle_high\lowEngineSnd\veh_ambulance_engine_low)" + R"(\highEngineSnd\veh_ambulance_engine_high\engineSndSpeed\10.000000\engineStartUpSnd\\engineStartUpLength\0\engineShutdownSnd\)" + R"(\engineIdleSnd\snowmobile_2_idle\engineSustainSnd\snowmobile_2_sustain\engineRampUpSnd\snowmobile_2_rampup\engineRampUpLength\3.263)" + R"(\engineRampDownSnd\snowmobile_2_rampdown\engineRampDownLength\5.262\suspensionSoftSnd\snowmobile_suspension_npc)" + R"(\suspensionSoftCompression\0.3\suspensionHardSnd\snowmobile_suspension_heavy_npc\suspensionHardCompression\0.8\collisionSnd\)" + R"(\collisionBlendSpeed\20.000000\collisionSnd\snowmobile_collision\collisionBlendSpeed\20.000000\speedSnd\snowmobile_wind_loop)" + R"(\speedSndBlendSpeed\60.000000\surfaceSndPrefix\snowmobile_surface\surfaceSndBlendSpeed\10.000000\slideVolume\0.8)" + R"(\slideBlendSpeed\20.000000\inAirPitch\1.3)"; + + MockSearchPath loadingSearchPath; + loadingSearchPath.AddFileData("vehicles/test_vehicle", RAW_VEHICLE); + + Zone zone("LoadingZone", 0, GameId::IW4, GamePlatform::PC); + + auto* physPresetInfo = GivenTestPhysPreset("vehicle_tank", zone); + auto* weaponInfo = GivenTestWeapon("sp/bradley_turret", zone); + auto* material0 = GivenTestMaterial("hud_minimap_harrier_green", zone); + auto* material1 = GivenTestMaterial("hud_minimap_harrier_red", zone); + auto sound0 = GivenTestSound("bradley_turret_spin", zone); + auto sound1 = GivenTestSound("bradley_turret_stop", zone); + auto sound2 = GivenTestSound("veh_ambulance_idle_low", zone); + auto sound3 = GivenTestSound("veh_ambulance_idle_high", zone); + auto sound4 = GivenTestSound("veh_ambulance_engine_low", zone); + auto sound5 = GivenTestSound("veh_ambulance_engine_high", zone); + auto sound6 = GivenTestSound("snowmobile_2_idle", zone); + auto sound7 = GivenTestSound("snowmobile_2_sustain", zone); + auto sound8 = GivenTestSound("snowmobile_2_rampup", zone); + auto sound9 = GivenTestSound("snowmobile_2_rampdown", zone); + auto sound10 = GivenTestSound("snowmobile_suspension_npc", zone); + auto sound11 = GivenTestSound("snowmobile_suspension_heavy_npc", zone); + auto sound12 = GivenTestSound("snowmobile_collision", zone); + auto sound13 = GivenTestSound("snowmobile_wind_loop", zone); + auto sound14 = GivenTestSound("snowmobile_surface_default", zone); + + AssetCreatorCollection creatorCollection(zone); + IgnoredAssetLookup ignoredAssetLookup; + AssetCreationContext loadingContext(zone, &creatorCollection, &ignoredAssetLookup); + const auto loader = vehicle::CreateRawLoaderIW4(zone.Memory(), loadingSearchPath, zone); + const auto result = loader->CreateAsset("test_vehicle", loadingContext); + + REQUIRE(result.HasBeenSuccessful()); + const auto* loadedAssetInfo = reinterpret_cast*>(result.GetAssetInfo()); + const auto* loadedVehicle = loadedAssetInfo->Asset(); + + REQUIRE(std::string(loadedVehicle->name) == "test_vehicle"); + REQUIRE(loadedVehicle->type == VEH_WHEELS_4); + REQUIRE(loadedVehicle->health == 100); + REQUIRE(loadedVehicle->quadBarrel == 0); + REQUIRE(loadedVehicle->texScrollScale == Approx(5.5f)); + REQUIRE(loadedVehicle->topSpeed == Approx(1056.0f)); + REQUIRE(loadedVehicle->accel == Approx(220.88f)); + REQUIRE(loadedVehicle->rotRate == Approx(60.0f)); + REQUIRE(loadedVehicle->rotAccel == Approx(100.0f)); + REQUIRE(loadedVehicle->maxBodyPitch == Approx(7.0f)); + REQUIRE(loadedVehicle->maxBodyRoll == Approx(7.0f)); + REQUIRE(loadedVehicle->fakeBodyAccelPitch == Approx(0.2f)); + REQUIRE(loadedVehicle->fakeBodyAccelRoll == Approx(0.2f)); + REQUIRE(loadedVehicle->fakeBodyVelPitch == Approx(0.0f)); + REQUIRE(loadedVehicle->fakeBodyVelRoll == Approx(0.0f)); + REQUIRE(loadedVehicle->fakeBodySideVelPitch == Approx(0.0f)); + REQUIRE(loadedVehicle->fakeBodyPitchStrength == Approx(30.0f)); + REQUIRE(loadedVehicle->fakeBodyRollStrength == Approx(30.0f)); + REQUIRE(loadedVehicle->fakeBodyPitchDampening == Approx(3.0f)); + REQUIRE(loadedVehicle->fakeBodyRollDampening == Approx(3.0f)); + REQUIRE(loadedVehicle->fakeBodyBoatRockingAmplitude == Approx(5.0f)); + REQUIRE(loadedVehicle->fakeBodyBoatRockingPeriod == Approx(3.0f)); + REQUIRE(loadedVehicle->fakeBodyBoatRockingRotationPeriod == Approx(240.0f)); + REQUIRE(loadedVehicle->fakeBodyBoatRockingFadeoutSpeed == Approx(264.0f)); + REQUIRE(loadedVehicle->boatBouncingMinForce == Approx(651.2f)); + REQUIRE(loadedVehicle->boatBouncingMaxForce == Approx(651.2f)); + REQUIRE(loadedVehicle->boatBouncingRate == Approx(1.5f)); + REQUIRE(loadedVehicle->boatBouncingFadeinSpeed == Approx(704.0f)); + REQUIRE(loadedVehicle->boatBouncingFadeoutSteeringAngle == Approx(12.0f)); + REQUIRE(loadedVehicle->collisionDamage == Approx(200.0f)); + REQUIRE(loadedVehicle->collisionSpeed == Approx(264.0f)); + REQUIRE(loadedVehicle->killcamOffset[0] == Approx(50.0f)); + REQUIRE(loadedVehicle->killcamOffset[1] == Approx(1000.0f)); + REQUIRE(loadedVehicle->killcamOffset[2] == Approx(0.0f)); + REQUIRE(loadedVehicle->playerProtected == 1); + REQUIRE(loadedVehicle->bulletDamage == 1); + REQUIRE(loadedVehicle->armorPiercingDamage == 1); + REQUIRE(loadedVehicle->grenadeDamage == 1); + REQUIRE(loadedVehicle->projectileDamage == 1); + REQUIRE(loadedVehicle->projectileSplashDamage == 1); + REQUIRE(loadedVehicle->heavyExplosiveDamage == 1); + REQUIRE(loadedVehicle->vehPhysDef.physicsEnabled == 1); + REQUIRE(loadedVehicle->vehPhysDef.physPresetName == "vehicle_tank"s); + REQUIRE(loadedVehicle->vehPhysDef.physPreset); + REQUIRE(loadedVehicle->vehPhysDef.physPreset->name == "vehicle_tank"s); + REQUIRE(loadedVehicle->vehPhysDef.accelGraphName == "tank_accel.graph"s); + REQUIRE(loadedVehicle->vehPhysDef.steeringAxle == VEH_AXLE_ALL); + REQUIRE(loadedVehicle->vehPhysDef.powerAxle == VEH_AXLE_ALL); + REQUIRE(loadedVehicle->vehPhysDef.brakingAxle == VEH_AXLE_ALL); + REQUIRE(loadedVehicle->vehPhysDef.reverseSpeed == Approx(352.0f)); + REQUIRE(loadedVehicle->vehPhysDef.maxVelocity == Approx(1760.0f)); + REQUIRE(loadedVehicle->vehPhysDef.maxPitch == Approx(60.0f)); + REQUIRE(loadedVehicle->vehPhysDef.maxRoll == Approx(60.0f)); + REQUIRE(loadedVehicle->vehPhysDef.suspensionTravelRear == Approx(0.0f)); + REQUIRE(loadedVehicle->vehPhysDef.suspensionStrengthFront == Approx(40.0f)); + REQUIRE(loadedVehicle->vehPhysDef.suspensionDampingFront == Approx(2.0f)); + REQUIRE(loadedVehicle->vehPhysDef.suspensionStrengthRear == Approx(40.0f)); + REQUIRE(loadedVehicle->vehPhysDef.suspensionDampingRear == Approx(2.0f)); + REQUIRE(loadedVehicle->vehPhysDef.frictionBraking == Approx(5.0f)); + REQUIRE(loadedVehicle->vehPhysDef.frictionCoasting == Approx(1.0f)); + REQUIRE(loadedVehicle->vehPhysDef.frictionTopSpeed == Approx(1.0f)); + REQUIRE(loadedVehicle->vehPhysDef.frictionSide == Approx(2.0f)); + REQUIRE(loadedVehicle->vehPhysDef.frictionSideRear == Approx(2.0f)); + REQUIRE(loadedVehicle->vehPhysDef.velocityDependentSlip == Approx(0.0001f)); + REQUIRE(loadedVehicle->vehPhysDef.rollStability == Approx(0.8f)); + REQUIRE(loadedVehicle->vehPhysDef.rollResistance == Approx(6160.0f)); + REQUIRE(loadedVehicle->vehPhysDef.pitchResistance == Approx(316.8f)); + REQUIRE(loadedVehicle->vehPhysDef.yawResistance == Approx(6160.0f)); + REQUIRE(loadedVehicle->vehPhysDef.uprightStrengthPitch == Approx(176.0f)); + REQUIRE(loadedVehicle->vehPhysDef.uprightStrengthRoll == Approx(616.0f)); + REQUIRE(loadedVehicle->vehPhysDef.targetAirPitch == Approx(0.0f)); + REQUIRE(loadedVehicle->vehPhysDef.airYawTorque == Approx(24.64f)); + REQUIRE(loadedVehicle->vehPhysDef.airPitchTorque == Approx(6.16f)); + REQUIRE(loadedVehicle->vehPhysDef.minimumMomentumForCollision == Approx(5280.0f)); + REQUIRE(loadedVehicle->vehPhysDef.collisionLaunchForceScale == Approx(1.75f)); + REQUIRE(loadedVehicle->vehPhysDef.wreckedMassScale == Approx(0.1f)); + REQUIRE(loadedVehicle->vehPhysDef.wreckedBodyFriction == Approx(0.6f)); + REQUIRE(loadedVehicle->vehPhysDef.minimumJoltForNotify == Approx(35200.0f)); + REQUIRE(loadedVehicle->vehPhysDef.slipThresholdFront == Approx(800.0f)); + REQUIRE(loadedVehicle->vehPhysDef.slipThresholdRear == Approx(400.0f)); + REQUIRE(loadedVehicle->vehPhysDef.slipFricScaleFront == Approx(0.2f)); + REQUIRE(loadedVehicle->vehPhysDef.slipFricScaleRear == Approx(0.1f)); + REQUIRE(loadedVehicle->vehPhysDef.slipFricRateFront == Approx(1.0f)); + REQUIRE(loadedVehicle->vehPhysDef.slipFricRateRear == Approx(1.0f)); + REQUIRE(loadedVehicle->vehPhysDef.slipYawTorque == Approx(49.28f)); + REQUIRE(loadedVehicle->boostDuration == Approx(0.0f)); + REQUIRE(loadedVehicle->boostRechargeTime == Approx(0.0f)); + REQUIRE(loadedVehicle->boostAcceleration == Approx(0.0f)); + REQUIRE(loadedVehicle->suspensionTravel == Approx(12.0f)); + REQUIRE(loadedVehicle->maxSteeringAngle == Approx(45.0f)); + REQUIRE(loadedVehicle->steeringLerp == Approx(5.0f)); + REQUIRE(loadedVehicle->minSteeringScale == Approx(1.0f)); + REQUIRE(loadedVehicle->minSteeringSpeed == Approx(0.0f)); + REQUIRE(loadedVehicle->camLookEnabled == Approx(0.0f)); + REQUIRE(loadedVehicle->camLerp == Approx(8.0f)); + REQUIRE(loadedVehicle->camPitchInfluence == Approx(1.0f)); + REQUIRE(loadedVehicle->camRollInfluence == Approx(0.6f)); + REQUIRE(loadedVehicle->camFovIncrease == Approx(20.0f)); + REQUIRE(loadedVehicle->camFovOffset == Approx(4.0f)); + REQUIRE(loadedVehicle->camFovSpeed == Approx(65.0f)); + REQUIRE(loadedVehicle->turretWeaponName == "sp/bradley_turret"s); + REQUIRE(loadedVehicle->turretHorizSpanLeft == Approx(180.0f)); + REQUIRE(loadedVehicle->turretHorizSpanRight == Approx(180.0f)); + REQUIRE(loadedVehicle->turretVertSpanUp == Approx(30.0f)); + REQUIRE(loadedVehicle->turretVertSpanDown == Approx(15.0f)); + REQUIRE(loadedVehicle->turretRotRate == Approx(30.0f)); + REQUIRE(loadedVehicle->turretSpinSnd.name); + REQUIRE(loadedVehicle->turretSpinSnd.name->soundName == "bradley_turret_spin"s); + REQUIRE(loadedVehicle->turretStopSnd.name); + REQUIRE(loadedVehicle->turretStopSnd.name->soundName == "bradley_turret_stop"s); + REQUIRE(loadedVehicle->trophyEnabled == 1); + REQUIRE(loadedVehicle->trophyRadius == Approx(450.0f)); + REQUIRE(loadedVehicle->trophyInactiveRadius == Approx(400.0f)); + REQUIRE(loadedVehicle->trophyAmmoCount == Approx(30.0f)); + REQUIRE(loadedVehicle->trophyReloadTime == Approx(1.0f)); + REQUIRE(zone.m_script_strings.Value(loadedVehicle->trophyTags[0]) == "tag_trophy_01_fx"s); + REQUIRE(zone.m_script_strings.Value(loadedVehicle->trophyTags[1]) == "tag_trophy_02_fx"s); + REQUIRE(zone.m_script_strings.Value(loadedVehicle->trophyTags[2]) == "tag_trophy_03_fx"s); + REQUIRE(zone.m_script_strings.Value(loadedVehicle->trophyTags[3]) == "tag_trophy_04_fx"s); + REQUIRE(loadedVehicle->compassFriendlyIcon); + REQUIRE(loadedVehicle->compassFriendlyIcon->info.name == "hud_minimap_harrier_green"s); + REQUIRE(loadedVehicle->compassEnemyIcon); + REQUIRE(loadedVehicle->compassEnemyIcon->info.name == "hud_minimap_harrier_red"s); + REQUIRE(loadedVehicle->compassIconWidth == 26); + REQUIRE(loadedVehicle->compassIconHeight == 26); + REQUIRE(loadedVehicle->idleLowSnd.name); + REQUIRE(loadedVehicle->idleLowSnd.name->soundName == "veh_ambulance_idle_low"s); + REQUIRE(loadedVehicle->idleHighSnd.name); + REQUIRE(loadedVehicle->idleHighSnd.name->soundName == "veh_ambulance_idle_high"s); + REQUIRE(loadedVehicle->engineLowSnd.name); + REQUIRE(loadedVehicle->engineLowSnd.name->soundName == "veh_ambulance_engine_low"s); + REQUIRE(loadedVehicle->engineHighSnd.name); + REQUIRE(loadedVehicle->engineHighSnd.name->soundName == "veh_ambulance_engine_high"s); + REQUIRE(loadedVehicle->engineSndSpeed == Approx(176.0f)); + REQUIRE(loadedVehicle->engineStartUpSnd.name == nullptr); + REQUIRE(loadedVehicle->engineStartUpLength == 0); + REQUIRE(loadedVehicle->engineShutdownSnd.name == nullptr); + REQUIRE(loadedVehicle->engineIdleSnd.name); + REQUIRE(loadedVehicle->engineIdleSnd.name->soundName == "snowmobile_2_idle"s); + REQUIRE(loadedVehicle->engineSustainSnd.name); + REQUIRE(loadedVehicle->engineSustainSnd.name->soundName == "snowmobile_2_sustain"s); + REQUIRE(loadedVehicle->engineRampUpSnd.name); + REQUIRE(loadedVehicle->engineRampUpSnd.name->soundName == "snowmobile_2_rampup"s); + REQUIRE(loadedVehicle->engineRampUpLength == 3263); + REQUIRE(loadedVehicle->engineRampDownSnd.name); + REQUIRE(loadedVehicle->engineRampDownSnd.name->soundName == "snowmobile_2_rampdown"s); + REQUIRE(loadedVehicle->engineRampDownLength == 5262); + REQUIRE(loadedVehicle->suspensionSoftSnd.name); + REQUIRE(loadedVehicle->suspensionSoftSnd.name->soundName == "snowmobile_suspension_npc"s); + REQUIRE(loadedVehicle->suspensionSoftCompression == Approx(0.3f)); + REQUIRE(loadedVehicle->suspensionHardSnd.name); + REQUIRE(loadedVehicle->suspensionHardSnd.name->soundName == "snowmobile_suspension_heavy_npc"s); + REQUIRE(loadedVehicle->suspensionHardCompression == Approx(0.8f)); + REQUIRE(loadedVehicle->collisionSnd.name); + REQUIRE(loadedVehicle->collisionSnd.name->soundName == "snowmobile_collision"s); + REQUIRE(loadedVehicle->collisionBlendSpeed == Approx(352.0f)); + REQUIRE(loadedVehicle->speedSnd.name); + REQUIRE(loadedVehicle->speedSnd.name->soundName == "snowmobile_wind_loop"s); + REQUIRE(loadedVehicle->speedSndBlendSpeed == Approx(1056.0f)); + REQUIRE(loadedVehicle->surfaceSndPrefix == "snowmobile_surface"s); + REQUIRE(loadedVehicle->surfaceSndBlendSpeed == Approx(176.0f)); + REQUIRE(loadedVehicle->slideVolume == Approx(0.8f)); + REQUIRE(loadedVehicle->slideBlendSpeed == Approx(352.0f)); + REQUIRE(loadedVehicle->inAirPitch == Approx(1.3f)); + + REQUIRE(loadedVehicle->vehPhysDef.topSpeed == Approx(loadedVehicle->topSpeed)); + REQUIRE(loadedVehicle->vehPhysDef.suspensionTravelFront == Approx(loadedVehicle->suspensionTravel)); + + REQUIRE(std::string(loadedVehicle->surfaceSnds[SURF_TYPE_DEFAULT].name->soundName) == "snowmobile_surface_default"); + REQUIRE(std::string(loadedVehicle->surfaceSnds[SURF_TYPE_SLUSH].name->soundName) == "snowmobile_surface_slush"); + + REQUIRE(loadedAssetInfo->m_dependencies.size() == 4u); + REQUIRE(std::ranges::find(loadedAssetInfo->m_dependencies, physPresetInfo) != loadedAssetInfo->m_dependencies.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_dependencies, weaponInfo) != loadedAssetInfo->m_dependencies.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_dependencies, material0) != loadedAssetInfo->m_dependencies.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_dependencies, material1) != loadedAssetInfo->m_dependencies.end()); + REQUIRE(loadedAssetInfo->m_used_script_strings.size() == 4u); + REQUIRE(loadedAssetInfo->m_indirect_asset_references.size() == 45u); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound0) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound1) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound2) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound3) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound4) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound5) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound6) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound7) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound8) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound9) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound10) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound11) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound12) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound13) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound14) != loadedAssetInfo->m_indirect_asset_references.end()); + } +} // namespace diff --git a/test/ObjLoadingTests/Game/IW5/Vehicle/RawLoaderVehicleIW5Test.cpp b/test/ObjLoadingTests/Game/IW5/Vehicle/RawLoaderVehicleIW5Test.cpp new file mode 100644 index 00000000..4479125a --- /dev/null +++ b/test/ObjLoadingTests/Game/IW5/Vehicle/RawLoaderVehicleIW5Test.cpp @@ -0,0 +1,433 @@ +#include "Game/IW5/Vehicle/RawLoaderVehicleIW5.h" + +#include "SearchPath/MockSearchPath.h" + +#include +#include + +using namespace IW5; +using namespace Catch; +using namespace std::string_literals; + +namespace +{ + XAssetInfo* GivenTestPhysPreset(const std::string& name, Zone& zone) + { + auto& memory = zone.Memory(); + auto* physPreset = memory.Alloc(); + physPreset->name = memory.Dup(name.c_str()); + return zone.m_pools.AddAsset(std::make_unique>(ASSET_TYPE_PHYSPRESET, name, physPreset)); + } + + XAssetInfo* GivenTestWeapon(const std::string& name, Zone& zone) + { + auto& memory = zone.Memory(); + auto* weapon = memory.Alloc(); + weapon->szInternalName = memory.Dup(name.c_str()); + return zone.m_pools.AddAsset(std::make_unique>(ASSET_TYPE_WEAPON, name, weapon)); + } + + IndirectAssetReference GivenTestSound(const std::string& name, Zone& zone) + { + auto& memory = zone.Memory(); + auto* sndAliasList = memory.Alloc(); + sndAliasList->aliasName = memory.Dup(name.c_str()); + + zone.m_pools.AddAsset(std::make_unique>(ASSET_TYPE_SOUND, name, sndAliasList)); + + return IndirectAssetReference(ASSET_TYPE_SOUND, name); + } + + XAssetInfo* GivenTestMaterial(const std::string& name, Zone& zone) + { + auto& memory = zone.Memory(); + auto* material = memory.Alloc(); + material->info.name = memory.Dup(name.c_str()); + return zone.m_pools.AddAsset(std::make_unique>(ASSET_TYPE_MATERIAL, name, material)); + } + + XAssetInfo* GivenTestFx(const std::string& name, Zone& zone) + { + auto& memory = zone.Memory(); + auto* fx = memory.Alloc(); + fx->name = memory.Dup(name.c_str()); + return zone.m_pools.AddAsset(std::make_unique>(ASSET_TYPE_FX, name, fx)); + } + + TEST_CASE("Vehicle loader restores stock raw fields (IW5)", "[iw5][vehicle][system]") + { + constexpr auto RAW_VEHICLE = + R"(VEHICLEFILE\type\4 wheel\useHintString\\health\100\quadBarrel\0\textureScrollScale\5.5\topSpeed\60.000000\accel\12.550000)" + R"(\rotRate\60\rotAccel\100\maxBodyPitch\7\maxBodyRoll\7\fakeBodyStabilizer\1\fakeBodyStabilizer\1\fakeBodyAccelPitch\0.2)" + R"(\fakeBodyAccelRoll\0.2\fakeBodyVelPitch\0\fakeBodyVelRoll\0\fakeBodySideVelPitch\0\fakeBodyPitchStrength\30)" + R"(\fakeBodyRollStrength\30\fakeBodyPitchDampening\3\fakeBodyRollDampening\3)" + R"(\fakeBodyBoatRockingAmplitude\5\fakeBodyBoatRockingPeriod\3\fakeBodyBoatRockingRotationPeriod\240)" + R"(\fakeBodyBoatRockingFadeoutSpeed\15.000000\boatBouncingMinForce\37.000000\boatBouncingMaxForce\37.000000\boatBouncingRate\1.5)" + R"(\boatBouncingFadeinSpeed\40.000000\boatBouncingFadeoutSteeringAngle\12\collisionDamage\200\collisionSpeed\15.000000)" + R"(\killcamZDist\50\killcamBackDist\1000\killcamUpDist\0\playerProtected\1\bulletDamage\1\armorPiercingDamage\1\grenadeDamage\1)" + R"(\projectileDamage\1\projectileSplashDamage\1\heavyExplosiveDamage\1\physicsEnabled\1\physicsPreset\vehicle_tank\accelerationGraph\tank_accel.graph)" + R"(\steeringAxle\all\powerAxle\all\brakingAxle\all\reverseSpeed\20.000000\maxVelocity\100.000000\maxPitch\60\maxRoll\60)" + R"(\suspensionTravelRear\0\suspensionStrengthFront\40\suspensionDampingFront\2\suspensionStrengthRear\40\suspensionDampingRear\2)" + R"(\frictionBraking\5\frictionCoasting\1\frictionTopSpeed\1\frictionSide\2\frictionSideRear\2\velocityDependentSlip\0.0001)" + R"(\rollStability\0.8\rollResistance\350.000000\pitchResistance\18.000000\yawResistance\350.000000\uprightStrengthPitch\10.000000)" + R"(\uprightStrengthRoll\35.000000\targetAirPitch\0\airYawTorque\1.400000\airPitchTorque\0.350000\minimumMomentumForCollision\300.000000)" + R"(\collisionLaunchForceScale\1.75\wreckedMassScale\0.1\wreckedBodyFriction\0.6\minimumJoltForNotify\2000.000000)" + R"(\slipThresholdFront\800\slipThresholdRear\400\slipFricScaleFront\0.2\slipFricScaleRear\0.1\slipFricRateFront\1\slipFricRateRear\1)" + R"(\slipYawTorque\2.800000\boostDuration\0\boostRechargeTime\0\boostAcceleration\0.000000\suspensionTravel\12\maxSteeringAngle\45)" + R"(\steeringLerp\5\minSteeringScale\1\minSteeringSpeed\0.000000)" + R"(\vehHelicopterBoundsRadius\1.0\vehHelicopterMaxSpeed\2.0\vehHelicopterMaxSpeedVertical\3.0\vehHelicopterMaxAccel\4.0)" + R"(\vehHelicopterMaxAccelVertical\5.0\vehHelicopterDecelerationFwd\6.0\vehHelicopterDecelerationSide\7.0\vehHelicopterDecelerationUp\8.0)" + R"(\vehHelicopterMaxYawRate\9.0\vehHelicopterMaxYawAccel\10.0\vehHelicopterTiltFromVelocity\11.0\vehHelicopterTiltFromControllerAxes\12.0)" + R"(\vehHelicopterTiltFromAcceleration\13.0\vehHelicopterTiltFromDeceleration\14.0)" + R"(\vehHelicopterTiltFromFwdAndYaw_VelAtMaxTilt\15.0\vehHelicopterTiltFromFwdAndYaw\16.0\vehHelicopterTiltMomentum\17.0)" + R"(\vehHelicopterTiltSpeed\18.0\vehHelicopterMaxPitch\19.0\vehHelicopterMaxRoll\20.0\vehHelicopterHoverSpeedThreshold\21.0)" + R"(\vehHelicopterJitterJerkyness\22.0\vehHelicopterLookaheadTime\23.0\vehHelicopterSoftCollisions\1)" + R"(\camLookEnabled\0\camRelativeControl\1\camLerp\8\camHeight\9.0\camRadius\10.0\camPitchInfluence\1\camYawInfluence\2\camRollInfluence\0.6)" + R"(\camFovIncrease\20\camFovOffset\4\camFovSpeed\65\camReturnSpeed\1\camReturnLerp\2\vehCam_UseGDT\1\vehCam_anglesPitch\4\vehCam_anglesYaw\5)" + R"(\vehCam_anglesRoll\6\vehCam_offsetX\7\vehCam_offsetY\8\vehCam_offsetZ\9\vehCam_radius\10\vehCam_speedInfluence\11\vehCam_pitchTurnRate\12)" + R"(\vehCam_pitchClamp\13\vehCam_yawTurnRate\14\vehCam_yawClamp\15\vehCam_zOffsetMode\world\vehCam_anglesPitch3P\17\vehCam_anglesYaw3P\18)" + R"(\vehCam_anglesRoll3P\19\vehCam_offsetX3P\20\vehCam_offsetY3P\21\vehCam_offsetZ3P\22\vehCam_radius3P\23\vehCam_speedInfluence3P\24)" + R"(\vehCam_pitchTurnRate3P\25\vehCam_pitchClamp3P\26\vehCam_yawTurnRate3P\27\vehCam_yawClamp3P\28\vehCam_zOffsetMode3P\vehicle\)" + R"(turretWeaponName\sp/bradley_turret\turretHorizSpanLeft\180\turretHorizSpanRight\180)" + R"(\turretVertSpanUp\30\turretVertSpanDown\15\turretHorizResistLeft\1\turretHorizResistRight\2\turretVertResistUp\3\turretVertResistDown\4)" + R"(\turretRotRate\30\turretSpinSnd\bradley_turret_spin\turretStopSnd\bradley_turret_stop)" + R"(\trophyEnabled\1\trophyRadius\450\trophyInactiveRadius\400\trophyAmmoCount\30\trophyReloadTime\1\trophyTags\tag_trophy_01_fx +tag_trophy_02_fx +tag_trophy_03_fx +tag_trophy_04_fx\trophyExplodeFx\testfx1\trophyFlashFx\testfx2)" + R"(\compassFriendlyIcon\hud_minimap_harrier_green\compassEnemyIcon\hud_minimap_harrier_red\compassFriendlyAltIcon\hud_minimap_harrier_alt_green)" + R"(\compassEnemyAltIcon\hud_minimap_harrier_alt_red\compassIconWidth\26\compassIconHeight\26)" + R"(\lowIdleSnd\veh_ambulance_idle_low\highIdleSnd\veh_ambulance_idle_high\lowEngineSnd\veh_ambulance_engine_low)" + R"(\highEngineSnd\veh_ambulance_engine_high\engineSndSpeed\10.000000\audioOriginTag\foo1\lowIdleSndAlt\foo2\highIdleSndAlt\foo3\)" + R"(lowEngineSndAlt\foo4\highEngineSndAlt\foo5\engineSndSpeedAlt\3\audioOriginTagAlt\foo6\turretSpinSndAlt\foo7\turretStopSndAlt\foo8)" + R"(\engineStartUpSnd\\engineStartUpLength\0\engineShutdownSnd\)" + R"(\engineIdleSnd\snowmobile_2_idle\engineSustainSnd\snowmobile_2_sustain\engineRampUpSnd\snowmobile_2_rampup\engineRampUpLength\3.263)" + R"(\engineRampDownSnd\snowmobile_2_rampdown\engineRampDownLength\5.262\suspensionSoftSnd\snowmobile_suspension_npc)" + R"(\suspensionSoftCompression\0.3\suspensionHardSnd\snowmobile_suspension_heavy_npc\suspensionHardCompression\0.8\collisionSnd\)" + R"(\collisionBlendSpeed\20.000000\collisionSnd\snowmobile_collision\collisionBlendSpeed\20.000000\speedSnd\snowmobile_wind_loop)" + R"(\speedSndBlendSpeed\60.000000\surfaceSndPrefix\snowmobile_surface\surfaceSndBlendSpeed\10.000000\slideVolume\0.8)" + R"(\slideBlendSpeed\20.000000\inAirPitch\1.3)"; + + MockSearchPath loadingSearchPath; + loadingSearchPath.AddFileData("vehicles/test_vehicle", RAW_VEHICLE); + + Zone zone("LoadingZone", 0, GameId::IW5, GamePlatform::PC); + + auto* physPresetInfo = GivenTestPhysPreset("vehicle_tank", zone); + auto* weaponInfo = GivenTestWeapon("sp/bradley_turret", zone); + auto* material0 = GivenTestMaterial("hud_minimap_harrier_green", zone); + auto* material1 = GivenTestMaterial("hud_minimap_harrier_red", zone); + auto* material2 = GivenTestMaterial("hud_minimap_harrier_alt_green", zone); + auto* material3 = GivenTestMaterial("hud_minimap_harrier_alt_red", zone); + auto* fx0 = GivenTestFx("testfx1", zone); + auto* fx1 = GivenTestFx("testfx2", zone); + auto sound0 = GivenTestSound("bradley_turret_spin", zone); + auto sound1 = GivenTestSound("bradley_turret_stop", zone); + auto sound2 = GivenTestSound("veh_ambulance_idle_low", zone); + auto sound3 = GivenTestSound("veh_ambulance_idle_high", zone); + auto sound4 = GivenTestSound("veh_ambulance_engine_low", zone); + auto sound5 = GivenTestSound("veh_ambulance_engine_high", zone); + auto sound6 = GivenTestSound("snowmobile_2_idle", zone); + auto sound7 = GivenTestSound("snowmobile_2_sustain", zone); + auto sound8 = GivenTestSound("snowmobile_2_rampup", zone); + auto sound9 = GivenTestSound("snowmobile_2_rampdown", zone); + auto sound10 = GivenTestSound("snowmobile_suspension_npc", zone); + auto sound11 = GivenTestSound("snowmobile_suspension_heavy_npc", zone); + auto sound12 = GivenTestSound("snowmobile_collision", zone); + auto sound13 = GivenTestSound("snowmobile_wind_loop", zone); + auto sound14 = GivenTestSound("snowmobile_surface_default", zone); + + AssetCreatorCollection creatorCollection(zone); + IgnoredAssetLookup ignoredAssetLookup; + AssetCreationContext loadingContext(zone, &creatorCollection, &ignoredAssetLookup); + const auto loader = vehicle::CreateRawLoaderIW5(zone.Memory(), loadingSearchPath, zone); + const auto result = loader->CreateAsset("test_vehicle", loadingContext); + + REQUIRE(result.HasBeenSuccessful()); + const auto* loadedAssetInfo = reinterpret_cast*>(result.GetAssetInfo()); + const auto* loadedVehicle = loadedAssetInfo->Asset(); + + REQUIRE(std::string(loadedVehicle->name) == "test_vehicle"); + REQUIRE(loadedVehicle->type == VEH_WHEELS_4); + REQUIRE(loadedVehicle->health == 100); + REQUIRE(loadedVehicle->quadBarrel == 0); + REQUIRE(loadedVehicle->texScrollScale == Approx(5.5f)); + REQUIRE(loadedVehicle->topSpeed == Approx(1056.0f)); + REQUIRE(loadedVehicle->accel == Approx(220.88f)); + REQUIRE(loadedVehicle->rotRate == Approx(60.0f)); + REQUIRE(loadedVehicle->rotAccel == Approx(100.0f)); + REQUIRE(loadedVehicle->maxBodyPitch == Approx(7.0f)); + REQUIRE(loadedVehicle->maxBodyRoll == Approx(7.0f)); + REQUIRE(loadedVehicle->fakeBodyStabilizer == 1); + REQUIRE(loadedVehicle->fakeBodyAccelPitch == Approx(0.2f)); + REQUIRE(loadedVehicle->fakeBodyAccelRoll == Approx(0.2f)); + REQUIRE(loadedVehicle->fakeBodyVelPitch == Approx(0.0f)); + REQUIRE(loadedVehicle->fakeBodyVelRoll == Approx(0.0f)); + REQUIRE(loadedVehicle->fakeBodySideVelPitch == Approx(0.0f)); + REQUIRE(loadedVehicle->fakeBodyPitchStrength == Approx(30.0f)); + REQUIRE(loadedVehicle->fakeBodyRollStrength == Approx(30.0f)); + REQUIRE(loadedVehicle->fakeBodyPitchDampening == Approx(3.0f)); + REQUIRE(loadedVehicle->fakeBodyRollDampening == Approx(3.0f)); + REQUIRE(loadedVehicle->fakeBodyBoatRockingAmplitude == Approx(5.0f)); + REQUIRE(loadedVehicle->fakeBodyBoatRockingPeriod == Approx(3.0f)); + REQUIRE(loadedVehicle->fakeBodyBoatRockingRotationPeriod == Approx(240.0f)); + REQUIRE(loadedVehicle->fakeBodyBoatRockingFadeoutSpeed == Approx(264.0f)); + REQUIRE(loadedVehicle->boatBouncingMinForce == Approx(651.2f)); + REQUIRE(loadedVehicle->boatBouncingMaxForce == Approx(651.2f)); + REQUIRE(loadedVehicle->boatBouncingRate == Approx(1.5f)); + REQUIRE(loadedVehicle->boatBouncingFadeinSpeed == Approx(704.0f)); + REQUIRE(loadedVehicle->boatBouncingFadeoutSteeringAngle == Approx(12.0f)); + REQUIRE(loadedVehicle->collisionDamage == Approx(200.0f)); + REQUIRE(loadedVehicle->collisionSpeed == Approx(264.0f)); + REQUIRE(loadedVehicle->killcamOffset[0] == Approx(50.0f)); + REQUIRE(loadedVehicle->killcamOffset[1] == Approx(1000.0f)); + REQUIRE(loadedVehicle->killcamOffset[2] == Approx(0.0f)); + REQUIRE(loadedVehicle->playerProtected == 1); + REQUIRE(loadedVehicle->bulletDamage == 1); + REQUIRE(loadedVehicle->armorPiercingDamage == 1); + REQUIRE(loadedVehicle->grenadeDamage == 1); + REQUIRE(loadedVehicle->projectileDamage == 1); + REQUIRE(loadedVehicle->projectileSplashDamage == 1); + REQUIRE(loadedVehicle->heavyExplosiveDamage == 1); + REQUIRE(loadedVehicle->vehPhysDef.physicsEnabled == 1); + REQUIRE(loadedVehicle->vehPhysDef.physPresetName == "vehicle_tank"s); + REQUIRE(loadedVehicle->vehPhysDef.physPreset); + REQUIRE(loadedVehicle->vehPhysDef.physPreset->name == "vehicle_tank"s); + REQUIRE(loadedVehicle->vehPhysDef.accelGraphName == "tank_accel.graph"s); + REQUIRE(loadedVehicle->vehPhysDef.steeringAxle == VEH_AXLE_ALL); + REQUIRE(loadedVehicle->vehPhysDef.powerAxle == VEH_AXLE_ALL); + REQUIRE(loadedVehicle->vehPhysDef.brakingAxle == VEH_AXLE_ALL); + REQUIRE(loadedVehicle->vehPhysDef.reverseSpeed == Approx(352.0f)); + REQUIRE(loadedVehicle->vehPhysDef.maxVelocity == Approx(1760.0f)); + REQUIRE(loadedVehicle->vehPhysDef.maxPitch == Approx(60.0f)); + REQUIRE(loadedVehicle->vehPhysDef.maxRoll == Approx(60.0f)); + REQUIRE(loadedVehicle->vehPhysDef.suspensionTravelRear == Approx(0.0f)); + REQUIRE(loadedVehicle->vehPhysDef.suspensionStrengthFront == Approx(40.0f)); + REQUIRE(loadedVehicle->vehPhysDef.suspensionDampingFront == Approx(2.0f)); + REQUIRE(loadedVehicle->vehPhysDef.suspensionStrengthRear == Approx(40.0f)); + REQUIRE(loadedVehicle->vehPhysDef.suspensionDampingRear == Approx(2.0f)); + REQUIRE(loadedVehicle->vehPhysDef.frictionBraking == Approx(5.0f)); + REQUIRE(loadedVehicle->vehPhysDef.frictionCoasting == Approx(1.0f)); + REQUIRE(loadedVehicle->vehPhysDef.frictionTopSpeed == Approx(1.0f)); + REQUIRE(loadedVehicle->vehPhysDef.frictionSide == Approx(2.0f)); + REQUIRE(loadedVehicle->vehPhysDef.frictionSideRear == Approx(2.0f)); + REQUIRE(loadedVehicle->vehPhysDef.velocityDependentSlip == Approx(0.0001f)); + REQUIRE(loadedVehicle->vehPhysDef.rollStability == Approx(0.8f)); + REQUIRE(loadedVehicle->vehPhysDef.rollResistance == Approx(6160.0f)); + REQUIRE(loadedVehicle->vehPhysDef.pitchResistance == Approx(316.8f)); + REQUIRE(loadedVehicle->vehPhysDef.yawResistance == Approx(6160.0f)); + REQUIRE(loadedVehicle->vehPhysDef.uprightStrengthPitch == Approx(176.0f)); + REQUIRE(loadedVehicle->vehPhysDef.uprightStrengthRoll == Approx(616.0f)); + REQUIRE(loadedVehicle->vehPhysDef.targetAirPitch == Approx(0.0f)); + REQUIRE(loadedVehicle->vehPhysDef.airYawTorque == Approx(24.64f)); + REQUIRE(loadedVehicle->vehPhysDef.airPitchTorque == Approx(6.16f)); + REQUIRE(loadedVehicle->vehPhysDef.minimumMomentumForCollision == Approx(5280.0f)); + REQUIRE(loadedVehicle->vehPhysDef.collisionLaunchForceScale == Approx(1.75f)); + REQUIRE(loadedVehicle->vehPhysDef.wreckedMassScale == Approx(0.1f)); + REQUIRE(loadedVehicle->vehPhysDef.wreckedBodyFriction == Approx(0.6f)); + REQUIRE(loadedVehicle->vehPhysDef.minimumJoltForNotify == Approx(35200.0f)); + REQUIRE(loadedVehicle->vehPhysDef.slipThresholdFront == Approx(800.0f)); + REQUIRE(loadedVehicle->vehPhysDef.slipThresholdRear == Approx(400.0f)); + REQUIRE(loadedVehicle->vehPhysDef.slipFricScaleFront == Approx(0.2f)); + REQUIRE(loadedVehicle->vehPhysDef.slipFricScaleRear == Approx(0.1f)); + REQUIRE(loadedVehicle->vehPhysDef.slipFricRateFront == Approx(1.0f)); + REQUIRE(loadedVehicle->vehPhysDef.slipFricRateRear == Approx(1.0f)); + REQUIRE(loadedVehicle->vehPhysDef.slipYawTorque == Approx(49.28f)); + REQUIRE(loadedVehicle->boostDuration == Approx(0.0f)); + REQUIRE(loadedVehicle->boostRechargeTime == Approx(0.0f)); + REQUIRE(loadedVehicle->boostAcceleration == Approx(0.0f)); + REQUIRE(loadedVehicle->suspensionTravel == Approx(12.0f)); + REQUIRE(loadedVehicle->maxSteeringAngle == Approx(45.0f)); + REQUIRE(loadedVehicle->steeringLerp == Approx(5.0f)); + REQUIRE(loadedVehicle->minSteeringScale == Approx(1.0f)); + REQUIRE(loadedVehicle->minSteeringSpeed == Approx(0.0f)); + REQUIRE(loadedVehicle->vehHelicopterBoundsRadius == Approx(1.0)); + REQUIRE(loadedVehicle->vehHelicopterMaxSpeed == Approx(2.0)); + REQUIRE(loadedVehicle->vehHelicopterMaxSpeedVertical == Approx(3.0)); + REQUIRE(loadedVehicle->vehHelicopterMaxAccel == Approx(4.0)); + REQUIRE(loadedVehicle->vehHelicopterMaxAccelVertical == Approx(5.0)); + REQUIRE(loadedVehicle->vehHelicopterDecelerationFwd == Approx(6.0)); + REQUIRE(loadedVehicle->vehHelicopterDecelerationSide == Approx(7.0)); + REQUIRE(loadedVehicle->vehHelicopterDecelerationUp == Approx(8.0)); + REQUIRE(loadedVehicle->vehHelicopterMaxYawRate == Approx(9.0)); + REQUIRE(loadedVehicle->vehHelicopterMaxYawAccel == Approx(10.0)); + REQUIRE(loadedVehicle->vehHelicopterTiltFromVelocity == Approx(11.0)); + REQUIRE(loadedVehicle->vehHelicopterTiltFromControllerAxes == Approx(12.0)); + REQUIRE(loadedVehicle->vehHelicopterTiltFromAcceleration == Approx(13.0)); + REQUIRE(loadedVehicle->vehHelicopterTiltFromDeceleration == Approx(14.0)); + REQUIRE(loadedVehicle->vehHelicopterTiltFromFwdAndYaw_VelAtMaxTilt == Approx(15.0)); + REQUIRE(loadedVehicle->vehHelicopterTiltFromFwdAndYaw == Approx(16.0)); + REQUIRE(loadedVehicle->vehHelicopterTiltMomentum == Approx(17.0)); + REQUIRE(loadedVehicle->vehHelicopterTiltSpeed == Approx(18.0)); + REQUIRE(loadedVehicle->vehHelicopterMaxPitch == Approx(19.0)); + REQUIRE(loadedVehicle->vehHelicopterMaxRoll == Approx(20.0)); + REQUIRE(loadedVehicle->vehHelicopterHoverSpeedThreshold == Approx(21.0)); + REQUIRE(loadedVehicle->vehHelicopterJitterJerkyness == Approx(22.0)); + REQUIRE(loadedVehicle->vehHelicopterLookaheadTime == Approx(23.0)); + REQUIRE(loadedVehicle->vehHelicopterSoftCollisions == 1); + REQUIRE(loadedVehicle->camLookEnabled == Approx(0.0f)); + REQUIRE(loadedVehicle->camRelativeControl == 1); + REQUIRE(loadedVehicle->camLerp == Approx(8.0f)); + REQUIRE(loadedVehicle->camHeight == Approx(9.0f)); + REQUIRE(loadedVehicle->camRadius == Approx(10.0f)); + REQUIRE(loadedVehicle->camPitchInfluence == Approx(1.0f)); + REQUIRE(loadedVehicle->camYawInfluence == Approx(2.0f)); + REQUIRE(loadedVehicle->camRollInfluence == Approx(0.6f)); + REQUIRE(loadedVehicle->camFovIncrease == Approx(20.0f)); + REQUIRE(loadedVehicle->camFovOffset == Approx(4.0f)); + REQUIRE(loadedVehicle->camFovSpeed == Approx(65.0f)); + REQUIRE(loadedVehicle->camReturnSpeed == Approx(1.0)); + REQUIRE(loadedVehicle->camReturnLerp == Approx(2.0)); + REQUIRE(loadedVehicle->vehCam_UseGDT == 1); + REQUIRE(loadedVehicle->vehCam_anglesPitch == Approx(4.0)); + REQUIRE(loadedVehicle->vehCam_anglesYaw == Approx(5.0)); + REQUIRE(loadedVehicle->vehCam_anglesRoll == Approx(6.0)); + REQUIRE(loadedVehicle->vehCam_offsetX == Approx(7.0)); + REQUIRE(loadedVehicle->vehCam_offsetY == Approx(8.0)); + REQUIRE(loadedVehicle->vehCam_offsetZ == Approx(9.0)); + REQUIRE(loadedVehicle->vehCam_radius == Approx(10.0)); + REQUIRE(loadedVehicle->vehCam_speedInfluence == Approx(11.0)); + REQUIRE(loadedVehicle->vehCam_pitchTurnRate == Approx(12.0)); + REQUIRE(loadedVehicle->vehCam_pitchClamp == Approx(13.0)); + REQUIRE(loadedVehicle->vehCam_yawTurnRate == Approx(14.0)); + REQUIRE(loadedVehicle->vehCam_yawClamp == Approx(15.0)); + REQUIRE(loadedVehicle->vehCam_zOffsetMode == VEHCAM_ZMODE_WORLD); + REQUIRE(loadedVehicle->vehCam_anglesPitch3P == Approx(17.0)); + REQUIRE(loadedVehicle->vehCam_anglesYaw3P == Approx(18.0)); + REQUIRE(loadedVehicle->vehCam_anglesRoll3P == Approx(19.0)); + REQUIRE(loadedVehicle->vehCam_offsetX3P == Approx(20.0)); + REQUIRE(loadedVehicle->vehCam_offsetY3P == Approx(21.0)); + REQUIRE(loadedVehicle->vehCam_offsetZ3P == Approx(22.0)); + REQUIRE(loadedVehicle->vehCam_radius3P == Approx(23.0)); + REQUIRE(loadedVehicle->vehCam_speedInfluence3P == Approx(24.0)); + REQUIRE(loadedVehicle->vehCam_pitchTurnRate3P == Approx(25.0)); + REQUIRE(loadedVehicle->vehCam_pitchClamp3P == Approx(26.0)); + REQUIRE(loadedVehicle->vehCam_yawTurnRate3P == Approx(27.0)); + REQUIRE(loadedVehicle->vehCam_yawClamp3P == Approx(28.0)); + REQUIRE(loadedVehicle->vehCam_zOffsetMode3P == VEHCAM_ZMODE_VEHICLE); + REQUIRE(loadedVehicle->turretWeaponName == "sp/bradley_turret"s); + REQUIRE(loadedVehicle->turretHorizSpanLeft == Approx(180.0f)); + REQUIRE(loadedVehicle->turretHorizSpanRight == Approx(180.0f)); + REQUIRE(loadedVehicle->turretVertSpanUp == Approx(30.0f)); + REQUIRE(loadedVehicle->turretVertSpanDown == Approx(15.0f)); + REQUIRE(loadedVehicle->turretHorizResistLeft == Approx(1)); + REQUIRE(loadedVehicle->turretHorizResistRight == Approx(2)); + REQUIRE(loadedVehicle->turretVertResistUp == Approx(3)); + REQUIRE(loadedVehicle->turretVertResistDown == Approx(4)); + REQUIRE(loadedVehicle->turretRotRate == Approx(30.0f)); + REQUIRE(loadedVehicle->turretSpinSnd.name); + REQUIRE(loadedVehicle->turretSpinSnd.name->soundName == "bradley_turret_spin"s); + REQUIRE(loadedVehicle->turretStopSnd.name); + REQUIRE(loadedVehicle->turretStopSnd.name->soundName == "bradley_turret_stop"s); + REQUIRE(loadedVehicle->trophyEnabled == 1); + REQUIRE(loadedVehicle->trophyRadius == Approx(450.0f)); + REQUIRE(loadedVehicle->trophyInactiveRadius == Approx(400.0f)); + REQUIRE(loadedVehicle->trophyAmmoCount == Approx(30.0f)); + REQUIRE(loadedVehicle->trophyReloadTime == Approx(1.0f)); + REQUIRE(zone.m_script_strings.Value(loadedVehicle->trophyTags[0]) == "tag_trophy_01_fx"s); + REQUIRE(zone.m_script_strings.Value(loadedVehicle->trophyTags[1]) == "tag_trophy_02_fx"s); + REQUIRE(zone.m_script_strings.Value(loadedVehicle->trophyTags[2]) == "tag_trophy_03_fx"s); + REQUIRE(zone.m_script_strings.Value(loadedVehicle->trophyTags[3]) == "tag_trophy_04_fx"s); + REQUIRE(loadedVehicle->trophyExplodeFx); + REQUIRE(loadedVehicle->trophyExplodeFx->name == "testfx1"s); + REQUIRE(loadedVehicle->trophyFlashFx); + REQUIRE(loadedVehicle->trophyFlashFx->name == "testfx2"s); + REQUIRE(loadedVehicle->compassFriendlyIcon); + REQUIRE(loadedVehicle->compassFriendlyIcon->info.name == "hud_minimap_harrier_green"s); + REQUIRE(loadedVehicle->compassEnemyIcon); + REQUIRE(loadedVehicle->compassEnemyIcon->info.name == "hud_minimap_harrier_red"s); + REQUIRE(loadedVehicle->compassFriendlyAltIcon); + REQUIRE(loadedVehicle->compassFriendlyAltIcon->info.name == "hud_minimap_harrier_alt_green"s); + REQUIRE(loadedVehicle->compassEnemyAltIcon); + REQUIRE(loadedVehicle->compassEnemyAltIcon->info.name == "hud_minimap_harrier_alt_red"s); + REQUIRE(loadedVehicle->compassIconWidth == 26); + REQUIRE(loadedVehicle->compassIconHeight == 26); + REQUIRE(loadedVehicle->idleLowSnd.name); + REQUIRE(loadedVehicle->idleLowSnd.name->soundName == "veh_ambulance_idle_low"s); + REQUIRE(loadedVehicle->idleHighSnd.name); + REQUIRE(loadedVehicle->idleHighSnd.name->soundName == "veh_ambulance_idle_high"s); + REQUIRE(loadedVehicle->engineLowSnd.name); + REQUIRE(loadedVehicle->engineLowSnd.name->soundName == "veh_ambulance_engine_low"s); + REQUIRE(loadedVehicle->engineHighSnd.name); + REQUIRE(loadedVehicle->engineHighSnd.name->soundName == "veh_ambulance_engine_high"s); + REQUIRE(loadedVehicle->engineSndSpeed == Approx(176.0f)); + REQUIRE(zone.m_script_strings.Value(loadedVehicle->audioOriginTag) == "foo1"s); + REQUIRE(loadedVehicle->idleLowSndAlt.name); + REQUIRE(loadedVehicle->idleLowSndAlt.name->soundName == "foo2"s); + REQUIRE(loadedVehicle->idleHighSndAlt.name); + REQUIRE(loadedVehicle->idleHighSndAlt.name->soundName == "foo3"s); + REQUIRE(loadedVehicle->engineLowSndAlt.name); + REQUIRE(loadedVehicle->engineLowSndAlt.name->soundName == "foo4"s); + REQUIRE(loadedVehicle->engineHighSndAlt.name); + REQUIRE(loadedVehicle->engineHighSndAlt.name->soundName == "foo5"s); + REQUIRE(loadedVehicle->engineSndSpeedAlt == Approx(52.8f)); + REQUIRE(zone.m_script_strings.Value(loadedVehicle->audioOriginTagAlt) == "foo6"s); + REQUIRE(loadedVehicle->turretSpinSndAlt.name); + REQUIRE(loadedVehicle->turretSpinSndAlt.name->soundName == "foo7"s); + REQUIRE(loadedVehicle->turretStopSndAlt.name); + REQUIRE(loadedVehicle->turretStopSndAlt.name->soundName == "foo8"s); + REQUIRE(loadedVehicle->engineStartUpSnd.name == nullptr); + REQUIRE(loadedVehicle->engineStartUpLength == 0); + REQUIRE(loadedVehicle->engineShutdownSnd.name == nullptr); + REQUIRE(loadedVehicle->engineIdleSnd.name); + REQUIRE(loadedVehicle->engineIdleSnd.name->soundName == "snowmobile_2_idle"s); + REQUIRE(loadedVehicle->engineSustainSnd.name); + REQUIRE(loadedVehicle->engineSustainSnd.name->soundName == "snowmobile_2_sustain"s); + REQUIRE(loadedVehicle->engineRampUpSnd.name); + REQUIRE(loadedVehicle->engineRampUpSnd.name->soundName == "snowmobile_2_rampup"s); + REQUIRE(loadedVehicle->engineRampUpLength == 3263); + REQUIRE(loadedVehicle->engineRampDownSnd.name); + REQUIRE(loadedVehicle->engineRampDownSnd.name->soundName == "snowmobile_2_rampdown"s); + REQUIRE(loadedVehicle->engineRampDownLength == 5262); + REQUIRE(loadedVehicle->suspensionSoftSnd.name); + REQUIRE(loadedVehicle->suspensionSoftSnd.name->soundName == "snowmobile_suspension_npc"s); + REQUIRE(loadedVehicle->suspensionSoftCompression == Approx(0.3f)); + REQUIRE(loadedVehicle->suspensionHardSnd.name); + REQUIRE(loadedVehicle->suspensionHardSnd.name->soundName == "snowmobile_suspension_heavy_npc"s); + REQUIRE(loadedVehicle->suspensionHardCompression == Approx(0.8f)); + REQUIRE(loadedVehicle->collisionSnd.name); + REQUIRE(loadedVehicle->collisionSnd.name->soundName == "snowmobile_collision"s); + REQUIRE(loadedVehicle->collisionBlendSpeed == Approx(352.0f)); + REQUIRE(loadedVehicle->speedSnd.name); + REQUIRE(loadedVehicle->speedSnd.name->soundName == "snowmobile_wind_loop"s); + REQUIRE(loadedVehicle->speedSndBlendSpeed == Approx(1056.0f)); + REQUIRE(loadedVehicle->surfaceSndPrefix == "snowmobile_surface"s); + REQUIRE(loadedVehicle->surfaceSndBlendSpeed == Approx(176.0f)); + REQUIRE(loadedVehicle->slideVolume == Approx(0.8f)); + REQUIRE(loadedVehicle->slideBlendSpeed == Approx(352.0f)); + REQUIRE(loadedVehicle->inAirPitch == Approx(1.3f)); + + REQUIRE(loadedVehicle->vehPhysDef.topSpeed == Approx(loadedVehicle->topSpeed)); + REQUIRE(loadedVehicle->vehPhysDef.suspensionTravelFront == Approx(loadedVehicle->suspensionTravel)); + + REQUIRE(std::string(loadedVehicle->surfaceSnds[SURF_TYPE_DEFAULT].name->soundName) == "snowmobile_surface_default"); + REQUIRE(std::string(loadedVehicle->surfaceSnds[SURF_TYPE_SLUSH].name->soundName) == "snowmobile_surface_slush"); + + REQUIRE(loadedAssetInfo->m_dependencies.size() == 8u); + REQUIRE(std::ranges::find(loadedAssetInfo->m_dependencies, physPresetInfo) != loadedAssetInfo->m_dependencies.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_dependencies, weaponInfo) != loadedAssetInfo->m_dependencies.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_dependencies, material0) != loadedAssetInfo->m_dependencies.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_dependencies, material1) != loadedAssetInfo->m_dependencies.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_dependencies, material2) != loadedAssetInfo->m_dependencies.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_dependencies, material3) != loadedAssetInfo->m_dependencies.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_dependencies, fx0) != loadedAssetInfo->m_dependencies.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_dependencies, fx1) != loadedAssetInfo->m_dependencies.end()); + REQUIRE(loadedAssetInfo->m_used_script_strings.size() == 6u); + REQUIRE(loadedAssetInfo->m_indirect_asset_references.size() == 51u); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound0) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound1) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound2) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound3) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound4) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound5) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound6) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound7) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound8) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound9) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound10) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound11) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound12) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound13) != loadedAssetInfo->m_indirect_asset_references.end()); + REQUIRE(std::ranges::find(loadedAssetInfo->m_indirect_asset_references, sound14) != loadedAssetInfo->m_indirect_asset_references.end()); + } +} // namespace diff --git a/test/ObjWritingTests/Game/IW4/Vehicle/VehicleDumperIW4Test.cpp b/test/ObjWritingTests/Game/IW4/Vehicle/VehicleDumperIW4Test.cpp new file mode 100644 index 00000000..01935866 --- /dev/null +++ b/test/ObjWritingTests/Game/IW4/Vehicle/VehicleDumperIW4Test.cpp @@ -0,0 +1,104 @@ +#include "Game/IW4/Vehicle/VehicleDumperIW4.h" + +#include "InfoString/InfoString.h" +#include "SearchPath/MockOutputPath.h" +#include "SearchPath/MockSearchPath.h" + +#include + +using namespace IW4; + +namespace +{ + constexpr auto VEHICLE_NAME = "test_vehicle"; + constexpr auto PHYS_PRESET_NAME = "test_phys_preset"; + constexpr auto WEAPON_NAME = "test_turret_weapon"; + constexpr auto MATERIAL_NAME = "test_compass_material"; + constexpr auto IDLE_SOUND_NAME = "test_idle_sound"; + constexpr auto SURFACE_SOUND_PREFIX = "test_surface"; + + struct TestVehicle + { + std::unique_ptr physPreset; + std::unique_ptr weapon; + std::unique_ptr material; + std::unique_ptr idleSound; + std::unique_ptr vehicle; + }; + + TestVehicle CreateTestVehicle() + { + TestVehicle result{ + .physPreset = std::make_unique(), + .weapon = std::make_unique(), + .material = std::make_unique(), + .idleSound = std::make_unique(), + .vehicle = std::make_unique(), + }; + + result.physPreset->name = PHYS_PRESET_NAME; + result.weapon->szInternalName = WEAPON_NAME; + result.material->info.name = MATERIAL_NAME; + result.idleSound->soundName = IDLE_SOUND_NAME; + + result.vehicle->name = VEHICLE_NAME; + result.vehicle->type = VEH_TANK; + result.vehicle->health = 750; + result.vehicle->topSpeed = 35.2f; + result.vehicle->suspensionTravel = 3.5f; + result.vehicle->vehPhysDef.physicsEnabled = true; + result.vehicle->vehPhysDef.physPresetName = PHYS_PRESET_NAME; + result.vehicle->vehPhysDef.physPreset = result.physPreset.get(); + result.vehicle->vehPhysDef.steeringAxle = VEH_AXLE_FRONT; + result.vehicle->vehPhysDef.powerAxle = VEH_AXLE_REAR; + result.vehicle->vehPhysDef.brakingAxle = VEH_AXLE_ALL; + result.vehicle->turretWeaponName = WEAPON_NAME; + result.vehicle->turretWeapon = result.weapon.get(); + result.vehicle->compassFriendlyIcon = result.material.get(); + result.vehicle->idleLowSnd.name = result.idleSound.get(); + result.vehicle->engineStartUpLength = 1500; + result.vehicle->surfaceSndPrefix = SURFACE_SOUND_PREFIX; + + return result; + } + + std::string DumpVehicle(VehicleDef& vehicle) + { + Zone dumpingZone("DumpingZone", 0, GameId::IW4, GamePlatform::PC); + vehicle.trophyTags[0] = dumpingZone.m_script_strings.AddOrGetScriptString("tag_trophy_left"); + vehicle.trophyTags[1] = dumpingZone.m_script_strings.AddOrGetScriptString("tag_trophy_right"); + dumpingZone.m_pools.AddAsset(ASSET_TYPE_VEHICLE, vehicle.name, &vehicle, {}, {}, {}); + + MockSearchPath dumpingObjPath; + MockOutputPath dumpingOutput; + AssetDumpingContext dumpingContext(dumpingZone, "", dumpingOutput, dumpingObjPath, std::nullopt); + vehicle::DumperIW4 dumper; + dumper.Dump(dumpingContext); + + const auto* dumpedFile = dumpingOutput.GetMockedFile("vehicles/test_vehicle"); + REQUIRE(dumpedFile != nullptr); + return dumpedFile->AsString(); + } + + TEST_CASE("Vehicle dumper serializes raw fields (IW4)", "[iw4][vehicle][system]") + { + auto testVehicle = CreateTestVehicle(); + std::istringstream dumpedStream(DumpVehicle(*testVehicle.vehicle)); + + InfoString infoString; + REQUIRE(infoString.FromStream("VEHICLEFILE", dumpedStream)); + REQUIRE(infoString.GetValueForKey("type") == "tank"); + REQUIRE(infoString.GetValueForKey("health") == "750"); + REQUIRE(infoString.GetValueForKey("topSpeed") == "2.000000"); + REQUIRE(infoString.GetValueForKey("physicsPreset") == PHYS_PRESET_NAME); + REQUIRE(infoString.GetValueForKey("steeringAxle") == "front"); + REQUIRE(infoString.GetValueForKey("powerAxle") == "rear"); + REQUIRE(infoString.GetValueForKey("brakingAxle") == "all"); + REQUIRE(infoString.GetValueForKey("turretWeaponName") == WEAPON_NAME); + REQUIRE(infoString.GetValueForKey("trophyTags") == "tag_trophy_left\ntag_trophy_right"); + REQUIRE(infoString.GetValueForKey("compassFriendlyIcon") == MATERIAL_NAME); + REQUIRE(infoString.GetValueForKey("lowIdleSnd") == IDLE_SOUND_NAME); + REQUIRE(infoString.GetValueForKey("engineStartUpLength") == "1.5"); + REQUIRE(infoString.GetValueForKey("surfaceSndPrefix") == SURFACE_SOUND_PREFIX); + } +} // namespace diff --git a/test/ObjWritingTests/Game/IW5/Vehicle/VehicleDumperIW5Test.cpp b/test/ObjWritingTests/Game/IW5/Vehicle/VehicleDumperIW5Test.cpp new file mode 100644 index 00000000..e497790f --- /dev/null +++ b/test/ObjWritingTests/Game/IW5/Vehicle/VehicleDumperIW5Test.cpp @@ -0,0 +1,120 @@ +#include "Game/IW5/Vehicle/VehicleDumperIW5.h" + +#include "InfoString/InfoString.h" +#include "SearchPath/MockOutputPath.h" +#include "SearchPath/MockSearchPath.h" + +#include + +using namespace IW5; + +namespace +{ + constexpr auto VEHICLE_NAME = "test_vehicle_iw5"; + constexpr auto PHYS_PRESET_NAME = "test_phys_preset_iw5"; + constexpr auto WEAPON_NAME = "test_turret_weapon_iw5"; + constexpr auto EXPLODE_FX_NAME = "test_trophy_explode_fx"; + constexpr auto FLASH_FX_NAME = "test_trophy_flash_fx"; + constexpr auto MATERIAL_NAME = "test_compass_alt_material"; + constexpr auto ALT_IDLE_SOUND_NAME = "test_alt_idle_sound"; + constexpr auto SURFACE_SOUND_PREFIX = "test_iw5_surface"; + + struct TestVehicle + { + std::unique_ptr physPreset; + std::unique_ptr weapon; + std::unique_ptr explodeFx; + std::unique_ptr flashFx; + std::unique_ptr material; + std::unique_ptr altIdleSound; + std::unique_ptr vehicle; + }; + + TestVehicle CreateTestVehicle() + { + TestVehicle result{ + .physPreset = std::make_unique(), + .weapon = std::make_unique(), + .explodeFx = std::make_unique(), + .flashFx = std::make_unique(), + .material = std::make_unique(), + .altIdleSound = std::make_unique(), + .vehicle = std::make_unique(), + }; + + result.physPreset->name = PHYS_PRESET_NAME; + result.weapon->szInternalName = WEAPON_NAME; + result.explodeFx->name = EXPLODE_FX_NAME; + result.flashFx->name = FLASH_FX_NAME; + result.material->info.name = MATERIAL_NAME; + result.altIdleSound->soundName = ALT_IDLE_SOUND_NAME; + + result.vehicle->name = VEHICLE_NAME; + result.vehicle->type = VEH_UGV; + result.vehicle->health = 900; + result.vehicle->topSpeed = 176.0f; + result.vehicle->suspensionTravel = 5.5f; + result.vehicle->fakeBodyStabilizer = true; + result.vehicle->vehPhysDef.physicsEnabled = true; + result.vehicle->vehPhysDef.physPresetName = PHYS_PRESET_NAME; + result.vehicle->vehPhysDef.physPreset = result.physPreset.get(); + result.vehicle->vehPhysDef.steeringAxle = VEH_AXLE_ALL; + result.vehicle->vehHelicopterBoundsRadius = 123.25f; + result.vehicle->camRelativeControl = true; + result.vehicle->vehCam_zOffsetMode = VEHCAM_ZMODE_VIEW; + result.vehicle->vehCam_zOffsetMode3P = VEHCAM_ZMODE_VEHICLE; + result.vehicle->turretWeaponName = WEAPON_NAME; + result.vehicle->turretWeapon = result.weapon.get(); + result.vehicle->turretHorizResistLeft = 27.5f; + result.vehicle->trophyExplodeFx = result.explodeFx.get(); + result.vehicle->trophyFlashFx = result.flashFx.get(); + result.vehicle->compassFriendlyAltIcon = result.material.get(); + result.vehicle->idleLowSndAlt.name = result.altIdleSound.get(); + result.vehicle->surfaceSndPrefix = SURFACE_SOUND_PREFIX; + + return result; + } + + std::string DumpVehicle(VehicleDef& vehicle) + { + Zone dumpingZone("DumpingZone", 0, GameId::IW5, GamePlatform::PC); + vehicle.trophyTags[0] = dumpingZone.m_script_strings.AddOrGetScriptString("tag_trophy_iw5"); + vehicle.audioOriginTag = dumpingZone.m_script_strings.AddOrGetScriptString("tag_audio_origin"); + vehicle.audioOriginTagAlt = dumpingZone.m_script_strings.AddOrGetScriptString("tag_audio_origin_alt"); + dumpingZone.m_pools.AddAsset(ASSET_TYPE_VEHICLE, vehicle.name, &vehicle, {}, {}, {}); + + MockSearchPath dumpingObjPath; + MockOutputPath dumpingOutput; + AssetDumpingContext dumpingContext(dumpingZone, "", dumpingOutput, dumpingObjPath, std::nullopt); + vehicle::DumperIW5 dumper; + dumper.Dump(dumpingContext); + + const auto* dumpedFile = dumpingOutput.GetMockedFile("vehicles/test_vehicle_iw5"); + REQUIRE(dumpedFile != nullptr); + return dumpedFile->AsString(); + } + + TEST_CASE("Vehicle dumper serializes raw fields (IW5)", "[iw5][vehicle][system]") + { + auto testVehicle = CreateTestVehicle(); + std::istringstream dumpedStream(DumpVehicle(*testVehicle.vehicle)); + + InfoString infoString; + REQUIRE(infoString.FromStream("VEHICLEFILE", dumpedStream)); + REQUIRE(infoString.GetValueForKey("type") == "ugv"); + REQUIRE(infoString.GetValueForKey("topSpeed") == "10.000000"); + REQUIRE(infoString.GetValueForKey("fakeBodyStabilizer") == "1"); + REQUIRE(infoString.GetValueForKey("physicsPreset") == PHYS_PRESET_NAME); + REQUIRE(infoString.GetValueForKey("vehHelicopterBoundsRadius") == "123.25"); + REQUIRE(infoString.GetValueForKey("camRelativeControl") == "1"); + REQUIRE(infoString.GetValueForKey("vehCam_zOffsetMode") == "view"); + REQUIRE(infoString.GetValueForKey("vehCam_zOffsetMode3P") == "vehicle"); + REQUIRE(infoString.GetValueForKey("turretHorizResistLeft") == "27.5"); + REQUIRE(infoString.GetValueForKey("trophyExplodeFx") == EXPLODE_FX_NAME); + REQUIRE(infoString.GetValueForKey("trophyFlashFx") == FLASH_FX_NAME); + REQUIRE(infoString.GetValueForKey("compassFriendlyAltIcon") == MATERIAL_NAME); + REQUIRE(infoString.GetValueForKey("audioOriginTag") == "tag_audio_origin"); + REQUIRE(infoString.GetValueForKey("audioOriginTagAlt") == "tag_audio_origin_alt"); + REQUIRE(infoString.GetValueForKey("lowIdleSndAlt") == ALT_IDLE_SOUND_NAME); + } +} // namespace