* Version 0.11 of the "Twisted Torus" script

* Support "recall" properties (Edit Object parameters)
* Cleaned up the verts/faces creation process.

1 files changed, 286 insertions, 103 deletions

diff --git a/add_mesh_twisted_torus.py b/add_mesh_twisted_torus.py
index d571e18b..ce6677fb 100644
--- a/add_mesh_twisted_torus.py
+++ b/add_mesh_twisted_torus.py
@@ -23,12 +23,12 @@
 bl_addon_info = {
     'name': 'Add Mesh: Twisted Torus',
     'author': 'Paulo_Gomes',
-    'version': '0.10',
+    'version': '0.11',
     'blender': (2, 5, 3),
     'location': 'View3D > Add > Mesh ',
     'description': 'Adds a mesh Twisted Torus to the Add Mesh menu',
     'url': 'http://wiki.blender.org/index.php/Extensions:2.5/Py/' \
-	    'Scripts/Add_Mesh/Add_Twisted_Torus',
+        'Scripts/Add_Mesh/Add_Twisted_Torus',
     'category': 'Add Mesh'}
 
 
@@ -53,61 +53,249 @@ Usage:
 
 
 import bpy
+from bpy.props import *
+
 import mathutils
+from mathutils import *
 from math import cos, sin, pi
 
 
-def add_twisted_torus(major_rad, minor_rad, major_seg, minor_seg, twists):
-    Vector = mathutils.Vector
-    Quaternion = mathutils.Quaternion
+# Stores the values of a list of properties and the
+# operator id in a property group ('recall_op') inside the object.
+# Could (in theory) be used for non-objects.
+# Note: Replaces any existing property group with the same name!
+# ob ... Object to store the properties in.
+# op ... The operator that should be used.
+# op_args ... A dictionary with valid Blender
+#             properties (operator arguments/parameters).
+def store_recall_properties(ob, op, op_args):
+    if ob and op and op_args:
+        recall_properties = {}
+
+        # Add the operator identifier and op parameters to the properties.
+        recall_properties['op'] = op.bl_idname
+        recall_properties['args'] = op_args
+
+        # Store new recall properties.
+        ob['recall'] = recall_properties
+
+
+# Apply view rotation to objects if "Align To" for
+# new objects was set to "VIEW" in the User Preference.
+def apply_object_align(context, ob):
+    obj_align = bpy.context.user_preferences.edit.object_align
+
+    if (context.space_data.type == 'VIEW_3D'
+        and obj_align == 'VIEW'):
+            view3d = context.space_data
+            region = view3d.region_3d
+            viewMatrix = region.view_matrix
+            rot = viewMatrix.rotation_part()
+            ob.rotation_euler = rot.invert().to_euler()
+
+
+# Create a new mesh (object) from verts/edges/faces.
+# verts/edges/faces ... List of vertices/edges/faces for the
+#                       new mesh (as used in from_pydata).
+# name ... Name of the new mesh (& object).
+# edit ... Replace existing mesh data.
+# Note: Using "edit" will destroy/delete existing mesh data.
+def create_mesh_object(context, verts, edges, faces, name, edit):
+    scene = context.scene
+    obj_act = scene.objects.active
+
+    # Can't edit anything, unless we have an active obj.
+    if edit and not obj_act:
+        return None
+
+    # Create new mesh
+    mesh = bpy.data.meshes.new(name)
+
+    # Make a mesh from a list of verts/edges/faces.
+    mesh.from_pydata(verts, edges, faces)
+
+    # Update mesh geometry after adding stuff.
+    mesh.update()
+
+    # Deselect all objects.
+    bpy.ops.object.select_all(action='DESELECT')
+
+    if edit:
+        # Replace geometry of existing object
+
+        # Use the active obj and select it.
+        ob_new = obj_act
+        ob_new.selected = True
+
+        if obj_act.mode == 'OBJECT':
+            # Get existing mesh datablock.
+            old_mesh = ob_new.data
+
+            # Set object data to nothing
+            ob_new.data = None
+
+            # Clear users of existing mesh datablock.
+            old_mesh.user_clear()
+
+            # Remove old mesh datablock if no users are left.
+            if (old_mesh.users == 0):
+                bpy.data.meshes.remove(old_mesh)
+
+            # Assign new mesh datablock.
+            ob_new.data = mesh
+
+    else:
+        # Create new object
+        ob_new = bpy.data.objects.new(name, mesh)
+
+        # Link new object to the given scene and select it.
+        scene.objects.link(ob_new)
+        ob_new.selected = True
+
+        # Place the object at the 3D cursor location.
+        ob_new.location = scene.cursor_location
+
+        apply_object_align(context, ob_new)
+
+    if obj_act and obj_act.mode == 'EDIT':
+        if not edit:
+            # We are in EditMode, switch to ObjectMode.
+            bpy.ops.object.mode_set(mode='OBJECT')
+
+            # Select the active object as well.
+            obj_act.selected = True
+
+            # Apply location of new object.
+            scene.update()
+
+            # Join new object into the active.
+            bpy.ops.object.join()
+
+            # Switching back to EditMode.
+            bpy.ops.object.mode_set(mode='EDIT')
+
+            ob_new = obj_act
+
+    else:
+        # We are in ObjectMode.
+        # Make the new object the active one.
+        scene.objects.active = ob_new
+
+    return ob_new
+
+
+# A very simple "bridge" tool.
+# Connects two equally long vertex rows with faces.
+# Returns a list of the new faces (list of  lists)
+#
+# vertIdx1 ... First vertex list (list of vertex indices).
+# vertIdx2 ... Second vertex list (list of vertex indices).
+# closed ... Creates a loop (first & last are closed).
+# flipped ... Invert the normal of the face(s).
+#
+# Note: You can set vertIdx1 to a single vertex index to create
+#       a fan/star of faces.
+# Note: If both vertex idx list are the same length they have
+#       to have at least 2 vertices.
+def createFaces(vertIdx1, vertIdx2, closed=False, flipped=False):
+    faces = []
 
