void leafpushdown(Leaf *leaf, unsigned int depth)
{
float xmid = halfway(leaf->extents.xmin, leaf->extents.xmax);
float ymid = halfway(leaf->extents.ymin, leaf->extents.ymax);
Qnode *newnode = calloc(1, sizeof(Qnode));
if(newnode) {
LeafData *cur = leaf->contents.payload;
newnode->depth = depth;
newnode->ul.extents = BUILD_EXTENTS(leaf->extents.xmin, leaf->extents.ymin,
xmid, ymid);
newnode->ur.extents = BUILD_EXTENTS(xmid, leaf->extents.ymin,
leaf->extents.xmax, ymid);
newnode->ll.extents = BUILD_EXTENTS(leaf->extents.xmin, ymid,
xmid, leaf->extents.ymax);
newnode->lr.extents = BUILD_EXTENTS(xmid, ymid,
leaf->extents.xmax, leaf->extents.ymax);
while(cur) {
DO_CORNERS(cur->x, cur->y, MOVE_CORNER, newnode);
}
leaf->size = 0;
leaf->contents.leaf = newnode;
}
}
void subdivide (std::vector<vector>& vertices,
std::vector<triangle>& triangles)
{
std::vector<triangle> new_tris;
for (const triangle& tri : triangles)
{
unsigned int a(tri[0]), b(tri[1]), c(tri[2]);
unsigned int d, e, f;
vector n1 (normalize(halfway(vertices[a], vertices[b])));
auto f1 (std::find (vertices.begin(), vertices.end(), n1));
if (f1 == vertices.end())
{
d = vertices.size();
vertices.push_back(n1);
}
else
{
d = std::distance(vertices.begin(), f1);
}
vector n2 (normalize(halfway(vertices[b], vertices[c])));
auto f2 (std::find (vertices.begin(), vertices.end(), n2));
if (f2 == vertices.end())
{
e = vertices.size();
vertices.push_back(n2);
}
else
{
e = std::distance(vertices.begin(), f2);
}
vector n3 (normalize(halfway(vertices[c], vertices[a])));
auto f3 (std::find (vertices.begin(), vertices.end(), n3));
if (f3 == vertices.end())
{
f = vertices.size();
vertices.push_back(n3);
}
else
{
f = std::distance(vertices.begin(), f3);
}
new_tris.push_back(make_triangle(a, d, f));
new_tris.push_back(make_triangle(d, b, e));
new_tris.push_back(make_triangle(f, e, c));
new_tris.push_back(make_triangle(d, e, f));
}
triangles.swap(new_tris);
}
void newtree(QuadTree *qt,
unsigned int maxsize,
unsigned int maxdepth,
Extent extents)
{
float xmid = halfway(extents.xmin,extents.xmax);
float ymid = halfway(extents.ymin,extents.ymax);
qt->head = NULL;
qt->maxsize = maxsize;
qt->maxdepth = maxdepth;
qt->extents = extents;
qt->head = calloc(1,sizeof(Qnode));
qt->head->depth = 1;
qt->head->ul.extents = BUILD_EXTENTS(qt->extents.xmin,
qt->extents.ymin,
xmid,
ymid);
qt->head->ur.extents = BUILD_EXTENTS(xmid,
qt->extents.ymin,
qt->extents.xmax,
ymid);
qt->head->ll.extents = BUILD_EXTENTS(qt->extents.xmin,
ymid,
xmid,
qt->extents.ymax);
qt->head->lr.extents = BUILD_EXTENTS(xmid,
ymid,
qt->extents.xmax,
qt->extents.ymax);
if (!qt->head) { // calloc has thrown a hizzy!
return;
}
}
optional<cache_iterator_type> advance(const tangent_vector& tangent, const double& from_t, const double& to_t, size_t recursion = 1) const
{
if (recursion > max_recursion_)
return optional<cache_iterator_type>();
//log_cout << " Parallel transport: " << from_t << " -> " << to_t << endl;
for (set<std::shared_ptr<chart> >::const_iterator i = charts().begin(); i != charts().end(); ++i)
if (tangent[*i])
{
optional<cache_iterator_type> result(advance_on_chart(*i, *tangent[*i], from_t, to_t));
if (result)
return result;
}
optional<cache_iterator_type> halfway(advance(tangent, from_t, (from_t + to_t) / 2, recursion + 1));
return halfway ? advance(*(*halfway)->second, (from_t + to_t) / 2, to_t, recursion + 1) : optional<cache_iterator_type>();
}
const HTMLEntityTableEntry* HTMLEntitySearch::findLast(UChar nextCharacter) const
{
const HTMLEntityTableEntry* left = m_first;
const HTMLEntityTableEntry* right = m_last;
if (left == right)
return right;
CompareResult result = compare(right, nextCharacter);
if (result == Prefix)
return right;
if (result == Before)
return left;
while (left + 1 < right) {
const HTMLEntityTableEntry* probe = halfway(left, right);
result = compare(probe, nextCharacter);
if (result == After)
right = probe;
else {
ASSERT(result == Before || result == Prefix);
left = probe;
}
}
ASSERT(left + 1 == right);
return left;
}
/*
* zero or positive weight is the number of interesting commits it can
* reach, including itself. Especially, weight = 0 means it does not
* reach any tree-changing commits (e.g. just above uninteresting one
* but traversal is with pathspec).
*
* weight = -1 means it has one parent and its distance is yet to
* be computed.
*
* weight = -2 means it has more than one parent and its distance is
* unknown. After running count_distance() first, they will get zero
* or positive distance.
*/
static struct commit_list *do_find_bisection(struct commit_list *list,
int nr, int *weights,
int find_all)
{
int n, counted;
struct commit_list *p;
counted = 0;
for (n = 0, p = list; p; p = p->next) {
struct commit *commit = p->item;
unsigned flags = commit->object.flags;
p->item->util = &weights[n++];
switch (count_interesting_parents(commit)) {
case 0:
if (!(flags & TREESAME)) {
weight_set(p, 1);
counted++;
show_list("bisection 2 count one",
counted, nr, list);
}
/*
* otherwise, it is known not to reach any
* tree-changing commit and gets weight 0.
*/
break;
case 1:
weight_set(p, -1);
break;
default:
weight_set(p, -2);
break;
}
}
show_list("bisection 2 initialize", counted, nr, list);
/*
* If you have only one parent in the resulting set
* then you can reach one commit more than that parent
* can reach. So we do not have to run the expensive
* count_distance() for single strand of pearls.
*
* However, if you have more than one parents, you cannot
* just add their distance and one for yourself, since
* they usually reach the same ancestor and you would
* end up counting them twice that way.
*
* So we will first count distance of merges the usual
* way, and then fill the blanks using cheaper algorithm.
*/
for (p = list; p; p = p->next) {
if (p->item->object.flags & UNINTERESTING)
continue;
if (weight(p) != -2)
continue;
weight_set(p, count_distance(p));
clear_distance(list);
/* Does it happen to be at exactly half-way? */
if (!find_all && halfway(p, nr))
return p;
counted++;
}
show_list("bisection 2 count_distance", counted, nr, list);
while (counted < nr) {
for (p = list; p; p = p->next) {
struct commit_list *q;
unsigned flags = p->item->object.flags;
if (0 <= weight(p))
continue;
for (q = p->item->parents; q; q = q->next) {
if (q->item->object.flags & UNINTERESTING)
continue;
if (0 <= weight(q))
break;
}
if (!q)
continue;
/*
* weight for p is unknown but q is known.
* add one for p itself if p is to be counted,
* otherwise inherit it from q directly.
*/
if (!(flags & TREESAME)) {
weight_set(p, weight(q)+1);
counted++;
show_list("bisection 2 count one",
counted, nr, list);
}
else
weight_set(p, weight(q));
/* Does it happen to be at exactly half-way? */
if (!find_all && halfway(p, nr))
return p;
}
}
show_list("bisection 2 counted all", counted, nr, list);
if (!find_all)
return best_bisection(list, nr);
else
return best_bisection_sorted(list, nr);
}
Color Shade(
int hitObj, // which object was hit
Ray R, // the ray that hit
RayHit hit, // result of intersection test
int lev) // level in trace recursion
{
Vector temp = R.v.clone();
temp.scale(hit.tValue);
Point poc = ptPlusVec(R.p, temp);
Vector norm = hit.norm;
Pigment* p = thePigs[theShapes[hitObj]->pig];
Finish* f = theFins[theShapes[hitObj]->fin];
Color col(0, 0, 0);
for (int i = 0; i < nLgts; i++) {
if (i == 0)
col.accumulate((theLgts[i]->col).dotWith(p->getColorAt(poc)).scaleBy(f->amb));
else {
Ray LightRay = Ray(poc, ptToPt(poc, theLgts[i]->loc));
LightRay.tValue = ptToPt(poc, theLgts[i]->loc).length();
if (!Hit(LightRay)) {
Light* l = theLgts[i];
Scalar d = dist(poc, l->loc);
Scalar atten = 1/(l->a + l->b*d + l->c*d*d);
//diff
Color temp = p->getColorAt(poc);
temp = temp.scaleBy(f->diff);
temp = temp.scaleBy(max(0, dotProd(norm, LightRay.v)));
temp = temp.scaleBy(atten);
temp = temp.dotWith(l->col);
col.accumulate(temp);
//spec
temp = l->col;
temp = temp.scaleBy(f->spec);
Vector view = R.v.clone();
view.scale(-1);
temp = temp.scaleBy(max(0, pow(dotProd(norm, halfway(LightRay.v, view)), f->shiny)));
temp = temp.scaleBy(atten);
col.accumulate(temp);
}
}
}
if (f->refl != 0) {
Vector v = R.v.clone();
v.scale(-1);
Vector n = norm.clone();
n.scale(2*dotProd(n, v));
Vector r = Vector(n.x - v.x, n.y - v.y, n.z - v.z);
Ray R2 = Ray(poc, r);
Color reflCol = Trace(R2, lev + 1);
reflCol = reflCol.scaleBy(f->refl);
col.accumulate(reflCol);
}
if (f->trans != 0) {
Vector v = R.v.clone();
v.scale(-1);
Vector n = norm.clone();
Scalar cosI = dotProd(v, n);
Scalar eta = 1;
if (hit.insideObj)
eta = f->ior;
else
eta = 1/(f->ior);
if (1 - eta*eta*(1 - cosI*cosI) < 0 && f->refl == 0) {
n.scale(2*dotProd(n, v));
Vector r = Vector(n.x - v.x, n.y - v.y, n.z - v.z);
Ray R2 = Ray(poc, r);
Color reflCol = Trace(R2, lev + 1);
reflCol = reflCol.scaleBy(f->refl);
col.accumulate(reflCol);
}
else {
Scalar cosT = sqrt(1 - eta*eta*(1 - cosI*cosI));
n.scale(eta*cosI-cosT);
v.scale(eta);
Vector r = Vector(n.x - v.x, n.y - v.y, n.z - v.z);
Ray R2 = Ray(poc, r);
Color refrCol = Trace(R2, lev + 1);
refrCol = refrCol.scaleBy(f->trans);
col.accumulate(refrCol);
}
}
return col;
//naive
//return p->getColorAt(poc);
}