2479 lines
70 KiB
Python
2479 lines
70 KiB
Python
# Copyright (C) 2021 Victor Soupday
|
|
# This file is part of CC/iC Blender Tools <https://github.com/soupday/cc_blender_tools>
|
|
#
|
|
# CC/iC Blender Tools 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 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# CC/iC Blender Tools 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 CC/iC Blender Tools. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
import os
|
|
import platform
|
|
import subprocess
|
|
import time
|
|
import difflib
|
|
import random
|
|
import re
|
|
import traceback
|
|
from mathutils import Vector, Quaternion, Matrix, Euler, Color
|
|
from hashlib import md5
|
|
import bpy
|
|
|
|
from . import vars
|
|
|
|
timer = 0
|
|
|
|
LOG_INDENT = 0
|
|
|
|
def log_indent():
|
|
global LOG_INDENT
|
|
LOG_INDENT += 3
|
|
|
|
|
|
def log_recess():
|
|
global LOG_INDENT
|
|
LOG_INDENT -= 3
|
|
|
|
|
|
def log_spacing():
|
|
return " " * LOG_INDENT
|
|
|
|
|
|
def log_detail(msg):
|
|
prefs = vars.prefs()
|
|
"""Log an info message to console."""
|
|
if prefs.log_level == "DETAILS":
|
|
print((" " * LOG_INDENT) + msg)
|
|
|
|
|
|
def log_info(msg):
|
|
prefs = vars.prefs()
|
|
"""Log an info message to console."""
|
|
if prefs.log_level == "ALL" or prefs.log_level == "DETAILS":
|
|
print((" " * LOG_INDENT) + msg)
|
|
|
|
|
|
def log_always(msg):
|
|
prefs = vars.prefs()
|
|
"""Log an info message to console."""
|
|
print((" " * LOG_INDENT) + msg)
|
|
|
|
|
|
def log_warn(msg):
|
|
prefs = vars.prefs()
|
|
"""Log a warning message to console."""
|
|
if prefs.log_level == "ALL" or prefs.log_level == "DETAILS" or prefs.log_level == "WARN":
|
|
print((" " * LOG_INDENT) + "Warning: " + msg)
|
|
|
|
|
|
def log_error(msg, e: Exception = None):
|
|
"""Log an error message to console and raise an exception."""
|
|
indent = LOG_INDENT
|
|
if indent > 1: indent -= 1
|
|
print("*" + (" " * indent) + "Error: " + msg)
|
|
if e is not None:
|
|
print(" -> " + getattr(e, 'message', repr(e)))
|
|
print("Stack Trace: ")
|
|
traceback.print_exc()
|
|
|
|
|
|
|
|
def start_timer():
|
|
global timer
|
|
timer = time.perf_counter()
|
|
|
|
|
|
def log_timer(msg, unit = "s"):
|
|
prefs = vars.prefs()
|
|
global timer
|
|
if prefs.log_level == "ALL":
|
|
duration = time.perf_counter() - timer
|
|
if unit == "ms":
|
|
duration *= 1000
|
|
elif unit == "us":
|
|
duration *= 1000000
|
|
elif unit == "ns":
|
|
duration *= 1000000000
|
|
print(msg + ": " + str(duration) + " " + unit)
|
|
|
|
|
|
def message_box(message = "", title = "Info", icon = 'INFO'):
|
|
def draw(self, context):
|
|
self.layout.label(text = message)
|
|
bpy.context.window_manager.popup_menu(draw, title = title, icon = icon)
|
|
|
|
|
|
def update_ui(context = None, area_type="VIEW_3D", region_type="UI", all=False):
|
|
for screen in bpy.data.screens:
|
|
for area in screen.areas:
|
|
if area.type == area_type or all:
|
|
for region in area.regions:
|
|
if region.type == region_type or all:
|
|
region.tag_redraw()
|
|
|
|
|
|
def report_multi(op, icon = 'INFO', messages = None):
|
|
if messages:
|
|
text = ""
|
|
for msg in messages:
|
|
text += msg + " \n"
|
|
if text:
|
|
op.report({icon}, text)
|
|
|
|
|
|
def message_box_multi(title = "Info", icon = 'INFO', messages = None):
|
|
def draw(self, context):
|
|
if messages:
|
|
for message in messages:
|
|
self.layout.label(text = message)
|
|
bpy.context.window_manager.popup_menu(draw, title = title, icon = icon)
|
|
|
|
|
|
def unique_name(name, no_version = False):
|
|
"""Generate a unique name for the node or property to quickly
|
|
identify texture nodes or nodes with parameters."""
|
|
|
|
props = vars.props()
|
|
if no_version:
|
|
name = name + "_" + vars.NODE_PREFIX + str(props.node_id)
|
|
else:
|
|
name = vars.NODE_PREFIX + name + "_" + vars.VERSION_STRING + "_" + str(props.node_id)
|
|
props.node_id = props.node_id + 1
|
|
return name
|
|
|
|
|
|
def set_ccic_id(obj: bpy.types.Object):
|
|
props = vars.props()
|
|
obj["ccic_id"] = vars.VERSION_STRING + "_" + str(props.node_id)
|
|
props.node_id = props.node_id + 1
|
|
|
|
|
|
def has_ccic_id(obj: bpy.types.Object):
|
|
if "ccic_id" in obj:
|
|
return True
|
|
if vars.NODE_PREFIX in obj.name:
|
|
return True
|
|
return False
|
|
|
|
|
|
def obj_is_linked(obj):
|
|
try:
|
|
if obj.library is not None:
|
|
return True
|
|
except: ...
|
|
return False
|
|
|
|
|
|
def obj_is_override(obj):
|
|
try:
|
|
if obj.override_library is not None:
|
|
return True
|
|
except: ...
|
|
return False
|
|
|
|
|
|
def unique_material_name(name, mat=None, start_index=1):
|
|
name = strip_name(name)
|
|
index = start_index
|
|
if name in bpy.data.materials and bpy.data.materials[name] != mat:
|
|
while name + "_" + str(index).zfill(2) in bpy.data.materials:
|
|
index += 1
|
|
return name + "_" + str(index).zfill(2)
|
|
return name
|
|
|
|
|
|
def unique_image_name(name, image=None, start_index=1):
|
|
name = strip_name(name)
|
|
index = start_index
|
|
if name in bpy.data.images and bpy.data.images[name] != image:
|
|
while name + "_" + str(index).zfill(2) in bpy.data.images:
|
|
index += 1
|
|
return name + "_" + str(index).zfill(2)
|
|
return name
|
|
|
|
|
|
def unique_object_name(name, obj=None, capitalize=False, start_index=1):
|
|
name = strip_name(name)
|
|
if capitalize:
|
|
name = name.capitalize()
|
|
if name in bpy.data.objects and bpy.data.objects[name] != obj:
|
|
index = start_index
|
|
while name + "_" + str(index).zfill(2) in bpy.data.objects:
|
|
index += 1
|
|
return name + "_" + str(index).zfill(2)
|
|
return name
|
|
|
|
|
|
def un_suffix_name(name):
|
|
"""Removes any combination of numerical suffixes from the end of a string"""
|
|
base_name = re.sub("([._+|/\,]\d+)*$", "", name)
|
|
return base_name
|
|
|
|
|
|
def is_same_path(pa, pb):
|
|
try:
|
|
if pa and pb:
|
|
return os.path.normpath(os.path.realpath(pa)) == os.path.normpath(os.path.realpath(pb))
|
|
else:
|
|
return False
|
|
except:
|
|
return False
|
|
|
|
|
|
def is_in_path(a, b):
|
|
"""Is path a in path b"""
|
|
try:
|
|
if a and b:
|
|
return os.path.normpath(os.path.realpath(a)) in os.path.normpath(os.path.realpath(b))
|
|
else:
|
|
return False
|
|
except:
|
|
return False
|
|
|
|
|
|
def path_is_parent(parent_path, child_path):
|
|
try:
|
|
parent_path = os.path.abspath(parent_path)
|
|
child_path = os.path.abspath(child_path)
|
|
return os.path.commonpath([parent_path]) == os.path.commonpath([parent_path, child_path])
|
|
except:
|
|
return False
|
|
|
|
|
|
def local_repath(path, original_start):
|
|
"""Takes the path relative to the original_start and makes
|
|
it relative to the blend file location instead.
|
|
Returns the full path."""
|
|
rel_path = relpath(path, original_start)
|
|
return os.path.normpath(bpy.path.abspath(f"//{rel_path}"))
|
|
|
|
|
|
def local_path(path = ""):
|
|
"""Get the full path of <path> relative to the blend file. Returns empty if no blend file path."""
|
|
if bpy.path.abspath("//"):
|
|
abs_path = bpy.path.abspath(f"//{path}")
|
|
return os.path.normpath(abs_path)
|
|
else:
|
|
return ""
|
|
|
|
|
|
def blend_file_name():
|
|
file_path = bpy.data.filepath
|
|
name = ""
|
|
if file_path:
|
|
folder, file = os.path.split(file_path)
|
|
name, ext = os.path.splitext(file)
|
|
return name
|
|
|
|
|
|
def relpath(path, start):
|
|
try:
|
|
return os.path.relpath(path, start)
|
|
except ValueError:
|
|
return os.path.abspath(path)
|
|
|
|
|
|
def search_up_path(path, folder):
|
|
path = os.path.normpath(path)
|
|
dir : str = os.path.dirname(path)
|
|
if dir == path or dir == "" or dir is None:
|
|
return ""
|
|
elif dir.lower().endswith(os.path.sep + folder.lower()):
|
|
return dir
|
|
return search_up_path(dir, folder)
|
|
|
|
|
|
def object_has_material(obj, name):
|
|
name = name.lower()
|
|
if obj.type == "MESH":
|
|
for mat in obj.data.materials:
|
|
if mat and name in mat.name.lower():
|
|
return True
|
|
return False
|
|
|
|
|
|
def object_exists_is_empty(obj):
|
|
"""Test if Object: obj still exists as an object in the scene, and is an empty."""
|
|
if obj is None:
|
|
return False
|
|
try:
|
|
name = obj.name
|
|
return len(obj.users_scene) > 0 and obj.type == "EMPTY"
|
|
except:
|
|
return False
|
|
|
|
|
|
def object_exists_is_mesh(obj):
|
|
"""Test if Object: obj still exists as an object in the scene, and is a mesh."""
|
|
if obj is None:
|
|
return False
|
|
try:
|
|
name = obj.name
|
|
return len(obj.users_scene) > 0 and obj.type == "MESH"
|
|
except:
|
|
return False
|
|
|
|
|
|
def object_exists_is_armature(obj):
|
|
"""Test if Object: obj still exists as an object in the scene, and is an armature."""
|
|
if obj is None:
|
|
return False
|
|
try:
|
|
name = obj.name
|
|
return len(obj.users_scene) > 0 and obj.type == "ARMATURE"
|
|
except:
|
|
return False
|
|
|
|
|
|
def object_exists_is_light(obj):
|
|
"""Test if Object: obj still exists as an object in the scene, and is a light."""
|
|
if obj is None:
|
|
return False
|
|
try:
|
|
name = obj.name
|
|
return len(obj.users_scene) > 0 and obj.type == "LIGHT"
|
|
except:
|
|
return False
|
|
|
|
|
|
def object_exists(obj: bpy.types.Object):
|
|
"""Test if Object: obj still exists as an object in the scene."""
|
|
if obj is None:
|
|
return False
|
|
try:
|
|
name = obj.name
|
|
return len(obj.users_scene) > 0
|
|
except:
|
|
return False
|
|
|
|
|
|
def material_exists(mat: bpy.types.Material):
|
|
"""Test if material still exists."""
|
|
if mat is None:
|
|
return False
|
|
try:
|
|
name = mat.name
|
|
return True
|
|
except:
|
|
return False
|
|
|
|
|
|
def image_exists(img: bpy.types.Image):
|
|
"""Test if material still exists."""
|
|
if img is None:
|
|
return False
|
|
try:
|
|
name = img.name
|
|
return True
|
|
except:
|
|
return False
|
|
|
|
|
|
def purge_image(img: bpy.types.Image):
|
|
if image_exists(img):
|
|
users = img.users - (1 if img.use_extra_user else 0)
|
|
if users <= 0:
|
|
bpy.data.images.remove(img)
|
|
|
|
|
|
def get_selected_mesh():
|
|
if object_exists_is_mesh(get_active_object()):
|
|
return get_active_object()
|
|
elif bpy.context.selected_objects:
|
|
for obj in bpy.context.selected_objects:
|
|
if object_exists_is_mesh(obj):
|
|
return obj
|
|
return None
|
|
|
|
|
|
def get_selected_meshes(context = None):
|
|
"""Gets selected meshes and includes any current context mesh"""
|
|
objects = [ obj for obj in bpy.context.selected_objects if object_exists_is_mesh(obj) ]
|
|
if context and context.object:
|
|
if object_exists_is_mesh(context.object):
|
|
if context.object not in objects:
|
|
objects.append(context.object)
|
|
return objects
|
|
|
|
|
|
def get_selected_armatures(context = None):
|
|
"""Gets selected armatures and includes any current context armature"""
|
|
objects = [ obj for obj in bpy.context.selected_objects if object_exists_is_armature(obj) ]
|
|
if context and context.object:
|
|
if object_exists_is_armature(context.object):
|
|
if context.object not in objects:
|
|
objects.append(context.object)
|
|
return objects
|
|
|
|
|
|
def safe_remove(item, force = False):
|
|
|
|
if object_exists(item):
|
|
|
|
if type(item) == bpy.types.Armature:
|
|
if (item.use_fake_user and item.users == 1) or item.users == 0 or force:
|
|
log_info("Removing Armature: " + item.name)
|
|
bpy.data.armatures.remove(item)
|
|
else:
|
|
log_info("Armature: " + item.name + " still in use!")
|
|
|
|
elif type(item) == bpy.types.Mesh:
|
|
if (item.use_fake_user and item.users == 1) or item.users == 0 or force:
|
|
log_info("Removing Mesh: " + item.name)
|
|
bpy.data.meshes.remove(item)
|
|
else:
|
|
log_info("Mesh: " + item.name + " still in use!")
|
|
|
|
elif type(item) == bpy.types.Object:
|
|
if (item.use_fake_user and item.users == 1) or item.users == 0 or force:
|
|
log_info("Removing Object: " + item.name)
|
|
bpy.data.objects.remove(item)
|
|
else:
|
|
log_info("Object: " + item.name + " still in use!")
|
|
|
|
elif type(item) == bpy.types.Material:
|
|
if (item.use_fake_user and item.users == 1) or item.users == 0 or force:
|
|
log_info("Removing Material: " + item.name)
|
|
bpy.data.materials.remove(item)
|
|
else:
|
|
log_info("Material: " + item.name + " still in use!")
|
|
|
|
elif type(item) == bpy.types.Image:
|
|
if (item.use_fake_user and item.users == 1) or item.users == 0 or force:
|
|
log_info("Removing Image: " + item.name)
|
|
bpy.data.images.remove(item)
|
|
else:
|
|
log_info("Image: " + item.name + " still in use!")
|
|
|
|
elif type(item) == bpy.types.Texture:
|
|
if (item.use_fake_user and item.users == 1) or item.users == 0 or force:
|
|
log_info("Removing Texture: " + item.name)
|
|
bpy.data.textures.remove(item)
|
|
else:
|
|
log_info("Texture: " + item.name + " still in use!")
|
|
|
|
elif type(item) == bpy.types.Action:
|
|
if (item.use_fake_user and item.users == 1) or item.users == 0 or force:
|
|
log_info("Removing Action: " + item.name)
|
|
bpy.data.textures.remove(item)
|
|
else:
|
|
log_info("Action: " + item.name + " still in use!")
|
|
|
|
|
|
def clean_collection(collection, include_fake = False):
|
|
cleaned = False
|
|
for item in collection:
|
|
if (include_fake and item.use_fake_user and item.users == 1) or item.users == 0:
|
|
log_detail(f"Clean Collection Removing: {item}")
|
|
collection.remove(item)
|
|
cleaned = True
|
|
return cleaned
|
|
|
|
|
|
def clean_up_unused():
|
|
clean_collection(bpy.data.images)
|
|
clean_collection(bpy.data.materials)
|
|
clean_collection(bpy.data.textures)
|
|
clean_collection(bpy.data.meshes)
|
|
clean_collection(bpy.data.armatures)
|
|
# as some node_groups are nested...
|
|
while clean_collection(bpy.data.node_groups):
|
|
clean_collection(bpy.data.node_groups)
|
|
|
|
|
|
def clamp(x, min = 0.0, max = 1.0):
|
|
if x < min:
|
|
x = min
|
|
if x > max:
|
|
x = max
|
|
return x
|
|
|
|
|
|
def smoothstep(edge0, edge1, x):
|
|
x = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0)
|
|
return x * x * (3 - 2 * x)
|
|
|
|
|
|
def map_smoothstep(edge0, edge1, value0, value1, x):
|
|
if edge1 == edge0:
|
|
return value1
|
|
x = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0)
|
|
t = x * x * (3 - 2 * x)
|
|
return value0 + (value1 - value0) * t
|
|
|
|
|
|
def saturate(x):
|
|
if x < 0.0:
|
|
x = 0.0
|
|
if x > 1.0:
|
|
x = 1.0
|
|
return x
|
|
|
|
|
|
def remap(edge0, edge1, min, max, x):
|
|
return min + ((x - edge0) * (max - min) / (edge1 - edge0))
|
|
|
|
|
|
def lerp(v0, v1, t):
|
|
t = max(0, min(1, t))
|
|
l = v0 + (v1 - v0) * t
|
|
return l
|
|
|
|
|
|
def inverse_lerp(vmin, vmax, value):
|
|
return min(1.0, max(0.0, (value - vmin) / (vmax - vmin)))
|
|
|
|
|
|
def lerp_color(c0, c1, t):
|
|
r = (lerp(c0[0], c1[0], t),
|
|
lerp(c0[1], c1[1], t),
|
|
lerp(c0[2], c1[2], t),
|
|
lerp(c0[3], c1[3], t))
|
|
return r
|
|
|
|
|
|
def inverse_lerp_color(min, max, value):
|
|
return (inverse_lerp(min[0], max[0], value[0]),
|
|
inverse_lerp(min[1], max[1], value[1]),
|
|
inverse_lerp(min[2], max[2], value[2]),
|
|
inverse_lerp(min[3], max[3], value[3]))
|
|
|
|
|
|
def linear_to_srgbx(x):
|
|
if x < 0.0:
|
|
return 0.0
|
|
elif x < 0.0031308:
|
|
return x * 12.92
|
|
elif x < 1.0:
|
|
return 1.055 * pow(x, 1.0 / 2.4) - 0.055
|
|
else:
|
|
return pow(x, 5.0 / 11.0)
|
|
|
|
|
|
def linear_to_srgb(color):
|
|
return (linear_to_srgbx(color[0]),
|
|
linear_to_srgbx(color[1]),
|
|
linear_to_srgbx(color[2]),
|
|
color[3])
|
|
|
|
|
|
def srgb_to_linearx(x):
|
|
if x <= 0.04045:
|
|
return x / 12.95
|
|
elif x < 1.0:
|
|
return pow((x + 0.055) / 1.055, 2.4)
|
|
else:
|
|
return pow(x, 2.2)
|
|
|
|
|
|
def srgb_to_linear(color):
|
|
return (srgb_to_linearx(color[0]),
|
|
srgb_to_linearx(color[1]),
|
|
srgb_to_linearx(color[2]),
|
|
color[3])
|
|
|
|
|
|
def count_maps(*maps):
|
|
count = 0
|
|
for map in maps:
|
|
if map is not None:
|
|
count += 1
|
|
return count
|
|
|
|
|
|
def key_count(obj: bpy.types.Object):
|
|
if obj.data.shape_keys and obj.data.shape_keys.key_blocks:
|
|
return len(obj.data.shape_keys.key_blocks)
|
|
return 0
|
|
|
|
|
|
def dimensions(x):
|
|
try:
|
|
l = len(x)
|
|
return l
|
|
except:
|
|
return 1
|
|
return 1
|
|
|
|
|
|
def match_dimensions(socket, value):
|
|
socket_dimensions = dimensions(socket)
|
|
value_dimensions = dimensions(value)
|
|
if socket_dimensions == 3 and value_dimensions == 1:
|
|
return (value, value, value)
|
|
elif socket_dimensions == 2 and value_dimensions == 1:
|
|
return (value, value)
|
|
else:
|
|
return value
|
|
|
|
|
|
def find_pose_bone(chr_cache, *name):
|
|
props = vars.props()
|
|
|
|
arm = chr_cache.get_armature()
|
|
for n in name:
|
|
if n in arm.pose.bones:
|
|
return arm.pose.bones[n]
|
|
return None
|
|
|
|
|
|
def find_pose_bone_in_armature(arm, *name):
|
|
if (arm.type == "ARMATURE"):
|
|
for n in name:
|
|
if n in arm.pose.bones:
|
|
return arm.pose.bones[n]
|
|
return None
|
|
|
|
|
|
def find_edit_bone_in_armature(arm, *name):
|
|
if (arm.type == "ARMATURE"):
|
|
for n in name:
|
|
if n in arm.data.edit_bones:
|
|
return arm.data.edit_bones[n]
|
|
return None
|
|
|
|
|
|
def get_active_object():
|
|
"""Return the actual active object and not the context reference."""
|
|
try:
|
|
if bpy.context.active_object:
|
|
return bpy.data.objects[bpy.context.active_object.name]
|
|
except:
|
|
pass
|
|
return None
|
|
|
|
|
|
def get_active_view_layer_object():
|
|
return bpy.context.view_layer.objects.active
|
|
|
|
|
|
def set_active_object(obj, deselect_all = False):
|
|
try:
|
|
if deselect_all:
|
|
bpy.ops.object.select_all(action='DESELECT')
|
|
obj.select_set(True)
|
|
bpy.context.view_layer.objects.active = obj
|
|
return (bpy.context.active_object == obj)
|
|
except:
|
|
return False
|
|
|
|
def set_only_active_object(obj):
|
|
return set_active_object(obj, True)
|
|
|
|
|
|
def set_mode(mode):
|
|
try:
|
|
if bpy.context.object == None:
|
|
if mode != "OBJECT":
|
|
log_error("No context object, unable to set any mode but OBJECT!")
|
|
return False
|
|
return True
|
|
else:
|
|
if bpy.context.object.mode != mode:
|
|
bpy.ops.object.mode_set(mode=mode)
|
|
if bpy.context.object.mode != mode:
|
|
log_error("Unable to set " + mode + " on object: " + bpy.context.object.name)
|
|
return False
|
|
return True
|
|
except:
|
|
return False
|
|
|
|
|
|
def get_mode():
|
|
try:
|
|
return bpy.context.object.mode
|
|
except:
|
|
return "OBJECT"
|
|
|
|
|
|
def is_selected_and_active(obj):
|
|
return get_active_object() == obj and obj in bpy.context.selected_objects
|
|
|
|
|
|
def is_only_selected_and_active(obj):
|
|
return (get_active_object() == obj and
|
|
obj in bpy.context.selected_objects and
|
|
len(bpy.context.selected_objects) == 1)
|
|
|
|
|
|
def edit_mode_to(obj, only_this = False):
|
|
if object_exists(obj):
|
|
if only_this and not is_only_selected_and_active(obj):
|
|
set_only_active_object(obj)
|
|
if is_selected_and_active(obj) and get_mode() == "EDIT":
|
|
return True
|
|
else:
|
|
if set_mode("OBJECT") and set_active_object(obj) and set_mode("EDIT"):
|
|
return True
|
|
return False
|
|
|
|
|
|
def object_mode():
|
|
return set_mode("OBJECT")
|
|
|
|
|
|
def object_mode_to(obj):
|
|
if object_exists(obj):
|
|
if get_mode() == "OBJECT" and get_active_object() == obj:
|
|
return True
|
|
if set_mode("OBJECT"):
|
|
if try_select_object(obj):
|
|
if set_active_object(obj):
|
|
return True
|
|
return False
|
|
|
|
|
|
def pose_mode_to(arm):
|
|
if object_exists_is_armature(arm):
|
|
if get_mode() == "POSE" and get_active_object() == arm:
|
|
return True
|
|
if object_mode_to(arm):
|
|
if set_mode("POSE"):
|
|
return True
|
|
return False
|
|
|
|
|
|
def duplicate_object(obj, include_action=False) -> bpy.types.Object:
|
|
if object_exists(obj) and set_mode("OBJECT"):
|
|
if try_select_object(obj, True) and set_active_object(obj):
|
|
|
|
obj_action = None
|
|
shape_key_action = None
|
|
|
|
# store existing actions
|
|
obj_action = safe_get_action(obj)
|
|
if not include_action:
|
|
safe_set_action(obj, None, create=False)
|
|
if obj.type == "MESH":
|
|
shape_key_action = safe_get_action(obj.data.shape_keys)
|
|
if not include_action:
|
|
safe_set_action(obj.data.shape_keys, None, create=False)
|
|
|
|
# duplicate object
|
|
bpy.ops.object.duplicate()
|
|
|
|
# restore non-duplicated actions
|
|
if not include_action:
|
|
if shape_key_action:
|
|
safe_set_action(obj.data.shape_keys, shape_key_action)
|
|
if obj_action:
|
|
safe_set_action(obj, obj_action)
|
|
|
|
return get_active_object()
|
|
return None
|
|
|
|
|
|
def remove_all_shape_keys(obj):
|
|
if obj and obj.data.shape_keys and obj.data.shape_keys.key_blocks:
|
|
keys = [key for key in obj.data.shape_keys.key_blocks]
|
|
keys.reverse() # make sure basis is last to be removed...
|
|
for key in keys:
|
|
obj.shape_key_remove(key)
|
|
|
|
|
|
def force_object_name(obj, name):
|
|
if name in bpy.data.objects:
|
|
existing = bpy.data.objects[name]
|
|
if existing != obj:
|
|
old_name = obj.name
|
|
rnd_id = generate_random_id(10)
|
|
existing.name = existing.name + "_" + rnd_id
|
|
obj.name = name
|
|
existing.name = old_name
|
|
else:
|
|
obj.name = name
|
|
|
|
|
|
def force_mesh_name(mesh, name):
|
|
if name in bpy.data.meshes:
|
|
existing = bpy.data.meshes[name]
|
|
if existing != mesh:
|
|
old_name = mesh.name
|
|
rnd_id = generate_random_id(10)
|
|
existing.name = existing.name + "_" + rnd_id
|
|
mesh.name = name
|
|
existing.name = old_name
|
|
else:
|
|
mesh.name = name
|
|
|
|
|
|
def force_armature_name(arm, name):
|
|
if name in bpy.data.armatures:
|
|
existing = bpy.data.armatures[name]
|
|
if existing != arm:
|
|
old_name = arm.name
|
|
rnd_id = generate_random_id(10)
|
|
existing.name = existing.name + "_" + rnd_id
|
|
arm.name = name
|
|
existing.name = old_name
|
|
else:
|
|
arm.name = name
|
|
|
|
|
|
def force_material_name(mat, name):
|
|
if name in bpy.data.materials:
|
|
existing = bpy.data.materials[name]
|
|
if existing != mat:
|
|
old_name = mat.name
|
|
rnd_id = generate_random_id(10)
|
|
existing.name = existing.name + "_" + rnd_id
|
|
mat.name = name
|
|
existing.name = old_name
|
|
else:
|
|
mat.name = name
|
|
|
|
|
|
def s2lin(x):
|
|
a = 0.055
|
|
if x <= 0.04045:
|
|
y = x * (1.0/12.92)
|
|
else:
|
|
y = pow((x + a)*(1.0/(1 + a)), 2.4)
|
|
return y
|
|
|
|
def lin2s(x):
|
|
a = 0.055
|
|
if x <= 0.0031308:
|
|
y = x * 12.92
|
|
else:
|
|
y = (1 + a)*pow(x, 1/2.4) - a
|
|
return y
|
|
|
|
|
|
# remove any .001 from the material name
|
|
def strip_name(name: str):
|
|
if len(name) >= 4:
|
|
if name[-3:].isdigit() and name[-4] == ".":
|
|
name = name[:-4]
|
|
return name
|
|
|
|
|
|
def names_to_list(names: str, delim: str = "|") -> list:
|
|
name_list = None
|
|
if names:
|
|
split = names.strip().split(delim)
|
|
for s in split:
|
|
s = s.strip()
|
|
if s:
|
|
if name_list is None:
|
|
name_list = []
|
|
name_list.append(s)
|
|
return name_list
|
|
|
|
|
|
def get_auto_index_suffix(name):
|
|
auto_index = 0
|
|
try:
|
|
if type(name) is not str:
|
|
name = name.name
|
|
if name[-4] == "|" and name[-3:].isdigit():
|
|
auto_index = int(name[-3:])
|
|
elif name[-5] == "|" and name[-4:].isdigit():
|
|
auto_index = int(name[-4:])
|
|
except:
|
|
pass
|
|
return auto_index
|
|
|
|
|
|
def is_blender_duplicate(name):
|
|
if len(name) >= 4:
|
|
if (name[-1:].isdigit() and
|
|
name[-2:].isdigit() and
|
|
name[-3:].isdigit() and
|
|
name[-4] == "."):
|
|
return True
|
|
return False
|
|
|
|
|
|
def get_duplication_suffix(name):
|
|
if len(name) >= 4:
|
|
if (name[-1:].isdigit() and
|
|
name[-2:].isdigit() and
|
|
name[-3:].isdigit() and
|
|
name[-4] == "."):
|
|
return int(name[-3:])
|
|
return 0
|
|
|
|
|
|
def make_unique_name_in(name, keys):
|
|
""""""
|
|
if name in keys:
|
|
i = 1
|
|
while name + "_" + str(i) in keys:
|
|
i += 1
|
|
return name + "_" + str(i)
|
|
return name
|
|
|
|
|
|
def partial_match(text, search, start = 0):
|
|
"""Action names can be truncated so sometimes we have to fall back on partial name matches."""
|
|
if text and search:
|
|
ls = len(search)
|
|
lt = len(text)
|
|
if start > -1 and lt > start:
|
|
if text[start:] == search:
|
|
return True
|
|
j = 0
|
|
for i in range(start, min(start + ls, lt)):
|
|
if text[i] != search[j]:
|
|
return False
|
|
j += 1
|
|
return True
|
|
return False
|
|
|
|
|
|
def get_longest_alpha_match(a : str, b : str):
|
|
match = difflib.SequenceMatcher(lambda x: x in " 0123456789", a, b).find_longest_match()
|
|
if match[2] == 0:
|
|
return ""
|
|
else:
|
|
return a[match[0]:(match[0] + match[2])]
|
|
|
|
|
|
def get_common_name(names):
|
|
common_name = names[0]
|
|
for i in range(1, len(names)):
|
|
common_name = get_longest_alpha_match(common_name, names[i])
|
|
while common_name[-1] in "_0123456789":
|
|
common_name = common_name[:-1]
|
|
return common_name
|
|
|
|
|
|
def get_dot_file_ext(ext):
|
|
try:
|
|
if ext[0] == ".":
|
|
return ext.lower()
|
|
else:
|
|
return f".{ext}".lower()
|
|
except:
|
|
return ""
|
|
|
|
|
|
def get_file_ext(ext):
|
|
try:
|
|
if ext[0] == ".":
|
|
return ext[1:].lower()
|
|
else:
|
|
return ext.lower()
|
|
except:
|
|
return ""
|
|
|
|
|
|
def is_file_ext(test, ext):
|
|
try:
|
|
if ext[0] == ".":
|
|
ext = ext[1:]
|
|
if test[0] == ".":
|
|
test = test[1:]
|
|
return test.lower() == ext.lower()
|
|
except:
|
|
return False
|
|
|
|
|
|
def get_set(collection) -> set:
|
|
return set(collection)
|
|
|
|
|
|
def get_set_new(collection, old: set) -> list:
|
|
current = get_set(collection)
|
|
return list(current - old)
|
|
|
|
|
|
def tag_objects():
|
|
for obj in bpy.data.objects:
|
|
obj.tag = True
|
|
|
|
|
|
def untagged_objects():
|
|
untagged = []
|
|
for obj in bpy.data.objects:
|
|
if obj.tag == False:
|
|
untagged.append(obj)
|
|
obj.tag = False
|
|
return untagged
|
|
|
|
|
|
def tag_materials():
|
|
for mat in bpy.data.materials:
|
|
if mat:
|
|
mat.tag = True
|
|
|
|
|
|
def untagged_materials():
|
|
untagged = []
|
|
for mat in bpy.data.materials:
|
|
if mat and mat.tag == False:
|
|
untagged.append(mat)
|
|
mat.tag = False
|
|
return untagged
|
|
|
|
|
|
def tag_images():
|
|
for img in bpy.data.images:
|
|
img.tag = True
|
|
|
|
|
|
def untagged_images():
|
|
untagged = []
|
|
for img in bpy.data.images:
|
|
if img.tag == False:
|
|
untagged.append(img)
|
|
img.tag = False
|
|
return untagged
|
|
|
|
|
|
def tag_actions():
|
|
for action in bpy.data.actions:
|
|
action.tag = True
|
|
|
|
|
|
def untagged_actions():
|
|
untagged = []
|
|
for action in bpy.data.actions:
|
|
if action.tag == False:
|
|
untagged.append(action)
|
|
action.tag = False
|
|
return untagged
|
|
|
|
|
|
def try_select_child_objects(obj):
|
|
try:
|
|
if obj:
|
|
if obj.type == "ARMATURE" or obj.type == "MESH" or obj.type == "EMPTY":
|
|
obj.select_set(True)
|
|
result = True
|
|
for child in obj.children:
|
|
if not try_select_child_objects(child):
|
|
result = False
|
|
return result
|
|
else:
|
|
return False
|
|
except:
|
|
return False
|
|
|
|
|
|
def add_child_objects(obj, objects, follow_armatures = False):
|
|
for child in obj.children:
|
|
if child not in objects:
|
|
if child.type == "ARMATURE" and not follow_armatures:
|
|
continue
|
|
objects.append(child)
|
|
if child.children:
|
|
add_child_objects(child, objects, follow_armatures)
|
|
|
|
|
|
def expand_with_child_objects(objects):
|
|
for obj in objects:
|
|
add_child_objects(obj, objects)
|
|
|
|
|
|
def get_child_objects(obj, include_parent = False, follow_armatures = False):
|
|
objects = []
|
|
if include_parent:
|
|
objects.append(obj)
|
|
add_child_objects(obj, objects, follow_armatures)
|
|
return objects
|
|
|
|
|
|
def try_select_object(obj, clear_selection = False):
|
|
if clear_selection:
|
|
clear_selected_objects()
|
|
try:
|
|
obj.select_set(True)
|
|
return True
|
|
except:
|
|
return False
|
|
|
|
|
|
def try_select_objects(objects, clear_selection = False, object_type = None, make_active = False):
|
|
if clear_selection:
|
|
clear_selected_objects()
|
|
result = True
|
|
for obj in objects:
|
|
if object_type and obj.type != object_type:
|
|
continue
|
|
if not try_select_object(obj):
|
|
result = False
|
|
else:
|
|
if make_active:
|
|
bpy.context.view_layer.objects.active = obj
|
|
return result
|
|
|
|
|
|
def clear_selected_objects():
|
|
try:
|
|
bpy.ops.object.select_all(action='DESELECT')
|
|
return True
|
|
except:
|
|
return False
|
|
|
|
|
|
def get_armature(name):
|
|
if (name in bpy.data.armatures and
|
|
name in bpy.data.objects and
|
|
bpy.data.objects[name].data == bpy.data.armatures[name] and
|
|
object_exists_is_armature(bpy.data.objects[name])):
|
|
return bpy.data.objects[name]
|
|
return None
|
|
|
|
|
|
def create_reuse_armature(name):
|
|
if name in bpy.data.armatures:
|
|
bpy.data.armatures.remove(bpy.data.armatures[name])
|
|
if name in bpy.data.objects:
|
|
bpy.data.objects.remove(bpy.data.armatures[name])
|
|
arm = bpy.data.armatures.new(name)
|
|
obj = bpy.data.objects.new(name, arm)
|
|
bpy.context.collection.objects.link(obj)
|
|
return obj
|
|
|
|
|
|
def get_armature_from_objects(objects):
|
|
armatures = get_armatures_from_objects(objects)
|
|
return get_topmost_object(armatures)
|
|
|
|
|
|
def get_armatures_from_objects(objects):
|
|
armatures = []
|
|
if objects:
|
|
for obj in objects:
|
|
arm = get_armature_from_object(obj)
|
|
if arm and arm not in armatures:
|
|
armatures.append(arm)
|
|
return armatures
|
|
|
|
|
|
def get_armature_from_object(obj):
|
|
arm = None
|
|
if obj.type == "ARMATURE":
|
|
arm = obj
|
|
elif obj.type == "MESH" and obj.parent and obj.parent.type == "ARMATURE":
|
|
arm = obj.parent
|
|
return arm
|
|
|
|
|
|
def is_child_of(obj, test):
|
|
"""Returns True if obj is a child or sub-child of test"""
|
|
while test.parent:
|
|
if test.parent == obj:
|
|
return True
|
|
test = test.parent
|
|
return False
|
|
|
|
|
|
def get_topmost_object(objects):
|
|
if not objects:
|
|
return None
|
|
if len(objects) == 1:
|
|
return objects[0]
|
|
else:
|
|
for obj in objects:
|
|
for test in objects:
|
|
if obj != test:
|
|
if not is_child_of(obj, test):
|
|
return obj
|
|
return None
|
|
|
|
|
|
def float_equals(a, b):
|
|
return abs(a - b) < 0.00001
|
|
|
|
|
|
def array_to_vector(arr):
|
|
if len(arr) == 3:
|
|
return Vector((arr[0], arr[1], arr[2]))
|
|
return Vector()
|
|
|
|
|
|
def array_to_color(arr, to_srgb=False, to_linear=False):
|
|
if len(arr) == 1:
|
|
r = g = b = arr[0]
|
|
a = 1
|
|
elif len(arr) == 2:
|
|
r = arr[0]
|
|
g = arr[1]
|
|
b = 0
|
|
a = 1
|
|
elif len(arr) == 3:
|
|
r = arr[0]
|
|
g = arr[1]
|
|
b = arr[2]
|
|
a = 1
|
|
elif len(arr) == 4:
|
|
r = arr[0]
|
|
g = arr[1]
|
|
b = arr[2]
|
|
a = arr[3]
|
|
if to_srgb:
|
|
return Color((linear_to_srgbx(r), linear_to_srgbx(g), linear_to_srgbx(b)))
|
|
elif to_linear:
|
|
return Color((srgb_to_linearx(r), srgb_to_linearx(g), srgb_to_linearx(b)))
|
|
else:
|
|
return Color((r,g,b))
|
|
|
|
|
|
def color_filter(color: Color, filter: Color):
|
|
cf = Color((color.r * filter.r, color.g * filter.g, color.b * filter.b))
|
|
if cf.v < 0.001:
|
|
return color
|
|
return cf * (color.v / cf.v)
|
|
|
|
|
|
def array_to_quaternion(arr):
|
|
if len(arr) == 4:
|
|
return Quaternion((arr[3], arr[0], arr[1], arr[2]))
|
|
return Quaternion()
|
|
|
|
|
|
def strip_cc_base_name(name):
|
|
obj_name = strip_name(name.strip())
|
|
if obj_name.startswith("CC_Base_") or obj_name.startswith("CC_Game_"):
|
|
obj_name = obj_name[8:]
|
|
return obj_name
|
|
|
|
|
|
def remove_from_collection(coll, item):
|
|
for i in range(0, len(coll)):
|
|
if coll[i] == item:
|
|
coll.remove(i)
|
|
return
|
|
|
|
|
|
def delete_armature_object(arm):
|
|
if object_exists_is_armature(arm):
|
|
data = arm.data
|
|
bpy.data.objects.remove(arm)
|
|
if data:
|
|
bpy.data.armatures.remove(data)
|
|
|
|
|
|
def delete_mesh_object(obj):
|
|
if object_exists_is_mesh(obj):
|
|
data = obj.data
|
|
bpy.data.objects.remove(obj)
|
|
if data:
|
|
bpy.data.meshes.remove(data)
|
|
|
|
|
|
def delete_light_object(obj):
|
|
if object_exists_is_light(obj):
|
|
data = obj.data
|
|
bpy.data.objects.remove(obj)
|
|
if data:
|
|
bpy.data.lights.remove(data)
|
|
|
|
|
|
def delete_objects(objects, log=False):
|
|
if objects:
|
|
for obj in objects:
|
|
if log:
|
|
log_info(f" - Deleting object: {obj.name}")
|
|
delete_object(obj)
|
|
|
|
|
|
def delete_object(obj):
|
|
if object_exists(obj):
|
|
try:
|
|
data = obj.data
|
|
except:
|
|
data = None
|
|
if data:
|
|
if obj.type == "MESH":
|
|
try:
|
|
bpy.data.meshes.remove(data)
|
|
except:
|
|
pass
|
|
elif obj.type == "ARMATURE":
|
|
try:
|
|
bpy.data.armatures.remove(data)
|
|
except:
|
|
pass
|
|
elif obj.type == "LIGHT":
|
|
try:
|
|
bpy.data.lights.remove(data)
|
|
except:
|
|
pass
|
|
elif obj.type == "CAMERA":
|
|
try:
|
|
bpy.data.camera.remove(data)
|
|
except:
|
|
pass
|
|
elif obj.type == "CURVE" or obj.type=="SURFACE" or obj.type == "FONT":
|
|
try:
|
|
bpy.data.curves.remove(data)
|
|
except:
|
|
pass
|
|
elif obj.type == "META":
|
|
try:
|
|
bpy.data.metaballs.remove(data)
|
|
except:
|
|
pass
|
|
elif obj.type == "VOLUME":
|
|
try:
|
|
bpy.data.volumes.remove(data)
|
|
except:
|
|
pass
|
|
elif obj.type == "GPENCIL":
|
|
try:
|
|
bpy.data.grease_pencils.remove(data)
|
|
except:
|
|
pass
|
|
elif obj.type == "LATICE":
|
|
try:
|
|
bpy.data.lattices.remove(data)
|
|
except:
|
|
pass
|
|
elif obj.type == "EMPTY":
|
|
try:
|
|
if obj.data:
|
|
if obj.data.type == "IMAGE":
|
|
bpy.data.images.remove(data)
|
|
except:
|
|
pass
|
|
elif obj.type == "LIGHT_PROBE":
|
|
try:
|
|
bpy.data.lightprobes.remove(data)
|
|
except:
|
|
pass
|
|
elif obj.type == "SPEAKER":
|
|
try:
|
|
bpy.data.speakers.remove(data)
|
|
except:
|
|
pass
|
|
try:
|
|
bpy.data.objects.remove(obj)
|
|
except:
|
|
pass
|
|
|
|
|
|
def get_object_tree(obj, objects = None):
|
|
if objects is None:
|
|
objects = []
|
|
if object_exists(obj):
|
|
objects.append(obj)
|
|
for child_obj in obj.children:
|
|
get_object_tree(child_obj, objects)
|
|
return objects
|
|
|
|
|
|
def delete_object_tree(obj):
|
|
objects = get_object_tree(obj)
|
|
for obj in objects:
|
|
delete_object(obj)
|
|
|
|
|
|
def hide_tree(obj, hide = True):
|
|
objects = get_object_tree(obj)
|
|
for obj in objects:
|
|
try:
|
|
obj.hide_set(hide)
|
|
except: ...
|
|
|
|
|
|
def hide(obj, hide=True):
|
|
try:
|
|
obj.hide_set(hide)
|
|
return True
|
|
except:
|
|
return False
|
|
|
|
|
|
def unhide(obj):
|
|
# TODO expand this to force visible in tmp collection if unable to make visible with hide_set
|
|
# but will require something to remove tmp collection later...
|
|
return hide(obj, hide=False)
|
|
|
|
|
|
def get_context_area(context, area_type):
|
|
if context is None:
|
|
context = bpy.context
|
|
for area in context.screen.areas:
|
|
if area.type == area_type:
|
|
return area
|
|
return None
|
|
|
|
|
|
def get_context_mesh(context=None):
|
|
if context is None:
|
|
context = bpy.context
|
|
if object_exists_is_mesh(context.object):
|
|
return context.object
|
|
return None
|
|
|
|
|
|
def get_context_material(context=None):
|
|
if context is None:
|
|
context = bpy.context
|
|
try:
|
|
return context.object.material_slots[context.object.active_material_index].material
|
|
except:
|
|
return None
|
|
|
|
|
|
def get_context_armature(context):
|
|
if context.object:
|
|
if object_exists_is_armature(context.object):
|
|
return context.object
|
|
try:
|
|
arm = context.object.parent
|
|
if object_exists_is_armature(arm):
|
|
return arm
|
|
except:
|
|
pass
|
|
return None
|
|
|
|
|
|
def get_context_character(context, strict=False):
|
|
"""strict: selected must part of the character"""
|
|
props = vars.props()
|
|
chr_cache = props.get_context_character_cache(context)
|
|
|
|
obj = context.object
|
|
mat = get_context_material(context)
|
|
obj_cache = None
|
|
mat_cache = None
|
|
|
|
if chr_cache:
|
|
obj_cache = chr_cache.get_object_cache(obj)
|
|
mat_cache = chr_cache.get_material_cache(mat)
|
|
arm = chr_cache.get_armature()
|
|
|
|
# if the context object is an armature or child of armature that is not part of this chr_cache
|
|
# clear the chr_cache, as this is a separate generic character.
|
|
if obj and not obj_cache:
|
|
if obj.type == "ARMATURE" and obj != arm and obj != chr_cache.rig_meta_rig:
|
|
chr_cache = None
|
|
elif obj.type == "MESH" and obj.parent and obj.parent != arm:
|
|
chr_cache = None
|
|
|
|
# if strict only return chr_cache from valid object_cache context object
|
|
# otherwise it could return the first and only chr_cache
|
|
if strict and (not obj or not obj_cache):
|
|
chr_cache = None
|
|
|
|
return chr_cache, obj, mat, obj_cache, mat_cache
|
|
|
|
|
|
def get_current_tool_idname(context = None):
|
|
if context is None:
|
|
context = bpy.context
|
|
tool_idname = context.workspace.tools.from_space_view3d_mode(context.mode).idname
|
|
return tool_idname
|
|
|
|
|
|
def add_layer_collections(layer_collection: bpy.types.LayerCollection, layer_collections, search = None):
|
|
if search:
|
|
if type(search) is str and search in layer_collection.name:
|
|
layer_collections.append(layer_collection)
|
|
elif type(search) is bpy.types.Collection and layer_collection.collection == search:
|
|
layer_collections.append(layer_collection)
|
|
elif type(search) is bpy.types.LayerCollection and layer_collection == search:
|
|
layer_collections.append(layer_collection)
|
|
else:
|
|
layer_collections.append(layer_collection)
|
|
child_layer_collection : bpy.types.LayerCollection
|
|
for child_layer_collection in layer_collection.children:
|
|
add_layer_collections(child_layer_collection, layer_collections, search)
|
|
|
|
|
|
def get_view_layer_collections(search=None):
|
|
layer_collections = []
|
|
for view_layer in bpy.context.scene.view_layers:
|
|
for layer_collection in view_layer.layer_collection.children:
|
|
add_layer_collections(layer_collection, layer_collections, search)
|
|
return layer_collections
|
|
|
|
|
|
# C.scene.view_layers[0].layer_collection.children[0].exclude
|
|
def limit_view_layer_to_collection(collection_name, *items):
|
|
layer_collections = []
|
|
to_hide = []
|
|
# exclude all active layer collections
|
|
for view_layer in bpy.context.scene.view_layers:
|
|
layer_collection : bpy.types.LayerCollection
|
|
for layer_collection in view_layer.layer_collection.children:
|
|
if not layer_collection.exclude:
|
|
for obj in layer_collection.collection.objects:
|
|
if not obj.visible_get():
|
|
to_hide.append(obj)
|
|
layer_collections.append(layer_collection)
|
|
layer_collection.exclude = True
|
|
# add a new collection just for these items
|
|
tmp_collection = bpy.data.collections.new(collection_name)
|
|
bpy.context.scene.collection.children.link(tmp_collection)
|
|
for item in items:
|
|
if item:
|
|
if type(item) is list:
|
|
for sub_item in item:
|
|
tmp_collection.objects.link(sub_item)
|
|
unhide(sub_item)
|
|
else:
|
|
tmp_collection.objects.link(item)
|
|
unhide(item)
|
|
# return the temp collection and the layers exlcuded
|
|
return tmp_collection, layer_collections, to_hide
|
|
|
|
|
|
def create_collection(name, existing=True, parent_collection: bpy.types.Collection = None):
|
|
if name in bpy.data.collections and existing:
|
|
return bpy.data.collections[name]
|
|
else:
|
|
collection = bpy.data.collections.new(name)
|
|
if parent_collection:
|
|
parent_collection.children.link(collection)
|
|
else:
|
|
bpy.context.scene.collection.children.link(collection)
|
|
return collection
|
|
|
|
|
|
def restore_limited_view_layers(tmp_collection, layer_collections, to_hide):
|
|
objects = []
|
|
for obj in tmp_collection.objects:
|
|
objects.append(obj)
|
|
for obj in objects:
|
|
tmp_collection.objects.unlink(obj)
|
|
bpy.context.scene.collection.children.unlink(tmp_collection)
|
|
bpy.data.collections.remove(tmp_collection)
|
|
for layer_collection in layer_collections:
|
|
layer_collection.exclude = False
|
|
for obj in to_hide:
|
|
hide(obj)
|
|
|
|
|
|
def force_visible_in_scene(collection_name, *objects):
|
|
tmp_collection = bpy.data.collections.new(collection_name)
|
|
bpy.context.scene.collection.children.link(tmp_collection)
|
|
for obj in objects:
|
|
if not obj.visible_get():
|
|
log_info(f"Object: {obj.name} is not visible or in a hidden collection. Linking to temporary root collection and making visible.")
|
|
unhide(obj)
|
|
tmp_collection.objects.link(obj)
|
|
return tmp_collection
|
|
|
|
|
|
def restore_visible_in_scene(tmp_collection : bpy.types.Collection):
|
|
objects = []
|
|
for obj in tmp_collection.objects:
|
|
objects.append(obj)
|
|
for obj in objects:
|
|
log_info(f"Object: {obj.name} Unlinking from temporary root collection and hiding.")
|
|
hide(obj)
|
|
tmp_collection.objects.unlink(obj)
|
|
bpy.context.scene.collection.children.unlink(tmp_collection)
|
|
bpy.data.collections.remove(tmp_collection)
|
|
|
|
|
|
def get_object_scene_collections(obj, exclude_rbw = True):
|
|
collections = []
|
|
if obj.name in bpy.context.scene.collection.objects:
|
|
collections.append(bpy.context.scene.collection)
|
|
rbw = bpy.context.scene.rigidbody_world
|
|
for col in bpy.data.collections:
|
|
# exclude rigid body world collections
|
|
if exclude_rbw and rbw and (col == rbw.collection or col == rbw.constraints):
|
|
continue
|
|
if col != bpy.context.scene.collection and obj.name in col.objects:
|
|
collections.append(col)
|
|
return collections
|
|
|
|
|
|
def get_all_scene_collections(exclude_rbw = True):
|
|
collections = []
|
|
collections.append(bpy.context.scene.collection)
|
|
rbw = bpy.context.scene.rigidbody_world
|
|
for col in bpy.data.collections:
|
|
# exclude rigid body world collections
|
|
if exclude_rbw and rbw and (col == rbw.collection or col == rbw.constraints):
|
|
continue
|
|
if col != bpy.context.scene.collection:
|
|
collections.append(col)
|
|
return collections
|
|
|
|
|
|
def remove_from_scene_collections(obj, collections = None, exclude_rbw = True):
|
|
if collections is None:
|
|
collections = get_all_scene_collections()
|
|
rbw = bpy.context.scene.rigidbody_world
|
|
for col in collections:
|
|
# exclude rigid body world collections
|
|
if exclude_rbw and rbw and (col == rbw.collection or col == rbw.constraints):
|
|
continue
|
|
if obj.name in col.objects:
|
|
col.objects.unlink(obj)
|
|
|
|
|
|
def move_object_to_scene_collections(obj, collections, exclude_rbw = True):
|
|
remove_from_scene_collections(obj)
|
|
rbw = bpy.context.scene.rigidbody_world
|
|
for col in collections:
|
|
# exclude rigid body world collections
|
|
if exclude_rbw and rbw and (col == rbw.collection or col == rbw.constraints):
|
|
continue
|
|
if obj.name not in col.objects:
|
|
col.objects.link(obj)
|
|
|
|
|
|
def store_mode_selection_state():
|
|
mode = get_mode()
|
|
active = get_active_object()
|
|
selection = bpy.context.selected_objects.copy()
|
|
return [mode, active, selection,
|
|
(bpy.context.scene.frame_current, bpy.context.scene.frame_start, bpy.context.scene.frame_end)]
|
|
|
|
|
|
def restore_mode_selection_state(store):
|
|
try:
|
|
set_mode("OBJECT")
|
|
try_select_objects(store[2], True)
|
|
set_active_object(store[1])
|
|
set_mode(store[0])
|
|
bpy.context.scene.frame_current = store[3][0]
|
|
bpy.context.scene.frame_start = store[3][1]
|
|
bpy.context.scene.frame_end = store[3][2]
|
|
except:
|
|
pass
|
|
|
|
|
|
def store_render_visibility_state(objects=None):
|
|
rv = {}
|
|
obj : bpy.types.Object
|
|
if objects is None:
|
|
objects = bpy.data.objects
|
|
for obj in objects:
|
|
if object_exists(obj):
|
|
visible = obj.visible_get()
|
|
render = not obj.hide_render
|
|
if render or visible:
|
|
rv[obj.name] = [visible, render]
|
|
return rv
|
|
|
|
|
|
def restore_render_visibility_state(rv):
|
|
obj : bpy.types.Object
|
|
for obj in bpy.data.objects:
|
|
if object_exists(obj):
|
|
if obj.name in rv:
|
|
visible, render = rv[obj.name]
|
|
try:
|
|
obj.hide_render = not render
|
|
hide(obj, not visible)
|
|
except:
|
|
pass
|
|
|
|
else:
|
|
try:
|
|
obj.hide_render = False
|
|
hide(obj)
|
|
except:
|
|
pass
|
|
|
|
|
|
def set_only_render_visible(object):
|
|
obj : bpy.types.Object
|
|
for obj in bpy.data.objects:
|
|
if object_exists(obj):
|
|
visible = obj.visible_get()
|
|
render = not obj.hide_render
|
|
if obj == object:
|
|
try:
|
|
obj.hide_render = False
|
|
unhide(obj)
|
|
except:
|
|
pass
|
|
else:
|
|
try:
|
|
obj.hide_render = True
|
|
hide(obj)
|
|
except:
|
|
pass
|
|
|
|
|
|
def store_object_transform(obj: bpy.types.Object):
|
|
T = (obj.location.copy(),
|
|
obj.rotation_mode,
|
|
obj.rotation_quaternion.copy(),
|
|
[a for a in obj.rotation_axis_angle],
|
|
obj.rotation_euler.copy(),
|
|
obj.scale.copy())
|
|
return T
|
|
|
|
|
|
def restore_object_transform(obj: bpy.types.Object, T: tuple, ignore_scale=False):
|
|
if ignore_scale:
|
|
obj.location, obj.rotation_mode, obj.rotation_quaternion, obj.rotation_axis_angle, obj.rotation_euler, scale = T
|
|
else:
|
|
obj.location, obj.rotation_mode, obj.rotation_quaternion, obj.rotation_axis_angle, obj.rotation_euler, obj.scale = T
|
|
|
|
|
|
def reset_object_transform(obj: bpy.types.Object):
|
|
obj.location = Vector((0,0,0))
|
|
obj.rotation_quaternion = Quaternion((1.0, 0.0, 0.0, 0.0))
|
|
obj.rotation_euler = Euler((0.0, -0.0, 0.0), 'XYZ')
|
|
obj.rotation_axis_angle = [0,0,0,0]
|
|
|
|
|
|
def get_region_3d(context=None):
|
|
space = get_view_3d_space(context)
|
|
if space:
|
|
return space, space.region_3d
|
|
return None, None
|
|
|
|
|
|
def get_view_3d_space(context=None) -> bpy.types.Space:
|
|
try:
|
|
if not context:
|
|
context = bpy.context
|
|
space_data = bpy.context.space_data
|
|
if space_data and space_data.tpye == "VIEW_3D":
|
|
return space_data
|
|
except: ...
|
|
try:
|
|
area = get_view_3d_area(context)
|
|
if area:
|
|
return area.spaces.active
|
|
except: ...
|
|
log_warn("Unable to get view 3d space!")
|
|
return None
|
|
|
|
|
|
def get_view_3d_shading(context=None) -> bpy.types.View3DShading:
|
|
try:
|
|
if not context:
|
|
context = bpy.context
|
|
space_data = context.space_data
|
|
if space_data and space_data.type == "VIEW_3D":
|
|
return space_data.shading
|
|
except: ...
|
|
try:
|
|
space_data = get_view_3d_space(context)
|
|
if space_data:
|
|
return space_data.shading
|
|
except: ...
|
|
log_warn("Unable to get view space shading!")
|
|
return None
|
|
|
|
|
|
def get_view_3d_area(context=None) -> bpy.types.Area:
|
|
try:
|
|
if not context:
|
|
context = bpy.context
|
|
for area in context.screen.areas:
|
|
if area.type == 'VIEW_3D':
|
|
return area
|
|
except: ...
|
|
return None
|
|
|
|
|
|
def align_object_to_view(obj, context):
|
|
if context is None:
|
|
context = bpy.context
|
|
area_3d = None
|
|
if context.area and context.area.type == 'VIEW_3D':
|
|
area_3d = bpy.context.area
|
|
else:
|
|
for area in context.screen.areas:
|
|
if area.type == 'VIEW_3D':
|
|
area_3d = area
|
|
if area_3d:
|
|
view_space = area_3d.spaces.active
|
|
r3d = view_space.region_3d
|
|
loc = r3d.view_location
|
|
rot = r3d.view_rotation
|
|
D = r3d.view_distance
|
|
v = Vector((0,0,1)) * D
|
|
|
|
obj.location = loc + rot @ v
|
|
if obj.rotation_mode == "XYZ":
|
|
obj.rotation_euler = rot.to_euler()
|
|
elif obj.rotation_mode == "QUATERNION":
|
|
obj.rotation_quaternion = rot.copy()
|
|
|
|
|
|
def copy_action(action: bpy.types.Action, new_name):
|
|
new_action = action.copy()
|
|
new_action.name = new_name
|
|
return new_action
|
|
|
|
|
|
def safe_get_action(obj) -> bpy.types.Action:
|
|
if obj:
|
|
try:
|
|
if obj.animation_data:
|
|
return obj.animation_data.action
|
|
except:
|
|
log_warn(f"Unable to get action from {obj.name}")
|
|
return None
|
|
|
|
|
|
def safe_set_action(obj, action, create=True):
|
|
if obj:
|
|
try:
|
|
if create and not obj.animation_data:
|
|
obj.animation_data_create()
|
|
if obj.animation_data:
|
|
obj.animation_data.action = action
|
|
return True
|
|
except:
|
|
action_name = action.name if action else "None"
|
|
log_warn(f"Unable to set action {action_name} to {obj.name}")
|
|
return False
|
|
|
|
|
|
def index_of_collection(item, collection):
|
|
for i, o in enumerate(collection):
|
|
if o == item:
|
|
return i
|
|
return -1
|
|
|
|
|
|
def collection_at_index(index, collection):
|
|
if index >= 0 and index < len(collection):
|
|
return collection[index]
|
|
return None
|
|
|
|
|
|
def set_active_layer_collection(layer_collection):
|
|
old = bpy.context.view_layer.active_layer_collection
|
|
bpy.context.view_layer.active_layer_collection = layer_collection
|
|
return old
|
|
|
|
|
|
def set_active_layer_collection_from(obj):
|
|
nlc = find_layer_collection_containing(obj)
|
|
return set_active_layer_collection(nlc)
|
|
|
|
|
|
def find_layer_collection_containing(obj, layer_collection = None):
|
|
if not layer_collection:
|
|
layer_collection = bpy.context.view_layer.layer_collection
|
|
if obj.name in layer_collection.collection.objects:
|
|
return layer_collection
|
|
for child in layer_collection.children:
|
|
found = find_layer_collection_containing(obj, child)
|
|
if found:
|
|
return found
|
|
return None
|
|
|
|
|
|
def find_layer_collection(name, layer_collection = None):
|
|
if not layer_collection:
|
|
layer_collection = bpy.context.view_layer.layer_collection
|
|
if layer_collection.name == name:
|
|
return layer_collection
|
|
for child in layer_collection.children:
|
|
found = find_layer_collection(name, child)
|
|
if found:
|
|
return found
|
|
return None
|
|
|
|
|
|
def clear_prop_collection(col):
|
|
try:
|
|
col.clear()
|
|
return True
|
|
except:
|
|
pass
|
|
try:
|
|
while col:
|
|
col.remove(col[0])
|
|
return True
|
|
except:
|
|
pass
|
|
log_error(f"Unable to clear property collection: {col}")
|
|
return False
|
|
|
|
|
|
def B290():
|
|
return is_blender_version("2.90.0")
|
|
|
|
def B291():
|
|
return is_blender_version("2.91.0")
|
|
|
|
def B292():
|
|
return is_blender_version("2.92.0")
|
|
|
|
def B293():
|
|
return is_blender_version("2.93.0")
|
|
|
|
def B300():
|
|
return is_blender_version("3.0.0")
|
|
|
|
def B310():
|
|
return is_blender_version("3.1.0")
|
|
|
|
def B320():
|
|
return is_blender_version("3.2.0")
|
|
|
|
def B321():
|
|
return is_blender_version("3.2.1")
|
|
|
|
def B330():
|
|
return is_blender_version("3.3.0")
|
|
|
|
def B340():
|
|
return is_blender_version("3.4.0")
|
|
|
|
def B341():
|
|
return is_blender_version("3.4.1")
|
|
|
|
def B350():
|
|
return is_blender_version("3.5.0")
|
|
|
|
def B400():
|
|
return is_blender_version("4.0.0")
|
|
|
|
def B401():
|
|
return is_blender_version("4.0.1")
|
|
|
|
def B410():
|
|
return is_blender_version("4.1.0")
|
|
|
|
def B420():
|
|
return is_blender_version("4.2.0")
|
|
|
|
def B430():
|
|
return is_blender_version("4.3.0")
|
|
|
|
|
|
def is_blender_version(version: str, test = "GTE"):
|
|
"""e.g. is_blender_version("3.0.0", "GTE")"""
|
|
major, minor, subversion = version.split(".")
|
|
blender_version = bpy.app.version
|
|
|
|
v_test = int(major) * 1000000 + int(minor) * 1000 + int(subversion)
|
|
v_blender = blender_version[0] * 1000000 + blender_version[1] * 1000 + blender_version[2]
|
|
|
|
if test == "GTE" and v_blender >= v_test:
|
|
return True
|
|
elif test == "GT" and v_blender > v_test:
|
|
return True
|
|
elif test == "LT" and v_blender < v_test:
|
|
return True
|
|
elif test == "LTE" and v_blender <= v_test:
|
|
return True
|
|
elif test == "EQ" and v_blender == v_test:
|
|
return True
|
|
elif test == "NE" and v_blender != v_test:
|
|
return True
|
|
return False
|
|
|
|
|
|
def is_addon_version(version: str, test = "GTE"):
|
|
"""e.g. is_addon_version("v1.1.8", "GTE")"""
|
|
major, minor, subversion = version[1:].split(".")
|
|
addon_version = vars.VERSION_STRING
|
|
addon_major, addon_minor, addon_subversion = addon_version[1:].split(".")
|
|
|
|
v_test = int(major) * 1000000 + int(minor) * 1000 + int(subversion)
|
|
v_addon = int(addon_major) * 1000000 + int(addon_minor) * 1000 + int(addon_subversion)
|
|
|
|
if test == "GTE" and v_addon >= v_test:
|
|
return True
|
|
elif test == "GT" and v_addon > v_test:
|
|
return True
|
|
elif test == "LT" and v_addon < v_test:
|
|
return True
|
|
elif test == "LTE" and v_addon <= v_test:
|
|
return True
|
|
elif test == "EQ" and v_addon == v_test:
|
|
return True
|
|
elif test == "NE" and v_addon != v_test:
|
|
return True
|
|
return False
|
|
|
|
|
|
def clear_reports():
|
|
win = bpy.context.window_manager.windows[0]
|
|
temp_area = True
|
|
info_area = win.screen.areas[0]
|
|
# try to find an existing info area
|
|
for area in win.screen.areas:
|
|
if info_area.type == "INFO":
|
|
info_area = area
|
|
temp_area = False
|
|
|
|
# other wise turn the first area into an info area temporarily
|
|
if temp_area:
|
|
area_type = info_area.type
|
|
info_area.type = "INFO"
|
|
|
|
context = bpy.context.copy()
|
|
context['window'] = win
|
|
context['screen'] = win.screen
|
|
context['area'] = win.screen.areas[0]
|
|
bpy.ops.info.select_all(context, action='SELECT')
|
|
bpy.ops.info.report_delete(context)
|
|
|
|
# restore the temp area
|
|
if temp_area:
|
|
info_area.type = area_type
|
|
|
|
|
|
def get_last_report():
|
|
win = bpy.context.window_manager.windows[0]
|
|
temp_area = True
|
|
info_area = win.screen.areas[0]
|
|
# try to find an existing info area
|
|
for area in win.screen.areas:
|
|
if info_area.type == "INFO":
|
|
info_area = area
|
|
temp_area = False
|
|
|
|
# other wise turn the first area into an info area temporarily
|
|
if temp_area:
|
|
area_type = info_area.type
|
|
info_area.type = "INFO"
|
|
|
|
context = bpy.context.copy()
|
|
context['window'] = win
|
|
context['screen'] = win.screen
|
|
context['area'] = win.screen.areas[0]
|
|
bpy.ops.info.select_all(context, action='SELECT')
|
|
bpy.ops.info.report_copy(context)
|
|
|
|
# restore the temp area
|
|
if temp_area:
|
|
info_area.type = area_type
|
|
|
|
# return the last line
|
|
clipboard = bpy.context.window_manager.clipboard
|
|
lines = clipboard.splitlines()
|
|
return lines[-1]
|
|
|
|
|
|
def match_wild(test: str, match_list: list) -> bool:
|
|
if test and match_list:
|
|
for match in match_list:
|
|
if test == match:
|
|
return True
|
|
elif match.startswith("*") and match.endswith("*"):
|
|
if match[1:-1] in test:
|
|
return True
|
|
elif match.startswith("*"):
|
|
if match[1:] in test:
|
|
return True
|
|
elif match.endswith("*"):
|
|
if match[:-1] in test:
|
|
return True
|
|
return False
|
|
|
|
|
|
def copy_collection_property(prop_a, prop_b, exclude: list = None):
|
|
prop_b.clear()
|
|
for prop in prop_a:
|
|
to_prop = prop_b.add()
|
|
copy_property_group(prop, to_prop, exclude=exclude)
|
|
|
|
|
|
def copy_property_group(group_a, group_b, exclude: list = None):
|
|
vars.block_property_update = True
|
|
# items() returns a list of properties that have been changed
|
|
# from the defaults, or been set, in the property group:
|
|
# returns a list of tuples [(prop, value), (prop, value)...]
|
|
items_a = group_a.items()
|
|
# get a list of all property names in group_a that have been altered
|
|
props_a = [ i[0] for i in items_a ]
|
|
# get a list of all properties in group_b
|
|
props_b = dir(group_b)
|
|
# get a list of all properties that have been changed in group_a and are present in group_b
|
|
props = [ p for p in props_a if p in props_b ]
|
|
for prop in props:
|
|
if exclude and match_wild(prop, exclude):
|
|
log_info(f" - excluding: {prop}")
|
|
continue
|
|
value = getattr(group_a, prop)
|
|
target = getattr(group_b, prop)
|
|
if type(target) == type(value) or value is None or target is None:
|
|
if issubclass(type(value), bpy.types.PropertyGroup):
|
|
# all property groups are subclasses of bpy.types.PropertyGroup
|
|
log_info(f" - copying property group: {prop}")
|
|
copy_property_group(value, target, exclude=exclude)
|
|
elif hasattr(value, "clear") and hasattr(value, "add"):
|
|
# collection properties have add() and clear() functions
|
|
log_info(f" - copying collection property: {prop}")
|
|
copy_collection_property(value, target, exclude=exclude)
|
|
else:
|
|
log_info(f" - setting: {prop} {value}")
|
|
setattr(group_b, prop, value)
|
|
else:
|
|
log_error(f"Properties are of different types: {prop} {type(value)} != {type(target)}")
|
|
vars.block_property_update = False
|
|
|
|
|
|
def stop_now():
|
|
raise Exception("STOP!")
|
|
|
|
|
|
def object_world_location(obj : bpy.types.Object, delta = None):
|
|
location = obj.location.copy()
|
|
if delta:
|
|
location += delta
|
|
if obj.parent:
|
|
return obj.parent.matrix_world @ location
|
|
else:
|
|
return location
|
|
|
|
|
|
def is_valid_icon(icon):
|
|
return icon in bpy.types.UILayout.bl_rna.functions["prop"].parameters["icon"].enum_items.keys()
|
|
|
|
|
|
def check_icon(icon):
|
|
if B321():
|
|
if icon == "OUTLINER_OB_HAIR":
|
|
return "OUTLINER_OB_CURVES"
|
|
elif icon == "HAIR":
|
|
return "CURVES"
|
|
return icon
|
|
|
|
|
|
def md5sum(filename):
|
|
hash = md5()
|
|
with open(filename, "rb") as f:
|
|
for chunk in iter(lambda: f.read(128 * hash.block_size), b""):
|
|
hash.update(chunk)
|
|
return hash.hexdigest()
|
|
|
|
|
|
def store_object_state(objects=None):
|
|
"""Store object & mesh/armature and material names and slots."""
|
|
if objects is None:
|
|
objects = bpy.data.objects
|
|
obj_state = {}
|
|
for obj in objects:
|
|
if (object_exists_is_armature(obj) or object_exists_is_mesh(obj)) and obj not in obj_state:
|
|
obj_state[obj] = {
|
|
"names": [obj.name, obj.data.name],
|
|
"visible": obj.visible_get(),
|
|
}
|
|
if obj.type == "MESH":
|
|
obj_state[obj]["slots"] = [ slot.material for slot in obj.material_slots ]
|
|
for mat in obj.data.materials:
|
|
if material_exists(mat) and mat not in obj_state:
|
|
obj_state[mat] = { "name": mat.name }
|
|
if obj.data.shape_keys and obj.data.shape_keys.key_blocks:
|
|
obj_state[obj]["action"] = safe_get_action(obj.data.shape_keys)
|
|
if obj.type == "ARMATURE":
|
|
obj_state[obj]["action"] = safe_get_action(obj)
|
|
return obj_state
|
|
|
|
|
|
def restore_object_state(obj_state):
|
|
"""Restore object & mesh/armature and material names and slots."""
|
|
for item in obj_state:
|
|
state = obj_state[item]
|
|
if type(item) is bpy.types.Object:
|
|
obj: bpy.types.Object = item
|
|
restore_name = True
|
|
if "rl_do_not_restore_name" in obj:
|
|
restore_name = False
|
|
del obj["rl_do_not_restore_name"]
|
|
if object_exists(obj):
|
|
if restore_name:
|
|
force_object_name(obj, state["names"][0])
|
|
if obj.type == "MESH":
|
|
if restore_name:
|
|
force_mesh_name(obj.data, state["names"][1])
|
|
for i, mat in enumerate(state["slots"]):
|
|
if not material_exists(mat):
|
|
mat = None
|
|
if obj.material_slots[i].material != mat:
|
|
obj.material_slots[i].material = mat
|
|
if "action" in state:
|
|
safe_set_action(obj.data.shape_keys, state["action"])
|
|
elif obj.type == "ARMATURE":
|
|
if restore_name:
|
|
force_armature_name(obj.data, state["names"][1])
|
|
if "action" in state:
|
|
safe_set_action(obj, state["action"])
|
|
elif type(item) is bpy.types.Material:
|
|
mat: bpy.types.Material = item
|
|
if material_exists(mat):
|
|
force_material_name(mat, state["name"])
|
|
|
|
|
|
def reset_shape_keys(objects):
|
|
"""Unlock and reset object shape keys to zero."""
|
|
for obj in objects:
|
|
if obj.type == "MESH":
|
|
# disable shape key lock
|
|
obj.show_only_shape_key = False
|
|
# reset all shape keys to zero
|
|
if obj.data.shape_keys and obj.data.shape_keys.key_blocks:
|
|
for key in obj.data.shape_keys.key_blocks:
|
|
key.value = 0.0
|
|
|
|
|
|
INVALID_EXPORT_CHARACTERS = "`¬!\"£$%^&*()+-=[]{}:@~;'#<>?,./\| "
|
|
DIGITS = "0123456789"
|
|
|
|
|
|
def is_invalid_export_name(name, is_material = False):
|
|
for char in INVALID_EXPORT_CHARACTERS:
|
|
if char in name:
|
|
return True
|
|
if is_material:
|
|
if name[0] in DIGITS:
|
|
return True
|
|
return False
|
|
|
|
|
|
def safe_export_name(name, is_material = False, is_split=False):
|
|
if is_split:
|
|
if is_blender_duplicate(name):
|
|
num = get_duplication_suffix(name)
|
|
name = strip_name(name) + f"_S{num:02}"
|
|
for char in INVALID_EXPORT_CHARACTERS:
|
|
if char in name:
|
|
name = name.replace(char, "_")
|
|
if is_material:
|
|
if name[0] in DIGITS:
|
|
name = f"_{name}"
|
|
return name
|
|
|
|
|
|
def determine_object_export_name(chr_cache, obj, obj_cache = None):
|
|
"""Work out what the object should be named when exporting
|
|
by comparing the current name with the original name when imported.
|
|
"""
|
|
obj_name = obj.name
|
|
if not obj_cache:
|
|
obj_cache = chr_cache.get_object_cache(obj)
|
|
source_changed = False
|
|
is_new_object = False
|
|
if obj_cache:
|
|
obj_expected_source_name = safe_export_name(strip_name(obj_name))
|
|
obj_source_name = obj_cache.source_name
|
|
source_changed = obj_expected_source_name != obj_source_name
|
|
if source_changed:
|
|
obj_safe_name = safe_export_name(obj_name)
|
|
else:
|
|
obj_safe_name = obj_source_name
|
|
else:
|
|
is_new_object = True
|
|
obj_safe_name = safe_export_name(obj_name)
|
|
obj_source_name = obj_safe_name
|
|
return obj_safe_name
|
|
|
|
|
|
def furthest_from(p0, *points):
|
|
most = 0
|
|
result = p0
|
|
for p in points:
|
|
dp = (p - p0).length
|
|
if dp > most:
|
|
most = dp
|
|
result = p
|
|
return result
|
|
|
|
|
|
def name_contains_distinct_keywords(name : str, *keywords : str):
|
|
"""Does the name contain the supplied keywords in distinct form:\n
|
|
i.e. capitalized "OneTwoThree"\n
|
|
or hungarian notation "oneTwoThree"\n
|
|
or surrouned by underscores "one_two_three"
|
|
"""
|
|
|
|
name_lower = name.lower()
|
|
name_length = len(name)
|
|
|
|
for k in keywords:
|
|
k_lower = k.lower()
|
|
k_length = len(k)
|
|
|
|
s = name_lower.find(k_lower)
|
|
e = s + k_length
|
|
|
|
if s >= 0:
|
|
|
|
# is keyword in name separated by underscores
|
|
if (name_lower.startswith(k_lower + "_") or
|
|
name_lower.endswith("_" + k_lower) or
|
|
"_" + k_lower + "_" in name_lower or
|
|
name_lower == k_lower):
|
|
return True
|
|
|
|
# match distinct keyword at start of name (any capitalization) or captitalized anywhere else
|
|
if s == 0 or name[s].isupper():
|
|
if e >= name_length or not name[e].islower():
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
def is_name_or_duplication(a, b):
|
|
return strip_name(a) == strip_name(b)
|
|
|
|
|
|
def object_has_shape_keys(obj):
|
|
try:
|
|
if obj.data.shape_keys and obj.data.shape_keys.key_blocks:
|
|
return True
|
|
else:
|
|
return False
|
|
except:
|
|
return False
|
|
|
|
|
|
def object_scale(obj):
|
|
try:
|
|
return (obj.scale[0] + obj.scale[1] + obj.scale[2]) / 3.0
|
|
except:
|
|
return 1.0
|
|
|
|
|
|
def make_transform_matrix(loc: Vector, rot: Quaternion, sca: Vector):
|
|
return Matrix.Translation(loc) @ (rot.to_matrix().to_4x4()) @ Matrix.Diagonal(sca).to_4x4()
|
|
|
|
|
|
def is_local_view(context):
|
|
try:
|
|
return context.space_data.local_view is not None
|
|
except:
|
|
return False
|
|
|
|
|
|
def fix_local_view(context):
|
|
if is_local_view(context):
|
|
bpy.ops.view3d.localview()
|
|
|
|
|
|
def show_system_file_browser(path):
|
|
if platform.system() == "Windows":
|
|
try:
|
|
explorer_path = os.path.join(os.getenv("WINDIR"), "explorer.exe")
|
|
subprocess.Popen((explorer_path, "/select,", path))
|
|
except:
|
|
pass
|
|
|
|
|
|
def get_scene_frame_range():
|
|
scene = bpy.context.scene
|
|
if scene.use_preview_range:
|
|
return scene.frame_preview_start, scene.frame_preview_end
|
|
else:
|
|
return scene.frame_start, scene.frame_end
|
|
|
|
|
|
def set_scene_frame_range(start, end):
|
|
scene = bpy.context.scene
|
|
if scene.use_preview_range:
|
|
scene.frame_preview_start = start
|
|
scene.frame_preview_end = end
|
|
else:
|
|
scene.frame_start = start
|
|
scene.frame_end = end
|
|
|
|
|
|
def make_empty(name, loc=None, rot=None, scale=None, matrix=None):
|
|
ob = bpy.data.objects.new(name, None)
|
|
if matrix:
|
|
ob.matrix_world = matrix
|
|
else:
|
|
if loc:
|
|
ob.location = loc
|
|
if rot:
|
|
ob.rotation_mode = "QUATERNION"
|
|
ob.rotation_quaternion = rot
|
|
if scale:
|
|
ob.scale = scale
|
|
bpy.context.scene.collection.objects.link(ob)
|
|
|
|
|
|
def generate_random_id(length):
|
|
CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
|
|
id = ""
|
|
for i in range(0, length):
|
|
id += random.choice(CHARS)
|
|
return id
|
|
|
|
|
|
def set_rl_object_id(obj, new_id):
|
|
if obj:
|
|
if obj.type == "ARMATURE":
|
|
obj["rl_armature_id"] = new_id
|
|
if "rl_object_id" in obj:
|
|
del(obj["rl_object_id"])
|
|
else:
|
|
obj["rl_object_id"] = new_id
|
|
|
|
|
|
def get_rl_object_id(obj):
|
|
if obj:
|
|
if obj.type == "ARMATURE" and "rl_armature_id" in obj:
|
|
return obj["rl_armature_id"]
|
|
if "rl_object_id" in obj:
|
|
return obj["rl_object_id"]
|
|
return None
|
|
|
|
|
|
def custom_prop(obj, prop_name, default=None):
|
|
if prop_name in obj:
|
|
return obj[prop_name]
|
|
return default
|
|
|
|
|
|
def fix_texture_rel_path(rel_path: str):
|
|
"""Fixes json texture relative path export bug in CC4 when exporting character directly
|
|
to the root folder of a drive"""
|
|
|
|
if rel_path.startswith(".textures"):
|
|
rel_path = rel_path[1:]
|
|
elif rel_path.startswith("./"):
|
|
rel_path = rel_path[2:]
|
|
return rel_path
|
|
|
|
|
|
def get_resource_path(folder, file):
|
|
addon_path = os.path.dirname(os.path.realpath(__file__))
|
|
resource_path = os.path.join(addon_path, folder, file)
|
|
return resource_path
|
|
|
|
|
|
def get_resource_folder(folder):
|
|
addon_path = os.path.dirname(os.path.realpath(__file__))
|
|
resource_folder = os.path.join(addon_path, folder)
|
|
return resource_folder
|
|
|
|
|
|
def get_unique_folder_path(parent_folder, folder_name, create=False, reuse=False):
|
|
suffix = 1
|
|
base_name = folder_name
|
|
folder_path = os.path.normpath(os.path.join(parent_folder, folder_name))
|
|
if not reuse:
|
|
while os.path.exists(folder_path):
|
|
folder_name = f"{base_name}_{str(suffix)}"
|
|
folder_path = os.path.normpath(os.path.join(parent_folder, folder_name))
|
|
suffix += 1
|
|
if create:
|
|
os.makedirs(folder_path, exist_ok=reuse)
|
|
return folder_path
|
|
|
|
|
|
def get_unique_file_path(parent_folder, file_name, reuse=False):
|
|
suffix = 1
|
|
base_name, ext = os.path.splitext(file_name)
|
|
file_path = os.path.normpath(os.path.join(parent_folder, file_name))
|
|
if not reuse:
|
|
while os.path.exists(file_path):
|
|
file_name = f"{base_name}_{str(suffix)}{ext}"
|
|
file_path = os.path.normpath(os.path.join(parent_folder, file_name))
|
|
suffix += 1
|
|
return file_path
|
|
|
|
|
|
def make_sub_folder(parent_folder, folder_name):
|
|
folder_path = os.path.normpath(os.path.join(parent_folder, folder_name))
|
|
os.makedirs(folder_path, exist_ok=True)
|
|
return folder_path
|
|
|
|
|
|
def open_folder(folder_path):
|
|
os.startfile(folder_path) |