25/01/12 0.18
[blender-addons-contrib.git] / io_directx_bel / bel / image.py
1 import bpy
2 import bpy.path
3
4 from . import __init__ as bel
5 from . import fs
6
7 debuglevel = 0
8
9 def dprint(str,l=2) :
10     if l <= debuglevel :
11         print(str)
12
13 # create or retrieve a bdata image
14 # given its path 
15 def new(path, name=False, relative = True, premul = True) :
16     path = fs.clean(path)
17     # check file
18     if fs.isfile(path) == False :
19         dprint('Texture image not found')
20         return False
21
22     if relative :
23         try :
24             path = bpy.path.relpath(path)
25             path = fs.clean(path)
26         except : 
27             print('cant turn path into relative one (.blend and img path drive letters ?) ')
28         
29     # retrieve paths to image file from existing image slot
30     # returns img if paths match
31     for img in bpy.data.images :
32         if img.filepath != '' :
33             if bpy.path.abspath(path) == bpy.path.abspath(fs.clean(img.filepath)) :
34                 return img
35
36     # create a unique name in image slot
37     if name == False : 
38         name = bpy.path.basename(path)
39     name = bel.bpyname(name,bpy.data.images.keys())
40
41     # finally :
42     img = bpy.data.images.load(filepath=path)
43     img.name = name
44     img.use_premultiply = premul
45     return img
46
47
48 def applyShader(mat,config) :
49
50     # matslot.link = 'DATA'
51     #mat = bpy.data.materials['Female_Body']
52
53     texslot = mat.texture_slots[0]
54     tex = texslot.texture
55     img = tex.image
56     
57     #config = shaders[shadername]
58     alpha = True if 'alpha' in config else False
59
60     ## MAT
61
62     mat.type = 'SURFACE'
63     # diffuse
64     mat.diffuse_color = Color((0.6, 0.6, 0.6))
65     mat.diffuse_intensity = 0.8
66     mat.diffuse_shader = 'LAMBERT'
67     mat.use_diffuse_ramp = False
68
69     # specular
70     mat.specular_color = Color((1.0, 1.0, 1.0))
71     mat.specular_intensity = 0.25
72     mat.specular_shader = 'COOKTORR'
73     mat.use_specular_ramp = False
74     mat.specular_hardness = 1.0
75
76     # shading
77     mat.emit = 0.0
78     mat.ambient = 0.5
79     mat.translucency = 0.0
80     mat.use_shadeless = False
81     mat.use_tangent_shading = False
82     mat.use_cubic = False
83
84     # transparency
85     mat.use_transparency = alpha
86     mat.transparency_method = 'Z_TRANSPARENCY'
87     mat.alpha = not(alpha)
88     mat.specular_alpha = not(alpha)
89     mat.raytrace_transparency.fresnel = 0.0
90     mat.raytrace_transparency.fresnel_factor = 1.25
91
92     # mirror
93     mat.raytrace_mirror.use = False
94
95     # subsurface_scattering
96     mat.subsurface_scattering.use
97
98     # strand
99     # options
100     # shadow
101     mat.use_shadows = True
102     mat.use_transparent_shadows = True
103     mat.use_cast_shadows_only = False
104     mat.shadow_cast_alpha = 1.0
105     mat.use_only_shadow = False
106     mat.shadow_only_type = 'SHADOW_ONLY_OLD'
107     mat.use_cast_buffer_shadows = True
108     mat.shadow_buffer_bias = 0.0
109     mat.use_ray_shadow_bias = True
110     mat.shadow_ray_bias = 0.0
111     mat.use_cast_approximate = True
112
113     # TEXTURE SLOT 0
114
115     # diffuse
116     texslot.diffuse_factor = 1.0
117     texslot.use_map_diffuse = True
118     texslot.diffuse_color_factor = 1.0
119     texslot.use_map_color_diffuse = True
120     texslot.alpha_factor = 1.0
121     texslot.use_map_alpha = alpha
122     texslot.translucency_factor = 0.0
123     texslot.use_map_translucency = False
124
125     # specular
126     texslot.specular_factor = 0.3
127     texslot.use_map_specular = True
128     texslot.specular_color_factor = 1.0
129     texslot.use_map_color_spec = True
130     texslot.hardness_factor = 0.1
131     texslot.use_map_hardness = True
132
133     # shading
134     texslot.ambient_factor = 0.0
135     texslot.use_map_ambient = False
136     texslot.emit_factor = 0.1
137     texslot.use_map_emit = True
138     texslot.mirror_factor = 0.0
139     texslot.use_map_mirror = False
140     texslot.raymir_factor = 0.0
141     texslot.use_map_raymir = False
142
143     # geometry
144     texslot.normal_factor = 0.0
145     texslot.use_map_normal = False
146     texslot.warp_factor = 0.1
147     texslot.use_map_warp = False
148     texslot.displacement_factor = 0.0
149     texslot.use_map_displacement = False
150
151     texslot.blend_type = 'MIX'
152     texslot.invert = False
153     texslot.use_rgb_to_intensity = False
154     texslot.color = Color((1.0, 0.0, 1.0)) # default
155     texslot.use_stencil = False
156     texslot.default_value = 1.0
157
158     # TEXTURE
159     tex.use_alpha = alpha
160     tex.use_preview_alpha = alpha
161
162     # IMAGE
163     if type(img) != type(None) :
164         img.use_premultiply = True
165
166 def BSshader(nodes,pointer) :
167     tkm = bpy.context.scene.tkm
168     typ, nodename = pointer.split(' ')
169     RenderShader = nodes[typ][nodename]
170     name = BSname(nodename,RenderShader['Object.Name'])
171     if name in bpy.data.materials :
172         mat = bpy.data.materials[name]
173     else :
174         mat = bpy.data.materials.new(name=name)
175         # Unused
176         DepthWriteEnable = RenderShader['DepthWriteEnable'] if 'DepthWriteEnable' in RenderShader else False # an integer
177         ShaderTransparency = RenderShader['MultiDrawLayer'] if 'MultiDrawLayer' in RenderShader else False # an integer
178         LightEnable = RenderShader['LightEnable'] if 'LightEnable' in RenderShader else False # an integer
179
180         ShaderPhong = BSnode(nodes,RenderShader['Surface'])
181         #print('mat : %s'%ShaderPhong['Material'])
182         RenderMaterial = BSnode(nodes,ShaderPhong['Material'])
183         DiffuseColor = RenderMaterial['DiffuseColor'] if 'DiffuseColor' in RenderMaterial else False
184         SpecularColor = RenderMaterial['SpecularColor'] if 'SpecularColor' in RenderMaterial else False
185         AmbientColor = RenderMaterial['AmbientColor'] if 'AmbientColor' in RenderMaterial else False
186         EmissionColor = RenderMaterial['Shininess'] if 'EmissionColor' in RenderMaterial else False
187         Shininess = RenderMaterial['Shininess'] if 'Shininess' in RenderMaterial else False
188         Transparency = RenderMaterial['Transparency'] if 'Transparency' in RenderMaterial else False
189         for key in RenderMaterial.keys() :
190             if key not in ['DiffuseColor','SpecularColor','AmbientColor','EmissionColor','Shininess','Transparency'] :
191                 print('NEW RENDERMATERIAL PROP ! : %s'%key)
192         
193         #print(AmbientColor)
194         if DiffuseColor : mat.diffuse_color = Color(DiffuseColor) #[0][0],DiffuseColor[0][1],DiffuseColor[0][2])
195         if SpecularColor : mat.specular_color = Color(SpecularColor)#[0][0],SpecularColor[0][1],SpecularColor[0][2])
196         if AmbientColor : mat.ambient = AmbientColor[0] # source value is a vector3f with x=y=z 
197         if EmissionColor : mat.emit = EmissionColor[0] # source value is a vector3f with x=y=z 
198         #if Shininess : mat.
199         #alpha is a boolean, whereas Transparency is a float or False
200         if Transparency :
201             mat.use_transparency = True
202             mat.transparency_method = 'Z_TRANSPARENCY'
203             mat.alpha = Transparency
204             mat.specular_alpha = 0
205             alpha = True
206         else : alpha = False
207         texinfluence = False
208         if 'Color' in ShaderPhong :
209             ShaderTexture = BSnode(nodes,ShaderPhong['Color'])
210             texinfluence = 'Color'
211         if 'Reflection' in ShaderPhong :
212             ShaderTexture = BSnode(nodes,ShaderPhong['Reflection'])
213             texinfluence = 'Reflection'
214         if texinfluence == False :
215             print('neither color nor refl. in ShaderPhong %s'%RenderShader['Surface'])
216             print('other props are : %s'%ShaderPhong.keys())
217             return mat
218
219         ShaderTextureName = ShaderTexture['Object.Name']
220
221         Texture2D = BSnode(nodes,ShaderTexture['Texture'])
222         Texture2DName = Texture2D['Object.Name']
223
224         FileObject = BSnode(nodes,Texture2D['Texture.FileObject'])
225         imgpath = FileObject['FileName']
226         imgname = imgpath.split('/')[-1]
227         imgpath = tkm.path_archives+'/Images/Q=Tex032M/'+imgpath
228
229         if imgname not in bpy.data.images :        
230             if os.path.isfile(imgpath+'.png') : ext = '.png'
231             elif os.path.isfile(imgpath+'.jp2') : ext = '.jp2'
232             else :
233                 print('Texture image not found ! %s'%Texture2D['Texture.FileObject'])
234                 print('path : %s.png or .jp2 '%imgpath)
235                 return mat
236             img = bpy.data.images.load(filepath=imgpath+ext)
237             img.name = imgname
238             img.use_premultiply = True
239         else : img = bpy.data.images[imgname]
240         
241         '''
242         texslot = mat.texture_slots[0]
243         mat.texture_slots[0]
244         tex = texslot.texture
245         tex.type = 'IMAGE'
246         img = tex.image        
247         img.name
248         '''
249         #img = bpy.data.images.new(name='imgname',width=640, height=512)
250
251         if ShaderTextureName not in bpy.data.textures :
252             tex = bpy.data.textures.new(name=ShaderTextureName,type='IMAGE')
253             tex.image = img
254             tex.use_alpha = alpha
255             tex.use_preview_alpha = alpha
256         else : tex = bpy.data.textures[ShaderTextureName]
257
258         texslot = mat.texture_slots.create(index=0)
259         texslot.texture = tex
260         texslot.texture_coords = 'UV'
261         texslot.uv_layer = 'UV0'
262         texslot.use_map_alpha = alpha
263         texslot.alpha_factor = 1.0
264
265     return mat