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 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 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 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 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 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 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'}
