Raincloud/blender-portable-repo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
blender-portable-repo/scripts/addons/cc_blender_tools-2_4_0/utils.py
T
Raincloud eef5547a2c 2026-03-11_4
2026-03-17 15:34:28 -06:00

3162 lines
89 KiB
Python
Raw Permalink Blame History

# 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, json
import traceback
from mathutils import Vector, Quaternion, Matrix, Euler, Color
from hashlib import md5
import bpy
from typing import List
from . import vars
timer = 0
LOG_TIMER = {}
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(name="NONE"):
global LOG_TIMER
LOG_TIMER[name] = [time.perf_counter(), 0.0, 0]
def mark_timer(name="NONE"):
global LOG_TIMER
if name not in LOG_TIMER:
start_timer(name)
LOG_TIMER[name][0] = time.perf_counter()
def update_timer(name="NONE"):
global LOG_TIMER
if name not in LOG_TIMER:
start_timer(name)
pc = time.perf_counter()
duration = pc - LOG_TIMER[name][0]
LOG_TIMER[name][1] += duration
LOG_TIMER[name][0] = pc
LOG_TIMER[name][2] += 1
def log_timer(msg, unit = "s", name="NONE"):
global LOG_TIMER
prefs = vars.prefs()
if name not in LOG_TIMER:
start_timer(name)
if LOG_TIMER[name][2] == 0:
update_timer(name)
if prefs.log_level == "ALL" or prefs.log_level == "DETAILS":
total_duration = LOG_TIMER[name][1]
if unit == "ms":
total_duration *= 1000
elif unit == "us":
total_duration *= 1000000
elif unit == "ns":
total_duration *= 1000000000
print((" " * LOG_INDENT) + msg + ": " + str(total_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 deduplicate_names(names: list, func=None, replace: dict=None, partial=False):
totals = {}
name: str = None
for i, name in enumerate(names):
if replace:
if partial:
for r in replace:
if r in name:
name = name.replace(r, replace[r])
break
elif name in replace:
name = replace[name]
if func:
name = func(name)
if name in totals:
count = totals[name]
else:
count = 0
totals[name] = 0
names[i] = name if count == 0 else f"{name}.{count:03d}"
totals[name] += 1
return names
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, suffix=""):
name = strip_name(name)
if capitalize:
name = name.capitalize()
if suffix:
suffix = "_" + suffix
try_name = name + suffix
if try_name in bpy.data.objects and bpy.data.objects[try_name] != obj:
index = start_index
try_name = name + str(index).zfill(2) + suffix
while try_name in bpy.data.objects:
index += 1
try_name = name + str(index).zfill(2) + suffix
return try_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) -> bool:
"""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_is_camera(obj):
"""Test if Object: obj still exists as an object in the scene, and is a camera."""
if obj is None:
return False
try:
name = obj.name
return len(obj.users_scene) > 0 and obj.type == "CAMERA"
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 action_exists(action: bpy.types.Action):
if action is None:
return False
try:
name = action.name
return True
except:
return False
def id_exists(item):
if item is None:
return False
try:
id = item.id_data
return True
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 same_sign(a, b):
if a < 0 and b < 0:
return True
if a > 0 and b > 0:
return True
return False
def sign(a):
if a >= 0:
return 1
return -1
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(from_min, from_max, to_min, to_max, x):
return to_min + ((x - from_min) * (to_max - to_min) / (from_max - from_min))
def lerp(v0, v1, t, clamp=True):
if clamp:
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):
if len(c0) == 4:
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))
else:
r = (lerp(c0[0], c1[0], t),
lerp(c0[1], c1[1], t),
lerp(c0[2], c1[2], 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):
if len(color) == 4:
return (linear_to_srgbx(color[0]),
linear_to_srgbx(color[1]),
linear_to_srgbx(color[2]),
color[3])
else:
return (linear_to_srgbx(color[0]),
linear_to_srgbx(color[1]),
linear_to_srgbx(color[2]))
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):
if len(color) == 4:
return (srgb_to_linearx(color[0]),
srgb_to_linearx(color[1]),
srgb_to_linearx(color[2]),
color[3])
else:
return (srgb_to_linearx(color[0]),
srgb_to_linearx(color[1]),
srgb_to_linearx(color[2]))
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 mag(vector: tuple):
tot = 0
for v in vector:
tot += v*v
return pow(tot, 0.5)
def lum(col: tuple):
rgb: list = col[:3]
while len(rgb) < 3:
rgb.append(0)
a = 1.0 if len(col) < 4 else col[3]
return (0.2126*rgb[0] + 0.7152*rgb[1] + 0.0722*rgb[2]) * a
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, duplicate_actions=False, keep_actions=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
obj_slot = None
key_action = None
key_slot = None
# store existing actions
obj_action, obj_slot = safe_get_action_slot(obj)
if not duplicate_actions:
safe_set_action(obj, None, create=False)
if obj.type == "MESH":
key_action, key_slot = safe_get_action_slot(obj.data.shape_keys)
if not duplicate_actions:
safe_set_action(obj.data.shape_keys, None, create=False)
# duplicate object
bpy.ops.object.duplicate()
duplicate = get_active_object()
# restore non-duplicated actions
if not duplicate_actions:
if key_action:
safe_set_action(obj.data.shape_keys, key_action, slot=key_slot)
if obj_action:
safe_set_action(obj, obj_action, slot=obj_slot)
# restore actions on duplicate
if keep_actions:
if key_action:
safe_set_action(duplicate.data.shape_keys, key_action, slot=key_slot)
if obj_action:
safe_set_action(duplicate, obj_action, slot=obj_slot)
return duplicate
return None
def remove_all_shape_keys(obj: bpy.types.Object):
# Bugged in Blender 4.4 (Maybe other versions too) - reverting to operators
#if obj and obj.data.shape_keys and obj.data.shape_keys.key_blocks:
# key: bpy.types.ShapeKey = None
# 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)
if obj and obj.data.shape_keys and obj.data.shape_keys.key_blocks:
sms = store_mode_selection_state()
set_active_object(obj, True)
bpy.ops.object.shape_key_remove(all=True, apply_mix=False)
restore_mode_selection_state(sms)
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 force_action_name(action, name):
if name in bpy.data.actions:
existing = bpy.data.actions[name]
if existing != action:
old_name = action.name
rnd_id = generate_random_id(10)
existing.name = existing.name + "_" + rnd_id
action.name = name
existing.name = old_name
else:
action.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
def strip_name(name: str):
"""Remove any .001 from the material name"""
if len(name) >= 4:
if name[-4] == "." and name[-3:].isdigit():
name = name[:-4]
return name
def deduplicate_name(name: str):
"""Remove any _01 or _1 from the material name"""
if len(name) >= 3:
if name[-3] == "_" and name[-2:].isdigit():
name = name[:-3]
elif len(name) >= 2:
if name[-2] == "_" and name[-1:].isdigit():
name = name[:-2]
return name
def source_name(name):
return strip_name(deduplicate_name(name))
def is_same_source_name(name1, name2):
return source_name(name1) == source_name(name2)
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, of_type=None):
for child in obj.children:
if child not in objects:
if child.type == "ARMATURE" and not follow_armatures:
continue
if not of_type or child.type == of_type:
objects.append(child)
if child.children:
add_child_objects(child, objects, follow_armatures, of_type)
def expand_with_child_objects(objects, follow_armatures=False, of_type=None):
for obj in objects:
if obj.type == "ARMATURE" and not follow_armatures:
continue
add_child_objects(obj, objects, follow_armatures, of_type)
def get_child_objects(obj, include_parent=False, follow_armatures=False, of_type=None):
objects = []
if include_parent:
if not of_type or obj.type == of_type:
objects.append(obj)
add_child_objects(obj, objects, follow_armatures, of_type)
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 delete_actions(actions):
for action in actions:
try:
bpy.data.actions.remove(action)
except: ...
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, render=False):
objects = get_object_tree(obj)
for obj in objects:
try:
obj.hide_set(hide)
if render:
obj.hide_render = hide
except: ...
def show(obj: bpy.types.Object, show=True, render=False):
hide(obj, hide=not show, render=render)
def hide(obj: bpy.types.Object, hide=True, render=False):
try:
obj.hide_set(hide)
if render:
obj.hide_render = 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()
if not context:
context = bpy.context
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 not chr_cache.is_related_object(obj):
if obj.type == "ARMATURE" and obj != arm:
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, include_frames=True):
try:
set_mode("OBJECT")
try_select_objects(store[2], True)
set_active_object(store[1])
set_mode(store[0])
if include_frames:
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
elif type(objects) is bpy.types.Object:
objects = [objects]
for obj in objects:
if object_exists(obj):
visible = obj.visible_get()
render = not obj.hide_render
rv[obj.name] = [visible, render]
return rv
def restore_render_visibility_state(rv):
obj : bpy.types.Object
for obj_name in rv:
if obj_name in bpy.data.objects:
obj = bpy.data.objects[obj_name]
if object_exists(obj):
visible, render = rv[obj.name]
try:
obj.hide_render = not render
hide(obj, not visible)
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_3d_regions(context=None):
spaces = get_view_3d_spaces(context)
if spaces:
return [ s.region_3d for s in spaces ]
return []
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_spaces(context=None) -> bpy.types.Space:
try:
areas = get_view_3d_areas(context)
if areas:
return [ area.spaces.active for area in areas ]
except: ...
log_warn("Unable to get view 3d spaces!")
return []
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_override_context():
for window_manager in bpy.data.window_managers:
for window in window_manager.windows:
for area in window.screen.areas:
if area.type == 'VIEW_3D':
for region in area.regions:
if region.type == 'WINDOW':
return dict(window=window, area=area, region=region)
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 get_view_3d_areas(context=None) -> bpy.types.Area:
areas = []
try:
if not context:
context = bpy.context
for area in context.screen.areas:
if area.type == 'VIEW_3D':
areas.append(area)
except:
areas = []
return areas
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
set_transform_rotation(obj, rot)
def has_data_path(obj: bpy.types.Object, path: str):
try:
prop = obj.path_resolve(path)
return True
except:
return False
def get_data_path_object_name(data_path: str):
if data_path.startswith("pose.bones["):
start = data_path.find('"', 0) + 1
end = data_path.find('"', start)
return data_path[start:end]
elif data_path.startswith("key_blocks["):
start = data_path.find('"', 0) + 1
end = data_path.find('"', start)
return data_path[start:end]
return ""
def copy_action(action: bpy.types.Action, new_name, reuse=False):
if reuse and new_name in bpy.data.actions:
bpy.data.actions.remove(bpy.data.actions[new_name])
new_action = action.copy()
new_action.name = new_name
return new_action
def make_action(name, reuse=False, slot_type=None, target_obj=None, slot_name=None, clear=False):
action = None
if reuse and name in bpy.data.actions:
action = bpy.data.actions[name]
if not action:
action = bpy.data.actions.new(name)
if clear:
clear_action(action)
if B440():
if target_obj:
if not slot_type:
slot_type = get_slot_type_for(target_obj)
if not slot_name:
slot_name = f"SLOT-{slot_type}"
make_action_slot(action, slot_type, slot_name)
return action
def make_action_slot(action, slot_type, slot_name):
if action and B440():
for slot in action.slots:
if slot.target_id_type == slot_type and strip_name(slot.name) == slot_name:
return slot
for slot in action.slots:
if slot.target_id_type == slot_type:
return slot
return action.slots.new(slot_type, slot_name)
return None
def get_action_slot(action, slot_type):
if action and B440():
for slot in action.slots:
if slot.target_id_type == slot_type:
return slot
return None
def find_action_slot(action, slot_type=None, slot_name=None, slot_id=None):
if action and B440():
for slot in action.slots:
if slot_type and slot_id:
if slot.target_id_type == slot_type and slot.identifier == slot_id:
return slot
elif slot_type and slot_name:
if slot.target_id_type == slot_type and slot.name_display == slot_name:
return slot
elif slot_id:
if slot.identifier == slot_id:
return slot
elif slot_name:
if slot.name_display == slot_name:
return slot
elif slot_type:
if slot.target_id_type == slot_type:
return slot
return None
def get_slot_type_for(obj):
T = type(obj)
slot_type = "OBJECT"
if T is bpy.types.Key:
slot_type = "KEY"
if (T is bpy.types.Light or
T is bpy.types.SpotLight or
T is bpy.types.SunLight or
T is bpy.types.AreaLight or
T is bpy.types.PointLight):
slot_type = "LIGHT"
if T is bpy.types.Camera:
slot_type = "CAMERA"
return slot_type
def set_action_slot(obj, action, slot=None):
"""Blender 4.4+ Only:
Set the obj.animation_data.action_slot to the supplied slot or
the first action slot with the matching slot_type"""
if obj and action and B440():
if slot:
try:
obj.animation_data.action_slot = slot
except Exception as e:
log_error(f"Unable to set action slot {action} / {slot}", e)
return True
else:
slot_type = get_slot_type_for(obj)
slot = get_action_slot(action, slot_type)
if slot:
try:
obj.animation_data.action_slot = slot
except:
log_error(f"Unable to set action slot by type: {slot_type} / {action} / {slot}")
return False
return True
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_get_action_slot(obj) -> bpy.types.Action:
if obj:
try:
if obj.animation_data:
if B440():
return obj.animation_data.action, obj.animation_data.action_slot
return obj.animation_data.action, None
except:
log_warn(f"Unable to get action from {obj.name}")
return None, None
def safe_set_action(obj, action, create=True, slot=None):
result = False
if obj:
try:
if create and not obj.animation_data:
obj.animation_data_create()
if obj.animation_data:
obj.animation_data.action = action
set_action_slot(obj, action, slot)
result = True
except Exception as e:
action_name = action.name if action else "None"
log_error(f"Unable to set action {action_name} to {obj.name}", e)
result = False
return result
def clear_action(action):
if action:
try:
if B440():
for layer in action.layers:
for strip in layer.strips:
for channelbag in strip.channelbags:
channelbag.fcurves.clear()
while action.slots:
action.slots.remove(action.slots[0])
else:
action.fcurves.clear()
return True
except:
log_error(f"Unable to clear action: {action}")
return False
def get_action_channelbags_list(action: bpy.types.Action):
channels = []
if action:
if B440():
channelbags = get_action_channelbags(action)
if channelbags:
for channelbag in channelbags:
channels.append(channelbag)
else:
channels.append(action)
return channels
def get_action_channelbags(action: bpy.types.Action):
if action:
if B440():
if not action.layers:
layer = action.layers.new("Layer")
else:
layer = action.layers[0]
if not layer.strips:
strip = layer.strips.new(type='KEYFRAME')
else:
strip = layer.strips[0]
return strip.channelbags
return None
def get_action_groups(action: bpy.types.Action) -> List[bpy.types.ActionGroup]:
groups = []
if B440():
channels = get_action_channelbags_list(action)
for channel in channels:
for group in channel.groups:
groups.append(group)
else:
for group in action.groups:
groups.append(group)
return groups
def get_action_fcurves(action: bpy.types.Action) -> List[bpy.types.FCurve]:
fcurves = []
if B440():
channels = get_action_channelbags_list(action)
for channel in channels:
for fcurve in channel.fcurves:
fcurves.append(fcurve)
else:
for fcurve in action.fcurves:
fcurves.append(fcurve)
return fcurves
def get_action_channelbag(action: bpy.types.Action, slot=None, slot_type=None):
if not action:
return None
if B440() and (slot or slot_type):
if not action.layers:
layer = action.layers.new("Layer")
else:
layer = action.layers[0]
if not layer.strips:
strip = layer.strips.new(type='KEYFRAME')
else:
strip = layer.strips[0]
if slot_type and not slot:
slot = get_action_slot(action, slot_type)
if slot:
channelbag = strip.channelbag(slot, ensure=True)
if channelbag:
return channelbag
if B500():
# actions do not have fcurves in B5
return None
else:
return action
def get_object_action_channelbag(obj):
action, slot = safe_get_action_slot(obj)
channels = get_action_channelbags_list(action)
for channel in channels:
if channel.slot == slot:
return channel
return None
def get_action_targets(obj):
targets = []
if object_exists_is_armature(obj):
targets.append(obj)
elif object_exists_is_mesh(obj):
targets.append(obj.data.shape_keys)
elif object_exists_is_light(obj) or object_exists_is_camera(obj):
targets.append(obj)
targets.append(obj.data)
return targets
def index_in_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 get_active_layer_collection():
return bpy.context.view_layer.active_layer_collection
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 prop_to_list(prop):
L = len(prop)
result = [0]*L
prop.foreach_get(result)
return result
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 B360():
return is_blender_version("3.6.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 B440():
return is_blender_version("4.4.0")
def B500():
return is_blender_version("5.0.0")
VER_CACHE = {}
def is_blender_version(version: str, test = "GTE"):
"""e.g. is_blender_version("3.0.0", "GTE")"""
global VER_CACHE
cid = (version, test)
if cid in VER_CACHE:
return VER_CACHE[cid]
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]
result = False
if test == "GTE" and v_blender >= v_test:
result = True
elif test == "GT" and v_blender > v_test:
result = True
elif test == "LT" and v_blender < v_test:
result = True
elif test == "LTE" and v_blender <= v_test:
result = True
elif test == "EQ" and v_blender == v_test:
result = True
elif test == "NE" and v_blender != v_test:
result = True
VER_CACHE[cid] = result
return result
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, exclude=None):
"""Unlock and reset object shape keys to zero."""
T = type(objects)
if T is not list and T is not tuple:
objects = [objects]
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:
if exclude and key.name in exclude: continue
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_has_shape_key(obj, key_name):
try:
if obj.data.shape_keys and obj.data.shape_keys.key_blocks:
return key_name in obj.data.shape_keys.key_blocks
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=Vector((1,1,1))):
return Matrix.Translation(loc) @ (rot.to_matrix().to_4x4()) @ Matrix.Diagonal(sca).to_4x4()
def set_transform_rotation(obj: bpy.types.Object, rotation: Quaternion):
if obj and rotation:
T = type(rotation)
if T is Euler:
rotation_quaternion = Quaternion(rotation)
elif T is tuple and len(rotation) == 2:
axis, angle = rotation
rotation_quaternion = axis_angle_to_quaternion(axis, angle)
elif T is Quaternion:
rotation_quaternion = rotation.copy()
else:
return
if obj.rotation_mode == "QUATERNION":
obj.rotation_quaternion = rotation_quaternion
elif obj.rotation_mode == "AXIS_ANGLE":
axis_angle = rotation_quaternion.to_axis_angle()
obj.rotation_axis_angle = axis_angle
else:
euler = rotation_quaternion.to_euler(obj.rotation_mode)
obj.rotation_euler = euler
def axis_angle_to_quaternion(axis: Vector, angle: float):
return Matrix.Rotation(angle, 4, axis).to_quaternion()
def get_transform_rotation(obj: bpy.types.Object) -> Quaternion:
if obj:
if obj.rotation_mode == "QUATERNION":
return obj.rotation_quaternion.copy()
elif obj.rotation_mode == "AXIS_ANGLE":
axis = obj.rotation_axis_angle[0:3]
angle = obj.rotation_axis_angle[3]
return axis_angle_to_quaternion(axis, angle)
else:
return obj.rotation_euler.to_quaternion()
return None
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:
set_transform_rotation(ob, rot)
if scale:
ob.scale = scale
bpy.context.scene.collection.objects.link(ob)
def is_n_panel_sub_tabs():
for prefs in bpy.context.preferences.addons.keys():
if "n_panel_sub_tabs" in prefs:
return True
return False
def generate_random_id(length):
CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
id = ""
for i in range(0, length):
id += random.choice(CHARS)
return id
def set_prop(obj, prop_name, value):
try:
obj[prop_name] = value
return True
except:
try:
del(obj[prop_name])
obj[prop_name] = value
return True
except: ...
return False
def get_prop(obj, prop_name, default_value = None):
try:
return obj[prop_name]
except: ...
return default_value
def del_prop(obj, prop_name):
try:
del obj[prop_name]
except: ...
def set_rl_link_id(obj, link_id=None):
if link_id is None:
link_id = generate_random_id(20)
if obj:
set_prop(obj, "rl_link_id", link_id)
return link_id
def get_rl_link_id(obj):
if obj:
if "link_id" in obj:
link_id = obj["link_id"]
del(obj["link_id"])
set_rl_link_id(obj, link_id)
return link_id
elif "rl_link_id" in obj:
return obj["rl_link_id"]
return None
def set_rl_object_id(obj, new_id=None):
if new_id is None:
new_id = generate_random_id(20)
if obj:
if obj.type == "ARMATURE":
set_prop(obj, "rl_armature_id", new_id)
if "rl_object_id" in obj:
del(obj["rl_object_id"])
else:
set_prop(obj, "rl_object_id", new_id)
return new_id
def get_rl_object_id(obj):
if object_exists(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 merge(a: list, b: list):
c = a.copy()
for i in b:
if i not in c:
c.append(i)
return c
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 timestampns():
return str(time.time_ns())
def datetimes():
return time.strftime("%Y%m%d%H%M%S")
def json_dumps(json_data, file_path=None, indent=4):
if file_path:
with open(file_path, "w") as f:
f.write(json.dumps(json_data, indent=indent))
else:
print(json.dumps(json_data, indent=indent))
def open_folder(folder_path):
os.startfile(folder_path)
def get_enum_prop_name(obj, prop_name, enum_value=None):
try:
prop = type(obj).bl_rna.properties[prop_name]
if enum_value is None:
enum_value = getattr(obj, prop_name)
return prop.enum_items[enum_value].name
except:
return prop_name
def largest_index(items: list, use_abs=False):
index = 0
largest_value = 0
for i, value in enumerate(items):
if use_abs:
if abs(value) > largest_value:
largest_value = abs(value)
index = i
else:
if value > largest_value:
largest_value = value
index = i
return index
def smallest_index(items: list):
index = 0
smallest_value = 0
for i, value in enumerate(items):
if value < smallest_value:
smallest_value = value
index = i
return index
def safe_free_bake(point_cache):
if B320():
with bpy.context.temp_override(point_cache=point_cache):
bpy.ops.ptcache.free_bake()
else:
context_override = bpy.context.copy()
context_override["point_cache"] = point_cache
bpy.ops.ptcache.free_bake(context_override)
Reference in New Issue View Git Blame Copy Permalink