506 lines
19 KiB
C++
506 lines
19 KiB
C++
//
|
|
// VehicleModelInfoVariation.h
|
|
// Data file for vehicle customization
|
|
//
|
|
// Rockstar Games (c) 2011
|
|
|
|
#ifndef INC_VEHICLE_MODELINFO_VARIATION_H_
|
|
#define INC_VEHICLE_MODELINFO_VARIATION_H_
|
|
|
|
#include "atl/array.h"
|
|
#include "atl/bitset.h"
|
|
#include "atl/hashstring.h"
|
|
#include "data/base.h"
|
|
#include "entity/extensionlist.h"
|
|
#include "fwdrawlist/drawlistmgr.h"
|
|
#include "fwutil/Flags.h"
|
|
#include "parser/macros.h"
|
|
|
|
#include "scene/RegdRefTypes.h"
|
|
#include "streaming/streamingmodule.h"
|
|
#include "streaming/streamingrequest.h"
|
|
#include "modelinfo/VehicleModelInfoColors.h"
|
|
#include "modelinfo/VehicleModelInfoPlates.h"
|
|
|
|
#include "control/replay/ReplaySettings.h"
|
|
|
|
#define MAX_LINKED_MODS (15)
|
|
|
|
#define NUM_EXHAUST_BONES (VEH_LAST_EXHAUST - VEH_FIRST_EXHAUST + 1)
|
|
#define NUM_EXTRALIGHT_BONES (4)
|
|
|
|
class CVehicle;
|
|
class CCustomShaderEffectVehicleType;
|
|
class CScriptPreloadData;
|
|
|
|
namespace rage {
|
|
class rmcDrawable;
|
|
class fragType;
|
|
}
|
|
|
|
// stores a list of streaming requests for each mod slot
|
|
class CVehicleStreamRequestGfx : public fwExtension
|
|
{
|
|
enum state{ VS_INIT, VS_REQ, VS_USE, VS_FREED };
|
|
|
|
public:
|
|
#if !__SPU
|
|
EXTENSIONID_DECL(CVehicleStreamRequestGfx, fwExtension);
|
|
#endif
|
|
|
|
CVehicleStreamRequestGfx();
|
|
~CVehicleStreamRequestGfx();
|
|
|
|
FW_REGISTER_CLASS_POOL(CVehicleStreamRequestGfx);
|
|
|
|
void RequestsComplete();
|
|
void Release();
|
|
bool HaveAllLoaded() { return m_reqFrags.HaveAllLoaded() && m_reqDrawables.HaveAllLoaded() && (m_state == VS_REQ) && (m_bDelayCompletion == false); }
|
|
void PushRequest() { Assert((m_state == VS_INIT) || (m_state == VS_FREED)); m_state = VS_REQ; }
|
|
|
|
s32 AddFrag(u8 modSlot, const strStreamingObjectName fragName, s32 streamFlags, s32 parentTxd);
|
|
s32 AddDrawable(eVehicleModType modSlot, const strStreamingObjectName drawableName, s32 streamFlags, s32 parentTxd);
|
|
|
|
s32 GetFragId(u8 modSlot) { Assert(modSlot < VMT_RENDERABLE + MAX_LINKED_MODS); return m_reqFrags.GetRequestId(modSlot); }
|
|
s32 GetDrawableId(eVehicleModType modSlot) { Assert(modSlot == VMT_WHEELS || modSlot == VMT_WHEELS_REAR_OR_HYDRAULICS); return m_reqDrawables.GetRequestId(modSlot - VMT_WHEELS); }
|
|
|
|
void SetTargetEntity(CVehicle *pEntity);
|
|
CVehicle* GetTargetEntity() const { return m_pTargetEntity; }
|
|
|
|
void SetDelayCompletion(bool bDelay) { m_bDelayCompletion = bDelay; }
|
|
|
|
private:
|
|
CVehicle* m_pTargetEntity;
|
|
state m_state;
|
|
bool m_bDelayCompletion;
|
|
|
|
strRequestArray<VMT_RENDERABLE + MAX_LINKED_MODS> m_reqFrags;
|
|
strRequestArray<2> m_reqDrawables;
|
|
};
|
|
|
|
// stores a list of streamed in mods to be used for rendering
|
|
class CVehicleStreamRenderGfx : public fwExtension
|
|
{
|
|
#if !__NO_OUTPUT
|
|
friend class CVehicleStreamRequestGfx;
|
|
#endif
|
|
|
|
public:
|
|
#if !__SPU
|
|
EXTENSIONID_DECL(CVehicleStreamRenderGfx, fwExtension);
|
|
#endif
|
|
|
|
CVehicleStreamRenderGfx();
|
|
CVehicleStreamRenderGfx(CVehicleStreamRequestGfx* pReq, CVehicle* targetEntity);
|
|
~CVehicleStreamRenderGfx();
|
|
|
|
FW_REGISTER_CLASS_POOL(CVehicleStreamRenderGfx);
|
|
|
|
void ReleaseGfx();
|
|
|
|
fragType* GetFrag(u8 modSlot) const;
|
|
const fragType* GetFragConst(u8 modSlot) const { return GetFrag(modSlot); }
|
|
CCustomShaderEffectVehicleType* GetFragCSEType(u8 modSlot) const;
|
|
strLocalIndex GetFragIndex(u8 modSlot) const;
|
|
|
|
rmcDrawable* GetDrawable(eVehicleModType modSlot) const;
|
|
const rmcDrawable* GetDrawableConst(eVehicleModType modSlot) const { return GetDrawable(modSlot); }
|
|
CCustomShaderEffectVehicleType* GetDrawableCSEType(eVehicleModType modSlot) const;
|
|
strLocalIndex GetDrawableIndex(eVehicleModType modSlot) const;
|
|
|
|
float GetWheelTyreRadiusScale() { return m_wheelTyreRadiusScale[0]; }
|
|
float GetWheelTyreWidthScale() { return m_wheelTyreWidthScale[0]; }
|
|
float GetRearWheelTyreRadiusScale() { return m_wheelTyreRadiusScale[1]; }
|
|
float GetRearWheelTyreWidthScale() { return m_wheelTyreWidthScale[1]; }
|
|
|
|
void OverrideWheelRimRadius(CVehicle* targetEntity) const;
|
|
void RestoreWheelRimRadius(CVehicle* targetEntity) const;
|
|
|
|
void StoreModMatrices(CVehicle* pVeh);
|
|
|
|
void AddRefsToGfx();
|
|
bool ValidateStreamingIndexHasBeenCached();
|
|
|
|
void SetMatrix(u8 slot, const Matrix33& mat) { Assert(slot < VMT_RENDERABLE + MAX_LINKED_MODS); m_boneMatrices[slot] = mat; }
|
|
const Matrix33& GetMatrix(u8 slot) const { Assert(slot < VMT_RENDERABLE + MAX_LINKED_MODS); return m_boneMatrices[slot]; }
|
|
void CopyMatrices(const CVehicleStreamRenderGfx& rOther);
|
|
|
|
u8 GetExhaustModIndex(eHierarchyId id) const;
|
|
s8 GetExhaustBoneIndex(eHierarchyId id) const;
|
|
u8 GetExtraLightModIndex(eHierarchyId id) const;
|
|
s8 GetExtraLightBoneIndex(eHierarchyId id) const;
|
|
u8 GetExtraLightCount() const;
|
|
|
|
void AddRef() { m_refCount++; }
|
|
void SetUsed(bool val);
|
|
|
|
static void Init();
|
|
static void Shutdown();
|
|
|
|
static void RemoveRefs();
|
|
|
|
private:
|
|
float m_wheelTyreRadiusScale[2];
|
|
bool m_usingWheelVariation[2];
|
|
|
|
Matrix33 m_boneMatrices[VMT_RENDERABLE + MAX_LINKED_MODS];
|
|
|
|
CVehicleModVisible* m_varModVisible[VMT_RENDERABLE];
|
|
CVehicleModLink* m_varModLinked[MAX_LINKED_MODS];
|
|
CVehicleWheel* m_varWheel[2];
|
|
|
|
struct sExtraBoneData
|
|
{
|
|
s8 m_boneIndex;
|
|
u8 m_modIndex;
|
|
};
|
|
sExtraBoneData m_exhaustBones[NUM_EXHAUST_BONES];
|
|
sExtraBoneData m_extraLightBones[NUM_EXTRALIGHT_BONES];
|
|
|
|
float m_wheelTyreWidthScale[2];
|
|
u16 m_refCount;
|
|
bool m_used;
|
|
|
|
#if !__NO_OUTPUT
|
|
RegdVeh m_targetEntity;
|
|
u32 m_frameCreated;
|
|
#endif
|
|
|
|
static atArray<CVehicleStreamRenderGfx*> ms_renderRefs[FENCE_COUNT];
|
|
static s32 ms_fenceUpdateIdx;
|
|
|
|
#if __DEV
|
|
public:
|
|
static void PoolFullCallback(void* pItem);
|
|
#endif //__DEV
|
|
|
|
};
|
|
|
|
#if !__DEV
|
|
inline bool CVehicleStreamRenderGfx::ValidateStreamingIndexHasBeenCached() { return true;}
|
|
#endif
|
|
|
|
// class that stores a variation instance generated from all future distribution parameters
|
|
class CVehicleVariationInstance
|
|
{
|
|
friend class CVehicleModelInfo;
|
|
public:
|
|
CVehicleVariationInstance();
|
|
~CVehicleVariationInstance();
|
|
|
|
static void InitSystem();
|
|
static void ShutdownSystem();
|
|
static void ProcessStreamRequests();
|
|
static void RequestVehicleModFiles(CVehicle* pVehicle, s32 flags = 0);
|
|
|
|
void SetKitIndex(u16 kitIndex)
|
|
{
|
|
#if __FINAL
|
|
m_kitIdx = kitIndex;
|
|
#else
|
|
XPARAM(disableVehMods);
|
|
m_kitIdx = PARAM_disableVehMods.Get()? INVALID_VEHICLE_KIT_INDEX : kitIndex;
|
|
#endif
|
|
}
|
|
|
|
u16 GetKitIndex() const
|
|
{
|
|
#if __FINAL
|
|
return m_kitIdx;
|
|
#else
|
|
XPARAM(disableVehMods);
|
|
return PARAM_disableVehMods.Get()? INVALID_VEHICLE_KIT_INDEX : m_kitIdx;
|
|
#endif
|
|
}
|
|
const CVehicleKit* GetKit() const;
|
|
|
|
// *ForType functions will require mod indices per slot, e.g. 2 would mean third mod for that mod type
|
|
// while the rest of the setters and getters work on the global mod list on the kit where 2 would mean third
|
|
// mod in that kit (can be any type)
|
|
u32 GetNumModsForType(eVehicleModType modSlot, const CVehicle* pVehicle) const;
|
|
void SetModIndexForType(eVehicleModType modSlot, u8 modIndex, CVehicle* pVehicle, bool variation, u32 streamingFlags = 0);
|
|
u8 GetModIndexForType(eVehicleModType modSlot, const CVehicle* pVehicle, bool& variation) const;
|
|
|
|
bool IsGen9ExclusiveVehicleMod(eVehicleModType modSlot, u8 modIndex, const CVehicle* pVehicle) const;
|
|
|
|
void SetPreloadModForType(eVehicleModType modSlot, u8 modIndex, CVehicle* pVehicle);
|
|
bool HasPreloadModsFinished();
|
|
void CleanUpPreloadMods(CVehicle* pVeh);
|
|
void ClearBonePositions();
|
|
|
|
void ApplyDeformation(CVehicle* pParentVehicle, const void* basePtr);
|
|
|
|
void SetBonePosition(u8 modIndex, const Vector3& position) { Assert(modIndex < VMT_RENDERABLE + MAX_LINKED_MODS); m_bonePositions[modIndex] = position; }
|
|
Vector3 GetBonePosition(u8 modIndex) const { Assert(modIndex < VMT_RENDERABLE + MAX_LINKED_MODS); return m_bonePositions[modIndex]; }
|
|
|
|
void UpdateBonePositions(CVehicle* pVehicle);
|
|
|
|
void SetModIndex(eVehicleModType modSlot, u8 modIndex, CVehicle* pVehicle, bool variation, u32 streamingFlags = 0);
|
|
u8 GetModIndex(eVehicleModType modSlot) const { return m_mods[modSlot]; }
|
|
bool SetLinkedModIndex(u8 modIndex, u8& index);
|
|
u8 GetLinkedModIndex(u8 index) const { return m_linkedMods[index]; }
|
|
s32 GetModBoneIndex(u8 modSlot) const;
|
|
|
|
void ToggleMod(eVehicleModType modSlot, bool toogleOn);
|
|
bool IsToggleModOn(eVehicleModType modSlot) const;
|
|
|
|
u8 GetNumMods() const { return m_numMods; }
|
|
const u8* GetMods() const { return m_mods; }
|
|
const u8* GetLinkedMods() const { return m_linkedMods; }
|
|
void ClearMods();
|
|
|
|
#if GTA_REPLAY
|
|
void ClearLinkedModsForReplay();
|
|
#endif //GTA_REPLAY
|
|
|
|
void SetColor1(u8 col) { m_color1 = col; }
|
|
void SetColor2(u8 col) { m_color2 = col; }
|
|
void SetColor3(u8 col) { m_color3 = col; }
|
|
void SetColor4(u8 col) { m_color4 = col; }
|
|
void SetColor5(u8 col) { m_color5 = col; }
|
|
void SetColor6(u8 col) { m_color6 = col; }
|
|
u8 GetColor1() const { return m_color1; }
|
|
u8 GetColor2() const { return m_color2; }
|
|
u8 GetColor3() const { return m_color3; }
|
|
u8 GetColor4() const { return m_color4; }
|
|
u8 GetColor5() const { return m_color5; }
|
|
u8 GetColor6() const { return m_color6; }
|
|
|
|
Color32 GetNeonColour() const { return m_neonColor; }
|
|
void SetNeonColour(Color32 c) { m_neonColor = c; }
|
|
bool IsNeonLOn() const { return m_neonLOn; }
|
|
void SetNeonLOn(bool on) { m_neonLOn = on; }
|
|
bool IsNeonROn() const { return m_neonROn; }
|
|
void SetNeonROn(bool on) { m_neonROn = on; }
|
|
bool IsNeonFOn() const { return m_neonFOn; }
|
|
void SetNeonFOn(bool on) { m_neonFOn = on; }
|
|
bool IsNeonBOn() const { return m_neonBOn; }
|
|
void SetNeonBOn(bool on) { m_neonBOn = on; }
|
|
|
|
void SetSmokeColorR(u8 r) { m_smokeColR = r; }
|
|
void SetSmokeColorG(u8 g) { m_smokeColG = g; }
|
|
void SetSmokeColorB(u8 b) { m_smokeColB = b; }
|
|
u8 GetSmokeColorR() const { return m_smokeColR; }
|
|
u8 GetSmokeColorG() const { return m_smokeColG; }
|
|
u8 GetSmokeColorB() const { return m_smokeColB; }
|
|
|
|
void SetWindowTint(u8 col) { m_windowTint = col; }
|
|
u8 GetWindowTint() const { return m_windowTint; }
|
|
|
|
void SetXenonLightColor(u8 col);
|
|
u8 GetXenonLightColor() const { return m_xenonLightColor; }
|
|
|
|
u32 GetIdentifierHashForType(eVehicleModType modSlot, u32 index) const;
|
|
u32 GetModifierForType(eVehicleModType modSlot, u32 index) const;
|
|
const char* GetModShopLabelForType(eVehicleModType modSlot, u32 index, CVehicle* pVehicle) const;
|
|
|
|
float GetAudioApply(eVehicleModType modSlot) const;
|
|
|
|
u32 GetEngineModifier() const { return GetModifier(VMT_ENGINE); }
|
|
u32 GetBrakesModifier() const { return GetModifier(VMT_BRAKES); }
|
|
u32 GetGearboxModifier() const { return GetModifier(VMT_GEARBOX); }
|
|
u32 GetArmourModifier() const { return GetModifier(VMT_ARMOUR); }
|
|
u32 GetSuspensionModifier() const { return GetModifier(VMT_SUSPENSION); }
|
|
|
|
u32 GetTotalWeightModifier() const;
|
|
float GetArmourDamageMultiplier() const;
|
|
|
|
bool HasCustomWheels() const { return m_mods[VMT_WHEELS] != INVALID_MOD; }
|
|
bool HasCustomRearWheels() const { return m_mods[VMT_WHEELS_REAR_OR_HYDRAULICS] != INVALID_MOD && m_canHaveRearWheels; }
|
|
u32 GetHydraulicsModifier() const { return GetModifier(VMT_WHEELS_REAR_OR_HYDRAULICS); } //hack, reuse VMT_WHEELS_REAR_OR_HYDRAULICS for VMT_HYDRAULICS
|
|
bool HasSpoiler() const { return m_mods[VMT_SPOILER] != INVALID_MOD; }
|
|
|
|
CVehicleStreamRenderGfx* GetVehicleRenderGfx() const { return m_renderGfx; }
|
|
void SetVehicleRenderGfx(CVehicleStreamRenderGfx* newRenderGfx);
|
|
|
|
bool HideModOnBone(const CVehicle* veh, s32 boneIndex, s8& slotTurnedOff);
|
|
void ShowModOnBone(const CVehicle* veh, s32 boneIndex);
|
|
bool IsBoneModed(eHierarchyId hierarchID);
|
|
u8 GetModSlotFromBone(eHierarchyId hierarchID);
|
|
void ShowAllMods() { m_renderableIsVisible = 0; m_renderableIsVisible = ~m_renderableIsVisible; }
|
|
bool IsModVisible(u8 modIndex) const { Assert(modIndex < 64); return (m_renderableIsVisible & (BIT_64(modIndex))) != 0; }// added assert to make sure we dont overrun the bitfield
|
|
bool IsBoneTurnedOff(const CVehicle* veh, s32 boneIndex) const;
|
|
|
|
s32 GetBone(u8 slot) const;
|
|
s32 GetBoneForLinkedMod(u8 slot) const;
|
|
s32 GetBoneToTurnOffForSlot(u8 slot, u32 index) const;
|
|
s32 GetNumBonesToTurnOffForSlot(u8 slot) const;
|
|
bool ShouldDrawOriginalForSlot(CVehicle* veh, u8 slot) const;
|
|
|
|
bool CanHaveRearWheels() const { return m_canHaveRearWheels; }
|
|
|
|
void SetModColor1(eVehicleColorType type, int baseColIndex, int specColIndex);
|
|
void SetModColor2(eVehicleColorType type, int baseColIndex);
|
|
void GetModColor1(eVehicleColorType& type, int& baseColIndex, int& specColIndex);
|
|
void GetModColor2(eVehicleColorType& type, int& baseColIndex);
|
|
const char* GetModColor1Name(bool spec) const;
|
|
const char* GetModColor2Name() const;
|
|
|
|
eVehicleWheelType GetWheelType(const CVehicle* pVeh) const;
|
|
void SetWheelType(eVehicleWheelType type);
|
|
|
|
void EnableVariation(u32 slot) { m_modVariations |= (1 << slot); }
|
|
void DisableVariation(u32 slot) { m_modVariations &= ~(1 << slot); }
|
|
bool HasVariation(u32 slot) const { return (m_modVariations & (1 << slot)) != -0; }
|
|
|
|
bool HaveModsStreamedIn(CVehicle* pVeh);
|
|
|
|
void SetModCollision(CVehicle* pVeh, u32 slot, bool on);
|
|
|
|
void PreRender2();
|
|
|
|
bool HasModMatrixBeenStoredThisFrame(u8 i) const;
|
|
void SetModMatrixStoredThisFrame(u8 i);
|
|
|
|
static int ms_MaxVehicleStreamRequest;
|
|
static int ms_MaxVehicleStreamRender;
|
|
|
|
private:
|
|
u32 GetModifier(eVehicleModType modSlot) const;
|
|
u32 GetWeightModifer(eVehicleModType modSlot) const;
|
|
|
|
u8 GetGlobalModIndex(eVehicleModType modSlot, u8 modIndex, const CVehicle* pVehicle) const;
|
|
Vector3 m_bonePositions[VMT_RENDERABLE + MAX_LINKED_MODS];
|
|
|
|
CVehicleStreamRenderGfx* m_renderGfx;
|
|
|
|
CScriptPreloadData* m_preloadData;
|
|
|
|
eVehicleColorType m_colorType1;
|
|
eVehicleColorType m_colorType2;
|
|
s32 m_baseColorIndex; // these two are stored here, even if we have m_color1/2/3/4 because some color combos might contain the same indices
|
|
s32 m_specColorIndex; // and we need to be able to identify the original combo index set.
|
|
s32 m_baseColorIndex2; // colorType2 can only have a base color
|
|
u64 m_renderableIsVisible;
|
|
Color32 m_neonColor;
|
|
fwFlags64 m_modMatricesStoredThisFrame;
|
|
u16 m_modVariations; // wheels can have optional variations, this bitset keeps track of which have their enabled
|
|
u8 m_mods[VMT_MAX];
|
|
u8 m_linkedMods[MAX_LINKED_MODS];
|
|
u8 m_numMods;
|
|
u16 m_kitIdx;
|
|
u8 m_color1, m_color2, m_color3, m_color4, m_color5, m_color6;
|
|
u8 m_smokeColR, m_smokeColG, m_smokeColB;
|
|
u8 m_windowTint;
|
|
s8 m_wheelType;
|
|
bool m_canHaveRearWheels;
|
|
bool m_neonLOn;
|
|
bool m_neonROn;
|
|
bool m_neonFOn;
|
|
bool m_neonBOn;
|
|
u8 m_xenonLightColor;
|
|
PAR_SIMPLE_PARSABLE;
|
|
};
|
|
CompileTimeAssert((VMT_RENDERABLE + MAX_LINKED_MODS) < 64); // bumped from 32 - hope this doesn't cause any issues
|
|
|
|
// class containing per vehicle data
|
|
class CVehicleVariationData BANK_ONLY(: public rage::datBase)
|
|
{
|
|
public:
|
|
CVehicleVariationData();
|
|
~CVehicleVariationData() {}
|
|
|
|
const char* GetModelName() const { return m_modelName; }
|
|
s32 GetNumColors() const { return m_colors.GetCount(); }
|
|
CVehicleModelColorIndices& GetColor(u32 index) { return m_colors[index]; }
|
|
const CVehicleModelColorIndices& GetColor(u32 index) const { return m_colors[index]; }
|
|
|
|
s32 GetNumKits() const { return m_kits.GetCount(); }
|
|
atHashString GetKit(u32 index) const { return m_kits[index]; }
|
|
|
|
u8 GetLightSettings() const { return m_lightSettingsIndex; }
|
|
void SetLightSettings(u32 value) { m_lightSettingsIndex = (u8)value&0xff; }
|
|
|
|
u8 GetSirenSettings() const { return m_sirenSettingsIndex; }
|
|
void SetSirenSettings(u32 value) { m_sirenSettingsIndex = (u8)value&0xff; }
|
|
|
|
vehicleLightSettingsId GetLightSettingsId() const { return m_lightSettings; }
|
|
void SetLightSettings(vehicleLightSettingsId id) { m_lightSettings = id; }
|
|
|
|
u8 GetSirenSettingsId() const { return m_sirenSettings; }
|
|
void SetSirenSettingsId(u8 id) { m_sirenSettings = id; }
|
|
|
|
int GetNumWindowsWithExposedEdges() const { return m_windowsWithExposedEdges.GetCount(); }
|
|
bool GetDoesWindowHaveExposedEdges(u32 hierarchyIdNameHash) const { for (int i = 0; i < m_windowsWithExposedEdges.GetCount(); i++) { if (m_windowsWithExposedEdges[i] == hierarchyIdNameHash) { return true; } } return false; }
|
|
|
|
CVehicleModelPlateProbabilities& GetPlateProbabilities() { return m_plateProbabilities; }
|
|
const CVehicleModelPlateProbabilities& GetPlateProbabilities() const { return m_plateProbabilities; }
|
|
|
|
#if __BANK
|
|
void SetModelName(const char* newName) { m_modelName = StringDuplicate(newName); }
|
|
void ReserveColors(const int numColors) { m_colors.Reserve(numColors); m_selectedColorBit.Init(numColors); }
|
|
CVehicleModelColorIndices& AppendColor() { return m_colors.Append(); }
|
|
|
|
CVehicleModelColorIndices& AddColor();
|
|
s32 GetWidgetSelectedColorIndex() const { return m_selectedColorBit.GetFirstBitIndex(); }
|
|
void AddWidgets(bkBank & bank, const atArray<const char *>& colorNames, const atArray<const char *>& lightNames, const atArray<const char*>& sirenNames, const CVehicleModelInfoPlates& plateInfo);
|
|
static void WidgetRemoveVehicleColorCB(CallbackData obj, CallbackData clientData);
|
|
void WidgetRemoveVehicleColor(const int colorIndex);
|
|
void WidgetChangedVehicleColor(CallbackData variationIndex);
|
|
void WidgetChangedColorSelection(CallbackData variationIndex);
|
|
#endif // __BANK
|
|
|
|
void OnPostLoad();
|
|
void OnPreSave();
|
|
|
|
private:
|
|
const char* m_modelName;
|
|
atArray<CVehicleModelColorIndices> m_colors;
|
|
atArray<atHashString> m_kits;
|
|
atArray<atHashString> m_windowsWithExposedEdges; // hashed vehicle hierarchy id names
|
|
CVehicleModelPlateProbabilities m_plateProbabilities;
|
|
u8 m_lightSettingsIndex;
|
|
u8 m_sirenSettingsIndex;
|
|
vehicleLightSettingsId m_lightSettings;
|
|
sirenSettingsId m_sirenSettings;
|
|
|
|
#if __BANK
|
|
atBitSet m_selectedColorBit; // bitmask (only one bit set at a time)
|
|
#endif // __BANK
|
|
|
|
PAR_SIMPLE_PARSABLE;
|
|
};
|
|
|
|
// main class that contains all vehicle variation data
|
|
class CVehicleModelInfoVariation BANK_ONLY(: public rage::datBase)
|
|
{
|
|
public:
|
|
CVehicleModelInfoVariation();
|
|
~CVehicleModelInfoVariation();
|
|
|
|
atArray<CVehicleVariationData>& GetVariationData() { return m_variationData; }
|
|
|
|
#if __BANK
|
|
void AddWidgets(rage::bkBank & bank);
|
|
void RefreshVehicleWidgets();
|
|
|
|
void ReshuffleColors(s32 editingIndex);
|
|
void ReshuffleLights(s32 editingIndex);
|
|
void ReshuffleSirens(s32 editingIndex);
|
|
#endif // __BANK
|
|
|
|
void OnPostLoad();
|
|
void OnPreSave();
|
|
|
|
private:
|
|
atArray<CVehicleVariationData> m_variationData;
|
|
|
|
|
|
#if __BANK
|
|
void DeleteWidgetNames();
|
|
void WidgetAddVehicleColor();
|
|
void WidgetCopyColorsFromVehicle();
|
|
|
|
s32 m_vehicleModelEditingIndex;
|
|
s32 m_vehicleCopyFromIndex;
|
|
bkGroup* m_vehicleModelBankGroup;
|
|
bkGroup* m_vehicleCurrentModelBankGroup;
|
|
atArray<const char*> m_vehicleNames; // extracted for widgets
|
|
atArray<u16> m_vehicleIndices;
|
|
#endif
|
|
|
|
PAR_SIMPLE_PARSABLE;
|
|
};
|
|
|
|
#endif // INC_VEHICLE_MODELINFO_VARIATION_H_
|