mesh_extrude_along_curve.py

   1 # ##### BEGIN GPL LICENSE BLOCK #####
   2 #
   3 #  This program is free software; you can redistribute it and/or
   4 #  modify it under the terms of the GNU General Public License
   5 #  as published by the Free Software Foundation; either version 2
   6 #  of the License, or (at your option) any later version.
   7 #
   8 #  This program is distributed in the hope that it will be useful,
   9 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 #  GNU General Public License for more details.
  12 #
  13 #  You should have received a copy of the GNU General Public License
  14 #  along with this program; if not, write to the Free Software Foundation,
  15 #  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  16 #
  17 # ##### END GPL LICENSE BLOCK #####
  18
  19 # <pep8 compliant>
  20
  21
  22 bl_info = {
  23     "name": "Extrude Along Curve",
  24     "author": "Andrew Hale (TrumanBlending)",
  25     "version": (0, 1),
  26     "blender": (2, 63, 0),
  27     "location": "",
  28     "description": "Extrude a face along a Bezier Curve",
  29     "warning": "",
  30     'wiki_url': "",
  31     'tracker_url': 'https://developer.blender.org/T32585',
  32     "category": "Mesh"}
  33
  34
  35 import bpy
  36 import bmesh
  37 from mathutils import Vector, Quaternion
  38 from math import ceil, floor, pi
  39
  40
  41 def eval_bez_tan(mat, points, t):
  42     num = len(points)
  43     t *= num - 1
  44     upper = ceil(t)
  45     lower = floor(t)
  46     if upper == lower:
  47         if upper == 0:
  48             return (mat * (points[upper].handle_right - points[upper].co)).normalized()
  49         elif upper == num - 1:
  50             return (mat * (points[upper].co - points[upper].handle_left)).normalized()
  51         else:
  52             return (mat * (points[upper].co - points[upper].handle_left)).normalized()
  53     else:
  54         t -= lower
  55         pupper = points[upper]
  56         plower = points[lower]
  57         tangent = -3 * (1 - t) ** 2 * plower.co + (-6 * (1 - t) * t + 3 * (1 - t) ** 2) * plower.handle_right + (-3 * t ** 2 + 3 * (1 - t) * 2 * t) * pupper.handle_left + 3 * t ** 2 * pupper.co
  58         tangent = mat * tangent
  59         tangent.normalize()
  60         return tangent
  61
  62
  63 def eval_bez(mat, points, t):
  64     num = len(points)
  65     t *= num - 1
  66     upper = ceil(t)
  67     lower = floor(t)
  68     if upper == lower:
  69         return mat * points[upper].co
  70     else:
  71         t -= lower
  72         pupper = points[upper]
  73         plower = points[lower]
  74         pos = (1 - t) ** 3 * plower.co + 3 * (1 - t) ** 2 * t * plower.handle_right + 3 * (1 - t) * t ** 2 * pupper.handle_left + t ** 3 * pupper.co
  75         return mat * pos
  76
  77
  78 def curve_ob_enum(self, context):
  79     obs = context.scene.objects
  80     cuobs = [(str(i), ob.name, ob.name) for i, ob in enumerate(obs) if ob.type == 'CURVE']
  81     curve_ob_enum.temp = cuobs
  82     return cuobs
  83
  84
  85 class ExtrudeAlongCurve(bpy.types.Operator):
  86     bl_idname = "mesh.extrude_along_curve"
  87     bl_label = "Extrude Along Curve"
  88     bl_options = {'REGISTER', 'UNDO'}
  89
  90     resolution = bpy.props.IntProperty(name="Resolution", default=1, min=1, soft_max=100)
  91     scale = bpy.props.FloatProperty(name="Scale", default=1.0, soft_min=0.0, soft_max=5.0)
  92     rotation = bpy.props.FloatProperty(name="Rotation", default=0.0, soft_min=-2 * pi, soft_max=2 * pi, subtype='ANGLE')
  93     splineidx = bpy.props.IntProperty(name="Spline Index", default=0, min=0)
  94     snapto = bpy.props.BoolProperty(name="Snap To Face", default=True)
  95     curveob = bpy.props.EnumProperty(name="Curve", items=curve_ob_enum)
  96
  97     @classmethod
  98     def poll(self, context):
  99         ob = context.active_object
 100         for cuob in context.scene.objects:
 101             if cuob.type == 'CURVE':
 102                 break
 103         else:
 104             return False
 105
 106         return (ob is not None) and (ob.type == 'MESH') and (context.mode == 'EDIT_MESH')
 107
 108     def draw(self, context):
 109         layout = self.layout
 110         layout.prop(self, "curveob", text="", icon='CURVE_DATA')
 111         layout.prop(self, "resolution")
 112         layout.prop(self, "scale")
 113         layout.prop(self, "rotation")
 114         layout.prop(self, "splineidx")
 115         layout.prop(self, "snapto")
 116
 117     def execute(self, context):
 118         ob = bpy.context.active_object
 119         me = ob.data
 120         bm = bmesh.from_edit_mesh(me)
 121
 122         # Get the selected curve object and the required spline
 123         cuob = context.scene.objects[int(self.curveob)]
 124         cu = cuob.data
 125
 126         self.splineidx = min(self.splineidx, len(cu.splines) - 1)
 127         p = cu.splines[self.splineidx].bezier_points
 128
 129         # Get the property values
 130         res = self.resolution
 131         scale = self.scale
 132         rotation = self.rotation
 133         dscale = (1 - scale) / res
 134         drot = rotation / res
 135
 136         # Get the matrices to convert between spaces
 137         cmat = ob.matrix_world.inverted() * cuob.matrix_world
 138         ctanmat = cmat.to_3x3().inverted().transposed()
 139
 140         # The list of parameter values to evaluate the bezier curve at
 141         tvals = [t / res for t in range(res + 1)]
 142
 143         # Get the first selected face, if none, cancel
 144         for f in bm.faces:
 145             if f.select:
 146                 break
 147         else:
 148             return {'CANCELLED'}
 149
 150         # Get the position vecs on the curve and tangent values
 151         bezval = [eval_bez(cmat, p, t) for t in tvals]
 152         beztan = [eval_bez_tan(ctanmat, p, t) for t in tvals]
 153         bezquat = [0] * len(tvals)
 154
 155         # Using curve only
 156         bezquat[0] = beztan[0].to_track_quat('Z', 'Y')
 157         fquat = bezquat[0].inverted()
 158
 159         # Calculate the min twist orientations
 160         for i in range(1, res + 1):
 161             ang = beztan[i - 1].angle(beztan[i], 0.0)
 162             if ang > 0.0:
 163                 axis = beztan[i - 1].cross(beztan[i])
 164                 q = Quaternion(axis, ang)
 165                 bezquat[i] = q * bezquat[i - 1]
 166             else:
 167                 bezquat[i] = bezquat[i - 1].copy()
 168
 169         # Get the faces to be modified
 170         fprev = f
 171         # no = f.normal.copy()
 172         faces = [f.copy() for i in range(res)]
 173
 174         # Offset if we need to snap to the face
 175         offset = Vector() if not self.snapto else (f.calc_center_median() - bezval[0])
 176
 177         # For each of the faces created, set their vert positions and create side faces
 178         for i, data in enumerate(zip(faces, bezval[1:], bezquat[1:])):
 179
 180             fn, pos, quat = data
 181             cen = fn.calc_center_median()
 182
 183             rotquat = Quaternion((0, 0, 1), i * drot)
 184
 185             for v in fn.verts:
 186                 v.co = quat * rotquat * fquat * (v.co - cen) * (1 - (i + 1) * dscale) + pos + offset
 187
 188             for ll, ul in zip(fprev.loops, fn.loops):
 189                 ff = bm.faces.new((ll.vert, ll.link_loop_next.vert, ul.link_loop_next.vert, ul.vert))
 190                 ff.normal_update()
 191
 192             bm.faces.remove(fprev)
 193             fprev = fn
 194
 195         me.calc_tessface()
 196         me.calc_normals()
 197         me.update()
 198
 199         return {'FINISHED'}
 200
 201
 202 def register():
 203     bpy.utils.register_module(__name__)
 204
 205
 206 def unregister():
 207     bpy.utils.unregister_module(__name__)
 208
 209
 210 if __name__ == "__main__":
 211     register()