update Collada Importer: reworked export and import of Materials
authorGaia Clary <gaia.clary@machinimatrix.org>
Tue, 4 Jun 2019 12:31:22 +0000 (14:31 +0200)
committerGaia Clary <gaia.clary@machinimatrix.org>
Wed, 5 Jun 2019 10:42:54 +0000 (12:42 +0200)
- added import of transparency and emission into principled BSDF Shader
- added support for importing all default collada material parameters

  * diffuse
  * emission
  * index_of_refraction
  * shininess (mapped to BSDF Roughness)
  * reflectivity (mapped to BSDF Metallic)
  * transparency + transparent mapped to BSDF Alpha)
  * ambient (creates unconnected texture node)
  * specular (creates unconnected texture node)
  * reflective(creates unconnected texture node)

- added support for exporting collada material parameters:

  * diffuse
  * emission
  * index_of_refraction
  * shininess (mapped to BSDF Roughness)
  * reflectivity (mapped to BSDF Metallic)
  * transparency + transparent mapped to BSDF Alpha)

- prepared support for exporting the following parameters
  but currently commented out:

  * ambient (creates unconnected texture node)
  * specular (creates unconnected texture node)
  * reflective(creates unconnected texture node)

  Problem: For now we only allow export of principled BSDF based
  materials. I am not sure from where to get ambient, specular
  and reflective as those values are not included in the
  principled BSDF Shader (wip).

source/blender/collada/BlenderTypes.h
source/blender/collada/DocumentImporter.cpp
source/blender/collada/EffectExporter.cpp
source/blender/collada/EffectExporter.h
source/blender/collada/Materials.cpp
source/blender/collada/Materials.h
source/blender/collada/collada_utils.cpp
source/blender/collada/collada_utils.h

index 22ad9b8c1e0e73a2e618930f05a406303454690e..0e024be2374ad51b64fde31357dd1e4dbc5fd476 100644 (file)
@@ -23,6 +23,7 @@
 
 typedef float(Vector)[3];
 typedef float(Quat)[4];
+typedef float(Color)[4];
 typedef float(Matrix)[4][4];
 typedef double(DMatrix)[4][4];
 
