def execute(self, context):
_LOG.enter()
print("default".ljust(40, '.') + ": " + LogService.LOGLEVELS[LogService.get_default_log_level()])
loggers = LogService.get_loggers()
logger_names = list(loggers.keys())
logger_names.sort()
for name in logger_names:
logger = loggers[name]
level = "(default)"
if logger.level_is_overridden:
level = logger.level
level = LogService.LOGLEVELS[level]
print(name.ljust(40, '.') + ": " + level)
self.report({"INFO"}, "Levels were printed to the console")
return {'FINISHED'}
def _populate_list(self, context):
global _NEED_RELOAD # pylint: disable=W0603
global _CACHED_LEVELS_LIST # pylint: disable=W0603
_LOG.enter()
_LOG.trace("Context is scene", isinstance(context, bpy.types.Scene))
if _NEED_RELOAD:
_CACHED_LEVELS_LIST = LogService.get_loggers_list_as_property_enum()
_NEED_RELOAD = False
return _CACHED_LEVELS_LIST
def execute(self, context):
_LOG.enter()
loggers = LogService.get_loggers()
scene = context.scene
from mpfb.ui.developer.developerpanel import LOG_LEVELS_PROPERTIES # pylint: disable=C0415
logger_name = LOG_LEVELS_PROPERTIES.get_value("available_loggers", entity_reference=scene)
if logger_name == "default":
input_path = LogService.get_path_to_combined_log_file()
else:
logger = LogService.get_logger(logger_name)
input_path = logger.get_path_to_log_file()
output_path = bpy.path.abspath(self.filepath)
shutil.copy(input_path, output_path)
return {'FINISHED'}
from mpfb.services.logservice import LogService
from mpfb.services.uiservice import UiService
from mpfb.services.locationservice import LocationService
from mpfb.services.objectservice import ObjectService
from mpfb.services.nodeservice import NodeService
from mpfb.services.materialservice import MaterialService
from mpfb.ui.enhancedsettings.enhancedsettingspanel import ENHANCED_SETTINGS_PROPERTIES
from mpfb._classmanager import ClassManager
import bpy, os, json
from ._savematerial import _save_material
_LOG = LogService.get_logger("enhancedsettings.overwritesettings")
class MPFB_OT_OverwriteEnhancedSettingsOperator(bpy.types.Operator):
"""This will overwrite the selected enhanced material settings, using values from the selected object's material"""
bl_idname = "mpfb.overwrite_enhanced_settings"
bl_label = "Overwrite settings"
bl_options = {'REGISTER'}
def execute(self, context):
_LOG.enter()
if context.object is None:
self.report({'ERROR'}, "Must have a selected object")
return {'FINISHED'}
name = ENHANCED_SETTINGS_PROPERTIES.get_value("available_settings",
entity_reference=context)
if not name is None:
import re, os
from .mhmatkeys import MHMAT_KEY_GROUPS, MHMAT_NAME_TO_KEY
from .mhmatkeytypes import MhMatFileKey
from mpfb.services.socketservice import SocketService
from mpfb.services.logservice import LogService
_LOG = LogService.get_logger("material.mhmaterial")
class MhMaterial:
def __init__(self):
self._settings = dict()
self._shader_config = dict()
# TODO: handle litsphere and shaderconfig
self.lit_sphere = dict()
self.shader_config = dict()
def _parse_material_line(self, line):
match = re.search(r'^([a-zA-Z]+)\s+(.*)$', line)
if match:
key = match.group(1)
key_lower = key.lower()
value = None
if key_lower in MHMAT_NAME_TO_KEY:
key_obj = MHMAT_NAME_TO_KEY[key_lower]
key_correct_case = key_obj.key_name
if key != key_correct_case:
_LOG.debug("Autofixing case: " + key + " -> " +
from mpfb.services.logservice import LogService
_LOG = LogService.get_logger("importeroperators.init")
_LOG.trace("initializing importer operators")
from .loadpresets import MPFB_OT_LoadImporterPresetsOperator
from .overwritepresets import MPFB_OT_OverwriteImporterPresetsOperator
from .savenewpresets import MPFB_OT_SaveNewImporterPresetsOperator
__all__ = [
"MPFB_OT_LoadImporterPresetsOperator",
"MPFB_OT_OverwriteImporterPresetsOperator",
"MPFB_OT_SaveNewImporterPresetsOperator"
]
"""Operator for opening web browser"""
import webbrowser, bpy
from bpy.props import StringProperty
from mpfb.services.logservice import LogService
from mpfb import ClassManager
_LOG = LogService.get_logger("webresources.webresource")
class MPFB_OT_Web_Resource_Operator(bpy.types.Operator):
"""Open web browser"""
bl_idname = "mpfb.web_resource"
bl_label = "Open"
bl_options = {'REGISTER'}
url: StringProperty(name="url", description="Address to open", default="")
def execute(self, context):
webbrowser.open(self.url)
return {'FINISHED'}
ClassManager.add_class(MPFB_OT_Web_Resource_Operator)
"""Functionality for listing log levels"""
from mpfb.services.logservice import LogService
from mpfb._classmanager import ClassManager
import bpy
_LOG = LogService.get_logger("loglevels.operators.listloglevels")
class MPFB_OT_List_Log_Levels_Operator(bpy.types.Operator):
"""List log levels to the console"""
bl_idname = "mpfb.list_log_levels"
bl_label = "List log levels"
bl_options = {'REGISTER'}
def execute(self, context):
_LOG.enter()
print("default".ljust(40, '.') + ": " + LogService.LOGLEVELS[LogService.get_default_log_level()])
loggers = LogService.get_loggers()
logger_names = list(loggers.keys())
logger_names.sort()
for name in logger_names:
logger = loggers[name]
level = "(default)"
if logger.level_is_overridden:
level = logger.level
level = LogService.LOGLEVELS[level]
print(name.ljust(40, '.') + ": " + level)
self.report({"INFO"}, "Levels were printed to the console")
from mpfb.services.logservice import LogService
_LOG = LogService.get_logger("setupikoperators.init")
_LOG.trace("initializing setup ik operators")
from .addhelpers import MPFB_OT_AddHelpersOperator
from .removehelpers import MPFB_OT_RemoveHelpersOperator
__all__ = ["MPFB_OT_AddHelpersOperator", "MPFB_OT_RemoveHelpersOperator"]
"""Operator for importing MHMAT material."""
import bpy
from bpy_extras.io_utils import ImportHelper
from bpy.props import StringProperty
from mpfb.entities.material.makeskinmaterial import MakeSkinMaterial
from mpfb.services.logservice import LogService
from mpfb.services.materialservice import MaterialService
from mpfb import ClassManager
_LOG = LogService.get_logger("makeskin.importmaterial")
class MPFB_OT_ImportMaterialOperator(bpy.types.Operator, ImportHelper):
"""Import MHMAT"""
bl_idname = "mpfb.import_makeskin_material"
bl_label = "Import material"
bl_options = {'REGISTER', 'UNDO'}
filter_glob: StringProperty(default='*.mhmat', options={'HIDDEN'})
@classmethod
def poll(cls, context):
if context.active_object is not None:
if not hasattr(context.active_object, "MhObjectType"):
return False
return True
return False
def execute(self, context):
obj = context.active_object
"""This module hierarchy provides utility classes for adding and
removing helper bones (for example IK targets, grip rotation handles etc)
to the finger section of a makehuman rig."""
from mpfb.services.logservice import LogService
_LOG = LogService.get_logger("fingerhelpers.init")
_LOG.trace("initializing fingerhelpers module")
"""This file contains the load clothes panel."""
from mpfb._classmanager import ClassManager
from mpfb.services.logservice import LogService
from mpfb.services.uiservice import UiService
from mpfb.services.sceneconfigset import SceneConfigSet
from mpfb.ui.abstractpanel import Abstract_Panel
import bpy, os
_LOG = LogService.get_logger("ui.loadclothespanel")
_LOC = os.path.dirname(__file__)
LOAD_CLOTHES_PROPERTIES_DIR = os.path.join(_LOC, "properties")
LOAD_CLOTHES_PROPERTIES = SceneConfigSet.from_definitions_in_json_directory(
LOAD_CLOTHES_PROPERTIES_DIR, prefix="LC_")
class MPFB_PT_Load_Clothes_Panel(Abstract_Panel):
"""UI for loading MHCLO files."""
bl_label = "Load MHCLO"
bl_category = UiService.get_value("CLOTHESCATEGORY")
bl_options = {'DEFAULT_CLOSED'}
bl_parent_id = "MPFB_PT_Assets_Panel"
def draw(self, context):
_LOG.enter()
layout = self.layout
scene = context.scene
LOAD_CLOTHES_PROPERTIES.draw_properties(scene, layout, [
"object_type", "material_type", "fit_to_body", "delete_group",
"specific_delete_group", "set_up_rigging", "interpolate_weights",
"""File containing main UI for makeskin"""
import os, bpy
from mpfb import ClassManager
from mpfb.services.logservice import LogService
from mpfb.services.sceneconfigset import SceneConfigSet
from mpfb.services.uiservice import UiService
from mpfb.ui.makeskin import MakeSkinObjectProperties
from mpfb.ui.abstractpanel import Abstract_Panel
_LOC = os.path.dirname(__file__)
MAKESKIN_PROPERTIES_DIR = os.path.join(_LOC, "properties")
MAKESKIN_PROPERTIES = SceneConfigSet.from_definitions_in_json_directory(
MAKESKIN_PROPERTIES_DIR, prefix="MS_")
_LOG = LogService.get_logger("makeskin.makeskinpanel")
class MPFB_PT_MakeSkin_Panel(Abstract_Panel):
"""MakeSkin main panel."""
bl_label = "MakeSkin"
bl_category = UiService.get_value("MATERIALSCATEGORY")
bl_options = {'DEFAULT_CLOSED'}
bl_parent_id = "MPFB_PT_Create_Panel"
def _create_material(self, scene, layout):
box = self._create_box(layout, "Create material", "TOOL_SETTINGS")
props = [
"overwrite",
#"create_node_visualization"
"""This module contains entities used in various places of the plugin."""
from mpfb.services.logservice import LogService
_LOG = LogService.get_logger("entities.init")
_LOG.trace("initializing entities module")
"""Operator for writing a MHMAT file."""
import bpy, os
from bpy_extras.io_utils import ExportHelper
from bpy.props import StringProperty
from mpfb.services.logservice import LogService
from mpfb.services.materialservice import MaterialService
from mpfb import ClassManager
from mpfb.entities.material.makeskinmaterial import MakeSkinMaterial
_LOG = LogService.get_logger("makeskin.writematerial")
class MPFB_OT_WriteMaterialOperator(bpy.types.Operator, ExportHelper):
"""Write material to MHMAT file"""
bl_idname = "mpfb.write_makeskin_material"
bl_label = "Write material"
bl_options = {'REGISTER'}
filename_ext = '.mhmat'
filter_glob: StringProperty(default='*.mhmat', options={'HIDDEN'})
filepath: StringProperty(
name="File Path",
description="Filepath used for exporting the file",
maxlen=1024,
subtype='FILE_PATH')
@classmethod
def poll(cls, context):
if context.active_object is not None:
"""Icons for the modeling panels"""
from mpfb.services.locationservice import LocationService
from mpfb.services.logservice import LogService
import bpy.utils.previews
import os, re
_LOG = LogService.get_logger("model.modelingicons")
MODELING_ICONS = bpy.utils.previews.new()
_TARGETS_DIR = LocationService.get_mpfb_data("targets")
_IMAGES_DIR = os.path.join(_TARGETS_DIR, "_images")
for image in os.listdir(_IMAGES_DIR):
if ".png" in image:
name = re.sub(r"\.png$", "", image)
name = re.sub("^r-", "", name)
name = re.sub("^l-", "", name)
image_path = os.path.join(_IMAGES_DIR, image)
_LOG.debug("Will try to load icon", (name, image_path))
MODELING_ICONS.load(name, image_path, 'IMAGE')
import os, bpy
from mpfb._classmanager import ClassManager
from mpfb.services.logservice import LogService
from mpfb.services.sceneconfigset import SceneConfigSet
from mpfb.services.uiservice import UiService
from mpfb.ui.abstractpanel import Abstract_Panel
_LOG = LogService.get_logger("importer.importerpanel")
_LOC = os.path.dirname(__file__)
IMPORTER_PROPERTIES_DIR = os.path.join(_LOC, "properties")
IMPORTER_PROPERTIES = SceneConfigSet.from_definitions_in_json_directory(
IMPORTER_PROPERTIES_DIR, prefix="IMP_")
def _populate_presets(self, context):
_LOG.enter()
_LOG.trace("Context is scene", isinstance(context, bpy.types.Scene))
available_presets = UiService.get_importer_panel_list()
if available_presets is None:
available_presets = []
return available_presets
def _populate_skin_settings(self, context):
_LOG.enter()
_LOG.trace("Context is scene", isinstance(context, bpy.types.Scene))
available_settings = UiService.get_importer_enhanced_settings_panel_list()
if available_settings is None:
available_settings = []
return available_settings
import os, bpy, shutil
from mpfb._classmanager import ClassManager
from mpfb.services.logservice import LogService
from mpfb.services.locationservice import LocationService
from mpfb.services.sceneconfigset import SceneConfigSet
from mpfb.services.uiservice import UiService
from mpfb.services.objectservice import ObjectService
from mpfb.ui.abstractpanel import Abstract_Panel
_LOG = LogService.get_logger("ui.enhancedsettings")
_LOC = os.path.dirname(__file__)
ENHANCED_SETTINGS_PROPERTIES_DIR = os.path.join(_LOC, "properties")
ENHANCED_SETTINGS_PROPERTIES = SceneConfigSet.from_definitions_in_json_directory(
ENHANCED_SETTINGS_PROPERTIES_DIR, prefix="ES_")
def _populate_settings(self, context):
_LOG.enter()
_LOG.trace("Context is scene", isinstance(context, bpy.types.Scene))
available_settings = UiService.get_enhanced_settings_panel_list()
if available_settings is None:
available_settings = []
return available_settings
_SETTINGS_LIST_PROP = {
"type": "enum",
"name": "available_settings",
"description": "Available settings",
"label": "Available settings",
"""This module contains functionality for serializing/deserializing rigs via JSON."""
from mpfb.services.logservice import LogService
from mpfb.services.rigservice import RigService
from mpfb.entities.objectproperties import GeneralObjectProperties
import bpy, math, json, random
_LOG = LogService.get_logger("entities.rig")
_MAX_ALLOWED_DIST = 0.01
_MAX_DIST_TO_CONSIDER_EXACT = 0.001
class Rig:
"""Entity class representing an armature."""
def __init__(self):
"""You might want to use one of the static methods rather than calling init directly."""
self.basemesh = None
self.armature_object = None
self.position_info = dict()
self.rig_definition = dict()
self.lowest_point = 1000.0
@staticmethod
def from_json_file_and_basemesh(filename, basemesh):
"""Create an instance of Rig and populate it with information from the json file and from the base mesh."""
rig = Rig()
with open(filename, "r") as json_file:
rig.rig_definition = json.load(json_file)
rig.basemesh = basemesh
"""This module provides functionality for adding helpers to fingers."""
import bpy
from mpfb.services.logservice import LogService
_LOG = LogService.get_logger("fingerhelpers.fingerhelpers")
from mpfb.services.rigservice import RigService
from mpfb.ui.righelpers import RigHelpersProperties
class FingerHelpers():
"""This is the abstract rig type independent base class for working with
helpers for fingers. You will want to call the static get_instance()
method to get a concrete implementation for the specific rig you are
working with."""
def __init__(self, which_hand, settings):
"""Get a new instance of FingerHelpers. You should not call this directly.
Use get_instance() instead."""
_LOG.debug("Constructing FingerHelpers object")
self.which_hand = which_hand
self.settings = settings
self._bone_info = dict()
_LOG.dump("settings", self.settings)
# ---- METHODS FOR APPLYING AND CREATING
"""File containing main UI for makeclothes"""
import os, bpy
from mpfb import ClassManager
from mpfb.services.logservice import LogService
from mpfb.services.sceneconfigset import SceneConfigSet
from mpfb.services.uiservice import UiService
from mpfb.ui.makeclothes import MakeClothesObjectProperties
from mpfb.ui.abstractpanel import Abstract_Panel
_LOC = os.path.dirname(__file__)
MAKECLOTHES_PROPERTIES_DIR = os.path.join(_LOC, "properties")
MAKECLOTHES_PROPERTIES = SceneConfigSet.from_definitions_in_json_directory(
MAKECLOTHES_PROPERTIES_DIR, prefix="MC_")
_LOG = LogService.get_logger("makeclothes.makeclothespanel")
class MPFB_PT_MakeClothes_Panel(Abstract_Panel):
"""MakeClothes main panel."""
bl_label = "MakeClothes"
bl_category = UiService.get_value("CLOTHESCATEGORY")
bl_options = {'DEFAULT_CLOSED'}
bl_parent_id = "MPFB_PT_Create_Panel"
def _setup_clothes(self, scene, layout):
box = self._create_box(layout, "Set up clothes", "TOOL_SETTINGS")
box.operator('mpfb.extract_makeclothes_clothes')
box.operator('mpfb.mark_makeclothes_clothes')
def execute(self, context):
_LOG.enter()
LogService.reset_log_levels()
self.report({"INFO"}, "All log level overrides were removed and default level was set to INFO")
return {'FINISHED'}
import os, json, re
from pathlib import Path
from .mhmaterial import MhMaterial
from mpfb.services.logservice import LogService
from mpfb.services.locationservice import LocationService
from mpfb.services.nodeservice import NodeService
from mpfb.services.materialservice import MaterialService
_LOG = LogService.get_logger("material.enhancedskinmaterial")
class EnhancedSkinMaterial(MhMaterial):
def __init__(self, importer_presets):
MhMaterial.__init__(self)
self.presets = importer_presets
def _template(self, template_values, has, tex, key):
template_values[has] = "false"
template_values[tex] = "\"\""
value = self.get_value(key)
if value:
_LOG.debug(key + " is set in mhmat")
template_values[has] = "true"
template_values[tex] = "\"" + value + "\""
else:
_LOG.debug(key + " is not set in mhmat")
def skin_tweaks(self, template_values, blender_material):
blender_material.diffuse_color = MaterialService.get_skin_diffuse_color()
import os, bpy
from mpfb._classmanager import ClassManager
from mpfb.services.logservice import LogService
from mpfb.services.locationservice import LocationService
from mpfb.services.sceneconfigset import SceneConfigSet
from mpfb.services.uiservice import UiService
from mpfb.ui.abstractpanel import Abstract_Panel
_LOG = LogService.get_logger("ui.importerpresets")
_LOC = os.path.dirname(__file__)
IMPORTER_PRESETS_PROPERTIES_DIR = os.path.join(_LOC, "properties")
IMPORTER_PRESETS_PROPERTIES = SceneConfigSet.from_definitions_in_json_directory(
IMPORTER_PRESETS_PROPERTIES_DIR, prefix="IP_")
def _populate_presets(self, context):
_LOG.enter()
_LOG.trace("Context is scene", isinstance(context, bpy.types.Scene))
available_presets = UiService.get_importer_presets_panel_list()
if available_presets is None:
available_presets = []
return available_presets
_PRESETS_LIST_PROP = {
"type": "enum",
"name": "available_presets",
"description": "Available presets",
"label": "Available presets",
"default": 0
"""Operators for developer stuff"""
from mpfb.services.logservice import LogService
_LOG = LogService.get_logger("developer.operators.init")
_LOG.trace("initializing developers operators")
from .listloglevels import MPFB_OT_List_Log_Levels_Operator
from .exportlog import MPFB_OT_Export_Log_Operator
from .resetloglevels import MPFB_OT_Reset_Log_Levels_Operator
from .setloglevel import MPFB_OT_Set_Log_Level_Operator
from .savenodes import MPFB_OT_Save_Nodes_Operator
from .loadnodes import MPFB_OT_Load_Nodes_Operator
from .saverig import MPFB_OT_Save_Rig_Operator
from .loadrig import MPFB_OT_Load_Rig_Operator
from .saveweights import MPFB_OT_Save_Weights_Operator
from .saverigifylayers import MPFB_OT_Save_Rigify_Layers_Operator
from .loadrigifylayers import MPFB_OT_Load_Rigify_Layers_Operator
__all__ = [
"MPFB_OT_List_Log_Levels_Operator",
"MPFB_OT_Reset_Log_Levels_Operator",
"MPFB_OT_Set_Log_Level_Operator",
"MPFB_OT_Load_Nodes_Operator",
"MPFB_OT_Save_Nodes_Operator",
"MPFB_OT_Save_Rig_Operator",
"MPFB_OT_Load_Rig_Operator",
"MPFB_OT_Save_Weights_Operator",
"MPFB_OT_Load_Rigify_Layers_Operator",
"MPFB_OT_Save_Rigify_Layers_Operator"
]
"""Operators for opening urls"""
from mpfb.services.logservice import LogService
_LOG = LogService.get_logger("webresources.operators.init")
_LOG.trace("initializing web resources operators")
from .webresource import MPFB_OT_Web_Resource_Operator
__all__ = ["MPFB_OT_Web_Resource_Operator"]
"""Operator for overwriting existing eye material settings."""
from mpfb.services.logservice import LogService
from mpfb.services.locationservice import LocationService
from mpfb.ui.eyesettings.eyesettingspanel import EYE_SETTINGS_PROPERTIES
from mpfb._classmanager import ClassManager
import bpy, os
from ._savematerial import _save_material
_LOG = LogService.get_logger("eyesettings.overwritesettings")
class MPFB_OT_OverwriteEyeSettingsOperator(bpy.types.Operator):
"""This will overwrite the selected eye material settings, using values from the selected object's material"""
bl_idname = "mpfb.overwrite_eye_settings"
bl_label = "Overwrite settings"
bl_options = {'REGISTER'}
def execute(self, context):
_LOG.enter()
if context.object is None:
self.report({'ERROR'}, "Must have a selected object")
return {'FINISHED'}
name = EYE_SETTINGS_PROPERTIES.get_value("available_settings", entity_reference=context)
if not name is None:
name = str(name).strip()
if name == "" or name is None:
self.report({'ERROR'}, "Settings must be chosen from the list")
import os, json
from pathlib import Path
from .mhmaterial import MhMaterial
from .mhmatkeys import MHMAT_KEYS
from mpfb.services.logservice import LogService
from mpfb.services.locationservice import LocationService
from mpfb.services.nodeservice import NodeService
from mpfb.services.materialservice import MaterialService
_LOG = LogService.get_logger("material.makeskinmaterial")
_TEXTURE_NAMES = [
"bumpmap", "diffuse", "displacementmap", "metallicmap", "normalmap",
"roughnessmap", "transmissionmap"
]
_NODE_SOCKET_VALUES = [] # key name, node name, socket name
_NODE_SOCKET_VALUES.append(["diffuseColor", "Principled BSDF", "Base Color"
]) # First pick up color from principled
_NODE_SOCKET_VALUES.append(["diffuseColor", "diffuseIntensity", "Color1"
]) # Then overwrite with intensity node if any
_NODE_SOCKET_VALUES.append(["diffuseIntensity", "diffuseIntensity", "Fac"])
_NODE_SOCKET_VALUES.append(["bumpmapIntensity", "bumpmap", "Strength"])
_NODE_SOCKET_VALUES.append(["normalmapIntensity", "normalmap", "Strength"])
_NODE_SOCKET_VALUES.append(
["displacementmapIntensity", "displacementmap", "Scale"])
_NODE_SOCKET_VALUES.append(["metallic", "Principled BSDF", "Metallic"])
_NODE_SOCKET_VALUES.append(["ior", "Principled BSDF", "IOR"])
_NODE_SOCKET_VALUES.append(["roughness", "Principled BSDF", "Roughness"])
"""Operator for adding a rigify rig."""
import bpy, os, json
from mpfb.services.logservice import LogService
from mpfb.services.objectservice import ObjectService
from mpfb.services.locationservice import LocationService
from mpfb.services.rigservice import RigService
from mpfb.entities.rig import Rig
from mpfb import ClassManager
_LOG = LogService.get_logger("addrig.add_rigify_rig")
class MPFB_OT_AddRigifyRigOperator(bpy.types.Operator):
"""Add a rigify rig"""
bl_idname = "mpfb.add_rigify_rig"
bl_label = "Add rigify rig"
bl_options = {'REGISTER', 'UNDO'}
@classmethod
def poll(cls, context):
if context.active_object is not None:
return ObjectService.object_is_basemesh(context.active_object)
return False
def execute(self, context):
scene = context.scene
if not ObjectService.object_is_basemesh(context.active_object):
self.report({'ERROR'}, "Rigs can only be added to the base mesh")
"""This module provides functionality for adding helpers to eyes."""
import bpy
from mpfb.services.logservice import LogService
_LOG = LogService.get_logger("eyehelpers.eyehelpers")
from mpfb.services.rigservice import RigService
from mpfb.ui.righelpers import RigHelpersProperties
class EyeHelpers():
"""This is the abstract rig type independent base class for working with
helpers for eyes. You will want to call the static get_instance()
method to get a concrete implementation for the specific rig you are
working with."""
def __init__(self, settings):
"""Get a new instance of EyeHelpers. You should not call this directly.
Use get_instance() instead."""
_LOG.debug("Constructing EyeHelpers object")
self.settings = settings
self._bone_info = dict()
_LOG.dump("settings", self.settings)
def apply_ik(self, armature_object):
"""Add rig helpers for eyes based on the settings that were provided
when constructing the class."""
_LOG.enter()
