729 lines
26 KiB
Python
729 lines
26 KiB
Python
# ##### BEGIN GPL LICENSE BLOCK #####
|
||
#
|
||
# This program is free software; you can redistribute it and/or
|
||
# modify it under the terms of the GNU General Public License
|
||
# as published by the Free Software Foundation; either version 2
|
||
# of the License, or (at your option) any later version.
|
||
#
|
||
# This program is distributed in the hope that it will be useful,
|
||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
# GNU General Public License for more details.
|
||
#
|
||
# You should have received a copy of the GNU General Public License
|
||
# along with this program; if not, write to the Free Software Foundation,
|
||
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||
#
|
||
# ##### END GPL LICENSE BLOCK #####
|
||
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import os
|
||
import sys
|
||
import traceback
|
||
import urllib.request
|
||
import uuid
|
||
import logging
|
||
|
||
import bpy
|
||
|
||
bk_logger = logging.getLogger(__name__)
|
||
|
||
_INT32_MIN = -2_147_483_648
|
||
_INT32_MAX = 2_147_483_647
|
||
|
||
|
||
def _sanitize_for_idprops(value):
|
||
"""Recursively sanitize a value so it can be stored as a Blender IDProperty.
|
||
Large integers that would overflow int32 are converted to strings.
|
||
"""
|
||
if isinstance(value, int):
|
||
if value < _INT32_MIN or value > _INT32_MAX:
|
||
return str(value)
|
||
return value
|
||
if isinstance(value, dict):
|
||
return {k: _sanitize_for_idprops(v) for k, v in value.items()}
|
||
if isinstance(value, (list, tuple, set)):
|
||
return [_sanitize_for_idprops(v) for v in value]
|
||
return value
|
||
|
||
|
||
_ASSET_TYPE_DIRS = {
|
||
"models",
|
||
"materials",
|
||
"hdrs",
|
||
"scenes",
|
||
"brushes",
|
||
"textures",
|
||
"nodegroups",
|
||
"printables",
|
||
"addons",
|
||
}
|
||
|
||
|
||
def get_texture_filepath(tex_dir_path, image, resolution="blend", source_path=""):
|
||
if source_path:
|
||
path = source_path
|
||
elif len(image.packed_files) > 0:
|
||
path = image.packed_files[0].filepath
|
||
else:
|
||
path = image.filepath
|
||
# backslashes needs to be replaced because bpy.path.basename(path)
|
||
# does not work on Mac for Windows paths
|
||
path = path or ""
|
||
path = path.replace("\\", "/")
|
||
image_file_name = bpy.path.basename(path)
|
||
if image_file_name == "":
|
||
image_file_name = image.name.split(".")[0]
|
||
|
||
# check if there is already an image with same name and thus also assigned path
|
||
# (can happen easily with generated tex sets and more materials)
|
||
file_path_original = os.path.join(tex_dir_path, image_file_name)
|
||
file_path_final = file_path_original
|
||
|
||
i = 0
|
||
done = False
|
||
while not done:
|
||
is_solo = True
|
||
for image1 in bpy.data.images:
|
||
if image != image1 and image1.filepath == file_path_final:
|
||
is_solo = False
|
||
fpleft, fpext = os.path.splitext(file_path_original)
|
||
file_path_final = fpleft + str(i).zfill(3) + fpext
|
||
i += 1
|
||
if is_solo:
|
||
done = True
|
||
|
||
return file_path_final
|
||
|
||
|
||
def get_resolution_from_file_path(file_path):
|
||
possible_resolutions = {
|
||
"_0_5K_": "resolution_0_5K",
|
||
"_1K_": "resolution_1K",
|
||
"_2K_": "resolution_2K",
|
||
"_4K_": "resolution_4K",
|
||
"_8K_": "resolution_8K",
|
||
}
|
||
for res in possible_resolutions:
|
||
if res in file_path:
|
||
return possible_resolutions[res]
|
||
return "blend"
|
||
|
||
|
||
def _resolve_author_name(asset_data: dict) -> str:
|
||
author = asset_data.get("author") or {}
|
||
full_name = author.get("fullName") or ""
|
||
if full_name:
|
||
return full_name
|
||
first = author.get("firstName") or ""
|
||
last = author.get("lastName") or ""
|
||
return f"{first} {last}".strip()
|
||
|
||
|
||
def _resolve_thumbnail_url(asset_data: dict) -> str:
|
||
for key in ("thumbnailMiddleUrl", "thumbnailSmallUrl", "thumbnailLargeUrl"):
|
||
url = asset_data.get(key)
|
||
if url:
|
||
return str(url)
|
||
|
||
for file in asset_data.get("files", []):
|
||
if file.get("fileType") not in (
|
||
"thumbnail",
|
||
"photo_thumbnail",
|
||
"wire_thumbnail",
|
||
):
|
||
continue
|
||
for key in (
|
||
"thumbnailMiddleUrl",
|
||
"thumbnailSmallUrl",
|
||
"fileThumbnailLarge",
|
||
"fileThumbnail",
|
||
):
|
||
url = file.get(key)
|
||
if url:
|
||
return str(url)
|
||
|
||
return ""
|
||
|
||
|
||
def _library_dir_from_fpath(blend_path: str) -> str:
|
||
"""Derive library root from a blend file path by stripping the asset_type folder.
|
||
|
||
Expected structure: <library>/<asset_type>/<asset_id>/<file>.blend
|
||
Returns the portion up to <library>. Falls back to two levels above the blend file directory.
|
||
"""
|
||
if not blend_path:
|
||
return ""
|
||
|
||
norm_path = os.path.abspath(blend_path)
|
||
parts = norm_path.split(os.sep)
|
||
for idx, part in enumerate(parts):
|
||
if part.lower() in _ASSET_TYPE_DIRS and idx > 0:
|
||
return os.sep.join(parts[:idx])
|
||
|
||
# Fallback: go two levels up from the blend file directory
|
||
dir_path = os.path.dirname(norm_path)
|
||
return os.path.abspath(os.path.join(dir_path, os.pardir, os.pardir))
|
||
|
||
|
||
def _download_thumbnail(url: str) -> str:
|
||
"""Download the thumbnail image from the given URL and save it to the same directory as the current .blend file.
|
||
|
||
Returns the file path of the downloaded thumbnail, or an empty string if the download failed.
|
||
"""
|
||
if not url:
|
||
return ""
|
||
base_name = "preview.png"
|
||
target_dir = os.path.dirname(bpy.data.filepath)
|
||
if not target_dir:
|
||
return ""
|
||
target_path = os.path.join(target_dir, base_name)
|
||
if os.path.exists(target_path):
|
||
return target_path
|
||
try:
|
||
req = urllib.request.Request(url)
|
||
req.add_header("User-Agent", "BlenderKit")
|
||
req.add_header("Accept", "image/*")
|
||
with urllib.request.urlopen(req, timeout=15) as response:
|
||
with open(target_path, "wb") as handle:
|
||
handle.write(response.read())
|
||
return target_path
|
||
except Exception:
|
||
return ""
|
||
|
||
|
||
def _sanitize_preview_image(preview_path: str) -> str:
|
||
"""Some thumbnail images have issues libEx support.
|
||
|
||
This function tries to sanitize the image by re-saving it as PNG from the blender.
|
||
"""
|
||
if not preview_path or not os.path.exists(preview_path):
|
||
return ""
|
||
base_dir = os.path.dirname(preview_path)
|
||
base_name = os.path.splitext(os.path.basename(preview_path))[0]
|
||
sanitized_path = os.path.join(base_dir, f"{base_name}_clean.png")
|
||
if os.path.exists(sanitized_path):
|
||
return sanitized_path
|
||
img = None
|
||
try:
|
||
img = bpy.data.images.load(preview_path, check_existing=False)
|
||
img.filepath_raw = sanitized_path
|
||
img.file_format = "PNG"
|
||
img.save()
|
||
return sanitized_path
|
||
except Exception:
|
||
return ""
|
||
finally:
|
||
if img is not None:
|
||
try:
|
||
bpy.data.images.remove(img)
|
||
except Exception:
|
||
pass
|
||
|
||
|
||
def _op_poll(op_callable, data_block) -> bool:
|
||
"""Check if the operator can run in the context of the given data block."""
|
||
try:
|
||
if hasattr(bpy.context, "temp_override"):
|
||
with bpy.context.temp_override(id=data_block):
|
||
return op_callable.poll()
|
||
override = bpy.context.copy()
|
||
override["id"] = data_block
|
||
return op_callable.poll(override)
|
||
except Exception:
|
||
return False
|
||
|
||
|
||
def _op_call(op_callable, data_block, **kwargs):
|
||
"""Call the operator in the context of the given data block."""
|
||
if hasattr(bpy.context, "temp_override"):
|
||
with bpy.context.temp_override(id=data_block):
|
||
return op_callable(**kwargs)
|
||
override = bpy.context.copy()
|
||
override["id"] = data_block
|
||
return op_callable(override, **kwargs)
|
||
|
||
|
||
def _apply_asset_preview(data_block, asset_data: dict) -> None:
|
||
"""Apply asset preview image to the asset data block.
|
||
|
||
It first tries to download the thumbnail from the URL provided in asset data.
|
||
If that fails, it falls back to generating a preview within Blender."""
|
||
if data_block is None:
|
||
return
|
||
print("🖼️ applying asset preview")
|
||
url = _resolve_thumbnail_url(asset_data)
|
||
preview_path = _download_thumbnail(url) if url else ""
|
||
if preview_path:
|
||
clean_path = _sanitize_preview_image(preview_path)
|
||
if clean_path:
|
||
preview_path = clean_path
|
||
try:
|
||
loaded = False
|
||
if _op_poll(bpy.ops.ed.lib_id_load_custom_preview, data_block):
|
||
result = _op_call(
|
||
bpy.ops.ed.lib_id_load_custom_preview,
|
||
data_block,
|
||
filepath=preview_path,
|
||
)
|
||
loaded = "FINISHED" in result
|
||
if loaded:
|
||
print(" Thumbnail preview applied successfully.")
|
||
return
|
||
except Exception as e:
|
||
print(
|
||
"Failed to load thumbnail preview, falling back to generating preview: "
|
||
f"{e}"
|
||
)
|
||
|
||
try:
|
||
if _op_poll(bpy.ops.ed.lib_id_generate_preview, data_block):
|
||
_op_call(bpy.ops.ed.lib_id_generate_preview, data_block)
|
||
print(" Generated preview applied successfully.")
|
||
except Exception:
|
||
print("Failed to generate preview, asset will have no preview")
|
||
return
|
||
|
||
|
||
def _write_metadata(data_block, asset_data: dict) -> None:
|
||
"""Write asset metadata to the asset data block.
|
||
|
||
This includes tags, author, and description."""
|
||
if data_block is None:
|
||
return
|
||
print("📝 writing asset metadata")
|
||
tags = data_block.asset_data.tags
|
||
for t in tags:
|
||
tags.remove(t)
|
||
tags = data_block.asset_data.tags
|
||
for t in asset_data.get("tags", []):
|
||
tags.new(str(t))
|
||
|
||
# assign more metadata in tags, so it is searchable in asset browser, and also visible in metadata panel
|
||
other_meta = {}
|
||
|
||
if asset_data.get("assetBaseId"):
|
||
other_meta["id"] = asset_data["assetBaseId"]
|
||
if asset_data.get("assetType"):
|
||
other_meta["asset_type"] = asset_data.get("assetType", "")
|
||
if asset_data.get("sourceAppVersion"):
|
||
other_meta["source_app_version"] = asset_data.get("sourceAppVersion", "")
|
||
|
||
# further custom meta from dictParameters
|
||
dict_parameters = asset_data.get("dictParameters", {})
|
||
if "category" in dict_parameters:
|
||
other_meta["category"] = dict_parameters["category"]
|
||
if "condition" in dict_parameters:
|
||
other_meta["condition"] = dict_parameters["condition"]
|
||
if "pbrType" in dict_parameters:
|
||
other_meta["pbr_type"] = dict_parameters["pbrType"]
|
||
if "materialStyle" in dict_parameters:
|
||
other_meta["material_style"] = dict_parameters["materialStyle"]
|
||
if "engine" in dict_parameters:
|
||
other_meta["engine"] = dict_parameters["engine"]
|
||
if "animated" in dict_parameters and dict_parameters["animated"]:
|
||
other_meta["animated"] = "yes"
|
||
if "simulation" in dict_parameters and dict_parameters["simulation"]:
|
||
other_meta["simulation"] = "yes"
|
||
|
||
# ad additional metadata to tags
|
||
for key, value in other_meta.items():
|
||
tags.new(f"{key}:{value}")
|
||
|
||
description = asset_data.get("description", "")
|
||
author_name = _resolve_author_name(asset_data)
|
||
|
||
data_block.asset_data.author = author_name
|
||
data_block.asset_data.description = description
|
||
if hasattr(data_block.asset_data, "copyright"):
|
||
data_block.asset_data.copyright = asset_data.get("copyright", "")
|
||
if hasattr(data_block.asset_data, "license"):
|
||
data_block.asset_data.license = asset_data.get("license", "")
|
||
|
||
|
||
def _sanitize_catalog_segment(segment: str) -> str:
|
||
cleaned = (segment or "").strip()
|
||
cleaned = cleaned.replace(":", "-").replace("/", "-").replace("\\", "-")
|
||
return cleaned or "Uncategorized"
|
||
|
||
|
||
def _resolve_category_segments(asset_data: dict) -> list[str]:
|
||
category_slug = asset_data.get("category") or asset_data.get(
|
||
"dictParameters", {}
|
||
).get("category")
|
||
if not category_slug:
|
||
return []
|
||
|
||
parts = [p for p in str(category_slug).split("-") if p]
|
||
return [_sanitize_catalog_segment(part) for part in parts]
|
||
|
||
|
||
def _resolve_catalog_path_parts(asset_data: dict) -> list[str]:
|
||
asset_type = (asset_data.get("assetType") or "").lower()
|
||
catalog_map = {
|
||
"model": "Models",
|
||
"material": "Materials",
|
||
"hdr": "HDRIs",
|
||
"hdri": "HDRIs",
|
||
"printable": "Printables",
|
||
"scene": "Scenes",
|
||
"brush": "Brushes",
|
||
"texture": "Textures",
|
||
"nodegroup": "Node Groups",
|
||
"addon": "Add-ons",
|
||
}
|
||
|
||
parts = []
|
||
top_level = catalog_map.get(asset_type)
|
||
if top_level:
|
||
parts.append(top_level)
|
||
|
||
parts.extend(_resolve_category_segments(asset_data))
|
||
bk_logger.debug(
|
||
"Resolved catalog path parts: %s for asset type '%s' and category '%s'",
|
||
parts,
|
||
asset_type,
|
||
asset_data.get("category"),
|
||
)
|
||
return parts
|
||
|
||
|
||
def _ensure_catalog_exists(
|
||
library_path: str, catalog_path: str, catalog_simple_name: str
|
||
) -> str:
|
||
"""Ensure that an asset catalog exists for the given path.
|
||
|
||
Returns the catalog ID if it exists or was created successfully, otherwise returns an empty string.
|
||
"""
|
||
# TODO use python exposed API, (currently only C API is available))
|
||
head = (
|
||
"# This is an Asset Catalog Definition file for Blender.\n"
|
||
"#\n"
|
||
"# Empty lines and lines starting with `#` will be ignored.\n"
|
||
"# The first non-ignored line should be the version indicator.\n"
|
||
'# Other lines are of the format "UUID:catalog/path/for/assets:simple catalog name"\n'
|
||
"\n"
|
||
"VERSION 1\n"
|
||
)
|
||
|
||
# check if file exists in library, if not create it
|
||
# this is needed to assign asset to catalog, otherwise it will be assigned to "unc
|
||
cat_path = os.path.join(library_path, "blender_assets.cats.txt")
|
||
if not os.path.exists(cat_path):
|
||
try:
|
||
with open(cat_path, "w", encoding="utf-8") as f:
|
||
f.write(head)
|
||
except Exception as e:
|
||
traceback.print_exc()
|
||
return ""
|
||
# create file if it does not exists with uuid and name
|
||
# get all catalogs in the file, if there is one with same name, return its uuid
|
||
cats = {}
|
||
# read existing catalogs
|
||
with open(cat_path, "r", encoding="utf-8") as f:
|
||
for line in f:
|
||
line = line.strip()
|
||
if not line or line.startswith("#"):
|
||
continue
|
||
parts = line.split(":")
|
||
if len(parts) != 3:
|
||
continue
|
||
cat_uuid, cat_path_entry, _ = parts
|
||
cats[cat_path_entry] = cat_uuid
|
||
|
||
# use regex to found the library name
|
||
if catalog_path in cats:
|
||
return cats[catalog_path]
|
||
|
||
# create new catalog entry
|
||
new_uuid = str(uuid.uuid4())
|
||
cats[catalog_path] = new_uuid
|
||
|
||
# write new catalog entry to file
|
||
try:
|
||
with open(cat_path, "a", encoding="utf-8") as f:
|
||
f.write(f"{new_uuid}:{catalog_path}:{catalog_simple_name}\n")
|
||
return new_uuid
|
||
except Exception as e:
|
||
traceback.print_exc()
|
||
return ""
|
||
|
||
|
||
def _assign_asset_catalog(
|
||
data_block, asset_data: dict, blend_path: str | None = None
|
||
) -> None:
|
||
"""Assign the asset to a catalog based on its type and category hierarchy."""
|
||
if data_block is None or data_block.asset_data is None:
|
||
return
|
||
print("📁 assigning asset to catalog")
|
||
|
||
if not blend_path:
|
||
print("Asset catalog assignment skipped: blend path missing.")
|
||
return
|
||
|
||
library_dir = _library_dir_from_fpath(blend_path)
|
||
library_dir = os.path.abspath(bpy.path.abspath(library_dir))
|
||
print("Resolved library directory: '%s'" % library_dir)
|
||
if not os.path.exists(library_dir):
|
||
try:
|
||
os.makedirs(library_dir, exist_ok=True)
|
||
except Exception:
|
||
print(f"Asset catalog assignment skipped: cannot create '{library_dir}'.")
|
||
return
|
||
|
||
path_parts = _resolve_catalog_path_parts(asset_data)
|
||
print(f"Resolved catalog path parts: {path_parts}")
|
||
if not path_parts:
|
||
print(
|
||
"Asset catalog assignment skipped: could not resolve catalog path from asset data."
|
||
)
|
||
return
|
||
|
||
catalog_path = "/".join(path_parts)
|
||
catalog_simple_name = path_parts[-1]
|
||
|
||
print(
|
||
"Resolved catalog path: '%s' and simple name: '%s' for asset with type '%s'"
|
||
% (
|
||
catalog_path,
|
||
catalog_simple_name,
|
||
asset_data.get("assetType"),
|
||
)
|
||
)
|
||
catalog_id = _ensure_catalog_exists(library_dir, catalog_path, catalog_simple_name)
|
||
if not catalog_id:
|
||
print("Asset catalog assignment skipped: failed to create catalog entry.")
|
||
return
|
||
print(f"Assigning asset to catalog '{catalog_path}' with ID {catalog_id}")
|
||
asset_meta = data_block.asset_data
|
||
if hasattr(asset_meta, "catalog_id"):
|
||
try:
|
||
asset_meta.catalog_id = catalog_id
|
||
except AttributeError:
|
||
print("Asset catalog assignment skipped: catalog_id is read-only.")
|
||
else:
|
||
print(
|
||
"Asset catalog assignment skipped: asset_data does not have catalog_id attribute."
|
||
)
|
||
|
||
|
||
def unpack_asset(data):
|
||
"""Unpack asset data into the current Blender file.
|
||
|
||
This function handles unpacking textures, writing metadata,
|
||
applying previews, and assigning the asset to a catalog based on its type.
|
||
"""
|
||
asset_data = data["asset_data"]
|
||
|
||
# assume unpack is true
|
||
unpack = True
|
||
if data.get("prefs", {}).get("unpack_files") is False:
|
||
unpack = False
|
||
|
||
# assume write_metadata is true
|
||
write_metadata = True
|
||
if data.get("prefs", {}).get("write_asset_metadata") is False:
|
||
write_metadata = False
|
||
|
||
if unpack:
|
||
print("🗃️ unpacking asset")
|
||
resolution = get_resolution_from_file_path(bpy.data.filepath)
|
||
|
||
# TODO - passing resolution inside asset data might not be the best solution
|
||
tex_dir_path = paths.get_texture_directory(asset_data, resolution=resolution)
|
||
tex_dir_abs = bpy.path.abspath(tex_dir_path)
|
||
if not os.path.exists(tex_dir_abs):
|
||
try:
|
||
os.mkdir(tex_dir_abs)
|
||
except Exception as e:
|
||
traceback.print_exc()
|
||
|
||
bpy.data.use_autopack = False
|
||
for image in bpy.data.images:
|
||
if image.name == "Render Result":
|
||
continue # skip rendered images
|
||
|
||
# Keep per-packed-file paths (UDIM/sequence) so image.unpack writes all frames/tiles.
|
||
if len(image.packed_files) > 0:
|
||
unpack_paths = []
|
||
for pf in image.packed_files:
|
||
pf_path = get_texture_filepath(
|
||
tex_dir_path,
|
||
image,
|
||
resolution=resolution,
|
||
source_path=pf.filepath,
|
||
)
|
||
unpack_paths.append(pf_path)
|
||
pf.filepath = pf_path # bpy.path.abspath(pf_path)
|
||
|
||
image_path = get_texture_filepath(
|
||
tex_dir_path,
|
||
image,
|
||
resolution=resolution,
|
||
source_path=image.filepath,
|
||
)
|
||
image.filepath = image_path # bpy.path.abspath(image_path)
|
||
image.filepath_raw = image_path # bpy.path.abspath(image_path)
|
||
print(
|
||
f"🖼️ unpacking file: {image.name} - {image.filepath}, "
|
||
f"{len(unpack_paths)} packed file(s)"
|
||
)
|
||
image.unpack(method="WRITE_ORIGINAL")
|
||
else:
|
||
fp = get_texture_filepath(
|
||
tex_dir_path,
|
||
image,
|
||
resolution=resolution,
|
||
source_path=image.filepath,
|
||
)
|
||
print(f"🖼️ unpacking file: {image.name} - {image.filepath}, {fp}")
|
||
image.filepath = fp # bpy.path.abspath(fp)
|
||
image.filepath_raw = fp # bpy.path.abspath(fp)
|
||
|
||
# mark asset browser asset
|
||
print("🏷️ marking asset")
|
||
data_block = None
|
||
if asset_data["assetType"] in ("model", "printable"):
|
||
# Mark the main collection as the asset instead of the root object.
|
||
# When upload_bg.py prepares a model for upload it places ALL objects
|
||
# (including children) as direct members of a single named collection that
|
||
# is a direct child of the scene collection. If we mark only the root
|
||
# object, Blender's asset browser will import just that one object and
|
||
# its children are left behind, resulting in an empty appearing in the
|
||
# scene. Marking the collection lets Blender create a proper collection
|
||
# instance that shows every object in the hierarchy.
|
||
#
|
||
# upload_bg.py calls asset_mark() on the root object before uploading, so
|
||
# every downloaded .blend arrives with the root object already marked as an
|
||
# asset. Clear those object-level marks first so only the collection entry
|
||
# appears in the asset browser (no duplicates).
|
||
for ob in bpy.data.objects:
|
||
if ob.asset_data is not None:
|
||
ob.asset_clear()
|
||
|
||
scene_collection = bpy.context.scene.collection
|
||
main_collection = None
|
||
for col in scene_collection.children:
|
||
has_root_objects = any(
|
||
ob.parent is None and ob in bpy.context.visible_objects
|
||
for ob in col.objects
|
||
)
|
||
if has_root_objects:
|
||
main_collection = col
|
||
break
|
||
|
||
if main_collection is not None:
|
||
if bpy.app.version >= (3, 0, 0):
|
||
main_collection.asset_mark()
|
||
# Store asset_data on the collection so that collection-instance
|
||
# EMPTYs added via Blender's native asset browser can be identified
|
||
# as BlenderKit assets (rating, bookmarking, etc.).
|
||
main_collection["asset_data"] = _sanitize_for_idprops(asset_data)
|
||
data_block = main_collection
|
||
else:
|
||
# Fallback: no suitable collection found – mark root visible objects.
|
||
for ob in bpy.data.objects:
|
||
if ob.parent is None and ob in bpy.context.visible_objects:
|
||
if bpy.app.version >= (3, 0, 0):
|
||
ob.asset_mark()
|
||
data_block = ob
|
||
elif asset_data["assetType"] == "material":
|
||
for m in bpy.data.materials:
|
||
if bpy.app.version >= (3, 0, 0):
|
||
m.asset_mark()
|
||
data_block = m
|
||
elif asset_data["assetType"] == "scene":
|
||
if bpy.app.version >= (3, 0, 0):
|
||
bpy.context.scene.asset_mark()
|
||
data_block = bpy.context.scene
|
||
elif asset_data["assetType"] == "brush":
|
||
for b in bpy.data.brushes:
|
||
if hasattr(b, "asset_data") and b.asset_data is not None:
|
||
if bpy.app.version >= (3, 0, 0):
|
||
b.asset_mark()
|
||
data_block = b
|
||
elif asset_data["assetType"] == "nodegroup":
|
||
for ng in bpy.data.node_groups:
|
||
if hasattr(ng, "asset_data") and ng.asset_data is not None:
|
||
if (
|
||
hasattr(ng.asset_data, "copyright")
|
||
and ng.asset_data.copyright == "Blender Foundation"
|
||
or ng.asset_data.is_property_readonly("author")
|
||
):
|
||
continue # skip official node groups, they are not assets
|
||
if bpy.app.version >= (3, 0, 0):
|
||
ng.asset_mark()
|
||
data_block = ng
|
||
|
||
if bpy.app.version >= (3, 0, 0) and data_block is not None and write_metadata:
|
||
_write_metadata(data_block, asset_data)
|
||
_apply_asset_preview(data_block, asset_data)
|
||
_assign_asset_catalog(
|
||
data_block,
|
||
asset_data,
|
||
blend_path=data.get("fpath"),
|
||
)
|
||
|
||
# if this isn't here, blender crashes when saving file.
|
||
if bpy.app.version >= (3, 0, 0):
|
||
bpy.context.preferences.filepaths.file_preview_type = "NONE"
|
||
|
||
bpy.ops.wm.save_as_mainfile(filepath=bpy.data.filepath, compress=False)
|
||
# now try to delete the .blend1 file
|
||
try:
|
||
os.remove(bpy.data.filepath + "1")
|
||
except Exception as e:
|
||
traceback.print_exc()
|
||
|
||
bpy.ops.wm.quit_blender()
|
||
sys.exit()
|
||
|
||
|
||
def patch_imports(addon_module_name: str):
|
||
"""Patch the python configuration, so the relative imports work as expected. There are few problems to fix:
|
||
1. Script is not recognized as module which would break at relative import. We need to set __package__ = "blenderkit" for legacy addon.
|
||
Or __package__ = "bl_ext.user_default.blenderkit"/"bl_ext.blenderkit_com.blenderkit_com". Otherwise we would see:
|
||
from . import paths
|
||
ImportError: attempted relative import with no known parent package
|
||
2. External repository (e.g. blenderkit_com) is not available as we start with --factory-startup, we need to enable it.
|
||
We can add it as LOCAL repo as the add-on is installed and we do not care about updates or anything in this BG script. Otherwise we would see:
|
||
from . import paths
|
||
ModuleNotFoundError: No module named 'bl_ext.blenderkit_com'; 'bl_ext' is not a package
|
||
"""
|
||
print(f"- Setting __package__ = '{addon_module_name}'")
|
||
global __package__
|
||
__package__ = addon_module_name
|
||
|
||
if bpy.app.version < (4, 2, 0):
|
||
print(
|
||
f"- Skipping, Blender version {bpy.app.version} < (4,2,0), no need to handle repositories"
|
||
)
|
||
return
|
||
|
||
parts = addon_module_name.split(".")
|
||
if len(parts) != 3:
|
||
print("- Skipping, addon_module_name does not contain 3 parts")
|
||
return
|
||
|
||
bpy.ops.preferences.extension_repo_add( # type: ignore[attr-defined]
|
||
name=parts[1], type="LOCAL"
|
||
) # Local is enough
|
||
print(f"- Local repository {parts[1]} added")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
# args order must match the order in blenderkit/client/download.go:UnpackAsset()!
|
||
json_path = sys.argv[-2]
|
||
patch_imports(
|
||
sys.argv[-1]
|
||
) # will be something like: "bl_ext.user_default.blenderkit" or "bl_ext.blenderkit_com.blenderkit", or just "blenderkit" on Blender < 4.2
|
||
|
||
from . import paths
|
||
|
||
print(json_path)
|
||
with open(json_path, "r", encoding="utf-8") as f:
|
||
data = json.load(f)
|
||
unpack_asset(data)
|