//------------------------------------------------------------------------------//
void GeoTerrainSection::_calcCurrentLod(Camera* cam)
{
Vector2 corner0(mSectionBound.getMinimum().x, mSectionBound.getMinimum().z);
Vector2 corner1(mSectionBound.getMinimum().x, mSectionBound.getMaximum().z);
Vector2 corner2(mSectionBound.getMaximum().x, mSectionBound.getMaximum().z);
Vector2 corner3(mSectionBound.getMaximum().x, mSectionBound.getMinimum().z);
Vector2 viewPoint(cam->getPosition().x, cam->getPosition().z);
// compute view distance to our 4 corners
float distance0 = viewPoint.distance(corner0);
float distance1 = viewPoint.distance(corner1);
float distance2 = viewPoint.distance(corner2);
float distance3 = viewPoint.distance(corner3);
// compute min distance as the test value
float dist = minimum(distance0, distance1);
dist = minimum(dist, distance2);
dist = minimum(dist, distance3);
// make sure the minimum distance is non-zero
dist = maximum(dist, 0.0001f);
// find the lowest lod which will suffice
mCurrentLod = 0;
bool finished = false;
float fScale = mCreator->getLodErrorScale();
float fLimit = mCreator->getRatioLimit();
while (!finished)
{
// find the ratio of variance over distance
float variance = mErrorMetrics[mCurrentLod];
float vRatio = (variance * fScale) / dist;
// if we exceed the ratio limit, move to the next lod
if (vRatio > fLimit
&& mCurrentLod + 1 < TOTAL_DETAIL_LEVELS)
{
++mCurrentLod;
}
else
{
finished=true;
}
}
}
Primitive::Ptr Renderer::CreateLine( const sf::Vector2f& begin, const sf::Vector2f& end, const sf::Color& color, float thickness ) {
// Get vector perpendicular to direction of the line vector.
// Vector is rotated CCW 90 degrees and normalized.
sf::Vector2f normal( end - begin );
std::swap( normal.x, normal.y );
float length = std::sqrt( normal.x * normal.x + normal.y * normal.y );
normal.x /= -length;
normal.y /= length;
sf::Vector2f corner0( begin + normal * ( thickness * .5f ) );
sf::Vector2f corner1( begin - normal * ( thickness * .5f ) );
sf::Vector2f corner2( end - normal * ( thickness * .5f ) );
sf::Vector2f corner3( end + normal * ( thickness * .5f ) );
return CreateQuad( corner3, corner2, corner1, corner0, color );
}
//-------------------------------------------------------------------------------//
void ChunkTerrainSection::_calcLod(Camera* cam)
{
// compute a 2d point for each corner of the section
Vector2 corner0(mSectionBound.getMinimum().x, mSectionBound.getMinimum().z);
Vector2 corner1(mSectionBound.getMinimum().x, mSectionBound.getMaximum().z);
Vector2 corner2(mSectionBound.getMaximum().x, mSectionBound.getMaximum().z);
Vector2 corner3(mSectionBound.getMaximum().x, mSectionBound.getMinimum().z);
Vector2 viewPoint= Vector2(cam->getPosition().x, cam->getPosition().z);
// compute view distance to our 4 corners
float distance0 = viewPoint.distance(corner0);
float distance1 = viewPoint.distance(corner1);
float distance2 = viewPoint.distance(corner2);
float distance3 = viewPoint.distance(corner3);
_recursiveTessellate(distance0, distance1, distance2, distance3,
0, 0, 0,
mCreator->getLodErrorScale(), mCreator->getRatioLimit());
}
void CModelDecal::CalcVertexExtents(ssize_t& i0, ssize_t& j0, ssize_t& i1, ssize_t& j1)
{
CVector3D corner0(m_Decal.m_OffsetX + m_Decal.m_SizeX/2, 0, m_Decal.m_OffsetZ + m_Decal.m_SizeZ/2);
CVector3D corner1(m_Decal.m_OffsetX + m_Decal.m_SizeX/2, 0, m_Decal.m_OffsetZ - m_Decal.m_SizeZ/2);
CVector3D corner2(m_Decal.m_OffsetX - m_Decal.m_SizeX/2, 0, m_Decal.m_OffsetZ - m_Decal.m_SizeZ/2);
CVector3D corner3(m_Decal.m_OffsetX - m_Decal.m_SizeX/2, 0, m_Decal.m_OffsetZ + m_Decal.m_SizeZ/2);
corner0 = GetTransform().Transform(corner0);
corner1 = GetTransform().Transform(corner1);
corner2 = GetTransform().Transform(corner2);
corner3 = GetTransform().Transform(corner3);
i0 = floor(std::min(std::min(corner0.X, corner1.X), std::min(corner2.X, corner3.X)) / TERRAIN_TILE_SIZE);
j0 = floor(std::min(std::min(corner0.Z, corner1.Z), std::min(corner2.Z, corner3.Z)) / TERRAIN_TILE_SIZE);
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, (ssize_t)0, m_Terrain->GetVerticesPerSide()-1);
j0 = clamp(j0, (ssize_t)0, m_Terrain->GetVerticesPerSide()-1);
i1 = clamp(i1, (ssize_t)0, m_Terrain->GetVerticesPerSide()-1);
j1 = clamp(j1, (ssize_t)0, m_Terrain->GetVerticesPerSide()-1);
}
// GET INTERPOLATOR
//-------------------------------------------------------------------------
GridInterface::Interpolator RectilinearGrid::getInterpolator(Index elem, const Vector &point, DataBase::Mapping mapping, GridInterface::InterpolationMode mode) const {
vassert(inside(elem, point));
#ifdef INTERPOL_DEBUG
if (!inside(elem, point)) {
return Interpolator();
}
#endif
if (mapping == DataBase::Element) {
std::vector<Scalar> weights(1, 1.);
std::vector<Index> indices(1, elem);
return Interpolator(weights, indices);
}
std::array<Index,3> n = cellCoordinates(elem, m_numDivisions);
std::array<Index,8> cl = cellVertices(elem, m_numDivisions);
Vector corner0(m_coords[0][n[0]], m_coords[1][n[1]], m_coords[2][n[2]]);
Vector corner1(m_coords[0][n[0]+1], m_coords[1][n[1]+1], m_coords[2][n[2]+1]);
const Vector diff = point-corner0;
const Vector size = corner1-corner0;
const Index nvert = 8;
std::vector<Index> indices((mode==Linear || mode==Mean) ? nvert : 1);
std::vector<Scalar> weights((mode==Linear || mode==Mean) ? nvert : 1);
if (mode == Mean) {
const Scalar w = Scalar(1)/nvert;
for (Index i=0; i<nvert; ++i) {
indices[i] = cl[i];
weights[i] = w;
}
} else if (mode == Linear) {
vassert(nvert == 8);
for (Index i=0; i<nvert; ++i) {
indices[i] = cl[i];
}
Vector ss = diff;
for (int c=0; c<3; ++c) {
ss[c] /= size[c];
}
weights[0] = (1-ss[0])*(1-ss[1])*(1-ss[2]);
weights[1] = ss[0]*(1-ss[1])*(1-ss[2]);
weights[2] = ss[0]*ss[1]*(1-ss[2]);
weights[3] = (1-ss[0])*ss[1]*(1-ss[2]);
weights[4] = (1-ss[0])*(1-ss[1])*ss[2];
weights[5] = ss[0]*(1-ss[1])*ss[2];
weights[6] = ss[0]*ss[1]*ss[2];
weights[7] = (1-ss[0])*ss[1]*ss[2];
} else {
weights[0] = 1;
if (mode == First) {
indices[0] = cl[0];
} else if(mode == Nearest) {
Vector ss = diff;
int nearest=0;
for (int c=0; c<3; ++c) {
nearest <<= 1;
ss[c] /= size[c];
if (ss[c] < 0.5)
nearest |= 1;
}
indices[0] = cl[nearest];
}
}
return Interpolator(weights, indices);
}
