d8a0f06c12b893b4ccabcc350d95310bd0d68340
[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   if (effect == nullptr) {
172     return;
173   }
174
175   if (cot.isColor() || !cot.isValid()) {
176     COLLADAFW::Color col = (cot.isValid()) ? cot.getColor() : COLLADAFW::Color(1, 1, 1, 1);
177     float alpha = val.getFloatValue() * col.getAlpha();  // Assuming A_ONE opaque mode
178
179     bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Alpha");
180     ((bNodeSocketValueFloat *)socket->default_value)->value = alpha;
181   }
182   else if (cot.isTexture()) {
183     int locy = -300 * (node_map.size() - 2);
184     add_texture_node(cot, -300, locy, "Alpha");
185     // TODO: Connect node
186   }
187 }
188
189 void MaterialNode::set_diffuse(COLLADAFW::ColorOrTexture &cot)
190 {
191   int locy = -300 * (node_map.size() - 2);
192   if (cot.isColor()) {
193     COLLADAFW::Color col = cot.getColor();
194     bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Base Color");
195     float *fcol = (float *)socket->default_value;
196
197     fcol[0] = material->r = col.getRed();
198     fcol[1] = material->g = col.getGreen();
199     fcol[2] = material->b = col.getBlue();
200     fcol[3] = material->a = col.getAlpha();
201   }
202   else if (cot.isTexture()) {
203     bNode *texture_node = add_texture_node(cot, -300, locy, "Base Color");
204     if (texture_node != NULL) {
205       add_link(texture_node, 0, shader_node, 0);
206     }
207   }
208 }
209
210 Image *MaterialNode::get_diffuse_image()
211 {
212   bNode *shader = ntreeFindType(ntree, SH_NODE_BSDF_PRINCIPLED);
213   if (shader == nullptr) {
214     return nullptr;
215   }
216
217   bNodeSocket *in_socket = nodeFindSocket(shader, SOCK_IN, "Base Color");
218   if (in_socket == nullptr) {
219     return nullptr;
220   }
221
222   bNodeLink *link = in_socket->link;
223   if (link == nullptr) {
224     return nullptr;
225   }
226
227   bNode *texture = link->fromnode;
228   if (texture == nullptr) {
229     return nullptr;
230   }
231
232   if (texture->type != SH_NODE_TEX_IMAGE) {
233     return nullptr;
234   }
235
236   Image *image = (Image *)texture->id;
237   return image;
238 }
239
240 static bNodeSocket *set_color(bNode *node, COLLADAFW::Color col)
241 {
242   bNodeSocket *socket = (bNodeSocket *)BLI_findlink(&node->outputs, 0);
243   float *fcol = (float *)socket->default_value;
244   fcol[0] = col.getRed();
245   fcol[1] = col.getGreen();
246   fcol[2] = col.getBlue();
247
248   return socket;
249 }
250
251 void MaterialNode::set_ambient(COLLADAFW::ColorOrTexture &cot)
252 {
253   int locy = -300 * (node_map.size() - 2);
254   if (cot.isColor()) {
255     COLLADAFW::Color col = cot.getColor();
256     bNode *node = add_node(SH_NODE_RGB, -300, locy, "Ambient");
257     set_color(node, col);
258     // TODO: Connect node
259   }
260   // texture
261   else if (cot.isTexture()) {
262     add_texture_node(cot, -300, locy, "Ambient");
263     // TODO: Connect node
264   }
265 }
266
267 void MaterialNode::set_reflective(COLLADAFW::ColorOrTexture &cot)
268 {
269   int locy = -300 * (node_map.size() - 2);
270   if (cot.isColor()) {
271     COLLADAFW::Color col = cot.getColor();
272     bNode *node = add_node(SH_NODE_RGB, -300, locy, "Reflective");
273     set_color(node, col);
274     // TODO: Connect node
275   }
276   // texture
277   else if (cot.isTexture()) {
278     add_texture_node(cot, -300, locy, "Reflective");
279     // TODO: Connect node
280   }
281 }
282
283 void MaterialNode::set_emission(COLLADAFW::ColorOrTexture &cot)
284 {
285   int locy = -300 * (node_map.size() - 2);
286   if (cot.isColor()) {
287     COLLADAFW::Color col = cot.getColor();
288     bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Emission");
289     float *fcol = (float *)socket->default_value;
290
291     fcol[0] = col.getRed();
292     fcol[1] = col.getGreen();
293     fcol[2] = col.getBlue();
294     fcol[3] = col.getAlpha();
295   }
296   else if (cot.isTexture()) {
297     bNode *texture_node = add_texture_node(cot, -300, locy, "Emission");
298     if (texture_node != NULL) {
299       add_link(texture_node, 0, shader_node, 0);
300     }
301   }
302 }
303
304 void MaterialNode::set_opacity(COLLADAFW::ColorOrTexture &cot)
305 {
306   if (effect == nullptr) {
307     return;
308   }
309
310   int locy = -300 * (node_map.size() - 2);
311   if (cot.isColor()) {
312     COLLADAFW::Color col = effect->getTransparent().getColor();
313     float alpha = effect->getTransparency().getFloatValue();
314
315     if (col.isValid()) {
316       alpha *= col.getAlpha();  // Assuming A_ONE opaque mode
317     }
318
319     bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Alpha");
320     ((bNodeSocketValueFloat *)socket->default_value)->value = alpha;
321   }
322   // texture
323   else if (cot.isTexture()) {
324     add_texture_node(cot, -300, locy, "Alpha");
325     // TODO: Connect node
326   }
327 }
328
329 void MaterialNode::set_specular(COLLADAFW::ColorOrTexture &cot)
330 {
331   int locy = -300 * (node_map.size() - 2);
332   if (cot.isColor()) {
333     COLLADAFW::Color col = cot.getColor();
334     bNode *node = add_node(SH_NODE_RGB, -300, locy, "Specular");
335     set_color(node, col);
336     // TODO: Connect node
337   }
338   // texture
339   else if (cot.isTexture()) {
340     add_texture_node(cot, -300, locy, "Specular");
341     // TODO: Connect node
342   }
343 }
344
345 bNode *MaterialNode::add_texture_node(COLLADAFW::ColorOrTexture &cot,
346                                       int locx,
347                                       int locy,
348                                       std::string label)
349 {
350   if (effect == nullptr) {
351     return nullptr;
352   }
353
354   UidImageMap &image_map = *uid_image_map;
355
356   COLLADAFW::Texture ctex = cot.getTexture();
357
358   COLLADAFW::SamplerPointerArray &samp_array = effect->getSamplerPointerArray();
359   COLLADAFW::Sampler *sampler = samp_array[ctex.getSamplerId()];
360
361   const COLLADAFW::UniqueId &ima_uid = sampler->getSourceImage();
362
363   if (image_map.find(ima_uid) == image_map.end()) {
364     fprintf(stderr, "Couldn't find an image by UID.\n");
365     return NULL;
366   }
367
368   Image *ima = image_map[ima_uid];
369   bNode *texture_node = add_node(SH_NODE_TEX_IMAGE, locx, locy, label);
370   texture_node->id = &ima->id;
371   return texture_node;
372 }