fbx/cycles support for mapping node.

1 files changed, 101 insertions, 17 deletions

diff --git a/io_scene_fbx/cycles_shader_compat.py b/io_scene_fbx/cycles_shader_compat.py
index 2f1b9fb2..7fb06467 100644
--- a/io_scene_fbx/cycles_shader_compat.py
+++ b/io_scene_fbx/cycles_shader_compat.py
@@ -52,6 +52,7 @@ class CyclesShaderWrapper():
         "node_mix_color_bump",
 
         "node_normalmap",
+        "node_texcoords",
         
         "node_image_alpha",
         "node_image_diff",
@@ -276,6 +277,15 @@ class CyclesShaderWrapper():
         links.new(self.node_mix_color_bump.outputs["Color"],
                   self.node_out.inputs["Displacement"])
 
+        # --------------------------------------------------------------------
+        # Tex Coords
+        node = nodes.new(type='ShaderNodeTexCoord')
+        node.label = "Texture Coords"
+        node.location = self._grid_location(-3, 3)
+        self.node_texcoords = node
+        del node
+        # no links, only use when needed!
+
     @staticmethod
     def _image_create_helper(image, node_dst, sockets_dst, use_alpha=False):
         tree = node_dst.id_data
@@ -292,6 +302,41 @@ class CyclesShaderWrapper():
         return node
 
     @staticmethod
+    def _mapping_create_helper(node_dst, socket_src,
+                               translation, rotation, scale):
+        tree = node_dst.id_data
+        nodes = tree.nodes
+        links = tree.links
+        
+        # in most cases:
+        # (socket_src == self.node_texcoords.outputs['UV'])
+
+        node_map = nodes.new(type='ShaderNodeMapping')
+        node_map.location = node_dst.location
+        node_map.location.x -= CyclesShaderWrapper._col_size
+
+        node_map.width = 160.0
+
+        if translation is not None:
+            node_map.translation = translation
+        if scale is not None:
+            node_map.scale = scale
+        if rotation is not None:
+            node_map.rotation = rotation
+
+        # link mapping -> image node
+        links.new(node_map.outputs["Vector"],
+                  node_dst.inputs["Vector"])
+
+        # link coord -> mapping
+        links.new(socket_src,
+                  node_map.inputs["Vector"])
+        return node_map
+
+    # note, all ***_mapping_set() functions currenly work the same way
+    # (only with different image arg), could generalize.
+
+    @staticmethod
     def _grid_location(x, y):
         return (x * CyclesShaderWrapper._col_size,
                 y * CyclesShaderWrapper._row_size)
@@ -301,8 +346,13 @@ class CyclesShaderWrapper():
 
     def diffuse_image_set(self, image):
         node = self.node_mix_color_diff
-        (self.node_image_diff =
-         self._image_create_helper(image, node, (node.inputs["Color2"],)))
+        self.node_image_diff = (
+            self._image_create_helper(image, node, (node.inputs["Color2"],)))
+
+    def diffuse_mapping_set(self, coords='UV',
+                            translation=None, rotation=None, scale=None):
+        return self._mapping_create_helper(
+            self.node_image_diff, self.node_texcoords.outputs[coords], translation, rotation, scale)
 
     def specular_color_set(self, color):
         self.node_bsdf_spec.mute = max(color) <= 0.0
@@ -310,8 +360,13 @@ class CyclesShaderWrapper():
 
     def specular_image_set(self, image):
         node = self.node_mix_color_spec
-        (self.node_image_spec =
-         self._image_create_helper(image, node, (node.inputs["Color2"],)))
+        self.node_image_spec = (
+            self._image_create_helper(image, node, (node.inputs["Color2"],)))
+
+    def specular_mapping_set(self, coords='UV',
+                             translation=None, rotation=None, scale=None):
+        return self._mapping_create_helper(
+            self.node_image_spec, self.node_texcoords.outputs[coords], translation, rotation, scale)
 
     def hardness_value_set(self, value):
         node = self.node_mix_color_hard
@@ -319,8 +374,13 @@ class CyclesShaderWrapper():
 
     def hardness_image_set(self, image):
         node = self.node_mix_color_hard
