Incompatible usage of the Collada transparency value
[blender.git] / source / blender / collada / Materials.cpp
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 #include "Materials.h"
18
19 MaterialNode::MaterialNode(bContext *C, Material *ma, KeyImageMap &key_image_map)
20     : mContext(C), material(ma), effect(nullptr), key_image_map(&key_image_map)
21 {
22   bNodeTree *new_ntree = prepare_material_nodetree();
23   setShaderType();
24   if (new_ntree) {
25     shader_node = add_node(SH_NODE_BSDF_PRINCIPLED, 0, 300, "");
26     output_node = add_node(SH_NODE_OUTPUT_MATERIAL, 300, 300, "");
27     add_link(shader_node, 0, output_node, 0);
28   }
29 }
30
31 MaterialNode::MaterialNode(bContext *C,
32                            COLLADAFW::EffectCommon *ef,
33                            Material *ma,
34                            UidImageMap &uid_image_map)
35     : mContext(C), material(ma), effect(ef), uid_image_map(&uid_image_map)
36 {
37   prepare_material_nodetree();
38   setShaderType();
39
40   std::map<std::string, bNode *> nmap;
41 #if 0
42   nmap["main"] = add_node(C, ntree, SH_NODE_BSDF_PRINCIPLED, -300, 300);
43   nmap["emission"] = add_node(C, ntree, SH_NODE_EMISSION, -300, 500, "emission");
44   nmap["add"] = add_node(C, ntree, SH_NODE_ADD_SHADER, 100, 400);
45   nmap["transparent"] = add_node(C, ntree, SH_NODE_BSDF_TRANSPARENT, 100, 200);
46   nmap["mix"] = add_node(C, ntree, SH_NODE_MIX_SHADER, 400, 300, "transparency");
47   nmap["out"] = add_node(C, ntree, SH_NODE_OUTPUT_MATERIAL, 600, 300);
48   nmap["out"]->flag &= ~NODE_SELECT;
49
50   add_link(ntree, nmap["emission"], 0, nmap["add"], 0);
51   add_link(ntree, nmap["main"], 0, nmap["add"], 1);
52   add_link(ntree, nmap["add"], 0, nmap["mix"], 1);
53   add_link(ntree, nmap["transparent"], 0, nmap["mix"], 2);
54
55   add_link(ntree, nmap["mix"], 0, nmap["out"], 0);
56   // experimental, probably not used.
57   make_group(C, ntree, nmap);
58 #else
59   shader_node = add_node(SH_NODE_BSDF_PRINCIPLED, 0, 300, "");
60   output_node = add_node(SH_NODE_OUTPUT_MATERIAL, 300, 300, "");
61   add_link(shader_node, 0, output_node, 0);
62 #endif
63 }
64
65 void MaterialNode::setShaderType()
66 {
67 #if 0
68   COLLADAFW::EffectCommon::ShaderType shader = ef->getShaderType();
69   // Currently we only support PBR based shaders
70   // TODO: simulate the effects with PBR
71
72   // blinn
73   if (shader == COLLADAFW::EffectCommon::SHADER_BLINN) {
74     ma->spec_shader = MA_SPEC_BLINN;
75     ma->spec = ef->getShininess().getFloatValue();
76   }
77   // phong
78   else if (shader == COLLADAFW::EffectCommon::SHADER_PHONG) {
79     ma->spec_shader = MA_SPEC_PHONG;
80     ma->har = ef->getShininess().getFloatValue();
81   }
82   // lambert
83   else if (shader == COLLADAFW::EffectCommon::SHADER_LAMBERT) {
84     ma->diff_shader = MA_DIFF_LAMBERT;
85   }
86   // default - lambert
87   else {
88     ma->diff_shader = MA_DIFF_LAMBERT;
89     fprintf(stderr, "Current shader type is not supported, default to lambert.\n");
90   }
91 #endif
92 }
93
94 // returns null if material already has a node tree
95 bNodeTree *MaterialNode::prepare_material_nodetree()
96 {
97   if (material->nodetree) {
98     ntree = material->nodetree;
99     return NULL;
100   }
101
102   material->nodetree = ntreeAddTree(NULL, "Shader Nodetree", "ShaderNodeTree");
103   material->use_nodes = true;
104   ntree = material->nodetree;
105   return ntree;
106 }
107
108 bNode *MaterialNode::add_node(int node_type, int locx, int locy, std::string label)
109 {
110   bNode *node = nodeAddStaticNode(mContext, ntree, node_type);
111   if (node) {
112     if (label.length() > 0) {
113       strcpy(node->label, label.c_str());
114     }
115     node->locx = locx;
116     node->locy = locy;
117     node->flag |= NODE_SELECT;
118   }
119   node_map[label] = node;
120   return node;
121 }
122
123 void MaterialNode::add_link(bNode *from_node, int from_index, bNode *to_node, int to_index)
124 {
125   bNodeSocket *from_socket = (bNodeSocket *)BLI_findlink(&from_node->outputs, from_index);
126   bNodeSocket *to_socket = (bNodeSocket *)BLI_findlink(&to_node->inputs, to_index);
127
128   nodeAddLink(ntree, from_node, from_socket, to_node, to_socket);
129 }
130
131 void MaterialNode::set_reflectivity(COLLADAFW::FloatOrParam &val)
132 {
133   float reflectivity = val.getFloatValue();
134   if (reflectivity >= 0) {
135     bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Metallic");
136     ((bNodeSocketValueFloat *)socket->default_value)->value = reflectivity;
137     material->metallic = reflectivity;
138   }
139 }
140
141 #if 0
142 // needs rework to be done for 2.81
143 void MaterialNode::set_shininess(COLLADAFW::FloatOrParam &val)
144 {
145   float roughness = val.getFloatValue();
146   if (roughness >= 0) {
147     bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Roughness");
148     ((bNodeSocketValueFloat *)socket->default_value)->value = roughness;
149   }
150 }
151 #endif
152
153 void MaterialNode::set_ior(COLLADAFW::FloatOrParam &val)
154 {
155   float ior = val.getFloatValue();
156   if (ior < 0) {
157     fprintf(stderr,
158             "IOR of negative value is not allowed for materials (using Blender default value "
159             "instead)");
160     return;
161   }
162
163   bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "IOR");
164   ((bNodeSocketValueFloat *)socket->default_value)->value = ior;
165 }
166
167 void MaterialNode::set_alpha(COLLADAFW::EffectCommon::OpaqueMode mode,
168                              COLLADAFW::ColorOrTexture &cot,
169                              COLLADAFW::FloatOrParam &val)
170 {
171   /*  Handling the alpha value according to the Collada 1.4 reference guide
172    *  see page 7-5 Determining Transparency (Opacity)
173    */
174
175   if (effect == nullptr) {
176     return;
177   }
178
179   if (cot.isColor() || !cot.isValid()) {
180     // transparent_cot is either a color or not defined
181
182     float transparent_alpha;
183     if (cot.isValid()) {
184       COLLADAFW::Color col = cot.getColor();
185       transparent_alpha = col.getAlpha();
186     }
187     else {
188       // no transparent color defined
189       transparent_alpha = 1;
190     }
191
192     float transparency_alpha = val.getFloatValue();
193     if (transparency_alpha < 0) {
194       // transparency is not defined
195       transparency_alpha = 1;  // set to opaque
196     }
197
198     float alpha = transparent_alpha * transparency_alpha;
199     if (mode == COLLADASW::EffectProfile::RGB_ZERO) {
200       alpha = 1 - alpha;
201     }
202
203     bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Alpha");
204     ((bNodeSocketValueFloat *)socket->default_value)->value = alpha;
205   }
206   else if (cot.isTexture()) {
207     int locy = -300 * (node_map.size() - 2);
208     add_texture_node(cot, -300, locy, "Alpha");
209   }
210 }
211
212 void MaterialNode::set_diffuse(COLLADAFW::ColorOrTexture &cot)
213 {
214   int locy = -300 * (node_map.size() - 2);
215   if (cot.isColor()) {
216     COLLADAFW::Color col = cot.getColor();
217     bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Base Color");
218     float *fcol = (float *)socket->default_value;
219
220     fcol[0] = material->r = col.getRed();
221     fcol[1] = material->g = col.getGreen();
222     fcol[2] = material->b = col.getBlue();
223     fcol[3] = material->a = col.getAlpha();
224   }
225   else if (cot.isTexture()) {
226     bNode *texture_node = add_texture_node(cot, -300, locy, "Base Color");
227     if (texture_node != NULL) {
228       add_link(texture_node, 0, shader_node, 0);
229     }
230   }
231 }
232
233 Image *MaterialNode::get_diffuse_image()
234 {
235   bNode *shader = ntreeFindType(ntree, SH_NODE_BSDF_PRINCIPLED);
236   if (shader == nullptr) {
237     return nullptr;
238   }
239
240   bNodeSocket *in_socket = nodeFindSocket(shader, SOCK_IN, "Base Color");
241   if (in_socket == nullptr) {
242     return nullptr;
243   }
244
245   bNodeLink *link = in_socket->link;
246   if (link == nullptr) {
247     return nullptr;
248   }
249
250   bNode *texture = link->fromnode;
251   if (texture == nullptr) {
252     return nullptr;
253   }
254
255   if (texture->type != SH_NODE_TEX_IMAGE) {
256     return nullptr;
257   }
258
259   Image *image = (Image *)texture->id;
260   return image;
261 }
262
263 static bNodeSocket *set_color(bNode *node, COLLADAFW::Color col)
264 {
265   bNodeSocket *socket = (bNodeSocket *)BLI_findlink(&node->outputs, 0);
266   float *fcol = (float *)socket->default_value;
267   fcol[0] = col.getRed();
268   fcol[1] = col.getGreen();
269   fcol[2] = col.getBlue();
270
271   return socket;
272 }
273
274 void MaterialNode::set_ambient(COLLADAFW::ColorOrTexture &cot)
275 {
276   int locy = -300 * (node_map.size() - 2);
277   if (cot.isColor()) {
278     COLLADAFW::Color col = cot.getColor();
279     bNode *node = add_node(SH_NODE_RGB, -300, locy, "Ambient");
280     set_color(node, col);
281     // TODO: Connect node
282   }
283   // texture
284   else if (cot.isTexture()) {
285     add_texture_node(cot, -300, locy, "Ambient");
286     // TODO: Connect node
287   }
288 }
289
290 void MaterialNode::set_reflective(COLLADAFW::ColorOrTexture &cot)
291 {
292   int locy = -300 * (node_map.size() - 2);
293   if (cot.isColor()) {
294     COLLADAFW::Color col = cot.getColor();
295     bNode *node = add_node(SH_NODE_RGB, -300, locy, "Reflective");
296     set_color(node, col);
297     // TODO: Connect node
298   }
299   // texture
300   else if (cot.isTexture()) {
301     add_texture_node(cot, -300, locy, "Reflective");
302     // TODO: Connect node
303   }
304 }
305
306 void MaterialNode::set_emission(COLLADAFW::ColorOrTexture &cot)
307 {
308   int locy = -300 * (node_map.size() - 2);
309   if (cot.isColor()) {
310     COLLADAFW::Color col = cot.getColor();
311     bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Emission");
312     float *fcol = (float *)socket->default_value;
313
314     fcol[0] = col.getRed();
315     fcol[1] = col.getGreen();
316     fcol[2] = col.getBlue();
317     fcol[3] = col.getAlpha();
318   }
319   else if (cot.isTexture()) {
320     bNode *texture_node = add_texture_node(cot, -300, locy, "Emission");
321     if (texture_node != NULL) {
322       add_link(texture_node, 0, shader_node, 0);
323     }
324   }
325 }
326
327 void MaterialNode::set_opacity(COLLADAFW::ColorOrTexture &cot)
328 {
329   if (effect == nullptr) {
330     return;
331   }
332
333   int locy = -300 * (node_map.size() - 2);
334   if (cot.isColor()) {
335     COLLADAFW::Color col = effect->getTransparent().getColor();
336     float alpha = effect->getTransparency().getFloatValue();
337
338     if (col.isValid()) {
339       alpha *= col.getAlpha();  // Assuming A_ONE opaque mode
340     }
341
342     bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Alpha");
343     ((bNodeSocketValueFloat *)socket->default_value)->value = alpha;
344   }
345   // texture
346   else if (cot.isTexture()) {
347     add_texture_node(cot, -300, locy, "Alpha");
348     // TODO: Connect node
349   }
350 }
351
352 void MaterialNode::set_specular(COLLADAFW::ColorOrTexture &cot)
353 {
354   int locy = -300 * (node_map.size() - 2);
355   if (cot.isColor()) {
356     COLLADAFW::Color col = cot.getColor();
357     bNode *node = add_node(SH_NODE_RGB, -300, locy, "Specular");
358     set_color(node, col);
359     // TODO: Connect node
360   }
361   // texture
362   else if (cot.isTexture()) {
363     add_texture_node(cot, -300, locy, "Specular");
364     // TODO: Connect node
365   }
366 }
367
368 bNode *MaterialNode::add_texture_node(COLLADAFW::ColorOrTexture &cot,
369                                       int locx,
370                                       int locy,
371                                       std::string label)
372 {
373   if (effect == nullptr) {
374     return nullptr;
375   }
376
377   UidImageMap &image_map = *uid_image_map;
378
379   COLLADAFW::Texture ctex = cot.getTexture();
380
381   COLLADAFW::SamplerPointerArray &samp_array = effect->getSamplerPointerArray();
382   COLLADAFW::Sampler *sampler = samp_array[ctex.getSamplerId()];
383
384   const COLLADAFW::UniqueId &ima_uid = sampler->getSourceImage();
385
386   if (image_map.find(ima_uid) == image_map.end()) {
387     fprintf(stderr, "Couldn't find an image by UID.\n");
388     return NULL;
389   }
390
391   Image *ima = image_map[ima_uid];
392   bNode *texture_node = add_node(SH_NODE_TEX_IMAGE, locx, locy, label);
393   texture_node->id = &ima->id;
394   return texture_node;
395 }