fixes for toolshelf
[blender-addons-contrib.git] / object_mangle_tools.py
1 # mangle_tools.py (c) 2011 Phil Cote (cotejrp1)
2 #
3 # ***** BEGIN GPL LICENSE BLOCK *****
4 #
5 #
6 # This program is free software; you can redistribute it and/or
7 # modify it under the terms of the GNU General Public License
8 # as published by the Free Software Foundation; either version 2
9 # of the License, or (at your option) any later version.
10 #
11 # This program is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 # GNU General Public License for more details.
15 #
16 # You should have received a copy of the GNU General Public License
17 # along with this program; if not, write to the Free Software Foundation,
18 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 #
20 # ***** END GPL LICENCE BLOCK *****
21
22 bl_info = {
23     "name": "Mangle Tools",
24     "author": "Phil Cote",
25     "version": (0, 2),
26     "blender": (2, 71, 0),
27     "location": "View3D > Toolshelf > Addons Tab",
28     "description": "Set of tools to mangle curves, meshes, and shape keys",
29     "warning": "", # used for warning icon and text in addons panel
30     "wiki_url": "",
31     "tracker_url": "https://developer.blender.org/T29071",
32     "category": "Object"}
33
34
35 import bpy
36 import random
37 import time
38 from math import pi
39 import bmesh
40
41 def move_coordinate(context, co, is_curve=False):
42     xyz_const = context.scene.constraint_vector
43     random.seed(time.time())
44     multiplier = 1
45
46     # For curves, we base the multiplier on the circumference formula.
47     # This helps make curve changes more noticable.
48     if is_curve:
49         multiplier = 2 * pi
50     random_mag = context.scene.random_magnitude
51     if xyz_const[0]:
52         co.x += .01 * random.randrange( -random_mag, random_mag ) * multiplier
53     if xyz_const[1]:
54         co.y += .01 * random.randrange( -random_mag, random_mag )  * multiplier
55     if xyz_const[2]:
56         co.z += .01 * random.randrange( -random_mag, random_mag ) * multiplier
57
58
59 class MeshManglerOperator(bpy.types.Operator):
60     """Push vertices on the selected object around in random """ \
61     """directions to create a crumpled look"""
62     bl_idname = "ba.mesh_mangler"
63     bl_label = "Mangle Mesh"
64     bl_options = { "REGISTER", "UNDO" }
65
66     @classmethod
67     def poll(cls, context):
68         ob = context.active_object
69         return ob != None and ob.type == 'MESH'
70
71     def execute(self, context):
72         mesh = context.active_object.data
73         bm = bmesh.new()
74         bm.from_mesh(mesh)
75         verts, faces = bm.verts, bm.faces
76         randomMag = context.scene.random_magnitude
77         random.seed( time.time() )
78
79         if mesh.shape_keys != None:
80             self.report({'INFO'}, "Cannot mangle mesh: Shape keys present")
81             return {'CANCELLED'}
82
83         for vert in verts:
84             xVal = .01 * random.randrange( -randomMag, randomMag )
85             yVal = .01 * random.randrange( -randomMag, randomMag)
86             zVal = .01 * random.randrange( -randomMag, randomMag )
87             vert.co.x = vert.co.x + xVal
88             vert.co.y = vert.co.y + yVal
89             vert.co.z = vert.co.z + zVal
90
91         bm.to_mesh(mesh)
92         mesh.update()
93         return {'FINISHED'}
94
95
96 class AnimanglerOperator(bpy.types.Operator):
97     """Make a shape key and pushes the verts around on it """ \
98     """to set up for random pulsating animation"""
99     bl_idname = "ba.ani_mangler"
100     bl_label = "Mangle Shape Key"
101
102
103     @classmethod
104     def poll(cls, context):
105         ob = context.active_object
106         return ob != None and ob.type in [ 'MESH', 'CURVE' ]
107
108     def execute(self, context):
109         scn = context.scene
110         mangleName = scn.mangle_name
111         ob = context.object
112         shapeKey = ob.shape_key_add( name=mangleName )
113         verts = shapeKey.data
114
115         for vert in verts:
116             move_coordinate(context, vert.co, is_curve=ob.type=='CURVE')
117
118         return {'FINISHED'}
119
120
121 class CurveManglerOp(bpy.types.Operator):
122     """Mangle a curve to the degree the user specifies"""
123     bl_idname = "ba.curve_mangler"
124     bl_label = "Mangle Curve"
125     bl_options = { 'REGISTER', 'UNDO' }
126
127     @classmethod
128     def poll(cls, context):
129         ob = context.active_object
130         return ob != None and ob.type == "CURVE"
131
132
133     def execute(self, context):
134
135         ob = context.active_object
136         if ob.data.shape_keys != None:
137             self.report({'INFO'}, "Cannot mangle curve.  Shape keys present")
138             return {'CANCELLED'}
139         splines = context.object.data.splines
140
141         for spline in splines:
142             if spline.type == 'BEZIER':
143                 points = spline.bezier_points
144             elif spline.type in {'POLY', 'NURBS'}:
145                 points = spline.points
146
147             for point in points:
148                 move_coordinate(context, point.co, is_curve=True)
149
150         return {'FINISHED'}
151
152
153 class MangleToolsPanel(bpy.types.Panel):
154     bl_label = "Mangle Tools"
155     bl_space_type = "VIEW_3D"
156     bl_region_type="TOOLS"
157     bl_context = "objectmode"
158     bl_options = {'DEFAULT_CLOSED'}
159     bl_category = "Addons"
160
161     def draw(self, context):
162         scn = context.scene
163         layout = self.layout
164         col = layout.column()
165         col.prop(scn, "constraint_vector")
166         col.prop(scn, "random_magnitude")
167
168         col.operator("ba.curve_mangler")
169         col.operator("ba.mesh_mangler")
170         col.separator()
171         col.prop(scn, "mangle_name")
172         col.operator("ba.ani_mangler")
173
174
175 IntProperty = bpy.props.IntProperty
176 StringProperty = bpy.props.StringProperty
177 BoolVectorProperty = bpy.props.BoolVectorProperty
178
179 def register():
180     bpy.utils.register_class(AnimanglerOperator)
181     bpy.utils.register_class(MeshManglerOperator)
182     bpy.utils.register_class(CurveManglerOp)
183     bpy.utils.register_class(MangleToolsPanel)
184     scnType = bpy.types.Scene
185
186
187     scnType.constraint_vector = BoolVectorProperty(name="Mangle Constraint",
188                                 default=(True,True,True),
189                                 subtype='XYZ',
190                                 description="Constrains Mangle Direction")
191
192     scnType.random_magnitude = IntProperty( name = "Mangle Severity",
193                               default = 10, min = 1, max = 30,
194                               description = "Severity of mangling")
195
196     scnType.mangle_name = StringProperty(name="Shape Key Name",
197                              default="mangle",
198                              description="Name given for mangled shape keys")
199 def unregister():
200     bpy.utils.unregister_class(AnimanglerOperator)
201     bpy.utils.unregister_class(MeshManglerOperator)
202     bpy.utils.unregister_class(MangleToolsPanel)
203     bpy.utils.unregister_class(CurveManglerOp)
204
205
206 if __name__ == "__main__":
207     register()