-        (self.node_image_hard =
-         self._image_create_helper(image, node, (node.inputs["Color2"],)))
+        self.node_image_hard = (
+            self._image_create_helper(image, node, (node.inputs["Color2"],)))
+
+    def hardness_mapping_set(self, coords='UV',
+                             translation=None, rotation=None, scale=None):
+        return self._mapping_create_helper(
+            self.node_image_hard, self.node_texcoords.outputs[coords], translation, rotation, scale)
 
     def reflect_color_set(self, color):
         node = self.node_mix_color_refl
@@ -335,8 +395,13 @@ class CyclesShaderWrapper():
     def reflect_image_set(self, image):
         self.node_bsdf_refl.mute = False
         node = self.node_mix_color_refl
-        (self.node_image_refl =
-         self._image_create_helper(image, node, (node.inputs["Color2"],)))
+        self.node_image_refl = (
+            self._image_create_helper(image, node, (node.inputs["Color2"],)))
+
+    def reflect_mapping_set(self, coords='UV',
+                            translation=None, rotation=None, scale=None):
+        return self._mapping_create_helper(
+            self.node_image_refl, self.node_texcoords.outputs[coords], translation, rotation, scale)
 
     def alpha_value_set(self, value):
         self.node_bsdf_alpha.mute &= (value >= 1.0)
@@ -349,8 +414,13 @@ class CyclesShaderWrapper():
         # note: use_alpha may need to be configurable
         # its not always the case that alpha channels use the image alpha
         # a greyscale image may also be used.
-        (self.node_image_alpha =
-         self._image_create_helper(image, node, (node.inputs["Color2"],), use_alpha=True))
+        self.node_image_alpha = (
+            self._image_create_helper(image, node, (node.inputs["Color2"],), use_alpha=True))
+
+    def alpha_mapping_set(self, coords='UV',
+                          translation=None, rotation=None, scale=None):
+        return self._mapping_create_helper(
+            self.node_image_alpha, self.node_texcoords.outputs[coords], translation, rotation, scale)
 
     def alpha_image_set_from_diffuse(self):
         # XXX, remove?
@@ -358,10 +428,14 @@ class CyclesShaderWrapper():
         links = tree.links
 
         self.node_bsdf_alpha.mute = False
-        node_image = self.node_mix_color_diff.inputs["Color2"].links[0].from_node
+        node_image = self.node_image_diff
         node = self.node_mix_color_alpha
-        links.new(node_image.outputs["Alpha"],
-                  node.inputs["Color2"])
+        if 1:
+            links.new(node_image.outputs["Alpha"],
+                      node.inputs["Color2"])
+        else:
+            self.alpha_image_set(node_image.image)
+            self.node_image_alpha.label = "Image Texture_ALPHA"
 
     def normal_factor_set(self, value):
         node = self.node_normalmap
@@ -370,10 +444,15 @@ class CyclesShaderWrapper():
     def normal_image_set(self, image):
         self.node_normalmap.mute = False
         node = self.node_normalmap
-        (self.node_image_normalmap =
-         self._image_create_helper(image, node, (node.inputs["Color"],)))
+        self.node_image_normalmap = (
+            self._image_create_helper(image, node, (node.inputs["Color"],)))
         self.node_image_normalmap.color_space = 'NONE'
 
+    def normal_mapping_set(self, coords='UV',
+                           translation=None, rotation=None, scale=None):
+        return self._mapping_create_helper(
+            self.node_image_normalmap, self.node_texcoords.outputs[coords], translation, rotation, scale)
+
     def bump_factor_set(self, value):
         node = self.node_mix_color_bump
         node.mute = (value <= 0.0)
@@ -381,5 +460,10 @@ class CyclesShaderWrapper():
 
     def bump_image_set(self, image):
         node = self.node_mix_color_bump
-        (self.node_image_bump =
-         self._image_create_helper(image, node, (node.inputs["Color2"],)))
+        self.node_image_bump = (
+            self._image_create_helper(image, node, (node.inputs["Color2"],)))
+
+    def bump_mapping_set(self, coords='UV',
+                         translation=None, rotation=None, scale=None):
+        return self._mapping_create_helper(
+            self.node_image_bump, self.node_texcoords.outputs[coords], translation, rotation, scale)