def _list_menu_nodes():
proxy_map = {}
#proxy_map["Basic Uncategorized Parameters"] = []
#proxy_map["Basic Uncategorized Conditions"] = []
#proxy_map["Basic Uncategorized Actions"] = []
def get_param_list(c): return proxy_map["Basic Uncategorized Parameters"]
def get_cond_list(c): return proxy_map["Basic Uncategorized Conditions"]
def get_act_list(c): return proxy_map["Basic Uncategorized Actions"]
def get_cat_list(c):
catname = c.nl_category
catlist = proxy_map.get(catname)
if catlist is None:
catlist = []
proxy_map[catname] = catlist
return catlist
for c in _registered_classes:
if hasattr(c, "nl_category"):
get_cat_list(c).append(nodeitems_utils.NodeItem(c.bl_idname))
elif issubclass(c, basicnodes.NLParameterNode):
get_param_list(c).append(nodeitems_utils.NodeItem(c.bl_idname))
elif issubclass(c, basicnodes.NLConditionNode):
get_cond_list(c).append(nodeitems_utils.NodeItem(c.bl_idname))
elif issubclass(c, basicnodes.NLActionNode):
get_act_list(c).append(nodeitems_utils.NodeItem(c.bl_idname))
pmap_keys = list(proxy_map.keys())
pmap_keys.sort()
menu_nodes = []
for name in pmap_keys:
itemlist = proxy_map[name]
menu_nodes.append(NodeCategory(name, name, items=itemlist))
return menu_nodes
def node_categories(osl_nodes):
osl_surface = []
osl_shaders = []
osl_2d_textures = []
osl_3d_textures = []
osl_color = []
osl_utilities = []
osl_other = []
for node in osl_nodes:
node_item = nodeitems_utils.NodeItem(node[0])
node_category = node[1]
if node_category == 'shader':
osl_shaders.append(node_item)
elif node_category == 'texture2d':
osl_2d_textures.append(node_item)
elif node_category == 'utility':
osl_utilities.append(node_item)
elif node_category == 'texture3d':
osl_3d_textures.append(node_item)
elif node_category == 'surface':
osl_surface.append(node_item)
elif node_category == 'color':
osl_color.append(node_item)
else:
osl_other.append(node_item)
appleseed_node_categories = [
AppleseedOSLNodeCategory("OSL_Surfaces",
"appleseed - Surface",
items=osl_surface),
AppleseedOSLNodeCategory("OSL_Shaders",
"appleseed - Shader",
items=osl_shaders),
AppleseedOSLNodeCategory("OSL_3D_Textures",
"appleseed - Texture3D",
items=osl_3d_textures),
AppleseedOSLNodeCategory("OSL_2D_Textures",
"appleseed - Texture2D",
items=osl_2d_textures),
AppleseedOSLNodeCategory("OSL_Color",
"appleseed - Color",
items=osl_color),
AppleseedOSLNodeCategory("OSL_Utilities",
"appleseed - Utility",
items=osl_utilities),
AppleseedOSLNodeCategory(
"OSL_Script",
"appleseed - Script",
items=[nodeitems_utils.NodeItem("AppleseedOSLScriptBaseNode")]),
AppleseedOSLNodeCategory("OSL_Other",
"appleseed - No Category",
items=osl_other)
]
return appleseed_node_categories
def register():
bpy.utils.register_class(pvObjectNode)
bpy.utils.register_class(pvBMeshNode)
categories = [
category.pvNodeCategory("BVTK_Blender", "Blender",
items = [
nodeitems_utils.NodeItem("pvObjectNode"),
nodeitems_utils.NodeItem("pvBMeshNode"),
]),
]
nodeitems_utils.register_node_categories("BVTK_CATEGORIES_Blend", categories)
def add_node(node_class: Type[Node], category: str):
global nodes
nodes.append(node_class)
if category_items.get(category) is None:
category_items[category] = []
category_items[category].append(
nodeitems_utils.NodeItem(node_class.bl_idname))
def register_nodes(category_label, *cls):
node_items = []
for c in cls:
if hasattr(bpy.types, c.bl_idname):
try:
print("Unregister class {}".format(c))
bpy.utils.unregister_class(getattr(bpy.types, c.bl_idname))
except RuntimeError as ex:
print("Cannot unregister type {}, for some reason\n{}".format(
c, ex))
print("Register class {}".format(c))
_loaded_nodes.append((category_label, c))
bpy.utils.register_class(c)
node_item = nodeitems_utils.NodeItem(c.bl_idname)
node_items.append(node_item)
node_category = NodeCategory(category_label,
category_label,
items=node_items)
try:
nodeitems_utils.unregister_node_categories(category_label)
except KeyError:
print("Info: Node Category {} has not been registered before.".format(
category_label))
nodeitems_utils.register_node_categories(category_label, [node_category])
pass
def register(cls):
cats = []
for c, l in cls.node_categories.items():
cid = c.replace(' ', '').upper()
items = [nodeitems_utils.NodeItem(nc.__name__) for nc in l]
cats.append(TungstenNodeCategory(cid, c, items=items))
nodeitems_utils.register_node_categories('TUNGSTEN', cats)
def register():
bpy.utils.register_class(pvInspector)
categories = [
category.pvNodeCategory("BVTK_INSPECTORS", "Inspectors",
items = [ nodeitems_utils.NodeItem("pvInspector") ]),
]
nodeitems_utils.register_node_categories("BVTK_CATEGORIES_Insp", categories)
def register():
bpy.utils.register_class(LightningGen)
newcatlist = [
CompositorNodeCategory(
"CP_GENERATE",
"Generate",
items=[nodeitems_utils.NodeItem("LightningGen")])
]
nodeitems_utils.register_node_categories("GENERATE_NODES", newcatlist)
def pvClass(k):
c = "pvSimple" + k
if c not in my_pvClasses:
#print("adding class ",c,"with object", k)
new_class = type(c, (bpy.types.Node, pvNode), {
"bl_label": k,
"pvType": k
})
bpy.utils.register_class(new_class)
setattr(sys.modules[__name__], c, new_class)
my_pvClasses.append(c)
return nodeitems_utils.NodeItem(c)
def register(cls):
bpy.types.Material.sort_material = bpy.props.PointerProperty(type=SORTMaterial, name="SORT Material Settings")
cats = []
for c, l in sorted(cls.node_categories.items()):
cid = 'SORT_' + c.replace(' ', '').upper()
items = [nodeitems_utils.NodeItem(nc.__name__) for nc in l]
cats.append(SORTPatternNodeCategory(cid, c, items=items))
cls.nodetypes[c] = []
for item in l :
cls.nodetypes[c].append((item.__name__,item.bl_label,item.output_type))
nodeitems_utils.register_node_categories('SORTSHADERNODES', cats)
def register():
for cls in _registered_classes:
print("Registering... {}".format(cls.__name__))
bpy.utils.register_class(cls)
menu_nodes = _list_menu_nodes()
bpy.utils.register_class(NoteNode)
menu_nodes.append(
NodeCategory("UTILS",
"Utils",
items=[nodeitems_utils.NodeItem(NoteNode.bl_idname)]))
nodeitems_utils.register_node_categories("NETLOGIC_NODES", menu_nodes)
bpy.types.Object.bgelogic_treelist = bpy.props.CollectionProperty(
type=NLNodeTreeReference)
pass
def register(node_system):
node_system.base_category = base.make_base_category(node_system)
for category_system_name, nodes_ids in node_system.categories_def.items():
items = []
for node_id in nodes_ids:
items.append(nodeitems_utils.NodeItem(node_id))
category_id = node_system.prefix + '_{}_node_category'.format(
category_system_name)
category = node_system.base_category(category_id,
category_system_name.capitalize(),
items=items)
node_system.categories.append(category)
nodeitems_utils.register_node_categories(node_system.tree.bl_idname,
node_system.categories)
def get_categories():
data = get_categs_data()
# node categories
categories = []
for name, ids in data.items():
# category items
items = []
for node_id in ids:
items.append(nodeitems_utils.NodeItem(node_id))
category_id = name.lower().replace(' ', '_')
category = ElementsNodeCategory(category_id, name, items=items)
categories.append(category)
return categories
def pvClasses(mod):
mylist = [i for i in dir(mod) if i[0] != "_"]
retlist = []
for k in mylist:
c = "pvSimple" + k
if c not in my_pvClasses:
print("adding class ",c,"with object", k)
new_class = type(c, (bpy.types.Node,pvNode), {
"bl_label": k,
"pvType": k
})
bpy.utils.register_class(new_class)
setattr(sys.modules[__name__], c,new_class)
my_pvClasses.append(c)
retlist.append(nodeitems_utils.NodeItem(c))
return(retlist)
def register_nodes(inox_engine):
from INOX import inox_blender
inox_blender.register_nodes(inox_engine)
global RUST_NODES
node_items = {}
for n in RUST_NODES:
bpy.utils.register_class(n)
if n.category not in node_items:
node_items[n.category] = []
node_items[n.category].append(
nodeitems_utils.NodeItem(n.name, label=n.name))
for key in node_items:
nodeitems_utils.register_node_categories(
key, [nodeitems_utils.NodeCategory(
key, key, items=node_items[key])])
def register():
bpy.utils.register_class(TinaNodeTree)
for socket in sockets:
bpy.utils.register_class(socket)
for node in nodes:
bpy.utils.register_class(node)
categories = []
for category_name, node_names in categories_map.items():
items = []
for node_name in node_names:
items.append(nodeitems_utils.NodeItem(node_name))
category = TinaBaseCategory(category_name,
category_name.capitalize(),
items=items)
categories.append(category)
nodeitems_utils.register_node_categories('tina_node_tree', categories)
def register():
print(f'Registering Bricky Nodes...')
for c in register_classes:
bpy.utils.register_class(c)
node_items = []
sensor_items = []
controller_items = []
actuator_items = []
filter(lambda a: a is not nodes.update_all_trees, bpy.app.handlers.undo_post)
filter(lambda a: a is not nodes.update_all_trees, bpy.app.handlers.game_post)
bpy.app.handlers.undo_post.append(nodes.update_all_trees)
bpy.app.handlers.game_post.append(nodes.update_all_trees)
for n in nodes._nodes:
node_items.append(nodeitems_utils.NodeItem(n.bl_idname))
for n in nodes._sen_nodes:
sensor_items.append(nodeitems_utils.NodeItem(n.bl_idname))
for n in nodes._con_nodes:
controller_items.append(nodeitems_utils.NodeItem(n.bl_idname))
for n in nodes._act_nodes:
actuator_items.append(nodeitems_utils.NodeItem(n.bl_idname))
layout_items = [
nodeitems_utils.NodeItem('NodeReroute'),
nodeitems_utils.NodeItem('NodeFrame')
]
node_categories = [
NodeCategory('BrickNodes', 'Brick Pointers', items=node_items),
NodeCategory('Sensors', 'Create Sensors', items=sensor_items),
NodeCategory('Controllers', 'Create Controllers', items=controller_items),
NodeCategory('Actuators', 'Create Actuators', items=actuator_items)
# NodeCategory('LayoutNodes', 'Layout', items=layout_items)
]
nodeitems_utils.register_node_categories("BRICK_NODES", node_categories)
# category and node only shows up in the desired node tree
# The first argument is a string with its id we will use to access it by
# the second argument is the name displayed to the user
# the third argument is a list of (items) nodes that are under
# that category, the list contains instances 'nodeitems_utils.NodeItem'
CustomNodeCategory("CUSTOMINPUTNODES", "Custom Input Nodes", items=[
# the nodes (items) in this category are instantiated in this list
# with the 'nodeitems_utils.NodeItem' class, which can have
# additional settings
# the first argument is the node class idname we want to add
# then there can be keyword arguments like label
# another argument can be a 'settings' keyword argument
# that takes a dictionary that can override default values of all
# properties
# NOTE: use 'repr()' to convert the value to string IMPORTANT
nodeitems_utils.NodeItem("CustomSimpleInputNode",
label="Simple Input", settings={"intProp":repr(1.0)}),
# minimalistic node addition is like this
nodeitems_utils.NodeItem("CustomSimpleInputNode"),
]),
]
#finally we register our classes so we can install as plugin
#to that end we create a list of classes to be loaded and unloaded
classes=(
CustomNodeTree,
CustomSimpleInputNode,
)
# for loading we define the registering of all defined classes
class PackShotterRenderNode(PackShotterNode):
bl_idname = "PackShotterRenderNode"
bl_label = "Render"
bl_icon = 'RENDER_STILL'
folder: bpy.props.StringProperty(subtype='DIR_PATH',
name="Folder",
description="The output folder")
scene: bpy.props.PointerProperty(type=bpy.types.Scene,
name="Scene",
description="The scene to render")
def init(self, context):
self.inputs.new('NodeSocketVirtual', "Input")
def draw_buttons(self, context, layout):
layout.prop(self, "folder")
layout.prop(self, "scene")
layout.operator(render.PackShotterRender.bl_idname)
category = PackShotterNodeCategory(
"OUTPUT",
"Output",
items=[nodeitems_utils.NodeItem(PackShotterRenderNode.bl_idname)])
REGISTER_CLASSES = (PackShotterRenderNode, )
text="Activate",
depress=is_pressed)
props.brush_to_activate = self.name
all_emitters = [BrushNode, RainNode]
all_physics = [DragNode, FrictionNode, GravityNode, RepelNode, WindNode]
all_system = [BrushDefineNode]
all_nodes = [*all_emitters, *all_physics, *all_system]
node_categories = [
# identifier, label, items-list
BrushNodeCategory(
'EMITTER',
"Emitter",
items=[nodeitems_utils.NodeItem(x.__name__) for x in all_emitters]),
BrushNodeCategory(
'PHYSICS',
"Physics",
items=[nodeitems_utils.NodeItem(x.__name__) for x in all_physics]),
BrushNodeCategory(
'SYSTEM',
"System",
items=[nodeitems_utils.NodeItem(x.__name__) for x in all_system])
]
def register_node_categories():
nodeitems_utils.register_node_categories('PAINTICLE_SIM_NODES',
node_categories)
def decorator(cls: 'Type[ProceduralTextureNode]'):
_fix_property_inheritance(cls)
category.append(nodeitems_utils.NodeItem(cls.bl_idname))
classes_to_register.add(cls)
return cls
def BuildItemsList(nodeType, subType=None):
def _hidePlugin(pluginName):
_skip_plugins = {
# 3ds max specific
'TexMaxHairInfo',
'GeomHair',
'TexLayeredMax',
'TexMaskMax',
'TexMarbleMax',
'TexRGBTintMax',
# XSI specific
'TexBillboardParticle',
'TexColor2Scalar',
'TexColor8Mix',
'TexColorAverage',
'TexColorCurve',
'TexColorExponential',
'TexColorMathBasic',
'TexColorSwitch',
'TexDisplacacementRestrict',
'TexFloatPerVertexHairSampler',
'TexHairRootSampler',
'TexInterpLinear',
'TexParticleShape',
'TexPerVertexHairSampler',
'texRenderHair',
'TexRgbaCombine',
'TexRgbaSplit',
'TexScalarCurve',
'TexScalarExponential',
'TexScalarHairRootSampler',
'TexScalarMathBasic',
'TexSurfIncidence',
'TexXSIBitmap',
'TexXSICell',
'texXSIColor2Alpha',
'texXSIColor2Vector',
'TexXSIColorBalance',
'TexXSIColorCorrection',
'TexXSIColorMix',
'TexXSIFabric',
'TexXSIFalloff',
'TexXSIFlagstone',
'TexXSIGradient',
'TexXSIHLSAdjust',
'TexXSIIntensity',
'TexXSILayered',
'TexXSIMulti',
'TexXSINormalMap',
'TexXSIRGBAKeyer',
'TexXSIRipple',
'TexXSIRock',
'TexXSIScalar2Color',
'TexXSIScalarInvert',
'TexXSISnow',
'TexXSIVein',
'TexXSIVertexColorLookup',
'TexXSIWeightmapColorLookup',
'TexXSIWeightmapLookup',
'TexXSIWood',
'volumeXSIMulti',
'xsiUVWGenChannel',
'xsiUVWGenEnvironment',
# Handled with meta node
'TexBitmap',
'BitmapBuffer',
# Manually handled
'TexBezierCurve',
'GeomMayaHair',
'GeomStaticMesh',
'VRayScene',
# Unused
'MtlBump',
'GeomImagePlane',
'GeomInfinitePlane',
'TexCustomBitmap',
'TexMultiX',
'TexIDIntegerMap',
'TexMeshVertexColor',
'TexMeshVertexColorWithDefault',
'TexMultiProjection',
'TexParticleDiffuse',
'TexParticleShape',
'TexParticleId',
'RawBitmapBuffer',
# Houdini specific
'TexExtMaterialID',
'TexExtMapChannels',
# Not yet implemented
'BRDFScanned',
'TexRamp',
}
if pluginName in _skip_plugins:
return True
# App specific
_name_filter = (
'Maya',
'TexMaya',
'MtlMaya',
'TexModo',
'TexXSI',
'texXSI',
'volumeXSI',
)
if pluginName.startswith(_name_filter):
return True
if pluginName.find('ASGVIS') >= 0:
return True
if pluginName.find('C4D') >= 0:
return True
if pluginName.find('Modo') >= 0:
return True
return False
def _getPluginDesc(pluginName):
if pluginName in PLUGINS_ID:
return PLUGINS_ID[pluginName]
menuItems = []
for t in VRayNodeTypes[nodeType]:
pluginName = t.bl_rna.identifier.replace("VRayNode", "")
if _hidePlugin(pluginName):
continue
pluginDesc = _getPluginDesc(pluginName)
if pluginDesc:
pluginSubtype = getattr(pluginDesc, 'SUBTYPE', None)
if subType is None:
# Add only data without SUBTYPE
if pluginSubtype is not None:
continue
else:
# Check subtype
if subType != pluginSubtype:
continue
menuItems.append(
nodeitems_utils.NodeItem(t.bl_rna.identifier, label=t.bl_label))
return menuItems
def GetCategories():
return [
VRayNodeCategory('VRAY_BLENDER',
"Blender",
items=[
nodeitems_utils.NodeItem("ShaderNodeNormal",
label="Normal"),
nodeitems_utils.NodeItem("ShaderNodeVectorCurve",
label="Curves"),
nodeitems_utils.NodeItem("ShaderNodeGroup",
label="Group"),
nodeitems_utils.NodeItem("NodeGroupInput",
label="Group Input"),
nodeitems_utils.NodeItem("NodeGroupOutput",
label="Group Output"),
],
icon='BLENDER'),
VRayNodeCategory(
'VRAY_MATERIAL',
"Material",
items=[
nodeitems_utils.NodeItem("VRayNodeMetaStandardMaterial"),
] + BuildItemsList('MATERIAL'),
icon='MATERIAL'),
VRayNodeCategory('VRAY_BRDF',
"BRDF",
items=BuildItemsList('BRDF'),
icon='TEXTURE_SHADED'),
VRayNodeCategory(
'VRAY_TEXTURE',
"Textures",
items=[
nodeitems_utils.NodeItem("VRayNodeMetaImageTexture"),
] + BuildItemsList('TEXTURE'),
icon='TEXTURE'),
VRayNodeCategory('VRAY_TEXTURE_UTILITIES',
"Texture Utilities",
items=BuildItemsList('TEXTURE', 'UTILITY'),
icon='SEQ_CHROMA_SCOPE'),
VRayNodeCategory('VRAY_UVWGEN',
"Mapping",
items=BuildItemsList('UVWGEN'),
icon='GROUP_UVS'),
VRayNodeCategory('VRAY_GEOMETRY',
"Geometry",
items=BuildItemsList('GEOMETRY'),
icon='MESH_DATA'),
VRayNodeCategory(
"VRAY_LIGHT",
"Lights",
items=BuildItemsList('LIGHT'),
icon='LAMP',
),
VRayNodeCategory(
"VRAY_MATH",
"Math",
items=[
nodeitems_utils.NodeItem("VRayNodeTransform"),
nodeitems_utils.NodeItem("VRayNodeMatrix"),
nodeitems_utils.NodeItem("VRayNodeVector"),
],
icon='MANIPUL',
),
VRayNodeCategory(
'VRAY_OUTPUTS',
"Outputs",
items=[
nodeitems_utils.NodeItem("VRayNodeOutputMaterial"),
nodeitems_utils.NodeItem("VRayNodeWorldOutput"),
nodeitems_utils.NodeItem("VRayNodeObjectOutput"),
nodeitems_utils.NodeItem("VRayNodeBlenderOutputGeometry"),
nodeitems_utils.NodeItem("VRayNodeBlenderOutputMaterial"),
],
icon='OBJECT_DATA'),
VRayNodeCategory('VRAY_SELECTORS',
"Selectors",
items=[
nodeitems_utils.NodeItem("VRayNodeSelectObject"),
nodeitems_utils.NodeItem("VRayNodeSelectGroup"),
],
icon='ZOOM_SELECTED'),
VRayNodeCategory('VRAY_ENVIRONMENT',
"Environment",
items=[
nodeitems_utils.NodeItem("VRayNodeEnvironment"),
],
icon='WORLD'),
VRayNodeCategory(
"VRAY_EFFECT",
"Effects",
items=[
nodeitems_utils.NodeItem("VRayNodeEffectsHolder"),
] + BuildItemsList('EFFECT'),
icon='GHOST_ENABLED',
),
VRayNodeCategory(
'VRAY_RENDERCHANNEL',
"Render Channels",
items=[
nodeitems_utils.NodeItem("VRayNodeRenderChannels",
label="Channels Container"),
] + BuildItemsList('RENDERCHANNEL'),
icon='SCENE_DATA'),
VRayNodeCategory("VRAY_LAYOUT",
"Layout",
items=[
nodeitems_utils.NodeItem("NodeFrame"),
nodeitems_utils.NodeItem("NodeReroute"),
nodeitems_utils.NodeItem("VRayNodeDebugSwitch"),
],
icon='NODE_INSERT_OFF'),
]
class ElementsNodeCategory(nodeitems_utils.NodeCategory):
@classmethod
def poll(cls, context):
return context.space_data.tree_type == 'elements_node_tree'
node_categories_data = {}
for node in nodes.node_classes:
if not node_categories_data.get(node.category, None):
node_categories_data[node.category] = []
node_categories_data[node.category].append(node.bl_idname)
node_categories = []
for category_name, nodes_ids in node_categories_data.items():
category_items = []
for node_id in nodes_ids:
category_items.append(nodeitems_utils.NodeItem(node_id))
category = ElementsNodeCategory(category_name.lower().replace(' ', '_'),
category_name,
items=category_items)
node_categories.append(category)
def register():
nodeitems_utils.register_node_categories('elements_node_tree',
node_categories)
def unregister():
nodeitems_utils.unregister_node_categories('elements_node_tree')
from . import (
preferences,
node_tree,
export_avango,
starter,
nodes,
sockets,
engine,
)
node_categories = [
node_tree.AvangoNodeCategory(
"SOMENODES",
"scene",
items=[
nu.NodeItem("Window"),
nu.NodeItem("Camera"),
nu.NodeItem("Light"),
nu.NodeItem("Screen"),
# nu.NodeItem("Transform"),
nu.NodeItem("Mesh"),
nu.NodeItem("FromObject"),
]),
node_tree.AvangoNodeCategory("UTILNODES",
"utils",
items=[
nu.NodeItem("FloatInputNode"),
nu.NodeItem("FloatMath"),
nu.NodeItem("TranslationMatrix"),
nu.NodeItem("RotationMatrix"),
nu.NodeItem("Vec3"),
import bpy
import nodeitems_utils
class RSNCategory(nodeitems_utils.NodeCategory):
@classmethod
def poll(cls, context):
return context.space_data.tree_type == 'RenderNodeTree'
node_categories = [
RSNCategory("INPUT",
"Input",
items=[
nodeitems_utils.NodeItem("RenderNodeTaskInput"),
nodeitems_utils.NodeItem("RenderNodeRandomInput"),
nodeitems_utils.NodeItem('RenderNodeFloatInput'),
nodeitems_utils.NodeItem('RenderNodeBoolInput'),
nodeitems_utils.NodeItem('RenderNodeIntInput'),
nodeitems_utils.NodeItem('RenderNodeVectorInput'),
nodeitems_utils.NodeItem('RenderNodeStringInput'),
nodeitems_utils.NodeItem('RenderNodeObjectInput'),
nodeitems_utils.NodeItem('RenderNodeGetCameraInfo'),
nodeitems_utils.NodeItem('RenderNodeMaterialInput'),
nodeitems_utils.NodeItem('RenderNodeActionInput'),
]),
RSNCategory("LIST",
"List",
items=[
nodeitems_utils.NodeItem("RenderNodeGetListIndex"),
nodeitems_utils.NodeItem("RenderNodeTaskRenderListNode"),
import bpy
import nodeitems_utils
class RSNCategory(nodeitems_utils.NodeCategory):
@classmethod
def poll(cls, context):
return context.space_data.tree_type == 'RenderStackNodeTree'
node_categories = [
RSNCategory(
"TASK",
"Task",
items=[
nodeitems_utils.NodeItem("RSNodeTaskNode"),
nodeitems_utils.NodeItem("RSNodeRenderListNode"),
# nodeitems_utils.NodeItem("RSNodeProcessorNode"),
# nodeitems_utils.NodeItem("RSNodeViewerNode"),
# nodeitems_utils.NodeItem("RSNodeTaskListNode"),
]),
RSNCategory(
"INPUT",
"Input",
items=[
nodeitems_utils.NodeItem('RenderNodeObjectInput'),
nodeitems_utils.NodeItem('RenderNodeStringInput'),
nodeitems_utils.NodeItem('RenderNodeMaterialInput'),
# nodeitems_utils.NodeItem("RSNodePropertyInputNode"),
# nodeitems_utils.NodeItem("RSNodeTaskInfoInputsNode"),
]),
mypath = join(os.path.dirname(os.path.realpath(__file__)),"nodes")
node_categories=[]
for category in listdir(mypath):
if category.startswith("__") or isfile(join(mypath, category)):
continue
addAllFrom("nodes."+category, classes)
p=join(mypath,category)
node_categories.append(BoneNodeCategory(
makeId(category).replace(".","_"),
category.capitalize(),
items=[nodeitems_utils.NodeItem(makeId(f[0:-3])) for f in listdir(p) if isfile(join(p, f))]
))
def reg():
for cl in classes:
bpy.utils.register_class(cl)
nodeitems_utils.register_node_categories("RIGPP_NODES", node_categories)
def dereg():
nodeitems_utils.unregister_node_categories("RIGPP_NODES")
for cl in classes:
bpy.utils.unregister_class(cl)
# so the categories only show up in our own tree type
class MyNodeCategory(nodeitems_utils.NodeCategory):
@classmethod
def poll(cls, context):
return context.space_data.tree_type == CustomNodeTree.bl_idname
# all categories in a list
node_categories = [
# identifier, label, items list
MyNodeCategory(
'OBJECTNODES',
'Object Nodes',
items=[
# our basic node
nodeitems_utils.NodeItem(CustomNode.bl_idname),
nodeitems_utils.NodeItem(CustomGroupNode.bl_idname),
]),
MyNodeCategory(
'BONENODES',
'Bone Nodes',
items=[
# the node item can have additional settings,
# which are applied to new nodes
# NB: settings values are stored as string expressions,
# for this reason they should be converted to strings using repr()
nodeitems_utils.NodeItem(
CustomNode.bl_idname,
label='Node A',
# settings={
# 'myStringProperty': repr('Lorem ipsum dolor sit amet'),
Base class for node categories.
"""
@classmethod
def poll(cls, context):
renderer = context.scene.render.engine
return context.space_data.tree_type == 'AppleseedNodeTree' and renderer == 'APPLESEED_RENDER'
# appleseed node categories
# Format: (identifier, label, items list)
appleseed_node_categories = [
AppleseedNodeCategory(
"BSDF",
"BSDF",
items=[
nodeitems_utils.NodeItem("AppleseedAshikhminNode"),
nodeitems_utils.NodeItem("AppleseedDiffuseBTDFNode"),
nodeitems_utils.NodeItem("AppleseedDisneyNode"),
nodeitems_utils.NodeItem("AppleseedKelemenNode"),
nodeitems_utils.NodeItem("AppleseedLambertianNode"),
nodeitems_utils.NodeItem("AppleseedMicrofacetNode"),
nodeitems_utils.NodeItem("AppleseedOrenNayarNode"),
nodeitems_utils.NodeItem("AppleseedSpecBRDFNode"),
nodeitems_utils.NodeItem("AppleseedSpecBTDFNode"),
nodeitems_utils.NodeItem("AppleseedBlendNode")
]),
AppleseedNodeCategory("TEXTURES",
"Texture",
items=[
nodeitems_utils.NodeItem("AppleseedTexNode"),
nodeitems_utils.NodeItem("AppleseedNormalNode")