-    PI_2 = pi * 2
-    z_axis = (0, 0, 1)
+    if not vertIdx1 or not vertIdx2:
+        return None
+
+    if len(vertIdx1) < 2 and len(vertIdx2) < 2:
+        return None
+
+    fan = False
+    if (len(vertIdx1) != len(vertIdx2)):
+        if (len(vertIdx1) == 1 and len(vertIdx2) > 1):
+            fan = True
+        else:
+            return None
+
+    total = len(vertIdx2)
+
+    if closed:
+        # Bridge the start with the end.
+        if flipped:
+            face = [
+                vertIdx1[0],
+                vertIdx2[0],
+                vertIdx2[total - 1]]
+            if not fan:
+                face.append(vertIdx1[total - 1])
+            faces.append(face)
+
+        else:
+            face = [vertIdx2[0], vertIdx1[0]]
+            if not fan:
+                face.append(vertIdx1[total - 1])
+            face.append(vertIdx2[total - 1])
+            faces.append(face)
+
+    # Bridge the rest of the faces.
+    for num in range(total - 1):
+        if flipped:
+            if fan:
+                face = [vertIdx2[num], vertIdx1[0], vertIdx2[num + 1]]
+            else:
+                face = [vertIdx2[num], vertIdx1[num],
+                    vertIdx1[num + 1], vertIdx2[num + 1]]
+            faces.append(face)
+        else:
+            if fan:
+                face = [vertIdx1[0], vertIdx2[num], vertIdx2[num + 1]]
+            else:
+                face = [vertIdx1[num], vertIdx2[num],
+                    vertIdx2[num + 1], vertIdx1[num + 1]]
+            faces.append(face)
+
+    return faces
+
+
+def add_twisted_torus(major_rad, minor_rad, major_seg, minor_seg, twists):
+    PI_2 = pi * 2.0
+    z_axis = (0.0, 0.0, 1.0)
 
     verts = []
     faces = []
