Cleanup: use named unsigned types in the Python API
[blender.git] / intern / cycles / kernel / svm / svm.h
1 /*
2  * Copyright 2011-2013 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #ifndef __SVM_H__
18 #define __SVM_H__
19
20 /* Shader Virtual Machine
21  *
22  * A shader is a list of nodes to be executed. These are simply read one after
23  * the other and executed, using an node counter. Each node and it's associated
24  * data is encoded as one or more uint4's in a 1D texture. If the data is larger
25  * than an uint4, the node can increase the node counter to compensate for this.
26  * Floats are encoded as int and then converted to float again.
27  *
28  * Nodes write their output into a stack. All stack data in the stack is
29  * floats, since it's all factors, colors and vectors. The stack will be stored
30  * in local memory on the GPU, as it would take too many register and indexes in
31  * ways not known at compile time. This seems the only solution even though it
32  * may be slow, with two positive factors. If the same shader is being executed,
33  * memory access will be coalesced and cached.
34  *
35  * The result of shader execution will be a single closure. This means the
36  * closure type, associated label, data and weight. Sampling from multiple
37  * closures is supported through the mix closure node, the logic for that is
38  * mostly taken care of in the SVM compiler.
39  */
40
41 #include "kernel/svm/svm_types.h"
42
43 CCL_NAMESPACE_BEGIN
44
45 /* Stack */
46
47 ccl_device_inline float3 stack_load_float3(float *stack, uint a)
48 {
49   kernel_assert(a + 2 < SVM_STACK_SIZE);
50
51   return make_float3(stack[a + 0], stack[a + 1], stack[a + 2]);
52 }
53
54 ccl_device_inline void stack_store_float3(float *stack, uint a, float3 f)
55 {
56   kernel_assert(a + 2 < SVM_STACK_SIZE);
57
58   stack[a + 0] = f.x;
59   stack[a + 1] = f.y;
60   stack[a + 2] = f.z;
61 }
62
63 ccl_device_inline float stack_load_float(float *stack, uint a)
64 {
65   kernel_assert(a < SVM_STACK_SIZE);
66
67   return stack[a];
68 }
69
70 ccl_device_inline float stack_load_float_default(float *stack, uint a, uint value)
71 {
72   return (a == (uint)SVM_STACK_INVALID) ? __uint_as_float(value) : stack_load_float(stack, a);
73 }
74
75 ccl_device_inline void stack_store_float(float *stack, uint a, float f)
76 {
77   kernel_assert(a < SVM_STACK_SIZE);
78
79   stack[a] = f;
80 }
81
82 ccl_device_inline int stack_load_int(float *stack, uint a)
83 {
84   kernel_assert(a < SVM_STACK_SIZE);
85
86   return __float_as_int(stack[a]);
87 }
88
89 ccl_device_inline int stack_load_int_default(float *stack, uint a, uint value)
90 {
91   return (a == (uint)SVM_STACK_INVALID) ? (int)value : stack_load_int(stack, a);
92 }
93
94 ccl_device_inline void stack_store_int(float *stack, uint a, int i)
95 {
96   kernel_assert(a < SVM_STACK_SIZE);
97
98   stack[a] = __int_as_float(i);
99 }
100
101 ccl_device_inline bool stack_valid(uint a)
102 {
103   return a != (uint)SVM_STACK_INVALID;
104 }
105
106 /* Reading Nodes */
107
108 ccl_device_inline uint4 read_node(KernelGlobals *kg, int *offset)
109 {
110   uint4 node = kernel_tex_fetch(__svm_nodes, *offset);
111   (*offset)++;
112   return node;
113 }
114
115 ccl_device_inline float4 read_node_float(KernelGlobals *kg, int *offset)
116 {
117   uint4 node = kernel_tex_fetch(__svm_nodes, *offset);
118   float4 f = make_float4(__uint_as_float(node.x),
119                          __uint_as_float(node.y),
120                          __uint_as_float(node.z),
121                          __uint_as_float(node.w));
122   (*offset)++;
123   return f;
124 }
125
126 ccl_device_inline float4 fetch_node_float(KernelGlobals *kg, int offset)
127 {
128   uint4 node = kernel_tex_fetch(__svm_nodes, offset);
129   return make_float4(__uint_as_float(node.x),
130                      __uint_as_float(node.y),
131                      __uint_as_float(node.z),
132                      __uint_as_float(node.w));
133 }
134
135 ccl_device_forceinline void svm_unpack_node_uchar2(uint i, uint *x, uint *y)
136 {
137   *x = (i & 0xFF);
138   *y = ((i >> 8) & 0xFF);
139 }
140
141 ccl_device_forceinline void svm_unpack_node_uchar3(uint i, uint *x, uint *y, uint *z)
142 {
143   *x = (i & 0xFF);
144   *y = ((i >> 8) & 0xFF);
145   *z = ((i >> 16) & 0xFF);
146 }
147
148 ccl_device_forceinline void svm_unpack_node_uchar4(uint i, uint *x, uint *y, uint *z, uint *w)
149 {
150   *x = (i & 0xFF);
151   *y = ((i >> 8) & 0xFF);
152   *z = ((i >> 16) & 0xFF);
153   *w = ((i >> 24) & 0xFF);
154 }
155
156 CCL_NAMESPACE_END
157
158 /* Nodes */
159
160 #include "kernel/svm/svm_noise.h"
161 #include "svm_fractal_noise.h"
162
163 #include "kernel/svm/svm_color_util.h"
164 #include "kernel/svm/svm_math_util.h"
165 #include "kernel/svm/svm_mapping_util.h"
166
167 #include "kernel/svm/svm_aov.h"
168 #include "kernel/svm/svm_attribute.h"
169 #include "kernel/svm/svm_gradient.h"
170 #include "kernel/svm/svm_blackbody.h"
171 #include "kernel/svm/svm_closure.h"
172 #include "kernel/svm/svm_noisetex.h"
173 #include "kernel/svm/svm_convert.h"
174 #include "kernel/svm/svm_displace.h"
175 #include "kernel/svm/svm_fresnel.h"
176 #include "kernel/svm/svm_wireframe.h"
177 #include "kernel/svm/svm_wavelength.h"
178 #include "kernel/svm/svm_camera.h"
179 #include "kernel/svm/svm_geometry.h"
180 #include "kernel/svm/svm_hsv.h"
181 #include "kernel/svm/svm_ies.h"
182 #include "kernel/svm/svm_image.h"
183 #include "kernel/svm/svm_gamma.h"
184 #include "kernel/svm/svm_brightness.h"
185 #include "kernel/svm/svm_invert.h"
186 #include "kernel/svm/svm_light_path.h"
187 #include "kernel/svm/svm_magic.h"
188 #include "kernel/svm/svm_mapping.h"
189 #include "kernel/svm/svm_normal.h"
190 #include "kernel/svm/svm_wave.h"
191 #include "kernel/svm/svm_math.h"
192 #include "kernel/svm/svm_mix.h"
193 #include "kernel/svm/svm_ramp.h"
194 #include "kernel/svm/svm_sepcomb_hsv.h"
195 #include "kernel/svm/svm_sepcomb_vector.h"
196 #include "kernel/svm/svm_musgrave.h"
197 #include "kernel/svm/svm_sky.h"
198 #include "kernel/svm/svm_tex_coord.h"
199 #include "kernel/svm/svm_value.h"
200 #include "kernel/svm/svm_voronoi.h"
201 #include "kernel/svm/svm_checker.h"
202 #include "kernel/svm/svm_brick.h"
203 #include "kernel/svm/svm_vector_rotate.h"
204 #include "kernel/svm/svm_vector_transform.h"
205 #include "kernel/svm/svm_voxel.h"
206 #include "kernel/svm/svm_bump.h"
207 #include "kernel/svm/svm_map_range.h"
208 #include "kernel/svm/svm_clamp.h"
209 #include "kernel/svm/svm_white_noise.h"
210 #include "kernel/svm/svm_vertex_color.h"
211
212 #ifdef __SHADER_RAYTRACE__
213 #  include "kernel/svm/svm_ao.h"
214 #  include "kernel/svm/svm_bevel.h"
215 #endif
216
217 CCL_NAMESPACE_BEGIN
218
219 /* Main Interpreter Loop */
220 ccl_device_noinline void svm_eval_nodes(KernelGlobals *kg,
221                                         ShaderData *sd,
222                                         ccl_addr_space PathState *state,
223                                         ccl_global float *buffer,
224                                         ShaderType type,
225                                         int path_flag)
226 {
227   float stack[SVM_STACK_SIZE];
228   int offset = sd->shader & SHADER_MASK;
229
230   while (1) {
231     uint4 node = read_node(kg, &offset);
232
233     switch (node.x) {
234 #if NODES_GROUP(NODE_GROUP_LEVEL_0)
235       case NODE_SHADER_JUMP: {
236         if (type == SHADER_TYPE_SURFACE)
237           offset = node.y;
238         else if (type == SHADER_TYPE_VOLUME)
239           offset = node.z;
240         else if (type == SHADER_TYPE_DISPLACEMENT)
241           offset = node.w;
242         else
243           return;
244         break;
245       }
246       case NODE_CLOSURE_BSDF:
247         svm_node_closure_bsdf(kg, sd, stack, node, type, path_flag, &offset);
248         break;
249       case NODE_CLOSURE_EMISSION:
250         svm_node_closure_emission(sd, stack, node);
251         break;
252       case NODE_CLOSURE_BACKGROUND:
253         svm_node_closure_background(sd, stack, node);
254         break;
255       case NODE_CLOSURE_SET_WEIGHT:
256         svm_node_closure_set_weight(sd, node.y, node.z, node.w);
257         break;
258       case NODE_CLOSURE_WEIGHT:
259         svm_node_closure_weight(sd, stack, node.y);
260         break;
261       case NODE_EMISSION_WEIGHT:
262         svm_node_emission_weight(kg, sd, stack, node);
263         break;
264       case NODE_MIX_CLOSURE:
265         svm_node_mix_closure(sd, stack, node);
266         break;
267       case NODE_JUMP_IF_ZERO:
268         if (stack_load_float(stack, node.z) == 0.0f)
269           offset += node.y;
270         break;
271       case NODE_JUMP_IF_ONE:
272         if (stack_load_float(stack, node.z) == 1.0f)
273           offset += node.y;
274         break;
275       case NODE_GEOMETRY:
276         svm_node_geometry(kg, sd, stack, node.y, node.z);
277         break;
278       case NODE_CONVERT:
279         svm_node_convert(kg, sd, stack, node.y, node.z, node.w);
280         break;
281       case NODE_TEX_COORD:
282         svm_node_tex_coord(kg, sd, path_flag, stack, node, &offset);
283         break;
284       case NODE_VALUE_F:
285         svm_node_value_f(kg, sd, stack, node.y, node.z);
286         break;
287       case NODE_VALUE_V:
288         svm_node_value_v(kg, sd, stack, node.y, &offset);
289         break;
290       case NODE_ATTR:
291         svm_node_attr(kg, sd, stack, node);
292         break;
293       case NODE_VERTEX_COLOR:
294         svm_node_vertex_color(kg, sd, stack, node.y, node.z, node.w);
295         break;
296 #  if NODES_FEATURE(NODE_FEATURE_BUMP)
297       case NODE_GEOMETRY_BUMP_DX:
298         svm_node_geometry_bump_dx(kg, sd, stack, node.y, node.z);
299         break;
300       case NODE_GEOMETRY_BUMP_DY:
301         svm_node_geometry_bump_dy(kg, sd, stack, node.y, node.z);
302         break;
303       case NODE_SET_DISPLACEMENT:
304         svm_node_set_displacement(kg, sd, stack, node.y);
305         break;
306       case NODE_DISPLACEMENT:
307         svm_node_displacement(kg, sd, stack, node);
308         break;
309       case NODE_VECTOR_DISPLACEMENT:
310         svm_node_vector_displacement(kg, sd, stack, node, &offset);
311         break;
312 #  endif /* NODES_FEATURE(NODE_FEATURE_BUMP) */
313 #  ifdef __TEXTURES__
314       case NODE_TEX_IMAGE:
315         svm_node_tex_image(kg, sd, stack, node, &offset);
316         break;
317       case NODE_TEX_IMAGE_BOX:
318         svm_node_tex_image_box(kg, sd, stack, node);
319         break;
320       case NODE_TEX_NOISE:
321         svm_node_tex_noise(kg, sd, stack, node.y, node.z, node.w, &offset);
322         break;
323 #  endif /* __TEXTURES__ */
324 #  ifdef __EXTRA_NODES__
325 #    if NODES_FEATURE(NODE_FEATURE_BUMP)
326       case NODE_SET_BUMP:
327         svm_node_set_bump(kg, sd, stack, node);
328         break;
329       case NODE_ATTR_BUMP_DX:
330         svm_node_attr_bump_dx(kg, sd, stack, node);
331         break;
332       case NODE_ATTR_BUMP_DY:
333         svm_node_attr_bump_dy(kg, sd, stack, node);
334         break;
335       case NODE_VERTEX_COLOR_BUMP_DX:
336         svm_node_vertex_color_bump_dx(kg, sd, stack, node.y, node.z, node.w);
337         break;
338       case NODE_VERTEX_COLOR_BUMP_DY:
339         svm_node_vertex_color_bump_dy(kg, sd, stack, node.y, node.z, node.w);
340         break;
341       case NODE_TEX_COORD_BUMP_DX:
342         svm_node_tex_coord_bump_dx(kg, sd, path_flag, stack, node, &offset);
343         break;
344       case NODE_TEX_COORD_BUMP_DY:
345         svm_node_tex_coord_bump_dy(kg, sd, path_flag, stack, node, &offset);
346         break;
347       case NODE_CLOSURE_SET_NORMAL:
348         svm_node_set_normal(kg, sd, stack, node.y, node.z);
349         break;
350 #      if NODES_FEATURE(NODE_FEATURE_BUMP_STATE)
351       case NODE_ENTER_BUMP_EVAL:
352         svm_node_enter_bump_eval(kg, sd, stack, node.y);
353         break;
354       case NODE_LEAVE_BUMP_EVAL:
355         svm_node_leave_bump_eval(kg, sd, stack, node.y);
356         break;
357 #      endif /* NODES_FEATURE(NODE_FEATURE_BUMP_STATE) */
358 #    endif   /* NODES_FEATURE(NODE_FEATURE_BUMP) */
359       case NODE_HSV:
360         svm_node_hsv(kg, sd, stack, node, &offset);
361         break;
362 #  endif /* __EXTRA_NODES__ */
363 #endif   /* NODES_GROUP(NODE_GROUP_LEVEL_0) */
364
365 #if NODES_GROUP(NODE_GROUP_LEVEL_1)
366       case NODE_CLOSURE_HOLDOUT:
367         svm_node_closure_holdout(sd, stack, node);
368         break;
369       case NODE_FRESNEL:
370         svm_node_fresnel(sd, stack, node.y, node.z, node.w);
371         break;
372       case NODE_LAYER_WEIGHT:
373         svm_node_layer_weight(sd, stack, node);
374         break;
375 #  if NODES_FEATURE(NODE_FEATURE_VOLUME)
376       case NODE_CLOSURE_VOLUME:
377         svm_node_closure_volume(kg, sd, stack, node, type);
378         break;
379       case NODE_PRINCIPLED_VOLUME:
380         svm_node_principled_volume(kg, sd, stack, node, type, path_flag, &offset);
381         break;
382 #  endif /* NODES_FEATURE(NODE_FEATURE_VOLUME) */
383 #  ifdef __EXTRA_NODES__
384       case NODE_MATH:
385         svm_node_math(kg, sd, stack, node.y, node.z, node.w, &offset);
386         break;
387       case NODE_VECTOR_MATH:
388         svm_node_vector_math(kg, sd, stack, node.y, node.z, node.w, &offset);
389         break;
390       case NODE_RGB_RAMP:
391         svm_node_rgb_ramp(kg, sd, stack, node, &offset);
392         break;
393       case NODE_GAMMA:
394         svm_node_gamma(sd, stack, node.y, node.z, node.w);
395         break;
396       case NODE_BRIGHTCONTRAST:
397         svm_node_brightness(sd, stack, node.y, node.z, node.w);
398         break;
399       case NODE_LIGHT_PATH:
400         svm_node_light_path(sd, state, stack, node.y, node.z, path_flag);
401         break;
402       case NODE_OBJECT_INFO:
403         svm_node_object_info(kg, sd, stack, node.y, node.z);
404         break;
405       case NODE_PARTICLE_INFO:
406         svm_node_particle_info(kg, sd, stack, node.y, node.z);
407         break;
408 #    ifdef __HAIR__
409 #      if NODES_FEATURE(NODE_FEATURE_HAIR)
410       case NODE_HAIR_INFO:
411         svm_node_hair_info(kg, sd, stack, node.y, node.z);
412         break;
413 #      endif /* NODES_FEATURE(NODE_FEATURE_HAIR) */
414 #    endif   /* __HAIR__ */
415 #  endif     /* __EXTRA_NODES__ */
416 #endif       /* NODES_GROUP(NODE_GROUP_LEVEL_1) */
417
418 #if NODES_GROUP(NODE_GROUP_LEVEL_2)
419       case NODE_TEXTURE_MAPPING:
420         svm_node_texture_mapping(kg, sd, stack, node.y, node.z, &offset);
421         break;
422       case NODE_MAPPING:
423         svm_node_mapping(kg, sd, stack, node.y, node.z, node.w, &offset);
424         break;
425       case NODE_MIN_MAX:
426         svm_node_min_max(kg, sd, stack, node.y, node.z, &offset);
427         break;
428       case NODE_CAMERA:
429         svm_node_camera(kg, sd, stack, node.y, node.z, node.w);
430         break;
431 #  ifdef __TEXTURES__
432       case NODE_TEX_ENVIRONMENT:
433         svm_node_tex_environment(kg, sd, stack, node);
434         break;
435       case NODE_TEX_SKY:
436         svm_node_tex_sky(kg, sd, stack, node, &offset);
437         break;
438       case NODE_TEX_GRADIENT:
439         svm_node_tex_gradient(sd, stack, node);
440         break;
441       case NODE_TEX_VORONOI:
442         svm_node_tex_voronoi(kg, sd, stack, node.y, node.z, node.w, &offset);
443         break;
444       case NODE_TEX_MUSGRAVE:
445         svm_node_tex_musgrave(kg, sd, stack, node.y, node.z, node.w, &offset);
446         break;
447       case NODE_TEX_WAVE:
448         svm_node_tex_wave(kg, sd, stack, node, &offset);
449         break;
450       case NODE_TEX_MAGIC:
451         svm_node_tex_magic(kg, sd, stack, node, &offset);
452         break;
453       case NODE_TEX_CHECKER:
454         svm_node_tex_checker(kg, sd, stack, node);
455         break;
456       case NODE_TEX_BRICK:
457         svm_node_tex_brick(kg, sd, stack, node, &offset);
458         break;
459       case NODE_TEX_WHITE_NOISE:
460         svm_node_tex_white_noise(kg, sd, stack, node.y, node.z, node.w, &offset);
461         break;
462 #  endif /* __TEXTURES__ */
463 #  ifdef __EXTRA_NODES__
464       case NODE_NORMAL:
465         svm_node_normal(kg, sd, stack, node.y, node.z, node.w, &offset);
466         break;
467       case NODE_LIGHT_FALLOFF:
468         svm_node_light_falloff(sd, stack, node);
469         break;
470       case NODE_IES:
471         svm_node_ies(kg, sd, stack, node, &offset);
472         break;
473       case NODE_AOV_START:
474         if (!svm_node_aov_check(state, buffer)) {
475           return;
476         }
477         break;
478       case NODE_AOV_COLOR:
479         svm_node_aov_color(kg, sd, stack, node, buffer);
480         break;
481       case NODE_AOV_VALUE:
482         svm_node_aov_value(kg, sd, stack, node, buffer);
483         break;
484 #  endif /* __EXTRA_NODES__ */
485 #endif   /* NODES_GROUP(NODE_GROUP_LEVEL_2) */
486
487 #if NODES_GROUP(NODE_GROUP_LEVEL_3)
488       case NODE_RGB_CURVES:
489       case NODE_VECTOR_CURVES:
490         svm_node_curves(kg, sd, stack, node, &offset);
491         break;
492       case NODE_TANGENT:
493         svm_node_tangent(kg, sd, stack, node);
494         break;
495       case NODE_NORMAL_MAP:
496         svm_node_normal_map(kg, sd, stack, node);
497         break;
498 #  ifdef __EXTRA_NODES__
499       case NODE_INVERT:
500         svm_node_invert(sd, stack, node.y, node.z, node.w);
501         break;
502       case NODE_MIX:
503         svm_node_mix(kg, sd, stack, node.y, node.z, node.w, &offset);
504         break;
505       case NODE_SEPARATE_VECTOR:
506         svm_node_separate_vector(sd, stack, node.y, node.z, node.w);
507         break;
508       case NODE_COMBINE_VECTOR:
509         svm_node_combine_vector(sd, stack, node.y, node.z, node.w);
510         break;
511       case NODE_SEPARATE_HSV:
512         svm_node_separate_hsv(kg, sd, stack, node.y, node.z, node.w, &offset);
513         break;
514       case NODE_COMBINE_HSV:
515         svm_node_combine_hsv(kg, sd, stack, node.y, node.z, node.w, &offset);
516         break;
517       case NODE_VECTOR_ROTATE:
518         svm_node_vector_rotate(sd, stack, node.y, node.z, node.w);
519         break;
520       case NODE_VECTOR_TRANSFORM:
521         svm_node_vector_transform(kg, sd, stack, node);
522         break;
523       case NODE_WIREFRAME:
524         svm_node_wireframe(kg, sd, stack, node);
525         break;
526       case NODE_WAVELENGTH:
527         svm_node_wavelength(kg, sd, stack, node.y, node.z);
528         break;
529       case NODE_BLACKBODY:
530         svm_node_blackbody(kg, sd, stack, node.y, node.z);
531         break;
532       case NODE_MAP_RANGE:
533         svm_node_map_range(kg, sd, stack, node.y, node.z, node.w, &offset);
534         break;
535       case NODE_CLAMP:
536         svm_node_clamp(kg, sd, stack, node.y, node.z, node.w, &offset);
537         break;
538 #  endif /* __EXTRA_NODES__ */
539 #  if NODES_FEATURE(NODE_FEATURE_VOLUME)
540       case NODE_TEX_VOXEL:
541         svm_node_tex_voxel(kg, sd, stack, node, &offset);
542         break;
543 #  endif /* NODES_FEATURE(NODE_FEATURE_VOLUME) */
544 #  ifdef __SHADER_RAYTRACE__
545       case NODE_BEVEL:
546         svm_node_bevel(kg, sd, state, stack, node);
547         break;
548       case NODE_AMBIENT_OCCLUSION:
549         svm_node_ao(kg, sd, state, stack, node);
550         break;
551 #  endif /* __SHADER_RAYTRACE__ */
552 #endif   /* NODES_GROUP(NODE_GROUP_LEVEL_3) */
553       case NODE_END:
554         return;
555       default:
556         kernel_assert(!"Unknown node type was passed to the SVM machine");
557         return;
558     }
559   }
560 }
561
562 CCL_NAMESPACE_END
563
564 #endif /* __SVM_H__ */