Itms/0ad
1
0
Fork 0
forked from 0ad/0ad
Code Pull Requests Activity

Rework 7ee94f23df

Browse Source 
Following comments by @vladislavbelov.

Differential Revision: https://code.wildfiregames.com/D3860
This was SVN commit r25278.
This commit is contained in:
wraitii 2021-04-16 16:01:30 +00:00
parent b3e3d1f715
commit 924c6ce34e
7 changed files with 44 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
source/graphics/Camera.cpp
View File

@ -262,8 +262,8 @@ CVector3D CCamera::GetWorldCoordinates(int px, int py, bool aboveWater) const
ssize_t mapSize = g_Game->GetWorld()->GetTerrain()->GetVerticesPerSide();
if (gotWater)
{
waterPoint.X = Clamp(waterPoint.X, 0.f, (mapSize - 1) * TERRAIN_TILE_SIZE);
waterPoint.Z = Clamp(waterPoint.Z, 0.f, (mapSize - 1) * TERRAIN_TILE_SIZE);
waterPoint.X = Clamp<float>(waterPoint.X, 0.f, (mapSize - 1) * TERRAIN_TILE_SIZE);
waterPoint.Z = Clamp<float>(waterPoint.Z, 0.f, (mapSize - 1) * TERRAIN_TILE_SIZE);
}
if (gotTerrain)
@ -340,8 +340,8 @@ CVector3D CCamera::GetFocus() const
ssize_t mapSize = g_Game->GetWorld()->GetTerrain()->GetVerticesPerSide();
if (gotWater)
{
waterPoint.X = Clamp(waterPoint.X, 0.f, (mapSize - 1) * TERRAIN_TILE_SIZE);
waterPoint.Z = Clamp(waterPoint.Z, 0.f, (mapSize - 1) * TERRAIN_TILE_SIZE);
waterPoint.X = Clamp<float>(waterPoint.X, 0.f, (mapSize - 1) * TERRAIN_TILE_SIZE);
waterPoint.Z = Clamp<float>(waterPoint.Z, 0.f, (mapSize - 1) * TERRAIN_TILE_SIZE);
}
if (gotTerrain)

8
source/graphics/Decal.cpp
View File

@ -45,10 +45,10 @@ void CModelDecal::CalcVertexExtents(ssize_t& i0, ssize_t& j0, ssize_t& i1, ssize
i1 = ceil(std::max(std::max(corner0.X, corner1.X), std::max(corner2.X, corner3.X)) / TERRAIN_TILE_SIZE);
j1 = ceil(std::max(std::max(corner0.Z, corner1.Z), std::max(corner2.Z, corner3.Z)) / TERRAIN_TILE_SIZE);
i0 = Clamp(i0, 0, m_Terrain->GetVerticesPerSide() - 1);
j0 = Clamp(j0, 0, m_Terrain->GetVerticesPerSide() - 1);
i1 = Clamp(i1, 0, m_Terrain->GetVerticesPerSide() - 1);
j1 = Clamp(j1, 0, m_Terrain->GetVerticesPerSide() - 1);
i0 = Clamp<ssize_t>(i0, 0, m_Terrain->GetVerticesPerSide() - 1);
j0 = Clamp<ssize_t>(j0, 0, m_Terrain->GetVerticesPerSide() - 1);
i1 = Clamp<ssize_t>(i1, 0, m_Terrain->GetVerticesPerSide() - 1);
j1 = Clamp<ssize_t>(j1, 0, m_Terrain->GetVerticesPerSide() - 1);
}
void CModelDecal::CalcBounds()

2
source/graphics/SmoothedValue.h
View File

@ -72,7 +72,7 @@ public:
void ClampSmoothly(float min, float max)
{
m_Target = Clamp(m_Target, min, max);
m_Target = Clamp<double>(m_Target, min, max);
}
float Update(float time);

48
source/graphics/Terrain.cpp
View File

