20dba59d2d0d917509055bd4e5a2518de833ecf5
[blender.git] / intern / cycles / kernel / svm / svm.h
1 /*
2  * Copyright 2011, Blender Foundation.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  */
18
19 #ifndef __SVM_H__
20 #define __SVM_H__
21
22 /* Shader Virtual Machine
23  *
24  * A shader is a list of nodes to be executed. These are simply read one after
25  * the other and executed, using an node counter. Each node and it's associated
26  * data is encoded as one or more uint4's in a 1D texture. If the data is larger
27  * than an uint4, the node can increase the node counter to compensate for this.
28  * Floats are encoded as int and then converted to float again.
29  *
30  * Nodes write their output into a stack. All stack data in the stack is
31  * floats, since it's all factors, colors and vectors. The stack will be stored
32  * in local memory on the GPU, as it would take too many register and indexes in
33  * ways not known at compile time. This seems the only solution even though it
34  * may be slow, with two positive factors. If the same shader is being executed,
35  * memory access will be coalesced, and on fermi cards, memory will actually be
36  * cached.
37  *
38  * The result of shader execution will be a single closure. This means the
39  * closure type, associated label, data and weight. Sampling from multiple
40  * closures is supported through the mix closure node, the logic for that is
41  * mostly taken care of in the SVM compiler.
42  */
43
44 #include "svm_types.h"
45
46 CCL_NAMESPACE_BEGIN
47
48 /* Stack */
49
50 __device_inline float3 stack_load_float3(float *stack, uint a)
51 {
52         kernel_assert(a+2 < SVM_STACK_SIZE);
53
54         return make_float3(stack[a+0], stack[a+1], stack[a+2]);
55 }
56
57 __device_inline void stack_store_float3(float *stack, uint a, float3 f)
58 {
59         kernel_assert(a+2 < SVM_STACK_SIZE);
60
61         stack[a+0] = f.x;
62         stack[a+1] = f.y;
63         stack[a+2] = f.z;
64 }
65
66 __device_inline float stack_load_float(float *stack, uint a)
67 {
68         kernel_assert(a < SVM_STACK_SIZE);
69
70         return stack[a];
71 }
72
73 __device_inline float stack_load_float_default(float *stack, uint a, uint value)
74 {
75         return (a == (uint)SVM_STACK_INVALID)? __uint_as_float(value): stack_load_float(stack, a);
76 }
77
78 __device_inline void stack_store_float(float *stack, uint a, float f)
79 {
80         kernel_assert(a < SVM_STACK_SIZE);
81
82         stack[a] = f;
83 }
84
85 __device_inline int stack_load_int(float *stack, uint a)
86 {
87         kernel_assert(a < SVM_STACK_SIZE);
88
89         return __float_as_int(stack[a]);
90 }
91
92 __device_inline float stack_load_int_default(float *stack, uint a, uint value)
93 {
94         return (a == (uint)SVM_STACK_INVALID)? (int)value: stack_load_int(stack, a);
95 }
96
97 __device_inline void stack_store_int(float *stack, uint a, int i)
98 {
99         kernel_assert(a < SVM_STACK_SIZE);
100
101         stack[a] = __int_as_float(i);
102 }
103
104 __device_inline bool stack_valid(uint a)
105 {
106         return a != (uint)SVM_STACK_INVALID;
107 }
108
109 /* Reading Nodes */
110
111 __device_inline uint4 read_node(KernelGlobals *kg, int *offset)
112 {
113         uint4 node = kernel_tex_fetch(__svm_nodes, *offset);
114         (*offset)++;
115         return node;
116 }
117
118 __device_inline float4 read_node_float(KernelGlobals *kg, int *offset)
119 {
120         uint4 node = kernel_tex_fetch(__svm_nodes, *offset);
121         float4 f = make_float4(__uint_as_float(node.x), __uint_as_float(node.y), __uint_as_float(node.z), __uint_as_float(node.w));
122         (*offset)++;
123         return f;
124 }
125
126 __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), __uint_as_float(node.y), __uint_as_float(node.z), __uint_as_float(node.w));
130 }
131
132 __device_inline void decode_node_uchar4(uint i, uint *x, uint *y, uint *z, uint *w)
133 {
134         if(x) *x = (i & 0xFF);
135         if(y) *y = ((i >> 8) & 0xFF);
136         if(z) *z = ((i >> 16) & 0xFF);
137         if(w) *w = ((i >> 24) & 0xFF);
138 }
139
140 CCL_NAMESPACE_END
141
142 /* Nodes */
143
144 #include "svm_noise.h"
145 #include "svm_texture.h"
146
147 #include "svm_attribute.h"
148 #include "svm_gradient.h"
149 #include "svm_blackbody.h"
150 #include "svm_closure.h"
151 #include "svm_noisetex.h"
152 #include "svm_convert.h"
153 #include "svm_displace.h"
154 #include "svm_fresnel.h"
155 #include "svm_wireframe.h"
156 #include "svm_wavelength.h"
157 #include "svm_camera.h"
158 #include "svm_geometry.h"
159 #include "svm_hsv.h"
160 #include "svm_image.h"
161 #include "svm_gamma.h"
162 #include "svm_brightness.h"
163 #include "svm_invert.h"
164 #include "svm_light_path.h"
165 #include "svm_magic.h"
166 #include "svm_mapping.h"
167 #include "svm_normal.h"
168 #include "svm_wave.h"
169 #include "svm_math.h"
170 #include "svm_mix.h"
171 #include "svm_ramp.h"
172 #include "svm_sepcomb_rgb.h"
173 #include "svm_musgrave.h"
174 #include "svm_sky.h"
175 #include "svm_tex_coord.h"
176 #include "svm_value.h"
177 #include "svm_voronoi.h"
178 #include "svm_checker.h"
179 #include "svm_brick.h"
180 #include "svm_vector_transform.h"
181
182 CCL_NAMESPACE_BEGIN
183
184 /* Main Interpreter Loop */
185
186 __device_noinline void svm_eval_nodes(KernelGlobals *kg, ShaderData *sd, ShaderType type, float randb, int path_flag)
187 {
188         float stack[SVM_STACK_SIZE];
189         float closure_weight = 1.0f;
190         int offset = sd->shader & SHADER_MASK;
191
192 #ifdef __MULTI_CLOSURE__
193         sd->num_closure = 0;
194         sd->randb_closure = randb;
195 #else
196         sd->closure.type = NBUILTIN_CLOSURES;
197 #endif
198
199         while(1) {
200                 uint4 node = read_node(kg, &offset);
201
202                 switch(node.x) {
203                         case NODE_SHADER_JUMP: {
204                                 if(type == SHADER_TYPE_SURFACE) offset = node.y;
205                                 else if(type == SHADER_TYPE_VOLUME) offset = node.z;
206                                 else if(type == SHADER_TYPE_DISPLACEMENT) offset = node.w;
207                                 else return;
208                                 break;
209                         }
210                         case NODE_CLOSURE_BSDF:
211                                 svm_node_closure_bsdf(kg, sd, stack, node, randb, path_flag, &offset);
212                                 break;
213                         case NODE_CLOSURE_EMISSION:
214                                 svm_node_closure_emission(sd, stack, node);
215                                 break;
216                         case NODE_CLOSURE_BACKGROUND:
217                                 svm_node_closure_background(sd, stack, node);
218                                 break;
219                         case NODE_CLOSURE_HOLDOUT:
220                                 svm_node_closure_holdout(sd, stack, node);
221                                 break;
222                         case NODE_CLOSURE_AMBIENT_OCCLUSION:
223                                 svm_node_closure_ambient_occlusion(sd, stack, node);
224                                 break;
225                         case NODE_CLOSURE_VOLUME:
226                                 svm_node_closure_volume(kg, sd, stack, node, path_flag);
227                                 break;
228                         case NODE_CLOSURE_SET_WEIGHT:
229                                 svm_node_closure_set_weight(sd, node.y, node.z, node.w);
230                                 break;
231                         case NODE_CLOSURE_WEIGHT:
232                                 svm_node_closure_weight(sd, stack, node.y);
233                                 break;
234                         case NODE_EMISSION_WEIGHT:
235                                 svm_node_emission_weight(kg, sd, stack, node);
236                                 break;
237                         case NODE_MIX_CLOSURE:
238                                 svm_node_mix_closure(sd, stack, node, &offset, &randb);
239                                 break;
240                         case NODE_ADD_CLOSURE:
241                                 svm_node_add_closure(sd, stack, node.y, node.z, &offset, &randb, &closure_weight);
242                                 break;
243                         case NODE_JUMP:
244                                 offset = node.y;
245                                 break;
246 #ifdef __IMAGE_TEXTURES__
247                         case NODE_TEX_IMAGE:
248                                 svm_node_tex_image(kg, sd, stack, node);
249                                 break;
250                         case NODE_TEX_IMAGE_BOX:
251                                 svm_node_tex_image_box(kg, sd, stack, node);
252                                 break;
253                         case NODE_TEX_ENVIRONMENT:
254                                 svm_node_tex_environment(kg, sd, stack, node);
255                                 break;
256 #endif
257 #ifdef __PROCEDURAL_TEXTURES__
258                         case NODE_TEX_SKY:
259                                 svm_node_tex_sky(kg, sd, stack, node.y, node.z);
260                                 break;
261                         case NODE_TEX_GRADIENT:
262                                 svm_node_tex_gradient(sd, stack, node);
263                                 break;
264                         case NODE_TEX_NOISE:
265                                 svm_node_tex_noise(kg, sd, stack, node, &offset);
266                                 break;
267                         case NODE_TEX_VORONOI:
268                                 svm_node_tex_voronoi(kg, sd, stack, node, &offset);
269                                 break;
270                         case NODE_TEX_MUSGRAVE:
271                                 svm_node_tex_musgrave(kg, sd, stack, node, &offset);
272                                 break;
273                         case NODE_TEX_WAVE:
274                                 svm_node_tex_wave(kg, sd, stack, node, &offset);
275                                 break;
276                         case NODE_TEX_MAGIC:
277                                 svm_node_tex_magic(kg, sd, stack, node, &offset);
278                                 break;
279                         case NODE_TEX_CHECKER:
280                                 svm_node_tex_checker(kg, sd, stack, node);
281                                 break;
282                         case NODE_TEX_BRICK:
283                                 svm_node_tex_brick(kg, sd, stack, node, &offset);
284                                 break;
285 #endif
286                         case NODE_CAMERA:
287                                 svm_node_camera(kg, sd, stack, node.y, node.z, node.w);
288                                 break;
289                         case NODE_GEOMETRY:
290                                 svm_node_geometry(kg, sd, stack, node.y, node.z);
291                                 break;
292 #ifdef __EXTRA_NODES__
293                         case NODE_GEOMETRY_BUMP_DX:
294                                 svm_node_geometry_bump_dx(kg, sd, stack, node.y, node.z);
295                                 break;
296                         case NODE_GEOMETRY_BUMP_DY:
297                                 svm_node_geometry_bump_dy(kg, sd, stack, node.y, node.z);
298                                 break;
299                         case NODE_LIGHT_PATH:
300                                 svm_node_light_path(sd, stack, node.y, node.z, path_flag);
301                                 break;
302                         case NODE_OBJECT_INFO:
303                                 svm_node_object_info(kg, sd, stack, node.y, node.z);
304                                 break;
305                         case NODE_PARTICLE_INFO:
306                                 svm_node_particle_info(kg, sd, stack, node.y, node.z);
307                                 break;
308 #ifdef __HAIR__
309                         case NODE_HAIR_INFO:
310                                 svm_node_hair_info(kg, sd, stack, node.y, node.z);
311                                 break;
312 #endif
313
314 #endif
315                         case NODE_CONVERT:
316                                 svm_node_convert(sd, stack, node.y, node.z, node.w);
317                                 break;
318                         case NODE_VALUE_F:
319                                 svm_node_value_f(kg, sd, stack, node.y, node.z);
320                                 break;
321                         case NODE_VALUE_V:
322                                 svm_node_value_v(kg, sd, stack, node.y, &offset);
323                                 break;
324 #ifdef __EXTRA_NODES__
325                         case NODE_INVERT:
326                                 svm_node_invert(sd, stack, node.y, node.z, node.w);
327                                 break;
328                         case NODE_GAMMA:
329                                 svm_node_gamma(sd, stack, node.y, node.z, node.w);
330                                 break;
331                         case NODE_BRIGHTCONTRAST:
332                                 svm_node_brightness(sd, stack, node.y, node.z, node.w);
333                                 break;
334                         case NODE_MIX:
335                                 svm_node_mix(kg, sd, stack, node.y, node.z, node.w, &offset);
336                                 break;
337                         case NODE_SEPARATE_RGB:
338                                 svm_node_separate_rgb(sd, stack, node.y, node.z, node.w);
339                                 break;
340                         case NODE_COMBINE_RGB:
341                                 svm_node_combine_rgb(sd, stack, node.y, node.z, node.w);
342                                 break;
343                         case NODE_HSV:
344                                 svm_node_hsv(kg, sd, stack, node.y, node.z, node.w, &offset);
345                                 break;
346 #endif
347                         case NODE_ATTR:
348                                 svm_node_attr(kg, sd, stack, node);
349                                 break;
350 #ifdef __EXTRA_NODES__
351                         case NODE_ATTR_BUMP_DX:
352                                 svm_node_attr_bump_dx(kg, sd, stack, node);
353                                 break;
354                         case NODE_ATTR_BUMP_DY:
355                                 svm_node_attr_bump_dy(kg, sd, stack, node);
356                                 break;
357 #endif
358                         case NODE_FRESNEL:
359                                 svm_node_fresnel(sd, stack, node.y, node.z, node.w);
360                                 break;
361                         case NODE_LAYER_WEIGHT:
362                                 svm_node_layer_weight(sd, stack, node);
363                                 break;
364 #ifdef __EXTRA_NODES__
365                         case NODE_WIREFRAME:
366                                 svm_node_wireframe(kg, sd, stack, node.y, node.z, node.w);
367                                 break;
368                         case NODE_WAVELENGTH:
369                                 svm_node_wavelength(sd, stack, node.y, node.z);
370                                 break;
371                         case NODE_BLACKBODY:
372                                 svm_node_blackbody(kg, sd, stack, node.y, node.z);
373                                 break;
374                         case NODE_SET_DISPLACEMENT:
375                                 svm_node_set_displacement(sd, stack, node.y);
376                                 break;
377                         case NODE_SET_BUMP:
378                                 svm_node_set_bump(kg, sd, stack, node);
379                                 break;
380                         case NODE_MATH:
381                                 svm_node_math(kg, sd, stack, node.y, node.z, node.w, &offset);
382                                 break;
383                         case NODE_VECTOR_MATH:
384                                 svm_node_vector_math(kg, sd, stack, node.y, node.z, node.w, &offset);
385                                 break;
386                         case NODE_VECTOR_TRANSFORM:
387                                 svm_node_vector_transform(kg, sd, stack, node);
388                                 break;
389                         case NODE_NORMAL:
390                                 svm_node_normal(kg, sd, stack, node.y, node.z, node.w, &offset);
391                                 break;
392 #endif
393                         case NODE_MAPPING:
394                                 svm_node_mapping(kg, sd, stack, node.y, node.z, &offset);
395                                 break;
396                         case NODE_MIN_MAX:
397                                 svm_node_min_max(kg, sd, stack, node.y, node.z, &offset);
398                                 break;
399                         case NODE_TEX_COORD:
400                                 svm_node_tex_coord(kg, sd, path_flag, stack, node.y, node.z);
401                                 break;
402 #ifdef __EXTRA_NODES__
403                         case NODE_TEX_COORD_BUMP_DX:
404                                 svm_node_tex_coord_bump_dx(kg, sd, path_flag, stack, node.y, node.z);
405                                 break;
406                         case NODE_TEX_COORD_BUMP_DY:
407                                 svm_node_tex_coord_bump_dy(kg, sd, path_flag, stack, node.y, node.z);
408                                 break;
409                         case NODE_CLOSURE_SET_NORMAL:
410                                 svm_node_set_normal(kg, sd, stack, node.y, node.z );
411                                 break;                  
412 #endif
413                         case NODE_EMISSION_SET_WEIGHT_TOTAL:
414                                 svm_node_emission_set_weight_total(kg, sd, node.y, node.z, node.w);
415                                 break;
416 #ifdef __EXTRA_NODES__
417                         case NODE_RGB_RAMP:
418                                 svm_node_rgb_ramp(kg, sd, stack, node, &offset);
419                                 break;
420                         case NODE_RGB_CURVES:
421                                 svm_node_rgb_curves(kg, sd, stack, node, &offset);
422                                 break;
423                         case NODE_VECTOR_CURVES:
424                                 svm_node_vector_curves(kg, sd, stack, node, &offset);
425                                 break;
426                         case NODE_LIGHT_FALLOFF:
427                                 svm_node_light_falloff(sd, stack, node);
428                                 break;
429 #endif                  
430 #ifdef __ANISOTROPIC__
431                         case NODE_TANGENT:
432                                 svm_node_tangent(kg, sd, stack, node);
433                                 break;
434 #endif                  
435 #ifdef __NORMAL_MAP__
436                         case NODE_NORMAL_MAP:
437                                 svm_node_normal_map(kg, sd, stack, node);
438                                 break;
439 #endif                  
440                         case NODE_END:
441                         default:
442 #ifndef __MULTI_CLOSURE__
443                                 sd->closure.weight *= closure_weight;
444 #endif
445                                 return;
446                 }
447         }
448 }
449
450 CCL_NAMESPACE_END
451
452 #endif /* __SVM_H__ */
453