Bumped version to 1.8.0

This stores project-specific settings, such as filesystem paths, for each
project, and restores those settings when the project is selected again.
Does not touch settings that haven't been set for the newly selected
project.

CHANGELOG.md

@@ -1,5 +1,47 @@
 # Blender Cloud changelog
 
+## Version 1.8 (in development)
+
+- Distinguish between 'please subscribe' (to get a new subscription) and 'please renew' (to renew an
+  existing subscription).
+- When re-opening the Texture Browser it now opens in the same folder as where it was when closed.
+- In the texture browser, draw the components of the texture (i.e. which map types are available),
+  such as 'bump, normal, specular'.
+- Use Interface Scale setting from user preferences to draw the Texture Browser text.
+- Store project-specific settings in the preferences, such as filesystem paths, for each project,
+  and restore those settings when the project is selected again. Does not touch settings that
+  haven't been set for the newly selected project. These settings are only saved when a setting
+  is updated, so to save your current settings need to update a single setting; this saves all
+  settings for the project.
+- Added button in the User Preferences to open a Cloud project in your webbrowser.
+
+
+## Version 1.7.5 (2017-10-06)
+
+- Sorting the project list alphabetically.
+- Renamed 'Job File Path' to 'Job Storage Path' so it's more explicit.
+- Allow overriding the render output path on a per-scene basis.
+
+
+## Version 1.7.4 (2017-09-05)
+
+- Fix [T52621](https://developer.blender.org/T52621): Fixed class name collision upon add-on
+  registration. This is checked since Blender 2.79.
+- Fix [T48852](https://developer.blender.org/T48852): Screenshot no longer shows "Communicating with
+  Blender Cloud".
+
+
+## Version 1.7.3 (2017-08-08)
+
+- Default to scene frame range when no frame range is given.
+- Refuse to render on Flamenco before blend file is saved at least once.
+- Fixed some Windows-specific issues.
+
+
+## Version 1.7.2 (2017-06-22)
+
+- Fixed compatibility with Blender 2.78c.
+
 
 ## Version 1.7.1 (2017-06-13)
 

blender_cloud/__init__.py

@@ -21,7 +21,7 @@
 bl_info = {
     'name': 'Blender Cloud',
     "author": "Sybren A. Stüvel, Francesco Siddi, Inês Almeida, Antony Riakiotakis",
-    'version': (1, 7, 1),
+    'version': (1, 8, 0),
     'blender': (2, 77, 0),
     'location': 'Addon Preferences panel, and Ctrl+Shift+Alt+A anywhere for texture browser',
     'description': 'Texture library browser and Blender Sync. Requires the Blender ID addon '
@@ -79,6 +79,7 @@ def register():
         reload_mod('blendfile')
         reload_mod('home_project')
         reload_mod('utils')
+        reload_mod('pillar')
 
         async_loop = reload_mod('async_loop')
         flamenco = reload_mod('flamenco')
@@ -87,9 +88,10 @@ def register():
         settings_sync = reload_mod('settings_sync')
         image_sharing = reload_mod('image_sharing')
         blender = reload_mod('blender')
+        project_specific = reload_mod('project_specific')
     else:
         from . import (blender, texture_browser, async_loop, settings_sync, blendfile, home_project,
-                       image_sharing, attract, flamenco)
+                       image_sharing, attract, flamenco, project_specific)
 
     async_loop.setup_asyncio_executor()
     async_loop.register()
@@ -101,7 +103,7 @@ def register():
     image_sharing.register()
     blender.register()
 
-    blender.handle_project_update()
+    project_specific.handle_project_update()
 
 
 def _monkey_patch_requests():

blender_cloud/attract/__init__.py

@@ -173,7 +173,7 @@ class AttractPollMixin:
         return attract_is_active
 
 
-class ToolsPanel(AttractPollMixin, Panel):
+class AttractToolsPanel(AttractPollMixin, Panel):
     bl_label = 'Attract'
     bl_space_type = 'SEQUENCE_EDITOR'
     bl_region_type = 'UI'
@@ -974,7 +974,7 @@ def register():
 
     bpy.types.SEQUENCER_PT_edit.append(draw_strip_movie_meta)
 
-    bpy.utils.register_class(ToolsPanel)
+    bpy.utils.register_class(AttractToolsPanel)
     bpy.utils.register_class(AttractShotRelink)
     bpy.utils.register_class(AttractShotDelete)
     bpy.utils.register_class(AttractStripUnlink)

blender_cloud/blender.py

@@ -23,22 +23,21 @@ Separated from __init__.py so that we can import & run from non-Blender environm
 import functools
 import logging
 import os.path
+import tempfile
 
 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 . import pillar, async_loop, flamenco, project_specific
 from .utils import pyside_cache, redraw
 
-PILLAR_WEB_SERVER_URL = 'https://cloud.blender.org/'
+PILLAR_WEB_SERVER_URL = os.environ.get('BCLOUD_SERVER', 'https://cloud.blender.org/')
-# PILLAR_WEB_SERVER_URL = 'http://pillar-web:5001/'
 PILLAR_SERVER_URL = '%sapi/' % PILLAR_WEB_SERVER_URL
 
 ADDON_NAME = 'blender_cloud'
 log = logging.getLogger(__name__)
-
 icons = None
 
 
@@ -140,30 +139,6 @@ def project_extensions(project_id) -> 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=[
@@ -178,7 +153,7 @@ class BlenderCloudProjectGroup(PropertyGroup):
         items=bcloud_available_projects,
         name='Cloud project',
         description='Which Blender Cloud project to work with',
-        update=handle_project_update
+        update=project_specific.handle_project_update
     )
 
     # List of projects is stored in 'available_projects' ID property,
@@ -190,13 +165,13 @@ class BlenderCloudProjectGroup(PropertyGroup):
     @available_projects.setter
     def available_projects(self, new_projects):
         self['available_projects'] = new_projects
-        handle_project_update()
+        project_specific.handle_project_update()
 
 
 class BlenderCloudPreferences(AddonPreferences):
     bl_idname = ADDON_NAME
 
-    # The following two properties are read-only to limit the scope of the
+    # The following property is read-only to limit the scope of the
     # addon and allow for proper testing within this scope.
     pillar_server = StringProperty(
         name='Blender Cloud Server',
@@ -225,29 +200,32 @@ class BlenderCloudPreferences(AddonPreferences):
         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='//../')
+        default='//../',
+        update=project_specific.store,
+    )
 
     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='')
