Fix Cycles viewport render not updating when tweaking displacement shader.
[blender.git] / intern / cycles / graph / node.cpp
1 /*
2  * Copyright 2011-2016 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 #include "graph/node.h"
18 #include "graph/node_type.h"
19
20 #include "util/util_foreach.h"
21 #include "util/util_md5.h"
22 #include "util/util_param.h"
23 #include "util/util_transform.h"
24
25 CCL_NAMESPACE_BEGIN
26
27 /* Node Type */
28
29 Node::Node(const NodeType *type_, ustring name_)
30 : name(name_), type(type_)
31 {
32         assert(type);
33
34         /* assign non-empty name, convenient for debugging */
35         if(name.empty()) {
36                 name = type->name;
37         }
38
39         /* initialize default values */
40         foreach(const SocketType& socket, type->inputs) {
41                 set_default_value(socket);
42         }
43 }
44
45 Node::~Node()
46 {
47 }
48
49 template<typename T>
50 static T& get_socket_value(const Node *node, const SocketType& socket)
51 {
52         return (T&)*(((char*)node) + socket.struct_offset);
53 }
54
55 #ifndef NDEBUG
56 static bool is_socket_float3(const SocketType& socket)
57 {
58         return socket.type == SocketType::COLOR ||
59                socket.type == SocketType::POINT ||
60                    socket.type == SocketType::VECTOR ||
61                    socket.type == SocketType::NORMAL;
62 }
63
64 static bool is_socket_array_float3(const SocketType& socket)
65 {
66         return socket.type == SocketType::COLOR_ARRAY ||
67                socket.type == SocketType::POINT_ARRAY ||
68                    socket.type == SocketType::VECTOR_ARRAY ||
69                    socket.type == SocketType::NORMAL_ARRAY;
70 }
71 #endif
72
73 /* set values */
74 void Node::set(const SocketType& input, bool value)
75 {
76         assert(input.type == SocketType::BOOLEAN);
77         get_socket_value<bool>(this, input) = value;
78 }
79
80 void Node::set(const SocketType& input, int value)
81 {
82         assert((input.type == SocketType::INT || input.type == SocketType::ENUM));
83         get_socket_value<int>(this, input) = value;
84 }
85
86 void Node::set(const SocketType& input, uint value)
87 {
88         assert(input.type == SocketType::UINT);
89         get_socket_value<uint>(this, input) = value;
90 }
91
92 void Node::set(const SocketType& input, float value)
93 {
94         assert(input.type == SocketType::FLOAT);
95         get_socket_value<float>(this, input) = value;
96 }
97
98 void Node::set(const SocketType& input, float2 value)
99 {
100         assert(input.type == SocketType::FLOAT);
101         get_socket_value<float2>(this, input) = value;
102 }
103
104 void Node::set(const SocketType& input, float3 value)
105 {
106         assert(is_socket_float3(input));
107         get_socket_value<float3>(this, input) = value;
108 }
109
110 void Node::set(const SocketType& input, const char *value)
111 {
112         set(input, ustring(value));
113 }
114
115 void Node::set(const SocketType& input, ustring value)
116 {
117         if(input.type == SocketType::STRING) {
118                 get_socket_value<ustring>(this, input) = value;
119         }
120         else if(input.type == SocketType::ENUM) {
121                 const NodeEnum& enm = *input.enum_values;
122                 if(enm.exists(value)) {
123                         get_socket_value<int>(this, input) = enm[value];
124                 }
125                 else {
126                         assert(0);
127                 }
128         }
129         else {
130                 assert(0);
131         }
132 }
133
134 void Node::set(const SocketType& input, const Transform& value)
135 {
136         assert(input.type == SocketType::TRANSFORM);
137         get_socket_value<Transform>(this, input) = value;
138 }
139
140 void Node::set(const SocketType& input, Node *value)
141 {
142         assert(input.type == SocketType::TRANSFORM);
143         get_socket_value<Node*>(this, input) = value;
144 }
145
146 /* set array values */
147 void Node::set(const SocketType& input, array<bool>& value)
148 {
149         assert(input.type == SocketType::BOOLEAN_ARRAY);
150         get_socket_value<array<bool> >(this, input).steal_data(value);
151 }
152
153 void Node::set(const SocketType& input, array<int>& value)
154 {
155         assert(input.type == SocketType::INT_ARRAY);
156         get_socket_value<array<int> >(this, input).steal_data(value);
157 }
158
159 void Node::set(const SocketType& input, array<float>& value)
160 {
161         assert(input.type == SocketType::FLOAT_ARRAY);
162         get_socket_value<array<float> >(this, input).steal_data(value);
163 }
164
165 void Node::set(const SocketType& input, array<float2>& value)
166 {
167         assert(input.type == SocketType::FLOAT_ARRAY);
168         get_socket_value<array<float2> >(this, input).steal_data(value);
169 }
170
171 void Node::set(const SocketType& input, array<float3>& value)
172 {
173         assert(is_socket_array_float3(input));
174         get_socket_value<array<float3> >(this, input).steal_data(value);
175 }
176
177 void Node::set(const SocketType& input, array<ustring>& value)
178 {
179         assert(input.type == SocketType::STRING_ARRAY);
180         get_socket_value<array<ustring> >(this, input).steal_data(value);
181 }
182
183 void Node::set(const SocketType& input, array<Transform>& value)
184 {
185         assert(input.type == SocketType::TRANSFORM_ARRAY);
186         get_socket_value<array<Transform> >(this, input).steal_data(value);
187 }
188
189 void Node::set(const SocketType& input, array<Node*>& value)
190 {
191         assert(input.type == SocketType::TRANSFORM_ARRAY);
192         get_socket_value<array<Node*> >(this, input).steal_data(value);
193 }
194
195 /* get values */
196 bool Node::get_bool(const SocketType& input) const
197 {
198         assert(input.type == SocketType::BOOLEAN);
199         return get_socket_value<bool>(this, input);
200 }
201
202 int Node::get_int(const SocketType& input) const
203 {
204         assert(input.type == SocketType::INT || input.type == SocketType::ENUM);
205         return get_socket_value<int>(this, input);
206 }
207
208 uint Node::get_uint(const SocketType& input) const
209 {
210         assert(input.type == SocketType::UINT);
211         return get_socket_value<uint>(this, input);
212 }
213
214 float Node::get_float(const SocketType& input) const
215 {
216         assert(input.type == SocketType::FLOAT);
217         return get_socket_value<float>(this, input);
218 }
219
220 float2 Node::get_float2(const SocketType& input) const
221 {
222         assert(input.type == SocketType::FLOAT);
223         return get_socket_value<float2>(this, input);
224 }
225
226 float3 Node::get_float3(const SocketType& input) const
227 {
228         assert(is_socket_float3(input));
229         return get_socket_value<float3>(this, input);
230 }
231
232 ustring Node::get_string(const SocketType& input) const
233 {
234         if(input.type == SocketType::STRING) {
235                 return get_socket_value<ustring>(this, input);
236         }
237         else if(input.type == SocketType::ENUM) {
238                 const NodeEnum& enm = *input.enum_values;
239                 int intvalue = get_socket_value<int>(this, input);
240                 return (enm.exists(intvalue)) ? enm[intvalue] : ustring();
241         }
242         else {
243                 assert(0);
244                 return ustring();
245         }
246 }
247
248 Transform Node::get_transform(const SocketType& input) const
249 {
250         assert(input.type == SocketType::TRANSFORM);
251         return get_socket_value<Transform>(this, input);
252 }
253
254 Node *Node::get_node(const SocketType& input) const
255 {
256         assert(input.type == SocketType::NODE);
257         return get_socket_value<Node*>(this, input);
258 }
259
260 /* get array values */
261 const array<bool>& Node::get_bool_array(const SocketType& input) const
262 {
263         assert(input.type == SocketType::BOOLEAN_ARRAY);
264         return get_socket_value<array<bool> >(this, input);
265 }
266
267 const array<int>& Node::get_int_array(const SocketType& input) const
268 {
269         assert(input.type == SocketType::INT_ARRAY);
270         return get_socket_value<array<int> >(this, input);
271 }
272
273 const array<float>& Node::get_float_array(const SocketType& input) const
274 {
275         assert(input.type == SocketType::FLOAT_ARRAY);
276         return get_socket_value<array<float> >(this, input);
277 }
278
279 const array<float2>& Node::get_float2_array(const SocketType& input) const
280 {
281         assert(input.type == SocketType::FLOAT_ARRAY);
282         return get_socket_value<array<float2> >(this, input);
283 }
284
285 const array<float3>& Node::get_float3_array(const SocketType& input) const
286 {
287         assert(is_socket_array_float3(input));
288         return get_socket_value<array<float3> >(this, input);
289 }
290
291 const array<ustring>& Node::get_string_array(const SocketType& input) const
292 {
293         assert(input.type == SocketType::STRING_ARRAY);
294         return get_socket_value<array<ustring> >(this, input);
295 }
296
297 const array<Transform>& Node::get_transform_array(const SocketType& input) const
298 {
299         assert(input.type == SocketType::TRANSFORM_ARRAY);
300         return get_socket_value<array<Transform> >(this, input);
301 }
302
303 const array<Node*>& Node::get_node_array(const SocketType& input) const
304 {
305         assert(input.type == SocketType::NODE_ARRAY);
306         return get_socket_value<array<Node*> >(this, input);
307 }
308
309 /* generic value operations */
310
311 bool Node::has_default_value(const SocketType& input) const
312 {
313         const void *src = input.default_value;
314         void *dst = &get_socket_value<char>(this, input);
315         return memcmp(dst, src, input.size()) == 0;
316 }
317
318 void Node::set_default_value(const SocketType& socket)
319 {
320         const void *src = socket.default_value;
321         void *dst = ((char*)this) + socket.struct_offset;
322         memcpy(dst, src, socket.size());
323 }
324
325 template<typename T>
326 static void copy_array(const Node *node, const SocketType& socket, const Node *other, const SocketType& other_socket)
327 {
328         const array<T>* src = (const array<T>*)(((char*)other) + other_socket.struct_offset);
329         array<T>* dst = (array<T>*)(((char*)node) + socket.struct_offset);
330         *dst = *src;
331 }
332
333 void Node::copy_value(const SocketType& socket, const Node& other, const SocketType& other_socket)
334 {
335         assert(socket.type == other_socket.type);
336
337         if(socket.is_array()) {
338                 switch(socket.type) {
339                         case SocketType::BOOLEAN_ARRAY: copy_array<bool>(this, socket, &other, other_socket); break;
340                         case SocketType::FLOAT_ARRAY: copy_array<float>(this, socket, &other, other_socket); break;
341                         case SocketType::INT_ARRAY: copy_array<int>(this, socket, &other, other_socket); break;
342                         case SocketType::COLOR_ARRAY: copy_array<float3>(this, socket, &other, other_socket); break;
343                         case SocketType::VECTOR_ARRAY: copy_array<float3>(this, socket, &other, other_socket); break;
344                         case SocketType::POINT_ARRAY: copy_array<float3>(this, socket, &other, other_socket); break;
345                         case SocketType::NORMAL_ARRAY: copy_array<float3>(this, socket, &other, other_socket); break;
346                         case SocketType::POINT2_ARRAY: copy_array<float2>(this, socket, &other, other_socket); break;
347                         case SocketType::STRING_ARRAY: copy_array<ustring>(this, socket, &other, other_socket); break;
348                         case SocketType::TRANSFORM_ARRAY: copy_array<Transform>(this, socket, &other, other_socket); break;
349                         case SocketType::NODE_ARRAY: copy_array<void*>(this, socket, &other, other_socket); break;
350                         default: assert(0); break;
351                 }
352         }
353         else {
354                 const void *src = ((char*)&other) + other_socket.struct_offset;
355                 void *dst = ((char*)this) + socket.struct_offset;
356                 memcpy(dst, src, socket.size());
357         }
358 }
359
360 template<typename T>
361 static bool is_array_equal(const Node *node, const Node *other, const SocketType& socket)
362 {
363         const array<T>* a = (const array<T>*)(((char*)node) + socket.struct_offset);
364         const array<T>* b = (const array<T>*)(((char*)other) + socket.struct_offset);
365         return *a == *b;
366 }
367
368 bool Node::equals_value(const Node& other, const SocketType& socket) const
369 {
370         if(socket.is_array()) {
371                 switch(socket.type) {
372                         case SocketType::BOOLEAN_ARRAY: return is_array_equal<bool>(this, &other, socket);
373                         case SocketType::FLOAT_ARRAY: return is_array_equal<float>(this, &other, socket);
374                         case SocketType::INT_ARRAY: return is_array_equal<int>(this, &other, socket);
375                         case SocketType::COLOR_ARRAY: return is_array_equal<float3>(this, &other, socket);
376                         case SocketType::VECTOR_ARRAY: return is_array_equal<float3>(this, &other, socket);
377                         case SocketType::POINT_ARRAY: return is_array_equal<float3>(this, &other, socket);
378                         case SocketType::NORMAL_ARRAY: return is_array_equal<float3>(this, &other, socket);
379                         case SocketType::POINT2_ARRAY: return is_array_equal<float2>(this, &other, socket);
380                         case SocketType::STRING_ARRAY: return is_array_equal<ustring>(this, &other, socket);
381                         case SocketType::TRANSFORM_ARRAY: return is_array_equal<Transform>(this, &other, socket);
382                         case SocketType::NODE_ARRAY: return is_array_equal<void*>(this, &other, socket);
383                         default: assert(0); return true;
384                 }
385         }
386         else {
387                 const void *a = ((char*)this) + socket.struct_offset;
388                 const void *b = ((char*)&other) + socket.struct_offset;
389                 return (memcmp(a, b, socket.size()) == 0);
390         }
391 }
392
393 /* equals */
394
395 bool Node::equals(const Node& other) const
396 {
397         assert(type == other.type);
398
399         foreach(const SocketType& socket, type->inputs) {
400                 if(!equals_value(other, socket))
401                         return false;
402         }
403
404         return true;
405 }
406
407 /* Hash */
408
409 void Node::hash(MD5Hash& md5)
410 {
411         md5.append(type->name.string());
412
413         foreach(const SocketType& socket, type->inputs) {
414                 md5.append(socket.name.string());
415
416                 if(socket.is_array()) {
417                         const array<bool>* a = (const array<bool>*)(((char*)this) + socket.struct_offset);
418                         md5.append((uint8_t*)a->data(), socket.size() * a->size());
419                 }
420                 else {
421                         md5.append(((uint8_t*)this) + socket.struct_offset, socket.size());
422                 }
423         }
424 }
425
426 CCL_NAMESPACE_END
427