home *** CD-ROM | disk | FTP | other *** search
/ Hackers Magazine 57 / CdHackersMagazineNr57.iso / Software / Multimedia / k3d-setup-0.7.11.0.exe / lib / site-packages / cgkit / material3ds.py < prev    next >
Encoding:
Python Source  |  2007-01-11  |  23.8 KB  |  690 lines
  1. # ***** BEGIN LICENSE BLOCK *****
  2. # Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3. #
  4. # The contents of this file are subject to the Mozilla Public License Version
  5. # 1.1 (the "License"); you may not use this file except in compliance with
  6. # the License. You may obtain a copy of the License at
  7. # http://www.mozilla.org/MPL/
  8. #
  9. # Software distributed under the License is distributed on an "AS IS" basis,
  10. # WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11. # for the specific language governing rights and limitations under the
  12. # License.
  13. #
  14. # The Original Code is the Python Computer Graphics Kit.
  15. #
  16. # The Initial Developer of the Original Code is Matthias Baas.
  17. # Portions created by the Initial Developer are Copyright (C) 2004
  18. # the Initial Developer. All Rights Reserved.
  19. #
  20. # Contributor(s):
  21. #
  22. # Alternatively, the contents of this file may be used under the terms of
  23. # either the GNU General Public License Version 2 or later (the "GPL"), or
  24. # the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  25. # in which case the provisions of the GPL or the LGPL are applicable instead
  26. # of those above. If you wish to allow use of your version of this file only
  27. # under the terms of either the GPL or the LGPL, and not to allow others to
  28. # use your version of this file under the terms of the MPL, indicate your
  29. # decision by deleting the provisions above and replace them with the notice
  30. # and other provisions required by the GPL or the LGPL. If you do not delete
  31. # the provisions above, a recipient may use your version of this file under
  32. # the terms of any one of the MPL, the GPL or the LGPL.
  33. #
  34. # ***** END LICENSE BLOCK *****
  35. # $Id: material3ds.py,v 1.4 2005/08/28 19:42:43 mbaas Exp $
  36.  
  37. ## \file material3ds.py
  38. ## Contains the Material3DS class.
  39.  
  40. import os.path, sys, shutil
  41. import protocols
  42. from _OpenGL.GL import *
  43. from Interfaces import *
  44. from slots import *
  45. import lookat, sl, math
  46. from material import Material
  47. from glmaterial import GLMaterial, GLTexture
  48. import ribexport
  49. import _Image as Image
  50.  
  51. # TextureMap3DS
  52. class TextureMap3DS:
  53.     """A texture map definition as it appears in 3DS files.
  54.     """
  55.     
  56.     def __init__(self,
  57.                  name,
  58.                  flags = 0,
  59.                  percent = 0.0,
  60.                  blur = 0.0,
  61.                  scale = (1.0, 1.0),
  62.                  offset = (0,0),
  63.                  rotation = 0,
  64.                  tint1 = (0,0,0),
  65.                  tint2 = (0,0,0),
  66.                  tintr = (0,0,0),
  67.                  tintg = (0,0,0),
  68.                  tintb = (0,0,0)
  69.                  ):
  70.         self.name = name
  71.         self.flags = flags
  72.         self.percent = percent
  73.         self.blur = blur
  74.         self.scale = scale
  75.         self.offset = offset
  76.         self.rotation = rotation
  77.         self.tint1 = tint1
  78.         self.tint2 = tint2
  79.         self.tintr = tintr
  80.         self.tintg = tintg
  81.         self.tintb = tintb
  82.  
  83.     def __str__(self):
  84.         s = "TextureMap3DS:\n"
  85.         s += '  Name    : "%s"\n'%self.name
  86.         s += '  Flags   : %d\n'%self.flags
  87.         s += '  Percent : %s\n'%self.percent
  88.         s += '  Blur    : %s\n'%self.blur
  89.         s += '  Scale   : %s, %s\n'%self.scale
  90.         s += '  Offset  : %s, %s\n'%self.offset
  91.         s += '  Rotation: %s\n'%self.rotation
  92.         s += '  Tint1   : %s\n'%(self.tint1,)
  93.         s += '  Tint2   : %s\n'%(self.tint2,)
  94.         s += '  TintR   : %s\n'%(self.tintr,)
  95.         s += '  TintG   : %s\n'%(self.tintg,)
  96.         s += '  TintB   : %s'%(self.tintb,)
  97.         return s
  98.  
  99.  
  100. # Material3DS
  101. class Material3DS(Material):
  102.     """This class represents a material as it appears in 3DS files.
  103.  
  104.     """
  105.  
  106.     protocols.advise(instancesProvide=[ribexport.IMaterial])
  107.     
  108. #    protocols.advise(instancesProvide=[ISceneItem])
  109.  
  110.     def __init__(self,
  111.                  name="Material3DS",
  112.                  ambient = (0,0,0,0),
  113.                  diffuse = (1.0, 1.0, 1.0, 1.0),
  114.                  specular = (1.0, 1.0, 1.0, 1.0),
  115.                  shininess = 1,
  116.                  shin_strength = 0,
  117.                  use_blur = 0,
  118.                  transparency = 0.0,
  119.                  falloff = 0,
  120.                  additive = 0,
  121.                  use_falloff = 0,
  122.                  self_illum = False,
  123.                  self_ilpct = 0.0,
  124.                  shading = 0,
  125.                  soften = 0,
  126.                  face_map = 0,
  127.                  two_sided = 0,
  128.                  map_decal = 0,
  129.                  use_wire = 0,
  130.                  use_wire_abs = 0,
  131.                  wire_size = 0,
  132.                  density = 1.0,
  133.                  texture1_map = None,
  134.                  texture1_mask = None,
  135.                  texture2_map = None,
  136.                  texture2_mask = None,
  137.                  opacity_map = None,
  138.                  opacity_mask = None,
  139.                  bump_map = None,
  140.                  bump_mask = None,
  141.                  specular_map = None,
  142.                  specular_mask = None,
  143.                  shininess_map = None,
  144.                  shininess_mask = None,
  145.                  self_illum_map = None,
  146.                  self_illum_mask = None,
  147.                  reflection_map = None,
  148.                  reflection_mask = None,
  149.  
  150.                  bump_size = 1.0   # Extra parameter to control the bump map
  151.                  ):
  152.  
  153.         Material.__init__(self, name=name, density=density)
  154.  
  155.         self.ambient = ambient
  156.         self.diffuse = diffuse
  157.         self.specular = specular
  158.         self.shininess = shininess
  159.         self.shin_strength = shin_strength
  160.         self.transparency = transparency
  161.         self.self_illum = self_illum
  162.         self.self_ilpct = self_ilpct
  163.         self.texture1_map = texture1_map
  164.         self.texture1_mask = texture1_mask
  165.         self.texture2_map = texture2_map
  166.         self.texture2_mask = texture2_mask
  167.         self.opacity_map = opacity_map
  168.         self.opacity_mask = opacity_mask
  169.         self.bump_map = bump_map
  170.         self.bump_mask = bump_mask
  171.         self.specular_map = specular_map
  172.         self.specular_mask = specular_mask
  173.         self.shininess_map = shininess_map
  174.         self.shininess_mask = shininess_mask
  175.         self.self_illum_map = self_illum_map
  176.         self.self_illum_mask = self_illum_mask
  177.         self.reflection_map = reflection_map
  178.         self.reflection_mask = reflection_mask
  179.         self.bump_size = bump_size
  180.  
  181.         if texture1_map==None:
  182.             self._gltexture = None
  183.             glambient = ambient
  184.             gldiffuse = diffuse
  185.         else:
  186.             map = texture1_map
  187.             T = mat4(1,0,0,-map.offset[0]-0.5, 0,-1,0,0.5-map.offset[1], 0,0,1,0, 0,0,0,1)
  188.             a = sl.radians(map.rotation)
  189.             ca = math.cos(a)
  190.             sa = math.sin(a)
  191.             R = mat4(ca,-sa,0,0, sa,ca,0,0, 0,0,1,0, 0,0,0,1)
  192.             S = mat4(map.scale[0],0,0,0.5, 0,map.scale[1],0,0.5, 0,0,1,0, 0,0,0,1)
  193.             self._gltexture = GLTexture(imagename = map.name,
  194.                                         mode = GL_MODULATE,
  195. #                                        transform = mat4().scaling(vec3(1,-1,1))
  196.                                         transform = S*R*T
  197.                                         )
  198.             glambient = map.percent*vec4(1,1,1,1) + (1-map.percent)*vec4(ambient)
  199.             gldiffuse = map.percent*vec4(1,1,1,1) + (1-map.percent)*vec4(diffuse)
  200.  
  201.         self._glmaterial = GLMaterial(ambient = glambient,
  202.                                       diffuse = gldiffuse,
  203.                                       specular = shin_strength*specular,
  204.                                       shininess = 25*shininess,
  205.                                       texture = self._gltexture
  206.                                       )
  207.  
  208. ##        print >>sys.stderr, "---",name,"---"
  209. ##        print >>sys.stderr, "ambient",self.ambient
  210. ##        print >>sys.stderr, "diffuse",self.diffuse
  211. ##        print >>sys.stderr, "Map1:"
  212. ##        print >>sys.stderr, self.texture1_map
  213. ##        print >>sys.stderr, "Map2:"
  214. ##        print >>sys.stderr, self.texture2_map
  215. ##        print >>sys.stderr, "Opacity:"
  216. ##        print >>sys.stderr, self.opacity_map
  217. ##        print >>sys.stderr, "Bump:"
  218. ##        print >>sys.stderr, self.bump_map
  219. ##        print >>sys.stderr, "Specular:"
  220. ##        print >>sys.stderr, self.specular_map
  221. ##        print >>sys.stderr, "Shininess:"
  222. ##        print >>sys.stderr, self.shininess_map
  223. ##        print >>sys.stderr, "Self illum:"
  224. ##        print >>sys.stderr, self.self_illum_map
  225. ##        print >>sys.stderr, "Reflection:"
  226. ##        print >>sys.stderr, self.reflection_map
  227. ##        print >>sys.stderr, "shininess",shininess
  228. ##        print >>sys.stderr, "shin_strength",shin_strength
  229. ##        print >>sys.stderr, "transparency",transparency
  230. ##        print >>sys.stderr, "falloff",falloff
  231. ##        print >>sys.stderr, "use_falloff",use_falloff
  232. ##        print >>sys.stderr, "use_blur", use_blur
  233. ##        print >>sys.stderr, "additive",additive
  234. ##        print >>sys.stderr, "shading",shading
  235. ##        print >>sys.stderr, "soften",soften
  236. ##        print >>sys.stderr, "self_illum", self_illum
  237. ##        print >>sys.stderr, "face_map", face_map
  238. ##        print >>sys.stderr, "two_sided", two_sided
  239. ##        print >>sys.stderr, "map_decal", map_decal
  240. ##        print >>sys.stderr, "use_wire", use_wire
  241. ##        print >>sys.stderr, "use_wire_abs", use_wire_abs
  242. ##        print >>sys.stderr, "wire_size", wire_size
  243.  
  244.     def applyGL(self):
  245.         self._glmaterial.applyGL()
  246.  
  247.     def usesBlending(self):
  248.         return self._glmaterial.usesBlending()
  249.  
  250.         
  251.     def createPasses(self):
  252.         """Returns a list of RenderPass objects."""
  253.         texdefs = []
  254.         texdefs += self._createTexDef(self.texture1_map)
  255.         texdefs += self._createTexDef(self.opacity_map)
  256.         texdefs += self._createTexDef(self.bump_map)
  257.         texdefs += self._createTexDef(self.specular_map)
  258.         texdefs += self._createTexDef(self.shininess_map)
  259.         texdefs += self._createTexDef(self.self_illum_map)
  260.         texdefs += self._createTexDef(self.reflection_map)
  261.  
  262.         if texdefs!=[]:
  263.             return [ribexport.TexPass(maps=texdefs)]
  264.         else:
  265.             return []
  266.  
  267.  
  268.     def preProcess(self, exporter):
  269.         """Preprocessing method.
  270.  
  271.         This method is called before the image is rendered and can be used
  272.         to create or copy image maps.
  273.         """
  274.         pass
  275. #        self._copyImageMap(self.texture1_map, exporter)                 
  276. #        self._copyImageMap(self.opacity_map, exporter)
  277. #        self._copyImageMap(self.bump_map, exporter)
  278. #        self._copyImageMap(self.specular_map, exporter)
  279. #        self._copyImageMap(self.shininess_map, exporter)
  280. #        self._copyImageMap(self.self_illum_map, exporter)
  281. #        self._copyImageMap(self.reflection_map, exporter)
  282.             
  283.  
  284.     def color(self):
  285.         """Return the color for the RiColor() call or None.
  286.         """
  287.         return self.diffuse
  288.  
  289.     def opacity(self):
  290.         """Return the opacity for the RiOpacity() call or None.
  291.         """
  292.         a = 1.0-self.transparency
  293.         return (a,a,a)
  294.  
  295.     def surfaceShaderName(self):
  296.         """Returns the name of the corresponding surface shader or None.
  297.         """
  298.         return "mat3ds"
  299.  
  300.     def surfaceShaderSource(self):
  301.         """Returns surface shader source code as a string or None.
  302.  
  303.         If the return value is None, then shaderName() must return
  304.         the name of the shader to use.
  305.         """
  306.         return """// 3DS material shader
  307.         
  308. surface $SHADERNAME(color ambient_col = color "rgb" (0, 0, 0);
  309.            color diffuse_col = color "rgb" (1, 1, 1);
  310.            color specular_col = color "rgb" (1, 1, 1);
  311.            float shininess = 0.0;
  312.            float shin_strength = 0.0;
  313.            float self_ilpct = 0.0;
  314.            // Texture map 1
  315.            string texture1_map = "";
  316.            float t1_uscale = 1.0;
  317.            float t1_vscale = 1.0;
  318.            float t1_uoffset = 0;
  319.            float t1_voffset = 0;
  320.            float t1_rotation = 0;
  321.            float t1_blur = 0.0;
  322.            // Specular map
  323.            string specular_map = "";
  324.            float sp_uscale = 1.0;
  325.            float sp_vscale = 1.0;
  326.            float sp_uoffset = 0;
  327.            float sp_voffset = 0;
  328.            float sp_rotation = 0;
  329.            float sp_blur = 0.0;
  330.            // Shininess map
  331.            string shininess_map = "";
  332.            float sh_uscale = 1.0;
  333.            float sh_vscale = 1.0;
  334.            float sh_uoffset = 0;
  335.            float sh_voffset = 0;
  336.            float sh_rotation = 0;
  337.            float sh_blur = 0.0;
  338.            // Opacity map
  339.            string opacity_map = "";
  340.            float op_uscale = 1.0;
  341.            float op_vscale = 1.0;
  342.            float op_uoffset = 0;
  343.            float op_voffset = 0;
  344.            float op_rotation = 0;
  345.            float op_blur = 0.0;
  346.            // Self illumination map
  347.            string self_illum_map = "";
  348.            float si_uscale = 1.0;
  349.            float si_vscale = 1.0;
  350.            float si_uoffset = 0;
  351.            float si_voffset = 0;
  352.            float si_rotation = 0;
  353.            float si_blur = 0.0;
  354.            // Reflection map
  355.            string reflection_map = "";
  356.            float refl_uscale = 1.0;
  357.            float refl_vscale = 1.0;
  358.            float refl_uoffset = 0;
  359.            float refl_voffset = 0;
  360.            float refl_rotation = 0;
  361.            float refl_percent = 0.0;
  362.            float refl_blur = 0.0;
  363.            varying point Pref = point(0,0,0);
  364.            )
  365. {
  366.   BAKE_BEGIN
  367.   normal Nf = BAKE_NORMAL(N);
  368.   color C_diffuse = diffuse_col;
  369.   color C_specular = specular_col;
  370.   color C_opacity = Os;
  371.   color C_refl = 0;
  372.   float final_shininess = shininess;
  373.   float final_self_ilpct = self_ilpct;
  374.   float s0, t0, ss, tt, a, ca, sa;
  375.   color col;
  376.  
  377.   if (texture1_map!="")
  378.   {
  379.     a = radians(t1_rotation);
  380.     ca = cos(a);
  381.     sa = sin(a);
  382.     s0 = s-t1_uoffset-0.5;
  383.     t0 = 0.5-t-t1_voffset;
  384.     ss = ca*s0 - sa*t0;
  385.     tt = sa*s0 + ca*t0;
  386.     ss = t1_uscale*ss+0.5;
  387.     tt = t1_vscale*tt+0.5;
  388.     C_diffuse = texture(texture1_map, ss, tt, "blur", t1_blur);
  389.   }
  390.  
  391.   if (specular_map!="")
  392.   {
  393.     a = radians(sp_rotation);
  394.     ca = cos(a);
  395.     sa = sin(a);
  396.     s0 = s-sp_uoffset-0.5;
  397.     t0 = 0.5-t-sp_voffset;
  398.     ss = ca*s0 - sa*t0;
  399.     tt = sa*s0 + ca*t0;
  400.     ss = sp_uscale*ss+0.5;
  401.     tt = sp_vscale*tt+0.5;
  402.     C_specular = texture(specular_map, ss, tt, "blur", sp_blur);
  403.   }
  404.  
  405.   if (shininess_map!="")
  406.   {
  407.     a = radians(sh_rotation);
  408.     ca = cos(a);
  409.     sa = sin(a);
  410.     s0 = s-sh_uoffset-0.5;
  411.     t0 = 0.5-t-sh_voffset;
  412.     ss = ca*s0 - sa*t0;
  413.     tt = sa*s0 + ca*t0;
  414.     ss = sh_uscale*ss+0.5;
  415.     tt = sh_vscale*tt+0.5;
  416.     col = texture(shininess_map, ss, tt, "blur", sh_blur);
  417.     final_shininess = (comp(col,0)+comp(col,1)+comp(col,2))/3;
  418.   }
  419.  
  420.   if (opacity_map!="")
  421.   {
  422.     a = radians(op_rotation);
  423.     ca = cos(a);
  424.     sa = sin(a);
  425.     s0 = s-op_uoffset-0.5;
  426.     t0 = 0.5-t-op_voffset;
  427.     ss = ca*s0 - sa*t0;
  428.     tt = sa*s0 + ca*t0;
  429.     ss = op_uscale*ss+0.5;
  430.     tt = op_vscale*tt+0.5;
  431.     float op = texture(opacity_map, ss, tt, "blur", op_blur);
  432.     C_opacity = color "rgb" (op, op, op);
  433.   }
  434.  
  435.   if (self_illum_map!="")
  436.   {
  437.     a = radians(si_rotation);
  438.     ca = cos(a);
  439.     sa = sin(a);
  440.     s0 = s-si_uoffset-0.5;
  441.     t0 = 0.5-t-si_voffset;
  442.     ss = ca*s0 - sa*t0;
  443.     tt = sa*s0 + ca*t0;
  444.     ss = si_uscale*ss+0.5;
  445.     tt = si_vscale*tt+0.5;
  446.     col = texture(self_illum_map, ss, tt, "blur", si_blur);
  447.     final_self_ilpct = (comp(col,0)+comp(col,1)+comp(col,2))/3;
  448.   }
  449.  
  450.   if (reflection_map!="")
  451.   {
  452.     vector R = normalize(vtransform("world", reflect(I, Nf)));
  453.     float lat = acos(zcomp(R));
  454.     float long = acos(ycomp(R)/sin(lat));
  455.     lat = lat/PI;
  456.     long = long/(2*PI);
  457.     if (xcomp(R)>0)
  458.       long = -long;
  459.     C_refl = texture(reflection_map, long, lat, "blur", refl_blur);
  460.   }
  461.  
  462.   Ci = C_diffuse*diffuse(Nf) +
  463.        shin_strength*C_specular*phong(Nf, -normalize(I), 25*final_shininess) +
  464.        refl_percent*C_refl;
  465.   Ci = mix(Ci, C_diffuse, final_self_ilpct);
  466.   Oi = C_opacity;
  467.   Ci *= Oi;
  468.   BAKE_END
  469. }        
  470.         """
  471.  
  472.     def surfaceShaderParams(self, passes):
  473.         """Return a dictionary with shader parameters and their values."""
  474.         a = self.ambient
  475.         d = self.diffuse
  476.         s = self.specular
  477.         res = {"uniform color ambient_col" : (a[0], a[1], a[2]),
  478.                 "uniform color diffuse_col" : (d[0], d[1], d[2]),
  479.                 "uniform color specular_col" : (s[0], s[1], s[2]),
  480.                 "uniform float shininess" : self.shininess,
  481.                 "uniform float shin_strength" : self.shin_strength,
  482.                 "uniform float self_ilpct" : self.self_ilpct
  483.                 }
  484.  
  485.         if self.texture1_map!=None:
  486.             texname = os.path.basename(self.texture1_map.name)
  487.             name, ext = os.path.splitext(texname)
  488.             res["uniform string texture1_map"] = name+".tex"
  489.             res["uniform float t1_uscale"] = self.texture1_map.scale[0]
  490.             res["uniform float t1_vscale"] = self.texture1_map.scale[1]
  491.             res["uniform float t1_uoffset"] = self.texture1_map.offset[0]
  492.             res["uniform float t1_voffset"] = self.texture1_map.offset[1]
  493.             res["uniform float t1_rotation"] = self.texture1_map.rotation
  494.  
  495.         if self.specular_map!=None:
  496.             texname = os.path.basename(self.specular_map.name)
  497.             name, ext = os.path.splitext(texname)
  498.             res["uniform string specular_map"] = name+".tex"
  499.             res["uniform float sp_uscale"] = self.specular_map.scale[0]
  500.             res["uniform float sp_vscale"] = self.specular_map.scale[1]
  501.             res["uniform float sp_uoffset"] = self.specular_map.offset[0]
  502.             res["uniform float sp_voffset"] = self.specular_map.offset[1]
  503.             res["uniform float sp_rotation"] = self.specular_map.rotation
  504.  
  505.         if self.shininess_map!=None:
  506.             texname = os.path.basename(self.shininess_map.name)
  507.             name, ext = os.path.splitext(texname)
  508.             res["uniform string shininess_map"] = name+".tex"
  509.             res["uniform float sh_uscale"] = self.shininess_map.scale[0]
  510.             res["uniform float sh_vscale"] = self.shininess_map.scale[1]
  511.             res["uniform float sh_uoffset"] = self.shininess_map.offset[0]
  512.             res["uniform float sh_voffset"] = self.shininess_map.offset[1]
  513.             res["uniform float sh_rotation"] = self.shininess_map.rotation
  514.  
  515.         if self.opacity_map!=None:
  516.             texname = os.path.basename(self.opacity_map.name)
  517.             name, ext = os.path.splitext(texname)
  518.             res["uniform string opacity_map"] = name+".tex"
  519.             res["uniform float op_uscale"] = self.opacity_map.scale[0]
  520.             res["uniform float op_vscale"] = self.opacity_map.scale[1]
  521.             res["uniform float op_uoffset"] = self.opacity_map.offset[0]
  522.             res["uniform float op_voffset"] = self.opacity_map.offset[1]
  523.             res["uniform float op_rotation"] = self.opacity_map.rotation
  524.  
  525.         if self.self_illum_map!=None:
  526.             texname = os.path.basename(self.self_illum_map.name)
  527.             name, ext = os.path.splitext(texname)
  528.             res["uniform string self_illum_map"] = name+".tex"
  529.             res["uniform float si_uscale"] = self.self_illum_map.scale[0]
  530.             res["uniform float si_vscale"] = self.self_illum_map.scale[1]
  531.             res["uniform float si_uoffset"] = self.self_illum_map.offset[0]
  532.             res["uniform float si_voffset"] = self.self_illum_map.offset[1]
  533.             res["uniform float si_rotation"] = self.self_illum_map.rotation
  534.  
  535.         if self.reflection_map!=None:
  536.             texname = os.path.basename(self.reflection_map.name)
  537.             name, ext = os.path.splitext(texname)
  538.             res["uniform string reflection_map"] = name+".tex"
  539.             res["uniform float refl_uscale"] = self.reflection_map.scale[0]
  540.             res["uniform float refl_vscale"] = self.reflection_map.scale[1]
  541.             res["uniform float refl_uoffset"] = self.reflection_map.offset[0]
  542.             res["uniform float refl_voffset"] = self.reflection_map.offset[1]
  543.             res["uniform float refl_rotation"] = self.reflection_map.rotation
  544.             res["uniform float refl_percent"] = self.reflection_map.percent
  545.             res["uniform float refl_blur"] = self.reflection_map.blur
  546.  
  547.         return res
  548.  
  549.     def surfaceShaderTransform(self):
  550.         return mat4(1)
  551.  
  552.     def displacementShaderName(self):
  553.         if self.bump_map==None:
  554.             return None
  555.         
  556.         return "mat3ds_bump"
  557.  
  558.     
  559.     def displacementShaderSource(self):
  560.         if self.bump_map==None:
  561.             return None
  562.         
  563.         return """// 3DS material shader (bump)
  564.         
  565. displacement $SHADERNAME(
  566.            // Bump map
  567.            string bump_map = "";
  568.            float uscale = 1.0;
  569.            float vscale = 1.0;
  570.            float uoffset = 0;
  571.            float voffset = 0;
  572.            float rotation = 0;
  573.            float blur = 0;
  574.            float bump_size = 1.0;
  575.            )
  576. {
  577.   float s0, t0, ss, tt, a, ca, sa;
  578.   color bc;
  579.   float amount = 0.0;
  580.  
  581.   if (bump_map!="")
  582.   {
  583.     a = radians(rotation);
  584.     ca = cos(a);
  585.     sa = sin(a);
  586.     s0 = s-uoffset-0.5;
  587.     t0 = 0.5-t-voffset;
  588.     ss = ca*s0 - sa*t0;
  589.     tt = sa*s0 + ca*t0;
  590.     ss = uscale*ss+0.5;
  591.     tt = vscale*tt+0.5;
  592.     bc = texture(bump_map, ss, tt, "blur", blur);
  593.     amount = (comp(bc,0)+comp(bc,1)+comp(bc,2))/3;
  594.   }
  595.  
  596.   P = P - bump_size*amount*normalize(N);
  597.   N = calculatenormal(P);
  598. }
  599.         """
  600.     
  601.     def displacementShaderParams(self, passes):
  602.         if self.bump_map==None:
  603.             return {}
  604.  
  605.         res = {}
  606.         texname = os.path.basename(self.bump_map.name)
  607.         name, ext = os.path.splitext(texname)
  608.         res["uniform string bump_map"] = name+".tex"
  609.         res["uniform float uscale"] = self.bump_map.scale[0]
  610.         res["uniform float vscale"] = self.bump_map.scale[1]
  611.         res["uniform float uoffset"] = self.bump_map.offset[0]
  612.         res["uniform float voffset"] = self.bump_map.offset[1]
  613.         res["uniform float rotation"] = self.bump_map.rotation
  614.         res["uniform float blur"] = self.bump_map.blur
  615.         res["uniform float bump_size"] = self.bump_size
  616.         return res
  617.  
  618.     def displacementBound(self):
  619.         if self.bump_map==None:
  620.             return "current", 0
  621.         else:
  622.             return "current", self.bump_size
  623.  
  624.     def displacementShaderTransform(self):
  625.         return mat4(1)
  626.     
  627.     def interiorShaderName(self):
  628.         return None
  629.     
  630.     def interiorShaderSource(self):
  631.         return None
  632.     
  633.     def interiorShaderParams(self, passes):
  634.         return {}
  635.  
  636.     def interiorShaderTransform(self):
  637.         return mat4(1)
  638.  
  639.  
  640. ##    def _copyImageMap(self, texmap, exporter):
  641. ##        """Copy the texture map image into the map folder.
  642.  
  643. ##        \param texmap (\c TextureMap3DS) Texture map object or None
  644. ##        \param exporter Exporter instance
  645. ##        """
  646. ##        return
  647. ##        if texmap==None:
  648. ##            return
  649.  
  650. ##        exporter.checkMapPath()
  651. ##        texname = os.path.basename(texmap.name)
  652. ##        name, ext = os.path.splitext(texname)
  653. ##        if ext.lower()!=".tif":
  654. ##            print 'Converting "%s"'%texmap.name
  655. ##            tifname = os.path.join(exporter.map_path, name+".tif")
  656. ##            # Read original map
  657. ##            try:
  658. ##                img = Image.open(texmap.name)
  659. ##            except IOError, e:
  660. ##                print e
  661. ##                return
  662. ##            # Save map as TIF file
  663. ##            img.save(tifname)
  664. ##        else:
  665. ##            print 'Copying "%s"'%texmap.name
  666. ##            shutil.copyfile(texmap.name, os.path.join(exporter.map_path, texmap.name))
  667.          
  668.  
  669.     def _createTexDef(self, texmap):
  670.         """Create texture definition for the TexPass.
  671.  
  672.         The method returns a list that is either empty or contains
  673.         one texture definition tuple.
  674.  
  675.         \param texmap (\c TextureMap3DS) Texture map object or None
  676.         \return An empty list or a list containing one texture def
  677.         """
  678.         if texmap==None:
  679.             return []
  680.         
  681. #        texname = os.path.basename(texmap.name)
  682.         texname = texmap.name
  683. #        texname, ext = os.path.splitext(texname)
  684.         blur = texmap.blur+1.0
  685.         texdef = (texname, #+".tif",
  686.                   "periodic", "periodic",
  687.                   "gaussian", blur, blur, {})
  688.         return [texdef]
  689.         
  690.