sandey/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity

Mesh sculpting event handeler script,

Browse Source 
see http://www.elysiun.com/forum/viewtopic.php?t=56101 for details,
This commit is contained in:
Campbell Barton 2006-01-15 14:44:09 +00:00
parent 93904a476e
commit c5fd40f0bf
1 changed files with 798 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

798
release/scripts/mesh_bbrush.py Normal file
View File

@ -0,0 +1,798 @@
# SPACEHANDLER.VIEW3D.EVENT
# Dont run, event handelers are accessed in the from the 3d View menu.
import Blender
from Blender import Mathutils, Window, Scene, Draw, Mesh
from Blender.Mathutils import CrossVecs, Matrix, Vector, Intersect, LineIntersect
# DESCRIPTION:
# screen_x, screen_y the origin point of the pick ray
# it is either the mouse location
# localMatrix is used if you want to have the returned values in an objects localspace.
# this is usefull when dealing with an objects data such as verts.
# or if useMid is true, the midpoint of the current 3dview
# returns
# Origin - the origin point of the pick ray
# Direction - the direction vector of the pick ray
# in global coordinates
epsilon = 1e-3 # just a small value to account for floating point errors
def getPickRay(screen_x, screen_y, localMatrix=None, useMid = False):
# Constant function variables
p = getPickRay.p
d = getPickRay.d
for win3d in Window.GetScreenInfo(Window.Types.VIEW3D): # we search all 3dwins for the one containing the point (screen_x, screen_y) (could be the mousecoords for example)
win_min_x, win_min_y, win_max_x, win_max_y = win3d['vertices']
# calculate a few geometric extents for this window
win_mid_x = (win_max_x + win_min_x + 1.0) * 0.5
win_mid_y = (win_max_y + win_min_y + 1.0) * 0.5
win_size_x = (win_max_x - win_min_x + 1.0) * 0.5
win_size_y = (win_max_y - win_min_y + 1.0) * 0.5
#useMid is for projecting the coordinates when we subdivide the screen into bins
if useMid: # == True
screen_x = win_mid_x
screen_y = win_mid_y
# if the given screencoords (screen_x, screen_y) are within the 3dwin we fount the right one...
if (win_max_x > screen_x > win_min_x) and ( win_max_y > screen_y > win_min_y):
# first we handle all pending events for this window (otherwise the matrices might come out wrong)
Window.QHandle(win3d['id'])
# now we get a few matrices for our window...
# sorry - i cannot explain here what they all do
# - if you're not familiar with all those matrices take a look at an introduction to OpenGL...
pm = Window.GetPerspMatrix() # the prespective matrix
pmi = Matrix(pm); pmi.invert() # the inverted perspective matrix
if (1.0 - epsilon < pmi[3][3] < 1.0 + epsilon):
# pmi[3][3] is 1.0 if the 3dwin is in ortho-projection mode (toggled with numpad 5)
hms = getPickRay.hms
ortho_d = getPickRay.ortho_d
# ortho mode: is a bit strange - actually there's no definite location of the camera ...
# but the camera could be displaced anywhere along the viewing direction.
ortho_d.x, ortho_d.y, ortho_d.z = Window.GetViewVector()
ortho_d.w = 0
# all rays are parallel in ortho mode - so the direction vector is simply the viewing direction
hms.x, hms.y, hms.z, hms.w = (screen_x-win_mid_x) /win_size_x, (screen_y-win_mid_y) / win_size_y, 0.0, 1.0
# these are the homogenious screencoords of the point (screen_x, screen_y) ranging from -1 to +1
p=(hms*pmi) + (1000*ortho_d)
p.resize3D()
d.x, d.y, d.z = ortho_d.x, ortho_d.y, ortho_d.z
# Finally we shift the position infinitely far away in
# the viewing direction to make sure the camera if outside the scene
# (this is actually a hack because this function
# is used in sculpt_mesh to initialize backface culling...)
else:
# PERSPECTIVE MODE: here everything is well defined - all rays converge at the camera's location
vmi = Matrix(Window.GetViewMatrix()); vmi.invert() # the inverse viewing matrix
fp = getPickRay.fp
dx = pm[3][3] * (((screen_x-win_min_x)/win_size_x)-1.0) - pm[3][0]
dy = pm[3][3] * (((screen_y-win_min_y)/win_size_y)-1.0) - pm[3][1]
fp.x, fp.y, fp.z = \
pmi[0][0]*dx+pmi[1][0]*dy,\
pmi[0][1]*dx+pmi[1][1]*dy,\
pmi[0][2]*dx+pmi[1][2]*dy
# fp is a global 3dpoint obtained from "unprojecting" the screenspace-point (screen_x, screen_y)
#- figuring out how to calculate this took me quite some time.
# The calculation of dxy and fp are simplified versions of my original code
#- so it's almost impossible to explain what's going on geometrically... sorry
p.x, p.y, p.z = vmi[3][:3]
# the camera's location in global 3dcoords can be read directly from the inverted viewmatrix
#d.x, d.y, d.z =normalize_v3(sub_v3v3(p, fp))
d.x, d.y, d.z = p.x-fp.x, p.y-fp.y, p.z-fp.z
#print 'd', d, 'p', p, 'fp', fp
# the direction vector is simply the difference vector from the virtual camera's position
#to the unprojected (screenspace) point fp
# Do we want to return a direction in object's localspace?
if localMatrix:
localInvMatrix = Matrix(localMatrix)
localInvMatrix.invert()
p = p*localInvMatrix
d = d*localInvMatrix # normalize_v3
p.x += localInvMatrix[3][0]
p.y += localInvMatrix[3][1]
p.z += localInvMatrix[3][2]
#else: # Worldspace, do nothing
d.normalize()
return True, p, d # Origin, Direction
# Mouse is not in any view, return None.
return False, None, None
# Constant function variables
getPickRay.d = Vector(0,0,0) # Perspective, 3d
getPickRay.p = Vector(0,0,0)
getPickRay.fp = Vector(0,0,0)
getPickRay.hms = Vector(0,0,0,0) # ortho only 4d
getPickRay.ortho_d = Vector(0,0,0,0) # ortho only 4d
def ui_set_preferences(user_interface=1):
# Create data and set defaults.
ADAPTIVE_GEOMETRY_but = Draw.Create(1)
BRUSH_MODE_but = Draw.Create(1)
BRUSH_PRESSURE_but = Draw.Create(0.05)
BRUSH_RADIUS_but = Draw.Create(0.25)
RESOLUTION_MIN_but = Draw.Create(0.1)
DISPLACE_NORMAL_MODE_but = Draw.Create(2)
STATIC_NORMAL_but = Draw.Create(1)
XPLANE_CLIP_but = Draw.Create(0)
STATIC_MESH_but = Draw.Create(1)
FIX_TOPOLOGY_but = Draw.Create(1)
# Remember old variables if alredy set.
try:
ADAPTIVE_GEOMETRY_but.val = Blender.bbrush['ADAPTIVE_GEOMETRY']
BRUSH_MODE_but.val = Blender.bbrush['BRUSH_MODE']
BRUSH_PRESSURE_but.val = Blender.bbrush['BRUSH_PRESSURE']
BRUSH_RADIUS_but.val = Blender.bbrush['BRUSH_RADIUS']
RESOLUTION_MIN_but.val = Blender.bbrush['RESOLUTION_MIN']
DISPLACE_NORMAL_MODE_but.val = Blender.bbrush['DISPLACE_NORMAL_MODE']
STATIC_NORMAL_but.val = Blender.bbrush['STATIC_NORMAL']
XPLANE_CLIP_but.val = Blender.bbrush['XPLANE_CLIP']
STATIC_MESH_but.val = Blender.bbrush['STATIC_MESH']
FIX_TOPOLOGY_but.val = Blender.bbrush['FIX_TOPOLOGY']
except:
Blender.bbrush = {}
if user_interface:
pup_block = [\
'Brush Options',\
('Adaptive Geometry', ADAPTIVE_GEOMETRY_but, 'Add and remove detail as needed. Uses min/max resolution.'),\
('Brush Type: ', BRUSH_MODE_but, 1, 5, 'Push/Pull:1, Grow/Shrink:2, Spin:3, Relax:4, Goo:5'),\
('Pressure: ', BRUSH_PRESSURE_but, 0.0, 1.0, 'Pressure of the brush.'),\
('Size: ', BRUSH_RADIUS_but, 0.0, 2.0, 'Size of the brush.'),\
('Geometry Res: ', RESOLUTION_MIN_but, 0.1, 0.5, 'Size of the brush & Adaptive Subdivision.'),\
('Displace Vector: ', DISPLACE_NORMAL_MODE_but, 1, 4, 'Vertex Normal:1, Median Normal:2, Face Normal:3, View Normal:4'),\
('Static Normal', STATIC_NORMAL_but, 'Use the initial normal only.'),\
('No X Crossing', XPLANE_CLIP_but, 'Dont allow verts to have a negative X axis (use for x-mirror).'),\
('Static Mesh', STATIC_MESH_but, 'During mouse interaction, dont update the mesh.'),\
#('Fix Topology', FIX_TOPOLOGY_but, 'Fix the mesh structure by rotating edges '),\
]
Draw.PupBlock('BlenBrush Prefs (RMB)', pup_block)
Blender.bbrush['ADAPTIVE_GEOMETRY'] = ADAPTIVE_GEOMETRY_but.val
print 'ADAPTIVE_GEOMETRY', ADAPTIVE_GEOMETRY_but.val
Blender.bbrush['BRUSH_MODE'] = BRUSH_MODE_but.val
Blender.bbrush['BRUSH_PRESSURE'] = BRUSH_PRESSURE_but.val
Blender.bbrush['BRUSH_RADIUS'] = BRUSH_RADIUS_but.val
Blender.bbrush['RESOLUTION_MIN'] = RESOLUTION_MIN_but.val
Blender.bbrush['DISPLACE_NORMAL_MODE'] = DISPLACE_NORMAL_MODE_but.val
Blender.bbrush['STATIC_NORMAL'] = STATIC_NORMAL_but.val
Blender.bbrush['XPLANE_CLIP'] = XPLANE_CLIP_but.val
Blender.bbrush['STATIC_MESH'] = STATIC_MESH_but.val
Blender.bbrush['FIX_TOPOLOGY'] = FIX_TOPOLOGY_but.val
def triangulateNMesh(nm):
'''
Converts the meshes faces to tris, modifies the mesh in place.
'''
NMesh = Blender.NMesh
#============================================================================#
# Returns a new face that has the same properties as the origional face #
# but with no verts #
#============================================================================#
def copyFace(face):
newFace = NMesh.Face()
# Copy some generic properties
newFace.mode = face.mode
if face.image != None:
newFace.image = face.image
newFace.flag = face.flag
newFace.mat = face.mat
newFace.smooth = face.smooth
return newFace
# 2 List comprehensions are a lot faster then 1 for loop.
tris = [f for f in nm.faces if len(f) == 3]
quads = [f for f in nm.faces if len(f) == 4]
if quads: # Mesh may have no quads.
has_uv = quads[0].uv
has_vcol = quads[0].col
for quadFace in quads:
# Triangulate along the shortest edge
if (quadFace.v[0].co - quadFace.v[2].co).length < (quadFace.v[1].co - quadFace.v[3].co).length:
# Method 1
triA = 0,1,2
triB = 0,2,3
else:
# Method 2
triA = 0,1,3
triB = 1,2,3
for tri1, tri2, tri3 in (triA, triB):
newFace = copyFace(quadFace)
newFace.v = [quadFace.v[tri1], quadFace.v[tri2], quadFace.v[tri3]]
if has_uv: newFace.uv = [quadFace.uv[tri1], quadFace.uv[tri2], quadFace.uv[tri3]]
if has_vcol: newFace.col = [quadFace.col[tri1], quadFace.col[tri2], quadFace.col[tri3]]
nm.addEdge(quadFace.v[tri1], quadFace.v[tri3]) # Add an edge where the 2 tris are devided.
tris.append(newFace)
nm.faces = tris
import mesh_tri2quad
def fix_topolagy(mesh):
return
ob = Scene.GetCurrent().getActiveObject()
nmesh = ob.getData()
#nmesh = Blender.NMesh.GetRaw(mesh.name)
triangulateNMesh(nmesh)
mesh_tri2quad.tri2quad(nmesh, 100, 0)
triangulateNMesh(nmesh)
nmesh.update()
'''
mesh = Mesh.Get(mesh.name)
for f in mesh.faces:
f.sel=1
mesh.quadToTriangle()
'''
def event_main():
print Blender.event
#mod =[Window.Qual.CTRL, Window.Qual.ALT, Window.Qual.SHIFT]
mod =[Window.Qual.CTRL, Window.Qual.ALT]
qual = Window.GetKeyQualifiers()
SHIFT_FLAG = Window.Qual.SHIFT
CTRL_FLAG = Window.Qual.CTRL
# UNDO
"""
is_editmode = Window.EditMode() # Exit Editmode.
if is_editmode: Window.EditMode(0)
if Blender.event == Draw.UKEY:
if is_editmode:
Blender.event = Draw.UKEY
return
else:
winId = [win3d for win3d in Window.GetScreenInfo(Window.Types.VIEW3D)][0]
Blender.event = None
Window.QHandle(winId['id'])
Window.EditMode(1)
Window.QHandle(winId['id'])
Window.QAdd(winId['id'],Draw.UKEY,1) # Change KeyPress Here for EditMode
Window.QAdd(winId['id'],Draw.UKEY,0)
Window.QHandle(winId['id'])
Window.EditMode(0)
Blender.event = None
return
"""
# Mouse button down with no modifiers.
if Blender.event == Draw.LEFTMOUSE and not [True for m in mod if m & qual]:
# Do not exit (draw)
pass
elif Blender.event == Draw.RIGHTMOUSE and not [True for m in mod if m & qual]:
ui_set_preferences()
return
else:
return
del qual
try:
Blender.bbrush
except:
# First time run
ui_set_preferences() # No ui
return
ADAPTIVE_GEOMETRY = Blender.bbrush['ADAPTIVE_GEOMETRY'] # 1
BRUSH_MODE = Blender.bbrush['BRUSH_MODE'] # 1
BRUSH_PRESSURE_ORIG = Blender.bbrush['BRUSH_PRESSURE'] # 0.1
BRUSH_RADIUS = Blender.bbrush['BRUSH_RADIUS'] # 0.5
RESOLUTION_MIN = Blender.bbrush['RESOLUTION_MIN'] # 0.08
STATIC_NORMAL = Blender.bbrush['STATIC_NORMAL'] # 0
XPLANE_CLIP = Blender.bbrush['XPLANE_CLIP'] # 0
DISPLACE_NORMAL_MODE = Blender.bbrush['DISPLACE_NORMAL_MODE'] # 'Vertex Normal%x1|Median Normal%x2|Face Normal%x3|View Normal%x4'
STATIC_MESH = Blender.bbrush['STATIC_MESH']
FIX_TOPOLOGY = Blender.bbrush['FIX_TOPOLOGY']
# Angle between Vecs wrapper.
AngleBetweenVecs = Mathutils.AngleBetweenVecs
def ang(v1,v2):
try:
return AngleBetweenVecs(v1,v2)
except:
return 180
"""
def Angle2D(x1, y1, x2, y2):
import math
RAD2DEG = 57.295779513082323
'''
Return the angle between two vectors on a plane
The angle is from vector 1 to vector 2, positive anticlockwise
The result is between -pi -> pi
'''
dtheta = math.atan2(y2,x2) - math.atan2(y1,x1) # theta1 - theta2
while dtheta > math.pi:
dtheta -= (math.pi*2)
while dtheta < -math.pi:
dtheta += (math.pi*2)
return dtheta * RAD2DEG #(180.0 / math.pi)
"""
def faceIntersect(f):
isect = Intersect(f.v[0].co, f.v[1].co, f.v[2].co, Direction, Origin, 1) # Clipped.
if isect:
return isect
elif len(f.v) == 4:
isect = Intersect(f.v[0].co, f.v[2].co, f.v[3].co, Direction, Origin, 1) # Clipped.
return isect
"""
# Unused so farm, too slow.
def removeDouble(v1,v2, me):
v1List = [f for f in me.faces if v1 in f.v]
v2List = [f for f in me.faces if v2 in f.v]
#print v1List
#print v2List
remFaces = []
newFaces = []
for f2 in v2List:
f2ls = list(f2.v)
i = f2ls.index(v2)
f2ls[i] = v1
#remFaces.append(f2)
if f2ls.count(v1) == 1:
newFaces.append(tuple(f2ls))
if remFaces:
me.faces.delete(1, remFaces)
#me.verts.delete(v2)
if newFaces:
me.faces.extend(newFaces)
"""
ob = Scene.GetCurrent().getActiveObject()
if not ob or ob.getType() != 'Mesh':
return
me = ob.getData(mesh=1)
is_editmode = Window.EditMode() # Exit Editmode.
if is_editmode: Window.EditMode(0)
# At the moment ADAPTIVE_GEOMETRY is the only thing that uses selection.
if ADAPTIVE_GEOMETRY:
# Deslect all
SEL_FLAG = Mesh.EdgeFlags['SELECT']
for ed in me.edges:
#ed.flag &= ~SEL_FLAG # deselect. 34
ed.flag = 32
'''for v in me.verts:
v.sel = 0'''
filter(lambda v: setattr(v, 'sel', 0), me.verts)
i = 0
time = Blender.sys.time()
last_best_isect = None # used for goo only
old_screen_x, old_screen_y = 1<<30, 1<<30
goo_dir_vec = last_goo_dir_vec = gooRotMatrix = None # goo mode only.
# Normal stuff
iFaceNormal = medainNormal = None
# Store all vert normals for now.
if BRUSH_MODE == 1 and STATIC_NORMAL: # Push pull
vert_orig_normals = dict([(v, v.no) for v in me.verts])
elif BRUSH_MODE == 4: # RELAX, BUILD EDGE CONNECTIVITE DATA.
# we need edge connectivity
#vertEdgeUsers = [list() for i in xrange(len(me.verts))]
verts_connected_by_edge = [list() for i in xrange(len(me.verts))]
for ed in me.edges:
i1, i2 = ed.v1.index, ed.v2.index
#vertEdgeUsers[i1].append(ed)
#vertEdgeUsers[i2].append(ed)
verts_connected_by_edge[i1].append(ed.v2)
verts_connected_by_edge[i2].append(ed.v1)
if STATIC_MESH:
# Try and find a static mesh to reuse.
# this is because we dont want to make a new mesh for each stroke.
mesh_static = None
for _me_name_ in Blender.NMesh.GetNames():
_me_ = Mesh.Get(_me_name_)
#print _me_.users , len(me.verts)
if _me_.users == 0 and len(_me_.verts) == 0:
mesh_static = _me_
#print 'using', _me_.name
break
del _me_name_
del _me_
if not mesh_static:
mesh_static = Mesh.New()
print 'Making new mesh', mesh_static.name
mesh_static.verts.extend([v.co for v in me.verts])
mesh_static.faces.extend([tuple([mesh_static.verts[v.index] for v in f.v]) for f in me.faces])
best_isect = gooPlane = None
while Window.GetMouseButtons() == 1:
i+=1
screen_x, screen_y = Window.GetMouseCoords()
# Skip when no mouse movement, Only for Goo!
if screen_x == old_screen_x and screen_y == old_screen_y:
if BRUSH_MODE == 5: # Dont modify while mouse is not moved for goo.
continue
else: # mouse has moved get the new mouse ray.
old_screen_x, old_screen_y = screen_x, screen_y
mouseInView, Origin, Direction = getPickRay(screen_x, screen_y, ob.matrixWorld)
if not mouseInView or not Origin:
return
Origin_SCALE = Origin * 100
# Find an intersecting face!
bestLen = 1<<30 # start with an assumed realy bad match.
best_isect = None # last intersect is used for goo.
best_face = None
if not last_best_isect:
last_best_isect = best_isect
if not mouseInView:
last_best_isect = None
else:
# Find Face intersection closest to the view.
#for f in [f for f in me.faces if ang(f.no, Direction) < 90]:
# Goo brush only intersects faces once, after that the brush follows teh view plain.
if BRUSH_MODE == 5 and gooPlane != None and gooPlane:
best_isect = Intersect( gooPlane[0], gooPlane[1], gooPlane[2], Direction, Origin, 0) # Non clipped
else:
if STATIC_MESH:
intersectingFaces = [(f, ix) for f in mesh_static.faces for ix in (faceIntersect(f),) if ix]
else:
intersectingFaces = [(f, ix) for f in me.faces for ix in (faceIntersect(f),) if ix]
for f, isect in intersectingFaces:
l = (Origin_SCALE-isect).length
if l < bestLen:
best_face = f
best_isect = isect
bestLen = l
if not best_isect:
# Dont interpolate once the mouse moves off the mesh.
lastGooVec = last_best_isect = None
else: # mouseInView must be true also
# Use the shift key to modify the pressure.
if SHIFT_FLAG & Window.GetKeyQualifiers():
BRUSH_PRESSURE = -BRUSH_PRESSURE_ORIG
else:
BRUSH_PRESSURE = BRUSH_PRESSURE_ORIG
brush_verts = [(v,le) for v in me.verts for le in ((v.co-best_isect).length,) if le < BRUSH_RADIUS]
# SETUP ONCE ONLY VARIABLES
if STATIC_NORMAL: # Only set the normal once.
if not iFaceNormal:
iFaceNormal = best_face.no
else:
if best_face:
iFaceNormal = best_face.no
if DISPLACE_NORMAL_MODE == 2: # MEDIAN NORMAL
if (STATIC_NORMAL and medainNormal == None) or not STATIC_NORMAL:
medainNormal = Vector(0,0,0)
for v, l in brush_verts:
medainNormal += v.no*(BRUSH_RADIUS-l)
medainNormal.normalize()
# ================================================================#
# == Tool code, loop on the verts and operate on them ============#
# ================================================================#
if BRUSH_MODE == 1: # NORMAL PAINT
for v,l in brush_verts:
v.sel = 1 # MARK THE VERT AS DIRTY.
falloff = (BRUSH_RADIUS-l) / BRUSH_RADIUS # falloff between 0 and 1
if DISPLACE_NORMAL_MODE == 1: # VERTEX NORMAL
if STATIC_NORMAL:
try:
no = vert_orig_normals[v]
except:
no = vert_orig_normals[v] = v.no
v.co += (no * BRUSH_PRESSURE) * falloff
else:
v.co += (v.no * BRUSH_PRESSURE) * falloff
elif DISPLACE_NORMAL_MODE == 2: # MEDIAN NORMAL # FIXME
v.co += (medainNormal * BRUSH_PRESSURE) * falloff
elif DISPLACE_NORMAL_MODE == 3: # FACE NORMAL
v.co += (iFaceNormal * BRUSH_PRESSURE) * falloff
elif DISPLACE_NORMAL_MODE == 4: # VIEW NORMAL
v.co += (Direction * BRUSH_PRESSURE) * falloff
elif BRUSH_MODE == 2: # SCALE
for v,l in brush_verts:
v.sel = 1 # MARK THE VERT AS DIRTY.
falloff = (BRUSH_RADIUS-l) / BRUSH_RADIUS # falloff between 0 and 1
vert_scale_vec = v.co - best_isect
vert_scale_vec.normalize()
# falloff needs to be scaled for this tool
falloff = falloff / 10
v.co += (vert_scale_vec * BRUSH_PRESSURE) * falloff # FLAT BRUSH
if BRUSH_MODE == 3: # ROTATE.
if DISPLACE_NORMAL_MODE == 1: # VERTEX NORMAL
ROTATE_MATRIX = Mathutils.RotationMatrix(BRUSH_PRESSURE*10, 4, 'r', iFaceNormal) # Cant use vertex normal, use face normal
elif DISPLACE_NORMAL_MODE == 2: # MEDIAN NORMAL
ROTATE_MATRIX = Mathutils.RotationMatrix(BRUSH_PRESSURE*10, 4, 'r', medainNormal) # Cant use vertex normal, use face normal
elif DISPLACE_NORMAL_MODE == 3: # FACE NORMAL
ROTATE_MATRIX = Mathutils.RotationMatrix(BRUSH_PRESSURE*10, 4, 'r', iFaceNormal) # Cant use vertex normal, use face normal
elif DISPLACE_NORMAL_MODE == 4: # VIEW NORMAL
ROTATE_MATRIX = Mathutils.RotationMatrix(BRUSH_PRESSURE*10, 4, 'r', Direction) # Cant use vertex normal, use face normal
# Brush code
for v,l in brush_verts:
# MARK THE VERT AS DIRTY.
v.sel = 1
falloff = (BRUSH_RADIUS-l) / BRUSH_RADIUS # falloff between 0 and 1
# Vectors handeled with rotation matrix creation.
rot_vert_loc = (ROTATE_MATRIX * (v.co-best_isect)) + best_isect
v.co = (v.co*(1-falloff)) + (rot_vert_loc*(falloff))
elif BRUSH_MODE == 4: # RELAX
vert_orig_loc = [Vector(v.co) for v in me.verts ] # save orig vert location.
#vertOrigNor = [Vector(v.no) for v in me.verts ] # save orig vert location.
# Brush code
for v,l in brush_verts:
v.sel = 1 # Mark the vert as dirty.
falloff = (BRUSH_RADIUS-l) / BRUSH_RADIUS # falloff between 0 and 1
connected_verts = verts_connected_by_edge[v.index]
relax_point = reduce(lambda a,b: a + vert_orig_loc[b.index], connected_verts, Mathutils.Vector(0,0,0)) * (1.0/len(connected_verts))
falloff = falloff * BRUSH_PRESSURE
# Old relax.
#v.co = (v.co*(1-falloff)) + (relax_point*(falloff))
ll = (v.co-relax_point).length
newpoint = (v.co*(1-falloff)) + (relax_point*(falloff)) - v.co
newpoint = newpoint * (1/(1+ll))
v.co = v.co + newpoint
'''
# New relax
relax_normal = vertOrigNor[v.index]
v1,v2,v3,v4 = v.co, v.co+relax_normal, relax_point-(relax_normal*10), relax_point+(relax_normal*10)
print v1,v2,v3,v4
try:
a,b = LineIntersect(v1,v2,v3,v4) # Scale the normal to make a line. we know we will intersect with.
v.co = (v.co*(1-falloff)) + (a*(falloff))
except:
pass
'''
elif BRUSH_MODE == 5: # GOO
#print last_best_isect, best_isect, 'AA'
if not last_best_isect:
last_best_isect = best_isect
# Set up a triangle orthographic to the view plane
gooPlane = [best_isect, CrossVecs(best_isect, Direction), None]
if DISPLACE_NORMAL_MODE == 4: # View Normal
tempRotMatrix = Mathutils.RotationMatrix(90, 3, 'r', Direction)
else:
tempRotMatrix = Mathutils.RotationMatrix(90, 3, 'r', CrossVecs(best_face.no, Direction))
gooPlane[2] = best_isect + (tempRotMatrix * gooPlane[1])
gooPlane[1] = gooPlane[1] + best_isect
continue # we need another point of reference.
elif last_best_isect == best_isect:
# Mouse has not moved, no point in trying to goo.
continue
else:
if goo_dir_vec:
last_goo_dir_vec = goo_dir_vec
# The direction the mouse moved in 3d space. use for gooing
# Modify best_isect so its not moving allong the view z axis.
# Assume Origin hasnt changed since the view wont change while the mouse is drawing. ATM.
best_isect = Intersect( gooPlane[0], gooPlane[1], gooPlane[2], Direction, Origin, 0) # Non clipped
goo_dir_vec = (best_isect - last_best_isect) * 2
# make a goo rotation matrix so the head of the goo rotates with the mouse.
"""
if last_goo_dir_vec and goo_dir_vec != last_goo_dir_vec:
'''
vmi = Matrix(Window.GetViewMatrix()); vmi.invert() # the inverse viewing matrix
a = last_goo_dir_vec * vmi
b = goo_dir_vec * vmi
c = Angle2D(a.x, a.y, b.x, b.y)
gooRotMatrix = Mathutils.RotationMatrix((c * goo_dir_vec.length)*-20, 3, 'r', Direction)
'''
pass
else:
gooRotMatrix = None
"""
if goo_dir_vec.x == 0 and goo_dir_vec.y == 0 and goo_dir_vec.z == 0:
continue
# Brush code
for v,l in brush_verts:
# MARK THE VERT AS DIRTY.
v.sel = 1
''' # ICICLES!!!
a = AngleBetweenVecs(goo_dir_vec, v.no)
if a > 66:
continue
l = l * ((1+a)/67.0)
l = max(0.00000001, l)
'''
falloff = (BRUSH_RADIUS-l) / BRUSH_RADIUS # falloff between 0 and 1
goo_loc = (v.co*(1-falloff)) + ((v.co+goo_dir_vec) *falloff)
v.co = (goo_loc*BRUSH_PRESSURE) + (v.co*(1-BRUSH_PRESSURE))
'''
if gooRotMatrix:
rotatedVertLocation = (gooRotMatrix * (v.co-best_isect)) + best_isect
v.co = (v.co*(1-falloff)) + (rotatedVertLocation*(falloff))
# USe for goo only.
'''
# Remember for the next sample
last_best_isect = best_isect
last_goo_dir_vec = goo_dir_vec
# Post processing after the verts have moved
# Subdivide any large edges, all but relax.
MAX_SUBDIV = 10 # Maximum number of subdivisions per redraw. makes things useable.
SUBDIV_COUNT = 0
if ADAPTIVE_GEOMETRY and (BRUSH_MODE == 1 or BRUSH_MODE == 2 or BRUSH_MODE == 3 or BRUSH_MODE == 5):
orig_len_edges = 0
#print 'ADAPTIVE_GEOMETRY'
while len(me.edges) != orig_len_edges and SUBDIV_COUNT < MAX_SUBDIV:
#print 'orig_len_edges', len(me.edges)
#me = ob.getData(mesh=1)
orig_len_edges = len(me.edges)
EDGE_COUNT = 0
for ed in me.edges:
if ed.v1.sel or ed.v2.sel:
l = (ed.v1.co - ed.v2.co).length
#if l > RESOLUTION_MAX:
if l > BRUSH_RADIUS:
#print 'adding edge'
#ed.flag |= SEL_FLAG
ed.flag = 35
SUBDIV_COUNT += 1
EDGE_COUNT +=1
"""
elif l < RESOLUTION_MIN:
'''
print 'removing edge'
v1 =e.v1
v2 =e.v2
v1.co = v2.co = (v1.co + v2.co) * 0.5
v1.sel = v2.sel = 1
me.remDoubles(0.001)
me = ob.getData(mesh=1)
break
'''
# Remove edge in python
print 'removing edge'
v1 =ed.v1
v2 =ed.v2
v1.co = v2.co = (v1.co + v2.co) * 0.5
removeDouble(v1, v2, me)
me = ob.getData(mesh=1)
break
"""
if EDGE_COUNT:
me.subdivide(1)
# Deselect all, we know theres only 2 selected
for ee in me.edges:
if ee.flag & SEL_FLAG:
#ee.flag &= ~SEL_FLAG
ee.flag = 32
'''
elif l < RESOLUTION_MIN:
print 'removing edge'
e.v1.co = e.v2.co = (e.v1.co + e.v2.co) * 0.5
me.remDoubles(0.001)
break
'''
# WHILE OVER
# Clean up selection.
#for v in me.verts:
# v.sel = 0
filter(lambda v: setattr(v, 'sel', 0), me.verts)
if XPLANE_CLIP:
filter(lambda v: setattr(v.co, 'x', max(0, v.co.x)), me.verts)
me.update()
#Window.SetCursorPos(best_isect.x, best_isect.y, best_isect.z)
Window.Redraw(Window.Types.VIEW3D)
if i:
Window.EditMode(1)
if not is_editmode: # User was in edit mode, so stay there.
Window.EditMode(0)
print '100 draws in %.6f' % (((Blender.sys.time()-time) / float(i))*100)
#Window.DrawProgressBar(1.0, '')
if STATIC_MESH:
#try:
mesh_static.verts = None
print len(mesh_static.verts)
mesh_static.update()
#except:
# pass
if FIX_TOPOLOGY:
fix_topolagy(me)
Blender.event = Draw.LEFTMOUSE
if __name__ == '__main__':
event_main()