830 lines
25 KiB
Python
830 lines
25 KiB
Python
import bpy
|
|
import os
|
|
from os.path import abspath, join
|
|
|
|
from bpy.types import AddonPreferences, PointerProperty, PropertyGroup
|
|
from bpy.props import (
|
|
BoolProperty,
|
|
StringProperty,
|
|
CollectionProperty,
|
|
EnumProperty,
|
|
IntProperty,
|
|
)
|
|
|
|
from asset_library.constants import (
|
|
DATA_TYPES,
|
|
DATA_TYPE_ITEMS,
|
|
ICONS,
|
|
RESOURCES_DIR,
|
|
LIBRARY_TYPE_DIR,
|
|
LIBRARY_TYPES,
|
|
ADAPTERS,
|
|
)
|
|
|
|
from asset_library.common.file_utils import import_module_from_path, norm_str
|
|
from asset_library.common.bl_utils import get_addon_prefs
|
|
from asset_library.common.library_cache import LibraryCache
|
|
from asset_library.common.catalog import Catalog
|
|
|
|
# from asset_library.common.functions import get_catalog_path
|
|
|
|
from pathlib import Path
|
|
import importlib
|
|
import inspect
|
|
|
|
|
|
def update_library_config(self, context):
|
|
print("update_library_config not yet implemented")
|
|
|
|
|
|
def update_library_path(self, context):
|
|
prefs = get_addon_prefs()
|
|
|
|
self["bundle_directory"] = str(self.library_path)
|
|
|
|
if not self.custom_bundle_name:
|
|
self["custom_bundle_name"] = self.name
|
|
|
|
if not self.custom_bundle_directory:
|
|
custom_bundle_dir = Path(prefs.bundle_directory, self.library_name).resolve()
|
|
self["custom_bundle_directory"] = str(custom_bundle_dir)
|
|
|
|
# if self.custom_bundle_directory:
|
|
# self['custom_bundle_directory'] = abspath(bpy.path.abspath(self.custom_bundle_directory))
|
|
# else:
|
|
# bundle_directory = join(prefs.bundle_directory, norm_str(self.name))
|
|
# self['custom_bundle_directory'] = abspath(bundle_directory)
|
|
|
|
self.set_library_path()
|
|
|
|
|
|
def update_all_library_path(self, context):
|
|
# print('update_all_assetlib_paths')
|
|
|
|
prefs = get_addon_prefs()
|
|
|
|
# if self.custom_bundle_directory:
|
|
# self['custom_bundle_directory'] = abspath(bpy.path.abspath(self.custom_bundle_directory))
|
|
|
|
for lib in prefs.libraries:
|
|
update_library_path(lib, context)
|
|
# lib.set_library_path()
|
|
|
|
|
|
def get_library_type_items(self, context):
|
|
# prefs = get_addon_prefs()
|
|
|
|
items = [("NONE", "None", "", 0)]
|
|
items += [
|
|
(norm_str(a.name, format=str.upper), a.name, "", i + 1)
|
|
for i, a in enumerate(LIBRARY_TYPES)
|
|
]
|
|
return items
|
|
|
|
|
|
def get_adapters_items(self, context):
|
|
# prefs = get_addon_prefs()
|
|
|
|
items = [("NONE", "None", "", 0)]
|
|
items += [
|
|
(norm_str(a.name, format=str.upper), a.name, "", i + 1)
|
|
for i, a in enumerate(ADAPTERS)
|
|
]
|
|
return items
|
|
|
|
|
|
def get_library_items(self, context):
|
|
prefs = get_addon_prefs()
|
|
|
|
items = [("NONE", "None", "", 0)]
|
|
items += [
|
|
(l.name, l.name, "", i + 1) for i, l in enumerate(prefs.libraries) if l != self
|
|
]
|
|
|
|
return items
|
|
|
|
|
|
def get_store_library_items(self, context):
|
|
# prefs = get_addon_prefs()
|
|
|
|
# libraries = [l for l in prefs.libraries if l.merge_library == self.name]
|
|
|
|
return [
|
|
(l.name, l.name, "", i) for i, l in enumerate([self] + self.merge_libraries)
|
|
]
|
|
|
|
|
|
class LibraryTypes(PropertyGroup):
|
|
def __iter__(self):
|
|
return (
|
|
getattr(self, p)
|
|
for p in self.bl_rna.properties.keys()
|
|
if p not in ("rna_type", "name")
|
|
)
|
|
|
|
|
|
class Adapters(PropertyGroup):
|
|
def __iter__(self):
|
|
return (
|
|
getattr(self, p)
|
|
for p in self.bl_rna.properties.keys()
|
|
if p not in ("rna_type", "name")
|
|
)
|
|
|
|
|
|
class AssetLibrary(PropertyGroup):
|
|
name: StringProperty(
|
|
name="Name", default="Action Library", update=update_library_path
|
|
)
|
|
id: StringProperty()
|
|
auto_bundle: BoolProperty(name="Auto Bundle", default=False)
|
|
expand: BoolProperty(name="Expand", default=False)
|
|
use: BoolProperty(name="Use", default=True, update=update_library_path)
|
|
data_type: EnumProperty(name="Type", items=DATA_TYPE_ITEMS, default="COLLECTION")
|
|
|
|
# template_image : StringProperty(default='', description='../{name}_image.png')
|
|
# template_video : StringProperty(default='', description='../{name}_video.mov')
|
|
# template_info : StringProperty(default='', description='../{name}_asset_info.json')
|
|
|
|
bundle_directory: StringProperty(
|
|
name="Bundle Directory", subtype="DIR_PATH", default=""
|
|
)
|
|
|
|
use_custom_bundle_directory: BoolProperty(default=False, update=update_library_path)
|
|
custom_bundle_directory: StringProperty(
|
|
name="Bundle Directory",
|
|
subtype="DIR_PATH",
|
|
default="",
|
|
update=update_library_path,
|
|
)
|
|
# use_merge : BoolProperty(default=False, update=update_library_path)
|
|
|
|
use_custom_bundle_name: BoolProperty(default=False, update=update_library_path)
|
|
custom_bundle_name: StringProperty(name="Merge Name", update=update_library_path)
|
|
# merge_library : EnumProperty(name='Merge Library', items=get_library_items, update=update_library_path)
|
|
# merge_name : StringProperty(name='Merge Name', update=update_library_path)
|
|
|
|
# Library when adding an asset to the library if merge with another
|
|
store_library: EnumProperty(items=get_store_library_items, name="Library")
|
|
|
|
template: StringProperty()
|
|
expand_extra: BoolProperty(name="Expand", default=False)
|
|
blend_depth: IntProperty(name="Blend Depth", default=1)
|
|
|
|
# source_directory : StringProperty(
|
|
# name="Path",
|
|
# subtype='DIR_PATH',
|
|
# default='',
|
|
# update=update_library_path
|
|
# )
|
|
|
|
# library_type : EnumProperty(items=library_type_ITEMS)
|
|
library_types: bpy.props.PointerProperty(type=LibraryTypes)
|
|
library_type_name: EnumProperty(items=get_library_type_items)
|
|
|
|
adapters: bpy.props.PointerProperty(type=Adapters)
|
|
adapter_name: EnumProperty(items=get_adapters_items)
|
|
|
|
parent_name: StringProperty()
|
|
|
|
# data_file_path : StringProperty(
|
|
# name="Path",
|
|
# subtype='FILE_PATH',
|
|
# default='',
|
|
# )
|
|
|
|
# def __init__(self):
|
|
# self.library_types.parent = self
|
|
|
|
@property
|
|
def parent(self):
|
|
prefs = get_addon_prefs()
|
|
if self.parent_name:
|
|
return prefs.libraries[self.parent_name]
|
|
|
|
@property
|
|
def merge_libraries(self):
|
|
prefs = get_addon_prefs()
|
|
return [
|
|
l
|
|
for l in prefs.libraries
|
|
if l != self and (l.library_path == self.library_path)
|
|
]
|
|
|
|
@property
|
|
def child_libraries(self):
|
|
prefs = get_addon_prefs()
|
|
return [l for l in prefs.libraries if l != self and (l.parent == self)]
|
|
|
|
@property
|
|
def data_types(self):
|
|
data_type = self.data_type
|
|
if data_type == "FILE":
|
|
data_type = "COLLECTION"
|
|
return f"{data_type.lower()}s"
|
|
|
|
@property
|
|
def library_type(self):
|
|
name = norm_str(self.library_type_name)
|
|
if not hasattr(self.library_types, name):
|
|
return
|
|
|
|
return getattr(self.library_types, name)
|
|
|
|
@property
|
|
def adapter(self):
|
|
name = norm_str(self.adapter_name)
|
|
if not hasattr(self.adapters, name):
|
|
return
|
|
|
|
return getattr(self.adapters, name)
|
|
|
|
@property
|
|
def library(self):
|
|
prefs = get_addon_prefs()
|
|
asset_lib_ref = bpy.context.space_data.params.asset_library_ref
|
|
|
|
# TODO work also outside asset_library_area
|
|
if asset_lib_ref not in prefs.libraries:
|
|
return None
|
|
|
|
return prefs.libraries[asset_lib_ref]
|
|
|
|
@property
|
|
def library_path(self):
|
|
prefs = get_addon_prefs()
|
|
|
|
library_name = self.library_name
|
|
# if not self.use_custom_bundle_name:
|
|
# library_name = norm_str(library_name)
|
|
|
|
if self.use_custom_bundle_directory:
|
|
return Path(self.custom_bundle_directory).resolve()
|
|
else:
|
|
library_name = norm_str(library_name)
|
|
return Path(prefs.bundle_directory, library_name).resolve()
|
|
|
|
@property
|
|
def bundle_dir(self):
|
|
return self.library_path.as_posix()
|
|
|
|
@property
|
|
def library_name(self):
|
|
if self.use_custom_bundle_name:
|
|
return self.custom_bundle_name
|
|
|
|
return self.name
|
|
|
|
def read_catalog(self):
|
|
return Catalog(self.library_path).read()
|
|
|
|
def read_cache(self, filepath=None):
|
|
if filepath:
|
|
return LibraryCache(filepath).read()
|
|
|
|
return LibraryCache.from_library(self).read()
|
|
|
|
def clear_library_path(self):
|
|
# print('Clear Library Path', self.name)
|
|
|
|
prefs = bpy.context.preferences
|
|
libs = prefs.filepaths.asset_libraries
|
|
|
|
# path = self.library_path.as_posix()
|
|
|
|
for l in reversed(libs):
|
|
# lib_path = Path(l.path).resolve().as_posix()
|
|
|
|
prev_name = self.get("asset_library") or self.library_name
|
|
|
|
# print(l.name, prev_name)
|
|
|
|
if l.name == prev_name:
|
|
index = list(libs).index(l)
|
|
try:
|
|
bpy.ops.preferences.asset_library_remove(index=index)
|
|
return
|
|
except AttributeError:
|
|
pass
|
|
|
|
# print('No library removed')
|
|
|
|
def set_dict(self, data, obj=None):
|
|
""" "Recursive method to set all attribute from a dict to this instance"""
|
|
|
|
if obj is None:
|
|
obj = self
|
|
|
|
# Make shure the input dict is not modidied
|
|
data = data.copy()
|
|
|
|
# print(obj)
|
|
|
|
for key, value in data.items():
|
|
if isinstance(value, dict):
|
|
|
|
if "name" in value:
|
|
setattr(obj, f"{key}_name", value.pop("name"))
|
|
|
|
# print('Nested value', getattr(obj, key))
|
|
self.set_dict(value, obj=getattr(obj, key))
|
|
|
|
elif key in obj.bl_rna.properties.keys():
|
|
if key == "id":
|
|
value = str(value)
|
|
|
|
elif key == "custom_bundle_name":
|
|
if not "use_custom_bundle_name" in data.values():
|
|
obj["use_custom_bundle_name"] = True
|
|
|
|
elif isinstance(value, str):
|
|
value = os.path.expandvars(value)
|
|
value = os.path.expanduser(value)
|
|
|
|
# print('set attr', key, value)
|
|
setattr(obj, key, value)
|
|
# obj[key] = value
|
|
|
|
else:
|
|
print(f"Prop {key} of {obj} not exist")
|
|
|
|
self["bundle_directory"] = str(self.library_path)
|
|
|
|
if not self.custom_bundle_name:
|
|
self["custom_bundle_name"] = self.name
|
|
|
|
# self.library_type_name = data['library_type']
|
|
# if not self.library_type:
|
|
# print(f"No library_type named {data['library_type']}")
|
|
# return
|
|
|
|
# for key, value in data.items():
|
|
# if key == 'options':
|
|
# for k, v in data['options'].items():
|
|
# setattr(self.library_type, k, v)
|
|
# elif key in self.bl_rna.properties.keys():
|
|
# if key == 'id':
|
|
# value = str(value)
|
|
|
|
# if key == 'custom_bundle_name':
|
|
# if not 'use_custom_bundle_name' in data.values():
|
|
# self["use_custom_bundle_name"] = True
|
|
|
|
# self[key] = value
|
|
|
|
def to_dict(self):
|
|
data = {
|
|
p: getattr(self, p)
|
|
for p in self.bl_rna.properties.keys()
|
|
if p != "rna_type"
|
|
}
|
|
|
|
if self.library_type:
|
|
data["library_type"] = self.library_type.to_dict()
|
|
data["library_type"]["name"] = data.pop("library_type_name")
|
|
del data["library_types"]
|
|
|
|
if self.adapter:
|
|
data["adapter"] = self.adapter.to_dict()
|
|
data["adapter"]["name"] = data.pop("adapter_name")
|
|
del data["adapters"]
|
|
|
|
return data
|
|
|
|
def set_library_path(self):
|
|
"""Update the Blender Preference Filepaths tab with the addon libraries"""
|
|
|
|
prefs = bpy.context.preferences
|
|
name = self.library_name
|
|
lib_path = self.library_path
|
|
|
|
self.clear_library_path()
|
|
|
|
if not self.use or not lib_path:
|
|
# if all(not l.use for l in self.merge_libraries):
|
|
# self.clear_library_path()
|
|
return
|
|
|
|
# lib = None
|
|
# if self.get('asset_library'):
|
|
# #print('old_name', self['asset_library'])
|
|
# lib = prefs.filepaths.asset_libraries.get(self['asset_library'])
|
|
|
|
# if not lib:
|
|
# #print('keys', prefs.filepaths.asset_libraries.keys())
|
|
# #print('name', name)
|
|
# #print(prefs.filepaths.asset_libraries.get(name))
|
|
# lib = prefs.filepaths.asset_libraries.get(name)
|
|
|
|
# Create the Asset Library Path
|
|
lib = prefs.filepaths.asset_libraries.get(name)
|
|
if not lib:
|
|
# print(f'Creating the lib {name}')
|
|
try:
|
|
bpy.ops.preferences.asset_library_add(directory=str(lib_path))
|
|
except AttributeError:
|
|
return
|
|
|
|
lib = prefs.filepaths.asset_libraries[-1]
|
|
|
|
lib.name = name
|
|
|
|
self["asset_library"] = name
|
|
lib.path = str(lib_path)
|
|
|
|
@property
|
|
def is_user(self):
|
|
prefs = get_addon_prefs()
|
|
return self in prefs.user_libraries.values()
|
|
|
|
@property
|
|
def is_env(self):
|
|
prefs = get_addon_prefs()
|
|
return self in prefs.env_libraries.values()
|
|
|
|
def add_row(
|
|
self, layout, data=None, prop=None, label="", boolean=None, factor=0.39
|
|
):
|
|
"""Act like the use_property_split but with more control"""
|
|
|
|
enabled = True
|
|
split = layout.split(factor=factor, align=True)
|
|
|
|
row = split.row(align=False)
|
|
row.use_property_split = False
|
|
row.alignment = "RIGHT"
|
|
row.label(text=str(label))
|
|
if boolean:
|
|
boolean_data = self
|
|
if isinstance(boolean, (list, tuple)):
|
|
boolean_data, boolean = boolean
|
|
|
|
row.prop(boolean_data, boolean, text="")
|
|
enabled = getattr(boolean_data, boolean)
|
|
|
|
row = split.row(align=True)
|
|
row.enabled = enabled
|
|
|
|
if isinstance(data, str):
|
|
row.label(text=data)
|
|
else:
|
|
row.prop(data or self, prop, text="")
|
|
|
|
return split
|
|
|
|
def draw_operators(self, layout):
|
|
row = layout.row(align=True)
|
|
row.alignment = "RIGHT"
|
|
row.prop(self, "library_type_name", text="")
|
|
row.prop(self, "auto_bundle", text="", icon="UV_SYNC_SELECT")
|
|
|
|
row.operator("assetlib.diff", text="", icon="FILE_REFRESH").name = self.name
|
|
|
|
op = row.operator("assetlib.bundle", icon="MOD_BUILD", text="")
|
|
op.name = self.name
|
|
|
|
layout.separator(factor=3)
|
|
|
|
def draw(self, layout):
|
|
prefs = get_addon_prefs()
|
|
# box = layout.box()
|
|
|
|
row = layout.row(align=True)
|
|
# row.use_property_split = False
|
|
|
|
# row.alignment = 'LEFT'
|
|
icon = "DISCLOSURE_TRI_DOWN" if self.expand else "DISCLOSURE_TRI_RIGHT"
|
|
row.prop(self, "expand", icon=icon, emboss=False, text="")
|
|
|
|
if self.is_user:
|
|
row.prop(self, "use", text="")
|
|
row.prop(self, "data_type", icon_only=True, emboss=False)
|
|
row.prop(self, "name", text="")
|
|
|
|
self.draw_operators(row)
|
|
|
|
index = list(prefs.user_libraries).index(self)
|
|
row.operator(
|
|
"assetlib.remove_user_library", icon="X", text="", emboss=False
|
|
).index = index
|
|
|
|
else:
|
|
row.prop(self, "use", text="")
|
|
row.label(icon=ICONS[self.data_type])
|
|
# row.label(text=self.name)
|
|
subrow = row.row(align=True)
|
|
subrow.alignment = "LEFT"
|
|
subrow.prop(self, "expand", emboss=False, text=self.name)
|
|
# row.separator_spacer()
|
|
|
|
self.draw_operators(row)
|
|
|
|
sub_row = row.row()
|
|
sub_row.enabled = False
|
|
sub_row.label(icon="FAKE_USER_ON")
|
|
|
|
if self.expand:
|
|
col = layout.column(align=False)
|
|
col.use_property_split = True
|
|
# row = col.row(align=True)
|
|
|
|
row = self.add_row(
|
|
col,
|
|
prop="custom_bundle_name",
|
|
boolean="use_custom_bundle_name",
|
|
label="Custom Bundle Name",
|
|
)
|
|
|
|
row.enabled = not self.use_custom_bundle_directory
|
|
|
|
prop = "bundle_directory"
|
|
if self.use_custom_bundle_directory:
|
|
prop = "custom_bundle_directory"
|
|
|
|
self.add_row(
|
|
col,
|
|
prop=prop,
|
|
boolean="use_custom_bundle_directory",
|
|
label="Custom Bundle Directory",
|
|
)
|
|
|
|
col.prop(self, "blend_depth")
|
|
|
|
# subcol = col.column(align=True)
|
|
# subcol.prop(self, "template_info", text='Template Info', icon='COPY_ID')
|
|
# subcol.prop(self, "template_image", text='Template Image', icon='COPY_ID')
|
|
# subcol.prop(self, "template_video", text='Template Video', icon='COPY_ID')
|
|
|
|
if self.library_type:
|
|
col.separator()
|
|
self.library_type.draw_prefs(col)
|
|
|
|
for lib in self.child_libraries:
|
|
lib.draw(layout)
|
|
|
|
col.separator()
|
|
|
|
|
|
class Collections:
|
|
"""Util Class to merge multiple collections"""
|
|
|
|
collections = []
|
|
|
|
def __init__(self, *collection):
|
|
self.collections = collection
|
|
|
|
for col in collection:
|
|
# print('Merge methods')
|
|
for attr in dir(col):
|
|
if attr.startswith("_"):
|
|
continue
|
|
|
|
value = getattr(col, attr)
|
|
# if not callable(value):
|
|
# continue
|
|
|
|
setattr(self, attr, value)
|
|
|
|
def __contains__(self, item):
|
|
if isinstance(item, str):
|
|
return item in self.to_dict()
|
|
else:
|
|
return item in self
|
|
|
|
def __iter__(self):
|
|
return self.to_list().__iter__()
|
|
|
|
def __getitem__(self, item):
|
|
if isinstance(item, int):
|
|
return self.to_list()[item]
|
|
else:
|
|
return self.to_dict()[item]
|
|
|
|
def get(self, item, fallback=None):
|
|
return self.to_dict().get(item) or fallback
|
|
|
|
def to_dict(self):
|
|
return {k: v for c in self.collections for k, v in c.items()}
|
|
|
|
def to_list(self):
|
|
return [v for c in self.collections for v in c.values()]
|
|
|
|
def get_parent(self, item):
|
|
for c in self.collections:
|
|
if item in c.values():
|
|
return c
|
|
|
|
def index(self, item):
|
|
c = self.get_parent(item)
|
|
|
|
if not c:
|
|
return item in self
|
|
|
|
return list(c.values()).index(item)
|
|
|
|
|
|
# class AssetLibraryOptions(PropertyGroup):
|
|
# pass
|
|
|
|
|
|
class AssetLibraryPrefs(AddonPreferences):
|
|
bl_idname = __package__
|
|
|
|
adapters = []
|
|
library_types = []
|
|
previews = bpy.utils.previews.new()
|
|
preview_modal = False
|
|
add_asset_dict = {}
|
|
|
|
# action : bpy.props.PointerProperty(type=AssetLibraryPath)
|
|
# asset : bpy.props.PointerProperty(type=AssetLibraryPath)
|
|
# library_types = {}
|
|
author: StringProperty(default=os.getlogin())
|
|
|
|
image_player: StringProperty(default="")
|
|
video_player: StringProperty(default="")
|
|
|
|
library_type_directory: StringProperty(
|
|
name="Library Type Directory", subtype="DIR_PATH"
|
|
)
|
|
adapter_directory: StringProperty(name="Adapter Directory", subtype="DIR_PATH")
|
|
|
|
env_libraries: CollectionProperty(type=AssetLibrary)
|
|
user_libraries: CollectionProperty(type=AssetLibrary)
|
|
expand_settings: BoolProperty(default=False)
|
|
bundle_directory: StringProperty(
|
|
name="Path", subtype="DIR_PATH", default="", update=update_all_library_path
|
|
)
|
|
|
|
config_directory: StringProperty(
|
|
name="Config Path",
|
|
subtype="FILE_PATH",
|
|
default=str(RESOURCES_DIR / "asset_library_config.json"),
|
|
update=update_library_config,
|
|
)
|
|
|
|
def load_library_types(self):
|
|
from asset_library.library_types.library_type import LibraryType
|
|
|
|
print("Asset Library: Load Library Types")
|
|
|
|
LIBRARY_TYPES.clear()
|
|
|
|
library_type_files = list(LIBRARY_TYPE_DIR.glob("*.py"))
|
|
if self.library_type_directory:
|
|
user_LIBRARY_TYPE_DIR = Path(self.library_type_directory)
|
|
if user_LIBRARY_TYPE_DIR.exists():
|
|
library_type_files += list(user_LIBRARY_TYPE_DIR.glob("*.py"))
|
|
|
|
for library_type_file in library_type_files:
|
|
if library_type_file.stem.startswith("_"):
|
|
continue
|
|
|
|
mod = import_module_from_path(library_type_file)
|
|
|
|
# print(library_type_file)
|
|
for name, obj in inspect.getmembers(mod):
|
|
|
|
if not inspect.isclass(obj):
|
|
continue
|
|
|
|
# print(obj.__bases__)
|
|
if not LibraryType in obj.__mro__:
|
|
continue
|
|
|
|
# Non registering base library_type
|
|
if obj is LibraryType or obj.name in (a.name for a in LIBRARY_TYPES):
|
|
continue
|
|
|
|
try:
|
|
print(f"Register Plugin {name}")
|
|
bpy.utils.register_class(obj)
|
|
setattr(
|
|
LibraryTypes,
|
|
norm_str(obj.name),
|
|
bpy.props.PointerProperty(type=obj),
|
|
)
|
|
LIBRARY_TYPES.append(obj)
|
|
|
|
except Exception as e:
|
|
print(f"Could not register library_type {name}")
|
|
print(e)
|
|
|
|
def load_adapters(self):
|
|
return
|
|
|
|
@property
|
|
def libraries(self):
|
|
return Collections(self.env_libraries, self.user_libraries)
|
|
|
|
def draw(self, context):
|
|
prefs = get_addon_prefs()
|
|
|
|
layout = self.layout
|
|
# layout.use_property_split = True
|
|
|
|
main_col = layout.column(align=False)
|
|
|
|
box = main_col.box()
|
|
row = box.row(align=True)
|
|
icon = "DISCLOSURE_TRI_DOWN" if self.expand_settings else "DISCLOSURE_TRI_RIGHT"
|
|
row.prop(self, "expand_settings", icon=icon, emboss=False, text="")
|
|
row.label(icon="PREFERENCES")
|
|
row.label(text="Settings")
|
|
# row.separator_spacer()
|
|
subrow = row.row()
|
|
subrow.alignment = "RIGHT"
|
|
subrow.operator("assetlib.reload_addon", text="Reload Addon")
|
|
|
|
if prefs.expand_settings:
|
|
col = box.column(align=True)
|
|
col.use_property_split = True
|
|
|
|
# col.prop(self, 'use_single_path', text='Single Path')
|
|
col.prop(self, "bundle_directory", text="Bundle Directory")
|
|
|
|
col.separator()
|
|
|
|
col.prop(self, "library_type_directory")
|
|
col.prop(self, "config_directory")
|
|
|
|
col.separator()
|
|
|
|
# col.prop(self, 'template_info', text='Asset Description Template', icon='COPY_ID')
|
|
|
|
# col.separator()
|
|
|
|
# col.prop(self, 'template_image', text='Template Image', icon='COPY_ID')
|
|
col.prop(
|
|
self, "image_player", text="Image Player"
|
|
) # icon='OUTLINER_OB_IMAGE'
|
|
|
|
# col.separator()
|
|
|
|
# col.prop(self, 'template_video', text='Template Video', icon='COPY_ID')
|
|
col.prop(self, "video_player", text="Video Player") # icon='FILE_MOVIE'
|
|
|
|
col.separator()
|
|
|
|
col.operator(
|
|
"assetlib.add_user_library",
|
|
text="Bundle All Libraries",
|
|
icon="MOD_BUILD",
|
|
)
|
|
|
|
for (
|
|
lib
|
|
) in self.libraries: # list(self.env_libraries) + list(self.user_libraries):
|
|
if lib.parent:
|
|
continue
|
|
|
|
box = main_col.box()
|
|
lib.draw(box)
|
|
|
|
row = main_col.row()
|
|
row.alignment = "RIGHT"
|
|
row.operator("assetlib.add_user_library", icon="ADD", text="", emboss=False)
|
|
|
|
|
|
classes = [
|
|
LibraryTypes,
|
|
Adapters,
|
|
# ConformAssetLibrary,
|
|
AssetLibrary,
|
|
AssetLibraryPrefs,
|
|
]
|
|
|
|
|
|
def register():
|
|
for cls in classes:
|
|
bpy.utils.register_class(cls)
|
|
|
|
prefs = get_addon_prefs()
|
|
|
|
# Read Env and override preferences
|
|
bundle_dir = os.getenv("ASSETLIB_BUNDLE_DIR")
|
|
if bundle_dir:
|
|
prefs["bundle_directory"] = os.path.expandvars(bundle_dir)
|
|
|
|
config_dir = os.getenv("ASSETLIB_CONFIG_DIR")
|
|
if config_dir:
|
|
prefs["config_directory"] = os.path.expandvars(config_dir)
|
|
|
|
LIBRARY_TYPE_DIR = os.getenv("ASSETLIB_LIBRARY_TYPE_DIR")
|
|
if LIBRARY_TYPE_DIR:
|
|
prefs["library_type_directory"] = os.path.expandvars(LIBRARY_TYPE_DIR)
|
|
|
|
ADAPTER_DIR = os.getenv("ASSETLIB_ADAPTER_DIR")
|
|
if ADAPTER_DIR:
|
|
prefs["adapter_directory"] = os.path.expandvars(ADAPTER_DIR)
|
|
|
|
prefs.load_library_types()
|
|
prefs.load_adapters()
|
|
|
|
|
|
def unregister():
|
|
for cls in reversed(classes + LIBRARY_TYPES):
|
|
bpy.utils.unregister_class(cls)
|
|
|
|
LIBRARY_TYPES.clear()
|