Add dumping of iw4 weapon files

src/ObjCommon/Game/IW4/InfoStringIW4.cpp

@@ -0,0 +1,171 @@
+#include "InfoStringIW4.h"
+
+#include <cassert>
+
+using namespace IW4;
+
+void InfoStringToStructConverter::FillStructure()
+{
+}
+
+InfoStringToStructConverter::InfoStringToStructConverter(const InfoString& infoString, void* structure,
+                                                         const cspField_t* fields, const size_t fieldCount)
+    : InfoStringToStructConverterBase(infoString, structure),
+      m_fields(fields),
+      m_field_count(fieldCount)
+{
+}
+
+void InfoStringFromStructConverter::FillFromBaseField(const cspField_t& field)
+{
+    switch (static_cast<csParseFieldType_t>(field.iFieldType))
+    {
+    case CSPFT_STRING:
+        FillFromString(std::string(field.szName), field.iOffset);
+        break;
+
+    case CSPFT_STRING_MAX_STRING_CHARS:
+        FillFromStringBuffer(std::string(field.szName), field.iOffset, 1024);
+        break;
+
+    case CSPFT_STRING_MAX_QPATH:
+        FillFromStringBuffer(std::string(field.szName), field.iOffset, 64);
+        break;
+
+    case CSPFT_STRING_MAX_OSPATH:
+        FillFromStringBuffer(std::string(field.szName), field.iOffset, 256);
+        break;
+
+    case CSPFT_INT:
+        FillFromInt(std::string(field.szName), field.iOffset);
+        break;
+
+    case CSPFT_QBOOLEAN:
+        FillFromQBoolean(std::string(field.szName), field.iOffset);
+        break;
+
+    case CSPFT_BOOL:
+        FillFromBool(std::string(field.szName), field.iOffset);
+        break;
+
+    case CSPFT_FLOAT:
+        FillFromFloat(std::string(field.szName), field.iOffset);
+        break;
+
+    case CSPFT_MPH_TO_INCHES_PER_SEC:
+        {
+            const auto* num = reinterpret_cast<float*>(reinterpret_cast<uintptr_t>(m_structure) + field.iOffset);
+            m_info_string.SetValueForKey(std::string(field.szName), std::to_string(*num / 17.6f));
+            break;
+        }
+
+    case CSPFT_MILLISECONDS:
+        FillFromMilliseconds(std::string(field.szName), field.iOffset);
+        break;
+
+    case CSPFT_FX:
+        {
+            const auto* fx = *reinterpret_cast<FxEffectDef**>(reinterpret_cast<uintptr_t>(m_structure) + field.iOffset);
+
+            if (fx)
+                m_info_string.SetValueForKey(std::string(field.szName), std::string(fx->name));
+            else
+                m_info_string.SetValueForKey(std::string(field.szName), "");
+            break;
+        }
+
+    case CSPFT_XMODEL:
+        {
+            const auto* model = *reinterpret_cast<XModel**>(reinterpret_cast<uintptr_t>(m_structure) + field.iOffset);
+
+            if (model)
+                m_info_string.SetValueForKey(std::string(field.szName), std::string(model->name));
+            else
+                m_info_string.SetValueForKey(std::string(field.szName), "");
+            break;
+        }
+
+    case CSPFT_MATERIAL:
+        {
+            const auto* material = *reinterpret_cast<Material**>(reinterpret_cast<uintptr_t>(m_structure) + field.
+                iOffset);
+
+            if (material)
+                m_info_string.SetValueForKey(std::string(field.szName), std::string(material->info.name));
+            else
+                m_info_string.SetValueForKey(std::string(field.szName), "");
+            break;
+        }
+
+    case CSPFT_PHYS_COLLMAP:
+        {
+            const auto* physCollMap = *reinterpret_cast<PhysCollmap**>(reinterpret_cast<uintptr_t>(m_structure) + field.
+                iOffset);
+
+            if (physCollMap)
+                m_info_string.SetValueForKey(std::string(field.szName), std::string(physCollMap->name));
+            else
+                m_info_string.SetValueForKey(std::string(field.szName), "");
+            break;
+        }
+
+    case CSPFT_SOUND:
+    {
+        const auto* sndAlias = reinterpret_cast<SndAliasCustom*>(reinterpret_cast<uintptr_t>(m_structure) + field.
+            iOffset);
+
+        if (sndAlias->name)
+            m_info_string.SetValueForKey(std::string(field.szName), std::string(sndAlias->name->soundName));
+        else
+            m_info_string.SetValueForKey(std::string(field.szName), "");
+        break;
+    }
+
+    case CSPFT_TRACER:
+        {
+            const auto* tracer = *reinterpret_cast<TracerDef**>(reinterpret_cast<uintptr_t>(m_structure) + field.
+                iOffset);
+
+            if (tracer)
+                m_info_string.SetValueForKey(std::string(field.szName), std::string(tracer->name));
+            else
+                m_info_string.SetValueForKey(std::string(field.szName), "");
+            break;
+        }
+
+    case CSPFT_NUM_BASE_FIELD_TYPES:
+    default:
+        assert(false);
+        break;
+    }
+}
+
+void InfoStringFromStructConverter::FillInfoString()
+{
+    for (auto fieldIndex = 0u; fieldIndex < m_field_count; fieldIndex++)
+    {
+        const auto& field = m_fields[fieldIndex];
+        assert(field.iFieldType >= 0);
+
+        if (field.iFieldType < CSPFT_NUM_BASE_FIELD_TYPES)
+            FillFromBaseField(field);
+        else
+            FillFromExtensionField(field);
+    }
+}
+
+InfoStringFromStructConverter::InfoStringFromStructConverter(const void* structure, const cspField_t* fields,
+                                                             const size_t fieldCount)
+    : InfoStringFromStructConverterBase(structure),
+      m_fields(fields),
+      m_field_count(fieldCount)
+{
+}
+
+InfoStringFromStructConverter::InfoStringFromStructConverter(const void* structure, const cspField_t* fields, const size_t fieldCount,
+                                                             std::function<std::string(scr_string_t)> scriptStringValueCallback)
+    : InfoStringFromStructConverterBase(structure, std::move(scriptStringValueCallback)),
+      m_fields(fields),
+      m_field_count(fieldCount)
+{
+}

