Cycles: Cleanup, move Embree BVH logic to own file

There is no way we can keep generic entry point functions easy to
follow if we start adding actual logic in them.

1 files changed, 121 insertions, 0 deletions

diff --git a/intern/cycles/kernel/bvh/bvh_embree.h b/intern/cycles/kernel/bvh/bvh_embree.h
index 34a099ebb4d..db6a1e3ac08 100644
--- a/intern/cycles/kernel/bvh/bvh_embree.h
+++ b/intern/cycles/kernel/bvh/bvh_embree.h
@@ -123,4 +123,125 @@ ccl_device_inline void kernel_embree_convert_local_hit(KernelGlobals *kg, const
 	isect->type = kernel_tex_fetch(__prim_type, isect->prim);
 }
 
+ccl_device_inline bool embree_scene_intersect(KernelGlobals *kg,
+                                              const Ray *ray,
+                                              const uint visibility,
+                                              Intersection *isect)
+{
+	kernel_assert(kernel_data.bvh.scene != NULL);
+	isect->t = ray->t;
+	CCLIntersectContext ctx(kg, CCLIntersectContext::RAY_REGULAR);
+	IntersectContext rtc_ctx(&ctx);
+	RTCRayHit ray_hit;
+	kernel_embree_setup_rayhit(*ray, ray_hit, visibility);
+	rtcIntersect1(kernel_data.bvh.scene, &rtc_ctx.context, &ray_hit);
+	if(ray_hit.hit.geomID != RTC_INVALID_GEOMETRY_ID && ray_hit.hit.primID != RTC_INVALID_GEOMETRY_ID) {
+		kernel_embree_convert_hit(kg, &ray_hit.ray, &ray_hit.hit, isect);
+		return true;
+	}
+	return false;
+}
+
+#ifdef __BVH_LOCAL__
+ccl_device_inline bool embree_scene_intersect_local(
+        KernelGlobals *kg,
+        const Ray ray,
+        LocalIntersection *local_isect,
+        int local_object,
+        uint *lcg_state,
+        int max_hits)
+{
+	kernel_assert(kernel_data.bvh.scene != NULL);
+	CCLIntersectContext ctx(kg, CCLIntersectContext::RAY_SSS);
+	ctx.lcg_state = lcg_state;
+	ctx.max_hits = max_hits;
+	ctx.ss_isect = local_isect;
+	local_isect->num_hits = 0;
+	ctx.sss_object_id = local_object;
+	IntersectContext rtc_ctx(&ctx);
+	RTCRay rtc_ray;
+	kernel_embree_setup_ray(ray, rtc_ray, PATH_RAY_ALL_VISIBILITY);
+	/* Get the Embree scene for this intersection. */
+	RTCGeometry geom = rtcGetGeometry(kernel_data.bvh.scene, local_object * 2);
+	if(geom) {
+		float3 P = ray.P;
+		float3 dir = ray.D;
+		float3 idir = ray.D;
+		const int object_flag = kernel_tex_fetch(__object_flag, local_object);
+		if(!(object_flag & SD_OBJECT_TRANSFORM_APPLIED)) {
+			Transform ob_itfm;
+			rtc_ray.tfar = bvh_instance_motion_push(kg,
+													local_object,
+													&ray,
+													&P,
+													&dir,
+													&idir,
+													ray.t,
+													&ob_itfm);
+			/* bvh_instance_motion_push() returns the inverse transform but
+				* it's not needed here. */
+			(void) ob_itfm;
+
+			rtc_ray.org_x = P.x;
+			rtc_ray.org_y = P.y;
+			rtc_ray.org_z = P.z;
+			rtc_ray.dir_x = dir.x;
+			rtc_ray.dir_y = dir.y;
+			rtc_ray.dir_z = dir.z;
+		}
+		RTCScene scene = (RTCScene)rtcGetGeometryUserData(geom);
+		if(scene) {
+			rtcOccluded1(scene, &rtc_ctx.context, &rtc_ray);
+		}
+	}
+	return local_isect->num_hits > 0;
+}
+#endif  /* __BVH_LOCAL__ */
+
+#ifdef __SHADOW_RECORD_ALL__
+ccl_device_inline bool embree_scene_intersect_shadow_all(
+        KernelGlobals *kg,
+        const Ray *ray,
+        Intersection *isect,
+        uint max_hits,
+        uint *num_hits)
+{
+	kernel_assert(kernel_data.bvh.scene != NULL);
+	CCLIntersectContext ctx(kg, CCLIntersectContext::RAY_SHADOW_ALL);
+	ctx.isect_s = isect;
+	ctx.max_hits = max_hits;
+	ctx.num_hits = 0;
+	IntersectContext rtc_ctx(&ctx);
+	RTCRay rtc_ray;
+	kernel_embree_setup_ray(*ray, rtc_ray, PATH_RAY_SHADOW);
+	rtcOccluded1(kernel_data.bvh.scene, &rtc_ctx.context, &rtc_ray);
+	if(ctx.num_hits > max_hits) {
+		return true;
+	}
+	*num_hits = ctx.num_hits;
+	return rtc_ray.tfar == -INFINITY;
+}
+#endif  /* __SHADOW_RECORD_ALL__ */
+
+#ifdef __VOLUME_RECORD_ALL__
+ccl_device_inline uint embree_scene_intersect_volume_all(
+        KernelGlobals *kg,
+        const Ray *ray,
+        Intersection *isect,
+        const uint max_hits,
+        const uint visibility)
+{
+	kernel_assert(kernel_data.bvh.scene != NULL);
+	CCLIntersectContext ctx(kg, CCLIntersectContext::RAY_VOLUME_ALL);
+	ctx.isect_s = isect;
+	ctx.max_hits = max_hits;
+	ctx.num_hits = 0;
+	IntersectContext rtc_ctx(&ctx);
+	RTCRay rtc_ray;
+	kernel_embree_setup_ray(*ray, rtc_ray, visibility);
+	rtcOccluded1(kernel_data.bvh.scene, &rtc_ctx.context, &rtc_ray);
+	return rtc_ray.tfar == -INFINITY;
+}
+#endif  /* __VOLUME_RECORD_ALL__ */
+
 CCL_NAMESPACE_END