AxioDL
/
metaforce
mirror of https://github.com/AxioDL/metaforce.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
metaforce/Runtime/World/CFluidPlane.cpp

480 lines
21 KiB
C++
Raw Permalink Normal View History

RuntimeCommonB: Normalize cpp file includes Like the prior changes normalizing the inclusions within headers, this tackles the cpp files of the RuntimeCommonB target, making these source files consistent with their headers.
2019-12-22 20:04:07 +00:00
#include "Runtime/World/CFluidPlane.hpp"
#include "Runtime/CSimplePool.hpp"
#include "Runtime/CStateManager.hpp"
#include "Runtime/GameGlobalObjects.hpp"
#include "Runtime/World/CRipple.hpp"
#include "Runtime/World/CScriptWater.hpp"
Various Implementations
2016-11-20 21:53:15 +00:00
Rename everything
2021-04-10 08:42:06 +00:00
namespace metaforce {
Implement class declaration for CFluidPlane/CFluidPlaneCPU
2017-08-06 07:15:42 +00:00
Merge branch 'master' of https://github.com/AxioDL/urde
2017-08-13 08:19:33 +00:00
CFluidPlane::CFluidPlane(CAssetId texPattern1, CAssetId texPattern2, CAssetId texColor, float alpha,
EFluidType fluidType, float rippleIntensity, const CFluidUVMotion& motion)
New code style refactor
2018-12-08 05:30:43 +00:00
: x4_texPattern1Id(texPattern1)
, x8_texPattern2Id(texPattern2)
, xc_texColorId(texColor)
, x40_alpha(alpha)
, x44_fluidType(fluidType)
, x48_rippleIntensity(rippleIntensity)
, x4c_uvMotion(motion) {
if (g_ResFactory->GetResourceTypeById(texPattern1) == FOURCC('TXTR'))
x10_texPattern1 = g_SimplePool->GetObj(SObjectTag{FOURCC('TXTR'), texPattern1});
if (g_ResFactory->GetResourceTypeById(texPattern2) == FOURCC('TXTR'))
x20_texPattern2 = g_SimplePool->GetObj(SObjectTag{FOURCC('TXTR'), texPattern2});
if (g_ResFactory->GetResourceTypeById(texColor) == FOURCC('TXTR'))
x30_texColor = g_SimplePool->GetObj(SObjectTag{FOURCC('TXTR'), texColor});
Various Implementations
2016-11-20 21:53:15 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
float CFluidPlane::ProjectRippleVelocity(float baseI, float velDot) const {
float tmp = 0.5f * baseI * velDot * velDot;
if (tmp != 0.f)
tmp = std::sqrt(tmp);
if (tmp >= 160.f)
return 1.f;
return tmp / 160.f;
Implement CFluidPlaneDoor and CScriptDamageableTrigger
2017-08-14 03:55:06 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
float CFluidPlane::CalculateRippleIntensity(float baseI) const {
CFluidPlane: Always initialize mul to 0.0f in CalculateRippleIntensity() Avoids a -Wmaybe-uninitialized warning.
2020-03-24 09:13:58 +00:00
float mul = 0.0f;
New code style refactor
2018-12-08 05:30:43 +00:00
switch (x44_fluidType) {
case EFluidType::NormalWater:
mul = g_tweakGame->GetRippleIntensityNormal();
break;
case EFluidType::PoisonWater:
mul = g_tweakGame->GetRippleIntensityPoison();
break;
case EFluidType::Lava:
mul = g_tweakGame->GetRippleIntensityLava();
break;
case EFluidType::PhazonFluid:
case EFluidType::Four:
mul = 0.8f;
break;
case EFluidType::ThickLava:
mul = 1.f;
break;
}
return zeus::clamp(0.f, baseI * mul * (1.f - x48_rippleIntensity + 0.5f), 1.f);
Implement CFluidPlaneDoor and CScriptDamageableTrigger
2017-08-14 03:55:06 +00:00
}
Initial collision testing and CStateManager work
2017-03-30 22:36:18 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
void CFluidPlane::AddRipple(float mag, TUniqueId rippler, const zeus::CVector3f& center, CScriptWater& water,
CStateManager& mgr) {
if (!water.CanRippleAtPoint(center))
return;
Implement CFluidPlaneDoor and CScriptDamageableTrigger
2017-08-14 03:55:06 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
mag = CalculateRippleIntensity(mag);
mgr.GetFluidPlaneManager()->RippleManager().AddRipple(CRipple(rippler, center, mag));
Initial collision testing and CStateManager work
2017-03-30 22:36:18 +00:00
}
Implement CFluidPlaneDoor and CScriptDamageableTrigger
2017-08-14 03:55:06 +00:00
void CFluidPlane::AddRipple(float intensity, TUniqueId rippler, const zeus::CVector3f& center,
const zeus::CVector3f& velocity, const CScriptWater& water, CStateManager& mgr,
New code style refactor
2018-12-08 05:30:43 +00:00
const zeus::CVector3f& upVec) {
if (!water.CanRippleAtPoint(center))
return;
Various Implementations
2016-11-20 21:53:15 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
intensity = CalculateRippleIntensity(ProjectRippleVelocity(intensity, upVec.dot(velocity)));
mgr.GetFluidPlaneManager()->RippleManager().AddRipple(CRipple(rippler, center, intensity));
Implement CFluidPlaneDoor and CScriptDamageableTrigger
2017-08-14 03:55:06 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CFluidPlane::AddRipple(const CRipple& ripple, const CScriptWater& water, CStateManager& mgr) {
if (!water.CanRippleAtPoint(ripple.GetCenter()))
return;
mgr.GetFluidPlaneManager()->RippleManager().AddRipple(ripple);
Various Implementations
2016-11-20 21:53:15 +00:00
}
Implement CFluidPlaneGPU for GPU-computed water ripples
2018-06-07 04:43:26 +00:00
CFluidPlane: Make use of std::array where applicable Makes all the arrays strongly typed. We can also use type aliases to greatly shorten some type definitions.
2020-04-12 13:52:36 +00:00
void CFluidPlane::RenderStripWithRipples(float curY, const Heights& heights, const Flags& flags, int startYDiv,
Implement CFluidPlaneGPU for GPU-computed water ripples
2018-06-07 04:43:26 +00:00
const CFluidPlaneRender::SPatchInfo& info,
std::vector<CFluidPlaneShader::Vertex>& vOut,
CFluidPlane: Resolve constness related compile errors that slipped through Gotta love Find References not, in fact, finding all the references.
2020-04-06 09:29:05 +00:00
std::vector<CFluidPlaneShader::PatchVertex>& pvOut) {
New code style refactor
2018-12-08 05:30:43 +00:00
m_shader->bindRegular();
int yTile = (startYDiv + CFluidPlaneRender::numSubdivisionsInTile - 1) / CFluidPlaneRender::numSubdivisionsInTile;
int endXTile =
(info.x0_xSubdivs + CFluidPlaneRender::numSubdivisionsInTile - 4) / CFluidPlaneRender::numSubdivisionsInTile;
int midDiv = CFluidPlaneRender::numSubdivisionsInTile / 2;
float tileMid = info.x18_rippleResolution * midDiv;
float yMin = curY;
float yMid = curY + tileMid;
float curX = info.x4_localMin.x();
int gridCell = info.x28_tileX + info.x2a_gridDimX * (info.x2e_tileY + yTile - 1);
int xTile = 1;
int tileSpan;
for (int i = 1; i < info.x0_xSubdivs - 2; i += CFluidPlaneRender::numSubdivisionsInTile * tileSpan,
gridCell += tileSpan, xTile += tileSpan, curX += info.x14_tileSize * tileSpan) {
tileSpan = 1;
if (info.x30_gridFlags && !info.x30_gridFlags[gridCell])
continue;
if ((flags[yTile][xTile] & 0x1f) == 0x1f) {
for (; xTile + tileSpan <= endXTile; ++tileSpan) {
if ((flags[yTile][xTile + tileSpan] & 0x1f) != 0x1f)
break;
if (info.x30_gridFlags && !info.x30_gridFlags[gridCell + tileSpan])
break;
}
int stripDivCount = tileSpan * CFluidPlaneRender::numSubdivisionsInTile + 1;
int remSubdivs = CFluidPlaneRender::numSubdivisionsInTile;
std::function<void(float x, float y, const CFluidPlaneRender::SHFieldSample& samp)> func;
switch (info.x37_normalMode) {
case CFluidPlaneRender::NormalMode::None:
func = [&](float x, float y, const CFluidPlaneRender::SHFieldSample& samp) {
vOut.emplace_back(zeus::CVector3f(x, y, samp.height));
};
break;
case CFluidPlaneRender::NormalMode::NoNormals:
func = [&](float x, float y, const CFluidPlaneRender::SHFieldSample& samp) {
vOut.emplace_back(zeus::CVector3f(x, y, samp.height), samp.MakeColor(info));
};
break;
case CFluidPlaneRender::NormalMode::Normals:
func = [&](float x, float y, const CFluidPlaneRender::SHFieldSample& samp) {
vOut.emplace_back(zeus::CVector3f(x, y, samp.height), samp.MakeNormal(), samp.MakeColor(info));
};
break;
case CFluidPlaneRender::NormalMode::NBT:
func = [&](float x, float y, const CFluidPlaneRender::SHFieldSample& samp) {
vOut.emplace_back(zeus::CVector3f(x, y, samp.height), samp.MakeNormal(), samp.MakeBinormal(),
samp.MakeTangent(), samp.MakeColor(info));
};
break;
}
float curTileY = yMin;
int curYDiv = startYDiv;
for (; remSubdivs > 0; --remSubdivs, ++curYDiv, curTileY += info.x18_rippleResolution) {
size_t start = vOut.size();
float curTileX = curX;
for (int v = 0; v < stripDivCount; ++v) {
func(curTileX, curTileY, heights[curYDiv][i + v]);
func(curTileX, curTileY + info.x18_rippleResolution, heights[curYDiv + 1][i + v]);
curTileX += info.x18_rippleResolution;
}
CGraphics::DrawArray(start, vOut.size() - start);
}
} else {
bool r19 = (flags[yTile + 1][xTile] & 0x2) != 0; // North
bool r16 = (flags[yTile][xTile - 1] & 0x8) != 0; // West
bool r18 = (flags[yTile][xTile + 1] & 0x4) != 0; // East
bool r17 = (flags[yTile - 1][xTile] & 0x1) != 0; // South
int r6 = (r19 ? CFluidPlaneRender::numSubdivisionsInTile : 1) + 2;
r6 += r18 ? CFluidPlaneRender::numSubdivisionsInTile : 1;
r6 += r17 ? CFluidPlaneRender::numSubdivisionsInTile : 1;
r6 += r16 ? CFluidPlaneRender::numSubdivisionsInTile : 1;
if (r6 == 6 && (info.x37_normalMode == CFluidPlaneRender::NormalMode::Normals ||
info.x37_normalMode == CFluidPlaneRender::NormalMode::NBT)) {
for (; xTile + tileSpan <= endXTile; ++tileSpan) {
if ((flags[yTile][xTile + tileSpan] & 0x1f) == 0x1f)
break;
if (info.x30_gridFlags && !info.x30_gridFlags[gridCell + tileSpan])
break;
if ((flags[yTile + 1][xTile + tileSpan] & 0x2) != 0x0)
break;
if ((flags[yTile][xTile + tileSpan + 1] & 0x4) != 0x0)
break;
if ((flags[yTile - 1][xTile + tileSpan] & 0x1) != 0x0)
break;
}
Implement CFluidPlaneGPU for GPU-computed water ripples
2018-06-07 04:43:26 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
int stripDivCount = tileSpan + 1;
size_t start = vOut.size();
switch (info.x37_normalMode) {
case CFluidPlaneRender::NormalMode::Normals: {
int curYDiv0 = startYDiv;
int curYDiv1 = startYDiv + CFluidPlaneRender::numSubdivisionsInTile;
float curTileX = curX;
for (int v = 0; v < stripDivCount; ++v) {
int curXDiv = v * CFluidPlaneRender::numSubdivisionsInTile + i;
const CFluidPlaneRender::SHFieldSample& samp0 = heights[curYDiv0][curXDiv];
const CFluidPlaneRender::SHFieldSample& samp1 = heights[curYDiv1][curXDiv];
vOut.emplace_back(zeus::CVector3f(curTileX, yMin, samp0.height), samp0.MakeNormal(), samp0.MakeColor(info));
vOut.emplace_back(zeus::CVector3f(curTileX, yMin + info.x14_tileSize, samp1.height), samp1.MakeNormal(),
samp1.MakeColor(info));
curTileX += info.x14_tileSize;
}
break;
}
case CFluidPlaneRender::NormalMode::NBT: {
int curYDiv0 = startYDiv;
int curYDiv1 = startYDiv + CFluidPlaneRender::numSubdivisionsInTile;
float curTileX = curX;
for (int v = 0; v < stripDivCount; ++v) {
int curXDiv = v * CFluidPlaneRender::numSubdivisionsInTile + i;
const CFluidPlaneRender::SHFieldSample& samp0 = heights[curYDiv0][curXDiv];
const CFluidPlaneRender::SHFieldSample& samp1 = heights[curYDiv1][curXDiv];
vOut.emplace_back(zeus::CVector3f(curTileX, yMin, samp0.height), samp0.MakeNormal(), samp0.MakeBinormal(),
samp0.MakeTangent(), samp0.MakeColor(info));
vOut.emplace_back(zeus::CVector3f(curTileX, yMin + info.x14_tileSize, samp1.height), samp1.MakeNormal(),
samp1.MakeBinormal(), samp1.MakeTangent(), samp1.MakeColor(info));
curTileX += info.x14_tileSize;
}
break;
}
default:
break;
}
CGraphics::DrawArray(start, vOut.size() - start);
} else {
TriFanToStrip<CFluidPlaneShader::Vertex> toStrip(vOut);
std::function<void(float x, float y, const CFluidPlaneRender::SHFieldSample& samp)> func;
Implement CFluidPlaneGPU for GPU-computed water ripples
2018-06-07 04:43:26 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
switch (info.x37_normalMode) {
case CFluidPlaneRender::NormalMode::None:
func = [&](float x, float y, const CFluidPlaneRender::SHFieldSample& samp) {
toStrip.EmplaceVert(zeus::CVector3f(x, y, samp.height));
};
break;
case CFluidPlaneRender::NormalMode::NoNormals:
func = [&](float x, float y, const CFluidPlaneRender::SHFieldSample& samp) {
toStrip.EmplaceVert(zeus::CVector3f(x, y, samp.height), samp.MakeColor(info));
};
break;
case CFluidPlaneRender::NormalMode::Normals:
func = [&](float x, float y, const CFluidPlaneRender::SHFieldSample& samp) {
toStrip.EmplaceVert(zeus::CVector3f(x, y, samp.height), samp.MakeNormal(), samp.MakeColor(info));
};
break;
case CFluidPlaneRender::NormalMode::NBT:
func = [&](float x, float y, const CFluidPlaneRender::SHFieldSample& samp) {
toStrip.EmplaceVert(zeus::CVector3f(x, y, samp.height), samp.MakeNormal(), samp.MakeBinormal(),
samp.MakeTangent(), samp.MakeColor(info));
};
break;
}
Implement CFluidPlaneGPU for GPU-computed water ripples
2018-06-07 04:43:26 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
func(tileMid + curX, yMid, heights[startYDiv + midDiv][i + midDiv]);
int curXDiv = i;
int curYDiv = startYDiv + CFluidPlaneRender::numSubdivisionsInTile;
float curTileX = curX;
float curTileY = yMin + info.x14_tileSize;
for (int v = 0; v < (r19 ? CFluidPlaneRender::numSubdivisionsInTile : 1); ++v) {
const CFluidPlaneRender::SHFieldSample& samp = heights[curYDiv][curXDiv + v];
func(curTileX, curTileY, samp);
curTileX += info.x18_rippleResolution;
Implement CFluidPlaneGPU for GPU-computed water ripples
2018-06-07 04:43:26 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
curXDiv = i + CFluidPlaneRender::numSubdivisionsInTile;
curYDiv = startYDiv + CFluidPlaneRender::numSubdivisionsInTile;
curTileX = curX + info.x14_tileSize;
curTileY = yMin + info.x14_tileSize;
for (int v = 0; v < (r18 ? CFluidPlaneRender::numSubdivisionsInTile : 1); ++v) {
const CFluidPlaneRender::SHFieldSample& samp = heights[curYDiv - v][curXDiv];
func(curTileX, curTileY, samp);
curTileY -= info.x18_rippleResolution;
}
curXDiv = i + CFluidPlaneRender::numSubdivisionsInTile;
curYDiv = startYDiv;
curTileX = curX + info.x14_tileSize;
curTileY = yMin;
for (int v = 0; v < (r17 ? CFluidPlaneRender::numSubdivisionsInTile : 1); ++v) {
const CFluidPlaneRender::SHFieldSample& samp = heights[curYDiv][curXDiv - v];
func(curTileX, curTileY, samp);
curTileX -= info.x18_rippleResolution;
}
curXDiv = i;
curYDiv = startYDiv;
curTileX = curX;
curTileY = yMin;
if (r16) {
for (int v = 0; v < CFluidPlaneRender::numSubdivisionsInTile + 1; ++v) {
const CFluidPlaneRender::SHFieldSample& samp = heights[curYDiv + v][curXDiv];
func(curTileX, curTileY, samp);
curTileY += info.x18_rippleResolution;
}
} else {
{
const CFluidPlaneRender::SHFieldSample& samp = heights[curYDiv][curXDiv];
func(curTileX, curTileY, samp);
}
curTileY += info.x14_tileSize;
{
const CFluidPlaneRender::SHFieldSample& samp =
heights[curYDiv + CFluidPlaneRender::numSubdivisionsInTile][curXDiv];
func(curTileX, curTileY, samp);
}
Implement CFluidPlaneGPU for GPU-computed water ripples
2018-06-07 04:43:26 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
toStrip.Draw();
}
Implement CFluidPlaneGPU for GPU-computed water ripples
2018-06-07 04:43:26 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Implement CFluidPlaneGPU for GPU-computed water ripples
2018-06-07 04:43:26 +00:00
}
CFluidPlane: Make use of std::array where applicable Makes all the arrays strongly typed. We can also use type aliases to greatly shorten some type definitions.
2020-04-12 13:52:36 +00:00
void CFluidPlane::RenderPatch(const CFluidPlaneRender::SPatchInfo& info, const Heights& heights, const Flags& flags,
New code style refactor
2018-12-08 05:30:43 +00:00
bool noRipples, bool flagIs1, std::vector<CFluidPlaneShader::Vertex>& vOut,
CFluidPlane: Resolve constness related compile errors that slipped through Gotta love Find References not, in fact, finding all the references.
2020-04-06 09:29:05 +00:00
std::vector<CFluidPlaneShader::PatchVertex>& pvOut) {
Using optick, linked from boo
2021-04-03 16:48:39 +00:00
OPTICK_EVENT();
New code style refactor
2018-12-08 05:30:43 +00:00
if (noRipples) {
m_shader->bindRegular();
float xMin = info.x4_localMin.x();
float yMin = info.x4_localMin.y();
float xMax = info.x18_rippleResolution * (info.x0_xSubdivs - 2) + xMin;
float yMax = info.x18_rippleResolution * (info.x1_ySubdivs - 2) + yMin;
switch (info.x37_normalMode) {
case CFluidPlaneRender::NormalMode::None: {
size_t start = vOut.size();
vOut.emplace_back(zeus::CVector3f(xMin, yMin, 0.f));
vOut.emplace_back(zeus::CVector3f(xMin, yMax, 0.f));
vOut.emplace_back(zeus::CVector3f(xMax, yMin, 0.f));
vOut.emplace_back(zeus::CVector3f(xMax, yMax, 0.f));
CGraphics::DrawArray(start, 4);
break;
}
case CFluidPlaneRender::NormalMode::NoNormals: {
size_t start = vOut.size();
zeus constexpr refactor and thermal visor fixes
2019-02-24 07:15:54 +00:00
vOut.emplace_back(zeus::CVector3f(xMin, yMin, 0.f), zeus::skBlack);
vOut.emplace_back(zeus::CVector3f(xMin, yMax, 0.f), zeus::skBlack);
vOut.emplace_back(zeus::CVector3f(xMax, yMin, 0.f), zeus::skBlack);
vOut.emplace_back(zeus::CVector3f(xMax, yMax, 0.f), zeus::skBlack);
New code style refactor
2018-12-08 05:30:43 +00:00
CGraphics::DrawArray(start, 4);
break;
}
case CFluidPlaneRender::NormalMode::Normals: {
int yTiles = (info.x1_ySubdivs - 3) / CFluidPlaneRender::numSubdivisionsInTile + 1;
int xTiles = (info.x0_xSubdivs - 3) / CFluidPlaneRender::numSubdivisionsInTile + 1;
int xTileStart = info.x28_tileX + info.x2e_tileY * info.x2a_gridDimX;
yMax = yMin;
for (int curYTile = yTiles; curYTile > 0;
--curYTile, yMax += info.x14_tileSize, xTileStart += info.x2a_gridDimX) {
xMax = xMin;
int nextXTile;
for (int curXTile = 0; curXTile < xTiles; curXTile = nextXTile) {
if (!info.x30_gridFlags || info.x30_gridFlags[xTileStart + curXTile]) {
if (curYTile == yTiles || curYTile == 1 || curXTile == 0 || xTiles - 1 == curXTile) {
TriFanToStrip<CFluidPlaneShader::Vertex> toStrip(vOut);
toStrip.EmplaceVert(
Reformat pass
2021-06-07 19:29:18 +00:00
zeus::CVector3f(xMax + 0.5f * info.x14_tileSize, yMax + 0.5f * info.x14_tileSize, 0.f), zeus::skUp,
zeus::skBlack);
New code style refactor
2018-12-08 05:30:43 +00:00
float tmp = xMax;
for (int v = 0; v < ((curYTile == 1) ? CFluidPlaneRender::numSubdivisionsInTile : 1); ++v) {
Reformat pass
2021-06-07 19:29:18 +00:00
toStrip.EmplaceVert(zeus::CVector3f(tmp, yMax + info.x14_tileSize, 0.f), zeus::skUp, zeus::skBlack);
New code style refactor
2018-12-08 05:30:43 +00:00
tmp += info.x18_rippleResolution;
}
tmp = yMax + info.x14_tileSize;
for (int v = 0; v < ((xTiles - 1 == curXTile) ? CFluidPlaneRender::numSubdivisionsInTile : 1); ++v) {
Reformat pass
2021-06-07 19:29:18 +00:00
toStrip.EmplaceVert(zeus::CVector3f(xMax + info.x14_tileSize, tmp, 0.f), zeus::skUp, zeus::skBlack);
New code style refactor
2018-12-08 05:30:43 +00:00
tmp -= info.x18_rippleResolution;
}
tmp = xMax + info.x14_tileSize;
for (int v = 0; v < ((curYTile == yTiles) ? CFluidPlaneRender::numSubdivisionsInTile : 1); ++v) {
zeus constexpr refactor and thermal visor fixes
2019-02-24 07:15:54 +00:00
toStrip.EmplaceVert(zeus::CVector3f(tmp, yMax, 0.f), zeus::skUp, zeus::skBlack);
New code style refactor
2018-12-08 05:30:43 +00:00
tmp -= info.x18_rippleResolution;
}
tmp = yMax;
for (int v = 0; v < ((curXTile == 0) ? CFluidPlaneRender::numSubdivisionsInTile : 1); ++v) {
zeus constexpr refactor and thermal visor fixes
2019-02-24 07:15:54 +00:00
toStrip.EmplaceVert(zeus::CVector3f(xMax, tmp, 0.f), zeus::skUp, zeus::skBlack);
New code style refactor
2018-12-08 05:30:43 +00:00
tmp += info.x18_rippleResolution;
}
Reformat pass
2021-06-07 19:29:18 +00:00
toStrip.EmplaceVert(zeus::CVector3f(xMax, yMax + info.x14_tileSize, 0.f), zeus::skUp, zeus::skBlack);
New code style refactor
2018-12-08 05:30:43 +00:00
toStrip.Draw();
nextXTile = curXTile + 1;
xMax += info.x14_tileSize;
} else {
nextXTile = curXTile + 1;
while (nextXTile < xTiles - 1 && (!info.x30_gridFlags || info.x30_gridFlags[xTileStart + nextXTile]))
++nextXTile;
size_t start = vOut.size();
for (int v = 0; v < nextXTile - curXTile + 1; ++v) {
zeus constexpr refactor and thermal visor fixes
2019-02-24 07:15:54 +00:00
vOut.emplace_back(zeus::CVector3f(xMax, yMax, 0.f), zeus::skUp, zeus::skBlack);
Reformat pass
2021-06-07 19:29:18 +00:00
vOut.emplace_back(zeus::CVector3f(xMax, yMax + info.x14_tileSize, 0.f), zeus::skUp, zeus::skBlack);
New code style refactor
2018-12-08 05:30:43 +00:00
xMax += info.x14_tileSize;
}
CGraphics::DrawArray(start, vOut.size() - start);
++nextXTile;
if (nextXTile == xTiles) {
--nextXTile;
xMax -= info.x14_tileSize;
}
Implement CFluidPlaneGPU for GPU-computed water ripples
2018-06-07 04:43:26 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
} else {
nextXTile = curXTile + 1;
xMax += info.x14_tileSize;
while (nextXTile < xTiles && !info.x30_gridFlags[xTileStart + nextXTile]) {
xMax += info.x14_tileSize;
++nextXTile;
}
}
Implement CFluidPlaneGPU for GPU-computed water ripples
2018-06-07 04:43:26 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
break;
}
case CFluidPlaneRender::NormalMode::NBT: {
if (flagIs1 || !info.x30_gridFlags) {
size_t start = vOut.size();
Reformat pass
2021-06-07 19:29:18 +00:00
vOut.emplace_back(zeus::CVector3f(xMin, yMin, 0.f), zeus::skUp, zeus::skForward, zeus::skRight, zeus::skBlack);
vOut.emplace_back(zeus::CVector3f(xMin, yMax, 0.f), zeus::skUp, zeus::skForward, zeus::skRight, zeus::skBlack);
vOut.emplace_back(zeus::CVector3f(xMax, yMin, 0.f), zeus::skUp, zeus::skForward, zeus::skRight, zeus::skBlack);
vOut.emplace_back(zeus::CVector3f(xMax, yMax, 0.f), zeus::skUp, zeus::skForward, zeus::skRight, zeus::skBlack);
New code style refactor
2018-12-08 05:30:43 +00:00
CGraphics::DrawArray(start, 4);
} else {
int xTiles = (info.x0_xSubdivs - 3) / CFluidPlaneRender::numSubdivisionsInTile + 1;
int yTiles = (info.x1_ySubdivs - 3) / CFluidPlaneRender::numSubdivisionsInTile + 1;
int xTileStart = info.x28_tileX + info.x2e_tileY * info.x2a_gridDimX;
for (; yTiles > 0; --yTiles, yMin += info.x14_tileSize, xTileStart += info.x2a_gridDimX) {
xMax = xMin;
int nextXTile;
for (int curXTile = 0; curXTile < xTiles; curXTile = nextXTile) {
if (info.x30_gridFlags[xTileStart + curXTile]) {
nextXTile = curXTile + 1;
int tile = xTileStart + nextXTile;
while (nextXTile < xTiles && info.x30_gridFlags[tile]) {
++nextXTile;
++tile;
}
size_t start = vOut.size();
for (int v = 0; v < nextXTile - curXTile + 1; ++v) {
Reformat pass
2021-06-07 19:29:18 +00:00
vOut.emplace_back(zeus::CVector3f(xMax, yMin, 0.f), zeus::skUp, zeus::skForward, zeus::skRight,
zeus::skBlack);
vOut.emplace_back(zeus::CVector3f(xMax, yMin + info.x14_tileSize, 0.f), zeus::skUp, zeus::skForward,
zeus constexpr refactor and thermal visor fixes
2019-02-24 07:15:54 +00:00
zeus::skRight, zeus::skBlack);
New code style refactor
2018-12-08 05:30:43 +00:00
xMax += info.x14_tileSize;
}
CGraphics::DrawArray(start, vOut.size() - start);
} else {
nextXTile = curXTile + 1;
xMax += info.x14_tileSize;
int tile = xTileStart + nextXTile;
while (nextXTile < xTiles && !info.x30_gridFlags[tile]) {
xMax += info.x14_tileSize;
++nextXTile;
++tile;
}
Implement CFluidPlaneGPU for GPU-computed water ripples
2018-06-07 04:43:26 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Implement CFluidPlaneGPU for GPU-computed water ripples
2018-06-07 04:43:26 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
break;
Implement CFluidPlaneGPU for GPU-computed water ripples
2018-06-07 04:43:26 +00:00
}
}
New code style refactor
2018-12-08 05:30:43 +00:00
} else {
float curY = info.x4_localMin.y();
for (int startYDiv = 1; startYDiv < info.x1_ySubdivs - 2;
startYDiv += CFluidPlaneRender::numSubdivisionsInTile, curY += info.x14_tileSize)
RenderStripWithRipples(curY, heights, flags, startYDiv, info, vOut, pvOut);
}
Implement CFluidPlaneGPU for GPU-computed water ripples
2018-06-07 04:43:26 +00:00
}
Rename everything
2021-04-10 08:42:06 +00:00
} // namespace metaforce