[Edit Linked Library] Fixes based on code review from Campbell
[blender-addons-contrib.git] / 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': "http://wiki.blender.org/index.php/Extensions:2.6/Py/Scripts",
31     'tracker_url': 'https://projects.blender.org/tracker/index.php?'\
32                    'func=detail&aid=32585',
33     "category": "Mesh"}
34
35
36 import bpy
37 import bmesh
38 from mathutils import Vector, Quaternion
39 from math import ceil, floor, pi
40
41
42 def eval_bez_tan(mat, points, t):
43     num = len(points)
44     t *= num - 1
45     upper = ceil(t)
46     lower = floor(t)
47     if upper == lower:
48         if upper == 0:
49             return (mat * (points[upper].handle_right - points[upper].co)).normalized()
50         elif upper == num - 1:
51             return (mat * (points[upper].co - points[upper].handle_left)).normalized()
52         else:
53             return (mat * (points[upper].co - points[upper].handle_left)).normalized()
54     else:
55         t -= lower
56         pupper = points[upper]
57         plower = points[lower]
58         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
59         tangent = mat * tangent
60         tangent.normalize()
61         return tangent
62
63
64 def eval_bez(mat, points, t):
65     num = len(points)
66     t *= num - 1
67     upper = ceil(t)
68     lower = floor(t)
69     if upper == lower:
70         return mat * points[upper].co
71     else:
72         t -= lower
73         pupper = points[upper]
74         plower = points[lower]
75         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
76         return mat * pos
77
78
79 def curve_ob_enum(self, context):
80     obs = context.scene.objects
81     cuobs = [(str(i), ob.name, ob.name) for i, ob in enumerate(obs) if ob.type == 'CURVE']
82     curve_ob_enum.temp = cuobs
83     return cuobs
84
85
86 class ExtrudeAlongCurve(bpy.types.Operator):
87     bl_idname = "mesh.extrude_along_curve"
88     bl_label = "Extrude Along Curve"
89     bl_options = {'REGISTER', 'UNDO'}
90
91     resolution = bpy.props.IntProperty(name="Resolution", default=1, min=1, soft_max=100)
92     scale = bpy.props.FloatProperty(name="Scale", default=1.0, soft_min=0.0, soft_max=5.0)
93     rotation = bpy.props.FloatProperty(name="Rotation", default=0.0, soft_min=-2 * pi, soft_max=2 * pi, subtype='ANGLE')
94     splineidx = bpy.props.IntProperty(name="Spline Index", default=0, min=0)
95     snapto = bpy.props.BoolProperty(name="Snap To Face", default=True)
96     curveob = bpy.props.EnumProperty(name="Curve", items=curve_ob_enum)
97
98     @classmethod
99     def poll(self, context):
100         ob = context.active_object
101         for cuob in context.scene.objects:
102             if cuob.type == 'CURVE':
103                 break
104         else:
105             return False
106
107         return (ob is not None) and (ob.type == 'MESH') and (context.mode == 'EDIT_MESH')
108
109     def draw(self, context):
110         layout = self.layout
111         layout.prop(self, "curveob", text="", icon='CURVE_DATA')
112         layout.prop(self, "resolution")
113         layout.prop(self, "scale")
114         layout.prop(self, "rotation")
115         layout.prop(self, "splineidx")
116         layout.prop(self, "snapto")
117
118     def execute(self, context):
119         ob = bpy.context.active_object
120         me = ob.data
121         bm = bmesh.from_edit_mesh(me)
122
123         # Get the selected curve object and the required spline
124         cuob = context.scene.objects[int(self.curveob)]
125         cu = cuob.data
126
127         self.splineidx = min(self.splineidx, len(cu.splines) - 1)
128         p = cu.splines[self.splineidx].bezier_points
129
130         # Get the property values
131         res = self.resolution
132         scale = self.scale
133         rotation = self.rotation
134         dscale = (1 - scale) / res
135         drot = rotation / res
136
137         # Get the matrices to convert between spaces
138         cmat = ob.matrix_world.inverted() * cuob.matrix_world
139         ctanmat = cmat.to_3x3().inverted().transposed()
140
141         # The list of parameter values to evaluate the bezier curve at
142         tvals = [t / res for t in range(res + 1)]
143
144         # Get the first selected face, if none, cancel
145         for f in bm.faces:
146             if f.select:
147                 break
148         else:
149             return {'CANCELLED'}
150
151         # Get the position vecs on the curve and tangent values
152         bezval = [eval_bez(cmat, p, t) for t in tvals]
153         beztan = [eval_bez_tan(ctanmat, p, t) for t in tvals]
154         bezquat = [0] * len(tvals)
155
156         # Using curve only
157         bezquat[0] = beztan[0].to_track_quat('Z', 'Y')
158         fquat = bezquat[0].inverted()
159
160         # Calculate the min twist orientations
161         for i in range(1, res + 1):
162             ang = beztan[i - 1].angle(beztan[i], 0.0)
163             if ang > 0.0:
164                 axis = beztan[i - 1].cross(beztan[i])
165                 q = Quaternion(axis, ang)
166                 bezquat[i] = q * bezquat[i - 1]
167             else:
168                 bezquat[i] = bezquat[i - 1].copy()
169
170         # Get the faces to be modified
171         fprev = f
172         # no = f.normal.copy()
173         faces = [f.copy() for i in range(res)]
174
175         # Offset if we need to snap to the face
176         offset = Vector() if not self.snapto else (f.calc_center_median() - bezval[0])
177
178         # For each of the faces created, set their vert positions and create side faces
179         for i, data in enumerate(zip(faces, bezval[1:], bezquat[1:])):
180
181             fn, pos, quat = data
182             cen = fn.calc_center_median()
183
184             rotquat = Quaternion((0, 0, 1), i * drot)
185
186             for v in fn.verts:
187                 v.co = quat * rotquat * fquat * (v.co - cen) * (1 - (i + 1) * dscale) + pos + offset
188
189             for ll, ul in zip(fprev.loops, fn.loops):
190                 ff = bm.faces.new((ll.vert, ll.link_loop_next.vert, ul.link_loop_next.vert, ul.vert))
191                 ff.normal_update()
192
193             bm.faces.remove(fprev)
194             fprev = fn
195
196         me.calc_tessface()
197         me.calc_normals()
198         me.update()
199
200         return {'FINISHED'}
201
202
203 def register():
204     bpy.utils.register_module(__name__)
205
206
207 def unregister():
208     bpy.utils.unregister_module(__name__)
209
210
211 if __name__ == "__main__":
212     register()