import common classes from bpy.types, saves ~1000 python getattrs on startup.
[blender.git] / release / scripts / startup / bl_operators / object_randomize_transform.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-80 compliant>
20
21 import bpy
22 from bpy.types import Operator
23
24
25 def randomize_selected(seed, delta, loc, rot, scale, scale_even):
26
27     import random
28     from random import uniform
29     from mathutils import Vector
30
31     random.seed(seed)
32
33     def rand_vec(vec_range):
34         return Vector(uniform(-val, val) for val in vec_range)
35
36     for obj in bpy.context.selected_objects:
37
38         if loc:
39             if delta:
40                 obj.delta_location += rand_vec(loc)
41             else:
42                 obj.location += rand_vec(loc)
43         else:  # otherwise the values change under us
44             uniform(0.0, 0.0), uniform(0.0, 0.0), uniform(0.0, 0.0)
45
46         if rot:  # TODO, non euler's
47             vec = rand_vec(rot)
48             if delta:
49                 obj.delta_rotation_euler[0] += vec[0]
50                 obj.delta_rotation_euler[1] += vec[1]
51                 obj.delta_rotation_euler[2] += vec[2]
52             else:
53                 obj.rotation_euler[0] += vec[0]
54                 obj.rotation_euler[1] += vec[1]
55                 obj.rotation_euler[2] += vec[2]
56         else:
57             uniform(0.0, 0.0), uniform(0.0, 0.0), uniform(0.0, 0.0)
58
59         if scale:
60             if delta:
61                 org_sca_x, org_sca_y, org_sca_z = obj.delta_scale
62             else:
63                 org_sca_x, org_sca_y, org_sca_z = obj.scale
64
65             if scale_even:
66                 sca_x = sca_y = sca_z = uniform(scale[0], - scale[0])
67                 uniform(0.0, 0.0), uniform(0.0, 0.0)
68             else:
69                 sca_x, sca_y, sca_z = rand_vec(scale)
70
71             if scale_even:
72                 aX = -(sca_x * org_sca_x) + org_sca_x
73                 aY = -(sca_x * org_sca_y) + org_sca_y
74                 aZ = -(sca_x * org_sca_z) + org_sca_z
75             else:
76                 aX = sca_x + org_sca_x
77                 aY = sca_y + org_sca_y
78                 aZ = sca_z + org_sca_z
79
80             if delta:
81                 obj.delta_scale = aX, aY, aZ
82             else:
83                 obj.scale = aX, aY, aZ
84         else:
85             uniform(0.0, 0.0), uniform(0.0, 0.0), uniform(0.0, 0.0)
86
87
88 from bpy.props import IntProperty, BoolProperty, FloatVectorProperty
89
90
91 class RandomizeLocRotSize(Operator):
92     '''Randomize objects loc/rot/scale'''
93     bl_idname = "object.randomize_transform"
94     bl_label = "Randomize Transform"
95     bl_options = {'REGISTER', 'UNDO'}
96
97     random_seed = IntProperty(
98             name="Random Seed",
99             description="Seed value for the random generator",
100             min=0,
101             max=1000,
102             default=0,
103             )
104     use_delta = BoolProperty(
105             name="Transform Delta",
106             description=("Randomize delta transform values "
107                          "instead of regular transform"),
108             default=False,
109             )
110     use_loc = BoolProperty(
111             name="Randomize Location",
112             description="Randomize the location values",
113             default=True,
114             )
115     loc = FloatVectorProperty(
116             name="Location",
117             description=("Maximun distance the objects "
118                          "can spread over each axis"),
119             min=-100.0,
120             max=100.0,
121             default=(0.0, 0.0, 0.0),
122             subtype='TRANSLATION',
123             )
124     use_rot = BoolProperty(
125             name="Randomize Rotation",
126             description="Randomize the rotation values",
127             default=True,
128             )
129     rot = FloatVectorProperty(
130             name="Rotation",
131             description="Maximun rotation over each axis",
132             min=-180.0,
133             max=180.0,
134             default=(0.0, 0.0, 0.0),
135             subtype='TRANSLATION',
136             )
137     use_scale = BoolProperty(
138             name="Randomize Scale",
139             description="Randomize the scale values",
140             default=True,
141             )
142     scale_even = BoolProperty(
143             name="Scale Even",
144             description="Use the same scale value for all axis",
145             default=False,
146             )
147
148     '''scale_min = FloatProperty(name="Minimun Scale Factor",
149         description="Lowest scale percentage possible",
150         default=0.15, min=-1.0, max=1.0, precision=3)'''
151
152     scale = FloatVectorProperty(
153             name="Scale",
154             description="Maximum scale randomization over each axis",
155             min=-100.0,
156             max=100.0,
157             default=(0.0, 0.0, 0.0),
158             subtype='TRANSLATION',
159             )
160
161     def execute(self, context):
162         from math import radians
163
164         seed = self.random_seed
165
166         delta = self.use_delta
167
168         loc = None if not self.use_loc else self.loc
169         rot = None if not self.use_rot else self.rot * radians(1.0)
170         scale = None if not self.use_scale else self.scale
171
172         scale_even = self.scale_even
173         #scale_min = self.scale_min
174
175         randomize_selected(seed, delta, loc, rot, scale, scale_even)
176
177         return {'FINISHED'}