/// \brief One dimensional midpoint displacement fractal. /// /// Size must be a power of 2. /// Falloff is the decay of displacement as the fractal is refined. /// Array is size + 1 long. array[0] and array[size] are filled /// with the control points for the fractal. void Segment::fill1d(BasePoint const & l, BasePoint const &h, float *array) const { array[0] = l.height(); array[m_res] = h.height(); LinInterp li(m_res, l.roughness(), h.roughness()); // seed the RNG. // The RNG is seeded only once for the line and the seed is based on the // two endpoints -because they are the common parameters for two adjoining // tiles //srand((l.seed() * 1000 + h.seed())); WFMath::MTRand::uint32 seed[2] = { l.seed(), h.seed() }; WFMath::MTRand rng(seed, 2); // stride is used to step across the array in a deterministic fashion // effectively we do the 1/2 point, then the 1/4 points, then the 1/8th // points etc. this has to be the same order every time because we call // on the RNG at every point decltype(getResolution()) stride = m_res / 2; // depth is used to indicate what level we are on. the displacement is // reduced each time we traverse the array. float depth = 1; while (stride) { for (decltype(getResolution()) i = stride; i < m_res; i += stride * 2) { auto hh = array[i - stride]; auto lh = array[i + stride]; auto hd = std::fabs(hh - lh); auto roughness = li.calc(i); //eliminate the problem where hd is nearly zero, leaving a flat section. if ((hd * 100.f) < roughness) { hd += 0.05f * roughness; } array[i] = ((hh + lh) / 2.f) + randHalf(rng) * roughness * hd / (1.f + std::pow(depth, BasePoint::FALLOFF)); } stride >>= 1; depth++; } }
/// \brief Two dimensional midpoint displacement fractal. /// /// For a tile where edges are to be filled by 1d fractals. /// Size must be a power of 2, array is (size + 1) * (size + 1) with the /// corners the control points. void Segment::fill2d(const BasePoint& p1, const BasePoint& p2, const BasePoint& p3, const BasePoint& p4) { assert(m_points!=0); // int line = m_res+1; // calculate the edges first. This is necessary so that segments tile // seamlessly note the order in which the edges are calculated and the // direction. opposite edges are calculated the same way (eg left->right) // so that the top of one tile matches the bottom of another, likewise // with sides. // temporary array used to hold each edge float * edge = new float[m_size]; // calc top edge and copy into m_points fill1d(p1,p2,edge); for (int i=0;i<=m_res;i++) { m_points[0*m_size + i] = edge[i]; checkMaxMin(edge[i]); } // calc left edge and copy into m_points fill1d(p1,p4,edge); for (int i=0;i<=m_res;i++) { m_points[i*m_size + 0] = edge[i]; checkMaxMin(edge[i]); } // calc right edge and copy into m_points fill1d(p2,p3,edge); for (int i=0;i<=m_res;i++) { m_points[i*m_size + m_res] = edge[i]; checkMaxMin(edge[i]); } // calc bottom edge and copy into m_points fill1d(p4,p3,edge); for (int i=0;i<=m_res;i++) { m_points[m_res*m_size + i] = edge[i]; checkMaxMin(edge[i]); } // seed the RNG - this is the 5th and last seeding for the tile. // it was seeded once for each edge, now once for the tile. //srand(p1.seed()*20 + p2.seed()*15 + p3.seed()*10 + p4.seed()*5); WFMath::MTRand::uint32 seed[4]={ p1.seed(), p2.seed(), p3.seed(), p4.seed() }; WFMath::MTRand rng(seed, 4); QuadInterp qi(m_res, p1.roughness(), p2.roughness(), p3.roughness(), p4.roughness()); float f = BasePoint::FALLOFF; float depth=0; // center of m_points is done separately int stride = m_res/2; //float roughness = (p1.roughness+p2.roughness+p3.roughness+p4.roughness)/(4.0f); float roughness = qi.calc(stride, stride); m_points[stride*m_size + stride] = qRMD(rng, m_points[0 * m_size + stride], m_points[stride*m_size + 0], m_points[stride*m_size + m_res], m_points[m_res*m_size + stride], roughness, f, depth); checkMaxMin(m_points[stride*m_size + stride]); stride >>= 1; // skip across the m_points and fill in the points // alternate cross and plus shapes. // this is a diamond-square algorithm. while (stride) { //Cross shape - + contributes to value at X //+ . + //. X . //+ . + for (int i=stride;i<m_res;i+=stride*2) { for (int j=stride;j<m_res;j+=stride*2) { roughness=qi.calc(i,j); m_points[j*m_size + i] = qRMD(rng, m_points[(i-stride) + (j+stride) * (m_size)], m_points[(i+stride) + (j-stride) * (m_size)], m_points[(i+stride) + (j+stride) * (m_size)], m_points[(i-stride) + (j-stride) * (m_size)], roughness, f, depth); checkMaxMin(m_points[j*m_size + i]); } } depth++; //Plus shape - + contributes to value at X //. + . //+ X + //. + . for (int i=stride*2;i<m_res;i+=stride*2) { for (int j=stride;j<m_res;j+=stride*2) { roughness=qi.calc(i,j); m_points[j*m_size + i] = qRMD(rng, m_points[(i-stride) + (j) * (m_size)], m_points[(i+stride) + (j) * (m_size)], m_points[(i) + (j+stride) * (m_size)], m_points[(i) + (j-stride) * (m_size)], roughness, f , depth); checkMaxMin(m_points[j*m_size + i]); } } for (int i=stride;i<m_res;i+=stride*2) { for (int j=stride*2;j<m_res;j+=stride*2) { roughness=qi.calc(i,j); m_points[j*m_size + i] = qRMD(rng, m_points[(i-stride) + (j) * (m_size)], m_points[(i+stride) + (j) * (m_size)], m_points[(i) + (j+stride) * (m_size)], m_points[(i) + (j-stride) * (m_size)], roughness, f, depth); checkMaxMin(m_points[j*m_size + i]); } } stride>>=1; depth++; } delete [] edge; }
CoordinatesPoint TranslatePointToCoord( BasePoint p ) { return CoordinatesPoint( PointPos( p.GetX(), p.GetY() ), "p", true ); }
BasePoint GetPointIntoSeg( BasePoint p1, BasePoint p2, double k ) { return BasePoint( p1.GetX() + (p2.GetX() - p1.GetX()) * k, p1.GetY() + (p2.GetY() - p1.GetY()) * k, p1.GetZ() + (p2.GetZ() - p1.GetZ()) * k ); }