==python scripts==
updated version of bevel center by Loic Berthe
This commit is contained in:
Tom Musgrove
parent
2c9a4eb6ef
commit
4734a2db7e
@ -2,21 +2,21 @@
|
||||
|
||||
""" Registration info for Blender menus
|
||||
Name: 'Bevel Center'
|
||||
Blender: 236
|
||||
Blender: 240
|
||||
Group: 'Mesh'
|
||||
Tip: 'Bevel selected vertices'
|
||||
Tip: 'Bevel selected faces, edges, and vertices'
|
||||
"""
|
||||
|
||||
__author__ = "Loic Berthe"
|
||||
__author__ = "Loic BERTHE"
|
||||
__url__ = ("blender", "elysiun")
|
||||
__version__ = "1.0"
|
||||
__version__ = "2.0"
|
||||
|
||||
__bpydoc__ = """\
|
||||
This script implements vertex bevelling in Blender.
|
||||
This script implements vertex and edges bevelling in Blender.
|
||||
|
||||
Usage:
|
||||
|
||||
Select the mesh you want to work on, enter Edit Mode and select the vertices
|
||||
Select the mesh you want to work on, enter Edit Mode and select the edges
|
||||
to bevel. Then run this script from the 3d View's Mesh->Scripts menu.
|
||||
|
||||
You can control the thickness of the bevel with the slider -- redefine the
|
||||
@ -24,358 +24,295 @@ end points for bigger or smaller ranges. The thickness can be changed even
|
||||
after applying the bevel, as many times as needed.
|
||||
|
||||
For an extra smoothing after or instead of direct bevel, set the level of
|
||||
recursiveness and use the "Recursive" button.
|
||||
recursiveness and use the "Recursive" button.
|
||||
|
||||
This "Recursive" Button, won't work in face select mode, unless you choose
|
||||
"faces" in the select mode menu.
|
||||
|
||||
Notes:<br>
|
||||
You can undo and redo your steps just like with normal mesh operations in
|
||||
You can undo and redo your steps just like with normal mesh operations in
|
||||
Blender.
|
||||
"""
|
||||
|
||||
# $Id$
|
||||
#
|
||||
######################################################################
|
||||
# Bevel Center v1 for Blender
|
||||
#
|
||||
# This script lets you bevel the selected vertices and control the
|
||||
# Bevel Center v2.0 for Blender
|
||||
|
||||
# This script lets you bevel the selected vertices or edges and control the
|
||||
# thickness of the bevel
|
||||
#
|
||||
# (c) 2004 Loïc Berthe (loic.berthe@lilotux.net)
|
||||
|
||||
# (c) 2004-2006 Loïc Berthe (loic+blender@lilotux.net)
|
||||
# released under Blender Artistic License
|
||||
#
|
||||
|
||||
######################################################################
|
||||
|
||||
import Blender
|
||||
from Blender import NMesh, Window
|
||||
from Blender import NMesh, Window, Scene
|
||||
from Blender.Draw import *
|
||||
from Blender.Mathutils import *
|
||||
from Blender.BGL import *
|
||||
|
||||
from math import pi, sin, sqrt
|
||||
|
||||
######################################################################
|
||||
# Functions to handle the global structures of the script NV, NE and NC
|
||||
# which contain informations about the vertices, faces and corners to be
|
||||
# created
|
||||
# Functions to handle the global structures of the script NF, NE and NC
|
||||
# which contain informations about faces and corners to be created
|
||||
|
||||
class Dir:
|
||||
def __init__(self, co):
|
||||
self.co = co
|
||||
global E_selected
|
||||
E_selected = NMesh.EdgeFlags['SELECT']
|
||||
|
||||
def add_to_NV(old,co,new):
|
||||
dir = Dir(co)
|
||||
#
|
||||
if old in NV.keys():
|
||||
NV[old][dir] = new
|
||||
else:
|
||||
NV[old] = {dir:new}
|
||||
|
||||
def is_in_NV(old,co):
|
||||
if old in NV.keys():
|
||||
for dir in NV[old]:
|
||||
if dir.co == co : return NV[old][dir]
|
||||
#
|
||||
return False
|
||||
|
||||
def add_to_NE(old, new):
|
||||
ind1 = old[0].index
|
||||
ind2 = old[1].index
|
||||
if ind1 > ind2:
|
||||
new.reverse()
|
||||
ind1,ind2 = ind2,ind1
|
||||
id = str(ind1)+"_"+str(ind2)
|
||||
if id in NE.keys():
|
||||
[NE[id].append(v) for v in new]
|
||||
else:
|
||||
NE[id] = new
|
||||
|
||||
def add_to_NC(old,edge):
|
||||
if old in NC.keys():
|
||||
NC[old].append(edge)
|
||||
else:
|
||||
NC[old] = [edge]
|
||||
|
||||
######################################################################
|
||||
# Geometric functions
|
||||
|
||||
def norm(vec):
|
||||
n = sqrt(vec[0]**2+vec[1]**2+vec[2]**2)
|
||||
return [vec[0]/n,vec[1]/n,vec[2]/n]
|
||||
|
||||
def parall_coord(old, dir):
|
||||
co = old.co
|
||||
vec = [0.0,0.0,0.0]
|
||||
nco = [0.0,0.0,0.0]
|
||||
#
|
||||
if len(dir) == 1:
|
||||
for i in range(3): vec[i] = dir[0].co[i] - co[i]
|
||||
vec = norm(vec)
|
||||
#
|
||||
elif len(dir) == 2:
|
||||
vec1 = [0.0,0.0,0.0]
|
||||
vec2 = [0.0,0.0,0.0]
|
||||
for i in range(3):
|
||||
vec1[i] = dir[0].co[i] - co[i]
|
||||
vec2[i] = dir[1].co[i] - co[i]
|
||||
vec1 = norm(vec1)
|
||||
vec2 = norm(vec2)
|
||||
for i in range(3) : vec[i] = vec1[i]+vec2[i]
|
||||
#
|
||||
for i in range(3): nco[i] = co[i] + dist.val*vec[i]
|
||||
return (nco,vec)
|
||||
|
||||
def get_vert(old, dir):
|
||||
""" Look in NV if a vertex corresponding to the vertex old and the
|
||||
direction dir already exists, and create one otherwise"""
|
||||
(nco, vec) = parall_coord(old, dir)
|
||||
v = is_in_NV(old,vec)
|
||||
if v: return v
|
||||
#
|
||||
v = NMesh.Vert(nco[0],nco[1],nco[2])
|
||||
v.sel = 1
|
||||
def make_sel_vert(*co):
|
||||
vi= NMesh.Vert(*co)
|
||||
v.sel = 1
|
||||
me.verts.append(v)
|
||||
add_to_NV(old,vec,v)
|
||||
return v
|
||||
|
||||
######################################################################
|
||||
# Functions to create the differents faces
|
||||
|
||||
def make_sel_face(verts):
|
||||
f = NMesh.Face(verts)
|
||||
f.sel = 1
|
||||
me.addFace(f)
|
||||
|
||||
def add_to_NV(old,dir,new):
|
||||
if old in NV.keys(): NV[old][dir] = new
|
||||
else: NV[old] = {dir:new}
|
||||
|
||||
def get_v(old, *neighbors):
|
||||
|
||||
# compute the direction of the new vert
|
||||
if len(neighbors) == 1 : dir = (neighbors[0].co - old.co).normalize()
|
||||
else : dir = (neighbors[0].co - old.co).normalize() + (neighbors[1].co-old.co).normalize()
|
||||
|
||||
# look in NV if this vert already exists
|
||||
key = tuple(dir)
|
||||
if old in NV and key in NV[old] : return NV[old][key]
|
||||
|
||||
def make_NF():
|
||||
""" Analyse the mesh, sort the faces containing selected vertices and
|
||||
create a liste NF : NF = [[flag, vertlist, old_face]]. Flag describes the
|
||||
topology of the face."""
|
||||
#
|
||||
for f in me.faces:
|
||||
V = f.v
|
||||
v_sel = [x.sel for x in V]
|
||||
nb_sel = sum(v_sel)
|
||||
if nb_sel == 0 :
|
||||
pass
|
||||
else:
|
||||
nb_v = len(V)
|
||||
#
|
||||
if nb_v == 4:
|
||||
#
|
||||
if nb_sel == 4:
|
||||
NF.append([1,V,f])
|
||||
#
|
||||
elif nb_sel == 3:
|
||||
if v_sel == [0,1,1,1]: V = [V[1],V[2],V[3],V[0]]
|
||||
elif v_sel == [1,0,1,1]: V = [V[2],V[3],V[0],V[1]]
|
||||
elif v_sel == [1,1,0,1]: V = [V[3],V[0],V[1],V[2]]
|
||||
NF.append([2,V,f])
|
||||
#
|
||||
elif nb_sel == 2:
|
||||
if v_sel == [1,0,1,0] or v_sel == [0,1,0,1]:
|
||||
if v_sel == [0,1,0,1]: V = [V[1],V[2],V[3],V[0]]
|
||||
NF.append([5,[V[0],V[1],V[3]],f])
|
||||
NF.append([5,[V[2],V[1],V[3]]])
|
||||
else:
|
||||
if v_sel == [0,1,1,0]: V = [V[1],V[2],V[3],V[0]]
|
||||
elif v_sel == [0,0,1,1]: V = [V[2],V[3],V[0],V[1]]
|
||||
elif v_sel == [1,0,0,1]: V = [V[3],V[0],V[1],V[2]]
|
||||
NF.append([3,V,f])
|
||||
#
|
||||
else:
|
||||
if v_sel == [0,1,0,0]: V = [V[1],V[2],V[3],V[0]]
|
||||
elif v_sel == [0,0,1,0]: V = [V[2],V[3],V[0],V[1]]
|
||||
elif v_sel == [0,0,0,1]: V = [V[3],V[0],V[1],V[2]]
|
||||
NF.append([4,V,f])
|
||||
#
|
||||
elif nb_v == 3:
|
||||
#
|
||||
if nb_sel == 3:
|
||||
NF.append([6,V,f])
|
||||
#
|
||||
elif nb_sel == 2:
|
||||
if v_sel == [0,1,1]: V = [V[1],V[2],V[0]]
|
||||
elif v_sel == [1,0,1]: V = [V[2],V[0],V[1]]
|
||||
NF.append([7,V,f])
|
||||
#
|
||||
else:
|
||||
if v_sel == [0,1,0]: V = [V[1],V[2],V[0]]
|
||||
elif v_sel == [0,0,1]: V = [V[2],V[0],V[1]]
|
||||
NF.append([5,V,f])
|
||||
# else, create it
|
||||
new = old.co + dist.val*dir
|
||||
v = make_sel_vert(new.x,new.y,new.z)
|
||||
add_to_NV(old,key,v)
|
||||
return v
|
||||
|
||||
def make_faces():
|
||||
""" Make the new faces according to NF """
|
||||
#
|
||||
for N in NF:
|
||||
cas = N[0]
|
||||
V = N[1]
|
||||
#
|
||||
if cas < 6:
|
||||
new_v = [0,0,0,0]
|
||||
if cas == 1: # v_sel = [1,1,1,1]
|
||||
for i in range(-1,3):
|
||||
new_v[i] = get_vert(V[i],[V[i-1],V[i+1]])
|
||||
new_f = NMesh.Face(new_v)
|
||||
me.faces.append(new_f)
|
||||
for i in range(-1,3):
|
||||
add_to_NE([V[i],V[i+1]],[new_v[i],new_v[i+1]])
|
||||
#
|
||||
elif cas == 2: # v_sel = [1,1,1,0]
|
||||
new_v[0] = get_vert(V[0],[V[3]])
|
||||
new_v[1] = get_vert(V[1],[V[0],V[2]])
|
||||
new_v[2] = get_vert(V[2],[V[3]])
|
||||
new_v[3] = V[3]
|
||||
#
|
||||
new_f = NMesh.Face(new_v)
|
||||
me.faces.append(new_f)
|
||||
#
|
||||
add_to_NE([V[0],V[1]],[new_v[0],new_v[1]])
|
||||
add_to_NE([V[1],V[2]],[new_v[1],new_v[2]])
|
||||
#
|
||||
elif cas == 3: # v_sel = [1,1,0,0]
|
||||
new_v[0] = get_vert(V[0],[V[3]])
|
||||
new_v[1] = get_vert(V[1],[V[2]])
|
||||
new_v[2] = V[2]
|
||||
new_v[3] = V[3]
|
||||
#
|
||||
new_f = NMesh.Face(new_v)
|
||||
me.faces.append(new_f)
|
||||
#
|
||||
add_to_NE([V[0],V[1]],[new_v[0],new_v[1]])
|
||||
#
|
||||
elif cas == 4: # v_sel = [1,0,0,0]
|
||||
new_v[0] = get_vert(V[0],[V[3]])
|
||||
new_v[1] = get_vert(V[0],[V[1]])
|
||||
new_v[2] = V[1]
|
||||
new_v[3] = V[3]
|
||||
#
|
||||
new_f = NMesh.Face(new_v)
|
||||
me.faces.append(new_f)
|
||||
#
|
||||
add_to_NC(V[0], new_v[0:2])
|
||||
#
|
||||
new_v[0] = V[1]
|
||||
new_v[1] = V[2]
|
||||
new_v[2] = V[3]
|
||||
#
|
||||
new_f = NMesh.Face(new_v[:3])
|
||||
me.faces.append(new_f)
|
||||
#
|
||||
else: # v_sel = [1,0,0]
|
||||
new_v[0] = get_vert(V[0],[V[2]])
|
||||
new_v[1] = get_vert(V[0],[V[1]])
|
||||
new_v[2] = V[1]
|
||||
new_v[3] = V[2]
|
||||
#
|
||||
new_f = NMesh.Face(new_v)
|
||||
me.faces.append(new_f)
|
||||
#
|
||||
add_to_NC(V[0], new_v[0:2])
|
||||
#
|
||||
else:
|
||||
new_v = [0,0,0]
|
||||
#
|
||||
if cas == 6: # v_sel = [1,1,1]
|
||||
for i in range(-1,2):
|
||||
new_v[i] = get_vert(V[i],[V[i-1],V[i+1]])
|
||||
new_f = NMesh.Face(new_v)
|
||||
me.faces.append(new_f)
|
||||
for i in range(-1,2):
|
||||
add_to_NE([V[i],V[i+1]],[new_v[i],new_v[i+1]])
|
||||
#
|
||||
elif cas == 7: # v_sel = [1,1,0]
|
||||
new_v[0] = get_vert(V[0],[V[2]])
|
||||
new_v[1] = get_vert(V[1],[V[2]])
|
||||
new_v[2] = V[2]
|
||||
#
|
||||
new_f = NMesh.Face(new_v)
|
||||
me.faces.append(new_f)
|
||||
add_to_NE([V[0],V[1]],[new_v[0],new_v[1]])
|
||||
""" Analyse the mesh, make the faces corresponding to selected faces and
|
||||
fill the structures NE and NC """
|
||||
|
||||
# make the differents flags consistent
|
||||
for e in me.edges:
|
||||
if e.flag & E_selected :
|
||||
e.v1.sel = 1
|
||||
e.v2.sel = 1
|
||||
|
||||
NF =[] # NF : New faces
|
||||
for f in me.faces:
|
||||
V = f.v
|
||||
nV = len(V)
|
||||
enumV = range(nV)
|
||||
E = [me.findEdge(V[i],V[(i+1) % nV]) for i in enumV]
|
||||
Esel = [x.flag & E_selected for x in E]
|
||||
|
||||
# look for selected vertices and creates a list containing the new vertices
|
||||
newV = V[:]
|
||||
changes = False
|
||||
for (i,v) in enumerate(V):
|
||||
if v.sel :
|
||||
changes = True
|
||||
if Esel[i-1] == 0 and Esel[i] == 1 : newV[i] = get_v(v,V[i-1])
|
||||
elif Esel[i-1] == 1 and Esel[i] == 0 : newV[i] = get_v(v,V[(i+1) % nV])
|
||||
elif Esel[i-1] == 1 and Esel[i] == 1 : newV[i] = get_v(v,V[i-1],V[(i+1) % nV])
|
||||
else : newV[i] = [get_v(v,V[i-1]),get_v(v,V[(i+1) % nV])]
|
||||
|
||||
if changes:
|
||||
# determine and store the face to be created
|
||||
|
||||
lenV = [len(x) for x in newV]
|
||||
|
||||
if 2 not in lenV :
|
||||
new_f = NMesh.Face(newV)
|
||||
if sum(Esel) == nV : new_f.sel = 1
|
||||
NF.append(new_f)
|
||||
|
||||
else :
|
||||
nb2 = lenV.count(2)
|
||||
|
||||
if nV == 4 : # f is a quad
|
||||
if nb2 == 1 :
|
||||
ind2 = lenV.index(2)
|
||||
NF.append(NMesh.Face([newV[ind2-1],newV[ind2][0],newV[ind2][1],newV[ind2-3]]))
|
||||
NF.append(NMesh.Face([newV[ind2-1],newV[ind2-2],newV[ind2-3]]))
|
||||
|
||||
elif nb2 == 2 :
|
||||
# We must know if the tuples are neighbours
|
||||
ind2 = ''.join([str(x) for x in lenV+lenV[:1]]).find('22')
|
||||
|
||||
if ind2 != -1 : # They are
|
||||
NF.append(NMesh.Face([newV[ind2][0],newV[ind2][1],newV[ind2-3][0],newV[ind2-3][1]]))
|
||||
NF.append(NMesh.Face([newV[ind2][0],newV[ind2-1],newV[ind2-2],newV[ind2-3][1]]))
|
||||
|
||||
else: # They aren't
|
||||
ind2 = lenV.index(2)
|
||||
NF.append(NMesh.Face([newV[ind2][0],newV[ind2][1],newV[ind2-2][0],newV[ind2-2][1]]))
|
||||
NF.append(NMesh.Face([newV[ind2][1],newV[ind2-3],newV[ind2-2][0]]))
|
||||
NF.append(NMesh.Face([newV[ind2][0],newV[ind2-1],newV[ind2-2][1]]))
|
||||
|
||||
elif nb2 == 3 :
|
||||
ind2 = lenV.index(3)
|
||||
NF.append(NMesh.Face([newV[ind2-1][1],newV[ind2],newV[ind2-3][0]]))
|
||||
NF.append(NMesh.Face([newV[ind2-1][0],newV[ind2-1][1],newV[ind2-3][0],newV[ind2-3][1]]))
|
||||
NF.append(NMesh.Face([newV[ind2-3][1],newV[ind2-2][0],newV[ind2-2][1],newV[ind2-1][0]]))
|
||||
|
||||
else:
|
||||
if (newV[0][1].co-newV[3][0].co).length + (newV[1][0].co-newV[2][1].co).length \
|
||||
< (newV[0][0].co-newV[1][1].co).length + (newV[2][0].co-newV[3][1].co).length :
|
||||
ind2 = 0
|
||||
else :
|
||||
ind2 = 1
|
||||
NF.append(NMesh.Face([newV[ind2-1][0],newV[ind2-1][1],newV[ind2][0],newV[ind2][1]]))
|
||||
NF.append(NMesh.Face([newV[ind2][1],newV[ind2-3][0],newV[ind2-2][1],newV[ind2-1][0]]))
|
||||
NF.append(NMesh.Face([newV[ind2-3][0],newV[ind2-3][1],newV[ind2-2][0],newV[ind2-2][1]]))
|
||||
|
||||
else : # f is a tri
|
||||
if nb2 == 1:
|
||||
ind2 = lenV.index(2)
|
||||
NF.append(NMesh.Face([newV[ind2-2],newV[ind2-1],newV[ind2][0],newV[ind2][1]]))
|
||||
|
||||
elif nb2 == 2:
|
||||
ind2 = lenV.index(3)
|
||||
NF.append(NMesh.Face([newV[ind2-1][1],newV[ind2],newV[ind2-2][0]]))
|
||||
NF.append(NMesh.Face([newV[ind2-2][0],newV[ind2-2][1],newV[ind2-1][0],newV[ind2-1][1]]))
|
||||
|
||||
else:
|
||||
ind2 = min(((newV[i][1].co-newV[i-1][0].co).length, i) for i in enumV)[1]
|
||||
NF.append(NMesh.Face([newV[ind2-1][1],newV[ind2][0],newV[ind2][1],newV[ind2-2][0]]))
|
||||
NF.append(NMesh.Face([newV[ind2-2][0],newV[ind2-2][1],newV[ind2-1][0],newV[ind2-1][1]]))
|
||||
|
||||
# Preparing the corners
|
||||
for i in enumV:
|
||||
if lenV[i] == 2 : NC.setdefault(V[i],[]).append(newV[i])
|
||||
|
||||
old_faces.append(f)
|
||||
|
||||
# Preparing the Edges
|
||||
for i in enumV:
|
||||
if Esel[i]:
|
||||
verts = [newV[i],newV[(i+1) % nV]]
|
||||
if V[i].index > V[(i+1) % nV].index : verts.reverse()
|
||||
NE.setdefault(E[i],[]).append(verts)
|
||||
|
||||
# Create the faces
|
||||
for f in NF: me.addFace(f)
|
||||
|
||||
def make_edges():
|
||||
""" Make the faces corresponding to selected edges """
|
||||
#
|
||||
for l in NE.values():
|
||||
if len(l) == 4:
|
||||
f = NMesh.Face([l[0],l[1],l[3],l[2]])
|
||||
me.faces.append(f)
|
||||
|
||||
for old,new in NE.iteritems() :
|
||||
if len(new) == 1 : # This edge was on a border
|
||||
oldv = [old.v1, old.v2]
|
||||
if old.v1.index < old.v2.index : oldv.reverse()
|
||||
|
||||
make_sel_face(oldv+new[0])
|
||||
|
||||
me.findEdge(*oldv).flag |= E_selected
|
||||
me.findEdge(*new[0]).flag |= E_selected
|
||||
|
||||
for v in oldv : NV_ext.add(v)
|
||||
|
||||
else:
|
||||
make_sel_face(new[0] + new[1][::-1])
|
||||
|
||||
me.findEdge(*new[0]).flag |= E_selected
|
||||
me.findEdge(*new[1]).flag |= E_selected
|
||||
|
||||
def make_corners():
|
||||
""" Make the faces corresponding to selected corners """
|
||||
#
|
||||
""" Make the faces corresponding to corners """
|
||||
|
||||
for v in NV.keys():
|
||||
V = NV[v].values()
|
||||
nb_v = len(V)
|
||||
#
|
||||
if nb_v < 3:
|
||||
pass
|
||||
#
|
||||
elif nb_v == 3:
|
||||
new_f = NMesh.Face(V)
|
||||
me.faces.append(new_f)
|
||||
#
|
||||
nV = len(V)
|
||||
|
||||
if nV == 1: pass
|
||||
|
||||
elif nV == 2 :
|
||||
if v in NV_ext:
|
||||
make_sel_face(V+[v])
|
||||
me.findEdge(*V).flag |= E_selected
|
||||
|
||||
else:
|
||||
# We need to know which are the edges around the corner.
|
||||
# First, we look for the quads surrounding the corner.
|
||||
q = [NE[id] for id in NE.keys() if str(v.index) in id.split('_')]
|
||||
#
|
||||
# We will put the associated edges in the list eed
|
||||
is_in_v = lambda x:x in V
|
||||
eed = [filter(is_in_v, l) for l in q]
|
||||
#
|
||||
# We will add the edges coming from faces where only one vertex is selected.
|
||||
# They are stocked in NC.
|
||||
if v in NC.keys():
|
||||
eed = eed+NC[v]
|
||||
b = eed.pop()
|
||||
# b will contain the sorted list of vertices
|
||||
#
|
||||
while eed:
|
||||
for l in eed:
|
||||
if l[0] == b[-1]:
|
||||
b.append(l[1])
|
||||
eed.remove(l)
|
||||
break
|
||||
elif l[1] == b[-1]:
|
||||
b.append(l[0])
|
||||
eed.remove(l)
|
||||
break
|
||||
# Now we can create the faces
|
||||
if nb_v == 4:
|
||||
new_f = NMesh.Face(b[:4])
|
||||
me.faces.append(new_f)
|
||||
#
|
||||
else:
|
||||
co = [0.0, 0.0,0.0]
|
||||
vec = [0.0, 0.0,0.0]
|
||||
for x in V:
|
||||
co[0] += x[0]
|
||||
co[1] += x[1]
|
||||
co[2] += x[2]
|
||||
#
|
||||
for dir in NV[v]:
|
||||
vec[0] += dir.co[0]
|
||||
vec[1] += dir.co[1]
|
||||
vec[2] += dir.co[2]
|
||||
#
|
||||
co = [x/nb_v for x in co]
|
||||
vec = [x/nb_v for x in vec]
|
||||
center = NMesh.Vert(co[0],co[1],co[2])
|
||||
center.sel = 1
|
||||
me.verts.append(center)
|
||||
add_to_NV(v,vec,center)
|
||||
#
|
||||
for k in range(nb_v):
|
||||
new_f = NMesh.Face([center, b[k], b[k+1]])
|
||||
me.faces.append(new_f)
|
||||
#
|
||||
if nV == 3 and v not in NV_ext : make_sel_face(V)
|
||||
|
||||
else :
|
||||
|
||||
# We need to know which are the edges around the corner.
|
||||
# First, we look for the quads surrounding the corner.
|
||||
eed = []
|
||||
for old, new in NE.iteritems():
|
||||
if v in (old.v1,old.v2) :
|
||||
if v.index == min(old.v1.index,old.v2.index) : ind = 0
|
||||
else : ind = 1
|
||||
|
||||
if len(new) == 1: eed.append([v,new[0][ind]])
|
||||
else : eed.append([new[0][ind],new[1][ind]])
|
||||
|
||||
# We will add the edges coming from faces where only one vertice is selected.
|
||||
# They are stored in NC.
|
||||
if v in NC: eed = eed+NC[v]
|
||||
|
||||
# Now we have to sort these vertices
|
||||
hc = {}
|
||||
for (a,b) in eed :
|
||||
hc.setdefault(a,[]).append(b)
|
||||
hc.setdefault(b,[]).append(a)
|
||||
|
||||
for x0,edges in hc.iteritems():
|
||||
if len(edges) == 1 : break
|
||||
|
||||
b = [x0] # b will contain the sorted list of vertices
|
||||
|
||||
for i in range(len(hc)-1):
|
||||
for x in hc[x0] :
|
||||
if x not in b : break
|
||||
b.append(x)
|
||||
x0 = x
|
||||
|
||||
b.append(b[0])
|
||||
|
||||
# Now we can create the faces
|
||||
if len(b) == 5: make_sel_face(b[:4])
|
||||
|
||||
else:
|
||||
New_V = Vector(0.0, 0.0,0.0)
|
||||
New_d = [0.0, 0.0,0.0]
|
||||
|
||||
for x in hc.keys(): New_V += x.co
|
||||
for dir in NV[v] :
|
||||
for i in xrange(3): New_d[i] += dir[i]
|
||||
|
||||
New_V *= 1./len(hc)
|
||||
for i in range(3) : New_d[i] /= nV
|
||||
|
||||
center = make_sel_vert(New_V.x,New_V.y,New_V.z)
|
||||
add_to_NV(v,tuple(New_d),center)
|
||||
|
||||
for k in range(len(b)-1): make_sel_face([center, b[k], b[k+1]])
|
||||
|
||||
if 2 < nV and v in NC :
|
||||
for edge in NC[v] : me.findEdge(*edge).flag |= E_selected
|
||||
|
||||
def clear_old():
|
||||
""" Erase old faces and vertices """
|
||||
for F in NF:
|
||||
if len(F) == 3:
|
||||
me.faces.remove(F[2])
|
||||
#
|
||||
|
||||
for f in old_faces: me.removeFace(f)
|
||||
|
||||
for v in NV.keys():
|
||||
me.verts.remove(v)
|
||||
if v not in NV_ext : me.verts.remove(v)
|
||||
|
||||
for e in me.edges:
|
||||
if e.flag & E_selected :
|
||||
e.v1.sel = 1
|
||||
e.v2.sel = 1
|
||||
|
||||
|
||||
######################################################################
|
||||
# Interface
|
||||
#
|
||||
|
||||
global dist
|
||||
NV = {}
|
||||
|
||||
dist = Create(0.2)
|
||||
left = Create(0.0)
|
||||
right = Create(1.0)
|
||||
@ -393,83 +330,79 @@ def draw():
|
||||
global EVENT_NOEVENT, EVENT_BEVEL, EVENT_UPDATE, EVENT_RECURS, EVENT_EXIT
|
||||
|
||||
glClear(GL_COLOR_BUFFER_BIT)
|
||||
Button("Bevel",EVENT_BEVEL,10,100,300,25)
|
||||
left=Number('', EVENT_NOEVENT,10,70,50, 20,left.val,0,right.val,'Set the minimum of the slider')
|
||||
right = Number("",EVENT_NOEVENT,260,70,50,20,right.val,left.val,200,"Set the maximum of the slider")
|
||||
dist=Slider("Thickness ",EVENT_UPDATE,65,70,190,20,dist.val,left.val,right.val,0,"Thickness of the bevel, can be changed even after bevelling")
|
||||
glRasterPos2d(10,40)
|
||||
Button("Bevel",EVENT_BEVEL,10,100,280,25)
|
||||
left=Number('', EVENT_NOEVENT,10,70,45, 20,left.val,0,right.val,'Set the minimum of the slider')
|
||||
right = Number("",EVENT_NOEVENT,245,70,45,20,right.val,left.val,200,"Set the maximum of the slider")
|
||||
dist=Slider("Thickness ",EVENT_UPDATE,60,70,180,20,dist.val,left.val,right.val,0, \
|
||||
"Thickness of the bevel, can be changed even after bevelling")
|
||||
glRasterPos2d(8,40)
|
||||
Text('To finish, you can use recursive bevel to smooth it')
|
||||
num=Number('', EVENT_NOEVENT,10,10,50, 16,num.val,1,100,'Recursion level')
|
||||
Button("Recursive",EVENT_RECURS,65,10,100,16)
|
||||
Button("Exit",EVENT_EXIT,230,10,80,20)
|
||||
num=Number('', EVENT_NOEVENT,10,10,40, 16,num.val,1,100,'Recursion level')
|
||||
Button("Recursive",EVENT_RECURS,55,10,100,16)
|
||||
Button("Exit",EVENT_EXIT,210,10,80,20)
|
||||
|
||||
def event(evt, val):
|
||||
if ((evt == QKEY or evt == ESCKEY) and not val):
|
||||
Exit()
|
||||
if ((evt == QKEY or evt == ESCKEY) and not val): Exit()
|
||||
|
||||
def bevent(evt):
|
||||
if evt == EVENT_EXIT :
|
||||
Exit()
|
||||
#
|
||||
elif evt == EVENT_BEVEL:
|
||||
bevel()
|
||||
#
|
||||
elif evt == EVENT_UPDATE:
|
||||
try:
|
||||
bevel_update()
|
||||
except NameError:
|
||||
pass
|
||||
#
|
||||
elif evt == EVENT_RECURS:
|
||||
recursive()
|
||||
if evt == EVENT_EXIT : Exit()
|
||||
elif evt == EVENT_BEVEL : bevel()
|
||||
elif evt == EVENT_UPDATE :
|
||||
try: bevel_update()
|
||||
except NameError : pass
|
||||
elif evt == EVENT_RECURS : recursive()
|
||||
|
||||
Register(draw, event, bevent)
|
||||
|
||||
######################################################################
|
||||
def bevel():
|
||||
""" The main function, which creates the bevel """
|
||||
global me,NF,NV,NE,NC, old_dist
|
||||
#
|
||||
is_editmode = Window.EditMode()
|
||||
if is_editmode: Window.EditMode(0)
|
||||
objects = Blender.Object.GetSelected()
|
||||
bev_obj = objects[0]
|
||||
if bev_obj.getType() != "Mesh":
|
||||
PupMenu("ERROR: active object must be a mesh")
|
||||
global me,NV,NV_ext,NE,NC, old_faces,old_dist
|
||||
|
||||
scn = Scene.GetCurrent()
|
||||
ob = scn.getActiveObject()
|
||||
if ob == None or ob.getType() != 'Mesh':
|
||||
Draw.PupMenu('ERROR%t|Select a mesh object.')
|
||||
return
|
||||
me = NMesh.GetRaw(bev_obj.getData(name_only = True))
|
||||
#
|
||||
NF = []
|
||||
|
||||
Window.WaitCursor(1) # Change the Cursor
|
||||
|
||||
is_editmode = Window.EditMode()
|
||||
if is_editmode: Window.EditMode(0)
|
||||
|
||||
me = ob.getData()
|
||||
|
||||
NV = {}
|
||||
NV_ext = set()
|
||||
NE = {}
|
||||
NC = {}
|
||||
#
|
||||
make_NF()
|
||||
old_faces = []
|
||||
|
||||
make_faces()
|
||||
make_edges()
|
||||
make_corners()
|
||||
clear_old()
|
||||
#
|
||||
|
||||
old_dist = dist.val
|
||||
#
|
||||
|
||||
me.update(1)
|
||||
if is_editmode: Window.EditMode(1)
|
||||
Window.WaitCursor(0)
|
||||
Blender.Redraw()
|
||||
|
||||
def bevel_update():
|
||||
""" Use NV to update the bevel """
|
||||
global dist, old_dist, NV
|
||||
if not NV: return
|
||||
global dist, old_dist
|
||||
is_editmode = Window.EditMode()
|
||||
if is_editmode: Window.EditMode(0)
|
||||
fac = dist.val - old_dist
|
||||
old_dist = dist.val
|
||||
#
|
||||
|
||||
for old_v in NV.keys():
|
||||
for dir in NV[old_v].keys():
|
||||
for i in range(3):
|
||||
NV[old_v][dir].co[i] += fac*dir.co[i]
|
||||
#
|
||||
NV[old_v][dir].co[i] += fac*dir[i]
|
||||
|
||||
me.update(1)
|
||||
if is_editmode: Window.EditMode(1)
|
||||
Blender.Redraw()
|
||||
@ -477,24 +410,23 @@ def bevel_update():
|
||||
def recursive():
|
||||
""" Make a recursive bevel... still experimental """
|
||||
global dist
|
||||
#
|
||||
from math import pi, sin
|
||||
|
||||
if num.val > 1:
|
||||
a = pi/4
|
||||
ang = []
|
||||
for k in range(num.val):
|
||||
ang.append(a)
|
||||
a = (pi+2*a)/4
|
||||
#
|
||||
|
||||
l = [2*(1-sin(x))/sin(2*x) for x in ang]
|
||||
R = dist.val/sum(l)
|
||||
l = [x*R for x in l]
|
||||
#
|
||||
|
||||
dist.val = l[0]
|
||||
bevel_update()
|
||||
#
|
||||
|
||||
for x in l[1:]:
|
||||
dist.val = x
|
||||
bevel()
|
||||
|
||||
# vim:set ts=4 sw=4:
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user