Blender V5.3
cycles/kernel/svm/util.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
7#include "kernel/globals.h"
8#include "kernel/types.h"
9
10#include "kernel/svm/types.h"
11
13
14/* Stack Load */
15
16ccl_device_inline float stack_load_float(const ccl_private float *stack, const uint a)
17{
19
20 return stack[a];
21}
22
24 const uint a,
25 const float value)
26{
27 return (a == (uint)SVM_STACK_INVALID) ? value : stack_load_float(stack, a);
28}
29
30ccl_device_inline float3 stack_load_float3(const ccl_private float *stack, const uint a)
31{
33
34 const ccl_private float *stack_a = stack + a;
35 return make_float3(stack_a[0], stack_a[1], stack_a[2]);
36}
37
39 const uint a,
40 const float3 value)
41{
42 return (a == (uint)SVM_STACK_INVALID) ? value : stack_load_float3(stack, a);
43}
44
45ccl_device_inline int stack_load_int(const ccl_private float *stack, const uint a)
46{
48
49 return __float_as_int(stack[a]);
50}
51
52/* Type-based stack load. T can be float, float3, dual1, or dual3.
53 * When T is a dual type, derivatives are loaded from adjacent stack slots. */
54
55template<typename T> ccl_device_inline T stack_load(const ccl_private float *stack, const uint a);
56
57ccl_device_template_spec float stack_load(const ccl_private float *stack, const uint a)
58{
59 return stack_load_float(stack, a);
60}
61
62ccl_device_template_spec float3 stack_load(const ccl_private float *stack, const uint a)
63{
64 return stack_load_float3(stack, a);
65}
66
67ccl_device_template_spec dual1 stack_load(const ccl_private float *stack, const uint a)
68{
69 return {
70 stack_load_float(stack, a), stack_load_float(stack, a + 1), stack_load_float(stack, a + 2)};
71}
72
73ccl_device_template_spec dual3 stack_load(const ccl_private float *stack, const uint a)
74{
75 return {stack_load_float3(stack, a),
76 stack_load_float3(stack, a + 3),
77 stack_load_float3(stack, a + 6)};
78}
79
80/* Load from SVMInputFloat and SVMInputFloat3. With template versions to support duals
81 * for loading derivatives from adjacent stack slots. */
82
84 const SVMInputFloat v)
85{
86 if ((v.bits >> 8) == (SVM_INPUT_STACK_OFFSET_MASK >> 8)) {
87 return stack_load_float(stack, v.bits & 0xFFu);
88 }
89 return __uint_as_float(v.bits);
90}
91
93 const SVMInputFloat3 v)
94{
95 if ((v.x.bits >> 8) == (SVM_INPUT_STACK_OFFSET_MASK >> 8)) {
96 return stack_load_float3(stack, v.x.bits & 0xFFu);
97 }
98 return make_float3(
99 __uint_as_float(v.x.bits), __uint_as_float(v.y.bits), __uint_as_float(v.z.bits));
100}
101
102ccl_device_inline int stack_load(const ccl_private float *stack, const SVMInputInt v)
103{
104 if (v.offset == SVM_STACK_INVALID) {
105 return v.value;
106 }
107 return stack_load_int(stack, v.offset);
108}
109
110template<typename T>
111ccl_device_inline T stack_load(const ccl_private float *stack, const SVMInputFloat v);
112
114{
115 return stack_load(stack, v);
116}
117
119{
120 if ((v.bits >> 8) == (SVM_INPUT_STACK_OFFSET_MASK >> 8)) {
121 return stack_load<dual1>(stack, v.bits & 0xFFu);
122 }
123 return dual1(__uint_as_float(v.bits));
124}
125
126template<typename T>
127ccl_device_inline T stack_load(const ccl_private float *stack, const SVMInputFloat3 v);
128
130{
131 return stack_load(stack, v);
132}
133
135{
136 if ((v.x.bits >> 8) == (SVM_INPUT_STACK_OFFSET_MASK >> 8)) {
137 return stack_load<dual3>(stack, v.x.bits & 0xFFu);
138 }
139 return dual3(make_float3(
140 __uint_as_float(v.x.bits), __uint_as_float(v.y.bits), __uint_as_float(v.z.bits)));
141}
142
143/* Stack Store */
144
145ccl_device_inline void stack_store_float(ccl_private float *stack, const uint a, const float f)
146{
148
149 stack[a] = f;
150}
151
152ccl_device_inline void stack_store_float3(ccl_private float *stack, const uint a, const float3 f)
153{
155 copy_v3_v3(stack + a, f);
156}
157
158ccl_device_inline void stack_store_int(ccl_private float *stack, const uint a, const int i)
159{
161
162 stack[a] = __int_as_float(i);
163}
164
165/* Type-based stack store. Overloaded for plain and dual types.
166 * For dual types, derivatives are stored in adjacent stack slots. */
167
168ccl_device_inline void stack_store(ccl_private float *stack, const uint a, const float f)
169{
170 stack_store_float(stack, a, f);
171}
172
173ccl_device_inline void stack_store(ccl_private float *stack, const uint a, const float3 f)
174{
175 stack_store_float3(stack, a, f);
176}
177
178ccl_device_inline void stack_store(ccl_private float *stack, const uint a, const dual1 f)
179{
180 stack_store_float(stack, a, f.val);
181 stack_store_float(stack, a + 1, f.dx);
182 stack_store_float(stack, a + 2, f.dy);
183}
184
185ccl_device_inline void stack_store(ccl_private float *stack, const uint a, const dual3 f)
186{
187 stack_store_float3(stack, a, f.val);
188 stack_store_float3(stack, a + 3, f.dx);
189 stack_store_float3(stack, a + 6, f.dy);
190}
191
192/* Stack Utility */
193
195{
196 return a != (uint)SVM_STACK_INVALID;
197}
198
199/* Reading Nodes */
200
201/* Read a typed node struct directly from the SVM byte-code stream. The struct T must be a
202 * multiple of sizeof(uint) and its memory layout must match the byte-code encoding. Returns
203 * a const reference into the byte-code array and advances the offset past the struct. */
204template<typename T>
206{
207 static_assert(alignof(T) <= alignof(uint));
208 static_assert(sizeof(T) % sizeof(uint) == 0);
209 const ccl_global T &node = *reinterpret_cast<const ccl_global T *>(
210 &kernel_data_fetch(svm_nodes, *offset));
211 *offset += sizeof(T) / sizeof(uint);
212 return node;
213}
214
216{
217 return make_float4(__uint_as_float(kernel_data_fetch(svm_nodes, offset)),
218 __uint_as_float(kernel_data_fetch(svm_nodes, offset + 1)),
219 __uint_as_float(kernel_data_fetch(svm_nodes, offset + 2)),
220 __uint_as_float(kernel_data_fetch(svm_nodes, offset + 3)));
221}
222
223/* Shading Helpers */
224
226{
227 return sd->dPdu * sd->du.dx + sd->dPdv * sd->dv.dx;
228}
229
231{
232 return sd->dPdu * sd->du.dy + sd->dPdv * sd->dv.dy;
233}
234
235/* Shading position, returns Float3Type = float3 (no derivatives) or dual3 (with derivatives). */
236
237template<typename Float3Type>
238ccl_device_inline Float3Type shading_position(const ccl_private ShaderData *sd)
239{
240 if constexpr (is_dual_v<Float3Type>) {
241 dual3 P(sd->P);
242 P.dx = dPdx(sd);
243 P.dy = dPdy(sd);
244 return P;
245 }
246 else {
247 return sd->P;
248 }
249}
250
251/* Shading incoming direction, returns Float3Type = float3 or dual3. */
252
253template<typename Float3Type>
254ccl_device_inline Float3Type shading_incoming(const ccl_private ShaderData *sd)
255{
256 if constexpr (is_dual_v<Float3Type>) {
257 dual3 I(sd->wi);
258 float3 dIdx, dIdy;
259 make_orthonormals(sd->wi, &dIdx, &dIdy);
260 I.dx = sd->dI * dIdx;
261 I.dy = sd->dI * dIdy;
262 return I;
263 }
264 else {
265 return sd->wi;
266 }
267}
268
ccl_device_inline float3 stack_load_float3_default(const ccl_private float *stack, const uint a, const float3 value)
ccl_device_forceinline float3 dPdx(const ccl_private ShaderData *sd)
ccl_device_inline void stack_store_float(ccl_private float *stack, const uint a, const float f)
ccl_device_inline int stack_load_int(const ccl_private float *stack, const uint a)
ccl_device_inline float3 stack_load_float3(const ccl_private float *stack, const uint a)
ccl_device_inline void stack_store_float3(ccl_private float *stack, const uint a, const float3 f)
ccl_device_inline void stack_store(ccl_private float *stack, const uint a, const float f)
CCL_NAMESPACE_BEGIN ccl_device_inline float stack_load_float(const ccl_private float *stack, const uint a)
ccl_device_inline void stack_store_int(ccl_private float *stack, const uint a, const int i)
ccl_device_inline Float3Type shading_incoming(const ccl_private ShaderData *sd)
ccl_device_inline Float3Type shading_position(const ccl_private ShaderData *sd)
ccl_device_forceinline float3 dPdy(const ccl_private ShaderData *sd)
ccl_device_inline const ccl_global T & svm_node_get(KernelGlobals kg, ccl_private int *const offset)
ccl_device_inline bool stack_valid(const uint a)
ccl_device_inline T stack_load(const ccl_private float *stack, const uint a)
ccl_device_inline float4 svm_node_get_data_float4(KernelGlobals kg, const int offset)
ccl_device_inline float stack_load_float_default(const ccl_private float *stack, const uint a, const float value)
#define kernel_assert(cond)
#define SVM_STACK_SIZE
#define ccl_restrict
#define ccl_device_forceinline
#define kernel_data_fetch(name, index)
#define ccl_private
#define ccl_device_inline
#define ccl_device_template_spec
#define SVM_STACK_INVALID
#define ccl_global
#define SVM_INPUT_STACK_OFFSET_MASK
#define CCL_NAMESPACE_END
ccl_device_forceinline float3 make_float3(const float x, const float y, const float z)
#define __int_as_float(x)
#define __float_as_int(x)
#define __uint_as_float(x)
ccl_device_inline void copy_v3_v3(ccl_private float *r, const float3 val)
ccl_device_inline void make_orthonormals(const float3 N, ccl_private float3 *a, ccl_private float3 *b)
#define T
#define I
#define make_float4
ccl_static_constexpr bool is_dual_v
Definition types_dual.h:118
dual< float3 > dual3
Definition types_dual.h:106
dual< float > dual1
Definition types_dual.h:104