# -*- coding: utf-8 -*-
import bpy
import math
from bpy.types import PropertyGroup
from mathutils import Vector
from . import cfg
from . import at_panel
from . import at_operators
from . at_calc_func import(
x_axis,
y_axis,
z_axis,
xyz_axis,
at_all_in_one,
at_random,
sum_serie,
tsr
)
"""not used yet
if check on update, may really slow the addon """
def check_list(alist):
"""check all the objects"""
for elem in alist:
if elem in bpy.data.objects:
pass
else:
cfg.display_error(str(elem)+" isn't valid.")
print("Check_list : a name isn't valid ", elem)
return False
return True
def elem_in_row(column, row, indice):
"""Number of elements in a row"""
elements = column + (row - 1) * indice
# print("row elements =", elements)
return elements
# ---------------------------- Properties ---------------------------
class ArrayTools_props(PropertyGroup):
"""Properties for array tools"""
def add_in_column(self, row, nb_column=-1):
"""Add nb_column element(s) in each row"""
column = cfg.at_count_values[0]
if nb_column == -1:
nb_column = cfg.at_count_values[1] - column
ref_name = cfg.atools_objs[0][0]
if ref_name in bpy.data.objects:
ref_obj = bpy.data.objects[ref_name]
# update the ref_mtx if object's transforms have changed
cfg.ref_mtx = ref_obj.matrix_world.copy()
# with offset no need to replace all elements, only the last
if self.is_tr_off_last:
for i in range(row):
col = column + i*self.alter
for j in range(col, col + nb_column):
objcp = ref_obj.copy()
array_col = bpy.data.collections.get(cfg.col_name)
array_col.objects.link(objcp)
if self.is_copy:
objcp.data = ref_obj.data.copy()
cfg.atools_objs[i].append(objcp.name)
self.transforms_lsr(j, i, cfg.ref_mtx, objcp.name)
# update the global ui
tr, sc, rot = self.calc_global()
self.up_ui_tr_global(tr)
self.up_ui_sc_global(sc)
self.up_ui_rot_global(rot)
else: # replace all elements
for i in range(row):
col = column + i*self.alter
for j in range(col, col + nb_column):
objcp = ref_obj.copy()
array_col = bpy.data.collections.get(cfg.col_name)
array_col.objects.link(objcp)
if self.is_copy:
objcp.data = ref_obj.data.copy()
cfg.atools_objs[i].append(objcp.name)
self.update_global(bpy.context)
del objcp
del ref_obj
else:
message = "Problem with reference object's name."
cfg.display_error(message)
print("Error in 'add_in_column' : ", message)
def del_in_column(self, row, nb_column=-1):
"""Remove nb_column element(s) in each row"""
if nb_column == -1:
nb_column = cfg.at_count_values[0] - cfg.at_count_values[1]
array_col = bpy.data.collections.get(cfg.col_name)
for i in range(row-1, -1, -1):
for j in range(nb_column):
del_name = cfg.atools_objs[i].pop()
if del_name in bpy.data.objects:
obj = bpy.data.objects[del_name]
array_col.objects.unlink(obj)
bpy.data.objects.remove(obj, do_unlink=True)
else:
cfg.display_error(del_name + " doesn't exist anymore.")
print("Error in 'del_in_column' : ", del_name)
# if no more element in list, remove the row
if not cfg.atools_objs[i]:
cfg.atools_objs.pop()
self.up_ui_updateRow(row - 1)
continue
if not self.is_tr_off_last:
# if global is used last
self.update_global(bpy.context)
else:
tr, sc, rot = self.calc_global()
self.up_ui_tr_global(tr)
self.up_ui_sc_global(sc)
self.up_ui_rot_global(rot)
def add_in_col_alter(self, row, nb_column):
"""Add elements in all rows except the first for variation"""
array_col = bpy.data.collections.get(cfg.col_name)
ref_name = cfg.atools_objs[0][0]
column = self.count
if ref_name in bpy.data.objects:
ref_obj = bpy.data.objects[ref_name]
cfg.ref_mtx = ref_obj.matrix_world.copy()
if self.is_tr_off_last:
for i in range(1, row):
for j in range(column, column + i * nb_column):
objcp = ref_obj.copy()
array_col = bpy.data.collections.get(cfg.col_name)
array_col.objects.link(objcp)
if self.is_copy:
objcp.data = ref_obj.data.copy()
cfg.atools_objs[i].append(objcp.name)
# print("objs=", cfg.atools_objs)
self.update_offset(bpy.context)
else: # replace all elements
for i in range(1, row):
for j in range(column, column + i * nb_column):
objcp = ref_obj.copy()
array_col = bpy.data.collections.get(cfg.col_name)
array_col.objects.link(objcp)
if self.is_copy:
objcp.data = ref_obj.data.copy()
cfg.atools_objs[i].append(objcp.name)
self.update_global(bpy.context)
del objcp
del ref_obj
else:
message = "Problem with reference object's name."
cfg.display_error(message)
print("Error in 'add_in_column' : ", message)
def del_in_col_alter(self, row, nb_column):
"""Remove elements in all rows except the first"""
array_col = bpy.data.collections.get(cfg.col_name)
for i in range(row -1 , 0, -1):
for j in range(nb_column * i):
del_name = cfg.atools_objs[i].pop()
# print("del name=", del_name)
if del_name in bpy.data.objects:
obj = bpy.data.objects[del_name]
array_col.objects.unlink(obj)
bpy.data.objects.remove(obj, do_unlink=True)
else:
cfg.display_error(del_name + " doesn't exist anymore.")
print("Error in 'del_in_column' : ", del_name)
if self.is_tr_off_last:
self.update_offset(bpy.context)
else:
self.update_global(bpy.context)
def add_in_row(self, column, nb_row=-1):
"""Add column elements in nb_row new row(s)"""
row = cfg.at_row_values[0]
if nb_row == -1:
nb_row = cfg.at_row_values[1] - row
ref_name = cfg.atools_objs[0][0]
if ref_name in bpy.data.objects:
ref_obj = bpy.data.objects[ref_name]
cfg.ref_mtx = ref_obj.matrix_world.copy()
if self.is_tr_off_last:
for i in range(row, row + nb_row):
cfg.atools_objs.append([])
for j in range(column + i*self.alter):
objcp = ref_obj.copy()
array_col = bpy.data.collections.get(cfg.col_name)
array_col.objects.link(objcp)
if self.is_copy:
objcp.data = ref_obj.data.copy()
cfg.atools_objs[i].append(objcp.name)
self.transforms_lsr(j, i, cfg.ref_mtx, objcp.name)
else:
for i in range(row, row + nb_row):
cfg.atools_objs.append([])
for j in range(column):
objcp = ref_obj.copy()
array_col = bpy.data.collections.get(cfg.col_name)
array_col.objects.link(objcp)
if self.is_copy:
objcp.data = ref_obj.data.copy()
cfg.atools_objs[i].append(objcp.name)
self.update_global(bpy.context)
else:
message = "Problem with reference object's name."
cfg.display_error(message)
print("Error in 'add in row' : ", message)
def del_in_row(self, nb_row=-1):
"""Remove nb_row row(s) : (column * nb_row) elements"""
if nb_row == -1:
nb_row = cfg.at_row_values[0] - cfg.at_row_values[1]
array_col = bpy.data.collections.get(cfg.col_name)
for i in range(nb_row):
names = cfg.atools_objs.pop()
for del_name in names:
if del_name in bpy.data.objects:
obj = bpy.data.objects[del_name]
array_col.objects.unlink(obj)
bpy.data.objects.remove(obj, do_unlink=True)
else:
cfg.display_error(del_name + " doesn't exist anymore.")
print("Error in 'del_in_column' : ", del_name)
def at_del_all(self, del_rall):
"""Delete all copies and remove objects from lists
del_rall : boolean, True to del reference object from list
"""
array_col = bpy.data.collections.get(cfg.col_name)
ref_name = cfg.atools_objs[0][0]
for i in range(self.row):
names = cfg.atools_objs.pop()
for obj_name in reversed(names):
if obj_name == ref_name:
continue
# test if object exist
if obj_name in bpy.data.objects:
obj = bpy.data.objects[obj_name]
array_col.objects.unlink(obj)
bpy.data.objects.remove(obj, do_unlink=True)
else:
cfg.display_error(obj_name + " not exist!")
print("Error in 'del_all' : ", obj_name)
if del_rall:
cfg.atools_objs.clear()
# removing the collection if empty
if not array_col.objects:
bpy.data.collections.remove(array_col)
else:
cfg.atools_objs.append([ref_name])
# print("Del_all done!")
# ----------------------- UI update -----------------------------
# ---------------------------------------------------------------
# ----------------------- count update --------------------------
def updateCount(self, context):
"""update the number of element(s) in column"""
if self.is_prog_change:
self.is_prog_change = False
else:
cfg.add_count(int(self.count))
cfg.del_count()
# cfg.count_values[0] always store old count value
difference = self.count - cfg.at_count_values[0]
self.update_infos()
if difference > 0:
self.add_in_column(self.row, difference)
elif difference < 0:
self.del_in_column(self.row, -difference)
# print("objs =", cfg.atools_objs)
def up_ui_updateCount(self, val):
"""Update the value of the property count in UI"""
self.is_prog_change = True
self.count = val
# ----------------------- row update ----------------------------
def update_row(self, context):
"""Update row property"""
cfg.add_row(self.row)
cfg.del_row()
if self.is_prog_change:
self.is_prog_change = False
else:
if self.alter < 0 and cfg.maxrow < self.row:
cfg.display_error("Maximun rows for these setting is : " + str(cfg.maxrow))
self.up_ui_updateRow(cfg.maxrow)
return
# cfg.at_row_values[0] always store old row value
difference = self.row - cfg.at_row_values[0]
if difference > 0:
self.add_in_row(self.count, difference)
elif difference < 0:
self.del_in_row(-difference)
line = elem_in_row(self.count, self.row, self.alter)
self.update_infos()
def up_ui_updateRow(self, val):
"""Update the value of the property row in UI"""
self.is_prog_change = True
self.row = val
def update_alter(self, context):
"""Update alter property"""
if self.is_prog_change:
self.is_prog_change = False
else:
# alter must have at least 2 rows
if self.row == 1 and self.alter != 0:
cfg.display_error("Add more rows first.")
self.up_ui_updateAlter(0)
return
if self.alter < 0:
# (column + (row-1)* variation) is the number of elements
# of the last row and must be at least >= 1
alter = int((1 - self.count) / (self.row - 1))
if self.alter < alter:
cfg.display_error("Min variation is '"+str(alter)+"' for these settings.")
self.up_ui_updateAlter(alter)
return
cfg.add_alter(self.alter)
cfg.del_alter()
self.update_ralign()
difference = self.alter - cfg.at_alter[0]
if difference > 0:
self.add_in_col_alter(self.row, difference)
elif difference < 0:
self.del_in_col_alter(self.row, -difference)
# print(f"count={self.count}, row={self.row}, alter={self.alter}")
line = elem_in_row(self.count, self.row, self.alter)
# print("elems in row =", line)
self.update_infos()
def up_ui_updateAlter(self, val):
"""Update the value of the property alter in UI"""
self.is_prog_change = True
self.alter = val
def update_ralign(self):
"""Update the value of ralign"""
decal = -self.alter * self.tr_offset
if self.align == 'LEFT':
self.ralign = Vector((0.0, 0.0, 0.0))
elif self.align == 'CENTER':
self.ralign = decal / 2
elif self.align == 'RIGHT':
self.ralign = decal
def update_align(self, context):
"""According to the value of align, calculate ralign"""
self.update_ralign()
if self.is_tr_off_last:
self.update_offset(bpy.context)
else:
self.update_global(bpy.context)
def update_infos(self):
"""Update properties total and erow"""
sum = sum_serie(self.row, self.alter)
square = self.count * self.row
if self.alter >= 0:
cfg.maxrow = self.row
else:
ca = self.count // -self.alter
cfg.maxrow = ca if self.count % self.alter == 0 else ca + 1
self.total = str(int(square + sum))
self.erow = str(elem_in_row(self.count, self.row, self.alter))
# ----------------------- translation update --------------------
def up_ui_tr_offset(self, val):
"""Update the value of the property tr_offset in UI"""
self.is_prog_change = True
self.tr_offset = val
def up_ui_tr_global(self, val):
"""Update the value of the property tr_global in UI"""
self.is_prog_change = True
self.tr_global = val
# ----------------------- scale update --------------------------
def up_ui_sc_offset(self, val):
"""Update the value of the property sc_offset in UI"""
self.is_prog_change = True
self.sc_offset = val
def up_ui_sc_global(self, val):
"""Update the value of the property sc_global in UI"""
self.is_prog_change = True
self.sc_global = val
# ----------------------- rotation update -----------------------
def up_ui_rot_offset(self, val):
"""Update the value of the property rot_offset in UI"""
self.is_prog_change = True
self.rot_offset = val
def up_ui_rot_global(self, val):
"""Update the value of the property rot_global in UI"""
self.is_prog_change = True
self.rot_global = val
# ---------------------------------------------------------------
def calc_global(self):
"""Calculate global for column"""
tg = (self.count-1) * self.tr_offset
sg = (xyz_axis() - (self.count-1) *
(cfg.ref_mtx.to_scale() - (self.sc_offset/100))) * 100
rg = self.count * Vector(self.rot_offset)
return tg,sg,rg
def transforms_lsr(self, column, row, mat, ename):
"""Calculate transforms according to the position of the element
column : indice of the element's column
row : indice of the element's row
mat : matrix of the reference object
ename : element's name to put in place
"""
localxyz = (x_axis(), y_axis(), z_axis())
translate, scaling, rotate = tsr(mat, column, row, self.tr_offset, self.tr_second,
self.sc_offset, self.sc_second, self.rot_offset, self.rot_second, self.ralign)
if ename in bpy.data.objects:
obj = bpy.data.objects[ename]
if self.at_pivot is not None:
obj.matrix_world = at_all_in_one(mat, rotate, localxyz, translate,
scaling, self.at_pivot.location)
else:
obj.matrix_world = at_all_in_one(mat, rotate, localxyz, translate,
scaling, mat.translation)
def apply_transforms(self, matx, nb_column, nb_row, tr, sc, rot):
"""Move, scale and rotate the selected elements
tr : translation offset of the first row
sc : scale offset of the first row
rot : rotation offset of the first row
return global transforms
"""
# local axis always (1,0,0) (0,1,0) (0,0,1)
localxyz = (x_axis(), y_axis(), z_axis())
ref_scale = matx.to_scale()
# duplicate code but avoid looping the test
if self.at_pivot is not None:
for i in range(nb_row):
for j in range(nb_column + i*self.alter):
elem = cfg.atools_objs[i][j]
if elem in bpy.data.objects:
obj = bpy.data.objects[elem]
else:
cfg.display_error(elem + " no more exist !")
print("Error in 'apply_transforms', name no more exist : ", elem)
continue
t_off, s_off, r_off = tsr(matx, j, i, tr, self.tr_second, sc,
self.sc_second, rot, self.rot_second, self.ralign)
obj.matrix_world = at_all_in_one(matx, r_off,
localxyz, t_off, s_off, self.at_pivot.location)
else:
for i in range(nb_row):
for j in range(nb_column + i*self.alter):
ref_loc = cfg.ref_mtx.translation
elem = cfg.atools_objs[i][j]
if elem in bpy.data.objects:
obj = bpy.data.objects[elem]
else:
cfg.display_error(elem + " no more exist !")
print("Error in 'apply_transforms', name no more exist : ", elem)
continue
t_off, s_off, r_off = tsr(matx, j, i, tr, self.tr_second, sc,
self.sc_second, rot, self.rot_second, self.ralign)
obj.matrix_world = at_all_in_one(matx, r_off,
localxyz, t_off, s_off, ref_loc)
tr_col,sc_col,rot_col = self.calc_global()
return(tr_col, sc_col, rot_col)
def update_offset(self, context):
"""Update for all offsets"""
if self.is_prog_change:
self.is_prog_change = False
else: # user change offset
self.is_tr_off_last = True
ref_name = cfg.atools_objs[0][0]
if bpy.data.objects[ref_name]:
cfg.ref_mtx = bpy.data.objects[ref_name].matrix_world.copy()
aloc, asc, arot = self.apply_transforms(cfg.ref_mtx, self.count, self.row,
self.tr_offset, self.sc_offset, Vector(self.rot_offset))
# since offset changes, global too
self.up_ui_tr_global(aloc)
self.up_ui_sc_global(asc)
self.up_ui_rot_global(arot)
def update_global(self, context):
"""Update for all globals"""
if self.is_prog_change:
self.is_prog_change = False
else: # user change global
self.is_tr_off_last = False
ref_name = cfg.atools_objs[0][0]
if bpy.data.objects[ref_name]:
cfg.ref_mtx = bpy.data.objects[ref_name].matrix_world.copy()
ref_scale = cfg.ref_mtx.to_scale()
translation_offset = Vector(self.tr_global) / (self.count - 1)
scale_offset = ref_scale - ((ref_scale-(self.sc_global/100)) / (self.count - 1))
rotation_offset = Vector(self.rot_global) / self.count
self.apply_transforms(cfg.ref_mtx, self.count, self.row, translation_offset,
Vector(scale_offset)*100, rotation_offset)
# since global changes, offset too
self.up_ui_tr_offset(translation_offset)
self.up_ui_sc_offset(Vector(scale_offset*100))
self.up_ui_rot_offset(rotation_offset)
def update_second(self, context):
"""Update the secondary transforms"""
ref_name = cfg.atools_objs[0][0]
if bpy.data.objects[ref_name]:
cfg.ref_mtx = bpy.data.objects[ref_name].matrix_world.copy()
self.apply_transforms(cfg.ref_mtx, self.count, self.row, self.tr_offset,
self.sc_offset, self.rot_offset)
# ----------------------- is_copy update ------------------------
def up_ui_is_copy(self):
"""Update the value of the property is_copy in UI"""
self.is_prog_change = True
self.is_copy = False
def update_is_copy(self, context):
"""Allow a copy or duplicate(copy link by default)"""
if self.is_prog_change:
self.is_prog_change = False
else:
if self.is_copy: # no need to rebuild all
for i in range(self.row):
for j in range(self.count):
if i == 0 and j == 0:
continue
ref_name = cfg.atools_objs[0][0]
elem_name = cfg.atools_objs[i][j]
bpy.data.objects[elem_name].data = bpy.data.objects[ref_name].data.copy()
else: # since the value change (now duplicate), need to rebuild
count = self.count
row = self.row
ref_name = cfg.atools_objs[0][0]
array_col = bpy.data.collections.get(cfg.col_name)
# DO NOT USE BLENDER CRASH WITH IT
# self.at_del_all(False)
bpy.ops.object.delete({"selected_objects": array_col.objects})
cfg.atools_objs.clear()
cfg.atools_objs.append([ref_name])
ref_obj = bpy.data.objects[ref_name]
for i in range(row):
if i != 0:
cfg.atools_objs.append([])
for j in range(count + i*self.alter):
objcp = ref_obj.copy()
array_col.objects.link(objcp)
cfg.atools_objs[i].append(objcp.name)
del objcp
del ref_obj
if self.is_tr_off_last:
self.update_offset(bpy.context)
else:
self.update_global(bpy.context)
print("Rebuild done!")
# ----------------------- random part ---------------------------
# ---------------------------------------------------------------
def update_seed(self, context):
if self.at_mode == 'ADV':
sc_min = (self.sc_min_x, self.sc_min_y, self.sc_min_z)
sc_max = (self.sc_max_x, self.sc_max_y, self.sc_max_z)
at_random(self.at_seed, self.count, self.row, self.tr_min, self.tr_max, sc_min,
sc_max, self.rot_min, self.rot_max, self.at_is_tr, self.at_is_sc, self.at_is_rot,
self.sc_all, self.tr_offset, self.tr_second, self.sc_offset, self.sc_second,
self.rot_offset, self.rot_second, self.at_pivot, self.alter, self.ralign)
else: # simple mode
vec = xyz_axis()
tr = self.tr_rand * vec
sc = self.sc_rand * vec
rot = self.rot_rand * vec
at_random(self.at_seed, self.count, self.row, -tr, tr, sc, 100*vec, -rot, rot,
self.at_is_tr, self.at_is_sc, self.at_is_rot, False, self.tr_offset,
self.tr_second, self.sc_offset, self.sc_second, self.rot_offset,
self.rot_second, self.at_pivot, self.alter, self.ralign)
def update_rtr(self, context):
"""rtr in simple mode update adv mode"""
self.tr_max = self.tr_rand * Vector((1.0, 1.0, 1.0))
self.tr_min = self.tr_rand * Vector((-1.0, -1.0, -1.0))
def update_rsc(self, context):
"""rsc in simple mode update adv mode"""
self.sc_max_x, self.sc_max_y, self.sc_max_z = (100.0, 100.0, 100.0)
rand = self.sc_rand
self.sc_min_x = rand
self.sc_min_y = rand
self.sc_min_z = rand
def update_rrot(self, context):
"""rrot in simple mode update adv mode"""
self.rot_max = self.rot_rand * Vector((1.0, 1.0, 1.0))
self.rot_min = self.rot_rand * Vector((-1.0, -1.0, -1.0))
def up_ui_sc_min_x(self, val):
"""Update the value of the property sc_min_x in UI"""
self.is_prog_change = True
self.sc_min_x = val
def up_ui_sc_min_y(self, val):
"""Update the value of the property sc_min_y in UI"""
self.is_prog_change = True
self.sc_min_y = val
def up_ui_sc_min_z(self, val):
"""Update the value of the property sc_min_z in UI"""
self.is_prog_change = True
self.sc_min_z = val
def up_ui_sc_max_x(self, val):
"""Update the value of the property sc_max_x in UI"""
self.is_prog_change = True
self.sc_max_x = val
def up_ui_sc_max_y(self, val):
"""Update the value of the property sc_max_y in UI"""
self.is_prog_change = True
self.sc_max_y = val
def up_ui_sc_max_z(self, val):
"""Update the value of the property sc_max_z in UI"""
self.is_prog_change = True
self.sc_max_z = val
# -------------- update min and max -----------------------------
# if user enter a max value < min, change min and vice versa
def up_tr_min(self, context):
"""Update tr_max if tr_min is higher"""
if self.is_prog_change:
self.is_prog_change = False
else:
for i in range(3):
if self.tr_min[i] > self.tr_max[i]:
self.is_prog_change = True
self.tr_max[i] = self.tr_min[i]
def up_tr_max(self, context):
"""Update tr_min if tr_max is lower"""
if self.is_prog_change:
self.is_prog_change = False
else:
for i in range(3):
if self.tr_min[i] > self.tr_max[i]:
self.is_prog_change = True
self.tr_min[i] = self.tr_max[i]
def up_sc_min_x(self, context):
"""Update sc_max_x if sc_min_x is higher"""
if self.is_prog_change:
self.is_prog_change = False
else:
test = self.sc_min_x > self.sc_max_x
if test and self.sc_all:
# case : min > max and uniform = True
self.up_ui_sc_max_x(self.sc_min_x)
# with uniform : min_x = min_y = min_z same for max_
self.up_ui_sc_min_y(self.sc_min_x)
self.up_ui_sc_min_z(self.sc_min_x)
self.up_ui_sc_max_y(self.sc_min_x)
self.up_ui_sc_max_z(self.sc_min_x)
elif self.sc_all:
# case : min < max and uniform = True
self.up_ui_sc_min_y(self.sc_min_x)
self.up_ui_sc_min_z(self.sc_min_x)
self.up_ui_sc_max_y(self.sc_max_x)
self.up_ui_sc_max_z(self.sc_max_x)
elif test:
# case : min > max and uniform = False
self.up_ui_sc_max_x(self.sc_min_x)
def up_sc_min_y(self, context):
"""Update sc_max_y if sc_min_y is higher"""
if self.is_prog_change:
self.is_prog_change = False
else:
test = self.sc_min_y > self.sc_max_y
if test and self.sc_all:
# case : min > max and uniform = True
self.up_ui_sc_max_y(self.sc_min_y)
# with uniform : min_x = min_y = min_z same for max_
self.up_ui_sc_min_x(self.sc_min_y)
self.up_ui_sc_min_z(self.sc_min_y)
self.up_ui_sc_max_x(self.sc_min_y)
self.up_ui_sc_max_y(self.sc_min_y)
elif self.sc_all:
# case : min < max and uniform = True
self.up_ui_sc_min_x(self.sc_min_y)
self.up_ui_sc_min_z(self.sc_min_y)
self.up_ui_sc_max_x(self.sc_max_y)
self.up_ui_sc_max_z(self.sc_max_y)
elif test:
# case : min > max and uniform = False
self.up_ui_sc_max_y(self.sc_min_y)
def up_sc_min_z(self, context):
"""Update sc_max_z if sc_min_z is higher"""
if self.is_prog_change:
self.is_prog_change = False
else:
test = self.sc_min_z > self.sc_max_z
if test and self.sc_all:
# case : min > max and uniform = True
self.up_ui_sc_max_z(self.sc_min_z)
# with uniform : min_x = min_y = min_z same for max_
self.up_ui_sc_min_x(self.sc_min_z)
self.up_ui_sc_min_y(self.sc_min_z)
self.up_ui_sc_max_x(self.sc_min_z)
self.up_ui_sc_max_y(self.sc_min_z)
elif self.sc_all:
# case : min < max and uniform = True
self.up_ui_sc_min_x(self.sc_min_z)
self.up_ui_sc_min_y(self.sc_min_z)
self.up_ui_sc_max_x(self.sc_max_z)
self.up_ui_sc_max_y(self.sc_max_z)
elif test:
# case : min > max and uniform = False
self.up_ui_sc_max_y(self.sc_min_z)
def up_sc_max_x(self, context):
"""Update sc_min_x if sc_max_x is lower"""
if self.is_prog_change:
self.is_prog_change = False
else:
test = self.sc_min_x > self.sc_max_x
if test and self.sc_all:
# case : min > max and uniform = True
self.up_ui_sc_min_x(self.sc_max_x)
# with uniform : min_x = min_y = min_z same for max_
self.up_ui_sc_max_y(self.sc_max_x)
self.up_ui_sc_max_z(self.sc_max_x)
self.up_ui_sc_min_y(self.sc_max_x)
self.up_ui_sc_min_z(self.sc_max_x)
elif self.sc_all:
# case : min < max and uniform = True
self.up_ui_sc_max_y(self.sc_max_x)
self.up_ui_sc_max_z(self.sc_max_x)
self.up_ui_sc_min_y(self.sc_min_x)
self.up_ui_sc_min_z(self.sc_min_x)
elif test:
# case : min > max and uniform = False
self.up_ui_sc_min_x(self.sc_max_x)
def up_sc_max_y(self, context):
"""Update sc_min_y if sc_max_y is lower"""
if self.is_prog_change:
self.is_prog_change = False
else:
test = self.sc_min_y > self.sc_max_y
if test and self.sc_all:
# case : min > max and uniform = True
self.up_ui_sc_min_y(self.sc_max_y)
# with uniform : min_x = min_y = min_z same for max_
self.up_ui_sc_max_x(self.sc_max_y)
self.up_ui_sc_max_z(self.sc_max_y)
self.up_ui_sc_min_x(self.sc_max_y)
self.up_ui_sc_min_z(self.sc_max_y)
elif self.sc_all:
# case : min < max and uniform = True
self.up_ui_sc_max_x(self.sc_max_y)
self.up_ui_sc_max_z(self.sc_max_y)
self.up_ui_sc_min_x(self.sc_min_y)
self.up_ui_sc_min_z(self.sc_min_y)
elif test:
# case : min > max and uniform = False
self.up_ui_sc_min_y(self.sc_max_y)
def up_sc_max_z(self, context):
"""Update sc_min_z if sc_max_z is lower"""
if self.is_prog_change:
self.is_prog_change = False
else:
test = self.sc_min_z > self.sc_max_z
if test and self.sc_all:
# case : min > max and uniform = True
self.up_ui_sc_min_z(self.sc_max_z)
# with uniform : min_x = min_y = min_z same for max_
self.up_ui_sc_max_x(self.sc_max_z)
self.up_ui_sc_max_y(self.sc_max_z)
self.up_ui_sc_min_x(self.sc_max_z)
self.up_ui_sc_min_y(self.sc_max_z)
elif self.sc_all:
# case : min < max and uniform = True
self.up_ui_sc_max_x(self.sc_max_z)
self.up_ui_sc_max_y(self.sc_max_z)
self.up_ui_sc_min_x(self.sc_min_z)
self.up_ui_sc_min_y(self.sc_min_z)
elif test:
# case : min > max and uniform = False
self.up_ui_sc_min_z(self.sc_max_z)
def up_rot_min(self, context):
"""Update rot_max if rot_min is higher"""
if self.is_prog_change:
self.is_prog_change = False
else:
for i in range(3):
if self.rot_min[i] > self.rot_max[i]:
self.is_prog_change = True
self.rot_max[i] = self.rot_min[i]
def up_rot_max(self, context):
"""Update rot_min if rot_max is lower"""
if self.is_prog_change:
self.is_prog_change = False
else:
for i in range(3):
if self.rot_min[i] > self.rot_max[i]:
self.is_prog_change = True
self.rot_min[i] = self.rot_max[i]
# ----------------------- reset all properties ------------------
def up_ui_reset(self):
"""Reset all UI properties"""
self.up_ui_updateCount(2)
self.up_ui_updateRow(1)
self.up_ui_is_copy()
self.up_ui_tr_offset(Vector((2.0, 0.0, 0.0)))
self.up_ui_tr_global(Vector((2.0, 0.0, 0.0)))
self.up_ui_sc_offset((100, 100, 100))
self.up_ui_sc_global((100, 100, 100))
self.up_ui_rot_offset(Vector((0.0, 0.0, 0.0)))
self.up_ui_rot_global(Vector((0.0, 0.0, 0.0)))
self.up_ui_updateAlter(0)
self.total = "2"
self.erow = "2"
count: bpy.props.IntProperty(
name='Count',
description="Number of elements, original count as one",
default=2,
soft_min=2,
update=updateCount
)
row: bpy.props.IntProperty(
name="Row",
description="Number of row(s)",
default=1,
soft_min=1,
soft_max=100,
update=update_row
)
"""Allow a variation in the row :
if row gets n elements, row +1 will get (n + variation) elements
only if n + variation > 0
"""
alter: bpy.props.IntProperty(
name=" Row variation",
description="""Variation in the number of elements in a row. (between -5 and 5).
\n Be careful with it""",
default=0,
soft_min=-5,
soft_max=5,
update=update_alter
)
total: bpy.props.StringProperty(
name="Total",
description="Total of elements in array",
default="2"
)
erow: bpy.props.StringProperty(
description="Number of elements in the current row.",
default="2"
)
# if alter <> 0, how align the rows
align: bpy.props.EnumProperty(
name='Align',
description="Align of rows when variation is not zero",
items=[
('LEFT', 'Left', "Align to the left", 'ALIGN_LEFT', 0),
('CENTER', 'Center', "Align to the center", 'ALIGN_CENTER', 1),
('RIGHT', 'Right', "Align to the right", 'ALIGN_RIGHT', 2)
],
default='LEFT',
update=update_align
)
# Vector alignment depends on align
ralign: bpy.props.FloatVectorProperty(
subtype='TRANSLATION',
unit='LENGTH',
default=(0.0, 0.0, 0.0)
)
# booleans use to know if user or prog change the value to avoid continuous loop
is_prog_change: bpy.props.BoolProperty(default=False) # True if prog change value
# which one between offset and global user calls last, True is offset, False global
is_tr_off_last: bpy.props.BoolProperty(default=True)
# True if addon is initialised
already_start: bpy.props.BoolProperty(default=False)
# if the user need a single copy or a duplicate (link object)
is_copy: bpy.props.BoolProperty(
name="Copy only",
description="Duplicate or copy, default is duplicate",
default=False,
update=update_is_copy
)
# translation vector offset
tr_offset: bpy.props.FloatVectorProperty(
name='Offset',
description="Distance between elements",
default=(2.0, 0.0, 0.0),
subtype='TRANSLATION',
unit='LENGTH',
precision=2,
step=50,
options={'ANIMATABLE'},
update=update_offset
)
# global translation distance
tr_global: bpy.props.FloatVectorProperty(
name='Global',
description="Distance between the original and the last element",
default=(2.0, 0.0, 0.0),
subtype='TRANSLATION',
unit='LENGTH',
precision=2,
step=50,
options={'ANIMATABLE'},
update=update_global
)
tr_second: bpy.props.FloatVectorProperty(
name="Translation",
description="Additional offset distance for rows",
default=(0.0, 0.0, 0.0),
subtype='TRANSLATION',
unit='LENGTH',
precision=2,
step=50,
update=update_second
)
at_pivot: bpy.props.PointerProperty(
name='Pivot',
description="Object you want as pivot point. If none, pivot point is the object's origine",
type=bpy.types.Object
)
# scaling vector offset
sc_offset: bpy.props.FloatVectorProperty(
name='Offset',
description="Incremental scale of the next elements",
default=(100.0, 100.0, 100.0),
subtype='XYZ',
precision=1,
step=100,
options={'ANIMATABLE'},
update=update_offset
)
# global scaling
sc_global: bpy.props.FloatVectorProperty(
name='Global',
description="Scale of the last element",
default=(100.0, 100.0, 100.0),
subtype='XYZ',
precision=1,
step=100,
options={'ANIMATABLE'},
update=update_global
)
sc_second: bpy.props.FloatVectorProperty(
name='Scale',
description="Additionnal scale for rows",
default=(100.0, 100.0, 100.0),
subtype='XYZ',
precision=1,
step=100,
options={'ANIMATABLE'},
update=update_second
)
# rotation vector offset
rot_offset: bpy.props.FloatVectorProperty(
name='Offset',
description="Angle between each element",
default=(0.0, 0.0, 0.0),
subtype='XYZ',
unit='ROTATION',
step=500, # = 5
options={'ANIMATABLE'},
update=update_offset
)
# global rotation
rot_global: bpy.props.FloatVectorProperty(
name='Global',
description="Maximum angle from the reference to the last element",
default=(0.0, 0.0, 0.0),
subtype='XYZ',
unit='ROTATION',
step=500, # = 5
options={'ANIMATABLE'},
update=update_global
)
rot_second: bpy.props.FloatVectorProperty(
name='Rotation',
description="Additionnal rotation for rows",
default=(0.0, 0.0, 0.0),
subtype='XYZ',
unit='ROTATION',
step=500,
options={'ANIMATABLE'},
update=update_second
)
# ----------------------- random part ---------------------------
at_seed: bpy.props.IntProperty(
name='Seed',
description="Seed value for random",
soft_min=0,
default=0,
update=update_seed
)
at_mode: bpy.props.EnumProperty(
name="Mode",
description="Choose between simple mode or advanced",
items=(('SIM', 'Simple', "Simple mode"),
('ADV', 'Advanced', "Advanced mode")),
default='SIM'
)
at_is_tr: bpy.props.BoolProperty(
name="Add translation",
description="Add translation in random?",
default=False
)
at_is_sc: bpy.props.BoolProperty(
name="Add scale",
description="Add scale in random?",
default=False
)
at_is_rot: bpy.props.BoolProperty(
name="Add rotation",
description="Add rotation in random?",
default=False
)
tr_min: bpy.props.FloatVectorProperty(
name="min",
description="Minimum random value for translation",
unit='LENGTH',
default=(0.0, 0.0, 0.0),
update=up_tr_min
)
tr_max: bpy.props.FloatVectorProperty(
name="max",
description="Maximum random value for translation",
unit='LENGTH',
default=(0.0, 0.0, 0.0),
update=up_tr_max
)
tr_rand: bpy.props.FloatProperty(
name="Translation",
description="Random values for all axis",
unit='LENGTH',
default=0.0,
update=update_rtr
)
sc_all: bpy.props.BoolProperty(
name="uniform scale",
description="Uniform or non uniform scale, default is non uniform.",
default=False
)
sc_min_x: bpy.props.IntProperty(
name="min",
description="Minimum random value for x scale",
default=100,
update=up_sc_min_x
)
sc_min_y: bpy.props.IntProperty(
name="min",
description="Minimum random value for y scale",
default=100,
update=up_sc_min_y
)
sc_min_z: bpy.props.IntProperty(
name="min",
description="Minimum random value for z scale",
default=100,
update=up_sc_min_z
)
sc_max_x: bpy.props.IntProperty(
name="max",
description="Maximum random value for x scale",
default=100,
update=up_sc_max_x
)
sc_max_y: bpy.props.IntProperty(
name="max",
description="Maximum random value for y scale",
default=100,
update=up_sc_max_y
)
sc_max_z: bpy.props.IntProperty(
name="max",
description="Maximum random value for z scale",
default=100,
update=up_sc_max_z
)
sc_rand: bpy.props.IntProperty(
name="Scale",
description="Random scale value for all axis",
default=100,
update=update_rsc
)
rot_min: bpy.props.FloatVectorProperty(
name="min",
description="Minimum random value for rotation",
unit='ROTATION',
default=(0.0, 0.0, 0.0),
update=up_rot_min
)
rot_max: bpy.props.FloatVectorProperty(
name="max",
description="Maximum random value for rotation",
unit='ROTATION',
default=(0.0, 0.0, 0.0),
update=up_rot_max
)
rot_rand: bpy.props.FloatProperty(
name="Rotation",
description="Random rotation for all axis",
unit='ROTATION',
default=0.0,
update=update_rrot
)