Make all features working
This commit is contained in:
“christopheseux”
@@ -1,4 +0,0 @@
|
||||
|
||||
from asset_library.adapters.adapter import AssetLibraryAdapter
|
||||
from asset_library.adapters.copy_folder import CopyFolderLibrary
|
||||
from asset_library.adapters.scan_folder import ScanFolderLibrary
|
||||
+2
-762
@@ -1,772 +1,12 @@
|
||||
|
||||
#from asset_library.common.functions import (norm_asset_datas,)
|
||||
from asset_library.common.bl_utils import get_addon_prefs, load_datablocks
|
||||
from asset_library.common.file_utils import read_file, write_file
|
||||
from asset_library.common.template import Template
|
||||
from asset_library.constants import (MODULE_DIR, RESOURCES_DIR)
|
||||
|
||||
from asset_library import (action, collection, file)
|
||||
|
||||
from bpy.types import PropertyGroup
|
||||
from bpy.props import StringProperty
|
||||
import bpy
|
||||
|
||||
from itertools import groupby
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import os
|
||||
import json
|
||||
import uuid
|
||||
import time
|
||||
from functools import partial
|
||||
import subprocess
|
||||
from glob import glob
|
||||
|
||||
|
||||
class AssetLibraryAdapter(PropertyGroup):
|
||||
class Adapter(PropertyGroup):
|
||||
|
||||
#def __init__(self):
|
||||
name = "Base Adapter"
|
||||
#library = None
|
||||
|
||||
@property
|
||||
def library(self):
|
||||
prefs = self.addon_prefs
|
||||
for lib in prefs.libraries:
|
||||
if lib.adapter == self:
|
||||
return lib
|
||||
|
||||
@property
|
||||
def bundle_directory(self):
|
||||
return self.library.library_path
|
||||
|
||||
@property
|
||||
def data_type(self):
|
||||
return self.library.data_type
|
||||
|
||||
@property
|
||||
def data_types(self):
|
||||
return self.library.data_types
|
||||
|
||||
def get_catalog_path(self, directory=None):
|
||||
directory = directory or self.bundle_directory
|
||||
return Path(directory, 'blender_assets.cats.txt')
|
||||
|
||||
@property
|
||||
def cache_file(self):
|
||||
return Path(self.bundle_directory) / f"blender_assets.{self.library.id}.json"
|
||||
|
||||
@property
|
||||
def tmp_cache_file(self):
|
||||
return Path(bpy.app.tempdir) / f"blender_assets.{self.library.id}.json"
|
||||
|
||||
@property
|
||||
def diff_file(self):
|
||||
return Path(bpy.app.tempdir, 'diff.json')
|
||||
|
||||
@property
|
||||
def preview_blend(self):
|
||||
return MODULE_DIR / self.data_type.lower() / "preview.blend"
|
||||
|
||||
@property
|
||||
def preview_assets_file(self):
|
||||
return Path(bpy.app.tempdir, "preview_assets_file.json")
|
||||
|
||||
@property
|
||||
def addon_prefs(self):
|
||||
return get_addon_prefs()
|
||||
|
||||
@property
|
||||
def module_type(self):
|
||||
lib_type = self.library.data_type
|
||||
if lib_type == 'ACTION':
|
||||
return action
|
||||
elif lib_type == 'FILE':
|
||||
return file
|
||||
elif lib_type == 'COLLECTION':
|
||||
return collection
|
||||
|
||||
def to_dict(self):
|
||||
return {p: getattr(self, p) for p in self.bl_rna.properties.keys() if p !='rna_type'}
|
||||
|
||||
@property
|
||||
def format_data(self):
|
||||
"""Dict for formating template"""
|
||||
return dict(self.to_dict(), bundle_dir=self.library.library_path)
|
||||
|
||||
def fetch(self):
|
||||
raise Exception('This method need to be define in the adapter')
|
||||
|
||||
def norm_file_name(self, name):
|
||||
return name.replace(' ', '_')
|
||||
|
||||
def read_file(self, file):
|
||||
return read_file(file)
|
||||
|
||||
def write_file(self, file, data):
|
||||
return write_file(file, data)
|
||||
|
||||
def copy_file(self, source, destination):
|
||||
src = Path(source)
|
||||
dst = Path(destination)
|
||||
|
||||
if not src.exists():
|
||||
print(f'Cannot copy file {src}: file not exist')
|
||||
return
|
||||
|
||||
dst.parent.mkdir(exist_ok=True, parents=True)
|
||||
|
||||
if src == dst:
|
||||
print(f'Cannot copy file {src}: source and destination are the same')
|
||||
return
|
||||
|
||||
print(f'Copy file from {src} to {dst}')
|
||||
shutil.copy2(str(src), str(dst))
|
||||
|
||||
def load_datablocks(self, src, names=None, type='objects', link=True, expr=None, assets_only=False):
|
||||
"""Link or append a datablock from a blendfile"""
|
||||
|
||||
if type.isupper():
|
||||
type = f'{type.lower()}s'
|
||||
|
||||
return load_datablocks(src, names=names, type=type, link=link, expr=expr, assets_only=assets_only)
|
||||
|
||||
def get_asset_data(self, asset):
|
||||
"""Extract asset information on a datablock"""
|
||||
|
||||
return dict(
|
||||
name=asset.name,
|
||||
author=asset.asset_data.author,
|
||||
tags=list(asset.asset_data.tags.keys()),
|
||||
metadata=dict(asset.asset_data),
|
||||
description=asset.asset_data.description,
|
||||
)
|
||||
|
||||
def get_asset_relative_path(self, name, catalog):
|
||||
'''Get a relative path for the asset'''
|
||||
name = self.norm_file_name(name)
|
||||
return Path(catalog, name, name).with_suffix('.blend')
|
||||
|
||||
def get_active_asset_library(self):
|
||||
asset_handle = bpy.context.asset_file_handle
|
||||
prefs = get_addon_prefs()
|
||||
asset_handle = bpy.context.asset_file_handle
|
||||
|
||||
lib = None
|
||||
if '.library_id' in asset_handle.asset_data:
|
||||
lib_id = asset_handle.asset_data['.library_id']
|
||||
lib = next((l for l in prefs.libraries if l.id == lib_id), None)
|
||||
|
||||
if not lib:
|
||||
print(f"No library found for id {lib_id}")
|
||||
|
||||
if not lib:
|
||||
lib = self
|
||||
|
||||
return lib
|
||||
|
||||
def get_active_asset_path(self):
|
||||
'''Get the full path of the active asset_handle from the asset brower'''
|
||||
prefs = get_addon_prefs()
|
||||
asset_handle = bpy.context.asset_file_handle
|
||||
|
||||
lib = self.get_active_asset_library()
|
||||
|
||||
if 'filepath' in asset_handle.asset_data:
|
||||
asset_path = asset_handle.asset_data['filepath']
|
||||
asset_path = lib.adapter.format_path(asset_path)
|
||||
else:
|
||||
asset_path = bpy.types.AssetHandle.get_full_library_path(
|
||||
asset_handle, bpy.context.asset_library_ref
|
||||
)
|
||||
|
||||
return asset_path
|
||||
|
||||
def get_image_path(self, name, catalog, filepath):
|
||||
raise Exception('Need to be defined in the adapter')
|
||||
|
||||
def get_video_path(self, name, catalog, filepath):
|
||||
raise Exception('Need to be defined in the adapter')
|
||||
|
||||
def new_asset(self, asset, asset_data):
|
||||
raise Exception('Need to be defined in the adapter')
|
||||
|
||||
def remove_asset(self, asset, asset_data):
|
||||
raise Exception('Need to be defined in the adapter')
|
||||
|
||||
|
||||
def format_asset_data(self, data):
|
||||
"""Get a dict for use in template fields"""
|
||||
return {
|
||||
'asset_name': data['name'],
|
||||
'asset_path': Path(data['filepath']),
|
||||
'catalog': data['catalog'],
|
||||
'catalog_name': data['catalog'].replace('/', '_'),
|
||||
}
|
||||
|
||||
def format_path(self, template, data={}, **kargs):
|
||||
if not template:
|
||||
return None
|
||||
|
||||
if data:
|
||||
data = self.format_asset_data(dict(data, **kargs))
|
||||
else:
|
||||
data = kargs
|
||||
|
||||
|
||||
if template.startswith('.'): #the template is relative
|
||||
template = Path(data['asset_path'], template).as_posix()
|
||||
|
||||
params = dict(
|
||||
**data,
|
||||
**self.format_data,
|
||||
)
|
||||
|
||||
return Template(template).format(params).resolve()
|
||||
|
||||
def find_path(self, template, data, **kargs):
|
||||
path = self.format_path(template, data, **kargs)
|
||||
paths = glob(str(path))
|
||||
if paths:
|
||||
return Path(paths[0])
|
||||
|
||||
def read_asset_description_file(self, asset_path) -> dict:
|
||||
"""Read the description file of the asset"""
|
||||
|
||||
description_path = self.get_description_path(asset_path)
|
||||
return self.read_file(description_path)
|
||||
|
||||
def write_description_file(self, asset_data, asset_path) -> None:
|
||||
description_path = self.get_description_path(asset_path)
|
||||
return write_file(description_path, asset_data)
|
||||
|
||||
def write_asset(self, asset, asset_path):
|
||||
|
||||
Path(asset_path).parent.mkdir(exist_ok=True, parents=True)
|
||||
|
||||
bpy.data.libraries.write(
|
||||
str(asset_path),
|
||||
{asset},
|
||||
path_remap="NONE",
|
||||
fake_user=True,
|
||||
compress=True
|
||||
)
|
||||
|
||||
def read_catalog(self, directory=None):
|
||||
"""Read the catalog file of the library target directory or of the specified directory"""
|
||||
catalog_path = self.get_catalog_path(directory)
|
||||
|
||||
if not catalog_path.exists():
|
||||
return {}
|
||||
|
||||
cat_data = {}
|
||||
|
||||
for line in catalog_path.read_text(encoding="utf-8").split('\n'):
|
||||
if line.startswith(('VERSION', '#')) or not line:
|
||||
continue
|
||||
|
||||
cat_id, cat_path, cat_name = line.split(':')
|
||||
cat_data[cat_path] = {'id':cat_id, 'name':cat_name}
|
||||
|
||||
return cat_data
|
||||
|
||||
def write_catalog(self, catalog_data, directory=None):
|
||||
"""Write the catalog file in the library target directory or of the specified directory"""
|
||||
|
||||
catalog_path = self.get_catalog_path(directory)
|
||||
|
||||
lines = ['VERSION 1', '']
|
||||
|
||||
# Add missing parents catalog
|
||||
norm_data = {}
|
||||
for cat_path, cat_data in catalog_data.items():
|
||||
norm_data[cat_path] = cat_data
|
||||
for p in Path(cat_path).parents[:-1]:
|
||||
if p in cat_data or p in norm_data:
|
||||
continue
|
||||
|
||||
norm_data[p.as_posix()] = {'id': str(uuid.uuid4()), 'name': '-'.join(p.parts)}
|
||||
|
||||
for cat_path, cat_data in sorted(norm_data.items()):
|
||||
cat_name = cat_data['name'].replace('/', '-')
|
||||
lines.append(f"{cat_data['id']}:{cat_path}:{cat_name}")
|
||||
|
||||
print(f'Catalog writen at: {catalog_path}')
|
||||
catalog_path.write_text('\n'.join(lines), encoding="utf-8")
|
||||
|
||||
def read_cache(self, cache_path=None):
|
||||
cache_path = cache_path or self.cache_file
|
||||
print(f'Read cache from {cache_path}')
|
||||
return self.read_file(cache_path)
|
||||
|
||||
def write_cache(self, asset_descriptions, cache_path=None):
|
||||
cache_path = cache_path or self.cache_file
|
||||
print(f'cache file writen to {cache_path}')
|
||||
return write_file(cache_path, list(asset_descriptions))
|
||||
|
||||
def prop_rel_path(self, path, prop):
|
||||
'''Get a filepath relative to a property of the adapter'''
|
||||
field_prop = '{%s}/'%prop
|
||||
|
||||
prop_value = getattr(self, prop)
|
||||
prop_value = Path(os.path.expandvars(prop_value)).resolve()
|
||||
|
||||
rel_path = Path(path).resolve().relative_to(prop_value).as_posix()
|
||||
|
||||
return field_prop + rel_path
|
||||
|
||||
def write_preview(self, preview, filepath):
|
||||
if not preview or not filepath:
|
||||
return
|
||||
|
||||
filepath = Path(filepath)
|
||||
filepath.parent.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
img_size = preview.image_size
|
||||
|
||||
px = [0] * img_size[0] * img_size[1] * 4
|
||||
preview.image_pixels_float.foreach_get(px)
|
||||
img = bpy.data.images.new(name=filepath.name, width=img_size[0], height=img_size[1], is_data=True, alpha=True)
|
||||
img.pixels.foreach_set(px)
|
||||
img.filepath_raw = str(filepath.with_suffix('.png'))
|
||||
img.file_format = 'PNG'
|
||||
img.save()
|
||||
|
||||
def draw_header(self, layout):
|
||||
"""Draw the header of the Asset Browser Window"""
|
||||
#layout.separator()
|
||||
|
||||
self.module_type.gui.draw_header(layout)
|
||||
|
||||
def draw_context_menu(self, layout):
|
||||
"""Draw the context menu of the Asset Browser Window"""
|
||||
self.module_type.gui.draw_context_menu(layout)
|
||||
|
||||
def generate_blend_preview(self, asset_description):
|
||||
asset_name = asset_description['name']
|
||||
catalog = asset_description['catalog']
|
||||
|
||||
asset_path = self.format_path(asset_description['filepath'])
|
||||
dst_image_path = self.get_image_path(asset_name, asset_path, catalog)
|
||||
|
||||
if dst_image_path.exists():
|
||||
return
|
||||
|
||||
# Check if a source image exists and if so copying it in the new directory
|
||||
src_image_path = asset_description.get('image')
|
||||
if src_image_path:
|
||||
src_image_path = self.get_template_path(src_image_path, asset_name, asset_path, catalog)
|
||||
if src_image_path and src_image_path.exists():
|
||||
self.copy_file(src_image_path, dst_image_path)
|
||||
return
|
||||
|
||||
print(f'Thumbnailing {asset_path} to {dst_image_path}')
|
||||
blender_thumbnailer = Path(bpy.app.binary_path).parent / 'blender-thumbnailer'
|
||||
|
||||
dst_image_path.parent.mkdir(exist_ok=True, parents=True)
|
||||
|
||||
subprocess.call([blender_thumbnailer, str(asset_path), str(dst_image_path)])
|
||||
|
||||
success = dst_image_path.exists()
|
||||
|
||||
if not success:
|
||||
empty_preview = RESOURCES_DIR / 'empty_preview.png'
|
||||
self.copy_file(str(empty_preview), str(dst_image_path))
|
||||
|
||||
return success
|
||||
|
||||
def generate_asset_preview(self, asset_description):
|
||||
"""Only generate preview when conforming a library"""
|
||||
|
||||
#print('\ngenerate_preview', asset_description['filepath'])
|
||||
|
||||
scn = bpy.context.scene
|
||||
#Creating the preview for collection, object or material
|
||||
camera = scn.camera
|
||||
vl = bpy.context.view_layer
|
||||
|
||||
data_type = self.data_type #asset_description['data_type']
|
||||
asset_path = self.format_path(asset_description['filepath'])
|
||||
|
||||
# Check if a source video exists and if so copying it in the new directory
|
||||
if self.library.template_video:
|
||||
for asset_data in asset_description['assets']:
|
||||
dst_asset_path = self.get_asset_bundle_path(asset_data)
|
||||
dst_video_path = self.format_path(self.library.template_video, asset_data, filepath=dst_asset_path) #Template(src_video_path).find(asset_data, asset_path=dst_asset_path, **self.format_data)
|
||||
|
||||
if dst_video_path.exists():
|
||||
print(f'The dest video {dst_video_path} already exist')
|
||||
continue
|
||||
|
||||
src_video_template = asset_data.get('video')
|
||||
if not src_video_template:
|
||||
continue
|
||||
|
||||
src_video_path = self.find_path(src_video_template, asset_data, filepath=asset_path)#Template(src_video_path).find(asset_data, asset_path=dst_asset_path, **self.format_data)
|
||||
if src_video_path:
|
||||
print(f'Copy video from {src_video_path} to {dst_video_path}')
|
||||
self.copy_file(src_video_path, dst_video_path)
|
||||
|
||||
# Check if asset as a preview image or need it to be generated
|
||||
asset_data_names = {}
|
||||
|
||||
if self.library.template_image:
|
||||
for asset_data in asset_description['assets']:
|
||||
name = asset_data['name']
|
||||
dst_asset_path = self.get_asset_bundle_path(asset_data)
|
||||
|
||||
dst_image_path = self.format_path(self.library.template_image, asset_data, filepath=dst_asset_path)
|
||||
if dst_image_path.exists():
|
||||
print(f'The dest image {dst_image_path} already exist')
|
||||
continue
|
||||
|
||||
# Check if a source image exists and if so copying it in the new directory
|
||||
src_image_template = asset_data.get('image')
|
||||
if src_image_template:
|
||||
src_image_path = self.find_path(src_image_template, asset_data, filepath=asset_path)
|
||||
|
||||
if src_image_path:
|
||||
self.copy_file(src_image_path, dst_image_path)
|
||||
#print(f'Copy image from {src_image_path} to {dst_image_path}')
|
||||
return
|
||||
|
||||
#Store in a dict all asset_data that does not have preview
|
||||
asset_data_names[name] = dict(asset_data, image_path=dst_image_path)
|
||||
|
||||
|
||||
if not asset_data_names:
|
||||
# No preview to generate
|
||||
return
|
||||
|
||||
#print('Making Preview for', asset_data_names)
|
||||
|
||||
asset_names = list(asset_data_names.keys())
|
||||
assets = self.load_datablocks(asset_path, names=asset_names, link=True, type=data_type)
|
||||
|
||||
for asset in assets:
|
||||
if not asset:
|
||||
continue
|
||||
|
||||
asset_data = asset_data_names[asset.name]
|
||||
image_path = asset_data['image_path']
|
||||
|
||||
if asset.preview:
|
||||
print(f'Writing asset preview to {image_path}')
|
||||
self.write_preview(asset.preview, image_path)
|
||||
continue
|
||||
|
||||
if data_type == 'COLLECTION':
|
||||
|
||||
bpy.ops.object.collection_instance_add(name=asset.name)
|
||||
|
||||
bpy.ops.view3d.camera_to_view_selected()
|
||||
instance = vl.objects.active
|
||||
|
||||
#scn.collection.children.link(asset)
|
||||
|
||||
scn.render.filepath = str(image_path)
|
||||
|
||||
print(f'Render asset {asset.name} to {image_path}')
|
||||
bpy.ops.render.render(write_still=True)
|
||||
|
||||
#instance.user_clear()
|
||||
asset.user_clear()
|
||||
|
||||
bpy.data.objects.remove(instance)
|
||||
|
||||
bpy.ops.outliner.orphans_purge(do_local_ids=True, do_linked_ids=True, do_recursive=True)
|
||||
|
||||
|
||||
def generate_previews(self, cache=None):
|
||||
|
||||
print('Generate previews')
|
||||
|
||||
if cache in (None, ''):
|
||||
cache = self.fetch()
|
||||
elif isinstance(cache, (Path, str)):
|
||||
cache = self.read_cache(cache)
|
||||
|
||||
#cache_diff.sort(key=lambda x :x['filepath'])
|
||||
#blend_groups = groupby(cache_diff, key=lambda x :x['filepath'])
|
||||
|
||||
#TODO Support all multiple data_type
|
||||
for asset_description in cache:
|
||||
|
||||
if asset_description.get('type', self.data_type) == 'FILE':
|
||||
self.generate_blend_preview(asset_description)
|
||||
else:
|
||||
self.generate_asset_preview(asset_description)
|
||||
|
||||
# filepath = asset_description['filepath']
|
||||
|
||||
# asset_datas = asset_description["assets"]
|
||||
|
||||
# asset_datas.sort(key=lambda x :x.get('type', self.data_type))
|
||||
# data_type_groups = groupby(asset_datas, key=lambda x :x.get('type', self.data_type))
|
||||
|
||||
# for data_type, same_type_asset_datas in data_type_groups:
|
||||
|
||||
# asset_names = [a['name'] for a in same_type_asset_datas]
|
||||
# self.generate_preview(filepath, asset_names, data_type)
|
||||
|
||||
def set_asset_preview(self, asset, asset_data):
|
||||
'''Load an externalize image as preview for an asset'''
|
||||
|
||||
asset_path = self.format_path(asset_data['filepath'])
|
||||
|
||||
image_template = asset_data.get('image')
|
||||
if self.library.template_image:
|
||||
asset_path = self.get_asset_bundle_path(asset_data)
|
||||
image_template = self.library.template_image
|
||||
|
||||
image_path = self.find_path(image_template, asset_data, filepath=asset_path)
|
||||
|
||||
if image_path:
|
||||
#print(f'Set asset preview for {image_path} for {asset}')
|
||||
with bpy.context.temp_override(id=asset):
|
||||
bpy.ops.ed.lib_id_load_custom_preview(
|
||||
filepath=str(image_path)
|
||||
)
|
||||
|
||||
if asset.preview:
|
||||
return asset.preview
|
||||
|
||||
def set_asset_catalog(self, asset, asset_data, catalog_data):
|
||||
"""Find the catalog if already exist or create it"""
|
||||
catalog_name = asset_data['catalog']
|
||||
catalog = catalog_data.get(catalog_name)
|
||||
if not catalog:
|
||||
catalog = {'id': str(uuid.uuid4()), 'name': catalog_name}
|
||||
catalog_data[catalog_name] = catalog
|
||||
|
||||
asset.asset_data.catalog_id = catalog['id']
|
||||
|
||||
def set_asset_metadata(self, asset, asset_data):
|
||||
"""Create custom prop to an asset base on provided data"""
|
||||
metadata = asset_data.get('metadata', {})
|
||||
|
||||
library_id = self.library.id
|
||||
if 'library_id' in asset_data:
|
||||
library_id = asset_data['library_id']
|
||||
|
||||
metadata['.library_id'] = library_id
|
||||
metadata['filepath'] = asset_data['filepath']
|
||||
for k, v in metadata.items():
|
||||
asset.asset_data[k] = v
|
||||
|
||||
def set_asset_tags(self, asset, asset_data):
|
||||
"""Create asset tags base on provided data"""
|
||||
|
||||
if 'tags' in asset_data:
|
||||
for tag in asset.asset_data.tags[:]:
|
||||
asset.asset_data.tags.remove(tag)
|
||||
|
||||
for tag in asset_data['tags']:
|
||||
if not tag:
|
||||
continue
|
||||
asset.asset_data.tags.new(tag, skip_if_exists=True)
|
||||
|
||||
def set_asset_info(self, asset, asset_data):
|
||||
"""Set asset description base on provided data"""
|
||||
|
||||
for key in ('author', 'description'):
|
||||
if key in asset_data:
|
||||
setattr(asset.asset_data, key, asset_data.get(key) or '')
|
||||
|
||||
def get_asset_bundle_path(self, asset_data):
|
||||
|
||||
catalog_parts = asset_data['catalog'].split('/') + [asset_data['name']]
|
||||
|
||||
sub_path = catalog_parts[:self.library.blend_depth]
|
||||
|
||||
blend_name = sub_path[-1].replace(' ', '_').lower()
|
||||
return Path(self.bundle_directory, *sub_path, blend_name).with_suffix('.blend')
|
||||
|
||||
def bundle(self, cache_diff=None):
|
||||
"""Group all new assets in one or multiple blends for the asset browser"""
|
||||
|
||||
if self.data_type not in ('FILE', 'ACTION', 'COLLECTION'):
|
||||
print(f'{self.data_type} is not supported yet')
|
||||
return
|
||||
|
||||
catalog_data = self.read_catalog() #TODO remove unused catalog
|
||||
|
||||
write_cache = False
|
||||
if not cache_diff:
|
||||
# Get list of all modifications
|
||||
asset_descriptions = self.fetch()
|
||||
|
||||
|
||||
cache, cache_diff = self.diff(asset_descriptions)
|
||||
|
||||
# Only write complete cache at the end
|
||||
write_cache = True
|
||||
|
||||
#self.generate_previews(asset_descriptions)
|
||||
self.write_cache(asset_descriptions, self.tmp_cache_file)
|
||||
bpy.ops.assetlib.generate_previews(name=self.library.name, cache=str(self.tmp_cache_file))
|
||||
|
||||
#print()
|
||||
#print(cache)
|
||||
#raise Exception()
|
||||
|
||||
elif isinstance(cache_diff, (Path, str)):
|
||||
cache_diff = json.loads(Path(cache_diff).read_text(encoding='utf-8'))
|
||||
|
||||
|
||||
if self.library.blend_depth == 0:
|
||||
raise Exception('Blender depth must be 1 at min')
|
||||
#groups = [(cache_diff)]
|
||||
else:
|
||||
cache_diff.sort(key=self.get_asset_bundle_path)
|
||||
groups = groupby(cache_diff, key=self.get_asset_bundle_path)
|
||||
|
||||
total_assets = len(cache_diff)
|
||||
print(f'total_assets={total_assets}')
|
||||
|
||||
if total_assets == 0:
|
||||
print('No assets found')
|
||||
return
|
||||
|
||||
#data_types = self.data_types
|
||||
#if self.data_types == 'FILE'
|
||||
|
||||
i = 0
|
||||
#assets_to_preview = []
|
||||
for blend_path, asset_datas in groups:
|
||||
#blend_name = sub_path[-1].replace(' ', '_').lower()
|
||||
#blend_path = Path(self.bundle_directory, *sub_path, blend_name).with_suffix('.blend')
|
||||
|
||||
if blend_path.exists():
|
||||
print(f'Opening existing bundle blend: {blend_path}')
|
||||
bpy.ops.wm.open_mainfile(filepath=str(blend_path))
|
||||
else:
|
||||
print(f'Create new bundle blend to: {blend_path}')
|
||||
bpy.ops.wm.read_homefile(use_empty=True)
|
||||
|
||||
for asset_data in asset_datas:
|
||||
if total_assets <= 100 or i % int(total_assets / 10) == 0:
|
||||
print(f'Progress: {int(i / total_assets * 100)+1}')
|
||||
|
||||
operation = asset_data.get('operation', 'ADD')
|
||||
asset = getattr(bpy.data, self.data_types).get(asset_data['name'])
|
||||
|
||||
if operation == 'REMOVE':
|
||||
if asset:
|
||||
getattr(bpy.data, self.data_types).remove(asset)
|
||||
else:
|
||||
print(f'ERROR : Remove Asset: {asset_data["name"]} not found in {blend_path}')
|
||||
continue
|
||||
|
||||
if operation == 'MODIFY' and not asset:
|
||||
print(f'WARNING: Modifiy Asset: {asset_data["name"]} not found in {blend_path} it will be created')
|
||||
|
||||
elif operation == 'ADD' or not asset:
|
||||
if asset:
|
||||
#raise Exception(f"Asset {asset_data['name']} Already in Blend")
|
||||
print(f"Asset {asset_data['name']} Already in Blend")
|
||||
getattr(bpy.data, self.data_types).remove(asset)
|
||||
|
||||
print(f"INFO: Add new asset: {asset_data['name']}")
|
||||
asset = getattr(bpy.data, self.data_types).new(name=asset_data['name'])
|
||||
else:
|
||||
print(f'operation {operation} not supported should be in (ADD, REMOVE, MODIFIED)')
|
||||
continue
|
||||
|
||||
asset.asset_mark()
|
||||
|
||||
self.set_asset_preview(asset, asset_data)
|
||||
|
||||
#if not asset_preview:
|
||||
# assets_to_preview.append((asset_data['filepath'], asset_data['name'], asset_data['data_type']))
|
||||
#if self.externalize_data:
|
||||
# self.write_preview(preview, filepath)
|
||||
|
||||
self.set_asset_catalog(asset, asset_data, catalog_data)
|
||||
self.set_asset_metadata(asset, asset_data)
|
||||
self.set_asset_tags(asset, asset_data)
|
||||
self.set_asset_info(asset, asset_data)
|
||||
|
||||
|
||||
i += 1
|
||||
|
||||
#self.write_asset_preview_file()
|
||||
|
||||
print(f'Saving Blend to {blend_path}')
|
||||
|
||||
blend_path.parent.mkdir(exist_ok=True, parents=True)
|
||||
bpy.ops.wm.save_as_mainfile(filepath=str(blend_path), compress=True)
|
||||
|
||||
if write_cache:
|
||||
self.write_cache(asset_descriptions)
|
||||
|
||||
self.write_catalog(catalog_data)
|
||||
|
||||
|
||||
bpy.ops.wm.quit_blender()
|
||||
|
||||
def norm_cache(self, cache):
|
||||
""" Return a new flat list of asset data
|
||||
the filepath keys are merge with the assets keys"""
|
||||
|
||||
if not cache or not isinstance(cache[0], dict):
|
||||
return []
|
||||
|
||||
new_cache = []
|
||||
|
||||
for asset_description in cache:
|
||||
asset_description = asset_description.copy()
|
||||
if 'assets' in asset_description:
|
||||
|
||||
assets = asset_description.pop('assets')
|
||||
for asset_data in assets:
|
||||
new_cache.append({**asset_description, **asset_data})
|
||||
else:
|
||||
new_cache.append(asset_description)
|
||||
|
||||
return new_cache
|
||||
|
||||
def diff(self, asset_descriptions=None):
|
||||
"""Compare the library cache with it current state and return the difference"""
|
||||
|
||||
cache = self.read_cache()
|
||||
|
||||
if cache is None:
|
||||
print(f'Fetch The library {self.library.name} for the first time, might be long...')
|
||||
cache = []
|
||||
|
||||
asset_descriptions = asset_descriptions or self.fetch()
|
||||
|
||||
#print('\n-------------------------', cache)
|
||||
|
||||
cache = {f"{a['filepath']}/{a['name']}": a for a in self.norm_cache(cache)}
|
||||
new_cache = {f"{a['filepath']}/{a['name']}" : a for a in self.norm_cache(asset_descriptions)}
|
||||
|
||||
assets_added = [v for k, v in new_cache.items() if k not in cache]
|
||||
assets_removed = [v for k, v in cache.items() if k not in new_cache]
|
||||
assets_modified = [v for k, v in cache.items() if v not in assets_removed and v!= new_cache[k]]
|
||||
|
||||
if assets_added:
|
||||
print(f'{len(assets_added)} Assets Added \n{tuple(a["name"] for a in assets_added[:10])}\n')
|
||||
if assets_removed:
|
||||
print(f'{len(assets_removed)} Assets Removed \n{tuple(a["name"] for a in assets_removed[:10])}\n')
|
||||
if assets_modified:
|
||||
print(f'{len(assets_modified)} Assets Modified \n{tuple(a["name"] for a in assets_modified[:10])}\n')
|
||||
|
||||
assets_added = [dict(a, operation='ADD') for a in assets_added]
|
||||
assets_removed = [dict(a, operation='REMOVE') for a in assets_removed]
|
||||
assets_modified = [dict(a, operation='MODIFY') for a in assets_modified]
|
||||
|
||||
cache_diff = assets_added + assets_removed + assets_modified
|
||||
if not cache_diff:
|
||||
print('No change in the library')
|
||||
|
||||
return new_cache, cache_diff
|
||||
|
||||
def draw_prefs(self, layout):
|
||||
"""Draw the options in the addon preference for this adapter"""
|
||||
|
||||
annotations = self.__class__.__annotations__
|
||||
for k, v in annotations.items():
|
||||
layout.prop(self, k, text=bpy.path.display_name(k))
|
||||
|
||||
return {p: getattr(self, p) for p in self.bl_rna.properties.keys() if p !='rna_type'}
|
||||
@@ -1,46 +0,0 @@
|
||||
|
||||
"""
|
||||
Adapter for making an asset library of all blender file found in a folder
|
||||
"""
|
||||
|
||||
|
||||
from asset_library.adapters.adapter import AssetLibraryAdapter
|
||||
from asset_library.common.file_utils import copy_dir
|
||||
from bpy.props import StringProperty
|
||||
from os.path import expandvars
|
||||
import bpy
|
||||
|
||||
|
||||
class CopyFolderLibrary(AssetLibraryAdapter):
|
||||
"""Copy library folder from a server to a local disk for better performance"""
|
||||
|
||||
name = "Copy Folder"
|
||||
source_directory : StringProperty()
|
||||
|
||||
includes : StringProperty()
|
||||
excludes : StringProperty()
|
||||
|
||||
def bundle(self, cache_diff=None):
|
||||
src = expandvars(self.source_directory)
|
||||
dst = expandvars(self.bundle_directory)
|
||||
|
||||
includes = [inc.strip() for inc in self.includes.split(',')]
|
||||
excludes = [ex.strip() for ex in self.excludes.split(',')]
|
||||
|
||||
print(f'Copy Folder from {src} to {dst}...')
|
||||
copy_dir(
|
||||
src, dst, only_recent=True,
|
||||
excludes=excludes, includes=includes
|
||||
)
|
||||
|
||||
def filter_prop(self, prop):
|
||||
if prop in ('template_description', 'template_video', 'template_image', 'blend_depth'):
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
# def draw_prop(self, layout, prop):
|
||||
# if prop in ('template_description', 'template_video', 'template_image', 'blend_depth'):
|
||||
# return
|
||||
|
||||
# super().draw_prop(layout)
|
||||
@@ -1,153 +0,0 @@
|
||||
|
||||
"""
|
||||
Plugin for making an asset library of all blender file found in a folder
|
||||
"""
|
||||
|
||||
|
||||
from asset_library.adapters.adapter import AssetLibraryAdapter
|
||||
from asset_library.common.template import Template
|
||||
from asset_library.common.file_utils import install_module
|
||||
|
||||
import bpy
|
||||
from bpy.props import (StringProperty, IntProperty, BoolProperty)
|
||||
import re
|
||||
from pathlib import Path
|
||||
from itertools import groupby
|
||||
import uuid
|
||||
import os
|
||||
import shutil
|
||||
import json
|
||||
import urllib3
|
||||
import traceback
|
||||
import time
|
||||
|
||||
|
||||
class KitsuLibrary(AssetLibraryAdapter):
|
||||
|
||||
name = "Kitsu"
|
||||
template_name : StringProperty()
|
||||
template_file : StringProperty()
|
||||
source_directory : StringProperty(subtype='DIR_PATH')
|
||||
#blend_depth: IntProperty(default=1)
|
||||
|
||||
url: StringProperty()
|
||||
login: StringProperty()
|
||||
password: StringProperty(subtype='PASSWORD')
|
||||
project_name: StringProperty()
|
||||
|
||||
def connect(self, url=None, login=None, password=None):
|
||||
'''Connect to kitsu api using provided url, login and password'''
|
||||
|
||||
gazu = install_module('gazu')
|
||||
urllib3.disable_warnings()
|
||||
|
||||
if not self.url:
|
||||
print(f'Kitsu Url: {self.url} is empty')
|
||||
return
|
||||
|
||||
url = self.url
|
||||
if not url.endswith('/api'):
|
||||
url += '/api'
|
||||
|
||||
print(f'Info: Setting Host for kitsu {url}')
|
||||
gazu.client.set_host(url)
|
||||
|
||||
if not gazu.client.host_is_up():
|
||||
print('Error: Kitsu Host is down')
|
||||
|
||||
try:
|
||||
print(f'Info: Log in to kitsu as {self.login}')
|
||||
res = gazu.log_in(self.login, self.password)
|
||||
print(f'Info: Sucessfully login to Kitsu as {res["user"]["full_name"]}')
|
||||
return res['user']
|
||||
except Exception as e:
|
||||
print(f'Error: {traceback.format_exc()}')
|
||||
|
||||
def get_asset_path(self, name, catalog, directory=None):
|
||||
directory = directory or self.source_directory
|
||||
return Path(directory, self.get_asset_relative_path(name, catalog))
|
||||
|
||||
def get_asset_description(self, data, asset_path):
|
||||
|
||||
modified = time.time_ns()
|
||||
catalog = data['entity_type_name']
|
||||
asset_path = self.prop_rel_path(asset_path, 'source_directory')
|
||||
#asset_name = self.norm_file_name(data['name'])
|
||||
|
||||
asset_description = dict(
|
||||
filepath=asset_path,
|
||||
modified=modified,
|
||||
library_id=self.library.id,
|
||||
assets=[dict(
|
||||
catalog=catalog,
|
||||
metadata=data.get('data', {}),
|
||||
description=data['description'],
|
||||
tags=[],
|
||||
type=self.data_type,
|
||||
image=self.library.template_image,
|
||||
video=self.library.template_video,
|
||||
name=data['name'])
|
||||
]
|
||||
)
|
||||
|
||||
return asset_description
|
||||
|
||||
# def bundle(self, cache_diff=None):
|
||||
# """Group all asset in one or multiple blends for the asset browser"""
|
||||
|
||||
# return super().bundle(cache_diff=cache_diff)
|
||||
|
||||
def fetch(self):
|
||||
"""Gather in a list all assets found in the folder"""
|
||||
|
||||
print(f'Fetch Assets for {self.library.name}')
|
||||
|
||||
gazu = install_module('gazu')
|
||||
self.connect()
|
||||
|
||||
template_file = Template(self.template_file)
|
||||
template_name = Template(self.template_name)
|
||||
|
||||
project = gazu.client.fetch_first('projects', {'name': self.project_name})
|
||||
entity_types = gazu.client.fetch_all('entity-types')
|
||||
entity_types_ids = {e['id']: e['name'] for e in entity_types}
|
||||
|
||||
asset_descriptions = []
|
||||
for asset_data in gazu.asset.all_assets_for_project(project):
|
||||
asset_data['entity_type_name'] = entity_types_ids[asset_data.pop('entity_type_id')]
|
||||
asset_name = asset_data['name']
|
||||
|
||||
asset_field_data = dict(asset_name=asset_name, type=asset_data['entity_type_name'], source_directory=self.source_directory)
|
||||
|
||||
try:
|
||||
asset_field_data.update(template_name.parse(asset_name))
|
||||
except Exception:
|
||||
print(f'Warning: Could not parse {asset_name} with template {template_name}')
|
||||
|
||||
asset_path = template_file.find(asset_field_data)
|
||||
if not asset_path:
|
||||
print(f'Warning: Could not find file for {template_file.format(asset_field_data)}')
|
||||
continue
|
||||
|
||||
#print(asset_path)
|
||||
|
||||
# TODO group when multiple asset are store in the same blend
|
||||
asset_descriptions.append(self.get_asset_description(asset_data, asset_path))
|
||||
|
||||
#asset = load_datablocks(asset_path, data_type='collections', names=asset_data['name'], link=True)
|
||||
#if not asset:
|
||||
# print(f"Asset {asset_name} not found in {asset_path}")
|
||||
|
||||
|
||||
#asset_description = self.get_asset_description(asset)
|
||||
|
||||
#asset_descriptions.append(asset_description)
|
||||
|
||||
#print(assets)
|
||||
# for k, v in assets[0].items():
|
||||
# print(f'- {k} {v}')
|
||||
|
||||
#print('+++++++++++++')
|
||||
#print(asset_descriptions)
|
||||
|
||||
return asset_descriptions
|
||||
@@ -1,165 +0,0 @@
|
||||
|
||||
"""
|
||||
Plugin for making an asset library of all blender file found in a folder
|
||||
"""
|
||||
|
||||
|
||||
from asset_library.adapters.adapter import AssetLibraryAdapter
|
||||
from asset_library.common.bl_utils import load_datablocks
|
||||
from asset_library.common.template import Template
|
||||
|
||||
import bpy
|
||||
from bpy.props import (StringProperty, IntProperty, BoolProperty)
|
||||
import re
|
||||
from pathlib import Path
|
||||
from itertools import groupby
|
||||
import uuid
|
||||
import os
|
||||
import shutil
|
||||
import json
|
||||
import time
|
||||
|
||||
|
||||
class ScanFolderLibrary(AssetLibraryAdapter):
|
||||
|
||||
name = "Scan Folder"
|
||||
source_directory : StringProperty(subtype='DIR_PATH')
|
||||
template_file : StringProperty()
|
||||
template_image : StringProperty()
|
||||
template_video : StringProperty()
|
||||
template_description : StringProperty()
|
||||
|
||||
def get_asset_path(self, name, catalog, directory=None):
|
||||
directory = directory or self.source_directory
|
||||
catalog = self.norm_file_name(catalog)
|
||||
name = self.norm_file_name(name)
|
||||
|
||||
return Path(directory, self.get_asset_relative_path(name, catalog))
|
||||
|
||||
def get_image_path(self, name, catalog, filepath):
|
||||
catalog = self.norm_file_name(catalog)
|
||||
name = self.norm_file_name(name)
|
||||
return self.format_path(self.template_image, dict(name=name, catalog=catalog, filepath=filepath))
|
||||
|
||||
def get_video_path(self, name, catalog, filepath):
|
||||
catalog = self.norm_file_name(catalog)
|
||||
name = self.norm_file_name(name)
|
||||
return self.format_path(self.template_video, dict(name=name, catalog=catalog, filepath=filepath))
|
||||
|
||||
def format_asset_description(self, asset_description, asset_path):
|
||||
|
||||
asset_path = self.prop_rel_path(asset_path, 'source_directory')
|
||||
modified = asset_description.get('modified', time.time_ns())
|
||||
|
||||
if self.data_type == 'FILE':
|
||||
return dict(
|
||||
filepath=asset_path,
|
||||
author=asset_description.get('author'),
|
||||
modified=modified,
|
||||
catalog=asset_description['catalog'],
|
||||
tags=[],
|
||||
description=asset_description.get('description', ''),
|
||||
type=self.data_type,
|
||||
image=self.template_image,
|
||||
name=asset_description['name']
|
||||
)
|
||||
|
||||
return dict(
|
||||
filepath=asset_path,
|
||||
modified=modified,
|
||||
library_id=self.library.id,
|
||||
assets=[dict(
|
||||
catalog=asset_data.get('catalog', asset_description['catalog']),
|
||||
author=asset_data.get('author'),
|
||||
metadata=asset_data.get('metadata', {}),
|
||||
description=asset_data.get('description', ''),
|
||||
tags=asset_data.get('tags', []),
|
||||
type=self.data_type,
|
||||
image=self.template_image,
|
||||
video=self.template_video,
|
||||
name=asset_data['name']) for asset_data in asset_description['assets']
|
||||
]
|
||||
)
|
||||
|
||||
def fetch(self):
|
||||
"""Gather in a list all assets found in the folder"""
|
||||
|
||||
print(f'Fetch Assets for {self.library.name}')
|
||||
|
||||
source_directory = Path(self.source_directory)
|
||||
template_file = Template(self.template_file)
|
||||
catalog_data = self.read_catalog(directory=source_directory)
|
||||
catalog_ids = {v['id']: k for k, v in catalog_data.items()}
|
||||
|
||||
cache = self.read_cache() or []
|
||||
|
||||
print(f'Search for blend using glob template: {template_file.glob_pattern}')
|
||||
print(f'Scanning Folder {source_directory}...')
|
||||
|
||||
new_cache = []
|
||||
|
||||
for asset_path in template_file.glob(source_directory):#sorted(blend_files):
|
||||
|
||||
source_rel_path = self.prop_rel_path(asset_path, 'source_directory')
|
||||
modified = asset_path.stat().st_mtime_ns
|
||||
|
||||
# Check if the asset description as already been cached
|
||||
asset_description = next((a for a in cache if a['filepath'] == source_rel_path), None)
|
||||
|
||||
if asset_description and asset_description['modified'] >= modified:
|
||||
print(asset_path, 'is skipped because not modified')
|
||||
new_cache.append(asset_description)
|
||||
continue
|
||||
|
||||
rel_path = asset_path.relative_to(source_directory).as_posix()
|
||||
field_data = template_file.parse(rel_path)
|
||||
|
||||
catalogs = [v for k,v in sorted(field_data.items()) if k.isdigit()]
|
||||
#catalogs = [c.replace('_', ' ').title() for c in catalogs]
|
||||
|
||||
asset_name = field_data.get('asset_name', asset_path.stem)
|
||||
|
||||
asset_description = {
|
||||
"name": asset_name,
|
||||
"catalog": '/'.join(catalogs),
|
||||
"assets": [],
|
||||
'modified': modified
|
||||
}
|
||||
|
||||
if self.data_type == 'FILE':
|
||||
asset_description = self.format_asset_description(asset_description, asset_path)
|
||||
new_cache.append(asset_description)
|
||||
continue
|
||||
|
||||
# Now check if there is a asset description file
|
||||
asset_description_path = self.find_path(self.template_description, asset_description, filepath=asset_path)
|
||||
if asset_description_path:
|
||||
new_cache.append(self.read_file(asset_description_path))
|
||||
continue
|
||||
|
||||
# Scan the blend file for assets inside and write a custom asset description for info found
|
||||
print(f'Scanning blendfile {asset_path}...')
|
||||
assets = self.load_datablocks(asset_path, type=self.data_types, link=True, assets_only=True)
|
||||
print(f'Found {len(assets)} {self.data_types} inside')
|
||||
|
||||
for asset in assets:
|
||||
#catalog_path = catalog_ids.get(asset.asset_data.catalog_id)
|
||||
|
||||
#if not catalog_path:
|
||||
# print(f'No catalog found for asset {asset.name}')
|
||||
#catalog_path = asset_description['catalog']#asset_path.relative_to(self.source_directory).as_posix()
|
||||
|
||||
# For now the catalog used is the one extract from the template file
|
||||
asset_description['assets'].append(self.get_asset_data(asset))
|
||||
|
||||
getattr(bpy.data, self.data_types).remove(asset)
|
||||
|
||||
asset_description = self.format_asset_description(asset_description, asset_path)
|
||||
|
||||
new_cache.append(asset_description)
|
||||
|
||||
|
||||
new_cache.sort(key=lambda x:x['filepath'])
|
||||
|
||||
return new_cache
|
||||
|
||||
Reference in New Issue
Block a user