-    i1 = 0
-    tot_verts = major_seg * minor_seg
+
+    edgeloop_prev = []
     for major_index in range(major_seg):
         quat = Quaternion(z_axis, (major_index / major_seg) * PI_2)
-        rot_twists = 2 * pi * major_index / major_seg * twists
+        rot_twists = PI_2 * major_index / major_seg * twists
 
+        edgeloop = []
+
+        # Create section ring
         for minor_index in range(minor_seg):
-            angle = (2 * pi * minor_index / minor_seg) + rot_twists
+            angle = (PI_2 * minor_index / minor_seg) + rot_twists
 
-            vec = Vector(major_rad + (cos(angle) * minor_rad), 0.0,
-                        (sin(angle) * minor_rad)) * quat
+            vec = Vector(
+                major_rad + (cos(angle) * minor_rad),
+                0.0,
+                sin(angle) * minor_rad)
+            vec = vec * quat
 
-            verts.extend([vec.x, vec.y, vec.z])
+            edgeloop.append(len(verts))
+            verts.append(vec)
 
-            if minor_index + 1 == minor_seg:
-                i2 = (major_index) * minor_seg
-                i3 = i1 + minor_seg
-                i4 = i2 + minor_seg
+        # Remember very first edgeloop.
+        if major_index == 0:
+            edgeloop_first = edgeloop
 
-            else:
-                i2 = i1 + 1
-                i3 = i1 + minor_seg
-                i4 = i3 + 1
-
-            if i2 >= tot_verts:
-                i2 = i2 - tot_verts
-            if i3 >= tot_verts:
-                i3 = i3 - tot_verts
-            if i4 >= tot_verts:
-                i4 = i4 - tot_verts
-
-            # stupid eekadoodle
-            if i2:
-                faces.extend([i1, i3, i4, i2])
-            else:
-                faces.extend([i2, i1, i3, i4])
+        # Bridge last with current ring
+        if edgeloop_prev:
+            f = createFaces(edgeloop_prev, edgeloop, closed=True)
+            faces.extend(f)
 
-            i1 += 1
+        edgeloop_prev = edgeloop
 
-    return verts, faces
+    # Bridge first and last ring
+    f = createFaces(edgeloop_prev, edgeloop_first, closed=True)
+    faces.extend(f)
 
-from bpy.props import *
+    return verts, faces
 
 
 class AddTwistedTorus(bpy.types.Operator):
@@ -116,37 +304,51 @@ class AddTwistedTorus(bpy.types.Operator):
     bl_label = "Add Torus"
     bl_options = {'REGISTER', 'UNDO'}
 
+    # edit - Whether to add or update.
+    edit = BoolProperty(name="",
+        description="",
+        default=False,
+        options={'HIDDEN'})
     major_radius = FloatProperty(name="Major Radius",
-    description="Radius from the origin to the center of the cross section",
-    default=1.0, min=0.01, max=100.0)
-
+        description="Radius from the origin to the" \
+            " center of the cross section",
+        min=0.01,
+        max=100.0,
+        default=1.0)
     minor_radius = FloatProperty(name="Minor Radius",
-    description="Radius of the torus' cross section",
-    default=0.25, min=0.01, max=100.0)
-
+        description="Radius of the torus' cross section",
+        min=0.01,
+        max=100.0,
+        default=0.25)
     major_segments = IntProperty(name="Major Segments",
-    description="Number of segments for the main ring of the torus",
-    default=48, min=3, max=256)
-
+        description="Number of segments for the main ring of the torus",
+        min=3,
+        max=256,
+        default=48)
     minor_segments = IntProperty(name="Minor Segments",
-    description="Number of segments for the minor ring of the torus",
-    default=12, min=3, max=256)
-
+        description="Number of segments for the minor ring of the torus",
+        min=3,
+        max=256,
+        default=12)
     twists = IntProperty(name="Twists",
-    description="Number of twists of the torus",
-    default=0, min=0, max=10)
+        description="Number of twists of the torus",
+        min=0,
+        max=256,
+        default=1)
 
     use_abso = BoolProperty(name="Use Int+Ext Controls",
-    description="Use the Int / Ext controls for torus dimensions",
-    default=False)
-
+        description="Use the Int / Ext controls for torus dimensions",
+        default=False)
     abso_major_rad = FloatProperty(name="Exterior Radius",
-    description="Total Exterior Radius of the torus",
-    default=1.0, min=0.01, max=100.0)
-
+        description="Total Exterior Radius of the torus",
+        min=0.01,
+        max=100.0,
+        default=1.0)
     abso_minor_rad = FloatProperty(name="Inside Radius",
-    description="Total Interior Radius of the torus",
-    default=0.5, min=0.01, max=100.0)
+        description="Total Interior Radius of the torus",
+        min=0.01,
+        max=100.0,
+        default=0.5)
 
     def execute(self, context):
         props = self.properties
