Differential D12367 Diff 41308 intern/cycles/kernel/bvh/bvh_traversal.h

Changeset View

Standalone View

intern/cycles/kernel/bvh/bvh_traversal.h

Show All 25 Lines
/* This is a template BVH traversal function, where various features can be		/* This is a template BVH traversal function, where various features can be
* enabled/disabled. This way we can compile optimized versions for each case		* enabled/disabled. This way we can compile optimized versions for each case
* without new features slowing things down.		* without new features slowing things down.
*		*
* BVH_HAIR: hair curve rendering		* BVH_HAIR: hair curve rendering
* BVH_MOTION: motion blur rendering		* BVH_MOTION: motion blur rendering
*/		*/

ccl_device_noinline bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,		ccl_device_noinline bool BVH_FUNCTION_FULL_NAME(BVH)(const KernelGlobals *kg,
const Ray *ray,		const Ray *ray,
Intersection *isect,		Intersection *isect,
const uint visibility)		const uint visibility)
{		{
/* todo:		/* todo:
* - test if pushing distance on the stack helps (for non shadow rays)		* - test if pushing distance on the stack helps (for non shadow rays)
* - separate version for shadow rays		* - separate version for shadow rays
* - likely and unlikely for if() statements		* - likely and unlikely for if() statements
▲ Show 20 Lines • Show All 88 Lines • ▼ Show 20 Lines	#endif
node_addr = traversal_stack[stack_ptr];		node_addr = traversal_stack[stack_ptr];
--stack_ptr;		--stack_ptr;

/* primitive intersection */		/* primitive intersection */
switch (type & PRIMITIVE_ALL) {		switch (type & PRIMITIVE_ALL) {
case PRIMITIVE_TRIANGLE: {		case PRIMITIVE_TRIANGLE: {
for (; prim_addr < prim_addr2; prim_addr++) {		for (; prim_addr < prim_addr2; prim_addr++) {
kernel_assert(kernel_tex_fetch(__prim_type, prim_addr) == type);		kernel_assert(kernel_tex_fetch(__prim_type, prim_addr) == type);
if (triangle_intersect(kg, isect, P, dir, visibility, object, prim_addr)) {		if (triangle_intersect(
		kg, isect, P, dir, isect->t, visibility, object, prim_addr)) {
/* shadow ray early termination */		/* shadow ray early termination */
if (visibility & PATH_RAY_SHADOW_OPAQUE)		if (visibility & PATH_RAY_SHADOW_OPAQUE)
return true;		return true;
}		}
}		}
break;		break;
}		}
#if BVH_FEATURE(BVH_MOTION)		#if BVH_FEATURE(BVH_MOTION)
case PRIMITIVE_MOTION_TRIANGLE: {		case PRIMITIVE_MOTION_TRIANGLE: {
for (; prim_addr < prim_addr2; prim_addr++) {		for (; prim_addr < prim_addr2; prim_addr++) {
kernel_assert(kernel_tex_fetch(__prim_type, prim_addr) == type);		kernel_assert(kernel_tex_fetch(__prim_type, prim_addr) == type);
if (motion_triangle_intersect(		if (motion_triangle_intersect(
kg, isect, P, dir, ray->time, visibility, object, prim_addr)) {		kg, isect, P, dir, isect->t, ray->time, visibility, object, prim_addr)) {
/* shadow ray early termination */		/* shadow ray early termination */
if (visibility & PATH_RAY_SHADOW_OPAQUE)		if (visibility & PATH_RAY_SHADOW_OPAQUE)
return true;		return true;
}		}
}		}
break;		break;
}		}
#endif /* BVH_FEATURE(BVH_MOTION) */		#endif /* BVH_FEATURE(BVH_MOTION) */
#if BVH_FEATURE(BVH_HAIR)		#if BVH_FEATURE(BVH_HAIR)
case PRIMITIVE_CURVE_THICK:		case PRIMITIVE_CURVE_THICK:
case PRIMITIVE_MOTION_CURVE_THICK:		case PRIMITIVE_MOTION_CURVE_THICK:
case PRIMITIVE_CURVE_RIBBON:		case PRIMITIVE_CURVE_RIBBON:
case PRIMITIVE_MOTION_CURVE_RIBBON: {		case PRIMITIVE_MOTION_CURVE_RIBBON: {
for (; prim_addr < prim_addr2; prim_addr++) {		for (; prim_addr < prim_addr2; prim_addr++) {
const uint curve_type = kernel_tex_fetch(__prim_type, prim_addr);		const uint curve_type = kernel_tex_fetch(__prim_type, prim_addr);
kernel_assert((curve_type & PRIMITIVE_ALL) == (type & PRIMITIVE_ALL));		kernel_assert((curve_type & PRIMITIVE_ALL) == (type & PRIMITIVE_ALL));
const bool hit = curve_intersect(		const bool hit = curve_intersect(kg,
kg, isect, P, dir, visibility, object, prim_addr, ray->time, curve_type);		isect,
		P,
		dir,
		isect->t,
		visibility,
		object,
		prim_addr,
		ray->time,
		curve_type);
if (hit) {		if (hit) {
/* shadow ray early termination */		/* shadow ray early termination */
if (visibility & PATH_RAY_SHADOW_OPAQUE)		if (visibility & PATH_RAY_SHADOW_OPAQUE)
return true;		return true;
}		}
}		}
break;		break;
}		}
#endif /* BVH_FEATURE(BVH_HAIR) */		#endif /* BVH_FEATURE(BVH_HAIR) */
}		}
}		}
else {		else {
/* instance push */		/* instance push */
object = kernel_tex_fetch(__prim_object, -prim_addr - 1);		object = kernel_tex_fetch(__prim_object, -prim_addr - 1);

#if BVH_FEATURE(BVH_MOTION)		#if BVH_FEATURE(BVH_MOTION)
isect->t = bvh_instance_motion_push(		isect->t *= bvh_instance_motion_push(kg, object, ray, &P, &dir, &idir, &ob_itfm);
kg, object, ray, &P, &dir, &idir, isect->t, &ob_itfm);
#else		#else
isect->t = bvh_instance_push(kg, object, ray, &P, &dir, &idir, isect->t);		isect->t *= bvh_instance_push(kg, object, ray, &P, &dir, &idir);
#endif		#endif

++stack_ptr;		++stack_ptr;
kernel_assert(stack_ptr < BVH_STACK_SIZE);		kernel_assert(stack_ptr < BVH_STACK_SIZE);
traversal_stack[stack_ptr] = ENTRYPOINT_SENTINEL;		traversal_stack[stack_ptr] = ENTRYPOINT_SENTINEL;

node_addr = kernel_tex_fetch(__object_node, object);		node_addr = kernel_tex_fetch(__object_node, object);
}		}
Show All 14 Lines	#endif
node_addr = traversal_stack[stack_ptr];		node_addr = traversal_stack[stack_ptr];
--stack_ptr;		--stack_ptr;
}		}
} while (node_addr != ENTRYPOINT_SENTINEL);		} while (node_addr != ENTRYPOINT_SENTINEL);

return (isect->prim != PRIM_NONE);		return (isect->prim != PRIM_NONE);
}		}

ccl_device_inline bool BVH_FUNCTION_NAME(KernelGlobals *kg,		ccl_device_inline bool BVH_FUNCTION_NAME(const KernelGlobals *kg,
const Ray *ray,		const Ray *ray,
Intersection *isect,		Intersection *isect,
const uint visibility)		const uint visibility)
{		{
return BVH_FUNCTION_FULL_NAME(BVH)(kg, ray, isect, visibility);		return BVH_FUNCTION_FULL_NAME(BVH)(kg, ray, isect, visibility);
}		}

#undef BVH_FUNCTION_NAME		#undef BVH_FUNCTION_NAME
#undef BVH_FUNCTION_FEATURES		#undef BVH_FUNCTION_FEATURES
#undef NODE_INTERSECT		#undef NODE_INTERSECT