src/ObjCommon/Game/IW4/InfoStringIW4.h

@@ -0,0 +1,33 @@
+#pragma once
+#include "Utils/InfoString.h"
+#include "Game/IW4/IW4.h"
+
+namespace IW4
+{
+    class InfoStringToStructConverter : public InfoStringToStructConverterBase
+    {
+        const cspField_t* m_fields;
+        size_t m_field_count;
+
+    protected:
+        void FillStructure() override;
+
+    public:
+        InfoStringToStructConverter(const InfoString& infoString, void* structure, const cspField_t* fields, size_t fieldCount);
+    };
+
+    class InfoStringFromStructConverter : public InfoStringFromStructConverterBase
+    {
+    protected:
+        const cspField_t* m_fields;
+        size_t m_field_count;
+
+        virtual void FillFromExtensionField(const cspField_t& field) = 0;
+        void FillFromBaseField(const cspField_t& field);
+        void FillInfoString() override;
+
+    public:
+        InfoStringFromStructConverter(const void* structure, const cspField_t* fields, size_t fieldCount);
+        InfoStringFromStructConverter(const void* structure, const cspField_t* fields, size_t fieldCount, std::function<std::string(scr_string_t)> scriptStringValueCallback);
+    };
+}

src/ObjWriting/Game/IW4/AssetDumpers/AssetDumperWeapon.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "Dumping/AbstractAssetDumper.h"
+#include "Game/IW4/IW4.h"
+
+namespace IW4
+{
+    class AssetDumperWeapon final : public AbstractAssetDumper<WeaponCompleteDef>
+    {
+        static cspField_t weapon_fields[];
+
+        static void CopyToFullDef(const WeaponCompleteDef* weapon, WeaponFullDef* fullDef);
+
+    protected:
+        bool ShouldDump(XAssetInfo<WeaponCompleteDef>* asset) override;
+        std::string GetFileNameForAsset(Zone* zone, XAssetInfo<WeaponCompleteDef>* asset) override;
+        void DumpAsset(Zone* zone, XAssetInfo<WeaponCompleteDef>* asset, FileAPI::File* out) override;
+    };
+}

