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
python类Vector()的实例源码
def set_location(self, context, p0, p1):
x0, y0 = p0
x1, y1 = p1
if x0 > x1:
x1, x0 = x0, x1
if y0 > y1:
y1, y0 = y0, y1
self.min = Vector((x0, y0))
self.max = Vector((x1, y1))
pos = [
Vector((x0, y0)),
Vector((x0, y1)),
Vector((x1, y1)),
Vector((x1, y0))]
self.area.set_pos(pos)
self.border.set_pos(pos)
def setup_user_defined_post(self, o, post_x, post_y, post_z):
self.user_defined_post = o
x = o.bound_box[6][0] - o.bound_box[0][0]
y = o.bound_box[6][1] - o.bound_box[0][1]
z = o.bound_box[6][2] - o.bound_box[0][2]
self.user_defined_post_scale = Vector((post_x / x, post_y / -y, post_z / z))
m = o.data
# create vertex group lookup dictionary for names
vgroup_names = {vgroup.index: vgroup.name for vgroup in o.vertex_groups}
# create dictionary of vertex group assignments per vertex
self.vertex_groups = [[vgroup_names[g.group] for g in v.groups] for v in m.vertices]
# uvs
uv_act = m.uv_layers.active
if uv_act is not None:
uv_layer = uv_act.data
self.user_defined_uvs = [[uv_layer[li].uv for li in p.loop_indices] for p in m.polygons]
else:
self.user_defined_uvs = [[(0, 0) for i in p.vertices] for p in m.polygons]
# material ids
self.user_defined_mat = [p.material_index for p in m.polygons]
def setup_manipulators(self):
if len(self.manipulators) == 0:
s = self.manipulators.add()
s.prop1_name = "width"
s = self.manipulators.add()
s.prop1_name = "height"
s.normal = Vector((0, 1, 0))
for i in range(self.n_parts):
p = self.parts[i]
n_manips = len(p.manipulators)
if n_manips == 0:
s = p.manipulators.add()
s.type_key = "ANGLE"
s.prop1_name = "a0"
s = p.manipulators.add()
s.type_key = "SIZE"
s.prop1_name = "length"
s = p.manipulators.add()
# s.type_key = 'SNAP_POINT'
s.type_key = 'WALL_SNAP'
s.prop1_name = str(i)
s.prop2_name = 'post_z'
def docylinder(self, faces, verts, radius, segs, tMt, tMb, tM, add=False):
segs_step = 2 * pi / segs
tmpverts = [0 for i in range(segs)]
if add:
cv = len(verts) - segs
else:
cv = len(verts)
for seg in range(segs):
seg_angle = pi / 4 + seg * segs_step
tmpverts[seg] = radius * Vector((sin(seg_angle), -cos(seg_angle), 0))
if not add:
for seg in range(segs):
verts.append(tM * tMb * tmpverts[seg])
for seg in range(segs):
verts.append(tM * tMt * tmpverts[seg])
for seg in range(segs - 1):
f = cv + seg
faces.append((f + 1, f, f + segs, f + segs + 1))
f = cv
faces.append((f, f + segs - 1, f + 2 * segs - 1, f + segs))
def create(self, context):
curve = context.active_object
bpy.ops.archipack.slab(auto_manipulate=self.auto_manipulate)
o = context.scene.objects.active
d = archipack_slab.datablock(o)
spline = curve.data.splines[0]
d.from_spline(curve.matrix_world, 12, spline)
if spline.type == 'POLY':
pt = spline.points[0].co
elif spline.type == 'BEZIER':
pt = spline.bezier_points[0].co
else:
pt = Vector((0, 0, 0))
# pretranslate
o.matrix_world = curve.matrix_world * Matrix([
[1, 0, 0, pt.x],
[0, 1, 0, pt.y],
[0, 0, 1, pt.z],
[0, 0, 0, 1]
])
return o
# -----------------------------------------------------
# Execute
# -----------------------------------------------------
def sp_draw(self, sp, context):
z = 2.7
if self.state == 'CREATE':
p0 = self.takeloc
else:
p0 = sp.takeloc
p1 = sp.placeloc
delta = p1 - p0
# print("sp_draw state:%s delta:%s p0:%s p1:%s" % (self.state, delta.length, p0, p1))
if delta.length == 0:
return
self.wall_part1.set_pos([p0, p1, Vector((p1.x, p1.y, p1.z + z)), Vector((p0.x, p0.y, p0.z + z))])
self.wall_line1.set_pos([p0, p1, Vector((p1.x, p1.y, p1.z + z)), Vector((p0.x, p0.y, p0.z + z))])
self.wall_part1.draw(context)
self.wall_line1.draw(context)
self.line.p = p0
self.line.v = delta
self.label.set_pos(context, self.line.length, self.line.lerp(0.5), self.line.v, normal=Vector((0, 0, 1)))
self.label.draw(context)
self.line.draw(context)
def set_pos(self, pos_2d):
self.pos_2d = pos_2d
o = pos_2d
w = 0.5 * self.sensor_width
d = self.depth
c = d / 1.4242
s = w - c
p0 = o + Vector((s, w))
p1 = o + Vector((w, s))
p2 = o + Vector((c, 0))
p3 = o + Vector((w, -s))
p4 = o + Vector((s, -w))
p5 = o + Vector((0, -c))
p6 = o + Vector((-s, -w))
p7 = o + Vector((-w, -s))
p8 = o + Vector((-c, 0))
p9 = o + Vector((-w, s))
p10 = o + Vector((-s, w))
p11 = o + Vector((0, c))
self.branch_0.set_pos([p11, p0, p1, p2, o])
self.branch_1.set_pos([p2, p3, p4, p5, o])
self.branch_2.set_pos([p5, p6, p7, p8, o])
self.branch_3.set_pos([p8, p9, p10, p11, o])
def set_pos(self, context, pos_2d):
x, ty = self.text_size(context)
w = self.sensor_width
y = 12
pos_2d.y += y
pos_2d.x -= 0.5 * w
self.pos_2d = pos_2d.copy()
self.pos_3d = pos_2d.copy()
self.pos_3d.x += 6
self.sensor_height = y
p0 = pos_2d + Vector((w, -0.5 * y))
p1 = pos_2d + Vector((w, 1.5 * y))
p2 = pos_2d + Vector((0, 1.5 * y))
p3 = pos_2d + Vector((0, -0.5 * y))
self.bg.set_pos([p0, p2])
self.frame.set_pos([p0, p1, p2, p3])
self.cancel.set_pos(pos_2d + Vector((w + 15, 0.5 * y)))
def execute(self, context):
if context.mode == "OBJECT":
o = context.active_object
props = archipack_reference_point.datablock(o)
if props is None:
return {'CANCELLED'}
sel = [obj for obj in context.selected_objects if obj != o and obj.parent != o]
itM = o.matrix_world.inverted()
# print("parent_to_reference parenting:%s objects" % (len(sel)))
for child in sel:
rs = child.matrix_world.to_3x3().to_4x4()
loc = itM * child.matrix_world.translation
child.parent = None
child.matrix_parent_inverse.identity()
child.location = Vector((0, 0, 0))
child.parent = o
child.matrix_world = rs
child.location = loc
return {'FINISHED'}
else:
self.report({'WARNING'}, "Archipack: Option only valid in Object mode")
return {'CANCELLED'}
def interactive_hole(self, context, o):
hole_obj = self.find_hole(o)
if hole_obj is None:
m = bpy.data.meshes.new("hole")
hole_obj = bpy.data.objects.new("hole", m)
context.scene.objects.link(hole_obj)
hole_obj['archipack_hole'] = True
hole_obj.parent = o
hole_obj.matrix_world = o.matrix_world.copy()
MaterialUtils.add_wall2_materials(hole_obj)
hole = self.hole
v = Vector((0, 0, 0))
offset = Vector((0, -0.001, 0))
size = Vector((self.x + 2 * self.frame_x, self.z + self.frame_x + 0.001, self.y))
verts = hole.vertices(16, offset, v, v, size, v, 0, 0, shape_z=None, path_type='RECTANGLE')
faces = hole.faces(16, path_type='RECTANGLE')
matids = hole.mat(16, 0, 1, path_type='RECTANGLE')
uvs = hole.uv(16, v, v, size, v, 0, 0, 0, 0, path_type='RECTANGLE')
bmed.buildmesh(context, hole_obj, verts, faces, matids=matids, uvs=uvs)
return hole_obj
def robust_hole(self, context, tM):
hole = self.hole
m = bpy.data.meshes.new("hole")
o = bpy.data.objects.new("hole", m)
o['archipack_robusthole'] = True
context.scene.objects.link(o)
v = Vector((0, 0, 0))
offset = Vector((0, -0.001, 0))
size = Vector((self.x + 2 * self.frame_x, self.z + self.frame_x + 0.001, self.y))
verts = hole.vertices(16, offset, v, v, size, v, 0, 0, shape_z=None, path_type='RECTANGLE')
verts = [tM * Vector(v) for v in verts]
faces = hole.faces(16, path_type='RECTANGLE')
matids = hole.mat(16, 0, 1, path_type='RECTANGLE')
uvs = hole.uv(16, v, v, size, v, 0, 0, 0, 0, path_type='RECTANGLE')
bmed.buildmesh(context, o, verts, faces, matids=matids, uvs=uvs)
MaterialUtils.add_wall2_materials(o)
o.select = True
context.scene.objects.active = o
return o
def setup_user_defined_post(self, o, post_x, post_y, post_z):
self.user_defined_post = o
x = o.bound_box[6][0] - o.bound_box[0][0]
y = o.bound_box[6][1] - o.bound_box[0][1]
z = o.bound_box[6][2] - o.bound_box[0][2]
self.user_defined_post_scale = Vector((post_x / x, post_y / -y, post_z / z))
m = o.data
# create vertex group lookup dictionary for names
vgroup_names = {vgroup.index: vgroup.name for vgroup in o.vertex_groups}
# create dictionary of vertex group assignments per vertex
self.vertex_groups = [[vgroup_names[g.group] for g in v.groups] for v in m.vertices]
# uvs
uv_act = m.uv_layers.active
if uv_act is not None:
uv_layer = uv_act.data
self.user_defined_uvs = [[uv_layer[li].uv for li in p.loop_indices] for p in m.polygons]
else:
self.user_defined_uvs = [[(0, 0) for i in p.vertices] for p in m.polygons]
# material ids
self.user_defined_mat = [p.material_index for p in m.polygons]
def setup_manipulators(self):
if len(self.manipulators) == 0:
s = self.manipulators.add()
s.prop1_name = "width"
s = self.manipulators.add()
s.prop1_name = "height"
s.normal = Vector((0, 1, 0))
for i in range(self.n_parts):
p = self.parts[i]
n_manips = len(p.manipulators)
if n_manips < 1:
m = p.manipulators.add()
m.type_key = 'SIZE'
m.prop1_name = 'length'
def verts(self):
center, origin, size, radius = self.get_radius()
is_not_circle = self.shape != 'CIRCLE'
offset = Vector((0, self.altitude, 0))
verts = self.window.vertices(self.curve_steps, offset, center, origin,
size, radius, self.angle_y, 0, shape_z=None, path_type=self.shape)
if self.out_frame:
verts += self.frame.vertices(self.curve_steps, offset, center, origin,
size, radius, self.angle_y, 0, shape_z=None, path_type=self.shape)
if is_not_circle and self.out_tablet_enable:
verts += self.out_tablet.vertices(self.curve_steps, offset, center, origin,
Vector((size.x + 2 * self.out_tablet_x, size.y, size.z)),
radius, self.angle_y, 0, shape_z=None, path_type='HORIZONTAL')
if is_not_circle and self.in_tablet_enable:
verts += self.in_tablet.vertices(self.curve_steps, offset, center, origin,
Vector((size.x + 2 * (self.frame_x + self.in_tablet_x), size.y, size.z)),
radius, self.angle_y, 0, shape_z=None, path_type='HORIZONTAL')
if is_not_circle and self.blind_enable:
verts += self.blind.vertices(self.curve_steps, offset, center, origin,
Vector((-size.x, 0, 0)), radius, 0, 0, shape_z=None, path_type='HORIZONTAL')
return verts
def setup_manipulators(self):
if len(self.manipulators) == 4:
return
s = self.manipulators.add()
s.prop1_name = "x"
s.prop2_name = "x"
s.type_key = "SNAP_SIZE_LOC"
s = self.manipulators.add()
s.prop1_name = "y"
s.prop2_name = "y"
s.type_key = "SNAP_SIZE_LOC"
s = self.manipulators.add()
s.prop1_name = "z"
s.normal = Vector((0, 1, 0))
s = self.manipulators.add()
s.prop1_name = "altitude"
s.normal = Vector((0, 1, 0))
def get_radius(self):
"""
return center, origin, size, radius
"""
if self.shape == 'ROUND':
return self._get_round_radius()
elif self.shape == 'ELLIPSIS':
return self._get_ellipsis_radius()
elif self.shape == 'CIRCLE':
return self._get_circle_radius()
elif self.shape == 'QUADRI':
return self._get_quad_radius()
elif self.shape in ['TRIANGLE', 'PENTAGON']:
return self._get_tri_radius()
else:
return Vector((0, 0, 0)), Vector((0, 0, 0)), \
Vector((self.x, self.z, 0)), Vector((0, 0, 0))
def __init__(self, p=None, v=None, p0=None, p1=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 2d
both optionnals
"""
Projection.__init__(self)
if p is not None and v is not None:
self.p = Vector(p).to_2d()
self.v = Vector(v).to_2d()
elif p0 is not None and p1 is not None:
self.p = Vector(p0).to_2d()
self.v = Vector(p1).to_2d() - self.p
else:
self.p = Vector((0, 0))
self.v = Vector((0, 0))
def __init__(self, c, radius, a0, da):
"""
a0 and da arguments are in radians
c Vector 2d center
radius float radius
a0 radians start angle
da radians delta angle from start to end
a0 = 0 on the right side
a0 = pi on the left side
da > 0 CCW contrary-clockwise
da < 0 CW clockwise
stored internally as radians
"""
Circle.__init__(self, Vector(c).to_2d(), radius)
self.a0 = a0
self.da = da
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))
