ABX/abx/prop_factory.py

135 lines
5.4 KiB
Python
Raw Permalink Normal View History

# blender_context.py
"""
Contextual metadata acquired from internal values in a Blender file.
This module must be invoked from within Blender to work, as it relies on the bpy Blender API
module and the currently-open Blender file's data graph in order to work.
It collects data about scenes, objects, groups, and other datablocks in the Blender file,
as well as data encoded in text blocks in different formats. Overall file data is incorporated
into a PropertyGroup attached to the "WindowManager" object identified as 'WinMan' (normally,
it appears there is only ever one of these in a Blender file, but if there is more than one, this
is the one that will be used).
"""
import io
import bpy, bpy.app, bpy.props, bpy.utils
from bpy.app.handlers import persistent
from .accumulate import UnionList, RecursiveDict
import yaml
def EnumFromList(schema, listname):
"""
Convert options from a list of strings referenced by key name.
Args:
schema (dict): definition of the property group containing the enum.
options (list): list of options as simple strings.
Returns:
List of options as tuples, as needed by Blender.
"""
return [(e, e.capitalize(), e.capitalize()) for e in schema[listname]]
def ExpandEnumList(schema, options):
"""
Convert options from a direct list.
Args:
schema (dict): definition of the property group containing the enum.
options (list): list of options. Individual options can be strings,
pairs, or triples.
Returns:
A list of triples defining the enumerated values as needed for Blender.
"""
blender_options = []
for option in options:
if type(option) is str:
blender_options.append((option, option, option))
elif isinstance(option, tuple) or isinstance(option, list):
option = tuple(option[0:3] + ([option[-1]]*(3-len(option))))
blender_options.append(option)
return blender_options
class PropertyGroupFactory(bpy.types.PropertyGroup):
"""
Property group factory for attachment to Blender object types.
Structure of the property group returned is determined by a dictionary
schema, which may be loaded from a YAML file.
This is a "class factory", a class which returns another class when
called.
"""
# These values mirror the Blender documentation for the bpy.props types:
prop_types = {
'str':{
'property': bpy.props.StringProperty,
'keywords': { 'name', 'description', 'default', 'maxlen',
'options', 'subtype'},
'translate': {
'desc': (None, 'description', None)}},
'enum': {
'property': bpy.props.EnumProperty,
'keywords': { 'items', 'name', 'description', 'default', 'options'},
'translate': {
'desc': (None, 'description', None),
'items_from': (EnumFromList, 'items'),
'items': (ExpandEnumList, 'items')}},
'int': {
'property': bpy.props.IntProperty,
'keywords': { 'name', 'description', 'default', 'min', 'max',
'soft_min', 'soft_max', 'step', 'options', 'subtype'},
'translate': {
'desc': (None, 'description')}},
'float': {
'property': bpy.props.FloatProperty,
'keywords': { 'name', 'description', 'default', 'min', 'max',
'soft_min', 'soft_max', 'step', 'options',
'subtype', 'precision', 'unit'},
'translate': {
'desc': (None, 'description')}},
'bool': {
'property': bpy.props.BoolProperty,
'keywords': { 'name', 'description', 'default', 'options', 'subtype'},
'translate': {
'desc': (None, 'description')}}
}
def __new__(cls, name, schema):
class CustomPropertyGroup(bpy.types.PropertyGroup):
pass
for definition in schema[name]:
# Translate and filter parameters
try:
propmap = cls.prop_types[definition['type']]
except KeyError:
# If no 'type' specified or 'type' not found, default to string:
propmap = cls.prop_types['str']
filtered = {}
for param in definition:
if 'translate' in propmap and param in propmap['translate']:
translator = propmap['translate'][param][0]
if callable(translator):
# Filtered translation
filtered[propmap['translate'][param][1]] = translator(schema, definition[param])
else:
# Simple translation
filtered[propmap['translate'][param][1]] = definition[param]
else:
filtered[param] = definition[param]
# Create the Blender Property object
kwargs = dict((key,filtered[key]) for key in propmap['keywords'] if key in filtered)
setattr(CustomPropertyGroup, definition['code'], propmap['property'](**kwargs))
bpy.utils.register_class(CustomPropertyGroup)
return(CustomPropertyGroup)