Blender V5.3
kernel/device/metal/bvh.h
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2021-2022 Blender Foundation
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5/* MetalRT implementation of ray-scene intersection. */
6
7#pragma once
8
9#include "kernel/bvh/types.h"
10#include "kernel/bvh/util.h"
11
13
14/* Payload types.
15 *
16 * Best practice is to minimize the size of MetalRT payloads to avoid heavy spilling during
17 * intersection tests.
18 */
19
25
28#if defined(__METALRT_MOTION__)
29 int self_object;
30#endif
31};
32
34 uint prim;
35 float t, u, v;
36};
37
38/* Payload for the local intersection queries.
39 * It embeds a subset of storage that is typically found in the LocalIntersection. This is because
40 * it is not possible to store a pointer to the actual LocalIntersection in the payload. So some
41 * data is duplicated into the payload and then copied back to the LocalIntersection. */
44#if defined(__METALRT_MOTION__)
45 int self_object;
46#endif
47
53};
54
59
60#ifdef __HAIR__
61ccl_device_forceinline bool curve_ribbon_accept(KernelGlobals kg,
62 const float u,
63 float t,
64 const ccl_private Ray *ray,
65 const int object,
66 const int prim,
67 const int type)
68{
69 KernelCurve kcurve = kernel_data_fetch(curves, prim);
70
71 int k0 = kcurve.first_key + PRIMITIVE_UNPACK_SEGMENT(type);
72 int k1 = k0 + 1;
73 int ka = max(k0 - 1, kcurve.first_key);
74 int kb = min(k1 + 1, kcurve.first_key + kcurve.num_keys - 1);
75
76 /* We can ignore motion blur here because we don't need the positions, and it doesn't affect the
77 * radius. */
78 const int position_offset = kernel_data_fetch(objects, object).position_offset;
79 float radius[4];
80 radius[0] = kernel_data_fetch(curve_keys, position_offset + ka).w;
81 radius[1] = kernel_data_fetch(curve_keys, position_offset + k0).w;
82 radius[2] = kernel_data_fetch(curve_keys, position_offset + k1).w;
83 radius[3] = kernel_data_fetch(curve_keys, position_offset + kb).w;
84 const float r = metal::catmull_rom(u, radius[0], radius[1], radius[2], radius[3]);
85
86 /* MPJ TODO: Can we ignore motion and/or object transforms here? Depends on scaling? */
87 float3 ray_P = ray->P;
88 float3 ray_D = ray->D;
89 if (!(kernel_data_fetch(object_flag, object) & SD_OBJECT_TRANSFORM_APPLIED)) {
90 float3 idir;
91# if defined(__METALRT_MOTION__)
92 bvh_instance_motion_push(nullptr, object, ray, &ray_P, &ray_D, &idir);
93# else
94 bvh_instance_push(nullptr, object, ray, &ray_P, &ray_D, &idir);
95# endif
96 }
97
98 /* ignore self intersections */
99 const float avoidance_factor = 2.0f;
100 return t * len(ray_D) > avoidance_factor * r;
101}
102
103ccl_device_forceinline float curve_ribbon_v(KernelGlobals kg,
104 const float u,
105 float t,
106 const ccl_private Ray *ray,
107 const int object,
108 const int prim,
109 const int type)
110{
111# if defined(__METALRT_MOTION__)
112 float time = ray->time;
113# else
114 float time = 0.0f;
115# endif
116
117 const bool is_motion = (type & PRIMITIVE_MOTION);
118
119 KernelCurve kcurve = kernel_data_fetch(curves, prim);
120
121 int k0 = kcurve.first_key + PRIMITIVE_UNPACK_SEGMENT(type);
122 int k1 = k0 + 1;
123 int ka = max(k0 - 1, kcurve.first_key);
124 int kb = min(k1 + 1, kcurve.first_key + kcurve.num_keys - 1);
125
126 float4 curve[4];
127 if (!is_motion) {
128 const int position_offset = kernel_data_fetch(objects, object).position_offset;
129 curve[0] = kernel_data_fetch(curve_keys, position_offset + ka);
130 curve[1] = kernel_data_fetch(curve_keys, position_offset + k0);
131 curve[2] = kernel_data_fetch(curve_keys, position_offset + k1);
132 curve[3] = kernel_data_fetch(curve_keys, position_offset + kb);
133 }
134 else {
135 motion_curve_keys(kg, object, time, ka, k0, k1, kb, curve);
136 }
137
138 float3 ray_P = ray->P;
139 float3 ray_D = ray->D;
140 if (!(kernel_data_fetch(object_flag, object) & SD_OBJECT_TRANSFORM_APPLIED)) {
141 float3 idir;
142# if defined(__METALRT_MOTION__)
143 bvh_instance_motion_push(nullptr, object, ray, &ray_P, &ray_D, &idir);
144# else
145 bvh_instance_push(nullptr, object, ray, &ray_P, &ray_D, &idir);
146# endif
147 }
148
149 const float4 P_curve4 = metal::catmull_rom(u, curve[0], curve[1], curve[2], curve[3]);
150 const float r_curve = P_curve4.w;
151
152 float3 P = ray_P + ray_D * t;
153 const float3 P_curve = make_float3(P_curve4);
154
155 const float4 dPdu4 = metal::catmull_rom_derivative(u, curve[0], curve[1], curve[2], curve[3]);
156 const float3 dPdu = make_float3(dPdu4);
157
158 const float3 tangent = normalize(dPdu);
159 const float3 bitangent = normalize(cross(tangent, -ray_D));
160
161 float v = dot(P - P_curve, bitangent) / r_curve;
162 return clamp(v, -1.0, 1.0f);
163}
164#endif /* __HAIR__ */
165
166/* Scene intersection. */
167
169 const ccl_private Ray *ray,
170 const uint visibility,
172{
173 metal::raytracing::ray r(ray->P, ray->D, ray->tmin, ray->tmax);
174 metalrt_intersector_type metalrt_intersect;
175 metalrt_intersect.force_opacity(metal::raytracing::forced_opacity::non_opaque);
176 metalrt_intersect.assume_geometry_type(
177 metal::raytracing::geometry_type::triangle |
178 (kernel_data.bvh.have_curves ? metal::raytracing::geometry_type::curve :
179 metal::raytracing::geometry_type::none) |
180 (kernel_data.bvh.have_points ? metal::raytracing::geometry_type::bounding_box :
181 metal::raytracing::geometry_type::none));
182
183 typename metalrt_intersector_type::result_type intersection;
184
186 payload.self_prim = ray->self.prim;
187 payload.self_object = ray->self.object;
188 payload.visibility = visibility;
189
190 uint ray_mask = visibility & 0xFF;
191 if (0 == ray_mask && (visibility & ~0xFF) != 0) {
192 ray_mask = 0xFF;
193 }
194
195#if defined(__METALRT_MOTION__)
196 intersection = metalrt_intersect.intersect(r,
197 metal_ancillaries->accel_struct,
198 ray_mask,
199 ray->time,
200 metal_ancillaries->ift_default,
201 payload);
202#else
203 intersection = metalrt_intersect.intersect(
204 r, metal_ancillaries->accel_struct, ray_mask, metal_ancillaries->ift_default, payload);
205#endif
206
207 if (intersection.type == metal::raytracing::intersection_type::none) {
208 isect->t = ray->tmax;
209 isect->type = PRIMITIVE_NONE;
210
211 return false;
212 }
213
214 isect->object = intersection.instance_id;
215 isect->t = intersection.distance;
216 if (intersection.type == metal::raytracing::intersection_type::triangle) {
217 isect->prim = intersection.primitive_id + intersection.user_instance_id;
218 isect->type = kernel_data_fetch(objects, intersection.instance_id).primitive_type;
219 isect->u = intersection.triangle_barycentric_coord.x;
220 isect->v = intersection.triangle_barycentric_coord.y;
221 }
222#ifdef __HAIR__
223 else if (kernel_data.bvh.have_curves &&
224 intersection.type == metal::raytracing::intersection_type::curve)
225 {
226 int prim = intersection.primitive_id + intersection.user_instance_id;
227 const KernelCurveSegment segment = kernel_data_fetch(curve_segments, prim);
228 isect->prim = segment.prim;
229 isect->type = segment.type;
230 isect->u = intersection.curve_parameter;
231
232 if ((segment.type & PRIMITIVE_CURVE) == PRIMITIVE_CURVE_RIBBON) {
233 isect->v = curve_ribbon_v(kg,
234 intersection.curve_parameter,
235 intersection.distance,
236 ray,
237 intersection.instance_id,
238 segment.prim,
239 segment.type);
240 }
241 else {
242 isect->v = 0.0f;
243 }
244 }
245#endif /* __HAIR__ */
246#ifdef __POINTCLOUD__
247 else if (kernel_data.bvh.have_points &&
248 intersection.type == metal::raytracing::intersection_type::bounding_box)
249 {
250 isect->prim = intersection.primitive_id + intersection.user_instance_id;
251 isect->type = kernel_data_fetch(objects, intersection.instance_id).primitive_type;
252 isect->u = 0.0f;
253 isect->v = 0.0f;
254 }
255#endif /* __POINTCLOUD__ */
256
257 return true;
258}
259
261 const ccl_private Ray *ray,
262 const uint visibility)
263{
264 metal::raytracing::ray r(ray->P, ray->D, ray->tmin, ray->tmax);
265 metalrt_intersector_type metalrt_intersect;
266 metalrt_intersect.force_opacity(metal::raytracing::forced_opacity::non_opaque);
267 metalrt_intersect.assume_geometry_type(
268 metal::raytracing::geometry_type::triangle |
269 (kernel_data.bvh.have_curves ? metal::raytracing::geometry_type::curve :
270 metal::raytracing::geometry_type::none) |
271 (kernel_data.bvh.have_points ? metal::raytracing::geometry_type::bounding_box :
272 metal::raytracing::geometry_type::none));
273
274 typename metalrt_intersector_type::result_type intersection;
275
276 metalrt_intersect.accept_any_intersection(true);
277
279 payload.self = ray->self;
280 payload.visibility = visibility;
281
282 uint ray_mask = visibility & 0xFF;
283 if (0 == ray_mask && (visibility & ~0xFF) != 0) {
284 ray_mask = 0xFF;
285 }
286
287#if defined(__METALRT_MOTION__)
288 intersection = metalrt_intersect.intersect(r,
289 metal_ancillaries->accel_struct,
290 ray_mask,
291 ray->time,
292 metal_ancillaries->ift_shadow,
293 payload);
294#else
295 intersection = metalrt_intersect.intersect(
296 r, metal_ancillaries->accel_struct, ray_mask, metal_ancillaries->ift_shadow, payload);
297#endif
298 return (intersection.type != metal::raytracing::intersection_type::none);
299}
300
301#ifdef __BVH_LOCAL__
302template<bool single_hit = false>
303ccl_device_intersect bool scene_intersect_local(KernelGlobals kg,
304 const ccl_private Ray *ray,
305 ccl_private LocalIntersection *local_isect,
306 const int local_object,
307 ccl_private uint *lcg_state,
308 const int max_hits)
309{
310 uint primitive_id_offset = kernel_data_fetch(object_prim_offset, local_object);
311
312 metal::raytracing::ray r(ray->P, ray->D, ray->tmin, ray->tmax);
313
314# if defined(__METALRT_MOTION__)
315 metalrt_intersector_type metalrt_intersect;
316 typename metalrt_intersector_type::result_type intersection;
317# else
318 metalrt_blas_intersector_type metalrt_intersect;
319 typename metalrt_blas_intersector_type::result_type intersection;
320
321 if (!(kernel_data_fetch(object_flag, local_object) & SD_OBJECT_TRANSFORM_APPLIED)) {
322 /* Transform the ray into object's local space. */
323 Transform itfm = kernel_data_fetch(objects, local_object).itfm;
324 r.origin = transform_point(&itfm, r.origin);
325 r.direction = transform_direction(&itfm, r.direction);
326 }
327# endif
328
329 metalrt_intersect.assume_geometry_type(metal::raytracing::geometry_type::triangle);
330
331 if (single_hit) {
333 payload.self_prim = ray->self.prim - primitive_id_offset;
334
335# if defined(__METALRT_MOTION__)
336 /* We can't skip over the top-level BVH in the motion blur case, so still need to do
337 * the self-object check. */
338 payload.self_object = local_object;
339 metalrt_intersect.force_opacity(metal::raytracing::forced_opacity::non_opaque);
340 intersection = metalrt_intersect.intersect(r,
341 metal_ancillaries->accel_struct,
342 ~0,
343 ray->time,
344 metal_ancillaries->ift_local_single_hit_mblur,
345 payload);
346# else
347 /* We only need custom intersection filtering (i.e. non_opaque) if we are performing a
348 * self-primitive intersection check. */
349 metalrt_intersect.force_opacity((ray->self.prim == PRIM_NONE) ?
350 metal::raytracing::forced_opacity::opaque :
351 metal::raytracing::forced_opacity::non_opaque);
352 intersection = metalrt_intersect.intersect(
353 r,
354 metal_ancillaries->blas_accel_structs[local_object].blas,
355 metal_ancillaries->ift_local_single_hit,
356 payload);
357# endif
358
359 if (intersection.type == metal::raytracing::intersection_type::none) {
360 local_isect->num_hits = 0;
361 return false;
362 }
363
364 uint prim = intersection.primitive_id + primitive_id_offset;
365 int prim_type = kernel_data_fetch(objects, local_object).primitive_type;
366
367 local_isect->num_hits = 1;
368 local_isect->hits[0].prim = prim;
369 local_isect->hits[0].type = prim_type;
370 local_isect->hits[0].object = local_object;
371 local_isect->hits[0].u = intersection.triangle_barycentric_coord.x;
372 local_isect->hits[0].v = intersection.triangle_barycentric_coord.y;
373 local_isect->hits[0].t = intersection.distance;
374
375 const int position_offset = kernel_data_fetch(objects, local_object).position_offset;
376 const packed_uint3 tri_vindex = kernel_data_fetch(tri_vindex, prim);
377 const float3 tri_a = float3(kernel_data_fetch(tri_verts, position_offset + tri_vindex.x));
378 const float3 tri_b = float3(kernel_data_fetch(tri_verts, position_offset + tri_vindex.y));
379 const float3 tri_c = float3(kernel_data_fetch(tri_verts, position_offset + tri_vindex.z));
380 local_isect->Ng[0] = normalize(cross(tri_b - tri_a, tri_c - tri_a));
381 return true;
382 }
383 else {
385 payload.self_prim = ray->self.prim - primitive_id_offset;
386 payload.max_hits = max_hits;
387 payload.num_hits = 0;
388 if (lcg_state) {
389 payload.has_lcg_state = true;
390 payload.lcg_state = *lcg_state;
391 }
392 else {
393 payload.has_lcg_state = false;
394 }
395
396 metalrt_intersect.force_opacity(metal::raytracing::forced_opacity::non_opaque);
397
398# if defined(__METALRT_MOTION__)
399 /* We can't skip over the top-level BVH in the motion blur case, so still need to do
400 * the self-object check. */
401 payload.self_object = local_object;
402 intersection = metalrt_intersect.intersect(r,
403 metal_ancillaries->accel_struct,
404 ~0,
405 ray->time,
406 metal_ancillaries->ift_local_mblur,
407 payload);
408# else
409 intersection = metalrt_intersect.intersect(
410 r,
411 metal_ancillaries->blas_accel_structs[local_object].blas,
412 metal_ancillaries->ift_local,
413 payload);
414# endif
415
416 if (max_hits == 0) {
417 /* Special case for when no hit information is requested, just report that something was hit
418 */
419 return (intersection.type != metal::raytracing::intersection_type::none);
420 }
421
422 if (lcg_state) {
423 *lcg_state = payload.lcg_state;
424 }
425
426 const int num_hits = payload.num_hits;
427 if (local_isect) {
428
429 /* Record geometric normal */
430 int prim_type = kernel_data_fetch(objects, local_object).primitive_type;
431
432 /* Number of hits counted can be higher than recorded due to reservoir sampling. */
433 local_isect->num_hits = num_hits;
434 const int num_recorded_hits = min(payload.num_hits, max_hits);
435 for (int hit = 0; hit < num_recorded_hits; hit++) {
436 const uint prim = payload.hits[hit].prim + primitive_id_offset;
437 local_isect->hits[hit].prim = prim;
438 local_isect->hits[hit].t = payload.hits[hit].t;
439 local_isect->hits[hit].u = payload.hits[hit].u;
440 local_isect->hits[hit].v = payload.hits[hit].v;
441 local_isect->hits[hit].object = local_object;
442 local_isect->hits[hit].type = prim_type;
443
444 const int position_offset = kernel_data_fetch(objects, local_object).position_offset;
445 const packed_uint3 tri_vindex = kernel_data_fetch(tri_vindex, prim);
446 const float3 tri_a = float3(kernel_data_fetch(tri_verts, position_offset + tri_vindex.x));
447 const float3 tri_b = float3(kernel_data_fetch(tri_verts, position_offset + tri_vindex.y));
448 const float3 tri_c = float3(kernel_data_fetch(tri_verts, position_offset + tri_vindex.z));
449 local_isect->Ng[hit] = normalize(cross(tri_b - tri_a, tri_c - tri_a));
450 }
451 }
452 return num_hits > 0;
453 }
454}
455#endif
456
457#ifdef __TRANSPARENT_SHADOWS__
458ccl_device_intersect void scene_intersect_shadow_all_metalrt(
459 const ccl_private Ray *ray, ccl_private BVHShadowAllPayload &ccl_restrict payload)
460{
461 metal::raytracing::ray r(ray->P, ray->D, ray->tmin, ray->tmax);
462 metalrt_intersector_type metalrt_intersect;
463 metalrt_intersect.force_opacity(metal::raytracing::forced_opacity::non_opaque);
464 metalrt_intersect.assume_geometry_type(
465 metal::raytracing::geometry_type::triangle |
466 (kernel_data.bvh.have_curves ? metal::raytracing::geometry_type::curve :
467 metal::raytracing::geometry_type::none) |
468 (kernel_data.bvh.have_points ? metal::raytracing::geometry_type::bounding_box :
469 metal::raytracing::geometry_type::none));
470
471 uint ray_mask = payload.base.ray_visibility & 0xFF;
472 if (0 == ray_mask && (payload.base.ray_visibility & ~0xFF) != 0) {
473 ray_mask = 0xFF;
474 }
475
476 typename metalrt_intersector_type::result_type intersection;
477
478# if defined(__METALRT_MOTION__)
479 intersection = metalrt_intersect.intersect(r,
480 metal_ancillaries->accel_struct,
481 ray_mask,
482 ray->time,
483 metal_ancillaries->ift_shadow_all,
484 payload);
485# else
486 intersection = metalrt_intersect.intersect(
487 r, metal_ancillaries->accel_struct, ray_mask, metal_ancillaries->ift_shadow_all, payload);
488# endif
489
490 (void)intersection;
491}
492#endif
493
494#ifdef __VOLUME__
495ccl_device_intersect bool scene_intersect_volume(KernelGlobals kg,
496 const ccl_private Ray *ray,
498 const uint visibility)
499{
500 metal::raytracing::ray r(ray->P, ray->D, ray->tmin, ray->tmax);
501 metalrt_intersector_type metalrt_intersect;
502 metalrt_intersect.force_opacity(metal::raytracing::forced_opacity::non_opaque);
503 metalrt_intersect.set_geometry_cull_mode(metal::raytracing::geometry_cull_mode::bounding_box |
504 metal::raytracing::geometry_cull_mode::curve);
505 metalrt_intersect.assume_geometry_type(
506 metal::raytracing::geometry_type::triangle |
507 (kernel_data.bvh.have_curves ? metal::raytracing::geometry_type::curve :
508 metal::raytracing::geometry_type::none) |
509 (kernel_data.bvh.have_points ? metal::raytracing::geometry_type::bounding_box :
510 metal::raytracing::geometry_type::none));
511
513 payload.self = ray->self;
514 payload.visibility = visibility;
515
516 uint ray_mask = visibility & 0xFF;
517 if (0 == ray_mask && (visibility & ~0xFF) != 0) {
518 ray_mask = 0xFF;
519 }
520
521 typename metalrt_intersector_type::result_type intersection;
522
523# if defined(__METALRT_MOTION__)
524 intersection = metalrt_intersect.intersect(r,
525 metal_ancillaries->accel_struct,
526 ray_mask,
527 ray->time,
528 metal_ancillaries->ift_volume,
529 payload);
530# else
531 intersection = metalrt_intersect.intersect(
532 r, metal_ancillaries->accel_struct, ray_mask, metal_ancillaries->ift_volume, payload);
533# endif
534
535 if (intersection.type == metal::raytracing::intersection_type::triangle) {
536 isect->prim = intersection.primitive_id + intersection.user_instance_id;
537 isect->type = kernel_data_fetch(objects, intersection.instance_id).primitive_type;
538 isect->u = intersection.triangle_barycentric_coord.x;
539 isect->v = intersection.triangle_barycentric_coord.y;
540 isect->object = intersection.instance_id;
541 isect->t = intersection.distance;
542 return true;
543 }
544 return false;
545}
546#endif
547
btScalar max
#define kernel_data
#define ccl_restrict
#define ccl_device_forceinline
#define kernel_data_fetch(name, index)
#define PRIM_NONE
#define PRIMITIVE_UNPACK_SEGMENT(type)
#define LOCAL_MAX_HITS
#define ccl_private
#define CCL_NAMESPACE_END
ccl_device_forceinline float3 make_float3(const float x, const float y, const float z)
VecBase< float, D > normalize(VecOp< float, D >) RET
float dot(VecOp< float, D >, VecOp< float, D >) RET
VecBase< float, 3 > cross(VecOp< float, 3 >, VecOp< float, 3 >) RET
constexpr T clamp(T, U, U) RET
float3 transform_direction(float3x3 mat, float3 direction)
float3 transform_point(float3x3 mat, float3 point)
ccl_device_intersect bool scene_intersect(KernelGlobals kg, const ccl_private Ray *ray, const uint visibility, ccl_private Intersection *isect)
ccl_device_intersect bool scene_intersect_shadow(KernelGlobals kg, const ccl_private Ray *ray, const uint visibility)
#define ccl_device_intersect
ccl_device_inline void bvh_instance_push(KernelGlobals kg, const int object, const ccl_private Ray *ray, ccl_private float3 *P, ccl_private float3 *dir, ccl_private float3 *idir)
@ PRIMITIVE_MOTION
@ PRIMITIVE_NONE
@ PRIMITIVE_CURVE_RIBBON
@ PRIMITIVE_CURVE
@ SD_OBJECT_TRANSFORM_APPLIED
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
Intersection< segment > intersection
std::string time(const std::tm &date_time, TimeFormat format=TimeFormat::H24)
unsigned int uint
Definition BKE_text.h:55
ATTR_WARN_UNUSED_RESULT const BMVert * v
void visibility(Visibility &srt, const ViewCulling &culling, const uint3 global_id, const uint3 local_id, const uint3 workgroup_id)
#define min(a, b)
Definition sort.cc:38
MetalRTLocalHit hits[LOCAL_MAX_HITS]
float w
Definition sky_math.h:225