//------------------------------------------------------------------------------// 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); }