mirror of
https://github.com/blender/blender-addons.git
synced 2025-08-20 13:22:58 +00:00
1309 lines
43 KiB
Python
1309 lines
43 KiB
Python
# SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
bl_info = {
|
|
"name": "Simple Curve",
|
|
"author": "Vladimir Spivak (cwolf3d)",
|
|
"version": (1, 6, 1),
|
|
"blender": (2, 80, 0),
|
|
"location": "View3D > Add > Curve",
|
|
"description": "Adds Simple Curve",
|
|
"warning": "",
|
|
"doc_url": "{BLENDER_MANUAL_URL}/addons/add_curve/extra_objects.html",
|
|
"category": "Add Curve",
|
|
}
|
|
|
|
|
|
# ------------------------------------------------------------
|
|
|
|
import bpy
|
|
from bpy_extras import object_utils
|
|
from bpy.types import (
|
|
Operator,
|
|
Menu,
|
|
Panel,
|
|
PropertyGroup,
|
|
)
|
|
from bpy.props import (
|
|
BoolProperty,
|
|
EnumProperty,
|
|
FloatProperty,
|
|
FloatVectorProperty,
|
|
IntProperty,
|
|
StringProperty,
|
|
PointerProperty,
|
|
)
|
|
from mathutils import (
|
|
Vector,
|
|
Matrix,
|
|
)
|
|
from math import (
|
|
sin, asin, sqrt,
|
|
acos, cos, pi,
|
|
radians, tan,
|
|
hypot,
|
|
)
|
|
# from bpy_extras.object_utils import *
|
|
|
|
|
|
# ------------------------------------------------------------
|
|
# Point:
|
|
|
|
def SimplePoint():
|
|
newpoints = []
|
|
|
|
newpoints.append([0.0, 0.0, 0.0])
|
|
|
|
return newpoints
|
|
|
|
|
|
# ------------------------------------------------------------
|
|
# Line:
|
|
|
|
def SimpleLine(c1=[0.0, 0.0, 0.0], c2=[2.0, 2.0, 2.0]):
|
|
newpoints = []
|
|
|
|
c3 = Vector(c2) - Vector(c1)
|
|
newpoints.append([0.0, 0.0, 0.0])
|
|
newpoints.append([c3[0], c3[1], c3[2]])
|
|
|
|
return newpoints
|
|
|
|
|
|
# ------------------------------------------------------------
|
|
# Angle:
|
|
|
|
def SimpleAngle(length=1.0, angle=45.0):
|
|
newpoints = []
|
|
|
|
angle = radians(angle)
|
|
newpoints.append([length, 0.0, 0.0])
|
|
newpoints.append([0.0, 0.0, 0.0])
|
|
newpoints.append([length * cos(angle), length * sin(angle), 0.0])
|
|
|
|
return newpoints
|
|
|
|
|
|
# ------------------------------------------------------------
|
|
# Distance:
|
|
|
|
def SimpleDistance(length=1.0, center=True):
|
|
newpoints = []
|
|
|
|
if center:
|
|
newpoints.append([-length / 2, 0.0, 0.0])
|
|
newpoints.append([length / 2, 0.0, 0.0])
|
|
else:
|
|
newpoints.append([0.0, 0.0, 0.0])
|
|
newpoints.append([length, 0.0, 0.0])
|
|
|
|
return newpoints
|
|
|
|
|
|
# ------------------------------------------------------------
|
|
# Circle:
|
|
|
|
def SimpleCircle(sides=4, radius=1.0):
|
|
newpoints = []
|
|
|
|
angle = radians(360) / sides
|
|
newpoints.append([radius, 0, 0])
|
|
if radius != 0 :
|
|
j = 1
|
|
while j < sides:
|
|
t = angle * j
|
|
x = cos(t) * radius
|
|
y = sin(t) * radius
|
|
newpoints.append([x, y, 0])
|
|
j += 1
|
|
|
|
return newpoints
|
|
|
|
|
|
# ------------------------------------------------------------
|
|
# Ellipse:
|
|
|
|
def SimpleEllipse(a=2.0, b=1.0):
|
|
newpoints = []
|
|
|
|
newpoints.append([a, 0.0, 0.0])
|
|
newpoints.append([0.0, b, 0.0])
|
|
newpoints.append([-a, 0.0, 0.0])
|
|
newpoints.append([0.0, -b, 0.0])
|
|
|
|
return newpoints
|
|
|
|
|
|
# ------------------------------------------------------------
|
|
# Arc:
|
|
|
|
def SimpleArc(sides=0, radius=1.0, startangle=0.0, endangle=45.0):
|
|
newpoints = []
|
|
|
|
startangle = radians(startangle)
|
|
endangle = radians(endangle)
|
|
sides += 1
|
|
|
|
angle = (endangle - startangle) / sides
|
|
x = cos(startangle) * radius
|
|
y = sin(startangle) * radius
|
|
newpoints.append([x, y, 0])
|
|
j = 1
|
|
while j < sides:
|
|
t = angle * j
|
|
x = cos(t + startangle) * radius
|
|
y = sin(t + startangle) * radius
|
|
newpoints.append([x, y, 0])
|
|
j += 1
|
|
x = cos(endangle) * radius
|
|
y = sin(endangle) * radius
|
|
newpoints.append([x, y, 0])
|
|
|
|
return newpoints
|
|
|
|
|
|
# ------------------------------------------------------------
|
|
# Sector:
|
|
|
|
def SimpleSector(sides=0, radius=1.0, startangle=0.0, endangle=45.0):
|
|
newpoints = []
|
|
|
|
startangle = radians(startangle)
|
|
endangle = radians(endangle)
|
|
sides += 1
|
|
|
|
newpoints.append([0, 0, 0])
|
|
angle = (endangle - startangle) / sides
|
|
x = cos(startangle) * radius
|
|
y = sin(startangle) * radius
|
|
newpoints.append([x, y, 0])
|
|
j = 1
|
|
while j < sides:
|
|
t = angle * j
|
|
x = cos(t + startangle) * radius
|
|
y = sin(t + startangle) * radius
|
|
newpoints.append([x, y, 0])
|
|
j += 1
|
|
x = cos(endangle) * radius
|
|
y = sin(endangle) * radius
|
|
newpoints.append([x, y, 0])
|
|
|
|
return newpoints
|
|
|
|
|
|
# ------------------------------------------------------------
|
|
# Segment:
|
|
|
|
def SimpleSegment(sides=0, a=2.0, b=1.0, startangle=0.0, endangle=45.0):
|
|
newpoints = []
|
|
|
|
startangle = radians(startangle)
|
|
endangle = radians(endangle)
|
|
sides += 1
|
|
|
|
angle = (endangle - startangle) / sides
|
|
x = cos(startangle) * a
|
|
y = sin(startangle) * a
|
|
newpoints.append([x, y, 0])
|
|
j = 1
|
|
while j < sides:
|
|
t = angle * j
|
|
x = cos(t + startangle) * a
|
|
y = sin(t + startangle) * a
|
|
newpoints.append([x, y, 0])
|
|
j += 1
|
|
x = cos(endangle) * a
|
|
y = sin(endangle) * a
|
|
newpoints.append([x, y, 0])
|
|
|
|
x = cos(endangle) * b
|
|
y = sin(endangle) * b
|
|
newpoints.append([x, y, 0])
|
|
j = sides - 1
|
|
while j > 0:
|
|
t = angle * j
|
|
x = cos(t + startangle) * b
|
|
y = sin(t + startangle) * b
|
|
newpoints.append([x, y, 0])
|
|
j -= 1
|
|
x = cos(startangle) * b
|
|
y = sin(startangle) * b
|
|
newpoints.append([x, y, 0])
|
|
|
|
return newpoints
|
|
|
|
|
|
# ------------------------------------------------------------
|
|
# Rectangle:
|
|
|
|
def SimpleRectangle(width=2.0, length=2.0, rounded=0.0, center=True):
|
|
newpoints = []
|
|
|
|
r = rounded / 2
|
|
|
|
if center:
|
|
x = width / 2
|
|
y = length / 2
|
|
if rounded != 0.0:
|
|
newpoints.append([-x + r, y, 0.0])
|
|
newpoints.append([x - r, y, 0.0])
|
|
newpoints.append([x, y - r, 0.0])
|
|
newpoints.append([x, -y + r, 0.0])
|
|
newpoints.append([x - r, -y, 0.0])
|
|
newpoints.append([-x + r, -y, 0.0])
|
|
newpoints.append([-x, -y + r, 0.0])
|
|
newpoints.append([-x, y - r, 0.0])
|
|
else:
|
|
newpoints.append([-x, y, 0.0])
|
|
newpoints.append([x, y, 0.0])
|
|
newpoints.append([x, -y, 0.0])
|
|
newpoints.append([-x, -y, 0.0])
|
|
|
|
else:
|
|
x = width
|
|
y = length
|
|
if rounded != 0.0:
|
|
newpoints.append([r, y, 0.0])
|
|
newpoints.append([x - r, y, 0.0])
|
|
newpoints.append([x, y - r, 0.0])
|
|
newpoints.append([x, r, 0.0])
|
|
newpoints.append([x - r, 0.0, 0.0])
|
|
newpoints.append([r, 0.0, 0.0])
|
|
newpoints.append([0.0, r, 0.0])
|
|
newpoints.append([0.0, y - r, 0.0])
|
|
else:
|
|
newpoints.append([0.0, 0.0, 0.0])
|
|
newpoints.append([0.0, y, 0.0])
|
|
newpoints.append([x, y, 0.0])
|
|
newpoints.append([x, 0.0, 0.0])
|
|
|
|
return newpoints
|
|
|
|
|
|
# ------------------------------------------------------------
|
|
# Rhomb:
|
|
|
|
def SimpleRhomb(width=2.0, length=2.0, center=True):
|
|
newpoints = []
|
|
x = width / 2
|
|
y = length / 2
|
|
|
|
if center:
|
|
newpoints.append([-x, 0.0, 0.0])
|
|
newpoints.append([0.0, y, 0.0])
|
|
newpoints.append([x, 0.0, 0.0])
|
|
newpoints.append([0.0, -y, 0.0])
|
|
else:
|
|
newpoints.append([x, 0.0, 0.0])
|
|
newpoints.append([0.0, y, 0.0])
|
|
newpoints.append([x, length, 0.0])
|
|
newpoints.append([width, y, 0.0])
|
|
|
|
return newpoints
|
|
|
|
|
|
# ------------------------------------------------------------
|
|
# Polygon:
|
|
|
|
def SimplePolygon(sides=3, radius=1.0):
|
|
newpoints = []
|
|
angle = radians(360.0) / sides
|
|
j = 0
|
|
|
|
while j < sides:
|
|
t = angle * j
|
|
x = sin(t) * radius
|
|
y = cos(t) * radius
|
|
newpoints.append([x, y, 0.0])
|
|
j += 1
|
|
|
|
return newpoints
|
|
|
|
|
|
# ------------------------------------------------------------
|
|
# Polygon_ab:
|
|
|
|
def SimplePolygon_ab(sides=3, a=2.0, b=1.0):
|
|
newpoints = []
|
|
angle = radians(360.0) / sides
|
|
j = 0
|
|
|
|
while j < sides:
|
|
t = angle * j
|
|
x = sin(t) * a
|
|
y = cos(t) * b
|
|
newpoints.append([x, y, 0.0])
|
|
j += 1
|
|
|
|
return newpoints
|
|
|
|
|
|
# ------------------------------------------------------------
|
|
# Trapezoid:
|
|
|
|
def SimpleTrapezoid(a=2.0, b=1.0, h=1.0, center=True):
|
|
newpoints = []
|
|
x = a / 2
|
|
y = b / 2
|
|
r = h / 2
|
|
|
|
if center:
|
|
newpoints.append([-x, -r, 0.0])
|
|
newpoints.append([-y, r, 0.0])
|
|
newpoints.append([y, r, 0.0])
|
|
newpoints.append([x, -r, 0.0])
|
|
|
|
else:
|
|
newpoints.append([0.0, 0.0, 0.0])
|
|
newpoints.append([x - y, h, 0.0])
|
|
newpoints.append([x + y, h, 0.0])
|
|
newpoints.append([a, 0.0, 0.0])
|
|
|
|
return newpoints
|
|
|
|
|
|
# ------------------------------------------------------------
|
|
# get array of vertcoordinates according to splinetype
|
|
def vertsToPoints(Verts, splineType):
|
|
|
|
# main vars
|
|
vertArray = []
|
|
|
|
# array for BEZIER spline output (V3)
|
|
if splineType == 'BEZIER':
|
|
for v in Verts:
|
|
vertArray += v
|
|
|
|
# array for nonBEZIER output (V4)
|
|
else:
|
|
for v in Verts:
|
|
vertArray += v
|
|
if splineType == 'NURBS':
|
|
# for nurbs w=1
|
|
vertArray.append(1)
|
|
else:
|
|
# for poly w=0
|
|
vertArray.append(0)
|
|
return vertArray
|
|
|
|
|
|
# ------------------------------------------------------------
|
|
# Main Function
|
|
|
|
def main(context, self, use_enter_edit_mode):
|
|
# output splineType 'POLY' 'NURBS' 'BEZIER'
|
|
splineType = self.outputType
|
|
|
|
sides = abs(int((self.Simple_endangle - self.Simple_startangle) / 90))
|
|
|
|
# get verts
|
|
if self.Simple_Type == 'Point':
|
|
verts = SimplePoint()
|
|
|
|
if self.Simple_Type == 'Line':
|
|
verts = SimpleLine(self.location, self.Simple_endlocation)
|
|
|
|
if self.Simple_Type == 'Distance':
|
|
verts = SimpleDistance(self.Simple_length, self.Simple_center)
|
|
|
|
if self.Simple_Type == 'Angle':
|
|
verts = SimpleAngle(self.Simple_length, self.Simple_angle)
|
|
|
|
if self.Simple_Type == 'Circle':
|
|
if self.Simple_sides < 4:
|
|
self.Simple_sides = 4
|
|
if self.Simple_radius == 0:
|
|
return {'FINISHED'}
|
|
verts = SimpleCircle(self.Simple_sides, self.Simple_radius)
|
|
|
|
if self.Simple_Type == 'Ellipse':
|
|
verts = SimpleEllipse(self.Simple_a, self.Simple_b)
|
|
|
|
if self.Simple_Type == 'Arc':
|
|
if self.Simple_sides < sides:
|
|
self.Simple_sides = sides
|
|
if self.Simple_radius == 0:
|
|
return {'FINISHED'}
|
|
verts = SimpleArc(
|
|
self.Simple_sides, self.Simple_radius,
|
|
self.Simple_startangle, self.Simple_endangle
|
|
)
|
|
|
|
if self.Simple_Type == 'Sector':
|
|
if self.Simple_sides < sides:
|
|
self.Simple_sides = sides
|
|
if self.Simple_radius == 0:
|
|
return {'FINISHED'}
|
|
verts = SimpleSector(
|
|
self.Simple_sides, self.Simple_radius,
|
|
self.Simple_startangle, self.Simple_endangle
|
|
)
|
|
|
|
if self.Simple_Type == 'Segment':
|
|
if self.Simple_sides < sides:
|
|
self.Simple_sides = sides
|
|
if self.Simple_a == 0 or self.Simple_b == 0 or self.Simple_a == self.Simple_b:
|
|
return {'FINISHED'}
|
|
if self.Simple_a > self.Simple_b:
|
|
verts = SimpleSegment(
|
|
self.Simple_sides, self.Simple_a, self.Simple_b,
|
|
self.Simple_startangle, self.Simple_endangle
|
|
)
|
|
if self.Simple_a < self.Simple_b:
|
|
verts = SimpleSegment(
|
|
self.Simple_sides, self.Simple_b, self.Simple_a,
|
|
self.Simple_startangle, self.Simple_endangle
|
|
)
|
|
|
|
if self.Simple_Type == 'Rectangle':
|
|
verts = SimpleRectangle(
|
|
self.Simple_width, self.Simple_length,
|
|
self.Simple_rounded, self.Simple_center
|
|
)
|
|
|
|
if self.Simple_Type == 'Rhomb':
|
|
verts = SimpleRhomb(
|
|
self.Simple_width, self.Simple_length, self.Simple_center
|
|
)
|
|
|
|
if self.Simple_Type == 'Polygon':
|
|
if self.Simple_sides < 3:
|
|
self.Simple_sides = 3
|
|
verts = SimplePolygon(
|
|
self.Simple_sides, self.Simple_radius
|
|
)
|
|
|
|
if self.Simple_Type == 'Polygon_ab':
|
|
if self.Simple_sides < 3:
|
|
self.Simple_sides = 3
|
|
verts = SimplePolygon_ab(
|
|
self.Simple_sides, self.Simple_a, self.Simple_b
|
|
)
|
|
|
|
if self.Simple_Type == 'Trapezoid':
|
|
verts = SimpleTrapezoid(
|
|
self.Simple_a, self.Simple_b, self.Simple_h, self.Simple_center
|
|
)
|
|
|
|
# turn verts into array
|
|
vertArray = vertsToPoints(verts, splineType)
|
|
|
|
# create object
|
|
if bpy.context.mode == 'EDIT_CURVE':
|
|
|
|
Curve = context.active_object
|
|
newSpline = Curve.data.splines.new(type=splineType) # spline
|
|
else:
|
|
name = self.Simple_Type # Type as name
|
|
|
|
dataCurve = bpy.data.curves.new(name, type='CURVE') # curve data block
|
|
newSpline = dataCurve.splines.new(type=splineType) # spline
|
|
|
|
# create object with new Curve
|
|
Curve = object_utils.object_data_add(context, dataCurve, operator=self) # place in active scene
|
|
Curve.select_set(True)
|
|
|
|
for spline in Curve.data.splines:
|
|
if spline.type == 'BEZIER':
|
|
for point in spline.bezier_points:
|
|
point.select_control_point = False
|
|
point.select_left_handle = False
|
|
point.select_right_handle = False
|
|
else:
|
|
for point in spline.points:
|
|
point.select = False
|
|
|
|
# create spline from vertarray
|
|
all_points = []
|
|
if splineType == 'BEZIER':
|
|
newSpline.bezier_points.add(int(len(vertArray) * 0.33))
|
|
newSpline.bezier_points.foreach_set('co', vertArray)
|
|
for point in newSpline.bezier_points:
|
|
point.handle_right_type = self.handleType
|
|
point.handle_left_type = self.handleType
|
|
point.select_control_point = True
|
|
point.select_left_handle = True
|
|
point.select_right_handle = True
|
|
all_points.append(point)
|
|
else:
|
|
newSpline.points.add(int(len(vertArray) * 0.25 - 1))
|
|
newSpline.points.foreach_set('co', vertArray)
|
|
newSpline.use_endpoint_u = True
|
|
for point in newSpline.points:
|
|
all_points.append(point)
|
|
point.select = True
|
|
|
|
n = len(all_points)
|
|
|
|
d = 2 * 0.27606262
|
|
|
|
if splineType == 'BEZIER':
|
|
if self.Simple_Type == 'Circle' or self.Simple_Type == 'Arc' or \
|
|
self.Simple_Type == 'Sector' or self.Simple_Type == 'Segment' or \
|
|
self.Simple_Type == 'Ellipse':
|
|
|
|
for p in all_points:
|
|
p.handle_right_type = 'FREE'
|
|
p.handle_left_type = 'FREE'
|
|
|
|
if self.Simple_Type == 'Circle':
|
|
i = 0
|
|
for p1 in all_points:
|
|
if i != (n - 1):
|
|
p2 = all_points[i + 1]
|
|
u1 = asin(p1.co.y / self.Simple_radius)
|
|
u2 = asin(p2.co.y / self.Simple_radius)
|
|
if p1.co.x > 0 and p2.co.x < 0:
|
|
u1 = acos(p1.co.x / self.Simple_radius)
|
|
u2 = acos(p2.co.x / self.Simple_radius)
|
|
elif p1.co.x < 0 and p2.co.x > 0:
|
|
u1 = acos(p1.co.x / self.Simple_radius)
|
|
u2 = acos(p2.co.x / self.Simple_radius)
|
|
u = u2 - u1
|
|
if u < 0:
|
|
u = -u
|
|
l = 4 / 3 * tan(1 / 4 * u) * self.Simple_radius
|
|
v1 = Vector((-p1.co.y, p1.co.x, 0))
|
|
v1.normalize()
|
|
v2 = Vector((-p2.co.y, p2.co.x, 0))
|
|
v2.normalize()
|
|
vh1 = v1 * l
|
|
vh2 = v2 * l
|
|
v1 = Vector((p1.co.x, p1.co.y, 0)) + vh1
|
|
v2 = Vector((p2.co.x, p2.co.y, 0)) - vh2
|
|
p1.handle_right = v1
|
|
p2.handle_left = v2
|
|
if i == (n - 1):
|
|
p2 = all_points[0]
|
|
u1 = asin(p1.co.y / self.Simple_radius)
|
|
u2 = asin(p2.co.y / self.Simple_radius)
|
|
if p1.co.x > 0 and p2.co.x < 0:
|
|
u1 = acos(p1.co.x / self.Simple_radius)
|
|
u2 = acos(p2.co.x / self.Simple_radius)
|
|
elif p1.co.x < 0 and p2.co.x > 0:
|
|
u1 = acos(p1.co.x / self.Simple_radius)
|
|
u2 = acos(p2.co.x / self.Simple_radius)
|
|
u = u2 - u1
|
|
if u < 0:
|
|
u = -u
|
|
l = 4 / 3 * tan(1 / 4 * u) * self.Simple_radius
|
|
v1 = Vector((-p1.co.y, p1.co.x, 0))
|
|
v1.normalize()
|
|
v2 = Vector((-p2.co.y, p2.co.x, 0))
|
|
v2.normalize()
|
|
vh1 = v1 * l
|
|
vh2 = v2 * l
|
|
v1 = Vector((p1.co.x, p1.co.y, 0)) + vh1
|
|
v2 = Vector((p2.co.x, p2.co.y, 0)) - vh2
|
|
p1.handle_right = v1
|
|
p2.handle_left = v2
|
|
i += 1
|
|
|
|
if self.Simple_Type == 'Ellipse':
|
|
all_points[0].handle_right = Vector((self.Simple_a, self.Simple_b * d, 0))
|
|
all_points[0].handle_left = Vector((self.Simple_a, -self.Simple_b * d, 0))
|
|
all_points[1].handle_right = Vector((-self.Simple_a * d, self.Simple_b, 0))
|
|
all_points[1].handle_left = Vector((self.Simple_a * d, self.Simple_b, 0))
|
|
all_points[2].handle_right = Vector((-self.Simple_a, -self.Simple_b * d, 0))
|
|
all_points[2].handle_left = Vector((-self.Simple_a, self.Simple_b * d, 0))
|
|
all_points[3].handle_right = Vector((self.Simple_a * d, -self.Simple_b, 0))
|
|
all_points[3].handle_left = Vector((-self.Simple_a * d, -self.Simple_b, 0))
|
|
|
|
if self.Simple_Type == 'Arc':
|
|
i = 0
|
|
for p1 in all_points:
|
|
if i != (n - 1):
|
|
p2 = all_points[i + 1]
|
|
u1 = asin(p1.co.y / self.Simple_radius)
|
|
u2 = asin(p2.co.y / self.Simple_radius)
|
|
if p1.co.x > 0 and p2.co.x < 0:
|
|
u1 = acos(p1.co.x / self.Simple_radius)
|
|
u2 = acos(p2.co.x / self.Simple_radius)
|
|
elif p1.co.x < 0 and p2.co.x > 0:
|
|
u1 = acos(p1.co.x / self.Simple_radius)
|
|
u2 = acos(p2.co.x / self.Simple_radius)
|
|
u = u2 - u1
|
|
if u < 0:
|
|
u = -u
|
|
l = 4 / 3 * tan(1 / 4 * u) * self.Simple_radius
|
|
v1 = Vector((-p1.co.y, p1.co.x, 0))
|
|
v1.normalize()
|
|
v2 = Vector((-p2.co.y, p2.co.x, 0))
|
|
v2.normalize()
|
|
vh1 = v1 * l
|
|
vh2 = v2 * l
|
|
if self.Simple_startangle < self.Simple_endangle:
|
|
v1 = Vector((p1.co.x, p1.co.y, 0)) + vh1
|
|
v2 = Vector((p2.co.x, p2.co.y, 0)) - vh2
|
|
p1.handle_right = v1
|
|
p2.handle_left = v2
|
|
else:
|
|
v1 = Vector((p1.co.x, p1.co.y, 0)) - vh1
|
|
v2 = Vector((p2.co.x, p2.co.y, 0)) + vh2
|
|
p1.handle_right = v1
|
|
p2.handle_left = v2
|
|
i += 1
|
|
all_points[0].handle_left_type = 'VECTOR'
|
|
all_points[-1].handle_right_type = 'VECTOR'
|
|
|
|
if self.Simple_Type == 'Sector':
|
|
i = 0
|
|
for p1 in all_points:
|
|
if i == 0:
|
|
p1.handle_right_type = 'VECTOR'
|
|
p1.handle_left_type = 'VECTOR'
|
|
elif i != (n - 1):
|
|
p2 = all_points[i + 1]
|
|
u1 = asin(p1.co.y / self.Simple_radius)
|
|
u2 = asin(p2.co.y / self.Simple_radius)
|
|
if p1.co.x > 0 and p2.co.x < 0:
|
|
u1 = acos(p1.co.x / self.Simple_radius)
|
|
u2 = acos(p2.co.x / self.Simple_radius)
|
|
elif p1.co.x < 0 and p2.co.x > 0:
|
|
u1 = acos(p1.co.x / self.Simple_radius)
|
|
u2 = acos(p2.co.x / self.Simple_radius)
|
|
u = u2 - u1
|
|
if u < 0:
|
|
u = -u
|
|
l = 4 / 3 * tan(1 / 4 * u) * self.Simple_radius
|
|
v1 = Vector((-p1.co.y, p1.co.x, 0))
|
|
v1.normalize()
|
|
v2 = Vector((-p2.co.y, p2.co.x, 0))
|
|
v2.normalize()
|
|
vh1 = v1 * l
|
|
vh2 = v2 * l
|
|
if self.Simple_startangle < self.Simple_endangle:
|
|
v1 = Vector((p1.co.x, p1.co.y, 0)) + vh1
|
|
v2 = Vector((p2.co.x, p2.co.y, 0)) - vh2
|
|
p1.handle_right = v1
|
|
p2.handle_left = v2
|
|
else:
|
|
v1 = Vector((p1.co.x, p1.co.y, 0)) - vh1
|
|
v2 = Vector((p2.co.x, p2.co.y, 0)) + vh2
|
|
p1.handle_right = v1
|
|
p2.handle_left = v2
|
|
i += 1
|
|
all_points[0].handle_left_type = 'VECTOR'
|
|
all_points[0].handle_right_type = 'VECTOR'
|
|
all_points[1].handle_left_type = 'VECTOR'
|
|
all_points[-1].handle_right_type = 'VECTOR'
|
|
|
|
if self.Simple_Type == 'Segment':
|
|
i = 0
|
|
if self.Simple_a > self.Simple_b:
|
|
Segment_a = self.Simple_a
|
|
Segment_b = self.Simple_b
|
|
if self.Simple_a < self.Simple_b:
|
|
Segment_b = self.Simple_a
|
|
Segment_a = self.Simple_b
|
|
for p1 in all_points:
|
|
if i < (n / 2 - 1):
|
|
p2 = all_points[i + 1]
|
|
u1 = asin(p1.co.y / Segment_a)
|
|
u2 = asin(p2.co.y / Segment_a)
|
|
if p1.co.x > 0 and p2.co.x < 0:
|
|
u1 = acos(p1.co.x / Segment_a)
|
|
u2 = acos(p2.co.x / Segment_a)
|
|
elif p1.co.x < 0 and p2.co.x > 0:
|
|
u1 = acos(p1.co.x / Segment_a)
|
|
u2 = acos(p2.co.x / Segment_a)
|
|
u = u2 - u1
|
|
if u < 0:
|
|
u = -u
|
|
l = 4 / 3 * tan(1 / 4 * u) * Segment_a
|
|
v1 = Vector((-p1.co.y, p1.co.x, 0))
|
|
v1.normalize()
|
|
v2 = Vector((-p2.co.y, p2.co.x, 0))
|
|
v2.normalize()
|
|
vh1 = v1 * l
|
|
vh2 = v2 * l
|
|
if self.Simple_startangle < self.Simple_endangle:
|
|
v1 = Vector((p1.co.x, p1.co.y, 0)) + vh1
|
|
v2 = Vector((p2.co.x, p2.co.y, 0)) - vh2
|
|
p1.handle_right = v1
|
|
p2.handle_left = v2
|
|
else:
|
|
v1 = Vector((p1.co.x, p1.co.y, 0)) - vh1
|
|
v2 = Vector((p2.co.x, p2.co.y, 0)) + vh2
|
|
p1.handle_right = v1
|
|
p2.handle_left = v2
|
|
elif i != (n / 2 - 1) and i != (n - 1):
|
|
p2 = all_points[i + 1]
|
|
u1 = asin(p1.co.y / Segment_b)
|
|
u2 = asin(p2.co.y / Segment_b)
|
|
if p1.co.x > 0 and p2.co.x < 0:
|
|
u1 = acos(p1.co.x / Segment_b)
|
|
u2 = acos(p2.co.x / Segment_b)
|
|
elif p1.co.x < 0 and p2.co.x > 0:
|
|
u1 = acos(p1.co.x / Segment_b)
|
|
u2 = acos(p2.co.x / Segment_b)
|
|
u = u2 - u1
|
|
if u < 0:
|
|
u = -u
|
|
l = 4 / 3 * tan(1 / 4 * u) * Segment_b
|
|
v1 = Vector((-p1.co.y, p1.co.x, 0))
|
|
v1.normalize()
|
|
v2 = Vector((-p2.co.y, p2.co.x, 0))
|
|
v2.normalize()
|
|
vh1 = v1 * l
|
|
vh2 = v2 * l
|
|
if self.Simple_startangle < self.Simple_endangle:
|
|
v1 = Vector((p1.co.x, p1.co.y, 0)) - vh1
|
|
v2 = Vector((p2.co.x, p2.co.y, 0)) + vh2
|
|
p1.handle_right = v1
|
|
p2.handle_left = v2
|
|
else:
|
|
v1 = Vector((p1.co.x, p1.co.y, 0)) + vh1
|
|
v2 = Vector((p2.co.x, p2.co.y, 0)) - vh2
|
|
p1.handle_right = v1
|
|
p2.handle_left = v2
|
|
|
|
i += 1
|
|
all_points[0].handle_left_type = 'VECTOR'
|
|
all_points[n - 1].handle_right_type = 'VECTOR'
|
|
all_points[int(n / 2) - 1].handle_right_type = 'VECTOR'
|
|
all_points[int(n / 2)].handle_left_type = 'VECTOR'
|
|
|
|
# set newSpline Options
|
|
newSpline.use_cyclic_u = self.use_cyclic_u
|
|
newSpline.use_endpoint_u = self.endp_u
|
|
newSpline.order_u = self.order_u
|
|
|
|
# set curve Options
|
|
Curve.data.dimensions = self.shape
|
|
Curve.data.use_path = True
|
|
if self.shape == '3D':
|
|
Curve.data.fill_mode = 'FULL'
|
|
else:
|
|
Curve.data.fill_mode = 'BOTH'
|
|
|
|
# move and rotate spline in edit mode
|
|
if bpy.context.mode == 'EDIT_CURVE':
|
|
if self.align == "WORLD":
|
|
location = self.location - context.active_object.location
|
|
bpy.ops.transform.translate(value = location, orient_type='GLOBAL')
|
|
bpy.ops.transform.rotate(value = self.rotation[0], orient_axis = 'X', orient_type='GLOBAL')
|
|
bpy.ops.transform.rotate(value = self.rotation[1], orient_axis = 'Y', orient_type='GLOBAL')
|
|
bpy.ops.transform.rotate(value = self.rotation[2], orient_axis = 'Z', orient_type='GLOBAL')
|
|
|
|
elif self.align == "VIEW":
|
|
bpy.ops.transform.translate(value = self.location)
|
|
bpy.ops.transform.rotate(value = self.rotation[0], orient_axis = 'X')
|
|
bpy.ops.transform.rotate(value = self.rotation[1], orient_axis = 'Y')
|
|
bpy.ops.transform.rotate(value = self.rotation[2], orient_axis = 'Z')
|
|
|
|
elif self.align == "CURSOR":
|
|
location = context.active_object.location
|
|
self.location = bpy.context.scene.cursor.location - location
|
|
self.rotation = bpy.context.scene.cursor.rotation_euler
|
|
|
|
bpy.ops.transform.translate(value = self.location)
|
|
bpy.ops.transform.rotate(value = self.rotation[0], orient_axis = 'X')
|
|
bpy.ops.transform.rotate(value = self.rotation[1], orient_axis = 'Y')
|
|
bpy.ops.transform.rotate(value = self.rotation[2], orient_axis = 'Z')
|
|
|
|
|
|
def menu(self, context):
|
|
oper1 = self.layout.operator(Simple.bl_idname, text="Angle", icon="DRIVER_ROTATIONAL_DIFFERENCE")
|
|
oper1.Simple_Type = "Angle"
|
|
oper1.use_cyclic_u = False
|
|
|
|
oper2 = self.layout.operator(Simple.bl_idname, text="Arc", icon="MOD_THICKNESS")
|
|
oper2.Simple_Type = "Arc"
|
|
oper2.use_cyclic_u = False
|
|
|
|
oper3 = self.layout.operator(Simple.bl_idname, text="Circle", icon="ANTIALIASED")
|
|
oper3.Simple_Type = "Circle"
|
|
oper3.use_cyclic_u = True
|
|
|
|
oper4 = self.layout.operator(Simple.bl_idname, text="Distance", icon="DRIVER_DISTANCE")
|
|
oper4.Simple_Type = "Distance"
|
|
oper4.use_cyclic_u = False
|
|
|
|
oper5 = self.layout.operator(Simple.bl_idname, text="Ellipse", icon="MESH_TORUS")
|
|
oper5.Simple_Type = "Ellipse"
|
|
oper5.use_cyclic_u = True
|
|
|
|
oper6 = self.layout.operator(Simple.bl_idname, text="Line", icon="MOD_SIMPLIFY")
|
|
oper6.Simple_Type = "Line"
|
|
oper6.use_cyclic_u = False
|
|
oper6.shape = '3D'
|
|
|
|
oper7 = self.layout.operator(Simple.bl_idname, text="Point", icon="LAYER_ACTIVE")
|
|
oper7.Simple_Type = "Point"
|
|
oper7.use_cyclic_u = False
|
|
|
|
oper8 = self.layout.operator(Simple.bl_idname, text="Polygon", icon="SEQ_CHROMA_SCOPE")
|
|
oper8.Simple_Type = "Polygon"
|
|
oper8.use_cyclic_u = True
|
|
|
|
oper9 = self.layout.operator(Simple.bl_idname, text="Polygon ab", icon="SEQ_CHROMA_SCOPE")
|
|
oper9.Simple_Type = "Polygon_ab"
|
|
oper9.use_cyclic_u = True
|
|
|
|
oper10 = self.layout.operator(Simple.bl_idname, text="Rectangle", icon="MESH_PLANE")
|
|
oper10.Simple_Type = "Rectangle"
|
|
oper10.use_cyclic_u = True
|
|
|
|
oper11 = self.layout.operator(Simple.bl_idname, text="Rhomb", icon="DECORATE_ANIMATE")
|
|
oper11.Simple_Type = "Rhomb"
|
|
oper11.use_cyclic_u = True
|
|
|
|
oper12 = self.layout.operator(Simple.bl_idname, text="Sector", icon="CON_SHRINKWRAP")
|
|
oper12.Simple_Type = "Sector"
|
|
oper12.use_cyclic_u = True
|
|
|
|
oper13 = self.layout.operator(Simple.bl_idname, text="Segment", icon="MOD_SIMPLEDEFORM")
|
|
oper13.Simple_Type = "Segment"
|
|
oper13.use_cyclic_u = True
|
|
|
|
oper14 = self.layout.operator(Simple.bl_idname, text="Trapezoid", icon="MOD_EDGESPLIT")
|
|
oper14.Simple_Type = "Trapezoid"
|
|
oper14.use_cyclic_u = True
|
|
|
|
# ------------------------------------------------------------
|
|
# Simple operator
|
|
|
|
class Simple(Operator, object_utils.AddObjectHelper):
|
|
bl_idname = "curve.simple"
|
|
bl_label = "Simple Curve"
|
|
bl_description = "Construct a Simple Curve"
|
|
bl_options = {'REGISTER', 'UNDO', 'PRESET'}
|
|
|
|
# change properties
|
|
Simple : BoolProperty(
|
|
name="Simple",
|
|
default=True,
|
|
description="Simple Curve"
|
|
)
|
|
Simple_Change : BoolProperty(
|
|
name="Change",
|
|
default=False,
|
|
description="Change Simple Curve"
|
|
)
|
|
Simple_Delete : StringProperty(
|
|
name="Delete",
|
|
description="Delete Simple Curve"
|
|
)
|
|
# general properties
|
|
Types = [('Point', "Point", "Construct a Point"),
|
|
('Line', "Line", "Construct a Line"),
|
|
('Distance', "Distance", "Construct a two point Distance"),
|
|
('Angle', "Angle", "Construct an Angle"),
|
|
('Circle', "Circle", "Construct a Circle"),
|
|
('Ellipse', "Ellipse", "Construct an Ellipse"),
|
|
('Arc', "Arc", "Construct an Arc"),
|
|
('Sector', "Sector", "Construct a Sector"),
|
|
('Segment', "Segment", "Construct a Segment"),
|
|
('Rectangle', "Rectangle", "Construct a Rectangle"),
|
|
('Rhomb', "Rhomb", "Construct a Rhomb"),
|
|
('Polygon', "Polygon", "Construct a Polygon"),
|
|
('Polygon_ab', "Polygon ab", "Construct a Polygon ab"),
|
|
('Trapezoid', "Trapezoid", "Construct a Trapezoid")
|
|
]
|
|
Simple_Type : EnumProperty(
|
|
name="Type",
|
|
description="Form of Curve to create",
|
|
items=Types
|
|
)
|
|
# Line properties
|
|
Simple_endlocation : FloatVectorProperty(
|
|
name="",
|
|
description="End location",
|
|
default=(2.0, 2.0, 2.0),
|
|
subtype='TRANSLATION'
|
|
)
|
|
# Trapezoid properties
|
|
Simple_a : FloatProperty(
|
|
name="Side a",
|
|
default=2.0,
|
|
min=0.0, soft_min=0.0,
|
|
unit='LENGTH',
|
|
description="a side Value"
|
|
)
|
|
Simple_b : FloatProperty(
|
|
name="Side b",
|
|
default=1.0,
|
|
min=0.0, soft_min=0.0,
|
|
unit='LENGTH',
|
|
description="b side Value"
|
|
)
|
|
Simple_h : FloatProperty(
|
|
name="Height",
|
|
default=1.0,
|
|
unit='LENGTH',
|
|
description="Height of the Trapezoid - distance between a and b"
|
|
)
|
|
Simple_angle : FloatProperty(
|
|
name="Angle",
|
|
default=45.0,
|
|
description="Angle"
|
|
)
|
|
Simple_startangle : FloatProperty(
|
|
name="Start angle",
|
|
default=0.0,
|
|
min=-360.0, soft_min=-360.0,
|
|
max=360.0, soft_max=360.0,
|
|
description="Start angle"
|
|
)
|
|
Simple_endangle : FloatProperty(
|
|
name="End angle",
|
|
default=45.0,
|
|
min=-360.0, soft_min=-360.0,
|
|
max=360.0, soft_max=360.0,
|
|
description="End angle"
|
|
)
|
|
Simple_sides : IntProperty(
|
|
name="Sides",
|
|
default=3,
|
|
min=0, soft_min=0,
|
|
description="Sides"
|
|
)
|
|
Simple_radius : FloatProperty(
|
|
name="Radius",
|
|
default=1.0,
|
|
min=0.0, soft_min=0.0,
|
|
unit='LENGTH',
|
|
description="Radius"
|
|
)
|
|
Simple_center : BoolProperty(
|
|
name="Length center",
|
|
default=True,
|
|
description="Length center"
|
|
)
|
|
|
|
Angle_types = [('Degrees', "Degrees", "Use Degrees"),
|
|
('Radians', "Radians", "Use Radians")]
|
|
Simple_degrees_or_radians : EnumProperty(
|
|
name="Degrees or radians",
|
|
description="Degrees or radians",
|
|
items=Angle_types
|
|
)
|
|
# Rectangle properties
|
|
Simple_width : FloatProperty(
|
|
name="Width",
|
|
default=2.0,
|
|
min=0.0, soft_min=0,
|
|
unit='LENGTH',
|
|
description="Width"
|
|
)
|
|
Simple_length : FloatProperty(
|
|
name="Length",
|
|
default=2.0,
|
|
min=0.0, soft_min=0.0,
|
|
unit='LENGTH',
|
|
description="Length"
|
|
)
|
|
Simple_rounded : FloatProperty(
|
|
name="Rounded",
|
|
default=0.0,
|
|
min=0.0, soft_min=0.0,
|
|
unit='LENGTH',
|
|
description="Rounded corners"
|
|
)
|
|
# Curve Options
|
|
shapeItems = [
|
|
('2D', "2D", "2D shape Curve"),
|
|
('3D', "3D", "3D shape Curve")]
|
|
shape : EnumProperty(
|
|
name="2D / 3D",
|
|
items=shapeItems,
|
|
description="2D or 3D Curve"
|
|
)
|
|
outputType : EnumProperty(
|
|
name="Output splines",
|
|
description="Type of splines to output",
|
|
items=[
|
|
('POLY', "Poly", "Poly Spline type"),
|
|
('NURBS', "Nurbs", "Nurbs Spline type"),
|
|
('BEZIER', "Bezier", "Bezier Spline type")],
|
|
default='BEZIER'
|
|
)
|
|
use_cyclic_u : BoolProperty(
|
|
name="Cyclic",
|
|
default=True,
|
|
description="make curve closed"
|
|
)
|
|
endp_u : BoolProperty(
|
|
name="Use endpoint u",
|
|
default=True,
|
|
description="stretch to endpoints"
|
|
)
|
|
order_u : IntProperty(
|
|
name="Order u",
|
|
default=4,
|
|
min=2, soft_min=2,
|
|
max=6, soft_max=6,
|
|
description="Order of nurbs spline"
|
|
)
|
|
handleType : EnumProperty(
|
|
name="Handle type",
|
|
default='VECTOR',
|
|
description="Bezier handles type",
|
|
items=[
|
|
('VECTOR', "Vector", "Vector type Bezier handles"),
|
|
('AUTO', "Auto", "Automatic type Bezier handles")]
|
|
)
|
|
edit_mode : BoolProperty(
|
|
name="Show in edit mode",
|
|
default=True,
|
|
description="Show in edit mode"
|
|
)
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
# general options
|
|
col = layout.column()
|
|
col.prop(self, "Simple_Type")
|
|
|
|
l = 0
|
|
s = 0
|
|
|
|
if self.Simple_Type == 'Line':
|
|
box = layout.box()
|
|
col = box.column(align=True)
|
|
col.label(text=self.Simple_Type + " Options:")
|
|
col.prop(self, "Simple_endlocation")
|
|
v = Vector(self.Simple_endlocation) - Vector(self.location)
|
|
l = v.length
|
|
|
|
if self.Simple_Type == 'Distance':
|
|
box = layout.box()
|
|
col = box.column(align=True)
|
|
col.label(text=self.Simple_Type + " Options:")
|
|
col.prop(self, "Simple_length")
|
|
col.prop(self, "Simple_center")
|
|
l = self.Simple_length
|
|
|
|
if self.Simple_Type == 'Angle':
|
|
box = layout.box()
|
|
col = box.column(align=True)
|
|
col.label(text=self.Simple_Type + " Options:")
|
|
col.prop(self, "Simple_length")
|
|
col.prop(self, "Simple_angle")
|
|
|
|
if self.Simple_Type == 'Circle':
|
|
box = layout.box()
|
|
col = box.column(align=True)
|
|
col.label(text=self.Simple_Type + " Options:")
|
|
col.prop(self, "Simple_sides")
|
|
col.prop(self, "Simple_radius")
|
|
|
|
l = 2 * pi * abs(self.Simple_radius)
|
|
s = pi * self.Simple_radius * self.Simple_radius
|
|
|
|
if self.Simple_Type == 'Ellipse':
|
|
box = layout.box()
|
|
col = box.column(align=True)
|
|
col.label(text=self.Simple_Type + " Options:")
|
|
col.prop(self, "Simple_a", text="Radius a")
|
|
col.prop(self, "Simple_b", text="Radius b")
|
|
|
|
l = pi * (3 * (self.Simple_a + self.Simple_b) -
|
|
sqrt((3 * self.Simple_a + self.Simple_b) *
|
|
(self.Simple_a + 3 * self.Simple_b)))
|
|
|
|
s = pi * abs(self.Simple_b) * abs(self.Simple_a)
|
|
|
|
if self.Simple_Type == 'Arc':
|
|
box = layout.box()
|
|
col = box.column(align=True)
|
|
col.label(text=self.Simple_Type + " Options:")
|
|
col.prop(self, "Simple_sides")
|
|
col.prop(self, "Simple_radius")
|
|
|
|
col = box.column(align=True)
|
|
col.prop(self, "Simple_startangle")
|
|
col.prop(self, "Simple_endangle")
|
|
#row = layout.row()
|
|
#row.prop(self, "Simple_degrees_or_radians", expand=True)
|
|
|
|
l = abs(pi * self.Simple_radius * (self.Simple_endangle - self.Simple_startangle) / 180)
|
|
|
|
if self.Simple_Type == 'Sector':
|
|
box = layout.box()
|
|
col = box.column(align=True)
|
|
col.label(text=self.Simple_Type + " Options:")
|
|
col.prop(self, "Simple_sides")
|
|
col.prop(self, "Simple_radius")
|
|
|
|
col = box.column(align=True)
|
|
col.prop(self, "Simple_startangle")
|
|
col.prop(self, "Simple_endangle")
|
|
#row = layout.row()
|
|
#row.prop(self, "Simple_degrees_or_radians", expand=True)
|
|
|
|
l = abs(pi * self.Simple_radius *
|
|
(self.Simple_endangle - self.Simple_startangle) / 180) + self.Simple_radius * 2
|
|
|
|
s = pi * self.Simple_radius * self.Simple_radius * \
|
|
abs(self.Simple_endangle - self.Simple_startangle) / 360
|
|
|
|
if self.Simple_Type == 'Segment':
|
|
box = layout.box()
|
|
col = box.column(align=True)
|
|
col.label(text=self.Simple_Type + " Options:")
|
|
col.prop(self, "Simple_sides")
|
|
col.prop(self, "Simple_a", text="Radius a")
|
|
col.prop(self, "Simple_b", text="Radius b")
|
|
|
|
col = box.column(align=True)
|
|
col.prop(self, "Simple_startangle")
|
|
col.prop(self, "Simple_endangle")
|
|
|
|
#row = layout.row()
|
|
#row.prop(self, "Simple_degrees_or_radians", expand=True)
|
|
|
|
la = abs(pi * self.Simple_a * (self.Simple_endangle - self.Simple_startangle) / 180)
|
|
lb = abs(pi * self.Simple_b * (self.Simple_endangle - self.Simple_startangle) / 180)
|
|
l = abs(self.Simple_a - self.Simple_b) * 2 + la + lb
|
|
|
|
sa = pi * self.Simple_a * self.Simple_a * \
|
|
abs(self.Simple_endangle - self.Simple_startangle) / 360
|
|
|
|
sb = pi * self.Simple_b * self.Simple_b * \
|
|
abs(self.Simple_endangle - self.Simple_startangle) / 360
|
|
|
|
s = abs(sa - sb)
|
|
|
|
if self.Simple_Type == 'Rectangle':
|
|
box = layout.box()
|
|
col = box.column(align=True)
|
|
col.label(text=self.Simple_Type + " Options:")
|
|
col.prop(self, "Simple_width")
|
|
col.prop(self, "Simple_length")
|
|
col.prop(self, "Simple_rounded")
|
|
|
|
box.prop(self, "Simple_center")
|
|
l = 2 * abs(self.Simple_width) + 2 * abs(self.Simple_length)
|
|
s = abs(self.Simple_width) * abs(self.Simple_length)
|
|
|
|
if self.Simple_Type == 'Rhomb':
|
|
box = layout.box()
|
|
col = box.column(align=True)
|
|
col.label(text=self.Simple_Type + " Options:")
|
|
col.prop(self, "Simple_width")
|
|
col.prop(self, "Simple_length")
|
|
col.prop(self, "Simple_center")
|
|
|
|
g = hypot(self.Simple_width / 2, self.Simple_length / 2)
|
|
l = 4 * g
|
|
s = self.Simple_width * self.Simple_length / 2
|
|
|
|
if self.Simple_Type == 'Polygon':
|
|
box = layout.box()
|
|
col = box.column(align=True)
|
|
col.label(text=self.Simple_Type + " Options:")
|
|
col.prop(self, "Simple_sides")
|
|
col.prop(self, "Simple_radius")
|
|
|
|
if self.Simple_Type == 'Polygon_ab':
|
|
box = layout.box()
|
|
col = box.column(align=True)
|
|
col.label(text="Polygon ab Options:")
|
|
col.prop(self, "Simple_sides")
|
|
col.prop(self, "Simple_a")
|
|
col.prop(self, "Simple_b")
|
|
|
|
if self.Simple_Type == 'Trapezoid':
|
|
box = layout.box()
|
|
col = box.column(align=True)
|
|
col.label(text=self.Simple_Type + " Options:")
|
|
col.prop(self, "Simple_a")
|
|
col.prop(self, "Simple_b")
|
|
col.prop(self, "Simple_h")
|
|
|
|
box.prop(self, "Simple_center")
|
|
g = hypot(self.Simple_h, (self.Simple_a - self.Simple_b) / 2)
|
|
l = self.Simple_a + self.Simple_b + g * 2
|
|
s = (abs(self.Simple_a) + abs(self.Simple_b)) / 2 * self.Simple_h
|
|
|
|
row = layout.row()
|
|
row.prop(self, "shape", expand=True)
|
|
|
|
# output options
|
|
col = layout.column()
|
|
col.label(text="Output Curve Type:")
|
|
col.row().prop(self, "outputType", expand=True)
|
|
|
|
if self.outputType == 'NURBS':
|
|
col.prop(self, "order_u")
|
|
elif self.outputType == 'BEZIER':
|
|
col.row().prop(self, 'handleType', expand=True)
|
|
|
|
col = layout.column()
|
|
col.row().prop(self, "use_cyclic_u", expand=True)
|
|
|
|
col = layout.column()
|
|
col.row().prop(self, "edit_mode", expand=True)
|
|
|
|
col = layout.column()
|
|
# AddObjectHelper props
|
|
col.prop(self, "align")
|
|
col.prop(self, "location")
|
|
col.prop(self, "rotation")
|
|
|
|
if l != 0 or s != 0:
|
|
box = layout.box()
|
|
box.label(text="Statistics:", icon="INFO")
|
|
if l != 0:
|
|
l_str = str(round(l, 4))
|
|
box.label(text="Length: " + l_str)
|
|
if s != 0:
|
|
s_str = str(round(s, 4))
|
|
box.label(text="Area: " + s_str)
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return context.scene is not None
|
|
|
|
def execute(self, context):
|
|
|
|
# turn off 'Enter Edit Mode'
|
|
use_enter_edit_mode = bpy.context.preferences.edit.use_enter_edit_mode
|
|
bpy.context.preferences.edit.use_enter_edit_mode = False
|
|
|
|
# main function
|
|
main(context, self, use_enter_edit_mode)
|
|
|
|
if use_enter_edit_mode:
|
|
bpy.ops.object.mode_set(mode = 'EDIT')
|
|
|
|
# restore pre operator state
|
|
bpy.context.preferences.edit.use_enter_edit_mode = use_enter_edit_mode
|
|
|
|
if self.edit_mode:
|
|
bpy.ops.object.mode_set(mode = 'EDIT')
|
|
else:
|
|
bpy.ops.object.mode_set(mode = 'OBJECT')
|
|
|
|
return {'FINISHED'}
|
|
|
|
def invoke(self, context, event):
|
|
|
|
self.execute(context)
|
|
|
|
return {'FINISHED'}
|
|
|
|
# Register
|
|
classes = [
|
|
Simple,
|
|
]
|
|
|
|
def register():
|
|
from bpy.utils import register_class
|
|
for cls in classes:
|
|
register_class(cls)
|
|
|
|
bpy.types.VIEW3D_MT_curve_add.append(menu)
|
|
|
|
def unregister():
|
|
from bpy.utils import unregister_class
|
|
for cls in reversed(classes):
|
|
unregister_class(cls)
|
|
|
|
bpy.types.VIEW3D_MT_curve_add.remove(menu)
|
|
|
|
if __name__ == "__main__":
|
|
register()
|