def nautical_euler_from_axes(forward, right):
x = Vector(right)
y = Vector(forward)
world_x = Vector((1, 0, 0))
world_z = Vector((0, 0, 1))
if abs(y.z) > (1 - 1e-12): # sufficiently close to vertical
roll = 0.0
xdir = x.copy()
else:
xdir = y.cross(world_z)
rollPos = angle_signed(-y, x, xdir, 0.0)
rollNeg = angle_signed(-y, x, -xdir, 0.0)
if abs(rollNeg) < abs(rollPos):
roll = rollNeg
xdir = -xdir
else:
roll = rollPos
xdir = Vector((xdir.x, xdir.y, 0)).normalized()
yaw = angle_signed(-world_z, xdir, world_x, 0.0)
zdir = xdir.cross(y).normalized()
pitch = angle_signed(-xdir, zdir, world_z, 0.0)
return Euler((pitch, roll, yaw), 'YXZ')
def arbitrary_x_axis(extrusion_normal):
world_y = Vector((0, 1, 0))
world_z = Vector((0, 0, 1))
if abs(extrusion_normal[0]) < 1 / 64 and abs(extrusion_normal[1]) < 1 / 64:
a_x = world_y.cross(extrusion_normal)
else:
a_x = world_z.cross(extrusion_normal)
a_x.normalize()
return a_x, extrusion_normal.cross(a_x)
def _gimbal_xyz(self, context, am):
rotobj = (context.active_pose_bone if context.mode == 'POSE' else None) or context.active_object
if (not rotobj) or (rotobj.rotation_mode == 'QUATERNION'):
if not am: am = self.calc_active_matrix(context)
xyz = am.col[:3]
elif rotobj.rotation_mode == 'AXIS_ANGLE':
aa = rotobj.rotation_axis_angle
z = Vector(aa[1:]).normalized()
q = Vector((0,0,1)).rotation_difference(z)
x = (q * Vector((1,0,0))).normalized()
y = z.cross(x)
else:
e = rotobj.rotation_euler
m = Matrix.Identity(3)
for e_ax in rotobj.rotation_mode:
m = Matrix.Rotation(getattr(e, e_ax.lower()), 3, e_ax) * m
x, y, z = m.col[:3]
if not xyz:
m = BlUtil.Object.matrix_parent(rotobj)
x.rotate(m)
y.rotate(m)
z.rotate(m)
xyz = x, y, z
return xyz
def rotate(self,v):
up_axis = Vector((0.0, 0.0, 1.0))
angle = v.angle(up_axis, 0)
rotation_axis = up_axis.cross(v)
bpy.ops.transform.rotate(value=angle,axis=rotation_axis)
return
def __get(self): # in object axes
world_x = Vector((1, 0, 0))
world_z = Vector((0, 0, 1))
x = self.right # right
y = self.forward # forward
z = self.up # up
if abs(y.z) > (1 - 1e-12): # sufficiently close to vertical
roll = 0.0
xdir = x.copy()
else:
xdir = y.cross(world_z)
rollPos = angle_signed(-y, x, xdir, 0.0)
rollNeg = angle_signed(-y, x, -xdir, 0.0)
if abs(rollNeg) < abs(rollPos):
roll = rollNeg
xdir = -xdir
else:
roll = rollPos
xdir = Vector((xdir.x, xdir.y, 0)).normalized()
yaw = angle_signed(-world_z, xdir, world_x, 0.0)
zdir = xdir.cross(y).normalized()
pitch = angle_signed(-xdir, zdir, world_z, 0.0)
return Euler((pitch, roll, yaw), 'YXZ')
def focus_view_on(region_3d, location):
r3d = region_3d
a = r3d.view_location.copy()
b = location
mm = r3d.view_matrix.inverted()
vr = mm.to_3x3()
loc = mm.translation
n = (a-loc).cross(b-loc).normalized()
alp = math.acos( max(-1.0,min(1.0, (a-loc).normalized().dot( (b-loc).normalized() ) )))
zero = Vector()
u0,v0,w0 = vr.transposed()
u = rot_on( zero, n, alp, u0 )
v = rot_on( zero, n, alp, v0 )
w = rot_on( zero, n, alp, w0 )
if bpy.context.user_preferences.inputs.view_rotate_method == 'TURNTABLE':
ez = Vector((0,0,1))
u2 = ez.cross(w)
v2 = w.cross(u2)
u,v = u2,v2
vr2 = Matrix((u,v,w)).transposed()
mm2 = vr2.to_4x4()
mm2[0][3] = loc[0]
mm2[1][3] = loc[1]
mm2[2][3] = loc[2]
dist0 = (loc-location).length
r3d.view_distance = dist0
r3d.view_matrix = mm2.inverted()
def add_f_curve_modifiers(armature_object, strength, speed):
wind_vector = Vector((1, 0, 0)) * strength
fcurves = armature_object.animation_data.action.fcurves
for f in fcurves:
for m in f.modifiers:
f.modifiers.remove(m)
bones = organize_bones(armature_object)
for b in bones:
mass = b.bone.tail_radius ** 2 * b.length
barycenter = b.tail * mass
for c in b.children:
mass += c["mass"]
barycenter += Vector(c["barycenter"])
b["mass"] = mass
b["barycenter"] = barycenter
barycenter /= mass
b.rotation_mode = 'XYZ'
b.keyframe_insert('rotation_euler', frame=0, index=0)
b.keyframe_insert('rotation_euler', frame=0, index=2)
fcurves = armature_object.animation_data.action.fcurves
for i in range(len(bones)):
f0 = fcurves[2 * i]
f1 = fcurves[2 * i + 1]
b = bones[i]
i_base = b.matrix.to_3x3().inverted()
bone_vector = b.tail - b.head
inertia_moment = bone_vector.length ** 2 * bones[i]["mass"] / 10000
damping = 0.5 * b.bone.tail_radius
stiffness = b.bone.tail_radius ** 2 / b.length * 800
if b.parent is not None and len(b.parent.children) > 1:
stiffness *= 2
# torque /= 3
# else:
# torque = Vector((0, 0, 0))
torque = i_base * wind_vector.cross(bone_vector) / (b.bone.tail_radius) / 1000
f = sqrt(abs(damping ** 2 - 4 * inertia_moment * stiffness)) / (5*b.bone.tail_radius) * speed
x_amplitude = torque.x
z_amplitude = torque.z
m0 = f0.modifiers.new(type='FNGENERATOR')
m1 = f1.modifiers.new(type='FNGENERATOR')
m0.function_type = 'SIN'
m1.function_type = 'SIN'
m0.amplitude = x_amplitude
m1.amplitude = z_amplitude
m0.phase_multiplier = f
m1.phase_multiplier = f
m0.value_offset = x_amplitude * 3
m1.value_offset = z_amplitude * 3
def vec_roll_to_mat3(axis, roll):
"""Computes 3x3 Matrix from rotation axis and its roll.
:param axis: Rotation
:type axis: Vector
:param roll: Roll
:type roll: float
:return: 3x3 Matrix
:rtype: Matrix
"""
nor = axis.normalized()
target = Vector((0, 1, 0))
axis = target.cross(nor)
if axis.dot(axis) > 1.0e-9:
axis.normalize()
theta = _math_utils.angle_normalized_v3v3(target, nor)
b_matrix = Matrix.Rotation(theta, 4, axis)
else:
if target.dot(nor) > 0:
up_or_down = 1.0
else:
up_or_down = -1.0
b_matrix = Matrix()
b_matrix[0] = (up_or_down, 0, 0, 0)
b_matrix[1] = (0, up_or_down, 0, 0)
b_matrix[2] = (0, 0, 1, 0)
b_matrix[3] = (0, 0, 0, 1)
roll_matrix = Matrix.Rotation(roll, 4, nor)
return (roll_matrix * b_matrix).to_3x3()
def get_align_matrix(location, normal):
up = Vector((0, 0, 1))
angle = normal.angle(up)
axis = up.cross(normal)
mat_rot = Matrix.Rotation(angle, 4, axis)
mat_loc = Matrix.Translation(location)
mat_align = mat_rot * mat_loc
return mat_align
def find_norm_vectors(mesh, vert_dict):
vertices = list(vert_dict.keys())
for vert in vertices:
edge_vectors = []
for edge in vert_dict[vert].edges:
if vert == edge[0]:
vec = mesh.vertices[edge[0]].co.copy() - mesh.vertices[edge[1]].co.copy()
else:
vec = mesh.vertices[edge[1]].co.copy() - mesh.vertices[edge[0]].co.copy()
edge_vectors.append(vec/vec.length)
vec1 = Vector.cross(edge_vectors[0], edge_vectors[1])
edges_vec = edge_vectors[1] + edge_vectors[0]
norm_vec = Vector.cross(vec1, edges_vec)
if norm_vec.length < 1e-12: #hackish fix for flat surfaces and straight edges
norm_vec = edge_vectors[0]
vert_dict[vert].new_index = len(mesh.vertices) + vertices.index(vert)
vert_dict[vert].norm_vec = norm_vec
vert_dict[vert].edge_vec = edge_vectors[0]
def set_bonded(atom,b):
"""Sets the positions of all atoms bonded to atom.
atom: Atom object
rotate: Boolean defining whether or not to rotate tetrahedron around the z-axis
b: bond length
"""
x = 0
y = 0
z = 0
b = b*sqrt(atom.radius)
bonds = atom.bonds
#Differences in position between central atom and bonded atom
for item in bonds:
if isinstance(item, Atom):
x = atom.pos[0] - item.pos[0]
y = atom.pos[1] - item.pos[1]
z = atom.pos[2] - item.pos[2]
break
n = math.radians(109.5)
n2 = pi*2/3
#Represents tetrahedron base centered at (0,0,0)
v1 = Vector((b*sin(n),0,b*cos(n)))
v2 = Vector((b*cos(n2),b*sin(n2),b*cos(n)))
v3 = Vector((b*cos(2*n2),b*sin(2*n2),b*cos(n)))
offset = (Vector((atom.pos)))
top= Vector((0,0,-b))
diff = Vector((x,y,z))
axis = top.cross(diff)
a = -(top.angle(diff, 0))
m = Matrix.Rotation(a,3,axis)
#Rotates the tetrahedron base to align itself with the starting vector
v1 = v1*m
v2 = v2*m
v3 = v3*m
#Sets the positions of bonded atoms to locations in the tetrahedron, scales bond lengths and moves tetrahedron
if len(bonds) >1:
if isinstance(bonds[1], Atom):
bonds[1].pos = v1*sqrt(bonds[1].radius)+offset
if len(bonds) >2:
if isinstance(bonds[2], Atom):
bonds[2].pos = v2*sqrt(bonds[2].radius)+offset
if len(bonds)>3:
if isinstance(bonds[3],Atom):
bonds[3].pos = v3*sqrt(bonds[3].radius)+offset
def make_strut(v1, v2, id, od, n, solid, loops):
v1 = Vector(v1)
v2 = Vector(v2)
axis = v2 - v1
pos = [(0, od / 2)]
if loops:
pos += [((od - id) / 2, od / 2),
(axis.length - (od - id) / 2, od / 2)]
pos += [(axis.length, od / 2)]
if solid:
pos += [(axis.length, id / 2)]
if loops:
pos += [(axis.length - (od - id) / 2, id / 2),
((od - id) / 2, id / 2)]
pos += [(0, id / 2)]
vps = len(pos)
fps = vps
if not solid:
fps -= 1
fw = axis.copy()
fw.normalize()
if (abs(axis[0] / axis.length) < 1e-5
and abs(axis[1] / axis.length) < 1e-5):
up = Vector((-1, 0, 0))
else:
up = Vector((0, 0, 1))
lf = up.cross(fw)
lf.normalize()
up = fw.cross(lf)
mat = Matrix((fw, lf, up))
mat.transpose()
verts = [None] * n * vps
faces = [None] * n * fps
for i in range(n):
base = (i - 1) * vps
x = cossin[i][0]
y = cossin[i][1]
for j in range(vps):
p = Vector((pos[j][0], pos[j][1] * x, pos[j][1] * y))
p = mat * p
verts[i * vps + j] = p + v1
if i:
for j in range(fps):
f = (i - 1) * fps + j
faces[f] = [base + j, base + vps + j,
base + vps + (j + 1) % vps, base + (j + 1) % vps]
base = len(verts) - vps
i = n
for j in range(fps):
f = (i - 1) * fps + j
faces[f] = [base + j, j, (j + 1) % vps, base + (j + 1) % vps]
#print(verts,faces)
return verts, faces
def calc_average_area(mdl):
frame = mdl.frames[0]
if frame.type:
frame = frame.frames[0]
totalarea = 0.0
for tri in mdl.tris:
verts = tuple(map(lambda i: frame.verts[i], tri.verts))
a = Vector(verts[0].r) - Vector(verts[1].r)
b = Vector(verts[2].r) - Vector(verts[1].r)
c = a.cross(b)
totalarea += (c * c) ** 0.5 / 2.0
return totalarea / len(mdl.tris)
def calcRotAngle(self, axis, nor_x, nor_y, nor_z):
theta = 0
vector_z = Vector((0.0, 0.0, 1.0))
vector_n = None
vector_cross = None
if axis == 'X':
vector_n = Vector((0.0, nor_y, nor_z))
theta = vector_z.angle(vector_n, 999)
vector_cross = vector_n.cross(vector_z)
if vector_cross.x < 0:
theta = -(theta)
elif axis == 'Y':
vector_n = Vector((nor_x, 0.0, nor_z))
theta = vector_z.angle(vector_n, 999)
vector_cross = vector_n.cross(vector_z)
if vector_cross.y < 0:
theta = -(theta)
else:
pass
return theta
def vec_roll_to_mat3(vec, roll): target = Vector((0,1,0)) nor = vec.normalized() axis = target.cross(nor) if axis.dot(axis) > 0.000001: axis.normalize() theta = target.angle(nor) bMatrix = Matrix.Rotation(theta, 3, axis) else: updown = 1 if target.dot(nor) > 0 else -1 bMatrix = Matrix.Scale(updown, 3) rMatrix = Matrix.Rotation(roll, 3, nor) mat = rMatrix * bMatrix return mat
def convert_bump(pixels, width, height):
outp = list(pixels)
for y in range(1, height - 1):
for x in range(1, width - 1):
i = ((y * width + x) * 4,
(y * width + x - 1) * 4,
(y * width + x + 1) * 4,
((y - 1) * width + x) * 4,
((y + 1) * width + x) * 4)
dx = Vector((1, 0, (pixels[i[2]] - pixels[i[1]]) / 2.0))
dy = Vector((0, 1, (pixels[i[4]] - pixels[i[3]]) / 2.0))
n = dx.cross(dy)
n.normalize()
outp[i[0]:i[0]+3] = map(lambda x: int(x * 127) + 128, list(n))
return outp
def matchPoleTarget(pb, above, below):
x = Vector(above.matrix.col[1][:3])
y = Vector(below.matrix.col[1][:3])
p0 = Vector(below.matrix.col[3][:3])
n = x.cross(y)
if abs(n.length) > 1e-4:
z = x - y
n.normalize()
z -= z.dot(n)*n
z.normalize()
p = p0 + 6*pb.length*z
else:
p = p0
gmat = Matrix.Translation(p)
pmat = getPoseMatrix(gmat, pb)
insertLocation(pb, pmat)
def fencehop(): cont = bge.logic.getCurrentController() own = cont.owner auto_action = cont.sensors['auto_action'] if not auto_action: return False elif own['isSpaceon']: #Gather info on the fence fence_obj = auto_action.hitObject fence_pos = fence_obj.worldPosition #get the normal of the fence hit_norm = Vector(auto_action.hitNormal) hit_norm.z = 0.0 #Vector axis of Sintel own_negative_y = Vector(own.getAxisVect((0.0, -1.0, 0.0))) own_negative_y.z = 0.0 #Cross it, then get the absolute vaule cross = hit_norm.cross(own_negative_y) cross = math.fabs(cross[2]) #print (cross) #Check the angle of approach if cross <=.5: new_pos = (fence_pos[2] + 2) own.worldPosition[2] = new_pos own['Leaping']=True CURRENT_SPEED = own.getLinearVelocity(True) if CURRENT_SPEED[1] < 11: CURRENT_SPEED[1] = 11 CURRENT_SPEED[2] = 10 #print (CURRENT_SPEED) own.setLinearVelocity(CURRENT_SPEED ,True) own['Tracking']=False return True else: return False
def matchIkLeg(legIk, toeFk, mBall, mToe, mHeel):
rmat = toeFk.matrix.to_3x3()
tHead = Vector(toeFk.matrix.col[3][:3])
ty = rmat.col[1]
tail = tHead + ty * toeFk.bone.length
zBall = mBall.matrix.col[3][2]
zToe = mToe.matrix.col[3][2]
zHeel = mHeel.matrix.col[3][2]
x = Vector(rmat.col[0])
y = Vector(rmat.col[1])
z = Vector(rmat.col[2])
if zHeel > zBall and zHeel > zToe:
# 1. foot.ik is flat
if abs(y[2]) > abs(z[2]):
y = -z
y[2] = 0
else:
# 2. foot.ik starts at heel
hHead = Vector(mHeel.matrix.col[3][:3])
y = tail - hHead
y.normalize()
x -= x.dot(y)*y
x.normalize()
if abs(x[2]) < 0.7:
x[2] = 0
x.normalize()
z = x.cross(y)
head = tail - y * legIk.bone.length
# Create matrix
gmat = Matrix()
gmat.col[0][:3] = x
gmat.col[1][:3] = y
gmat.col[2][:3] = z
gmat.col[3][:3] = head
pmat = getPoseMatrix(gmat, legIk)
insertLocation(legIk, pmat)
insertRotation(legIk, pmat)
def polygon_area(verts, poly):
''' The area of the given polygon '''
if len(poly) < 3: # not a plane - no area
return 0
total = Vector([0, 0, 0])
N = len(poly)
for i in range(N):
vi1 = Vector(verts[poly[i]])
vi2 = Vector(verts[poly[(i + 1) % N]])
prod = vi1.cross(vi2)
total[0] += prod[0]
total[1] += prod[1]
total[2] += prod[2]
normal = Vector(polygon_normal(verts, poly))
area = abs(total.dot(normal)) / 2
return area
def area_pol(poly):
if len(poly) < 3: # not a plane - no area
return 0
total = Vector((0, 0, 0))
for i in range(len(poly)):
vi1 = Vector(poly[i])
if i is len(poly)-1:
vi2 = Vector(poly[0])
else:
vi2 = Vector(poly[i+1])
prod = vi1.cross(vi2)[:]
total[0] += prod[0]
total[1] += prod[1]
total[2] += prod[2]
result = total.dot(unit_normal(poly[0], poly[1], poly[2]))
return abs(result/2)
def main(): cont = bge.logic.getCurrentController() own = cont.owner wall_ray = cont.sensors["wall_ray"] wall_normal = Vector(wall_ray.hitNormal) wall_normal.z = 0.0 own_negative_y = Vector(own.getAxisVect((0.0, -1.0, 0.0))) own_negative_y.z = 0.0 cross = wall_normal.cross(own_negative_y) if cross.z > 0.0: new_dir = Matrix.Rotation(-90.0, 3, 'X') * wall_normal else: new_dir = Matrix.Rotation(90.0, 3, 'X') * wall_normal #print (new_dir) #own.alignAxisToVect(new_dir, 0, .1)
def trackball(p1x, p1y, p2x, p2y, TRACKBALLSIZE=1.0):
#"""
#if (p1x == p2x) and (p1y == p2y):
# return Quaternion() # Zero rotation
# First, figure out z-coordinates for projection of P1 and P2 to deformed sphere
p1 = Vector((p1x, p1y, tb_project_to_sphere(TRACKBALLSIZE, p1x, p1y)))
p2 = Vector((p2x, p2y, tb_project_to_sphere(TRACKBALLSIZE, p2x, p2y)))
# Now, we want the cross product of P1 and P2
a = p2.cross(p1) # vcross(p2,p1,a); # Axis of rotation
# Figure out how much to rotate around that axis.
d = p1 - p2
t = d.magnitude / (2.0*TRACKBALLSIZE)
# Avoid problems with out-of-control values...
t = min(max(t, -1.0), 1.0)
#phi = 2.0 * math.asin(t) # how much to rotate about axis
phi = 2.0 * t # how much to rotate about axis
return Quaternion(a, phi)
def set_orientation(self, ori, local=False): vector = True try: len(ori[0]) vector = False except TypeError: pass if vector: ori_vec = [float(i) for i in ori] y = Vector((ori_vec[0], ori_vec[1], ori_vec[2])) z = Vector((0.0, 0.0, 1.0)) x = y.cross(z) ori = ([ [x[0], y[0], z[0]], [x[1], y[1], z[1]], [x[2], y[2], z[2]] ]) if local: self.gameobj.localOrientation = ori[:] else: self.gameobj.worldOrientation = ori[:]
def modal_rotate_tool(self, context, eventd):
cx,cy = self.action_center
mx,my = eventd['mouse']
px,py = self.prev_pos #mode_pos
if eventd['press'] in {'RET', 'NUMPAD_ENTER', 'LEFTMOUSE'}:
self.tool_fn('commit', eventd)
return 'main'
if eventd['press'] in {'ESC', 'RIGHTMOUSE'}:
self.tool_fn('undo', eventd)
return 'main'
if eventd['type'] == 'MOUSEMOVE':
vp = Vector((px-cx,py-cy,0))
vm = Vector((mx-cx,my-cy,0))
ang = vp.angle(vm) * (-1 if vp.cross(vm).z<0 else 1)
self.tool_rot += ang
self.tool_fn(self.tool_rot, eventd)
self.prev_pos = (mx,my)
return ''
return ''
def _arc_segment(v_1, v_2): ELorigin = bpy.context.scene.objects['ELorigin'] ELground = bpy.context.scene.objects['ELground'] v = v_2 - v_1 d = v.length ELorigin.location = Vector((0, 0, 0)) ELground.location = Vector((0, 0, -d)) v_L = ELground.location - ELorigin.location q = Quaternion() c = Vector.cross(v_L, v) q.x = c.x q.y = c.y q.z = c.z q.w = sqrt((v_L.length ** 2) * (v.length ** 2)) + \ Vector.dot(v_L, v) q.normalize() euler = q.to_euler() bpy.ops.object.runfslg_operator() laALL = bpy.context.scene.objects['laALL'] laALL.name = 'lARC' laALL.rotation_euler = euler laALL.location = v_1 bpy.context.active_object.select = False laALL.select = True bpy.ops.object.transform_apply(location=True, rotation=True, scale=True) laALL.select = False bpy.context.active_object.select = True return laALL
def camera_light_source(use_camera, use_light, object_center_vec, object_size):
camera_factor = 15.0
# If chosen a camera is put into the scene.
if use_camera == True:
# Assume that the object is put into the global origin. Then, the
# camera is moved in x and z direction, not in y. The object has its
# size at distance sqrt(object_size) from the origin. So, move the
# camera by this distance times a factor of camera_factor in x and z.
# Then add x, y and z of the origin of the object.
object_camera_vec = Vector((sqrt(object_size) * camera_factor, 0.0,
sqrt(object_size) * camera_factor))
camera_xyz_vec = object_center_vec + object_camera_vec
# Create the camera
camera_data = bpy.data.cameras.new("A_camera")
camera_data.lens = 45
camera_data.clip_end = 500.0
camera = bpy.data.objects.new("A_camera", camera_data)
camera.location = camera_xyz_vec
bpy.context.collection.objects.link(camera)
# Here the camera is rotated such it looks towards the center of
# the object. The [0.0, 0.0, 1.0] vector along the z axis
z_axis_vec = Vector((0.0, 0.0, 1.0))
# The angle between the last two vectors
angle = object_camera_vec.angle(z_axis_vec, 0)
# The cross-product of z_axis_vec and object_camera_vec
axis_vec = z_axis_vec.cross(object_camera_vec)
# Rotate 'axis_vec' by 'angle' and convert this to euler parameters.
# 4 is the size of the matrix.
camera.rotation_euler = Matrix.Rotation(angle, 4, axis_vec).to_euler()
# Rotate the camera around its axis by 90° such that we have a nice
# camera position and view onto the object.
bpy.ops.object.select_all(action='DESELECT')
camera.select_set(True)
# Rotate the camera around its axis 'object_camera_vec' by 90° such
# that we have a nice camera view onto the object.
matrix_rotation = Matrix.Rotation(90 / 360 * 2 * pi, 4,
object_camera_vec)
rotate_object(matrix_rotation, camera)
# Here a lamp is put into the scene, if chosen.
if use_light == True:
# This is the distance from the object measured in terms of %
# of the camera distance. It is set onto 50% (1/2) distance.
lamp_dl = sqrt(object_size) * 15 * 0.5
# This is a factor to which extend the lamp shall go to the right
# (from the camera point of view).
lamp_dy_right = lamp_dl * (3.0 / 4.0)
# Create x, y and z for the lamp.
object_lamp_vec = Vector((lamp_dl, lamp_dy_right, lamp_dl))
lamp_xyz_vec = object_center_vec + object_lamp_vec
length = lamp_xyz_vec.length
# As a lamp we use a point source.
lamp_data = bpy.data.lights.new(name="A_lamp", type="POINT")
# We now determine the emission strength of the lamp. Note that the
# intensity depends on 1/r^2. For this we use a value of 100000.0 at a
# distance of 58. This value was determined manually inside Blender.
lamp_data.energy = 500000.0 * ((length * length) / (58.0 * 58.0))
lamp = bpy.data.objects.new("A_lamp", lamp_data)
lamp.location = lamp_xyz_vec
bpy.context.collection.objects.link(lamp)
# Some settings for the World: a bit ambient occlusion
bpy.context.scene.world.light_settings.use_ambient_occlusion = True
bpy.context.scene.world.light_settings.ao_factor = 0.1
def read(self):
tree = et.parse(self.filepath)
# Clear the scene
for ob in bpy.context.scene.objects:
ob.select = True
bpy.ops.object.delete()
camera = tree.find("./camera")
bpy.ops.object.camera_add()
camera_obj = bpy.context.selected_objects[0]
nearClip = 1e-4
farClip = 1e4
fov = 30.0
width = 1280
height = 720
for parameter in camera:
name = parameter.get('name')
if name == 'nearClip':
nearClip = float(parameter.get('value'))
elif name == 'farClip':
farClip = float(parameter.get('value'))
elif name == 'fov':
fov = float(parameter.get('value'))
elif name == 'width':
width = int(parameter.get('value'))
elif name == 'height':
height = int(parameter.get('value'))
elif name == 'toWorld':
lookat = parameter.find("./lookat")
target = tuple(
float(x) for x in self.__str2float(lookat.get('target')))
origin = tuple(
float(x) for x in self.__str2float(lookat.get('origin')))
up = tuple(
float(x) for x in self.__str2float(lookat.get('up')))
vtarget = Vector(target)
vorigin = Vector(origin)
vup = Vector(up)
vdir = vtarget - vorigin
vdir.normalize()
vup.normalize()
vleft = vup.cross(vdir)
vleft.normalize()
newup = vdir.cross(vleft)
newup.normalize()
lookat_transform = Matrix([
(vleft.x, newup.x, vdir.x, vorigin.x),
(vleft.y, newup.y, vdir.y, vorigin.y),
(vleft.z, newup.z, vdir.z, vorigin.z), (0, 0, 0, 1)
])
euler = lookat_transform.to_euler()
euler.z = euler.z
camera_obj.location = vorigin
camera_obj.rotation_euler = euler
camera_obj.data.clip_end = farClip
camera_obj.data.clip_start = nearClip
camera_obj.data.lens_unit = 'FOV'
camera_obj.data.angle = fov / 180.0 * math.pi
bpy.context.scene.render.resolution_x = width
bpy.context.scene.render.resolution_y = height
camera_obj.select = False
meshes = tree.findall("./mesh")
# import meshes
for mesh in meshes:
obj = mesh.find("./string[@name='filename']")
obj_path = obj.get("value")
bpy.ops.import_scene.obj(
filepath=os.path.join(self.workingDir, obj_path))
me = bpy.context.selected_objects[0].data
bm = bmesh.new()
bm.from_mesh(me)
bmesh.ops.scale(bm, vec=(1, -1, -1))
transforms = mesh.find("./transform")
for transform in transforms:
transform_type = transform.tag
values = [
float(x)
for x in re.split('[,\s]+', transform.get('value'))
]
if transform_type == 'matrix':
bmatrix = list(zip(*([iter(values)] * 4)))
bmesh.ops.transform(bm, matrix=Matrix(bmatrix))
elif transform_type == 'scale':
bmesh.ops.scale(bm, vec=values)
elif transform_type == 'translate':
bmesh.ops.translate(bm, vec=values)
bm.to_mesh(me)
bm.free()
mat = bpy.data.materials.new(
name=bpy.context.selected_objects[0].name)
bsdf = mesh.find("./bsdf")
bsdf_type = bsdf.get("type")
if bsdf_type == 'diffuse':
albedo = bsdf.find("./color[@name='albedo']")
color = tuple(
float(x) for x in self.__str2float(albedo.get('value')))
bpy.context.selected_objects[0].data.materials.append(mat)
mat.diffuse_color = color
emitter = mesh.find("./emitter")
if emitter is not None:
radiance = emitter.find("./color[@name='radiance']")
color = max(
float(x)
for x in re.split('[,\s]+', radiance.get('value')))
mat.emit = color / 1000
bpy.context.selected_objects[0].select = False
class GlLine(GlBaseLine):
"""
2d/3d Line
"""
def __init__(self, d=3, p=None, v=None, p0=None, p1=None, z_axis=None):
"""
d=3 use 3d coords, d=2 use 2d pixels coords
Init by either
p: Vector or tuple origin
v: Vector or tuple size and direction
or
p0: Vector or tuple 1 point location
p1: Vector or tuple 2 point location
Will convert any into Vector 3d
both optionnals
"""
if p is not None and v is not None:
self.p = Vector(p)
self.v = Vector(v)
elif p0 is not None and p1 is not None:
self.p = Vector(p0)
self.v = Vector(p1) - self.p
else:
self.p = Vector((0, 0, 0))
self.v = Vector((0, 0, 0))
if z_axis is not None:
self.z_axis = z_axis
else:
self.z_axis = Vector((0, 0, 1))
GlBaseLine.__init__(self, d)
@property
def p0(self):
return self.p
@property
def p1(self):
return self.p + self.v
@p0.setter
def p0(self, p0):
"""
Note: setting p0
move p0 only
"""
p1 = self.p1
self.p = Vector(p0)
self.v = p1 - p0
@p1.setter
def p1(self, p1):
"""
Note: setting p1
move p1 only
"""
self.v = Vector(p1) - self.p
@property
def length(self):
return self.v.length
@property
def angle(self):
return atan2(self.v.y, self.v.x)
@property
def cross(self):
"""
Vector perpendicular on plane defined by z_axis
lie on the right side
p1
|--x
p0
"""
return self.v.cross(self.z_axis)
def normal(self, t=0):
"""
Line perpendicular on plane defined by z_axis
lie on the right side
p1
|--x
p0
"""
n = GlLine()
n.p = self.lerp(t)
n.v = self.cross
return n
def sized_normal(self, t, size):
"""
GlLine perpendicular on plane defined by z_axis and of given size
positionned at t in current line
lie on the right side
p1
|--x
p0
"""
n = GlLine()
n.p = self.lerp(t)
n.v = size * self.cross.normalized()
return n
def lerp(self, t):
"""
Interpolate along segment
t parameter [0, 1] where 0 is start of arc and 1 is end
"""
return self.p + self.v * t
def offset(self, offset):
"""
offset > 0 on the right part
"""
self.p += offset * self.cross.normalized()
def point_sur_segment(self, pt):
""" point_sur_segment (2d)
point: Vector 3d
t: param t de l'intersection sur le segment courant
d: distance laterale perpendiculaire positif a droite
"""
dp = (pt - self.p).to_2d()
v2d = self.v.to_2d()
dl = v2d.length
d = (self.v.x * dp.y - self.v.y * dp.x) / dl
t = (v2d * dp) / (dl * dl)
return t > 0 and t < 1, d, t
@property
def pts(self):
return [self.p0, self.p1]
def extract_primitives(glTF, blender_mesh, blender_object,
blender_vertex_groups, modifiers, export_settings):
"""
Extract primitives from a mesh. Polygons are triangulated and sorted by material.
Furthermore, primitives are split up, if the indices range is exceeded.
Finally, triangles are also split up/duplicated, if face normals are used instead of vertex normals.
"""
print_console('INFO', 'Extracting primitive: ' + blender_mesh.name)
if blender_mesh.has_custom_normals:
# Custom normals are all (0, 0, 0) until calling calc_normals_split() or calc_tangents().
blender_mesh.calc_normals_split()
use_tangents = False
if blender_mesh.uv_layers.active and len(blender_mesh.uv_layers) > 0:
try:
blender_mesh.calc_tangents()
use_tangents = True
except Exception:
print_console(
'WARNING',
'Could not calculate tangents. Please try to triangulate the mesh first.'
)
#
material_map = {}
#
# Gathering position, normal and tex_coords.
#
no_material_attributes = {POSITION_ATTRIBUTE: [], NORMAL_ATTRIBUTE: []}
if use_tangents:
no_material_attributes[TANGENT_ATTRIBUTE] = []
#
# Directory of materials with its primitive.
#
no_material_primitives = {
MATERIAL_ID: 0,
INDICES_ID: [],
ATTRIBUTES_ID: no_material_attributes
}
material_idx_to_primitives = {0: no_material_primitives}
#
vertex_index_to_new_indices = {}
material_map[0] = vertex_index_to_new_indices
#
# Create primitive for each material.
#
for (mat_idx, _) in enumerate(blender_mesh.materials):
attributes = {POSITION_ATTRIBUTE: [], NORMAL_ATTRIBUTE: []}
if use_tangents:
attributes[TANGENT_ATTRIBUTE] = []
primitive = {
MATERIAL_ID: mat_idx,
INDICES_ID: [],
ATTRIBUTES_ID: attributes
}
material_idx_to_primitives[mat_idx] = primitive
#
vertex_index_to_new_indices = {}
material_map[mat_idx] = vertex_index_to_new_indices
tex_coord_max = 0
if blender_mesh.uv_layers.active:
tex_coord_max = len(blender_mesh.uv_layers)
#
vertex_colors = {}
color_index = 0
for vertex_color in blender_mesh.vertex_colors:
vertex_color_name = COLOR_PREFIX + str(color_index)
vertex_colors[vertex_color_name] = vertex_color
color_index += 1
if color_index >= GLTF_MAX_COLORS:
break
color_max = color_index
#
bone_max = 0
for blender_polygon in blender_mesh.polygons:
for loop_index in blender_polygon.loop_indices:
vertex_index = blender_mesh.loops[loop_index].vertex_index
bones_count = len(blender_mesh.vertices[vertex_index].groups)
if bones_count > 0:
if bones_count % 4 == 0:
bones_count -= 1
bone_max = max(bone_max, bones_count // 4 + 1)
#
morph_max = 0
blender_shape_keys = []
if blender_mesh.shape_keys is not None:
for blender_shape_key in blender_mesh.shape_keys.key_blocks:
if blender_shape_key != blender_shape_key.relative_key:
if blender_shape_key.mute is False:
morph_max += 1
blender_shape_keys.append(
ShapeKey(
blender_shape_key,
blender_shape_key.normals_vertex_get(
), # calculate vertex normals for this shape key
blender_shape_key.normals_polygon_get())
) # calculate polygon normals for this shape key
armature = None
if modifiers is not None:
modifiers_dict = {m.type: m for m in modifiers}
if "ARMATURE" in modifiers_dict:
modifier = modifiers_dict["ARMATURE"]
armature = modifier.object
#
# Convert polygon to primitive indices and eliminate invalid ones. Assign to material.
#
for blender_polygon in blender_mesh.polygons:
export_color = True
#
if export_settings['gltf_materials'] is False:
primitive = material_idx_to_primitives[0]
vertex_index_to_new_indices = material_map[0]
elif not blender_polygon.material_index in material_idx_to_primitives:
primitive = material_idx_to_primitives[0]
vertex_index_to_new_indices = material_map[0]
else:
primitive = material_idx_to_primitives[
blender_polygon.material_index]
vertex_index_to_new_indices = material_map[
blender_polygon.material_index]
#
attributes = primitive[ATTRIBUTES_ID]
face_normal = blender_polygon.normal
face_tangent = Vector((0.0, 0.0, 0.0))
face_bitangent = Vector((0.0, 0.0, 0.0))
if use_tangents:
for loop_index in blender_polygon.loop_indices:
temp_vertex = blender_mesh.loops[loop_index]
face_tangent += temp_vertex.tangent
face_bitangent += temp_vertex.bitangent
face_tangent.normalize()
face_bitangent.normalize()
#
indices = primitive[INDICES_ID]
loop_index_list = []
if len(blender_polygon.loop_indices) == 3:
loop_index_list.extend(blender_polygon.loop_indices)
elif len(blender_polygon.loop_indices) > 3:
# Triangulation of polygon. Using internal function, as non-convex polygons could exist.
polyline = []
for loop_index in blender_polygon.loop_indices:
vertex_index = blender_mesh.loops[loop_index].vertex_index
v = blender_mesh.vertices[vertex_index].co
polyline.append(Vector((v[0], v[1], v[2])))
triangles = tessellate_polygon((polyline, ))
for triangle in triangles:
for triangle_index in triangle:
loop_index_list.append(
blender_polygon.loop_indices[triangle_index])
else:
continue
for loop_index in loop_index_list:
vertex_index = blender_mesh.loops[loop_index].vertex_index
if vertex_index_to_new_indices.get(vertex_index) is None:
vertex_index_to_new_indices[vertex_index] = []
#
v = None
n = None
t = None
b = None
uvs = []
colors = []
joints = []
weights = []
target_positions = []
target_normals = []
target_tangents = []
vertex = blender_mesh.vertices[vertex_index]
v = convert_swizzle_location(vertex.co, armature, blender_object,
export_settings)
if blender_polygon.use_smooth or blender_mesh.use_auto_smooth:
if blender_mesh.has_custom_normals:
n = convert_swizzle_normal(
blender_mesh.loops[loop_index].normal, armature,
blender_object, export_settings)
else:
n = convert_swizzle_normal(vertex.normal, armature,
blender_object, export_settings)
if use_tangents:
t = convert_swizzle_tangent(
blender_mesh.loops[loop_index].tangent, armature,
blender_object, export_settings)
b = convert_swizzle_location(
blender_mesh.loops[loop_index].bitangent, armature,
blender_object, export_settings)
else:
n = convert_swizzle_normal(face_normal, armature,
blender_object, export_settings)
if use_tangents:
t = convert_swizzle_tangent(face_tangent, armature,
blender_object,
export_settings)
b = convert_swizzle_location(face_bitangent, armature,
blender_object,
export_settings)
if use_tangents:
tv = Vector((t[0], t[1], t[2]))
bv = Vector((b[0], b[1], b[2]))
nv = Vector((n[0], n[1], n[2]))
if (nv.cross(tv)).dot(bv) < 0.0:
t[3] = -1.0
if blender_mesh.uv_layers.active:
for tex_coord_index in range(0, tex_coord_max):
uv = blender_mesh.uv_layers[tex_coord_index].data[
loop_index].uv
uvs.append([uv.x, 1.0 - uv.y])
#
if color_max > 0 and export_color:
for color_index in range(0, color_max):
color_name = COLOR_PREFIX + str(color_index)
color = vertex_colors[color_name].data[loop_index].color
colors.append([
color_srgb_to_scene_linear(color[0]),
color_srgb_to_scene_linear(color[1]),
color_srgb_to_scene_linear(color[2]), color[3]
])
#
bone_count = 0
if blender_vertex_groups is not None and vertex.groups is not None and len(
vertex.groups) > 0 and export_settings[
gltf2_blender_export_keys.SKINS]:
joint = []
weight = []
vertex_groups = vertex.groups
if not export_settings['gltf_all_vertex_influences']:
# sort groups by weight descending
vertex_groups = sorted(vertex.groups,
key=attrgetter('weight'),
reverse=True)
for group_element in vertex_groups:
if len(joint) == 4:
bone_count += 1
joints.append(joint)
weights.append(weight)
joint = []
weight = []
#
joint_weight = group_element.weight
if joint_weight <= 0.0:
continue
#
vertex_group_index = group_element.group
vertex_group_name = blender_vertex_groups[
vertex_group_index].name
joint_index = None
if armature:
skin = gltf2_blender_gather_skins.gather_skin(
armature, export_settings)
for index, j in enumerate(skin.joints):
if j.name == vertex_group_name:
joint_index = index
break
#
if joint_index is not None:
joint.append(joint_index)
weight.append(joint_weight)
if len(joint) > 0:
bone_count += 1
for fill in range(0, 4 - len(joint)):
joint.append(0)
weight.append(0.0)
joints.append(joint)
weights.append(weight)
for fill in range(0, bone_max - bone_count):
joints.append([0, 0, 0, 0])
weights.append([0.0, 0.0, 0.0, 0.0])
#
if morph_max > 0 and export_settings[
gltf2_blender_export_keys.MORPH]:
for morph_index in range(0, morph_max):
blender_shape_key = blender_shape_keys[morph_index]
v_morph = convert_swizzle_location(
blender_shape_key.shape_key.data[vertex_index].co,
armature, blender_object, export_settings)
# Store delta.
v_morph -= v
target_positions.append(v_morph)
#
n_morph = None
if blender_polygon.use_smooth:
temp_normals = blender_shape_key.vertex_normals
n_morph = (temp_normals[vertex_index * 3 + 0],
temp_normals[vertex_index * 3 + 1],
temp_normals[vertex_index * 3 + 2])
else:
temp_normals = blender_shape_key.polygon_normals
n_morph = (temp_normals[blender_polygon.index * 3 + 0],
temp_normals[blender_polygon.index * 3 + 1],
temp_normals[blender_polygon.index * 3 + 2])
n_morph = convert_swizzle_normal(Vector(n_morph), armature,
blender_object,
export_settings)
# Store delta.
n_morph -= n
target_normals.append(n_morph)
#
if use_tangents:
rotation = n_morph.rotation_difference(n)
t_morph = Vector((t[0], t[1], t[2]))
t_morph.rotate(rotation)
target_tangents.append(t_morph)
#
#
create = True
for current_new_index in vertex_index_to_new_indices[vertex_index]:
found = True
for i in range(0, 3):
if attributes[POSITION_ATTRIBUTE][current_new_index * 3 +
i] != v[i]:
found = False
break
if attributes[NORMAL_ATTRIBUTE][current_new_index * 3 +
i] != n[i]:
found = False
break
if use_tangents:
for i in range(0, 4):
if attributes[TANGENT_ATTRIBUTE][current_new_index * 4
+ i] != t[i]:
found = False
break
if not found:
continue
for tex_coord_index in range(0, tex_coord_max):
uv = uvs[tex_coord_index]
tex_coord_id = TEXCOORD_PREFIX + str(tex_coord_index)
for i in range(0, 2):
if attributes[tex_coord_id][current_new_index * 2 +
i] != uv[i]:
found = False
break
if export_color:
for color_index in range(0, color_max):
color = colors[color_index]
color_id = COLOR_PREFIX + str(color_index)
for i in range(0, 3):
# Alpha is always 1.0 - see above.
current_color = attributes[color_id][
current_new_index * 4 + i]
if color_srgb_to_scene_linear(
current_color) != color[i]:
found = False
break
if export_settings[gltf2_blender_export_keys.SKINS]:
for bone_index in range(0, bone_max):
joint = joints[bone_index]
weight = weights[bone_index]
joint_id = JOINTS_PREFIX + str(bone_index)
weight_id = WEIGHTS_PREFIX + str(bone_index)
for i in range(0, 4):
if attributes[joint_id][current_new_index * 4 +
i] != joint[i]:
found = False
break
if attributes[weight_id][current_new_index * 4 +
i] != weight[i]:
found = False
break
if export_settings[gltf2_blender_export_keys.MORPH]:
for morph_index in range(0, morph_max):
target_position = target_positions[morph_index]
target_normal = target_normals[morph_index]
if use_tangents:
target_tangent = target_tangents[morph_index]
target_position_id = MORPH_POSITION_PREFIX + str(
morph_index)
target_normal_id = MORPH_NORMAL_PREFIX + str(
morph_index)
target_tangent_id = MORPH_TANGENT_PREFIX + str(
morph_index)
for i in range(0, 3):
if attributes[target_position_id][
current_new_index * 3 +
i] != target_position[i]:
found = False
break
if attributes[target_normal_id][
current_new_index * 3 +
i] != target_normal[i]:
found = False
break
if use_tangents:
if attributes[target_tangent_id][
current_new_index * 3 +
i] != target_tangent[i]:
found = False
break
if found:
indices.append(current_new_index)
create = False
break
if not create:
continue
new_index = 0
if primitive.get('max_index') is not None:
new_index = primitive['max_index'] + 1
primitive['max_index'] = new_index
vertex_index_to_new_indices[vertex_index].append(new_index)
#
#
indices.append(new_index)
#
attributes[POSITION_ATTRIBUTE].extend(v)
attributes[NORMAL_ATTRIBUTE].extend(n)
if use_tangents:
attributes[TANGENT_ATTRIBUTE].extend(t)
if blender_mesh.uv_layers.active:
for tex_coord_index in range(0, tex_coord_max):
tex_coord_id = TEXCOORD_PREFIX + str(tex_coord_index)
if attributes.get(tex_coord_id) is None:
attributes[tex_coord_id] = []
attributes[tex_coord_id].extend(uvs[tex_coord_index])
if export_color:
for color_index in range(0, color_max):
color_id = COLOR_PREFIX + str(color_index)
if attributes.get(color_id) is None:
attributes[color_id] = []
attributes[color_id].extend(colors[color_index])
if export_settings[gltf2_blender_export_keys.SKINS]:
for bone_index in range(0, bone_max):
joint_id = JOINTS_PREFIX + str(bone_index)
if attributes.get(joint_id) is None:
attributes[joint_id] = []
attributes[joint_id].extend(joints[bone_index])
weight_id = WEIGHTS_PREFIX + str(bone_index)
if attributes.get(weight_id) is None:
attributes[weight_id] = []
attributes[weight_id].extend(weights[bone_index])
if export_settings[gltf2_blender_export_keys.MORPH]:
for morph_index in range(0, morph_max):
target_position_id = MORPH_POSITION_PREFIX + str(
morph_index)
if attributes.get(target_position_id) is None:
attributes[target_position_id] = []
attributes[target_position_id].extend(
target_positions[morph_index])
target_normal_id = MORPH_NORMAL_PREFIX + str(morph_index)
if attributes.get(target_normal_id) is None:
attributes[target_normal_id] = []
attributes[target_normal_id].extend(
target_normals[morph_index])
if use_tangents:
target_tangent_id = MORPH_TANGENT_PREFIX + str(
morph_index)
if attributes.get(target_tangent_id) is None:
attributes[target_tangent_id] = []
attributes[target_tangent_id].extend(
target_tangents[morph_index])
#
# Add non-empty primitives
#
result_primitives = [
primitive for primitive in material_idx_to_primitives.values()
if len(primitive[INDICES_ID]) != 0
]
print_console('INFO', 'Primitives created: ' + str(len(result_primitives)))
return result_primitives
def blend_rec(graph,
tcoords,
gcoords,
colors,
label,
node_size=3,
edge_thickness=0.25):
# edge obj
bpy.data.materials.new(name="light_gray")
bpy.data.materials["light_gray"].diffuse_color = (0.4627450980392157,
0.4627450980392157,
0.4627450980392157)
bpy.data.materials["light_gray"].specular_intensity = 0.5
# sphere obj
for color, aa in zip(colors, label):
bpy.data.materials.new(name=aa)
bpy.data.materials[aa].diffuse_color = color
bpy.data.materials[aa].specular_intensity = 0.5
# Transparency parameters
bpy.data.materials[aa].use_transparency = True
bpy.data.materials[aa].transparency_method = "RAYTRACE"
bpy.data.materials[aa].alpha = 0.95
bpy.data.materials[aa].raytrace_transparency.fresnel = 0.1
bpy.data.materials[aa].raytrace_transparency.ior = 1.15
# sphere rec obj
bpy.data.materials.new(name="red")
bpy.data.materials["red"].diffuse_color = (1, 0, 0)
bpy.data.materials["red"].specular_intensity = 0.5
# text obj
text = bpy.data.objects.new("label",
bpy.data.curves.new(type="FONT", name="curve"))
bpy.data.materials.new(name="black")
bpy.data.materials["black"].diffuse_color = (0, 0, 0)
bpy.data.materials["black"].specular_intensity = 0.5
# Set scene, light and alpha_mode
scene = bpy.context.scene
scene.render.engine = 'BLENDER_RENDER' # 'CYCLE'
scene.render.alpha_mode = 'TRANSPARENT' # remove background
area = next(area for area in bpy.context.screen.areas
if area.type == 'VIEW_3D')
area.spaces[0].region_3d.view_perspective = 'CAMERA'
bpy.data.worlds["World"].light_settings.use_ambient_occlusion = True
bpy.data.worlds["World"].light_settings.samples = 10
# camera position
if (len(bpy.data.cameras) == 1):
obj = bpy.data.objects['Camera'] # bpy.types.Camera
mean_x = np.mean([el[0] for el in tcoords.values()])
mean_y = np.mean([el[1] for el in tcoords.values()])
mean_z = np.mean([el[2] for el in tcoords.values()])
obj.location.x = mean_x
obj.location.y = mean_y
min_x = min([el[0] for el in tcoords.values()])
max_x = max([el[0] for el in tcoords.values()])
min_y = min([el[1] for el in tcoords.values()])
max_y = max([el[1] for el in tcoords.values()])
obj.location.z = mean_z + max(
max_x - min_x, max_y - min_y) / (2 * np.tan(np.radians(20) / 2))
obj.rotation_euler = (0.0, 0.0, np.radians(90))
obj.keyframe_insert(data_path="location", frame=10.0)
# Add some mesh primitives
bpy.ops.object.select_all(action='DESELECT')
bpy.ops.mesh.primitive_uv_sphere_add()
sphere = bpy.context.object
bpy.ops.mesh.primitive_cylinder_add()
cylinder = bpy.context.object
cylinder.active_material = bpy.data.materials["light_gray"]
bpy.ops.mesh.primitive_uv_sphere_add()
gsphere = bpy.context.object
gsphere.active_material = bpy.data.materials["red"]
# Keep references to all nodes and edges
shapes = []
# Keep separate references to shapes to be smoothed
shapes_to_smooth = []
# Draw nodes
nx.set_node_attributes(graph, [], "color")
for node, aa in zip(graph.nodes(), label):
# Coloring rule for nodes. Edit this to suit your needs!
col = colors[node]
# Copy mesh primitive and edit to make node
# (You can change the shape of drawn nodes here)
node_sphere = sphere.copy()
node_sphere.data = sphere.data.copy()
node_sphere.location = tcoords[node]
node_sphere.dimensions = [node_size] * 3
node_sphere.active_material = bpy.data.materials[aa]
bpy.context.scene.objects.link(node_sphere)
shapes.append(node_sphere)
shapes_to_smooth.append(node_sphere)
#lbl = text.copy()
#lbl.data = text.data.copy()
#lbl.data.body = label[node]
#lbl.rotation_mode = "AXIS_ANGLE"
#lbl.rotation_euler = (0.0, 0.0, np.radians(90))
#lbl.active_material = bpy.data.materials["black"]
#lbl.dimensions = [.00000001] * 3
#lbl.location = np.asarray(tcoords[node]) + [0., 0., node_size/2]
#bpy.context.scene.objects.link(lbl)
# guess atom
gues_sphere = gsphere.copy()
gues_sphere.data = gsphere.data.copy()
gues_sphere.dimensions = [node_size] * 3
gues_sphere.location = gcoords[node]
gues_sphere.active_material = bpy.data.materials["red"]
bpy.context.scene.objects.link(gues_sphere)
shapes.append(gues_sphere)
shapes_to_smooth.append(gues_sphere)
# Draw edges
for source, target in graph.edges():
# Get source and target locations by drilling down into data structure
source_loc = tcoords[source]
target_loc = tcoords[target]
diff = [c2 - c1 for c2, c1 in zip(source_loc, target_loc)]
cent = [(c2 + c1) / 2 for c2, c1 in zip(source_loc, target_loc)]
mag = sum([(c2 - c1)**2
for c1, c2 in zip(source_loc, target_loc)])**0.5
# Euler rotation calculation
v_axis = Vector(diff).normalized()
v_obj = Vector((0, 0, 1))
v_rot = v_obj.cross(v_axis)
angle = acos(v_obj.dot(v_axis))
# Copy mesh primitive to create edge
edge_cylinder = cylinder.copy()
edge_cylinder.data = cylinder.data.copy()
edge_cylinder.dimensions = [edge_thickness] * 2 + [mag - node_size]
edge_cylinder.location = cent
edge_cylinder.rotation_mode = "AXIS_ANGLE"
edge_cylinder.rotation_axis_angle = [angle] + list(v_rot)
bpy.context.scene.objects.link(edge_cylinder)
shapes.append(edge_cylinder)
shapes_to_smooth.append(edge_cylinder)
# Remove primitive meshes
bpy.ops.object.select_all(action='DESELECT')
sphere.select = True
gsphere.select = True
cylinder.select = True
# If the starting cube is there, remove it
if "Cube" in bpy.data.objects.keys():
bpy.data.objects.get("Cube").select = True
bpy.ops.object.delete()
# Smooth specified shapes
for shape in shapes_to_smooth:
shape.select = True
bpy.context.scene.objects.active = shapes_to_smooth[0]
bpy.ops.object.shade_smooth()
# Join shapes
for shape in shapes:
shape.select = True
bpy.context.scene.objects.active = shapes[0]
bpy.ops.object.join()
# Center object origin to geometry
bpy.ops.object.origin_set(type="ORIGIN_GEOMETRY", center="MEDIAN")
# Refresh scene
bpy.context.scene.update()
class GlHandle(GlPolygon):
def __init__(self,
sensor_size,
size,
draggable=False,
selectable=False,
d=3):
"""
sensor_size : 2d size in pixels of sensor area
size : 3d size of handle
"""
GlPolygon.__init__(self, d=d)
self.colour_active = (1.0, 0.0, 0.0, 1.0)
self.colour_hover = (1.0, 1.0, 0.0, 1.0)
self.colour_normal = (1.0, 1.0, 1.0, 1.0)
self.colour_selected = (0.0, 0.0, 0.7, 1.0)
self.size = size
self.sensor_width = sensor_size
self.sensor_height = sensor_size
self.pos_3d = Vector((0, 0, 0))
self.up_axis = Vector((0, 0, 0))
self.c_axis = Vector((0, 0, 0))
self.hover = False
self.active = False
self.draggable = draggable
self.selectable = selectable
self.selected = False
def set_pos(self, context, pos_3d, direction, normal=Vector((0, 0, 1))):
self.up_axis = direction.normalized()
self.c_axis = self.up_axis.cross(normal)
self.pos_3d = pos_3d
self.pos_2d = self.position_2d_from_coord(context, self.sensor_center)
def check_hover(self, pos_2d):
if self.draggable:
dp = pos_2d - self.pos_2d
self.hover = abs(dp.x) < self.sensor_width and abs(
dp.y) < self.sensor_height
@property
def sensor_center(self):
pts = self.pts
n = len(pts)
x, y, z = 0, 0, 0
for pt in pts:
x += pt.x
y += pt.y
z += pt.z
return Vector((x / n, y / n, z / n))
@property
def pts(self):
raise NotImplementedError
@property
def colour(self):
if self.render:
return self.colour_inactive
elif self.draggable:
if self.active:
return self.colour_active
elif self.hover:
return self.colour_hover
elif self.selected:
return self.colour_selected
return self.colour_normal
else:
return self.colour_inactive
def tp_insert_mesh_geometry(self, context):
wm = context.window_manager
object = wm.TP_Tileable_Mesh_Previews
obj_list = []
second_obj = ""
if bpy.context.mode == 'OBJECT':
tp_desc_mesh_insert(object) ###objectlist
elif bpy.context.mode == 'EDIT':
bpy.ops.object.mode_set(mode='OBJECT')
ref_obj = bpy.context.active_object
if len(context.selected_objects) == 2:
obj1, obj2 = context.selected_objects
second_obj = obj1 if obj2 == ref_obj else obj2
bpy.data.objects[second_obj.name].select = False
bpy.ops.object.duplicate_move()
bpy.context.active_object.name = "Dummy"
obj = context.active_object
bpy.ops.object.parent_clear(type='CLEAR_KEEP_TRANSFORM')
bpy.ops.object.transform_apply(location=True,
rotation=True,
scale=True)
copy_cursor = bpy.context.scene.cursor_location.copy()
bm = bmesh.new()
bm.from_mesh(obj.data)
selected_faces = [f for f in bm.faces if f.select]
for face in selected_faces:
face_location = face.calc_center_median()
loc_world_space = obj.matrix_world * Vector(face_location)
z = Vector((0, 0, 1))
angle = face.normal.angle(z)
axis = z.cross(face.normal)
bpy.context.scene.cursor_location = loc_world_space
tp_desc_mesh_insert(object) ###objectlist
bpy.ops.transform.rotate(value=angle, axis=axis)
obj_list.append(context.object.name)
bm.to_mesh(obj.data)
bm.free()
bpy.context.scene.cursor_location = copy_cursor
bpy.ops.object.select_all(action='DESELECT')
bpy.context.scene.objects.active = bpy.data.objects["Dummy"]
bpy.data.objects["Dummy"].select = True
bpy.ops.object.delete(use_global=False)
bpy.context.scene.objects.active = bpy.data.objects[obj_list[0]]
for obj in obj_list:
bpy.data.objects[obj].select = True
bpy.ops.make.link() # custom link called from operators module
bpy.ops.object.select_all(action='DESELECT')
bpy.context.scene.objects.active = bpy.data.objects[ref_obj.name]
if second_obj:
bpy.data.objects[second_obj.name].select = True
bpy.data.objects[ref_obj.name].select = True
bpy.ops.object.mode_set(mode='EDIT')
del (obj_list[:])
def execute(self, context):
obj_list = []
bpy.ops.object.mode_set(mode='OBJECT')
ref_obj = bpy.context.active_object
obj1, obj2 = context.selected_objects
second_obj = obj1 if obj2 == ref_obj else obj2
obj_list.append(second_obj.name)
bpy.data.objects[second_obj.name].select = False
bpy.ops.object.duplicate_move()
bpy.context.active_object.name = "Dummy"
obj = context.active_object
bpy.ops.object.parent_clear(type='CLEAR_KEEP_TRANSFORM')
bpy.ops.object.transform_apply(location=True,
rotation=True,
scale=True)
copy_cursor = bpy.context.scene.cursor_location.copy()
bm = bmesh.new()
bm.from_mesh(obj.data)
selected_faces = [f for f in bm.faces if f.select]
for face in selected_faces:
face_location = face.calc_center_median()
loc_world_space = obj.matrix_world * Vector(face_location)
z = Vector((0, 0, 1))
angle = face.normal.angle(z)
axis = z.cross(face.normal)
bpy.ops.object.select_all(action='DESELECT')
bpy.context.scene.objects.active = bpy.data.objects[
second_obj.name]
bpy.data.objects[second_obj.name].select = True
bpy.ops.object.duplicate()
bpy.context.scene.cursor_location = loc_world_space
bpy.ops.view3d.snap_selected_to_cursor()
bpy.ops.transform.rotate(value=angle, axis=axis)
obj_list.append(context.object.name)
bm.to_mesh(obj.data)
bm.free()
bpy.context.scene.cursor_location = copy_cursor
bpy.ops.object.select_all(action='DESELECT')
bpy.context.scene.objects.active = bpy.data.objects["Dummy"]
bpy.data.objects["Dummy"].select = True
bpy.ops.object.delete(use_global=False)
bpy.context.scene.objects.active = bpy.data.objects[obj_list[0]]
for obj in obj_list:
bpy.data.objects[obj].select = True
bpy.ops.make.link() # custom link called from operators module
bpy.ops.object.select_all(action='DESELECT')
bpy.context.scene.objects.active = bpy.data.objects[ref_obj.name]
bpy.data.objects[second_obj.name].select = True
bpy.data.objects[ref_obj.name].select = True
bpy.ops.object.mode_set(mode='EDIT')
del (obj_list[:])
return {'FINISHED'}
def create_object_to_selection(self, context):
if not bpy.context.object:
add_primitive()
# bpy.ops.object.orientationvariable(variable="LOCAL")
elif context.object.mode == 'EDIT':
#Duplicate the mesh, apply his transform and perform the code to add object on it
bpy.ops.object.mode_set(mode='OBJECT')
bpy.ops.object.duplicate_move()
bpy.context.active_object.name = "Dummy"
bpy.ops.object.parent_clear(type='CLEAR_KEEP_TRANSFORM')
bpy.ops.object.transform_apply(location=True,
rotation=True,
scale=True)
list_insert_meshes = []
obj = bpy.context.active_object
saved_location = bpy.context.scene.cursor_location.copy()
bm = bmesh.new()
bm.from_mesh(obj.data)
selected_faces = [f for f in bm.faces if f.select]
for face in selected_faces:
face_location = face.calc_center_median()
loc_world_space = obj.matrix_world * Vector(face_location)
z = Vector((0, 0, 1))
angle = face.normal.angle(z)
axis = z.cross(face.normal)
bpy.context.scene.cursor_location = loc_world_space
add_primitive()
bpy.ops.transform.rotate(value=angle, axis=axis)
list_insert_meshes.append(context.active_object.name)
bm.to_mesh(obj.data)
bm.free()
bpy.context.scene.cursor_location = saved_location
#Deselect all the objects, select the dummy object and delete it
bpy.ops.object.select_all(action='DESELECT')
bpy.context.scene.objects.active = bpy.data.objects["Dummy"]
bpy.context.object.select = True
bpy.ops.object.delete(use_global=False)
#Select inserted meshes
for obj in list_insert_meshes:
bpy.context.scene.objects.active = bpy.data.objects[obj]
bpy.data.objects[obj].select = True
if len(list_insert_meshes) > 1:
bpy.ops.object.make_links_data(type='OBDATA') #Make link
del (list_insert_meshes[:])
# bpy.ops.object.orientationvariable(variable="LOCAL")
else:
saved_location = bpy.context.scene.cursor_location.copy()
bpy.ops.view3d.snap_cursor_to_selected()
add_primitive()
bpy.context.scene.cursor_location = saved_location
def modal(self, context, event):
context.area.tag_redraw()
lin_def_settings = context.scene.mi_ldeformer_settings
region = context.region
rv3d = context.region_data
m_coords = event.mouse_region_x, event.mouse_region_y
active_obj = context.scene.objects.active
bm = bmesh.from_edit_mesh(active_obj.data)
# update check
if lin_def_settings.manual_update is True:
if event.type == 'U':
if event.value == 'PRESS':
self.do_update = True
else:
self.do_update = False
else:
self.do_update = True
# tooltip
tooltip_text = None
if lin_def_settings.manual_update is True and self.tool_mode not in {
'IDLE', 'MOVE_POINT'
}:
tooltip_text = "Press U key to udate!"
else:
tooltip_text = "I:Invert, Z:Z-Constraint, X:X-Constraint, S:Scale, Shift-S:ScaleForward, G:Move, R:Rotate, B:Bend, Shift-B:BendSpiral, T:Tape, Shift-T:Twist, Ctrl+Z:Undo, Ctrl+Shift+Z:Redo"
context.area.header_text_set(tooltip_text)
# key pressed
if self.tool_mode == 'IDLE' and event.value == 'PRESS':
if event.type in {'LEFTMOUSE', 'SELECTMOUSE'}:
if self.lw_tool:
# pick linear widget point
picked_point = l_widget.pick_lw_point(
context, m_coords, self.lw_tool)
if picked_point:
self.deform_mouse_pos = Vector(m_coords)
self.active_lw_point = picked_point
self.tool_mode = 'MOVE_POINT'
else:
picked_point = ut_base.get_mouse_on_plane(
context, self.start_work_center, None, m_coords)
if picked_point:
self.lw_tool = l_widget.MI_Linear_Widget()
self.lw_tool.start_point = l_widget.MI_LW_Point(
picked_point.copy())
self.lw_tool.middle_point = l_widget.MI_LW_Point(
picked_point.copy())
self.lw_tool.end_point = l_widget.MI_LW_Point(
picked_point)
self.active_lw_point = self.lw_tool.end_point
self.tool_mode = 'MOVE_POINT'
elif event.type in {'S', 'G', 'R', 'B', 'T'}:
# set tool type
if event.type == 'S':
if event.shift:
self.tool_mode = 'SCALE_FRONT'
else:
self.tool_mode = 'SCALE_ALL'
elif event.type == 'R':
self.tool_mode = 'ROTATE_ALL'
elif event.type == 'G':
self.tool_mode = 'MOVE_ALL'
elif event.type == 'B':
if event.shift:
self.tool_mode = 'BEND_SPIRAL'
else:
self.tool_mode = 'BEND_ALL'
elif event.type == 'T':
if event.shift:
self.tool_mode = 'TWIST'
else:
self.tool_mode = 'TAPE'
# get tool verts
if self.tool_mode in {'SCALE_FRONT', 'TAPE'}:
# do not clamp for SCALE_FRONT mode
self.apply_tool_verts = l_widget.get_tool_verts(
self.lw_tool, self.work_verts, bm, active_obj, False,
True)
else:
self.apply_tool_verts = l_widget.get_tool_verts(
self.lw_tool, self.work_verts, bm, active_obj, True,
True)
# set some settings for tools
if self.tool_mode in {'SCALE_ALL', 'SCALE_FRONT', 'TAPE'}:
self.deform_mouse_pos = Vector(m_coords)
elif self.tool_mode == 'MOVE_ALL':
mouse_pos_3d = ut_base.get_mouse_on_plane(
context, self.lw_tool.start_point.position, None,
m_coords)
self.deform_vec_pos = mouse_pos_3d # 3d location
elif self.tool_mode in {
'ROTATE_ALL', 'TWIST', 'BEND_ALL', 'BEND_SPIRAL'
}:
start_2d = view3d_utils.location_3d_to_region_2d(
region, rv3d, self.lw_tool.start_point.position)
self.deform_vec_pos = (
Vector(m_coords) -
start_2d).normalized() # 2d direction
self.deform_mouse_pos = 0.0 # we will use it as angle counter
if self.tool_mode in {'BEND_SPIRAL', 'BEND_ALL'}:
self.bend_scale_len = (Vector(m_coords) -
start_2d).length
#return {'RUNNING_MODAL'}
elif event.type in {'Z', 'X'} and self.lw_tool:
if event.type == 'Z' and event.ctrl:
if event.shift:
redo_history(bm, self.h_undo, self.h_redo, active_obj)
else:
undo_history(bm, self.h_undo, self.h_redo, active_obj)
else:
pre_verts = [bm.verts[v_id] for v_id in self.work_verts]
if event.type == 'X':
if self.lw_tool_axis:
if self.lw_tool_axis == 'X':
l_widget.setup_lw_tool(rv3d, self.lw_tool,
active_obj, pre_verts,
'X_Left', 1.0)
self.lw_tool_axis = 'X_Left'
elif self.lw_tool_axis == 'X_Left':
l_widget.setup_lw_tool(rv3d, self.lw_tool,
active_obj, pre_verts,
'X_Right', 1.0)
## revert direction
#stp = self.lw_tool.start_point.position.copy()
#self.lw_tool.start_point.position = self.lw_tool.end_point.position
#self.lw_tool.end_point.position = stp
self.lw_tool_axis = 'X_Right'
elif self.lw_tool_axis == 'X_Right':
l_widget.setup_lw_tool(rv3d, self.lw_tool,
active_obj, pre_verts,
'X', 1.0)
self.lw_tool_axis = 'X'
else:
l_widget.setup_lw_tool(rv3d, self.lw_tool,
active_obj, pre_verts,
'X', 1.0)
self.lw_tool_axis = 'X'
else:
l_widget.setup_lw_tool(rv3d, self.lw_tool,
active_obj, pre_verts, 'X',
1.0)
self.lw_tool_axis = 'X'
else:
if self.lw_tool_axis:
if self.lw_tool_axis == 'Z':
l_widget.setup_lw_tool(rv3d, self.lw_tool,
active_obj, pre_verts,
'Z_Top', 1.0)
self.lw_tool_axis = 'Z_Top'
elif self.lw_tool_axis == 'Z_Top':
l_widget.setup_lw_tool(rv3d, self.lw_tool,
active_obj, pre_verts,
'Z_Bottom', 1.0)
## revert direction
#stp = self.lw_tool.start_point.position.copy()
#self.lw_tool.start_point.position = self.lw_tool.end_point.position
#self.lw_tool.end_point.position = stp
self.lw_tool_axis = 'Z_Bottom'
elif self.lw_tool_axis == 'Z_Bottom':
l_widget.setup_lw_tool(rv3d, self.lw_tool,
active_obj, pre_verts,
'Z', 1.0)
self.lw_tool_axis = 'Z'
else:
l_widget.setup_lw_tool(rv3d, self.lw_tool,
active_obj, pre_verts,
'Z', 1.0)
self.lw_tool_axis = 'Z'
else:
l_widget.setup_lw_tool(rv3d, self.lw_tool,
active_obj, pre_verts, 'Z',
1.0)
self.lw_tool_axis = 'Z'
elif event.type == 'I' and self.lw_tool:
start_copy = self.lw_tool.start_point.position.copy()
self.lw_tool.start_point.position = self.lw_tool.end_point.position
self.lw_tool.end_point.position = start_copy
# TOOL WORK!
if self.tool_mode == 'MOVE_POINT':
if event.value == 'RELEASE':
self.tool_mode = 'IDLE'
return {'RUNNING_MODAL'}
else:
# move points
new_point_pos = ut_base.get_mouse_on_plane(
context, self.active_lw_point.position, None, m_coords)
if self.active_lw_point.position == self.lw_tool.start_point.position or self.active_lw_point.position == self.lw_tool.end_point.position:
self.active_lw_point.position = new_point_pos
l_widget.update_middle_point(self.lw_tool)
elif self.active_lw_point.position == self.lw_tool.middle_point.position:
self.lw_tool.start_point.position += new_point_pos - self.active_lw_point.position
self.lw_tool.end_point.position += new_point_pos - self.active_lw_point.position
self.lw_tool.middle_point.position = new_point_pos
return {'RUNNING_MODAL'}
elif self.tool_mode in {'SCALE_ALL', 'SCALE_FRONT', 'TAPE'}:
if event.value == 'RELEASE' and event.type in {
'LEFTMOUSE', 'SELECTMOUSE'
}:
bm.normal_update()
# add to undo history
self.h_redo.clear()
pre_work_verts = [bm.verts[v_id] for v_id in self.work_verts]
add_history(pre_work_verts, self.h_undo)
self.tool_mode = 'IDLE'
elif self.do_update:
# move points
start_point_2d = view3d_utils.location_3d_to_region_2d(
region, rv3d, self.lw_tool.start_point.position)
if start_point_2d:
tool_dist = (start_point_2d - self.deform_mouse_pos).length
now_dist = (start_point_2d - Vector(m_coords)).length
apply_value = (now_dist - tool_dist) / tool_dist
if apply_value != 0.0:
tool_orig = active_obj.matrix_world.inverted(
) * self.lw_tool.start_point.position
tool_end = active_obj.matrix_world.inverted(
) * self.lw_tool.end_point.position
tool_vec = tool_end - tool_orig
tool_dir = (tool_end - tool_orig).normalized()
for vert_data in self.apply_tool_verts:
scale_vec = None
scale_value = vert_data[1]
if self.tool_mode == 'SCALE_ALL':
scale_vec = (vert_data[2] - tool_orig)
elif self.tool_mode == 'SCALE_FRONT':
scale_vec = (tool_end - tool_orig)
else:
# TAPE
scale_vec = vert_data[2] - (
tool_orig + (tool_dir * vert_data[1] *
(tool_vec).length))
scale_value = min(1.0, vert_data[1])
bm.verts[vert_data[0]].co = vert_data[2] + (
scale_vec * (scale_value * apply_value))
#bm.normal_update()
bmesh.update_edit_mesh(active_obj.data)
self.do_update = False
return {'RUNNING_MODAL'}
elif self.tool_mode == 'MOVE_ALL':
if event.value == 'RELEASE' and event.type in {
'LEFTMOUSE', 'SELECTMOUSE'
}:
bm.normal_update()
# add to undo history
self.h_redo.clear()
pre_work_verts = [bm.verts[v_id] for v_id in self.work_verts]
add_history(pre_work_verts, self.h_undo)
self.tool_mode = 'IDLE'
elif self.do_update:
mouse_pos_3d = ut_base.get_mouse_on_plane(
context, self.lw_tool.start_point.position, None, m_coords)
mouse_pos_3d = active_obj.matrix_world.inverted(
) * mouse_pos_3d
start_pos = active_obj.matrix_world.inverted(
) * self.lw_tool.start_point.position
orig_pos = active_obj.matrix_world.inverted(
) * self.deform_vec_pos
orig_vec = orig_pos - start_pos
move_vec = (mouse_pos_3d - start_pos) - orig_vec
for vert_data in self.apply_tool_verts:
move_value = vert_data[1]
bm.verts[vert_data[0]].co = vert_data[2] + (move_vec *
move_value)
#bm.normal_update()
bmesh.update_edit_mesh(active_obj.data)
self.do_update = False
return {'RUNNING_MODAL'}
elif self.tool_mode in {
'ROTATE_ALL', 'TWIST', 'BEND_ALL', 'BEND_SPIRAL'
}:
if event.value == 'RELEASE' and event.type in {
'LEFTMOUSE', 'SELECTMOUSE'
}:
bm.normal_update()
# add to undo history
self.h_redo.clear()
pre_work_verts = [bm.verts[v_id] for v_id in self.work_verts]
add_history(pre_work_verts, self.h_undo)
self.tool_mode = 'IDLE'
elif self.do_update:
m_coords = Vector(
m_coords) # convert into vector for operations
start_2d = view3d_utils.location_3d_to_region_2d(
region, rv3d, self.lw_tool.start_point.position)
new_vec_dir = (m_coords - start_2d).normalized()
rot_angle = new_vec_dir.angle(self.deform_vec_pos)
start_3d = self.lw_tool.start_point.position
end_3d = self.lw_tool.end_point.position
if rot_angle != 0.0:
# check for left or right direction to rotate
vec_check_1 = Vector((new_vec_dir[0], new_vec_dir[1], 0))
vec_check_2 = Vector(
(new_vec_dir[0] - self.deform_vec_pos[0],
new_vec_dir[1] - self.deform_vec_pos[1], 0))
checker_side_dir = vec_check_1.cross(
vec_check_2).normalized()[2]
if checker_side_dir > 0.0:
rot_angle = -rot_angle
start_pos = self.lw_tool.start_point.position
rot_dir = None
if self.tool_mode == 'ROTATE_FRONT' or self.tool_mode == 'TWIST':
# ROTATE_FRONT code
rot_dir = (end_3d - start_3d).normalized()
else:
rot_dir = (rv3d.view_rotation * Vector(
(0.0, 0.0, -1.0))).normalized()
rot_angle += self.deform_mouse_pos # add rot angle
bend_side_dir = None
faloff_len = None
spiral_value = 0.0 # only for BEND_SPIRAL
bend_scale_value = 1.0 # only for BEND_ALL
if self.tool_mode == 'BEND_ALL' or self.tool_mode == 'BEND_SPIRAL':
bend_side_dir = (((end_3d - start_3d).normalized()
).cross(rot_dir)).normalized()
faloff_len = end_3d - start_3d
if self.tool_mode == 'BEND_SPIRAL':
val_scale = None
if rot_angle > 0.0:
val_scale = (1.0 -
((m_coords - start_2d).length /
self.bend_scale_len))
else:
val_scale = (((m_coords - start_2d).length /
self.bend_scale_len))
spiral_value = 1.0 - (faloff_len.length *
val_scale)
else:
val_scale = (((m_coords - start_2d).length /
self.bend_scale_len))
bend_scale_value = ((val_scale))
do_bend = False
if self.tool_mode == 'BEND_ALL' or self.tool_mode == 'BEND_SPIRAL':
do_bend = True
for vert_data in self.apply_tool_verts:
apply_value = vert_data[1]
final_apply_value = rot_angle * apply_value
# do rotation
if final_apply_value != 0.0:
rot_mat = Matrix.Rotation(final_apply_value, 3,
rot_dir)
vert = bm.verts[vert_data[0]]
if do_bend:
vert_temp = (active_obj.matrix_world *
vert_data[2]) - (
(faloff_len) * apply_value)
back_offset = (
((faloff_len).length /
(final_apply_value)) + spiral_value) * (
apply_value * bend_scale_value)
vert_temp += bend_side_dir * back_offset
vert.co = vert_temp
else:
# set original position
vert.co[0] = vert_data[2][0]
vert.co[1] = vert_data[2][1]
vert.co[2] = vert_data[2][2]
# ROTATE VERTS!
if do_bend:
vert.co = rot_mat * (
(vert.co) - start_pos) + start_pos
back_offset = (
(faloff_len).length /
(final_apply_value)) * (apply_value *
bend_scale_value)
vert.co = active_obj.matrix_world.inverted(
) * (vert.co - (bend_side_dir * back_offset))
else:
vert.co = active_obj.matrix_world.inverted(
) * (rot_mat *
((active_obj.matrix_world * vert.co) -
start_pos) + start_pos)
self.deform_vec_pos = new_vec_dir
self.deform_mouse_pos = rot_angle # set new angle rotation for next step
#bm.normal_update()
bmesh.update_edit_mesh(active_obj.data)
self.do_update = False
return {'RUNNING_MODAL'}
else:
if event.value == 'RELEASE' and event.type in {
'LEFTMOUSE', 'SELECTMOUSE'
}:
self.tool_mode = 'IDLE'
return {'RUNNING_MODAL'}
# main stuff
if event.type in {'RIGHTMOUSE', 'ESC'}:
context.space_data.show_manipulator = self.manipulator
# bpy.types.SpaceView3D.draw_handler_remove(self.lin_deform_handle_3d, 'WINDOW')
bpy.types.SpaceView3D.draw_handler_remove(
self.lin_deform_handle_2d, 'WINDOW')
context.area.header_text_set()
return {'FINISHED'}
elif event.type in self.pass_keys:
# allow navigation
return {'PASS_THROUGH'}
return {'RUNNING_MODAL'}
def create_mesh(data_list, AFMdata, use_smooth, scale_size, scale_height,
use_camera, use_lamp):
# This is for the image name.
path_list = AFMdata.datfile.strip('/').split('/')
number_img = len(data_list)
image_x_offset_gap = 10.0 * scale_size
image_x_all = sum(AFMdata.x_size) * scale_size
image_x_offset = -(image_x_all + image_x_offset_gap *
(number_img - 1)) / 2.0
# For each image do:
for k, data in enumerate(data_list):
size_x = AFMdata.x_pixel[k]
size_y = AFMdata.y_pixel[k]
image_scale = AFMdata.x_size[k] / float(AFMdata.x_pixel[k])
image_scale = image_scale * scale_size
image_x_size = AFMdata.x_size[k] * scale_size
image_x_offset += image_x_size / 2.0
image_name = path_list[-1] + "_" + AFMdata.channel[k][1]
data_mesh = []
data_faces = []
#print("passed - create_mesh ---- 1")
for i, line in enumerate(data):
for j, pixel in enumerate(line):
# The vertices
data_mesh.append(
Vector((float(i) * image_scale, float(j) * image_scale,
float(pixel) * scale_height)))
# The faces
if i < size_y - 1 and j < size_x - 1:
data_faces.append([
size_x * i + j, size_x * (i + 1) + j,
size_x * (i + 1) + j + 1, size_x * i + j + 1
])
#print("passed - create_mesh ---- 2")
# Build the mesh
surface_mesh = bpy.data.meshes.new("Mesh")
surface_mesh.from_pydata(data_mesh, [], data_faces)
surface_mesh.update()
surface = bpy.data.objects.new(image_name, surface_mesh)
bpy.context.scene.objects.link(surface)
bpy.ops.object.select_all(action='DESELECT')
surface.select = True
bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY')
# sum((v.co for v in mesh.vertices), Vector()) / len(mesh.vertices)
if use_smooth:
for polygon in surface.data.polygons:
polygon.use_smooth = True
surface.location = Vector((0.0, image_x_offset, 0.0))
image_x_offset += image_x_size / 2.0 + image_x_offset_gap
#print("passed - create_mesh ---- 3")
object_center_vec = Vector((0.0, 0.0, 0.0))
object_size = (sum(AFMdata.x_size) * scale_size + image_x_offset_gap *
(len(data_list) - 1))
# ------------------------------------------------------------------------
# CAMERA AND LAMP
camera_factor = 20.0
# If chosen a camera is put into the scene.
if use_camera == True:
# Assume that the object is put into the global origin. Then, the
# camera is moved in x and z direction, not in y. The object has its
# size at distance sqrt(object_size) from the origin. So, move the
# camera by this distance times a factor of camera_factor in x and z.
# Then add x, y and z of the origin of the object.
object_camera_vec = Vector((sqrt(object_size) * camera_factor, 0.0,
sqrt(object_size) * camera_factor))
camera_xyz_vec = object_center_vec + object_camera_vec
# Create the camera
current_layers = bpy.context.scene.layers
camera_data = bpy.data.cameras.new("A_camera")
camera_data.lens = 45
camera_data.clip_end = 50000.0
camera = bpy.data.objects.new("A_camera", camera_data)
camera.location = camera_xyz_vec
camera.layers = current_layers
bpy.context.scene.objects.link(camera)
# Here the camera is rotated such it looks towards the center of
# the object. The [0.0, 0.0, 1.0] vector along the z axis
z_axis_vec = Vector((0.0, 0.0, 1.0))
# The angle between the last two vectors
angle = object_camera_vec.angle(z_axis_vec, 0)
# The cross-product of z_axis_vec and object_camera_vec
axis_vec = z_axis_vec.cross(object_camera_vec)
# Rotate 'axis_vec' by 'angle' and convert this to euler parameters.
# 4 is the size of the matrix.
camera.rotation_euler = Matrix.Rotation(angle, 4, axis_vec).to_euler()
# Rotate the camera around its axis by 90° such that we have a nice
# camera position and view onto the object.
bpy.ops.object.select_all(action='DESELECT')
camera.select = True
bpy.ops.transform.rotate(value=(90.0 * 2 * pi / 360.0),
axis=object_camera_vec,
constraint_axis=(False, False, False),
constraint_orientation='GLOBAL',
mirror=False,
proportional='DISABLED',
proportional_edit_falloff='SMOOTH',
proportional_size=1,
snap=False,
snap_target='CLOSEST',
snap_point=(0, 0, 0),
snap_align=False,
snap_normal=(0, 0, 0),
release_confirm=False)
# Here a lamp is put into the scene, if chosen.
if use_lamp == True:
# This is the distance from the object measured in terms of %
# of the camera distance. It is set onto 50% (1/2) distance.
lamp_dl = sqrt(object_size) * 15 * 0.5
# This is a factor to which extend the lamp shall go to the right
# (from the camera point of view).
lamp_dy_right = lamp_dl * (3.0 / 4.0)
# Create x, y and z for the lamp.
object_lamp_vec = Vector((lamp_dl, lamp_dy_right, lamp_dl))
lamp_xyz_vec = object_center_vec + object_lamp_vec
# Create the lamp
current_layers = bpy.context.scene.layers
lamp_data = bpy.data.lamps.new(name="A_lamp", type="POINT")
lamp_data.distance = 5000.0
lamp_data.energy = 3.0
lamp_data.shadow_method = 'RAY_SHADOW'
lamp = bpy.data.objects.new("A_lamp", lamp_data)
lamp.location = lamp_xyz_vec
lamp.layers = current_layers
bpy.context.scene.objects.link(lamp)
bpy.context.scene.world.light_settings.use_ambient_occlusion = True
bpy.context.scene.world.light_settings.ao_factor = 0.1
def create_poly_box(polyline, allverts, materials, geocenter):
materialindex = int(polyline.attrib["m"])
idxs = []
idxs.append(int(polyline.attrib["v1"]))
idxs.append(int(polyline.attrib["v2"]))
idxs.append(int(polyline.attrib["v3"]))
idxs.append(int(polyline.attrib["v4"]))
verts = []
for idx in idxs:
verts.append(allverts[idx])
p1 = verts[0]
p2 = verts[1]
p3 = verts[2]
p4 = verts[3]
a, b, c, d = p1, p2, p3, p4
cf1 = (a + b) / 2
cf2 = (c + d) / 2
cf3 = (a + d) / 2
cf4 = (b + c) / 2
cf5 = (a + c) / 2
cf6 = (b + d) / 2
# caclulate box center
center = (cf3 + cf4) / 2
rightest = get_closest_axis_point(Vector((1, 0, 0)), center,
[cf1, cf2, cf3, cf4, cf5, cf6])
upest = get_closest_axis_point(Vector((0, 0, 1)), center,
[cf1, cf2, cf3, cf4, cf5, cf6])
right = (rightest - center).normalized()
up = (upest - center).normalized()
forward = Vector.cross(right, up).normalized()
mat = Matrix.Identity(4)
mat[0] = (right.x, right.y, right.z, 0)
mat[1] = (up.x, up.y, up.z, 0)
mat[2] = (forward.x, forward.y, forward.z, 0)
mat[3] = (0, 0, 0, 1)
mat.normalize()
rotation = mat.to_quaternion().inverted().normalized().to_euler('XYZ')
# calculate scale
seq = [cf1, cf2, cf3, cf4, cf5, cf6]
_cf1 = get_closest_axis_point(right, center, seq)
_cf2 = get_closest_axis_point(-right, center, seq)
_cf3 = get_closest_axis_point(-up, center, seq)
_cf4 = get_closest_axis_point(up, center, seq)
_cf5 = get_closest_axis_point(-forward, center, seq)
_cf6 = get_closest_axis_point(forward, center, seq)
W = (_cf2 - _cf1).length
L = (_cf3 - _cf4).length
H = (_cf5 - _cf6).length
scale = Vector((W, L, H))
# blender stuff
mesh = bpy.data.meshes.new("box")
bm = bmesh.new()
bmesh.ops.create_cube(bm, size=1)
bm.to_mesh(mesh)
bm.free()
mat = materials[materialindex]
mesh.materials.append(mat)
obj = bpy.data.objects.new("box", mesh)
#obj.data.materials.append(material)
#location = center + geocenter
obj.location = center #location #boxes dont use geocenter to offset?
obj.rotation_euler = rotation
obj.scale = scale
obj.sollumtype = "Bound Box"
return obj
class GlHandle(GlPolygon):
def __init__(self, sensor_size, size, draggable=False, selectable=False, d=3):
"""
sensor_size : 2d size in pixels of sensor area
size : 3d size of handle
"""
GlPolygon.__init__(self, d=d)
self.colour_active = (1.0, 0.0, 0.0, 1.0)
self.colour_hover = (1.0, 1.0, 0.0, 1.0)
self.colour_normal = (1.0, 1.0, 1.0, 1.0)
self.colour_selected = (0.0, 0.0, 0.7, 1.0)
self.size = size
self.sensor_width = sensor_size
self.sensor_height = sensor_size
self.pos_3d = Vector((0, 0, 0))
self.up_axis = Vector((0, 0, 0))
self.c_axis = Vector((0, 0, 0))
self.hover = False
self.active = False
self.draggable = draggable
self.selectable = selectable
self.selected = False
def set_pos(self, context, pos_3d, direction, normal=Vector((0, 0, 1))):
self.up_axis = direction.normalized()
self.c_axis = self.up_axis.cross(normal)
self.pos_3d = pos_3d
self.pos_2d = self.position_2d_from_coord(context, self.sensor_center)
def check_hover(self, pos_2d):
if self.draggable:
dp = pos_2d - self.pos_2d
self.hover = abs(dp.x) < self.sensor_width and abs(dp.y) < self.sensor_height
@property
def sensor_center(self):
pts = self.pts
n = len(pts)
x, y, z = 0, 0, 0
for pt in pts:
x += pt.x
y += pt.y
z += pt.z
return Vector((x / n, y / n, z / n))
@property
def pts(self):
raise NotImplementedError
@property
def colour(self):
if self.render:
return self.colour_inactive
elif self.draggable:
if self.active:
return self.colour_active
elif self.hover:
return self.colour_hover
elif self.selected:
return self.colour_selected
return self.colour_normal
else:
return self.colour_inactive
def add_f_curve_modifiers(armature_object, strength, speed):
wind_vector = Vector((1, 0, 0)) * strength
fcurves = armature_object.animation_data.action.fcurves
for f in fcurves:
for m in f.modifiers:
f.modifiers.remove(m)
bones = organize_bones(armature_object)
for b in bones:
mass = b.bone.tail_radius**2 * b.length
barycenter = b.tail * mass
for c in b.children:
mass += c["mass"]
barycenter += Vector(c["barycenter"])
b["mass"] = mass
b["barycenter"] = barycenter
barycenter /= mass
b.rotation_mode = 'XYZ'
b.keyframe_insert('rotation_euler', frame=0, index=0)
b.keyframe_insert('rotation_euler', frame=0, index=2)
fcurves = armature_object.animation_data.action.fcurves
for i in range(len(bones)):
f0 = fcurves[2 * i]
f1 = fcurves[2 * i + 1]
b = bones[i]
i_base = b.matrix.to_3x3().inverted()
bone_vector = b.tail - b.head
inertia_moment = bone_vector.length**2 * bones[i]["mass"] / 10000
damping = 0.5 * b.bone.tail_radius
stiffness = b.bone.tail_radius**2 / b.length * 800
if b.parent is not None and len(b.parent.children) > 1:
stiffness *= 2
# torque /= 3
# else:
# torque = Vector((0, 0, 0))
torque = i_base * wind_vector.cross(bone_vector) / (
b.bone.tail_radius) / 1000
f = sqrt(abs(damping**2 - 4 * inertia_moment * stiffness)) / (
5 * b.bone.tail_radius) * speed
x_amplitude = torque.x
z_amplitude = torque.z
m0 = f0.modifiers.new(type='FNGENERATOR')
m1 = f1.modifiers.new(type='FNGENERATOR')
m0.function_type = 'SIN'
m1.function_type = 'SIN'
m0.amplitude = x_amplitude
m1.amplitude = z_amplitude
m0.phase_multiplier = f
m1.phase_multiplier = f
m0.value_offset = x_amplitude * 3
m1.value_offset = z_amplitude * 3
def execute(self, context):
if self.reset_values is True:
self.reset_all_values()
active_obj = context.scene.objects.active
bm = bmesh.from_edit_mesh(active_obj.data)
bm.verts.ensure_lookup_table()
#verts = [v for v in bm.verts if v.select]
# get loops
loops = loop_t.get_connected_input(bm)
loops = loop_t.check_loops(loops, bm)
if not loops:
self.report({'WARNING'}, "No Loops!")
return {'CANCELLED'}
first_indexes = []
if isinstance(bm.select_history[0], bmesh.types.BMVert):
for element in bm.select_history:
first_indexes.append(element.index)
elif isinstance(bm.select_history[0], bmesh.types.BMEdge):
for element in bm.select_history:
el_verts = element.verts
first_indexes.append(el_verts[0].index)
first_indexes.append(el_verts[1].index)
for loop in loops:
if loop[1] is True:
continue
loop_verts = []
for ind in loop[0]:
loop_verts.append(bm.verts[ind])
# for the case if we need to reverse it
if loop[0][-1] in first_indexes:
loop_verts = list(reversed(loop_verts))
# reverse again for the direction
if self.reverse_direction is True:
loop_verts = list(reversed(loop_verts))
# positions
first_vert_pos = active_obj.matrix_world * loop_verts[0].co
last_vert_pos = active_obj.matrix_world * loop_verts[-1].co
loop_centr_orig = first_vert_pos.lerp(last_vert_pos, 0.5)
relative_dist = (first_vert_pos - loop_centr_orig).length
sidevec = (first_vert_pos - last_vert_pos).normalized()
obj_matrix = active_obj.matrix_world
obj_matrix_inv = obj_matrix.inverted()
if self.direction_vector == 'Custom':
rot_dir = Vector((self.rotate_axis[0], self.rotate_axis[1],
self.rotate_axis[2])).normalized()
elif self.direction_vector == 'MiddleCrossed':
middle_nor = loop_verts[int(len(loop_verts) /
2)].normal.copy().normalized()
middle_nor = ut_base.get_normal_world(middle_nor, obj_matrix,
obj_matrix_inv)
rot_dir = middle_nor.cross(sidevec).normalized()
# fix only for MiddleCrossed
if not self.reverse_direction:
rot_dir.negate()
else:
middle_nor = loop_verts[int(len(loop_verts) /
2)].normal.copy().normalized()
middle_nor = ut_base.get_normal_world(middle_nor, obj_matrix,
obj_matrix_inv)
middle_nor = middle_nor.cross(sidevec).normalized()
rot_dir = middle_nor.cross(sidevec).normalized()
rot_dir.negate()
upvec = rot_dir.cross(sidevec).normalized()
loop_centr = (self.upvec_offset * upvec *
relative_dist) + loop_centr_orig
loop_angle = (first_vert_pos - loop_centr).normalized().angle(
(last_vert_pos - loop_centr).normalized())
if self.upvec_offset > 0:
loop_angle = math.radians((360 - math.degrees(loop_angle)))
# even spread
line_data = None
if self.spread_mode == 'Even':
world_verts = [
active_obj.matrix_world * vert.co for vert in loop_verts
]
line_data = []
line_length = 0.0
for i, vec in enumerate(world_verts):
if i == 0:
line_data.append(0)
else:
line_length += (vec - world_verts[i - 1]).length
line_data.append(line_length)
# make arc!
for i, vert in enumerate(loop_verts):
if i != 0 and i != len(loop_verts) - 1:
if self.spread_mode == 'Normal':
rot_angle = loop_angle * (i / (len(loop_verts) - 1))
else:
rot_angle = loop_angle * (
line_data[i] / line_data[len(loop_verts) - 1])
rot_mat = Matrix.Rotation(rot_angle, 3, rot_dir)
vert_pos = (rot_mat *
(first_vert_pos - loop_centr)) + loop_centr
if self.scale_arc != 0:
vert_rel_dist = mathu.geometry.distance_point_to_plane(
vert_pos, loop_centr_orig, upvec)
vert_rel_dist_max = self.upvec_offset + relative_dist
if vert_rel_dist != 0 and vert_rel_dist_max != 0:
vert_pos_offset = vert_rel_dist / vert_rel_dist_max
vert_pos += (self.scale_arc * upvec *
vert_pos_offset * vert_rel_dist_max)
# rotate arc
if self.rotate_arc_axis != 0:
rot_mat_2 = Matrix.Rotation(
math.radians(self.rotate_arc_axis), 3, sidevec)
vert_pos = (
rot_mat_2 *
(vert_pos - loop_centr_orig)) + loop_centr_orig
vert.co = active_obj.matrix_world.inverted() * vert_pos
bm.normal_update()
bmesh.update_edit_mesh(active_obj.data)
return {'FINISHED'}
def draw_molecule(molecule, center=(0, 0, 0), show_bonds=True, join=True):
"""Draws a JSON-formatted molecule in Blender.
This method uses a couple of tricks from [1] to improve rendering speed.
In particular, it minimizes the amount of unique meshes and materials,
and doesn't draw until all objects are initialized.
[1] https://blenderartists.org/forum/showthread.php
?273149-Generating-a-large-number-of-mesh-primitives
Args:
molecule: The molecule to be drawn, as a python object following the
JSON convention set in this project.
center: (Optional, default (0, 0, 0)) Cartesian center of molecule. Use
to draw multiple molecules in different locations.
show_bonds: (Optional, default True) Draws a ball-and-stick model if
True, and a space-filling model if False.
join: (Optional, default True) Joins the molecule into a single object.
Set to False if you want to individually manipulate atoms/bonds.
Returns:
If run in a blender context, will return a visual object of the
molecule.
"""
shapes = []
# If using space-filling model, scale up atom size and remove bonds
# Add atom primitive
bpy.ops.object.select_all(action='DESELECT')
bpy.ops.mesh.primitive_uv_sphere_add()
sphere = bpy.context.object
# Initialize bond material if it's going to be used.
if show_bonds:
bpy.data.materials.new(name='bond')
# print(bpy.data.materials['bond'])
bpy.data.materials[
'bond'].diffuse_color = atom_data['bond']['color'] + [1.0]
bpy.data.materials['bond'].specular_intensity = 0.2
bpy.ops.mesh.primitive_cylinder_add()
cylinder = bpy.context.object
cylinder.active_material = bpy.data.materials['bond']
# draw atoms
for atom in molecule['atoms']:
if atom['element'] not in atom_data:
atom['element'] = 'undefined'
if atom['element'] not in bpy.data.materials:
key = atom['element']
bpy.data.materials.new(name=key)
bpy.data.materials[key].diffuse_color = atom_data[key]['color'] + [
1.0
]
bpy.data.materials[key].specular_intensity = 0.2
atom_sphere = sphere.copy()
atom_sphere.data = sphere.data.copy()
atom_sphere.location = [
l + c for l, c in zip(atom['location'], center)
]
scale = 1 if show_bonds else 2.5
atom_sphere.dimensions = [
atom_data[atom['element']]['radius'] * scale * 2
] * 3
atom_sphere.active_material = bpy.data.materials[atom['element']]
bpy.context.collection.objects.link(atom_sphere)
shapes.append(atom_sphere)
# draw bonds
for bond in (molecule['bonds'] if show_bonds else []):
start = molecule['atoms'][bond['atoms'][0]]['location']
end = molecule['atoms'][bond['atoms'][1]]['location']
diff = [c2 - c1 for c2, c1 in zip(start, end)]
cent = [(c2 + c1) / 2 for c2, c1 in zip(start, end)]
mag = sum([(c2 - c1)**2 for c1, c2 in zip(start, end)])**0.5
v_axis = Vector(diff).normalized()
v_obj = Vector((0, 0, 1))
v_rot = v_obj.cross(v_axis)
# This check prevents gimbal lock (ie. weird behavior when v_axis is
# close to (0, 0, 1))
if v_rot.length > 0.01:
v_rot = v_rot.normalized()
axis_angle = [acos(v_obj.dot(v_axis))] + list(v_rot)
else:
v_rot = Vector((1, 0, 0))
axis_angle = [0] * 4
if bond['order'] not in range(1, 4):
sys.stderr.write("Improper number of bonds! Defaulting to 1.\n")
bond['order'] = 1
if bond['order'] == 1:
trans = [[0] * 3]
elif bond['order'] == 2:
trans = [[1.4 * atom_data['bond']['radius'] * x for x in v_rot],
[-1.4 * atom_data['bond']['radius'] * x for x in v_rot]]
elif bond['order'] == 3:
trans = [[0] * 3,
[2.2 * atom_data['bond']['radius'] * x for x in v_rot],
[-2.2 * atom_data['bond']['radius'] * x for x in v_rot]]
for i in range(bond['order']):
bond_cylinder = cylinder.copy()
bond_cylinder.data = cylinder.data.copy()
bond_cylinder.dimensions = [
atom_data['bond']['radius'] * scale * 2
] * 2 + [mag]
bond_cylinder.location = [
c + scale * v for c, v in zip(cent, trans[i])
]
bond_cylinder.rotation_mode = 'AXIS_ANGLE'
bond_cylinder.rotation_axis_angle = axis_angle
bpy.context.collection.objects.link(bond_cylinder)
shapes.append(bond_cylinder)
# Remove primitive meshes
bpy.ops.object.select_all(action='DESELECT')
sphere.select_set(state=True)
if show_bonds:
cylinder.select_set(state=True)
# If the starting cube is there, remove it
if 'Cube' in bpy.data.objects.keys():
bpy.data.objects.get('Cube').select_set(state=True)
bpy.ops.object.delete()
for shape in shapes:
shape.select_set(state=True)
bpy.context.view_layer.objects.active = shapes[0]
bpy.ops.object.shade_smooth()
if join:
bpy.ops.object.join()
bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY', center='MEDIAN')
bpy.context.view_layer.update()
def lookFrom(p):
y = Vector([0,0,1])
z = p
x = y.cross(z).normalized()
y = z.cross(x).normalized()
return Matrix.Translation(p) @ Matrix([x, y, z]).transposed().to_4x4()
def execute(self, context):
self.hcol = context.preferences.addons[
'kekit'].preferences.modal_color_header
self.tcol = context.preferences.addons[
'kekit'].preferences.modal_color_text
self.scol = context.preferences.addons[
'kekit'].preferences.modal_color_subtext
if self.ke_fitprim_option == "BOX":
self.boxmode, self.world = True, False
elif self.ke_fitprim_option == "CYL":
self.boxmode, self.world = False, False
elif self.ke_fitprim_option == "SPHERE":
self.boxmode, self.world, self.sphere = False, False, True
elif self.ke_fitprim_option == "QUADSPHERE":
self.boxmode, self.world, self.sphere = False, False, True
else:
self.boxmode, self.world, self.sphere = False, False, False
if bpy.context.scene.kekit.fitprim_item:
self.itemize = True
else:
self.itemize = self.ke_fitprim_itemize
self.modal = bpy.context.scene.kekit.fitprim_modal
self.cyl_sides = bpy.context.scene.kekit.fitprim_sides
self.select = bpy.context.scene.kekit.fitprim_select
self.unit = round(bpy.context.scene.kekit.fitprim_unit, 4)
self.sphere_ring = bpy.context.scene.kekit.fitprim_sphere_ring
self.sphere_seg = bpy.context.scene.kekit.fitprim_sphere_seg
self.quadsphere_seg = bpy.context.scene.kekit.fitprim_quadsphere_seg
self.edit_mode = bpy.context.mode
sel_verts = []
sel_verts2 = []
multi_object_mode = False
cursor = context.scene.cursor
self.og_cloc = cursor.location.copy()
self.og_crot = cursor.rotation_euler.copy()
og_orientation = str(context.scene.transform_orientation_slots[0].type)
if self.itemize or self.edit_mode == "OBJECT" and context.object is not None:
# make sure the new object is in the same layer as context object
objc = context.object.users_collection[0]
layer_collection = context.view_layer.layer_collection
layer_coll = get_layer_collection(layer_collection, objc.name)
alc = context.view_layer.active_layer_collection
if objc.name != alc.name and alc.name != "Master Collection":
context.view_layer.active_layer_collection = layer_coll
elif objc.name != "Master Collection" and objc.name != alc.name:
context.view_layer.active_layer_collection = layer_coll
# -----------------------------------------------------------------------------------------
# MULTI OBJECT CHECK & SETUP
# -----------------------------------------------------------------------------------------
if self.edit_mode == "EDIT_MESH":
sel_mode = [b for b in bpy.context.tool_settings.mesh_select_mode]
other_side = []
sel_obj = [
o for o in bpy.context.selected_objects if o.type == "MESH"
]
if len(sel_obj) == 2:
multi_object_mode = True
obj = bpy.context.active_object
obj_mtx = obj.matrix_world.copy()
second_obj = []
bm = bmesh.from_edit_mesh(obj.data)
bm.faces.ensure_lookup_table()
bm.verts.ensure_lookup_table()
sel_verts = [v for v in bm.verts if v.select]
if sel_mode[2]:
sel_poly = [p for p in bm.faces if p.select]
active_face = bm.faces.active
if active_face not in sel_poly:
active_face = None
if multi_object_mode:
second_obj = [o for o in sel_obj if o != obj][0]
bm2 = bmesh.from_edit_mesh(second_obj.data)
obj_mtx2 = second_obj.matrix_world.copy()
sel_poly2 = [p for p in bm2.faces if p.select]
if sel_poly2:
active_face2 = bm2.faces.active
if active_face2 not in sel_poly2:
active_face2 = None
if active_face2:
sel_verts2 = active_face2.verts
else:
sel_verts2 = sel_poly2[0].verts
active_face2 = sel_poly2[0] # haxxfixxx
else:
sel_verts2 = [v for v in bm2.verts if v.select]
if not sel_verts2:
multi_object_mode = False
elif sel_mode[0]:
# Just for 2-vert mode in multiobj mode
ole = sel_verts2[0].link_edges[:]
other_side = get_shortest(obj_mtx2, ole)
side = None
distance = 0
vps = []
normal, setpos, setrot, center = None, None, None, None
first_island = None
island_mode = False
# -----------------------------------------------------------------------------------------
# NO SELECTION MODE
# -----------------------------------------------------------------------------------------
if not sel_verts or self.edit_mode == "OBJECT":
# Check mouse over target
if not self.edit_mode == "OBJECT":
bpy.ops.object.mode_set(mode="OBJECT")
hit_obj, hit_wloc, hit_normal, hit_face = mouse_raycast(
context, self.mouse_pos, evaluated=True)
if not self.edit_mode == "OBJECT":
bpy.ops.object.mode_set(mode="EDIT")
if self.edit_mode != "OBJECT" and hit_obj is not None:
if len(hit_obj.modifiers) > 0:
self.report({
"INFO"
}, "FitPrim: Selected elements required in Edit Mode if Modifiers exist"
)
return {"CANCELLED"}
if hit_obj and hit_face is not None:
# mouse over placement on face
self.world = False
mtx = hit_obj.matrix_world
eks = hit_obj.data.polygons[hit_face].edge_keys
vecs = []
for vp in eks:
vc1 = mtx @ hit_obj.data.vertices[vp[0]].co
vc2 = mtx @ hit_obj.data.vertices[vp[1]].co
vecs.append(Vector(vc1 - vc2).normalized())
evps = []
for vp in eks:
v1, v2 = hit_obj.data.vertices[
vp[0]], hit_obj.data.vertices[vp[1]]
evps.append([v1, v2])
side, center, start_vec = get_sides(mtx, vecs, evps)
if self.ke_fitprim_option == "PLANE" and self.edit_mode == "OBJECT":
setpos = center
# setpos = mtx @ hit_obj.data.polygons[hit_face].center
side *= 2
else:
offset = hit_normal * (side / 2)
setpos = center + offset
# setpos = mtx @ hit_obj.data.polygons[hit_face].center + offset
setrot = rotation_from_vector(hit_normal, start_vec)
else:
# view placement compensation & Z0 drop
view_vec = region_2d_to_vector_3d(context.region,
context.space_data.region_3d,
self.mouse_pos)
view_pos = context.space_data.region_3d.view_matrix.inverted(
).translation
if get_view_type() != "ORTHO":
ground = ((0, 0, 0), (0, 1, 0), (1, 0, 0))
raypos = intersect_ray_tri(ground[0], ground[1], ground[2],
view_vec, view_pos, False)
snap_val = str(self.unit).split('.')
if int(snap_val[0]) > 0:
snap = 0
else:
snap = len(snap_val[1])
setpos = Vector((round(raypos[0],
snap), round(raypos[1],
snap), self.unit / 2))
else:
setpos = region_2d_to_location_3d(
context.region, context.space_data.region_3d,
self.mouse_pos, view_vec)
self.world = True
side = self.unit
if self.ke_fitprim_option == "PLANE" and self.edit_mode == "OBJECT":
side *= 2
distance = side
sel_mode = (True, False, False)
# -----------------------------------------------------------------------------------------
# VERT MODE(s)
# -----------------------------------------------------------------------------------------
elif sel_mode[0]:
if len(sel_verts) == 1 and not multi_object_mode:
# 1-VERT MODE
self.world = True
side = get_shortest(obj_mtx, sel_verts[0].link_edges[:])
distance = side
setpos = obj_mtx @ sel_verts[0].co
elif len(sel_verts) == 2 and not multi_object_mode or \
multi_object_mode and len(sel_verts2) == 1 and len(sel_verts) == 1:
# 2 Vert mode
if multi_object_mode:
p1 = obj_mtx @ sel_verts[0].co
p2 = obj_mtx2 @ sel_verts2[0].co
side = [other_side]
con_edges = sel_verts[0].link_edges[:]
side.append(get_shortest(obj_mtx, con_edges))
side = sorted(side)[0]
else:
p1 = obj_mtx @ sel_verts[0].co
p2 = obj_mtx @ sel_verts[1].co
con_edges = sel_verts[0].link_edges[:] + sel_verts[
1].link_edges[:]
side = get_shortest(obj_mtx, con_edges)
v_1 = Vector(p1 - p2).normalized()
v_2 = Vector((0, 0, 1))
if abs(v_1.dot(v_2)) == 1:
v_2 = Vector((1, 0, 0))
n_v = v_1.cross(v_2).normalized()
u_v = n_v.cross(v_1).normalized()
t_v = u_v.cross(n_v).normalized()
setrot = Matrix((u_v, n_v, t_v)).to_4x4().inverted()
distance = get_distance(p1, p2)
setpos = Vector(get_midpoint(p1, p2))
elif len(sel_verts) == 4 or multi_object_mode and len(
sel_verts2) + len(sel_verts) <= 4:
# 4-vert Rectangle mode
# holy brute force batman
if not second_obj:
second_obj = obj
tri = tri_order(((obj, sel_verts), (second_obj, sel_verts2)))
q = tri[-1]
# just placing a unit prim with min side in the center (for this one) so disregarding other vecs
v1 = Vector(tri[0][0].matrix_world @ tri[0][1].co -
tri[1][0].matrix_world @ tri[1][1].co)
v2 = Vector(tri[0][0].matrix_world @ tri[0][1].co -
tri[2][0].matrix_world @ tri[2][1].co)
# v3 = Vector(q[0].matrix_world @ q[1].co - tri[1][0].matrix_world @ tri[1][1].co)
# v4 = Vector(q[0].matrix_world @ q[1].co - tri[2][0].matrix_world @ tri[2][1].co)
d1 = get_distance(tri[0][0].matrix_world @ tri[0][1].co,
tri[1][0].matrix_world @ tri[1][1].co)
# d2 = get_distance(tri[0][0].matrix_world @ tri[0][1].co, tri[2][0].matrix_world @ tri[2][1].co)
# d3 = get_distance(q[0].matrix_world @ q[1].co, tri[1][0].matrix_world @ tri[1][1].co)
d4 = get_distance(q[0].matrix_world @ q[1].co,
tri[2][0].matrix_world @ tri[2][1].co)
if d1 < d4:
side = d1
else:
side = d4
distance = side
ap1 = average_vector([obj_mtx @ v.co for v in sel_verts])
if sel_verts2:
ap2 = average_vector([obj_mtx2 @ v.co for v in sel_verts2])
setpos = average_vector((ap1, ap2))
else:
setpos = ap1
n = v1.normalized().cross(v2.normalized())
u = n.cross(v1.normalized())
t = u.cross(n)
setrot = Matrix((u, n, t)).to_4x4().inverted()
else:
self.report({
"INFO"
}, "FitPrim: Invalid Vert Mode Selection: Select 1, 2 or 4 verts"
)
return {"CANCELLED"}
# -----------------------------------------------------------------------------------------
# EDGE MODE
# -----------------------------------------------------------------------------------------
elif sel_mode[1]:
one_line, loops, loops2 = False, [], []
sel_edges = [e for e in bm.edges if e.select]
vps = [e.verts[:] for e in sel_edges]
active_edge = bm.select_history.active
if active_edge:
active_edge_facenormals = [
correct_normal(obj_mtx, p.normal)
for p in active_edge.link_faces
]
active_edge_normal = Vector(
average_vector(active_edge_facenormals)).normalized()
# GET ISLANDS
if multi_object_mode and active_edge:
# print("multi obj mode") # todo: limited multiobj mode, rework one-for-all?
sel_edges2 = [e for e in bm2.edges if e.select]
vps2 = [e.verts for e in sel_edges2]
p1 = get_loops(vps, legacy=True)
p2 = get_loops(vps2, legacy=True)
if p1 and p2:
a1, a2 = obj_mtx @ p1[0][0].co, obj_mtx @ p1[0][-1].co
b1, b2 = obj_mtx2 @ p2[0][0].co, obj_mtx2 @ p2[0][-1].co
else:
a1, a2 = obj_mtx @ sel_verts[0].co, obj_mtx @ sel_verts[
-1].co
b1, b2 = obj_mtx2 @ sel_verts2[
0].co, obj_mtx2 @ sel_verts2[-1].co
b_avg = get_midpoint(b1, b2)
spacing, mp = get_closest_midpoint(a1, a2, b_avg)
u_v = Vector(a1 - b1).normalized()
t_v = Vector(a1 - a2).normalized()
n_v = u_v.cross(t_v).normalized()
setrot = rotation_from_vector(n_v, t_v, rotate90=True)
setpos = mp
side = spacing
distance = spacing
elif active_edge: # same (active) obj island selections
if len(sel_edges) > 1:
if len(sel_edges) == 2 and not bool(
set(sel_edges[0].verts).intersection(
sel_edges[1].verts)):
a1p, a2p = sel_edges[0].verts, sel_edges[1].verts
a1, a2 = obj_mtx @ a1p[0].co, obj_mtx @ a1p[1].co
b_avg = average_vector(
[obj_mtx @ a2p[0].co, obj_mtx @ a2p[1].co])
lf1 = sel_edges[0].link_faces[:]
lf = [
f for f in sel_edges[1].link_faces[:] if f in lf1
]
v1 = Vector((obj_mtx @ a1p[0].co -
obj_mtx @ a1p[1].co)).normalized()
v2 = Vector((obj_mtx @ a2p[0].co -
obj_mtx @ a2p[1].co)).normalized()
if not lf:
u_v = Vector(a1 -
(obj_mtx @ a2p[0].co)).normalized()
t_v = Vector(a1 - a2).normalized()
n_v = u_v.cross(t_v).normalized()
setrot = rotation_from_vector(n_v,
t_v,
rotate90=True)
else:
n = correct_normal(obj_mtx, lf[0].normal)
# t = average_vector((v1, v2))
# if sum(t) == 0:
# print("AVG FAIL")
t = v1
setrot = rotation_from_vector(n, t, rotate90=True)
spacing, mp = get_closest_midpoint(a1, a2, b_avg)
setpos = mp
side = spacing
distance = spacing
else:
loops = get_loops(vps, legacy=True)
if len(loops) > 1:
# print ("single obj - multi loop", len(loops))
# Check for closed loops
a_ep1, a_ep2 = loops[0][0], loops[0][-1]
b_ep1, b_ep2 = loops[1][0], loops[1][-1]
if a_ep1 == a_ep2:
a_ep2 = loops[0][-2]
if b_ep1 == b_ep2:
b_ep2 = loops[1][-2]
# get coords & set vals
a1, a2 = obj_mtx @ a_ep1.co, obj_mtx @ a_ep2.co
b1, b2 = obj_mtx @ b_ep1.co, obj_mtx @ b_ep2.co
b_avg = get_midpoint(b1, b2)
spacing, mp = get_closest_midpoint(a1, a2, b_avg)
u_v = Vector((0, 0, 1))
t_v = Vector(a1 - a2).normalized()
if abs(u_v.dot(t_v)) == 1:
u_v = Vector((1, 0, 0))
n_v = u_v.cross(t_v).normalized()
setrot = rotation_from_vector(n_v, t_v, rotate90=False)
setpos = mp
side = spacing
distance = spacing
elif len(loops) == 1 or len(sel_edges) == 1:
# print ("single obj - single loop")
single_line = False
if len(sel_edges) != 1:
if loops[0][0] != loops[0][-1]:
single_line = True
if len(sel_edges) != 1 and not single_line:
vecs = [
Vector((obj_mtx @ vp[0].co) -
(obj_mtx @ vp[1].co)).normalized()
for vp in vps
]
normal = average_vector([
correct_normal(obj_mtx, v.normal)
for v in flatten(vps)
])
side, center, start_vec = get_sides(obj_mtx, vecs, vps)
distance = side
setpos = center
setrot = rotation_from_vector(normal, start_vec)
elif len(sel_edges) == 1 or single_line:
# print("1 edge --> one line", one_line)
p1, p2 = obj_mtx @ sel_verts[
0].co, obj_mtx @ sel_verts[1].co
t_v = Vector(p1 - p2).normalized()
n_v = active_edge_normal
setrot = rotation_from_vector(n_v, t_v)
distance = get_distance(p1, p2)
setpos = get_midpoint(p1, p2)
side = distance
else:
print("Unexpected: Aborting operation.")
return {'CANCELLED'}
# -----------------------------------------------------------------------------------------
# FACE MODE
# -----------------------------------------------------------------------------------------
elif sel_mode[2] and active_face and sel_poly:
fail_island = False
# GET ISLANDS
if multi_object_mode and active_face:
first_island = sel_verts
point = obj_mtx @ active_face.calc_center_median()
firstcos = [obj_mtx @ v.co for v in active_face.verts]
secondcos = [obj_mtx2 @ v.co for v in active_face2.verts]
if firstcos and secondcos:
island_mode = True
distance = point_to_plane(point, firstcos, secondcos)
if distance:
distance = abs(distance)
else:
# print("Multi obj Point to plane failed for some reason - using single island mode.")
# island_mode = False
fail_island = True
else: # same (active) obj island selections
first_island, second_island = get_selection_islands(
sel_poly, active_face)
# Ofc, needs correct order for point to plane, and I'll just rely on face.verts for that:
calc_island_1 = active_face.verts[:]
calc_island_2 = []
for p in sel_poly:
verts = p.verts[:]
for v in verts:
if v in second_island:
calc_island_2 = verts
break
if len(first_island) != 0 and len(second_island) != 0:
firstcos = [obj_mtx @ v.co for v in calc_island_1]
secondcos = [obj_mtx @ v.co for v in calc_island_2]
distance = point_to_plane(
obj_mtx @ active_face.calc_center_median(), firstcos,
secondcos)
if distance:
distance = abs(distance)
island_mode = True
else:
# print("Point to plane failed for some reason - using single island mode.")
fail_island = True
# print(distance)
else:
# Ngon mode
first_island = sel_verts
# GETVALUES
if island_mode or fail_island:
bpy.ops.mesh.select_all(action='DESELECT')
for v in first_island:
bm.verts[v.index].select = True
bmesh.update_edit_mesh(obj.data)
bpy.ops.mesh.select_mode(type='VERT')
bpy.ops.mesh.select_mode(type='FACE')
bm.faces.ensure_lookup_table()
faces = [f for f in bm.faces if f.select]
normal = average_vector(
[correct_normal(obj_mtx, f.normal) for f in faces])
bpy.ops.mesh.region_to_loop()
sel_edges = [e for e in bm.edges if e.select]
vps = [e.verts[:] for e in sel_edges]
vecs = [
Vector((obj_mtx @ vp[0].co) -
(obj_mtx @ vp[1].co)).normalized() for vp in vps
]
side, center, start_vec = get_sides(obj_mtx, vecs, vps)
setrot = rotation_from_vector(normal, start_vec)
# -----------------------------------------------------------------------------------------
# PROCESS
# -----------------------------------------------------------------------------------------
if side:
if self.ke_fitprim_option == "PLANE" and self.edit_mode != "OBJECT":
if sel_mode[2]:
setpos = center
elif len(sel_verts) == 0 or sel_mode[0] or sel_mode[1]:
side *= .5
distance = distance / 2
if self.sphere and sel_mode[0]:
if not len(sel_verts) == 0:
side = distance
elif sel_mode[2]:
if island_mode:
side *= .5
offset = normal * distance * .5
distance *= .5
if self.sphere:
side = distance
else:
side *= .5
distance = side
offset = normal * side
setpos = center + offset
if not island_mode and self.sphere:
setpos = setpos - offset
# SET FINAL ROTATION
if self.world:
setrot = (0, 0, 0)
if self.ke_fitprim_option == "PLANE" and not sel_verts:
setpos[2] = 0
else:
setrot = setrot.to_euler()
# RUN OP
if not self.edit_mode == "OBJECT":
bpy.ops.mesh.select_mode(type='FACE')
if self.itemize:
if self.edit_mode != "OBJECT":
bpy.ops.object.mode_set(mode="OBJECT")
bpy.ops.transform.select_orientation(orientation='GLOBAL')
cursor.location = setpos
cursor.rotation_euler = setrot
# -----------------------------------------------------------------------------------------
# CUBE
# -----------------------------------------------------------------------------------------
if self.boxmode:
bpy.ops.mesh.primitive_box_add(width=side,
depth=side,
height=distance,
align='WORLD',
location=setpos,
rotation=setrot)
if self.itemize or self.edit_mode == "OBJECT":
bpy.ops.object.shade_smooth()
bpy.context.object.data.use_auto_smooth = True
# -----------------------------------------------------------------------------------------
# PLANE
# -----------------------------------------------------------------------------------------
elif self.ke_fitprim_option == "PLANE":
# side *= 2
enter = True
if self.edit_mode == 'OBJECT' or self.itemize:
enter = False
bpy.ops.mesh.primitive_plane_add(enter_editmode=enter,
align='WORLD',
location=setpos,
rotation=setrot,
size=side,
scale=(1, 1, 1))
if self.itemize or self.edit_mode == "OBJECT":
bpy.ops.object.shade_smooth()
bpy.context.object.data.use_auto_smooth = True
# -----------------------------------------------------------------------------------------
# SPHERE
# -----------------------------------------------------------------------------------------
elif self.sphere and not self.ke_fitprim_option == "QUADSPHERE":
bpy.ops.mesh.primitive_uv_sphere_add(
segments=self.sphere_seg,
ring_count=self.sphere_ring,
radius=side,
align='WORLD',
location=setpos,
rotation=setrot)
if self.itemize or self.edit_mode == "OBJECT":
bpy.ops.object.shade_smooth()
bpy.context.object.data.use_auto_smooth = True
# -----------------------------------------------------------------------------------------
# QUADSPHERE
# -----------------------------------------------------------------------------------------
elif self.ke_fitprim_option == "QUADSPHERE":
cutnr = self.quadsphere_seg
# calc compensated subd radius from cube
v1_pos = setpos[0] + side, setpos[1] + side, setpos[2] + side
rad = sqrt(sum([(a - b)**2 for a, b in zip(setpos, v1_pos)]))
diff = side / rad
side = (side * diff)
distance = side
bpy.ops.mesh.primitive_box_add(width=side,
depth=side,
height=distance,
align='WORLD',
location=setpos,
rotation=setrot,
name="QuadSphere")
if self.itemize or self.edit_mode == "OBJECT":
bpy.ops.object.mode_set(mode="EDIT")
bpy.ops.mesh.subdivide(number_cuts=cutnr, smoothness=1)
bpy.ops.mesh.faces_shade_smooth()
bpy.ops.object.mode_set(mode="OBJECT")
else:
bpy.ops.mesh.subdivide(number_cuts=cutnr, smoothness=1)
bpy.ops.mesh.faces_shade_smooth()
bpy.ops.ed.undo_push()
# bpy.context.object.data.use_auto_smooth = as_check
if self.itemize or self.edit_mode == "OBJECT":
bpy.ops.object.shade_smooth()
bpy.context.object.data.use_auto_smooth = True
# -----------------------------------------------------------------------------------------
# CYLINDER
# -----------------------------------------------------------------------------------------
else:
bpy.ops.mesh.primitive_cylinder_add(vertices=self.cyl_sides,
radius=side,
depth=distance * 2,
enter_editmode=False,
align='WORLD',
location=setpos,
rotation=setrot)
if self.modal:
if self.itemize or self.edit_mode == "OBJECT":
bpy.ops.object.mode_set(mode="EDIT")
self.settings = (side, distance, setpos, setrot)
context.window_manager.modal_handler_add(self)
self._timer = context.window_manager.event_timer_add(
0.5, window=context.window)
args = (self, context, self.screen_x)
self._handle = bpy.types.SpaceView3D.draw_handler_add(
draw_callback_px, args, 'WINDOW', 'POST_PIXEL')
bpy.context.space_data.overlay.show_cursor = False
return {'RUNNING_MODAL'}
if multi_object_mode and not self.itemize:
second_obj.select_set(state=True)
obj.select_set(state=True)
bpy.ops.object.editmode_toggle()
bpy.ops.object.editmode_toggle()
else:
self.report({"INFO"},
"FitPrim: Invalid Selection / No Active Element?")
if not self.select and not self.itemize and not self.edit_mode == "OBJECT":
bpy.ops.mesh.select_all(action='DESELECT')
if self.itemize:
bpy.ops.transform.select_orientation(orientation=og_orientation)
cursor.location = self.og_cloc
cursor.rotation_euler = self.og_crot
bpy.context.active_object.select_set(state=True)
self.ke_fitprim_itemize = False
return {"FINISHED"}
def import_arc(rcurve, bcurve, scale):
'''
Parse arc data from Speckle object dictionary
'''
#plane = find_key_case_insensitive(rcurve, "plane")
plane = rcurve.plane
if not plane:
return
origin = plane.origin
normal = Vector(plane.normal.value)
#origin = find_key_case_insensitive(plane, "origin")
#normal = find_key_case_insensitive(plane, "normal")
#normal = Vector(find_key_case_insensitive(normal, "value"))
xaxis = plane.xdir
yaxis = plane.ydir
radius = rcurve.radius * scale
startAngle = rcurve.startAngle
endAngle = rcurve.endAngle
#xaxis = find_key_case_insensitive(plane, "xdir")
#yaxis = find_key_case_insensitive(plane, "ydir")
#radius = find_key_case_insensitive(rcurve, "radius", 0) * scale
#startAngle = find_key_case_insensitive(rcurve, "startAngle", 0)
#endAngle = find_key_case_insensitive(rcurve, "endAngle", 0)
startQuat = Quaternion(normal, startAngle)
endQuat = Quaternion(normal, endAngle)
'''
Get start and end vectors, centre point, angles, etc.
'''
r1 = Vector(plane.xdir.value)
r1.rotate(startQuat)
r2 = Vector(plane.xdir.value)
r2.rotate(endQuat)
c = Vector(plane.origin.value) * scale
spt = c + r1 * radius
ept = c + r2 * radius
#d = radius * (endAngle - startAngle)
angle = endAngle - startAngle
t1 = normal.cross(r1)
#t2 = normal.cross(r2)
'''
Initialize arc data and calculate subdivisions
'''
arc = bcurve.splines.new('NURBS')
arc.use_cyclic_u = False
Ndiv = max(int(math.floor(angle / 0.3)), 2)
step = angle / float(Ndiv)
stepQuat = Quaternion(normal, step)
tan = math.tan(step / 2) * radius
arc.points.add(Ndiv + 1)
'''
Set start and end points
'''
arc.points[0].co = (spt.x, spt.y, spt.z, 1)
arc.points[Ndiv + 1].co = (ept.x, ept.y, ept.z, 1)
'''
Set intermediate points
'''
for i in range(Ndiv):
t1 = normal.cross(r1)
pt = c + r1 * radius + t1 * tan
arc.points[i + 1].co = (pt.x, pt.y, pt.z, 1)
r1.rotate(stepQuat)
'''
Set curve settings
'''
arc.use_endpoint_u = True
arc.order_u = 3
return arc
def lp_left(bm, lp, wid, vm, wm):
# pass
size = len(lp)
up = wm.inverted() * vm.inverted() * Vector((0, 0, 1))
lp_off = []
faces = []
for i in range(size - 1):
if i == 0:
pt = bm.verts[lp[i]].co
pre = bm.verts[lp[-2]].co
nxt = bm.verts[lp[1]].co
pre_ind = lp[size - 2]
nxt_ind = lp[1]
else:
bm.verts.ensure_lookup_table()
pt = bm.verts[lp[i]].co
pre = bm.verts[lp[i - 1]].co
nxt = bm.verts[lp[i + 1]].co
pre_ind = lp[i - 1]
nxt_ind = lp[i + 1]
vec1 = pt - pre
vec2 = pt - nxt
mid = vec1.normalized() + vec2.normalized()
if mid.length < 10e-4:
up2 = Vector((0, 0, 1))
mid = up2.cross(vec1)
else:
xx = mid.cross(vec1).dot(up)
if xx > 0:
mid.negate()
mid.normalize()
if pre_ind == nxt_ind:
mid = (pt - pre).normalized()
q_a = mathutils.Quaternion((0.0, 0.0, 1.0), math.radians(90.0))
q_b = mathutils.Quaternion((0.0, 0.0, 1.0), math.radians(-180.0))
mid.rotate(q_a)
pt1 = pt + mid * wid
mid.rotate(q_b)
pt2 = pt + mid * wid
new_vert_1 = bm.verts.new(pt1)
new_vert_2 = bm.verts.new(pt2)
lp_off.append([new_vert_1, new_vert_2])
else:
ang = mid.angle(pre - pt)
vec_len = wid / (math.sin(ang))
# print(wid)
pt = pt + mid * vec_len
new_vert = bm.verts.new(pt)
lp_off.append(new_vert)
lp_off.append(lp_off[0])
bm.verts.index_update()
for i in range(len(lp_off) - 1):
bm.verts.ensure_lookup_table()
p1 = bm.verts[lp[i]]
p2 = bm.verts[lp[i + 1]]
p3 = lp_off[i + 1]
p4 = lp_off[i]
if isinstance(p3, list):
faces.append((p1, p2, p3[0], p4))
#faces.append((p3[0],p2,p3[1]))
elif isinstance(p4, list):
faces.append((p1, p2, p3, p4[1]))
else:
faces.append((p1, p2, p3, p4))
return faces
def execute(self, context):
automerge = False
self.used_modal = False
sel_check, place, noloc, place, dupe = False, False, False, False, False
normal, tangent, place_quat = None, None, None
mode = bpy.context.mode[:]
sel_mode = bpy.context.tool_settings.mesh_select_mode[:]
obj = bpy.context.active_object
if not obj:
self.report({"INFO"}, "Unrotator: No Active Object?")
return {"CANCELLED"}
if self.ke_unrotator_option == "DUPE":
dupe, noloc = True, False
elif self.ke_unrotator_option == "NO_LOC":
noloc, dupe = True, False
connect = bpy.context.scene.kekit.unrotator_connect
nolink = bpy.context.scene.kekit.unrotator_nolink
nosnap = bpy.context.scene.kekit.unrotator_nosnap
actual_invert = bpy.context.scene.kekit.unrotator_invert
self.center = bpy.context.scene.kekit.unrotator_center
if self.center_override:
self.center = True
# Check mouse over target -----------------------------------------------------------------------
bpy.ops.object.mode_set(mode="OBJECT")
hit_obj, hit_wloc, hit_normal, hit_face = mouse_raycast(context,
self.mouse_pos,
evaluated=True)
# print("HIT:", hit_obj, hit_face, hit_normal)
if mode == "OBJECT" and not nosnap:
self.rot_offset = 0
self.center = False
if mode == "EDIT_MESH":
bpy.ops.object.mode_set(mode="EDIT")
automerge = bool(context.scene.tool_settings.use_mesh_automerge)
if automerge:
context.scene.tool_settings.use_mesh_automerge = False
# Get selected obj bm
obj_mtx = obj.matrix_world.copy()
od = obj.data
bm = bmesh.from_edit_mesh(od)
# Check selections
sel_poly = [p for p in bm.faces if p.select]
sel_edges = [e for e in bm.edges if e.select]
sel_verts = [v for v in bm.verts if v.select]
active_h = bm.select_history.active
active_point = None
# Making sure an active element is in the selection
if sel_mode[1] and sel_edges:
if active_h not in sel_edges:
bm.select_history.add(sel_edges[-1])
active_h = bm.select_history.active
active_point = active_h.verts[0]
elif sel_mode[0] and sel_verts:
if active_h not in sel_verts:
bm.select_history.add(sel_verts[-1])
active_h = bm.select_history.active
active_point = active_h
elif sel_mode[2] and sel_poly:
if active_h not in sel_poly:
bm.select_history.add(sel_poly[-1])
active_h = bm.select_history.active
active_point = active_h.verts[0]
# Verify valid selections
if len(sel_verts) >= 3 and active_h:
if sel_mode[0]:
sel_check = True
elif sel_mode[1] and len(sel_edges) >= 2:
sel_check = True
elif sel_mode[2] and len(sel_poly):
sel_check = True
if not sel_check:
self.report({
"INFO"
}, "Unrotator: Selection Error - Incorrect/No geo Selected? Active Element?"
)
return {"CANCELLED"}
# Expand Linked, or not ------------------------------------------------------------------
if connect:
bpy.ops.mesh.select_linked()
linked_verts = [v for v in bm.verts if v.select]
elif not connect:
linked_verts = sel_verts # fall-back
# still calc the linked avg pos
islands = get_islands(bm, sel_verts)
for island in islands:
if any(v in sel_verts for v in island):
linked_verts = island
break
# Linked Selection center pos
bm.verts.ensure_lookup_table()
linked_verts_co = [v.co for v in linked_verts]
avg_pos = obj_mtx @ Vector(average_vector(linked_verts_co))
sel_cos = [v.co for v in sel_verts]
avg_sel_pos = obj_mtx @ Vector(average_vector(sel_cos))
center_d = Vector(avg_sel_pos - avg_pos).normalized()
# bmdupe
if dupe:
bmesh.ops.duplicate(bm,
geom=([v for v in bm.verts if v.select] +
[e for e in bm.edges if e.select] +
[p for p in bm.faces if p.select]))
# -----------------------------------------------------------------------------------------
# Check mouse over target - place check
# -----------------------------------------------------------------------------------------
if type(hit_face) == int:
if hit_obj.name == obj.name:
bm.faces.ensure_lookup_table()
hit_face_verts = bm.faces[hit_face].verts[:]
if any(i in hit_face_verts for i in linked_verts):
# print("Mouse over same Obj and selected geo - Unrotate only mode")
place = False
else:
# print("Mouse over same Obj but unselected geo - Unrotate & Place in same mesh mode")
place = True
n, t = self.calc_face_vectors(bm.faces[hit_face],
obj_mtx, obj,
len(hit_face_verts))
n.negate()
place_quat = rotation_from_vector(n, t).to_quaternion()
if self.center:
bm.faces.ensure_lookup_table()
hit_wloc = average_vector(
[obj_mtx @ v.co for v in hit_face_verts])
elif hit_obj.name != obj.name:
# print("Mouse over different Object - Unrotate & Place mode")
place = True
hit_face_verts = hit_obj.data.polygons[
hit_face].vertices[:]
n, t = self.calc_face_vectors(
hit_obj.data.polygons[hit_face], hit_obj.matrix_world,
hit_obj, len(hit_face_verts))
n.negate()
place_quat = rotation_from_vector(n, t).to_quaternion()
if self.center:
hit_vcos = [
hit_obj.matrix_world @ hit_obj.data.vertices[i].co
for i in hit_face_verts
]
hit_wloc = average_vector(hit_vcos)
# -----------------------------------------------------------------------------------------
# Selection processing for normal and tangent vecs
# -----------------------------------------------------------------------------------------
if sel_mode[0]:
# VERT MODE ---------------------------------------------------------------------------
h = tri_points_order(
[sel_verts[0].co, sel_verts[1].co, sel_verts[2].co])
# Vectors from 3 points, hypoT ignored
p1, p2, p3 = obj_mtx @ sel_verts[h[0]].co, obj_mtx @ sel_verts[
h[1]].co, obj_mtx @ sel_verts[h[2]].co
v2 = p3 - p1
v1 = p2 - p1
normal = v1.cross(v2).normalized()
tangent = Vector(v1).normalized()
# Direction flip check against center mass
d = normal.dot(center_d)
if d <= 0:
normal.negate()
elif sel_mode[1]:
# EDGE MODE ---------------------------------------------------------------------------
bm.edges.ensure_lookup_table()
# Active edge is tangent
ev = active_h.verts[:]
ev1, ev2 = ev[0].co, ev[1].co
tangent = correct_normal(obj_mtx,
Vector((ev1 - ev2)).normalized())
# B-tangent is shortest vec to v1
c = [v for v in sel_verts if v not in ev]
vecs = [Vector((ev1 - v.co).normalized()) for v in c]
v2 = correct_normal(obj_mtx, sorted(vecs)[0])
# Normal is crossp
normal = tangent.cross(v2).normalized()
# Direction flip check against center mass
d = normal.dot(center_d)
if d <= 0:
normal.negate()
elif sel_mode[2]:
# POLY MODE ---------------------------------------------------------------------------
normal, tangent = self.calc_face_vectors(
active_h, obj_mtx, obj, len(sel_verts))
# -----------------------------------------------------------------------------------------
# Process & Execute transforms!
# -----------------------------------------------------------------------------------------
if actual_invert:
normal.negate()
if self.inv:
normal.negate()
rotm = rotation_from_vector(normal, tangent)
rq = rotm.to_quaternion()
if self.rot_offset != 0:
rq @= Quaternion((0, 0, 1), self.rot_offset)
if place_quat is not None:
qd = place_quat @ rq.inverted()
else:
# rot to place at bottom
rq @= Quaternion((1, 0, 0), radians(-180.0))
qd = rq.rotation_difference(Quaternion())
rot = qd.to_euler("XYZ")
rx, ry, rz = rot.x * -1, rot.y * -1, rot.z * -1
# Old macro method to avoid non-uniform scale issues...slow, but works.
bpy.ops.transform.rotate(value=rx,
orient_axis='X',
orient_type='GLOBAL',
use_proportional_edit=False,
snap=False,
orient_matrix_type='GLOBAL')
bpy.ops.transform.rotate(value=ry,
orient_axis='Y',
orient_type='GLOBAL',
use_proportional_edit=False,
snap=False,
orient_matrix_type='GLOBAL')
bpy.ops.transform.rotate(value=rz,
orient_axis='Z',
orient_type='GLOBAL',
use_proportional_edit=False,
snap=False,
orient_matrix_type='GLOBAL')
# Calc offset
nv = [v.co for v in linked_verts]
npos = obj_mtx @ Vector(average_vector(nv))
if place and not noloc:
# Move & offset placement
d = distance_point_to_plane(obj_mtx @ active_point.co, npos,
hit_normal)
offset = hit_normal * d
hit_vec = hit_wloc - (npos + offset)
bmesh.ops.translate(bm,
vec=hit_vec,
space=obj_mtx,
verts=linked_verts)
bmesh.update_edit_mesh(obj.data)
else:
# Compensate z pos to rot-in-place-ish
comp = (npos - avg_pos) * -1
bpy.ops.transform.translate(value=comp)
bmesh.update_edit_mesh(obj.data)
elif mode == 'OBJECT':
# Unrotate only
if not hit_obj:
obj.select_set(True)
obj.rotation_euler = (0, 0, self.rot_offset)
elif hit_obj.name == obj.name:
obj.select_set(True)
obj.rotation_euler = (0, 0, self.rot_offset)
# Place!
elif hit_obj.name != obj.name:
obj.select_set(True)
self.og_pos = Vector(obj.location)
if dupe:
if nolink:
bpy.ops.object.duplicate(linked=False)
else:
bpy.ops.object.duplicate(linked=True)
obj = bpy.context.active_object
obj.select_set(True)
mtx = hit_obj.matrix_world
eks = hit_obj.data.polygons[hit_face].edge_keys
vecs = []
for vp in eks:
vc1 = mtx @ hit_obj.data.vertices[vp[0]].co
vc2 = mtx @ hit_obj.data.vertices[vp[1]].co
vecs.append(vc1 - vc2)
short_sort = sorted(vecs)
start_vec = short_sort[0]
self.setrot = rotation_from_vector(hit_normal,
start_vec,
rotate90=True,
rw=True).to_quaternion()
self.setrot @= Quaternion((0, 0, 1), self.rot_offset)
if noloc or nosnap:
obj.rotation_euler = self.setrot.to_euler()
if not noloc:
if self.center and nosnap:
hit_wloc = hit_obj.matrix_world @ Vector(
hit_obj.data.polygons[hit_face].center)
obj.location = hit_wloc
# no snapping place only
obj.location = hit_wloc
if not nosnap:
obj.rotation_euler = self.setrot.to_euler()
self.f_center = hit_obj.matrix_world @ Vector(
hit_obj.data.polygons[hit_face].center)
self.used_modal = True
self.og_snaps = self.get_snap_settings(context)
self.set_snap_settings(context, self.modal_snap)
context.window_manager.modal_handler_add(self)
bpy.ops.transform.translate('INVOKE_DEFAULT')
return {'RUNNING_MODAL'}
# Selection revert for non-face selections
if not sel_mode[2] and mode != "OBJECT":
bpy.ops.mesh.select_all(action='DESELECT')
if sel_mode[1]:
bm.edges.ensure_lookup_table()
for v in sel_edges:
bm.edges[v.index].select = True
elif sel_mode[0]:
bm.verts.ensure_lookup_table()
for v in sel_verts:
bm.verts[v.index].select = True
bm.select_history.clear()
bm.select_history.add(active_h)
bmesh.update_edit_mesh(obj.data)
if automerge:
context.scene.tool_settings.use_mesh_automerge = True
return {"FINISHED"}
class Turtle:
def __init__( self,
tropism=(0,0,0),
tropismsize=0,
angle=radians(30),
iseed=42 ):
self.tropism = Vector(tropism).normalized()
self.magnitude = tropismsize
self.forward = Vector((1,0,0))
self.up = Vector((0,0,1))
self.right = self.forward.cross(self.up)
self.stack = []
self.position = Vector((0,0,0))
self.angle = angle
self.radius = 0.1
self.__init_terminals()
seed(iseed)
def __init_terminals(self):
"""
Initialize a map of predefined terminals.
"""
self.terminals = {
'+': self.term_plus,
'-': self.term_minus,
'[': self.term_push,
']': self.term_pop,
'/': self.term_slash,
'\\': self.term_backslash,
'<': self.term_less,
'>': self.term_greater,
'&': self.term_amp,
'!': self.term_expand,
'@': self.term_shrink,
'#': self.term_fatten,
'%': self.term_slink,
'F': self.term_edge,
'Q': self.term_quad,
# '{': self.term_object
}
def apply_tropism(self):
# tropism is a normalized vector
t = self.tropism * self.magnitude
tf=self.forward + t
tf.normalize()
q = tf.rotation_difference(self.forward)
self.forward.rotate(q)
self.up.rotate(q)
self.right.rotate(q)
def term_plus(self, value=None):
val = radians(value) if not value is None else self.angle
r = Matrix.Rotation(val, 4, self.right)
self.forward.rotate(r)
self.up.rotate(r)
def term_minus(self, value=None):
val = radians(value) if not value is None else self.angle
r = Matrix.Rotation(-val, 4, self.right)
self.forward.rotate(r)
self.up.rotate(r)
def term_amp(self, value=30):
k = (random()-0.5) * value
self.term_plus(value=k)
k = (random()-0.5) * value
self.term_slash(value=k)
def term_slash(self, value=None):
r = Matrix.Rotation(radians(value) if not value is None
else self.angle, 4, self.up)
self.forward.rotate(r)
self.right.rotate(r)
def term_backslash(self, value=None):
r = Matrix.Rotation(-radians(value) if not value is None
else -self.angle, 4, self.up)
self.forward.rotate(r)
self.right.rotate(r)
def term_less(self, value=None):
r = Matrix.Rotation(radians(value) if not value is None
else self.angle, 4, self.forward)
self.up.rotate(r)
self.right.rotate(r)
def term_greater(self, value=None):
r = Matrix.Rotation(-radians(value) if not value is None
else -self.angle, 4, self.forward)
self.up.rotate(r)
self.right.rotate(r)
def term_pop(self, value=None):
t = self.stack.pop()
( self.forward,
self.up,
self.right,
self.position,
self.radius ) = t
def term_push(self, value=None):
t = ( self.forward.copy(),
self.up.copy(),
self.right.copy(),
self.position.copy(),
self.radius )
self.stack.append(t)
def term_expand(self, value=1.1):
self.forward *= value
self.up *= value
self.right *= value
def term_shrink(self, value=0.9):
self.forward *= value
self.up *= value
self.right *= value
def term_fatten(self, value=1.1):
self.radius *= value
def term_slink(self, value=0.9):
self.radius *= value
def term_edge(self, value=None):
s = self.position.copy()
self.apply_tropism()
self.position += self.forward
e = self.position.copy()
return Edge(start=s, end=e, radius=self.radius)
def term_quad(self, value=0.5):
return Quad(pos=self.position,
right=self.right,
up=self.up,
forward=self.forward )
def term_object(self, value=None, name=None):
s = self.position.copy()
self.apply_tropism()
self.position += self.forward
return BObject(name=name,
pos=s,
right=self.right,
up=self.up,
forward=self.forward )
def interpret(self, s):
"""
interpret the iterable s, yield Quad, Edge or Object named tuples.
"""
print('interpret:',s)
name=''
for c in s:
t = None
print(c,name)
if c == '}':
t = self.term_object(name=name[1:])
name=''
elif c == '{' or name != '':
name += c
continue
elif name != '':
continue
elif c in self.terminals:
t = self.terminals[c]()
print('yield',t)
if not t is None:
yield t
def execute(self, context):
if self.ke_fitprim_option == "BOX":
self.boxmode, self.world = True, False
elif self.ke_fitprim_option == "CYL":
self.boxmode, self.world = False, False
elif self.ke_fitprim_option == "SPHERE":
self.boxmode, self.world, self.sphere = False, False, True
elif self.ke_fitprim_option == "QUADSPHERE":
self.boxmode, self.world, self.sphere = False, False, True
if bpy.context.scene.kekit.fitprim_item:
self.itemize = True
else:
self.itemize = self.ke_fitprim_itemize
self.modal = bpy.context.scene.kekit.fitprim_modal
self.cyl_sides = bpy.context.scene.kekit.fitprim_sides
self.select = bpy.context.scene.kekit.fitprim_select
self.unit = bpy.context.scene.kekit.fitprim_unit
self.sphere_ring = bpy.context.scene.kekit.fitprim_sphere_ring
self.sphere_seg = bpy.context.scene.kekit.fitprim_sphere_seg
self.quadsphere_seg = bpy.context.scene.kekit.fitprim_quadsphere_seg
self.edit_mode = bpy.context.mode
sel_verts = []
multi_object_mode = False
# -----------------------------------------------------------------------------------------
# MULTI OBJECT CHECK & SETUP
# -----------------------------------------------------------------------------------------
if self.edit_mode == "EDIT_MESH":
sel_mode = [b for b in bpy.context.tool_settings.mesh_select_mode]
multi_object_mode = False
other_side = []
sel_obj = [
o for o in bpy.context.objects_in_mode if o.type == "MESH"
]
if len(sel_obj) == 2:
multi_object_mode = True
obj = bpy.context.active_object
if multi_object_mode:
second_obj = [o for o in sel_obj if o != obj][0]
bm2 = bmesh.from_edit_mesh(second_obj.data)
obj_mtx2 = second_obj.matrix_world.copy()
# selection double check - just to get some manual selection control w. 2nd active face
sel_poly2 = [p for p in bm2.faces if p.select]
if sel_poly2:
active_face2 = bm2.faces.active
if active_face2 not in sel_poly2:
active_face2 = None
if active_face2:
sel_verts2 = active_face2.verts
else:
sel_verts2 = sel_poly2[0].verts
else:
sel_verts2 = [v for v in bm2.verts if v.select]
if not sel_verts2:
multi_object_mode = False
elif sel_mode[0]:
# Just for 2-vert mode in multiobj mode
ole = sel_verts2[0].link_edges[:]
other_side = get_shortest(obj_mtx2, ole)
obj_mtx = obj.matrix_world.copy()
bm = bmesh.from_edit_mesh(obj.data)
bm.faces.ensure_lookup_table()
bm.verts.ensure_lookup_table()
sel_verts = [v for v in bm.verts if v.select]
if sel_mode[2]:
sel_poly = [p for p in bm.faces if p.select]
active_face = bm.faces.active
if active_face not in sel_poly:
active_face = None
side = None
distance = 0
vps = []
normal, setpos, setrot, center = None, None, None, None
first_island = None
island_mode = False
# -----------------------------------------------------------------------------------------
# NO SELECTION MODE
# -----------------------------------------------------------------------------------------
if not sel_verts or self.edit_mode == "OBJECT":
self.world = True
screenpos = region_2d_to_location_3d(context.region,
context.space_data.region_3d,
self.mouse_pos, (0, 0, 0))
setpos = screenpos
side = self.unit
distance = side
sel_mode = (True, False, False)
# -----------------------------------------------------------------------------------------
# VERT MODE(s)
# -----------------------------------------------------------------------------------------
elif sel_mode[0] and len(sel_verts) == 1 and not multi_object_mode:
# 1-VERT MODE
self.world = True
side = get_shortest(obj_mtx, sel_verts[0].link_edges[:])
distance = side
setpos = obj_mtx @ sel_verts[0].co
elif sel_mode[0]:
# 2+ Vert mode
if multi_object_mode:
p1 = obj_mtx @ sel_verts[0].co
p2 = obj_mtx2 @ sel_verts2[0].co
side = [other_side]
con_edges = sel_verts[0].link_edges[:]
side.append(get_shortest(obj_mtx, con_edges))
side = sorted(side)[0]
else:
p1 = obj_mtx @ sel_verts[0].co
p2 = obj_mtx @ sel_verts[1].co
con_edges = sel_verts[0].link_edges[:] + sel_verts[
1].link_edges[:]
side = get_shortest(obj_mtx, con_edges)
v_1 = p1 - p2
v_2 = Vector((0, 0, 1))
if v_1.dot(v_2) < 0:
v_2 = Vector((1, 0, 0))
n_v = v_1.cross(v_2).normalized()
u_v = n_v.cross(v_1).normalized()
t_v = u_v.cross(n_v).normalized()
setrot = Matrix((u_v, n_v, t_v)).to_4x4().inverted()
distance = get_distance(p1, p2)
setpos = Vector(get_midpoint(p1, p2))
# -----------------------------------------------------------------------------------------
# EDGE MODE
# -----------------------------------------------------------------------------------------
elif sel_mode[1]:
one_line, loops, loops2 = False, [], []
sel_edges = [e for e in bm.edges if e.select]
vps = [e.verts for e in sel_edges]
active_edge = bm.select_history.active
if active_edge:
active_edge_facenormals = [
correct_normal(obj_mtx, p.normal)
for p in active_edge.link_faces
]
active_edge_normal = Vector(
average_vector(active_edge_facenormals)).normalized()
# GET ISLANDS
if multi_object_mode and active_edge:
# print("multi obj mode") # todo: limited multiobj mode, rework one-for-all?
sel_edges2 = [e for e in bm2.edges if e.select]
vps2 = [e.verts for e in sel_edges2]
p1 = get_loops(vps, legacy=True)
p2 = get_loops(vps2, legacy=True)
if p1 and p2:
a1, a2 = obj_mtx @ p1[0][0].co, obj_mtx @ p1[0][-1].co
b1, b2 = obj_mtx2 @ p2[0][0].co, obj_mtx2 @ p2[0][-1].co
else:
a1, a2 = obj_mtx @ sel_verts[0].co, obj_mtx @ sel_verts[
-1].co
b1, b2 = obj_mtx2 @ sel_verts2[
0].co, obj_mtx2 @ sel_verts2[-1].co
b_avg = get_midpoint(b1, b2)
spacing, mp = get_closest_midpoint(a1, a2, b_avg)
u_v = Vector(a1 - b1).normalized()
t_v = Vector(a1 - a2).normalized()
n_v = u_v.cross(t_v).normalized()
setrot = rotation_from_vector(n_v, t_v, rotate90=True)
setpos = mp
side = spacing
distance = spacing
elif active_edge: # same (active) obj island selections
if len(sel_edges) > 1:
if len(sel_edges) == 2 and not bool(
set(sel_edges[0].verts).intersection(
sel_edges[1].verts)):
a1p, a2p = sel_edges[0].verts, sel_edges[1].verts
a1, a2 = obj_mtx @ a1p[0].co, obj_mtx @ a1p[1].co
# b1, b2 = obj_mtx @ a2p[0].co, obj_mtx @ a2p[1].co
b_avg = average_vector(
[obj_mtx @ a2p[0].co, obj_mtx @ a2p[1].co])
u_v = Vector(a1 - (obj_mtx @ a2p[0].co)).normalized()
t_v = Vector(a1 - a2).normalized()
n_v = u_v.cross(t_v).normalized()
setrot = rotation_from_vector(n_v, t_v, rotate90=True)
spacing, mp = get_closest_midpoint(a1, a2, b_avg)
setpos = mp
side = spacing
distance = spacing
else:
loops = get_loops(vps, legacy=True)
if len(loops) > 1:
# print ("single obj - multi loop", len(loops))
# Check for closed loops
a_ep1, a_ep2 = loops[0][0], loops[0][-1]
b_ep1, b_ep2 = loops[1][0], loops[1][-1]
if a_ep1 == a_ep2:
a_ep2 = loops[0][-2]
if b_ep1 == b_ep2:
b_ep2 = loops[1][-2]
# get coords & set vals
a1, a2 = obj_mtx @ a_ep1.co, obj_mtx @ a_ep2.co
b1, b2 = obj_mtx @ b_ep1.co, obj_mtx @ b_ep2.co
b_avg = get_midpoint(b1, b2)
spacing, mp = get_closest_midpoint(a1, a2, b_avg)
u_v = Vector((0, 0, 1))
t_v = Vector(a1 - a2).normalized()
if u_v.dot(t_v) > 0:
u_v = Vector((1, 0, 0))
n_v = u_v.cross(t_v).normalized()
setrot = rotation_from_vector(n_v, t_v, rotate90=False)
setpos = mp
side = spacing
distance = spacing
elif len(loops) == 1 or len(sel_edges) == 1:
# print ("single obj - single loop")
vecs = [(obj_mtx @ vp[0].co) - (obj_mtx @ vp[1].co)
for vp in vps]
start_vec = vecs[-1]
side, sides, center = get_sides(obj_mtx, start_vec, vecs,
vps)
# if len(sel_edges) == 4:
# print("FIX")
# ONE LINE (ONE EDGE or SINGLE STRAIGHT LINE) MODE------------------------------
if len(sides) == 1 and len(sides[0]) == len(sel_verts):
# print("1 side --> one line:", sides[0])
one_line = sides[0][0], sides[0][-1]
elif len(sel_edges) == 1:
# print("1 edge --> one line", one_line)
one_line = sel_verts
if one_line:
# print ("one line. center, points, normal:", center, one_line, active_edge_normal)
p1, p2 = obj_mtx @ one_line[0].co, obj_mtx @ one_line[
1].co
t_v = Vector(p1 - p2).normalized()
n_v = active_edge_normal
setrot = rotation_from_vector(n_v, t_v)
distance = get_distance(p1, p2)
setpos = get_midpoint(p1, p2)
side = distance
else:
# RECT CHECK SIDES OR NGON MODE--------------------------------------------
# print("Edge Rect/Ngon mode. Sides:", len(sides))
b_candidate = sides[0][0].link_edges
b_candidate = [e.verts for e in b_candidate]
b = [
v for vp in b_candidate for v in vp
if v not in sides[0] and v in sel_verts
]
if b:
b = obj_mtx @ b[0].co
a = obj_mtx @ sides[0][0].co - obj_mtx @ sides[0][
1].co
b = obj_mtx @ sides[0][0].co - b
t_v = Vector(a).normalized()
u_v = Vector(b).normalized()
n_v = u_v.cross(t_v).normalized()
setrot = rotation_from_vector(n_v,
t_v,
rotate90=True)
distance = side
setpos = center
else:
side = None
# -----------------------------------------------------------------------------------------
# FACE MODE
# -----------------------------------------------------------------------------------------
elif sel_mode[2] and active_face and sel_poly:
# GET ISLANDS
if multi_object_mode and active_face:
first_island = sel_verts
point = obj_mtx @ active_face.calc_center_median()
firstcos = [obj_mtx @ v.co for v in sel_verts]
secondcos = [obj_mtx2 @ v.co for v in sel_verts2]
if firstcos and secondcos:
island_mode = True
distance = point_to_plane(point, firstcos, secondcos)
if distance:
distance = abs(distance)
else:
# print("Multi obj Point to plane failed for some reason - using single island mode.")
island_mode = False
else: # same (active) obj island selections
first_island, second_island = get_selection_islands(
sel_poly, active_face)
if len(first_island) != 0 and len(second_island) != 0:
firstcos = [obj_mtx @ v.co
for v in first_island] # needs order sort
secondcos = [obj_mtx @ v.co for v in second_island]
distance = point_to_plane(
obj_mtx @ active_face.calc_center_median(), firstcos,
secondcos)
if distance:
distance = abs(distance)
island_mode = True
else:
# print("Point to plane failed for some reason - using single island mode.")
island_mode = False
else:
# Ngon mode
first_island = sel_verts
# GET PRIMARY SELECTION VALUES
ngoncheck = len(active_face.verts)
if sel_mode[2] and len(sel_verts) < 4:
ngoncheck = 5 # todo: better solution for tris...
bpy.ops.mesh.select_all(action='DESELECT')
for v in first_island:
bm.verts[v.index].select = True
bmesh.update_edit_mesh(obj.data, True)
bpy.ops.mesh.select_mode(type='VERT')
bpy.ops.mesh.select_mode(type='FACE')
bm.faces.ensure_lookup_table()
# sel_poly = [p for p in bm.faces if p.select]
bpy.ops.mesh.region_to_loop()
sel_edges = [e for e in bm.edges if e.select]
vps = [e.verts for e in sel_edges]
vecs = [(obj_mtx @ vp[0].co) - (obj_mtx @ vp[1].co) for vp in vps]
normal = correct_normal(obj_mtx, active_face.normal)
start_vec = vecs[-1]
setrot = rotation_from_vector(normal, start_vec)
# print("Rectangle or Ngon mode",ngoncheck)
if ngoncheck <= 4:
side, sides, center = get_sides(obj_mtx,
start_vec,
vecs,
vps,
legacy=False)
else:
side, sides, center = get_sides(obj_mtx,
start_vec,
vecs,
vps,
legacy=True)
# -----------------------------------------------------------------------------------------
# PROCESS
# -----------------------------------------------------------------------------------------
if side:
if len(sel_verts) == 0 or sel_mode[0] or sel_mode[1]:
side *= .5
distance = distance / 2
if self.sphere and sel_mode[0]:
if not len(sel_verts) == 0:
side = distance
elif sel_mode[2]:
if island_mode:
side *= .5
offset = normal * distance * .5
distance *= .5
if self.sphere:
side = distance
else:
side *= .5
distance = side
offset = normal * side
setpos = center + offset
if not island_mode and self.sphere:
setpos = setpos - offset
# SET FINAL ROTATION
if self.world:
setrot = (0, 0, 0)
else:
setrot = setrot.to_euler()
# RUN OP
if not self.edit_mode == "OBJECT":
bpy.ops.mesh.select_mode(type='FACE')
if self.itemize:
bpy.ops.object.mode_set(mode="OBJECT")
cursor = bpy.context.scene.cursor
bpy.ops.transform.select_orientation(orientation='GLOBAL')
cursor.location = setpos
cursor.rotation_euler = setrot
if self.boxmode:
bpy.ops.mesh.primitive_box_add(width=side,
depth=side,
height=distance,
align='WORLD',
location=setpos,
rotation=setrot)
if self.itemize or self.edit_mode == "OBJECT":
bpy.ops.object.shade_smooth()
bpy.context.object.data.use_auto_smooth = True
elif self.sphere and not self.ke_fitprim_option == "QUADSPHERE":
bpy.ops.mesh.primitive_uv_sphere_add(
segments=self.sphere_seg,
ring_count=self.sphere_ring,
radius=side,
align='WORLD',
location=setpos,
rotation=setrot)
if self.itemize or self.edit_mode == "OBJECT":
bpy.ops.object.shade_smooth()
bpy.context.object.data.use_auto_smooth = True
elif self.ke_fitprim_option == "QUADSPHERE":
bpy.ops.mesh.primitive_round_cube_add(
align='WORLD',
location=setpos,
rotation=setrot,
radius=side,
size=(0, 0, 0),
arc_div=self.quadsphere_seg,
lin_div=0,
div_type='CORNERS')
if self.itemize or self.edit_mode == "OBJECT":
bpy.ops.object.shade_smooth()
bpy.context.object.data.use_auto_smooth = True
else:
bpy.ops.mesh.primitive_cylinder_add(vertices=self.cyl_sides,
radius=side,
depth=distance * 2,
enter_editmode=False,
align='WORLD',
location=setpos,
rotation=setrot)
if self.modal:
if self.itemize or self.edit_mode == "OBJECT":
bpy.ops.object.mode_set(mode="EDIT")
self.settings = (side, distance, setpos, setrot)
context.window_manager.modal_handler_add(self)
args = (self, context, self.screen_x)
self._handle = bpy.types.SpaceView3D.draw_handler_add(
draw_callback_px, args, 'WINDOW', 'POST_PIXEL')
bpy.context.space_data.overlay.show_cursor = False
return {'RUNNING_MODAL'}
if multi_object_mode and not self.itemize:
second_obj.select_set(state=True)
obj.select_set(state=True)
bpy.ops.object.editmode_toggle()
bpy.ops.object.editmode_toggle()
else:
self.report({
"INFO"
}, "FitPrim: Incorrect Selection? / Edit Mode? / No Active Element?"
)
if not self.select and not self.itemize and not self.edit_mode == "OBJECT":
bpy.ops.mesh.select_all(action='DESELECT')
if self.itemize:
bpy.ops.view3d.snap_cursor_to_center()
bpy.context.active_object.select_set(state=True)
self.ke_fitprim_itemize = False
return {"FINISHED"}
def calvn(pas, alfa, ray, vn):
vr = Vector((cos(alfa), sin(alfa), 0.0))
vt = Vector((-ray * sin(alfa), ray * cos(alfa), pas))
vn = vr.cross(vt)
vn.normalize()
return vn
class Line3d(Line):
"""
3d Line
mostly a gl enabled for future use in manipulators
coords are in world space
"""
def __init__(self, p=None, v=None, p0=None, p1=None, z_axis=None):
"""
Init by either
p: Vector or tuple origin
v: Vector or tuple size and direction
or
p0: Vector or tuple 1 point location
p1: Vector or tuple 2 point location
Will convert any into Vector 3d
both optionnals
"""
if p is not None and v is not None:
self.p = Vector(p).to_3d()
self.v = Vector(v).to_3d()
elif p0 is not None and p1 is not None:
self.p = Vector(p0).to_3d()
self.v = Vector(p1).to_3d() - self.p
else:
self.p = Vector((0, 0, 0))
self.v = Vector((0, 0, 0))
if z_axis is not None:
self.z_axis = z_axis
else:
self.z_axis = Vector((0, 0, 1))
@property
def p0(self):
return self.p
@property
def p1(self):
return self.p + self.v
@p0.setter
def p0(self, p0):
"""
Note: setting p0
move p0 only
"""
p1 = self.p1
self.p = Vector(p0).to_3d()
self.v = p1 - p0
@p1.setter
def p1(self, p1):
"""
Note: setting p1
move p1 only
"""
self.v = Vector(p1).to_3d() - self.p
@property
def cross_z(self):
"""
3d Vector perpendicular on plane xy
lie on the right side
p1
|--x
p0
"""
return self.v.cross(Vector((0, 0, 1)))
@property
def cross(self):
"""
3d Vector perpendicular on plane defined by z_axis
lie on the right side
p1
|--x
p0
"""
return self.v.cross(self.z_axis)
def normal(self, t=0):
"""
3d Vector perpendicular on plane defined by z_axis
lie on the right side
p1
|--x
p0
"""
n = Line3d()
n.p = self.lerp(t)
n.v = self.cross
return n
def sized_normal(self, t, size):
"""
3d Line perpendicular on plane defined by z_axis and of given size
positionned at t in current line
lie on the right side
p1
|--x
p0
"""
p = self.lerp(t)
v = size * self.cross.normalized()
return Line3d(p, v, z_axis=self.z_axis)
def offset(self, offset):
"""
offset > 0 on the right part
"""
return Line3d(self.p + offset * self.cross.normalized(), self.v)
# unless override, 2d methods should raise NotImplementedError
def intersect(self, line):
raise NotImplementedError
def point_sur_segment(self, pt):
raise NotImplementedError
def tangeant(self, t, da, radius):
raise NotImplementedError
def camera_light_source(use_camera, use_light, object_center_vec, object_size):
camera_factor = 15.0
# If chosen a camera is put into the scene.
if use_camera == True:
# Assume that the object is put into the global origin. Then, the
# camera is moved in x and z direction, not in y. The object has its
# size at distance sqrt(object_size) from the origin. So, move the
# camera by this distance times a factor of camera_factor in x and z.
# Then add x, y and z of the origin of the object.
object_camera_vec = Vector((sqrt(object_size) * camera_factor, 0.0,
sqrt(object_size) * camera_factor))
camera_xyz_vec = object_center_vec + object_camera_vec
# Create the camera
camera_data = bpy.data.cameras.new("A_camera")
camera_data.lens = 45
camera_data.clip_end = 500.0
camera = bpy.data.objects.new("A_camera", camera_data)
camera.location = camera_xyz_vec
bpy.context.collection.objects.link(camera)
# Here the camera is rotated such it looks towards the center of
# the object. The [0.0, 0.0, 1.0] vector along the z axis
z_axis_vec = Vector((0.0, 0.0, 1.0))
# The angle between the last two vectors
angle = object_camera_vec.angle(z_axis_vec, 0)
# The cross-product of z_axis_vec and object_camera_vec
axis_vec = z_axis_vec.cross(object_camera_vec)
# Rotate 'axis_vec' by 'angle' and convert this to euler parameters.
# 4 is the size of the matrix.
camera.rotation_euler = Matrix.Rotation(angle, 4, axis_vec).to_euler()
# Rotate the camera around its axis by 90° such that we have a nice
# camera position and view onto the object.
bpy.ops.object.select_all(action='DESELECT')
camera.select_set(True)
# Rotate the camera around its axis 'object_camera_vec' by 90° such
# that we have a nice camera view onto the object.
matrix_rotation = Matrix.Rotation(90 / 360 * 2 * pi, 4,
object_camera_vec)
rotate_object(matrix_rotation, camera)
# Here a lamp is put into the scene, if chosen.
if use_light == True:
# This is the distance from the object measured in terms of %
# of the camera distance. It is set onto 50% (1/2) distance.
light_dl = sqrt(object_size) * 15 * 0.5
# This is a factor to which extend the lamp shall go to the right
# (from the camera point of view).
light_dy_right = light_dl * (3.0 / 4.0)
# Create x, y and z for the lamp.
object_light_vec = Vector((light_dl, light_dy_right, light_dl))
light_xyz_vec = object_center_vec + object_light_vec
# Create the lamp
light_data = bpy.data.lights.new(name="A_light", type="SUN")
light_data.distance = 500.0
light_data.energy = 3.0
lamp = bpy.data.objects.new("A_light", light_data)
lamp.location = light_xyz_vec
bpy.context.collection.objects.link(lamp)
# Some settings for the World: a bit ambient occlusion
bpy.context.scene.world.light_settings.use_ambient_occlusion = True
bpy.context.scene.world.light_settings.ao_factor = 0.2
# Some properties for cycles
lamp.data.use_nodes = True
lmp_P_BSDF = lamp.data.node_tree.nodes['Emission']
lmp_P_BSDF.inputs['Strength'].default_value = 5
def get_axes(mmd_local_axis_x, mmd_local_axis_z):
x_axis = Vector(mmd_local_axis_x).normalized().xzy
z_axis = Vector(mmd_local_axis_z).normalized().xzy
y_axis = z_axis.cross(x_axis).normalized()
z_axis = x_axis.cross(y_axis).normalized() # correction
return (x_axis, y_axis, z_axis)
def extract_primitives(glTF, blender_mesh, blender_vertex_groups, modifiers,
export_settings):
"""
Extract primitives from a mesh. Polygons are triangulated and sorted by material.
Furthermore, primitives are split up, if the indices range is exceeded.
Finally, triangles are also split up/duplicated, if face normals are used instead of vertex normals.
"""
print_console('INFO', 'Extracting primitive: ' + blender_mesh.name)
use_tangents = False
if blender_mesh.uv_layers.active and len(blender_mesh.uv_layers) > 0:
try:
blender_mesh.calc_tangents()
use_tangents = True
except Exception:
print_console(
'WARNING',
'Could not calculate tangents. Please try to triangulate the mesh first.'
)
#
material_map = {}
#
# Gathering position, normal and tex_coords.
#
no_material_attributes = {POSITION_ATTRIBUTE: [], NORMAL_ATTRIBUTE: []}
if use_tangents:
no_material_attributes[TANGENT_ATTRIBUTE] = []
#
# Directory of materials with its primitive.
#
no_material_primitives = {
MATERIAL_ID: '',
INDICES_ID: [],
ATTRIBUTES_ID: no_material_attributes
}
material_name_to_primitives = {'': no_material_primitives}
#
vertex_index_to_new_indices = {}
material_map[''] = vertex_index_to_new_indices
#
# Create primitive for each material.
#
for blender_material in blender_mesh.materials:
if blender_material is None:
continue
attributes = {POSITION_ATTRIBUTE: [], NORMAL_ATTRIBUTE: []}
if use_tangents:
attributes[TANGENT_ATTRIBUTE] = []
primitive = {
MATERIAL_ID: blender_material.name,
INDICES_ID: [],
ATTRIBUTES_ID: attributes
}
material_name_to_primitives[blender_material.name] = primitive
#
vertex_index_to_new_indices = {}
material_map[blender_material.name] = vertex_index_to_new_indices
tex_coord_max = 0
if blender_mesh.uv_layers.active:
tex_coord_max = len(blender_mesh.uv_layers)
#
vertex_colors = {}
color_index = 0
for vertex_color in blender_mesh.vertex_colors:
vertex_color_name = COLOR_PREFIX + str(color_index)
vertex_colors[vertex_color_name] = vertex_color
color_index += 1
if color_index >= GLTF_MAX_COLORS:
break
color_max = color_index
#
bone_max = 0
for blender_polygon in blender_mesh.polygons:
for loop_index in blender_polygon.loop_indices:
vertex_index = blender_mesh.loops[loop_index].vertex_index
bones_count = len(blender_mesh.vertices[vertex_index].groups)
if bones_count > 0:
if bones_count % 4 == 0:
bones_count -= 1
bone_max = max(bone_max, bones_count // 4 + 1)
#
morph_max = 0
blender_shape_keys = []
if blender_mesh.shape_keys is not None:
morph_max = len(blender_mesh.shape_keys.key_blocks) - 1
for blender_shape_key in blender_mesh.shape_keys.key_blocks:
if blender_shape_key != blender_shape_key.relative_key:
blender_shape_keys.append(
ShapeKey(
blender_shape_key,
blender_shape_key.normals_vertex_get(
), # calculate vertex normals for this shape key
blender_shape_key.normals_polygon_get())
) # calculate polygon normals for this shape key
#
# Convert polygon to primitive indices and eliminate invalid ones. Assign to material.
#
for blender_polygon in blender_mesh.polygons:
export_color = True
#
if blender_polygon.material_index < 0 or blender_polygon.material_index >= len(blender_mesh.materials) or \
blender_mesh.materials[blender_polygon.material_index] is None:
primitive = material_name_to_primitives['']
vertex_index_to_new_indices = material_map['']
else:
primitive = material_name_to_primitives[blender_mesh.materials[
blender_polygon.material_index].name]
vertex_index_to_new_indices = material_map[blender_mesh.materials[
blender_polygon.material_index].name]
#
attributes = primitive[ATTRIBUTES_ID]
face_normal = blender_polygon.normal
face_tangent = Vector((0.0, 0.0, 0.0))
face_bitangent = Vector((0.0, 0.0, 0.0))
if use_tangents:
for loop_index in blender_polygon.loop_indices:
temp_vertex = blender_mesh.loops[loop_index]
face_tangent += temp_vertex.tangent
face_bitangent += temp_vertex.bitangent
face_tangent.normalize()
face_bitangent.normalize()
#
indices = primitive[INDICES_ID]
loop_index_list = []
if len(blender_polygon.loop_indices) == 3:
loop_index_list.extend(blender_polygon.loop_indices)
elif len(blender_polygon.loop_indices) > 3:
# Triangulation of polygon. Using internal function, as non-convex polygons could exist.
polyline = []
for loop_index in blender_polygon.loop_indices:
vertex_index = blender_mesh.loops[loop_index].vertex_index
v = blender_mesh.vertices[vertex_index].co
polyline.append(Vector((v[0], v[1], v[2])))
triangles = tessellate_polygon((polyline, ))
for triangle in triangles:
loop_index_list.append(
blender_polygon.loop_indices[triangle[0]])
loop_index_list.append(
blender_polygon.loop_indices[triangle[2]])
loop_index_list.append(
blender_polygon.loop_indices[triangle[1]])
else:
continue
for loop_index in loop_index_list:
vertex_index = blender_mesh.loops[loop_index].vertex_index
if vertex_index_to_new_indices.get(vertex_index) is None:
vertex_index_to_new_indices[vertex_index] = []
#
v = None
n = None
t = None
b = None
uvs = []
colors = []
joints = []
weights = []
target_positions = []
target_normals = []
target_tangents = []
vertex = blender_mesh.vertices[vertex_index]
v = convert_swizzle_location(vertex.co, export_settings)
if blender_polygon.use_smooth:
n = convert_swizzle_location(vertex.normal, export_settings)
if use_tangents:
t = convert_swizzle_tangent(
blender_mesh.loops[loop_index].tangent,
export_settings)
b = convert_swizzle_location(
blender_mesh.loops[loop_index].bitangent,
export_settings)
else:
n = convert_swizzle_location(face_normal, export_settings)
if use_tangents:
t = convert_swizzle_tangent(face_tangent, export_settings)
b = convert_swizzle_location(face_bitangent,
export_settings)
if use_tangents:
tv = Vector((t[0], t[1], t[2]))
bv = Vector((b[0], b[1], b[2]))
nv = Vector((n[0], n[1], n[2]))
if (nv.cross(tv)).dot(bv) < 0.0:
t[3] = -1.0
if blender_mesh.uv_layers.active:
for tex_coord_index in range(0, tex_coord_max):
uv = blender_mesh.uv_layers[tex_coord_index].data[
loop_index].uv
uvs.append([uv.x, 1.0 - uv.y])
#
if color_max > 0 and export_color:
for color_index in range(0, color_max):
color_name = COLOR_PREFIX + str(color_index)
color = vertex_colors[color_name].data[loop_index].color
colors.append([
color_srgb_to_scene_linear(color[0]),
color_srgb_to_scene_linear(color[1]),
color_srgb_to_scene_linear(color[2]), 1.0
])
#
bone_count = 0
if blender_vertex_groups is not None and vertex.groups is not None and len(
vertex.groups) > 0 and export_settings[
gltf2_blender_export_keys.SKINS]:
joint = []
weight = []
vertex_groups = vertex.groups
if not export_settings['gltf_all_vertex_influences']:
# sort groups by weight descending
vertex_groups = sorted(vertex.groups,
key=attrgetter('weight'),
reverse=True)
for group_element in vertex_groups:
if len(joint) == 4:
bone_count += 1
joints.append(joint)
weights.append(weight)
joint = []
weight = []
#
joint_weight = group_element.weight
if joint_weight <= 0.0:
continue
#
vertex_group_index = group_element.group
vertex_group_name = blender_vertex_groups[
vertex_group_index].name
joint_index = None
if modifiers is not None:
modifiers_dict = {m.type: m for m in modifiers}
if "ARMATURE" in modifiers_dict:
armature = modifiers_dict["ARMATURE"].object
skin = gltf2_blender_gather_skins.gather_skin(
armature, export_settings)
for index, j in enumerate(skin.joints):
if j.name == vertex_group_name:
joint_index = index
break
#
if joint_index is not None:
joint.append(joint_index)
weight.append(joint_weight)
if len(joint) > 0:
bone_count += 1
for fill in range(0, 4 - len(joint)):
joint.append(0)
weight.append(0.0)
joints.append(joint)
weights.append(weight)
for fill in range(0, bone_max - bone_count):
joints.append([0, 0, 0, 0])
weights.append([0.0, 0.0, 0.0, 0.0])
#
if morph_max > 0 and export_settings[
gltf2_blender_export_keys.MORPH]:
for morph_index in range(0, morph_max):
blender_shape_key = blender_shape_keys[morph_index]
v_morph = convert_swizzle_location(
blender_shape_key.shape_key.data[vertex_index].co,
export_settings)
# Store delta.
v_morph -= v
target_positions.append(v_morph)
#
n_morph = None
if blender_polygon.use_smooth:
temp_normals = blender_shape_key.vertex_normals
n_morph = (temp_normals[vertex_index * 3 + 0],
temp_normals[vertex_index * 3 + 1],
temp_normals[vertex_index * 3 + 2])
else:
temp_normals = blender_shape_key.polygon_normals
n_morph = (temp_normals[blender_polygon.index * 3 + 0],
temp_normals[blender_polygon.index * 3 + 1],
temp_normals[blender_polygon.index * 3 + 2])
n_morph = convert_swizzle_location(n_morph,
export_settings)
# Store delta.
n_morph -= n
target_normals.append(n_morph)
#
if use_tangents:
rotation = n_morph.rotation_difference(n)
t_morph = Vector((t[0], t[1], t[2]))
t_morph.rotate(rotation)
target_tangents.append(t_morph)
#
#
create = True
for current_new_index in vertex_index_to_new_indices[vertex_index]:
found = True
for i in range(0, 3):
if attributes[POSITION_ATTRIBUTE][current_new_index * 3 +
i] != v[i]:
found = False
break
if attributes[NORMAL_ATTRIBUTE][current_new_index * 3 +
i] != n[i]:
found = False
break
if use_tangents:
for i in range(0, 4):
if attributes[TANGENT_ATTRIBUTE][current_new_index * 4
+ i] != t[i]:
found = False
break
if not found:
continue
for tex_coord_index in range(0, tex_coord_max):
uv = uvs[tex_coord_index]
tex_coord_id = TEXCOORD_PREFIX + str(tex_coord_index)
for i in range(0, 2):
if attributes[tex_coord_id][current_new_index * 2 +
i] != uv[i]:
found = False
break
if export_color:
for color_index in range(0, color_max):
color = colors[color_index]
color_id = COLOR_PREFIX + str(color_index)
for i in range(0, 3):
# Alpha is always 1.0 - see above.
current_color = attributes[color_id][
current_new_index * 4 + i]
if color_srgb_to_scene_linear(
current_color) != color[i]:
found = False
break
if export_settings[gltf2_blender_export_keys.SKINS]:
for bone_index in range(0, bone_max):
joint = joints[bone_index]
weight = weights[bone_index]
joint_id = JOINTS_PREFIX + str(bone_index)
weight_id = WEIGHTS_PREFIX + str(bone_index)
for i in range(0, 4):
if attributes[joint_id][current_new_index * 4 +
i] != joint[i]:
found = False
break
if attributes[weight_id][current_new_index * 4 +
i] != weight[i]:
found = False
break
if export_settings[gltf2_blender_export_keys.MORPH]:
for morph_index in range(0, morph_max):
target_position = target_positions[morph_index]
target_normal = target_normals[morph_index]
if use_tangents:
target_tangent = target_tangents[morph_index]
target_position_id = MORPH_POSITION_PREFIX + str(
morph_index)
target_normal_id = MORPH_NORMAL_PREFIX + str(
morph_index)
target_tangent_id = MORPH_TANGENT_PREFIX + str(
morph_index)
for i in range(0, 3):
if attributes[target_position_id][
current_new_index * 3 +
i] != target_position[i]:
found = False
break
if attributes[target_normal_id][
current_new_index * 3 +
i] != target_normal[i]:
found = False
break
if use_tangents:
if attributes[target_tangent_id][
current_new_index * 3 +
i] != target_tangent[i]:
found = False
break
if found:
indices.append(current_new_index)
create = False
break
if not create:
continue
new_index = 0
if primitive.get('max_index') is not None:
new_index = primitive['max_index'] + 1
primitive['max_index'] = new_index
vertex_index_to_new_indices[vertex_index].append(new_index)
#
#
indices.append(new_index)
#
attributes[POSITION_ATTRIBUTE].extend(v)
attributes[NORMAL_ATTRIBUTE].extend(n)
if use_tangents:
attributes[TANGENT_ATTRIBUTE].extend(t)
if blender_mesh.uv_layers.active:
for tex_coord_index in range(0, tex_coord_max):
tex_coord_id = TEXCOORD_PREFIX + str(tex_coord_index)
if attributes.get(tex_coord_id) is None:
attributes[tex_coord_id] = []
attributes[tex_coord_id].extend(uvs[tex_coord_index])
if export_color:
for color_index in range(0, color_max):
color_id = COLOR_PREFIX + str(color_index)
if attributes.get(color_id) is None:
attributes[color_id] = []
attributes[color_id].extend(colors[color_index])
if export_settings[gltf2_blender_export_keys.SKINS]:
for bone_index in range(0, bone_max):
joint_id = JOINTS_PREFIX + str(bone_index)
if attributes.get(joint_id) is None:
attributes[joint_id] = []
attributes[joint_id].extend(joints[bone_index])
weight_id = WEIGHTS_PREFIX + str(bone_index)
if attributes.get(weight_id) is None:
attributes[weight_id] = []
attributes[weight_id].extend(weights[bone_index])
if export_settings[gltf2_blender_export_keys.MORPH]:
for morph_index in range(0, morph_max):
target_position_id = MORPH_POSITION_PREFIX + str(
morph_index)
if attributes.get(target_position_id) is None:
attributes[target_position_id] = []
attributes[target_position_id].extend(
target_positions[morph_index])
target_normal_id = MORPH_NORMAL_PREFIX + str(morph_index)
if attributes.get(target_normal_id) is None:
attributes[target_normal_id] = []
attributes[target_normal_id].extend(
target_normals[morph_index])
if use_tangents:
target_tangent_id = MORPH_TANGENT_PREFIX + str(
morph_index)
if attributes.get(target_tangent_id) is None:
attributes[target_tangent_id] = []
attributes[target_tangent_id].extend(
target_tangents[morph_index])
#
# Add primitive plus split them if needed.
#
result_primitives = []
for material_name, primitive in material_name_to_primitives.items():
export_color = True
#
indices = primitive[INDICES_ID]
if len(indices) == 0:
continue
position = primitive[ATTRIBUTES_ID][POSITION_ATTRIBUTE]
normal = primitive[ATTRIBUTES_ID][NORMAL_ATTRIBUTE]
if use_tangents:
tangent = primitive[ATTRIBUTES_ID][TANGENT_ATTRIBUTE]
tex_coords = []
for tex_coord_index in range(0, tex_coord_max):
tex_coords.append(primitive[ATTRIBUTES_ID][TEXCOORD_PREFIX +
str(tex_coord_index)])
colors = []
if export_color:
for color_index in range(0, color_max):
tex_coords.append(primitive[ATTRIBUTES_ID][COLOR_PREFIX +
str(color_index)])
joints = []
weights = []
if export_settings[gltf2_blender_export_keys.SKINS]:
for bone_index in range(0, bone_max):
joints.append(primitive[ATTRIBUTES_ID][JOINTS_PREFIX +
str(bone_index)])
weights.append(primitive[ATTRIBUTES_ID][WEIGHTS_PREFIX +
str(bone_index)])
target_positions = []
target_normals = []
target_tangents = []
if export_settings[gltf2_blender_export_keys.MORPH]:
for morph_index in range(0, morph_max):
target_positions.append(
primitive[ATTRIBUTES_ID][MORPH_POSITION_PREFIX +
str(morph_index)])
target_normals.append(
primitive[ATTRIBUTES_ID][MORPH_NORMAL_PREFIX +
str(morph_index)])
if use_tangents:
target_tangents.append(
primitive[ATTRIBUTES_ID][MORPH_TANGENT_PREFIX +
str(morph_index)])
#
count = len(indices)
if count == 0:
continue
max_index = max(indices)
#
# NOTE: Values used by some graphics APIs as "primitive restart" values are disallowed.
# Specifically, the value 65535 (in UINT16) cannot be used as a vertex index.
# https://github.com/KhronosGroup/glTF/issues/1142
# https://github.com/KhronosGroup/glTF/pull/1476/files
range_indices = 65535
#
if max_index >= range_indices:
#
# Splitting result_primitives.
#
# At start, all indices are pending.
pending_attributes = {POSITION_ATTRIBUTE: [], NORMAL_ATTRIBUTE: []}
if use_tangents:
pending_attributes[TANGENT_ATTRIBUTE] = []
pending_primitive = {
MATERIAL_ID: material_name,
INDICES_ID: [],
ATTRIBUTES_ID: pending_attributes
}
pending_primitive[INDICES_ID].extend(indices)
pending_attributes[POSITION_ATTRIBUTE].extend(position)
pending_attributes[NORMAL_ATTRIBUTE].extend(normal)
if use_tangents:
pending_attributes[TANGENT_ATTRIBUTE].extend(tangent)
tex_coord_index = 0
for tex_coord in tex_coords:
pending_attributes[TEXCOORD_PREFIX +
str(tex_coord_index)] = tex_coord
tex_coord_index += 1
if export_color:
color_index = 0
for color in colors:
pending_attributes[COLOR_PREFIX + str(color_index)] = color
color_index += 1
if export_settings[gltf2_blender_export_keys.SKINS]:
joint_index = 0
for joint in joints:
pending_attributes[JOINTS_PREFIX +
str(joint_index)] = joint
joint_index += 1
weight_index = 0
for weight in weights:
pending_attributes[WEIGHTS_PREFIX +
str(weight_index)] = weight
weight_index += 1
if export_settings[gltf2_blender_export_keys.MORPH]:
morph_index = 0
for target_position in target_positions:
pending_attributes[MORPH_POSITION_PREFIX +
str(morph_index)] = target_position
morph_index += 1
morph_index = 0
for target_normal in target_normals:
pending_attributes[MORPH_NORMAL_PREFIX +
str(morph_index)] = target_normal
morph_index += 1
if use_tangents:
morph_index = 0
for target_tangent in target_tangents:
pending_attributes[MORPH_TANGENT_PREFIX +
str(morph_index)] = target_tangent
morph_index += 1
pending_indices = pending_primitive[INDICES_ID]
# Continue until all are processed.
while len(pending_indices) > 0:
process_indices = pending_primitive[INDICES_ID]
max_index = max(process_indices)
pending_indices = []
#
#
all_local_indices = []
for i in range(0, (max_index // range_indices) + 1):
all_local_indices.append([])
#
#
# For all faces ...
for face_index in range(0, len(process_indices), 3):
written = False
face_min_index = min(process_indices[face_index + 0],
process_indices[face_index + 1],
process_indices[face_index + 2])
face_max_index = max(process_indices[face_index + 0],
process_indices[face_index + 1],
process_indices[face_index + 2])
# ... check if it can be but in a range of maximum indices.
for i in range(0, (max_index // range_indices) + 1):
offset = i * range_indices
# Yes, so store the primitive with its indices.
if face_min_index >= offset and face_max_index < offset + range_indices:
all_local_indices[i].extend([
process_indices[face_index + 0],
process_indices[face_index + 1],
process_indices[face_index + 2]
])
written = True
break
# If not written, the triangle face has indices from different ranges.
if not written:
pending_indices.extend([
process_indices[face_index + 0],
process_indices[face_index + 1],
process_indices[face_index + 2]
])
# Only add result_primitives, which do have indices in it.
for local_indices in all_local_indices:
if len(local_indices) > 0:
current_primitive = extract_primitive_floor(
pending_primitive, local_indices, use_tangents)
result_primitives.append(current_primitive)
print_console(
'DEBUG',
'Adding primitive with splitting. Indices: ' +
str(len(current_primitive[INDICES_ID])) +
' Vertices: ' + str(
len(current_primitive[ATTRIBUTES_ID]
[POSITION_ATTRIBUTE]) // 3))
# Process primitive faces having indices in several ranges.
if len(pending_indices) > 0:
pending_primitive = extract_primitive_pack(
pending_primitive, pending_indices, use_tangents)
print_console(
'DEBUG', 'Creating temporary primitive for splitting')
else:
#
# No splitting needed.
#
result_primitives.append(primitive)
print_console(
'DEBUG', 'Adding primitive without splitting. Indices: ' +
str(len(primitive[INDICES_ID])) + ' Vertices: ' +
str(len(primitive[ATTRIBUTES_ID][POSITION_ATTRIBUTE]) // 3))
print_console('INFO', 'Primitives created: ' + str(len(result_primitives)))
return result_primitives
def draw_molecule(molecule,
center=(0, 0, 0),
max_molecule_size=5,
show_bonds=True):
"""Draw a molecule to blender. Uses loaded json molecule data."""
# Get scale factor - only scales large molecules down
max_coord = 1E-6
for atom in molecule["atoms"]:
max_coord = max(max_coord, *[abs(a) for a in atom["location"]])
scale = min(max_molecule_size / max_coord, 1)
# Scale location coordinates and add specified center
for atom in molecule["atoms"]:
atom["location"] = [
c + x * scale for c, x in zip(center, atom["location"])
]
# Keep references to all atoms and bonds
shapes = []
# If using space-filling model, scale up atom size and remove bonds
if not show_bonds:
scale *= 2.5
molecule["bonds"] = []
# Add atom primitive
bpy.ops.object.select_all(action='DESELECT')
bpy.ops.mesh.primitive_uv_sphere_add()
sphere = bpy.context.object
# Add bond material and primitive if it's going to be used
if molecule["bonds"]:
key = "bond"
bpy.data.materials.new(name=key)
bpy.data.materials[key].diffuse_color = atom_data[key]["color"]
bpy.data.materials[key].specular_intensity = 0.2
bpy.ops.mesh.primitive_cylinder_add()
cylinder = bpy.context.object
cylinder.active_material = bpy.data.materials["bond"]
# Draw atoms
for atom in molecule["atoms"]:
# If element is not in dictionary, use undefined values
if atom["element"] not in atom_data:
atom["element"] = "undefined"
# If material for atom type has not yet been defined, do so
if atom["element"] not in bpy.data.materials:
key = atom["element"]
bpy.data.materials.new(name=key)
bpy.data.materials[key].diffuse_color = atom_data[key]["color"]
bpy.data.materials[key].specular_intensity = 0.2
# Copy mesh primitive and edit to make atom
atom_sphere = sphere.copy()
atom_sphere.data = sphere.data.copy()
atom_sphere.location = atom["location"]
atom_sphere.dimensions = [
atom_data[atom["element"]]["radius"] * scale * 2
] * 3
atom_sphere.active_material = bpy.data.materials[atom["element"]]
bpy.context.scene.objects.link(atom_sphere)
shapes.append(atom_sphere)
# Draw bonds
for bond in molecule["bonds"]:
# Extracting locations
first_loc = molecule["atoms"][bond["atoms"][0]]["location"]
second_loc = molecule["atoms"][bond["atoms"][1]]["location"]
diff = [c2 - c1 for c2, c1 in zip(first_loc, second_loc)]
cent = [(c2 + c1) / 2 for c2, c1 in zip(first_loc, second_loc)]
mag = sum([(c2 - c1)**2 for c1, c2 in zip(first_loc, second_loc)])**0.5
# Euler rotation calculation
v_axis = Vector(diff).normalized()
v_obj = Vector((0, 0, 1))
v_rot = v_obj.cross(v_axis)
angle = acos(v_obj.dot(v_axis))
# Check that the number of bonds is logical
if bond["order"] not in range(1, 4):
print("Improper number of bonds! Defaulting to 1.")
bond["order"] = 1
# Specify locations of each bond in every scenario
if bond["order"] == 1:
trans = [[0] * 3]
elif bond["order"] == 2:
trans = [[1.4 * atom_data["bond"]["radius"] * x for x in v_obj],
[-1.4 * atom_data["bond"]["radius"] * x for x in v_obj]]
elif bond["order"] == 3:
trans = [[0] * 3,
[2.2 * atom_data["bond"]["radius"] * x for x in v_obj],
[-2.2 * atom_data["bond"]["radius"] * x for x in v_obj]]
# Draw bonds
for i in range(bond["order"]):
bond_cylinder = cylinder.copy()
bond_cylinder.data = cylinder.data.copy()
bond_cylinder.dimensions = [
atom_data["bond"]["radius"] * scale * 2
] * 2 + [mag]
bond_cylinder.location = [
c + scale * v for c, v in zip(cent, trans[i])
]
bond_cylinder.rotation_mode = "AXIS_ANGLE"
bond_cylinder.rotation_axis_angle = [angle] + list(v_rot)
bpy.context.scene.objects.link(bond_cylinder)
shapes.append(bond_cylinder)
# Remove primitive meshes
bpy.ops.object.select_all(action='DESELECT')
sphere.select = True
if molecule["bonds"]:
cylinder.select = True
# If the starting cube is there, remove it
if "Cube" in bpy.data.objects.keys():
bpy.data.objects.get("Cube").select = True
bpy.ops.object.delete()
# Smooth and join molecule shapes
for shape in shapes:
shape.select = True
bpy.context.scene.objects.active = shapes[0]
bpy.ops.object.shade_smooth()
bpy.ops.object.join()
# Center object origin to geometry
bpy.ops.object.origin_set(type="ORIGIN_GEOMETRY", center="MEDIAN")
# Refresh scene
bpy.context.scene.update()
def import_xyz(Ball_type,
Ball_azimuth,
Ball_zenith,
Ball_radius_factor,
radiustype,
Ball_distance_factor,
put_to_center,
put_to_center_all,
use_camera,
use_lamp,
filepath_xyz):
# List of materials
atom_material_list = []
# ------------------------------------------------------------------------
# INITIALIZE THE ELEMENT LIST
read_elements()
# ------------------------------------------------------------------------
# READING DATA OF ATOMS
Number_of_total_atoms = read_xyz_file(filepath_xyz,
radiustype)
# We show the atoms of the first frame.
first_frame = ALL_FRAMES[0]
# ------------------------------------------------------------------------
# MATERIAL PROPERTIES FOR ATOMS
# Create first a new list of materials for each type of atom
# (e.g. hydrogen)
for atoms_of_one_type in first_frame:
# Take the first atom
atom = atoms_of_one_type[0]
material = bpy.data.materials.new(atom.name)
material.name = atom.name
material.diffuse_color = atom.color
atom_material_list.append(material)
# Now, we go through all atoms and give them a material. For all atoms ...
for atoms_of_one_type in first_frame:
for atom in atoms_of_one_type:
# ... and all materials ...
for material in atom_material_list:
# ... select the correct material for the current atom via
# comparison of names ...
if atom.name in material.name:
# ... and give the atom its material properties.
# However, before we check if it is a vacancy
# The vacancy is represented by a transparent cube.
if atom.name == "Vacancy":
material.transparency_method = 'Z_TRANSPARENCY'
material.alpha = 1.3
material.raytrace_transparency.fresnel = 1.6
material.raytrace_transparency.fresnel_factor = 1.6
material.use_transparency = True
# The atom gets its properties.
atom.material = material
# ------------------------------------------------------------------------
# TRANSLATION OF THE STRUCTURE TO THE ORIGIN
# It may happen that the structure in a XYZ file already has an offset
# If chosen, the structure is put into the center of the scene
# (only the first frame).
if put_to_center == True and put_to_center_all == False:
sum_vec = Vector((0.0,0.0,0.0))
# Sum of all atom coordinates
for atoms_of_one_type in first_frame:
sum_vec = sum([atom.location for atom in atoms_of_one_type], sum_vec)
# Then the average is taken
sum_vec = sum_vec / Number_of_total_atoms
# After, for each atom the center of gravity is substracted
for atoms_of_one_type in first_frame:
for atom in atoms_of_one_type:
atom.location -= sum_vec
# If chosen, the structure is put into the center of the scene
# (all frames).
if put_to_center_all == True:
# For all frames
for frame in ALL_FRAMES:
sum_vec = Vector((0.0,0.0,0.0))
# Sum of all atom coordinates
for (i, atoms_of_one_type) in enumerate(frame):
# This is a guarantee that only the total number of atoms of the
# first frame is used. Condition is, so far, that the number of
# atoms in a xyz file is constant. However, sometimes the number
# may increase (or decrease). If it decreases, the addon crashes.
# If it increases, only the tot number of atoms of the first frame
# is used.
# By time, I will allow varying atom numbers ... but this takes
# some time ...
if i >= Number_of_total_atoms:
break
sum_vec = sum([atom.location for atom in atoms_of_one_type], sum_vec)
# Then the average is taken
sum_vec = sum_vec / Number_of_total_atoms
# After, for each atom the center of gravity is substracted
for atoms_of_one_type in frame:
for atom in atoms_of_one_type:
atom.location -= sum_vec
# ------------------------------------------------------------------------
# SCALING
# Take all atoms and adjust their radii and scale the distances.
for atoms_of_one_type in first_frame:
for atom in atoms_of_one_type:
atom.location *= Ball_distance_factor
# ------------------------------------------------------------------------
# DETERMINATION OF SOME GEOMETRIC PROPERTIES
# In the following, some geometric properties of the whole object are
# determined: center, size, etc.
sum_vec = Vector((0.0,0.0,0.0))
# First the center is determined. All coordinates are summed up ...
for atoms_of_one_type in first_frame:
sum_vec = sum([atom.location for atom in atoms_of_one_type], sum_vec)
# ... and the average is taken. This gives the center of the object.
object_center_vec = sum_vec / Number_of_total_atoms
# Now, we determine the size.The farthest atom from the object center is
# taken as a measure. The size is used to place well the camera and light
# into the scene.
object_size_vec = []
for atoms_of_one_type in first_frame:
object_size_vec += [atom.location - object_center_vec for atom in atoms_of_one_type]
object_size = 0.0
object_size = max(object_size_vec).length
# ------------------------------------------------------------------------
# CAMERA AND LAMP
camera_factor = 20.0
# If chosen a camera is put into the scene.
if use_camera == True:
# Assume that the object is put into the global origin. Then, the
# camera is moved in x and z direction, not in y. The object has its
# size at distance sqrt(object_size) from the origin. So, move the
# camera by this distance times a factor of camera_factor in x and z.
# Then add x, y and z of the origin of the object.
object_camera_vec = Vector((sqrt(object_size) * camera_factor,
0.0,
sqrt(object_size) * camera_factor))
camera_xyz_vec = object_center_vec + object_camera_vec
# Create the camera
current_layers=bpy.context.scene.layers
camera_data = bpy.data.cameras.new("A_camera")
camera_data.lens = 45
camera_data.clip_end = 500.0
camera = bpy.data.objects.new("A_camera", camera_data)
camera.location = camera_xyz_vec
camera.layers = current_layers
bpy.context.scene.objects.link(camera)
# Here the camera is rotated such it looks towards the center of
# the object. The [0.0, 0.0, 1.0] vector along the z axis
z_axis_vec = Vector((0.0, 0.0, 1.0))
# The angle between the last two vectors
angle = object_camera_vec.angle(z_axis_vec, 0)
# The cross-product of z_axis_vec and object_camera_vec
axis_vec = z_axis_vec.cross(object_camera_vec)
# Rotate 'axis_vec' by 'angle' and convert this to euler parameters.
# 4 is the size of the matrix.
camera.rotation_euler = Matrix.Rotation(angle, 4, axis_vec).to_euler()
# Rotate the camera around its axis by 90° such that we have a nice
# camera position and view onto the object.
bpy.ops.object.select_all(action='DESELECT')
camera.select = True
bpy.ops.transform.rotate(value=(90.0*2*pi/360.0),
axis=object_camera_vec,
constraint_axis=(False, False, False),
constraint_orientation='GLOBAL',
mirror=False, proportional='DISABLED',
proportional_edit_falloff='SMOOTH',
proportional_size=1, snap=False,
snap_target='CLOSEST', snap_point=(0, 0, 0),
snap_align=False, snap_normal=(0, 0, 0),
release_confirm=False)
# Here a lamp is put into the scene, if chosen.
if use_lamp == True:
# This is the distance from the object measured in terms of %
# of the camera distance. It is set onto 50% (1/2) distance.
lamp_dl = sqrt(object_size) * 15 * 0.5
# This is a factor to which extend the lamp shall go to the right
# (from the camera point of view).
lamp_dy_right = lamp_dl * (3.0/4.0)
# Create x, y and z for the lamp.
object_lamp_vec = Vector((lamp_dl,lamp_dy_right,lamp_dl))
lamp_xyz_vec = object_center_vec + object_lamp_vec
# Create the lamp
current_layers=bpy.context.scene.layers
lamp_data = bpy.data.lamps.new(name="A_lamp", type="POINT")
lamp_data.distance = 500.0
lamp_data.energy = 3.0
lamp_data.shadow_method = 'RAY_SHADOW'
lamp = bpy.data.objects.new("A_lamp", lamp_data)
lamp.location = lamp_xyz_vec
lamp.layers = current_layers
bpy.context.scene.objects.link(lamp)
bpy.context.scene.world.light_settings.use_ambient_occlusion = True
bpy.context.scene.world.light_settings.ao_factor = 0.2
# ------------------------------------------------------------------------
# DRAWING THE ATOMS
bpy.ops.object.select_all(action='DESELECT')
# For each list of atoms of ONE type (e.g. Hydrogen)
for atoms_of_one_type in first_frame:
# Create first the vertices composed of the coordinates of all
# atoms of one type
atom_vertices = []
for atom in atoms_of_one_type:
# In fact, the object is created in the World's origin.
# This is why 'object_center_vec' is substracted. At the end
# the whole object is translated back to 'object_center_vec'.
atom_vertices.append( atom.location - object_center_vec )
# Build the mesh
atom_mesh = bpy.data.meshes.new("Mesh_"+atom.name)
atom_mesh.from_pydata(atom_vertices, [], [])
atom_mesh.update()
new_atom_mesh = bpy.data.objects.new(atom.name, atom_mesh)
bpy.context.scene.objects.link(new_atom_mesh)
# Now, build a representative sphere (atom)
current_layers=bpy.context.scene.layers
if atom.name == "Vacancy":
bpy.ops.mesh.primitive_cube_add(
view_align=False, enter_editmode=False,
location=(0.0, 0.0, 0.0),
rotation=(0.0, 0.0, 0.0),
layers=current_layers)
else:
# NURBS balls
if Ball_type == "0":
bpy.ops.surface.primitive_nurbs_surface_sphere_add(
view_align=False, enter_editmode=False,
location=(0,0,0), rotation=(0.0, 0.0, 0.0),
layers=current_layers)
# UV balls
elif Ball_type == "1":
bpy.ops.mesh.primitive_uv_sphere_add(
segments=Ball_azimuth, ring_count=Ball_zenith,
size=1, view_align=False, enter_editmode=False,
location=(0,0,0), rotation=(0, 0, 0),
layers=current_layers)
# Meta balls
elif Ball_type == "2":
bpy.ops.object.metaball_add(type='BALL', view_align=False,
enter_editmode=False, location=(0, 0, 0),
rotation=(0, 0, 0), layers=current_layers)
ball = bpy.context.scene.objects.active
ball.scale = (atom.radius*Ball_radius_factor,) * 3
if atom.name == "Vacancy":
ball.name = "Cube_"+atom.name
else:
ball.name = "Ball (NURBS)_"+atom.name
ball.active_material = atom.material
ball.parent = new_atom_mesh
new_atom_mesh.dupli_type = 'VERTS'
# The object is back translated to 'object_center_vec'.
new_atom_mesh.location = object_center_vec
STRUCTURE.append(new_atom_mesh)
# ------------------------------------------------------------------------
# SELECT ALL LOADED OBJECTS
bpy.ops.object.select_all(action='DESELECT')
obj = None
for obj in STRUCTURE:
obj.select = True
# activate the last selected object (perhaps another should be active?)
if obj:
bpy.context.scene.objects.active = obj
class GlLine(GlBaseLine):
"""
2d/3d Line
"""
def __init__(self, d=3, p=None, v=None, p0=None, p1=None, z_axis=None):
"""
d=3 use 3d coords, d=2 use 2d pixels coords
Init by either
p: Vector or tuple origin
v: Vector or tuple size and direction
or
p0: Vector or tuple 1 point location
p1: Vector or tuple 2 point location
Will convert any into Vector 3d
both optionnals
"""
if p is not None and v is not None:
self.p = Vector(p)
self.v = Vector(v)
elif p0 is not None and p1 is not None:
self.p = Vector(p0)
self.v = Vector(p1) - self.p
else:
self.p = Vector((0, 0, 0))
self.v = Vector((0, 0, 0))
if z_axis is not None:
self.z_axis = z_axis
else:
self.z_axis = Vector((0, 0, 1))
GlBaseLine.__init__(self, d)
@property
def p0(self):
return self.p
@property
def p1(self):
return self.p + self.v
@p0.setter
def p0(self, p0):
"""
Note: setting p0
move p0 only
"""
p1 = self.p1
self.p = Vector(p0)
self.v = p1 - p0
@p1.setter
def p1(self, p1):
"""
Note: setting p1
move p1 only
"""
self.v = Vector(p1) - self.p
@property
def length(self):
return self.v.length
@property
def angle(self):
return atan2(self.v.y, self.v.x)
@property
def cross(self):
"""
Vector perpendicular on plane defined by z_axis
lie on the right side
p1
|--x
p0
"""
return self.v.cross(self.z_axis)
def normal(self, t=0):
"""
Line perpendicular on plane defined by z_axis
lie on the right side
p1
|--x
p0
"""
n = GlLine()
n.p = self.lerp(t)
n.v = self.cross
return n
def sized_normal(self, t, size):
"""
GlLine perpendicular on plane defined by z_axis and of given size
positionned at t in current line
lie on the right side
p1
|--x
p0
"""
n = GlLine()
n.p = self.lerp(t)
n.v = size * self.cross.normalized()
return n
def lerp(self, t):
"""
Interpolate along segment
t parameter [0, 1] where 0 is start of arc and 1 is end
"""
return self.p + self.v * t
def offset(self, offset):
"""
offset > 0 on the right part
"""
self.p += offset * self.cross.normalized()
def point_sur_segment(self, pt):
""" point_sur_segment (2d)
point: Vector 3d
t: param t de l'intersection sur le segment courant
d: distance laterale perpendiculaire positif a droite
"""
dp = (pt - self.p).to_2d()
v2d = self.v.to_2d()
dl = v2d.length
d = (self.v.x * dp.y - self.v.y * dp.x) / dl
t = (v2d * dp) / (dl * dl)
return t > 0 and t < 1, d, t
@property
def pts(self):
return [self.p0, self.p1]
def execute(self, context):
curvepoints = []
curveobj = context.active_object
bpy.ops.object.empty_add(type='PLAIN_AXES')
parentobj = context.active_object
parentobj.name = 'CurveForce'
if len(curveobj.data.splines[0].bezier_points) > 1:
curvepoints = [v.co for v in curveobj.data.splines[0].bezier_points]
else:
curvepoints = [v.co for v in curveobj.data.splines[0].points]
curveobj.parent = parentobj
context.active_object.select = False
curveobj.select = True
previousnormal = Vector([0.0,0.0,0.0])
lastStrength = context.window_manager.curveForce_strength
lastDistance = context.window_manager.curveForce_maxDist
for i in range(len(curvepoints)):
cpoint = Vector([curvepoints[i][0],curvepoints[i][1],curvepoints[i][2]])
bpy.ops.object.empty_add(type='SINGLE_ARROW',location=(cpoint))
context.active_object.name = 'ForceObj'
# turn into forcefield
bpy.ops.object.forcefield_toggle()
context.active_object.field.type = 'WIND'
if context.window_manager.curveForce_trailout:
if i > 0:
lastStrength = lastStrength * 0.9
lastDistance = lastDistance * 0.9
context.active_object.field.strength = lastStrength
context.active_object.field.use_max_distance = True
context.active_object.field.distance_max = lastDistance
context.active_object.field.falloff_power = context.window_manager.curveForce_falloffPower
# get the curve's direction between points
tempnorm = Vector([0,0,0])
if (i < len(curvepoints) - 1):
cpoint2 = Vector([curvepoints[i + 1][0],curvepoints[i + 1][1],curvepoints[i + 1][2]])
tempnorm = cpoint - cpoint2
if i > 0:
if abs(previousnormal.length) > 0.0:
tempnorm = (tempnorm + previousnormal) / 2.0
previousnormal = tempnorm
else:
if curveobj.data.splines[0].use_cyclic_u or curveobj.data.splines[0].use_cyclic_u:
cpoint2 = Vector([curvepoints[0][0],curvepoints[0][1],curvepoints[0][2]])
tempnorm = cpoint - cpoint2
if abs(previousnormal.length) > 0.0:
tempnorm = (tempnorm + previousnormal) / 2.0
previousnormal = tempnorm
else:
cpoint2 = Vector([curvepoints[i - 1][0],curvepoints[i - 1][1],curvepoints[i - 1][2]])
tempnorm = cpoint2 - cpoint
if abs(previousnormal.length) > 0.0:
tempnorm = (tempnorm + previousnormal) / 2.0
previousnormal = tempnorm
if abs(tempnorm.length) > 0.0:
z = Vector((0,0,1))
angle = tempnorm.angle(z)
axis = z.cross(tempnorm)
mat = Matrix.Rotation(angle, 4, axis)
mat_world = context.active_object.matrix_world * mat
context.active_object.matrix_world = mat_world
context.active_object.parent = parentobj
return {'FINISHED'}
def grow(self):
from numpy import sum, all, ones
self.itt += 1
stp = self.stp
killzone = self.killzone
noise = self.noise
v_xyz,s_xyz = self.get_positions()
dvv,dvs = self.get_distances(v_xyz,s_xyz)
vs_map,sv_map = self.make_maps(dvv,dvs,killzone)
nv,ns = dvs.shape
self.select_seed()
bm = self.get_bmesh()
nodes = [v for v in bm.verts]
for i,jj in vs_map.items():
v = Vector(sum(s_xyz[jj,:]-v_xyz[i,:],axis=0))
v.normalize()
# this is flawed. particularly for "flat" geometries
p,pn = self.closest_point_on_geom(nodes[i].co)
projected = pn.cross(v.cross(pn))
projected += random_unit_vector()*noise
projected.normalize()
new = nodes[i].co + projected*stp
verts = [nodes[i]]
new_vert = bmesh.ops.extrude_vert_indiv(
bm,
verts=verts)['verts'].pop()
new_vert.co = new
## mask out dead sources
mask = ones(ns,'bool')
for j,ii in sv_map.items():
if all(dvs[ii,j]<=killzone):
mask[j] = False
self.num_sources -= 1
print('merging:',len(ii),'deleted source:',j)
new_verts = []
for i in ii:
new = bmesh.ops.extrude_vert_indiv(
bm,
verts=[nodes[i]])['verts'].pop()
new.co = self.sources[j]
new_verts.append(new)
bmesh.ops.remove_doubles(bm,verts=new_verts,dist=0.01)
self.dead_sources.append(self.sources[j])
self.to_mesh()
self.sources = self.sources[mask,:]
return
def execute(self, context):
obj = context.active_object
bpy.context.space_data.pivot_point = 'INDIVIDUAL_ORIGINS'
bpy.ops.object.mode_set(mode='OBJECT')
if len(bpy.context.selected_objects) > 1:
first_obj = bpy.context.active_object
obj_a, obj_b = context.selected_objects
second_obj = obj_a if obj_b == first_obj else obj_b
bpy.data.objects[second_obj.name].select = False
if context.mode == 'EDIT_MESH':
print(self)
self.report({'INFO'},
"Please select a source and a target object")
else:
bpy.ops.object.duplicate_move()
for i in range(self.set_origin):
bpy.ops.object.cubefront_side_minus_z()
bpy.context.active_object.name = "Dummy"
bpy.ops.object.parent_clear(type='CLEAR_KEEP_TRANSFORM')
bpy.ops.object.transform_apply(location=True,
rotation=True,
scale=True)
copy_cursor = bpy.context.scene.cursor_location.copy()
bm = bmesh.new()
bm.from_mesh(obj.data)
selected_faces = [f for f in bm.faces if f.select]
for face in selected_faces:
face_location = face.calc_center_median()
loc_world_space = obj.matrix_world * Vector(face_location)
z = Vector((0, 0, 1))
angle = face.normal.angle(z)
axis = z.cross(face.normal)
bpy.ops.object.select_all(action='DESELECT')
bpy.context.scene.objects.active = bpy.data.objects[
second_obj.name]
bpy.data.objects[second_obj.name].select = True
for i in range(self.dupli_linked):
bpy.ops.object.duplicate_move_linked(
OBJECT_OT_duplicate={
"linked": True,
"mode": 'TRANSLATION'
})
for i in range(self.dupli):
bpy.ops.object.duplicate_move(OBJECT_OT_duplicate={
"linked": False,
"mode": 'TRANSLATION'
})
for i in range(self.set_origin):
bpy.ops.tp_ops.cubefront_side_minus_z()
bpy.context.scene.cursor_location = loc_world_space
bpy.ops.view3d.snap_selected_to_cursor()
bpy.ops.transform.rotate(value=angle, axis=axis)
bm.to_mesh(obj.data)
bm.free()
bpy.context.scene.cursor_location = copy_cursor
bpy.ops.object.select_all(action='DESELECT')
bpy.context.scene.objects.active = bpy.data.objects["Dummy"]
bpy.data.objects["Dummy"].select = True
bpy.ops.object.delete(use_global=False)
bpy.ops.object.select_all(action='DESELECT')
bpy.context.scene.objects.active = bpy.data.objects[
second_obj.name]
bpy.data.objects[second_obj.name].select = True
for i in range(self.set_edit):
bpy.context.scene.objects.active = bpy.data.objects[
first_obj.name]
bpy.ops.object.mode_set(mode='EDIT')
print(self)
self.report({'INFO'}, "Editmode")
else:
print(self)
self.report({'INFO'}, "Please select a source and a target object")
return {"FINISHED"}