src/ObjWriting/Game/IW4/ZoneDumperIW4.cpp

@@ -3,12 +3,13 @@
 #include "Game/IW4/GameIW4.h"
 #include "Game/IW4/GameAssetPoolIW4.h"
 
+#include "AssetDumpers/AssetDumperAddonMapEnts.h"
+#include "AssetDumpers/AssetDumperGfxImage.h"
+#include "AssetDumpers/AssetDumperLoadedSound.h"
+#include "AssetDumpers/AssetDumperLocalizeEntry.h"
 #include "AssetDumpers/AssetDumperRawFile.h"
 #include "AssetDumpers/AssetDumperStringTable.h"
-#include "AssetDumpers/AssetDumperLocalizeEntry.h"
+#include "AssetDumpers/AssetDumperWeapon.h"
-#include "AssetDumpers/AssetDumperGfxImage.h"
-#include "AssetDumpers/AssetDumperAddonMapEnts.h"
-#include "AssetDumpers/AssetDumperLoadedSound.h"
 
 using namespace IW4;
 
@@ -53,7 +54,7 @@ bool ZoneDumper::DumpZone(Zone* zone, const std::string& basePath) const
     // DUMP_ASSET_POOL(AssetDumperMenuList, m_menu_list)
     // DUMP_ASSET_POOL(AssetDumpermenuDef_t, m_menu_def)
     DUMP_ASSET_POOL(AssetDumperLocalizeEntry, m_localize)
-    // DUMP_ASSET_POOL(AssetDumperWeaponCompleteDef, m_weapon)
+    DUMP_ASSET_POOL(AssetDumperWeapon, m_weapon)
     // DUMP_ASSET_POOL(AssetDumperSndDriverGlobals, m_snd_driver_globals)
     // DUMP_ASSET_POOL(AssetDumperFxEffectDef, m_fx)
     // DUMP_ASSET_POOL(AssetDumperFxImpactTable, m_fx_impact_table)

src/ZoneCommon/Game/IW4/IW4.h

@@ -51,4 +51,64 @@ namespace IW4
         int assetCount;
         XAsset* assets;
     };
