774 lines
25 KiB
Python
774 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() |