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