updated bl_info
[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 bl_info = {
22     "name": "Mangle Tools",
23     "author": "Phil Cote",
24     "version": (0, 2),
25     "blender": (2, 6, 3),
26     "location": "View3D > Tools",
27     "description": "Set of tools to mangle curves, meshes, and shape keys",
28     "warning": "", # used for warning icon and text in addons panel
29     "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.5/Py/"\
30         "Scripts/",
31     "tracker_url": "https://projects.blender.org/tracker/index.php?"\
32         "func=detail&aid=29071",
33     "category": "Object"}
34
35 import bpy
36 import random
37 import time
38 from math import pi
39 from pdb import set_trace
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 directions to 
61     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         verts, faces = mesh.vertices, mesh.polygons
74         randomMag = context.scene.random_magnitude
75         random.seed( time.time() )
76
77         if mesh.shape_keys != None:
78             self.report( {"INFO"}, "Cannot mangle mesh: Shape keys present" )
79             return {'CANCELLED'}
80         
81         for vert in verts:
82             xVal = .01 * random.randrange( -randomMag, randomMag )
83             yVal = .01 * random.randrange( -randomMag, randomMag)
84             zVal = .01 * random.randrange( -randomMag, randomMag )
85             vert.co.x = vert.co.x + xVal
86             vert.co.y = vert.co.y + yVal
87             vert.co.z = vert.co.z + zVal    
88             
89         return {'FINISHED'}
90
91
92 class AnimanglerOperator(bpy.types.Operator):
93     '''makes a shape key and pushes the verts around on it to set up for random pulsating animation'''
94     bl_idname = "ba.ani_mangler"
95     bl_label = "Mangle Shape Key"
96
97
98     @classmethod
99     def poll(cls, context):
100         ob = context.active_object
101         return ob != None and ob.type in [ 'MESH', 'CURVE' ]
102
103     def execute(self, context):
104         scn = context.scene
105         mangleName = scn.mangle_name
106         ob = context.object
107         shapeKey = ob.shape_key_add( name=mangleName )
108         verts = shapeKey.data
109         
110         for vert in verts:
111             move_coordinate(context, vert.co, is_curve=ob.type=='CURVE')
112             
113         return {'FINISHED'}
114
115
116 class CurveManglerOp(bpy.types.Operator):
117     '''Mangles a curve to the degree the user specifies'''
118     bl_idname = "ba.curve_mangler"
119     bl_label = "Mangle Curve"
120     bl_options = { 'REGISTER', 'UNDO' }
121
122     @classmethod
123     def poll(cls, context):
124         ob = context.active_object
125         return ob != None and ob.type == "CURVE"
126
127
128     def execute(self, context):
129
130         ob = context.active_object
131         if ob.data.shape_keys != None:
132             self.report({"INFO"}, "Cannot mangle curve.  Shape keys present")
133             return {'CANCELLED'}
134         splines = context.object.data.splines
135         
136         for spline in splines:
137             if spline.type == 'BEZIER':
138                 points = spline.bezier_points
139             elif spline.type in ('POLY', 'NURBS'):
140                 points = spline.points
141
142             for point in points:
143                 move_coordinate(context, point.co, is_curve=True)
144
145         return {'FINISHED'}
146
147
148 class MangleToolsPanel(bpy.types.Panel):
149     bl_label = "Mangle Tools"
150     bl_space_type = "VIEW_3D"
151     bl_region_type="TOOLS"
152     bl_context = "objectmode"
153     bl_options = {'DEFAULT_CLOSED'}
154
155     def draw(self, context):
156         scn = context.scene
157         layout = self.layout
158         col = layout.column()
159         col.prop(scn, "constraint_vector")
160         col.prop(scn, "random_magnitude")
161
162         col.operator("ba.curve_mangler")
163         col.operator("ba.mesh_mangler")
164         col.separator()
165         col.prop(scn, "mangle_name")
166         col.operator("ba.ani_mangler")
167
168
169 IntProperty = bpy.props.IntProperty
170 StringProperty = bpy.props.StringProperty
171 BoolVectorProperty = bpy.props.BoolVectorProperty
172
173 def register():
174     bpy.utils.register_class(AnimanglerOperator)
175     bpy.utils.register_class(MeshManglerOperator)
176     bpy.utils.register_class(CurveManglerOp)
177     bpy.utils.register_class(MangleToolsPanel)
178     scnType = bpy.types.Scene
179     
180                                     
181     scnType.constraint_vector = BoolVectorProperty(name="Mangle Constraint", 
182                                 default=(True,True,True),
183                                 subtype='XYZ',
184                                 description="Constrains Mangle Direction")
185                                 
186     scnType.random_magnitude = IntProperty( name = "Mangle Severity", 
187                               default = 10, min = 1, max = 30, 
188                               description = "Severity of mangling")
189     
190     scnType.mangle_name = StringProperty(name="Shape Key Name",
191                              default="mangle",
192                              description="Name given for mangled shape keys")
193 def unregister():
194     bpy.utils.unregister_class(AnimanglerOperator)
195     bpy.utils.unregister_class(MeshManglerOperator)
196     bpy.utils.unregister_class(MangleToolsPanel)
197     bpy.utils.unregister_class(CurveManglerOp)
198
199
200 if __name__ == "__main__":
201     register()