def main(): # Make sure BlenderPanda addon is enabled addon_utils.enable("BlenderPanda", persistent=True) #print(sys.argv) srcdir, dstdir = sys.argv[1], sys.argv[2] #print('Exporting:', srcdir) #print('Export to:', dstdir) for root, _dirs, files in os.walk(srcdir): for asset in files: src = os.path.join(root, asset) dst = src.replace(srcdir, dstdir).replace('.blend', '.bam') if not asset.endswith('.blend'): # Only convert blend files with pman_build stub continue if os.path.exists(dst) and os.stat(src).st_mtime <= os.stat(dst).st_mtime: # Don't convert up-to-date-files continue if asset.endswith('.blend'): print('Converting .blend file ({}) to .bam ({})'.format(src, dst)) try: os.makedirs(os.path.dirname(dst)) except FileExistsError: pass bpy.ops.wm.open_mainfile(filepath=src) bpy.ops.panda_engine.export_bam(filepath=dst, copy_images=False, skip_up_to_date=True)
def register(): # load dependency add-ons import addon_utils for addon_id in addon_dependencies: default_state, loaded_state = addon_utils.check(addon_id) if not loaded_state: addon_utils.enable(addon_id, default_set=False, persistent=True) # load BlenRig internal classes for c in armature_classes: bpy.utils.register_class(c) for c in alignment_classes: bpy.utils.register_class(c) for c in snapping_classes: bpy.utils.register_class(c) for c in body_picker_biped_classes: bpy.utils.register_class(c) for c in body_picker_quadruped_classes: bpy.utils.register_class(c) for c in face_picker_classes: bpy.utils.register_class(c) for c in blenrig_rigs_classes: bpy.utils.register_class(c) # BlenRig Props bpy.types.WindowManager.blenrig_5_props = bpy.props.PointerProperty(type = Blenrig_5_Props) # BlenRig Object Add Panel bpy.types.INFO_MT_armature_add.append(blenrig5_add_menu_func)
def reload_addons(do_reload=True, do_reverse=True): modules = addon_utils.modules({}) modules.sort(key=lambda mod: mod.__name__) addons = bpy.context.user_preferences.addons # first disable all for mod_name in list(addons.keys()): addon_utils.disable(mod_name) assert(bool(addons) == False) # Run twice each time. for i in (0, 1): for mod in modules: mod_name = mod.__name__ print("\tenabling:", mod_name) addon_utils.enable(mod_name) assert(mod_name in addons) for mod in addon_utils.modules({}): mod_name = mod.__name__ print("\tdisabling:", mod_name) addon_utils.disable(mod_name) assert(not (mod_name in addons)) # now test reloading if do_reload: imp.reload(sys.modules[mod_name]) if do_reverse: # in case order matters when it shouldnt modules.reverse()
def reload_addons(do_reload=True, do_reverse=True): modules = addon_utils.modules({}) modules.sort(key=lambda mod: mod.__name__) addons = bpy.context.user_preferences.addons # first disable all for mod_name in list(addons.keys()): addon_utils.disable(mod_name) assert (bool(addons) == False) # Run twice each time. for i in (0, 1): for mod in modules: mod_name = mod.__name__ print("\tenabling:", mod_name) addon_utils.enable(mod_name) assert (mod_name in addons) for mod in addon_utils.modules({}): mod_name = mod.__name__ print("\tdisabling:", mod_name) addon_utils.disable(mod_name) assert (not (mod_name in addons)) # now test reloading if do_reload: imp.reload(sys.modules[mod_name]) if do_reverse: # incase order matters when it shouldnt modules.reverse()
def set_default_parameters(): """ Loads and sets default parameters defined in DefaultConfig.py """ # Set default intrinsics CameraUtility.set_intrinsics_from_blender_params( DefaultConfig.fov, DefaultConfig.resolution_x, DefaultConfig.resolution_y, DefaultConfig.clip_start, DefaultConfig.clip_end, DefaultConfig.pixel_aspect_x, DefaultConfig.pixel_aspect_y, DefaultConfig.shift_x, DefaultConfig.shift_y, "FOV") CameraUtility.set_stereo_parameters( DefaultConfig.stereo_convergence_mode, DefaultConfig.stereo_convergence_distance, DefaultConfig.stereo_interocular_distance) # Init renderer RendererUtility.init() RendererUtility.set_samples(DefaultConfig.samples) addon_utils.enable("render_auto_tile_size") RendererUtility.toggle_auto_tile_size(True) # Set number of cpu cores used for rendering (1 thread is always used for coordination => 1 # cpu thread means GPU-only rendering) RendererUtility.set_cpu_threads(1) RendererUtility.set_denoiser(DefaultConfig.denoiser) RendererUtility.set_simplify_subdivision_render( DefaultConfig.simplify_subdivision_render) RendererUtility.set_light_bounces( DefaultConfig.diffuse_bounces, DefaultConfig.glossy_bounces, DefaultConfig.ao_bounces_render, DefaultConfig.max_bounces, DefaultConfig.transmission_bounces, DefaultConfig.transparency_bounces, DefaultConfig.volume_bounces)
def reload_addons(do_reload=True, do_reverse=True): modules = addon_modules_sorted() addons = bpy.context.user_preferences.addons disable_addons() # Run twice each time. for i in (0, 1): for mod in modules: mod_name = mod.__name__ print("\tenabling:", mod_name) addon_utils.enable(mod_name, default_set=True) assert (mod_name in addons) for mod in modules: mod_name = mod.__name__ print("\tdisabling:", mod_name) addon_utils.disable(mod_name) assert (not (mod_name in addons)) # now test reloading if do_reload: imp.reload(sys.modules[mod_name]) if do_reverse: # in case order matters when it shouldn't modules.reverse()
def register(): for mod in addon_utils.modules(): if mod.bl_info.get('name', (-1, -1, -1)) == "Rigify": if not addon_utils.check(mod.__name__)[1]: addon_utils.enable(mod.__name__, default_set=True, handle_error=None) for cls in classes: bpy.utils.register_class(cls) wm = bpy.context.window_manager kc = wm.keyconfigs.addon if kc: km = kc.keymaps.new(name="3D View", space_type="VIEW_3D") kmi = km.keymap_items.new("wm.call_menu", type="A", value="PRESS", shift=True, ctrl=True) kmi.properties.name = "RIGIFY_PARTS_MT_add_master_menu" addon_keymaps.append([km, kmi])
def register(): bpy.utils.register_module(__name__) addon_name = "proxy_refresh" addon_state = addon_utils.check( addon_name) # Returns: loaded_default, loaded_state addon_state_pr = addon_state[1] if not addon_state_pr: default_set = True # From addon_utils function persistent = True # From addon_utils function result = addon_utils.enable(addon_name, default_set, persistent) if result is None: # Add-on not found addon_state_pr = False addon_name = "addon_create_animation_scene" addon_state = addon_utils.check(addon_name) # loaded_default, loaded_state addon_state_acas = addon_state[1] if not addon_state_acas: default_set = True # From addon_utils function persistent = True # From addon_utils function result = addon_utils.enable(addon_name, default_set, persistent) if result is None: # Add-on not found addon_state_acas = False addon_name = "tangent_animation_outliner" addon_state = addon_utils.check(addon_name) # loaded_default, loaded_state addon_state_acas = addon_state[1] if not addon_state_acas: default_set = True # From addon_utils function persistent = True # From addon_utils function result = addon_utils.enable(addon_name, default_set, persistent) if result is None: # Add-on not found addon_state_acas = False
def EnableAddon(self, addon_name): addon_utils.enable(addon_name, default_set=True, persistent=True) addon_utils.modules_refresh() return { 'is_enabled': addon_utils.check(addon_name)[0], 'is_loaded': addon_utils.check(addon_name)[1], }
def enable(module): if Get.ops('wm.addon_enable'): bpy.ops.wm.addon_enable(module=module) elif Get.ops('preferences.addon_enable'): bpy.ops.preferences.addon_enable(module=module) else: addon_utils.enable(module_name=module)
def reload_addons(do_reload=True, do_reverse=True): modules = addon_modules_sorted() addons = bpy.context.preferences.addons disable_addons() # Run twice each time. for _ in (0, 1): for mod in modules: mod_name = mod.__name__ print("\tenabling:", mod_name) addon_utils.enable(mod_name, default_set=True) assert(mod_name in addons) for mod in modules: mod_name = mod.__name__ print("\tdisabling:", mod_name) addon_utils.disable(mod_name, default_set=True) assert(not (mod_name in addons)) # now test reloading if do_reload: imp.reload(sys.modules[mod_name]) if do_reverse: # in case order matters when it shouldn't modules.reverse()
def remesh(self, context): lr = self.copiedobject hr = self.initialobject if self.manifold_method == "print3d": isloaded = addon_utils.check("object_print3d_utils")[0] if not isloaded: addon_utils.enable("object_print3d_utils") bpy.ops.mesh.print3d_clean_non_manifold() if not isloaded: addon_utils.disable("object_print3d_utils") elif self.manifold_method == "fill": bpy.ops.object.editmode_toggle() bpy.ops.mesh.select_mode(type="EDGE") bpy.ops.mesh.select_all(action='DESELECT') bpy.ops.mesh.select_non_manifold() bpy.ops.mesh.fill() bpy.ops.object.editmode_toggle() elif self.manifold_method == "manifold": self.report({"ERROR"}, "Manifold is not implemented yet") return {"CANCELLED"} elif self.manifold_method == "meshlab": self.report({"ERROR"}, "Meshlab manifolding is not implemented yet") return {"CANCELLED"} return {"FINISHED"}
def on_scene_update_post(scene): if hasattr(bpy.app.handlers, 'scene_update_post'): bpy.app.handlers.scene_update_post.remove(on_scene_update_post) # Enable addon by default for Armory integrated in Blender user_preferences = bpy.context.user_preferences if not 'armory' in user_preferences.addons: enable('armory', default_set=True, persistent=True, handle_error=None) bpy.ops.wm.save_userpref()
def register(): # register auto updater addon_updater_ops.register(bl_info) bpy.utils.register_module(__name__) addon_utils.enable("io_scene_fbx", default_set=True, persistent=True) bpy.types.Scene.preflight_props = bpy.props.PointerProperty( type=PreflightOptionsGroup)
def perform_check(): for addon in addon_dependencies: if addon in addons: is_enabled, is_loaded = check(addon) if not is_enabled: enable(addon) else: print("!Dependency %s missing!" % addon)
def __init__(self, config): Module.__init__(self, config) self._folder_path = "" self._used_assets = [] self._add_cp = {} self._preload = False self._fill_used_empty_materials = False # makes the integration of complex materials easier addon_utils.enable("node_wrangler")
def setUp(self): namespace = self.id().split('.') print(namespace[-2] + '.' + namespace[-1]) self.filepath = self.outpath() if not os.path.exists(self.__filepath): os.makedirs(self.__filepath) bpy.ops.wm.read_homefile(use_empty=True) addon_utils.enable('io_mesh_w3d', default_set=True)
def tex2vc(mesh_object, alpha_color=(0, 0, 0), replace_active_layer=True, mappingMode='CLIP', blendingMode='MULTIPLY', mirror_x=False, mirror_y=False, del_tex=True): """Transfer texture colors to vertex colors alpha_color: betweeon 0 and 1 replace_active_layer (bool) mappingMode (enum in 'CLIP', 'REPEAT', 'EXTEND') blendingMode (enum in ['MIX', 'ADD', 'SUBTRACT', 'MULTIPLY', 'SCREEN', 'OVERLAY', 'DIFFERENCE', 'DIVIDE', 'DARKEN', 'LIGHTEN', 'HUE', 'SATURATION', 'VALUE', 'COLOR', 'SOFT_LIGHT', 'LINEAR_LIGHT']) mirror_x (bool) mirror_y (bool) del_tex (bool): delete texture and material after conversion """ # Deselect All bpy.ops.object.select_all(action='DESELECT') # Select Source and make active mesh_object.select = True bpy.context.scene.objects.active = mesh_object """ # http://blender.stackexchange.com/questions/15638/how-to-distinguish-between-addon-is-not-installed-and-addon-is-not-enabled mod = None addon_name = 'uv_bake_texture_to_vcols' if addon_name not in addon_utils.addons_fake_modules: print("%s: Addon not installed." % addon_name) else: is_enabled, is_loaded = addon_utils.check(addon_name) if not is_loaded: try: mod = addon_utils.enable(addon_name, default_set=False, persistent=False) except: print("%s: Could not enable Addon on the fly." % addon_name ) if mod: print("%s: enabled and running." % addon_name) """ # Ensure that uv_bake_texture_to_vcols add-on is loaded and enabled is_enabled, is_loaded = addon_utils.check('uv_bake_texture_to_vcols') if not is_enabled: #print("%s enabled" % addon) addon_utils.enable('uv_bake_texture_to_vcols') bpy.context.scene.uv_bake_alpha_color = alpha_color bpy.ops.uv.bake_texture_to_vcols(replace_active_layer=replace_active_layer, mappingMode=mappingMode, blendingMode=blendingMode, mirror_x=mirror_x, mirror_y=mirror_y) if del_tex: remove_tex_color(mesh_object=mesh_object) return None
def enable_rpr(case): event('Load rpr', True, case) if not addon_utils.check('rprblender')[0]: addon_utils.enable('rprblender', default_set=True, persistent=False, handle_error=None) set_value(bpy.context.scene.render, 'engine', 'RPR') event('Load rpr', False, case)
def execute(self, context): bpy.ops.code_autocomplete.save_files() addon_name = get_addon_name() module = sys.modules.get(addon_name) if module: addon_utils.disable(addon_name) importlib.reload(module) addon_utils.enable(addon_name) return {"FINISHED"}
def checkAddon(addon_name): '''Check is an addon is installed and enable it if needed''' addon_utils.modules_refresh() if addon_name not in addon_utils.addons_fake_modules: raise ImportError("%s addon not installed." % addon_name) else: default, enable = addon_utils.check(addon_name) #>>Warning: addon-module 'geoscene' found module but without __addon_enabled__ field, possible name collision if not enable: addon_utils.enable(addon_name, default_set=True, persistent=False)
def setUp(self): self._reports = [] if self.blend_file: bpy.ops.wm.open_mainfile(filepath=self.relpath(self.blend_file)) else: bpy.ops.wm.read_homefile() addon_utils.enable('io_scene_xray', default_set=True) handlers.load_post(None) self.__prev_report_catcher = TestReadyOperator.report_catcher TestReadyOperator.report_catcher = lambda op, type, message: self._reports.append( (type, message))
def register(): bpy.utils.register_module(__name__) bpy.types.Scene.copy_indices = CopyIDs() # bpy.ops.wm.addon_enable(module="space_view3d_copy_attributes") addon_utils.enable("space_view3d_copy_attributes", default_set=True, persistent=True) bpy.types.VIEW3D_MT_copypopup.append( append_copy_ids) #add copy ids to Ctrl+C 'Copy Attributes addon' bpy.types.MESH_MT_CopyFaceSettings.append( append_copy_ids_editmode ) #add copy ids to Ctrl+C 'Copy Attributes addon'
def loadAddon(self, name, version): import addon_utils for module in addon_utils.modules(): if module.__name__ == name: if version == module.bl_info['version']: print("Enabling addon: {0}".format(name)) addon_utils.enable(name, default_set=True, persistent=False, handle_error=None) return else: raise Exception("Unexpected addon version: {0}".format(str(module.bl_info['version']))) raise Exception("Addon not found: {0}".format(name))
def install_mmobj(): enabled,_ = addon_utils.check('io_scene_mmobj') if not enabled: addon_utils.enable('io_scene_mmobj', True) enabled,_ = addon_utils.check('io_scene_mmobj') if enabled: bpy.ops.wm.save_userpref() print(SUCCESS) else: # sys.exit(1) # this causes blender to die messily without setting the return code. so we'll just have to print the error print("MMERROR: Plugin failed to enable; install path may not be correct, or it is incompatible with this version of blender") else: print(SUCCESS)
def execute(self, context): pl_prop = context.scene.devpack_props.addon_list for ad in pl_prop: if not ad.select: continue if self.enable: print(f'Enabling {ad.name} -> {ad.addon_module}') addon_utils.enable(ad.addon_module) else: print(f'Disabling {ad.name} -> {ad.addon_module}') addon_utils.disable(ad.addon_module) return {"FINISHED"}
def load_addons(): modules = addon_modules_sorted() addons = bpy.context.user_preferences.addons # first disable all for mod_name in list(addons.keys()): addon_utils.disable(mod_name, default_set=True) assert(bool(addons) is False) for mod in modules: mod_name = mod.__name__ addon_utils.enable(mod_name, default_set=True) assert(mod_name in addons)
def enable_named_addon(addon_name): """Enable the given addon Raises an error if the addon cannot be enabled. """ # Enable the addon, note that this utility checks timestamps and # reloads the addon if necessary _log.info('enable %s', addon_name) addon_utils.enable(addon_name) if not is_addon_enabled(addon_name): raise Exception('failed to enable addon: %s', addon_name)
def load_addons(): modules = addon_modules_sorted() addons = bpy.context.user_preferences.addons # first disable all for mod_name in list(addons.keys()): addon_utils.disable(mod_name, default_set=True) assert (bool(addons) is False) for mod in modules: mod_name = mod.__name__ addon_utils.enable(mod_name, default_set=True) assert (mod_name in addons)
def execute(self, _context): from addon_utils import enable from .helper import get_save_directory # Enable the "Import Images as Planes" add-on to be used here enable("io_import_images_as_planes") clipboard = Clipboard.push(get_save_directory()) clipboard.report.log() self.report({clipboard.report.type}, clipboard.report.message) if clipboard.report.type != "INFO": return {"CANCELLED"} for image in clipboard.images: bpy.ops.import_image.to_plane(files=[{"name": image.filepath}]) return {"FINISHED"}
def _enable_addon(self): """Enables the nif scripts addon, so all tests can use it.""" addon_utils.enable(module_name=self.nif_module_name, default_set=True, persistent=False, handle_error=None) nose.tools.assert_true(self.is_enabled()) print("Addon enabled successfully") try: import io_scene_niftools except ImportError: print("Failed to import io_scene_niftools module") assert False try: import pyffi except ImportError: print("Dependancy was not found, ensure that pyffi was built and included with the installer") assert False
def processRemoteCommand(self, cmd): exists = os.path.isfile(cmd) if exists: print('try execute "' + cmd + '"') exec(compile(open(cmd).read(), cmd, 'exec')) return True else: addonName = cmd print('try restart "' + addonName + '"') addon_utils.disable(addonName) addon_utils.enable(addonName) return True print('no command given') return False
def load_addons(): modules = addon_utils.modules({}) modules.sort(key=lambda mod: mod.__name__) addons = bpy.context.user_preferences.addons # first disable all for mod_name in list(addons.keys()): addon_utils.disable(mod_name) assert (bool(addons) is False) for mod in modules: mod_name = mod.__name__ addon_utils.enable(mod_name) assert (mod_name in addons)
def load_addons(): modules = addon_utils.modules({}) modules.sort(key=lambda mod: mod.__name__) addons = bpy.context.user_preferences.addons # first disable all for mod_name in list(addons.keys()): addon_utils.disable(mod_name) assert(bool(addons) == False) for mod in modules: mod_name = mod.__name__ addon_utils.enable(mod_name) assert(mod_name in addons)
def execute(self, _context): import addon_utils err_str = "" def err_cb(ex): import traceback nonlocal err_str err_str = traceback.format_exc() print(err_str) mod = addon_utils.enable(self.module, default_set=True, handle_error=err_cb) if mod: info = addon_utils.module_bl_info(mod) info_ver = info.get("blender", (0, 0, 0)) if info_ver > bpy.app.version: self.report( {'WARNING'}, "This script was written Blender " "version %d.%d.%d and might not " "function (correctly), " "though it is enabled" % info_ver ) return {'FINISHED'} else: if err_str: self.report({'ERROR'}, err_str) return {'CANCELLED'}
def import_file(self, f): ''' Imports an obj file and returns the name of the object ''' old_stdout = sys.stdout old_stderr = sys.stderr dvnull = open(devnull, 'w') sys.stdout = sys.stderr = dvnull # Check if obj importer is enabled if not addon_utils.check("io_scene_obj")[1]: # Enable it if not addon_utils.enable("io_scene_obj"): self.report({'ERROR'}, "could not load obj importer, aborting...") # try: bpy.ops.import_scene.obj( filepath=f, axis_forward='-Z', axis_up='Y', use_edges=True, use_smooth_groups=True, use_split_objects=False, use_split_groups=False, use_groups_as_vgroups=False, use_image_search=True, split_mode='OFF', global_clamp_size=0) # except AttributeError: # self.report({'ERROR'}, "obj importer not loaded, aborting...") sys.stdout = old_stdout sys.stderr = old_stderr return self.rename_object(f)
def test_enable_addon(): """Enables the nif scripts addon, so all tests can use it.""" try: addon_utils.enable(module_name=nif_module_name, default_set=True, persistent=False, handle_error=None) except: pass enabled = False modules = bpy.context.user_preferences.addons.keys() if (nif_module_name in modules): enabled = True nose.tools.assert_true(enabled)
def __init__(self, master_node=False, master_list=[], slave_list=[], offset_num=1): self.scene_name = bpy.context.scene.name self.master_node = master_node self.master_list = master_list self.slave_list = slave_list self.offset_num = offset_num try: self.group = bpy.data.groups["grp.stuff"] except: self.group = bpy.data.groups.new("grp.stuff") import addon_utils try: addon_utils.enable("_wm_properties_new", default_set=True) except: self.report({"ERROR"}, "Could not enable module: WM_OT_Properties")
def import_file(self, f): ''' Imports an obj file and returns the name of the object ''' old_stdout = sys.stdout old_stderr = sys.stderr dvnull = open(devnull, 'w') sys.stdout = sys.stderr = dvnull # Check if obj importer is enabled if not addon_utils.check("io_scene_obj")[1]: # Enable it if not addon_utils.enable("io_scene_obj"): self.report({'ERROR'}, "could not load obj importer, aborting...") # try: bpy.ops.import_scene.obj(filepath=f, axis_forward='-Z', axis_up='Y', use_edges=True, use_smooth_groups=True, use_split_objects=False, use_split_groups=False, use_groups_as_vgroups=False, use_image_search=True, split_mode='OFF', global_clamp_size=0) # except AttributeError: # self.report({'ERROR'}, "obj importer not loaded, aborting...") sys.stdout = old_stdout sys.stderr = old_stderr return self.rename_object(f)
def load_addons(): modules = addon_modules_sorted() addons = bpy.context.user_preferences.addons # first disable all for mod_name in list(addons.keys()): addon_utils.disable(mod_name, default_set=True) assert(bool(addons) is False) for mod in modules: mod_name = mod.__name__ if mod_name in BLACKLIST: continue addon_utils.enable(mod_name, default_set=True) if not (mod_name in addons): raise Exception("'addon_utils.enable(%r)' call failed" % mod_name)
def _setup_addons(self): import sys sys_path = [] if self.addon_paths is not None: for path in self.addon_paths(): if path not in sys.path: sys.path.append(path) import addon_utils addons = [] if self.addons is not None: addons.extend(self.addons()) for addon in addons: addon_utils.enable(addon) self._addon_store = { "sys_path": sys_path, "addons": addons, }
def setupCleanBlenderEnvironment(self): name = 'arx_addon' import addon_utils from bpy import context # Disable the module first to prevent log spam for module in addon_utils.modules(): if module.__name__ == name: is_enabled, is_loaded = addon_utils.check(name) if is_loaded: addon_utils.disable(name) #bpy.ops.wm.read_homefile() bpy.ops.wm.read_factory_settings() #addon_utils.modules_refresh() moduleFound = False for module in addon_utils.modules(): if module.__name__ == name: default, enable = addon_utils.check(name) if not enable: addon_utils.enable(name, default_set=True, persistent=False, handle_error=None) context.user_preferences.addons[name].preferences.arxAssetPath = self.dataDirectory moduleFound = True if not moduleFound: raise Exception("Addon not found: {0}".format(name)) # Cleanup the default scene def removeObj(name): defaultCube = bpy.context.scene.objects.get(name) if defaultCube: defaultCube.select = True bpy.ops.object.delete() removeObj('Cube') removeObj('Camera') removeObj('Lamp')
def test_load_addons(): modules = addon_modules_sorted() disable_addons() addons = bpy.context.preferences.addons addons_fail = [] for mod in modules: mod_name = mod.__name__ print("\tenabling:", mod_name) addon_utils.enable(mod_name, default_set=True) if (mod_name not in addons) and (mod_name not in BLACKLIST_ADDONS): addons_fail.append(mod_name) if addons_fail: print("addons failed to load (%d):" % len(addons_fail)) for mod_name in addons_fail: print(" %s" % mod_name) else: print("addons all loaded without errors!") print("")
def register(): bpy.utils.register_module(__name__) bpy.types.Screen.tangent_outliner = bpy.props.PointerProperty(type = TA_Outliner) addon_name = "proxy_refresh" addon_state = addon_utils.check(addon_name) # Returns: loaded_default, loaded_state addon_state_pr = addon_state[1] if not addon_state_pr: default_set=True # From addon_utils function persistent=True # From addon_utils function result = addon_utils.enable(addon_name, default_set, persistent) if result is None: # Add-on not found addon_state_pr = False addon_name = "addon_create_animation_scene" addon_state = addon_utils.check(addon_name) # loaded_default, loaded_state addon_state_acas = addon_state[1] if not addon_state_acas: default_set=True # From addon_utils function persistent=True # From addon_utils function result = addon_utils.enable(addon_name, default_set, persistent) if result is None: # Add-on not found addon_state_acas = False
def test_load_addons(): modules = addon_utils.modules({}) modules.sort(key=lambda mod: mod.__name__) disable_addons() addons = bpy.context.user_preferences.addons addons_fail = [] for mod in modules: mod_name = mod.__name__ print("\tenabling:", mod_name) addon_utils.enable(mod_name) if mod_name not in addons: addons_fail.append(mod_name) if addons_fail: print("addons failed to load (%d):" % len(addons_fail)) for mod_name in addons_fail: print(" %s" % mod_name) else: print("addons all loaded without errors!") print("")
def execute(self, context): mod = addon_utils.enable(self.module) if mod: info = addon_utils.module_bl_info(mod) info_ver = info.get("blender", (0, 0, 0)) if info_ver > bpy.app.version: self.report({'WARNING'}, ("This script was written Blender " "version %d.%d.%d and might not " "function (correctly).\n" "The script is enabled though.") % info_ver) return {'FINISHED'} else: return {'CANCELLED'}
def execute(self, context): mod = addon_utils.enable(self.module) if hasattr(mod,'__name__') : info = addon_utils.module_bl_info(mod) info_ver = info.get("blender", (0, 0, 0)) if info_ver > bpy.app.version: self.report({'WARNING'}, ("This script was written Blender " "version %d.%d.%d and might not " "function (correctly).\n" "The script is enabled though.") % info_ver) return {'FINISHED'} else: msg = mod if type(mod) == str else "Error. See console" self.report({'ERROR'}, msg) return {'CANCELLED'}
import bpy, os, sys # some script launching blender would run this first. import addon_utils addon_utils.enable("bpy_externall") # addon_utils.enable("bpy_externall-master") # if you installed from zip # start listening bpy.ops.wm.bpy_externall_server(speed=1, mode="start")
'location': 'Armature, Object and Lattice properties, View3d tools panel, Armature Add menu', 'description': 'BlenRig 5 rigging system', 'wiki_url': 'https://cloud.blender.org/p/blenrig/', 'tracker_url': '', 'category': 'Rigging'} import bpy import os from bpy.props import FloatProperty, IntProperty, BoolProperty ######### Load Dependencies ########## import addon_utils addon_utils.enable("space_view3d_copy_attributes", default_set=False, persistent=True, handle_error=None) ######### Relative Path ########## base_dir = os.path.dirname(__file__) from . import base_dir ######### Load Rig Functions ########## from .rig_functions import ( bone_auto_hide, reproportion_toggle, rig_toggles, toggle_face_drivers, toggle_flex_drivers, toggle_body_drivers )
else: # sino se hace el primer import # importando archivos en el mismo directorio que el __init__.py from .basics import * from .fabrickbrick import * import bpy from bpy.props import * import random ############################################### # para tener un boton que recarga el addon ############################################### import addon_utils ############################################### addon_utils.enable("__init__", default_set=False, persistent=False, handle_error=None) addon_utils.disable("__init__", default_set=False, handle_error=None) class ReloadMyAdoon(bpy.types.Operator): bl_idname = "object.zebus_dialog2" bl_label = "Reset addon" def execute(self,context): addon_utils.disable("wallcreator") addon_utils.enable("wallcreator") return {'FINISHED'} ############################################### class DialogOperator(bpy.types.Operator): bl_idname = "object.zebus_dialog" bl_label = "Wall Bricks Creator v02" ############################################### # Defaults:
import sys import os import shutil import bpy import addon_utils # Make sure BlenderPanda addon is enabled addon_utils.enable("BlenderPanda", persistent=True) #print(sys.argv) srcdir, dstdir = sys.argv[-2:] #print('Exporting:', srcdir) #print('Export to:', dstdir) for root, dirs, files in os.walk(srcdir): for asset in files: src = os.path.join(root, asset) dst = src.replace(srcdir, dstdir).replace('.blend', '.bam') if not asset.endswith('.blend'): # Only convert blend files with pman_build stub continue if os.path.exists(dst) and os.stat(src).st_mtime <= os.stat(dst).st_mtime: # Don't convert up-to-date-files continue if asset.endswith('.blend'): print('Converting .blend file ({}) to .bam ({})'.format(src, dst))
def addon_ensure(addon_id): # Enable the addon, dont change preferences. default_state, loaded_state = addon_utils.check(addon_id) if not loaded_state: addon_utils.enable(addon_id, default_set=False)
import bpy import addon_utils # enable addon add_curve_sapling addon_utils.enable('add_curve_sapling') for idx in range(0,8): # get obj name list before tree create beforeObjNames = [] for i in bpy.data.objects: i.select = False beforeObjNames.append(i.name) # set 3d cursor bpy.context.scene.cursor_location = (idx*1.5, idx, 0.0) # put tree object bpy.ops.curve.tree_add(do_update=True, chooseSet='1', bevel=True, prune=True, showLeaves=True, useArm=False, seed=0, handleType='0', levels=3, length=(1, 0.3, 0.6, 0.45), lengthV=(0, 0, 0, 0), branches=(0, 50, 30, 10), curveRes=(3, 5, 3, 1), curve=(0, -40, -40, 0), curveV=(20, 50, 75, 0), curveBack=(0, 0, 0, 0), baseSplits=0, segSplits=(0, 0, 0, 0), splitAngle=(0, 0, 0, 0), splitAngleV=(0, 0, 0, 0), scale=2, scaleV=3, attractUp=0.5, shape=str(idx), baseSize=0.4, ratio=0.015, taper=(1, 1, 1, 1), ratioPower=1.2, downAngle=(90, 60, 45, 45), downAngleV=(0, -50, 10, 10), rotate=(140, 140, 140, 77), rotateV=(0, 0, 0, 0), scale0=1, scaleV0=0.2, pruneWidth=0.4, pruneWidthPeak=0.6, prunePowerHigh=0.5, prunePowerLow=0.001, pruneRatio=1, leaves=25, leafScale=0.17, leafScaleX=1, leafDist='4', bend=0, bevelRes=0, resU=4, frameRate=1, windSpeed=2, windGust=0, armAnim=False, startCurv=0) # get name after created tree afterObjNames = [] for i in bpy.data.objects: afterObjNames.append(i.name) treeObjNames = set(afterObjNames) - set(beforeObjNames) for name in treeObjNames: #print("objName = " + name) if not bpy.data.objects[name].parent: bpy.data.objects[name].select = True else: bpy.data.objects[name].select = False
"mirror_vertex_groups", "multi_rename_dom", #"space_view3d_Meta-Tools_0-3_tab", "mass_align", "modifier_tool", "subdiv_tool", "wireframe_toggle", "DeadlineBlenderClient", "custom_file_tab", #turns off remap relative. *Addon's cannot be unregistered. Remove the file to permanently remove the addon "cubesurfer", ] import addon_utils for addon in addon_startup_list: try: addon_utils.enable(addon, default_set=True) except: log.warning("Could not enable addon %s - skipped" % addon) else: log.info("Loaded addon %s" % addon) # Setup defaults - base this on the show. TODO: un-hardcode this # Basic render settings bpy.context.scene.render.fps = 24 bpy.context.scene.render.resolution_x = 1440 bpy.context.scene.render.resolution_y = 810 bpy.context.scene.render.resolution_percentage = 100 bpy.context.scene.render.pixel_aspect_x = 1.0 bpy.context.scene.render.pixel_aspect_y = 1.0
def execute(self,context): addon_utils.disable("wallcreator") addon_utils.enable("wallcreator") return {'FINISHED'}