This repository has been archived on 2023-10-03. You can view files and clone it, but cannot push or open issues or pull requests.

801 lines
27 KiB
Python
Raw Normal View History

# ##### 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
2016-04-13 15:37:19 +02:00
import logging
2016-07-08 17:00:44 +02:00
import os.path
import tempfile
2016-04-13 15:37:19 +02:00
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, project_specific
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
2016-05-04 14:30:47 +02:00
ADDON_NAME = "blender_cloud"
2016-04-13 15:37:19 +02:00
log = logging.getLogger(__name__)
2016-07-08 17:00:44 +02:00
icons = None
@pyside_cache
def blender_syncable_versions(self, context):
2016-08-26 17:43:20 +02:00
"""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
2016-08-26 17:43:20 +02:00
def bcloud_available_projects(self, context):
"""Returns the list of items used by BlenderCloudProjectGroup.project EnumProperty."""
projs = preferences().project.available_projects
2016-08-26 17:43:20 +02:00
if not projs:
return [("", "No projects available in your Blender Cloud", "")]
return [(p["_id"], p["name"], "") for p in projs]
2016-08-26 17:43:20 +02:00
@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", ()))
2016-08-26 17:43:20 +02:00
class BlenderCloudProjectGroup(PropertyGroup):
status: EnumProperty(
2016-08-26 17:43:20 +02:00
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"),
2016-08-26 17:43:20 +02:00
],
name="status",
update=redraw,
)
2016-08-26 17:43:20 +02:00
project: EnumProperty(
2016-08-26 17:43:20 +02:00
items=bcloud_available_projects,
name="Cloud project",
description="Which Blender Cloud project to work with",
update=project_specific.handle_project_update,
)
2016-08-26 17:43:20 +02:00
# 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", [])
2016-08-26 17:43:20 +02:00
@available_projects.setter
def available_projects(self, new_projects):
self["available_projects"] = new_projects
project_specific.handle_project_update()
2016-08-26 17:43:20 +02:00
class BlenderCloudPreferences(AddonPreferences):
bl_idname = ADDON_NAME
# 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",
description="URL of the Blender Cloud backend server",
2016-05-04 14:30:47 +02:00
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="//../",
update=project_specific.store,
)
2016-08-26 17:43:20 +02:00
flamenco_manager: PointerProperty(type=flamenco.FlamencoManagerGroup)
flamenco_exclude_filter: StringProperty(
name="File Exclude Filter",
description='Space-separated list of filename filters, like "*.abc *.mkv", to prevent '
"matching files from being packed into the output directory",
default="",
update=project_specific.store,
)
flamenco_job_file_path: StringProperty(
name="Job Storage Path",
description="Path where to store job files, should be accesible for Workers too",
subtype="DIR_PATH",
default=tempfile.gettempdir(),
update=project_specific.store,
)
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=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 "
"path relative to the project with this many path components stripped off "
"the front",
min=0,
default=0,
soft_max=4,
update=project_specific.store,
)
flamenco_relative_only: BoolProperty(
name="Relative Paths Only",
description="When enabled, only assets that are referred to with a relative path are "
"packed, and assets referred to by an absolute path are excluded from the "
"BAT pack. When disabled, all assets are packed",
default=False,
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,
)
flamenco_show_quit_after_submit_button: BoolProperty(
name='Show "Submit & Quit" button',
description='When enabled, next to the "Render on Flamenco" button there will be a button '
'"Submit & Quit" that silently quits Blender after submitting the render job '
"to Flamenco",
default=False,
)
def draw(self, context):
2016-05-03 18:29:43 +02:00
import textwrap
layout = self.layout
# Carefully try and import the Blender ID addon
try:
2016-04-01 14:11:12 +02:00
import blender_id
except ImportError:
2016-04-01 14:11:12 +02:00
blender_id = None
blender_id_profile = None
else:
2016-04-01 14:11:12 +02:00
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()
2016-07-08 17:00:44 +02:00
auth_box.label(text=text, icon=msg_icon)
2016-05-03 18:29:43 +02:00
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(factor=0.33)
row.label(text="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(text=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(text="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(factor=0.5)
row_push = row_buttons.row()
2016-06-28 16:55:35 +02:00
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
if bss.status in {"NONE", "IDLE"}:
if not versions:
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" % bss.version,
icon="TRIA_DOWN",
)
props.action = "PULL"
props.blender_version = bss.version
row_pull.operator(
"pillar.sync", text="", icon="DOWNARROW_HLT"
).action = "SELECT"
else:
row_pull.label(text="Cloud Sync is running.")
def draw_project_selector(self, project_box, bcp: BlenderCloudProjectGroup):
project_row = project_box.row(align=True)
project_row.label(text="Project settings", icon_value=icon("CLOUD"))
row_buttons = project_row.row(align=True)
2016-08-26 17:43:20 +02:00
projects = bcp.available_projects
project = bcp.project
if bcp.status in {"NONE", "IDLE"}:
if not projects:
row_buttons.operator(
"pillar.projects", text="Find project to load", icon="FILE_REFRESH"
)
2016-08-26 17:43:20 +02:00
else:
row_buttons.prop(bcp, "project")
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
2016-08-26 17:43:20 +02:00
else:
row_buttons.label(text="Fetching available projects.")
2016-08-26 17:43:20 +02:00
enabled_for = project_extensions(project)
if not project:
return
if not enabled_for:
project_box.label(text="This project is not set up for Attract or Flamenco")
return
project_box.label(
text="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 Project Path")
def draw_flamenco_buttons(
self, flamenco_box, bcp: flamenco.FlamencoManagerGroup, context
):
header_row = flamenco_box.row(align=True)
header_row.label(text="Flamenco:", icon_value=icon("CLOUD"))
manager_split = flamenco_box.split(factor=0.32, align=True)
manager_split.label(text="Manager:")
manager_box = manager_split.row(align=True)
if bcp.status in {"NONE", "IDLE"}:
if not bcp.available_managers:
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(text="Fetching available managers.")
path_split = flamenco_box.split(factor=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(factor=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(factor=0.32, align=True)
prop_split.label(text="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(text=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(
text="Blend file is not in your project path, "
"unable to give output path example."
)
flamenco_box.prop(self, "flamenco_relative_only")
flamenco_box.prop(self, "flamenco_open_browser_after_submit")
flamenco_box.prop(self, "flamenco_show_quit_after_submit_button")
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)
2016-07-14 11:47:50 +02:00
@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):
2016-04-01 17:16:29 +02:00
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:
2016-05-04 14:30:47 +02:00
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_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,
):
2016-10-18 12:23:36 +02:00
"""Fetches the projects available to the user"""
bl_idname = "pillar.projects"
bl_label = "Fetch available projects"
2016-08-26 17:43:20 +02:00
stop_upon_exception = True
_log = logging.getLogger("bpy.ops.%s" % bl_idname)
2016-08-26 17:43:20 +02:00
async def async_execute(self, context):
if not await self.authenticate(context):
return
2016-08-26 17:43:20 +02:00
import pillarsdk
from .pillar import pillar_call
self.log.info("Going to fetch projects for user %s", self.user_id)
2016-08-26 17:43:20 +02:00
preferences().project.status = "FETCHING"
2016-08-26 17:43:20 +02:00
# Get all projects, except the home project.
projects_user = await pillar_call(
pillarsdk.Project.all,
{
"where": {"user": self.user_id, "category": {"$ne": "home"}},
"sort": "-name",
"projection": {"_id": True, "name": True, "extension_props": True},
},
)
2016-08-26 17:43:20 +02:00
projects_shared = await pillar_call(
pillarsdk.Project.all,
{
"where": {
"user": {"$ne": self.user_id},
"permissions.groups.group": {"$in": self.db_user.groups},
},
"sort": "-name",
"projection": {"_id": True, "name": True, "extension_props": True},
},
)
2016-08-26 17:43:20 +02:00
# 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"])
)
2016-08-26 17:43:20 +02:00
def proj_sort_key(project):
return project.get("name")
preferences().project.available_projects = sorted(projects, key=proj_sort_key)
2016-08-26 17:43:20 +02:00
self.quit()
def quit(self):
preferences().project.status = "IDLE"
2016-08-26 17:43:20 +02:00
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 ctx_preferences():
"""Returns bpy.context.preferences in a 2.79-compatible way."""
try:
return bpy.context.preferences
except AttributeError:
return bpy.context.user_preferences
def preferences() -> BlenderCloudPreferences:
return ctx_preferences().addons[ADDON_NAME].preferences
2016-07-08 17:00:44 +02:00
def load_custom_icons():
global icons
if icons is not None:
# Already loaded
return
import bpy.utils.previews
2016-07-08 17:00:44 +02:00
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")
2016-07-08 17:00:44 +02:00
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)
2016-08-26 17:43:20 +02:00
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)
2016-05-17 17:30:38 +02:00
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)
2016-07-08 17:00:44 +02:00
load_custom_icons()
def unregister():
2016-07-08 17:00:44 +02:00
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)
2016-08-26 17:43:20 +02:00
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
del WindowManager.blender_sync_status