index 1c241671c812fbc0cb28c65cbed37cba79f0a939..06f6682f401f1fd9405abf58a0ed178e1ae49dce 100644 (file)
@@ -796,14 +796,21 @@ bool DocumentImporter::writeMaterial(const COLLADAFW::Material *cmat)
 void DocumentImporter::write_profile_COMMON(COLLADAFW::EffectCommon *ef, Material *ma)
 {
   MaterialNode matNode = MaterialNode(mContext, ef, ma, uid_image_map);
-  matNode.set_reflectivity(ef->getReflectivity().getFloatValue());
-  matNode.set_ior(ef->getIndexOfRefraction().getFloatValue());
-  matNode.set_diffuse(ef->getDiffuse(), "Diffuse");
-  matNode.set_ambient(ef->getAmbient(), "Ambient");
-  matNode.set_specular(ef->getSpecular(), "Specular");
-  matNode.set_reflective(ef->getReflective(), "Reflective");
-  matNode.set_emission(ef->getEmission(), "Emission");
-  matNode.set_opacity(ef->getOpacity(), "Opacity");
+
+  /* Direct mapping to principled BSDF Shader */
+  matNode.set_diffuse(ef->getDiffuse());
+  matNode.set_emission(ef->getEmission());
+  matNode.set_ior(ef->getIndexOfRefraction());
+  matNode.set_alpha(ef->getOpaqueMode(), ef->getTransparent(), ef->getTransparency());
+
+  /* following mapping still needs to be verified */
+  matNode.set_shininess(ef->getShininess());
+  matNode.set_reflectivity(ef->getReflectivity());
+
+  /* not supported by principled BSDF */
+  matNode.set_ambient(ef->getAmbient());
+  matNode.set_specular(ef->getSpecular());
+  matNode.set_reflective(ef->getReflective());
 }
 
 /** When this method is called, the writer must write the effect.
index a45cdccecf31cd77d850de4a7e0eaf9544020098..a0ad3740e45569bcaf6fa8f95e5aa15fcc819383 100644 (file)
@@ -104,6 +104,7 @@ void EffectsExporter::set_transparency(COLLADASW::EffectProfile &ep, Material *m
   double alpha = bc_get_alpha(ma);
   ep.setTransparency(alpha, false, "alpha");
 }
+
 void EffectsExporter::set_diffuse_color(COLLADASW::EffectProfile &ep, Material *ma)
 {
   // get diffuse color
@@ -111,6 +112,25 @@ void EffectsExporter::set_diffuse_color(COLLADASW::EffectProfile &ep, Material *
   ep.setDiffuse(cot, false, "diffuse");
 }
 
+void EffectsExporter::set_ambient(COLLADASW::EffectProfile &ep, Material *ma)
+{
+  // get diffuse color
+  COLLADASW::ColorOrTexture cot = bc_get_ambient(ma);
+  ep.setAmbient(cot, false, "ambient");
+}
+void EffectsExporter::set_specular(COLLADASW::EffectProfile &ep, Material *ma)
+{
+  // get diffuse color
+  COLLADASW::ColorOrTexture cot = bc_get_specular(ma);
+  ep.setSpecular(cot, false, "specular");
+}
+void EffectsExporter::set_reflective(COLLADASW::EffectProfile &ep, Material *ma)
+{
+  // get diffuse color
+  COLLADASW::ColorOrTexture cot = bc_get_reflective(ma);
+  ep.setReflective(cot, false, "reflective");
+}
+
 void EffectsExporter::set_reflectivity(COLLADASW::EffectProfile &ep, Material *ma)
 {
   double reflectivity = bc_get_reflectivity(ma);
@@ -123,6 +143,18 @@ void EffectsExporter::set_emission(COLLADASW::EffectProfile &ep, Material *ma)
   ep.setEmission(cot, false, "emission");
 }
 
+void EffectsExporter::set_ior(COLLADASW::EffectProfile &ep, Material *ma)
+{
+  double alpha = bc_get_ior(ma);
+  ep.setIndexOfRefraction(alpha, false, "ior");
+}
+
+void EffectsExporter::set_shininess(COLLADASW::EffectProfile &ep, Material *ma)
+{
+  double shininess = bc_get_shininess(ma);
+  ep.setShininess(shininess, false, "shininess");
+}
+
 void EffectsExporter::get_images(Material *ma, KeyImageMap &material_image_map)
 {
   if (!ma->use_nodes) {
@@ -180,10 +212,17 @@ void EffectsExporter::operator()(Material *ma, Object *ob)
 
   COLLADASW::ColorOrTexture cot;
 
-  set_transparency(ep, ma);
   set_diffuse_color(ep, ma);
-  set_reflectivity(ep, ma);
   set_emission(ep, ma);
+  set_ior(ep, ma);
+  set_shininess(ep, ma);
+  set_reflectivity(ep, ma);
+  set_transparency(ep, ma);
+
+  /* TODO: from where to get ambient, specular and reflective? */
+  // set_ambient(ep, ma);
+  // set_specular(ep, ma);
+  // set_reflective(ep, ma);
 
   get_images(ma, material_image_map);
   std::string active_uv(getActiveUVLayerName(ob));
