def get_shot_from_name(keys=''): seq = keys.split(' ')[0] shot = keys.split(' ')[1] task = keys.split(' ')[3] current_scene = alc.scene_object() dict_ = {'company': current_scene.company, 'context': 'source', 'project': current_scene.project, 'scope': 'assets', 'seq': seq, 'shot': shot, 'task': task, 'user': '******', 'resolution': 'high' } path_object = alc.PathObject(dict_) path_object.set_attr(filename='%s_%s_%s.%s' % (path_object.seq, path_object.shot, path_object.task, current_scene.ext )) default_asset = path_object.latest_version() return (default_asset)
def get_asset_from_name(keys=''): name = keys.split(' ')[0] type = keys.split(' ')[1] if type in ['char', 'veh']: task = 'rig' else: task = 'mdl' current_scene = alc.scene_object() dict_ = {'company': current_scene.company, 'context': 'source', 'project': current_scene.project, 'scope': 'assets', 'seq': type, 'shot': name, 'task': task, 'user': '******', 'resolution': 'high' } path_object = alc.PathObject(dict_) path_object.set_attr(filename='%s_%s_%s.%s' % (path_object.seq, path_object.shot, path_object.task, current_scene.ext )) default_asset = path_object.latest_version() return (default_asset)
def unlink_asset(object): filepath = None try: libname = object.data.library except AttributeError: for lib in bpy.data.libraries: libname = object.instance_collection print('_________unlinking__________') print(object) if 'proxy' in object.name: name = object.name.split('_')[0] else: name = object.name obj = bpy.data.objects[name] if not libname: bpy.data.batch_remove(ids=([obj])) else: try: filepath = libname.library.filepath except AttributeError: pass if filepath and alc.PathObject(filepath).type == 'env': remove_linked_environment_dependencies(libname.library) bpy.data.batch_remove(ids=(libname, obj))
def get_items(self, context): from cgl.plugins.blender import alchemy as alc import os scene = alc.scene_object() project = alc.PathObject(scene.split_after('project')) char = project.copy(scope='assets', seq='char') assets = ['char', 'prop', 'lib', 'veh', 'env'] asset_dic = {} for asset in assets: asset_dic.update({asset: project.copy(scope='assets', seq=asset,branch = scene.branch,)}) list_base = [] list = [] for type in assets: if os.path.isdir(asset_dic[type].path_root): for i in os.listdir(asset_dic[type].path_root): list_base.append('{} {}'.format(i, type)) dictionary = {} for i in list_base: list.append(i.split(' ')[0]) dictionary = dict(map(str, x.split(' ')) for x in list_base) value = [('{} {}'.format(list[i], dictionary[list[i]]), '{} {}'.format(dictionary[list[i]], '{}'.format(list[i])), '') for i in range(len(list))] return (value)
def get_asset_from_name(keys=''): name = keys.split(' ')[0] type = keys.split(' ')[1] user = keys.split(' ')[2] task = 'mdl' current_scene = alc.scene_object() dict_ = { 'company': current_scene.company, 'context': 'source', 'project': current_scene.project, 'scope': 'assets', 'seq': type, 'shot': name, 'task': task, 'user': user, 'branch': current_scene.branch, 'variant': 'default', 'resolution': 'high' } path_object = alc.PathObject(dict_) path_object.set_attr(filename='%s_%s_%s.%s' % (path_object.seq, path_object.shot, path_object.task, current_scene.ext)) default_asset = path_object.latest_version() return (default_asset)
def get_task(self, context): scene = bpy.types.Scene.scene_enum path_object = alc.PathObject(get_asset_from_name(scene)) tasks = reorder_list(path_object.glob_project_element('task'), arg='rig') value = [(tasks[i], tasks[i], '') for i in range(len(tasks))] return (value)
def get_variant(self, context): scene = bpy.types.Scene.scene_enum path_object = alc.PathObject(get_asset_from_name(scene)) versions = path_object.glob_project_element('variant') version = versions.reverse() value = [(versions[i], versions[i], '') for i in range(len(versions))] return (value)
def get_users(self, context): scene = bpy.types.Scene.scene_enum path_object = alc.PathObject(get_asset_from_name(scene)) user_list = path_object.glob_project_element('user') if not user_list: path_object = path_object.copy(task='rig') user_list = path_object.glob_project_element('user') users = reorder_list(user_list, arg='publish') value = [(users[i], users[i], '') for i in range(len(users))] return (value)
def get_users(self, context): scene = bpy.types.Scene.scene_enum path_object = alc.PathObject(get_shot_from_name(scene)) users = os.listdir(path_object.split_after('variant')) for i in users: if i == 'publish': users.remove(i) users.insert(0, "publish") value = [(users[i], users[i], '') for i in range(len(users))] return (value)
def get_default_lighting(): current_scene = alc.scene_object() dict_ = { 'company': current_scene.company, 'context': 'source', 'project': current_scene.project, 'scope': 'shots', 'seq': 'DEFAULT_LIGHT_SETUP', 'shot': '0010', 'task': 'light', 'user': '******', 'resolution': 'high' } path_object = alc.PathObject(dict_) path_object.copy(set_proper_filename=True)
def get_default_camera(): current_scene = alc.scene_object() dict_ = { 'company': current_scene.company, 'context': 'source', 'project': current_scene.project, 'scope': 'shots', 'seq': 'DEFAULT_RIG_CHECK', 'shot': '0010', 'task': 'cam', 'user': '******', 'resolution': 'high' } path_object = alc.PathObject(dict_) path_object.set_attr( filename='%s_%s_%s.%s' % (path_object.seq, path_object.shot, path_object.task, 'blend')) default_camera = path_object.latest_version() print(default_camera.path_root) default_in_scene = False for group in bpy.data.node_groups: if path_object.filename in group.name: default_in_scene = True if not default_in_scene: alc.import_file(filepath=default_camera.path_root, type='CAMERA', linked=False, collection_name=path_object.filename_base) bpy.context.scene.collection.objects.link( bpy.data.objects[path_object.filename_base]) outFile = default_camera.copy(ext='json').path_root with open(outFile) as json_file: data = json.load(json_file) bpy.context.scene.frame_start = data['frame_start'] bpy.context.scene.frame_end = data['frame_end'] # return (default_camera)
def open_available_file(path_object): import os filename = alc.PathObject(path_object).copy(filename='') print(filename.path_root) found = False files = os.listdir(filename.path_root) print(files) if files: for file in files: if file.endswith('.blend') and not found: found = True print(path_object) new_file = filename.copy(filename=file).path_root os.rename(new_file, path_object) alc.open_file(path_object) else: alc.confirm_prompt(message='No file found')
def selected_path_object(): from pathlib import Path selection = bpy.context.selected_objects for obj in selection: if 'proxy' in obj.name: name = obj.name.split('_')[0] else: if '.' in obj.name: name = obj.name.split('.')[0] else: name = obj.name library = bpy.context.object.instance_collection.library library_path = bpy.path.abspath(library.filepath) filename = Path(bpy.path.abspath(library_path)).__str__() lumber_object = alc.PathObject(filename) lumber_object = lumber_object.copy(context='source') return lumber_object
def parent_linked_environment_assets(library): import os env = library bpy.ops.file.make_paths_absolute() env_path = alc.PathObject(env.filepath) env_layout = env_path.copy(ext='json').path_root asset_collection = create_collection('env') if os.path.isfile(env_layout): data = load_json(env_layout) env_object_collection = create_environment_objects_collection( env_path.asset) for i in data: name = data[i]['name'] print(44444444444) print(env_object_collection) move_to_collection(i, env_object_collection) print(env_path.asset) move_to_collection(env_path.asset, bpy.data.collections['env'])
def remove_linked_environment_dependencies(library): env = library bpy.ops.file.make_paths_absolute() env_path = alc.PathObject(env.filepath) env_layout = env_path.copy(ext='msd').path_root data = load_json(env_layout) for i in data: print(i) name = data[i]['name'] if i in bpy.data.objects: obj = bpy.data.objects[i] unlink_asset(obj) try: env_asset_collection = bpy.data.collections['{}_assets'.format(env_path.asset)] bpy.data.collections.remove(env_asset_collection) except KeyError: pass
def run(): view_layer = bpy.context.scene.objects bpy.ops.file.make_paths_absolute() reparent_collections(view_layer) parent_object(view_layer, 'cam', 'CAMERA') parent_object(view_layer, 'light', 'LIGHT') parent_object(view_layer, 'gpencil', 'GPENCIL') parent_object(view_layer, 'armature', 'ARMATURE') create_characters_collections() for lib in bpy.data.libraries: type = alc.PathObject(return_lib_path(lib)).type if type == 'env': print('________________________env library found:') print(lib) parent_linked_environment_assets(lib) bpy.ops.file.make_paths_relative()
def get_default_shader(): current_scene = alc.scene_object() dict = { 'company': current_scene.company, 'context': 'render', 'project': current_scene.project, 'branch': 'master', 'variant': 'default', 'scope': 'assets', 'seq': 'lib', 'shot': 'DEFAULTSHADER', 'task': 'shd', 'version': '000.001', 'user': '******', 'resolution': 'high', 'filename': 'lib_DEFAULTSHADER_shd', 'ext': 'blend' } path_object = alc.PathObject(dict) path_object = path_object.copy(set_proper_filename=True, latest=True) print(path_object.path_root) default_in_scene = False # for group in bpy.data.node_groups: # if 'DEFAULTSHADER' in group.name: # default_in_scene = True if not default_in_scene: from cgl.plugins.blender.tasks import shd from importlib import reload import os if os.path.isfile(path_object.path_root): reload(shd) shd.import_materials(path_object.path_root) else: print('NO DEFAULT SHADER FOUND')
def get_users(self, context): import os scene = bpy.types.Scene.scene_enum path_object = alc.PathObject(get_asset_from_name(scene)) print(path_object.path_root) user_list = path_object.glob_project_element('user') if not user_list: if path_object.type == 'char': path_object = path_object.copy(task='rig') user_list = path_object.glob_project_element('user') else: users = os.listdir(path_object.copy(task='mdl').split_after('task')) users = reorder_list(user_list, arg='publish') print(users) value = [(users[i], users[i], '') for i in range(len(users))] return (value)
def get_shot_from_name(keys=''): seq = keys.split(' ')[0] shot = keys.split(' ')[1] task = keys.split(' ')[2] user = keys.split(' ')[3] current_scene = alc.scene_object() dict_ = {'company': current_scene.company, 'context': 'source', 'project': current_scene.project, 'scope': 'shots', 'seq': seq, 'shot': shot, 'task': task, 'user': user, 'resolution': 'high' } path_object = alc.PathObject(dict_) default_asset = path_object.latest_version() return default_asset
def open_selected_library(): obj = bpy.context.active_object if 'proxy' in obj.name: name = obj.name.split('_')[0] else: if '.' in obj.name: name = obj.name.split('.')[0] else: name = obj.name library = bpy.data.collections[name].library libraryPath = bpy.path.abspath(library.filepath) filename = Path(bpy.path.abspath(libraryPath)).__str__() lumber_object = alc.PathObject(filename).copy(context = 'source') alc.save_file() import os os.startfile(lumber_object.path_root, 'open')
def get_items(self, context): from cgl.plugins.blender import alchemy as alc import os scene = alc.scene_object() project = alc.PathObject(scene.split_after('project')) char = project.copy(scope='assets', seq='char') assets = ['char', 'prop', 'lib', 'veh', 'env'] asset_dic = {} for asset in assets: asset_dic.update({asset: project.copy(scope='assets', seq=asset)}) type = 'char' characters = os.listdir(asset_dic['char'].path_root) dictionary = {key: 'char' for key in characters} type = 'prop' props = os.listdir(asset_dic[type].path_root) dictionary.update({key: type for key in props}) type = 'env' environment = os.listdir(asset_dic[type].path_root) dictionary.update({key: type for key in environment}) type = 'veh' vehicles = os.listdir(asset_dic[type].path_root) dictionary.update({key: type for key in vehicles}) list = characters + props + environment + vehicles print(dictionary) # list.append(os.listdir(asset_dic['prop'].path_root)) value = [('{} {}'.format(list[i], dictionary[list[i]]), '{} {}'.format(dictionary[list[i]], list[i]), '') for i in range(len(list))] return (value)
def get_asset_from_name(keys=''): import os name = keys.split(' ')[0] type = keys.split(' ')[1] user = keys.split(' ')[2] task = 'mdl' current_scene = alc.scene_object() dict_ = {'company': current_scene.company, 'context': 'source', 'project': current_scene.project, 'scope': 'assets', 'seq': type, 'shot': name, 'task': task, 'user': user, 'branch':current_scene.branch, 'resolution': 'high' } path_object = alc.PathObject(dict_) path_object.set_attr(filename='%s_%s_%s.%s' % (path_object.seq, path_object.shot, path_object.task, current_scene.ext )) default_asset = path_object.latest_version() if default_asset.type == 'char': default_asset = default_asset.copy(task='rig', set_proper_filename=True) if not os.path.isfile(default_asset.path_root): if default_asset.type == 'char': default_asset = path_object.copy(task='rig', set_proper_filename=True) else: default_asset = path_object.copy(task='mdl') # default_asset = default_asset.copy(task='rig', set_proper_filename=True) return (default_asset)
def run(): import os """ This run statement is what's executed when your button is pressed in blender. :return: """ object = bpy.context.object if object: library = get_lib_from_object(object) path = return_lib_path(library) path_object = alc.PathObject(path) json = path_object.copy(ext='json').path_root if os.path.isfile(json): read_layout(outFile=json) bpy.ops.object.setup_collections() else: alc.confirm_prompt(message='no layout file found') else: alc.confirm_prompt(message='please select an object')
def get_default_lighting(): current_scene = alc.scene_object() dict_ = { 'company': current_scene.company, 'context': 'source', 'project': current_scene.project, 'scope': 'shots', 'seq': 'DEFAULT_LIGHT_SETUP', 'shot': '0010', 'task': 'light', 'user': '******', 'resolution': 'high' } path_object = alc.PathObject(dict_) path_object.set_attr(filename='%s_%s_%s.%s' % (path_object.seq, path_object.shot, path_object.task, current_scene.ext)) default_light = path_object.latest_version() print(default_light.path_root) default_in_scene = False for collection in bpy.data.collections: if 'defautLightSet' in collection.name: default_in_scene = True if not default_in_scene: alc.import_file( filepath=default_light.path_root, collection_name=default_light.filename_base, linked=False, append=False, type='COLLECTION', ) bpy.context.scene.collection.children.link( bpy.data.collections[path_object.shot]) return (default_light)
def get_items(self, context): from cgl.plugins.blender import alchemy as alc import os scene = alc.scene_object() project = alc.PathObject(scene.split_after('project')) proj_shots = project.copy(scope='shots', context='source', branch=alc.scene_object().branch) print('_______________SHOTS___________') sequences = os.listdir(proj_shots.path_root) print(sequences) shots = [] for seq in sequences: # print(seq) seq_path = os.path.join(proj_shots.path_root, seq) if os.path.isdir(seq_path): # print(seq_path) list = os.listdir(seq_path) for shot in list: if os.path.isdir(os.path.join(seq_path, shot)): shot_dir = os.path.join(seq_path, shot) for task in os.listdir(shot_dir): if os.path.isdir(os.path.join(shot_dir, task)): shotid = '{} {} {}'.format(seq, shot, task) if '.json' not in shotid: shots.append((shotid, shotid, '')) # print(22222222222) print(shotid) return (shots)
def reparent_collections(view_layer): for obj in view_layer: if obj.instance_type == 'COLLECTION': if obj.instance_collection: collection = obj.instance_collection print(collection) print(collection.library) if collection.library: path_object = alc.PathObject(collection.library.filepath) if path_object.asset: print(path_object.root) create_collection(path_object.type) for collection in bpy.data.collections: if collection.name == path_object.type: # print(collection.name ) if collection not in obj.users_collection: try: collection.objects.link(obj) except RuntimeError: print( " Error: Could not link the object {} " .format(obj), "because one of it's collections is is linked." ) unlink_collections(obj, path_object.type) for collection in bpy.context.scene.collection.children: if len(collection.objects) < 1: print(collection.name) bpy.context.scene.collection.children.unlink(collection)