+
+    struct cspField_t
+    {
+        const char* szName;
+        int iOffset;
+        int iFieldType;
+    };
+
+    enum csParseFieldType_t
+    {
+        CSPFT_STRING = 0,
+        CSPFT_STRING_MAX_STRING_CHARS,
+        CSPFT_STRING_MAX_QPATH,
+        CSPFT_STRING_MAX_OSPATH,
+        CSPFT_INT,
+        CSPFT_QBOOLEAN,
+        CSPFT_BOOL,
+        CSPFT_FLOAT,
+        CSPFT_MPH_TO_INCHES_PER_SEC,
+        CSPFT_MILLISECONDS,
+        CSPFT_FX,
+        CSPFT_XMODEL,
+        CSPFT_MATERIAL,
+        CSPFT_PHYS_COLLMAP,
+        CSPFT_SOUND,
+        CSPFT_TRACER,
+
+        CSPFT_NUM_BASE_FIELD_TYPES,
+    };
+
+    enum weapFieldType_t
+    {
+        WFT_WEAPONTYPE = CSPFT_NUM_BASE_FIELD_TYPES,
+        WFT_WEAPONCLASS,
+        WFT_OVERLAYRETICLE,
+        WFT_PENETRATE_TYPE,
+        WFT_IMPACT_TYPE,
+        WFT_STANCE,
+        WFT_PROJ_EXPLOSION,
+        WFT_OFFHAND_CLASS,
+        WFT_ANIMTYPE,
+        WFT_ACTIVE_RETICLE_TYPE,
+        WFT_GUIDED_MISSILE_TYPE,
+        WFT_BOUNCE_SOUND,
+        WFT_STICKINESS,
+        WFT_OVERLAYINTERFACE,
+        WFT_INVENTORYTYPE,
+        WFT_FIRETYPE,
+        WFT_AMMOCOUNTER_CLIPTYPE,
+        WFT_ICONRATIO_HUD,
+        WFT_ICONRATIO_PICKUP,
+        WFT_ICONRATIO_AMMOCOUNTER,
+        WFT_ICONRATIO_KILL,
+        WFT_ICONRATIO_DPAD,
+        WFT_HIDETAGS,
+        WFT_NOTETRACKSOUNDMAP,
+        WFT_NOTETRACKRUMBLEMAP,
+
+        WFT_NUM_FIELD_TYPES,
+    };
 }

src/ZoneCommon/Game/IW4/IW4_Assets.h

@@ -3118,6 +3118,112 @@ namespace IW4
         MISSILE_GUIDANCE_COUNT
     };
 
