Blender V5.3
closures.cpp
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2009-2010 Sony Pictures Imageworks Inc., et al. All Rights Reserved.
2 * SPDX-FileCopyrightText: 2011-2022 Blender Foundation
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 *
6 * Adapted code from Open Shading Language. */
7
8#include <OSL/genclosure.h>
9#include <OSL/oslclosure.h>
10
11#include "kernel/types.h"
12
13#include "kernel/osl/globals.h"
14#include "kernel/osl/services.h"
15
16#include "util/math.h"
17#include "util/param.h"
18
19#include "kernel/globals.h"
20
22#include "kernel/geom/object.h"
25
26#include "kernel/osl/camera.h"
27#include "kernel/osl/osl.h"
28
29#define TO_VEC3(v) OSL::Vec3(v.x, v.y, v.z)
30#define TO_FLOAT3(v) make_float3(v[0], v[1], v[2])
31
33
34static_assert(sizeof(OSLClosure) == sizeof(OSL::ClosureColor) &&
35 sizeof(OSLClosureAdd) == sizeof(OSL::ClosureAdd) &&
36 sizeof(OSLClosureMul) == sizeof(OSL::ClosureMul) &&
37 sizeof(OSLClosureComponent) == sizeof(OSL::ClosureComponent));
38static_assert(sizeof(ShaderGlobals) >= sizeof(OSL::ShaderGlobals) &&
39 offsetof(ShaderGlobals, backfacing) == offsetof(OSL::ShaderGlobals, backfacing));
40
41/* Registration */
42
43#define OSL_CLOSURE_STRUCT_BEGIN(Upper, lower) \
44 static OSL::ClosureParam *osl_closure_##lower##_params() \
45 { \
46 static OSL::ClosureParam params[] = {
47#define OSL_CLOSURE_STRUCT_END(Upper, lower) \
48 CLOSURE_STRING_KEYPARAM(Upper##Closure, label, "label"), CLOSURE_FINISH_PARAM(Upper##Closure) \
49 } \
50 ; \
51 return params; \
52 }
53#define OSL_CLOSURE_STRUCT_MEMBER(Upper, TYPE, type, name, key) \
54 CLOSURE_##TYPE##_KEYPARAM(Upper##Closure, name, key),
55#define OSL_CLOSURE_STRUCT_ARRAY_MEMBER(Upper, TYPE, type, name, key, size) \
56 CLOSURE_##TYPE##_ARRAY_PARAM(Upper##Closure, name, size),
57
58#include "closures_template.h"
59
60static OSL::ClosureParam *osl_closure_layer_params()
61{
62 static OSL::ClosureParam params[] = {CLOSURE_CLOSURE_PARAM(LayerClosure, top),
63 CLOSURE_CLOSURE_PARAM(LayerClosure, base),
64 CLOSURE_FINISH_PARAM(LayerClosure)};
65 return params;
66}
67
68void OSLRenderServices::register_closures(OSL::ShadingSystem *ss)
69{
70#define OSL_CLOSURE_STRUCT_BEGIN(Upper, lower) \
71 ss->register_closure( \
72 #lower, OSL_CLOSURE_##Upper##_ID, osl_closure_##lower##_params(), nullptr, nullptr);
73
74#include "closures_template.h"
75
76 ss->register_closure(
77 "layer", OSL_CLOSURE_LAYER_ID, osl_closure_layer_params(), nullptr, nullptr);
78}
79
80/* Surface & Background */
81
82template<typename IntegratorGenericState>
84 IntegratorGenericState state,
85 ShaderData *sd,
86 const PathRayVisibility path_visibility,
87 const uint32_t path_flag)
88{
89 /* setup shader globals from shader data */
90 shaderdata_to_shaderglobals(sd, path_visibility, path_flag, &kg->osl.shader_globals);
91
92 /* clear trace data */
93 kg->osl.tracedata.init = false;
94
95 /* Used by render-services. */
96 kg->osl.shader_globals.kg = kg;
97 if constexpr (std::is_same_v<IntegratorGenericState, IntegratorShadowState>) {
98 kg->osl.shader_globals.path_state = nullptr;
99 kg->osl.shader_globals.shadow_path_state = (const IntegratorShadowStateCPU *)state;
100 }
101 else if constexpr (std::is_same_v<IntegratorGenericState, IntegratorBakeState>) {
102 kg->osl.shader_globals.path_state = nullptr;
103 kg->osl.shader_globals.shadow_path_state = nullptr;
104 }
105 else {
106 kg->osl.shader_globals.path_state = (const IntegratorStateCPU *)state;
107 kg->osl.shader_globals.shadow_path_state = nullptr;
108 }
109
110 /* execute shader for this point */
111 OSL::ShadingSystem *ss = (OSL::ShadingSystem *)kg->osl.ss;
112 OSL::ShaderGlobals *globals = reinterpret_cast<OSL::ShaderGlobals *>(&kg->osl.shader_globals);
113 OSL::ShadingContext *octx = kg->osl.context;
114 const int shader = sd->shader & SHADER_MASK;
115
116 if (sd->object == OBJECT_NONE) {
117 /* background */
118 if (kg->osl.globals->background_state) {
119 ss->execute(*octx,
120 *(kg->osl.globals->background_state),
121 kg->osl.thread_index,
122 0,
123 *globals,
124 nullptr,
125 nullptr);
126 }
127 }
128 else {
129 /* automatic bump shader */
130 if (kg->osl.globals->bump_state[shader]) {
131 /* save state */
132 const float3 P = sd->P;
133 const float dP = sd->dP;
134 const OSL::Vec3 dPdx = globals->dPdx;
135 const OSL::Vec3 dPdy = globals->dPdy;
136
137 /* set state as if undisplaced */
138 if (sd->shader_flag & SD_HAS_DISPLACEMENT) {
141
144
145 sd->P = P.val;
147
148 globals->P = TO_VEC3(sd->P);
149 globals->dPdx = TO_VEC3(P.dx);
150 globals->dPdy = TO_VEC3(P.dy);
151
152 /* Set normal as if undisplaced. */
154 globals->N = TO_VEC3(sd->N);
155 }
156
157 /* execute bump shader */
158 ss->execute(*octx,
159 *(kg->osl.globals->bump_state[shader]),
160 kg->osl.thread_index,
161 0,
162 *globals,
163 nullptr,
164 nullptr);
165
166 /* reset state */
167 sd->P = P;
168 sd->dP = dP;
169
170 /* Apply bump output to sd->N since it's used for shadow terminator logic, for example. */
171 sd->N = TO_FLOAT3(globals->N);
172
173 globals->P = TO_VEC3(P);
174 globals->dPdx = TO_VEC3(dPdx);
175 globals->dPdy = TO_VEC3(dPdy);
176 }
177
178 /* surface shader */
179 if (kg->osl.globals->surface_state[shader]) {
180 ss->execute(*octx,
181 *(kg->osl.globals->surface_state[shader]),
182 kg->osl.thread_index,
183 0,
184 *globals,
185 nullptr,
186 nullptr);
187 }
188 }
189
190 /* flatten closure tree */
191 if (kg->osl.shader_globals.Ci) {
192 flatten_closure_tree(kg, sd, path_visibility, path_flag, kg->osl.shader_globals.Ci);
193 }
194}
195
196template<>
198 const ThreadKernelGlobalsCPU *kg,
200 ShaderData *sd,
201 const PathRayVisibility path_visibility,
202 const uint32_t path_flag)
203{
204 osl_eval_nodes_surface(kg, state, sd, path_visibility, path_flag);
205}
206
207template<>
210 ShaderData *sd,
211 const PathRayVisibility path_visibility,
212 const uint32_t path_flag)
213{
214 osl_eval_nodes_surface(kg, state, sd, path_visibility, path_flag);
215}
216
217template<>
219 const ThreadKernelGlobalsCPU *kg,
221 ShaderData *sd,
222 const PathRayVisibility path_visibility,
223 const uint32_t path_flag)
224{
225 osl_eval_nodes_surface(kg, state, sd, path_visibility, path_flag);
226}
227
228/* Volume */
229
230template<typename IntegratorGenericState>
232 IntegratorGenericState state,
233 ShaderData *sd,
234 const PathRayVisibility path_visibility,
235 const uint32_t path_flag)
236{
237 /* setup shader globals from shader data */
238 shaderdata_to_shaderglobals(sd, path_visibility, path_flag, &kg->osl.shader_globals);
239
240 /* clear trace data */
241 kg->osl.tracedata.init = false;
242
243 /* Used by render-services. */
244 kg->osl.shader_globals.kg = kg;
245 if constexpr (std::is_same_v<IntegratorGenericState, IntegratorShadowState>) {
246 kg->osl.shader_globals.path_state = nullptr;
247 kg->osl.shader_globals.shadow_path_state = (const IntegratorShadowStateCPU *)state;
248 }
249 else if constexpr (std::is_same_v<IntegratorGenericState, IntegratorBakeState>) {
250 kg->osl.shader_globals.path_state = nullptr;
251 kg->osl.shader_globals.shadow_path_state = nullptr;
252 }
253 else {
254 kg->osl.shader_globals.path_state = (const IntegratorStateCPU *)state;
255 kg->osl.shader_globals.shadow_path_state = nullptr;
256 }
257
258 /* execute shader */
259 OSL::ShadingSystem *ss = (OSL::ShadingSystem *)kg->osl.ss;
260 OSL::ShaderGlobals *globals = reinterpret_cast<OSL::ShaderGlobals *>(&kg->osl.shader_globals);
261 OSL::ShadingContext *octx = kg->osl.context;
262 const int shader = sd->shader & SHADER_MASK;
263
264 if (kg->osl.globals->volume_state[shader]) {
265 ss->execute(*octx,
266 *(kg->osl.globals->volume_state[shader]),
267 kg->osl.thread_index,
268 0,
269 *globals,
270 nullptr,
271 nullptr);
272 }
273
274 /* flatten closure tree */
275 if (kg->osl.shader_globals.Ci) {
276 flatten_closure_tree(kg, sd, path_visibility, path_flag, kg->osl.shader_globals.Ci);
277 }
278}
279
280template<>
282 const ThreadKernelGlobalsCPU *kg,
284 ShaderData *sd,
285 const PathRayVisibility path_visibility,
286 const uint32_t path_flag)
287{
288 osl_eval_nodes_volume(kg, state, sd, path_visibility, path_flag);
289}
290
291template<>
294 ShaderData *sd,
295 const PathRayVisibility path_visibility,
296 const uint32_t path_flag)
297{
298 osl_eval_nodes_volume(kg, state, sd, path_visibility, path_flag);
299}
300
301template<>
303 const ThreadKernelGlobalsCPU *kg,
305 ShaderData *sd,
306 const PathRayVisibility path_visibility,
307 const uint32_t path_flag)
308{
309 osl_eval_nodes_volume(kg, state, sd, path_visibility, path_flag);
310}
311
312/* Displacement */
313
314template<typename IntegratorGenericState>
316 IntegratorGenericState state,
317 ShaderData *sd,
318 const PathRayVisibility path_visibility,
319 const uint32_t path_flag)
320{
321 /* setup shader globals from shader data */
322 shaderdata_to_shaderglobals(sd, path_visibility, path_flag, &kg->osl.shader_globals);
323
324 /* clear trace data */
325 kg->osl.tracedata.init = false;
326
327 /* Used by render-services. */
328 kg->osl.shader_globals.kg = kg;
329
330 if constexpr (std::is_same_v<IntegratorGenericState, IntegratorBakeState>) {
331 kg->osl.shader_globals.path_state = nullptr;
332 kg->osl.shader_globals.shadow_path_state = nullptr;
333 }
334 else {
335 kg->osl.shader_globals.path_state = (const IntegratorStateCPU *)state;
336 kg->osl.shader_globals.shadow_path_state = nullptr;
337 }
338
339 /* execute shader */
340 OSL::ShadingSystem *ss = (OSL::ShadingSystem *)kg->osl.ss;
341 OSL::ShaderGlobals *globals = reinterpret_cast<OSL::ShaderGlobals *>(&kg->osl.shader_globals);
342 OSL::ShadingContext *octx = kg->osl.context;
343 const int shader = sd->shader & SHADER_MASK;
344
345 if (kg->osl.globals->displacement_state[shader]) {
346 ss->execute(*octx,
347 *(kg->osl.globals->displacement_state[shader]),
348 kg->osl.thread_index,
349 0,
350 *globals,
351 nullptr,
352 nullptr);
353 }
354
355 /* get back position */
356 sd->P = TO_FLOAT3(globals->P);
357}
358
359template<>
361 const ThreadKernelGlobalsCPU *kg,
363 ShaderData *sd,
364 const PathRayVisibility path_visibility,
365 const uint32_t path_flag)
366{
367 osl_eval_nodes_displacement(kg, state, sd, path_visibility, path_flag);
368}
369
370template<>
372 const ThreadKernelGlobalsCPU *kg,
374 ShaderData *sd,
375 const PathRayVisibility path_visibility,
376 const uint32_t path_flag)
377{
378 osl_eval_nodes_displacement(kg, state, sd, path_visibility, path_flag);
379}
380
381template<>
383 const ThreadKernelGlobalsCPU *kg,
385 ShaderData *sd,
386 const PathRayVisibility path_visibility,
387 const uint32_t path_flag)
388{
389 osl_eval_nodes_displacement(kg, state, sd, path_visibility, path_flag);
390}
391
392/* Camera */
393
395 ccl_private ShaderData *sd,
396 const packed_float3 sensor,
397 const packed_float3 dSdx,
398 const packed_float3 dSdy,
399 const float2 rand_lens,
404 packed_float3 &dDdx,
405 packed_float3 &dDdy)
406{
407 if (!kg || !kg->osl.globals->camera_state) {
408 return zero_spectrum();
409 }
410
411 /* Setup shader globals from the sensor position. */
412 cameradata_to_shaderglobals(sd, sensor, dSdx, dSdy, rand_lens, &kg->osl.shader_globals);
413
414 /* Clear trace data. */
415 kg->osl.tracedata.init = false;
416
417 /* Provide kernel globals to the render-services. */
418 kg->osl.shader_globals.kg = kg;
419
420 /* Execute the shader. */
421 OSL::ShadingSystem *ss = (OSL::ShadingSystem *)kg->osl.ss;
422 OSL::ShaderGlobals *globals = reinterpret_cast<OSL::ShaderGlobals *>(&kg->osl.shader_globals);
423 OSL::ShadingContext *octx = kg->osl.context;
424
425 float output[21] = {0.0f};
426
427 ss->execute(
428 *octx, *kg->osl.globals->camera_state, kg->osl.thread_index, 0, *globals, nullptr, output);
429
430 P = make_float3(output[0], output[1], output[2]);
431 dPdx = make_float3(output[3], output[4], output[5]);
432 dPdy = make_float3(output[6], output[7], output[8]);
433 D = make_float3(output[9], output[10], output[11]);
434 dDdx = make_float3(output[12], output[13], output[14]);
435 dDdy = make_float3(output[15], output[16], output[17]);
436 return make_float3(output[18], output[19], output[20]);
437}
438
#define D
#define output
static void register_closures(OSL::ShadingSystem *ss)
Definition closures.cpp:68
void osl_eval_nodes_displacement(const ThreadKernelGlobalsCPU *kg, IntegratorGenericState state, ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t path_flag)
Definition closures.cpp:315
void osl_eval_nodes_volume(const ThreadKernelGlobalsCPU *kg, IntegratorGenericState state, ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t path_flag)
Definition closures.cpp:231
#define TO_FLOAT3(v)
Definition closures.cpp:30
static OSL::ClosureParam * osl_closure_layer_params()
Definition closures.cpp:60
#define TO_VEC3(v)
Definition closures.cpp:29
void osl_eval_nodes_surface(const ThreadKernelGlobalsCPU *kg, IntegratorGenericState state, ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t path_flag)
Definition closures.cpp:83
ccl_device_forceinline float3 dPdx(const ccl_private ShaderData *sd)
ccl_device_forceinline float3 dPdy(const ccl_private ShaderData *sd)
#define kernel_assert(cond)
#define zero_spectrum
#define OBJECT_NONE
#define ccl_private
#define CCL_NAMESPACE_END
ccl_device_forceinline float3 make_float3(const float x, const float y, const float z)
#define offsetof(t, d)
ccl_device_forceinline float differential_make_compact(const float dD)
const int state
CCL_NAMESPACE_BEGIN ccl_device_forceinline bool is_attribute_found(const ccl_private AttributeDescriptor &desc)
ccl_device_inline AttributeDescriptor find_attribute(const ccl_global AttributeMap *attributes_map, uint attr_offset, const int prim, const uint64_t id)
ccl_device_inline void object_position_transform(KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private T *P)
CCL_NAMESPACE_BEGIN ccl_device_inline void cameradata_to_shaderglobals(ccl_private ShaderData *sd, const packed_float3 sensor, const packed_float3 dSdx, const packed_float3 dSdy, const float2 rand_lens, ccl_private ShaderGlobals *globals)
packed_float3 osl_eval_camera(KernelGlobals kg, ccl_private ShaderData *sd, const packed_float3 sensor, const packed_float3 dSdx, const packed_float3 dSdy, const float2 rand_lens, packed_float3 &P, packed_float3 &dPdx, packed_float3 &dPdy, packed_float3 &D, packed_float3 &dDdx, packed_float3 &dDdy)
CCL_NAMESPACE_BEGIN ccl_device_inline void shaderdata_to_shaderglobals(ccl_private ShaderData *sd, const PathRayVisibility path_visibility, const uint32_t path_flag, ccl_private ShaderGlobals *globals)
void osl_eval_nodes(const ThreadKernelGlobalsCPU *kg, ConstIntegratorGenericState state, ShaderData *sd, PathRayVisibility path_visibility, uint32_t path_flag)
ccl_device void flatten_closure_tree(KernelGlobals kg, ccl_private ShaderData *sd, const PathRayVisibility ray_visibility, const uint32_t path_flag, const ccl_private OSLClosure *closure)
uint32_t PathRayVisibility
@ SD_HAS_DISPLACEMENT
@ SHADER_MASK
@ ATTR_STD_POSITION_UNDISPLACED
ccl_device void primitive_normal_set_undisplaced(KernelGlobals kg, ccl_private ShaderData *sd, const int position_undisplaced_offset)
Definition primitive.h:63
CCL_NAMESPACE_BEGIN ccl_device_forceinline T primitive_surface_attribute(KernelGlobals kg, const ccl_private ShaderData *sd, const AttributeDescriptor desc)
Definition primitive.h:32
IntegratorShadowStateCPU * IntegratorShadowState
Definition state.h:229
IntegratorStateCPU * IntegratorState
Definition state.h:227
dual< float3 > dual3
Definition types_dual.h:106