def draw(self, layout, context):
# Blender's NodeItem completely unlists anything that polls False. We would rather
# display the item but disabled so the user has a hint that it exists but cannot be
# used at the present time.
if self._poll_add is not None and not self._poll_add(context):
row = layout.row()
row.enabled = False
NodeItem.draw(self, row, context)
else:
NodeItem.draw(self, layout, context)
bpy.ops.image.invert(invert_r=False, invert_g=False, invert_b=False, invert_a=False)
class MyNodeCategory(NodeCategory):
@classmethod
def poll(cls, context):
return context.space_data.tree_type == "ImageTreeType"
node_categories = [
# identifier, label, items list
MyNodeCategory(
"IMAGEPNODES",
"Image Processing Nodes",
items=[
NodeItem("ImageInputNodeType"),
NodeItem("ImageViewNodeType"),
NodeItem("ImageOutputNodeType"),
],
)
]
# ### INITIALIZATION
# register classes
regclasses = [ImageInputNode, ImageViewNode, ImageOutputNode]
def register():
for entry in regclasses:
bpy.utils.register_class(entry)
and eevee_shader_nodes_poll(context))
def object_eevee_cycles_shader_nodes_poll(context):
return (object_shader_nodes_poll(context)
and eevee_cycles_shader_nodes_poll(context))
# All standard node categories currently used in nodes.
shader_node_categories = [
# Shader Nodes (Cycles and Eevee)
ShaderNodeCategory("SH_NEW_INPUT",
"Input",
items=[
NodeItem("ShaderNodeTexCoord"),
NodeItem("ShaderNodeAttribute"),
NodeItem("ShaderNodeLightPath"),
NodeItem("ShaderNodeFresnel"),
NodeItem("ShaderNodeLayerWeight"),
NodeItem("ShaderNodeRGB"),
NodeItem("ShaderNodeValue"),
NodeItem("ShaderNodeTangent"),
NodeItem("ShaderNodeNewGeometry"),
NodeItem("ShaderNodeWireframe"),
NodeItem("ShaderNodeBevel"),
NodeItem("ShaderNodeAmbientOcclusion"),
NodeItem("ShaderNodeObjectInfo"),
NodeItem("ShaderNodeHairInfo"),
NodeItem("ShaderNodeVolumeInfo"),
NodeItem("ShaderNodeParticleInfo"),
snode.shader_type == 'WORLD')
# only show nodes working in object node trees
def object_shader_nodes_poll(context):
snode = context.space_data
return (snode.tree_type == 'ShaderNodeTree' and
snode.shader_type == 'OBJECT')
# All standard node categories currently used in nodes.
shader_node_categories = [
# Shader Nodes
ShaderOldNodeCategory("SH_INPUT", "Input", items=[
NodeItem("ShaderNodeMaterial"),
NodeItem("ShaderNodeCameraData"),
NodeItem("ShaderNodeLampData"),
NodeItem("ShaderNodeValue"),
NodeItem("ShaderNodeRGB"),
NodeItem("ShaderNodeTexture"),
NodeItem("ShaderNodeGeometry"),
NodeItem("ShaderNodeExtendedMaterial"),
NodeItem("ShaderNodeParticleInfo"),
NodeItem("NodeGroupInput", poll=group_input_output_item_poll),
]),
ShaderOldNodeCategory("SH_OUTPUT", "Output", items=[
NodeItem("ShaderNodeOutput"),
NodeItem("NodeGroupOutput", poll=group_input_output_item_poll),
]),
ShaderOldNodeCategory("SH_OP_COLOR", "Color", items=[
bl_icon = ICON_VOLUME
class LuxCoreNodeCategoryVolume(NodeCategory):
@classmethod
def poll(cls, context):
return context.space_data.tree_type == "luxcore_volume_nodes"
# Here we define the menu structure the user sees when he
# presses Shift+A in the node editor to add a new node
luxcore_node_categories_volume = [
LuxCoreNodeCategoryVolume("LUXCORE_VOLUME_VOLUME",
"Volume",
items=[
NodeItem("LuxCoreNodeVolClear",
label="Clear"),
NodeItem("LuxCoreNodeVolHomogeneous",
label="Homogeneous"),
NodeItem("LuxCoreNodeVolHeterogeneous",
label="Heterogeneous"),
]),
LuxCoreNodeCategoryVolume(
"LUXCORE_VOLUME_TEXTURE",
"Texture",
items=[
# Note: 2D textures make no sense for volumes
NodeItem("LuxCoreNodeTexBrick", label="Brick"),
NodeItem("LuxCoreNodeTexCheckerboard3D", label="3D Checkerboard"),
NodeItem("LuxCoreNodeTexfBM", label="fBM"),
NodeItem("LuxCoreNodeTexMarble", label="Marble"),
NodeItem("LuxCoreNodeTexWindy", label="Windy"),
@persistent
def on_file_loaded(scene):
''' initialize cache after a blender file open '''
core.init_cache()
#---------------------------------------------------------------------------------
# VTKNodeCategory
#---------------------------------------------------------------------------------
class VTKNodeCategory(NodeCategory):
@classmethod
def poll(cls, context):
return context.space_data.tree_type == 'VTKTreeType'
menu_items = [NodeItem(x) for x in core.TYPENAMES]
node_categories = [VTKNodeCategory("ALL", "vtk nodes", items=menu_items)]
#---------------------------------------------------------------------------------
# Registering
#---------------------------------------------------------------------------------
def register():
bpy.app.handlers.load_post.append(on_file_loaded)
for c in core.CLASSES:
bpy.utils.register_class(c)
nodeitems_utils.register_node_categories("VTK_NODES", node_categories)
def unregister():
nodeitems_utils.unregister_node_categories("VTK_NODES")
return .125, .571, .125, 1
class MyNodeCategory(NodeCategory):
@classmethod
def poll(cls, context):
return context.space_data.tree_type == 'mtree_node_tree'
# all categories in a list
node_categories = [
# identifier, label, items list
MyNodeCategory('NODES',
"Nodes",
items=[
NodeItem("MtreeTrunk"),
NodeItem("MtreeRoots"),
NodeItem("MtreeParameters"),
NodeItem("MtreeGrow"),
NodeItem("MtreeSplit"),
NodeItem("MtreeBranch"),
NodeItem("MtreeTwig")
]),
]
class MTREE_OT_SaveLoadPreset(Operator):
"""save Mtree node tree as preset"""
bl_idname = "mtree.saveloadpreset"
bl_label = " Save or Load Preset"
bl_options = {"REGISTER", "UNDO"}
import time
from . import render
from .utils import new_name
class DisabledShaderNodeCategory(NodeCategory):
@classmethod
def poll(cls, context):
return context.space_data.tree_type == 'ShaderNodeTree'
node_categories = [
DisabledShaderNodeCategory("SHADERS",
"Shaders",
items=[
NodeItem("ShaderNodeAddShader"),
NodeItem("ShaderNodeBsdfDiffuse"),
NodeItem("ShaderNodeEmission"),
NodeItem("ShaderNodeBsdfGlass"),
NodeItem("ShaderNodeBsdfGlossy"),
NodeItem("ShaderNodeHoldout"),
NodeItem("ShaderNodeMixShader"),
NodeItem("ShaderNodeBsdfPrincipled"),
NodeItem("ShaderNodeVolumePrincipled"),
NodeItem("ShaderNodeBsdfRefraction"),
NodeItem("ShaderNodeEeveeSpecular"),
NodeItem("ShaderNodeSubsurfaceScattering"),
NodeItem("ShaderNodeBsdfTranslucent"),
NodeItem("ShaderNodeBsdfTransparent"),
NodeItem("ShaderNodeVolumeAbsorption"),
NodeItem("ShaderNodeVolumeScatter"),
def geometry_node_items(context):
if context is None:
return
space = context.space_data
if not space:
return
yield NodeItem("GeometryNodeBoundBox")
yield NodeItem("GeometryNodeConvexHull")
yield NodeItem("GeometryNodeDeleteGeometry")
yield NodeItem("GeometryNodeDuplicateElements")
yield NodeItem("GeometryNodeProximity")
yield NodeItem("GeometryNodeGeometryToInstance")
yield NodeItem("GeometryNodeJoinGeometry")
yield NodeItem("GeometryNodeMergeByDistance")
yield NodeItem("GeometryNodeRaycast")
yield NodeItem("GeometryNodeSeparateComponents")
yield NodeItem("GeometryNodeSeparateGeometry")
yield NodeItem("GeometryNodeTransform")
yield NodeItemCustom(draw=lambda self, layout, context: layout.separator())
yield NodeItem("GeometryNodeSetID")
yield NodeItem("GeometryNodeSetPosition")
def mesh_node_items(context):
if context is None:
return
space = context.space_data
if not space:
return
yield NodeItem("GeometryNodeDualMesh")
yield NodeItem("GeometryNodeExtrudeMesh")
yield NodeItem("GeometryNodeFlipFaces")
yield NodeItem("GeometryNodeMeshBoolean")
yield NodeItem("GeometryNodeMeshToCurve")
yield NodeItem("GeometryNodeMeshToPoints")
yield NodeItem("GeometryNodeSplitEdges")
yield NodeItem("GeometryNodeSubdivideMesh")
yield NodeItem("GeometryNodeSubdivisionSurface")
yield NodeItem("GeometryNodeTriangulate")
yield NodeItem("GeometryNodeScaleElements")
yield NodeItemCustom(draw=lambda self, layout, context: layout.separator())
yield NodeItem("GeometryNodeInputMeshEdgeAngle")
yield NodeItem("GeometryNodeInputMeshEdgeNeighbors")
yield NodeItem("GeometryNodeInputMeshEdgeVertices")
yield NodeItem("GeometryNodeInputMeshFaceArea")
yield NodeItem("GeometryNodeInputMeshFaceNeighbors")
yield NodeItem("GeometryNodeInputMeshFaceIsPlanar")
yield NodeItem("GeometryNodeInputMeshIsland")
yield NodeItem("GeometryNodeInputShadeSmooth")
yield NodeItem("GeometryNodeInputMeshVertexNeighbors")
yield NodeItemCustom(draw=lambda self, layout, context: layout.separator())
yield NodeItem("GeometryNodeSetShadeSmooth")
and eevee_shader_nodes_poll(context))
def object_eevee_cycles_shader_nodes_poll(context):
return (object_shader_nodes_poll(context)
and eevee_cycles_shader_nodes_poll(context))
# All standard node categories currently used in nodes.
shader_node_categories = [
# Shader Nodes (Cycles and Eevee)
ShaderNodeCategory("SH_NEW_INPUT",
"Input",
items=[
NodeItem("ShaderNodeTexCoord"),
NodeItem("ShaderNodeAttribute"),
NodeItem("ShaderNodeLightPath"),
NodeItem("ShaderNodeFresnel"),
NodeItem("ShaderNodeLayerWeight"),
NodeItem("ShaderNodeRGB"),
NodeItem("ShaderNodeValue"),
NodeItem("ShaderNodeTangent"),
NodeItem("ShaderNodeNewGeometry"),
NodeItem("ShaderNodeWireframe"),
NodeItem("ShaderNodeBevel"),
NodeItem("ShaderNodeAmbientOcclusion"),
NodeItem("ShaderNodeObjectInfo"),
NodeItem("ShaderNodeHairInfo"),
NodeItem("ShaderNodePointInfo"),
NodeItem("ShaderNodeVolumeInfo"),
BnhelaCharacterSocket,
BnhelaLocationSocket,
)
class BnhelaNodeCategory(NodeCategory):
@classmethod
def poll(cls, context):
return context.space_data.tree_type == 'BnhelaNodeTree'
node_categories = [
BnhelaNodeCategory('GENERIC',
"Basic",
items=[
NodeItem("BnhelaCharacterNode"),
NodeItem("BnhelaLocationNode"),
NodeItem("BnhelaSceneNode"),
]),
BnhelaNodeCategory('LAYOUT',
"Layout",
items=[
NodeItem("NodeFrame"),
NodeItem("NodeReroute"),
])
]
def register():
from bpy.utils import register_class
for cls in classes:
def draw_buttons(self, context, layout):
layout.prop(self, "op")
class ClNodeCategory(NodeCategory):
@classmethod
def poll(cls, context):
return context.space_data.tree_type == "ClNodeTree"
categories = [
ClNodeCategory("INPUT_CATEGORY",
"Input",
items=[
NodeItem("ClNodeSurfaceInput"),
NodeItem("ClNodeSolidInput"),
NodeItem("ClNodeParticleInput"),
NodeItem("ClNodeFieldInput"),
NodeItem("ClNodeSmokeCache"),
NodeItem("ClNodeFogPostInput"),
NodeItem("ClNodeFloatInput"),
NodeItem("ClNodeVectorInput"),
NodeItem("ClNodeVoxelInfo"),
NodeItem("ClNodeAdvectionInfo"),
NodeItem("ClNodeObjectInfo"),
NodeItem("ClNodeSceneInfo"),
]),
ClNodeCategory("OUTPUT_CATEGORY",
"Output",
items=[
def point_node_items(context):
if context is None:
return
space = context.space_data
if not space:
return
if geometry_nodes_legacy_poll(context):
yield NodeItem("GeometryNodeLegacyAlignRotationToVector",
poll=geometry_nodes_legacy_poll)
yield NodeItem("GeometryNodeLegacyPointDistribute",
poll=geometry_nodes_legacy_poll)
yield NodeItem("GeometryNodeLegacyPointInstance",
poll=geometry_nodes_legacy_poll)
yield NodeItem("GeometryNodeLegacyPointScale",
poll=geometry_nodes_legacy_poll)
yield NodeItem("GeometryNodeLegacyPointSeparate",
poll=geometry_nodes_legacy_poll)
yield NodeItem("GeometryNodeLegacyPointTranslate",
poll=geometry_nodes_legacy_poll)
yield NodeItem("GeometryNodeLegacyRotatePoints",
poll=geometry_nodes_legacy_poll)
yield NodeItemCustom(
draw=lambda self, layout, context: layout.separator())
yield NodeItem("GeometryNodeDistributePointsOnFaces")
yield NodeItem("GeometryNodePointsToVertices")
yield NodeItem("GeometryNodePointsToVolume")
yield NodeItemCustom(draw=lambda self, layout, context: layout.separator())
yield NodeItemCustom(draw=lambda self, layout, context: layout.separator())
yield NodeItem("GeometryNodeSetPointRadius")
def geometry_node_items(context):
if context is None:
return
space = context.space_data
if not space:
return
if geometry_nodes_legacy_poll(context):
yield NodeItem("GeometryNodeLegacyDeleteGeometry",
poll=geometry_nodes_legacy_poll)
yield NodeItem("GeometryNodeLegacyRaycast",
poll=geometry_nodes_legacy_poll)
yield NodeItemCustom(
draw=lambda self, layout, context: layout.separator())
yield NodeItem("GeometryNodeBoundBox")
yield NodeItem("GeometryNodeConvexHull")
yield NodeItem("GeometryNodeDeleteGeometry")
yield NodeItem("GeometryNodeGeometryToInstance")
yield NodeItem("GeometryNodeProximity")
yield NodeItem("GeometryNodeJoinGeometry")
yield NodeItem("GeometryNodeRaycast")
yield NodeItem("GeometryNodeSeparateComponents")
yield NodeItem("GeometryNodeSeparateGeometry")
yield NodeItem("GeometryNodeTransform")
yield NodeItemCustom(draw=lambda self, layout, context: layout.separator())
yield NodeItem("GeometryNodeSetID")
yield NodeItem("GeometryNodeSetPosition")
for line in self.myCollProperty:
col.label(line.name)
import nodeitems_utils
from nodeitems_utils import NodeCategory, NodeItem
# our own base class with an appropriate poll function,
# so the categories only show up in our own tree type
class CommentNodeCategory(NodeCategory):
pass
# all categories in a list
comment_node_categories = [
# identifier, label, items list
CommentNodeCategory("COMMENTNODES", "Commenting", items=[
NodeItem(CommentNode.bl_idname, label="Comment"),
]),
]
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 unregister():
def geometry_input_node_items(context):
if context is None:
return
space = context.space_data
if not space:
return
yield NodeItem("FunctionNodeInputBool")
yield NodeItem("GeometryNodeCollectionInfo")
yield NodeItem("FunctionNodeInputColor")
yield NodeItem("FunctionNodeInputInt")
yield NodeItem("GeometryNodeIsViewport")
yield NodeItem("GeometryNodeInputMaterial")
yield NodeItem("GeometryNodeObjectInfo")
yield NodeItem("FunctionNodeInputString")
yield NodeItem("ShaderNodeValue")
yield NodeItem("FunctionNodeInputVector")
yield NodeItemCustom(draw=lambda self, layout, context: layout.separator())
yield NodeItem("GeometryNodeInputID")
yield NodeItem("GeometryNodeInputIndex")
yield NodeItem("GeometryNodeInputNamedAttribute")
yield NodeItem("GeometryNodeInputNormal")
yield NodeItem("GeometryNodeInputPosition")
yield NodeItem("GeometryNodeInputRadius")
yield NodeItem("GeometryNodeInputSceneTime")
# our own base class with an appropriate poll function,
# so the categories only show up in our own tree type
class MyNodeCategory(NodeCategory):
@classmethod
def poll(cls, context):
return context.space_data.tree_type == 'CustomTreeType'
# all categories in a list
node_categories = [
# identifier, label, items list
MyNodeCategory('SOMENODES', "Some Nodes", items=[
# our basic node
NodeItem("CustomNodeType"),
]),
MyNodeCategory('OTHERNODES', "Other 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()
NodeItem("CustomNodeType", label="Node A", settings={
"my_string_prop": repr("Lorem ipsum dolor sit amet"),
"my_float_prop": repr(1.0),
}),
NodeItem("CustomNodeType", label="Node B", settings={
"my_string_prop": repr("consectetur adipisicing elit"),
"my_float_prop": repr(2.0),
}),
]),
def curve_node_items(context):
if context is None:
return
space = context.space_data
if not space:
return
yield NodeItem("GeometryNodeCurveLength")
yield NodeItem("GeometryNodeCurveToMesh")
yield NodeItem("GeometryNodeCurveToPoints")
yield NodeItem("GeometryNodeFillCurve")
yield NodeItem("GeometryNodeFilletCurve")
yield NodeItem("GeometryNodeResampleCurve")
yield NodeItem("GeometryNodeReverseCurve")
yield NodeItem("GeometryNodeSampleCurve")
yield NodeItem("GeometryNodeSubdivideCurve")
yield NodeItem("GeometryNodeTrimCurve")
yield NodeItemCustom(draw=lambda self, layout, context: layout.separator())
yield NodeItem("GeometryNodeInputCurveHandlePositions")
yield NodeItem("GeometryNodeInputTangent")
yield NodeItem("GeometryNodeInputCurveTilt")
yield NodeItem("GeometryNodeCurveEndpointSelection")
yield NodeItem("GeometryNodeCurveHandleTypeSelection")
yield NodeItem("GeometryNodeInputSplineCyclic")
yield NodeItem("GeometryNodeSplineLength")
yield NodeItem("GeometryNodeSplineParameter")
yield NodeItem("GeometryNodeInputSplineResolution")
yield NodeItemCustom(draw=lambda self, layout, context: layout.separator())
yield NodeItem("GeometryNodeSetCurveRadius")
yield NodeItem("GeometryNodeSetCurveTilt")
yield NodeItem("GeometryNodeSetCurveHandlePositions")
yield NodeItem("GeometryNodeCurveSetHandles")
yield NodeItem("GeometryNodeSetSplineCyclic")
yield NodeItem("GeometryNodeSetSplineResolution")
yield NodeItem("GeometryNodeCurveSplineType")
class KaleidoscopeCategory(NodeCategory):
@classmethod
def poll(cls, context):
b = False
if context.space_data.tree_type == 'ShaderNodeTree':
b = True
return b
# all categories in a list
node_categories = [
KaleidoscopeCategory("KALEIDOSCOPENODES",
"Kaleidoscope",
items=[
NodeItem("kaleidoscope_hybrid.node"),
NodeItem("spectrum_palette.node"),
NodeItem("intensity.node")
]),
]
class Kaleidoscope(bpy.types.AddonPreferences):
bl_idname = "kaleidoscope"
def draw(self, context):
kaleidoscope_props = bpy.context.scene.kaleidoscope_props
layout = self.layout
box = layout.box()
col = box.column()
row = col.row()
def deco(cls):
item = NodeItem(nodetype=cls.bl_idname)
items.append(item)
return cls
@classmethod
def poll(cls, context):
return context.space_data.tree_type == "cm_AudioNodeTree"
class AudioObjectNodeCategory(NodeCategory):
@classmethod
def poll(cls, context):
return context.space_data.tree_type == "cm_AudioNodeTree"
categories = [
AudioSetupNodeCategory("AUDIO_SETUP_CATEGORY",
"Setup",
items=[
NodeItem("cm_audio.midi_guitar_info_node"),
NodeItem("cm_audio.midi_guitar_note_node"),
NodeItem("cm_audio.midi_analyse_node"),
NodeItem("cm_audio.midi_bake_node"),
NodeItem("cm_audio_midi_init_node"),
NodeItem("cm_audio_midi_accum"),
NodeItem("cm_audio_midi_midi_handler"),
NodeItem("cm_audio.render_node"),
NodeItem("cm_audio_sound_bake_node"),
]),
AudioEditNodeCategory("AUDIO_EDIT_CATEGORY",
"Edit & Utility Tools",
items=[
NodeItem("cm_audio.bounce_node"),
NodeItem("cm_audio.compare_node"),
NodeItem("cm_audio.condition_node"),
def register_rman_nodes():
global __RMAN_NODE_CATEGORIES__
rfb_log().debug("Registering RenderMan Plugin Nodes:")
path_list = get_path_list()
for path in path_list:
for root, dirnames, filenames in os.walk(path):
for filename in filenames:
if filename.endswith(('.args', '.oso')):
node_desc = NodeDesc(
FilePath(root).join(FilePath(filename)))
__RMAN_NODES__[node_desc.node_type].append(node_desc)
rfb_log().debug("\t%s" % node_desc.name)
# These plugin types are special. They are not actually shading
# nodes that can be used in Blender's shading editor, but
# we still create PropertyGroups for them so they can be inserted
# into the correct UI panel.
if node_desc.node_type in [
'integrator', 'projection', 'displaydriver',
'displayfilter', 'samplefilter', 'light',
'lightfilter'
]:
register_plugin_types(node_desc)
if node_desc.name != 'PxrMeshLight':
# for mesh light, we need to create a shader graph node
continue
typename, nodetype = generate_node_type(node_desc)
if not typename and not nodetype:
continue
if typename and nodetype:
__RMAN_NODE_TYPES__[typename] = nodetype
# categories
node_item = NodeItem(typename, label=nodetype.bl_label)
if node_desc.node_type == 'pattern':
if hasattr(node_desc, 'classification'):
try:
tokens = node_desc.classification.split('/')
category = tokens[-1].lower()
lst = __RMAN_NODE_CATEGORIES__.get(
'patterns_%s' % category, None)
if not lst:
lst = ('RenderMan %s Patterns' %
category.capitalize(), [])
lst[1].append(node_item)
__RMAN_NODE_CATEGORIES__['patterns_%s' %
category] = lst
except:
pass
else:
__RMAN_NODE_CATEGORIES__['patterns_misc'][
1].append(node_item)
elif node_desc.node_type == 'bxdf':
__RMAN_NODE_CATEGORIES__['bxdf'][1].append(node_item)
elif node_desc.node_type == 'displace':
__RMAN_NODE_CATEGORIES__['displace'][1].append(
node_item)
elif node_desc.node_type == 'light':
__RMAN_NODE_CATEGORIES__['light'][1].append(node_item)
rfb_log().debug("Finished Registering RenderMan Plugin Nodes.")
# all categories in a list
node_categories = [
# identifier, label, items list
RendermanPatternNodeCategory(
"PRMan_output_nodes",
"RenderMan Outputs",
items=[
NodeItem(
'RendermanOutputNode',
label=rman_bl_nodes_shaders.RendermanOutputNode.bl_label)
]),
]
for name, (desc, items) in __RMAN_NODE_CATEGORIES__.items():
node_categories.append(
RendermanPatternNodeCategory(name,
desc,
items=sorted(
items, key=attrgetter('_label'))))
nodeitems_utils.register_node_categories("RENDERMANSHADERNODES",
node_categories)
# filter out recursive groups
if contains_group(group, ntree):
continue
yield NodeItem(node_tree_group_type[group.bl_idname], group.name,
{"node_tree": "bpy.data.node_groups[%r]" % group.name})
# All standard node categories currently used in nodes.
shader_node_categories = [
# Shader Nodes
ShaderOldNodeCategory("SH_INPUT",
"Input",
items=[
NodeItem("ShaderNodeMaterial"),
NodeItem("ShaderNodeCameraData"),
NodeItem("ShaderNodeValue"),
NodeItem("ShaderNodeRGB"),
NodeItem("ShaderNodeTexture"),
NodeItem("ShaderNodeGeometry"),
NodeItem("ShaderNodeExtendedMaterial"),
]),
ShaderOldNodeCategory("SH_OUTPUT",
"Output",
items=[
NodeItem("ShaderNodeOutput"),
]),
ShaderOldNodeCategory("SH_OP_COLOR",
"Color",
items=[
def add_node(node_class, category):
global nodes
nodes.append(node_class)
if category_items.get(category) == None:
category_items[category] = []
category_items[category].append(NodeItem(node_class.bl_idname))
bl_idname = "luxcore_volume_nodes"
bl_label = "LuxCore Volume Nodes"
bl_icon = icons.NTREE_VOLUME
class LuxCoreNodeCategoryVolume(NodeCategory):
@classmethod
def poll(cls, context):
return context.space_data.tree_type == "luxcore_volume_nodes"
# Here we define the menu structure the user sees when he
# presses Shift+A in the node editor to add a new node
luxcore_node_categories_volume = [
LuxCoreNodeCategoryVolume("LUXCORE_VOLUME_VOLUME", "Volume", items=[
NodeItem("LuxCoreNodeVolClear", label="Clear"),
NodeItem("LuxCoreNodeVolHomogeneous", label="Homogeneous"),
NodeItem("LuxCoreNodeVolHeterogeneous", label="Heterogeneous"),
]),
LuxCoreNodeCategoryVolume("LUXCORE_VOLUME_TEXTURE", "Texture", items=[
# Note: 2D textures make no sense for volumes
NodeItem("LuxCoreNodeTexBrick", label="Brick"),
NodeItem("LuxCoreNodeTexCheckerboard3D", label="3D Checkerboard"),
NodeItem("LuxCoreNodeTexfBM", label="fBM"),
NodeItem("LuxCoreNodeTexMarble", label="Marble"),
NodeItem("LuxCoreNodeTexWindy", label="Windy"),
NodeItem("LuxCoreNodeTexWrinkled", label="Wrinkled"),
NodeItem("LuxCoreNodeTexSmoke", label="Smoke Data"),
NodeItem("LuxCoreNodeTexOpenVDB", label="OpenVDB File"),
]),
context.scene.render.engine == 'octane'
# only show input/output nodes inside node groups
def group_input_output_item_poll(context):
space = context.space_data
if space.edit_tree in bpy.data.node_groups.values():
return True
return False
# All standard node categories currently used in nodes.
shader_node_categories = [
# Shader Nodes
# New Shader Nodes (Octane)
ShaderNewNodeCategory("SH_NEW_OCT_SHADER", "Octane Shader", items=[
NodeItem("ShaderNodeOctDiffuseMat"),
NodeItem("ShaderNodeOctGlossyMat"),
NodeItem("ShaderNodeOctSpecularMat"),
NodeItem("ShaderNodeOctMixMat"),
NodeItem("ShaderNodeOctPortalMat"),
]),
ShaderNewNodeCategory("SH_NEW_OCT_TEXTURE", "Octane Texture", items=[
NodeItem("ShaderNodeOctFloatTex"),
NodeItem("ShaderNodeOctRGBSpectrumTex"),
NodeItem("ShaderNodeOctGaussSpectrumTex"),
NodeItem("ShaderNodeOctChecksTex"),
NodeItem("ShaderNodeOctMarbleTex"),
NodeItem("ShaderNodeOctRidgedFractalTex"),
NodeItem("ShaderNodeOctSawWaveTex"),
NodeItem("ShaderNodeOctSineWaveTex"),
NodeItem("ShaderNodeOctTriWaveTex"),
def not_implemented_node(idname):
NodeType = getattr(bpy.types, idname)
name = NodeType.bl_rna.name
label = "%s (mockup)" % name
return NodeItem(idname, label=label)
from rprblender.utils import is_rpr_active
class RPR_ShaderNodeCategory(NodeCategory):
@classmethod
def poll(cls, context):
return context.scene.render.engine == "RPR"\
and context.space_data.tree_type in ('ShaderNodeTree', 'RPRTreeType')
node_categories = [
RPR_ShaderNodeCategory(
'RPR_INPUT',
"Input",
items=[
NodeItem('ShaderNodeAmbientOcclusion'),
NodeItem('ShaderNodeFresnel'),
NodeItem('ShaderNodeLayerWeight'),
NodeItem('ShaderNodeObjectInfo'),
NodeItem('ShaderNodeRGB'),
NodeItem('ShaderNodeTexCoord'),
NodeItem('ShaderNodeValue'),
NodeItem('ShaderNodeNewGeometry'),
NodeItem('ShaderNodeUVMap'),
NodeItem('RPRShaderProceduralUVNode'),
NodeItem('RPRShaderNodeLookup'),
],
),
RPR_ShaderNodeCategory(
'RPR_OUTPUT',
"Output",
def add_node(node_class, category):
global nodes
nodes.append(node_class)
category_items[category].append(NodeItem(node_class.bl_idname))
# output has changed
utils_node.update_opengl_materials(None, bpy.context)
class LuxCoreNodeCategoryMaterial(NodeCategory):
@classmethod
def poll(cls, context):
return context.space_data.tree_type == "luxcore_material_nodes"
# Here we define the menu structure the user sees when he
# presses Shift+A in the node editor to add a new node.
# In general it is a good idea to put often used nodes near the top.
luxcore_node_categories_material = [
LuxCoreNodeCategoryMaterial("LUXCORE_MATERIAL_MATERIAL", "Material", items=[
NodeItem("LuxCoreNodeMatDisney", label="Disney"),
NodeItem("LuxCoreNodeMatMix", label="Mix"),
NodeItem("LuxCoreNodeMatMatte", label="Matte"),
NodeItem("LuxCoreNodeMatMatteTranslucent", label="Matte Translucent"),
NodeItem("LuxCoreNodeMatMetal", label="Metal"),
NodeItem("LuxCoreNodeMatMirror", label="Mirror"),
NodeItem("LuxCoreNodeMatGlossy2", label="Glossy"),
NodeItem("LuxCoreNodeMatGlossyTranslucent", label="Glossy Translucent"),
NodeItem("LuxCoreNodeMatGlossyCoating", label="Glossy Coating"),
NodeItem("LuxCoreNodeMatGlass", label="Glass"),
NodeItem("LuxCoreNodeMatNull", label="Null (Transparent)"),
NodeItem("LuxCoreNodeMatCarpaint", label="Carpaint"),
NodeItem("LuxCoreNodeMatCloth", label="Cloth"),
NodeItem("LuxCoreNodeMatVelvet", label="Velvet"),
NodeItem("LuxCoreNodeMatTwoSided", label="Two Sided"),
NodeItem("LuxCoreNodeMatFrontBackOpacity", label="Front/Back Opacity"),