+    enum weapAnimFiles_t
+    {
+        WEAP_ANIM_ROOT = 0x0,
+        WEAP_ANIM_IDLE = 0x1,
+        WEAP_ANIM_EMPTY_IDLE = 0x2,
+        WEAP_ANIM_FIRE = 0x3,
+        WEAP_ANIM_HOLD_FIRE = 0x4,
+        WEAP_ANIM_LASTSHOT = 0x5,
+        WEAP_ANIM_RECHAMBER = 0x6,
+        WEAP_ANIM_MELEE = 0x7,
+        WEAP_ANIM_MELEE_CHARGE = 0x8,
+        WEAP_ANIM_RELOAD = 0x9,
+        WEAP_ANIM_RELOAD_EMPTY = 0xA,
+        WEAP_ANIM_RELOAD_START = 0xB,
+        WEAP_ANIM_RELOAD_END = 0xC,
+        WEAP_ANIM_RAISE = 0xD,
+        WEAP_ANIM_FIRST_RAISE = 0xE,
+        WEAP_ANIM_BREACH_RAISE = 0xF,
+        WEAP_ANIM_DROP = 0x10,
+        WEAP_ANIM_ALT_RAISE = 0x11,
+        WEAP_ANIM_ALT_DROP = 0x12,
+        WEAP_ANIM_QUICK_RAISE = 0x13,
+        WEAP_ANIM_QUICK_DROP = 0x14,
+        WEAP_ANIM_EMPTY_RAISE = 0x15,
+        WEAP_ANIM_EMPTY_DROP = 0x16,
+        WEAP_ANIM_SPRINT_IN = 0x17,
+        WEAP_ANIM_SPRINT_LOOP = 0x18,
+        WEAP_ANIM_SPRINT_OUT = 0x19,
+        WEAP_ANIM_STUNNED_START = 0x1A,
+        WEAP_ANIM_STUNNED_LOOP = 0x1B,
+        WEAP_ANIM_STUNNED_END = 0x1C,
+        WEAP_ANIM_DETONATE = 0x1D,
+        WEAP_ANIM_NIGHTVISION_WEAR = 0x1E,
+        WEAP_ANIM_NIGHTVISION_REMOVE = 0x1F,
+        WEAP_ANIM_ADS_FIRE = 0x20,
+        WEAP_ANIM_ADS_LASTSHOT = 0x21,
+        WEAP_ANIM_ADS_RECHAMBER = 0x22,
+        WEAP_ANIM_ADS_UP = 0x23,
+        WEAP_ANIM_ADS_DOWN = 0x24,
+
+        NUM_WEAP_ANIMS,
+    };
+
+    enum materialSurfType_t
+    {
+        SURF_TYPE_DEFAULT,
+        SURF_TYPE_BARK,
+        SURF_TYPE_BRICK,
+        SURF_TYPE_CARPET,
+        SURF_TYPE_CLOTH,
+        SURF_TYPE_CONCRETE,
+        SURF_TYPE_DIRT,
+        SURF_TYPE_FLESH,
+        SURF_TYPE_FOLIAGE,
+        SURF_TYPE_GLASS,
+        SURF_TYPE_GRASS,
+        SURF_TYPE_GRAVEL,
+        SURF_TYPE_ICE,
+        SURF_TYPE_METAL,
+        SURF_TYPE_MUD,
+        SURF_TYPE_PAPER,
+        SURF_TYPE_PLASTER,
+        SURF_TYPE_ROCK,
+        SURF_TYPE_SAND,
+        SURF_TYPE_SNOW,
+        SURF_TYPE_WATER,
+        SURF_TYPE_WOOD,
+        SURF_TYPE_ASPHALT,
+        SURF_TYPE_CERAMIC,
+        SURF_TYPE_PLASTIC,
+        SURF_TYPE_RUBBER,
+        SURF_TYPE_CUSHION,
+        SURF_TYPE_FRUIT,
+        SURF_TYPE_PAINTED_METAL,
+        SURF_TYPE_RIOT_SHIELD,
+        SURF_TYPE_SLUSH,
+
+        SURF_TYPE_NUM
+    };
+
+    enum hitLocation_t
+    {
+        HITLOC_NONE = 0x0,
+        HITLOC_HELMET = 0x1,
+        HITLOC_HEAD = 0x2,
+        HITLOC_NECK = 0x3,
+        HITLOC_TORSO_UPR = 0x4,
+        HITLOC_TORSO_LWR = 0x5,
+        HITLOC_R_ARM_UPR = 0x6,
+        HITLOC_L_ARM_UPR = 0x7,
+        HITLOC_R_ARM_LWR = 0x8,
+        HITLOC_L_ARM_LWR = 0x9,
+        HITLOC_R_HAND = 0xA,
+        HITLOC_L_HAND = 0xB,
+        HITLOC_R_LEG_UPR = 0xC,
+        HITLOC_L_LEG_UPR = 0xD,
+        HITLOC_R_LEG_LWR = 0xE,
+        HITLOC_L_LEG_LWR = 0xF,
+        HITLOC_R_FOOT = 0x10,
+        HITLOC_L_FOOT = 0x11,
+        HITLOC_GUN = 0x12,
+        HITLOC_SHIELD = 0x13,
+
+        HITLOC_NUM,
+    };
+
     struct snd_alias_list_name
     {
         const char* soundName;
@@ -3591,6 +3697,25 @@ namespace IW4
         bool dpadIconShowsAmmo;
     };
 
+    struct WeaponFullDef
+    {
+        WeaponCompleteDef weapCompleteDef;
+        WeaponDef weapDef;
+        unsigned __int16 hideTags[32];
+        const char* szXAnims[37];
+        XModel* gunXModel[16];
+        const char* szXAnimsRightHanded[37];
+        const char* szXAnimsLeftHanded[37];
+        unsigned __int16 notetrackSoundMapKeys[16];
+        unsigned __int16 notetrackSoundMapValues[16];
+        unsigned __int16 notetrackRumbleMapKeys[16];
+        unsigned __int16 notetrackRumbleMapValues[16];
+        XModel* worldModel[16];
+        float parallelBounce[31];
+        float perpendicularBounce[31];
+        float locationDamageMultipliers[20];
+    };
+
     enum VehicleAxleType
     {
         VEH_AXLE_FRONT = 0x0,