mirror/re3
1
0
Fork 0
mirror of https://github.com/GTAmodding/re3.git synced 2024-12-25 17:25:41 +00:00
Code Issues Projects Releases Wiki Activity

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

Browse source
This commit is contained in:
erorcun 2020-11-12 17:37:04 +03:00
commit 4f8029ad7c
32 changed files with 2248 additions and 887 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1706
src/audio/AudioLogic.cpp
View file

File diff suppressed because it is too large Load diff

3
src/audio/AudioManager.cpp
View file

@ -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()
{

151
src/audio/AudioManager.h
View file

@ -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; }
float GetReflectionsDistance(int32 idx) const { return m_afReflectionsDistances[idx]; }
uint32 GetFrameCounter() const { return m_FrameCounter; } // done
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 GetVehicleNonDriveWheelSkidValue(uint8 wheel, CAutomobile *automobile, cTransmission *transmission, float velocityChange);
float GetVehicleDriveWheelSkidValue(CVehicle* veh, tWheelState wheelState, float gasPedalAudio, cTransmission* transmission, float velocityChange); // done
float GetVehicleNonDriveWheelSkidValue(CVehicle* veh, tWheelState wheelState, cTransmission* transmission, float velocityChange); // done
bool HasAirBrakes(int32 model) const; // done
void Initialise(); // done
void InitialisePoliceRadio();
void InitialisePoliceRadioZones();
void InitialisePoliceRadio(); //done
void InitialisePoliceRadioZones(); //done
void InterrogateAudioEntities(); // done
bool IsAudioInitialised() const;
bool IsMissionAudioSampleFinished(uint8 slot);
bool IsAudioInitialised() const; // done
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 ProcessBoatEngine(cVehicleParams *params);
bool ProcessBoatMovingOverWater(cVehicleParams *params);
void ProcessActiveQueues(); // done
bool ProcessAirBrakes(cVehicleParams& params); // done
bool ProcessBoatEngine(cVehicleParams& params);
bool ProcessBoatMovingOverWater(cVehicleParams& params);
#ifdef GTA_BRIDGE
void ProcessBridge();
void ProcessBridgeMotor();
void ProcessBridgeOneShots();
void ProcessBridgeWarning();
void ProcessBridge(); // done(bcs not exists in VC)
void ProcessBridgeMotor(); // done(bcs not exists in VC)
void ProcessBridgeOneShots(); // done(bcs not exists in VC)
void ProcessBridgeWarning(); // done(bcs not exists in VC)
#endif
bool ProcessCarBombTick(cVehicleParams *params); // done
void ProcessCesna(cVehicleParams *params); //
//void ProcessCrane(); //
bool ProcessEngineDamage(cVehicleParams *params); // done
bool ProcessCarBombTick(cVehicleParams& params); // done
void ProcessCarHeli(cVehicleParams& params); // done
void ProcessCesna(cVehicleParams& params); //
//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 ProcessVehicleFlatTyre(cVehicleParams* params); // done
void ProcessJumbo(cVehicleParams *); //
void ProcessJumboAccel(CPlane *plane); //
void ProcessJumboDecel(CPlane *plane); //
void ProcessJumboFlying(); //
void ProcessJumboLanding(CPlane *plane); //
void ProcessJumboTakeOff(CPlane *plane); //
void ProcessJumboTaxi(); //
void ProcessJumbo(cVehicleParams& params); // done
void ProcessJumboAccel(CPlane *plane); // done
void ProcessJumboDecel(CPlane *plane); // done
void ProcessJumboFlying(); // done
void ProcessJumboLanding(CPlane *plane); // done
void ProcessJumboTakeOff(CPlane *plane); // done
void ProcessJumboTaxi(); // done
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 ProcessPlayersVehicleEngine(cVehicleParams *params, CVehicle* veh); // done
void ProcessProjectiles(); //
void ProcessRainOnVehicle(cVehicleParams *params); //
void ProcessReverb() const; //
bool ProcessReverseGear(cVehicleParams *params); // done
void ProcessPlane(cVehicleParams& params); // done
void ProcessPlayerMood(); // done
void ProcessPlayersVehicleEngine(cVehicleParams& params, CVehicle* veh); // done
void ProcessProjectiles(); // done
void ProcessRainOnVehicle(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
bool ProcessVehicleDoors(cVehicleParams *params); //done
void ProcessVehicleEngine(cVehicleParams *params); //done
void UpdateGasPedalAudio(CVehicle* veh, int vehType); //done
void ProcessVehicleHorn(cVehicleParams *params);
void ProcessVehicleOneShots(cVehicleParams *params);
bool ProcessVehicleReverseWarning(cVehicleParams *params);
bool ProcessVehicleRoadNoise(cVehicleParams *params);
bool ProcessVehicleSirenOrAlarm(cVehicleParams *params);
bool ProcessVehicleSkidding(cVehicleParams *params);
void ProcessWaterCannon(int32);
void ProcessWeather(int32 id); //done
bool ProcessWetRoadNoise(cVehicleParams *params);
void ProcessEscalators(); //done
void ProcessExtraSounds(); //done
void ProcessVehicle(CVehicle *vehicle); // done
bool ProcessVehicleDoors(cVehicleParams& params); // done
void ProcessVehicleEngine(cVehicleParams& params); // done
void ProcessVehicleFlatTyre(cVehicleParams& params); // done
bool ProcessVehicleHorn(cVehicleParams& params); // done
void ProcessVehicleOneShots(cVehicleParams& params); // done
bool ProcessVehicleReverseWarning(cVehicleParams& params); // done
bool ProcessVehicleRoadNoise(cVehicleParams& params); // done
bool ProcessVehicleSirenOrAlarm(cVehicleParams& params); // done
bool ProcessVehicleSkidding(cVehicleParams& params); // done
void ProcessWaterCannon(int32); // done
void ProcessWeather(int32 id); // done
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 ResetPoliceRadio();
void ResetTimers(uint32 time);
void ReportCrime(eCrimeType crime, const CVector &pos); // done
void ResetAudioLogicTimers(uint32 timer); // done
void ResetPoliceRadio(); // done
void ResetTimers(uint32 time); // done
void Service();
void ServiceCollisions();
void Service(); //done
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 TranslateEntity(Const CVector *v1, CVector *v2) const;
void Terminate(); //done
void TranslateEntity(Const CVector *v1, CVector *v2) const; //done
void UpdateReflections();
bool UsesReverseWarning(int32 model) const; //done
bool UsesSiren(int32 model) const;
bool UsesSirenSwitching(int32 model) const;
void UpdateGasPedalAudio(CVehicle* veh, int vehType); // done
void UpdateReflections(); //done
bool UsesReverseWarning(int32 model) const; //done
bool UsesSiren(cVehicleParams& params) const; //done
bool UsesSirenSwitching(cVehicleParams& params) const; //done
CVehicle *FindVehicleOfPlayer(); //done
void SetPedTalkingStatus(CPed *ped, uint8 status);

2
src/audio/soundlist.h
View file

@ -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,

16
src/control/Pickups.cpp
View file

@ -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)
{

1
src/control/Pickups.h
View file

@ -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);

