diff --git a/add_curve_extra_objects/__init__.py b/add_curve_extra_objects/__init__.py
index ec45c1c18669c9fc28a065aefe4a81172df1af79..e24b770ffb6c0eeec3f30a9a1dc2504aa23e566d 100644
--- a/add_curve_extra_objects/__init__.py
+++ b/add_curve_extra_objects/__init__.py
@@ -45,8 +45,91 @@ else:
from . import add_surface_plane_cone
import bpy
-from bpy.types import Menu
+from bpy.types import Menu, AddonPreferences
+from bpy.props import StringProperty, IntProperty, BoolProperty
+def convert_old_presets(data_path, msg_data_path, old_preset_subdir, new_preset_subdir, fixdic={}, ext=".py"):
+ ''' convert old presets '''
+
+ def convert_presets(self, context):
+ if not getattr(self, data_path, False):
+ return None
+ import os
+
+ target_path = os.path.join("presets", old_preset_subdir)
+ target_path = bpy.utils.user_resource('SCRIPTS',
+ target_path)
+
+ # created an anytype op to run against preset
+ op = type('', (), {})()
+
+ files = [f for f in os.listdir(target_path) if f.endswith(ext)]
+ if not files:
+ print("No old presets in %s" % target_path)
+ setattr(self, msg_data_path, "No old presets")
+ return None
+
+ new_target_path = os.path.join("presets", new_preset_subdir)
+ new_target_path = bpy.utils.user_resource('SCRIPTS',
+ new_target_path,
+ create=True)
+ for f in files:
+ file = open(os.path.join(target_path, f))
+ for line in file:
+ if line.startswith("op."):
+ exec(line)
+ file.close()
+ for key, items in fixdic.items():
+ if hasattr(op, key) and isinstance(getattr(op, key), int):
+ setattr(op, key, items[getattr(op, key)])
+ # create a new one
+ new_file_path = os.path.join(new_target_path, f)
+ if os.path.isfile(new_file_path):
+ # do nothing
+ print("Preset %s already exists, passing..." % f)
+ continue
+ file_preset = open(new_file_path, 'w')
+ file_preset.write("import bpy\n")
+ file_preset.write("op = bpy.context.active_operator\n")
+ for prop, value in vars(op).items():
+ file_preset.write("op.%s = %s\n" % (prop, str(value)))
+ file_preset.close()
+ print("Writing new preset to %s" % new_file_path)
+
+ setattr(self, msg_data_path, "Converted %d old presets" % len(files))
+ return None
+ return convert_presets
+
+
+class CurveExtraObjectsAddonPreferences(AddonPreferences):
+ bl_idname = __name__
+
+ spiral_fixdic = {"spiral_type": ['ARCH', 'ARCH', 'LOG', 'SPHERE', 'TORUS'],
+ "curve_type": ['POLY', 'NURB'],
+ "spiral_direction": ['COUNTER_CLOCKWISE', 'CLOCKWISE']
+ }
+ update_spriral_presets_msg = StringProperty(default="Nothing to do")
+ update_spiral_presets = BoolProperty(
+ name="Update Old Presets",
+ description="Update presets to reflect data changes",
+ default=False,
+ update=convert_old_presets("update_spiral_presets", # this props name
+ "update_spiral_presets_msg", # message prop
+ "operator/curve.spirals",
+ "curve_extras/curve.spirals",
+ fixdic=spiral_fixdic)
+ )
+
+ def draw(self, context):
+ layout = self.layout
+ layout.label(text="Spirals")
+ if self.update_spiral_presets:
+ layout.label(self.update_spriral_presets_msg, icon='FILE_TICK')
+ else:
+ layout.prop(self, "update_spiral_presets")
+
+
+# TODO check if this is even used.
class INFO_MT_curve_extras_add(Menu):
# Define the "Extras" menu
bl_idname = "curve_extra_objects_add"
@@ -55,31 +138,40 @@ class INFO_MT_curve_extras_add(Menu):
def draw(self, context):
layout = self.layout
layout.operator_context = 'INVOKE_REGION_WIN'
- layout.operator("mesh.curveaceous_galore",
- text="Curve Profiles")
- layout.operator("curve.spirals",
- text="Spirals")
+ layout.operator_menu_enum("mesh.curveaceous_galore",
+ "ProfileType",
+ )
+ layout.operator_menu_enum("curve.spirals",
+ "spiral_type",
+ icon='FORCE_VORTEX')
layout.operator("curve.torus_knot_plus",
text="Torus Knot Plus")
# Define "Extras" menus
def menu_func(self, context):
- self.layout.separator()
- self.layout.operator("mesh.curveaceous_galore",
- text="Curve Profiles")
- self.layout.operator("curve.torus_knot_plus",
- text="Torus Knot Plus")
- self.layout.operator("curve.spirals",
- text="Spirals")
+ if context.mode != 'OBJECT':
+ # fix in D2142 will allow to work in EDIT_CURVE
+ return None
+ layout = self.layout
+ layout.separator()
+ layout.operator_menu_enum("mesh.curveaceous_galore",
+ "ProfileType",
+ )
+ layout.operator_menu_enum("curve.spirals",
+ "spiral_type",
+ icon='FORCE_VORTEX')
+ layout.operator("curve.torus_knot_plus", text="Torus Knot Plus")
def menu_surface(self, context):
layout = self.layout
self.layout.separator()
- self.layout.operator("object.add_surface_wedge", text="Wedge", icon="MOD_CURVE")
- self.layout.operator("object.add_surface_cone", text="Cone", icon="MOD_CURVE")
- self.layout.operator("object.add_surface_star", text="Star", icon="MOD_CURVE")
- self.layout.operator("object.add_surface_plane", text="Plane", icon="MOD_CURVE")
- self.layout.operator("curve.smooth_x_times", text="Special Smooth", icon="MOD_CURVE")
+ if context.mode == 'EDIT_SURFACE':
+ self.layout.operator("curve.smooth_x_times", text="Special Smooth", icon="MOD_CURVE")
+ elif context.mode == 'OBJECT':
+ self.layout.operator("object.add_surface_wedge", text="Wedge", icon="MOD_CURVE")
+ self.layout.operator("object.add_surface_cone", text="Cone", icon="MOD_CURVE")
+ self.layout.operator("object.add_surface_star", text="Star", icon="MOD_CURVE")
+ self.layout.operator("object.add_surface_plane", text="Plane", icon="MOD_CURVE")
def register():
bpy.utils.register_module(__name__)
diff --git a/add_curve_extra_objects/add_curve_aceous_galore.py b/add_curve_extra_objects/add_curve_aceous_galore.py
index 41bf45877078a041d3ad0e53ddbe5079b8d2c526..259660fbb3de63b19a5689bd5cc1a413b17dd89a 100644
--- a/add_curve_extra_objects/add_curve_aceous_galore.py
+++ b/add_curve_extra_objects/add_curve_aceous_galore.py
@@ -31,8 +31,8 @@ bl_info = {
'''
-##------------------------------------------------------------
-#### import modules
+# ------------------------------------------------------------
+# import modules
import bpy
from bpy.props import (
BoolProperty,
@@ -51,11 +51,11 @@ from math import (
)
import mathutils.noise as Noise
from bpy.types import Operator
-###------------------------------------------------------------
-#### Some functions to use with others:
-###------------------------------------------------------------
+# ------------------------------------------------------------
+# Some functions to use with others:
+# ------------------------------------------------------------
-#------------------------------------------------------------
+# ------------------------------------------------------------
# Generate random number:
def randnum(low=0.0, high=1.0, seed=0):
"""
@@ -82,9 +82,9 @@ def randnum(low=0.0, high=1.0, seed=0):
return rnum
-#------------------------------------------------------------
+# ------------------------------------------------------------
# Make some noise:
-def vTurbNoise(x,y,z, iScale=0.25, Size=1.0, Depth=6, Hard=0, Basis=0, Seed=0):
+def vTurbNoise(x, y, z, iScale=0.25, Size=1.0, Depth=6, Hard=0, Basis=0, Seed=0):
"""
vTurbNoise((x,y,z), iScale=0.25, Size=1.0, Depth=6, Hard=0, Basis=0, Seed=0 )
@@ -109,32 +109,34 @@ def vTurbNoise(x,y,z, iScale=0.25, Size=1.0, Depth=6, Hard=0, Basis=0, Seed=0):
the generated turbulence vector.
(type=3-float list)
"""
- rand = randnum(-100,100,Seed)
- if Basis == 9: Basis = 14
+ rand = randnum(-100, 100, Seed)
+ if Basis == 9:
+ Basis = 14
vTurb = Noise.turbulence_vector((x/Size+rand, y/Size+rand, z/Size+rand), Depth, Hard, Basis)
tx = vTurb[0]*iScale
ty = vTurb[1]*iScale
tz = vTurb[2]*iScale
- return tx,ty,tz
+ return tx, ty, tz
#------------------------------------------------------------
# Axis: ( used in 3DCurve Turbulence )
-def AxisFlip(x,y,z, x_axis=1, y_axis=1, z_axis=1, flip=0 ):
+def AxisFlip(x, y, z, x_axis=1, y_axis=1, z_axis=1, flip=0):
if flip != 0:
flip *= -1
- else: flip = 1
+ else:
+ flip = 1
x *= x_axis*flip
y *= y_axis*flip
z *= z_axis*flip
- return x,y,z
+ return x, y, z
-###-------------------------------------------------------------------
-#### 2D Curve shape functions:
-###-------------------------------------------------------------------
+# -------------------------------------------------------------------
+# 2D Curve shape functions:
+# -------------------------------------------------------------------
-##------------------------------------------------------------
+# ------------------------------------------------------------
# 2DCurve: Profile: L, H, T, U, Z
def ProfileCurve(type=0, a=0.25, b=0.25):
"""
@@ -155,42 +157,42 @@ def ProfileCurve(type=0, a=0.25, b=0.25):
"""
newpoints = []
- if type ==1:
- ## H:
- a*=0.5
- b*=0.5
- newpoints = [ [ -1.0, 1.0, 0.0 ], [ -1.0+a, 1.0, 0.0 ],
- [ -1.0+a, b, 0.0 ], [ 1.0-a, b, 0.0 ], [ 1.0-a, 1.0, 0.0 ],
- [ 1.0, 1.0, 0.0 ], [ 1.0, -1.0, 0.0 ], [ 1.0-a, -1.0, 0.0 ],
- [ 1.0-a, -b, 0.0 ], [ -1.0+a, -b, 0.0 ], [ -1.0+a, -1.0, 0.0 ],
- [ -1.0, -1.0, 0.0 ] ]
- elif type ==2:
- ## T:
- a*=0.5
- newpoints = [ [ -1.0, 1.0, 0.0 ], [ 1.0, 1.0, 0.0 ],
- [ 1.0, 1.0-b, 0.0 ], [ a, 1.0-b, 0.0 ], [ a, -1.0, 0.0 ],
- [ -a, -1.0, 0.0 ], [ -a, 1.0-b, 0.0 ], [ -1.0, 1.0-b, 0.0 ] ]
- elif type ==3:
- ## U:
- a*=0.5
- newpoints = [ [ -1.0, 1.0, 0.0 ], [ -1.0+a, 1.0, 0.0 ],
- [ -1.0+a, -1.0+b, 0.0 ], [ 1.0-a, -1.0+b, 0.0 ], [ 1.0-a, 1.0, 0.0 ],
- [ 1.0, 1.0, 0.0 ], [ 1.0, -1.0, 0.0 ], [ -1.0, -1.0, 0.0 ] ]
- elif type ==4:
- ## Z:
- a*=0.5
- newpoints = [ [ -0.5, 1.0, 0.0 ], [ a, 1.0, 0.0 ],
- [ a, -1.0+b, 0.0 ], [ 1.0, -1.0+b, 0.0 ], [ 1.0, -1.0, 0.0 ],
- [ -a, -1.0, 0.0 ], [ -a, 1.0-b, 0.0 ], [ -1.0, 1.0-b, 0.0 ],
- [ -1.0, 1.0, 0.0 ] ]
+ if type == 1:
+ # H:
+ a *= 0.5
+ b *= 0.5
+ newpoints = [[-1.0, 1.0, 0.0], [-1.0+a, 1.0, 0.0],
+ [-1.0+a, b, 0.0], [1.0-a, b, 0.0], [1.0-a, 1.0, 0.0],
+ [1.0, 1.0, 0.0], [1.0, -1.0, 0.0], [1.0-a, -1.0, 0.0],
+ [1.0-a, -b, 0.0], [-1.0+a, -b, 0.0], [-1.0+a, -1.0, 0.0],
+ [-1.0, -1.0, 0.0]]
+ elif type == 2:
+ # T:
+ a *= 0.5
+ newpoints = [[-1.0, 1.0, 0.0], [1.0, 1.0, 0.0],
+ [1.0, 1.0-b, 0.0], [a, 1.0-b, 0.0], [a, -1.0, 0.0],
+ [-a, -1.0, 0.0], [-a, 1.0-b, 0.0], [-1.0, 1.0-b, 0.0]]
+ elif type == 3:
+ # U:
+ a *= 0.5
+ newpoints = [[-1.0, 1.0, 0.0], [-1.0+a, 1.0, 0.0],
+ [-1.0+a, -1.0+b, 0.0], [1.0-a, -1.0+b, 0.0], [1.0-a, 1.0, 0.0],
+ [1.0, 1.0, 0.0], [1.0, -1.0, 0.0], [-1.0, -1.0, 0.0]]
+ elif type == 4:
+ # Z:
+ a *= 0.5
+ newpoints = [[-0.5, 1.0, 0.0], [a, 1.0, 0.0],
+ [a, -1.0+b, 0.0], [1.0, -1.0+b, 0.0], [1.0, -1.0, 0.0],
+ [-a, -1.0, 0.0], [-a, 1.0-b, 0.0], [-1.0, 1.0-b, 0.0],
+ [-1.0, 1.0, 0.0]]
else:
- ## L:
- newpoints = [ [ -1.0, 1.0, 0.0 ], [ -1.0+a, 1.0, 0.0 ],
- [ -1.0+a, -1.0+b, 0.0 ], [ 1.0, -1.0+b, 0.0 ],
- [ 1.0, -1.0, 0.0 ], [ -1.0, -1.0, 0.0 ] ]
+ # L:
+ newpoints = [[-1.0, 1.0, 0.0], [-1.0+a, 1.0, 0.0],
+ [-1.0+a, -1.0+b, 0.0], [1.0, -1.0+b, 0.0],
+ [1.0, -1.0, 0.0], [-1.0, -1.0, 0.0]]
return newpoints
-##------------------------------------------------------------
+# ------------------------------------------------------------
# 2DCurve: Miscellaneous.: Diamond, Arrow1, Arrow2, Square, ....
def MiscCurve(type=1, a=1.0, b=0.5, c=1.0):
"""
@@ -214,28 +216,28 @@ def MiscCurve(type=1, a=1.0, b=0.5, c=1.0):
"""
newpoints = []
- a*=0.5
- b*=0.5
+ a *= 0.5
+ b *= 0.5
if type == 1:
- ## diamond:
- newpoints = [ [ 0.0, b, 0.0 ], [ a, 0.0, 0.0 ], [ 0.0, -b, 0.0 ], [ -a, 0.0, 0.0 ] ]
+ # diamond:
+ newpoints = [[0.0, b, 0.0], [a, 0.0, 0.0], [0.0, -b, 0.0], [-a, 0.0, 0.0]]
elif type == 2:
- ## Arrow1:
- newpoints = [ [ -a, b, 0.0 ], [ a, 0.0, 0.0 ], [ -a, -b, 0.0 ], [ 0.0, 0.0, 0.0 ] ]
+ # Arrow1:
+ newpoints = [[-a, b, 0.0], [a, 0.0, 0.0], [-a, -b, 0.0], [0.0, 0.0, 0.0]]
elif type == 3:
- ## Arrow2:
- newpoints = [ [ -1.0, b, 0.0 ], [ -1.0+a, b, 0.0 ],
- [ -1.0+a, 1.0, 0.0 ], [ 1.0, 0.0, 0.0 ],
- [ -1.0+a, -1.0, 0.0 ], [ -1.0+a, -b, 0.0 ],
- [ -1.0, -b, 0.0 ] ]
+ # Arrow2:
+ newpoints = [[-1.0, b, 0.0], [-1.0+a, b, 0.0],
+ [-1.0+a, 1.0, 0.0], [1.0, 0.0, 0.0],
+ [-1.0+a, -1.0, 0.0], [-1.0+a, -b, 0.0],
+ [-1.0, -b, 0.0]]
elif type == 4:
- ## Rounded square:
- newpoints = [ [ -a, b-b*0.2, 0.0 ], [ -a+a*0.05, b-b*0.05, 0.0 ], [ -a+a*0.2, b, 0.0 ],
- [ a-a*0.2, b, 0.0 ], [ a-a*0.05, b-b*0.05, 0.0 ], [ a, b-b*0.2, 0.0 ],
- [ a, -b+b*0.2, 0.0 ], [ a-a*0.05, -b+b*0.05, 0.0 ], [ a-a*0.2, -b, 0.0 ],
- [ -a+a*0.2, -b, 0.0 ], [ -a+a*0.05, -b+b*0.05, 0.0 ], [ -a, -b+b*0.2, 0.0 ] ]
+ # Rounded square:
+ newpoints = [[-a, b-b*0.2, 0.0], [-a+a*0.05, b-b*0.05, 0.0], [-a+a*0.2, b, 0.0],
+ [a-a*0.2, b, 0.0], [a-a*0.05, b-b*0.05, 0.0], [a, b-b*0.2, 0.0],
+ [a, -b+b*0.2, 0.0], [a-a*0.05, -b+b*0.05, 0.0], [a-a*0.2, -b, 0.0],
+ [-a+a*0.2, -b, 0.0], [-a+a*0.05, -b+b*0.05, 0.0], [-a, -b+b*0.2, 0.0]]
elif type == 5:
- ## Rounded Rectangle II:
+ # Rounded Rectangle II:
newpoints = []
x = a / 2
y = b / 2
@@ -246,27 +248,27 @@ def MiscCurve(type=1, a=1.0, b=0.5, c=1.0):
if r > y:
r = y - 0.0001
- if r>0:
- newpoints.append([-x+r,y,0])
- newpoints.append([x-r,y,0])
- newpoints.append([x,y-r,0])
- newpoints.append([x,-y+r,0])
- newpoints.append([x-r,-y,0])
- newpoints.append([-x+r,-y,0])
- newpoints.append([-x,-y+r,0])
- newpoints.append([-x,y-r,0])
+ if r > 0:
+ newpoints.append([-x+r, y, 0])
+ newpoints.append([x-r, y, 0])
+ newpoints.append([x, y-r, 0])
+ newpoints.append([x, -y+r, 0])
+ newpoints.append([x-r, -y, 0])
+ newpoints.append([-x+r, -y, 0])
+ newpoints.append([-x, -y+r, 0])
+ newpoints.append([-x, y-r, 0])
else:
- newpoints.append([-x,y,0])
- newpoints.append([x,y,0])
- newpoints.append([x,-y,0])
- newpoints.append([-x,-y,0])
+ newpoints.append([-x, y, 0])
+ newpoints.append([x, y, 0])
+ newpoints.append([x, -y, 0])
+ newpoints.append([-x, -y, 0])
else:
- ## Square:
- newpoints = [ [ -a, b, 0.0 ], [ a, b, 0.0 ], [ a, -b, 0.0 ], [ -a, -b, 0.0 ] ]
+ # Square:
+ newpoints = [[-a, b, 0.0], [a, b, 0.0], [a, -b, 0.0], [-a, -b, 0.0]]
return newpoints
-##------------------------------------------------------------
+# ------------------------------------------------------------
# 2DCurve: Star:
def StarCurve(starpoints=8, innerradius=0.5, outerradius=1.0, twist=0.0):
"""
@@ -295,14 +297,14 @@ def StarCurve(starpoints=8, innerradius=0.5, outerradius=1.0, twist=0.0):
t = (i*step)
x1 = cos(t*pi)*outerradius
y1 = sin(t*pi)*outerradius
- newpoints.append([x1,y1,0])
+ newpoints.append([x1, y1, 0])
x2 = cos(t*pi+(pi/starpoints+twist))*innerradius
y2 = sin(t*pi+(pi/starpoints+twist))*innerradius
- newpoints.append([x2,y2,0])
- i+=1
+ newpoints.append([x2, y2, 0])
+ i += 1
return newpoints
-##------------------------------------------------------------
+# ------------------------------------------------------------
# 2DCurve: Flower:
def FlowerCurve(petals=8, innerradius=0.5, outerradius=1.0, petalwidth=2.0):
"""
@@ -332,17 +334,17 @@ def FlowerCurve(petals=8, innerradius=0.5, outerradius=1.0, petalwidth=2.0):
t = (i*step)
x1 = cos(t*pi-(pi/petals))*innerradius
y1 = sin(t*pi-(pi/petals))*innerradius
- newpoints.append([x1,y1,0])
+ newpoints.append([x1, y1, 0])
x2 = cos(t*pi-pet)*outerradius
y2 = sin(t*pi-pet)*outerradius
- newpoints.append([x2,y2,0])
+ newpoints.append([x2, y2, 0])
x3 = cos(t*pi+pet)*outerradius
y3 = sin(t*pi+pet)*outerradius
- newpoints.append([x3,y3,0])
- i+=1
+ newpoints.append([x3, y3, 0])
+ i += 1
return newpoints
-##------------------------------------------------------------
+# ------------------------------------------------------------
# 2DCurve: Arc,Sector,Segment,Ring:
def ArcCurve(sides=6, startangle=0.0, endangle=90.0, innerradius=0.5, outerradius=1.0, type=3):
"""
@@ -371,34 +373,34 @@ def ArcCurve(sides=6, startangle=0.0, endangle=90.0, innerradius=0.5, outerradiu
newpoints = []
sides += 1
angle = (2.0*(1.0/360.0))
- endangle-=startangle
+ endangle -= startangle
step = ((angle*endangle)/(sides-1))
i = 0
while i < sides:
t = (i*step) + angle*startangle
x1 = sin(t*pi)*outerradius
y1 = cos(t*pi)*outerradius
- newpoints.append([x1,y1,0])
- i+=1
+ newpoints.append([x1, y1, 0])
+ i += 1
- #if type ==0:
+ # if type ==0:
# Arc: turn cyclic curve flag off!
# Segment:
- if type ==2:
- newpoints.append([0,0,0])
+ if type == 2:
+ newpoints.append([0, 0, 0])
# Ring:
- elif type ==3:
- j=sides-1
+ elif type == 3:
+ j = sides-1
while j > -1:
t = (j*step) + angle*startangle
x2 = sin(t*pi)*innerradius
y2 = cos(t*pi)*innerradius
- newpoints.append([x2,y2,0])
- j-=1
+ newpoints.append([x2, y2, 0])
+ j -= 1
return newpoints
-##------------------------------------------------------------
+# ------------------------------------------------------------
# 2DCurve: Cog wheel:
def CogCurve(theeth=8, innerradius=0.8, middleradius=0.95, outerradius=1.0, bevel=0.5):
"""
@@ -431,26 +433,26 @@ def CogCurve(theeth=8, innerradius=0.8, middleradius=0.95, outerradius=1.0, beve
t = (i*step)
x1 = cos(t*pi-(pi/theeth)-pet)*innerradius
y1 = sin(t*pi-(pi/theeth)-pet)*innerradius
- newpoints.append([x1,y1,0])
+ newpoints.append([x1, y1, 0])
x2 = cos(t*pi-(pi/theeth)+pet)*innerradius
y2 = sin(t*pi-(pi/theeth)+pet)*innerradius
- newpoints.append([x2,y2,0])
+ newpoints.append([x2, y2, 0])
x3 = cos(t*pi-pet)*middleradius
y3 = sin(t*pi-pet)*middleradius
- newpoints.append([x3,y3,0])
+ newpoints.append([x3, y3, 0])
x4 = cos(t*pi-(pet*bevel))*outerradius
y4 = sin(t*pi-(pet*bevel))*outerradius
- newpoints.append([x4,y4,0])
+ newpoints.append([x4, y4, 0])
x5 = cos(t*pi+(pet*bevel))*outerradius
y5 = sin(t*pi+(pet*bevel))*outerradius
- newpoints.append([x5,y5,0])
+ newpoints.append([x5, y5, 0])
x6 = cos(t*pi+pet)*middleradius
y6 = sin(t*pi+pet)*middleradius
- newpoints.append([x6,y6,0])
- i+=1
+ newpoints.append([x6, y6, 0])
+ i += 1
return newpoints
-##------------------------------------------------------------
+# ------------------------------------------------------------
# 2DCurve: nSide:
def nSideCurve(sides=6, radius=1.0):
"""
@@ -475,12 +477,12 @@ def nSideCurve(sides=6, radius=1.0):
t = (i*step)
x = sin(t*pi)*radius
y = cos(t*pi)*radius
- newpoints.append([x,y,0])
- i+=1
+ newpoints.append([x, y, 0])
+ i += 1
return newpoints
-##------------------------------------------------------------
+# ------------------------------------------------------------
# 2DCurve: Splat:
def SplatCurve(sides=24, scale=1.0, seed=0, basis=0, radius=1.0):
"""
@@ -509,21 +511,21 @@ def SplatCurve(sides=24, scale=1.0, seed=0, basis=0, radius=1.0):
i = 0
while i < sides:
t = (i*step)
- turb = vTurbNoise(t,t,t, 1.0, scale, 6, 0, basis, seed )
+ turb = vTurbNoise(t, t, t, 1.0, scale, 6, 0, basis, seed)
turb = turb[2] * 0.5 + 0.5
x = sin(t*pi)*radius * turb
y = cos(t*pi)*radius * turb
- newpoints.append([x,y,0])
- i+=1
+ newpoints.append([x, y, 0])
+ i += 1
return newpoints
-###-----------------------------------------------------------
-#### 3D curve shape functions:
-###-----------------------------------------------------------
+# -----------------------------------------------------------
+# 3D curve shape functions:
+# -----------------------------------------------------------
-###------------------------------------------------------------
+# ------------------------------------------------------------
# 3DCurve: Helix:
-def HelixCurve( number=100, height=2.0, startangle=0.0, endangle=360.0, width=1.0, a=0.0, b=0.0 ):
+def HelixCurve(number=100, height=2.0, startangle=0.0, endangle=360.0, width=1.0, a=0.0, b=0.0):
"""
HelixCurve( number=100, height=2.0, startangle=0.0, endangle=360.0, width=1.0, a=0.0, b=0.0 )
@@ -554,20 +556,20 @@ def HelixCurve( number=100, height=2.0, startangle=0.0, endangle=360.0, width=1.
step = angle/(number-1)
h = height/angle
start = (startangle*2.0/360.0)
- a/=angle
+ a /= angle
i = 0
while i < number:
- t = ( i*step+start )
- x = sin( (t*pi) ) * ( 1.0 + cos( t * pi * a - ( b * pi ) ) ) * ( 0.25 * width )
- y = cos( (t*pi) ) * ( 1.0 + cos( t * pi * a - ( b * pi ) ) ) * ( 0.25 * width )
- z = ( t * h ) -h*start
- newpoints.append([x,y,z])
- i+=1
+ t = (i*step+start)
+ x = sin((t*pi)) * (1.0 + cos(t * pi * a - (b * pi))) * (0.25 * width)
+ y = cos((t*pi)) * (1.0 + cos(t * pi * a - (b * pi))) * (0.25 * width)
+ z = (t * h) - h*start
+ newpoints.append([x, y, z])
+ i += 1
return newpoints
-###------------------------------------------------------------ ?
+# ------------------------------------------------------------ ?
# 3DCurve: Cycloid: Cycloid, Epicycloid, Hypocycloid
-def CycloidCurve( number=24, length=2.0, type=0, a=1.0, b=1.0, startangle=0.0, endangle=360.0 ):
+def CycloidCurve(number=24, length=2.0, type=0, a=1.0, b=1.0, startangle=0.0, endangle=360.0):
"""
CycloidCurve( number=24, length=2.0, type=0, a=1.0, b=1.0, startangle=0.0, endangle=360.0 )
@@ -591,39 +593,39 @@ def CycloidCurve( number=24, length=2.0, type=0, a=1.0, b=1.0, startangle=0.0, e
#h = height/angle
d = length
start = (startangle*2.0/360.0)
- a/=angle
+ a /= angle
i = 0
- if type == 0: # Epitrochoid
+ if type == 0: # Epitrochoid
while i < number:
- t = ( i*step+start )
+ t = (i*step+start)
x = ((a + b) * cos(t*pi)) - (d * cos(((a+b)/b)*t*pi))
y = ((a + b) * sin(t*pi)) - (d * sin(((a+b)/b)*t*pi))
- z = 0 # ( t * h ) -h*start
- newpoints.append([x,y,z])
- i+=1
+ z = 0 # ( t * h ) -h*start
+ newpoints.append([x, y, z])
+ i += 1
else:
- newpoints = [[-1,-1,0], [-1,1,0], [1,1,0], [1,-1,0]]
+ newpoints = [[-1, -1, 0], [-1, 1, 0], [1, 1, 0], [1, -1, 0]]
return newpoints
-##------------------------------------------------------------
+# ------------------------------------------------------------
# calculates the matrix for the new object
# depending on user pref
def align_matrix(context):
loc = Matrix.Translation(context.scene.cursor_location)
obj_align = context.user_preferences.edit.object_align
if (context.space_data.type == 'VIEW_3D'
- and obj_align == 'VIEW'):
+ and obj_align == 'VIEW'):
rot = context.space_data.region_3d.view_matrix.to_3x3().inverted().to_4x4()
else:
rot = Matrix()
align_matrix = loc * rot
return align_matrix
-##------------------------------------------------------------
-#### Curve creation functions
+# ------------------------------------------------------------
+# Curve creation functions
# sets bezierhandles to auto
-def setBezierHandles(obj, mode = 'AUTOMATIC'):
+def setBezierHandles(obj, mode='AUTOMATIC'):
scene = bpy.context.scene
if obj.type != 'CURVE':
return
@@ -648,8 +650,8 @@ def vertsToPoints(Verts, splineType):
for v in Verts:
vertArray += v
if splineType == 'NURBS':
- vertArray.append(1) #for nurbs w=1
- else: #for poly w=0
+ vertArray.append(1) # for nurbs w=1
+ else: # for poly w=0
vertArray.append(0)
return vertArray
@@ -661,8 +663,8 @@ def createCurve(context, vertArray, self, align_matrix):
# create curve
scene = context.scene
- newCurve = bpy.data.curves.new(name, type = 'CURVE') # curvedatablock
- newSpline = newCurve.splines.new(type = splineType) # spline
+ newCurve = bpy.data.curves.new(name, type='CURVE') # curvedatablock
+ newSpline = newCurve.splines.new(type=splineType) # spline
# create spline from vertarray
if splineType == 'BEZIER':
@@ -680,11 +682,11 @@ def createCurve(context, vertArray, self, align_matrix):
newSpline.order_u = self.order_u
# create object with newCurve
- new_obj = bpy.data.objects.new(name, newCurve) # object
- scene.objects.link(new_obj) # place in active scene
- new_obj.select = True # set as selected
+ new_obj = bpy.data.objects.new(name, newCurve) # object
+ scene.objects.link(new_obj) # place in active scene
+ new_obj.select = True # set as selected
scene.objects.active = new_obj # set as active
- new_obj.matrix_world = align_matrix # apply matrix
+ new_obj.matrix_world = align_matrix # apply matrix
# set bezierhandles
if splineType == 'BEZIER':
@@ -692,7 +694,7 @@ def createCurve(context, vertArray, self, align_matrix):
return
-##------------------------------------------------------------
+# ------------------------------------------------------------
# Main Function
def main(context, self, align_matrix):
# deselect all objects
@@ -781,7 +783,7 @@ class Curveaceous_galore(Operator):
# align_matrix for the invoke
align_matrix = None
- #### general properties
+ # general properties
ProfileTypes = [
('Profile', 'Profile', 'Profile'),
('Miscellaneous', 'Miscellaneous', 'Miscellaneous'),
@@ -804,7 +806,7 @@ class Curveaceous_galore(Operator):
description="Type of splines to output",
items=SplineTypes)
- #### Curve Options
+ # Curve Options
shapeItems = [
('2D', '2D', '2D'),
('3D', '3D', '3D')]
@@ -829,7 +831,7 @@ class Curveaceous_galore(Operator):
description="bezier handles type",
items=bezHandles)
- #### ProfileCurve properties
+ # ProfileCurve properties
ProfileCurveType = IntProperty(name="Type",
min=1, soft_min=1,
max=5, soft_max=5,
@@ -842,7 +844,7 @@ class Curveaceous_galore(Operator):
default=0.25,
description="var2 of ProfileCurve")
- #### MiscCurve properties
+ # MiscCurve properties
MiscCurveType = IntProperty(name="Type",
min=1, soft_min=1,
max=6, soft_max=6,
@@ -859,7 +861,7 @@ class Curveaceous_galore(Operator):
min=0, soft_min=0,
description="var3 of MiscCurve")
- #### Common properties
+ # Common properties
innerRadius = FloatProperty(name="Inner radius",
default=0.5,
min=0, soft_min=0,
@@ -873,7 +875,7 @@ class Curveaceous_galore(Operator):
min=0, soft_min=0,
description="Outer radius")
- #### Flower properties
+ # Flower properties
petals = IntProperty(name="Petals",
default=8,
min=2, soft_min=2,
@@ -883,7 +885,7 @@ class Curveaceous_galore(Operator):
min=0.01, soft_min=0.01,
description="Petal width")
- #### Star properties
+ # Star properties
starPoints = IntProperty(name="Star points",
default=8,
min=2, soft_min=2,
@@ -892,7 +894,7 @@ class Curveaceous_galore(Operator):
default=0.0,
description="Twist")
- #### Arc properties
+ # Arc properties
arcSides = IntProperty(name="Arc sides",
default=6,
min=1, soft_min=1,
@@ -909,7 +911,7 @@ class Curveaceous_galore(Operator):
max=3, soft_max=3,
description="Sides of arc")
- #### Cogwheel properties
+ # Cogwheel properties
teeth = IntProperty(name="Teeth",
default=8,
min=2, soft_min=2,
@@ -920,13 +922,13 @@ class Curveaceous_galore(Operator):
max=1, soft_max=1,
description="Bevel")
- #### Nsided property
+ # Nsided property
Nsides = IntProperty(name="Sides",
default=8,
min=3, soft_min=3,
description="Number of sides")
- #### Splat properties
+ # Splat properties
splatSides = IntProperty(name="Splat sides",
default=24,
min=3, soft_min=3,
@@ -945,7 +947,7 @@ class Curveaceous_galore(Operator):
max=14, soft_max=14,
description="Basis")
- #### Helix properties
+ # Helix properties
helixPoints = IntProperty(name="resolution",
default=100,
min=3, soft_min=3,
@@ -970,7 +972,7 @@ class Curveaceous_galore(Operator):
default=0.0,
description="Helix var2")
- #### Cycloid properties
+ # Cycloid properties
cycloPoints = IntProperty(name="Resolution",
default=100,
min=3, soft_min=3,
@@ -1035,10 +1037,10 @@ class Curveaceous_galore(Operator):
elif self.ProfileType == 'Arc':
box.prop(self, 'arcSides')
- box.prop(self, 'arcType') # has only one Type?
+ box.prop(self, 'arcType') # has only one Type?
box.prop(self, 'startAngle')
box.prop(self, 'endAngle')
- box.prop(self, 'innerRadius') # doesn't seem to do anything
+ box.prop(self, 'innerRadius') # doesn't seem to do anything
box.prop(self, 'outerRadius')
elif self.ProfileType == 'Cogwheel':
@@ -1070,7 +1072,7 @@ class Curveaceous_galore(Operator):
elif self.ProfileType == 'Cycloid':
box.prop(self, 'cycloPoints')
- #box.prop(self, 'cycloType') # needs the other types first
+ # box.prop(self, 'cycloType') # needs the other types first
box.prop(self, 'cycloStart')
box.prop(self, 'cycloEnd')
box.prop(self, 'cyclo_a')
@@ -1102,7 +1104,7 @@ class Curveaceous_galore(Operator):
##### POLL #####
@classmethod
def poll(cls, context):
- return context.scene != None
+ return context.scene is not None
##### EXECUTE #####
def execute(self, context):
@@ -1113,8 +1115,8 @@ class Curveaceous_galore(Operator):
# deal with 2D - 3D curve differences
if self.ProfileType in ['Helix', 'Cycloid']:
self.shape = '3D'
- #else:
- #self.shape = '2D' # someone decide if we want this
+ # else:
+ # self.shape = '2D' # someone decide if we want this
if self.ProfileType in ['Helix']:
self.use_cyclic_u = False
diff --git a/add_curve_extra_objects/add_curve_spirals.py b/add_curve_extra_objects/add_curve_spirals.py
index 29a8687099283f69a4c4832d1fbf20ebe3ed5376..f8b12ae10f74778470004f48939b36e43d28085d 100644
--- a/add_curve_extra_objects/add_curve_spirals.py
+++ b/add_curve_extra_objects/add_curve_spirals.py
@@ -15,116 +15,119 @@
'''
import bpy, time
from bpy.props import (
+ EnumProperty,
BoolProperty,
FloatProperty,
IntProperty,
)
from math import (
sin,
- cos,
- pi,
+ cos,
+ pi,
exp
)
from bpy_extras.object_utils import AddObjectHelper, object_data_add
-from bpy.types import Operator
+from bpy.types import Operator, Menu
+from bl_operators.presets import AddPresetBase
-#make normal spiral
-#-----------------------------------------------------------------------------
+
+# make normal spiral
+# ----------------------------------------------------------------------------
def make_spiral(props, context):
-#archemedian and logarithmic can be plottet in zylindrical coordinates
-#if props.spiral_type != 1 and props.spiral_type != 2:
-# return None
-
-#INPUT: turns->degree->max_phi, steps, direction
-#Initialise Polar Coordinate Enviroment
-#-------------------------------
- props.degree = 360*props.turns #If you want to make the slider for degree
- steps = props.steps * props.turns #props.steps[per turn] -> steps[for the whole spiral]
+ # archemedian and logarithmic can be plottet in zylindrical coordinates
+ # if props.spiral_type != 1 and props.spiral_type != 2:
+ # return None
+
+ # INPUT: turns->degree->max_phi, steps, direction
+ # Initialise Polar Coordinate Enviroment
+ # -------------------------------
+ props.degree = 360*props.turns # If you want to make the slider for degree
+ steps = props.steps * props.turns # props.steps[per turn] -> steps[for the whole spiral]
props.z_scale = props.dif_z * props.turns
-
- max_phi = pi*props.degree/180 #max angle in radian
- step_phi = max_phi/steps #angle in radians between two vertices
- if props.spiral_direction == 1:
- step_phi *= -1 #flip direction
+
+ max_phi = pi*props.degree/180 # max angle in radian
+ step_phi = max_phi/steps # angle in radians between two vertices
+ if props.spiral_direction == 'CLOCKWISE':
+ step_phi *= -1 # flip direction
max_phi *= -1
- step_z = props.z_scale/(steps-1) #z increase in one step
-
+ step_z = props.z_scale/(steps-1) # z increase in one step
+
verts = []
- verts.extend([props.radius,0,0,1])
-
+ verts.extend([props.radius, 0, 0, 1])
+
cur_phi = 0
- cur_z = 0
-#-------------------------------
+ cur_z = 0
+# ------------------------------
-#Archemedean: dif_radius, radius
+# Archemedean: dif_radius, radius
cur_rad = props.radius
- step_rad = props.dif_radius/(steps * 360/props.degree)
-#radius increase per angle for archemedean spiral| (steps * 360/props.degree)...Steps needed for 360 deg
-#Logarithmic: radius, B_force, ang_div, dif_z
-
-#print("max_phi:",max_phi,"step_phi:",step_phi,"step_rad:",step_rad,"step_z:",step_z)
+ step_rad = props.dif_radius/(steps * 360/props.degree)
+# radius increase per angle for archemedean spiral| (steps * 360/props.degree)...Steps needed for 360 deg
+# Logarithmic: radius, B_force, ang_div, dif_z
+
+# print("max_phi:",max_phi,"step_phi:",step_phi,"step_rad:",step_rad,"step_z:",step_z)
while abs(cur_phi) <= abs(max_phi):
cur_phi += step_phi
- cur_z += step_z
-
-#-------------------------------
- if props.spiral_type == 1:
+ cur_z += step_z
+
+# ------------------------------
+ if props.spiral_type == 'ARCH':
cur_rad += step_rad
- if props.spiral_type == 2:
-#r = a*e^{|theta| * b}
- cur_rad = props.radius * pow(props.B_force, abs(cur_phi))
-#-------------------------------
-
+ if props.spiral_type == 'LOG':
+ # r = a*e^{|theta| * b}
+ cur_rad = props.radius * pow(props.B_force, abs(cur_phi))
+# ------------------------------
+
px = cur_rad * cos(cur_phi)
py = cur_rad * sin(cur_phi)
- verts.extend( [px,py,cur_z,1] )
+ verts.extend([px, py, cur_z, 1])
return verts
-#make Spheric spiral
-#-----------------------------------------------------------------------------
+# make Spheric spiral
+# ----------------------------------------------------------------------------
def make_spiral_spheric(props, context):
- #INPUT: turns, steps[per turn], radius
- #use spherical Coordinates
- step_phi = (2*pi) / props.steps #Step of angle in radians for one turn
- steps = props.steps * props.turns #props.steps[per turn] -> steps[for the whole spiral]
-
- max_phi = 2*pi*props.turns #max angle in radian
- step_phi = max_phi/steps #angle in radians between two vertices
- if props.spiral_direction == 1: #flip direction
+ # INPUT: turns, steps[per turn], radius
+ # use spherical Coordinates
+ step_phi = (2*pi) / props.steps # Step of angle in radians for one turn
+ steps = props.steps * props.turns # props.steps[per turn] -> steps[for the whole spiral]
+
+ max_phi = 2*pi*props.turns # max angle in radian
+ step_phi = max_phi/steps # angle in radians between two vertices
+ if props.spiral_direction == 'CLOCKWISE': # flip direction
step_phi *= -1
max_phi *= -1
- step_theta = pi / (steps-1) #theta increase in one step (pi == 180 deg)
+ step_theta = pi / (steps-1) # theta increase in one step (pi == 180 deg)
verts = []
- verts.extend([0,0,-props.radius,1]) #First vertex at south pole
+ verts.extend([0, 0, -props.radius, 1]) # First vertex at south pole
#cur_rad = props.radius = CONST
cur_phi = 0
- cur_theta = -pi/2 #Beginning at south pole
+ cur_theta = -pi/2 # Beginning at south pole
while abs(cur_phi) <= abs(max_phi):
-#Coordinate Transformation sphere->rect
+ # Coordinate Transformation sphere->rect
px = props.radius * cos(cur_theta) * cos(cur_phi)
py = props.radius * cos(cur_theta) * sin(cur_phi)
pz = props.radius * sin(cur_theta)
- verts.extend([px,py,pz,1])
+ verts.extend([px, py, pz, 1])
cur_theta += step_theta
cur_phi += step_phi
return verts
-#make torus spiral
-#-----------------------------------------------------------------------------
+# make torus spiral
+# ----------------------------------------------------------------------------
def make_spiral_torus(props, context):
-#INPUT: turns, steps, inner_radius, curves_number, mul_height, dif_inner_radius, cycles
- max_phi = 2*pi*props.turns * props.cycles #max angle in radian
- step_phi = 2*pi/props.steps #Step of angle in radians between two vertices
- if props.spiral_direction == 1: #flip direction
+ # INPUT: turns, steps, inner_radius, curves_number, mul_height, dif_inner_radius, cycles
+ max_phi = 2*pi*props.turns * props.cycles # max angle in radian
+ step_phi = 2*pi/props.steps # Step of angle in radians between two vertices
+ if props.spiral_direction == 'CLOCKWISE': # flip direction
step_phi *= -1
max_phi *= -1
step_theta = (2*pi / props.turns) / props.steps
@@ -133,24 +136,24 @@ def make_spiral_torus(props, context):
step_z = props.dif_z / (props.steps * props.turns)
verts = []
-
- cur_phi = 0 #Inner Ring Radius Angle
- cur_theta = 0 #Ring Radius Angle
+
+ cur_phi = 0 # Inner Ring Radius Angle
+ cur_theta = 0 # Ring Radius Angle
cur_rad = props.radius
cur_inner_rad = props.inner_radius
cur_z = 0
n_cycle = 0
-
+
while abs(cur_phi) <= abs(max_phi):
-#Torus Coordinates -> Rect
- px = ( cur_rad + cur_inner_rad * cos(cur_phi) ) * cos(props.curves_number * cur_theta)
- py = ( cur_rad + cur_inner_rad * cos(cur_phi) ) * sin(props.curves_number * cur_theta)
+ # Torus Coordinates -> Rect
+ px = (cur_rad + cur_inner_rad * cos(cur_phi)) * cos(props.curves_number * cur_theta)
+ py = (cur_rad + cur_inner_rad * cos(cur_phi)) * sin(props.curves_number * cur_theta)
pz = cur_inner_rad * sin(cur_phi) + cur_z
- verts.extend([px,py,pz,1])
+ verts.extend([px, py, pz, 1])
- if props.touch == True and cur_phi >= n_cycle * 2*pi:
- step_z = ( (n_cycle+1) * props.dif_inner_radius + props.inner_radius ) * 2 / (props.steps * props.turns)
+ if props.touch and cur_phi >= n_cycle * 2*pi:
+ step_z = ((n_cycle+1) * props.dif_inner_radius + props.inner_radius) * 2 / (props.steps * props.turns)
n_cycle += 1
cur_theta += step_theta
@@ -160,55 +163,72 @@ def make_spiral_torus(props, context):
cur_z += step_z
return verts
-#-----------------------------------------------------------------------------
+# ----------------------------------------------------------------------------
def draw_curve(props, context):
- if props.spiral_type == 1:
+ if props.spiral_type == 'ARCH':
verts = make_spiral(props, context)
- if props.spiral_type == 2:
+ if props.spiral_type == 'LOG':
verts = make_spiral(props, context)
- if props.spiral_type == 3:
+ if props.spiral_type == 'SPHERE':
verts = make_spiral_spheric(props, context)
- if props.spiral_type == 4:
+ if props.spiral_type == 'TORUS':
verts = make_spiral_torus(props, context)
-
+
curve_data = bpy.data.curves.new(name='Spiral', type='CURVE')
curve_data.dimensions = '3D'
-
+
+ spline = curve_data.splines.new(type=props.curve_type)
+ '''
if props.curve_type == 0:
spline = curve_data.splines.new(type='POLY')
elif props.curve_type == 1:
spline = curve_data.splines.new(type='NURBS')
-
- spline.points.add( len(verts)*0.25-1 )
-#Add only one quarter of points as elements in verts, because verts looks like: "x,y,z,?,x,y,z,?,x,..."
+ '''
+ spline.points.add(len(verts)*0.25-1)
+# Add only one quarter of points as elements in verts, because verts looks like: "x,y,z,?,x,y,z,?,x,..."
spline.points.foreach_set('co', verts)
new_obj = object_data_add(context, curve_data)
-class spirals(Operator):
+class CURVE_OT_spirals(Operator):
bl_idname = "curve.spirals"
- bl_label = "Spirals"
- bl_options = {'REGISTER','UNDO', 'PRESET'}
-#UNDO needed for operator redo and therefore also to let the addobjecthelp appear!!!
- bl_description = "adds different types of spirals"
-
- spiral_type = IntProperty(default=1, min=1, max=4, description="1:archemedian, 2:logarithmic, 3:spheric, 4:torus")
- curve_type = IntProperty(default=0, min=0, max=1, description="0:Poly, 1:Nurb")
- spiral_direction = IntProperty(default=0, min=0, max=1, description="0:counter-clockwise, 1:clockwise")
-
+ bl_label = "Add Curve: Spirals"
+ bl_options = {'REGISTER', 'UNDO'}
+
+# UNDO needed for operator redo and therefore also to let the addobjecthelp appear!!!
+ bl_description = "Create different types of spirals"
+ spiral_type = EnumProperty(items=[('ARCH', "Archemedian", "Archemedian"),
+ ("LOG", "Logarithmic", "Logarithmic"),
+ ("SPHERE", "Spheric", "Spheric"),
+ ("TORUS", "Torus", "Torus")],
+ default='ARCH',
+ name="Spiral Type",
+ description="Type of spiral to add")
+
+ curve_type = EnumProperty(items=[('POLY', "Poly", "PolyLine"),
+ ("NURBS", "NURBS", "NURBS")],
+ default='POLY',
+ name="Curve Type",
+ description="Type of spline to use")
+
+ spiral_direction = EnumProperty(items=[('COUNTER_CLOCKWISE', "Counter Clockwise", "Wind in a counter clockwise direction"),
+ ("CLOCKWISE", "Clockwise", "Wind in a clockwise direction")],
+ default='COUNTER_CLOCKWISE',
+ name="Spiral Direction",
+ description="Direction of winding")
+
turns = IntProperty(default=1, min=1, max=1000, description="Length of Spiral in 360 deg")
steps = IntProperty(default=24, min=2, max=1000, description="Number of Vertices per turn")
-
radius = FloatProperty(default=1.00, min=0.00, max=100.00, description="radius for first turn")
dif_z = FloatProperty(default=0, min=-10.00, max=100.00, description="increase in z axis per turn")
-#needed for 1 and 2 spiral_type
-#ARCHMEDEAN variables
+# needed for 1 and 2 spiral_type
+# ARCHMEDEAN variables
dif_radius = FloatProperty(default=0.00, min=-50.00, max=50.00, description="radius increment in each turn")
-#step between turns(one turn equals 360 deg)
-#LOG variables
+# step between turns(one turn equals 360 deg)
+# LOG variables
B_force = FloatProperty(default=1.00, min=0.00, max=30.00, description="factor of exponent")
-#TORUS variables
+# TORUS variables
inner_radius = FloatProperty(default=0.20, min=0.00, max=100, description="Inner Radius of Torus")
dif_inner_radius = FloatProperty(default=0, min=-10, max=100, description="Increase of inner Radius per Cycle")
dif_radius = FloatProperty(default=0, min=-10, max=100, description="Increase of Torus Radius per Cycle")
@@ -218,47 +238,98 @@ class spirals(Operator):
def draw(self, context):
layout = self.layout
- layout.prop(self, 'spiral_type', text="Spiral Type")
- layout.prop(self, 'curve_type', text="Curve Type")
- layout.prop(self, 'spiral_direction', text="Spiral Direction")
-
+ col = layout.column_flow(align=True)
+ col.label('Presets:')
+ row = col.row(align=True)
+ row.menu("OBJECT_MT_spiral_curve_presets", text=bpy.types.OBJECT_MT_spiral_curve_presets.bl_label)
+ row.operator("curve_extras.spiral_presets", text="", icon='ZOOMIN')
+ #op = row.operator("curve.spiral_presets", text="SAVE")
+ #op.name = bpy.types.OBJECT_MT_spiral_curve_presets.bl_label
+ op = row.operator("curve_extras.spiral_presets", text="", icon='ZOOMOUT')
+ op.remove_active = True
+
+ layout.prop(self, 'spiral_type')
+ layout.prop(self, 'curve_type')
+ layout.prop(self, 'spiral_direction')
+
layout.label(text="Spiral Parameters:")
- layout.prop(self, 'turns', text = "Turns")
- layout.prop(self, 'steps', text = "Steps")
+ layout.prop(self, 'turns', text="Turns")
+ layout.prop(self, 'steps', text="Steps")
box = layout.box()
- if self.spiral_type == 1:
- box.prop(self, 'dif_radius', text = "Radius Growth")
- box.prop(self, 'radius', text = "Radius")
- box.prop(self, 'dif_z', text = "Height")
- if self.spiral_type == 2:
- box.prop(self, 'radius', text = "Radius")
- box.prop(self, 'B_force', text = "Expansion Force")
- box.prop(self, 'dif_z', text = "Height")
- if self.spiral_type == 3:
- box.prop(self, 'radius', text = "Radius")
- if self.spiral_type == 4:
- box.prop(self, 'cycles', text = "Number of Cycles")
+ if self.spiral_type == 'ARCH':
+ box.prop(self, 'dif_radius', text="Radius Growth")
+ box.prop(self, 'radius', text="Radius")
+ box.prop(self, 'dif_z', text="Height")
+ if self.spiral_type == 'LOG':
+ box.prop(self, 'radius', text="Radius")
+ box.prop(self, 'B_force', text="Expansion Force")
+ box.prop(self, 'dif_z', text="Height")
+ if self.spiral_type == 'SPHERE':
+ box.prop(self, 'radius', text="Radius")
+ if self.spiral_type == 'TORUS':
+ box.prop(self, 'cycles', text="Number of Cycles")
if self.dif_inner_radius == 0 and self.dif_z == 0:
self.cycles = 1
- box.prop(self, 'radius', text = "Radius")
+ box.prop(self, 'radius', text="Radius")
if self.dif_z == 0:
- box.prop(self, 'dif_z', text = "Height per Cycle")
+ box.prop(self, 'dif_z', text="Height per Cycle")
else:
box2 = box.box()
- box2.prop(self, 'dif_z', text = "Height per Cycle")
- box2.prop(self, 'touch', text = "Make Snail")
- box.prop(self, 'inner_radius', text = "Inner Radius")
- box.prop(self, 'curves_number', text = "Curves Number")
- box.prop(self, 'dif_radius', text = "Increase of Torus Radius")
- box.prop(self, 'dif_inner_radius', text = "Increase of Inner Radius")
+ box2.prop(self, 'dif_z', text="Height per Cycle")
+ box2.prop(self, 'touch', text="Make Snail")
+ box.prop(self, 'inner_radius', text="Inner Radius")
+ box.prop(self, 'curves_number', text="Curves Number")
+ box.prop(self, 'dif_radius', text="Increase of Torus Radius")
+ box.prop(self, 'dif_inner_radius', text="Increase of Inner Radius")
@classmethod
def poll(cls, context):
-#method called by blender to check if the operator can be run
- return context.scene != None
+ # method called by blender to check if the operator can be run
+ return context.scene is not None
+
def execute(self, context):
time_start = time.time()
draw_curve(self, context)
- print("Drawing Spiral Finished: %.4f sec", time.time() - time_start)
+ print("Drawing Spiral Finished: %.4f sec" % (time.time() - time_start))
return {'FINISHED'}
+
+class CURVE_EXTRAS_OT_spirals_presets(AddPresetBase, Operator):
+ '''Spirals Presets'''
+ bl_idname = "curve_extras.spiral_presets"
+ bl_label = "Spirals"
+ preset_menu = "OBJECT_MT_spiral_curve_presets"
+ preset_subdir = "curve_extras/curve.spirals"
+
+ preset_defines = [
+ "op = bpy.context.active_operator",
+ ]
+
+ preset_values = [
+ "op.spiral_type",
+ "op.curve_type",
+ "op.spiral_direction",
+ "op.turns",
+ "op.steps",
+ "op.radius",
+ "op.dif_z",
+ "op.dif_radius",
+ "op.B_force",
+ "op.inner_radius",
+ "op.dif_inner_radius",
+ "op.cycles",
+ "op.curves_number",
+ "op.touch",
+ ]
+
+class OBJECT_MT_spiral_curve_presets(Menu):
+ '''Presets for curve.spiral.'''
+ bl_label = "Spiral Curve Presets"
+ bl_idname = "OBJECT_MT_spiral_curve_presets"
+ preset_subdir = "curve_extras/curve.spirals"
+ preset_operator = "script.execute_preset"
+
+ draw = bpy.types.Menu.draw_preset
+
+if __name__ == "__main__":
+ bpy.utils.register_module(__name__)
diff --git a/add_curve_extra_objects/add_curve_torus_knots.py b/add_curve_extra_objects/add_curve_torus_knots.py
index b43bd8310472764363ddcc5c8db914c3d9650157..e6499de566391aacf31520a9e11c31ffb714720e 100644
--- a/add_curve_extra_objects/add_curve_torus_knots.py
+++ b/add_curve_extra_objects/add_curve_torus_knots.py
@@ -36,14 +36,14 @@ bl_info = {
import bpy
from bpy.props import (
BoolProperty,
- EnumProperty,
- FloatProperty,
+ EnumProperty,
+ FloatProperty,
IntProperty
)
from math import (
sin,
- cos,
- pi,
+ cos,
+ pi,
sqrt
)
from mathutils import *
@@ -65,28 +65,28 @@ def gcd(a, b):
####################### Knot Definitions ###############################
########################################################################
def Torus_Knot(self, linkIndex=0):
- p = self.torus_p # revolution count (around the torus center)
- q = self.torus_q # spin count (around the torus tube)
+ p = self.torus_p # revolution count (around the torus center)
+ q = self.torus_q # spin count (around the torus tube)
- N = self.torus_res # curve resolution (number of control points)
+ N = self.torus_res # curve resolution (number of control points)
# use plus options only when they are enabled
if self.options_plus:
- u = self.torus_u # p multiplier
- v = self.torus_v # q multiplier
- h = self.torus_h # height (scale along Z)
- s = self.torus_s # torus scale (radii scale factor)
- else: # don't use plus settings
+ u = self.torus_u # p multiplier
+ v = self.torus_v # q multiplier
+ h = self.torus_h # height (scale along Z)
+ s = self.torus_s # torus scale (radii scale factor)
+ else: # don't use plus settings
u = 1
v = 1
h = 1
s = 1
- R = self.torus_R * s # major radius (scaled)
- r = self.torus_r * s # minor radius (scaled)
+ R = self.torus_R * s # major radius (scaled)
+ r = self.torus_r * s # minor radius (scaled)
# number of decoupled links when (p,q) are NOT co-primes
- links = gcd(p,q) # = 1 when (p,q) are co-primes
+ links = gcd(p, q) # = 1 when (p,q) are co-primes
# parametrized angle increment (cached outside of the loop for performance)
# NOTE: the total angle is divided by number of decoupled links to ensure
@@ -95,17 +95,17 @@ def Torus_Knot(self, linkIndex=0):
# link phase : each decoupled link is phased equally around the torus center
# NOTE: linkIndex value is in [0, links-1]
- linkPhase = 2*pi/q * linkIndex # = 0 when there is just ONE link
+ linkPhase = 2*pi/q * linkIndex # = 0 when there is just ONE link
# user defined phasing
if self.options_plus:
- rPhase = self.torus_rP # user defined revolution phase
- sPhase = self.torus_sP # user defined spin phase
- else: # don't use plus settings
+ rPhase = self.torus_rP # user defined revolution phase
+ sPhase = self.torus_sP # user defined spin phase
+ else: # don't use plus settings
rPhase = 0
sPhase = 0
- rPhase += linkPhase # total revolution phase of the current link
+ rPhase += linkPhase # total revolution phase of the current link
if DEBUG:
print("")
@@ -117,16 +117,18 @@ def Torus_Knot(self, linkIndex=0):
print("link phase = %.2f rad" % linkPhase)
# flip directions ? NOTE: flipping both is equivalent to no flip
- if self.flip_p: p*=-1
- if self.flip_q: q*=-1
+ if self.flip_p:
+ p *= -1
+ if self.flip_q:
+ q *= -1
# create the 3D point array for the current link
newPoints = []
for n in range(N-1):
-# t = 2*pi / links * n/(N-1) with: da = 2*pi/links/(N-1) => t = n * da
+ # t = 2*pi / links * n/(N-1) with: da = 2*pi/links/(N-1) => t = n * da
t = n * da
- theta = p*t*u + rPhase # revolution angle
- phi = q*t*v + sPhase # spin angle
+ theta = p*t*u + rPhase # revolution angle
+ phi = q*t*v + sPhase # spin angle
x = (R + r*cos(phi)) * cos(theta)
y = (R + r*cos(phi)) * sin(theta)
@@ -134,7 +136,7 @@ def Torus_Knot(self, linkIndex=0):
# append 3D point
# NOTE : the array is adjusted later as needed to 4D for POLY and NURBS
- newPoints.append([x,y,z])
+ newPoints.append([x, y, z])
return newPoints
@@ -142,7 +144,7 @@ def Torus_Knot(self, linkIndex=0):
# Calculate the align matrix for the new object (based on user preferences)
def align_matrix(self, context):
if self.absolute_location:
- loc = Matrix.Translation(Vector((0,0,0)))
+ loc = Matrix.Translation(Vector((0, 0, 0)))
else:
loc = Matrix.Translation(context.scene.cursor_location)
@@ -161,7 +163,7 @@ def align_matrix(self, context):
# ------------------------------------------------------------------------------
# Set curve BEZIER handles to auto
-def setBezierHandles(obj, mode = 'AUTOMATIC'):
+def setBezierHandles(obj, mode='AUTOMATIC'):
scene = bpy.context.scene
if obj.type != 'CURVE':
return
@@ -174,7 +176,7 @@ def setBezierHandles(obj, mode = 'AUTOMATIC'):
# ------------------------------------------------------------------------------
# Convert array of vert coordinates to points according to spline type
def vertsToPoints(Verts, splineType):
-# main vars
+ # main vars
vertArray = []
# array for BEZIER spline output (V3)
@@ -187,8 +189,8 @@ def vertsToPoints(Verts, splineType):
for v in Verts:
vertArray += v
if splineType == 'NURBS':
- vertArray.append(1) # for NURBS w=1
- else: # for POLY w=0
+ vertArray.append(1) # for NURBS w=1
+ else: # for POLY w=0
vertArray.append(0)
return vertArray
@@ -196,7 +198,7 @@ def vertsToPoints(Verts, splineType):
# ------------------------------------------------------------------------------
# Create the Torus Knot curve and object and add it to the scene
def create_torus_knot(self, context):
-# pick a name based on (p,q) parameters
+ # pick a name based on (p,q) parameters
aName = "Torus Knot %i x %i" % (self.torus_p, self.torus_q)
# create curve
@@ -208,12 +210,12 @@ def create_torus_knot(self, context):
# create torus knot link(s)
if self.multiple_links:
- links = gcd(self.torus_p, self.torus_q);
+ links = gcd(self.torus_p, self.torus_q)
else:
- links = 1;
+ links = 1
for l in range(links):
-# get vertices for the current link
+ # get vertices for the current link
verts = Torus_Knot(self, l)
# output splineType 'POLY' 'NURBS' or 'BEZIER'
@@ -255,10 +257,10 @@ def create_torus_knot(self, context):
# set object in the scene
scene = bpy.context.scene
- scene.objects.link(new_obj) # place in active scene
- new_obj.select = True # set as selected
+ scene.objects.link(new_obj) # place in active scene
+ new_obj.select = True # set as selected
scene.objects.active = new_obj # set as active
- new_obj.matrix_world = self.align_matrix # apply matrix
+ new_obj.matrix_world = self.align_matrix # apply matrix
# set BEZIER handles
if splineType == 'BEZIER':
@@ -269,28 +271,28 @@ def create_torus_knot(self, context):
# ------------------------------------------------------------------------------
# Create materials to be assigned to each TK link
def addLinkColors(self, curveData):
-# some predefined colors for the torus knot links
+ # some predefined colors for the torus knot links
colors = []
- if self.colorSet == "1": # RGBish
- colors += [ [0.0, 0.0, 1.0] ]
- colors += [ [0.0, 1.0, 0.0] ]
- colors += [ [1.0, 0.0, 0.0] ]
- colors += [ [1.0, 1.0, 0.0] ]
- colors += [ [0.0, 1.0, 1.0] ]
- colors += [ [1.0, 0.0, 1.0] ]
- colors += [ [1.0, 0.5, 0.0] ]
- colors += [ [0.0, 1.0, 0.5] ]
- colors += [ [0.5, 0.0, 1.0] ]
- else: # RainBow
- colors += [ [0.0, 0.0, 1.0] ]
- colors += [ [0.0, 0.5, 1.0] ]
- colors += [ [0.0, 1.0, 1.0] ]
- colors += [ [0.0, 1.0, 0.5] ]
- colors += [ [0.0, 1.0, 0.0] ]
- colors += [ [0.5, 1.0, 0.0] ]
- colors += [ [1.0, 1.0, 0.0] ]
- colors += [ [1.0, 0.5, 0.0] ]
- colors += [ [1.0, 0.0, 0.0] ]
+ if self.colorSet == "1": # RGBish
+ colors += [[0.0, 0.0, 1.0]]
+ colors += [[0.0, 1.0, 0.0]]
+ colors += [[1.0, 0.0, 0.0]]
+ colors += [[1.0, 1.0, 0.0]]
+ colors += [[0.0, 1.0, 1.0]]
+ colors += [[1.0, 0.0, 1.0]]
+ colors += [[1.0, 0.5, 0.0]]
+ colors += [[0.0, 1.0, 0.5]]
+ colors += [[0.5, 0.0, 1.0]]
+ else: # RainBow
+ colors += [[0.0, 0.0, 1.0]]
+ colors += [[0.0, 0.5, 1.0]]
+ colors += [[0.0, 1.0, 1.0]]
+ colors += [[0.0, 1.0, 0.5]]
+ colors += [[0.0, 1.0, 0.0]]
+ colors += [[0.5, 1.0, 0.0]]
+ colors += [[1.0, 1.0, 0.0]]
+ colors += [[1.0, 0.5, 0.0]]
+ colors += [[1.0, 0.0, 0.0]]
me = curveData
mat_offset = len(me.materials)
@@ -301,17 +303,19 @@ def addLinkColors(self, curveData):
matListNames = bpy.data.materials.keys()
# create the material
if matName not in matListNames:
- if DEBUG: print("Creating new material : %s" % matName)
+ if DEBUG:
+ print("Creating new material : %s" % matName)
mat = bpy.data.materials.new(matName)
else:
- if DEBUG: print("Material %s already exists" % matName)
+ if DEBUG:
+ print("Material %s already exists" % matName)
mat = bpy.data.materials[matName]
# set material color
if self.options_plus and self.random_colors:
mat.diffuse_color = random(), random(), random()
else:
- cID = i % (len(colors)) # cycle through predefined colors
+ cID = i % (len(colors)) # cycle through predefined colors
mat.diffuse_color = colors[cID]
if self.options_plus:
@@ -332,7 +336,7 @@ class torus_knot_plus(Operator, AddObjectHelper):
bl_context = "object"
def mode_update_callback(self, context):
-# keep the equivalent radii sets (R,r)/(eR,iR) in sync
+ # keep the equivalent radii sets (R,r)/(eR,iR) in sync
if self.mode == 'EXT_INT':
self.torus_eR = self.torus_R + self.torus_r
self.torus_iR = self.torus_R - self.torus_r
@@ -340,19 +344,19 @@ class torus_knot_plus(Operator, AddObjectHelper):
# align_matrix for the invoke
align_matrix = None
-#### GENERAL options
+# GENERAL options
options_plus = BoolProperty(
name="Extra Options",
default=False,
description="Show more options (the plus part)",
)
absolute_location = BoolProperty(
- name= "Absolute Location",
+ name="Absolute Location",
default=False,
description="Set absolute location instead of relative to 3D cursor",
)
-#### COLOR options
+# COLOR options
use_colors = BoolProperty(
name="Use Colors",
default=False,
@@ -360,7 +364,7 @@ class torus_knot_plus(Operator, AddObjectHelper):
)
colorSet = EnumProperty(
name="Color Set",
- items= (('1', 'RGBish', 'RGBsish ordered colors'),
+ items=(('1', 'RGBish', 'RGBsish ordered colors'),
('2', 'Rainbow', 'Rainbow ordered colors')),
)
random_colors = BoolProperty(
@@ -375,7 +379,7 @@ class torus_knot_plus(Operator, AddObjectHelper):
description="Color saturation",
)
-#### SURFACE Options
+# SURFACE Options
geo_surface = BoolProperty(
name="Surface",
default=True,
@@ -407,7 +411,7 @@ class torus_knot_plus(Operator, AddObjectHelper):
description="Offset the surface relative to the curve"
)
-#### TORUS KNOT Options
+# TORUS KNOT Options
torus_p = IntProperty(
name="p",
default=2,
@@ -460,7 +464,7 @@ class torus_knot_plus(Operator, AddObjectHelper):
description="Phase spins by this radian amount"
)
-#### TORUS DIMENSIONS options
+# TORUS DIMENSIONS options
mode = EnumProperty(
name="Torus Dimensions",
items=(("MAJOR_MINOR", "Major/Minor",
@@ -514,7 +518,7 @@ class torus_knot_plus(Operator, AddObjectHelper):
description="Scale along the local Z axis"
)
-#### CURVE options
+# CURVE options
torus_res = IntProperty(
name="Curve Resolution",
default=100,
@@ -573,7 +577,8 @@ class torus_knot_plus(Operator, AddObjectHelper):
links = gcd(self.torus_p, self.torus_q)
info = "Multiple Links"
- if links > 1: info += " ( " + str(links) + " )"
+ if links > 1:
+ info += " ( " + str(links) + " )"
box.prop(self, 'multiple_links', text=info)
if self.options_plus:
@@ -596,7 +601,7 @@ class torus_knot_plus(Operator, AddObjectHelper):
col = box.column(align=True)
col.prop(self, "torus_r")
- else: # EXTERIOR-INTERIOR
+ else: # EXTERIOR-INTERIOR
col = box.column(align=True)
col.prop(self, "torus_eR")
@@ -617,7 +622,7 @@ class torus_knot_plus(Operator, AddObjectHelper):
col.label(text="Output Curve Type:")
col.row().prop(self, 'outputType', expand=True)
- depends=box.column()
+ depends = box.column()
depends.prop(self, 'torus_res')
# deactivate the "curve resolution" if "adaptive resolution" is enabled
depends.enabled = not self.adaptive_resolution
@@ -658,29 +663,31 @@ class torus_knot_plus(Operator, AddObjectHelper):
##### POLL #####
@classmethod
def poll(cls, context):
- if context.mode != "OBJECT": return False
- return context.scene != None
+ if context.mode != "OBJECT":
+ return False
+ return context.scene is not None
##### EXECUTE #####
def execute(self, context):
if self.mode == 'EXT_INT':
-# adjust the equivalent radii pair : (R,r) <=> (eR,iR)
+ # adjust the equivalent radii pair : (R,r) <=> (eR,iR)
self.torus_R = (self.torus_eR + self.torus_iR)*0.5
self.torus_r = (self.torus_eR - self.torus_iR)*0.5
if self.adaptive_resolution:
-# adjust curve resolution automatically based on (p,q,R,r) values
+ # adjust curve resolution automatically based on (p,q,R,r) values
p = self.torus_p
q = self.torus_q
R = self.torus_R
r = self.torus_r
- links = gcd(p,q)
+ links = gcd(p, q)
# get an approximate length of the whole TK curve
- maxTKLen = 2*pi*sqrt(p*p*(R+r)*(R+r) + q*q*r*r) # upper bound approximation
- minTKLen = 2*pi*sqrt(p*p*(R-r)*(R-r) + q*q*r*r) # lower bound approximation
- avgTKLen = (minTKLen + maxTKLen)/2 # average approximation
- if DEBUG: print("Approximate average TK length = %.2f" % avgTKLen)
- self.torus_res = max(3, avgTKLen/links * 8) # x N factor = control points per unit length
+ maxTKLen = 2*pi*sqrt(p*p*(R+r)*(R+r) + q*q*r*r) # upper bound approximation
+ minTKLen = 2*pi*sqrt(p*p*(R-r)*(R-r) + q*q*r*r) # lower bound approximation
+ avgTKLen = (minTKLen + maxTKLen)/2 # average approximation
+ if DEBUG:
+ print("Approximate average TK length = %.2f" % avgTKLen)
+ self.torus_res = max(3, avgTKLen/links * 8) # x N factor = control points per unit length
# update align matrix
self.align_matrix = align_matrix(self, context)
diff --git a/add_curve_extra_objects/add_surface_plane_cone.py b/add_curve_extra_objects/add_surface_plane_cone.py
index 4e0a1e4b1a20c33b874da00e0c1a2eec66c0c29f..9836904749442947baeee43982c7186642fb9e5c 100644
--- a/add_curve_extra_objects/add_surface_plane_cone.py
+++ b/add_curve_extra_objects/add_surface_plane_cone.py
@@ -30,6 +30,7 @@ from bpy.props import (
)
from bpy.types import Operator
+from bpy.utils import register_class, unregister_class
class MakeSurfaceWedge(Operator):
@@ -58,6 +59,10 @@ class MakeSurfaceWedge(Operator):
min=1,
max=500)
+ @classmethod
+ def poll(cls, context):
+ return context.mode == 'OBJECT'
+
def execute(self, context):
# variables
size = self.size
@@ -66,7 +71,7 @@ class MakeSurfaceWedge(Operator):
# add a surface Plane
bpy.ops.object.add_surface_plane()
# save some time, by getting instant acces to those values.
- ao = bpy.context.active_object
+ ao = context.active_object
point = ao.data.splines[0].points
# rotate 90 degrees on the z axis
ao.rotation_euler[0] = 0.0
@@ -77,10 +82,10 @@ class MakeSurfaceWedge(Operator):
bpy.ops.curve.select_all(action='DESELECT')
# select points 0 and 1, and extrudde them
# declaring ao and point again seems necesary...
- ao = bpy.context.active_object
+ ao = context.active_object
point = ao.data.splines[0].points
point[0].select = True
- ao = bpy.context.active_object
+ ao = context.active_object
point = ao.data.splines[0].points
point[1].select = True
bpy.ops.curve.extrude()
@@ -102,14 +107,14 @@ class MakeSurfaceWedge(Operator):
# get origin to geometry.
bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY', center='MEDIAN')
# change name
- bpy.context.active_object.name = 'SurfaceWedge'
+ context.active_object.name = 'SurfaceWedge'
# get the wedge to the 3d cursor.
- bpy.context.active_object.location = bpy.context.scene.cursor_location
+ context.active_object.location = context.scene.cursor_location
bpy.ops.transform.resize(value=(size, size, size))
# adjust resolution in u and v direction
- bpy.context.active_object.data.resolution_u = res_u
- bpy.context.active_object.data.resolution_v = res_v
+ context.active_object.data.resolution_u = res_u
+ context.active_object.data.resolution_v = res_v
return{'FINISHED'}
@@ -141,6 +146,10 @@ class MakeSurfaceCone(Operator):
min=1,
max=500)
+ @classmethod
+ def poll(cls, context):
+ return context.mode == 'OBJECT'
+
def execute(self, context):
size = self.size
res_u = self.res_u
@@ -149,8 +158,8 @@ class MakeSurfaceCone(Operator):
# add basemesh, a nurbs torus
bpy.ops.surface.primitive_nurbs_surface_torus_add(location=(0, 0, 0))
# get active object and active object name
- ao = bpy.context.active_object
- aoname = bpy.context.active_object.name
+ ao = context.active_object
+ aoname = context.active_object.name
# go to edit mode
bpy.ops.object.mode_set(mode='EDIT')
# deselect all
@@ -181,18 +190,18 @@ class MakeSurfaceCone(Operator):
bpy.ops.object.editmode_toggle()
bpy.ops.object.editmode_toggle()
# change name
- bpy.context.active_object.name = 'SurfaceCone'
+ context.active_object.name = 'SurfaceCone'
# go back to object mode
bpy.ops.object.editmode_toggle()
# bring object to cursor
bpy.ops.object.mode_set(mode='OBJECT')
- bpy.context.active_object.location = bpy.context.scene.cursor_location
+ context.active_object.location = context.scene.cursor_location
# adjust size
bpy.ops.transform.resize(value=(size, size, size))
# adjust resolution in u and v direction
- bpy.context.active_object.data.resolution_u = res_u
- bpy.context.active_object.data.resolution_v = res_v
+ context.active_object.data.resolution_u = res_u
+ context.active_object.data.resolution_v = res_v
return{'FINISHED'}
@@ -222,6 +231,10 @@ class MakeSurfaceStar(Operator):
min=1,
max=500)
+ @classmethod
+ def poll(cls, context):
+ return context.mode == 'OBJECT'
+
def execute(self, context):
size = self.size
res_u = self.res_u
@@ -231,7 +244,7 @@ class MakeSurfaceStar(Operator):
bpy.ops.surface.primitive_nurbs_surface_circle_add(location=(0, 0, 0))
# we got 8 points, we need 40 points.
# get active object
- ao = bpy.context.active_object
+ ao = context.active_object
# enter edtimode
bpy.ops.object.mode_set(mode='EDIT')
# deselect all
@@ -261,7 +274,7 @@ class MakeSurfaceStar(Operator):
(0.1545085906982422, -0.4755282402038574, 0.25, 1.0),
(0.8090166449546814, -0.5877856612205505, 0.2499999850988388, 1.0)]
for i in range(0, 10):
- bpy.context.active_object.data.splines[0].points[i].co = ListOfCoords[i]
+ context.active_object.data.splines[0].points[i].co = ListOfCoords[i]
# now select all, and subdivide till 40 points is reached:
bpy.ops.curve.select_all(action='SELECT')
@@ -280,15 +293,15 @@ class MakeSurfaceStar(Operator):
# origin to geometry
bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY', center='MEDIAN')
# get object to 3d cursor
- bpy.context.active_object.location = bpy.context.scene.cursor_location
+ context.active_object.location = context.scene.cursor_location
# change name
ao.name = 'SurfaceStar'
# adjust size
bpy.ops.transform.resize(value=(size, size, size))
# adjust resolution in u and v direction
- bpy.context.active_object.data.resolution_u = res_u
- bpy.context.active_object.data.resolution_v = res_v
+ context.active_object.data.resolution_u = res_u
+ context.active_object.data.resolution_v = res_v
return{'FINISHED'}
@@ -318,6 +331,10 @@ class MakeSurfacePlane(Operator):
min=1,
max=500)
+ @classmethod
+ def poll(cls, context):
+ return context.mode == 'OBJECT'
+
def execute(self, context):
size = self.size
res_u = self.res_u
@@ -326,34 +343,34 @@ class MakeSurfacePlane(Operator):
bpy.ops.surface.primitive_nurbs_surface_surface_add() # add the base mesh, a NURBS Surface
bpy.ops.transform.resize(value=(1, 1, 0.0001), constraint_axis=(False, False, True)) # make it flat
- ao = bpy.context.active_object.name # get the active object' s name
+ ao = context.active_object.name # get the active object' s name
# added surface has 16 points
# deleting points to get plane shape.
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.curve.select_all(action='DESELECT')
- bpy.context.active_object.data.splines[0].points[0].select = True
- bpy.context.active_object.data.splines[0].points[1].select = True
- bpy.context.active_object.data.splines[0].points[2].select = True
- bpy.context.active_object.data.splines[0].points[3].select = True
+ context.active_object.data.splines[0].points[0].select = True
+ context.active_object.data.splines[0].points[1].select = True
+ context.active_object.data.splines[0].points[2].select = True
+ context.active_object.data.splines[0].points[3].select = True
bpy.ops.curve.delete(type='VERT')
- bpy.context.active_object.data.splines[0].points[8].select = True
- bpy.context.active_object.data.splines[0].points[9].select = True
- bpy.context.active_object.data.splines[0].points[10].select = True
- bpy.context.active_object.data.splines[0].points[11].select = True
+ context.active_object.data.splines[0].points[8].select = True
+ context.active_object.data.splines[0].points[9].select = True
+ context.active_object.data.splines[0].points[10].select = True
+ context.active_object.data.splines[0].points[11].select = True
bpy.ops.curve.delete(type='VERT')
- bpy.context.active_object.data.splines[0].points[0].select = True
- bpy.context.active_object.data.splines[0].points[4].select = True
+ context.active_object.data.splines[0].points[0].select = True
+ context.active_object.data.splines[0].points[4].select = True
bpy.ops.curve.delete(type='VERT')
- bpy.context.active_object.data.splines[0].points[2].select = True
- bpy.context.active_object.data.splines[0].points[5].select = True
+ context.active_object.data.splines[0].points[2].select = True
+ context.active_object.data.splines[0].points[5].select = True
bpy.ops.curve.delete(type='VERT')
# assigning name
- bpy.context.active_object.name = 'SurfacePlane'
+ context.active_object.name = 'SurfacePlane'
# select all
bpy.ops.curve.select_all(action='SELECT')
# bringing origin to center:
@@ -363,12 +380,12 @@ class MakeSurfacePlane(Operator):
bpy.ops.object.transform_apply(scale=True)
# bring object to 3d cursor.
bpy.ops.object.mode_set(mode='OBJECT')
- bpy.context.active_object.location = bpy.context.scene.cursor_location
+ context.active_object.location = context.scene.cursor_location
bpy.ops.transform.resize(value=(size, size, size))
# adjust resolution in u and v direction
- bpy.context.active_object.data.resolution_u = res_u
- bpy.context.active_object.data.resolution_v = res_v
+ context.active_object.data.resolution_u = res_u
+ context.active_object.data.resolution_v = res_v
return{'FINISHED'}
@@ -391,6 +408,10 @@ class SmoothXtimes(Operator):
default=1,
description='amount of smooths')
+ @classmethod
+ def poll(cls, context):
+ return context.mode == 'EDIT_SURFACE'
+
def execute(self, context):
# smooth times time(s).
times = self.times
@@ -420,12 +441,12 @@ def SmoothXtimes_button(self, context):
def register():
- bpy.utils.register_class(UserInterface)
- bpy.utils.register_class(MakeSurfacePlane)
- bpy.utils.register_class(MakeSurfaceCone)
- bpy.utils.register_class(MakeSurfaceStar)
- bpy.utils.register_class(MakeSurfaceWedge)
- bpy.utils.register_class(SmoothXtimes)
+ register_class(UserInterface)
+ register_class(MakeSurfacePlane)
+ register_class(MakeSurfaceCone)
+ register_class(MakeSurfaceStar)
+ register_class(MakeSurfaceWedge)
+ register_class(SmoothXtimes)
bpy.types.INFO_MT_surface_add.append(Surface_plane_button)
bpy.types.INFO_MT_surface_add.append(Surface_cone_button)
bpy.types.INFO_MT_surface_add.append(Surface_star_button)
@@ -434,12 +455,12 @@ def register():
def unregister():
- bpy.utils.unregister_class(UserInterface)
- bpy.utils.unregister_class(MakeSurfacePlane)
- bpy.utils.unregister_class(MakeSurfaceCone)
- bpy.utils.unregister_class(MakeSurfaceStar)
- bpy.utils.unregister_class(MakeSurfaceWedge)
- bpy.utils.unregister_class(SmoothXtimes)
+ unregister_class(UserInterface)
+ unregister_class(MakeSurfacePlane)
+ unregister_class(MakeSurfaceCone)
+ unregister_class(MakeSurfaceStar)
+ unregister_class(MakeSurfaceWedge)
+ unregister_class(SmoothXtimes)
bpy.types.INFO_MT_surface_add.remove(Surface_plane_button)
bpy.types.INFO_MT_surface_add.remove(Surface_cone_button)
bpy.types.INFO_MT_surface_add.remove(Surface_star_button)