Blender V5.3
kernel/device/hiprt/bvh.h
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#pragma once
6
8
10
19
20/* --------------------------------------------------------------------
21 * Utilities.
22 */
23
25 ccl_private hiprtRay &ray_hip)
26{
27 ray_hip.direction = ray.D;
28 ray_hip.origin = ray.P;
29 ray_hip.maxT = ray.tmax;
30 ray_hip.minT = ray.tmin;
31}
32
34{
35 const int object = kernel_data_fetch(user_instance_id, hit.instanceID);
36 const int prim_offset = kernel_data_fetch(object_prim_offset, object);
37 const int primitive_type = kernel_data_fetch(objects, object).primitive_type;
38
39 const int prim = hit.primID + prim_offset;
40
41 isect->t = hit.t;
42 isect->u = hit.uv.x;
43 isect->v = hit.uv.y;
44
45 isect->object = object;
46
47 if (primitive_type & PRIMITIVE_CURVE) {
48 const KernelCurveSegment segment = kernel_data_fetch(curve_segments, prim);
49 isect->prim = segment.prim;
50 isect->type = segment.type;
51 }
52 else {
53 isect->prim = prim;
54 isect->type = primitive_type;
55 }
56}
57
58/* --------------------------------------------------------------------
59 * Custom intersection functions.
60 */
61
63 BVHPayload *payload,
64 hiprtHit &hit)
65
66{
67 /* Could also cast shadow payload to get the elements needed to do the intersection no need to
68 * write a separate function for shadow intersection. */
69
70 KernelGlobals kg = nullptr;
71
72 const int object = kernel_data_fetch(user_instance_id, hit.instanceID);
73
74 const int prim_offset = kernel_data_fetch(object_prim_offset, object);
75 const KernelCurveSegment segment = kernel_data_fetch(curve_segments, hit.primID + prim_offset);
76
77#ifdef __SHADOW_LINKING__
78 if (intersection_skip_shadow_link(kg, payload->ray_self, object)) {
79 return false; /* Ignore hit - continue traversal. */
80 }
81#endif
82
83 if (intersection_skip_self_shadow(payload->ray_self, object, segment.prim)) {
84 return false;
85 }
86
87 const float ray_time = payload->ray_time;
88
89 Intersection isect;
90 const bool b_hit = curve_intersect(kg,
91 &isect,
92 ray.origin,
93 ray.direction,
94 ray.minT,
95 ray.maxT,
96 object,
97 segment.prim,
98 ray_time,
99 segment.type);
100 if (b_hit) {
101 hit.uv.x = isect.u;
102 hit.uv.y = isect.v;
103 hit.t = isect.t;
104 }
105
106 return b_hit;
107}
108
110 BVHPayload *payload,
111 hiprtHit &hit)
112{
113 KernelGlobals kg = nullptr;
114
115 const int object = kernel_data_fetch(user_instance_id, hit.instanceID);
116 const int prim_offset = kernel_data_fetch(object_prim_offset, object);
117
118 const int prim = hit.primID + prim_offset;
119
120 if (intersection_skip_self_shadow(payload->ray_self, object, prim)) {
121 return false;
122 }
123
124 Intersection isect;
125 const bool b_hit = motion_triangle_intersect(kg,
126 &isect,
127 ray.origin,
128 ray.direction,
129 ray.minT,
130 ray.maxT,
131 payload->ray_time,
132 payload->ray_visibility,
133 object,
134 prim,
135 hit.instanceID);
136
137 if (b_hit) {
138 hit.uv.x = isect.u;
139 hit.uv.y = isect.v;
140 hit.t = isect.t;
141 }
142
143 return b_hit;
144}
145
147 LocalPayload *payload,
148 hiprtHit &hit)
149{
150#ifdef __OBJECT_MOTION__
151 KernelGlobals kg = nullptr;
152
153 const int object = payload->local_object;
154
155 const int prim_offset = kernel_data_fetch(object_prim_offset, object);
156 const int prim = hit.primID + prim_offset;
157
158 if (intersection_skip_self_local(payload->self, prim)) {
159 return false;
160 }
161
162 return motion_triangle_intersect_local(kg,
163 payload->local_isect,
164 ray.origin,
165 ray.direction,
166 payload->ray_time,
167 object,
168 prim,
169 ray.minT,
170 ray.maxT,
171 payload->lcg_state,
172 payload->max_hits);
173
174#else
175 return false;
176#endif
177}
178
180 BVHPayload *payload,
181 hiprtHit &hit)
182{
183#ifdef __OBJECT_MOTION__
184 KernelGlobals kg = nullptr;
185
186 const int object = kernel_data_fetch(user_instance_id, hit.instanceID);
187 const int prim_offset = kernel_data_fetch(object_prim_offset, object);
188 const int prim = hit.primID + prim_offset;
189
191 kg, object, prim, payload->ray_self, payload->ray_visibility))
192 {
193 return false;
194 }
195
196 Intersection isect;
197 const bool b_hit = motion_triangle_intersect(kg,
198 &isect,
199 ray.origin,
200 ray.direction,
201 ray.minT,
202 ray.maxT,
203 payload->ray_time,
204 payload->ray_visibility,
205 object,
206 prim,
207 hit.instanceID);
208
209 if (b_hit) {
210 hit.uv.x = isect.u;
211 hit.uv.y = isect.v;
212 hit.t = isect.t;
213 }
214
215 return b_hit;
216#else
217 return false;
218#endif
219}
220
222 BVHPayload *payload,
223 hiprtHit &hit)
224{
225#if defined(__POINTCLOUD__)
226 KernelGlobals kg = nullptr;
227
228 const int object = kernel_data_fetch(user_instance_id, hit.instanceID);
229 const int prim_offset = kernel_data_fetch(object_prim_offset, object);
230
231 const int prim = hit.primID + prim_offset;
232
233 const int primitive_type = kernel_data_fetch(objects, object).primitive_type;
234
235# ifdef __SHADOW_LINKING__
236 if (intersection_skip_shadow_link(kg, payload->ray_self, object)) {
237 return false; /* Ignore hit - continue traversal */
238 }
239# endif
240
241 if (intersection_skip_self_shadow(payload->ray_self, object, prim)) {
242 return false;
243 }
244
245 Intersection isect;
246 const bool b_hit = point_or_gsplat_intersect(kg,
247 &isect,
248 ray.origin,
249 ray.direction,
250 ray.minT,
251 ray.maxT,
252 object,
253 prim,
254 payload->ray_time,
255 primitive_type);
256
257 if (b_hit) {
258 hit.uv.x = isect.u;
259 hit.uv.y = isect.v;
260 hit.t = isect.t;
261 }
262
263 return b_hit;
264#else
265 return false;
266#endif
267}
268
269/* --------------------------------------------------------------------
270 * Intersection filters.
271 */
272
274 BVHPayload *payload,
275 const hiprtHit &hit)
276{
277 KernelGlobals kg = nullptr;
278
279 const int object_id = kernel_data_fetch(user_instance_id, hit.instanceID);
280 const int prim_offset = kernel_data_fetch(object_prim_offset, object_id);
281 const int prim = hit.primID + prim_offset;
282
283#ifdef __SHADOW_LINKING__
284 if (intersection_skip_shadow_link(kg, payload->ray_self, object_id)) {
285 return true; /* Ignore hit - continue traversal. */
286 }
287#endif
288
289 if (intersection_skip_self_shadow(payload->ray_self, object_id, prim)) {
290 return true; /* Ignore hit - continue traversal. */
291 }
292
293 return false;
294}
295
297 BVHShadowAllPayload *payload,
298 const hiprtHit &hit)
299
300{
301 KernelGlobals kg = nullptr;
302 Intersection isect;
303 set_intersect_point(hit, &isect);
305 kg, payload->state, *payload, payload->ray_self, payload->ray_visibility, isect);
306}
307
309 BVHShadowAllPayload *payload,
310 const hiprtHit &hit)
311
312{
313 KernelGlobals kg = nullptr;
314 Intersection isect;
315 set_intersect_point(hit, &isect);
317 kg, payload->state, *payload, payload->ray_self, payload->ray_visibility, isect);
318}
319
321 LocalPayload *payload,
322 const hiprtHit &hit)
323{
324#ifdef __BVH_LOCAL__
325 KernelGlobals kg = nullptr;
326
327 const int object_id = payload->local_object;
328 const uint max_hits = payload->max_hits;
329
330 /* Triangle primitive uses hardware intersection, other primitives do custom intersection
331 * which does reservoir sampling for intersections. For the custom primitives only check
332 * whether we can stop traversal early on. The rest of the checks here only do for the
333 * regular triangles. */
334 const int primitive_type = kernel_data_fetch(objects, object_id).primitive_type;
335 if (primitive_type != PRIMITIVE_TRIANGLE) {
336 if (max_hits == 0) {
337 return false;
338 }
339 return true;
340 }
341
342 const int prim_offset = kernel_data_fetch(object_prim_offset, object_id);
343 const int prim = hit.primID + prim_offset;
344# ifndef __RAY_OFFSET__
345 if (intersection_skip_self_local(payload->self, prim)) {
346 return true; /* Continue search. */
347 }
348# endif
349
350 if (max_hits == 0) {
351 return false; /* Stop search. */
352 }
353
354 const int hit_index = local_intersect_get_record_index(
355 payload->local_isect, hit.t, payload->lcg_state, max_hits);
356 if (hit_index == -1) {
357 return true; /* Continue search. */
358 }
359
360 Intersection *isect = &payload->local_isect->hits[hit_index];
361 isect->t = hit.t;
362 isect->u = hit.uv.x;
363 isect->v = hit.uv.y;
364 isect->prim = prim;
365 isect->object = object_id;
366 isect->type = primitive_type;
367
368 payload->local_isect->Ng[hit_index] = hit.normal;
369
370 return true;
371#else
372 return false;
373#endif
374}
375
377 BVHPayload *payload,
378 const hiprtHit &hit)
379{
380 KernelGlobals kg = nullptr;
381
382 const int object = kernel_data_fetch(user_instance_id, hit.instanceID);
383 const int prim_offset = kernel_data_fetch(object_prim_offset, object);
384 const int prim = hit.primID + prim_offset;
385
387 kg, object, prim, payload->ray_self, payload->ray_visibility))
388 {
389 return true;
390 }
391
392 return false;
393}
394
395HIPRT_DEVICE bool intersectFunc(const uint geom_type,
396 const uint ray_type,
397 const hiprtFuncTableHeader &tableHeader,
398 const hiprtRay &ray,
399 void *payload,
400 hiprtHit &hit)
401{
402 const uint index = tableHeader.numGeomTypes * ray_type + geom_type;
403 switch (index) {
406 return curve_custom_intersect(ray, (BVHPayload *)payload, hit);
409 return motion_triangle_custom_intersect(ray, (BVHPayload *)payload, hit);
411 return motion_triangle_custom_local_intersect(ray, (LocalPayload *)payload, hit);
413 return motion_triangle_custom_volume_intersect(ray, (BVHPayload *)payload, hit);
416 return point_custom_intersect(ray, (BVHPayload *)payload, hit);
417 default:
418 break;
419 }
420 return false;
421}
422
423HIPRT_DEVICE bool filterFunc(const uint geom_type,
424 const uint ray_type,
425 const hiprtFuncTableHeader &tableHeader,
426 const hiprtRay &ray,
427 void *payload,
428 const hiprtHit &hit)
429{
430 const uint index = tableHeader.numGeomTypes * ray_type + geom_type;
431 switch (index) {
433 return closest_intersection_filter(ray, (BVHPayload *)payload, hit);
435 return shadow_intersection_filter_curve(ray, (BVHShadowAllPayload *)payload, hit);
439 return shadow_intersection_filter(ray, (BVHShadowAllPayload *)payload, hit);
442 return local_intersection_filter(ray, (LocalPayload *)payload, hit);
444 return volume_triangle_intersection_filter(ray, (BVHPayload *)payload, hit);
446 /* Motion triangle volume filtering is done in the custom intersection function. */
447 return false;
448 default:
449 break;
450 }
451 return false;
452}
453
454/* --------------------------------------------------------------------
455 * BVH functions.
456 */
457
459 const ccl_private Ray *ray,
460 const uint visibility,
462{
463 isect->t = ray->tmax;
464 isect->u = 0.0f;
465 isect->v = 0.0f;
466 isect->prim = PRIM_NONE;
467 isect->object = OBJECT_NONE;
468 isect->type = PRIMITIVE_NONE;
469 if (!intersection_ray_valid(ray)) {
470 isect->t = ray->tmax;
471 isect->type = PRIMITIVE_NONE;
472 return false;
473 }
474
475 if (kernel_data.device_bvh == 0) {
476 return false;
477 }
478
479 hiprtRay ray_hip;
480 set_hiprt_ray(*ray, ray_hip);
481
482 BVHPayload payload;
483 payload.ray_self = ray->self;
484 payload.ray_visibility = visibility;
485 payload.ray_time = ray->time;
486
487 Stack stack(kg->global_stack_buffer, kg->shared_stack);
488 Instance_Stack instance_stack;
489
490 hiprtHit hit;
491 if (visibility & PATH_RAY_VISIBILITY_SHADOW_OPAQUE) {
492 hiprtSceneTraversalAnyHitCustomStack traversal((hiprtScene)kernel_data.device_bvh,
493 ray_hip,
494 stack,
495 instance_stack,
496 visibility,
497 hiprtTraversalHintDefault,
498 &payload,
499 kernel_params.table_closest_intersect,
500 0 /* RAY_TYPE */,
501 ray->time);
502 hit = traversal.getNextHit();
503 }
504 else {
505 hiprtSceneTraversalClosestCustomStack traversal((hiprtScene)kernel_data.device_bvh,
506 ray_hip,
507 stack,
508 instance_stack,
509 visibility,
510 hiprtTraversalHintDefault,
511 &payload,
512 kernel_params.table_closest_intersect,
513 0 /* RAY_TYPE */,
514 ray->time);
515
516 hit = traversal.getNextHit();
517 }
518
519 if (hit.hasHit()) {
520 set_intersect_point(hit, isect);
521 return true;
522 }
523
524 return false;
525}
526
528 const ccl_private Ray *ray,
529 const uint visibility)
530{
531 Intersection isect;
532 return scene_intersect(kg, ray, visibility, &isect);
533}
534
535#ifdef __BVH_LOCAL__
536template<bool single_hit = false>
537ccl_device_intersect bool scene_intersect_local(KernelGlobals kg,
538 const ccl_private Ray *ray,
539 ccl_private LocalIntersection *local_isect,
540 const int local_object,
541 ccl_private uint *lcg_state,
542 const int max_hits)
543{
544 if (local_isect != nullptr) {
545 local_isect->num_hits = 0;
546 }
547
548 if (!intersection_ray_valid(ray)) {
549 return false;
550 }
551
552 const int primitive_type = kernel_data_fetch(objects, local_object).primitive_type;
553 if (!(primitive_type & PRIMITIVE_TRIANGLE)) {
554 /* Local intersection functions are only considering triangle and motion triangle primitives.
555 * If the local intersection is requested from other primitives (curve or point cloud) perform
556 * an early return to avoid tree traversal with no primitive intersection. */
557 return false;
558 }
559
560 float3 P = ray->P;
561 float3 dir = bvh_clamp_direction(ray->D);
562 float3 idir = bvh_inverse_direction(dir);
563
564 const uint object_flag = kernel_data_fetch(object_flag, local_object);
565 if (!(object_flag & SD_OBJECT_TRANSFORM_APPLIED)) {
566# ifdef __OBJECT_MOTION__
567 bvh_instance_motion_push(kg, local_object, ray, &P, &dir, &idir);
568# else
569 bvh_instance_push(kg, local_object, ray, &P, &dir, &idir);
570# endif
571 }
572
573 hiprtRay ray_hip;
574 ray_hip.origin = P;
575 ray_hip.direction = dir;
576 ray_hip.maxT = ray->tmax;
577 ray_hip.minT = ray->tmin;
578
579 LocalPayload payload = {0};
580 payload.self = ray->self;
581 payload.ray_time = ray->time;
582 payload.local_object = local_object;
583 payload.max_hits = max_hits;
584 payload.lcg_state = lcg_state;
585 payload.local_isect = local_isect;
586
587 Stack stack(kg->global_stack_buffer, kg->shared_stack);
588 Instance_Stack instance_stack;
589
590 hiprtGeometry local_geom = (hiprtGeometry)(kernel_data_fetch(blas_ptr, local_object));
591
592 hiprtHit hit;
593 if (primitive_type == PRIMITIVE_MOTION_TRIANGLE) {
594 /* Motion triangle BVH uses custom primitives which requires custom traversal. */
595 hiprtGeomCustomTraversalAnyHitCustomStack traversal(local_geom,
596 ray_hip,
597 stack,
598 hiprtTraversalHintDefault,
599 &payload,
600 kernel_params.table_local_intersect,
601 2);
602 hit = traversal.getNextHit();
603 }
604 else {
605 hiprtGeomTraversalAnyHitCustomStack traversal(local_geom,
606 ray_hip,
607 stack,
608 hiprtTraversalHintDefault,
609 &payload,
610 kernel_params.table_local_intersect,
611 2);
612 hit = traversal.getNextHit();
613 }
614
615 return hit.hasHit();
616}
617#endif /* __BVH_LOCAL__ */
618
619#ifdef __TRANSPARENT_SHADOWS__
620ccl_device_inline void scene_intersect_shadow_all_hiprt(
621 KernelGlobals kg,
622 const ccl_private Ray *ccl_restrict ray,
623 ccl_private BVHShadowAllPayload &ccl_restrict payload)
624{
625 hiprtRay ray_hip;
626 set_hiprt_ray(*ray, ray_hip);
627
628 Stack stack(kg->global_stack_buffer, kg->shared_stack);
629 Instance_Stack instance_stack;
630
631 hiprtSceneTraversalAnyHitCustomStack traversal((hiprtScene)kernel_data.device_bvh,
632 ray_hip,
633 stack,
634 instance_stack,
635 payload.ray_visibility,
636 hiprtTraversalHintDefault,
637 &payload,
638 kernel_params.table_shadow_intersect,
639 1 /* RAY_TYPE */,
640 ray->time);
641
642 const hiprtHit hit = traversal.getNextHit();
643 (void)hit;
644}
645#endif /* __TRANSPARENT_SHADOWS__ */
646
647#ifdef __VOLUME__
648ccl_device_intersect bool scene_intersect_volume(KernelGlobals kg,
649 const ccl_private Ray *ray,
651 const uint visibility)
652{
653 isect->t = ray->tmax;
654 isect->u = 0.0f;
655 isect->v = 0.0f;
656 isect->prim = PRIM_NONE;
657 isect->object = OBJECT_NONE;
658 isect->type = PRIMITIVE_NONE;
659
660 if (!intersection_ray_valid(ray)) {
661 return false;
662 }
663
664 hiprtRay ray_hip;
665 set_hiprt_ray(*ray, ray_hip);
666
667 BVHPayload payload;
668 payload.ray_self = ray->self;
669 payload.ray_visibility = visibility;
670 payload.ray_time = ray->time;
671
672 Stack stack(kg->global_stack_buffer, kg->shared_stack);
673 Instance_Stack instance_stack;
674
675 hiprtSceneTraversalClosestCustomStack traversal((hiprtScene)kernel_data.device_bvh,
676 ray_hip,
677 stack,
678 instance_stack,
679 visibility,
680 hiprtTraversalHintDefault,
681 &payload,
682 kernel_params.table_volume_intersect,
683 3 /* RAY_TYPE */,
684 ray->time);
685
686 const hiprtHit hit = traversal.getNextHit();
687 if (hit.hasHit()) {
688 set_intersect_point(hit, isect);
689 return true;
690 }
691
692 return false;
693}
694#endif /* __VOLUME__ */
695
ccl_device_inline bool intersection_skip_shadow_link(KernelGlobals kg, const ccl_ray_data RaySelfPrimitives &self, const int isect_object)
ccl_device_inline bool intersection_skip_self_shadow(const ccl_ray_data RaySelfPrimitives &self, const int object, const int prim)
CCL_NAMESPACE_BEGIN ccl_device_inline bool intersection_ray_valid(const ccl_private Ray *ray)
ccl_device_inline bool intersection_skip_self_local(const ccl_ray_data RaySelfPrimitives &self, const int prim)
#define kernel_data
#define ccl_restrict
#define ccl_device_forceinline
#define kernel_data_fetch(name, index)
#define PRIM_NONE
#define OBJECT_NONE
#define ccl_private
#define ccl_device_inline
#define CCL_NAMESPACE_END
@ Motion_Triangle_Filter_Volume
@ Motion_Triangle_Filter_Local
@ Triangle_Filter_Closest
@ Curve_Filter_Shadow
@ Motion_Triangle_Filter_Shadow
@ Point_Filter_Shadow
@ Triangle_Filter_Local
@ Triangle_Filter_Volume
@ Triangle_Filter_Shadow
@ Motion_Triangle_Intersect_Shadow
@ Curve_Intersect_Function
@ Motion_Triangle_Intersect_Function
@ Point_Intersect_Shadow
@ Curve_Intersect_Shadow
@ Point_Intersect_Function
@ Motion_Triangle_Intersect_Volume
@ Motion_Triangle_Intersect_Local
#define index(i)
ccl_device_forceinline bool bvh_shadow_all_anyhit_filter(KernelGlobals kg, IntegratorShadowState state, ccl_ray_data BVHShadowAllPayload &ccl_restrict payload, const ccl_ray_data RaySelfPrimitives &ccl_restrict ray_self, const uint ray_visibility, const Intersection isect)
ccl_device_forceinline bool bvh_volume_anyhit_triangle_filter(KernelGlobals kg, const int object, const int prim, const ccl_ray_data RaySelfPrimitives &ccl_restrict ray_self, const uint ray_visibility)
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 bool motion_triangle_custom_volume_intersect(const hiprtRay &ray, BVHPayload *payload, hiprtHit &hit)
ccl_device_inline bool volume_triangle_intersection_filter(const hiprtRay &ray, BVHPayload *payload, const hiprtHit &hit)
ccl_device_inline bool closest_intersection_filter(const hiprtRay &ray, BVHPayload *payload, const hiprtHit &hit)
ccl_device_inline bool curve_custom_intersect(const hiprtRay &ray, BVHPayload *payload, hiprtHit &hit)
ccl_device_inline bool shadow_intersection_filter(const hiprtRay &ray, BVHShadowAllPayload *payload, const hiprtHit &hit)
ccl_device_inline bool point_custom_intersect(const hiprtRay &ray, BVHPayload *payload, hiprtHit &hit)
HIPRT_DEVICE bool intersectFunc(const uint geom_type, const uint ray_type, const hiprtFuncTableHeader &tableHeader, const hiprtRay &ray, void *payload, hiprtHit &hit)
HIPRT_DEVICE bool filterFunc(const uint geom_type, const uint ray_type, const hiprtFuncTableHeader &tableHeader, const hiprtRay &ray, void *payload, const hiprtHit &hit)
ccl_device_inline bool local_intersection_filter(const hiprtRay &ray, LocalPayload *payload, const hiprtHit &hit)
ccl_device_inline bool shadow_intersection_filter_curve(const hiprtRay &ray, BVHShadowAllPayload *payload, const hiprtHit &hit)
ccl_device_inline bool motion_triangle_custom_intersect(const hiprtRay &ray, BVHPayload *payload, hiprtHit &hit)
ccl_device_inline void set_intersect_point(const hiprtHit &hit, ccl_private Intersection *isect)
ccl_device_inline bool motion_triangle_custom_local_intersect(const hiprtRay &ray, LocalPayload *payload, hiprtHit &hit)
ccl_device_forceinline void set_hiprt_ray(const ccl_private Ray &ray, ccl_private hiprtRay &ray_hip)
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)
ccl_device_inline float3 bvh_inverse_direction(const float3 dir)
ccl_device_inline float3 bvh_clamp_direction(const float3 dir)
@ PRIMITIVE_MOTION_TRIANGLE
@ PRIMITIVE_NONE
@ PRIMITIVE_CURVE
@ PRIMITIVE_TRIANGLE
@ PATH_RAY_VISIBILITY_SHADOW_OPAQUE
@ SD_OBJECT_TRANSFORM_APPLIED
CCL_NAMESPACE_BEGIN ccl_device_inline bool motion_triangle_intersect(KernelGlobals kg, ccl_private Intersection *isect, const float3 P, const float3 dir, const float tmin, const float tmax, const float time, const uint visibility, const int object, const int prim, const int prim_addr)
unsigned int uint
Definition BKE_text.h:55
void visibility(Visibility &srt, const ViewCulling &culling, const uint3 global_id, const uint3 local_id, const uint3 workgroup_id)
RaySelfPrimitives ray_self
Intersection hits[LOCAL_MAX_HITS]
float3 Ng[LOCAL_MAX_HITS]
LocalIntersection * local_isect
RaySelfPrimitives self