forked from bartvdbraak/blender
8b9a3b94fc
The storage of IDProperty UI data (min, max, default value, etc) is
quite complicated. For every property, retrieving a single one of these
values involves three string lookups. First for the "_RNA_UI" group
property, then another for a group with the property's name, then for
the data value name. Not only is this inefficient, it's hard to reason
about, unintuitive, and not at all self-explanatory.
This commit replaces that system with a UI data struct directly in the
IDProperty. If it's not used, the only cost is of a NULL pointer. Beyond
storing the description, name, and RNA subtype, derived structs are used
to store type specific UI data like min and max.
Note that this means that addons using (abusing) the `_RNA_UI` custom
property will have to be changed. A few places in the addons repository
will be changed after this commit with D9919.
**Before**
Before, first the _RNA_UI subgroup is retrieved the _RNA_UI group,
then the subgroup for the original property, then specific UI data
is accessed like any other IDProperty.
```
prop = rna_idprop_ui_prop_get(idproperties_owner, "prop_name", create=True)
prop["min"] = 1.0
```
**After**
After, the `id_properties_ui` function for RNA structs returns a python
object specifically for managing an IDProperty's UI data.
```
ui_data = idproperties_owner.id_properties_ui("prop_name")
ui_data.update(min=1.0)
```
In addition to `update`, there are now other functions:
- `as_dict`: Returns a dictionary of the property's UI data.
- `clear`: Removes the property's UI data.
- `update_from`: Copy UI data between properties,
even if they have different owners.
Differential Revision: https://developer.blender.org/D9697
1015 lines
35 KiB
Python
1015 lines
35 KiB
Python
# ##### BEGIN GPL LICENSE BLOCK #####
|
|
#
|
|
# This program is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU General Public License
|
|
# as published by the Free Software Foundation; either version 2
|
|
# of the License, or (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
#
|
|
# ##### END GPL LICENSE BLOCK #####
|
|
|
|
# <pep8-80 compliant>
|
|
|
|
import bpy
|
|
from bpy.types import Operator
|
|
from bpy.props import (
|
|
BoolProperty,
|
|
EnumProperty,
|
|
IntProperty,
|
|
StringProperty,
|
|
)
|
|
|
|
|
|
class SelectPattern(Operator):
|
|
"""Select objects matching a naming pattern"""
|
|
bl_idname = "object.select_pattern"
|
|
bl_label = "Select Pattern"
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
pattern: StringProperty(
|
|
name="Pattern",
|
|
description="Name filter using '*', '?' and "
|
|
"'[abc]' unix style wildcards",
|
|
maxlen=64,
|
|
default="*",
|
|
)
|
|
case_sensitive: BoolProperty(
|
|
name="Case Sensitive",
|
|
description="Do a case sensitive compare",
|
|
default=False,
|
|
)
|
|
extend: BoolProperty(
|
|
name="Extend",
|
|
description="Extend the existing selection",
|
|
default=True,
|
|
)
|
|
|
|
def execute(self, context):
|
|
|
|
import fnmatch
|
|
|
|
if self.case_sensitive:
|
|
pattern_match = fnmatch.fnmatchcase
|
|
else:
|
|
pattern_match = (lambda a, b:
|
|
fnmatch.fnmatchcase(a.upper(), b.upper()))
|
|
is_ebone = False
|
|
is_pbone = False
|
|
obj = context.object
|
|
if obj and obj.mode == 'POSE':
|
|
items = obj.data.bones
|
|
if not self.extend:
|
|
bpy.ops.pose.select_all(action='DESELECT')
|
|
is_pbone = True
|
|
elif obj and obj.type == 'ARMATURE' and obj.mode == 'EDIT':
|
|
items = obj.data.edit_bones
|
|
if not self.extend:
|
|
bpy.ops.armature.select_all(action='DESELECT')
|
|
is_ebone = True
|
|
else:
|
|
items = context.visible_objects
|
|
if not self.extend:
|
|
bpy.ops.object.select_all(action='DESELECT')
|
|
|
|
# Can be pose bones, edit bones or objects
|
|
for item in items:
|
|
if pattern_match(item.name, self.pattern):
|
|
|
|
# hrmf, perhaps there should be a utility function for this.
|
|
if is_ebone:
|
|
item.select = True
|
|
item.select_head = True
|
|
item.select_tail = True
|
|
if item.use_connect:
|
|
item_parent = item.parent
|
|
if item_parent is not None:
|
|
item_parent.select_tail = True
|
|
elif is_pbone:
|
|
item.select = True
|
|
else:
|
|
item.select_set(True)
|
|
|
|
return {'FINISHED'}
|
|
|
|
def invoke(self, context, event):
|
|
wm = context.window_manager
|
|
return wm.invoke_props_popup(self, event)
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
|
|
layout.prop(self, "pattern")
|
|
row = layout.row()
|
|
row.prop(self, "case_sensitive")
|
|
row.prop(self, "extend")
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
obj = context.object
|
|
return (not obj) or (obj.mode == 'OBJECT') or (obj.type == 'ARMATURE')
|
|
|
|
|
|
class SelectCamera(Operator):
|
|
"""Select the active camera"""
|
|
bl_idname = "object.select_camera"
|
|
bl_label = "Select Camera"
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
extend: BoolProperty(
|
|
name="Extend",
|
|
description="Extend the selection",
|
|
default=False,
|
|
)
|
|
|
|
def execute(self, context):
|
|
scene = context.scene
|
|
view_layer = context.view_layer
|
|
view = context.space_data
|
|
if view and view.type == 'VIEW_3D' and view.use_local_camera:
|
|
camera = view.camera
|
|
else:
|
|
camera = scene.camera
|
|
|
|
if camera is None:
|
|
self.report({'WARNING'}, "No camera found")
|
|
elif camera.name not in scene.objects:
|
|
self.report({'WARNING'}, "Active camera is not in this scene")
|
|
else:
|
|
if not self.extend:
|
|
bpy.ops.object.select_all(action='DESELECT')
|
|
view_layer.objects.active = camera
|
|
# camera.hide = False # XXX TODO where is this now?
|
|
camera.select_set(True)
|
|
return {'FINISHED'}
|
|
|
|
return {'CANCELLED'}
|
|
|
|
|
|
class SelectHierarchy(Operator):
|
|
"""Select object relative to the active object's position """ \
|
|
"""in the hierarchy"""
|
|
bl_idname = "object.select_hierarchy"
|
|
bl_label = "Select Hierarchy"
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
direction: EnumProperty(
|
|
items=(
|
|
('PARENT', "Parent", ""),
|
|
('CHILD', "Child", ""),
|
|
),
|
|
name="Direction",
|
|
description="Direction to select in the hierarchy",
|
|
default='PARENT',
|
|
)
|
|
extend: BoolProperty(
|
|
name="Extend",
|
|
description="Extend the existing selection",
|
|
default=False,
|
|
)
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return context.object
|
|
|
|
def execute(self, context):
|
|
view_layer = context.view_layer
|
|
select_new = []
|
|
act_new = None
|
|
|
|
selected_objects = context.selected_objects
|
|
obj_act = context.object
|
|
|
|
if context.object not in selected_objects:
|
|
selected_objects.append(context.object)
|
|
|
|
if self.direction == 'PARENT':
|
|
for obj in selected_objects:
|
|
parent = obj.parent
|
|
|
|
if parent and parent.visible_get():
|
|
if obj_act == obj:
|
|
act_new = parent
|
|
|
|
select_new.append(parent)
|
|
|
|
else:
|
|
for obj in selected_objects:
|
|
select_new.extend([child for child in obj.children if child.visible_get()])
|
|
|
|
if select_new:
|
|
select_new.sort(key=lambda obj_iter: obj_iter.name)
|
|
act_new = select_new[0]
|
|
|
|
# don't edit any object settings above this
|
|
if select_new:
|
|
if not self.extend:
|
|
bpy.ops.object.select_all(action='DESELECT')
|
|
|
|
for obj in select_new:
|
|
obj.select_set(True)
|
|
|
|
view_layer.objects.active = act_new
|
|
return {'FINISHED'}
|
|
|
|
return {'CANCELLED'}
|
|
|
|
|
|
class SubdivisionSet(Operator):
|
|
"""Sets a Subdivision Surface level (1 to 5)"""
|
|
|
|
bl_idname = "object.subdivision_set"
|
|
bl_label = "Subdivision Set"
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
level: IntProperty(
|
|
name="Level",
|
|
min=-100, max=100,
|
|
soft_min=-6, soft_max=6,
|
|
default=1,
|
|
)
|
|
relative: BoolProperty(
|
|
name="Relative",
|
|
description=("Apply the subdivision surface level as an offset "
|
|
"relative to the current level"),
|
|
default=False,
|
|
)
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
obs = context.selected_editable_objects
|
|
return (obs is not None)
|
|
|
|
def execute(self, context):
|
|
level = self.level
|
|
relative = self.relative
|
|
|
|
if relative and level == 0:
|
|
return {'CANCELLED'} # nothing to do
|
|
|
|
if not relative and level < 0:
|
|
self.level = level = 0
|
|
|
|
def set_object_subd(obj):
|
|
for mod in obj.modifiers:
|
|
if mod.type == 'MULTIRES':
|
|
if not relative:
|
|
if level > mod.total_levels:
|
|
sub = level - mod.total_levels
|
|
for _ in range(sub):
|
|
bpy.ops.object.multires_subdivide(modifier="Multires")
|
|
|
|
if obj.mode == 'SCULPT':
|
|
if mod.sculpt_levels != level:
|
|
mod.sculpt_levels = level
|
|
elif obj.mode == 'OBJECT':
|
|
if mod.levels != level:
|
|
mod.levels = level
|
|
return
|
|
else:
|
|
if obj.mode == 'SCULPT':
|
|
if mod.sculpt_levels + level <= mod.total_levels:
|
|
mod.sculpt_levels += level
|
|
elif obj.mode == 'OBJECT':
|
|
if mod.levels + level <= mod.total_levels:
|
|
mod.levels += level
|
|
return
|
|
|
|
elif mod.type == 'SUBSURF':
|
|
if relative:
|
|
mod.levels += level
|
|
else:
|
|
if mod.levels != level:
|
|
mod.levels = level
|
|
|
|
return
|
|
|
|
# add a new modifier
|
|
try:
|
|
if obj.mode == 'SCULPT':
|
|
mod = obj.modifiers.new("Multires", 'MULTIRES')
|
|
if level > 0:
|
|
for _ in range(level):
|
|
bpy.ops.object.multires_subdivide(modifier="Multires")
|
|
else:
|
|
mod = obj.modifiers.new("Subdivision", 'SUBSURF')
|
|
mod.levels = level
|
|
except:
|
|
self.report({'WARNING'},
|
|
"Modifiers cannot be added to object: " + obj.name)
|
|
|
|
for obj in context.selected_editable_objects:
|
|
set_object_subd(obj)
|
|
|
|
return {'FINISHED'}
|
|
|
|
|
|
class ShapeTransfer(Operator):
|
|
"""Copy the active shape key of another selected object to this one"""
|
|
|
|
bl_idname = "object.shape_key_transfer"
|
|
bl_label = "Transfer Shape Key"
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
mode: EnumProperty(
|
|
items=(
|
|
('OFFSET',
|
|
"Offset",
|
|
"Apply the relative positional offset",
|
|
),
|
|
('RELATIVE_FACE',
|
|
"Relative Face",
|
|
"Calculate relative position (using faces)",
|
|
),
|
|
('RELATIVE_EDGE',
|
|
"Relative Edge",
|
|
"Calculate relative position (using edges)",
|
|
),
|
|
),
|
|
name="Transformation Mode",
|
|
description="Relative shape positions to the new shape method",
|
|
default='OFFSET',
|
|
)
|
|
use_clamp: BoolProperty(
|
|
name="Clamp Offset",
|
|
description=("Clamp the transformation to the distance each "
|
|
"vertex moves in the original shape"),
|
|
default=False,
|
|
)
|
|
|
|
def _main(self, ob_act, objects, mode='OFFSET', use_clamp=False):
|
|
|
|
def me_nos(verts):
|
|
return [v.normal.copy() for v in verts]
|
|
|
|
def me_cos(verts):
|
|
return [v.co.copy() for v in verts]
|
|
|
|
def ob_add_shape(ob, name):
|
|
me = ob.data
|
|
key = ob.shape_key_add(from_mix=False)
|
|
if len(me.shape_keys.key_blocks) == 1:
|
|
key.name = "Basis"
|
|
key = ob.shape_key_add(from_mix=False) # we need a rest
|
|
key.name = name
|
|
ob.active_shape_key_index = len(me.shape_keys.key_blocks) - 1
|
|
ob.show_only_shape_key = True
|
|
|
|
from mathutils.geometry import barycentric_transform
|
|
from mathutils import Vector
|
|
|
|
if use_clamp and mode == 'OFFSET':
|
|
use_clamp = False
|
|
|
|
me = ob_act.data
|
|
orig_key_name = ob_act.active_shape_key.name
|
|
|
|
orig_shape_coords = me_cos(ob_act.active_shape_key.data)
|
|
|
|
orig_normals = me_nos(me.vertices)
|
|
# actual mesh vertex location isn't as reliable as the base shape :S
|
|
# orig_coords = me_cos(me.vertices)
|
|
orig_coords = me_cos(me.shape_keys.key_blocks[0].data)
|
|
|
|
for ob_other in objects:
|
|
if ob_other.type != 'MESH':
|
|
self.report({'WARNING'},
|
|
("Skipping '%s', "
|
|
"not a mesh") % ob_other.name)
|
|
continue
|
|
me_other = ob_other.data
|
|
if len(me_other.vertices) != len(me.vertices):
|
|
self.report({'WARNING'},
|
|
("Skipping '%s', "
|
|
"vertex count differs") % ob_other.name)
|
|
continue
|
|
|
|
target_normals = me_nos(me_other.vertices)
|
|
if me_other.shape_keys:
|
|
target_coords = me_cos(me_other.shape_keys.key_blocks[0].data)
|
|
else:
|
|
target_coords = me_cos(me_other.vertices)
|
|
|
|
ob_add_shape(ob_other, orig_key_name)
|
|
|
|
# editing the final coords, only list that stores wrapped coords
|
|
target_shape_coords = [v.co for v in
|
|
ob_other.active_shape_key.data]
|
|
|
|
median_coords = [[] for i in range(len(me.vertices))]
|
|
|
|
# Method 1, edge
|
|
if mode == 'OFFSET':
|
|
for i, vert_cos in enumerate(median_coords):
|
|
vert_cos.append(target_coords[i] +
|
|
(orig_shape_coords[i] - orig_coords[i]))
|
|
|
|
elif mode == 'RELATIVE_FACE':
|
|
for poly in me.polygons:
|
|
idxs = poly.vertices[:]
|
|
v_before = idxs[-2]
|
|
v = idxs[-1]
|
|
for v_after in idxs:
|
|
pt = barycentric_transform(orig_shape_coords[v],
|
|
orig_coords[v_before],
|
|
orig_coords[v],
|
|
orig_coords[v_after],
|
|
target_coords[v_before],
|
|
target_coords[v],
|
|
target_coords[v_after],
|
|
)
|
|
median_coords[v].append(pt)
|
|
v_before = v
|
|
v = v_after
|
|
|
|
elif mode == 'RELATIVE_EDGE':
|
|
for ed in me.edges:
|
|
i1, i2 = ed.vertices
|
|
v1, v2 = orig_coords[i1], orig_coords[i2]
|
|
edge_length = (v1 - v2).length
|
|
n1loc = v1 + orig_normals[i1] * edge_length
|
|
n2loc = v2 + orig_normals[i2] * edge_length
|
|
|
|
# now get the target nloc's
|
|
v1_to, v2_to = target_coords[i1], target_coords[i2]
|
|
edlen_to = (v1_to - v2_to).length
|
|
n1loc_to = v1_to + target_normals[i1] * edlen_to
|
|
n2loc_to = v2_to + target_normals[i2] * edlen_to
|
|
|
|
pt = barycentric_transform(orig_shape_coords[i1],
|
|
v2, v1, n1loc,
|
|
v2_to, v1_to, n1loc_to)
|
|
median_coords[i1].append(pt)
|
|
|
|
pt = barycentric_transform(orig_shape_coords[i2],
|
|
v1, v2, n2loc,
|
|
v1_to, v2_to, n2loc_to)
|
|
median_coords[i2].append(pt)
|
|
|
|
# apply the offsets to the new shape
|
|
from functools import reduce
|
|
VectorAdd = Vector.__add__
|
|
|
|
for i, vert_cos in enumerate(median_coords):
|
|
if vert_cos:
|
|
co = reduce(VectorAdd, vert_cos) / len(vert_cos)
|
|
|
|
if use_clamp:
|
|
# clamp to the same movement as the original
|
|
# breaks copy between different scaled meshes.
|
|
len_from = (orig_shape_coords[i] -
|
|
orig_coords[i]).length
|
|
ofs = co - target_coords[i]
|
|
ofs.length = len_from
|
|
co = target_coords[i] + ofs
|
|
|
|
target_shape_coords[i][:] = co
|
|
|
|
return {'FINISHED'}
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
obj = context.active_object
|
|
return (obj and obj.mode != 'EDIT')
|
|
|
|
def execute(self, context):
|
|
ob_act = context.active_object
|
|
objects = [ob for ob in context.selected_editable_objects
|
|
if ob != ob_act]
|
|
|
|
if 1: # swap from/to, means we can't copy to many at once.
|
|
if len(objects) != 1:
|
|
self.report({'ERROR'},
|
|
("Expected one other selected "
|
|
"mesh object to copy from"))
|
|
|
|
return {'CANCELLED'}
|
|
ob_act, objects = objects[0], [ob_act]
|
|
|
|
if ob_act.type != 'MESH':
|
|
self.report({'ERROR'}, "Other object is not a mesh")
|
|
return {'CANCELLED'}
|
|
|
|
if ob_act.active_shape_key is None:
|
|
self.report({'ERROR'}, "Other object has no shape key")
|
|
return {'CANCELLED'}
|
|
return self._main(ob_act, objects, self.mode, self.use_clamp)
|
|
|
|
|
|
class JoinUVs(Operator):
|
|
"""Transfer UV Maps from active to selected objects """ \
|
|
"""(needs matching geometry)"""
|
|
bl_idname = "object.join_uvs"
|
|
bl_label = "Transfer UV Maps"
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
obj = context.active_object
|
|
return (obj and obj.type == 'MESH')
|
|
|
|
def _main(self, context):
|
|
import array
|
|
obj = context.active_object
|
|
mesh = obj.data
|
|
|
|
is_editmode = (obj.mode == 'EDIT')
|
|
if is_editmode:
|
|
bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
|
|
|
|
if not mesh.uv_layers:
|
|
self.report({'WARNING'},
|
|
"Object: %s, Mesh: '%s' has no UVs"
|
|
% (obj.name, mesh.name))
|
|
else:
|
|
nbr_loops = len(mesh.loops)
|
|
|
|
# seems to be the fastest way to create an array
|
|
uv_array = array.array('f', [0.0] * 2) * nbr_loops
|
|
mesh.uv_layers.active.data.foreach_get("uv", uv_array)
|
|
|
|
objects = context.selected_editable_objects[:]
|
|
|
|
for obj_other in objects:
|
|
if obj_other.type == 'MESH':
|
|
obj_other.data.tag = False
|
|
|
|
for obj_other in objects:
|
|
if obj_other != obj and obj_other.type == 'MESH':
|
|
mesh_other = obj_other.data
|
|
if mesh_other != mesh:
|
|
if mesh_other.tag is False:
|
|
mesh_other.tag = True
|
|
|
|
if len(mesh_other.loops) != nbr_loops:
|
|
self.report({'WARNING'}, "Object: %s, Mesh: "
|
|
"'%s' has %d loops (for %d faces),"
|
|
" expected %d\n"
|
|
% (obj_other.name,
|
|
mesh_other.name,
|
|
len(mesh_other.loops),
|
|
len(mesh_other.polygons),
|
|
nbr_loops,
|
|
),
|
|
)
|
|
else:
|
|
uv_other = mesh_other.uv_layers.active
|
|
if not uv_other:
|
|
mesh_other.uv_layers.new()
|
|
uv_other = mesh_other.uv_layers.active
|
|
if not uv_other:
|
|
self.report({'ERROR'}, "Could not add "
|
|
"a new UV map to object "
|
|
"'%s' (Mesh '%s')\n"
|
|
% (obj_other.name,
|
|
mesh_other.name,
|
|
),
|
|
)
|
|
|
|
# finally do the copy
|
|
uv_other.data.foreach_set("uv", uv_array)
|
|
mesh_other.update()
|
|
|
|
if is_editmode:
|
|
bpy.ops.object.mode_set(mode='EDIT', toggle=False)
|
|
|
|
def execute(self, context):
|
|
self._main(context)
|
|
return {'FINISHED'}
|
|
|
|
|
|
class MakeDupliFace(Operator):
|
|
"""Convert objects into instanced faces"""
|
|
bl_idname = "object.make_dupli_face"
|
|
bl_label = "Make Instance Face"
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
@staticmethod
|
|
def _main(context):
|
|
from mathutils import Vector
|
|
from collections import defaultdict
|
|
|
|
SCALE_FAC = 0.01
|
|
offset = 0.5 * SCALE_FAC
|
|
base_tri = (Vector((-offset, -offset, 0.0)),
|
|
Vector((+offset, -offset, 0.0)),
|
|
Vector((+offset, +offset, 0.0)),
|
|
Vector((-offset, +offset, 0.0)),
|
|
)
|
|
|
|
def matrix_to_quad(matrix):
|
|
# scale = matrix.median_scale
|
|
trans = matrix.to_translation()
|
|
rot = matrix.to_3x3() # also contains scale
|
|
|
|
return [(rot @ b) + trans for b in base_tri]
|
|
linked = defaultdict(list)
|
|
for obj in context.selected_objects:
|
|
if obj.type == 'MESH':
|
|
linked[obj.data].append(obj)
|
|
|
|
for data, objects in linked.items():
|
|
face_verts = [axis for obj in objects
|
|
for v in matrix_to_quad(obj.matrix_world)
|
|
for axis in v]
|
|
nbr_verts = len(face_verts) // 3
|
|
nbr_faces = nbr_verts // 4
|
|
|
|
faces = list(range(nbr_verts))
|
|
|
|
mesh = bpy.data.meshes.new(data.name + "_dupli")
|
|
|
|
mesh.vertices.add(nbr_verts)
|
|
mesh.loops.add(nbr_faces * 4) # Safer than nbr_verts.
|
|
mesh.polygons.add(nbr_faces)
|
|
|
|
mesh.vertices.foreach_set("co", face_verts)
|
|
mesh.loops.foreach_set("vertex_index", faces)
|
|
mesh.polygons.foreach_set("loop_start", range(0, nbr_faces * 4, 4))
|
|
mesh.polygons.foreach_set("loop_total", (4,) * nbr_faces)
|
|
mesh.update() # generates edge data
|
|
|
|
ob_new = bpy.data.objects.new(mesh.name, mesh)
|
|
context.collection.objects.link(ob_new)
|
|
|
|
ob_inst = bpy.data.objects.new(data.name, data)
|
|
context.collection.objects.link(ob_inst)
|
|
|
|
ob_new.instance_type = 'FACES'
|
|
ob_inst.parent = ob_new
|
|
ob_new.use_instance_faces_scale = True
|
|
ob_new.instance_faces_scale = 1.0 / SCALE_FAC
|
|
|
|
ob_inst.select_set(True)
|
|
ob_new.select_set(True)
|
|
|
|
for obj in objects:
|
|
for collection in obj.users_collection:
|
|
collection.objects.unlink(obj)
|
|
|
|
def execute(self, context):
|
|
self._main(context)
|
|
return {'FINISHED'}
|
|
|
|
|
|
class IsolateTypeRender(Operator):
|
|
"""Hide unselected render objects of same type as active """ \
|
|
"""by setting the hide render flag"""
|
|
bl_idname = "object.isolate_type_render"
|
|
bl_label = "Restrict Render Unselected"
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
def execute(self, context):
|
|
act_type = context.object.type
|
|
|
|
for obj in context.visible_objects:
|
|
|
|
if obj.select_get():
|
|
obj.hide_render = False
|
|
else:
|
|
if obj.type == act_type:
|
|
obj.hide_render = True
|
|
|
|
return {'FINISHED'}
|
|
|
|
|
|
class ClearAllRestrictRender(Operator):
|
|
"""Reveal all render objects by setting the hide render flag"""
|
|
bl_idname = "object.hide_render_clear_all"
|
|
bl_label = "Clear All Restrict Render"
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
def execute(self, context):
|
|
for obj in context.scene.objects:
|
|
obj.hide_render = False
|
|
return {'FINISHED'}
|
|
|
|
|
|
class TransformsToDeltas(Operator):
|
|
"""Convert normal object transforms to delta transforms, """ \
|
|
"""any existing delta transforms will be included as well"""
|
|
bl_idname = "object.transforms_to_deltas"
|
|
bl_label = "Transforms to Deltas"
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
mode: EnumProperty(
|
|
items=(
|
|
('ALL', "All Transforms", "Transfer location, rotation, and scale transforms"),
|
|
('LOC', "Location", "Transfer location transforms only"),
|
|
('ROT', "Rotation", "Transfer rotation transforms only"),
|
|
('SCALE', "Scale", "Transfer scale transforms only"),
|
|
),
|
|
name="Mode",
|
|
description="Which transforms to transfer",
|
|
default='ALL',
|
|
)
|
|
reset_values: BoolProperty(
|
|
name="Reset Values",
|
|
description=("Clear transform values after transferring to deltas"),
|
|
default=True,
|
|
)
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
obs = context.selected_editable_objects
|
|
return (obs is not None)
|
|
|
|
def execute(self, context):
|
|
for obj in context.selected_editable_objects:
|
|
if self.mode in {'ALL', 'LOC'}:
|
|
self.transfer_location(obj)
|
|
|
|
if self.mode in {'ALL', 'ROT'}:
|
|
self.transfer_rotation(obj)
|
|
|
|
if self.mode in {'ALL', 'SCALE'}:
|
|
self.transfer_scale(obj)
|
|
|
|
return {'FINISHED'}
|
|
|
|
def transfer_location(self, obj):
|
|
obj.delta_location += obj.location
|
|
|
|
if self.reset_values:
|
|
obj.location.zero()
|
|
|
|
def transfer_rotation(self, obj):
|
|
# TODO: add transforms together...
|
|
if obj.rotation_mode == 'QUATERNION':
|
|
delta = obj.delta_rotation_quaternion.copy()
|
|
obj.delta_rotation_quaternion = obj.rotation_quaternion
|
|
obj.delta_rotation_quaternion.rotate(delta)
|
|
|
|
if self.reset_values:
|
|
obj.rotation_quaternion.identity()
|
|
elif obj.rotation_mode == 'AXIS_ANGLE':
|
|
pass # Unsupported
|
|
else:
|
|
delta = obj.delta_rotation_euler.copy()
|
|
obj.delta_rotation_euler = obj.rotation_euler
|
|
obj.delta_rotation_euler.rotate(delta)
|
|
|
|
if self.reset_values:
|
|
obj.rotation_euler.zero()
|
|
|
|
def transfer_scale(self, obj):
|
|
obj.delta_scale[0] *= obj.scale[0]
|
|
obj.delta_scale[1] *= obj.scale[1]
|
|
obj.delta_scale[2] *= obj.scale[2]
|
|
|
|
if self.reset_values:
|
|
obj.scale[:] = (1, 1, 1)
|
|
|
|
|
|
class TransformsToDeltasAnim(Operator):
|
|
"""Convert object animation for normal transforms to delta transforms"""
|
|
bl_idname = "object.anim_transforms_to_deltas"
|
|
bl_label = "Animated Transforms to Deltas"
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
obs = context.selected_editable_objects
|
|
return (obs is not None)
|
|
|
|
def execute(self, context):
|
|
# map from standard transform paths to "new" transform paths
|
|
STANDARD_TO_DELTA_PATHS = {
|
|
"location": "delta_location",
|
|
"rotation_euler": "delta_rotation_euler",
|
|
"rotation_quaternion": "delta_rotation_quaternion",
|
|
# "rotation_axis_angle" : "delta_rotation_axis_angle",
|
|
"scale": "delta_scale"
|
|
}
|
|
DELTA_PATHS = STANDARD_TO_DELTA_PATHS.values()
|
|
|
|
# try to apply on each selected object
|
|
for obj in context.selected_editable_objects:
|
|
adt = obj.animation_data
|
|
if (adt is None) or (adt.action is None):
|
|
self.report({'WARNING'},
|
|
"No animation data to convert on object: %r" %
|
|
obj.name)
|
|
continue
|
|
|
|
# first pass over F-Curves: ensure that we don't have conflicting
|
|
# transforms already (e.g. if this was applied already) T29110.
|
|
existingFCurves = {}
|
|
for fcu in adt.action.fcurves:
|
|
# get "delta" path - i.e. the final paths which may clash
|
|
path = fcu.data_path
|
|
if path in STANDARD_TO_DELTA_PATHS:
|
|
# to be converted - conflicts may exist...
|
|
dpath = STANDARD_TO_DELTA_PATHS[path]
|
|
elif path in DELTA_PATHS:
|
|
# already delta - check for conflicts...
|
|
dpath = path
|
|
else:
|
|
# non-transform - ignore
|
|
continue
|
|
|
|
# a delta path like this for the same index shouldn't
|
|
# exist already, otherwise we've got a conflict
|
|
if dpath in existingFCurves:
|
|
# ensure that this index hasn't occurred before
|
|
if fcu.array_index in existingFCurves[dpath]:
|
|
# conflict
|
|
self.report({'ERROR'},
|
|
"Object '%r' already has '%r' F-Curve(s). "
|
|
"Remove these before trying again" %
|
|
(obj.name, dpath))
|
|
return {'CANCELLED'}
|
|
else:
|
|
# no conflict here
|
|
existingFCurves[dpath] += [fcu.array_index]
|
|
else:
|
|
# no conflict yet
|
|
existingFCurves[dpath] = [fcu.array_index]
|
|
|
|
# if F-Curve uses standard transform path
|
|
# just append "delta_" to this path
|
|
for fcu in adt.action.fcurves:
|
|
if fcu.data_path == "location":
|
|
fcu.data_path = "delta_location"
|
|
obj.location.zero()
|
|
elif fcu.data_path == "rotation_euler":
|
|
fcu.data_path = "delta_rotation_euler"
|
|
obj.rotation_euler.zero()
|
|
elif fcu.data_path == "rotation_quaternion":
|
|
fcu.data_path = "delta_rotation_quaternion"
|
|
obj.rotation_quaternion.identity()
|
|
# XXX: currently not implemented
|
|
# ~ elif fcu.data_path == "rotation_axis_angle":
|
|
# ~ fcu.data_path = "delta_rotation_axis_angle"
|
|
elif fcu.data_path == "scale":
|
|
fcu.data_path = "delta_scale"
|
|
obj.scale = 1.0, 1.0, 1.0
|
|
|
|
# hack: force animsys flush by changing frame, so that deltas get run
|
|
context.scene.frame_set(context.scene.frame_current)
|
|
|
|
return {'FINISHED'}
|
|
|
|
|
|
class DupliOffsetFromCursor(Operator):
|
|
"""Set offset used for collection instances based on cursor position"""
|
|
bl_idname = "object.instance_offset_from_cursor"
|
|
bl_label = "Set Offset from Cursor"
|
|
bl_options = {'INTERNAL', 'UNDO'}
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return (context.active_object is not None)
|
|
|
|
def execute(self, context):
|
|
scene = context.scene
|
|
collection = context.collection
|
|
|
|
collection.instance_offset = scene.cursor.location
|
|
|
|
return {'FINISHED'}
|
|
|
|
|
|
class LoadImageAsEmpty:
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
filepath: StringProperty(
|
|
subtype='FILE_PATH'
|
|
)
|
|
|
|
filter_image: BoolProperty(default=True, options={'HIDDEN', 'SKIP_SAVE'})
|
|
filter_folder: BoolProperty(default=True, options={'HIDDEN', 'SKIP_SAVE'})
|
|
|
|
view_align: BoolProperty(
|
|
name="Align to View",
|
|
default=True,
|
|
)
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return context.mode == 'OBJECT'
|
|
|
|
def invoke(self, context, _event):
|
|
context.window_manager.fileselect_add(self)
|
|
return {'RUNNING_MODAL'}
|
|
|
|
def execute(self, context):
|
|
scene = context.scene
|
|
cursor = scene.cursor.location
|
|
|
|
try:
|
|
image = bpy.data.images.load(self.filepath, check_existing=True)
|
|
except RuntimeError as ex:
|
|
self.report({'ERROR'}, str(ex))
|
|
return {'CANCELLED'}
|
|
|
|
bpy.ops.object.empty_add(
|
|
'INVOKE_REGION_WIN',
|
|
type='IMAGE',
|
|
location=cursor,
|
|
align=('VIEW' if self.view_align else 'WORLD'),
|
|
)
|
|
|
|
view_layer = context.view_layer
|
|
obj = view_layer.objects.active
|
|
obj.data = image
|
|
obj.empty_display_size = 5.0
|
|
self.set_settings(context, obj)
|
|
return {'FINISHED'}
|
|
|
|
def set_settings(self, context, obj):
|
|
pass
|
|
|
|
|
|
class LoadBackgroundImage(LoadImageAsEmpty, Operator):
|
|
"""Add a reference image into the background behind objects"""
|
|
bl_idname = "object.load_background_image"
|
|
bl_label = "Load Background Image"
|
|
|
|
def set_settings(self, context, obj):
|
|
obj.empty_image_depth = 'BACK'
|
|
obj.empty_image_side = 'FRONT'
|
|
|
|
if context.space_data.type == 'VIEW_3D':
|
|
if not context.space_data.region_3d.is_perspective:
|
|
obj.show_empty_image_perspective = False
|
|
|
|
|
|
class LoadReferenceImage(LoadImageAsEmpty, Operator):
|
|
"""Add a reference image into the scene between objects"""
|
|
bl_idname = "object.load_reference_image"
|
|
bl_label = "Load Reference Image"
|
|
|
|
def set_settings(self, context, obj):
|
|
pass
|
|
|
|
|
|
class OBJECT_OT_assign_property_defaults(Operator):
|
|
"""Assign the current values of custom properties as their defaults, """ \
|
|
"""for use as part of the rest pose state in NLA track mixing"""
|
|
bl_idname = "object.assign_property_defaults"
|
|
bl_label = "Assign Custom Property Values as Default"
|
|
bl_options = {'UNDO', 'REGISTER'}
|
|
|
|
process_data: BoolProperty(name="Process data properties", default=True)
|
|
process_bones: BoolProperty(name="Process bone properties", default=True)
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
obj = context.active_object
|
|
return obj is not None and obj.library is None and obj.mode in {'POSE', 'OBJECT'}
|
|
|
|
@staticmethod
|
|
def assign_defaults(obj):
|
|
from rna_prop_ui import rna_idprop_ui_prop_default_set
|
|
|
|
rna_properties = {prop.identifier for prop in obj.bl_rna.properties if prop.is_runtime}
|
|
|
|
for prop, value in obj.items():
|
|
if prop not in rna_properties:
|
|
rna_idprop_ui_prop_default_set(obj, prop, value)
|
|
|
|
def execute(self, context):
|
|
obj = context.active_object
|
|
|
|
self.assign_defaults(obj)
|
|
|
|
if self.process_bones and obj.pose:
|
|
for pbone in obj.pose.bones:
|
|
self.assign_defaults(pbone)
|
|
|
|
if self.process_data and obj.data and obj.data.library is None:
|
|
self.assign_defaults(obj.data)
|
|
|
|
if self.process_bones and isinstance(obj.data, bpy.types.Armature):
|
|
for bone in obj.data.bones:
|
|
self.assign_defaults(bone)
|
|
|
|
return {'FINISHED'}
|
|
|
|
|
|
classes = (
|
|
ClearAllRestrictRender,
|
|
DupliOffsetFromCursor,
|
|
IsolateTypeRender,
|
|
JoinUVs,
|
|
LoadBackgroundImage,
|
|
LoadReferenceImage,
|
|
MakeDupliFace,
|
|
SelectCamera,
|
|
SelectHierarchy,
|
|
SelectPattern,
|
|
ShapeTransfer,
|
|
SubdivisionSet,
|
|
TransformsToDeltas,
|
|
TransformsToDeltasAnim,
|
|
OBJECT_OT_assign_property_defaults,
|
|
)
|