Merge branch 'miami' of https://github.com/GTAmodding/re3 into miami

src/audio/AudioManager.cpp

@@ -275,6 +275,7 @@ cAudioManager::ResetTimers(uint32 time)
 		SampleManager.SetEffectsFadeVolume(0);
 		SampleManager.SetMusicFadeVolume(0);
 		MusicManager.ResetMusicAfterReload();
+		m_bIsPlayerShutUp = false;
 #ifdef AUDIO_OAL
 		SampleManager.Service();
 #endif
@@ -622,7 +623,6 @@ cAudioManager::AddDetailsToRequestedOrderList(uint8 sample)
 	m_abSampleQueueIndexTable[m_nActiveSampleQueue][i] = sample;
 }
 
-// --MIAMI: Done
 void
 cAudioManager::AddReflectionsToRequestedQueue()
 {
@@ -684,7 +684,6 @@ cAudioManager::AddReflectionsToRequestedQueue()
 	m_sQueueSample.m_fDistance = oldDist;
 }
 
-// --MIAMI: Done
 void
 cAudioManager::UpdateReflections()
 {

src/audio/AudioManager.h

@@ -4,6 +4,7 @@
 #include "AudioCollision.h"
 #include "PoliceRadio.h"
 #include "VehicleModelInfo.h"
+#include "Vehicle.h"
 
 class tSound
 {
@@ -97,7 +98,7 @@ public:
 	void Process();             // done
 };
 
-VALIDATE_SIZE(cPedComments, 1164);
+VALIDATE_SIZE(cPedComments, 0x490);
 
 class CEntity;
 
@@ -230,8 +231,8 @@ public:
 	~cAudioManager();
 
 	// getters
-	uint32 GetFrameCounter() const { return m_FrameCounter; }
+	uint32 GetFrameCounter() const { return m_FrameCounter; } // done
-	float GetReflectionsDistance(int32 idx) const { return m_afReflectionsDistances[idx]; }
+	float GetReflectionsDistance(int32 idx) const { return m_afReflectionsDistances[idx]; } // done
 	int32 GetRandomNumber(int32 idx) const { return m_anRandomTable[idx]; }
 	int32 GetRandomNumberInRange(int32 idx, int32 low, int32 high) const { return (m_anRandomTable[idx] % (high - low + 1)) + low; }
 	bool IsMissionAudioSamplePlaying(uint8 slot) const; // { return m_sMissionAudio.m_nPlayStatus == 1; }
@@ -248,7 +249,7 @@ public:
 	void CalculateDistance(bool &condition, float dist);                                                                   // done
 	bool CheckForAnAudioFileOnCD() const;                                                                                  // done
 	void ClearActiveSamples();                                                                                             // done
-	void ClearMissionAudio(uint8 slot);                                                                                    // done
+	void ClearMissionAudio(uint8 slot);                                                                                    // done (inlined in vc)
 	void ClearRequestedQueue();                                                                                            // done (inlined in vc)
 	uint32 ComputeDopplerEffectedFrequency(uint32 oldFreq, float position1, float position2, float speedMultiplier) const; // done
 	int32 ComputePan(float, CVector *);                                                                                    // done
@@ -358,7 +359,7 @@ public:
 	uint32 GetGenericFemaleTalkSfx(CPed *ped, int16 sound); // todo names (inlined in vc)
 	// end of functions returning talk sfx
 
-	void GenerateIntegerRandomNumberTable();
+	void GenerateIntegerRandomNumberTable(); // done
 	char *Get3DProviderName(uint8 id) const;
 	uint8 GetCDAudioDriveLetter() const;
 	int8 GetCurrent3DProviderIndex() const;
@@ -373,107 +374,108 @@ public:
 	uint8 GetNum3DProvidersAvailable() const; // done
 	uint32 GetPedCommentSfx(CPed *ped, int32 sound);
 	void GetPhrase(uint32 &phrase, uint32 &prevPhrase, uint32 sample, uint32 maxOffset) const;
-	float GetVehicleDriveWheelSkidValue(uint8 wheel, CAutomobile *automobile, cTransmission *transmission, float velocityChange);
+	float GetVehicleDriveWheelSkidValue(CVehicle* veh, tWheelState wheelState, float gasPedalAudio, cTransmission* transmission, float velocityChange); // done
-	float GetVehicleNonDriveWheelSkidValue(uint8 wheel, CAutomobile *automobile, cTransmission *transmission, float velocityChange);
+	float GetVehicleNonDriveWheelSkidValue(CVehicle* veh, tWheelState wheelState, cTransmission* transmission, float velocityChange);                   // done
 
 	bool HasAirBrakes(int32 model) const; // done
 
 	void Initialise(); // done
-	void InitialisePoliceRadio();
+	void InitialisePoliceRadio(); //done
-	void InitialisePoliceRadioZones();
+	void InitialisePoliceRadioZones(); //done
 	void InterrogateAudioEntities(); // done
-	bool IsAudioInitialised() const;
+	bool IsAudioInitialised() const; // done
-	bool IsMissionAudioSampleFinished(uint8 slot);
+	bool IsMissionAudioSampleFinished(uint8 slot); // done
 	bool IsMP3RadioChannelAvailable() const; // done
 
-	bool MissionScriptAudioUsesPoliceChannel(int32 soundMission) const;
+	bool MissionScriptAudioUsesPoliceChannel(int32 soundMission) const; //done
 
 	void PlayLoadedMissionAudio(uint8 slot);                // done
 	void PlayOneShot(int32 index, int16 sound, float vol);  // done
-	void PlaySuspectLastSeen(float x, float y, float z);    //
+	void PlaySuspectLastSeen(float x, float y, float z);    // done
 	void PlayerJustGotInCar() const;                        // done
 	void PlayerJustLeftCar() const;                         // done
-	void PostInitialiseGameSpecificSetup();                 //
+	void PostInitialiseGameSpecificSetup();                 // done
 	void PostTerminateGameSpecificShutdown();               // done
 	void PreInitialiseGameSpecificSetup() const;            // done
 	void PreloadMissionAudio(uint8 slot, Const char *name); // done
 	void PreTerminateGameSpecificShutdown();                // done
 	/// processX - main logic of adding new sounds
 	void ProcessActiveQueues();                              // done
-	bool ProcessAirBrakes(cVehicleParams *params);
+	bool ProcessAirBrakes(cVehicleParams& params);           // done
-	bool ProcessBoatEngine(cVehicleParams *params);
+	bool ProcessBoatEngine(cVehicleParams& params);          
-	bool ProcessBoatMovingOverWater(cVehicleParams *params);
+	bool ProcessBoatMovingOverWater(cVehicleParams& params); 
 #ifdef GTA_BRIDGE
-	void ProcessBridge();
+	void ProcessBridge();         // done(bcs not exists in VC)
-	void ProcessBridgeMotor();
+	void ProcessBridgeMotor();    // done(bcs not exists in VC)
-	void ProcessBridgeOneShots();
+	void ProcessBridgeOneShots(); // done(bcs not exists in VC)
-	void ProcessBridgeWarning();
+	void ProcessBridgeWarning();  // done(bcs not exists in VC)
 #endif
-	bool ProcessCarBombTick(cVehicleParams *params);                         // done
+	bool ProcessCarBombTick(cVehicleParams& params);                         // done
-	void ProcessCesna(cVehicleParams *params);                               // 
+	void ProcessCarHeli(cVehicleParams& params);                             // done
-	//void ProcessCrane();                                                   // 
+	void ProcessCesna(cVehicleParams& params);                               // 
-	bool ProcessEngineDamage(cVehicleParams *params);                        // done
+	//void ProcessCrane();                                                   // done(bcs not exists in VC)
+	bool ProcessEngineDamage(cVehicleParams& params);                        // done
 	void ProcessEntity(int32 sound);                                         // done
 	void ProcessExplosions(int32 explosion);                                 // done
 	void ProcessFireHydrant();                                               // done
-	void ProcessFires(int32 entity);                                         // 
+	void ProcessFires(int32 entity);                                         // done
 	void ProcessFrontEnd();                                                  // done
 	void ProcessGarages();                                                   // 
-	void ProcessCarHeli(cVehicleParams* params);                             // done
+	void ProcessJumbo(cVehicleParams& params);                               // done
-	void ProcessVehicleFlatTyre(cVehicleParams* params);                     // done
+	void ProcessJumboAccel(CPlane *plane);                                   // done
-	void ProcessJumbo(cVehicleParams *);                                     // 
+	void ProcessJumboDecel(CPlane *plane);                                   // done
-	void ProcessJumboAccel(CPlane *plane);                                   // 
+	void ProcessJumboFlying();                                               // done
-	void ProcessJumboDecel(CPlane *plane);                                   // 
+	void ProcessJumboLanding(CPlane *plane);                                 // done
-	void ProcessJumboFlying();                                               // 
+	void ProcessJumboTakeOff(CPlane *plane);                               	 // done
-	void ProcessJumboLanding(CPlane *plane);                                 // 
+	void ProcessJumboTaxi();                                                 // done
-	void ProcessJumboTakeOff(CPlane *plane);                               	 // 
-	void ProcessJumboTaxi();                                                 // 
 	void ProcessLoopingScriptObject(uint8 sound);                            // 
 	void ProcessMissionAudio();                                              // 
 	void ProcessMissionAudioSlot(uint8 slot);                                // 
-	void ProcessModelCarEngine(cVehicleParams *params);                      // 
+	void ProcessModelHeliVehicle(cVehicleParams& params);                    // done
+	void ProcessModelVehicle(cVehicleParams& params);                        // done
 	void ProcessOneShotScriptObject(uint8 sound);                            // 
-	void ProcessPed(CPhysical *ped);                                         // 
+	void ProcessPed(CPhysical *ped);                                         // done
 	void ProcessPedOneShots(cPedParams *params);                             // 
 	void ProcessPhysical(int32 id);                                          // done
-	void ProcessPlane(cVehicleParams *params);                               // done
+	void ProcessPlane(cVehicleParams& params);                               // done
-	void ProcessPlayersVehicleEngine(cVehicleParams *params, CVehicle* veh); // done
+	void ProcessPlayerMood();                                                // done
-	void ProcessProjectiles();                                               // 
+	void ProcessPlayersVehicleEngine(cVehicleParams& params, CVehicle* veh); // done
-	void ProcessRainOnVehicle(cVehicleParams *params);                       // 
+	void ProcessProjectiles();                                               // done
-	void ProcessReverb() const;                                              // 
+	void ProcessRainOnVehicle(cVehicleParams& params);                       // done
-	bool ProcessReverseGear(cVehicleParams *params);                         // done
+	void ProcessReverb() const;                                              // done
+	bool ProcessReverseGear(cVehicleParams& params);                         // done
 	void ProcessScriptObject(int32 id);                                      // done
-	void ProcessSpecial();
+	void ProcessSpecial();                                                   // done
 #ifdef GTA_TRAIN
-	bool ProcessTrainNoise(cVehicleParams *params);
+	bool ProcessTrainNoise(cVehicleParams *params); //done(bcs not exists in VC)
 #endif
-	void ProcessVehicle(CVehicle *vehicle); //done, but need add model functions
+	void ProcessVehicle(CVehicle *vehicle);                    // done
-	bool ProcessVehicleDoors(cVehicleParams *params); //done
+	bool ProcessVehicleDoors(cVehicleParams& params);          // done
-	void ProcessVehicleEngine(cVehicleParams *params); //done
+	void ProcessVehicleEngine(cVehicleParams& params);         // done
-	void UpdateGasPedalAudio(CVehicle* veh, int vehType); //done
+	void ProcessVehicleFlatTyre(cVehicleParams& params);                     // done
-	void ProcessVehicleHorn(cVehicleParams *params);
+	bool ProcessVehicleHorn(cVehicleParams& params);           // done
-	void ProcessVehicleOneShots(cVehicleParams *params);
+	void ProcessVehicleOneShots(cVehicleParams& params);       // done
-	bool ProcessVehicleReverseWarning(cVehicleParams *params);
+	bool ProcessVehicleReverseWarning(cVehicleParams& params); // done
-	bool ProcessVehicleRoadNoise(cVehicleParams *params);
+	bool ProcessVehicleRoadNoise(cVehicleParams& params);      // done
-	bool ProcessVehicleSirenOrAlarm(cVehicleParams *params);
+	bool ProcessVehicleSirenOrAlarm(cVehicleParams& params);   // done
-	bool ProcessVehicleSkidding(cVehicleParams *params);
+	bool ProcessVehicleSkidding(cVehicleParams& params);       // done
-	void ProcessWaterCannon(int32);
+	void ProcessWaterCannon(int32);                            // done
 	void ProcessWeather(int32 id);                             // done
-	bool ProcessWetRoadNoise(cVehicleParams *params);
+	bool ProcessWetRoadNoise(cVehicleParams& params);          // done
 	void ProcessEscalators();                                  // done
 	void ProcessExtraSounds();                                 // done
 
-	int32 RandomDisplacement(uint32 seed) const;
+	int32 RandomDisplacement(uint32 seed) const;                                                                                      // done
 	void ReacquireDigitalHandle() const;                                                                                              // done
 	void ReleaseDigitalHandle() const;                                                                                                // done
 	void ReportCollision(CEntity *entity1, CEntity *entity2, uint8 surface1, uint8 surface2, float collisionPower, float intensity2); // done
 	void ReportCrime(eCrimeType crime, const CVector &pos);                                                                           // done
-	void ResetAudioLogicTimers(uint32 timer);
+	void ResetAudioLogicTimers(uint32 timer);                                                                                         // done
-	void ResetPoliceRadio();
+	void ResetPoliceRadio();                                                                                                          // done
-	void ResetTimers(uint32 time);
+	void ResetTimers(uint32 time);                                                                                                    // done
 
-	void Service();
+	void Service(); //done
-	void ServiceCollisions();
+	void ServiceCollisions(); //done
 	void ServicePoliceRadio();
 	void ServicePoliceRadioChannel(uint8 wantedLevel);
 	void ServiceSoundEffects();
@@ -501,13 +503,14 @@ public:
 	void SetupPedComments(cPedParams *params, uint32 sound); // done
 	void SetupSuspectLastSeenReport();
 
-	void Terminate();
+	void Terminate(); //done
-	void TranslateEntity(Const CVector *v1, CVector *v2) const;
+	void TranslateEntity(Const CVector *v1, CVector *v2) const; //done
 
-	void UpdateReflections();
+	void UpdateGasPedalAudio(CVehicle* veh, int vehType);      // done
+	void UpdateReflections();                              //done
 	bool UsesReverseWarning(int32 model) const;            //done
-	bool UsesSiren(int32 model) const;
+	bool UsesSiren(cVehicleParams& params) const;          //done
-	bool UsesSirenSwitching(int32 model) const;
+	bool UsesSirenSwitching(cVehicleParams& params) const; //done
 
 	CVehicle *FindVehicleOfPlayer(); //done
 	void SetPedTalkingStatus(CPed *ped, uint8 status);

src/audio/soundlist.h

@@ -33,7 +33,7 @@ enum eSound : uint16
 	SOUND_CAR_TANK_TURRET_ROTATE,
 	SOUND_CAR_BOMB_TICK,
 	SOUND_PLANE_ON_GROUND,
-	SOUND_31,
+	SOUND_HELI_BLADE,
 	SOUND_32,
 	SOUND_STEP_START,
 	SOUND_STEP_END,

src/control/Pickups.cpp

@@ -369,7 +369,7 @@ CPickup::Update(CPlayerPed *player, CVehicle *vehicle, int playerId)
 			if (weaponType < WEAPONTYPE_TOTALWEAPONS && CDarkel::FrenzyOnGoing()) {
 				isPickupTouched = false;
 				m_bWasControlMessageShown = false;
-			} else if (weaponType != WEAPONTYPE_UNARMED) {
+			} else if (weaponType < WEAPONTYPE_TOTALWEAPONS && weaponType != WEAPONTYPE_UNARMED) {
 				uint32 slot = CWeaponInfo::GetWeaponInfo(weaponType)->m_nWeaponSlot;
 				eWeaponType plrWeaponSlot = FindPlayerPed()->GetWeapon(slot).m_eWeaponType;
 				if (plrWeaponSlot != weaponType) {
@@ -1411,6 +1411,20 @@ CPickups::DetonateMinesHitByGunShot(CVector *vec1, CVector *vec2)
 	}
 }
 
+void
+CPickups::RemoveUnnecessaryPickups(const CVector& center, float radius)
+{
+	for (int i = 0; i < NUMPICKUPS; i++) {
+		if (aPickUps[i].m_eType == PICKUP_ONCE_TIMEOUT || aPickUps[i].m_eType == PICKUP_MONEY) {
+			if (Distance(center, aPickUps[i].m_vecPos) < radius) {
+				aPickUps[i].GetRidOfObjects();
+				aPickUps[i].m_bRemoved = true;
+				aPickUps[i].m_eType = PICKUP_NONE;
+			}
+		}
+	}
+}
+
 void
 CPickups::Load(uint8 *buf, uint32 size)
 {

src/control/Pickups.h

@@ -103,6 +103,7 @@ public:
 	static bool TryToMerge_WeaponType(CVector pos, eWeaponType weapon, uint8 type, uint32 quantity, bool unused);
 	static void CreateSomeMoney(CVector, int);
 	static void DetonateMinesHitByGunShot(CVector *vec1, CVector *vec2);
+	static void RemoveUnnecessaryPickups(const CVector& center, float radius);
 	static void Load(uint8 *buf, uint32 size);
 	static void Save(uint8 *buf, uint32 *size);
 

src/control/Script.cpp

@@ -11232,7 +11232,7 @@ int8 CRunningScript::ProcessCommands1000To1099(int32 command)
 		CollectParameters(&m_nIp, 2);
 		CPed* pPed = CPools::GetPedPool()->GetAt(ScriptParams[0]);
 		script_assert(pPed);
-		pPed->bNoCriticalHits = (ScriptParams[0] == 0);
+		pPed->bNoCriticalHits = (ScriptParams[1] == 0);
 		return 0;
 	}
 	/*

src/control/Script.h

@@ -381,6 +381,7 @@ private:
 public:
 	static void RemoveThisPed(CPed* pPed);
 
+	static uint32& GetLastMissionPassedTime() { return LastMissionPassedTime; }
 #ifdef MISSION_SWITCHER
 	static void SwitchToMission(int32 mission);
 #endif

src/core/World.cpp

@@ -15,6 +15,7 @@
 #include "Object.h"
 #include "ParticleObject.h"
 #include "Ped.h"
+#include "Pickups.h"
 #include "PlayerPed.h"
 #include "Population.h"
 #include "ProjectileInfo.h"
@@ -28,6 +29,7 @@
 #include "WaterLevel.h"
 #include "World.h"
 
+// --MIAMI: file done
 
 #define OBJECT_REPOSITION_OFFSET_Z 2.0f
 
@@ -157,6 +159,7 @@ CWorld::ClearExcitingStuffFromArea(const CVector &pos, float radius, bool bRemov
 		CProjectileInfo::RemoveAllProjectiles();
 		CShadows::TidyUpShadows();
 	}
+	CPickups::RemoveUnnecessaryPickups(pos, radius);
 }
 
 bool
@@ -333,11 +336,24 @@ CWorld::ProcessLineOfSightSectorList(CPtrList &list, const CColLine &line, CColP
 {
 	bool deadPeds = false;
 	bool bikers = false;
+	bool carTyres = false;
 	float mindist = dist;
 	CPtrNode *node;
 	CEntity *e;
 	CColModel *colmodel;
+	CColModel tyreCol;
+	CColSphere tyreSpheres[6];
+	CColPoint tyreColPoint;
+	float tyreDist;
 
+	if(bIncludeCarTyres && list.first && ((CEntity*)list.first->item)->IsVehicle()){
+		carTyres = true;
+		tyreCol.numTriangles = 0;
+		tyreCol.numBoxes = 0;
+		tyreCol.numLines = 0;
+		tyreCol.spheres = tyreSpheres;
+		tyreCol.numSpheres = ARRAY_SIZE(tyreSpheres);
+	}
 	if(list.first && bIncludeDeadPeds && ((CEntity *)list.first->item)->IsPed()) deadPeds = true;
 	if(list.first && bIncludeBikers && ((CEntity *)list.first->item)->IsPed()) bikers = true;
 
@@ -346,10 +362,11 @@ CWorld::ProcessLineOfSightSectorList(CPtrList &list, const CColLine &line, CColP
 		if(e->m_scanCode != GetCurrentScanCode() && e != pIgnoreEntity && (e->bUsesCollision || deadPeds || bikers) &&
 		   !(ignoreSomeObjects && CameraToIgnoreThisObject(e))) {
 			colmodel = nil;
+			tyreDist = mindist;
 			e->m_scanCode = GetCurrentScanCode();
 
 			if(e->IsPed()) {
-				if(e->bUsesCollision || deadPeds && ((CPed *)e)->m_nPedState == PED_DEAD || bikers) {
+				if(e->bUsesCollision || deadPeds && ((CPed *)e)->m_nPedState == PED_DEAD || bikers && ((CPed*)e)->InVehicle() && (((CPed*)e)->m_pMyVehicle->IsBike() || ((CPed*)e)->m_pMyVehicle->IsBoat())) {
 					colmodel = ((CPedModelInfo *)CModelInfo::GetModelInfo(e->GetModelIndex()))->AnimatePedColModelSkinned(e->GetClump());
 				} else
 					colmodel = nil;
@@ -360,8 +377,18 @@ CWorld::ProcessLineOfSightSectorList(CPtrList &list, const CColLine &line, CColP
 			if(colmodel && CCollision::ProcessLineOfSight(line, e->GetMatrix(), *colmodel, point, dist,
 			                                              ignoreSeeThrough, ignoreShootThrough))
 				entity = e;
+			if(carTyres && ((CVehicle*)e)->SetUpWheelColModel(&tyreCol) && CCollision::ProcessLineOfSight(line, e->GetMatrix(), tyreCol, tyreColPoint, tyreDist, false, ignoreShootThrough)){
+				float dp1 = DotProduct(line.p1 - line.p0, e->GetRight());
+				float dp2 = DotProduct(point.point - e->GetPosition(), e->GetRight());
+				if(tyreDist < mindist || dp1 < -0.85f && dp2 > 0.0f || dp1 > 0.85f && dp2 < 0.0f){
+					mindist = tyreDist;
+					point = tyreColPoint;
+					entity = e;
 				}
 			}
+		}
+	}
+	tyreCol.spheres = nil;
 
 	if(mindist < dist) {
 		dist = mindist;
@@ -695,18 +722,10 @@ CWorld::FindObjectsInRange(Const CVector &centre, float radius, bool ignoreZ, in
 	if(minY <= 0) minY = 0;
 
 	int maxX = GetSectorIndexX(centre.x + radius);
-#ifdef FIX_BUGS
 	if(maxX >= NUMSECTORS_X) maxX = NUMSECTORS_X - 1;
-#else
-	if(maxX >= NUMSECTORS_X) maxX = NUMSECTORS_X;
-#endif
 
 	int maxY = GetSectorIndexY(centre.y + radius);
-#ifdef FIX_BUGS
 	if(maxY >= NUMSECTORS_Y) maxY = NUMSECTORS_Y - 1;
-#else
-	if(maxY >= NUMSECTORS_Y) maxY = NUMSECTORS_Y;
-#endif
 
 	AdvanceCurrentScanCode();
 
@@ -781,13 +800,18 @@ CWorld::FindObjectsOfTypeInRange(uint32 modelId, const CVector &position, float
 	*nEntitiesFound = 0;
 	const CVector2D vecSectorStartPos(position.x - radius, position.y - radius);
 	const CVector2D vecSectorEndPos(position.x + radius, position.y + radius);
-	const int32 nStartX = Max(CWorld::GetSectorIndexX(vecSectorStartPos.x), 0);
+	const int32 nStartX = Max(GetSectorIndexX(vecSectorStartPos.x), 0);
-	const int32 nStartY = Max(CWorld::GetSectorIndexY(vecSectorStartPos.y), 0);
+	const int32 nStartY = Max(GetSectorIndexY(vecSectorStartPos.y), 0);
-	const int32 nEndX = Min(CWorld::GetSectorIndexX(vecSectorEndPos.x), NUMSECTORS_X - 1);
+#ifdef FIX_BUGS
-	const int32 nEndY = Min(CWorld::GetSectorIndexY(vecSectorEndPos.y), NUMSECTORS_Y - 1);
+	const int32 nEndX = Min(GetSectorIndexX(vecSectorEndPos.x), NUMSECTORS_X - 1);
+	const int32 nEndY = Min(GetSectorIndexY(vecSectorEndPos.y), NUMSECTORS_Y - 1);
+#else
+	const int32 nEndX = Min(GetSectorIndexX(vecSectorEndPos.x), NUMSECTORS_X);
+	const int32 nEndY = Min(GetSectorIndexY(vecSectorEndPos.y), NUMSECTORS_Y);
+#endif
 	for(int32 y = nStartY; y <= nEndY; y++) {
 		for(int32 x = nStartX; x <= nEndX; x++) {
-			CSector *pSector = CWorld::GetSector(x, y);
+			CSector *pSector = GetSector(x, y);
 			if(bBuildings) {
 				CWorld::FindObjectsOfTypeInRangeSectorList(
 				    modelId, pSector->m_lists[ENTITYLIST_BUILDINGS], position, radius, bCheck2DOnly,
@@ -1050,13 +1074,18 @@ CWorld::FindObjectsKindaColliding(const CVector &position, float radius, bool bC
 	*nCollidingEntities = 0;
 	const CVector2D vecSectorStartPos(position.x - radius, position.y - radius);
 	const CVector2D vecSectorEndPos(position.x + radius, position.y + radius);
-	const int32 nStartX = Max(CWorld::GetSectorIndexX(vecSectorStartPos.x), 0);
+	const int32 nStartX = Max(GetSectorIndexX(vecSectorStartPos.x), 0);
-	const int32 nStartY = Max(CWorld::GetSectorIndexY(vecSectorStartPos.y), 0);
+	const int32 nStartY = Max(GetSectorIndexY(vecSectorStartPos.y), 0);
-	const int32 nEndX = Min(CWorld::GetSectorIndexX(vecSectorEndPos.x), NUMSECTORS_X - 1);
+#ifdef FIX_BUGS
-	const int32 nEndY = Min(CWorld::GetSectorIndexY(vecSectorEndPos.y), NUMSECTORS_Y - 1);
+	const int32 nEndX = Min(GetSectorIndexX(vecSectorEndPos.x), NUMSECTORS_X - 1);
+	const int32 nEndY = Min(GetSectorIndexY(vecSectorEndPos.y), NUMSECTORS_Y - 1);
+#else
+	const int32 nEndX = Min(GetSectorIndexX(vecSectorEndPos.x), NUMSECTORS_X);
+	const int32 nEndY = Min(GetSectorIndexY(vecSectorEndPos.y), NUMSECTORS_Y);
+#endif
 	for(int32 y = nStartY; y <= nEndY; y++) {
 		for(int32 x = nStartX; x <= nEndX; x++) {
-			CSector *pSector = CWorld::GetSector(x, y);
+			CSector *pSector = GetSector(x, y);
 			if(bBuildings) {
 				CWorld::FindObjectsKindaCollidingSectorList(
 				    pSector->m_lists[ENTITYLIST_BUILDINGS], position, radius, bCheck2DOnly,
@@ -1129,13 +1158,18 @@ CWorld::FindObjectsIntersectingCube(const CVector &vecStartPos, const CVector &v
 {
 	CWorld::AdvanceCurrentScanCode();
 	*nIntersecting = 0;
-	const int32 nStartX = Max(CWorld::GetSectorIndexX(vecStartPos.x), 0);
+	const int32 nStartX = Max(GetSectorIndexX(vecStartPos.x), 0);
-	const int32 nStartY = Max(CWorld::GetSectorIndexY(vecStartPos.y), 0);
+	const int32 nStartY = Max(GetSectorIndexY(vecStartPos.y), 0);
-	const int32 nEndX = Min(CWorld::GetSectorIndexX(vecEndPos.x), NUMSECTORS_X - 1);
+#ifdef FIX_BUGS
-	const int32 nEndY = Min(CWorld::GetSectorIndexY(vecEndPos.y), NUMSECTORS_Y - 1);
+	const int32 nEndX = Min(GetSectorIndexX(vecStartPos.x), NUMSECTORS_X - 1);
+	const int32 nEndY = Min(GetSectorIndexY(vecStartPos.y), NUMSECTORS_Y - 1);
+#else
+	const int32 nEndX = Min(GetSectorIndexX(vecSectorPos.x), NUMSECTORS_X);
+	const int32 nEndY = Min(GetSectorIndexY(vecSectorPos.y), NUMSECTORS_Y);
+#endif
 	for(int32 y = nStartY; y <= nEndY; y++) {
 		for(int32 x = nStartX; x <= nEndX; x++) {
-			CSector *pSector = CWorld::GetSector(x, y);
+			CSector *pSector = GetSector(x, y);
 			if(bBuildings) {
 				CWorld::FindObjectsIntersectingCubeSectorList(pSector->m_lists[ENTITYLIST_BUILDINGS],
 				                                              vecStartPos, vecEndPos, nIntersecting,
@@ -1210,13 +1244,18 @@ CWorld::FindObjectsIntersectingAngledCollisionBox(const CBox &boundingBox, const
 {
 	CWorld::AdvanceCurrentScanCode();
 	*nEntitiesFound = 0;
-	const int32 nStartX = Max(CWorld::GetSectorIndexX(fStartX), 0);
+	const int32 nStartX = Max(GetSectorIndexX(fStartX), 0);
-	const int32 nStartY = Max(CWorld::GetSectorIndexY(fStartY), 0);
+	const int32 nStartY = Max(GetSectorIndexY(fStartY), 0);
-	const int32 nEndX = Min(CWorld::GetSectorIndexX(fEndX), NUMSECTORS_X - 1);
+#ifdef FIX_BUGS
-	const int32 nEndY = Min(CWorld::GetSectorIndexY(fEndY), NUMSECTORS_Y - 1);
+	const int32 nEndX = Min(GetSectorIndexX(fEndX), NUMSECTORS_X - 1);
+	const int32 nEndY = Min(GetSectorIndexY(fEndY), NUMSECTORS_Y - 1);
+#else
+	const int32 nEndX = Min(GetSectorIndexX(fEndX), NUMSECTORS_X);
+	const int32 nEndY = Min(GetSectorIndexY(fEndY), NUMSECTORS_Y);
+#endif
 	for(int32 y = nStartY; y <= nEndY; y++) {
 		for(int32 x = nStartX; x <= nEndX; x++) {
-			CSector *pSector = CWorld::GetSector(x, y);
+			CSector *pSector = GetSector(x, y);
 			if(bBuildings) {
 				CWorld::FindObjectsIntersectingAngledCollisionBoxSectorList(
 				    pSector->m_lists[ENTITYLIST_BUILDINGS], boundingBox, matrix, position,
@@ -1290,13 +1329,18 @@ CWorld::FindMissionEntitiesIntersectingCube(const CVector &vecStartPos, const CV
 {
 	CWorld::AdvanceCurrentScanCode();
 	*nIntersecting = 0;
-	const int32 nStartX = Max(CWorld::GetSectorIndexX(vecStartPos.x), 0);
+	const int32 nStartX = Max(GetSectorIndexX(vecStartPos.x), 0);
-	const int32 nStartY = Max(CWorld::GetSectorIndexY(vecStartPos.y), 0);
+	const int32 nStartY = Max(GetSectorIndexY(vecStartPos.y), 0);
-	const int32 nEndX = Min(CWorld::GetSectorIndexX(vecEndPos.x), NUMSECTORS_X - 1);
+#ifdef FIX_BUGS
-	const int32 nEndY = Min(CWorld::GetSectorIndexY(vecEndPos.y), NUMSECTORS_Y - 1);
+	const int32 nEndX = Min(GetSectorIndexX(vecEndPos.x), NUMSECTORS_X - 1);
+	const int32 nEndY = Min(GetSectorIndexY(vecEndPos.y), NUMSECTORS_Y - 1);
+#else
+	const int32 nEndX = Min(GetSectorIndexX(vecEndPos.x), NUMSECTORS_X);
+	const int32 nEndY = Min(GetSectorIndexY(vecEndPos.y), NUMSECTORS_Y);
+#endif
 	for(int32 y = nStartY; y <= nEndY; y++) {
 		for(int32 x = nStartX; x <= nEndX; x++) {
-			CSector *pSector = CWorld::GetSector(x, y);
+			CSector *pSector = GetSector(x, y);
 			if(bVehicles) {
 				CWorld::FindMissionEntitiesIntersectingCubeSectorList(
 				    pSector->m_lists[ENTITYLIST_VEHICLES], vecStartPos, vecEndPos, nIntersecting,
@@ -1504,13 +1548,18 @@ CWorld::CallOffChaseForArea(float x1, float y1, float x2, float y2)
 	float fStartY = y1 - 10.0f;
 	float fEndX = x2 + 10.0f;
 	float fEndY = y2 + 10.0f;
-	const int32 nStartX = Max(CWorld::GetSectorIndexX(fStartX), 0);
+	const int32 nStartX = Max(GetSectorIndexX(fStartX), 0);
-	const int32 nStartY = Max(CWorld::GetSectorIndexY(fStartY), 0);
+	const int32 nStartY = Max(GetSectorIndexY(fStartY), 0);
-	const int32 nEndX = Min(CWorld::GetSectorIndexX(fEndX), NUMSECTORS_X - 1);
+#ifdef FIX_BUGS
-	const int32 nEndY = Min(CWorld::GetSectorIndexY(fEndY), NUMSECTORS_Y - 1);
+	const int32 nEndX = Min(GetSectorIndexX(fEndX), NUMSECTORS_X - 1);
+	const int32 nEndY = Min(GetSectorIndexY(fEndY), NUMSECTORS_Y - 1);
+#else
+	const int32 nEndX = Min(GetSectorIndexX(fEndX), NUMSECTORS_X);
+	const int32 nEndY = Min(GetSectorIndexY(fEndY), NUMSECTORS_Y);
+#endif
 	for(int32 y = nStartY; y <= nEndY; y++) {
 		for(int32 x = nStartX; x <= nEndX; x++) {
-			CSector *pSector = CWorld::GetSector(x, y);
+			CSector *pSector = GetSector(x, y);
 			CWorld::CallOffChaseForAreaSectorListVehicles(pSector->m_lists[ENTITYLIST_VEHICLES], x1, y1, x2,
 			                                              y2, fStartX, fStartY, fEndX, fEndY);
 			CWorld::CallOffChaseForAreaSectorListVehicles(pSector->m_lists[ENTITYLIST_VEHICLES_OVERLAP], x1,
@@ -1638,7 +1687,7 @@ CWorld::RemoveFallenCars(void)
 		CVehicle *veh = CPools::GetVehiclePool()->GetSlot(poolIndex);
 		if(veh) {
 			if(veh->GetPosition().z < MAP_Z_LOW_LIMIT) {
-				if(veh->VehicleCreatedBy == MISSION_VEHICLE || veh == FindPlayerVehicle() ||
+				if(veh->VehicleCreatedBy == MISSION_VEHICLE && !veh->bRenderScorched || veh == FindPlayerVehicle() ||
 				   (veh->pDriver && veh->pDriver->IsPlayer())) {
 					int closestNode = ThePaths.FindNodeClosestToCoors(veh->GetPosition(), PATH_CAR,
 					                                                  999999.9f, false, false);
@@ -1829,8 +1878,7 @@ CWorld::RepositionOneObject(CEntity *pEntity)
 		modelId == MI_DUMP1 || modelId == MI_ROADWORKBARRIER1 || modelId == MI_BUSSIGN1 || modelId == MI_NOPARKINGSIGN1 ||
 		modelId == MI_PHONESIGN || modelId == MI_FIRE_HYDRANT || modelId == MI_BOLLARDLIGHT ||
 		modelId == MI_PARKTABLE || modelId == MI_PARKINGMETER2 || modelId == MI_TELPOLE02 ||
-	    modelId == MI_PARKBENCH || modelId == MI_BARRIER1 || IsTreeModel(modelId) ||
+		modelId == MI_PARKBENCH || modelId == MI_BARRIER1 || IsTreeModel(modelId)
-		IsLightThatNeedsRepositioning(modelId)
 		) {
 		CVector& position = pEntity->GetMatrix().GetPosition();
 		CColModel* pColModel = pEntity->GetColModel();
@@ -1842,20 +1890,39 @@ CWorld::RepositionOneObject(CEntity *pEntity)
 			fBoundingBoxMinZ;
 		pEntity->m_matrix.UpdateRW();
 		pEntity->UpdateRwFrame();
-	} else if(modelId == MI_BUOY) {
+	} else if(IsLightThatNeedsRepositioning(modelId)) {
-		float fWaterLevel = 0.0f;
+		CVector position = pEntity->GetMatrix().GetPosition();
+		CColModel* pColModel = pEntity->GetColModel();
+		float fBoundingBoxMinZ = pColModel->boundingBox.min.z;
+		float fHeight = pColModel->boundingBox.max.z - pColModel->boundingBox.min.z;
+		if (fHeight < OBJECT_REPOSITION_OFFSET_Z) fHeight = OBJECT_REPOSITION_OFFSET_Z;
+		if (pColModel->numBoxes == 1)
+			position = pEntity->GetMatrix() * CVector(
+				(pColModel->boxes[0].min.x + pColModel->boxes[0].max.x) / 2,
+				(pColModel->boxes[0].min.y + pColModel->boxes[0].max.y) / 2,
+				pColModel->boxes[0].min.z);
+		else if (pColModel->numSpheres > 0) {
+			position.z = 1000.0f;
+			for (int i = 0; i < pColModel->numSpheres; i++) {
+				if (pColModel->spheres[i].center.z < position.z)
+					position = pColModel->spheres[i].center;
+			}
+			if (position.z < 1000.0f)
+				position = pEntity->GetMatrix() * position;
+		}
+		pEntity->GetMatrix().GetPosition().z = FindGroundZFor3DCoord(position.x, position.y, pEntity->GetMatrix().GetPosition().z + fHeight, nil) - fBoundingBoxMinZ;
+		pEntity->GetMatrix().UpdateRW();
+		pEntity->UpdateRwFrame();
+		
+	}
+	if(modelId == MI_BUOY) {
 		bool bFound = true;
 		const CVector &position = pEntity->GetPosition();
 		float fGroundZ = CWorld::FindGroundZFor3DCoord(position.x, position.y,
 		                                               position.z + OBJECT_REPOSITION_OFFSET_Z, &bFound);
-		if(CWaterLevel::GetWaterLevelNoWaves(position.x, position.y, position.z + OBJECT_REPOSITION_OFFSET_Z,
-		                                     &fWaterLevel)) {
-			if(!bFound || fWaterLevel > fGroundZ) {
 		CColModel *pColModel = pEntity->GetColModel();
 		float fHeight = pColModel->boundingBox.max.z - pColModel->boundingBox.min.z;
-				pEntity->GetMatrix().GetPosition().z = 0.2f * fHeight + fWaterLevel - 0.5f * fHeight;
+		pEntity->GetMatrix().GetPosition().z = 0.2f * fHeight + 6.0f - 0.5f * fHeight;
-			}
-		}
 	}
 }
 
@@ -1873,6 +1940,28 @@ CWorld::SetCarsOnFire(float x, float y, float z, float radius, CEntity *reason)
 	}
 }
 
+void
+CWorld::SetPedsChoking(float x, float y, float z, float radius, CEntity* reason)
+{
+	int32 poolSize = CPools::GetPedPool()->GetSize();
+	for (int32 i = poolSize - 1; i >= 0; i--) {
+		CPed* pPed = CPools::GetPedPool()->GetSlot(i);
+		// suspicious copypaste
+		if (pPed && pPed->m_nPedState != PED_DEAD && !pPed->bInVehicle && !pPed->m_pFire && !pPed->bFireProof && pPed->CharCreatedBy != MISSION_CHAR) {
+			if (Abs(pPed->GetPosition().z - z) < 5.0f && Abs(pPed->GetPosition().x - x) < radius &&
+				Abs(pPed->GetPosition().y - y) < radius) {
+				if (!pPed->IsPlayer())
+					pPed->SetFlee(CVector2D(x, y), 10000);
+#ifdef FIX_BUGS
+				pPed->InflictDamage(reason, WEAPONTYPE_TEARGAS, 1.0f, PEDPIECE_TORSO, 0);
+#else
+				pPed->InflictDamage(nil, WEAPONTYPE_TEARGAS, 1.0f, PEDPIECE_TORSO, 0);
+#endif
+			}
+		}
+	}
+}
+
 void
 CWorld::SetPedsOnFire(float x, float y, float z, float radius, CEntity *reason)
 {
@@ -1925,11 +2014,12 @@ CWorld::Process(void)
 			if(csObj && csObj->m_entryInfoList.first) {
 				if(csObj->m_rwObject && RwObjectGetType(csObj->m_rwObject) == rpCLUMP &&
 				   RpAnimBlendClumpGetFirstAssociation(csObj->GetClump())) {
-// TODO(MIAMI): doRender argument
+					if (csObj->IsObject())
-					RpAnimBlendClumpUpdateAnimations(csObj->GetClump(),
+						RpAnimBlendClumpUpdateAnimations(csObj->GetClump(), 0.02f * CTimer::GetTimeStepNonClipped());
-					                                 0.02f * (csObj->IsObject()
+					else {
-					                                              ? CTimer::GetTimeStepNonClipped()
+						csObj->bOffscreen = !csObj->GetIsOnScreen();
-					                                              : CTimer::GetTimeStep()));
+						RpAnimBlendClumpUpdateAnimations(csObj->GetClump(), 0.02f * CTimer::GetTimeStep(), !csObj->bOffscreen);
+					}
 				}
 				csObj->ProcessControl();
 				csObj->ProcessCollision();
@@ -1949,11 +2039,12 @@ CWorld::Process(void)
 #endif
 			if(movingEnt->m_rwObject && RwObjectGetType(movingEnt->m_rwObject) == rpCLUMP &&
 			   RpAnimBlendClumpGetFirstAssociation(movingEnt->GetClump())) {
-// TODO(MIAMI): doRender argument
+				if (movingEnt->IsObject())
-				RpAnimBlendClumpUpdateAnimations(movingEnt->GetClump(),
+					RpAnimBlendClumpUpdateAnimations(movingEnt->GetClump(), 0.02f * CTimer::GetTimeStepNonClipped());
-				                                 0.02f * (movingEnt->IsObject()
+				else {
-				                                              ? CTimer::GetTimeStepNonClipped()
+					movingEnt->bOffscreen = !movingEnt->GetIsOnScreen();
-				                                              : CTimer::GetTimeStep()));
+					RpAnimBlendClumpUpdateAnimations(movingEnt->GetClump(), 0.02f * CTimer::GetTimeStep(), !movingEnt->bOffscreen);
+				}
 			}
 		}
 		for(CPtrNode *node = ms_listMovingEntityPtrs.first; node; node = node->next) {
@@ -2037,7 +2128,7 @@ CWorld::Process(void)
 						movingEnt->bIsStuck = true;
 						if(movingEnt->GetStatus() == STATUS_PLAYER) {
 							printf("STUCK: Final Step: Player Entity %d Is Stuck\n", movingEnt->GetModelIndex());
-							movingEnt->m_vecMoveSpeed *= 0.3f;
+							movingEnt->m_vecMoveSpeed *= Pow(0.707f, CTimer::GetTimeStep());
 							movingEnt->ApplyMoveSpeed();
 							movingEnt->ApplyTurnSpeed();
 						}
@@ -2102,13 +2193,13 @@ CWorld::TriggerExplosion(const CVector &position, float fRadius, float fPower, C
 {
 	CVector2D vecStartPos(position.x - fRadius, position.y - fRadius);
 	CVector2D vecEndPos(position.x + fRadius, position.y + fRadius);
-	const int32 nStartX = Max(CWorld::GetSectorIndexX(vecStartPos.x), 0);
+	const int32 nStartX = Max(GetSectorIndexX(vecStartPos.x), 0);
-	const int32 nStartY = Max(CWorld::GetSectorIndexY(vecStartPos.y), 0);
+	const int32 nStartY = Max(GetSectorIndexY(vecStartPos.y), 0);
-	const int32 nEndX = Min(CWorld::GetSectorIndexX(vecEndPos.x), NUMSECTORS_X - 1);
+	const int32 nEndX = Min(GetSectorIndexX(vecEndPos.x), NUMSECTORS_X - 1);
-	const int32 nEndY = Min(CWorld::GetSectorIndexY(vecEndPos.y), NUMSECTORS_Y - 1);
+	const int32 nEndY = Min(GetSectorIndexY(vecEndPos.y), NUMSECTORS_Y - 1);
 	for(int32 y = nStartY; y <= nEndY; y++) {
 		for(int32 x = nStartX; x <= nEndX; x++) {
-			CSector *pSector = CWorld::GetSector(x, y);
+			CSector *pSector = GetSector(x, y);
 			CWorld::TriggerExplosionSectorList(pSector->m_lists[ENTITYLIST_VEHICLES], position, fRadius,
 			                                   fPower, pCreator, bProcessVehicleBombTimer);
 			CWorld::TriggerExplosionSectorList(pSector->m_lists[ENTITYLIST_PEDS], position, fRadius, fPower,
@@ -2146,7 +2237,7 @@ CWorld::TriggerExplosionSectorList(CPtrList &list, const CVector &position, floa
 								   pObject->bHasBeenDamaged) {
 									if(pEntity->IsObject() &&
 									   modelId != MI_EXPLODINGBARREL &&
-									   modelId != MI_PETROLPUMP)
+									   modelId != MI_PETROLPUMP && modelId != MI_PETROLPUMP2)
 										pObject->bHasBeenDamaged = true;
 								} else {
 									CVector pos = pEntity->GetPosition();
@@ -2171,7 +2262,7 @@ CWorld::TriggerExplosionSectorList(CPtrList &list, const CVector &position, floa
 				if(!pEntity->GetIsStatic()) {
 					float fDamageMultiplier = Min((fRadius - fMagnitude) * 2.0f / fRadius, 1.0f);
 					CVector vecForceDir =
-					    vecDistance * (fPower * pEntity->m_fMass * 0.00071429f * fDamageMultiplier /
+					    vecDistance * (fPower * pEntity->m_fMass / 14000.0f * fDamageMultiplier /
 					                   Max(fMagnitude, 0.01f));
 					vecForceDir.z = Max(vecForceDir.z, 0.0f);
 					if(pEntity == FindPlayerPed()) vecForceDir.z = Min(vecForceDir.z, 1.0f);

src/core/World.h

@@ -77,7 +77,7 @@ public:
 	static void Remove(CEntity *entity);
 	static void Add(CEntity *entity);
 
-	static CSector *GetSector(int x, int y) { return &ms_aSectors[y][x]; }
+	static CSector *GetSector(int x, int y) { if (x > NUMSECTORS_X - 1 || y > NUMSECTORS_Y - 1) return &ms_aSectors[0][0]; return &ms_aSectors[y][x]; }
 	static CPtrList &GetBigBuildingList(eLevelName i) { return ms_bigBuildingsList[i]; }
 	static CPtrList &GetMovingEntityList(void) { return ms_listMovingEntityPtrs; }
 	static uint16 GetCurrentScanCode(void) { return ms_nCurrentScanCode; }
@@ -144,6 +144,7 @@ public:
 	static void SetAllCarsCanBeDamaged(bool);
 	static void ExtinguishAllCarFiresInArea(CVector, float);
 	static void SetCarsOnFire(float x, float y, float z, float radius, CEntity* reason);
+	static void SetPedsChoking(float x, float y, float z, float radius, CEntity* reason);
 	static void SetPedsOnFire(float x, float y, float z, float radius, CEntity* reason);
 
 	static void Initialise();
@@ -157,6 +158,23 @@ public:
 	static void TriggerExplosion(const CVector& position, float fRadius, float fPower, CEntity* pCreator, bool bProcessVehicleBombTimer);
 	static void TriggerExplosionSectorList(CPtrList& list, const CVector& position, float fRadius, float fPower, CEntity* pCreator, bool bProcessVehicleBombTimer);
 	static void UseDetonator(CEntity *pEntity);
+
+	// NB: following functions are unused (TODO?)
+	static void CastShadow(float, float, float, float);
+	static void CastShadowSectorList(CPtrList&, float, float, float, float);
+	static void FindLowestZForCoord(float, float);
+	static void CheckBlockListIntegrity(void);
+	static void ProcessVerticalLineSectorList_FillGlobeColPoints(CPtrList&, const CColLine&, CEntity*&, bool, CStoredCollPoly*);
+	static void ProcessVerticalLineSector_FillGlobeColPoints(CSector&, const CColLine&, CEntity*&, bool, bool, bool, bool, bool, bool, CStoredCollPoly*);
+	static void ProcessVerticalLine_FillGlobeColPoints(const CVector&, float, CEntity*&, bool, bool, bool, bool, bool, bool, CStoredCollPoly*);
+	static void PrintCarChanges(void);
+	static void TestForBuildingsOnTopOfEachOther(CPtrList&);
+	static void TestForBuildingsOnTopOfEachOther(void);
+	static void TestForUnusedModels(CPtrList&, int*);
+	static void TestForUnusedModels(void);
+	static void HandleCollisionZoneChange(eLevelName, eLevelName);
+	static void DoZoneTestForChaser(class CPhysical*);
+	static void FindPlayerSlotWithPedPointer(void*);
 };
 
 extern CColPoint gaTempSphereColPoints[MAX_COLLISION_POINTS];

src/core/Zones.cpp

@@ -532,14 +532,14 @@ CTheZones::SetZonePedInfo(uint16 zoneid, uint8 day, int16 pedDensity,
 	info->gangPedThreshold[8] = gang8Density;
 
 	info->gangPedThreshold[0] += info->copPedThreshold;
-	info->gangPedThreshold[1] = info->gangPedThreshold[0];
+	info->gangPedThreshold[1] += info->gangPedThreshold[0];
-	info->gangPedThreshold[2] = info->gangPedThreshold[1];
+	info->gangPedThreshold[2] += info->gangPedThreshold[1];
-	info->gangPedThreshold[3] = info->gangPedThreshold[2];
+	info->gangPedThreshold[3] += info->gangPedThreshold[2];
-	info->gangPedThreshold[4] = info->gangPedThreshold[3];
+	info->gangPedThreshold[4] += info->gangPedThreshold[3];
-	info->gangPedThreshold[5] = info->gangPedThreshold[4];
+	info->gangPedThreshold[5] += info->gangPedThreshold[4];
-	info->gangPedThreshold[6] = info->gangPedThreshold[5];
+	info->gangPedThreshold[6] += info->gangPedThreshold[5];
-	info->gangPedThreshold[7] = info->gangPedThreshold[6];
+	info->gangPedThreshold[7] += info->gangPedThreshold[6];
-	info->gangPedThreshold[8] = info->gangPedThreshold[7];
+	info->gangPedThreshold[8] += info->gangPedThreshold[7];
 }
 
 //--MIAMI: unused

src/core/config.h

@@ -246,6 +246,7 @@ enum Config {
 #ifdef LIBRW
 //#define EXTENDED_COLOURFILTER		// more options for colour filter (replaces mblur)
 //#define EXTENDED_PIPELINES		// custom render pipelines (includes Neo)
+//#define NEW_RENDERER		// leeds-like world rendering, needs librw
 #endif
 //#define MULTISAMPLING		// adds MSAA option TODO
 

src/core/main.cpp

@@ -107,6 +107,13 @@ void TheGame(void);
 void DebugMenuPopulate(void);
 #endif
 
+#ifdef NEW_RENDERER
+bool gbNewRenderer;
+#define CLEARMODE (rwCAMERACLEARZ | rwCAMERACLEARSTENCIL)
+#else
+#define CLEARMODE (rwCAMERACLEARZ)
+#endif
+
 void
 ValidateVersion()
 {
@@ -151,7 +158,7 @@ DoRWStuffStartOfFrame(int16 TopRed, int16 TopGreen, int16 TopBlue, int16 BottomR
 	CDraw::CalculateAspectRatio();
 	CameraSize(Scene.camera, nil, SCREEN_VIEWWINDOW, SCREEN_ASPECT_RATIO);
 	CVisibilityPlugins::SetRenderWareCamera(Scene.camera);
-	RwCameraClear(Scene.camera, &TopColor.rwRGBA, rwCAMERACLEARZ);
+	RwCameraClear(Scene.camera, &TopColor.rwRGBA, CLEARMODE);
 
 	if(!RsCameraBeginUpdate(Scene.camera))
 		return false;
@@ -170,7 +177,7 @@ DoRWStuffStartOfFrame_Horizon(int16 TopRed, int16 TopGreen, int16 TopBlue, int16
 	CDraw::CalculateAspectRatio();
 	CameraSize(Scene.camera, nil, SCREEN_VIEWWINDOW, SCREEN_ASPECT_RATIO);
 	CVisibilityPlugins::SetRenderWareCamera(Scene.camera);
-	RwCameraClear(Scene.camera, &gColourTop, rwCAMERACLEARZ);
+	RwCameraClear(Scene.camera, &gColourTop, CLEARMODE);
 
 	if(!RsCameraBeginUpdate(Scene.camera))
 		return false;
@@ -849,9 +856,130 @@ DisplayGameDebugText()
 }
 #endif
 
+#ifdef NEW_RENDERER
+bool gbRenderRoads = true;
+bool gbRenderEverythingBarRoads = true;
+bool gbRenderFadingInUnderwaterEntities = true;
+bool gbRenderFadingInEntities = true;
+bool gbRenderWater = true;
+bool gbRenderBoats = true;
+bool gbRenderVehicles = true;
+bool gbRenderWorld0 = true;
+bool gbRenderWorld1 = true;
+bool gbRenderWorld2 = true;
+
+void
+MattRenderScene(void)
+{
+	// this calls CMattRenderer::Render
+	CWorld::AdvanceCurrentScanCode();
+	// CMattRenderer::ResetRenderStates
+	CRenderer::ClearForFrame();
+	// CClock::CalcEnvMapTimeMultiplicator
+	CWaterLevel::RenderWater();	// actually CMattRenderer::RenderWater
+	// CClock::ms_EnvMapTimeMultiplicator = 1.0f;
+	// cWorldStream::ClearDynamics
+	CRenderer::ConstructRenderList();
+if(gbRenderWorld0)
+	CRenderer::RenderWorld(0);	// roads
+	// CMattRenderer::ResetRenderStates
+	CRenderer::PreRender();
+	CCoronas::RenderReflections();
+if(gbRenderWorld1)
+	CRenderer::RenderWorld(1);	// opaque
+if(gbRenderRoads)
+	CRenderer::RenderRoads();
+
+	CRenderer::RenderPeds();
+
+	// not sure where to put these since LCS has no underwater entities
+if(gbRenderBoats)
+	CRenderer::RenderBoats();
+if(gbRenderFadingInUnderwaterEntities)
+	CRenderer::RenderFadingInUnderwaterEntities();
+if(gbRenderWater)
+	CRenderer::RenderTransparentWater();
+
+if(gbRenderEverythingBarRoads)
+	CRenderer::RenderEverythingBarRoads();
+	// get env map here?
+	// moved this:
+	// CRenderer::RenderFadingInEntities();
+}
+
+void
+RenderScene_new(void)
+{
+	CClouds::Render();
+	DoRWRenderHorizon();
+
+	MattRenderScene();
+	DefinedState();
+	// CMattRenderer::ResetRenderStates
+	// moved CRenderer::RenderBoats to before transparent water
+}
+
+// TODO
+bool FredIsInFirstPersonCam(void) { return true; }	// this seems to give the best result in all cases
+
+void
+RenderEffects_new(void)
+{
+	CShadows::RenderStaticShadows();
+	// CRenderer::GenerateEnvironmentMap
+	CShadows::RenderStoredShadows();
+	CSkidmarks::Render();
+	CRubbish::Render();
+
+	// these aren't really effects
+	DefinedState();
+	if(FredIsInFirstPersonCam()){
+		DefinedState();
+		C3dMarkers::Render();	// normally rendered in CSpecialFX::Render()
+if(gbRenderWorld2)
+		CRenderer::RenderWorld(2);	// transparent
+if(gbRenderVehicles)
+		CRenderer::RenderVehicles();
+	}else{
+if(gbRenderVehicles)
+		CRenderer::RenderVehicles();
+if(gbRenderWorld2)
+		CRenderer::RenderWorld(2);	// transparent
+	}
+	// better render these after transparent world
+if(gbRenderFadingInEntities)
+	CRenderer::RenderFadingInEntities();
+
+	// actual effects here
+	CGlass::Render();
+	// CMattRenderer::ResetRenderStates
+	DefinedState();
+	CCoronas::RenderSunReflection();
+	CWeather::RenderRainStreaks();
+	// CWeather::AddSnow
+	CWaterCannons::Render();
+	CAntennas::Render();
+	CSpecialFX::Render();
+	CRopes::Render();
+	CCoronas::Render();
+	CParticle::Render();
+	CPacManPickups::Render();
+	CWeaponEffects::Render();
+	CPointLights::RenderFogEffect();
+	CMovingThings::Render();
+	CRenderer::RenderFirstPersonVehicle();
+}
+#endif
+
 void
 RenderScene(void)
 {
+#ifdef NEW_RENDERER
+	if(gbNewRenderer){
+		RenderScene_new();
+		return;
+	}
+#endif
 	CClouds::Render();
 	DoRWRenderHorizon();
 	CRenderer::RenderRoads();
@@ -885,6 +1013,12 @@ RenderDebugShit(void)
 void
 RenderEffects(void)
 {
+#ifdef NEW_RENDERER
+	if(gbNewRenderer){
+		RenderEffects_new();
+		return;
+	}
+#endif
 	CGlass::Render();
 	CWaterCannons::Render();
 	CSpecialFX::Render();
@@ -1061,6 +1195,10 @@ Idle(void *arg)
 			pos.y = SCREEN_HEIGHT / 2.0f;
 			RsMouseSetPos(&pos);
 #endif
+#ifdef NEW_RENDERER
+	if(!gbNewRenderer)
+#endif
+{
 		tbStartTimer(0, "CnstrRenderList");
 #ifdef PC_WATER
 		CWaterLevel::PreCalcWaterGeometry();
@@ -1071,6 +1209,7 @@ Idle(void *arg)
 		tbStartTimer(0, "PreRender");
 		CRenderer::PreRender();
 		tbEndTimer("PreRender");
+}
 
 #ifdef FIX_BUGS
 		RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void *)FALSE); // TODO: temp? this fixes OpenGL render but there should be a better place for this
@@ -1125,7 +1264,7 @@ Idle(void *arg)
 		CameraSize(Scene.camera, nil, SCREEN_VIEWWINDOW, DEFAULT_ASPECT_RATIO);
 #endif
 		CVisibilityPlugins::SetRenderWareCamera(Scene.camera);
-		RwCameraClear(Scene.camera, &gColourTop, rwCAMERACLEARZ);
+		RwCameraClear(Scene.camera, &gColourTop, CLEARMODE);
 		if(!RsCameraBeginUpdate(Scene.camera))
 			return;
 	}
@@ -1174,7 +1313,7 @@ FrontendIdle(void)
 
 	CameraSize(Scene.camera, nil, SCREEN_VIEWWINDOW, SCREEN_ASPECT_RATIO);
 	CVisibilityPlugins::SetRenderWareCamera(Scene.camera);
-	RwCameraClear(Scene.camera, &gColourTop, rwCAMERACLEARZ);
+	RwCameraClear(Scene.camera, &gColourTop, CLEARMODE);
 	if(!RsCameraBeginUpdate(Scene.camera))
 		return;
 
@@ -1450,7 +1589,7 @@ void TheGame(void)
 			{
 				CameraSize(Scene.camera, NULL, SCREEN_VIEWWINDOW, SCREEN_ASPECT_RATIO);
 				CVisibilityPlugins::SetRenderWareCamera(Scene.camera);
-				RwCameraClear(Scene.camera, &gColourTop, rwCAMERACLEARZ);
+				RwCameraClear(Scene.camera, &gColourTop, CLEARMODE);
 				if (!RsCameraBeginUpdate(Scene.camera))
 					break;
 			}

src/core/main.h

@@ -38,3 +38,8 @@ void ResetLoadingScreenBar(void);
 #ifndef MASTER
 void TheModelViewer(void);
 #endif
+
+#ifdef NEW_RENDERER
+extern bool gbNewRenderer;
+bool FredIsInFirstPersonCam(void);
+#endif

src/core/re3.cpp

@@ -422,6 +422,30 @@ DebugMenuPopulate(void)
 		DebugMenuAddVarBool8("Render", "Frame limiter", &FrontEndMenuManager.m_PrefsFrameLimiter, nil);
 		DebugMenuAddVarBool8("Render", "VSynch", &FrontEndMenuManager.m_PrefsVsync, nil);
 		DebugMenuAddVar("Render", "Max FPS", &RsGlobal.maxFPS, nil, 1, 1, 1000, nil);
+#ifdef NEW_RENDERER
+		DebugMenuAddVarBool8("Render", "new renderer", &gbNewRenderer, nil);
+extern bool gbRenderRoads;
+extern bool gbRenderEverythingBarRoads;
+extern bool gbRenderFadingInUnderwaterEntities;
+extern bool gbRenderFadingInEntities;
+extern bool gbRenderWater;
+extern bool gbRenderBoats;
+extern bool gbRenderVehicles;
+extern bool gbRenderWorld0;
+extern bool gbRenderWorld1;
+extern bool gbRenderWorld2;
+		DebugMenuAddVarBool8("Render", "gbRenderRoads", &gbRenderRoads, nil);
+		DebugMenuAddVarBool8("Render", "gbRenderEverythingBarRoads", &gbRenderEverythingBarRoads, nil);
+		DebugMenuAddVarBool8("Render", "gbRenderFadingInUnderwaterEntities", &gbRenderFadingInUnderwaterEntities, nil);
+		DebugMenuAddVarBool8("Render", "gbRenderFadingInEntities", &gbRenderFadingInEntities, nil);
+		DebugMenuAddVarBool8("Render", "gbRenderWater", &gbRenderWater, nil);
+		DebugMenuAddVarBool8("Render", "gbRenderBoats", &gbRenderBoats, nil);
+		DebugMenuAddVarBool8("Render", "gbRenderVehicles", &gbRenderVehicles, nil);
+		DebugMenuAddVarBool8("Render", "gbRenderWorld0", &gbRenderWorld0, nil);
+		DebugMenuAddVarBool8("Render", "gbRenderWorld1", &gbRenderWorld1, nil);
+		DebugMenuAddVarBool8("Render", "gbRenderWorld2", &gbRenderWorld2, nil);
+#endif
+
 #ifdef EXTENDED_COLOURFILTER
 		static const char *filternames[] = { "None", "Simple", "Normal", "Mobile" };
 		e = DebugMenuAddVar("Render", "Colourfilter", &CPostFX::EffectSwitch, nil, 1, CPostFX::POSTFX_OFF, CPostFX::POSTFX_MOBILE, filternames);

src/fakerw/fake.cpp

@@ -294,32 +294,13 @@ RwTextureAddressMode RwTextureGetAddressingV(const RwTexture *texture);
 // TODO
 void _rwD3D8TexDictionaryEnableRasterFormatConversion(bool enable) { }
 
-static rw::Raster*
-ConvertTexRaster(rw::Raster *ras)
-{
-	using namespace rw;
-
-	if(ras->platform == rw::platform)
-		return ras;
-	// compatible platforms
-	if(ras->platform == PLATFORM_D3D8 && rw::platform == PLATFORM_D3D9 ||
-	   ras->platform == PLATFORM_D3D9 && rw::platform == PLATFORM_D3D8)
-		return ras;
-
-	Image *img = ras->toImage();
-	ras->destroy();
-	img->unpalettize();
-	ras = Raster::createFromImage(img);
-	img->destroy();
-	return ras;
-}
 
 // hack for reading native textures
 RwBool rwNativeTextureHackRead(RwStream *stream, RwTexture **tex, RwInt32 size)
 {
 	*tex = Texture::streamReadNative(stream);
 #ifdef LIBRW
-	(*tex)->raster = ConvertTexRaster((*tex)->raster);
+	(*tex)->raster = rw::Raster::convertTexToCurrentPlatform((*tex)->raster);
 #endif
 	return *tex != nil;
 }
@@ -796,6 +777,9 @@ RwBool       RpWorldPluginAttach(void) {
 	registerNativeDataPlugin();
 	registerAtomicRightsPlugin();
 	registerMaterialRightsPlugin();
+
+	// not sure if this goes here
+	rw::xbox::registerVertexFormatPlugin();
 	return true;
 }
 

src/objects/Object.cpp

@@ -38,7 +38,7 @@ CObject::CObject(void)
 	m_colour2 = 0;
 	m_colour1 = m_colour2;
 	m_nBonusValue = 0;
-	// m_nCostValue = 0; // TODO(Miami)
+	m_nCostValue = 0;
 	bIsPickup = false;
 	bPickupObjWithMessage = false;
 	bOutOfStock = false;
@@ -444,7 +444,7 @@ CObject::Init(void)
 	m_colour2 = 0;
 	m_nBonusValue = 0;
 	bIsWeapon = false;
-// TODO(MIAMI): some new field here
+	m_nCostValue = 0;
 	m_pCollidingEntity = nil;
 	CColPoint point;
 	CEntity* outEntity = nil;

src/render/Glass.cpp

@@ -967,7 +967,7 @@ CGlass::BreakGlassPhysically(CVector pos, float radius)
 					for ( int32 j = 0; j < col->numTriangles; j++ )
 					{
 						if ( CCollision::TestSphereTriangle(sphere,
-							col->vertices, col->triangles[i], col->trianglePlanes[i]) )
+							col->vertices, col->triangles[j], col->trianglePlanes[j]) )
 						{
 							hit = true;
 						}

src/render/Hud.cpp

@@ -360,7 +360,11 @@ void CHud::Draw()
 						RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
 						RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
 						RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+#ifdef FIX_BUGS
+						RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+#else
 						RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVDESTALPHA);
+#endif
 						RwRenderStateSet(rwRENDERSTATETEXTURERASTER, RwTextureGetRaster(gpLaserDotTex));
 #ifdef FIX_BUGS
 						int intensity = CGeneral::GetRandomNumberInRange(0, 37);

src/render/Renderer.cpp

@@ -1,3 +1,4 @@
+#define WITH_D3D
 #include "common.h"
 
 #include "main.h"
@@ -6,6 +7,7 @@
 #include "Treadable.h"
 #include "Ped.h"
 #include "Vehicle.h"
+#include "Boat.h"
 #include "Heli.h"
 #include "Bike.h"
 #include "Object.h"
@@ -47,12 +49,27 @@ int32 CRenderer::ms_nNoOfVisibleEntities;
 CEntity *CRenderer::ms_aVisibleEntityPtrs[NUMVISIBLEENTITIES];
 CEntity *CRenderer::ms_aInVisibleEntityPtrs[NUMINVISIBLEENTITIES];
 int32 CRenderer::ms_nNoOfInVisibleEntities;
+#ifdef NEW_RENDERER
+int32 CRenderer::ms_nNoOfVisibleVehicles;
+CEntity *CRenderer::ms_aVisibleVehiclePtrs[NUMVISIBLEENTITIES];
+int32 CRenderer::ms_nNoOfVisibleBuildings;
+CEntity *CRenderer::ms_aVisibleBuildingPtrs[NUMVISIBLEENTITIES];
+#endif
 
 CVector CRenderer::ms_vecCameraPosition;
 CVehicle *CRenderer::m_pFirstPersonVehicle;
 bool CRenderer::m_loadingPriority;
 float CRenderer::ms_lodDistScale = 1.2f;
 
+#ifdef FIX_BUGS
+#define LOD_DISTANCE (300.0f*TheCamera.LODDistMultiplier)
+#else
+#define LOD_DISTANCE 300.0f
+#endif
+#define FADE_DISTANCE 20.0f
+#define STREAM_DISTANCE 30.0f
+
+
 void
 CRenderer::Init(void)
 {
@@ -75,6 +92,20 @@ CRenderer::PreRender(void)
 	for(i = 0; i < ms_nNoOfVisibleEntities; i++)
 		ms_aVisibleEntityPtrs[i]->PreRender();
 
+#ifdef NEW_RENDERER
+	if(gbNewRenderer){
+		for(i = 0; i < ms_nNoOfVisibleVehicles; i++)
+			ms_aVisibleVehiclePtrs[i]->PreRender();
+		// How is this done with cWorldStream?
+		for(i = 0; i < ms_nNoOfVisibleBuildings; i++)
+			ms_aVisibleBuildingPtrs[i]->PreRender();
+		for(node = CVisibilityPlugins::m_alphaBuildingList.head.next;
+		    node != &CVisibilityPlugins::m_alphaBuildingList.tail;
+		    node = node->next)
+			((CEntity*)node->item.entity)->PreRender();
+	}
+#endif
+
 	for (i = 0; i < ms_nNoOfInVisibleEntities; i++) {
 #ifdef SQUEEZE_PERFORMANCE
 		if (ms_aInVisibleEntityPtrs[i]->IsVehicle() && ((CVehicle*)ms_aInVisibleEntityPtrs[i])->IsHeli())
@@ -230,7 +261,6 @@ CRenderer::RenderEverythingBarRoads(void)
 {
 	int i;
 	CEntity *e;
-	CVector dist;
 	EntityInfo ei;
 
 	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)TRUE);
@@ -253,12 +283,10 @@ CRenderer::RenderEverythingBarRoads(void)
 		   e->IsPed() && CVisibilityPlugins::GetClumpAlpha((RpClump*)e->m_rwObject) != 255){
 			if(e->IsVehicle() && PutIntoSortedVehicleList((CVehicle*)e)){
 				ei.ent = e;
-				dist = ms_vecCameraPosition - e->GetPosition();
+				ei.sort = (ms_vecCameraPosition - e->GetPosition()).MagnitudeSqr();
-				ei.sort = dist.MagnitudeSqr();
 				gSortedVehiclesAndPeds.InsertSorted(ei);
 			}else{
-				dist = ms_vecCameraPosition - e->GetPosition();
+				if(!CVisibilityPlugins::InsertEntityIntoSortedList(e, (ms_vecCameraPosition - e->GetPosition()).Magnitude())){
-				if(!CVisibilityPlugins::InsertEntityIntoSortedList(e, dist.Magnitude())){
 					printf("Ran out of space in alpha entity list");
 					RenderOneNonRoad(e);
 				}
@@ -277,6 +305,24 @@ CRenderer::RenderBoats(void)
 	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
 	SetCullMode(rwCULLMODECULLBACK);
 
+#ifdef NEW_RENDERER
+	int i;
+	CEntity *e;
+	EntityInfo ei;
+	if(gbNewRenderer){
+		gSortedVehiclesAndPeds.Clear();
+		// not the real thing
+		for(i = 0; i < ms_nNoOfVisibleVehicles; i++){
+			e = ms_aVisibleVehiclePtrs[i];
+			if(e->IsVehicle() && PutIntoSortedVehicleList((CVehicle*)e)){
+				ei.ent = e;
+				ei.sort = (ms_vecCameraPosition - e->GetPosition()).MagnitudeSqr();
+				gSortedVehiclesAndPeds.InsertSorted(ei);
+			}
+		}
+	}
+#endif
+
 	for(node = gSortedVehiclesAndPeds.tail.prev;
 	    node != &gSortedVehiclesAndPeds.head;
 	    node = node->prev){
@@ -285,6 +331,573 @@ CRenderer::RenderBoats(void)
 	}
 }
 
+#ifdef NEW_RENDERER
+#ifndef LIBRW
+#error "Need librw for EXTENDED_PIPELINES"
+#endif
+#include "WaterLevel.h"
+
+enum {
+	// blend passes
+	PASS_NOZ,	// no z-write
+	PASS_ADD,	// additive
+	PASS_BLEND	// normal blend
+};
+
+static RwRGBAReal black;
+
+#ifdef RW_D3D9
+struct BuildingInst
+{
+	rw::RawMatrix combinedMat;
+	rw::d3d9::InstanceDataHeader *instHeader;
+	uint8 fadeAlpha;
+	bool lighting;
+};
+static BuildingInst blendInsts[3][2000];
+static int numBlendInsts[3];
+
+static void
+SetStencilState(int state)
+{
+	switch(state){
+	// disable stencil
+	case 0:
+		rw::d3d::setRenderState(D3DRS_STENCILENABLE, FALSE);
+		break;
+	// test against stencil
+	case 1:
+		rw::d3d::setRenderState(D3DRS_STENCILENABLE, TRUE);
+		rw::d3d::setRenderState(D3DRS_STENCILFUNC, D3DCMP_NOTEQUAL);
+		rw::d3d::setRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_KEEP);
+		rw::d3d::setRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP);
+		rw::d3d::setRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP);
+		rw::d3d::setRenderState(D3DRS_STENCILMASK, 0xFF);
+		rw::d3d::setRenderState(D3DRS_STENCILREF, 0xFF);
+		break;
+	// write to stencil
+	case 2:
+		rw::d3d::setRenderState(D3DRS_STENCILENABLE, TRUE);
+		rw::d3d::setRenderState(D3DRS_STENCILFUNC, D3DCMP_ALWAYS);
+		rw::d3d::setRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_REPLACE);
+		rw::d3d::setRenderState(D3DRS_STENCILREF, 0xFF);
+		break;
+	}
+}
+
+static void
+SetMatrix(BuildingInst *building, rw::Matrix *worldMat)
+{
+	using namespace rw;
+	RawMatrix world, worldview;
+	Camera *cam = engine->currentCamera;
+	convMatrix(&world, worldMat);
+	RawMatrix::mult(&worldview, &world, &cam->devView);
+	RawMatrix::mult(&building->combinedMat, &worldview, &cam->devProj);
+}
+
+static bool
+IsTextureTransparent(RwTexture *tex)
+{
+	if(tex == nil || tex->raster == nil)
+		return false;
+	return PLUGINOFFSET(rw::d3d::D3dRaster, tex->raster, rw::d3d::nativeRasterOffset)->hasAlpha;
+}
+
+// Render all opaque meshes and put atomics that needs blending
+// into the deferred list.
+static void
+AtomicFirstPass(RpAtomic *atomic, int pass)
+{
+	using namespace rw;
+	using namespace rw::d3d;
+	using namespace rw::d3d9;
+
+	BuildingInst *building = &blendInsts[pass][numBlendInsts[pass]];
+
+	atomic->getPipeline()->instance(atomic);
+	building->instHeader = (d3d9::InstanceDataHeader*)atomic->geometry->instData;
+	assert(building->instHeader != nil);
+	assert(building->instHeader->platform == PLATFORM_D3D9);
+	building->fadeAlpha = 255;
+	building->lighting = !!(atomic->geometry->flags & rw::Geometry::LIGHT);
+
+	bool setupDone = false;
+	bool defer = false;
+	SetMatrix(building, atomic->getFrame()->getLTM());
+
+	InstanceData *inst = building->instHeader->inst;
+	for(rw::uint32 i = 0; i < building->instHeader->numMeshes; i++, inst++){
+		Material *m = inst->material;
+
+		if(inst->vertexAlpha || m->color.alpha != 255 ||
+		   IsTextureTransparent(m->texture)){
+			defer = true;
+			continue;
+		}
+
+		// alright we're rendering this atomic
+		if(!setupDone){
+			setStreamSource(0, building->instHeader->vertexStream[0].vertexBuffer, 0, building->instHeader->vertexStream[0].stride);
+			setIndices(building->instHeader->indexBuffer);
+			setVertexDeclaration(building->instHeader->vertexDeclaration);
+			setVertexShader(default_amb_VS);
+			d3ddevice->SetVertexShaderConstantF(VSLOC_combined, (float*)&building->combinedMat, 4);
+			if(building->lighting)
+				setAmbient(pAmbient->color);
+			else
+				setAmbient(black);
+			setupDone = true;
+		}
+
+		setMaterial(m->color, m->surfaceProps);
+
+		if(m->texture){
+			d3d::setTexture(0, m->texture);
+			setPixelShader(default_tex_PS);
+		}else
+			setPixelShader(default_PS);
+
+		drawInst(building->instHeader, inst);
+	}
+	if(defer)
+		numBlendInsts[pass]++;
+}
+
+static void
+AtomicFullyTransparent(RpAtomic *atomic, int pass, int fadeAlpha)
+{
+	using namespace rw;
+	using namespace rw::d3d;
+	using namespace rw::d3d9;
+
+	BuildingInst *building = &blendInsts[pass][numBlendInsts[pass]];
+
+	atomic->getPipeline()->instance(atomic);
+	building->instHeader = (d3d9::InstanceDataHeader*)atomic->geometry->instData;
+	assert(building->instHeader != nil);
+	assert(building->instHeader->platform == PLATFORM_D3D9);
+	building->fadeAlpha = fadeAlpha;
+	building->lighting = !!(atomic->geometry->flags & rw::Geometry::LIGHT);
+	SetMatrix(building, atomic->getFrame()->getLTM());
+	numBlendInsts[pass]++;
+}
+
+static void
+RenderBlendPass(int pass)
+{
+	using namespace rw;
+	using namespace rw::d3d;
+	using namespace rw::d3d9;
+
+	setVertexShader(default_amb_VS);
+
+	int i;
+	for(i = 0; i < numBlendInsts[pass]; i++){
+		BuildingInst *building = &blendInsts[pass][i];
+
+		setStreamSource(0, building->instHeader->vertexStream[0].vertexBuffer, 0, building->instHeader->vertexStream[0].stride);
+		setIndices(building->instHeader->indexBuffer);
+		setVertexDeclaration(building->instHeader->vertexDeclaration);
+		d3ddevice->SetVertexShaderConstantF(VSLOC_combined, (float*)&building->combinedMat, 4);
+		if(building->lighting)
+			setAmbient(pAmbient->color);
+		else
+			setAmbient(black);
+
+		InstanceData *inst = building->instHeader->inst;
+		for(rw::uint32 j = 0; j < building->instHeader->numMeshes; j++, inst++){
+			Material *m = inst->material;
+			if(!inst->vertexAlpha && m->color.alpha == 255 && !IsTextureTransparent(m->texture) && building->fadeAlpha == 255)
+				continue;	// already done this one
+
+			rw::RGBA color = m->color;
+			color.alpha = (color.alpha * building->fadeAlpha)/255;
+			setMaterial(color, m->surfaceProps);
+
+			if(m->texture){
+				d3d::setTexture(0, m->texture);
+				setPixelShader(default_tex_PS);
+			}else
+				setPixelShader(default_PS);
+
+			drawInst(building->instHeader, inst);
+		}
+	}
+}
+#endif
+#ifdef RW_GL3
+struct BuildingInst
+{
+	rw::Matrix matrix;
+	rw::gl3::InstanceDataHeader *instHeader;
+	uint8 fadeAlpha;
+	bool lighting;
+};
+static BuildingInst blendInsts[3][2000];
+static int numBlendInsts[3];
+
+static void
+SetStencilState(int state)
+{
+	switch(state){
+	// disable stencil
+	case 0:
+		glDisable(GL_STENCIL_TEST);    
+		break;
+	// test against stencil
+	case 1:
+		glEnable(GL_STENCIL_TEST);
+		glStencilFunc(GL_NOTEQUAL, 0xFF, 0xFF);
+		glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
+		glStencilMask(0xFF);
+		break;
+	// write to stencil
+	case 2:
+		glEnable(GL_STENCIL_TEST);    
+		glStencilFunc(GL_ALWAYS, 0xFF, 0xFF);
+		glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
+		break;
+	}
+}
+
+static bool
+IsTextureTransparent(RwTexture *tex)
+{
+	if(tex == nil || tex->raster == nil)
+		return false;
+	return PLUGINOFFSET(rw::gl3::Gl3Raster, tex->raster, rw::gl3::nativeRasterOffset)->hasAlpha;
+}
+
+// Render all opaque meshes and put atomics that needs blending
+// into the deferred list.
+static void
+AtomicFirstPass(RpAtomic *atomic, int pass)
+{
+	using namespace rw;
+	using namespace rw::gl3;
+
+	BuildingInst *building = &blendInsts[pass][numBlendInsts[pass]];
+
+	atomic->getPipeline()->instance(atomic);
+	building->instHeader = (gl3::InstanceDataHeader*)atomic->geometry->instData;
+	assert(building->instHeader != nil);
+	assert(building->instHeader->platform == PLATFORM_GL3);
+	building->fadeAlpha = 255;
+	building->lighting = !!(atomic->geometry->flags & rw::Geometry::LIGHT);
+
+	WorldLights lights;
+	lights.numAmbients = 1;
+	lights.numDirectionals = 0;
+	lights.numLocals = 0;
+	if(building->lighting)
+		lights.ambient = pAmbient->color;
+	else
+		lights.ambient = black;
+
+	bool setupDone = false;
+	bool defer = false;
+	building->matrix = *atomic->getFrame()->getLTM();
+
+	InstanceData *inst = building->instHeader->inst;
+	for(rw::uint32 i = 0; i < building->instHeader->numMeshes; i++, inst++){
+		Material *m = inst->material;
+
+		if(inst->vertexAlpha || m->color.alpha != 255 ||
+		   IsTextureTransparent(m->texture)){
+			defer = true;
+			continue;
+		}
+
+		// alright we're rendering this atomic
+		if(!setupDone){
+			defaultShader->use();
+			setWorldMatrix(&building->matrix);
+#ifdef RW_GL_USE_VAOS
+			glBindVertexArray(building->instHeader->vao);
+#else
+			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, building->instHeader->ibo);
+			glBindBuffer(GL_ARRAY_BUFFER, building->instHeader->vbo);
+			setAttribPointers(building->instHeader->attribDesc, building->instHeader->numAttribs);
+#endif
+			setLights(&lights);
+			setupDone = true;
+		}
+
+		setMaterial(m->color, m->surfaceProps);
+
+		setTexture(0, m->texture);
+
+		drawInst(building->instHeader, inst);
+	}
+#ifndef RW_GL_USE_VAOS
+	disableAttribPointers(building->instHeader->attribDesc, building->instHeader->numAttribs);
+#endif
+	if(defer)
+		numBlendInsts[pass]++;
+}
+
+static void
+AtomicFullyTransparent(RpAtomic *atomic, int pass, int fadeAlpha)
+{
+	using namespace rw;
+	using namespace rw::gl3;
+
+	BuildingInst *building = &blendInsts[pass][numBlendInsts[pass]];
+
+	atomic->getPipeline()->instance(atomic);
+	building->instHeader = (gl3::InstanceDataHeader*)atomic->geometry->instData;
+	assert(building->instHeader != nil);
+	assert(building->instHeader->platform == PLATFORM_GL3);
+	building->fadeAlpha = fadeAlpha;
+	building->lighting = !!(atomic->geometry->flags & rw::Geometry::LIGHT);
+	building->matrix = *atomic->getFrame()->getLTM();
+	numBlendInsts[pass]++;
+}
+
+static void
+RenderBlendPass(int pass)
+{
+	using namespace rw;
+	using namespace rw::gl3;
+
+	defaultShader->use();
+	WorldLights lights;
+	lights.numAmbients = 1;
+	lights.numDirectionals = 0;
+	lights.numLocals = 0;
+
+	int i;
+	for(i = 0; i < numBlendInsts[pass]; i++){
+		BuildingInst *building = &blendInsts[pass][i];
+
+#ifdef RW_GL_USE_VAOS
+		glBindVertexArray(building->instHeader->vao);
+#else
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, building->instHeader->ibo);
+		glBindBuffer(GL_ARRAY_BUFFER, building->instHeader->vbo);
+		setAttribPointers(building->instHeader->attribDesc, building->instHeader->numAttribs);
+#endif
+		setWorldMatrix(&building->matrix);
+		if(building->lighting)
+			lights.ambient = pAmbient->color;
+		else
+			lights.ambient = black;
+		setLights(&lights);
+
+		InstanceData *inst = building->instHeader->inst;
+		for(rw::uint32 j = 0; j < building->instHeader->numMeshes; j++, inst++){
+			Material *m = inst->material;
+			if(!inst->vertexAlpha && m->color.alpha == 255 && !IsTextureTransparent(m->texture) && building->fadeAlpha == 255)
+				continue;	// already done this one
+
+			rw::RGBA color = m->color;
+			color.alpha = (color.alpha * building->fadeAlpha)/255;
+			setMaterial(color, m->surfaceProps);
+
+			setTexture(0, m->texture);
+
+			drawInst(building->instHeader, inst);
+		}
+#ifndef RW_GL_USE_VAOS
+		disableAttribPointers(building->instHeader->attribDesc, building->instHeader->numAttribs);
+#endif
+	}
+}
+#endif
+
+void
+CRenderer::RenderOneBuilding(CEntity *ent, float camdist)
+{
+	if(ent->m_rwObject == nil)
+		return;
+	assert(RwObjectGetType(ent->m_rwObject) == rpATOMIC);
+	RpAtomic *atomic = (RpAtomic*)ent->m_rwObject;
+	CSimpleModelInfo *mi = (CSimpleModelInfo*)CModelInfo::GetModelInfo(ent->GetModelIndex());
+
+	ent->bImBeingRendered = true;	// TODO: this seems wrong, but do we even need it?
+
+	int pass = PASS_BLEND;
+	if(mi->m_additive)	// very questionable
+		pass = PASS_ADD;
+	if(mi->m_noZwrite)
+		pass = PASS_NOZ;
+
+	if(ent->bDistanceFade){
+		RpAtomic *lodatm;
+		float fadefactor;
+		uint32 alpha;
+
+		lodatm = mi->GetAtomicFromDistance(camdist - FADE_DISTANCE);
+		fadefactor = (mi->GetLargestLodDistance() - (camdist - FADE_DISTANCE))/FADE_DISTANCE;
+		if(fadefactor > 1.0f)
+			fadefactor = 1.0f;
+		alpha = mi->m_alpha * fadefactor;
+
+		if(alpha == 255)
+			AtomicFirstPass(atomic, pass);
+		else{
+			// not quite sure what this is about, do we have to do that?
+			RpGeometry *geo = RpAtomicGetGeometry(lodatm);
+			if(geo != RpAtomicGetGeometry(atomic))
+				RpAtomicSetGeometry(atomic, geo, rpATOMICSAMEBOUNDINGSPHERE);
+			AtomicFullyTransparent(atomic, pass, alpha);
+		}
+	}else
+		AtomicFirstPass(atomic, pass);
+
+	ent->bImBeingRendered = false;	// TODO: this seems wrong, but do we even need it?
+}
+
+void
+CRenderer::RenderWorld(int pass)
+{
+	int i;
+	CEntity *e;
+	CLink<CVisibilityPlugins::AlphaObjectInfo> *node;
+
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)TRUE);
+	SetCullMode(rwCULLMODECULLBACK);
+	DeActivateDirectional();
+	SetAmbientColours();
+
+	// Temporary...have to figure out sorting better
+	switch(pass){
+	case 0:
+		// Roads
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)FALSE);
+		for(i = 0; i < ms_nNoOfVisibleBuildings; i++){
+			e = ms_aVisibleBuildingPtrs[i];
+			if(e->bIsBIGBuilding || IsRoad(e))
+				RenderOneBuilding(e);
+		}
+		for(node = CVisibilityPlugins::m_alphaBuildingList.tail.prev;
+		    node != &CVisibilityPlugins::m_alphaBuildingList.head;
+		    node = node->prev){
+			e = node->item.entity;
+			if(e->bIsBIGBuilding || IsRoad(e))
+				RenderOneBuilding(e, node->item.sort);
+		}
+		break;
+	case 1:
+		// Opaque
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)FALSE);
+		for(i = 0; i < ms_nNoOfVisibleBuildings; i++){
+			e = ms_aVisibleBuildingPtrs[i];
+			if(!(e->bIsBIGBuilding || IsRoad(e)))
+				RenderOneBuilding(e);
+		}
+		for(node = CVisibilityPlugins::m_alphaBuildingList.tail.prev;
+		    node != &CVisibilityPlugins::m_alphaBuildingList.head;
+		    node = node->prev){
+			e = node->item.entity;
+			if(!(e->bIsBIGBuilding || IsRoad(e)))
+				RenderOneBuilding(e, node->item.sort);
+		}
+		// Now we have iterated through all visible buildings (unsorted and sorted)
+		// and the transparency list is done.
+
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+		RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, FALSE);
+		RenderBlendPass(PASS_NOZ);
+		RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+		break;
+	case 2:
+		// Transparent
+		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDONE);
+		RenderBlendPass(PASS_ADD);
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+		RenderBlendPass(PASS_BLEND);
+		break;
+	}
+}
+
+void
+CRenderer::RenderPeds(void)
+{
+	int i;
+	CEntity *e;
+
+	for(i = 0; i < ms_nNoOfVisibleVehicles; i++){
+		e = ms_aVisibleVehiclePtrs[i];
+		if(e->IsPed())
+			RenderOneNonRoad(e);
+	}
+}
+
+void
+CRenderer::RenderVehicles(void)
+{
+	int i;
+	CEntity *e;
+	EntityInfo ei;
+	CLink<EntityInfo> *node;
+
+	// not the real thing
+	for(i = 0; i < ms_nNoOfVisibleVehicles; i++){
+		e = ms_aVisibleVehiclePtrs[i];
+		if(!e->IsVehicle())
+			continue;
+		if(PutIntoSortedVehicleList((CVehicle*)e))
+			continue;	// boats handled elsewhere
+		ei.ent = e;
+		ei.sort = (ms_vecCameraPosition - e->GetPosition()).MagnitudeSqr();
+		gSortedVehiclesAndPeds.InsertSorted(ei);
+	}
+
+	for(node = gSortedVehiclesAndPeds.tail.prev;
+	    node != &gSortedVehiclesAndPeds.head;
+	    node = node->prev)
+		RenderOneNonRoad(node->item.ent);
+}
+
+void
+CRenderer::RenderTransparentWater(void)
+{
+	int i;
+	CEntity *e;
+
+	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, nil);
+	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)FALSE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDZERO);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDONE);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
+	SetStencilState(2);
+
+	for(i = 0; i < ms_nNoOfVisibleVehicles; i++){
+		e = ms_aVisibleVehiclePtrs[i];
+		if(e->IsVehicle() && ((CVehicle*)e)->IsBoat())
+			((CBoat*)e)->RenderWaterOutPolys();
+	}
+
+	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)TRUE);
+	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
+	RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
+	SetStencilState(1);
+
+	CWaterLevel::RenderTransparentWater();
+
+	SetStencilState(0);
+}
+
+void
+CRenderer::ClearForFrame(void)
+{
+	ms_nNoOfVisibleEntities = 0;
+	ms_nNoOfVisibleVehicles = 0;
+	ms_nNoOfVisibleBuildings = 0;
+	ms_nNoOfInVisibleEntities = 0;
+	gSortedVehiclesAndPeds.Clear();
+
+	numBlendInsts[PASS_NOZ] = 0;
+	numBlendInsts[PASS_ADD] = 0;
+	numBlendInsts[PASS_BLEND] = 0;
+}
+#endif
+
 void
 CRenderer::RenderFadingInEntities(void)
 {
@@ -327,14 +940,6 @@ enum Visbility
 	VIS_STREAMME
 };
 
-#ifdef FIX_BUGS
-#define LOD_DISTANCE (300.0f*TheCamera.LODDistMultiplier)
-#else
-#define LOD_DISTANCE 300.0f
-#endif
-#define FADE_DISTANCE 20.0f
-#define STREAM_DISTANCE 30.0f
-
 // Time Objects can be time culled if
 //   other == -1 || CModelInfo::GetModelInfo(other)->GetRwObject()
 // i.e. we have to draw even at the wrong time if
@@ -640,9 +1245,13 @@ void
 CRenderer::ConstructRenderList(void)
 {
 	COcclusion::ProcessBeforeRendering();
-
+#ifdef NEW_RENDERER
+	if(!gbNewRenderer)
+#endif
+{
 	ms_nNoOfVisibleEntities = 0;
 	ms_nNoOfInVisibleEntities = 0;
+}
 	ms_vecCameraPosition = TheCamera.GetPosition();
 	// TODO: blocked ranges, but unused
 	ScanWorld();
@@ -1041,6 +1650,20 @@ CRenderer::ScanSectorPoly(RwV2d *poly, int32 numVertices, void (*scanfunc)(CPtrL
 	}
 }
 
+void
+CRenderer::InsertEntityIntoList(CEntity *ent)
+{
+#ifdef NEW_RENDERER
+	// TODO: there are more flags being checked here
+	if(gbNewRenderer && (ent->IsVehicle() || ent->IsPed()))
+		ms_aVisibleVehiclePtrs[ms_nNoOfVisibleVehicles++] = ent;
+	else if(gbNewRenderer && ent->IsBuilding())
+		ms_aVisibleBuildingPtrs[ms_nNoOfVisibleBuildings++] = ent;
+	else
+#endif
+		ms_aVisibleEntityPtrs[ms_nNoOfVisibleEntities++] = ent;
+}
+
 void
 CRenderer::ScanBigBuildingList(CPtrList &list)
 {
@@ -1058,7 +1681,7 @@ CRenderer::ScanBigBuildingList(CPtrList &list)
 			vis = VIS_VISIBLE;
 		switch(vis){
 		case VIS_VISIBLE:
-			ms_aVisibleEntityPtrs[ms_nNoOfVisibleEntities++] = ent;
+			InsertEntityIntoList(ent);
 			ent->bOffscreen = false;
 			break;
 		case VIS_STREAMME:
@@ -1089,7 +1712,7 @@ CRenderer::ScanSectorList(CPtrList *lists)
 
 			switch(SetupEntityVisibility(ent)){
 			case VIS_VISIBLE:
-				ms_aVisibleEntityPtrs[ms_nNoOfVisibleEntities++] = ent;
+				InsertEntityIntoList(ent);
 				break;
 			case VIS_INVISIBLE:
 				if(!IsGlass(ent->GetModelIndex()))
@@ -1134,7 +1757,7 @@ CRenderer::ScanSectorList_Priority(CPtrList *lists)
 
 			switch(SetupEntityVisibility(ent)){
 			case VIS_VISIBLE:
-				ms_aVisibleEntityPtrs[ms_nNoOfVisibleEntities++] = ent;
+				InsertEntityIntoList(ent);
 				break;
 			case VIS_INVISIBLE:
 				if(!IsGlass(ent->GetModelIndex()))
@@ -1181,7 +1804,7 @@ CRenderer::ScanSectorList_Subway(CPtrList *lists)
 			ent->bOffscreen = false;
 			switch(SetupEntityVisibility(ent)){
 			case VIS_VISIBLE:
-				ms_aVisibleEntityPtrs[ms_nNoOfVisibleEntities++] = ent;
+				InsertEntityIntoList(ent);
 				break;
 			case VIS_OFFSCREEN:
 				ent->bOffscreen = true;

src/render/Renderer.h

@@ -21,6 +21,13 @@ class CRenderer
 	static CEntity *ms_aVisibleEntityPtrs[NUMVISIBLEENTITIES];
 	static int32 ms_nNoOfInVisibleEntities;
 	static CEntity *ms_aInVisibleEntityPtrs[NUMINVISIBLEENTITIES];
+#ifdef NEW_RENDERER
+	static int32 ms_nNoOfVisibleVehicles;
+	static CEntity *ms_aVisibleVehiclePtrs[NUMVISIBLEENTITIES];
+	// for cWorldStream emulation
+	static int32 ms_nNoOfVisibleBuildings;
+	static CEntity *ms_aVisibleBuildingPtrs[NUMVISIBLEENTITIES];
+#endif
 
 	static CVector ms_vecCameraPosition;
 	static CVehicle *m_pFirstPersonVehicle;
@@ -63,4 +70,15 @@ public:
 	static bool ShouldModelBeStreamed(CEntity *ent, const CVector &campos);
 
 	static void RemoveVehiclePedLights(CEntity *ent, bool reset);
+
+
+#ifdef NEW_RENDERER
+	static void ClearForFrame(void);
+	static void RenderPeds(void);
+	static void RenderVehicles(void);	// also renders peds in LCS
+	static void RenderOneBuilding(CEntity *ent, float camdist = 0.0f);
+	static void RenderWorld(int pass);	// like cWorldStream::Render(int)
+	static void RenderTransparentWater(void);	// keep-out polys and transparent water
+#endif
+	static void InsertEntityIntoList(CEntity *ent);
 };

src/render/SpecialFX.cpp

@@ -169,6 +169,9 @@ CSpecialFX::Render(void)
 	CBrightLights::Render();
 	CShinyTexts::Render();
 	CMoneyMessages::Render();
+#ifdef NEW_RENDERER
+	if(!(gbNewRenderer && FredIsInFirstPersonCam()))
+#endif
 	C3dMarkers::Render();
 }
 

src/rw/VisibilityPlugins.cpp

@@ -1,6 +1,7 @@
 #include "common.h"
 
 #include "templates.h"
+#include "main.h"
 #include "Entity.h"
 #include "ModelInfo.h"
 #include "Lights.h"
@@ -19,6 +20,9 @@ CLinkList<CVisibilityPlugins::AlphaObjectInfo> CVisibilityPlugins::m_alphaList;
 CLinkList<CVisibilityPlugins::AlphaObjectInfo> CVisibilityPlugins::m_alphaBoatAtomicList;
 CLinkList<CVisibilityPlugins::AlphaObjectInfo> CVisibilityPlugins::m_alphaEntityList;
 CLinkList<CVisibilityPlugins::AlphaObjectInfo> CVisibilityPlugins::m_alphaUnderwaterEntityList;
+#ifdef NEW_RENDERER
+CLinkList<CVisibilityPlugins::AlphaObjectInfo> CVisibilityPlugins::m_alphaBuildingList;
+#endif
 
 int32 CVisibilityPlugins::ms_atomicPluginOffset = -1;
 int32 CVisibilityPlugins::ms_framePluginOffset = -1;
@@ -59,6 +63,11 @@ CVisibilityPlugins::Initialise(void)
 	m_alphaUnderwaterEntityList.head.item.sort = 0.0f;
 	m_alphaUnderwaterEntityList.tail.item.sort = 100000000.0f;
 
+#ifdef NEW_RENDERER
+	m_alphaBuildingList.Init(NUMALPHAENTITYLIST);
+	m_alphaBuildingList.head.item.sort = 0.0f;
+	m_alphaBuildingList.tail.item.sort = 100000000.0f;
+#endif
 }
 
 void
@@ -68,6 +77,9 @@ CVisibilityPlugins::Shutdown(void)
 	m_alphaBoatAtomicList.Shutdown();
 	m_alphaEntityList.Shutdown();
 	m_alphaUnderwaterEntityList.Shutdown();
+#ifdef NEW_RENDERER
+	m_alphaBuildingList.Shutdown();
+#endif
 }
 
 void
@@ -76,6 +88,9 @@ CVisibilityPlugins::InitAlphaEntityList(void)
 	m_alphaEntityList.Clear();
 	m_alphaBoatAtomicList.Clear();
 	m_alphaUnderwaterEntityList.Clear();
+#ifdef NEW_RENDERER
+	m_alphaBuildingList.Clear();
+#endif
 }
 
 bool
@@ -84,6 +99,10 @@ CVisibilityPlugins::InsertEntityIntoSortedList(CEntity *e, float dist)
 	AlphaObjectInfo item;
 	item.entity = e;
 	item.sort = dist;
+#ifdef NEW_RENDERER
+	if(gbNewRenderer && e->IsBuilding())
+		return !!m_alphaBuildingList.InsertSorted(item);
+#endif
 	if(e->bUnderwater && m_alphaUnderwaterEntityList.InsertSorted(item))
 		return true;
 	return !!m_alphaEntityList.InsertSorted(item);
@@ -308,7 +327,7 @@ CVisibilityPlugins::RenderFadingAtomic(RpAtomic *atomic, float camdist)
 	mi = GetAtomicModelInfo(atomic);
 	lodatm = mi->GetAtomicFromDistance(camdist - FADE_DISTANCE);
 	if(mi->m_additive)
-		AtomicDefaultRenderCallBack(atomic);
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDONE);
 
 	fadefactor = (mi->GetLargestLodDistance() - (camdist - FADE_DISTANCE))/FADE_DISTANCE;
 	if(fadefactor > 1.0f)

src/rw/VisibilityPlugins.h

@@ -24,6 +24,9 @@ public:
 	static CLinkList<AlphaObjectInfo> m_alphaBoatAtomicList;
 	static CLinkList<AlphaObjectInfo> m_alphaEntityList;
 	static CLinkList<AlphaObjectInfo> m_alphaUnderwaterEntityList;
+#ifdef NEW_RENDERER
+	static CLinkList<AlphaObjectInfo> m_alphaBuildingList;
+#endif
 	static RwCamera *ms_pCamera;
 	static RwV3d *ms_pCameraPosn;
 	static float ms_cullCompsDist;

src/vehicles/Automobile.cpp

@@ -1494,7 +1494,7 @@ CAutomobile::ProcessControl(void)
 				blade = Multiply3x3(blade, GetMatrix());
 				camDist /= Max(Sqrt(distSq), 0.01f);
 				if(Abs(DotProduct(camDist, blade)) > 0.95f){
-					DMAudio.PlayOneShot(m_audioEntityId, SOUND_31, 0.0f);
+					DMAudio.PlayOneShot(m_audioEntityId, SOUND_HELI_BLADE, 0.0f);
 					m_fPropellerRotation = m_aWheelRotation[1];
 				}
 			}
@@ -4834,19 +4834,19 @@ CAutomobile::SetUpWheelColModel(CColModel *colModel)
 
 	CMatrix mat;
 	mat.Attach(RwFrameGetMatrix(m_aCarNodes[CAR_WHEEL_LF]));
-	colModel->spheres[0].Set(mi->m_wheelScale, mat.GetPosition(), SURFACE_RUBBER, CAR_PIECE_WHEEL_LF);
+	colModel->spheres[0].Set(mi->m_wheelScale / 2, mat.GetPosition(), SURFACE_RUBBER, CAR_PIECE_WHEEL_LF);
 	mat.Attach(RwFrameGetMatrix(m_aCarNodes[CAR_WHEEL_LB]));
-	colModel->spheres[1].Set(mi->m_wheelScale, mat.GetPosition(), SURFACE_RUBBER, CAR_PIECE_WHEEL_LR);
+	colModel->spheres[1].Set(mi->m_wheelScale / 2, mat.GetPosition(), SURFACE_RUBBER, CAR_PIECE_WHEEL_LR);
 	mat.Attach(RwFrameGetMatrix(m_aCarNodes[CAR_WHEEL_RF]));
-	colModel->spheres[2].Set(mi->m_wheelScale, mat.GetPosition(), SURFACE_RUBBER, CAR_PIECE_WHEEL_RF);
+	colModel->spheres[2].Set(mi->m_wheelScale / 2, mat.GetPosition(), SURFACE_RUBBER, CAR_PIECE_WHEEL_RF);
 	mat.Attach(RwFrameGetMatrix(m_aCarNodes[CAR_WHEEL_RB]));
-	colModel->spheres[3].Set(mi->m_wheelScale, mat.GetPosition(), SURFACE_RUBBER, CAR_PIECE_WHEEL_RR);
+	colModel->spheres[3].Set(mi->m_wheelScale / 2, mat.GetPosition(), SURFACE_RUBBER, CAR_PIECE_WHEEL_RR);
 
 	if(m_aCarNodes[CAR_WHEEL_LM] != nil && m_aCarNodes[CAR_WHEEL_RM] != nil){
 		mat.Attach(RwFrameGetMatrix(m_aCarNodes[CAR_WHEEL_LM]));
-		colModel->spheres[4].Set(mi->m_wheelScale, mat.GetPosition(), SURFACE_RUBBER, CAR_PIECE_WHEEL_LR);
+		colModel->spheres[4].Set(mi->m_wheelScale / 2, mat.GetPosition(), SURFACE_RUBBER, CAR_PIECE_WHEEL_LR);
 		mat.Attach(RwFrameGetMatrix(m_aCarNodes[CAR_WHEEL_RM]));
-		colModel->spheres[5].Set(mi->m_wheelScale, mat.GetPosition(), SURFACE_RUBBER, CAR_PIECE_WHEEL_RR);
+		colModel->spheres[5].Set(mi->m_wheelScale / 2, mat.GetPosition(), SURFACE_RUBBER, CAR_PIECE_WHEEL_RR);
 		colModel->numSpheres = 6;
 	}else
 		colModel->numSpheres = 4;

src/vehicles/Boat.cpp

@@ -1,5 +1,6 @@
 #include "common.h"
 
+#include "main.h"
 #include "General.h"
 #include "Timecycle.h"
 #include "Weather.h"
@@ -1100,6 +1101,15 @@ CBoat::Render()
 	m_nSetPieceExtendedRangeTime = CTimer::GetTimeInMilliseconds() + 3000;
 	if (!CVehicle::bWheelsOnlyCheat)
 		CEntity::Render();
+#ifdef NEW_RENDERER
+	if(!gbNewRenderer)
+#endif
+	RenderWaterOutPolys();	// not separate function in VC
+}
+
+void
+CBoat::RenderWaterOutPolys(void)
+{
 	if(GetModelIndex() == MI_SKIMMER)
 		return;
 	KeepWaterOutIndices[0] = 0;
@@ -1178,11 +1188,16 @@ CBoat::Render()
 	KeepWaterOutVertices[2].v = 1.0f;
 	KeepWaterOutVertices[3].u = 1.0f;
 	KeepWaterOutVertices[3].v = 1.0f;
+#ifdef NEW_RENDERER
+	if(!gbNewRenderer)
+#endif
+{
 	RwRenderStateSet(rwRENDERSTATETEXTURERASTER, gpWaterRaster);
 	RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
 	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)FALSE);
 	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDZERO);
 	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDONE);
+}
 	if (!CVehicle::bWheelsOnlyCheat && RwIm3DTransform(KeepWaterOutVertices, 4, GetMatrix().m_attachment, rwIM3D_VERTEXUV)) {
 		RwIm3DRenderIndexedPrimitive(rwPRIMTYPETRILIST, KeepWaterOutIndices, 6);
 		RwIm3DEnd();
@@ -1209,10 +1224,15 @@ CBoat::Render()
 			RwIm3DEnd();
 		}
 	}
+#ifdef NEW_RENDERER
+	if(!gbNewRenderer)
+#endif
+{
 	RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)TRUE);
 	RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
 	RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
 }
+}
 
 void
 CBoat::Teleport(CVector v)

src/vehicles/Boat.h

@@ -63,6 +63,7 @@ public:
 	virtual bool IsComponentPresent(int32 component) { return true; }
 	virtual void BlowUpCar(CEntity *ent);
 
+	void RenderWaterOutPolys(void);
 	void ApplyWaterResistance(void);
 	void SetupModelNodes();
 	void PruneWakeTrail(void);

src/weapons/ProjectileInfo.cpp

@@ -296,10 +296,8 @@ CProjectileInfo::Update()
 			CParticle::AddParticle(PARTICLE_TEARGAS, projectilePos, CVector(-0.2f, tearGasOffset, 0.0f), 0, 0.0f, 0, 0, 0, 0);
 			CParticle::AddParticle(PARTICLE_TEARGAS, projectilePos, CVector(tearGasOffset, tearGasOffset, 0.0f), 0, 0.0f, 0, 0, 0, 0);
 
-			// TODO(Miami): SetPedsChoking
+			if ( CTimer::GetTimeInMilliseconds() & 0x200 )
-			/*if ( CTimer::GetTimeInMilliseconds() & 0x200 )
 				CWorld::SetPedsChoking(projectilePos.x, projectilePos.y, projectilePos.z, 6.0f, gaProjectileInfo[i].m_pSource);
-			*/
 		}
 
 		if (gaProjectileInfo[i].m_eWeaponType == WEAPONTYPE_ROCKET) {

src/weapons/WeaponEffects.cpp

@@ -94,7 +94,11 @@ CWeaponEffects::Render(void)
 		RwRenderStateSet(rwRENDERSTATEZTESTENABLE,       (void *)FALSE);
 		RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void *)TRUE);
 		RwRenderStateSet(rwRENDERSTATESRCBLEND,          (void *)rwBLENDSRCALPHA);
+#ifdef FIX_BUGS
+		RwRenderStateSet(rwRENDERSTATEDESTBLEND,         (void *)rwBLENDINVSRCALPHA);
+#else
 		RwRenderStateSet(rwRENDERSTATEDESTBLEND,         (void *)rwBLENDINVDESTALPHA);
+#endif
 		RwRenderStateSet(rwRENDERSTATETEXTURERASTER,     (void *)gpCrossHairRaster);
 
 		RwV3d pos;

vendor/librw

@@ -1 +1 @@
-Subproject commit e68ef1374d20071887348e9031f5fa38a2e4f7ed
+Subproject commit 7e80d45cdb6663f97d89ed443198ce6e37c4435e

vendor/ogg

@@ -1 +1 @@
-Subproject commit 36f969bb37559345ee03796ed625a9abd42c6db9
+Subproject commit 31bd3f2707fb7dbae539a7093ba1fc4b2b37d84e

vendor/opus

@@ -1 +1 @@
-Subproject commit 034c1b61a250457649d788bbf983b3f0fb63f02e
+Subproject commit c2b542b6c02bafbe7a83b2eeec6cb5a0bfa3ed0d