@ -118,8 +118,8 @@ CStr8 CTerrain::GetMovementClass(ssize_t i, ssize_t j) const
// outwards to infinity
void CTerrain::CalcPosition(ssize_t i, ssize_t j, CVector3D& pos) const
{
ssize_t hi = Clamp(i, 0, m_MapSize - 1);
ssize_t hj = Clamp(j, 0, m_MapSize - 1);
ssize_t hi = Clamp<ssize_t>(i, 0, m_MapSize - 1);
ssize_t hj = Clamp<ssize_t>(j, 0, m_MapSize - 1);
u16 height = m_Heightmap[hj*m_MapSize + hi];
pos.X = float(i*TERRAIN_TILE_SIZE);
pos.Y = float(height*HEIGHT_SCALE);
@ -130,8 +130,8 @@ void CTerrain::CalcPosition(ssize_t i, ssize_t j, CVector3D& pos) const
// CalcPositionFixed: calculate the world space position of the vertex at (i,j)
void CTerrain::CalcPositionFixed(ssize_t i, ssize_t j, CFixedVector3D& pos) const
{
ssize_t hi = Clamp(i, 0, m_MapSize - 1);
ssize_t hj = Clamp(j, 0, m_MapSize - 1);
ssize_t hi = Clamp<ssize_t>(i, 0, m_MapSize - 1);
ssize_t hj = Clamp<ssize_t>(j, 0, m_MapSize - 1);
u16 height = m_Heightmap[hj*m_MapSize + hi];
pos.X = fixed::FromInt(i) * (int)TERRAIN_TILE_SIZE;
// fixed max value is 32767, but height is a u16, so divide by two to avoid overflow
@ -308,15 +308,15 @@ CMiniPatch* CTerrain::GetTile(ssize_t i, ssize_t j) const
float CTerrain::GetVertexGroundLevel(ssize_t i, ssize_t j) const
{
i = Clamp(i, 0, m_MapSize - 1);
j = Clamp(j, 0, m_MapSize - 1);
i = Clamp<ssize_t>(i, 0, m_MapSize - 1);
j = Clamp<ssize_t>(j, 0, m_MapSize - 1);
return HEIGHT_SCALE * m_Heightmap[j*m_MapSize + i];
}
fixed CTerrain::GetVertexGroundLevelFixed(ssize_t i, ssize_t j) const
{
i = Clamp(i, 0, m_MapSize - 1);
j = Clamp(j, 0, m_MapSize - 1);
i = Clamp<ssize_t>(i, 0, m_MapSize - 1);
j = Clamp<ssize_t>(j, 0, m_MapSize - 1);
// Convert to fixed metres (being careful to avoid intermediate overflows)
return fixed::FromInt(m_Heightmap[j*m_MapSize + i] / 2) / (int)(HEIGHT_UNITS_PER_METRE / 2);
}
@ -324,8 +324,8 @@ fixed CTerrain::GetVertexGroundLevelFixed(ssize_t i, ssize_t j) const
fixed CTerrain::GetSlopeFixed(ssize_t i, ssize_t j) const
{
// Clamp to size-2 so we can use the tiles (i,j)-(i+1,j+1)
i = Clamp(i, 0, m_MapSize - 2);
j = Clamp(j, 0, m_MapSize - 2);
i = Clamp<ssize_t>(i, 0, m_MapSize - 2);
j = Clamp<ssize_t>(j, 0, m_MapSize - 2);
u16 h00 = m_Heightmap[j*m_MapSize + i];
u16 h01 = m_Heightmap[(j+1)*m_MapSize + i];
@ -480,8 +480,8 @@ fixed CTerrain::GetExactGroundLevelFixed(fixed x, fixed z) const
bool CTerrain::GetTriangulationDir(ssize_t i, ssize_t j) const
{
// Clamp to size-2 so we can use the tiles (i,j)-(i+1,j+1)
i = Clamp(i, 0, m_MapSize - 2);
j = Clamp(j, 0, m_MapSize - 2);
i = Clamp<ssize_t>(i, 0, m_MapSize - 2);
j = Clamp<ssize_t>(j, 0, m_MapSize - 2);
int h00 = m_Heightmap[j*m_MapSize + i];
int h01 = m_Heightmap[(j+1)*m_MapSize + i];
@ -774,10 +774,10 @@ void CTerrain::SetHeightMap(u16* heightmap)
void CTerrain::MakeDirty(ssize_t i0, ssize_t j0, ssize_t i1, ssize_t j1, int dirtyFlags)
{
// Finds the inclusive limits of the patches that include the specified range of tiles
ssize_t pi0 = Clamp( i0 /PATCH_SIZE, 0, m_MapSizePatches-1);
ssize_t pi1 = Clamp((i1-1)/PATCH_SIZE, 0, m_MapSizePatches-1);
ssize_t pj0 = Clamp( j0 /PATCH_SIZE, 0, m_MapSizePatches-1);
ssize_t pj1 = Clamp((j1-1)/PATCH_SIZE, 0, m_MapSizePatches-1);
ssize_t pi0 = Clamp<ssize_t>( i0 /PATCH_SIZE, 0, m_MapSizePatches-1);
ssize_t pi1 = Clamp<ssize_t>((i1-1)/PATCH_SIZE, 0, m_MapSizePatches-1);
ssize_t pj0 = Clamp<ssize_t>( j0 /PATCH_SIZE, 0, m_MapSizePatches-1);
ssize_t pj1 = Clamp<ssize_t>((j1-1)/PATCH_SIZE, 0, m_MapSizePatches-1);
for (ssize_t j = pj0; j <= pj1; j++)
{
@ -793,10 +793,10 @@ void CTerrain::MakeDirty(ssize_t i0, ssize_t j0, ssize_t i1, ssize_t j1, int dir
if (m_Heightmap)
{
m_HeightMipmap.Update(m_Heightmap,
Clamp(i0, 0, m_MapSize - 1),
Clamp(j0, 0, m_MapSize - 1),
Clamp(i1, 1, m_MapSize),
Clamp(j1, 1, m_MapSize)
Clamp<ssize_t>(i0, 0, m_MapSize - 1),
Clamp<ssize_t>(j0, 0, m_MapSize - 1),
Clamp<ssize_t>(i1, 1, m_MapSize),
Clamp<ssize_t>(j1, 1, m_MapSize)
);
}
}
@ -820,10 +820,10 @@ void CTerrain::MakeDirty(int dirtyFlags)
CBoundingBoxAligned CTerrain::GetVertexesBound(ssize_t i0, ssize_t j0, ssize_t i1, ssize_t j1)
{
i0 = Clamp(i0, 0, m_MapSize - 1);
j0 = Clamp(j0, 0, m_MapSize - 1);
i1 = Clamp(i1, 0, m_MapSize - 1);
j1 = Clamp(j1, 0, m_MapSize - 1);
i0 = Clamp<ssize_t>(i0, 0, m_MapSize - 1);
j0 = Clamp<ssize_t>(j0, 0, m_MapSize - 1);
i1 = Clamp<ssize_t>(i1, 0, m_MapSize - 1);
j1 = Clamp<ssize_t>(j1, 0, m_MapSize - 1);
u16 minH = 65535;
u16 maxH = 0;

11
source/maths/MathUtil.h
View File

@ -28,17 +28,8 @@ inline T Interpolate(const T& a, const T& b, float t)
return a + (b - a) * t;
}
// TODO C++20: use the proper one.
template<typename T>
struct type_identity
{
using type = T;
};
template<typename T>
using type_identity_t = typename type_identity<T>::type;
template <typename T>
inline T Clamp(T value, type_identity_t<T> min, type_identity_t<T> max)
inline T Clamp(T value, T min, T max)
{
if (value <= min)
return min;

12
source/renderer/SilhouetteRenderer.cpp
View File

@ -190,10 +190,10 @@ static void ComputeScreenBounds(Occluder& occluder, const CBoundingBoxAligned& b
// TODO: there must be a quicker way to do this than to test every vertex,
// given the symmetry of the bounding box
occluder.x0 = Clamp(x0, std::numeric_limits<u16>::min(), g_MaxCoord - 1);
occluder.y0 = Clamp(y0, std::numeric_limits<u16>::min(), g_MaxCoord - 1);
occluder.x1 = Clamp(x1, std::numeric_limits<u16>::min(), g_MaxCoord - 1);
occluder.y1 = Clamp(y1, std::numeric_limits<u16>::min(), g_MaxCoord - 1);
occluder.x0 = Clamp(x0, std::numeric_limits<u16>::min(), static_cast<u16>(g_MaxCoord - 1));
occluder.y0 = Clamp(y0, std::numeric_limits<u16>::min(), static_cast<u16>(g_MaxCoord - 1));
occluder.x1 = Clamp(x1, std::numeric_limits<u16>::min(), static_cast<u16>(g_MaxCoord - 1));
occluder.y1 = Clamp(y1, std::numeric_limits<u16>::min(), static_cast<u16>(g_MaxCoord - 1));
occluder.z = z0;
}
@ -202,8 +202,8 @@ static void ComputeScreenPos(Caster& caster, const CVector3D& pos, CMatrix3D& pr
CVector4D svec = proj.Transform(CVector4D(pos.X, pos.Y, pos.Z, 1.0f));
u16 x = g_HalfMaxCoord + static_cast<int>(g_HalfMaxCoord * svec.X / svec.W);
u16 y = g_HalfMaxCoord + static_cast<int>(g_HalfMaxCoord * svec.Y / svec.W);
caster.x = Clamp(x, std::numeric_limits<u16>::min(), g_MaxCoord - 1);
caster.y = Clamp(y, std::numeric_limits<u16>::min(), g_MaxCoord - 1);
caster.x = Clamp(x, std::numeric_limits<u16>::min(), static_cast<u16>(g_MaxCoord - 1));
caster.y = Clamp(y, std::numeric_limits<u16>::min(), static_cast<u16>(g_MaxCoord - 1));
caster.z = svec.Z / svec.W;
}

8
source/simulation2/components/CCmpPathfinder.cpp
View File

@ -613,10 +613,10 @@ void CCmpPathfinder::TerrainUpdateHelper(bool expandPassability, int itile0, int
// We need to extend the boundaries by 1 tile, because slope and ground
// level are calculated by multiple neighboring tiles.
// TODO: add CTerrain constant instead of 1.
istart = Clamp(itile0 - 1, 0, m_MapSize) * Pathfinding::NAVCELLS_PER_TILE;
iend = Clamp(itile1 + 1, 0, m_MapSize) * Pathfinding::NAVCELLS_PER_TILE;
jstart = Clamp(jtile0 - 1, 0, m_MapSize) * Pathfinding::NAVCELLS_PER_TILE;
jend = Clamp(jtile1 + 1, 0, m_MapSize) * Pathfinding::NAVCELLS_PER_TILE;
istart = Clamp<int>(itile0 - 1, 0, m_MapSize) * Pathfinding::NAVCELLS_PER_TILE;
iend = Clamp<int>(itile1 + 1, 0, m_MapSize) * Pathfinding::NAVCELLS_PER_TILE;
jstart = Clamp<int>(jtile0 - 1, 0, m_MapSize) * Pathfinding::NAVCELLS_PER_TILE;
jend = Clamp<int>(jtile1 + 1, 0, m_MapSize) * Pathfinding::NAVCELLS_PER_TILE;
}
// Compute initial terrain-dependent passability