Blender V5.3
volume_all.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,
29 Intersection *isect_array,
30 const uint max_hits,
31 const uint visibility)
32{
33 /* todo:
34 * - test if pushing distance on the stack helps (for non shadow rays)
35 * - separate version for shadow rays
36 * - likely and unlikely for if() statements
37 * - test restrict attribute for pointers
38 */
39
40 /* traversal stack in CUDA thread-local memory */
41 int traversal_stack[BVH_STACK_SIZE];
42 traversal_stack[0] = ENTRYPOINT_SENTINEL;
43
44 /* traversal variables in registers */
45 int stack_ptr = 0;
46 int node_addr = kernel_data.bvh.root;
47
48 /* ray parameters in registers */
49 float3 P = ray->P;
50 float3 dir = bvh_clamp_direction(ray->D);
51 float3 idir = bvh_inverse_direction(dir);
52 const float tmin = ray->tmin;
53 int object = OBJECT_NONE;
54 float isect_t = ray->tmax;
55
56 uint num_hits = 0;
57 isect_array->t = ray->tmax;
58
59 /* traversal loop */
60 do {
61 do {
62 /* traverse internal nodes */
63 while (node_addr >= 0 && node_addr != ENTRYPOINT_SENTINEL) {
64 int node_addr_child1, traverse_mask;
65 float dist[2];
66 float4 cnodes = kernel_data_fetch(bvh_nodes, node_addr + 0);
67
68 traverse_mask = NODE_INTERSECT(kg,
69 P,
71 dir,
72#endif
73 idir,
74 tmin,
75 isect_t,
76 node_addr,
77 visibility,
78 dist);
79
80 node_addr = __float_as_int(cnodes.z);
81 node_addr_child1 = __float_as_int(cnodes.w);
82
83 if (traverse_mask == 3) {
84 /* Both children were intersected, push the farther one. */
85 bool is_closest_child1 = (dist[1] < dist[0]);
86 if (is_closest_child1) {
87 int tmp = node_addr;
88 node_addr = node_addr_child1;
89 node_addr_child1 = tmp;
90 }
91
92 ++stack_ptr;
93 kernel_assert(stack_ptr < BVH_STACK_SIZE);
94 traversal_stack[stack_ptr] = node_addr_child1;
95 }
96 else {
97 /* One child was intersected. */
98 if (traverse_mask == 2) {
99 node_addr = node_addr_child1;
100 }
101 else if (traverse_mask == 0) {
102 /* Neither child was intersected. */
103 node_addr = traversal_stack[stack_ptr];
104 --stack_ptr;
105 }
106 }
107 }
108
109 /* if node is leaf, fetch triangle list */
110 if (node_addr < 0) {
111 float4 leaf = kernel_data_fetch(bvh_leaf_nodes, (-node_addr - 1));
112 int prim_addr = __float_as_int(leaf.x);
113
114 if (prim_addr >= 0) {
115 const int prim_addr2 = __float_as_int(leaf.y);
116 const uint type = __float_as_int(leaf.w);
117 bool hit;
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 hit = triangle_intersect(kg,
141 isect_array,
142 P,
143 dir,
144 tmin,
145 isect_t,
146 visibility,
147 prim_object,
148 prim,
149 prim_addr);
150 if (hit) {
151 /* Move on to next entry in intersections array. */
152 isect_array++;
153 num_hits++;
154 isect_array->t = isect_t;
155 if (num_hits == max_hits) {
156 return num_hits;
157 }
158 }
159 }
160 break;
161 }
162#if BVH_FEATURE(BVH_MOTION)
164 /* intersect ray against primitive */
165 for (; prim_addr < prim_addr2; prim_addr++) {
166 kernel_assert((kernel_data_fetch(prim_type, prim_addr) & PRIMITIVE_ALL) ==
167 (type & PRIMITIVE_ALL));
168 /* only primitives from volume object */
169 const int prim_object = (object == OBJECT_NONE) ?
170 kernel_data_fetch(prim_object, prim_addr) :
171 object;
172 const int prim = kernel_data_fetch(prim_index, prim_addr);
174 kg, prim_object, prim, ray->self, visibility))
175 {
176 continue;
177 }
179 isect_array,
180 P,
181 dir,
182 tmin,
183 isect_t,
184 ray->time,
185 visibility,
186 prim_object,
187 prim,
188 prim_addr);
189 if (hit) {
190 /* Move on to next entry in intersections array. */
191 isect_array++;
192 num_hits++;
193 isect_array->t = isect_t;
194 if (num_hits == max_hits) {
195 return num_hits;
196 }
197 }
198 }
199 break;
200 }
201#endif /* BVH_MOTION */
202 default: {
203 break;
204 }
205 }
206 }
207 else {
208 /* instance push */
209 object = kernel_data_fetch(prim_object, -prim_addr - 1);
210 const uint object_flag = kernel_data_fetch(object_flag, object);
211 if (object_flag & SD_OBJECT_HAS_VOLUME) {
212#if BVH_FEATURE(BVH_MOTION)
213 bvh_instance_motion_push(kg, object, ray, &P, &dir, &idir);
214#else
215 bvh_instance_push(kg, object, ray, &P, &dir, &idir);
216#endif
217
218 isect_array->t = isect_t;
219
220 ++stack_ptr;
221 kernel_assert(stack_ptr < BVH_STACK_SIZE);
222 traversal_stack[stack_ptr] = ENTRYPOINT_SENTINEL;
223
224 node_addr = kernel_data_fetch(object_node, object);
225 }
226 else {
227 /* pop */
228 object = OBJECT_NONE;
229 node_addr = traversal_stack[stack_ptr];
230 --stack_ptr;
231 }
232 }
233 }
234 } while (node_addr != ENTRYPOINT_SENTINEL);
235
236 if (stack_ptr >= 0) {
237 kernel_assert(object != OBJECT_NONE);
238
239 /* Instance pop. */
240 bvh_instance_pop(ray, &P, &dir, &idir);
241
242 object = OBJECT_NONE;
243 node_addr = traversal_stack[stack_ptr];
244 --stack_ptr;
245 }
246 } while (node_addr != ENTRYPOINT_SENTINEL);
247
248 return num_hits;
249}
250
252 const ccl_private Ray *ray,
253 Intersection *isect_array,
254 const uint max_hits,
255 const uint visibility)
256{
257 return BVH_FUNCTION_FULL_NAME(BVH)(kg, ray, isect_array, max_hits, visibility);
258}
259
260#undef BVH_FUNCTION_NAME
261#undef BVH_FUNCTION_FEATURES
262#undef NODE_INTERSECT
Definition bvh/bvh.h:67
#define kernel_assert(cond)
#define kernel_data
#define kernel_data_fetch(name, index)
#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)