2
src/control/Script.cpp
View file

@ -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;
}
/*

1
src/control/Script.h
View file

@ -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

249
src/core/World.cpp
View file

@ -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 nStartY = Max(CWorld::GetSectorIndexY(vecSectorStartPos.y), 0);
const int32 nEndX = Min(CWorld::GetSectorIndexX(vecSectorEndPos.x), NUMSECTORS_X - 1);
const int32 nEndY = Min(CWorld::GetSectorIndexY(vecSectorEndPos.y), NUMSECTORS_Y - 1);
const int32 nStartX = Max(GetSectorIndexX(vecSectorStartPos.x), 0);
const int32 nStartY = Max(GetSectorIndexY(vecSectorStartPos.y), 0);
#ifdef FIX_BUGS
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 nStartY = Max(CWorld::GetSectorIndexY(vecSectorStartPos.y), 0);
const int32 nEndX = Min(CWorld::GetSectorIndexX(vecSectorEndPos.x), NUMSECTORS_X - 1);
const int32 nEndY = Min(CWorld::GetSectorIndexY(vecSectorEndPos.y), NUMSECTORS_Y - 1);
const int32 nStartX = Max(GetSectorIndexX(vecSectorStartPos.x), 0);
const int32 nStartY = Max(GetSectorIndexY(vecSectorStartPos.y), 0);
#ifdef FIX_BUGS
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 nStartY = Max(CWorld::GetSectorIndexY(vecStartPos.y), 0);
const int32 nEndX = Min(CWorld::GetSectorIndexX(vecEndPos.x), NUMSECTORS_X - 1);
const int32 nEndY = Min(CWorld::GetSectorIndexY(vecEndPos.y), NUMSECTORS_Y - 1);
const int32 nStartX = Max(GetSectorIndexX(vecStartPos.x), 0);
const int32 nStartY = Max(GetSectorIndexY(vecStartPos.y), 0);
#ifdef FIX_BUGS
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 nStartY = Max(CWorld::GetSectorIndexY(fStartY), 0);
const int32 nEndX = Min(CWorld::GetSectorIndexX(fEndX), NUMSECTORS_X - 1);
const int32 nEndY = Min(CWorld::GetSectorIndexY(fEndY), NUMSECTORS_Y - 1);
const int32 nStartX = Max(GetSectorIndexX(fStartX), 0);
const int32 nStartY = Max(GetSectorIndexY(fStartY), 0);
#ifdef FIX_BUGS
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 nStartY = Max(CWorld::GetSectorIndexY(vecStartPos.y), 0);
const int32 nEndX = Min(CWorld::GetSectorIndexX(vecEndPos.x), NUMSECTORS_X - 1);
const int32 nEndY = Min(CWorld::GetSectorIndexY(vecEndPos.y), NUMSECTORS_Y - 1);
const int32 nStartX = Max(GetSectorIndexX(vecStartPos.x), 0);
const int32 nStartY = Max(GetSectorIndexY(vecStartPos.y), 0);
#ifdef FIX_BUGS
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 nStartY = Max(CWorld::GetSectorIndexY(fStartY), 0);
const int32 nEndX = Min(CWorld::GetSectorIndexX(fEndX), NUMSECTORS_X - 1);
const int32 nEndY = Min(CWorld::GetSectorIndexY(fEndY), NUMSECTORS_Y - 1);
const int32 nStartX = Max(GetSectorIndexX(fStartX), 0);
const int32 nStartY = Max(GetSectorIndexY(fStartY), 0);
#ifdef FIX_BUGS
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);
@ -1825,37 +1874,55 @@ CWorld::RepositionOneObject(CEntity *pEntity)
{
int16 modelId = pEntity->GetModelIndex();
if (modelId == MI_PARKINGMETER || modelId == MI_PHONEBOOTH1 || modelId == MI_WASTEBIN ||
modelId == MI_BIN || modelId == MI_POSTBOX1 || modelId == MI_NEWSSTAND || modelId == MI_TRAFFICCONE ||
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) ||
IsLightThatNeedsRepositioning(modelId)
modelId == MI_BIN || modelId == MI_POSTBOX1 || modelId == MI_NEWSSTAND || modelId == MI_TRAFFICCONE ||
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)
) {
CVector &position = pEntity->GetMatrix().GetPosition();
CColModel *pColModel = pEntity->GetColModel();
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 (fHeight < OBJECT_REPOSITION_OFFSET_Z) fHeight = OBJECT_REPOSITION_OFFSET_Z;
position.z = CWorld::FindGroundZFor3DCoord(position.x, position.y,
position.z + fHeight, nil) -
fBoundingBoxMinZ;
position.z + fHeight, nil) -
fBoundingBoxMinZ;
pEntity->m_matrix.UpdateRW();
pEntity->UpdateRwFrame();
} else if(modelId == MI_BUOY) {
float fWaterLevel = 0.0f;
} else if(IsLightThatNeedsRepositioning(modelId)) {
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;
}
}
CColModel *pColModel = pEntity->GetColModel();
float fHeight = pColModel->boundingBox.max.z - pColModel->boundingBox.min.z;
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
RpAnimBlendClumpUpdateAnimations(csObj->GetClump(),
0.02f * (csObj->IsObject()
? CTimer::GetTimeStepNonClipped()
: CTimer::GetTimeStep()));
if (csObj->IsObject())
RpAnimBlendClumpUpdateAnimations(csObj->GetClump(), 0.02f * CTimer::GetTimeStepNonClipped());
else {
csObj->bOffscreen = !csObj->GetIsOnScreen();
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
RpAnimBlendClumpUpdateAnimations(movingEnt->GetClump(),
0.02f * (movingEnt->IsObject()
? CTimer::GetTimeStepNonClipped()
: CTimer::GetTimeStep()));
if (movingEnt->IsObject())
RpAnimBlendClumpUpdateAnimations(movingEnt->GetClump(), 0.02f * CTimer::GetTimeStepNonClipped());
else {
movingEnt->bOffscreen = !movingEnt->GetIsOnScreen();
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 nStartY = Max(CWorld::GetSectorIndexY(vecStartPos.y), 0);
const int32 nEndX = Min(CWorld::GetSectorIndexX(vecEndPos.x), NUMSECTORS_X - 1);
const int32 nEndY = Min(CWorld::GetSectorIndexY(vecEndPos.y), NUMSECTORS_Y - 1);
const int32 nStartX = Max(GetSectorIndexX(vecStartPos.x), 0);
const int32 nStartY = Max(GetSectorIndexY(vecStartPos.y), 0);
const int32 nEndX = Min(GetSectorIndexX(vecEndPos.x), NUMSECTORS_X - 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);

20
src/core/World.h
View file

@ -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];

16
src/core/Zones.cpp
View file

@ -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[2] = info->gangPedThreshold[1];
info->gangPedThreshold[3] = info->gangPedThreshold[2];
info->gangPedThreshold[4] = info->gangPedThreshold[3];
info->gangPedThreshold[5] = info->gangPedThreshold[4];
info->gangPedThreshold[6] = info->gangPedThreshold[5];
info->gangPedThreshold[7] = info->gangPedThreshold[6];
info->gangPedThreshold[8] = info->gangPedThreshold[7];
info->gangPedThreshold[1] += info->gangPedThreshold[0];
info->gangPedThreshold[2] += info->gangPedThreshold[1];
info->gangPedThreshold[3] += info->gangPedThreshold[2];
info->gangPedThreshold[4] += info->gangPedThreshold[3];
info->gangPedThreshold[5] += info->gangPedThreshold[4];
info->gangPedThreshold[6] += info->gangPedThreshold[5];
info->gangPedThreshold[7] += info->gangPedThreshold[6];
info->gangPedThreshold[8] += info->gangPedThreshold[7];
}
//--MIAMI: unused

1
src/core/config.h
View file

@ -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

149
src/core/main.cpp
View file

@ -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;
}

5
src/core/main.h
View file

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

24
src/core/re3.cpp
View file

@ -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);

24
src/fakerw/fake.cpp
View file

@ -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;
}

4
src/objects/Object.cpp
View file

@ -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;

2
src/render/Glass.cpp
View file

@ -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;
}

4
src/render/Hud.cpp
View file

@ -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);

659
src/render/Renderer.cpp
View file

@ -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 = dist.MagnitudeSqr();
ei.sort = (ms_vecCameraPosition - e->GetPosition()).MagnitudeSqr();
gSortedVehiclesAndPeds.InsertSorted(ei);
}else{
dist = ms_vecCameraPosition - e->GetPosition();
if(!CVisibilityPlugins::InsertEntityIntoSortedList(e, dist.Magnitude())){
if(!CVisibilityPlugins::InsertEntityIntoSortedList(e, (ms_vecCameraPosition - e->GetPosition()).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;

18
src/render/Renderer.h
View file

@ -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);
};

3
src/render/SpecialFX.cpp
View file

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

21
src/rw/VisibilityPlugins.cpp
View file

@ -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)

3
src/rw/VisibilityPlugins.h
View file

@ -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;

14
src/vehicles/Automobile.cpp
View file

@ -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;

20
src/vehicles/Boat.cpp
View file

@ -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)

3
src/vehicles/Boat.h
View file

@ -62,7 +62,8 @@ public:
virtual void GetComponentWorldPosition(int32 component, CVector &pos);
virtual bool IsComponentPresent(int32 component) { return true; }
virtual void BlowUpCar(CEntity *ent);
void RenderWaterOutPolys(void);
void ApplyWaterResistance(void);
void SetupModelNodes();
void PruneWakeTrail(void);

4
src/weapons/ProjectileInfo.cpp
View file

@ -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) {

4
src/weapons/WeaponEffects.cpp
View file

@ -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;

2
vendor/librw vendored

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

2
vendor/ogg vendored

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

2
vendor/opus vendored

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