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