Cycles: support loading images from arbitrary OpenColorIO color space
[blender.git] / intern / cycles / render / osl.cpp
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 #include "device/device.h"
18
19 #include "render/colorspace.h"
20 #include "render/graph.h"
21 #include "render/light.h"
22 #include "render/osl.h"
23 #include "render/scene.h"
24 #include "render/shader.h"
25 #include "render/nodes.h"
26
27 #ifdef WITH_OSL
28
29 #  include "kernel/osl/osl_globals.h"
30 #  include "kernel/osl/osl_services.h"
31 #  include "kernel/osl/osl_shader.h"
32
33 #  include "util/util_foreach.h"
34 #  include "util/util_logging.h"
35 #  include "util/util_md5.h"
36 #  include "util/util_path.h"
37 #  include "util/util_progress.h"
38 #  include "util/util_projection.h"
39
40 #endif
41
42 CCL_NAMESPACE_BEGIN
43
44 #ifdef WITH_OSL
45
46 /* Shared Texture and Shading System */
47
48 OSL::TextureSystem *OSLShaderManager::ts_shared = NULL;
49 int OSLShaderManager::ts_shared_users = 0;
50 thread_mutex OSLShaderManager::ts_shared_mutex;
51
52 OSL::ShadingSystem *OSLShaderManager::ss_shared = NULL;
53 OSLRenderServices *OSLShaderManager::services_shared = NULL;
54 int OSLShaderManager::ss_shared_users = 0;
55 thread_mutex OSLShaderManager::ss_shared_mutex;
56 thread_mutex OSLShaderManager::ss_mutex;
57
58 /* Shader Manager */
59
60 OSLShaderManager::OSLShaderManager()
61 {
62   texture_system_init();
63   shading_system_init();
64 }
65
66 OSLShaderManager::~OSLShaderManager()
67 {
68   shading_system_free();
69   texture_system_free();
70 }
71
72 void OSLShaderManager::free_memory()
73 {
74 #  ifdef OSL_HAS_BLENDER_CLEANUP_FIX
75   /* There is a problem with llvm+osl: The order global destructors across
76    * different compilation units run cannot be guaranteed, on windows this means
77    * that the llvm destructors run before the osl destructors, causing a crash
78    * when the process exits. the OSL in svn has a special cleanup hack to
79    * sidestep this behavior */
80   OSL::pvt::LLVM_Util::Cleanup();
81 #  endif
82 }
83
84 void OSLShaderManager::reset(Scene * /*scene*/)
85 {
86   shading_system_free();
87   shading_system_init();
88 }
89
90 void OSLShaderManager::device_update(Device *device,
91                                      DeviceScene *dscene,
92                                      Scene *scene,
93                                      Progress &progress)
94 {
95   if (!need_update)
96     return;
97
98   VLOG(1) << "Total " << scene->shaders.size() << " shaders.";
99
100   device_free(device, dscene, scene);
101
102   /* determine which shaders are in use */
103   device_update_shaders_used(scene);
104
105   /* create shaders */
106   OSLGlobals *og = (OSLGlobals *)device->osl_memory();
107
108   /* Partial thread init of services, the OSL compiler can query data like
109    * constant texture handles. This will be done again right before rendering
110    * with full data available. */
111   services->thread_init(NULL, og, ts);
112
113   foreach (Shader *shader, scene->shaders) {
114     assert(shader->graph);
115
116     if (progress.get_cancel())
117       return;
118
119     /* we can only compile one shader at the time as the OSL ShadingSytem
120      * has a single state, but we put the lock here so different renders can
121      * compile shaders alternating */
122     thread_scoped_lock lock(ss_mutex);
123
124     OSLCompiler compiler((void *)this, (void *)ss, og, scene->image_manager, scene->light_manager);
125     compiler.background = (shader == scene->default_background);
126     compiler.compile(scene, shader);
127
128     if (shader->use_mis && shader->has_surface_emission)
129       scene->light_manager->need_update = true;
130   }
131
132   /* setup shader engine */
133   og->ss = ss;
134   og->ts = ts;
135   og->services = services;
136
137   int background_id = scene->shader_manager->get_shader_id(scene->default_background);
138   og->background_state = og->surface_state[background_id & SHADER_MASK];
139   og->use = true;
140
141   foreach (Shader *shader, scene->shaders)
142     shader->need_update = false;
143
144   need_update = false;
145
146   /* set texture system */
147   scene->image_manager->set_osl_texture_system((void *)ts);
148
149   /* add special builtin texture types */
150   og->textures.insert(ustring("@ao"), new OSLTextureHandle(OSLTextureHandle::AO));
151   og->textures.insert(ustring("@bevel"), new OSLTextureHandle(OSLTextureHandle::BEVEL));
152
153   device_update_common(device, dscene, scene, progress);
154
155   {
156     /* Perform greedyjit optimization.
157      *
158      * This might waste time on optimizing gorups which are never actually
159      * used, but this prevents OSL from allocating data on TLS at render
160      * time.
161      *
162      * This is much better for us because this way we aren't required to
163      * stop task scheduler threads to make sure all TLS is clean and don't
164      * have issues with TLS data free accessing freed memory if task scheduler
165      * is being freed after the Session is freed.
166      */
167     thread_scoped_lock lock(ss_shared_mutex);
168     ss->optimize_all_groups();
169   }
170 }
171
172 void OSLShaderManager::device_free(Device *device, DeviceScene *dscene, Scene *scene)
173 {
174   OSLGlobals *og = (OSLGlobals *)device->osl_memory();
175
176   device_free_common(device, dscene, scene);
177
178   /* clear shader engine */
179   og->use = false;
180   og->ss = NULL;
181   og->ts = NULL;
182
183   og->surface_state.clear();
184   og->volume_state.clear();
185   og->displacement_state.clear();
186   og->bump_state.clear();
187   og->background_state.reset();
188 }
189
190 void OSLShaderManager::texture_system_init()
191 {
192   /* create texture system, shared between different renders to reduce memory usage */
193   thread_scoped_lock lock(ts_shared_mutex);
194
195   if (ts_shared_users == 0) {
196     ts_shared = TextureSystem::create(true);
197
198     ts_shared->attribute("automip", 1);
199     ts_shared->attribute("autotile", 64);
200     ts_shared->attribute("gray_to_rgb", 1);
201
202     /* effectively unlimited for now, until we support proper mipmap lookups */
203     ts_shared->attribute("max_memory_MB", 16384);
204   }
205
206   ts = ts_shared;
207   ts_shared_users++;
208 }
209
210 void OSLShaderManager::texture_system_free()
211 {
212   /* shared texture system decrease users and destroy if no longer used */
213   thread_scoped_lock lock(ts_shared_mutex);
214   ts_shared_users--;
215
216   if (ts_shared_users == 0) {
217     ts_shared->invalidate_all(true);
218     OSL::TextureSystem::destroy(ts_shared);
219     ts_shared = NULL;
220   }
221
222   ts = NULL;
223 }
224
225 void OSLShaderManager::shading_system_init()
226 {
227   /* create shading system, shared between different renders to reduce memory usage */
228   thread_scoped_lock lock(ss_shared_mutex);
229
230   if (ss_shared_users == 0) {
231     services_shared = new OSLRenderServices();
232
233     string shader_path = path_get("shader");
234 #  ifdef _WIN32
235     /* Annoying thing, Cycles stores paths in UTF-8 codepage, so it can
236      * operate with file paths with any character. This requires to use wide
237      * char functions, but OSL uses old fashioned ANSI functions which means:
238      *
239      * - We have to convert our paths to ANSI before passing to OSL
240      * - OSL can't be used when there's a multi-byte character in the path
241      *   to the shaders folder.
242      */
243     shader_path = string_to_ansi(shader_path);
244 #  endif
245
246     ss_shared = new OSL::ShadingSystem(services_shared, ts_shared, &errhandler);
247     ss_shared->attribute("lockgeom", 1);
248     ss_shared->attribute("commonspace", "world");
249     ss_shared->attribute("searchpath:shader", shader_path);
250     ss_shared->attribute("greedyjit", 1);
251
252     VLOG(1) << "Using shader search path: " << shader_path;
253
254     /* our own ray types */
255     static const char *raytypes[] = {
256         "camera",      /* PATH_RAY_CAMERA */
257         "reflection",  /* PATH_RAY_REFLECT */
258         "refraction",  /* PATH_RAY_TRANSMIT */
259         "diffuse",     /* PATH_RAY_DIFFUSE */
260         "glossy",      /* PATH_RAY_GLOSSY */
261         "singular",    /* PATH_RAY_SINGULAR */
262         "transparent", /* PATH_RAY_TRANSPARENT */
263
264         "shadow", /* PATH_RAY_SHADOW_OPAQUE_NON_CATCHER */
265         "shadow", /* PATH_RAY_SHADOW_OPAQUE_CATCHER */
266         "shadow", /* PATH_RAY_SHADOW_TRANSPARENT_NON_CATCHER */
267         "shadow", /* PATH_RAY_SHADOW_TRANSPARENT_CATCHER */
268
269         "__unused__",  "volume_scatter", /* PATH_RAY_VOLUME_SCATTER */
270         "__unused__",
271
272         "__unused__",  "diffuse_ancestor", /* PATH_RAY_DIFFUSE_ANCESTOR */
273         "__unused__",  "__unused__",       "__unused__", "__unused__",
274         "__unused__",  "__unused__",       "__unused__",
275     };
276
277     const int nraytypes = sizeof(raytypes) / sizeof(raytypes[0]);
278     ss_shared->attribute("raytypes", TypeDesc(TypeDesc::STRING, nraytypes), raytypes);
279
280     OSLShader::register_closures((OSLShadingSystem *)ss_shared);
281
282     loaded_shaders.clear();
283   }
284
285   ss = ss_shared;
286   services = services_shared;
287   ss_shared_users++;
288 }
289
290 void OSLShaderManager::shading_system_free()
291 {
292   /* shared shading system decrease users and destroy if no longer used */
293   thread_scoped_lock lock(ss_shared_mutex);
294   ss_shared_users--;
295
296   if (ss_shared_users == 0) {
297     delete ss_shared;
298     ss_shared = NULL;
299
300     delete services_shared;
301     services_shared = NULL;
302   }
303
304   ss = NULL;
305   services = NULL;
306 }
307
308 bool OSLShaderManager::osl_compile(const string &inputfile, const string &outputfile)
309 {
310   vector<string> options;
311   string stdosl_path;
312   string shader_path = path_get("shader");
313
314   /* specify output file name */
315   options.push_back("-o");
316   options.push_back(outputfile);
317
318   /* specify standard include path */
319   string include_path_arg = string("-I") + shader_path;
320   options.push_back(include_path_arg);
321
322   stdosl_path = path_get("shader/stdosl.h");
323
324   /* compile */
325   OSL::OSLCompiler *compiler = new OSL::OSLCompiler(&OSL::ErrorHandler::default_handler());
326   bool ok = compiler->compile(string_view(inputfile), options, string_view(stdosl_path));
327   delete compiler;
328
329   return ok;
330 }
331
332 bool OSLShaderManager::osl_query(OSL::OSLQuery &query, const string &filepath)
333 {
334   string searchpath = path_user_get("shaders");
335   return query.open(filepath, searchpath);
336 }
337
338 static string shader_filepath_hash(const string &filepath, uint64_t modified_time)
339 {
340   /* compute a hash from filepath and modified time to detect changes */
341   MD5Hash md5;
342   md5.append((const uint8_t *)filepath.c_str(), filepath.size());
343   md5.append((const uint8_t *)&modified_time, sizeof(modified_time));
344
345   return md5.get_hex();
346 }
347
348 const char *OSLShaderManager::shader_test_loaded(const string &hash)
349 {
350   map<string, OSLShaderInfo>::iterator it = loaded_shaders.find(hash);
351   return (it == loaded_shaders.end()) ? NULL : it->first.c_str();
352 }
353
354 OSLShaderInfo *OSLShaderManager::shader_loaded_info(const string &hash)
355 {
356   map<string, OSLShaderInfo>::iterator it = loaded_shaders.find(hash);
357   return (it == loaded_shaders.end()) ? NULL : &it->second;
358 }
359
360 const char *OSLShaderManager::shader_load_filepath(string filepath)
361 {
362   size_t len = filepath.size();
363   string extension = filepath.substr(len - 4);
364   uint64_t modified_time = path_modified_time(filepath);
365
366   if (extension == ".osl") {
367     /* .OSL File */
368     string osopath = filepath.substr(0, len - 4) + ".oso";
369     uint64_t oso_modified_time = path_modified_time(osopath);
370
371     /* test if we have loaded the corresponding .OSO already */
372     if (oso_modified_time != 0) {
373       const char *hash = shader_test_loaded(shader_filepath_hash(osopath, oso_modified_time));
374
375       if (hash)
376         return hash;
377     }
378
379     /* autocompile .OSL to .OSO if needed */
380     if (oso_modified_time == 0 || (oso_modified_time < modified_time)) {
381       OSLShaderManager::osl_compile(filepath, osopath);
382       modified_time = path_modified_time(osopath);
383     }
384     else
385       modified_time = oso_modified_time;
386
387     filepath = osopath;
388   }
389   else {
390     if (extension == ".oso") {
391       /* .OSO File, nothing to do */
392     }
393     else if (path_dirname(filepath) == "") {
394       /* .OSO File in search path */
395       filepath = path_join(path_user_get("shaders"), filepath + ".oso");
396     }
397     else {
398       /* unknown file */
399       return NULL;
400     }
401
402     /* test if we have loaded this .OSO already */
403     const char *hash = shader_test_loaded(shader_filepath_hash(filepath, modified_time));
404
405     if (hash)
406       return hash;
407   }
408
409   /* read oso bytecode from file */
410   string bytecode_hash = shader_filepath_hash(filepath, modified_time);
411   string bytecode;
412
413   if (!path_read_text(filepath, bytecode)) {
414     fprintf(stderr, "Cycles shader graph: failed to read file %s\n", filepath.c_str());
415     OSLShaderInfo info;
416     loaded_shaders[bytecode_hash] = info; /* to avoid repeat tries */
417     return NULL;
418   }
419
420   return shader_load_bytecode(bytecode_hash, bytecode);
421 }
422
423 const char *OSLShaderManager::shader_load_bytecode(const string &hash, const string &bytecode)
424 {
425   ss->LoadMemoryCompiledShader(hash.c_str(), bytecode.c_str());
426
427   OSLShaderInfo info;
428
429   if (!info.query.open_bytecode(bytecode)) {
430     fprintf(stderr, "OSL query error: %s\n", info.query.geterror().c_str());
431   }
432
433   /* this is a bit weak, but works */
434   info.has_surface_emission = (bytecode.find("\"emission\"") != string::npos);
435   info.has_surface_transparent = (bytecode.find("\"transparent\"") != string::npos);
436   info.has_surface_bssrdf = (bytecode.find("\"bssrdf\"") != string::npos);
437
438   loaded_shaders[hash] = info;
439
440   return loaded_shaders.find(hash)->first.c_str();
441 }
442
443 OSLNode *OSLShaderManager::osl_node(const std::string &filepath,
444                                     const std::string &bytecode_hash,
445                                     const std::string &bytecode)
446 {
447   /* create query */
448   const char *hash;
449
450   if (!filepath.empty()) {
451     hash = shader_load_filepath(filepath);
452   }
453   else {
454     hash = shader_test_loaded(bytecode_hash);
455     if (!hash)
456       hash = shader_load_bytecode(bytecode_hash, bytecode);
457   }
458
459   if (!hash) {
460     return NULL;
461   }
462
463   OSLShaderInfo *info = shader_loaded_info(hash);
464
465   /* count number of inputs */
466   size_t num_inputs = 0;
467
468   for (int i = 0; i < info->query.nparams(); i++) {
469     const OSL::OSLQuery::Parameter *param = info->query.getparam(i);
470
471     /* skip unsupported types */
472     if (param->varlenarray || param->isstruct || param->type.arraylen > 1)
473       continue;
474
475     if (!param->isoutput)
476       num_inputs++;
477   }
478
479   /* create node */
480   OSLNode *node = OSLNode::create(num_inputs);
481
482   /* add new sockets from parameters */
483   set<void *> used_sockets;
484
485   for (int i = 0; i < info->query.nparams(); i++) {
486     const OSL::OSLQuery::Parameter *param = info->query.getparam(i);
487
488     /* skip unsupported types */
489     if (param->varlenarray || param->isstruct || param->type.arraylen > 1)
490       continue;
491
492     SocketType::Type socket_type;
493
494     if (param->isclosure) {
495       socket_type = SocketType::CLOSURE;
496     }
497     else if (param->type.vecsemantics != TypeDesc::NOSEMANTICS) {
498       if (param->type.vecsemantics == TypeDesc::COLOR)
499         socket_type = SocketType::COLOR;
500       else if (param->type.vecsemantics == TypeDesc::POINT)
501         socket_type = SocketType::POINT;
502       else if (param->type.vecsemantics == TypeDesc::VECTOR)
503         socket_type = SocketType::VECTOR;
504       else if (param->type.vecsemantics == TypeDesc::NORMAL)
505         socket_type = SocketType::NORMAL;
506       else
507         continue;
508
509       if (!param->isoutput && param->validdefault) {
510         float3 *default_value = (float3 *)node->input_default_value();
511         default_value->x = param->fdefault[0];
512         default_value->y = param->fdefault[1];
513         default_value->z = param->fdefault[2];
514       }
515     }
516     else if (param->type.aggregate == TypeDesc::SCALAR) {
517       if (param->type.basetype == TypeDesc::INT) {
518         socket_type = SocketType::INT;
519
520         if (!param->isoutput && param->validdefault) {
521           *(int *)node->input_default_value() = param->idefault[0];
522         }
523       }
524       else if (param->type.basetype == TypeDesc::FLOAT) {
525         socket_type = SocketType::FLOAT;
526
527         if (!param->isoutput && param->validdefault) {
528           *(float *)node->input_default_value() = param->fdefault[0];
529         }
530       }
531       else if (param->type.basetype == TypeDesc::STRING) {
532         socket_type = SocketType::STRING;
533
534         if (!param->isoutput && param->validdefault) {
535           *(ustring *)node->input_default_value() = param->sdefault[0];
536         }
537       }
538       else
539         continue;
540     }
541     else
542       continue;
543
544     if (param->isoutput) {
545       node->add_output(param->name, socket_type);
546     }
547     else {
548       node->add_input(param->name, socket_type);
549     }
550   }
551
552   /* set bytcode hash or filepath */
553   if (!bytecode_hash.empty()) {
554     node->bytecode_hash = bytecode_hash;
555   }
556   else {
557     node->filepath = filepath;
558   }
559
560   /* Generate inputs and outputs */
561   node->create_inputs_outputs(node->type);
562
563   return node;
564 }
565
566 /* Graph Compiler */
567
568 OSLCompiler::OSLCompiler(void *manager_,
569                          void *shadingsys_,
570                          OSLGlobals *osl_globals_,
571                          ImageManager *image_manager_,
572                          LightManager *light_manager_)
573 {
574   manager = manager_;
575   shadingsys = shadingsys_;
576   osl_globals = osl_globals_;
577   image_manager = image_manager_;
578   light_manager = light_manager_;
579   current_type = SHADER_TYPE_SURFACE;
580   current_shader = NULL;
581   background = false;
582 }
583
584 string OSLCompiler::id(ShaderNode *node)
585 {
586   /* assign layer unique name based on pointer address + bump mode */
587   stringstream stream;
588   stream << "node_" << node->type->name << "_" << node;
589
590   return stream.str();
591 }
592
593 string OSLCompiler::compatible_name(ShaderNode *node, ShaderInput *input)
594 {
595   string sname(input->name().string());
596   size_t i;
597
598   /* strip whitespace */
599   while ((i = sname.find(" ")) != string::npos)
600     sname.replace(i, 1, "");
601
602   /* if output exists with the same name, add "In" suffix */
603   foreach (ShaderOutput *output, node->outputs) {
604     if (input->name() == output->name()) {
605       sname += "In";
606       break;
607     }
608   }
609
610   return sname;
611 }
612
613 string OSLCompiler::compatible_name(ShaderNode *node, ShaderOutput *output)
614 {
615   string sname(output->name().string());
616   size_t i;
617
618   /* strip whitespace */
619   while ((i = sname.find(" ")) != string::npos)
620     sname.replace(i, 1, "");
621
622   /* if input exists with the same name, add "Out" suffix */
623   foreach (ShaderInput *input, node->inputs) {
624     if (input->name() == output->name()) {
625       sname += "Out";
626       break;
627     }
628   }
629
630   return sname;
631 }
632
633 bool OSLCompiler::node_skip_input(ShaderNode *node, ShaderInput *input)
634 {
635   /* exception for output node, only one input is actually used
636    * depending on the current shader type */
637
638   if (input->flags() & SocketType::SVM_INTERNAL)
639     return true;
640
641   if (node->special_type == SHADER_SPECIAL_TYPE_OUTPUT) {
642     if (input->name() == "Surface" && current_type != SHADER_TYPE_SURFACE)
643       return true;
644     if (input->name() == "Volume" && current_type != SHADER_TYPE_VOLUME)
645       return true;
646     if (input->name() == "Displacement" && current_type != SHADER_TYPE_DISPLACEMENT)
647       return true;
648     if (input->name() == "Normal" && current_type != SHADER_TYPE_BUMP)
649       return true;
650   }
651   else if (node->special_type == SHADER_SPECIAL_TYPE_BUMP) {
652     if (input->name() == "Height")
653       return true;
654   }
655   else if (current_type == SHADER_TYPE_DISPLACEMENT && input->link &&
656            input->link->parent->special_type == SHADER_SPECIAL_TYPE_BUMP)
657     return true;
658
659   return false;
660 }
661
662 void OSLCompiler::add(ShaderNode *node, const char *name, bool isfilepath)
663 {
664   OSL::ShadingSystem *ss = (OSL::ShadingSystem *)shadingsys;
665
666   /* load filepath */
667   if (isfilepath) {
668     name = ((OSLShaderManager *)manager)->shader_load_filepath(name);
669
670     if (name == NULL)
671       return;
672   }
673
674   /* pass in fixed parameter values */
675   foreach (ShaderInput *input, node->inputs) {
676     if (!input->link) {
677       /* checks to untangle graphs */
678       if (node_skip_input(node, input))
679         continue;
680       /* already has default value assigned */
681       else if (input->flags() & SocketType::DEFAULT_LINK_MASK)
682         continue;
683
684       string param_name = compatible_name(node, input);
685       const SocketType &socket = input->socket_type;
686       switch (input->type()) {
687         case SocketType::COLOR:
688           parameter_color(param_name.c_str(), node->get_float3(socket));
689           break;
690         case SocketType::POINT:
691           parameter_point(param_name.c_str(), node->get_float3(socket));
692           break;
693         case SocketType::VECTOR:
694           parameter_vector(param_name.c_str(), node->get_float3(socket));
695           break;
696         case SocketType::NORMAL:
697           parameter_normal(param_name.c_str(), node->get_float3(socket));
698           break;
699         case SocketType::FLOAT:
700           parameter(param_name.c_str(), node->get_float(socket));
701           break;
702         case SocketType::INT:
703           parameter(param_name.c_str(), node->get_int(socket));
704           break;
705         case SocketType::STRING:
706           parameter(param_name.c_str(), node->get_string(socket));
707           break;
708         case SocketType::CLOSURE:
709         case SocketType::UNDEFINED:
710         default:
711           break;
712       }
713     }
714   }
715
716   /* create shader of the appropriate type. OSL only distinguishes between "surface"
717    * and "displacement" atm */
718   if (current_type == SHADER_TYPE_SURFACE)
719     ss->Shader("surface", name, id(node).c_str());
720   else if (current_type == SHADER_TYPE_VOLUME)
721     ss->Shader("surface", name, id(node).c_str());
722   else if (current_type == SHADER_TYPE_DISPLACEMENT)
723     ss->Shader("displacement", name, id(node).c_str());
724   else if (current_type == SHADER_TYPE_BUMP)
725     ss->Shader("displacement", name, id(node).c_str());
726   else
727     assert(0);
728
729   /* link inputs to other nodes */
730   foreach (ShaderInput *input, node->inputs) {
731     if (input->link) {
732       if (node_skip_input(node, input))
733         continue;
734
735       /* connect shaders */
736       string id_from = id(input->link->parent);
737       string id_to = id(node);
738       string param_from = compatible_name(input->link->parent, input->link);
739       string param_to = compatible_name(node, input);
740
741       ss->ConnectShaders(id_from.c_str(), param_from.c_str(), id_to.c_str(), param_to.c_str());
742     }
743   }
744
745   /* test if we shader contains specific closures */
746   OSLShaderInfo *info = ((OSLShaderManager *)manager)->shader_loaded_info(name);
747
748   if (current_type == SHADER_TYPE_SURFACE) {
749     if (info) {
750       if (info->has_surface_emission)
751         current_shader->has_surface_emission = true;
752       if (info->has_surface_transparent)
753         current_shader->has_surface_transparent = true;
754       if (info->has_surface_bssrdf) {
755         current_shader->has_surface_bssrdf = true;
756         current_shader->has_bssrdf_bump = true; /* can't detect yet */
757       }
758       current_shader->has_bump = true; /* can't detect yet */
759     }
760
761     if (node->has_spatial_varying()) {
762       current_shader->has_surface_spatial_varying = true;
763     }
764   }
765   else if (current_type == SHADER_TYPE_VOLUME) {
766     if (node->has_spatial_varying())
767       current_shader->has_volume_spatial_varying = true;
768   }
769
770   if (node->has_object_dependency()) {
771     current_shader->has_object_dependency = true;
772   }
773
774   if (node->has_attribute_dependency()) {
775     current_shader->has_attribute_dependency = true;
776   }
777
778   if (node->has_integrator_dependency()) {
779     current_shader->has_integrator_dependency = true;
780   }
781 }
782
783 static TypeDesc array_typedesc(TypeDesc typedesc, int arraylength)
784 {
785   return TypeDesc((TypeDesc::BASETYPE)typedesc.basetype,
786                   (TypeDesc::AGGREGATE)typedesc.aggregate,
787                   (TypeDesc::VECSEMANTICS)typedesc.vecsemantics,
788                   arraylength);
789 }
790
791 void OSLCompiler::parameter(ShaderNode *node, const char *name)
792 {
793   OSL::ShadingSystem *ss = (OSL::ShadingSystem *)shadingsys;
794   ustring uname = ustring(name);
795   const SocketType &socket = *(node->type->find_input(uname));
796
797   switch (socket.type) {
798     case SocketType::BOOLEAN: {
799       int value = node->get_bool(socket);
800       ss->Parameter(name, TypeDesc::TypeInt, &value);
801       break;
802     }
803     case SocketType::FLOAT: {
804       float value = node->get_float(socket);
805       ss->Parameter(uname, TypeDesc::TypeFloat, &value);
806       break;
807     }
808     case SocketType::INT: {
809       int value = node->get_int(socket);
810       ss->Parameter(uname, TypeDesc::TypeInt, &value);
811       break;
812     }
813     case SocketType::COLOR: {
814       float3 value = node->get_float3(socket);
815       ss->Parameter(uname, TypeDesc::TypeColor, &value);
816       break;
817     }
818     case SocketType::VECTOR: {
819       float3 value = node->get_float3(socket);
820       ss->Parameter(uname, TypeDesc::TypeVector, &value);
821       break;
822     }
823     case SocketType::POINT: {
824       float3 value = node->get_float3(socket);
825       ss->Parameter(uname, TypeDesc::TypePoint, &value);
826       break;
827     }
828     case SocketType::NORMAL: {
829       float3 value = node->get_float3(socket);
830       ss->Parameter(uname, TypeDesc::TypeNormal, &value);
831       break;
832     }
833     case SocketType::POINT2: {
834       float2 value = node->get_float2(socket);
835       ss->Parameter(uname, TypeDesc(TypeDesc::FLOAT, TypeDesc::VEC2, TypeDesc::POINT), &value);
836       break;
837     }
838     case SocketType::STRING: {
839       ustring value = node->get_string(socket);
840       ss->Parameter(uname, TypeDesc::TypeString, &value);
841       break;
842     }
843     case SocketType::ENUM: {
844       ustring value = node->get_string(socket);
845       ss->Parameter(uname, TypeDesc::TypeString, &value);
846       break;
847     }
848     case SocketType::TRANSFORM: {
849       Transform value = node->get_transform(socket);
850       ProjectionTransform projection(value);
851       projection = projection_transpose(projection);
852       ss->Parameter(uname, TypeDesc::TypeMatrix, &projection);
853       break;
854     }
855     case SocketType::BOOLEAN_ARRAY: {
856       // OSL does not support booleans, so convert to int
857       const array<bool> &value = node->get_bool_array(socket);
858       array<int> intvalue(value.size());
859       for (size_t i = 0; i < value.size(); i++)
860         intvalue[i] = value[i];
861       ss->Parameter(uname, array_typedesc(TypeDesc::TypeInt, value.size()), intvalue.data());
862       break;
863     }
864     case SocketType::FLOAT_ARRAY: {
865       const array<float> &value = node->get_float_array(socket);
866       ss->Parameter(uname, array_typedesc(TypeDesc::TypeFloat, value.size()), value.data());
867       break;
868     }
869     case SocketType::INT_ARRAY: {
870       const array<int> &value = node->get_int_array(socket);
871       ss->Parameter(uname, array_typedesc(TypeDesc::TypeInt, value.size()), value.data());
872       break;
873     }
874     case SocketType::COLOR_ARRAY:
875     case SocketType::VECTOR_ARRAY:
876     case SocketType::POINT_ARRAY:
877     case SocketType::NORMAL_ARRAY: {
878       TypeDesc typedesc;
879
880       switch (socket.type) {
881         case SocketType::COLOR_ARRAY:
882           typedesc = TypeDesc::TypeColor;
883           break;
884         case SocketType::VECTOR_ARRAY:
885           typedesc = TypeDesc::TypeVector;
886           break;
887         case SocketType::POINT_ARRAY:
888           typedesc = TypeDesc::TypePoint;
889           break;
890         case SocketType::NORMAL_ARRAY:
891           typedesc = TypeDesc::TypeNormal;
892           break;
893         default:
894           assert(0);
895           break;
896       }
897
898       // convert to tightly packed array since float3 has padding
899       const array<float3> &value = node->get_float3_array(socket);
900       array<float> fvalue(value.size() * 3);
901       for (size_t i = 0, j = 0; i < value.size(); i++) {
902         fvalue[j++] = value[i].x;
903         fvalue[j++] = value[i].y;
904         fvalue[j++] = value[i].z;
905       }
906
907       ss->Parameter(uname, array_typedesc(typedesc, value.size()), fvalue.data());
908       break;
909     }
910     case SocketType::POINT2_ARRAY: {
911       const array<float2> &value = node->get_float2_array(socket);
912       ss->Parameter(
913           uname,
914           array_typedesc(TypeDesc(TypeDesc::FLOAT, TypeDesc::VEC2, TypeDesc::POINT), value.size()),
915           value.data());
916       break;
917     }
918     case SocketType::STRING_ARRAY: {
919       const array<ustring> &value = node->get_string_array(socket);
920       ss->Parameter(uname, array_typedesc(TypeDesc::TypeString, value.size()), value.data());
921       break;
922     }
923     case SocketType::TRANSFORM_ARRAY: {
924       const array<Transform> &value = node->get_transform_array(socket);
925       array<ProjectionTransform> fvalue(value.size());
926       for (size_t i = 0; i < value.size(); i++) {
927         fvalue[i] = projection_transpose(ProjectionTransform(value[i]));
928       }
929       ss->Parameter(uname, array_typedesc(TypeDesc::TypeMatrix, fvalue.size()), fvalue.data());
930       break;
931     }
932     case SocketType::CLOSURE:
933     case SocketType::NODE:
934     case SocketType::NODE_ARRAY:
935     case SocketType::UNDEFINED:
936     case SocketType::UINT: {
937       assert(0);
938       break;
939     }
940   }
941 }
942
943 void OSLCompiler::parameter(const char *name, float f)
944 {
945   OSL::ShadingSystem *ss = (OSL::ShadingSystem *)shadingsys;
946   ss->Parameter(name, TypeDesc::TypeFloat, &f);
947 }
948
949 void OSLCompiler::parameter_color(const char *name, float3 f)
950 {
951   OSL::ShadingSystem *ss = (OSL::ShadingSystem *)shadingsys;
952   ss->Parameter(name, TypeDesc::TypeColor, &f);
953 }
954
955 void OSLCompiler::parameter_point(const char *name, float3 f)
956 {
957   OSL::ShadingSystem *ss = (OSL::ShadingSystem *)shadingsys;
958   ss->Parameter(name, TypeDesc::TypePoint, &f);
959 }
960
961 void OSLCompiler::parameter_normal(const char *name, float3 f)
962 {
963   OSL::ShadingSystem *ss = (OSL::ShadingSystem *)shadingsys;
964   ss->Parameter(name, TypeDesc::TypeNormal, &f);
965 }
966
967 void OSLCompiler::parameter_vector(const char *name, float3 f)
968 {
969   OSL::ShadingSystem *ss = (OSL::ShadingSystem *)shadingsys;
970   ss->Parameter(name, TypeDesc::TypeVector, &f);
971 }
972
973 void OSLCompiler::parameter(const char *name, int f)
974 {
975   OSL::ShadingSystem *ss = (OSL::ShadingSystem *)shadingsys;
976   ss->Parameter(name, TypeDesc::TypeInt, &f);
977 }
978
979 void OSLCompiler::parameter(const char *name, const char *s)
980 {
981   OSL::ShadingSystem *ss = (OSL::ShadingSystem *)shadingsys;
982   ss->Parameter(name, TypeDesc::TypeString, &s);
983 }
984
985 void OSLCompiler::parameter(const char *name, ustring s)
986 {
987   OSL::ShadingSystem *ss = (OSL::ShadingSystem *)shadingsys;
988   const char *str = s.c_str();
989   ss->Parameter(name, TypeDesc::TypeString, &str);
990 }
991
992 void OSLCompiler::parameter(const char *name, const Transform &tfm)
993 {
994   OSL::ShadingSystem *ss = (OSL::ShadingSystem *)shadingsys;
995   ProjectionTransform projection(tfm);
996   projection = projection_transpose(projection);
997   ss->Parameter(name, TypeDesc::TypeMatrix, (float *)&projection);
998 }
999
1000 void OSLCompiler::parameter_array(const char *name, const float f[], int arraylen)
1001 {
1002   OSL::ShadingSystem *ss = (OSL::ShadingSystem *)shadingsys;
1003   TypeDesc type = TypeDesc::TypeFloat;
1004   type.arraylen = arraylen;
1005   ss->Parameter(name, type, f);
1006 }
1007
1008 void OSLCompiler::parameter_color_array(const char *name, const array<float3> &f)
1009 {
1010   /* NB: cycles float3 type is actually 4 floats! need to use an explicit array */
1011   array<float[3]> table(f.size());
1012
1013   for (int i = 0; i < f.size(); ++i) {
1014     table[i][0] = f[i].x;
1015     table[i][1] = f[i].y;
1016     table[i][2] = f[i].z;
1017   }
1018
1019   OSL::ShadingSystem *ss = (OSL::ShadingSystem *)shadingsys;
1020   TypeDesc type = TypeDesc::TypeColor;
1021   type.arraylen = table.size();
1022   ss->Parameter(name, type, table.data());
1023 }
1024
1025 void OSLCompiler::parameter_attribute(const char *name, ustring s)
1026 {
1027   if (Attribute::name_standard(s.c_str()))
1028     parameter(name, (string("geom:") + s.c_str()).c_str());
1029   else
1030     parameter(name, s.c_str());
1031 }
1032
1033 void OSLCompiler::find_dependencies(ShaderNodeSet &dependencies, ShaderInput *input)
1034 {
1035   ShaderNode *node = (input->link) ? input->link->parent : NULL;
1036
1037   if (node != NULL && dependencies.find(node) == dependencies.end()) {
1038     foreach (ShaderInput *in, node->inputs)
1039       if (!node_skip_input(node, in))
1040         find_dependencies(dependencies, in);
1041
1042     dependencies.insert(node);
1043   }
1044 }
1045
1046 void OSLCompiler::generate_nodes(const ShaderNodeSet &nodes)
1047 {
1048   ShaderNodeSet done;
1049   bool nodes_done;
1050
1051   do {
1052     nodes_done = true;
1053
1054     foreach (ShaderNode *node, nodes) {
1055       if (done.find(node) == done.end()) {
1056         bool inputs_done = true;
1057
1058         foreach (ShaderInput *input, node->inputs)
1059           if (!node_skip_input(node, input))
1060             if (input->link && done.find(input->link->parent) == done.end())
1061               inputs_done = false;
1062
1063         if (inputs_done) {
1064           node->compile(*this);
1065           done.insert(node);
1066
1067           if (current_type == SHADER_TYPE_SURFACE) {
1068             if (node->has_surface_emission())
1069               current_shader->has_surface_emission = true;
1070             if (node->has_surface_transparent())
1071               current_shader->has_surface_transparent = true;
1072             if (node->has_spatial_varying())
1073               current_shader->has_surface_spatial_varying = true;
1074             if (node->has_surface_bssrdf()) {
1075               current_shader->has_surface_bssrdf = true;
1076               if (node->has_bssrdf_bump())
1077                 current_shader->has_bssrdf_bump = true;
1078             }
1079             if (node->has_bump()) {
1080               current_shader->has_bump = true;
1081             }
1082           }
1083           else if (current_type == SHADER_TYPE_VOLUME) {
1084             if (node->has_spatial_varying())
1085               current_shader->has_volume_spatial_varying = true;
1086           }
1087         }
1088         else
1089           nodes_done = false;
1090       }
1091     }
1092   } while (!nodes_done);
1093 }
1094
1095 OSL::ShaderGroupRef OSLCompiler::compile_type(Shader *shader, ShaderGraph *graph, ShaderType type)
1096 {
1097   OSL::ShadingSystem *ss = (OSL::ShadingSystem *)shadingsys;
1098
1099   current_type = type;
1100
1101   OSL::ShaderGroupRef group = ss->ShaderGroupBegin(shader->name.c_str());
1102
1103   ShaderNode *output = graph->output();
1104   ShaderNodeSet dependencies;
1105
1106   if (type == SHADER_TYPE_SURFACE) {
1107     /* generate surface shader */
1108     find_dependencies(dependencies, output->input("Surface"));
1109     generate_nodes(dependencies);
1110     output->compile(*this);
1111   }
1112   else if (type == SHADER_TYPE_BUMP) {
1113     /* generate bump shader */
1114     find_dependencies(dependencies, output->input("Normal"));
1115     generate_nodes(dependencies);
1116     output->compile(*this);
1117   }
1118   else if (type == SHADER_TYPE_VOLUME) {
1119     /* generate volume shader */
1120     find_dependencies(dependencies, output->input("Volume"));
1121     generate_nodes(dependencies);
1122     output->compile(*this);
1123   }
1124   else if (type == SHADER_TYPE_DISPLACEMENT) {
1125     /* generate displacement shader */
1126     find_dependencies(dependencies, output->input("Displacement"));
1127     generate_nodes(dependencies);
1128     output->compile(*this);
1129   }
1130   else
1131     assert(0);
1132
1133   ss->ShaderGroupEnd();
1134
1135   return group;
1136 }
1137
1138 void OSLCompiler::compile(Scene *scene, Shader *shader)
1139 {
1140   if (shader->need_update) {
1141     ShaderGraph *graph = shader->graph;
1142     ShaderNode *output = (graph) ? graph->output() : NULL;
1143
1144     bool has_bump = (shader->displacement_method != DISPLACE_TRUE) &&
1145                     output->input("Surface")->link && output->input("Displacement")->link;
1146
1147     /* finalize */
1148     shader->graph->finalize(scene,
1149                             has_bump,
1150                             shader->has_integrator_dependency,
1151                             shader->displacement_method == DISPLACE_BOTH);
1152
1153     current_shader = shader;
1154
1155     shader->has_surface = false;
1156     shader->has_surface_emission = false;
1157     shader->has_surface_transparent = false;
1158     shader->has_surface_bssrdf = false;
1159     shader->has_bump = has_bump;
1160     shader->has_bssrdf_bump = has_bump;
1161     shader->has_volume = false;
1162     shader->has_displacement = false;
1163     shader->has_surface_spatial_varying = false;
1164     shader->has_volume_spatial_varying = false;
1165     shader->has_object_dependency = false;
1166     shader->has_attribute_dependency = false;
1167     shader->has_integrator_dependency = false;
1168
1169     /* generate surface shader */
1170     if (shader->used && graph && output->input("Surface")->link) {
1171       shader->osl_surface_ref = compile_type(shader, shader->graph, SHADER_TYPE_SURFACE);
1172
1173       if (has_bump)
1174         shader->osl_surface_bump_ref = compile_type(shader, shader->graph, SHADER_TYPE_BUMP);
1175       else
1176         shader->osl_surface_bump_ref = OSL::ShaderGroupRef();
1177
1178       shader->has_surface = true;
1179     }
1180     else {
1181       shader->osl_surface_ref = OSL::ShaderGroupRef();
1182       shader->osl_surface_bump_ref = OSL::ShaderGroupRef();
1183     }
1184
1185     /* generate volume shader */
1186     if (shader->used && graph && output->input("Volume")->link) {
1187       shader->osl_volume_ref = compile_type(shader, shader->graph, SHADER_TYPE_VOLUME);
1188       shader->has_volume = true;
1189     }
1190     else
1191       shader->osl_volume_ref = OSL::ShaderGroupRef();
1192
1193     /* generate displacement shader */
1194     if (shader->used && graph && output->input("Displacement")->link) {
1195       shader->osl_displacement_ref = compile_type(shader, shader->graph, SHADER_TYPE_DISPLACEMENT);
1196       shader->has_displacement = true;
1197     }
1198     else
1199       shader->osl_displacement_ref = OSL::ShaderGroupRef();
1200   }
1201
1202   /* push state to array for lookup */
1203   osl_globals->surface_state.push_back(shader->osl_surface_ref);
1204   osl_globals->volume_state.push_back(shader->osl_volume_ref);
1205   osl_globals->displacement_state.push_back(shader->osl_displacement_ref);
1206   osl_globals->bump_state.push_back(shader->osl_surface_bump_ref);
1207 }
1208
1209 void OSLCompiler::parameter_texture(const char *name, ustring filename, ustring colorspace)
1210 {
1211   /* Textured loaded through the OpenImageIO texture cache. For this
1212    * case we need to do runtime color space conversion. */
1213   OSLTextureHandle *handle = new OSLTextureHandle(OSLTextureHandle::OIIO);
1214   handle->processor = ColorSpaceManager::get_processor(colorspace);
1215   osl_globals->textures.insert(filename, handle);
1216   parameter(name, filename);
1217 }
1218
1219 void OSLCompiler::parameter_texture(const char *name, int svm_slot)
1220 {
1221   /* Texture loaded through SVM image texture system. We generate a unique
1222    * name, which ends up being used in OSLRenderServices::get_texture_handle
1223    * to get handle again. */
1224   ustring filename(string_printf("@i%d", svm_slot).c_str());
1225   osl_globals->textures.insert(filename, new OSLTextureHandle(OSLTextureHandle::SVM, svm_slot));
1226   parameter(name, filename);
1227 }
1228
1229 void OSLCompiler::parameter_texture_ies(const char *name, int svm_slot)
1230 {
1231   /* IES light textures stored in SVM. */
1232   ustring filename(string_printf("@l%d", svm_slot).c_str());
1233   osl_globals->textures.insert(filename, new OSLTextureHandle(OSLTextureHandle::IES, svm_slot));
1234   parameter(name, filename);
1235 }
1236
1237 #else
1238
1239 void OSLCompiler::add(ShaderNode * /*node*/, const char * /*name*/, bool /*isfilepath*/)
1240 {
1241 }
1242
1243 void OSLCompiler::parameter(ShaderNode * /*node*/, const char * /*name*/)
1244 {
1245 }
1246
1247 void OSLCompiler::parameter(const char * /*name*/, float /*f*/)
1248 {
1249 }
1250
1251 void OSLCompiler::parameter_color(const char * /*name*/, float3 /*f*/)
1252 {
1253 }
1254
1255 void OSLCompiler::parameter_vector(const char * /*name*/, float3 /*f*/)
1256 {
1257 }
1258
1259 void OSLCompiler::parameter_point(const char * /*name*/, float3 /*f*/)
1260 {
1261 }
1262
1263 void OSLCompiler::parameter_normal(const char * /*name*/, float3 /*f*/)
1264 {
1265 }
1266
1267 void OSLCompiler::parameter(const char * /*name*/, int /*f*/)
1268 {
1269 }
1270
1271 void OSLCompiler::parameter(const char * /*name*/, const char * /*s*/)
1272 {
1273 }
1274
1275 void OSLCompiler::parameter(const char * /*name*/, ustring /*s*/)
1276 {
1277 }
1278
1279 void OSLCompiler::parameter(const char * /*name*/, const Transform & /*tfm*/)
1280 {
1281 }
1282
1283 void OSLCompiler::parameter_array(const char * /*name*/, const float /*f*/[], int /*arraylen*/)
1284 {
1285 }
1286
1287 void OSLCompiler::parameter_color_array(const char * /*name*/, const array<float3> & /*f*/)
1288 {
1289 }
1290
1291 void OSLCompiler::parameter_texture(const char * /* name */,
1292                                     ustring /* filename */,
1293                                     ustring /* colorspace */)
1294 {
1295 }
1296
1297 void OSLCompiler::parameter_texture(const char * /* name */, int /* svm_slot */)
1298 {
1299 }
1300
1301 void OSLCompiler::parameter_texture_ies(const char * /* name */, int /* svm_slot */)
1302 {
1303 }
1304
1305 #endif /* WITH_OSL */
1306
1307 CCL_NAMESPACE_END