mirror of https://github.com/AxioDL/metaforce.git
619 lines
24 KiB
C++
619 lines
24 KiB
C++
#include "CScriptWater.hpp"
|
|
#include "CStateManager.hpp"
|
|
#include "TCastTo.hpp"
|
|
#include "GameGlobalObjects.hpp"
|
|
#include "CSimplePool.hpp"
|
|
#include "World/CWorld.hpp"
|
|
#include "Graphics/CBooRenderer.hpp"
|
|
#include "Camera/CGameCamera.hpp"
|
|
|
|
namespace urde
|
|
{
|
|
|
|
const float CScriptWater::kSplashScales[6] =
|
|
{
|
|
1.0f, 3.0f, 0.709f,
|
|
1.19f, 0.709f, 1.f
|
|
};
|
|
|
|
CScriptWater::CScriptWater(CStateManager& mgr, TUniqueId uid, std::string_view name, const CEntityInfo& info,
|
|
const zeus::CVector3f& pos, const zeus::CAABox& box, const urde::CDamageInfo& dInfo,
|
|
zeus::CVector3f& orientedForce, ETriggerFlags triggerFlags, bool thermalCold,
|
|
bool allowRender, CAssetId patternMap1, CAssetId patternMap2, CAssetId colorMap,
|
|
CAssetId bumpMap, CAssetId envMap, CAssetId envBumpMap, CAssetId unusedMap,
|
|
const zeus::CVector3f& bumpLightDir, float bumpScale, float morphInTime, float morphOutTime,
|
|
bool active, CFluidPlane::EFluidType fluidType, bool b4, float alpha,
|
|
const CFluidUVMotion& uvMot, float turbSpeed, float turbDistance, float turbFreqMax,
|
|
float turbFreqMin, float turbPhaseMax, float turbPhaseMin, float turbAmplitudeMax,
|
|
float turbAmplitudeMin, const zeus::CColor& splashColor, const zeus::CColor& unkColor,
|
|
CAssetId splashParticle1, CAssetId splashParticle2, CAssetId splashParticle3,
|
|
CAssetId visorRunoffParticle, CAssetId unmorphVisorRunoffparticle, s32 visorRunoffSfx,
|
|
s32 unmorphVisorRunoffSfx, s32 splashSfx1, s32 splashSfx2, s32 splashSfx3, float tileSize,
|
|
u32 tileSubdivisions, float specularMin, float specularMax, float reflectionSize,
|
|
float rippleIntensity, float reflectionBlend, float fogBias, float fogMagnitude,
|
|
float fogSpeed, const zeus::CColor& fogColor, CAssetId lightmapId,
|
|
float unitsPerLightmapTexel, float alphaInTime, float alphaOutTime, u32, u32, bool, s32,
|
|
s32, std::unique_ptr<u32[]>&& u32Arr)
|
|
: CScriptTrigger(uid, name, info, pos, box, dInfo, orientedForce, triggerFlags, active, false, false),
|
|
x1b8_positionMorphed(pos), x1c4_extentMorphed(box.max - box.min), x1d0_morphInTime(morphInTime), x1d4_positionOrig(pos),
|
|
x1e0_extentOrig(box.max - box.min), x1ec_damageOrig(dInfo.GetDamage()), x1f0_damageMorphed(dInfo.GetDamage()),
|
|
x1f4_morphOutTime(morphOutTime), x214_fogBias(fogBias), x218_fogMagnitude(fogMagnitude), x21c_origFogBias(fogBias),
|
|
x220_origFogMagnitude(fogMagnitude), x224_fogSpeed(fogSpeed), x228_fogColor(fogColor),
|
|
x22c_splashParticle1Id(splashParticle1), x230_splashParticle2Id(splashParticle2),
|
|
x234_splashParticle3Id(splashParticle3), x238_visorRunoffParticleId(visorRunoffParticle),
|
|
x24c_unmorphVisorRunoffParticleId(unmorphVisorRunoffparticle),
|
|
x260_visorRunoffSfx(CSfxManager::TranslateSFXID(visorRunoffSfx)),
|
|
x262_unmorphVisorRunoffSfx(CSfxManager::TranslateSFXID(unmorphVisorRunoffSfx)),
|
|
x2a4_splashColor(splashColor), x2a8_fogColor(unkColor), x2ac_alphaInTime(alphaInTime), x2b0_alphaOutTime(alphaOutTime),
|
|
x2b4_alphaInRecip((alphaInTime != 0.f) ? 1.f / alphaInTime : 0.f),
|
|
x2b8_alphaOutRecip((alphaOutTime != 0.f) ? 1.f / alphaOutTime : 0.f), x2bc_alpha(alpha), x2c0_tileSize(tileSize)
|
|
{
|
|
zeus::CAABox triggerAABB = GetTriggerBoundsWR();
|
|
x2c4_gridDimX = u32((x2c0_tileSize + triggerAABB.max.x - triggerAABB.min.x - 0.01f) / x2c0_tileSize);
|
|
x2c8_gridDimY = u32((x2c0_tileSize + triggerAABB.max.y - triggerAABB.min.y - 0.01f) / x2c0_tileSize);
|
|
x2cc_gridCellCount = (x2c4_gridDimX + 1) * (x2c8_gridDimY + 1);
|
|
x2e8_24_b4 = b4;
|
|
x2e8_27_allowRender = allowRender;
|
|
x2e8_28_recomputeClipping = true;
|
|
|
|
x1b4_fluidPlane = std::make_unique<CFluidPlaneCPU>(patternMap1, patternMap2, colorMap, bumpMap, envMap, envBumpMap,
|
|
lightmapId, unitsPerLightmapTexel, tileSize, tileSubdivisions,
|
|
fluidType, x2bc_alpha, bumpLightDir, bumpScale, uvMot,
|
|
turbSpeed, turbDistance, turbFreqMax, turbFreqMin, turbPhaseMax,
|
|
turbPhaseMin, turbAmplitudeMax, turbAmplitudeMin, specularMin,
|
|
specularMax, reflectionBlend, reflectionSize, rippleIntensity,
|
|
x2cc_gridCellCount *
|
|
((std::max(u32(2), tileSubdivisions) * 4 + 2) * 4));
|
|
u32Arr.reset();
|
|
x264_splashEffects.resize(3);
|
|
if (x22c_splashParticle1Id.IsValid())
|
|
x264_splashEffects[0].emplace(g_SimplePool->GetObj({FOURCC('PART'), x22c_splashParticle1Id}));
|
|
if (x230_splashParticle2Id.IsValid())
|
|
x264_splashEffects[1].emplace(g_SimplePool->GetObj({FOURCC('PART'), x230_splashParticle2Id}));
|
|
if (x234_splashParticle3Id.IsValid())
|
|
x264_splashEffects[2].emplace(g_SimplePool->GetObj({FOURCC('PART'), x234_splashParticle3Id}));
|
|
if (x238_visorRunoffParticleId.IsValid())
|
|
x23c_visorRunoffEffect.emplace(g_SimplePool->GetObj({FOURCC('PART'), x238_visorRunoffParticleId}));
|
|
if (x24c_unmorphVisorRunoffParticleId.IsValid())
|
|
x250_unmorphVisorRunoffEffect.emplace(g_SimplePool->GetObj({FOURCC('PART'), x24c_unmorphVisorRunoffParticleId}));
|
|
x298_splashSounds.push_back(CSfxManager::TranslateSFXID(splashSfx1));
|
|
x298_splashSounds.push_back(CSfxManager::TranslateSFXID(splashSfx2));
|
|
x298_splashSounds.push_back(CSfxManager::TranslateSFXID(splashSfx3));
|
|
SetCalculateLighting(true);
|
|
if (lightmapId.IsValid())
|
|
x90_actorLights->DisableAreaLights();
|
|
x90_actorLights->SetMaxDynamicLights(4);
|
|
x90_actorLights->SetCastShadows(false);
|
|
x90_actorLights->SetAmbientChannelOverflow(false);
|
|
x90_actorLights->SetFindNearestDynamicLights(true);
|
|
x148_24_detectCamera = true;
|
|
CalculateRenderBounds();
|
|
xe6_27_renderVisorFlags = u8(thermalCold ? 2 : 1);
|
|
if (!x30_24_active)
|
|
{
|
|
x2bc_alpha = 0.f;
|
|
x214_fogBias = 0.f;
|
|
x218_fogMagnitude = 0.f;
|
|
}
|
|
SetupGrid(true);
|
|
}
|
|
|
|
void CScriptWater::SetupGrid(bool recomputeClipping)
|
|
{
|
|
zeus::CAABox triggerAABB = GetTriggerBoundsWR();
|
|
auto dimX = u32((triggerAABB.max.x - triggerAABB.min.x + x2c0_tileSize) / x2c0_tileSize);
|
|
auto dimY = u32((triggerAABB.max.y - triggerAABB.min.y + x2c0_tileSize) / x2c0_tileSize);
|
|
x2e4_gridCellCount2 = x2cc_gridCellCount = (dimX + 1) * (dimY + 1);
|
|
x2dc_vertIntersects.reset();
|
|
if (!x2d8_tileIntersects || dimX != x2c4_gridDimX || dimY != x2c8_gridDimY)
|
|
x2d8_tileIntersects.reset(new bool[dimX * dimY]);
|
|
x2c4_gridDimX = dimX;
|
|
x2c8_gridDimY = dimY;
|
|
for (int i=0 ; i<x2c8_gridDimY ; ++i)
|
|
for (int j=0 ; j<x2c4_gridDimX ; ++j)
|
|
x2d8_tileIntersects[i * x2c4_gridDimX + j] = true;
|
|
if (!x2e0_patchIntersects || x2d0_patchDimX != 0 || x2d4_patchDimY != 0)
|
|
x2e0_patchIntersects.reset(new u8[32]);
|
|
for (int i=0 ; i<32 ; ++i)
|
|
x2e0_patchIntersects[i] = 1;
|
|
x2d4_patchDimY = 0;
|
|
x2d0_patchDimX = 0;
|
|
x2e8_28_recomputeClipping = recomputeClipping;
|
|
}
|
|
|
|
static const CMaterialFilter SolidFilter = CMaterialFilter::MakeInclude({EMaterialTypes::Solid});
|
|
|
|
void CScriptWater::SetupGridClipping(CStateManager& mgr, int computeVerts)
|
|
{
|
|
if (x2e8_28_recomputeClipping)
|
|
{
|
|
x2e4_gridCellCount2 = 0;
|
|
x2dc_vertIntersects.reset();
|
|
x2e8_28_recomputeClipping = false;
|
|
}
|
|
|
|
if (x2e4_gridCellCount2 >= x2cc_gridCellCount)
|
|
return;
|
|
|
|
if (!x2dc_vertIntersects)
|
|
x2dc_vertIntersects.reset(new bool[(x2c4_gridDimX + 1) * (x2c8_gridDimY + 1)]);
|
|
zeus::CAABox triggerBounds = GetTriggerBoundsWR();
|
|
zeus::CVector3f basePos = triggerBounds.min;
|
|
basePos.z = triggerBounds.max.z + 0.8f;
|
|
auto gridDiv = std::div(int(x2e4_gridCellCount2), int(x2c4_gridDimX + 1));
|
|
float yOffset = x2c0_tileSize * gridDiv.quot;
|
|
float xOffset = x2c0_tileSize * gridDiv.rem;
|
|
float mag = std::min(120.f, 2.f * (x130_bounds.max.z - x130_bounds.min.z) + 0.8f);
|
|
for (int i = x2e4_gridCellCount2; i < std::min(x2e4_gridCellCount2 + computeVerts, x2cc_gridCellCount); ++i)
|
|
{
|
|
zeus::CVector3f pos = basePos;
|
|
pos.x += xOffset;
|
|
pos.y += yOffset;
|
|
x2dc_vertIntersects[i] = mgr.RayStaticIntersection(pos, zeus::CVector3f::skDown, mag, SolidFilter).IsValid();
|
|
gridDiv.rem += 1;
|
|
xOffset += x2c0_tileSize;
|
|
if (gridDiv.rem > x2c4_gridDimX)
|
|
{
|
|
yOffset += x2c0_tileSize;
|
|
xOffset = 0.f;
|
|
gridDiv.rem = 0;
|
|
}
|
|
}
|
|
x2e4_gridCellCount2 += computeVerts;
|
|
if (x2e4_gridCellCount2 < x2cc_gridCellCount)
|
|
return;
|
|
|
|
x2e4_gridCellCount2 = x2cc_gridCellCount;
|
|
x2d8_tileIntersects.reset(new bool[x2c4_gridDimX * x2c8_gridDimY]);
|
|
|
|
for (int i = 0; i < x2c8_gridDimY; ++i)
|
|
{
|
|
int rowBase = x2c4_gridDimX * i;
|
|
int nextRowBase = (x2c4_gridDimX + 1) * i;
|
|
for (int j = 0; j < x2c4_gridDimX; ++j)
|
|
{
|
|
x2d8_tileIntersects[rowBase + j] =
|
|
x2dc_vertIntersects[nextRowBase + j] ||
|
|
x2dc_vertIntersects[nextRowBase + j + 1] ||
|
|
x2dc_vertIntersects[nextRowBase + j + x2c4_gridDimX + 1] ||
|
|
x2dc_vertIntersects[nextRowBase + j + x2c4_gridDimX + 2];
|
|
}
|
|
}
|
|
|
|
int tilesPerPatch = std::min(42 / x1b4_fluidPlane->GetTileSubdivisions(), 7);
|
|
x2d0_patchDimX = (tilesPerPatch + x2c4_gridDimX - 1) / tilesPerPatch;
|
|
x2d4_patchDimY = (tilesPerPatch + x2c8_gridDimY - 1) / tilesPerPatch;
|
|
x2e0_patchIntersects.reset(new u8[x2d0_patchDimX * x2d4_patchDimY]);
|
|
int curTileY = 0;
|
|
int nextTileY;
|
|
for (int i=0 ; i<x2d4_patchDimY ; ++i, curTileY = nextTileY)
|
|
{
|
|
nextTileY = curTileY + tilesPerPatch;
|
|
int curTileX = 0;
|
|
int rowBase = x2d0_patchDimX * i;
|
|
for (int j=0 ; j<x2d0_patchDimX ; ++j)
|
|
{
|
|
int nextTileX = curTileX + tilesPerPatch;
|
|
bool allClear = true;
|
|
bool allIntersections = true;
|
|
for (int k=curTileY ; k<std::min(nextTileY, x2c8_gridDimY) ; ++k)
|
|
{
|
|
if (!allClear && !allIntersections)
|
|
break;
|
|
for (int l=curTileX ; l<std::min(nextTileX, x2c4_gridDimX) ; ++l)
|
|
{
|
|
if (x2d8_tileIntersects[k * x2c4_gridDimX + l])
|
|
{
|
|
allClear = false;
|
|
if (!allIntersections)
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
allIntersections = false;
|
|
if (!allClear)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
u8 flag;
|
|
if (allIntersections)
|
|
flag = 1;
|
|
else if (allClear)
|
|
flag = 0;
|
|
else
|
|
flag = 2;
|
|
x2e0_patchIntersects[rowBase + j] = flag;
|
|
curTileX += tilesPerPatch;
|
|
}
|
|
}
|
|
|
|
x2dc_vertIntersects.reset();
|
|
}
|
|
|
|
void CScriptWater::UpdateSplashInhabitants(CStateManager& mgr)
|
|
{
|
|
for (auto it = x1fc_waterInhabitants.begin() ; it != x1fc_waterInhabitants.end() ;)
|
|
{
|
|
auto& inhab = *it;
|
|
TCastToPtr<CActor> act = mgr.ObjectById(inhab.first);
|
|
bool intersects = false;
|
|
if (act)
|
|
{
|
|
if (auto tb = act->GetTouchBounds())
|
|
{
|
|
zeus::CAABox thisTb = GetTriggerBoundsWR();
|
|
if (tb->min.z <= thisTb.max.z && tb->max.z >= thisTb.max.z)
|
|
intersects = true;
|
|
}
|
|
}
|
|
|
|
if (act && inhab.second)
|
|
{
|
|
if (intersects)
|
|
act->FluidFXThink(EFluidState::InFluid, *this, mgr);
|
|
mgr.SendScriptMsg(act.GetPtr(), GetUniqueId(), EScriptObjectMessage::UpdateSplashInhabitant);
|
|
inhab.second = false;
|
|
}
|
|
else
|
|
{
|
|
it = x1fc_waterInhabitants.erase(it);
|
|
if (act)
|
|
{
|
|
if (intersects)
|
|
act->FluidFXThink(EFluidState::LeftFluid, *this, mgr);
|
|
mgr.SendScriptMsg(act.GetPtr(), GetUniqueId(), EScriptObjectMessage::RemoveSplashInhabitant);
|
|
}
|
|
continue;
|
|
}
|
|
++it;
|
|
}
|
|
}
|
|
|
|
void CScriptWater::Think(float dt, CStateManager& mgr)
|
|
{
|
|
if (!x30_24_active)
|
|
return;
|
|
|
|
bool oldCamSubmerged = x148_25_camSubmerged;
|
|
CScriptTrigger::Think(dt, mgr);
|
|
|
|
CGameCamera* curCam = mgr.GetCameraManager()->GetCurrentCamera(mgr);
|
|
if (x148_25_camSubmerged && !oldCamSubmerged)
|
|
mgr.SendScriptMsg(curCam, x8_uid, EScriptObjectMessage::AddSplashInhabitant);
|
|
else if (!x148_25_camSubmerged && oldCamSubmerged)
|
|
mgr.SendScriptMsg(curCam, x8_uid, EScriptObjectMessage::RemoveSplashInhabitant);
|
|
|
|
UpdateSplashInhabitants(mgr);
|
|
|
|
if (x2e8_30_alphaOut)
|
|
{
|
|
x2bc_alpha -= x2b8_alphaOutRecip * dt * x1b4_fluidPlane->GetAlpha();
|
|
x214_fogBias -= x2b8_alphaOutRecip * dt * x21c_origFogBias;
|
|
x218_fogMagnitude -= x2b8_alphaOutRecip * dt * x220_origFogMagnitude;
|
|
if (x2bc_alpha <= 0.f)
|
|
{
|
|
x218_fogMagnitude = 0.f;
|
|
x214_fogBias = 0.f;
|
|
x2bc_alpha = 0.f;
|
|
x2e8_30_alphaOut = false;
|
|
}
|
|
}
|
|
else if (x2e8_29_alphaIn)
|
|
{
|
|
x2bc_alpha += x2b4_alphaInRecip * dt * x1b4_fluidPlane->GetAlpha();
|
|
x214_fogBias -= x2b4_alphaInRecip * dt * x21c_origFogBias;
|
|
x218_fogMagnitude -= x2b4_alphaInRecip * dt * x220_origFogMagnitude;
|
|
if (x2bc_alpha > x1b4_fluidPlane->GetAlpha())
|
|
{
|
|
x2bc_alpha = x1b4_fluidPlane->GetAlpha();
|
|
x214_fogBias = x21c_origFogBias;
|
|
x218_fogMagnitude = x220_origFogMagnitude;
|
|
x2e8_29_alphaIn = false;
|
|
}
|
|
}
|
|
|
|
if (x2e8_26_morphing)
|
|
{
|
|
bool stillMorphing = true;
|
|
if (x2e8_25_morphIn)
|
|
{
|
|
x1f8_morphFactor += dt / x1d0_morphInTime;
|
|
if (x1f8_morphFactor > 1.f)
|
|
{
|
|
x1f8_morphFactor = 1.f;
|
|
stillMorphing = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
x1f8_morphFactor -= dt / x1f4_morphOutTime;
|
|
if (x1f8_morphFactor < 0.f)
|
|
{
|
|
x1f8_morphFactor = 0.f;
|
|
stillMorphing = false;
|
|
}
|
|
}
|
|
|
|
SetTranslation(zeus::CVector3f::lerp(x1d4_positionOrig, x1b8_positionMorphed, x1f8_morphFactor));
|
|
zeus::CVector3f lerpExtent = zeus::CVector3f::lerp(x1e0_extentOrig, x1c4_extentMorphed, x1f8_morphFactor);
|
|
x130_bounds = zeus::CAABox(lerpExtent * -0.5f, lerpExtent * 0.5f);
|
|
CalculateRenderBounds();
|
|
|
|
if (!stillMorphing)
|
|
SetMorphing(false);
|
|
else
|
|
SetupGrid(false);
|
|
}
|
|
|
|
SetupGridClipping(mgr, 4);
|
|
}
|
|
|
|
void CScriptWater::AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId other, CStateManager& mgr)
|
|
{
|
|
switch (msg)
|
|
{
|
|
case EScriptObjectMessage::Next:
|
|
if (!x30_24_active)
|
|
break;
|
|
x2e8_25_morphIn = !x2e8_25_morphIn;
|
|
if (x2e8_25_morphIn)
|
|
{
|
|
for (const SConnection& conn : x20_conns)
|
|
{
|
|
if (conn.x0_state != EScriptObjectState::Play ||
|
|
conn.x4_msg != EScriptObjectMessage::Activate)
|
|
continue;
|
|
auto list = mgr.GetIdListForScript(conn.x8_objId);
|
|
if (list.first == mgr.GetIdListEnd())
|
|
continue;
|
|
if (TCastToConstPtr<CScriptTrigger> trig = mgr.GetObjectById(list.first->second))
|
|
{
|
|
x1b8_positionMorphed = trig->GetTranslation();
|
|
x1c4_extentMorphed = trig->GetTriggerBoundsOR().max - trig->GetTriggerBoundsOR().min;
|
|
x1f0_damageMorphed = trig->GetDamageInfo().GetDamage();
|
|
x1d4_positionOrig = GetTranslation();
|
|
x1e0_extentOrig = x130_bounds.max - x130_bounds.min;
|
|
x1ec_damageOrig = x100_damageInfo.GetDamage();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
SetMorphing(true);
|
|
break;
|
|
case EScriptObjectMessage::Activate:
|
|
x2e8_30_alphaOut = false;
|
|
if (std::fabs(x2ac_alphaInTime) < 0.00001f)
|
|
{
|
|
x2bc_alpha = x1b4_fluidPlane->GetAlpha();
|
|
x214_fogBias = x21c_origFogBias;
|
|
x218_fogMagnitude = x220_origFogMagnitude;
|
|
}
|
|
else
|
|
{
|
|
x2e8_29_alphaIn = true;
|
|
}
|
|
break;
|
|
case EScriptObjectMessage::Action:
|
|
x2e8_29_alphaIn = false;
|
|
if (std::fabs(x2b0_alphaOutTime) < 0.00001f)
|
|
{
|
|
x2bc_alpha = 0.f;
|
|
x214_fogBias = 0.f;
|
|
x218_fogMagnitude = 0.f;
|
|
}
|
|
else
|
|
{
|
|
x2e8_30_alphaOut = true;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
CScriptTrigger::AcceptScriptMsg(msg, other, mgr);
|
|
}
|
|
|
|
void CScriptWater::PreRender(CStateManager& mgr, const zeus::CFrustum& frustum)
|
|
{
|
|
if (x2e8_27_allowRender)
|
|
{
|
|
zeus::CAABox aabb = GetSortingBounds(mgr);
|
|
xe4_30_outOfFrustum = !frustum.aabbFrustumTest(aabb);
|
|
if (!xe4_30_outOfFrustum)
|
|
{
|
|
if (x4_areaId != kInvalidAreaId)
|
|
{
|
|
if (x90_actorLights->GetMaxAreaLights() &&
|
|
(xe4_29_actorLightsDirty || x90_actorLights->GetIsDirty()))
|
|
{
|
|
const CGameArea* area = mgr.GetWorld()->GetAreaAlways(x4_areaId);
|
|
if (area->IsPostConstructed())
|
|
{
|
|
x90_actorLights->BuildAreaLightList(mgr, *area, GetTriggerBoundsWR());
|
|
xe4_29_actorLightsDirty = false;
|
|
}
|
|
}
|
|
x90_actorLights->BuildDynamicLightList(mgr, GetTriggerBoundsWR());
|
|
}
|
|
x150_frustum = frustum;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
xe4_30_outOfFrustum = true;
|
|
}
|
|
}
|
|
|
|
void CScriptWater::AddToRenderer(const zeus::CFrustum& /*frustum*/, const CStateManager& mgr) const
|
|
{
|
|
if (!xe4_30_outOfFrustum)
|
|
{
|
|
zeus::CPlane plane;
|
|
plane.vec = x34_transform.origin.normalized();
|
|
plane.d = x34_transform.origin.z + x130_bounds.max.z;
|
|
zeus::CAABox renderBounds = GetSortingBounds(mgr);
|
|
mgr.AddDrawableActorPlane(*this, plane, renderBounds);
|
|
}
|
|
}
|
|
|
|
void CScriptWater::Render(const CStateManager& mgr) const
|
|
{
|
|
if (x30_24_active && !xe4_30_outOfFrustum)
|
|
{
|
|
float zOffset = 0.5f * (x9c_renderBounds.max.z + x9c_renderBounds.min.z) - x34_transform.origin.z;
|
|
zeus::CAABox aabb = x9c_renderBounds.getTransformedAABox(
|
|
zeus::CTransform::Translate(-x34_transform.origin.x, -x34_transform.origin.y,
|
|
-x34_transform.origin.z - zOffset));
|
|
zeus::CTransform xf = x34_transform;
|
|
xf.origin.z += zOffset;
|
|
zeus::CVector3f areaCenter = mgr.GetWorld()->GetAreaAlways(mgr.GetNextAreaId())->GetAABB().center();
|
|
std::experimental::optional<CRippleManager> rippleMan(mgr.GetFluidPlaneManager()->GetRippleManager());
|
|
x1b4_fluidPlane->Render(mgr, x2bc_alpha, aabb, xf,
|
|
mgr.GetWorld()->GetAreaAlways(x4_areaId)->GetTransform(), false,
|
|
x150_frustum, rippleMan, x8_uid, x2d8_tileIntersects.get(),
|
|
x2c4_gridDimX, x2c8_gridDimY, areaCenter);
|
|
if (x214_fogBias != 0.f)
|
|
{
|
|
if (mgr.GetPlayerState()->CanVisorSeeFog(mgr))
|
|
{
|
|
float fogLevel = mgr.IntegrateVisorFog(x218_fogMagnitude *
|
|
std::sin(x224_fogSpeed * CGraphics::GetSecondsMod900()) +
|
|
x214_fogBias);
|
|
if (fogLevel > 0.f)
|
|
{
|
|
zeus::CAABox fogBox = GetTriggerBoundsWR();
|
|
fogBox.min.z = fogBox.max.z;
|
|
fogBox.max.z += fogLevel;
|
|
zeus::CTransform modelXf = zeus::CTransform::Translate(fogBox.center()) *
|
|
zeus::CTransform::Scale((fogBox.max - fogBox.min) * 0.5f);
|
|
zeus::CAABox renderAABB(zeus::CVector3f::skNegOne, zeus::CVector3f::skOne);
|
|
CGraphics::SetModelMatrix(modelXf);
|
|
g_Renderer->SetAmbientColor(zeus::CColor::skWhite);
|
|
g_Renderer->RenderFogVolume(x228_fogColor, renderAABB, nullptr, nullptr);
|
|
}
|
|
}
|
|
}
|
|
CGraphics::DisableAllLights();
|
|
}
|
|
CActor::Render(mgr);
|
|
}
|
|
|
|
void CScriptWater::Touch(CActor& otherAct, CStateManager& mgr)
|
|
{
|
|
if (!x30_24_active)
|
|
return;
|
|
|
|
CScriptTrigger::Touch(otherAct, mgr);
|
|
if (otherAct.GetMaterialList().HasMaterial(EMaterialTypes::Trigger))
|
|
return;
|
|
|
|
for (auto& inhab : x1fc_waterInhabitants)
|
|
if (inhab.first == otherAct.GetUniqueId())
|
|
{
|
|
inhab.second = true;
|
|
return;
|
|
}
|
|
|
|
auto touchBounds = otherAct.GetTouchBounds();
|
|
if (!touchBounds)
|
|
return;
|
|
|
|
x1fc_waterInhabitants.emplace_back(otherAct.GetUniqueId(), true);
|
|
float triggerMaxZ = GetTriggerBoundsWR().max.z;
|
|
if (touchBounds->min.z <= triggerMaxZ && touchBounds->max.z >= triggerMaxZ)
|
|
otherAct.FluidFXThink(EFluidState::EnteredFluid, *this, mgr);
|
|
|
|
mgr.SendScriptMsg(&otherAct, x8_uid, EScriptObjectMessage::AddSplashInhabitant);
|
|
}
|
|
|
|
void CScriptWater::CalculateRenderBounds()
|
|
{
|
|
zeus::CVector3f aabbMin = x130_bounds.min;
|
|
aabbMin.z = x130_bounds.max.z - 1.f;
|
|
zeus::CVector3f aabbMax = x130_bounds.max;
|
|
aabbMax.z += 1.f;
|
|
zeus::CVector3f transAABBMin = aabbMin + GetTranslation();
|
|
zeus::CVector3f transAABBMax = aabbMax + GetTranslation();
|
|
x9c_renderBounds = zeus::CAABox(transAABBMin, transAABBMax);
|
|
}
|
|
|
|
zeus::CAABox CScriptWater::GetSortingBounds(const CStateManager& mgr) const
|
|
{
|
|
zeus::CVector3f max = x9c_renderBounds.max;
|
|
max.z = std::max(max.z, x9c_renderBounds.max.z - 1.f + x214_fogBias + x218_fogMagnitude);
|
|
return {x9c_renderBounds.min, max};
|
|
}
|
|
|
|
EWeaponCollisionResponseTypes CScriptWater::GetCollisionResponseType(const zeus::CVector3f&, const zeus::CVector3f&,
|
|
const CWeaponMode&, int) const
|
|
{
|
|
return EWeaponCollisionResponseTypes::Water;
|
|
}
|
|
|
|
s16 CScriptWater::GetSplashSound(float dt) const
|
|
{
|
|
return x298_splashSounds[GetSplashIndex(dt)];
|
|
}
|
|
|
|
const std::experimental::optional<TLockedToken<CGenDescription>>& CScriptWater::GetSplashEffect(float dt) const
|
|
{
|
|
return x264_splashEffects[GetSplashIndex(dt)];
|
|
}
|
|
|
|
float CScriptWater::GetSplashEffectScale(float dt) const
|
|
{
|
|
if (std::fabs(dt - 1.f) < 0.00001f)
|
|
return kSplashScales[5];
|
|
|
|
u32 idx = GetSplashIndex(dt);
|
|
float s = dt - zeus::floorF(dt * 3.f);
|
|
return ((1.f - s) * (s * kSplashScales[idx * 2])) + kSplashScales[idx];
|
|
}
|
|
|
|
u32 CScriptWater::GetSplashIndex(float dt) const
|
|
{
|
|
auto idx = u32(dt * 3.f);
|
|
return (idx < 3 ? idx : idx - 1);
|
|
}
|
|
|
|
void CScriptWater::SetMorphing(bool m)
|
|
{
|
|
if (m == x2e8_26_morphing)
|
|
return;
|
|
x2e8_26_morphing = m;
|
|
SetupGrid(!m);
|
|
}
|
|
|
|
const CScriptWater* CScriptWater::GetNextConnectedWater(const CStateManager& mgr) const
|
|
{
|
|
for (const SConnection& conn : x20_conns)
|
|
{
|
|
if (conn.x0_state != EScriptObjectState::Play || conn.x4_msg != EScriptObjectMessage::Activate)
|
|
continue;
|
|
auto its = mgr.GetIdListForScript(conn.x8_objId);
|
|
if (its.first != mgr.GetIdListEnd())
|
|
if (TCastToConstPtr<CScriptWater> water = mgr.GetObjectById(its.first->second))
|
|
return water.GetPtr();
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
bool CScriptWater::CanRippleAtPoint(const zeus::CVector3f& point) const
|
|
{
|
|
if (!x2d8_tileIntersects)
|
|
return true;
|
|
|
|
auto xTile = int((point.x - GetTriggerBoundsOR().min.x) / x2c0_tileSize);
|
|
if (xTile < 0 || xTile >= x2c4_gridDimX)
|
|
return false;
|
|
|
|
auto yTile = int((point.y - GetTriggerBoundsOR().min.y) / x2c0_tileSize);
|
|
if (xTile < 0 || xTile >= x2c8_gridDimY)
|
|
return false;
|
|
|
|
return x2d8_tileIntersects[yTile * x2c4_gridDimX + xTile];
|
|
}
|
|
}
|