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")