bool BSPTree::intersect_node(Ray &ray, const BSPNode &node, double t_min, double t_max) const
{
node_calls++;
if (node.axis_leaf==4)
{
bool found = false;
for(int i=0; i < node.count; ++i)
{
const ISectTri* tri = all_objects[node.id+i];
if (intersect(ray, *tri, t_max))
found=true;
//const TriAccel* tri2 = all_triaccel[node.id+i];
//if (intersect2(ray, *tri2, t_max))
// found=true;
}
if (found)
return true;
else
return false;
}
else
{
BSPNode *near_node;
BSPNode *far_node;
if (ray.direction[node.axis_leaf]>=0)
{
near_node = node.left;
far_node = node.right;
}
else
{
near_node = node.right;
far_node = node.left;
}
// In order to avoid instability
double t;
if (fabs(ray.direction[node.axis_leaf])<d_eps)
t = (node.plane - ray.origin[node.axis_leaf])/d_eps;// intersect node plane;
else
t = (node.plane - ray.origin[node.axis_leaf])/ray.direction[node.axis_leaf];// intersect node plane;
if (t>t_max)
return intersect_node(ray, *near_node, t_min, t_max);
else if (t<t_min)
return intersect_node(ray, *far_node, t_min, t_max);
else
{
if (intersect_node(ray, *near_node, t_min, t))
return true;
else
return intersect_node(ray, *far_node, t, t_max);
}
}
}
void RStarTreeNode::intersect_tree(const Frustum &frustum,
const PlaneMask mask, BoundedObjectPtrVector &visitor) const
{
Uint32 i;
PlaneMask out_mask;
IntersectionType result;
if (get_leaf())
{
intersect_node(frustum, mask, visitor);
}
else
{
for (i = 0; i < get_count(); i++)
{
result = frustum.intersect(get_element_bounding_box(i),
mask, out_mask);
switch (result)
{
case it_inside:
{
get_node(i)->add_node(visitor);
break;
}
case it_intersect:
{
get_node(i)->intersect_tree(
frustum, out_mask,
visitor);
break;
}
case it_outside:
{
break;
}
}
}
}
}
bool BSPTree::intersect(Ray &ray) const
{
double t_min, t_max;
bbox.intersect_min_max(ray, t_min, t_max);
if (t_min>t_max)
return false;
if (!intersect_node(ray, *root, t_min, t_max))
return false;
//intersect_fast_node(ray, &fast_tree[0], t_min, t_max);
//if (!ray.has_hit)
// return false;
else
{
// Calculate the normal at the intersection
ray.id = reinterpret_cast<size_t>(ray.hit_object);
ray.hit_object = trimesh[ray.id];
const Vec3i& face = ray.hit_object->normals.face(ray.hit_face_id);
const Vec3f& normal0 = ray.hit_object->normals.vertex(face[0]);
const Vec3f& normal1 = ray.hit_object->normals.vertex(face[1]);
const Vec3f& normal2 = ray.hit_object->normals.vertex(face[2]);
ray.hit_normal = transforms[ray.id].mul_3D_vector(
normalize(normal0*(1 - ray.u - ray.v) + normal1*ray.u + normal2*ray.v));
ray.hit_pos = ray.origin + ray.direction*ray.dist;
/*
const Vec3i& face = ray.hit_object->normals.face(ray.hit_face_id);
const Vec3f& normal0 = ray.hit_object->normals.vertex(face[0]);
const Vec3f& normal1 = ray.hit_object->normals.vertex(face[1]);
const Vec3f& normal2 = ray.hit_object->normals.vertex(face[2]);
ray.hit_normal = normalize(normal0*(1 - ray.u - ray.v) + normal1*ray.u + normal2*ray.v);
ray.hit_pos = ray.origin + ray.direction*ray.dist;
*/
return true;
}
}
void BVH4Intersector4Hybrid<types,robust,PrimitiveIntersector4>::intersect(bool4* valid_i, BVH4* bvh, Ray4& ray)
{
/* verify correct input */
bool4 valid0 = *valid_i;
#if defined(RTCORE_IGNORE_INVALID_RAYS)
valid0 &= ray.valid();
#endif
assert(all(valid0,ray.tnear > -FLT_MIN));
assert(!(types & BVH4::FLAG_NODE_MB) || all(valid0,ray.time >= 0.0f & ray.time <= 1.0f));
/* load ray */
Vec3f4 ray_org = ray.org;
Vec3f4 ray_dir = ray.dir;
float4 ray_tnear = ray.tnear, ray_tfar = ray.tfar;
const Vec3f4 rdir = rcp_safe(ray_dir);
const Vec3f4 org(ray_org), org_rdir = org * rdir;
ray_tnear = select(valid0,ray_tnear,float4(pos_inf));
ray_tfar = select(valid0,ray_tfar ,float4(neg_inf));
const float4 inf = float4(pos_inf);
Precalculations pre(valid0,ray);
/* compute near/far per ray */
Vec3i4 nearXYZ;
nearXYZ.x = select(rdir.x >= 0.0f,int4(0*(int)sizeof(float4)),int4(1*(int)sizeof(float4)));
nearXYZ.y = select(rdir.y >= 0.0f,int4(2*(int)sizeof(float4)),int4(3*(int)sizeof(float4)));
nearXYZ.z = select(rdir.z >= 0.0f,int4(4*(int)sizeof(float4)),int4(5*(int)sizeof(float4)));
/* allocate stack and push root node */
float4 stack_near[stackSizeChunk];
NodeRef stack_node[stackSizeChunk];
stack_node[0] = BVH4::invalidNode;
stack_near[0] = inf;
stack_node[1] = bvh->root;
stack_near[1] = ray_tnear;
NodeRef* stackEnd = stack_node+stackSizeChunk;
NodeRef* __restrict__ sptr_node = stack_node + 2;
float4* __restrict__ sptr_near = stack_near + 2;
while (1) pop:
{
/* pop next node from stack */
assert(sptr_node > stack_node);
sptr_node--;
sptr_near--;
NodeRef cur = *sptr_node;
if (unlikely(cur == BVH4::invalidNode)) {
assert(sptr_node == stack_node);
break;
}
/* cull node if behind closest hit point */
float4 curDist = *sptr_near;
const bool4 active = curDist < ray_tfar;
if (unlikely(none(active)))
continue;
/* switch to single ray traversal */
#if !defined(__WIN32__) || defined(__X86_64__)
size_t bits = movemask(active);
if (unlikely(__popcnt(bits) <= SWITCH_THRESHOLD)) {
for (size_t i=__bsf(bits); bits!=0; bits=__btc(bits,i), i=__bsf(bits)) {
BVH4Intersector4Single<types,robust,PrimitiveIntersector4>::intersect1(bvh, cur, i, pre, ray, ray_org, ray_dir, rdir, ray_tnear, ray_tfar, nearXYZ);
}
ray_tfar = min(ray_tfar,ray.tfar);
continue;
}
#endif
while (1)
{
/* process normal nodes */
if (likely((types & 0x1) && cur.isNode()))
{
const bool4 valid_node = ray_tfar > curDist;
STAT3(normal.trav_nodes,1,popcnt(valid_node),4);
const Node* __restrict__ const node = cur.node();
/* pop of next node */
assert(sptr_node > stack_node);
sptr_node--;
sptr_near--;
cur = *sptr_node;
curDist = *sptr_near;
#pragma unroll(4)
for (unsigned i=0; i<BVH4::N; i++)
{
const NodeRef child = node->children[i];
if (unlikely(child == BVH4::emptyNode)) break;
float4 lnearP; const bool4 lhit = intersect_node<robust>(node,i,org,rdir,org_rdir,ray_tnear,ray_tfar,lnearP);
/* if we hit the child we choose to continue with that child if it
is closer than the current next child, or we push it onto the stack */
if (likely(any(lhit)))
{
assert(sptr_node < stackEnd);
assert(child != BVH4::emptyNode);
const float4 childDist = select(lhit,lnearP,inf);
sptr_node++;
sptr_near++;
/* push cur node onto stack and continue with hit child */
if (any(childDist < curDist))
{
*(sptr_node-1) = cur;
*(sptr_near-1) = curDist;
curDist = childDist;
cur = child;
}
/* push hit child onto stack */
else {
*(sptr_node-1) = child;
*(sptr_near-1) = childDist;
}
}
}
#if SWITCH_DURING_DOWN_TRAVERSAL == 1
// seems to be the best place for testing utilization
if (unlikely(popcnt(ray_tfar > curDist) <= SWITCH_THRESHOLD))
{
*sptr_node++ = cur;
*sptr_near++ = curDist;
goto pop;
}
#endif
}
/* process motion blur nodes */
else if (likely((types & 0x10) && cur.isNodeMB()))
{
const bool4 valid_node = ray_tfar > curDist;
STAT3(normal.trav_nodes,1,popcnt(valid_node),4);
const BVH4::NodeMB* __restrict__ const node = cur.nodeMB();
/* pop of next node */
assert(sptr_node > stack_node);
sptr_node--;
sptr_near--;
cur = *sptr_node;
curDist = *sptr_near;
#pragma unroll(4)
for (unsigned i=0; i<BVH4::N; i++)
{
const NodeRef child = node->child(i);
if (unlikely(child == BVH4::emptyNode)) break;
float4 lnearP; const bool4 lhit = intersect_node(node,i,org,rdir,org_rdir,ray_tnear,ray_tfar,ray.time,lnearP);
/* if we hit the child we choose to continue with that child if it
is closer than the current next child, or we push it onto the stack */
if (likely(any(lhit)))
{
assert(sptr_node < stackEnd);
assert(child != BVH4::emptyNode);
const float4 childDist = select(lhit,lnearP,inf);
sptr_node++;
sptr_near++;
/* push cur node onto stack and continue with hit child */
if (any(childDist < curDist))
{
*(sptr_node-1) = cur;
*(sptr_near-1) = curDist;
curDist = childDist;
cur = child;
}
/* push hit child onto stack */
else {
*(sptr_node-1) = child;
*(sptr_near-1) = childDist;
}
}
}
#if SWITCH_DURING_DOWN_TRAVERSAL == 1
// seems to be the best place for testing utilization
if (unlikely(popcnt(ray_tfar > curDist) <= SWITCH_THRESHOLD))
{
*sptr_node++ = cur;
*sptr_near++ = curDist;
goto pop;
}
#endif
}
else
break;
}
void BVH4Intersector8Chunk<types, robust, PrimitiveIntersector8>::intersect(bool8* valid_i, BVH4* bvh, Ray8& ray)
{
/* verify correct input */
bool8 valid0 = *valid_i;
#if defined(RTCORE_IGNORE_INVALID_RAYS)
valid0 &= ray.valid();
#endif
assert(all(valid0,ray.tnear > -FLT_MIN));
assert(!(types & BVH4::FLAG_NODE_MB) || all(valid0,ray.time >= 0.0f & ray.time <= 1.0f));
/* load ray */
const Vec3f8 rdir = rcp_safe(ray.dir);
const Vec3f8 org(ray.org), org_rdir = org * rdir;
float8 ray_tnear = select(valid0,ray.tnear,pos_inf);
float8 ray_tfar = select(valid0,ray.tfar ,neg_inf);
const float8 inf = float8(pos_inf);
Precalculations pre(valid0,ray);
/* allocate stack and push root node */
float8 stack_near[stackSize];
NodeRef stack_node[stackSize];
stack_node[0] = BVH4::invalidNode;
stack_near[0] = inf;
stack_node[1] = bvh->root;
stack_near[1] = ray_tnear;
NodeRef* stackEnd = stack_node+stackSize;
NodeRef* __restrict__ sptr_node = stack_node + 2;
float8* __restrict__ sptr_near = stack_near + 2;
while (1)
{
/* pop next node from stack */
assert(sptr_node > stack_node);
sptr_node--;
sptr_near--;
NodeRef cur = *sptr_node;
if (unlikely(cur == BVH4::invalidNode)) {
assert(sptr_node == stack_node);
break;
}
/* cull node if behind closest hit point */
float8 curDist = *sptr_near;
if (unlikely(none(ray_tfar > curDist)))
continue;
while (1)
{
/* process normal nodes */
if (likely((types & 0x1) && cur.isNode()))
{
const bool8 valid_node = ray_tfar > curDist;
STAT3(normal.trav_nodes,1,popcnt(valid_node),8);
const Node* __restrict__ const node = cur.node();
/* pop of next node */
assert(sptr_node > stack_node);
sptr_node--;
sptr_near--;
cur = *sptr_node;
curDist = *sptr_near;
#pragma unroll(4)
for (unsigned i=0; i<BVH4::N; i++)
{
const NodeRef child = node->children[i];
if (unlikely(child == BVH4::emptyNode)) break;
float8 lnearP; const bool8 lhit = intersect8_node<robust>(node,i,org,rdir,org_rdir,ray_tnear,ray_tfar,lnearP);
/* if we hit the child we choose to continue with that child if it
is closer than the current next child, or we push it onto the stack */
if (likely(any(lhit)))
{
assert(sptr_node < stackEnd);
assert(child != BVH4::emptyNode);
const float8 childDist = select(lhit,lnearP,inf);
sptr_node++;
sptr_near++;
/* push cur node onto stack and continue with hit child */
if (any(childDist < curDist))
{
*(sptr_node-1) = cur;
*(sptr_near-1) = curDist;
curDist = childDist;
cur = child;
}
/* push hit child onto stack */
else {
*(sptr_node-1) = child;
*(sptr_near-1) = childDist;
}
}
}
}
/* process motion blur nodes */
else if (likely((types & 0x10) && cur.isNodeMB()))
{
const bool8 valid_node = ray_tfar > curDist;
STAT3(normal.trav_nodes,1,popcnt(valid_node),8);
const BVH4::NodeMB* __restrict__ const node = cur.nodeMB();
/* pop of next node */
assert(sptr_node > stack_node);
sptr_node--;
sptr_near--;
cur = *sptr_node;
curDist = *sptr_near;
#pragma unroll(4)
for (unsigned i=0; i<BVH4::N; i++)
{
const NodeRef child = node->child(i);
if (unlikely(child == BVH4::emptyNode)) break;
float8 lnearP; const bool8 lhit = intersect_node(node,i,org,rdir,org_rdir,ray_tnear,ray_tfar,ray.time,lnearP);
/* if we hit the child we choose to continue with that child if it
is closer than the current next child, or we push it onto the stack */
if (likely(any(lhit)))
{
assert(sptr_node < stackEnd);
assert(child != BVH4::emptyNode);
const float8 childDist = select(lhit,lnearP,inf);
sptr_node++;
sptr_near++;
/* push cur node onto stack and continue with hit child */
if (any(childDist < curDist))
{
*(sptr_node-1) = cur;
*(sptr_near-1) = curDist;
curDist = childDist;
cur = child;
}
/* push hit child onto stack */
else {
*(sptr_node-1) = child;
*(sptr_near-1) = childDist;
}
}
}
}
else
break;
}
