Blender V5.3
geom/triangle.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/* Triangle Primitive
6 *
7 * Basic triangle with 3 vertices is used to represent mesh surfaces. For BVH
8 * ray intersection we use a precomputed triangle storage to accelerate
9 * intersection at the cost of more memory usage */
10
11#pragma once
12
13#include "kernel/globals.h"
14
16#include "kernel/geom/object.h"
17
19
20/* Evaluate a quantity at barycentric coordinates u, v, given the values at three triangle
21 * vertices. */
22template<typename T>
24triangle_interpolate(const float u, const float v, const T f0, const T f1, const T f2)
25{
26 return (1.0f - u - v) * f0 + u * f1 + v * f2;
27}
28
29/* Normal on triangle. */
31{
32 /* load triangle vertices */
33 const int position_offset = kernel_data_fetch(objects, sd->object).position_offset;
34 const uint3 tri_vindex = kernel_data_fetch(tri_vindex, sd->prim);
35 const float3 v0 = kernel_data_fetch(tri_verts, position_offset + tri_vindex.x);
36 const float3 v1 = kernel_data_fetch(tri_verts, position_offset + tri_vindex.y);
37 const float3 v2 = kernel_data_fetch(tri_verts, position_offset + tri_vindex.z);
38
39 /* return normal */
40 if (object_negative_scale_applied(sd->object_flag)) {
41 return normalize(cross(v2 - v0, v1 - v0));
42 }
43 return normalize(cross(v1 - v0, v2 - v0));
44}
45
46/* Face normal of undisplaced triangle, from vertex positions stored as attribute. */
48 ccl_private const ShaderData *sd,
49 const int position_attr_offset)
50{
51 const uint3 tri_vindex = kernel_data_fetch(tri_vindex, sd->prim);
53 kg, ATTR_ELEMENT_VERTEX, position_attr_offset + tri_vindex.x);
55 kg, ATTR_ELEMENT_VERTEX, position_attr_offset + tri_vindex.y);
57 kg, ATTR_ELEMENT_VERTEX, position_attr_offset + tri_vindex.z);
58
59 if (object_negative_scale_applied(sd->object_flag)) {
60 return normalize(cross(v2 - v0, v1 - v0));
61 }
62 return normalize(cross(v1 - v0, v2 - v0));
63}
64
65/* Point and normal on triangle. */
67 const int object,
68 const int prim,
69 const float u,
70 const float v,
73 ccl_private int *shader)
74{
75 /* load triangle vertices */
76 const int position_offset = kernel_data_fetch(objects, object).position_offset;
77 const uint3 tri_vindex = kernel_data_fetch(tri_vindex, prim);
78 const float3 v0 = kernel_data_fetch(tri_verts, position_offset + tri_vindex.x);
79 const float3 v1 = kernel_data_fetch(tri_verts, position_offset + tri_vindex.y);
80 const float3 v2 = kernel_data_fetch(tri_verts, position_offset + tri_vindex.z);
81
82 /* compute point */
83 const float w = 1.0f - u - v;
84 *P = (w * v0 + u * v1 + v * v2);
85 /* get object flags */
86 const uint object_flag = kernel_data_fetch(object_flag, object);
87 /* compute normal */
88 if (object_negative_scale_applied(object_flag)) {
89 *Ng = normalize(cross(v2 - v0, v1 - v0));
90 }
91 else {
92 *Ng = normalize(cross(v1 - v0, v2 - v0));
93 }
94 /* shader */
95 *shader = kernel_data_fetch(tri_shader, prim);
96}
97
98/* Triangle vertex locations */
99
101 const int object,
102 const int prim,
103 float3 P[3])
104{
105 const int position_offset = kernel_data_fetch(objects, object).position_offset;
106 const uint3 tri_vindex = kernel_data_fetch(tri_vindex, prim);
107 P[0] = kernel_data_fetch(tri_verts, position_offset + tri_vindex.x);
108 P[1] = kernel_data_fetch(tri_verts, position_offset + tri_vindex.y);
109 P[2] = kernel_data_fetch(tri_verts, position_offset + tri_vindex.z);
110}
111
112/* Triangle vertex locations and vertex normals */
113
115 ccl_private const ShaderData *sd,
116 float3 P[3],
117 float3 N[3])
118{
119 const int position_offset = kernel_data_fetch(objects, sd->object).position_offset;
120 const uint3 tri_vindex = kernel_data_fetch(tri_vindex, sd->prim);
121 P[0] = kernel_data_fetch(tri_verts, position_offset + tri_vindex.x);
122 P[1] = kernel_data_fetch(tri_verts, position_offset + tri_vindex.y);
123 P[2] = kernel_data_fetch(tri_verts, position_offset + tri_vindex.z);
124
125 const int normal_offset = kernel_data_fetch(objects, sd->object).mesh_volume.normal_offset;
126 int i0, i1, i2;
127
128 if (sd->object_flag & SD_OBJECT_HAS_CORNER_NORMALS) {
129 i0 = sd->prim * 3 + 0;
130 i1 = sd->prim * 3 + 1;
131 i2 = sd->prim * 3 + 2;
132 }
133 else {
134 i0 = tri_vindex.x;
135 i1 = tri_vindex.y;
136 i2 = tri_vindex.z;
137 }
138
139 attribute_data_fetch_normals(kg, normal_offset, i0, i1, i2, N);
140}
141
142/* Interpolate smooth vertex normal from vertices */
143
145 KernelGlobals kg, float3 Ng, int object, int object_flag, int prim, float u, float v)
146{
147 const int normal_offset = kernel_data_fetch(objects, object).mesh_volume.normal_offset;
148 int i0, i1, i2;
149
150 if (object_flag & SD_OBJECT_HAS_CORNER_NORMALS) {
151 i0 = prim * 3 + 0;
152 i1 = prim * 3 + 1;
153 i2 = prim * 3 + 2;
154 }
155 else {
156 const uint3 tri_vindex = kernel_data_fetch(tri_vindex, prim);
157 i0 = tri_vindex.x;
158 i1 = tri_vindex.y;
159 i2 = tri_vindex.z;
160 }
161
162 const float3 N = safe_normalize(
163 attribute_data_interpolate_normals(kg, normal_offset, i0, i1, i2, u, v));
164 return is_zero(N) ? Ng : N;
165}
166
167/* Compute triangle normals at the hit position, and offsetted positions in x and y direction for
168 * bump mapping. */
170 const float3 Ng,
171 const int object,
172 const int object_flag,
173 const int prim,
174 const float u,
175 float v,
176 const differential du,
177 const differential dv,
178 ccl_private float3 &N_x,
179 ccl_private float3 &N_y)
180{
181 const int normal_offset = kernel_data_fetch(objects, object).mesh_volume.normal_offset;
182 int i0, i1, i2;
183
184 if (object_flag & SD_OBJECT_HAS_CORNER_NORMALS) {
185 i0 = prim * 3 + 0;
186 i1 = prim * 3 + 1;
187 i2 = prim * 3 + 2;
188 }
189 else {
190 const uint3 tri_vindex = kernel_data_fetch(tri_vindex, prim);
191 i0 = tri_vindex.x;
192 i1 = tri_vindex.y;
193 i2 = tri_vindex.z;
194 }
195
196 float3 n[3];
197 attribute_data_fetch_normals(kg, normal_offset, i0, i1, i2, n);
198
199 const float3 N = safe_normalize(triangle_interpolate(u, v, n[0], n[1], n[2]));
200 N_x = safe_normalize(triangle_interpolate(u + du.dx, v + dv.dx, n[0], n[1], n[2]));
201 N_y = safe_normalize(triangle_interpolate(u + du.dy, v + dv.dy, n[0], n[1], n[2]));
202
203 N_x = is_zero(N_x) ? Ng : N_x;
204 N_y = is_zero(N_y) ? Ng : N_y;
205 return is_zero(N) ? Ng : N;
206}
207
208/* Special variation for normal mapping, where we want to match the unnormalized object
209 * space interpolation as assumed by normal map baking exactly. An exact match avoids
210 * discontinuities across UV seams.*/
212 KernelGlobals kg, ccl_private const ShaderData *sd)
213{
214 const int normal_offset = kernel_data_fetch(objects, sd->object).mesh_volume.normal_offset;
215 int i0, i1, i2;
216
217 if (sd->object_flag & SD_OBJECT_HAS_CORNER_NORMALS) {
218 i0 = sd->prim * 3 + 0;
219 i1 = sd->prim * 3 + 1;
220 i2 = sd->prim * 3 + 2;
221 }
222 else {
223 const uint3 tri_vindex = kernel_data_fetch(tri_vindex, sd->prim);
224 i0 = tri_vindex.x;
225 i1 = tri_vindex.y;
226 i2 = tri_vindex.z;
227 }
228
229 float3 n[3];
230 attribute_data_fetch_normals(kg, normal_offset, i0, i1, i2, n);
231
232 if (sd->object_flag & SD_OBJECT_TRANSFORM_APPLIED) {
233 object_inverse_normal_transform(kg, sd, &n[0]);
234 object_inverse_normal_transform(kg, sd, &n[1]);
235 object_inverse_normal_transform(kg, sd, &n[2]);
236 }
237
238 const float3 N = safe_normalize(triangle_interpolate(sd->u, sd->v, n[0], n[1], n[2]));
239 return is_zero(N) ? sd->Ng : N;
240}
241
242/* Ray differentials on triangle */
243
245 const int object,
246 const int prim,
247 ccl_private float3 *dPdu,
248 ccl_private float3 *dPdv)
249{
250 /* fetch triangle vertex coordinates */
251 const int position_offset = kernel_data_fetch(objects, object).position_offset;
252 const uint3 tri_vindex = kernel_data_fetch(tri_vindex, prim);
253 const float3 p0 = kernel_data_fetch(tri_verts, position_offset + tri_vindex.x);
254 const float3 p1 = kernel_data_fetch(tri_verts, position_offset + tri_vindex.y);
255 const float3 p2 = kernel_data_fetch(tri_verts, position_offset + tri_vindex.z);
256
257 /* compute derivatives of P w.r.t. uv */
258 *dPdu = (p1 - p0);
259 *dPdv = (p2 - p0);
260}
261
262/* Partial derivative of f w.r.t. x, namely ∂f/∂x.
263 * f is a function of barycentric coordinates u, v, given by
264 * f(u, v) = f1 * u + f2 * v + f0 * (1 - u - v),
265 * the derivatives are
266 * ∂f/∂u = (f1 - f0), ∂f/∂v = (f2 - f0).
267 * The partial derivative in x is
268 * ∂f/∂x = ∂f/∂u * ∂u/∂x + ∂f/∂v * ∂v/∂x
269 * = (f1 - f0) * du.dx + (f2 - f0) * dv.dx. */
270template<typename T>
272 const ccl_private differential &dv,
273 const ccl_private T &f0,
274 const ccl_private T &f1,
275 const ccl_private T &f2)
276{
277 return du.dx * f1 + dv.dx * f2 - (du.dx + dv.dx) * f0;
278}
279
280/* Partial derivative of f w.r.t. in x, namely ∂f/∂y, similarly computed as ∂f/∂x above. */
281template<typename T>
283 const ccl_private differential &dv,
284 const ccl_private T &f0,
285 const ccl_private T &f1,
286 const ccl_private T &f2)
287{
288 return du.dy * f1 + dv.dy * f2 - (du.dy + dv.dy) * f0;
289}
290
291/* Read attributes on various triangle elements. T is the return type, which can be a plain type
292 * (float, float3, etc.) or a dual type (dual1, dual3, etc.) to include derivatives. */
293template<typename T>
295 const ccl_private ShaderData *sd,
296 const AttributeDescriptor desc)
297{
298 using BaseT = dual_base_t<T>;
299
301 int i0, i1, i2;
302
303 if (desc.element & ATTR_ELEMENT_VERTEX) {
304 const uint3 tri_vindex = kernel_data_fetch(tri_vindex, sd->prim);
305 i0 = tri_vindex.x;
306 i1 = tri_vindex.y;
307 i2 = tri_vindex.z;
308 }
309 else {
310 /* Corner attributes. */
311 const int tri = sd->prim * 3;
312 i0 = tri + 0;
313 i1 = tri + 1;
314 i2 = tri + 2;
315 }
316
317 BaseT f[3];
318 attribute_data_fetch_3<BaseT>(kg, desc.element, desc.offset, i0, i1, i2, f);
319
320 if constexpr (is_dual_v<T>) {
321 T result;
322 result.val = triangle_interpolate(sd->u, sd->v, f[0], f[1], f[2]);
323#ifdef __RAY_DIFFERENTIALS__
324 result.dx = triangle_attribute_dfdx(sd->du, sd->dv, f[0], f[1], f[2]);
325 result.dy = triangle_attribute_dfdy(sd->du, sd->dv, f[0], f[1], f[2]);
326#endif
327 return result;
328 }
329 else {
330 return triangle_interpolate(sd->u, sd->v, f[0], f[1], f[2]);
331 }
332 }
333
334 if (desc.element & ATTR_ELEMENT_FACE) {
335 return T(attribute_data_fetch<BaseT>(kg, desc.element, desc.offset + sd->prim));
336 }
337 return make_zero<T>();
338}
339
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition btQuadWord.h:119
#define kernel_data_fetch(name, index)
#define ccl_private
#define ccl_device_inline
#define CCL_NAMESPACE_END
ccl_device_inline float3 triangle_smooth_normal(KernelGlobals kg, float3 Ng, int object, int object_flag, int prim, float u, float v)
ccl_device_inline float3 triangle_face_normal_undisplaced(KernelGlobals kg, ccl_private const ShaderData *sd, const int position_attr_offset)
CCL_NAMESPACE_BEGIN ccl_device_inline T triangle_interpolate(const float u, const float v, const T f0, const T f1, const T f2)
ccl_device_inline float3 triangle_normal(KernelGlobals kg, ccl_private ShaderData *sd)
ccl_device_inline float3 triangle_smooth_normal_unnormalized_object_space(KernelGlobals kg, ccl_private const ShaderData *sd)
ccl_device_inline void triangle_dPdudv(KernelGlobals kg, const int object, const int prim, ccl_private float3 *dPdu, ccl_private float3 *dPdv)
ccl_device_inline T triangle_attribute_dfdy(const ccl_private differential &du, const ccl_private differential &dv, const ccl_private T &f0, const ccl_private T &f1, const ccl_private T &f2)
ccl_device_inline T triangle_attribute_dfdx(const ccl_private differential &du, const ccl_private differential &dv, const ccl_private T &f0, const ccl_private T &f1, const ccl_private T &f2)
ccl_device_inline void triangle_vertices_and_normals(KernelGlobals kg, ccl_private const ShaderData *sd, float3 P[3], float3 N[3])
ccl_device_inline void triangle_point_normal(KernelGlobals kg, const int object, const int prim, const float u, const float v, ccl_private float3 *P, ccl_private float3 *Ng, ccl_private int *shader)
ccl_device T triangle_attribute(KernelGlobals kg, const ccl_private ShaderData *sd, const AttributeDescriptor desc)
ccl_device_inline void triangle_vertices(KernelGlobals kg, const int object, const int prim, float3 P[3])
VecBase< float, D > normalize(VecOp< float, D >) RET
VecBase< float, 3 > cross(VecOp< float, 3 >, VecOp< float, 3 >) RET
bool is_zero(float3x3 a)
VecT safe_normalize(VecT vector)
ccl_device_inline void attribute_data_fetch_normals(KernelGlobals kg, const int offset, const int i0, const int i1, const int i2, ccl_private float3 N[3])
ccl_device_inline void attribute_data_fetch_3(KernelGlobals kg, const AttributeElement element, const int offset, const int i0, const int i1, const int i2, ccl_private T f[3])
ccl_device_inline T attribute_data_fetch(KernelGlobals kg, AttributeElement element, int offset)
ccl_device_inline float3 attribute_data_interpolate_normals(KernelGlobals kg, const int offset, const int i0, const int i1, const int i2, const float u, const float v)
ccl_device_inline bool object_negative_scale_applied(const uint object_flag)
ccl_device_inline void object_inverse_normal_transform(KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private float3 *N)
@ SD_OBJECT_HAS_CORNER_NORMALS
@ SD_OBJECT_TRANSFORM_APPLIED
@ ATTR_ELEMENT_CORNER
@ ATTR_ELEMENT_VERTEX
@ ATTR_ELEMENT_FACE
ccl_device_inline T make_zero()
Definition math_dual.h:20
#define N
#define T
#define ccl_device
AttributeElement element
uint y
Definition types_uint3.h:13
uint z
Definition types_uint3.h:13
uint x
Definition types_uint3.h:13
ccl_static_constexpr bool is_dual_v
Definition types_dual.h:118
typename dual_base_type< T >::type dual_base_t
Definition types_dual.h:128