662 lines
22 KiB
Python
662 lines
22 KiB
Python
# Anansi Studio Extensions for Blender 'ABX'
|
|
"""
|
|
Collection of Blender extension tools to make our jobs easier.
|
|
This is not really meant to be an integrated plugin, but rather
|
|
a collection of useful scripts we can run to solve problems we
|
|
run into.
|
|
"""
|
|
#
|
|
#Copyright (C) 2019 Terry Hancock
|
|
#
|
|
# 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.
|
|
#
|
|
|
|
import os
|
|
|
|
import bpy, bpy.utils, bpy.types, bpy.props
|
|
from bpy.app.handlers import persistent
|
|
|
|
from . import abx_context
|
|
from . import copy_anim
|
|
from . import ink_paint
|
|
from . import render_profile
|
|
|
|
|
|
# Lunatics Scene Panel
|
|
|
|
# Lunatics file/scene properties:
|
|
|
|
# TODO: This hard-coded table is a temporary solution until I have figured
|
|
# out a good way to look these up from the project files (maybe YAML?):
|
|
seq_id_table = {
|
|
('S1', 0): {'':'', 'mt':'Main Title'},
|
|
('S1', 1): {'':'',
|
|
'TR':'Train',
|
|
'SR':'Soyuz Rollout',
|
|
'TB':'Touring Baikonur',
|
|
'PC':'Press Conference',
|
|
'SU':'Suiting Up',
|
|
'LA':'Launch',
|
|
'SF':'Soyuz Flight',
|
|
'mt':'Main Title',
|
|
'ad':'Ad Spot',
|
|
'pv':'Preview',
|
|
'et':'Episode Titles',
|
|
'cr':'Credits'
|
|
},
|
|
('S1', 2): {'':'',
|
|
'MM':'Media Montage',
|
|
'mt':'Main Title',
|
|
'et':'Episode Titles',
|
|
'SS':'Space Station',
|
|
'LC':'Loading Cargo',
|
|
'TL':'Trans Lunar Injection',
|
|
'BT':'Bed Time',
|
|
'ad':'Ad Spot',
|
|
'pv':'Preview',
|
|
'cr':'Credits'
|
|
},
|
|
('S1', 3): {'':'',
|
|
'mt':'Main Title',
|
|
'et':'Episode Titles',
|
|
'ZG':'Zero G',
|
|
'LI':'Lunar Injection',
|
|
'LO':'Lunar Orbit',
|
|
'ML':'Moon Landing',
|
|
'IR':'Iridium',
|
|
'TC':'Touring Colony',
|
|
'FD':'Family Dinner',
|
|
'ad':'Ad Spot',
|
|
'pv':'Preview',
|
|
'cr':'Credits'
|
|
},
|
|
('S2', 0): {'':'', 'mt':'Main Title'},
|
|
('L', 0): {'':'',
|
|
'demo':'Demonstration',
|
|
'prop':'Property',
|
|
'set': 'Set',
|
|
'ext': 'Exterior Set',
|
|
'int': 'Interior Set',
|
|
'prac':'Practical',
|
|
'char':'Character',
|
|
'fx': 'Special Effect',
|
|
'stock': 'Stock Animation'
|
|
},
|
|
None: ['']
|
|
}
|
|
|
|
|
|
# def get_seq_ids(self, context):
|
|
# """
|
|
# Specific function to retrieve enumerated values for sequence units.
|
|
#
|
|
# NOTE: due to be replaced by file_context features.
|
|
# """
|
|
# #
|
|
# # Note: To avoid the reference bug mentioned in the Blender documentation,
|
|
# # we only return values held in the global seq_id_table, which
|
|
# # should remain defined and therefore hold a reference to the strings.
|
|
# #
|
|
# if not context:
|
|
# seq_ids = seq_id_table[None]
|
|
# else:
|
|
# scene = context.scene
|
|
# series = scene.lunaprops.series_id
|
|
# episode = scene.lunaprops.episode_id
|
|
# if (series, episode) in seq_id_table:
|
|
# seq_ids = seq_id_table[(series, episode)]
|
|
# else:
|
|
# seq_ids = seq_id_table[None]
|
|
# seq_enum_items = [(s, s, seq_id_table[series,episode][s]) for s in seq_ids]
|
|
# return seq_enum_items
|
|
|
|
class ProjectProperties(bpy.types.PropertyGroup):
|
|
"""
|
|
Properties of the scene (and file), used for naming.
|
|
"""
|
|
# name_context_id = bpy.props.StringProperty(options={'HIDDEN', 'LIBRARY_EDITABLE'})
|
|
#
|
|
# @property
|
|
# def name_context(self):
|
|
# if self.name_context_id in BlendFile.name_contexts:
|
|
# return BlendFile.name_contexts[self.name_context_id]
|
|
# else:
|
|
# name_context = BlendFile.new_name_context()
|
|
# self.name_context_id = str(id(name_context))
|
|
# return name_context
|
|
render_root = bpy.props.StringProperty(
|
|
name = 'Render Root',
|
|
description = 'Path to where renders should be stored',
|
|
subtype = 'FILE_PATH')
|
|
|
|
render_folder = bpy.props.StringProperty(
|
|
name = 'Render Folder',
|
|
description = 'Relative path from Render Root (without filename)',
|
|
subtype = 'FILE_NAME')
|
|
|
|
render_prefix = bpy.props.StringProperty(
|
|
name = 'Render Prefix',
|
|
description = 'Prefix used to create filenames used in rendering',
|
|
subtype = 'FILE_NAME')
|
|
|
|
designation = bpy.props.StringProperty(
|
|
name = 'Designation',
|
|
description = 'Short code for this Blender scene only',
|
|
maxlen=16)
|
|
|
|
scene_suffix = bpy.props.StringProperty(
|
|
name = 'Scene Suffix',
|
|
description = 'Short descriptive annotation for this scene (used only in scene name)',
|
|
maxlen=16)
|
|
|
|
role = bpy.props.EnumProperty(
|
|
name = 'Role',
|
|
description = 'Role of this scene in project',
|
|
items = (('cam', 'Camera', 'Camera direction and render to EXR'),
|
|
('compos', 'Compositing', 'Post-compositing from EXR'),
|
|
('anim', 'Animation', 'Character animation scene'),
|
|
('mech', 'Mechanical', 'Mech animation scene'),
|
|
('asset', 'Asset', 'Project model assets'),
|
|
('prop', 'Prop', 'Stage property asset'),
|
|
('char', 'Character', 'Character model asset'),
|
|
('prac', 'Practical', 'Practical property - rigged prop')),
|
|
default='cam')
|
|
|
|
frame_start = bpy.props.IntProperty(
|
|
name = 'Start',
|
|
description = "Start frame of shot (used to set the render start frame)",
|
|
soft_min = 0, soft_max=10000)
|
|
|
|
frame_end = bpy.props.IntProperty(
|
|
name = 'End',
|
|
description = "End frame of shot (used to set the render end frame)",
|
|
soft_min = 0, soft_max=10000)
|
|
|
|
frame_rate = bpy.props.IntProperty(
|
|
default = 30,
|
|
name = 'FPS',
|
|
description = "Frame rate for shot",
|
|
soft_max = 30,
|
|
min = 1, max = 120)
|
|
|
|
ink = bpy.props.EnumProperty(
|
|
items = (('FS', 'Freestyle', 'Uses Freestyle Ink'),
|
|
('EN', 'Edge Node', 'Uses EdgeNode for Ink'),
|
|
('FE', 'FS + EN', 'Uses both Freestyle & EdgeNode for Ink'),
|
|
('NI', 'No Ink', 'Does not use ink (paint render used for final)'),
|
|
('CU', 'Custom', 'Custom setup, do not touch ink settings')),
|
|
default = 'CU',
|
|
name = 'Ink Type',
|
|
description = "Determines how ink will be handled in final shot render")
|
|
|
|
@property
|
|
def scene_name(self):
|
|
if self.scene_suffix:
|
|
return self.designation + ' ' + self.scene_suffix
|
|
else:
|
|
return self.designation
|
|
|
|
@property
|
|
def render_stem(self):
|
|
if self.render_prefix:
|
|
return self.render_prefix + '-' + self.designation
|
|
else:
|
|
return self.designation
|
|
|
|
def render_path(self, suffix='', framedigits=5, ext='png', rdr_fmt='PNG'):
|
|
if suffix:
|
|
suffix = '-' + suffix
|
|
if rdr_fmt in ('AVI', 'MKV'):
|
|
path = os.path.join(self.render_root, self.render_folder, suffix,
|
|
self.render_prefix + self.designation + suffix + '.' + ext)
|
|
else:
|
|
path = os.path.join(self.render_root, self.render_folder, suffix, self.designation,
|
|
self.render_prefix + self.designation + suffix + '-f' + '#'*framedigits + '.' + ext)
|
|
return path
|
|
|
|
class ProjectPanel(bpy.types.Panel):
|
|
"""
|
|
Add a panel to the Properties-Scene screen with Project Settings.
|
|
"""
|
|
bl_idname = 'SCENE_PT_project'
|
|
bl_label = 'Project Properties'
|
|
bl_space_type = 'PROPERTIES'
|
|
bl_region_type = 'WINDOW'
|
|
bl_context = 'scene'
|
|
|
|
def draw(self, context):
|
|
pp = bpy.context.scene.project_properties
|
|
self.layout.label(text='Project Properties')
|
|
row = self.layout.row()
|
|
row.prop(pp, 'render_root')
|
|
row = self.layout.row()
|
|
row.prop(pp, 'render_folder')
|
|
row = self.layout.row()
|
|
row.prop(pp, 'render_prefix')
|
|
row.prop(pp, 'designation')
|
|
row.prop(pp, 'scene_suffix')
|
|
self.layout.label(text='Render Range')
|
|
row = self.layout.row()
|
|
row.prop(pp, 'frame_start')
|
|
row.prop(pp, 'frame_end')
|
|
row.prop(pp, 'frame_rate')
|
|
self.layout.label(text='Extra')
|
|
row = self.layout.row()
|
|
row.prop(pp, 'role')
|
|
row.prop(pp, 'ink')
|
|
|
|
# Buttons
|
|
|
|
|
|
|
|
# class LunaticsSceneProperties(bpy.types.PropertyGroup):
|
|
# """
|
|
# Properties of the current scene.
|
|
#
|
|
# NOTE: due to be replaced by 'ProjectProperties', using the schema data
|
|
# retrieved by file_context.
|
|
# """
|
|
#
|
|
# series_id = bpy.props.EnumProperty(
|
|
# items=[
|
|
# ('S1', 'S1', 'Series One'),
|
|
# ('S2', 'S2', 'Series Two'),
|
|
# ('S3', 'S3', 'Series Three'),
|
|
# ('A1', 'Aud','Audiodrama'),
|
|
# ('L', 'Lib','Library')
|
|
# ],
|
|
# name="Series",
|
|
# default='S1',
|
|
# description="Series/Season of Animated Series, Audiodrama, or Library"
|
|
# )
|
|
#
|
|
# episode_id = bpy.props.IntProperty(
|
|
# name="Episode",
|
|
# default=0,
|
|
# description="Episode number (0 means multi-use), ignored for Library",
|
|
# min=0,
|
|
# max=1000,
|
|
# soft_max=18
|
|
# )
|
|
#
|
|
# seq_id = bpy.props.EnumProperty(
|
|
# name='',
|
|
# items=get_seq_ids,
|
|
# description="Sequence ID"
|
|
# )
|
|
#
|
|
# block_id = bpy.props.IntProperty(
|
|
# name='',
|
|
# default=1,
|
|
# min=0,
|
|
# max=20,
|
|
# soft_max=10,
|
|
# description="Block number"
|
|
# )
|
|
#
|
|
# use_multicam = bpy.props.BoolProperty(
|
|
# name="Multicam",
|
|
# default=False,
|
|
# description="Use multicam camera/shot numbering?"
|
|
# )
|
|
#
|
|
# cam_id = bpy.props.IntProperty(
|
|
# name="Cam",
|
|
# default=0,
|
|
# min=0,
|
|
# max=20,
|
|
# soft_max=10,
|
|
# description="Camera number"
|
|
# )
|
|
#
|
|
# shot_id = bpy.props.EnumProperty(
|
|
# name='Shot',
|
|
# #items=[('NONE', '', 'Single')]+[(c,c,'Shot '+c) for c in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'],
|
|
# items=[(c,c,'Shot '+c) for c in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'],
|
|
# default='A',
|
|
# description="Shot ID, normally a single capital letter, can be empty, two letters for transitions"
|
|
# )
|
|
#
|
|
# shot_name = bpy.props.StringProperty(
|
|
# name='Name',
|
|
# description='Short descriptive codename',
|
|
# maxlen=0
|
|
# )
|
|
#
|
|
#
|
|
#
|
|
# class LunaticsScenePanel(bpy.types.Panel):
|
|
# """
|
|
# Add a panel to the Properties-Scene screen
|
|
#
|
|
# NOTE: To be replaced by 'ProjectPropertiesPanel'.
|
|
# """
|
|
# bl_idname = 'SCENE_PT_lunatics'
|
|
# bl_label = 'Lunatics Project'
|
|
# bl_space_type = 'PROPERTIES'
|
|
# bl_region_type = 'WINDOW'
|
|
# bl_context = 'scene'
|
|
#
|
|
# def draw(self, context):
|
|
# lunaprops = bpy.context.scene.lunaprops
|
|
# self.layout.label(text='Lunatics! Project Properties')
|
|
# row = self.layout.row()
|
|
# row.prop(lunaprops, 'series_id')
|
|
# row.prop(lunaprops, 'episode_id')
|
|
# row = self.layout.row()
|
|
# row.prop(lunaprops, 'use_multicam')
|
|
# row = self.layout.row()
|
|
# row.prop(lunaprops, 'seq_id')
|
|
# row.prop(lunaprops, 'block_id')
|
|
# if lunaprops.use_multicam:
|
|
# row.prop(lunaprops, 'cam_id')
|
|
# row.prop(lunaprops, 'shot_id')
|
|
# row.prop(lunaprops, 'shot_name')
|
|
|
|
# Buttons
|
|
|
|
|
|
|
|
class RenderProfilesOperator(bpy.types.Operator):
|
|
"""
|
|
Operator invoked implicitly when render profile is changed.
|
|
"""
|
|
bl_idname = 'render.render_profiles'
|
|
bl_label = 'Apply Render Profile'
|
|
bl_options = {'UNDO'}
|
|
|
|
def invoke(self, context, event):
|
|
scene = context.scene
|
|
profile = scene.render_profile_settings.render_profile
|
|
|
|
BlendFile.render_profiles.apply(scene, profile)
|
|
|
|
return {'FINISHED'}
|
|
|
|
|
|
class RenderProfilesPanel(bpy.types.Panel):
|
|
"""
|
|
Add simple drop-down selector for generating common render settings with
|
|
destination set according to project defaults.
|
|
"""
|
|
bl_idname = 'SCENE_PT_render_profiles'
|
|
bl_label = 'Render Profiles'
|
|
bl_space_type = 'PROPERTIES'
|
|
bl_region_type = 'WINDOW'
|
|
bl_context = 'render'
|
|
|
|
def draw(self, context):
|
|
rps = bpy.context.scene.render_profile_settings
|
|
row = self.layout.row()
|
|
row.prop(rps, 'render_profile')
|
|
row = self.layout.row()
|
|
row.operator('render.render_profiles')
|
|
|
|
class reset_rigify_after_scale(bpy.types.Operator):
|
|
"""
|
|
Fix selected Rigify-type Rig after scaling.
|
|
|
|
Resets the "STRETCH TO" constraints on a Rigify rig after they've been
|
|
disturbed by rescaling
|
|
"""
|
|
bl_idname = 'object.reset_scaled_rigify'
|
|
bl_label = "Reset Rigify"
|
|
bl_options = {'UNDO'}
|
|
|
|
def invoke(self, context, event):
|
|
tgt_obs = [ob for ob in context.selected_objects if ob.type == 'ARMATURE']
|
|
for ob in tgt_obs:
|
|
copy_anim.reset_armature_stretch_constraints(ob)
|
|
return {'FINISHED'}
|
|
|
|
|
|
class copy_animation(bpy.types.Operator):
|
|
"""
|
|
Copy animation from active object to selected objects (select source last!).
|
|
|
|
Useful for fixing broken proxy rigs. Can also re-scale
|
|
"""
|
|
bl_idname = 'object.copy_anim'
|
|
bl_label = 'Copy Animation'
|
|
bl_options = {'UNDO'}
|
|
|
|
def invoke(self, context, event):
|
|
#print("Copy NLA from selected armature to active armatures.")
|
|
|
|
src_ob = context.active_object
|
|
tgt_obs = [ob for ob in context.selected_objects if ob != context.active_object]
|
|
|
|
# TODO
|
|
# Are these type checks necessary?
|
|
# Is there any reason to restrict this operator to armature objects?
|
|
# I think there isn't.
|
|
|
|
if src_ob.type != 'ARMATURE':
|
|
self.report({'WARNING'}, 'Cannot copy NLA data from object that is not an ARMATURE.')
|
|
return {'CANCELLED'}
|
|
|
|
tgt_arm_obs = []
|
|
for ob in tgt_obs:
|
|
if ob.type == 'ARMATURE':
|
|
tgt_arm_obs.append(ob)
|
|
if not tgt_arm_obs:
|
|
self.report({'WARNING'}, 'No armature objects selected to copy animation data to.')
|
|
return {'CANCELLED'}
|
|
|
|
copy_anim.copy_object_animation(src_ob, tgt_arm_obs,
|
|
dopesheet=context.scene.copy_anim_settings.dopesheet,
|
|
nla=context.scene.copy_anim_settings.nla,
|
|
rescale=context.scene.copy_anim_settings.rescale,
|
|
scale_factor=context.scene.copy_anim_settings.scale_factor,
|
|
report=self.report)
|
|
|
|
return {'FINISHED'}
|
|
|
|
|
|
|
|
class copy_animation_settings(bpy.types.PropertyGroup):
|
|
"""
|
|
Settings for the 'copy_animation' operator.
|
|
"""
|
|
dopesheet = bpy.props.BoolProperty(
|
|
name = "Dope Sheet",
|
|
description = "Copy animation from Dope Sheet",
|
|
default=True)
|
|
|
|
nla = bpy.props.BoolProperty(
|
|
name = "NLA Strips",
|
|
description = "Copy all strips from NLA Editor",
|
|
default=True)
|
|
|
|
rescale = bpy.props.BoolProperty(
|
|
name = "Re-Scale/Copy",
|
|
description = "Make rescaled COPY of actions instead of LINK to original",
|
|
default = False)
|
|
|
|
scale_factor = bpy.props.FloatProperty(
|
|
name = "Scale",
|
|
description = "Scale factor for scaling animation (Re-Scale w/ 1.0 copies actions)",
|
|
default = 1.0)
|
|
|
|
|
|
class CharacterPanel(bpy.types.Panel):
|
|
"""
|
|
Features for working with characters and armatures.
|
|
|
|
Currently only includes the CopyAnimation operator.
|
|
"""
|
|
bl_space_type = "VIEW_3D" # window type panel is displayed in
|
|
bl_context = "objectmode"
|
|
bl_region_type = "TOOLS" # region of window panel is displayed in
|
|
bl_label = "Character"
|
|
bl_category = "ABX"
|
|
|
|
def draw(self, context):
|
|
settings = bpy.context.scene.copy_anim_settings
|
|
layout = self.layout.column(align = True)
|
|
layout.label("Animation Data")
|
|
layout.operator('object.copy_anim')
|
|
layout.prop(settings, 'dopesheet')
|
|
layout.prop(settings, 'nla')
|
|
layout.prop(settings, 'rescale')
|
|
layout.prop(settings, 'scale_factor')
|
|
layout.separator()
|
|
layout.operator('object.reset_scaled_rigify')
|
|
|
|
|
|
|
|
class InkPaintProps(bpy.types.PropertyGroup):
|
|
"""
|
|
Settings for Ink/Paint Config.
|
|
"""
|
|
inkthru = bpy.props.BoolProperty(
|
|
name = "Ink-Thru",
|
|
description = "Support transparent Freestyle ink effect",
|
|
default=True)
|
|
|
|
billboards = bpy.props.BoolProperty(
|
|
name = "Billboards",
|
|
description = "Support material pass for correct billboard inking",
|
|
default = False)
|
|
|
|
sepsky = bpy.props.BoolProperty(
|
|
name = "Separate Sky",
|
|
description = "Render sky separately with compositing support (better shadows)",
|
|
default = True)
|
|
|
|
|
|
class InkPaintOp(bpy.types.Operator):
|
|
"""
|
|
Ink/Paint Config Operator.
|
|
"""
|
|
bl_idname = "scene.lunatics_compos"
|
|
bl_label = "Ink/Paint Config"
|
|
bl_options = {'UNDO'}
|
|
bl_description = "Set up standard Lunatics Ink/Paint compositing in scene"
|
|
|
|
def invoke(self, context, event):
|
|
"""
|
|
Add standard 'Lunatics!' shot compositing to the currently-selected scene.
|
|
"""
|
|
scene = context.scene
|
|
|
|
shot = ink_paint.InkPaintShot(scene,
|
|
inkthru=context.scene.lx_compos_settings.inkthru,
|
|
billboards=context.scene.lx_compos_settings.billboards,
|
|
sepsky=context.scene.lx_compos_settings.sepsky )
|
|
|
|
shot.cfg_scene()
|
|
|
|
return {'FINISHED'}
|
|
|
|
|
|
|
|
class InkPaintPanel(bpy.types.Panel):
|
|
"""
|
|
Ink/Paint Configuration panel.
|
|
"""
|
|
bl_space_type = "VIEW_3D"
|
|
bl_context = "objectmode"
|
|
bl_region_type = "TOOLS"
|
|
bl_label = "Lunatics"
|
|
bl_category = "ABX"
|
|
|
|
def draw(self, context):
|
|
settings = bpy.context.scene.lx_compos_settings
|
|
layout = self.layout.column(align = True)
|
|
layout.label("Compositing")
|
|
layout.operator('scene.lunatics_compos')
|
|
layout.prop(settings, 'inkthru', text="Ink-Thru")
|
|
layout.prop(settings, 'billboards', text="Billboards")
|
|
layout.prop(settings, 'sepsky', text="Separate Sky")
|
|
|
|
|
|
BlendFile = abx_context.ABX_Context()
|
|
|
|
class RenderProfileSettings(bpy.types.PropertyGroup):
|
|
"""
|
|
Settings for Render Profiles control.
|
|
"""
|
|
render_profile = bpy.props.EnumProperty(
|
|
name='Profile',
|
|
items=render_profile.blender_enum_lookup,
|
|
description="Select from render profiles defined in project")
|
|
|
|
|
|
@persistent
|
|
def update_handler(ctxt):
|
|
"""
|
|
Keeps ABX_Context up-to-date with Blender file loaded.
|
|
"""
|
|
BlendFile.update(bpy.data.filepath)
|
|
|
|
|
|
def register():
|
|
# bpy.utils.register_class(LunaticsSceneProperties)
|
|
# bpy.types.Scene.lunaprops = bpy.props.PointerProperty(type=LunaticsSceneProperties)
|
|
# bpy.utils.register_class(LunaticsScenePanel)
|
|
|
|
bpy.utils.register_class(ProjectProperties)
|
|
bpy.types.Scene.project_properties = bpy.props.PointerProperty(type=ProjectProperties)
|
|
bpy.utils.register_class(ProjectPanel)
|
|
|
|
bpy.utils.register_class(RenderProfileSettings)
|
|
bpy.types.Scene.render_profile_settings = bpy.props.PointerProperty(
|
|
type=RenderProfileSettings)
|
|
bpy.utils.register_class(RenderProfilesOperator)
|
|
bpy.utils.register_class(RenderProfilesPanel)
|
|
|
|
bpy.utils.register_class(reset_rigify_after_scale)
|
|
|
|
bpy.utils.register_class(copy_animation)
|
|
bpy.utils.register_class(copy_animation_settings)
|
|
bpy.types.Scene.copy_anim_settings = bpy.props.PointerProperty(type=copy_animation_settings)
|
|
bpy.utils.register_class(CharacterPanel)
|
|
|
|
bpy.utils.register_class(InkPaintProps)
|
|
bpy.types.Scene.lx_compos_settings = bpy.props.PointerProperty(type=InkPaintProps)
|
|
bpy.utils.register_class(InkPaintOp)
|
|
bpy.utils.register_class(InkPaintPanel)
|
|
|
|
bpy.app.handlers.save_post.append(update_handler)
|
|
bpy.app.handlers.load_post.append(update_handler)
|
|
bpy.app.handlers.scene_update_post.append(update_handler)
|
|
|
|
def unregister():
|
|
bpy.app.handlers.save_post.remove(update_handler)
|
|
bpy.app.handlers.load_post.remove(update_handler)
|
|
bpy.app.handlers.scene_update_post.remove(update_handler)
|
|
|
|
# bpy.utils.unregister_class(LunaticsSceneProperties)
|
|
# bpy.utils.unregister_class(LunaticsScenePanel)
|
|
|
|
bpy.utils.unregister_class(ProjectProperties)
|
|
|
|
bpy.utils.unregister_class(RenderProfileSettings)
|
|
bpy.utils.unregister_class(RenderProfilesOperator)
|
|
bpy.utils.unregister_class(RenderProfilesPanel)
|
|
|
|
bpy.utils.unregister_class(reset_rigify_after_scale)
|
|
|
|
bpy.utils.unregister_class(copy_animation)
|
|
bpy.utils.unregister_class(copy_animation_settings)
|
|
bpy.utils.unregister_class(CharacterPanel)
|
|
|
|
bpy.utils.unregister_class(InkPaintProps)
|
|
bpy.utils.unregister_class(InkPaintOp)
|
|
bpy.utils.unregister_class(InkPaintPanel)
|
|
|
|
|