mirror of https://github.com/AxioDL/metaforce.git
579 lines
27 KiB
C++
579 lines
27 KiB
C++
#include <Runtime/GameGlobalObjects.hpp>
|
|
#include "CFluidPlane.hpp"
|
|
#include "CSimplePool.hpp"
|
|
#include "CRipple.hpp"
|
|
#include "CScriptWater.hpp"
|
|
#include "CStateManager.hpp"
|
|
|
|
namespace urde
|
|
{
|
|
|
|
CFluidPlane::CFluidPlane(CAssetId texPattern1, CAssetId texPattern2, CAssetId texColor, float alpha,
|
|
EFluidType fluidType, float rippleIntensity, const CFluidUVMotion& motion)
|
|
: 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});
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
float CFluidPlane::CalculateRippleIntensity(float baseI) const
|
|
{
|
|
float mul;
|
|
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);
|
|
}
|
|
|
|
void CFluidPlane::AddRipple(float mag, TUniqueId rippler, const zeus::CVector3f& center,
|
|
CScriptWater& water, CStateManager& mgr)
|
|
{
|
|
if (!water.CanRippleAtPoint(center))
|
|
return;
|
|
|
|
mag = CalculateRippleIntensity(mag);
|
|
mgr.GetFluidPlaneManager()->RippleManager().AddRipple(CRipple(rippler, center, mag));
|
|
}
|
|
|
|
void CFluidPlane::AddRipple(float intensity, TUniqueId rippler, const zeus::CVector3f& center,
|
|
const zeus::CVector3f& velocity, const CScriptWater& water, CStateManager& mgr,
|
|
const zeus::CVector3f& upVec)
|
|
{
|
|
if (!water.CanRippleAtPoint(center))
|
|
return;
|
|
|
|
intensity = CalculateRippleIntensity(ProjectRippleVelocity(intensity, upVec.dot(velocity)));
|
|
mgr.GetFluidPlaneManager()->RippleManager().AddRipple(CRipple(rippler, center, intensity));
|
|
}
|
|
|
|
void CFluidPlane::AddRipple(const CRipple& ripple, const CScriptWater& water, CStateManager& mgr)
|
|
{
|
|
if (!water.CanRippleAtPoint(ripple.GetCenter()))
|
|
return;
|
|
mgr.GetFluidPlaneManager()->RippleManager().AddRipple(ripple);
|
|
}
|
|
|
|
void CFluidPlane::RenderStripWithRipples(float curY,
|
|
const CFluidPlaneRender::SHFieldSample (&heights)[46][46],
|
|
const u8 (&flags)[9][9], int startYDiv,
|
|
const CFluidPlaneRender::SPatchInfo& info,
|
|
std::vector<CFluidPlaneShader::Vertex>& vOut,
|
|
std::vector<CFluidPlaneShader::PatchVertex>& pvOut) const
|
|
{
|
|
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;
|
|
}
|
|
|
|
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;
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
toStrip.Draw();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CFluidPlane::RenderPatch(const CFluidPlaneRender::SPatchInfo& info,
|
|
const CFluidPlaneRender::SHFieldSample (&heights)[46][46],
|
|
const u8 (&flags)[9][9], bool noRipples, bool flagIs1,
|
|
std::vector<CFluidPlaneShader::Vertex>& vOut,
|
|
std::vector<CFluidPlaneShader::PatchVertex>& pvOut) const
|
|
{
|
|
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();
|
|
vOut.emplace_back(zeus::CVector3f(xMin, yMin, 0.f), zeus::CColor::skBlack);
|
|
vOut.emplace_back(zeus::CVector3f(xMin, yMax, 0.f), zeus::CColor::skBlack);
|
|
vOut.emplace_back(zeus::CVector3f(xMax, yMin, 0.f), zeus::CColor::skBlack);
|
|
vOut.emplace_back(zeus::CVector3f(xMax, yMax, 0.f), zeus::CColor::skBlack);
|
|
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(zeus::CVector3f(xMax + 0.5f * info.x14_tileSize,
|
|
yMax + 0.5f * info.x14_tileSize, 0.f),
|
|
zeus::CVector3f::skUp, zeus::CColor::skBlack);
|
|
|
|
float tmp = xMax;
|
|
for (int v=0 ; v<((curYTile == 1) ?
|
|
CFluidPlaneRender::numSubdivisionsInTile : 1) ; ++v)
|
|
{
|
|
toStrip.EmplaceVert(zeus::CVector3f(tmp, yMax + info.x14_tileSize, 0.f),
|
|
zeus::CVector3f::skUp, zeus::CColor::skBlack);
|
|
tmp += info.x18_rippleResolution;
|
|
}
|
|
|
|
tmp = yMax + info.x14_tileSize;
|
|
for (int v=0 ; v<((xTiles - 1 == curXTile) ?
|
|
CFluidPlaneRender::numSubdivisionsInTile : 1) ; ++v)
|
|
{
|
|
toStrip.EmplaceVert(zeus::CVector3f(xMax + info.x14_tileSize, tmp, 0.f),
|
|
zeus::CVector3f::skUp, zeus::CColor::skBlack);
|
|
tmp -= info.x18_rippleResolution;
|
|
}
|
|
|
|
tmp = xMax + info.x14_tileSize;
|
|
for (int v=0 ; v<((curYTile == yTiles) ?
|
|
CFluidPlaneRender::numSubdivisionsInTile : 1) ; ++v)
|
|
{
|
|
toStrip.EmplaceVert(zeus::CVector3f(tmp, yMax, 0.f),
|
|
zeus::CVector3f::skUp, zeus::CColor::skBlack);
|
|
tmp -= info.x18_rippleResolution;
|
|
}
|
|
|
|
tmp = yMax;
|
|
for (int v=0 ; v<((curXTile == 0) ?
|
|
CFluidPlaneRender::numSubdivisionsInTile : 1) ; ++v)
|
|
{
|
|
toStrip.EmplaceVert(zeus::CVector3f(xMax, tmp, 0.f),
|
|
zeus::CVector3f::skUp, zeus::CColor::skBlack);
|
|
tmp += info.x18_rippleResolution;
|
|
}
|
|
|
|
toStrip.EmplaceVert(zeus::CVector3f(xMax, yMax + info.x14_tileSize, 0.f),
|
|
zeus::CVector3f::skUp, zeus::CColor::skBlack);
|
|
|
|
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)
|
|
{
|
|
vOut.emplace_back(zeus::CVector3f(xMax, yMax, 0.f),
|
|
zeus::CVector3f::skUp, zeus::CColor::skBlack);
|
|
vOut.emplace_back(zeus::CVector3f(xMax, yMax + info.x14_tileSize, 0.f),
|
|
zeus::CVector3f::skUp, zeus::CColor::skBlack);
|
|
xMax += info.x14_tileSize;
|
|
}
|
|
CGraphics::DrawArray(start, vOut.size() - start);
|
|
|
|
++nextXTile;
|
|
if (nextXTile == xTiles)
|
|
{
|
|
--nextXTile;
|
|
xMax -= info.x14_tileSize;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nextXTile = curXTile + 1;
|
|
xMax += info.x14_tileSize;
|
|
while (nextXTile < xTiles && !info.x30_gridFlags[xTileStart+nextXTile])
|
|
{
|
|
xMax += info.x14_tileSize;
|
|
++nextXTile;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case CFluidPlaneRender::NormalMode::NBT:
|
|
{
|
|
if (flagIs1 || !info.x30_gridFlags)
|
|
{
|
|
size_t start = vOut.size();
|
|
vOut.emplace_back(zeus::CVector3f(xMin, yMin, 0.f), zeus::CVector3f::skUp,
|
|
zeus::CVector3f::skForward, zeus::CVector3f::skRight, zeus::CColor::skBlack);
|
|
vOut.emplace_back(zeus::CVector3f(xMin, yMax, 0.f), zeus::CVector3f::skUp,
|
|
zeus::CVector3f::skForward, zeus::CVector3f::skRight, zeus::CColor::skBlack);
|
|
vOut.emplace_back(zeus::CVector3f(xMax, yMin, 0.f), zeus::CVector3f::skUp,
|
|
zeus::CVector3f::skForward, zeus::CVector3f::skRight, zeus::CColor::skBlack);
|
|
vOut.emplace_back(zeus::CVector3f(xMax, yMax, 0.f), zeus::CVector3f::skUp,
|
|
zeus::CVector3f::skForward, zeus::CVector3f::skRight, zeus::CColor::skBlack);
|
|
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)
|
|
{
|
|
vOut.emplace_back(zeus::CVector3f(xMax, yMin, 0.f), zeus::CVector3f::skUp,
|
|
zeus::CVector3f::skForward, zeus::CVector3f::skRight,
|
|
zeus::CColor::skBlack);
|
|
vOut.emplace_back(zeus::CVector3f(xMax, yMin + info.x14_tileSize, 0.f),
|
|
zeus::CVector3f::skUp, zeus::CVector3f::skForward,
|
|
zeus::CVector3f::skRight, zeus::CColor::skBlack);
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
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);
|
|
}
|
|
}
|
|
|
|
}
|