Yusarina
9961223548
Added the Armature Validation modes now, we have Stritct, Basic and None, it will give a warning to the user in the panel if there have it set to basic or none. Settings panel added, langauge change has been added back. Did some work on it to slightl improve the system. Added dubug area, basically everything but autoload will use logging now, you be able to turn it on/off in debug settings. Did other bits and bobs.
194 lines
6.9 KiB
Python
194 lines
6.9 KiB
Python
import os
|
|
import bpy
|
|
import sys
|
|
import typing
|
|
import inspect
|
|
import pkgutil
|
|
import tomllib
|
|
import importlib
|
|
from pathlib import Path
|
|
from typing import List, Dict, Set, Optional, Any, Type, Tuple, Generator, TypeVar
|
|
|
|
__all__ = (
|
|
"init",
|
|
"register",
|
|
"unregister",
|
|
)
|
|
|
|
T = TypeVar('T')
|
|
modules: Optional[List[Any]] = None
|
|
ordered_classes: Optional[List[Type]] = None
|
|
|
|
def init() -> None:
|
|
"""Initialize the auto-loader by discovering modules and classes"""
|
|
global modules
|
|
global ordered_classes
|
|
|
|
# Configure logging first
|
|
from .logging_setup import configure_logging
|
|
configure_logging(False)
|
|
|
|
from .addon_preferences import get_preference
|
|
configure_logging(get_preference("enable_logging", False))
|
|
|
|
print("Auto-load init starting")
|
|
modules = get_all_submodules(Path(__file__).parent.parent)
|
|
ordered_classes = get_ordered_classes_to_register(modules)
|
|
print(f"Found modules: {modules}")
|
|
print(f"Found classes: {ordered_classes}")
|
|
|
|
def register() -> None:
|
|
"""Register all discovered classes and modules"""
|
|
print("Registering classes")
|
|
for cls in ordered_classes:
|
|
print(f"Registering: {cls}")
|
|
try:
|
|
bpy.utils.register_class(cls)
|
|
except ValueError:
|
|
continue
|
|
|
|
for module in modules:
|
|
if module.__name__ == __name__:
|
|
continue
|
|
if hasattr(module, "register"):
|
|
module.register()
|
|
|
|
def unregister() -> None:
|
|
"""Unregister all classes and modules in reverse order"""
|
|
for cls in reversed(ordered_classes):
|
|
bpy.utils.unregister_class(cls)
|
|
|
|
for module in modules:
|
|
if module.__name__ == __name__:
|
|
continue
|
|
if hasattr(module, "unregister"):
|
|
module.unregister()
|
|
|
|
def get_manifest_id() -> str:
|
|
"""Get the addon ID from the manifest file"""
|
|
manifest_path = Path(__file__).parent.parent / "blender_manifest.toml"
|
|
with open(manifest_path, "rb") as f:
|
|
manifest = tomllib.load(f)
|
|
return manifest["id"]
|
|
|
|
def get_all_submodules(directory: Path) -> List[Any]:
|
|
"""Discover and import all submodules in the given directory"""
|
|
modules = []
|
|
addon_id = get_manifest_id()
|
|
for root, dirs, files in os.walk(directory):
|
|
if "__pycache__" in root:
|
|
continue
|
|
path = Path(root)
|
|
if path == directory:
|
|
package_name = f"bl_ext.user_default.{addon_id}"
|
|
else:
|
|
relative_path = path.relative_to(directory).as_posix().replace('/', '.')
|
|
package_name = f"bl_ext.user_default.{addon_id}.{relative_path}"
|
|
for name in sorted(iter_module_names(path)):
|
|
modules.append(importlib.import_module(f".{name}", package_name))
|
|
return modules
|
|
|
|
def iter_submodules(path: Path, package_name: str) -> Generator[Any, None, None]:
|
|
"""Iterate through submodules in a package"""
|
|
for name in sorted(iter_module_names(path)):
|
|
yield importlib.import_module("." + name, package_name)
|
|
|
|
def iter_module_names(path: Path) -> Generator[str, None, None]:
|
|
"""Iterate through module names in a directory"""
|
|
print(f"Scanning path: {path}")
|
|
modules_list = list(pkgutil.iter_modules([str(path)]))
|
|
print(f"Found these modules: {modules_list}")
|
|
for _, module_name, is_pkg in modules_list:
|
|
if not is_pkg:
|
|
print(f"Found module: {module_name}")
|
|
yield module_name
|
|
|
|
def get_ordered_classes_to_register(modules: List[Any]) -> List[Type]:
|
|
"""Get a topologically sorted list of classes to register"""
|
|
return toposort(get_register_deps_dict(modules))
|
|
|
|
def get_register_deps_dict(modules: List[Any]) -> Dict[Type, Set[Type]]:
|
|
"""Get dependencies dictionary for class registration"""
|
|
deps_dict = {}
|
|
classes_to_register = set(iter_classes_to_register(modules))
|
|
for cls in classes_to_register:
|
|
deps_dict[cls] = set(iter_own_register_deps(cls, classes_to_register))
|
|
return deps_dict
|
|
|
|
def iter_own_register_deps(cls: Type, classes_to_register: Set[Type]) -> Generator[Type, None, None]:
|
|
"""Iterate through a class's own registration dependencies"""
|
|
yield from (dep for dep in iter_register_deps(cls) if dep in classes_to_register)
|
|
|
|
def iter_register_deps(cls: Type) -> Generator[Type, None, None]:
|
|
"""Iterate through all registration dependencies of a class"""
|
|
for value in typing.get_type_hints(cls, {}, {}).values():
|
|
dependency = get_dependency_from_annotation(value)
|
|
if dependency is not None:
|
|
yield dependency
|
|
|
|
def get_dependency_from_annotation(value: Any) -> Optional[Type]:
|
|
"""Get dependency type from a type annotation"""
|
|
if isinstance(value, tuple) and len(value) == 2:
|
|
if value[0] in (bpy.props.PointerProperty, bpy.props.CollectionProperty):
|
|
return value[1]["type"]
|
|
return None
|
|
|
|
def iter_classes_to_register(modules: List[Any]) -> Generator[Type, None, None]:
|
|
"""Iterate through classes that need to be registered"""
|
|
base_types = get_register_base_types()
|
|
for cls in get_classes_in_modules(modules):
|
|
if any(base in base_types for base in cls.__bases__):
|
|
if not getattr(cls, "_is_registered", False):
|
|
yield cls
|
|
|
|
def get_classes_in_modules(modules: List[Any]) -> Set[Type]:
|
|
"""Get all classes defined in the modules"""
|
|
classes = set()
|
|
for module in modules:
|
|
for cls in iter_classes_in_module(module):
|
|
classes.add(cls)
|
|
return classes
|
|
|
|
def iter_classes_in_module(module: Any) -> Generator[Type, None, None]:
|
|
"""Iterate through classes defined in a module"""
|
|
for value in module.__dict__.values():
|
|
if inspect.isclass(value):
|
|
yield value
|
|
|
|
def get_register_base_types() -> Set[Type]:
|
|
"""Get set of base types that need registration"""
|
|
return set(getattr(bpy.types, name) for name in [
|
|
"Panel", "Operator", "PropertyGroup",
|
|
"AddonPreferences", "Header", "Menu",
|
|
"Node", "NodeSocket", "NodeTree",
|
|
"UIList", "RenderEngine"
|
|
])
|
|
|
|
def toposort(deps_dict: Dict[Type, Set[Type]]) -> List[Type]:
|
|
"""Topologically sort classes based on their dependencies"""
|
|
sorted_list = []
|
|
sorted_values = set()
|
|
|
|
panels_to_sort = [(value, deps) for value, deps in deps_dict.items()
|
|
if hasattr(value, 'bl_parent_id')]
|
|
|
|
base_panels = [(value, deps) for value, deps in deps_dict.items()
|
|
if not hasattr(value, 'bl_parent_id')]
|
|
|
|
for value, deps in base_panels:
|
|
if len(deps) == 0:
|
|
sorted_list.append(value)
|
|
sorted_values.add(value)
|
|
|
|
while len(deps_dict) > len(sorted_values):
|
|
unsorted = []
|
|
for value, deps in deps_dict.items():
|
|
if value not in sorted_values:
|
|
if len(deps - sorted_values) == 0:
|
|
sorted_list.append(value)
|
|
sorted_values.add(value)
|
|
else:
|
|
unsorted.append(value)
|
|
|
|
return sorted_list
|