Blender V5.3
kernel/bvh/volume.h
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2009-2010 NVIDIA Corporation
2 * SPDX-FileCopyrightText: 2009-2012 Intel Corporation
3 * SPDX-FileCopyrightText: 2011-2022 Blender Foundation
4 *
5 * SPDX-License-Identifier: Apache-2.0
6 *
7 * Adapted code from NVIDIA Corporation. */
8
9#if BVH_FEATURE(BVH_HAIR)
10# define NODE_INTERSECT bvh_node_intersect
11#else
12# define NODE_INTERSECT bvh_aligned_node_intersect
13#endif
14
15/* This is a template BVH traversal function for volumes, where
16 * various features can be enabled/disabled. This way we can compile optimized
17 * versions for each case without new features slowing things down.
18 *
19 * BVH_MOTION: motion blur rendering
20 */
21
22#ifndef __KERNEL_GPU__
24#else
26#endif
28 const ccl_private Ray *ray,
30 const uint visibility)
31{
32 /* todo:
33 * - test if pushing distance on the stack helps (for non shadow rays)
34 * - separate version for shadow rays
35 * - likely and unlikely for if() statements
36 * - test restrict attribute for pointers
37 */
38
39 /* traversal stack in CUDA thread-local memory */
40 int traversal_stack[BVH_STACK_SIZE];
41 traversal_stack[0] = ENTRYPOINT_SENTINEL;
42
43 /* traversal variables in registers */
44 int stack_ptr = 0;
45 int node_addr = kernel_data.bvh.root;
46
47 /* ray parameters in registers */
48 float3 P = ray->P;
49 float3 dir = bvh_clamp_direction(ray->D);
50 float3 idir = bvh_inverse_direction(dir);
51 const float tmin = ray->tmin;
52 int object = OBJECT_NONE;
53
54 isect->t = ray->tmax;
55 isect->u = 0.0f;
56 isect->v = 0.0f;
57 isect->prim = PRIM_NONE;
58 isect->object = OBJECT_NONE;
59
60 /* traversal loop */
61 do {
62 do {
63 /* traverse internal nodes */
64 while (node_addr >= 0 && node_addr != ENTRYPOINT_SENTINEL) {
65 int node_addr_child1, traverse_mask;
66 float dist[2];
67 float4 cnodes = kernel_data_fetch(bvh_nodes, node_addr + 0);
68
69 traverse_mask = NODE_INTERSECT(kg,
70 P,
72 dir,
73#endif
74 idir,
75 tmin,
76 isect->t,
77 node_addr,
78 visibility,
79 dist);
80
81 node_addr = __float_as_int(cnodes.z);
82 node_addr_child1 = __float_as_int(cnodes.w);
83
84 if (traverse_mask == 3) {
85 /* Both children were intersected, push the farther one. */
86 bool is_closest_child1 = (dist[1] < dist[0]);
87 if (is_closest_child1) {
88 int tmp = node_addr;
89 node_addr = node_addr_child1;
90 node_addr_child1 = tmp;
91 }
92
93 ++stack_ptr;
94 kernel_assert(stack_ptr < BVH_STACK_SIZE);
95 traversal_stack[stack_ptr] = node_addr_child1;
96 }
97 else {
98 /* One child was intersected. */
99 if (traverse_mask == 2) {
100 node_addr = node_addr_child1;
101 }
102 else if (traverse_mask == 0) {
103 /* Neither child was intersected. */
104 node_addr = traversal_stack[stack_ptr];
105 --stack_ptr;
106 }
107 }
108 }
109
110 /* if node is leaf, fetch triangle list */
111 if (node_addr < 0) {
112 float4 leaf = kernel_data_fetch(bvh_leaf_nodes, (-node_addr - 1));
113 int prim_addr = __float_as_int(leaf.x);
114
115 if (prim_addr >= 0) {
116 const int prim_addr2 = __float_as_int(leaf.y);
117 const uint type = __float_as_int(leaf.w);
118
119 /* pop */
120 node_addr = traversal_stack[stack_ptr];
121 --stack_ptr;
122
123 /* primitive intersection */
124 switch (type & PRIMITIVE_ALL) {
125 case PRIMITIVE_TRIANGLE: {
126 /* intersect ray against primitive */
127 for (; prim_addr < prim_addr2; prim_addr++) {
128 kernel_assert((kernel_data_fetch(prim_type, prim_addr) & PRIMITIVE_ALL) ==
129 (type & PRIMITIVE_ALL));
130 /* only primitives from volume object */
131 const int prim_object = (object == OBJECT_NONE) ?
132 kernel_data_fetch(prim_object, prim_addr) :
133 object;
134 const int prim = kernel_data_fetch(prim_index, prim_addr);
136 kg, prim_object, prim, ray->self, visibility))
137 {
138 continue;
139 }
140
142 kg, isect, P, dir, tmin, isect->t, visibility, prim_object, prim, prim_addr);
143 }
144 break;
145 }
146#if BVH_FEATURE(BVH_MOTION)
148 /* intersect ray against primitive */
149 for (; prim_addr < prim_addr2; prim_addr++) {
150 kernel_assert((kernel_data_fetch(prim_type, prim_addr) & PRIMITIVE_ALL) ==
151 (type & PRIMITIVE_ALL));
152 /* only primitives from volume object */
153 const int prim_object = (object == OBJECT_NONE) ?
154 kernel_data_fetch(prim_object, prim_addr) :
155 object;
156 const int prim = kernel_data_fetch(prim_index, prim_addr);
158 kg, prim_object, prim, ray->self, visibility))
159 {
160 continue;
161 }
163 isect,
164 P,
165 dir,
166 tmin,
167 isect->t,
168 ray->time,
169 visibility,
170 prim_object,
171 prim,
172 prim_addr);
173 }
174 break;
175 }
176#endif
177 default: {
178 break;
179 }
180 }
181 }
182 else {
183 /* instance push */
184 object = kernel_data_fetch(prim_object, -prim_addr - 1);
185 uint object_flag = kernel_data_fetch(object_flag, object);
186 if (object_flag & SD_OBJECT_HAS_VOLUME) {
187#if BVH_FEATURE(BVH_MOTION)
188 bvh_instance_motion_push(kg, object, ray, &P, &dir, &idir);
189#else
190 bvh_instance_push(kg, object, ray, &P, &dir, &idir);
191#endif
192
193 ++stack_ptr;
194 kernel_assert(stack_ptr < BVH_STACK_SIZE);
195 traversal_stack[stack_ptr] = ENTRYPOINT_SENTINEL;
196
197 node_addr = kernel_data_fetch(object_node, object);
198 }
199 else {
200 /* pop */
201 object = OBJECT_NONE;
202 node_addr = traversal_stack[stack_ptr];
203 --stack_ptr;
204 }
205 }
206 }
207 } while (node_addr != ENTRYPOINT_SENTINEL);
208
209 if (stack_ptr >= 0) {
210 kernel_assert(object != OBJECT_NONE);
211
212 /* instance pop */
213 bvh_instance_pop(ray, &P, &dir, &idir);
214
215 object = OBJECT_NONE;
216 node_addr = traversal_stack[stack_ptr];
217 --stack_ptr;
218 }
219 } while (node_addr != ENTRYPOINT_SENTINEL);
220
221 return (isect->prim != PRIM_NONE);
222}
223
225 const ccl_private Ray *ray,
227 const uint visibility)
228{
229 return BVH_FUNCTION_FULL_NAME(BVH)(kg, ray, isect, visibility);
230}
231
232#undef BVH_FUNCTION_NAME
233#undef BVH_FUNCTION_FEATURES
234#undef NODE_INTERSECT
Definition bvh/bvh.h:67
#define kernel_assert(cond)
#define kernel_data
#define kernel_data_fetch(name, index)
#define PRIM_NONE
#define OBJECT_NONE
#define ccl_private
#define ccl_device_inline
#define __float_as_int(x)
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)
#define BVH_FUNCTION_NAME
#define BVH_STACK_SIZE
#define BVH_FEATURE(f)
#define ENTRYPOINT_SENTINEL
#define BVH_HAIR
#define BVH_FUNCTION_FULL_NAME(prefix)
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)
ccl_device_inline void bvh_instance_pop(const ccl_private Ray *ray, ccl_private float3 *P, ccl_private float3 *dir, ccl_private float3 *idir)
@ PRIMITIVE_ALL
@ PRIMITIVE_MOTION_TRIANGLE
@ PRIMITIVE_TRIANGLE
@ SD_OBJECT_HAS_VOLUME
#define NODE_INTERSECT
Definition local.h:11
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)
#define ccl_device
float y
Definition sky_math.h:225
float z
Definition sky_math.h:225
float x
Definition sky_math.h:225
float w
Definition sky_math.h:225
CCL_NAMESPACE_BEGIN ccl_device_inline bool triangle_intersect(KernelGlobals kg, ccl_private Intersection *isect, const float3 P, const float3 dir, const float tmin, const float tmax, const uint visibility, const int object, const int prim, const int prim_addr)