@@ -156,48 +358,29 @@ class AddTwistedTorus(bpy.types.Operator):
             props.major_radius = props.abso_minor_rad + extra_helper
             props.minor_radius = extra_helper
 
-        verts_loc, faces = add_twisted_torus(props.major_radius,
-                                            props.minor_radius,
-                                            props.major_segments,
-                                            props.minor_segments,
-                                            props.twists)
-
-        mesh = bpy.data.meshes.new("TwistedTorus")
-
-        mesh.add_geometry(int(len(verts_loc) / 3), 0, int(len(faces) / 4))
-        mesh.verts.foreach_set("co", verts_loc)
-        mesh.faces.foreach_set("verts_raw", faces)
-        mesh.faces.foreach_set("smooth", [False] * len(mesh.faces))
-
-        scene = context.scene
-
-        # ugh
-        for ob in scene.objects:
-            ob.selected = False
-
-        mesh.update()
-        ob_new = bpy.data.objects.new("TwistedTorus", mesh)
-        scene.objects.link(ob_new)
-        ob_new.selected = True
-
-        ob_new.location = scene.cursor_location
-
-        obj_act = scene.objects.active
-
-        if obj_act and obj_act.mode == 'EDIT':
-            bpy.ops.object.mode_set(mode='OBJECT')
-
-            obj_act.selected = True
-            scene.update()  # apply location
-            #scene.objects.active = ob_new
-
-            bpy.ops.object.join()  # join into the active.
-
-            bpy.ops.object.mode_set(mode='EDIT')
-        else:
-            scene.objects.active = ob_new
-            if context.user_preferences.edit.enter_edit_mode:
-                bpy.ops.object.mode_set(mode='EDIT')
+        verts, faces = add_twisted_torus(
+            props.major_radius,
+            props.minor_radius,
+            props.major_segments,
+            props.minor_segments,
+            props.twists)
+
+        # Actually create the mesh object from this geometry data.
+        obj = create_mesh_object(context, verts, [], faces, "TwistedTorus",
+            props.edit)
+
+        # Store 'recall' properties in the object.
+        recall_args_list = {
+            "edit": True,
+            "major_radius": props.major_radius,
+            "minor_radius": props.minor_radius,
+            "major_segments": props.major_segments,
+            "minor_segments": props.minor_segments,
+            "twists": props.twists,
+            "use_abso": props.use_abso,
+            "abso_major_rad": props.abso_major_rad,
+            "abso_minor_rad": props.abso_minor_rad}
+        store_recall_properties(obj, self, recall_args_list)
 
         return {'FINISHED'}
 
@@ -205,7 +388,7 @@ class AddTwistedTorus(bpy.types.Operator):
 # Add to the menu
 menu_func = (lambda self,
             context: self.layout.operator(AddTwistedTorus.bl_idname,
-            text="TwistedTorus", icon='MESH_DONUT'))
+            text="Twisted Torus", icon='MESH_DONUT'))
 
 
 def register():