1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
|
# SPDX-License-Identifier: GPL-2.0-or-later
from bpy.types import Operator
from mathutils import Vector
import math
def get_random_transform(transform_params, entropy):
from random import uniform
from random import seed as random_seed
(seed, loc, rot, scale, scale_even) = transform_params
# First, seed the RNG.
random_seed(seed + entropy)
# Next, call uniform a known number of times.
offset_u = uniform(0, 1)
offset_v = uniform(0, 1)
angle = uniform(0, 1)
scale_u = uniform(0, 1)
scale_v = uniform(0, 1)
# Apply the transform_params.
if loc:
offset_u *= loc[0]
offset_v *= loc[1]
else:
offset_u = 0
offset_v = 0
if rot:
angle *= rot
else:
angle = 0
if scale:
scale_u = scale_u * (2 * scale[0] - 2.0) + 2.0 - scale[0]
scale_v = scale_v * (2 * scale[1] - 2.0) + 2.0 - scale[1]
else:
scale_u = 1
scale_v = 1
if scale_even:
scale_v = scale_u
# Results in homogenous co-ordinates.
return [[scale_u * math.cos(angle), -scale_v * math.sin(angle), offset_u],
[scale_u * math.sin(angle), scale_v * math.cos(angle), offset_v]]
def randomize_uv_transform_island(bm, uv_layer, faces, transform_params):
# Ensure consistent random values for island, regardless of selection etc.
entropy = min(f.index for f in faces)
transform = get_random_transform(transform_params, entropy)
# Find bounding box.
minmax = [1e30, 1e30, -1e30, -1e30]
for face in faces:
for loop in face.loops:
u, v = loop[uv_layer].uv
minmax[0] = min(minmax[0], u)
minmax[1] = min(minmax[1], v)
minmax[2] = max(minmax[2], u)
minmax[3] = max(minmax[3], v)
mid_u = (minmax[0] + minmax[2]) / 2
mid_v = (minmax[1] + minmax[3]) / 2
del_u = transform[0][2] + mid_u - transform[0][0] * mid_u - transform[0][1] * mid_v
del_v = transform[1][2] + mid_v - transform[1][0] * mid_u - transform[1][1] * mid_v
# Apply transform.
for face in faces:
for loop in face.loops:
pre_uv = loop[uv_layer].uv
u = transform[0][0] * pre_uv[0] + transform[0][1] * pre_uv[1] + del_u
v = transform[1][0] * pre_uv[0] + transform[1][1] * pre_uv[1] + del_v
loop[uv_layer].uv = (u, v)
def is_face_uv_selected(face, uv_layer):
for loop in face.loops:
if not loop[uv_layer].select:
return False
return True
def is_island_uv_selected(bm, island, uv_layer):
for face in island:
if is_face_uv_selected(face, uv_layer):
return True
return False
def randomize_uv_transform_bmesh(mesh, bm, transform_params):
import bpy_extras.bmesh_utils
uv_layer = bm.loops.layers.uv.verify()
islands = bpy_extras.bmesh_utils.bmesh_linked_uv_islands(bm, uv_layer)
for island in islands:
if is_island_uv_selected(bm, island, uv_layer):
randomize_uv_transform_island(bm, uv_layer, island, transform_params)
def randomize_uv_transform(context, transform_params):
import bmesh
ob_list = context.objects_in_mode_unique_data
for ob in ob_list:
bm = bmesh.from_edit_mesh(ob.data)
if not bm.loops.layers.uv:
continue
# Only needed to access the minimum face index of each island.
bm.faces.index_update()
randomize_uv_transform_bmesh(ob.data, bm, transform_params)
for ob in ob_list:
bmesh.update_edit_mesh(ob.data)
return {'FINISHED'}
from bpy.props import (
BoolProperty,
FloatProperty,
FloatVectorProperty,
IntProperty,
)
class RandomizeUVTransform(Operator):
"""Randomize uv island's location, rotation, and scale"""
bl_idname = "uv.randomize_uv_transform"
bl_label = "Randomize"
bl_options = {'REGISTER', 'UNDO'}
random_seed: IntProperty(
name="Random Seed",
description="Seed value for the random generator",
min=0,
max=10000,
default=0,
)
use_loc: BoolProperty(
name="Randomize Location",
description="Randomize the location values",
default=True,
)
loc: FloatVectorProperty(
name="Location",
description=("Maximum distance the objects "
"can spread over each axis"),
min=-100.0,
max=100.0,
size=2,
subtype='TRANSLATION',
default=(0.0, 0.0),
)
use_rot: BoolProperty(
name="Randomize Rotation",
description="Randomize the rotation value",
default=True,
)
rot: FloatProperty(
name="Rotation",
description="Maximum rotation",
min=-2 * math.pi,
max=2 * math.pi,
subtype='ANGLE',
default=0.0,
)
use_scale: BoolProperty(
name="Randomize Scale",
description="Randomize the scale values",
default=True,
)
scale_even: BoolProperty(
name="Scale Even",
description="Use the same scale value for both axes",
default=False,
)
scale: FloatVectorProperty(
name="Scale",
description="Maximum scale randomization over each axis",
min=-100.0,
max=100.0,
default=(1.0, 1.0),
size=2,
)
@classmethod
def poll(cls, context):
return context.mode == 'EDIT_MESH'
def execute(self, context):
seed = self.random_seed
loc = [0, 0] if not self.use_loc else self.loc
rot = 0 if not self.use_rot else self.rot
scale = None if not self.use_scale else self.scale
scale_even = self.scale_even
transformParams = [seed, loc, rot, scale, scale_even]
return randomize_uv_transform(context, transformParams)
classes = (
RandomizeUVTransform,
)
|
