# ##### 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 ##### """Blender-specific code. Separated from __init__.py so that we can import & run from non-Blender environments. """ import functools import logging import os.path import bpy from bpy.types import AddonPreferences, Operator, WindowManager, Scene, PropertyGroup from bpy.props import StringProperty, EnumProperty, PointerProperty, BoolProperty, IntProperty import rna_prop_ui from . import pillar, async_loop, flamenco from .utils import pyside_cache, redraw PILLAR_WEB_SERVER_URL = os.environ.get('BCLOUD_SERVER', 'https://cloud.blender.org/') PILLAR_SERVER_URL = '%sapi/' % PILLAR_WEB_SERVER_URL ADDON_NAME = 'blender_cloud' log = logging.getLogger(__name__) icons = None @pyside_cache('version') def blender_syncable_versions(self, context): """Returns the list of items used by SyncStatusProperties.version EnumProperty.""" bss = context.window_manager.blender_sync_status versions = bss.available_blender_versions if not versions: return [('', 'No settings stored in your Blender Cloud', '')] return [(v, v, '') for v in versions] class SyncStatusProperties(PropertyGroup): status = EnumProperty( items=[ ('NONE', 'NONE', 'We have done nothing at all yet.'), ('IDLE', 'IDLE', 'User requested something, which is done, and we are now idle.'), ('SYNCING', 'SYNCING', 'Synchronising with Blender Cloud.'), ], name='status', description='Current status of Blender Sync', update=redraw) version = EnumProperty( items=blender_syncable_versions, name='Version of Blender from which to pull', description='Version of Blender from which to pull') message = StringProperty(name='message', update=redraw) level = EnumProperty( items=[ ('INFO', 'INFO', ''), ('WARNING', 'WARNING', ''), ('ERROR', 'ERROR', ''), ('SUBSCRIBE', 'SUBSCRIBE', ''), ], name='level', update=redraw) def report(self, level: set, message: str): assert len(level) == 1, 'level should be a set of one string, not %r' % level self.level = level.pop() self.message = message # Message can also be empty, just to erase it from the GUI. # No need to actually log those. if message: try: loglevel = logging._nameToLevel[self.level] except KeyError: loglevel = logging.WARNING log.log(loglevel, message) # List of syncable versions is stored in 'available_blender_versions' ID property, # because I don't know how to store a variable list of strings in a proper RNA property. @property def available_blender_versions(self) -> list: return self.get('available_blender_versions', []) @available_blender_versions.setter def available_blender_versions(self, new_versions): self['available_blender_versions'] = new_versions @pyside_cache('project') def bcloud_available_projects(self, context): """Returns the list of items used by BlenderCloudProjectGroup.project EnumProperty.""" projs = preferences().project.available_projects if not projs: return [('', 'No projects available in your Blender Cloud', '')] return [(p['_id'], p['name'], '') for p in projs] @functools.lru_cache(1) def project_extensions(project_id) -> set: """Returns the extensions the project is enabled for. At the moment of writing these are 'attract' and 'flamenco'. """ log.debug('Finding extensions for project %s', project_id) # We can't use our @property, since the preferences may be loaded from a # preferences blend file, in which case it is not constructed from Python code. available_projects = preferences().project.get('available_projects', []) if not available_projects: log.debug('No projects available.') return set() proj = next((p for p in available_projects if p['_id'] == project_id), None) if proj is None: log.debug('Project %s not found in available projects.', project_id) return set() return set(proj.get('enabled_for', ())) def handle_project_update(_=None, _2=None): """Handles changing projects, which may cause extensions to be disabled/enabled. Ignores arguments so that it can be used as property update callback. """ project_id = preferences().project.project log.info('Updating internal state to reflect extensions enabled on current project %s.', project_id) project_extensions.cache_clear() from blender_cloud import attract, flamenco attract.deactivate() flamenco.deactivate() enabled_for = project_extensions(project_id) log.info('Project extensions: %s', enabled_for) if 'attract' in enabled_for: attract.activate() if 'flamenco' in enabled_for: flamenco.activate() class BlenderCloudProjectGroup(PropertyGroup): status = EnumProperty( items=[ ('NONE', 'NONE', 'We have done nothing at all yet'), ('IDLE', 'IDLE', 'User requested something, which is done, and we are now idle'), ('FETCHING', 'FETCHING', 'Fetching available projects from Blender Cloud'), ], name='status', update=redraw) project = EnumProperty( items=bcloud_available_projects, name='Cloud project', description='Which Blender Cloud project to work with', update=handle_project_update ) # List of projects is stored in 'available_projects' ID property, # because I don't know how to store a variable list of strings in a proper RNA property. @property def available_projects(self) -> list: return self.get('available_projects', []) @available_projects.setter def available_projects(self, new_projects): self['available_projects'] = new_projects handle_project_update() class BlenderCloudPreferences(AddonPreferences): bl_idname = ADDON_NAME # The following two properties are read-only to limit the scope of the # addon and allow for proper testing within this scope. pillar_server = StringProperty( name='Blender Cloud Server', description='URL of the Blender Cloud backend server', default=PILLAR_SERVER_URL, get=lambda self: PILLAR_SERVER_URL ) local_texture_dir = StringProperty( name='Default Blender Cloud Texture Storage Directory', subtype='DIR_PATH', default='//textures') open_browser_after_share = BoolProperty( name='Open Browser after Sharing File', description='When enabled, Blender will open a webbrowser', default=True ) # TODO: store project-dependent properties with the project, so that people # can switch projects and the Attract and Flamenco properties switch with it. project = PointerProperty(type=BlenderCloudProjectGroup) cloud_project_local_path = StringProperty( name='Local Project Path', description='Local path of your Attract project, used to search for blend files; ' 'usually best to set to an absolute path', subtype='DIR_PATH', default='//../') flamenco_manager = PointerProperty(type=flamenco.FlamencoManagerGroup) flamenco_exclude_filter = StringProperty( name='File Exclude Filter', description='Filter like "*.abc;*.mkv" to prevent certain files to be packed ' 'into the output directory', default='') # TODO: before making Flamenco public, change the defaults to something less Institute-specific. # NOTE: The assumption is that the workers can also find the files in the same path. # This assumption is true for the Blender Institute. flamenco_job_file_path = StringProperty( name='Job File Path', description='Path where to store job files, should be accesible for Workers too', subtype='DIR_PATH', default='/render/_flamenco/storage') # TODO: before making Flamenco public, change the defaults to something less Institute-specific. flamenco_job_output_path = StringProperty( name='Job Output Path', description='Path where to store output files, should be accessible for Workers', subtype='DIR_PATH', default='/render/_flamenco/output') flamenco_job_output_strip_components = IntProperty( name='Job Output Path Strip Components', description='The final output path comprises of the job output path, and the blend file ' 'path relative to the project with this many path components stripped off ' 'the front', min=0, default=0, soft_max=4, ) flamenco_open_browser_after_submit = BoolProperty( name='Open Browser after Submitting Job', description='When enabled, Blender will open a webbrowser', default=True ) def draw(self, context): import textwrap layout = self.layout # Carefully try and import the Blender ID addon try: import blender_id except ImportError: blender_id = None blender_id_profile = None else: blender_id_profile = blender_id.get_active_profile() if blender_id is None: msg_icon = 'ERROR' text = 'This add-on requires Blender ID' help_text = 'Make sure that the Blender ID add-on is installed and activated' elif not blender_id_profile: msg_icon = 'ERROR' text = 'You are logged out.' help_text = 'To login, go to the Blender ID add-on preferences.' elif bpy.app.debug and pillar.SUBCLIENT_ID not in blender_id_profile.subclients: msg_icon = 'QUESTION' text = 'No Blender Cloud credentials.' help_text = ('You are logged in on Blender ID, but your credentials have not ' 'been synchronized with Blender Cloud yet. Press the Update ' 'Credentials button.') else: msg_icon = 'WORLD_DATA' text = 'You are logged in as %s.' % blender_id_profile.username help_text = ('To logout or change profile, ' 'go to the Blender ID add-on preferences.') # Authentication stuff auth_box = layout.box() auth_box.label(text=text, icon=msg_icon) help_lines = textwrap.wrap(help_text, 80) for line in help_lines: auth_box.label(text=line) if bpy.app.debug: auth_box.operator("pillar.credentials_update") # Texture browser stuff texture_box = layout.box() texture_box.enabled = msg_icon != 'ERROR' sub = texture_box.column() sub.label(text='Local directory for downloaded textures', icon_value=icon('CLOUD')) sub.prop(self, "local_texture_dir", text='Default') sub.prop(context.scene, "local_texture_dir", text='Current scene') # Blender Sync stuff bss = context.window_manager.blender_sync_status bsync_box = layout.box() bsync_box.enabled = msg_icon != 'ERROR' row = bsync_box.row().split(percentage=0.33) row.label('Blender Sync with Blender Cloud', icon_value=icon('CLOUD')) icon_for_level = { 'INFO': 'NONE', 'WARNING': 'INFO', 'ERROR': 'ERROR', 'SUBSCRIBE': 'ERROR', } msg_icon = icon_for_level[bss.level] if bss.message else 'NONE' message_container = row.row() message_container.label(bss.message, icon=msg_icon) sub = bsync_box.column() if bss.level == 'SUBSCRIBE': self.draw_subscribe_button(sub) self.draw_sync_buttons(sub, bss) # Image Share stuff share_box = layout.box() share_box.label('Image Sharing on Blender Cloud', icon_value=icon('CLOUD')) share_box.prop(self, 'open_browser_after_share') # Project selector project_box = layout.box() project_box.enabled = self.project.status in {'NONE', 'IDLE'} self.draw_project_selector(project_box, self.project) extensions = project_extensions(self.project.project) # Flamenco stuff if 'flamenco' in extensions: flamenco_box = project_box.column() self.draw_flamenco_buttons(flamenco_box, self.flamenco_manager, context) def draw_subscribe_button(self, layout): layout.operator('pillar.subscribe', icon='WORLD') def draw_sync_buttons(self, layout, bss): layout.enabled = bss.status in {'NONE', 'IDLE'} buttons = layout.column() row_buttons = buttons.row().split(percentage=0.5) row_push = row_buttons.row() row_pull = row_buttons.row(align=True) row_push.operator('pillar.sync', text='Save %i.%i settings' % bpy.app.version[:2], icon='TRIA_UP').action = 'PUSH' versions = bss.available_blender_versions version = bss.version if bss.status in {'NONE', 'IDLE'}: if not versions or not version: row_pull.operator('pillar.sync', text='Find version to load', icon='TRIA_DOWN').action = 'REFRESH' else: props = row_pull.operator('pillar.sync', text='Load %s settings' % version, icon='TRIA_DOWN') props.action = 'PULL' props.blender_version = version row_pull.operator('pillar.sync', text='', icon='DOTSDOWN').action = 'SELECT' else: row_pull.label('Cloud Sync is running.') def draw_project_selector(self, project_box, bcp: BlenderCloudProjectGroup): project_row = project_box.row(align=True) project_row.label('Project settings', icon_value=icon('CLOUD')) row_buttons = project_row.row(align=True) projects = bcp.available_projects project = bcp.project if bcp.status in {'NONE', 'IDLE'}: if not projects or not project: row_buttons.operator('pillar.projects', text='Find project to load', icon='FILE_REFRESH') else: row_buttons.prop(bcp, 'project') row_buttons.operator('pillar.projects', text='', icon='FILE_REFRESH') else: row_buttons.label('Fetching available projects.') enabled_for = project_extensions(project) if not project: return if not enabled_for: project_box.label('This project is not set up for Attract or Flamenco') return project_box.label('This project is set up for: %s' % ', '.join(sorted(enabled_for))) # This is only needed when the project is set up for either Attract or Flamenco. project_box.prop(self, 'cloud_project_local_path', text='Local Cloud Project Path') def draw_flamenco_buttons(self, flamenco_box, bcp: flamenco.FlamencoManagerGroup, context): from .flamenco import bam_interface header_row = flamenco_box.row(align=True) header_row.label('Flamenco:', icon_value=icon('CLOUD')) manager_split = flamenco_box.split(0.32, align=True) manager_split.label('Manager:') manager_box = manager_split.row(align=True) if bcp.status in {'NONE', 'IDLE'}: if not bcp.available_managers or not bcp.manager: manager_box.operator('flamenco.managers', text='Find Flamenco Managers', icon='FILE_REFRESH') else: manager_box.prop(bcp, 'manager', text='') manager_box.operator('flamenco.managers', text='', icon='FILE_REFRESH') else: manager_box.label('Fetching available managers.') path_split = flamenco_box.split(0.32, align=True) path_split.label(text='Job File Path:') path_box = path_split.row(align=True) path_box.prop(self, 'flamenco_job_file_path', text='') props = path_box.operator('flamenco.explore_file_path', text='', icon='DISK_DRIVE') props.path = self.flamenco_job_file_path job_output_box = flamenco_box.column(align=True) path_split = job_output_box.split(0.32, align=True) path_split.label(text='Job Output Path:') path_box = path_split.row(align=True) path_box.prop(self, 'flamenco_job_output_path', text='') props = path_box.operator('flamenco.explore_file_path', text='', icon='DISK_DRIVE') props.path = self.flamenco_job_output_path job_output_box.prop(self, 'flamenco_exclude_filter') prop_split = job_output_box.split(0.32, align=True) prop_split.label('Strip Components:') prop_split.prop(self, 'flamenco_job_output_strip_components', text='') from .flamenco import render_output_path path_box = job_output_box.row(align=True) output_path = render_output_path(context) if output_path: path_box.label(str(output_path)) props = path_box.operator('flamenco.explore_file_path', text='', icon='DISK_DRIVE') props.path = str(output_path.parent) else: path_box.label('Blend file is not in your project path, ' 'unable to give output path example.') flamenco_box.prop(self, 'flamenco_open_browser_after_submit') class PillarCredentialsUpdate(pillar.PillarOperatorMixin, Operator): """Updates the Pillar URL and tests the new URL.""" bl_idname = 'pillar.credentials_update' bl_label = 'Update credentials' bl_description = 'Resynchronises your Blender ID login with Blender Cloud' log = logging.getLogger('bpy.ops.%s' % bl_idname) @classmethod def poll(cls, context): # Only allow activation when the user is actually logged in. return cls.is_logged_in(context) @classmethod def is_logged_in(cls, context): try: import blender_id except ImportError: return False return blender_id.is_logged_in() def execute(self, context): import blender_id import asyncio # Only allow activation when the user is actually logged in. if not self.is_logged_in(context): self.report({'ERROR'}, 'No active profile found') return {'CANCELLED'} try: loop = asyncio.get_event_loop() loop.run_until_complete(self.check_credentials(context, set())) except blender_id.BlenderIdCommError as ex: log.exception('Error sending subclient-specific token to Blender ID') self.report({'ERROR'}, 'Failed to sync Blender ID to Blender Cloud') return {'CANCELLED'} except Exception as ex: log.exception('Error in test call to Pillar') self.report({'ERROR'}, 'Failed test connection to Blender Cloud') return {'CANCELLED'} self.report({'INFO'}, 'Blender Cloud credentials & endpoint URL updated.') return {'FINISHED'} class PILLAR_OT_subscribe(Operator): """Opens a browser to subscribe the user to the Cloud.""" bl_idname = 'pillar.subscribe' bl_label = 'Subscribe to the Cloud' bl_description = "Opens a page in a web browser to subscribe to the Blender Cloud" def execute(self, context): import webbrowser webbrowser.open_new_tab('https://cloud.blender.org/join') self.report({'INFO'}, 'We just started a browser for you.') return {'FINISHED'} class PILLAR_OT_projects(async_loop.AsyncModalOperatorMixin, pillar.AuthenticatedPillarOperatorMixin, Operator): """Fetches the projects available to the user""" bl_idname = 'pillar.projects' bl_label = 'Fetch available projects' stop_upon_exception = True _log = logging.getLogger('bpy.ops.%s' % bl_idname) async def async_execute(self, context): if not await self.authenticate(context): return import pillarsdk from .pillar import pillar_call self.log.info('Going to fetch projects for user %s', self.user_id) preferences().project.status = 'FETCHING' # Get all projects, except the home project. projects_user = await pillar_call( pillarsdk.Project.all, {'where': {'user': self.user_id, 'category': {'$ne': 'home'}}, 'sort': '-_created', 'projection': {'_id': True, 'name': True, 'extension_props': True}, }) projects_shared = await pillar_call( pillarsdk.Project.all, {'where': {'user': {'$ne': self.user_id}, 'permissions.groups.group': {'$in': self.db_user.groups}}, 'sort': '-_created', 'projection': {'_id': True, 'name': True, 'extension_props': True}, }) # We need to convert to regular dicts before storing in ID properties. # Also don't store more properties than we need. def reduce_properties(project_list): for p in project_list: p = p.to_dict() extension_props = p.get('extension_props', {}) enabled_for = list(extension_props.keys()) self._log.debug('Project %r is enabled for %s', p['name'], enabled_for) yield { '_id': p['_id'], 'name': p['name'], 'enabled_for': enabled_for, } projects = list(reduce_properties(projects_user['_items'])) + \ list(reduce_properties(projects_shared['_items'])) preferences().project.available_projects = projects self.quit() def quit(self): preferences().project.status = 'IDLE' super().quit() class PILLAR_PT_image_custom_properties(rna_prop_ui.PropertyPanel, bpy.types.Panel): """Shows custom properties in the image editor.""" bl_space_type = 'IMAGE_EDITOR' bl_region_type = 'UI' bl_label = 'Custom Properties' _context_path = 'edit_image' _property_type = bpy.types.Image def preferences() -> BlenderCloudPreferences: return bpy.context.user_preferences.addons[ADDON_NAME].preferences def load_custom_icons(): global icons if icons is not None: # Already loaded return import bpy.utils.previews icons = bpy.utils.previews.new() my_icons_dir = os.path.join(os.path.dirname(__file__), 'icons') icons.load('CLOUD', os.path.join(my_icons_dir, 'icon-cloud.png'), 'IMAGE') def unload_custom_icons(): global icons if icons is None: # Already unloaded return bpy.utils.previews.remove(icons) icons = None def icon(icon_name: str) -> int: """Returns the icon ID for the named icon. Use with layout.operator('pillar.image_share', icon_value=icon('CLOUD')) """ return icons[icon_name].icon_id def register(): bpy.utils.register_class(BlenderCloudProjectGroup) bpy.utils.register_class(BlenderCloudPreferences) bpy.utils.register_class(PillarCredentialsUpdate) bpy.utils.register_class(SyncStatusProperties) bpy.utils.register_class(PILLAR_OT_subscribe) bpy.utils.register_class(PILLAR_OT_projects) bpy.utils.register_class(PILLAR_PT_image_custom_properties) addon_prefs = preferences() WindowManager.last_blender_cloud_location = StringProperty( name="Last Blender Cloud browser location", default="/") def default_if_empty(scene, context): """The scene's local_texture_dir, if empty, reverts to the addon prefs.""" if not scene.local_texture_dir: scene.local_texture_dir = addon_prefs.local_texture_dir Scene.local_texture_dir = StringProperty( name='Blender Cloud texture storage directory for current scene', subtype='DIR_PATH', default=addon_prefs.local_texture_dir, update=default_if_empty) WindowManager.blender_sync_status = PointerProperty(type=SyncStatusProperties) load_custom_icons() def unregister(): unload_custom_icons() bpy.utils.unregister_class(BlenderCloudProjectGroup) bpy.utils.unregister_class(PillarCredentialsUpdate) bpy.utils.unregister_class(BlenderCloudPreferences) bpy.utils.unregister_class(SyncStatusProperties) bpy.utils.unregister_class(PILLAR_OT_subscribe) bpy.utils.unregister_class(PILLAR_OT_projects) bpy.utils.unregister_class(PILLAR_PT_image_custom_properties) del WindowManager.last_blender_cloud_location del WindowManager.blender_sync_status