+        default='',
-    # TODO: before making Flamenco public, change the defaults to something less Institute-specific.
+        update=project_specific.store,
-    # 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',
+        name='Job Storage Path',
         description='Path where to store job files, should be accesible for Workers too',
         subtype='DIR_PATH',
-        default='/render/_flamenco/storage')
+        default=tempfile.gettempdir(),
-
+        update=project_specific.store,
-    # 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')
+        default=tempfile.gettempdir(),
+        update=project_specific.store,
+    )
     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 '
@@ -256,11 +234,12 @@ class BlenderCloudPreferences(AddonPreferences):
         min=0,
         default=0,
         soft_max=4,
+        update=project_specific.store,
     )
     flamenco_open_browser_after_submit = BoolProperty(
         name='Open Browser after Submitting Job',
         description='When enabled, Blender will open a webbrowser',
-        default=True
+        default=True,
     )
 
     def draw(self, context):
@@ -407,6 +386,10 @@ class BlenderCloudPreferences(AddonPreferences):
                 row_buttons.operator('pillar.projects',
                                      text='',
                                      icon='FILE_REFRESH')
+                props = row_buttons.operator('pillar.project_open_in_browser',
+                                             text='',
+                                             icon='WORLD')
+                props.project_id = project
         else:
             row_buttons.label('Fetching available projects.')
 
@@ -462,16 +445,7 @@ class BlenderCloudPreferences(AddonPreferences):
         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')
-        show_warning = bool(self.flamenco_exclude_filter and
-                            not bam_interface.bam_supports_exclude_option())
-        job_output_box.alert = show_warning
-        job_output_box.prop(self, 'flamenco_exclude_filter',
-                            icon='ERROR' if show_warning else 'NONE')
-        if show_warning:
-            job_output_box.label(
-                text='Warning, the exclusion filter requires a newer version of Blender!')
-        job_output_box.alert = False
 
         prop_split = job_output_box.split(0.32, align=True)
         prop_split.label('Strip Components:')
@@ -555,6 +529,36 @@ class PILLAR_OT_subscribe(Operator):
         return {'FINISHED'}
 
 
+class PILLAR_OT_project_open_in_browser(Operator):
+    bl_idname = 'pillar.project_open_in_browser'
+    bl_label = 'Open in Browser'
+    bl_description = 'Opens a webbrowser to show the project'
+
+    project_id = StringProperty(name='Project ID')
+
+    def execute(self, context):
+        if not self.project_id:
+            return {'CANCELLED'}
+
+        import webbrowser
+        import urllib.parse
+
+        import pillarsdk
+        from .pillar import sync_call
+
+        project = sync_call(pillarsdk.Project.find, self.project_id, {'projection': {'url': True}})
+
+        if log.isEnabledFor(logging.DEBUG):
+            import pprint
+            log.debug('found project: %s', pprint.pformat(project.to_dict()))
+
+        url = urllib.parse.urljoin(PILLAR_WEB_SERVER_URL, 'p/' + project.url)
+        webbrowser.open_new_tab(url)
+        self.report({'INFO'}, 'Opened a browser at %s' % url)
+
+        return {'FINISHED'}
+
+
 class PILLAR_OT_projects(async_loop.AsyncModalOperatorMixin,
                          pillar.AuthenticatedPillarOperatorMixin,
                          Operator):
