// // streaming/populationstreaming.h // // Copyright (C) 1999-2009 Rockstar Games. All Rights Reserved. // #ifndef STREAMING_POPULATIONSTREAMING_H #define STREAMING_POPULATIONSTREAMING_H #include "atl/array.h" #include "streaming/streamingdefs.h" #include "modelinfo/PedModelInfo.h" #include "modelinfo/VehicleModelInfoFlags.h" class CPedStreamRenderGfx; class CPopZone; class CVehicleStreamRenderGfx; #if RSG_ORBIS || RSG_DURANGO || RSG_PC #define MAX_HD_VEHICLES (64) // all models really, we won't have 64 different vehicle models in memory #define MAX_HD_VEHICLES_IN_MP (64) #define ASSET_MULTIPLIER (3) #else #define MAX_HD_VEHICLES (2) #define MAX_HD_VEHICLES_IN_MP_GARAGE (5) #define ASSET_MULTIPLIER (1) #endif #define MIN_NUMBER_STREAMED_CARS (3 * ASSET_MULTIPLIER) // The code tries to at least have this many vehicles streamed in. #define MIN_NUMBER_STREAMED_PEDS (2 * ASSET_MULTIPLIER) // The code tries to at least have this many peds streamed in. #define MAX_NUMBER_STREAMED_SCENARIO_PEDS_PER_SLOT (2 * ASSET_MULTIPLIER) #define SCENARIO_DONT_GET_RELOADED_DURATION (1000) // Scenario peds will not be reloaded after being streamed out for this long. #define MAX_NETWORK_MODEL_INTERVALS (128) #define NUM_NETWORK_MODEL_VARIATIONS (7) #define MAX_MEM_LEVELS (4) #define DEBUG_POPULATION_MEMORY (1 && !__FINAL) namespace rage { class Vector3; }; class CLoadedModelGroup { public: CLoadedModelGroup() {Clear();} void Clear(); bool AddMember(u32 NewMember); bool RemoveMember(u32 OldMember); u32 GetMember(u32 Member) const; int CountMembers() const; bool IsEmpty(); int CountUsableOnes(); bool IsMemberInGroup(u32 ModelIndex) const; bool IsMaleInPedGroup(); bool IsFemaleInPedGroup(); bool IsBikeDriverInPedGroup(); bool IsBikeInVehGroup(); strLocalIndex PickRandomCarModel(bool cargens); u32 PickRandomPedModel(); void SortBasedOnUsage(); u32 PickLeastUsedModel(int MaxOfThem); u32 PickLeastUsedPedModel(); void Merge(CLoadedModelGroup *pList1, CLoadedModelGroup *pList2, CLoadedModelGroup *pList3 = NULL, CLoadedModelGroup *pList4 = NULL); void CopyCarsThatBelongInThisZone(CLoadedModelGroup *pSource, CPopZone *pZone); void Copy(CLoadedModelGroup *pSource); void CopyCarsSmallWorkers(CLoadedModelGroup *pSource, bool bSmallWorkers); void CopyEligibleCars(const Vector3 & vPos, CLoadedModelGroup* source, bool smallWorkers, bool removeNonNative, bool removeCopCars, bool removeOnlyOnHighway, bool removeNonOffroad, bool removeBigVehicles); void RemoveCarsFromGroup(s32 popGroup); void RemoveModelsNotInGroup(s32 popGroup, bool peds); void RemoveModelsNotInModelSet(int/*CAmbientModelSetManager::ModelSetType)*/ modelSetType, int modelSetIndex); void RemoveOnlyOnHighwayCarsFromGroup(); void RemoveNonOffroadCars(); void RemoveNonNativeCars(); void RemoveBoats(); void RemoveTaxiVehs(); void RemoveCopVehs(); void RemoveEmergencyServices(); void RemoveBigVehicles(); void RemoveDiscardedVehicles(); void RemoveModelsThatHaveHitMaximumNumber(); void RemoveRareModels(); void RemoveModelsThatAreUsedNearby(const Vector3 *coors); void RemoveNonMotorcyclePeds(); void RemoveVehModelsWithFlagSet(CVehicleModelInfoFlags::Flags flag, bool flagValue = true); void RemovePedModelsThatCantDriveCars(bool forDriver); void RemoveSuppresedPeds(); void RemovePedsThatCantDriveCarType(ePedVehicleTypes carType); void RemoveSuppressedAndNonAmbientCars(); void RemoveMaleOrFemale(bool male); void RemoveNonPassengerPeds(); void RemoveBulkyItemPeds(); void SortCarsByDistance(const Vector3& pos, bool cargens); void SortCarsByMemoryUse(); void SortCarsByName(); void SortPedsByDistance(const Vector3& pos); void SortPedsByMemoryUse(); void SortPedsByName(); private: void RemoveIndex(s32 index); u32 aMembers[MAX_NUM_IN_LOADED_MODEL_GROUP]; }; struct sPopEntry { strIndex streamIdx; s32 refCount; }; enum eMemoryTrackType { MTT_VEHICLE, MTT_PED, MTT_WEAPON, MTT_MAX }; class CPopulationStreaming { friend class CLoadedModelGroup; public: //PURPOSE // Class Constructor CPopulationStreaming(); //PURPOSE // Initialises the population streaming system //PARAMS // initMode - The type of initialisation to perform void Init(unsigned initMode); //PURPOSE // Loads population streaming values from Tunables (peds and vehicle population limits) void OnTunablesLoad(); //PURPOSE // Shuts down the population streaming system //PARAMS // shutdownMode - The type of shutdown to perform void Shutdown(unsigned shutdownMode); //PURPOSE // Updates the population streaming system void Update(); //PURPOSE // Returns the network model variation ID to use when determining which models to stream during network games u32 GetNetworkModelVariationID() { return m_NetworkModelVariationID; } //PURPOSE // Sets the network model variation ID to use when determining which models to stream during network games //PARAMS // networkModelVariationID - The ID to use void SetNetworkModelVariationID(u32 networkModelVariationID); //PURPOSE // Sets the reduce ambient ped model budget flag. If this is set // a reduced number of ambient ped models will be streamed in for // use by the ambient population. This is useful for scripts that // stream in a large number of ped models. //PARAMS // value - The value to set the flag to void SetReduceAmbientPedModelBudget(bool value); //PURPOSE // Sets the reduce ambient vehicle model budget flag. If this is set // a reduced number of ambient vehicle models will be streamed in for // use by the ambient population. This is useful for scripts that // stream in a large number of vehicle models. //PARAMS // value - The value to set the flag to void SetReduceAmbientVehicleModelBudget(bool value); //PURPOSE // This function is called when the population cycle information changes. // This affects which cars and peds should be streamed in and updates the // system accordingly void HandlePopCycleInfoChange(bool enteredNewZone); //PURPOSE // Attempts to stream one of the currently loaded vehicle models out. Only // vehicles that have been used a minimum number of times will be streamed // out unless the force parameter is set to true. This function only marks // the model as available for removal by the streaming system, so it will // not be streamed out until there are no more instances of the model on the map //PARAMS // force - Indicates whether a model should be streamed out regardless of // how many times it has been used bool StreamOneCarOut(bool force = false); //PURPOSE // Attempts to stream one of the currently loaded ped models out. Only // peds that have been used a minimum number of times will be streamed // out unless the force parameter is set to true. This function only marks // the model as available for removal by the streaming system, so it will // not be streamed out until there are no more instances of the model on the map //PARAMS // force - Indicates whether a model should be streamed out regardless of // how many times it has been used bool StreamOnePedOut(bool force = false); //PURPOSE // Returns whether the ped is available for spawn bool IsPedAvailableForSpawn(u32 modelIndex); //PURPOSE // Returns whether the given vehicle type has a driver loaded in memory or not bool IsDriverAvailable(u32 modelIndex); //PURPOSE // This function is called by the streaming system once a model has // finished streaming into memory //PARAMS // modelIndex - The model index of the model that has streamed in void ModelHasBeenStreamedIn(u32 modelIndex); //PURPOSE // This function is called by the streaming system once a model has // finished streaming out of memory //PARAMS // modelIndex - The model index of the model that has streamed out void ModelHasBeenStreamedOut(u32 modelIndex); //PURPOSE // Returns a model index of a fallback ped. This is an average // looking ped that can used when a specific ped model requested is not available u32 GetFallbackPedModelIndex(bool bDriversOnly = true); //PURPOSE // Returns whether there is a fallback ped available. This is an average // looking ped that can used when a specific ped model requested is not available bool IsFallbackPedAvailable(bool bikesOnly = false, bool bDriversOnly = true); //PURPOSE // Returns a list of peds that can be used as fallback drivers void GetFallbackPedGroup(CLoadedModelGroup& fallbackGroup, bool carDrivers); //PURPOSE // Scenario code makes requests for peds through this function. bool StreamScenarioPeds(fwModelId PedModel, bool highPri, bool startupMode, const char* debugSourceName); //PURPOSE // Returns a list of streamed in peds available for use in the current location CLoadedModelGroup& GetAppropriateLoadedPeds() {return m_AppropriateLoadedPeds;} //PURPOSE // Returns a list of streamed in peds not available for use in the current location CLoadedModelGroup& GetInAppropriateLoadedPeds() {return m_InAppropriateLoadedPeds;} //PURPOSE // Returns a list of streamed in peds not available in any pop zone CLoadedModelGroup& GetSpecialLoadedPeds() {return m_SpecialLoadedPeds;} //PURPOSE // Returns a list of discarded peds CLoadedModelGroup& GetDiscardedPeds() {return m_DiscardedPeds;} //PURPOSE // Returns a list of streamed in vehicles available for use in the current location CLoadedModelGroup& GetAppropriateLoadedCars() {return m_AppropriateLoadedCars;} //PURPOSE // Returns a list of streamed in vehicles not available for use in the current location CLoadedModelGroup& GetInAppropriateLoadedCars() {return m_InAppropriateLoadedCars;} //PURPOSE // Returns a list of discarded vehicles CLoadedModelGroup& GetDiscardedCars() {return m_DiscardedCars;} //PURPOSE // Returns a list of special vehicles CLoadedModelGroup& GetSpecialCars() {return m_SpecialLoadedCars;} //PURPOSE // Returns a list of streamed in boats available for use in the current location CLoadedModelGroup& GetLoadedBoats() {return m_LoadedBoats;} //PURPOSE // Returns true if the given car model index is in the discarded list bool IsCarDiscarded(u32 modelIndex); //PURPOSE // Displays debug text describing the currently streamed in ped models void PrintDebugForPeds(); //PURPOSE // Displays debug text describing the currently streamed in vehicle models void PrintDebugForVehicles(); //PURPOSE // Request several vehicles to be streamed in, should be used at startup to populate the appropriate loaded cars array. void InitialVehicleRequest(u32 numRequests); //PURPOSE // Resets the level of the vehicle memory budget to its starting value (called when a mission script terminates) void ResetVehMemoryBudgetLevel(); //PURPOSE // Sets the level of the vehicle memory budget void SetVehMemoryBudgetLevel(u32 level); //PURPOSE // Resets the level of the ped memory budget to its starting value (called when a mission script terminates) void ResetPedMemoryBudgetLevel(); //PURPOSE // Sets the level of the ped memory budget void SetPedMemoryBudgetLevel(u32 level); //PURPOSE // Add object to list of objects that are considered resident and shouldnt be considered in the budgets void AddResidentObject(strIndex streamingIndex) {m_residentObjects.PushAndGrow(streamingIndex);} //PURPOSE // Remove object from the list of objects that are considered resident and shouldnt be considered in the budgets void RemoveResidentObject(strIndex streamingIndex) {m_residentObjectsToRemove.PushAndGrow(streamingIndex);} //PURPOSE // Return list of objects considered resident and shouldnt be considered in the budgets const atArray& GetResidentObjectList() const {return m_residentObjects;} //PURPOSE // Callback to remove ped objects as they are out to be deleted. void RemoveResidentPedObjects(); #if __BANK //PURPOSE // Overrides all vehicle archetypes with the one specified void SetVehicleOverrideIndex(u32 index) { m_vehicleOverrideIndex = index; } u32 GetVehicleOverrideIndex() const { return m_vehicleOverrideIndex; } void AllocateVehicleAndPedResourceMem(); void FreeVehicleAndPedResourceMem(); //PURPOSE // Dumps detailed vehicle memory to tty void DumpVehicleMemoryInfo(); #endif //PURPOSE // Checks if a vehicle model is in the allowed network array, if a net game is on bool IsVehicleInAllowedNetworkArray(u32 modelIndex) const; //PURPOSE // Flushes all vehicle models out from memory static void FlushAllVehicleModelsHard(); //PURPOSE // Flushes all vehicle models out from memory, ignores streaming requests so doesn't guarantee 100% everything will be ejected static void FlushAllVehicleModelsSoft(); //PURPOSE // Returns the currently allowed ped model start offset into the list of peds streamed // during network games. This is based off the current network time and dependent on how // many unwanted ped models are currently in the process of streaming out u32 GetAllowedNetworkPedModelStartOffset() { return m_LocalAllowedPedModelStartOffset; } //PURPOSE // Returns the currently allowed vehicle model start offset into the list of vehicles streamed // during network games. This is based off the current network time and dependent on how // many unwanted vehicle models are currently in the process of streaming out u32 GetAllowedNetworkVehicleModelStartOffset() { return m_LocalAllowedVehicleModelStartOffset; } //PURPOSE // In network games the list of models available for streaming is stored in a list // consistent across machines, and the current network time is used to generate an // offset into this list to cycle the models streamed over time. The model offset // can wrap if the network session is running long enough, so when comparing two // model offsets to find which is the lower we need to take wrapping into account. // This function provides a method of comparing two model offsets based on this considerations //PARAMS // firstModelOffset - Model offset to check whether lower than the second // secondModelOffset - Model offset to compare first model offset against bool IsNetworkModelOffsetLower(u32 firstModelOffset, u32 secondModelOffset); //PURPOSE // Gets the number of ped models that are loaded due to scenarios. // PARAMS // eSlotType - which type of ped is being streamed in (generally normal or small for things like birds) int GetNumScenarioPedModelsLoaded(eScenarioPopStreamingSlot eSlotType) const { return m_aNumScenarioPedModelsLoaded[eSlotType]; } #if !__FINAL //PURPOSE // Gets a string name of the slot for debugging. static const char* GetScenarioSlotName(eScenarioPopStreamingSlot eSlotType); #endif //PURPOSE // This function is called when a streamed ped gets new assets //PARAMS // gfx - The streamed render gfx objects which keeps track of all current assets void AddStreamedPedVariation(const CPedStreamRenderGfx* gfx); //PURPOSE // This function is called when a mod variation is set on a vehicle //PARAMS // gfx - The streamed render gfx objects which keeps track of all current assets void AddStreamedVehicleVariation(const CVehicleStreamRenderGfx* gfx); //PURPOSE // This function is called when a streamed ped has its assets removed //PARAMS // gfx - The streamed render gfx objects which keeps track of all current assets void RemoveStreamedPedVariation(const CPedStreamRenderGfx* gfx); //PURPOSE // This function is called when a mod variation is removed from a vehicle //PARAMS // gfx - The streamed render gfx objects which keeps track of all current assets void RemoveStreamedVehicleVariation(const CVehicleStreamRenderGfx* gfx); //PURPOSE // Get the current limit for how many scenario peds can be streamed in int GetMaxScenarioPedModelsLoadedPerSlot() const { return m_MaxScenarioPedModelsLoadedPerSlot; } //PURPOSE // Set the current limit for how many scenario peds can be streamed in //PARAMS // num - The new limit void SetMaxScenarioPedModelsLoadedPerSlot(int num) { m_MaxScenarioPedModelsLoadedPerSlot = num; } //PURPOSE // Set the script override of how many scenario peds can be streamed in //PARAMS // num - The new override, or -1 for no override void SetMaxScenarioPedModelsLoadedOverride(int num) { m_MaxScenarioPedModelsLoadedOverride = num; } //PURPOSE // Get the script override of how many scenario peds can be streamed in int GetMaxScenarioPedModelsLoadedOverride() const { return m_MaxScenarioPedModelsLoadedOverride; } //PURPOSE // Temporarily prevent new scenario ped models from being streamed in //PARAMS // timeInMS - Time in milli-seconds for how long from now to prevent new scenario models void DisallowScenarioPedStreamingForDuration(u32 timeInMS); //PURPOSE // Returns whether the vehicle with the specified model index is part of the // current population zone //PARAMS // modelIndex - The model index of the vehicle to check bool DoesCarModelBelongInCurrentPopulationZone(u32 modelIndex); //PURPOSE // Keeps track on when we spawned a vehicle on highway last, to know if we need to stream anything specific in void SpawnedVehicleOnHighway(); //PURPOSE // Returns available memory for vehicles and peds #if __PS3 || __XENON s32 GetMemForVehiclesAdjustment(eMemoryType eType, u32 uLevel) const; s32 GetMemForPedsAdjustment(eMemoryType eType, u32 uLevel) const; #endif // __PS3 || __XENON s32 GetMemForVehicles(eMemoryType eType, u32 uLevel) const; s32 GetMemForPeds(eMemoryType eType, u32 uLevel) const; s32 GetCurrentMemForPeds() const; s32 GetCurrentMemForVehicles() const; //PURPOSE static s32 GetCachedTotalMemUsedByPeds() { return sm_TotalMemUsedByPeds; } // Returns total memory used by peds s32 GetTotalMemUsedByPeds() const { return m_TotalMemoryUsedByPedModelsMain + m_TotalMemoryUsedByPedModelsVram + m_TotalStreamedPedMemoryMain + m_TotalStreamedPedMemoryVram; } s32 GetTotalMainUsedByPeds() const { return m_TotalMemoryUsedByPedModelsMain + m_TotalStreamedPedMemoryMain; } s32 GetTotalVramUsedByPeds() const { return m_TotalMemoryUsedByPedModelsVram + m_TotalStreamedPedMemoryVram; } s32 GetTotalStreamedMainUsedByPeds() const { return m_TotalStreamedPedMemoryMain; } s32 GetTotalStreamedVramUsedByPeds() const { return m_TotalStreamedPedMemoryVram; } //PURPOSE static s32 GetCachedTotalMemUsedByVehicles() { return sm_TotalMemUsedByVehicles; } // Returns total memory used by vehicles s32 GetTotalMemUsedByVehicles() const { return m_TotalMemoryUsedByVehicleModelsMain + m_TotalMemoryUsedByVehicleModelsVram + m_TotalStreamedVehicleMemoryMain + m_TotalStreamedVehicleMemoryVram; } s32 GetTotalMainUsedByVehicles() const { return m_TotalMemoryUsedByVehicleModelsMain + m_TotalStreamedVehicleMemoryMain; } s32 GetTotalVramUsedByVehicles() const { return m_TotalMemoryUsedByVehicleModelsVram + m_TotalStreamedVehicleMemoryVram; } s32 GetTotalStreamedMainUsedByVehicles() const { return m_TotalStreamedVehicleMemoryMain; } s32 GetTotalStreamedVramUsedByVehicles() const { return m_TotalStreamedVehicleMemoryVram; } //PURPOSE // Returns total memory used by weapons s32 GetTotalMainUsedByWeapons() const { return m_TotalWeaponMemoryMain; } s32 GetTotalVramUsedByWeapons() const { return m_TotalWeaponMemoryVram; } //PURPOSE // This function decides if we should request a driver to the given vehicle and if so adds the request //PARAMS // modelIndex - The model index of the vehicle that (maybe) needs a driver void RequestVehicleDriver(u32 vehicleModelIndex); //PURPOSE // This function decides if we should undo a driver request //PARAMS // modelIndex - The model index of the vehicle that doesn't need a driver anymore void UnrequestVehicleDriver(u32 vehicleModelIndex); bool CanSpawnInMp(u32 modelIndex); #if __BANK float RenderPedMemoryUse(float x, float y); float RenderVehicleMemoryUse(float x, float y); #endif //__BANK private: //PURPOSE // Stores information about a currently streamed in model (vehicle or ped) struct StreamedInModelData { u32 m_ModelIndex; // model index of a streamed in model s32 m_TimeStreamedIn; // time the model was streamed in s32 m_TimeNoLongerRequired; // time the model was marked available for streaming out u32 m_HDAssetSizeMain; // main mem size of hd assets, if any are loaded u32 m_HDAssetSizeVram; // vram mem size of hd assets, if any are loaded #if DEBUG_POPULATION_MEMORY u32 m_mainUsed; u32 m_vramUsed; #endif // DEBUG_POPULATION_MEMORY bool m_IsHD; // keeps track if the current entry has its hd assets counted in the budget or not bool m_IsWeapon; }; //PURPOSE // Used by GetAdjustedModelStartOffset() to determine whether to calculate an offset for // peds or vehicles enum ModelOffsetType { PED_MODEL_OFFSET, // ped model offset VEHICLE_MODEL_OFFSET, // vehicle model offset }; static const unsigned MAX_STREAMED_IN_MODELS = (128 + 32) * ASSET_MULTIPLIER; //PURPOSE // Get the total number of cars streamed in u32 GetTotalNumberOfCarsStreamedIn() const; //PURPOSE // Adds a car to the discarded list and removes it from the other lists for book keeping //PARAMS // modelIndex - The index of the model to add void AddDiscardedCar(u32 modelIndex); //PURPOSE // Re-instates a discarded car back into the correct lists //PARAMS // modelIndex - The index of the model to add void ReinstateDiscardedCar(u32 modelIndex); //PURPOSE // Adds a ped to the discarded list and removes it from the other lists for book keeping //PARAMS // modelIndex - The index of the model to add void AddDiscardedPed(u32 modelIndex); //PURPOSE // Re-instates a discarded ped back into the correct lists //PARAMS // modelIndex - The index of the model to add void ReinstateDiscardedPed(u32 modelIndex); //PURPOSE // Addes a streamed or re-instated model to the correct appropriate list //PARAMS // modelIndex - The index of the model to add bool AddPedModelToCorrectList( u32 modelIndex ); //PURPOSE // Stores information about a newly streamed in model //PARAMS // modelIndex - The index of the model to add s32 AddStreamedInModelData(u32 modelIndex); //PURPOSE // Removes information about a newly streamed out model //PARAMS // modelIndex - The index of the model to remove bool RemoveStreamedInModelData(u32 modelIndex); //PURPOSE // Returns whether the specified model data is currently streamed in //PARAMS // modelIndex - The index of the model to check bool IsModelDataStreamedIn(u32 modelIndex); //PURPOSE // Stores information about a newly used component if it's not already in the list //PARAMS // modelIndex - The index of the parent model // componentList - The component list for this model type // totalAccum - total memory accumulator for this model type // totalVirtual - total new virtual memory used in the budget by this model // totalPhysical - total new physical memory used in the budget by this model void AddStreamedInComponent(u32 modelIndex, atArray& componentList, u32& totalVirtual, u32& totalPhysical, eMemoryTrackType type); void AddStreamedInDependencies(const atArray& deps, atArray& componentList, u32& totalVirtual, u32& totalPhysical, eMemoryTrackType type); //PURPOSE // Removes information about a newly discarded component. Subtracts memory from budget if refcount is 0 //PARAMS // modelIndex - The index of the parent model // componentList - The component list for this model type // totalAccum - total memory accumulator for this model type // totalVirtual - total virtual memory that was removed from the budget by this model // totalPhysical - total physics memory that was removed from the budget by this model void RemoveStreamedInComponent(u32 modelIndex, atArray& componentList, u32& totalVirtual, u32& totalPhysical, eMemoryTrackType type); void RemoveStreamedInDependencies(const atArray& deps, atArray& componentList, u32& totalVirtual, u32& totalPhysical, eMemoryTrackType type); //PURPOSE // Returns the time a model (vehicle or ped) was streamed in //PARAMS // modelIndex - The index of the model to check s32 GetTimeModelStreamedIn(u32 modelIndex); //PURPOSE // Sets the time a model (vehicle or ped) was streamed in (for use to prolong scenario uses) //PARAMS // modelIndex - The index of the model to change void SetTimeModelStreamedIn(fwModelId PedModelId, s32 time); //PURPOSE // Marks a model (vehicle or ped) as no longer requires to be streamed in //PARAMS // modelIndex - The index of the model to set as no longer needed void MarkModelNoLongerRequired(u32 modelIndex); //PURPOSE // Returns whether the vehicle with the specified model index should be streamed in //PARAMS // modelIndex - The model index of the vehicle to check bool IsCarModelNeededCurrently(u32 modelIndex); //PURPOSE // Returns whether the ped with the specified model index should be streamed in //PARAMS // modelIndex - The model index of the ped to check bool IsPedModelNeededCurrently(u32 modelIndex); //PURPOSE // Returns whether the ped with the specified model index is needed in any zone //PARAMS // modelIndex - The model index of the ped to check bool IsPedModelNeededInAnyZone(u32 modelIndex); //PURPOSE // Streams a new vehicle model for use by the ambient population void StreamOneNewCar(); //PURPOSE // Streams a new ped model for use by the ambient population void StreamOneNewPed(bool bNeedDriver); //PURPOSE // Counts the number of common vehicles we have in memory u32 GetNumCommonVehicles(); //PURPOSE // Chooses a new vehicle model to stream in for use by the ambient population in network games u32 ChooseNewVehicleModelForMP(); //PURPOSE // Chooses a new vehicle model to stream in for use by the ambient population in single player games u32 ChooseNewVehicleModelForSP(); //PURPOSE // Chooses a new ped model to stream in for use by the ambient population in single player games u32 ChooseNewPedModelForSP(bool bNeedDriver); //PURPOSE // Chooses a new ped model to stream in for use by the ambient population in multiplayer games u32 ChooseNewPedModelForMP(bool bNeedDriver); //PURPOSE // Attempts to stream new models in for use by the ambient population, // if necessary void StreamModelsIn(); //PURPOSE // Attempts to stream any models out that are no longer required. void StreamModelsOut(); //PURPOSE // Finds the oldest model in memory and returns its id strLocalIndex FindOldestModelToStreamOut(bool isPed, bool canStreamCommonOut); //PURPOSE // Builds a list of candidate models to stream out in single player games //PARAMS // candidatesToRemove - list of models to stream out void GetCandidateVehiclesToStreamOutForSP(CLoadedModelGroup &candidatesToRemove, bool canStreamCommonVehicleOut); //PURPOSE // This function is called when a ped model has finished streaming in //PARAMS // modelIndex - The model index of the ped streamed in void PedHasBeenStreamedIn(u32 modelIndex); //PURPOSE // This function is called when a ped model has finished streaming out //PARAMS // modelIndex - The model index of the ped streamed out void PedHasBeenStreamedOut(u32 modelIndex); //PURPOSE // This function is called when a vehicle model has finished streaming in //PARAMS // modelIndex - The model index of the vehicle streamed in void VehicleHasBeenStreamedIn(u32 modelIndex); //PURPOSE // This function is called when a vehicle model has finished streaming out //PARAMS // modelIndex - The model index of the vehicle streamed out void VehicleHasBeenStreamedOut(u32 modelIndex); //PURPOSE // This function is called when a weapon model has finished streaming in //PARAMS // modelIndex - The model index of the weapon streamed in void WeaponHasBeenStreamedIn(u32 modelIndex); //PURPOSE // This function is called when a weapon model has finished streaming out //PARAMS // modelIndex - The model index of the weapon streamed out void WeaponHasBeenStreamedOut(u32 modelIndex); //PURPOSE // Updates the appropriate and inappropriate vehicle lists when the pop // cycle changes void ReclassifyLoadedCars(); //PURPOSE // Updates the appropriate and inappropriate ped lists during // network games based on the time models have been streamed in void ReclassifyLoadedVehiclesForNetwork(); //PURPOSE // Updates the appropriate and inappropriate ped lists when the pop // cycle changes void ReclassifyLoadedPeds(); //PURPOSE // Updates the appropriate and inappropriate ped lists during // network games based on the time models have been streamed in void ReclassifyLoadedPedsForNetwork(); //PURPOSE // Removes an unused models from the streaming system void RemoveUnusedModels(); //PURPOSE // Keeps track of what HD assets are in memory for the vehicles and peds we have loaded void UpdateHDCosts(); //PURPOSE // Removes all streamed in ped models when the system is shutting down void RemoveStreamedPedModelsOnShutdown(); //PURPOSE // Removes all streamed in vehicle models when the system is shutting down void RemoveStreamedCarModelsOnShutdown(); //PURPOSE // Ensures there is enough CVehicleStructures objects for new // vehicle models to be streamed in. If the number of free // CVehicleStructures drops below a threshold this function attempts to make space. void EmergencyRemoveVehicleStructures(); //PURPOSE // Marks vehicle models that are not currently required for removal by the streaming system void TellStreamingAboutDeletableVehicles(); //PURPOSE // Marks ped models that are not currently required for removal by the streaming system void TellStreamingAboutDeletablePeds(); //PURPOSE // Chooses a vehicle from the specified car group to stream in //PARAMS // vehModelGroup - The car group to load the vehicle from u32 ChooseCarModelToLoad(s32* groupArray, s32 numGroups, u32 restrictions); //PURPOSE // Checks whether the specified vehicle model is incompatible with // the other currently loaded vehicles. This is used to prevent too // many similar or unusual vehicles being streamed in at the same time //PARAMS // modelIndex - The index of the model to check bool IsIncompatibleWithAlreadyLoadedCar(u32 modelIndex); //PURPOSE // Finds the best ped to stream in next fromt he lsit of peds in the current pop zone u32 ChoosePedModelToLoad(s32* groupArray, s32 numGroups, u32 restrictions); //PURPOSE // Returns true if the given ped model info can drive cars bool CanPedModelDrive(u32 mi); //PURPOSE // Returns true if the given ped model info can ride bikes bool CanPedModelRideBike(u32 mi); //PURPOSE // Updates the list of currently required models for the network game void UpdateModelsRequiredForNetwork(); //PURPOSE // Updates the list of currently required vehicle models for the network game //PARAMS // modelStartOffset - Start offset into the list of models for the current pop zone for calculating the list of models to stream void UpdateVehicleModelsRequiredForNetwork(u32 modelStartOffset); //PURPOSE // Updates the list of currently required ped models for the network game //PARAMS // modelStartOffset - Start offset into the list of models for the current pop zone for calculating the list of models to stream void UpdatePedModelsRequiredForNetwork(u32 modelStartOffset); //PURPOSE // The models streamed in network games are taken from the population zones and are cycled based on the network time. // A new model can only be streamed when some of the old models have been streamed out. To ensure machines in the same network // session always stream the same vehicles we can only stream a new model when all of the nearby players are ready. This function // determines the allowable model start offset based on these rules (it will return the current model start offset if it is not possible // to stream a new model yet) //PARAMS // offsetType - type of model offset to check - vehicles or peds // desiredModelStartOffset - the target model start offset (derived from network time) // popScheduleChanged - indicates whether the pop schedule has changed since the model lists were last updated u32 GetAdjustedModelStartOffset(ModelOffsetType offsetType, u32 desiredModelStartOffset, bool popScheduleChanged); #if __BANK //PURPOSE // Logs information about the models pending removal that are preventing the desired model start offset from being used. // This is generally because instances of these models are nearby the local player and cannot be cleaned up //PARAMS // offsetType - Indicates whether these models are for peds or vehicles // desiredModelStartOffset - This is the offset into the models list that we want to use based off the current network time interval // adjustedModelStartOffset - This is the offset into the models list adjusted to take into account of old models pending removal void LogModelsPendingRemovalInfo(ModelOffsetType offsetType, u32 desiredModelStartOffset, u32 adjustedModelStartOffset); #endif // __BANK //PURPOSE // Returns the current network time interval to use to index into the model lists u32 GetCurrentNetworkTimeInterval(); //PURPOSE // Displays information about the different car groups currently streamed in // in the single player game void PrintCarGroups(); //PURPOSE // Displays information about the different car groups currently streamed in // in the network game void PrintNetworkCarGroups(); //PURPOSE // Returns if we have any free memory left for peds/vehicles bool IsThereAnyMemoryLeft(eMemoryTrackType type); //PURPOSE // Returns if we use more memory than specified in the budget for peds or vehicles bool AreWeOverBudget(eMemoryTrackType type); //PURPOSE // Add/remove memory used by peds/vehicles void AddTotalMemoryUsed(s32 main, s32 vram, eMemoryTrackType type); //PURPOSE // Returns whether we are allowed to stream in one more ped for scenarios or not //PARAMS // highPri - True if this is for a high priority scenario // startupMode - True if we are in the population system's startup mode, i.e. the screen is faded or some similar situation. // eSlotNumber - the scenario streaming slot the model is using bool IsAllowedToRequestScenarioPedModel(bool highPri, bool startupMode, eScenarioPopStreamingSlot eSlotNumber) const; // storage for data about currently streamed in models StreamedInModelData m_StreamedInModelData[MAX_STREAMED_IN_MODELS]; CLoadedModelGroup m_AppropriateLoadedCars; // Currently streamed in vehicles that can be used in the current zone CLoadedModelGroup m_InAppropriateLoadedCars; // Currently streamed in vehicles that cannot be used in the current zone CLoadedModelGroup m_SpecialLoadedCars; // Currently streamed in vehicles outside the ambient population (police cars, taxis etc...) CLoadedModelGroup m_LoadedBoats; // Currently streamed in boats CLoadedModelGroup m_VehicleModelsRequiredForNetwork; // Currently required vehicle models for the network game CLoadedModelGroup m_DiscardedCars; // Car types that have been discarded from the population but are still in memory bool m_bBoatsNeeded; // Do we have to have some boats streamed in here? CLoadedModelGroup m_AppropriateLoadedPeds; // Currently streamed in peds that can be used in the current zone CLoadedModelGroup m_InAppropriateLoadedPeds; // Currently streamed in peds that cannot be used in the current zone CLoadedModelGroup m_SpecialLoadedPeds; // Currently streamed in peds that outside the ambient population (cops, firemen etc...) CLoadedModelGroup m_PedModelsRequiredForNetwork; // Currently required ped models for the network game CLoadedModelGroup m_DiscardedPeds; // ped types discarded by population code but still in memory s32 m_MaxScenarioPedModelsLoadedPerSlot; // How many ped models we are currently allowed to request for scenarios per streaming slot. s32 m_MaxScenarioPedModelsLoadedOverride; // Override of m_MaxScenarioPedModelsLoaded set by script, or -1 s32 m_TotalMemoryUsedByPedModelsMain; // The total main streaming memory currently in use by ped models s32 m_TotalMemoryUsedByPedModelsVram; // The total vram streaming memory currently in use by ped models s32 m_TotalMemoryUsedByVehicleModelsMain; // The total main streaming memory currently in use by vehicle models s32 m_TotalMemoryUsedByVehicleModelsVram; // The total vram streaming memory currently in use by vehicle models s32 m_MemOverBudgetMainPeds; s32 m_MemOverBudgetVramPeds; s32 m_MemOverBudgetMainVehs; s32 m_MemOverBudgetVramVehs; s32 m_TotalStreamedPedMemoryMain; s32 m_TotalStreamedPedMemoryVram; s32 m_TotalStreamedVehicleMemoryMain; s32 m_TotalStreamedVehicleMemoryVram; s32 m_TotalWeaponMemoryMain; s32 m_TotalWeaponMemoryVram; bool m_bReducePedModelBudget; // Indicates whether the streaming budget for peds should be reduced bool m_bReduceVehicleModelBudget; // Indicates whether the streaming budget for vehicles should be reduced u32 m_NetworkModelVariationID; // Used to increase variety in the order models are streamed in, while remaining consistent across machines u32 m_LastTimeUsedForStreamingNetPeds; // The last network time in seconds used to decide which network ped models to stream u32 m_LastTimeUsedForStreamingNetVehicles; // The last network time in seconds used to decide which network vehicle models to stream s32 m_LastZoneUsedForStreamingNetModels; // The last pop zone used to decide which network models to stream u32 m_LocalAllowedPedModelStartOffset; // The ped model start offset the local machine is able to move to (based on network time and how many models are pending streaming out) u32 m_LocalAllowedVehicleModelStartOffset; // The ped model start offset the local machine is able to move to (based on network time and how many models are pending streaming out) u32 m_LastVehicleOnHighwaySpawn; u32 m_ScenarioPedStreamingDisabledUntilTimeMS; // Time stamp (compatible with fwTimer::GetTimeInMilliseconds()) for when we are allowed to stream in new scenario models again. atArray m_vehicleComponents; atArray m_pedComponents; atArray m_weaponComponents; atArray m_residentObjects; atArray m_residentObjectsToRemove; atRangeArray m_aNumScenarioPedModelsLoaded; // How many ped models are streamed in (or have been requested) for scenarioss s8 m_numQueuedVehicleModels; static s32 sm_TotalMemUsedByPeds; static s32 sm_TotalMemUsedByVehicles; #if __BANK u32 m_vehicleOverrideIndex; #endif }; // wrapper class needed to interface with game skeleton code class CPopulationStreamingWrapper { public: static void Init(unsigned initMode); static void Shutdown(unsigned shutdownMode); static void Update(); }; extern CPopulationStreaming gPopStreaming; #endif // STREAMING_POPULATIONSTREAMING_H