def register():
from . import ui
from . import properties
preferences.register()
properties.register()
ui.register()
node_tree.register()
sockets.register()
export_avango.register()
starter.register()
nodes.register()
bpy.utils.register_module(__name__)
# Idee: root am SceneGraph
# 1.)
# alle objects haben CollectionProperty,
# sollte beim exportieren des scene graphs ein die CollectionProperty eines
# Hierarchieknotens leer sein, wird ein default FieldContainer des
# passenden typs erstellt
# 2.) wenn ein Node gelöscht wird, soll auf referenzierten blender objecten
# vorher die Referenz auf diesen Node entfernt werden
#bpy.types.Object.avango_nodes = bpy.props.CollectionProperty(
# type=bpy.types.PropertyGroup)
if 'AVANGO_NODES' in nu._node_categories:
nu.unregister_node_categories('AVANGO_NODES')
nu.register_node_categories('AVANGO_NODES', node_categories)
def register():
bpy.utils.register_class(CrowdMasterTree)
bpy.utils.register_class(DefaultSocket)
bpy.utils.register_class(StateSocket)
bpy.utils.register_class(DependanceSocket)
bpy.utils.register_class(LogicNode)
bpy.utils.register_class(StateNode)
bpy.utils.register_class(InputNode)
bpy.utils.register_class(GraphNode)
bpy.utils.register_class(AndNode)
bpy.utils.register_class(OrNode)
bpy.utils.register_class(StrongNode)
bpy.utils.register_class(WeakNode)
bpy.utils.register_class(QueryTagNode)
bpy.utils.register_class(SetTagNode)
bpy.utils.register_class(VariableNode)
bpy.utils.register_class(FilterNode)
bpy.utils.register_class(MapNode)
bpy.utils.register_class(OutputNode)
bpy.utils.register_class(PriorityNode)
bpy.utils.register_class(EventNode)
bpy.utils.register_class(PythonNode)
bpy.utils.register_class(PrintNode)
bpy.utils.register_class(StartState)
bpy.utils.register_class(ActionState)
bpy.utils.register_class(NoteNode)
nodeitems_utils.register_node_categories("CrowdMaster_NODES", node_categories)
def register():
bpy.utils.register_class(HookSocketType)
bpy.utils.register_class(MyCustomNode)
bpy.utils.register_class(HookNode)
bpy.utils.register_class(StrangeInput)
bpy.utils.register_class(StrangeOutput)
nodeitems_utils.register_node_categories("REIGHLEYNODES", node_categories)
def reload_menu():
menu, node_count, original_categories = make_categories()
if 'SVERCHOK' in nodeitems_utils._node_categories:
nodeitems_utils.unregister_node_categories("SVERCHOK")
nodeitems_utils.register_node_categories("SVERCHOK", menu)
build_help_remap(original_categories)
def register():
bpy.utils.register_class(MyCustomTree)
bpy.utils.register_class(MyCustomSocket)
bpy.utils.register_class(MyCustomNode)
bpy.utils.register_class(MyCustomGroup)
nodeitems_utils.register_node_categories("CUSTOM_NODES", node_categories)
def register():
bpy.utils.register_class(UwatelaNodeTree)
bpy.utils.register_class(UwatelaNodeSocket)
bpy.utils.register_class(UwatelaMeshMoveNode)
bpy.utils.register_class(UwatelaObjectInputNode)
nodeitems_utils.register_node_categories("UWATELA", node_categories)
def register():
menu, node_count = make_categories()
if 'SVERCHOK' in nodeitems_utils._node_categories:
nodeitems_utils.unregister_node_categories("SVERCHOK")
nodeitems_utils.register_node_categories("SVERCHOK", menu)
print("\n** Sverchok loaded with {i} nodes **".format(i=node_count))
def register():
bpy.utils.register_class(CrowdMasterTree)
bpy.utils.register_class(DefaultSocket)
bpy.utils.register_class(StateSocket)
bpy.utils.register_class(DependanceSocket)
bpy.utils.register_class(LogicNode)
bpy.utils.register_class(StateNode)
bpy.utils.register_class(NewInputNode)
bpy.utils.register_class(GraphNode)
bpy.utils.register_class(MathNode)
bpy.utils.register_class(AndNode)
bpy.utils.register_class(OrNode)
bpy.utils.register_class(NotNode)
bpy.utils.register_class(StrongNode)
bpy.utils.register_class(WeakNode)
bpy.utils.register_class(SetTagNode)
bpy.utils.register_class(FilterNode)
bpy.utils.register_class(MapNode)
bpy.utils.register_class(OutputNode)
bpy.utils.register_class(PriorityNode)
bpy.utils.register_class(PrintNode)
bpy.utils.register_class(StartState)
bpy.utils.register_class(ActionState)
bpy.utils.register_class(NoteNode)
bpy.utils.register_class(SimNoteTextFromClipboard)
bpy.utils.register_class(SimNoteClear)
nodeitems_utils.register_node_categories(
"CrowdMaster_NODES", node_categories)
def register():
bpy.utils.register_module(__name__)
try:
nodeitems_utils.register_node_categories("CG_PIPELINE_NODES", node_categories)
reload_blend_data()
except:
pass
def register():
bpy.utils.register_class(NodeComment)
bpy.utils.register_class(CommentNode)
try:
nodeitems_utils.register_node_categories("COMMENT_NODES", comment_node_categories)
except:
pass
def register():
for cls in classes:
bpy.utils.register_class(cls)
bpy.types.Scene.splash = PointerProperty(type=SplashSettings)
import nodeitems_utils
nodeitems_utils.register_node_categories("SPLASH_NODES", nodes.node_categories)
def register():
registerIfPossible(__name__)
for moduleName in moduleNames:
registerIfPossible(moduleName)
categories = mn_node_register.getNodeCategories()
register_node_categories("ANIMATIONNODES", categories)
bpy.types.Scene.mn_settings = PointerProperty(type = AnimationNodesSettings, name = "Animation Node Settings")
def register():
util.safe_register_class(AppleseedOSLNodeTree)
node_list = util.read_osl_shaders()
for node in node_list:
try:
node_name, node_category = oslnode.generate_node(node)
osl_node_names.append([node_name, node_category])
except:
pass
register_node_categories("APPLESEED", node_categories(osl_node_names))
def register():
bpy.utils.register_module(__name__)
nodeitems_utils.register_node_categories("POVRAYNODES", node_categories)
bpy.types.DATA_PT_metaball.append(menu_func_meta)
bpy.types.INFO_MT_add.append(menu_func_add)
bpy.types.INFO_MT_file_import.append(menu_func_import)
bpy.types.NODE_HT_header.append(menu_func_nodes)
bpy.types.PARTICLE_PT_cache.append(menu_func_particles_bake)
bpy.types.WORLD_PT_context_world.append(menu_func_world)
def register():
bpy.utils.register_class(B4W_LogicEditorErrTextWrap)
bpy.utils.register_class(B4W_LogicEditorErrors)
bpy.utils.register_class(B4W_LogicNodeTree)
bpy.utils.register_class(B4W_LogicNode)
bpy.utils.register_class(B4W_LogicNodeJumpSocket)
bpy.utils.register_class(B4W_LogicNodeOrderSocket)
nodeitems_utils.register_node_categories("B4W_LOGIC_CUSTOM_NODES", node_categories)
register_hotkey()
def register():
bpy.utils.register_module(__name__)
#Only appends the header once during development
# if not bpy.context.scene.appended_header:
bpy.types.NODE_HT_header.append(SceneNodesHeader)
# bpy.context.scene.appended_header = True
if 'SCENE_NODES' in nodeitems_utils._node_categories:
nodeitems_utils.unregister_node_categories("SCENE_NODES")
nodeitems_utils.register_node_categories("SCENE_NODES", node_categories)
def register(self):
class PyNodesCategory(nodeitems_utils.NodeCategory):
@classmethod
def poll(cls, context):
space = context.space_data
if not (space.type == 'NODE_EDITOR' and space.tree_type == self.nodetree_cls.bl_idname):
return False
return True
node_category_items = lambda node_classes : [ nodeitems_utils.NodeItem(getattr(cls, "bl_idname", cls.__name__)) for cls in node_classes ]
node_categories = [ PyNodesCategory(name, name, items=node_category_items(node_classes)) for name, node_classes in self.node_items.items() ]
nodeitems_utils.register_node_categories(self.nodetree_cls.bl_idname, node_categories)
def FLOW_nodecats(perform):
import nodeitems_utils as nu
node_categories = nu._node_categories
if perform == 'unregister':
if FLOW in node_categories:
nu.unregister_node_categories(FLOW)
elif perform == 'register':
from FLOW.flow_nodes_index import make_categories
if not (FLOW in node_categories):
nu.register_node_categories(FLOW, make_categories())
def register():
# === Blender classes ===
bpy.utils.register_module(__name__)
nodeitems_utils.register_node_categories("CUSTOM_CATEGORIES", categories)
# === Model setup ===
# Scene global used by NodeTree & Nodes for communication with Adapter
# Workaround due to NodeTree/Node non-persistent classes
bpy.types.Scene.observable = Observable()
# Adapter observes nodetree scene global
bpy.types.Scene.adapter = Adapter(bpy.types.Scene.observable)
print("Nodearama registered successfully.")
def register():
for cls in classes:
bpy.utils.register_class(cls)
user_preferences = bpy.context.user_preferences
prefs = user_preferences.addons[__package__].preferences
#Register pointer property if not already done
if not hasattr(bpy.types.Scene, "OSLProps"):
bpy.types.Scene.OSLProps = bpy.props.PointerProperty(type=OSLProps, name="Renderman OSL Settings")
#from bpy.app.handlers import persistent
#@persistent
#def load_handler(dummy):
categories = {}
for name, arg_file in args_files_in_path(prefs, None).items():
generate_node_type(prefs, name, ET.parse(arg_file).getroot())
pattern_nodeitems = []
bxdf_nodeitems = []
light_nodeitems = []
for name, node_type in RendermanPatternGraph.nodetypes.items():
node_item = NodeItem(name, label=node_type.bl_label)
if node_type.renderman_node_type == 'pattern':
pattern_nodeitems.append(node_item)
elif node_type.renderman_node_type == 'bxdf':
bxdf_nodeitems.append(node_item)
elif node_type.renderman_node_type == 'light':
light_nodeitems.append(node_item)
# all categories in a list
node_categories = [
# identifier, label, items list
RendermanPatternNodeCategory("PRMan_output_nodes", "PRMan outputs",
items = [RendermanOutputNode]),
RendermanPatternNodeCategory("PRMan_bxdf", "PRMan Bxdfs",
items=sorted(bxdf_nodeitems, key=attrgetter('_label')) ),
RendermanPatternNodeCategory("PRMan_patterns", "PRMan Patterns",
items=sorted(pattern_nodeitems, key=attrgetter('_label')) ),
RendermanPatternNodeCategory("PRMan_lights", "PRMan Lights",
items=sorted(light_nodeitems, key=attrgetter('_label')) )
]
nodeitems_utils.register_node_categories("RENDERMANSHADERNODES",
node_categories)
def register():
bpy.utils.register_class(RendermanShaderSocket)
bpy.utils.register_class(RendermanNodeSocketColor)
bpy.utils.register_class(RendermanNodeSocketFloat)
bpy.utils.register_class(RendermanNodeSocketInt)
bpy.utils.register_class(RendermanNodeSocketString)
bpy.utils.register_class(RendermanNodeSocketVector)
user_preferences = bpy.context.user_preferences
prefs = user_preferences.addons[__package__].preferences
#from bpy.app.handlers import persistent
#@persistent
#def load_handler(dummy):
categories = {}
for name, arg_file in args_files_in_path(prefs, None).items():
generate_node_type(prefs, name, ET.parse(arg_file).getroot())
pattern_nodeitems = []
bxdf_nodeitems = []
light_nodeitems = []
for name, node_type in RendermanPatternGraph.nodetypes.items():
node_item = NodeItem(name, label=node_type.bl_label)
if node_type.renderman_node_type == 'pattern':
pattern_nodeitems.append(node_item)
elif node_type.renderman_node_type == 'bxdf':
bxdf_nodeitems.append(node_item)
elif node_type.renderman_node_type == 'light':
light_nodeitems.append(node_item)
# all categories in a list
node_categories = [
# identifier, label, items list
RendermanPatternNodeCategory("PRMan_output_nodes", "PRMan outputs",
items = [RendermanOutputNode]),
RendermanPatternNodeCategory("PRMan_bxdf", "PRMan Bxdfs",
items=sorted(bxdf_nodeitems, key=attrgetter('_label')) ),
RendermanPatternNodeCategory("PRMan_patterns", "PRMan Patterns",
items=sorted(pattern_nodeitems, key=attrgetter('_label')) ),
RendermanPatternNodeCategory("PRMan_lights", "PRMan Lights",
items=sorted(light_nodeitems, key=attrgetter('_label')) )
]
nodeitems_utils.register_node_categories("RENDERMANSHADERNODES",
node_categories)
def register():
# two calls needed
# one for registering the things in this file
# the other everything that lives in the fake 'animation_nodes'
# namespace. It registers everything else.
bpy.utils.register_module(__name__)
bpy.utils.register_module("animation_nodes")
categories = mn_node_register.getNodeCategories()
# if we use F8 reload this happens.
if "ANIMATIONNODES" in nodeitems_utils._node_categories:
unregister_node_categories("ANIMATIONNODES")
register_node_categories("ANIMATIONNODES", categories)
bpy.types.Scene.mn_settings = PointerProperty(type = AnimationNodesSettings, name = "Animation Node Settings")
print("Loaded Animation Nodes with {} modules".format(len(animation_nodes_modules)))
def register():
import nodeitems_utils
from .utils import sv_tools, text_editor_plugins, text_editor_submenu
node_tree.register()
for n in nodes_list:
n.register()
sv_tools.register()
text_editor_plugins.register()
text_editor_submenu.register()
handlers.register()
bpy.utils.register_class(SverchokPreferences)
if 'SVERCHOK' not in nodeitems_utils._node_categories:
nodeitems_utils.register_node_categories("SVERCHOK", menu.make_categories())
def register():
bpy.app.handlers.load_post.append( appleseed_scene_loaded)
bpy.app.handlers.scene_update_pre.append( appleseed_scene_loaded)
nodeitems_utils.register_node_categories("APPLESEED", appleseed_node_categories)
bpy.utils.register_class( AppleseedNodeTree)
ashikhmin_brdf.register()
bsdf_blend.register()
diffuse_btdf.register()
disney_brdf.register()
kelemen_brdf.register()
lambertian_brdf.register()
microfacet_brdf.register()
orennayar_brdf.register()
specular_brdf.register()
specular_btdf.register()
texture.register()
normal.register()
material.register()
def register():
# all categories in a list
node_categories = [
# identifier, label, items list
SORTPatternNodeCategory("SORT_bxdf", "SORT Bxdfs",items= [NodeItem("SORTNodeLambert"),NodeItem("SORTNodeMerl"),NodeItem("SORTNodeMicrofacetReflection"),NodeItem("SORTNodeMicrofacetRefraction"),NodeItem("SORTNodeOrenNayar")] ),
SORTPatternNodeCategory("SORT_operator", "SORT Operator",items= [NodeItem("SORTNodeAdd"),NodeItem("SORTNodeMultiply"),NodeItem("SORTNodeBlend"),NodeItem("SORTNodeLerp")] ),
SORTPatternNodeCategory("SORT_texture", "SORT Texture",items= [NodeItem("SORTNodeGrid"),NodeItem("SORTNodeCheckbox"),NodeItem("SORTNodeImage")] ),
SORTPatternNodeCategory("SORT_constant", "SORT Constant",items= [NodeItem("SORTNodeConstant")] ),
SORTPatternNodeCategory("SORT_input", "SORT Input",items=[],),
]
nodeitems_utils.register_node_categories("SORTSHADERNODES",node_categories)
# register node types
SORTPatternGraph.nodetypes[SORTNodeLambert] = 'SORTNodeLambert'
SORTPatternGraph.nodetypes[SORTNodeMerl] = 'SORTNodeMerl'
SORTPatternGraph.nodetypes[SORTNodeMicrofacetReflection] = 'SORTNodeMicrofacetReflection'
SORTPatternGraph.nodetypes[SORTNodeMicrofacetRefraction] = 'SORTNodeMicrofacetRefraction'
SORTPatternGraph.nodetypes[SORTNodeOrenNayar] = 'SORTNodeOrenNayar'
def register():
import nodeitems_utils
categors_menu = menu.make_categories()
print("** Sverchok has {i} nodes **".format(i=categors_menu[1]))
for m in imported_modules + node_list:
if hasattr(m, "register"):
m.register()
else:
pass
#print("failed to register {}".format(m.__name__))
if 'SVERCHOK' not in nodeitems_utils._node_categories:
nodeitems_utils.register_node_categories("SVERCHOK", categors_menu[0])
if reload_event:
# tag reload event which will cause a full sverchok startup on
# first update event
for m in imported_modules:
if m.__name__ == "data_structure":
m.RELOAD_EVENT = True
print("Sverchok is reloaded, press update")
def register():
bpy.utils.register_class(CrowdMasterAGenTree)
bpy.utils.register_class(GeoSocket)
bpy.utils.register_class(TemplateSocket)
bpy.utils.register_class(GenerateNode)
bpy.utils.register_class(AddToGroupNode)
bpy.utils.register_class(ObjectInputNode)
bpy.utils.register_class(GroupInputNode)
bpy.utils.register_class(LinkGroupNode)
bpy.utils.register_class(ConstrainBoneNode)
bpy.utils.register_class(ModifyBoneNode)
bpy.utils.register_class(GeoSwitchNode)
bpy.utils.register_class(TemplateSwitchNode)
bpy.utils.register_class(ParentNode)
bpy.utils.register_class(material_entry)
bpy.utils.register_class(material_UIList)
bpy.utils.register_class(SCENE_OT_cm_materialsNode_add)
bpy.utils.register_class(SCENE_OT_cm_materialsNode_remove)
bpy.utils.register_class(RandomMaterialNode)
bpy.utils.register_class(TemplateNode)
bpy.utils.register_class(OffsetNode)
bpy.utils.register_class(RandomNode)
bpy.utils.register_class(PointTowardsNode)
bpy.utils.register_class(CombineNode)
bpy.utils.register_class(RandomPositionNode)
bpy.utils.register_class(MeshPositionNode)
bpy.utils.register_class(VCOLPositionNode)
bpy.utils.register_class(PathPositionNode)
bpy.utils.register_class(FormationPositionNode)
bpy.utils.register_class(TargetPositionNode)
bpy.utils.register_class(ObstacleNode)
bpy.utils.register_class(GroundNode)
bpy.utils.register_class(SettagNode)
bpy.utils.register_class(NoteNode)
bpy.utils.register_class(GenNoteTextFromClipboard)
bpy.utils.register_class(GenNoteClear)
nodeitems_utils.register_node_categories(
"AGEN_CUSTOM_NODES", agen_node_categories)
def register():
bpy.utils.register_class(TaskTree)
for prop, proptype in taskdna.Props.get_bpy_types():
setattr(bpy.types.TaskTree, 'task_{}'.format(prop), proptype())
bpy.types.TaskTree.task_name = bpy.props.StringProperty()
def get_nodes(self, context):
too_many = len(self.nodes) >= 32
return [
tuple([node.name] * 3) for node in self.nodes
if node.select or not too_many]
bpy.types.TaskTree.task_deps = bpy.props.EnumProperty(
items=get_nodes,options={'ENUM_FLAG'})
for bpy_class in (TaskSocket, TaskNode):
bpy.utils.register_class(bpy_class)
nodeitems_utils.register_node_categories("CUSTOM_NODES", node_categories)
for bpy_class in (
CreateTask, TasksImport, TasksExport, TasksExportCSV,
TasksImportCSV, TaskCreatePanel,
TaskIOPanel, SearchOperator, SearchPanel, StatsPanel):
bpy.utils.register_class(bpy_class)
def register():
properties.register()
interface.register()
node_tree.register()
field_container.register()
exporter.register()
# Idee: root am SceneGraph
# 1.)
# alle objects haben CollectionProperty,
# sollte beim exportieren des scene graphs ein die CollectionProperty eines
# Hierarchieknotens leer sein, wird ein default FieldContainer des
# passenden typs erstellt
# 2.) wenn ein Node gelöscht wird, soll auf referenzierten blender objecten
# vorher die Referenz auf diesen Node entfernt werden
#bpy.types.Object.avango_nodes = bpy.props.CollectionProperty(type=bpy.types.PropertyGroup)
if not 'AVANGO_NODES' in nu._node_categories:
nu.register_node_categories('AVANGO_NODES', node_categories)
def register():
bpy.utils.register_class(CrowdMasterTree)
bpy.utils.register_class(DefaultSocket)
bpy.utils.register_class(StateSocket)
bpy.utils.register_class(DependanceSocket)
bpy.utils.register_class(LogicNode)
bpy.utils.register_class(StateNode)
bpy.utils.register_class(NewInputNode)
bpy.utils.register_class(GraphNode)
bpy.utils.register_class(MathNode)
bpy.utils.register_class(AndNode)
bpy.utils.register_class(OrNode)
bpy.utils.register_class(NotNode)
bpy.utils.register_class(SetTagNode)
bpy.utils.register_class(FilterNode)
bpy.utils.register_class(MapNode)
bpy.utils.register_class(OutputNode)
bpy.utils.register_class(PriorityNode)
bpy.utils.register_class(PrintNode)
bpy.utils.register_class(StartState)
bpy.utils.register_class(ActionState)
bpy.utils.register_class(NoteNode)
bpy.utils.register_class(SimNoteClear)
bpy.utils.register_class(CrowdMasterMuteSimNodes)
nodeitems_utils.register_node_categories(
"CrowdMaster_NODES", node_categories)
wm = bpy.context.window_manager
kc = wm.keyconfigs.addon
if kc:
global keyMap
keyMap = kc.keymaps.new(name='Node Editor', space_type='NODE_EDITOR')
kmi = keyMap.keymap_items.new('node.cm_sim_mute', 'M', 'PRESS')
keyMapItems.append(kmi)
def register():
bpy.utils.register_class(MyCustomTree)
bpy.utils.register_class(MyCustomSocket)
bpy.utils.register_class(MyCustomNode)
nodeitems_utils.register_node_categories("CUSTOM_NODES", node_categories)
def register():
nodeitems_utils.register_node_categories("LUXCORE_TEXTURE_TREE", luxcore_node_categories_texture)
def register():
categories = get_categories()
nodeitems_utils.register_node_categories('elements_node_tree', categories)
def register():
bpy.utils.register_class(ShaderNode_MultiInput)
nodeitems_utils.register_node_categories("SH_MultiInput", node_categories)
def register():
nodeitems_utils.register_node_categories("SHADER", shader_node_categories)
nodeitems_utils.register_node_categories("COMPOSITING", compositor_node_categories)
nodeitems_utils.register_node_categories("TEXTURE", texture_node_categories)
def register():
nodeitems_utils.register_node_categories('SHADER', shader_node_categories)
nodeitems_utils.register_node_categories('COMPOSITING', compositor_node_categories)
nodeitems_utils.register_node_categories('TEXTURE', texture_node_categories)
nodeitems_utils.register_node_categories('GEOMETRY', geometry_node_categories)
def register():
for x in classes:
register_class(x)
nodeitems_utils.register_node_categories('RENIM_MAPPING_NODES',
node_categories)
def register():
nodeitems_utils.register_node_categories("LUXCORE_VOLUME_TREE",
luxcore_node_categories_volume)
def register():
from bpy.utils import register_class
for cls in classes:
register_class(cls)
nodeitems_utils.register_node_categories('CUSTOM_NODES', bdc.node_categories)
def register():
bpy.utils.register_class(CGPipelineTree)
bpy.utils.register_class(BeginNode)
bpy.utils.register_class(DrawMeshesNode)
bpy.utils.register_class(DrawRectsNode)
bpy.utils.register_class(DrawDecalsNode)
bpy.utils.register_class(ClearTargetNode)
bpy.utils.register_class(ClearImageNode)
bpy.utils.register_class(GenerateMipmapsNode)
bpy.utils.register_class(SetTargetNode)
bpy.utils.register_class(SetViewportNode)
bpy.utils.register_class(BindTargetNode)
bpy.utils.register_class(DrawMaterialQuadNode)
bpy.utils.register_class(DrawQuadNode)
bpy.utils.register_class(DrawWorldNode)
bpy.utils.register_class(DrawCompositorNode)
bpy.utils.register_class(DrawCompositorWithFXAANode)
bpy.utils.register_class(DrawGreasePencilNode)
bpy.utils.register_class(TargetNode)
bpy.utils.register_class(ShadowMapNode)
bpy.utils.register_class(ImageNode)
bpy.utils.register_class(Image3DNode)
bpy.utils.register_class(TargetArrayNode)
bpy.utils.register_class(DepthBufferNode)
bpy.utils.register_class(GBufferNode)
bpy.utils.register_class(FramebufferNode)
bpy.utils.register_class(QuadPassNode)
bpy.utils.register_class(SSAOPassNode)
bpy.utils.register_class(SSAOReprojectPassNode)
bpy.utils.register_class(ApplySSAOPassNode)
bpy.utils.register_class(SSRPassNode)
bpy.utils.register_class(BloomPassNode)
bpy.utils.register_class(MotionBlurPassNode)
bpy.utils.register_class(MotionBlurVelocityPassNode)
bpy.utils.register_class(CopyPassNode)
bpy.utils.register_class(MatIDToDepthNode)
bpy.utils.register_class(BlendPassNode)
bpy.utils.register_class(CombinePassNode)
bpy.utils.register_class(BlurBasicPassNode)
bpy.utils.register_class(DebugNormalsPassNode)
bpy.utils.register_class(FXAAPassNode)
bpy.utils.register_class(SSResolveNode)
bpy.utils.register_class(SMAAPassNode)
bpy.utils.register_class(TAAPassNode)
bpy.utils.register_class(SSSPassNode)
bpy.utils.register_class(WaterPassNode)
bpy.utils.register_class(DeferredLightPassNode)
bpy.utils.register_class(DeferredIndirectPassNode)
bpy.utils.register_class(VolumetricLightPassNode)
bpy.utils.register_class(TranslucentResolvePassNode)
bpy.utils.register_class(ScreenNode)
bpy.utils.register_class(BackgroundColorNode)
bpy.utils.register_class(LampCountNode)
bpy.utils.register_class(CallFunctionNode)
bpy.utils.register_class(BranchFunctionNode)
bpy.utils.register_class(MergeStagesNode)
bpy.utils.register_class(LoopStagesNode)
bpy.utils.register_class(LoopLampsNode)
bpy.utils.register_class(DrawStereoNode)
nodeitems_utils.register_node_categories("CG_PIPELINE_NODES", node_categories)
def register():
global original_poll_func
original_poll_func = ShaderNodeCategory.poll
ShaderNodeCategory.poll = hide_func
nodeitems_utils.register_node_categories("PBRT_SHADER_NODES",
pbrt_shader_node_category)
def register():
nodeitems_utils.register_node_categories('elements_node_tree',
node_categories)
def register():
bpy.utils.register_module(__name__)
try:
nodeitems_utils.register_node_categories("CG_NODES", node_categories)
except:
pass
def register():
nodeitems_utils.register_node_categories("GameGraphType", node_categories)
def register():
categories = getNodeCategories()
register_node_categories("ANIMATIONNODES", categories)