@@ -581,7 +585,7 @@ class PILLAR_OT_projects(async_loop.AsyncModalOperatorMixin,
             pillarsdk.Project.all,
             {'where': {'user': self.user_id,
                        'category': {'$ne': 'home'}},
-             'sort': '-_created',
+             'sort': '-name',
              'projection': {'_id': True,
                             'name': True,
                             'extension_props': True},
@@ -591,7 +595,7 @@ class PILLAR_OT_projects(async_loop.AsyncModalOperatorMixin,
             pillarsdk.Project.all,
             {'where': {'user': {'$ne': self.user_id},
                        'permissions.groups.group': {'$in': self.db_user.groups}},
-             'sort': '-_created',
+             'sort': '-name',
              'projection': {'_id': True,
                             'name': True,
                             'extension_props': True},
@@ -615,7 +619,10 @@ class PILLAR_OT_projects(async_loop.AsyncModalOperatorMixin,
         projects = list(reduce_properties(projects_user['_items'])) + \
                    list(reduce_properties(projects_shared['_items']))
 
-        preferences().project.available_projects = projects
+        def proj_sort_key(project):
+            return project.get('name')
+
+        preferences().project.available_projects = sorted(projects, key=proj_sort_key)
 
         self.quit()
 
@@ -679,6 +686,7 @@ def register():
     bpy.utils.register_class(SyncStatusProperties)
     bpy.utils.register_class(PILLAR_OT_subscribe)
     bpy.utils.register_class(PILLAR_OT_projects)
+    bpy.utils.register_class(PILLAR_OT_project_open_in_browser)
     bpy.utils.register_class(PILLAR_PT_image_custom_properties)
 
     addon_prefs = preferences()
@@ -713,6 +721,7 @@ def unregister():
     bpy.utils.unregister_class(SyncStatusProperties)
     bpy.utils.unregister_class(PILLAR_OT_subscribe)
     bpy.utils.unregister_class(PILLAR_OT_projects)
+    bpy.utils.unregister_class(PILLAR_OT_project_open_in_browser)
     bpy.utils.unregister_class(PILLAR_PT_image_custom_properties)
 
     del WindowManager.last_blender_cloud_location

blender_cloud/flamenco/__init__.py

@@ -20,16 +20,29 @@
 
 The preferences are managed blender.py, the rest of the Flamenco-specific stuff is here.
 """
+
 import functools
 import logging
+import os
 from pathlib import Path, PurePath
 import typing
 
+if "bpy" in locals():
+    import importlib
+
+    try:
+        bam_interface = importlib.reload(bam_interface)
+        sdk = importlib.reload(sdk)
+    except NameError:
+        from . import bam_interface, sdk
+else:
+    from . import bam_interface, sdk
+
 import bpy
 from bpy.types import AddonPreferences, Operator, WindowManager, Scene, PropertyGroup
 from bpy.props import StringProperty, EnumProperty, PointerProperty, BoolProperty, IntProperty
 
-from .. import async_loop, pillar
+from .. import async_loop, pillar, project_specific
 from ..utils import pyside_cache, redraw
 
 log = logging.getLogger(__name__)
@@ -54,7 +67,9 @@ class FlamencoManagerGroup(PropertyGroup):
     manager = EnumProperty(
         items=available_managers,
         name='Flamenco Manager',
-        description='Which Flamenco Manager to use for jobs')
+        description='Which Flamenco Manager to use for jobs',
+        update=project_specific.store,
+    )
 
     status = EnumProperty(
         items=[
@@ -136,6 +151,14 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
     log = logging.getLogger('%s.FLAMENCO_OT_render' % __name__)
 
     async def async_execute(self, context):
+        # Refuse to start if the file hasn't been saved. It's okay if
+        # it's dirty, but we do need a filename and a location.
+        if not os.path.exists(context.blend_data.filepath):
+            self.report({'ERROR'}, 'Please save your Blend file before using '
+                                   'the Blender Cloud addon.')
+            self.quit()
+            return
+
         if not await self.authenticate(context):
             return
 
@@ -178,10 +201,12 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
 
         # Create the job at Flamenco Server.
         context.window_manager.flamenco_status = 'COMMUNICATING'
+
+        frame_range = scene.flamenco_render_frame_range.strip() or scene_frame_range(context)
         settings = {'blender_cmd': '{blender}',
                     'chunk_size': scene.flamenco_render_fchunk_size,
                     'filepath': manager.replace_path(outfile),
-                    'frames': scene.flamenco_render_frame_range,
+                    'frames': frame_range,
                     'render_output': manager.replace_path(render_output),
                     }
 
@@ -301,7 +326,6 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
 
         from datetime import datetime
         from ..blender import preferences
-        from . import bam_interface
 
         prefs = preferences()
 
@@ -335,6 +359,13 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
         return outfile, missing_sources
 
 
+def scene_frame_range(context) -> str:
+    """Returns the frame range string for the current scene."""
+
+    s = context.scene
+    return '%i-%i' % (s.frame_start, s.frame_end)
+
+
 class FLAMENCO_OT_scene_to_frame_range(FlamencoPollMixin, Operator):
     """Sets the scene frame range as the Flamenco render frame range."""
     bl_idname = 'flamenco.scene_to_frame_range'
@@ -342,8 +373,7 @@ class FLAMENCO_OT_scene_to_frame_range(FlamencoPollMixin, Operator):
     bl_description = __doc__.rstrip('.')
 
     def execute(self, context):
-        s = context.scene
+        context.scene.flamenco_render_frame_range = scene_frame_range(context)
-        s.flamenco_render_frame_range = '%i-%i' % (s.frame_start, s.frame_end)
         return {'FINISHED'}
 
 
@@ -359,14 +389,15 @@ class FLAMENCO_OT_copy_files(Operator,
 
     async def async_execute(self, context):
         from pathlib import Path
-        from . import bam_interface
         from ..blender import preferences
 
         context.window_manager.flamenco_status = 'PACKING'
+        exclusion_filter = preferences().flamenco_exclude_filter or None
 
         missing_sources = await bam_interface.bam_copy(
             Path(context.blend_data.filepath),
             Path(preferences().flamenco_job_file_path),
+            exclusion_filter
         )
 
         if missing_sources:
@@ -423,6 +454,30 @@ class FLAMENCO_OT_explore_file_path(FlamencoPollMixin,
         return {'FINISHED'}
 
 
+class FLAMENCO_OT_enable_output_path_override(Operator):
+    """Enables the 'override output path' setting."""
+
+    bl_idname = 'flamenco.enable_output_path_override'
+    bl_label = 'Enable Overriding of Output Path'
+    bl_description = 'Click to specify a non-default Output Path for this particular job'
+
+    def execute(self, context):
+        context.scene.flamenco_do_override_output_path = True
+        return {'FINISHED'}
+
+
+class FLAMENCO_OT_disable_output_path_override(Operator):
+    """Disables the 'override output path' setting."""
+
+    bl_idname = 'flamenco.disable_output_path_override'
+    bl_label = 'disable Overriding of Output Path'
+    bl_description = 'Click to use the default Output Path'
+
+    def execute(self, context):
+        context.scene.flamenco_do_override_output_path = False
+        return {'FINISHED'}
+
+
 async def create_job(user_id: str,
                      project_id: str,
                      manager_id: str,
@@ -477,6 +532,7 @@ def _render_output_path(
         flamenco_job_output_path: str,
         render_image_format: str,
         flamenco_render_frame_range: str,
+        include_rel_path: bool = True,
 ) -> typing.Optional[PurePath]:
     """Cached version of render_output_path()
 
@@ -501,8 +557,7 @@ def _render_output_path(
     except ValueError:
         return None
 
-    rel_parts = proj_rel.parts[flamenco_job_output_strip_components:]
+    output_top = PurePath(flamenco_job_output_path)
-    output_top = Path(flamenco_job_output_path)
 
     # Strip off '.flamenco' too; we use 'xxx.flamenco.blend' as job file, but
     # don't want to have all the output paths ending in '.flamenco'.
@@ -510,7 +565,11 @@ def _render_output_path(
     if stem.endswith('.flamenco'):
         stem = stem[:-9]
 
-    dir_components = output_top.joinpath(*rel_parts) / stem
+    if include_rel_path:
+        rel_parts = proj_rel.parts[flamenco_job_output_strip_components:]
+        dir_components = output_top.joinpath(*rel_parts) / stem
+    else:
+        dir_components = output_top
 
     # Blender will have to append the file extensions by itself.
     if is_image_type(render_image_format):
@@ -535,13 +594,19 @@ def render_output_path(context, filepath: Path = None) -> typing.Optional[PurePa
     if filepath is None:
         filepath = Path(context.blend_data.filepath)
 
+    if scene.flamenco_do_override_output_path:
+        job_output_path = scene.flamenco_override_output_path
+    else:
+        job_output_path = prefs.flamenco_job_output_path
+
     return _render_output_path(
         prefs.cloud_project_local_path,
         filepath,
         prefs.flamenco_job_output_strip_components,
-        prefs.flamenco_job_output_path,
+        job_output_path,
         scene.render.image_settings.file_format,
         scene.flamenco_render_frame_range,
+        include_rel_path=not scene.flamenco_do_override_output_path,
     )
 
 
@@ -575,8 +640,9 @@ class FLAMENCO_PT_render(bpy.types.Panel, FlamencoPollMixin):
         if getattr(context.scene, 'flamenco_render_job_type', None) == 'blender-render-progressive':
             layout.prop(context.scene, 'flamenco_render_schunk_count')
 
-        readonly_stuff = layout.column(align=True)
+        paths_layout = layout.column(align=True)
-        labeled_row = readonly_stuff.split(0.25, align=True)
+
+        labeled_row = paths_layout.split(0.25, align=True)
         labeled_row.label('Storage:')
         prop_btn_row = labeled_row.row(align=True)
         prop_btn_row.label(prefs.flamenco_job_file_path)
@@ -584,19 +650,33 @@ class FLAMENCO_PT_render(bpy.types.Panel, FlamencoPollMixin):
                                       text='', icon='DISK_DRIVE')
         props.path = prefs.flamenco_job_file_path
 
-        labeled_row = readonly_stuff.split(0.25, align=True)
-        labeled_row.label('Output:')
-        prop_btn_row = labeled_row.row(align=True)
         render_output = render_output_path(context)
-
         if render_output is None:
-            prop_btn_row.label('Unable to render with Flamenco, outside of project directory.')
+            paths_layout.label('Unable to render with Flamenco, outside of project directory.')
         else:
-            prop_btn_row.label(str(render_output))
+            labeled_row = paths_layout.split(0.25, align=True)
+            labeled_row.label('Output:')
+            prop_btn_row = labeled_row.row(align=True)
+
+            if context.scene.flamenco_do_override_output_path:
+                prop_btn_row.prop(context.scene, 'flamenco_override_output_path', text='')
+                op = FLAMENCO_OT_disable_output_path_override.bl_idname
+                icon = 'X'
+            else:
+                prop_btn_row.label(str(render_output))
+                op = FLAMENCO_OT_enable_output_path_override.bl_idname
+                icon = 'GREASEPENCIL'
+            prop_btn_row.operator(op, icon=icon, text='')
+
             props = prop_btn_row.operator(FLAMENCO_OT_explore_file_path.bl_idname,
                                           text='', icon='DISK_DRIVE')
             props.path = str(render_output.parent)
 
+            if context.scene.flamenco_do_override_output_path:
+                labeled_row = paths_layout.split(0.25, align=True)
+                labeled_row.label('Effective Output Path:')
+                labeled_row.label(str(render_output))
+
             flamenco_status = context.window_manager.flamenco_status
             if flamenco_status == 'IDLE':
                 layout.operator(FLAMENCO_OT_render.bl_idname,
@@ -628,6 +708,22 @@ def deactivate():
     _render_output_path.cache_clear()
 
 
+def flamenco_do_override_output_path_updated(scene, context):
+    """Set the override paths to the default, if not yet set."""
+
+    # Only set a default when enabling the override.
+    if not scene.flamenco_do_override_output_path:
+        return
+
+    # Don't overwrite existing setting.
+    if scene.flamenco_override_output_path:
+        return
+
+    from ..blender import preferences
+    scene.flamenco_override_output_path = preferences().flamenco_job_output_path
+    log.info('Setting Override Output Path to %s', scene.flamenco_override_output_path)
+
+
 def register():
     from ..utils import redraw
 
@@ -637,6 +733,8 @@ def register():
     bpy.utils.register_class(FLAMENCO_OT_scene_to_frame_range)
     bpy.utils.register_class(FLAMENCO_OT_copy_files)
     bpy.utils.register_class(FLAMENCO_OT_explore_file_path)
+    bpy.utils.register_class(FLAMENCO_OT_enable_output_path_override)
+    bpy.utils.register_class(FLAMENCO_OT_disable_output_path_override)
     bpy.utils.register_class(FLAMENCO_PT_render)
 
     scene = bpy.types.Scene
@@ -674,6 +772,19 @@ def register():
         description='Higher numbers mean higher priority'
     )
 
+    scene.flamenco_do_override_output_path = BoolProperty(
+        name='Override Output Path for this Job',
+        description='When enabled, allows you to specify a non-default Output path '
+                    'for this particular job',
+        default=False,
+        update=flamenco_do_override_output_path_updated
+    )
+    scene.flamenco_override_output_path = StringProperty(
+        name='Override Output Path',
+        description='Path where to store output files, should be accessible for Workers',
+        subtype='DIR_PATH',
+        default='')
+
     bpy.types.WindowManager.flamenco_status = EnumProperty(
         items=[
             ('IDLE', 'IDLE', 'Not doing anything.'),
@@ -710,6 +821,14 @@ def unregister():
         del bpy.types.Scene.flamenco_render_job_priority
     except AttributeError:
         pass
+    try:
+        del bpy.types.Scene.flamenco_do_override_output_path
+    except AttributeError:
+        pass
+    try:
+        del bpy.types.Scene.flamenco_override_output_path
+    except AttributeError:
+        pass
     try:
         del bpy.types.WindowManager.flamenco_status
     except AttributeError:

blender_cloud/flamenco/bam_interface.py

@@ -1,6 +1,5 @@
 """BAM packing interface for Flamenco."""
 
-import functools
 import logging
 from pathlib import Path
 import typing
@@ -15,26 +14,26 @@ class CommandExecutionError(Exception):
     pass
 
 
-if 'bam_supports_exclude_option' in locals():
+def wheel_pythonpath_278() -> str:
-    locals()['bam_supports_exclude_option'].cache_clear()
+    """Returns the value of a PYTHONPATH environment variable needed to run BAM from its wheel file.
 
-
+    Workaround for Blender 2.78c not having io_blend_utils.pythonpath()
-@functools.lru_cache(maxsize=1)
-def bam_supports_exclude_option() -> bool:
-    """Returns True if the version of BAM bundled with Blender supports --exclude.
-
-    This feature was added to BAM 1.1.7, so we can do a simple version check.
     """
 
-    try:
+    import os
-        import io_blend_utils
+    from ..wheels import wheel_filename
-    except ImportError:
-        # If this happens, BAM won't work at all. However, this function can be called from
-        # the GUI; by being a bit careful while importing, we avoid breaking Blender's GUI.
-        log.exception('Error importing io_blend_utils module.')
-        return False
 
-    return io_blend_utils.bl_info['version'] >= (1, 1, 7)
+    # Find the wheel to run.
+    wheelpath = wheel_filename('blender_bam')
+
+    log.info('Using wheel %s to run BAM-Pack', wheelpath)
+
+    # Update the PYTHONPATH to include that wheel.
+    existing_pypath = os.environ.get('PYTHONPATH', '')
+    if existing_pypath:
+        return os.pathsep.join((existing_pypath, wheelpath))
+
+    return wheelpath
 
 
 async def bam_copy(base_blendfile: Path, target_blendfile: Path,
@@ -51,6 +50,7 @@ async def bam_copy(base_blendfile: Path, target_blendfile: Path,
     """
 
     import asyncio
+    import os
     import shlex
     import subprocess
 
@@ -66,18 +66,28 @@ async def bam_copy(base_blendfile: Path, target_blendfile: Path,
     ]
 
     if exclusion_filter:
-        if bam_supports_exclude_option():
+        args.extend(['--exclude', exclusion_filter])
-            args.extend(['--exclude', exclusion_filter])
-        else:
-            log.warning('Your version of Blender does not support the exclusion filter, '
-                        'copying all files.')
 
     cmd_to_log = ' '.join(shlex.quote(s) for s in args)
     log.info('Executing %s', cmd_to_log)
 
+    # Workaround for Blender 2.78c not having io_blend_utils.pythonpath()
+    if hasattr(io_blend_utils, 'pythonpath'):
+        pythonpath = io_blend_utils.pythonpath()
+    else:
+        pythonpath = wheel_pythonpath_278()
+
+    env = {
+        'PYTHONPATH': pythonpath,
+        # Needed on Windows because http://bugs.python.org/issue8557
+        'PATH': os.environ['PATH'],
+    }
+    if 'SYSTEMROOT' in os.environ:  # Windows http://bugs.python.org/issue20614
+        env['SYSTEMROOT'] = os.environ['SYSTEMROOT']
+
     proc = await asyncio.create_subprocess_exec(
         *args,
-        env={'PYTHONPATH': io_blend_utils.pythonpath()},
+        env=env,
         stdin=subprocess.DEVNULL,
         stdout=subprocess.PIPE,
         stderr=subprocess.STDOUT,

blender_cloud/flamenco/sdk.py

@@ -11,21 +11,20 @@ class Manager(List, Find):
 
     @functools.lru_cache()
     def _sorted_path_replacements(self) -> list:
-        import sys
+        import platform
 
         if self.path_replacement is None:
             return []
 
-        print('SORTING PATH REPLACEMENTS')
-
         items = self.path_replacement.to_dict().items()
 
         def by_length(item):
             return -len(item[0]), item[0]
 
-        platform = sys.platform
+        this_platform = platform.system().lower()
-        return [(varname, platform_replacements[platform])
+        return [(varname, platform_replacements[this_platform])
-                for varname, platform_replacements in sorted(items, key=by_length)]
+                for varname, platform_replacements in sorted(items, key=by_length)
+                if this_platform in platform_replacements]
 
     def replace_path(self, some_path: pathlib.PurePath) -> str:
         """Performs path variable replacement.

blender_cloud/image_sharing.py

@@ -112,7 +112,11 @@ class PILLAR_OT_image_share(pillar.PillarOperatorMixin,
     async def async_execute(self, context):
         """Entry point of the asynchronous operator."""
 
-        self.report({'INFO'}, 'Communicating with Blender Cloud')
+        # We don't want to influence what is included in the screen shot.
+        if self.target == 'SCREENSHOT':
+            print('Blender Cloud add-on is communicating with Blender Cloud')
+        else:
+            self.report({'INFO'}, 'Communicating with Blender Cloud')
 
         try:
             # Refresh credentials
@@ -120,9 +124,8 @@ class PILLAR_OT_image_share(pillar.PillarOperatorMixin,
                 db_user = await self.check_credentials(context, REQUIRES_ROLES_FOR_IMAGE_SHARING)
                 self.user_id = db_user['_id']
                 self.log.debug('Found user ID: %s', self.user_id)
-            except pillar.NotSubscribedToCloudError:
+            except pillar.NotSubscribedToCloudError as ex:
-                self.log.exception('User not subscribed to cloud.')
+                self._log_subscription_needed(can_renew=ex.can_renew)
-                self.report({'ERROR'}, 'Please subscribe to the Blender Cloud.')
                 self._state = 'QUIT'
                 return
             except pillar.UserNotLoggedInError:

blender_cloud/pillar.py

@@ -62,7 +62,16 @@ class CredentialsNotSyncedError(UserNotLoggedInError):
 
 
 class NotSubscribedToCloudError(UserNotLoggedInError):
-    """Raised when the user may be logged in on Blender ID, but has no Blender Cloud token."""
+    """Raised when the user does not have an active Cloud subscription.
+
+    :ivar can_renew: True when the user has an inactive subscription that can be renewed,
+        or False when the user has no subscription at all.
+    """
+
+    def __init__(self, can_renew: bool):
+        super().__init__()
+        self.can_renew = can_renew
+        log.warning('Not subscribed to cloud, can_renew=%s', can_renew)
 
 
 class PillarError(RuntimeError):
@@ -273,14 +282,15 @@ async def check_pillar_credentials(required_roles: set):
     except (pillarsdk.UnauthorizedAccess, pillarsdk.ResourceNotFound, pillarsdk.ForbiddenAccess):
         raise CredentialsNotSyncedError()
 
-    roles = db_user.roles or set()
+    roles = set(db_user.roles or set())
-    log.debug('User has roles %r', roles)
+    log.getChild('check_pillar_credentials').debug('user has roles %r', roles)
-    if required_roles and not required_roles.intersection(set(roles)):
+    if required_roles and not required_roles.intersection(roles):
         # Delete the subclient info. This forces a re-check later, which can
         # then pick up on the user's new status.
         del profile.subclients[SUBCLIENT_ID]
         profile.save_json()
-        raise NotSubscribedToCloudError()
+
+        raise NotSubscribedToCloudError(can_renew='has_subscription' in roles)
 
     return db_user
 
@@ -834,7 +844,6 @@ class PillarOperatorMixin:
         try:
             db_user = await check_pillar_credentials(required_roles)
         except NotSubscribedToCloudError:
-            self._log_subscription_needed()
             raise
         except CredentialsNotSyncedError:
             self.log.info('Credentials not synced, re-syncing automatically.')
@@ -845,7 +854,6 @@ class PillarOperatorMixin:
         try:
             db_user = await refresh_pillar_credentials(required_roles)
         except NotSubscribedToCloudError:
-            self._log_subscription_needed()
             raise
         except CredentialsNotSyncedError:
             self.log.info('Credentials not synced after refreshing, handling as not logged in.')
@@ -857,11 +865,13 @@ class PillarOperatorMixin:
             self.log.info('Credentials refreshed and ok.')
             return db_user
 
-    def _log_subscription_needed(self):
+    def _log_subscription_needed(self, *, can_renew: bool, level='ERROR'):
-        self.log.warning(
+        if can_renew:
-            'Please subscribe to the blender cloud at https://cloud.blender.org/join')
+            msg = 'Please renew your Blender Cloud subscription at https://cloud.blender.org/renew'
-        self.report({'INFO'},
+        else:
-                    'Please subscribe to the blender cloud at https://cloud.blender.org/join')
+            msg = 'Please subscribe to the blender cloud at https://cloud.blender.org/join'
+        self.log.warning(msg)
+        self.report({level}, msg)
 
 
 class AuthenticatedPillarOperatorMixin(PillarOperatorMixin):

blender_cloud/project_specific.py

@@ -0,0 +1,101 @@
+"""Handle saving and loading project-specific settings."""
+
+import logging
+
+# Names of BlenderCloudPreferences properties that are both project-specific
+# and simple enough to store directly in a dict.
+PROJECT_SPECIFIC_SIMPLE_PROPS = (
+    'cloud_project_local_path',
+    'flamenco_exclude_filter',
+    'flamenco_job_file_path',
+    'flamenco_job_output_path',
+    'flamenco_job_output_strip_components'
+)
+
+log = logging.getLogger(__name__)
+project_settings_loading = False
+
+
+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.
+    """
+
+    from .blender import preferences, project_extensions
+
+    global project_settings_loading
+    project_settings_loading = True
+    try:
+        prefs = preferences()
+        project_id = prefs.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()
+
+        # Load project-specific settings from the last time we visited this project.
+        ps = prefs.get('project_settings', {}).get(project_id, {})
+        if not ps:
+            log.debug('no project-specific settings are available, not touching options')
+            return
+
+        if log.isEnabledFor(logging.DEBUG):
+            from pprint import pformat
+            log.debug('loading project-specific settings:\n%s', pformat(ps.to_dict()))
+
+        for name in PROJECT_SPECIFIC_SIMPLE_PROPS:
+            if name in ps and hasattr(prefs, name):
+                setattr(prefs, name, ps[name])
+        if ps.get('flamenco_manager'):
+            prefs.flamenco_manager.manager = ps['flamenco_manager']
+            log.debug('setting flamenco manager to %s', ps['flamenco_manager'])
+
+    finally:
+        project_settings_loading = False
+
+
+def store(_=None, _2=None):
+    """Remember project-specific settings as soon as one of them changes.
+
+    Ignores arguments so that it can be used as property update callback.
+
+    No-op when project_settings_loading=True, to prevent saving project-
+    specific settings while they are actually being loaded.
+    """
+    from .blender import preferences
+
+    global project_settings_loading
+    if project_settings_loading:
+        return
+
+    prefs = preferences()
+    project_id = prefs.project.project
+    all_settings = prefs.get('project_settings', {})
+    ps = all_settings.get(project_id, {})
+
+    for name in PROJECT_SPECIFIC_SIMPLE_PROPS:
+        ps[name] = getattr(prefs, name)
+    ps['flamenco_manager'] = prefs.flamenco_manager.manager
+
+    if log.isEnabledFor(logging.DEBUG):
+        from pprint import pformat
+        if hasattr(ps, 'to_dict'):
+            ps_to_log = ps.to_dict()
+        else:
+            ps_to_log = ps
+        log.debug('saving project-specific settings:\n%s', pformat(ps_to_log))
+
+    all_settings[project_id] = ps
+    prefs['project_settings'] = all_settings

blender_cloud/settings_sync.py

@@ -284,9 +284,8 @@ class PILLAR_OT_sync(pillar.PillarOperatorMixin,
                 db_user = await self.check_credentials(context, REQUIRES_ROLES_FOR_SYNC)
                 self.user_id = db_user['_id']
                 log.debug('Found user ID: %s', self.user_id)
-            except pillar.NotSubscribedToCloudError:
+            except pillar.NotSubscribedToCloudError as ex:
-                self.log.exception('User not subscribed to cloud.')
+                self._log_subscription_needed(can_renew=ex.can_renew)
-                self.bss_report({'SUBSCRIBE'}, 'Please subscribe to the Blender Cloud.')
                 self._state = 'QUIT'
                 return
             except pillar.UserNotLoggedInError:

blender_cloud/texture_browser.py

@@ -76,8 +76,8 @@ class MenuItem:
     icon_margin_y = 4
     text_margin_x = 6
 
-    text_height = 16
+    text_size = 12
-    text_width = 72
+    text_size_small = 10
 
     DEFAULT_ICONS = {
         'FOLDER': os.path.join(library_icons_path, 'folder.png'),
@@ -214,12 +214,32 @@ class MenuItem:
 
         # draw some text
         font_id = 0
-        blf.position(font_id,
+        text_dpi = bpy.context.user_preferences.system.dpi
-                     self.x + self.icon_margin_x + ICON_WIDTH + self.text_margin_x,
+        text_x = self.x + self.icon_margin_x + ICON_WIDTH + self.text_margin_x
-                     self.y + ICON_HEIGHT * 0.5 - 0.25 * self.text_height, 0)
+        text_y = self.y + ICON_HEIGHT * 0.5 - 0.25 * self.text_size
-        blf.size(font_id, self.text_height, self.text_width)
+        blf.position(font_id, text_x, text_y, 0)
+        blf.size(font_id, self.text_size, text_dpi)
         blf.draw(font_id, self.label_text)
 
+        # Draw the components of the texture (i.e. which map types are available)
+        try:
+            node_files = self.node.properties.files
+        except AttributeError:
+            # Happens for nodes that don't have .properties.files.
+            node_files = None
+        if not node_files:
+            return
+
+        map_types = {f.map_type for f in node_files if f.map_type}
+        map_types.discard('color')  # all textures have colour
+        if not map_types:
+            return
+
+        bgl.glColor4f(1.0, 1.0, 1.0, 0.5)
+        blf.size(font_id, self.text_size_small, text_dpi)
+        blf.position(font_id, text_x, self.y + 0.5 * self.text_size_small, 0)
+        blf.draw(font_id, ', '.join(sorted(map_types)))
+
     def hits(self, mouse_x: int, mouse_y: int) -> bool:
         return self.x < mouse_x < self.x + self.width and self.y < mouse_y < self.y + self.height
 
@@ -311,8 +331,8 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
             self.mouse_y = event.mouse_y
 
         left_mouse_release = event.type == 'LEFTMOUSE' and event.value == 'RELEASE'
-        if self._state == 'PLEASE_SUBSCRIBE' and left_mouse_release:
+        if left_mouse_release and self._state in {'PLEASE_SUBSCRIBE', 'PLEASE_RENEW'}:
-            self.open_browser_subscribe()
+            self.open_browser_subscribe(renew=self._state == 'PLEASE_RENEW')
             self._finish(context)
             return {'FINISHED'}
 
@@ -365,9 +385,9 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
 
         try:
             db_user = await self.check_credentials(context, REQUIRED_ROLES_FOR_TEXTURE_BROWSER)
-        except pillar.NotSubscribedToCloudError:
+        except pillar.NotSubscribedToCloudError as ex:
-            self.log.info('User not subscribed to Blender Cloud.')
+            self._log_subscription_needed(can_renew=ex.can_renew, level='INFO')
-            self._show_subscribe_screen()
+            self._show_subscribe_screen(can_renew=ex.can_renew)
             return None
 
         if db_user is None:
@@ -375,10 +395,14 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
 
         await self.async_download_previews()
 
-    def _show_subscribe_screen(self):
+    def _show_subscribe_screen(self, *, can_renew: bool):
         """Shows the "You need to subscribe" screen."""
 
-        self._state = 'PLEASE_SUBSCRIBE'
+        if can_renew:
+            self._state = 'PLEASE_RENEW'
+        else:
+            self._state = 'PLEASE_SUBSCRIBE'
+
         bpy.context.window.cursor_set('HAND')
 
     def descend_node(self, menu_item: MenuItem):
@@ -548,6 +572,7 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
 
     def browse_assets(self):
         self.log.debug('Browsing assets at %r', self.current_path)
+        bpy.context.window_manager.last_blender_cloud_location = str(self.current_path)
         self._new_async_task(self.async_download_previews())
 
     def draw_menu(self, context):
@@ -560,6 +585,7 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
             'DOWNLOADING_TEXTURE': self._draw_downloading,
             'EXCEPTION': self._draw_exception,
             'PLEASE_SUBSCRIBE': self._draw_subscribe,
+            'PLEASE_RENEW': self._draw_renew,
         }
 
         if self._state in drawers:
@@ -727,6 +753,11 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
                                   'Click to subscribe to the Blender Cloud',
                                   (0.0, 0.0, 0.2, 0.6))
 
+    def _draw_renew(self, context):
+        self._draw_text_on_colour(context,
+                                  'Click to renew your Blender Cloud subscription',
+                                  (0.0, 0.0, 0.2, 0.6))
+
     def get_clicked(self) -> MenuItem:
 
         for item in self.current_display_content:
@@ -807,11 +838,11 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
                                                      future=signalling_future))
         self.async_task.add_done_callback(texture_download_completed)
 
-    def open_browser_subscribe(self):
+    def open_browser_subscribe(self, *, renew: bool):
         import webbrowser
 
-        webbrowser.open_new_tab('https://cloud.blender.org/join')
+        url = 'renew' if renew else 'join'
-
+        webbrowser.open_new_tab('https://cloud.blender.org/%s' % url)
         self.report({'INFO'}, 'We just started a browser for you.')
 
     def _scroll_smooth(self):
@@ -866,9 +897,8 @@ class PILLAR_OT_switch_hdri(pillar.PillarOperatorMixin,
             try:
                 db_user = await self.check_credentials(context, REQUIRED_ROLES_FOR_TEXTURE_BROWSER)
                 user_id = db_user['_id']
-            except pillar.NotSubscribedToCloudError:
+            except pillar.NotSubscribedToCloudError as ex:
-                self.log.exception('User not subscribed to cloud.')
+                self._log_subscription_needed(can_renew=ex.can_renew)
-                self.report({'ERROR'}, 'Please subscribe to the Blender Cloud.')
                 self._state = 'QUIT'
                 return
             except pillar.UserNotLoggedInError:

blender_cloud/wheels/__init__.py

@@ -44,6 +44,12 @@ def load_wheel(module_name, fname_prefix):
                   module_name, module.__file__, fname_prefix)
         return
 
+    sys.path.append(wheel_filename(fname_prefix))
+    module = __import__(module_name)
+    log.debug('Loaded %s from %s', module_name, module.__file__)
+
+
+def wheel_filename(fname_prefix: str) -> str:
     path_pattern = os.path.join(my_dir, '%s*.whl' % fname_prefix)
     wheels = glob.glob(path_pattern)
     if not wheels:
@@ -51,9 +57,7 @@ def load_wheel(module_name, fname_prefix):
 
     # If there are multiple wheels that match, load the latest one.
     wheels.sort()
-    sys.path.append(wheels[-1])
+    return wheels[-1]
-    module = __import__(module_name)
-    log.debug('Loaded %s from %s', module_name, module.__file__)
 
 
 def load_wheels():

requirements.txt

@@ -3,13 +3,15 @@
 lockfile==0.12.2
 pillarsdk==1.6.1
 wheel==0.29.0
+blender-bam==1.1.7
 
 # Secondary requirements:
-cffi==1.6.0
+asn1crypto==0.24.0
-cryptography==1.3.1
+cffi==1.11.2
-idna==2.1
+cryptography==2.1.4
+idna==2.6
 pyasn1==0.1.9
-pycparser==2.14
+pycparser==2.18
-pyOpenSSL==16.0.0
+pyOpenSSL==17.5.0
 requests==2.10.0
-six==1.10.0
+six==1.11.0

setup.py

@@ -101,6 +101,11 @@ class BuildWheels(Command):
             log.info('Downloading Pillar Python SDK wheel')
             self.download_wheel(requirements['pillarsdk'])
 
+        # Download BAM from pypi. This is required for compatibility with Blender 2.78.
+        if not list(self.wheels_path.glob('blender_bam*.whl')):
+            log.info('Downloading BAM wheel')
+            self.download_wheel(requirements['blender-bam'])
+
         # Build CacheControl.
         if not list(self.wheels_path.glob('CacheControl*.whl')):
             log.info('Building CacheControl in %s', self.cachecontrol_path)
@@ -227,7 +232,7 @@ setup(
               'wheels': BuildWheels},
     name='blender_cloud',
     description='The Blender Cloud addon allows browsing the Blender Cloud from Blender.',
-    version='1.7.1',
+    version='1.8.0',
     author='Sybren A. Stüvel',
     author_email='sybren@stuvel.eu',
     packages=find_packages('.'),

tests/test_path_replacement.py

@@ -83,8 +83,13 @@ class PathReplacementTest(unittest.TestCase):
 
     def _do_test(self, test_paths, platform, pathclass):
         self.test_manager.PurePlatformPath = pathclass
-        with unittest.mock.patch('sys.platform', platform):
+
+        def mocked_system():
+            return platform
+
+        with unittest.mock.patch('platform.system', mocked_system):
             for expected_result, input_path in test_paths:
+                as_path_instance = pathclass(input_path)
                 self.assertEqual(expected_result,
-                                 self.test_manager.replace_path(pathclass(input_path)),
+                                 self.test_manager.replace_path(as_path_instance),
-                                 'for input %s on platform %s' % (input_path, platform))
+                                 'for input %r on platform %s' % (as_path_instance, platform))