diff --git a/release/scripts/startup/nodeitems_builtins.py b/release/scripts/startup/nodeitems_builtins.py index 21bb3d01616..53fdee5fc3c 100644 --- a/release/scripts/startup/nodeitems_builtins.py +++ b/release/scripts/startup/nodeitems_builtins.py @@ -1,758 +1,759 @@ # SPDX-License-Identifier: GPL-2.0-or-later import bpy import nodeitems_utils from nodeitems_utils import ( NodeCategory, NodeItem, NodeItemCustom, ) # Subclasses for standard node types class SortedNodeCategory(NodeCategory): def __init__(self, identifier, name, description="", items=None): # for builtin nodes the convention is to sort by name if isinstance(items, list): items = sorted(items, key=lambda item: item.label.lower()) super().__init__(identifier, name, description=description, items=items) class CompositorNodeCategory(SortedNodeCategory): @classmethod def poll(cls, context): return (context.space_data.type == 'NODE_EDITOR' and context.space_data.tree_type == 'CompositorNodeTree') class ShaderNodeCategory(SortedNodeCategory): @classmethod def poll(cls, context): return (context.space_data.type == 'NODE_EDITOR' and context.space_data.tree_type == 'ShaderNodeTree') class TextureNodeCategory(SortedNodeCategory): @classmethod def poll(cls, context): return (context.space_data.type == 'NODE_EDITOR' and context.space_data.tree_type == 'TextureNodeTree') class GeometryNodeCategory(SortedNodeCategory): @classmethod def poll(cls, context): return (context.space_data.type == 'NODE_EDITOR' and context.space_data.tree_type == 'GeometryNodeTree') # menu entry for node group tools def group_tools_draw(_self, layout, _context): layout.operator("node.group_make") layout.operator("node.group_ungroup") layout.separator() # maps node tree type to group node type node_tree_group_type = { 'CompositorNodeTree': 'CompositorNodeGroup', 'ShaderNodeTree': 'ShaderNodeGroup', 'TextureNodeTree': 'TextureNodeGroup', 'GeometryNodeTree': 'GeometryNodeGroup', } # Custom Menu for Geometry Node Curves. 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") # Custom Menu for Geometry Node Mesh. 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("GeometryNodeMeshToVolume") 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") # Custom Menu for Geometry Nodes "Geometry" category. 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") # Custom Menu for UV Nodes. def uv_node_items(context): if context is None: return space = context.space_data if not space: return yield NodeItem("GeometryNodeUVUnwrap") yield NodeItem("GeometryNodeUVPackIslands") # Custom Menu for Geometry Node Input Nodes. 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") # Custom Menu for Geometry Node Instance Nodes. def geometry_instance_node_items(context): if context is None: return space = context.space_data if not space: return yield NodeItem("GeometryNodeInstanceOnPoints") yield NodeItem("GeometryNodeInstancesToPoints") yield NodeItem("GeometryNodeRealizeInstances") yield NodeItem("GeometryNodeRotateInstances") yield NodeItem("GeometryNodeScaleInstances") yield NodeItem("GeometryNodeTranslateInstances") yield NodeItemCustom(draw=lambda self, layout, context: layout.separator()) yield NodeItem("GeometryNodeInputInstanceRotation") yield NodeItem("GeometryNodeInputInstanceScale") # Custom Menu for Material Nodes. def geometry_material_node_items(context): if context is None: return space = context.space_data if not space: return yield NodeItem("GeometryNodeReplaceMaterial") yield NodeItemCustom(draw=lambda self, layout, context: layout.separator()) yield NodeItem("GeometryNodeInputMaterialIndex") yield NodeItem("GeometryNodeMaterialSelection") yield NodeItemCustom(draw=lambda self, layout, context: layout.separator()) yield NodeItem("GeometryNodeSetMaterial") yield NodeItem("GeometryNodeSetMaterialIndex") # Custom Menu for Geometry Node Points. def point_node_items(context): if context is None: return space = context.space_data if not space: return + yield NodeItem("GeometryNodeDistributePointsInVolume") yield NodeItem("GeometryNodeDistributePointsOnFaces") yield NodeItem("GeometryNodePoints") 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") # Generic node group items generator for shader, compositor, geometry and texture node groups. def node_group_items(context): if context is None: return space = context.space_data if not space: return yield NodeItemCustom(draw=group_tools_draw) yield NodeItem("NodeGroupInput", poll=group_input_output_item_poll) yield NodeItem("NodeGroupOutput", poll=group_input_output_item_poll) ntree = space.edit_tree if not ntree: return yield NodeItemCustom(draw=lambda self, layout, context: layout.separator()) def contains_group(nodetree, group): if nodetree == group: return True else: for node in nodetree.nodes: if node.bl_idname in node_tree_group_type.values() and node.node_tree is not None: if contains_group(node.node_tree, group): return True return False for group in context.blend_data.node_groups: if group.bl_idname != ntree.bl_idname: continue # filter out recursive groups if contains_group(group, ntree): continue # filter out hidden nodetrees if group.name.startswith('.'): continue yield NodeItem(node_tree_group_type[group.bl_idname], label=group.name, settings={"node_tree": "bpy.data.node_groups[%r]" % group.name}) # 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 # only show input/output nodes when editing line style node trees def line_style_shader_nodes_poll(context): snode = context.space_data return (snode.tree_type == 'ShaderNodeTree' and snode.shader_type == 'LINESTYLE') # only show nodes working in world node trees def world_shader_nodes_poll(context): snode = context.space_data return (snode.tree_type == 'ShaderNodeTree' and 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') def cycles_shader_nodes_poll(context): return context.engine == 'CYCLES' def eevee_shader_nodes_poll(context): return context.engine == 'BLENDER_EEVEE' def eevee_cycles_shader_nodes_poll(context): return (cycles_shader_nodes_poll(context) or eevee_shader_nodes_poll(context)) def object_cycles_shader_nodes_poll(context): return (object_shader_nodes_poll(context) and cycles_shader_nodes_poll(context)) def object_eevee_shader_nodes_poll(context): return (object_shader_nodes_poll(context) 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"), NodeItem("ShaderNodeParticleInfo"), NodeItem("ShaderNodeCameraData"), NodeItem("ShaderNodeUVMap"), NodeItem("ShaderNodeVertexColor"), NodeItem("ShaderNodeUVAlongStroke", poll=line_style_shader_nodes_poll), ]), ShaderNodeCategory("SH_NEW_OUTPUT", "Output", items=[ NodeItem("ShaderNodeOutputMaterial", poll=object_eevee_cycles_shader_nodes_poll), NodeItem("ShaderNodeOutputLight", poll=object_cycles_shader_nodes_poll), NodeItem("ShaderNodeOutputAOV"), NodeItem("ShaderNodeOutputWorld", poll=world_shader_nodes_poll), NodeItem("ShaderNodeOutputLineStyle", poll=line_style_shader_nodes_poll), ]), ShaderNodeCategory("SH_NEW_SHADER", "Shader", items=[ NodeItem("ShaderNodeMixShader", poll=eevee_cycles_shader_nodes_poll), NodeItem("ShaderNodeAddShader", poll=eevee_cycles_shader_nodes_poll), NodeItem("ShaderNodeBsdfDiffuse", poll=object_eevee_cycles_shader_nodes_poll), NodeItem("ShaderNodeBsdfPrincipled", poll=object_eevee_cycles_shader_nodes_poll), NodeItem("ShaderNodeBsdfGlossy", poll=object_eevee_cycles_shader_nodes_poll), NodeItem("ShaderNodeBsdfTransparent", poll=object_eevee_cycles_shader_nodes_poll), NodeItem("ShaderNodeBsdfRefraction", poll=object_eevee_cycles_shader_nodes_poll), NodeItem("ShaderNodeBsdfGlass", poll=object_eevee_cycles_shader_nodes_poll), NodeItem("ShaderNodeBsdfTranslucent", poll=object_eevee_cycles_shader_nodes_poll), NodeItem("ShaderNodeBsdfAnisotropic", poll=object_cycles_shader_nodes_poll), NodeItem("ShaderNodeBsdfVelvet", poll=object_cycles_shader_nodes_poll), NodeItem("ShaderNodeBsdfToon", poll=object_cycles_shader_nodes_poll), NodeItem("ShaderNodeSubsurfaceScattering", poll=object_eevee_cycles_shader_nodes_poll), NodeItem("ShaderNodeEmission", poll=eevee_cycles_shader_nodes_poll), NodeItem("ShaderNodeBsdfHair", poll=object_cycles_shader_nodes_poll), NodeItem("ShaderNodeBackground", poll=world_shader_nodes_poll), NodeItem("ShaderNodeHoldout", poll=object_eevee_cycles_shader_nodes_poll), NodeItem("ShaderNodeVolumeAbsorption", poll=eevee_cycles_shader_nodes_poll), NodeItem("ShaderNodeVolumeScatter", poll=eevee_cycles_shader_nodes_poll), NodeItem("ShaderNodeVolumePrincipled"), NodeItem("ShaderNodeEeveeSpecular", poll=object_eevee_shader_nodes_poll), NodeItem("ShaderNodeBsdfHairPrincipled", poll=object_cycles_shader_nodes_poll) ]), ShaderNodeCategory("SH_NEW_TEXTURE", "Texture", items=[ NodeItem("ShaderNodeTexImage"), NodeItem("ShaderNodeTexEnvironment"), NodeItem("ShaderNodeTexSky"), NodeItem("ShaderNodeTexNoise"), NodeItem("ShaderNodeTexWave"), NodeItem("ShaderNodeTexVoronoi"), NodeItem("ShaderNodeTexMusgrave"), NodeItem("ShaderNodeTexGradient"), NodeItem("ShaderNodeTexMagic"), NodeItem("ShaderNodeTexChecker"), NodeItem("ShaderNodeTexBrick"), NodeItem("ShaderNodeTexPointDensity"), NodeItem("ShaderNodeTexIES"), NodeItem("ShaderNodeTexWhiteNoise"), ]), ShaderNodeCategory("SH_NEW_OP_COLOR", "Color", items=[ NodeItem("ShaderNodeMixRGB"), NodeItem("ShaderNodeRGBCurve"), NodeItem("ShaderNodeInvert"), NodeItem("ShaderNodeLightFalloff"), NodeItem("ShaderNodeHueSaturation"), NodeItem("ShaderNodeGamma"), NodeItem("ShaderNodeBrightContrast"), ]), ShaderNodeCategory("SH_NEW_OP_VECTOR", "Vector", items=[ NodeItem("ShaderNodeMapping"), NodeItem("ShaderNodeBump"), NodeItem("ShaderNodeDisplacement"), NodeItem("ShaderNodeVectorDisplacement"), NodeItem("ShaderNodeNormalMap"), NodeItem("ShaderNodeNormal"), NodeItem("ShaderNodeVectorCurve"), NodeItem("ShaderNodeVectorRotate"), NodeItem("ShaderNodeVectorTransform"), ]), ShaderNodeCategory("SH_NEW_CONVERTOR", "Converter", items=[ NodeItem("ShaderNodeMapRange"), NodeItem("ShaderNodeFloatCurve"), NodeItem("ShaderNodeClamp"), NodeItem("ShaderNodeMath"), NodeItem("ShaderNodeValToRGB"), NodeItem("ShaderNodeRGBToBW"), NodeItem("ShaderNodeShaderToRGB", poll=object_eevee_shader_nodes_poll), NodeItem("ShaderNodeVectorMath"), NodeItem("ShaderNodeSeparateColor"), NodeItem("ShaderNodeCombineColor"), NodeItem("ShaderNodeSeparateXYZ"), NodeItem("ShaderNodeCombineXYZ"), NodeItem("ShaderNodeWavelength"), NodeItem("ShaderNodeBlackbody"), ]), ShaderNodeCategory("SH_NEW_SCRIPT", "Script", items=[ NodeItem("ShaderNodeScript"), ]), ShaderNodeCategory("SH_NEW_GROUP", "Group", items=node_group_items), ShaderNodeCategory("SH_NEW_LAYOUT", "Layout", items=[ NodeItem("NodeFrame"), NodeItem("NodeReroute"), ]), ] compositor_node_categories = [ # Compositor Nodes CompositorNodeCategory("CMP_INPUT", "Input", items=[ NodeItem("CompositorNodeRLayers"), NodeItem("CompositorNodeImage"), NodeItem("CompositorNodeMovieClip"), NodeItem("CompositorNodeMask"), NodeItem("CompositorNodeRGB"), NodeItem("CompositorNodeValue"), NodeItem("CompositorNodeTexture"), NodeItem("CompositorNodeBokehImage"), NodeItem("CompositorNodeTime"), NodeItem("CompositorNodeSceneTime"), NodeItem("CompositorNodeTrackPos"), ]), CompositorNodeCategory("CMP_OUTPUT", "Output", items=[ NodeItem("CompositorNodeComposite"), NodeItem("CompositorNodeViewer"), NodeItem("CompositorNodeSplitViewer"), NodeItem("CompositorNodeOutputFile"), NodeItem("CompositorNodeLevels"), ]), CompositorNodeCategory("CMP_OP_COLOR", "Color", items=[ NodeItem("CompositorNodeMixRGB"), NodeItem("CompositorNodeAlphaOver"), NodeItem("CompositorNodeInvert"), NodeItem("CompositorNodeCurveRGB"), NodeItem("CompositorNodeHueSat"), NodeItem("CompositorNodeColorBalance"), NodeItem("CompositorNodeHueCorrect"), NodeItem("CompositorNodeBrightContrast"), NodeItem("CompositorNodeGamma"), NodeItem("CompositorNodeExposure"), NodeItem("CompositorNodeColorCorrection"), NodeItem("CompositorNodePosterize"), NodeItem("CompositorNodeTonemap"), NodeItem("CompositorNodeZcombine"), ]), CompositorNodeCategory("CMP_CONVERTOR", "Converter", items=[ NodeItem("CompositorNodeMath"), NodeItem("CompositorNodeValToRGB"), NodeItem("CompositorNodeSetAlpha"), NodeItem("CompositorNodePremulKey"), NodeItem("CompositorNodeIDMask"), NodeItem("CompositorNodeRGBToBW"), NodeItem("CompositorNodeSeparateColor"), NodeItem("CompositorNodeCombineColor"), NodeItem("CompositorNodeSeparateXYZ"), NodeItem("CompositorNodeCombineXYZ"), NodeItem("CompositorNodeSwitchView"), NodeItem("CompositorNodeConvertColorSpace"), ]), CompositorNodeCategory("CMP_OP_FILTER", "Filter", items=[ NodeItem("CompositorNodeBlur"), NodeItem("CompositorNodeBilateralblur"), NodeItem("CompositorNodeDilateErode"), NodeItem("CompositorNodeDespeckle"), NodeItem("CompositorNodeFilter"), NodeItem("CompositorNodeBokehBlur"), NodeItem("CompositorNodeVecBlur"), NodeItem("CompositorNodeDefocus"), NodeItem("CompositorNodeGlare"), NodeItem("CompositorNodeInpaint"), NodeItem("CompositorNodeDBlur"), NodeItem("CompositorNodePixelate"), NodeItem("CompositorNodeSunBeams"), NodeItem("CompositorNodeDenoise"), NodeItem("CompositorNodeAntiAliasing"), ]), CompositorNodeCategory("CMP_OP_VECTOR", "Vector", items=[ NodeItem("CompositorNodeNormal"), NodeItem("CompositorNodeMapValue"), NodeItem("CompositorNodeMapRange"), NodeItem("CompositorNodeNormalize"), NodeItem("CompositorNodeCurveVec"), ]), CompositorNodeCategory("CMP_MATTE", "Matte", items=[ NodeItem("CompositorNodeKeying"), NodeItem("CompositorNodeKeyingScreen"), NodeItem("CompositorNodeChannelMatte"), NodeItem("CompositorNodeColorSpill"), NodeItem("CompositorNodeBoxMask"), NodeItem("CompositorNodeEllipseMask"), NodeItem("CompositorNodeLumaMatte"), NodeItem("CompositorNodeDiffMatte"), NodeItem("CompositorNodeDistanceMatte"), NodeItem("CompositorNodeChromaMatte"), NodeItem("CompositorNodeColorMatte"), NodeItem("CompositorNodeDoubleEdgeMask"), NodeItem("CompositorNodeCryptomatte"), NodeItem("CompositorNodeCryptomatteV2"), ]), CompositorNodeCategory("CMP_DISTORT", "Distort", items=[ NodeItem("CompositorNodeScale"), NodeItem("CompositorNodeLensdist"), NodeItem("CompositorNodeMovieDistortion"), NodeItem("CompositorNodeTranslate"), NodeItem("CompositorNodeRotate"), NodeItem("CompositorNodeFlip"), NodeItem("CompositorNodeCrop"), NodeItem("CompositorNodeDisplace"), NodeItem("CompositorNodeMapUV"), NodeItem("CompositorNodeTransform"), NodeItem("CompositorNodeStabilize"), NodeItem("CompositorNodePlaneTrackDeform"), NodeItem("CompositorNodeCornerPin"), ]), CompositorNodeCategory("CMP_GROUP", "Group", items=node_group_items), CompositorNodeCategory("CMP_LAYOUT", "Layout", items=[ NodeItem("NodeFrame"), NodeItem("NodeReroute"), NodeItem("CompositorNodeSwitch"), ]), ] texture_node_categories = [ # Texture Nodes TextureNodeCategory("TEX_INPUT", "Input", items=[ NodeItem("TextureNodeCurveTime"), NodeItem("TextureNodeCoordinates"), NodeItem("TextureNodeTexture"), NodeItem("TextureNodeImage"), ]), TextureNodeCategory("TEX_OUTPUT", "Output", items=[ NodeItem("TextureNodeOutput"), NodeItem("TextureNodeViewer"), ]), TextureNodeCategory("TEX_OP_COLOR", "Color", items=[ NodeItem("TextureNodeMixRGB"), NodeItem("TextureNodeCurveRGB"), NodeItem("TextureNodeInvert"), NodeItem("TextureNodeHueSaturation"), NodeItem("TextureNodeCombineColor"), NodeItem("TextureNodeSeparateColor"), ]), TextureNodeCategory("TEX_PATTERN", "Pattern", items=[ NodeItem("TextureNodeChecker"), NodeItem("TextureNodeBricks"), ]), TextureNodeCategory("TEX_TEXTURE", "Textures", items=[ NodeItem("TextureNodeTexNoise"), NodeItem("TextureNodeTexDistNoise"), NodeItem("TextureNodeTexClouds"), NodeItem("TextureNodeTexBlend"), NodeItem("TextureNodeTexVoronoi"), NodeItem("TextureNodeTexMagic"), NodeItem("TextureNodeTexMarble"), NodeItem("TextureNodeTexWood"), NodeItem("TextureNodeTexMusgrave"), NodeItem("TextureNodeTexStucci"), ]), TextureNodeCategory("TEX_CONVERTOR", "Converter", items=[ NodeItem("TextureNodeMath"), NodeItem("TextureNodeValToRGB"), NodeItem("TextureNodeRGBToBW"), NodeItem("TextureNodeValToNor"), NodeItem("TextureNodeDistance"), ]), TextureNodeCategory("TEX_DISTORT", "Distort", items=[ NodeItem("TextureNodeScale"), NodeItem("TextureNodeTranslate"), NodeItem("TextureNodeRotate"), NodeItem("TextureNodeAt"), ]), TextureNodeCategory("TEX_GROUP", "Group", items=node_group_items), TextureNodeCategory("TEX_LAYOUT", "Layout", items=[ NodeItem("NodeFrame"), NodeItem("NodeReroute"), ]), ] geometry_node_categories = [ # Geometry Nodes GeometryNodeCategory("GEO_ATTRIBUTE", "Attribute", items=[ NodeItem("GeometryNodeCaptureAttribute"), NodeItem("GeometryNodeAttributeDomainSize"), NodeItem("GeometryNodeAttributeStatistic"), NodeItem("GeometryNodeAttributeTransfer"), NodeItem("GeometryNodeRemoveAttribute"), NodeItem("GeometryNodeStoreNamedAttribute"), ]), GeometryNodeCategory("GEO_COLOR", "Color", items=[ NodeItem("ShaderNodeMixRGB"), NodeItem("ShaderNodeRGBCurve"), NodeItem("ShaderNodeValToRGB"), NodeItem("FunctionNodeSeparateColor"), NodeItem("FunctionNodeCombineColor"), ]), GeometryNodeCategory("GEO_CURVE", "Curve", items=curve_node_items), GeometryNodeCategory("GEO_PRIMITIVES_CURVE", "Curve Primitives", items=[ NodeItem("GeometryNodeCurvePrimitiveLine"), NodeItem("GeometryNodeCurvePrimitiveCircle"), NodeItem("GeometryNodeCurveStar"), NodeItem("GeometryNodeCurveSpiral"), NodeItem("GeometryNodeCurveArc"), NodeItem("GeometryNodeCurveQuadraticBezier"), NodeItem("GeometryNodeCurvePrimitiveQuadrilateral"), NodeItem("GeometryNodeCurvePrimitiveBezierSegment"), ]), GeometryNodeCategory("GEO_GEOMETRY", "Geometry", items=geometry_node_items), GeometryNodeCategory("GEO_UV", "UV", items=uv_node_items), GeometryNodeCategory("GEO_INPUT", "Input", items=geometry_input_node_items), GeometryNodeCategory("GEO_INSTANCE", "Instances", items=geometry_instance_node_items), GeometryNodeCategory("GEO_MATERIAL", "Material", items=geometry_material_node_items), GeometryNodeCategory("GEO_MESH", "Mesh", items=mesh_node_items), GeometryNodeCategory("GEO_PRIMITIVES_MESH", "Mesh Primitives", items=[ NodeItem("GeometryNodeMeshCircle"), NodeItem("GeometryNodeMeshCone"), NodeItem("GeometryNodeMeshCube"), NodeItem("GeometryNodeMeshCylinder"), NodeItem("GeometryNodeMeshGrid"), NodeItem("GeometryNodeMeshIcoSphere"), NodeItem("GeometryNodeMeshLine"), NodeItem("GeometryNodeMeshUVSphere"), ]), GeometryNodeCategory("GEO_OUTPUT", "Output", items=[ NodeItem("GeometryNodeViewer"), ]), GeometryNodeCategory("GEO_POINT", "Point", items=point_node_items), GeometryNodeCategory("GEO_TEXT", "Text", items=[ NodeItem("FunctionNodeStringLength"), NodeItem("FunctionNodeSliceString"), NodeItem("FunctionNodeValueToString"), NodeItem("GeometryNodeStringJoin"), NodeItem("FunctionNodeInputSpecialCharacters"), NodeItem("GeometryNodeStringToCurves"), NodeItem("FunctionNodeReplaceString"), ]), GeometryNodeCategory("GEO_TEXTURE", "Texture", items=[ NodeItem("ShaderNodeTexBrick"), NodeItem("ShaderNodeTexChecker"), NodeItem("ShaderNodeTexGradient"), NodeItem("ShaderNodeTexMagic"), NodeItem("ShaderNodeTexMusgrave"), NodeItem("ShaderNodeTexNoise"), NodeItem("ShaderNodeTexVoronoi"), NodeItem("ShaderNodeTexWave"), NodeItem("ShaderNodeTexWhiteNoise"), NodeItem("GeometryNodeImageTexture"), ]), GeometryNodeCategory("GEO_UTILITIES", "Utilities", items=[ NodeItem("GeometryNodeAccumulateField"), NodeItem("GeometryNodeFieldAtIndex"), NodeItem("GeometryNodeFieldOnDomain"), NodeItem("ShaderNodeMapRange"), NodeItem("ShaderNodeFloatCurve"), NodeItem("ShaderNodeClamp"), NodeItem("ShaderNodeMath"), NodeItem("FunctionNodeBooleanMath"), NodeItem("FunctionNodeRotateEuler"), NodeItem("FunctionNodeCompare"), NodeItem("FunctionNodeFloatToInt"), NodeItem("GeometryNodeSwitch"), NodeItem("FunctionNodeRandomValue"), NodeItem("FunctionNodeAlignEulerToVector"), ]), GeometryNodeCategory("GEO_VECTOR", "Vector", items=[ NodeItem("ShaderNodeVectorCurve"), NodeItem("ShaderNodeSeparateXYZ"), NodeItem("ShaderNodeCombineXYZ"), NodeItem("ShaderNodeVectorMath"), NodeItem("ShaderNodeVectorRotate"), ]), GeometryNodeCategory("GEO_VOLUME", "Volume", items=[ NodeItem("GeometryNodeVolumeCube"), NodeItem("GeometryNodeVolumeToMesh"), ]), GeometryNodeCategory("GEO_GROUP", "Group", items=node_group_items), GeometryNodeCategory("GEO_LAYOUT", "Layout", items=[ NodeItem("NodeFrame"), NodeItem("NodeReroute"), ]), ] 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 unregister(): nodeitems_utils.unregister_node_categories('SHADER') nodeitems_utils.unregister_node_categories('COMPOSITING') nodeitems_utils.unregister_node_categories('TEXTURE') nodeitems_utils.unregister_node_categories('GEOMETRY') if __name__ == "__main__": register() diff --git a/source/blender/blenkernel/BKE_node.h b/source/blender/blenkernel/BKE_node.h index e13ac3180ec..9f5bb39c551 100644 --- a/source/blender/blenkernel/BKE_node.h +++ b/source/blender/blenkernel/BKE_node.h @@ -504,1060 +504,1061 @@ struct bNodeTree *ntreeLocalize(struct bNodeTree *ntree); * We have to assume the editor already changed completely. */ void ntreeLocalMerge(struct Main *bmain, struct bNodeTree *localtree, struct bNodeTree *ntree); /** * This is only direct data, tree itself should have been written. */ void ntreeBlendWrite(struct BlendWriter *writer, struct bNodeTree *ntree); /** * \note `ntree` itself has been read! */ void ntreeBlendReadData(struct BlendDataReader *reader, struct bNodeTree *ntree); void ntreeBlendReadLib(struct BlendLibReader *reader, struct bNodeTree *ntree); void ntreeBlendReadExpand(struct BlendExpander *expander, struct bNodeTree *ntree); /** \} */ /* -------------------------------------------------------------------- */ /** \name Node Tree Interface * \{ */ struct bNodeSocket *ntreeFindSocketInterface(struct bNodeTree *ntree, eNodeSocketInOut in_out, const char *identifier); struct bNodeSocket *ntreeAddSocketInterface(struct bNodeTree *ntree, eNodeSocketInOut in_out, const char *idname, const char *name); struct bNodeSocket *ntreeInsertSocketInterface(struct bNodeTree *ntree, eNodeSocketInOut in_out, const char *idname, struct bNodeSocket *next_sock, const char *name); struct bNodeSocket *ntreeAddSocketInterfaceFromSocket(struct bNodeTree *ntree, struct bNode *from_node, struct bNodeSocket *from_sock); struct bNodeSocket *ntreeInsertSocketInterfaceFromSocket(struct bNodeTree *ntree, struct bNodeSocket *next_sock, struct bNode *from_node, struct bNodeSocket *from_sock); void ntreeRemoveSocketInterface(struct bNodeTree *ntree, struct bNodeSocket *sock); struct StructRNA *ntreeInterfaceTypeGet(struct bNodeTree *ntree, bool create); void ntreeInterfaceTypeFree(struct bNodeTree *ntree); void ntreeInterfaceTypeUpdate(struct bNodeTree *ntree); /** \} */ /* -------------------------------------------------------------------- */ /** \name Generic API, Nodes * \{ */ struct bNodeType *nodeTypeFind(const char *idname); void nodeRegisterType(struct bNodeType *ntype); void nodeUnregisterType(struct bNodeType *ntype); bool nodeTypeUndefined(const struct bNode *node); struct GHashIterator *nodeTypeGetIterator(void); /* Helper macros for iterating over node types. */ #define NODE_TYPES_BEGIN(ntype) \ { \ GHashIterator *__node_type_iter__ = nodeTypeGetIterator(); \ for (; !BLI_ghashIterator_done(__node_type_iter__); \ BLI_ghashIterator_step(__node_type_iter__)) { \ bNodeType *ntype = (bNodeType *)BLI_ghashIterator_getValue(__node_type_iter__); #define NODE_TYPES_END \ } \ BLI_ghashIterator_free(__node_type_iter__); \ } \ ((void)0) struct bNodeSocketType *nodeSocketTypeFind(const char *idname); void nodeRegisterSocketType(struct bNodeSocketType *stype); void nodeUnregisterSocketType(struct bNodeSocketType *stype); bool nodeSocketIsRegistered(struct bNodeSocket *sock); struct GHashIterator *nodeSocketTypeGetIterator(void); const char *nodeSocketTypeLabel(const bNodeSocketType *stype); bool nodeIsStaticSocketType(const struct bNodeSocketType *stype); const char *nodeStaticSocketType(int type, int subtype); const char *nodeStaticSocketInterfaceType(int type, int subtype); const char *nodeStaticSocketLabel(int type, int subtype); /* Helper macros for iterating over node types. */ #define NODE_SOCKET_TYPES_BEGIN(stype) \ { \ GHashIterator *__node_socket_type_iter__ = nodeSocketTypeGetIterator(); \ for (; !BLI_ghashIterator_done(__node_socket_type_iter__); \ BLI_ghashIterator_step(__node_socket_type_iter__)) { \ bNodeSocketType *stype = (bNodeSocketType *)BLI_ghashIterator_getValue( \ __node_socket_type_iter__); #define NODE_SOCKET_TYPES_END \ } \ BLI_ghashIterator_free(__node_socket_type_iter__); \ } \ ((void)0) struct bNodeSocket *nodeFindSocket(const struct bNode *node, eNodeSocketInOut in_out, const char *identifier); struct bNodeSocket *nodeAddSocket(struct bNodeTree *ntree, struct bNode *node, eNodeSocketInOut in_out, const char *idname, const char *identifier, const char *name); struct bNodeSocket *nodeAddStaticSocket(struct bNodeTree *ntree, struct bNode *node, eNodeSocketInOut in_out, int type, int subtype, const char *identifier, const char *name); void nodeRemoveSocket(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock); void nodeRemoveSocketEx(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock, bool do_id_user); void nodeRemoveAllSockets(struct bNodeTree *ntree, struct bNode *node); void nodeModifySocketType(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock, const char *idname); void nodeModifySocketTypeStatic( struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock, int type, int subtype); struct bNode *nodeAddNode(const struct bContext *C, struct bNodeTree *ntree, const char *idname); struct bNode *nodeAddStaticNode(const struct bContext *C, struct bNodeTree *ntree, int type); /** * \note Goes over entire tree. */ void nodeUnlinkNode(struct bNodeTree *ntree, struct bNode *node); /** * Find the first available, non-duplicate name for a given node. */ void nodeUniqueName(struct bNodeTree *ntree, struct bNode *node); /** * Delete node, associated animation data and ID user count. */ void nodeRemoveNode(struct Main *bmain, struct bNodeTree *ntree, struct bNode *node, bool do_id_user); #ifdef __cplusplus namespace blender::bke { /** * \note keeps socket list order identical, for copying links. * \note `unique_name` should usually be true, unless the \a dst_tree is temporary, * or the names can already be assumed valid. */ bNode *node_copy_with_mapping(bNodeTree *dst_tree, const bNode &node_src, int flag, bool unique_name, Map &new_socket_map); bNode *node_copy(bNodeTree *dst_tree, const bNode &src_node, int flag, bool unique_name); } // namespace blender::bke #endif /** * Also used via RNA API, so we check for proper input output direction. */ struct bNodeLink *nodeAddLink(struct bNodeTree *ntree, struct bNode *fromnode, struct bNodeSocket *fromsock, struct bNode *tonode, struct bNodeSocket *tosock); void nodeRemLink(struct bNodeTree *ntree, struct bNodeLink *link); void nodeRemSocketLinks(struct bNodeTree *ntree, struct bNodeSocket *sock); void nodeMuteLinkToggle(struct bNodeTree *ntree, struct bNodeLink *link); bool nodeLinkIsHidden(const struct bNodeLink *link); bool nodeLinkIsSelected(const struct bNodeLink *link); void nodeInternalRelink(struct bNodeTree *ntree, struct bNode *node); void nodeToView(const struct bNode *node, float x, float y, float *rx, float *ry); void nodeFromView(const struct bNode *node, float x, float y, float *rx, float *ry); bool nodeAttachNodeCheck(const struct bNode *node, const struct bNode *parent); void nodeAttachNode(struct bNode *node, struct bNode *parent); void nodeDetachNode(struct bNode *node); void nodePositionRelative(struct bNode *from_node, struct bNode *to_node, struct bNodeSocket *from_sock, struct bNodeSocket *to_sock); void nodePositionPropagate(struct bNode *node); /** * Finds a node based on its name. */ struct bNode *nodeFindNodebyName(struct bNodeTree *ntree, const char *name); /** * Finds a node based on given socket and returns true on success. */ bool nodeFindNode(struct bNodeTree *ntree, struct bNodeSocket *sock, struct bNode **r_node, int *r_sockindex); /** * \note Recursive. */ struct bNode *nodeFindRootParent(bNode *node); /** * \returns true if \a child has \a parent as a parent/grandparent/... etc. * \note Recursive */ bool nodeIsChildOf(const bNode *parent, const bNode *child); /** * Iterate over a chain of nodes, starting with \a node_start, executing * \a callback for each node (which can return false to end iterator). * * \param reversed: for backwards iteration * \note Recursive */ void nodeChainIter(const bNodeTree *ntree, const bNode *node_start, bool (*callback)(bNode *, bNode *, void *, const bool), void *userdata, bool reversed); /** * Iterate over a chain of nodes, starting with \a node_start, executing * \a callback for each node (which can return false to end iterator). * * Faster than nodeChainIter. Iter only once per node. * Can be called recursively (using another nodeChainIterBackwards) by * setting the recursion_lvl accordingly. * * \note Needs updated socket links (ntreeUpdateTree). * \note Recursive */ void nodeChainIterBackwards(const bNodeTree *ntree, const bNode *node_start, bool (*callback)(bNode *, bNode *, void *), void *userdata, int recursion_lvl); /** * Iterate over all parents of \a node, executing \a callback for each parent * (which can return false to end iterator) * * \note Recursive */ void nodeParentsIter(bNode *node, bool (*callback)(bNode *, void *), void *userdata); struct bNodeLink *nodeFindLink(struct bNodeTree *ntree, const struct bNodeSocket *from, const struct bNodeSocket *to); int nodeCountSocketLinks(const struct bNodeTree *ntree, const struct bNodeSocket *sock); void nodeSetSelected(struct bNode *node, bool select); /** * Two active flags, ID nodes have special flag for buttons display. */ void nodeSetActive(struct bNodeTree *ntree, struct bNode *node); struct bNode *nodeGetActive(struct bNodeTree *ntree); void nodeClearActive(struct bNodeTree *ntree); /** * Two active flags, ID nodes have special flag for buttons display. */ struct bNode *nodeGetActiveTexture(struct bNodeTree *ntree); struct bNode *nodeGetActivePaintCanvas(struct bNodeTree *ntree); /** * \brief Does the given node supports the sub active flag. * * \param sub_active: The active flag to check. #NODE_ACTIVE_TEXTURE / #NODE_ACTIVE_PAINT_CANVAS. */ bool nodeSupportsActiveFlag(const struct bNode *node, int sub_active); int nodeSocketIsHidden(const struct bNodeSocket *sock); void nodeSetSocketAvailability(struct bNodeTree *ntree, struct bNodeSocket *sock, bool is_available); int nodeSocketLinkLimit(const struct bNodeSocket *sock); /** * If the node implements a `declare` function, this function makes sure that `node->declaration` * is up to date. It is expected that the sockets of the node are up to date already. */ bool nodeDeclarationEnsure(struct bNodeTree *ntree, struct bNode *node); /** * Just update `node->declaration` if necessary. This can also be called on nodes that may not be * up to date (e.g. because the need versioning or are dynamic). */ bool nodeDeclarationEnsureOnOutdatedNode(struct bNodeTree *ntree, struct bNode *node); /** * Update `socket->declaration` for all sockets in the node. This assumes that the node declaration * and sockets are up to date already. */ void nodeSocketDeclarationsUpdate(struct bNode *node); /** * Node Clipboard. */ void BKE_node_clipboard_init(const struct bNodeTree *ntree); void BKE_node_clipboard_clear(void); void BKE_node_clipboard_free(void); /** * Return false when one or more ID's are lost. */ bool BKE_node_clipboard_validate(void); void BKE_node_clipboard_add_node(struct bNode *node); void BKE_node_clipboard_add_link(struct bNodeLink *link); const struct ListBase *BKE_node_clipboard_get_nodes(void); const struct ListBase *BKE_node_clipboard_get_links(void); int BKE_node_clipboard_get_type(void); /** * Node Instance Hash. */ typedef struct bNodeInstanceHash { /** XXX should be made a direct member, #GHash allocation needs to support it */ GHash *ghash; } bNodeInstanceHash; typedef void (*bNodeInstanceValueFP)(void *value); /** * Magic number for initial hash key. */ extern const bNodeInstanceKey NODE_INSTANCE_KEY_BASE; extern const bNodeInstanceKey NODE_INSTANCE_KEY_NONE; bNodeInstanceKey BKE_node_instance_key(bNodeInstanceKey parent_key, const struct bNodeTree *ntree, const struct bNode *node); bNodeInstanceHash *BKE_node_instance_hash_new(const char *info); void BKE_node_instance_hash_free(bNodeInstanceHash *hash, bNodeInstanceValueFP valfreefp); void BKE_node_instance_hash_insert(bNodeInstanceHash *hash, bNodeInstanceKey key, void *value); void *BKE_node_instance_hash_lookup(bNodeInstanceHash *hash, bNodeInstanceKey key); int BKE_node_instance_hash_remove(bNodeInstanceHash *hash, bNodeInstanceKey key, bNodeInstanceValueFP valfreefp); void BKE_node_instance_hash_clear(bNodeInstanceHash *hash, bNodeInstanceValueFP valfreefp); void *BKE_node_instance_hash_pop(bNodeInstanceHash *hash, bNodeInstanceKey key); int BKE_node_instance_hash_haskey(bNodeInstanceHash *hash, bNodeInstanceKey key); int BKE_node_instance_hash_size(bNodeInstanceHash *hash); void BKE_node_instance_hash_clear_tags(bNodeInstanceHash *hash); void BKE_node_instance_hash_tag(bNodeInstanceHash *hash, void *value); bool BKE_node_instance_hash_tag_key(bNodeInstanceHash *hash, bNodeInstanceKey key); void BKE_node_instance_hash_remove_untagged(bNodeInstanceHash *hash, bNodeInstanceValueFP valfreefp); typedef GHashIterator bNodeInstanceHashIterator; BLI_INLINE bNodeInstanceHashIterator *BKE_node_instance_hash_iterator_new(bNodeInstanceHash *hash) { return BLI_ghashIterator_new(hash->ghash); } BLI_INLINE void BKE_node_instance_hash_iterator_init(bNodeInstanceHashIterator *iter, bNodeInstanceHash *hash) { BLI_ghashIterator_init(iter, hash->ghash); } BLI_INLINE void BKE_node_instance_hash_iterator_free(bNodeInstanceHashIterator *iter) { BLI_ghashIterator_free(iter); } BLI_INLINE bNodeInstanceKey BKE_node_instance_hash_iterator_get_key(bNodeInstanceHashIterator *iter) { return *(bNodeInstanceKey *)BLI_ghashIterator_getKey(iter); } BLI_INLINE void *BKE_node_instance_hash_iterator_get_value(bNodeInstanceHashIterator *iter) { return BLI_ghashIterator_getValue(iter); } BLI_INLINE void BKE_node_instance_hash_iterator_step(bNodeInstanceHashIterator *iter) { BLI_ghashIterator_step(iter); } BLI_INLINE bool BKE_node_instance_hash_iterator_done(bNodeInstanceHashIterator *iter) { return BLI_ghashIterator_done(iter); } #define NODE_INSTANCE_HASH_ITER(iter_, hash_) \ for (BKE_node_instance_hash_iterator_init(&iter_, hash_); \ BKE_node_instance_hash_iterator_done(&iter_) == false; \ BKE_node_instance_hash_iterator_step(&iter_)) /* Node Previews */ bool BKE_node_preview_used(const struct bNode *node); bNodePreview *BKE_node_preview_verify( struct bNodeInstanceHash *previews, bNodeInstanceKey key, int xsize, int ysize, bool create); bNodePreview *BKE_node_preview_copy(struct bNodePreview *preview); void BKE_node_preview_free(struct bNodePreview *preview); void BKE_node_preview_init_tree(struct bNodeTree *ntree, int xsize, int ysize); void BKE_node_preview_remove_unused(struct bNodeTree *ntree); void BKE_node_preview_clear(struct bNodePreview *preview); void BKE_node_preview_clear_tree(struct bNodeTree *ntree); void BKE_node_preview_merge_tree(struct bNodeTree *to_ntree, struct bNodeTree *from_ntree, bool remove_old); /** \} */ /* -------------------------------------------------------------------- */ /** \name Node Type Access * \{ */ void nodeLabel(const struct bNodeTree *ntree, const struct bNode *node, char *label, int maxlen); /** * Get node socket label if it is set. */ const char *nodeSocketLabel(const struct bNodeSocket *sock); bool nodeGroupPoll(struct bNodeTree *nodetree, struct bNodeTree *grouptree, const char **r_disabled_hint); /** * Initialize a new node type struct with default values and callbacks. */ void node_type_base(struct bNodeType *ntype, int type, const char *name, short nclass); void node_type_base_custom(struct bNodeType *ntype, const char *idname, const char *name, short nclass); void node_type_socket_templates(struct bNodeType *ntype, struct bNodeSocketTemplate *inputs, struct bNodeSocketTemplate *outputs); void node_type_size(struct bNodeType *ntype, int width, int minwidth, int maxwidth); void node_type_size_preset(struct bNodeType *ntype, eNodeSizePreset size); void node_type_init(struct bNodeType *ntype, void (*initfunc)(struct bNodeTree *ntree, struct bNode *node)); /** * \warning Nodes defining a storage type _must_ allocate this for new nodes. * Otherwise nodes will reload as undefined (T46619). */ void node_type_storage(struct bNodeType *ntype, const char *storagename, void (*freefunc)(struct bNode *node), void (*copyfunc)(struct bNodeTree *dest_ntree, struct bNode *dest_node, const struct bNode *src_node)); void node_type_update(struct bNodeType *ntype, void (*updatefunc)(struct bNodeTree *ntree, struct bNode *node)); void node_type_group_update(struct bNodeType *ntype, void (*group_update_func)(struct bNodeTree *ntree, struct bNode *node)); void node_type_exec(struct bNodeType *ntype, NodeInitExecFunction init_exec_fn, NodeFreeExecFunction free_exec_fn, NodeExecFunction exec_fn); void node_type_gpu(struct bNodeType *ntype, NodeGPUExecFunction gpu_fn); /** \} */ /* -------------------------------------------------------------------- */ /** \name Node Generic Functions * \{ */ bool BKE_node_is_connected_to_output(struct bNodeTree *ntree, struct bNode *node); /* ************** COMMON NODES *************** */ #define NODE_UNDEFINED -2 /* node type is not registered */ #define NODE_CUSTOM -1 /* for dynamically registered custom types */ #define NODE_GROUP 2 // #define NODE_FORLOOP 3 /* deprecated */ // #define NODE_WHILELOOP 4 /* deprecated */ #define NODE_FRAME 5 #define NODE_REROUTE 6 #define NODE_GROUP_INPUT 7 #define NODE_GROUP_OUTPUT 8 #define NODE_CUSTOM_GROUP 9 void BKE_node_tree_unlink_id(ID *id, struct bNodeTree *ntree); /** \} */ /* -------------------------------------------------------------------- */ /** \name Node Tree Iterator * * Utility macro for visiting every node tree in the library data, * including local bNodeTree blocks in other IDs. * This avoids the need for callback functions and allows executing code * in a single inner code block. * * Variables: * * - nodetree: * The actual bNodeTree data block. * Check nodetree->idname or nodetree->typeinfo to use only specific types. * * - id: * The owner of the bNodeTree data block. * Same as nodetree if it's a linkable node tree from the library. * * Examples: * * \code{.c} * FOREACH_NODETREE_BEGIN(bmain, nodetree, id) { * if (id == nodetree) * printf("This is a linkable node tree"); * } FOREACH_NODETREE_END; * * FOREACH_NODETREE_BEGIN(bmain, nodetree, id) { * if (nodetree->idname == "ShaderNodeTree") * printf("This is a shader node tree); * if (GS(id) == ID_MA) * printf(" and it's owned by a material"); * } FOREACH_NODETREE_END; * \endcode * * \{ */ /* should be an opaque type, only for internal use by BKE_node_tree_iter_*** */ struct NodeTreeIterStore { bNodeTree *ngroup; Scene *scene; struct Material *mat; Tex *tex; struct Light *light; struct World *world; struct FreestyleLineStyle *linestyle; struct Simulation *simulation; }; void BKE_node_tree_iter_init(struct NodeTreeIterStore *ntreeiter, struct Main *bmain); bool BKE_node_tree_iter_step(struct NodeTreeIterStore *ntreeiter, struct bNodeTree **r_nodetree, struct ID **r_id); #define FOREACH_NODETREE_BEGIN(bmain, _nodetree, _id) \ { \ struct NodeTreeIterStore _nstore; \ bNodeTree *_nodetree; \ ID *_id; \ /* avoid compiler warning about unused variables */ \ BKE_node_tree_iter_init(&_nstore, bmain); \ while (BKE_node_tree_iter_step(&_nstore, &_nodetree, &_id) == true) { \ if (_nodetree) { #define FOREACH_NODETREE_END \ } \ } \ } \ ((void)0) /** \} */ /* -------------------------------------------------------------------- */ /** \name Node Tree */ void BKE_nodetree_remove_layer_n(struct bNodeTree *ntree, struct Scene *scene, int layer_index); /* -------------------------------------------------------------------- */ /** \name Shader Nodes * \{ */ /* NOTE: types are needed to restore callbacks, don't change values. */ //#define SH_NODE_MATERIAL 100 #define SH_NODE_RGB 101 #define SH_NODE_VALUE 102 #define SH_NODE_MIX_RGB 103 #define SH_NODE_VALTORGB 104 #define SH_NODE_RGBTOBW 105 #define SH_NODE_SHADERTORGB 106 //#define SH_NODE_TEXTURE 106 #define SH_NODE_NORMAL 107 //#define SH_NODE_GEOMETRY 108 #define SH_NODE_MAPPING 109 #define SH_NODE_CURVE_VEC 110 #define SH_NODE_CURVE_RGB 111 #define SH_NODE_CAMERA 114 #define SH_NODE_MATH 115 #define SH_NODE_VECTOR_MATH 116 #define SH_NODE_SQUEEZE 117 //#define SH_NODE_MATERIAL_EXT 118 #define SH_NODE_INVERT 119 #define SH_NODE_SEPRGB_LEGACY 120 #define SH_NODE_COMBRGB_LEGACY 121 #define SH_NODE_HUE_SAT 122 #define SH_NODE_OUTPUT_MATERIAL 124 #define SH_NODE_OUTPUT_WORLD 125 #define SH_NODE_OUTPUT_LIGHT 126 #define SH_NODE_FRESNEL 127 #define SH_NODE_MIX_SHADER 128 #define SH_NODE_ATTRIBUTE 129 #define SH_NODE_BACKGROUND 130 #define SH_NODE_BSDF_ANISOTROPIC 131 #define SH_NODE_BSDF_DIFFUSE 132 #define SH_NODE_BSDF_GLOSSY 133 #define SH_NODE_BSDF_GLASS 134 #define SH_NODE_BSDF_TRANSLUCENT 137 #define SH_NODE_BSDF_TRANSPARENT 138 #define SH_NODE_BSDF_VELVET 139 #define SH_NODE_EMISSION 140 #define SH_NODE_NEW_GEOMETRY 141 #define SH_NODE_LIGHT_PATH 142 #define SH_NODE_TEX_IMAGE 143 #define SH_NODE_TEX_SKY 145 #define SH_NODE_TEX_GRADIENT 146 #define SH_NODE_TEX_VORONOI 147 #define SH_NODE_TEX_MAGIC 148 #define SH_NODE_TEX_WAVE 149 #define SH_NODE_TEX_NOISE 150 #define SH_NODE_TEX_MUSGRAVE 152 #define SH_NODE_TEX_COORD 155 #define SH_NODE_ADD_SHADER 156 #define SH_NODE_TEX_ENVIRONMENT 157 // #define SH_NODE_OUTPUT_TEXTURE 158 #define SH_NODE_HOLDOUT 159 #define SH_NODE_LAYER_WEIGHT 160 #define SH_NODE_VOLUME_ABSORPTION 161 #define SH_NODE_VOLUME_SCATTER 162 #define SH_NODE_GAMMA 163 #define SH_NODE_TEX_CHECKER 164 #define SH_NODE_BRIGHTCONTRAST 165 #define SH_NODE_LIGHT_FALLOFF 166 #define SH_NODE_OBJECT_INFO 167 #define SH_NODE_PARTICLE_INFO 168 #define SH_NODE_TEX_BRICK 169 #define SH_NODE_BUMP 170 #define SH_NODE_SCRIPT 171 #define SH_NODE_AMBIENT_OCCLUSION 172 #define SH_NODE_BSDF_REFRACTION 173 #define SH_NODE_TANGENT 174 #define SH_NODE_NORMAL_MAP 175 #define SH_NODE_HAIR_INFO 176 #define SH_NODE_SUBSURFACE_SCATTERING 177 #define SH_NODE_WIREFRAME 178 #define SH_NODE_BSDF_TOON 179 #define SH_NODE_WAVELENGTH 180 #define SH_NODE_BLACKBODY 181 #define SH_NODE_VECT_TRANSFORM 182 #define SH_NODE_SEPHSV_LEGACY 183 #define SH_NODE_COMBHSV_LEGACY 184 #define SH_NODE_BSDF_HAIR 185 // #define SH_NODE_LAMP 186 #define SH_NODE_UVMAP 187 #define SH_NODE_SEPXYZ 188 #define SH_NODE_COMBXYZ 189 #define SH_NODE_OUTPUT_LINESTYLE 190 #define SH_NODE_UVALONGSTROKE 191 #define SH_NODE_TEX_POINTDENSITY 192 #define SH_NODE_BSDF_PRINCIPLED 193 #define SH_NODE_TEX_IES 194 #define SH_NODE_EEVEE_SPECULAR 195 #define SH_NODE_BEVEL 197 #define SH_NODE_DISPLACEMENT 198 #define SH_NODE_VECTOR_DISPLACEMENT 199 #define SH_NODE_VOLUME_PRINCIPLED 200 /* 201..700 occupied by other node types, continue from 701 */ #define SH_NODE_BSDF_HAIR_PRINCIPLED 701 #define SH_NODE_MAP_RANGE 702 #define SH_NODE_CLAMP 703 #define SH_NODE_TEX_WHITE_NOISE 704 #define SH_NODE_VOLUME_INFO 705 #define SH_NODE_VERTEX_COLOR 706 #define SH_NODE_OUTPUT_AOV 707 #define SH_NODE_VECTOR_ROTATE 708 #define SH_NODE_CURVE_FLOAT 709 #define SH_NODE_POINT_INFO 710 #define SH_NODE_COMBINE_COLOR 711 #define SH_NODE_SEPARATE_COLOR 712 /** \} */ /* -------------------------------------------------------------------- */ /** \name Composite Nodes * \{ */ /* output socket defines */ #define RRES_OUT_IMAGE 0 #define RRES_OUT_ALPHA 1 /* NOTE: types are needed to restore callbacks, don't change values. */ #define CMP_NODE_VIEWER 201 #define CMP_NODE_RGB 202 #define CMP_NODE_VALUE 203 #define CMP_NODE_MIX_RGB 204 #define CMP_NODE_VALTORGB 205 #define CMP_NODE_RGBTOBW 206 #define CMP_NODE_NORMAL 207 #define CMP_NODE_CURVE_VEC 208 #define CMP_NODE_CURVE_RGB 209 #define CMP_NODE_ALPHAOVER 210 #define CMP_NODE_BLUR 211 #define CMP_NODE_FILTER 212 #define CMP_NODE_MAP_VALUE 213 #define CMP_NODE_TIME 214 #define CMP_NODE_VECBLUR 215 #define CMP_NODE_SEPRGBA_LEGACY 216 #define CMP_NODE_SEPHSVA_LEGACY 217 #define CMP_NODE_SETALPHA 218 #define CMP_NODE_HUE_SAT 219 #define CMP_NODE_IMAGE 220 #define CMP_NODE_R_LAYERS 221 #define CMP_NODE_COMPOSITE 222 #define CMP_NODE_OUTPUT_FILE 223 #define CMP_NODE_TEXTURE 224 #define CMP_NODE_TRANSLATE 225 #define CMP_NODE_ZCOMBINE 226 #define CMP_NODE_COMBRGBA_LEGACY 227 #define CMP_NODE_DILATEERODE 228 #define CMP_NODE_ROTATE 229 #define CMP_NODE_SCALE 230 #define CMP_NODE_SEPYCCA_LEGACY 231 #define CMP_NODE_COMBYCCA_LEGACY 232 #define CMP_NODE_SEPYUVA_LEGACY 233 #define CMP_NODE_COMBYUVA_LEGACY 234 #define CMP_NODE_DIFF_MATTE 235 #define CMP_NODE_COLOR_SPILL 236 #define CMP_NODE_CHROMA_MATTE 237 #define CMP_NODE_CHANNEL_MATTE 238 #define CMP_NODE_FLIP 239 #define CMP_NODE_SPLITVIEWER 240 // #define CMP_NODE_INDEX_MASK 241 #define CMP_NODE_MAP_UV 242 #define CMP_NODE_ID_MASK 243 #define CMP_NODE_DEFOCUS 244 #define CMP_NODE_DISPLACE 245 #define CMP_NODE_COMBHSVA_LEGACY 246 #define CMP_NODE_MATH 247 #define CMP_NODE_LUMA_MATTE 248 #define CMP_NODE_BRIGHTCONTRAST 249 #define CMP_NODE_GAMMA 250 #define CMP_NODE_INVERT 251 #define CMP_NODE_NORMALIZE 252 #define CMP_NODE_CROP 253 #define CMP_NODE_DBLUR 254 #define CMP_NODE_BILATERALBLUR 255 #define CMP_NODE_PREMULKEY 256 #define CMP_NODE_DIST_MATTE 257 #define CMP_NODE_VIEW_LEVELS 258 #define CMP_NODE_COLOR_MATTE 259 #define CMP_NODE_COLORBALANCE 260 #define CMP_NODE_HUECORRECT 261 #define CMP_NODE_MOVIECLIP 262 #define CMP_NODE_STABILIZE2D 263 #define CMP_NODE_TRANSFORM 264 #define CMP_NODE_MOVIEDISTORTION 265 #define CMP_NODE_DOUBLEEDGEMASK 266 #define CMP_NODE_OUTPUT_MULTI_FILE__DEPRECATED \ 267 /* DEPRECATED multi file node has been merged into regular CMP_NODE_OUTPUT_FILE */ #define CMP_NODE_MASK 268 #define CMP_NODE_KEYINGSCREEN 269 #define CMP_NODE_KEYING 270 #define CMP_NODE_TRACKPOS 271 #define CMP_NODE_INPAINT 272 #define CMP_NODE_DESPECKLE 273 #define CMP_NODE_ANTIALIASING 274 #define CMP_NODE_GLARE 301 #define CMP_NODE_TONEMAP 302 #define CMP_NODE_LENSDIST 303 #define CMP_NODE_SUNBEAMS 304 #define CMP_NODE_COLORCORRECTION 312 #define CMP_NODE_MASK_BOX 313 #define CMP_NODE_MASK_ELLIPSE 314 #define CMP_NODE_BOKEHIMAGE 315 #define CMP_NODE_BOKEHBLUR 316 #define CMP_NODE_SWITCH 317 #define CMP_NODE_PIXELATE 318 #define CMP_NODE_MAP_RANGE 319 #define CMP_NODE_PLANETRACKDEFORM 320 #define CMP_NODE_CORNERPIN 321 #define CMP_NODE_SWITCH_VIEW 322 #define CMP_NODE_CRYPTOMATTE_LEGACY 323 #define CMP_NODE_DENOISE 324 #define CMP_NODE_EXPOSURE 325 #define CMP_NODE_CRYPTOMATTE 326 #define CMP_NODE_POSTERIZE 327 #define CMP_NODE_CONVERT_COLOR_SPACE 328 #define CMP_NODE_SCENE_TIME 329 #define CMP_NODE_SEPARATE_XYZ 330 #define CMP_NODE_COMBINE_XYZ 331 #define CMP_NODE_COMBINE_COLOR 332 #define CMP_NODE_SEPARATE_COLOR 333 /* channel toggles */ #define CMP_CHAN_RGB 1 #define CMP_CHAN_A 2 /* filter types */ #define CMP_FILT_SOFT 0 #define CMP_FILT_SHARP_BOX 1 #define CMP_FILT_LAPLACE 2 #define CMP_FILT_SOBEL 3 #define CMP_FILT_PREWITT 4 #define CMP_FILT_KIRSCH 5 #define CMP_FILT_SHADOW 6 #define CMP_FILT_SHARP_DIAMOND 7 /* scale node type, in custom1 */ #define CMP_SCALE_RELATIVE 0 #define CMP_SCALE_ABSOLUTE 1 #define CMP_SCALE_SCENEPERCENT 2 #define CMP_SCALE_RENDERPERCENT 3 /* custom2 */ #define CMP_SCALE_RENDERSIZE_FRAME_ASPECT (1 << 0) #define CMP_SCALE_RENDERSIZE_FRAME_CROP (1 << 1) /* track position node, in custom1 */ #define CMP_TRACKPOS_ABSOLUTE 0 #define CMP_TRACKPOS_RELATIVE_START 1 #define CMP_TRACKPOS_RELATIVE_FRAME 2 #define CMP_TRACKPOS_ABSOLUTE_FRAME 3 /* Cryptomatte source. */ #define CMP_CRYPTOMATTE_SRC_RENDER 0 #define CMP_CRYPTOMATTE_SRC_IMAGE 1 /* Default SMAA configuration values. */ #define CMP_DEFAULT_SMAA_THRESHOLD 1.0f #define CMP_DEFAULT_SMAA_CONTRAST_LIMIT 0.2f #define CMP_DEFAULT_SMAA_CORNER_ROUNDING 0.25f /** \} */ /* -------------------------------------------------------------------- */ /** \name Texture Nodes * \{ */ struct TexResult; #define TEX_NODE_OUTPUT 401 #define TEX_NODE_CHECKER 402 #define TEX_NODE_TEXTURE 403 #define TEX_NODE_BRICKS 404 #define TEX_NODE_MATH 405 #define TEX_NODE_MIX_RGB 406 #define TEX_NODE_RGBTOBW 407 #define TEX_NODE_VALTORGB 408 #define TEX_NODE_IMAGE 409 #define TEX_NODE_CURVE_RGB 410 #define TEX_NODE_INVERT 411 #define TEX_NODE_HUE_SAT 412 #define TEX_NODE_CURVE_TIME 413 #define TEX_NODE_ROTATE 414 #define TEX_NODE_VIEWER 415 #define TEX_NODE_TRANSLATE 416 #define TEX_NODE_COORD 417 #define TEX_NODE_DISTANCE 418 #define TEX_NODE_COMPOSE_LEGACY 419 #define TEX_NODE_DECOMPOSE_LEGACY 420 #define TEX_NODE_VALTONOR 421 #define TEX_NODE_SCALE 422 #define TEX_NODE_AT 423 #define TEX_NODE_COMBINE_COLOR 424 #define TEX_NODE_SEPARATE_COLOR 425 /* 501-599 reserved. Use like this: TEX_NODE_PROC + TEX_CLOUDS, etc */ #define TEX_NODE_PROC 500 #define TEX_NODE_PROC_MAX 600 /** \} */ /* -------------------------------------------------------------------- */ /** \name Geometry Nodes * \{ */ #define GEO_NODE_TRIANGULATE 1000 #define GEO_NODE_TRANSFORM 1002 #define GEO_NODE_MESH_BOOLEAN 1003 #define GEO_NODE_OBJECT_INFO 1007 #define GEO_NODE_JOIN_GEOMETRY 1010 #define GEO_NODE_COLLECTION_INFO 1023 #define GEO_NODE_IS_VIEWPORT 1024 #define GEO_NODE_SUBDIVIDE_MESH 1029 #define GEO_NODE_MESH_PRIMITIVE_CUBE 1032 #define GEO_NODE_MESH_PRIMITIVE_CIRCLE 1033 #define GEO_NODE_MESH_PRIMITIVE_UV_SPHERE 1034 #define GEO_NODE_MESH_PRIMITIVE_CYLINDER 1035 #define GEO_NODE_MESH_PRIMITIVE_ICO_SPHERE 1036 #define GEO_NODE_MESH_PRIMITIVE_CONE 1037 #define GEO_NODE_MESH_PRIMITIVE_LINE 1038 #define GEO_NODE_MESH_PRIMITIVE_GRID 1039 #define GEO_NODE_BOUNDING_BOX 1042 #define GEO_NODE_SWITCH 1043 #define GEO_NODE_CURVE_TO_MESH 1045 #define GEO_NODE_RESAMPLE_CURVE 1047 #define GEO_NODE_INPUT_MATERIAL 1050 #define GEO_NODE_REPLACE_MATERIAL 1051 #define GEO_NODE_CURVE_LENGTH 1054 #define GEO_NODE_CONVEX_HULL 1056 #define GEO_NODE_SEPARATE_COMPONENTS 1059 #define GEO_NODE_CURVE_PRIMITIVE_STAR 1062 #define GEO_NODE_CURVE_PRIMITIVE_SPIRAL 1063 #define GEO_NODE_CURVE_PRIMITIVE_QUADRATIC_BEZIER 1064 #define GEO_NODE_CURVE_PRIMITIVE_BEZIER_SEGMENT 1065 #define GEO_NODE_CURVE_PRIMITIVE_CIRCLE 1066 #define GEO_NODE_VIEWER 1067 #define GEO_NODE_CURVE_PRIMITIVE_LINE 1068 #define GEO_NODE_CURVE_PRIMITIVE_QUADRILATERAL 1070 #define GEO_NODE_TRIM_CURVE 1071 #define GEO_NODE_FILL_CURVE 1075 #define GEO_NODE_INPUT_POSITION 1076 #define GEO_NODE_SET_POSITION 1077 #define GEO_NODE_INPUT_INDEX 1078 #define GEO_NODE_INPUT_NORMAL 1079 #define GEO_NODE_CAPTURE_ATTRIBUTE 1080 #define GEO_NODE_MATERIAL_SELECTION 1081 #define GEO_NODE_SET_MATERIAL 1082 #define GEO_NODE_REALIZE_INSTANCES 1083 #define GEO_NODE_ATTRIBUTE_STATISTIC 1084 #define GEO_NODE_SAMPLE_CURVE 1085 #define GEO_NODE_INPUT_TANGENT 1086 #define GEO_NODE_STRING_JOIN 1087 #define GEO_NODE_CURVE_SPLINE_PARAMETER 1088 #define GEO_NODE_FILLET_CURVE 1089 #define GEO_NODE_DISTRIBUTE_POINTS_ON_FACES 1090 #define GEO_NODE_STRING_TO_CURVES 1091 #define GEO_NODE_INSTANCE_ON_POINTS 1092 #define GEO_NODE_MESH_TO_POINTS 1093 #define GEO_NODE_POINTS_TO_VERTICES 1094 #define GEO_NODE_REVERSE_CURVE 1095 #define GEO_NODE_PROXIMITY 1096 #define GEO_NODE_SUBDIVIDE_CURVE 1097 #define GEO_NODE_INPUT_SPLINE_LENGTH 1098 #define GEO_NODE_CURVE_SPLINE_TYPE 1099 #define GEO_NODE_CURVE_SET_HANDLE_TYPE 1100 #define GEO_NODE_POINTS_TO_VOLUME 1101 #define GEO_NODE_CURVE_HANDLE_TYPE_SELECTION 1102 #define GEO_NODE_DELETE_GEOMETRY 1103 #define GEO_NODE_SEPARATE_GEOMETRY 1104 #define GEO_NODE_INPUT_RADIUS 1105 #define GEO_NODE_INPUT_CURVE_TILT 1106 #define GEO_NODE_INPUT_CURVE_HANDLES 1107 #define GEO_NODE_INPUT_SHADE_SMOOTH 1108 #define GEO_NODE_INPUT_SPLINE_RESOLUTION 1109 #define GEO_NODE_INPUT_SPLINE_CYCLIC 1110 #define GEO_NODE_SET_CURVE_RADIUS 1111 #define GEO_NODE_SET_CURVE_TILT 1112 #define GEO_NODE_SET_CURVE_HANDLES 1113 #define GEO_NODE_SET_SHADE_SMOOTH 1114 #define GEO_NODE_SET_SPLINE_RESOLUTION 1115 #define GEO_NODE_SET_SPLINE_CYCLIC 1116 #define GEO_NODE_SET_POINT_RADIUS 1117 #define GEO_NODE_INPUT_MATERIAL_INDEX 1118 #define GEO_NODE_SET_MATERIAL_INDEX 1119 #define GEO_NODE_TRANSLATE_INSTANCES 1120 #define GEO_NODE_SCALE_INSTANCES 1121 #define GEO_NODE_ROTATE_INSTANCES 1122 #define GEO_NODE_SPLIT_EDGES 1123 #define GEO_NODE_MESH_TO_CURVE 1124 #define GEO_NODE_TRANSFER_ATTRIBUTE 1125 #define GEO_NODE_SUBDIVISION_SURFACE 1126 #define GEO_NODE_CURVE_ENDPOINT_SELECTION 1127 #define GEO_NODE_RAYCAST 1128 #define GEO_NODE_CURVE_TO_POINTS 1130 #define GEO_NODE_INSTANCES_TO_POINTS 1131 #define GEO_NODE_IMAGE_TEXTURE 1132 #define GEO_NODE_VOLUME_TO_MESH 1133 #define GEO_NODE_INPUT_ID 1134 #define GEO_NODE_SET_ID 1135 #define GEO_NODE_ATTRIBUTE_DOMAIN_SIZE 1136 #define GEO_NODE_DUAL_MESH 1137 #define GEO_NODE_INPUT_MESH_EDGE_VERTICES 1138 #define GEO_NODE_INPUT_MESH_FACE_AREA 1139 #define GEO_NODE_INPUT_MESH_FACE_NEIGHBORS 1140 #define GEO_NODE_INPUT_MESH_VERTEX_NEIGHBORS 1141 #define GEO_NODE_GEOMETRY_TO_INSTANCE 1142 #define GEO_NODE_INPUT_MESH_EDGE_NEIGHBORS 1143 #define GEO_NODE_INPUT_MESH_ISLAND 1144 #define GEO_NODE_INPUT_SCENE_TIME 1145 #define GEO_NODE_ACCUMULATE_FIELD 1146 #define GEO_NODE_INPUT_MESH_EDGE_ANGLE 1147 #define GEO_NODE_FIELD_AT_INDEX 1148 #define GEO_NODE_CURVE_PRIMITIVE_ARC 1149 #define GEO_NODE_FLIP_FACES 1150 #define GEO_NODE_SCALE_ELEMENTS 1151 #define GEO_NODE_EXTRUDE_MESH 1152 #define GEO_NODE_MERGE_BY_DISTANCE 1153 #define GEO_NODE_DUPLICATE_ELEMENTS 1154 #define GEO_NODE_INPUT_MESH_FACE_IS_PLANAR 1155 #define GEO_NODE_STORE_NAMED_ATTRIBUTE 1156 #define GEO_NODE_INPUT_NAMED_ATTRIBUTE 1157 #define GEO_NODE_REMOVE_ATTRIBUTE 1158 #define GEO_NODE_INPUT_INSTANCE_ROTATION 1159 #define GEO_NODE_INPUT_INSTANCE_SCALE 1160 #define GEO_NODE_VOLUME_CUBE 1161 #define GEO_NODE_POINTS 1162 #define GEO_NODE_FIELD_ON_DOMAIN 1163 #define GEO_NODE_MESH_TO_VOLUME 1164 #define GEO_NODE_UV_UNWRAP 1165 #define GEO_NODE_UV_PACK_ISLANDS 1166 +#define GEO_NODE_DISTRIBUTE_POINTS_IN_VOLUME 1167 /** \} */ /* -------------------------------------------------------------------- */ /** \name Function Nodes * \{ */ #define FN_NODE_BOOLEAN_MATH 1200 #define FN_NODE_COMPARE 1202 #define FN_NODE_LEGACY_RANDOM_FLOAT 1206 #define FN_NODE_INPUT_VECTOR 1207 #define FN_NODE_INPUT_STRING 1208 #define FN_NODE_FLOAT_TO_INT 1209 #define FN_NODE_VALUE_TO_STRING 1210 #define FN_NODE_STRING_LENGTH 1211 #define FN_NODE_SLICE_STRING 1212 #define FN_NODE_INPUT_SPECIAL_CHARACTERS 1213 #define FN_NODE_RANDOM_VALUE 1214 #define FN_NODE_ROTATE_EULER 1215 #define FN_NODE_ALIGN_EULER_TO_VECTOR 1216 #define FN_NODE_INPUT_COLOR 1217 #define FN_NODE_REPLACE_STRING 1218 #define FN_NODE_INPUT_BOOL 1219 #define FN_NODE_INPUT_INT 1220 #define FN_NODE_SEPARATE_COLOR 1221 #define FN_NODE_COMBINE_COLOR 1222 /** \} */ void BKE_node_system_init(void); void BKE_node_system_exit(void); extern struct bNodeType NodeTypeUndefined; extern struct bNodeSocketType NodeSocketTypeUndefined; #ifdef __cplusplus } #endif #ifdef __cplusplus namespace blender::bke { bNodeSocket *node_find_enabled_socket(bNode &node, eNodeSocketInOut in_out, StringRef name); bNodeSocket *node_find_enabled_input_socket(bNode &node, StringRef name); bNodeSocket *node_find_enabled_output_socket(bNode &node, StringRef name); } // namespace blender::bke #endif #define NODE_STORAGE_FUNCS(StorageT) \ [[maybe_unused]] static StorageT &node_storage(bNode &node) \ { \ return *static_cast(node.storage); \ } \ [[maybe_unused]] static const StorageT &node_storage(const bNode &node) \ { \ return *static_cast(node.storage); \ } diff --git a/source/blender/blenkernel/intern/node.cc b/source/blender/blenkernel/intern/node.cc index 5be912ffb2b..31680f070dc 100644 --- a/source/blender/blenkernel/intern/node.cc +++ b/source/blender/blenkernel/intern/node.cc @@ -3846,1175 +3846,1176 @@ void BKE_node_clipboard_add_node(bNode *node) node_info->library_name[0] = '\0'; } } else { node_info->id_name[0] = '\0'; node_info->library_name[0] = '\0'; } BLI_addtail(&node_clipboard.nodes_extra_info, node_info); /* end extra info */ #endif /* USE_NODE_CB_VALIDATE */ /* add node */ BLI_addtail(&node_clipboard.nodes, node); } void BKE_node_clipboard_add_link(bNodeLink *link) { BLI_addtail(&node_clipboard.links, link); } const ListBase *BKE_node_clipboard_get_nodes() { return &node_clipboard.nodes; } const ListBase *BKE_node_clipboard_get_links() { return &node_clipboard.links; } int BKE_node_clipboard_get_type() { return node_clipboard.type; } void BKE_node_clipboard_free() { BKE_node_clipboard_validate(); BKE_node_clipboard_clear(); } /* Node Instance Hash */ const bNodeInstanceKey NODE_INSTANCE_KEY_BASE = {5381}; const bNodeInstanceKey NODE_INSTANCE_KEY_NONE = {0}; /* Generate a hash key from ntree and node names * Uses the djb2 algorithm with xor by Bernstein: * http://www.cse.yorku.ca/~oz/hash.html */ static bNodeInstanceKey node_hash_int_str(bNodeInstanceKey hash, const char *str) { char c; while ((c = *str++)) { hash.value = ((hash.value << 5) + hash.value) ^ c; /* (hash * 33) ^ c */ } /* separator '\0' character, to avoid ambiguity from concatenated strings */ hash.value = (hash.value << 5) + hash.value; /* hash * 33 */ return hash; } bNodeInstanceKey BKE_node_instance_key(bNodeInstanceKey parent_key, const bNodeTree *ntree, const bNode *node) { bNodeInstanceKey key = node_hash_int_str(parent_key, ntree->id.name + 2); if (node) { key = node_hash_int_str(key, node->name); } return key; } static unsigned int node_instance_hash_key(const void *key) { return ((const bNodeInstanceKey *)key)->value; } static bool node_instance_hash_key_cmp(const void *a, const void *b) { unsigned int value_a = ((const bNodeInstanceKey *)a)->value; unsigned int value_b = ((const bNodeInstanceKey *)b)->value; return (value_a != value_b); } bNodeInstanceHash *BKE_node_instance_hash_new(const char *info) { bNodeInstanceHash *hash = (bNodeInstanceHash *)MEM_mallocN(sizeof(bNodeInstanceHash), info); hash->ghash = BLI_ghash_new( node_instance_hash_key, node_instance_hash_key_cmp, "node instance hash ghash"); return hash; } void BKE_node_instance_hash_free(bNodeInstanceHash *hash, bNodeInstanceValueFP valfreefp) { BLI_ghash_free(hash->ghash, nullptr, (GHashValFreeFP)valfreefp); MEM_freeN(hash); } void BKE_node_instance_hash_insert(bNodeInstanceHash *hash, bNodeInstanceKey key, void *value) { bNodeInstanceHashEntry *entry = (bNodeInstanceHashEntry *)value; entry->key = key; entry->tag = 0; BLI_ghash_insert(hash->ghash, &entry->key, value); } void *BKE_node_instance_hash_lookup(bNodeInstanceHash *hash, bNodeInstanceKey key) { return BLI_ghash_lookup(hash->ghash, &key); } int BKE_node_instance_hash_remove(bNodeInstanceHash *hash, bNodeInstanceKey key, bNodeInstanceValueFP valfreefp) { return BLI_ghash_remove(hash->ghash, &key, nullptr, (GHashValFreeFP)valfreefp); } void BKE_node_instance_hash_clear(bNodeInstanceHash *hash, bNodeInstanceValueFP valfreefp) { BLI_ghash_clear(hash->ghash, nullptr, (GHashValFreeFP)valfreefp); } void *BKE_node_instance_hash_pop(bNodeInstanceHash *hash, bNodeInstanceKey key) { return BLI_ghash_popkey(hash->ghash, &key, nullptr); } int BKE_node_instance_hash_haskey(bNodeInstanceHash *hash, bNodeInstanceKey key) { return BLI_ghash_haskey(hash->ghash, &key); } int BKE_node_instance_hash_size(bNodeInstanceHash *hash) { return BLI_ghash_len(hash->ghash); } void BKE_node_instance_hash_clear_tags(bNodeInstanceHash *hash) { bNodeInstanceHashIterator iter; NODE_INSTANCE_HASH_ITER (iter, hash) { bNodeInstanceHashEntry *value = (bNodeInstanceHashEntry *) BKE_node_instance_hash_iterator_get_value(&iter); value->tag = 0; } } void BKE_node_instance_hash_tag(bNodeInstanceHash *UNUSED(hash), void *value) { bNodeInstanceHashEntry *entry = (bNodeInstanceHashEntry *)value; entry->tag = 1; } bool BKE_node_instance_hash_tag_key(bNodeInstanceHash *hash, bNodeInstanceKey key) { bNodeInstanceHashEntry *entry = (bNodeInstanceHashEntry *)BKE_node_instance_hash_lookup(hash, key); if (entry) { entry->tag = 1; return true; } return false; } void BKE_node_instance_hash_remove_untagged(bNodeInstanceHash *hash, bNodeInstanceValueFP valfreefp) { /* NOTE: Hash must not be mutated during iterating! * Store tagged entries in a separate list and remove items afterward. */ bNodeInstanceKey *untagged = (bNodeInstanceKey *)MEM_mallocN( sizeof(bNodeInstanceKey) * BKE_node_instance_hash_size(hash), "temporary node instance key list"); bNodeInstanceHashIterator iter; int num_untagged = 0; NODE_INSTANCE_HASH_ITER (iter, hash) { bNodeInstanceHashEntry *value = (bNodeInstanceHashEntry *) BKE_node_instance_hash_iterator_get_value(&iter); if (!value->tag) { untagged[num_untagged++] = BKE_node_instance_hash_iterator_get_key(&iter); } } for (int i = 0; i < num_untagged; i++) { BKE_node_instance_hash_remove(hash, untagged[i], valfreefp); } MEM_freeN(untagged); } /* ************** dependency stuff *********** */ /* node is guaranteed to be not checked before */ static int node_get_deplist_recurs(bNodeTree *ntree, bNode *node, bNode ***nsort) { int level = 0xFFF; node->done = true; /* check linked nodes */ LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) { if (link->tonode == node) { bNode *fromnode = link->fromnode; if (fromnode->done == 0) { fromnode->level = node_get_deplist_recurs(ntree, fromnode, nsort); } if (fromnode->level <= level) { level = fromnode->level - 1; } } } /* check parent node */ if (node->parent) { if (node->parent->done == 0) { node->parent->level = node_get_deplist_recurs(ntree, node->parent, nsort); } if (node->parent->level <= level) { level = node->parent->level - 1; } } if (nsort) { **nsort = node; (*nsort)++; } return level; } void ntreeGetDependencyList(struct bNodeTree *ntree, struct bNode ***r_deplist, int *r_deplist_len) { *r_deplist_len = 0; /* first clear data */ LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { node->done = false; (*r_deplist_len)++; } if (*r_deplist_len == 0) { *r_deplist = nullptr; return; } bNode **nsort; nsort = *r_deplist = (bNode **)MEM_callocN((*r_deplist_len) * sizeof(bNode *), "sorted node array"); /* recursive check */ LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { if (node->done == 0) { node->level = node_get_deplist_recurs(ntree, node, &nsort); } } } /* only updates node->level for detecting cycles links */ void ntreeUpdateNodeLevels(bNodeTree *ntree) { /* first clear tag */ LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { node->done = false; } /* recursive check */ LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { if (node->done == 0) { node->level = node_get_deplist_recurs(ntree, node, nullptr); } } } void ntreeUpdateAllNew(Main *main) { Vector new_ntrees; /* Update all new node trees on file read or append, to add/remove sockets * in groups nodes if the group changed, and handle any update flags that * might have been set in file reading or versioning. */ FOREACH_NODETREE_BEGIN (main, ntree, owner_id) { if (owner_id->tag & LIB_TAG_NEW) { BKE_ntree_update_tag_all(ntree); } } FOREACH_NODETREE_END; BKE_ntree_update_main(main, nullptr); } void ntreeUpdateAllUsers(Main *main, ID *id) { if (id == nullptr) { return; } bool need_update = false; /* Update all users of ngroup, to add/remove sockets as needed. */ FOREACH_NODETREE_BEGIN (main, ntree, owner_id) { LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { if (node->id == id) { BKE_ntree_update_tag_node_property(ntree, node); need_update = true; } } } FOREACH_NODETREE_END; if (need_update) { BKE_ntree_update_main(main, nullptr); } } /* ************* node type access ********** */ void nodeLabel(const bNodeTree *ntree, const bNode *node, char *label, int maxlen) { label[0] = '\0'; if (node->label[0] != '\0') { BLI_strncpy(label, node->label, maxlen); } else if (node->typeinfo->labelfunc) { node->typeinfo->labelfunc(ntree, node, label, maxlen); } /* The previous methods (labelfunc) could not provide an adequate label for the node. */ if (label[0] == '\0') { /* Kind of hacky and weak... Ideally would be better to use RNA here. :| */ const char *tmp = CTX_IFACE_(BLT_I18NCONTEXT_ID_NODETREE, node->typeinfo->ui_name); if (tmp == node->typeinfo->ui_name) { tmp = IFACE_(node->typeinfo->ui_name); } BLI_strncpy(label, tmp, maxlen); } } const char *nodeSocketLabel(const bNodeSocket *sock) { return (sock->label[0] != '\0') ? sock->label : sock->name; } static void node_type_base_defaults(bNodeType *ntype) { /* default size values */ node_type_size_preset(ntype, NODE_SIZE_DEFAULT); ntype->height = 100; ntype->minheight = 30; ntype->maxheight = FLT_MAX; } /* allow this node for any tree type */ static bool node_poll_default(bNodeType *UNUSED(ntype), bNodeTree *UNUSED(ntree), const char **UNUSED(disabled_hint)) { return true; } /* use the basic poll function */ static bool node_poll_instance_default(bNode *node, bNodeTree *ntree, const char **disabled_hint) { return node->typeinfo->poll(node->typeinfo, ntree, disabled_hint); } void node_type_base(bNodeType *ntype, int type, const char *name, short nclass) { /* Use static type info header to map static int type to identifier string and RNA struct type. * Associate the RNA struct type with the bNodeType. * Dynamically registered nodes will create an RNA type at runtime * and call RNA_struct_blender_type_set, so this only needs to be done for old RNA types * created in makesrna, which can not be associated to a bNodeType immediately, * since bNodeTypes are registered afterward ... */ #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \ case ID: \ BLI_strncpy(ntype->idname, #Category #StructName, sizeof(ntype->idname)); \ ntype->rna_ext.srna = RNA_struct_find(#Category #StructName); \ BLI_assert(ntype->rna_ext.srna != nullptr); \ RNA_struct_blender_type_set(ntype->rna_ext.srna, ntype); \ break; switch (type) { #include "NOD_static_types.h" } /* make sure we have a valid type (everything registered) */ BLI_assert(ntype->idname[0] != '\0'); ntype->type = type; BLI_strncpy(ntype->ui_name, name, sizeof(ntype->ui_name)); ntype->nclass = nclass; node_type_base_defaults(ntype); ntype->poll = node_poll_default; ntype->poll_instance = node_poll_instance_default; } void node_type_base_custom(bNodeType *ntype, const char *idname, const char *name, short nclass) { BLI_strncpy(ntype->idname, idname, sizeof(ntype->idname)); ntype->type = NODE_CUSTOM; BLI_strncpy(ntype->ui_name, name, sizeof(ntype->ui_name)); ntype->nclass = nclass; node_type_base_defaults(ntype); } struct SocketTemplateIdentifierCallbackData { bNodeSocketTemplate *list; bNodeSocketTemplate *ntemp; }; static bool unique_socket_template_identifier_check(void *arg, const char *name) { SocketTemplateIdentifierCallbackData *data = (SocketTemplateIdentifierCallbackData *)arg; for (bNodeSocketTemplate *ntemp = data->list; ntemp->type >= 0; ntemp++) { if (ntemp != data->ntemp) { if (STREQ(ntemp->identifier, name)) { return true; } } } return false; } static void unique_socket_template_identifier(bNodeSocketTemplate *list, bNodeSocketTemplate *ntemp, const char defname[], char delim) { SocketTemplateIdentifierCallbackData data; data.list = list; data.ntemp = ntemp; BLI_uniquename_cb(unique_socket_template_identifier_check, &data, defname, delim, ntemp->identifier, sizeof(ntemp->identifier)); } void node_type_socket_templates(struct bNodeType *ntype, struct bNodeSocketTemplate *inputs, struct bNodeSocketTemplate *outputs) { ntype->inputs = inputs; ntype->outputs = outputs; /* automatically generate unique identifiers */ if (inputs) { /* clear identifier strings (uninitialized memory) */ for (bNodeSocketTemplate *ntemp = inputs; ntemp->type >= 0; ntemp++) { ntemp->identifier[0] = '\0'; } for (bNodeSocketTemplate *ntemp = inputs; ntemp->type >= 0; ntemp++) { BLI_strncpy(ntemp->identifier, ntemp->name, sizeof(ntemp->identifier)); unique_socket_template_identifier(inputs, ntemp, ntemp->identifier, '_'); } } if (outputs) { /* clear identifier strings (uninitialized memory) */ for (bNodeSocketTemplate *ntemp = outputs; ntemp->type >= 0; ntemp++) { ntemp->identifier[0] = '\0'; } for (bNodeSocketTemplate *ntemp = outputs; ntemp->type >= 0; ntemp++) { BLI_strncpy(ntemp->identifier, ntemp->name, sizeof(ntemp->identifier)); unique_socket_template_identifier(outputs, ntemp, ntemp->identifier, '_'); } } } void node_type_init(struct bNodeType *ntype, void (*initfunc)(struct bNodeTree *ntree, struct bNode *node)) { ntype->initfunc = initfunc; } void node_type_size(struct bNodeType *ntype, int width, int minwidth, int maxwidth) { ntype->width = width; ntype->minwidth = minwidth; if (maxwidth <= minwidth) { ntype->maxwidth = FLT_MAX; } else { ntype->maxwidth = maxwidth; } } void node_type_size_preset(struct bNodeType *ntype, eNodeSizePreset size) { switch (size) { case NODE_SIZE_DEFAULT: node_type_size(ntype, 140, 100, NODE_DEFAULT_MAX_WIDTH); break; case NODE_SIZE_SMALL: node_type_size(ntype, 100, 80, NODE_DEFAULT_MAX_WIDTH); break; case NODE_SIZE_MIDDLE: node_type_size(ntype, 150, 120, NODE_DEFAULT_MAX_WIDTH); break; case NODE_SIZE_LARGE: node_type_size(ntype, 240, 140, NODE_DEFAULT_MAX_WIDTH); break; } } void node_type_storage(bNodeType *ntype, const char *storagename, void (*freefunc)(struct bNode *node), void (*copyfunc)(struct bNodeTree *dest_ntree, struct bNode *dest_node, const struct bNode *src_node)) { if (storagename) { BLI_strncpy(ntype->storagename, storagename, sizeof(ntype->storagename)); } else { ntype->storagename[0] = '\0'; } ntype->copyfunc = copyfunc; ntype->freefunc = freefunc; } void node_type_update(struct bNodeType *ntype, void (*updatefunc)(struct bNodeTree *ntree, struct bNode *node)) { ntype->updatefunc = updatefunc; } void node_type_group_update(struct bNodeType *ntype, void (*group_update_func)(struct bNodeTree *ntree, struct bNode *node)) { ntype->group_update_func = group_update_func; } void node_type_exec(struct bNodeType *ntype, NodeInitExecFunction init_exec_fn, NodeFreeExecFunction free_exec_fn, NodeExecFunction exec_fn) { ntype->init_exec_fn = init_exec_fn; ntype->free_exec_fn = free_exec_fn; ntype->exec_fn = exec_fn; } void node_type_gpu(struct bNodeType *ntype, NodeGPUExecFunction gpu_fn) { ntype->gpu_fn = gpu_fn; } /* callbacks for undefined types */ static bool node_undefined_poll(bNodeType *UNUSED(ntype), bNodeTree *UNUSED(nodetree), const char **UNUSED(r_disabled_hint)) { /* this type can not be added deliberately, it's just a placeholder */ return false; } /* register fallback types used for undefined tree, nodes, sockets */ static void register_undefined_types() { /* NOTE: these types are not registered in the type hashes, * they are just used as placeholders in case the actual types are not registered. */ NodeTreeTypeUndefined.type = NTREE_UNDEFINED; strcpy(NodeTreeTypeUndefined.idname, "NodeTreeUndefined"); strcpy(NodeTreeTypeUndefined.ui_name, N_("Undefined")); strcpy(NodeTreeTypeUndefined.ui_description, N_("Undefined Node Tree Type")); node_type_base_custom(&NodeTypeUndefined, "NodeUndefined", "Undefined", 0); NodeTypeUndefined.poll = node_undefined_poll; BLI_strncpy(NodeSocketTypeUndefined.idname, "NodeSocketUndefined", sizeof(NodeSocketTypeUndefined.idname)); /* extra type info for standard socket types */ NodeSocketTypeUndefined.type = SOCK_CUSTOM; NodeSocketTypeUndefined.subtype = PROP_NONE; NodeSocketTypeUndefined.use_link_limits_of_type = true; NodeSocketTypeUndefined.input_link_limit = 0xFFF; NodeSocketTypeUndefined.output_link_limit = 0xFFF; } static void registerCompositNodes() { register_node_type_cmp_group(); register_node_type_cmp_rlayers(); register_node_type_cmp_image(); register_node_type_cmp_texture(); register_node_type_cmp_value(); register_node_type_cmp_rgb(); register_node_type_cmp_curve_time(); register_node_type_cmp_scene_time(); register_node_type_cmp_movieclip(); register_node_type_cmp_composite(); register_node_type_cmp_viewer(); register_node_type_cmp_splitviewer(); register_node_type_cmp_output_file(); register_node_type_cmp_view_levels(); register_node_type_cmp_curve_rgb(); register_node_type_cmp_mix_rgb(); register_node_type_cmp_hue_sat(); register_node_type_cmp_brightcontrast(); register_node_type_cmp_gamma(); register_node_type_cmp_exposure(); register_node_type_cmp_invert(); register_node_type_cmp_alphaover(); register_node_type_cmp_zcombine(); register_node_type_cmp_colorbalance(); register_node_type_cmp_huecorrect(); register_node_type_cmp_normal(); register_node_type_cmp_curve_vec(); register_node_type_cmp_map_value(); register_node_type_cmp_map_range(); register_node_type_cmp_normalize(); register_node_type_cmp_filter(); register_node_type_cmp_blur(); register_node_type_cmp_dblur(); register_node_type_cmp_bilateralblur(); register_node_type_cmp_vecblur(); register_node_type_cmp_dilateerode(); register_node_type_cmp_inpaint(); register_node_type_cmp_despeckle(); register_node_type_cmp_defocus(); register_node_type_cmp_posterize(); register_node_type_cmp_sunbeams(); register_node_type_cmp_denoise(); register_node_type_cmp_antialiasing(); register_node_type_cmp_convert_color_space(); register_node_type_cmp_valtorgb(); register_node_type_cmp_rgbtobw(); register_node_type_cmp_setalpha(); register_node_type_cmp_idmask(); register_node_type_cmp_math(); register_node_type_cmp_seprgba(); register_node_type_cmp_combrgba(); register_node_type_cmp_sephsva(); register_node_type_cmp_combhsva(); register_node_type_cmp_sepyuva(); register_node_type_cmp_combyuva(); register_node_type_cmp_sepycca(); register_node_type_cmp_combycca(); register_node_type_cmp_premulkey(); register_node_type_cmp_separate_xyz(); register_node_type_cmp_combine_xyz(); register_node_type_cmp_separate_color(); register_node_type_cmp_combine_color(); register_node_type_cmp_diff_matte(); register_node_type_cmp_distance_matte(); register_node_type_cmp_chroma_matte(); register_node_type_cmp_color_matte(); register_node_type_cmp_channel_matte(); register_node_type_cmp_color_spill(); register_node_type_cmp_luma_matte(); register_node_type_cmp_doubleedgemask(); register_node_type_cmp_keyingscreen(); register_node_type_cmp_keying(); register_node_type_cmp_cryptomatte(); register_node_type_cmp_cryptomatte_legacy(); register_node_type_cmp_translate(); register_node_type_cmp_rotate(); register_node_type_cmp_scale(); register_node_type_cmp_flip(); register_node_type_cmp_crop(); register_node_type_cmp_displace(); register_node_type_cmp_mapuv(); register_node_type_cmp_glare(); register_node_type_cmp_tonemap(); register_node_type_cmp_lensdist(); register_node_type_cmp_transform(); register_node_type_cmp_stabilize2d(); register_node_type_cmp_moviedistortion(); register_node_type_cmp_colorcorrection(); register_node_type_cmp_boxmask(); register_node_type_cmp_ellipsemask(); register_node_type_cmp_bokehimage(); register_node_type_cmp_bokehblur(); register_node_type_cmp_switch(); register_node_type_cmp_switch_view(); register_node_type_cmp_pixelate(); register_node_type_cmp_mask(); register_node_type_cmp_trackpos(); register_node_type_cmp_planetrackdeform(); register_node_type_cmp_cornerpin(); } static void registerShaderNodes() { register_node_type_sh_group(); register_node_type_sh_camera(); register_node_type_sh_gamma(); register_node_type_sh_brightcontrast(); register_node_type_sh_value(); register_node_type_sh_rgb(); register_node_type_sh_wireframe(); register_node_type_sh_wavelength(); register_node_type_sh_blackbody(); register_node_type_sh_mix_rgb(); register_node_type_sh_valtorgb(); register_node_type_sh_rgbtobw(); register_node_type_sh_shadertorgb(); register_node_type_sh_normal(); register_node_type_sh_mapping(); register_node_type_sh_curve_float(); register_node_type_sh_curve_vec(); register_node_type_sh_curve_rgb(); register_node_type_sh_map_range(); register_node_type_sh_clamp(); register_node_type_sh_math(); register_node_type_sh_vect_math(); register_node_type_sh_vector_rotate(); register_node_type_sh_vect_transform(); register_node_type_sh_squeeze(); register_node_type_sh_invert(); register_node_type_sh_sepcolor(); register_node_type_sh_combcolor(); register_node_type_sh_seprgb(); register_node_type_sh_combrgb(); register_node_type_sh_sephsv(); register_node_type_sh_combhsv(); register_node_type_sh_sepxyz(); register_node_type_sh_combxyz(); register_node_type_sh_hue_sat(); register_node_type_sh_attribute(); register_node_type_sh_bevel(); register_node_type_sh_displacement(); register_node_type_sh_vector_displacement(); register_node_type_sh_geometry(); register_node_type_sh_light_path(); register_node_type_sh_light_falloff(); register_node_type_sh_object_info(); register_node_type_sh_fresnel(); register_node_type_sh_layer_weight(); register_node_type_sh_tex_coord(); register_node_type_sh_particle_info(); register_node_type_sh_bump(); register_node_type_sh_vertex_color(); register_node_type_sh_background(); register_node_type_sh_bsdf_anisotropic(); register_node_type_sh_bsdf_diffuse(); register_node_type_sh_bsdf_principled(); register_node_type_sh_bsdf_glossy(); register_node_type_sh_bsdf_glass(); register_node_type_sh_bsdf_translucent(); register_node_type_sh_bsdf_transparent(); register_node_type_sh_bsdf_velvet(); register_node_type_sh_bsdf_toon(); register_node_type_sh_bsdf_hair(); register_node_type_sh_bsdf_hair_principled(); register_node_type_sh_emission(); register_node_type_sh_holdout(); register_node_type_sh_volume_absorption(); register_node_type_sh_volume_scatter(); register_node_type_sh_volume_principled(); register_node_type_sh_subsurface_scattering(); register_node_type_sh_mix_shader(); register_node_type_sh_add_shader(); register_node_type_sh_uvmap(); register_node_type_sh_uvalongstroke(); register_node_type_sh_eevee_specular(); register_node_type_sh_output_light(); register_node_type_sh_output_material(); register_node_type_sh_output_world(); register_node_type_sh_output_linestyle(); register_node_type_sh_output_aov(); register_node_type_sh_tex_image(); register_node_type_sh_tex_environment(); register_node_type_sh_tex_sky(); register_node_type_sh_tex_noise(); register_node_type_sh_tex_wave(); register_node_type_sh_tex_voronoi(); register_node_type_sh_tex_musgrave(); register_node_type_sh_tex_gradient(); register_node_type_sh_tex_magic(); register_node_type_sh_tex_checker(); register_node_type_sh_tex_brick(); register_node_type_sh_tex_pointdensity(); register_node_type_sh_tex_ies(); register_node_type_sh_tex_white_noise(); } static void registerTextureNodes() { register_node_type_tex_group(); register_node_type_tex_math(); register_node_type_tex_mix_rgb(); register_node_type_tex_valtorgb(); register_node_type_tex_rgbtobw(); register_node_type_tex_valtonor(); register_node_type_tex_curve_rgb(); register_node_type_tex_curve_time(); register_node_type_tex_invert(); register_node_type_tex_hue_sat(); register_node_type_tex_coord(); register_node_type_tex_distance(); register_node_type_tex_compose(); register_node_type_tex_decompose(); register_node_type_tex_combine_color(); register_node_type_tex_separate_color(); register_node_type_tex_output(); register_node_type_tex_viewer(); register_node_type_sh_script(); register_node_type_sh_tangent(); register_node_type_sh_normal_map(); register_node_type_sh_hair_info(); register_node_type_sh_point_info(); register_node_type_sh_volume_info(); register_node_type_tex_checker(); register_node_type_tex_texture(); register_node_type_tex_bricks(); register_node_type_tex_image(); register_node_type_sh_bsdf_refraction(); register_node_type_sh_ambient_occlusion(); register_node_type_tex_rotate(); register_node_type_tex_translate(); register_node_type_tex_scale(); register_node_type_tex_at(); register_node_type_tex_proc_voronoi(); register_node_type_tex_proc_blend(); register_node_type_tex_proc_magic(); register_node_type_tex_proc_marble(); register_node_type_tex_proc_clouds(); register_node_type_tex_proc_wood(); register_node_type_tex_proc_musgrave(); register_node_type_tex_proc_noise(); register_node_type_tex_proc_stucci(); register_node_type_tex_proc_distnoise(); } static void registerGeometryNodes() { register_node_type_geo_group(); register_node_type_geo_accumulate_field(); register_node_type_geo_attribute_capture(); register_node_type_geo_attribute_domain_size(); register_node_type_geo_attribute_statistic(); register_node_type_geo_boolean(); register_node_type_geo_bounding_box(); register_node_type_geo_collection_info(); register_node_type_geo_convex_hull(); register_node_type_geo_curve_endpoint_selection(); register_node_type_geo_curve_fill(); register_node_type_geo_curve_fillet(); register_node_type_geo_curve_handle_type_selection(); register_node_type_geo_curve_length(); register_node_type_geo_curve_primitive_arc(); register_node_type_geo_curve_primitive_bezier_segment(); register_node_type_geo_curve_primitive_circle(); register_node_type_geo_curve_primitive_line(); register_node_type_geo_curve_primitive_quadratic_bezier(); register_node_type_geo_curve_primitive_quadrilateral(); register_node_type_geo_curve_primitive_spiral(); register_node_type_geo_curve_primitive_star(); register_node_type_geo_curve_resample(); register_node_type_geo_curve_reverse(); register_node_type_geo_curve_sample(); register_node_type_geo_curve_set_handle_type(); register_node_type_geo_curve_spline_parameter(); register_node_type_geo_curve_spline_type(); register_node_type_geo_curve_subdivide(); register_node_type_geo_curve_to_mesh(); register_node_type_geo_curve_to_points(); register_node_type_geo_curve_trim(); register_node_type_geo_delete_geometry(); register_node_type_geo_duplicate_elements(); register_node_type_geo_distribute_points_on_faces(); register_node_type_geo_dual_mesh(); register_node_type_geo_edge_split(); register_node_type_geo_extrude_mesh(); register_node_type_geo_field_at_index(); register_node_type_geo_field_on_domain(); register_node_type_geo_flip_faces(); register_node_type_geo_geometry_to_instance(); register_node_type_geo_image_texture(); register_node_type_geo_input_named_attribute(); register_node_type_geo_input_curve_handles(); register_node_type_geo_input_curve_tilt(); register_node_type_geo_input_id(); register_node_type_geo_input_index(); register_node_type_geo_input_instance_rotation(); register_node_type_geo_input_instance_scale(); register_node_type_geo_input_material_index(); register_node_type_geo_input_material(); register_node_type_geo_input_mesh_edge_angle(); register_node_type_geo_input_mesh_edge_neighbors(); register_node_type_geo_input_mesh_edge_vertices(); register_node_type_geo_input_mesh_face_area(); register_node_type_geo_input_mesh_face_is_planar(); register_node_type_geo_input_mesh_face_neighbors(); register_node_type_geo_input_mesh_island(); register_node_type_geo_input_mesh_vertex_neighbors(); register_node_type_geo_input_normal(); register_node_type_geo_input_position(); register_node_type_geo_input_radius(); register_node_type_geo_input_scene_time(); register_node_type_geo_input_shade_smooth(); register_node_type_geo_input_spline_cyclic(); register_node_type_geo_input_spline_length(); register_node_type_geo_input_spline_resolution(); register_node_type_geo_input_tangent(); register_node_type_geo_instance_on_points(); register_node_type_geo_instances_to_points(); register_node_type_geo_is_viewport(); register_node_type_geo_join_geometry(); register_node_type_geo_material_replace(); register_node_type_geo_material_selection(); register_node_type_geo_merge_by_distance(); register_node_type_geo_mesh_primitive_circle(); register_node_type_geo_mesh_primitive_cone(); register_node_type_geo_mesh_primitive_cube(); register_node_type_geo_mesh_primitive_cylinder(); register_node_type_geo_mesh_primitive_grid(); register_node_type_geo_mesh_primitive_ico_sphere(); register_node_type_geo_mesh_primitive_line(); register_node_type_geo_mesh_primitive_uv_sphere(); register_node_type_geo_mesh_subdivide(); register_node_type_geo_mesh_to_curve(); register_node_type_geo_mesh_to_points(); register_node_type_geo_mesh_to_volume(); register_node_type_geo_object_info(); register_node_type_geo_points(); register_node_type_geo_points_to_vertices(); register_node_type_geo_points_to_volume(); register_node_type_geo_proximity(); register_node_type_geo_raycast(); register_node_type_geo_realize_instances(); register_node_type_geo_remove_attribute(); register_node_type_geo_rotate_instances(); register_node_type_geo_scale_elements(); register_node_type_geo_scale_instances(); register_node_type_geo_separate_components(); register_node_type_geo_separate_geometry(); register_node_type_geo_set_curve_handles(); register_node_type_geo_set_curve_radius(); register_node_type_geo_set_curve_tilt(); register_node_type_geo_set_id(); register_node_type_geo_set_material_index(); register_node_type_geo_set_material(); register_node_type_geo_set_point_radius(); register_node_type_geo_set_position(); register_node_type_geo_set_shade_smooth(); register_node_type_geo_set_spline_cyclic(); register_node_type_geo_set_spline_resolution(); register_node_type_geo_store_named_attribute(); register_node_type_geo_string_join(); register_node_type_geo_string_to_curves(); register_node_type_geo_subdivision_surface(); register_node_type_geo_switch(); register_node_type_geo_transfer_attribute(); register_node_type_geo_transform(); register_node_type_geo_translate_instances(); register_node_type_geo_triangulate(); register_node_type_geo_viewer(); register_node_type_geo_volume_cube(); register_node_type_geo_volume_to_mesh(); register_node_type_geo_uv_pack_islands(); register_node_type_geo_uv_unwrap(); + register_node_type_geo_distribute_points_in_volume(); } static void registerFunctionNodes() { register_node_type_fn_align_euler_to_vector(); register_node_type_fn_boolean_math(); register_node_type_fn_combine_color(); register_node_type_fn_compare(); register_node_type_fn_float_to_int(); register_node_type_fn_input_bool(); register_node_type_fn_input_color(); register_node_type_fn_input_int(); register_node_type_fn_input_special_characters(); register_node_type_fn_input_string(); register_node_type_fn_input_vector(); register_node_type_fn_random_value(); register_node_type_fn_replace_string(); register_node_type_fn_rotate_euler(); register_node_type_fn_separate_color(); register_node_type_fn_slice_string(); register_node_type_fn_string_length(); register_node_type_fn_value_to_string(); } void BKE_node_system_init() { nodetreetypes_hash = BLI_ghash_str_new("nodetreetypes_hash gh"); nodetypes_hash = BLI_ghash_str_new("nodetypes_hash gh"); nodesockettypes_hash = BLI_ghash_str_new("nodesockettypes_hash gh"); register_undefined_types(); register_standard_node_socket_types(); register_node_tree_type_cmp(); register_node_tree_type_sh(); register_node_tree_type_tex(); register_node_tree_type_geo(); register_node_type_frame(); register_node_type_reroute(); register_node_type_group_input(); register_node_type_group_output(); registerCompositNodes(); registerShaderNodes(); registerTextureNodes(); registerGeometryNodes(); registerFunctionNodes(); } void BKE_node_system_exit() { if (nodetypes_hash) { NODE_TYPES_BEGIN (nt) { if (nt->rna_ext.free) { nt->rna_ext.free(nt->rna_ext.data); } } NODE_TYPES_END; BLI_ghash_free(nodetypes_hash, nullptr, node_free_type); nodetypes_hash = nullptr; } if (nodesockettypes_hash) { NODE_SOCKET_TYPES_BEGIN (st) { if (st->ext_socket.free) { st->ext_socket.free(st->ext_socket.data); } if (st->ext_interface.free) { st->ext_interface.free(st->ext_interface.data); } } NODE_SOCKET_TYPES_END; BLI_ghash_free(nodesockettypes_hash, nullptr, node_free_socket_type); nodesockettypes_hash = nullptr; } if (nodetreetypes_hash) { NODE_TREE_TYPES_BEGIN (nt) { if (nt->rna_ext.free) { nt->rna_ext.free(nt->rna_ext.data); } } NODE_TREE_TYPES_END; BLI_ghash_free(nodetreetypes_hash, nullptr, ntree_free_type); nodetreetypes_hash = nullptr; } } /* -------------------------------------------------------------------- */ /* NodeTree Iterator Helpers (FOREACH_NODETREE_BEGIN) */ void BKE_node_tree_iter_init(struct NodeTreeIterStore *ntreeiter, struct Main *bmain) { ntreeiter->ngroup = (bNodeTree *)bmain->nodetrees.first; ntreeiter->scene = (Scene *)bmain->scenes.first; ntreeiter->mat = (Material *)bmain->materials.first; ntreeiter->tex = (Tex *)bmain->textures.first; ntreeiter->light = (Light *)bmain->lights.first; ntreeiter->world = (World *)bmain->worlds.first; ntreeiter->linestyle = (FreestyleLineStyle *)bmain->linestyles.first; ntreeiter->simulation = (Simulation *)bmain->simulations.first; } bool BKE_node_tree_iter_step(struct NodeTreeIterStore *ntreeiter, bNodeTree **r_nodetree, struct ID **r_id) { if (ntreeiter->ngroup) { *r_nodetree = (bNodeTree *)ntreeiter->ngroup; *r_id = (ID *)ntreeiter->ngroup; ntreeiter->ngroup = (bNodeTree *)ntreeiter->ngroup->id.next; } else if (ntreeiter->scene) { *r_nodetree = (bNodeTree *)ntreeiter->scene->nodetree; *r_id = (ID *)ntreeiter->scene; ntreeiter->scene = (Scene *)ntreeiter->scene->id.next; } else if (ntreeiter->mat) { *r_nodetree = (bNodeTree *)ntreeiter->mat->nodetree; *r_id = (ID *)ntreeiter->mat; ntreeiter->mat = (Material *)ntreeiter->mat->id.next; } else if (ntreeiter->tex) { *r_nodetree = (bNodeTree *)ntreeiter->tex->nodetree; *r_id = (ID *)ntreeiter->tex; ntreeiter->tex = (Tex *)ntreeiter->tex->id.next; } else if (ntreeiter->light) { *r_nodetree = (bNodeTree *)ntreeiter->light->nodetree; *r_id = (ID *)ntreeiter->light; ntreeiter->light = (Light *)ntreeiter->light->id.next; } else if (ntreeiter->world) { *r_nodetree = (bNodeTree *)ntreeiter->world->nodetree; *r_id = (ID *)ntreeiter->world; ntreeiter->world = (World *)ntreeiter->world->id.next; } else if (ntreeiter->linestyle) { *r_nodetree = (bNodeTree *)ntreeiter->linestyle->nodetree; *r_id = (ID *)ntreeiter->linestyle; ntreeiter->linestyle = (FreestyleLineStyle *)ntreeiter->linestyle->id.next; } else if (ntreeiter->simulation) { *r_nodetree = (bNodeTree *)ntreeiter->simulation->nodetree; *r_id = (ID *)ntreeiter->simulation; ntreeiter->simulation = (Simulation *)ntreeiter->simulation->id.next; } else { return false; } return true; } /* -------------------------------------------------------------------- */ /* NodeTree kernel functions */ void BKE_nodetree_remove_layer_n(bNodeTree *ntree, Scene *scene, const int layer_index) { BLI_assert(layer_index != -1); LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { if (node->type == CMP_NODE_R_LAYERS && (Scene *)node->id == scene) { if (node->custom1 == layer_index) { node->custom1 = 0; } else if (node->custom1 > layer_index) { node->custom1--; } } } } diff --git a/source/blender/makesdna/DNA_node_types.h b/source/blender/makesdna/DNA_node_types.h index 76d8207eead..9c78f289baf 100644 --- a/source/blender/makesdna/DNA_node_types.h +++ b/source/blender/makesdna/DNA_node_types.h @@ -463,1683 +463,1693 @@ typedef struct bNodeTree { /** Grease pencil data. */ struct bGPdata *gpd; /** Node tree stores own offset for consistent editor view. */ float view_center[2]; ListBase nodes, links; int type; /** * Sockets in groups have unique identifiers, adding new sockets always * will increase this counter. */ int cur_index; int flag; /** Flag to prevent re-entrant update calls. */ short is_updating; /** Generic temporary flag for recursion check (DFS/BFS). */ short done; /** Specific node type this tree is used for. */ int nodetype DNA_DEPRECATED; /** Quality setting when editing. */ short edit_quality; /** Quality setting when rendering. */ short render_quality; /** Tile size for compositor engine. */ int chunksize; /** Execution mode to use for compositor engine. */ int execution_mode; rctf viewer_border; /* Lists of bNodeSocket to hold default values and own_index. * Warning! Don't make links to these sockets, input/output nodes are used for that. * These sockets are used only for generating external interfaces. */ ListBase inputs, outputs; /* Node preview hash table * Only available in base node trees (e.g. scene->node_tree) */ struct bNodeInstanceHash *previews; /* Defines the node tree instance to use for the "active" context, * in case multiple different editors are used and make context ambiguous. */ bNodeInstanceKey active_viewer_key; char _pad[4]; /** Execution data. * * XXX It would be preferable to completely move this data out of the underlying node tree, * so node tree execution could finally run independent of the tree itself. * This would allow node trees to be merely linked by other data (materials, textures, etc.), * as ID data is supposed to. * Execution data is generated from the tree once at execution start and can then be used * as long as necessary, even while the tree is being modified. */ struct bNodeTreeExec *execdata; /* Callbacks. */ void (*progress)(void *, float progress); /** \warning may be called by different threads */ void (*stats_draw)(void *, const char *str); int (*test_break)(void *); void (*update_draw)(void *); void *tbh, *prh, *sdh, *udh; /** Image representing what the node group does. */ struct PreviewImage *preview; bNodeTreeRuntimeHandle *runtime; } bNodeTree; /** #NodeTree.type, index */ #define NTREE_UNDEFINED -2 /* Represents #NodeTreeTypeUndefined type. */ #define NTREE_CUSTOM -1 /* for dynamically registered custom types */ #define NTREE_SHADER 0 #define NTREE_COMPOSIT 1 #define NTREE_TEXTURE 2 #define NTREE_GEOMETRY 3 /** #NodeTree.flag */ #define NTREE_DS_EXPAND (1 << 0) /* for animation editors */ #define NTREE_COM_OPENCL (1 << 1) /* use opencl */ #define NTREE_TWO_PASS (1 << 2) /* two pass */ #define NTREE_COM_GROUPNODE_BUFFER (1 << 3) /* use groupnode buffers */ #define NTREE_VIEWER_BORDER (1 << 4) /* use a border for viewer nodes */ /* NOTE: DEPRECATED, use (id->tag & LIB_TAG_LOCALIZED) instead. */ /* tree is localized copy, free when deleting node groups */ /* #define NTREE_IS_LOCALIZED (1 << 5) */ /* tree->execution_mode */ typedef enum eNodeTreeExecutionMode { NTREE_EXECUTION_MODE_TILED = 0, NTREE_EXECUTION_MODE_FULL_FRAME = 1, } eNodeTreeExecutionMode; typedef enum eNodeTreeRuntimeFlag { /** There is a node that references an image with animation. */ NTREE_RUNTIME_FLAG_HAS_IMAGE_ANIMATION = 1 << 0, /** There is a material output node in the group. */ NTREE_RUNTIME_FLAG_HAS_MATERIAL_OUTPUT = 1 << 1, } eNodeTreeRuntimeFlag; /* socket value structs for input buttons * DEPRECATED now using ID properties */ typedef struct bNodeSocketValueInt { /** RNA subtype. */ int subtype; int value; int min, max; } bNodeSocketValueInt; typedef struct bNodeSocketValueFloat { /** RNA subtype. */ int subtype; float value; float min, max; } bNodeSocketValueFloat; typedef struct bNodeSocketValueBoolean { char value; } bNodeSocketValueBoolean; typedef struct bNodeSocketValueVector { /** RNA subtype. */ int subtype; float value[3]; float min, max; } bNodeSocketValueVector; typedef struct bNodeSocketValueRGBA { float value[4]; } bNodeSocketValueRGBA; typedef struct bNodeSocketValueString { int subtype; char _pad[4]; /** 1024 = FILEMAX. */ char value[1024]; } bNodeSocketValueString; typedef struct bNodeSocketValueObject { struct Object *value; } bNodeSocketValueObject; typedef struct bNodeSocketValueImage { struct Image *value; } bNodeSocketValueImage; typedef struct bNodeSocketValueCollection { struct Collection *value; } bNodeSocketValueCollection; typedef struct bNodeSocketValueTexture { struct Tex *value; } bNodeSocketValueTexture; typedef struct bNodeSocketValueMaterial { struct Material *value; } bNodeSocketValueMaterial; /* Data structs, for `node->storage`. */ enum { CMP_NODE_MASKTYPE_ADD = 0, CMP_NODE_MASKTYPE_SUBTRACT = 1, CMP_NODE_MASKTYPE_MULTIPLY = 2, CMP_NODE_MASKTYPE_NOT = 3, }; enum { CMP_NODE_DILATEERODE_STEP = 0, CMP_NODE_DILATEERODE_DISTANCE_THRESH = 1, CMP_NODE_DILATEERODE_DISTANCE = 2, CMP_NODE_DILATEERODE_DISTANCE_FEATHER = 3, }; enum { CMP_NODE_INPAINT_SIMPLE = 0, }; enum { /* CMP_NODEFLAG_MASK_AA = (1 << 0), */ /* DEPRECATED */ CMP_NODEFLAG_MASK_NO_FEATHER = (1 << 1), CMP_NODEFLAG_MASK_MOTION_BLUR = (1 << 2), /* We may want multiple aspect options, exposed as an rna enum. */ CMP_NODEFLAG_MASK_FIXED = (1 << 8), CMP_NODEFLAG_MASK_FIXED_SCENE = (1 << 9), }; enum { CMP_NODEFLAG_BLUR_VARIABLE_SIZE = (1 << 0), CMP_NODEFLAG_BLUR_EXTEND_BOUNDS = (1 << 1), }; typedef struct NodeFrame { short flag; short label_size; } NodeFrame; /** \note This one has been replaced with #ImageUser, keep it for do_versions(). */ typedef struct NodeImageAnim { int frames DNA_DEPRECATED; int sfra DNA_DEPRECATED; int nr DNA_DEPRECATED; char cyclic DNA_DEPRECATED; char movie DNA_DEPRECATED; char _pad[2]; } NodeImageAnim; typedef struct ColorCorrectionData { float saturation; float contrast; float gamma; float gain; float lift; char _pad[4]; } ColorCorrectionData; typedef struct NodeColorCorrection { ColorCorrectionData master; ColorCorrectionData shadows; ColorCorrectionData midtones; ColorCorrectionData highlights; float startmidtones; float endmidtones; } NodeColorCorrection; typedef struct NodeBokehImage { float angle; int flaps; float rounding; float catadioptric; float lensshift; } NodeBokehImage; typedef struct NodeBoxMask { float x; float y; float rotation; float height; float width; char _pad[4]; } NodeBoxMask; typedef struct NodeEllipseMask { float x; float y; float rotation; float height; float width; char _pad[4]; } NodeEllipseMask; /** Layer info for image node outputs. */ typedef struct NodeImageLayer { /* index in the Image->layers->passes lists */ int pass_index DNA_DEPRECATED; /* render pass name */ /** Amount defined in IMB_openexr.h. */ char pass_name[64]; } NodeImageLayer; typedef struct NodeBlurData { short sizex, sizey; short samples, maxspeed, minspeed, relative, aspect; short curved; float fac, percentx, percenty; short filtertype; char bokeh, gamma; /** Needed for absolute/relative conversions. */ int image_in_width, image_in_height; } NodeBlurData; typedef struct NodeDBlurData { float center_x, center_y, distance, angle, spin, zoom; short iter; char wrap, _pad; } NodeDBlurData; typedef struct NodeBilateralBlurData { float sigma_color, sigma_space; short iter; char _pad[2]; } NodeBilateralBlurData; typedef struct NodeAntiAliasingData { float threshold; float contrast_limit; float corner_rounding; } NodeAntiAliasingData; /** \note Only for do-version code. */ typedef struct NodeHueSat { float hue, sat, val; } NodeHueSat; typedef struct NodeImageFile { /** 1024 = FILE_MAX. */ char name[1024]; struct ImageFormatData im_format; int sfra, efra; } NodeImageFile; /** * XXX: first struct fields should match #NodeImageFile to ensure forward compatibility. */ typedef struct NodeImageMultiFile { /** 1024 = FILE_MAX. */ char base_path[1024]; ImageFormatData format; /** XXX old frame rand values from NodeImageFile for forward compatibility. */ int sfra DNA_DEPRECATED, efra DNA_DEPRECATED; /** Selected input in details view list. */ int active_input; char _pad[4]; } NodeImageMultiFile; typedef struct NodeImageMultiFileSocket { /* single layer file output */ short use_render_format DNA_DEPRECATED; /** Use overall node image format. */ short use_node_format; char save_as_render; char _pad1[3]; /** 1024 = FILE_MAX. */ char path[1024]; ImageFormatData format; /* multilayer output */ /** EXR_TOT_MAXNAME-2 ('.' and channel char are appended). */ char layer[30]; char _pad2[2]; } NodeImageMultiFileSocket; typedef struct NodeChroma { float t1, t2, t3; float fsize, fstrength, falpha; float key[4]; short algorithm, channel; } NodeChroma; typedef struct NodeTwoXYs { short x1, x2, y1, y2; float fac_x1, fac_x2, fac_y1, fac_y2; } NodeTwoXYs; typedef struct NodeTwoFloats { float x, y; } NodeTwoFloats; typedef struct NodeVertexCol { char name[64]; } NodeVertexCol; typedef struct NodeCMPCombSepColor { /* CMPNodeCombSepColorMode */ uint8_t mode; uint8_t ycc_mode; } NodeCMPCombSepColor; /** Defocus blur node. */ typedef struct NodeDefocus { char bktype, _pad0, preview, gamco; short samples, no_zbuf; float fstop, maxblur, bthresh, scale; float rotation; char _pad1[4]; } NodeDefocus; typedef struct NodeScriptDict { /** For PyObject *dict. */ void *dict; /** For BPy_Node *node. */ void *node; } NodeScriptDict; /** glare node. */ typedef struct NodeGlare { char quality, type, iter; /* XXX angle is only kept for backward/forward compatibility, * was used for two different things, see T50736. */ char angle DNA_DEPRECATED, _pad0, size, star_45, streaks; float colmod, mix, threshold, fade; float angle_ofs; char _pad1[4]; } NodeGlare; /** Tonemap node. */ typedef struct NodeTonemap { float key, offset, gamma; float f, m, a, c; int type; } NodeTonemap; /** Lens distortion node. */ typedef struct NodeLensDist { short jit, proj, fit; char _pad[2]; } NodeLensDist; typedef struct NodeColorBalance { /* ASC CDL parameters */ float slope[3]; float offset[3]; float power[3]; float offset_basis; char _pad[4]; /* LGG parameters */ float lift[3]; float gamma[3]; float gain[3]; } NodeColorBalance; typedef struct NodeColorspill { short limchan, unspill; float limscale; float uspillr, uspillg, uspillb; } NodeColorspill; typedef struct NodeConvertColorSpace { char from_color_space[64]; char to_color_space[64]; } NodeConvertColorSpace; typedef struct NodeDilateErode { char falloff; } NodeDilateErode; typedef struct NodeMask { int size_x, size_y; } NodeMask; typedef struct NodeSetAlpha { char mode; } NodeSetAlpha; typedef struct NodeTexBase { TexMapping tex_mapping; ColorMapping color_mapping; } NodeTexBase; typedef struct NodeTexSky { NodeTexBase base; int sky_model; float sun_direction[3]; float turbidity; float ground_albedo; float sun_size; float sun_intensity; float sun_elevation; float sun_rotation; float altitude; float air_density; float dust_density; float ozone_density; char sun_disc; char _pad[7]; } NodeTexSky; typedef struct NodeTexImage { NodeTexBase base; ImageUser iuser; int color_space DNA_DEPRECATED; int projection; float projection_blend; int interpolation; int extension; char _pad[4]; } NodeTexImage; typedef struct NodeTexChecker { NodeTexBase base; } NodeTexChecker; typedef struct NodeTexBrick { NodeTexBase base; int offset_freq, squash_freq; float offset, squash; } NodeTexBrick; typedef struct NodeTexEnvironment { NodeTexBase base; ImageUser iuser; int color_space DNA_DEPRECATED; int projection; int interpolation; char _pad[4]; } NodeTexEnvironment; typedef struct NodeTexGradient { NodeTexBase base; int gradient_type; char _pad[4]; } NodeTexGradient; typedef struct NodeTexNoise { NodeTexBase base; int dimensions; char _pad[4]; } NodeTexNoise; typedef struct NodeTexVoronoi { NodeTexBase base; int dimensions; int feature; int distance; int coloring DNA_DEPRECATED; } NodeTexVoronoi; typedef struct NodeTexMusgrave { NodeTexBase base; int musgrave_type; int dimensions; } NodeTexMusgrave; typedef struct NodeTexWave { NodeTexBase base; int wave_type; int bands_direction; int rings_direction; int wave_profile; } NodeTexWave; typedef struct NodeTexMagic { NodeTexBase base; int depth; char _pad[4]; } NodeTexMagic; typedef struct NodeShaderAttribute { char name[64]; int type; char _pad[4]; } NodeShaderAttribute; typedef struct NodeShaderVectTransform { int type; int convert_from, convert_to; char _pad[4]; } NodeShaderVectTransform; typedef struct NodeShaderTexPointDensity { NodeTexBase base; short point_source; char _pad[2]; int particle_system; float radius; int resolution; short space; short interpolation; short color_source; short ob_color_source; /** Vertex attribute layer for color source, MAX_CUSTOMDATA_LAYER_NAME. */ char vertex_attribute_name[64]; /* Used at runtime only by sampling RNA API. */ PointDensity pd; int cached_resolution; char _pad2[4]; } NodeShaderTexPointDensity; typedef struct NodeShaderPrincipled { char use_subsurface_auto_radius; char _pad[3]; } NodeShaderPrincipled; /** TEX_output. */ typedef struct TexNodeOutput { char name[64]; } TexNodeOutput; typedef struct NodeKeyingScreenData { char tracking_object[64]; } NodeKeyingScreenData; typedef struct NodeKeyingData { float screen_balance; float despill_factor; float despill_balance; int edge_kernel_radius; float edge_kernel_tolerance; float clip_black, clip_white; int dilate_distance; int feather_distance; int feather_falloff; int blur_pre, blur_post; } NodeKeyingData; typedef struct NodeTrackPosData { char tracking_object[64]; char track_name[64]; } NodeTrackPosData; typedef struct NodeTranslateData { char wrap_axis; char relative; } NodeTranslateData; typedef struct NodePlaneTrackDeformData { char tracking_object[64]; char plane_track_name[64]; char flag; char motion_blur_samples; char _pad[2]; float motion_blur_shutter; } NodePlaneTrackDeformData; typedef struct NodeShaderScript { int mode; int flag; /** 1024 = FILE_MAX. */ char filepath[1024]; char bytecode_hash[64]; char *bytecode; } NodeShaderScript; typedef struct NodeShaderTangent { int direction_type; int axis; char uv_map[64]; } NodeShaderTangent; typedef struct NodeShaderNormalMap { int space; char uv_map[64]; } NodeShaderNormalMap; typedef struct NodeShaderUVMap { char uv_map[64]; } NodeShaderUVMap; typedef struct NodeShaderVertexColor { char layer_name[64]; } NodeShaderVertexColor; typedef struct NodeShaderTexIES { int mode; /** 1024 = FILE_MAX. */ char filepath[1024]; } NodeShaderTexIES; typedef struct NodeShaderOutputAOV { char name[64]; } NodeShaderOutputAOV; typedef struct NodeSunBeams { float source[2]; float ray_length; } NodeSunBeams; typedef struct CryptomatteEntry { struct CryptomatteEntry *next, *prev; float encoded_hash; /** MAX_NAME. */ char name[64]; char _pad[4]; } CryptomatteEntry; typedef struct CryptomatteLayer { struct CryptomatteEntry *next, *prev; char name[64]; } CryptomatteLayer; typedef struct NodeCryptomatte_Runtime { /* Contains `CryptomatteLayer`. */ ListBase layers; /* Temp storage for the cryptomatte picker. */ float add[3]; float remove[3]; } NodeCryptomatte_Runtime; typedef struct NodeCryptomatte { /** * `iuser` needs to be first element due to RNA limitations. * When we define the #ImageData properties, we can't define them from * `storage->iuser`, so storage needs to be cast to #ImageUser directly. */ ImageUser iuser; /* Contains `CryptomatteEntry`. */ ListBase entries; /* MAX_NAME */ char layer_name[64]; /* Stores `entries` as a string for opening in 2.80-2.91. */ char *matte_id; /** Legacy attributes */ /* Number of input sockets. */ int inputs_num; char _pad[4]; NodeCryptomatte_Runtime runtime; } NodeCryptomatte; typedef struct NodeDenoise { char hdr; char prefilter; } NodeDenoise; typedef struct NodeMapRange { /* eCustomDataType */ uint8_t data_type; /* NodeMapRangeType. */ uint8_t interpolation_type; uint8_t clamp; char _pad[5]; } NodeMapRange; typedef struct NodeRandomValue { /* eCustomDataType. */ uint8_t data_type; } NodeRandomValue; typedef struct NodeAccumulateField { /* eCustomDataType. */ uint8_t data_type; /* eAttrDomain. */ uint8_t domain; } NodeAccumulateField; typedef struct NodeInputBool { uint8_t boolean; } NodeInputBool; typedef struct NodeInputInt { int integer; } NodeInputInt; typedef struct NodeInputVector { float vector[3]; } NodeInputVector; typedef struct NodeInputColor { float color[4]; } NodeInputColor; typedef struct NodeInputString { char *string; } NodeInputString; typedef struct NodeGeometryExtrudeMesh { /* GeometryNodeExtrudeMeshMode */ uint8_t mode; } NodeGeometryExtrudeMesh; typedef struct NodeGeometryObjectInfo { /* GeometryNodeTransformSpace. */ uint8_t transform_space; } NodeGeometryObjectInfo; typedef struct NodeGeometryPointsToVolume { /* GeometryNodePointsToVolumeResolutionMode */ uint8_t resolution_mode; /* GeometryNodeAttributeInputMode */ uint8_t input_type_radius; } NodeGeometryPointsToVolume; typedef struct NodeGeometryCollectionInfo { /* GeometryNodeTransformSpace. */ uint8_t transform_space; } NodeGeometryCollectionInfo; typedef struct NodeGeometryProximity { /* GeometryNodeProximityTargetType. */ uint8_t target_element; } NodeGeometryProximity; typedef struct NodeGeometryVolumeToMesh { /* VolumeToMeshResolutionMode */ uint8_t resolution_mode; } NodeGeometryVolumeToMesh; typedef struct NodeGeometryMeshToVolume { /* MeshToVolumeModifierResolutionMode */ uint8_t resolution_mode; } NodeGeometryMeshToVolume; typedef struct NodeGeometrySubdivisionSurface { /* eSubsurfUVSmooth. */ uint8_t uv_smooth; /* eSubsurfBoundarySmooth. */ uint8_t boundary_smooth; } NodeGeometrySubdivisionSurface; typedef struct NodeGeometryMeshCircle { /* GeometryNodeMeshCircleFillType. */ uint8_t fill_type; } NodeGeometryMeshCircle; typedef struct NodeGeometryMeshCylinder { /* GeometryNodeMeshCircleFillType. */ uint8_t fill_type; } NodeGeometryMeshCylinder; typedef struct NodeGeometryMeshCone { /* GeometryNodeMeshCircleFillType. */ uint8_t fill_type; } NodeGeometryMeshCone; typedef struct NodeGeometryMergeByDistance { /* GeometryNodeMergeByDistanceMode. */ uint8_t mode; } NodeGeometryMergeByDistance; typedef struct NodeGeometryMeshLine { /* GeometryNodeMeshLineMode. */ uint8_t mode; /* GeometryNodeMeshLineCountMode. */ uint8_t count_mode; } NodeGeometryMeshLine; typedef struct NodeSwitch { /* NodeSwitch. */ uint8_t input_type; } NodeSwitch; typedef struct NodeGeometryCurveSplineType { /* GeometryNodeSplineType. */ uint8_t spline_type; } NodeGeometryCurveSplineType; typedef struct NodeGeometrySetCurveHandlePositions { /* GeometryNodeCurveHandleMode. */ uint8_t mode; } NodeGeometrySetCurveHandlePositions; typedef struct NodeGeometryCurveSetHandles { /* GeometryNodeCurveHandleType. */ uint8_t handle_type; /* GeometryNodeCurveHandleMode. */ uint8_t mode; } NodeGeometryCurveSetHandles; typedef struct NodeGeometryCurveSelectHandles { /* GeometryNodeCurveHandleType. */ uint8_t handle_type; /* GeometryNodeCurveHandleMode. */ uint8_t mode; } NodeGeometryCurveSelectHandles; typedef struct NodeGeometryCurvePrimitiveArc { /* GeometryNodeCurvePrimitiveArcMode. */ uint8_t mode; } NodeGeometryCurvePrimitiveArc; typedef struct NodeGeometryCurvePrimitiveLine { /* GeometryNodeCurvePrimitiveLineMode. */ uint8_t mode; } NodeGeometryCurvePrimitiveLine; typedef struct NodeGeometryCurvePrimitiveBezierSegment { /* GeometryNodeCurvePrimitiveBezierSegmentMode. */ uint8_t mode; } NodeGeometryCurvePrimitiveBezierSegment; typedef struct NodeGeometryCurvePrimitiveCircle { /* GeometryNodeCurvePrimitiveMode. */ uint8_t mode; } NodeGeometryCurvePrimitiveCircle; typedef struct NodeGeometryCurvePrimitiveQuad { /* GeometryNodeCurvePrimitiveQuadMode. */ uint8_t mode; } NodeGeometryCurvePrimitiveQuad; typedef struct NodeGeometryCurveResample { /* GeometryNodeCurveResampleMode. */ uint8_t mode; } NodeGeometryCurveResample; typedef struct NodeGeometryCurveFillet { /* GeometryNodeCurveFilletMode. */ uint8_t mode; } NodeGeometryCurveFillet; typedef struct NodeGeometryCurveTrim { /* GeometryNodeCurveSampleMode. */ uint8_t mode; } NodeGeometryCurveTrim; typedef struct NodeGeometryCurveToPoints { /* GeometryNodeCurveResampleMode. */ uint8_t mode; } NodeGeometryCurveToPoints; typedef struct NodeGeometryCurveSample { /* GeometryNodeCurveSampleMode. */ uint8_t mode; } NodeGeometryCurveSample; typedef struct NodeGeometryTransferAttribute { /* eCustomDataType. */ int8_t data_type; /* eAttrDomain. */ int8_t domain; /* GeometryNodeAttributeTransferMode. */ uint8_t mode; char _pad[1]; } NodeGeometryTransferAttribute; typedef struct NodeGeometryRaycast { /* GeometryNodeRaycastMapMode. */ uint8_t mapping; /* eCustomDataType. */ int8_t data_type; /* Deprecated input types in new Ray-cast node. Can be removed when legacy nodes are no longer * supported. */ uint8_t input_type_ray_direction; uint8_t input_type_ray_length; } NodeGeometryRaycast; typedef struct NodeGeometryCurveFill { uint8_t mode; } NodeGeometryCurveFill; typedef struct NodeGeometryMeshToPoints { /* GeometryNodeMeshToPointsMode */ uint8_t mode; } NodeGeometryMeshToPoints; typedef struct NodeGeometryAttributeCapture { /* eCustomDataType. */ int8_t data_type; /* eAttrDomain. */ int8_t domain; } NodeGeometryAttributeCapture; typedef struct NodeGeometryStoreNamedAttribute { /* eCustomDataType. */ int8_t data_type; /* eAttrDomain. */ int8_t domain; } NodeGeometryStoreNamedAttribute; typedef struct NodeGeometryInputNamedAttribute { /* eCustomDataType. */ int8_t data_type; } NodeGeometryInputNamedAttribute; typedef struct NodeGeometryStringToCurves { /* GeometryNodeStringToCurvesOverflowMode */ uint8_t overflow; /* GeometryNodeStringToCurvesAlignXMode */ uint8_t align_x; /* GeometryNodeStringToCurvesAlignYMode */ uint8_t align_y; /* GeometryNodeStringToCurvesPivotMode */ uint8_t pivot_mode; } NodeGeometryStringToCurves; typedef struct NodeGeometryDeleteGeometry { /* eAttrDomain. */ int8_t domain; /* GeometryNodeDeleteGeometryMode. */ int8_t mode; } NodeGeometryDeleteGeometry; typedef struct NodeGeometryDuplicateElements { /* eAttrDomain. */ int8_t domain; } NodeGeometryDuplicateElements; typedef struct NodeGeometrySeparateGeometry { /* eAttrDomain. */ int8_t domain; } NodeGeometrySeparateGeometry; typedef struct NodeGeometryImageTexture { int interpolation; int extension; } NodeGeometryImageTexture; typedef struct NodeGeometryViewer { /* eCustomDataType. */ int8_t data_type; } NodeGeometryViewer; typedef struct NodeGeometryUVUnwrap { /* GeometryNodeUVUnwrapMethod. */ uint8_t method; } NodeGeometryUVUnwrap; +typedef struct NodeGeometryDistributePointsInVolume { + /* GeometryNodePointDistributeVolumeMode. */ + uint8_t mode; +} NodeGeometryDistributePointsInVolume; + typedef struct NodeFunctionCompare { /* NodeCompareOperation */ int8_t operation; /* eNodeSocketDatatype */ int8_t data_type; /* NodeCompareMode */ int8_t mode; char _pad[1]; } NodeFunctionCompare; typedef struct NodeCombSepColor { /* NodeCombSepColorMode */ int8_t mode; } NodeCombSepColor; /* script node mode */ #define NODE_SCRIPT_INTERNAL 0 #define NODE_SCRIPT_EXTERNAL 1 /* script node flag */ #define NODE_SCRIPT_AUTO_UPDATE 1 /* IES node mode. */ #define NODE_IES_INTERNAL 0 #define NODE_IES_EXTERNAL 1 /* Frame node flags. */ #define NODE_FRAME_SHRINK 1 /* keep the bounding box minimal */ #define NODE_FRAME_RESIZEABLE 2 /* test flag, if frame can be resized by user */ /* Proxy node flags. */ #define NODE_PROXY_AUTOTYPE 1 /* automatically change output type based on link */ /* Comp channel matte. */ #define CMP_NODE_CHANNEL_MATTE_CS_RGB 1 #define CMP_NODE_CHANNEL_MATTE_CS_HSV 2 #define CMP_NODE_CHANNEL_MATTE_CS_YUV 3 #define CMP_NODE_CHANNEL_MATTE_CS_YCC 4 /* glossy distributions */ #define SHD_GLOSSY_BECKMANN 0 #define SHD_GLOSSY_SHARP 1 #define SHD_GLOSSY_GGX 2 #define SHD_GLOSSY_ASHIKHMIN_SHIRLEY 3 #define SHD_GLOSSY_MULTI_GGX 4 /* vector transform */ #define SHD_VECT_TRANSFORM_TYPE_VECTOR 0 #define SHD_VECT_TRANSFORM_TYPE_POINT 1 #define SHD_VECT_TRANSFORM_TYPE_NORMAL 2 #define SHD_VECT_TRANSFORM_SPACE_WORLD 0 #define SHD_VECT_TRANSFORM_SPACE_OBJECT 1 #define SHD_VECT_TRANSFORM_SPACE_CAMERA 2 /** #NodeShaderAttribute.type */ enum { SHD_ATTRIBUTE_GEOMETRY = 0, SHD_ATTRIBUTE_OBJECT = 1, SHD_ATTRIBUTE_INSTANCER = 2, }; /* toon modes */ #define SHD_TOON_DIFFUSE 0 #define SHD_TOON_GLOSSY 1 /* hair components */ #define SHD_HAIR_REFLECTION 0 #define SHD_HAIR_TRANSMISSION 1 /* principled hair parametrization */ #define SHD_PRINCIPLED_HAIR_REFLECTANCE 0 #define SHD_PRINCIPLED_HAIR_PIGMENT_CONCENTRATION 1 #define SHD_PRINCIPLED_HAIR_DIRECT_ABSORPTION 2 /* blend texture */ #define SHD_BLEND_LINEAR 0 #define SHD_BLEND_QUADRATIC 1 #define SHD_BLEND_EASING 2 #define SHD_BLEND_DIAGONAL 3 #define SHD_BLEND_RADIAL 4 #define SHD_BLEND_QUADRATIC_SPHERE 5 #define SHD_BLEND_SPHERICAL 6 /* noise basis for textures */ #define SHD_NOISE_PERLIN 0 #define SHD_NOISE_VORONOI_F1 1 #define SHD_NOISE_VORONOI_F2 2 #define SHD_NOISE_VORONOI_F3 3 #define SHD_NOISE_VORONOI_F4 4 #define SHD_NOISE_VORONOI_F2_F1 5 #define SHD_NOISE_VORONOI_CRACKLE 6 #define SHD_NOISE_CELL_NOISE 7 #define SHD_NOISE_SOFT 0 #define SHD_NOISE_HARD 1 /* Voronoi Texture */ enum { SHD_VORONOI_EUCLIDEAN = 0, SHD_VORONOI_MANHATTAN = 1, SHD_VORONOI_CHEBYCHEV = 2, SHD_VORONOI_MINKOWSKI = 3, }; enum { SHD_VORONOI_F1 = 0, SHD_VORONOI_F2 = 1, SHD_VORONOI_SMOOTH_F1 = 2, SHD_VORONOI_DISTANCE_TO_EDGE = 3, SHD_VORONOI_N_SPHERE_RADIUS = 4, }; /* musgrave texture */ #define SHD_MUSGRAVE_MULTIFRACTAL 0 #define SHD_MUSGRAVE_FBM 1 #define SHD_MUSGRAVE_HYBRID_MULTIFRACTAL 2 #define SHD_MUSGRAVE_RIDGED_MULTIFRACTAL 3 #define SHD_MUSGRAVE_HETERO_TERRAIN 4 /* wave texture */ #define SHD_WAVE_BANDS 0 #define SHD_WAVE_RINGS 1 enum { SHD_WAVE_BANDS_DIRECTION_X = 0, SHD_WAVE_BANDS_DIRECTION_Y = 1, SHD_WAVE_BANDS_DIRECTION_Z = 2, SHD_WAVE_BANDS_DIRECTION_DIAGONAL = 3, }; enum { SHD_WAVE_RINGS_DIRECTION_X = 0, SHD_WAVE_RINGS_DIRECTION_Y = 1, SHD_WAVE_RINGS_DIRECTION_Z = 2, SHD_WAVE_RINGS_DIRECTION_SPHERICAL = 3, }; enum { SHD_WAVE_PROFILE_SIN = 0, SHD_WAVE_PROFILE_SAW = 1, SHD_WAVE_PROFILE_TRI = 2, }; /* sky texture */ #define SHD_SKY_PREETHAM 0 #define SHD_SKY_HOSEK 1 #define SHD_SKY_NISHITA 2 /* environment texture */ #define SHD_PROJ_EQUIRECTANGULAR 0 #define SHD_PROJ_MIRROR_BALL 1 #define SHD_IMAGE_EXTENSION_REPEAT 0 #define SHD_IMAGE_EXTENSION_EXTEND 1 #define SHD_IMAGE_EXTENSION_CLIP 2 /* image texture */ #define SHD_PROJ_FLAT 0 #define SHD_PROJ_BOX 1 #define SHD_PROJ_SPHERE 2 #define SHD_PROJ_TUBE 3 /* image texture interpolation */ #define SHD_INTERP_LINEAR 0 #define SHD_INTERP_CLOSEST 1 #define SHD_INTERP_CUBIC 2 #define SHD_INTERP_SMART 3 /* tangent */ #define SHD_TANGENT_RADIAL 0 #define SHD_TANGENT_UVMAP 1 /* tangent */ #define SHD_TANGENT_AXIS_X 0 #define SHD_TANGENT_AXIS_Y 1 #define SHD_TANGENT_AXIS_Z 2 /* normal map, displacement space */ #define SHD_SPACE_TANGENT 0 #define SHD_SPACE_OBJECT 1 #define SHD_SPACE_WORLD 2 #define SHD_SPACE_BLENDER_OBJECT 3 #define SHD_SPACE_BLENDER_WORLD 4 #define SHD_AO_INSIDE 1 #define SHD_AO_LOCAL 2 /** Mapping node vector types. */ enum { NODE_MAPPING_TYPE_POINT = 0, NODE_MAPPING_TYPE_TEXTURE = 1, NODE_MAPPING_TYPE_VECTOR = 2, NODE_MAPPING_TYPE_NORMAL = 3, }; /** Rotation node vector types. */ enum { NODE_VECTOR_ROTATE_TYPE_AXIS = 0, NODE_VECTOR_ROTATE_TYPE_AXIS_X = 1, NODE_VECTOR_ROTATE_TYPE_AXIS_Y = 2, NODE_VECTOR_ROTATE_TYPE_AXIS_Z = 3, NODE_VECTOR_ROTATE_TYPE_EULER_XYZ = 4, }; /* math node clamp */ #define SHD_MATH_CLAMP 1 typedef enum NodeMathOperation { NODE_MATH_ADD = 0, NODE_MATH_SUBTRACT = 1, NODE_MATH_MULTIPLY = 2, NODE_MATH_DIVIDE = 3, NODE_MATH_SINE = 4, NODE_MATH_COSINE = 5, NODE_MATH_TANGENT = 6, NODE_MATH_ARCSINE = 7, NODE_MATH_ARCCOSINE = 8, NODE_MATH_ARCTANGENT = 9, NODE_MATH_POWER = 10, NODE_MATH_LOGARITHM = 11, NODE_MATH_MINIMUM = 12, NODE_MATH_MAXIMUM = 13, NODE_MATH_ROUND = 14, NODE_MATH_LESS_THAN = 15, NODE_MATH_GREATER_THAN = 16, NODE_MATH_MODULO = 17, NODE_MATH_ABSOLUTE = 18, NODE_MATH_ARCTAN2 = 19, NODE_MATH_FLOOR = 20, NODE_MATH_CEIL = 21, NODE_MATH_FRACTION = 22, NODE_MATH_SQRT = 23, NODE_MATH_INV_SQRT = 24, NODE_MATH_SIGN = 25, NODE_MATH_EXPONENT = 26, NODE_MATH_RADIANS = 27, NODE_MATH_DEGREES = 28, NODE_MATH_SINH = 29, NODE_MATH_COSH = 30, NODE_MATH_TANH = 31, NODE_MATH_TRUNC = 32, NODE_MATH_SNAP = 33, NODE_MATH_WRAP = 34, NODE_MATH_COMPARE = 35, NODE_MATH_MULTIPLY_ADD = 36, NODE_MATH_PINGPONG = 37, NODE_MATH_SMOOTH_MIN = 38, NODE_MATH_SMOOTH_MAX = 39, } NodeMathOperation; typedef enum NodeVectorMathOperation { NODE_VECTOR_MATH_ADD = 0, NODE_VECTOR_MATH_SUBTRACT = 1, NODE_VECTOR_MATH_MULTIPLY = 2, NODE_VECTOR_MATH_DIVIDE = 3, NODE_VECTOR_MATH_CROSS_PRODUCT = 4, NODE_VECTOR_MATH_PROJECT = 5, NODE_VECTOR_MATH_REFLECT = 6, NODE_VECTOR_MATH_DOT_PRODUCT = 7, NODE_VECTOR_MATH_DISTANCE = 8, NODE_VECTOR_MATH_LENGTH = 9, NODE_VECTOR_MATH_SCALE = 10, NODE_VECTOR_MATH_NORMALIZE = 11, NODE_VECTOR_MATH_SNAP = 12, NODE_VECTOR_MATH_FLOOR = 13, NODE_VECTOR_MATH_CEIL = 14, NODE_VECTOR_MATH_MODULO = 15, NODE_VECTOR_MATH_FRACTION = 16, NODE_VECTOR_MATH_ABSOLUTE = 17, NODE_VECTOR_MATH_MINIMUM = 18, NODE_VECTOR_MATH_MAXIMUM = 19, NODE_VECTOR_MATH_WRAP = 20, NODE_VECTOR_MATH_SINE = 21, NODE_VECTOR_MATH_COSINE = 22, NODE_VECTOR_MATH_TANGENT = 23, NODE_VECTOR_MATH_REFRACT = 24, NODE_VECTOR_MATH_FACEFORWARD = 25, NODE_VECTOR_MATH_MULTIPLY_ADD = 26, } NodeVectorMathOperation; typedef enum NodeBooleanMathOperation { NODE_BOOLEAN_MATH_AND = 0, NODE_BOOLEAN_MATH_OR = 1, NODE_BOOLEAN_MATH_NOT = 2, NODE_BOOLEAN_MATH_NAND = 3, NODE_BOOLEAN_MATH_NOR = 4, NODE_BOOLEAN_MATH_XNOR = 5, NODE_BOOLEAN_MATH_XOR = 6, NODE_BOOLEAN_MATH_IMPLY = 7, NODE_BOOLEAN_MATH_NIMPLY = 8, } NodeBooleanMathOperation; typedef enum NodeCompareMode { NODE_COMPARE_MODE_ELEMENT = 0, NODE_COMPARE_MODE_LENGTH = 1, NODE_COMPARE_MODE_AVERAGE = 2, NODE_COMPARE_MODE_DOT_PRODUCT = 3, NODE_COMPARE_MODE_DIRECTION = 4 } NodeCompareMode; typedef enum NodeCompareOperation { NODE_COMPARE_LESS_THAN = 0, NODE_COMPARE_LESS_EQUAL = 1, NODE_COMPARE_GREATER_THAN = 2, NODE_COMPARE_GREATER_EQUAL = 3, NODE_COMPARE_EQUAL = 4, NODE_COMPARE_NOT_EQUAL = 5, NODE_COMPARE_COLOR_BRIGHTER = 6, NODE_COMPARE_COLOR_DARKER = 7, } NodeCompareOperation; typedef enum FloatToIntRoundingMode { FN_NODE_FLOAT_TO_INT_ROUND = 0, FN_NODE_FLOAT_TO_INT_FLOOR = 1, FN_NODE_FLOAT_TO_INT_CEIL = 2, FN_NODE_FLOAT_TO_INT_TRUNCATE = 3, } FloatToIntRoundingMode; /** Clamp node types. */ enum { NODE_CLAMP_MINMAX = 0, NODE_CLAMP_RANGE = 1, }; /** Map range node types. */ enum { NODE_MAP_RANGE_LINEAR = 0, NODE_MAP_RANGE_STEPPED = 1, NODE_MAP_RANGE_SMOOTHSTEP = 2, NODE_MAP_RANGE_SMOOTHERSTEP = 3, }; /* mix rgb node flags */ #define SHD_MIXRGB_USE_ALPHA 1 #define SHD_MIXRGB_CLAMP 2 /* Subsurface. */ enum { #ifdef DNA_DEPRECATED_ALLOW SHD_SUBSURFACE_COMPATIBLE = 0, /* Deprecated */ SHD_SUBSURFACE_CUBIC = 1, SHD_SUBSURFACE_GAUSSIAN = 2, #endif SHD_SUBSURFACE_BURLEY = 3, SHD_SUBSURFACE_RANDOM_WALK_FIXED_RADIUS = 4, SHD_SUBSURFACE_RANDOM_WALK = 5, }; /* blur node */ #define CMP_NODE_BLUR_ASPECT_NONE 0 #define CMP_NODE_BLUR_ASPECT_Y 1 #define CMP_NODE_BLUR_ASPECT_X 2 /* wrapping */ #define CMP_NODE_WRAP_NONE 0 #define CMP_NODE_WRAP_X 1 #define CMP_NODE_WRAP_Y 2 #define CMP_NODE_WRAP_XY 3 #define CMP_NODE_MASK_MBLUR_SAMPLES_MAX 64 /* image */ #define CMP_NODE_IMAGE_USE_STRAIGHT_OUTPUT 1 /* viewer and composite output. */ #define CMP_NODE_OUTPUT_IGNORE_ALPHA 1 /* Plane track deform node. */ enum { CMP_NODEFLAG_PLANETRACKDEFORM_MOTION_BLUR = 1, }; /* Stabilization node. */ enum { CMP_NODEFLAG_STABILIZE_INVERSE = 1, }; /* Set Alpha Node. */ /** #NodeSetAlpha.mode */ typedef enum CMPNodeSetAlphaMode { CMP_NODE_SETALPHA_MODE_APPLY = 0, CMP_NODE_SETALPHA_MODE_REPLACE_ALPHA = 1, } CMPNodeSetAlphaMode; /* Denoise Node. */ /** #NodeDenoise.prefilter */ typedef enum CMPNodeDenoisePrefilter { CMP_NODE_DENOISE_PREFILTER_FAST = 0, CMP_NODE_DENOISE_PREFILTER_NONE = 1, CMP_NODE_DENOISE_PREFILTER_ACCURATE = 2 } CMPNodeDenoisePrefilter; /* Color combine/separate modes */ typedef enum CMPNodeCombSepColorMode { CMP_NODE_COMBSEP_COLOR_RGB = 0, CMP_NODE_COMBSEP_COLOR_HSV = 1, CMP_NODE_COMBSEP_COLOR_HSL = 2, CMP_NODE_COMBSEP_COLOR_YCC = 3, CMP_NODE_COMBSEP_COLOR_YUV = 4, } CMPNodeCombSepColorMode; #define CMP_NODE_PLANETRACKDEFORM_MBLUR_SAMPLES_MAX 64 /* Point Density shader node */ enum { SHD_POINTDENSITY_SOURCE_PSYS = 0, SHD_POINTDENSITY_SOURCE_OBJECT = 1, }; enum { SHD_POINTDENSITY_SPACE_OBJECT = 0, SHD_POINTDENSITY_SPACE_WORLD = 1, }; enum { SHD_POINTDENSITY_COLOR_PARTAGE = 1, SHD_POINTDENSITY_COLOR_PARTSPEED = 2, SHD_POINTDENSITY_COLOR_PARTVEL = 3, }; enum { SHD_POINTDENSITY_COLOR_VERTCOL = 0, SHD_POINTDENSITY_COLOR_VERTWEIGHT = 1, SHD_POINTDENSITY_COLOR_VERTNOR = 2, }; /* Output shader node */ typedef enum NodeShaderOutputTarget { SHD_OUTPUT_ALL = 0, SHD_OUTPUT_EEVEE = 1, SHD_OUTPUT_CYCLES = 2, } NodeShaderOutputTarget; /* Geometry Nodes */ typedef enum GeometryNodeProximityTargetType { GEO_NODE_PROX_TARGET_POINTS = 0, GEO_NODE_PROX_TARGET_EDGES = 1, GEO_NODE_PROX_TARGET_FACES = 2, } GeometryNodeProximityTargetType; typedef enum GeometryNodeBooleanOperation { GEO_NODE_BOOLEAN_INTERSECT = 0, GEO_NODE_BOOLEAN_UNION = 1, GEO_NODE_BOOLEAN_DIFFERENCE = 2, } GeometryNodeBooleanOperation; typedef enum GeometryNodeCurvePrimitiveCircleMode { GEO_NODE_CURVE_PRIMITIVE_CIRCLE_TYPE_POINTS = 0, GEO_NODE_CURVE_PRIMITIVE_CIRCLE_TYPE_RADIUS = 1 } GeometryNodeCurvePrimitiveCircleMode; typedef enum GeometryNodeCurveHandleType { GEO_NODE_CURVE_HANDLE_FREE = 0, GEO_NODE_CURVE_HANDLE_AUTO = 1, GEO_NODE_CURVE_HANDLE_VECTOR = 2, GEO_NODE_CURVE_HANDLE_ALIGN = 3 } GeometryNodeCurveHandleType; typedef enum GeometryNodeCurveHandleMode { GEO_NODE_CURVE_HANDLE_LEFT = (1 << 0), GEO_NODE_CURVE_HANDLE_RIGHT = (1 << 1) } GeometryNodeCurveHandleMode; typedef enum GeometryNodeTriangulateNGons { GEO_NODE_TRIANGULATE_NGON_BEAUTY = 0, GEO_NODE_TRIANGULATE_NGON_EARCLIP = 1, } GeometryNodeTriangulateNGons; typedef enum GeometryNodeTriangulateQuads { GEO_NODE_TRIANGULATE_QUAD_BEAUTY = 0, GEO_NODE_TRIANGULATE_QUAD_FIXED = 1, GEO_NODE_TRIANGULATE_QUAD_ALTERNATE = 2, GEO_NODE_TRIANGULATE_QUAD_SHORTEDGE = 3, GEO_NODE_TRIANGULATE_QUAD_LONGEDGE = 4, } GeometryNodeTriangulateQuads; typedef enum GeometryNodeDistributePointsOnFacesMode { GEO_NODE_POINT_DISTRIBUTE_POINTS_ON_FACES_RANDOM = 0, GEO_NODE_POINT_DISTRIBUTE_POINTS_ON_FACES_POISSON = 1, } GeometryNodeDistributePointsOnFacesMode; +typedef enum GeometryNodeDistributePointsInVolumeMode { + GEO_NODE_DISTRIBUTE_POINTS_IN_VOLUME_DENSITY_RANDOM = 0, + GEO_NODE_DISTRIBUTE_POINTS_IN_VOLUME_DENSITY_GRID = 1, +} GeometryNodeDistributePointsInVolumeMode; + typedef enum GeometryNodeExtrudeMeshMode { GEO_NODE_EXTRUDE_MESH_VERTICES = 0, GEO_NODE_EXTRUDE_MESH_EDGES = 1, GEO_NODE_EXTRUDE_MESH_FACES = 2, } GeometryNodeExtrudeMeshMode; typedef enum FunctionNodeRotateEulerType { FN_NODE_ROTATE_EULER_TYPE_EULER = 0, FN_NODE_ROTATE_EULER_TYPE_AXIS_ANGLE = 1, } FunctionNodeRotateEulerType; typedef enum FunctionNodeRotateEulerSpace { FN_NODE_ROTATE_EULER_SPACE_OBJECT = 0, FN_NODE_ROTATE_EULER_SPACE_LOCAL = 1, } FunctionNodeRotateEulerSpace; typedef enum NodeAlignEulerToVectorAxis { FN_NODE_ALIGN_EULER_TO_VECTOR_AXIS_X = 0, FN_NODE_ALIGN_EULER_TO_VECTOR_AXIS_Y = 1, FN_NODE_ALIGN_EULER_TO_VECTOR_AXIS_Z = 2, } NodeAlignEulerToVectorAxis; typedef enum NodeAlignEulerToVectorPivotAxis { FN_NODE_ALIGN_EULER_TO_VECTOR_PIVOT_AXIS_AUTO = 0, FN_NODE_ALIGN_EULER_TO_VECTOR_PIVOT_AXIS_X = 1, FN_NODE_ALIGN_EULER_TO_VECTOR_PIVOT_AXIS_Y = 2, FN_NODE_ALIGN_EULER_TO_VECTOR_PIVOT_AXIS_Z = 3, } NodeAlignEulerToVectorPivotAxis; typedef enum GeometryNodeTransformSpace { GEO_NODE_TRANSFORM_SPACE_ORIGINAL = 0, GEO_NODE_TRANSFORM_SPACE_RELATIVE = 1, } GeometryNodeTransformSpace; typedef enum GeometryNodePointsToVolumeResolutionMode { GEO_NODE_POINTS_TO_VOLUME_RESOLUTION_MODE_AMOUNT = 0, GEO_NODE_POINTS_TO_VOLUME_RESOLUTION_MODE_SIZE = 1, } GeometryNodePointsToVolumeResolutionMode; typedef enum GeometryNodeMeshCircleFillType { GEO_NODE_MESH_CIRCLE_FILL_NONE = 0, GEO_NODE_MESH_CIRCLE_FILL_NGON = 1, GEO_NODE_MESH_CIRCLE_FILL_TRIANGLE_FAN = 2, } GeometryNodeMeshCircleFillType; typedef enum GeometryNodeMergeByDistanceMode { GEO_NODE_MERGE_BY_DISTANCE_MODE_ALL = 0, GEO_NODE_MERGE_BY_DISTANCE_MODE_CONNECTED = 1, } GeometryNodeMergeByDistanceMode; typedef enum GeometryNodeUVUnwrapMethod { GEO_NODE_UV_UNWRAP_METHOD_ANGLE_BASED = 0, GEO_NODE_UV_UNWRAP_METHOD_CONFORMAL = 1, } GeometryNodeUVUnwrapMethod; typedef enum GeometryNodeMeshLineMode { GEO_NODE_MESH_LINE_MODE_END_POINTS = 0, GEO_NODE_MESH_LINE_MODE_OFFSET = 1, } GeometryNodeMeshLineMode; typedef enum GeometryNodeMeshLineCountMode { GEO_NODE_MESH_LINE_COUNT_TOTAL = 0, GEO_NODE_MESH_LINE_COUNT_RESOLUTION = 1, } GeometryNodeMeshLineCountMode; typedef enum GeometryNodeCurvePrimitiveArcMode { GEO_NODE_CURVE_PRIMITIVE_ARC_TYPE_POINTS = 0, GEO_NODE_CURVE_PRIMITIVE_ARC_TYPE_RADIUS = 1, } GeometryNodeCurvePrimitiveArcMode; typedef enum GeometryNodeCurvePrimitiveLineMode { GEO_NODE_CURVE_PRIMITIVE_LINE_MODE_POINTS = 0, GEO_NODE_CURVE_PRIMITIVE_LINE_MODE_DIRECTION = 1 } GeometryNodeCurvePrimitiveLineMode; typedef enum GeometryNodeCurvePrimitiveQuadMode { GEO_NODE_CURVE_PRIMITIVE_QUAD_MODE_RECTANGLE = 0, GEO_NODE_CURVE_PRIMITIVE_QUAD_MODE_PARALLELOGRAM = 1, GEO_NODE_CURVE_PRIMITIVE_QUAD_MODE_TRAPEZOID = 2, GEO_NODE_CURVE_PRIMITIVE_QUAD_MODE_KITE = 3, GEO_NODE_CURVE_PRIMITIVE_QUAD_MODE_POINTS = 4, } GeometryNodeCurvePrimitiveQuadMode; typedef enum GeometryNodeCurvePrimitiveBezierSegmentMode { GEO_NODE_CURVE_PRIMITIVE_BEZIER_SEGMENT_POSITION = 0, GEO_NODE_CURVE_PRIMITIVE_BEZIER_SEGMENT_OFFSET = 1, } GeometryNodeCurvePrimitiveBezierSegmentMode; typedef enum GeometryNodeCurveResampleMode { GEO_NODE_CURVE_RESAMPLE_COUNT = 0, GEO_NODE_CURVE_RESAMPLE_LENGTH = 1, GEO_NODE_CURVE_RESAMPLE_EVALUATED = 2, } GeometryNodeCurveResampleMode; typedef enum GeometryNodeCurveSampleMode { GEO_NODE_CURVE_SAMPLE_FACTOR = 0, GEO_NODE_CURVE_SAMPLE_LENGTH = 1, } GeometryNodeCurveSampleMode; typedef enum GeometryNodeCurveFilletMode { GEO_NODE_CURVE_FILLET_BEZIER = 0, GEO_NODE_CURVE_FILLET_POLY = 1, } GeometryNodeCurveFilletMode; typedef enum GeometryNodeAttributeTransferMode { GEO_NODE_ATTRIBUTE_TRANSFER_NEAREST_FACE_INTERPOLATED = 0, GEO_NODE_ATTRIBUTE_TRANSFER_NEAREST = 1, GEO_NODE_ATTRIBUTE_TRANSFER_INDEX = 2, } GeometryNodeAttributeTransferMode; typedef enum GeometryNodeRaycastMapMode { GEO_NODE_RAYCAST_INTERPOLATED = 0, GEO_NODE_RAYCAST_NEAREST = 1, } GeometryNodeRaycastMapMode; typedef enum GeometryNodeCurveFillMode { GEO_NODE_CURVE_FILL_MODE_TRIANGULATED = 0, GEO_NODE_CURVE_FILL_MODE_NGONS = 1, } GeometryNodeCurveFillMode; typedef enum GeometryNodeMeshToPointsMode { GEO_NODE_MESH_TO_POINTS_VERTICES = 0, GEO_NODE_MESH_TO_POINTS_EDGES = 1, GEO_NODE_MESH_TO_POINTS_FACES = 2, GEO_NODE_MESH_TO_POINTS_CORNERS = 3, } GeometryNodeMeshToPointsMode; typedef enum GeometryNodeStringToCurvesOverflowMode { GEO_NODE_STRING_TO_CURVES_MODE_OVERFLOW = 0, GEO_NODE_STRING_TO_CURVES_MODE_SCALE_TO_FIT = 1, GEO_NODE_STRING_TO_CURVES_MODE_TRUNCATE = 2, } GeometryNodeStringToCurvesOverflowMode; typedef enum GeometryNodeStringToCurvesAlignXMode { GEO_NODE_STRING_TO_CURVES_ALIGN_X_LEFT = 0, GEO_NODE_STRING_TO_CURVES_ALIGN_X_CENTER = 1, GEO_NODE_STRING_TO_CURVES_ALIGN_X_RIGHT = 2, GEO_NODE_STRING_TO_CURVES_ALIGN_X_JUSTIFY = 3, GEO_NODE_STRING_TO_CURVES_ALIGN_X_FLUSH = 4, } GeometryNodeStringToCurvesAlignXMode; typedef enum GeometryNodeStringToCurvesAlignYMode { GEO_NODE_STRING_TO_CURVES_ALIGN_Y_TOP_BASELINE = 0, GEO_NODE_STRING_TO_CURVES_ALIGN_Y_TOP = 1, GEO_NODE_STRING_TO_CURVES_ALIGN_Y_MIDDLE = 2, GEO_NODE_STRING_TO_CURVES_ALIGN_Y_BOTTOM_BASELINE = 3, GEO_NODE_STRING_TO_CURVES_ALIGN_Y_BOTTOM = 4, } GeometryNodeStringToCurvesAlignYMode; typedef enum GeometryNodeStringToCurvesPivotMode { GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_MIDPOINT = 0, GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_TOP_LEFT = 1, GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_TOP_CENTER = 2, GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_TOP_RIGHT = 3, GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_BOTTOM_LEFT = 4, GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_BOTTOM_CENTER = 5, GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_BOTTOM_RIGHT = 6, } GeometryNodeStringToCurvesPivotMode; typedef enum GeometryNodeDeleteGeometryMode { GEO_NODE_DELETE_GEOMETRY_MODE_ALL = 0, GEO_NODE_DELETE_GEOMETRY_MODE_EDGE_FACE = 1, GEO_NODE_DELETE_GEOMETRY_MODE_ONLY_FACE = 2, } GeometryNodeDeleteGeometryMode; typedef enum GeometryNodeRealizeInstancesFlag { GEO_NODE_REALIZE_INSTANCES_LEGACY_BEHAVIOR = (1 << 0), } GeometryNodeRealizeInstancesFlag; typedef enum GeometryNodeScaleElementsMode { GEO_NODE_SCALE_ELEMENTS_UNIFORM = 0, GEO_NODE_SCALE_ELEMENTS_SINGLE_AXIS = 1, } GeometryNodeScaleElementsMode; typedef enum NodeCombSepColorMode { NODE_COMBSEP_COLOR_RGB = 0, NODE_COMBSEP_COLOR_HSV = 1, NODE_COMBSEP_COLOR_HSL = 2, } NodeCombSepColorMode; #ifdef __cplusplus } #endif diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c index 386ef3f74a3..be95a6fa6e5 100644 --- a/source/blender/makesrna/intern/rna_nodetree.c +++ b/source/blender/makesrna/intern/rna_nodetree.c @@ -8882,2000 +8882,2025 @@ static void def_cmp_keying(StructRNA *srna) RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "feather_falloff", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "feather_falloff"); RNA_def_property_enum_items(prop, rna_enum_proportional_falloff_curve_only_items); RNA_def_property_ui_text(prop, "Feather Falloff", "Falloff type the feather"); RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_CURVE_LEGACY); /* Abusing id_curve :/ */ RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "feather_distance", PROP_INT, PROP_NONE); RNA_def_property_int_sdna(prop, NULL, "feather_distance"); RNA_def_property_range(prop, -100, 100); RNA_def_property_ui_text(prop, "Feather Distance", "Distance to grow/shrink the feather"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_cmp_trackpos(StructRNA *srna) { PropertyRNA *prop; static const EnumPropertyItem position_items[] = { {CMP_TRACKPOS_ABSOLUTE, "ABSOLUTE", 0, "Absolute", "Output absolute position of a marker"}, {CMP_TRACKPOS_RELATIVE_START, "RELATIVE_START", 0, "Relative Start", "Output position of a marker relative to first marker of a track"}, {CMP_TRACKPOS_RELATIVE_FRAME, "RELATIVE_FRAME", 0, "Relative Frame", "Output position of a marker relative to marker at given frame number"}, {CMP_TRACKPOS_ABSOLUTE_FRAME, "ABSOLUTE_FRAME", 0, "Absolute Frame", "Output absolute position of a marker at given frame number"}, {0, NULL, 0, NULL, NULL}, }; prop = RNA_def_property(srna, "clip", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_sdna(prop, NULL, "id"); RNA_def_property_struct_type(prop, "MovieClip"); RNA_def_property_flag(prop, PROP_EDITABLE); RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY); RNA_def_property_ui_text(prop, "Movie Clip", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "position", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "custom1"); RNA_def_property_enum_items(prop, position_items); RNA_def_property_ui_text(prop, "Position", "Which marker position to use for output"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "frame_relative", PROP_INT, PROP_NONE); RNA_def_property_int_sdna(prop, NULL, "custom2"); RNA_def_property_ui_text(prop, "Frame", "Frame to be used for relative position"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); RNA_def_struct_sdna_from(srna, "NodeTrackPosData", "storage"); prop = RNA_def_property(srna, "tracking_object", PROP_STRING, PROP_NONE); RNA_def_property_string_sdna(prop, NULL, "tracking_object"); RNA_def_property_ui_text(prop, "Tracking Object", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "track_name", PROP_STRING, PROP_NONE); RNA_def_property_string_sdna(prop, NULL, "track_name"); RNA_def_property_ui_text(prop, "Track", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_cmp_translate(StructRNA *srna) { static const EnumPropertyItem translate_items[] = { {CMP_NODE_WRAP_NONE, "NONE", 0, "None", "No wrapping on X and Y"}, {CMP_NODE_WRAP_X, "XAXIS", 0, "X Axis", "Wrap all pixels on the X axis"}, {CMP_NODE_WRAP_Y, "YAXIS", 0, "Y Axis", "Wrap all pixels on the Y axis"}, {CMP_NODE_WRAP_XY, "BOTH", 0, "Both Axes", "Wrap all pixels on both axes"}, {0, NULL, 0, NULL, NULL}, }; PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeTranslateData", "storage"); prop = RNA_def_property(srna, "use_relative", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "relative", 1); RNA_def_property_ui_text( prop, "Relative", "Use relative (fraction of input image size) values to define translation"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "wrap_axis", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "wrap_axis"); RNA_def_property_enum_items(prop, translate_items); RNA_def_property_ui_text(prop, "Wrapping", "Wrap image on a specific axis"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_cmp_planetrackdeform(StructRNA *srna) { PropertyRNA *prop; prop = RNA_def_property(srna, "clip", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_sdna(prop, NULL, "id"); RNA_def_property_struct_type(prop, "MovieClip"); RNA_def_property_flag(prop, PROP_EDITABLE); RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY); RNA_def_property_ui_text(prop, "Movie Clip", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); RNA_def_struct_sdna_from(srna, "NodePlaneTrackDeformData", "storage"); prop = RNA_def_property(srna, "tracking_object", PROP_STRING, PROP_NONE); RNA_def_property_string_sdna(prop, NULL, "tracking_object"); RNA_def_property_ui_text(prop, "Tracking Object", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "plane_track_name", PROP_STRING, PROP_NONE); RNA_def_property_string_sdna(prop, NULL, "plane_track_name"); RNA_def_property_ui_text(prop, "Plane Track", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "use_motion_blur", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "flag", CMP_NODEFLAG_PLANETRACKDEFORM_MOTION_BLUR); RNA_def_property_ui_text(prop, "Motion Blur", "Use multi-sampled motion blur of the mask"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "motion_blur_samples", PROP_INT, PROP_NONE); RNA_def_property_range(prop, 1, CMP_NODE_PLANETRACKDEFORM_MBLUR_SAMPLES_MAX); RNA_def_property_ui_text(prop, "Samples", "Number of motion blur samples"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "motion_blur_shutter", PROP_FLOAT, PROP_NONE); RNA_def_property_range(prop, 0.0, 1.0f); RNA_def_property_ui_text(prop, "Shutter", "Exposure for motion blur as a factor of FPS"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_cmp_sunbeams(StructRNA *srna) { PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeSunBeams", "storage"); prop = RNA_def_property(srna, "source", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "source"); RNA_def_property_range(prop, -100.0f, 100.0f); RNA_def_property_ui_range(prop, -10.0f, 10.0f, 10, 3); RNA_def_property_ui_text( prop, "Source", "Source point of rays as a factor of the image width and height"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "ray_length", PROP_FLOAT, PROP_UNSIGNED); RNA_def_property_float_sdna(prop, NULL, "ray_length"); RNA_def_property_range(prop, 0.0f, 100.0f); RNA_def_property_ui_range(prop, 0.0f, 1.0f, 10, 3); RNA_def_property_ui_text(prop, "Ray Length", "Length of rays as a factor of the image size"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_cmp_cryptomatte_entry(BlenderRNA *brna) { StructRNA *srna; PropertyRNA *prop; srna = RNA_def_struct(brna, "CryptomatteEntry", NULL); RNA_def_struct_sdna(srna, "CryptomatteEntry"); prop = RNA_def_property(srna, "encoded_hash", PROP_FLOAT, PROP_NONE); RNA_def_property_clear_flag(prop, PROP_EDITABLE); RNA_def_property_float_sdna(prop, NULL, "encoded_hash"); prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE); RNA_def_property_clear_flag(prop, PROP_EDITABLE); RNA_def_property_ui_text(prop, "Name", ""); RNA_def_struct_name_property(srna, prop); } static void def_cmp_cryptomatte_common(StructRNA *srna) { PropertyRNA *prop; static float default_1[3] = {1.0f, 1.0f, 1.0f}; prop = RNA_def_property(srna, "matte_id", PROP_STRING, PROP_NONE); RNA_def_property_string_funcs(prop, "rna_NodeCryptomatte_matte_get", "rna_NodeCryptomatte_matte_length", "rna_NodeCryptomatte_matte_set"); RNA_def_property_ui_text( prop, "Matte Objects", "List of object and material crypto IDs to include in matte"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "add", PROP_FLOAT, PROP_COLOR); RNA_def_property_float_sdna(prop, NULL, "runtime.add"); RNA_def_property_float_array_default(prop, default_1); RNA_def_property_range(prop, -FLT_MAX, FLT_MAX); RNA_def_property_ui_text( prop, "Add", "Add object or material to matte, by picking a color from the Pick output"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeCryptomatte_update_add"); prop = RNA_def_property(srna, "remove", PROP_FLOAT, PROP_COLOR); RNA_def_property_float_sdna(prop, NULL, "runtime.remove"); RNA_def_property_float_array_default(prop, default_1); RNA_def_property_range(prop, -FLT_MAX, FLT_MAX); RNA_def_property_ui_text( prop, "Remove", "Remove object or material from matte, by picking a color from the Pick output"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeCryptomatte_update_remove"); } static void def_cmp_cryptomatte_legacy(StructRNA *srna) { RNA_def_struct_sdna_from(srna, "NodeCryptomatte", "storage"); def_cmp_cryptomatte_common(srna); } static void def_cmp_cryptomatte(StructRNA *srna) { PropertyRNA *prop; static const EnumPropertyItem cryptomatte_source_items[] = { {CMP_CRYPTOMATTE_SRC_RENDER, "RENDER", 0, "Render", "Use Cryptomatte passes from a render"}, {CMP_CRYPTOMATTE_SRC_IMAGE, "IMAGE", 0, "Image", "Use Cryptomatte passes from an image"}, {0, NULL, 0, NULL, NULL}}; prop = RNA_def_property(srna, "source", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "custom1"); RNA_def_property_enum_items(prop, cryptomatte_source_items); RNA_def_property_enum_funcs(prop, NULL, "rna_NodeCryptomatte_source_set", NULL); RNA_def_property_ui_text(prop, "Source", "Where the Cryptomatte passes are loaded from"); prop = RNA_def_property(srna, "scene", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_funcs( prop, "rna_NodeCryptomatte_scene_get", "rna_NodeCryptomatte_scene_set", NULL, NULL); RNA_def_property_struct_type(prop, "Scene"); RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT); RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY); RNA_def_property_ui_text(prop, "Scene", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_funcs(prop, "rna_NodeCryptomatte_image_get", "rna_NodeCryptomatte_image_set", NULL, "rna_NodeCryptomatte_image_poll"); RNA_def_property_struct_type(prop, "Image"); RNA_def_property_flag(prop, PROP_EDITABLE); RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY); RNA_def_property_ui_text(prop, "Image", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); RNA_def_struct_sdna_from(srna, "NodeCryptomatte", "storage"); def_cmp_cryptomatte_common(srna); prop = RNA_def_property(srna, "layer_name", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, node_cryptomatte_layer_name_items); RNA_def_property_enum_funcs(prop, "rna_NodeCryptomatte_layer_name_get", "rna_NodeCryptomatte_layer_name_set", "rna_NodeCryptomatte_layer_name_itemf"); RNA_def_property_ui_text(prop, "Cryptomatte Layer", "What Cryptomatte layer is used"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "entries", PROP_COLLECTION, PROP_NONE); RNA_def_property_collection_sdna(prop, NULL, "entries", NULL); RNA_def_property_struct_type(prop, "CryptomatteEntry"); RNA_def_property_ui_text(prop, "Mattes", ""); RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* Included here instead of defining image_user as a property of the node, * see def_cmp_image for details. * As mentioned in DNA_node_types.h, iuser is the first member of the Cryptomatte * storage type, so we can cast node->storage to ImageUser. * That is required since we can't define the properties from storage->iuser directly... */ RNA_def_struct_sdna_from(srna, "ImageUser", "storage"); def_node_image_user(srna); } static void def_cmp_denoise(StructRNA *srna) { PropertyRNA *prop; static const EnumPropertyItem prefilter_items[] = { {CMP_NODE_DENOISE_PREFILTER_NONE, "NONE", 0, "None", "No prefiltering, use when guiding passes are noise-free"}, {CMP_NODE_DENOISE_PREFILTER_FAST, "FAST", 0, "Fast", "Denoise image and guiding passes together. Improves quality when guiding passes are noisy " "using least amount of extra processing time"}, {CMP_NODE_DENOISE_PREFILTER_ACCURATE, "ACCURATE", 0, "Accurate", "Prefilter noisy guiding passes before denoising image. Improves quality when guiding " "passes are noisy using extra processing time"}, {0, NULL, 0, NULL, NULL}}; RNA_def_struct_sdna_from(srna, "NodeDenoise", "storage"); prop = RNA_def_property(srna, "use_hdr", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "hdr", 0); RNA_def_property_ui_text(prop, "HDR", "Process HDR images"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "prefilter", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, prefilter_items); RNA_def_property_ui_text(prop, "", "Denoising prefilter"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_cmp_antialiasing(StructRNA *srna) { PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeAntiAliasingData", "storage"); prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_FACTOR); RNA_def_property_float_sdna(prop, NULL, "threshold"); RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.1, 3); RNA_def_property_ui_text( prop, "Threshold", "Threshold to detect edges (smaller threshold makes more sensitive detection)"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "contrast_limit", PROP_FLOAT, PROP_FACTOR); RNA_def_property_float_sdna(prop, NULL, "contrast_limit"); RNA_def_property_range(prop, 0.0f, 1.0f); RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.1, 3); RNA_def_property_ui_text( prop, "Contrast Limit", "How much to eliminate spurious edges to avoid artifacts (the larger value makes less " "active; the value 2.0, for example, means discard a detected edge if there is a " "neighboring edge that has 2.0 times bigger contrast than the current one)"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "corner_rounding", PROP_FLOAT, PROP_FACTOR); RNA_def_property_float_sdna(prop, NULL, "corner_rounding"); RNA_def_property_range(prop, 0.0f, 1.0f); RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.1, 3); RNA_def_property_ui_text(prop, "Corner Rounding", "How much sharp corners will be rounded"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } /* -- Texture Nodes --------------------------------------------------------- */ static void def_tex_output(StructRNA *srna) { PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "TexNodeOutput", "storage"); prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_NONE); RNA_def_property_string_sdna(prop, NULL, "name"); RNA_def_property_ui_text(prop, "Output Name", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_tex_image(StructRNA *srna) { PropertyRNA *prop; prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_sdna(prop, NULL, "id"); RNA_def_property_struct_type(prop, "Image"); RNA_def_property_flag(prop, PROP_EDITABLE); RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY); RNA_def_property_ui_text(prop, "Image", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "image_user", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_sdna(prop, NULL, "storage"); RNA_def_property_struct_type(prop, "ImageUser"); RNA_def_property_ui_text( prop, "Image User", "Parameters defining the image duration, offset and related settings"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_tex_bricks(StructRNA *srna) { PropertyRNA *prop; prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "custom3"); RNA_def_property_range(prop, 0.0f, 1.0f); RNA_def_property_ui_text(prop, "Offset Amount", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "offset_frequency", PROP_INT, PROP_NONE); RNA_def_property_int_sdna(prop, NULL, "custom1"); RNA_def_property_range(prop, 2, 99); RNA_def_property_ui_text(prop, "Offset Frequency", "Offset every N rows"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "squash", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "custom4"); RNA_def_property_range(prop, 0.0f, 99.0f); RNA_def_property_ui_text(prop, "Squash Amount", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "squash_frequency", PROP_INT, PROP_NONE); RNA_def_property_int_sdna(prop, NULL, "custom2"); RNA_def_property_range(prop, 2, 99); RNA_def_property_ui_text(prop, "Squash Frequency", "Squash every N rows"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } /* -- Geometry Nodes --------------------------------------------------------- */ static void def_geo_boolean(StructRNA *srna) { PropertyRNA *prop; static const EnumPropertyItem rna_node_geometry_boolean_method_items[] = { {GEO_NODE_BOOLEAN_INTERSECT, "INTERSECT", 0, "Intersect", "Keep the part of the mesh that is common between all operands"}, {GEO_NODE_BOOLEAN_UNION, "UNION", 0, "Union", "Combine meshes in an additive way"}, {GEO_NODE_BOOLEAN_DIFFERENCE, "DIFFERENCE", 0, "Difference", "Combine meshes in a subtractive way"}, {0, NULL, 0, NULL, NULL}, }; prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "custom1"); RNA_def_property_enum_items(prop, rna_node_geometry_boolean_method_items); RNA_def_property_enum_default(prop, GEO_NODE_BOOLEAN_INTERSECT); RNA_def_property_ui_text(prop, "Operation", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_attribute_domain_size(StructRNA *srna) { PropertyRNA *prop = RNA_def_property(srna, "component", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "custom1"); RNA_def_property_enum_items(prop, rna_enum_geometry_component_type_items); RNA_def_property_enum_default(prop, GEO_COMPONENT_TYPE_MESH); RNA_def_property_ui_text(prop, "Component", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_curve_primitive_bezier_segment(StructRNA *srna) { static const EnumPropertyItem mode_items[] = { {GEO_NODE_CURVE_PRIMITIVE_BEZIER_SEGMENT_POSITION, "POSITION", ICON_NONE, "Position", "The start and end handles are fixed positions"}, {GEO_NODE_CURVE_PRIMITIVE_BEZIER_SEGMENT_OFFSET, "OFFSET", ICON_NONE, "Offset", "The start and end handles are offsets from the spline's control points"}, {0, NULL, 0, NULL, NULL}, }; PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometryCurvePrimitiveBezierSegment", "storage"); prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, mode_items); RNA_def_property_ui_text(prop, "Mode", "Method used to determine control handles"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_curve_sample(StructRNA *srna) { static EnumPropertyItem mode_items[] = { {GEO_NODE_CURVE_SAMPLE_FACTOR, "FACTOR", 0, "Factor", "Find sample positions on the curve using a factor of its total length"}, {GEO_NODE_CURVE_SAMPLE_LENGTH, "LENGTH", 0, "Length", "Find sample positions on the curve using a distance from its beginning"}, {0, NULL, 0, NULL, NULL}, }; RNA_def_struct_sdna_from(srna, "NodeGeometryCurveSample", "storage"); PropertyRNA *prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, mode_items); RNA_def_property_ui_text(prop, "Mode", "Method for sampling input"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_triangulate(StructRNA *srna) { PropertyRNA *prop; static const EnumPropertyItem rna_node_geometry_triangulate_quad_method_items[] = { {GEO_NODE_TRIANGULATE_QUAD_BEAUTY, "BEAUTY", 0, "Beauty", "Split the quads in nice triangles, slower method"}, {GEO_NODE_TRIANGULATE_QUAD_FIXED, "FIXED", 0, "Fixed", "Split the quads on the first and third vertices"}, {GEO_NODE_TRIANGULATE_QUAD_ALTERNATE, "FIXED_ALTERNATE", 0, "Fixed Alternate", "Split the quads on the 2nd and 4th vertices"}, {GEO_NODE_TRIANGULATE_QUAD_SHORTEDGE, "SHORTEST_DIAGONAL", 0, "Shortest Diagonal", "Split the quads along their shortest diagonal"}, {GEO_NODE_TRIANGULATE_QUAD_LONGEDGE, "LONGEST_DIAGONAL", 0, "Longest Diagonal", "Split the quads along their longest diagonal"}, {0, NULL, 0, NULL, NULL}, }; static const EnumPropertyItem rna_node_geometry_triangulate_ngon_method_items[] = { {GEO_NODE_TRIANGULATE_NGON_BEAUTY, "BEAUTY", 0, "Beauty", "Arrange the new triangles evenly (slow)"}, {GEO_NODE_TRIANGULATE_NGON_EARCLIP, "CLIP", 0, "Clip", "Split the polygons with an ear clipping algorithm"}, {0, NULL, 0, NULL, NULL}, }; prop = RNA_def_property(srna, "quad_method", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "custom1"); RNA_def_property_enum_items(prop, rna_node_geometry_triangulate_quad_method_items); RNA_def_property_enum_default(prop, GEO_NODE_TRIANGULATE_QUAD_SHORTEDGE); RNA_def_property_ui_text(prop, "Quad Method", "Method for splitting the quads into triangles"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "ngon_method", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "custom2"); RNA_def_property_enum_items(prop, rna_node_geometry_triangulate_ngon_method_items); RNA_def_property_enum_default(prop, GEO_NODE_TRIANGULATE_NGON_BEAUTY); RNA_def_property_ui_text(prop, "N-gon Method", "Method for splitting the n-gons into triangles"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_geo_subdivision_surface(StructRNA *srna) { PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometrySubdivisionSurface", "storage"); prop = RNA_def_property(srna, "uv_smooth", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "uv_smooth"); RNA_def_property_enum_items(prop, rna_enum_subdivision_uv_smooth_items); RNA_def_property_enum_default(prop, SUBSURF_UV_SMOOTH_PRESERVE_BOUNDARIES); RNA_def_property_ui_text(prop, "UV Smooth", "Controls how smoothing is applied to UVs"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "boundary_smooth", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "boundary_smooth"); RNA_def_property_enum_items(prop, rna_enum_subdivision_boundary_smooth_items); RNA_def_property_enum_default(prop, SUBSURF_BOUNDARY_SMOOTH_ALL); RNA_def_property_ui_text(prop, "Boundary Smooth", "Controls how open boundaries are smoothed"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_geo_accumulate_field(StructRNA *srna) { PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeAccumulateField", "storage"); prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "data_type"); RNA_def_property_enum_items(prop, rna_enum_attribute_type_items); RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_GeoNodeAccumulateField_type_itemf"); RNA_def_property_enum_default(prop, CD_PROP_FLOAT); RNA_def_property_ui_text(prop, "Data Type", "Type of data stored in attribute"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); prop = RNA_def_property(srna, "domain", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "domain"); RNA_def_property_enum_items(prop, rna_enum_attribute_domain_items); RNA_def_property_enum_default(prop, ATTR_DOMAIN_POINT); RNA_def_property_ui_text(prop, "Domain", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_fn_random_value(StructRNA *srna) { PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeRandomValue", "storage"); prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "data_type"); RNA_def_property_enum_items(prop, rna_enum_attribute_type_items); RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_FunctionNodeRandomValue_type_itemf"); RNA_def_property_enum_default(prop, CD_PROP_FLOAT); RNA_def_property_ui_text(prop, "Data Type", "Type of data stored in attribute"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_attribute_statistic(StructRNA *srna) { PropertyRNA *prop; prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "custom1"); RNA_def_property_enum_items(prop, rna_enum_attribute_type_items); RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_GeometryNodeAttributeStatistic_type_itemf"); RNA_def_property_enum_default(prop, CD_PROP_FLOAT); RNA_def_property_ui_text( prop, "Data Type", "The data type the attribute is converted to before calculating the results"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_GeometryNode_socket_update"); prop = RNA_def_property(srna, "domain", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "custom2"); RNA_def_property_enum_items(prop, rna_enum_attribute_domain_items); RNA_def_property_enum_default(prop, ATTR_DOMAIN_POINT); RNA_def_property_ui_text(prop, "Domain", "Which domain to read the data from"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_geo_extrude_mesh(StructRNA *srna) { PropertyRNA *prop; static const EnumPropertyItem mode_items[] = { {GEO_NODE_EXTRUDE_MESH_VERTICES, "VERTICES", 0, "Vertices", ""}, {GEO_NODE_EXTRUDE_MESH_EDGES, "EDGES", 0, "Edges", ""}, {GEO_NODE_EXTRUDE_MESH_FACES, "FACES", 0, "Faces", ""}, {0, NULL, 0, NULL, NULL}, }; RNA_def_struct_sdna_from(srna, "NodeGeometryExtrudeMesh", "storage"); prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "mode"); RNA_def_property_enum_items(prop, mode_items); RNA_def_property_enum_default(prop, GEO_NODE_EXTRUDE_MESH_FACES); RNA_def_property_ui_text(prop, "Mode", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_geo_distribute_points_on_faces(StructRNA *srna) { PropertyRNA *prop; static const EnumPropertyItem rna_node_geometry_distribute_points_on_faces_mode_items[] = { {GEO_NODE_POINT_DISTRIBUTE_POINTS_ON_FACES_RANDOM, "RANDOM", 0, "Random", "Distribute points randomly on the surface"}, {GEO_NODE_POINT_DISTRIBUTE_POINTS_ON_FACES_POISSON, "POISSON", 0, "Poisson Disk", "Distribute the points randomly on the surface while taking a minimum distance between " "points into account"}, {0, NULL, 0, NULL, NULL}, }; prop = RNA_def_property(srna, "distribute_method", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "custom1"); RNA_def_property_enum_items(prop, rna_node_geometry_distribute_points_on_faces_mode_items); RNA_def_property_enum_default(prop, GEO_NODE_POINT_DISTRIBUTE_POINTS_ON_FACES_RANDOM); RNA_def_property_ui_text(prop, "Distribution Method", "Method to use for scattering points"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_curve_spline_type(StructRNA *srna) { PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometryCurveSplineType", "storage"); prop = RNA_def_property(srna, "spline_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "spline_type"); RNA_def_property_enum_items(prop, rna_enum_curves_types); RNA_def_property_ui_text(prop, "Type", "The curve type to change the selected curves to"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_curve_set_handle_type(StructRNA *srna) { PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometryCurveSetHandles", "storage"); prop = RNA_def_property(srna, "handle_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "handle_type"); RNA_def_property_enum_items(prop, rna_node_geometry_curve_handle_type_items); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_node_geometry_curve_handle_side_items); RNA_def_property_ui_text(prop, "Mode", "Whether to update left and right handles"); RNA_def_property_flag(prop, PROP_ENUM_FLAG); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_curve_set_handle_positions(StructRNA *srna) { PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometrySetCurveHandlePositions", "storage"); prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_node_geometry_curve_handle_side_items); RNA_def_property_ui_text(prop, "Mode", "Whether to update left and right handles"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_curve_handle_type_selection(StructRNA *srna) { PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometryCurveSelectHandles", "storage"); prop = RNA_def_property(srna, "handle_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "handle_type"); RNA_def_property_enum_items(prop, rna_node_geometry_curve_handle_type_items); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_node_geometry_curve_handle_side_items); RNA_def_property_ui_text(prop, "Mode", "Whether to check the type of left and right handles"); RNA_def_property_flag(prop, PROP_ENUM_FLAG); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_curve_primitive_circle(StructRNA *srna) { static const EnumPropertyItem mode_items[] = { {GEO_NODE_CURVE_PRIMITIVE_CIRCLE_TYPE_POINTS, "POINTS", ICON_NONE, "Points", "Define the radius and location with three points"}, {GEO_NODE_CURVE_PRIMITIVE_CIRCLE_TYPE_RADIUS, "RADIUS", ICON_NONE, "Radius", "Define the radius with a float"}, {0, NULL, 0, NULL, NULL}, }; PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometryCurvePrimitiveCircle", "storage"); prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, mode_items); RNA_def_property_ui_text(prop, "Mode", "Method used to determine radius and placement"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_curve_primitive_arc(StructRNA *srna) { static const EnumPropertyItem mode_items[] = { {GEO_NODE_CURVE_PRIMITIVE_ARC_TYPE_POINTS, "POINTS", ICON_NONE, "Points", "Define arc by 3 points on circle. Arc is calculated between start and end points"}, {GEO_NODE_CURVE_PRIMITIVE_ARC_TYPE_RADIUS, "RADIUS", ICON_NONE, "Radius", "Define radius with a float"}, {0, NULL, 0, NULL, NULL}, }; PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometryCurvePrimitiveArc", "storage"); prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, mode_items); RNA_def_property_ui_text(prop, "Mode", "Method used to determine radius and placement"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_curve_primitive_line(StructRNA *srna) { static const EnumPropertyItem mode_items[] = { {GEO_NODE_CURVE_PRIMITIVE_LINE_MODE_POINTS, "POINTS", ICON_NONE, "Points", "Define the start and end points of the line"}, {GEO_NODE_CURVE_PRIMITIVE_LINE_MODE_DIRECTION, "DIRECTION", ICON_NONE, "Direction", "Define a line with a start point, direction and length"}, {0, NULL, 0, NULL, NULL}, }; PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometryCurvePrimitiveLine", "storage"); prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, mode_items); RNA_def_property_ui_text(prop, "Mode", "Method used to determine radius and placement"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_fn_rotate_euler(StructRNA *srna) { static const EnumPropertyItem type_items[] = { {FN_NODE_ROTATE_EULER_TYPE_AXIS_ANGLE, "AXIS_ANGLE", ICON_NONE, "Axis Angle", "Rotate around an axis by an angle"}, {FN_NODE_ROTATE_EULER_TYPE_EULER, "EULER", ICON_NONE, "Euler", "Rotate around the X, Y, and Z axes"}, {0, NULL, 0, NULL, NULL}, }; static const EnumPropertyItem space_items[] = { {FN_NODE_ROTATE_EULER_SPACE_OBJECT, "OBJECT", ICON_NONE, "Object", "Rotate the input rotation in the local space of the object"}, {FN_NODE_ROTATE_EULER_SPACE_LOCAL, "LOCAL", ICON_NONE, "Local", "Rotate the input rotation in its local space"}, {0, NULL, 0, NULL, NULL}, }; PropertyRNA *prop; prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "custom1"); RNA_def_property_enum_items(prop, type_items); RNA_def_property_ui_text(prop, "Type", "Method used to describe the rotation"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); prop = RNA_def_property(srna, "space", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "custom2"); RNA_def_property_enum_items(prop, space_items); RNA_def_property_ui_text(prop, "Space", "Base orientation for rotation"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_fn_align_euler_to_vector(StructRNA *srna) { static const EnumPropertyItem axis_items[] = { {FN_NODE_ALIGN_EULER_TO_VECTOR_AXIS_X, "X", ICON_NONE, "X", "Align the X axis with the vector"}, {FN_NODE_ALIGN_EULER_TO_VECTOR_AXIS_Y, "Y", ICON_NONE, "Y", "Align the Y axis with the vector"}, {FN_NODE_ALIGN_EULER_TO_VECTOR_AXIS_Z, "Z", ICON_NONE, "Z", "Align the Z axis with the vector"}, {0, NULL, 0, NULL, NULL}, }; static const EnumPropertyItem pivot_axis_items[] = { {FN_NODE_ALIGN_EULER_TO_VECTOR_PIVOT_AXIS_AUTO, "AUTO", ICON_NONE, "Auto", "Automatically detect the best rotation axis to rotate towards the vector"}, {FN_NODE_ALIGN_EULER_TO_VECTOR_PIVOT_AXIS_X, "X", ICON_NONE, "X", "Rotate around the local X axis"}, {FN_NODE_ALIGN_EULER_TO_VECTOR_PIVOT_AXIS_Y, "Y", ICON_NONE, "Y", "Rotate around the local Y axis"}, {FN_NODE_ALIGN_EULER_TO_VECTOR_PIVOT_AXIS_Z, "Z", ICON_NONE, "Z", "Rotate around the local Z axis"}, {0, NULL, 0, NULL, NULL}, }; PropertyRNA *prop; prop = RNA_def_property(srna, "axis", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "custom1"); RNA_def_property_enum_items(prop, axis_items); RNA_def_property_ui_text(prop, "Axis", "Axis to align to the vector"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "pivot_axis", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "custom2"); RNA_def_property_enum_items(prop, pivot_axis_items); RNA_def_property_ui_text(prop, "Pivot Axis", "Axis to rotate around"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_geo_object_info(StructRNA *srna) { PropertyRNA *prop; static const EnumPropertyItem rna_node_geometry_object_info_transform_space_items[] = { {GEO_NODE_TRANSFORM_SPACE_ORIGINAL, "ORIGINAL", 0, "Original", "Output the geometry relative to the input object transform, and the location, rotation " "and " "scale relative to the world origin"}, {GEO_NODE_TRANSFORM_SPACE_RELATIVE, "RELATIVE", 0, "Relative", "Bring the input object geometry, location, rotation and scale into the modified object, " "maintaining the relative position between the two objects in the scene"}, {0, NULL, 0, NULL, NULL}, }; RNA_def_struct_sdna_from(srna, "NodeGeometryObjectInfo", "storage"); prop = RNA_def_property(srna, "transform_space", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_node_geometry_object_info_transform_space_items); RNA_def_property_ui_text( prop, "Transform Space", "The transformation of the vector and geometry outputs"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations"); } static void def_geo_points_to_volume(StructRNA *srna) { PropertyRNA *prop; static EnumPropertyItem resolution_mode_items[] = { {GEO_NODE_POINTS_TO_VOLUME_RESOLUTION_MODE_AMOUNT, "VOXEL_AMOUNT", 0, "Amount", "Specify the approximate number of voxels along the diagonal"}, {GEO_NODE_POINTS_TO_VOLUME_RESOLUTION_MODE_SIZE, "VOXEL_SIZE", 0, "Size", "Specify the voxel side length"}, {0, NULL, 0, NULL, NULL}, }; RNA_def_struct_sdna_from(srna, "NodeGeometryPointsToVolume", "storage"); prop = RNA_def_property(srna, "resolution_mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, resolution_mode_items); RNA_def_property_ui_text(prop, "Resolution Mode", "How the voxel size is specified"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } +static void def_geo_distribute_points_in_volume(StructRNA *srna) +{ + PropertyRNA *prop; + + static const EnumPropertyItem mode_items[] = { + {GEO_NODE_DISTRIBUTE_POINTS_IN_VOLUME_DENSITY_RANDOM, + "DENSITY_RANDOM", + 0, + "Random", + "Distribute points randomly inside of the volume"}, + {GEO_NODE_DISTRIBUTE_POINTS_IN_VOLUME_DENSITY_GRID, + "DENSITY_GRID", + 0, + "Grid", + "Distribute the points in a grid pattern inside of the volume"}, + {0, NULL, 0, NULL, NULL}, + }; + + RNA_def_struct_sdna_from(srna, "NodeGeometryDistributePointsInVolume", "storage"); + prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); + RNA_def_property_enum_items(prop, mode_items); + RNA_def_property_ui_text(prop, "Distribution Method", "Method to use for scattering points"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); +} + static void def_geo_uv_unwrap(StructRNA *srna) { PropertyRNA *prop; static EnumPropertyItem rna_node_geometry_uv_unwrap_method_items[] = { {GEO_NODE_UV_UNWRAP_METHOD_ANGLE_BASED, "ANGLE_BASED", 0, "Angle Based", "This method gives a good 2D representation of a mesh"}, {GEO_NODE_UV_UNWRAP_METHOD_CONFORMAL, "CONFORMAL", 0, "Conformal", "Uses LSCM (Least Squares Conformal Mapping). This usually gives a less accurate UV " "mapping than Angle Based, but works better for simpler objects"}, {0, NULL, 0, NULL, NULL}, }; RNA_def_struct_sdna_from(srna, "NodeGeometryUVUnwrap", "storage"); prop = RNA_def_property(srna, "method", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_node_geometry_uv_unwrap_method_items); RNA_def_property_ui_text(prop, "Method", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_geo_collection_info(StructRNA *srna) { PropertyRNA *prop; static const EnumPropertyItem rna_node_geometry_collection_info_transform_space_items[] = { {GEO_NODE_TRANSFORM_SPACE_ORIGINAL, "ORIGINAL", 0, "Original", "Output the geometry relative to the collection offset"}, {GEO_NODE_TRANSFORM_SPACE_RELATIVE, "RELATIVE", 0, "Relative", "Bring the input collection geometry into the modified object, maintaining the relative " "position between the objects in the scene"}, {0, NULL, 0, NULL, NULL}, }; RNA_def_struct_sdna_from(srna, "NodeGeometryCollectionInfo", "storage"); prop = RNA_def_property(srna, "transform_space", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_node_geometry_collection_info_transform_space_items); RNA_def_property_ui_text(prop, "Transform Space", "The transformation of the geometry output"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations"); } static void def_geo_proximity(StructRNA *srna) { static const EnumPropertyItem target_element_items[] = { {GEO_NODE_PROX_TARGET_POINTS, "POINTS", ICON_NONE, "Points", "Calculate the proximity to the target's points (faster than the other modes)"}, {GEO_NODE_PROX_TARGET_EDGES, "EDGES", ICON_NONE, "Edges", "Calculate the proximity to the target's edges"}, {GEO_NODE_PROX_TARGET_FACES, "FACES", ICON_NONE, "Faces", "Calculate the proximity to the target's faces"}, {0, NULL, 0, NULL, NULL}, }; PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometryProximity", "storage"); prop = RNA_def_property(srna, "target_element", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, target_element_items); RNA_def_property_enum_default(prop, GEO_NODE_PROX_TARGET_FACES); RNA_def_property_ui_text( prop, "Target Geometry", "Element of the target geometry to calculate the distance from"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_volume_to_mesh(StructRNA *srna) { PropertyRNA *prop; static EnumPropertyItem resolution_mode_items[] = { {VOLUME_TO_MESH_RESOLUTION_MODE_GRID, "GRID", 0, "Grid", "Use resolution of the volume grid"}, {VOLUME_TO_MESH_RESOLUTION_MODE_VOXEL_AMOUNT, "VOXEL_AMOUNT", 0, "Amount", "Desired number of voxels along one axis"}, {VOLUME_TO_MESH_RESOLUTION_MODE_VOXEL_SIZE, "VOXEL_SIZE", 0, "Size", "Desired voxel side length"}, {0, NULL, 0, NULL, NULL}, }; RNA_def_struct_sdna_from(srna, "NodeGeometryVolumeToMesh", "storage"); prop = RNA_def_property(srna, "resolution_mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, resolution_mode_items); RNA_def_property_ui_text(prop, "Resolution Mode", "How the voxel size is specified"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_mesh_to_volume(StructRNA *srna) { PropertyRNA *prop; static EnumPropertyItem resolution_mode_items[] = { {MESH_TO_VOLUME_RESOLUTION_MODE_VOXEL_AMOUNT, "VOXEL_AMOUNT", 0, "Amount", "Desired number of voxels along one axis"}, {MESH_TO_VOLUME_RESOLUTION_MODE_VOXEL_SIZE, "VOXEL_SIZE", 0, "Size", "Desired voxel side length"}, {0, NULL, 0, NULL, NULL}, }; RNA_def_struct_sdna_from(srna, "NodeGeometryMeshToVolume", "storage"); prop = RNA_def_property(srna, "resolution_mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, resolution_mode_items); RNA_def_property_ui_text(prop, "Resolution Mode", "How the voxel size is specified"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_mesh_circle(StructRNA *srna) { PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometryMeshCircle", "storage"); prop = RNA_def_property(srna, "fill_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_node_geometry_mesh_circle_fill_type_items); RNA_def_property_ui_text(prop, "Fill Type", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_geo_mesh_cylinder(StructRNA *srna) { PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometryMeshCylinder", "storage"); prop = RNA_def_property(srna, "fill_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_node_geometry_mesh_circle_fill_type_items); RNA_def_property_ui_text(prop, "Fill Type", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_mesh_cone(StructRNA *srna) { PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometryMeshCone", "storage"); prop = RNA_def_property(srna, "fill_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_node_geometry_mesh_circle_fill_type_items); RNA_def_property_ui_text(prop, "Fill Type", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_merge_by_distance(StructRNA *srna) { PropertyRNA *prop; static EnumPropertyItem mode_items[] = { {GEO_NODE_MERGE_BY_DISTANCE_MODE_ALL, "ALL", 0, "All", "Merge all close selected points, whether or not they are connected"}, {GEO_NODE_MERGE_BY_DISTANCE_MODE_CONNECTED, "CONNECTED", 0, "Connected", "Only merge mesh vertices along existing edges. This method can be much faster"}, {0, NULL, 0, NULL, NULL}, }; RNA_def_struct_sdna_from(srna, "NodeGeometryMergeByDistance", "storage"); prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, mode_items); RNA_def_property_ui_text(prop, "Mode", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_mesh_line(StructRNA *srna) { PropertyRNA *prop; static EnumPropertyItem mode_items[] = { {GEO_NODE_MESH_LINE_MODE_OFFSET, "OFFSET", 0, "Offset", "Specify the offset from one vertex to the next"}, {GEO_NODE_MESH_LINE_MODE_END_POINTS, "END_POINTS", 0, "End Points", "Specify the line's start and end points"}, {0, NULL, 0, NULL, NULL}, }; static EnumPropertyItem count_mode_items[] = { {GEO_NODE_MESH_LINE_COUNT_TOTAL, "TOTAL", 0, "Count", "Specify the total number of vertices"}, {GEO_NODE_MESH_LINE_COUNT_RESOLUTION, "RESOLUTION", 0, "Resolution", "Specify the distance between vertices"}, {0, NULL, 0, NULL, NULL}, }; RNA_def_struct_sdna_from(srna, "NodeGeometryMeshLine", "storage"); prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, mode_items); RNA_def_property_ui_text(prop, "Mode", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); prop = RNA_def_property(srna, "count_mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, count_mode_items); RNA_def_property_ui_text(prop, "Count Mode", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_switch(StructRNA *srna) { PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeSwitch", "storage"); prop = RNA_def_property(srna, "input_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "input_type"); RNA_def_property_enum_items(prop, node_socket_data_type_items); RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_GeometryNodeSwitch_type_itemf"); RNA_def_property_ui_text(prop, "Input Type", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_curve_primitive_quadrilateral(StructRNA *srna) { PropertyRNA *prop; static EnumPropertyItem mode_items[] = { {GEO_NODE_CURVE_PRIMITIVE_QUAD_MODE_RECTANGLE, "RECTANGLE", 0, "Rectangle", "Create a rectangle"}, {GEO_NODE_CURVE_PRIMITIVE_QUAD_MODE_PARALLELOGRAM, "PARALLELOGRAM", 0, "Parallelogram", "Create a parallelogram"}, {GEO_NODE_CURVE_PRIMITIVE_QUAD_MODE_TRAPEZOID, "TRAPEZOID", 0, "Trapezoid", "Create a trapezoid"}, {GEO_NODE_CURVE_PRIMITIVE_QUAD_MODE_KITE, "KITE", 0, "Kite", "Create a Kite / Dart"}, {GEO_NODE_CURVE_PRIMITIVE_QUAD_MODE_POINTS, "POINTS", 0, "Points", "Create a quadrilateral from four points"}, {0, NULL, 0, NULL, NULL}, }; RNA_def_struct_sdna_from(srna, "NodeGeometryCurvePrimitiveQuad", "storage"); prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "mode"); RNA_def_property_enum_items(prop, mode_items); RNA_def_property_enum_default(prop, GEO_NODE_CURVE_PRIMITIVE_QUAD_MODE_RECTANGLE); RNA_def_property_ui_text(prop, "Mode", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_curve_resample(StructRNA *srna) { PropertyRNA *prop; static EnumPropertyItem mode_items[] = { {GEO_NODE_CURVE_RESAMPLE_EVALUATED, "EVALUATED", 0, "Evaluated", "Output the input spline's evaluated points, based on the resolution attribute for NURBS " "and Bezier splines. Poly splines are unchanged"}, {GEO_NODE_CURVE_RESAMPLE_COUNT, "COUNT", 0, "Count", "Sample the specified number of points along each spline"}, {GEO_NODE_CURVE_RESAMPLE_LENGTH, "LENGTH", 0, "Length", "Calculate the number of samples by splitting each spline into segments with the specified " "length"}, {0, NULL, 0, NULL, NULL}, }; RNA_def_struct_sdna_from(srna, "NodeGeometryCurveResample", "storage"); prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, mode_items); RNA_def_property_ui_text(prop, "Mode", "How to specify the amount of samples"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_curve_fillet(StructRNA *srna) { PropertyRNA *prop; static EnumPropertyItem mode_items[] = { {GEO_NODE_CURVE_FILLET_BEZIER, "BEZIER", 0, "Bezier", "Align Bezier handles to create circular arcs at each control point"}, {GEO_NODE_CURVE_FILLET_POLY, "POLY", 0, "Poly", "Add control points along a circular arc (handle type is vector if Bezier Spline)"}, {0, NULL, 0, NULL, NULL}, }; RNA_def_struct_sdna_from(srna, "NodeGeometryCurveFillet", "storage"); prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, mode_items); RNA_def_property_ui_text(prop, "Mode", "How to choose number of vertices on fillet"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_curve_to_points(StructRNA *srna) { PropertyRNA *prop; static EnumPropertyItem mode_items[] = { {GEO_NODE_CURVE_RESAMPLE_EVALUATED, "EVALUATED", 0, "Evaluated", "Create points from the curve's evaluated points, based on the resolution attribute for " "NURBS and Bezier splines"}, {GEO_NODE_CURVE_RESAMPLE_COUNT, "COUNT", 0, "Count", "Sample each spline by evenly distributing the specified number of points"}, {GEO_NODE_CURVE_RESAMPLE_LENGTH, "LENGTH", 0, "Length", "Sample each spline by splitting it into segments with the specified length"}, {0, NULL, 0, NULL, NULL}, }; RNA_def_struct_sdna_from(srna, "NodeGeometryCurveToPoints", "storage"); prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, mode_items); RNA_def_property_ui_text(prop, "Mode", "How to generate points from the input curve"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_mesh_to_points(StructRNA *srna) { PropertyRNA *prop; static EnumPropertyItem mode_items[] = { {GEO_NODE_MESH_TO_POINTS_VERTICES, "VERTICES", 0, "Vertices", "Create a point in the point cloud for each selected vertex"}, {GEO_NODE_MESH_TO_POINTS_EDGES, "EDGES", 0, "Edges", "Create a point in the point cloud for each selected edge"}, {GEO_NODE_MESH_TO_POINTS_FACES, "FACES", 0, "Faces", "Create a point in the point cloud for each selected face"}, {GEO_NODE_MESH_TO_POINTS_CORNERS, "CORNERS", 0, "Corners", "Create a point in the point cloud for each selected face corner"}, {0, NULL, 0, NULL, NULL}, }; RNA_def_struct_sdna_from(srna, "NodeGeometryMeshToPoints", "storage"); prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, mode_items); RNA_def_property_ui_text(prop, "Mode", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_geo_curve_trim(StructRNA *srna) { PropertyRNA *prop; static EnumPropertyItem mode_items[] = { {GEO_NODE_CURVE_SAMPLE_FACTOR, "FACTOR", 0, "Factor", "Find the endpoint positions using a factor of each spline's length"}, {GEO_NODE_CURVE_RESAMPLE_LENGTH, "LENGTH", 0, "Length", "Find the endpoint positions using a length from the start of each spline"}, {0, NULL, 0, NULL, NULL}, }; RNA_def_struct_sdna_from(srna, "NodeGeometryCurveTrim", "storage"); prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, mode_items); RNA_def_property_ui_text(prop, "Mode", "How to find endpoint positions for the trimmed spline"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } static void def_geo_transfer_attribute(StructRNA *srna) { static EnumPropertyItem mapping_items[] = { {GEO_NODE_ATTRIBUTE_TRANSFER_NEAREST_FACE_INTERPOLATED, "NEAREST_FACE_INTERPOLATED", 0, "Nearest Face Interpolated", "Transfer the attribute from the nearest face on a surface (loose points and edges are " "ignored)"}, {GEO_NODE_ATTRIBUTE_TRANSFER_NEAREST, "NEAREST", 0, "Nearest", "Transfer the element from the nearest element (using face and edge centers for the " "distance computation)"}, {GEO_NODE_ATTRIBUTE_TRANSFER_INDEX, "INDEX", 0, "Index", "Transfer the data from the element with the corresponding index in the target geometry"}, {0, NULL, 0, NULL, NULL}, }; PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometryTransferAttribute", "storage"); prop = RNA_def_property(srna, "mapping", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "mode"); RNA_def_property_enum_items(prop, mapping_items); RNA_def_property_ui_text(prop, "Mapping", "Mapping between geometries"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_enum_attribute_type_items); RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_NodeGeometryTransferAttribute_type_itemf"); RNA_def_property_enum_default(prop, CD_PROP_FLOAT); RNA_def_property_ui_text(prop, "Data Type", "The type for the source and result data"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); prop = RNA_def_property(srna, "domain", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_enum_attribute_domain_items); RNA_def_property_enum_default(prop, ATTR_DOMAIN_POINT); RNA_def_property_ui_text(prop, "Domain", "The domain to use on the target geometry"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_geo_input_material(StructRNA *srna) { PropertyRNA *prop; prop = RNA_def_property(srna, "material", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_sdna(prop, NULL, "id"); RNA_def_property_struct_type(prop, "Material"); RNA_def_property_flag(prop, PROP_EDITABLE); RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY); RNA_def_property_ui_text(prop, "Material", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_geo_raycast(StructRNA *srna) { static EnumPropertyItem mapping_items[] = { {GEO_NODE_RAYCAST_INTERPOLATED, "INTERPOLATED", 0, "Interpolated", "Interpolate the attribute from the corners of the hit face"}, {GEO_NODE_RAYCAST_NEAREST, "NEAREST", 0, "Nearest", "Use the attribute value of the closest mesh element"}, {0, NULL, 0, NULL, NULL}, }; PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometryRaycast", "storage"); prop = RNA_def_property(srna, "mapping", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, mapping_items); RNA_def_property_ui_text(prop, "Mapping", "Mapping from the target geometry to hit points"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_enum_attribute_type_items); RNA_def_property_enum_funcs( prop, NULL, NULL, "rna_GeometryNodeAttributeType_type_with_socket_itemf"); RNA_def_property_enum_default(prop, CD_PROP_FLOAT); RNA_def_property_ui_text(prop, "Data Type", "Type of data stored in attribute"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_GeometryNode_socket_update"); } static void def_geo_curve_fill(StructRNA *srna) { static const EnumPropertyItem mode_items[] = { {GEO_NODE_CURVE_FILL_MODE_TRIANGULATED, "TRIANGLES", 0, "Triangles", ""}, {GEO_NODE_CURVE_FILL_MODE_NGONS, "NGONS", 0, "N-gons", ""}, {0, NULL, 0, NULL, NULL}, }; PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometryCurveFill", "storage"); prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "mode"); RNA_def_property_enum_items(prop, mode_items); RNA_def_property_ui_text(prop, "Mode", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_geo_store_named_attribute(StructRNA *srna) { PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometryStoreNamedAttribute", "storage"); prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_enum_attribute_type_items); RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_GeometryNodeAttributeType_type_itemf"); RNA_def_property_enum_default(prop, CD_PROP_FLOAT); RNA_def_property_ui_text(prop, "Data Type", "Type of data stored in attribute"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_GeometryNode_socket_update"); prop = RNA_def_property(srna, "domain", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_enum_attribute_domain_items); RNA_def_property_enum_default(prop, ATTR_DOMAIN_POINT); RNA_def_property_ui_text(prop, "Domain", "Which domain to store the data in"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_geo_input_named_attribute(StructRNA *srna) { PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometryInputNamedAttribute", "storage"); prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_enum_attribute_type_items); RNA_def_property_enum_funcs( prop, NULL, NULL, "rna_GeometryNodeAttributeType_type_with_socket_itemf"); RNA_def_property_enum_default(prop, CD_PROP_FLOAT); RNA_def_property_ui_text(prop, "Data Type", "The data type used to read the attribute values"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_GeometryNode_socket_update"); } static void def_geo_attribute_capture(StructRNA *srna) { PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometryAttributeCapture", "storage"); prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_enum_attribute_type_items); RNA_def_property_enum_funcs( prop, NULL, NULL, "rna_GeometryNodeAttributeType_type_with_socket_itemf"); RNA_def_property_enum_default(prop, CD_PROP_FLOAT); RNA_def_property_ui_text(prop, "Data Type", "Type of data stored in attribute"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_GeometryNode_socket_update"); prop = RNA_def_property(srna, "domain", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_enum_attribute_domain_items); RNA_def_property_enum_default(prop, ATTR_DOMAIN_POINT); RNA_def_property_ui_text(prop, "Domain", "Which domain to store the data in"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_geo_delete_geometry(StructRNA *srna) { PropertyRNA *prop; static const EnumPropertyItem mode_items[] = { {GEO_NODE_DELETE_GEOMETRY_MODE_ALL, "ALL", 0, "All", ""}, {GEO_NODE_DELETE_GEOMETRY_MODE_EDGE_FACE, "EDGE_FACE", 0, "Only Edges & Faces", ""}, {GEO_NODE_DELETE_GEOMETRY_MODE_ONLY_FACE, "ONLY_FACE", 0, "Only Faces", ""}, {0, NULL, 0, NULL, NULL}, }; RNA_def_struct_sdna_from(srna, "NodeGeometryDeleteGeometry", "storage"); prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, mode_items); RNA_def_property_enum_default(prop, GEO_NODE_DELETE_GEOMETRY_MODE_ALL); RNA_def_property_ui_text(prop, "Mode", "Which parts of the mesh component to delete"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "domain", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_enum_attribute_domain_without_corner_items); RNA_def_property_enum_default(prop, ATTR_DOMAIN_POINT); RNA_def_property_ui_text(prop, "Domain", "Which domain to delete in"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_geo_duplicate_elements(StructRNA *srna) { PropertyRNA *prop; static const EnumPropertyItem domain_items[] = { {ATTR_DOMAIN_POINT, "POINT", 0, "Point", ""}, {ATTR_DOMAIN_EDGE, "EDGE", 0, "Edge", ""}, {ATTR_DOMAIN_FACE, "FACE", 0, "Face", ""}, {ATTR_DOMAIN_CURVE, "SPLINE", 0, "Spline", ""}, {ATTR_DOMAIN_INSTANCE, "INSTANCE", 0, "Instance", ""}, {0, NULL, 0, NULL, NULL}, }; RNA_def_struct_sdna_from(srna, "NodeGeometryDuplicateElements", "storage"); prop = RNA_def_property(srna, "domain", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, domain_items); RNA_def_property_enum_default(prop, ATTR_DOMAIN_POINT); RNA_def_property_ui_text(prop, "Domain", "Which domain to duplicate"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_geo_string_to_curves(StructRNA *srna) { static const EnumPropertyItem rna_node_geometry_string_to_curves_overflow_items[] = { {GEO_NODE_STRING_TO_CURVES_MODE_OVERFLOW, "OVERFLOW", ICON_NONE, "Overflow", "Let the text use more space than the specified height"}, {GEO_NODE_STRING_TO_CURVES_MODE_SCALE_TO_FIT, "SCALE_TO_FIT", ICON_NONE, "Scale To Fit", "Scale the text size to fit inside the width and height"}, {GEO_NODE_STRING_TO_CURVES_MODE_TRUNCATE, "TRUNCATE", ICON_NONE, "Truncate", "Only output curves that fit within the width and height. Output the remainder to the " "\"Remainder\" output"}, {0, NULL, 0, NULL, NULL}, }; static const EnumPropertyItem rna_node_geometry_string_to_curves_align_x_items[] = { {GEO_NODE_STRING_TO_CURVES_ALIGN_X_LEFT, "LEFT", ICON_ALIGN_LEFT, "Left", "Align text to the left"}, {GEO_NODE_STRING_TO_CURVES_ALIGN_X_CENTER, "CENTER", ICON_ALIGN_CENTER, "Center", "Align text to the center"}, {GEO_NODE_STRING_TO_CURVES_ALIGN_X_RIGHT, "RIGHT", ICON_ALIGN_RIGHT, "Right", "Align text to the right"}, {GEO_NODE_STRING_TO_CURVES_ALIGN_X_JUSTIFY, "JUSTIFY", ICON_ALIGN_JUSTIFY, "Justify", "Align text to the left and the right"}, {GEO_NODE_STRING_TO_CURVES_ALIGN_X_FLUSH, "FLUSH", ICON_ALIGN_FLUSH, "Flush", "Align text to the left and the right, with equal character spacing"}, {0, NULL, 0, NULL, NULL}, }; static const EnumPropertyItem rna_node_geometry_string_to_curves_align_y_items[] = { {GEO_NODE_STRING_TO_CURVES_ALIGN_Y_TOP_BASELINE, "TOP_BASELINE", ICON_ALIGN_TOP, "Top Baseline", "Align text to the top baseline"}, {GEO_NODE_STRING_TO_CURVES_ALIGN_Y_TOP, "TOP", ICON_ALIGN_TOP, "Top", "Align text to the top"}, {GEO_NODE_STRING_TO_CURVES_ALIGN_Y_MIDDLE, "MIDDLE", ICON_ALIGN_MIDDLE, "Middle", "Align text to the middle"}, {GEO_NODE_STRING_TO_CURVES_ALIGN_Y_BOTTOM_BASELINE, "BOTTOM_BASELINE", ICON_ALIGN_BOTTOM, "Bottom Baseline", "Align text to the bottom baseline"}, {GEO_NODE_STRING_TO_CURVES_ALIGN_Y_BOTTOM, "BOTTOM", ICON_ALIGN_BOTTOM, "Bottom", "Align text to the bottom"}, {0, NULL, 0, NULL, NULL}, }; static const EnumPropertyItem rna_node_geometry_string_to_curves_pivot_mode[] = { {GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_MIDPOINT, "MIDPOINT", 0, "Midpoint", "Midpoint"}, {GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_TOP_LEFT, "TOP_LEFT", 0, "Top Left", "Top Left"}, {GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_TOP_CENTER, "TOP_CENTER", 0, "Top Center", "Top Center"}, {GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_TOP_RIGHT, "TOP_RIGHT", 0, "Top Right", "Top Right"}, {GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_BOTTOM_LEFT, "BOTTOM_LEFT", 0, "Bottom Left", "Bottom Left"}, {GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_BOTTOM_CENTER, "BOTTOM_CENTER", 0, "Bottom Center", "Bottom Center"}, {GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_BOTTOM_RIGHT, "BOTTOM_RIGHT", 0, "Bottom Right", "Bottom Right"}, {0, NULL, 0, NULL, NULL}, }; PropertyRNA *prop; prop = RNA_def_property(srna, "font", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_sdna(prop, NULL, "id"); RNA_def_property_struct_type(prop, "VectorFont"); RNA_def_property_ui_text(prop, "Font", "Font of the text. Falls back to the UI font by default"); RNA_def_property_flag(prop, PROP_EDITABLE); RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); RNA_def_struct_sdna_from(srna, "NodeGeometryStringToCurves", "storage"); prop = RNA_def_property(srna, "overflow", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "overflow"); RNA_def_property_enum_items(prop, rna_node_geometry_string_to_curves_overflow_items); RNA_def_property_enum_default(prop, GEO_NODE_STRING_TO_CURVES_MODE_OVERFLOW); RNA_def_property_ui_text(prop, "Overflow", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); prop = RNA_def_property(srna, "align_x", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "align_x"); RNA_def_property_enum_items(prop, rna_node_geometry_string_to_curves_align_x_items); RNA_def_property_enum_default(prop, GEO_NODE_STRING_TO_CURVES_ALIGN_X_LEFT); RNA_def_property_ui_text(prop, "Align X", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "align_y", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "align_y"); RNA_def_property_enum_items(prop, rna_node_geometry_string_to_curves_align_y_items); RNA_def_property_enum_default(prop, GEO_NODE_STRING_TO_CURVES_ALIGN_Y_TOP_BASELINE); RNA_def_property_ui_text(prop, "Align Y", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "pivot_mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "pivot_mode"); RNA_def_property_enum_items(prop, rna_node_geometry_string_to_curves_pivot_mode); RNA_def_property_enum_default(prop, GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_BOTTOM_LEFT); RNA_def_property_ui_text(prop, "Pivot Point", "Pivot point position relative to character"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_geo_separate_geometry(StructRNA *srna) { PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometrySeparateGeometry", "storage"); prop = RNA_def_property(srna, "domain", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_enum_attribute_domain_without_corner_items); RNA_def_property_enum_default(prop, ATTR_DOMAIN_POINT); RNA_def_property_ui_text(prop, "Domain", "Which domain to separate on"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } static void def_geo_viewer(StructRNA *srna) { PropertyRNA *prop; RNA_def_struct_sdna_from(srna, "NodeGeometryViewer", "storage"); prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_enum_attribute_type_items); RNA_def_property_enum_funcs( prop, NULL, NULL, "rna_GeometryNodeAttributeType_type_with_socket_itemf"); RNA_def_property_enum_default(prop, CD_PROP_FLOAT); RNA_def_property_ui_text(prop, "Data Type", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_GeometryNode_socket_update"); } static void def_geo_realize_instances(StructRNA *srna) { PropertyRNA *prop; prop = RNA_def_property(srna, "legacy_behavior", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "custom1", GEO_NODE_REALIZE_INSTANCES_LEGACY_BEHAVIOR); RNA_def_property_ui_text( prop, "Legacy Behavior", "Behave like before instance attributes existed"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_GeometryNode_socket_update"); } static void def_geo_field_at_index(StructRNA *srna) { PropertyRNA *prop; prop = RNA_def_property(srna, "domain", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "custom1"); RNA_def_property_enum_items(prop, rna_enum_attribute_domain_items); RNA_def_property_ui_text(prop, "Domain", "Domain the field is evaluated in"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_GeometryNode_socket_update"); prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "custom2"); RNA_def_property_enum_items(prop, rna_enum_attribute_type_items); RNA_def_property_enum_funcs( prop, NULL, NULL, "rna_GeometryNodeAttributeType_type_with_socket_itemf"); RNA_def_property_ui_text(prop, "Data Type", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_GeometryNode_socket_update"); } static void def_geo_field_on_domain(StructRNA *srna) { PropertyRNA *prop; prop = RNA_def_property(srna, "domain", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "custom1"); RNA_def_property_enum_items(prop, rna_enum_attribute_domain_items); RNA_def_property_ui_text(prop, "Domain", "Domain the field is evaluated in"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_GeometryNode_socket_update"); prop = RNA_def_property(srna, "data_type", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "custom2"); RNA_def_property_enum_items(prop, rna_enum_attribute_type_items); RNA_def_property_enum_funcs( prop, NULL, NULL, "rna_GeometryNodeAttributeType_type_with_socket_itemf"); RNA_def_property_ui_text(prop, "Data Type", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_GeometryNode_socket_update"); } static void def_geo_scale_elements(StructRNA *srna) { PropertyRNA *prop; static const EnumPropertyItem domain_items[] = { {ATTR_DOMAIN_FACE, "FACE", ICON_NONE, "Face", "Scale individual faces or neighboring face islands"}, {ATTR_DOMAIN_EDGE, "EDGE", ICON_NONE, "Edge", "Scale individual edges or neighboring edge islands"}, {0, NULL, 0, NULL, NULL}, }; static const EnumPropertyItem scale_mode_items[] = { {GEO_NODE_SCALE_ELEMENTS_UNIFORM, "UNIFORM", ICON_NONE, "Uniform", "Scale elements by the same factor in every direction"}, {GEO_NODE_SCALE_ELEMENTS_SINGLE_AXIS, "SINGLE_AXIS", ICON_NONE, "Single Axis", "Scale elements in a single direction"}, {0, NULL, 0, NULL, NULL}, }; prop = RNA_def_property(srna, "domain", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "custom1"); RNA_def_property_enum_items(prop, domain_items); RNA_def_property_enum_default(prop, ATTR_DOMAIN_FACE); RNA_def_property_ui_text(prop, "Domain", "Element type to transform"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_GeometryNode_socket_update"); prop = RNA_def_property(srna, "scale_mode", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "custom2"); RNA_def_property_enum_items(prop, scale_mode_items); RNA_def_property_ui_text(prop, "Scale Mode", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_GeometryNode_socket_update"); } /* -------------------------------------------------------------------------- */ static void rna_def_shader_node(BlenderRNA *brna) { StructRNA *srna; srna = RNA_def_struct(brna, "ShaderNode", "NodeInternal"); RNA_def_struct_ui_text(srna, "Shader Node", "Material shader node"); RNA_def_struct_sdna(srna, "bNode"); RNA_def_struct_register_funcs(srna, "rna_ShaderNode_register", "rna_Node_unregister", NULL); } static void rna_def_compositor_node(BlenderRNA *brna) { StructRNA *srna; FunctionRNA *func; srna = RNA_def_struct(brna, "CompositorNode", "NodeInternal"); RNA_def_struct_ui_text(srna, "Compositor Node", ""); RNA_def_struct_sdna(srna, "bNode"); RNA_def_struct_register_funcs(srna, "rna_CompositorNode_register", "rna_Node_unregister", NULL); /* compositor node need_exec flag */ func = RNA_def_function(srna, "tag_need_exec", "rna_CompositorNode_tag_need_exec"); RNA_def_function_ui_description(func, "Tag the node for compositor update"); def_cmp_cryptomatte_entry(brna); } static void rna_def_texture_node(BlenderRNA *brna) { StructRNA *srna; srna = RNA_def_struct(brna, "TextureNode", "NodeInternal"); RNA_def_struct_ui_text(srna, "Texture Node", ""); RNA_def_struct_sdna(srna, "bNode"); RNA_def_struct_register_funcs(srna, "rna_TextureNode_register", "rna_Node_unregister", NULL); } static void rna_def_geometry_node(BlenderRNA *brna) { StructRNA *srna; srna = RNA_def_struct(brna, "GeometryNode", "NodeInternal"); RNA_def_struct_ui_text(srna, "Geometry Node", ""); RNA_def_struct_sdna(srna, "bNode"); RNA_def_struct_register_funcs(srna, "rna_GeometryNode_register", "rna_Node_unregister", NULL); } static void rna_def_function_node(BlenderRNA *brna) { StructRNA *srna; srna = RNA_def_struct(brna, "FunctionNode", "NodeInternal"); RNA_def_struct_ui_text(srna, "Function Node", ""); RNA_def_struct_sdna(srna, "bNode"); RNA_def_struct_register_funcs(srna, "rna_FunctionNode_register", "rna_Node_unregister", NULL); } diff --git a/source/blender/nodes/NOD_geometry.h b/source/blender/nodes/NOD_geometry.h index 8f15add33fd..9441175bb52 100644 --- a/source/blender/nodes/NOD_geometry.h +++ b/source/blender/nodes/NOD_geometry.h @@ -1,148 +1,149 @@ /* SPDX-License-Identifier: GPL-2.0-or-later */ #pragma once #include "BKE_node.h" #ifdef __cplusplus extern "C" { #endif extern struct bNodeTreeType *ntreeType_Geometry; void register_node_tree_type_geo(void); void register_node_type_geo_group(void); void register_node_type_geo_custom_group(bNodeType *ntype); void register_node_type_geo_accumulate_field(void); void register_node_type_geo_attribute_capture(void); void register_node_type_geo_attribute_domain_size(void); void register_node_type_geo_attribute_separate_xyz(void); void register_node_type_geo_attribute_statistic(void); void register_node_type_geo_boolean(void); void register_node_type_geo_bounding_box(void); void register_node_type_geo_collection_info(void); void register_node_type_geo_convex_hull(void); void register_node_type_geo_curve_endpoint_selection(void); void register_node_type_geo_curve_fill(void); void register_node_type_geo_curve_fillet(void); void register_node_type_geo_curve_handle_type_selection(void); void register_node_type_geo_curve_length(void); void register_node_type_geo_curve_primitive_arc(void); void register_node_type_geo_curve_primitive_bezier_segment(void); void register_node_type_geo_curve_primitive_circle(void); void register_node_type_geo_curve_primitive_line(void); void register_node_type_geo_curve_primitive_quadratic_bezier(void); void register_node_type_geo_curve_primitive_quadrilateral(void); void register_node_type_geo_curve_primitive_spiral(void); void register_node_type_geo_curve_primitive_star(void); void register_node_type_geo_curve_resample(void); void register_node_type_geo_curve_reverse(void); void register_node_type_geo_curve_sample(void); void register_node_type_geo_curve_set_handle_type(void); void register_node_type_geo_curve_spline_parameter(void); void register_node_type_geo_curve_spline_type(void); void register_node_type_geo_curve_subdivide(void); void register_node_type_geo_curve_to_mesh(void); void register_node_type_geo_curve_to_points(void); void register_node_type_geo_curve_trim(void); void register_node_type_geo_delete_geometry(void); void register_node_type_geo_duplicate_elements(void); void register_node_type_geo_distribute_points_on_faces(void); void register_node_type_geo_dual_mesh(void); void register_node_type_geo_edge_split(void); void register_node_type_geo_extrude_mesh(void); void register_node_type_geo_field_at_index(void); void register_node_type_geo_field_on_domain(void); void register_node_type_geo_flip_faces(void); void register_node_type_geo_geometry_to_instance(void); void register_node_type_geo_image_texture(void); void register_node_type_geo_input_named_attribute(void); void register_node_type_geo_input_curve_handles(void); void register_node_type_geo_input_curve_tilt(void); void register_node_type_geo_input_id(void); void register_node_type_geo_input_index(void); void register_node_type_geo_input_instance_rotation(void); void register_node_type_geo_input_instance_scale(void); void register_node_type_geo_input_material_index(void); void register_node_type_geo_input_material(void); void register_node_type_geo_input_mesh_edge_angle(void); void register_node_type_geo_input_mesh_edge_neighbors(void); void register_node_type_geo_input_mesh_edge_vertices(void); void register_node_type_geo_input_mesh_face_area(void); void register_node_type_geo_input_mesh_face_is_planar(void); void register_node_type_geo_input_mesh_face_neighbors(void); void register_node_type_geo_input_mesh_island(void); void register_node_type_geo_input_mesh_vertex_neighbors(void); void register_node_type_geo_input_normal(void); void register_node_type_geo_input_position(void); void register_node_type_geo_input_radius(void); void register_node_type_geo_input_scene_time(void); void register_node_type_geo_input_shade_smooth(void); void register_node_type_geo_input_spline_cyclic(void); void register_node_type_geo_input_spline_length(void); void register_node_type_geo_input_spline_resolution(void); void register_node_type_geo_input_tangent(void); void register_node_type_geo_instance_on_points(void); void register_node_type_geo_instances_to_points(void); void register_node_type_geo_is_viewport(void); void register_node_type_geo_join_geometry(void); void register_node_type_geo_material_replace(void); void register_node_type_geo_material_selection(void); void register_node_type_geo_merge_by_distance(void); void register_node_type_geo_mesh_primitive_circle(void); void register_node_type_geo_mesh_primitive_cone(void); void register_node_type_geo_mesh_primitive_cube(void); void register_node_type_geo_mesh_primitive_cylinder(void); void register_node_type_geo_mesh_primitive_grid(void); void register_node_type_geo_mesh_primitive_ico_sphere(void); void register_node_type_geo_mesh_primitive_line(void); void register_node_type_geo_mesh_primitive_uv_sphere(void); void register_node_type_geo_mesh_subdivide(void); void register_node_type_geo_mesh_to_curve(void); void register_node_type_geo_mesh_to_points(void); void register_node_type_geo_mesh_to_volume(void); void register_node_type_geo_object_info(void); void register_node_type_geo_points(void); void register_node_type_geo_points_to_vertices(void); void register_node_type_geo_points_to_volume(void); void register_node_type_geo_proximity(void); void register_node_type_geo_raycast(void); void register_node_type_geo_realize_instances(void); void register_node_type_geo_remove_attribute(void); void register_node_type_geo_rotate_instances(void); void register_node_type_geo_scale_elements(void); void register_node_type_geo_scale_instances(void); void register_node_type_geo_select_by_handle_type(void); void register_node_type_geo_separate_components(void); void register_node_type_geo_separate_geometry(void); void register_node_type_geo_set_curve_handles(void); void register_node_type_geo_set_curve_radius(void); void register_node_type_geo_set_curve_tilt(void); void register_node_type_geo_set_id(void); void register_node_type_geo_set_material_index(void); void register_node_type_geo_set_material(void); void register_node_type_geo_set_point_radius(void); void register_node_type_geo_set_position(void); void register_node_type_geo_set_shade_smooth(void); void register_node_type_geo_set_spline_cyclic(void); void register_node_type_geo_set_spline_resolution(void); void register_node_type_geo_store_named_attribute(void); void register_node_type_geo_string_join(void); void register_node_type_geo_string_to_curves(void); void register_node_type_geo_subdivision_surface(void); void register_node_type_geo_switch(void); void register_node_type_geo_transfer_attribute(void); void register_node_type_geo_transform(void); void register_node_type_geo_translate_instances(void); void register_node_type_geo_triangulate(void); void register_node_type_geo_viewer(void); void register_node_type_geo_volume_cube(void); void register_node_type_geo_volume_to_mesh(void); void register_node_type_geo_uv_pack_islands(void); void register_node_type_geo_uv_unwrap(void); +void register_node_type_geo_distribute_points_in_volume(void); #ifdef __cplusplus } #endif diff --git a/source/blender/nodes/NOD_static_types.h b/source/blender/nodes/NOD_static_types.h index 609791ad091..3d5d78358cc 100644 --- a/source/blender/nodes/NOD_static_types.h +++ b/source/blender/nodes/NOD_static_types.h @@ -1,411 +1,412 @@ /* SPDX-License-Identifier: GPL-2.0-or-later */ /** \file * \ingroup nodes */ /* intentionally no include guard */ /* Keep aligned args for readability. */ /* clang-format off */ /* Empty definitions for undefined macros to avoid warnings */ #ifndef DefNode #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) #endif /* WARNING! If you edit those strings, please do the same in relevant nodes files (under blender/nodes/...)! */ /* Tree type Node ID RNA def function Enum name Struct name UI Name UI Description */ DefNode(Node, NODE_FRAME, def_frame, "FRAME", Frame, "Frame", "Collect related nodes together in a common area.\nFrames are useful when a node setup becomes large and confusing yet the re-usability of a Node Group is not required") DefNode(Node, NODE_GROUP, def_group, "GROUP", Group, "Group", "") DefNode(Node, NODE_GROUP_INPUT, def_group_input, "GROUP_INPUT", GroupInput, "Group Input", "While inside a group, expose connected data as sockets in the node gruop interface") DefNode(Node, NODE_GROUP_OUTPUT, def_group_output, "GROUP_OUTPUT", GroupOutput, "Group Output", "While inside a group, output connected data") DefNode(Node, NODE_REROUTE, 0, "REROUTE", Reroute, "Reroute", "Used for organizing.\nReroute looks and behaves much like a socket on other nodes in that it supports one input connection while allowing multiple output connections") DefNode(ShaderNode, SH_NODE_RGB, 0, "RGB", RGB, "RGB", "A color picker") DefNode(ShaderNode, SH_NODE_VALUE, 0, "VALUE", Value, "Value", "A node to input numerical values to other nodes in the tree") DefNode(ShaderNode, SH_NODE_MIX_RGB, def_mix_rgb, "MIX_RGB", MixRGB, "MixRGB", "Mix colors by working on the individual and corresponding pixels of the two input colors") DefNode(ShaderNode, SH_NODE_VALTORGB, def_colorramp, "VALTORGB", ValToRGB, "ColorRamp", "Map values to colors with the use of a gradient") DefNode(ShaderNode, SH_NODE_RGBTOBW, 0, "RGBTOBW", RGBToBW, "RGB to BW", "Convert an RGB color image to a grayscale by the luminance") DefNode(ShaderNode, SH_NODE_SHADERTORGB, 0, "SHADERTORGB", ShaderToRGB, "Shader to RGB", "Convert rendering effect (such as light and shadow) to color.\nTypically used for non-photorealistic rendering, to apply additional effects on the output of BSDFs.\nFor example, a color ramp on the output of a diffuse BSDF can be used to create a flexible toon shader.\nNote: only supported for Eevee") DefNode(ShaderNode, SH_NODE_NORMAL, 0, "NORMAL", Normal, "Normal", "Generate a normal vector and a dot product") DefNode(ShaderNode, SH_NODE_GAMMA, 0, "GAMMA", Gamma, "Gamma", "Apply a gamma correction") DefNode(ShaderNode, SH_NODE_BRIGHTCONTRAST, 0, "BRIGHTCONTRAST", BrightContrast, "Bright Contrast", "Control the brightness and contrast of the input color") DefNode(ShaderNode, SH_NODE_MAPPING, def_sh_mapping, "MAPPING", Mapping, "Mapping", "Transform the input vector by applying translation, rotation, and scaling") DefNode(ShaderNode, SH_NODE_CURVE_VEC, def_vector_curve, "CURVE_VEC", VectorCurve, "Vector Curves", "Map an input vector component to a curve, Used to fine-tune the interpolation of the input") DefNode(ShaderNode, SH_NODE_CURVE_RGB, def_rgb_curve, "CURVE_RGB", RGBCurve, "RGB Curves", "Apply color corrections for each color channel") DefNode(ShaderNode, SH_NODE_CAMERA, 0, "CAMERA", CameraData, "Camera Data", "Use to get information about the position of the object relative to the camera.\nFor Example: To change the shading of objects further away from the camera, or make custom fog effects") DefNode(ShaderNode, SH_NODE_MAP_RANGE, def_map_range, "MAP_RANGE", MapRange, "Map Range", "Remap a value from a range to a target range") DefNode(ShaderNode, SH_NODE_CLAMP, def_clamp, "CLAMP", Clamp, "Clamp", "Clamp a value between a minimum and a maximum") DefNode(ShaderNode, SH_NODE_MATH, def_math, "MATH", Math, "Math", "Perform math operations") DefNode(ShaderNode, SH_NODE_VECTOR_MATH, def_vector_math, "VECT_MATH", VectorMath, "Vector Math", "Perform vector math operation") DefNode(ShaderNode, SH_NODE_SQUEEZE, 0, "SQUEEZE", Squeeze, "Squeeze Value", "") DefNode(ShaderNode, SH_NODE_INVERT, 0, "INVERT", Invert, "Invert", "Inverts a color, producing a negative") DefNode(ShaderNode, SH_NODE_SEPRGB_LEGACY, 0, "SEPRGB", SeparateRGB, "Separate RGB", "Split an image into its red, green and blue channels") DefNode(ShaderNode, SH_NODE_COMBRGB_LEGACY, 0, "COMBRGB", CombineRGB, "Combine RGB", "Combine an image from its red, green and blue channels") DefNode(ShaderNode, SH_NODE_HUE_SAT, 0, "HUE_SAT", HueSaturation, "Hue Saturation Value","Apply a color transformation in the HSV Color Model") DefNode(ShaderNode, SH_NODE_OUTPUT_MATERIAL, def_sh_output, "OUTPUT_MATERIAL", OutputMaterial, "Material Output", "Output surface material information to a surface object") DefNode(ShaderNode, SH_NODE_EEVEE_SPECULAR, 0, "EEVEE_SPECULAR", EeveeSpecular, "Specular BSDF", "Similar to the Principled BSDF node but uses the specular workflow instead of the metallic.\nThe specular workflow functions by specifying the facing (along normal) reflection color The result may not be physically plausible because there is no energy conservation") DefNode(ShaderNode, SH_NODE_OUTPUT_LIGHT, def_sh_output, "OUTPUT_LIGHT", OutputLight, "Light Output", "Output light information to a light object") DefNode(ShaderNode, SH_NODE_OUTPUT_WORLD, def_sh_output, "OUTPUT_WORLD", OutputWorld, "World Output", "Output light color information to the scene’s World") DefNode(ShaderNode, SH_NODE_OUTPUT_LINESTYLE, def_sh_output_linestyle,"OUTPUT_LINESTYLE", OutputLineStyle, "Line Style Output", "") DefNode(ShaderNode, SH_NODE_FRESNEL, 0, "FRESNEL", Fresnel, "Fresnel", "Produce a blending factor depending on the angle between the surface normal and the viewing direction using Fresnel equations.\nFaces facing the viewer result in darker values, and perpendicular faces produce lighter values.\nTypically used for mixing realistic reflections at grazing angles") DefNode(ShaderNode, SH_NODE_LAYER_WEIGHT, 0, "LAYER_WEIGHT", LayerWeight, "Layer Weight", "Produce a blending factor depending on the angle between the surface normal and the viewing direction.\nDirectly facing the viewer results in darker values and perpendicular faces will be lighter.\nTypically used for layering shaders with the Mix Shader node") DefNode(ShaderNode, SH_NODE_MIX_SHADER, 0, "MIX_SHADER", MixShader, "Mix Shader", "Mix two shaders together.\nTypically used for material layering") DefNode(ShaderNode, SH_NODE_ADD_SHADER, 0, "ADD_SHADER", AddShader, "Add Shader", "Add two Shaders together") DefNode(ShaderNode, SH_NODE_ATTRIBUTE, def_sh_attribute, "ATTRIBUTE", Attribute, "Attribute", "Retrieve attributes attached to an object or mesh") DefNode(ShaderNode, SH_NODE_AMBIENT_OCCLUSION, def_sh_ambient_occlusion,"AMBIENT_OCCLUSION", AmbientOcclusion, "Ambient Occlusion", "Computes how much the hemisphere above the shading point is occluded.\nThis can be used for procedural texturing, for example, to add weathering effects to corners only.\nNote: For Cycle, This is an expensive shader and may slow down render significantly") DefNode(ShaderNode, SH_NODE_BACKGROUND, 0, "BACKGROUND", Background, "Background", "Add background light emission.\nNote: This node should only be used for the world surface output") DefNode(ShaderNode, SH_NODE_HOLDOUT, 0, "HOLDOUT", Holdout, "Holdout", "Create a “hole” in the image with zero alpha transparency, which is useful for compositing.\nNote: the holdout shader can only create alpha when: Properties ‣ Render ‣ Film ‣ Transparent is enabled") DefNode(ShaderNode, SH_NODE_BSDF_ANISOTROPIC, def_anisotropic, "BSDF_ANISOTROPIC", BsdfAnisotropic, "Anisotropic BSDF", "Glossy reflection with separate control over U and V direction roughness") DefNode(ShaderNode, SH_NODE_BSDF_DIFFUSE, 0, "BSDF_DIFFUSE", BsdfDiffuse, "Diffuse BSDF", "Lambertian and Oren-Nayar diffuse reflection") DefNode(ShaderNode, SH_NODE_BSDF_PRINCIPLED, def_principled, "BSDF_PRINCIPLED", BsdfPrincipled, "Principled BSDF", "Physically-based, easy-to-use shader for rendering surface materials.\nIt is based on the Disney principled model also known as the “PBR” shader, making it compatible with other software.\nTextures painted or baked from other softwares may be directly linked to the corresponding parameters in this shader") DefNode(ShaderNode, SH_NODE_BSDF_GLOSSY, def_glossy, "BSDF_GLOSSY", BsdfGlossy, "Glossy BSDF", "Reflection with microfacet distribution, used for materials such as metal or mirrors") DefNode(ShaderNode, SH_NODE_BSDF_GLASS, def_glass, "BSDF_GLASS", BsdfGlass, "Glass BSDF", "Glass-like shader mixing refraction and reflection at grazing angles") DefNode(ShaderNode, SH_NODE_BSDF_REFRACTION, def_refraction, "BSDF_REFRACTION", BsdfRefraction, "Refraction BSDF", "Glossy refraction with sharp or microfacet distribution,.\nTypically used for materials that transmit light") DefNode(ShaderNode, SH_NODE_BSDF_TRANSLUCENT, 0, "BSDF_TRANSLUCENT", BsdfTranslucent, "Translucent BSDF", "Lambertian diffuse transmission") DefNode(ShaderNode, SH_NODE_BSDF_TRANSPARENT, 0, "BSDF_TRANSPARENT", BsdfTransparent, "Transparent BSDF", "Transparency without refraction, passing straight through the surface as if there were no geometry there") DefNode(ShaderNode, SH_NODE_BSDF_VELVET, 0, "BSDF_VELVET", BsdfVelvet, "Velvet BSDF", "Reflection for materials such as cloth.\nTypically used together with other shaders (such as a Diffuse Shader) and is not particularly useful on its own") DefNode(ShaderNode, SH_NODE_BSDF_TOON, def_toon, "BSDF_TOON", BsdfToon, "Toon BSDF", "Diffuse and Glossy shaders with cartoon light effects") DefNode(ShaderNode, SH_NODE_BSDF_HAIR, def_hair, "BSDF_HAIR", BsdfHair, "Hair BSDF", "Reflection and transmission shaders optimized for hair rendering") DefNode(ShaderNode, SH_NODE_BSDF_HAIR_PRINCIPLED, def_hair_principled, "BSDF_HAIR_PRINCIPLED", BsdfHairPrincipled, "Principled Hair BSDF", "Physically-based, easy-to-use shader for rendering hair and fur") DefNode(ShaderNode, SH_NODE_SUBSURFACE_SCATTERING, def_sh_subsurface, "SUBSURFACE_SCATTERING",SubsurfaceScattering,"Subsurface Scattering","Subsurface multiple scattering shader.\nRather than light being reflected directly off the surface, it will penetrate the surface and bounce around internally.\nTypically used for materials such as skin, wax, marble or milk") DefNode(ShaderNode, SH_NODE_VOLUME_ABSORPTION, 0, "VOLUME_ABSORPTION", VolumeAbsorption, "Volume Absorption", "Absorb light as it passes through the volume") DefNode(ShaderNode, SH_NODE_VOLUME_SCATTER, 0, "VOLUME_SCATTER", VolumeScatter, "Volume Scatter", "Scatter light as it passes through the volume.\nTypically usage would be to add fog to a scene") DefNode(ShaderNode, SH_NODE_VOLUME_PRINCIPLED, 0, "PRINCIPLED_VOLUME", VolumePrincipled, "Principled Volume", "Combine all volume shading components into a single easy to use node") DefNode(ShaderNode, SH_NODE_EMISSION, 0, "EMISSION", Emission, "Emission", "Lambertian emission shader") DefNode(ShaderNode, SH_NODE_NEW_GEOMETRY, 0, "NEW_GEOMETRY", NewGeometry, "Geometry", "Geometric information about the current shading point") DefNode(ShaderNode, SH_NODE_LIGHT_PATH, 0, "LIGHT_PATH", LightPath, "Light Path", "Find out for which kind of incoming ray the shader is being executed.\nTypically used for non-physically-based tricks, For example: an invisible object that still affects parts of the scene") DefNode(ShaderNode, SH_NODE_LIGHT_FALLOFF, 0, "LIGHT_FALLOFF", LightFalloff, "Light Falloff", "Manipulate how light intensity decreases over distance.\nTypically used for non-physically-based effects, in reality, the light will always fall off quadratically") DefNode(ShaderNode, SH_NODE_OBJECT_INFO, 0, "OBJECT_INFO", ObjectInfo, "Object Info", "Retrieve information about the object instance") DefNode(ShaderNode, SH_NODE_PARTICLE_INFO, 0, "PARTICLE_INFO", ParticleInfo, "Particle Info", "Retrieve the data of the particle that spawned the object instance.\nIt can be useful to give some variation to a single material assigned to multiple instances of instancing object") DefNode(ShaderNode, SH_NODE_HAIR_INFO, 0, "HAIR_INFO", HairInfo, "Curves Info", "Retrieve hair curve information") DefNode(ShaderNode, SH_NODE_POINT_INFO, 0, "POINT_INFO", PointInfo, "Point Info", "Retrieve information about points in a point cloud") DefNode(ShaderNode, SH_NODE_VOLUME_INFO, 0, "VOLUME_INFO", VolumeInfo, "Volume Info", "Read volume data attributes found from smoke domains and other volumes") DefNode(ShaderNode, SH_NODE_WIREFRAME, def_sh_tex_wireframe, "WIREFRAME", Wireframe, "Wireframe", "Retrieve the edges of an object as it appears to Cycles.\nNote: as meshes are triangulated before being processed by Cycles, topology will always appear triangulated when viewed with the Wireframe node") DefNode(ShaderNode, SH_NODE_WAVELENGTH, 0, "WAVELENGTH", Wavelength, "Wavelength", "Convert a wavelength value to an RGB value") DefNode(ShaderNode, SH_NODE_BLACKBODY, 0, "BLACKBODY", Blackbody, "Blackbody", "Convert a blackbody temperature to an RGB value") DefNode(ShaderNode, SH_NODE_BUMP, def_sh_bump, "BUMP", Bump, "Bump", "Generate a perturbed normal from a height texture, for bump mapping.\nTypically used for faking high detailed surfaces") DefNode(ShaderNode, SH_NODE_NORMAL_MAP, def_sh_normal_map, "NORMAL_MAP", NormalMap, "Normal Map", "Generate a perturbed normal from an RGB normal map image.\nTypically used for faking high detailed surfaces") DefNode(ShaderNode, SH_NODE_TANGENT, def_sh_tangent, "TANGENT", Tangent, "Tangent", "Generate a tangent direction for the Anisotropic BSDF") DefNode(ShaderNode, SH_NODE_SCRIPT, def_sh_script, "SCRIPT", Script, "Script", "Generate an OSL shader from a file or text block.\nNote: there is no support for running OSL code on the GPU") DefNode(ShaderNode, SH_NODE_TEX_IMAGE, def_sh_tex_image, "TEX_IMAGE", TexImage, "Image Texture", "Add an image file as a texture") DefNode(ShaderNode, SH_NODE_TEX_ENVIRONMENT, def_sh_tex_environment, "TEX_ENVIRONMENT", TexEnvironment, "Environment Texture","Add an image file as an environment texture.\nTypically used to light the scene with the background node") DefNode(ShaderNode, SH_NODE_TEX_SKY, def_sh_tex_sky, "TEX_SKY", TexSky, "Sky Texture", "Generate a procedural sky texture") DefNode(ShaderNode, SH_NODE_TEX_GRADIENT, def_sh_tex_gradient, "TEX_GRADIENT", TexGradient, "Gradient Texture", "Generate an interpolated color and intensity values based on the input vector") DefNode(ShaderNode, SH_NODE_TEX_NOISE, def_sh_tex_noise, "TEX_NOISE", TexNoise, "Noise Texture", "Generate a fractal Perlin noise") DefNode(ShaderNode, SH_NODE_TEX_MAGIC, def_sh_tex_magic, "TEX_MAGIC", TexMagic, "Magic Texture", "Generate a psychedelic color texture") DefNode(ShaderNode, SH_NODE_TEX_WAVE, def_sh_tex_wave, "TEX_WAVE", TexWave, "Wave Texture", "Generate procedural bands or rings with noise") DefNode(ShaderNode, SH_NODE_TEX_MUSGRAVE, def_sh_tex_musgrave, "TEX_MUSGRAVE", TexMusgrave, "Musgrave Texture", "Generate a fractal Perlin noise.\nUnlike the Noise Texture, which is also a fractal Perlin noise, the Musgrave Texture allows greater control over how octaves are combined") DefNode(ShaderNode, SH_NODE_TEX_VORONOI, def_sh_tex_voronoi, "TEX_VORONOI", TexVoronoi, "Voronoi Texture", "Generate a Worley noise.\nTypically used to generate textures such as stones, water, or biological cells") DefNode(ShaderNode, SH_NODE_TEX_CHECKER, def_sh_tex_checker, "TEX_CHECKER", TexChecker, "Checker Texture", "Generate a checkerboard texture") DefNode(ShaderNode, SH_NODE_TEX_BRICK, def_sh_tex_brick, "TEX_BRICK", TexBrick, "Brick Texture", "Generate a procedural texture producing bricks") DefNode(ShaderNode, SH_NODE_TEX_POINTDENSITY, def_sh_tex_pointdensity,"TEX_POINTDENSITY", TexPointDensity, "Point Density", "Generate a volumetric point for each particle or vertex of another object") DefNode(ShaderNode, SH_NODE_TEX_COORD, def_sh_tex_coord, "TEX_COORD", TexCoord, "Texture Coordinate","Retrieve multiple types of texture coordinates.\nTypically used as inputs for texture nodes") DefNode(ShaderNode, SH_NODE_VECTOR_ROTATE, def_sh_vector_rotate, "VECTOR_ROTATE", VectorRotate, "Vector Rotate", "Rotate a vector around a pivot point (center)") DefNode(ShaderNode, SH_NODE_VECT_TRANSFORM, def_sh_vect_transform, "VECT_TRANSFORM", VectorTransform, "Vector Transform", "Convert a vector, point, or normal between world, camera, and object coordinate space") DefNode(ShaderNode, SH_NODE_SEPHSV_LEGACY, 0, "SEPHSV", SeparateHSV, "Separate HSV", "Split an image into its hue, saturation, and value channels") DefNode(ShaderNode, SH_NODE_COMBHSV_LEGACY, 0, "COMBHSV", CombineHSV, "Combine HSV", "Combine an image from its hue, saturation, and value channels") DefNode(ShaderNode, SH_NODE_UVMAP, def_sh_uvmap, "UVMAP", UVMap, "UV Map", "Retrieve a specified UV map") DefNode(ShaderNode, SH_NODE_VERTEX_COLOR, def_sh_vertex_color, "VERTEX_COLOR", VertexColor, "Color Attribute", "Retrieve a specified color attribute") DefNode(ShaderNode, SH_NODE_UVALONGSTROKE, def_sh_uvalongstroke, "UVALONGSTROKE", UVAlongStroke, "UV Along Stroke", "") DefNode(ShaderNode, SH_NODE_SEPXYZ, 0, "SEPXYZ", SeparateXYZ, "Separate XYZ", "Split an image into its X, Y, and Z channels") DefNode(ShaderNode, SH_NODE_COMBXYZ, 0, "COMBXYZ", CombineXYZ, "Combine XYZ", "Combine an image from its X, Y, and Z channels") DefNode(ShaderNode, SH_NODE_BEVEL, def_sh_bevel, "BEVEL", Bevel, "Bevel", "Generates normals with round corners.\nNote: this is only supported in Cycles, and is expensive") DefNode(ShaderNode, SH_NODE_DISPLACEMENT, def_sh_displacement, "DISPLACEMENT", Displacement, "Displacement", "Displace the surface along the surface normal") DefNode(ShaderNode, SH_NODE_VECTOR_DISPLACEMENT,def_sh_vector_displacement,"VECTOR_DISPLACEMENT",VectorDisplacement,"Vector Displacement","Displace the surface along arbitrary directions") DefNode(ShaderNode, SH_NODE_TEX_IES, def_sh_tex_ies, "TEX_IES", TexIES, "IES Texture", "Used to match real world lights based on IES files (IES).\nIES files store the directional intensity distribution of light sources") DefNode(ShaderNode, SH_NODE_TEX_WHITE_NOISE, def_sh_tex_white_noise, "TEX_WHITE_NOISE", TexWhiteNoise, "White Noise", "Return a random number based on an input seed") DefNode(ShaderNode, SH_NODE_OUTPUT_AOV, def_sh_output_aov, "OUTPUT_AOV", OutputAOV, "AOV Output", "Arbitrary Output Variables.\nProvide custom render passes for arbitrary shader node components") DefNode(ShaderNode, SH_NODE_CURVE_FLOAT, def_float_curve, "CURVE_FLOAT", FloatCurve, "Float Curve", "Map an input float to a curve and outputs a float value") DefNode(ShaderNode, SH_NODE_COMBINE_COLOR, def_sh_combsep_color, "COMBINE_COLOR", CombineColor, "Combine Color", "Combine an image from its red, green, and blue channels") DefNode(ShaderNode, SH_NODE_SEPARATE_COLOR, def_sh_combsep_color, "SEPARATE_COLOR", SeparateColor, "Separate Color", "Split an image into its red, green, and blue channels") DefNode(CompositorNode, CMP_NODE_VIEWER, def_cmp_viewer, "VIEWER", Viewer, "Viewer", "" ) DefNode(CompositorNode, CMP_NODE_RGB, 0, "RGB", RGB, "RGB", "" ) DefNode(CompositorNode, CMP_NODE_VALUE, 0, "VALUE", Value, "Value", "" ) DefNode(CompositorNode, CMP_NODE_MIX_RGB, def_mix_rgb, "MIX_RGB", MixRGB, "Mix", "" ) DefNode(CompositorNode, CMP_NODE_VALTORGB, def_colorramp, "VALTORGB", ValToRGB, "ColorRamp", "" ) DefNode(CompositorNode, CMP_NODE_RGBTOBW, 0, "RGBTOBW", RGBToBW, "RGB to BW", "" ) DefNode(CompositorNode, CMP_NODE_NORMAL, 0, "NORMAL", Normal, "Normal", "" ) DefNode(CompositorNode, CMP_NODE_CURVE_VEC, def_vector_curve, "CURVE_VEC", CurveVec, "Vector Curves", "" ) DefNode(CompositorNode, CMP_NODE_CURVE_RGB, def_rgb_curve, "CURVE_RGB", CurveRGB, "RGB Curves", "" ) DefNode(CompositorNode, CMP_NODE_ALPHAOVER, def_cmp_alpha_over, "ALPHAOVER", AlphaOver, "Alpha Over", "" ) DefNode(CompositorNode, CMP_NODE_BLUR, def_cmp_blur, "BLUR", Blur, "Blur", "" ) DefNode(CompositorNode, CMP_NODE_FILTER, def_cmp_filter, "FILTER", Filter, "Filter", "" ) DefNode(CompositorNode, CMP_NODE_MAP_VALUE, def_cmp_map_value, "MAP_VALUE", MapValue, "Map Value", "" ) DefNode(CompositorNode, CMP_NODE_MAP_RANGE, def_cmp_map_range, "MAP_RANGE", MapRange, "Map Range", "" ) DefNode(CompositorNode, CMP_NODE_TIME, def_time, "TIME", Time, "Time Curve", "" ) DefNode(CompositorNode, CMP_NODE_VECBLUR, def_cmp_vector_blur, "VECBLUR", VecBlur, "Vector Blur", "" ) DefNode(CompositorNode, CMP_NODE_SEPRGBA_LEGACY, 0, "SEPRGBA", SepRGBA, "Separate RGBA", "" ) DefNode(CompositorNode, CMP_NODE_SEPHSVA_LEGACY, 0, "SEPHSVA", SepHSVA, "Separate HSVA", "" ) DefNode(CompositorNode, CMP_NODE_SETALPHA, def_cmp_set_alpha, "SETALPHA", SetAlpha, "Set Alpha", "" ) DefNode(CompositorNode, CMP_NODE_HUE_SAT, 0, "HUE_SAT", HueSat, "Hue Saturation Value","" ) DefNode(CompositorNode, CMP_NODE_IMAGE, def_cmp_image, "IMAGE", Image, "Image", "" ) DefNode(CompositorNode, CMP_NODE_R_LAYERS, def_cmp_render_layers, "R_LAYERS", RLayers, "Render Layers", "" ) DefNode(CompositorNode, CMP_NODE_COMPOSITE, def_cmp_composite, "COMPOSITE", Composite, "Composite", "" ) /* NOTE: #OutputFile node has special RNA setup function called in rna_nodetree.c */ DefNode(CompositorNode, CMP_NODE_OUTPUT_FILE, 0, "OUTPUT_FILE", OutputFile, "File Output", "" ) DefNode(CompositorNode, CMP_NODE_TEXTURE, def_texture, "TEXTURE", Texture, "Texture", "" ) DefNode(CompositorNode, CMP_NODE_TRANSLATE, def_cmp_translate, "TRANSLATE", Translate, "Translate", "" ) DefNode(CompositorNode, CMP_NODE_ZCOMBINE, def_cmp_zcombine, "ZCOMBINE", Zcombine, "Z Combine", "" ) DefNode(CompositorNode, CMP_NODE_COMBRGBA_LEGACY,0, "COMBRGBA", CombRGBA, "Combine RGBA", "" ) DefNode(CompositorNode, CMP_NODE_DILATEERODE, def_cmp_dilate_erode, "DILATEERODE", DilateErode, "Dilate/Erode", "" ) DefNode(CompositorNode, CMP_NODE_INPAINT, def_cmp_inpaint, "INPAINT", Inpaint, "Inpaint", "" ) DefNode(CompositorNode, CMP_NODE_DESPECKLE, def_cmp_despeckle, "DESPECKLE", Despeckle, "Despeckle", "" ) DefNode(CompositorNode, CMP_NODE_ROTATE, def_cmp_rotate, "ROTATE", Rotate, "Rotate", "" ) DefNode(CompositorNode, CMP_NODE_SCALE, def_cmp_scale, "SCALE", Scale, "Scale", "" ) DefNode(CompositorNode, CMP_NODE_SEPYCCA_LEGACY, def_cmp_ycc, "SEPYCCA", SepYCCA, "Separate YCbCrA", "" ) DefNode(CompositorNode, CMP_NODE_COMBYCCA_LEGACY,def_cmp_ycc, "COMBYCCA", CombYCCA, "Combine YCbCrA", "" ) DefNode(CompositorNode, CMP_NODE_SEPYUVA_LEGACY, 0, "SEPYUVA", SepYUVA, "Separate YUVA", "" ) DefNode(CompositorNode, CMP_NODE_COMBYUVA_LEGACY,0, "COMBYUVA", CombYUVA, "Combine YUVA", "" ) DefNode(CompositorNode, CMP_NODE_DIFF_MATTE, def_cmp_diff_matte, "DIFF_MATTE", DiffMatte, "Difference Key", "" ) DefNode(CompositorNode, CMP_NODE_COLOR_SPILL, def_cmp_color_spill, "COLOR_SPILL", ColorSpill, "Color Spill", "" ) DefNode(CompositorNode, CMP_NODE_CHROMA_MATTE, def_cmp_chroma_matte, "CHROMA_MATTE", ChromaMatte, "Chroma Key", "" ) DefNode(CompositorNode, CMP_NODE_CHANNEL_MATTE, def_cmp_channel_matte, "CHANNEL_MATTE", ChannelMatte, "Channel Key", "" ) DefNode(CompositorNode, CMP_NODE_FLIP, def_cmp_flip, "FLIP", Flip, "Flip", "" ) DefNode(CompositorNode, CMP_NODE_SPLITVIEWER, def_cmp_splitviewer, "SPLITVIEWER", SplitViewer, "Split Viewer", "" ) DefNode(CompositorNode, CMP_NODE_MAP_UV, def_cmp_map_uv, "MAP_UV", MapUV, "Map UV", "" ) DefNode(CompositorNode, CMP_NODE_ID_MASK, def_cmp_id_mask, "ID_MASK", IDMask, "ID Mask", "" ) DefNode(CompositorNode, CMP_NODE_DOUBLEEDGEMASK, def_cmp_double_edge_mask,"DOUBLEEDGEMASK", DoubleEdgeMask, "Double Edge Mask", "" ) DefNode(CompositorNode, CMP_NODE_DEFOCUS, def_cmp_defocus, "DEFOCUS", Defocus, "Defocus", "" ) DefNode(CompositorNode, CMP_NODE_DISPLACE, 0, "DISPLACE", Displace, "Displace", "" ) DefNode(CompositorNode, CMP_NODE_COMBHSVA_LEGACY,0, "COMBHSVA", CombHSVA, "Combine HSVA", "" ) DefNode(CompositorNode, CMP_NODE_MATH, def_math, "MATH", Math, "Math", "" ) DefNode(CompositorNode, CMP_NODE_LUMA_MATTE, def_cmp_luma_matte, "LUMA_MATTE", LumaMatte, "Luminance Key", "" ) DefNode(CompositorNode, CMP_NODE_BRIGHTCONTRAST, def_cmp_brightcontrast, "BRIGHTCONTRAST", BrightContrast, "Bright/Contrast", "" ) DefNode(CompositorNode, CMP_NODE_GAMMA, 0, "GAMMA", Gamma, "Gamma", "" ) DefNode(CompositorNode, CMP_NODE_INVERT, def_cmp_invert, "INVERT", Invert, "Invert", "" ) DefNode(CompositorNode, CMP_NODE_NORMALIZE, 0, "NORMALIZE", Normalize, "Normalize", "" ) DefNode(CompositorNode, CMP_NODE_CROP, def_cmp_crop, "CROP", Crop, "Crop", "" ) DefNode(CompositorNode, CMP_NODE_DBLUR, def_cmp_dblur, "DBLUR", DBlur, "Directional Blur", "" ) DefNode(CompositorNode, CMP_NODE_BILATERALBLUR, def_cmp_bilateral_blur, "BILATERALBLUR", Bilateralblur, "Bilateral Blur", "" ) DefNode(CompositorNode, CMP_NODE_PREMULKEY, def_cmp_premul_key, "PREMULKEY", PremulKey, "Alpha Convert", "" ) DefNode(CompositorNode, CMP_NODE_GLARE, def_cmp_glare, "GLARE", Glare, "Glare", "" ) DefNode(CompositorNode, CMP_NODE_TONEMAP, def_cmp_tonemap, "TONEMAP", Tonemap, "Tonemap", "" ) DefNode(CompositorNode, CMP_NODE_LENSDIST, def_cmp_lensdist, "LENSDIST", Lensdist, "Lens Distortion", "" ) DefNode(CompositorNode, CMP_NODE_VIEW_LEVELS, def_cmp_levels, "LEVELS", Levels, "Levels", "" ) DefNode(CompositorNode, CMP_NODE_COLOR_MATTE, def_cmp_color_matte, "COLOR_MATTE", ColorMatte, "Color Key", "" ) DefNode(CompositorNode, CMP_NODE_DIST_MATTE, def_cmp_distance_matte, "DISTANCE_MATTE", DistanceMatte, "Distance Key", "" ) DefNode(CompositorNode, CMP_NODE_COLORBALANCE, def_cmp_colorbalance, "COLORBALANCE", ColorBalance, "Color Balance", "" ) DefNode(CompositorNode, CMP_NODE_HUECORRECT, def_cmp_huecorrect, "HUECORRECT", HueCorrect, "Hue Correct", "" ) DefNode(CompositorNode, CMP_NODE_MOVIECLIP, def_cmp_movieclip, "MOVIECLIP", MovieClip, "Movie Clip", "" ) DefNode(CompositorNode, CMP_NODE_TRANSFORM, dev_cmd_transform, "TRANSFORM", Transform, "Transform", "" ) DefNode(CompositorNode, CMP_NODE_STABILIZE2D, def_cmp_stabilize2d, "STABILIZE2D", Stabilize, "Stabilize 2D", "" ) DefNode(CompositorNode, CMP_NODE_MOVIEDISTORTION,def_cmp_moviedistortion,"MOVIEDISTORTION",MovieDistortion, "Movie Distortion", "" ) DefNode(CompositorNode, CMP_NODE_MASK_BOX, def_cmp_boxmask, "BOXMASK", BoxMask, "Box Mask", "" ) DefNode(CompositorNode, CMP_NODE_MASK_ELLIPSE, def_cmp_ellipsemask, "ELLIPSEMASK", EllipseMask, "Ellipse Mask", "" ) DefNode(CompositorNode, CMP_NODE_BOKEHIMAGE, def_cmp_bokehimage, "BOKEHIMAGE", BokehImage, "Bokeh Image", "" ) DefNode(CompositorNode, CMP_NODE_BOKEHBLUR, def_cmp_bokehblur, "BOKEHBLUR", BokehBlur, "Bokeh Blur", "" ) DefNode(CompositorNode, CMP_NODE_SWITCH, def_cmp_switch, "SWITCH", Switch, "Switch", "" ) DefNode(CompositorNode, CMP_NODE_SWITCH_VIEW, def_cmp_switch_view, "VIEWSWITCH", SwitchView, "Switch View", "" ) DefNode(CompositorNode, CMP_NODE_COLORCORRECTION,def_cmp_colorcorrection,"COLORCORRECTION",ColorCorrection, "Color Correction", "" ) DefNode(CompositorNode, CMP_NODE_MASK, def_cmp_mask, "MASK", Mask, "Mask", "" ) DefNode(CompositorNode, CMP_NODE_KEYINGSCREEN, def_cmp_keyingscreen, "KEYINGSCREEN", KeyingScreen, "Keying Screen", "" ) DefNode(CompositorNode, CMP_NODE_KEYING, def_cmp_keying, "KEYING", Keying, "Keying", "" ) DefNode(CompositorNode, CMP_NODE_TRACKPOS, def_cmp_trackpos, "TRACKPOS", TrackPos, "Track Position", "" ) DefNode(CompositorNode, CMP_NODE_PIXELATE, 0, "PIXELATE", Pixelate, "Pixelate", "" ) DefNode(CompositorNode, CMP_NODE_PLANETRACKDEFORM,def_cmp_planetrackdeform,"PLANETRACKDEFORM",PlaneTrackDeform,"Plane Track Deform","" ) DefNode(CompositorNode, CMP_NODE_CORNERPIN, 0, "CORNERPIN", CornerPin, "Corner Pin", "" ) DefNode(CompositorNode, CMP_NODE_SUNBEAMS, def_cmp_sunbeams, "SUNBEAMS", SunBeams, "Sun Beams", "" ) DefNode(CompositorNode, CMP_NODE_CRYPTOMATTE, def_cmp_cryptomatte, "CRYPTOMATTE_V2", CryptomatteV2, "Cryptomatte", "" ) DefNode(CompositorNode, CMP_NODE_CRYPTOMATTE_LEGACY, def_cmp_cryptomatte_legacy, "CRYPTOMATTE", Cryptomatte, "Cryptomatte (Legacy)", "" ) DefNode(CompositorNode, CMP_NODE_DENOISE, def_cmp_denoise, "DENOISE", Denoise, "Denoise", "" ) DefNode(CompositorNode, CMP_NODE_EXPOSURE, 0, "EXPOSURE", Exposure, "Exposure", "" ) DefNode(CompositorNode, CMP_NODE_ANTIALIASING, def_cmp_antialiasing, "ANTIALIASING", AntiAliasing, "Anti-Aliasing", "" ) DefNode(CompositorNode, CMP_NODE_POSTERIZE, 0, "POSTERIZE", Posterize, "Posterize", "" ) DefNode(CompositorNode, CMP_NODE_CONVERT_COLOR_SPACE,def_cmp_convert_color_space, "CONVERT_COLORSPACE", ConvertColorSpace, "Color Space", "" ) DefNode(CompositorNode, CMP_NODE_SCENE_TIME, 0, "SCENE_TIME", SceneTime, "Scene Time", "" ) DefNode(CompositorNode, CMP_NODE_COMBINE_XYZ, 0, "COMBINE_XYZ", CombineXYZ, "Combine XYZ", "" ) DefNode(CompositorNode, CMP_NODE_SEPARATE_XYZ, 0, "SEPARATE_XYZ", SeparateXYZ, "Separate XYZ", "" ) DefNode(CompositorNode, CMP_NODE_SEPARATE_COLOR, def_cmp_combsep_color, "SEPARATE_COLOR", SeparateColor, "Separate Color", "" ) DefNode(CompositorNode, CMP_NODE_COMBINE_COLOR, def_cmp_combsep_color, "COMBINE_COLOR", CombineColor, "Combine Color", "" ) DefNode(TextureNode, TEX_NODE_OUTPUT, def_tex_output, "OUTPUT", Output, "Output", "" ) DefNode(TextureNode, TEX_NODE_CHECKER, 0, "CHECKER", Checker, "Checker", "" ) DefNode(TextureNode, TEX_NODE_TEXTURE, def_texture, "TEXTURE", Texture, "Texture", "" ) DefNode(TextureNode, TEX_NODE_BRICKS, def_tex_bricks, "BRICKS", Bricks, "Bricks", "" ) DefNode(TextureNode, TEX_NODE_MATH, def_math, "MATH", Math, "Math", "" ) DefNode(TextureNode, TEX_NODE_MIX_RGB, def_mix_rgb, "MIX_RGB", MixRGB, "Mix RGB", "" ) DefNode(TextureNode, TEX_NODE_RGBTOBW, 0, "RGBTOBW", RGBToBW, "RGB to BW", "" ) DefNode(TextureNode, TEX_NODE_VALTORGB, def_colorramp, "VALTORGB", ValToRGB, "ColorRamp", "" ) DefNode(TextureNode, TEX_NODE_IMAGE, def_tex_image, "IMAGE", Image, "Image", "" ) DefNode(TextureNode, TEX_NODE_CURVE_RGB, def_rgb_curve, "CURVE_RGB", CurveRGB, "RGB Curves", "" ) DefNode(TextureNode, TEX_NODE_INVERT, 0, "INVERT", Invert, "Invert", "" ) DefNode(TextureNode, TEX_NODE_HUE_SAT, 0, "HUE_SAT", HueSaturation, "Hue Saturation Value", "" ) DefNode(TextureNode, TEX_NODE_CURVE_TIME, def_time, "CURVE_TIME", CurveTime, "Curve Time", "" ) DefNode(TextureNode, TEX_NODE_ROTATE, 0, "ROTATE", Rotate, "Rotate", "" ) DefNode(TextureNode, TEX_NODE_VIEWER, 0, "VIEWER", Viewer, "Viewer", "" ) DefNode(TextureNode, TEX_NODE_TRANSLATE, 0, "TRANSLATE", Translate, "Translate", "" ) DefNode(TextureNode, TEX_NODE_COORD, 0, "COORD", Coordinates, "Coordinates", "" ) DefNode(TextureNode, TEX_NODE_DISTANCE, 0, "DISTANCE", Distance, "Distance", "" ) DefNode(TextureNode, TEX_NODE_COMPOSE_LEGACY, 0, "COMPOSE", Compose, "Combine RGBA", "" ) DefNode(TextureNode, TEX_NODE_DECOMPOSE_LEGACY,0, "DECOMPOSE", Decompose, "Separate RGBA", "" ) DefNode(TextureNode, TEX_NODE_VALTONOR, 0, "VALTONOR", ValToNor, "Value to Normal", "" ) DefNode(TextureNode, TEX_NODE_SCALE, 0, "SCALE", Scale, "Scale", "" ) DefNode(TextureNode, TEX_NODE_AT, 0, "AT", At, "At", "" ) DefNode(TextureNode, TEX_NODE_COMBINE_COLOR, def_tex_combsep_color, "COMBINE_COLOR", CombineColor, "Combine Color", "" ) DefNode(TextureNode, TEX_NODE_SEPARATE_COLOR, def_tex_combsep_color, "SEPARATE_COLOR", SeparateColor, "Separate Color", "" ) /* procedural textures */ DefNode(TextureNode, TEX_NODE_PROC+TEX_VORONOI, 0, "TEX_VORONOI", TexVoronoi, "Voronoi", "" ) DefNode(TextureNode, TEX_NODE_PROC+TEX_BLEND, 0, "TEX_BLEND", TexBlend, "Blend", "" ) DefNode(TextureNode, TEX_NODE_PROC+TEX_MAGIC, 0, "TEX_MAGIC", TexMagic, "Magic", "" ) DefNode(TextureNode, TEX_NODE_PROC+TEX_MARBLE, 0, "TEX_MARBLE", TexMarble, "Marble", "" ) DefNode(TextureNode, TEX_NODE_PROC+TEX_CLOUDS, 0, "TEX_CLOUDS", TexClouds, "Clouds", "" ) DefNode(TextureNode, TEX_NODE_PROC+TEX_WOOD, 0, "TEX_WOOD", TexWood, "Wood", "" ) DefNode(TextureNode, TEX_NODE_PROC+TEX_MUSGRAVE, 0, "TEX_MUSGRAVE", TexMusgrave, "Musgrave", "" ) DefNode(TextureNode, TEX_NODE_PROC+TEX_NOISE, 0, "TEX_NOISE", TexNoise, "Noise", "" ) DefNode(TextureNode, TEX_NODE_PROC+TEX_STUCCI, 0, "TEX_STUCCI", TexStucci, "Stucci", "" ) DefNode(TextureNode, TEX_NODE_PROC+TEX_DISTNOISE, 0, "TEX_DISTNOISE", TexDistNoise, "Distorted Noise", "" ) DefNode(FunctionNode, FN_NODE_ALIGN_EULER_TO_VECTOR, def_fn_align_euler_to_vector, "ALIGN_EULER_TO_VECTOR", AlignEulerToVector, "Align Euler To Vector", "") DefNode(FunctionNode, FN_NODE_BOOLEAN_MATH, def_boolean_math, "BOOLEAN_MATH", BooleanMath, "Boolean Math", "") DefNode(FunctionNode, FN_NODE_COMBINE_COLOR, def_fn_combsep_color, "COMBINE_COLOR", CombineColor, "Combine Color", "") DefNode(FunctionNode, FN_NODE_COMPARE, def_compare, "COMPARE", Compare, "Compare", "") DefNode(FunctionNode, FN_NODE_FLOAT_TO_INT, def_float_to_int, "FLOAT_TO_INT", FloatToInt, "Float to Integer", "") DefNode(FunctionNode, FN_NODE_INPUT_BOOL, def_fn_input_bool, "INPUT_BOOL", InputBool, "Boolean", "") DefNode(FunctionNode, FN_NODE_INPUT_COLOR, def_fn_input_color, "INPUT_COLOR", InputColor, "Color", "") DefNode(FunctionNode, FN_NODE_INPUT_INT, def_fn_input_int, "INPUT_INT", InputInt, "Integer", "") DefNode(FunctionNode, FN_NODE_INPUT_SPECIAL_CHARACTERS, 0, "INPUT_SPECIAL_CHARACTERS", InputSpecialCharacters, "Special Characters", "") DefNode(FunctionNode, FN_NODE_INPUT_STRING, def_fn_input_string, "INPUT_STRING", InputString, "String", "") DefNode(FunctionNode, FN_NODE_INPUT_VECTOR, def_fn_input_vector, "INPUT_VECTOR", InputVector, "Vector", "") DefNode(FunctionNode, FN_NODE_RANDOM_VALUE, def_fn_random_value, "RANDOM_VALUE", RandomValue, "Random Value", "") DefNode(FunctionNode, FN_NODE_REPLACE_STRING, 0, "REPLACE_STRING", ReplaceString, "Replace String", "") DefNode(FunctionNode, FN_NODE_ROTATE_EULER, def_fn_rotate_euler, "ROTATE_EULER", RotateEuler, "Rotate Euler", "") DefNode(FunctionNode, FN_NODE_SEPARATE_COLOR, def_fn_combsep_color, "SEPARATE_COLOR", SeparateColor, "Separate Color", "") DefNode(FunctionNode, FN_NODE_SLICE_STRING, 0, "SLICE_STRING", SliceString, "Slice String", "") DefNode(FunctionNode, FN_NODE_STRING_LENGTH, 0, "STRING_LENGTH", StringLength, "String Length", "") DefNode(FunctionNode, FN_NODE_VALUE_TO_STRING, 0, "VALUE_TO_STRING", ValueToString, "Value to String", "") DefNode(GeometryNode, GEO_NODE_ATTRIBUTE_DOMAIN_SIZE, def_geo_attribute_domain_size, "ATTRIBUTE_DOMAIN_SIZE", AttributeDomainSize, "Domain Size", "") DefNode(GeometryNode, GEO_NODE_ATTRIBUTE_STATISTIC, def_geo_attribute_statistic, "ATTRIBUTE_STATISTIC", AttributeStatistic, "Attribute Statistic", "") DefNode(GeometryNode, GEO_NODE_BOUNDING_BOX, 0, "BOUNDING_BOX", BoundBox, "Bounding Box", "") DefNode(GeometryNode, GEO_NODE_CAPTURE_ATTRIBUTE, def_geo_attribute_capture, "CAPTURE_ATTRIBUTE", CaptureAttribute, "Capture Attribute", "") DefNode(GeometryNode, GEO_NODE_COLLECTION_INFO, def_geo_collection_info, "COLLECTION_INFO", CollectionInfo, "Collection Info", "") DefNode(GeometryNode, GEO_NODE_CONVEX_HULL, 0, "CONVEX_HULL", ConvexHull, "Convex Hull", "") DefNode(GeometryNode, GEO_NODE_CURVE_ENDPOINT_SELECTION, 0, "CURVE_ENDPOINT_SELECTION", CurveEndpointSelection, "Endpoint Selection", "") DefNode(GeometryNode, GEO_NODE_CURVE_HANDLE_TYPE_SELECTION, def_geo_curve_handle_type_selection, "CURVE_HANDLE_TYPE_SELECTION", CurveHandleTypeSelection, "Handle Type Selection", "") DefNode(GeometryNode, GEO_NODE_CURVE_LENGTH, 0, "CURVE_LENGTH", CurveLength, "Curve Length", "") DefNode(GeometryNode, GEO_NODE_CURVE_PRIMITIVE_ARC, def_geo_curve_primitive_arc, "CURVE_PRIMITIVE_ARC", CurveArc, "Arc", "") DefNode(GeometryNode, GEO_NODE_CURVE_PRIMITIVE_BEZIER_SEGMENT, def_geo_curve_primitive_bezier_segment, "CURVE_PRIMITIVE_BEZIER_SEGMENT", CurvePrimitiveBezierSegment, "Bezier Segment", "") DefNode(GeometryNode, GEO_NODE_CURVE_PRIMITIVE_CIRCLE, def_geo_curve_primitive_circle, "CURVE_PRIMITIVE_CIRCLE", CurvePrimitiveCircle, "Curve Circle", "") DefNode(GeometryNode, GEO_NODE_CURVE_PRIMITIVE_LINE, def_geo_curve_primitive_line, "CURVE_PRIMITIVE_LINE", CurvePrimitiveLine, "Curve Line", "") DefNode(GeometryNode, GEO_NODE_CURVE_PRIMITIVE_QUADRATIC_BEZIER, 0, "CURVE_PRIMITIVE_QUADRATIC_BEZIER", CurveQuadraticBezier, "Quadratic Bezier", "") DefNode(GeometryNode, GEO_NODE_CURVE_PRIMITIVE_QUADRILATERAL, def_geo_curve_primitive_quadrilateral, "CURVE_PRIMITIVE_QUADRILATERAL", CurvePrimitiveQuadrilateral, "Quadrilateral", "") DefNode(GeometryNode, GEO_NODE_CURVE_PRIMITIVE_SPIRAL, 0, "CURVE_PRIMITIVE_SPIRAL", CurveSpiral, "Curve Spiral", "") DefNode(GeometryNode, GEO_NODE_CURVE_PRIMITIVE_STAR, 0, "CURVE_PRIMITIVE_STAR", CurveStar, "Star", "") DefNode(GeometryNode, GEO_NODE_CURVE_SET_HANDLE_TYPE, def_geo_curve_set_handle_type, "CURVE_SET_HANDLES", CurveSetHandles, "Set Handle Type", "") DefNode(GeometryNode, GEO_NODE_CURVE_SPLINE_PARAMETER, 0, "SPLINE_PARAMETER", SplineParameter, "Spline Parameter", "") DefNode(GeometryNode, GEO_NODE_CURVE_SPLINE_TYPE, def_geo_curve_spline_type, "CURVE_SPLINE_TYPE", CurveSplineType, "Set Spline Type", "") DefNode(GeometryNode, GEO_NODE_CURVE_TO_MESH, 0, "CURVE_TO_MESH", CurveToMesh, "Curve to Mesh", "") DefNode(GeometryNode, GEO_NODE_CURVE_TO_POINTS, def_geo_curve_to_points, "CURVE_TO_POINTS", CurveToPoints, "Curve to Points", "") DefNode(GeometryNode, GEO_NODE_DELETE_GEOMETRY, def_geo_delete_geometry, "DELETE_GEOMETRY", DeleteGeometry, "Delete Geometry", "") DefNode(GeometryNode, GEO_NODE_DUPLICATE_ELEMENTS, def_geo_duplicate_elements, "DUPLICATE_ELEMENTS", DuplicateElements, "Duplicate Elements", "") DefNode(GeometryNode, GEO_NODE_DISTRIBUTE_POINTS_ON_FACES, def_geo_distribute_points_on_faces, "DISTRIBUTE_POINTS_ON_FACES", DistributePointsOnFaces, "Distribute Points on Faces", "") DefNode(GeometryNode, GEO_NODE_ACCUMULATE_FIELD, def_geo_accumulate_field, "ACCUMULATE_FIELD", AccumulateField, "Accumulate Field", "") DefNode(GeometryNode, GEO_NODE_DUAL_MESH, 0, "DUAL_MESH", DualMesh, "Dual Mesh", "") DefNode(GeometryNode, GEO_NODE_EXTRUDE_MESH, def_geo_extrude_mesh, "EXTRUDE_MESH", ExtrudeMesh, "Extrude Mesh", "") DefNode(GeometryNode, GEO_NODE_FIELD_AT_INDEX, def_geo_field_at_index, "FIELD_AT_INDEX", FieldAtIndex, "Field at Index", "") DefNode(GeometryNode, GEO_NODE_FIELD_ON_DOMAIN, def_geo_field_on_domain, "FIELD_ON_DOMAIN", FieldOnDomain, "Field on Domain", "") DefNode(GeometryNode, GEO_NODE_FILL_CURVE, def_geo_curve_fill, "FILL_CURVE", FillCurve, "Fill Curve", "") DefNode(GeometryNode, GEO_NODE_FILLET_CURVE, def_geo_curve_fillet, "FILLET_CURVE", FilletCurve, "Fillet Curve", "") DefNode(GeometryNode, GEO_NODE_FLIP_FACES, 0, "FLIP_FACES", FlipFaces, "Flip Faces", "") DefNode(GeometryNode, GEO_NODE_GEOMETRY_TO_INSTANCE, 0, "GEOMETRY_TO_INSTANCE", GeometryToInstance, "Geometry to Instance", "") DefNode(GeometryNode, GEO_NODE_IMAGE_TEXTURE, def_geo_image_texture, "IMAGE_TEXTURE", ImageTexture, "Image Texture", "") DefNode(GeometryNode, GEO_NODE_INPUT_NAMED_ATTRIBUTE, def_geo_input_named_attribute, "INPUT_ATTRIBUTE", InputNamedAttribute, "Named Attribute", "") DefNode(GeometryNode, GEO_NODE_INPUT_CURVE_HANDLES, 0, "INPUT_CURVE_HANDLES", InputCurveHandlePositions, "Curve Handle Positions", "") DefNode(GeometryNode, GEO_NODE_INPUT_CURVE_TILT, 0, "INPUT_CURVE_TILT", InputCurveTilt, "Curve Tilt", "") DefNode(GeometryNode, GEO_NODE_INPUT_ID, 0, "INPUT_ID", InputID, "ID", "") DefNode(GeometryNode, GEO_NODE_INPUT_INDEX, 0, "INDEX", InputIndex, "Index", "") DefNode(GeometryNode, GEO_NODE_INPUT_INSTANCE_ROTATION, 0, "INPUT_INSTANCE_ROTATION", InputInstanceRotation, "Instance Rotation", "") DefNode(GeometryNode, GEO_NODE_INPUT_INSTANCE_SCALE, 0, "INPUT_INSTANCE_SCALE", InputInstanceScale, "Instance Scale", "") DefNode(GeometryNode, GEO_NODE_INPUT_MATERIAL_INDEX, 0, "INPUT_MATERIAL_INDEX", InputMaterialIndex, "Material Index", "") DefNode(GeometryNode, GEO_NODE_INPUT_MATERIAL, def_geo_input_material, "INPUT_MATERIAL", InputMaterial, "Material", "") DefNode(GeometryNode, GEO_NODE_INPUT_MESH_EDGE_ANGLE, 0, "MESH_EDGE_ANGLE", InputMeshEdgeAngle, "Edge Angle", "") DefNode(GeometryNode, GEO_NODE_INPUT_MESH_EDGE_NEIGHBORS, 0, "MESH_EDGE_NEIGHBORS", InputMeshEdgeNeighbors, "Edge Neighbors", "") DefNode(GeometryNode, GEO_NODE_INPUT_MESH_EDGE_VERTICES, 0, "MESH_EDGE_VERTICES", InputMeshEdgeVertices, "Edge Vertices", "") DefNode(GeometryNode, GEO_NODE_INPUT_MESH_FACE_AREA, 0, "MESH_FACE_AREA", InputMeshFaceArea, "Face Area", "") DefNode(GeometryNode, GEO_NODE_INPUT_MESH_FACE_IS_PLANAR, 0, "MESH_FACE_IS_PLANAR", InputMeshFaceIsPlanar, "Face is Planar", "") DefNode(GeometryNode, GEO_NODE_INPUT_MESH_FACE_NEIGHBORS, 0, "MESH_FACE_NEIGHBORS", InputMeshFaceNeighbors, "Face Neighbors", "") DefNode(GeometryNode, GEO_NODE_INPUT_MESH_ISLAND, 0, "MESH_ISLAND", InputMeshIsland, "Mesh Island", "") DefNode(GeometryNode, GEO_NODE_INPUT_MESH_VERTEX_NEIGHBORS, 0, "MESH_VERTEX_NEIGHBORS", InputMeshVertexNeighbors, "Vertex Neighbors", "") DefNode(GeometryNode, GEO_NODE_INPUT_NORMAL, 0, "INPUT_NORMAL", InputNormal, "Normal", "") DefNode(GeometryNode, GEO_NODE_INPUT_POSITION, 0, "POSITION", InputPosition, "Position", "") DefNode(GeometryNode, GEO_NODE_INPUT_RADIUS, 0, "INPUT_RADIUS", InputRadius, "Radius", "") DefNode(GeometryNode, GEO_NODE_INPUT_SCENE_TIME, 0, "INPUT_SCENE_TIME", InputSceneTime, "Scene Time", "") DefNode(GeometryNode, GEO_NODE_INPUT_SHADE_SMOOTH, 0, "INPUT_SHADE_SMOOTH", InputShadeSmooth, "Is Shade Smooth", "") DefNode(GeometryNode, GEO_NODE_INPUT_SPLINE_CYCLIC, 0, "INPUT_SPLINE_CYCLIC", InputSplineCyclic, "Is Spline Cyclic", "") DefNode(GeometryNode, GEO_NODE_INPUT_SPLINE_LENGTH, 0, "SPLINE_LENGTH", SplineLength, "Spline Length", "") DefNode(GeometryNode, GEO_NODE_INPUT_SPLINE_RESOLUTION, 0, "INPUT_SPLINE_RESOLUTION", InputSplineResolution, "Spline Resolution", "") DefNode(GeometryNode, GEO_NODE_INPUT_TANGENT, 0, "INPUT_TANGENT", InputTangent, "Curve Tangent", "") DefNode(GeometryNode, GEO_NODE_INSTANCE_ON_POINTS, 0, "INSTANCE_ON_POINTS", InstanceOnPoints, "Instance on Points", "") DefNode(GeometryNode, GEO_NODE_INSTANCES_TO_POINTS, 0, "INSTANCES_TO_POINTS", InstancesToPoints, "Instances to Points", "") DefNode(GeometryNode, GEO_NODE_IS_VIEWPORT, 0, "IS_VIEWPORT", IsViewport, "Is Viewport", "") DefNode(GeometryNode, GEO_NODE_JOIN_GEOMETRY, 0, "JOIN_GEOMETRY", JoinGeometry, "Join Geometry", "") DefNode(GeometryNode, GEO_NODE_MATERIAL_SELECTION, 0, "MATERIAL_SELECTION", MaterialSelection, "Material Selection", "") DefNode(GeometryNode, GEO_NODE_MERGE_BY_DISTANCE, def_geo_merge_by_distance, "MERGE_BY_DISTANCE", MergeByDistance, "Merge by Distance", "") DefNode(GeometryNode, GEO_NODE_MESH_BOOLEAN, def_geo_boolean, "MESH_BOOLEAN", MeshBoolean, "Mesh Boolean", "") DefNode(GeometryNode, GEO_NODE_MESH_PRIMITIVE_CIRCLE, def_geo_mesh_circle, "MESH_PRIMITIVE_CIRCLE", MeshCircle, "Mesh Circle", "") DefNode(GeometryNode, GEO_NODE_MESH_PRIMITIVE_CONE, def_geo_mesh_cone, "MESH_PRIMITIVE_CONE", MeshCone, "Cone", "") DefNode(GeometryNode, GEO_NODE_MESH_PRIMITIVE_CUBE, 0, "MESH_PRIMITIVE_CUBE", MeshCube, "Cube", "") DefNode(GeometryNode, GEO_NODE_MESH_PRIMITIVE_CYLINDER, def_geo_mesh_cylinder, "MESH_PRIMITIVE_CYLINDER", MeshCylinder, "Cylinder", "") DefNode(GeometryNode, GEO_NODE_MESH_PRIMITIVE_GRID, 0, "MESH_PRIMITIVE_GRID", MeshGrid, "Grid", "") DefNode(GeometryNode, GEO_NODE_MESH_PRIMITIVE_ICO_SPHERE, 0, "MESH_PRIMITIVE_ICO_SPHERE", MeshIcoSphere, "Ico Sphere", "") DefNode(GeometryNode, GEO_NODE_MESH_PRIMITIVE_LINE, def_geo_mesh_line, "MESH_PRIMITIVE_LINE", MeshLine, "Mesh Line", "") DefNode(GeometryNode, GEO_NODE_MESH_PRIMITIVE_UV_SPHERE, 0, "MESH_PRIMITIVE_UV_SPHERE", MeshUVSphere, "UV Sphere", "") DefNode(GeometryNode, GEO_NODE_MESH_TO_CURVE, 0, "MESH_TO_CURVE", MeshToCurve, "Mesh to Curve", "") DefNode(GeometryNode, GEO_NODE_MESH_TO_POINTS, def_geo_mesh_to_points, "MESH_TO_POINTS", MeshToPoints, "Mesh to Points", "") DefNode(GeometryNode, GEO_NODE_MESH_TO_VOLUME, def_geo_mesh_to_volume, "MESH_TO_VOLUME", MeshToVolume, "Mesh To Volume", "") DefNode(GeometryNode, GEO_NODE_OBJECT_INFO, def_geo_object_info, "OBJECT_INFO", ObjectInfo, "Object Info", "") DefNode(GeometryNode, GEO_NODE_POINTS, 0, "POINTS", Points, "Points", "") DefNode(GeometryNode, GEO_NODE_POINTS_TO_VERTICES, 0, "POINTS_TO_VERTICES", PointsToVertices, "Points to Vertices", "") DefNode(GeometryNode, GEO_NODE_POINTS_TO_VOLUME, def_geo_points_to_volume, "POINTS_TO_VOLUME", PointsToVolume, "Points to Volume", "") DefNode(GeometryNode, GEO_NODE_PROXIMITY, def_geo_proximity, "PROXIMITY", Proximity, "Geometry Proximity", "") DefNode(GeometryNode, GEO_NODE_RAYCAST, def_geo_raycast, "RAYCAST", Raycast, "Raycast", "") DefNode(GeometryNode, GEO_NODE_REMOVE_ATTRIBUTE, 0, "REMOVE_ATTRIBUTE", RemoveAttribute, "Remove Named Attribute", "") DefNode(GeometryNode, GEO_NODE_REALIZE_INSTANCES, def_geo_realize_instances, "REALIZE_INSTANCES", RealizeInstances, "Realize Instances", "") DefNode(GeometryNode, GEO_NODE_REPLACE_MATERIAL, 0, "REPLACE_MATERIAL", ReplaceMaterial, "Replace Material", "") DefNode(GeometryNode, GEO_NODE_RESAMPLE_CURVE, def_geo_curve_resample, "RESAMPLE_CURVE", ResampleCurve, "Resample Curve", "") DefNode(GeometryNode, GEO_NODE_REVERSE_CURVE, 0, "REVERSE_CURVE", ReverseCurve, "Reverse Curve", "") DefNode(GeometryNode, GEO_NODE_ROTATE_INSTANCES, 0, "ROTATE_INSTANCES", RotateInstances, "Rotate Instances", "") DefNode(GeometryNode, GEO_NODE_SAMPLE_CURVE, def_geo_curve_sample, "SAMPLE_CURVE", SampleCurve, "Sample Curve", "") DefNode(GeometryNode, GEO_NODE_SCALE_ELEMENTS, def_geo_scale_elements, "SCALE_ELEMENTS", ScaleElements, "Scale Elements", "") DefNode(GeometryNode, GEO_NODE_SCALE_INSTANCES, 0, "SCALE_INSTANCES", ScaleInstances, "Scale Instances", "") DefNode(GeometryNode, GEO_NODE_SEPARATE_COMPONENTS, 0, "SEPARATE_COMPONENTS", SeparateComponents, "Separate Components", "") DefNode(GeometryNode, GEO_NODE_SEPARATE_GEOMETRY, def_geo_separate_geometry, "SEPARATE_GEOMETRY", SeparateGeometry, "Separate Geometry", "") DefNode(GeometryNode, GEO_NODE_SET_CURVE_HANDLES, def_geo_curve_set_handle_positions, "SET_CURVE_HANDLES", SetCurveHandlePositions, "Set Handle Positions", "") DefNode(GeometryNode, GEO_NODE_SET_CURVE_RADIUS, 0, "SET_CURVE_RADIUS", SetCurveRadius, "Set Curve Radius", "") DefNode(GeometryNode, GEO_NODE_SET_CURVE_TILT, 0, "SET_CURVE_TILT", SetCurveTilt, "Set Curve Tilt", "") DefNode(GeometryNode, GEO_NODE_SET_ID, 0, "SET_ID", SetID, "Set ID", "") DefNode(GeometryNode, GEO_NODE_SET_MATERIAL_INDEX, 0, "SET_MATERIAL_INDEX", SetMaterialIndex, "Set Material Index", "") DefNode(GeometryNode, GEO_NODE_SET_MATERIAL, 0, "SET_MATERIAL", SetMaterial, "Set Material", "") DefNode(GeometryNode, GEO_NODE_SET_POINT_RADIUS, 0, "SET_POINT_RADIUS", SetPointRadius, "Set Point Radius", "") DefNode(GeometryNode, GEO_NODE_SET_POSITION, 0, "SET_POSITION", SetPosition, "Set Position", "") DefNode(GeometryNode, GEO_NODE_SET_SHADE_SMOOTH, 0, "SET_SHADE_SMOOTH", SetShadeSmooth, "Set Shade Smooth", "") DefNode(GeometryNode, GEO_NODE_SET_SPLINE_CYCLIC, 0, "SET_SPLINE_CYCLIC", SetSplineCyclic, "Set Spline Cyclic", "") DefNode(GeometryNode, GEO_NODE_SET_SPLINE_RESOLUTION, 0, "SET_SPLINE_RESOLUTION", SetSplineResolution, "Set Spline Resolution", "") DefNode(GeometryNode, GEO_NODE_SPLIT_EDGES, 0, "SPLIT_EDGES", SplitEdges, "Split Edges", "") DefNode(GeometryNode, GEO_NODE_STORE_NAMED_ATTRIBUTE, def_geo_store_named_attribute, "STORE_NAMED_ATTRIBUTE", StoreNamedAttribute, "Store Named Attribute", "") DefNode(GeometryNode, GEO_NODE_STRING_JOIN, 0, "STRING_JOIN", StringJoin, "Join Strings", "") DefNode(GeometryNode, GEO_NODE_STRING_TO_CURVES, def_geo_string_to_curves, "STRING_TO_CURVES", StringToCurves, "String to Curves", "") DefNode(GeometryNode, GEO_NODE_SUBDIVIDE_CURVE, 0, "SUBDIVIDE_CURVE", SubdivideCurve, "Subdivide Curve", "") DefNode(GeometryNode, GEO_NODE_SUBDIVIDE_MESH, 0, "SUBDIVIDE_MESH", SubdivideMesh, "Subdivide Mesh", "") DefNode(GeometryNode, GEO_NODE_SUBDIVISION_SURFACE, def_geo_subdivision_surface, "SUBDIVISION_SURFACE", SubdivisionSurface, "Subdivision Surface", "") DefNode(GeometryNode, GEO_NODE_SWITCH, def_geo_switch, "SWITCH", Switch, "Switch", "") DefNode(GeometryNode, GEO_NODE_TRANSFER_ATTRIBUTE, def_geo_transfer_attribute, "ATTRIBUTE_TRANSFER", AttributeTransfer, "Transfer Attribute", "") DefNode(GeometryNode, GEO_NODE_TRANSFORM, 0, "TRANSFORM", Transform, "Transform", "") DefNode(GeometryNode, GEO_NODE_TRANSLATE_INSTANCES, 0, "TRANSLATE_INSTANCES", TranslateInstances, "Translate Instances", "") DefNode(GeometryNode, GEO_NODE_TRIANGULATE, def_geo_triangulate, "TRIANGULATE", Triangulate, "Triangulate", "") DefNode(GeometryNode, GEO_NODE_TRIM_CURVE, def_geo_curve_trim, "TRIM_CURVE", TrimCurve, "Trim Curve", "") DefNode(GeometryNode, GEO_NODE_VIEWER, def_geo_viewer, "VIEWER", Viewer, "Viewer", "") DefNode(GeometryNode, GEO_NODE_VOLUME_CUBE, 0, "VOLUME_CUBE", VolumeCube, "Volume Cube", "") DefNode(GeometryNode, GEO_NODE_VOLUME_TO_MESH, def_geo_volume_to_mesh, "VOLUME_TO_MESH", VolumeToMesh, "Volume to Mesh", "") DefNode(GeometryNode, GEO_NODE_UV_PACK_ISLANDS, 0, "UV_PACK_ISLANDS", UVPackIslands, "Pack UV Islands", "") DefNode(GeometryNode, GEO_NODE_UV_UNWRAP, def_geo_uv_unwrap, "UV_UNWRAP", UVUnwrap, "UV Unwrap", "") +DefNode(GeometryNode, GEO_NODE_DISTRIBUTE_POINTS_IN_VOLUME, def_geo_distribute_points_in_volume, "DISTRIBUTE_POINTS_IN_VOLUME", DistributePointsInVolume, "Distribute Points In Volume", "") /* undefine macros */ #undef DefNode /* clang-format on */ diff --git a/source/blender/nodes/geometry/CMakeLists.txt b/source/blender/nodes/geometry/CMakeLists.txt index 950124f75d0..fe28ff37034 100644 --- a/source/blender/nodes/geometry/CMakeLists.txt +++ b/source/blender/nodes/geometry/CMakeLists.txt @@ -1,247 +1,250 @@ # SPDX-License-Identifier: GPL-2.0-or-later set(INC . .. ../intern ../../editors/include ../../blenkernel ../../blenlib ../../blentranslation ../../bmesh ../../depsgraph ../../functions ../../geometry ../../gpu ../../imbuf ../../makesdna ../../makesrna ../../render ../../windowmanager ../../../../intern/guardedalloc + # RNA_prototypes.h ${CMAKE_BINARY_DIR}/source/blender/makesrna ) - set(SRC nodes/node_geo_accumulate_field.cc nodes/node_geo_attribute_capture.cc nodes/node_geo_attribute_domain_size.cc nodes/node_geo_attribute_statistic.cc nodes/node_geo_boolean.cc nodes/node_geo_bounding_box.cc nodes/node_geo_collection_info.cc nodes/node_geo_common.cc nodes/node_geo_convex_hull.cc nodes/node_geo_curve_endpoint_selection.cc nodes/node_geo_curve_fill.cc nodes/node_geo_curve_fillet.cc nodes/node_geo_curve_handle_type_selection.cc nodes/node_geo_curve_length.cc nodes/node_geo_curve_primitive_arc.cc nodes/node_geo_curve_primitive_bezier_segment.cc nodes/node_geo_curve_primitive_circle.cc nodes/node_geo_curve_primitive_line.cc nodes/node_geo_curve_primitive_quadratic_bezier.cc nodes/node_geo_curve_primitive_quadrilateral.cc nodes/node_geo_curve_primitive_spiral.cc nodes/node_geo_curve_primitive_star.cc nodes/node_geo_curve_resample.cc nodes/node_geo_curve_reverse.cc nodes/node_geo_curve_sample.cc nodes/node_geo_curve_set_handle_type.cc nodes/node_geo_curve_spline_parameter.cc nodes/node_geo_curve_spline_type.cc nodes/node_geo_curve_subdivide.cc nodes/node_geo_curve_to_mesh.cc nodes/node_geo_curve_to_points.cc nodes/node_geo_curve_trim.cc nodes/node_geo_delete_geometry.cc nodes/node_geo_distribute_points_on_faces.cc nodes/node_geo_dual_mesh.cc nodes/node_geo_duplicate_elements.cc nodes/node_geo_edge_split.cc nodes/node_geo_extrude_mesh.cc nodes/node_geo_field_at_index.cc nodes/node_geo_field_on_domain.cc nodes/node_geo_flip_faces.cc nodes/node_geo_geometry_to_instance.cc nodes/node_geo_image_texture.cc nodes/node_geo_input_curve_handles.cc nodes/node_geo_input_curve_tilt.cc nodes/node_geo_input_id.cc nodes/node_geo_input_index.cc nodes/node_geo_input_instance_rotation.cc nodes/node_geo_input_instance_scale.cc nodes/node_geo_input_material.cc nodes/node_geo_input_material_index.cc nodes/node_geo_input_mesh_edge_angle.cc nodes/node_geo_input_mesh_edge_neighbors.cc nodes/node_geo_input_mesh_edge_vertices.cc nodes/node_geo_input_mesh_face_area.cc nodes/node_geo_input_mesh_face_is_planar.cc nodes/node_geo_input_mesh_face_neighbors.cc nodes/node_geo_input_mesh_island.cc nodes/node_geo_input_mesh_vertex_neighbors.cc nodes/node_geo_input_named_attribute.cc nodes/node_geo_input_normal.cc nodes/node_geo_input_position.cc nodes/node_geo_input_radius.cc nodes/node_geo_input_scene_time.cc nodes/node_geo_input_shade_smooth.cc nodes/node_geo_input_spline_cyclic.cc nodes/node_geo_input_spline_length.cc nodes/node_geo_input_spline_resolution.cc nodes/node_geo_input_tangent.cc nodes/node_geo_instance_on_points.cc nodes/node_geo_instances_to_points.cc nodes/node_geo_is_viewport.cc nodes/node_geo_join_geometry.cc nodes/node_geo_material_replace.cc nodes/node_geo_material_selection.cc nodes/node_geo_merge_by_distance.cc nodes/node_geo_mesh_primitive_circle.cc nodes/node_geo_mesh_primitive_cone.cc nodes/node_geo_mesh_primitive_cube.cc nodes/node_geo_mesh_primitive_cylinder.cc nodes/node_geo_mesh_primitive_grid.cc nodes/node_geo_mesh_primitive_ico_sphere.cc nodes/node_geo_mesh_primitive_line.cc nodes/node_geo_mesh_primitive_uv_sphere.cc nodes/node_geo_mesh_subdivide.cc nodes/node_geo_mesh_to_curve.cc nodes/node_geo_mesh_to_points.cc nodes/node_geo_mesh_to_volume.cc nodes/node_geo_object_info.cc nodes/node_geo_points.cc nodes/node_geo_points_to_vertices.cc nodes/node_geo_points_to_volume.cc nodes/node_geo_proximity.cc nodes/node_geo_raycast.cc nodes/node_geo_realize_instances.cc nodes/node_geo_remove_attribute.cc nodes/node_geo_rotate_instances.cc nodes/node_geo_scale_elements.cc nodes/node_geo_scale_instances.cc nodes/node_geo_separate_components.cc nodes/node_geo_separate_geometry.cc nodes/node_geo_set_curve_handles.cc nodes/node_geo_set_curve_radius.cc nodes/node_geo_set_curve_tilt.cc nodes/node_geo_set_id.cc nodes/node_geo_set_material.cc nodes/node_geo_set_material_index.cc nodes/node_geo_set_point_radius.cc nodes/node_geo_set_position.cc nodes/node_geo_set_shade_smooth.cc nodes/node_geo_set_spline_cyclic.cc nodes/node_geo_set_spline_resolution.cc nodes/node_geo_store_named_attribute.cc nodes/node_geo_string_join.cc nodes/node_geo_string_to_curves.cc nodes/node_geo_subdivision_surface.cc nodes/node_geo_switch.cc nodes/node_geo_transfer_attribute.cc nodes/node_geo_transform.cc nodes/node_geo_translate_instances.cc nodes/node_geo_triangulate.cc nodes/node_geo_uv_pack_islands.cc nodes/node_geo_uv_unwrap.cc nodes/node_geo_viewer.cc nodes/node_geo_volume_cube.cc nodes/node_geo_volume_to_mesh.cc + nodes/node_geo_distribute_points_in_volume.cc node_geometry_exec.cc node_geometry_tree.cc node_geometry_util.cc node_geometry_util.hh ) set(LIB bf_bmesh bf_functions bf_geometry bf_nodes ) if(WITH_BULLET) list(APPEND INC_SYS ${BULLET_INCLUDE_DIRS} ../../../../intern/rigidbody ) + if(NOT WITH_SYSTEM_BULLET) - list(APPEND LIB - extern_bullet + list(APPEND LIB + extern_bullet ) endif() list(APPEND LIB ${BULLET_LIBRARIES} ) add_definitions(-DWITH_BULLET) endif() if(WITH_PYTHON) list(APPEND INC ../../python ) list(APPEND INC_SYS ${PYTHON_INCLUDE_DIRS} ) list(APPEND LIB ${PYTHON_LINKFLAGS} ${PYTHON_LIBRARIES} ) add_definitions(-DWITH_PYTHON) endif() if(WITH_TBB) list(APPEND INC_SYS ${TBB_INCLUDE_DIRS} ) add_definitions(-DWITH_TBB) + if(WIN32) # TBB includes Windows.h which will define min/max macros # that will collide with the stl versions. add_definitions(-DNOMINMAX) endif() endif() if(WITH_IMAGE_OPENEXR) add_definitions(-DWITH_OPENEXR) endif() if(WITH_OPENSUBDIV) add_definitions(-DWITH_OPENSUBDIV) endif() if(WITH_GMP) add_definitions(-DWITH_GMP) list(APPEND INC_SYS ${GMP_INCLUDE_DIRS} ) list(APPEND LIB ${GMP_LIBRARIES} ) endif() if(WITH_OPENVDB) list(APPEND INC_SYS ${OPENVDB_INCLUDE_DIRS} ) add_definitions(-DWITH_OPENVDB ${OPENVDB_DEFINITIONS}) endif() blender_add_lib(bf_nodes_geometry "${SRC}" "${INC}" "${INC_SYS}" "${LIB}") if(WITH_UNITY_BUILD) set_target_properties(bf_nodes_geometry PROPERTIES UNITY_BUILD ON) set_target_properties(bf_nodes_geometry PROPERTIES UNITY_BUILD_BATCH_SIZE 10) endif() # RNA_prototypes.h add_dependencies(bf_nodes_geometry bf_rna)