# ##### 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 ##### import copy import logging import os import shutil import time import traceback from . import ( append_link, client_lib, client_tasks, paths, reports, resolutions, search, ui_panels, utils, ) bk_logger = logging.getLogger(__name__) import bpy from bpy.app.handlers import persistent from bpy.props import ( BoolProperty, EnumProperty, FloatVectorProperty, FloatProperty, IntProperty, StringProperty, ) download_tasks = {} def check_missing(): """Checks for missing files, and possibly starts re-download of these into the scene""" # missing libs: # TODO: put these into a panel and let the user decide if these should be downloaded. missing = [] for l in bpy.data.libraries: fp = l.filepath if fp.startswith("//"): fp = bpy.path.abspath(fp) if not os.path.exists(fp) and l.get("asset_data") is not None: missing.append(l) for l in missing: asset_data = l["asset_data"] downloaded = check_existing(asset_data, resolution=asset_data.get("resolution")) if downloaded: try: l.reload() except: download(l["asset_data"], redownload=True) else: download(l["asset_data"], redownload=True) def check_unused(): """Find assets that have been deleted from scene but their library is still present.""" # this is obviously broken. Blender should take care of the extra data automaticlaly # first clean up collections for c in bpy.data.collections: if len(c.all_objects) == 0 and c.get("is_blenderkit_asset"): bpy.data.collections.remove(c) return used_libs = [] for ob in bpy.data.objects: if ( ob.instance_collection is not None and ob.instance_collection.library is not None ): # used_libs[ob.instance_collection.name] = True if ob.instance_collection.library not in used_libs: used_libs.append(ob.instance_collection.library) for ps in ob.particle_systems: set = ps.settings if ( ps.settings.render_type == "GROUP" and ps.settings.instance_collection is not None and ps.settings.instance_collection.library not in used_libs ): used_libs.append(ps.settings.instance_collection) for l in bpy.data.libraries: if l not in used_libs and l.getn("asset_data"): bk_logger.info(f"attempt to remove this library: {l.filepath}") # have to unlink all groups, since the file is a 'user' even if the groups aren't used at all... for user_id in l.users_id: if type(user_id) == bpy.types.Collection: bpy.data.collections.remove(user_id) l.user_clear() @persistent def scene_save(context): """Do cleanup of blenderkit props and send a message to the server about assets used.""" # TODO this can be optimized by merging these 2 functions, since both iterate over all objects. if bpy.app.background: return check_unused() report_data = ( get_asset_usages() ) # TODO: FIX OR REMOVE THIS (now returns empty dict all the time) https://github.com/BlenderKit/blenderkit/issues/1013 if report_data != {}: client_lib.report_usages(report_data) @persistent def scene_load(context): """Restart broken downloads on scene load.""" check_missing() # global download_threads # download_threads = [] # commenting this out - old restore broken download on scene start. Might come back if downloads get recorded in scene # reset_asset_ids = {} # reset_obs = {} # for ob in bpy.context.scene.collection.objects: # if ob.name[:12] == 'downloading ': # obn = ob.name # # asset_data = ob['asset_data'] # # # obn.replace('#', '') # # if asset_data['id'] not in reset_asset_ids: # # if reset_obs.get(asset_data['id']) is None: # reset_obs[asset_data['id']] = [obn] # reset_asset_ids[asset_data['id']] = asset_data # else: # reset_obs[asset_data['id']].append(obn) # for asset_id in reset_asset_ids: # asset_data = reset_asset_ids[asset_id] # done = False # if check_existing(asset_data, resolution = should be here): # for obname in reset_obs[asset_id]: # downloader = s.collection.objects[obname] # done = try_finished_append(asset_data, # model_location=downloader.location, # model_rotation=downloader.rotation_euler) # # if not done: # downloading = check_downloading(asset_data) # if not downloading: # download(asset_data, downloaders=reset_obs[asset_id], delete=True) # check for group users that have been deleted, remove the groups /files from the file... # TODO scenes fixing part... download the assets not present on drive, # and erase from scene linked files that aren't used in the scene. # TODO: FIX OR REMOVE THIS BROKEN FUNCTION - remove empty dict all the time # https://github.com/BlenderKit/blenderkit/issues/1013 def get_asset_usages(): """Report the usage of assets to the server.""" sid = utils.get_scene_id() assets = {} asset_obs = [] scene = bpy.context.scene asset_usages = {} for ob in scene.collection.objects: if ob.get("asset_data") != None: asset_obs.append(ob) for ob in asset_obs: asset_data = ob["asset_data"] abid = asset_data["assetBaseId"] if assets.get(abid) is None: asset_usages[abid] = {"count": 1} assets[abid] = asset_data else: asset_usages[abid]["count"] += 1 # brushes for b in bpy.data.brushes: if b.get("asset_data") != None: abid = b["asset_data"]["assetBaseId"] asset_usages[abid] = {"count": 1} assets[abid] = b["asset_data"] # materials for ob in scene.collection.objects: for ms in ob.material_slots: m = ms.material if m is not None and m.get("asset_data") is not None: abid = m["asset_data"]["assetBaseId"] if assets.get(abid) is None: asset_usages[abid] = {"count": 1} assets[abid] = m["asset_data"] else: asset_usages[abid]["count"] += 1 assets_list = [] assets_reported = scene.get("assets reported", {}) new_assets_count = 0 for k in asset_usages.keys(): if k not in assets_reported.keys(): data = asset_usages[k] list_item = { "asset": k, "usageCount": data["count"], "proximitySet": data.get("proximity", []), } assets_list.append(list_item) new_assets_count += 1 if k not in assets_reported.keys(): assets_reported[k] = True scene["assets reported"] = assets_reported if new_assets_count == 0: bk_logger.debug("no new assets were added") return {} usage_report = {"scene": sid, "reportType": "save", "assetusageSet": assets_list} au = scene.get("assets used", {}) ad = scene.get("assets deleted", {}) ak = assets.keys() for k in au.keys(): if k not in ak: ad[k] = au[k] else: if k in ad: ad.pop(k) # scene['assets used'] = {} for k in ak: # rewrite assets used. scene["assets used"][k] = assets[k] return usage_report def udpate_asset_data_in_dicts(asset_data): """ updates asset data in all relevant dictionaries, after a threaded download task \ - where the urls were retrieved, and now they can be reused Parameters ---------- asset_data - data coming back from thread, thus containing also download urls """ data = asset_data.copy() del data[ "filesSize" ] # filesSize is not needed, causes troubles: github.com/BlenderKit/BlenderKit/issues/1601 scene = bpy.context.scene scene["assets used"] = scene.get("assets used", {}) scene["assets used"][asset_data["assetBaseId"]] = data # Get search results from history history_step = search.get_active_history_step() search_results = history_step.get("search_results") if not search_results: return for result in search_results: if result["assetBaseId"] != asset_data["assetBaseId"]: continue for file in asset_data["files"]: if not file.get("url"): continue for f1 in result["files"]: if f1["fileType"] != file["fileType"]: continue f1["url"] = file["url"] def assign_material(object, material, target_slot): """Assign material to either slot or GN node based on mapping""" if "material_mapping" in object: mapping = object["material_mapping"] target_info = mapping.get(str(target_slot)) if target_info: if target_info["type"] == "SLOT": # Regular material slot assignment if len(object.material_slots) == 0: object.data.materials.append(material) else: object.material_slots[target_info["index"]].material = material elif target_info["type"] == "GN": # Assign to GN Set Material node for modifier in object.modifiers: if ( modifier.type == "NODES" and modifier.node_group.name == target_info["tree_name"] ): node = modifier.node_group.nodes.get(target_info["node_name"]) if node and node.type == "SET_MATERIAL": node.inputs["Material"].default_value = material break # Stop after first matching node else: # Fall back to regular slot assignment if len(object.material_slots) == 0: object.data.materials.append(material) elif len(object.material_slots) > target_slot: object.material_slots[target_slot].material = material def append_asset(asset_data, **kwargs): # downloaders=[], location=None, """Link or append an asset to the scene based on its type and settings. This function handles the process of bringing an asset into the scene, supporting different asset types (model, material, brush, scene, hdr, etc.) and different import methods (link vs append). """ file_names = kwargs.get("file_paths") if file_names is None: file_names = paths.get_download_filepaths(asset_data, kwargs["resolution"]) ##### # how to do particle drop: # link the group we are interested in( there are more groups in File!!!! , have to get the correct one!) wm = bpy.context.window_manager user_preferences = bpy.context.preferences.addons[__package__].preferences user_preferences.download_counter += 1 if asset_data["assetType"] == "scene": sprops = wm.blenderkit_scene scene = append_link.append_scene( file_names[0], link=sprops.append_link == "LINK", fake_user=False ) if scene is not None: asset_main = scene if sprops.switch_after_append: bpy.context.window_manager.windows[0].scene = scene if asset_data["assetType"] == "hdr": hdr = append_link.load_HDR(file_name=file_names[0], name=asset_data["name"]) asset_main = hdr if asset_data["assetType"] in ("model", "printable"): downloaders = kwargs.get("downloaders") sprops = wm.blenderkit_models # TODO this is here because combinations of linking objects or appending groups are rather not-usefull if sprops.import_method == "LINK_COLLECTION": sprops.append_link = "LINK" sprops.import_as = "GROUP" else: sprops.append_link = "APPEND" sprops.import_as = "INDIVIDUAL" # copy for override al = sprops.append_link # set consistency for objects already in scene, otherwise this literally breaks blender :) ain, resolution = asset_in_scene(asset_data) # this is commented out since it already happens in start_download function. # if resolution: # kwargs['resolution'] = resolution # override based on history if ain is not False: if ain == "LINKED": al = "LINK" else: al = "APPEND" if asset_data["assetType"] == "model": source_parent = get_asset_in_scene(asset_data) if source_parent: asset_main, new_obs = duplicate_asset( source=source_parent, **kwargs ) asset_main.location = kwargs["model_location"] asset_main.rotation_euler = kwargs["model_rotation"] # this is a case where asset is already in scene and should be duplicated instead. # there is a big chance that the duplication wouldn't work perfectly(hidden or unselectable objects) # so here we need to check and return if there was success # also, if it was successful, no other operations are needed , basically all asset data is already ready from the original asset if new_obs: # update here assets rated/used because there might be new download urls? udpate_asset_data_in_dicts(asset_data) bpy.ops.ed.undo_push( "INVOKE_REGION_WIN", message="add %s to scene" % asset_data["name"], ) return # first get conditions for append link link = al == "LINK" # then append link if downloaders: for downloader in downloaders: # this cares for adding particle systems directly to target mesh, but I had to block it now, # because of the sluggishnes of it. Possibly re-enable when it's possible to do this faster? if ( "particle_plants" in asset_data["tags"] and kwargs["target_object"] != "" ): append_link.append_particle_system( file_names[-1], target_object=kwargs["target_object"], rotation=downloader["rotation"], link=False, name=asset_data["name"], ) return if link: asset_main, new_obs = append_link.link_collection( file_names[-1], location=downloader["location"], rotation=downloader["rotation"], link=link, name=asset_data["name"], parent=kwargs.get("parent"), collection=kwargs.get("target_collection", ""), ) else: asset_main, new_obs = append_link.append_objects( file_names[-1], location=downloader["location"], rotation=downloader["rotation"], link=link, name=asset_data["name"], parent=kwargs.get("parent"), collection=kwargs.get("target_collection", ""), ) if asset_main.type == "EMPTY" and link: bmin = asset_data["bbox_min"] bmax = asset_data["bbox_max"] size_min = min( 1.0, (bmax[0] - bmin[0] + bmax[1] - bmin[1] + bmax[2] - bmin[2]) / 3, ) asset_main.empty_display_size = size_min elif kwargs.get("model_location") is not None: if link: asset_main, new_obs = append_link.link_collection( file_names[-1], location=kwargs["model_location"], rotation=kwargs["model_rotation"], link=link, name=asset_data["name"], parent=kwargs.get("parent"), collection=kwargs.get("target_collection", ""), ) else: asset_main, new_obs = append_link.append_objects( file_names[-1], location=kwargs["model_location"], rotation=kwargs["model_rotation"], link=link, name=asset_data["name"], parent=kwargs.get("parent"), collection=kwargs.get("target_collection", ""), ) # scale Empty for assets, so they don't clutter the scene. if asset_main.type == "EMPTY" and link: bmin = asset_data["bbox_min"] bmax = asset_data["bbox_max"] size_min = min( 1.0, (bmax[0] - bmin[0] + bmax[1] - bmin[1] + bmax[2] - bmin[2]) / 3 ) asset_main.empty_display_size = size_min if link: group = asset_main.instance_collection lib = group.library lib["asset_data"] = asset_data elif asset_data["assetType"] == "brush": inscene = False for b in bpy.data.brushes: if b.blenderkit.id == asset_data["id"]: inscene = True brush = b break if not inscene: brush = append_link.append_brush( file_names[-1], link=False, fake_user=False ) thumbnail_name = asset_data["thumbnail"].split(os.sep)[-1] tempdir = paths.get_temp_dir("brush_search") thumbpath = os.path.join(tempdir, thumbnail_name) asset_thumbs_dir = paths.get_download_dirs("brush")[0] asset_thumb_path = os.path.join(asset_thumbs_dir, thumbnail_name) shutil.copy(thumbpath, asset_thumb_path) asset_blender_version = utils.asset_version_as_tuple(asset_data) # brushes from blender version < 3.5 have inverted texture bias # so we need to invert it here if asset_blender_version < (3, 5, 0): brush.texture_sample_bias = -brush.texture_sample_bias # re-mark as asset in blender version >= 4.3 # but only if asset comes from a version older than that if asset_blender_version < (4, 3, 0) and bpy.app.version >= (4, 3, 0): brush.asset_clear() brush.asset_mark() brush.icon_filepath = asset_thumb_path # set the brush active if bpy.context.view_layer.objects.active.mode == "SCULPT": if bpy.app.version < (4, 3, 0): bpy.context.tool_settings.sculpt.brush = brush else: bpy.ops.brush.asset_activate( relative_asset_identifier=f"Brush{os.sep}{brush.name}" ) elif ( bpy.context.view_layer.objects.active.mode == "TEXTURE_PAINT" ): # could be just else, but for future possible more types... if bpy.app.version < (4, 3, 0): bpy.context.tool_settings.image_paint.brush = brush else: bpy.ops.brush.asset_activate( relative_asset_identifier=f"Brush{os.sep}{brush.name}" ) # TODO add grease pencil brushes! # bpy.context.tool_settings.image_paint.brush = brush asset_main = brush elif asset_data["assetType"] == "material": inscene = False sprops = wm.blenderkit_mat for g in bpy.data.materials: if g.blenderkit.id == asset_data["id"]: inscene = True material = g break if not inscene: link = sprops.import_method == "LINK" material = append_link.append_material( file_names[-1], matname=asset_data["name"], link=link, fake_user=False ) target_object = bpy.data.objects[kwargs["target_object"]] assign_material(target_object, material, kwargs["material_target_slot"]) asset_main = material elif asset_data["assetType"] == "nodegroup": inscene = False sprops = wm.blenderkit_nodegroup for g in bpy.data.node_groups: if hasattr(g, "blenderkit") and g.blenderkit.id == asset_data["id"]: inscene = True nodegroup = g break if not inscene: nodegroup, added_to_editor = append_link.append_nodegroup( file_names[-1], nodegroupname=asset_data["name"], link=False, fake_user=False, node_x=kwargs.get("node_x", 0), node_y=kwargs.get("node_y", 0), ) # Show a message to the user if the node was not added to an editor if not added_to_editor: reports.add_report( f"Node group '{nodegroup.name}' was added to the Blender file but no suitable node editor was found to place the node.", type="INFO", ) else: # If nodegroup was already in scene, we still want to try to add it to the editor _, added_to_editor = append_link.append_nodegroup( file_names[-1], nodegroupname=asset_data["name"], link=False, fake_user=False, node_x=kwargs.get("node_x", 0), node_y=kwargs.get("node_y", 0), ) bk_logger.info(f"appended nodegroup: {nodegroup}") asset_main = nodegroup asset_data["resolution"] = kwargs["resolution"] udpate_asset_data_in_dicts(asset_data) update_asset_metadata(asset_main, asset_data) bpy.ops.ed.undo_push( "INVOKE_REGION_WIN", message="add %s to scene" % asset_data["name"] ) # moving reporting to on save. # report_use_success(asset_data['id']) def update_asset_metadata(asset_main, asset_data): """Update downloaded asset_data on the asset_main placed in the scene.""" asset_main.blenderkit.asset_base_id = asset_data["assetBaseId"] asset_main.blenderkit.id = asset_data["id"] asset_main.blenderkit.description = asset_data["description"] asset_main.blenderkit.tags = utils.list2string(asset_data["tags"]) # BUG #554: categories needs update, but are not in asset_data asset_main["asset_data"] = ( asset_data # TODO remove this??? should write to blenderkit Props? ) def replace_resolution_linked(file_paths, asset_data): """Replace one asset resolution for another. This is the much simpler case. - Find the library. - Replace the path and name of the library, reload. """ file_name = os.path.basename(file_paths[-1]) for l in bpy.data.libraries: if not l.get("asset_data"): continue if not l["asset_data"]["assetBaseId"] == asset_data["assetBaseId"]: continue bk_logger.debug("try to re-link library") if not os.path.isfile(file_paths[-1]): bk_logger.debug("library file doesnt exist") break l.filepath = os.path.join(os.path.dirname(l.filepath), file_name) l.name = file_name udpate_asset_data_in_dicts(asset_data) def replace_resolution_appended(file_paths, asset_data, resolution): """In this case the texture paths need to be replaced. - Find the file path pattern that is present in texture paths. - Replace the pattern with the new one. """ all_patterns = [] for suff in paths.resolution_suffix.values(): pattern = f"{asset_data['id']}{os.sep}textures{suff}{os.sep}" all_patterns.append(pattern) new_pattern = f"{asset_data['id']}{os.sep}textures{paths.resolution_suffix[resolution]}{os.sep}" # replace the pattern with the new one. for i in bpy.data.images: for old_pattern in all_patterns: if i.filepath.find(old_pattern) > -1: fp = i.filepath.replace(old_pattern, new_pattern) fpabs = bpy.path.abspath(fp) if not os.path.exists(fpabs): # this currently handles .png's that have been swapped to .jpg's during resolution generation process. # should probably also handle .exr's and similar others. # bk_logger.debug('need to find a replacement') base, ext = os.path.splitext(fp) if resolution == "blend" and i.get("original_extension"): fp = base + i.get("original_extension") elif ext in (".png", ".PNG"): fp = base + ".jpg" i.filepath = fp i.filepath_raw = fp # bpy.path.abspath(fp) for pf in i.packed_files: pf.filepath = fp i.reload() udpate_asset_data_in_dicts(asset_data) # TODO: keep this until we check resolution replacement and other features from this one are supported in daemon. # @bpy.app.handlers.persistent # def download_timer(): # # TODO might get moved to handle all blenderkit stuff, not to slow down. # ''' # check for running and finished downloads. # Running downloads get checked for progress which is passed to UI. # Finished downloads are processed and linked/appended to scene. # ''' # global download_threads # # utils.p('start download timer') # # # bk_logger.debug('timer download') # print(len(download_threads)) # if len(download_threads) == 0: # # utils.p('end download timer') # # return 2 # s = bpy.context.scene # # for threaddata in download_threads: # t = threaddata[0] # asset_data = threaddata[1] # tcom = threaddata[2] # # progress_bars = [] # downloaders = [] # # if t.is_alive(): # set downloader size # sr = global_vars.DATA.get('search results') # if sr is not None: # for r in sr: # if asset_data['id'] == r['id']: # r['downloaded'] = 0.5 # tcom.progress # if not t.is_alive(): # if tcom.error: # sprops = utils.get_search_props() # sprops.report = tcom.report # download_threads.remove(threaddata) # # utils.p('end download timer') # return # # file_paths = paths.get_download_filepaths(asset_data, tcom.passargs['resolution']) # if len(file_paths) == 0: # bk_logger.debug('library names not found in asset data after download') # download_threads.remove(threaddata) # break # # wm = bpy.context.window_manager # # at = asset_data['assetType'] # if ((bpy.context.mode == 'OBJECT' and \ # (at == 'model' or at == 'material'))) \ # or ((at == 'brush') \ # and wm.get('appendable') == True) or at == 'scene' or at == 'hdr': # # don't do this stuff in editmode and other modes, just wait... # download_threads.remove(threaddata) # # # duplicate file if the global and subdir are used in prefs # if len(file_paths) == 2: # todo this should try to check if both files exist and are ok. # utils.copy_asset(file_paths[0], file_paths[1]) # # shutil.copyfile(file_paths[0], file_paths[1]) # # bk_logger.debug('appending asset') # # progress bars: # # # we need to check if mouse isn't down, which means an operator can be running. # # Especially for sculpt mode, where appending a brush during a sculpt stroke causes crasehes # # # # if tcom.passargs.get('redownload'): # # handle lost libraries here: # for l in bpy.data.libraries: # if l.get('asset_data') is not None and l['asset_data']['id'] == asset_data['id']: # l.filepath = file_paths[-1] # l.reload() # # if tcom.passargs.get('replace_resolution'): # # try to relink # # HDRs are always swapped, so their swapping is handled without the replace_resolution option # # ain, resolution = asset_in_scene(asset_data) # # if ain == 'LINKED': # replace_resolution_linked(file_paths, asset_data) # # # elif ain == 'APPENDED': # replace_resolution_appended(file_paths, asset_data, tcom.passargs['resolution']) # # # # else: # done = try_finished_append(asset_data, **tcom.passargs) # if not done: # at = asset_data['assetType'] # tcom.passargs['retry_counter'] = tcom.passargs.get('retry_counter', 0) + 1 # download(asset_data, **tcom.passargs) # # if global_vars.DATA['search results'] is not None and done: # for sres in global_vars.DATA['search results']: # if asset_data['id'] == sres['id']: # sres['downloaded'] = 100 # # bk_logger.debug('finished download thread') # # utils.p('end download timer') # # return .5 def handle_download_task(task: client_tasks.Task): """Handle incoming task information. Update progress. Print messages. Fire post-download functions. """ global download_tasks if task.status == "finished": # we still write progress since sometimes the progress bars wouldn't end on 100% download_write_progress(task.task_id, task) # try to parse, in some states task gets returned to be pending (e.g. in editmode) try: download_post(task) download_tasks.pop(task.task_id) return except Exception as e: bk_logger.exception(f"Asset appending/linking has failed") task.message = f"Append failed: {e}" task.status = "error" if task.status == "error": reports.add_report(task.message, type="ERROR") download_tasks.pop(task.task_id) else: download_write_progress(task.task_id, task) def clear_downloads(): """Cancel all downloads.""" global download_tasks download_tasks.clear() def download_write_progress(task_id, task): """writes progress from client_lib reports to addon tasks list""" global download_tasks task_addon = download_tasks.get(task.task_id) if task_addon is None: bk_logger.warning(f"couldn't write download progress to {task.progress}") return task_addon["progress"] = task.progress task_addon["text"] = task.message # go through search results to write progress to display progress bars sr = search.get_search_results() if sr is not None: for r in sr: if task.data["asset_data"]["id"] == r["id"]: r["downloaded"] = task.progress # TODO might get moved to handle all blenderkit stuff, not to slow down. def download_post(task: client_tasks.Task) -> None: """Check for running and finished downloads. Running downloads get checked for progress which is passed to UI. Finished downloads are processed and linked/appended to scene. Finished downloads can become pending tasks, if Blender isn't ready to append the files. """ global download_tasks orig_task = download_tasks.get(task.task_id) if orig_task is None: return # What does this mean? Is it a failure? Or expected? file_paths = task.result.get("file_paths", []) if file_paths == []: bk_logger.info("library names not found in asset data after download") # SUPER IMPORTANT CODE HERE # Writing this back into the asset file data means it can be reused in the scene or file. rf = paths.get_res_file(task.data["asset_data"], task.data["resolution"])[0] rf["file_name"] = file_paths[-1] rf["url"] = task.result.get("url") wm = bpy.context.window_manager at = task.data["asset_data"]["assetType"] # don't do this stuff in editmode and other modes, just wait... # we don't remove the task before it's actually possible to remove it. if bpy.context.mode != "OBJECT" and (at == "model" or at == "material"): # try to switch to object mode - if it's not possible, propagate exception higher up bpy.ops.object.mode_set(mode="OBJECT") # don't append brushes if not in sculpt/paint mode - WHY? if (at == "brush") and wm.get("appendable") == False: # type: ignore # try to switch to sculpt mode - if it's not possible, propagate exception higher up bpy.ops.object.mode_set(mode="SCULPT") # duplicate file if the global and subdir are used in prefs if ( len(file_paths) == 2 ): # todo this should try to check if both files exist and are ok. utils.copy_asset(file_paths[0], file_paths[1]) # shutil.copyfile(file_paths[0], file_paths[1]) bk_logger.debug("appending asset") # progress bars: # we need to check if mouse isn't down, which means an operator can be running. # Especially for sculpt mode, where appending a brush during a sculpt stroke causes crasehes # # TODO use redownload in data, this is used for downloading/ copying missing libraries. if task.data.get("redownload"): # handle lost libraries here: for l in bpy.data.libraries: # type: ignore if not isinstance(l, bpy.types.Library): continue if ( l.get("asset_data") is not None # type: ignore[attr-defined] and l["asset_data"]["id"] == task.data["asset_data"]["id"] # type: ignore[index] ): l.filepath = file_paths[-1] l.reload() if task.data.get("replace_resolution"): # try to relink # HDRs are always swapped, so their swapping is handled without the replace_resolution option ain, _ = asset_in_scene(task.data["asset_data"]) if ain == "LINKED": replace_resolution_linked(file_paths, task.data["asset_data"]) elif ain == "APPENDED": replace_resolution_appended( file_paths, task.data["asset_data"], task.data["resolution"] ) return orig_task.update(task.data) try_finished_append( file_paths=file_paths, **task.data ) # exception is handled in calling function # TODO add back re-download capability for deamon - used for lost libraries # tcom.passargs['retry_counter'] = tcom.passargs.get('retry_counter', 0) + 1 # download(asset_data, **tcom.passargs) # utils.p('end download timer') return def download(asset_data, **kwargs): """Init download data and request task from BlenderKit-Client.""" if kwargs.get("retry_counter", 0) > 3: sprops = utils.get_search_props() report = f"Maximum retries exceeded for {asset_data['name']}" sprops.report = report reports.add_report(report, type="ERROR") bk_logger.debug(sprops.report) return # incoming data can be either directly dict from python, or blender id property # (recovering failed downloads on reload) if type(asset_data) == dict: asset_data = copy.deepcopy(asset_data) else: asset_data = asset_data.to_dict() # inject resolution into prefs. prefs = utils.get_preferences_as_dict() prefs["resolution"] = kwargs.get("resolution", "original") data = { "asset_data": asset_data, "PREFS": prefs, "progress": 0, "text": f'downloading {asset_data["name"]}', } for arg, value in kwargs.items(): data[arg] = value data["PREFS"]["scene_id"] = utils.get_scene_id() data["download_dirs"] = paths.get_download_dirs(asset_data["assetType"]) if "downloaders" in kwargs: data["downloaders"] = kwargs["downloaders"] response = client_lib.asset_download(data) download_tasks[response["task_id"]] = data def handle_bkclientjs_get_asset(task: client_tasks.Task): """Handle incoming bkclientjs/get_asset task. User asked for download in online gallery. How it goes: 1. Webpage tries to connect to Client, gets data about connected Softwares 2. User choosed Blender with appID of this Blender 2. Client gets asset data from API 3. Client creates finished task bkclientjs/get_asset containing asset data 4. We handle the task in here 5. We request the download of the asset as if user has clicked it inside Blender TODO: #1262Implement append to universal search results instead. """ pass """ UNUSED CODE for direct download: prefs = utils.get_preferences_as_dict() prefs["resolution"] = task.result["resolution"] prefs["scene_id"] = utils.get_scene_id() download_dirs = paths.get_download_dirs(task.result["asset_data"]["assetType"]) data = { "asset_data": task.result["asset_data"], "download_dirs": download_dirs, "PREFS": prefs, "progress": 0, "text": f'Getting asset {task.result["asset_data"]["name"]}', "downloaders": [{'location': (0.0, 0.0, 0.0), 'rotation': (0.0, 0.0, 0.0)}], "cast_parent": "", "target_object": task.result["asset_data"]["name"], "material_target_slot": 0, "model_location": (0.0, 0.0, 0.0), "model_rotation": (0.0, 0.0, 0.0), "replace": False, "replace_resolution": False, "resolution": task.result["resolution"], } response = client_lib.asset_download(data) download_tasks[response["task_id"]] = data """ def check_downloading(asset_data, **kwargs) -> bool: """Check if the asset is already being downloaded. If not, return False. If yes, just make a progress bar with downloader object and return True. """ global download_tasks downloading = False for _, task in download_tasks.items(): p_asset_data = task["asset_data"] if p_asset_data["id"] == asset_data["id"]: at = asset_data["assetType"] if at in ("model", "material"): downloader = { "location": kwargs["model_location"], "rotation": kwargs["model_rotation"], } task["downloaders"].append(downloader) downloading = True return downloading def check_existing(asset_data, resolution="blend", can_return_others=False): """Check if the object exists on the hard drive.""" if asset_data.get("files") == None: return False # this is because of some very odl files where asset data had no files structure. file_names = paths.get_download_filepaths( asset_data, resolution, can_return_others=can_return_others ) if len(file_names) == 0: return False if len(file_names) == 2: # TODO this should check also for failed or running downloads. # If download is running, assign just the running thread. if download isn't running but the file is wrong size, # delete file and restart download (or continue downoad? if possible.) if os.path.isfile(file_names[0]): # and not os.path.isfile(file_names[1]) utils.copy_asset(file_names[0], file_names[1]) elif not os.path.isfile(file_names[0]) and os.path.isfile( file_names[1] ): # only in case of changed settings or deleted/moved global dict. utils.copy_asset(file_names[1], file_names[0]) if os.path.isfile(file_names[0]): return True return False def try_finished_append(asset_data, **kwargs): """Try to append asset, if not successfully delete source files. This means probably wrong download, so download should restart. Returns True if successful, False if file_names are empty or file_names[-1] is not file. Returns Exception if append_asset() failed. """ file_paths = kwargs.get("file_paths") if file_paths is None or len(file_paths) == 0: file_paths = paths.get_download_filepaths(asset_data, kwargs["resolution"]) bk_logger.debug("try to append already existing asset") if len(file_paths) == 0: raise utils.BlenderkitAppendException("No file_paths found") if not os.path.isfile(file_paths[-1]): raise utils.BlenderkitAppendException( f"Library file does not exist: {file_paths[-1]}" ) kwargs["name"] = asset_data["name"] try: append_asset(asset_data, **kwargs) except Exception as e: # TODO: this should distinguish if the appending failed (wrong file) # or something else happened (shouldn't delete the files) for file_path in file_paths: try: os.remove(file_path) except Exception as e1: bk_logger.error(f"removing file {file_path} failed: {e1}") raise e # Update downloaded status in search results sr = search.get_search_results() if sr is None: return for sres in sr: if asset_data["id"] != sres["id"]: continue sres["downloaded"] = 100 def get_asset_in_scene(asset_data): """tries to find an appended copy of particular asset and duplicate it - so it doesn't have to be appended again.""" for ob in bpy.context.scene.objects: ad1 = ob.get("asset_data") if not ad1: continue if ad1.get("assetBaseId") == asset_data["assetBaseId"]: return ob return None def check_all_visible(obs): """checks all objects are visible, so they can be manipulated/copied.""" for ob in obs: if not ob.visible_get(): return False return True def check_selectible(obs): """checks if all objects can be selected and selects them if possible. this isn't only select_hide, but all possible combinations of collections e.t.c. so hard to check otherwise. """ for ob in obs: ob.select_set(True) if not ob.select_get(): return False return True def duplicate_asset( source, **kwargs ) -> tuple[bpy.types.Object, list[bpy.types.Object]]: """ Duplicate asset when it's already appended in the scene, so that blender's append doesn't create duplicated data. """ bk_logger.debug("duplicate asset instead") # we need to save selection sel = utils.selection_get() try: bpy.ops.object.select_all(action="DESELECT") except Exception as e: reports.add_report( f"duplicate_asset: {str(e)}", 3, type="ERROR", ) raise e # check visibility obs = utils.get_hierarchy(source) if not check_all_visible(obs): return None, [] # check selectability and select in one run if not check_selectible(obs): return None, [] # duplicate the asset objects bpy.ops.object.duplicate(linked=True) nobs = bpy.context.selected_objects[:] # get asset main object for ob in nobs: if ob.parent not in nobs: asset_main = ob break # in case of replacement,there might be a paarent relationship that can be restored if kwargs.get("parent"): parent = bpy.data.objects[kwargs["parent"]] asset_main.parent = ( parent # even if parent is None this is ok without if condition ) else: asset_main.parent = None # restore original selection utils.selection_set(sel) return asset_main, nobs def asset_in_scene(asset_data): """checks if the asset is already in scene. If yes, modifies asset data so the asset can be reached again.""" scene = bpy.context.scene assets_used = scene.get("assets used", {}) base_id = asset_data["assetBaseId"] if base_id not in assets_used.keys(): return False, None ad = assets_used[base_id] if not ad.get("files"): return False, None for fi in ad["files"]: if fi.get("file_name") == None: continue for fi1 in asset_data["files"]: if fi["fileType"] != fi1["fileType"]: continue fi1["file_name"] = fi["file_name"] fi1["url"] = fi["url"] # browse all collections since linked collections can have same name. if asset_data["assetType"] in ("model", "printable"): for c in bpy.data.collections: if c.name != ad["name"]: continue # there can also be more linked collections with same name, we need to check base_id. if c.library is None: continue if not c.library.get("asset_data"): continue if ( c.library and c.library["asset_data"].get("assetBaseId") == base_id ): bk_logger.info("asset found linked in the scene") return "LINKED", ad.get("resolution") elif asset_data["assetType"] == "material": for m in bpy.data.materials: if not m.get("asset_data"): continue if m.library and m["asset_data"].get("assetBaseId") == base_id: bk_logger.info("asset found linked in the scene") return "LINKED", ad.get("resolution") bk_logger.info("asset found appended in the scene") return "APPENDED", ad.get("resolution") return False, None def start_download(asset_data, **kwargs) -> bool: """Start download of an asset. But first check if the asset is not already in scene. Or if file is not being downloaded already. Return true if new download was started. Otherwise return false. """ # first check if the asset is already in scene. We can use that asset without checking with server ain, _ = asset_in_scene(asset_data) # quota_ok = ain is not False # if resolution: # kwargs['resolution'] = resolution # otherwise, check on server if check_downloading(asset_data, **kwargs): return False if ain and not kwargs.get("replace_resolution"): # this goes to appending asset - where it should duplicate the original asset already in scene. bk_logger.info("try append or asset from drive without download") try: try_finished_append(asset_data, **kwargs) return False except Exception as e: bk_logger.info(f"Failed to append asset: {e}, continuing with download") if asset_data["assetType"] in ("model", "material"): downloader = { "location": kwargs["model_location"], "rotation": kwargs["model_rotation"], } download(asset_data, downloaders=[downloader], **kwargs) return True download(asset_data, **kwargs) return True asset_types = ( ("MODEL", "Model", "set of objects"), ("SCENE", "Scene", "scene"), ("HDR", "Hdr", "hdr"), ("MATERIAL", "Material", "any .blend Material"), ("TEXTURE", "Texture", "a texture, or texture set"), ("BRUSH", "Brush", "brush, can be any type of blender brush"), ("ADDON", "Addon", "addnon"), ) class BlenderkitKillDownloadOperator(bpy.types.Operator): """Kill a download""" bl_idname = "scene.blenderkit_download_kill" bl_label = "BlenderKit Kill Asset Download" bl_options = {"REGISTER", "INTERNAL"} task_id: StringProperty( # type: ignore[valid-type] name="Task ID", description="ID of the task to kill", default="" ) def execute(self, context): global download_tasks download_tasks.pop(self.task_id) client_lib.cancel_download(self.task_id) return {"FINISHED"} def available_resolutions_callback(self, context): """Checks active asset for available resolutions and offers only those available TODO: this currently returns always the same list of resolutions, make it actually work """ pat_items = ( ("512", "512", "", 1), ("1024", "1024", "", 2), ("2048", "2048", "", 3), ("4096", "4096", "", 4), ("8192", "8192", "", 5), ) items = [] for item in pat_items: if int(self.max_resolution) >= int(item[0]): items.append(item) items.append(("ORIGINAL", "Original", "", 6)) return items def has_asset_files(asset_data): """Check if asset has files.""" for f in asset_data["files"]: if f["fileType"] == "blend": return True return False class BlenderkitDownloadOperator(bpy.types.Operator): """Download and link asset to scene. Only link if asset already available locally""" bl_idname = "scene.blenderkit_download" bl_label = "Download" bl_options = {"REGISTER", "UNDO", "INTERNAL"} # asset_type: EnumProperty( # name="Type", # items=asset_types, # description="Type of download", # default="MODEL", # ) asset_index: IntProperty( # type: ignore[valid-type] name="Asset Index", description="asset index in search results", default=-1 ) asset_base_id: StringProperty( # type: ignore[valid-type] name="Asset base Id", description="Asset base id, used instead of search result index", default="", ) target_object: StringProperty( # type: ignore[valid-type] name="Target Object", description="Material or object target for replacement", default="", ) target_collection: StringProperty( # type: ignore[valid-type] name="Target Collection", description="Collection to place the asset in", default="", ) material_target_slot: IntProperty( # type: ignore[valid-type] name="Asset Index", description="asset index in search results", default=0 ) model_location: FloatVectorProperty(name="Asset Location", default=(0, 0, 0)) # type: ignore[valid-type] model_rotation: FloatVectorProperty(name="Asset Rotation", default=(0, 0, 0)) # type: ignore[valid-type] replace: BoolProperty( # type: ignore[valid-type] name="Replace", description="replace selection with the asset", default=False, options={"SKIP_SAVE"}, ) replace_resolution: BoolProperty( # type: ignore[valid-type] name="Replace resolution", description="replace resolution of the active asset", default=False, options={"SKIP_SAVE"}, ) invoke_resolution: BoolProperty( # type: ignore[valid-type] name="Replace resolution popup", description="pop up to ask which resolution to download", default=False, options={"SKIP_SAVE"}, ) invoke_scene_settings: BoolProperty( # type: ignore[valid-type] name="Scene import settings popup", description="pop up scene import settings", default=False, options={"SKIP_SAVE"}, ) use_resolution_operator: BoolProperty( # type: ignore[valid-type] name="Use operator resolution set by the operator", description="Use resolution set by the operator", default=False, options={"SKIP_SAVE"}, ) resolution: EnumProperty( # type: ignore[valid-type] items=available_resolutions_callback, default=6, description="Replace resolution", options={"SKIP_SAVE"}, ) # needs to be passed to the operator to not show all resolution possibilities max_resolution: IntProperty(name="Max resolution", description="", default=0) # type: ignore[valid-type] # has_res_0_5k: BoolProperty(name='512', # description='', default=False) cast_parent: StringProperty( # type: ignore[valid-type] name="Particles Target Object", description="", default="" ) node_x: FloatProperty( # type: ignore[valid-type] name="Node X Position", description="X position to place the node group in node editor", default=0.0, ) node_y: FloatProperty( # type: ignore[valid-type] name="Node Y Position", description="Y position to place the node group in node editor", default=0.0, ) # close_window: BoolProperty(name='Close window', # description='Try to close the window below mouse before download', # default=False) # @classmethod # def poll(cls, context): # return bpy.context.window_manager.BlenderKitModelThumbnails is not '' tooltip: bpy.props.StringProperty( # type: ignore[valid-type] default="Download and link asset to scene. Only link if asset already available locally" ) @classmethod def description(cls, context, properties): return properties.tooltip def get_asset_data(self, context): """Get asset data - it can come from scene, or from search results.""" scene = bpy.context.scene if self.asset_index > -1: # Getting the data from search results sr = search.get_search_results() asset_data = sr[ self.asset_index ] # TODO CHECK ALL OCCURRENCES OF PASSING BLENDER ID PROPS TO THREADS! asset_base_id = asset_data["assetBaseId"] return asset_data # Getting the data from scene asset_base_id = self.asset_base_id assets_used = scene.get("assets used", {}) if ( asset_base_id in assets_used ): # already used assets have already download link and especially file link. asset_data = scene["assets used"][asset_base_id].to_dict() return asset_data # when not in scene nor in search results, we need to get it from the server params = {"asset_base_id": self.asset_base_id} preferences = bpy.context.preferences.addons[__package__].preferences results = search.get_search_simple( params, page_size=1, max_results=1, api_key=preferences.api_key ) asset_data = search.parse_result(results[0]) return asset_data def execute(self, context): preferences = bpy.context.preferences.addons[__package__].preferences self.asset_data = self.get_asset_data(context) if not has_asset_files(self.asset_data): msg = f"Asset {self.asset_data['displayName']} has no files. Author should reupload the asset." reports.add_report(msg, type="ERROR") return {"CANCELLED"} asset_type = self.asset_data["assetType"] if ( (asset_type == "model" or asset_type == "material") and (bpy.context.mode != "OBJECT") and (bpy.context.view_layer.objects.active is not None) ): bpy.ops.object.mode_set(mode="OBJECT") # either settings resolution is used, or the one set by operator. # all operator calls need to set use_resolution_operator True if they want to define/swap resolution if not self.use_resolution_operator: resolution = preferences.resolution else: resolution = self.resolution resolution = resolutions.resolution_props_to_server[resolution] if self.replace: # cleanup first, assign later. obs = utils.get_selected_replace_adepts() for ob in obs: if self.asset_base_id != "": # this is for a case when replace is called from a panel, # this uses active object as replacement source instead of target. if ob.get("asset_data") is not None and ( ob["asset_data"]["assetBaseId"] == self.asset_base_id and ob["asset_data"]["resolution"] == resolution ): continue parent = ob.parent if parent: parent = ( ob.parent.name ) # after this, parent is either name or None. kwargs = { "cast_parent": self.cast_parent, "target_object": ob.name, "target_collection": self.target_collection, "material_target_slot": ob.active_material_index, "model_location": tuple(ob.matrix_world.translation), "model_rotation": tuple(ob.matrix_world.to_euler()), "replace": True, "replace_resolution": False, "parent": parent, "resolution": resolution, "node_x": self.node_x, "node_y": self.node_y, } bk_logger.debug( f"Replace kwargs with target_collection={kwargs['target_collection']}" ) # TODO - move this After download, not before, so that the replacement utils.delete_hierarchy(ob) start_download(self.asset_data, **kwargs) return {"FINISHED"} # replace resolution needs to replace all instances of the resolution in the scene # and deleting originals has to be thus done after the downlaod kwargs = { "cast_parent": self.cast_parent, "target_object": self.target_object, "target_collection": self.target_collection, "material_target_slot": self.material_target_slot, "model_location": tuple(self.model_location), "model_rotation": tuple(self.model_rotation), "replace": False, "replace_resolution": self.replace_resolution, "resolution": resolution, "node_x": self.node_x, "node_y": self.node_y, } bk_logger.debug( f"Final kwargs with target_collection={kwargs['target_collection']}" ) start_download(self.asset_data, **kwargs) return {"FINISHED"} def draw(self, context): # this timer is there to not let double clicks thorugh the popups down to the asset bar. ui_panels.last_time_dropdown_active = time.time() layout = self.layout if self.invoke_resolution: layout.prop(self, "resolution", expand=True, icon_only=False) if self.invoke_scene_settings: ui_panels.draw_scene_import_settings(self, context) def invoke(self, context, event): # if self.close_window: # context.window.cursor_warp(event.mouse_x-1000, event.mouse_y - 1000); wm = context.window_manager # only make a pop up in case of switching resolutions if self.invoke_resolution: self.asset_data = self.get_asset_data(context) preferences = bpy.context.preferences.addons[__package__].preferences # set initial resolutions enum activation if preferences.resolution != "ORIGINAL" and int( preferences.resolution ) <= int(self.max_resolution): self.resolution = preferences.resolution elif int(self.max_resolution) > 0: self.resolution = str(self.max_resolution) else: self.resolution = "ORIGINAL" return wm.invoke_props_dialog(self) if self.invoke_scene_settings: return wm.invoke_props_dialog(self) # if self.close_window: # time.sleep(0.1) # context.region.tag_redraw() # time.sleep(0.1) # # context.window.cursor_warp(event.mouse_x, event.mouse_y); return self.execute(context) def register_download(): bpy.utils.register_class(BlenderkitDownloadOperator) bpy.utils.register_class(BlenderkitKillDownloadOperator) bpy.app.handlers.load_post.append(scene_load) bpy.app.handlers.save_pre.append(scene_save) def unregister_download(): bpy.utils.unregister_class(BlenderkitDownloadOperator) bpy.utils.unregister_class(BlenderkitKillDownloadOperator) bpy.app.handlers.load_post.remove(scene_load) bpy.app.handlers.save_pre.remove(scene_save)