← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/blender/gutsy-security

« back to all changes in this revision

Viewing changes to release/scripts/mesh_solidify.py

  • Committer: Bazaar Package Importer
  • Author(s): Florian Ernst
  • Date: 2007-05-17 11:47:59 UTC
  • mfrom: (1.2.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20070517114759-yp4ybrnhp2u7pk66
Tags: 2.44-1
* New upstream release.
* Drop debian/patches/01_64bits_stupidity, not needed anymore: as of this
  version blender is 64 bits safe again. Adjust README.Debian accordingly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
release/scripts/mesh_solidify.py
15
15
Optionaly you can skin between the original and new faces to make a watertight solid object
16
16
"""
17
17
 
 
18
# -------------------------------------------------------------------------- 
 
19
# Solidify Selection 1.0 by Campbell Barton (AKA Ideasman42) 
 
20
# -------------------------------------------------------------------------- 
 
21
# ***** BEGIN GPL LICENSE BLOCK ***** 
 
22
# 
 
23
# This program is free software; you can redistribute it and/or 
 
24
# modify it under the terms of the GNU General Public License 
 
25
# as published by the Free Software Foundation; either version 2 
 
26
# of the License, or (at your option) any later version. 
 
27
# 
 
28
# This program is distributed in the hope that it will be useful, 
 
29
# but WITHOUT ANY WARRANTY; without even the implied warranty of 
 
30
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 
31
# GNU General Public License for more details. 
 
32
# 
 
33
# You should have received a copy of the GNU General Public License 
 
34
# along with this program; if not, write to the Free Software Foundation, 
 
35
# Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. 
 
36
# 
 
37
# ***** END GPL LICENCE BLOCK ***** 
 
38
# -------------------------------------------------------------------------- 
18
39
 
19
40
from Blender import *
 
41
import bpy
20
42
import BPyMesh
21
43
# reload(BPyMesh)
22
44
import BPyMessages
23
45
# reload(BPyMessages)
24
46
 
 
47
from BPyMathutils import angleToLength
 
48
 
25
49
# python 2.3 has no reversed() iterator. this will only work on lists and tuples
26
50
try:
27
51
        reversed
73
97
Ang= Mathutils.AngleBetweenVecs
74
98
SMALL_NUM=0.00001
75
99
 
76
 
 
77
 
# returns a length from an angle
78
 
# Imaging a 2d space.
79
 
# there is a hoz line at Y1 going to inf on both X ends, never moves (LINEA)
80
 
# down at Y0 is a unit length line point up at (angle) from X0,Y0 (LINEB)
81
 
# This function returns the length of LINEB at the point it would intersect LINEA
82
 
# - Use this for working out how long to make the vector - differencing it from surrounding faces,
83
 
# import math
84
 
from math import pi, sin, cos, sqrt
85
 
 
86
 
def lengthFromAngle(angle):
87
 
        ''' # Alredy accounted for
88
 
        if angle < SMALL_NUM:
89
 
                return 1.0
90
 
        '''
91
 
        angle = 2*pi*angle/360
92
 
        x,y = cos(angle), sin(angle)
93
 
        # print "YX", x,y
94
 
        # 0 d is hoz to the right.
95
 
        # 90d is vert upward.
96
 
        fac=1/x
97
 
        x=x*fac
98
 
        y=y*fac
99
 
        return sqrt((x*x)+(y*y))
100
 
 
101
 
 
102
 
def main():
103
 
        scn = Scene.GetCurrent()
104
 
        ob = scn.objects.active
105
 
        
106
 
        if not ob or ob.type != 'Mesh':
107
 
                BPyMessages.Error_NoMeshActive()
108
 
                return
109
 
        
110
 
        me = ob.getData(mesh=1)
111
 
        if me.multires:
112
 
                BPyMessages.Error_NoMeshMultiresEdit()
113
 
                return
114
 
        
115
 
        # Create the variables.
116
 
        PREF_THICK = Draw.Create(-0.1)
117
 
        PREF_SKIN_SIDES= Draw.Create(1)
118
 
        PREF_REM_ORIG= Draw.Create(0)
119
 
        
120
 
        pup_block = [\
121
 
        ('Thick:', PREF_THICK, -10, 10, 'Skin thickness in mesh space.'),\
122
 
        ('Skin Sides', PREF_SKIN_SIDES, 'Skin between the original and new faces.'),\
123
 
        ('Remove Original', PREF_REM_ORIG, 'Remove the selected faces after skinning.'),\
124
 
        ]
125
 
        
126
 
        if not Draw.PupBlock('Solid Skin Selection', pup_block):
127
 
                return
128
 
        
129
 
        PREF_THICK= PREF_THICK.val
130
 
        PREF_SKIN_SIDES= PREF_SKIN_SIDES.val
131
 
        PREF_REM_ORIG= PREF_REM_ORIG.val
132
 
        
133
 
        Window.WaitCursor(1)
134
 
        
135
 
        is_editmode = Window.EditMode() 
136
 
        if is_editmode: Window.EditMode(0)
 
100
def solidify(me, PREF_THICK, PREF_SKIN_SIDES=True, PREF_REM_ORIG=False, PREF_COLLAPSE_SIDES=False):
137
101
        
138
102
        # Main code function
139
 
        me = ob.getData(mesh=1)
140
103
        me_faces = me.faces
141
104
        faces_sel= [f for f in me_faces if f.sel]
142
105
        
143
 
        
144
106
        BPyMesh.meshCalcNormals(me)
145
107
        normals= [v.no for v in me.verts]
146
108
        vertFaces= [[] for i in xrange(len(me.verts))]
163
125
                                elif a < SMALL_NUM:
164
126
                                        length+= 1
165
127
                                else:
166
 
                                        length+= lengthFromAngle(a)
 
128
                                        length+= angleToLength(a)
167
129
                        
168
130
                        length= length/len(vertFaces[i])
169
131
                        #print 'LENGTH %.6f' % length
216
178
        """
217
179
        copy_facedata_multilayer(me, faces_sel, [me_faces[len_faces + i] for i in xrange(len(faces_sel))])
218
180
        
219
 
        if PREF_SKIN_SIDES:
 
181
        if PREF_SKIN_SIDES or PREF_COLLAPSE_SIDES:
220
182
                skin_side_faces= []
221
183
                skin_side_faces_orig= []
222
184
                # Get edges of faces that only have 1 user - so we can make walls
238
200
                                                edges[edgekey] = f, f_v, i, ROT_QUAD_INDEX[i+1]
239
201
                del ROT_QUAD_INDEX, ROT_TRI_INDEX
240
202
                
 
203
                # So we can remove doubles with edges only.
 
204
                if PREF_COLLAPSE_SIDES:
 
205
                        me.sel = False
241
206
                
242
207
                # Edges are done. extrude the single user edges.
243
208
                for edge_face_data in edges.itervalues():
244
209
                        if edge_face_data: # != None
245
210
                                f, f_v, i1, i2 = edge_face_data
246
211
                                v1i,v2i= f_v[i1].index, f_v[i2].index
247
 
                                # Now make a new Face
248
 
                                # skin_side_faces.append( (v1i, v2i, vert_mapping[v2i], vert_mapping[v1i]) )
249
 
                                skin_side_faces.append( (v2i, v1i, vert_mapping[v1i], vert_mapping[v2i]) )
250
 
                                skin_side_faces_orig.append((f, len(me_faces) + len(skin_side_faces_orig), i1, i2))
251
 
                
252
 
                me_faces.extend(skin_side_faces)
253
 
                
254
 
                
255
 
                
256
 
                # Now assign properties.
257
 
                """
258
 
                # Before MultiUVs
259
 
                for i, origfData in enumerate(skin_side_faces_orig):
260
 
                        orig_f, new_f_idx, i1, i2 = origfData
261
 
                        new_f= me_faces[new_f_idx]
262
 
                        
263
 
                        new_f.mat= orig_f.mat
264
 
                        new_f.smooth= orig_f.smooth
265
 
                        if has_uv:
266
 
                                new_f.mode= orig_f.mode
267
 
                                new_f.flag= orig_f.flag
268
 
                                if orig_f.image:
 
212
                                
 
213
                                if PREF_COLLAPSE_SIDES:
 
214
                                        # Collapse
 
215
                                        cv1 = me.verts[v1i]
 
216
                                        cv2 = me.verts[vert_mapping[v1i]]
 
217
                                        
 
218
                                        cv3 = me.verts[v2i]
 
219
                                        cv4 = me.verts[vert_mapping[v2i]]
 
220
                                        
 
221
                                        cv1.co = cv2.co = (cv1.co+cv2.co)/2
 
222
                                        cv3.co = cv4.co = (cv3.co+cv4.co)/2
 
223
                                        
 
224
                                        cv1.sel=cv2.sel=cv3.sel=cv4.sel=True
 
225
                                        
 
226
                                        
 
227
                                        
 
228
                                else:
 
229
                                        # Now make a new Face
 
230
                                        # skin_side_faces.append( (v1i, v2i, vert_mapping[v2i], vert_mapping[v1i]) )
 
231
                                        skin_side_faces.append( (v2i, v1i, vert_mapping[v1i], vert_mapping[v2i]) )
 
232
                                        skin_side_faces_orig.append((f, len(me_faces) + len(skin_side_faces_orig), i1, i2))
 
233
                
 
234
                if PREF_COLLAPSE_SIDES:
 
235
                        me.remDoubles(0.0001)
 
236
                else:
 
237
                        me_faces.extend(skin_side_faces)
 
238
                        # Now assign properties.
 
239
                        """
 
240
                        # Before MultiUVs
 
241
                        for i, origfData in enumerate(skin_side_faces_orig):
 
242
                                orig_f, new_f_idx, i1, i2 = origfData
 
243
                                new_f= me_faces[new_f_idx]
 
244
                                
 
245
                                new_f.mat= orig_f.mat
 
246
                                new_f.smooth= orig_f.smooth
 
247
                                if has_uv:
 
248
                                        new_f.mode= orig_f.mode
 
249
                                        new_f.flag= orig_f.flag
 
250
                                        if orig_f.image:
 
251
                                                new_f.image= orig_f.image
 
252
                                        
 
253
                                        uv1= orig_f.uv[i1]
 
254
                                        uv2= orig_f.uv[i2]
 
255
                                        new_f.uv= (uv1, uv2, uv2, uv1)
 
256
                                
 
257
                                if has_vcol:
 
258
                                        col1= orig_f.col[i1]
 
259
                                        col2= orig_f.col[i2]
 
260
                                        new_f.col= (col1, col2, col2, col1)
 
261
                        """
 
262
                        
 
263
                        for i, origfData in enumerate(skin_side_faces_orig):
 
264
                                orig_f, new_f_idx, i2, i1 = origfData
 
265
                                new_f= me_faces[new_f_idx]
 
266
                                
 
267
                                new_f.mat= orig_f.mat
 
268
                                new_f.smooth= orig_f.smooth
 
269
                        
 
270
                        for uvlayer in me.getUVLayerNames():
 
271
                                me.activeUVLayer = uvlayer
 
272
                                for i, origfData in enumerate(skin_side_faces_orig):
 
273
                                        orig_f, new_f_idx, i2, i1 = origfData
 
274
                                        new_f= me_faces[new_f_idx]
 
275
                                        
 
276
                                        new_f.mode= orig_f.mode
 
277
                                        new_f.flag= orig_f.flag
269
278
                                        new_f.image= orig_f.image
270
 
                                
271
 
                                uv1= orig_f.uv[i1]
272
 
                                uv2= orig_f.uv[i2]
273
 
                                new_f.uv= (uv1, uv2, uv2, uv1)
274
 
                        
275
 
                        if has_vcol:
276
 
                                col1= orig_f.col[i1]
277
 
                                col2= orig_f.col[i2]
278
 
                                new_f.col= (col1, col2, col2, col1)
279
 
                """
280
 
                
281
 
                for i, origfData in enumerate(skin_side_faces_orig):
282
 
                        orig_f, new_f_idx, i2, i1 = origfData
283
 
                        new_f= me_faces[new_f_idx]
284
 
                        
285
 
                        new_f.mat= orig_f.mat
286
 
                        new_f.smooth= orig_f.smooth
287
 
                
288
 
                for uvlayer in me.getUVLayerNames():
289
 
                        me.activeUVLayer = uvlayer
290
 
                        for i, origfData in enumerate(skin_side_faces_orig):
291
 
                                orig_f, new_f_idx, i2, i1 = origfData
292
 
                                new_f= me_faces[new_f_idx]
293
 
                                
294
 
                                new_f.mode= orig_f.mode
295
 
                                new_f.flag= orig_f.flag
296
 
                                new_f.image= orig_f.image
297
 
                                
298
 
                                uv1= orig_f.uv[i1]
299
 
                                uv2= orig_f.uv[i2]
300
 
                                new_f.uv= (uv1, uv2, uv2, uv1)
301
 
                
302
 
                for collayer in me.getColorLayerNames():
303
 
                        me.activeColorLayer = collayer
304
 
                        for i, origfData in enumerate(skin_side_faces_orig):
305
 
                                orig_f, new_f_idx, i2, i1 = origfData
306
 
                                new_f= me_faces[new_f_idx]
307
 
                                
308
 
                                col1= orig_f.col[i1]
309
 
                                col2= orig_f.col[i2]
310
 
                                new_f.col= (col1, col2, col2, col1)
311
 
        
 
279
                                        
 
280
                                        uv1= orig_f.uv[i1]
 
281
                                        uv2= orig_f.uv[i2]
 
282
                                        new_f.uv= (uv1, uv2, uv2, uv1)
 
283
                        
 
284
                        for collayer in me.getColorLayerNames():
 
285
                                me.activeColorLayer = collayer
 
286
                                for i, origfData in enumerate(skin_side_faces_orig):
 
287
                                        orig_f, new_f_idx, i2, i1 = origfData
 
288
                                        new_f= me_faces[new_f_idx]
 
289
                                        
 
290
                                        col1= orig_f.col[i1]
 
291
                                        col2= orig_f.col[i2]
 
292
                                        new_f.col= (col1, col2, col2, col1)
 
293
                
312
294
        
313
295
        if PREF_REM_ORIG:
314
296
                me_faces.delete(0, faces_sel)
 
297
 
 
298
 
 
299
 
 
300
 
 
301
def main():
 
302
        scn = bpy.data.scenes.active
 
303
        ob = scn.objects.active
 
304
        
 
305
        if not ob or ob.type != 'Mesh':
 
306
                BPyMessages.Error_NoMeshActive()
 
307
                return
 
308
        
 
309
        me = ob.getData(mesh=1)
 
310
        if me.multires:
 
311
                BPyMessages.Error_NoMeshMultiresEdit()
 
312
                return
 
313
        
 
314
        # Create the variables.
 
315
        PREF_THICK = Draw.Create(-0.1)
 
316
        PREF_SKIN_SIDES= Draw.Create(1)
 
317
        PREF_COLLAPSE_SIDES= Draw.Create(0)
 
318
        PREF_REM_ORIG= Draw.Create(0)
 
319
        
 
320
        pup_block = [\
 
321
        ('Thick:', PREF_THICK, -10, 10, 'Skin thickness in mesh space.'),\
 
322
        ('Skin Sides', PREF_SKIN_SIDES, 'Skin between the original and new faces.'),\
 
323
        ('Collapse Sides', PREF_COLLAPSE_SIDES, 'Skin between the original and new faces.'),\
 
324
        ('Remove Original', PREF_REM_ORIG, 'Remove the selected faces after skinning.'),\
 
325
        ]
 
326
        
 
327
        if not Draw.PupBlock('Solid Skin Selection', pup_block):
 
328
                return
 
329
        
 
330
        is_editmode = Window.EditMode() 
 
331
        if is_editmode: Window.EditMode(0)
 
332
        
 
333
        Window.WaitCursor(1)
 
334
        
 
335
        me = ob.getData(mesh=1)
 
336
        solidify(me, PREF_THICK.val, PREF_SKIN_SIDES.val, PREF_REM_ORIG.val, PREF_COLLAPSE_SIDES.val)
315
337
        
316
338
        
317
339
        Window.WaitCursor(0)