index 75511800081567a28d996c45292906c49aeb6f6e..57df844233c67bda9bcfef54fabd67faafceb09b 100644 (file)
@@ -55,10 +55,17 @@ class EffectsExporter : COLLADASW::LibraryEffects {
 
  private:
   void set_shader_type(COLLADASW::EffectProfile &ep, Material *ma);
-  void set_transparency(COLLADASW::EffectProfile &ep, Material *ma);
+
   void set_diffuse_color(COLLADASW::EffectProfile &ep, Material *ma);
-  void set_reflectivity(COLLADASW::EffectProfile &ep, Material *ma);
   void set_emission(COLLADASW::EffectProfile &ep, Material *ma);
+  void set_ior(COLLADASW::EffectProfile &ep, Material *ma);
+  void set_shininess(COLLADASW::EffectProfile &ep, Material *ma);
+  void set_reflectivity(COLLADASW::EffectProfile &ep, Material *ma);
+  void set_transparency(COLLADASW::EffectProfile &ep, Material *ma);
+  void set_ambient(COLLADASW::EffectProfile &ep, Material *ma);
+  void set_specular(COLLADASW::EffectProfile &ep, Material *ma);
+  void set_reflective(COLLADASW::EffectProfile &ep, Material *ma);
+
   void get_images(Material *ma, KeyImageMap &uid_image_map);
   void create_image_samplers(COLLADASW::EffectProfile &ep,
                              KeyImageMap &uid_image_map,
index 4313e634b2361e087691352ba5ab4a5aca4279a9..becbe49a55e96474cad6a288fc9c644cc841e879 100644 (file)
@@ -21,6 +21,9 @@ MaterialNode::MaterialNode(bContext *C, Material *ma, KeyImageMap &key_image_map
 {
   ntree = prepare_material_nodetree();
   setShaderType();
+  shader_node = add_node(SH_NODE_BSDF_PRINCIPLED, 0, 300, "");
+  output_node = add_node(SH_NODE_OUTPUT_MATERIAL, 300, 300, "");
+  add_link(shader_node, 0, output_node, 0);
 }
 
 MaterialNode::MaterialNode(bContext *C,
@@ -118,25 +121,64 @@ void MaterialNode::add_link(bNode *from_node, int from_index, bNode *to_node, in
   nodeAddLink(ntree, from_node, from_socket, to_node, to_socket);
 }
 
-void MaterialNode::set_reflectivity(float val)
+void MaterialNode::set_reflectivity(COLLADAFW::FloatOrParam &val)
+{
+  float reflectivity = val.getFloatValue();
+  bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Metallic");
+  ((bNodeSocketValueFloat *)socket->default_value)->value = reflectivity;
+
+  material->metallic = reflectivity;
+}
+
+void MaterialNode::set_shininess(COLLADAFW::FloatOrParam &val)
+{
+  float roughness = val.getFloatValue();
+  bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Roughness");
+  ((bNodeSocketValueFloat *)socket->default_value)->value = roughness;
+}
+
+void MaterialNode::set_ior(COLLADAFW::FloatOrParam &val)
 {
-  material->metallic = val;
-  bNodeSocket *socket = (bNodeSocket *)BLI_findlink(&shader_node->inputs, BC_PBR_METALLIC);
-  *(float *)socket->default_value = val;
+  float ior = val.getFloatValue();
+  if (ior < 0) {
+    fprintf(stderr,
+            "IOR of negative value is not allowed for materials (using Blender default value "
+            "instead)");
+    return;
+  }
+
+  bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "IOR");
+  ((bNodeSocketValueFloat *)socket->default_value)->value = ior;
 }
 
-void MaterialNode::set_ior(float val)
+void MaterialNode::set_alpha(COLLADAFW::EffectCommon::OpaqueMode mode,
+                             COLLADAFW::ColorOrTexture &cot,
+                             COLLADAFW::FloatOrParam &val)
 {
-  bNodeSocket *socket = (bNodeSocket *)BLI_findlink(&shader_node->inputs, BC_PBR_IOR);
-  *(float *)socket->default_value = val;
+  if (effect == nullptr) {
+    return;
+  }
+
+  if (cot.isColor() || !cot.isValid()) {
+    COLLADAFW::Color col = (cot.isValid()) ? cot.getColor() : COLLADAFW::Color(1, 1, 1, 1);
+    float alpha = val.getFloatValue() * col.getAlpha();  // Assuming A_ONE opaque mode
+
+    bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Alpha");
+    ((bNodeSocketValueFloat *)socket->default_value)->value = alpha;
+  }
+  else if (cot.isTexture()) {
+    int locy = -300 * (node_map.size() - 2);
+    add_texture_node(cot, -300, locy, "Alpha");
+    // TODO: Connect node
+  }
 }
 
-void MaterialNode::set_diffuse(COLLADAFW::ColorOrTexture &cot, std::string label)
+void MaterialNode::set_diffuse(COLLADAFW::ColorOrTexture &cot)
 {
   int locy = -300 * (node_map.size() - 2);
   if (cot.isColor()) {
     COLLADAFW::Color col = cot.getColor();
-    bNodeSocket *socket = (bNodeSocket *)BLI_findlink(&shader_node->inputs, BC_PBR_DIFFUSE);
+    bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Base Color");
     float *fcol = (float *)socket->default_value;
 
     fcol[0] = material->r = col.getRed();
@@ -145,7 +187,7 @@ void MaterialNode::set_diffuse(COLLADAFW::ColorOrTexture &cot, std::string label
     fcol[3] = material->a = col.getAlpha();
   }
   else if (cot.isTexture()) {
-    bNode *texture_node = add_texture_node(cot, -300, locy, label);
+    bNode *texture_node = add_texture_node(cot, -300, locy, "Base Color");
     if (texture_node != NULL) {
       add_link(texture_node, 0, shader_node, 0);
     }
@@ -159,7 +201,7 @@ Image *MaterialNode::get_diffuse_image()
     return nullptr;
   }
 
-  bNodeSocket *in_socket = (bNodeSocket *)BLI_findlink(&shader->inputs, BC_PBR_DIFFUSE);
+  bNodeSocket *in_socket = nodeFindSocket(shader_node, SOCK_IN, "Base Color");
   if (in_socket == nullptr) {
     return nullptr;
   }
@@ -193,54 +235,60 @@ static bNodeSocket *set_color(bNode *node, COLLADAFW::Color col)
   return socket;
 }
 
-void MaterialNode::set_ambient(COLLADAFW::ColorOrTexture &cot, std::string label)
+void MaterialNode::set_ambient(COLLADAFW::ColorOrTexture &cot)
 {
   int locy = -300 * (node_map.size() - 2);
   if (cot.isColor()) {
     COLLADAFW::Color col = cot.getColor();
-    bNode *node = add_node(SH_NODE_RGB, -300, locy, label);
+    bNode *node = add_node(SH_NODE_RGB, -300, locy, "Ambient");
     set_color(node, col);
     // TODO: Connect node
   }
   // texture
   else if (cot.isTexture()) {
-    add_texture_node(cot, -300, locy, label);
+    add_texture_node(cot, -300, locy, "Ambient");
     // TODO: Connect node
   }
 }
-void MaterialNode::set_reflective(COLLADAFW::ColorOrTexture &cot, std::string label)
+
+void MaterialNode::set_reflective(COLLADAFW::ColorOrTexture &cot)
 {
   int locy = -300 * (node_map.size() - 2);
   if (cot.isColor()) {
     COLLADAFW::Color col = cot.getColor();
-    bNode *node = add_node(SH_NODE_RGB, -300, locy, label);
+    bNode *node = add_node(SH_NODE_RGB, -300, locy, "Reflective");
     set_color(node, col);
     // TODO: Connect node
   }
   // texture
   else if (cot.isTexture()) {
-    add_texture_node(cot, -300, locy, label);
+    add_texture_node(cot, -300, locy, "Reflective");
     // TODO: Connect node
   }
 }
 
-void MaterialNode::set_emission(COLLADAFW::ColorOrTexture &cot, std::string label)
+void MaterialNode::set_emission(COLLADAFW::ColorOrTexture &cot)
 {
   int locy = -300 * (node_map.size() - 2);
   if (cot.isColor()) {
     COLLADAFW::Color col = cot.getColor();
-    bNode *node = add_node(SH_NODE_RGB, -300, locy, label);
-    set_color(node, col);
-    // TODO: Connect node
+    bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Emission");
+    float *fcol = (float *)socket->default_value;
+
+    fcol[0] = col.getRed();
+    fcol[1] = col.getGreen();
+    fcol[2] = col.getBlue();
+    fcol[3] = col.getAlpha();
   }
-  // texture
   else if (cot.isTexture()) {
-    add_texture_node(cot, -300, locy, label);
-    // TODO: Connect node
+    bNode *texture_node = add_texture_node(cot, -300, locy, "Emission");
+    if (texture_node != NULL) {
+      add_link(texture_node, 0, shader_node, 0);
+    }
   }
 }
 
-void MaterialNode::set_opacity(COLLADAFW::ColorOrTexture &cot, std::string label)
+void MaterialNode::set_opacity(COLLADAFW::ColorOrTexture &cot)
 {
   if (effect == nullptr) {
     return;
@@ -254,37 +302,29 @@ void MaterialNode::set_opacity(COLLADAFW::ColorOrTexture &cot, std::string label
     if (col.isValid()) {
       alpha *= col.getAlpha();  // Assuming A_ONE opaque mode
     }
-    if (col.isValid() || alpha < 1.0) {
-      // not sure what to do here
-    }
 
-    bNode *node = add_node(SH_NODE_RGB, -300, locy, label);
-    set_color(node, col);
-    // TODO: Connect node
+    bNodeSocket *socket = nodeFindSocket(shader_node, SOCK_IN, "Alpha");
+    ((bNodeSocketValueFloat *)socket->default_value)->value = alpha;
   }
   // texture
   else if (cot.isTexture()) {
-    add_texture_node(cot, -300, locy, label);
+    add_texture_node(cot, -300, locy, "Alpha");
     // TODO: Connect node
   }
 }
 
-void MaterialNode::set_specular(COLLADAFW::ColorOrTexture &cot, std::string label)
+void MaterialNode::set_specular(COLLADAFW::ColorOrTexture &cot)
 {
   int locy = -300 * (node_map.size() - 2);
   if (cot.isColor()) {
     COLLADAFW::Color col = cot.getColor();
-    material->specr = col.getRed();
-    material->specg = col.getGreen();
-    material->specb = col.getBlue();
-
-    bNode *node = add_node(SH_NODE_RGB, -300, locy, label);
+    bNode *node = add_node(SH_NODE_RGB, -300, locy, "Specular");
     set_color(node, col);
     // TODO: Connect node
   }
   // texture
   else if (cot.isTexture()) {
-    add_texture_node(cot, -300, locy, label);
+    add_texture_node(cot, -300, locy, "Specular");
     // TODO: Connect node
   }
 }
index 445b9fd0758a37e7da54dd87b32270e9f2d2dfe3..8f3c3dbcd93298d9ef5f580da4d4e58a8ffd3465 100644 (file)
@@ -31,12 +31,6 @@ extern "C" {
 #include "collada_utils.h"
 #include "COLLADAFWEffectCommon.h"
 
-typedef enum BC_pbr_inputs {
-  BC_PBR_DIFFUSE = 0,
-  BC_PBR_METALLIC = 4,
-  BC_PBR_IOR = 14,
-} BC_pbr_inputs;
-
 typedef std::map<std::string, bNode *> NodeMap;
 
 class MaterialNode {
@@ -63,15 +57,20 @@ class MaterialNode {
  public:
   MaterialNode(bContext *C, COLLADAFW::EffectCommon *ef, Material *ma, UidImageMap &uid_image_map);
   MaterialNode(bContext *C, Material *ma, KeyImageMap &key_image_map);
-  void set_diffuse(COLLADAFW::ColorOrTexture &cot, std::string label);
   Image *get_diffuse_image();
-  void set_specular(COLLADAFW::ColorOrTexture &cot, std::string label);
-  void set_ambient(COLLADAFW::ColorOrTexture &cot, std::string label);
-  void set_reflective(COLLADAFW::ColorOrTexture &cot, std::string label);
-  void set_emission(COLLADAFW::ColorOrTexture &cot, std::string label);
-  void set_opacity(COLLADAFW::ColorOrTexture &cot, std::string label);
-  void set_reflectivity(float val);
-  void set_ior(float val);
+
+  void set_diffuse(COLLADAFW::ColorOrTexture &cot);
+  void set_specular(COLLADAFW::ColorOrTexture &cot);
+  void set_ambient(COLLADAFW::ColorOrTexture &cot);
+  void set_reflective(COLLADAFW::ColorOrTexture &cot);
+  void set_emission(COLLADAFW::ColorOrTexture &cot);
+  void set_opacity(COLLADAFW::ColorOrTexture &cot);
+  void set_reflectivity(COLLADAFW::FloatOrParam &val);
+  void set_shininess(COLLADAFW::FloatOrParam &val);
+  void set_ior(COLLADAFW::FloatOrParam &val);
+  void set_alpha(COLLADAFW::EffectCommon::OpaqueMode mode,
+                 COLLADAFW::ColorOrTexture &cot,
+                 COLLADAFW::FloatOrParam &val);
 };
 
 #endif
index 50dc1d8d658001cb9c67c76ded8e53372304802e..dd5611c4bef04115da89c7200c72147ef73c35a2 100644 (file)
@@ -1321,92 +1321,110 @@ void bc_add_default_shader(bContext *C, Material *ma)
 
 COLLADASW::ColorOrTexture bc_get_base_color(Material *ma)
 {
-  bNode *master_shader = bc_get_master_shader(ma);
-  if (ma->use_nodes && master_shader) {
-    return bc_get_base_color(master_shader);
+  Color default_color = {0.8, 0.8, 0.8, 1.0};
+  bNode *shader = bc_get_master_shader(ma);
+  if (ma->use_nodes && shader) {
+    return bc_get_cot_from_shader(shader, "Base Color", default_color);
   }
   else {
-    return bc_get_cot(ma->r, ma->g, ma->b, ma->a);
+    return bc_get_cot(default_color);
   }
 }
 
-COLLADASW::ColorOrTexture bc_get_base_color(bNode *shader)
+COLLADASW::ColorOrTexture bc_get_emission(Material *ma)
 {
-  bNodeSocket *socket = nodeFindSocket(shader, SOCK_IN, "Base Color");
-  if (socket) {
-    bNodeSocketValueRGBA *dcol = (bNodeSocketValueRGBA *)socket->default_value;
-    float *col = dcol->value;
-    return bc_get_cot(col[0], col[1], col[2], col[3]);
+  Color default_color = {0, 0, 0, 1};
+  bNode *shader = bc_get_master_shader(ma);
+  if (ma->use_nodes && shader) {
+    return bc_get_cot_from_shader(shader, "Emission", default_color);
   }
   else {
-    return bc_get_cot(0.8, 0.8, 0.8, 1.0); /* default white */
+    return bc_get_cot(default_color); /* default black */
   }
 }
 
-COLLADASW::ColorOrTexture bc_get_emission(Material *ma)
+COLLADASW::ColorOrTexture bc_get_ambient(Material *ma)
+{
+  Color default_color = {0, 0, 0, 1.0};
+  return bc_get_cot(default_color);
+}
+
+COLLADASW::ColorOrTexture bc_get_specular(Material *ma)
+{
+  Color default_color = {0, 0, 0, 1.0};
+  return bc_get_cot(default_color);
+}
+
+COLLADASW::ColorOrTexture bc_get_reflective(Material *ma)
+{
+  Color default_color = {0, 0, 0, 1.0};
+  return bc_get_cot(default_color);
+}
+
+double bc_get_alpha(Material *ma)
 {
+  double alpha = ma->a; /* fallback if no socket found */
   bNode *master_shader = bc_get_master_shader(ma);
   if (ma->use_nodes && master_shader) {
-    return bc_get_emission(master_shader);
-  }
-  else {
-    return bc_get_cot(0, 0, 0, 1); /* default black */
+    bc_get_float_from_shader(master_shader, alpha, "Alpha");
   }
+  return alpha;
 }
 
-COLLADASW::ColorOrTexture bc_get_emission(bNode *shader)
+double bc_get_ior(Material *ma)
 {
-  bNodeSocket *socket = nodeFindSocket(shader, SOCK_IN, "Emission");
-  if (socket) {
-    bNodeSocketValueRGBA *dcol = (bNodeSocketValueRGBA *)socket->default_value;
-    float *col = dcol->value;
-    return bc_get_cot(col[0], col[1], col[2], col[3]);
-  }
-  else {
-    return bc_get_cot(0, 0, 0, 1); /* default black */
+  double ior = -1; /* fallback if no socket found */
+  bNode *master_shader = bc_get_master_shader(ma);
+  if (ma->use_nodes && master_shader) {
+    bc_get_float_from_shader(master_shader, ior, "IOR");
   }
+  return ior;
 }
 
-bool bc_get_reflectivity(bNode *shader, double &reflectivity)
+double bc_get_shininess(Material *ma)
 {
-  bNodeSocket *socket = nodeFindSocket(shader, SOCK_IN, "Specular");
-  if (socket) {
-    bNodeSocketValueFloat *ref = (bNodeSocketValueFloat *)socket->default_value;
-    reflectivity = (double)ref->value;
-    return true;
+  double ior = -1; /* fallback if no socket found */
+  bNode *master_shader = bc_get_master_shader(ma);
+  if (ma->use_nodes && master_shader) {
+    bc_get_float_from_shader(master_shader, ior, "Roughness");
   }
-  return false;
+  return ior;
 }
 
-double bc_get_alpha(Material *ma)
+double bc_get_reflectivity(Material *ma)
 {
-  double alpha = ma->a; /* fallback if no socket found */
+  double reflectivity = ma->spec; /* fallback if no socket found */
   bNode *master_shader = bc_get_master_shader(ma);
   if (ma->use_nodes && master_shader) {
-    bc_get_alpha(master_shader, alpha);
+    bc_get_float_from_shader(master_shader, reflectivity, "Metallic");
   }
-  return alpha;
+  return reflectivity;
 }
 
-bool bc_get_alpha(bNode *shader, double &alpha)
+double bc_get_float_from_shader(bNode *shader, double &val, std::string nodeid)
 {
-  bNodeSocket *socket = nodeFindSocket(shader, SOCK_IN, "Alpha");
+  bNodeSocket *socket = nodeFindSocket(shader, SOCK_IN, nodeid.c_str());
   if (socket) {
     bNodeSocketValueFloat *ref = (bNodeSocketValueFloat *)socket->default_value;
-    alpha = (double)ref->value;
+    val = (double)ref->value;
     return true;
   }
   return false;
 }
 
-double bc_get_reflectivity(Material *ma)
+COLLADASW::ColorOrTexture bc_get_cot_from_shader(bNode *shader,
+                                                 std::string nodeid,
+                                                 Color &default_color)
 {
-  double reflectivity = ma->spec; /* fallback if no socket found */
-  bNode *master_shader = bc_get_master_shader(ma);
-  if (ma->use_nodes && master_shader) {
-    bc_get_reflectivity(master_shader, reflectivity);
+  bNodeSocket *socket = nodeFindSocket(shader, SOCK_IN, nodeid.c_str());
+  if (socket) {
+    bNodeSocketValueRGBA *dcol = (bNodeSocketValueRGBA *)socket->default_value;
+    float *col = dcol->value;
+    return bc_get_cot(col);
+  }
+  else {
+    return bc_get_cot(default_color); /* default black */
   }
-  return reflectivity;
 }
 
 bNode *bc_get_master_shader(Material *ma)
@@ -1428,3 +1446,10 @@ COLLADASW::ColorOrTexture bc_get_cot(float r, float g, float b, float a)
   COLLADASW::ColorOrTexture cot(color);
   return cot;
 }
+
+COLLADASW::ColorOrTexture bc_get_cot(Color col)
+{
+  COLLADASW::Color color(col[0], col[1], col[2], col[3]);
+  COLLADASW::ColorOrTexture cot(color);
+  return cot;
+}
index 7836b1ede865288efdf590e64480429bc01c0658..2912b315276d9b48ccf509c9e0e8e5f2fbd25032 100644 (file)
@@ -384,16 +384,24 @@ class BoneExtensionManager {
 
 void bc_add_default_shader(bContext *C, Material *ma);
 bNode *bc_get_master_shader(Material *ma);
-COLLADASW::ColorOrTexture bc_get_cot(float r, float g, float b, float a);
 
 COLLADASW::ColorOrTexture bc_get_base_color(Material *ma);
-COLLADASW::ColorOrTexture bc_get_base_color(bNode *shader);
 COLLADASW::ColorOrTexture bc_get_emission(Material *ma);
-COLLADASW::ColorOrTexture bc_get_emission(bNode *shader);
+COLLADASW::ColorOrTexture bc_get_ambient(Material *ma);
+COLLADASW::ColorOrTexture bc_get_specular(Material *ma);
+COLLADASW::ColorOrTexture bc_get_reflective(Material *ma);
 
 double bc_get_reflectivity(Material *ma);
-bool bc_get_reflectivity(bNode *shader, double &emission);
 double bc_get_alpha(Material *ma);
-bool bc_get_alpha(bNode *shader, double &alpha);
+double bc_get_ior(Material *ma);
+double bc_get_shininess(Material *ma);
+
+double bc_get_float_from_shader(bNode *shader, double &ior, std::string nodeid);
+COLLADASW::ColorOrTexture bc_get_cot_from_shader(bNode *shader,
+                                                 std::string nodeid,
+                                                 Color &default_color);
+
+COLLADASW::ColorOrTexture bc_get_cot(float r, float g, float b, float a);
+COLLADASW::ColorOrTexture bc_get_cot(Color col);
 
 #endif