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

579 lines
27 KiB
C++
Raw Normal View History

Implement class declaration for CFluidPlane/CFluidPlaneCPU
2017-08-06 07:15:42 +00:00
#include <Runtime/GameGlobalObjects.hpp>
Various Implementations
2016-11-20 21:53:15 +00:00
#include "CFluidPlane.hpp"
Implement class declaration for CFluidPlane/CFluidPlaneCPU
2017-08-06 07:15:42 +00:00
#include "CSimplePool.hpp"
Implement CFluidPlaneDoor and CScriptDamageableTrigger
2017-08-14 03:55:06 +00:00
#include "CRipple.hpp"
#include "CScriptWater.hpp"
#include "CStateManager.hpp"
Various Implementations
2016-11-20 21:53:15 +00:00
namespace urde
{
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)
Implement class declaration for CFluidPlane/CFluidPlaneCPU
2017-08-06 07:15:42 +00:00
: x4_texPattern1Id(texPattern1), x8_texPattern2Id(texPattern2), xc_texColorId(texColor), x40_alpha(alpha),
Nearly finish CScriptWater
2017-08-13 07:56:35 +00:00
x44_fluidType(fluidType), x48_rippleIntensity(rippleIntensity), x4c_uvMotion(motion)
Various Implementations
2016-11-20 21:53:15 +00:00
{
Implement class declaration for CFluidPlane/CFluidPlaneCPU
2017-08-06 07:15:42 +00:00
if (g_ResFactory->GetResourceTypeById(texPattern1) == FOURCC('TXTR'))
Implement CFluidPlaneGPU for GPU-computed water ripples
2018-06-07 04:43:26 +00:00
x10_texPattern1 = g_SimplePool->GetObj(SObjectTag{FOURCC('TXTR'), texPattern1});
Implement class declaration for CFluidPlane/CFluidPlaneCPU
2017-08-06 07:15:42 +00:00
if (g_ResFactory->GetResourceTypeById(texPattern2) == FOURCC('TXTR'))
Implement CFluidPlaneGPU for GPU-computed water ripples
2018-06-07 04:43:26 +00:00
x20_texPattern2 = g_SimplePool->GetObj(SObjectTag{FOURCC('TXTR'), texPattern2});
Implement class declaration for CFluidPlane/CFluidPlaneCPU
2017-08-06 07:15:42 +00:00
if (g_ResFactory->GetResourceTypeById(texColor) == FOURCC('TXTR'))
Implement CFluidPlaneGPU for GPU-computed water ripples
2018-06-07 04:43:26 +00:00
x30_texColor = g_SimplePool->GetObj(SObjectTag{FOURCC('TXTR'), texColor});
Various Implementations
2016-11-20 21:53:15 +00:00
}
Implement CFluidPlaneDoor and CScriptDamageableTrigger
2017-08-14 03:55:06 +00:00
float CFluidPlane::ProjectRippleVelocity(float baseI, float velDot) const
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
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;
Additional CPlayer implementations
2017-08-16 05:34:02 +00:00
case EFluidType::PhazonFluid:
Implement CFluidPlaneDoor and CScriptDamageableTrigger
2017-08-14 03:55:06 +00:00
case EFluidType::Four:
mul = 0.8f;
break;
Additional CPlayer implementations
2017-08-16 05:34:02 +00:00
case EFluidType::ThickLava:
Implement CFluidPlaneDoor and CScriptDamageableTrigger
2017-08-14 03:55:06 +00:00
mul = 1.f;
break;
}
return zeus::clamp(0.f, baseI * mul * (1.f - x48_rippleIntensity + 0.5f), 1.f);
}
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 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));
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,
const zeus::CVector3f& upVec)
Various Implementations
2016-11-20 21:53:15 +00:00
{
Implement CFluidPlaneDoor and CScriptDamageableTrigger
2017-08-14 03:55:06 +00:00
if (!water.CanRippleAtPoint(center))
return;
Various Implementations
2016-11-20 21:53:15 +00:00
Implement CFluidPlaneDoor and CScriptDamageableTrigger
2017-08-14 03:55:06 +00:00
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);
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
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);
}
}
Various Implementations
2016-11-20 21:53:15 +00:00
}