diff options
293 files changed, 13263 insertions, 8911 deletions
diff --git a/doc/python_api/examples/bpy.types.NodeTree.py b/doc/python_api/examples/bpy.types.NodeTree.py new file mode 100644 index 00000000000..401b3a01ae0 --- /dev/null +++ b/doc/python_api/examples/bpy.types.NodeTree.py @@ -0,0 +1,23 @@ +""" +Poll Function ++++++++++++++++ +The :class:`NodeTree.poll` function determines if a node tree is visible +in the given context (similar to how :class:`Panel.poll` +and :class:`Menu.poll` define visibility). If it returns False, +the node tree type will not be selectable in the node editor. + +A typical condition for shader nodes would be to check the active render engine +of the scene and only show nodes of the renderer they are designed for. +""" +import bpy + + +class CyclesNodeTree(bpy.types.NodeTree): + """ This operator is only visible when Cycles is the selected render engine""" + bl_label = "Cycles Node Tree" + + @classmethod + def poll(cls, context): + return context.scene.render.engine == 'CYCLES' + +bpy.utils.register_class(CyclesNodeTree) diff --git a/intern/cycles/blender/blender_python.cpp b/intern/cycles/blender/blender_python.cpp index a10f3b63033..f7a05463f66 100644 --- a/intern/cycles/blender/blender_python.cpp +++ b/intern/cycles/blender/blender_python.cpp @@ -207,6 +207,7 @@ static PyObject *available_devices_func(PyObject *self, PyObject *args) } #ifdef WITH_OSL + static PyObject *osl_update_node_func(PyObject *self, PyObject *args) { PyObject *pynodegroup, *pynode; @@ -248,17 +249,19 @@ static PyObject *osl_update_node_func(PyObject *self, PyObject *args) continue; /* determine socket type */ - BL::NodeSocket::type_enum socket_type; - float default_float4[4] = {0.0f, 0.0f, 0.0f, 1.0f}; + std::string socket_type; + BL::NodeSocket::type_enum data_type = BL::NodeSocket::type_VALUE; + float4 default_float4 = make_float4(0.0f, 0.0f, 0.0f, 1.0f); float default_float = 0.0f; int default_int = 0; std::string default_string = ""; if(param->isclosure) { - socket_type = BL::NodeSocket::type_SHADER; + socket_type = "NodeSocketShader"; } else if(param->type.vecsemantics == TypeDesc::COLOR) { - socket_type = BL::NodeSocket::type_RGBA; + socket_type = "NodeSocketColor"; + data_type = BL::NodeSocket::type_RGBA; if(param->validdefault) { default_float4[0] = param->fdefault[0]; @@ -269,7 +272,8 @@ static PyObject *osl_update_node_func(PyObject *self, PyObject *args) else if(param->type.vecsemantics == TypeDesc::POINT || param->type.vecsemantics == TypeDesc::VECTOR || param->type.vecsemantics == TypeDesc::NORMAL) { - socket_type = BL::NodeSocket::type_VECTOR; + socket_type = "NodeSocketVector"; + data_type = BL::NodeSocket::type_VECTOR; if(param->validdefault) { default_float4[0] = param->fdefault[0]; @@ -279,17 +283,20 @@ static PyObject *osl_update_node_func(PyObject *self, PyObject *args) } else if(param->type.aggregate == TypeDesc::SCALAR) { if(param->type.basetype == TypeDesc::INT) { - socket_type = BL::NodeSocket::type_INT; + socket_type = "NodeSocketInt"; + data_type = BL::NodeSocket::type_INT; if(param->validdefault) default_int = param->idefault[0]; } else if(param->type.basetype == TypeDesc::FLOAT) { - socket_type = BL::NodeSocket::type_VALUE; + socket_type = "NodeSocketFloat"; + data_type = BL::NodeSocket::type_VALUE; if(param->validdefault) default_float = param->fdefault[0]; } else if(param->type.basetype == TypeDesc::STRING) { - socket_type = BL::NodeSocket::type_STRING; + socket_type = "NodeSocketString"; + data_type = BL::NodeSocket::type_STRING; if(param->validdefault) default_string = param->sdefault[0]; } @@ -300,38 +307,52 @@ static PyObject *osl_update_node_func(PyObject *self, PyObject *args) continue; /* find socket socket */ - BL::NodeSocket b_sock = b_node.find_socket(param->name.c_str(), param->isoutput); - - /* remove if type no longer matches */ - if(b_sock && b_sock.type() != socket_type) { - b_node.remove_socket(b_sock); - b_sock = BL::NodeSocket(PointerRNA_NULL); + BL::NodeSocket b_sock(PointerRNA_NULL); + if (param->isoutput) { + b_sock = b_node.outputs[param->name]; + + /* remove if type no longer matches */ + if(b_sock && b_sock.bl_idname() != socket_type) { + b_node.outputs.remove(b_sock); + b_sock = BL::NodeSocket(PointerRNA_NULL); + } + + if (!b_sock) { + /* create new socket */ + b_sock = b_node.outputs.create(socket_type.c_str(), param->name.c_str(), param->name.c_str()); + } + } + else { + b_sock = b_node.inputs[param->name]; + + /* remove if type no longer matches */ + if(b_sock && b_sock.bl_idname() != socket_type) { + b_node.inputs.remove(b_sock); + b_sock = BL::NodeSocket(PointerRNA_NULL); + } + + if (!b_sock) { + /* create new socket */ + b_sock = b_node.inputs.create(socket_type.c_str(), param->name.c_str(), param->name.c_str()); + } } - /* create new socket */ - if(!b_sock) { - b_sock = b_node.add_socket(param->name.c_str(), socket_type, param->isoutput); - - /* set default value */ - if(socket_type == BL::NodeSocket::type_VALUE) { - BL::NodeSocketFloatNone b_float_sock(b_sock.ptr); - b_float_sock.default_value(default_float); + /* set default value */ + if(b_sock) { + if(data_type == BL::NodeSocket::type_VALUE) { + set_float(b_sock.ptr, "default_value", default_float); } - else if(socket_type == BL::NodeSocket::type_INT) { - BL::NodeSocketIntNone b_int_sock(b_sock.ptr); - b_int_sock.default_value(default_int); + else if(data_type == BL::NodeSocket::type_INT) { + set_int(b_sock.ptr, "default_value", default_int); } - else if(socket_type == BL::NodeSocket::type_RGBA) { - BL::NodeSocketRGBA b_rgba_sock(b_sock.ptr); - b_rgba_sock.default_value(default_float4); + else if(data_type == BL::NodeSocket::type_RGBA) { + set_float4(b_sock.ptr, "default_value", default_float4); } - else if(socket_type == BL::NodeSocket::type_VECTOR) { - BL::NodeSocketVectorNone b_vector_sock(b_sock.ptr); - b_vector_sock.default_value(default_float4); + else if(data_type == BL::NodeSocket::type_VECTOR) { + set_float3(b_sock.ptr, "default_value", float4_to_float3(default_float4)); } - else if(socket_type == BL::NodeSocket::type_STRING) { - BL::NodeSocketStringNone b_string_sock(b_sock.ptr); - b_string_sock.default_value(default_string); + else if(data_type == BL::NodeSocket::type_STRING) { + set_string(b_sock.ptr, "default_value", default_string); } } @@ -349,7 +370,7 @@ static PyObject *osl_update_node_func(PyObject *self, PyObject *args) for (b_node.inputs.begin(b_input); b_input != b_node.inputs.end(); ++b_input) { if(used_sockets.find(b_input->ptr.data) == used_sockets.end()) { - b_node.remove_socket(*b_input); + b_node.inputs.remove(*b_input); removed = true; break; } @@ -357,7 +378,7 @@ static PyObject *osl_update_node_func(PyObject *self, PyObject *args) for (b_node.outputs.begin(b_output); b_output != b_node.outputs.end(); ++b_output) { if(used_sockets.find(b_output->ptr.data) == used_sockets.end()) { - b_node.remove_socket(*b_output); + b_node.outputs.remove(*b_output); removed = true; break; } diff --git a/intern/cycles/blender/blender_shader.cpp b/intern/cycles/blender/blender_shader.cpp index 0f7dc15db19..45a97f1d530 100644 --- a/intern/cycles/blender/blender_shader.cpp +++ b/intern/cycles/blender/blender_shader.cpp @@ -31,9 +31,9 @@ CCL_NAMESPACE_BEGIN -typedef map<void*, ShaderNode*> PtrNodeMap; -typedef pair<ShaderNode*, std::string> SocketPair; -typedef map<void*, SocketPair> PtrSockMap; +typedef map<void*, ShaderInput*> PtrInputMap; +typedef map<void*, ShaderOutput*> PtrOutputMap; +typedef map<std::string, ProxyNode*> ProxyMap; /* Find */ @@ -55,83 +55,88 @@ void BlenderSync::find_shader(BL::ID id, vector<uint>& used_shaders, int default static BL::NodeSocket get_node_output(BL::Node b_node, const string& name) { BL::Node::outputs_iterator b_out; - + for(b_node.outputs.begin(b_out); b_out != b_node.outputs.end(); ++b_out) if(b_out->name() == name) return *b_out; - + assert(0); - + return *b_out; } static float3 get_node_output_rgba(BL::Node b_node, const string& name) { - BL::NodeSocketRGBA sock(get_node_output(b_node, name)); - return get_float3(sock.default_value()); + BL::NodeSocket b_sock = get_node_output(b_node, name); + float value[4]; + RNA_float_get_array(&b_sock.ptr, "default_value", value); + return make_float3(value[0], value[1], value[2]); } static float get_node_output_value(BL::Node b_node, const string& name) { - BL::NodeSocketFloatNone sock(get_node_output(b_node, name)); - return sock.default_value(); + BL::NodeSocket b_sock = get_node_output(b_node, name); + return RNA_float_get(&b_sock.ptr, "default_value"); } -static ShaderSocketType convert_socket_type(BL::NodeSocket::type_enum b_type) +static float3 get_node_output_vector(BL::Node b_node, const string& name) { - switch (b_type) { - case BL::NodeSocket::type_VALUE: - return SHADER_SOCKET_FLOAT; - case BL::NodeSocket::type_INT: - return SHADER_SOCKET_INT; - case BL::NodeSocket::type_VECTOR: - return SHADER_SOCKET_VECTOR; - case BL::NodeSocket::type_RGBA: - return SHADER_SOCKET_COLOR; - case BL::NodeSocket::type_SHADER: - return SHADER_SOCKET_CLOSURE; - case BL::NodeSocket::type_STRING: - return SHADER_SOCKET_STRING; - - case BL::NodeSocket::type_BOOLEAN: - case BL::NodeSocket::type_MESH: - default: - return SHADER_SOCKET_FLOAT; + BL::NodeSocket b_sock = get_node_output(b_node, name); + float value[3]; + RNA_float_get_array(&b_sock.ptr, "default_value", value); + return make_float3(value[0], value[1], value[2]); +} + +static ShaderSocketType convert_socket_type(BL::NodeSocket b_socket) +{ + switch (b_socket.type()) { + case BL::NodeSocket::type_VALUE: + return SHADER_SOCKET_FLOAT; + case BL::NodeSocket::type_INT: + return SHADER_SOCKET_INT; + case BL::NodeSocket::type_VECTOR: + return SHADER_SOCKET_VECTOR; + case BL::NodeSocket::type_RGBA: + return SHADER_SOCKET_COLOR; + case BL::NodeSocket::type_STRING: + return SHADER_SOCKET_STRING; + case BL::NodeSocket::type_SHADER: + return SHADER_SOCKET_CLOSURE; + + default: + return SHADER_SOCKET_UNDEFINED; } } -static void set_default_value(ShaderInput *input, BL::NodeSocket sock, BL::BlendData b_data, BL::ID b_id) +static void set_default_value(ShaderInput *input, BL::Node b_node, BL::NodeSocket b_sock, BL::BlendData b_data, BL::ID b_id) { /* copy values for non linked inputs */ switch(input->type) { case SHADER_SOCKET_FLOAT: { - BL::NodeSocketFloatNone value_sock(sock); - input->set(value_sock.default_value()); + input->set(get_float(b_sock.ptr, "default_value")); break; } case SHADER_SOCKET_INT: { - BL::NodeSocketIntNone value_sock(sock); - input->set((float)value_sock.default_value()); + input->set((float)get_int(b_sock.ptr, "default_value")); break; } case SHADER_SOCKET_COLOR: { - BL::NodeSocketRGBA rgba_sock(sock); - input->set(get_float3(rgba_sock.default_value())); + input->set(float4_to_float3(get_float4(b_sock.ptr, "default_value"))); break; } case SHADER_SOCKET_NORMAL: case SHADER_SOCKET_POINT: case SHADER_SOCKET_VECTOR: { - BL::NodeSocketVectorNone vec_sock(sock); - input->set(get_float3(vec_sock.default_value())); + input->set(get_float3(b_sock.ptr, "default_value")); break; } case SHADER_SOCKET_STRING: { - BL::NodeSocketStringNone string_sock(sock); - input->set((ustring)blender_absolute_path(b_data, b_id, string_sock.default_value())); + input->set((ustring)blender_absolute_path(b_data, b_id, get_string(b_sock.ptr, "default_value"))); break; } + case SHADER_SOCKET_CLOSURE: + case SHADER_SOCKET_UNDEFINED: break; } } @@ -171,295 +176,226 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen { ShaderNode *node = NULL; - switch(b_node.type()) { - /* not supported */ - case BL::ShaderNode::type_GEOMETRY: break; - case BL::ShaderNode::type_MATERIAL: break; - case BL::ShaderNode::type_MATERIAL_EXT: break; - case BL::ShaderNode::type_OUTPUT: break; - case BL::ShaderNode::type_SQUEEZE: break; - case BL::ShaderNode::type_TEXTURE: break; - case BL::ShaderNode::type_FRAME: break; - /* handled outside this function */ - case BL::ShaderNode::type_GROUP: break; - /* existing blender nodes */ - case BL::ShaderNode::type_REROUTE: { - BL::Node::inputs_iterator b_input; - b_node.inputs.begin(b_input); - BL::Node::outputs_iterator b_output; - b_node.outputs.begin(b_output); - ProxyNode *proxy = new ProxyNode(convert_socket_type(b_input->type()), convert_socket_type(b_output->type())); - node = proxy; - break; - } - case BL::ShaderNode::type_CURVE_VEC: { - BL::ShaderNodeVectorCurve b_curve_node(b_node); - VectorCurvesNode *curves = new VectorCurvesNode(); - curvemapping_color_to_array(b_curve_node.mapping(), curves->curves, RAMP_TABLE_SIZE, false); - node = curves; - break; - } - case BL::ShaderNode::type_CURVE_RGB: { - BL::ShaderNodeRGBCurve b_curve_node(b_node); - RGBCurvesNode *curves = new RGBCurvesNode(); - curvemapping_color_to_array(b_curve_node.mapping(), curves->curves, RAMP_TABLE_SIZE, true); - node = curves; - break; - } - case BL::ShaderNode::type_VALTORGB: { - RGBRampNode *ramp = new RGBRampNode(); - BL::ShaderNodeValToRGB b_ramp_node(b_node); - colorramp_to_array(b_ramp_node.color_ramp(), ramp->ramp, RAMP_TABLE_SIZE); - node = ramp; - break; - } - case BL::ShaderNode::type_RGB: { - ColorNode *color = new ColorNode(); - color->value = get_node_output_rgba(b_node, "Color"); - node = color; - break; - } - case BL::ShaderNode::type_VALUE: { - ValueNode *value = new ValueNode(); - value->value = get_node_output_value(b_node, "Value"); - node = value; - break; - } - case BL::ShaderNode::type_CAMERA: { - node = new CameraNode(); - break; - } - case BL::ShaderNode::type_INVERT: { - node = new InvertNode(); - break; - } - case BL::ShaderNode::type_GAMMA: { - node = new GammaNode(); - break; - } - case BL::ShaderNode::type_BRIGHTCONTRAST: { - node = new BrightContrastNode(); - break; - } - case BL::ShaderNode::type_MIX_RGB: { - BL::ShaderNodeMixRGB b_mix_node(b_node); - MixNode *mix = new MixNode(); - mix->type = MixNode::type_enum[b_mix_node.blend_type()]; + /* existing blender nodes */ + if (b_node.is_a(&RNA_ShaderNodeRGBCurve)) { + BL::ShaderNodeRGBCurve b_curve_node(b_node); + RGBCurvesNode *curves = new RGBCurvesNode(); + curvemapping_color_to_array(b_curve_node.mapping(), curves->curves, RAMP_TABLE_SIZE, true); + node = curves; + } + if (b_node.is_a(&RNA_ShaderNodeVectorCurve)) { + BL::ShaderNodeVectorCurve b_curve_node(b_node); + VectorCurvesNode *curves = new VectorCurvesNode(); + curvemapping_color_to_array(b_curve_node.mapping(), curves->curves, RAMP_TABLE_SIZE, false); + node = curves; + } + else if (b_node.is_a(&RNA_ShaderNodeValToRGB)) { + RGBRampNode *ramp = new RGBRampNode(); + BL::ShaderNodeValToRGB b_ramp_node(b_node); + colorramp_to_array(b_ramp_node.color_ramp(), ramp->ramp, RAMP_TABLE_SIZE); + node = ramp; + } + else if (b_node.is_a(&RNA_ShaderNodeRGB)) { + ColorNode *color = new ColorNode(); + color->value = get_node_output_rgba(b_node, "Color"); + node = color; + } + else if (b_node.is_a(&RNA_ShaderNodeValue)) { + ValueNode *value = new ValueNode(); + value->value = get_node_output_value(b_node, "Value"); + node = value; + } + else if (b_node.is_a(&RNA_ShaderNodeCameraData)) { + node = new CameraNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeInvert)) { + node = new InvertNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeGamma)) { + node = new GammaNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeBrightContrast)) { + node = new BrightContrastNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeMixRGB)) { + BL::ShaderNodeMixRGB b_mix_node(b_node); + MixNode *mix = new MixNode(); + mix->type = MixNode::type_enum[b_mix_node.blend_type()]; mix->use_clamp = b_mix_node.use_clamp(); - node = mix; - break; - } - case BL::ShaderNode::type_SEPRGB: { - node = new SeparateRGBNode(); - break; - } - case BL::ShaderNode::type_COMBRGB: { - node = new CombineRGBNode(); - break; - } - case BL::ShaderNode::type_HUE_SAT: { - node = new HSVNode(); - break; - } - case BL::ShaderNode::type_RGBTOBW: { - node = new ConvertNode(SHADER_SOCKET_COLOR, SHADER_SOCKET_FLOAT); - break; - } - case BL::ShaderNode::type_MATH: { - BL::ShaderNodeMath b_math_node(b_node); - MathNode *math = new MathNode(); - math->type = MathNode::type_enum[b_math_node.operation()]; + node = mix; + } + else if (b_node.is_a(&RNA_ShaderNodeSeparateRGB)) { + node = new SeparateRGBNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeCombineRGB)) { + node = new CombineRGBNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeHueSaturation)) { + node = new HSVNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeRGBToBW)) { + node = new ConvertNode(SHADER_SOCKET_COLOR, SHADER_SOCKET_FLOAT); + } + else if (b_node.is_a(&RNA_ShaderNodeMath)) { + BL::ShaderNodeMath b_math_node(b_node); + MathNode *math = new MathNode(); + math->type = MathNode::type_enum[b_math_node.operation()]; math->use_clamp = b_math_node.use_clamp(); - node = math; - break; - } - case BL::ShaderNode::type_VECT_MATH: { - BL::ShaderNodeVectorMath b_vector_math_node(b_node); - VectorMathNode *vmath = new VectorMathNode(); - vmath->type = VectorMathNode::type_enum[b_vector_math_node.operation()]; - node = vmath; - break; - } - case BL::ShaderNode::type_NORMAL: { - BL::Node::outputs_iterator out_it; - b_node.outputs.begin(out_it); - BL::NodeSocketVectorNone vec_sock(*out_it); - - NormalNode *norm = new NormalNode(); - norm->direction = get_float3(vec_sock.default_value()); - - node = norm; - break; - } - case BL::ShaderNode::type_MAPPING: { - BL::ShaderNodeMapping b_mapping_node(b_node); - MappingNode *mapping = new MappingNode(); - - get_tex_mapping(&mapping->tex_mapping, b_mapping_node); - - node = mapping; - break; - } - - /* new nodes */ - case BL::ShaderNode::type_OUTPUT_MATERIAL: - case BL::ShaderNode::type_OUTPUT_WORLD: - case BL::ShaderNode::type_OUTPUT_LAMP: { - node = graph->output(); - break; - } - case BL::ShaderNode::type_FRESNEL: { - node = new FresnelNode(); - break; - } - case BL::ShaderNode::type_LAYER_WEIGHT: { - node = new LayerWeightNode(); - break; - } - case BL::ShaderNode::type_ADD_SHADER: { - node = new AddClosureNode(); - break; - } - case BL::ShaderNode::type_MIX_SHADER: { - node = new MixClosureNode(); - break; - } - case BL::ShaderNode::type_ATTRIBUTE: { - BL::ShaderNodeAttribute b_attr_node(b_node); - AttributeNode *attr = new AttributeNode(); - attr->attribute = b_attr_node.attribute_name(); - node = attr; - break; - } - case BL::ShaderNode::type_BACKGROUND: { - node = new BackgroundNode(); - break; - } - case BL::ShaderNode::type_HOLDOUT: { - node = new HoldoutNode(); - break; - } - case BL::ShaderNode::type_BSDF_ANISOTROPIC: { - node = new WardBsdfNode(); - break; - } - case BL::ShaderNode::type_BSDF_DIFFUSE: { - node = new DiffuseBsdfNode(); - break; - } - case BL::ShaderNode::type_BSDF_GLOSSY: { - BL::ShaderNodeBsdfGlossy b_glossy_node(b_node); - GlossyBsdfNode *glossy = new GlossyBsdfNode(); - - switch(b_glossy_node.distribution()) { - case BL::ShaderNodeBsdfGlossy::distribution_SHARP: - glossy->distribution = ustring("Sharp"); - break; - case BL::ShaderNodeBsdfGlossy::distribution_BECKMANN: - glossy->distribution = ustring("Beckmann"); - break; - case BL::ShaderNodeBsdfGlossy::distribution_GGX: - glossy->distribution = ustring("GGX"); - break; - } - node = glossy; - break; - } - case BL::ShaderNode::type_BSDF_GLASS: { - BL::ShaderNodeBsdfGlass b_glass_node(b_node); - GlassBsdfNode *glass = new GlassBsdfNode(); - switch(b_glass_node.distribution()) { - case BL::ShaderNodeBsdfGlass::distribution_SHARP: - glass->distribution = ustring("Sharp"); - break; - case BL::ShaderNodeBsdfGlass::distribution_BECKMANN: - glass->distribution = ustring("Beckmann"); - break; - case BL::ShaderNodeBsdfGlass::distribution_GGX: - glass->distribution = ustring("GGX"); - break; - } - node = glass; - break; - } - case BL::ShaderNode::type_BSDF_REFRACTION: { - BL::ShaderNodeBsdfRefraction b_refraction_node(b_node); - RefractionBsdfNode *refraction = new RefractionBsdfNode(); - switch(b_refraction_node.distribution()) { - case BL::ShaderNodeBsdfRefraction::distribution_SHARP: - refraction->distribution = ustring("Sharp"); - break; - case BL::ShaderNodeBsdfRefraction::distribution_BECKMANN: - refraction->distribution = ustring("Beckmann"); - break; - case BL::ShaderNodeBsdfRefraction::distribution_GGX: - refraction->distribution = ustring("GGX"); - break; - } - node = refraction; - break; - } - case BL::ShaderNode::type_BSDF_TRANSLUCENT: { - node = new TranslucentBsdfNode(); - break; - } - case BL::ShaderNode::type_BSDF_TRANSPARENT: { - node = new TransparentBsdfNode(); - break; - } - case BL::ShaderNode::type_BSDF_VELVET: { - node = new VelvetBsdfNode(); - break; - } - case BL::ShaderNode::type_EMISSION: { - node = new EmissionNode(); - break; - } - case BL::ShaderNode::type_AMBIENT_OCCLUSION: { - node = new AmbientOcclusionNode(); - break; - } - case BL::ShaderNode::type_VOLUME_ISOTROPIC: { - node = new IsotropicVolumeNode(); - break; - } - case BL::ShaderNode::type_VOLUME_TRANSPARENT: { - node = new TransparentVolumeNode(); - break; - } - case BL::ShaderNode::type_NEW_GEOMETRY: { - node = new GeometryNode(); + node = math; + } + else if (b_node.is_a(&RNA_ShaderNodeVectorMath)) { + BL::ShaderNodeVectorMath b_vector_math_node(b_node); + VectorMathNode *vmath = new VectorMathNode(); + vmath->type = VectorMathNode::type_enum[b_vector_math_node.operation()]; + node = vmath; + } + else if (b_node.is_a(&RNA_ShaderNodeNormal)) { + BL::Node::outputs_iterator out_it; + b_node.outputs.begin(out_it); + BL::NodeSocket vec_sock(*out_it); + + NormalNode *norm = new NormalNode(); + norm->direction = get_node_output_vector(b_node, "Normal"); + node = norm; + } + else if (b_node.is_a(&RNA_ShaderNodeMapping)) { + BL::ShaderNodeMapping b_mapping_node(b_node); + MappingNode *mapping = new MappingNode(); + + get_tex_mapping(&mapping->tex_mapping, b_mapping_node); + + node = mapping; + } + /* new nodes */ + else if (b_node.is_a(&RNA_ShaderNodeOutputMaterial) + || b_node.is_a(&RNA_ShaderNodeOutputWorld) + || b_node.is_a(&RNA_ShaderNodeOutputLamp)) { + node = graph->output(); + } + else if (b_node.is_a(&RNA_ShaderNodeFresnel)) { + node = new FresnelNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeLayerWeight)) { + node = new LayerWeightNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeAddShader)) { + node = new AddClosureNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeMixShader)) { + node = new MixClosureNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeAttribute)) { + BL::ShaderNodeAttribute b_attr_node(b_node); + AttributeNode *attr = new AttributeNode(); + attr->attribute = b_attr_node.attribute_name(); + node = attr; + } + else if (b_node.is_a(&RNA_ShaderNodeBackground)) { + node = new BackgroundNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeHoldout)) { + node = new HoldoutNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeBsdfAnisotropic)) { + node = new WardBsdfNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeBsdfDiffuse)) { + node = new DiffuseBsdfNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeBsdfGlossy)) { + BL::ShaderNodeBsdfGlossy b_glossy_node(b_node); + GlossyBsdfNode *glossy = new GlossyBsdfNode(); + + switch(b_glossy_node.distribution()) { + case BL::ShaderNodeBsdfGlossy::distribution_SHARP: + glossy->distribution = ustring("Sharp"); break; - } - case BL::ShaderNode::type_LIGHT_PATH: { - node = new LightPathNode(); + case BL::ShaderNodeBsdfGlossy::distribution_BECKMANN: + glossy->distribution = ustring("Beckmann"); break; - } - case BL::ShaderNode::type_LIGHT_FALLOFF: { - node = new LightFalloffNode(); + case BL::ShaderNodeBsdfGlossy::distribution_GGX: + glossy->distribution = ustring("GGX"); break; } - case BL::ShaderNode::type_OBJECT_INFO: { - node = new ObjectInfoNode(); + node = glossy; + } + else if (b_node.is_a(&RNA_ShaderNodeBsdfGlass)) { + BL::ShaderNodeBsdfGlass b_glass_node(b_node); + GlassBsdfNode *glass = new GlassBsdfNode(); + switch(b_glass_node.distribution()) { + case BL::ShaderNodeBsdfGlass::distribution_SHARP: + glass->distribution = ustring("Sharp"); break; - } - case BL::ShaderNode::type_PARTICLE_INFO: { - node = new ParticleInfoNode(); + case BL::ShaderNodeBsdfGlass::distribution_BECKMANN: + glass->distribution = ustring("Beckmann"); break; - } - case BL::ShaderNode::type_HAIR_INFO: { - node = new HairInfoNode(); + case BL::ShaderNodeBsdfGlass::distribution_GGX: + glass->distribution = ustring("GGX"); break; } - case BL::ShaderNode::type_BUMP: { - node = new BumpNode(); - break; + node = glass; + } + else if (b_node.is_a(&RNA_ShaderNodeBsdfRefraction)) { + BL::ShaderNodeBsdfRefraction b_refraction_node(b_node); + RefractionBsdfNode *refraction = new RefractionBsdfNode(); + switch(b_refraction_node.distribution()) { + case BL::ShaderNodeBsdfRefraction::distribution_SHARP: + refraction->distribution = ustring("Sharp"); + break; + case BL::ShaderNodeBsdfRefraction::distribution_BECKMANN: + refraction->distribution = ustring("Beckmann"); + break; + case BL::ShaderNodeBsdfRefraction::distribution_GGX: + refraction->distribution = ustring("GGX"); + break; } - case BL::ShaderNode::type_SCRIPT: { + node = refraction; + } + else if (b_node.is_a(&RNA_ShaderNodeBsdfTranslucent)) { + node = new TranslucentBsdfNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeBsdfTransparent)) { + node = new TransparentBsdfNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeBsdfVelvet)) { + node = new VelvetBsdfNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeEmission)) { + node = new EmissionNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeAmbientOcclusion)) { + node = new AmbientOcclusionNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeVolumeIsotropic)) { + node = new IsotropicVolumeNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeVolumeTransparent)) { + node = new TransparentVolumeNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeNewGeometry)) { + node = new GeometryNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeLightPath)) { + node = new LightPathNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeLightFalloff)) { + node = new LightFalloffNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeObjectInfo)) { + node = new ObjectInfoNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeParticleInfo)) { + node = new ParticleInfoNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeHairInfo)) { + node = new HairInfoNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeBump)) { + node = new BumpNode(); + } + else if (b_node.is_a(&RNA_ShaderNodeScript)) { #ifdef WITH_OSL - if(!scene->shader_manager->use_osl()) - break; - + if(scene->shader_manager->use_osl()) { /* create script node */ BL::ShaderNodeScript b_script_node(b_node); OSLScriptNode *script_node = new OSLScriptNode(); @@ -472,29 +408,31 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen * Note 2: ShaderInput/ShaderOutput store shallow string copies only! * Socket names must be stored in the extra lists instead. */ BL::Node::inputs_iterator b_input; - + for (b_script_node.inputs.begin(b_input); b_input != b_script_node.inputs.end(); ++b_input) { script_node->input_names.push_back(ustring(b_input->name())); - ShaderInput *input = script_node->add_input(script_node->input_names.back().c_str(), convert_socket_type(b_input->type())); - set_default_value(input, *b_input, b_data, b_ntree); + ShaderInput *input = script_node->add_input(script_node->input_names.back().c_str(), + convert_socket_type(*b_input)); + set_default_value(input, b_node, *b_input, b_data, b_ntree); } - + BL::Node::outputs_iterator b_output; - + for (b_script_node.outputs.begin(b_output); b_output != b_script_node.outputs.end(); ++b_output) { script_node->output_names.push_back(ustring(b_output->name())); - script_node->add_output(script_node->output_names.back().c_str(), convert_socket_type(b_output->type())); + script_node->add_output(script_node->output_names.back().c_str(), + convert_socket_type(*b_output)); } - + /* load bytecode or filepath */ OSLShaderManager *manager = (OSLShaderManager*)scene->shader_manager; string bytecode_hash = b_script_node.bytecode_hash(); - + if(!bytecode_hash.empty()) { /* loaded bytecode if not already done */ if(!manager->shader_test_loaded(bytecode_hash)) manager->shader_load_bytecode(bytecode_hash, b_script_node.bytecode()); - + script_node->bytecode_hash = bytecode_hash; } else { @@ -503,173 +441,157 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen } node = script_node; -#endif - - break; } - case BL::ShaderNode::type_TEX_IMAGE: { - BL::ShaderNodeTexImage b_image_node(b_node); - BL::Image b_image(b_image_node.image()); - ImageTextureNode *image = new ImageTextureNode(); - if(b_image) { - /* builtin images will use callback-based reading because - * they could only be loaded correct from blender side +#endif + } + else if (b_node.is_a(&RNA_ShaderNodeTexImage)) { + BL::ShaderNodeTexImage b_image_node(b_node); + BL::Image b_image(b_image_node.image()); + ImageTextureNode *image = new ImageTextureNode(); + if(b_image) { + /* builtin images will use callback-based reading because + * they could only be loaded correct from blender side + */ + bool is_builtin = b_image.packed_file() || + b_image.source() == BL::Image::source_GENERATED || + b_image.source() == BL::Image::source_MOVIE; + + if(is_builtin) { + /* for builtin images we're using image datablock name to find an image to + * read pixels from later + * + * also store frame number as well, so there's no differences in handling + * builtin names for packed images and movies */ - bool is_builtin = b_image.packed_file() || - b_image.source() == BL::Image::source_GENERATED || - b_image.source() == BL::Image::source_MOVIE; - - if(is_builtin) { - /* for builtin images we're using image datablock name to find an image to - * read pixels from later - * - * also store frame number as well, so there's no differences in handling - * builtin names for packed images and movies - */ - int scene_frame = b_scene.frame_current(); - int image_frame = image_user_frame_number(b_image_node.image_user(), scene_frame); - image->filename = b_image.name() + "@" + string_printf("%d", image_frame); - image->builtin_data = b_image.ptr.data; - } - else { - image->filename = image_user_file_path(b_image_node.image_user(), b_image, b_scene.frame_current()); - image->builtin_data = NULL; - } - - image->animated = b_image_node.image_user().use_auto_refresh(); + int scene_frame = b_scene.frame_current(); + int image_frame = image_user_frame_number(b_image_node.image_user(), scene_frame); + image->filename = b_image.name() + "@" + string_printf("%d", image_frame); + image->builtin_data = b_image.ptr.data; } - image->color_space = ImageTextureNode::color_space_enum[(int)b_image_node.color_space()]; - image->projection = ImageTextureNode::projection_enum[(int)b_image_node.projection()]; - image->projection_blend = b_image_node.projection_blend(); - get_tex_mapping(&image->tex_mapping, b_image_node.texture_mapping()); - node = image; - break; - } - case BL::ShaderNode::type_TEX_ENVIRONMENT: { - BL::ShaderNodeTexEnvironment b_env_node(b_node); - BL::Image b_image(b_env_node.image()); - EnvironmentTextureNode *env = new EnvironmentTextureNode(); - if(b_image) { - bool is_builtin = b_image.packed_file() || - b_image.source() == BL::Image::source_GENERATED || - b_image.source() == BL::Image::source_MOVIE; - - if(is_builtin) { - int scene_frame = b_scene.frame_current(); - int image_frame = image_user_frame_number(b_env_node.image_user(), scene_frame); - env->filename = b_image.name() + "@" + string_printf("%d", image_frame); - env->builtin_data = b_image.ptr.data; - } - else { - env->filename = image_user_file_path(b_env_node.image_user(), b_image, b_scene.frame_current()); - env->animated = b_env_node.image_user().use_auto_refresh(); - env->builtin_data = NULL; - } + else { + image->filename = image_user_file_path(b_image_node.image_user(), b_image, b_scene.frame_current()); + image->builtin_data = NULL; } - env->color_space = EnvironmentTextureNode::color_space_enum[(int)b_env_node.color_space()]; - env->projection = EnvironmentTextureNode::projection_enum[(int)b_env_node.projection()]; - get_tex_mapping(&env->tex_mapping, b_env_node.texture_mapping()); - node = env; - break; - } - case BL::ShaderNode::type_TEX_GRADIENT: { - BL::ShaderNodeTexGradient b_gradient_node(b_node); - GradientTextureNode *gradient = new GradientTextureNode(); - gradient->type = GradientTextureNode::type_enum[(int)b_gradient_node.gradient_type()]; - get_tex_mapping(&gradient->tex_mapping, b_gradient_node.texture_mapping()); - node = gradient; - break; - } - case BL::ShaderNode::type_TEX_VORONOI: { - BL::ShaderNodeTexVoronoi b_voronoi_node(b_node); - VoronoiTextureNode *voronoi = new VoronoiTextureNode(); - voronoi->coloring = VoronoiTextureNode::coloring_enum[(int)b_voronoi_node.coloring()]; - get_tex_mapping(&voronoi->tex_mapping, b_voronoi_node.texture_mapping()); - node = voronoi; - break; - } - case BL::ShaderNode::type_TEX_MAGIC: { - BL::ShaderNodeTexMagic b_magic_node(b_node); - MagicTextureNode *magic = new MagicTextureNode(); - magic->depth = b_magic_node.turbulence_depth(); - get_tex_mapping(&magic->tex_mapping, b_magic_node.texture_mapping()); - node = magic; - break; - } - case BL::ShaderNode::type_TEX_WAVE: { - BL::ShaderNodeTexWave b_wave_node(b_node); - WaveTextureNode *wave = new WaveTextureNode(); - wave->type = WaveTextureNode::type_enum[(int)b_wave_node.wave_type()]; - get_tex_mapping(&wave->tex_mapping, b_wave_node.texture_mapping()); - node = wave; - break; - } - case BL::ShaderNode::type_TEX_CHECKER: { - BL::ShaderNodeTexChecker b_checker_node(b_node); - CheckerTextureNode *checker = new CheckerTextureNode(); - get_tex_mapping(&checker->tex_mapping, b_checker_node.texture_mapping()); - node = checker; - break; - } - case BL::ShaderNode::type_TEX_BRICK: { - BL::ShaderNodeTexBrick b_brick_node(b_node); - BrickTextureNode *brick = new BrickTextureNode(); - brick->offset = b_brick_node.offset(); - brick->offset_frequency = b_brick_node.offset_frequency(); - brick->squash = b_brick_node.squash(); - brick->squash_frequency = b_brick_node.squash_frequency(); - get_tex_mapping(&brick->tex_mapping, b_brick_node.texture_mapping()); - node = brick; - break; - } - case BL::ShaderNode::type_TEX_NOISE: { - BL::ShaderNodeTexNoise b_noise_node(b_node); - NoiseTextureNode *noise = new NoiseTextureNode(); - get_tex_mapping(&noise->tex_mapping, b_noise_node.texture_mapping()); - node = noise; - break; - } - case BL::ShaderNode::type_TEX_MUSGRAVE: { - BL::ShaderNodeTexMusgrave b_musgrave_node(b_node); - MusgraveTextureNode *musgrave = new MusgraveTextureNode(); - musgrave->type = MusgraveTextureNode::type_enum[(int)b_musgrave_node.musgrave_type()]; - get_tex_mapping(&musgrave->tex_mapping, b_musgrave_node.texture_mapping()); - node = musgrave; - break; - } - case BL::ShaderNode::type_TEX_COORD: { - BL::ShaderNodeTexCoord b_tex_coord_node(b_node); - TextureCoordinateNode *tex_coord = new TextureCoordinateNode(); - tex_coord->from_dupli = b_tex_coord_node.from_dupli(); - node = tex_coord; - break; - } - case BL::ShaderNode::type_TEX_SKY: { - BL::ShaderNodeTexSky b_sky_node(b_node); - SkyTextureNode *sky = new SkyTextureNode(); - sky->sun_direction = get_float3(b_sky_node.sun_direction()); - sky->turbidity = b_sky_node.turbidity(); - get_tex_mapping(&sky->tex_mapping, b_sky_node.texture_mapping()); - node = sky; - break; - } - case BL::ShaderNode::type_NORMAL_MAP: { - BL::ShaderNodeNormalMap b_normal_map_node(b_node); - NormalMapNode *nmap = new NormalMapNode(); - nmap->space = NormalMapNode::space_enum[(int)b_normal_map_node.space()]; - nmap->attribute = b_normal_map_node.uv_map(); - node = nmap; - break; + + image->animated = b_image_node.image_user().use_auto_refresh(); } - case BL::ShaderNode::type_TANGENT: { - BL::ShaderNodeTangent b_tangent_node(b_node); - TangentNode *tangent = new TangentNode(); - tangent->direction_type = TangentNode::direction_type_enum[(int)b_tangent_node.direction_type()]; - tangent->axis = TangentNode::axis_enum[(int)b_tangent_node.axis()]; - tangent->attribute = b_tangent_node.uv_map(); - node = tangent; - break; + image->color_space = ImageTextureNode::color_space_enum[(int)b_image_node.color_space()]; + image->projection = ImageTextureNode::projection_enum[(int)b_image_node.projection()]; + image->projection_blend = b_image_node.projection_blend(); + get_tex_mapping(&image->tex_mapping, b_image_node.texture_mapping()); + node = image; + } + else if (b_node.is_a(&RNA_ShaderNodeTexEnvironment)) { + BL::ShaderNodeTexEnvironment b_env_node(b_node); + BL::Image b_image(b_env_node.image()); + EnvironmentTextureNode *env = new EnvironmentTextureNode(); + if(b_image) { + bool is_builtin = b_image.packed_file() || + b_image.source() == BL::Image::source_GENERATED || + b_image.source() == BL::Image::source_MOVIE; + + if(is_builtin) { + int scene_frame = b_scene.frame_current(); + int image_frame = image_user_frame_number(b_env_node.image_user(), scene_frame); + env->filename = b_image.name() + "@" + string_printf("%d", image_frame); + env->builtin_data = b_image.ptr.data; + } + else { + env->filename = image_user_file_path(b_env_node.image_user(), b_image, b_scene.frame_current()); + env->animated = b_env_node.image_user().use_auto_refresh(); + env->builtin_data = NULL; + } } + env->color_space = EnvironmentTextureNode::color_space_enum[(int)b_env_node.color_space()]; + env->projection = EnvironmentTextureNode::projection_enum[(int)b_env_node.projection()]; + get_tex_mapping(&env->tex_mapping, b_env_node.texture_mapping()); + node = env; + } + else if (b_node.is_a(&RNA_ShaderNodeTexGradient)) { + BL::ShaderNodeTexGradient b_gradient_node(b_node); + GradientTextureNode *gradient = new GradientTextureNode(); + gradient->type = GradientTextureNode::type_enum[(int)b_gradient_node.gradient_type()]; + get_tex_mapping(&gradient->tex_mapping, b_gradient_node.texture_mapping()); + node = gradient; + } + else if (b_node.is_a(&RNA_ShaderNodeTexVoronoi)) { + BL::ShaderNodeTexVoronoi b_voronoi_node(b_node); + VoronoiTextureNode *voronoi = new VoronoiTextureNode(); + voronoi->coloring = VoronoiTextureNode::coloring_enum[(int)b_voronoi_node.coloring()]; + get_tex_mapping(&voronoi->tex_mapping, b_voronoi_node.texture_mapping()); + node = voronoi; + } + else if (b_node.is_a(&RNA_ShaderNodeTexMagic)) { + BL::ShaderNodeTexMagic b_magic_node(b_node); + MagicTextureNode *magic = new MagicTextureNode(); + magic->depth = b_magic_node.turbulence_depth(); + get_tex_mapping(&magic->tex_mapping, b_magic_node.texture_mapping()); + node = magic; + } + else if (b_node.is_a(&RNA_ShaderNodeTexWave)) { + BL::ShaderNodeTexWave b_wave_node(b_node); + WaveTextureNode *wave = new WaveTextureNode(); + wave->type = WaveTextureNode::type_enum[(int)b_wave_node.wave_type()]; + get_tex_mapping(&wave->tex_mapping, b_wave_node.texture_mapping()); + node = wave; + } + else if (b_node.is_a(&RNA_ShaderNodeTexChecker)) { + BL::ShaderNodeTexChecker b_checker_node(b_node); + CheckerTextureNode *checker = new CheckerTextureNode(); + get_tex_mapping(&checker->tex_mapping, b_checker_node.texture_mapping()); + node = checker; + } + else if (b_node.is_a(&RNA_ShaderNodeTexBrick)) { + BL::ShaderNodeTexBrick b_brick_node(b_node); + BrickTextureNode *brick = new BrickTextureNode(); + brick->offset = b_brick_node.offset(); + brick->offset_frequency = b_brick_node.offset_frequency(); + brick->squash = b_brick_node.squash(); + brick->squash_frequency = b_brick_node.squash_frequency(); + get_tex_mapping(&brick->tex_mapping, b_brick_node.texture_mapping()); + node = brick; + } + else if (b_node.is_a(&RNA_ShaderNodeTexNoise)) { + BL::ShaderNodeTexNoise b_noise_node(b_node); + NoiseTextureNode *noise = new NoiseTextureNode(); + get_tex_mapping(&noise->tex_mapping, b_noise_node.texture_mapping()); + node = noise; + } + else if (b_node.is_a(&RNA_ShaderNodeTexMusgrave)) { + BL::ShaderNodeTexMusgrave b_musgrave_node(b_node); + MusgraveTextureNode *musgrave = new MusgraveTextureNode(); + musgrave->type = MusgraveTextureNode::type_enum[(int)b_musgrave_node.musgrave_type()]; + get_tex_mapping(&musgrave->tex_mapping, b_musgrave_node.texture_mapping()); + node = musgrave; + } + else if (b_node.is_a(&RNA_ShaderNodeTexCoord)) { + BL::ShaderNodeTexCoord b_tex_coord_node(b_node); + TextureCoordinateNode *tex_coord = new TextureCoordinateNode(); + tex_coord->from_dupli = b_tex_coord_node.from_dupli(); + node = tex_coord; + } + else if (b_node.is_a(&RNA_ShaderNodeTexSky)) { + BL::ShaderNodeTexSky b_sky_node(b_node); + SkyTextureNode *sky = new SkyTextureNode(); + sky->sun_direction = get_float3(b_sky_node.sun_direction()); + sky->turbidity = b_sky_node.turbidity(); + get_tex_mapping(&sky->tex_mapping, b_sky_node.texture_mapping()); + node = sky; + } + else if (b_node.is_a(&RNA_ShaderNodeNormalMap)) { + BL::ShaderNodeNormalMap b_normal_map_node(b_node); + NormalMapNode *nmap = new NormalMapNode(); + nmap->space = NormalMapNode::space_enum[(int)b_normal_map_node.space()]; + nmap->attribute = b_normal_map_node.uv_map(); + node = nmap; + } + else if (b_node.is_a(&RNA_ShaderNodeTangent)) { + BL::ShaderNodeTangent b_tangent_node(b_node); + TangentNode *tangent = new TangentNode(); + tangent->direction_type = TangentNode::direction_type_enum[(int)b_tangent_node.direction_type()]; + tangent->axis = TangentNode::axis_enum[(int)b_tangent_node.axis()]; + tangent->attribute = b_tangent_node.uv_map(); + node = tangent; } if(node && node != graph->output()) @@ -678,18 +600,16 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen return node; } -static SocketPair node_socket_map_pair(PtrNodeMap& node_map, BL::Node b_node, BL::NodeSocket b_socket) +static ShaderInput *node_find_input_by_name(ShaderNode *node, BL::Node b_node, BL::NodeSocket b_socket) { BL::Node::inputs_iterator b_input; - BL::Node::outputs_iterator b_output; string name = b_socket.name(); bool found = false; int counter = 0, total = 0; - - /* find in inputs */ - for(b_node.inputs.begin(b_input); b_input != b_node.inputs.end(); ++b_input) { - if(b_input->name() == name) { - if(!found) + + for (b_node.inputs.begin(b_input); b_input != b_node.inputs.end(); ++b_input) { + if (b_input->name() == name) { + if (!found) counter++; total++; } @@ -697,128 +617,145 @@ static SocketPair node_socket_map_pair(PtrNodeMap& node_map, BL::Node b_node, BL if(b_input->ptr.data == b_socket.ptr.data) found = true; } + + /* rename if needed */ + if (name == "Shader") + name = "Closure"; + + if (total > 1) + name = string_printf("%s%d", name.c_str(), counter); + + return node->input(name.c_str()); +} - if(!found) { - /* find in outputs */ - found = false; - counter = 0; - total = 0; - - for(b_node.outputs.begin(b_output); b_output != b_node.outputs.end(); ++b_output) { - if(b_output->name() == name) { - if(!found) - counter++; - total++; - } - - if(b_output->ptr.data == b_socket.ptr.data) - found = true; +static ShaderOutput *node_find_output_by_name(ShaderNode *node, BL::Node b_node, BL::NodeSocket b_socket) +{ + BL::Node::outputs_iterator b_output; + string name = b_socket.name(); + bool found = false; + int counter = 0, total = 0; + + for (b_node.outputs.begin(b_output); b_output != b_node.outputs.end(); ++b_output) { + if (b_output->name() == name) { + if (!found) + counter++; + total++; } - } + if(b_output->ptr.data == b_socket.ptr.data) + found = true; + } + /* rename if needed */ - if(name == "Shader") + if (name == "Shader") name = "Closure"; - - if(total > 1) + + if (total > 1) name = string_printf("%s%d", name.c_str(), counter); - - return SocketPair(node_map[b_node.ptr.data], name); + + return node->output(name.c_str()); } -static void add_nodes(Scene *scene, BL::BlendData b_data, BL::Scene b_scene, ShaderGraph *graph, BL::ShaderNodeTree b_ntree, PtrSockMap& sockets_map) +static void add_nodes(Scene *scene, BL::BlendData b_data, BL::Scene b_scene, ShaderGraph *graph, BL::ShaderNodeTree b_ntree, ProxyMap &proxy_map) { /* add nodes */ BL::ShaderNodeTree::nodes_iterator b_node; - PtrNodeMap node_map; - PtrSockMap proxy_map; + PtrInputMap input_map; + PtrOutputMap output_map; + + BL::Node::inputs_iterator b_input; + BL::Node::outputs_iterator b_output; for(b_ntree.nodes.begin(b_node); b_node != b_ntree.nodes.end(); ++b_node) { - if(b_node->mute()) { - BL::Node::inputs_iterator b_input; - BL::Node::outputs_iterator b_output; - bool found_match = false; - - /* this is slightly different than blender logic, we just connect a - * single pair for of input/output, but works ok for the node we have */ - for(b_node->inputs.begin(b_input); b_input != b_node->inputs.end(); ++b_input) { - if(b_input->is_linked()) { - for(b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) { - if(b_output->is_linked() && b_input->type() == b_output->type()) { - ProxyNode *proxy = new ProxyNode(convert_socket_type(b_input->type()), convert_socket_type(b_output->type())); - graph->add(proxy); - - proxy_map[b_input->ptr.data] = SocketPair(proxy, proxy->inputs[0]->name); - proxy_map[b_output->ptr.data] = SocketPair(proxy, proxy->outputs[0]->name); - found_match = true; - - break; - } - } - } - - if(found_match) - break; + if (b_node->mute() || b_node->is_a(&RNA_NodeReroute)) { + /* replace muted node with internal links */ + BL::Node::internal_links_iterator b_link; + for (b_node->internal_links.begin(b_link); b_link != b_node->internal_links.end(); ++b_link) { + ProxyNode *proxy = new ProxyNode(convert_socket_type(b_link->to_socket())); + + input_map[b_link->from_socket().ptr.data] = proxy->inputs[0]; + output_map[b_link->to_socket().ptr.data] = proxy->outputs[0]; + + graph->add(proxy); } } - else if(b_node->is_a(&RNA_NodeGroup)) { - /* add proxy converter nodes for inputs and outputs */ + else if (b_node->is_a(&RNA_ShaderNodeGroup)) { BL::NodeGroup b_gnode(*b_node); BL::ShaderNodeTree b_group_ntree(b_gnode.node_tree()); + ProxyMap group_proxy_map; + if (!b_group_ntree) continue; - - BL::Node::inputs_iterator b_input; - BL::Node::outputs_iterator b_output; - PtrSockMap group_sockmap; + add_nodes(scene, b_data, b_scene, graph, b_group_ntree, group_proxy_map); + /* map the outer socket to the internal proxy nodes */ for(b_node->inputs.begin(b_input); b_input != b_node->inputs.end(); ++b_input) { - ShaderSocketType extern_type = convert_socket_type(b_input->type()); - ShaderSocketType intern_type = convert_socket_type(b_input->group_socket().type()); - ShaderNode *proxy = graph->add(new ProxyNode(extern_type, intern_type)); - /* map the external node socket to the proxy node socket */ - proxy_map[b_input->ptr.data] = SocketPair(proxy, proxy->inputs[0]->name); - /* map the internal group socket to the proxy node socket */ - group_sockmap[b_input->group_socket().ptr.data] = SocketPair(proxy, proxy->outputs[0]->name); + /* get internal proxy node from group proxy map */ + assert(group_proxy_map.find(b_input->identifier()) != group_proxy_map.end()); + assert(group_proxy_map[b_input->identifier()]->special_type == SHADER_SPECIAL_TYPE_PROXY); + ProxyNode *proxy = group_proxy_map[b_input->identifier()]; + + input_map[b_input->ptr.data] = proxy->inputs[0]; - /* default input values of the group node */ - set_default_value(proxy->inputs[0], *b_input, b_data, b_group_ntree); + /* input value for proxy inputs is defined by group node */ + set_default_value(proxy->inputs[0], *b_node, *b_input, b_data, b_ntree); } + /* map the outer socket to the internal proxy nodes */ for(b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) { - ShaderSocketType extern_type = convert_socket_type(b_output->type()); - ShaderSocketType intern_type = convert_socket_type(b_output->group_socket().type()); - ShaderNode *proxy = graph->add(new ProxyNode(intern_type, extern_type)); - /* map the external node socket to the proxy node socket */ - proxy_map[b_output->ptr.data] = SocketPair(proxy, proxy->outputs[0]->name); - /* map the internal group socket to the proxy node socket */ - group_sockmap[b_output->group_socket().ptr.data] = SocketPair(proxy, proxy->inputs[0]->name); + /* get internal proxy node from group node map */ + assert(group_proxy_map.find(b_output->identifier()) != group_proxy_map.end()); + assert(group_proxy_map[b_output->identifier()]->special_type == SHADER_SPECIAL_TYPE_PROXY); + ProxyNode *proxy = group_proxy_map[b_output->identifier()]; - /* default input values of internal, unlinked group outputs */ - set_default_value(proxy->inputs[0], b_output->group_socket(), b_data, b_group_ntree); + output_map[b_output->ptr.data] = proxy->outputs[0]; + } + } + else if (b_node->is_a(&RNA_NodeGroupInput)) { + /* add a proxy node for each socket */ + for(b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) { + ProxyNode *proxy = new ProxyNode(convert_socket_type(*b_output)); + + output_map[b_output->ptr.data] = proxy->outputs[0]; + + /* register the proxy node for external binding */ + proxy_map[b_output->identifier()] = proxy; + + graph->add(proxy); + } + } + else if (b_node->is_a(&RNA_NodeGroupOutput)) { + /* add a proxy node for each socket */ + for(b_node->inputs.begin(b_input); b_input != b_node->inputs.end(); ++b_input) { + ProxyNode *proxy = new ProxyNode(convert_socket_type(*b_input)); + + input_map[b_input->ptr.data] = proxy->inputs[0]; + + set_default_value(proxy->inputs[0], *b_node, *b_input, b_data, b_ntree); + + /* register the proxy node for external binding */ + proxy_map[b_input->identifier()] = proxy; + + graph->add(proxy); } - - add_nodes(scene, b_data, b_scene, graph, b_group_ntree, group_sockmap); } else { ShaderNode *node = add_node(scene, b_data, b_scene, graph, b_ntree, BL::ShaderNode(*b_node)); if(node) { - BL::Node::inputs_iterator b_input; - - node_map[b_node->ptr.data] = node; - + /* map node sockets for linking */ for(b_node->inputs.begin(b_input); b_input != b_node->inputs.end(); ++b_input) { - SocketPair pair = node_socket_map_pair(node_map, *b_node, *b_input); - ShaderInput *input = pair.first->input(pair.second.c_str()); + ShaderInput *input = node_find_input_by_name(node, *b_node, *b_input); + input_map[b_input->ptr.data] = input; - assert(input); - - /* copy values for non linked inputs */ - set_default_value(input, *b_input, b_data, b_ntree); + set_default_value(input, *b_node, *b_input, b_data, b_ntree); + } + for(b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) { + ShaderOutput *output = node_find_output_by_name(node, *b_node, *b_output); + output_map[b_output->ptr.data] = output; } } } @@ -829,44 +766,23 @@ static void add_nodes(Scene *scene, BL::BlendData b_data, BL::Scene b_scene, Sha for(b_ntree.links.begin(b_link); b_link != b_ntree.links.end(); ++b_link) { /* get blender link data */ - BL::Node b_from_node = b_link->from_node(); - BL::Node b_to_node = b_link->to_node(); - BL::NodeSocket b_from_sock = b_link->from_socket(); BL::NodeSocket b_to_sock = b_link->to_socket(); - SocketPair from_pair, to_pair; - - /* links without a node pointer are connections to group inputs/outputs */ - - /* from sock */ - if(b_from_node) { - if (b_from_node.mute() || b_from_node.is_a(&RNA_NodeGroup)) - from_pair = proxy_map[b_from_sock.ptr.data]; - else - from_pair = node_socket_map_pair(node_map, b_from_node, b_from_sock); - } - else - from_pair = sockets_map[b_from_sock.ptr.data]; - - /* to sock */ - if(b_to_node) { - if (b_to_node.mute() || b_to_node.is_a(&RNA_NodeGroup)) - to_pair = proxy_map[b_to_sock.ptr.data]; - else - to_pair = node_socket_map_pair(node_map, b_to_node, b_to_sock); - } - else - to_pair = sockets_map[b_to_sock.ptr.data]; + ShaderOutput *output = 0; + ShaderInput *input = 0; + + PtrOutputMap::iterator output_it = output_map.find(b_from_sock.ptr.data); + if (output_it != output_map.end()) + output = output_it->second; + PtrInputMap::iterator input_it = input_map.find(b_to_sock.ptr.data); + if (input_it != input_map.end()) + input = input_it->second; /* either node may be NULL when the node was not exported, typically * because the node type is not supported */ - if(from_pair.first && to_pair.first) { - ShaderOutput *output = from_pair.first->output(from_pair.second.c_str()); - ShaderInput *input = to_pair.first->input(to_pair.second.c_str()); - + if(output && input) graph->connect(output, input); - } } } @@ -891,10 +807,10 @@ void BlenderSync::sync_materials(bool update_all) /* create nodes */ if(b_mat->use_nodes() && b_mat->node_tree()) { - PtrSockMap sock_to_node; + ProxyMap proxy_map; BL::ShaderNodeTree b_ntree(b_mat->node_tree()); - add_nodes(scene, b_data, b_scene, graph, b_ntree, sock_to_node); + add_nodes(scene, b_data, b_scene, graph, b_ntree, proxy_map); } else { ShaderNode *closure, *out; @@ -932,10 +848,10 @@ void BlenderSync::sync_world(bool update_all) /* create nodes */ if(b_world && b_world.use_nodes() && b_world.node_tree()) { - PtrSockMap sock_to_node; + ProxyMap proxy_map; BL::ShaderNodeTree b_ntree(b_world.node_tree()); - add_nodes(scene, b_data, b_scene, graph, b_ntree, sock_to_node); + add_nodes(scene, b_data, b_scene, graph, b_ntree, proxy_map); } else if(b_world) { ShaderNode *closure, *out; @@ -991,10 +907,10 @@ void BlenderSync::sync_lamps(bool update_all) if(b_lamp->use_nodes() && b_lamp->node_tree()) { shader->name = b_lamp->name().c_str(); - PtrSockMap sock_to_node; + ProxyMap proxy_map; BL::ShaderNodeTree b_ntree(b_lamp->node_tree()); - add_nodes(scene, b_data, b_scene, graph, b_ntree, sock_to_node); + add_nodes(scene, b_data, b_scene, graph, b_ntree, proxy_map); } else { ShaderNode *closure, *out; diff --git a/intern/cycles/blender/blender_util.h b/intern/cycles/blender/blender_util.h index 976ed875211..bd4852d08e1 100644 --- a/intern/cycles/blender/blender_util.h +++ b/intern/cycles/blender/blender_util.h @@ -202,30 +202,60 @@ static inline uint get_layer(BL::Array<int, 20> array, BL::Array<int, 8> local_a return layer; } -#if 0 static inline float3 get_float3(PointerRNA& ptr, const char *name) { float3 f; RNA_float_get_array(&ptr, name, &f.x); return f; } -#endif + +static inline void set_float3(PointerRNA& ptr, const char *name, float3 value) +{ + RNA_float_set_array(&ptr, name, &value.x); +} + +static inline float4 get_float4(PointerRNA& ptr, const char *name) +{ + float4 f; + RNA_float_get_array(&ptr, name, &f.x); + return f; +} + +static inline void set_float4(PointerRNA& ptr, const char *name, float4 value) +{ + RNA_float_set_array(&ptr, name, &value.x); +} static inline bool get_boolean(PointerRNA& ptr, const char *name) { return RNA_boolean_get(&ptr, name)? true: false; } +static inline void set_boolean(PointerRNA& ptr, const char *name, bool value) +{ + RNA_boolean_set(&ptr, name, (int)value); +} + static inline float get_float(PointerRNA& ptr, const char *name) { return RNA_float_get(&ptr, name); } +static inline void set_float(PointerRNA& ptr, const char *name, float value) +{ + RNA_float_set(&ptr, name, value); +} + static inline int get_int(PointerRNA& ptr, const char *name) { return RNA_int_get(&ptr, name); } +static inline void set_int(PointerRNA& ptr, const char *name, int value) +{ + RNA_int_set(&ptr, name, value); +} + static inline int get_enum(PointerRNA& ptr, const char *name) { return RNA_enum_get(&ptr, name); @@ -242,6 +272,32 @@ static inline string get_enum_identifier(PointerRNA& ptr, const char *name) return string(identifier); } +static inline void set_enum(PointerRNA& ptr, const char *name, int value) +{ + RNA_enum_set(&ptr, name, value); +} + +static inline void set_enum(PointerRNA& ptr, const char *name, const string &identifier) +{ + RNA_enum_set_identifier(&ptr, name, identifier.c_str()); +} + +static inline string get_string(PointerRNA& ptr, const char *name) +{ + char cstrbuf[1024]; + char *cstr = RNA_string_get_alloc(&ptr, name, cstrbuf, sizeof(cstrbuf)); + string str(cstr); + if (cstr != cstrbuf) + MEM_freeN(cstr); + + return str; +} + +static inline void set_string(PointerRNA& ptr, const char *name, const string &value) +{ + RNA_string_set(&ptr, name, value.c_str()); +} + /* Relative Paths */ static inline string blender_absolute_path(BL::BlendData b_data, BL::ID b_id, const string& path) diff --git a/intern/cycles/render/graph.h b/intern/cycles/render/graph.h index 61b5bd83534..c6b9ae08508 100644 --- a/intern/cycles/render/graph.h +++ b/intern/cycles/render/graph.h @@ -43,6 +43,8 @@ class OSLCompiler; * Data type for inputs and outputs */ enum ShaderSocketType { + SHADER_SOCKET_UNDEFINED, + SHADER_SOCKET_FLOAT, SHADER_SOCKET_INT, SHADER_SOCKET_COLOR, diff --git a/intern/cycles/render/nodes.cpp b/intern/cycles/render/nodes.cpp index 8ac12242e15..398b9f0a758 100644 --- a/intern/cycles/render/nodes.cpp +++ b/intern/cycles/render/nodes.cpp @@ -1242,15 +1242,14 @@ void ConvertNode::compile(OSLCompiler& compiler) /* Proxy */ -ProxyNode::ProxyNode(ShaderSocketType from_, ShaderSocketType to_) +ProxyNode::ProxyNode(ShaderSocketType type_) : ShaderNode("proxy") { - from = from_; - to = to_; + type = type_; special_type = SHADER_SPECIAL_TYPE_PROXY; - add_input("Input", from); - add_output("Output", to); + add_input("Input", type); + add_output("Output", type); } void ProxyNode::compile(SVMCompiler& compiler) diff --git a/intern/cycles/render/nodes.h b/intern/cycles/render/nodes.h index 3609497e5ce..1efe4ae076d 100644 --- a/intern/cycles/render/nodes.h +++ b/intern/cycles/render/nodes.h @@ -190,10 +190,10 @@ public: class ProxyNode : public ShaderNode { public: - ProxyNode(ShaderSocketType from, ShaderSocketType to); + ProxyNode(ShaderSocketType type); SHADER_NODE_BASE_CLASS(ProxyNode) - ShaderSocketType from, to; + ShaderSocketType type; }; class BsdfNode : public ShaderNode { diff --git a/release/scripts/modules/bpy_types.py b/release/scripts/modules/bpy_types.py index 4398b1721f7..f42fd8e3107 100644 --- a/release/scripts/modules/bpy_types.py +++ b/release/scripts/modules/bpy_types.py @@ -485,17 +485,6 @@ class Text(bpy_types.ID): ) -class NodeSocket(StructRNA): # , metaclass=RNAMeta - __slots__ = () - - @property - def links(self): - """List of node links from or to this socket""" - return tuple(link for link in self.id_data.links - if (link.from_socket == self or - link.to_socket == self)) - - # values are module: [(cls, path, line), ...] TypeMap = {} @@ -757,3 +746,147 @@ class Region(StructRNA): return None + +class NodeTree(bpy_types.ID, metaclass=RNAMetaPropGroup): + __slots__ = () + + +class NodeSocketTemplate(): + type = 'UNDEFINED' + + # Default implementation: + # Create a single property using the socket template's 'value_property' attribute + # value_property should be created in the __init__ function + # + # If necessary this function can be overloaded in subclasses, e.g. to create multiple value properties + def define_node_properties(self, node_type, prefix): + if hasattr(self, "value_property"): + setattr(node_type, prefix+"value", self.value_property) + + def init_socket(self, socket): + socket.type = self.type + if hasattr(self, "value_property"): + socket.value_property = self.value_property[1]['attr'] + + +def gen_valid_identifier(seq): + # get an iterator + itr = iter(seq) + # pull characters until we get a legal one for first in identifer + for ch in itr: + if ch == '_' or ch.isalpha(): + yield ch + break + # pull remaining characters and yield legal ones for identifier + for ch in itr: + if ch == '_' or ch.isalpha() or ch.isdigit(): + yield ch + +def sanitize_identifier(name): + return ''.join(gen_valid_identifier(name)) + +def unique_identifier(name, identifier_list): + # First some basic sanitation, to make a usable identifier string from the name + base = sanitize_identifier(name) + # Now make a unique identifier by appending an unused index + identifier = base + index = 0 + while identifier in identifier_list: + index += 1 + identifier = base + str(index) + return identifier + +class RNAMetaNode(RNAMetaPropGroup): + def __new__(cls, name, bases, classdict, **args): + # Wrapper for node.init, to add sockets from templates + + def create_sockets(self): + inputs = getattr(self, 'input_templates', None) + if inputs: + for temp in inputs: + socket = self.inputs.new(type=temp.bl_socket_idname, name=temp.name, identifier=temp.identifier) + temp.init_socket(socket) + outputs = getattr(self, 'output_templates', None) + if outputs: + for temp in outputs: + socket = self.outputs.new(type=temp.bl_socket_idname, name=temp.name, identifier=temp.identifier) + temp.init_socket(socket) + + init_base = classdict.get('init', None) + if init_base: + def init_node(self, context): + create_sockets(self) + init_base(self, context) + else: + def init_node(self, context): + create_sockets(self) + + classdict['init'] = init_node + + # Create the regular class + result = RNAMetaPropGroup.__new__(cls, name, bases, classdict) + + # Add properties from socket templates + inputs = classdict.get('input_templates', None) + if inputs: + for i, temp in enumerate(inputs): + temp.identifier = unique_identifier(temp.name, [t.identifier for t in inputs[0:i]]) + temp.define_node_properties(result, "input_"+temp.identifier+"_") + outputs = classdict.get('output_templates', None) + if outputs: + for i, temp in enumerate(outputs): + temp.identifier = unique_identifier(temp.name, [t.identifier for t in outputs[0:i]]) + temp.define_node_properties(result, "output_"+temp.identifier+"_") + + return result + + +class Node(StructRNA, metaclass=RNAMetaNode): + __slots__ = () + + @classmethod + def poll(cls, ntree): + return True + + +class NodeSocket(StructRNA, metaclass=RNAMetaPropGroup): + __slots__ = () + + @property + def links(self): + """List of node links from or to this socket""" + return tuple(link for link in self.id_data.links + if (link.from_socket == self or + link.to_socket == self)) + + +class NodeSocketInterface(StructRNA, metaclass=RNAMetaPropGroup): + __slots__ = () + + +# These are intermediate subclasses, need a bpy type too +class CompositorNode(Node): + __slots__ = () + + @classmethod + def poll(cls, ntree): + return ntree.bl_idname == 'CompositorNodeTree' + + def update(self): + self.tag_need_exec() + +class ShaderNode(Node): + __slots__ = () + + @classmethod + def poll(cls, ntree): + return ntree.bl_idname == 'ShaderNodeTree' + + +class TextureNode(Node): + __slots__ = () + + @classmethod + def poll(cls, ntree): + return ntree.bl_idname == 'TextureNodeTree' + diff --git a/release/scripts/startup/bl_operators/node.py b/release/scripts/startup/bl_operators/node.py index bc0224db765..9839e0ee092 100644 --- a/release/scripts/startup/bl_operators/node.py +++ b/release/scripts/startup/bl_operators/node.py @@ -100,75 +100,55 @@ class NODE_OT_add_node(NodeAddOperator, Operator): return result -# XXX These node item lists should actually be generated by a callback at -# operator execution time (see node_type_items below), -# using the active node tree from the context. -# Due to a difficult bug in bpy this is not possible -# (item list memory gets freed too early), -# so for now just copy the static item lists to these global variables. -# -# In the custom_nodes branch, the static per-tree-type node items are replaced -# by a single independent type list anyway (with a poll function to limit node -# types to the respective trees). So this workaround is only temporary. - -# lazy init -node_type_items_dict = {} - -# Prefixes used to distinguish base node types and node groups -node_type_prefix = 'NODE_' -node_group_prefix = 'GROUP_' - - -# Generate a list of enum items for a given node class -# Copy existing type enum, adding a prefix to distinguish from node groups -# Skip the base node group type, -# node groups will be added below for all existing group trees -def node_type_items(node_class): - return [(node_type_prefix + item.identifier, item.name, item.description) - for item in node_class.bl_rna.properties['type'].enum_items - if item.identifier != 'GROUP'] - - -# Generate items for node group types -# Filter by the given tree_type -# Node group trees don't have a description property yet -# (could add this as a custom property though) -def node_group_items(tree_type): - return [(node_group_prefix + group.name, group.name, '') - for group in bpy.data.node_groups if group.type == tree_type] +def node_classes_iter(base=bpy.types.Node): + """ + Yields all true node classes by checking for the is_registered_node_type classmethod. + Node types can use specialized subtypes of bpy.types.Node, which are not usable + nodes themselves (e.g. CompositorNode). + """ + if base.is_registered_node_type(): + yield base + for subclass in base.__subclasses__(): + for node_class in node_classes_iter(subclass): + yield node_class + + +def node_class_items_iter(node_class, context): + identifier = node_class.bl_rna.identifier + # XXX Checking for explicit group node types is stupid. + # This should be replaced by a generic system of generating + # node items via callback. + # Group node_tree pointer should also use a poll function to filter the library list, + # but cannot do that without a node instance here. A node callback could just use the internal poll function. + if identifier in {'ShaderNodeGroup', 'CompositorNodeGroup', 'TextureNodeGroup'}: + tree_idname = context.space_data.edit_tree.bl_idname + for group in bpy.data.node_groups: + if group.bl_idname == tree_idname: + yield (group.name, "", {"node_tree":group}) # XXX empty string should be replaced by description from tree + else: + yield (node_class.bl_rna.name, node_class.bl_rna.description, {}) -# Returns the enum item list for the edited tree in the context -def node_type_items_cb(self, context): +def node_items_iter(context): snode = context.space_data if not snode: - return () + return tree = snode.edit_tree if not tree: - return () - - # Lists of basic node types for each - if not node_type_items_dict: - node_type_items_dict.update({ - 'SHADER': node_type_items(bpy.types.ShaderNode), - 'COMPOSITING': node_type_items(bpy.types.CompositorNode), - 'TEXTURE': node_type_items(bpy.types.TextureNode), - }) - - # XXX Does not work correctly, see comment above - ''' - return [(item.identifier, item.name, item.description, item.value) - for item in - tree.nodes.bl_rna.functions['new'].parameters['type'].enum_items] - ''' - - if tree.type in node_type_items_dict: - return node_type_items_dict[tree.type] + node_group_items(tree.type) - else: - return () + return + + for node_class in node_classes_iter(): + if node_class.poll(tree): + for item in node_class_items_iter(node_class, context): + yield (node_class,) + item + + +# Create an enum list from node class items +def node_type_items_cb(self, context): + return [(str(index), item[1], item[2]) for index, item in enumerate(node_items_iter(context))] -class NODE_OT_add_search(Operator): +class NODE_OT_add_search(NodeAddOperator, Operator): '''Add a node to the active tree''' bl_idname = "node.add_search" bl_label = "Search and Add Node" @@ -182,55 +162,48 @@ class NODE_OT_add_search(Operator): items=node_type_items_cb, ) - _node_type_items_dict = None + def execute(self, context): + for index, item in enumerate(node_items_iter(context)): + if str(index) == self.type: + node = self.create_node(context, item[0].bl_rna.identifier) + for prop,value in item[3].items(): + setattr(node, prop, value) + break + return {'FINISHED'} - def create_node(self, context): - space = context.space_data - tree = space.edit_tree + def invoke(self, context, event): + self.store_mouse_cursor(context, event) + # Delayed execution in the search popup + context.window_manager.invoke_search_popup(self) + return {'CANCELLED'} - # Enum item identifier has an additional prefix to - # distinguish base node types from node groups - item = self.type - if item.startswith(node_type_prefix): - # item means base node type - node = tree.nodes.new(type=item[len(node_type_prefix):]) - elif item.startswith(node_group_prefix): - # item means node group type - node = tree.nodes.new( - type='GROUP', - group=bpy.data.node_groups[item[len(node_group_prefix):]]) - else: - return None - for n in tree.nodes: - if n == node: - node.select = True - tree.nodes.active = node - else: - node.select = False - node.location = space.cursor_location - return node +# Simple basic operator for adding a node without further initialization +class NODE_OT_add_node(NodeAddOperator, bpy.types.Operator): + '''Add a node to the active tree''' + bl_idname = "node.add_node" + bl_label = "Add Node" - @classmethod - def poll(cls, context): - space = context.space_data - # needs active node editor and a tree to add nodes to - return (space.type == 'NODE_EDITOR' and space.edit_tree) + type = StringProperty(name="Node Type", description="Node type") def execute(self, context): - self.create_node(context) + node = self.create_node(context, self.type) return {'FINISHED'} - def invoke(self, context, event): - space = context.space_data - v2d = context.region.view2d - # convert mouse position to the View2D for later node placement - space.cursor_location = v2d.region_to_view(event.mouse_region_x, - event.mouse_region_y) +class NODE_OT_add_group_node(NodeAddOperator, bpy.types.Operator): + '''Add a group node to the active tree''' + bl_idname = "node.add_group_node" + bl_label = "Add Group Node" - context.window_manager.invoke_search_popup(self) - return {'CANCELLED'} + type = StringProperty(name="Node Type", description="Node type") + grouptree = StringProperty(name="Group tree", description="Group node tree name") + + def execute(self, context): + node = self.create_node(context, self.type) + node.node_tree = bpy.data.node_groups[self.grouptree] + + return {'FINISHED'} class NODE_OT_collapse_hide_unused_toggle(Operator): @@ -261,3 +234,24 @@ class NODE_OT_collapse_hide_unused_toggle(Operator): socket.hide = hide return {'FINISHED'} + + +class NODE_OT_tree_path_parent(Operator): + '''Go to parent node tree''' + bl_idname = "node.tree_path_parent" + bl_label = "Parent Node Tree" + bl_options = {'REGISTER', 'UNDO'} + + @classmethod + def poll(cls, context): + space = context.space_data + # needs active node editor and a tree + return (space.type == 'NODE_EDITOR' and len(space.path) > 1) + + def execute(self, context): + space = context.space_data + + space.path.pop() + + return {'FINISHED'} + diff --git a/release/scripts/startup/bl_ui/space_node.py b/release/scripts/startup/bl_ui/space_node.py index 1865b049a03..e739c5ea5d4 100644 --- a/release/scripts/startup/bl_ui/space_node.py +++ b/release/scripts/startup/bl_ui/space_node.py @@ -44,8 +44,8 @@ class NODE_HT_header(Header): row.menu("NODE_MT_node") layout.prop(snode, "tree_type", text="", expand=True) - - if snode.tree_type == 'SHADER': + + if snode.tree_type == 'ShaderNodeTree': if scene.render.use_shading_nodes: layout.prop(snode, "shader_type", text="", expand=True) @@ -65,7 +65,7 @@ class NODE_HT_header(Header): if snode_id: layout.prop(snode_id, "use_nodes") - elif snode.tree_type == 'TEXTURE': + elif snode.tree_type == 'TextureNodeTree': layout.prop(snode, "texture_type", text="", expand=True) if id_from: @@ -76,7 +76,7 @@ class NODE_HT_header(Header): if snode_id: layout.prop(snode_id, "use_nodes") - elif snode.tree_type == 'COMPOSITING': + elif snode.tree_type == 'CompositorNodeTree': layout.prop(snode_id, "use_nodes") layout.prop(snode_id.render, "use_free_unused_nodes", text="Free Unused") layout.prop(snode, "show_backdrop") @@ -84,6 +84,13 @@ class NODE_HT_header(Header): row = layout.row(align=True) row.prop(snode, "backdrop_channels", text="", expand=True) layout.prop(snode, "use_auto_render") + + else: + # Custom node tree is edited as independent ID block + layout.template_ID(snode, "node_tree", new="node.new_node_tree") + + layout.prop(snode, "pin", text="") + layout.operator("node.tree_path_parent", text="", icon='FILE_PARENT') layout.separator() @@ -182,6 +189,7 @@ class NODE_MT_node(Menu): layout.operator("node.group_edit") layout.operator("node.group_ungroup") layout.operator("node.group_make") + layout.operator("node.group_insert") layout.separator() @@ -208,7 +216,7 @@ class NODE_PT_properties(Panel): @classmethod def poll(cls, context): snode = context.space_data - return snode.tree_type == 'COMPOSITING' + return snode.tree_type == 'CompositorNodeTree' def draw_header(self, context): snode = context.space_data @@ -237,7 +245,7 @@ class NODE_PT_quality(bpy.types.Panel): @classmethod def poll(cls, context): snode = context.space_data - return snode.tree_type == 'COMPOSITING' and snode.node_tree is not None + return snode.tree_type == 'CompositorNodeTree' and snode.node_tree is not None def draw(self, context): layout = self.layout @@ -276,5 +284,28 @@ class NODE_MT_node_color_specials(Menu): layout.operator("node.node_copy_color", icon='COPY_ID') +class NODE_UL_interface_sockets(bpy.types.UIList): + def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index): + socket = item + color = socket.draw_color(context) + + if self.layout_type in {'DEFAULT', 'COMPACT'}: + row = layout.row(align=True) + + # inputs get icon on the left + if socket.in_out == 'IN': + row.template_node_socket(color) + + row.label(text=socket.name, icon_value=icon) + + # outputs get icon on the right + if socket.in_out == 'OUT': + row.template_node_socket(color) + + elif self.layout_type in {'GRID'}: + layout.alignment = 'CENTER' + layout.template_node_socket(color) + + if __name__ == "__main__": # only for live edit. bpy.utils.register_module(__name__) diff --git a/release/scripts/templates_py/custom_nodes.py b/release/scripts/templates_py/custom_nodes.py new file mode 100644 index 00000000000..485ee0ebe05 --- /dev/null +++ b/release/scripts/templates_py/custom_nodes.py @@ -0,0 +1,159 @@ +import bpy +# XXX these don't work yet ... +#from bpy_types import NodeTree, Node, NodeSocket + +# Implementation of custom nodes from Python + + +# Shortcut for node type menu +def add_nodetype(layout, type): + layout.operator("node.add_node", text=type.bl_label).type = type.bl_rna.identifier + +# Derived from the NodeTree base type, similar to Menu, Operator, Panel, etc. +class MyCustomTree(bpy.types.NodeTree): + # Description string + '''A custom node tree type that will show up in the node editor header''' + # Optional identifier string. If not explicitly defined, the python class name is used. + bl_idname = 'CustomTreeType' + # Label for nice name display + bl_label = 'Custom Node Tree' + # Icon identifier + # NOTE: If no icon is defined, the node tree will not show up in the editor header! + # This can be used to make additional tree types for groups and similar nodes (see below) + # Only one base tree class is needed in the editor for selecting the general category + bl_icon = 'NODETREE' + + def draw_add_menu(self, context, layout): + layout.label("Hello World!") + add_nodetype(layout, bpy.types.CustomNodeType) + add_nodetype(layout, bpy.types.MyCustomGroup) + + +# Custom socket type +class MyCustomSocket(bpy.types.NodeSocket): + # Description string + '''Custom node socket type''' + # Optional identifier string. If not explicitly defined, the python class name is used. + bl_idname = 'CustomSocketType' + # Label for nice name display + bl_label = 'Custom Node Socket' + # Socket color + bl_color = (1.0, 0.4, 0.216, 0.5) + + # Enum items list + my_items = [ + ("DOWN", "Down", "Where your feet are"), + ("UP", "Up", "Where your head should be"), + ("LEFT", "Left", "Not right"), + ("RIGHT", "Right", "Not left") + ] + + myEnumProperty = bpy.props.EnumProperty(name="Direction", description="Just an example", items=my_items, default='UP') + + # Optional function for drawing the socket input value + def draw(self, context, layout, node): + layout.prop(self, "myEnumProperty", text=self.name) + + +# Base class for all custom nodes in this tree type. +# Defines a poll function to enable instantiation. +class MyCustomTreeNode : + @classmethod + def poll(cls, ntree): + return ntree.bl_idname == 'CustomTreeType' + +# Derived from the Node base type. +class MyCustomNode(bpy.types.Node, MyCustomTreeNode): + # === Basics === + # Description string + '''A custom node''' + # Optional identifier string. If not explicitly defined, the python class name is used. + bl_idname = 'CustomNodeType' + # Label for nice name display + bl_label = 'Custom Node' + # Icon identifier + bl_icon = 'SOUND' + + # === Custom Properties === + # These work just like custom properties in ID data blocks + # Extensive information can be found under + # http://wiki.blender.org/index.php/Doc:2.6/Manual/Extensions/Python/Properties + myStringProperty = bpy.props.StringProperty() + myFloatProperty = bpy.props.FloatProperty(default=3.1415926) + + # === Optional Functions === + # Initialization function, called when a new node is created. + # This is the most common place to create the sockets for a node, as shown below. + # NOTE: this is not the same as the standard __init__ function in Python, which is + # a purely internal Python method and unknown to the node system! + def init(self, context): + self.inputs.new('CustomSocketType', "Hello") + self.inputs.new('NodeSocketFloat', "World") + self.inputs.new('NodeSocketVector', "!") + + self.outputs.new('NodeSocketColor', "How") + self.outputs.new('NodeSocketColor', "are") + self.outputs.new('NodeSocketFloat', "you") + + # Copy function to initialize a copied node from an existing one. + def copy(self, node): + print("Copying from node ", node) + + # Free function to clean up on removal. + def free(self): + print("Removing node ", self, ", Goodbye!") + + # Additional buttons displayed on the node. + def draw_buttons(self, context, layout): + layout.label("Node settings") + layout.prop(self, "myFloatProperty") + + # Detail buttons in the sidebar. + # If this function is not defined, the draw_buttons function is used instead + def draw_buttons_ext(self, context, layout): + layout.prop(self, "myFloatProperty") + # myStringProperty button will only be visible in the sidebar + layout.prop(self, "myStringProperty") + + +# A customized group-like node. +class MyCustomGroup(bpy.types.NodeGroup, MyCustomTreeNode): + # === Basics === + # Description string + '''A custom group node''' + # Label for nice name display + bl_label = 'Custom Group Node' + bl_group_tree_idname = 'CustomTreeType' + + orks = bpy.props.IntProperty(default=3) + dwarfs = bpy.props.IntProperty(default=12) + wizards = bpy.props.IntProperty(default=1) + + # Additional buttons displayed on the node. + def draw_buttons(self, context, layout): + col = layout.column(align=True) + col.prop(self, "orks") + col.prop(self, "dwarfs") + col.prop(self, "wizards") + + layout.label("The Node Tree:") + layout.prop(self, "node_tree", text="") + + +def register(): + bpy.utils.register_class(MyCustomTree) + bpy.utils.register_class(MyCustomSocket) + bpy.utils.register_class(MyCustomNode) + bpy.utils.register_class(MyCustomGroup) + + +def unregister(): + bpy.utils.unregister_class(MyCustomTree) + bpy.utils.unregister_class(MyCustomSocket) + bpy.utils.unregister_class(MyCustomNode) + bpy.utils.unregister_class(MyCustomGroup) + + +if __name__ == "__main__": + register() + diff --git a/source/blender/blenkernel/BKE_blender.h b/source/blender/blenkernel/BKE_blender.h index a53fc15714e..d03c631f7a1 100644 --- a/source/blender/blenkernel/BKE_blender.h +++ b/source/blender/blenkernel/BKE_blender.h @@ -42,7 +42,7 @@ extern "C" { * and keep comment above the defines. * Use STRINGIFY() rather than defining with quotes */ #define BLENDER_VERSION 266 -#define BLENDER_SUBVERSION 1 +#define BLENDER_SUBVERSION 2 /* 262 was the last editmesh release but it has compatibility code for bmesh data */ #define BLENDER_MINVERSION 262 diff --git a/source/blender/blenkernel/BKE_node.h b/source/blender/blenkernel/BKE_node.h index 80955729326..513851ce18f 100644 --- a/source/blender/blenkernel/BKE_node.h +++ b/source/blender/blenkernel/BKE_node.h @@ -32,8 +32,21 @@ * \ingroup bke */ +#include "BLI_ghash.h" +#include "BLI_utildefines.h" + #include "DNA_listBase.h" +/* for FOREACH_NODETREE */ +#include "DNA_lamp_types.h" +#include "DNA_material_types.h" +#include "DNA_node_types.h" +#include "DNA_scene_types.h" +#include "DNA_texture_types.h" +#include "DNA_world_types.h" + +#include "RNA_types.h" + /* not very important, but the stack solver likes to know a maximum */ #define MAX_SOCKET 64 @@ -43,7 +56,10 @@ struct bNodeLink; struct bNodeSocket; struct bNodeStack; struct bNodeTree; +struct bNodeTreeType; struct bNodeTreeExec; +struct bNodeExecContext; +struct bNodeExecData; struct GPUMaterial; struct GPUNode; struct GPUNodeStack; @@ -65,6 +81,7 @@ struct ARegion; struct Object; struct ColorManagedViewSettings; struct ColorManagedDisplaySettings; +struct bNodeInstanceHash; /* ************** NODE TYPE DEFINITIONS ***** */ @@ -72,9 +89,9 @@ struct ColorManagedDisplaySettings; * Can be used to quickly define a list of static sockets for a node, * which are added to each new node of that type. * - * \deprecated New nodes should add default sockets in the initialization - * function instead. This struct is mostly kept for old nodes and should - * be removed some time. + * \deprecated This struct is used by C nodes to define templates as simple + * static struct lists. These are converted to the new template collections + * in RNA types automatically. */ typedef struct bNodeSocketTemplate { int type, limit; @@ -86,38 +103,38 @@ typedef struct bNodeSocketTemplate { /* after this line is used internal only */ struct bNodeSocket *sock; /* used to hold verified socket */ + char identifier[64]; /* generated from name */ } bNodeSocketTemplate; -typedef void (*NodeSocketButtonFunction)(const struct bContext *C, struct uiBlock *block, - struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock, - const char *name, int x, int y, int width); - /** Defines a socket type. * Defines the appearance and behavior of a socket in the UI. */ typedef struct bNodeSocketType { - int type; - char ui_name[64]; /* MAX_NAME */ - char ui_description[128]; - int ui_icon; - char ui_color[4]; + char idname[64]; /* identifier name */ + + void (*draw)(struct bContext *C, struct uiLayout *layout, struct PointerRNA *ptr, struct PointerRNA *node_ptr); + void (*draw_color)(struct bContext *C, struct PointerRNA *ptr, struct PointerRNA *node_ptr, float *r_color); + + void (*interface_draw)(struct bContext *C, struct uiLayout *layout, struct PointerRNA *ptr); + void (*interface_draw_color)(struct bContext *C, struct PointerRNA *ptr, float *r_color); + void (*interface_register_properties)(struct bNodeTree *ntree, struct bNodeSocket *stemp, struct StructRNA *data_srna); + void (*interface_init_socket)(struct bNodeTree *ntree, struct bNodeSocket *stemp, struct bNode *node, struct bNodeSocket *sock, const char *data_path); + void (*interface_from_socket)(struct bNodeTree *ntree, struct bNodeSocket *stemp, struct bNode *node, struct bNodeSocket *sock); - const char *value_structname; - int value_structsize; + /* RNA integration */ + ExtensionRNA ext_socket; + ExtensionRNA ext_interface; - NodeSocketButtonFunction buttonfunc; + /* for standard socket types in C */ + int type, subtype; } bNodeSocketType; -/** Template for creating a node. - * Stored required parameters to make a new node of a specific type. - */ -typedef struct bNodeTemplate { - int type; - - struct Main *main; - struct Scene *scene; - struct bNodeTree *ngroup; /* group tree */ -} bNodeTemplate; +typedef void (*NodeSocketDrawFunction)(struct bContext *C, struct uiLayout *layout, struct PointerRNA *ptr, struct PointerRNA *node_ptr, int linked); + +typedef void *(*NodeInitExecFunction)(struct bNodeExecContext *context, struct bNode *node, bNodeInstanceKey key); +typedef void (*NodeFreeExecFunction)(struct bNode *node, void *nodedata); +typedef void (*NodeExecFunction)(void *data, int thread, struct bNode *, struct bNodeExecData *execdata, struct bNodeStack **in, struct bNodeStack **out); +typedef int (*NodeGPUExecFunction)(struct GPUMaterial *mat, struct bNode *node, struct bNodeExecData *execdata, struct GPUNodeStack *in, struct GPUNodeStack *out); /** Defines a node type. * Initial attributes and constants for a node as well as callback functions @@ -127,8 +144,13 @@ typedef struct bNodeType { void *next, *prev; short needs_free; /* set for allocated types that need to be freed */ + char idname[64]; /* identifier name */ int type; - char name[64]; /* MAX_NAME */ + + char ui_name[64]; /* MAX_NAME */ + char ui_description[256]; + int ui_icon; + float width, minwidth, maxwidth; float height, minheight, maxheight; short nclass, flag, compatibility; @@ -139,7 +161,8 @@ typedef struct bNodeType { char storagename[64]; /* struct name for DNA */ /// Main draw function for the node. - void (*drawfunc)(const struct bContext *C, struct ARegion *ar, struct SpaceNode *snode, struct bNodeTree *ntree, struct bNode *node); + void (*drawfunc)(const struct bContext *C, struct ARegion *ar, struct SpaceNode *snode, + struct bNodeTree *ntree, struct bNode *node, bNodeInstanceKey key); /// Updates the node geometry attributes according to internal state before actual drawing. void (*drawupdatefunc)(const struct bContext *C, struct bNodeTree *ntree, struct bNode *node); /// Draw the option buttons on the node. @@ -150,8 +173,11 @@ typedef struct bNodeType { void (*uibackdropfunc)(struct SpaceNode *snode, struct ImBuf *backdrop, struct bNode *node, int x, int y); /// Draw a node socket. Default draws the input value button. - NodeSocketButtonFunction drawinputfunc; - NodeSocketButtonFunction drawoutputfunc; + /* XXX deprecated, only used for the OutputFile node, + * should be removed at some point. + */ + NodeSocketDrawFunction drawinputfunc; + NodeSocketDrawFunction drawoutputfunc; /// Optional custom label function for the node header. const char *(*labelfunc)(struct bNode *); @@ -168,45 +194,42 @@ typedef struct bNodeType { void (*verifyfunc)(struct bNodeTree *ntree, struct bNode *node, struct ID *id); /// Initialize a new node instance of this type after creation. - void (*initfunc)(struct bNodeTree *ntree, struct bNode *node, struct bNodeTemplate *ntemp); - /// Free the custom storage data. - void (*freestoragefunc)(struct bNode *node); - /// Make a copy of the custom storage data. - void (*copystoragefunc)(struct bNode *node, struct bNode *target); + void (*initfunc)(struct bNodeTree *ntree, struct bNode *node); + /// Free the node instance. + void (*freefunc)(struct bNode *node); + /// Make a copy of the node instance. + void (*copyfunc)(struct bNodeTree *dest_ntree, struct bNode *dest_node, struct bNode *src_node); - /// Create a template from an existing node. - struct bNodeTemplate (*templatefunc)(struct bNode *); - /** If a node can be made from the template in the given node tree. - * \note Node groups can not be created inside their own node tree. - */ - int (*validfunc)(struct bNodeTree *ntree, struct bNodeTemplate *ntemp); + /* Registerable API callback versions, called in addition to C callbacks */ + void (*initfunc_api)(const struct bContext *C, struct PointerRNA *ptr); + void (*freefunc_api)(struct PointerRNA *ptr); + void (*copyfunc_api)(struct PointerRNA *ptr, struct bNode *src_node); - /// Initialize a node tree associated to this node type. - void (*inittreefunc)(struct bNodeTree *ntree); - /// Update a node tree associated to this node type. - void (*updatetreefunc)(struct bNodeTree *ntree); - - /* group edit callbacks for operators */ - /* XXX this is going to be changed as required by the UI */ - struct bNodeTree *(*group_edit_get)(struct bNode *node); - struct bNodeTree *(*group_edit_set)(struct bNode *node, int edit); - void (*group_edit_clear)(struct bNode *node); + /* can this node type be added to a node tree */ + int (*poll)(struct bNodeType *ntype, struct bNodeTree *nodetree); + /* can this node be added to a node tree */ + int (*poll_instance)(struct bNode *node, struct bNodeTree *nodetree); /* Update the internal links list, for muting and disconnect operators. */ void (*update_internal_links)(struct bNodeTree *, struct bNode *node); /* **** execution callbacks **** */ - void *(*initexecfunc)(struct bNode *node); - void (*freeexecfunc)(struct bNode *node, void *nodedata); - void (*execfunc)(void *data, struct bNode *, struct bNodeStack **, struct bNodeStack **); - /* XXX this alternative exec function has been added to avoid changing all node types. - * when a final generic version of execution code is defined, this will be changed anyway - */ - void (*newexecfunc)(void *data, int thread, struct bNode *, void *nodedata, struct bNodeStack **, struct bNodeStack **); + NodeInitExecFunction initexecfunc; + NodeFreeExecFunction freeexecfunc; + NodeExecFunction execfunc; /* gpu */ - int (*gpufunc)(struct GPUMaterial *mat, struct bNode *node, struct GPUNodeStack *in, struct GPUNodeStack *out); - /* extended gpu function */ - int (*gpuextfunc)(struct GPUMaterial *mat, struct bNode *node, void *nodedata, struct GPUNodeStack *in, struct GPUNodeStack *out); + NodeGPUExecFunction gpufunc; + + /* Group type static info + * + * XXX This data is needed by group operators. If these operators could be implemented completely in Python, + * the static data could instead be stored in Python classes and would need no special treatment. + * Due to the way group operators move nodes between data blocks this is currently not possible. + */ + char group_tree_idname[64]; /* tree type associated to the group node type */ + + /* RNA integration */ + ExtensionRNA ext; } bNodeType; /* node->exec, now in use for composites (#define for break is same as ready yes) */ @@ -245,6 +268,7 @@ typedef struct bNodeType { #define NODE_CLASS_TRANSFORM 30 #define NODE_CLASS_COMBINE 31 #define NODE_CLASS_SCRIPT 32 +#define NODE_CLASS_INTERFACE 33 #define NODE_CLASS_SHADER 40 #define NODE_CLASS_LAYOUT 100 @@ -258,10 +282,6 @@ typedef struct bNodeType { #define NODE_RESIZE_RIGHT 4 #define NODE_RESIZE_LEFT 8 -/* enum values for input/output */ -#define SOCK_IN 1 -#define SOCK_OUT 2 - typedef enum eNodeSizePreset { NODE_SIZE_DEFAULT, NODE_SIZE_SMALL, @@ -270,19 +290,26 @@ typedef enum eNodeSizePreset { struct bNodeTreeExec; -typedef void (*bNodeTreeCallback)(void *calldata, struct ID *owner_id, struct bNodeTree *ntree); typedef void (*bNodeClassCallback)(void *calldata, int nclass, const char *name); typedef struct bNodeTreeType { int type; /* type identifier */ - char idname[64]; /* id name for RNA identification */ - - ListBase node_types; /* type definitions */ + char idname[64]; /* identifier name */ + + char ui_name[64]; + char ui_description[256]; + int ui_icon; /* callbacks */ void (*free_cache)(struct bNodeTree *ntree); void (*free_node_cache)(struct bNodeTree *ntree, struct bNode *node); - void (*foreach_nodetree)(struct Main *main, void *calldata, bNodeTreeCallback func); /* iteration over all node trees */ void (*foreach_nodeclass)(struct Scene *scene, void *calldata, bNodeClassCallback func); /* iteration over all node classes */ + /* Add menu for this node tree. */ + void (*draw_add_menu)(const struct bContext *C, struct uiLayout *layout, struct bNodeTree *ntree); + /* Check visibility in the node editor */ + int (*poll)(const struct bContext *C, struct bNodeTreeType *ntreetype); + /* Select a node tree from the context */ + void (*get_from_context)(const struct bContext *C, struct bNodeTreeType *ntreetype, + struct bNodeTree **r_ntree, struct ID **r_id, struct ID **r_from); /* calls allowing threaded composite */ void (*localize)(struct bNodeTree *localtree, struct bNodeTree *ntree); @@ -291,23 +318,37 @@ typedef struct bNodeTreeType { /* Tree update. Overrides nodetype->updatetreefunc! */ void (*update)(struct bNodeTree *ntree); - /* Node update. Overrides nodetype->updatefunc! */ - void (*update_node)(struct bNodeTree *ntree, struct bNode *node); int (*validate_link)(struct bNodeTree *ntree, struct bNodeLink *link); - - /* Default internal linking. */ - void (*update_internal_links)(struct bNodeTree *, struct bNode *node); + + /* RNA integration */ + ExtensionRNA ext; } bNodeTreeType; + /* ************** GENERIC API, TREES *************** */ -struct bNodeTreeType *ntreeGetType(int type); -struct bNodeType *ntreeGetNodeType(struct bNodeTree *ntree); -struct bNodeSocketType *ntreeGetSocketType(int type); +struct bNodeTreeType *ntreeTypeFind(const char *idname); +void ntreeTypeAdd(struct bNodeTreeType* nt); +void ntreeTypeFreeLink(struct bNodeTreeType* nt); +struct GHashIterator *ntreeTypeGetIterator(void); + +/* helper macros for iterating over tree types */ +#define NODE_TREE_TYPES_BEGIN(ntype) \ +{ \ + GHashIterator *__node_tree_type_iter__ = ntreeTypeGetIterator(); \ + for (; BLI_ghashIterator_notDone(__node_tree_type_iter__); BLI_ghashIterator_step(__node_tree_type_iter__)) { \ + bNodeTreeType *ntype = BLI_ghashIterator_getValue(__node_tree_type_iter__); -struct bNodeTree *ntreeAddTree(struct Main *bmain, const char *name, int type, int nodetype); -void ntreeInitTypes(struct bNodeTree *ntree); +#define NODE_TREE_TYPES_END \ + } \ + BLI_ghashIterator_free(__node_tree_type_iter__); \ +} + +void ntreeSetTypes(const struct bContext *C, struct bNodeTree *ntree); +int ntreeIsValid(struct bNodeTree *ntree); + +struct bNodeTree *ntreeAddTree(struct Main *bmain, const char *name, const char *idname); /* copy/free funcs, need to manage ID users */ void ntreeFreeTree_ex(struct bNodeTree *ntree, const short do_id_user); @@ -337,8 +378,6 @@ void ntreeGetDependencyList(struct bNodeTree *ntree, struct bNode * * new tree types have a per-output socket flag to indicate the final output to use explicitly. */ void ntreeSetOutput(struct bNodeTree *ntree); -void ntreeInitPreview(struct bNodeTree *, int xsize, int ysize); -void ntreeClearPreview(struct bNodeTree *ntree); void ntreeFreeCache(struct bNodeTree *ntree); @@ -348,29 +387,86 @@ struct bNodeTree *ntreeLocalize(struct bNodeTree *ntree); void ntreeLocalSync(struct bNodeTree *localtree, struct bNodeTree *ntree); void ntreeLocalMerge(struct bNodeTree *localtree, struct bNodeTree *ntree); +/* ************** NODE TREE INTERFACE *************** */ + +struct bNodeSocket *ntreeFindSocketInterface(struct bNodeTree *ntree, int in_out, const char *identifier); +struct bNodeSocket *ntreeAddSocketInterface(struct bNodeTree *ntree, int in_out, const char *idname, const char *name); +struct bNodeSocket *ntreeInsertSocketInterface(struct bNodeTree *ntree, int 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, int create); +void ntreeInterfaceTypeFree(struct bNodeTree *ntree); +void ntreeInterfaceTypeUpdate(struct bNodeTree *ntree); + /* ************** GENERIC API, NODES *************** */ -struct bNodeSocket *nodeAddSocket(struct bNodeTree *ntree, struct bNode *node, int in_out, const char *name, int type); -struct bNodeSocket *nodeInsertSocket(struct bNodeTree *ntree, struct bNode *node, int in_out, struct bNodeSocket *next_sock, const char *name, int type); +struct bNodeType *nodeTypeFind(const char *idname); +void nodeRegisterType(struct bNodeType* ntype); +void nodeUnregisterType(struct bNodeType* ntype); +struct GHashIterator *nodeTypeGetIterator(void); + +/* helper macros for iterating over node types */ +#define NODE_TYPES_BEGIN(ntype) \ +{ \ + GHashIterator *__node_type_iter__ = nodeTypeGetIterator(); \ + for (; BLI_ghashIterator_notDone(__node_type_iter__); BLI_ghashIterator_step(__node_type_iter__)) { \ + bNodeType *ntype = BLI_ghashIterator_getValue(__node_type_iter__); + +#define NODE_TYPES_END \ + } \ + BLI_ghashIterator_free(__node_type_iter__); \ +} + +struct bNodeSocketType *nodeSocketTypeFind(const char *idname); +void nodeRegisterSocketType(struct bNodeSocketType* stype); +void nodeUnregisterSocketType(struct bNodeSocketType* stype); +struct GHashIterator *nodeSocketTypeGetIterator(void); +const char * nodeStaticSocketType(int type, int subtype); +const char * nodeStaticSocketInterfaceType(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_notDone(__node_socket_type_iter__); BLI_ghashIterator_step(__node_socket_type_iter__)) { \ + bNodeSocketType *stype = BLI_ghashIterator_getValue(__node_socket_type_iter__); + +#define NODE_SOCKET_TYPES_END \ + } \ + BLI_ghashIterator_free(__node_socket_type_iter__); \ +} + +void nodeMakeDynamicType(struct bNode *node); +int nodeDynamicUnlinkText(struct ID *txtid); + +struct bNodeSocket *nodeFindSocket(struct bNode *node, int in_out, const char *identifier); +struct bNodeSocket *nodeAddSocket(struct bNodeTree *ntree, struct bNode *node, int in_out, const char *idname, + const char *identifier, const char *name); +struct bNodeSocket *nodeInsertSocket(struct bNodeTree *ntree, struct bNode *node, int in_out, const char *idname, + struct bNodeSocket *next_sock, const char *identifier, const char *name); +struct bNodeSocket *nodeAddStaticSocket(struct bNodeTree *ntree, struct bNode *node, int in_out, int type, int subtype, + const char *identifier, const char *name); +struct bNodeSocket *nodeInsertStaticSocket(struct bNodeTree *ntree, struct bNode *node, int in_out, int type, int subtype, + struct bNodeSocket *next_sock, const char *identifier, const char *name); void nodeRemoveSocket(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock); void nodeRemoveAllSockets(struct bNodeTree *ntree, struct bNode *node); -void nodeAddToPreview(struct bNode *node, const float col[4], int x, int y, int do_manage); - -struct bNode *nodeAddNode(struct bNodeTree *ntree, struct bNodeTemplate *ntemp); +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); void nodeUnlinkNode(struct bNodeTree *ntree, struct bNode *node); void nodeUniqueName(struct bNodeTree *ntree, struct bNode *node); -void nodeRegisterType(struct bNodeTreeType *ttype, struct bNodeType *ntype); -void nodeMakeDynamicType(struct bNode *node); -int nodeDynamicUnlinkText(struct ID *txtid); - void nodeFreeNode(struct bNodeTree *ntree, struct bNode *node); struct bNode *nodeCopyNode(struct bNodeTree *ntree, struct bNode *node); 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); +int nodeLinkIsHidden(struct bNodeLink *link); void nodeInternalRelink(struct bNodeTree *ntree, struct bNode *node); void nodeToView(struct bNode *node, float x, float y, float *rx, float *ry); @@ -380,11 +476,12 @@ void nodeAttachNode(struct bNode *node, struct bNode *parent); void nodeDetachNode(struct bNode *node); struct bNode *nodeFindNodebyName(struct bNodeTree *ntree, const char *name); -int nodeFindNode(struct bNodeTree *ntree, struct bNodeSocket *sock, struct bNode **nodep, int *sockindex, int *in_out); +int nodeFindNode(struct bNodeTree *ntree, struct bNodeSocket *sock, struct bNode **nodep, int *sockindex); struct bNodeLink *nodeFindLink(struct bNodeTree *ntree, struct bNodeSocket *from, struct bNodeSocket *to); int nodeCountSocketLinks(struct bNodeTree *ntree, struct bNodeSocket *sock); +void nodeSetSelected(struct bNode *node, int select); void nodeSetActive(struct bNodeTree *ntree, struct bNode *node); struct bNode *nodeGetActive(struct bNodeTree *ntree); struct bNode *nodeGetActiveID(struct bNodeTree *ntree, short idtype); @@ -396,11 +493,9 @@ struct bNode *nodeGetActiveTexture(struct bNodeTree *ntree); void nodeUpdate(struct bNodeTree *ntree, struct bNode *node); int nodeUpdateID(struct bNodeTree *ntree, struct ID *id); void nodeUpdateInternalLinks(struct bNodeTree *ntree, struct bNode *node); - -void nodeFreePreview(struct bNode *node); +void nodeSynchronizeID(struct bNode *node, bool copy_to_id); int nodeSocketIsHidden(struct bNodeSocket *sock); -void nodeSocketSetType(struct bNodeSocket *sock, int type); /* Node Clipboard */ void BKE_node_clipboard_init(struct bNodeTree *ntree); @@ -412,78 +507,189 @@ 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 +{ + GHash *ghash; /* XXX should be made a direct member, GHash allocation needs to support it */ +} bNodeInstanceHash; + +typedef void (*bNodeInstanceValueFP)(void *value); + +extern const bNodeInstanceKey NODE_INSTANCE_KEY_BASE; + +bNodeInstanceKey BKE_node_instance_key(bNodeInstanceKey parent_key, struct bNodeTree *ntree, 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); +int 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_not_done(bNodeInstanceHashIterator *iter) { return BLI_ghashIterator_notDone(iter); } + +#define NODE_INSTANCE_HASH_ITER(iter_, hash_) \ + for (BKE_node_instance_hash_iterator_init(&iter_, hash_); \ + BKE_node_instance_hash_iterator_not_done(&iter_); \ + BKE_node_instance_hash_iterator_step(&iter_)) + + +/* Node Previews */ + +int BKE_node_preview_used(struct bNode *node); +bNodePreview* BKE_node_preview_verify(struct bNodeInstanceHash *previews, bNodeInstanceKey key, int xsize, int ysize, int 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, int create_previews); +void BKE_node_preview_free_tree(struct bNodeTree *ntree); +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_sync_tree(struct bNodeTree *to_ntree, struct bNodeTree *from_ntree); +void BKE_node_preview_merge_tree(struct bNodeTree *to_ntree, struct bNodeTree *from_ntree); + +void BKE_node_preview_set_pixel(struct bNodePreview *preview, const float col[4], int x, int y, int do_manage); + + /* ************** NODE TYPE ACCESS *************** */ -struct bNodeTemplate nodeMakeTemplate(struct bNode *node); -int nodeValid(struct bNodeTree *ntree, struct bNodeTemplate *ntemp); const char *nodeLabel(struct bNode *node); struct bNodeTree *nodeGroupEditGet(struct bNode *node); struct bNodeTree *nodeGroupEditSet(struct bNode *node, int edit); void nodeGroupEditClear(struct bNode *node); +int nodeGroupPoll(struct bNodeTree *nodetree, struct bNodeTree *grouptree); + /* Init a new node type struct with default values and callbacks */ -void node_type_base(struct bNodeTreeType *ttype, struct bNodeType *ntype, int type, - const char *name, short nclass, short flag); +void node_type_base(struct bNodeType *ntype, int type, const char *name, short nclass, short flag); +void node_type_base_custom(struct bNodeType *ntype, const char *idname, const char *name, short nclass, short flag); 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, struct bNodeTemplate *ntemp)); -void node_type_valid(struct bNodeType *ntype, int (*validfunc)(struct bNodeTree *ntree, struct bNodeTemplate *ntemp)); +void node_type_init(struct bNodeType *ntype, void (*initfunc)(struct bNodeTree *ntree, struct bNode *node)); void node_type_storage(struct bNodeType *ntype, const char *storagename, - void (*freestoragefunc)(struct bNode *), - void (*copystoragefunc)(struct bNode *, struct bNode *)); + void (*freefunc)(struct bNode *node), + void (*copyfunc)(struct bNodeTree *dest_ntree, struct bNode *dest_node, struct bNode *src_node)); void node_type_label(struct bNodeType *ntype, const char *(*labelfunc)(struct bNode *)); -void node_type_template(struct bNodeType *ntype, struct bNodeTemplate (*templatefunc)(struct bNode *)); void node_type_update(struct bNodeType *ntype, void (*updatefunc)(struct bNodeTree *ntree, struct bNode *node), void (*verifyfunc)(struct bNodeTree *ntree, struct bNode *node, struct ID *id)); -void node_type_tree(struct bNodeType *ntype, - void (*inittreefunc)(struct bNodeTree *), - void (*updatetreefunc)(struct bNodeTree *)); -void node_type_group_edit(struct bNodeType *ntype, - struct bNodeTree *(*group_edit_get)(struct bNode *node), - struct bNodeTree *(*group_edit_set)(struct bNode *node, int edit), - void (*group_edit_clear)(struct bNode *node)); - -void node_type_exec(struct bNodeType *ntype, void (*execfunc)(void *data, struct bNode *, struct bNodeStack **, - struct bNodeStack **)); -void node_type_exec_new(struct bNodeType *ntype, - void *(*initexecfunc)(struct bNode *node), - void (*freeexecfunc)(struct bNode *node, void *nodedata), - void (*newexecfunc)(void *data, int thread, struct bNode *, void *nodedata, - struct bNodeStack **, struct bNodeStack **)); + +void node_type_exec(struct bNodeType *ntype, NodeInitExecFunction initexecfunc, NodeFreeExecFunction freeexecfunc, NodeExecFunction execfunc); +void node_type_gpu(struct bNodeType *ntype, NodeGPUExecFunction gpufunc); void node_type_internal_links(struct bNodeType *ntype, void (*update_internal_links)(struct bNodeTree *, struct bNode *)); -void node_type_gpu(struct bNodeType *ntype, int (*gpufunc)(struct GPUMaterial *mat, struct bNode *node, - struct GPUNodeStack *in, struct GPUNodeStack *out)); -void node_type_gpu_ext(struct bNodeType *ntype, int (*gpuextfunc)(struct GPUMaterial *mat, struct bNode *node, - void *nodedata, struct GPUNodeStack *in, - struct GPUNodeStack *out)); void node_type_compatibility(struct bNodeType *ntype, short compatibility); /* ************** 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_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 -/* look up a socket on a group node by the internal group socket */ -struct bNodeSocket *node_group_find_input(struct bNode *gnode, struct bNodeSocket *gsock); -struct bNodeSocket *node_group_find_output(struct bNode *gnode, struct bNodeSocket *gsock); +void BKE_node_tree_unlink_id(ID *id, struct bNodeTree *ntree); -struct bNodeSocket *node_group_add_socket(struct bNodeTree *ngroup, const char *name, int type, int in_out); -struct bNodeSocket *node_group_expose_socket(struct bNodeTree *ngroup, struct bNodeSocket *sock, int in_out); -void node_group_expose_all_sockets(struct bNodeTree *ngroup); -void node_group_remove_socket(struct bNodeTree *ngroup, struct bNodeSocket *gsock, int in_out); -struct bNodeSocket *node_group_add_extern_socket(struct bNodeTree *ntree, ListBase *lb, int in_out, struct bNodeSocket *gsock); - -/* in node_common.c */ -void register_node_type_frame(struct bNodeTreeType *ttype); -void register_node_type_reroute(struct bNodeTreeType *ttype); +/* 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: + * + * FOREACH_NODETREE(bmain, nodetree) + * if (id == nodetree) + * printf("This is a linkable node tree"); + * FOREACH_NODETREE_END + * + * FOREACH_NODETREE(bmain, nodetree) + * 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 + */ -void BKE_node_tree_unlink_id_cb(void *calldata, struct ID *owner_id, struct bNodeTree *ntree); +#define FOREACH_NODETREE(bmain, _nodetree, _id) \ +{ \ + bNodeTree *_nodetree; \ + ID *_id; \ + bNodeTree *_ngroup = bmain->nodetree.first; \ + Scene *_scene = bmain->scene.first; \ + Material *_mat = bmain->mat.first; \ + Tex *_tex = bmain->tex.first; \ + Lamp *_lamp = bmain->lamp.first; \ + World *_world = bmain->world.first; \ + /* avoid compiler warning about unused variables */ \ + (void)_id; \ + (void)_nodetree; \ + do { \ + if (_ngroup) { \ + _nodetree = _ngroup; \ + _id = (ID *)_ngroup; \ + _ngroup = _ngroup->id.next; \ + } \ + else if (_scene) { \ + _nodetree = _scene->nodetree; \ + _id = (ID *)_scene; \ + _scene = _scene->id.next; \ + } \ + else if (_mat) { \ + _nodetree = _mat->nodetree; \ + _id = (ID *)_mat; \ + _mat = _mat->id.next; \ + } \ + else if (_tex) { \ + _nodetree = _tex->nodetree; \ + _id = (ID *)_tex; \ + _tex = _tex->id.next; \ + } \ + else if (_lamp) { \ + _nodetree = _lamp->nodetree; \ + _id = (ID *)_lamp; \ + _lamp = _lamp->id.next; \ + } \ + else if (_world) { \ + _nodetree = _world->nodetree; \ + _id = (ID *)_world; \ + _world = _world->id.next; \ + } \ + else \ + break; \ + if (_nodetree) { + +#define FOREACH_NODETREE_END \ + } \ + } while (TRUE); \ +} /* ************** SHADER NODES *************** */ @@ -583,11 +789,10 @@ struct ShadeResult; /* API */ -struct bNodeTreeExec *ntreeShaderBeginExecTree(struct bNodeTree *ntree, int use_tree_data); -void ntreeShaderEndExecTree(struct bNodeTreeExec *exec, int use_tree_data); +struct bNodeTreeExec *ntreeShaderBeginExecTree(struct bNodeTree *ntree); +void ntreeShaderEndExecTree(struct bNodeTreeExec *exec); bool ntreeShaderExecTree(struct bNodeTree *ntree, struct ShadeInput *shi, struct ShadeResult *shr); void ntreeShaderGetTexcoMode(struct bNodeTree *ntree, int osa, short *texco, int *mode); -void nodeShaderSynchronizeID(struct bNode *node, int copyto); /* switch material render loop */ extern void (*node_shader_lamp_loop)(struct ShadeInput *, struct ShadeResult *); @@ -798,8 +1003,8 @@ struct TexResult; int ntreeTexTagAnimated(struct bNodeTree *ntree); void ntreeTexCheckCyclics(struct bNodeTree *ntree); -struct bNodeTreeExec *ntreeTexBeginExecTree(struct bNodeTree *ntree, int use_tree_data); -void ntreeTexEndExecTree(struct bNodeTreeExec *exec, int use_tree_data); +struct bNodeTreeExec *ntreeTexBeginExecTree(struct bNodeTree *ntree); +void ntreeTexEndExecTree(struct bNodeTreeExec *exec); int ntreeTexExecTree(struct bNodeTree *ntree, struct TexResult *target, float coord[3], float dxt[3], float dyt[3], int osatex, const short thread, struct Tex *tex, short which_output, int cfra, int preview, struct ShadeInput *shi, struct MTex *mtex); diff --git a/source/blender/blenkernel/intern/image.c b/source/blender/blenkernel/intern/image.c index c27f5e62520..355541557ea 100644 --- a/source/blender/blenkernel/intern/image.c +++ b/source/blender/blenkernel/intern/image.c @@ -2171,7 +2171,7 @@ void BKE_image_walk_all_users(const Main *mainp, void *customdata, } else if (sa->spacetype == SPACE_NODE) { SpaceNode *snode = sa->spacedata.first; - if ((snode->treetype == NTREE_COMPOSIT) && (snode->nodetree)) { + if (snode->nodetree && snode->nodetree->type==NTREE_COMPOSIT) { bNode *node; for (node = snode->nodetree->nodes.first; node; node = node->next) { if (node->id && node->type == CMP_NODE_IMAGE) { diff --git a/source/blender/blenkernel/intern/mask.c b/source/blender/blenkernel/intern/mask.c index 87802ab8ee6..a5241684e3a 100644 --- a/source/blender/blenkernel/intern/mask.c +++ b/source/blender/blenkernel/intern/mask.c @@ -57,6 +57,8 @@ #include "BKE_movieclip.h" #include "BKE_image.h" +#include "NOD_composite.h" + static MaskSplinePoint *mask_spline_point_next(MaskSpline *spline, MaskSplinePoint *points_array, MaskSplinePoint *point) { if (point == &points_array[spline->tot_point - 1]) { @@ -966,10 +968,9 @@ void BKE_mask_free(Main *bmain, Mask *mask) } } - { - bNodeTreeType *treetype = ntreeGetType(NTREE_COMPOSIT); - treetype->foreach_nodetree(bmain, (void *)mask, &BKE_node_tree_unlink_id_cb); - } + FOREACH_NODETREE(bmain, ntree, id) { + BKE_node_tree_unlink_id((ID *)mask, ntree); + } FOREACH_NODETREE_END /* free mask data */ BKE_mask_layer_free_list(&mask->masklayers); diff --git a/source/blender/blenkernel/intern/material.c b/source/blender/blenkernel/intern/material.c index ab425d8e5b9..c47eb7eac45 100644 --- a/source/blender/blenkernel/intern/material.c +++ b/source/blender/blenkernel/intern/material.c @@ -1012,7 +1012,7 @@ void init_render_material(Material *mat, int r_mode, float *amb) init_render_nodetree(mat->nodetree, mat, r_mode, amb); if (!mat->nodetree->execdata) - mat->nodetree->execdata = ntreeShaderBeginExecTree(mat->nodetree, 1); + mat->nodetree->execdata = ntreeShaderBeginExecTree(mat->nodetree); } } @@ -1046,7 +1046,7 @@ void end_render_material(Material *mat) { if (mat && mat->nodetree && mat->use_nodes) { if (mat->nodetree->execdata) - ntreeShaderEndExecTree(mat->nodetree->execdata, 1); + ntreeShaderEndExecTree(mat->nodetree->execdata); } } diff --git a/source/blender/blenkernel/intern/movieclip.c b/source/blender/blenkernel/intern/movieclip.c index e79754ca203..821c8fe3bda 100644 --- a/source/blender/blenkernel/intern/movieclip.c +++ b/source/blender/blenkernel/intern/movieclip.c @@ -86,6 +86,8 @@ #include "intern/openexr/openexr_multi.h" #endif +#include "NOD_composite.h" + /*********************** movieclip buffer loaders *************************/ static int sequence_guess_offset(const char *full_name, int head_len, unsigned short numlen) @@ -1401,10 +1403,9 @@ void BKE_movieclip_unlink(Main *bmain, MovieClip *clip) } } - { - bNodeTreeType *treetype = ntreeGetType(NTREE_COMPOSIT); - treetype->foreach_nodetree(bmain, (void *)clip, &BKE_node_tree_unlink_id_cb); - } + FOREACH_NODETREE(bmain, ntree, id) { + BKE_node_tree_unlink_id((ID *)clip, ntree); + } FOREACH_NODETREE_END clip->id.us = 0; } diff --git a/source/blender/blenkernel/intern/node.c b/source/blender/blenkernel/intern/node.c index 974a564b9da..0b63c4d8842 100644 --- a/source/blender/blenkernel/intern/node.c +++ b/source/blender/blenkernel/intern/node.c @@ -58,133 +58,634 @@ #include "BKE_action.h" #include "BKE_fcurve.h" #include "BKE_global.h" +#include "BKE_idprop.h" #include "BKE_image.h" #include "BKE_library.h" #include "BKE_main.h" #include "BKE_node.h" +#include "BLI_ghash.h" #include "RNA_access.h" +#include "RNA_define.h" #include "NOD_socket.h" +#include "NOD_common.h" #include "NOD_composite.h" #include "NOD_shader.h" #include "NOD_texture.h" -bNodeTreeType *ntreeGetType(int type) +static void node_add_sockets_from_type(bNodeTree *ntree, bNode *node, bNodeType *ntype) { - static bNodeTreeType *types[NUM_NTREE_TYPES]; - static int types_init = 1; - if (types_init) { - types[NTREE_SHADER] = &ntreeType_Shader; - types[NTREE_COMPOSIT] = &ntreeType_Composite; - types[NTREE_TEXTURE] = &ntreeType_Texture; - types_init = 0; + bNodeSocketTemplate *sockdef; + /* bNodeSocket *sock; */ /* UNUSED */ + + if (ntype->inputs) { + sockdef = ntype->inputs; + while (sockdef->type != -1) { + /* sock = */ node_add_socket_from_template(ntree, node, sockdef, SOCK_IN); + + sockdef++; + } + } + if (ntype->outputs) { + sockdef = ntype->outputs; + while (sockdef->type != -1) { + /* sock = */ node_add_socket_from_template(ntree, node, sockdef, SOCK_OUT); + + sockdef++; + } } +} + +/* Note: This function is called to initialize node data based on the type. + * The bNodeType may not be registered at creation time of the node, + * so this can be delayed until the node type gets registered. + * The node->typeinfo must not be used in that case until it is defined! + */ +static void node_init(const struct bContext *C, bNodeTree *ntree, bNode *node) +{ + bNodeType *ntype = node->typeinfo; + if (!ntype) + return; + + /* only do this once */ + if (node->flag & NODE_INIT) + return; + + node->flag = NODE_SELECT | ntype->flag; + node->width = ntype->width; + node->miniwidth = 42.0f; + node->height = ntype->height; + node->color[0] = node->color[1] = node->color[2] = 0.608; /* default theme color */ - if (type >= 0 && type < NUM_NTREE_TYPES) { - return types[type]; + /* initialize the node name with the node label. + * note: do this after the initfunc so nodes get their data set which may be used in naming + * (node groups for example) */ + /* XXX Do not use nodeLabel() here, it returns translated content, which should *only* be used + * in UI, *never* in data... + * This solution may be a bit rougher than nodeLabel()'s returned string, but it's simpler + * than adding a "no translate" flag to this func (and labelfunc() as well). */ + BLI_strncpy(node->name, ntype->ui_name, NODE_MAXSTR); + nodeUniqueName(ntree, node); + + node_add_sockets_from_type(ntree, node, ntype); + + if (ntype->initfunc != NULL) + ntype->initfunc(ntree, node); + + /* extra init callback */ + if (ntype->initfunc_api) { + PointerRNA ptr; + RNA_pointer_create((ID *)ntree, &RNA_Node, node, &ptr); + + /* XXX Warning: context can be NULL in case nodes are added in do_versions. + * Delayed init is not supported for nodes with context-based initfunc_api atm. + */ + BLI_assert(C != NULL); + ntype->initfunc_api(C, &ptr); + } + + node->flag |= NODE_INIT; +} + +static void ntree_set_typeinfo(bNodeTree *ntree, bNodeTreeType *typeinfo) +{ + ntree->typeinfo = typeinfo; + + if (typeinfo) { + /* deprecated integer type */ + ntree->type = typeinfo->type; } else { - return NULL; + ntree->init &= ~NTREE_TYPE_INIT; } } -static bNodeType *node_get_type(bNodeTree *ntree, int type) +static void node_set_typeinfo(const struct bContext *C, bNodeTree *ntree, bNode *node, bNodeType *typeinfo) { - bNodeType *ntype = ntreeGetType(ntree->type)->node_types.first; - for (; ntype; ntype = ntype->next) - if (ntype->type == type) - return ntype; + node->typeinfo = typeinfo; + if (typeinfo) { + /* deprecated integer type */ + node->type = typeinfo->type; + + /* initialize the node if necessary */ + node_init(C, ntree, node); + } + else { + ntree->init &= ~NTREE_TYPE_INIT; + } +} + +static void node_socket_set_typeinfo(bNodeTree *ntree, bNodeSocket *sock, bNodeSocketType *typeinfo) +{ + sock->typeinfo = typeinfo; + + if (typeinfo) { + if (sock->default_value == NULL) { + /* initialize the default_value pointer used by standard socket types */ + node_socket_init_default_value(sock); + } + } + else { + ntree->init &= ~NTREE_TYPE_INIT; + } +} + +/* Set specific typeinfo pointers in all node trees on register/unregister */ +static void update_typeinfo(Main *bmain, const struct bContext *C, bNodeTreeType *treetype, bNodeType *nodetype, bNodeSocketType *socktype, bool unregister) +{ + if (!bmain) + return; + + FOREACH_NODETREE(bmain, ntree, id) { + bNode *node; + bNodeSocket *sock; + + ntree->init |= NTREE_TYPE_INIT; + + if (treetype && strcmp(ntree->idname, treetype->idname)==0) + ntree_set_typeinfo(ntree, unregister ? NULL : treetype); + + /* initialize nodes */ + for (node=ntree->nodes.first; node; node=node->next) { + if (nodetype && strcmp(node->idname, nodetype->idname)==0) + node_set_typeinfo(C, ntree, node, unregister ? NULL : nodetype); + + /* initialize node sockets */ + for (sock=node->inputs.first; sock; sock=sock->next) + if (socktype && strcmp(sock->idname, socktype->idname)==0) + node_socket_set_typeinfo(ntree, sock, unregister ? NULL : socktype); + for (sock=node->outputs.first; sock; sock=sock->next) + if (socktype && strcmp(sock->idname, socktype->idname)==0) + node_socket_set_typeinfo(ntree, sock, unregister ? NULL : socktype); + } + + /* initialize tree sockets */ + for (sock=ntree->inputs.first; sock; sock=sock->next) + if (socktype && strcmp(sock->idname, socktype->idname)==0) + node_socket_set_typeinfo(ntree, sock, unregister ? NULL : socktype); + for (sock=ntree->outputs.first; sock; sock=sock->next) + if (socktype && strcmp(sock->idname, socktype->idname)==0) + node_socket_set_typeinfo(ntree, sock, unregister ? NULL : socktype); + } + FOREACH_NODETREE_END +} + +/* Try to initialize all typeinfo in a node tree. + * NB: In general undefined typeinfo is a perfectly valid case, the type may just be registered later. + * In that case the update_typeinfo function will set typeinfo on registration + * and do necessary updates. + */ +void ntreeSetTypes(const struct bContext *C, bNodeTree *ntree) +{ + bNode *node; + bNodeSocket *sock; + + ntree->init |= NTREE_TYPE_INIT; + + ntree_set_typeinfo(ntree, ntreeTypeFind(ntree->idname)); + + for (node = ntree->nodes.first; node; node = node->next) { + node_set_typeinfo(C, ntree, node, nodeTypeFind(node->idname)); + + for (sock=node->inputs.first; sock; sock=sock->next) + node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname)); + for (sock=node->outputs.first; sock; sock=sock->next) + node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname)); + } + + for (sock=ntree->inputs.first; sock; sock=sock->next) + node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname)); + for (sock=ntree->outputs.first; sock; sock=sock->next) + node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname)); +} + + +static GHash *nodetreetypes_hash= NULL; +static GHash *nodetypes_hash= NULL; +static GHash *nodesockettypes_hash= NULL; + +bNodeTreeType *ntreeTypeFind(const char *idname) +{ + bNodeTreeType* nt; + + if (idname[0]) { + nt= BLI_ghash_lookup(nodetreetypes_hash, idname); + if(nt) + return nt; + } + return NULL; } -bNodeType *ntreeGetNodeType(bNodeTree *ntree) +void ntreeTypeAdd(bNodeTreeType* nt) { - return node_get_type(ntree, ntree->nodetype); + BLI_ghash_insert(nodetreetypes_hash, (void *)nt->idname, nt); + /* XXX pass Main to register function? */ + update_typeinfo(G.main, NULL, nt, NULL, NULL, false); } -bNodeSocketType *ntreeGetSocketType(int type) +/* callback for hash value free function */ +static void ntree_free_type(void *treetype_v) { - static bNodeSocketType *types[NUM_SOCKET_TYPES] = {NULL}; - static int types_init = 1; + bNodeTreeType *treetype = treetype_v; + /* XXX pass Main to unregister function? */ + update_typeinfo(G.main, NULL, treetype, NULL, NULL, true); + MEM_freeN(treetype); +} - if (types_init) { - node_socket_type_init(types); - types_init = 0; +void ntreeTypeFreeLink(bNodeTreeType* nt) +{ + BLI_ghash_remove(nodetreetypes_hash, nt->idname, NULL, ntree_free_type); +} + +GHashIterator *ntreeTypeGetIterator() +{ + return BLI_ghashIterator_new(nodetreetypes_hash); +} + +int ntreeIsValid(bNodeTree *ntree) +{ + return (ntree && (ntree->init & NTREE_TYPE_INIT)); +} + +bNodeType *nodeTypeFind(const char *idname) +{ + bNodeType* nt; + + if (idname[0]) { + nt= BLI_ghash_lookup(nodetypes_hash, idname); + if(nt) + return nt; } - if (type < NUM_SOCKET_TYPES) { - return types[type]; + return NULL; +} + +static void free_dynamic_typeinfo(bNodeType *ntype) +{ + if(ntype->type==NODE_DYNAMIC) { + if(ntype->inputs) { + MEM_freeN(ntype->inputs); + } + if(ntype->outputs) { + MEM_freeN(ntype->outputs); + } + if(ntype->ui_name) { + MEM_freeN((void *)ntype->ui_name); + } } - else { - return NULL; +} + +/* callback for hash value free function */ +static void node_free_type(void *nodetype_v) +{ + bNodeType *nodetype = nodetype_v; + /* XXX pass Main to unregister function? */ + update_typeinfo(G.main, NULL, NULL, nodetype, NULL, true); + + /* XXX deprecated */ + if (nodetype->type==NODE_DYNAMIC) + free_dynamic_typeinfo(nodetype); + + if (nodetype->needs_free) + MEM_freeN(nodetype); +} + +void nodeRegisterType(bNodeType *nt) +{ + /* debug only: basic verification of registered types */ + BLI_assert(nt->idname[0] != '\0'); + BLI_assert(nt->poll != NULL); + + BLI_ghash_insert(nodetypes_hash, (void *)nt->idname, nt); + /* XXX pass Main to register function? */ + update_typeinfo(G.main, NULL, NULL, nt, NULL, false); +} + +void nodeUnregisterType(bNodeType* nt) +{ + BLI_ghash_remove(nodetypes_hash, nt->idname, NULL, node_free_type); +} + +GHashIterator *nodeTypeGetIterator() +{ + return BLI_ghashIterator_new(nodetypes_hash); +} + +bNodeSocketType *nodeSocketTypeFind(const char *idname) +{ + bNodeSocketType* st; + + if (idname[0]) { + st= BLI_ghash_lookup(nodesockettypes_hash, idname); + if(st) + return st; } + + return NULL; } -void ntreeInitTypes(bNodeTree *ntree) +/* callback for hash value free function */ +static void node_free_socket_type(void *socktype_v) { - bNode *node, *next; + bNodeSocketType *socktype = socktype_v; + /* XXX pass Main to unregister function? */ + update_typeinfo(G.main, NULL, NULL, NULL, socktype, true); - for (node = ntree->nodes.first; node; node = next) { - next = node->next; - - node->typeinfo = node_get_type(ntree, node->type); + MEM_freeN(socktype); +} - if (node->typeinfo == NULL) { - printf("Error: Node type %s doesn't exist anymore, removed\n", node->name); - nodeFreeNode(ntree, node); - } +void nodeRegisterSocketType(bNodeSocketType* st) +{ + BLI_ghash_insert(nodesockettypes_hash, (void *)st->idname, st); + /* XXX pass Main to register function? */ + update_typeinfo(G.main, NULL, NULL, NULL, st, false); +} + +void nodeUnregisterSocketType(bNodeSocketType* st) +{ + BLI_ghash_remove(nodesockettypes_hash, st->idname, NULL, node_free_socket_type); +} + +GHashIterator *nodeSocketTypeGetIterator(void) +{ + return BLI_ghashIterator_new(nodesockettypes_hash); +} + +void nodeMakeDynamicType(bNode *UNUSED(node)) +{ + #if 0 /* XXX deprecated */ + /* find SH_DYNAMIC_NODE ntype */ + bNodeType *ntype= ntreeType_Shader->node_types.first; + while(ntype) { + if(ntype->type==NODE_DYNAMIC) + break; + ntype= ntype->next; } - - ntree->init |= NTREE_TYPE_INIT; + + /* make own type struct to fill */ + if(ntype) { + /*node->typeinfo= MEM_dupallocN(ntype);*/ + bNodeType *newtype= MEM_callocN(sizeof(bNodeType), "dynamic bNodeType"); + *newtype= *ntype; + BLI_strncpy(newtype->name, ntype->name, sizeof(newtype->name)); + node->typeinfo= newtype; + } + #endif } -static bNodeSocket *make_socket(bNodeTree *UNUSED(ntree), int in_out, const char *name, int type) +struct bNodeSocket *nodeFindSocket(bNode *node, int in_out, const char *identifier) +{ + bNodeSocket *sock = (in_out == SOCK_IN ? node->inputs.first : node->outputs.first); + for (; sock; sock=sock->next) { + if (strcmp(sock->identifier, identifier)==0) + return sock; + } + return NULL; +} + +/* find unique socket identifier */ +static bool unique_identifier_check(void *arg, const char *identifier) +{ + struct ListBase *lb = arg; + bNodeSocket *sock; + for (sock = lb->first; sock; sock = sock->next) { + if (strcmp(sock->identifier, identifier)==0) + return true; + } + return false; +} + +static bNodeSocket *make_socket(bNodeTree *ntree, bNode *UNUSED(node), int in_out, ListBase *lb, + const char *idname, const char *identifier, const char *name) { bNodeSocket *sock; + char auto_identifier[MAX_NAME]; + + if (identifier && identifier[0] != '\0') { + /* use explicit identifier */ + BLI_strncpy(auto_identifier, identifier, sizeof(auto_identifier)); + } + else { + /* if no explicit identifier is given, assign a unique identifier based on the name */ + BLI_strncpy(auto_identifier, name, sizeof(auto_identifier)); + } + /* make the identifier unique */ + BLI_uniquename_cb(unique_identifier_check, lb, NULL, '.', auto_identifier, sizeof(auto_identifier)); sock = MEM_callocN(sizeof(bNodeSocket), "sock"); + sock->in_out = in_out; - BLI_strncpy(sock->name, name, NODE_MAXSTR); + BLI_strncpy(sock->identifier, auto_identifier, NODE_MAXSTR); sock->limit = (in_out == SOCK_IN ? 1 : 0xFFF); - sock->type = type; + + BLI_strncpy(sock->name, name, NODE_MAXSTR); sock->storage = NULL; sock->flag |= SOCK_COLLAPSED; + sock->type = SOCK_CUSTOM; /* int type undefined by default */ - sock->default_value = node_socket_make_default_value(type); - node_socket_init_default_value(type, sock->default_value); + BLI_strncpy(sock->idname, idname, sizeof(sock->idname)); + node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(idname)); return sock; } -bNodeSocket *nodeAddSocket(bNodeTree *ntree, bNode *node, int in_out, const char *name, int type) +bNodeSocket *nodeAddSocket(bNodeTree *ntree, bNode *node, int in_out, const char *idname, + const char *identifier, const char *name) { - bNodeSocket *sock = make_socket(ntree, in_out, name, type); - if (in_out == SOCK_IN) - BLI_addtail(&node->inputs, sock); - else if (in_out == SOCK_OUT) - BLI_addtail(&node->outputs, sock); + ListBase *lb = (in_out == SOCK_IN ? &node->inputs : &node->outputs); + bNodeSocket *sock = make_socket(ntree, node, in_out, lb, idname, identifier, name); + + BLI_remlink(lb, sock); /* does nothing for new socket */ + BLI_addtail(lb, sock); node->update |= NODE_UPDATE; return sock; } -bNodeSocket *nodeInsertSocket(bNodeTree *ntree, bNode *node, int in_out, bNodeSocket *next_sock, const char *name, int type) +bNodeSocket *nodeInsertSocket(bNodeTree *ntree, bNode *node, int in_out, const char *idname, + bNodeSocket *next_sock, const char *identifier, const char *name) { - bNodeSocket *sock = make_socket(ntree, in_out, name, type); - if (in_out == SOCK_IN) - BLI_insertlinkbefore(&node->inputs, next_sock, sock); - else if (in_out == SOCK_OUT) - BLI_insertlinkbefore(&node->outputs, next_sock, sock); + ListBase *lb = (in_out == SOCK_IN ? &node->inputs : &node->outputs); + bNodeSocket *sock = make_socket(ntree, node, in_out, lb, idname, identifier, name); + + BLI_remlink(lb, sock); /* does nothing for new socket */ + BLI_insertlinkbefore(lb, next_sock, sock); node->update |= NODE_UPDATE; return sock; } +const char *nodeStaticSocketType(int type, int subtype) +{ + switch (type) { + case SOCK_FLOAT: + switch (subtype) { + case PROP_UNSIGNED: + return "NodeSocketFloatUnsigned"; + case PROP_PERCENTAGE: + return "NodeSocketFloatPercentage"; + case PROP_FACTOR: + return "NodeSocketFloatFactor"; + case PROP_ANGLE: + return "NodeSocketFloatAngle"; + case PROP_TIME: + return "NodeSocketFloatTime"; + case PROP_NONE: + default: + return "NodeSocketFloat"; + } + case SOCK_INT: + switch (subtype) { + case PROP_UNSIGNED: + return "NodeSocketIntUnsigned"; + case PROP_PERCENTAGE: + return "NodeSocketIntPercentage"; + case PROP_FACTOR: + return "NodeSocketIntFactor"; + case PROP_NONE: + default: + return "NodeSocketInt"; + } + case SOCK_BOOLEAN: + return "NodeSocketBool"; + case SOCK_VECTOR: + switch (subtype) { + case PROP_TRANSLATION: + return "NodeSocketVectorTranslation"; + case PROP_DIRECTION: + return "NodeSocketVectorDirection"; + case PROP_VELOCITY: + return "NodeSocketVectorVelocity"; + case PROP_ACCELERATION: + return "NodeSocketVectorAcceleration"; + case PROP_EULER: + return "NodeSocketVectorEuler"; + case PROP_XYZ: + return "NodeSocketVectorXYZ"; + case PROP_NONE: + default: + return "NodeSocketVector"; + } + case SOCK_RGBA: + return "NodeSocketColor"; + case SOCK_STRING: + return "NodeSocketString"; + case SOCK_SHADER: + return "NodeSocketShader"; + } + return NULL; +} + +const char *nodeStaticSocketInterfaceType(int type, int subtype) +{ + switch (type) { + case SOCK_FLOAT: + switch (subtype) { + case PROP_UNSIGNED: + return "NodeSocketInterfaceFloatUnsigned"; + case PROP_PERCENTAGE: + return "NodeSocketInterfaceFloatPercentage"; + case PROP_FACTOR: + return "NodeSocketInterfaceFloatFactor"; + case PROP_ANGLE: + return "NodeSocketInterfaceFloatAngle"; + case PROP_TIME: + return "NodeSocketInterfaceFloatTime"; + case PROP_NONE: + default: + return "NodeSocketInterfaceFloat"; + } + case SOCK_INT: + switch (subtype) { + case PROP_UNSIGNED: + return "NodeSocketInterfaceIntUnsigned"; + case PROP_PERCENTAGE: + return "NodeSocketInterfaceIntPercentage"; + case PROP_FACTOR: + return "NodeSocketInterfaceIntFactor"; + case PROP_NONE: + default: + return "NodeSocketInterfaceInt"; + } + case SOCK_BOOLEAN: + return "NodeSocketInterfaceBool"; + case SOCK_VECTOR: + switch (subtype) { + case PROP_TRANSLATION: + return "NodeSocketInterfaceVectorTranslation"; + case PROP_DIRECTION: + return "NodeSocketInterfaceVectorDirection"; + case PROP_VELOCITY: + return "NodeSocketInterfaceVectorVelocity"; + case PROP_ACCELERATION: + return "NodeSocketInterfaceVectorAcceleration"; + case PROP_EULER: + return "NodeSocketInterfaceVectorEuler"; + case PROP_XYZ: + return "NodeSocketInterfaceVectorXYZ"; + case PROP_NONE: + default: + return "NodeSocketInterfaceVector"; + } + case SOCK_RGBA: + return "NodeSocketInterfaceColor"; + case SOCK_STRING: + return "NodeSocketInterfaceString"; + case SOCK_SHADER: + return "NodeSocketInterfaceShader"; + } + return NULL; +} + +bNodeSocket *nodeAddStaticSocket(bNodeTree *ntree, bNode *node, int in_out, int type, int subtype, + const char *identifier, const char *name) +{ + const char *idname = nodeStaticSocketType(type, subtype); + bNodeSocket *sock; + + if (!idname) { + printf("Error: static node socket type %d undefined\n", type); + return NULL; + } + + sock = nodeAddSocket(ntree, node, in_out, idname, identifier, name); + sock->type = type; + return sock; +} + +bNodeSocket *nodeInsertStaticSocket(bNodeTree *ntree, bNode *node, int in_out, int type, int subtype, + bNodeSocket *next_sock, const char *identifier, const char *name) +{ + const char *idname = nodeStaticSocketType(type, subtype); + bNodeSocket *sock; + + if (!idname) { + printf("Error: static node socket type %d undefined\n", type); + return NULL; + } + + sock = nodeInsertSocket(ntree, node, in_out, idname, next_sock, identifier, name); + sock->type = type; + return sock; +} + +static void node_socket_free(bNodeTree *UNUSED(ntree), bNodeSocket *sock, bNode *UNUSED(node)) +{ + if (sock->prop) { + IDP_FreeProperty(sock->prop); + MEM_freeN(sock->prop); + } + + if (sock->default_value) + MEM_freeN(sock->default_value); +} + void nodeRemoveSocket(bNodeTree *ntree, bNode *node, bNodeSocket *sock) { bNodeLink *link, *next; @@ -200,7 +701,7 @@ void nodeRemoveSocket(bNodeTree *ntree, bNode *node, bNodeSocket *sock) BLI_remlink(&node->inputs, sock); BLI_remlink(&node->outputs, sock); - node_socket_free_default_value(sock->type, sock->default_value); + node_socket_free(ntree, sock, node); MEM_freeN(sock); node->update |= NODE_UPDATE; @@ -208,7 +709,7 @@ void nodeRemoveSocket(bNodeTree *ntree, bNode *node, bNodeSocket *sock) void nodeRemoveAllSockets(bNodeTree *ntree, bNode *node) { - bNodeSocket *sock; + bNodeSocket *sock, *sock_next; bNodeLink *link, *next; for (link = ntree->links.first; link; link = next) { @@ -218,12 +719,16 @@ void nodeRemoveAllSockets(bNodeTree *ntree, bNode *node) } } - for (sock = node->inputs.first; sock; sock = sock->next) - node_socket_free_default_value(sock->type, sock->default_value); - BLI_freelistN(&node->inputs); - for (sock = node->outputs.first; sock; sock = sock->next) - node_socket_free_default_value(sock->type, sock->default_value); - BLI_freelistN(&node->outputs); + for (sock = node->inputs.first; sock; sock = sock_next) { + sock_next = sock->next; + node_socket_free(ntree, sock, node); + MEM_freeN(sock); + } + for (sock = node->outputs.first; sock; sock = sock_next) { + sock_next = sock->next; + node_socket_free(ntree, sock, node); + MEM_freeN(sock); + } node->update |= NODE_UPDATE; } @@ -235,26 +740,18 @@ bNode *nodeFindNodebyName(bNodeTree *ntree, const char *name) } /* finds a node based on given socket */ -int nodeFindNode(bNodeTree *ntree, bNodeSocket *sock, bNode **nodep, int *sockindex, int *in_out) +int nodeFindNode(bNodeTree *ntree, bNodeSocket *sock, bNode **nodep, int *sockindex) { + int in_out = sock->in_out; bNode *node; bNodeSocket *tsock; int index = 0; for (node = ntree->nodes.first; node; node = node->next) { - for (index = 0, tsock = node->inputs.first; tsock; tsock = tsock->next, index++) { - if (tsock == sock) { - if (in_out) *in_out = SOCK_IN; + tsock = (in_out == SOCK_IN ? node->inputs.first : node->outputs.first); + for (index = 0; tsock; tsock = tsock->next, index++) { + if (tsock == sock) break; - } - } - if (tsock) - break; - for (index = 0, tsock = node->outputs.first; tsock; tsock = tsock->next, index++) { - if (tsock == sock) { - if (in_out) *in_out = SOCK_OUT; - break; - } } if (tsock) break; @@ -271,28 +768,6 @@ int nodeFindNode(bNodeTree *ntree, bNodeSocket *sock, bNode **nodep, int *sockin } /* ************** Add stuff ********** */ -static void node_add_sockets_from_type(bNodeTree *ntree, bNode *node, bNodeType *ntype) -{ - bNodeSocketTemplate *sockdef; - /* bNodeSocket *sock; */ /* UNUSED */ - - if (ntype->inputs) { - sockdef = ntype->inputs; - while (sockdef->type != -1) { - /* sock = */ node_add_input_from_template(ntree, node, sockdef); - - sockdef++; - } - } - if (ntype->outputs) { - sockdef = ntype->outputs; - while (sockdef->type != -1) { - /* sock = */ node_add_output_from_template(ntree, node, sockdef); - - sockdef++; - } - } -} /* Find the first available, non-duplicate name for a given node */ void nodeUniqueName(bNodeTree *ntree, bNode *node) @@ -300,51 +775,55 @@ void nodeUniqueName(bNodeTree *ntree, bNode *node) BLI_uniquename(&ntree->nodes, node, "Node", '.', offsetof(bNode, name), sizeof(node->name)); } -bNode *nodeAddNode(bNodeTree *ntree, struct bNodeTemplate *ntemp) +bNode *nodeAddNode(const struct bContext *C, bNodeTree *ntree, const char *idname) { bNode *node; - bNodeType *ntype; - - ntype = node_get_type(ntree, ntemp->type); - if (ntype == NULL) { - printf("nodeAddNodeType() error: '%d' type invalid\n", ntemp->type); - return NULL; - } - /* validity check */ - if (!nodeValid(ntree, ntemp)) - return NULL; node = MEM_callocN(sizeof(bNode), "new node"); - node->type = ntype->type; - node->typeinfo = ntype; - node->flag = NODE_SELECT | ntype->flag; - node->width = ntype->width; - node->miniwidth = 42.0f; - node->height = ntype->height; - node->color[0] = node->color[1] = node->color[2] = 0.608; /* default theme color */ - - node_add_sockets_from_type(ntree, node, ntype); - BLI_addtail(&ntree->nodes, node); - if (ntype->initfunc != NULL) - ntype->initfunc(ntree, node, ntemp); - - /* initialize the node name with the node label. - * note: do this after the initfunc so nodes get their data set which may be used in naming - * (node groups for example) */ - /* XXX Do not use nodeLabel() here, it returns translated content, which should *only* be used - * in UI, *never* in data... - * This solution may be a bit rougher than nodeLabel()'s returned string, but it's simpler - * than adding a "no translate" flag to this func (and labelfunc() as well). */ - BLI_strncpy(node->name, node->typeinfo->name, NODE_MAXSTR); - nodeUniqueName(ntree, node); + BLI_strncpy(node->idname, idname, sizeof(node->idname)); + node_set_typeinfo(C, ntree, node, nodeTypeFind(idname)); ntree->update |= NTREE_UPDATE_NODES; return node; } +bNode *nodeAddStaticNode(const struct bContext *C, bNodeTree *ntree, int type) +{ + const char *idname=NULL; + + NODE_TYPES_BEGIN(ntype) + if(ntype->type==type) { + idname = ntype->idname; + break; + } + NODE_TYPES_END + if (!idname) { + printf("Error: static node type %d undefined\n", type); + return NULL; + } + return nodeAddNode(C, ntree, idname); +} + +static void node_socket_copy(bNodeSocket *dst, bNodeSocket *src) +{ + src->new_sock = dst; + + if (src->prop) + dst->prop = IDP_CopyProperty(src->prop); + + if (src->default_value) + dst->default_value = MEM_dupallocN(src->default_value); + + dst->stack_index = 0; + /* XXX some compositor node (e.g. image, render layers) still store + * some persistent buffer data here, need to clear this to avoid dangling pointers. + */ + dst->cache = NULL; +} + /* keep socket listorder identical, for copying links */ /* ntree is the target tree */ bNode *nodeCopyNode(struct bNodeTree *ntree, struct bNode *node) @@ -363,33 +842,16 @@ bNode *nodeCopyNode(struct bNodeTree *ntree, struct bNode *node) BLI_duplicatelist(&nnode->inputs, &node->inputs); oldsock = node->inputs.first; - for (sock = nnode->inputs.first; sock; sock = sock->next, oldsock = oldsock->next) { - oldsock->new_sock = sock; - sock->stack_index = 0; - - sock->default_value = node_socket_make_default_value(oldsock->type); - node_socket_copy_default_value(oldsock->type, sock->default_value, oldsock->default_value); - - /* XXX some compositor node (e.g. image, render layers) still store - * some persistent buffer data here, need to clear this to avoid dangling pointers. - */ - sock->cache = NULL; - } + for (sock = nnode->inputs.first; sock; sock = sock->next, oldsock = oldsock->next) + node_socket_copy(sock, oldsock); BLI_duplicatelist(&nnode->outputs, &node->outputs); oldsock = node->outputs.first; - for (sock = nnode->outputs.first; sock; sock = sock->next, oldsock = oldsock->next) { - oldsock->new_sock = sock; - sock->stack_index = 0; - - sock->default_value = node_socket_make_default_value(oldsock->type); - node_socket_copy_default_value(oldsock->type, sock->default_value, oldsock->default_value); - - /* XXX some compositor node (e.g. image, render layers) still store - * some persistent buffer data here, need to clear this to avoid dangling pointers. - */ - sock->cache = NULL; - } + for (sock = nnode->outputs.first; sock; sock = sock->next, oldsock = oldsock->next) + node_socket_copy(sock, oldsock); + + if (node->prop) + nnode->prop = IDP_CopyProperty(node->prop); BLI_duplicatelist(&nnode->internal_links, &node->internal_links); oldlink = node->internal_links.first; @@ -402,22 +864,17 @@ bNode *nodeCopyNode(struct bNodeTree *ntree, struct bNode *node) /* don't increase node->id users, freenode doesn't decrement either */ - if (node->typeinfo->copystoragefunc) - node->typeinfo->copystoragefunc(node, nnode); + if (node->typeinfo->copyfunc) + node->typeinfo->copyfunc(ntree, nnode, node); node->new_node = nnode; nnode->new_node = NULL; - /* only shader nodes get pleasant preview updating this way, compo uses own system */ - if (node->preview) { - if (ntree && (ntree->type == NTREE_SHADER)) { - nnode->preview = MEM_dupallocN(node->preview); - if (node->preview->rect) - nnode->preview->rect = MEM_dupallocN(node->preview->rect); - } - else { - nnode->preview = NULL; - } + if (nnode->typeinfo->copyfunc_api) { + PointerRNA ptr; + RNA_pointer_create((ID *)ntree, &RNA_Node, nnode, &ptr); + + nnode->typeinfo->copyfunc_api(&ptr, node); } if (ntree) @@ -429,71 +886,13 @@ bNode *nodeCopyNode(struct bNodeTree *ntree, struct bNode *node) /* also used via rna api, so we check for proper input output direction */ bNodeLink *nodeAddLink(bNodeTree *ntree, bNode *fromnode, bNodeSocket *fromsock, bNode *tonode, bNodeSocket *tosock) { - bNodeSocket *sock; bNodeLink *link = NULL; - int from = 0, to = 0; - if (fromnode) { - /* test valid input */ - for (sock = fromnode->outputs.first; sock; sock = sock->next) - if (sock == fromsock) - break; - if (sock) - from = 1; /* OK */ - else { - for (sock = fromnode->inputs.first; sock; sock = sock->next) - if (sock == fromsock) - break; - if (sock) - from = -1; /* OK but flip */ - } - } - else if (ntree) { - /* check tree sockets */ - for (sock = ntree->inputs.first; sock; sock = sock->next) - if (sock == fromsock) - break; - if (sock) - from = 1; /* OK */ - else { - for (sock = ntree->outputs.first; sock; sock = sock->next) - if (sock == fromsock) - break; - if (sock) - from = -1; /* OK but flip */ - } - } - if (tonode) { - for (sock = tonode->inputs.first; sock; sock = sock->next) - if (sock == tosock) - break; - if (sock) - to = 1; /* OK */ - else { - for (sock = tonode->outputs.first; sock; sock = sock->next) - if (sock == tosock) - break; - if (sock) - to = -1; /* OK but flip */ - } - } - else if (ntree) { - /* check tree sockets */ - for (sock = ntree->outputs.first; sock; sock = sock->next) - if (sock == tosock) - break; - if (sock) - to = 1; /* OK */ - else { - for (sock = ntree->inputs.first; sock; sock = sock->next) - if (sock == tosock) - break; - if (sock) - to = -1; /* OK but flip */ - } - } + /* test valid input */ + BLI_assert(fromnode); + BLI_assert(tonode); - if (from >= 0 && to >= 0) { + if (fromsock->in_out == SOCK_OUT && tosock->in_out == SOCK_IN) { link = MEM_callocN(sizeof(bNodeLink), "link"); if (ntree) BLI_addtail(&ntree->links, link); @@ -502,7 +901,8 @@ bNodeLink *nodeAddLink(bNodeTree *ntree, bNode *fromnode, bNodeSocket *fromsock, link->tonode = tonode; link->tosock = tosock; } - else if (from <= 0 && to <= 0) { + else if (fromsock->in_out == SOCK_IN && tosock->in_out == SOCK_OUT) { + /* OK but flip */ link = MEM_callocN(sizeof(bNodeLink), "link"); if (ntree) BLI_addtail(&ntree->links, link); @@ -546,6 +946,11 @@ void nodeRemSocketLinks(bNodeTree *ntree, bNodeSocket *sock) ntree->update |= NTREE_UPDATE_LINKS; } +int nodeLinkIsHidden(bNodeLink *link) +{ + return nodeSocketIsHidden(link->fromsock) || nodeSocketIsHidden(link->tosock); +} + void nodeInternalRelink(bNodeTree *ntree, bNode *node) { bNodeLink *link, *link_next; @@ -662,30 +1067,29 @@ void nodeDetachNode(struct bNode *node) } } -bNodeTree *ntreeAddTree(Main *bmain, const char *name, int type, int nodetype) +bNodeTree *ntreeAddTree(Main *bmain, const char *name, const char *idname) { bNodeTree *ntree; - bNodeType *ntype; - /* trees are created as local trees if they of compositor, material or texture type, + /* trees are created as local trees for compositor, material or texture nodes, * node groups and other tree types are created as library data. */ - if (ELEM3(type, NTREE_COMPOSIT, NTREE_SHADER, NTREE_TEXTURE) && nodetype == 0) { + if (bmain) { + ntree= BKE_libblock_alloc(&bmain->nodetree, ID_NT, name); + } + else { ntree = MEM_callocN(sizeof(bNodeTree), "new node tree"); - *( (short *)ntree->id.name) = ID_NT; /* not "type", as that is ntree->type */ + *( (short *)ntree->id.name ) = ID_NT; BLI_strncpy(ntree->id.name + 2, name, sizeof(ntree->id.name)); } - else - ntree = BKE_libblock_alloc(&bmain->nodetree, ID_NT, name); - ntree->type = type; - ntree->nodetype = nodetype; - - ntreeInitTypes(ntree); + /* Types are fully initialized at this point, + * if an undefined node is added later this will be reset. + */ + ntree->init |= NTREE_TYPE_INIT; - ntype = node_get_type(ntree, ntree->nodetype); - if (ntype && ntype->inittreefunc) - ntype->inittreefunc(ntree); + BLI_strncpy(ntree->idname, idname, sizeof(ntree->idname)); + ntree_set_typeinfo(ntree, ntreeTypeFind(idname)); return ntree; } @@ -699,12 +1103,12 @@ bNodeTree *ntreeAddTree(Main *bmain, const char *name, int type, int nodetype) * copying for internal use (threads for eg), where you wont want it to modify the * scene data. */ -static bNodeTree *ntreeCopyTree_internal(bNodeTree *ntree, const short do_id_user, const short do_make_extern) +static bNodeTree *ntreeCopyTree_internal(bNodeTree *ntree, const short do_id_user, const short do_make_extern, const short copy_previews) { bNodeTree *newtree; bNode *node /*, *nnode */ /* UNUSED */, *last; + bNodeSocket *sock, *oldsock; bNodeLink *link; - bNodeSocket *gsock, *oldgsock; if (ntree == NULL) return NULL; @@ -747,22 +1151,6 @@ static bNodeTree *ntreeCopyTree_internal(bNodeTree *ntree, const short do_id_use break; } - /* socket definition for group usage */ - BLI_duplicatelist(&newtree->inputs, &ntree->inputs); - for (gsock = newtree->inputs.first, oldgsock = ntree->inputs.first; gsock; gsock = gsock->next, oldgsock = oldgsock->next) { - oldgsock->new_sock = gsock; - gsock->groupsock = (oldgsock->groupsock ? oldgsock->groupsock->new_sock : NULL); - gsock->default_value = node_socket_make_default_value(oldgsock->type); - node_socket_copy_default_value(oldgsock->type, gsock->default_value, oldgsock->default_value); - } - BLI_duplicatelist(&newtree->outputs, &ntree->outputs); - for (gsock = newtree->outputs.first, oldgsock = ntree->outputs.first; gsock; gsock = gsock->next, oldgsock = oldgsock->next) { - oldgsock->new_sock = gsock; - gsock->groupsock = (oldgsock->groupsock ? oldgsock->groupsock->new_sock : NULL); - gsock->default_value = node_socket_make_default_value(oldgsock->type); - node_socket_copy_default_value(oldgsock->type, gsock->default_value, oldgsock->default_value); - } - /* copy links */ BLI_duplicatelist(&newtree->links, &ntree->links); for (link = newtree->links.first; link; link = link->next) { @@ -775,18 +1163,47 @@ static bNodeTree *ntreeCopyTree_internal(bNodeTree *ntree, const short do_id_use link->tosock->link = link; } + /* copy interface sockets */ + BLI_duplicatelist(&newtree->inputs, &ntree->inputs); + oldsock = ntree->inputs.first; + for (sock = newtree->inputs.first; sock; sock = sock->next, oldsock = oldsock->next) + node_socket_copy(sock, oldsock); + + BLI_duplicatelist(&newtree->outputs, &ntree->outputs); + oldsock = ntree->outputs.first; + for (sock = newtree->outputs.first; sock; sock = sock->next, oldsock = oldsock->next) + node_socket_copy(sock, oldsock); + + /* copy preview hash */ + if (ntree->previews && copy_previews) { + bNodeInstanceHashIterator iter; + + newtree->previews = BKE_node_instance_hash_new("node previews"); + + NODE_INSTANCE_HASH_ITER(iter, ntree->previews) { + bNodeInstanceKey key = BKE_node_instance_hash_iterator_get_key(&iter); + bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter); + BKE_node_instance_hash_insert(newtree->previews, key, BKE_node_preview_copy(preview)); + } + } + else + newtree->previews = NULL; + /* update node->parent pointers */ for (node = newtree->nodes.first; node; node = node->next) { if (node->parent) node->parent = node->parent->new_node; } + /* node tree will generate its own interface type */ + ntree->interface_type = NULL; + return newtree; } bNodeTree *ntreeCopyTree_ex(bNodeTree *ntree, const short do_id_user) { - return ntreeCopyTree_internal(ntree, do_id_user, TRUE); + return ntreeCopyTree_internal(ntree, do_id_user, TRUE, TRUE); } bNodeTree *ntreeCopyTree(bNodeTree *ntree) { @@ -835,62 +1252,225 @@ void ntreeUserDecrefID(bNodeTree *ntree) } } -/* *************** preview *********** */ -/* if node->preview, then we assume the rect to exist */ +/* *************** Node Preview *********** */ -void nodeFreePreview(bNode *node) +/* XXX this should be removed eventually ... + * Currently BKE functions are modelled closely on previous code, + * using BKE_node_preview_init_tree to set up previews for a whole node tree in advance. + * This should be left more to the individual node tree implementations. + */ +int BKE_node_preview_used(bNode *node) { - if (node->preview) { - if (node->preview->rect) - MEM_freeN(node->preview->rect); - MEM_freeN(node->preview); - node->preview = NULL; - } + /* XXX check for closed nodes? */ + return (node->typeinfo->flag & NODE_PREVIEW) != 0; } -static void node_init_preview(bNode *node, int xsize, int ysize) +bNodePreview *BKE_node_preview_verify(bNodeInstanceHash *previews, bNodeInstanceKey key, int xsize, int ysize, int create) { + bNodePreview *preview; - if (node->preview == NULL) { - node->preview = MEM_callocN(sizeof(bNodePreview), "node preview"); - // printf("added preview %s\n", node->name); + preview = BKE_node_instance_hash_lookup(previews, key); + if (!preview) { + if (create) { + preview = MEM_callocN(sizeof(bNodePreview), "node preview"); + BKE_node_instance_hash_insert(previews, key, preview); + } + else + return NULL; } /* node previews can get added with variable size this way */ if (xsize == 0 || ysize == 0) - return; + return preview; /* sanity checks & initialize */ - if (node->preview->rect) { - if (node->preview->xsize != xsize && node->preview->ysize != ysize) { - MEM_freeN(node->preview->rect); - node->preview->rect = NULL; + if (preview->rect) { + if (preview->xsize != xsize || preview->ysize != ysize) { + MEM_freeN(preview->rect); + preview->rect = NULL; } } - if (node->preview->rect == NULL) { - node->preview->rect = MEM_callocN(4 * xsize + xsize * ysize * sizeof(char) * 4, "node preview rect"); - node->preview->xsize = xsize; - node->preview->ysize = ysize; + if (preview->rect == NULL) { + preview->rect = MEM_callocN(4 * xsize + xsize * ysize * sizeof(char) * 4, "node preview rect"); + preview->xsize = xsize; + preview->ysize = ysize; } /* no clear, makes nicer previews */ + + return preview; } -void ntreeInitPreview(bNodeTree *ntree, int xsize, int ysize) +bNodePreview *BKE_node_preview_copy(bNodePreview *preview) +{ + bNodePreview *new_preview = MEM_dupallocN(preview); + if (preview->rect) + new_preview->rect = MEM_dupallocN(preview->rect); + return new_preview; +} + +void BKE_node_preview_free(bNodePreview *preview) +{ + if (preview->rect) + MEM_freeN(preview->rect); + MEM_freeN(preview); +} + +static void node_preview_init_tree_recursive(bNodeInstanceHash *previews, bNodeTree *ntree, bNodeInstanceKey parent_key, int xsize, int ysize, int create) { bNode *node; - - if (ntree == NULL) + for (node = ntree->nodes.first; node; node = node->next) { + bNodeInstanceKey key = BKE_node_instance_key(parent_key, ntree, node); + + if (BKE_node_preview_used(node)) { + node->preview_xsize = xsize; + node->preview_ysize = ysize; + + BKE_node_preview_verify(previews, key, xsize, ysize, create); + } + + if (node->type == NODE_GROUP) + node_preview_init_tree_recursive(previews, (bNodeTree *)node->id, key, xsize, ysize, create); + } +} + +void BKE_node_preview_init_tree(bNodeTree *ntree, int xsize, int ysize, int create_previews) +{ + if (!ntree) return; + if (!ntree->previews) + ntree->previews = BKE_node_instance_hash_new("node previews"); + + node_preview_init_tree_recursive(ntree->previews, ntree, NODE_INSTANCE_KEY_BASE, xsize, ysize, create_previews); +} + +static void node_preview_tag_used_recursive(bNodeInstanceHash *previews, bNodeTree *ntree, bNodeInstanceKey parent_key) +{ + bNode *node; for (node = ntree->nodes.first; node; node = node->next) { - if (node->typeinfo->flag & NODE_PREVIEW) /* hrms, check for closed nodes? */ - node_init_preview(node, xsize, ysize); - if (node->type == NODE_GROUP && (node->flag & NODE_GROUP_EDIT)) - ntreeInitPreview((bNodeTree *)node->id, xsize, ysize); + bNodeInstanceKey key = BKE_node_instance_key(parent_key, ntree, node); + + if (BKE_node_preview_used(node)) + BKE_node_instance_hash_tag_key(previews, key); + + if (node->type == NODE_GROUP) + node_preview_tag_used_recursive(previews, (bNodeTree *)node->id, key); + } +} + +void BKE_node_preview_remove_unused(bNodeTree *ntree) +{ + if (!ntree || !ntree->previews) + return; + + /* use the instance hash functions for tagging and removing unused previews */ + BKE_node_instance_hash_clear_tags(ntree->previews); + node_preview_tag_used_recursive(ntree->previews, ntree, NODE_INSTANCE_KEY_BASE); + + BKE_node_instance_hash_remove_untagged(ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free); +} + +void BKE_node_preview_free_tree(bNodeTree *ntree) +{ + if (!ntree) + return; + + if (ntree->previews) { + BKE_node_instance_hash_free(ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free); + ntree->previews = NULL; + } +} + +void BKE_node_preview_clear(bNodePreview *preview) +{ + if (preview && preview->rect) + memset(preview->rect, 0, MEM_allocN_len(preview->rect)); +} + +void BKE_node_preview_clear_tree(bNodeTree *ntree) +{ + bNodeInstanceHashIterator iter; + + if (!ntree || !ntree->previews) + return; + + NODE_INSTANCE_HASH_ITER(iter, ntree->previews) { + bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter); + BKE_node_preview_clear(preview); + } +} + +static void node_preview_sync(bNodePreview *to, bNodePreview *from) +{ + /* sizes should have been initialized by BKE_node_preview_init_tree */ + BLI_assert(to->xsize == from->xsize && to->ysize == from->ysize); + + /* copy over contents of previews */ + if (to->rect && from->rect) { + int xsize = to->xsize; + int ysize = to->ysize; + memcpy(to->rect, from->rect, 4 * xsize + xsize * ysize * sizeof(char) * 4); } } +void BKE_node_preview_sync_tree(bNodeTree *to_ntree, bNodeTree *from_ntree) +{ + bNodeInstanceHash *from_previews = from_ntree->previews; + bNodeInstanceHash *to_previews = to_ntree->previews; + bNodeInstanceHashIterator iter; + + if (!from_previews || !to_previews) + return; + + NODE_INSTANCE_HASH_ITER(iter, from_previews) { + bNodeInstanceKey key = BKE_node_instance_hash_iterator_get_key(&iter); + bNodePreview *from = BKE_node_instance_hash_iterator_get_value(&iter); + bNodePreview *to = BKE_node_instance_hash_lookup(to_previews, key); + + if (from && to) + node_preview_sync(to, from); + } +} + +void BKE_node_preview_merge_tree(bNodeTree *to_ntree, bNodeTree *from_ntree) +{ + /* free old previews */ + if (to_ntree->previews) + BKE_node_instance_hash_free(to_ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free); + + /* transfer previews */ + to_ntree->previews = from_ntree->previews; + from_ntree->previews = NULL; + + /* clean up, in case any to_ntree nodes have been removed */ + BKE_node_preview_remove_unused(to_ntree); +} + +/* hack warning! this function is only used for shader previews, and + * since it gets called multiple times per pixel for Ztransp we only + * add the color once. Preview gets cleared before it starts render though */ +void BKE_node_preview_set_pixel(bNodePreview *preview, const float col[4], int x, int y, int do_manage) +{ + if (preview) { + if (x >= 0 && y >= 0) { + if (x < preview->xsize && y < preview->ysize) { + unsigned char *tar = preview->rect + 4 * ((preview->xsize * y) + x); + + if (do_manage) { + linearrgb_to_srgb_uchar4(tar, col); + } + else { + rgba_float_to_uchar(tar, col); + } + } + //else printf("prv out bound x y %d %d\n", x, y); + } + //else printf("prv out bound x y %d %d\n", x, y); + } +} + +#if 0 static void nodeClearPreview(bNode *node) { if (node->preview && node->preview->rect) @@ -908,7 +1488,7 @@ void ntreeClearPreview(bNodeTree *ntree) for (node = ntree->nodes.first; node; node = node->next) { if (node->typeinfo->flag & NODE_PREVIEW) nodeClearPreview(node); - if (node->type == NODE_GROUP && (node->flag & NODE_GROUP_EDIT)) + if (node->type == NODE_GROUP) ntreeClearPreview((bNodeTree *)node->id); } } @@ -936,6 +1516,7 @@ void nodeAddToPreview(bNode *node, const float col[4], int x, int y, int do_mana //else printf("prv out bound x y %d %d\n", x, y); } } +#endif /* ************** Free stuff ********** */ @@ -985,45 +1566,54 @@ void nodeFreeNode(bNodeTree *ntree, bNode *node) { bNodeSocket *sock, *nextsock; + /* extra free callback */ + if (node->typeinfo && node->typeinfo->freefunc_api) { + PointerRNA ptr; + RNA_pointer_create((ID *)ntree, &RNA_Node, node, &ptr); + + node->typeinfo->freefunc_api(&ptr); + } + + /* since it is called while free database, node->id is undefined */ + /* can be called for nodes outside a node tree (e.g. clipboard) */ if (ntree) { - bNodeTreeType *treetype = ntreeGetType(ntree->type); - /* remove all references to this node */ nodeUnlinkNode(ntree, node); node_unlink_attached(ntree, node); - + BLI_remlink(&ntree->nodes, node); - - if (treetype->free_node_cache) - treetype->free_node_cache(ntree, node); + + if (ntree->typeinfo && ntree->typeinfo->free_node_cache) + ntree->typeinfo->free_node_cache(ntree, node); /* texture node has bad habit of keeping exec data around */ if (ntree->type == NTREE_TEXTURE && ntree->execdata) { - ntreeTexEndExecTree(ntree->execdata, 1); + ntreeTexEndExecTree(ntree->execdata); ntree->execdata = NULL; } + + if(node->typeinfo && node->typeinfo->freefunc) + node->typeinfo->freefunc(node); } - /* since it is called while free database, node->id is undefined */ - - if (node->typeinfo && node->typeinfo->freestoragefunc) - node->typeinfo->freestoragefunc(node); - for (sock = node->inputs.first; sock; sock = nextsock) { nextsock = sock->next; - node_socket_free_default_value(sock->type, sock->default_value); + node_socket_free(ntree, sock, node); MEM_freeN(sock); } for (sock = node->outputs.first; sock; sock = nextsock) { nextsock = sock->next; - node_socket_free_default_value(sock->type, sock->default_value); + node_socket_free(ntree, sock, node); MEM_freeN(sock); } BLI_freelistN(&node->internal_links); - nodeFreePreview(node); + if (node->prop) { + IDP_FreeProperty(node->prop); + MEM_freeN(node->prop); + } MEM_freeN(node); @@ -1031,12 +1621,24 @@ void nodeFreeNode(bNodeTree *ntree, bNode *node) ntree->update |= NTREE_UPDATE_NODES; } +static void node_socket_interface_free(bNodeTree *UNUSED(ntree), bNodeSocket *sock) +{ + if (sock->prop) { + IDP_FreeProperty(sock->prop); + MEM_freeN(sock->prop); + } + + /* can be left over from old files */ + if (sock->default_value) + MEM_freeN(sock->default_value); +} + /* do not free ntree itself here, BKE_libblock_free calls this function too */ void ntreeFreeTree_ex(bNodeTree *ntree, const short do_id_user) { bNodeTree *tntree; bNode *node, *next; - bNodeSocket *sock; + bNodeSocket *sock, *nextsock; if (ntree == NULL) return; @@ -1048,15 +1650,18 @@ void ntreeFreeTree_ex(bNodeTree *ntree, const short do_id_user) if (ntree->execdata) { switch (ntree->type) { case NTREE_SHADER: - ntreeShaderEndExecTree(ntree->execdata, 1); + ntreeShaderEndExecTree(ntree->execdata); break; case NTREE_TEXTURE: - ntreeTexEndExecTree(ntree->execdata, 1); + ntreeTexEndExecTree(ntree->execdata); ntree->execdata = NULL; break; } } + /* unregister associated RNA types */ + ntreeInterfaceTypeFree(ntree); + BKE_free_animdata((ID *)ntree); id_us_min((ID *)ntree->gpd); @@ -1082,13 +1687,23 @@ void ntreeFreeTree_ex(bNodeTree *ntree, const short do_id_user) nodeFreeNode(ntree, node); } + + /* free interface sockets */ + for (sock = ntree->inputs.first; sock; sock = nextsock) { + nextsock = sock->next; + node_socket_interface_free(ntree, sock); + MEM_freeN(sock); + } + for (sock = ntree->outputs.first; sock; sock = nextsock) { + nextsock = sock->next; + node_socket_interface_free(ntree, sock); + MEM_freeN(sock); + } - for (sock = ntree->inputs.first; sock; sock = sock->next) - node_socket_free_default_value(sock->type, sock->default_value); - BLI_freelistN(&ntree->inputs); - for (sock = ntree->outputs.first; sock; sock = sock->next) - node_socket_free_default_value(sock->type, sock->default_value); - BLI_freelistN(&ntree->outputs); + /* free preview hash */ + if (ntree->previews) { + BKE_node_instance_hash_free(ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free); + } /* if ntree is not part of library, free the libblock data explicitly */ for (tntree = G.main->nodetree.first; tntree; tntree = tntree->id.next) @@ -1106,13 +1721,10 @@ void ntreeFreeTree(bNodeTree *ntree) void ntreeFreeCache(bNodeTree *ntree) { - bNodeTreeType *treetype; - if (ntree == NULL) return; - treetype = ntreeGetType(ntree->type); - if (treetype->free_cache) - treetype->free_cache(ntree); + if (ntree->typeinfo->free_cache) + ntree->typeinfo->free_cache(ntree); } void ntreeSetOutput(bNodeTree *ntree) @@ -1162,6 +1774,24 @@ void ntreeSetOutput(bNodeTree *ntree) if (output == 0) node->flag |= NODE_DO_OUTPUT; } + + /* group node outputs use this flag too */ + if (node->type == NODE_GROUP_OUTPUT) { + bNode *tnode; + int output = 0; + + for (tnode = ntree->nodes.first; tnode; tnode = tnode->next) { + if (tnode->type == NODE_GROUP_OUTPUT) { + if (tnode->flag & NODE_DO_OUTPUT) { + output++; + if (output > 1) + tnode->flag &= ~NODE_DO_OUTPUT; + } + } + } + if (output == 0) + node->flag |= NODE_DO_OUTPUT; + } } /* here we could recursively set which nodes have to be done, @@ -1180,52 +1810,10 @@ bNodeTree *ntreeFromID(ID *id) } } -typedef struct MakeLocalCallData { - ID *group_id; - ID *new_id; - int lib, local; -} MakeLocalCallData; - -static void ntreeMakeLocal_CheckLocal(void *calldata, ID *owner_id, bNodeTree *ntree) -{ - MakeLocalCallData *cd = (MakeLocalCallData *)calldata; - bNode *node; - - /* find if group is in tree */ - for (node = ntree->nodes.first; node; node = node->next) { - if (node->id == cd->group_id) { - if (owner_id->lib) { - cd->lib = TRUE; - } - else { - cd->local = TRUE; - } - } - } -} - -static void ntreeMakeLocal_LinkNew(void *calldata, ID *owner_id, bNodeTree *ntree) -{ - MakeLocalCallData *cd = (MakeLocalCallData *)calldata; - bNode *node; - - /* find if group is in tree */ - for (node = ntree->nodes.first; node; node = node->next) { - if (node->id == cd->group_id) { - if (owner_id->lib == NULL) { - node->id = cd->new_id; - cd->new_id->us++; - cd->group_id->us--; - } - } - } -} - void ntreeMakeLocal(bNodeTree *ntree) { Main *bmain = G.main; - bNodeTreeType *treetype = ntreeGetType(ntree->type); - MakeLocalCallData cd; + int lib = FALSE, local = FALSE; /* - only lib users: do nothing * - only local users: set flag @@ -1239,26 +1827,42 @@ void ntreeMakeLocal(bNodeTree *ntree) } /* now check users of groups... again typedepending, callback... */ - cd.group_id = &ntree->id; - cd.new_id = NULL; - cd.local = 0; - cd.lib = 0; - - treetype->foreach_nodetree(G.main, &cd, &ntreeMakeLocal_CheckLocal); + FOREACH_NODETREE(G.main, tntree, owner_id) { + bNode *node; + /* find if group is in tree */ + for (node = tntree->nodes.first; node; node = node->next) { + if (node->id == (ID *)ntree) { + if (owner_id->lib) + lib = TRUE; + else + local = TRUE; + } + } + } FOREACH_NODETREE_END /* if all users are local, we simply make tree local */ - if (cd.local && cd.lib == 0) { + if (local && !lib) { id_clear_lib_data(bmain, (ID *)ntree); } - else if (cd.local && cd.lib) { + else if (local && lib) { /* this is the mixed case, we copy the tree and assign it to local users */ bNodeTree *newtree = ntreeCopyTree(ntree); newtree->id.us = 0; - - cd.new_id = &newtree->id; - treetype->foreach_nodetree(G.main, &cd, &ntreeMakeLocal_LinkNew); + FOREACH_NODETREE(G.main, tntree, owner_id) { + bNode *node; + /* find if group is in tree */ + for (node = tntree->nodes.first; node; node = node->next) { + if (node->id == (ID *)ntree) { + if (owner_id->lib == NULL) { + node->id = (ID *)newtree; + newtree->id.us++; + ntree->id.us--; + } + } + } + } FOREACH_NODETREE_END } } @@ -1283,90 +1887,326 @@ int ntreeOutputExists(bNode *node, bNodeSocket *testsock) /* returns localized tree for execution in threads */ bNodeTree *ntreeLocalize(bNodeTree *ntree) { - bNodeTreeType *ntreetype = ntreeGetType(ntree->type); - - bNodeTree *ltree; - bNode *node; + if (ntreeIsValid(ntree)) { + bNodeTree *ltree; + bNode *node; + + bAction *action_backup = NULL, *tmpact_backup = NULL; + + /* Workaround for copying an action on each render! + * set action to NULL so animdata actions don't get copied */ + AnimData *adt = BKE_animdata_from_id(&ntree->id); + + if (adt) { + action_backup = adt->action; + tmpact_backup = adt->tmpact; + + adt->action = NULL; + adt->tmpact = NULL; + } - bAction *action_backup = NULL, *tmpact_backup = NULL; + /* Make full copy. + * Note: previews are not copied here. + */ + ltree = ntreeCopyTree_internal(ntree, FALSE, FALSE, FALSE); + + if (adt) { + AnimData *ladt = BKE_animdata_from_id(<ree->id); + + adt->action = ladt->action = action_backup; + adt->tmpact = ladt->tmpact = tmpact_backup; + + if (action_backup) action_backup->id.us++; + if (tmpact_backup) tmpact_backup->id.us++; + + } + /* end animdata uglyness */ - /* Workaround for copying an action on each render! - * set action to NULL so animdata actions don't get copied */ - AnimData *adt = BKE_animdata_from_id(&ntree->id); + /* ensures only a single output node is enabled */ + ntreeSetOutput(ntree); + + for (node = ntree->nodes.first; node; node = node->next) { + /* store new_node pointer to original */ + node->new_node->new_node = node; + } + + if (ntree->typeinfo->localize) + ntree->typeinfo->localize(ltree, ntree); + + return ltree; + } + else + return NULL; +} - if (adt) { - action_backup = adt->action; - tmpact_backup = adt->tmpact; +/* sync local composite with real tree */ +/* local tree is supposed to be running, be careful moving previews! */ +/* is called by jobs manager, outside threads, so it doesnt happen during draw */ +void ntreeLocalSync(bNodeTree *localtree, bNodeTree *ntree) +{ + if (localtree && ntreeIsValid(ntree)) { + /* XXX syncing was disabled for compositor nodes. + * It has to be ensured that there is no concurrent read/write access! + * Possibly needs a mutex lock or a flag to disable for certain tree types ... + */ + BKE_node_preview_sync_tree(ntree, localtree); + + if (ntree->typeinfo->local_sync) + ntree->typeinfo->local_sync(localtree, ntree); + } +} - adt->action = NULL; - adt->tmpact = NULL; +/* merge local tree results back, and free local tree */ +/* we have to assume the editor already changed completely */ +void ntreeLocalMerge(bNodeTree *localtree, bNodeTree *ntree) +{ + if (localtree && ntreeIsValid(ntree)) { + BKE_node_preview_merge_tree(ntree, localtree); + + if (ntree->typeinfo->local_merge) + ntree->typeinfo->local_merge(localtree, ntree); + + ntreeFreeTree_ex(localtree, FALSE); + MEM_freeN(localtree); } +} - /* node copy func */ - ltree = ntreeCopyTree_internal(ntree, FALSE, FALSE); - if (adt) { - AnimData *ladt = BKE_animdata_from_id(<ree->id); +/* ************ NODE TREE INTERFACE *************** */ - adt->action = ladt->action = action_backup; - adt->tmpact = ladt->tmpact = tmpact_backup; +static bNodeSocket *make_socket_template(bNodeTree *ntree, int in_out, + const char *idname, const char *name) +{ + bNodeSocketType *stype = nodeSocketTypeFind(idname); + bNodeSocket *sock; + int own_index = ntree->cur_index++; + + if (stype == NULL) { + printf("Error: node socket type '%s' undefined\n", idname); + return NULL; + } + + sock = MEM_callocN(sizeof(bNodeSocket), "socket template"); + sock->typeinfo= stype; + BLI_strncpy(sock->idname, stype->idname, sizeof(sock->idname)); + sock->in_out = in_out; + sock->type = SOCK_CUSTOM; /* int type undefined by default */ + + /* assign new unique index */ + own_index = ntree->cur_index++; + /* use the own_index as socket identifier */ + if (in_out == SOCK_IN) + BLI_snprintf(sock->identifier, MAX_NAME, "Input_%d", own_index); + else + BLI_snprintf(sock->identifier, MAX_NAME, "Output_%d", own_index); +#ifdef USE_NODE_COMPAT_CUSTOMNODES + /* XXX forward compatibility: + * own_index is deprecated, but needs to be set here. + * Node sockets generally use the identifier string instead now, + * but reconstructing own_index in writefile.c would require parsing the identifier string. + */ + sock->own_index = own_index; +#endif + + sock->limit = (in_out == SOCK_IN ? 1 : 0xFFF); + + BLI_strncpy(sock->name, name, NODE_MAXSTR); + sock->storage = NULL; + sock->flag |= SOCK_COLLAPSED; + + return sock; +} - if (action_backup) action_backup->id.us++; - if (tmpact_backup) tmpact_backup->id.us++; - +bNodeSocket *ntreeFindSocketInterface(bNodeTree *ntree, int in_out, const char *identifier) +{ + bNodeSocket *iosock = (in_out == SOCK_IN ? ntree->inputs.first : ntree->outputs.first); + for (; iosock; iosock = iosock->next) + if (strcmp(iosock->identifier, identifier)==0) + return iosock; + return NULL; +} + +bNodeSocket *ntreeAddSocketInterface(bNodeTree *ntree, int in_out, const char *idname, const char *name) +{ + bNodeSocket *iosock; + + iosock = make_socket_template(ntree, in_out, idname, name); + if (in_out == SOCK_IN) { + BLI_addtail(&ntree->inputs, iosock); + ntree->update |= NTREE_UPDATE_GROUP_IN; } - /* end animdata uglyness */ + else if (in_out == SOCK_OUT) { + BLI_addtail(&ntree->outputs, iosock); + ntree->update |= NTREE_UPDATE_GROUP_OUT; + } + + return iosock; +} - /* ensures only a single output node is enabled */ - ntreeSetOutput(ntree); +bNodeSocket *ntreeInsertSocketInterface(bNodeTree *ntree, int in_out, const char *idname, + bNodeSocket *next_sock, const char *name) +{ + bNodeSocket *iosock; + + iosock = make_socket_template(ntree, in_out, idname, name); + if (in_out == SOCK_IN) { + BLI_insertlinkbefore(&ntree->inputs, next_sock, iosock); + ntree->update |= NTREE_UPDATE_GROUP_IN; + } + else if (in_out == SOCK_OUT) { + BLI_insertlinkbefore(&ntree->outputs, next_sock, iosock); + ntree->update |= NTREE_UPDATE_GROUP_OUT; + } + + return iosock; +} - for (node = ntree->nodes.first; node; node = node->next) { - /* store new_node pointer to original */ - node->new_node->new_node = node; +struct bNodeSocket *ntreeAddSocketInterfaceFromSocket(bNodeTree *ntree, bNode *from_node, bNodeSocket *from_sock) +{ + bNodeSocket *iosock = ntreeAddSocketInterface(ntree, from_sock->in_out, from_sock->idname, from_sock->name); + if (iosock) { + if (iosock->typeinfo->interface_from_socket) + iosock->typeinfo->interface_from_socket(ntree, iosock, from_node, from_sock); } + return iosock; +} - if (ntreetype->localize) - ntreetype->localize(ltree, ntree); +struct bNodeSocket *ntreeInsertSocketInterfaceFromSocket(bNodeTree *ntree, bNodeSocket *next_sock, bNode *from_node, bNodeSocket *from_sock) +{ + bNodeSocket *iosock = ntreeInsertSocketInterface(ntree, from_sock->in_out, from_sock->idname, next_sock, from_sock->name); + if (iosock) { + if (iosock->typeinfo->interface_from_socket) + iosock->typeinfo->interface_from_socket(ntree, iosock, from_node, from_sock); + } + return iosock; +} - return ltree; +void ntreeRemoveSocketInterface(bNodeTree *ntree, bNodeSocket *sock) +{ + /* this is fast, this way we don't need an in_out argument */ + BLI_remlink(&ntree->inputs, sock); + BLI_remlink(&ntree->outputs, sock); + + node_socket_interface_free(ntree, sock); + MEM_freeN(sock); + + ntree->update |= NTREE_UPDATE_GROUP; } -/* sync local composite with real tree */ -/* local tree is supposed to be running, be careful moving previews! */ -/* is called by jobs manager, outside threads, so it doesnt happen during draw */ -void ntreeLocalSync(bNodeTree *localtree, bNodeTree *ntree) +/* generates a valid RNA identifier from the node tree name */ +static void ntree_interface_identifier_base(bNodeTree *ntree, char *base) { - bNodeTreeType *ntreetype = ntreeGetType(ntree->type); + /* generate a valid RNA identifier */ + sprintf(base, "NodeTreeInterface_%s", ntree->id.name+2); + RNA_identifier_sanitize(base, FALSE); +} - if (ntreetype->local_sync) - ntreetype->local_sync(localtree, ntree); +/* check if the identifier is already in use */ +static bool ntree_interface_unique_identifier_check(void *UNUSED(data), const char *identifier) +{ + return (RNA_struct_find(identifier) != NULL); } -/* merge local tree results back, and free local tree */ -/* we have to assume the editor already changed completely */ -void ntreeLocalMerge(bNodeTree *localtree, bNodeTree *ntree) +/* generates the actual unique identifier and ui name and description */ +static void ntree_interface_identifier(bNodeTree *ntree, const char *base, char *identifier, int maxlen, char *name, char *description) { - bNodeTreeType *ntreetype = ntreeGetType(ntree->type); - bNode *lnode; + /* There is a possibility that different node tree names get mapped to the same identifier + * after sanitization (e.g. "SomeGroup_A", "SomeGroup.A" both get sanitized to "SomeGroup_A"). + * On top of the sanitized id string add a number suffix if necessary to avoid duplicates. + */ + identifier[0] = '\0'; + BLI_uniquename_cb(ntree_interface_unique_identifier_check, NULL, base, '_', identifier, maxlen); - /* move over the compbufs and previews */ - for (lnode = localtree->nodes.first; lnode; lnode = lnode->next) { - if (ntreeNodeExists(ntree, lnode->new_node)) { - if (lnode->preview && lnode->preview->rect) { - nodeFreePreview(lnode->new_node); - lnode->new_node->preview = lnode->preview; - lnode->preview = NULL; - } + sprintf(name, "Node Tree %s Interface", ntree->id.name+2); + sprintf(description, "Interface properties of node group %s", ntree->id.name+2); +} + +static void ntree_interface_type_create(bNodeTree *ntree) +{ + StructRNA *srna; + bNodeSocket *sock; + /* strings are generated from base string + ID name, sizes are sufficient */ + char base[MAX_ID_NAME+64], identifier[MAX_ID_NAME+64], name[MAX_ID_NAME+64], description[MAX_ID_NAME+64]; + + /* generate a valid RNA identifier */ + ntree_interface_identifier_base(ntree, base); + ntree_interface_identifier(ntree, base, identifier, sizeof(identifier), name, description); + + /* register a subtype of PropertyGroup */ + srna = RNA_def_struct_ptr(&BLENDER_RNA, identifier, &RNA_PropertyGroup); + RNA_def_struct_ui_text(srna, name, description); + RNA_def_struct_duplicate_pointers(srna); + + /* associate the RNA type with the node tree */ + ntree->interface_type = srna; + RNA_struct_blender_type_set(srna, ntree); + + /* add socket properties */ + for (sock = ntree->inputs.first; sock; sock = sock->next) { + bNodeSocketType *stype = sock->typeinfo; + if (stype && stype->interface_register_properties) + stype->interface_register_properties(ntree, sock, srna); + } + for (sock = ntree->outputs.first; sock; sock = sock->next) { + bNodeSocketType *stype = sock->typeinfo; + if (stype && stype->interface_register_properties) + stype->interface_register_properties(ntree, sock, srna); + } +} + +StructRNA *ntreeInterfaceTypeGet(bNodeTree *ntree, int create) +{ + if (ntree->interface_type) { + /* strings are generated from base string + ID name, sizes are sufficient */ + char base[MAX_ID_NAME+64], identifier[MAX_ID_NAME+64], name[MAX_ID_NAME+64], description[MAX_ID_NAME+64]; + + /* A bit of a hack: when changing the ID name, update the RNA type identifier too, + * so that the names match. This is not strictly necessary to keep it working, + * but better for identifying associated NodeTree blocks and RNA types. + */ + StructRNA *srna = ntree->interface_type; + + ntree_interface_identifier_base(ntree, base); + + /* RNA identifier may have a number suffix, but should start with the idbase string */ + if (strncmp(RNA_struct_identifier(srna), base, sizeof(base)) != 0) { + /* generate new unique RNA identifier from the ID name */ + ntree_interface_identifier(ntree, base, identifier, sizeof(identifier), name, description); + + /* rename the RNA type */ + RNA_def_struct_free_pointers(srna); + RNA_def_struct_identifier(srna, identifier); + RNA_def_struct_ui_text(srna, name, description); + RNA_def_struct_duplicate_pointers(srna); } } + else if (create) { + ntree_interface_type_create(ntree); + } + + return ntree->interface_type; +} - if (ntreetype->local_merge) - ntreetype->local_merge(localtree, ntree); +void ntreeInterfaceTypeFree(bNodeTree *ntree) +{ + if (ntree->interface_type) { + RNA_struct_free(&BLENDER_RNA, ntree->interface_type); + ntree->interface_type = NULL; + } +} - ntreeFreeTree_ex(localtree, FALSE); - MEM_freeN(localtree); +void ntreeInterfaceTypeUpdate(bNodeTree *ntree) +{ + /* XXX it would be sufficient to just recreate all properties + * instead of re-registering the whole struct type, + * but there is currently no good way to do this in the RNA functions. + * Overhead should be negligible. + */ + ntreeInterfaceTypeFree(ntree); + ntree_interface_type_create(ntree); } + /* ************ find stuff *************** */ int ntreeHasType(bNodeTree *ntree, int type) @@ -1420,25 +2260,25 @@ bNode *nodeGetActive(bNodeTree *ntree) /* two active flags, ID nodes have special flag for buttons display */ bNode *nodeGetActiveID(bNodeTree *ntree, short idtype) { - bNode *node; + bNode *node, *tnode; if (ntree == NULL) return NULL; - /* check for group edit */ - for (node = ntree->nodes.first; node; node = node->next) - if (node->flag & NODE_GROUP_EDIT) - break; - - if (node) - ntree = (bNodeTree *)node->id; - - /* now find active node with this id */ for (node = ntree->nodes.first; node; node = node->next) if (node->id && GS(node->id->name) == idtype) if (node->flag & NODE_ACTIVE_ID) - break; - - return node; + return node; + + /* no node with active ID in this tree, look inside groups */ + for(node= ntree->nodes.first; node; node= node->next) { + if(node->type==NODE_GROUP) { + tnode = nodeGetActiveID((bNodeTree*)node->id, idtype); + if (tnode) + return tnode; + } + } + + return NULL; } int nodeSetActiveID(bNodeTree *ntree, short idtype, ID *id) @@ -1448,15 +2288,6 @@ int nodeSetActiveID(bNodeTree *ntree, short idtype, ID *id) if (ntree == NULL) return ok; - /* check for group edit */ - for (node = ntree->nodes.first; node; node = node->next) - if (node->flag & NODE_GROUP_EDIT) - break; - - if (node) - ntree = (bNodeTree *)node->id; - - /* now find active node with this id */ for (node = ntree->nodes.first; node; node = node->next) { if (node->id && GS(node->id->name) == idtype) { if (id && ok == FALSE && node->id == id) { @@ -1469,6 +2300,15 @@ int nodeSetActiveID(bNodeTree *ntree, short idtype, ID *id) } } + /* update all groups linked from here + * if active ID node has been found already, + * just pass NULL so other matching nodes are deactivated. + */ + for(node= ntree->nodes.first; node; node= node->next) { + if(node->type==NODE_GROUP) + ok |= nodeSetActiveID((bNodeTree*)node->id, idtype, (ok==FALSE ? id : NULL)); + } + return ok; } @@ -1485,6 +2325,24 @@ void nodeClearActiveID(bNodeTree *ntree, short idtype) node->flag &= ~NODE_ACTIVE_ID; } +void nodeSetSelected(bNode *node, int select) +{ + if (select) { + node->flag |= NODE_SELECT; + } + else { + bNodeSocket *sock; + + node->flag &= ~NODE_SELECT; + + /* deselect sockets too */ + for (sock=node->inputs.first; sock; sock=sock->next) + sock->flag &= ~NODE_SELECT; + for (sock=node->outputs.first; sock; sock=sock->next) + sock->flag &= ~NODE_SELECT; + } +} + void nodeClearActive(bNodeTree *ntree) { bNode *node; @@ -1495,7 +2353,6 @@ void nodeClearActive(bNodeTree *ntree) node->flag &= ~(NODE_ACTIVE | NODE_ACTIVE_ID); } - /* two active flags, ID nodes have special flag for buttons display */ void nodeSetActive(bNodeTree *ntree, bNode *node) { @@ -1525,19 +2382,6 @@ int nodeSocketIsHidden(bNodeSocket *sock) return ((sock->flag & (SOCK_HIDDEN | SOCK_UNAVAIL)) != 0); } -void nodeSocketSetType(bNodeSocket *sock, int type) -{ - int old_type = sock->type; - void *old_default_value = sock->default_value; - - sock->type = type; - - sock->default_value = node_socket_make_default_value(sock->type); - node_socket_init_default_value(type, sock->default_value); - node_socket_convert_default_value(sock->type, sock->default_value, old_type, old_default_value); - node_socket_free_default_value(old_type, old_default_value); -} - /* ************** Node Clipboard *********** */ #define USE_NODE_CB_VALIDATE @@ -1692,6 +2536,163 @@ int BKE_node_clipboard_get_type(void) return node_clipboard.type; } + +/* Node Instance Hash */ + +/* magic number for initial hash key */ +const bNodeInstanceKey NODE_INSTANCE_KEY_BASE = {5381}; + +/* 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, bNodeTree *ntree, bNode *node) +{ + bNodeInstanceKey key; + + 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 int 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; + if (value_a == value_b) + return 0; + else if (value_a < value_b) + return -1; + else + return 1; +} + +bNodeInstanceHash *BKE_node_instance_hash_new(const char *info) +{ + bNodeInstanceHash *hash = 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, NULL, (GHashValFreeFP)valfreefp); + MEM_freeN(hash); +} + +void BKE_node_instance_hash_insert(bNodeInstanceHash *hash, bNodeInstanceKey key, void *value) +{ + bNodeInstanceHashEntry *entry = 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, NULL, (GHashValFreeFP)valfreefp); +} + +void BKE_node_instance_hash_clear(bNodeInstanceHash *hash, bNodeInstanceValueFP valfreefp) +{ + BLI_ghash_clear(hash->ghash, NULL, (GHashValFreeFP)valfreefp); +} + +void *BKE_node_instance_hash_pop(bNodeInstanceHash *hash, bNodeInstanceKey key) +{ + return BLI_ghash_pop(hash->ghash, &key, NULL); +} + +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_size(hash->ghash); +} + +void BKE_node_instance_hash_clear_tags(bNodeInstanceHash *hash) +{ + bNodeInstanceHashIterator iter; + + NODE_INSTANCE_HASH_ITER(iter, hash) { + bNodeInstanceHashEntry *value = BKE_node_instance_hash_iterator_get_value(&iter); + + value->tag = 0; + } +} + +void BKE_node_instance_hash_tag(bNodeInstanceHash *UNUSED(hash), void *value) +{ + bNodeInstanceHashEntry *entry = value; + entry->tag = 1; +} + +int BKE_node_instance_hash_tag_key(bNodeInstanceHash *hash, bNodeInstanceKey key) +{ + bNodeInstanceHashEntry *entry = BKE_node_instance_hash_lookup(hash, key); + + if (entry) { + entry->tag = 1; + return TRUE; + } + else + 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 = MEM_mallocN(sizeof(bNodeInstanceKey)*BKE_node_instance_hash_size(hash), "temporary node instance key list"); + bNodeInstanceHashIterator iter; + int num_untagged, i; + + num_untagged = 0; + NODE_INSTANCE_HASH_ITER(iter, hash) { + bNodeInstanceHashEntry *value = BKE_node_instance_hash_iterator_get_value(&iter); + + if (!value->tag) + untagged[num_untagged++] = BKE_node_instance_hash_iterator_get_key(&iter); + } + + for (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 */ @@ -1707,12 +2708,10 @@ static int node_get_deplist_recurs(bNodeTree *ntree, bNode *node, bNode ***nsort for (link = ntree->links.first; link; link = link->next) { if (link->tonode == node) { fromnode = link->fromnode; - if (fromnode) { - if (fromnode->done == 0) - fromnode->level = node_get_deplist_recurs(ntree, fromnode, nsort); - if (fromnode->level <= level) - level = fromnode->level - 1; - } + if (fromnode->done == 0) + fromnode->level = node_get_deplist_recurs(ntree, fromnode, nsort); + if (fromnode->level <= level) + level = fromnode->level - 1; } } @@ -1792,13 +2791,6 @@ static void ntree_update_link_pointers(bNodeTree *ntree) sock->flag &= ~SOCK_IN_USE; } } - for (sock = ntree->inputs.first; sock; sock = sock->next) { - sock->flag &= ~SOCK_IN_USE; - } - for (sock = ntree->outputs.first; sock; sock = sock->next) { - sock->link = NULL; - sock->flag &= ~SOCK_IN_USE; - } for (link = ntree->links.first; link; link = link->next) { link->tosock->link = link; @@ -1810,144 +2802,133 @@ static void ntree_update_link_pointers(bNodeTree *ntree) static void ntree_validate_links(bNodeTree *ntree) { - bNodeTreeType *ntreetype = ntreeGetType(ntree->type); bNodeLink *link; for (link = ntree->links.first; link; link = link->next) { link->flag |= NODE_LINK_VALID; if (link->fromnode && link->tonode && link->fromnode->level <= link->tonode->level) link->flag &= ~NODE_LINK_VALID; - else if (ntreetype->validate_link) { - if (!ntreetype->validate_link(ntree, link)) + else if (ntree->typeinfo->validate_link) { + if (!ntree->typeinfo->validate_link(ntree, link)) link->flag &= ~NODE_LINK_VALID; } } } -static void ntree_verify_nodes_cb(void *calldata, struct ID *UNUSED(owner_id), struct bNodeTree *ntree) -{ - ID *id = (ID *)calldata; - bNode *node; - - for (node = ntree->nodes.first; node; node = node->next) - if (node->typeinfo->verifyfunc) - node->typeinfo->verifyfunc(ntree, node, id); -} - void ntreeVerifyNodes(struct Main *main, struct ID *id) { - bNodeTreeType *ntreetype; - bNodeTree *ntree; - int n; - - for (n = 0; n < NUM_NTREE_TYPES; ++n) { - ntreetype = ntreeGetType(n); - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(main, id, ntree_verify_nodes_cb); - } - for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next) - ntree_verify_nodes_cb(id, NULL, ntree); + FOREACH_NODETREE(main, ntree, owner_id) { + bNode *node; + + if (!ntreeIsValid(ntree)) + return; + + for (node = ntree->nodes.first; node; node = node->next) + if (node->typeinfo && node->typeinfo->verifyfunc) + node->typeinfo->verifyfunc(ntree, node, id); + } FOREACH_NODETREE_END } void ntreeUpdateTree(bNodeTree *ntree) { - bNodeTreeType *ntreetype = ntreeGetType(ntree->type); bNode *node; + /* avoid reentrant updates, can be caused by RNA update callbacks */ + if (ntree->is_updating) + return; + ntree->is_updating = TRUE; + + /* only if types are initialized */ + if (!ntreeIsValid(ntree)) + return; + if (ntree->update & (NTREE_UPDATE_LINKS | NTREE_UPDATE_NODES)) { /* set the bNodeSocket->link pointers */ ntree_update_link_pointers(ntree); - - /* update the node level from link dependencies */ - ntree_update_node_level(ntree); } /* update individual nodes */ for (node = ntree->nodes.first; node; node = node->next) { /* node tree update tags override individual node update flags */ if ((node->update & NODE_UPDATE) || (ntree->update & NTREE_UPDATE)) { - if (ntreetype->update_node) - ntreetype->update_node(ntree, node); - else if (node->typeinfo->updatefunc) + if (node->typeinfo->updatefunc) node->typeinfo->updatefunc(ntree, node); nodeUpdateInternalLinks(ntree, node); } } - /* check link validity */ - if (ntree->update & (NTREE_UPDATE_LINKS | NTREE_UPDATE_NODES)) - ntree_validate_links(ntree); - /* generic tree update callback */ - if (ntreetype->update) - ntreetype->update(ntree); - else { - /* Trees can be associated with a specific node type (i.e. group nodes), - * in that case a tree update function may be defined by that node type. - */ - bNodeType *ntype = node_get_type(ntree, ntree->nodetype); - if (ntype && ntype->updatetreefunc) - ntype->updatetreefunc(ntree); - } + if (ntree->typeinfo->update) + ntree->typeinfo->update(ntree); + /* XXX this should be moved into the tree type update callback for tree supporting node groups. + * Currently the node tree interface is still a generic feature of the base NodeTree type. + */ + if (ntree->update & NTREE_UPDATE_GROUP) + ntreeInterfaceTypeUpdate(ntree); /* XXX hack, should be done by depsgraph!! */ ntreeVerifyNodes(G.main, &ntree->id); + if (ntree->update & (NTREE_UPDATE_LINKS | NTREE_UPDATE_NODES)) { + /* node updates can change sockets or links, repeat link pointer update afterward */ + ntree_update_link_pointers(ntree); + + /* update the node level from link dependencies */ + ntree_update_node_level(ntree); + + /* check link validity */ + ntree_validate_links(ntree); + } + /* clear update flags */ for (node = ntree->nodes.first; node; node = node->next) { node->update = 0; } ntree->update = 0; + + ntree->is_updating = FALSE; } void nodeUpdate(bNodeTree *ntree, bNode *node) { - bNodeTreeType *ntreetype = ntreeGetType(ntree->type); + /* avoid reentrant updates, can be caused by RNA update callbacks */ + if (ntree->is_updating) + return; + ntree->is_updating = TRUE; - if (ntreetype->update_node) - ntreetype->update_node(ntree, node); - else if (node->typeinfo->updatefunc) + if (node->typeinfo->updatefunc) node->typeinfo->updatefunc(ntree, node); nodeUpdateInternalLinks(ntree, node); /* clear update flag */ node->update = 0; + + ntree->is_updating = FALSE; } int nodeUpdateID(bNodeTree *ntree, ID *id) { - bNodeTreeType *ntreetype; bNode *node; int change = FALSE; if (ELEM(NULL, id, ntree)) return change; - ntreetype = ntreeGetType(ntree->type); + /* avoid reentrant updates, can be caused by RNA update callbacks */ + if (ntree->is_updating) + return change; + ntree->is_updating = TRUE; - if (ntreetype->update_node) { - for (node = ntree->nodes.first; node; node = node->next) { - if (node->id == id) { - change = TRUE; - node->update |= NODE_UPDATE_ID; - ntreetype->update_node(ntree, node); - /* clear update flag */ - node->update = 0; - } - } - } - else { - for (node = ntree->nodes.first; node; node = node->next) { - if (node->id == id) { - change = TRUE; - node->update |= NODE_UPDATE_ID; - if (node->typeinfo->updatefunc) - node->typeinfo->updatefunc(ntree, node); - /* clear update flag */ - node->update = 0; - } + for (node = ntree->nodes.first; node; node = node->next) { + if(node->id == id) { + change = TRUE; + node->update |= NODE_UPDATE_ID; + if (node->typeinfo->updatefunc) + node->typeinfo->updatefunc(ntree, node); + /* clear update flag */ + node->update = 0; } } @@ -1955,6 +2936,7 @@ int nodeUpdateID(bNodeTree *ntree, ID *id) nodeUpdateInternalLinks(ntree, node); } + ntree->is_updating = FALSE; return change; } @@ -1967,21 +2949,75 @@ void nodeUpdateInternalLinks(bNodeTree *ntree, bNode *node) } -/* ************* node type access ********** */ - -int nodeValid(bNodeTree *ntree, bNodeTemplate *ntemp) +/* nodes that use ID data get synced with local data */ +void nodeSynchronizeID(bNode *node, bool copy_to_id) { - bNodeType *ntype = node_get_type(ntree, ntemp->type); - if (ntype) { - if (ntype->validfunc) - return ntype->validfunc(ntree, ntemp); - else - return 1; + if (node->id==NULL) return; + + if (ELEM(node->type, SH_NODE_MATERIAL, SH_NODE_MATERIAL_EXT)) { + bNodeSocket *sock; + Material *ma= (Material *)node->id; + int a; + + /* hrmf, case in loop isn't super fast, but we don't edit 100s of material at same time either! */ + for (a=0, sock= node->inputs.first; sock; sock= sock->next, a++) { + if (!nodeSocketIsHidden(sock)) { + if (copy_to_id) { + switch (a) { + case MAT_IN_COLOR: + copy_v3_v3(&ma->r, ((bNodeSocketValueRGBA *)sock->default_value)->value); break; + case MAT_IN_SPEC: + copy_v3_v3(&ma->specr, ((bNodeSocketValueRGBA *)sock->default_value)->value); break; + case MAT_IN_REFL: + ma->ref= ((bNodeSocketValueFloat *)sock->default_value)->value; break; + case MAT_IN_MIR: + copy_v3_v3(&ma->mirr, ((bNodeSocketValueRGBA *)sock->default_value)->value); break; + case MAT_IN_AMB: + ma->amb = ((bNodeSocketValueFloat *)sock->default_value)->value; break; + case MAT_IN_EMIT: + ma->emit = ((bNodeSocketValueFloat *)sock->default_value)->value; break; + case MAT_IN_SPECTRA: + ma->spectra = ((bNodeSocketValueFloat *)sock->default_value)->value; break; + case MAT_IN_RAY_MIRROR: + ma->ray_mirror = ((bNodeSocketValueFloat *)sock->default_value)->value; break; + case MAT_IN_ALPHA: + ma->alpha = ((bNodeSocketValueFloat *)sock->default_value)->value; break; + case MAT_IN_TRANSLUCENCY: + ma->translucency = ((bNodeSocketValueFloat *)sock->default_value)->value; break; + } + } + else { + switch (a) { + case MAT_IN_COLOR: + copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, &ma->r); break; + case MAT_IN_SPEC: + copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, &ma->specr); break; + case MAT_IN_REFL: + ((bNodeSocketValueFloat *)sock->default_value)->value= ma->ref; break; + case MAT_IN_MIR: + copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, &ma->mirr); break; + case MAT_IN_AMB: + ((bNodeSocketValueFloat *)sock->default_value)->value = ma->amb; break; + case MAT_IN_EMIT: + ((bNodeSocketValueFloat *)sock->default_value)->value = ma->emit; break; + case MAT_IN_SPECTRA: + ((bNodeSocketValueFloat *)sock->default_value)->value = ma->spectra; break; + case MAT_IN_RAY_MIRROR: + ((bNodeSocketValueFloat *)sock->default_value)->value = ma->ray_mirror; break; + case MAT_IN_ALPHA: + ((bNodeSocketValueFloat *)sock->default_value)->value = ma->alpha; break; + case MAT_IN_TRANSLUCENCY: + ((bNodeSocketValueFloat *)sock->default_value)->value = ma->translucency; break; + } + } + } + } } - else - return 0; } + +/* ************* node type access ********** */ + const char *nodeLabel(bNode *node) { if (node->label[0] != '\0') @@ -1989,81 +3025,136 @@ const char *nodeLabel(bNode *node) else if (node->typeinfo->labelfunc) return node->typeinfo->labelfunc(node); else - return IFACE_(node->typeinfo->name); + return IFACE_(node->typeinfo->ui_name); } -struct bNodeTree *nodeGroupEditGet(struct bNode *node) +static void node_type_base_defaults(bNodeType *ntype) { - if (node->typeinfo->group_edit_get) - return node->typeinfo->group_edit_get(node); - else - return NULL; + /* default size values */ + node_type_size_preset(ntype, NODE_SIZE_DEFAULT); + ntype->height = 100; + ntype->minheight = 30; + ntype->maxheight = FLT_MAX; } -struct bNodeTree *nodeGroupEditSet(struct bNode *node, int edit) +/* allow this node for any tree type */ +static int node_poll_default(bNodeType *UNUSED(ntype), bNodeTree *UNUSED(ntree)) { - if (node->typeinfo->group_edit_set) - return node->typeinfo->group_edit_set(node, edit); - else if (node->typeinfo->group_edit_get) - return node->typeinfo->group_edit_get(node); - else - return NULL; + return TRUE; } -void nodeGroupEditClear(struct bNode *node) +/* use the basic poll function */ +static int node_poll_instance_default(bNode *node, bNodeTree *ntree) { - if (node->typeinfo->group_edit_clear) - node->typeinfo->group_edit_clear(node); + return node->typeinfo->poll(node->typeinfo, ntree); } -struct bNodeTemplate nodeMakeTemplate(struct bNode *node) +void node_type_base(bNodeType *ntype, int type, const char *name, short nclass, short flag) { - bNodeTemplate ntemp; - if (node->typeinfo->templatefunc) - return node->typeinfo->templatefunc(node); - else { - ntemp.type = node->type; - return ntemp; + /* 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->ext.srna = RNA_struct_find(#Category #StructName); \ + BLI_assert(ntype->ext.srna != NULL); \ + RNA_struct_blender_type_set(ntype->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; + ntype->flag = flag; + + node_type_base_defaults(ntype); + + ntype->poll = node_poll_default; + ntype->poll_instance = node_poll_instance_default; } -void node_type_base(bNodeTreeType *ttype, bNodeType *ntype, int type, const char *name, short nclass, short flag) +void node_type_base_custom(bNodeType *ntype, const char *idname, const char *name, short nclass, short flag) { - memset(ntype, 0, sizeof(bNodeType)); - - ntype->type = type; - BLI_strncpy(ntype->name, name, sizeof(ntype->name)); + 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; ntype->flag = flag; - /* Default muting stuff. */ - if (ttype) - ntype->update_internal_links = ttype->update_internal_links; + node_type_base_defaults(ntype); +} - /* default size values */ - node_type_size_preset(ntype, NODE_SIZE_DEFAULT); +static bool unique_socket_template_identifier_check(void *arg, const char *name) +{ + bNodeSocketTemplate *ntemp; + struct {bNodeSocketTemplate *list; bNodeSocketTemplate *ntemp;} *data= arg; - ntype->height = 100; - ntype->minheight = 30; - ntype->maxheight = FLT_MAX; + for (ntemp = data->list; ntemp->type >= 0; ++ntemp) { + if (ntemp != data->ntemp) { + if (!strcmp(ntemp->identifier, name)) { + return true; + } + } + } + + return false; +} + +static void unique_socket_template_identifier(bNodeSocketTemplate *list, bNodeSocketTemplate *ntemp, const char defname[], char delim) +{ + struct {bNodeSocketTemplate *list; bNodeSocketTemplate *ntemp;} 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) { + bNodeSocketTemplate *ntemp; + ntype->inputs = inputs; ntype->outputs = outputs; + + /* automatically generate unique identifiers */ + if (inputs) { + /* clear identifier strings (uninitialized memory) */ + for (ntemp=inputs; ntemp->type >= 0; ++ntemp) + ntemp->identifier[0] = '\0'; + + for (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 (ntemp=outputs; ntemp->type >= 0; ++ntemp) + ntemp->identifier[0] = '\0'; + + for (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, struct bNodeTemplate *ntemp)) +void node_type_init(struct bNodeType *ntype, void (*initfunc)(struct bNodeTree *ntree, struct bNode *node)) { ntype->initfunc = initfunc; } -void node_type_valid(struct bNodeType *ntype, int (*validfunc)(struct bNodeTree *ntree, struct bNodeTemplate *ntemp)) -{ - ntype->validfunc = validfunc; -} - void node_type_size(struct bNodeType *ntype, int width, int minwidth, int maxwidth) { ntype->width = width; @@ -2089,14 +3180,17 @@ void node_type_size_preset(struct bNodeType *ntype, eNodeSizePreset size) } } -void node_type_storage(bNodeType *ntype, const char *storagename, void (*freestoragefunc)(struct bNode *), void (*copystoragefunc)(struct bNode *, struct bNode *)) +void node_type_storage(bNodeType *ntype, + const char *storagename, + void (*freefunc)(struct bNode *node), + void (*copyfunc)(struct bNodeTree *dest_ntree, struct bNode *dest_node, struct bNode *src_node)) { if (storagename) BLI_strncpy(ntype->storagename, storagename, sizeof(ntype->storagename)); else ntype->storagename[0] = '\0'; - ntype->copystoragefunc = copystoragefunc; - ntype->freestoragefunc = freestoragefunc; + ntype->copyfunc = copyfunc; + ntype->freefunc = freefunc; } void node_type_label(struct bNodeType *ntype, const char *(*labelfunc)(struct bNode *)) @@ -2104,11 +3198,6 @@ void node_type_label(struct bNodeType *ntype, const char *(*labelfunc)(struct bN ntype->labelfunc = labelfunc; } -void node_type_template(struct bNodeType *ntype, struct bNodeTemplate (*templatefunc)(struct bNode *)) -{ - ntype->templatefunc = templatefunc; -} - void node_type_update(struct bNodeType *ntype, void (*updatefunc)(struct bNodeTree *ntree, struct bNode *node), void (*verifyfunc)(struct bNodeTree *ntree, struct bNode *node, struct ID *id)) @@ -2117,50 +3206,21 @@ void node_type_update(struct bNodeType *ntype, ntype->verifyfunc = verifyfunc; } -void node_type_tree(struct bNodeType *ntype, void (*inittreefunc)(struct bNodeTree *), void (*updatetreefunc)(struct bNodeTree *)) -{ - ntype->inittreefunc = inittreefunc; - ntype->updatetreefunc = updatetreefunc; -} - -void node_type_group_edit(struct bNodeType *ntype, - struct bNodeTree *(*group_edit_get)(struct bNode *node), - struct bNodeTree *(*group_edit_set)(struct bNode *node, int edit), - void (*group_edit_clear)(struct bNode *node)) -{ - ntype->group_edit_get = group_edit_get; - ntype->group_edit_set = group_edit_set; - ntype->group_edit_clear = group_edit_clear; -} - -void node_type_exec(struct bNodeType *ntype, void (*execfunc)(void *data, struct bNode *, struct bNodeStack **, struct bNodeStack **)) -{ - ntype->execfunc = execfunc; -} - -void node_type_exec_new(struct bNodeType *ntype, - void *(*initexecfunc)(struct bNode *node), - void (*freeexecfunc)(struct bNode *node, void *nodedata), - void (*newexecfunc)(void *data, int thread, struct bNode *, void *nodedata, struct bNodeStack **, struct bNodeStack **)) +void node_type_exec(struct bNodeType *ntype, NodeInitExecFunction initexecfunc, NodeFreeExecFunction freeexecfunc, NodeExecFunction execfunc) { ntype->initexecfunc = initexecfunc; ntype->freeexecfunc = freeexecfunc; - ntype->newexecfunc = newexecfunc; -} - -void node_type_internal_links(bNodeType *ntype, void (*update_internal_links)(bNodeTree *, bNode *)) -{ - ntype->update_internal_links = update_internal_links; + ntype->execfunc = execfunc; } -void node_type_gpu(struct bNodeType *ntype, int (*gpufunc)(struct GPUMaterial *mat, struct bNode *node, struct GPUNodeStack *in, struct GPUNodeStack *out)) +void node_type_gpu(struct bNodeType *ntype, NodeGPUExecFunction gpufunc) { ntype->gpufunc = gpufunc; } -void node_type_gpu_ext(struct bNodeType *ntype, int (*gpuextfunc)(struct GPUMaterial *mat, struct bNode *node, void *nodedata, struct GPUNodeStack *in, struct GPUNodeStack *out)) +void node_type_internal_links(bNodeType *ntype, void (*update_internal_links)(bNodeTree *, bNode *)) { - ntype->gpuextfunc = gpuextfunc; + ntype->update_internal_links = update_internal_links; } void node_type_compatibility(struct bNodeType *ntype, short compatibility) @@ -2168,298 +3228,276 @@ void node_type_compatibility(struct bNodeType *ntype, short compatibility) ntype->compatibility = compatibility; } -static bNodeType *is_nodetype_registered(ListBase *typelist, int type) -{ - bNodeType *ntype = typelist->first; - - for (; ntype; ntype = ntype->next) - if (ntype->type == type) - return ntype; - - return NULL; -} - -void nodeRegisterType(bNodeTreeType *ttype, bNodeType *ntype) -{ - ListBase *typelist = &(ttype->node_types); - bNodeType *found = is_nodetype_registered(typelist, ntype->type); - - if (found == NULL) - BLI_addtail(typelist, ntype); - - /* 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) \ - if (ID == ntype->type) { \ - StructRNA *srna = RNA_struct_find(STRINGIFY_ARG(Category##StructName)); \ - BLI_assert(srna != NULL); \ - RNA_struct_blender_type_set(srna, ntype); \ - } - - /* XXX hack, this file will be moved to the nodes folder in customnodes branch, - * then this stupid include path is not needed any more. - */ - #include "intern/rna_nodetree_types.h" -} - -static void registerCompositNodes(bNodeTreeType *ttype) -{ - register_node_type_frame(ttype); - register_node_type_reroute(ttype); - - register_node_type_cmp_group(ttype); - - register_node_type_cmp_rlayers(ttype); - register_node_type_cmp_image(ttype); - register_node_type_cmp_texture(ttype); - register_node_type_cmp_value(ttype); - register_node_type_cmp_rgb(ttype); - register_node_type_cmp_curve_time(ttype); - register_node_type_cmp_movieclip(ttype); - - register_node_type_cmp_composite(ttype); - register_node_type_cmp_viewer(ttype); - register_node_type_cmp_splitviewer(ttype); - register_node_type_cmp_output_file(ttype); - register_node_type_cmp_view_levels(ttype); - - register_node_type_cmp_curve_rgb(ttype); - register_node_type_cmp_mix_rgb(ttype); - register_node_type_cmp_hue_sat(ttype); - register_node_type_cmp_brightcontrast(ttype); - register_node_type_cmp_gamma(ttype); - register_node_type_cmp_invert(ttype); - register_node_type_cmp_alphaover(ttype); - register_node_type_cmp_zcombine(ttype); - register_node_type_cmp_colorbalance(ttype); - register_node_type_cmp_huecorrect(ttype); - - register_node_type_cmp_normal(ttype); - register_node_type_cmp_curve_vec(ttype); - register_node_type_cmp_map_value(ttype); - register_node_type_cmp_map_range(ttype); - register_node_type_cmp_normalize(ttype); - - register_node_type_cmp_filter(ttype); - register_node_type_cmp_blur(ttype); - register_node_type_cmp_dblur(ttype); - register_node_type_cmp_bilateralblur(ttype); - register_node_type_cmp_vecblur(ttype); - register_node_type_cmp_dilateerode(ttype); - register_node_type_cmp_inpaint(ttype); - register_node_type_cmp_despeckle(ttype); - register_node_type_cmp_defocus(ttype); - - register_node_type_cmp_valtorgb(ttype); - register_node_type_cmp_rgbtobw(ttype); - register_node_type_cmp_setalpha(ttype); - register_node_type_cmp_idmask(ttype); - register_node_type_cmp_math(ttype); - register_node_type_cmp_seprgba(ttype); - register_node_type_cmp_combrgba(ttype); - register_node_type_cmp_sephsva(ttype); - register_node_type_cmp_combhsva(ttype); - register_node_type_cmp_sepyuva(ttype); - register_node_type_cmp_combyuva(ttype); - register_node_type_cmp_sepycca(ttype); - register_node_type_cmp_combycca(ttype); - register_node_type_cmp_premulkey(ttype); - - register_node_type_cmp_diff_matte(ttype); - register_node_type_cmp_distance_matte(ttype); - register_node_type_cmp_chroma_matte(ttype); - register_node_type_cmp_color_matte(ttype); - register_node_type_cmp_channel_matte(ttype); - register_node_type_cmp_color_spill(ttype); - register_node_type_cmp_luma_matte(ttype); - register_node_type_cmp_doubleedgemask(ttype); - register_node_type_cmp_keyingscreen(ttype); - register_node_type_cmp_keying(ttype); - - register_node_type_cmp_translate(ttype); - register_node_type_cmp_rotate(ttype); - register_node_type_cmp_scale(ttype); - register_node_type_cmp_flip(ttype); - register_node_type_cmp_crop(ttype); - register_node_type_cmp_displace(ttype); - register_node_type_cmp_mapuv(ttype); - register_node_type_cmp_glare(ttype); - register_node_type_cmp_tonemap(ttype); - register_node_type_cmp_lensdist(ttype); - register_node_type_cmp_transform(ttype); - register_node_type_cmp_stabilize2d(ttype); - register_node_type_cmp_moviedistortion(ttype); - - register_node_type_cmp_colorcorrection(ttype); - register_node_type_cmp_boxmask(ttype); - register_node_type_cmp_ellipsemask(ttype); - register_node_type_cmp_bokehimage(ttype); - register_node_type_cmp_bokehblur(ttype); - register_node_type_cmp_switch(ttype); - register_node_type_cmp_pixelate(ttype); - - register_node_type_cmp_mask(ttype); - register_node_type_cmp_trackpos(ttype); -} - -static void registerShaderNodes(bNodeTreeType *ttype) -{ - register_node_type_frame(ttype); - register_node_type_reroute(ttype); - - register_node_type_sh_group(ttype); - - register_node_type_sh_output(ttype); - register_node_type_sh_material(ttype); - register_node_type_sh_camera(ttype); - register_node_type_sh_gamma(ttype); - register_node_type_sh_brightcontrast(ttype); - register_node_type_sh_value(ttype); - register_node_type_sh_rgb(ttype); - register_node_type_sh_mix_rgb(ttype); - register_node_type_sh_valtorgb(ttype); - register_node_type_sh_rgbtobw(ttype); - register_node_type_sh_texture(ttype); - register_node_type_sh_normal(ttype); - register_node_type_sh_geom(ttype); - register_node_type_sh_mapping(ttype); - register_node_type_sh_curve_vec(ttype); - register_node_type_sh_curve_rgb(ttype); - register_node_type_sh_math(ttype); - register_node_type_sh_vect_math(ttype); - register_node_type_sh_squeeze(ttype); - register_node_type_sh_material_ext(ttype); - register_node_type_sh_invert(ttype); - register_node_type_sh_seprgb(ttype); - register_node_type_sh_combrgb(ttype); - register_node_type_sh_hue_sat(ttype); - - register_node_type_sh_attribute(ttype); - register_node_type_sh_geometry(ttype); - register_node_type_sh_light_path(ttype); - register_node_type_sh_light_falloff(ttype); - register_node_type_sh_object_info(ttype); - register_node_type_sh_fresnel(ttype); - register_node_type_sh_layer_weight(ttype); - register_node_type_sh_tex_coord(ttype); - register_node_type_sh_particle_info(ttype); - register_node_type_sh_hair_info(ttype); - register_node_type_sh_bump(ttype); - register_node_type_sh_script(ttype); - register_node_type_sh_tangent(ttype); - register_node_type_sh_normal_map(ttype); - - register_node_type_sh_background(ttype); - register_node_type_sh_bsdf_anisotropic(ttype); - register_node_type_sh_bsdf_diffuse(ttype); - register_node_type_sh_bsdf_glossy(ttype); - register_node_type_sh_bsdf_glass(ttype); - register_node_type_sh_bsdf_refraction(ttype); - register_node_type_sh_bsdf_translucent(ttype); - register_node_type_sh_bsdf_transparent(ttype); - register_node_type_sh_bsdf_velvet(ttype); - register_node_type_sh_emission(ttype); - register_node_type_sh_holdout(ttype); - register_node_type_sh_ambient_occlusion(ttype); - //register_node_type_sh_volume_transparent(ttype); - //register_node_type_sh_volume_isotropic(ttype); - register_node_type_sh_mix_shader(ttype); - register_node_type_sh_add_shader(ttype); - - register_node_type_sh_output_lamp(ttype); - register_node_type_sh_output_material(ttype); - register_node_type_sh_output_world(ttype); - - register_node_type_sh_tex_image(ttype); - register_node_type_sh_tex_environment(ttype); - register_node_type_sh_tex_sky(ttype); - register_node_type_sh_tex_noise(ttype); - register_node_type_sh_tex_wave(ttype); - register_node_type_sh_tex_voronoi(ttype); - register_node_type_sh_tex_musgrave(ttype); - register_node_type_sh_tex_gradient(ttype); - register_node_type_sh_tex_magic(ttype); - register_node_type_sh_tex_checker(ttype); - register_node_type_sh_tex_brick(ttype); -} - -static void registerTextureNodes(bNodeTreeType *ttype) -{ - register_node_type_frame(ttype); - register_node_type_reroute(ttype); - - register_node_type_tex_group(ttype); - - register_node_type_tex_math(ttype); - register_node_type_tex_mix_rgb(ttype); - register_node_type_tex_valtorgb(ttype); - register_node_type_tex_rgbtobw(ttype); - register_node_type_tex_valtonor(ttype); - register_node_type_tex_curve_rgb(ttype); - register_node_type_tex_curve_time(ttype); - register_node_type_tex_invert(ttype); - register_node_type_tex_hue_sat(ttype); - register_node_type_tex_coord(ttype); - register_node_type_tex_distance(ttype); - register_node_type_tex_compose(ttype); - register_node_type_tex_decompose(ttype); - - register_node_type_tex_output(ttype); - register_node_type_tex_viewer(ttype); - - register_node_type_tex_checker(ttype); - register_node_type_tex_texture(ttype); - register_node_type_tex_bricks(ttype); - register_node_type_tex_image(ttype); - - register_node_type_tex_rotate(ttype); - register_node_type_tex_translate(ttype); - register_node_type_tex_scale(ttype); - register_node_type_tex_at(ttype); - - register_node_type_tex_proc_voronoi(ttype); - register_node_type_tex_proc_blend(ttype); - register_node_type_tex_proc_magic(ttype); - register_node_type_tex_proc_marble(ttype); - register_node_type_tex_proc_clouds(ttype); - register_node_type_tex_proc_wood(ttype); - register_node_type_tex_proc_musgrave(ttype); - register_node_type_tex_proc_noise(ttype); - register_node_type_tex_proc_stucci(ttype); - register_node_type_tex_proc_distnoise(ttype); -} - -static void free_typeinfos(ListBase *list) -{ - bNodeType *ntype, *next; - for (ntype = list->first; ntype; ntype = next) { - next = ntype->next; - - if (ntype->needs_free) - MEM_freeN(ntype); - } +static void registerCompositNodes(void) +{ + 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_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_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_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_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_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_pixelate(); + + register_node_type_cmp_mask(); + register_node_type_cmp_trackpos(); +} + +static void registerShaderNodes(void) +{ + register_node_type_sh_group(); + + register_node_type_sh_output(); + register_node_type_sh_material(); + 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_mix_rgb(); + register_node_type_sh_valtorgb(); + register_node_type_sh_rgbtobw(); + register_node_type_sh_texture(); + register_node_type_sh_normal(); + register_node_type_sh_geom(); + register_node_type_sh_mapping(); + register_node_type_sh_curve_vec(); + register_node_type_sh_curve_rgb(); + register_node_type_sh_math(); + register_node_type_sh_vect_math(); + register_node_type_sh_squeeze(); + register_node_type_sh_material_ext(); + register_node_type_sh_invert(); + register_node_type_sh_seprgb(); + register_node_type_sh_combrgb(); + register_node_type_sh_hue_sat(); + + register_node_type_sh_attribute(); + 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_background(); + register_node_type_sh_bsdf_anisotropic(); + register_node_type_sh_bsdf_diffuse(); + 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_emission(); + register_node_type_sh_holdout(); + //register_node_type_sh_volume_transparent(); + //register_node_type_sh_volume_isotropic(); + register_node_type_sh_mix_shader(); + register_node_type_sh_add_shader(); + + register_node_type_sh_output_lamp(); + register_node_type_sh_output_material(); + register_node_type_sh_output_world(); + + 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(); +} + +static void registerTextureNodes(void) +{ + 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_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_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(); } void init_nodesystem(void) { - /* init clipboard */ - node_clipboard.nodes.first = node_clipboard.nodes.last = NULL; - node_clipboard.links.first = node_clipboard.links.last = NULL; + nodetreetypes_hash = BLI_ghash_new(BLI_ghashutil_strhash, BLI_ghashutil_strcmp, "nodetreetypes_hash gh"); + nodetypes_hash = BLI_ghash_new(BLI_ghashutil_strhash, BLI_ghashutil_strcmp, "nodetypes_hash gh"); + nodesockettypes_hash = BLI_ghash_new(BLI_ghashutil_strhash, BLI_ghashutil_strcmp, "nodesockettypes_hash gh"); + + register_standard_node_socket_types(); + + register_node_tree_type_cmp(); + register_node_tree_type_sh(); + register_node_tree_type_tex(); + + register_node_type_frame(); + register_node_type_reroute(); + register_node_type_group_input(); + register_node_type_group_output(); - registerCompositNodes(ntreeGetType(NTREE_COMPOSIT)); - registerShaderNodes(ntreeGetType(NTREE_SHADER)); - registerTextureNodes(ntreeGetType(NTREE_TEXTURE)); + registerCompositNodes(); + registerShaderNodes(); + registerTextureNodes(); } void free_nodesystem(void) { - free_typeinfos(&ntreeGetType(NTREE_COMPOSIT)->node_types); - free_typeinfos(&ntreeGetType(NTREE_SHADER)->node_types); - free_typeinfos(&ntreeGetType(NTREE_TEXTURE)->node_types); + NODE_TYPES_BEGIN(nt) + if(nt->ext.free) { + nt->ext.free(nt->ext.data); + } + NODE_TYPES_END + + 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 + + NODE_TREE_TYPES_BEGIN(nt) + if(nt->ext.free) { + nt->ext.free(nt->ext.data); + } + NODE_TREE_TYPES_END + + BLI_ghash_free(nodetypes_hash, NULL, node_free_type); + nodetypes_hash = NULL; + + BLI_ghash_free(nodesockettypes_hash, NULL, node_free_socket_type); + nodesockettypes_hash = NULL; + + BLI_ghash_free(nodetreetypes_hash, NULL, ntree_free_type); + nodetreetypes_hash = NULL; } /* called from BKE_scene_unlink, when deleting a scene goes over all scenes diff --git a/source/blender/blenkernel/intern/texture.c b/source/blender/blenkernel/intern/texture.c index bdf2ce622de..c6d4cf1412d 100644 --- a/source/blender/blenkernel/intern/texture.c +++ b/source/blender/blenkernel/intern/texture.c @@ -695,7 +695,7 @@ Tex *BKE_texture_copy(Tex *tex) if (tex->nodetree) { if (tex->nodetree->execdata) { - ntreeTexEndExecTree(tex->nodetree->execdata, 1); + ntreeTexEndExecTree(tex->nodetree->execdata); } texn->nodetree = ntreeCopyTree(tex->nodetree); } diff --git a/source/blender/blenlib/BLI_ghash.h b/source/blender/blenlib/BLI_ghash.h index 97564ca5363..641aaa1f3fc 100644 --- a/source/blender/blenlib/BLI_ghash.h +++ b/source/blender/blenlib/BLI_ghash.h @@ -70,6 +70,7 @@ void BLI_ghash_free(GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfre void BLI_ghash_insert(GHash *gh, void *key, void *val); void *BLI_ghash_lookup(GHash *gh, const void *key); bool BLI_ghash_remove(GHash *gh, void *key, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp); +void BLI_ghash_clear(GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp); void *BLI_ghash_pop(GHash *gh, void *key, GHashKeyFreeFP keyfreefp); bool BLI_ghash_haskey(GHash *gh, const void *key); int BLI_ghash_size(GHash *gh); diff --git a/source/blender/blenlib/CMakeLists.txt b/source/blender/blenlib/CMakeLists.txt index bd6e84f7ef9..e39ae395ffa 100644 --- a/source/blender/blenlib/CMakeLists.txt +++ b/source/blender/blenlib/CMakeLists.txt @@ -23,10 +23,13 @@ # # ***** END GPL LICENSE BLOCK ***** +# XXX allowing blenkernel and RNA includes in blenlib is a hack, +# but needed in a few places atm (bpath.c for instance) set(INC . # ../blenkernel # dont add this back! ../makesdna + ../makesrna ../../../intern/ghost ../../../intern/guardedalloc ../../../extern/wcwidth diff --git a/source/blender/blenlib/intern/BLI_ghash.c b/source/blender/blenlib/intern/BLI_ghash.c index ebc40ebc5e3..0887d646479 100644 --- a/source/blender/blenlib/intern/BLI_ghash.c +++ b/source/blender/blenlib/intern/BLI_ghash.c @@ -62,8 +62,7 @@ GHash *BLI_ghash_new(GHashHashFP hashfp, GHashCmpFP cmpfp, const char *info) gh->nentries = 0; gh->nbuckets = hashsizes[gh->cursize]; - gh->buckets = MEM_mallocN(gh->nbuckets * sizeof(*gh->buckets), "buckets"); - memset(gh->buckets, 0, gh->nbuckets * sizeof(*gh->buckets)); + gh->buckets = MEM_callocN(gh->nbuckets * sizeof(*gh->buckets), "buckets"); return gh; } @@ -88,8 +87,7 @@ void BLI_ghash_insert(GHash *gh, void *key, void *val) int i, nold = gh->nbuckets; gh->nbuckets = hashsizes[++gh->cursize]; - gh->buckets = (Entry **)MEM_mallocN(gh->nbuckets * sizeof(*gh->buckets), "buckets"); - memset(gh->buckets, 0, gh->nbuckets * sizeof(*gh->buckets)); + gh->buckets = (Entry **)MEM_callocN(gh->nbuckets * sizeof(*gh->buckets), "buckets"); for (i = 0; i < nold; i++) { for (e = old[i]; e; ) { @@ -148,6 +146,32 @@ bool BLI_ghash_remove(GHash *gh, void *key, GHashKeyFreeFP keyfreefp, GHashValFr return false; } +void BLI_ghash_clear(GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp) +{ + int i; + + if (keyfreefp || valfreefp) { + for (i = 0; i < gh->nbuckets; i++) { + Entry *e; + + for (e = gh->buckets[i]; e; ) { + Entry *n = e->next; + + if (keyfreefp) keyfreefp(e->key); + if (valfreefp) valfreefp(e->val); + + e = n; + } + } + } + + gh->cursize = 0; + gh->nentries = 0; + gh->nbuckets = hashsizes[gh->cursize]; + + gh->buckets = MEM_recallocN(gh->buckets, gh->nbuckets * sizeof(*gh->buckets)); +} + /* same as above but return the value, * no free value argument since it will be returned */ void *BLI_ghash_pop(GHash *gh, void *key, GHashKeyFreeFP keyfreefp) diff --git a/source/blender/blenloader/intern/readfile.c b/source/blender/blenloader/intern/readfile.c index be2b45a3e12..ea5610af3b5 100644 --- a/source/blender/blenloader/intern/readfile.c +++ b/source/blender/blenloader/intern/readfile.c @@ -127,6 +127,7 @@ #include "BKE_lattice.h" #include "BKE_library.h" // for which_libbase #include "BKE_idcode.h" +#include "BKE_idprop.h" #include "BKE_material.h" #include "BKE_main.h" // for Main #include "BKE_mesh.h" // for ME_ defines (patching) @@ -150,7 +151,11 @@ #include "IMB_imbuf.h" // for proxy / timecode versioning stuff +#include "NOD_common.h" #include "NOD_socket.h" +#include "NOD_composite.h" +#include "NOD_shader.h" +#include "NOD_texture.h" #include "BLO_readfile.h" #include "BLO_undofile.h" @@ -1313,10 +1318,12 @@ void blo_make_image_pointer_map(FileData *fd, Main *oldmain) oldnewmap_insert(fd->imamap, ima->renders[a], ima->renders[a], 0); } for (; sce; sce = sce->id.next) { - if (sce->nodetree) { - bNode *node; - for (node = sce->nodetree->nodes.first; node; node = node->next) - oldnewmap_insert(fd->imamap, node->preview, node->preview, 0); + if (sce->nodetree && sce->nodetree->previews) { + bNodeInstanceHashIterator iter; + NODE_INSTANCE_HASH_ITER(iter, sce->nodetree->previews) { + bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter); + oldnewmap_insert(fd->imamap, preview, preview, 0); + } } } } @@ -1355,10 +1362,23 @@ void blo_end_image_pointer_map(FileData *fd, Main *oldmain) ima->gputexture = newimaadr(fd, ima->gputexture); } for (; sce; sce = sce->id.next) { - if (sce->nodetree) { - bNode *node; - for (node = sce->nodetree->nodes.first; node; node = node->next) - node->preview = newimaadr(fd, node->preview); + if (sce->nodetree && sce->nodetree->previews) { + bNodeInstanceHash *new_previews = BKE_node_instance_hash_new("node previews"); + bNodeInstanceHashIterator iter; + + /* reconstruct the preview hash, only using remaining pointers */ + NODE_INSTANCE_HASH_ITER(iter, sce->nodetree->previews) { + bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter); + if (preview) { + bNodePreview *new_preview = newimaadr(fd, preview); + if (new_preview) { + bNodeInstanceKey key = BKE_node_instance_hash_iterator_get_key(&iter); + BKE_node_instance_hash_insert(new_previews, key, new_preview); + } + } + } + BKE_node_instance_hash_free(sce->nodetree->previews, NULL); + sce->nodetree->previews = new_previews; } } } @@ -2286,17 +2306,42 @@ static void direct_link_motionpath(FileData *fd, bMotionPath *mpath) /* ************ READ NODE TREE *************** */ +static void lib_link_node_socket(FileData *fd, ID *UNUSED(id), bNodeSocket *sock) +{ + /* Link ID Properties -- and copy this comment EXACTLY for easy finding + * of library blocks that implement this.*/ + if (sock->prop) + IDP_LibLinkProperty(sock->prop, (fd->flags & FD_FLAGS_SWITCH_ENDIAN), fd); +} + /* singe node tree (also used for material/scene trees), ntree is not NULL */ static void lib_link_ntree(FileData *fd, ID *id, bNodeTree *ntree) { bNode *node; + bNodeSocket *sock; if (ntree->adt) lib_link_animdata(fd, &ntree->id, ntree->adt); ntree->gpd = newlibadr_us(fd, id->lib, ntree->gpd); - for (node = ntree->nodes.first; node; node = node->next) - node->id = newlibadr_us(fd, id->lib, node->id); + for (node = ntree->nodes.first; node; node = node->next) { + /* Link ID Properties -- and copy this comment EXACTLY for easy finding + * of library blocks that implement this.*/ + if (node->prop) + IDP_LibLinkProperty(node->prop, (fd->flags & FD_FLAGS_SWITCH_ENDIAN), fd); + + node->id= newlibadr_us(fd, id->lib, node->id); + + for (sock=node->inputs.first; sock; sock=sock->next) + lib_link_node_socket(fd, id, sock); + for (sock=node->outputs.first; sock; sock=sock->next) + lib_link_node_socket(fd, id, sock); + } + + for (sock=ntree->inputs.first; sock; sock=sock->next) + lib_link_node_socket(fd, id, sock); + for (sock=ntree->outputs.first; sock; sock=sock->next) + lib_link_node_socket(fd, id, sock); } /* library ntree linking after fileread */ @@ -2313,131 +2358,49 @@ static void lib_link_nodetree(FileData *fd, Main *main) } } -static void do_versions_socket_default_value(bNodeSocket *sock) -{ - bNodeSocketValueFloat *valfloat; - bNodeSocketValueVector *valvector; - bNodeSocketValueRGBA *valrgba; - - if (sock->default_value) - return; - - switch (sock->type) { - case SOCK_FLOAT: - valfloat = sock->default_value = MEM_callocN(sizeof(bNodeSocketValueFloat), "default socket value"); - valfloat->value = sock->ns.vec[0]; - valfloat->min = sock->ns.min; - valfloat->max = sock->ns.max; - valfloat->subtype = PROP_NONE; - break; - case SOCK_VECTOR: - valvector = sock->default_value = MEM_callocN(sizeof(bNodeSocketValueVector), "default socket value"); - copy_v3_v3(valvector->value, sock->ns.vec); - valvector->min = sock->ns.min; - valvector->max = sock->ns.max; - valvector->subtype = PROP_NONE; - break; - case SOCK_RGBA: - valrgba = sock->default_value = MEM_callocN(sizeof(bNodeSocketValueRGBA), "default socket value"); - copy_v4_v4(valrgba->value, sock->ns.vec); - break; - } -} - -void blo_do_versions_nodetree_default_value(bNodeTree *ntree) -{ - bNode *node; - bNodeSocket *sock; - for (node=ntree->nodes.first; node; node=node->next) { - for (sock=node->inputs.first; sock; sock=sock->next) - do_versions_socket_default_value(sock); - for (sock=node->outputs.first; sock; sock=sock->next) - do_versions_socket_default_value(sock); - } - for (sock=ntree->inputs.first; sock; sock=sock->next) - do_versions_socket_default_value(sock); - for (sock=ntree->outputs.first; sock; sock=sock->next) - do_versions_socket_default_value(sock); -} - -static void lib_nodetree_init_types_cb(void *UNUSED(data), ID *UNUSED(id), bNodeTree *ntree) -{ - bNode *node; - - ntreeInitTypes(ntree); - - /* need to do this here instead of in do_versions, otherwise next function can crash */ - blo_do_versions_nodetree_default_value(ntree); - - /* XXX could be replaced by do_versions for new nodes */ - for (node=ntree->nodes.first; node; node=node->next) - node_verify_socket_templates(ntree, node); -} - -/* updates group node socket own_index so that +/* updates group node socket identifier so that * external links to/from the group node are preserved. */ static void lib_node_do_versions_group_indices(bNode *gnode) { bNodeTree *ngroup = (bNodeTree*)gnode->id; - bNode *intnode; - bNodeSocket *sock, *gsock, *intsock; - int found; + bNodeSocket *sock; + bNodeLink *link; for (sock=gnode->outputs.first; sock; sock=sock->next) { int old_index = sock->to_index; - for (gsock=ngroup->outputs.first; gsock; gsock=gsock->next) { - if (gsock->link && gsock->link->fromsock->own_index == old_index) { - sock->own_index = gsock->own_index; - break; + + for (link = ngroup->links.first; link; link = link->next) { + if (link->tonode->type == NODE_GROUP_OUTPUT && link->fromsock->own_index == old_index) { + strcpy(sock->identifier, link->fromsock->identifier); + /* deprecated */ + sock->own_index = link->fromsock->own_index; + sock->to_index = 0; + sock->groupsock = NULL; } } } for (sock=gnode->inputs.first; sock; sock=sock->next) { int old_index = sock->to_index; - /* can't use break in double loop */ - found = 0; - for (intnode=ngroup->nodes.first; intnode && !found; intnode=intnode->next) { - for (intsock=intnode->inputs.first; intsock; intsock=intsock->next) { - if (intsock->own_index == old_index && intsock->link) { - sock->own_index = intsock->link->fromsock->own_index; - found = 1; - break; - } + + for (link = ngroup->links.first; link; link = link->next) { + if (link->fromnode->type == NODE_GROUP_INPUT && link->tosock->own_index == old_index) { + strcpy(sock->identifier, link->tosock->identifier); + /* deprecated */ + sock->own_index = link->tosock->own_index; + sock->to_index = 0; + sock->groupsock = NULL; } } } } -/* updates external links for all group nodes in a tree */ -static void lib_nodetree_do_versions_group_indices_cb(void *UNUSED(data), ID *UNUSED(id), bNodeTree *ntree) -{ - bNode *node; - - for (node = ntree->nodes.first; node; node = node->next) { - if (node->type == NODE_GROUP) { - bNodeTree *ngroup = (bNodeTree*)node->id; - if (ngroup && (ngroup->flag & NTREE_DO_VERSIONS_GROUP_EXPOSE)) - lib_node_do_versions_group_indices(node); - } - } -} - -/* make an update call for the tree */ -static void lib_nodetree_do_versions_update_cb(void *UNUSED(data), ID *UNUSED(id), bNodeTree *ntree) -{ - if (ntree->update) - ntreeUpdateTree(ntree); -} - /* verify types for nodes and groups, all data has to be read */ /* open = 0: appending/linking, open = 1: open new file (need to clean out dynamic * typedefs */ static void lib_verify_nodetree(Main *main, int UNUSED(open)) { bNodeTree *ntree; - int i; - bNodeTreeType *ntreetype; /* this crashes blender on undo/redo */ #if 0 @@ -2447,41 +2410,138 @@ static void lib_verify_nodetree(Main *main, int UNUSED(open)) #endif /* set node->typeinfo pointers */ - for (i = 0; i < NUM_NTREE_TYPES; ++i) { - ntreetype = ntreeGetType(i); - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(main, NULL, lib_nodetree_init_types_cb); - } - for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next) - lib_nodetree_init_types_cb(NULL, NULL, ntree); + FOREACH_NODETREE(main, ntree, id) { + ntreeSetTypes(NULL, ntree); + } FOREACH_NODETREE_END + + /* verify static socket templates */ + FOREACH_NODETREE(main, ntree, id) { + bNode *node; + for (node=ntree->nodes.first; node; node=node->next) + node_verify_socket_templates(ntree, node); + } FOREACH_NODETREE_END { int has_old_groups = 0; /* XXX this should actually be part of do_versions, but since we need * finished library linking, it is not possible there. Instead in do_versions - * we have set the NTREE_DO_VERSIONS flag, so at this point we can do the + * we have set the NTREE_DO_VERSIONS_GROUP_EXPOSE_2_56_2 flag, so at this point we can do the * actual group node updates. */ for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next) { - if (ntree->flag & NTREE_DO_VERSIONS_GROUP_EXPOSE) { - /* this adds copies and links from all unlinked internal sockets to group inputs/outputs. */ - node_group_expose_all_sockets(ntree); + if (ntree->flag & NTREE_DO_VERSIONS_GROUP_EXPOSE_2_56_2) has_old_groups = 1; - } } if (has_old_groups) { - for (i = 0; i < NUM_NTREE_TYPES; ++i) { - ntreetype = ntreeGetType(i); - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(main, NULL, lib_nodetree_do_versions_group_indices_cb); - } + FOREACH_NODETREE(main, ntree, id) { + /* updates external links for all group nodes in a tree */ + bNode *node; + for (node = ntree->nodes.first; node; node = node->next) { + if (node->type == NODE_GROUP) { + bNodeTree *ngroup = (bNodeTree*)node->id; + if (ngroup && (ngroup->flag & NTREE_DO_VERSIONS_GROUP_EXPOSE_2_56_2)) + lib_node_do_versions_group_indices(node); + } + } + } FOREACH_NODETREE_END } for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next) - ntree->flag &= ~NTREE_DO_VERSIONS_GROUP_EXPOSE; + ntree->flag &= ~NTREE_DO_VERSIONS_GROUP_EXPOSE_2_56_2; } + + { + /* Convert the previously used ntree->inputs/ntree->outputs lists to interface nodes. + * Pre 2.56.2 node trees automatically have all unlinked sockets exposed already + * (see NTREE_DO_VERSIONS_GROUP_EXPOSE_2_56_2). + * + * XXX this should actually be part of do_versions, + * but needs valid typeinfo pointers to create interface nodes. + */ + for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next) { + if (ntree->flag & NTREE_DO_VERSIONS_CUSTOMNODES_GROUP) { + bNode *input_node = NULL, *output_node = NULL; + int num_inputs = 0, num_outputs = 0; + bNodeLink *link, *next_link; + /* Only create new interface nodes for actual older files. + * New file versions already have input/output nodes with duplicate links, + * in that case just remove the invalid links. + */ + int create_io_nodes = (ntree->flag & NTREE_DO_VERSIONS_CUSTOMNODES_GROUP_CREATE_INTERFACE); + + float input_locx = 1000000.0f, input_locy = 0.0f; + float output_locx = -1000000.0f, output_locy = 0.0f; + /* rough guess, not nice but we don't have access to UI constants here ... */ + static const float offsetx = 42 + 3*20 + 20; + /*static const float offsety = 0.0f;*/ + + if (create_io_nodes) { + if (ntree->inputs.first) + input_node = nodeAddStaticNode(NULL, ntree, NODE_GROUP_INPUT); + + if (ntree->outputs.first) + output_node = nodeAddStaticNode(NULL, ntree, NODE_GROUP_OUTPUT); + } + + /* Redirect links from/to the node tree interface to input/output node. + * If the fromnode/tonode pointers are NULL, this means a link from/to + * the ntree interface sockets, which need to be redirected to new interface nodes. + */ + for (link = ntree->links.first; link; link = next_link) { + int free_link = FALSE; + next_link = link->next; + + if (link->fromnode == NULL) { + if (input_node) { + link->fromnode = input_node; + link->fromsock = node_group_input_find_socket(input_node, link->fromsock->identifier); + ++num_inputs; + + if (input_locx > link->tonode->locx - offsetx) + input_locx = link->tonode->locx - offsetx; + input_locy += link->tonode->locy; + } + else + free_link = TRUE; + } + + if (link->tonode == NULL) { + if (output_node) { + link->tonode = output_node; + link->tosock = node_group_output_find_socket(output_node, link->tosock->identifier); + ++num_outputs; + + if (output_locx < link->fromnode->locx + offsetx) + output_locx = link->fromnode->locx + offsetx; + output_locy += link->fromnode->locy; + } + else + free_link = TRUE; + } + + if (free_link) + nodeRemLink(ntree, link); + } + + if (num_inputs > 0) { + input_locy /= num_inputs; + input_node->locx = input_locx; + input_node->locy = input_locy; + } + if (num_outputs > 0) { + output_locy /= num_outputs; + output_node->locx = output_locx; + output_node->locy = output_locy; + } + + /* clear do_versions flags */ + ntree->flag &= ~(NTREE_DO_VERSIONS_CUSTOMNODES_GROUP | NTREE_DO_VERSIONS_CUSTOMNODES_GROUP_CREATE_INTERFACE); + } + } + } + /* verify all group user nodes */ for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next) { ntreeVerifyNodes(main, &ntree->id); @@ -2489,21 +2549,22 @@ static void lib_verify_nodetree(Main *main, int UNUSED(open)) /* make update calls where necessary */ { - for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next) + FOREACH_NODETREE(main, ntree, id) { + /* make an update call for the tree */ if (ntree->update) ntreeUpdateTree(ntree); - - for (i = 0; i < NUM_NTREE_TYPES; i++) { - ntreetype = ntreeGetType(i); - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(main, NULL, lib_nodetree_do_versions_update_cb); - } + } FOREACH_NODETREE_END } } static void direct_link_node_socket(FileData *fd, bNodeSocket *sock) { + sock->prop = newdataadr(fd, sock->prop); + if (sock->prop) + IDP_DirectLinkProperty(sock->prop, (fd->flags & FD_FLAGS_SWITCH_ENDIAN), fd); + sock->link = newdataadr(fd, sock->link); + sock->typeinfo = NULL; sock->storage = newdataadr(fd, sock->storage); sock->default_value = newdataadr(fd, sock->default_value); sock->cache = NULL; @@ -2518,6 +2579,10 @@ static void direct_link_nodetree(FileData *fd, bNodeTree *ntree) bNodeLink *link; ntree->init = 0; /* to set callbacks and force setting types */ + ntree->is_updating = FALSE; + ntree->typeinfo= NULL; + ntree->interface_type = NULL; + ntree->progress = NULL; ntree->execdata = NULL; @@ -2533,6 +2598,10 @@ static void direct_link_nodetree(FileData *fd, bNodeTree *ntree) link_list(fd, &node->inputs); link_list(fd, &node->outputs); + node->prop = newdataadr(fd, node->prop); + if (node->prop) + IDP_DirectLinkProperty(node->prop, (fd->flags & FD_FLAGS_SWITCH_ENDIAN), fd); + link_list(fd, &node->internal_links); for (link = node->internal_links.first; link; link = link->next) { link->fromnode = newdataadr(fd, link->fromnode); @@ -2544,8 +2613,9 @@ static void direct_link_nodetree(FileData *fd, bNodeTree *ntree) if (node->type == CMP_NODE_MOVIEDISTORTION) { node->storage = newmclipadr(fd, node->storage); } - else + else { node->storage = newdataadr(fd, node->storage); + } if (node->storage) { /* could be handlerized at some point */ @@ -2556,9 +2626,6 @@ static void direct_link_nodetree(FileData *fd, bNodeTree *ntree) else if (node->type==SH_NODE_SCRIPT) { NodeShaderScript *nss = (NodeShaderScript *) node->storage; nss->bytecode = newdataadr(fd, nss->bytecode); - nss->prop = newdataadr(fd, nss->prop); - if (nss->prop) - IDP_DirectLinkProperty(nss->prop, (fd->flags & FD_FLAGS_SWITCH_ENDIAN), fd); } } else if (ntree->type==NTREE_COMPOSIT) { @@ -2577,14 +2644,9 @@ static void direct_link_nodetree(FileData *fd, bNodeTree *ntree) } link_list(fd, &ntree->links); - /* external sockets */ - link_list(fd, &ntree->inputs); - link_list(fd, &ntree->outputs); - /* and we connect the rest */ for (node = ntree->nodes.first; node; node = node->next) { node->parent = newdataadr(fd, node->parent); - node->preview = newimaadr(fd, node->preview); node->lasty = 0; for (sock = node->inputs.first; sock; sock = sock->next) @@ -2592,6 +2654,10 @@ static void direct_link_nodetree(FileData *fd, bNodeTree *ntree) for (sock = node->outputs.first; sock; sock = sock->next) direct_link_node_socket(fd, sock); } + + /* interface socket lists */ + link_list(fd, &ntree->inputs); + link_list(fd, &ntree->outputs); for (sock = ntree->inputs.first; sock; sock = sock->next) direct_link_node_socket(fd, sock); for (sock = ntree->outputs.first; sock; sock = sock->next) @@ -2604,6 +2670,29 @@ static void direct_link_nodetree(FileData *fd, bNodeTree *ntree) link->tosock = newdataadr(fd, link->tosock); } +#if 0 + if (ntree->previews) { + bNodeInstanceHash *new_previews = BKE_node_instance_hash_new("node previews"); + bNodeInstanceHashIterator iter; + + NODE_INSTANCE_HASH_ITER(iter, ntree->previews) { + bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter); + if (preview) { + bNodePreview *new_preview = newimaadr(fd, preview); + if (new_preview) { + bNodeInstanceKey key = BKE_node_instance_hash_iterator_get_key(&iter); + BKE_node_instance_hash_insert(new_previews, key, new_preview); + } + } + } + BKE_node_instance_hash_free(ntree->previews, NULL); + ntree->previews = new_previews; + } +#else + /* XXX TODO */ + ntree->previews = NULL; +#endif + /* type verification is in lib-link */ } @@ -5543,28 +5632,34 @@ static void lib_link_screen(FileData *fd, Main *main) } else if (sl->spacetype == SPACE_NODE) { SpaceNode *snode = (SpaceNode *)sl; + bNodeTreePath *path, *path_next; - snode->id = newlibadr(fd, sc->id.lib, snode->id); + for (path=snode->treepath.first; path; path=path->next) { + path->nodetree = newlibadr(fd, sc->id.lib, path->nodetree); + + if (!path->nodetree) + break; + } - if (ELEM3(snode->treetype, NTREE_COMPOSIT, NTREE_SHADER, NTREE_TEXTURE)) { - /* internal data, a bit patchy */ - snode->nodetree = NULL; - if (snode->id) { - if (GS(snode->id->name)==ID_MA) - snode->nodetree = ((Material *)snode->id)->nodetree; - else if (GS(snode->id->name)==ID_WO) - snode->nodetree = ((World *)snode->id)->nodetree; - else if (GS(snode->id->name)==ID_LA) - snode->nodetree = ((Lamp *)snode->id)->nodetree; - else if (GS(snode->id->name)==ID_SCE) - snode->nodetree = ((Scene *)snode->id)->nodetree; - else if (GS(snode->id->name)==ID_TE) - snode->nodetree = ((Tex *)snode->id)->nodetree; - } + /* remaining path entries are invalid, remove */ + for (; path; path = path_next) { + path_next = path->next; + + BLI_remlink(&snode->treepath, path); + MEM_freeN(path); } - else { - snode->nodetree = newlibadr_us(fd, sc->id.lib, snode->nodetree); + + snode->nodetree = newlibadr(fd, sc->id.lib, snode->nodetree); + /* edittree is just the last in the path, + * set this directly since the path may have been shortened above */ + if (snode->treepath.last) { + path = snode->treepath.last; + snode->edittree = path->nodetree; } + else + snode->edittree = NULL; + snode->id = newlibadr(fd, sc->id.lib, snode->id); + snode->from = newlibadr(fd, sc->id.lib, snode->from); } else if (sl->spacetype == SPACE_CLIP) { SpaceClip *sclip = (SpaceClip *)sl; @@ -5584,6 +5679,24 @@ static void lib_link_screen(FileData *fd, Main *main) } } +static bool restore_pointer(ID *id, ID *newid, int user) +{ + if (strcmp(newid->name+2, id->name+2) == 0) { + if (newid->lib == id->lib) { + if (user == 1) { + if (newid->us == 0) { + newid->us++; + } + } + else if (user == 2) { + id_us_ensure_real(newid); + } + return true; + } + } + return false; +} + /** * Only for undo files, or to restore a screen after reading without UI... * @@ -5595,30 +5708,33 @@ static void lib_link_screen(FileData *fd, Main *main) static void *restore_pointer_by_name(Main *mainp, ID *id, int user) { if (id) { - ListBase *lb = which_libbase(mainp, GS(id->name)); - - if (lb) { // there's still risk of checking corrupt mem (freed Ids in oops) - ID *idn = lb->first; - char *name = id->name + 2; - - for (; idn; idn = idn->next) { - if (idn->name[2] == name[0] && strcmp(idn->name+2, name) == 0) { - if (idn->lib == id->lib) { - if (user == 1) { - if (idn->us == 0) { - idn->us++; - } - } - else if (user == 2) { - id_us_ensure_real(idn); - } - break; - } + /* node trees can be stored locally in other IDs, needs special handling ... */ + if (GS(id->name) == ID_NT) { + ID *idn = NULL; + + FOREACH_NODETREE(mainp, ntree, owner_id) { + if (restore_pointer(id, &ntree->id, user)) { + idn = &ntree->id; + break; } } + FOREACH_NODETREE_END return idn; } + else { + ListBase *lb = which_libbase(mainp, GS(id->name)); + if (lb) { // there's still risk of checking corrupt mem (freed Ids in oops) + ID *idn = lb->first; + + for (; idn; idn = idn->next) { + if (restore_pointer(id, idn, user)) + break; + } + + return idn; + } + } } return NULL; } @@ -5848,24 +5964,34 @@ void blo_lib_link_screen_restore(Main *newmain, bScreen *curscreen, Scene *cursc } else if (sl->spacetype == SPACE_NODE) { SpaceNode *snode= (SpaceNode *)sl; + bNodeTreePath *path, *path_next; - snode->id = restore_pointer_by_name(newmain, snode->id, 1); - snode->edittree = NULL; + for (path=snode->treepath.first; path; path=path->next) { + path->nodetree= restore_pointer_by_name(newmain, (ID*)path->nodetree, 0); + + if (!path->nodetree) + break; + } - if (ELEM3(snode->treetype, NTREE_COMPOSIT, NTREE_SHADER, NTREE_TEXTURE)) { - snode->nodetree = NULL; - if (snode->id) { - if (GS(snode->id->name)==ID_MA) - snode->nodetree = ((Material *)snode->id)->nodetree; - else if (GS(snode->id->name)==ID_SCE) - snode->nodetree = ((Scene *)snode->id)->nodetree; - else if (GS(snode->id->name)==ID_TE) - snode->nodetree = ((Tex *)snode->id)->nodetree; - } + /* remaining path entries are invalid, remove */ + for (; path; path = path_next) { + path_next = path->next; + + BLI_remlink(&snode->treepath, path); + MEM_freeN(path); } - else { - snode->nodetree= restore_pointer_by_name(newmain, &snode->nodetree->id, 1); + + snode->nodetree = restore_pointer_by_name(newmain, (ID*)snode->nodetree, 0); + /* edittree is just the last in the path, + * set this directly since the path may have been shortened above */ + if (snode->treepath.last) { + path = snode->treepath.last; + snode->edittree = path->nodetree; } + else + snode->edittree = NULL; + snode->id = restore_pointer_by_name(newmain, snode->id, 1); + snode->from = restore_pointer_by_name(newmain, snode->from, 0); } else if (sl->spacetype == SPACE_CLIP) { SpaceClip *sclip = (SpaceClip *)sl; @@ -6116,6 +6242,8 @@ static void direct_link_screen(FileData *fd, bScreen *sc) snode->gpd = newdataadr(fd, snode->gpd); direct_link_gpencil(fd, snode->gpd); } + + link_list(fd, &snode->treepath); snode->edittree = NULL; snode->linkdrag.first = snode->linkdrag.last = NULL; } @@ -6855,7 +6983,6 @@ static void link_global(FileData *fd, BlendFileData *bfd) } } -/* deprecated, only keep this for readfile.c */ void convert_tface_mt(FileData *fd, Main *main) { Main *gmain; @@ -6890,22 +7017,6 @@ static void do_versions_nodetree_image_default_alpha_output(bNodeTree *ntree) } } -static void do_version_ntree_tex_mapping_260(void *UNUSED(data), ID *UNUSED(id), bNodeTree *ntree) -{ - bNode *node; - - for (node = ntree->nodes.first; node; node = node->next) { - if (node->type == SH_NODE_MAPPING) { - TexMapping *tex_mapping; - - tex_mapping= node->storage; - tex_mapping->projx= PROJ_X; - tex_mapping->projy= PROJ_Y; - tex_mapping->projz= PROJ_Z; - } - } -} - static void do_versions_nodetree_convert_angle(bNodeTree *ntree) { bNode *node; @@ -7240,151 +7351,6 @@ static void do_versions_nodetree_frame_2_64_6(bNodeTree *ntree) } } -static void do_version_ntree_image_user_264(void *UNUSED(data), ID *UNUSED(id), bNodeTree *ntree) -{ - bNode *node; - - for (node = ntree->nodes.first; node; node = node->next) { - if (ELEM(node->type, SH_NODE_TEX_IMAGE, SH_NODE_TEX_ENVIRONMENT)) { - NodeTexImage *tex = node->storage; - - tex->iuser.frames= 1; - tex->iuser.sfra= 1; - tex->iuser.fie_ima= 2; - tex->iuser.ok= 1; - } - } -} - -static void do_version_ntree_dilateerode_264(void *UNUSED(data), ID *UNUSED(id), bNodeTree *ntree) -{ - bNode *node; - - for (node = ntree->nodes.first; node; node = node->next) { - if (node->type == CMP_NODE_DILATEERODE) { - if (node->storage == NULL) { - NodeDilateErode *data = MEM_callocN(sizeof(NodeDilateErode), __func__); - data->falloff = PROP_SMOOTH; - node->storage = data; - } - } - } -} - -static void do_version_ntree_defocus_264(void *UNUSED(data), ID *UNUSED(id), bNodeTree *ntree) -{ - bNode *node; - - for (node = ntree->nodes.first; node; node = node->next) { - if (node->type == CMP_NODE_DEFOCUS) { - NodeDefocus *data = node->storage; - if (data->maxblur == 0.0f) { - data->maxblur = 16.0f; - } - } - } -} - -static void do_version_ntree_mask_264(void *UNUSED(data), ID *UNUSED(id), bNodeTree *ntree) -{ - bNode *node; - - for (node = ntree->nodes.first; node; node = node->next) { - if (node->type == CMP_NODE_MASK) { - if (node->storage == NULL) { - NodeMask *data = MEM_callocN(sizeof(NodeMask), __func__); - /* move settings into own struct */ - data->size_x = (int)node->custom3; - data->size_y = (int)node->custom4; - node->custom3 = 0.5f; /* default shutter */ - node->storage = data; - } - } - } -} - -static void do_version_ntree_keying_despill_balance(void *UNUSED(data), ID *UNUSED(id), bNodeTree *ntree) -{ - bNode *node; - - for (node = ntree->nodes.first; node; node = node->next) { - if (node->type == CMP_NODE_KEYING) { - NodeKeyingData *data = node->storage; - - if (data->despill_balance == 0.0f) { - data->despill_balance = 0.5f; - } - } - } -} - -static void do_version_ntree_tex_coord_from_dupli_264(void *UNUSED(data), ID *UNUSED(id), bNodeTree *ntree) -{ - bNode *node; - - for (node = ntree->nodes.first; node; node = node->next) - if (node->type == SH_NODE_TEX_COORD) - node->flag |= NODE_OPTIONS; -} - -static void do_version_node_cleanup_dynamic_sockets_264(void *UNUSED(data), ID *UNUSED(id), bNodeTree *ntree) -{ - bNode *node; - bNodeSocket *sock; - - for (node = ntree->nodes.first; node; node = node->next) { - if (!ELEM(node->type, NODE_GROUP, CMP_NODE_IMAGE)) { - for (sock = node->inputs.first; sock; sock = sock->next) - sock->flag &= ~SOCK_DYNAMIC; - for (sock = node->outputs.first; sock; sock = sock->next) - sock->flag &= ~SOCK_DYNAMIC; - } - } -} - -static void do_version_node_fix_translate_wrapping(void *UNUSED(data), ID *UNUSED(id), bNodeTree *ntree) -{ - bNode *node; - - for (node = ntree->nodes.first; node; node = node->next) { - if (node->type == CMP_NODE_TRANSLATE && node->storage == NULL) { - node->storage = MEM_callocN(sizeof(NodeTranslateData), "node translate data"); - } - } -} - -static void do_version_node_straight_image_alpha_workaround(void *data, ID *UNUSED(id), bNodeTree *ntree) -{ - FileData *fd = (FileData *) data; - bNode *node; - - for (node = ntree->nodes.first; node; node = node->next) { - if (node->type == CMP_NODE_IMAGE) { - Image *image = blo_do_versions_newlibadr(fd, ntree->id.lib, node->id); - - if (image) { - if ((image->flag & IMA_DO_PREMUL) == 0 && image->alpha_mode == IMA_ALPHA_STRAIGHT) - node->custom1 |= CMP_NODE_IMAGE_USE_STRAIGHT_OUTPUT; - } - } - } -} - -static void do_version_node_fix_internal_links_264(void *UNUSED(data), ID *UNUSED(id), bNodeTree *ntree) -{ - bNode *node; - bNodeLink *link, *nextlink; - - for (node = ntree->nodes.first; node; node = node->next) { - for (link = node->internal_links.first; link; link = nextlink) { - nextlink = link->next; - if (!link->fromnode || !link->fromsock || !link->tonode || !link->tosock) { - BLI_remlink(&node->internal_links, link); - } - } - } -} - static void do_version_logic_264(ListBase *regionbase) { ARegion *ar; @@ -7436,6 +7402,146 @@ static void do_versions_affine_tracker_track(MovieTrackingTrack *track) } } + +static const char *node_get_static_idname(int type, int treetype) +{ + /* use static type info header to map static int type to identifier string */ + #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \ + case ID: return #Category #StructName; + + /* XXX hack, group types share a single static integer identifier, but are registered as separate types */ + if (type == NODE_GROUP) { + switch (treetype) { + case NTREE_COMPOSIT: return "CompositorNodeGroup"; + case NTREE_SHADER: return "ShaderNodeGroup"; + case NTREE_TEXTURE: return "TextureNodeGroup"; + } + } + else { + switch (type) { + #include "NOD_static_types.h" + } + } + return ""; +} + +static const char *node_socket_get_static_idname(bNodeSocket *sock) +{ + switch (sock->type) { + case SOCK_FLOAT: { + bNodeSocketValueFloat *dval = sock->default_value; + return nodeStaticSocketType(SOCK_FLOAT, dval->subtype); + } + case SOCK_INT: { + bNodeSocketValueInt *dval = sock->default_value; + return nodeStaticSocketType(SOCK_INT, dval->subtype); + } + case SOCK_BOOLEAN: { + return nodeStaticSocketType(SOCK_BOOLEAN, PROP_NONE); + } + case SOCK_VECTOR: { + bNodeSocketValueVector *dval = sock->default_value; + return nodeStaticSocketType(SOCK_VECTOR, dval->subtype); + } + case SOCK_RGBA: { + return nodeStaticSocketType(SOCK_RGBA, PROP_NONE); + } + case SOCK_STRING: { + bNodeSocketValueString *dval = sock->default_value; + return nodeStaticSocketType(SOCK_STRING, dval->subtype); + } + case SOCK_SHADER: { + return nodeStaticSocketType(SOCK_SHADER, PROP_NONE); + } + } + return ""; +} + +static void do_versions_nodetree_customnodes(bNodeTree *ntree, int UNUSED(is_group)) +{ + /* initialize node tree type idname */ + { + bNode *node; + bNodeSocket *sock; + + ntree->typeinfo = NULL; + + /* tree type idname */ + switch (ntree->type) { + case NTREE_COMPOSIT: + strcpy(ntree->idname, "CompositorNodeTree"); + break; + case NTREE_SHADER: + strcpy(ntree->idname, "ShaderNodeTree"); + break; + case NTREE_TEXTURE: + strcpy(ntree->idname, "TextureNodeTree"); + break; + } + + /* node type idname */ + for (node=ntree->nodes.first; node; node=node->next) { + BLI_strncpy(node->idname, node_get_static_idname(node->type, ntree->type), sizeof(node->idname)); + + /* existing old nodes have been initialized already */ + node->flag |= NODE_INIT; + + /* sockets idname */ + for (sock=node->inputs.first; sock; sock=sock->next) + BLI_strncpy(sock->idname, node_socket_get_static_idname(sock), sizeof(sock->idname)); + for (sock=node->outputs.first; sock; sock=sock->next) + BLI_strncpy(sock->idname, node_socket_get_static_idname(sock), sizeof(sock->idname)); + } + /* tree sockets idname */ + for (sock=ntree->inputs.first; sock; sock=sock->next) + BLI_strncpy(sock->idname, node_socket_get_static_idname(sock), sizeof(sock->idname)); + for (sock=ntree->outputs.first; sock; sock=sock->next) + BLI_strncpy(sock->idname, node_socket_get_static_idname(sock), sizeof(sock->idname)); + } + + /* initialize socket in_out values */ + { + bNode *node; + bNodeSocket *sock; + + for (node=ntree->nodes.first; node; node=node->next) { + for (sock=node->inputs.first; sock; sock=sock->next) + sock->in_out = SOCK_IN; + for (sock=node->outputs.first; sock; sock=sock->next) + sock->in_out = SOCK_OUT; + } + for (sock=ntree->inputs.first; sock; sock=sock->next) + sock->in_out = SOCK_IN; + for (sock=ntree->outputs.first; sock; sock=sock->next) + sock->in_out = SOCK_OUT; + } + + /* initialize socket identifier strings */ + { + bNode *node; + bNodeSocket *sock; + + for (node=ntree->nodes.first; node; node=node->next) { + for (sock=node->inputs.first; sock; sock=sock->next) { + BLI_strncpy(sock->identifier, sock->name, sizeof(sock->identifier)); + BLI_uniquename(&node->inputs, sock, sock->identifier, '.', offsetof(bNodeSocket, identifier), sizeof(sock->identifier)); + } + for (sock=node->outputs.first; sock; sock=sock->next) { + BLI_strncpy(sock->identifier, sock->name, sizeof(sock->identifier)); + BLI_uniquename(&node->outputs, sock, sock->identifier, '.', offsetof(bNodeSocket, identifier), sizeof(sock->identifier)); + } + } + for (sock=ntree->inputs.first; sock; sock=sock->next) { + BLI_strncpy(sock->identifier, sock->name, sizeof(sock->identifier)); + BLI_uniquename(&ntree->inputs, sock, sock->identifier, '.', offsetof(bNodeSocket, identifier), sizeof(sock->identifier)); + } + for (sock=ntree->outputs.first; sock; sock=sock->next) { + BLI_strncpy(sock->identifier, sock->name, sizeof(sock->identifier)); + BLI_uniquename(&ntree->outputs, sock, sock->identifier, '.', offsetof(bNodeSocket, identifier), sizeof(sock->identifier)); + } + } +} + /* initialize userdef with non-UI dependency stuff */ /* other initializers (such as theme color defaults) go to resources.c */ static void do_versions_userdef(FileData *fd, BlendFileData *bfd) @@ -7451,7 +7557,6 @@ static void do_versions_userdef(FileData *fd, BlendFileData *bfd) user->image_gpubuffer_limit = 10; } } - static void do_versions(FileData *fd, Library *lib, Main *main) { /* WATCH IT!!!: pointers from libdata have not been converted */ @@ -7517,10 +7622,21 @@ static void do_versions(FileData *fd, Library *lib, Main *main) } if (main->versionfile < 260 || (main->versionfile == 260 && main->subversionfile < 2)) { - bNodeTreeType *ntreetype = ntreeGetType(NTREE_SHADER); - - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(main, NULL, do_version_ntree_tex_mapping_260); + FOREACH_NODETREE(main, ntree, id) { + if (ntree->type == NTREE_SHADER) { + bNode *node; + for (node = ntree->nodes.first; node; node = node->next) { + if (node->type == SH_NODE_MAPPING) { + TexMapping *tex_mapping; + + tex_mapping= node->storage; + tex_mapping->projx= PROJ_X; + tex_mapping->projy= PROJ_Y; + tex_mapping->projz= PROJ_Z; + } + } + } + } FOREACH_NODETREE_END } if (main->versionfile < 260 || (main->versionfile == 260 && main->subversionfile < 4)) { @@ -8156,16 +8272,26 @@ static void do_versions(FileData *fd, Library *lib, Main *main) } if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 9)) { - bNodeTreeType *ntreetype = ntreeGetType(NTREE_SHADER); - - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(main, NULL, do_version_ntree_image_user_264); + FOREACH_NODETREE(main, ntree, id) { + if (ntree->type == NTREE_SHADER) { + bNode *node; + for (node = ntree->nodes.first; node; node = node->next) { + if (ELEM(node->type, SH_NODE_TEX_IMAGE, SH_NODE_TEX_ENVIRONMENT)) { + NodeTexImage *tex = node->storage; + + tex->iuser.frames= 1; + tex->iuser.sfra= 1; + tex->iuser.fie_ima= 2; + tex->iuser.ok= 1; + } + } + } + } FOREACH_NODETREE_END } if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 10)) { { Scene *scene; - bNodeTreeType *ntreetype; // composite redesign for (scene=main->scene.first; scene; scene=scene->id.next) { if (scene->nodetree) { @@ -8174,11 +8300,20 @@ static void do_versions(FileData *fd, Library *lib, Main *main) } } } - ntreetype = ntreeGetType(NTREE_COMPOSIT); - - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(main, NULL, do_version_ntree_defocus_264); + FOREACH_NODETREE(main, ntree, id) { + if (ntree->type == NTREE_COMPOSIT) { + bNode *node; + for (node = ntree->nodes.first; node; node = node->next) { + if (node->type == CMP_NODE_DEFOCUS) { + NodeDefocus *data = node->storage; + if (data->maxblur == 0.0f) { + data->maxblur = 16.0f; + } + } + } + } + } FOREACH_NODETREE_END } { @@ -8236,19 +8371,40 @@ static void do_versions(FileData *fd, Library *lib, Main *main) } if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 13)) { - bNodeTreeType *ntreetype = ntreeGetType(NTREE_COMPOSIT); - - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(main, NULL, do_version_ntree_dilateerode_264); + FOREACH_NODETREE(main, ntree, id) { + if (ntree->type == NTREE_COMPOSIT) { + bNode *node; + for (node = ntree->nodes.first; node; node = node->next) { + if (node->type == CMP_NODE_DILATEERODE) { + if (node->storage == NULL) { + NodeDilateErode *data = MEM_callocN(sizeof(NodeDilateErode), __func__); + data->falloff = PROP_SMOOTH; + node->storage = data; + } + } + } + } + } FOREACH_NODETREE_END } if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 14)) { ParticleSettings *part; - bNodeTreeType *ntreetype = ntreeGetType(NTREE_COMPOSIT); - - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(main, NULL, do_version_ntree_keying_despill_balance); - + + FOREACH_NODETREE(main, ntree, id) { + if (ntree->type == NTREE_COMPOSIT) { + bNode *node; + for (node = ntree->nodes.first; node; node = node->next) { + if (node->type == CMP_NODE_KEYING) { + NodeKeyingData *data = node->storage; + + if (data->despill_balance == 0.0f) { + data->despill_balance = 0.5f; + } + } + } + } + } FOREACH_NODETREE_END + /* keep compatibility for dupliobject particle size */ for (part=main->particle.first; part; part=part->id.next) if (ELEM(part->ren_as, PART_DRAW_OB, PART_DRAW_GR)) @@ -8257,12 +8413,25 @@ static void do_versions(FileData *fd, Library *lib, Main *main) } if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 17)) { - bNodeTreeType *ntreetype = ntreeGetType(NTREE_COMPOSIT); - - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(main, NULL, do_version_ntree_mask_264); + FOREACH_NODETREE(main, ntree, id) { + if (ntree->type == NTREE_COMPOSIT) { + bNode *node; + for (node = ntree->nodes.first; node; node = node->next) { + if (node->type == CMP_NODE_MASK) { + if (node->storage == NULL) { + NodeMask *data = MEM_callocN(sizeof(NodeMask), __func__); + /* move settings into own struct */ + data->size_x = (int)node->custom3; + data->size_y = (int)node->custom4; + node->custom3 = 0.5f; /* default shutter */ + node->storage = data; + } + } + } + } + } FOREACH_NODETREE_END } - + if (main->versionfile < 263 || (main->versionfile == 263 && main->subversionfile < 18)) { Scene *scene; @@ -8387,15 +8556,14 @@ static void do_versions(FileData *fd, Library *lib, Main *main) } if (main->versionfile < 264 || (main->versionfile == 264 && main->subversionfile < 1)) { - bNodeTreeType *ntreetype = ntreeGetType(NTREE_SHADER); - bNodeTree *ntree; - - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(main, NULL, do_version_ntree_tex_coord_from_dupli_264); - - for (ntree=main->nodetree.first; ntree; ntree=ntree->id.next) - if (ntree->type==NTREE_SHADER) - do_version_ntree_tex_coord_from_dupli_264(NULL, NULL, ntree); + FOREACH_NODETREE(main, ntree, id) { + if (ntree->type == NTREE_SHADER) { + bNode *node; + for (node = ntree->nodes.first; node; node = node->next) + if (node->type == SH_NODE_TEX_COORD) + node->flag |= NODE_OPTIONS; + } + } FOREACH_NODETREE_END } if (main->versionfile < 264 || (main->versionfile == 264 && main->subversionfile < 2)) { @@ -8481,28 +8649,6 @@ static void do_versions(FileData *fd, Library *lib, Main *main) } } - if (main->versionfile < 264 || (main->versionfile == 264 && main->subversionfile < 4)) { - /* Fix for old node flags: Apparently the SOCK_DYNAMIC flag has been in use for other - * purposes before and then removed and later reused for SOCK_DYNAMIC. This socket should - * only be used by certain node types which don't use template lists, cleaning this up here. - */ - bNodeTreeType *ntreetype; - bNodeTree *ntree; - - ntreetype = ntreeGetType(NTREE_COMPOSIT); - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(main, NULL, do_version_node_cleanup_dynamic_sockets_264); - ntreetype = ntreeGetType(NTREE_SHADER); - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(main, NULL, do_version_node_cleanup_dynamic_sockets_264); - ntreetype = ntreeGetType(NTREE_TEXTURE); - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(main, NULL, do_version_node_cleanup_dynamic_sockets_264); - - for (ntree=main->nodetree.first; ntree; ntree=ntree->id.next) - do_version_node_cleanup_dynamic_sockets_264(NULL, NULL, ntree); - } - if (main->versionfile < 264 || (main->versionfile == 264 && main->subversionfile < 5)) { /* set a unwrapping margin and ABF by default */ Scene *scene; @@ -8519,22 +8665,19 @@ static void do_versions(FileData *fd, Library *lib, Main *main) /* Fix for bug #32982, internal_links list could get corrupted from r51630 onward. * Simply remove bad internal_links lists to avoid NULL pointers. */ - bNodeTreeType *ntreetype; - bNodeTree *ntree; - - ntreetype = ntreeGetType(NTREE_COMPOSIT); - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(main, NULL, do_version_node_fix_internal_links_264); - ntreetype = ntreeGetType(NTREE_SHADER); - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(main, NULL, do_version_node_fix_internal_links_264); - ntreetype = ntreeGetType(NTREE_TEXTURE); - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(main, NULL, do_version_node_fix_internal_links_264); - - for (ntree=main->nodetree.first; ntree; ntree=ntree->id.next) - do_version_node_fix_internal_links_264(NULL, NULL, ntree); - + FOREACH_NODETREE(main, ntree, id) + bNode *node; + bNodeLink *link, *nextlink; + + for (node = ntree->nodes.first; node; node = node->next) { + for (link = node->internal_links.first; link; link = nextlink) { + nextlink = link->next; + if (!link->fromnode || !link->fromsock || !link->tonode || !link->tosock) { + BLI_remlink(&node->internal_links, link); + } + } + } + FOREACH_NODETREE_END } if (main->versionfile < 264 || (main->versionfile == 264 && main->subversionfile < 6)) { @@ -8678,8 +8821,6 @@ static void do_versions(FileData *fd, Library *lib, Main *main) Scene *scene; Image *image; Tex *tex; - bNodeTreeType *ntreetype; - bNodeTree *ntree; for (scene = main->scene.first; scene; scene = scene->id.next) { Sequence *seq; @@ -8735,12 +8876,21 @@ static void do_versions(FileData *fd, Library *lib, Main *main) } } - ntreetype = ntreeGetType(NTREE_COMPOSIT); - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(main, fd, do_version_node_straight_image_alpha_workaround); + FOREACH_NODETREE(main, ntree, id) { + if (ntree->type == NTREE_COMPOSIT) { + bNode *node; + for (node = ntree->nodes.first; node; node = node->next) { + if (node->type == CMP_NODE_IMAGE) { + Image *image = blo_do_versions_newlibadr(fd, ntree->id.lib, node->id); - for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next) - do_version_node_straight_image_alpha_workaround(fd, NULL, ntree); + if (image) { + if ((image->flag & IMA_DO_PREMUL) == 0 && image->alpha_mode == IMA_ALPHA_STRAIGHT) + node->custom1 |= CMP_NODE_IMAGE_USE_STRAIGHT_OUTPUT; + } + } + } + } + } FOREACH_NODETREE_END } else if (main->versionfile < 266 || (main->versionfile == 266 && main->subversionfile < 1)) { /* texture use alpha was removed for 2.66 but added back again for 2.66a, @@ -8805,15 +8955,76 @@ static void do_versions(FileData *fd, Library *lib, Main *main) // add storage for compositor translate nodes when not existing if (MAIN_VERSION_OLDER(main, 265, 11)) { - bNodeTreeType *ntreetype; - bNodeTree *ntree; + FOREACH_NODETREE(main, ntree, id) { + if (ntree->type == NTREE_COMPOSIT) { + bNode *node; + for (node = ntree->nodes.first; node; node = node->next) { + if (node->type == CMP_NODE_TRANSLATE && node->storage == NULL) { + node->storage = MEM_callocN(sizeof(NodeTranslateData), "node translate data"); + } + } + } + } FOREACH_NODETREE_END + } - ntreetype = ntreeGetType(NTREE_COMPOSIT); - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(main, NULL, do_version_node_fix_translate_wrapping); + if (!MAIN_VERSION_ATLEAST(main, 266, 2)) { + FOREACH_NODETREE(main, ntree, id) { + do_versions_nodetree_customnodes(ntree, ((ID *)ntree == id)); + } FOREACH_NODETREE_END + } - for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next) - do_version_node_fix_translate_wrapping(NULL, NULL, ntree); + if (!MAIN_VERSION_ATLEAST(main, 266, 2)) { + bScreen *sc; + for (sc= main->screen.first; sc; sc= sc->id.next) { + ScrArea *sa; + for (sa= sc->areabase.first; sa; sa= sa->next) { + SpaceLink *sl; + for (sl= sa->spacedata.first; sl; sl= sl->next) { + if(sl->spacetype==SPACE_NODE) { + SpaceNode *snode = (SpaceNode *)sl; + + /* reset pointers to force tree path update from context */ + snode->nodetree = NULL; + snode->edittree = NULL; + snode->id = NULL; + snode->from = NULL; + + /* convert deprecated treetype setting to tree_idname */ + switch (snode->treetype) { + case NTREE_COMPOSIT: + strcpy(snode->tree_idname, "CompositorNodeTree"); + break; + case NTREE_SHADER: + strcpy(snode->tree_idname, "ShaderNodeTree"); + break; + case NTREE_TEXTURE: + strcpy(snode->tree_idname, "TextureNodeTree"); + break; + } + } + } + } + } + } + + /* Set flag for delayed do_versions in lib_verify_nodetree. It needs valid typeinfo pointers ... */ + { + bNodeTree *ntree; + for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next) { + /* XXX This should be kept without version check for now! + * As long as USE_NODE_COMPAT_CUSTOMNODES is active, files will write links + * to tree interface sockets for forward compatibility. These links need to be removed again + * on file load in new versions. + * Once forward compatibility is not required any longer, make a subversion bump + * and only execute this for older versions. + */ + ntree->flag |= NTREE_DO_VERSIONS_CUSTOMNODES_GROUP; + + /* Only add interface nodes once. + * In old Blender versions they will be removed automatically due to undefined type */ + if (!MAIN_VERSION_ATLEAST(main, 266, 2)) + ntree->flag |= NTREE_DO_VERSIONS_CUSTOMNODES_GROUP_CREATE_INTERFACE; + } } if (main->versionfile < 267) { diff --git a/source/blender/blenloader/intern/readfile.h b/source/blender/blenloader/intern/readfile.h index 46b95434e53..6d5fc056d89 100644 --- a/source/blender/blenloader/intern/readfile.h +++ b/source/blender/blenloader/intern/readfile.h @@ -152,7 +152,6 @@ void *blo_do_versions_newlibadr_us(struct FileData *fd, void *lib, void *adr); struct PartEff *blo_do_version_give_parteff_245(struct Object *ob); void blo_do_version_old_trackto_to_constraints(struct Object *ob); void blo_do_versions_view3d_split_250(struct View3D *v3d, struct ListBase *regions); -void blo_do_versions_nodetree_default_value(struct bNodeTree *ntree); void blo_do_versions_pre250(struct FileData *fd, struct Library *lib, struct Main *main); void blo_do_versions_250(struct FileData *fd, struct Library *lib, struct Main *main); diff --git a/source/blender/blenloader/intern/versioning_250.c b/source/blender/blenloader/intern/versioning_250.c index 36f3ea3654c..f92a8678300 100644 --- a/source/blender/blenloader/intern/versioning_250.c +++ b/source/blender/blenloader/intern/versioning_250.c @@ -672,13 +672,90 @@ static void do_version_bone_roll_256(Bone *bone) do_version_bone_roll_256(child); } -static void do_versions_nodetree_dynamic_sockets(bNodeTree *ntree) +/* deprecated, only keep this for readfile.c */ +/* XXX Deprecated function to add a socket in ntree->inputs/ntree->outputs list + * (previously called node_group_add_socket). This function has been superseded + * by the implementation of proxy nodes. It is still necessary though + * for do_versions of pre-2.56.2 code (r35033), so later proxy nodes + * can be generated consistently from ntree socket lists. + */ +static bNodeSocket *do_versions_node_group_add_socket_2_56_2(bNodeTree *ngroup, const char *name, int type, int in_out) +{ +// bNodeSocketType *stype = ntreeGetSocketType(type); + bNodeSocket *gsock = MEM_callocN(sizeof(bNodeSocket), "bNodeSocket"); + + BLI_strncpy(gsock->name, name, sizeof(gsock->name)); + gsock->type = type; + + gsock->next = gsock->prev = NULL; + gsock->new_sock = NULL; + gsock->link = NULL; + /* assign new unique index */ + gsock->own_index = ngroup->cur_index++; + gsock->limit = (in_out==SOCK_IN ? 0xFFF : 1); + +// if (stype->value_structsize > 0) +// gsock->default_value = MEM_callocN(stype->value_structsize, "default socket value"); + + BLI_addtail(in_out==SOCK_IN ? &ngroup->inputs : &ngroup->outputs, gsock); + + ngroup->update |= (in_out==SOCK_IN ? NTREE_UPDATE_GROUP_IN : NTREE_UPDATE_GROUP_OUT); + + return gsock; +} + +/* Create default_value structs for node sockets from the internal bNodeStack value. + * These structs were used from 2.59.2 on, but are replaced in the subsequent do_versions for custom nodes + * by generic ID property values. This conversion happened _after_ do_versions originally due to messy type initialization + * for node sockets. Now created here intermediately for convenience and to keep do_versions consistent. + * + * Node compatibility code is gross ... + */ +static void do_versions_socket_default_value_259(bNodeSocket *sock) +{ + bNodeSocketValueFloat *valfloat; + bNodeSocketValueVector *valvector; + bNodeSocketValueRGBA *valrgba; + + if (sock->default_value) + return; + + switch (sock->type) { + case SOCK_FLOAT: + valfloat = sock->default_value = MEM_callocN(sizeof(bNodeSocketValueFloat), "default socket value"); + valfloat->value = sock->ns.vec[0]; + valfloat->min = sock->ns.min; + valfloat->max = sock->ns.max; + valfloat->subtype = PROP_NONE; + break; + case SOCK_VECTOR: + valvector = sock->default_value = MEM_callocN(sizeof(bNodeSocketValueVector), "default socket value"); + copy_v3_v3(valvector->value, sock->ns.vec); + valvector->min = sock->ns.min; + valvector->max = sock->ns.max; + valvector->subtype = PROP_NONE; + break; + case SOCK_RGBA: + valrgba = sock->default_value = MEM_callocN(sizeof(bNodeSocketValueRGBA), "default socket value"); + copy_v4_v4(valrgba->value, sock->ns.vec); + break; + } +} + +static void do_versions_nodetree_default_value_259(bNodeTree *ntree) { + bNode *node; bNodeSocket *sock; - for (sock = ntree->inputs.first; sock; sock = sock->next) - sock->flag |= SOCK_DYNAMIC; - for (sock = ntree->outputs.first; sock; sock = sock->next) - sock->flag |= SOCK_DYNAMIC; + for (node=ntree->nodes.first; node; node=node->next) { + for (sock=node->inputs.first; sock; sock=sock->next) + do_versions_socket_default_value_259(sock); + for (sock=node->outputs.first; sock; sock=sock->next) + do_versions_socket_default_value_259(sock); + } + for (sock=ntree->inputs.first; sock; sock=sock->next) + do_versions_socket_default_value_259(sock); + for (sock=ntree->outputs.first; sock; sock=sock->next) + do_versions_socket_default_value_259(sock); } void blo_do_versions_250(FileData *fd, Library *lib, Main *main) @@ -2289,16 +2366,79 @@ void blo_do_versions_250(FileData *fd, Library *lib, Main *main) if (main->versionfile < 256 || (main->versionfile == 256 && main->subversionfile < 2)) { bNodeTree *ntree; - + bNode *node; + bNodeSocket *sock, *gsock; + bNodeLink *link; + /* node sockets are not exposed automatically any more, * this mimics the old behavior by adding all unlinked sockets to groups. */ - for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next) { - /* XXX Only setting a flag here. Actual adding of group sockets - * is done in lib_verify_nodetree, because at this point the internal - * nodes may not be up-to-date! (missing lib-link) + for (ntree=main->nodetree.first; ntree; ntree=ntree->id.next) { + /* this adds copies and links from all unlinked internal sockets to group inputs/outputs. */ + + /* first make sure the own_index for new sockets is valid */ + for (node=ntree->nodes.first; node; node=node->next) { + for (sock=node->inputs.first; sock; sock=sock->next) + if (sock->own_index >= ntree->cur_index) + ntree->cur_index = sock->own_index+1; + for (sock=node->outputs.first; sock; sock=sock->next) + if (sock->own_index >= ntree->cur_index) + ntree->cur_index = sock->own_index+1; + } + + /* add ntree->inputs/ntree->outputs sockets for all unlinked sockets in the group tree. */ + for (node=ntree->nodes.first; node; node=node->next) { + for (sock=node->inputs.first; sock; sock=sock->next) { + if (!sock->link && !nodeSocketIsHidden(sock)) { + + gsock = do_versions_node_group_add_socket_2_56_2(ntree, sock->name, sock->type, SOCK_IN); + + /* initialize the default socket value */ + copy_v4_v4(gsock->ns.vec, sock->ns.vec); + + /* XXX nodeAddLink does not work with incomplete (node==NULL) links any longer, + * have to create these directly here. These links are updated again in subsequent do_version! + */ + link= MEM_callocN(sizeof(bNodeLink), "link"); + BLI_addtail(&ntree->links, link); + link->fromnode= NULL; + link->fromsock= gsock; + link->tonode= node; + link->tosock= sock; + ntree->update |= NTREE_UPDATE_LINKS; + + sock->link = link; + } + } + for (sock=node->outputs.first; sock; sock=sock->next) { + if (nodeCountSocketLinks(ntree, sock)==0 && !nodeSocketIsHidden(sock)) { + gsock = do_versions_node_group_add_socket_2_56_2(ntree, sock->name, sock->type, SOCK_OUT); + + /* initialize the default socket value */ + copy_v4_v4(gsock->ns.vec, sock->ns.vec); + + /* XXX nodeAddLink does not work with incomplete (node==NULL) links any longer, + * have to create these directly here. These links are updated again in subsequent do_version! + */ + link= MEM_callocN(sizeof(bNodeLink), "link"); + BLI_addtail(&ntree->links, link); + link->fromnode= node; + link->fromsock= sock; + link->tonode= NULL; + link->tosock= gsock; + ntree->update |= NTREE_UPDATE_LINKS; + + gsock->link = link; + } + } + } + + /* XXX The external group node sockets needs to adjust their own_index to point at + * associated ntree inputs/outputs internal sockets. However, this can only happen + * after lib-linking (needs access to internal node group tree)! + * Setting a temporary flag here, actual do_versions happens in lib_verify_nodetree. */ - ntree->flag |= NTREE_DO_VERSIONS_GROUP_EXPOSE; + ntree->flag |= NTREE_DO_VERSIONS_GROUP_EXPOSE_2_56_2; } } @@ -2601,39 +2741,29 @@ void blo_do_versions_250(FileData *fd, Library *lib, Main *main) bNodeTree *ntree; for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next) { - blo_do_versions_nodetree_default_value(ntree); + do_versions_nodetree_default_value_259(ntree); ntree->update |= NTREE_UPDATE; } for (sce = main->scene.first; sce; sce = sce->id.next) if (sce->nodetree) { - blo_do_versions_nodetree_default_value(sce->nodetree); + do_versions_nodetree_default_value_259(sce->nodetree); sce->nodetree->update |= NTREE_UPDATE; } for (mat = main->mat.first; mat; mat = mat->id.next) if (mat->nodetree) { - blo_do_versions_nodetree_default_value(mat->nodetree); + do_versions_nodetree_default_value_259(mat->nodetree); mat->nodetree->update |= NTREE_UPDATE; } for (tex = main->tex.first; tex; tex = tex->id.next) if (tex->nodetree) { - blo_do_versions_nodetree_default_value(tex->nodetree); + do_versions_nodetree_default_value_259(tex->nodetree); tex->nodetree->update |= NTREE_UPDATE; } } - /* add SOCK_DYNAMIC flag to existing group sockets */ - { - bNodeTree *ntree; - /* only need to do this for trees in main, local trees are not used as groups */ - for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next) { - do_versions_nodetree_dynamic_sockets(ntree); - ntree->update |= NTREE_UPDATE; - } - } - { /* Initialize group tree nodetypes. * These are used to distinguish tree types and diff --git a/source/blender/blenloader/intern/writefile.c b/source/blender/blenloader/intern/writefile.c index 4f7ec77a8e6..d78c6687e16 100644 --- a/source/blender/blenloader/intern/writefile.c +++ b/source/blender/blenloader/intern/writefile.c @@ -74,6 +74,7 @@ #include <math.h> #include <fcntl.h> +#include <limits.h> #include <stdio.h> #include <string.h> #include <stdlib.h> @@ -151,6 +152,7 @@ #include "BKE_curve.h" #include "BKE_constraint.h" #include "BKE_global.h" // for G +#include "BKE_idprop.h" #include "BKE_library.h" // for set_listbasepointers #include "BKE_main.h" #include "BKE_node.h" @@ -162,6 +164,13 @@ #include "BKE_pointcache.h" #include "BKE_mesh.h" +#ifdef USE_NODE_COMPAT_CUSTOMNODES +#include "NOD_common.h" +#include "NOD_socket.h" /* for sock->default_value data */ +#endif + +#include "RNA_access.h" + #include "BLO_writefile.h" #include "BLO_readfile.h" #include "BLO_undofile.h" @@ -670,46 +679,54 @@ static void write_curvemapping(WriteData *wd, CurveMapping *cumap) write_curvemapping_curves(wd, cumap); } -static void write_node_socket(WriteData *wd, bNodeSocket *sock) +static void write_node_socket(WriteData *wd, bNodeTree *UNUSED(ntree), bNode *node, bNodeSocket *sock) { - bNodeSocketType *stype= ntreeGetSocketType(sock->type); - +#ifdef USE_NODE_COMPAT_CUSTOMNODES /* forward compatibility code, so older blenders still open */ sock->stack_type = 1; - if (sock->default_value) { - bNodeSocketValueFloat *valfloat; - bNodeSocketValueVector *valvector; - bNodeSocketValueRGBA *valrgba; - - switch (sock->type) { - case SOCK_FLOAT: - valfloat = sock->default_value; - sock->ns.vec[0] = valfloat->value; - sock->ns.min = valfloat->min; - sock->ns.max = valfloat->max; - break; - case SOCK_VECTOR: - valvector = sock->default_value; - copy_v3_v3(sock->ns.vec, valvector->value); - sock->ns.min = valvector->min; - sock->ns.max = valvector->max; - break; - case SOCK_RGBA: - valrgba = sock->default_value; - copy_v4_v4(sock->ns.vec, valrgba->value); - sock->ns.min = 0.0f; - sock->ns.max = 1.0f; - break; + if (node->type == NODE_GROUP) { + bNodeTree *ngroup = (bNodeTree *)node->id; + if (ngroup) { + /* for node groups: look up the deprecated groupsock pointer */ + sock->groupsock = ntreeFindSocketInterface(ngroup, sock->in_out, sock->identifier); + BLI_assert(sock->groupsock != NULL); + + /* node group sockets now use the generic identifier string to verify group nodes, + * old blender uses the own_index. + */ + sock->own_index = sock->groupsock->own_index; } } +#endif /* actual socket writing */ writestruct(wd, DATA, "bNodeSocket", 1, sock); + + if (sock->prop) + IDP_WriteProperty(sock->prop, wd); + if (sock->default_value) - writestruct(wd, DATA, stype->value_structname, 1, sock->default_value); + writedata(wd, DATA, MEM_allocN_len(sock->default_value), sock->default_value); } +static void write_node_socket_interface(WriteData *wd, bNodeTree *UNUSED(ntree), bNodeSocket *sock) +{ +#ifdef USE_NODE_COMPAT_CUSTOMNODES + /* forward compatibility code, so older blenders still open */ + sock->stack_type = 1; + + /* Reconstruct the deprecated default_value structs in socket interface DNA. */ + if (sock->default_value == NULL && sock->typeinfo) { + node_socket_init_default_value(sock); + } +#endif + /* actual socket writing */ + writestruct(wd, DATA, "bNodeSocket", 1, sock); + + if (sock->prop) + IDP_WriteProperty(sock->prop, wd); +} /* this is only direct data, tree itself should have been written */ static void write_nodetree(WriteData *wd, bNodeTree *ntree) { @@ -721,18 +738,19 @@ static void write_nodetree(WriteData *wd, bNodeTree *ntree) if (ntree->adt) write_animdata(wd, ntree->adt); - for (node= ntree->nodes.first; node; node= node->next) + for (node= ntree->nodes.first; node; node= node->next) { writestruct(wd, DATA, "bNode", 1, node); - for (node= ntree->nodes.first; node; node= node->next) { + if (node->prop) + IDP_WriteProperty(node->prop, wd); + for (sock= node->inputs.first; sock; sock= sock->next) - write_node_socket(wd, sock); + write_node_socket(wd, ntree, node, sock); for (sock= node->outputs.first; sock; sock= sock->next) - write_node_socket(wd, sock); + write_node_socket(wd, ntree, node, sock); for (link = node->internal_links.first; link; link = link->next) writestruct(wd, DATA, "bNodeLink", 1, link); - if (node->storage) { /* could be handlerized at some point, now only 1 exception still */ if (ntree->type==NTREE_SHADER && (node->type==SH_NODE_CURVE_VEC || node->type==SH_NODE_CURVE_RGB)) @@ -741,10 +759,6 @@ static void write_nodetree(WriteData *wd, bNodeTree *ntree) NodeShaderScript *nss = (NodeShaderScript *)node->storage; if (nss->bytecode) writedata(wd, DATA, strlen(nss->bytecode)+1, nss->bytecode); - /* Write ID Properties -- and copy this comment EXACTLY for easy finding - * of library blocks that implement this.*/ - if (nss->prop) - IDP_WriteProperty(nss->prop, wd); writestruct(wd, DATA, node->typeinfo->storagename, 1, node->storage); } else if (ntree->type==NTREE_COMPOSIT && ELEM4(node->type, CMP_NODE_TIME, CMP_NODE_CURVE_VEC, CMP_NODE_CURVE_RGB, CMP_NODE_HUECORRECT)) @@ -773,11 +787,10 @@ static void write_nodetree(WriteData *wd, bNodeTree *ntree) for (link= ntree->links.first; link; link= link->next) writestruct(wd, DATA, "bNodeLink", 1, link); - /* external sockets */ - for (sock= ntree->inputs.first; sock; sock= sock->next) - write_node_socket(wd, sock); - for (sock= ntree->outputs.first; sock; sock= sock->next) - write_node_socket(wd, sock); + for (sock = ntree->inputs.first; sock; sock = sock->next) + write_node_socket_interface(wd, ntree, sock); + for (sock = ntree->outputs.first; sock; sock = sock->next) + write_node_socket_interface(wd, ntree, sock); } static void current_screen_compat(Main *mainvar, bScreen **screen) @@ -2518,7 +2531,12 @@ static void write_screens(WriteData *wd, ListBase *scrbase) writestruct(wd, DATA, "SpaceTime", 1, sl); } else if (sl->spacetype==SPACE_NODE) { - writestruct(wd, DATA, "SpaceNode", 1, sl); + SpaceNode *snode = (SpaceNode *)sl; + bNodeTreePath *path; + writestruct(wd, DATA, "SpaceNode", 1, snode); + + for (path=snode->treepath.first; path; path=path->next) + writestruct(wd, DATA, "bNodeTreePath", 1, path); } else if (sl->spacetype==SPACE_LOGIC) { writestruct(wd, DATA, "SpaceLogic", 1, sl); @@ -2770,6 +2788,118 @@ static void write_nodetrees(WriteData *wd, ListBase *idbase) } } +#ifdef USE_NODE_COMPAT_CUSTOMNODES +static void customnodes_add_deprecated_nodetree_data(bNodeTree *ntree) +{ + bNodeLink *link, *last_link = ntree->links.last; + /* Forward compatibility for group nodes: add links to node tree interface sockets. + * These links are invalid by new rules (missing node pointer)! + * They will be removed again in customnodes_free_deprecated_data, + * cannot do this directly lest bNodeLink pointer mapping becomes ambiguous. + * When loading files with such links in a new Blender version + * they will be removed as well. + */ + for (link = ntree->links.first; link; link = link->next) { + bNode *fromnode = link->fromnode, *tonode = link->tonode; + bNodeSocket *fromsock = link->fromsock, *tosock = link->tosock; + + /* check both sides of the link, to handle direct input-to-output links */ + if (fromnode->type == NODE_GROUP_INPUT) { + fromnode = NULL; + fromsock = ntreeFindSocketInterface(ntree, SOCK_IN, fromsock->identifier); + } + /* only the active output node defines links */ + if (tonode->type == NODE_GROUP_OUTPUT && (tonode->flag & NODE_DO_OUTPUT)) { + tonode = NULL; + tosock = ntreeFindSocketInterface(ntree, SOCK_OUT, tosock->identifier); + } + + if (!fromnode || !tonode) { + /* Note: not using nodeAddLink here, it asserts existing node pointers */ + bNodeLink *tlink = MEM_callocN(sizeof(bNodeLink), "group node link"); + tlink->fromnode = fromnode; + tlink->fromsock = fromsock; + tlink->tonode = tonode; + tlink->tosock= tosock; + tosock->link = tlink; + tlink->flag |= NODE_LINK_VALID; + BLI_addtail(&ntree->links, tlink); + } + + /* don't check newly created compatibility links */ + if (link == last_link) + break; + } +} + +static void customnodes_add_deprecated_data(Main *mainvar) +{ + bNodeTree *ntree; + Scene *scene; + Material *mat; + World *world; + Lamp *lamp; + Tex *tex; + + for (ntree = mainvar->nodetree.first; ntree; ntree = ntree->id.next) + customnodes_add_deprecated_nodetree_data(ntree); + for (scene = mainvar->scene.first; scene; scene = scene->id.next) + if (scene->nodetree) + customnodes_add_deprecated_nodetree_data(scene->nodetree); + for (mat = mainvar->mat.first; mat; mat = mat->id.next) + if (mat->nodetree) + customnodes_add_deprecated_nodetree_data(mat->nodetree); + for (world = mainvar->world.first; world; world = world->id.next) + if (world->nodetree) + customnodes_add_deprecated_nodetree_data(world->nodetree); + for (lamp = mainvar->lamp.first; lamp; lamp = lamp->id.next) + if (lamp->nodetree) + customnodes_add_deprecated_nodetree_data(lamp->nodetree); + for (tex = mainvar->tex.first; tex; tex = tex->id.next) + if (tex->nodetree) + customnodes_add_deprecated_nodetree_data(tex->nodetree); +} + +static void customnodes_free_deprecated_nodetree_data(bNodeTree *ntree) +{ + bNodeLink *link, *next_link; + + for (link = ntree->links.first; link; link = next_link) { + next_link = link->next; + if (link->fromnode == NULL || link->tonode == NULL) + nodeRemLink(ntree, link); + } +} + +static void customnodes_free_deprecated_data(Main *mainvar) +{ + bNodeTree *ntree; + Scene *scene; + Material *mat; + World *world; + Lamp *lamp; + Tex *tex; + + for (ntree = mainvar->nodetree.first; ntree; ntree = ntree->id.next) + customnodes_free_deprecated_nodetree_data(ntree); + for (scene = mainvar->scene.first; scene; scene = scene->id.next) + if (scene->nodetree) + customnodes_free_deprecated_nodetree_data(scene->nodetree); + for (mat = mainvar->mat.first; mat; mat = mat->id.next) + if (mat->nodetree) + customnodes_free_deprecated_nodetree_data(mat->nodetree); + for (world = mainvar->world.first; world; world = world->id.next) + if (world->nodetree) + customnodes_free_deprecated_nodetree_data(world->nodetree); + for (lamp = mainvar->lamp.first; lamp; lamp = lamp->id.next) + if (lamp->nodetree) + customnodes_free_deprecated_nodetree_data(lamp->nodetree); + for (tex = mainvar->tex.first; tex; tex = tex->id.next) + if (tex->nodetree) + customnodes_free_deprecated_nodetree_data(tex->nodetree); +} +#endif + static void write_brushes(WriteData *wd, ListBase *idbase) { Brush *brush; @@ -2981,6 +3111,11 @@ static int write_file_handle(Main *mainvar, int handle, MemFile *compare, MemFil wd->use_mesh_compat = (write_flags & G_FILE_MESH_COMPAT) != 0; #endif +#ifdef USE_NODE_COMPAT_CUSTOMNODES + /* deprecated forward compat data is freed again below */ + customnodes_add_deprecated_data(mainvar); +#endif + sprintf(buf, "BLENDER%c%c%.3d", (sizeof(void*)==8)?'-':'_', (ENDIAN_ORDER==B_ENDIAN)?'V':'v', BLENDER_VERSION); mywrite(wd, buf, 12); @@ -3026,6 +3161,14 @@ static int write_file_handle(Main *mainvar, int handle, MemFile *compare, MemFil /* dna as last, because (to be implemented) test for which structs are written */ writedata(wd, DNA1, wd->sdna->datalen, wd->sdna->data); +#ifdef USE_NODE_COMPAT_CUSTOMNODES + /* Ugly, forward compatibility code generates deprecated data during writing, + * this has to be freed again. Can not be done directly after writing, otherwise + * the data pointers could be reused and not be mapped correctly. + */ + customnodes_free_deprecated_data(mainvar); +#endif + /* end of file */ memset(&bhead, 0, sizeof(BHead)); bhead.code= ENDB; diff --git a/source/blender/compositor/intern/COM_CompositorContext.cpp b/source/blender/compositor/intern/COM_CompositorContext.cpp index e1cc25d028a..6008a889205 100644 --- a/source/blender/compositor/intern/COM_CompositorContext.cpp +++ b/source/blender/compositor/intern/COM_CompositorContext.cpp @@ -29,7 +29,6 @@ CompositorContext::CompositorContext() this->m_rd = NULL; this->m_quality = COM_QUALITY_HIGH; this->m_hasActiveOpenCLDevices = false; - this->m_activegNode = NULL; this->m_fastCalculation = false; this->m_viewSettings = NULL; this->m_displaySettings = NULL; diff --git a/source/blender/compositor/intern/COM_CompositorContext.h b/source/blender/compositor/intern/COM_CompositorContext.h index 840a9e59584..3c7db703bf9 100644 --- a/source/blender/compositor/intern/COM_CompositorContext.h +++ b/source/blender/compositor/intern/COM_CompositorContext.h @@ -64,11 +64,12 @@ private: * @see ExecutionSystem */ bNodeTree *m_bnodetree; - + /** - * @brief activegNode the group node that is currently being edited. + * @brief Preview image hash table + * This field is initialized in ExecutionSystem and must only be read from that point on. */ - bNode *m_activegNode; + bNodeInstanceHash *m_previews; /** * @brief does this system have active opencl devices? @@ -115,19 +116,19 @@ public: const bNodeTree *getbNodeTree() const { return this->m_bnodetree; } /** - * @brief set the active groupnode of the context + * @brief get the scene of the context */ - void setActivegNode(bNode *gnode) { this->m_activegNode = gnode; } + const RenderData *getRenderData() const { return this->m_rd; } /** - * @brief get the active groupnode of the context + * @brief set the preview image hash table */ - const bNode *getActivegNode() const { return this->m_activegNode; } + void setPreviewHash(bNodeInstanceHash *previews) { this->m_previews = previews; } /** - * @brief get the scene of the context + * @brief get the preview image hash table */ - const RenderData *getRenderData() const { return this->m_rd; } + bNodeInstanceHash *getPreviewHash() const { return this->m_previews; } /** * @brief set view settings of color color management diff --git a/source/blender/compositor/intern/COM_Converter.cpp b/source/blender/compositor/intern/COM_Converter.cpp index 9c4a32f20c9..80f5b4fc149 100644 --- a/source/blender/compositor/intern/COM_Converter.cpp +++ b/source/blender/compositor/intern/COM_Converter.cpp @@ -124,7 +124,7 @@ Node *Converter::convert(bNode *b_node, bool fast) { - Node *node; + Node *node = NULL; if (b_node->flag & NODE_MUTED) { node = new MuteNode(b_node); @@ -226,6 +226,10 @@ Node *Converter::convert(bNode *b_node, bool fast) case NODE_GROUP: node = new GroupNode(b_node); break; + case NODE_GROUP_INPUT: + case NODE_GROUP_OUTPUT: + /* handled in GroupNode::ungroup */ + break; case CMP_NODE_NORMAL: node = new NormalNode(b_node); break; @@ -399,7 +403,6 @@ Node *Converter::convert(bNode *b_node, bool fast) node = new PixelateNode(b_node); break; default: - node = new MuteNode(b_node); break; } return node; diff --git a/source/blender/compositor/intern/COM_ExecutionSystem.cpp b/source/blender/compositor/intern/COM_ExecutionSystem.cpp index 2b2af73d0c8..2da1c34ab44 100644 --- a/source/blender/compositor/intern/COM_ExecutionSystem.cpp +++ b/source/blender/compositor/intern/COM_ExecutionSystem.cpp @@ -49,7 +49,9 @@ ExecutionSystem::ExecutionSystem(RenderData *rd, bNodeTree *editingtree, bool re const ColorManagedViewSettings *viewSettings, const ColorManagedDisplaySettings *displaySettings) { this->m_context.setbNodeTree(editingtree); + this->m_context.setPreviewHash(editingtree->previews); this->m_context.setFastCalculation(fastcalculation); +#if 0 /* XXX TODO find a better way to define visible output nodes from all editors */ bNode *gnode; for (gnode = (bNode *)editingtree->nodes.first; gnode; gnode = gnode->next) { if (gnode->type == NODE_GROUP && gnode->typeinfo->group_edit_get(gnode)) { @@ -57,6 +59,7 @@ ExecutionSystem::ExecutionSystem(RenderData *rd, bNodeTree *editingtree, bool re break; } } +#endif /* initialize the CompositorContext */ if (rendering) { @@ -68,7 +71,7 @@ ExecutionSystem::ExecutionSystem(RenderData *rd, bNodeTree *editingtree, bool re this->m_context.setRendering(rendering); this->m_context.setHasActiveOpenCLDevices(WorkScheduler::hasGPUDevices() && (editingtree->flag & NTREE_COM_OPENCL)); - ExecutionSystemHelper::addbNodeTree(*this, 0, editingtree, NULL); + ExecutionSystemHelper::addbNodeTree(*this, 0, editingtree, NODE_INSTANCE_KEY_BASE); this->m_context.setRenderData(rd); this->m_context.setViewSettings(viewSettings); diff --git a/source/blender/compositor/intern/COM_ExecutionSystemHelper.cpp b/source/blender/compositor/intern/COM_ExecutionSystemHelper.cpp index 506bd42ace3..ad396e053f2 100644 --- a/source/blender/compositor/intern/COM_ExecutionSystemHelper.cpp +++ b/source/blender/compositor/intern/COM_ExecutionSystemHelper.cpp @@ -26,7 +26,6 @@ #include <stdio.h> #include "PIL_time.h" -#include "BKE_node.h" #include "COM_Converter.h" #include "COM_NodeOperation.h" @@ -39,18 +38,25 @@ #include "COM_ReadBufferOperation.h" #include "COM_ViewerBaseOperation.h" -void ExecutionSystemHelper::addbNodeTree(ExecutionSystem &system, int nodes_start, bNodeTree *tree, bNode *groupnode) +extern "C" { +#include "BKE_node.h" +} + +void ExecutionSystemHelper::addbNodeTree(ExecutionSystem &system, int nodes_start, bNodeTree *tree, bNodeInstanceKey parent_key) { vector<Node *>& nodes = system.getNodes(); vector<SocketConnection *>& links = system.getConnections(); - const bNode *activeGroupNode = system.getContext().getActivegNode(); - bool isActiveGroup = activeGroupNode == groupnode; /* add all nodes of the tree to the node list */ bNode *node = (bNode *)tree->nodes.first; while (node != NULL) { + /* XXX TODO replace isActiveGroup by a more accurate check, all visible editors should do this! */ + bool isActiveGroup = true; Node *nnode = addNode(nodes, node, isActiveGroup, system.getContext().isFastCalculation()); - nnode->setbNodeGroup(groupnode); + if (nnode) { + nnode->setbNodeTree(tree); + nnode->setInstanceKey(BKE_node_instance_key(parent_key, tree, node)); + } node = node->next; } @@ -81,8 +87,10 @@ void ExecutionSystemHelper::addNode(vector<Node *>& nodes, Node *node) Node *ExecutionSystemHelper::addNode(vector<Node *>& nodes, bNode *b_node, bool inActiveGroup, bool fast) { Node *node = Converter::convert(b_node, fast); - node->setIsInActiveGroup(inActiveGroup); - addNode(nodes, node); + if (node) { + node->setIsInActiveGroup(inActiveGroup); + addNode(nodes, node); + } return node; } void ExecutionSystemHelper::addOperation(vector<NodeOperation *>& operations, NodeOperation *operation) @@ -109,43 +117,21 @@ void ExecutionSystemHelper::findOutputNodeOperations(vector<NodeOperation *> *re static InputSocket *find_input(NodeRange &node_range, bNode *bnode, bNodeSocket *bsocket) { - if (bnode != NULL) { - for (NodeIterator it = node_range.first; it != node_range.second; ++it) { - Node *node = *it; - if (node->getbNode() == bnode) - return node->findInputSocketBybNodeSocket(bsocket); - } - } - else { - for (NodeIterator it = node_range.first; it != node_range.second; ++it) { - Node *node = *it; - if (node->isProxyNode()) { - InputSocket *proxySocket = node->getInputSocket(0); - if (proxySocket->getbNodeSocket() == bsocket) - return proxySocket; - } - } + for (NodeIterator it = node_range.first; it != node_range.second; ++it) { + Node *node = *it; + InputSocket *input = node->findInputSocketBybNodeSocket(bsocket); + if (input) + return input; } return NULL; } static OutputSocket *find_output(NodeRange &node_range, bNode *bnode, bNodeSocket *bsocket) { - if (bnode != NULL) { - for (NodeIterator it = node_range.first; it != node_range.second; ++it) { - Node *node = *it; - if (node->getbNode() == bnode) - return node->findOutputSocketBybNodeSocket(bsocket); - } - } - else { - for (NodeIterator it = node_range.first; it != node_range.second; ++it) { - Node *node = *it; - if (node->isProxyNode()) { - OutputSocket *proxySocket = node->getOutputSocket(0); - if (proxySocket->getbNodeSocket() == bsocket) - return proxySocket; - } - } + for (NodeIterator it = node_range.first; it != node_range.second; ++it) { + Node *node = *it; + OutputSocket *output = node->findOutputSocketBybNodeSocket(bsocket); + if (output) + return output; } return NULL; } @@ -190,7 +176,7 @@ void ExecutionSystemHelper::debugDump(ExecutionSystem *system) tot = system->getNodes().size(); for (int i = 0; i < tot; i++) { node = system->getNodes()[i]; - printf("// NODE: %s\r\n", node->getbNode()->typeinfo->name); + printf("// NODE: %s\r\n", node->getbNode()->typeinfo->ui_name); } tot = system->getOperations().size(); for (int i = 0; i < tot; i++) { diff --git a/source/blender/compositor/intern/COM_ExecutionSystemHelper.h b/source/blender/compositor/intern/COM_ExecutionSystemHelper.h index 307e082ea80..e05796b9127 100644 --- a/source/blender/compositor/intern/COM_ExecutionSystemHelper.h +++ b/source/blender/compositor/intern/COM_ExecutionSystemHelper.h @@ -48,7 +48,7 @@ public: * @param tree bNodeTree to add * @return Node representing the "Compositor node" of the maintree. or NULL when a subtree is added */ - static void addbNodeTree(ExecutionSystem &system, int nodes_start, bNodeTree *tree, bNode *groupnode); + static void addbNodeTree(ExecutionSystem &system, int nodes_start, bNodeTree *tree, bNodeInstanceKey parent_key); /** * @brief add an editor node to the system. diff --git a/source/blender/compositor/intern/COM_InputSocket.cpp b/source/blender/compositor/intern/COM_InputSocket.cpp index 2493d4e5a27..6868745d631 100644 --- a/source/blender/compositor/intern/COM_InputSocket.cpp +++ b/source/blender/compositor/intern/COM_InputSocket.cpp @@ -157,24 +157,3 @@ NodeOperation *InputSocket::getOperation() const return NULL; } } - -float *InputSocket::getStaticValues() -{ - /* XXX only works for socket types with actual float input values. - * currently all compositor socket types (value, rgba, vector) support this. - */ - bNodeSocket *b_socket = this->getbNodeSocket(); - static float default_null = 0.0f; - - switch (this->getDataType()) { - case COM_DT_VALUE: - return &((bNodeSocketValueFloat *)b_socket->default_value)->value; - case COM_DT_COLOR: - return ((bNodeSocketValueRGBA *)b_socket->default_value)->value; - case COM_DT_VECTOR: - return ((bNodeSocketValueVector *)b_socket->default_value)->value; - default: - /* XXX this should never happen, just added to please the compiler */ - return &default_null; - } -} diff --git a/source/blender/compositor/intern/COM_InputSocket.h b/source/blender/compositor/intern/COM_InputSocket.h index 5cd4cf3beb7..5a36fe3f33b 100644 --- a/source/blender/compositor/intern/COM_InputSocket.h +++ b/source/blender/compositor/intern/COM_InputSocket.h @@ -143,7 +143,6 @@ public: bool isStatic(); - float *getStaticValues(); SocketReader *getReader(); NodeOperation *getOperation() const; }; diff --git a/source/blender/compositor/intern/COM_Node.cpp b/source/blender/compositor/intern/COM_Node.cpp index d49bb5f96fb..f59580acb50 100644 --- a/source/blender/compositor/intern/COM_Node.cpp +++ b/source/blender/compositor/intern/COM_Node.cpp @@ -67,10 +67,9 @@ Node::Node(bNode *editorNode, bool create_sockets): NodeBase() void Node::addSetValueOperation(ExecutionSystem *graph, InputSocket *inputsocket, int editorNodeInputSocketIndex) { - bNodeSocket *bSock = this->getEditorInputSocket(editorNodeInputSocketIndex); + InputSocket *input = getInputSocket(editorNodeInputSocketIndex); SetValueOperation *operation = new SetValueOperation(); - bNodeSocketValueFloat *val = (bNodeSocketValueFloat *)bSock->default_value; - operation->setValue(val->value); + operation->setValue(input->getEditorValueFloat()); this->addLink(graph, operation->getOutputSocket(), inputsocket); graph->addOperation(operation); } @@ -79,11 +78,13 @@ void Node::addPreviewOperation(ExecutionSystem *system, CompositorContext *conte { if (this->isInActiveGroup()) { if (!(this->getbNode()->flag & NODE_HIDDEN)) { // do not calculate previews of hidden nodes. - if (this->getbNode()->flag & NODE_PREVIEW) { + bNodeInstanceHash *previews = context->getPreviewHash(); + if (previews && (this->getbNode()->flag & NODE_PREVIEW)) { PreviewOperation *operation = new PreviewOperation(context->getViewSettings(), context->getDisplaySettings()); system->addOperation(operation); operation->setbNode(this->getbNode()); operation->setbNodeTree(system->getContext().getbNodeTree()); + operation->verifyPreview(previews, this->getInstanceKey()); this->addLink(system, outputSocket, operation->getInputSocket(0)); } } @@ -114,25 +115,27 @@ SocketConnection *Node::addLink(ExecutionSystem *graph, OutputSocket *outputSock void Node::addSetColorOperation(ExecutionSystem *graph, InputSocket *inputsocket, int editorNodeInputSocketIndex) { - bNodeSocket *bSock = this->getEditorInputSocket(editorNodeInputSocketIndex); + InputSocket *input = getInputSocket(editorNodeInputSocketIndex); SetColorOperation *operation = new SetColorOperation(); - bNodeSocketValueRGBA *val = (bNodeSocketValueRGBA *)bSock->default_value; - operation->setChannel1(val->value[0]); - operation->setChannel2(val->value[1]); - operation->setChannel3(val->value[2]); - operation->setChannel4(val->value[3]); + float col[4]; + input->getEditorValueColor(col); + operation->setChannel1(col[0]); + operation->setChannel2(col[1]); + operation->setChannel3(col[2]); + operation->setChannel4(col[3]); this->addLink(graph, operation->getOutputSocket(), inputsocket); graph->addOperation(operation); } void Node::addSetVectorOperation(ExecutionSystem *graph, InputSocket *inputsocket, int editorNodeInputSocketIndex) { - bNodeSocket *bSock = this->getEditorInputSocket(editorNodeInputSocketIndex); - bNodeSocketValueVector *val = (bNodeSocketValueVector *)bSock->default_value; + InputSocket *input = getInputSocket(editorNodeInputSocketIndex); SetVectorOperation *operation = new SetVectorOperation(); - operation->setX(val->value[0]); - operation->setY(val->value[1]); - operation->setZ(val->value[2]); + float vec[3]; + input->getEditorValueVector(vec); + operation->setX(vec[0]); + operation->setY(vec[1]); + operation->setZ(vec[2]); this->addLink(graph, operation->getOutputSocket(), inputsocket); graph->addOperation(operation); } diff --git a/source/blender/compositor/intern/COM_Node.h b/source/blender/compositor/intern/COM_Node.h index 5b0381f6443..fb5dfe2e9b7 100644 --- a/source/blender/compositor/intern/COM_Node.h +++ b/source/blender/compositor/intern/COM_Node.h @@ -53,12 +53,11 @@ private: * @brief Is this node part of the active group */ bool m_inActiveGroup; - + /** - * @brief The group node this node belongs to. - * @note: used to find the links in the current subtree for muting nodes + * @brief Instance key to identify the node in an instance hash table */ - bNode *m_bNodeGroup; + bNodeInstanceKey m_instanceKey; public: Node(bNode *editorNode, bool create_sockets = true); @@ -145,8 +144,9 @@ public: */ OutputSocket *findOutputSocketBybNodeSocket(bNodeSocket *socket); - inline void setbNodeGroup(bNode *group) {this->m_bNodeGroup = group;} - inline bNode *getbNodeGroup() {return this->m_bNodeGroup;} + void setInstanceKey(bNodeInstanceKey instance_key) { m_instanceKey = instance_key; } + bNodeInstanceKey getInstanceKey() const { return m_instanceKey; } + protected: void addPreviewOperation(ExecutionSystem *system, CompositorContext *context, InputSocket *inputSocket); void addPreviewOperation(ExecutionSystem *system, CompositorContext *context, OutputSocket *outputSocket); diff --git a/source/blender/compositor/intern/COM_NodeBase.h b/source/blender/compositor/intern/COM_NodeBase.h index e386b5e08a0..41b6ab70bf9 100644 --- a/source/blender/compositor/intern/COM_NodeBase.h +++ b/source/blender/compositor/intern/COM_NodeBase.h @@ -59,6 +59,11 @@ private: */ bNode *m_editorNode; + /** + * @brief stores the reference to the SDNA bNode struct + */ + bNodeTree *m_editorNodeTree; + protected: /** * @brief get access to the vector of input sockets @@ -82,14 +87,25 @@ public: /** * @brief get the reference to the SDNA bNode struct */ - bNode *getbNode() {return m_editorNode;} + bNode *getbNode() const {return m_editorNode;} + + /** + * @brief get the reference to the SDNA bNodeTree struct + */ + bNodeTree *getbNodeTree() const {return m_editorNodeTree;} /** * @brief set the reference to the bNode * @note used in Node instances to receive the storage/settings and complex node for highlight during execution * @param bNode */ - void setbNode(bNode *bNode) {this->m_editorNode = bNode;} + void setbNode(bNode *node) {this->m_editorNode = node;} + + /** + * @brief set the reference to the bNodeTree + * @param bNodeTree + */ + void setbNodeTree(bNodeTree *nodetree) {this->m_editorNodeTree = nodetree;} /** * @brief is this node an operation? diff --git a/source/blender/compositor/intern/COM_Socket.cpp b/source/blender/compositor/intern/COM_Socket.cpp index 30f28f9dddb..3465fa6f56d 100644 --- a/source/blender/compositor/intern/COM_Socket.cpp +++ b/source/blender/compositor/intern/COM_Socket.cpp @@ -24,6 +24,10 @@ #include "COM_Node.h" #include "COM_SocketConnection.h" +extern "C" { +#include "RNA_access.h" +} + Socket::Socket(DataType datatype) { this->m_datatype = datatype; @@ -41,3 +45,24 @@ int Socket::isOutputSocket() const { return false; } const int Socket::isConnected() const { return false; } void Socket::setNode(NodeBase *node) { this->m_node = node; } NodeBase *Socket::getNode() const { return this->m_node; } + +float Socket::getEditorValueFloat() +{ + PointerRNA ptr; + RNA_pointer_create((ID *)getNode()->getbNodeTree(), &RNA_NodeSocket, getbNodeSocket(), &ptr); + return RNA_float_get(&ptr, "default_value"); +} + +void Socket::getEditorValueColor(float *value) +{ + PointerRNA ptr; + RNA_pointer_create((ID *)getNode()->getbNodeTree(), &RNA_NodeSocket, getbNodeSocket(), &ptr); + return RNA_float_get_array(&ptr, "default_value", value); +} + +void Socket::getEditorValueVector(float *value) +{ + PointerRNA ptr; + RNA_pointer_create((ID *)getNode()->getbNodeTree(), &RNA_NodeSocket, getbNodeSocket(), &ptr); + return RNA_float_get_array(&ptr, "default_value", value); +} diff --git a/source/blender/compositor/intern/COM_Socket.h b/source/blender/compositor/intern/COM_Socket.h index bad112d20c7..6532864a4d9 100644 --- a/source/blender/compositor/intern/COM_Socket.h +++ b/source/blender/compositor/intern/COM_Socket.h @@ -36,6 +36,7 @@ using namespace std; class SocketConnection; class NodeBase; +struct PointerRNA; /** * @brief Base class for InputSocket and OutputSocket. @@ -86,6 +87,10 @@ public: void setEditorSocket(bNodeSocket *editorSocket) { this->m_editorSocket = editorSocket; } bNodeSocket *getbNodeSocket() const { return this->m_editorSocket; } + float getEditorValueFloat(); + void getEditorValueColor(float *value); + void getEditorValueVector(float *value); + #ifdef WITH_CXX_GUARDEDALLOC MEM_CXX_CLASS_ALLOC_FUNCS("COM:Socket") #endif diff --git a/source/blender/compositor/intern/COM_compositor.cpp b/source/blender/compositor/intern/COM_compositor.cpp index 49ab9db5dd8..94a27e17b68 100644 --- a/source/blender/compositor/intern/COM_compositor.cpp +++ b/source/blender/compositor/intern/COM_compositor.cpp @@ -21,9 +21,9 @@ */ -#include "BKE_node.h" extern "C" { - #include "BLI_threads.h" +#include "BKE_node.h" +#include "BLI_threads.h" } #include "BKE_main.h" #include "BKE_global.h" @@ -63,6 +63,11 @@ void COM_execute(RenderData *rd, bNodeTree *editingtree, int rendering, return; } + /* Make sure node tree has previews. + * Don't create previews in advance, this is done when adding preview operations. + */ + BKE_node_preview_init_tree(editingtree, COM_PREVIEW_SIZE, COM_PREVIEW_SIZE, FALSE); + /* initialize workscheduler, will check if already done. TODO deinitialize somewhere */ bool use_opencl = (editingtree->flag & NTREE_COM_OPENCL); WorkScheduler::initialize(use_opencl); @@ -85,7 +90,6 @@ void COM_execute(RenderData *rd, bNodeTree *editingtree, int rendering, } } - ExecutionSystem *system = new ExecutionSystem(rd, editingtree, rendering, false, viewSettings, displaySettings); system->execute(); delete system; diff --git a/source/blender/compositor/nodes/COM_BlurNode.cpp b/source/blender/compositor/nodes/COM_BlurNode.cpp index 6a4987c2075..b59a92710bc 100644 --- a/source/blender/compositor/nodes/COM_BlurNode.cpp +++ b/source/blender/compositor/nodes/COM_BlurNode.cpp @@ -45,8 +45,7 @@ void BlurNode::convertToOperations(ExecutionSystem *graph, CompositorContext *co InputSocket *inputSizeSocket = this->getInputSocket(1); bool connectedSizeSocket = inputSizeSocket->isConnected(); - const bNodeSocket *sock = this->getInputSocket(1)->getbNodeSocket(); - const float size = ((const bNodeSocketValueFloat *)sock->default_value)->value; + const float size = this->getInputSocket(1)->getEditorValueFloat(); CompositorQuality quality = context->getQuality(); NodeOperation *input_operation = NULL, *output_operation = NULL; diff --git a/source/blender/compositor/nodes/COM_BokehBlurNode.cpp b/source/blender/compositor/nodes/COM_BokehBlurNode.cpp index 70f20e3235b..5725bc6cb32 100644 --- a/source/blender/compositor/nodes/COM_BokehBlurNode.cpp +++ b/source/blender/compositor/nodes/COM_BokehBlurNode.cpp @@ -60,21 +60,17 @@ void BokehBlurNode::convertToOperations(ExecutionSystem *graph, CompositorContex else { BokehBlurOperation *operation = new BokehBlurOperation(); - const bNodeSocket *sock = this->getInputSocket(2)->getbNodeSocket(); - const float size = ((const bNodeSocketValueFloat *)sock->default_value)->value; - this->getInputSocket(0)->relinkConnections(operation->getInputSocket(0), 0, graph); this->getInputSocket(1)->relinkConnections(operation->getInputSocket(1), 1, graph); this->getInputSocket(2)->relinkConnections(operation->getInputSocket(3), 2, graph); this->getInputSocket(3)->relinkConnections(operation->getInputSocket(2), 3, graph); - //operation->setSize(((bNodeSocketValueFloat *)this->getInputSocket(2)->getbNodeSocket()->default_value)->value); operation->setQuality(context->getQuality()); operation->setbNode(this->getbNode()); graph->addOperation(operation); this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket()); if (!connectedSizeSocket) { - operation->setSize(size); + operation->setSize(this->getInputSocket(2)->getEditorValueFloat()); } } } diff --git a/source/blender/compositor/nodes/COM_ColorCurveNode.cpp b/source/blender/compositor/nodes/COM_ColorCurveNode.cpp index 93ff304afd8..103fbf26c7d 100644 --- a/source/blender/compositor/nodes/COM_ColorCurveNode.cpp +++ b/source/blender/compositor/nodes/COM_ColorCurveNode.cpp @@ -50,10 +50,11 @@ void ColorCurveNode::convertToOperations(ExecutionSystem *graph, CompositorConte this->getInputSocket(0)->relinkConnections(operation->getInputSocket(0), 0, graph); this->getInputSocket(1)->relinkConnections(operation->getInputSocket(1), 1, graph); - bNodeSocketValueRGBA *val = (bNodeSocketValueRGBA *)this->getInputSocket(2)->getbNodeSocket()->default_value; - operation->setBlackLevel(val->value); - val = (bNodeSocketValueRGBA *)this->getInputSocket(3)->getbNodeSocket()->default_value; - operation->setWhiteLevel(val->value); + float col[4]; + this->getInputSocket(2)->getEditorValueColor(col); + operation->setBlackLevel(col); + this->getInputSocket(3)->getEditorValueColor(col); + operation->setWhiteLevel(col); this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket()); operation->setCurveMapping((CurveMapping *)this->getbNode()->storage); diff --git a/source/blender/compositor/nodes/COM_ColorNode.cpp b/source/blender/compositor/nodes/COM_ColorNode.cpp index 088f8bbb19d..fc2566e5a47 100644 --- a/source/blender/compositor/nodes/COM_ColorNode.cpp +++ b/source/blender/compositor/nodes/COM_ColorNode.cpp @@ -32,9 +32,10 @@ ColorNode::ColorNode(bNode *editorNode) : Node(editorNode) void ColorNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context) { SetColorOperation *operation = new SetColorOperation(); - bNodeSocket *socket = this->getEditorOutputSocket(0); - bNodeSocketValueRGBA *dval = (bNodeSocketValueRGBA *)socket->default_value; - this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket()); - operation->setChannels(dval->value); + OutputSocket *output = this->getOutputSocket(0); + output->relinkConnections(operation->getOutputSocket()); + float col[4]; + output->getEditorValueColor(col); + operation->setChannels(col); graph->addOperation(operation); } diff --git a/source/blender/compositor/nodes/COM_GroupNode.cpp b/source/blender/compositor/nodes/COM_GroupNode.cpp index 05c749345d5..3b67d0912d4 100644 --- a/source/blender/compositor/nodes/COM_GroupNode.cpp +++ b/source/blender/compositor/nodes/COM_GroupNode.cpp @@ -20,6 +20,8 @@ * Monique Dewanchand */ +#include "BKE_node.h" + #include "COM_GroupNode.h" #include "COM_SocketProxyNode.h" #include "COM_SetColorOperation.h" @@ -37,13 +39,38 @@ void GroupNode::convertToOperations(ExecutionSystem *graph, CompositorContext *c } } +static int find_group_input(GroupNode *gnode, const char *identifier, InputSocket **r_sock) +{ + int index; + for (index = 0; index < gnode->getNumberOfInputSockets(); ++index) { + InputSocket *sock = gnode->getInputSocket(index); + if (strcmp(sock->getbNodeSocket()->identifier, identifier)==0) { + *r_sock = sock; + return index; + } + } + *r_sock = NULL; + return -1; +} + +static int find_group_output(GroupNode *gnode, const char *identifier, OutputSocket **r_sock) +{ + int index; + for (index = 0; index < gnode->getNumberOfOutputSockets(); ++index) { + OutputSocket *sock = gnode->getOutputSocket(index); + if (strcmp(sock->getbNodeSocket()->identifier, identifier)==0) { + *r_sock = sock; + return index; + } + } + *r_sock = NULL; + return -1; +} + void GroupNode::ungroup(ExecutionSystem &system) { bNode *bnode = this->getbNode(); bNodeTree *subtree = (bNodeTree *)bnode->id; - vector<InputSocket *> &inputsockets = this->getInputSockets(); - vector<OutputSocket *> &outputsockets = this->getOutputSockets(); - unsigned int index; /* get the node list size _before_ adding proxy nodes, so they are available for linking */ int nodes_start = system.getNodes().size(); @@ -54,26 +81,44 @@ void GroupNode::ungroup(ExecutionSystem &system) return; } - for (index = 0; index < inputsockets.size(); index++) { - InputSocket *inputSocket = inputsockets[index]; - bNodeSocket *editorInput = inputSocket->getbNodeSocket(); - if (editorInput->groupsock) { - SocketProxyNode *proxy = new SocketProxyNode(bnode, editorInput, editorInput->groupsock, false); - inputSocket->relinkConnections(proxy->getInputSocket(0), index, &system); - ExecutionSystemHelper::addNode(system.getNodes(), proxy); - } - } - const bool groupnodeBuffering = system.getContext().isGroupnodeBufferEnabled(); - for (index = 0; index < outputsockets.size(); index++) { - OutputSocket *outputSocket = outputsockets[index]; - bNodeSocket *editorOutput = outputSocket->getbNodeSocket(); - if (editorOutput->groupsock) { - SocketProxyNode *proxy = new SocketProxyNode(bnode, editorOutput->groupsock, editorOutput, groupnodeBuffering); - outputSocket->relinkConnections(proxy->getOutputSocket(0)); - ExecutionSystemHelper::addNode(system.getNodes(), proxy); + + /* create proxy nodes for group input/output nodes */ + for (bNode *bionode = (bNode *)subtree->nodes.first; bionode; bionode = bionode->next) { + if (bionode->type == NODE_GROUP_INPUT) { + for (bNodeSocket *bsock = (bNodeSocket *)bionode->outputs.first; bsock; bsock = bsock->next) { + InputSocket *gsock; + int gsock_index = find_group_input(this, bsock->identifier, &gsock); + /* ignore virtual sockets */ + if (gsock) { + SocketProxyNode *proxy = new SocketProxyNode(bionode, gsock->getbNodeSocket(), bsock, false); + ExecutionSystemHelper::addNode(system.getNodes(), proxy); + + gsock->relinkConnectionsDuplicate(proxy->getInputSocket(0), gsock_index, &system); + } + } + } + + if (bionode->type == NODE_GROUP_OUTPUT && (bionode->flag & NODE_DO_OUTPUT)) { + for (bNodeSocket *bsock = (bNodeSocket *)bionode->inputs.first; bsock; bsock = bsock->next) { + OutputSocket *gsock; + find_group_output(this, bsock->identifier, &gsock); + /* ignore virtual sockets */ + if (gsock) { + SocketProxyNode *proxy = new SocketProxyNode(bionode, bsock, gsock->getbNodeSocket(), groupnodeBuffering); + ExecutionSystemHelper::addNode(system.getNodes(), proxy); + + gsock->relinkConnections(proxy->getOutputSocket(0)); + } + } } } - - ExecutionSystemHelper::addbNodeTree(system, nodes_start, subtree, bnode); + + /* unlink the group node itself, input links have been duplicated */ + for (int index = 0; index < this->getNumberOfInputSockets(); ++index) { + InputSocket *sock = this->getInputSocket(index); + sock->unlinkConnections(&system); + } + + ExecutionSystemHelper::addbNodeTree(system, nodes_start, subtree, this->getInstanceKey()); } diff --git a/source/blender/compositor/nodes/COM_LensDistortionNode.cpp b/source/blender/compositor/nodes/COM_LensDistortionNode.cpp index 94c2fc885fb..f91744d88b6 100644 --- a/source/blender/compositor/nodes/COM_LensDistortionNode.cpp +++ b/source/blender/compositor/nodes/COM_LensDistortionNode.cpp @@ -51,8 +51,8 @@ void LensDistortionNode::convertToOperations(ExecutionSystem *graph, CompositorC operation->setData(data); if (!(this->getInputSocket(1)->isConnected() || this->getInputSocket(2)->isConnected())) { // no nodes connected to the distortion and dispersion. We can precalculate some values - float distortion = ((const bNodeSocketValueFloat *)this->getInputSocket(1)->getbNodeSocket()->default_value)->value; - float dispersion = ((const bNodeSocketValueFloat *)this->getInputSocket(2)->getbNodeSocket()->default_value)->value; + float distortion = this->getInputSocket(1)->getEditorValueFloat(); + float dispersion = this->getInputSocket(2)->getEditorValueFloat(); operation->setDistortionAndDispersion(distortion, dispersion); } diff --git a/source/blender/compositor/nodes/COM_NormalNode.cpp b/source/blender/compositor/nodes/COM_NormalNode.cpp index fbfff8386d0..41b91f61328 100644 --- a/source/blender/compositor/nodes/COM_NormalNode.cpp +++ b/source/blender/compositor/nodes/COM_NormalNode.cpp @@ -36,15 +36,13 @@ void NormalNode::convertToOperations(ExecutionSystem *graph, CompositorContext * InputSocket *inputSocket = this->getInputSocket(0); OutputSocket *outputSocket = this->getOutputSocket(0); OutputSocket *outputSocketDotproduct = this->getOutputSocket(1); - bNode *editorNode = this->getbNode(); SetVectorOperation *operationSet = new SetVectorOperation(); - bNodeSocket *insock = (bNodeSocket *)editorNode->outputs.first; - bNodeSocketValueVector *dval = (bNodeSocketValueVector *)insock->default_value; float normal[3]; + outputSocket->getEditorValueVector(normal); /* animation can break normalization, this restores it */ - normalize_v3_v3(normal, dval->value); + normalize_v3(normal); operationSet->setX(normal[0]); operationSet->setY(normal[1]); diff --git a/source/blender/compositor/nodes/COM_SocketProxyNode.cpp b/source/blender/compositor/nodes/COM_SocketProxyNode.cpp index ded6186ad77..c822d2107ec 100644 --- a/source/blender/compositor/nodes/COM_SocketProxyNode.cpp +++ b/source/blender/compositor/nodes/COM_SocketProxyNode.cpp @@ -50,54 +50,54 @@ void SocketProxyNode::convertToOperations(ExecutionSystem *graph, CompositorCont { OutputSocket *outputsocket = this->getOutputSocket(0); InputSocket *inputsocket = this->getInputSocket(0); - if (outputsocket->isConnected()) { - if (inputsocket->isConnected()) { - SocketProxyOperation *operation = new SocketProxyOperation(this->getOutputSocket()->getDataType()); - inputsocket->relinkConnections(operation->getInputSocket(0)); - outputsocket->relinkConnections(operation->getOutputSocket(0)); - graph->addOperation(operation); - if (m_buffer) { - WriteBufferOperation *writeOperation = new WriteBufferOperation(); - ReadBufferOperation *readOperation = new ReadBufferOperation(); - readOperation->setMemoryProxy(writeOperation->getMemoryProxy()); - - operation->getOutputSocket()->relinkConnections(readOperation->getOutputSocket()); - addLink(graph, operation->getOutputSocket(), writeOperation->getInputSocket(0)); - - graph->addOperation(writeOperation); - graph->addOperation(readOperation); - } + if (inputsocket->isConnected()) { + SocketProxyOperation *operation = new SocketProxyOperation(this->getOutputSocket()->getDataType()); + inputsocket->relinkConnections(operation->getInputSocket(0)); + outputsocket->relinkConnections(operation->getOutputSocket(0)); + graph->addOperation(operation); + + if (m_buffer) { + WriteBufferOperation *writeOperation = new WriteBufferOperation(); + ReadBufferOperation *readOperation = new ReadBufferOperation(); + readOperation->setMemoryProxy(writeOperation->getMemoryProxy()); + + operation->getOutputSocket()->relinkConnections(readOperation->getOutputSocket()); + addLink(graph, operation->getOutputSocket(), writeOperation->getInputSocket(0)); + + graph->addOperation(writeOperation); + graph->addOperation(readOperation); } - else { - /* If input is not connected, add a constant value operation instead */ - switch (outputsocket->getDataType()) { - case COM_DT_VALUE: - { - SetValueOperation *operation = new SetValueOperation(); - bNodeSocketValueFloat *dval = (bNodeSocketValueFloat *)inputsocket->getbNodeSocket()->default_value; - operation->setValue(dval->value); - outputsocket->relinkConnections(operation->getOutputSocket(0)); - graph->addOperation(operation); - break; - } - case COM_DT_COLOR: - { - SetColorOperation *operation = new SetColorOperation(); - bNodeSocketValueRGBA *dval = (bNodeSocketValueRGBA *)inputsocket->getbNodeSocket()->default_value; - operation->setChannels(dval->value); - outputsocket->relinkConnections(operation->getOutputSocket(0)); - graph->addOperation(operation); - break; - } - case COM_DT_VECTOR: - { - SetVectorOperation *operation = new SetVectorOperation(); - bNodeSocketValueVector *dval = (bNodeSocketValueVector *)inputsocket->getbNodeSocket()->default_value; - operation->setVector(dval->value); - outputsocket->relinkConnections(operation->getOutputSocket(0)); - graph->addOperation(operation); - break; - } + } + else if (outputsocket->isConnected()) { + /* If input is not connected, add a constant value operation instead */ + switch (outputsocket->getDataType()) { + case COM_DT_VALUE: + { + SetValueOperation *operation = new SetValueOperation(); + operation->setValue(inputsocket->getEditorValueFloat()); + outputsocket->relinkConnections(operation->getOutputSocket(0)); + graph->addOperation(operation); + break; + } + case COM_DT_COLOR: + { + SetColorOperation *operation = new SetColorOperation(); + float col[4]; + inputsocket->getEditorValueColor(col); + operation->setChannels(col); + outputsocket->relinkConnections(operation->getOutputSocket(0)); + graph->addOperation(operation); + break; + } + case COM_DT_VECTOR: + { + SetVectorOperation *operation = new SetVectorOperation(); + float vec[3]; + inputsocket->getEditorValueVector(vec); + operation->setVector(vec); + outputsocket->relinkConnections(operation->getOutputSocket(0)); + graph->addOperation(operation); + break; } } } diff --git a/source/blender/compositor/nodes/COM_ValueNode.cpp b/source/blender/compositor/nodes/COM_ValueNode.cpp index 593d74952ee..ed4440aa099 100644 --- a/source/blender/compositor/nodes/COM_ValueNode.cpp +++ b/source/blender/compositor/nodes/COM_ValueNode.cpp @@ -32,9 +32,8 @@ ValueNode::ValueNode(bNode *editorNode) : Node(editorNode) void ValueNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context) { SetValueOperation *operation = new SetValueOperation(); - bNodeSocket *socket = this->getEditorOutputSocket(0); - bNodeSocketValueFloat *dval = (bNodeSocketValueFloat *)socket->default_value; - this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket()); - operation->setValue(dval->value); + OutputSocket *output = this->getOutputSocket(0); + output->relinkConnections(operation->getOutputSocket()); + operation->setValue(output->getEditorValueFloat()); graph->addOperation(operation); } diff --git a/source/blender/compositor/operations/COM_PreviewOperation.cpp b/source/blender/compositor/operations/COM_PreviewOperation.cpp index 6e58b277f66..ba158fb2509 100644 --- a/source/blender/compositor/operations/COM_PreviewOperation.cpp +++ b/source/blender/compositor/operations/COM_PreviewOperation.cpp @@ -36,42 +36,47 @@ extern "C" { #include "IMB_imbuf.h" #include "IMB_imbuf_types.h" #include "IMB_colormanagement.h" + #include "BKE_node.h" } PreviewOperation::PreviewOperation(const ColorManagedViewSettings *viewSettings, const ColorManagedDisplaySettings *displaySettings) : NodeOperation() { this->addInputSocket(COM_DT_COLOR, COM_SC_NO_RESIZE); + this->m_preview = NULL; this->m_outputBuffer = NULL; this->m_input = NULL; this->m_divider = 1.0f; - this->m_node = NULL; this->m_viewSettings = viewSettings; this->m_displaySettings = displaySettings; } +void PreviewOperation::verifyPreview(bNodeInstanceHash *previews, bNodeInstanceKey key) +{ + /* Size (0, 0) ensures the preview rect is not allocated in advance, + * this is set later in initExecution once the resolution is determined. + */ + this->m_preview = BKE_node_preview_verify(previews, key, 0, 0, TRUE); +} + void PreviewOperation::initExecution() { this->m_input = getInputSocketReader(0); - if (!this->m_node->preview) { - this->m_node->preview = (bNodePreview *)MEM_callocN(sizeof(bNodePreview), "node preview"); - } - else { - if (this->getWidth() == (unsigned int)this->m_node->preview->xsize && - this->getHeight() == (unsigned int)this->m_node->preview->ysize) - { - this->m_outputBuffer = this->m_node->preview->rect; - } + + if (this->getWidth() == (unsigned int)this->m_preview->xsize && + this->getHeight() == (unsigned int)this->m_preview->ysize) + { + this->m_outputBuffer = this->m_preview->rect; } if (this->m_outputBuffer == NULL) { this->m_outputBuffer = (unsigned char *)MEM_callocN(sizeof(unsigned char) * 4 * getWidth() * getHeight(), "PreviewOperation"); - if (this->m_node->preview->rect) { - MEM_freeN(this->m_node->preview->rect); + if (this->m_preview->rect) { + MEM_freeN(this->m_preview->rect); } - this->m_node->preview->xsize = getWidth(); - this->m_node->preview->ysize = getHeight(); - this->m_node->preview->rect = this->m_outputBuffer; + this->m_preview->xsize = getWidth(); + this->m_preview->ysize = getHeight(); + this->m_preview->rect = this->m_outputBuffer; } } diff --git a/source/blender/compositor/operations/COM_PreviewOperation.h b/source/blender/compositor/operations/COM_PreviewOperation.h index 0da6b8e4e56..bb60dfa0420 100644 --- a/source/blender/compositor/operations/COM_PreviewOperation.h +++ b/source/blender/compositor/operations/COM_PreviewOperation.h @@ -35,7 +35,7 @@ protected: /** * @brief holds reference to the SDNA bNode, where this nodes will render the preview image for */ - bNode *m_node; + bNodePreview *m_preview; SocketReader *m_input; float m_divider; @@ -43,6 +43,8 @@ protected: const ColorManagedDisplaySettings *m_displaySettings; public: PreviewOperation(const ColorManagedViewSettings *viewSettings, const ColorManagedDisplaySettings *displaySettings); + void verifyPreview(bNodeInstanceHash *previews, bNodeInstanceKey key); + bool isOutputOperation(bool rendering) const { return !G.background; } void initExecution(); void deinitExecution(); @@ -50,7 +52,6 @@ public: void executeRegion(rcti *rect, unsigned int tileNumber); void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]); - void setbNode(bNode *node) { this->m_node = node; } bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); bool isPreviewOperation() { return true; } diff --git a/source/blender/editors/include/ED_node.h b/source/blender/editors/include/ED_node.h index 32baa8883e1..448a15334c7 100644 --- a/source/blender/editors/include/ED_node.h +++ b/source/blender/editors/include/ED_node.h @@ -39,7 +39,10 @@ struct Tex; struct bContext; struct bNodeTree; struct bNode; +struct bNodeType; +struct bNodeSocketType; struct bNodeTree; +struct bNodeTreeType; struct ScrArea; struct Scene; struct View2D; @@ -51,15 +54,30 @@ typedef enum { NODE_RIGHT = 8 } NodeBorder; +/* space_node.c */ +int ED_node_tree_path_length(struct SpaceNode *snode); +void ED_node_tree_path_get(struct SpaceNode *snode, char *value); +void ED_node_tree_path_get_fixedbuf(struct SpaceNode *snode, char *value, int max_length); + +void ED_node_tree_start(struct SpaceNode *snode, struct bNodeTree *ntree, struct ID *id, struct ID *from); +void ED_node_tree_push(struct SpaceNode *snode, struct bNodeTree *ntree, struct bNode *gnode); +void ED_node_tree_pop(struct SpaceNode *snode); +int ED_node_tree_depth(struct SpaceNode *snode); +struct bNodeTree *ED_node_tree_get(struct SpaceNode *snode, int level); + /* drawnode.c */ void ED_node_init_butfuncs(void); +void ED_init_custom_node_type(struct bNodeType *ntype); +void ED_init_custom_node_socket_type(struct bNodeSocketType *stype); +void ED_init_standard_node_socket_type(struct bNodeSocketType *stype); +void ED_init_node_socket_type_virtual(struct bNodeSocketType *stype); void ED_node_sample_set(const float col[4]); void ED_node_draw_snap(struct View2D *v2d, const float cent[2], float size, NodeBorder border); /* node_draw.c */ -void ED_node_tree_update(struct SpaceNode *snode, struct Scene *scene); -void ED_node_changed_update(struct ID *id, struct bNode *node); -void ED_node_generic_update(struct Main *bmain, struct bNodeTree *ntree, struct bNode *node); +void ED_node_tree_update(const struct bContext *C); +void ED_node_tag_update_id(struct ID *id); +void ED_node_tag_update_nodetree(struct Main *bmain, struct bNodeTree *ntree); void ED_node_sort(struct bNodeTree *ntree); /* node_relationships.c */ @@ -67,9 +85,14 @@ void ED_node_link_intersect_test(struct ScrArea *sa, int test); void ED_node_link_insert(struct ScrArea *sa); /* node_edit.c */ -void ED_node_shader_default(struct Scene *scene, struct ID *id); -void ED_node_composit_default(struct Scene *sce); -void ED_node_texture_default(struct Tex *tex); +void ED_node_set_tree_type(struct SpaceNode *snode, struct bNodeTreeType *typeinfo); +int ED_node_is_compositor(struct SpaceNode *snode); +int ED_node_is_shader(struct SpaceNode *snode); +int ED_node_is_texture(struct SpaceNode *snode); + +void ED_node_shader_default(const struct bContext *C, struct ID *id); +void ED_node_composit_default(const struct bContext *C, struct Scene *scene); +void ED_node_texture_default(const struct bContext *C, struct Tex *tex); int ED_node_select_check(ListBase *lb); void ED_node_post_apply_transform(struct bContext *C, struct bNodeTree *ntree); void ED_node_set_active(struct Main *bmain, struct bNodeTree *ntree, struct bNode *node); diff --git a/source/blender/editors/include/UI_interface.h b/source/blender/editors/include/UI_interface.h index 3c8a9a87fbe..f805b199280 100644 --- a/source/blender/editors/include/UI_interface.h +++ b/source/blender/editors/include/UI_interface.h @@ -259,7 +259,8 @@ typedef enum { WAVEFORM = (49 << 9), VECTORSCOPE = (50 << 9), PROGRESSBAR = (51 << 9), - SEARCH_MENU_UNLINK = (52 << 9) + SEARCH_MENU_UNLINK = (52 << 9), + NODESOCKET = (53 << 9) } eButType; #define BUTTYPE (63 << 9) @@ -835,6 +836,8 @@ void uiTemplateEditModeSelection(uiLayout *layout, struct bContext *C); void uiTemplateTextureImage(uiLayout *layout, struct bContext *C, struct Tex *tex); void uiTemplateReportsBanner(uiLayout *layout, struct bContext *C); void uiTemplateKeymapItemProperties(uiLayout *layout, struct PointerRNA *ptr); +void uiTemplateComponentMenu(uiLayout *layout, struct PointerRNA *ptr, const char *propname, const char *name); +void uiTemplateNodeSocket(uiLayout *layout, struct bContext *C, float *color); /* Default UIList class name, keep in sync with its declaration in bl_ui/__init__.py */ #define UI_UL_DEFAULT_CLASS_NAME "UI_UL_list" diff --git a/source/blender/editors/include/UI_resources.h b/source/blender/editors/include/UI_resources.h index 0086ef03b65..0cb3b2ce6d1 100644 --- a/source/blender/editors/include/UI_resources.h +++ b/source/blender/editors/include/UI_resources.h @@ -144,6 +144,7 @@ enum { TH_NODE, TH_NODE_IN_OUT, + TH_NODE_INTERFACE, TH_NODE_OPERATOR, TH_NODE_CONVERTOR, TH_NODE_GROUP, diff --git a/source/blender/editors/include/UI_view2d.h b/source/blender/editors/include/UI_view2d.h index 81a0f526049..3743539a9bd 100644 --- a/source/blender/editors/include/UI_view2d.h +++ b/source/blender/editors/include/UI_view2d.h @@ -167,7 +167,7 @@ View2DGrid *UI_view2d_grid_calc(struct Scene *scene, struct View2D *v2d, short xunits, short xclamp, short yunits, short yclamp, int winx, int winy); void UI_view2d_grid_draw(struct View2D *v2d, View2DGrid *grid, int flag); void UI_view2d_constant_grid_draw(struct View2D *v2d); -void UI_view2d_multi_grid_draw(struct View2D *v2d, float step, int level_size, int totlevels); +void UI_view2d_multi_grid_draw(struct View2D *v2d, int colorid, float step, int level_size, int totlevels); void UI_view2d_grid_size(View2DGrid *grid, float *r_dx, float *r_dy); void UI_view2d_grid_free(View2DGrid *grid); @@ -200,6 +200,9 @@ struct View2D *UI_view2d_fromcontext_rwin(const struct bContext *C); void UI_view2d_getscale(struct View2D *v2d, float *x, float *y); void UI_view2d_getscale_inverse(struct View2D *v2d, float *x, float *y); +void UI_view2d_getcenter(struct View2D *v2d, float *x, float *y); +void UI_view2d_setcenter(struct View2D *v2d, float x, float y); + short UI_view2d_mouse_in_scrollers(const struct bContext *C, struct View2D *v2d, int x, int y); /* cached text drawing in v2d, to allow pixel-aligned draw as post process */ diff --git a/source/blender/editors/interface/interface_draw.c b/source/blender/editors/interface/interface_draw.c index 5486e12c6bf..7fc5c21f052 100644 --- a/source/blender/editors/interface/interface_draw.c +++ b/source/blender/editors/interface/interface_draw.c @@ -42,6 +42,7 @@ #include "BLI_utildefines.h" #include "BKE_colortools.h" +#include "BKE_node.h" #include "BKE_texture.h" #include "BKE_tracking.h" @@ -1685,6 +1686,71 @@ void ui_draw_but_TRACKPREVIEW(ARegion *ar, uiBut *but, uiWidgetColors *UNUSED(wc glDisable(GL_BLEND); } +void ui_draw_but_NODESOCKET(ARegion *ar, uiBut *but, uiWidgetColors *UNUSED(wcol), rcti *recti) +{ + static const float size = 5.0f; + + /* 16 values of sin function */ + static float si[16] = { + 0.00000000f, 0.39435585f, 0.72479278f, 0.93775213f, + 0.99871650f, 0.89780453f, 0.65137248f, 0.29936312f, + -0.10116832f, -0.48530196f, -0.79077573f, -0.96807711f, + -0.98846832f, -0.84864425f, -0.57126821f, -0.20129852f + }; + /* 16 values of cos function */ + static float co[16] = { + 1.00000000f, 0.91895781f, 0.68896691f, 0.34730525f, + -0.05064916f, -0.44039415f, -0.75875812f, -0.95413925f, + -0.99486932f, -0.87434661f, -0.61210598f, -0.25065253f, + 0.15142777f, 0.52896401f, 0.82076344f, 0.97952994f, + }; + + unsigned char *col = but->col; + int a; + GLint scissor[4]; + rcti scissor_new; + float x, y; + + x = 0.5f * (recti->xmin + recti->xmax); + y = 0.5f * (recti->ymin + recti->ymax); + + /* need scissor test, can draw outside of boundary */ + glGetIntegerv(GL_VIEWPORT, scissor); + scissor_new.xmin = ar->winrct.xmin + recti->xmin; + scissor_new.ymin = ar->winrct.ymin + recti->ymin; + scissor_new.xmax = ar->winrct.xmin + recti->xmax; + scissor_new.ymax = ar->winrct.ymin + recti->ymax; + BLI_rcti_isect(&scissor_new, &ar->winrct, &scissor_new); + glScissor(scissor_new.xmin, + scissor_new.ymin, + BLI_rcti_size_x(&scissor_new), + BLI_rcti_size_y(&scissor_new)); + + glColor4ubv(col); + + glEnable(GL_BLEND); + glBegin(GL_POLYGON); + for (a = 0; a < 16; a++) + glVertex2f(x + size * si[a], y + size * co[a]); + glEnd(); + glDisable(GL_BLEND); + + glColor4ub(0, 0, 0, 150); + + glEnable(GL_BLEND); + glEnable(GL_LINE_SMOOTH); + glBegin(GL_LINE_LOOP); + for (a = 0; a < 16; a++) + glVertex2f(x + size * si[a], y + size * co[a]); + glEnd(); + glDisable(GL_LINE_SMOOTH); + glDisable(GL_BLEND); + glLineWidth(1.0f); + + /* restore scissortest */ + glScissor(scissor[0], scissor[1], scissor[2], scissor[3]); +} + /* ****************************************************** */ diff --git a/source/blender/editors/interface/interface_handlers.c b/source/blender/editors/interface/interface_handlers.c index 39aef38fadb..54a173af603 100644 --- a/source/blender/editors/interface/interface_handlers.c +++ b/source/blender/editors/interface/interface_handlers.c @@ -5434,6 +5434,7 @@ static int ui_do_button(bContext *C, uiBlock *block, uiBut *but, const wmEvent * case LISTROW: case BUT_IMAGE: case PROGRESSBAR: + case NODESOCKET: retval = ui_do_but_EXIT(C, but, data, event); break; case HISTOGRAM: diff --git a/source/blender/editors/interface/interface_intern.h b/source/blender/editors/interface/interface_intern.h index 6065fcfe574..19b863dd6fa 100644 --- a/source/blender/editors/interface/interface_intern.h +++ b/source/blender/editors/interface/interface_intern.h @@ -510,6 +510,7 @@ void ui_draw_but_NORMAL(uiBut *but, struct uiWidgetColors *wcol, rcti *rect); void ui_draw_but_CURVE(ARegion *ar, uiBut *but, struct uiWidgetColors *wcol, rcti *rect); void ui_draw_but_IMAGE(ARegion *ar, uiBut *but, struct uiWidgetColors *wcol, rcti *rect); void ui_draw_but_TRACKPREVIEW(ARegion *ar, uiBut *but, struct uiWidgetColors *wcol, rcti *rect); +void ui_draw_but_NODESOCKET(ARegion *ar, uiBut *but, struct uiWidgetColors *wcol, rcti *rect); /* interface_handlers.c */ extern void ui_pan_to_scroll(const struct wmEvent *event, int *type, int *val); diff --git a/source/blender/editors/interface/interface_templates.c b/source/blender/editors/interface/interface_templates.c index eeddd8c7a9a..ee2625cf94b 100644 --- a/source/blender/editors/interface/interface_templates.c +++ b/source/blender/editors/interface/interface_templates.c @@ -32,6 +32,7 @@ #include "MEM_guardedalloc.h" #include "DNA_dynamicpaint_types.h" +#include "DNA_node_types.h" #include "DNA_scene_types.h" #include "DNA_object_types.h" #include "DNA_object_force.h" @@ -57,6 +58,7 @@ #include "BKE_main.h" #include "BKE_material.h" #include "BKE_modifier.h" +#include "BKE_node.h" #include "BKE_object.h" #include "BKE_packedFile.h" #include "BKE_particle.h" @@ -3064,3 +3066,65 @@ void uiTemplateColormanagedViewSettings(uiLayout *layout, bContext *UNUSED(C), P if (view_settings->flag & COLORMANAGE_VIEW_USE_CURVES) uiTemplateCurveMapping(col, &view_transform_ptr, "curve_mapping", 'c', TRUE, 0); } + +/********************************* Component Menu *************************************/ + +typedef struct ComponentMenuArgs { + PointerRNA ptr; + char propname[64]; /* XXX arbitrary */ +} ComponentMenuArgs; +/* NOTE: this is a block-menu, needs 0 events, otherwise the menu closes */ +static uiBlock *component_menu(bContext *C, ARegion *ar, void *args_v) +{ + ComponentMenuArgs *args = (ComponentMenuArgs*)args_v; + uiBlock *block; + uiLayout *layout; + + block = uiBeginBlock(C, ar, __func__, UI_EMBOSS); + uiBlockSetFlag(block, UI_BLOCK_KEEP_OPEN); + + layout = uiLayoutColumn(uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, 0, 0, UI_UNIT_X * 6, UI_UNIT_Y, UI_GetStyle()), 0); + + uiItemR(layout, &args->ptr, args->propname, UI_ITEM_R_EXPAND, "", ICON_NONE); + + uiBoundsBlock(block, 6); + uiBlockSetDirection(block, UI_DOWN); + uiEndBlock(C, block); + + return block; +} +void uiTemplateComponentMenu(uiLayout *layout, PointerRNA *ptr, const char *propname, const char *name) +{ + ComponentMenuArgs *args = MEM_callocN(sizeof(ComponentMenuArgs), "component menu template args"); + uiBlock *block; + + args->ptr = *ptr; + BLI_strncpy(args->propname, propname, sizeof(args->propname)); + + block = uiLayoutGetBlock(layout); + uiBlockBeginAlign(block); + + uiDefBlockButN(block, component_menu, args, name, 0, 0, UI_UNIT_X * 6, UI_UNIT_Y, ""); + + uiBlockEndAlign(block); +} + +/************************* Node Socket Icon **************************/ + +void uiTemplateNodeSocket(uiLayout *layout, bContext *UNUSED(C), float *color) +{ + uiBlock *block; + uiBut *but; + + block = uiLayoutGetBlock(layout); + uiBlockBeginAlign(block); + + /* XXX using explicit socket colors is not quite ideal. + * Eventually it should be possible to use theme colors for this purpose, + * but this requires a better design for extendable color palettes in user prefs. + */ + but = uiDefBut(block, NODESOCKET, 0, "", 0, 0, UI_UNIT_X, UI_UNIT_Y, NULL, 0, 0, 0, 0, ""); + rgba_float_to_uchar(but->col, color); + + uiBlockEndAlign(block); +} diff --git a/source/blender/editors/interface/interface_widgets.c b/source/blender/editors/interface/interface_widgets.c index 78b6d2541fd..fc379468c6b 100644 --- a/source/blender/editors/interface/interface_widgets.c +++ b/source/blender/editors/interface/interface_widgets.c @@ -3367,6 +3367,10 @@ void ui_draw_but(const bContext *C, ARegion *ar, uiStyle *style, uiBut *but, rct ui_draw_but_TRACKPREVIEW(ar, but, &tui->wcol_regular, rect); break; + case NODESOCKET: + ui_draw_but_NODESOCKET(ar, but, &tui->wcol_regular, rect); + break; + default: wt = widget_type(UI_WTYPE_REGULAR); } diff --git a/source/blender/editors/interface/resources.c b/source/blender/editors/interface/resources.c index 7ff5677259e..6b278358db9 100644 --- a/source/blender/editors/interface/resources.c +++ b/source/blender/editors/interface/resources.c @@ -389,6 +389,8 @@ const unsigned char *UI_ThemeGetColorPtr(bTheme *btheme, int spacetype, int colo cp = ts->syntaxv; break; case TH_NODE_GROUP: cp = ts->syntaxc; break; + case TH_NODE_INTERFACE: + cp= ts->console_output; break; case TH_NODE_FRAME: cp = ts->movie; break; case TH_NODE_MATTE: @@ -951,7 +953,7 @@ void ui_theme_init_default(void) rgba_char_args_set_fl(btheme->ttime.grid, 0.36, 0.36, 0.36, 1.0); rgba_char_args_set(btheme->ttime.shade1, 173, 173, 173, 255); /* sliders */ - /* space node, re-uses syntax color storage */ + /* space node, re-uses syntax and console color storage */ btheme->tnode = btheme->tv3d; rgba_char_args_set(btheme->tnode.edge_select, 255, 255, 255, 255); /* wire selected */ rgba_char_args_set(btheme->tnode.syntaxl, 155, 155, 155, 160); /* TH_NODE, backdrop */ @@ -960,6 +962,7 @@ void ui_theme_init_default(void) rgba_char_args_set(btheme->tnode.syntaxv, 104, 106, 117, 255); /* generator */ rgba_char_args_set(btheme->tnode.syntaxc, 105, 117, 110, 255); /* group */ rgba_char_args_set(btheme->tnode.movie, 155, 155, 155, 160); /* frame */ + rgba_char_args_set(btheme->tnode.console_output, 190, 190, 80, 255); /* group input/output */ btheme->tnode.noodle_curving = 5; /* space logic */ @@ -2149,6 +2152,13 @@ void init_userdef_do_versions(void) } } + if (U.versionfile < 266 || (U.versionfile == 266 && U.subversionfile < 2)) { + bTheme *btheme; + for (btheme = U.themes.first; btheme; btheme = btheme->next) { + rgba_char_args_test_set(btheme->tnode.console_output, 223, 202, 53, 255); /* interface nodes */ + } + } + /* NOTE!! from now on use U.versionfile and U.subversionfile */ diff --git a/source/blender/editors/interface/view2d.c b/source/blender/editors/interface/view2d.c index 8a6de9a549b..fe7e6d01955 100644 --- a/source/blender/editors/interface/view2d.c +++ b/source/blender/editors/interface/view2d.c @@ -1368,7 +1368,7 @@ void UI_view2d_constant_grid_draw(View2D *v2d) } /* Draw a multi-level grid in given 2d-region */ -void UI_view2d_multi_grid_draw(View2D *v2d, float step, int level_size, int totlevels) +void UI_view2d_multi_grid_draw(View2D *v2d, int colorid, float step, int level_size, int totlevels) { int offset = -10; float lstep = step; @@ -1378,7 +1378,7 @@ void UI_view2d_multi_grid_draw(View2D *v2d, float step, int level_size, int totl int i; float start; - UI_ThemeColorShade(TH_BACK, offset); + UI_ThemeColorShade(colorid, offset); i = (v2d->cur.xmin >= 0.0f ? -(int)(-v2d->cur.xmin / lstep) : (int)(v2d->cur.xmin / lstep)); start = i * lstep; @@ -1402,7 +1402,7 @@ void UI_view2d_multi_grid_draw(View2D *v2d, float step, int level_size, int totl } /* X and Y axis */ - UI_ThemeColorShade(TH_BACK, offset - 8); + UI_ThemeColorShade(colorid, offset - 8); glVertex2f(0.0f, v2d->cur.ymin); glVertex2f(0.0f, v2d->cur.ymax); glVertex2f(v2d->cur.xmin, 0.0f); @@ -2075,6 +2075,31 @@ void UI_view2d_getscale_inverse(View2D *v2d, float *x, float *y) if (y) *y = BLI_rctf_size_y(&v2d->cur) / BLI_rcti_size_y(&v2d->mask); } +/* Simple functions for consistent center offset access. + * Used by node editor to shift view center for each individual node tree. + */ +void UI_view2d_getcenter(struct View2D *v2d, float *x, float *y) +{ + /* get center */ + if (x) *x = 0.5f*(v2d->cur.xmin + v2d->cur.xmax); + if (y) *y = 0.5f*(v2d->cur.ymin + v2d->cur.ymax); +} +void UI_view2d_setcenter(struct View2D *v2d, float x, float y) +{ + /* get delta from current center */ + float dx = x - 0.5f*(v2d->cur.xmin + v2d->cur.xmax); + float dy = y - 0.5f*(v2d->cur.ymin + v2d->cur.ymax); + + /* add to cur */ + v2d->cur.xmin += dx; + v2d->cur.xmax += dx; + v2d->cur.ymin += dy; + v2d->cur.ymax += dy; + + /* make sure that 'cur' rect is in a valid state as a result of these changes */ + UI_view2d_curRect_validate(v2d); +} + /* Check if mouse is within scrollers * - Returns appropriate code for match * 'h' = in horizontal scroller diff --git a/source/blender/editors/object/object_add.c b/source/blender/editors/object/object_add.c index dbb0d55a2b1..312cceac77d 100644 --- a/source/blender/editors/object/object_add.c +++ b/source/blender/editors/object/object_add.c @@ -852,7 +852,7 @@ static int object_lamp_add_exec(bContext *C, wmOperator *op) rename_id(&la->id, get_lamp_defname(type)); if (BKE_scene_use_new_shading_nodes(scene)) { - ED_node_shader_default(scene, &la->id); + ED_node_shader_default(C, &la->id); la->use_nodes = TRUE; } diff --git a/source/blender/editors/render/render_preview.c b/source/blender/editors/render/render_preview.c index dd5b97a68ed..948e272eca0 100644 --- a/source/blender/editors/render/render_preview.c +++ b/source/blender/editors/render/render_preview.c @@ -378,8 +378,8 @@ static Scene *preview_prepare_scene(Scene *scene, ID *id, int id_type, ShaderPre sce->lay = 1 << mat->pr_type; if (mat->nodetree && sp->pr_method == PR_NODE_RENDER) { /* two previews, they get copied by wmJob */ - ntreeInitPreview(mat->nodetree, sp->sizex, sp->sizey); - ntreeInitPreview(origmat->nodetree, sp->sizex, sp->sizey); + BKE_node_preview_init_tree(mat->nodetree, sp->sizex, sp->sizey, TRUE); + BKE_node_preview_init_tree(origmat->nodetree, sp->sizex, sp->sizey, TRUE); } } } @@ -442,8 +442,8 @@ static Scene *preview_prepare_scene(Scene *scene, ID *id, int id_type, ShaderPre if (tex && tex->nodetree && sp->pr_method == PR_NODE_RENDER) { /* two previews, they get copied by wmJob */ - ntreeInitPreview(origtex->nodetree, sp->sizex, sp->sizey); - ntreeInitPreview(tex->nodetree, sp->sizex, sp->sizey); + BKE_node_preview_init_tree(origtex->nodetree, sp->sizex, sp->sizey, TRUE); + BKE_node_preview_init_tree(tex->nodetree, sp->sizex, sp->sizey, TRUE); } } else if (id_type == ID_LA) { @@ -479,8 +479,8 @@ static Scene *preview_prepare_scene(Scene *scene, ID *id, int id_type, ShaderPre if (la && la->nodetree && sp->pr_method == PR_NODE_RENDER) { /* two previews, they get copied by wmJob */ - ntreeInitPreview(origla->nodetree, sp->sizex, sp->sizey); - ntreeInitPreview(la->nodetree, sp->sizex, sp->sizey); + BKE_node_preview_init_tree(origla->nodetree, sp->sizex, sp->sizey, TRUE); + BKE_node_preview_init_tree(la->nodetree, sp->sizex, sp->sizey, TRUE); } } else if (id_type == ID_WO) { @@ -497,8 +497,8 @@ static Scene *preview_prepare_scene(Scene *scene, ID *id, int id_type, ShaderPre if (wrld && wrld->nodetree && sp->pr_method == PR_NODE_RENDER) { /* two previews, they get copied by wmJob */ - ntreeInitPreview(wrld->nodetree, sp->sizex, sp->sizey); - ntreeInitPreview(origwrld->nodetree, sp->sizex, sp->sizey); + BKE_node_preview_init_tree(wrld->nodetree, sp->sizex, sp->sizey, TRUE); + BKE_node_preview_init_tree(origwrld->nodetree, sp->sizex, sp->sizey, TRUE); } } diff --git a/source/blender/editors/render/render_shading.c b/source/blender/editors/render/render_shading.c index c33b7442e41..54f59a82adc 100644 --- a/source/blender/editors/render/render_shading.c +++ b/source/blender/editors/render/render_shading.c @@ -379,7 +379,7 @@ static int new_material_exec(bContext *C, wmOperator *UNUSED(op)) ma = BKE_material_add(bmain, "Material"); if (BKE_scene_use_new_shading_nodes(scene)) { - ED_node_shader_default(scene, &ma->id); + ED_node_shader_default(C, &ma->id); ma->use_nodes = TRUE; } } @@ -481,7 +481,7 @@ static int new_world_exec(bContext *C, wmOperator *UNUSED(op)) wo = add_world(bmain, "World"); if (BKE_scene_use_new_shading_nodes(scene)) { - ED_node_shader_default(scene, &wo->id); + ED_node_shader_default(C, &wo->id); wo->use_nodes = TRUE; } } diff --git a/source/blender/editors/render/render_update.c b/source/blender/editors/render/render_update.c index a467b053443..d29c711cad0 100644 --- a/source/blender/editors/render/render_update.c +++ b/source/blender/editors/render/render_update.c @@ -377,7 +377,7 @@ static void texture_changed(Main *bmain, Tex *tex) if (scene->use_nodes && scene->nodetree) { for (node = scene->nodetree->nodes.first; node; node = node->next) { if (node->id == &tex->id) - ED_node_changed_update(&scene->id, node); + ED_node_tag_update_id(&scene->id); } } diff --git a/source/blender/editors/screen/screen_ops.c b/source/blender/editors/screen/screen_ops.c index 1906a3259a9..8b69e6e831d 100644 --- a/source/blender/editors/screen/screen_ops.c +++ b/source/blender/editors/screen/screen_ops.c @@ -47,6 +47,7 @@ #include "DNA_meta_types.h" #include "DNA_mesh_types.h" #include "DNA_mask_types.h" +#include "DNA_node_types.h" #include "DNA_userdef_types.h" #include "BKE_context.h" @@ -54,6 +55,7 @@ #include "BKE_global.h" #include "BKE_main.h" #include "BKE_mesh.h" +#include "BKE_node.h" #include "BKE_object.h" #include "BKE_report.h" #include "BKE_scene.h" @@ -252,7 +254,7 @@ int ED_operator_node_active(bContext *C) { SpaceNode *snode = CTX_wm_space_node(C); - if (snode && snode->edittree) + if (snode && ntreeIsValid(snode->edittree)) return 1; return 0; diff --git a/source/blender/editors/sculpt_paint/paint_image.c b/source/blender/editors/sculpt_paint/paint_image.c index d94b9372560..92a55151b66 100644 --- a/source/blender/editors/sculpt_paint/paint_image.c +++ b/source/blender/editors/sculpt_paint/paint_image.c @@ -407,7 +407,7 @@ void paint_brush_init_tex(Brush *brush) if (brush) { MTex *mtex = &brush->mtex; if (mtex->tex && mtex->tex->nodetree) - ntreeTexBeginExecTree(mtex->tex->nodetree, 1); /* has internal flag to detect it only does it once */ + ntreeTexBeginExecTree(mtex->tex->nodetree); /* has internal flag to detect it only does it once */ } } @@ -416,7 +416,7 @@ void paint_brush_exit_tex(Brush *brush) if (brush) { MTex *mtex = &brush->mtex; if (mtex->tex && mtex->tex->nodetree) - ntreeTexEndExecTree(mtex->tex->nodetree->execdata, 1); + ntreeTexEndExecTree(mtex->tex->nodetree->execdata); } } diff --git a/source/blender/editors/sculpt_paint/sculpt.c b/source/blender/editors/sculpt_paint/sculpt.c index 156be008a96..51500ab8e1c 100644 --- a/source/blender/editors/sculpt_paint/sculpt.c +++ b/source/blender/editors/sculpt_paint/sculpt.c @@ -4073,7 +4073,7 @@ static void sculpt_brush_init_tex(const Scene *scene, Sculpt *sd, SculptSession /* init mtex nodes */ if (mtex->tex && mtex->tex->nodetree) - ntreeTexBeginExecTree(mtex->tex->nodetree, 1); /* has internal flag to detect it only does it once */ + ntreeTexBeginExecTree(mtex->tex->nodetree); /* has internal flag to detect it only does it once */ /* TODO: Shouldn't really have to do this at the start of every * stroke, but sculpt would need some sort of notification when @@ -4249,7 +4249,7 @@ static void sculpt_brush_exit_tex(Sculpt *sd) MTex *mtex = &brush->mtex; if (mtex->tex && mtex->tex->nodetree) - ntreeTexEndExecTree(mtex->tex->nodetree->execdata, 1); + ntreeTexEndExecTree(mtex->tex->nodetree->execdata); } static void sculpt_stroke_done(const bContext *C, struct PaintStroke *UNUSED(stroke)) diff --git a/source/blender/editors/space_buttons/buttons_texture.c b/source/blender/editors/space_buttons/buttons_texture.c index 1643921e4dd..bb1310d486a 100644 --- a/source/blender/editors/space_buttons/buttons_texture.c +++ b/source/blender/editors/space_buttons/buttons_texture.c @@ -113,7 +113,7 @@ static void buttons_texture_users_find_nodetree(ListBase *users, ID *id, { bNode *node; - if (ntree) { + if (ntreeIsValid(ntree)) { for (node = ntree->nodes.first; node; node = node->next) { if (node->typeinfo->nclass == NODE_CLASS_TEXTURE) { PointerRNA ptr; diff --git a/source/blender/editors/space_node/drawnode.c b/source/blender/editors/space_node/drawnode.c index 4a14d6ba6fd..fddecf267a9 100644 --- a/source/blender/editors/space_node/drawnode.c +++ b/source/blender/editors/space_node/drawnode.c @@ -43,18 +43,23 @@ #include "BKE_image.h" #include "BKE_main.h" #include "BKE_node.h" +#include "BKE_scene.h" #include "BKE_tracking.h" #include "BLF_api.h" #include "BLF_translation.h" +#include "NOD_texture.h" #include "BIF_gl.h" #include "BIF_glutil.h" +#include "BLF_translation.h" #include "MEM_guardedalloc.h" #include "RNA_access.h" +#include "RNA_define.h" +#include "RNA_enum_types.h" #include "ED_node.h" @@ -68,189 +73,137 @@ #include "IMB_imbuf_types.h" #include "node_intern.h" /* own include */ +#include "NOD_composite.h" +#include "NOD_shader.h" +#include "NOD_texture.h" -/* ****************** SOCKET BUTTON DRAW FUNCTIONS ***************** */ +/* ****************** MENU FUNCTIONS ***************** */ -static void node_sync_cb(bContext *UNUSED(C), void *snode_v, void *node_v) +static void node_add_menu_class(bContext *C, uiLayout *layout, void *arg_nodeclass) { - SpaceNode *snode = snode_v; + Scene *scene= CTX_data_scene(C); + SpaceNode *snode= CTX_wm_space_node(C); + bNodeTree *ntree; + int nodeclass= GET_INT_FROM_POINTER(arg_nodeclass); + int event, compatibility= 0; - if (snode->treetype == NTREE_SHADER) { - nodeShaderSynchronizeID(node_v, 1); - // allqueue(REDRAWBUTSSHADING, 0); + ntree = snode->nodetree; + + if(!ntree) { + uiItemS(layout); + return; } -} - -static void node_socket_button_label(const bContext *UNUSED(C), uiBlock *block, - bNodeTree *UNUSED(ntree), bNode *UNUSED(node), bNodeSocket *sock, - const char *UNUSED(name), int x, int y, int width) -{ - uiDefBut(block, LABEL, 0, IFACE_(sock->name), x, y, width, NODE_DY, NULL, 0, 0, 0, 0, ""); -} -static void node_socket_button_default(const bContext *C, uiBlock *block, - bNodeTree *ntree, bNode *node, bNodeSocket *sock, - const char *name, int x, int y, int width) -{ - if (sock->link || (sock->flag & SOCK_HIDE_VALUE)) - node_socket_button_label(C, block, ntree, node, sock, name, x, y, width); - else { + if(ntree->type == NTREE_SHADER) { + if(BKE_scene_use_new_shading_nodes(scene)) + compatibility= NODE_NEW_SHADING; + else + compatibility= NODE_OLD_SHADING; + } + + if (nodeclass==NODE_CLASS_GROUP) { + Main *bmain= CTX_data_main(C); + bNodeTree *ngroup; + const char *ngroup_type, *node_type; PointerRNA ptr; - uiBut *bt; - - RNA_pointer_create(&ntree->id, &RNA_NodeSocket, sock, &ptr); - bt = uiDefButR(block, NUM, B_NODE_EXEC, IFACE_(name), - x, y + 1, width, NODE_DY - 2, - &ptr, "default_value", 0, 0, 0, -1, -1, NULL); - if (node) - uiButSetFunc(bt, node_sync_cb, CTX_wm_space_node(C), node); + NODE_TYPES_BEGIN(ntype) + if (ntype->nclass!=nodeclass || !ntype->ui_name) + continue; + if (!ntype->poll(ntype, ntree)) + continue; + + switch (ntree->type) { + case NTREE_COMPOSIT: + ngroup_type = "CompositorNodeTree"; + node_type = "CompositorNodeGroup"; + break; + case NTREE_SHADER: + ngroup_type = "ShaderNodeTree"; + node_type = "ShaderNodeGroup"; + break; + case NTREE_TEXTURE: + ngroup_type = "TextureNodeTree"; + node_type = "TextureNodeGroup"; + break; + } + + ptr = uiItemFullO(layout, "NODE_OT_group_make", "New Group", ntype->ui_icon, NULL, WM_OP_INVOKE_DEFAULT, UI_ITEM_O_RETURN_PROPS); + RNA_string_set(&ptr, "node_type", node_type); + + uiItemS(layout); + + for(ngroup=bmain->nodetree.first, event=0; ngroup; ngroup= ngroup->id.next, ++event) { + /* only use group trees of the right type */ + if (strcmp(ngroup->idname, ngroup_type)!=0) + continue; + if (!nodeGroupPoll(ntree, ngroup)) + continue; + + ptr = uiItemFullO(layout, "NODE_OT_add_group_node", ngroup->id.name+2, ntype->ui_icon, NULL, WM_OP_INVOKE_DEFAULT, UI_ITEM_O_RETURN_PROPS); + RNA_string_set(&ptr, "type", ntype->idname); + RNA_string_set(&ptr, "grouptree", ngroup->id.name+2); + } + NODE_TYPES_END } -} - -static void node_socket_button_string(const bContext *C, uiBlock *block, - bNodeTree *ntree, bNode *node, bNodeSocket *sock, - const char *name, int x, int y, int width) -{ - if (sock->link || (sock->flag & SOCK_HIDE_VALUE)) - node_socket_button_label(C, block, ntree, node, sock, name, x, y, width); - else { + else if (nodeclass==NODE_DYNAMIC) { + /* disabled */ + } + else + { PointerRNA ptr; - uiBut *bt; - - SpaceNode *snode = CTX_wm_space_node(C); - const char *ui_name = IFACE_(name); - float slen; - - UI_ThemeColor(TH_TEXT); - slen = (UI_GetStringWidth(ui_name) + NODE_MARGIN_X) * snode->aspect; /* XXX, check for dpis */ - while (slen > (width * 0.5f) && *ui_name) { - ui_name = BLI_str_find_next_char_utf8(ui_name, NULL); - slen = (UI_GetStringWidth(ui_name) + NODE_MARGIN_X) * snode->aspect; - } - - RNA_pointer_create(&ntree->id, &RNA_NodeSocket, sock, &ptr); - - if (name[0] == '\0') - slen = 0.0; - - bt = uiDefButR(block, TEX, B_NODE_EXEC, "", - x, y + 1, width - slen, NODE_DY - 2, - &ptr, "default_value", 0, 0, 0, -1, -1, ""); - if (node) - uiButSetFunc(bt, node_sync_cb, CTX_wm_space_node(C), node); - if (slen > 0.0f) - uiDefBut(block, LABEL, 0, IFACE_(name), x + (width - slen), y + 2, slen, NODE_DY - 2, NULL, 0, 0, 0, 0, ""); + NODE_TYPES_BEGIN(ntype) + if (ntype->nclass!=nodeclass || !ntype->ui_name) + continue; + if (!ntype->poll(ntype, ntree)) + continue; + if (compatibility && (ntype->compatibility & compatibility)==0) + continue; + + ptr = uiItemFullO(layout, "NODE_OT_add_node", IFACE_(ntype->ui_name), ntype->ui_icon, NULL, WM_OP_INVOKE_DEFAULT, UI_ITEM_O_RETURN_PROPS); + RNA_string_set(&ptr, "type", ntype->idname); + NODE_TYPES_END } } -typedef struct SocketComponentMenuArgs { - PointerRNA ptr; - int x, y, width; - uiButHandleFunc cb; - void *arg1, *arg2; -} SocketComponentMenuArgs; -/* NOTE: this is a block-menu, needs 0 events, otherwise the menu closes */ -static uiBlock *socket_component_menu(bContext *C, ARegion *ar, void *args_v) +static void node_add_menu_foreach_class_cb(void *calldata, int nclass, const char *name) { - SocketComponentMenuArgs *args = (SocketComponentMenuArgs *)args_v; - uiBlock *block; - uiLayout *layout; - - block = uiBeginBlock(C, ar, __func__, UI_EMBOSS); - uiBlockSetFlag(block, UI_BLOCK_KEEP_OPEN); - - layout = uiLayoutColumn(uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, - args->x, args->y + 2, args->width, NODE_DY, UI_GetStyle()), FALSE); - - uiItemR(layout, &args->ptr, "default_value", UI_ITEM_R_EXPAND, "", ICON_NONE); - - return block; + uiLayout *layout= calldata; + uiItemMenuF(layout, IFACE_(name), 0, node_add_menu_class, SET_INT_IN_POINTER(nclass)); } -static void node_socket_button_components(const bContext *C, uiBlock *block, - bNodeTree *ntree, bNode *node, bNodeSocket *sock, - const char *name, int x, int y, int width) + +static void node_add_menu_default(const bContext *C, uiLayout *layout, bNodeTree *ntree) { - if (sock->link || (sock->flag & SOCK_HIDE_VALUE)) - node_socket_button_label(C, block, ntree, node, sock, name, x, y, width); - else { - PointerRNA ptr; - SocketComponentMenuArgs *args; - - RNA_pointer_create(&ntree->id, &RNA_NodeSocket, sock, &ptr); - - args = MEM_callocN(sizeof(SocketComponentMenuArgs), "SocketComponentMenuArgs"); - - args->ptr = ptr; - args->x = x; - args->y = y; - args->width = width; - args->cb = node_sync_cb; - args->arg1 = CTX_wm_space_node(C); - args->arg2 = node; - - uiDefBlockButN(block, socket_component_menu, args, IFACE_(name), x, y + 1, width, NODE_DY - 2, ""); - } + Scene *scene= CTX_data_scene(C); + + if(ntree->typeinfo->foreach_nodeclass) + ntree->typeinfo->foreach_nodeclass(scene, layout, node_add_menu_foreach_class_cb); } -static void node_socket_button_color(const bContext *C, uiBlock *block, - bNodeTree *ntree, bNode *node, bNodeSocket *sock, - const char *name, int x, int y, int width) +/* ****************** SOCKET BUTTON DRAW FUNCTIONS ***************** */ + +static void node_socket_button_label(bContext *UNUSED(C), uiLayout *layout, PointerRNA *ptr, PointerRNA *UNUSED(node_ptr)) { - if (sock->link || (sock->flag & SOCK_HIDE_VALUE)) - node_socket_button_label(C, block, ntree, node, sock, IFACE_(name), x, y, width); - else { - PointerRNA ptr; - uiBut *bt; - int labelw = width - 40; - RNA_pointer_create(&ntree->id, &RNA_NodeSocket, sock, &ptr); - - bt = uiDefButR(block, COLOR, B_NODE_EXEC, "", - x, y + 2, (labelw > 0 ? 40 : width), NODE_DY - 2, - &ptr, "default_value", -1, 0, 0, -1, -1, NULL); - if (node) - uiButSetFunc(bt, node_sync_cb, CTX_wm_space_node(C), node); - - if (name[0] != '\0' && labelw > 0) - uiDefBut(block, LABEL, 0, IFACE_(name), x + 40, y + 2, labelw, NODE_DY - 2, NULL, 0, 0, 0, 0, ""); - } + bNodeSocket *sock = (bNodeSocket *)ptr->data; + uiItemL(layout, sock->name, 0); } -/* standard draw function, display the default input value */ -static void node_draw_input_default(const bContext *C, uiBlock *block, - bNodeTree *ntree, bNode *node, bNodeSocket *sock, - const char *name, int x, int y, int width) +static void node_draw_input_default(bContext *C, uiLayout *layout, PointerRNA *ptr, PointerRNA *node_ptr, int linked) { - bNodeSocketType *stype = ntreeGetSocketType(sock->type); - if (stype->buttonfunc) - stype->buttonfunc(C, block, ntree, node, sock, name, x, y, width); + bNodeSocket *sock = (bNodeSocket *)ptr->data; + if (linked || (sock->flag & SOCK_HIDE_VALUE)) + node_socket_button_label(C, layout, ptr, node_ptr); else - node_socket_button_label(C, block, ntree, node, sock, IFACE_(name), x, y, width); + sock->typeinfo->draw(C, layout, ptr, node_ptr); } -static void node_draw_output_default(const bContext *UNUSED(C), uiBlock *block, - bNodeTree *UNUSED(ntree), bNode *node, bNodeSocket *sock, - const char *name, int UNUSED(x), int UNUSED(y), int UNUSED(width)) +static void node_draw_output_default(bContext *C, uiLayout *layout, PointerRNA *ptr, PointerRNA *node_ptr, int UNUSED(linked)) { - const char *ui_name = IFACE_(name); - float slen; - - UI_ThemeColor(TH_TEXT); - slen = (UI_GetStringWidth(ui_name) + NODE_MARGIN_X) ; - while (slen > NODE_WIDTH(node) && *ui_name) { - ui_name = BLI_str_find_next_char_utf8(ui_name, NULL); - slen = (UI_GetStringWidth(ui_name) + NODE_MARGIN_X); - } - - if (*ui_name) { - uiDefBut(block, LABEL, 0, ui_name, - (int)(sock->locx - slen), (int)(sock->locy - 9.0f), - (short)slen, (short)NODE_DY, - NULL, 0, 0, 0, 0, ""); - } + node_socket_button_label(C, layout, ptr, node_ptr); } + /* ****************** BASE DRAW FUNCTIONS FOR NEW OPERATOR NODES ***************** */ #if 0 /* UNUSED */ @@ -297,25 +250,23 @@ static void node_draw_socket_new(bNodeSocket *sock, float size) static void node_buts_value(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr) { + bNode *node = ptr->data; + /* first output stores value */ + bNodeSocket *output = node->outputs.first; PointerRNA sockptr; - PropertyRNA *prop; - - /* first socket stores value */ - prop = RNA_struct_find_property(ptr, "outputs"); - RNA_property_collection_lookup_int(ptr, prop, 0, &sockptr); + RNA_pointer_create(ptr->id.data, &RNA_NodeSocket, output, &sockptr); uiItemR(layout, &sockptr, "default_value", 0, "", ICON_NONE); } static void node_buts_rgb(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr) { - uiLayout *col; + bNode *node = ptr->data; + /* first output stores value */ + bNodeSocket *output = node->outputs.first; PointerRNA sockptr; - PropertyRNA *prop; - - /* first socket stores value */ - prop = RNA_struct_find_property(ptr, "outputs"); - RNA_property_collection_lookup_int(ptr, prop, 0, &sockptr); + uiLayout *col; + RNA_pointer_create(ptr->id.data, &RNA_NodeSocket, output, &sockptr); col = uiLayoutColumn(layout, FALSE); uiTemplateColorPicker(col, &sockptr, "default_value", 1, 0, 0, 0); @@ -399,14 +350,15 @@ static void node_buts_curvecol(uiLayout *layout, bContext *UNUSED(C), PointerRNA static void node_buts_normal(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr) { - bNodeTree *ntree = (bNodeTree *)ptr->id.data; - bNode *node = (bNode *)ptr->data; - bNodeSocket *sock = node->outputs.first; /* first socket stores normal */ + bNode *node = ptr->data; + /* first output stores normal */ + bNodeSocket *output = node->outputs.first; PointerRNA sockptr; - - RNA_pointer_create(&ntree->id, &RNA_NodeSocket, sock, &sockptr); + RNA_pointer_create(ptr->id.data, &RNA_NodeSocket, output, &sockptr); + uiItemR(layout, &sockptr, "default_value", 0, "", ICON_NONE); } + #if 0 /* not used in 2.5x yet */ static void node_browse_tex_cb(bContext *C, void *ntree_v, void *node_v) { @@ -491,427 +443,6 @@ static int node_resize_area_default(bNode *node, int x, int y) /* ****************** BUTTON CALLBACKS FOR COMMON NODES ***************** */ -/* width of socket columns in group display */ -#define NODE_GROUP_FRAME 120 - -/* based on settings in node, sets drawing rect info. each redraw! */ -/* note: this assumes only 1 group at a time is drawn (linked data) */ -/* in node->totr the entire boundbox for the group is stored */ -static void node_update_group(const bContext *C, bNodeTree *ntree, bNode *gnode) -{ - if (!(gnode->flag & NODE_GROUP_EDIT)) { - node_update_default(C, ntree, gnode); - } - else { - bNodeTree *ngroup = (bNodeTree *)gnode->id; - bNode *node; - bNodeSocket *sock, *gsock; - float locx, locy; - rctf *rect = &gnode->totr; - const float dpi_fac = UI_DPI_FAC; - const float node_group_frame = NODE_GROUP_FRAME * dpi_fac; - const float group_header = 26 * dpi_fac; - int counter; - int dy; - - /* get "global" coords */ - node_to_view(gnode, 0.0f, 0.0f, &locx, &locy); - - /* center them, is a bit of abuse of locx and locy though */ - node_update_nodetree(C, ngroup, locx, locy); - - rect->xmin = rect->xmax = locx; - rect->ymin = rect->ymax = locy; - - counter = 1; - for (node = ngroup->nodes.first; node; node = node->next) { - if (counter) { - *rect = node->totr; - counter = 0; - } - else - BLI_rctf_union(rect, &node->totr); - } - - /* add some room for links to group sockets */ - rect->xmin -= 4 * NODE_DY; - rect->xmax += 4 * NODE_DY; - rect->ymin -= NODE_DY; - rect->ymax += NODE_DY; - - /* input sockets */ - dy = BLI_rctf_cent_y(rect) + (NODE_DY * (BLI_countlist(&gnode->inputs) - 1)); - gsock = ngroup->inputs.first; - sock = gnode->inputs.first; - while (gsock || sock) { - while (sock && !sock->groupsock) { - sock->locx = rect->xmin - node_group_frame; - sock->locy = dy; - - /* prevent long socket lists from growing out of the group box */ - if (dy - 3 * NODE_DYS < rect->ymin) - rect->ymin = dy - 3 * NODE_DYS; - if (dy + 3 * NODE_DYS > rect->ymax) - rect->ymax = dy + 3 * NODE_DYS; - dy -= 2 * NODE_DY; - - sock = sock->next; - } - while (gsock && (!sock || sock->groupsock != gsock)) { - gsock->locx = rect->xmin; - gsock->locy = dy; - - /* prevent long socket lists from growing out of the group box */ - if (dy - 3 * NODE_DYS < rect->ymin) - rect->ymin = dy - 3 * NODE_DYS; - if (dy + 3 * NODE_DYS > rect->ymax) - rect->ymax = dy + 3 * NODE_DYS; - dy -= 2 * NODE_DY; - - gsock = gsock->next; - } - while (sock && gsock && sock->groupsock == gsock) { - gsock->locx = rect->xmin; - sock->locx = rect->xmin - node_group_frame; - sock->locy = gsock->locy = dy; - - /* prevent long socket lists from growing out of the group box */ - if (dy - 3 * NODE_DYS < rect->ymin) - rect->ymin = dy - 3 * NODE_DYS; - if (dy + 3 * NODE_DYS > rect->ymax) - rect->ymax = dy + 3 * NODE_DYS; - dy -= 2 * NODE_DY; - - sock = sock->next; - gsock = gsock->next; - } - } - - /* output sockets */ - dy = BLI_rctf_cent_y(rect) + (NODE_DY * (BLI_countlist(&gnode->outputs) - 1)); - gsock = ngroup->outputs.first; - sock = gnode->outputs.first; - while (gsock || sock) { - while (sock && !sock->groupsock) { - sock->locx = rect->xmax + node_group_frame; - sock->locy = dy - NODE_DYS; - - /* prevent long socket lists from growing out of the group box */ - if (dy - 3 * NODE_DYS < rect->ymin) - rect->ymin = dy - 3 * NODE_DYS; - if (dy + 3 * NODE_DYS > rect->ymax) - rect->ymax = dy + 3 * NODE_DYS; - dy -= 2 * NODE_DY; - - sock = sock->next; - } - while (gsock && (!sock || sock->groupsock != gsock)) { - gsock->locx = rect->xmax; - gsock->locy = dy - NODE_DYS; - - /* prevent long socket lists from growing out of the group box */ - if (dy - 3 * NODE_DYS < rect->ymin) - rect->ymin = dy - 3 * NODE_DYS; - if (dy + 3 * NODE_DYS > rect->ymax) - rect->ymax = dy + 3 * NODE_DYS; - dy -= 2 * NODE_DY; - - gsock = gsock->next; - } - while (sock && gsock && sock->groupsock == gsock) { - gsock->locx = rect->xmax; - sock->locx = rect->xmax + node_group_frame; - sock->locy = gsock->locy = dy - NODE_DYS; - - /* prevent long socket lists from growing out of the group box */ - if (dy - 3 * NODE_DYS < rect->ymin) - rect->ymin = dy - 3 * NODE_DYS; - if (dy + 3 * NODE_DYS > rect->ymax) - rect->ymax = dy + 3 * NODE_DYS; - dy -= 2 * NODE_DY; - - sock = sock->next; - gsock = gsock->next; - } - } - - /* Set the block bounds to clip mouse events from underlying nodes. - * Add margin for header and input/output columns. - */ - uiExplicitBoundsBlock(gnode->block, - rect->xmin - node_group_frame, - rect->ymin, - rect->xmax + node_group_frame, - rect->ymax + group_header); - } -} - -static void update_group_input_cb(bContext *UNUSED(C), void *UNUSED(snode_v), void *ngroup_v) -{ - bNodeTree *ngroup = (bNodeTree *)ngroup_v; - - ngroup->update |= NTREE_UPDATE_GROUP_IN; - ntreeUpdateTree(ngroup); -} - -static void update_group_output_cb(bContext *UNUSED(C), void *UNUSED(snode_v), void *ngroup_v) -{ - bNodeTree *ngroup = (bNodeTree *)ngroup_v; - - ngroup->update |= NTREE_UPDATE_GROUP_OUT; - ntreeUpdateTree(ngroup); -} - -static void draw_group_socket_name(SpaceNode *snode, bNode *gnode, bNodeSocket *sock, - int in_out, float xoffset, float yoffset, short width, short height) -{ - if (sock->flag & SOCK_DYNAMIC) { - bNodeTree *ngroup = (bNodeTree *)gnode->id; - uiBut *but; - but = uiDefBut(gnode->block, TEX, 0, "", - sock->locx + xoffset, sock->locy + 1 + yoffset, width, height, - sock->name, 0, sizeof(sock->name), 0, 0, ""); - if (in_out == SOCK_IN) - uiButSetFunc(but, update_group_input_cb, snode, ngroup); - else - uiButSetFunc(but, update_group_output_cb, snode, ngroup); - } - else { - const char *ui_name = IFACE_(sock->name); - uiDefBut(gnode->block, LABEL, 0, ui_name, - sock->locx + xoffset, sock->locy + 1 + yoffset, width, height, - NULL, 0, 0, 0, 0, ""); - } -} - -static void draw_group_socket(const bContext *C, SpaceNode *snode, bNodeTree *ntree, bNode *gnode, - bNodeSocket *sock, bNodeSocket *gsock, int index, int in_out) -{ - const float dpi_fac = UI_DPI_FAC; - bNodeTree *ngroup = (bNodeTree *)gnode->id; - bNodeSocketType *stype = ntreeGetSocketType(gsock ? gsock->type : sock->type); - uiBut *bt; - float offset; - int draw_value; - const float node_group_frame = NODE_GROUP_FRAME * dpi_fac; - const float socket_size = NODE_SOCKSIZE; - const float arrowbutw = 0.8f * UI_UNIT_X; - const short co_text_w = 72 * dpi_fac; - const float co_margin = 6.0f * dpi_fac; - /* layout stuff for buttons on group left frame */ - const float colw = 0.6f * node_group_frame; - const float col1 = co_margin - node_group_frame; - const float col2 = col1 + colw + co_margin; - const float col3 = -arrowbutw - co_margin; - /* layout stuff for buttons on group right frame */ - const float cor1 = co_margin; - const float cor2 = cor1 + arrowbutw; - const float cor3 = cor2 + arrowbutw + co_margin; - - /* node and group socket circles */ - if (sock) - node_socket_circle_draw(ntree, sock, socket_size, sock->flag & SELECT); - if (gsock) - node_socket_circle_draw(ngroup, gsock, socket_size, gsock->flag & SELECT); - - /* socket name */ - offset = (in_out == SOCK_IN ? col1 : cor3); - if (!gsock) - offset += (in_out == SOCK_IN ? node_group_frame : -node_group_frame); - - /* draw both name and value button if: - * 1) input: not internal - * 2) output: (node type uses const outputs) and (group output is unlinked) - */ - draw_value = 0; - switch (in_out) { - case SOCK_IN: - draw_value = !(gsock && (gsock->flag & SOCK_INTERNAL)); - break; - case SOCK_OUT: - if (gnode->typeinfo->flag & NODE_CONST_OUTPUT) - draw_value = !(gsock && gsock->link); - break; - } - if (draw_value) { - /* both name and value buttons */ - if (gsock) { - draw_group_socket_name(snode, gnode, gsock, in_out, offset, 0, co_text_w, NODE_DY); - if (stype->buttonfunc) - stype->buttonfunc(C, gnode->block, ngroup, NULL, gsock, "", - gsock->locx + offset, gsock->locy - NODE_DY, colw); - } - else { - draw_group_socket_name(snode, gnode, sock, in_out, offset, 0, co_text_w, NODE_DY); - if (stype->buttonfunc) - stype->buttonfunc(C, gnode->block, ngroup, NULL, sock, "", - sock->locx + offset, sock->locy - NODE_DY, colw); - } - } - else { - /* only name, no value button */ - if (gsock) - draw_group_socket_name(snode, gnode, gsock, in_out, offset, -NODE_DYS, co_text_w, NODE_DY); - else - draw_group_socket_name(snode, gnode, sock, in_out, offset, -NODE_DYS, co_text_w, NODE_DY); - } - - if (gsock && (gsock->flag & SOCK_DYNAMIC)) { - /* up/down buttons */ - offset = (in_out == SOCK_IN ? col2 : cor2); - uiBlockSetDirection(gnode->block, UI_TOP); - uiBlockBeginAlign(gnode->block); - bt = uiDefIconButO(gnode->block, BUT, "NODE_OT_group_socket_move_up", 0, ICON_TRIA_UP, - gsock->locx + offset, gsock->locy, arrowbutw, arrowbutw, ""); - if (!gsock->prev || !(gsock->prev->flag & SOCK_DYNAMIC)) - uiButSetFlag(bt, UI_BUT_DISABLED); - RNA_int_set(uiButGetOperatorPtrRNA(bt), "index", index); - RNA_enum_set(uiButGetOperatorPtrRNA(bt), "in_out", in_out); - bt = uiDefIconButO(gnode->block, BUT, "NODE_OT_group_socket_move_down", 0, ICON_TRIA_DOWN, - gsock->locx + offset, gsock->locy - arrowbutw, arrowbutw, arrowbutw, ""); - if (!gsock->next || !(gsock->next->flag & SOCK_DYNAMIC)) - uiButSetFlag(bt, UI_BUT_DISABLED); - RNA_int_set(uiButGetOperatorPtrRNA(bt), "index", index); - RNA_enum_set(uiButGetOperatorPtrRNA(bt), "in_out", in_out); - uiBlockEndAlign(gnode->block); - uiBlockSetDirection(gnode->block, 0); - - /* remove button */ - offset = (in_out == SOCK_IN ? col3 : cor1); - uiBlockSetEmboss(gnode->block, UI_EMBOSSN); - bt = uiDefIconButO(gnode->block, BUT, "NODE_OT_group_socket_remove", 0, ICON_X, - gsock->locx + offset, gsock->locy - 0.5f * arrowbutw, arrowbutw, arrowbutw, ""); - RNA_int_set(uiButGetOperatorPtrRNA(bt), "index", index); - RNA_enum_set(uiButGetOperatorPtrRNA(bt), "in_out", in_out); - uiBlockSetEmboss(gnode->block, UI_EMBOSS); - } -} - -/* groups are, on creation, centered around 0,0 */ -static void node_draw_group(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNode *gnode) -{ - if (!(gnode->flag & NODE_GROUP_EDIT)) { - node_draw_default(C, ar, snode, ntree, gnode); - } - else { - bNodeTree *ngroup = (bNodeTree *)gnode->id; - bNodeSocket *sock, *gsock; - uiLayout *layout; - PointerRNA ptr; - rctf rect = gnode->totr; - const float dpi_fac = UI_DPI_FAC; - const float node_group_frame = NODE_GROUP_FRAME * dpi_fac; - const float group_header = 26 * dpi_fac; - - int index; - - /* backdrop header */ - glEnable(GL_BLEND); - uiSetRoundBox(UI_CNR_TOP_LEFT | UI_CNR_TOP_RIGHT); - UI_ThemeColorShadeAlpha(TH_NODE_GROUP, 0, -70); - uiDrawBox(GL_POLYGON, - rect.xmin - node_group_frame, rect.ymax, - rect.xmax + node_group_frame, rect.ymax + group_header, BASIS_RAD); - - /* backdrop body */ - UI_ThemeColorShadeAlpha(TH_BACK, -8, -70); - uiSetRoundBox(UI_CNR_NONE); - uiDrawBox(GL_POLYGON, rect.xmin, rect.ymin, rect.xmax, rect.ymax, BASIS_RAD); - - /* input column */ - UI_ThemeColorShadeAlpha(TH_BACK, 10, -50); - uiSetRoundBox(UI_CNR_BOTTOM_LEFT); - uiDrawBox(GL_POLYGON, rect.xmin - node_group_frame, rect.ymin, rect.xmin, rect.ymax, BASIS_RAD); - - /* output column */ - UI_ThemeColorShadeAlpha(TH_BACK, 10, -50); - uiSetRoundBox(UI_CNR_BOTTOM_RIGHT); - uiDrawBox(GL_POLYGON, rect.xmax, rect.ymin, rect.xmax + node_group_frame, rect.ymax, BASIS_RAD); - - /* input column separator */ - glColor4ub(200, 200, 200, 140); - glBegin(GL_LINES); - glVertex2f(rect.xmin, rect.ymin); - glVertex2f(rect.xmin, rect.ymax); - glEnd(); - - /* output column separator */ - glColor4ub(200, 200, 200, 140); - glBegin(GL_LINES); - glVertex2f(rect.xmax, rect.ymin); - glVertex2f(rect.xmax, rect.ymax); - glEnd(); - - /* group node outline */ - uiSetRoundBox(UI_CNR_ALL); - glColor4ub(200, 200, 200, 140); - glEnable(GL_LINE_SMOOTH); - uiDrawBox(GL_LINE_LOOP, - rect.xmin - node_group_frame, rect.ymin, - rect.xmax + node_group_frame, rect.ymax + group_header, BASIS_RAD); - glDisable(GL_LINE_SMOOTH); - glDisable(GL_BLEND); - - /* backdrop title */ - UI_ThemeColor(TH_TEXT_HI); - - layout = uiBlockLayout(gnode->block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, - (int)(rect.xmin + NODE_MARGIN_X), (int)(rect.ymax + (group_header - (2.5f * dpi_fac))), - min_ii((int)(BLI_rctf_size_x(&rect) - 18.0f), node_group_frame + 20), group_header, UI_GetStyle()); - RNA_pointer_create(&ntree->id, &RNA_Node, gnode, &ptr); - uiTemplateIDBrowse(layout, (bContext *)C, &ptr, "node_tree", NULL, NULL, NULL); - uiBlockLayoutResolve(gnode->block, NULL, NULL); - - /* draw the internal tree nodes and links */ - node_draw_nodetree(C, ar, snode, ngroup); - - /* group sockets */ - gsock = ngroup->inputs.first; - sock = gnode->inputs.first; - index = 0; - while (gsock || sock) { - while (sock && !sock->groupsock) { - draw_group_socket(C, snode, ntree, gnode, sock, NULL, index, SOCK_IN); - sock = sock->next; - } - while (gsock && (!sock || sock->groupsock != gsock)) { - draw_group_socket(C, snode, ntree, gnode, NULL, gsock, index, SOCK_IN); - gsock = gsock->next; - index++; - } - while (sock && gsock && sock->groupsock == gsock) { - draw_group_socket(C, snode, ntree, gnode, sock, gsock, index, SOCK_IN); - sock = sock->next; - gsock = gsock->next; - index++; - } - } - gsock = ngroup->outputs.first; - sock = gnode->outputs.first; - index = 0; - while (gsock || sock) { - while (sock && !sock->groupsock) { - draw_group_socket(C, snode, ntree, gnode, sock, NULL, index, SOCK_OUT); - sock = sock->next; - } - while (gsock && (!sock || sock->groupsock != gsock)) { - draw_group_socket(C, snode, ntree, gnode, NULL, gsock, index, SOCK_OUT); - gsock = gsock->next; - index++; - } - while (sock && gsock && sock->groupsock == gsock) { - draw_group_socket(C, snode, ntree, gnode, sock, gsock, index, SOCK_OUT); - sock = sock->next; - gsock = gsock->next; - index++; - } - } - - uiEndBlock(C, gnode->block); - uiDrawBlock(C, gnode->block); - gnode->block = NULL; - } -} static void node_uifunc_group(uiLayout *layout, bContext *C, PointerRNA *ptr) { @@ -1003,7 +534,8 @@ static void node_draw_frame_label(bNode *node, const float aspect) BLF_disable(fontid, BLF_ASPECT); } -static void node_draw_frame(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *UNUSED(ntree), bNode *node) +static void node_draw_frame(const bContext *C, ARegion *ar, SpaceNode *snode, + bNodeTree *UNUSED(ntree), bNode *node, bNodeInstanceKey UNUSED(key)) { rctf *rct = &node->totr; int color_id = node_get_colorid(node); @@ -1118,7 +650,8 @@ static void node_update_reroute(const bContext *UNUSED(C), bNodeTree *UNUSED(ntr node->totr.ymin = locy - size; } -static void node_draw_reroute(const bContext *C, ARegion *ar, SpaceNode *UNUSED(snode), bNodeTree *ntree, bNode *node) +static void node_draw_reroute(const bContext *C, ARegion *ar, SpaceNode *UNUSED(snode), + bNodeTree *ntree, bNode *node, bNodeInstanceKey UNUSED(key)) { bNodeSocket *sock; char showname[128]; /* 128 used below */ @@ -1178,7 +711,7 @@ static void node_draw_reroute(const bContext *C, ARegion *ar, SpaceNode *UNUSED( * highlight also if node itself is selected, since we don't display the node body separately! */ for (sock = node->inputs.first; sock; sock = sock->next) { - node_socket_circle_draw(ntree, sock, socket_size, (sock->flag & SELECT) || (node->flag & SELECT)); + node_socket_circle_draw(C, ntree, node, sock, socket_size, (sock->flag & SELECT) || (node->flag & SELECT)); } uiEndBlock(C, node->block); @@ -1205,8 +738,6 @@ static void node_common_set_butfunc(bNodeType *ntype) switch (ntype->type) { case NODE_GROUP: ntype->uifunc = node_uifunc_group; - ntype->drawfunc = node_draw_group; - ntype->drawupdatefunc = node_update_group; break; case NODE_FRAME: ntype->drawfunc = node_draw_frame; @@ -1491,8 +1022,6 @@ static void node_shader_buts_script_details(uiLayout *layout, bContext *C, Point static void node_shader_set_butfunc(bNodeType *ntype) { switch (ntype->type) { - /* case NODE_GROUP: note, typeinfo for group is generated... see "XXX ugly hack" */ - case SH_NODE_MATERIAL: case SH_NODE_MATERIAL_EXT: ntype->uifunc = node_shader_buts_material; @@ -2092,20 +1621,17 @@ static void node_composit_buts_id_mask(uiLayout *layout, bContext *UNUSED(C), Po } /* draw function for file output node sockets, displays only sub-path and format, no value button */ -static void node_draw_input_file_output(const bContext *C, uiBlock *block, - bNodeTree *ntree, bNode *node, bNodeSocket *sock, - const char *UNUSED(name), int x, int y, int width) +static void node_draw_input_file_output(bContext *C, uiLayout *layout, PointerRNA *ptr, PointerRNA *node_ptr, int UNUSED(linked)) { - uiLayout *layout, *row; - PointerRNA nodeptr, inputptr, imfptr; + bNodeTree *ntree = ptr->id.data; + bNodeSocket *sock = ptr->data; + uiLayout *row; + PointerRNA inputptr, imfptr; int imtype; - int rx, ry; - RNA_pointer_create(&ntree->id, &RNA_Node, node, &nodeptr); - layout = uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, x, y + NODE_DY, width, 20, UI_GetStyle()); row = uiLayoutRow(layout, FALSE); - imfptr = RNA_pointer_get(&nodeptr, "format"); + imfptr = RNA_pointer_get(node_ptr, "format"); imtype = RNA_enum_get(&imfptr, "file_format"); if (imtype == R_IMF_IMTYPE_MULTILAYER) { NodeImageMultiFileSocket *input = sock->storage; @@ -2117,6 +1643,7 @@ static void node_draw_input_file_output(const bContext *C, uiBlock *block, NodeImageMultiFileSocket *input = sock->storage; PropertyRNA *imtype_prop; const char *imtype_name; + uiBlock *block; RNA_pointer_create(&ntree->id, &RNA_NodeOutputFileSlotFile, input, &inputptr); uiItemL(row, input->path, ICON_NONE); @@ -2127,12 +1654,11 @@ static void node_draw_input_file_output(const bContext *C, uiBlock *block, imtype_prop = RNA_struct_find_property(&imfptr, "file_format"); RNA_property_enum_name((bContext *)C, &imfptr, imtype_prop, RNA_property_enum_get(&imfptr, imtype_prop), &imtype_name); + block = uiLayoutGetBlock(row); uiBlockSetEmboss(block, UI_EMBOSSP); uiItemL(row, imtype_name, ICON_NONE); uiBlockSetEmboss(block, UI_EMBOSSN); } - - uiBlockLayoutResolve(block, &rx, &ry); } static void node_composit_buts_file_output(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr) { @@ -2781,8 +2307,6 @@ static void node_composit_buts_trackpos(uiLayout *layout, bContext *C, PointerRN static void node_composit_set_butfunc(bNodeType *ntype) { switch (ntype->type) { - /* case NODE_GROUP: note, typeinfo for group is generated... see "XXX ugly hack" */ - case CMP_NODE_IMAGE: ntype->uifunc = node_composit_buts_image; ntype->uifuncbut = node_composit_buts_image_details; @@ -2998,8 +2522,6 @@ static void node_composit_set_butfunc(bNodeType *ntype) case CMP_NODE_TRACKPOS: ntype->uifunc = node_composit_buts_trackpos; break; - default: - ntype->uifunc = NULL; } } @@ -3158,81 +2680,170 @@ static void node_texture_set_butfunc(bNodeType *ntype) /* ******* init draw callbacks for all tree types, only called in usiblender.c, once ************* */ -void ED_node_init_butfuncs(void) +static void node_property_update_default(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr) { - bNodeTreeType *treetype; - bNodeType *ntype; - bNodeSocketType *stype; - int i; + bNodeTree *ntree = ptr->id.data; + ED_node_tag_update_nodetree(bmain, ntree); +} + +static void node_socket_template_properties_update(bNodeType *ntype, bNodeSocketTemplate *stemp) +{ + StructRNA *srna = ntype->ext.srna; + PropertyRNA *prop = RNA_struct_type_find_property(srna, stemp->identifier); - /* node type ui functions */ - for (i = 0; i < NUM_NTREE_TYPES; ++i) { - treetype = ntreeGetType(i); - if (treetype) { - for (ntype = treetype->node_types.first; ntype; ntype = ntype->next) { - /* default ui functions */ - ntype->drawfunc = node_draw_default; - ntype->drawupdatefunc = node_update_default; - ntype->select_area_func = node_select_area_default; - ntype->tweak_area_func = node_tweak_area_default; - ntype->uifunc = NULL; - ntype->uifuncbut = NULL; - ntype->drawinputfunc = node_draw_input_default; - ntype->drawoutputfunc = node_draw_output_default; - ntype->resize_area_func = node_resize_area_default; - - node_common_set_butfunc(ntype); - - switch (i) { - case NTREE_COMPOSIT: - node_composit_set_butfunc(ntype); - break; - case NTREE_SHADER: - node_shader_set_butfunc(ntype); - break; - case NTREE_TEXTURE: - node_texture_set_butfunc(ntype); - break; - } - } - } + if (prop) + RNA_def_property_update_runtime(prop, node_property_update_default); +} + +static void node_template_properties_update(bNodeType *ntype) +{ + bNodeSocketTemplate *stemp; + + if (ntype->inputs) { + for (stemp = ntype->inputs; stemp->type >= 0; ++stemp) + node_socket_template_properties_update(ntype, stemp); } + if (ntype->outputs) { + for (stemp = ntype->outputs; stemp->type >= 0; ++stemp) + node_socket_template_properties_update(ntype, stemp); + } +} + +void ED_node_init_butfuncs(void) +{ + /* node type ui functions */ + NODE_TYPES_BEGIN(ntype) + /* default ui functions */ + ntype->drawfunc = node_draw_default; + ntype->drawupdatefunc = node_update_default; + ntype->select_area_func = node_select_area_default; + ntype->tweak_area_func = node_tweak_area_default; + ntype->uifunc = NULL; + ntype->uifuncbut = NULL; + ntype->drawinputfunc = node_draw_input_default; + ntype->drawoutputfunc = node_draw_output_default; + ntype->resize_area_func = node_resize_area_default; + + node_common_set_butfunc(ntype); + + node_composit_set_butfunc(ntype); + node_shader_set_butfunc(ntype); + node_texture_set_butfunc(ntype); + + /* define update callbacks for socket properties */ + node_template_properties_update(ntype); + NODE_TYPES_END - /* socket type ui functions */ - for (i = 0; i < NUM_SOCKET_TYPES; ++i) { - stype = ntreeGetSocketType(i); - if (stype) { - switch (stype->type) { - case SOCK_FLOAT: - case SOCK_INT: - case SOCK_BOOLEAN: - stype->buttonfunc = node_socket_button_default; - break; - case SOCK_STRING: - stype->buttonfunc = node_socket_button_string; - break; - case SOCK_VECTOR: - stype->buttonfunc = node_socket_button_components; - break; - case SOCK_RGBA: - stype->buttonfunc = node_socket_button_color; - break; - case SOCK_SHADER: - stype->buttonfunc = node_socket_button_label; - break; - default: - stype->buttonfunc = NULL; - } + /* tree type icons */ + ntreeType_Composite->ui_icon = ICON_RENDERLAYERS; + ntreeType_Composite->draw_add_menu = node_add_menu_default; + ntreeType_Shader->ui_icon = ICON_MATERIAL; + ntreeType_Shader->draw_add_menu = node_add_menu_default; + ntreeType_Texture->ui_icon = ICON_TEXTURE; + ntreeType_Texture->draw_add_menu = node_add_menu_default; +} + +void ED_init_custom_node_type(bNodeType *ntype) +{ + /* default ui functions */ + ntype->drawfunc = node_draw_default; + ntype->drawupdatefunc = node_update_default; + ntype->drawinputfunc = node_draw_input_default; + ntype->drawoutputfunc = node_draw_output_default; + ntype->resize_area_func = node_resize_area_default; + ntype->select_area_func = node_select_area_default; + ntype->tweak_area_func = node_tweak_area_default; +} + +void ED_init_custom_node_socket_type(bNodeSocketType *stype) +{ + /* default ui functions */ + stype->draw = node_socket_button_label; +} + +/* maps standard socket integer type to a color */ +static const float std_node_socket_colors[][4] = { + {0.63, 0.63, 0.63, 1.0}, /* SOCK_FLOAT */ + {0.39, 0.39, 0.78, 1.0}, /* SOCK_VECTOR */ + {0.78, 0.78, 0.16, 1.0}, /* SOCK_RGBA */ + {0.39, 0.78, 0.39, 1.0}, /* SOCK_SHADER */ + {0.70, 0.65, 0.19, 1.0}, /* SOCK_BOOLEAN */ + {0.0, 0.0, 0.0, 1.0}, /*__SOCK_MESH (deprecated) */ + {0.06, 0.52, 0.15, 1.0}, /* SOCK_INT */ + {1.0, 1.0, 1.0, 1.0}, /* SOCK_STRING */ +}; + +/* common color callbacks for standard types */ +static void std_node_socket_draw_color(bContext *UNUSED(C), PointerRNA *ptr, PointerRNA *UNUSED(node_ptr), float *r_color) +{ + bNodeSocket *sock = ptr->data; + int type = sock->typeinfo->type; + copy_v4_v4(r_color, std_node_socket_colors[type]); +} +static void std_node_socket_interface_draw_color(bContext *UNUSED(C), PointerRNA *ptr, float *r_color) +{ + bNodeSocket *sock = ptr->data; + int type = sock->typeinfo->type; + copy_v4_v4(r_color, std_node_socket_colors[type]); +} + +static void std_node_socket_draw(bContext *UNUSED(C), uiLayout *layout, PointerRNA *ptr, PointerRNA *UNUSED(node_ptr)) +{ + bNodeSocket *sock = ptr->data; + int type = sock->typeinfo->type; + /*int subtype = sock->typeinfo->subtype;*/ + + switch (type) { + case SOCK_FLOAT: + case SOCK_INT: + case SOCK_BOOLEAN: + uiItemR(layout, ptr, "default_value", 0, sock->name, 0); + break; + case SOCK_VECTOR: + uiTemplateComponentMenu(layout, ptr, "default_value", sock->name); + break; + case SOCK_RGBA: { + uiLayout *row = uiLayoutRow(layout, false); + uiLayoutSetAlignment(row, UI_LAYOUT_ALIGN_LEFT); + /* draw the socket name right of the actual button */ + uiItemR(row, ptr, "default_value", 0, "", 0); + uiItemL(row, sock->name, 0); + break; + } + case SOCK_STRING: { + uiLayout *row = uiLayoutRow(layout, true); + /* draw the socket name right of the actual button */ + uiItemR(row, ptr, "default_value", 0, "", 0); + uiItemL(row, sock->name, 0); + break; } } } +void ED_init_standard_node_socket_type(bNodeSocketType *stype) +{ + stype->draw = std_node_socket_draw; + stype->draw_color = std_node_socket_draw_color; + stype->interface_draw_color = std_node_socket_interface_draw_color; +} + +static void node_socket_virtual_draw_color(bContext *UNUSED(C), PointerRNA *UNUSED(ptr), PointerRNA *UNUSED(node_ptr), float *r_color) +{ + /* alpha = 0, empty circle */ + zero_v4(r_color); +} + +void ED_init_node_socket_type_virtual(bNodeSocketType *stype) +{ + stype->draw = node_socket_button_label; + stype->draw_color = node_socket_virtual_draw_color; +} + /* ************** Generic drawing ************** */ void draw_nodespace_back_pix(const bContext *C, ARegion *ar, SpaceNode *snode) { - - if ((snode->flag & SNODE_BACKDRAW) && snode->treetype == NTREE_COMPOSIT) { + if ((snode->flag & SNODE_BACKDRAW) && ED_node_is_compositor(snode)) { Image *ima = BKE_image_verify_viewer(IMA_TYPE_COMPOSITE, "Viewer Node"); void *lock; ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock); @@ -3640,18 +3251,13 @@ void node_draw_link(View2D *v2d, SpaceNode *snode, bNodeLink *link) do_triple = TRUE; } else { - int cycle = 0; - /* going to give issues once... */ if (link->tosock->flag & SOCK_UNAVAIL) return; if (link->fromsock->flag & SOCK_UNAVAIL) return; - /* check cyclic */ - if (link->fromnode && link->tonode) - cycle = (link->fromnode->level < link->tonode->level || link->tonode->level == 0xFFF); - if (!cycle && (link->flag & NODE_LINK_VALID)) { + if (link->flag & NODE_LINK_VALID) { /* special indicated link, on drop-node */ if (link->flag & NODE_LINKFLAG_HILITE) { th_col1 = th_col2 = TH_ACTIVE; diff --git a/source/blender/editors/space_node/node_add.c b/source/blender/editors/space_node/node_add.c index 235d91ecd92..cd04957c0a5 100644 --- a/source/blender/editors/space_node/node_add.c +++ b/source/blender/editors/space_node/node_add.c @@ -62,62 +62,60 @@ #include "node_intern.h" /* own include */ -/* can be called from menus too, but they should do own undopush and redraws */ -bNode *node_add_node(SpaceNode *snode, Main *bmain, Scene *scene, - bNodeTemplate *ntemp, float locx, float locy) +/* XXX Does some additional initialization on top of nodeAddNode + * Can be used with both custom and static nodes, if idname==NULL the static int type will be used instead. + * Can be called from menus too, but they should do own undopush and redraws. + */ +bNode *node_add_node(const bContext *C, const char *idname, int type, float locx, float locy) { - bNode *node = NULL, *gnode; - + SpaceNode *snode = CTX_wm_space_node(C); + Main *bmain = CTX_data_main(C); + Scene *scene = CTX_data_scene(C); + bNode *node = NULL; + node_deselect_all(snode); - - node = nodeAddNode(snode->edittree, ntemp); - + + if (idname) + node = nodeAddNode(C, snode->edittree, idname); + else + node = nodeAddStaticNode(C, snode->edittree, type); + BLI_assert(node && node->typeinfo); + /* generics */ - if (node) { - node_select(node); - - /* node location is mapped */ - locx /= UI_DPI_FAC; - locy /= UI_DPI_FAC; - - gnode = node_tree_get_editgroup(snode->nodetree); - // arbitrary y offset of 60 so its visible - if (gnode) { - node_from_view(gnode, locx, locy + 60.0f, &node->locx, &node->locy); - } - else { - node->locx = locx; - node->locy = locy + 60.0f; + node->locx = locx; + node->locy = locy + 60.0f; // arbitrary.. so its visible, (0,0) is top of node + nodeSetSelected(node, TRUE); + + /* node location is mapped */ + locx /= UI_DPI_FAC; + locy /= UI_DPI_FAC; + + node->locx = locx; + node->locy = locy + 60.0f; + + ntreeUpdateTree(snode->edittree); + ED_node_set_active(bmain, snode->edittree, node); + + if (snode->nodetree->type == NTREE_COMPOSIT) { + if (ELEM4(node->type, CMP_NODE_R_LAYERS, CMP_NODE_COMPOSITE, CMP_NODE_DEFOCUS, CMP_NODE_OUTPUT_FILE)) { + node->id = &scene->id; } - - ntreeUpdateTree(snode->edittree); - ED_node_set_active(bmain, snode->edittree, node); - - if (snode->nodetree->type == NTREE_COMPOSIT) { - if (ELEM4(node->type, CMP_NODE_R_LAYERS, CMP_NODE_COMPOSITE, CMP_NODE_DEFOCUS, CMP_NODE_OUTPUT_FILE)) { - node->id = &scene->id; - } - else if (ELEM3(node->type, CMP_NODE_MOVIECLIP, CMP_NODE_MOVIEDISTORTION, CMP_NODE_STABILIZE2D)) { - node->id = (ID *)scene->clip; - } - - ntreeCompositForceHidden(snode->edittree, scene); + else if (ELEM3(node->type, CMP_NODE_MOVIECLIP, CMP_NODE_MOVIEDISTORTION, CMP_NODE_STABILIZE2D)) { + node->id = (ID *)scene->clip; } - - if (node->id) - id_us_plus(node->id); - - - if (snode->flag & SNODE_USE_HIDDEN_PREVIEW) - node->flag &= ~NODE_PREVIEW; - - snode_update(snode, node); + + ntreeCompositForceHidden(snode->edittree, scene); } - + + if (node->id) + id_us_plus(node->id); + + snode_update(snode, node); + if (snode->nodetree->type == NTREE_TEXTURE) { ntreeTexCheckCyclics(snode->edittree); } - + return node; } @@ -183,9 +181,7 @@ static bNodeSocketLink *add_reroute_do_socket_section(bContext *C, bNodeSocketLi /* create the reroute node for this cursock */ if (!reroute_node) { - bNodeTemplate ntemp; - ntemp.type = NODE_REROUTE; - reroute_node = nodeAddNode(ntree, &ntemp); + reroute_node = nodeAddStaticNode(C, ntree, NODE_REROUTE); /* add a single link to/from the reroute node to replace multiple links */ if (in_out == SOCK_OUT) { @@ -213,18 +209,11 @@ static bNodeSocketLink *add_reroute_do_socket_section(bContext *C, bNodeSocketLi } if (num_links > 0) { - bNode *gnode = node_tree_get_editgroup(snode->nodetree); - /* average cut point from shared links */ mul_v2_fl(insert_point, 1.0f / num_links); - if (gnode) { - node_from_view(gnode, insert_point[0], insert_point[1], &reroute_node->locx, &reroute_node->locy); - } - else { - reroute_node->locx = insert_point[0]; - reroute_node->locy = insert_point[1]; - } + reroute_node->locx = insert_point[0]; + reroute_node->locy = insert_point[1]; } return socklink; @@ -266,6 +255,8 @@ static int add_reroute_exec(bContext *C, wmOperator *op) output_links.first = output_links.last = NULL; input_links.first = input_links.last = NULL; for (link = ntree->links.first; link; link = link->next) { + if (nodeLinkIsHidden(link)) + continue; if (add_reroute_intersect_check(link, mcoords, i, insert_point)) { add_reroute_insert_socket_link(&output_links, link->fromsock, link, insert_point); add_reroute_insert_socket_link(&input_links, link->tosock, link, insert_point); @@ -330,12 +321,10 @@ void NODE_OT_add_reroute(wmOperatorType *ot) static int node_add_file_exec(bContext *C, wmOperator *op) { - Main *bmain = CTX_data_main(C); - Scene *scene = CTX_data_scene(C); SpaceNode *snode = CTX_wm_space_node(C); bNode *node; Image *ima = NULL; - bNodeTemplate ntemp; + int type= 0; /* check input variables */ if (RNA_struct_property_is_set(op->ptr, "filepath")) { @@ -367,36 +356,35 @@ static int node_add_file_exec(bContext *C, wmOperator *op) switch (snode->nodetree->type) { case NTREE_SHADER: - ntemp.type = SH_NODE_TEX_IMAGE; + type = SH_NODE_TEX_IMAGE; break; case NTREE_TEXTURE: - ntemp.type = TEX_NODE_IMAGE; + type = TEX_NODE_IMAGE; break; case NTREE_COMPOSIT: - ntemp.type = CMP_NODE_IMAGE; + type = CMP_NODE_IMAGE; break; default: return OPERATOR_CANCELLED; } - + ED_preview_kill_jobs(C); - - node = node_add_node(snode, bmain, scene, &ntemp, snode->cursor[0], snode->cursor[1]); - + + node = node_add_node(C, NULL, type, snode->cursor[0], snode->cursor[1]); + if (!node) { BKE_report(op->reports, RPT_WARNING, "Could not add an image node"); return OPERATOR_CANCELLED; } - + node->id = (ID *)ima; - id_us_plus(node->id); - + BKE_image_signal(ima, NULL, IMA_SIGNAL_RELOAD); WM_event_add_notifier(C, NC_IMAGE | NA_EDITED, ima); snode_notify(C, snode); snode_dag_update(C, snode); - + return OPERATOR_FINISHED; } @@ -404,11 +392,11 @@ static int node_add_file_invoke(bContext *C, wmOperator *op, const wmEvent *even { ARegion *ar = CTX_wm_region(C); SpaceNode *snode = CTX_wm_space_node(C); - + /* convert mouse coordinates to v2d space */ UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &snode->cursor[0], &snode->cursor[1]); - + if (RNA_struct_property_is_set(op->ptr, "filepath") || RNA_struct_property_is_set(op->ptr, "name")) return node_add_file_exec(C, op); else @@ -435,35 +423,35 @@ void NODE_OT_add_file(wmOperatorType *ot) RNA_def_string(ot->srna, "name", "Image", MAX_ID_NAME - 2, "Name", "Datablock name to assign"); } - /********************** New node tree operator *********************/ static int new_node_tree_exec(bContext *C, wmOperator *op) { - SpaceNode *snode; + SpaceNode *snode= CTX_wm_space_node(C); + Main *bmain = CTX_data_main(C); bNodeTree *ntree; - Main *bmain; PointerRNA ptr, idptr; PropertyRNA *prop; - int treetype; + const char *idname; char treename[MAX_ID_NAME - 2] = "NodeTree"; - - /* retrieve state */ - snode = CTX_wm_space_node(C); - bmain = CTX_data_main(C); - - if (RNA_struct_property_is_set(op->ptr, "type")) - treetype = RNA_enum_get(op->ptr, "type"); - else - treetype = snode->treetype; - + + if (RNA_struct_property_is_set(op->ptr, "type")) { + prop = RNA_struct_find_property(op->ptr, "type"); + RNA_property_enum_identifier(C, op->ptr, prop, RNA_property_enum_get(op->ptr, prop), &idname); + } + else if (snode) + idname = snode->tree_idname; + if (RNA_struct_property_is_set(op->ptr, "name")) RNA_string_get(op->ptr, "name", treename); - - ntree = ntreeAddTree(bmain, treename, treetype, 0); - if (!ntree) + + if (!ntreeTypeFind(idname)) { + BKE_reportf(op->reports, RPT_ERROR, "Node tree type %s undefined", idname); return OPERATOR_CANCELLED; - + } + + ntree = ntreeAddTree(bmain, treename, idname); + /* hook into UI */ uiIDContextProperty(C, &ptr, &prop); @@ -477,29 +465,36 @@ static int new_node_tree_exec(bContext *C, wmOperator *op) RNA_property_update(C, &ptr, prop); } else if (snode) { - Scene *scene = CTX_data_scene(C); snode->nodetree = ntree; - - ED_node_tree_update(snode, scene); + + ED_node_tree_update(C); } - + return OPERATOR_FINISHED; } +static EnumPropertyItem *new_node_tree_type_itemf(bContext *UNUSED(C), PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), int *free) +{ + return rna_node_tree_type_itemf(NULL, NULL, free); +} + void NODE_OT_new_node_tree(wmOperatorType *ot) { + PropertyRNA *prop; + /* identifiers */ ot->name = "New Node Tree"; ot->idname = "NODE_OT_new_node_tree"; ot->description = "Create a new node tree"; - + /* api callbacks */ ot->exec = new_node_tree_exec; - ot->poll = ED_operator_node_active; - + /* flags */ ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; - - RNA_def_enum(ot->srna, "type", nodetree_type_items, NTREE_COMPOSIT, "Tree Type", ""); + + prop = RNA_def_enum(ot->srna, "type", DummyRNA_NULL_items, 0, "Tree Type", ""); + RNA_def_enum_funcs(prop, new_node_tree_type_itemf); RNA_def_string(ot->srna, "name", "NodeTree", MAX_ID_NAME - 2, "Name", ""); } + diff --git a/source/blender/editors/space_node/node_buttons.c b/source/blender/editors/space_node/node_buttons.c index 300328f5fd4..30cc3b93e8a 100644 --- a/source/blender/editors/space_node/node_buttons.c +++ b/source/blender/editors/space_node/node_buttons.c @@ -62,7 +62,7 @@ static int active_nodetree_poll(const bContext *C, PanelType *UNUSED(pt)) { SpaceNode *snode = CTX_wm_space_node(C); - return (snode && snode->nodetree); + return (snode && ntreeIsValid(snode->nodetree)); } /* poll callback for active node */ @@ -70,7 +70,7 @@ static int active_node_poll(const bContext *C, PanelType *UNUSED(pt)) { SpaceNode *snode = CTX_wm_space_node(C); - return (snode && snode->edittree && nodeGetActive(snode->edittree)); + return (snode && ntreeIsValid(snode->edittree) && nodeGetActive(snode->edittree)); } /* active node */ @@ -160,6 +160,86 @@ static void node_sockets_panel(const bContext *C, Panel *pa) } } +static int node_tree_interface_poll(const bContext *C, PanelType *UNUSED(pt)) +{ + SpaceNode *snode= CTX_wm_space_node(C); + + return (snode && snode->edittree && (snode->edittree->inputs.first || snode->edittree->outputs.first)); +} + +static int node_tree_find_active_socket(bNodeTree *ntree, bNodeSocket **r_sock, int *r_in_out) +{ + bNodeSocket *sock; + for (sock = ntree->inputs.first; sock; sock = sock->next) { + if (sock->flag & SELECT) { + *r_sock = sock; + *r_in_out = SOCK_IN; + return TRUE; + } + } + for (sock = ntree->outputs.first; sock; sock = sock->next) { + if (sock->flag & SELECT) { + *r_sock = sock; + *r_in_out = SOCK_OUT; + return TRUE; + } + } + + *r_sock = NULL; + *r_in_out = 0; + return FALSE; +} + +static void node_tree_interface_panel(const bContext *C, Panel *pa) +{ + SpaceNode *snode= CTX_wm_space_node(C); + bNodeTree *ntree= (snode) ? snode->edittree : NULL; + bNodeSocket *sock; + int in_out; + uiLayout *layout= pa->layout, *row, *split, *col; + PointerRNA ptr, sockptr, opptr; + + if(!ntree) + return; + + RNA_id_pointer_create((ID *)ntree, &ptr); + + node_tree_find_active_socket(ntree, &sock, &in_out); + RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, sock, &sockptr); + + row = uiLayoutRow(layout, FALSE); + + split = uiLayoutRow(row, TRUE); + col = uiLayoutColumn(split, TRUE); + uiItemL(col, "Inputs:", ICON_NONE); + uiTemplateList(col, (bContext*)C, "NODE_UL_interface_sockets", "", &ptr, "inputs", &ptr, "active_input", 0, 0, 0); + opptr = uiItemFullO(col, "NODE_OT_tree_socket_add", "", ICON_PLUS, NULL, WM_OP_EXEC_DEFAULT, UI_ITEM_O_RETURN_PROPS); + RNA_enum_set(&opptr, "in_out", SOCK_IN); + + col = uiLayoutColumn(split, TRUE); + uiItemL(col, "Outputs:", ICON_NONE); + uiTemplateList(col, (bContext*)C, "NODE_UL_interface_sockets", "", &ptr, "outputs", &ptr, "active_output", 0, 0, 0); + opptr = uiItemFullO(col, "NODE_OT_tree_socket_add", "", ICON_PLUS, NULL, WM_OP_EXEC_DEFAULT, UI_ITEM_O_RETURN_PROPS); + RNA_enum_set(&opptr, "in_out", SOCK_OUT); + + col = uiLayoutColumn(row, TRUE); + opptr = uiItemFullO(col, "NODE_OT_tree_socket_move", "", ICON_TRIA_UP, NULL, WM_OP_EXEC_DEFAULT, UI_ITEM_O_RETURN_PROPS); + RNA_enum_set(&opptr, "direction", 1); + opptr = uiItemFullO(col, "NODE_OT_tree_socket_move", "", ICON_TRIA_DOWN, NULL, WM_OP_EXEC_DEFAULT, UI_ITEM_O_RETURN_PROPS); + RNA_enum_set(&opptr, "direction", 2); + + if (sock) { + row = uiLayoutRow(layout, TRUE); + uiItemR(row, &sockptr, "name", 0, NULL, ICON_NONE); + uiItemO(row, "", ICON_X, "NODE_OT_tree_socket_remove"); + + uiItemS(layout); + + if (sock->typeinfo->interface_draw) + sock->typeinfo->interface_draw((bContext*)C, layout, &sockptr); + } +} + /* ******************* node buttons registration ************** */ void node_buttons_register(ARegionType *art) @@ -180,7 +260,14 @@ void node_buttons_register(ARegionType *art) pt->poll = node_sockets_poll; pt->flag |= PNL_DEFAULT_CLOSED; BLI_addtail(&art->paneltypes, pt); - + + pt= MEM_callocN(sizeof(PanelType), "spacetype node panel tree interface"); + strcpy(pt->idname, "NODE_PT_node_tree_interface"); + strcpy(pt->label, "Interface"); + pt->draw= node_tree_interface_panel; + pt->poll= node_tree_interface_poll; + BLI_addtail(&art->paneltypes, pt); + pt = MEM_callocN(sizeof(PanelType), "spacetype node panel gpencil"); strcpy(pt->idname, "NODE_PT_gpencil"); strcpy(pt->label, "Grease Pencil"); diff --git a/source/blender/editors/space_node/node_draw.c b/source/blender/editors/space_node/node_draw.c index d2cc42b0a56..80a6ff1a393 100644 --- a/source/blender/editors/space_node/node_draw.c +++ b/source/blender/editors/space_node/node_draw.c @@ -29,10 +29,14 @@ * \brief higher level node drawing for the node editor. */ +#include "DNA_lamp_types.h" #include "DNA_node_types.h" +#include "DNA_material_types.h" #include "DNA_object_types.h" -#include "DNA_space_types.h" #include "DNA_screen_types.h" +#include "DNA_space_types.h" +#include "DNA_texture_types.h" +#include "DNA_world_types.h" #include "BLI_math.h" #include "BLI_blenlib.h" @@ -44,6 +48,8 @@ #include "BKE_main.h" #include "BKE_node.h" +#include "BLF_api.h" + #include "BIF_gl.h" #include "BIF_glutil.h" @@ -52,6 +58,7 @@ #include "ED_node.h" #include "ED_gpencil.h" +#include "ED_screen.h" #include "ED_space_api.h" #include "UI_resources.h" @@ -65,25 +72,49 @@ /* XXX interface.h */ extern void ui_dropshadow(const rctf *rct, float radius, float aspect, float alpha, int select); -/* XXX update functions for node editor are a mess, needs a clear concept */ -void ED_node_tree_update(SpaceNode *snode, Scene *scene) +void ED_node_tree_update(const bContext *C) { - snode_set_context(snode, scene); + SpaceNode *snode = CTX_wm_space_node(C); + snode_set_context(C); if (snode->nodetree && snode->nodetree->id.us == 0) snode->nodetree->id.us = 1; } -void ED_node_changed_update(ID *id, bNode *node) +/* id is supposed to contain a node tree */ +static bNodeTree *node_tree_from_ID(ID *id) { - bNodeTree *nodetree, *edittree; - int treetype; - - node_tree_from_ID(id, &nodetree, &edittree, &treetype); + if (id) { + short idtype = GS(id->name); + + switch (idtype) { + case ID_NT: + return (bNodeTree*)id; + case ID_MA: + return ((Material*)id)->nodetree; + case ID_LA: + return ((Lamp*)id)->nodetree; + case ID_WO: + return ((World*)id)->nodetree; + case ID_SCE: + return ((Scene*)id)->nodetree; + case ID_TE: + return ((Tex*)id)->nodetree; + } + } + + return NULL; +} - if (treetype == NTREE_SHADER) { +void ED_node_tag_update_id(ID *id) +{ + bNodeTree *ntree = node_tree_from_ID(id); + if (id == NULL) + return; + + if (ntree->type == NTREE_SHADER) { DAG_id_tag_update(id, 0); - + if (GS(id->name) == ID_MA) WM_main_add_notifier(NC_MATERIAL | ND_SHADING_DRAW, id); else if (GS(id->name) == ID_LA) @@ -91,18 +122,10 @@ void ED_node_changed_update(ID *id, bNode *node) else if (GS(id->name) == ID_WO) WM_main_add_notifier(NC_WORLD | ND_WORLD_DRAW, id); } - else if (treetype == NTREE_COMPOSIT) { - if (node) - nodeUpdate(edittree, node); - /* don't use NodeTagIDChanged, it gives far too many recomposites for image, scene layers, ... */ - - node = node_tree_get_editgroup(nodetree); - if (node) - nodeUpdateID(nodetree, node->id); - + else if (ntree->type == NTREE_COMPOSIT) { WM_main_add_notifier(NC_SCENE | ND_NODES, id); } - else if (treetype == NTREE_TEXTURE) { + else if (ntree->type == NTREE_TEXTURE) { DAG_id_tag_update(id, 0); WM_main_add_notifier(NC_TEXTURE | ND_NODES, id); } @@ -123,25 +146,17 @@ static int has_nodetree(bNodeTree *ntree, bNodeTree *lookup) return 0; } -typedef struct NodeUpdateCalldata { - bNodeTree *ntree; - bNode *node; -} NodeUpdateCalldata; -static void node_generic_update_cb(void *calldata, ID *owner_id, bNodeTree *ntree) -{ - NodeUpdateCalldata *cd = (NodeUpdateCalldata *)calldata; - /* check if nodetree uses the group stored in calldata */ - if (has_nodetree(ntree, cd->ntree)) - ED_node_changed_update(owner_id, cd->node); -} -void ED_node_generic_update(Main *bmain, bNodeTree *ntree, bNode *node) +void ED_node_tag_update_nodetree(Main *bmain, bNodeTree *ntree) { - bNodeTreeType *tti = ntreeGetType(ntree->type); - NodeUpdateCalldata cd; - cd.ntree = ntree; - cd.node = node; + if (!ntreeIsValid(ntree)) + return; + /* look through all datablocks, to support groups */ - tti->foreach_nodetree(bmain, &cd, node_generic_update_cb); + FOREACH_NODETREE(bmain, tntree, id) { + /* check if nodetree uses the group */ + if (has_nodetree(tntree, ntree)) + ED_node_tag_update_id(id); + } FOREACH_NODETREE_END if (ntree->type == NTREE_TEXTURE) ntreeTexCheckCyclics(ntree); @@ -251,12 +266,12 @@ void ED_node_sort(bNodeTree *ntree) } -static void do_node_internal_buttons(bContext *C, void *node_v, int event) +static void do_node_internal_buttons(bContext *C, void *UNUSED(node_v), int event) { if (event == B_NODE_EXEC) { SpaceNode *snode = CTX_wm_space_node(C); if (snode && snode->id) - ED_node_changed_update(snode->id, node_v); + ED_node_tag_update_id(snode->id); } } @@ -296,13 +311,15 @@ void node_from_view(struct bNode *node, float x, float y, float *rx, float *ry) /* based on settings in node, sets drawing rect info. each redraw! */ static void node_update_basis(const bContext *C, bNodeTree *ntree, bNode *node) { - uiLayout *layout; - PointerRNA ptr; + uiLayout *layout, *row; + PointerRNA nodeptr, sockptr; bNodeSocket *nsock; float locx, locy; float dy; int buty; + RNA_pointer_create(&ntree->id, &RNA_Node, node, &nodeptr); + /* get "global" coords */ node_to_view(node, 0.0f, 0.0f, &locx, &locy); dy = locy; @@ -313,14 +330,36 @@ static void node_update_basis(const bContext *C, bNodeTree *ntree, bNode *node) /* little bit space in top */ if (node->outputs.first) dy -= NODE_DYS / 2; - + /* output sockets */ for (nsock = node->outputs.first; nsock; nsock = nsock->next) { - if (!nodeSocketIsHidden(nsock)) { - nsock->locx = locx + NODE_WIDTH(node); - nsock->locy = dy - NODE_DYS; - dy -= NODE_DY; - } + if (nodeSocketIsHidden(nsock)) + continue; + + RNA_pointer_create(&ntree->id, &RNA_NodeSocket, nsock, &sockptr); + + layout = uiBlockLayout(node->block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, + locx+NODE_DYS, dy, NODE_WIDTH(node)-NODE_DY, NODE_DY, UI_GetStyle()); + /* context pointers for current node and socket */ + uiLayoutSetContextPointer(layout, "node", &nodeptr); + uiLayoutSetContextPointer(layout, "socket", &sockptr); + + /* align output buttons to the right */ + row = uiLayoutRow(layout, 1); + uiLayoutSetAlignment(row, UI_LAYOUT_ALIGN_RIGHT); + + node->typeinfo->drawoutputfunc((bContext *)C, row, &sockptr, &nodeptr, (nsock->flag & SOCK_IN_USE)); + + uiBlockEndAlign(node->block); + uiBlockLayoutResolve(node->block, NULL, &buty); + + /* ensure minimum socket height in case layout is empty */ + buty = MIN2(buty, dy - NODE_DY); + + nsock->locx = locx + NODE_WIDTH(node); + /* place the socket circle in the middle of the layout */ + nsock->locy = 0.5f * (dy + buty); + dy = buty; } node->prvr.xmin = locx + NODE_DYS; @@ -328,43 +367,32 @@ static void node_update_basis(const bContext *C, bNodeTree *ntree, bNode *node) /* preview rect? */ if (node->flag & NODE_PREVIEW) { - if (node->preview && node->preview->rect) { - float aspect = 1.0f; - - if (node->preview && node->preview->xsize && node->preview->ysize) - aspect = (float)node->preview->ysize / (float)node->preview->xsize; + float aspect = 1.0f; + + if (node->preview_xsize && node->preview_ysize) + aspect = (float)node->preview_ysize / (float)node->preview_xsize; + + dy -= NODE_DYS / 2; + node->prvr.ymax = dy; + + if (aspect <= 1.0f) + node->prvr.ymin = dy - aspect * (NODE_WIDTH(node) - NODE_DY); + else { + /* width correction of image */ + /* XXX huh? (ton) */ + float dx = (NODE_WIDTH(node) - NODE_DYS) - (NODE_WIDTH(node) - NODE_DYS) / aspect; - dy -= NODE_DYS / 2; - node->prvr.ymax = dy; + node->prvr.ymin = dy - (NODE_WIDTH(node) - NODE_DY); - if (aspect <= 1.0f) - node->prvr.ymin = dy - aspect * (NODE_WIDTH(node) - NODE_DY); - else { - /* width correction of image */ - /* XXX huh? (ton) */ - float dx = (NODE_WIDTH(node) - NODE_DYS) - (NODE_WIDTH(node) - NODE_DYS) / aspect; - - node->prvr.ymin = dy - (NODE_WIDTH(node) - NODE_DY); - - node->prvr.xmin += 0.5f * dx; - node->prvr.xmax -= 0.5f * dx; - } - - dy = node->prvr.ymin - NODE_DYS / 2; - - /* make sure that maximums are bigger or equal to minimums */ - if (node->prvr.xmax < node->prvr.xmin) SWAP(float, node->prvr.xmax, node->prvr.xmin); - if (node->prvr.ymax < node->prvr.ymin) SWAP(float, node->prvr.ymax, node->prvr.ymin); - } - else { - float oldh = BLI_rctf_size_y(&node->prvr); - if (oldh == 0.0f) - oldh = 0.6f * NODE_WIDTH(node) - NODE_DY; - dy -= NODE_DYS / 2; - node->prvr.ymax = dy; - node->prvr.ymin = dy - oldh; - dy = node->prvr.ymin - NODE_DYS / 2; + node->prvr.xmin += 0.5f * dx; + node->prvr.xmax -= 0.5f * dx; } + + dy = node->prvr.ymin - NODE_DYS / 2; + + /* make sure that maximums are bigger or equal to minimums */ + if (node->prvr.xmax < node->prvr.xmin) SWAP(float, node->prvr.xmax, node->prvr.xmin); + if (node->prvr.ymax < node->prvr.ymin) SWAP(float, node->prvr.ymax, node->prvr.ymin); } /* buttons rect? */ @@ -378,14 +406,12 @@ static void node_update_basis(const bContext *C, bNodeTree *ntree, bNode *node) node->butr.ymin = 0; node->butr.ymax = 0; - RNA_pointer_create(&ntree->id, &RNA_Node, node, &ptr); - layout = uiBlockLayout(node->block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, locx + NODE_DYS, dy, node->butr.xmax, 0, UI_GetStyle()); - uiLayoutSetContextPointer(layout, "node", &ptr); + uiLayoutSetContextPointer(layout, "node", &nodeptr); - node->typeinfo->uifunc(layout, (bContext *)C, &ptr); + node->typeinfo->uifunc(layout, (bContext *)C, &nodeptr); uiBlockEndAlign(node->block); uiBlockLayoutResolve(node->block, NULL, &buty); @@ -395,11 +421,29 @@ static void node_update_basis(const bContext *C, bNodeTree *ntree, bNode *node) /* input sockets */ for (nsock = node->inputs.first; nsock; nsock = nsock->next) { - if (!nodeSocketIsHidden(nsock)) { - nsock->locx = locx; - nsock->locy = dy - NODE_DYS; - dy -= NODE_DY; - } + if (nodeSocketIsHidden(nsock)) + continue; + + RNA_pointer_create(&ntree->id, &RNA_NodeSocket, nsock, &sockptr); + + layout = uiBlockLayout(node->block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, + locx+NODE_DYS, dy, NODE_WIDTH(node)-NODE_DY, NODE_DY, UI_GetStyle()); + /* context pointers for current node and socket */ + uiLayoutSetContextPointer(layout, "node", &nodeptr); + uiLayoutSetContextPointer(layout, "socket", &sockptr); + + node->typeinfo->drawinputfunc((bContext *)C, layout, &sockptr, &nodeptr, (nsock->flag & SOCK_IN_USE)); + + uiBlockEndAlign(node->block); + uiBlockLayoutResolve(node->block, NULL, &buty); + + /* ensure minimum socket height in case layout is empty */ + buty = MIN2(buty, dy - NODE_DY); + + nsock->locx = locx; + /* place the socket circle in the middle of the layout */ + nsock->locy = 0.5f * (dy + buty); + dy = buty; } /* little bit space in end */ @@ -510,6 +554,7 @@ int node_get_colorid(bNode *node) case NODE_CLASS_OP_VECTOR: case NODE_CLASS_OP_FILTER: return TH_NODE_OPERATOR; case NODE_CLASS_GROUP: return TH_NODE_GROUP; + case NODE_CLASS_INTERFACE: return TH_NODE_INTERFACE; case NODE_CLASS_MATTE: return TH_NODE_MATTE; case NODE_CLASS_DISTORT: return TH_NODE_DISTORT; default: return TH_NODE; @@ -534,7 +579,7 @@ static void node_draw_mute_line(View2D *v2d, SpaceNode *snode, bNode *node) } /* this might have some more generic use */ -static void node_circle_draw(float x, float y, float size, char *col, int highlight) +static void node_circle_draw(float x, float y, float size, float *col, int highlight) { /* 16 values of sin function */ static float si[16] = { @@ -552,12 +597,14 @@ static void node_circle_draw(float x, float y, float size, char *col, int highli }; int a; - glColor3ub(col[0], col[1], col[2]); + glColor4fv(col); + glEnable(GL_BLEND); glBegin(GL_POLYGON); for (a = 0; a < 16; a++) glVertex2f(x + size * si[a], y + size * co[a]); glEnd(); + glDisable(GL_BLEND); if (highlight) { UI_ThemeColor(TH_TEXT_HI); @@ -577,66 +624,93 @@ static void node_circle_draw(float x, float y, float size, char *col, int highli glLineWidth(1.0f); } -void node_socket_circle_draw(bNodeTree *UNUSED(ntree), bNodeSocket *sock, float size, int highlight) +void node_socket_circle_draw(const bContext *C, bNodeTree *ntree, bNode *node, bNodeSocket *sock, float size, int highlight) { - bNodeSocketType *stype = ntreeGetSocketType(sock->type); - node_circle_draw(sock->locx, sock->locy, size, stype->ui_color, highlight); + PointerRNA ptr, node_ptr; + float color[4]; + + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr); + RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr); + sock->typeinfo->draw_color((bContext *)C, &ptr, &node_ptr, color); + node_circle_draw(sock->locx, sock->locy, size, color, highlight); } /* ************** Socket callbacks *********** */ -/* not a callback */ -static void node_draw_preview(bNodePreview *preview, rctf *prv) +static void node_draw_preview_background(float tile, rctf *rect) { - float xscale = BLI_rctf_size_x(prv) / ((float)preview->xsize); - float yscale = BLI_rctf_size_y(prv) / ((float)preview->ysize); - float tile = BLI_rctf_size_x(prv) / 10.0f; float x, y; /* draw checkerboard backdrop to show alpha */ glColor3ub(120, 120, 120); - glRectf(prv->xmin, prv->ymin, prv->xmax, prv->ymax); + glRectf(rect->xmin, rect->ymin, rect->xmax, rect->ymax); glColor3ub(160, 160, 160); - for (y = prv->ymin; y < prv->ymax; y += tile * 2) { - for (x = prv->xmin; x < prv->xmax; x += tile * 2) { + for (y = rect->ymin; y < rect->ymax; y += tile * 2) { + for (x = rect->xmin; x < rect->xmax; x += tile * 2) { float tilex = tile, tiley = tile; - if (x + tile > prv->xmax) - tilex = prv->xmax - x; - if (y + tile > prv->ymax) - tiley = prv->ymax - y; + if (x + tile > rect->xmax) + tilex = rect->xmax - x; + if (y + tile > rect->ymax) + tiley = rect->ymax - y; glRectf(x, y, x + tilex, y + tiley); } } - for (y = prv->ymin + tile; y < prv->ymax; y += tile * 2) { - for (x = prv->xmin + tile; x < prv->xmax; x += tile * 2) { + for (y = rect->ymin + tile; y < rect->ymax; y += tile * 2) { + for (x = rect->xmin + tile; x < rect->xmax; x += tile * 2) { float tilex = tile, tiley = tile; - if (x + tile > prv->xmax) - tilex = prv->xmax - x; - if (y + tile > prv->ymax) - tiley = prv->ymax - y; + if (x + tile > rect->xmax) + tilex = rect->xmax - x; + if (y + tile > rect->ymax) + tiley = rect->ymax - y; glRectf(x, y, x + tilex, y + tiley); } } - - glPixelZoom(xscale, yscale); +} +/* not a callback */ +static void node_draw_preview(bNodePreview *preview, rctf *prv) +{ + float xrect = BLI_rctf_size_x(prv); + float yrect = BLI_rctf_size_y(prv); + float xscale = xrect / ((float)preview->xsize); + float yscale = yrect / ((float)preview->ysize); + float scale; + rctf draw_rect; + + /* uniform scale and offset */ + draw_rect = *prv; + if (xscale < yscale) { + float offset = 0.5f * (yrect - ((float)preview->ysize) * xscale); + draw_rect.ymin += offset; + draw_rect.ymax -= offset; + scale = xscale; + } + else { + float offset = 0.5f * (xrect - ((float)preview->xsize) * yscale); + draw_rect.xmin += offset; + draw_rect.xmax -= offset; + scale = yscale; + } + + node_draw_preview_background(BLI_rctf_size_x(prv) / 10.0f, &draw_rect); + glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); /* premul graphics */ glColor4f(1.0, 1.0, 1.0, 1.0); - glaDrawPixelsTex(prv->xmin, prv->ymin, preview->xsize, preview->ysize, GL_UNSIGNED_BYTE, GL_LINEAR, preview->rect); + glPixelZoom(scale, scale); + glaDrawPixelsTex(draw_rect.xmin, draw_rect.ymin, preview->xsize, preview->ysize, GL_UNSIGNED_BYTE, GL_LINEAR, preview->rect); + glPixelZoom(1.0f, 1.0f); glDisable(GL_BLEND); - glPixelZoom(1.0f, 1.0f); UI_ThemeColorShadeAlpha(TH_BACK, -15, +100); - fdrawbox(prv->xmin, prv->ymin, prv->xmax, prv->ymax); - + fdrawbox(draw_rect.xmin, draw_rect.ymin, draw_rect.xmax, draw_rect.ymax); } /* common handle function for operator buttons that need to select the node first */ @@ -669,8 +743,9 @@ void node_draw_shadow(SpaceNode *snode, bNode *node, float radius, float alpha) } } -static void node_draw_basis(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNode *node) +static void node_draw_basis(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNode *node, bNodeInstanceKey key) { + bNodeInstanceHash *previews = CTX_data_pointer_get(C, "node_previews").data; bNodeSocket *sock; rctf *rct = &node->totr; float iconofs; @@ -680,9 +755,9 @@ static void node_draw_basis(const bContext *C, ARegion *ar, SpaceNode *snode, bN char showname[128]; /* 128 used below */ View2D *v2d = &ar->v2d; - /* hurmf... another candidate for callback, have to see how this works first */ - if (node->id && node->block && snode->treetype == NTREE_SHADER) - nodeShaderSynchronizeID(node, 0); + /* XXX hack: copy values from linked ID data where displayed as sockets */ + if (node->block) + nodeSynchronizeID(node, false); /* skip if out of view */ if (BLI_rctf_isect(&node->totr, &ar->v2d.cur, NULL) == FALSE) { @@ -823,11 +898,7 @@ static void node_draw_basis(const bContext *C, ARegion *ar, SpaceNode *snode, bN if (nodeSocketIsHidden(sock)) continue; - node_socket_circle_draw(ntree, sock, NODE_SOCKSIZE, sock->flag & SELECT); - - node->typeinfo->drawinputfunc(C, node->block, ntree, node, sock, IFACE_(sock->name), - sock->locx + (NODE_DYS), sock->locy - NODE_DYS, - NODE_WIDTH(node) - NODE_DY); + node_socket_circle_draw(C, ntree, node, sock, NODE_SOCKSIZE, sock->flag & SELECT); } /* socket outputs */ @@ -835,17 +906,14 @@ static void node_draw_basis(const bContext *C, ARegion *ar, SpaceNode *snode, bN if (nodeSocketIsHidden(sock)) continue; - node_socket_circle_draw(ntree, sock, NODE_SOCKSIZE, sock->flag & SELECT); - - node->typeinfo->drawoutputfunc(C, node->block, ntree, node, sock, IFACE_(sock->name), - sock->locx - NODE_WIDTH(node) + (NODE_DYS), sock->locy - NODE_DYS, - NODE_WIDTH(node) - NODE_DY); + node_socket_circle_draw(C, ntree, node, sock, NODE_SOCKSIZE, sock->flag & SELECT); } /* preview */ if (node->flag & NODE_PREVIEW) { - if (node->preview && node->preview->rect && !BLI_rctf_is_empty(&node->prvr)) - node_draw_preview(node->preview, &node->prvr); + bNodePreview *preview = previews ? BKE_node_instance_hash_lookup(previews, key) : NULL; + if (preview && preview->rect && !BLI_rctf_is_empty(&node->prvr)) + node_draw_preview(preview, &node->prvr); } UI_ThemeClearColor(color_id); @@ -855,7 +923,7 @@ static void node_draw_basis(const bContext *C, ARegion *ar, SpaceNode *snode, bN node->block = NULL; } -static void node_draw_hidden(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNode *node) +static void node_draw_hidden(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNode *node, bNodeInstanceKey UNUSED(key)) { bNodeSocket *sock; rctf *rct = &node->totr; @@ -957,12 +1025,12 @@ static void node_draw_hidden(const bContext *C, ARegion *ar, SpaceNode *snode, b /* sockets */ for (sock = node->inputs.first; sock; sock = sock->next) { if (!nodeSocketIsHidden(sock)) - node_socket_circle_draw(snode->nodetree, sock, socket_size, sock->flag & SELECT); + node_socket_circle_draw(C, ntree, node, sock, socket_size, sock->flag & SELECT); } for (sock = node->outputs.first; sock; sock = sock->next) { if (!nodeSocketIsHidden(sock)) - node_socket_circle_draw(snode->nodetree, sock, socket_size, sock->flag & SELECT); + node_socket_circle_draw(C, ntree, node, sock, socket_size, sock->flag & SELECT); } uiEndBlock(C, node->block); @@ -989,7 +1057,7 @@ void node_set_cursor(wmWindow *win, SpaceNode *snode) bNodeSocket *sock; int cursor = CURSOR_STD; - if (ntree) { + if (ntreeIsValid(ntree)) { if (node_find_indicated_socket(snode, &node, &sock, SOCK_IN | SOCK_OUT)) { /* pass */ } @@ -1009,12 +1077,12 @@ void node_set_cursor(wmWindow *win, SpaceNode *snode) WM_cursor_set(win, cursor); } -void node_draw_default(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNode *node) +void node_draw_default(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNode *node, bNodeInstanceKey key) { if (node->flag & NODE_HIDDEN) - node_draw_hidden(C, ar, snode, ntree, node); + node_draw_hidden(C, ar, snode, ntree, node, key); else - node_draw_basis(C, ar, snode, ntree, node); + node_draw_basis(C, ar, snode, ntree, node, key); } static void node_update(const bContext *C, bNodeTree *ntree, bNode *node) @@ -1023,34 +1091,28 @@ static void node_update(const bContext *C, bNodeTree *ntree, bNode *node) node->typeinfo->drawupdatefunc(C, ntree, node); } -void node_update_nodetree(const bContext *C, bNodeTree *ntree, float offsetx, float offsety) +void node_update_nodetree(const bContext *C, bNodeTree *ntree) { bNode *node; /* update nodes front to back, so children sizes get updated before parents */ for (node = ntree->nodes.last; node; node = node->prev) { - /* XXX little hack (not used anyore?) */ - node->locx += offsetx; - node->locy += offsety; - node_update(C, ntree, node); - - node->locx -= offsetx; - node->locy -= offsety; } } -static void node_draw(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNode *node) +static void node_draw(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNode *node, bNodeInstanceKey key) { if (node->typeinfo->drawfunc) - node->typeinfo->drawfunc(C, ar, snode, ntree, node); + node->typeinfo->drawfunc(C, ar, snode, ntree, node, key); } #define USE_DRAW_TOT_UPDATE -void node_draw_nodetree(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree) +void node_draw_nodetree(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNodeInstanceKey parent_key) { bNode *node; + bNodeInstanceKey key; bNodeLink *link; int a; @@ -1073,122 +1135,200 @@ void node_draw_nodetree(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeT if (!(node->flag & NODE_BACKGROUND)) continue; + + key = BKE_node_instance_key(parent_key, ntree, node); node->nr = a; /* index of node in list, used for exec event code */ - node_draw(C, ar, snode, ntree, node); + node_draw(C, ar, snode, ntree, node, key); } /* node lines */ glEnable(GL_BLEND); glEnable(GL_LINE_SMOOTH); - for (link = ntree->links.first; link; link = link->next) - node_draw_link(&ar->v2d, snode, link); + for (link = ntree->links.first; link; link = link->next) { + if (!nodeLinkIsHidden(link)) + node_draw_link(&ar->v2d, snode, link); + } glDisable(GL_LINE_SMOOTH); glDisable(GL_BLEND); /* draw foreground nodes, last nodes in front */ for (a = 0, node = ntree->nodes.first; node; node = node->next, a++) { + bNodeInstanceKey key = BKE_node_instance_key(parent_key, ntree, node); if (node->flag & NODE_BACKGROUND) continue; + + key = BKE_node_instance_key(parent_key, ntree, node); node->nr = a; /* index of node in list, used for exec event code */ - node_draw(C, ar, snode, ntree, node); + node_draw(C, ar, snode, ntree, node, key); } } -void drawnodespace(const bContext *C, ARegion *ar, View2D *v2d) +/* draw tree path info in lower left corner */ +static void draw_tree_path(SpaceNode *snode) +{ + char info[256]; + + ED_node_tree_path_get_fixedbuf(snode, info, sizeof(info)); + + UI_ThemeColor(TH_TEXT_HI); + BLF_draw_default(30, 30, 0.0f, info, sizeof(info)); +} + +static void snode_setup_v2d(SpaceNode *snode, ARegion *ar, float centerx, float centery) +{ + View2D *v2d = &ar->v2d; + + /* shift view to node tree center */ + UI_view2d_setcenter(v2d, centerx, centery); + UI_view2d_view_ortho(v2d); + + /* aspect+font, set each time */ + snode->aspect = BLI_rctf_size_x(&v2d->cur) / (float)ar->winx; + // XXX snode->curfont = uiSetCurFont_ext(snode->aspect); +} + +static void draw_nodetree(const bContext *C, ARegion *ar, bNodeTree *ntree, bNodeInstanceKey parent_key) +{ + SpaceNode *snode = CTX_wm_space_node(C); + + node_uiblocks_init(C, ntree); + +#ifdef WITH_COMPOSITOR + if (ntree->type == NTREE_COMPOSIT) { + COM_startReadHighlights(); + } +#endif + + node_update_nodetree(C, ntree); + node_draw_nodetree(C, ar, snode, ntree, parent_key); +} + +/* shade the parent node group and add a uiBlock to clip mouse events */ +static void draw_group_overlay(const bContext *C, ARegion *ar) +{ + View2D *v2d = &ar->v2d; + rctf rect = v2d->cur; + uiBlock *block; + + /* shade node groups to separate them visually */ + UI_ThemeColorShadeAlpha(TH_NODE_GROUP, 0, -70); + glEnable(GL_BLEND); + uiSetRoundBox(0); + uiDrawBox(GL_POLYGON, rect.xmin, rect.ymin, rect.xmax, rect.ymax, 0); + glDisable(GL_BLEND); + + /* set the block bounds to clip mouse events from underlying nodes */ + block = uiBeginBlock(C, ar, "node tree bounds block", UI_EMBOSS); + uiExplicitBoundsBlock(block, rect.xmin, rect.ymin, rect.xmax, rect.ymax); + uiBlockSetFlag(block, UI_BLOCK_CLIP_EVENTS); + uiEndBlock(C, block); +} + +void drawnodespace(const bContext *C, ARegion *ar) { View2DScrollers *scrollers; SpaceNode *snode = CTX_wm_space_node(C); - bNodeLinkDrag *nldrag; - LinkData *linkdata; + View2D *v2d = &ar->v2d; UI_ThemeClearColor(TH_BACK); glClear(GL_COLOR_BUFFER_BIT); UI_view2d_view_ortho(v2d); - - //uiFreeBlocksWin(&sa->uiblocks, sa->win); ED_region_draw_cb_draw(C, ar, REGION_DRAW_PRE_VIEW); /* only set once */ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_MAP1_VERTEX_3); - - /* aspect+font, set each time */ - snode->aspect = BLI_rctf_size_x(&v2d->cur) / (float)ar->winx; - // XXX snode->curfont = uiSetCurFont_ext(snode->aspect); - - /* grid */ - UI_view2d_multi_grid_draw(v2d, U.widget_unit, 5, 2); - - /* backdrop */ - draw_nodespace_back_pix(C, ar, snode); /* nodes */ - snode_set_context(snode, CTX_data_scene(C)); - - if (snode->nodetree) { - bNode *node; - /* void **highlights = 0; */ /* UNUSED */ + snode_set_context(C); + + /* draw parent node trees */ + if (snode->treepath.last) { + static const int max_depth = 2; + bNodeTreePath *path; + int depth, curdepth; + float center[2]; + bNodeTree *ntree; + bNodeLinkDrag *nldrag; + LinkData *linkdata; - node_uiblocks_init(C, snode->nodetree); + /* current View2D center, will be set temporarily for parent node trees */ + UI_view2d_getcenter(v2d, ¢er[0], ¢er[1]); - /* uiBlocks must be initialized in drawing order for correct event clipping. - * Node group internal blocks added after the main group block. - */ - for (node = snode->nodetree->nodes.first; node; node = node->next) { - if (node->flag & NODE_GROUP_EDIT) - node_uiblocks_init(C, (bNodeTree *)node->id); + /* store new view center in current edittree */ + if (snode->edittree) + copy_v2_v2(snode->edittree->view_center, center); + + depth = 0; + path = snode->treepath.last; + while (path->prev && depth < max_depth) { + path = path->prev; + ++depth; + } + /* parent node trees in the background */ + for (curdepth = depth; curdepth >= 0; path = path->next, --curdepth) { + ntree = path->nodetree; + + if (ntreeIsValid(ntree)) { + snode_setup_v2d(snode, ar, ntree->view_center[0], ntree->view_center[1]); + + if (curdepth == 0) { + /* grid, uses theme color based on node path depth */ + UI_view2d_multi_grid_draw(v2d, (depth > 0 ? TH_NODE_GROUP : TH_BACK), U.widget_unit, 5, 2); + + /* backdrop */ + draw_nodespace_back_pix(C, ar, snode); + } + + draw_nodetree(C, ar, ntree, path->parent_key); + + if (curdepth > 0) + draw_group_overlay(C, ar); + } } - node_update_nodetree(C, snode->nodetree, 0.0f, 0.0f); - -#ifdef WITH_COMPOSITOR - if (snode->nodetree->type == NTREE_COMPOSIT) { - COM_startReadHighlights(); + /* reset View2D */ + UI_view2d_setcenter(v2d, center[0], center[1]); + + /* temporary links */ + glEnable(GL_BLEND); + glEnable(GL_LINE_SMOOTH); + for (nldrag = snode->linkdrag.first; nldrag; nldrag = nldrag->next) { + for (linkdata = nldrag->links.first; linkdata; linkdata = linkdata->next) + node_draw_link(v2d, snode, (bNodeLink *)linkdata->data); } -#endif - - node_draw_nodetree(C, ar, snode, snode->nodetree); + glDisable(GL_LINE_SMOOTH); + glDisable(GL_BLEND); - #if 0 - /* active group */ - for (node = snode->nodetree->nodes.first; node; node = node->next) { - if (node->flag & NODE_GROUP_EDIT) - node_draw_group(C, ar, snode, snode->nodetree, node); + if (snode->flag & SNODE_SHOW_GPENCIL) { + /* draw grease-pencil ('canvas' strokes) */ + draw_gpencil_view2d(C, TRUE); } - #endif } - - /* temporary links */ - glEnable(GL_BLEND); - glEnable(GL_LINE_SMOOTH); - for (nldrag = snode->linkdrag.first; nldrag; nldrag = nldrag->next) { - for (linkdata = nldrag->links.first; linkdata; linkdata = linkdata->next) { - node_draw_link(&ar->v2d, snode, (bNodeLink *)linkdata->data); - } + else { + /* default grid */ + UI_view2d_multi_grid_draw(v2d, TH_BACK, U.widget_unit, 5, 2); + + /* backdrop */ + draw_nodespace_back_pix(C, ar, snode); } - glDisable(GL_LINE_SMOOTH); - glDisable(GL_BLEND); ED_region_draw_cb_draw(C, ar, REGION_DRAW_POST_VIEW); - if (snode->flag & SNODE_SHOW_GPENCIL) { - /* draw grease-pencil ('canvas' strokes) */ - if (snode->nodetree) { - draw_gpencil_view2d(C, TRUE); - } - } - /* reset view matrix */ UI_view2d_view_restore(C); - if (snode->flag & SNODE_SHOW_GPENCIL) { - /* draw grease-pencil (screen strokes, and also paintbuffer) */ - if (snode->nodetree) { + if (snode->treepath.last) { + if (snode->flag & SNODE_SHOW_GPENCIL) { + /* draw grease-pencil (screen strokes, and also paintbuffer) */ draw_gpencil_view2d(C, FALSE); } } + + /* tree path info */ + draw_tree_path(snode); /* scrollers */ scrollers = UI_view2d_scrollers_calc(C, v2d, 10, V2D_GRID_CLAMP, V2D_ARG_DUMMY, V2D_ARG_DUMMY); diff --git a/source/blender/editors/space_node/node_edit.c b/source/blender/editors/space_node/node_edit.c index 941bd783c39..2012284f39b 100644 --- a/source/blender/editors/space_node/node_edit.c +++ b/source/blender/editors/space_node/node_edit.c @@ -31,6 +31,8 @@ #include "MEM_guardedalloc.h" +#include "DNA_action_types.h" +#include "DNA_anim_types.h" #include "DNA_lamp_types.h" #include "DNA_material_types.h" #include "DNA_node_types.h" @@ -65,6 +67,7 @@ #include "RNA_access.h" #include "RNA_define.h" +#include "RNA_enum_types.h" #include "WM_api.h" #include "WM_types.h" @@ -76,6 +79,12 @@ #include "IMB_imbuf_types.h" #include "node_intern.h" /* own include */ +#include "NOD_common.h" +#include "NOD_socket.h" +#include "NOD_composite.h" +#include "NOD_shader.h" +#include "NOD_texture.h" + #define USE_ESC_COMPO @@ -241,27 +250,12 @@ int composite_node_active(bContext *C) { if (ED_operator_node_active(C)) { SpaceNode *snode = CTX_wm_space_node(C); - if (snode->treetype == NTREE_COMPOSIT) + if (ED_node_is_compositor(snode)) return 1; } return 0; } -/* also checks for edited groups */ -bNode *editnode_get_active(bNodeTree *ntree) -{ - bNode *node; - - /* check for edited group */ - for (node = ntree->nodes.first; node; node = node->next) - if (nodeGroupEditGet(node)) - break; - if (node) - return nodeGetActive((bNodeTree *)node->id); - else - return nodeGetActive(ntree); -} - static int has_nodetree(bNodeTree *ntree, bNodeTree *lookup) { bNode *node; @@ -277,20 +271,16 @@ static int has_nodetree(bNodeTree *ntree, bNodeTree *lookup) return 0; } -static void snode_dag_update_group(void *calldata, ID *owner_id, bNodeTree *ntree) -{ - if (has_nodetree(ntree, calldata)) - DAG_id_tag_update(owner_id, 0); -} - void snode_dag_update(bContext *C, SpaceNode *snode) { Main *bmain = CTX_data_main(C); /* for groups, update all ID's using this */ if (snode->edittree != snode->nodetree) { - bNodeTreeType *tti = ntreeGetType(snode->edittree->type); - tti->foreach_nodetree(bmain, snode->edittree, snode_dag_update_group); + FOREACH_NODETREE(bmain, tntree, id) { + if (has_nodetree(tntree, snode->edittree)) + DAG_id_tag_update(id, 0); + } FOREACH_NODETREE_END } DAG_id_tag_update(snode->id, 0); @@ -300,37 +290,53 @@ void snode_notify(bContext *C, SpaceNode *snode) { WM_event_add_notifier(C, NC_NODE | NA_EDITED, NULL); - if (snode->treetype == NTREE_SHADER) + if(ED_node_is_shader(snode)) WM_event_add_notifier(C, NC_MATERIAL | ND_NODES, snode->id); - else if (snode->treetype == NTREE_COMPOSIT) + else if(ED_node_is_compositor(snode)) WM_event_add_notifier(C, NC_SCENE | ND_NODES, snode->id); - else if (snode->treetype == NTREE_TEXTURE) + else if(ED_node_is_texture(snode)) WM_event_add_notifier(C, NC_TEXTURE | ND_NODES, snode->id); } -bNode *node_tree_get_editgroup(bNodeTree *nodetree) +void ED_node_set_tree_type(SpaceNode *snode, bNodeTreeType *typeinfo) { - bNode *gnode; - - /* get the groupnode */ - for (gnode = nodetree->nodes.first; gnode; gnode = gnode->next) - if (nodeGroupEditGet(gnode)) - break; - return gnode; + if (typeinfo) + BLI_strncpy(snode->tree_idname, typeinfo->idname, sizeof(snode->tree_idname)); + else + snode->tree_idname[0] = '\0'; +} + +int ED_node_is_compositor(struct SpaceNode *snode) +{ + return (strcmp(snode->tree_idname, ntreeType_Composite->idname)==0); +} + +int ED_node_is_shader(struct SpaceNode *snode) +{ + return (strcmp(snode->tree_idname, ntreeType_Shader->idname)==0); +} + +int ED_node_is_texture(struct SpaceNode *snode) +{ + return (strcmp(snode->tree_idname, ntreeType_Texture->idname)==0); } /* assumes nothing being done in ntree yet, sets the default in/out node */ /* called from shading buttons or header */ -void ED_node_shader_default(Scene *scene, ID *id) +void ED_node_shader_default(const bContext *C, ID *id) { + Scene *scene = CTX_data_scene(C); bNode *in, *out; bNodeSocket *fromsock, *tosock, *sock; bNodeTree *ntree; - bNodeTemplate ntemp; + PointerRNA ptr; int output_type, shader_type; - float color[3], strength = 1.0f; + float color[4] = { 0.0f, 0.0f, 0.0f, 1.0f }, strength = 1.0f; - ntree = ntreeAddTree(G.main, "Shader Nodetree", NTREE_SHADER, 0); + ntree = ntreeAddTree(NULL, "Shader Nodetree", ntreeType_Shader->idname); + + RNA_id_pointer_create((ID *)ntree, &ptr); + RNA_boolean_set(&ptr, "is_local_tree", TRUE); switch (GS(id->name)) { case ID_MA: @@ -383,12 +389,10 @@ void ED_node_shader_default(Scene *scene, ID *id) return; } - ntemp.type = output_type; - out = nodeAddNode(ntree, &ntemp); + out = nodeAddStaticNode(C, ntree, output_type); out->locx = 300.0f; out->locy = 300.0f; - ntemp.type = shader_type; - in = nodeAddNode(ntree, &ntemp); + in = nodeAddStaticNode(C, ntree, shader_type); in->locx = 10.0f; in->locy = 300.0f; nodeSetActive(ntree, in); @@ -399,12 +403,16 @@ void ED_node_shader_default(Scene *scene, ID *id) /* default values */ if (BKE_scene_use_new_shading_nodes(scene)) { + PointerRNA sockptr; sock = in->inputs.first; - copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, color); + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sockptr); + + RNA_float_set_array(&sockptr, "default_value", color); if (strength != 0.0f) { sock = in->inputs.last; - ((bNodeSocketValueFloat *)sock->default_value)->value = strength; + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sockptr); + RNA_float_set(&sockptr, "default_value", strength); } } @@ -413,11 +421,11 @@ void ED_node_shader_default(Scene *scene, ID *id) /* assumes nothing being done in ntree yet, sets the default in/out node */ /* called from shading buttons or header */ -void ED_node_composit_default(Scene *sce) +void ED_node_composit_default(const bContext *C, struct Scene *sce) { bNode *in, *out; bNodeSocket *fromsock, *tosock; - bNodeTemplate ntemp; + PointerRNA ptr; /* but lets check it anyway */ if (sce->nodetree) { @@ -426,20 +434,21 @@ void ED_node_composit_default(Scene *sce) return; } - sce->nodetree = ntreeAddTree(G.main, "Compositing Nodetree", NTREE_COMPOSIT, 0); - + sce->nodetree = ntreeAddTree(NULL, "Compositing Nodetree", ntreeType_Composite->idname); + + RNA_id_pointer_create((ID *)sce->nodetree, &ptr); + RNA_boolean_set(&ptr, "is_local_tree", TRUE); + sce->nodetree->chunksize = 256; sce->nodetree->edit_quality = NTREE_QUALITY_HIGH; sce->nodetree->render_quality = NTREE_QUALITY_HIGH; - ntemp.type = CMP_NODE_COMPOSITE; - out = nodeAddNode(sce->nodetree, &ntemp); + out = nodeAddStaticNode(C, sce->nodetree, CMP_NODE_COMPOSITE); out->locx = 300.0f; out->locy = 400.0f; out->id = &sce->id; id_us_plus(out->id); - ntemp.type = CMP_NODE_R_LAYERS; - in = nodeAddNode(sce->nodetree, &ntemp); + in = nodeAddStaticNode(C, sce->nodetree, CMP_NODE_R_LAYERS); in->locx = 10.0f; in->locy = 400.0f; in->id = &sce->id; id_us_plus(in->id); @@ -457,11 +466,11 @@ void ED_node_composit_default(Scene *sce) /* assumes nothing being done in ntree yet, sets the default in/out node */ /* called from shading buttons or header */ -void ED_node_texture_default(Tex *tx) +void ED_node_texture_default(const bContext *C, Tex *tx) { bNode *in, *out; bNodeSocket *fromsock, *tosock; - bNodeTemplate ntemp; + PointerRNA ptr; /* but lets check it anyway */ if (tx->nodetree) { @@ -470,14 +479,15 @@ void ED_node_texture_default(Tex *tx) return; } - tx->nodetree = ntreeAddTree(G.main, "Texture Nodetree", NTREE_TEXTURE, 0); + tx->nodetree = ntreeAddTree(NULL, "Texture Nodetree", ntreeType_Texture->idname); + + RNA_id_pointer_create((ID *)tx->nodetree, &ptr); + RNA_boolean_set(&ptr, "is_local_tree", TRUE); - ntemp.type = TEX_NODE_OUTPUT; - out = nodeAddNode(tx->nodetree, &ntemp); + out = nodeAddStaticNode(C, tx->nodetree, TEX_NODE_OUTPUT); out->locx = 300.0f; out->locy = 300.0f; - ntemp.type = TEX_NODE_CHECKER; - in = nodeAddNode(tx->nodetree, &ntemp); + in = nodeAddStaticNode(C, tx->nodetree, TEX_NODE_CHECKER); in->locx = 10.0f; in->locy = 300.0f; nodeSetActive(tx->nodetree, in); @@ -488,162 +498,66 @@ void ED_node_texture_default(Tex *tx) ntreeUpdateTree(tx->nodetree); } -/* id is supposed to contain a node tree */ -void node_tree_from_ID(ID *id, bNodeTree **ntree, bNodeTree **edittree, int *treetype) +/* Here we set the active tree(s), even called for each redraw now, so keep it fast :) */ +void snode_set_context(const bContext *C) { - if (id) { - bNode *node = NULL; - short idtype = GS(id->name); + SpaceNode *snode = CTX_wm_space_node(C); + bNodeTreeType *treetype = ntreeTypeFind(snode->tree_idname); + bNodeTree *ntree = snode->nodetree; + ID *id = snode->id, *from = snode->from; - if (idtype == ID_NT) { - *ntree = (bNodeTree *)id; - if (treetype) *treetype = (*ntree)->type; - } - else if (idtype == ID_MA) { - *ntree = ((Material *)id)->nodetree; - if (treetype) *treetype = NTREE_SHADER; - } - else if (idtype == ID_LA) { - *ntree = ((Lamp *)id)->nodetree; - if (treetype) *treetype = NTREE_SHADER; - } - else if (idtype == ID_WO) { - *ntree = ((World *)id)->nodetree; - if (treetype) *treetype = NTREE_SHADER; - } - else if (idtype == ID_SCE) { - *ntree = ((Scene *)id)->nodetree; - if (treetype) *treetype = NTREE_COMPOSIT; - } - else if (idtype == ID_TE) { - *ntree = ((Tex *)id)->nodetree; - if (treetype) *treetype = NTREE_TEXTURE; - } - else { - if (treetype) *treetype = 0; - return; - } + /* we use this to signal warnings, when node shaders are drawn in wrong render engine */ + if (BKE_scene_use_new_shading_nodes(CTX_data_scene(C))) + snode->flag |= SNODE_NEW_SHADERS; + else + snode->flag &= ~SNODE_NEW_SHADERS; + + /* check the tree type */ + if (!treetype + || (treetype->poll && !treetype->poll(C, treetype))) { + /* invalid tree type, disable */ + snode->tree_idname[0] = '\0'; + ED_node_tree_start(snode, NULL, NULL, NULL); + return; + } - /* find editable group */ - if (edittree) { - if (*ntree) - for (node = (*ntree)->nodes.first; node; node = node->next) - if (nodeGroupEditGet(node)) - break; - - if (node && node->id) - *edittree = (bNodeTree *)node->id; - else - *edittree = *ntree; - } + if (snode->nodetree && strcmp(snode->nodetree->idname, snode->tree_idname) != 0) { + /* current tree does not match selected type, clear tree path */ + ntree = NULL; + id = NULL; + from = NULL; } - else { - *ntree = NULL; - *edittree = NULL; - if (treetype) *treetype = 0; + + if (!(snode->flag & SNODE_PIN) || ntree == NULL) { + if (treetype->get_from_context) + treetype->get_from_context(C, treetype, &ntree, &id, &from); } + + if (snode->nodetree!=ntree || snode->id!=id || snode->from!=snode->from) + ED_node_tree_start(snode, ntree, id, from); } -/* Here we set the active tree(s), even called for each redraw now, so keep it fast :) */ -void snode_set_context(SpaceNode *snode, Scene *scene) +void snode_update(SpaceNode *snode, bNode *node) { - Object *ob = OBACT; + bNodeTreePath *path; - snode->id = snode->from = NULL; + /* XXX this only updates nodes in the current node space tree path. + * The function supposedly should update any potential group node linking to changed tree, + * this really requires a working depsgraph ... + */ - if (snode->treetype == NTREE_SHADER) { - /* we use this to signal warnings, when node shaders are drawn in wrong render engine */ - if (BKE_scene_use_new_shading_nodes(scene)) - snode->flag |= SNODE_NEW_SHADERS; - else - snode->flag &= ~SNODE_NEW_SHADERS; - - /* need active object, or we allow pinning... */ - if (snode->shaderfrom == SNODE_SHADER_OBJECT) { - if (ob) { - if (ob->type == OB_LAMP) { - snode->from = &ob->id; - snode->id = ob->data; - } - else { - Material *ma = give_current_material(ob, ob->actcol); - if (ma) { - snode->from = &ob->id; - snode->id = &ma->id; - } - } - } - } - else { /* SNODE_SHADER_WORLD */ - if (scene->world) { - snode->from = NULL; - snode->id = &scene->world->id; - } - } - } - else if (snode->treetype == NTREE_COMPOSIT) { - snode->id = &scene->id; - - /* update output sockets based on available layers */ - ntreeCompositForceHidden(scene->nodetree, scene); - } - else if (snode->treetype == NTREE_TEXTURE) { - Tex *tx = NULL; - - if (snode->texfrom == SNODE_TEX_OBJECT) { - if (ob) { - tx = give_current_object_texture(ob); - - if (ob->type == OB_LAMP) - snode->from = (ID *)ob->data; - else - snode->from = (ID *)give_current_material(ob, ob->actcol); - - /* from is not set fully for material nodes, should be ID + Node then */ - snode->id = &tx->id; - } - } - else if (snode->texfrom == SNODE_TEX_WORLD) { - tx = give_current_world_texture(scene->world); - snode->from = (ID *)scene->world; - snode->id = &tx->id; - } - else { - struct Brush *brush = NULL; - - if (ob && (ob->mode & OB_MODE_SCULPT)) - brush = paint_brush(&scene->toolsettings->sculpt->paint); - else - brush = paint_brush(&scene->toolsettings->imapaint.paint); - - if (brush) { - snode->from = (ID *)brush; - tx = give_current_brush_texture(brush); - snode->id = &tx->id; - } + /* update all edited group nodes */ + path=snode->treepath.last; + if (path) { + bNodeTree *ngroup = path->nodetree; + for (path=path->prev; path; path=path->prev) { + nodeUpdateID(path->nodetree, (ID*)ngroup); + ngroup = path->nodetree; } } - else { - if (snode->nodetree && snode->nodetree->type == snode->treetype) - snode->id = &snode->nodetree->id; - else - snode->id = NULL; - } - - node_tree_from_ID(snode->id, &snode->nodetree, &snode->edittree, NULL); -} -void snode_update(SpaceNode *snode, bNode *node) -{ - bNode *gnode; - if (node) nodeUpdate(snode->edittree, node); - - /* if inside group, tag entire group */ - gnode = node_tree_get_editgroup(snode->nodetree); - if (gnode) - nodeUpdateID(snode->nodetree, gnode->id); } void ED_node_set_active(Main *bmain, bNodeTree *ntree, bNode *node) @@ -654,6 +568,19 @@ void ED_node_set_active(Main *bmain, bNodeTree *ntree, bNode *node) if (node->type != NODE_GROUP) { int was_output = (node->flag & NODE_DO_OUTPUT); + int do_update = 0; + + /* generic node group output: set node as active output */ + if (node->type == NODE_GROUP_OUTPUT) { + bNode *tnode; + for (tnode = ntree->nodes.first; tnode; tnode = tnode->next) + if (tnode->type == NODE_GROUP_OUTPUT) + tnode->flag &= ~NODE_DO_OUTPUT; + + node->flag |= NODE_DO_OUTPUT; + if (!was_output) + do_update = 1; + } /* tree specific activate calls */ if (ntree->type == NTREE_SHADER) { @@ -670,8 +597,10 @@ void ED_node_set_active(Main *bmain, bNodeTree *ntree, bNode *node) node->flag |= NODE_DO_OUTPUT; if (was_output == 0) - ED_node_generic_update(bmain, ntree, node); + ED_node_tag_update_nodetree(bmain, ntree); } + else if (do_update) + ED_node_tag_update_nodetree(bmain, ntree); /* if active texture changed, free glsl materials */ if ((node->flag & NODE_ACTIVE_TEXTURE) && !was_active_texture) { @@ -698,7 +627,7 @@ void ED_node_set_active(Main *bmain, bNodeTree *ntree, bNode *node) node->flag |= NODE_DO_OUTPUT; if (was_output == 0) - ED_node_generic_update(bmain, ntree, node); + ED_node_tag_update_nodetree(bmain, ntree); /* addnode() doesnt link this yet... */ node->id = (ID *)BKE_image_verify_viewer(IMA_TYPE_COMPOSITE, "Viewer Node"); @@ -723,9 +652,11 @@ void ED_node_set_active(Main *bmain, bNodeTree *ntree, bNode *node) tnode->flag &= ~NODE_DO_OUTPUT; node->flag |= NODE_DO_OUTPUT; - ED_node_generic_update(bmain, ntree, node); + ED_node_tag_update_nodetree(bmain, ntree); } } + else if (do_update) + ED_node_tag_update_nodetree(bmain, ntree); } else if (ntree->type == NTREE_TEXTURE) { // XXX @@ -762,7 +693,7 @@ static void edit_node_properties(wmOperatorType *ot) /* XXX could node be a context pointer? */ RNA_def_string(ot->srna, "node", "", MAX_NAME, "Node", ""); RNA_def_int(ot->srna, "socket", 0, 0, MAX_SOCKET, "Socket", "", 0, MAX_SOCKET); - RNA_def_enum(ot->srna, "in_out", socket_in_out_items, SOCK_IN, "Socket Side", ""); + RNA_def_enum(ot->srna, "in_out", node_socket_in_out_items, SOCK_IN, "Socket Side", ""); } static int edit_node_invoke_properties(bContext *C, wmOperator *op) @@ -874,7 +805,7 @@ static int node_resize_modal(bContext *C, wmOperator *op, const wmEvent *event) { SpaceNode *snode = CTX_wm_space_node(C); ARegion *ar = CTX_wm_region(C); - bNode *node = editnode_get_active(snode->edittree); + bNode *node = nodeGetActive(snode->edittree); NodeSizeWidget *nsw = op->customdata; float mx, my, dx, dy; @@ -977,7 +908,7 @@ static int node_resize_invoke(bContext *C, wmOperator *op, const wmEvent *event) { SpaceNode *snode = CTX_wm_space_node(C); ARegion *ar = CTX_wm_region(C); - bNode *node = editnode_get_active(snode->edittree); + bNode *node = nodeGetActive(snode->edittree); int dir; if (node) { @@ -1056,33 +987,6 @@ void node_set_hidden_sockets(SpaceNode *snode, bNode *node, int set) } } -/* return 0, nothing done */ -static int UNUSED_FUNCTION(node_mouse_groupheader) (SpaceNode *snode) -{ - bNode *gnode; - float mx = 0, my = 0; -// XXX int mval[2]; - - gnode = node_tree_get_editgroup(snode->nodetree); - if (gnode == NULL) return 0; - -// XXX getmouseco_areawin(mval); -// XXX areamouseco_to_ipoco(G.v2d, mval, &mx, &my); - - /* click in header or outside? */ - if (BLI_rctf_isect_pt(&gnode->totr, mx, my) == 0) { - rctf rect = gnode->totr; - - rect.ymax += NODE_DY; - if (BLI_rctf_isect_pt(&rect, mx, my) == 0) - snode_make_group_editable(snode, NULL); /* toggles, so exits editmode */ -// else -// XXX transform_nodes(snode->nodetree, 'g', "Move group"); - - return 1; - } - return 0; -} /* checks snode->mouse position, and returns found node/socket */ /* type is SOCK_IN and/or SOCK_OUT */ @@ -1143,32 +1047,6 @@ int node_find_indicated_socket(SpaceNode *snode, bNode **nodep, bNodeSocket **so } } - /* check group sockets - * NB: using ngroup->outputs as input sockets and vice versa here! - */ - if (in_out & SOCK_IN) { - for (sock = snode->edittree->outputs.first; sock; sock = sock->next) { - if (!nodeSocketIsHidden(sock)) { - if (BLI_rctf_isect_pt(&rect, sock->locx, sock->locy)) { - *nodep = NULL; /* NULL node pointer indicates group socket */ - *sockp = sock; - return 1; - } - } - } - } - if (in_out & SOCK_OUT) { - for (sock = snode->edittree->inputs.first; sock; sock = sock->next) { - if (!nodeSocketIsHidden(sock)) { - if (BLI_rctf_isect_pt(&rect, sock->locx, sock->locy)) { - *nodep = NULL; /* NULL node pointer indicates group socket */ - *sockp = sock; - return 1; - } - } - } - } - return 0; } @@ -1215,7 +1093,7 @@ static int node_duplicate_exec(bContext *C, wmOperator *op) * but operators and readfile.c do. */ id_us_plus(newnode->id); /* to ensure redraws or rerenders happen */ - ED_node_changed_update(snode->id, newnode); + ED_node_tag_update_id(snode->id); } } @@ -1276,9 +1154,9 @@ static int node_duplicate_exec(bContext *C, wmOperator *op) /* has been set during copy above */ newnode = node->new_node; - node_deselect(node); + nodeSetSelected(node, FALSE); node->flag &= ~NODE_ACTIVE; - node_select(newnode); + nodeSetSelected(newnode, TRUE); } /* make sure we don't copy new nodes again! */ @@ -1312,6 +1190,8 @@ void NODE_OT_duplicate(wmOperatorType *ot) } int ED_node_select_check(ListBase *lb) + + { bNode *node; @@ -1456,6 +1336,7 @@ void NODE_OT_render_changed(wmOperatorType *ot) ot->flag = 0; } + /* ****************** Hide operator *********************** */ static void node_flag_toggle_exec(SpaceNode *snode, int toggle_flag) @@ -1962,8 +1843,6 @@ static int node_clipboard_copy_exec(bContext *C, wmOperator *UNUSED(op)) { SpaceNode *snode = CTX_wm_space_node(C); bNodeTree *ntree = snode->edittree; - bNode *gnode = node_tree_get_editgroup(snode->nodetree); - float gnode_x = 0.0f, gnode_y = 0.0f; bNode *node; bNodeLink *link, *newlink; @@ -1973,10 +1852,6 @@ static int node_clipboard_copy_exec(bContext *C, wmOperator *UNUSED(op)) BKE_node_clipboard_clear(); BKE_node_clipboard_init(ntree); - /* get group node offset */ - if (gnode) - node_to_view(gnode, 0.0f, 0.0f, &gnode_x, &gnode_y); - for (node = ntree->nodes.first; node; node = node->next) { if (node->flag & SELECT) { bNode *new_node; @@ -1999,12 +1874,6 @@ static int node_clipboard_copy_exec(bContext *C, wmOperator *UNUSED(op)) nodeDetachNode(new_node); } } - - /* transform to basic view space. child node location is relative to parent */ - if (!new_node->parent) { - new_node->locx += gnode_x; - new_node->locy += gnode_y; - } } } @@ -2051,8 +1920,6 @@ static int node_clipboard_paste_exec(bContext *C, wmOperator *op) { SpaceNode *snode = CTX_wm_space_node(C); bNodeTree *ntree = snode->edittree; - bNode *gnode = node_tree_get_editgroup(snode->nodetree); - float gnode_center[2]; const ListBase *clipboard_nodes_lb; const ListBase *clipboard_links_lb; bNode *node; @@ -2086,14 +1953,6 @@ static int node_clipboard_paste_exec(bContext *C, wmOperator *op) /* deselect old nodes */ node_deselect_all(snode); - /* get group node offset */ - if (gnode) { - node_to_view(gnode, 0.0f, 0.0f, &gnode_center[0], &gnode_center[1]); - } - else { - zero_v2(gnode_center); - } - /* calculate "barycenter" for placing on mouse cursor */ zero_v2(center); for (node = clipboard_nodes_lb->first, num_nodes = 0; node; node = node->next, num_nodes++) { @@ -2110,7 +1969,7 @@ static int node_clipboard_paste_exec(bContext *C, wmOperator *op) id_us_plus(node->id); /* pasted nodes are selected */ - node_select(new_node); + nodeSetSelected(new_node, TRUE); } /* reparent copied nodes */ @@ -2118,13 +1977,6 @@ static int node_clipboard_paste_exec(bContext *C, wmOperator *op) bNode *new_node = node->new_node; if (new_node->parent) new_node->parent = new_node->parent->new_node; - - - /* place nodes around the mouse cursor. child nodes locations are relative to parent */ - if (!new_node->parent) { - new_node->locx += snode->cursor[0] - center[0] - gnode_center[0]; - new_node->locy += snode->cursor[1] - center[1] - gnode_center[1]; - } } for (link = clipboard_links_lb->first; link; link = link->next) { @@ -2167,15 +2019,186 @@ void NODE_OT_clipboard_paste(wmOperatorType *ot) ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; } -/* ********************** Shader Script Update ******************/ +/********************** Add interface socket operator *********************/ -typedef struct ScriptUpdateData { - RenderEngine *engine; - RenderEngineType *type; +static bNodeSocket *ntree_get_active_interface_socket(ListBase *lb) +{ + bNodeSocket *sock; + for (sock = lb->first; sock; sock = sock->next) + if (sock->flag & SELECT) + return sock; + return NULL; +} - Text *text; - int found; -} ScriptUpdateData; +static int ntree_socket_add_exec(bContext *C, wmOperator *op) +{ + SpaceNode *snode = CTX_wm_space_node(C); + bNodeTree *ntree = snode->edittree; + int in_out = RNA_enum_get(op->ptr, "in_out"); + PointerRNA ntree_ptr; + bNodeSocket *sock, *tsock, *active_sock; + const char *default_name; + + RNA_id_pointer_create((ID *)ntree, &ntree_ptr); + + if (in_out == SOCK_IN) { + active_sock = ntree_get_active_interface_socket(&ntree->inputs); + default_name = "Input"; + } + else { + active_sock = ntree_get_active_interface_socket(&ntree->outputs); + default_name = "Output"; + } + + if (active_sock) { + /* insert a copy of the active socket right after it */ + sock = ntreeInsertSocketInterface(ntree, in_out, active_sock->idname, active_sock->next, active_sock->name); + /* XXX this only works for actual sockets, not interface templates! */ + /*nodeSocketCopyValue(sock, &ntree_ptr, active_sock, &ntree_ptr);*/ + } + else { + /* XXX TODO define default socket type for a tree! */ + sock = ntreeAddSocketInterface(ntree, in_out, "NodeSocketFloat", default_name); + } + + /* deactivate sockets (has to check both lists) */ + for (tsock = ntree->inputs.first; tsock; tsock = tsock->next) + tsock->flag &= ~SELECT; + for (tsock = ntree->outputs.first; tsock; tsock = tsock->next) + tsock->flag &= ~SELECT; + /* make the new socket active */ + sock->flag |= SELECT; + + ntreeUpdateTree(ntree); + + return OPERATOR_FINISHED; +} + +void NODE_OT_tree_socket_add(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Add Node Tree Interface Socket"; + ot->idname= "NODE_OT_tree_socket_add"; + + /* api callbacks */ + ot->exec= ntree_socket_add_exec; + ot->poll= ED_operator_node_active; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + RNA_def_enum(ot->srna, "in_out", node_socket_in_out_items, SOCK_IN, "Socket Type", ""); +} + +/********************** Remove interface socket operator *********************/ + +static int ntree_socket_remove_exec(bContext *C, wmOperator *UNUSED(op)) +{ + SpaceNode *snode = CTX_wm_space_node(C); + bNodeTree *ntree = snode->edittree; + bNodeSocket *iosock, *active_sock; + + iosock = ntree_get_active_interface_socket(&ntree->inputs); + if (!iosock) + iosock = ntree_get_active_interface_socket(&ntree->outputs); + if (!iosock) + return OPERATOR_CANCELLED; + + /* preferably next socket becomes active, otherwise try previous socket */ + active_sock = (iosock->next ? iosock->next : iosock->prev); + ntreeRemoveSocketInterface(ntree, iosock); + + /* set active socket */ + if (active_sock) + active_sock->flag |= SELECT; + + ntreeUpdateTree(ntree); + + return OPERATOR_FINISHED; +} + +void NODE_OT_tree_socket_remove(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Remove Node Tree Interface Socket"; + ot->idname= "NODE_OT_tree_socket_remove"; + + /* api callbacks */ + ot->exec= ntree_socket_remove_exec; + ot->poll= ED_operator_node_active; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; +} + +/********************** Move interface socket operator *********************/ + +static EnumPropertyItem move_direction_items[] = { + { 1, "UP", 0, "Up", "" }, + { 2, "DOWN", 0, "Down", "" }, + { 0, NULL, 0, NULL, NULL }, +}; + +static int ntree_socket_move_exec(bContext *C, wmOperator *op) +{ + SpaceNode *snode = CTX_wm_space_node(C); + bNodeTree *ntree = snode->edittree; + int direction = RNA_enum_get(op->ptr, "direction"); + bNodeSocket *iosock; + ListBase *lb; + + lb = &ntree->inputs; + iosock = ntree_get_active_interface_socket(lb); + if (!iosock) { + lb = &ntree->outputs; + iosock = ntree_get_active_interface_socket(lb); + } + if (!iosock) + return OPERATOR_CANCELLED; + + switch (direction) { + case 1: { /* up */ + bNodeSocket *before = iosock->prev; + BLI_remlink(lb, iosock); + if (before) + BLI_insertlinkbefore(lb, before, iosock); + else + BLI_addhead(lb, iosock); + break; + } + case 2: { /* down */ + bNodeSocket *after = iosock->next; + BLI_remlink(lb, iosock); + if (after) + BLI_insertlinkafter(lb, after, iosock); + else + BLI_addtail(lb, iosock); + break; + } + } + + ntreeUpdateTree(ntree); + + return OPERATOR_FINISHED; +} + +void NODE_OT_tree_socket_move(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Move Node Tree Socket"; + ot->idname= "NODE_OT_tree_socket_move"; + + /* api callbacks */ + ot->exec= ntree_socket_move_exec; + ot->poll= ED_operator_node_active; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + RNA_def_enum(ot->srna, "direction", move_direction_items, 1, "Direction", ""); +} + +/* ********************** Shader Script Update ******************/ static int node_shader_script_update_poll(bContext *C) { @@ -2208,64 +2231,79 @@ static int node_shader_script_update_poll(bContext *C) return 0; } -static void node_shader_script_update_text(void *data_, ID *UNUSED(id), bNodeTree *ntree) +/* recursively check for script nodes in groups using this text and update */ +static int node_shader_script_update_text_recursive(RenderEngine *engine, RenderEngineType *type, bNodeTree *ntree, Text *text) { - ScriptUpdateData *data = (ScriptUpdateData *)data_; + int found = FALSE; bNode *node; - + + ntree->done = TRUE; + /* update each script that is using this text datablock */ for (node = ntree->nodes.first; node; node = node->next) { if (node->type == NODE_GROUP) { - node_shader_script_update_text(data_, NULL, (bNodeTree *)node->id); + bNodeTree *ngroup = (bNodeTree *)node->id; + if (ngroup && !ngroup->done) + found |= node_shader_script_update_text_recursive(engine, type, ngroup, text); } - else if (node->type == SH_NODE_SCRIPT && node->id == &data->text->id) { - data->type->update_script_node(data->engine, ntree, node); - data->found = TRUE; + else if (node->type == SH_NODE_SCRIPT && node->id == &text->id) { + type->update_script_node(engine, ntree, node); + found = TRUE; } } + + return found; } static int node_shader_script_update_exec(bContext *C, wmOperator *op) { Main *bmain = CTX_data_main(C); Scene *scene = CTX_data_scene(C); - ScriptUpdateData data; PointerRNA nodeptr = CTX_data_pointer_get_type(C, "node", &RNA_ShaderNodeScript); + RenderEngine *engine; + RenderEngineType *type; + int found = FALSE; /* setup render engine */ - data.type = RE_engines_find(scene->r.engine); - data.engine = RE_engine_create(data.type); - data.engine->reports = op->reports; - data.text = NULL; - data.found = FALSE; + type = RE_engines_find(scene->r.engine); + engine = RE_engine_create(type); + engine->reports = op->reports; if (nodeptr.data) { /* update single node */ bNodeTree *ntree = nodeptr.id.data; bNode *node = nodeptr.data; - data.type->update_script_node(data.engine, ntree, node); + type->update_script_node(engine, ntree, node); - data.found = TRUE; + found = TRUE; } else { /* update all nodes using text datablock */ - data.text = CTX_data_pointer_get_type(C, "edit_text", &RNA_Text).data; - - if (data.text) { - bNodeTreeType *ntreetype = ntreeGetType(NTREE_SHADER); - - if (ntreetype && ntreetype->foreach_nodetree) - ntreetype->foreach_nodetree(bmain, &data, node_shader_script_update_text); + Text *text = CTX_data_pointer_get_type(C, "edit_text", &RNA_Text).data; + + if (text) { + /* clear flags for recursion check */ + FOREACH_NODETREE(bmain, ntree, id) { + if (ntree->type == NTREE_SHADER) + ntree->done = FALSE; + } FOREACH_NODETREE_END + + FOREACH_NODETREE(bmain, ntree, id) { + if (ntree->type == NTREE_SHADER) { + if (!ntree->done) + found |= node_shader_script_update_text_recursive(engine, type, ntree, text); + } + } FOREACH_NODETREE_END - if (!data.found) + if (!found) BKE_report(op->reports, RPT_INFO, "Text not used by any node, no update done"); } } - RE_engine_free(data.engine); + RE_engine_free(engine); - return (data.found)? OPERATOR_FINISHED: OPERATOR_CANCELLED; + return (found)? OPERATOR_FINISHED: OPERATOR_CANCELLED; } void NODE_OT_shader_script_update(wmOperatorType *ot) diff --git a/source/blender/editors/space_node/node_group.c b/source/blender/editors/space_node/node_group.c index 6696284b169..ba98f9ea94d 100644 --- a/source/blender/editors/space_node/node_group.c +++ b/source/blender/editors/space_node/node_group.c @@ -66,85 +66,132 @@ #include "UI_resources.h" #include "node_intern.h" /* own include */ +#include "NOD_common.h" #include "NOD_socket.h" -static EnumPropertyItem socket_in_out_items[] = { - { SOCK_IN, "SOCK_IN", 0, "Input", "" }, - { SOCK_OUT, "SOCK_OUT", 0, "Output", "" }, - { 0, NULL, 0, NULL, NULL }, -}; - -/* ***************** Edit Group operator ************* */ - -void snode_make_group_editable(SpaceNode *snode, bNode *gnode) +/* define common group node operator properties */ +static void node_group_operator_properties(wmOperatorType *ot) { - bNode *node; - - /* make sure nothing has group editing on */ - for (node = snode->nodetree->nodes.first; node; node = node->next) { - nodeGroupEditClear(node); + /* NB: not using an enum here, because that it would have to use an item callback and thus require + * copying of identifier strings anyway. node_type is not a user option, just a way of allowing + * node group operators to work on different types of group nodes. + */ + RNA_def_string(ot->srna, "node_type", "", 0, "Node Type", "Group node type the operator works on"); +} - /* while we're here, clear texture active */ - if (node->typeinfo->nclass == NODE_CLASS_TEXTURE) { - /* this is not 100% sure to be reliable, see comment on the flag */ - node->flag &= ~NODE_ACTIVE_TEXTURE; - } +/* Internal poll functions so group node operators can work with different group node types. + * This checks the operator node type property and looks up the respective types. + * If this function returns FALSE the operator should return PASS_THROUGH to allow other variants. + */ +static int node_group_operator_check_type(bContext *C, wmOperator *op, char **r_node_idname, char **r_ntree_idname) +{ + SpaceNode *snode = CTX_wm_space_node(C); + bNodeTree *ntree = snode->edittree; + PropertyRNA *ntype_prop = RNA_struct_find_property(op->ptr, "node_type"); + char *node_idname, *ntree_idname; + bNodeType *ntype; + bNodeTreeType *ntreetype; + + if (!RNA_property_is_set(op->ptr, ntype_prop)) { + BKE_report(op->reports, RPT_ERROR, "Group node type not set"); + return FALSE; } - - if (gnode == NULL) { - /* with NULL argument we do a toggle */ - if (snode->edittree == snode->nodetree) - gnode = nodeGetActive(snode->nodetree); + + node_idname = RNA_property_string_get_alloc(op->ptr, ntype_prop, NULL, 0, NULL); + ntype = nodeTypeFind(node_idname); + if (!ntype) { + BKE_reportf(op->reports, RPT_ERROR, "Group node type %s undefined", node_idname); + MEM_freeN(node_idname); + return FALSE; } - - if (gnode) { - snode->edittree = nodeGroupEditSet(gnode, 1); - - /* deselect all other nodes, so we can also do grabbing of entire subtree */ - for (node = snode->nodetree->nodes.first; node; node = node->next) { - node_deselect(node); - - if (node->typeinfo->nclass == NODE_CLASS_TEXTURE) { - /* this is not 100% sure to be reliable, see comment on the flag */ - node->flag &= ~NODE_ACTIVE_TEXTURE; - } - } - node_select(gnode); + + if (!ntype->poll(ntype, ntree)) { + MEM_freeN(node_idname); + return FALSE; } + + ntree_idname = BLI_strdup(ntype->group_tree_idname); + ntreetype = ntreeTypeFind(ntree_idname); + if (!ntreetype) { + BKE_reportf(op->reports, RPT_ERROR, "Group node tree type %s undefined", ntree_idname); + MEM_freeN(node_idname); + MEM_freeN(ntree_idname); + return FALSE; + } + + if (r_node_idname) + *r_node_idname = node_idname; + else + MEM_freeN(node_idname); + + if (r_ntree_idname) + *r_ntree_idname = ntree_idname; else - snode->edittree = snode->nodetree; + MEM_freeN(ntree_idname); + + return TRUE; } -static int node_group_edit_exec(bContext *C, wmOperator *UNUSED(op)) +static bNode *node_group_get_active(bContext *C, const char *node_idname) { SpaceNode *snode = CTX_wm_space_node(C); + bNode *node = nodeGetActive(snode->edittree); + + if (node && strcmp(node->idname, node_idname)==0) + return node; + else + return NULL; +} - ED_preview_kill_jobs(C); +/* ***************** Edit Group operator ************* */ - if (snode->nodetree == snode->edittree) { - bNode *gnode = nodeGetActive(snode->edittree); - snode_make_group_editable(snode, gnode); +static int node_group_edit_exec(bContext *C, wmOperator *op) +{ + SpaceNode *snode = CTX_wm_space_node(C); + char *node_idname; + bNode *gnode; + int exit = RNA_boolean_get(op->ptr, "exit"); + + ED_preview_kill_jobs(C); + + if (!node_group_operator_check_type(C, op, &node_idname, NULL)) + return OPERATOR_PASS_THROUGH; + + gnode = node_group_get_active(C, node_idname); + MEM_freeN(node_idname); + + if (gnode && !exit) { + bNodeTree *ngroup= (bNodeTree*)gnode->id; + + if (ngroup) { + if (ngroup->id.lib) + ntreeMakeLocal(ngroup); + + ED_node_tree_push(snode, ngroup, gnode); + } } else - snode_make_group_editable(snode, NULL); - + ED_node_tree_pop(snode); + WM_event_add_notifier(C, NC_SCENE | ND_NODES, NULL); - + return OPERATOR_FINISHED; } static int node_group_edit_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event)) { - SpaceNode *snode = CTX_wm_space_node(C); + char *node_idname; bNode *gnode; - - /* XXX callback? */ - if (snode->nodetree == snode->edittree) { - gnode = nodeGetActive(snode->edittree); - if (gnode && gnode->id && GS(gnode->id->name) == ID_NT && gnode->id->lib) { - uiPupMenuOkee(C, op->type->idname, "Make group local?"); - return OPERATOR_CANCELLED; - } + + if (!node_group_operator_check_type(C, op, &node_idname, NULL)) + return OPERATOR_PASS_THROUGH; + + gnode = node_group_get_active(C, node_idname); + MEM_freeN(node_idname); + + if (gnode && gnode->id && gnode->id->lib) { + WM_operator_confirm_message(C, op, "Make group local?"); + return OPERATOR_CANCELLED; } return node_group_edit_exec(C, op); @@ -156,258 +203,17 @@ void NODE_OT_group_edit(wmOperatorType *ot) ot->name = "Edit Group"; ot->description = "Edit node group"; ot->idname = "NODE_OT_group_edit"; - + /* api callbacks */ ot->invoke = node_group_edit_invoke; ot->exec = node_group_edit_exec; ot->poll = ED_operator_node_active; - - /* flags */ - ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; -} - -/* ***************** Add Group Socket operator ************* */ - -static int node_group_socket_add_exec(bContext *C, wmOperator *op) -{ - SpaceNode *snode = CTX_wm_space_node(C); - int in_out = -1; - char name[MAX_NAME] = ""; - int type = SOCK_FLOAT; - bNodeTree *ngroup = snode->edittree; - /* bNodeSocket *sock; */ /* UNUSED */ - - ED_preview_kill_jobs(C); - - if (RNA_struct_property_is_set(op->ptr, "name")) - RNA_string_get(op->ptr, "name", name); - - if (RNA_struct_property_is_set(op->ptr, "type")) - type = RNA_enum_get(op->ptr, "type"); - - if (RNA_struct_property_is_set(op->ptr, "in_out")) - in_out = RNA_enum_get(op->ptr, "in_out"); - else - return OPERATOR_CANCELLED; - - /* using placeholder subtype first */ - /* sock = */ /* UNUSED */ node_group_add_socket(ngroup, name, type, in_out); - - ntreeUpdateTree(ngroup); - - snode_notify(C, snode); - - return OPERATOR_FINISHED; -} - -void NODE_OT_group_socket_add(wmOperatorType *ot) -{ - /* identifiers */ - ot->name = "Add Group Socket"; - ot->description = "Add node group socket"; - ot->idname = "NODE_OT_group_socket_add"; - - /* api callbacks */ - ot->exec = node_group_socket_add_exec; - ot->poll = ED_operator_node_active; - - /* flags */ - ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; - - RNA_def_enum(ot->srna, "in_out", socket_in_out_items, SOCK_IN, "Socket Type", "Input or Output"); - RNA_def_string(ot->srna, "name", "", MAX_NAME, "Name", "Group socket name"); - RNA_def_enum(ot->srna, "type", node_socket_type_items, SOCK_FLOAT, "Type", "Type of the group socket"); -} - -/* ***************** Remove Group Socket operator ************* */ - -static int node_group_socket_remove_exec(bContext *C, wmOperator *op) -{ - SpaceNode *snode = CTX_wm_space_node(C); - int index = -1; - int in_out = -1; - bNodeTree *ngroup = snode->edittree; - bNodeSocket *sock; - - ED_preview_kill_jobs(C); - - if (RNA_struct_property_is_set(op->ptr, "index")) - index = RNA_int_get(op->ptr, "index"); - else - return OPERATOR_CANCELLED; - - if (RNA_struct_property_is_set(op->ptr, "in_out")) - in_out = RNA_enum_get(op->ptr, "in_out"); - else - return OPERATOR_CANCELLED; - - sock = (bNodeSocket *)BLI_findlink(in_out == SOCK_IN ? &ngroup->inputs : &ngroup->outputs, index); - if (sock) { - node_group_remove_socket(ngroup, sock, in_out); - ntreeUpdateTree(ngroup); - - snode_notify(C, snode); - } - - return OPERATOR_FINISHED; -} - -void NODE_OT_group_socket_remove(wmOperatorType *ot) -{ - /* identifiers */ - ot->name = "Remove Group Socket"; - ot->description = "Remove a node group socket"; - ot->idname = "NODE_OT_group_socket_remove"; - - /* api callbacks */ - ot->exec = node_group_socket_remove_exec; - ot->poll = ED_operator_node_active; - - /* flags */ - ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; - - RNA_def_int(ot->srna, "index", 0, 0, INT_MAX, "Index", "", 0, INT_MAX); - RNA_def_enum(ot->srna, "in_out", socket_in_out_items, SOCK_IN, "Socket Type", "Input or Output"); -} - -/* ***************** Move Group Socket Up operator ************* */ - -static int node_group_socket_move_up_exec(bContext *C, wmOperator *op) -{ - SpaceNode *snode = CTX_wm_space_node(C); - int index = -1; - int in_out = -1; - bNodeTree *ngroup = snode->edittree; - bNodeSocket *sock, *prev; - - ED_preview_kill_jobs(C); - - if (RNA_struct_property_is_set(op->ptr, "index")) - index = RNA_int_get(op->ptr, "index"); - else - return OPERATOR_CANCELLED; - - if (RNA_struct_property_is_set(op->ptr, "in_out")) - in_out = RNA_enum_get(op->ptr, "in_out"); - else - return OPERATOR_CANCELLED; - - /* swap */ - if (in_out == SOCK_IN) { - sock = (bNodeSocket *)BLI_findlink(&ngroup->inputs, index); - prev = sock->prev; - /* can't move up the first socket */ - if (!prev) - return OPERATOR_CANCELLED; - BLI_remlink(&ngroup->inputs, sock); - BLI_insertlinkbefore(&ngroup->inputs, prev, sock); - - ngroup->update |= NTREE_UPDATE_GROUP_IN; - } - else if (in_out == SOCK_OUT) { - sock = (bNodeSocket *)BLI_findlink(&ngroup->outputs, index); - prev = sock->prev; - /* can't move up the first socket */ - if (!prev) - return OPERATOR_CANCELLED; - BLI_remlink(&ngroup->outputs, sock); - BLI_insertlinkbefore(&ngroup->outputs, prev, sock); - - ngroup->update |= NTREE_UPDATE_GROUP_OUT; - } - ntreeUpdateTree(ngroup); - - snode_notify(C, snode); - - return OPERATOR_FINISHED; -} - -void NODE_OT_group_socket_move_up(wmOperatorType *ot) -{ - /* identifiers */ - ot->name = "Move Group Socket Up"; - ot->description = "Move up node group socket"; - ot->idname = "NODE_OT_group_socket_move_up"; - - /* api callbacks */ - ot->exec = node_group_socket_move_up_exec; - ot->poll = ED_operator_node_active; - - /* flags */ - ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; - - RNA_def_int(ot->srna, "index", 0, 0, INT_MAX, "Index", "", 0, INT_MAX); - RNA_def_enum(ot->srna, "in_out", socket_in_out_items, SOCK_IN, "Socket Type", "Input or Output"); -} - -/* ***************** Move Group Socket Up operator ************* */ - -static int node_group_socket_move_down_exec(bContext *C, wmOperator *op) -{ - SpaceNode *snode = CTX_wm_space_node(C); - int index = -1; - int in_out = -1; - bNodeTree *ngroup = snode->edittree; - bNodeSocket *sock, *next; - - ED_preview_kill_jobs(C); - - if (RNA_struct_property_is_set(op->ptr, "index")) - index = RNA_int_get(op->ptr, "index"); - else - return OPERATOR_CANCELLED; - - if (RNA_struct_property_is_set(op->ptr, "in_out")) - in_out = RNA_enum_get(op->ptr, "in_out"); - else - return OPERATOR_CANCELLED; - - /* swap */ - if (in_out == SOCK_IN) { - sock = (bNodeSocket *)BLI_findlink(&ngroup->inputs, index); - next = sock->next; - /* can't move down the last socket */ - if (!next) - return OPERATOR_CANCELLED; - BLI_remlink(&ngroup->inputs, sock); - BLI_insertlinkafter(&ngroup->inputs, next, sock); - - ngroup->update |= NTREE_UPDATE_GROUP_IN; - } - else if (in_out == SOCK_OUT) { - sock = (bNodeSocket *)BLI_findlink(&ngroup->outputs, index); - next = sock->next; - /* can't move down the last socket */ - if (!next) - return OPERATOR_CANCELLED; - BLI_remlink(&ngroup->outputs, sock); - BLI_insertlinkafter(&ngroup->outputs, next, sock); - - ngroup->update |= NTREE_UPDATE_GROUP_OUT; - } - ntreeUpdateTree(ngroup); - - snode_notify(C, snode); - - return OPERATOR_FINISHED; -} - -void NODE_OT_group_socket_move_down(wmOperatorType *ot) -{ - /* identifiers */ - ot->name = "Move Group Socket Down"; - ot->description = "Move down node group socket"; - ot->idname = "NODE_OT_group_socket_move_down"; - - /* api callbacks */ - ot->exec = node_group_socket_move_down_exec; - ot->poll = ED_operator_node_active; - + /* flags */ ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; - - RNA_def_int(ot->srna, "index", 0, 0, INT_MAX, "Index", "", 0, INT_MAX); - RNA_def_enum(ot->srna, "in_out", socket_in_out_items, SOCK_IN, "Socket Type", "Input or Output"); + + node_group_operator_properties(ot); + RNA_def_boolean(ot->srna, "exit", FALSE, "Exit", ""); } /* ******************** Ungroup operator ********************** */ @@ -415,180 +221,185 @@ void NODE_OT_group_socket_move_down(wmOperatorType *ot) /* returns 1 if its OK */ static int node_group_ungroup(bNodeTree *ntree, bNode *gnode) { - bNodeLink *link, *linkn; - bNode *node, *nextn; + bNodeLink *link, *linkn, *tlink; + bNode *node, *nextnode; bNodeTree *ngroup, *wgroup; ListBase anim_basepaths = {NULL, NULL}; - + ngroup = (bNodeTree *)gnode->id; - if (ngroup == NULL) return 0; - + /* clear new pointers, set in copytree */ for (node = ntree->nodes.first; node; node = node->next) node->new_node = NULL; - + /* wgroup is a temporary copy of the NodeTree we're merging in * - all of wgroup's nodes are transferred across to their new home * - ngroup (i.e. the source NodeTree) is left unscathed * - temp copy. don't change ID usercount */ wgroup = ntreeCopyTree_ex(ngroup, FALSE); - - /* add the nodes into the ntree */ - for (node = wgroup->nodes.first; node; node = nextn) { - nextn = node->next; - - /* keep track of this node's RNA "base" path (the part of the path identifying the node) + + /* Add the nodes into the ntree */ + for(node= wgroup->nodes.first; node; node= nextnode) { + nextnode= node->next; + + /* Remove interface nodes. + * This also removes remaining links to and from interface nodes. + */ + if (ELEM(node->type, NODE_GROUP_INPUT, NODE_GROUP_OUTPUT)) { + nodeFreeNode(wgroup, node); + continue; + } + + /* keep track of this node's RNA "base" path (the part of the path identifying the node) * if the old nodetree has animation data which potentially covers this node */ if (wgroup->adt) { PointerRNA ptr; char *path; - + RNA_pointer_create(&wgroup->id, &RNA_Node, node, &ptr); path = RNA_path_from_ID_to_struct(&ptr); - + if (path) BLI_addtail(&anim_basepaths, BLI_genericNodeN(path)); } - + /* migrate node */ BLI_remlink(&wgroup->nodes, node); BLI_addtail(&ntree->nodes, node); - - /* ensure unique node name in the nodee tree */ + + /* ensure unique node name in the node tree */ nodeUniqueName(ntree, node); - + if (!node->parent) { node->locx += gnode->locx; node->locy += gnode->locy; } - + node->flag |= NODE_SELECT; } - - /* restore external links to and from the gnode */ - for (link = ntree->links.first; link; link = link->next) { - if (link->fromnode == gnode) { - if (link->fromsock->groupsock) { - bNodeSocket *gsock = link->fromsock->groupsock; - if (gsock->link) { - if (gsock->link->fromnode) { - /* NB: using the new internal copies here! the groupsock pointer still maps to the old tree */ - link->fromnode = (gsock->link->fromnode ? gsock->link->fromnode->new_node : NULL); - link->fromsock = gsock->link->fromsock->new_sock; - } - else { - /* group output directly maps to group input */ - bNodeSocket *insock = node_group_find_input(gnode, gsock->link->fromsock); - if (insock->link) { - link->fromnode = insock->link->fromnode; - link->fromsock = insock->link->fromsock; - } - } - } - else { - /* copy the default input value from the group socket default to the external socket */ - node_socket_convert_default_value(link->tosock->type, link->tosock->default_value, gsock->type, gsock->default_value); - } - } - } - } - /* remove internal output links, these are not used anymore */ - for (link = wgroup->links.first; link; link = linkn) { - linkn = link->next; - if (!link->tonode) - nodeRemLink(wgroup, link); - } - /* restore links from internal nodes */ - for (link = wgroup->links.first; link; link = linkn) { - linkn = link->next; - /* indicates link to group input */ - if (!link->fromnode) { - /* NB: can't use find_group_node_input here, - * because gnode sockets still point to the old tree! - */ - bNodeSocket *insock; - for (insock = gnode->inputs.first; insock; insock = insock->next) - if (insock->groupsock->new_sock == link->fromsock) - break; - if (insock->link) { - link->fromnode = insock->link->fromnode; - link->fromsock = insock->link->fromsock; - } - else { - /* copy the default input value from the group node socket default to the internal socket */ - node_socket_convert_default_value(link->tosock->type, link->tosock->default_value, insock->type, insock->default_value); - nodeRemLink(wgroup, link); - } - } - } - - /* add internal links to the ntree */ + + /* Add internal links to the ntree */ for (link = wgroup->links.first; link; link = linkn) { linkn = link->next; BLI_remlink(&wgroup->links, link); BLI_addtail(&ntree->links, link); } - + /* and copy across the animation, * note that the animation data's action can be NULL here */ if (wgroup->adt) { LinkData *ld, *ldn = NULL; bAction *waction; - + /* firstly, wgroup needs to temporary dummy action that can be destroyed, as it shares copies */ waction = wgroup->adt->action = BKE_action_copy(wgroup->adt->action); - + /* now perform the moving */ BKE_animdata_separate_by_basepath(&wgroup->id, &ntree->id, &anim_basepaths); - + /* paths + their wrappers need to be freed */ for (ld = anim_basepaths.first; ld; ld = ldn) { ldn = ld->next; - + MEM_freeN(ld->data); BLI_freelinkN(&anim_basepaths, ld); } - + /* free temp action too */ if (waction) { BKE_libblock_free(&G.main->action, waction); } } - - /* delete the group instance. this also removes old input links! */ - nodeFreeNode(ntree, gnode); - + /* free the group tree (takes care of user count) */ BKE_libblock_free(&G.main->nodetree, wgroup); - + + /* restore external links to and from the gnode */ + /* note: the nodes have been copied to intermediate wgroup first (so need to use new_node), + * then transferred to ntree (new_node pointers remain valid). + */ + + /* input links */ + for (link = ngroup->links.first; link; link = link->next) { + if (link->fromnode->type == NODE_GROUP_INPUT) { + const char *identifier = link->fromsock->identifier; + int num_external_links = 0; + + /* find external links to this input */ + for (tlink = ntree->links.first; tlink; tlink = tlink->next) { + if (tlink->tonode == gnode && strcmp(tlink->tosock->identifier, identifier)==0) { + nodeAddLink(ntree, tlink->fromnode, tlink->fromsock, link->tonode->new_node, link->tosock->new_sock); + ++num_external_links; + } + } + + /* if group output is not externally linked, + * convert the constant input value to ensure somewhat consistent behavior */ + if (num_external_links == 0) { + bNodeSocket *sock = node_group_find_input_socket(gnode, identifier); + BLI_assert(sock); + + /* XXX TODO nodeSocketCopy(ntree, link->tosock->new_sock, link->tonode->new_node, ntree, sock, gnode);*/ + } + } + } + + /* output links */ + for (link = ntree->links.first; link; link = link->next) { + if (link->fromnode == gnode) { + const char *identifier = link->fromsock->identifier; + int num_internal_links = 0; + + /* find internal links to this output */ + for (tlink = ngroup->links.first; tlink; tlink = tlink->next) { + /* only use active output node */ + if (tlink->tonode->type == NODE_GROUP_OUTPUT && (tlink->tonode->flag & NODE_DO_OUTPUT)) { + if (strcmp(tlink->tosock->identifier, identifier)==0) { + nodeAddLink(ntree, tlink->fromnode->new_node, tlink->fromsock->new_sock, link->tonode, link->tosock); + ++num_internal_links; + } + } + } + + /* if group output is not internally linked, + * convert the constant output value to ensure somewhat consistent behavior */ + if (num_internal_links == 0) { + bNodeSocket *sock = node_group_find_output_socket(gnode, identifier); + BLI_assert(sock); + + /* XXX TODO nodeSocketCopy(ntree, link->tosock, link->tonode, ntree, sock, gnode); */ + } + } + } + + /* delete the group instance */ + nodeFreeNode(ntree, gnode); + ntree->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS; - + return 1; } + static int node_group_ungroup_exec(bContext *C, wmOperator *op) { SpaceNode *snode = CTX_wm_space_node(C); + char *node_idname; bNode *gnode; ED_preview_kill_jobs(C); - /* are we inside of a group? */ - gnode = node_tree_get_editgroup(snode->nodetree); - if (gnode) - snode_make_group_editable(snode, NULL); - - gnode = nodeGetActive(snode->edittree); - if (gnode == NULL) + if (!node_group_operator_check_type(C, op, &node_idname, NULL)) + return OPERATOR_PASS_THROUGH; + + gnode = node_group_get_active(C, node_idname); + MEM_freeN(node_idname); + if (!gnode) return OPERATOR_CANCELLED; - - if (gnode->type != NODE_GROUP) { - BKE_report(op->reports, RPT_WARNING, "Not a group"); - return OPERATOR_CANCELLED; - } - else if (node_group_ungroup(snode->nodetree, gnode)) { + + if (gnode->id && node_group_ungroup(snode->edittree, gnode)) { ntreeUpdateTree(snode->nodetree); } else { @@ -608,93 +419,92 @@ void NODE_OT_group_ungroup(wmOperatorType *ot) ot->name = "Ungroup"; ot->description = "Ungroup selected nodes"; ot->idname = "NODE_OT_group_ungroup"; - + /* api callbacks */ ot->exec = node_group_ungroup_exec; ot->poll = ED_operator_node_active; - + /* flags */ ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; + + node_group_operator_properties(ot); } /* ******************** Separate operator ********************** */ /* returns 1 if its OK */ -static int node_group_separate_selected(bNodeTree *ntree, bNode *gnode, int make_copy) +static int node_group_separate_selected(bNodeTree *ntree, bNodeTree *ngroup, float offx, float offy, int make_copy) { bNodeLink *link, *link_next; bNode *node, *node_next, *newnode; - bNodeTree *ngroup; ListBase anim_basepaths = {NULL, NULL}; - - ngroup = (bNodeTree *)gnode->id; - if (ngroup == NULL) return 0; - + /* deselect all nodes in the target tree */ for (node = ntree->nodes.first; node; node = node->next) - node_deselect(node); - + nodeSetSelected(node, FALSE); + /* clear new pointers, set in nodeCopyNode */ for (node = ngroup->nodes.first; node; node = node->next) node->new_node = NULL; - + /* add selected nodes into the ntree */ for (node = ngroup->nodes.first; node; node = node_next) { node_next = node->next; - if (node->flag & NODE_SELECT) { - - if (make_copy) { - /* make a copy */ - newnode = nodeCopyNode(ngroup, node); - } - else { - /* use the existing node */ - newnode = node; - } - - /* keep track of this node's RNA "base" path (the part of the path identifying the node) - * if the old nodetree has animation data which potentially covers this node - */ - if (ngroup->adt) { - PointerRNA ptr; - char *path; - - RNA_pointer_create(&ngroup->id, &RNA_Node, newnode, &ptr); - path = RNA_path_from_ID_to_struct(&ptr); - - if (path) - BLI_addtail(&anim_basepaths, BLI_genericNodeN(path)); - } - - /* ensure valid parent pointers, detach if parent stays inside the group */ - if (newnode->parent && !(newnode->parent->flag & NODE_SELECT)) - nodeDetachNode(newnode); - - /* migrate node */ - BLI_remlink(&ngroup->nodes, newnode); - BLI_addtail(&ntree->nodes, newnode); + if (!(node->flag & NODE_SELECT)) + continue; + + /* ignore interface nodes */ + if (ELEM(node->type, NODE_GROUP_INPUT, NODE_GROUP_OUTPUT)) { + nodeSetSelected(node, FALSE); + continue; + } + + if (make_copy) { + /* make a copy */ + newnode = nodeCopyNode(ngroup, node); + } + else { + /* use the existing node */ + newnode = node; + } + + /* keep track of this node's RNA "base" path (the part of the path identifying the node) + * if the old nodetree has animation data which potentially covers this node + */ + if (ngroup->adt) { + PointerRNA ptr; + char *path; - /* ensure unique node name in the node tree */ - nodeUniqueName(ntree, newnode); + RNA_pointer_create(&ngroup->id, &RNA_Node, newnode, &ptr); + path = RNA_path_from_ID_to_struct(&ptr); - if (!newnode->parent) { - newnode->locx += gnode->locx; - newnode->locy += gnode->locy; - } + if (path) + BLI_addtail(&anim_basepaths, BLI_genericNodeN(path)); } - else { - /* ensure valid parent pointers, detach if child stays inside the group */ - if (node->parent && (node->parent->flag & NODE_SELECT)) - nodeDetachNode(node); + + /* ensure valid parent pointers, detach if parent stays inside the group */ + if (newnode->parent && !(newnode->parent->flag & NODE_SELECT)) + nodeDetachNode(newnode); + + /* migrate node */ + BLI_remlink(&ngroup->nodes, newnode); + BLI_addtail(&ntree->nodes, newnode); + + /* ensure unique node name in the node tree */ + nodeUniqueName(ntree, newnode); + + if (!newnode->parent) { + newnode->locx += offx; + newnode->locy += offy; } } - + /* add internal links to the ntree */ for (link = ngroup->links.first; link; link = link_next) { int fromselect = (link->fromnode && (link->fromnode->flag & NODE_SELECT)); int toselect = (link->tonode && (link->tonode->flag & NODE_SELECT)); link_next = link->next; - + if (make_copy) { /* make a copy of internal links */ if (fromselect && toselect) @@ -711,28 +521,28 @@ static int node_group_separate_selected(bNodeTree *ntree, bNode *gnode, int make } } } - + /* and copy across the animation, * note that the animation data's action can be NULL here */ if (ngroup->adt) { LinkData *ld, *ldn = NULL; - + /* now perform the moving */ BKE_animdata_separate_by_basepath(&ngroup->id, &ntree->id, &anim_basepaths); - + /* paths + their wrappers need to be freed */ for (ld = anim_basepaths.first; ld; ld = ldn) { ldn = ld->next; - + MEM_freeN(ld->data); BLI_freelinkN(&anim_basepaths, ld); } } - + ntree->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS; if (!make_copy) ngroup->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS; - + return 1; } @@ -751,56 +561,64 @@ EnumPropertyItem node_group_separate_types[] = { static int node_group_separate_exec(bContext *C, wmOperator *op) { SpaceNode *snode = CTX_wm_space_node(C); - bNode *gnode; + bNodeTree *ngroup, *nparent; int type = RNA_enum_get(op->ptr, "type"); + float offx, offy; ED_preview_kill_jobs(C); /* are we inside of a group? */ - gnode = node_tree_get_editgroup(snode->nodetree); - if (!gnode) { + ngroup = snode->edittree; + nparent = ED_node_tree_get(snode, 1); + if (!nparent) { BKE_report(op->reports, RPT_WARNING, "Not inside node group"); return OPERATOR_CANCELLED; } - + /* get node tree offset */ + snode_group_offset(snode, &offx, &offy); + switch (type) { case NODE_GS_COPY: - if (!node_group_separate_selected(snode->nodetree, gnode, 1)) { + if (!node_group_separate_selected(nparent, ngroup, offx, offy, 1)) { BKE_report(op->reports, RPT_WARNING, "Cannot separate nodes"); return OPERATOR_CANCELLED; } break; case NODE_GS_MOVE: - if (!node_group_separate_selected(snode->nodetree, gnode, 0)) { + if (!node_group_separate_selected(nparent, ngroup, offx, offy, 0)) { BKE_report(op->reports, RPT_WARNING, "Cannot separate nodes"); return OPERATOR_CANCELLED; } break; } - + /* switch to parent tree */ - snode_make_group_editable(snode, NULL); - + ED_node_tree_pop(snode); + ntreeUpdateTree(snode->nodetree); - + snode_notify(C, snode); snode_dag_update(C, snode); return OPERATOR_FINISHED; } -static int node_group_separate_invoke(bContext *C, wmOperator *UNUSED(op), const wmEvent *UNUSED(event)) +static int node_group_separate_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event)) { - uiPopupMenu *pup = uiPupMenuBegin(C, CTX_IFACE_(BLF_I18NCONTEXT_OPERATOR_DEFAULT, "Separate"), ICON_NONE); - uiLayout *layout = uiPupMenuLayout(pup); - - uiLayoutSetOperatorContext(layout, WM_OP_EXEC_DEFAULT); - uiItemEnumO(layout, "NODE_OT_group_separate", NULL, 0, "type", NODE_GS_COPY); - uiItemEnumO(layout, "NODE_OT_group_separate", NULL, 0, "type", NODE_GS_MOVE); - - uiPupMenuEnd(C, pup); - - return OPERATOR_CANCELLED; + if (!node_group_operator_check_type(C, op, NULL, NULL)) + return OPERATOR_PASS_THROUGH; + else { + uiPopupMenu *pup = uiPupMenuBegin(C, CTX_IFACE_(BLF_I18NCONTEXT_OPERATOR_DEFAULT, "Separate"), ICON_NONE); + uiLayout *layout = uiPupMenuLayout(pup); + + uiLayoutSetOperatorContext(layout, WM_OP_EXEC_DEFAULT); + uiItemEnumO(layout, "NODE_OT_group_separate", NULL, 0, "type", NODE_GS_COPY); + uiItemEnumO(layout, "NODE_OT_group_separate", NULL, 0, "type", NODE_GS_MOVE); + + uiPupMenuEnd(C, pup); + + return OPERATOR_CANCELLED; + } } void NODE_OT_group_separate(wmOperatorType *ot) @@ -809,162 +627,181 @@ void NODE_OT_group_separate(wmOperatorType *ot) ot->name = "Separate"; ot->description = "Separate selected nodes from the node group"; ot->idname = "NODE_OT_group_separate"; - + /* api callbacks */ ot->invoke = node_group_separate_invoke; ot->exec = node_group_separate_exec; ot->poll = ED_operator_node_active; - + /* flags */ ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; - + + node_group_operator_properties(ot); RNA_def_enum(ot->srna, "type", node_group_separate_types, NODE_GS_COPY, "Type", ""); } /* ****************** Make Group operator ******************* */ -static int node_group_make_test(bNodeTree *ntree, bNode *gnode) +static int node_group_make_use_node(bNode *node, bNode *gnode) { + return (node != gnode + && !ELEM(node->type, NODE_GROUP_INPUT, NODE_GROUP_OUTPUT) + && (node->flag & NODE_SELECT)); +} + +static int node_group_make_test_selected(bNodeTree *ntree, bNode *gnode, const char *ntree_idname, struct ReportList *reports) +{ + bNodeTree *ngroup; bNode *node; bNodeLink *link; - int totnode = 0; - - /* is there something to group? also do some clearing */ + int ok = TRUE; + + /* make a local pseudo node tree to pass to the node poll functions */ + ngroup = ntreeAddTree(NULL, "Pseudo Node Group", ntree_idname); + + /* check poll functions for selected nodes */ for (node = ntree->nodes.first; node; node = node->next) { - if (node == gnode) - continue; - - if (node->flag & NODE_SELECT) { - /* no groups in groups */ - if (node->type == NODE_GROUP) - return 0; - totnode++; + if (node_group_make_use_node(node, gnode)) { + if (!node->typeinfo->poll_instance(node, ngroup)) { + BKE_reportf(reports, RPT_WARNING, "Can not add node '%s' in a group", node->name); + ok = FALSE; + break; + } } node->done = 0; } - if (totnode == 0) return 0; - + + /* free local pseudo node tree again */ + ntreeFreeTree(ngroup); + MEM_freeN(ngroup); + if (!ok) + return FALSE; + /* check if all connections are OK, no unselected node has both * inputs and outputs to a selection */ for (link = ntree->links.first; link; link = link->next) { - if (link->fromnode && link->tonode && link->fromnode->flag & NODE_SELECT && link->fromnode != gnode) + if (node_group_make_use_node(link->fromnode, gnode)) link->tonode->done |= 1; - if (link->fromnode && link->tonode && link->tonode->flag & NODE_SELECT && link->tonode != gnode) + if (node_group_make_use_node(link->tonode, gnode)) link->fromnode->done |= 2; } - for (node = ntree->nodes.first; node; node = node->next) { - if (node == gnode) - continue; - if ((node->flag & NODE_SELECT) == 0) - if (node->done == 3) - break; + if (!(node->flag & NODE_SELECT) + && node != gnode + && node->done == 3) + return FALSE; } - if (node) - return 0; - - return 1; + return TRUE; } - -static void node_get_selected_minmax(bNodeTree *ntree, bNode *gnode, float *min, float *max) +static int node_get_selected_minmax(bNodeTree *ntree, bNode *gnode, float *min, float *max) { bNode *node; float loc[2]; + int totselect = 0; + INIT_MINMAX2(min, max); for (node = ntree->nodes.first; node; node = node->next) { - if (node == gnode) - continue; - if (node->flag & NODE_SELECT) { + if (node_group_make_use_node(node, gnode)) { nodeToView(node, 0.0f, 0.0f, &loc[0], &loc[1]); minmax_v2v2_v2(min, max, loc); + ++totselect; } } + + /* sane min/max if no selected nodes */ + if (totselect == 0) { + min[0] = min[1] = max[0] = max[1] = 0.0f; + } + + return totselect; } -static int node_group_make_insert_selected(bNodeTree *ntree, bNode *gnode) +static void node_group_make_insert_selected(const bContext *C, bNodeTree *ntree, bNode *gnode) { bNodeTree *ngroup = (bNodeTree *)gnode->id; bNodeLink *link, *linkn; bNode *node, *nextn; - bNodeSocket *gsock, *sock; + bNodeSocket *sock; ListBase anim_basepaths = {NULL, NULL}; - float min[2], max[2]; - + float min[2], max[2], center[2]; + int totselect; + int expose_all = FALSE; + bNode *input_node = NULL, *output_node = NULL; /* lazy initialized, in case there are no external links */ + + /* XXX rough guess, not nice but we don't have access to UI constants here ... */ + static const float offsetx = 200; + static const float offsety = 0.0f; + /* deselect all nodes in the target tree */ for (node = ngroup->nodes.first; node; node = node->next) - node_deselect(node); - - node_get_selected_minmax(ntree, gnode, min, max); - + nodeSetSelected(node, FALSE); + + totselect = node_get_selected_minmax(ntree, gnode, min, max); + add_v2_v2v2(center, min, max); + mul_v2_fl(center, 0.5f); + + /* auto-add interface for "solo" nodes */ + if (totselect == 1) + expose_all = TRUE; + /* move nodes over */ for (node = ntree->nodes.first; node; node = nextn) { nextn = node->next; - if (node == gnode) - continue; - if (node->flag & NODE_SELECT) { - /* keep track of this node's RNA "base" path (the part of the pat identifying the node) + if (node_group_make_use_node(node, gnode)) { + /* keep track of this node's RNA "base" path (the part of the pat identifying the node) * if the old nodetree has animation data which potentially covers this node */ if (ntree->adt) { PointerRNA ptr; char *path; - + RNA_pointer_create(&ntree->id, &RNA_Node, node, &ptr); path = RNA_path_from_ID_to_struct(&ptr); - + if (path) BLI_addtail(&anim_basepaths, BLI_genericNodeN(path)); } - + /* ensure valid parent pointers, detach if parent stays outside the group */ if (node->parent && !(node->parent->flag & NODE_SELECT)) nodeDetachNode(node); - + /* change node-collection membership */ BLI_remlink(&ntree->nodes, node); BLI_addtail(&ngroup->nodes, node); - + /* ensure unique node name in the ngroup */ nodeUniqueName(ngroup, node); - - if (!node->parent) { - node->locx -= 0.5f * (min[0] + max[0]); - node->locy -= 0.5f * (min[1] + max[1]); - } - } - else { - /* if the parent is to be inserted but not the child, detach properly */ - if (node->parent && (node->parent->flag & NODE_SELECT)) - nodeDetachNode(node); } } - + /* move animation data over */ if (ntree->adt) { LinkData *ld, *ldn = NULL; - + BKE_animdata_separate_by_basepath(&ntree->id, &ngroup->id, &anim_basepaths); - + /* paths + their wrappers need to be freed */ for (ld = anim_basepaths.first; ld; ld = ldn) { ldn = ld->next; - + MEM_freeN(ld->data); BLI_freelinkN(&anim_basepaths, ld); } } - + /* node groups don't use internal cached data */ ntreeFreeCache(ngroup); - + /* relink external sockets */ for (link = ntree->links.first; link; link = linkn) { - int fromselect = (link->fromnode && (link->fromnode->flag & NODE_SELECT) && link->fromnode != gnode); - int toselect = (link->tonode && (link->tonode->flag & NODE_SELECT) && link->tonode != gnode); + int fromselect = node_group_make_use_node(link->fromnode, gnode); + int toselect = node_group_make_use_node(link->tonode, gnode); + linkn = link->next; - + if ((fromselect && link->tonode == gnode) || (toselect && link->fromnode == gnode)) { /* remove all links to/from the gnode. * this can remove link information, but there's no general way to preserve it. @@ -976,58 +813,123 @@ static int node_group_make_insert_selected(bNodeTree *ntree, bNode *gnode) BLI_addtail(&ngroup->links, link); } else if (toselect) { - gsock = node_group_expose_socket(ngroup, link->tosock, SOCK_IN); - link->tosock->link = nodeAddLink(ngroup, NULL, gsock, link->tonode, link->tosock); - link->tosock = node_group_add_extern_socket(ntree, &gnode->inputs, SOCK_IN, gsock); + bNodeSocket *iosock = ntreeAddSocketInterfaceFromSocket(ngroup, link->tonode, link->tosock); + bNodeSocket *input_sock; + + /* lazy init */ + if (!input_node) { + input_node = nodeAddStaticNode(C, ngroup, NODE_GROUP_INPUT); + + input_node->locx = min[0] - center[0] - offsetx; + input_node->locy = -offsety; + } + /* update the group node and interface node sockets, + * so the new interface socket can be linked. + */ + node_group_verify(ntree, gnode, (ID *)ngroup); + node_group_input_verify(ngroup, input_node, (ID *)ngroup); + + /* create new internal link */ + input_sock = node_group_input_find_socket(input_node, iosock->identifier); + nodeAddLink(ngroup, input_node, input_sock, link->tonode, link->tosock); + + /* redirect external link */ link->tonode = gnode; + link->tosock = node_group_find_input_socket(gnode, iosock->identifier); } else if (fromselect) { - /* search for existing group node socket */ - for (gsock = ngroup->outputs.first; gsock; gsock = gsock->next) - if (gsock->link && gsock->link->fromsock == link->fromsock) - break; - if (!gsock) { - gsock = node_group_expose_socket(ngroup, link->fromsock, SOCK_OUT); - gsock->link = nodeAddLink(ngroup, link->fromnode, link->fromsock, NULL, gsock); - link->fromsock = node_group_add_extern_socket(ntree, &gnode->outputs, SOCK_OUT, gsock); + bNodeSocket *iosock = ntreeAddSocketInterfaceFromSocket(ngroup, link->fromnode, link->fromsock); + bNodeSocket *output_sock; + + /* lazy init */ + if (!output_node) { + output_node = nodeAddStaticNode(C, ngroup, NODE_GROUP_OUTPUT); + + output_node->locx = max[0] - center[0] + offsetx; + output_node->locy = -offsety; } - else - link->fromsock = node_group_find_output(gnode, gsock); + /* update the group node and interface node sockets, + * so the new interface socket can be linked. + */ + node_group_verify(ntree, gnode, (ID *)ngroup); + node_group_output_verify(ngroup, output_node, (ID *)ngroup); + + /* create new internal link */ + output_sock = node_group_output_find_socket(output_node, iosock->identifier); + nodeAddLink(ngroup, link->fromnode, link->fromsock, output_node, output_sock); + + /* redirect external link */ link->fromnode = gnode; + link->fromsock = node_group_find_output_socket(gnode, iosock->identifier); } } - /* auto-add interface for "solo" nodes */ - node = ((bNodeTree *)gnode->id)->nodes.first; - if (node && !node->next) { - for (sock = node->inputs.first; sock; sock = sock->next) { - int skip = FALSE; - - for (link = ((bNodeTree *)gnode->id)->links.first; link; link = link->next) - if (link->tosock == sock) - skip = TRUE; - - if (skip == TRUE) - continue; - - gsock = node_group_expose_socket(ngroup, sock, SOCK_IN); - node_group_add_extern_socket(ntree, &gnode->inputs, SOCK_IN, gsock); - nodeAddLink(ngroup, NULL, gsock, node, sock); + /* move nodes in the group to the center */ + for (node = ngroup->nodes.first; node; node = node->next) { + if (node_group_make_use_node(node, gnode) && !node->parent) { + node->locx -= center[0]; + node->locy -= center[1]; } - - for (sock = node->outputs.first; sock; sock = sock->next) { - int skip = FALSE; - - for (link = ((bNodeTree *)gnode->id)->links.first; link; link = link->next) - if (link->fromsock == sock) - skip = TRUE; - - if (skip == TRUE) - continue; - - gsock = node_group_expose_socket(ngroup, sock, SOCK_OUT); - node_group_add_extern_socket(ntree, &gnode->outputs, SOCK_OUT, gsock); - nodeAddLink(ngroup, NULL, gsock, node, sock); + } + + /* expose all unlinked sockets too */ + if (expose_all) { + for (node = ngroup->nodes.first; node; node = node->next) { + if (node_group_make_use_node(node, gnode)) { + for (sock = node->inputs.first; sock; sock = sock->next) { + bNodeSocket *iosock, *input_sock; + int skip = FALSE; + for (link = ngroup->links.first; link; link = link->next) { + if (link->tosock == sock) { + skip = TRUE; + break; + } + } + if (skip) + continue; + + iosock = ntreeAddSocketInterfaceFromSocket(ngroup, node, sock); + + /* lazy init */ + if (!input_node) { + input_node = nodeAddStaticNode(C, ngroup, NODE_GROUP_INPUT); + + input_node->locx = min[0] - center[0] - offsetx; + input_node->locy = -offsety; + } + node_group_input_verify(ngroup, input_node, (ID *)ngroup); + + /* create new internal link */ + input_sock = node_group_input_find_socket(input_node, iosock->identifier); + nodeAddLink(ngroup, input_node, input_sock, node, sock); + } + + for (sock = node->outputs.first; sock; sock = sock->next) { + bNodeSocket *iosock, *output_sock; + int skip = FALSE; + for (link = ngroup->links.first; link; link = link->next) + if (link->fromsock == sock) + skip = TRUE; + if (skip) + continue; + + iosock = ntreeAddSocketInterfaceFromSocket(ngroup, node, sock); + + /* lazy init */ + if (!output_node) { + output_node = nodeAddStaticNode(C, ngroup, NODE_GROUP_OUTPUT); + + output_node->locx = max[0] - center[0] + offsetx; + output_node->locy = -offsety; + } + + node_group_output_verify(ngroup, output_node, (ID *)ngroup); + + /* create new internal link */ + output_sock = node_group_output_find_socket(output_node, iosock->identifier); + nodeAddLink(ngroup, node, sock, output_node, output_sock); + } + } } } @@ -1035,30 +937,32 @@ static int node_group_make_insert_selected(bNodeTree *ntree, bNode *gnode) ngroup->update |= NTREE_UPDATE | NTREE_UPDATE_LINKS; /* update of the tree containing the group instance node */ ntree->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS; - - return 1; } -static bNode *node_group_make_from_selected(bNodeTree *ntree) +static bNode *node_group_make_from_selected(const bContext *C, bNodeTree *ntree, const char *ntype, const char *ntreetype) { + Main *bmain = CTX_data_main(C); bNode *gnode; bNodeTree *ngroup; float min[2], max[2]; - bNodeTemplate ntemp; - - node_get_selected_minmax(ntree, NULL, min, max); - + int totselect; + + totselect = node_get_selected_minmax(ntree, NULL, min, max); + /* don't make empty group */ + if (totselect == 0) + return NULL; + /* new nodetree */ - ngroup = ntreeAddTree(G.main, "NodeGroup", ntree->type, NODE_GROUP); - + ngroup = ntreeAddTree(bmain, "NodeGroup", ntreetype); + /* make group node */ - ntemp.type = NODE_GROUP; - ntemp.ngroup = ngroup; - gnode = nodeAddNode(ntree, &ntemp); + gnode = nodeAddNode(C, ntree, ntype); + gnode->id = (ID *)ngroup; + gnode->locx = 0.5f * (min[0] + max[0]); gnode->locy = 0.5f * (min[1] + max[1]); - - node_group_make_insert_selected(ntree, gnode); + + node_group_make_insert_selected(C, ntree, gnode); /* update of the tree containing the group instance node */ ntree->update |= NTREE_UPDATE_NODES; @@ -1066,120 +970,116 @@ static bNode *node_group_make_from_selected(bNodeTree *ntree) return gnode; } -typedef enum eNodeGroupMakeType { - NODE_GM_NEW, - NODE_GM_INSERT -} eNodeGroupMakeType; - -/* Operator Property */ -EnumPropertyItem node_group_make_types[] = { - {NODE_GM_NEW, "NEW", 0, "New", "Create a new node group from selected nodes"}, - {NODE_GM_INSERT, "INSERT", 0, "Insert", "Insert into active node group"}, - {0, NULL, 0, NULL, NULL} -}; - static int node_group_make_exec(bContext *C, wmOperator *op) { SpaceNode *snode = CTX_wm_space_node(C); + bNodeTree *ntree = snode->edittree; + char *node_idname, *ntree_idname; + bNodeTree *ngroup; bNode *gnode; - int type = RNA_enum_get(op->ptr, "type"); - - if (snode->edittree != snode->nodetree) { - BKE_report(op->reports, RPT_WARNING, "Cannot add a new group in a group"); - return OPERATOR_CANCELLED; - } - - /* for time being... is too complex to handle */ - if (snode->treetype == NTREE_COMPOSIT) { - for (gnode = snode->nodetree->nodes.first; gnode; gnode = gnode->next) { - if (gnode->flag & SELECT) - if (gnode->type == CMP_NODE_R_LAYERS) - break; - } - - if (gnode) { - BKE_report(op->reports, RPT_WARNING, "Cannot add a Render Layers node in a group"); - return OPERATOR_CANCELLED; - } - } - + ED_preview_kill_jobs(C); - - switch (type) { - case NODE_GM_NEW: - if (node_group_make_test(snode->nodetree, NULL)) { - gnode = node_group_make_from_selected(snode->nodetree); - } - else { - BKE_report(op->reports, RPT_WARNING, "Cannot make group"); - return OPERATOR_CANCELLED; - } - break; - case NODE_GM_INSERT: - gnode = nodeGetActive(snode->nodetree); - if (!gnode || gnode->type != NODE_GROUP) { - BKE_report(op->reports, RPT_WARNING, "No active group node"); - return OPERATOR_CANCELLED; - } - if (node_group_make_test(snode->nodetree, gnode)) { - node_group_make_insert_selected(snode->nodetree, gnode); - } - else { - BKE_report(op->reports, RPT_WARNING, "Cannot insert into group"); - return OPERATOR_CANCELLED; - } - break; + + if (!node_group_operator_check_type(C, op, &node_idname, &ntree_idname)) + return OPERATOR_PASS_THROUGH; + + if (!node_group_make_test_selected(ntree, NULL, ntree_idname, op->reports)) { + MEM_freeN(node_idname); + MEM_freeN(ntree_idname); + return OPERATOR_CANCELLED; } - + + gnode = node_group_make_from_selected(C, ntree, node_idname, ntree_idname); + MEM_freeN(node_idname); + MEM_freeN(ntree_idname); + if (gnode) { - nodeSetActive(snode->nodetree, gnode); - snode_make_group_editable(snode, gnode); + ngroup = (bNodeTree *)gnode->id; + + nodeSetActive(ntree, gnode); + if (ngroup) { + ED_node_tree_push(snode, ngroup, gnode); + ntreeUpdateTree(ngroup); + } } - - if (gnode) - ntreeUpdateTree((bNodeTree *)gnode->id); - ntreeUpdateTree(snode->nodetree); + + ntreeUpdateTree(ntree); snode_notify(C, snode); snode_dag_update(C, snode); - + return OPERATOR_FINISHED; } -static int node_group_make_invoke(bContext *C, wmOperator *UNUSED(op), const wmEvent *UNUSED(event)) -{ - SpaceNode *snode = CTX_wm_space_node(C); - bNode *act = nodeGetActive(snode->edittree); - uiPopupMenu *pup = uiPupMenuBegin(C, CTX_IFACE_(BLF_I18NCONTEXT_OPERATOR_DEFAULT, "Make Group"), ICON_NONE); - uiLayout *layout = uiPupMenuLayout(pup); - - uiLayoutSetOperatorContext(layout, WM_OP_EXEC_DEFAULT); - uiItemEnumO(layout, "NODE_OT_group_make", NULL, 0, "type", NODE_GM_NEW); - - /* if active node is a group, add insert option */ - if (act && act->type == NODE_GROUP) { - uiItemEnumO(layout, "NODE_OT_group_make", NULL, 0, "type", NODE_GM_INSERT); - } - - uiPupMenuEnd(C, pup); - - return OPERATOR_CANCELLED; -} - void NODE_OT_group_make(wmOperatorType *ot) { /* identifiers */ - ot->name = "Group"; + ot->name = "Make Group"; ot->description = "Make group from selected nodes"; ot->idname = "NODE_OT_group_make"; - + /* api callbacks */ - ot->invoke = node_group_make_invoke; ot->exec = node_group_make_exec; ot->poll = ED_operator_node_active; - + /* flags */ ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; + + node_group_operator_properties(ot); +} - RNA_def_enum(ot->srna, "type", node_group_make_types, NODE_GM_NEW, "Type", ""); +/* ****************** Group Insert operator ******************* */ + +static int node_group_insert_exec(bContext *C, wmOperator *op) +{ + SpaceNode *snode = CTX_wm_space_node(C); + bNodeTree *ntree = snode->edittree; + bNodeTree *ngroup; + char *node_idname; + bNode *gnode; + + ED_preview_kill_jobs(C); + + if (!node_group_operator_check_type(C, op, &node_idname, NULL)) + return OPERATOR_PASS_THROUGH; + + gnode = node_group_get_active(C, node_idname); + MEM_freeN(node_idname); + + if (!gnode || !gnode->id) + return OPERATOR_CANCELLED; + + ngroup = (bNodeTree *)gnode->id; + if (!node_group_make_test_selected(ntree, gnode, ngroup->idname, op->reports)) + return OPERATOR_CANCELLED; + + node_group_make_insert_selected(C, ntree, gnode); + + nodeSetActive(ntree, gnode); + ED_node_tree_push(snode, ngroup, gnode); + ntreeUpdateTree(ngroup); + + ntreeUpdateTree(ntree); + + snode_notify(C, snode); + snode_dag_update(C, snode); + + return OPERATOR_FINISHED; +} + +void NODE_OT_group_insert(wmOperatorType *ot) +{ + /* identifiers */ + ot->name = "Group Insert"; + ot->description = "Insert selected nodes into a node group"; + ot->idname = "NODE_OT_group_insert"; + + /* api callbacks */ + ot->exec = node_group_insert_exec; + ot->poll = ED_operator_node_active; + + /* flags */ + ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; + + node_group_operator_properties(ot); } diff --git a/source/blender/editors/space_node/node_header.c b/source/blender/editors/space_node/node_header.c index f26b6ff0f54..175bbce756e 100644 --- a/source/blender/editors/space_node/node_header.c +++ b/source/blender/editors/space_node/node_header.c @@ -58,186 +58,21 @@ /* ************************ add menu *********************** */ -static void do_node_add(bContext *C, bNodeTemplate *ntemp) -{ - Main *bmain = CTX_data_main(C); - Scene *scene = CTX_data_scene(C); - SpaceNode *snode = CTX_wm_space_node(C); - ScrArea *sa = CTX_wm_area(C); - ARegion *ar; - bNode *node, *node_new; - - /* get location to add node at mouse */ - for (ar = sa->regionbase.first; ar; ar = ar->next) { - if (ar->regiontype == RGN_TYPE_WINDOW) { - wmWindow *win = CTX_wm_window(C); - int x = win->eventstate->x - ar->winrct.xmin; - int y = win->eventstate->y - ar->winrct.ymin; - - if (y < 60) y += 60; - UI_view2d_region_to_view(&ar->v2d, x, y, &snode->cursor[0], &snode->cursor[1]); - } - } - - /* store selection in temp test flag */ - for (node = snode->edittree->nodes.first; node; node = node->next) { - if (node->flag & NODE_SELECT) node->flag |= NODE_TEST; - else node->flag &= ~NODE_TEST; - } - - node_new = node_add_node(snode, bmain, scene, ntemp, snode->cursor[0], snode->cursor[1]); - - /* select previous selection before autoconnect */ - for (node = snode->edittree->nodes.first; node; node = node->next) { - if (node->flag & NODE_TEST) node->flag |= NODE_SELECT; - } - - /* deselect after autoconnection */ - for (node = snode->edittree->nodes.first; node; node = node->next) { - if (node->flag & NODE_TEST) node->flag &= ~NODE_SELECT; - } - - /* once this is called from an operator, this should be removed */ - if (node_new) { - char undostr[BKE_UNDO_STR_MAX]; - BLI_snprintf(undostr, sizeof(undostr), "Add Node %s", nodeLabel(node_new)); - BKE_write_undo(C, undostr); - } - - snode_notify(C, snode); - snode_dag_update(C, snode); -} - -static void do_node_add_static(bContext *C, void *UNUSED(arg), int event) -{ - Main *bmain = CTX_data_main(C); - Scene *scene = CTX_data_scene(C); - bNodeTemplate ntemp; - - ntemp.type = event; - ntemp.main = bmain; - ntemp.scene = scene; - - do_node_add(C, &ntemp); -} - -static void do_node_add_group(bContext *C, void *UNUSED(arg), int event) -{ - SpaceNode *snode = CTX_wm_space_node(C); - Main *bmain = CTX_data_main(C); - Scene *scene = CTX_data_scene(C); - bNodeTemplate ntemp; - - if (event >= 0) { - ntemp.ngroup = BLI_findlink(&G.main->nodetree, event); - ntemp.type = ntemp.ngroup->nodetype; - } - else { - ntemp.type = -event; - switch (ntemp.type) { - case NODE_GROUP: - ntemp.ngroup = ntreeAddTree(bmain, "Group", snode->treetype, ntemp.type); - break; - default: - ntemp.ngroup = NULL; - } - } - if (!ntemp.ngroup) - return; - - ntemp.main = bmain; - ntemp.scene = scene; - - do_node_add(C, &ntemp); -} - -static int node_tree_has_type(int treetype, int nodetype) -{ - bNodeTreeType *ttype = ntreeGetType(treetype); - bNodeType *ntype; - for (ntype = ttype->node_types.first; ntype; ntype = ntype->next) { - if (ntype->type == nodetype) - return 1; - } - return 0; -} - -static void node_add_menu(bContext *C, uiLayout *layout, void *arg_nodeclass) -{ - Main *bmain = CTX_data_main(C); - Scene *scene = CTX_data_scene(C); - SpaceNode *snode = CTX_wm_space_node(C); - bNodeTree *ntree; - int nodeclass = GET_INT_FROM_POINTER(arg_nodeclass); - int event, compatibility = 0; - - ntree = snode->nodetree; - - if (!ntree) { - uiItemS(layout); - return; - } - - if (ntree->type == NTREE_SHADER) { - if (BKE_scene_use_new_shading_nodes(scene)) - compatibility = NODE_NEW_SHADING; - else - compatibility = NODE_OLD_SHADING; - } - - if (nodeclass == NODE_CLASS_GROUP) { - bNodeTree *ngroup; - - uiLayoutSetFunc(layout, do_node_add_group, NULL); - - /* XXX hack: negative numbers used for empty group types */ - if (node_tree_has_type(ntree->type, NODE_GROUP)) - uiItemV(layout, IFACE_("New Group"), 0, -NODE_GROUP); - uiItemS(layout); - - for (ngroup = bmain->nodetree.first, event = 0; ngroup; ngroup = ngroup->id.next, ++event) { - /* only use group trees */ - if (ngroup->type == ntree->type && ngroup->nodetype == NODE_GROUP) { - uiItemV(layout, ngroup->id.name + 2, 0, event); - } - } - } - else { - bNodeType *ntype; - - uiLayoutSetFunc(layout, do_node_add_static, NULL); - - for (ntype = ntreeGetType(ntree->type)->node_types.first; ntype; ntype = ntype->next) { - if (ntype->nclass == nodeclass && ntype->name) { - if (!compatibility || (ntype->compatibility & compatibility)) { - uiItemV(layout, IFACE_(ntype->name), 0, ntype->type); - } - } - } - } -} - -static void node_menu_add_foreach_cb(void *calldata, int nclass, const char *name) -{ - uiLayout *layout = calldata; - uiItemMenuF(layout, IFACE_(name), 0, node_add_menu, SET_INT_IN_POINTER(nclass)); -} - static void node_menu_add(const bContext *C, Menu *menu) { - Scene *scene = CTX_data_scene(C); SpaceNode *snode = CTX_wm_space_node(C); uiLayout *layout = menu->layout; - bNodeTreeType *ntreetype = ntreeGetType(snode->treetype); + bNodeTree *ntree = snode->edittree; - if (!snode->nodetree) + if (!ntree || !ntree->typeinfo || !ntree->typeinfo->draw_add_menu) { uiLayoutSetActive(layout, FALSE); - + return; + } + uiLayoutSetOperatorContext(layout, WM_OP_INVOKE_DEFAULT); uiItemO(layout, CTX_IFACE_(BLF_I18NCONTEXT_OPERATOR_DEFAULT, "Search ..."), 0, "NODE_OT_add_search"); - if (ntreetype && ntreetype->foreach_nodeclass) - ntreetype->foreach_nodeclass(scene, layout, node_menu_add_foreach_cb); + ntree->typeinfo->draw_add_menu(C, layout, ntree); } void node_menus_register(void) diff --git a/source/blender/editors/space_node/node_intern.h b/source/blender/editors/space_node/node_intern.h index cbf7101a101..a24da7143f9 100644 --- a/source/blender/editors/space_node/node_intern.h +++ b/source/blender/editors/space_node/node_intern.h @@ -32,6 +32,7 @@ #define __NODE_INTERN_H__ #include <stddef.h> /* for size_t */ +#include "BKE_node.h" #include "UI_interface.h" /* internal exports only */ @@ -43,7 +44,6 @@ struct bContext; struct wmWindow; struct wmWindowManager; struct wmEvent; -struct bNodeTemplate; struct bNode; struct bNodeSocket; struct bNodeLink; @@ -66,21 +66,26 @@ typedef struct bNodeLinkDrag { ARegion *node_has_buttons_region(ScrArea *sa); ARegion *node_has_tools_region(ScrArea *sa); +void snode_group_offset(struct SpaceNode *snode, float *x, float *y); /* transform between View2Ds in the tree path */ + /* node_header.c */ void node_menus_register(void); /* node_draw.c */ int node_get_colorid(struct bNode *node); -void node_socket_circle_draw(struct bNodeTree *ntree, struct bNodeSocket *sock, float size, int highlight); +void node_socket_circle_draw(const struct bContext *C, struct bNodeTree *ntree, struct bNode *node, + struct bNodeSocket *sock, float size, int highlight); int node_get_resize_cursor(int directions); void node_draw_shadow(struct SpaceNode *snode, struct bNode *node, float radius, float alpha); -void node_draw_default(const struct bContext *C, struct ARegion *ar, struct SpaceNode *snode, struct bNodeTree *ntree, struct bNode *node); +void node_draw_default(const struct bContext *C, struct ARegion *ar, struct SpaceNode *snode, + struct bNodeTree *ntree, struct bNode *node, bNodeInstanceKey key); void node_update_default(const struct bContext *C, struct bNodeTree *ntree, struct bNode *node); int node_select_area_default(struct bNode *node, int x, int y); int node_tweak_area_default(struct bNode *node, int x, int y); -void node_update_nodetree(const struct bContext *C, struct bNodeTree *ntree, float offsetx, float offsety); -void node_draw_nodetree(const struct bContext *C, struct ARegion *ar, struct SpaceNode *snode, struct bNodeTree *ntree); -void drawnodespace(const bContext *C, ARegion *ar, View2D *v2d); +void node_update_nodetree(const struct bContext *C, struct bNodeTree *ntree); +void node_draw_nodetree(const struct bContext *C, struct ARegion *ar, struct SpaceNode *snode, + struct bNodeTree *ntree, bNodeInstanceKey parent_key); +void drawnodespace(const bContext *C, ARegion *ar); void node_set_cursor(struct wmWindow *win, struct SpaceNode *snode); /* DPI scaled coords */ @@ -100,8 +105,6 @@ void node_operatortypes(void); void node_keymap(struct wmKeyConfig *keyconf); /* node_select.c */ -void node_select(struct bNode *node); -void node_deselect(struct bNode *node); void node_deselect_all(struct SpaceNode *snode); void node_socket_select(struct bNode *node, struct bNodeSocket *sock); void node_socket_deselect(struct bNode *node, struct bNodeSocket *sock, int deselect_node); @@ -138,13 +141,15 @@ void draw_nodespace_back_pix(const struct bContext *C, struct ARegion *ar, struc /* node_add.c */ -bNode *node_add_node(struct SpaceNode *snode, struct Main *bmain, struct Scene *scene, - struct bNodeTemplate *ntemp, float locx, float locy); +bNode *node_add_node(const struct bContext *C, const char *idname, int type, float locx, float locy); void NODE_OT_add_reroute(struct wmOperatorType *ot); +void NODE_OT_add_file(struct wmOperatorType *ot); +void NODE_OT_new_node_tree(struct wmOperatorType *ot); /* node_group.c */ void NODE_OT_group_make(struct wmOperatorType *ot); +void NODE_OT_group_insert(struct wmOperatorType *ot); void NODE_OT_group_ungroup(struct wmOperatorType *ot); void NODE_OT_group_separate(struct wmOperatorType *ot); void NODE_OT_group_edit(struct wmOperatorType *ot); @@ -154,11 +159,6 @@ void NODE_OT_group_socket_move_up(struct wmOperatorType *ot); void NODE_OT_group_socket_move_down(struct wmOperatorType *ot); -/* note_add.c */ -void NODE_OT_add_file(struct wmOperatorType *ot); -void NODE_OT_new_node_tree(struct wmOperatorType *ot); - - /* node_relationships.c */ void NODE_OT_link(struct wmOperatorType *ot); void NODE_OT_link_make(struct wmOperatorType *ot); @@ -175,11 +175,9 @@ void NODE_OT_show_cyclic_dependencies(struct wmOperatorType *ot); void NODE_OT_link_viewer(struct wmOperatorType *ot); /* node_edit.c */ -void node_tree_from_ID(ID *id, bNodeTree **ntree, bNodeTree **edittree, int *treetype); void snode_notify(struct bContext *C, struct SpaceNode *snode); void snode_dag_update(struct bContext *C, struct SpaceNode *snode); -void snode_set_context(struct SpaceNode *snode, Scene *scene); -void snode_make_group_editable(struct SpaceNode *snode, struct bNode *gnode); +void snode_set_context(const struct bContext *C); bNode *node_tree_get_editgroup(bNodeTree *ntree); void snode_update(struct SpaceNode *snode, struct bNode *node); @@ -215,6 +213,10 @@ void NODE_OT_output_file_move_active_socket(struct wmOperatorType *ot); void NODE_OT_clipboard_copy(struct wmOperatorType *ot); void NODE_OT_clipboard_paste(struct wmOperatorType *ot); +void NODE_OT_tree_socket_add(struct wmOperatorType *ot); +void NODE_OT_tree_socket_remove(struct wmOperatorType *ot); +void NODE_OT_tree_socket_move(struct wmOperatorType *ot); + void NODE_OT_shader_script_update(struct wmOperatorType *ot); void NODE_OT_viewer_border(struct wmOperatorType *ot); diff --git a/source/blender/editors/space_node/node_ops.c b/source/blender/editors/space_node/node_ops.c index d16c6627d3f..db664265466 100644 --- a/source/blender/editors/space_node/node_ops.c +++ b/source/blender/editors/space_node/node_ops.c @@ -84,13 +84,10 @@ void node_operatortypes(void) WM_operatortype_append(NODE_OT_add_reroute); WM_operatortype_append(NODE_OT_group_make); + WM_operatortype_append(NODE_OT_group_insert); WM_operatortype_append(NODE_OT_group_ungroup); WM_operatortype_append(NODE_OT_group_separate); WM_operatortype_append(NODE_OT_group_edit); - WM_operatortype_append(NODE_OT_group_socket_add); - WM_operatortype_append(NODE_OT_group_socket_remove); - WM_operatortype_append(NODE_OT_group_socket_move_up); - WM_operatortype_append(NODE_OT_group_socket_move_down); WM_operatortype_append(NODE_OT_link_viewer); @@ -122,6 +119,10 @@ void node_operatortypes(void) WM_operatortype_append(NODE_OT_shader_script_update); WM_operatortype_append(NODE_OT_viewer_border); + + WM_operatortype_append(NODE_OT_tree_socket_add); + WM_operatortype_append(NODE_OT_tree_socket_remove); + WM_operatortype_append(NODE_OT_tree_socket_move); } void ED_operatormacros_node(void) @@ -198,6 +199,29 @@ static void node_select_keymap(wmKeyMap *keymap, int extend) } } +/* register group operators for a specific group node type */ +static void node_group_operators(wmKeyMap *keymap, const char *node_type) +{ + wmKeyMapItem *kmi; + + kmi = WM_keymap_add_item(keymap, "NODE_OT_group_make", GKEY, KM_PRESS, KM_CTRL, 0); + RNA_string_set(kmi->ptr, "node_type", node_type); + + kmi = WM_keymap_add_item(keymap, "NODE_OT_group_ungroup", GKEY, KM_PRESS, KM_ALT, 0); + RNA_string_set(kmi->ptr, "node_type", node_type); + + kmi = WM_keymap_add_item(keymap, "NODE_OT_group_separate", PKEY, KM_PRESS, 0, 0); + RNA_string_set(kmi->ptr, "node_type", node_type); + + kmi= WM_keymap_add_item(keymap, "NODE_OT_group_edit", TABKEY, KM_PRESS, 0, 0); + RNA_string_set(kmi->ptr, "node_type", node_type); + RNA_boolean_set(kmi->ptr, "exit", FALSE); + + kmi= WM_keymap_add_item(keymap, "NODE_OT_group_edit", TABKEY, KM_PRESS, KM_SHIFT, 0); + RNA_string_set(kmi->ptr, "node_type", node_type); + RNA_boolean_set(kmi->ptr, "exit", TRUE); +} + void node_keymap(struct wmKeyConfig *keyconf) { wmKeyMap *keymap; @@ -230,9 +254,18 @@ void node_keymap(struct wmKeyConfig *keyconf) RNA_boolean_set(kmi->ptr, "deselect", TRUE); /* each of these falls through if not handled... */ - WM_keymap_add_item(keymap, "NODE_OT_link", LEFTMOUSE, KM_PRESS, 0, 0); + kmi = WM_keymap_add_item(keymap, "NODE_OT_link", LEFTMOUSE, KM_PRESS, 0, 0); + RNA_boolean_set(kmi->ptr, "detach", FALSE); + RNA_boolean_set(kmi->ptr, "expose", FALSE); kmi = WM_keymap_add_item(keymap, "NODE_OT_link", LEFTMOUSE, KM_PRESS, KM_CTRL, 0); RNA_boolean_set(kmi->ptr, "detach", TRUE); + RNA_boolean_set(kmi->ptr, "expose", FALSE); + kmi = WM_keymap_add_item(keymap, "NODE_OT_link", LEFTMOUSE, KM_PRESS, KM_SHIFT, 0); + RNA_boolean_set(kmi->ptr, "detach", FALSE); + RNA_boolean_set(kmi->ptr, "expose", TRUE); + kmi = WM_keymap_add_item(keymap, "NODE_OT_link", LEFTMOUSE, KM_PRESS, KM_SHIFT|KM_CTRL, 0); + RNA_boolean_set(kmi->ptr, "detach", TRUE); + RNA_boolean_set(kmi->ptr, "expose", TRUE); WM_keymap_add_item(keymap, "NODE_OT_resize", LEFTMOUSE, KM_PRESS, 0, 0); WM_keymap_add_item(keymap, "NODE_OT_add_reroute", LEFTMOUSE, KM_PRESS, KM_SHIFT, 0); @@ -288,11 +321,10 @@ void node_keymap(struct wmKeyConfig *keyconf) WM_keymap_add_item(keymap, "NODE_OT_select_same_type_next", RIGHTBRACKETKEY, KM_PRESS, KM_SHIFT, 0); WM_keymap_add_item(keymap, "NODE_OT_select_same_type_prev", LEFTBRACKETKEY, KM_PRESS, KM_SHIFT, 0); - WM_keymap_add_item(keymap, "NODE_OT_group_make", GKEY, KM_PRESS, KM_CTRL, 0); - WM_keymap_add_item(keymap, "NODE_OT_group_ungroup", GKEY, KM_PRESS, KM_ALT, 0); - WM_keymap_add_item(keymap, "NODE_OT_group_separate", PKEY, KM_PRESS, 0, 0); - WM_keymap_add_item(keymap, "NODE_OT_group_edit", TABKEY, KM_PRESS, 0, 0); - + node_group_operators(keymap, "ShaderNodeGroup"); + node_group_operators(keymap, "CompositorNodeGroup"); + node_group_operators(keymap, "TextureNodeGroup"); + WM_keymap_add_item(keymap, "NODE_OT_read_renderlayers", RKEY, KM_PRESS, KM_CTRL, 0); WM_keymap_add_item(keymap, "NODE_OT_read_fullsamplelayers", RKEY, KM_PRESS, KM_SHIFT, 0); WM_keymap_add_item(keymap, "NODE_OT_render_changed", ZKEY, KM_PRESS, 0, 0); diff --git a/source/blender/editors/space_node/node_relationships.c b/source/blender/editors/space_node/node_relationships.c index 097e4f418e0..d95487bb24e 100644 --- a/source/blender/editors/space_node/node_relationships.c +++ b/source/blender/editors/space_node/node_relationships.c @@ -54,6 +54,7 @@ #include "UI_view2d.h" #include "node_intern.h" /* own include */ +#include "NOD_common.h" /* ****************** Add *********************** */ @@ -323,13 +324,8 @@ static int node_link_viewer(const bContext *C, bNode *tonode) if (sock) { /* add a new viewer if none exists yet */ if (!node) { - Main *bmain = CTX_data_main(C); - Scene *scene = CTX_data_scene(C); - bNodeTemplate ntemp; - - ntemp.type = CMP_NODE_VIEWER; /* XXX location is a quick hack, just place it next to the linked socket */ - node = node_add_node(snode, bmain, scene, &ntemp, sock->locx + 100, sock->locy); + node = node_add_node(C, NULL, CMP_NODE_VIEWER, sock->locx + 100, sock->locy); if (!node) return OPERATOR_CANCELLED; @@ -364,7 +360,7 @@ static int node_active_link_viewer(bContext *C, wmOperator *UNUSED(op)) SpaceNode *snode = CTX_wm_space_node(C); bNode *node; - node = editnode_get_active(snode->edittree); + node = nodeGetActive(snode->edittree); if (!node) return OPERATOR_CANCELLED; @@ -434,18 +430,6 @@ static void node_remove_extra_links(SpaceNode *snode, bNodeSocket *tsock, bNodeL } } -static int outside_group_rect(SpaceNode *snode) -{ - bNode *gnode = node_tree_get_editgroup(snode->nodetree); - if (gnode) { - return (snode->cursor[0] < gnode->totr.xmin || - snode->cursor[0] >= gnode->totr.xmax || - snode->cursor[1] < gnode->totr.ymin || - snode->cursor[1] >= gnode->totr.ymax); - } - return 0; -} - /* loop that adds a nodelink, called by function below */ /* in_out = starting socket */ static int node_link_modal(bContext *C, wmOperator *op, const wmEvent *event) @@ -459,55 +443,41 @@ static int node_link_modal(bContext *C, wmOperator *op, const wmEvent *event) bNodeLink *link; LinkData *linkdata; int in_out; + int expose; in_out = nldrag->in_out; - + UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &snode->cursor[0], &snode->cursor[1]); + expose = RNA_boolean_get(op->ptr, "expose"); + switch (event->type) { case MOUSEMOVE: - + if (in_out == SOCK_OUT) { if (node_find_indicated_socket(snode, &tnode, &tsock, SOCK_IN)) { for (linkdata = nldrag->links.first; linkdata; linkdata = linkdata->next) { link = linkdata->data; - + /* skip if this is already the target socket */ if (link->tosock == tsock) continue; /* skip if socket is on the same node as the fromsock */ if (tnode && link->fromnode == tnode) continue; - + /* attach links to the socket */ link->tonode = tnode; link->tosock = tsock; - /* add it to the node tree temporarily */ - if (BLI_findindex(&ntree->links, link) < 0) - BLI_addtail(&ntree->links, link); - - ntree->update |= NTREE_UPDATE_LINKS; } - ntreeUpdateTree(ntree); } else { - int do_update = FALSE; for (linkdata = nldrag->links.first; linkdata; linkdata = linkdata->next) { link = linkdata->data; - - if (link->tonode || link->tosock) { - BLI_remlink(&ntree->links, link); - link->prev = link->next = NULL; - link->tonode = NULL; - link->tosock = NULL; - - ntree->update |= NTREE_UPDATE_LINKS; - do_update = TRUE; - } - } - if (do_update) { - ntreeUpdateTree(ntree); + + link->tonode = NULL; + link->tosock = NULL; } } } @@ -515,108 +485,126 @@ static int node_link_modal(bContext *C, wmOperator *op, const wmEvent *event) if (node_find_indicated_socket(snode, &tnode, &tsock, SOCK_OUT)) { for (linkdata = nldrag->links.first; linkdata; linkdata = linkdata->next) { link = linkdata->data; - + /* skip if this is already the target socket */ if (link->fromsock == tsock) continue; /* skip if socket is on the same node as the fromsock */ if (tnode && link->tonode == tnode) continue; - + /* attach links to the socket */ link->fromnode = tnode; link->fromsock = tsock; - /* add it to the node tree temporarily */ - if (BLI_findindex(&ntree->links, link) < 0) - BLI_addtail(&ntree->links, link); - - ntree->update |= NTREE_UPDATE_LINKS; } - ntreeUpdateTree(ntree); } else { - int do_update = FALSE; for (linkdata = nldrag->links.first; linkdata; linkdata = linkdata->next) { link = linkdata->data; - - if (link->fromnode || link->fromsock) { - BLI_remlink(&ntree->links, link); - link->prev = link->next = NULL; - link->fromnode = NULL; - link->fromsock = NULL; - - ntree->update |= NTREE_UPDATE_LINKS; - do_update = TRUE; - } - } - if (do_update) { - ntreeUpdateTree(ntree); + + link->fromnode = NULL; + link->fromsock = NULL; } } } - + ED_region_tag_redraw(ar); break; - + case LEFTMOUSE: case RIGHTMOUSE: case MIDDLEMOUSE: { + /* XXX expose + detach could have some ugly corner cases and is not great. + * The first link will define the exposed socket type, which is arbitrary. + * Some of the resulting links may turn out to be invalid. + */ + bNode *ionode = NULL; + bNodeSocket *iosock = NULL, *gsock; for (linkdata = nldrag->links.first; linkdata; linkdata = linkdata->next) { link = linkdata->data; - + if (link->tosock && link->fromsock) { - /* send changed events for original tonode and new */ - if (link->tonode) - snode_update(snode, link->tonode); - + /* add link to the node tree */ + BLI_addtail(&ntree->links, link); + + ntree->update |= NTREE_UPDATE_LINKS; + + /* tag tonode for update */ + link->tonode->update |= NODE_UPDATE; + /* we might need to remove a link */ if (in_out == SOCK_OUT) node_remove_extra_links(snode, link->tosock, link); - - /* when linking to group outputs, update the socket type */ - /* XXX this should all be part of a generic update system */ - if (!link->tonode) { - if (link->tosock->type != link->fromsock->type) - nodeSocketSetType(link->tosock, link->fromsock->type); - } } - else if (outside_group_rect(snode) && (link->tonode || link->fromnode)) { - /* automatically add new group socket */ - if (link->tonode && link->tosock) { - link->fromsock = node_group_expose_socket(ntree, link->tosock, SOCK_IN); - link->fromnode = NULL; - if (BLI_findindex(&ntree->links, link) < 0) - BLI_addtail(&ntree->links, link); - + else if (expose) { + if (link->tosock) { + if (!ionode) { + ionode = nodeAddStaticNode(C, snode->edittree, NODE_GROUP_INPUT); + gsock = ntreeAddSocketInterfaceFromSocket(snode->edittree, link->tonode, link->tosock); + node_group_input_verify(snode->edittree, ionode, (ID *)snode->edittree); + iosock = node_group_input_find_socket(ionode, gsock->identifier); + + { + /* place the node at the mouse pointer */ + float sockx = 42.f + 3*HIDDEN_RAD; /* XXX totally arbitrary initial hidden node size ... */ + float socky = -HIDDEN_RAD; + + ionode->locx = snode->cursor[0] - sockx; + ionode->locy = snode->cursor[1] - socky; + } + } + link->fromnode = ionode; + link->fromsock = iosock; + + BLI_addtail(&ntree->links, link); + ntree->update |= NTREE_UPDATE_GROUP_IN | NTREE_UPDATE_LINKS; } - else if (link->fromnode && link->fromsock) { - link->tosock = node_group_expose_socket(ntree, link->fromsock, SOCK_OUT); - link->tonode = NULL; - if (BLI_findindex(&ntree->links, link) < 0) - BLI_addtail(&ntree->links, link); - + else if (link->fromsock) { + if (!ionode) { + ionode = nodeAddStaticNode(C, snode->edittree, NODE_GROUP_OUTPUT); + gsock = ntreeAddSocketInterfaceFromSocket(snode->edittree, link->fromnode, link->fromsock); + node_group_output_verify(snode->edittree, ionode, (ID *)snode->edittree); + iosock = node_group_output_find_socket(ionode, gsock->identifier); + + { + /* place the node at the mouse pointer */ + float sockx = 0; + float socky = -HIDDEN_RAD; + + ionode->locx = snode->cursor[0] - sockx; + ionode->locy = snode->cursor[1] - socky; + } + } + link->tonode = ionode; + link->tosock = iosock; + + BLI_addtail(&ntree->links, link); + ntree->update |= NTREE_UPDATE_GROUP_OUT | NTREE_UPDATE_LINKS; } + else { + nodeRemLink(snode->edittree, link); + } } else nodeRemLink(ntree, link); } - + ntreeUpdateTree(ntree); snode_notify(C, snode); snode_dag_update(C, snode); - + BLI_remlink(&snode->linkdrag, nldrag); /* links->data pointers are either held by the tree or freed already */ BLI_freelistN(&nldrag->links); MEM_freeN(nldrag); - + return OPERATOR_FINISHED; } } - + return OPERATOR_RUNNING_MODAL; } @@ -646,6 +634,8 @@ static bNodeLinkDrag *node_link_init(SpaceNode *snode, int detach) linkdata->data = oplink = MEM_callocN(sizeof(bNodeLink), "drag link op link"); *oplink = *link; oplink->next = oplink->prev = NULL; + oplink->flag |= NODE_LINK_VALID; + BLI_addtail(&nldrag->links, linkdata); nodeRemLink(snode->edittree, link); } @@ -659,6 +649,8 @@ static bNodeLinkDrag *node_link_init(SpaceNode *snode, int detach) linkdata->data = oplink = MEM_callocN(sizeof(bNodeLink), "drag link op link"); oplink->fromnode = node; oplink->fromsock = sock; + oplink->flag |= NODE_LINK_VALID; + BLI_addtail(&nldrag->links, linkdata); } } @@ -678,9 +670,11 @@ static bNodeLinkDrag *node_link_init(SpaceNode *snode, int detach) linkdata->data = oplink = MEM_callocN(sizeof(bNodeLink), "drag link op link"); *oplink = *link; oplink->next = oplink->prev = NULL; + oplink->flag |= NODE_LINK_VALID; + BLI_addtail(&nldrag->links, linkdata); nodeRemLink(snode->edittree, link); - + /* send changed event to original link->tonode */ if (node) snode_update(snode, node); @@ -695,6 +689,8 @@ static bNodeLinkDrag *node_link_init(SpaceNode *snode, int detach) linkdata->data = oplink = MEM_callocN(sizeof(bNodeLink), "drag link op link"); oplink->tonode = node; oplink->tosock = sock; + oplink->flag |= NODE_LINK_VALID; + BLI_addtail(&nldrag->links, linkdata); } } @@ -760,6 +756,7 @@ void NODE_OT_link(wmOperatorType *ot) ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_BLOCKING; RNA_def_boolean(ot->srna, "detach", FALSE, "Detach", "Detach and redirect existing links"); + RNA_def_boolean(ot->srna, "expose", FALSE, "Expose", "Expose the socket as an interface node"); } /* ********************** Make Link operator ***************** */ @@ -845,6 +842,8 @@ static int cut_links_exec(bContext *C, wmOperator *op) for (link = snode->edittree->links.first; link; link = next) { next = link->next; + if (nodeLinkIsHidden(link)) + continue; if (cut_links_intersect(link, mcoords, i)) { @@ -1075,11 +1074,8 @@ static void node_join_attach_recursive(bNode *node, bNode *frame) static int node_join_exec(bContext *C, wmOperator *UNUSED(op)) { SpaceNode *snode = CTX_wm_space_node(C); - Main *bmain = CTX_data_main(C); - Scene *scene = CTX_data_scene(C); bNodeTree *ntree = snode->edittree; bNode *node, *frame; - bNodeTemplate ntemp; /* XXX save selection: node_add_node call below sets the new frame as single active+selected node */ for (node = ntree->nodes.first; node; node = node->next) { @@ -1089,10 +1085,7 @@ static int node_join_exec(bContext *C, wmOperator *UNUSED(op)) node->flag &= ~NODE_TEST; } - ntemp.main = bmain; - ntemp.scene = scene; - ntemp.type = NODE_FRAME; - frame = node_add_node(snode, bmain, scene, &ntemp, 0.0f, 0.0f); + frame = node_add_node(C, NULL, NODE_FRAME, 0.0f, 0.0f); /* reset tags */ for (node = ntree->nodes.first; node; node = node->next) @@ -1310,6 +1303,9 @@ static SpaceNode *ed_node_link_conditions(ScrArea *sa, bNode **select) /* test node for links */ for (link = snode->edittree->links.first; link; link = link->next) { + if (nodeLinkIsHidden(link)) + continue; + if (link->tonode == *select || link->fromnode == *select) return NULL; } @@ -1350,7 +1346,9 @@ void ED_node_link_intersect_test(ScrArea *sa, int test) /* we only tag a single link for intersect now */ /* idea; use header dist when more? */ for (link = snode->edittree->links.first; link; link = link->next) { - + if (nodeLinkIsHidden(link)) + continue; + if (cut_links_intersect(link, mcoords, 5)) { /* intersect code wants edges */ if (selink) break; @@ -1415,11 +1413,12 @@ void ED_node_link_insert(ScrArea *sa) link->tonode = select; link->tosock = socket_best_match(&select->inputs); + node_remove_extra_links(snode, link->tosock, link); link->flag &= ~NODE_LINKFLAG_HILITE; nodeAddLink(snode->edittree, select, socket_best_match(&select->outputs), node, sockto); ntreeUpdateTree(snode->edittree); /* needed for pointers */ snode_update(snode, select); - ED_node_changed_update(snode->id, select); + ED_node_tag_update_id(snode->id); } } diff --git a/source/blender/editors/space_node/node_select.c b/source/blender/editors/space_node/node_select.c index c917b8ee756..291fe86e016 100644 --- a/source/blender/editors/space_node/node_select.c +++ b/source/blender/editors/space_node/node_select.c @@ -82,30 +82,9 @@ static bNode *node_under_mouse_tweak(bNodeTree *ntree, int mx, int my) return NULL; } -void node_select(bNode *node) -{ - node->flag |= SELECT; -} - -void node_deselect(bNode *node) -{ - bNodeSocket *sock; - - node->flag &= ~SELECT; - - /* deselect sockets too */ - for (sock = node->inputs.first; sock; sock = sock->next) - sock->flag &= ~SELECT; - for (sock = node->outputs.first; sock; sock = sock->next) - sock->flag &= ~SELECT; -} - static void node_toggle(bNode *node) { - if (node->flag & SELECT) - node_deselect(node); - else - node_select(node); + nodeSetSelected(node, !(node->flag & SELECT)); } void node_socket_select(bNode *node, bNodeSocket *sock) @@ -157,7 +136,7 @@ void node_deselect_all(SpaceNode *snode) bNode *node; for (node = snode->edittree->nodes.first; node; node = node->next) - node_deselect(node); + nodeSetSelected(node, FALSE); } void node_deselect_all_input_sockets(SpaceNode *snode, int deselect_nodes) @@ -189,9 +168,6 @@ void node_deselect_all_input_sockets(SpaceNode *snode, int deselect_nodes) node->flag &= ~SELECT; } } - - for (sock = snode->edittree->outputs.first; sock; sock = sock->next) - sock->flag &= ~SELECT; } void node_deselect_all_output_sockets(SpaceNode *snode, int deselect_nodes) @@ -223,9 +199,6 @@ void node_deselect_all_output_sockets(SpaceNode *snode, int deselect_nodes) node->flag &= ~SELECT; } } - - for (sock = snode->edittree->inputs.first; sock; sock = sock->next) - sock->flag &= ~SELECT; } /* return 1 if we need redraw otherwise zero. */ @@ -249,12 +222,12 @@ int node_select_same_type(SpaceNode *snode) if (p->type != nac->type && p->flag & SELECT) { /* if it's selected but different type, unselect */ redraw = 1; - node_deselect(p); + nodeSetSelected(p, FALSE); } else if (p->type == nac->type && (!(p->flag & SELECT))) { /* if it's the same type and is not selected, select! */ redraw = 1; - node_select(p); + nodeSetSelected(p, TRUE); } } return(redraw); @@ -296,8 +269,8 @@ int node_select_same_type_np(SpaceNode *snode, int dir) if (p) { for (tnode = snode->edittree->nodes.first; tnode; tnode = tnode->next) if (tnode != p) - node_deselect(tnode); - node_select(p); + nodeSetSelected(tnode, FALSE); + nodeSetSelected(p, TRUE); return(1); } return(0); @@ -311,8 +284,8 @@ void node_select_single(bContext *C, bNode *node) for (tnode = snode->edittree->nodes.first; tnode; tnode = tnode->next) if (tnode != node) - node_deselect(tnode); - node_select(node); + nodeSetSelected(tnode, FALSE); + nodeSetSelected(node, TRUE); ED_node_set_active(bmain, snode->edittree, node); @@ -387,8 +360,8 @@ static int node_mouse_select(Main *bmain, SpaceNode *snode, ARegion *ar, const i if (node) { for (tnode = snode->edittree->nodes.first; tnode; tnode = tnode->next) - node_deselect(tnode); - node_select(node); + nodeSetSelected(tnode, FALSE); + nodeSetSelected(node, TRUE); ED_node_set_active(bmain, snode->edittree, node); selected = 1; } @@ -477,13 +450,10 @@ static int node_borderselect_exec(bContext *C, wmOperator *op) for (node = snode->edittree->nodes.first; node; node = node->next) { if (BLI_rctf_isect(&rectf, &node->totr, NULL)) { - if (gesture_mode == GESTURE_MODAL_SELECT) - node_select(node); - else - node_deselect(node); + nodeSetSelected(node, (gesture_mode == GESTURE_MODAL_SELECT)); } else if (!extend) { - node_deselect(node); + nodeSetSelected(node, FALSE); } } @@ -566,11 +536,7 @@ static int do_lasso_select_node(bContext *C, const int mcords[][2], short moves, if (BLI_rcti_isect_pt(&rect, screen_co[0], screen_co[1]) && BLI_lasso_is_point_inside(mcords, moves, screen_co[0], screen_co[1], INT_MAX)) { - if (select) - node_select(node); - else - node_deselect(node); - + nodeSetSelected(node, select); change = TRUE; } } @@ -642,13 +608,13 @@ static int node_select_all_exec(bContext *C, wmOperator *op) for (node = node_lb->first; node; node = node->next) { switch (action) { case SEL_SELECT: - node_select(node); + nodeSetSelected(node, TRUE); break; case SEL_DESELECT: - node_deselect(node); + nodeSetSelected(node, FALSE); break; case SEL_INVERT: - ((node->flag & SELECT) ? node_deselect : node_select)(node); + nodeSetSelected(node, !(node->flag & SELECT)); break; } } @@ -688,13 +654,15 @@ static int node_select_linked_to_exec(bContext *C, wmOperator *UNUSED(op)) node->flag &= ~NODE_TEST; for (link = snode->edittree->links.first; link; link = link->next) { + if (nodeLinkIsHidden(link)) + continue; if (link->fromnode && link->tonode && (link->fromnode->flag & NODE_SELECT)) link->tonode->flag |= NODE_TEST; } for (node = snode->edittree->nodes.first; node; node = node->next) { if (node->flag & NODE_TEST) - node_select(node); + nodeSetSelected(node, TRUE); } ED_node_sort(snode->edittree); @@ -730,13 +698,15 @@ static int node_select_linked_from_exec(bContext *C, wmOperator *UNUSED(op)) node->flag &= ~NODE_TEST; for (link = snode->edittree->links.first; link; link = link->next) { + if (nodeLinkIsHidden(link)) + continue; if (link->fromnode && link->tonode && (link->tonode->flag & NODE_SELECT)) link->fromnode->flag |= NODE_TEST; } for (node = snode->edittree->nodes.first; node; node = node->next) { if (node->flag & NODE_TEST) - node_select(node); + nodeSetSelected(node, TRUE); } ED_node_sort(snode->edittree); diff --git a/source/blender/editors/space_node/node_templates.c b/source/blender/editors/space_node/node_templates.c index ca85415cb5a..e4b0512d992 100644 --- a/source/blender/editors/space_node/node_templates.c +++ b/source/blender/editors/space_node/node_templates.c @@ -130,7 +130,7 @@ static void node_socket_disconnect(Main *bmain, bNodeTree *ntree, bNode *node_to nodeUpdate(ntree, node_to); ntreeUpdateTree(ntree); - ED_node_generic_update(bmain, ntree, node_to); + ED_node_tag_update_nodetree(bmain, ntree); } /* remove all nodes connected to this socket, if they aren't connected to other nodes */ @@ -145,11 +145,11 @@ static void node_socket_remove(Main *bmain, bNodeTree *ntree, bNode *node_to, bN nodeUpdate(ntree, node_to); ntreeUpdateTree(ntree); - ED_node_generic_update(bmain, ntree, node_to); + ED_node_tag_update_nodetree(bmain, ntree); } /* add new node connected to this socket, or replace an existing one */ -static void node_socket_add_replace(Main *bmain, bNodeTree *ntree, bNode *node_to, bNodeSocket *sock_to, bNodeTemplate *ntemp, int sock_num) +static void node_socket_add_replace(const bContext *C, bNodeTree *ntree, bNode *node_to, bNodeSocket *sock_to, int type, bNodeTree *ngroup, int sock_num) { bNode *node_from; bNodeSocket *sock_from_tmp; @@ -163,24 +163,29 @@ static void node_socket_add_replace(Main *bmain, bNodeTree *ntree, bNode *node_t /* find existing node that we can use */ for (node_from = ntree->nodes.first; node_from; node_from = node_from->next) - if (node_from->type == ntemp->type) + if (node_from->type == type) break; if (node_from) if (!(node_from->inputs.first == NULL && !(node_from->typeinfo->flag & NODE_OPTIONS))) node_from = NULL; - if (node_prev && node_prev->type == ntemp->type && - (ntemp->type != NODE_GROUP || node_prev->id == &ntemp->ngroup->id)) - { + /* XXX how can this be done nicely? bNodeTemplate is removed, it doesn't work for generic custom nodes */ + if (node_prev && node_prev->type == type && + (type != NODE_GROUP || node_prev->id == &ngroup->id)) { /* keep the previous node if it's the same type */ node_from = node_prev; } else if (!node_from) { - node_from = nodeAddNode(ntree, ntemp); + node_from = nodeAddStaticNode(C, ntree, type); node_from->locx = node_to->locx - (node_from->typeinfo->width + 50); node_from->locy = node_to->locy; - + + /* XXX bad, should be dispatched to generic operator or something ... */ + if (type==NODE_GROUP) { + node_from->id = (ID*)ngroup; + } + if (node_from->id) id_us_plus(node_from->id); } @@ -209,9 +214,11 @@ static void node_socket_add_replace(Main *bmain, bNodeTree *ntree, bNode *node_t nodeRemLink(ntree, link); } - node_socket_free_default_value(sock_from->type, sock_from->default_value); - sock_from->default_value = node_socket_make_default_value(sock_from->type); - node_socket_copy_default_value(sock_from->type, sock_from->default_value, sock_prev->default_value); +#if 0 /* XXX TODO */ + node_socket_free_default_value(sock_from->typeinfo, sock_from->default_value); + sock_from->default_value = node_socket_make_default_value(sock_from->typeinfo); + node_socket_copy_default_value(sock_from->typeinfo, sock_from->default_value, sock_prev->default_value); +#endif } } } @@ -231,7 +238,7 @@ static void node_socket_add_replace(Main *bmain, bNodeTree *ntree, bNode *node_t nodeUpdate(ntree, node_to); ntreeUpdateTree(ntree); - ED_node_generic_update(bmain, ntree, node_to); + ED_node_tag_update_nodetree(CTX_data_main(C), ntree); } /****************************** Node Link Menu *******************************/ @@ -262,19 +269,13 @@ static void ui_node_link(bContext *C, void *arg_p, void *event_p) bNodeSocket *sock_to = arg->sock; bNodeTree *ntree = arg->ntree; int event = GET_INT_FROM_POINTER(event_p); - bNodeTemplate ntemp; - - ntemp.type = arg->type; - ntemp.ngroup = arg->ngroup; - ntemp.scene = CTX_data_scene(C); - ntemp.main = CTX_data_main(C); if (event == UI_NODE_LINK_DISCONNECT) node_socket_disconnect(bmain, ntree, node_to, sock_to); else if (event == UI_NODE_LINK_REMOVE) node_socket_remove(bmain, ntree, node_to, sock_to); else - node_socket_add_replace(bmain, ntree, node_to, sock_to, &ntemp, arg->output); + node_socket_add_replace(C, ntree, node_to, sock_to, arg->type, arg->ngroup, arg->output); ED_undo_push(C, "Node input modify"); } @@ -289,10 +290,10 @@ static void ui_node_sock_name(bNodeSocket *sock, char name[UI_MAX_NAME_STR]) if (node->id) BLI_strncpy(node_name, node->id->name + 2, UI_MAX_NAME_STR); else - BLI_strncpy(node_name, N_("Group"), UI_MAX_NAME_STR); + BLI_strncpy(node_name, N_(node->typeinfo->ui_name), UI_MAX_NAME_STR); } else - BLI_strncpy(node_name, node->typeinfo->name, UI_MAX_NAME_STR); + BLI_strncpy(node_name, node->typeinfo->ui_name, UI_MAX_NAME_STR); if (node->inputs.first == NULL && node->outputs.first != node->outputs.last) @@ -316,19 +317,16 @@ static int ui_compatible_sockets(int typeA, int typeB) static void ui_node_menu_column(NodeLinkArg *arg, int nclass, const char *cname) { - Main *bmain = arg->bmain; bNodeTree *ntree = arg->ntree; bNodeSocket *sock = arg->sock; uiLayout *layout = arg->layout; uiLayout *column = NULL; uiBlock *block = uiLayoutGetBlock(layout); uiBut *but; - bNodeType *ntype; - bNodeTree *ngroup; NodeLinkArg *argN; int first = 1; int compatibility = 0; - + if (ntree->type == NTREE_SHADER) { if (BKE_scene_use_new_shading_nodes(arg->scene)) compatibility = NODE_NEW_SHADING; @@ -336,114 +334,58 @@ static void ui_node_menu_column(NodeLinkArg *arg, int nclass, const char *cname) compatibility = NODE_OLD_SHADING; } - if (nclass == NODE_CLASS_GROUP) { - for (ngroup = bmain->nodetree.first; ngroup; ngroup = ngroup->id.next) { - bNodeSocket *gsock; - char name[UI_MAX_NAME_STR]; - int i, j, num = 0; - - if (ngroup->type != ntree->type) + NODE_TYPES_BEGIN(ntype) + bNodeSocketTemplate *stemp; + char name[UI_MAX_NAME_STR]; + int i, j, num = 0; + + if (compatibility && !(ntype->compatibility & compatibility)) + continue; + + if (ntype->nclass != nclass) + continue; + + for (i = 0, stemp = ntype->outputs; stemp && stemp->type != -1; stemp++, i++) + if (ui_compatible_sockets(stemp->type, sock->type)) + num++; + + for (i = 0, j = 0, stemp = ntype->outputs; stemp && stemp->type != -1; stemp++, i++) { + if (!ui_compatible_sockets(stemp->type, sock->type)) continue; - - for (gsock = ngroup->inputs.first; gsock; gsock = gsock->next) - if (ui_compatible_sockets(gsock->type, sock->type)) - num++; - - for (i = 0, j = 0, gsock = ngroup->outputs.first; gsock; gsock = gsock->next, i++) { - if (!ui_compatible_sockets(gsock->type, sock->type)) - continue; - - if (first) { - column = uiLayoutColumn(layout, FALSE); - uiBlockSetCurLayout(block, column); - - uiItemL(column, IFACE_(cname), ICON_NODE); - but = block->buttons.last; - but->flag = UI_TEXT_LEFT; - - first = 0; - } - - if (num > 1) { - if (j == 0) { - uiItemL(column, ngroup->id.name + 2, ICON_NODE); - but = block->buttons.last; - but->flag = UI_TEXT_LEFT; - } - - BLI_snprintf(name, UI_MAX_NAME_STR, " %s", gsock->name); - j++; - } - else - BLI_strncpy(name, ngroup->id.name + 2, UI_MAX_NAME_STR); - - but = uiDefBut(block, BUT, 0, ngroup->id.name + 2, 0, 0, UI_UNIT_X * 4, UI_UNIT_Y, - NULL, 0.0, 0.0, 0.0, 0.0, TIP_("Add node to input")); - - argN = MEM_dupallocN(arg); - argN->type = NODE_GROUP; - argN->ngroup = ngroup; - argN->output = i; - uiButSetNFunc(but, ui_node_link, argN, NULL); + + if (first) { + column = uiLayoutColumn(layout, 0); + uiBlockSetCurLayout(block, column); + + uiItemL(column, IFACE_(cname), ICON_NODE); + but = block->buttons.last; + but->flag = UI_TEXT_LEFT; + + first = 0; } - } - } - else { - bNodeTreeType *ttype = ntreeGetType(ntree->type); - - for (ntype = ttype->node_types.first; ntype; ntype = ntype->next) { - bNodeSocketTemplate *stemp; - char name[UI_MAX_NAME_STR]; - int i, j, num = 0; - - if (compatibility && !(ntype->compatibility & compatibility)) - continue; - - if (ntype->nclass != nclass) - continue; - - for (i = 0, stemp = ntype->outputs; stemp && stemp->type != -1; stemp++, i++) - if (ui_compatible_sockets(stemp->type, sock->type)) - num++; - - for (i = 0, j = 0, stemp = ntype->outputs; stemp && stemp->type != -1; stemp++, i++) { - if (!ui_compatible_sockets(stemp->type, sock->type)) - continue; - - if (first) { - column = uiLayoutColumn(layout, FALSE); - uiBlockSetCurLayout(block, column); - - uiItemL(column, IFACE_(cname), ICON_NODE); + + if (num > 1) { + if (j == 0) { + uiItemL(column, IFACE_(ntype->ui_name), ICON_NODE); but = block->buttons.last; but->flag = UI_TEXT_LEFT; - - first = 0; - } - - if (num > 1) { - if (j == 0) { - uiItemL(column, IFACE_(ntype->name), ICON_NODE); - but = block->buttons.last; - but->flag = UI_TEXT_LEFT; - } - - BLI_snprintf(name, UI_MAX_NAME_STR, " %s", IFACE_(stemp->name)); - j++; } - else - BLI_strncpy(name, IFACE_(ntype->name), UI_MAX_NAME_STR); - - but = uiDefBut(block, BUT, 0, name, 0, 0, UI_UNIT_X * 4, UI_UNIT_Y, - NULL, 0.0, 0.0, 0.0, 0.0, TIP_("Add node to input")); - - argN = MEM_dupallocN(arg); - argN->type = ntype->type; - argN->output = i; - uiButSetNFunc(but, ui_node_link, argN, NULL); + + BLI_snprintf(name, UI_MAX_NAME_STR, " %s", IFACE_(stemp->name)); + j++; } + else + BLI_strncpy(name, IFACE_(ntype->ui_name), UI_MAX_NAME_STR); + + but = uiDefBut(block, BUT, 0, name, 0, 0, UI_UNIT_X*4, UI_UNIT_Y, + NULL, 0.0, 0.0, 0.0, 0.0, TIP_("Add node to input")); + + argN = MEM_dupallocN(arg); + argN->type = ntype->type; + argN->output = i; + uiButSetNFunc(but, ui_node_link, argN, NULL); } - } + NODE_TYPES_END } static void node_menu_column_foreach_cb(void *calldata, int nclass, const char *name) @@ -463,7 +405,7 @@ static void ui_template_node_link_menu(bContext *C, uiLayout *layout, void *but_ uiLayout *split, *column; NodeLinkArg *arg = (NodeLinkArg *)but->func_argN; bNodeSocket *sock = arg->sock; - bNodeTreeType *ntreetype = ntreeGetType(arg->ntree->type); + bNodeTreeType *ntreetype = arg->ntree->typeinfo; uiBlockSetCurLayout(block, layout); split = uiLayoutSplit(layout, 0.0f, FALSE); @@ -557,7 +499,7 @@ static void ui_node_draw_node(uiLayout *layout, bContext *C, bNodeTree *ntree, b static void ui_node_draw_input(uiLayout *layout, bContext *C, bNodeTree *ntree, bNode *node, bNodeSocket *input, int depth) { - PointerRNA inputptr; + PointerRNA inputptr, nodeptr; uiBlock *block = uiLayoutGetBlock(layout); uiBut *bt; uiLayout *split, *row, *col; @@ -579,6 +521,7 @@ static void ui_node_draw_input(uiLayout *layout, bContext *C, bNodeTree *ntree, /* socket RNA pointer */ RNA_pointer_create(&ntree->id, &RNA_NodeSocket, input, &inputptr); + RNA_pointer_create(&ntree->id, &RNA_Node, node, &nodeptr); /* indented label */ memset(label, ' ', indent); @@ -627,16 +570,25 @@ static void ui_node_draw_input(uiLayout *layout, bContext *C, bNodeTree *ntree, } else { /* input not linked, show value */ - if (input->type != SOCK_SHADER && !(input->flag & SOCK_HIDE_VALUE)) { - if (input->type == SOCK_VECTOR) { + if (!(input->flag & SOCK_HIDE_VALUE)) { + switch (input->type) { + case SOCK_FLOAT: + case SOCK_INT: + case SOCK_BOOLEAN: + case SOCK_RGBA: + case SOCK_STRING: + row = uiLayoutRow(split, TRUE); + uiItemR(row, &inputptr, "default_value", 0, "", ICON_NONE); + break; + case SOCK_VECTOR: row = uiLayoutRow(split, FALSE); col = uiLayoutColumn(row, FALSE); - uiItemR(col, &inputptr, "default_value", 0, "", ICON_NONE); - } - else { - row = uiLayoutRow(split, TRUE); - uiItemR(row, &inputptr, "default_value", 0, "", ICON_NONE); + break; + + default: + row = uiLayoutRow(split, FALSE); + break; } } else @@ -653,7 +605,7 @@ void uiTemplateNodeView(uiLayout *layout, bContext *C, bNodeTree *ntree, bNode * { bNode *tnode; - if (!ntree) + if (!ntreeIsValid(ntree)) return; /* clear for cycle check */ diff --git a/source/blender/editors/space_node/node_view.c b/source/blender/editors/space_node/node_view.c index a2fa7d3caf6..1241227c9d8 100644 --- a/source/blender/editors/space_node/node_view.c +++ b/source/blender/editors/space_node/node_view.c @@ -61,6 +61,7 @@ #include "IMB_imbuf_types.h" #include "node_intern.h" /* own include */ +#include "NOD_composite.h" /* **************** View All Operator ************** */ @@ -370,7 +371,7 @@ int ED_space_node_color_sample(SpaceNode *snode, ARegion *ar, int mval[2], float float fx, fy, bufx, bufy; int ret = FALSE; - if (snode->treetype != NTREE_COMPOSIT || (snode->flag & SNODE_BACKDRAW) == 0) { + if (strcmp(snode->tree_idname, ntreeType_Composite->idname)==0 || (snode->flag & SNODE_BACKDRAW) == 0) { /* use viewer image for color sampling only if we're in compositor tree * with backdrop enabled */ @@ -524,7 +525,7 @@ static int sample_invoke(bContext *C, wmOperator *op, const wmEvent *event) ARegion *ar = CTX_wm_region(C); ImageSampleInfo *info; - if (snode->treetype != NTREE_COMPOSIT || !(snode->flag & SNODE_BACKDRAW)) + if (!ED_node_is_compositor(snode) || !(snode->flag & SNODE_BACKDRAW)) return OPERATOR_CANCELLED; info = MEM_callocN(sizeof(ImageSampleInfo), "ImageSampleInfo"); diff --git a/source/blender/editors/space_node/space_node.c b/source/blender/editors/space_node/space_node.c index 75f28baf558..ac2f36ed51d 100644 --- a/source/blender/editors/space_node/space_node.c +++ b/source/blender/editors/space_node/space_node.c @@ -45,10 +45,10 @@ #include "BKE_node.h" #include "ED_space_api.h" +#include "ED_node.h" #include "ED_render.h" #include "ED_screen.h" #include "ED_node.h" - #include "WM_api.h" #include "WM_types.h" @@ -59,6 +59,168 @@ #include "node_intern.h" /* own include */ + +/* ******************** tree path ********************* */ + +void ED_node_tree_start(SpaceNode *snode, bNodeTree *ntree, ID *id, ID *from) +{ + bNodeTreePath *path, *path_next; + for (path=snode->treepath.first; path; path=path_next) { + path_next = path->next; + MEM_freeN(path); + } + snode->treepath.first = snode->treepath.last = NULL; + + if (ntree) { + path = MEM_callocN(sizeof(bNodeTreePath), "node tree path"); + path->nodetree = ntree; + path->parent_key = NODE_INSTANCE_KEY_BASE; + if (id) + BLI_strncpy(path->node_name, id->name+2, sizeof(path->node_name)); + BLI_addtail(&snode->treepath, path); + } + + /* update current tree */ + snode->nodetree = snode->edittree = ntree; + snode->id = id; + snode->from = from; + + /* listener updates the View2D center from edittree */ + WM_main_add_notifier(NC_SCENE|ND_NODES, NULL); +} + +void ED_node_tree_push(SpaceNode *snode, bNodeTree *ntree, bNode *gnode) +{ + bNodeTreePath *path = MEM_callocN(sizeof(bNodeTreePath), "node tree path"); + bNodeTreePath *prev_path = snode->treepath.last; + path->nodetree = ntree; + if (gnode) { + if (prev_path) + path->parent_key = BKE_node_instance_key(prev_path->parent_key, prev_path->nodetree, gnode); + else + path->parent_key = NODE_INSTANCE_KEY_BASE; + + BLI_strncpy(path->node_name, gnode->name, sizeof(path->node_name)); + } + else + path->parent_key = NODE_INSTANCE_KEY_BASE; + + BLI_addtail(&snode->treepath, path); + + /* update current tree */ + snode->edittree = ntree; + + /* listener updates the View2D center from edittree */ + WM_main_add_notifier(NC_SCENE|ND_NODES, NULL); +} + +void ED_node_tree_pop(SpaceNode *snode) +{ + bNodeTreePath *path = snode->treepath.last; + + /* don't remove root */ + if (path == snode->treepath.first) + return; + + BLI_remlink(&snode->treepath, path); + MEM_freeN(path); + + /* update current tree */ + path = snode->treepath.last; + snode->edittree = path->nodetree; + + /* listener updates the View2D center from edittree */ + WM_main_add_notifier(NC_SCENE|ND_NODES, NULL); +} + +int ED_node_tree_depth(SpaceNode *snode) +{ + return BLI_countlist(&snode->treepath); +} + +bNodeTree *ED_node_tree_get(SpaceNode *snode, int level) +{ + bNodeTreePath *path; + int i; + for (path = snode->treepath.last, i = 0; path; path=path->prev, ++i) { + if (i == level) + return path->nodetree; + } + return NULL; +} + +int ED_node_tree_path_length(SpaceNode *snode) +{ + bNodeTreePath *path; + int length = 0; + int i; + for (path=snode->treepath.first, i=0; path; path=path->next, ++i) { + length += strlen(path->node_name); + if (i > 0) + length += 1; /* for separator char */ + } + return length; +} + +void ED_node_tree_path_get(SpaceNode *snode, char *value) +{ + bNodeTreePath *path; + int i; + + value[0] = '\0'; + for (path=snode->treepath.first, i=0; path; path=path->next, ++i) { + if (i == 0) { + strcpy(value, path->node_name); + value += strlen(path->node_name); + } + else { + sprintf(value, "/%s", path->node_name); + value += strlen(path->node_name) + 1; + } + } +} + +void ED_node_tree_path_get_fixedbuf(SpaceNode *snode, char *value, int max_length) +{ + bNodeTreePath *path; + int size, i; + + value[0] = '\0'; + for (path=snode->treepath.first, i=0; path; path=path->next, ++i) { + if (i == 0) { + BLI_strncpy(value, path->node_name, max_length); + size = strlen(path->node_name); + } + else { + BLI_snprintf(value, max_length, "/%s", path->node_name); + size = strlen(path->node_name) + 1; + } + max_length -= size; + if (max_length <= 0) + break; + value += size; + } +} + +void snode_group_offset(SpaceNode *snode, float *x, float *y) +{ + bNodeTreePath *path = snode->treepath.last; + float cx, cy; + + if (path) { + cx = path->nodetree->view_center[0]; + cy = path->nodetree->view_center[1]; + + if (path->prev) { + *x = cx - path->prev->nodetree->view_center[0]; + *y = cy - path->prev->nodetree->view_center[1]; + return; + } + } + + *x = *y = 0.0f; +} + /* ******************** manage regions ********************* */ ARegion *node_has_buttons_region(ScrArea *sa) @@ -124,6 +286,12 @@ static SpaceLink *node_new(const bContext *UNUSED(C)) /* backdrop */ snode->zoom = 1.0f; + /* select the first tree type for valid type */ + NODE_TREE_TYPES_BEGIN(treetype) + strcpy(snode->tree_idname, treetype->idname); + break; + NODE_TREE_TYPES_END + /* header */ ar = MEM_callocN(sizeof(ARegion), "header for node"); @@ -167,10 +335,15 @@ static SpaceLink *node_new(const bContext *UNUSED(C)) return (SpaceLink *)snode; } -/* not spacelink itself */ -static void node_free(SpaceLink *UNUSED(sl)) +static void node_free(SpaceLink *sl) { + SpaceNode *snode = (SpaceNode*)sl; + bNodeTreePath *path, *path_next; + for (path=snode->treepath.first; path; path=path_next) { + path_next = path->next; + MEM_freeN(path); + } } @@ -184,14 +357,21 @@ static void node_area_listener(ScrArea *sa, wmNotifier *wmn) { /* note, ED_area_tag_refresh will re-execute compositor */ SpaceNode *snode = sa->spacedata.first; - int type = snode->treetype; short shader_type = snode->shaderfrom; /* preview renders */ switch (wmn->category) { case NC_SCENE: switch (wmn->data) { - case ND_NODES: + case ND_NODES: { + ARegion *ar = BKE_area_find_region_type(sa, RGN_TYPE_WINDOW); + /* shift view to node tree center */ + if (ar && snode->edittree) + UI_view2d_setcenter(&ar->v2d, snode->edittree->view_center[0], snode->edittree->view_center[1]); + + ED_area_tag_refresh(sa); + break; + } case ND_FRAME: ED_area_tag_refresh(sa); break; @@ -199,7 +379,7 @@ static void node_area_listener(ScrArea *sa, wmNotifier *wmn) ED_area_tag_redraw(sa); break; case ND_TRANSFORM_DONE: - if (type == NTREE_COMPOSIT) { + if (ED_node_is_compositor(snode)) { if (snode->flag & SNODE_AUTO_RENDER) { snode->recalc = 1; ED_area_tag_refresh(sa); @@ -211,7 +391,7 @@ static void node_area_listener(ScrArea *sa, wmNotifier *wmn) /* future: add ID checks? */ case NC_MATERIAL: - if (type == NTREE_SHADER) { + if (ED_node_is_shader(snode)) { if (wmn->data == ND_SHADING) ED_area_tag_refresh(sa); else if (wmn->data == ND_SHADING_DRAW) @@ -224,18 +404,18 @@ static void node_area_listener(ScrArea *sa, wmNotifier *wmn) } break; case NC_TEXTURE: - if (type == NTREE_SHADER || type == NTREE_TEXTURE) { + if (ED_node_is_shader(snode) || ED_node_is_texture(snode)) { if (wmn->data == ND_NODES) ED_area_tag_refresh(sa); } break; case NC_WORLD: - if (type == NTREE_SHADER && shader_type == SNODE_SHADER_WORLD) { + if (ED_node_is_shader(snode) && shader_type == SNODE_SHADER_WORLD) { ED_area_tag_refresh(sa); } break; case NC_OBJECT: - if (type == NTREE_SHADER) { + if (ED_node_is_shader(snode)) { if (wmn->data == ND_OB_SHADING) ED_area_tag_refresh(sa); } @@ -261,7 +441,7 @@ static void node_area_listener(ScrArea *sa, wmNotifier *wmn) break; case NC_MASK: if (wmn->action == NA_EDITED) { - if (type == NTREE_COMPOSIT) { + if (snode->nodetree && snode->nodetree->type == NTREE_COMPOSIT) { ED_area_tag_refresh(sa); } } @@ -269,7 +449,7 @@ static void node_area_listener(ScrArea *sa, wmNotifier *wmn) case NC_IMAGE: if (wmn->action == NA_EDITED) { - if (type == NTREE_COMPOSIT) { + if (ED_node_is_compositor(snode)) { /* note that nodeUpdateID is already called by BKE_image_signal() on all * scenes so really this is just to know if the images is used in the compo else * painting on images could become very slow when the compositor is open. */ @@ -281,7 +461,7 @@ static void node_area_listener(ScrArea *sa, wmNotifier *wmn) case NC_MOVIECLIP: if (wmn->action == NA_EDITED) { - if (type == NTREE_COMPOSIT) { + if (ED_node_is_compositor(snode)) { if (nodeUpdateID(snode->nodetree, wmn->reference)) ED_area_tag_refresh(sa); } @@ -294,11 +474,13 @@ static void node_area_refresh(const struct bContext *C, ScrArea *sa) { /* default now: refresh node is starting preview */ SpaceNode *snode = sa->spacedata.first; + + ED_preview_kill_jobs(C); + + snode_set_context(C); - snode_set_context(snode, CTX_data_scene(C)); - - if (snode->nodetree) { - if (snode->treetype == NTREE_SHADER) { + if (ntreeIsValid(snode->nodetree)) { + if (snode->nodetree->type == NTREE_SHADER) { if (GS(snode->id->name) == ID_MA) { Material *ma = (Material *)snode->id; if (ma->use_nodes) @@ -315,7 +497,7 @@ static void node_area_refresh(const struct bContext *C, ScrArea *sa) ED_preview_shader_job(C, sa, snode->id, NULL, NULL, 100, 100, PR_NODE_RENDER); } } - else if (snode->treetype == NTREE_COMPOSIT) { + else if (snode->nodetree->type == NTREE_COMPOSIT) { Scene *scene = (Scene *)snode->id; if (scene->use_nodes) { /* recalc is set on 3d view changes for auto compo */ @@ -328,7 +510,7 @@ static void node_area_refresh(const struct bContext *C, ScrArea *sa) } } } - else if (snode->treetype == NTREE_TEXTURE) { + else if (snode->nodetree->type == NTREE_TEXTURE) { Tex *tex = (Tex *)snode->id; if (tex->use_nodes) { ED_preview_shader_job(C, sa, snode->id, NULL, NULL, 100, 100, PR_NODE_RENDER); @@ -339,11 +521,14 @@ static void node_area_refresh(const struct bContext *C, ScrArea *sa) static SpaceLink *node_duplicate(SpaceLink *sl) { - SpaceNode *snoden = MEM_dupallocN(sl); + SpaceNode *snode = (SpaceNode*)sl; + SpaceNode *snoden = MEM_dupallocN(snode); /* clear or remove stuff from old */ snoden->nodetree = NULL; snoden->linkdrag.first = snoden->linkdrag.last = NULL; + + BLI_duplicatelist(&snoden->treepath, &snode->treepath); return (SpaceLink *)snoden; } @@ -415,9 +600,7 @@ static void node_main_area_init(wmWindowManager *wm, ARegion *ar) static void node_main_area_draw(const bContext *C, ARegion *ar) { - View2D *v2d = &ar->v2d; - - drawnodespace(C, ar, v2d); + drawnodespace(C, ar); } @@ -469,11 +652,8 @@ static void node_header_area_init(wmWindowManager *UNUSED(wm), ARegion *ar) static void node_header_area_draw(const bContext *C, ARegion *ar) { - SpaceNode *snode = CTX_wm_space_node(C); - Scene *scene = CTX_data_scene(C); - /* find and set the context */ - snode_set_context(snode, scene); + snode_set_context(C); ED_region_header(C, ar); } @@ -549,6 +729,14 @@ static int node_context(const bContext *C, const char *member, bContextDataResul CTX_data_type_set(result, CTX_DATA_TYPE_POINTER); return 1; } + else if (CTX_data_equals(member, "node_previews")) { + if (snode->nodetree) { + CTX_data_pointer_set(result, &snode->nodetree->id, &RNA_NodeInstanceHash, snode->nodetree->previews); + } + + CTX_data_type_set(result, CTX_DATA_TYPE_POINTER); + return 1; + } return 0; } diff --git a/source/blender/editors/uvedit/uvedit_ops.c b/source/blender/editors/uvedit/uvedit_ops.c index 85375bcaf83..6ea37644533 100644 --- a/source/blender/editors/uvedit/uvedit_ops.c +++ b/source/blender/editors/uvedit/uvedit_ops.c @@ -159,7 +159,7 @@ void ED_object_assign_active_image(Main *bmain, Object *ob, int mat_nr, Image *i if (node && is_image_texture_node(node)) { node->id = &ima->id; - ED_node_generic_update(bmain, ma->nodetree, node); + ED_node_tag_update_nodetree(bmain, ma->nodetree); } } diff --git a/source/blender/makesdna/DNA_node_types.h b/source/blender/makesdna/DNA_node_types.h index 2e24b6ed78d..5ccdd5c6ac2 100644 --- a/source/blender/makesdna/DNA_node_types.h +++ b/source/blender/makesdna/DNA_node_types.h @@ -44,11 +44,19 @@ struct SpaceNode; struct bNodeLink; struct bNodeType; struct bNodeTreeExec; +struct bNodePreview; +struct bNodeInstanceHash; struct AnimData; struct bGPdata; struct uiBlock; struct Image; +/* In writefile.c: write deprecated DNA data, + * to ensure forward compatibility in 2.6x versions. + * Will be removed eventually. + */ +#define USE_NODE_COMPAT_CUSTOMNODES + #define NODE_MAXSTR 64 typedef struct bNodeStack { @@ -79,13 +87,22 @@ typedef struct bNodeStack { typedef struct bNodeSocket { struct bNodeSocket *next, *prev, *new_sock; + IDProperty *prop; /* user-defined properties */ + + char identifier[64]; /* unique identifier for mapping */ + char name[64]; /* MAX_NAME */ + /* XXX deprecated, only used for the Image and OutputFile nodes, + * should be removed at some point. + */ void *storage; /* custom storage */ short type, flag; short limit; /* max. number of links */ - short pad1; + short in_out; /* input/output type */ + struct bNodeSocketType *typeinfo; /* runtime type information */ + char idname[64]; /* runtime type identifier */ float locx, locy; @@ -98,11 +115,14 @@ typedef struct bNodeSocket { int resizemode; /* compositor resize mode of the socket */ void *cache; /* cached data from execution */ - /* internal data to retrieve relations and groups */ - int own_index; /* group socket identifiers, to find matching pairs after reading files */ + /* internal data to retrieve relations and groups + * DEPRECATED, now uses the generic identifier string instead + */ + int own_index DNA_DEPRECATED; /* group socket identifiers, to find matching pairs after reading files */ /* XXX deprecated, only used for restoring old group node links */ int to_index DNA_DEPRECATED; - struct bNodeSocket *groupsock; + /* XXX deprecated, still forward compatible since verification restores pointer from matching own_index. */ + struct bNodeSocket *groupsock DNA_DEPRECATED; struct bNodeLink *link; /* a link pointer, set in ntreeUpdateTree */ @@ -111,31 +131,34 @@ typedef struct bNodeSocket { } bNodeSocket; /* sock->type */ +#define SOCK_CUSTOM -1 /* socket has no integer type */ #define SOCK_FLOAT 0 #define SOCK_VECTOR 1 #define SOCK_RGBA 2 #define SOCK_SHADER 3 #define SOCK_BOOLEAN 4 -#define SOCK_MESH 5 +#define __SOCK_MESH 5 /* deprecated */ #define SOCK_INT 6 #define SOCK_STRING 7 #define NUM_SOCKET_TYPES 8 /* must be last! */ /* socket side (input/output) */ -#define SOCK_IN 1 -#define SOCK_OUT 2 +typedef enum eNodeSocketInOut { + SOCK_IN = 1, + SOCK_OUT = 2 +} eNodeSocketInOut; /* sock->flag, first bit is select */ /* hidden is user defined, to hide unused */ #define SOCK_HIDDEN 2 /* for quick check if socket is linked */ -#define SOCK_IN_USE 4 /* XXX deprecated */ +#define SOCK_IN_USE 4 /* unavailable is for dynamic sockets */ #define SOCK_UNAVAIL 8 - /* dynamic socket (can be modified by user) */ -#define SOCK_DYNAMIC 16 - /* group socket should not be exposed */ -#define SOCK_INTERNAL 32 + /* DEPRECATED dynamic socket (can be modified by user) */ +#define __SOCK_DYNAMIC 16 + /* DEPRECATED group socket should not be exposed */ +#define __SOCK_INTERNAL 32 /* socket collapsed in UI */ #define SOCK_COLLAPSED 64 /* hide socket value, if it gets auto default */ @@ -144,19 +167,18 @@ typedef struct bNodeSocket { /* DEPRECATED, only kept here to avoid reusing the flag */ #define SOCK_AUTO_HIDDEN__DEPRECATED 256 -typedef struct bNodePreview { - unsigned char *rect; - short xsize, ysize; - int pad; -} bNodePreview; - /* limit data in bNode to what we want to see saved? */ typedef struct bNode { struct bNode *next, *prev, *new_node; + + IDProperty *prop; /* user-defined properties */ + + struct bNodeType *typeinfo; /* runtime type information */ + char idname[64]; /* runtime type identifier */ char name[64]; /* MAX_NAME */ int flag; - short type, pad2; + short type, pad; short done, level; /* both for dependency and sorting */ short lasty, menunr; /* lasty: check preview render status, menunr: browse ID blocks */ short stack_index; /* for groupnode, offset in global caller stack */ @@ -186,10 +208,17 @@ typedef struct bNode { rctf totr; /* entire boundbox (worldspace) */ rctf butr; /* optional buttons area */ rctf prvr; /* optional preview area */ - bNodePreview *preview; /* optional preview image */ + /* XXX TODO + * Node totr size depends on the prvr size, which in turn is determined from preview size. + * In earlier versions bNodePreview was stored directly in nodes, but since now there can be + * multiple instances using different preview images it is possible that required node size varies between instances. + * preview_xsize, preview_ysize defines a common reserved size for preview rect for now, + * could be replaced by more accurate node instance drawing, but that requires removing totr from DNA + * and replacing all uses with per-instance data. + */ + short preview_xsize, preview_ysize; /* reserved size of the preview rect */ + int pad2; struct uiBlock *block; /* runtime during drawing */ - - struct bNodeType *typeinfo; /* lookup of callbacks and defaults */ } bNode; /* node->flag */ @@ -200,7 +229,7 @@ typedef struct bNode { #define NODE_ACTIVE 16 #define NODE_ACTIVE_ID 32 #define NODE_DO_OUTPUT 64 -#define NODE_GROUP_EDIT 128 +#define __NODE_GROUP_EDIT 128 /* DEPRECATED */ /* free test flag, undefined */ #define NODE_TEST 256 /* node is disabled */ @@ -221,6 +250,12 @@ typedef struct bNode { #define NODE_ACTIVE_TEXTURE (1<<14) /* use a custom color for the node */ #define NODE_CUSTOM_COLOR (1<<15) + /* Node has been initialized + * This flag indicates the node->typeinfo->init function has been called. + * In case of undefined type at creation time this can be delayed until + * until the node type is registered. + */ +#define NODE_INIT (1<<16) /* node->update */ /* XXX NODE_UPDATE is a generic update flag. More fine-grained updates @@ -229,6 +264,36 @@ typedef struct bNode { #define NODE_UPDATE 0xFFFF /* generic update flag (includes all others) */ #define NODE_UPDATE_ID 1 /* associated id data block has changed */ +/* Unique hash key for identifying node instances + * Defined as a struct because DNA does not support other typedefs. + */ +typedef struct bNodeInstanceKey +{ + unsigned int value; +} bNodeInstanceKey; + +/* Base struct for entries in node instance hash. + * WARNING: pointers are cast to this struct internally, + * it must be first member in hash entry structs! + */ +typedef struct bNodeInstanceHashEntry { + bNodeInstanceKey key; + + /* tags for cleaning the cache */ + short tag; + short pad; +} bNodeInstanceHashEntry; + + +typedef struct bNodePreview { + bNodeInstanceHashEntry hash_entry; /* must be first */ + + unsigned char *rect; + short xsize, ysize; + int pad; +} bNodePreview; + + typedef struct bNodeLink { struct bNodeLink *next, *prev; @@ -263,7 +328,13 @@ typedef struct bNodeTree { ID id; struct AnimData *adt; /* animation data (must be immediately after id for utilities to use it) */ + struct bNodeTreeType *typeinfo; /* runtime type information */ + char idname[64]; /* runtime type identifier */ + + struct StructRNA *interface_type; /* runtime RNA type of the group interface */ + struct bGPdata *gpd; /* grease pencil data */ + float view_center[2]; /* node tree stores own offset for consistent editor view */ ListBase nodes, links; @@ -272,8 +343,11 @@ typedef struct bNodeTree { * will increase this counter */ int flag; int update; /* update flags */ + short is_updating; /* flag to prevent reentrant update calls */ + short done; /* generic temporary flag for recursion check (DFS/BFS) */ + int pad2; - int nodetype; /* specific node type this tree is used for */ + int nodetype DNA_DEPRECATED; /* specific node type this tree is used for */ short edit_quality; /* Quality setting when editing */ short render_quality; /* Quality setting when rendering */ @@ -281,7 +355,16 @@ typedef struct bNodeTree { rctf viewer_border; - ListBase inputs, outputs; /* external sockets for group nodes */ + /* 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; /* execution data */ /* XXX It would be preferable to completely move this data out of the underlying node tree, @@ -302,10 +385,10 @@ typedef struct bNodeTree { } bNodeTree; /* ntree->type, index */ +#define NTREE_CUSTOM -1 /* for dynamically registered custom types */ #define NTREE_SHADER 0 #define NTREE_COMPOSIT 1 #define NTREE_TEXTURE 2 -#define NUM_NTREE_TYPES 3 /* ntree->init, flag */ #define NTREE_TYPE_INIT 1 @@ -320,18 +403,24 @@ typedef struct bNodeTree { /* XXX not nice, but needed as a temporary flags * for group updates after library linking. */ -#define NTREE_DO_VERSIONS_GROUP_EXPOSE 1024 +#define NTREE_DO_VERSIONS_GROUP_EXPOSE_2_56_2 1024 /* changes from r35033 */ +#define NTREE_DO_VERSIONS_CUSTOMNODES_GROUP 2048 /* custom_nodes branch: remove links to node tree sockets */ +#define NTREE_DO_VERSIONS_CUSTOMNODES_GROUP_CREATE_INTERFACE 4096 /* custom_nodes branch: create group input/output nodes */ /* ntree->update */ -#define NTREE_UPDATE 0xFFFF /* generic update flag (includes all others) */ -#define NTREE_UPDATE_LINKS 1 /* links have been added or removed */ -#define NTREE_UPDATE_NODES 2 /* nodes or sockets have been added or removed */ -#define NTREE_UPDATE_GROUP_IN 16 /* group inputs have changed */ -#define NTREE_UPDATE_GROUP_OUT 32 /* group outputs have changed */ -#define NTREE_UPDATE_GROUP 48 /* group has changed (generic flag including all other group flags) */ - - -/* socket value structs for input buttons */ +typedef enum eNodeTreeUpdate { + NTREE_UPDATE = 0xFFFF, /* generic update flag (includes all others) */ + NTREE_UPDATE_LINKS = 1, /* links have been added or removed */ + NTREE_UPDATE_NODES = 2, /* nodes or sockets have been added or removed */ + NTREE_UPDATE_GROUP_IN = 16, /* group inputs have changed */ + NTREE_UPDATE_GROUP_OUT = 32, /* group outputs have changed */ + NTREE_UPDATE_GROUP = 48 /* group has changed (generic flag including all other group flags) */ +} eNodeTreeUpdate; + + +/* socket value structs for input buttons + * DEPRECATED now using ID properties + */ typedef struct bNodeSocketValueInt { int subtype; /* RNA subtype */ @@ -731,8 +820,6 @@ typedef struct NodeShaderScript { char bytecode_hash[64]; char *bytecode; - - IDProperty *prop; } NodeShaderScript; typedef struct NodeShaderTangent { @@ -758,6 +845,9 @@ typedef struct NodeShaderNormalMap { #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 @@ -857,6 +947,39 @@ typedef struct NodeShaderNormalMap { #define CMP_NODE_MASK_MBLUR_SAMPLES_MAX 64 +/* geometry output socket defines */ +#define GEOM_OUT_GLOB 0 +#define GEOM_OUT_LOCAL 1 +#define GEOM_OUT_VIEW 2 +#define GEOM_OUT_ORCO 3 +#define GEOM_OUT_UV 4 +#define GEOM_OUT_NORMAL 5 +#define GEOM_OUT_VCOL 6 +#define GEOM_OUT_VCOL_ALPHA 7 +#define GEOM_OUT_FRONTBACK 8 + +/* material input socket defines */ +#define MAT_IN_COLOR 0 +#define MAT_IN_SPEC 1 +#define MAT_IN_REFL 2 +#define MAT_IN_NORMAL 3 +#define MAT_IN_MIR 4 +#define MAT_IN_AMB 5 +#define MAT_IN_EMIT 6 +#define MAT_IN_SPECTRA 7 +#define MAT_IN_RAY_MIRROR 8 +#define MAT_IN_ALPHA 9 +#define MAT_IN_TRANSLUCENCY 10 +#define NUM_MAT_IN 11 /* for array size */ + +/* material output socket defines */ +#define MAT_OUT_COLOR 0 +#define MAT_OUT_ALPHA 1 +#define MAT_OUT_NORMAL 2 +#define MAT_OUT_DIFFUSE 3 +#define MAT_OUT_SPEC 4 +#define MAT_OUT_AO 5 + /* image */ #define CMP_NODE_IMAGE_USE_STRAIGHT_OUTPUT 1 diff --git a/source/blender/makesdna/DNA_space_types.h b/source/blender/makesdna/DNA_space_types.h index 0873c2278c5..a810f4219e0 100644 --- a/source/blender/makesdna/DNA_space_types.h +++ b/source/blender/makesdna/DNA_space_types.h @@ -43,6 +43,7 @@ #include "DNA_image_types.h" /* ImageUser */ #include "DNA_movieclip_types.h" /* MovieClipUser */ #include "DNA_sequence_types.h" /* SequencerScopes */ +#include "DNA_node_types.h" /* for bNodeInstanceKey */ /* Hum ... Not really nice... but needed for spacebuts. */ #include "DNA_view2d_types.h" @@ -880,6 +881,17 @@ typedef struct SpaceScript { /* Nodes Editor =========================================== */ /* Node Editor */ + +typedef struct bNodeTreePath { + struct bNodeTreePath *next, *prev; + + struct bNodeTree *nodetree; + bNodeInstanceKey parent_key; /* base key for nodes in this tree instance */ + int pad; + /* XXX this is not automatically updated when node names are changed! */ + char node_name[64]; /* MAX_NAME */ +} bNodeTreePath; + typedef struct SpaceNode { SpaceLink *next, *prev; ListBase regionbase; /* storage of regions for inactive spaces */ @@ -897,12 +909,24 @@ typedef struct SpaceNode { float zoom; /* zoom for backdrop */ float cursor[2]; /* mouse pos for drawing socketless link and adding nodes */ + /* XXX nodetree pointer info is all in the path stack now, + * remove later on and use bNodeTreePath instead. For now these variables are set when pushing/popping + * from path stack, to avoid having to update all the functions and operators. Can be done when + * design is accepted and everything is properly tested. + */ + ListBase treepath; + struct bNodeTree *nodetree, *edittree; - int treetype; /* treetype: as same nodetree->type */ + + /* tree type for the current node tree */ + char tree_idname[64]; + int treetype DNA_DEPRECATED; /* treetype: as same nodetree->type */ + int pad3; + short texfrom; /* texfrom object, world or brush */ short shaderfrom; /* shader from object or world */ short recalc; /* currently on 0/1, for auto compo */ - short pad[3]; + short pad4; ListBase linkdrag; /* temporary data for modal linking operator */ struct bGPdata *gpd; /* grease-pencil data */ @@ -921,6 +945,7 @@ typedef enum eSpaceNode_Flag { SNODE_SHOW_HIGHLIGHT = (1 << 6), SNODE_USE_HIDDEN_PREVIEW = (1 << 10), SNODE_NEW_SHADERS = (1 << 11), + SNODE_PIN = (1 << 12), } eSpaceNode_Flag; /* snode->texfrom */ diff --git a/source/blender/makesrna/RNA_access.h b/source/blender/makesrna/RNA_access.h index cde104710df..efa6f37648a 100644 --- a/source/blender/makesrna/RNA_access.h +++ b/source/blender/makesrna/RNA_access.h @@ -363,14 +363,13 @@ extern StructRNA RNA_NearSensor; extern StructRNA RNA_NlaStrip; extern StructRNA RNA_NlaTrack; extern StructRNA RNA_Node; -extern StructRNA RNA_NodeForLoop; -extern StructRNA RNA_NodeGroup; extern StructRNA RNA_NodeOutputFileSlotFile; extern StructRNA RNA_NodeOutputFileSlotLayer; +extern StructRNA RNA_NodeInstanceHash; extern StructRNA RNA_NodeLink; extern StructRNA RNA_NodeSocket; +extern StructRNA RNA_NodeSocketInterface; extern StructRNA RNA_NodeTree; -extern StructRNA RNA_NodeWhileLoop; extern StructRNA RNA_NoiseTexture; extern StructRNA RNA_NorController; extern StructRNA RNA_Object; @@ -655,7 +654,9 @@ StructRNA *RNA_struct_find(const char *identifier); const char *RNA_struct_identifier(StructRNA *type); const char *RNA_struct_ui_name(StructRNA *type); +const char *RNA_struct_ui_name_raw(StructRNA *type); const char *RNA_struct_ui_description(StructRNA *type); +const char *RNA_struct_ui_description_raw(StructRNA *type); const char *RNA_struct_translation_context(StructRNA *type); int RNA_struct_ui_icon(StructRNA *type); @@ -721,7 +722,9 @@ int RNA_property_array_item_index(PropertyRNA *prop, char name); int RNA_property_string_maxlength(PropertyRNA *prop); const char *RNA_property_ui_name(PropertyRNA *prop); +const char *RNA_property_ui_name_raw(PropertyRNA *prop); const char *RNA_property_ui_description(PropertyRNA *prop); +const char *RNA_property_ui_description_raw(PropertyRNA *prop); const char *RNA_property_translation_context(PropertyRNA *prop); int RNA_property_ui_icon(PropertyRNA *prop); @@ -976,9 +979,11 @@ void RNA_collection_clear(PointerRNA *ptr, const char *name); /* check if the idproperty exists, for operators */ bool RNA_property_is_set_ex(PointerRNA *ptr, PropertyRNA *prop, bool use_ghost); bool RNA_property_is_set(PointerRNA *ptr, PropertyRNA *prop); +void RNA_property_unset(PointerRNA *ptr, PropertyRNA *prop); bool RNA_struct_property_is_set_ex(PointerRNA *ptr, const char *identifier, bool use_ghost); bool RNA_struct_property_is_set(PointerRNA *ptr, const char *identifier); bool RNA_property_is_idprop(PropertyRNA *prop); +void RNA_struct_property_unset(PointerRNA *ptr, const char *identifier); /* python compatible string representation of this property, (must be freed!) */ char *RNA_property_as_string(struct bContext *C, PointerRNA *ptr, PropertyRNA *prop, int index); @@ -995,6 +1000,7 @@ char *RNA_function_as_string_keywords(struct bContext *C, FunctionRNA *func, Poi const char *RNA_function_identifier(FunctionRNA *func); const char *RNA_function_ui_description(FunctionRNA *func); +const char *RNA_function_ui_description_raw(FunctionRNA *func); int RNA_function_flag(FunctionRNA *func); int RNA_function_defined(FunctionRNA *func); diff --git a/source/blender/makesrna/RNA_define.h b/source/blender/makesrna/RNA_define.h index 5ab37c6d97b..924fc505fda 100644 --- a/source/blender/makesrna/RNA_define.h +++ b/source/blender/makesrna/RNA_define.h @@ -223,6 +223,8 @@ const char *RNA_property_typename(PropertyType type); #define IS_DNATYPE_FLOAT_COMPAT(_str) (strcmp(_str, "float") == 0 || strcmp(_str, "double") == 0) #define IS_DNATYPE_INT_COMPAT(_str) (strcmp(_str, "int") == 0 || strcmp(_str, "short") == 0 || strcmp(_str, "char") == 0) +void RNA_identifier_sanitize(char *identifier, int property); + /* max size for dynamic defined type descriptors, * this value is arbitrary */ #define RNA_DYN_DESCR_MAX 240 diff --git a/source/blender/makesrna/RNA_enum_types.h b/source/blender/makesrna/RNA_enum_types.h index eabf0391c01..2719ae889d4 100644 --- a/source/blender/makesrna/RNA_enum_types.h +++ b/source/blender/makesrna/RNA_enum_types.h @@ -29,6 +29,10 @@ #include "RNA_types.h" +struct bNodeTreeType; +struct bNodeType; +struct bNodeSocketType; + /* Types */ extern EnumPropertyItem id_type_items[]; @@ -128,8 +132,23 @@ extern EnumPropertyItem gameproperty_type_items[]; extern EnumPropertyItem viewport_shade_items[]; -extern EnumPropertyItem nodetree_type_items[]; -extern EnumPropertyItem node_socket_type_items[]; +int rna_node_tree_type_to_enum(struct bNodeTreeType *typeinfo); +int rna_node_tree_idname_to_enum(const char *idname); +struct bNodeTreeType *rna_node_tree_type_from_enum(int value); +EnumPropertyItem *rna_node_tree_type_itemf(void *data, int (*poll)(void *data, struct bNodeTreeType *), int *free); + +int rna_node_type_to_enum(struct bNodeType *typeinfo); +int rna_node_idname_to_enum(const char *idname); +struct bNodeType *rna_node_type_from_enum(int value); +EnumPropertyItem *rna_node_type_itemf(void *data, int (*poll)(void *data, struct bNodeType*), int *free); + +int rna_node_socket_type_to_enum(struct bNodeSocketType *typeinfo); +int rna_node_socket_idname_to_enum(const char *idname); +struct bNodeSocketType *rna_node_socket_type_from_enum(int value); +EnumPropertyItem *rna_node_socket_type_itemf(void *data, int (*poll)(void *data, struct bNodeSocketType*), int *free); + +extern EnumPropertyItem node_socket_in_out_items[]; +extern EnumPropertyItem node_icon_items[]; extern EnumPropertyItem node_math_items[]; extern EnumPropertyItem node_vec_math_items[]; diff --git a/source/blender/makesrna/intern/CMakeLists.txt b/source/blender/makesrna/intern/CMakeLists.txt index 7621ebb70b3..a0ee5e05390 100644 --- a/source/blender/makesrna/intern/CMakeLists.txt +++ b/source/blender/makesrna/intern/CMakeLists.txt @@ -259,6 +259,7 @@ blender_include_dirs( ../../imbuf ../../ikplugin ../../makesdna + ../../nodes/ ../../windowmanager ../../editors/include ../../render/extern/include @@ -296,7 +297,6 @@ set(SRC ${SRC_RNA_INC} rna_internal.h rna_internal_types.h - rna_nodetree_types.h rna_mesh_utils.h ) diff --git a/source/blender/makesrna/intern/rna_access.c b/source/blender/makesrna/intern/rna_access.c index f3efbd0d53e..92ce8122597 100644 --- a/source/blender/makesrna/intern/rna_access.c +++ b/source/blender/makesrna/intern/rna_access.c @@ -282,6 +282,20 @@ static IDProperty *rna_idproperty_find(PointerRNA *ptr, const char *name) return NULL; } +static void rna_idproperty_free(PointerRNA *ptr, const char *name) +{ + IDProperty *group = RNA_struct_idprops(ptr, 0); + + if (group) { + IDProperty *idprop = IDP_GetPropertyFromGroup(group, name); + if (idprop) { + IDP_RemFromGroup(group, idprop); + IDP_FreeProperty(idprop); + MEM_freeN(idprop); + } + } +} + static int rna_ensure_property_array_length(PointerRNA *ptr, PropertyRNA *prop) { if (prop->magic == RNA_MAGIC) { @@ -477,7 +491,7 @@ static const char *rna_ensure_property_description(PropertyRNA *prop) description = ((IDProperty *)prop)->name; /* XXX - not correct */ } - return TIP_(description); + return description; } static const char *rna_ensure_property_name(PropertyRNA *prop) @@ -489,7 +503,7 @@ static const char *rna_ensure_property_name(PropertyRNA *prop) else name = ((IDProperty *)prop)->name; - return CTX_IFACE_(prop->translation_context, name); + return name; } /* Structs */ @@ -515,6 +529,11 @@ const char *RNA_struct_ui_name(StructRNA *type) return CTX_IFACE_(type->translation_context, type->name); } +const char *RNA_struct_ui_name_raw(StructRNA *type) +{ + return type->name; +} + int RNA_struct_ui_icon(StructRNA *type) { if (type) @@ -528,6 +547,11 @@ const char *RNA_struct_ui_description(StructRNA *type) return TIP_(type->description); } +const char *RNA_struct_ui_description_raw(StructRNA *type) +{ + return type->description; +} + const char *RNA_struct_translation_context(StructRNA *type) { return type->translation_context ? type->translation_context : BLF_I18NCONTEXT_DEFAULT; @@ -778,7 +802,7 @@ const char *RNA_property_identifier(PropertyRNA *prop) const char *RNA_property_description(PropertyRNA *prop) { - return rna_ensure_property_description(prop); + return TIP_(rna_ensure_property_description(prop)); } PropertyType RNA_property_type(PropertyRNA *prop) @@ -1401,11 +1425,21 @@ int RNA_property_enum_bitflag_identifiers(bContext *C, PointerRNA *ptr, Property const char *RNA_property_ui_name(PropertyRNA *prop) { + return CTX_IFACE_(prop->translation_context, rna_ensure_property_name(prop)); +} + +const char *RNA_property_ui_name_raw(PropertyRNA *prop) +{ return rna_ensure_property_name(prop); } const char *RNA_property_ui_description(PropertyRNA *prop) { + return TIP_(rna_ensure_property_description(prop)); +} + +const char *RNA_property_ui_description_raw(PropertyRNA *prop) +{ return rna_ensure_property_description(prop); } @@ -4797,6 +4831,13 @@ bool RNA_property_is_set(PointerRNA *ptr, PropertyRNA *prop) } } +void RNA_property_unset(PointerRNA *ptr, PropertyRNA *prop) +{ + if (prop->flag & PROP_IDPROPERTY) { + rna_idproperty_free(ptr, prop->identifier); + } +} + bool RNA_struct_property_is_set_ex(PointerRNA *ptr, const char *identifier, bool use_ghost) { PropertyRNA *prop = RNA_struct_find_property(ptr, identifier); @@ -4825,6 +4866,15 @@ bool RNA_struct_property_is_set(PointerRNA *ptr, const char *identifier) } } +void RNA_struct_property_unset(PointerRNA *ptr, const char *identifier) +{ + PropertyRNA *prop = RNA_struct_find_property(ptr, identifier); + + if (prop) { + RNA_property_unset(ptr, prop); + } +} + bool RNA_property_is_idprop(PropertyRNA *prop) { return (prop->magic != RNA_MAGIC); @@ -5190,6 +5240,11 @@ const char *RNA_function_identifier(FunctionRNA *func) const char *RNA_function_ui_description(FunctionRNA *func) { + return TIP_(func->description); +} + +const char *RNA_function_ui_description_raw(FunctionRNA *func) +{ return func->description; } diff --git a/source/blender/makesrna/intern/rna_color.c b/source/blender/makesrna/intern/rna_color.c index 74d212fae57..49e1122bf18 100644 --- a/source/blender/makesrna/intern/rna_color.c +++ b/source/blender/makesrna/intern/rna_color.c @@ -298,7 +298,7 @@ static void rna_ColorRamp_update(Main *bmain, Scene *UNUSED(scene), PointerRNA * for (node = ntree->nodes.first; node; node = node->next) { if (ELEM3(node->type, SH_NODE_VALTORGB, CMP_NODE_VALTORGB, TEX_NODE_VALTORGB)) { - ED_node_generic_update(bmain, ntree, node); + ED_node_tag_update_nodetree(bmain, ntree); } } } diff --git a/source/blender/makesrna/intern/rna_define.c b/source/blender/makesrna/intern/rna_define.c index c92777af8fd..61e67ad3298 100644 --- a/source/blender/makesrna/intern/rna_define.c +++ b/source/blender/makesrna/intern/rna_define.c @@ -458,6 +458,78 @@ static int rna_validate_identifier(const char *identifier, char *error, int prop return 1; } +void RNA_identifier_sanitize(char *identifier, int property) +{ + int a = 0; + + /* list from http://docs.python.org/py3k/reference/lexical_analysis.html#keywords */ + static const char *kwlist[] = { + /* "False", "None", "True", */ + "and", "as", "assert", "break", + "class", "continue", "def", "del", "elif", "else", "except", + "finally", "for", "from", "global", "if", "import", "in", + "is", "lambda", "nonlocal", "not", "or", "pass", "raise", + "return", "try", "while", "with", "yield", NULL + }; + + + if (!isalpha(identifier[0])) { + /* first character failed isalpha() check */ + identifier[0] = '_'; + } + + for (a = 0; identifier[a]; a++) { + if (DefRNA.preprocess && property) { + if (isalpha(identifier[a]) && isupper(identifier[a])) { + /* property names must contain lower case characters only */ + identifier[a] = tolower(identifier[a]); + } + } + + if (identifier[a] == '_') { + continue; + } + + if (identifier[a] == ' ') { + /* spaces are not okay in identifier names */ + identifier[a] = '_'; + } + + if (isalnum(identifier[a]) == 0) { + /* one of the characters failed an isalnum() check and is not an underscore */ + identifier[a] = '_'; + } + } + + for (a = 0; kwlist[a]; a++) { + if (strcmp(identifier, kwlist[a]) == 0) { + /* this keyword is reserved by python. + * just replace the last character by '_' to keep it readable. + */ + identifier[strlen(identifier)-1] = '_'; + break; + } + } + + if (property) { + static const char *kwlist_prop[] = { + /* not keywords but reserved all the same because py uses */ + "keys", "values", "items", "get", + NULL + }; + + for (a = 0; kwlist_prop[a]; a++) { + if (strcmp(identifier, kwlist_prop[a]) == 0) { + /* this keyword is reserved by python. + * just replace the last character by '_' to keep it readable. + */ + identifier[strlen(identifier)-1] = '_'; + break; + } + } + } +} + /* Blender Data Definition */ BlenderRNA *RNA_create(void) diff --git a/source/blender/makesrna/intern/rna_lamp.c b/source/blender/makesrna/intern/rna_lamp.c index 912f4d914cb..7fee67cd569 100644 --- a/source/blender/makesrna/intern/rna_lamp.c +++ b/source/blender/makesrna/intern/rna_lamp.c @@ -42,6 +42,7 @@ #include "MEM_guardedalloc.h" +#include "BKE_context.h" #include "BKE_depsgraph.h" #include "BKE_main.h" #include "BKE_texture.h" @@ -169,14 +170,14 @@ static void rna_Lamp_spot_size_set(PointerRNA *ptr, float value) la->spotsize = RAD2DEGF(value); } -static void rna_Lamp_use_nodes_update(Main *blain, Scene *scene, PointerRNA *ptr) +static void rna_Lamp_use_nodes_update(bContext *C, PointerRNA *ptr) { Lamp *la = (Lamp *)ptr->data; if (la->use_nodes && la->nodetree == NULL) - ED_node_shader_default(scene, &la->id); + ED_node_shader_default(C, &la->id); - rna_Lamp_update(blain, scene, ptr); + rna_Lamp_update(CTX_data_main(C), CTX_data_scene(C), ptr); } #else @@ -414,6 +415,7 @@ static void rna_def_lamp(BlenderRNA *brna) prop = RNA_def_property(srna, "use_nodes", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "use_nodes", 1); RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); + RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE); RNA_def_property_ui_text(prop, "Use Nodes", "Use shader nodes to render the lamp"); RNA_def_property_update(prop, 0, "rna_Lamp_use_nodes_update"); diff --git a/source/blender/makesrna/intern/rna_main_api.c b/source/blender/makesrna/intern/rna_main_api.c index 4d5d4d4a7cd..a79fa1aaed4 100644 --- a/source/blender/makesrna/intern/rna_main_api.c +++ b/source/blender/makesrna/intern/rna_main_api.c @@ -235,23 +235,32 @@ static void rna_Main_materials_remove(Main *bmain, ReportList *reports, PointerR } } -static bNodeTree *rna_Main_nodetree_new(Main *bmain, const char *name, int type) +static EnumPropertyItem *rna_Main_nodetree_type_itemf(bContext *UNUSED(C), PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), int *free) { - bNodeTree *tree = ntreeAddTree(bmain, name, type, NODE_GROUP); - - id_us_min(&tree->id); - return tree; + return rna_node_tree_type_itemf(NULL, NULL, free); +} +static struct bNodeTree *rna_Main_nodetree_new(Main *bmain, const char *name, int type) +{ + bNodeTreeType *typeinfo = rna_node_tree_type_from_enum(type); + if (typeinfo) { + bNodeTree *ntree = ntreeAddTree(bmain, name, typeinfo->idname); + + id_us_min(&ntree->id); + return ntree; + } + else + return NULL; } -static void rna_Main_nodetree_remove(Main *bmain, ReportList *reports, PointerRNA *tree_ptr) +static void rna_Main_nodetree_remove(Main *bmain, ReportList *reports, PointerRNA *ntree_ptr) { - bNodeTree *tree = tree_ptr->data; - if (ID_REAL_USERS(tree) <= 0) { - BKE_libblock_free(&bmain->nodetree, tree); - RNA_POINTER_INVALIDATE(tree_ptr); + bNodeTree *ntree = ntree_ptr->data; + if (ID_REAL_USERS(ntree) <= 0) { + BKE_libblock_free(&bmain->nodetree, ntree); + RNA_POINTER_INVALIDATE(ntree_ptr); } else { BKE_reportf(reports, RPT_ERROR, "Node tree '%s' must have zero users to be removed, found %d", - tree->id.name + 2, ID_REAL_USERS(tree)); + ntree->id.name + 2, ID_REAL_USERS(ntree)); } } @@ -1069,10 +1078,8 @@ void RNA_def_main_node_groups(BlenderRNA *brna, PropertyRNA *cprop) PropertyRNA *parm; PropertyRNA *prop; - static EnumPropertyItem node_nodetree_items[] = { - {0, "SHADER", 0, "Shader", ""}, - {1, "COMPOSITE", 0, "Composite", ""}, - {2, "TEXTURE", 0, "Texture", ""}, + static EnumPropertyItem dummy_items[] = { + {0, "DUMMY", 0, "", ""}, {0, NULL, 0, NULL, NULL} }; @@ -1085,7 +1092,8 @@ void RNA_def_main_node_groups(BlenderRNA *brna, PropertyRNA *cprop) RNA_def_function_ui_description(func, "Add a new node tree to the main database"); parm = RNA_def_string(func, "name", "NodeGroup", 0, "", "New name for the datablock"); RNA_def_property_flag(parm, PROP_REQUIRED); - parm = RNA_def_enum(func, "type", node_nodetree_items, 0, "Type", "The type of node_group to add"); + parm = RNA_def_enum(func, "type", dummy_items, 0, "Type", "The type of node_group to add"); + RNA_def_property_enum_funcs(parm, NULL, NULL, "rna_Main_nodetree_type_itemf"); RNA_def_property_flag(parm, PROP_REQUIRED); /* return type */ parm = RNA_def_pointer(func, "tree", "NodeTree", "", "New node tree datablock"); diff --git a/source/blender/makesrna/intern/rna_material.c b/source/blender/makesrna/intern/rna_material.c index d1c81200e6a..57ae217cff6 100644 --- a/source/blender/makesrna/intern/rna_material.c +++ b/source/blender/makesrna/intern/rna_material.c @@ -82,6 +82,7 @@ EnumPropertyItem ramp_blend_items[] = { #include "DNA_node_types.h" #include "DNA_object_types.h" +#include "BKE_context.h" #include "BKE_depsgraph.h" #include "BKE_main.h" #include "BKE_material.h" @@ -111,7 +112,7 @@ static void rna_Material_update_previews(Main *bmain, Scene *scene, PointerRNA * Material *ma = ptr->id.data; if (ma->nodetree) - ntreeClearPreview(ma->nodetree); + BKE_node_preview_clear_tree(ma->nodetree); WM_main_add_notifier(NC_MATERIAL | ND_SHADING, ma); } @@ -287,14 +288,14 @@ static void rna_Material_use_specular_ramp_set(PointerRNA *ptr, int value) ma->ramp_spec = add_colorband(0); } -static void rna_Material_use_nodes_update(Main *bmain, Scene *scene, PointerRNA *ptr) +static void rna_Material_use_nodes_update(bContext *C, PointerRNA *ptr) { Material *ma = (Material *)ptr->data; if (ma->use_nodes && ma->nodetree == NULL) - ED_node_shader_default(scene, &ma->id); + ED_node_shader_default(C, &ma->id); - rna_Material_update(bmain, scene, ptr); + rna_Material_update(CTX_data_main(C), CTX_data_scene(C), ptr); } static EnumPropertyItem *rna_Material_texture_coordinates_itemf(bContext *UNUSED(C), PointerRNA *ptr, @@ -2024,6 +2025,7 @@ void RNA_def_material(BlenderRNA *brna) prop = RNA_def_property(srna, "use_nodes", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "use_nodes", 1); RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); + RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE); RNA_def_property_ui_text(prop, "Use Nodes", "Use shader nodes to render the material"); RNA_def_property_update(prop, 0, "rna_Material_use_nodes_update"); diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c index e7c030d5cdf..99b4f5a794d 100644 --- a/source/blender/makesrna/intern/rna_nodetree.c +++ b/source/blender/makesrna/intern/rna_nodetree.c @@ -26,6 +26,7 @@ #include <stdlib.h> #include <string.h> +#include <limits.h> #include "BLI_listbase.h" #include "BLI_math.h" @@ -61,11 +62,22 @@ #include "MEM_guardedalloc.h" -EnumPropertyItem nodetree_type_items[] = { - {NTREE_SHADER, "SHADER", ICON_MATERIAL, "Shader", "Shader nodes"}, - {NTREE_TEXTURE, "TEXTURE", ICON_TEXTURE, "Texture", "Texture nodes"}, - {NTREE_COMPOSIT, "COMPOSITING", ICON_RENDERLAYERS, "Compositing", "Compositing nodes"}, - {0, NULL, 0, NULL, NULL} +EnumPropertyItem node_socket_in_out_items[] = { + { SOCK_IN, "IN", 0, "Input", "" }, + { SOCK_OUT, "OUT", 0, "Output", "" }, + { 0, NULL, 0, NULL, NULL } +}; + +EnumPropertyItem node_socket_type_items[] = { + {SOCK_CUSTOM, "CUSTOM", 0, "Custom", ""}, + {SOCK_FLOAT, "VALUE", 0, "Value", ""}, + {SOCK_INT, "INT", 0, "Int", ""}, + {SOCK_BOOLEAN, "BOOLEAN", 0, "Boolean", ""}, + {SOCK_VECTOR, "VECTOR", 0, "Vector", ""}, + {SOCK_STRING, "STRING", 0, "String", ""}, + {SOCK_RGBA, "RGBA", 0, "RGBA", ""}, + {SOCK_SHADER, "SHADER", 0, "Shader", ""}, + {0, NULL, 0, NULL, NULL} }; EnumPropertyItem node_quality_items[] = { @@ -85,17 +97,15 @@ EnumPropertyItem node_chunksize_items[] = { {0, NULL, 0, NULL, NULL} }; -EnumPropertyItem node_socket_type_items[] = { - {SOCK_FLOAT, "VALUE", 0, "Value", ""}, - {SOCK_VECTOR, "VECTOR", 0, "Vector", ""}, - {SOCK_RGBA, "RGBA", 0, "RGBA", ""}, - {SOCK_SHADER, "SHADER", 0, "Shader", ""}, - {SOCK_BOOLEAN, "BOOLEAN", 0, "Boolean", ""}, - {SOCK_MESH, "MESH", 0, "Mesh", ""}, - {SOCK_INT, "INT", 0, "Int", ""}, - {SOCK_STRING, "STRING", 0, "String", ""}, - {0, NULL, 0, NULL, NULL} -}; +#define DEF_ICON_BLANK_SKIP +#define DEF_ICON(name) {ICON_##name, (#name), 0, (#name), ""}, +#define DEF_VICO(name) +EnumPropertyItem node_icon_items[] = { +#include "UI_icons.h" + {0, NULL, 0, NULL, NULL}}; +#undef DEF_ICON_BLANK_SKIP +#undef DEF_ICON +#undef DEF_VICO EnumPropertyItem node_math_items[] = { { 0, "ADD", 0, "Add", ""}, @@ -174,52 +184,20 @@ EnumPropertyItem prop_wave_items[] = { }; #endif -/* Add any new socket value subtype here. - * When adding a new subtype here, make sure you also add it - * to the subtype definitions in DNA_node_types.h. - * This macro is used by the RNA and the internal converter functions - * to define all socket subtypes. The SUBTYPE macro must be defined - * before using this macro, and undefined afterwards. - */ -#define NODE_DEFINE_SUBTYPES_INT \ - SUBTYPE(INT, Int, NONE, None) \ - SUBTYPE(INT, Int, UNSIGNED, Unsigned) - -#define NODE_DEFINE_SUBTYPES_FLOAT \ - SUBTYPE(FLOAT, Float, NONE, None) \ - SUBTYPE(FLOAT, Float, UNSIGNED, Unsigned) \ - SUBTYPE(FLOAT, Float, PERCENTAGE, Percentage) \ - SUBTYPE(FLOAT, Float, FACTOR, Factor) \ - SUBTYPE(FLOAT, Float, ANGLE, Angle) \ - SUBTYPE(FLOAT, Float, TIME, Time) \ - SUBTYPE(FLOAT, Float, DISTANCE, Distance) - -#define NODE_DEFINE_SUBTYPES_STRING \ - SUBTYPE(STRING, String, NONE, None) \ - SUBTYPE(STRING, String, FILEPATH, Filepath) - -#define NODE_DEFINE_SUBTYPES_VECTOR \ - SUBTYPE(VECTOR, Vector, NONE, None) \ - SUBTYPE(VECTOR, Vector, TRANSLATION, Translation) \ - SUBTYPE(VECTOR, Vector, DIRECTION, Direction) \ - SUBTYPE(VECTOR, Vector, VELOCITY, Velocity) \ - SUBTYPE(VECTOR, Vector, ACCELERATION, Acceleration) \ - SUBTYPE(VECTOR, Vector, EULER, Euler) \ - SUBTYPE(VECTOR, Vector, XYZ, XYZ) - -#define NODE_DEFINE_SUBTYPES \ - NODE_DEFINE_SUBTYPES_INT \ - NODE_DEFINE_SUBTYPES_FLOAT \ - NODE_DEFINE_SUBTYPES_STRING \ - NODE_DEFINE_SUBTYPES_VECTOR \ - #ifdef RNA_RUNTIME #include "BLI_linklist.h" +#include "BLI_string.h" + +#include "BKE_context.h" +#include "BKE_idprop.h" #include "BKE_global.h" #include "ED_node.h" +#include "ED_render.h" + +#include "NOD_socket.h" #include "RE_engine.h" #include "RE_pipeline.h" @@ -227,66 +205,1334 @@ EnumPropertyItem prop_wave_items[] = { #include "DNA_scene_types.h" #include "WM_api.h" -static StructRNA *rna_Node_refine(struct PointerRNA *ptr) + +int rna_node_tree_type_to_enum(bNodeTreeType *typeinfo) { - bNode *node = (bNode *)ptr->data; + int i=0, result=-1; + NODE_TREE_TYPES_BEGIN(nt) + if (nt == typeinfo) { + result = i; + break; + } + ++i; + NODE_TREE_TYPES_END + return result; +} + +int rna_node_tree_idname_to_enum(const char *idname) +{ + int i=0, result=-1; + NODE_TREE_TYPES_BEGIN(nt) + if (strcmp(nt->idname, idname)==0) { + result = i; + break; + } + ++i; + NODE_TREE_TYPES_END + return result; +} - switch (node->type) { +bNodeTreeType *rna_node_tree_type_from_enum(int value) +{ + int i=0; + bNodeTreeType *result=NULL; + NODE_TREE_TYPES_BEGIN(nt) + if (i == value) { + result = nt; + break; + } + ++i; + NODE_TREE_TYPES_END + return result; +} + +EnumPropertyItem *rna_node_tree_type_itemf(void *data, int (*poll)(void *data, bNodeTreeType *), int *free) +{ + EnumPropertyItem tmp = {0, "", 0, "", ""}; + EnumPropertyItem *item = NULL; + int totitem=0, i=0; + + NODE_TREE_TYPES_BEGIN(nt) + if (poll && !poll(data, nt)) { + ++i; + continue; + } - #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \ - case ID: return &RNA_##Category##StructName; - - #include "rna_nodetree_types.h" + tmp.value = i; + tmp.identifier = nt->idname; + tmp.icon = nt->ui_icon; + tmp.name = nt->ui_name; + tmp.description = nt->ui_description; - case NODE_GROUP: - return &RNA_NodeGroup; - case NODE_FRAME: - return &RNA_NodeFrame; - case NODE_REROUTE: - return &RNA_NodeReroute; - default: - return &RNA_Node; + RNA_enum_item_add(&item, &totitem, &tmp); + + ++i; + NODE_TREE_TYPES_END + + RNA_enum_item_end(&item, &totitem); + *free = 1; + + return item; +} + +int rna_node_type_to_enum(bNodeType *typeinfo) +{ + int i=0, result=-1; + NODE_TYPES_BEGIN(ntype) + if (ntype==typeinfo) { + result = i; + break; + } + ++i; + NODE_TYPES_END + return result; +} + +int rna_node_idname_to_enum(const char *idname) +{ + int i=0, result=-1; + NODE_TYPES_BEGIN(ntype) + if (strcmp(ntype->idname, idname)==0) { + result = i; + break; + } + ++i; + NODE_TYPES_END + return result; +} + +bNodeType *rna_node_type_from_enum(int value) +{ + int i=0; + bNodeType *result=NULL; + NODE_TYPES_BEGIN(ntype) + if (i==value) { + result = ntype; + break; + } + ++i; + NODE_TYPES_END + return result; +} + +EnumPropertyItem *rna_node_type_itemf(void *data, int (*poll)(void *data, bNodeType *), int *free) +{ + EnumPropertyItem *item = NULL; + EnumPropertyItem tmp = {0, "", 0, "", ""}; + int totitem=0, i=0; + + NODE_TYPES_BEGIN(ntype) + if (poll && !poll(data, ntype)) { + ++i; + continue; + } + + tmp.value = i; + tmp.identifier = ntype->idname; + tmp.icon = ntype->ui_icon; + tmp.name = ntype->ui_name; + tmp.description = ntype->ui_description; + + RNA_enum_item_add(&item, &totitem, &tmp); + + ++i; + NODE_TYPES_END + RNA_enum_item_end(&item, &totitem); + *free = 1; + + return item; +} + +int rna_node_socket_type_to_enum(bNodeSocketType *typeinfo) +{ + int i=0, result=-1; + NODE_SOCKET_TYPES_BEGIN(stype) + if (stype==typeinfo) { + result = i; + break; + } + ++i; + NODE_SOCKET_TYPES_END + return result; +} + +int rna_node_socket_idname_to_enum(const char *idname) +{ + int i=0, result=-1; + NODE_SOCKET_TYPES_BEGIN(stype) + if (strcmp(stype->idname, idname)==0) { + result = i; + break; + } + ++i; + NODE_SOCKET_TYPES_END + return result; +} + +bNodeSocketType *rna_node_socket_type_from_enum(int value) +{ + int i=0; + bNodeSocketType *result=NULL; + NODE_SOCKET_TYPES_BEGIN(stype) + if (i==value) { + result = stype; + break; + } + ++i; + NODE_SOCKET_TYPES_END + return result; +} + +EnumPropertyItem *rna_node_socket_type_itemf(void *data, int (*poll)(void *data, bNodeSocketType *), int *free) +{ + EnumPropertyItem *item = NULL; + EnumPropertyItem tmp = {0, "", 0, "", ""}; + int totitem=0, i=0; + StructRNA *srna; + + NODE_SOCKET_TYPES_BEGIN(stype) + if (poll && !poll(data, stype)) { + ++i; + continue; + } + + srna = stype->ext_socket.srna; + tmp.value = i; + tmp.identifier = stype->idname; + tmp.icon = RNA_struct_ui_icon(srna); + tmp.name = RNA_struct_ui_name(srna); + tmp.description = RNA_struct_ui_description(srna); + + RNA_enum_item_add(&item, &totitem, &tmp); + + ++i; + NODE_SOCKET_TYPES_END + RNA_enum_item_end(&item, &totitem); + *free = 1; + + return item; +} + +static EnumPropertyItem *rna_node_static_type_itemf(bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop), int *free) +{ + EnumPropertyItem *item = NULL; + EnumPropertyItem tmp; + int totitem=0; + + /* hack, don't want to add include path to RNA just for this, since in the future RNA types + * for nodes should be defined locally at runtime anyway ... + */ + + tmp.value = NODE_CUSTOM; + tmp.identifier = "CUSTOM"; + tmp.name = "Custom"; + tmp.description = "Custom Node"; + tmp.icon = ICON_NONE; + RNA_enum_item_add(&item, &totitem, &tmp); + + tmp.value = NODE_UNDEFINED; + tmp.identifier = "UNDEFINED"; + tmp.name = "UNDEFINED"; + tmp.description = ""; + tmp.icon = ICON_NONE; + RNA_enum_item_add(&item, &totitem, &tmp); + + #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \ + if (strcmp(#Category, "Node")==0) { \ + tmp.value = ID; \ + tmp.identifier = EnumName; \ + tmp.name = UIName; \ + tmp.description = UIDesc; \ + tmp.icon = ICON_NONE; \ + RNA_enum_item_add(&item, &totitem, &tmp); \ + } + #include "../../nodes/NOD_static_types.h" + #undef DefNode + + if (RNA_struct_is_a(ptr->type, &RNA_ShaderNode)) { + #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \ + if (strcmp(#Category, "ShaderNode")==0) { \ + tmp.value = ID; \ + tmp.identifier = EnumName; \ + tmp.name = UIName; \ + tmp.description = UIDesc; \ + tmp.icon = ICON_NONE; \ + RNA_enum_item_add(&item, &totitem, &tmp); \ + } + #include "../../nodes/NOD_static_types.h" + #undef DefNode + } + + if (RNA_struct_is_a(ptr->type, &RNA_CompositorNode)) { + #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \ + if (strcmp(#Category, "CompositorNode")==0) { \ + tmp.value = ID; \ + tmp.identifier = EnumName; \ + tmp.name = UIName; \ + tmp.description = UIDesc; \ + tmp.icon = ICON_NONE; \ + RNA_enum_item_add(&item, &totitem, &tmp); \ + } + #include "../../nodes/NOD_static_types.h" + #undef DefNode + } + + if (RNA_struct_is_a(ptr->type, &RNA_TextureNode)) { + #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \ + if (strcmp(#Category, "TextureNode")==0) { \ + tmp.value = ID; \ + tmp.identifier = EnumName; \ + tmp.name = UIName; \ + tmp.description = UIDesc; \ + tmp.icon = ICON_NONE; \ + RNA_enum_item_add(&item, &totitem, &tmp); \ + } + #include "../../nodes/NOD_static_types.h" + #undef DefNode } + + RNA_enum_item_end(&item, &totitem); + *free = 1; + + return item; } +/* ******** Node Tree ******** */ + static StructRNA *rna_NodeTree_refine(struct PointerRNA *ptr) { + bNodeTree *ntree= (bNodeTree*)ptr->data; + + if (ntree->typeinfo && ntree->typeinfo->ext.srna) + return ntree->typeinfo->ext.srna; + else + return &RNA_NodeTree; +} + +static int rna_NodeTree_poll(const bContext *C, bNodeTreeType *ntreetype) +{ + extern FunctionRNA rna_NodeTree_poll_func; + + PointerRNA ptr; + ParameterList list; + FunctionRNA *func; + void *ret; + int visible; + + RNA_pointer_create(NULL, ntreetype->ext.srna, NULL, &ptr); /* dummy */ + func = &rna_NodeTree_poll_func; /* RNA_struct_find_function(&ptr, "poll"); */ + + RNA_parameter_list_create(&list, &ptr, func); + RNA_parameter_set_lookup(&list, "context", &C); + ntreetype->ext.call((bContext *)C, &ptr, func, &list); + + RNA_parameter_get_lookup(&list, "visible", &ret); + visible = *(int*)ret; + + RNA_parameter_list_free(&list); + + return visible; +} + +static void rna_NodeTree_draw_add_menu(const bContext *C, struct uiLayout *layout, bNodeTree *ntree) +{ + extern FunctionRNA rna_NodeTree_draw_add_menu_func; + + PointerRNA ptr; + ParameterList list; + FunctionRNA *func; + + if (!ntreeIsValid(ntree)) + return; + + RNA_id_pointer_create(&ntree->id, &ptr); + func = &rna_NodeTree_draw_add_menu_func; /* RNA_struct_find_function(&ptr, "draw_add_menu"); */ + + RNA_parameter_list_create(&list, &ptr, func); + RNA_parameter_set_lookup(&list, "context", &C); + RNA_parameter_set_lookup(&list, "layout", &layout); + ntree->typeinfo->ext.call((bContext *)C, &ptr, func, &list); + + RNA_parameter_list_free(&list); +} + +static void rna_NodeTree_get_from_context(const bContext *C, bNodeTreeType *ntreetype, + bNodeTree **r_ntree, ID **r_id, ID **r_from) +{ + extern FunctionRNA rna_NodeTree_get_from_context_func; + + PointerRNA ptr; + ParameterList list; + FunctionRNA *func; + void *ret1, *ret2, *ret3; + + RNA_pointer_create(NULL, ntreetype->ext.srna, NULL, &ptr); /* dummy */ + func = &rna_NodeTree_get_from_context_func; /* RNA_struct_find_function(&ptr, "get_from_context"); */ + + RNA_parameter_list_create(&list, &ptr, func); + RNA_parameter_set_lookup(&list, "context", &C); + ntreetype->ext.call((bContext *)C, &ptr, func, &list); + + RNA_parameter_get_lookup(&list, "result_1", &ret1); + RNA_parameter_get_lookup(&list, "result_2", &ret2); + RNA_parameter_get_lookup(&list, "result_3", &ret3); + *r_ntree = *(bNodeTree **)ret1; + *r_id = *(ID **)ret2; + *r_from = *(ID **)ret3; + + RNA_parameter_list_free(&list); +} + +static void rna_NodeTree_unregister(Main *UNUSED(bmain), StructRNA *type) +{ + bNodeTreeType *nt= RNA_struct_blender_type_get(type); + + if(!nt) + return; + + RNA_struct_free_extension(type, &nt->ext); + + ntreeTypeFreeLink(nt); + + RNA_struct_free(&BLENDER_RNA, type); + + /* update while blender is running */ + WM_main_add_notifier(NC_NODE|NA_EDITED, NULL); +} + +static StructRNA *rna_NodeTree_register(Main *bmain, ReportList *reports, void *data, const char *identifier, + StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free) +{ + bNodeTreeType *nt, dummynt; + bNodeTree dummyntree; + PointerRNA dummyptr; + int have_function[3]; + + /* setup dummy tree & tree type to store static properties in */ + memset(&dummynt, 0, sizeof(bNodeTreeType)); + memset(&dummyntree, 0, sizeof(bNodeTree)); + dummyntree.typeinfo= &dummynt; + RNA_pointer_create(NULL, &RNA_NodeTree, &dummyntree, &dummyptr); + + /* validate the python class */ + if(validate(&dummyptr, data, have_function) != 0) + return NULL; + + if(strlen(identifier) >= sizeof(dummynt.idname)) { + BKE_reportf(reports, RPT_ERROR, "registering node tree class: '%s' is too long, maximum length is %d", + identifier, (int)sizeof(dummynt.idname)); + return NULL; + } + + /* check if we have registered this tree type before, and remove it */ + nt= ntreeTypeFind(dummynt.idname); + if(nt) + rna_NodeTree_unregister(bmain, nt->ext.srna); + + /* create a new node tree type */ + nt= MEM_callocN(sizeof(bNodeTreeType), "node tree type"); + memcpy(nt, &dummynt, sizeof(dummynt)); + + nt->type = NTREE_CUSTOM; + + nt->ext.srna= RNA_def_struct_ptr(&BLENDER_RNA, nt->idname, &RNA_NodeTree); + nt->ext.data= data; + nt->ext.call= call; + nt->ext.free= free; + RNA_struct_blender_type_set(nt->ext.srna, nt); + + RNA_def_struct_ui_text(nt->ext.srna, nt->ui_name, nt->ui_description); + RNA_def_struct_ui_icon(nt->ext.srna, nt->ui_icon); + + nt->poll = (have_function[0]) ? rna_NodeTree_poll : NULL; + nt->draw_add_menu = (have_function[1]) ? rna_NodeTree_draw_add_menu : NULL; + nt->get_from_context = (have_function[2]) ? rna_NodeTree_get_from_context : NULL; + + ntreeTypeAdd(nt); + + /* update while blender is running */ + WM_main_add_notifier(NC_NODE|NA_EDITED, NULL); + + return nt->ext.srna; +} + +static void rna_NodeTree_update(Main *bmain, Scene *scene, PointerRNA *ptr) +{ + bNodeTree *ntree = (bNodeTree *)ptr->id.data; + + /* when using border, make it so no old data from outside of + * border is hanging around + * ideally shouldn't be in RNA callback, but how to teach + * compo to only clear frame when border usage is actually + * toggling + */ + if (ntree->flag & NTREE_VIEWER_BORDER) { + Image *ima = BKE_image_verify_viewer(IMA_TYPE_COMPOSITE, "Viewer Node"); + void *lock; + ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock); + + if (ibuf) { + if (ibuf->rect) + memset(ibuf->rect, 0, 4 * ibuf->x * ibuf->y); + + if (ibuf->rect_float) + memset(ibuf->rect_float, 0, 4 * ibuf->x * ibuf->y * sizeof(float)); + + ibuf->userflags |= IB_DISPLAY_BUFFER_INVALID; + } + + BKE_image_release_ibuf(ima, ibuf, lock); + } + + WM_main_add_notifier(NC_NODE | NA_EDITED, NULL); + WM_main_add_notifier(NC_SCENE | ND_NODES, &ntree->id); + + ED_node_tag_update_nodetree(bmain, ntree); +} + +static bNode *rna_NodeTree_node_new(bNodeTree *ntree, bContext *C, ReportList *reports, const char *type) +{ + bNodeType *ntype; + bNode *node; + + if (!ntreeIsValid(ntree)) { + BKE_reportf(reports, RPT_ERROR, "Node tree %s invalid", ntree->id.name+2); + return NULL; + } + + ntype = nodeTypeFind(type); + if (!ntype) { + BKE_reportf(reports, RPT_ERROR, "Node type %s undefined", type); + return NULL; + } + + if (ntype->poll && !ntype->poll(ntype, ntree)) { + BKE_reportf(reports, RPT_ERROR, "Cannot add node of type %s to node tree '%s'", type, ntree->id.name+2); + return NULL; + } + + node = nodeAddNode(C, ntree, type); + BLI_assert(node && node->typeinfo); + + /* XXX ugly stuff, should be done with specialized operators (after actual node creation)! */ + if (ntree->type==NTREE_COMPOSIT) { + if(ELEM4(node->type, CMP_NODE_COMPOSITE, CMP_NODE_DEFOCUS, CMP_NODE_OUTPUT_FILE, CMP_NODE_R_LAYERS)) { + /* annoying, find the node tree we are in, scene can be NULL */ + Scene *scene; + for(scene= CTX_data_main(C)->scene.first; scene; scene= scene->id.next) { + if(scene->nodetree == ntree) { + break; + } + } + node->id= (ID *)scene; + id_us_plus(node->id); + } + + ntreeCompositForceHidden(ntree, CTX_data_scene(C)); + } + else if (ntree->type==NTREE_TEXTURE) { + ntreeTexCheckCyclics(ntree); + } + + ntreeUpdateTree(ntree); + nodeUpdate(ntree, node); + WM_main_add_notifier(NC_NODE | NA_EDITED, ntree); + + return node; +} + +static void rna_NodeTree_node_remove(bNodeTree *ntree, ReportList *reports, PointerRNA *node_ptr) +{ + bNode *node = node_ptr->data; + + if (!ntreeIsValid(ntree)) { + BKE_reportf(reports, RPT_ERROR, "Node tree %s invalid", ntree->id.name+2); + return; + } + + if (BLI_findindex(&ntree->nodes, node) == -1) { + BKE_reportf(reports, RPT_ERROR, "Unable to locate node '%s' in node tree", node->name); + return; + } + + id_us_min(node->id); + nodeFreeNode(ntree, node); + RNA_POINTER_INVALIDATE(node_ptr); + + ntreeUpdateTree(ntree); /* update group node socket links */ + WM_main_add_notifier(NC_NODE | NA_EDITED, ntree); +} + +static void rna_NodeTree_node_clear(bNodeTree *ntree, ReportList *reports) +{ + bNode *node = ntree->nodes.first; + + if (!ntreeIsValid(ntree)) { + BKE_reportf(reports, RPT_ERROR, "Node tree %s invalid", ntree->id.name+2); + return; + } + + while (node) { + bNode *next_node = node->next; + + if (node->id) + id_us_min(node->id); + + nodeFreeNode(ntree, node); + + node = next_node; + } + + ntreeUpdateTree(ntree); + + WM_main_add_notifier(NC_NODE | NA_EDITED, ntree); +} + +static PointerRNA rna_NodeTree_active_node_get(PointerRNA *ptr) +{ bNodeTree *ntree = (bNodeTree *)ptr->data; + bNode *node = nodeGetActive(ntree); + return rna_pointer_inherit_refine(ptr, &RNA_Node, node); +} - switch (ntree->type) { - case NTREE_SHADER: - return &RNA_ShaderNodeTree; - case NTREE_COMPOSIT: - return &RNA_CompositorNodeTree; - case NTREE_TEXTURE: - return &RNA_TextureNodeTree; - default: - return &RNA_NodeTree; +static void rna_NodeTree_active_node_set(PointerRNA *ptr, const PointerRNA value) +{ + bNodeTree *ntree = (bNodeTree *)ptr->data; + bNode *node = (bNode *)value.data; + + /* activating node might require valid typeinfo */ + if (!ntreeIsValid(ntree)) + return; + + if (node && BLI_findindex(&ntree->nodes, node) != -1) + nodeSetActive(ntree, node); + else + nodeClearActive(ntree); +} + +static bNodeLink *rna_NodeTree_link_new(bNodeTree *ntree, ReportList *reports, + bNodeSocket *fromsock, bNodeSocket *tosock, + int verify_limits) +{ + bNodeLink *ret; + bNode *fromnode = NULL, *tonode = NULL; + + if (!ntreeIsValid(ntree)) { + BKE_reportf(reports, RPT_ERROR, "Node tree %s invalid", ntree->id.name+2); + return NULL; + } + + nodeFindNode(ntree, fromsock, &fromnode, NULL); + nodeFindNode(ntree, tosock, &tonode, NULL); + + if (&fromsock->in_out == &tosock->in_out) { + BKE_report(reports, RPT_ERROR, "Same input/output direction of sockets"); + return NULL; + } + + if (verify_limits) { + /* remove other socket links if limit is exceeded */ + if (nodeCountSocketLinks(ntree, fromsock) > fromsock->limit) + nodeRemSocketLinks(ntree, fromsock); + if (nodeCountSocketLinks(ntree, tosock) > tosock->limit) + nodeRemSocketLinks(ntree, tosock); + } + + ret = nodeAddLink(ntree, fromnode, fromsock, tonode, tosock); + + if (ret) { + if (tonode) + nodeUpdate(ntree, tonode); + + ntreeUpdateTree(ntree); + + WM_main_add_notifier(NC_NODE | NA_EDITED, ntree); } + return ret; } -static char *rna_Node_path(PointerRNA *ptr) +static void rna_NodeTree_link_remove(bNodeTree *ntree, ReportList *reports, PointerRNA *link_ptr) +{ + bNodeLink *link = link_ptr->data; + + if (!ntreeIsValid(ntree)) { + BKE_reportf(reports, RPT_ERROR, "Node tree %s invalid", ntree->id.name+2); + return; + } + + if (BLI_findindex(&ntree->links, link) == -1) { + BKE_report(reports, RPT_ERROR, "Unable to locate link in node tree"); + return; + } + + nodeRemLink(ntree, link); + RNA_POINTER_INVALIDATE(link_ptr); + + ntreeUpdateTree(ntree); + WM_main_add_notifier(NC_NODE | NA_EDITED, ntree); +} + +static void rna_NodeTree_link_clear(bNodeTree *ntree, ReportList *reports) +{ + bNodeLink *link = ntree->links.first; + + if (!ntreeIsValid(ntree)) { + BKE_reportf(reports, RPT_ERROR, "Node tree %s invalid", ntree->id.name+2); + return; + } + + while (link) { + bNodeLink *next_link = link->next; + + nodeRemLink(ntree, link); + + link = next_link; + } + ntreeUpdateTree(ntree); + + WM_main_add_notifier(NC_NODE | NA_EDITED, ntree); +} + +static int rna_NodeTree_active_input_get(PointerRNA *ptr) +{ + bNodeTree *ntree = (bNodeTree*)ptr->data; + bNodeSocket *gsock; + int index; + + for (gsock = ntree->inputs.first, index = 0; gsock; gsock = gsock->next, ++index) + if (gsock->flag & SELECT) + return index; + return -1; +} + +static void rna_NodeTree_active_input_set(PointerRNA *ptr, int value) +{ + bNodeTree *ntree = (bNodeTree*)ptr->data; + bNodeSocket *gsock; + int index; + + for (gsock = ntree->inputs.first, index = 0; gsock; gsock = gsock->next, ++index) { + if (index == value) + gsock->flag |= SELECT; + else + gsock->flag &= ~SELECT; + } + for (gsock = ntree->outputs.first; gsock; gsock = gsock->next) { + gsock->flag &= ~SELECT; + } +} + +static int rna_NodeTree_active_output_get(PointerRNA *ptr) +{ + bNodeTree *ntree = (bNodeTree*)ptr->data; + bNodeSocket *gsock; + int index; + + for (gsock = ntree->outputs.first, index = 0; gsock; gsock = gsock->next, ++index) + if (gsock->flag & SELECT) + return index; + return -1; +} + +static void rna_NodeTree_active_output_set(PointerRNA *ptr, int value) +{ + bNodeTree *ntree = (bNodeTree*)ptr->data; + bNodeSocket *gsock; + int index; + + for (gsock = ntree->inputs.first; gsock; gsock = gsock->next) { + gsock->flag &= ~SELECT; + } + for (gsock = ntree->outputs.first, index = 0; gsock; gsock = gsock->next, ++index) { + if (index == value) + gsock->flag |= SELECT; + else + gsock->flag &= ~SELECT; + } +} + +static int rna_NodeTree_inputs_lookupstring(PointerRNA *ptr, const char *key, PointerRNA *r_ptr) +{ + bNodeTree *ntree = (bNodeTree *)ptr->data; + bNodeSocket *sock = ntreeFindSocketInterface(ntree, SOCK_IN, key); + RNA_pointer_create(ptr->id.data, &RNA_NodeSocketInterface, sock, r_ptr); + return (sock != NULL); +} + +static int rna_NodeTree_outputs_lookupstring(PointerRNA *ptr, const char *key, PointerRNA *r_ptr) +{ + bNodeTree *ntree = (bNodeTree *)ptr->data; + bNodeSocket *sock = ntreeFindSocketInterface(ntree, SOCK_OUT, key); + RNA_pointer_create(ptr->id.data, &RNA_NodeSocketInterface, sock, r_ptr); + return (sock != NULL); +} + +static bNodeSocket *rna_NodeTree_inputs_new(bNodeTree *ntree, ReportList *reports, const char *type, const char *name) +{ + bNodeSocket *sock; + + if (!ntreeIsValid(ntree)) { + BKE_reportf(reports, RPT_ERROR, "Node tree %s invalid", ntree->id.name+2); + return NULL; + } + + sock = ntreeAddSocketInterface(ntree, SOCK_IN, type, name); + + ntreeUpdateTree(ntree); + WM_main_add_notifier(NC_NODE|NA_EDITED, ntree); + + return sock; +} + +static bNodeSocket *rna_NodeTree_outputs_new(bNodeTree *ntree, ReportList *reports, const char *type, const char *name) +{ + bNodeSocket *sock; + + if (!ntreeIsValid(ntree)) { + BKE_reportf(reports, RPT_ERROR, "Node tree %s invalid", ntree->id.name+2); + return NULL; + } + + sock = ntreeAddSocketInterface(ntree, SOCK_OUT, type, name); + + ntreeUpdateTree(ntree); + WM_main_add_notifier(NC_NODE|NA_EDITED, ntree); + + return sock; +} + +static void rna_NodeTree_socket_remove(bNodeTree *ntree, ReportList *reports, bNodeSocket *sock) +{ + if (!ntreeIsValid(ntree)) { + BKE_reportf(reports, RPT_ERROR, "Node tree %s invalid", ntree->id.name+2); + return; + } + + if (BLI_findindex(&ntree->inputs, sock) == -1 && BLI_findindex(&ntree->outputs, sock) == -1) { + BKE_reportf(reports, RPT_ERROR, "Unable to locate socket '%s' in node", sock->identifier); + } + else { + ntreeRemoveSocketInterface(ntree, sock); + + ntreeUpdateTree(ntree); + WM_main_add_notifier(NC_NODE|NA_EDITED, ntree); + } +} + +static void rna_NodeTree_inputs_clear(bNodeTree *ntree, ReportList *reports) +{ + bNodeSocket *sock, *nextsock; + + if (!ntreeIsValid(ntree)) { + BKE_reportf(reports, RPT_ERROR, "Node tree %s invalid", ntree->id.name+2); + return; + } + + for (sock = ntree->inputs.first; sock; sock = nextsock) { + nextsock = sock->next; + ntreeRemoveSocketInterface(ntree, sock); + } + + ntreeUpdateTree(ntree); + WM_main_add_notifier(NC_NODE|NA_EDITED, ntree); +} + +static void rna_NodeTree_outputs_clear(bNodeTree *ntree, ReportList *reports) +{ + bNodeSocket *sock, *nextsock; + + if (!ntreeIsValid(ntree)) { + BKE_reportf(reports, RPT_ERROR, "Node tree %s invalid", ntree->id.name+2); + return; + } + + for (sock = ntree->outputs.first; sock; sock = nextsock) { + nextsock = sock->next; + ntreeRemoveSocketInterface(ntree, sock); + } + + ntreeUpdateTree(ntree); + WM_main_add_notifier(NC_NODE|NA_EDITED, ntree); +} + +static void rna_NodeTree_interface_update(bNodeTree *ntree, bContext *C) +{ + if (!ntreeIsValid(ntree)) + return; + + ntree->update |= NTREE_UPDATE_GROUP; + ntreeUpdateTree(ntree); + + ED_node_tag_update_nodetree(CTX_data_main(C), ntree); +} + +static void rna_NodeTree_bl_idname_get(PointerRNA *ptr, char *value) +{ + bNodeTree *ntree = ptr->data; + if (ntree->typeinfo) + strcpy(value, ntree->typeinfo->idname); + else + strcpy(value, "UNDEFINED"); +} +static int rna_NodeTree_bl_idname_length(PointerRNA *ptr) +{ + bNodeTree *ntree = ptr->data; + if (ntree->typeinfo) + return strlen(ntree->typeinfo->idname); + else + return strlen("UNDEFINED"); +} + +static void rna_NodeTree_bl_label_get(PointerRNA *ptr, char *value) +{ + bNodeTree *ntree = ptr->data; + if (ntree->typeinfo) + strcpy(value, ntree->typeinfo->ui_name); + else + strcpy(value, "UNDEFINED"); +} +static int rna_NodeTree_bl_label_length(PointerRNA *ptr) +{ + bNodeTree *ntree = ptr->data; + if (ntree->typeinfo) + return strlen(ntree->typeinfo->ui_name); + else + return strlen("UNDEFINED"); +} + +static void rna_NodeTree_bl_description_get(PointerRNA *ptr, char *value) +{ + bNodeTree *ntree = ptr->data; + if (ntree->typeinfo) + strcpy(value, ntree->typeinfo->ui_description); + else + strcpy(value, "UNDEFINED"); +} +static int rna_NodeTree_bl_description_length(PointerRNA *ptr) +{ + bNodeTree *ntree = ptr->data; + if (ntree->typeinfo) + return strlen(ntree->typeinfo->ui_description); + else + return strlen("UNDEFINED"); +} + +static int rna_NodeTree_bl_icon_get(PointerRNA *ptr) +{ + bNodeTree *ntree = ptr->data; + if (ntree->typeinfo) + return ntree->typeinfo->ui_icon; + else + return ICON_NONE; +} + + +/* ******** NodeLink ******** */ + +static int rna_NodeLink_is_hidden_get(PointerRNA *ptr) +{ + bNodeLink *link = ptr->data; + return nodeLinkIsHidden(link); +} + + +/* ******** Node ******** */ + +static StructRNA *rna_Node_refine(struct PointerRNA *ptr) { bNode *node = (bNode *)ptr->data; + + if (node->typeinfo && node->typeinfo->ext.srna) + return node->typeinfo->ext.srna; + else + return ptr->type; +} + +static char *rna_Node_path(PointerRNA *ptr) +{ + bNode *node = (bNode*)ptr->data; return BLI_sprintfN("nodes[\"%s\"]", node->name); } -static const char *rna_Node_get_node_type(StructRNA *type) +static int rna_Node_poll(bNodeType *ntype, bNodeTree *ntree) { - bNodeType *nodetype = RNA_struct_blender_type_get(type); - if (nodetype) { - /* XXX hack: with customnodes branch, nodes will use an identifier string instead of integer ID. - * Then this can be returned directly instead of doing this ugly include thingy ... - */ - #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \ - if (ID == nodetype->type) { \ - return EnumName; \ - } - - #include "rna_nodetree_types.h" + extern FunctionRNA rna_Node_poll_func; + + PointerRNA ptr; + ParameterList list; + FunctionRNA *func; + void *ret; + int visible; + + RNA_pointer_create(NULL, ntype->ext.srna, NULL, &ptr); /* dummy */ + func = &rna_Node_poll_func; /* RNA_struct_find_function(&ptr, "poll"); */ + + RNA_parameter_list_create(&list, &ptr, func); + RNA_parameter_set_lookup(&list, "node_tree", &ntree); + ntype->ext.call(NULL, &ptr, func, &list); + + RNA_parameter_get_lookup(&list, "visible", &ret); + visible = *(int*)ret; + + RNA_parameter_list_free(&list); + + return visible; +} + +static int rna_Node_poll_instance(bNode *node, bNodeTree *ntree) +{ + extern FunctionRNA rna_Node_poll_instance_func; + + PointerRNA ptr; + ParameterList list; + FunctionRNA *func; + void *ret; + int visible; + + if (!node->typeinfo) + return FALSE; + + RNA_pointer_create(NULL, node->typeinfo->ext.srna, node, &ptr); /* dummy */ + func = &rna_Node_poll_instance_func; /* RNA_struct_find_function(&ptr, "poll_instance"); */ + + RNA_parameter_list_create(&list, &ptr, func); + RNA_parameter_set_lookup(&list, "node_tree", &ntree); + node->typeinfo->ext.call(NULL, &ptr, func, &list); + + RNA_parameter_get_lookup(&list, "visible", &ret); + visible = *(int*)ret; + + RNA_parameter_list_free(&list); + + return visible; +} + +static int rna_Node_poll_instance_default(bNode *node, bNodeTree *ntree) +{ + if (!node->typeinfo) + return FALSE; + + /* use the basic poll function */ + return rna_Node_poll(node->typeinfo, ntree); +} + +static void rna_Node_update_reg(bNodeTree *ntree, bNode *node) +{ + extern FunctionRNA rna_Node_update_func; + + PointerRNA ptr; + ParameterList list; + FunctionRNA *func; + + if (!node->typeinfo) + return; + + RNA_pointer_create((ID *)ntree, node->typeinfo->ext.srna, node, &ptr); + func = &rna_Node_update_func; /* RNA_struct_find_function(&ptr, "update"); */ + + RNA_parameter_list_create(&list, &ptr, func); + node->typeinfo->ext.call(NULL, &ptr, func, &list); + + RNA_parameter_list_free(&list); +} + +static void rna_Node_init(const bContext *C, PointerRNA *ptr) +{ + extern FunctionRNA rna_Node_init_func; + + bNode *node = (bNode *)ptr->data; + ParameterList list; + FunctionRNA *func; + + if (!node->typeinfo) + return; + + func = &rna_Node_init_func; /* RNA_struct_find_function(&ptr, "init"); */ + + RNA_parameter_list_create(&list, ptr, func); + node->typeinfo->ext.call((bContext *)C, ptr, func, &list); + + RNA_parameter_list_free(&list); +} + +static void rna_Node_copy(PointerRNA *ptr, struct bNode *copynode) +{ + extern FunctionRNA rna_Node_copy_func; + + bNode *node = (bNode *)ptr->data; + ParameterList list; + FunctionRNA *func; + + if (!node->typeinfo) + return; + + func = &rna_Node_copy_func; /* RNA_struct_find_function(&ptr, "copy"); */ + + RNA_parameter_list_create(&list, ptr, func); + RNA_parameter_set_lookup(&list, "node", ©node); + node->typeinfo->ext.call(NULL, ptr, func, &list); + + RNA_parameter_list_free(&list); +} + +static void rna_Node_free(PointerRNA *ptr) +{ + extern FunctionRNA rna_Node_free_func; + + bNode *node = (bNode *)ptr->data; + ParameterList list; + FunctionRNA *func; + + if (!node->typeinfo) + return; + + func = &rna_Node_free_func; /* RNA_struct_find_function(&ptr, "free"); */ + + RNA_parameter_list_create(&list, ptr, func); + node->typeinfo->ext.call(NULL, ptr, func, &list); + + RNA_parameter_list_free(&list); +} + +static void rna_Node_draw_buttons(struct uiLayout *layout, bContext *C, PointerRNA *ptr) +{ + extern FunctionRNA rna_Node_draw_buttons_func; + + bNode *node = (bNode *)ptr->data; + ParameterList list; + FunctionRNA *func; + + if (!node->typeinfo) + return; + + func = &rna_Node_draw_buttons_func; /* RNA_struct_find_function(&ptr, "draw_buttons"); */ + + RNA_parameter_list_create(&list, ptr, func); + RNA_parameter_set_lookup(&list, "context", &C); + RNA_parameter_set_lookup(&list, "layout", &layout); + node->typeinfo->ext.call(C, ptr, func, &list); + + RNA_parameter_list_free(&list); +} + +static void rna_Node_draw_buttons_ext(struct uiLayout *layout, bContext *C, PointerRNA *ptr) +{ + extern FunctionRNA rna_Node_draw_buttons_ext_func; + + bNode *node = (bNode *)ptr->data; + ParameterList list; + FunctionRNA *func; + + if (!node->typeinfo) + return; + + func = &rna_Node_draw_buttons_ext_func; /* RNA_struct_find_function(&ptr, "draw_buttons_ext"); */ + + RNA_parameter_list_create(&list, ptr, func); + RNA_parameter_set_lookup(&list, "context", &C); + RNA_parameter_set_lookup(&list, "layout", &layout); + node->typeinfo->ext.call(C, ptr, func, &list); + + RNA_parameter_list_free(&list); +} + +static int rna_Node_is_registered_node_type(StructRNA *type) +{ + return (RNA_struct_blender_type_get(type) != NULL); +} + +static void rna_Node_is_registered_node_type_runtime(bContext *UNUSED(C), ReportList *UNUSED(reports), PointerRNA *ptr, ParameterList *parms) +{ + int result = (RNA_struct_blender_type_get(ptr->type) != NULL); + RNA_parameter_set_lookup(parms, "result", &result); +} + +static void rna_Node_unregister(Main *UNUSED(bmain), StructRNA *type) +{ + bNodeType *nt= RNA_struct_blender_type_get(type); + + if(!nt) + return; + + RNA_struct_free_extension(type, &nt->ext); + + /* this also frees the allocated nt pointer, no MEM_free call needed! */ + nodeUnregisterType(nt); + + RNA_struct_free(&BLENDER_RNA, type); + + /* update while blender is running */ + WM_main_add_notifier(NC_NODE|NA_EDITED, NULL); +} + +/* Generic internal registration function. + * Can be used to implement callbacks for registerable RNA node subtypes. + */ +static bNodeType *rna_Node_register_base(Main *bmain, ReportList *reports, StructRNA *basetype, + void *data, const char *identifier, + StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free) +{ + bNodeType *nt, dummynt; + bNode dummynode; + PointerRNA dummyptr; + FunctionRNA *func; + PropertyRNA *parm; + int have_function[8]; + + /* setup dummy node & node type to store static properties in */ + memset(&dummynt, 0, sizeof(bNodeType)); + /* this does some additional initialization of default values */ + node_type_base_custom(&dummynt, identifier, "", 0, 0); + + memset(&dummynode, 0, sizeof(bNode)); + dummynode.typeinfo= &dummynt; + RNA_pointer_create(NULL, basetype, &dummynode, &dummyptr); + + /* validate the python class */ + if(validate(&dummyptr, data, have_function) != 0) + return NULL; + + if(strlen(identifier) >= sizeof(dummynt.idname)) { + BKE_reportf(reports, RPT_ERROR, "registering node class: '%s' is too long, maximum length is %d", + identifier, (int)sizeof(dummynt.idname)); + return NULL; + } + + /* check if we have registered this node type before, and remove it */ + nt= nodeTypeFind(dummynt.idname); + if(nt) + rna_Node_unregister(bmain, nt->ext.srna); + + /* create a new node type */ + nt= MEM_callocN(sizeof(bNodeType), "node type"); + memcpy(nt, &dummynt, sizeof(dummynt)); + /* make sure the node type struct is freed on unregister */ + nt->needs_free = 1; + + nt->ext.srna= RNA_def_struct_ptr(&BLENDER_RNA, nt->idname, basetype); + nt->ext.data= data; + nt->ext.call= call; + nt->ext.free= free; + RNA_struct_blender_type_set(nt->ext.srna, nt); + + RNA_def_struct_ui_text(nt->ext.srna, nt->ui_name, nt->ui_description); + RNA_def_struct_ui_icon(nt->ext.srna, nt->ui_icon); + + func = RNA_def_function_runtime(nt->ext.srna, "is_registered_node_type", rna_Node_is_registered_node_type_runtime); + RNA_def_function_ui_description(func, "True if a registered node type"); + RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_SELF_TYPE); + parm = RNA_def_boolean(func, "result", FALSE, "Result", ""); + RNA_def_function_return(func, parm); + + /* XXX bad level call! needed to initialize the basic draw functions ... */ + ED_init_custom_node_type(nt); + + nt->poll = (have_function[0]) ? rna_Node_poll : NULL; + nt->poll_instance = (have_function[1]) ? rna_Node_poll_instance : rna_Node_poll_instance_default; + nt->updatefunc = (have_function[2]) ? rna_Node_update_reg : NULL; + nt->initfunc_api = (have_function[3]) ? rna_Node_init : NULL; + nt->copyfunc_api = (have_function[4]) ? rna_Node_copy : NULL; + nt->freefunc_api = (have_function[5]) ? rna_Node_free : NULL; + nt->uifunc = (have_function[6]) ? rna_Node_draw_buttons : NULL; + nt->uifuncbut = (have_function[7]) ? rna_Node_draw_buttons_ext : NULL; + /* node buttons are only drawn if the options flag is set */ + if (nt->uifunc || nt->uifuncbut) + nt->flag |= NODE_OPTIONS; + + return nt; +} + +static StructRNA *rna_Node_register(Main *bmain, ReportList *reports, + void *data, const char *identifier, + StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free) +{ + bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_Node, data, identifier, validate, call, free); + if (!nt) + return NULL; + + nodeRegisterType(nt); + + /* update while blender is running */ + WM_main_add_notifier(NC_NODE|NA_EDITED, NULL); + + return nt->ext.srna; +} + +static StructRNA *rna_NodeGroup_register(Main *bmain, ReportList *reports, + void *data, const char *identifier, + StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free) +{ + bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_NodeGroup, data, identifier, validate, call, free); + if (!nt) + return NULL; + + nodeRegisterType(nt); + + /* update while blender is running */ + WM_main_add_notifier(NC_NODE|NA_EDITED, NULL); + + return nt->ext.srna; +} + +static StructRNA *rna_ShaderNode_register(Main *bmain, ReportList *reports, + void *data, const char *identifier, + StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free) +{ + bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_ShaderNode, data, identifier, validate, call, free); + if (!nt) + return NULL; + + nodeRegisterType(nt); + + /* update while blender is running */ + WM_main_add_notifier(NC_NODE|NA_EDITED, NULL); + + return nt->ext.srna; +} + +static StructRNA *rna_CompositorNode_register(Main *bmain, ReportList *reports, + void *data, const char *identifier, + StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free) +{ + bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_CompositorNode, data, identifier, validate, call, free); + if (!nt) + return NULL; + + nodeRegisterType(nt); + + /* update while blender is running */ + WM_main_add_notifier(NC_NODE|NA_EDITED, NULL); + + return nt->ext.srna; +} + +static StructRNA *rna_TextureNode_register(Main *bmain, ReportList *reports, + void *data, const char *identifier, + StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free) +{ + bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_TextureNode, data, identifier, validate, call, free); + if (!nt) + return NULL; + + nodeRegisterType(nt); + + /* update while blender is running */ + WM_main_add_notifier(NC_NODE|NA_EDITED, NULL); + + return nt->ext.srna; +} + +static IDProperty *rna_Node_idprops(PointerRNA *ptr, bool create) +{ + bNode *node = ptr->data; + + if (create && !node->prop) { + IDPropertyTemplate val = {0}; + node->prop = IDP_New(IDP_GROUP, &val, "RNA_Node ID properties"); } - return ""; + + return node->prop; } static void rna_Node_parent_set(PointerRNA *ptr, PointerRNA value) @@ -330,47 +1576,388 @@ static int rna_Node_parent_poll(PointerRNA *ptr, PointerRNA value) return TRUE; } -static StructRNA *rna_NodeSocket_refine(PointerRNA *ptr) +static void rna_Node_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr) { - bNodeSocket *sock = (bNodeSocket *)ptr->data; + bNodeTree *ntree = (bNodeTree*)ptr->id.data; + ED_node_tag_update_nodetree(bmain, ntree); +} + +static void rna_Node_socket_value_update(ID *id, bNode *UNUSED(node), bContext *C) +{ + ED_node_tag_update_nodetree(CTX_data_main(C), (bNodeTree *)id); +} + +static void rna_Node_select_set(PointerRNA *ptr, int value) +{ + bNode *node= (bNode*)ptr->data; + nodeSetSelected(node, value); +} + +static void rna_Node_name_set(PointerRNA *ptr, const char *value) +{ + bNodeTree *ntree = (bNodeTree*)ptr->id.data; + bNode *node = (bNode*)ptr->data; + char oldname[sizeof(node->name)]; - if (sock->default_value) { - /* This returns the refined socket type with the full definition - * of the default input value with type and subtype. - */ - - #define SUBTYPE(socktype, stypename, id, idname) \ - { \ - bNodeSocketValue##stypename *value = (bNodeSocketValue##stypename *)sock->default_value; \ - if (value->subtype == PROP_##id) \ - return &RNA_NodeSocket##stypename##idname; \ - } + /* make a copy of the old name first */ + BLI_strncpy(oldname, node->name, sizeof(node->name)); + /* set new name */ + BLI_strncpy_utf8(node->name, value, sizeof(node->name)); + + nodeUniqueName(ntree, node); + + /* fix all the animation data which may link to this */ + BKE_all_animdata_fix_paths_rename(NULL, "nodes", oldname, node->name); +} + +static int rna_Node_inputs_lookupstring(PointerRNA *ptr, const char *key, PointerRNA *r_ptr) +{ + bNode *node = (bNode *)ptr->data; + bNodeSocket *sock = nodeFindSocket(node, SOCK_IN, key); + RNA_pointer_create(ptr->id.data, &RNA_NodeSocket, sock, r_ptr); + return (sock != NULL); +} + +static int rna_Node_outputs_lookupstring(PointerRNA *ptr, const char *key, PointerRNA *r_ptr) +{ + bNode *node = (bNode *)ptr->data; + bNodeSocket *sock = nodeFindSocket(node, SOCK_OUT, key); + RNA_pointer_create(ptr->id.data, &RNA_NodeSocket, sock, r_ptr); + return (sock != NULL); +} + +static bNodeSocket *rna_Node_inputs_new(ID *id, bNode *node, ReportList *reports, const char *type, const char *name, const char *identifier) +{ + bNodeTree *ntree = (bNodeTree *)id; + bNodeSocket *sock; + + if (!node->typeinfo) { + BKE_reportf(reports, RPT_ERROR, "Node type %s of node %s undefined", node->idname, node->name); + return NULL; + } + + sock = nodeAddSocket(ntree, node, SOCK_IN, type, identifier, name); + + if (sock == NULL) { + BKE_report(reports, RPT_ERROR, "Unable to create socket"); + } + else { + ntreeUpdateTree(ntree); + WM_main_add_notifier(NC_NODE|NA_EDITED, ntree); + } + + return sock; +} + +static bNodeSocket *rna_Node_outputs_new(ID *id, bNode *node, ReportList *reports, const char *type, const char *name, const char *identifier) +{ + bNodeTree *ntree = (bNodeTree *)id; + bNodeSocket *sock; + + if (!node->typeinfo) { + BKE_reportf(reports, RPT_ERROR, "Node type %s of node %s undefined", node->idname, node->name); + return NULL; + } + + sock = nodeAddSocket(ntree, node, SOCK_OUT, type, identifier, name); + + if (sock == NULL) { + BKE_reportf(reports, RPT_ERROR, "Unable to create socket"); + } + else { + ntreeUpdateTree(ntree); + WM_main_add_notifier(NC_NODE|NA_EDITED, ntree); + } + + return sock; +} + +static void rna_Node_socket_remove(ID *id, bNode *node, ReportList *reports, bNodeSocket *sock) +{ + bNodeTree *ntree = (bNodeTree *)id; + + if (!node->typeinfo) { + BKE_reportf(reports, RPT_ERROR, "Node type %s of node %s undefined", node->idname, node->name); + return; + } + + if (BLI_findindex(&node->inputs, sock) == -1 && BLI_findindex(&node->outputs, sock) == -1) { + BKE_reportf(reports, RPT_ERROR, "Unable to locate socket '%s' in node", sock->identifier); + } + else { + nodeRemoveSocket(ntree, node, sock); - switch (sock->type) { - case SOCK_FLOAT: - NODE_DEFINE_SUBTYPES_FLOAT - break; - case SOCK_INT: - NODE_DEFINE_SUBTYPES_INT - break; - case SOCK_BOOLEAN: - return &RNA_NodeSocketBoolean; - case SOCK_VECTOR: - NODE_DEFINE_SUBTYPES_VECTOR - break; - case SOCK_STRING: - NODE_DEFINE_SUBTYPES_STRING - break; - case SOCK_RGBA: - return &RNA_NodeSocketRGBA; - case SOCK_SHADER: - return &RNA_NodeSocketShader; - } + ntreeUpdateTree(ntree); + WM_main_add_notifier(NC_NODE|NA_EDITED, ntree); + } +} + +static void rna_Node_inputs_clear(ID *id, bNode *node, ReportList *reports) +{ + bNodeTree *ntree = (bNodeTree *)id; + bNodeSocket *sock, *nextsock; + + if (!node->typeinfo) { + BKE_reportf(reports, RPT_ERROR, "Node type %s of node %s undefined", node->idname, node->name); + return; + } + + for (sock = node->inputs.first; sock; sock = nextsock) { + nextsock = sock->next; + nodeRemoveSocket(ntree, node, sock); + } + + ntreeUpdateTree(ntree); + WM_main_add_notifier(NC_NODE|NA_EDITED, ntree); +} + +static void rna_Node_outputs_clear(ID *id, bNode *node, ReportList *reports) +{ + bNodeTree *ntree = (bNodeTree *)id; + bNodeSocket *sock, *nextsock; + + if (!node->typeinfo) { + BKE_reportf(reports, RPT_ERROR, "Node type %s of node %s undefined", node->idname, node->name); + return; + } + + for (sock = node->outputs.first; sock; sock = nextsock) { + nextsock = sock->next; + nodeRemoveSocket(ntree, node, sock); + } + + ntreeUpdateTree(ntree); + WM_main_add_notifier(NC_NODE|NA_EDITED, ntree); +} + +static void rna_Node_width_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax) +{ + bNode *node = ptr->data; + if (node->typeinfo) { + *min = *softmin = node->typeinfo->minwidth; + *max = *softmax = node->typeinfo->maxwidth; + } + else { + *min = *softmin = 0.0f; + *max = *softmax = 0.0f; + } +} + +static void rna_Node_height_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax) +{ + bNode *node = ptr->data; + if (node->typeinfo) { + *min = *softmin = node->typeinfo->minheight; + *max = *softmax = node->typeinfo->maxheight; + } + else { + *min = *softmin = 0.0f; + *max = *softmax = 0.0f; + } +} + +static void rna_Node_bl_idname_get(PointerRNA *ptr, char *value) +{ + bNode *node= ptr->data; + if (node->typeinfo) + strcpy(value, node->typeinfo->idname); + else + strcpy(value, "UNDEFINED"); +} +static int rna_Node_bl_idname_length(PointerRNA *ptr) +{ + bNode *node = ptr->data; + if (node->typeinfo) + return strlen(node->typeinfo->idname); + else + return strlen("UNDEFINED"); +} + +static void rna_Node_bl_label_get(PointerRNA *ptr, char *value) +{ + bNode *node= ptr->data; + if (node->typeinfo) + strcpy(value, node->typeinfo->ui_name); + else + strcpy(value, "UNDEFINED"); +} +static int rna_Node_bl_label_length(PointerRNA *ptr) +{ + bNode *node = ptr->data; + if (node->typeinfo) + return strlen(node->typeinfo->ui_name); + else + return strlen("UNDEFINED"); +} + +static void rna_Node_bl_description_get(PointerRNA *ptr, char *value) +{ + bNode *node= ptr->data; + if (node->typeinfo) + strcpy(value, node->typeinfo->ui_description); + else + strcpy(value, ""); +} +static int rna_Node_bl_description_length(PointerRNA *ptr) +{ + bNode *node = ptr->data; + if (node->typeinfo) + return strlen(node->typeinfo->ui_description); + else + return strlen(""); +} + +static int rna_Node_bl_icon_get(PointerRNA *ptr) +{ + bNode *node = ptr->data; + if (node->typeinfo) + return node->typeinfo->ui_icon; + else + return ICON_NONE; +} + +static int rna_Node_bl_static_type_get(PointerRNA *ptr) +{ + bNode *node = ptr->data; + if (node->typeinfo) + return node->typeinfo->type; + else + return NODE_UNDEFINED; +} + + +/* ******** Node Socket ******** */ + +static void rna_NodeSocket_draw(bContext *C, struct uiLayout *layout, PointerRNA *ptr, PointerRNA *node_ptr) +{ + extern FunctionRNA rna_NodeSocket_draw_func; + + bNodeSocket *sock = (bNodeSocket *)ptr->data; + ParameterList list; + FunctionRNA *func; + + if (!sock->typeinfo) + return; + + func = &rna_NodeSocket_draw_func; /* RNA_struct_find_function(&ptr, "draw"); */ + + RNA_parameter_list_create(&list, ptr, func); + RNA_parameter_set_lookup(&list, "context", &C); + RNA_parameter_set_lookup(&list, "layout", &layout); + RNA_parameter_set_lookup(&list, "node", node_ptr); + sock->typeinfo->ext_socket.call(C, ptr, func, &list); + + RNA_parameter_list_free(&list); +} + +static void rna_NodeSocket_draw_color(bContext *C, PointerRNA *ptr, PointerRNA *node_ptr, float *r_color) +{ + extern FunctionRNA rna_NodeSocket_draw_color_func; + + bNodeSocket *sock = (bNodeSocket *)ptr->data; + ParameterList list; + FunctionRNA *func; + void *ret; + + if (!sock->typeinfo) + return; + + func = &rna_NodeSocket_draw_color_func; /* RNA_struct_find_function(&ptr, "draw_color"); */ + + RNA_parameter_list_create(&list, ptr, func); + RNA_parameter_set_lookup(&list, "context", &C); + RNA_parameter_set_lookup(&list, "node", node_ptr); + sock->typeinfo->ext_socket.call(C, ptr, func, &list); + + RNA_parameter_get_lookup(&list, "color", &ret); + copy_v4_v4(r_color, (float *)ret); + + RNA_parameter_list_free(&list); +} + +static void rna_NodeSocket_unregister(Main *UNUSED(bmain), StructRNA *type) +{ + bNodeSocketType *st= RNA_struct_blender_type_get(type); + if(!st) + return; + + RNA_struct_free_extension(type, &st->ext_socket); + + nodeUnregisterSocketType(st); + + RNA_struct_free(&BLENDER_RNA, type); + + /* update while blender is running */ + WM_main_add_notifier(NC_NODE|NA_EDITED, NULL); +} + +static StructRNA *rna_NodeSocket_register(Main *bmain, ReportList *reports, void *data, const char *identifier, + StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free) +{ + bNodeSocketType *st, dummyst; + bNodeSocket dummysock; + PointerRNA dummyptr; + int have_function[2]; + + /* setup dummy socket & socket type to store static properties in */ + memset(&dummyst, 0, sizeof(bNodeSocketType)); + + memset(&dummysock, 0, sizeof(bNodeSocket)); + dummysock.typeinfo= &dummyst; + RNA_pointer_create(NULL, &RNA_NodeSocket, &dummysock, &dummyptr); + + /* validate the python class */ + if(validate(&dummyptr, data, have_function) != 0) + return NULL; + + if(strlen(identifier) >= sizeof(dummyst.idname)) { + BKE_reportf(reports, RPT_ERROR, "registering node socket class: '%s' is too long, maximum length is %d", + identifier, (int)sizeof(dummyst.idname)); + return NULL; + } + + /* check if we have registered this socket type before */ + st= nodeSocketTypeFind(dummyst.idname); + if (!st) { + /* create a new node socket type */ + st= MEM_callocN(sizeof(bNodeSocketType), "node socket type"); + memcpy(st, &dummyst, sizeof(dummyst)); - #undef SUBTYPE + nodeRegisterSocketType(st); + } + + /* if RNA type is already registered, unregister first */ + if (st->ext_socket.srna) { + StructRNA *srna = st->ext_socket.srna; + RNA_struct_free_extension(srna, &st->ext_socket); + RNA_struct_free(&BLENDER_RNA, srna); } + st->ext_socket.srna= RNA_def_struct_ptr(&BLENDER_RNA, st->idname, &RNA_NodeSocket); + st->ext_socket.data= data; + st->ext_socket.call= call; + st->ext_socket.free= free; + RNA_struct_blender_type_set(st->ext_socket.srna, st); - return &RNA_NodeSocket; + /* XXX bad level call! needed to initialize the basic draw functions ... */ + ED_init_custom_node_socket_type(st); + + st->draw = (have_function[0]) ? rna_NodeSocket_draw : NULL; + st->draw_color = (have_function[1]) ? rna_NodeSocket_draw_color : NULL; + + /* update while blender is running */ + WM_main_add_notifier(NC_NODE|NA_EDITED, NULL); + + return st->ext_socket.srna; +} + +static StructRNA *rna_NodeSocket_refine(PointerRNA *ptr) +{ + bNodeSocket *sock = (bNodeSocket *)ptr->data; + + if (sock->typeinfo && sock->typeinfo->ext_socket.srna) + return sock->typeinfo->ext_socket.srna; + else + return &RNA_NodeSocket; } static char *rna_NodeSocket_path(PointerRNA *ptr) @@ -380,29 +1967,65 @@ static char *rna_NodeSocket_path(PointerRNA *ptr) bNode *node; int socketindex; - /* group sockets */ - socketindex = BLI_findindex(&ntree->inputs, sock); - if (socketindex != -1) - return BLI_sprintfN("inputs[%d]", socketindex); - - socketindex = BLI_findindex(&ntree->outputs, sock); - if (socketindex != -1) - return BLI_sprintfN("outputs[%d]", socketindex); - - /* node sockets */ - if (!nodeFindNode(ntree, sock, &node, NULL, NULL)) return NULL; + if (!nodeFindNode(ntree, sock, &node, &socketindex)) + return NULL; - socketindex = BLI_findindex(&node->inputs, sock); - if (socketindex != -1) + if (sock->in_out == SOCK_IN) return BLI_sprintfN("nodes[\"%s\"].inputs[%d]", node->name, socketindex); - - socketindex = BLI_findindex(&node->outputs, sock); - if (socketindex != -1) + else return BLI_sprintfN("nodes[\"%s\"].outputs[%d]", node->name, socketindex); return NULL; } +static IDProperty *rna_NodeSocket_idprops(PointerRNA *ptr, bool create) +{ + bNodeSocket *sock = ptr->data; + + if (create && !sock->prop) { + IDPropertyTemplate val = {0}; + sock->prop = IDP_New(IDP_GROUP, &val, "RNA_NodeSocket ID properties"); + } + + return sock->prop; +} + +static void rna_NodeSocket_bl_idname_get(PointerRNA *ptr, char *value) +{ + bNodeSocket *sock = ptr->data; + if (sock->typeinfo) + strcpy(value, sock->typeinfo->idname); + else + strcpy(value, "UNDEFINED"); +} +static int rna_NodeSocket_bl_idname_length(PointerRNA *ptr) +{ + bNodeSocket *sock = ptr->data; + if (sock->typeinfo) + return strlen(sock->typeinfo->idname); + else + return strlen("UNDEFINED"); +} + +static PointerRNA rna_NodeSocket_node_get(PointerRNA *ptr) +{ + bNodeTree *ntree = (bNodeTree*)ptr->id.data; + bNodeSocket *sock = (bNodeSocket *)ptr->data; + bNode *node; + PointerRNA r_ptr; + + nodeFindNode(ntree, sock, &node, NULL); + + RNA_pointer_create((ID *)ntree, &RNA_Node, node, &r_ptr); + return r_ptr; +} + +static void rna_NodeSocket_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr) +{ + bNodeTree *ntree = (bNodeTree*)ptr->id.data; + ED_node_tag_update_nodetree(bmain, ntree); +} + static void rna_NodeSocket_hide_set(PointerRNA *ptr, int value) { bNodeSocket *sock = (bNodeSocket *)ptr->data; @@ -417,151 +2040,334 @@ static void rna_NodeSocket_hide_set(PointerRNA *ptr, int value) sock->flag &= ~SOCK_HIDDEN; } -/* Button Set Funcs for Matte Nodes */ -static void rna_Matte_t1_set(PointerRNA *ptr, float value) + +static void rna_NodeSocketInterface_draw(bContext *C, struct uiLayout *layout, PointerRNA *ptr) { - bNode *node = (bNode *)ptr->data; - NodeChroma *chroma = node->storage; - - chroma->t1 = value; - - if (value < chroma->t2) - chroma->t2 = value; + extern FunctionRNA rna_NodeSocketInterface_draw_func; + + bNodeSocket *stemp = (bNodeSocket *)ptr->data; + ParameterList list; + FunctionRNA *func; + + if (!stemp->typeinfo) + return; + + func = &rna_NodeSocketInterface_draw_func; /* RNA_struct_find_function(&ptr, "draw"); */ + + RNA_parameter_list_create(&list, ptr, func); + RNA_parameter_set_lookup(&list, "context", &C); + RNA_parameter_set_lookup(&list, "layout", &layout); + stemp->typeinfo->ext_interface.call(C, ptr, func, &list); + + RNA_parameter_list_free(&list); } -static void rna_Matte_t2_set(PointerRNA *ptr, float value) +static void rna_NodeSocketInterface_draw_color(bContext *C, PointerRNA *ptr, float *r_color) { - bNode *node = (bNode *)ptr->data; - NodeChroma *chroma = node->storage; - - if (value > chroma->t1) - value = chroma->t1; - - chroma->t2 = value; + extern FunctionRNA rna_NodeSocketInterface_draw_color_func; + + bNodeSocket *sock = (bNodeSocket *)ptr->data; + ParameterList list; + FunctionRNA *func; + void *ret; + + if (!sock->typeinfo) + return; + + func = &rna_NodeSocketInterface_draw_color_func; /* RNA_struct_find_function(&ptr, "draw_color"); */ + + RNA_parameter_list_create(&list, ptr, func); + RNA_parameter_set_lookup(&list, "context", &C); + sock->typeinfo->ext_interface.call(C, ptr, func, &list); + + RNA_parameter_get_lookup(&list, "color", &ret); + copy_v4_v4(r_color, (float *)ret); + + RNA_parameter_list_free(&list); } -static void rna_distance_matte_t1_set(PointerRNA *ptr, float value) +static void rna_NodeSocketInterface_register_properties(bNodeTree *ntree, bNodeSocket *stemp, StructRNA *data_srna) { - bNode *node = (bNode *)ptr->data; - NodeChroma *chroma = node->storage; + extern FunctionRNA rna_NodeSocketInterface_register_properties_func; - chroma->t1 = value; + PointerRNA ptr; + ParameterList list; + FunctionRNA *func; + + if (!stemp->typeinfo) + return; + + RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr); + func = &rna_NodeSocketInterface_register_properties_func; /* RNA_struct_find_function(&ptr, "register_properties"); */ + + RNA_parameter_list_create(&list, &ptr, func); + RNA_parameter_set_lookup(&list, "data_rna_type", &data_srna); + stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list); + + RNA_parameter_list_free(&list); } -static void rna_distance_matte_t2_set(PointerRNA *ptr, float value) +static void rna_NodeSocketInterface_init_socket(bNodeTree *ntree, bNodeSocket *stemp, bNode *node, bNodeSocket *sock, const char *data_path) { - bNode *node = (bNode *)ptr->data; - NodeChroma *chroma = node->storage; + extern FunctionRNA rna_NodeSocketInterface_init_socket_func; - chroma->t2 = value; + PointerRNA ptr, node_ptr, sock_ptr; + ParameterList list; + FunctionRNA *func; + + if (!stemp->typeinfo) + return; + + RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr); + RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr); + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sock_ptr); + func = &rna_NodeSocketInterface_init_socket_func; /* RNA_struct_find_function(&ptr, "init_socket"); */ + + RNA_parameter_list_create(&list, &ptr, func); + RNA_parameter_set_lookup(&list, "node", &node_ptr); + RNA_parameter_set_lookup(&list, "socket", &sock_ptr); + RNA_parameter_set_lookup(&list, "data_path", &data_path); + stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list); + + RNA_parameter_list_free(&list); } -static void rna_difference_matte_t1_set(PointerRNA *ptr, float value) +static void rna_NodeSocketInterface_from_socket(bNodeTree *ntree, bNodeSocket *stemp, bNode *node, bNodeSocket *sock) { - bNode *node = (bNode *)ptr->data; - NodeChroma *chroma = node->storage; + extern FunctionRNA rna_NodeSocketInterface_from_socket_func; - chroma->t1 = value; + PointerRNA ptr, node_ptr, sock_ptr; + ParameterList list; + FunctionRNA *func; + + if (!stemp->typeinfo) + return; + + RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr); + RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr); + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sock_ptr); + func = &rna_NodeSocketInterface_from_socket_func; /* RNA_struct_find_function(&ptr, "from_socket"); */ + + RNA_parameter_list_create(&list, &ptr, func); + RNA_parameter_set_lookup(&list, "node", &node_ptr); + RNA_parameter_set_lookup(&list, "socket", &sock_ptr); + stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list); + + RNA_parameter_list_free(&list); } -static void rna_difference_matte_t2_set(PointerRNA *ptr, float value) +static void rna_NodeSocketInterface_unregister(Main *UNUSED(bmain), StructRNA *type) { - bNode *node = (bNode *)ptr->data; - NodeChroma *chroma = node->storage; + bNodeSocketType *st= RNA_struct_blender_type_get(type); + if(!st) + return; + + RNA_struct_free_extension(type, &st->ext_interface); + + RNA_struct_free(&BLENDER_RNA, type); + + /* update while blender is running */ + WM_main_add_notifier(NC_NODE|NA_EDITED, NULL); +} - chroma->t2 = value; +static StructRNA *rna_NodeSocketInterface_register(Main *bmain, ReportList *reports, void *data, const char *identifier, + StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free) +{ + bNodeSocketType *st, dummyst; + bNodeSocket dummysock; + PointerRNA dummyptr; + int have_function[5]; + + /* setup dummy socket & socket type to store static properties in */ + memset(&dummyst, 0, sizeof(bNodeSocketType)); + + memset(&dummysock, 0, sizeof(bNodeSocket)); + dummysock.typeinfo= &dummyst; + RNA_pointer_create(NULL, &RNA_NodeSocketInterface, &dummysock, &dummyptr); + + /* validate the python class */ + if (validate(&dummyptr, data, have_function) != 0) + return NULL; + + /* check if we have registered this socket type before */ + st= nodeSocketTypeFind(dummyst.idname); + if (st) { + /* basic socket type registered by a socket class before. */ + } + else { + /* create a new node socket type */ + st= MEM_callocN(sizeof(bNodeSocketType), "node socket type"); + memcpy(st, &dummyst, sizeof(dummyst)); + + nodeRegisterSocketType(st); + } + + /* if RNA type is already registered, unregister first */ + if (st->ext_interface.srna) { + StructRNA *srna = st->ext_interface.srna; + RNA_struct_free_extension(srna, &st->ext_interface); + RNA_struct_free(&BLENDER_RNA, srna); + } + st->ext_interface.srna= RNA_def_struct_ptr(&BLENDER_RNA, identifier, &RNA_NodeSocketInterface); + st->ext_interface.data= data; + st->ext_interface.call= call; + st->ext_interface.free= free; + RNA_struct_blender_type_set(st->ext_interface.srna, st); + + st->interface_draw = (have_function[0]) ? rna_NodeSocketInterface_draw : NULL; + st->interface_draw_color = (have_function[1]) ? rna_NodeSocketInterface_draw_color : NULL; + st->interface_register_properties = (have_function[2]) ? rna_NodeSocketInterface_register_properties : NULL; + st->interface_init_socket = (have_function[3]) ? rna_NodeSocketInterface_init_socket : NULL; + st->interface_from_socket = (have_function[4]) ? rna_NodeSocketInterface_from_socket : NULL; + + /* update while blender is running */ + WM_main_add_notifier(NC_NODE|NA_EDITED, NULL); + + return st->ext_interface.srna; } +static StructRNA *rna_NodeSocketInterface_refine(PointerRNA *ptr) +{ + bNodeSocket *sock = (bNodeSocket *)ptr->data; + + if (sock->typeinfo && sock->typeinfo->ext_interface.srna) + return sock->typeinfo->ext_interface.srna; + else + return &RNA_NodeSocketInterface; +} -static void rna_Node_scene_set(PointerRNA *ptr, PointerRNA value) +static char *rna_NodeSocketInterface_path(PointerRNA *ptr) { - bNode *node = (bNode *)ptr->data; + bNodeTree *ntree = (bNodeTree *)ptr->id.data; + bNodeSocket *sock = (bNodeSocket *)ptr->data; + int socketindex; + + socketindex = BLI_findindex(&ntree->inputs, sock); + if (socketindex != -1) + return BLI_sprintfN("inputs[%d]", socketindex); + + socketindex = BLI_findindex(&ntree->outputs, sock); + if (socketindex != -1) + return BLI_sprintfN("outputs[%d]", socketindex); + + return NULL; +} - if (node->id) { - id_us_min(node->id); - node->id = NULL; +static IDProperty *rna_NodeSocketInterface_idprops(PointerRNA *ptr, bool create) +{ + bNodeSocket *sock = ptr->data; + + if (create && !sock->prop) { + IDPropertyTemplate val = {0}; + sock->prop = IDP_New(IDP_GROUP, &val, "RNA_NodeSocketInterface ID properties"); } + + return sock->prop; +} - node->id = value.data; - - id_us_plus(node->id); +static void rna_NodeSocketInterface_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr) +{ + bNodeTree *ntree = ptr->id.data; + bNodeSocket *stemp = ptr->data; + + if (!stemp->typeinfo) + return; + + ntree->update |= NTREE_UPDATE_GROUP; + ntreeUpdateTree(ntree); + + ED_node_tag_update_nodetree(bmain, ntree); } +/* ******** Standard Node Socket Base Types ******** */ -static void node_update(Main *bmain, Scene *UNUSED(scene), bNodeTree *ntree, bNode *node) +static void rna_NodeSocketStandard_draw(ID *id, bNodeSocket *sock, struct bContext *C, struct uiLayout *layout, PointerRNA *nodeptr) { - ED_node_generic_update(bmain, ntree, node); + PointerRNA ptr; + RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr); + sock->typeinfo->draw(C, layout, &ptr, nodeptr); } -static void rna_Node_update(Main *bmain, Scene *scene, PointerRNA *ptr) +static void rna_NodeSocketStandard_draw_color(ID *id, bNodeSocket *sock, struct bContext *C, PointerRNA *nodeptr, float *r_color) { - bNodeTree *ntree = (bNodeTree *)ptr->id.data; - bNode *node = (bNode *)ptr->data; - - node_update(bmain, scene, ntree, node); + PointerRNA ptr; + RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr); + sock->typeinfo->draw_color(C, &ptr, nodeptr, r_color); } -static void rna_Node_tex_image_update(Main *bmain, Scene *scene, PointerRNA *ptr) +static void rna_NodeSocketInterfaceStandard_draw(ID *id, bNodeSocket *sock, struct bContext *C, struct uiLayout *layout) { - bNodeTree *ntree = (bNodeTree *)ptr->id.data; - bNode *node = (bNode *)ptr->data; + PointerRNA ptr; + RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr); + sock->typeinfo->interface_draw(C, layout, &ptr); +} - node_update(bmain, scene, ntree, node); - WM_main_add_notifier(NC_IMAGE, NULL); +static void rna_NodeSocketInterfaceStandard_draw_color(ID *id, bNodeSocket *sock, struct bContext *C, float *r_color) +{ + PointerRNA ptr; + RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr); + sock->typeinfo->interface_draw_color(C, &ptr, r_color); } -static void rna_Node_material_update(Main *bmain, Scene *scene, PointerRNA *ptr) +/* using a context update function here, to avoid searching the node if possible */ +static void rna_NodeSocketStandard_value_update(struct bContext *C, PointerRNA *ptr) { - bNodeTree *ntree = (bNodeTree *)ptr->id.data; - bNode *node = (bNode *)ptr->data; + bNode *node; + + /* default update */ + rna_NodeSocket_update(CTX_data_main(C), CTX_data_scene(C), ptr); + + /* try to use node from context, faster */ + node = CTX_data_pointer_get(C, "node").data; + if (!node) { + bNodeTree *ntree = ptr->id.data; + bNodeSocket *sock = ptr->data; + + /* fall back to searching node in the tree */ + nodeFindNode(ntree, sock, &node, NULL); + } + + if (node) + nodeSynchronizeID(node, true); +} - if (node->id) - nodeSetActive(ntree, node); - node_update(bmain, scene, ntree, node); +/* ******** Node Types ******** */ + +static void rna_CompositorNode_tag_need_exec(bNode *node) +{ + node->need_exec = TRUE; } -static void rna_NodeTree_update(Main *bmain, Scene *scene, PointerRNA *ptr) +static void rna_Node_tex_image_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr) { bNodeTree *ntree = (bNodeTree *)ptr->id.data; - /* when using border, make it so no old data from outside of - * border is hanging around - * ideally shouldn't be in RNA callback, but how to teach - * compo to only clear frame when border usage is actually - * toggling - */ - if (ntree->flag & NTREE_VIEWER_BORDER) { - Image *ima = BKE_image_verify_viewer(IMA_TYPE_COMPOSITE, "Viewer Node"); - void *lock; - ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock); - - if (ibuf) { - if (ibuf->rect) - memset(ibuf->rect, 0, 4 * ibuf->x * ibuf->y); - - if (ibuf->rect_float) - memset(ibuf->rect_float, 0, 4 * ibuf->x * ibuf->y * sizeof(float)); + ED_node_tag_update_nodetree(bmain, ntree); + WM_main_add_notifier(NC_IMAGE, NULL); +} - ibuf->userflags |= IB_DISPLAY_BUFFER_INVALID; - } +static void rna_Node_material_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr) +{ + bNodeTree *ntree = (bNodeTree *)ptr->id.data; + bNode *node = (bNode *)ptr->data; - BKE_image_release_ibuf(ima, ibuf, lock); - } + if (node->id) + nodeSetActive(ntree, node); - WM_main_add_notifier(NC_NODE | NA_EDITED, NULL); - WM_main_add_notifier(NC_SCENE | ND_NODES, &ntree->id); + ED_node_tag_update_nodetree(bmain, ntree); } -static void rna_NodeGroup_update(Main *bmain, Scene *scene, PointerRNA *ptr) +static void rna_NodeGroup_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr) { bNodeTree *ntree = (bNodeTree *)ptr->id.data; bNode *node = (bNode *)ptr->data; - ntreeUpdateTree((bNodeTree *)node->id); + if (node->id) + ntreeUpdateTree((bNodeTree *)node->id); - node_update(bmain, scene, ntree, node); + ED_node_tag_update_nodetree(bmain, ntree); } static int rna_NodeGroup_node_tree_poll(PointerRNA *ptr, const PointerRNA value) @@ -573,91 +2379,99 @@ static int rna_NodeGroup_node_tree_poll(PointerRNA *ptr, const PointerRNA value) return (ngroup->type == ntree->type); } -static void rna_Node_name_set(PointerRNA *ptr, const char *value) + +static StructRNA *rna_NodeGroup_interface_typef(PointerRNA *ptr) { - bNodeTree *ntree = (bNodeTree *)ptr->id.data; - bNode *node = (bNode *)ptr->data; - char oldname[sizeof(node->name)]; - - /* make a copy of the old name first */ - BLI_strncpy(oldname, node->name, sizeof(node->name)); - /* set new name */ - BLI_strncpy_utf8(node->name, value, sizeof(node->name)); - - nodeUniqueName(ntree, node); - - /* fix all the animation data which may link to this */ - BKE_all_animdata_fix_paths_rename(NULL, "nodes", oldname, node->name); + bNode *node = ptr->data; + bNodeTree *ngroup = (bNodeTree *)node->id; + + if (ngroup) { + StructRNA *srna = ntreeInterfaceTypeGet(ngroup, TRUE); + if (srna) + return srna; + } + return &RNA_PropertyGroup; } -static void rna_Node_width_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax) +static StructRNA *rna_NodeGroupInputOutput_interface_typef(PointerRNA *ptr) { - bNode *node = ptr->data; - *min = *softmin = node->typeinfo->minwidth; - *max = *softmax = node->typeinfo->maxwidth; + bNodeTree *ntree = ptr->id.data; + + if (ntree) { + StructRNA *srna = ntreeInterfaceTypeGet(ntree, TRUE); + if (srna) + return srna; + } + return &RNA_PropertyGroup; } -static void rna_Node_height_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax) +static void rna_distance_matte_t1_set(PointerRNA *ptr, float value) { - bNode *node = ptr->data; - *min = *softmin = node->typeinfo->minheight; - *max = *softmax = node->typeinfo->maxheight; + bNode *node = (bNode *)ptr->data; + NodeChroma *chroma = node->storage; + + chroma->t1 = value; } -static void rna_NodeSocket_update(Main *bmain, Scene *scene, PointerRNA *ptr) +static void rna_distance_matte_t2_set(PointerRNA *ptr, float value) { - bNodeTree *ntree = (bNodeTree *)ptr->id.data; - bNodeSocket *sock = (bNodeSocket *)ptr->data; - bNode *node; - - if (nodeFindNode(ntree, sock, &node, NULL, NULL)) - node_update(bmain, scene, ntree, node); + bNode *node = (bNode *)ptr->data; + NodeChroma *chroma = node->storage; + + chroma->t2 = value; } -static void rna_NodeGroupSocket_update(Main *bmain, Scene *scene, PointerRNA *ptr) +static void rna_difference_matte_t1_set(PointerRNA *ptr, float value) { - bNodeTree *ntree = (bNodeTree *)ptr->id.data; - bNodeSocket *sock = (bNodeSocket *)ptr->data; - bNode *node; - - ntreeUpdateTree(ntree); - - if (nodeFindNode(ntree, sock, &node, NULL, NULL)) - node_update(bmain, scene, ntree, node); + bNode *node = (bNode *)ptr->data; + NodeChroma *chroma = node->storage; + + chroma->t1 = value; } -#if 0 /* UNUSED */ -static void rna_NodeLink_update(Main *bmain, Scene *scene, PointerRNA *ptr) +static void rna_difference_matte_t2_set(PointerRNA *ptr, float value) { - bNodeTree *ntree = (bNodeTree *)ptr->id.data; + bNode *node = (bNode *)ptr->data; + NodeChroma *chroma = node->storage; - ntree->update |= NTREE_UPDATE_LINKS; - ntreeUpdateTree(ntree); + chroma->t2 = value; } -#endif -static void rna_NodeSocketInt_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax) +/* Button Set Funcs for Matte Nodes */ +static void rna_Matte_t1_set(PointerRNA *ptr, float value) { - bNodeSocket *sock = (bNodeSocket *)ptr->data; - bNodeSocketValueInt *val = (bNodeSocketValueInt *)sock->default_value; - *softmin = val->min; - *softmax = val->max; + bNode *node = (bNode *)ptr->data; + NodeChroma *chroma = node->storage; + + chroma->t1 = value; + + if (value < chroma->t2) + chroma->t2 = value; } -static void rna_NodeSocketFloat_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax) +static void rna_Matte_t2_set(PointerRNA *ptr, float value) { - bNodeSocket *sock = (bNodeSocket *)ptr->data; - bNodeSocketValueFloat *val = (bNodeSocketValueFloat *)sock->default_value; - *softmin = val->min; - *softmax = val->max; + bNode *node = (bNode *)ptr->data; + NodeChroma *chroma = node->storage; + + if (value > chroma->t1) + value = chroma->t1; + + chroma->t2 = value; } -static void rna_NodeSocketVector_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax) +static void rna_Node_scene_set(PointerRNA *ptr, PointerRNA value) { - bNodeSocket *sock = (bNodeSocket *)ptr->data; - bNodeSocketValueVector *val = (bNodeSocketValueVector *)sock->default_value; - *softmin = val->min; - *softmax = val->max; + bNode *node = (bNode *)ptr->data; + + if (node->id) { + id_us_min(node->id); + node->id = NULL; + } + + node->id = value.data; + + id_us_plus(node->id); } static void rna_Node_image_layer_update(Main *bmain, Scene *scene, PointerRNA *ptr) @@ -741,35 +2555,35 @@ static EnumPropertyItem *rna_Node_channel_itemf(bContext *UNUSED(C), PointerRNA switch (node->custom1) { case CMP_NODE_CHANNEL_MATTE_CS_RGB: - tmp.identifier = "R"; tmp.name = "R"; tmp.value = 1; + tmp.identifier = "R"; tmp.name= "R"; tmp.value= 1; RNA_enum_item_add(&item, &totitem, &tmp); - tmp.identifier = "G"; tmp.name = "G"; tmp.value = 2; + tmp.identifier = "G"; tmp.name= "G"; tmp.value= 2; RNA_enum_item_add(&item, &totitem, &tmp); - tmp.identifier = "B"; tmp.name = "B"; tmp.value = 3; + tmp.identifier = "B"; tmp.name= "B"; tmp.value= 3; RNA_enum_item_add(&item, &totitem, &tmp); break; case CMP_NODE_CHANNEL_MATTE_CS_HSV: - tmp.identifier = "H"; tmp.name = "H"; tmp.value = 1; + tmp.identifier = "H"; tmp.name= "H"; tmp.value= 1; RNA_enum_item_add(&item, &totitem, &tmp); - tmp.identifier = "S"; tmp.name = "S"; tmp.value = 2; + tmp.identifier = "S"; tmp.name= "S"; tmp.value= 2; RNA_enum_item_add(&item, &totitem, &tmp); - tmp.identifier = "V"; tmp.name = "V"; tmp.value = 3; + tmp.identifier = "V"; tmp.name= "V"; tmp.value= 3; RNA_enum_item_add(&item, &totitem, &tmp); break; case CMP_NODE_CHANNEL_MATTE_CS_YUV: - tmp.identifier = "Y"; tmp.name = "Y"; tmp.value = 1; + tmp.identifier = "Y"; tmp.name= "Y"; tmp.value= 1; RNA_enum_item_add(&item, &totitem, &tmp); - tmp.identifier = "G"; tmp.name = "U"; tmp.value = 2; + tmp.identifier = "G"; tmp.name= "U"; tmp.value= 2; RNA_enum_item_add(&item, &totitem, &tmp); - tmp.identifier = "V"; tmp.name = "V"; tmp.value = 3; + tmp.identifier = "V"; tmp.name= "V"; tmp.value= 3; RNA_enum_item_add(&item, &totitem, &tmp); break; case CMP_NODE_CHANNEL_MATTE_CS_YCC: - tmp.identifier = "Y"; tmp.name = "Y"; tmp.value = 1; + tmp.identifier = "Y"; tmp.name= "Y"; tmp.value= 1; RNA_enum_item_add(&item, &totitem, &tmp); - tmp.identifier = "CB"; tmp.name = "Cr"; tmp.value = 2; + tmp.identifier = "CB"; tmp.name= "Cr"; tmp.value= 2; RNA_enum_item_add(&item, &totitem, &tmp); - tmp.identifier = "CR"; tmp.name = "Cb"; tmp.value = 3; + tmp.identifier = "CR"; tmp.name= "Cb"; tmp.value= 3; RNA_enum_item_add(&item, &totitem, &tmp); break; default: @@ -782,274 +2596,13 @@ static EnumPropertyItem *rna_Node_channel_itemf(bContext *UNUSED(C), PointerRNA return item; } -static PointerRNA rna_NodeTree_active_node_get(PointerRNA *ptr) -{ - bNodeTree *ntree = (bNodeTree *)ptr->data; - bNode *node = nodeGetActive(ntree); - return rna_pointer_inherit_refine(ptr, &RNA_Node, node); -} - -static void rna_NodeTree_active_node_set(PointerRNA *ptr, PointerRNA value) -{ - bNodeTree *ntree = (bNodeTree *)ptr->data; - bNode *node = (bNode *)value.data; - if (node && BLI_findindex(&ntree->nodes, node) != -1) - nodeSetActive(ntree, node); - else - nodeClearActive(ntree); -} - -static bNode *rna_NodeTree_node_new(bNodeTree *ntree, bContext *C, ReportList *reports, - int type, bNodeTree *group) -{ - bNode *node; - bNodeTemplate ntemp; - - if (type == NODE_GROUP && group == NULL) { - BKE_report(reports, RPT_ERROR, "Node type 'GROUP' missing group argument"); - return NULL; - } - - ntemp.type = type; - ntemp.ngroup = group; - ntemp.scene = CTX_data_scene(C); - ntemp.main = CTX_data_main(C); - node = nodeAddNode(ntree, &ntemp); - - if (node == NULL) { - BKE_report(reports, RPT_ERROR, "Unable to create node"); - } - else { - ntreeUpdateTree(ntree); /* update group node socket links*/ - nodeUpdate(ntree, node); - WM_main_add_notifier(NC_NODE | NA_EDITED, ntree); - - if (group) - id_us_plus(&group->id); - } - - return node; -} - -static bNode *rna_NodeTree_node_composite_new(bNodeTree *ntree, bContext *C, ReportList *reports, - int type, bNodeTree *group) -{ - /* raises error on failure */ - bNode *node = rna_NodeTree_node_new(ntree, C, reports, type, group); - - if (node) { - if (ELEM4(node->type, CMP_NODE_COMPOSITE, CMP_NODE_DEFOCUS, CMP_NODE_OUTPUT_FILE, CMP_NODE_R_LAYERS)) { - /* annoying, find the node tree we are in, scene can be NULL */ - Scene *scene; - for (scene = CTX_data_main(C)->scene.first; scene; scene = scene->id.next) { - if (scene->nodetree == ntree) { - break; - } - } - node->id = (ID *)scene; - id_us_plus(node->id); - } - - ntreeCompositForceHidden(ntree, CTX_data_scene(C)); - ntreeUpdateTree(ntree); - } - - return node; -} - -static bNode *rna_NodeTree_node_texture_new(bNodeTree *ntree, bContext *C, ReportList *reports, - int type, bNodeTree *group) -{ - /* raises error on failure */ - bNode *node = rna_NodeTree_node_new(ntree, C, reports, type, group); - - if (node) { - ntreeTexCheckCyclics(ntree); - } - - return node; -} - -static void rna_NodeTree_node_remove(bNodeTree *ntree, ReportList *reports, PointerRNA *node_ptr) -{ - bNode *node = node_ptr->data; - if (BLI_findindex(&ntree->nodes, node) == -1) { - BKE_reportf(reports, RPT_ERROR, "Unable to locate node '%s' in node tree", node->name); - return; - } - - id_us_min(node->id); - nodeFreeNode(ntree, node); - RNA_POINTER_INVALIDATE(node_ptr); - - ntreeUpdateTree(ntree); /* update group node socket links */ - WM_main_add_notifier(NC_NODE | NA_EDITED, ntree); -} - -static void rna_NodeTree_node_clear(bNodeTree *ntree) -{ - bNode *node = ntree->nodes.first; - - while (node) { - bNode *next_node = node->next; - - if (node->id) - id_us_min(node->id); - - nodeFreeNode(ntree, node); - - node = next_node; - } - - ntreeUpdateTree(ntree); /* update group node socket links*/ - - WM_main_add_notifier(NC_NODE | NA_EDITED, ntree); -} - -static bNodeLink *rna_NodeTree_link_new(bNodeTree *ntree, ReportList *reports, - bNodeSocket *fromsock, bNodeSocket *tosock) -{ - bNodeLink *ret; - bNode *fromnode = NULL, *tonode = NULL; - int from_in_out, to_in_out; - - nodeFindNode(ntree, fromsock, &fromnode, NULL, &from_in_out); - nodeFindNode(ntree, tosock, &tonode, NULL, &to_in_out); - - if (&from_in_out == &to_in_out) { - BKE_report(reports, RPT_ERROR, "Same input/output direction of sockets"); - return NULL; - } - - /* unlink node input socket */ - if (to_in_out == SOCK_IN) - nodeRemSocketLinks(ntree, tosock); - else - nodeRemSocketLinks(ntree, fromsock); - - ret = nodeAddLink(ntree, fromnode, fromsock, tonode, tosock); - - if (ret) { - if (tonode) - nodeUpdate(ntree, tonode); - - ntreeUpdateTree(ntree); - - WM_main_add_notifier(NC_NODE | NA_EDITED, ntree); - } - - return ret; -} - -static void rna_NodeTree_link_remove(bNodeTree *ntree, ReportList *reports, PointerRNA *link_ptr) -{ - bNodeLink *link = link_ptr->data; - if (BLI_findindex(&ntree->links, link) == -1) { - BKE_report(reports, RPT_ERROR, "Unable to locate link in node tree"); - return; - } - - nodeRemLink(ntree, link); - RNA_POINTER_INVALIDATE(link_ptr); - - ntreeUpdateTree(ntree); - WM_main_add_notifier(NC_NODE | NA_EDITED, ntree); -} - -static void rna_NodeTree_link_clear(bNodeTree *ntree) -{ - bNodeLink *link = ntree->links.first; - - while (link) { - bNodeLink *next_link = link->next; - - nodeRemLink(ntree, link); - - link = next_link; - } - ntreeUpdateTree(ntree); - - WM_main_add_notifier(NC_NODE | NA_EDITED, ntree); -} - -static bNodeSocket *rna_NodeTree_input_new(bNodeTree *ntree, ReportList *UNUSED(reports), const char *name, int type) -{ - /* XXX should check if tree is a group here! no good way to do this currently. */ - bNodeSocket *gsock = node_group_add_socket(ntree, name, type, SOCK_IN); - - ntree->update |= NTREE_UPDATE_GROUP_IN; - ntreeUpdateTree(ntree); - WM_main_add_notifier(NC_NODE | NA_EDITED, ntree); - return gsock; -} - -static bNodeSocket *rna_NodeTree_output_new(bNodeTree *ntree, ReportList *UNUSED(reports), const char *name, int type) -{ - /* XXX should check if tree is a group here! no good way to do this currently. */ - bNodeSocket *gsock = node_group_add_socket(ntree, name, type, SOCK_OUT); - - ntree->update |= NTREE_UPDATE_GROUP_OUT; - ntreeUpdateTree(ntree); - WM_main_add_notifier(NC_NODE | NA_EDITED, ntree); - return gsock; -} - -static bNodeSocket *rna_NodeTree_input_expose(bNodeTree *ntree, ReportList *reports, bNodeSocket *sock, int add_link) -{ - bNode *node; - bNodeSocket *gsock; - int index, in_out; - - if (!nodeFindNode(ntree, sock, &node, &index, &in_out)) - BKE_report(reports, RPT_ERROR, "Unable to locate socket in node tree"); - else if (in_out != SOCK_IN) - BKE_report(reports, RPT_ERROR, "Socket is not an input"); - else { - /* XXX should check if tree is a group here! no good way to do this currently. */ - gsock = node_group_add_socket(ntree, sock->name, sock->type, SOCK_IN); - if (add_link) - nodeAddLink(ntree, NULL, gsock, node, sock); - - ntree->update |= NTREE_UPDATE_GROUP_IN; - ntreeUpdateTree(ntree); - WM_main_add_notifier(NC_NODE | NA_EDITED, ntree); - return gsock; - } - return NULL; -} - -static bNodeSocket *rna_NodeTree_output_expose(bNodeTree *ntree, ReportList *reports, bNodeSocket *sock, int add_link) -{ - bNode *node; - bNodeSocket *gsock; - int index, in_out; - - if (!nodeFindNode(ntree, sock, &node, &index, &in_out)) - BKE_report(reports, RPT_ERROR, "Unable to locate socket in node tree"); - else if (in_out != SOCK_OUT) - BKE_report(reports, RPT_ERROR, "Socket is not an output"); - else { - /* XXX should check if tree is a group here! no good way to do this currently. */ - gsock = node_group_add_socket(ntree, sock->name, sock->type, SOCK_OUT); - if (add_link) - nodeAddLink(ntree, node, sock, NULL, gsock); - - ntree->update |= NTREE_UPDATE_GROUP_OUT; - ntreeUpdateTree(ntree); - WM_main_add_notifier(NC_NODE | NA_EDITED, ntree); - return gsock; - } - return NULL; -} - -static void rna_Image_Node_update_id(Main *bmain, Scene *scene, PointerRNA *ptr) +static void rna_Image_Node_update_id(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr) { bNodeTree *ntree = (bNodeTree *)ptr->id.data; bNode *node = (bNode *)ptr->data; node->update |= NODE_UPDATE_ID; - node_update(bmain, scene, ntree, node); - node->update &= ~NODE_UPDATE_ID; + nodeUpdate(ntree, node); /* to update image node sockets */ } static void rna_Mapping_Node_update(Main *bmain, Scene *scene, PointerRNA *ptr) @@ -1073,6 +2626,8 @@ static PointerRNA rna_NodeOutputFile_slot_file_get(CollectionPropertyIterator *i return ptr; } +/* ******** Node Socket Types ******** */ + static PointerRNA rna_NodeOutputFile_slot_layer_get(CollectionPropertyIterator *iter) { PointerRNA ptr; @@ -1126,53 +2681,6 @@ static void rna_NodeOutputFileSlotLayer_name_set(PointerRNA *ptr, const char *va } } -static bNodeSocket *rna_ShaderNodeScript_find_socket(bNode *node, const char *name, int is_output) -{ - bNodeSocket *sock; - - if (is_output) { - for (sock = node->outputs.first; sock; sock = sock->next) { - if (strcmp(sock->name, name) == 0) { - return sock; - } - } - } - else { - for (sock = node->inputs.first; sock; sock = sock->next) { - if (strcmp(sock->name, name) == 0) { - return sock; - } - } - } - - return NULL; -} - -static void rna_ShaderNodeScript_remove_socket(ID *id, bNode *node, bNodeSocket *sock) -{ - bNodeTree *ntree = (bNodeTree *)id; - - nodeRemoveSocket(ntree, node, sock); - - ED_node_generic_update(G.main, ntree, node); -} - -static bNodeSocket *rna_ShaderNodeScript_add_socket(ID *id, bNode *node, const char *name, int type, int is_output) -{ - bNodeTree *ntree = (bNodeTree *)id; - bNodeSocket *sock; - - /* replace existing socket with the same name, to keep it unique */ - sock = rna_ShaderNodeScript_find_socket(node, name, is_output); - if (sock) - nodeRemoveSocket(ntree, node, sock); - sock = nodeAddSocket(ntree, node, (is_output ? SOCK_OUT : SOCK_IN), name, type); - - ED_node_generic_update(G.main, ntree, node); - - return sock; -} - static void rna_ShaderNodeScript_mode_set(PointerRNA *ptr, int value) { bNode *node = (bNode *)ptr->data; @@ -1236,19 +2744,6 @@ static void rna_ShaderNodeScript_bytecode_set(PointerRNA *ptr, const char *value nss->bytecode = NULL; } -static IDProperty *rna_ShaderNodeScript_idprops(PointerRNA *ptr, bool create) -{ - bNode *node = (bNode *)ptr->data; - NodeShaderScript *nss = node->storage; - - if (create && !nss->prop) { - IDPropertyTemplate val = {0}; - nss->prop = IDP_New(IDP_GROUP, &val, "RNA_ShaderNodeScript ID properties"); - } - - return nss->prop; -} - static void rna_ShaderNodeScript_update(Main *bmain, Scene *scene, PointerRNA *ptr) { bNodeTree *ntree = (bNodeTree *)ptr->id.data; @@ -1262,7 +2757,7 @@ static void rna_ShaderNodeScript_update(Main *bmain, Scene *scene, PointerRNA *p RE_engine_free(engine); } - node_update(bmain, scene, ntree, node); + ED_node_tag_update_nodetree(bmain, ntree); } #else @@ -1311,139 +2806,36 @@ static EnumPropertyItem node_script_mode_items[] = { {0, NULL, 0, NULL, NULL} }; -#define MaxNodes 50000 - -enum -{ - Category_GroupNode, - Category_LayoutNode, - Category_ShaderNode, - Category_CompositorNode, - Category_TextureNode, -}; - -typedef struct NodeInfo { - int defined; - int category; - const char *enum_name; - const char *struct_name; - const char *base_name; - int icon; - const char *ui_name; - const char *ui_desc; -} NodeInfo; - -static NodeInfo nodes[MaxNodes]; - -static void reg_node(int ID, int category, const char *enum_name, const char *struct_name, - const char *base_name, const char *ui_name, const char *ui_desc) -{ - NodeInfo *ni = nodes + ID; - - ni->defined = 1; - ni->category = category; - ni->enum_name = enum_name; - ni->struct_name = struct_name; - ni->base_name = base_name; - ni->ui_name = ui_name; - ni->ui_desc = ui_desc; -} - -static void init(void) -{ - memset(nodes, 0, sizeof(nodes)); - - #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \ - reg_node(ID, Category_##Category, EnumName, STRINGIFY_ARG(Category##StructName), #Category, UIName, UIDesc); - - #include "rna_nodetree_types.h" - - reg_node(NODE_GROUP, Category_GroupNode, "GROUP", "NodeGroup", "SpecialNode", "Group", ""); - reg_node(NODE_FRAME, Category_LayoutNode, "FRAME", "NodeFrame", "SpecialNode", "Frame", ""); - reg_node(NODE_REROUTE, Category_LayoutNode, "REROUTE", "NodeReroute", "SpecialNode", "Reroute", ""); -} +/* -- Common nodes ---------------------------------------------------------- */ -static StructRNA *def_node(BlenderRNA *brna, int node_id) +static void def_group_input(StructRNA *srna) { - StructRNA *srna; - FunctionRNA *func; - PropertyRNA *parm; - NodeInfo *node = nodes + node_id; - - srna = RNA_def_struct(brna, node->struct_name, node->base_name); - RNA_def_struct_ui_text(srna, node->ui_name, node->ui_desc); - RNA_def_struct_sdna(srna, "bNode"); - - func = RNA_def_function(srna, "get_node_type", "rna_Node_get_node_type"); - RNA_def_function_ui_description(func, "Get the identifier of the node type"); - RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_SELF_TYPE); - parm = RNA_def_string(func, "result", "", 0, "Result", ""); - RNA_def_function_return(func, parm); + PropertyRNA *prop; - return srna; + prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE); + RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_NodeGroupInputOutput_interface_typef", NULL); + RNA_def_property_struct_type(prop, "PropertyGroup"); + RNA_def_property_flag(prop, PROP_IDPROPERTY); + RNA_def_property_ui_text(prop, "Interface", "Interface socket data"); } -static void alloc_node_type_items(EnumPropertyItem *items, int category) +static void def_group_output(StructRNA *srna) { - int i; - int count = 4; - EnumPropertyItem *item = items; - - for (i = 0; i < MaxNodes; i++) - if (nodes[i].defined && nodes[i].category == category) - count++; - - /*item = items = MEM_callocN(count * sizeof(EnumPropertyItem), "alloc_node_type_items");*/ - - for (i = 0; i < MaxNodes; i++) { - NodeInfo *node = nodes + i; - if (node->defined && node->category == category) { - item->value = i; - item->identifier = node->enum_name; - item->icon = node->icon; - item->name = node->ui_name; - item->description = node->ui_desc; - - item++; - } - } - - item->value = NODE_GROUP; - item->identifier = "GROUP"; - item->icon = 0; - item->name = "Group"; - item->description = ""; - - item++; - - item->value = NODE_REROUTE; - item->identifier = "REROUTE"; - item->icon = 0; - item->name = "Reroute"; - item->description = ""; - - item++; - - item->value = NODE_FRAME; - item->identifier = "FRAME"; - item->icon = 0; - item->name = "Frame"; - item->description = ""; - - item++; - - /* NOTE!, increase 'count' when adding items here */ + PropertyRNA *prop; - memset(item, 0, sizeof(EnumPropertyItem)); + prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE); + RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_NodeGroupInputOutput_interface_typef", NULL); + RNA_def_property_struct_type(prop, "PropertyGroup"); + RNA_def_property_flag(prop, PROP_IDPROPERTY); + RNA_def_property_ui_text(prop, "Interface", "Interface socket data"); } - -/* -- Common nodes ---------------------------------------------------------- */ - static void def_group(StructRNA *srna) { PropertyRNA *prop; + RNA_def_struct_register_funcs(srna, "rna_NodeGroup_register", "rna_Node_unregister", NULL); + prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_sdna(prop, NULL, "id"); RNA_def_property_struct_type(prop, "NodeTree"); @@ -1451,6 +2843,18 @@ static void def_group(StructRNA *srna) RNA_def_property_flag(prop, PROP_EDITABLE); RNA_def_property_ui_text(prop, "Node Tree", ""); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeGroup_update"); + + prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE); + RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_NodeGroup_interface_typef", NULL); + RNA_def_property_struct_type(prop, "PropertyGroup"); + RNA_def_property_flag(prop, PROP_IDPROPERTY); + RNA_def_property_ui_text(prop, "Interface", "Interface socket data"); + + /* registration */ + prop = RNA_def_property(srna, "bl_group_tree_idname", PROP_STRING, PROP_NONE); + RNA_def_property_string_sdna(prop, NULL, "typeinfo->group_tree_idname"); + RNA_def_property_flag(prop, PROP_REGISTER | PROP_NEVER_CLAMP); + RNA_def_property_ui_text(prop, "Group Tree Type", ""); } static void def_frame(StructRNA *srna) @@ -2062,8 +3466,7 @@ static void def_sh_tangent(StructRNA *srna) static void def_sh_script(StructRNA *srna) { - FunctionRNA *func; - PropertyRNA *prop, *parm; + PropertyRNA *prop; prop = RNA_def_property(srna, "script", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_sdna(prop, NULL, "id"); @@ -2073,7 +3476,6 @@ static void def_sh_script(StructRNA *srna) RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNodeScript_update"); RNA_def_struct_sdna_from(srna, "NodeShaderScript", "storage"); - RNA_def_struct_idprops_func(srna, "rna_ShaderNodeScript_idprops"); prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH); RNA_def_property_ui_text(prop, "File Path", "Shader script path"); @@ -2104,7 +3506,8 @@ static void def_sh_script(StructRNA *srna) RNA_def_struct_sdna_from(srna, "bNode", NULL); /* API functions */ - + +#if 0 /* XXX TODO use general node api for this */ func = RNA_def_function(srna, "find_socket", "rna_ShaderNodeScript_find_socket"); RNA_def_function_ui_description(func, "Find a socket by name"); parm = RNA_def_string(func, "name", "", 0, "Socket name", ""); @@ -2129,6 +3532,7 @@ static void def_sh_script(StructRNA *srna) RNA_def_function_flag(func, FUNC_USE_SELF_ID); parm = RNA_def_pointer(func, "sock", "NodeSocket", "Socket", ""); RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL); +#endif } /* -- Compositor Nodes ------------------------------------------------------ */ @@ -4382,390 +5786,571 @@ static void def_tex_bricks(StructRNA *srna) /* -------------------------------------------------------------------------- */ -static EnumPropertyItem shader_node_type_items[MaxNodes]; static void rna_def_shader_node(BlenderRNA *brna) { StructRNA *srna; - PropertyRNA *prop; - alloc_node_type_items(shader_node_type_items, Category_ShaderNode); - srna = RNA_def_struct(brna, "ShaderNode", "Node"); RNA_def_struct_ui_text(srna, "Shader Node", "Material shader node"); RNA_def_struct_sdna(srna, "bNode"); - - prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE); - RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_enum_items(prop, shader_node_type_items); - RNA_def_property_ui_text(prop, "Type", ""); + RNA_def_struct_register_funcs(srna, "rna_ShaderNode_register", "rna_Node_unregister", NULL); } -static EnumPropertyItem compositor_node_type_items[MaxNodes]; static void rna_def_compositor_node(BlenderRNA *brna) { StructRNA *srna; - PropertyRNA *prop; - - alloc_node_type_items(compositor_node_type_items, Category_CompositorNode); + FunctionRNA *func; srna = RNA_def_struct(brna, "CompositorNode", "Node"); RNA_def_struct_ui_text(srna, "Compositor Node", ""); RNA_def_struct_sdna(srna, "bNode"); - - prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE); - RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_enum_items(prop, compositor_node_type_items); - RNA_def_property_ui_text(prop, "Type", ""); + 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"); } -static EnumPropertyItem texture_node_type_items[MaxNodes]; static void rna_def_texture_node(BlenderRNA *brna) { StructRNA *srna; - PropertyRNA *prop; - - alloc_node_type_items(texture_node_type_items, Category_TextureNode); srna = RNA_def_struct(brna, "TextureNode", "Node"); RNA_def_struct_ui_text(srna, "Texture Node", ""); RNA_def_struct_sdna(srna, "bNode"); - - prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE); - RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_enum_items(prop, texture_node_type_items); - RNA_def_property_ui_text(prop, "Type", ""); + RNA_def_struct_register_funcs(srna, "rna_TextureNode_register", "rna_Node_unregister", NULL); } -static void rna_def_special_node(BlenderRNA *brna) +/* -------------------------------------------------------------------------- */ + +static void rna_def_node_socket(BlenderRNA *brna) { StructRNA *srna; PropertyRNA *prop; + PropertyRNA *parm; + FunctionRNA *func; + + static float default_draw_color[] = { 0.0f, 0.0f, 0.0f, 1.0f }; + + srna = RNA_def_struct(brna, "NodeSocket", NULL); + RNA_def_struct_ui_text(srna, "Node Socket", "Input or output socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); + RNA_def_struct_refine_func(srna, "rna_NodeSocket_refine"); + RNA_def_struct_ui_icon(srna, ICON_PLUG); + RNA_def_struct_path_func(srna, "rna_NodeSocket_path"); + RNA_def_struct_register_funcs(srna, "rna_NodeSocket_register", "rna_NodeSocket_unregister", NULL); + RNA_def_struct_idprops_func(srna, "rna_NodeSocket_idprops"); - static EnumPropertyItem specific_node_type_items[] = { - {NODE_GROUP, "GROUP", ICON_NODE, "Group", ""}, - {NODE_FRAME, "FRAME", ICON_NODE, "Frame", ""}, - {NODE_REROUTE, "REROUTE", ICON_NODE, "Reroute", ""}, - {0, NULL, 0, NULL, NULL} - }; - - srna = RNA_def_struct(brna, "SpecialNode", "Node"); - RNA_def_struct_ui_text(srna, "Special Node", ""); - RNA_def_struct_sdna(srna, "bNode"); + prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE); + RNA_def_property_ui_text(prop, "Name", "Socket name"); + RNA_def_struct_name_property(srna, prop); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocket_update"); - prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE); + prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE); + RNA_def_property_string_sdna(prop, NULL, "identifier"); RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_enum_items(prop, specific_node_type_items); - RNA_def_property_ui_text(prop, "Type", ""); -} + RNA_def_property_ui_text(prop, "Identifier", "Unique identifier for mapping sockets"); -/* -------------------------------------------------------------------------- */ + prop = RNA_def_property(srna, "in_out", PROP_ENUM, PROP_NONE); + RNA_def_property_enum_sdna(prop, NULL, "in_out"); + RNA_def_property_enum_items(prop, node_socket_in_out_items); + RNA_def_property_enum_default(prop, SOCK_IN); + RNA_def_property_clear_flag(prop, PROP_EDITABLE); + RNA_def_property_ui_text(prop, "Input or Output", "Input or Output type"); -static void rna_def_nodetree_link_api(BlenderRNA *brna, PropertyRNA *cprop) -{ - StructRNA *srna; - PropertyRNA *parm; - FunctionRNA *func; + prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", SOCK_HIDDEN); + RNA_def_property_boolean_funcs(prop, NULL, "rna_NodeSocket_hide_set"); + RNA_def_property_ui_text(prop, "Hide", "Hide the socket"); + RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, NULL); - RNA_def_property_srna(cprop, "NodeLinks"); - srna = RNA_def_struct(brna, "NodeLinks", NULL); - RNA_def_struct_sdna(srna, "bNodeTree"); - RNA_def_struct_ui_text(srna, "Node Links", "Collection of Node Links"); + prop = RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", SOCK_UNAVAIL); + RNA_def_property_ui_text(prop, "Enabled", "Enable the socket"); + RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, NULL); - func = RNA_def_function(srna, "new", "rna_NodeTree_link_new"); - RNA_def_function_ui_description(func, "Add a node link to this node tree"); - RNA_def_function_flag(func, FUNC_USE_REPORTS); - parm = RNA_def_pointer(func, "input", "NodeSocket", "", "The input socket"); - RNA_def_property_flag(parm, PROP_REQUIRED); - parm = RNA_def_pointer(func, "output", "NodeSocket", "", "The output socket"); - RNA_def_property_flag(parm, PROP_REQUIRED); - /* return */ - parm = RNA_def_pointer(func, "link", "NodeLink", "", "New node link"); - RNA_def_function_return(func, parm); + prop = RNA_def_property(srna, "is_linked", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", SOCK_IN_USE); + RNA_def_property_clear_flag(prop, PROP_EDITABLE); + RNA_def_property_ui_text(prop, "Linked", "True if the socket is connected"); - func = RNA_def_function(srna, "remove", "rna_NodeTree_link_remove"); - RNA_def_function_ui_description(func, "remove a node link from the node tree"); - RNA_def_function_flag(func, FUNC_USE_REPORTS); - parm = RNA_def_pointer(func, "link", "NodeLink", "", "The node link to remove"); - RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR); - RNA_def_property_clear_flag(parm, PROP_THICK_WRAP); + prop = RNA_def_property(srna, "show_expanded", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", SOCK_COLLAPSED); + RNA_def_property_ui_text(prop, "Expanded", "Socket links are expanded in the user interface"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, NULL); - func = RNA_def_function(srna, "clear", "rna_NodeTree_link_clear"); - RNA_def_function_ui_description(func, "remove all node links from the node tree"); -} + prop = RNA_def_property(srna, "node", PROP_POINTER, PROP_NONE); + RNA_def_property_pointer_funcs(prop, "rna_NodeSocket_node_get", NULL, NULL, NULL); + RNA_def_property_struct_type(prop, "Node"); + RNA_def_property_clear_flag(prop, PROP_EDITABLE); + RNA_def_property_ui_text(prop, "Node", "Node owning this socket"); -/* shared between all note tree types*/ -static void rna_def_nodetree_active_api(StructRNA *srna, PropertyRNA *UNUSED(cprop)) -{ - PropertyRNA *prop; + /* NB: the type property is used by standard sockets. + * Ideally should be defined only for the registered subclass, + * but to use the existing DNA is added in the base type here. + * Future socket types can ignore or override this if needed. + */ + prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE); + RNA_def_property_enum_sdna(prop, NULL, "type"); + RNA_def_property_enum_items(prop, node_socket_type_items); + RNA_def_property_enum_default(prop, SOCK_FLOAT); + RNA_def_property_ui_text(prop, "Type", "Data type"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocket_update"); + + /* registration */ + prop = RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE); + RNA_def_property_string_sdna(prop, NULL, "typeinfo->idname"); + RNA_def_property_string_funcs(prop, "rna_NodeSocket_bl_idname_get", "rna_NodeSocket_bl_idname_length", NULL); + RNA_def_property_flag(prop, PROP_REGISTER | PROP_NEVER_CLAMP); + RNA_def_property_ui_text(prop, "ID Name", ""); + + /* draw socket */ + func = RNA_def_function(srna, "draw", NULL); + RNA_def_function_ui_description(func, "Draw socket"); + RNA_def_function_flag(func, FUNC_REGISTER); + parm = RNA_def_pointer(func, "context", "Context", "", ""); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL); + parm = RNA_def_property(func, "layout", PROP_POINTER, PROP_NONE); + RNA_def_property_struct_type(parm, "UILayout"); + RNA_def_property_ui_text(parm, "Layout", "Layout in the UI"); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL); + parm = RNA_def_property(func, "node", PROP_POINTER, PROP_NONE); + RNA_def_property_struct_type(parm, "Node"); + RNA_def_property_ui_text(parm, "Node", "Node the socket belongs to"); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR); - prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE); - RNA_def_property_struct_type(prop, "Node"); - RNA_def_property_pointer_funcs(prop, "rna_NodeTree_active_node_get", "rna_NodeTree_active_node_set", NULL, NULL); - RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK); - RNA_def_property_ui_text(prop, "Active Node", "Active node in this tree"); - RNA_def_property_update(prop, NC_SCENE | ND_OB_ACTIVE, NULL); + func = RNA_def_function(srna, "draw_color", NULL); + RNA_def_function_ui_description(func, "Color of the socket icon"); + RNA_def_function_flag(func, FUNC_REGISTER); + parm = RNA_def_pointer(func, "context", "Context", "", ""); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL); + parm = RNA_def_property(func, "node", PROP_POINTER, PROP_NONE); + RNA_def_property_struct_type(parm, "Node"); + RNA_def_property_ui_text(parm, "Node", "Node the socket belongs to"); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR); + parm = RNA_def_float_array(func, "color", 4, default_draw_color, 0.0f, 1.0f, "Color", "", 0.0f, 1.0f); + RNA_def_function_output(func, parm); } -static void rna_def_composite_nodetree_api(BlenderRNA *brna, PropertyRNA *cprop) +static void rna_def_node_socket_interface(BlenderRNA *brna) { StructRNA *srna; + PropertyRNA *prop; PropertyRNA *parm; FunctionRNA *func; + + static float default_draw_color[] = { 0.0f, 0.0f, 0.0f, 1.0f }; + + srna = RNA_def_struct(brna, "NodeSocketInterface", NULL); + RNA_def_struct_ui_text(srna, "Node Socket Template", "Parameters to define node sockets"); + /* XXX Using bNodeSocket DNA for templates is a compatibility hack. + * This allows to keep the inputs/outputs lists in bNodeTree working for earlier versions + * and at the same time use them for socket templates in groups. + */ + RNA_def_struct_sdna(srna, "bNodeSocket"); + RNA_def_struct_refine_func(srna, "rna_NodeSocketInterface_refine"); + RNA_def_struct_path_func(srna, "rna_NodeSocketInterface_path"); + RNA_def_struct_idprops_func(srna, "rna_NodeSocketInterface_idprops"); + RNA_def_struct_register_funcs(srna, "rna_NodeSocketInterface_register", "rna_NodeSocketInterface_unregister", NULL); - RNA_def_property_srna(cprop, "CompositorNodes"); - srna = RNA_def_struct(brna, "CompositorNodes", NULL); - RNA_def_struct_sdna(srna, "bNodeTree"); - RNA_def_struct_ui_text(srna, "Compositor Nodes", "Collection of Compositor Nodes"); + prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE); + RNA_def_property_ui_text(prop, "Name", "Socket name"); + RNA_def_struct_name_property(srna, prop); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketInterface_update"); - func = RNA_def_function(srna, "new", "rna_NodeTree_node_composite_new"); - RNA_def_function_ui_description(func, "Add a node to this node tree"); - RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS); - parm = RNA_def_enum(func, "type", compositor_node_type_items, 0, "Type", "Type of node to add"); + prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE); + RNA_def_property_string_sdna(prop, NULL, "identifier"); + RNA_def_property_clear_flag(prop, PROP_EDITABLE); + RNA_def_property_ui_text(prop, "Identifier", "Unique identifier for mapping sockets"); + + prop = RNA_def_property(srna, "in_out", PROP_ENUM, PROP_NONE); + RNA_def_property_enum_sdna(prop, NULL, "in_out"); + RNA_def_property_enum_items(prop, node_socket_in_out_items); + RNA_def_property_enum_default(prop, SOCK_IN); + RNA_def_property_clear_flag(prop, PROP_EDITABLE); + RNA_def_property_ui_text(prop, "Input or Output", "Input or Output type"); + + /* registration */ + prop = RNA_def_property(srna, "bl_socket_idname", PROP_STRING, PROP_NONE); + RNA_def_property_string_sdna(prop, NULL, "typeinfo->idname"); + RNA_def_property_string_funcs(prop, "rna_NodeSocket_bl_idname_get", "rna_NodeSocket_bl_idname_length", NULL); + RNA_def_property_flag(prop, PROP_REGISTER | PROP_NEVER_CLAMP); + RNA_def_property_ui_text(prop, "ID Name", ""); + + func = RNA_def_function(srna, "draw", NULL); + RNA_def_function_ui_description(func, "Draw template settings"); + RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL); + parm = RNA_def_pointer(func, "context", "Context", "", ""); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL); + parm = RNA_def_property(func, "layout", PROP_POINTER, PROP_NONE); + RNA_def_property_struct_type(parm, "UILayout"); + RNA_def_property_ui_text(parm, "Layout", "Layout in the UI"); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL); + + func = RNA_def_function(srna, "draw_color", NULL); + RNA_def_function_ui_description(func, "Color of the socket icon"); + RNA_def_function_flag(func, FUNC_REGISTER); + parm = RNA_def_pointer(func, "context", "Context", "", ""); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL); + parm = RNA_def_float_array(func, "color", 4, default_draw_color, 0.0f, 1.0f, "Color", "", 0.0f, 1.0f); + RNA_def_function_output(func, parm); + + func = RNA_def_function(srna, "register_properties", NULL); + RNA_def_function_ui_description(func, "Define RNA properties of a socket"); + RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE); + parm = RNA_def_pointer(func, "data_rna_type", "Struct", "Data RNA Type", "RNA type for special socket properties"); RNA_def_property_flag(parm, PROP_REQUIRED); - RNA_def_pointer(func, "group", "NodeTree", "", "The group tree"); - /* return value */ - parm = RNA_def_pointer(func, "node", "Node", "", "New node"); - RNA_def_function_return(func, parm); - func = RNA_def_function(srna, "remove", "rna_NodeTree_node_remove"); - RNA_def_function_ui_description(func, "Remove a node from this node tree"); - RNA_def_function_flag(func, FUNC_USE_REPORTS); - parm = RNA_def_pointer(func, "node", "Node", "", "The node to remove"); + func = RNA_def_function(srna, "init_socket", NULL); + RNA_def_function_ui_description(func, "Initialize a node socket instance"); + RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE); + parm = RNA_def_pointer(func, "node", "Node", "Node", "Node of the socket to initialize"); RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR); - RNA_def_property_clear_flag(parm, PROP_THICK_WRAP); + parm = RNA_def_pointer(func, "socket", "NodeSocket", "Socket", "Socket to initialize"); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR); + parm = RNA_def_string(func, "data_path", "", 0, "Data Path", "Path to specialized socket data"); + RNA_def_property_flag(parm, PROP_REQUIRED); - func = RNA_def_function(srna, "clear", "rna_NodeTree_node_clear"); - RNA_def_function_ui_description(func, "Remove all nodes from this node tree"); + func = RNA_def_function(srna, "from_socket", NULL); + RNA_def_function_ui_description(func, "Setup template parameters from an existing socket"); + RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE); + parm = RNA_def_pointer(func, "node", "Node", "Node", "Node of the original socket"); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR); + parm = RNA_def_pointer(func, "socket", "NodeSocket", "Socket", "Original socket"); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR); +} - rna_def_nodetree_active_api(srna, cprop); +static void rna_def_node_socket_float(BlenderRNA *brna, const char *idname, const char *interface_idname, PropertySubType subtype) +{ + StructRNA *srna; + PropertyRNA *prop; + + srna = RNA_def_struct(brna, idname, "NodeSocketStandard"); + RNA_def_struct_ui_text(srna, "Float Node Socket", "Floating point number socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); + + RNA_def_struct_sdna_from(srna, "bNodeSocketValueFloat", "default_value"); + + prop = RNA_def_property(srna, "default_value", PROP_FLOAT, subtype); + RNA_def_property_float_sdna(prop, NULL, "value"); + RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update"); + RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE); + + /* XXX need to reset the from-type here, so subtype subclasses cast correctly! (RNA bug) */ + RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); + + /* socket interface */ + srna = RNA_def_struct(brna, interface_idname, "NodeSocketInterfaceStandard"); + RNA_def_struct_ui_text(srna, "Float Node Socket Interface", "Floating point number socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); } -static void rna_def_shader_nodetree_api(BlenderRNA *brna, PropertyRNA *cprop) +static void rna_def_node_socket_int(BlenderRNA *brna, const char *identifier, const char *interface_idname, PropertySubType subtype) { StructRNA *srna; - PropertyRNA *parm; - FunctionRNA *func; + PropertyRNA *prop; + + srna = RNA_def_struct(brna, identifier, "NodeSocketStandard"); + RNA_def_struct_ui_text(srna, "Integer Node Socket", "Integer number socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); + + RNA_def_struct_sdna_from(srna, "bNodeSocketValueInt", "default_value"); + + prop = RNA_def_property(srna, "default_value", PROP_INT, subtype); + RNA_def_property_int_sdna(prop, NULL, "value"); + RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update"); + RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE); + + /* XXX need to reset the from-type here, so subtype subclasses cast correctly! (RNA bug) */ + RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); + + /* socket interface */ + srna = RNA_def_struct(brna, interface_idname, "NodeSocketInterfaceStandard"); + RNA_def_struct_ui_text(srna, "Integer Node Socket Interface", "Integer number socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); +} - RNA_def_property_srna(cprop, "ShaderNodes"); - srna = RNA_def_struct(brna, "ShaderNodes", NULL); - RNA_def_struct_sdna(srna, "bNodeTree"); - RNA_def_struct_ui_text(srna, "Shader Nodes", "Collection of Shader Nodes"); +static void rna_def_node_socket_bool(BlenderRNA *brna, const char *identifier, const char *interface_idname) +{ + StructRNA *srna; + PropertyRNA *prop; + + srna = RNA_def_struct(brna, identifier, "NodeSocketStandard"); + RNA_def_struct_ui_text(srna, "Boolean Node Socket", "Boolean value socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); + + RNA_def_struct_sdna_from(srna, "bNodeSocketValueBoolean", "default_value"); + + prop = RNA_def_property(srna, "default_value", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "value", 1); + RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update"); + RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE); + + /* XXX need to reset the from-type here, so subtype subclasses cast correctly! (RNA bug) */ + RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); + + /* socket interface */ + srna = RNA_def_struct(brna, interface_idname, "NodeSocketInterfaceStandard"); + RNA_def_struct_ui_text(srna, "Boolean Node Socket Interface", "Boolean value socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); +} - func = RNA_def_function(srna, "new", "rna_NodeTree_node_new"); - RNA_def_function_ui_description(func, "Add a node to this node tree"); - RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS); - parm = RNA_def_enum(func, "type", shader_node_type_items, 0, "Type", "Type of node to add"); - RNA_def_property_flag(parm, PROP_REQUIRED); - RNA_def_pointer(func, "group", "NodeTree", "", "The group tree"); - /* return value */ - parm = RNA_def_pointer(func, "node", "Node", "", "New node"); - RNA_def_function_return(func, parm); +static void rna_def_node_socket_vector(BlenderRNA *brna, const char *identifier, const char *interface_idname, PropertySubType subtype) +{ + StructRNA *srna; + PropertyRNA *prop; + + srna = RNA_def_struct(brna, identifier, "NodeSocketStandard"); + RNA_def_struct_ui_text(srna, "Vector Node Socket", "3D vector socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); + + RNA_def_struct_sdna_from(srna, "bNodeSocketValueVector", "default_value"); + + prop = RNA_def_property(srna, "default_value", PROP_FLOAT, subtype); + RNA_def_property_float_sdna(prop, NULL, "value"); + RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update"); + RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE); + + /* XXX need to reset the from-type here, so subtype subclasses cast correctly! (RNA bug) */ + RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); + + /* socket interface */ + srna = RNA_def_struct(brna, interface_idname, "NodeSocketInterfaceStandard"); + RNA_def_struct_ui_text(srna, "Vector Node Socket Interface", "3D vector socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); +} - func = RNA_def_function(srna, "remove", "rna_NodeTree_node_remove"); - RNA_def_function_ui_description(func, "Remove a node from this node tree"); - RNA_def_function_flag(func, FUNC_USE_REPORTS); - parm = RNA_def_pointer(func, "node", "Node", "", "The node to remove"); - RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR); - RNA_def_property_clear_flag(parm, PROP_THICK_WRAP); +static void rna_def_node_socket_color(BlenderRNA *brna, const char *identifier, const char *interface_idname) +{ + StructRNA *srna; + PropertyRNA *prop; + + srna = RNA_def_struct(brna, identifier, "NodeSocketStandard"); + RNA_def_struct_ui_text(srna, "Color Node Socket", "RGBA color socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); + + RNA_def_struct_sdna_from(srna, "bNodeSocketValueRGBA", "default_value"); + + prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_COLOR); + RNA_def_property_float_sdna(prop, NULL, "value"); + RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update"); + RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE); + + /* XXX need to reset the from-type here, so subtype subclasses cast correctly! (RNA bug) */ + RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); + + /* socket interface */ + srna = RNA_def_struct(brna, interface_idname, "NodeSocketInterfaceStandard"); + RNA_def_struct_ui_text(srna, "Color Node Socket Interface", "RGBA color socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); +} - func = RNA_def_function(srna, "clear", "rna_NodeTree_node_clear"); - RNA_def_function_ui_description(func, "Remove all nodes from this node tree"); +static void rna_def_node_socket_string(BlenderRNA *brna, const char *identifier, const char *interface_idname) +{ + StructRNA *srna; + PropertyRNA *prop; + + srna = RNA_def_struct(brna, identifier, "NodeSocketStandard"); + RNA_def_struct_ui_text(srna, "String Node Socket", "String socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); + + RNA_def_struct_sdna_from(srna, "bNodeSocketValueString", "default_value"); + + prop = RNA_def_property(srna, "default_value", PROP_STRING, PROP_NONE); + RNA_def_property_string_sdna(prop, NULL, "value"); + RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update"); + RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE); + + /* XXX need to reset the from-type here, so subtype subclasses cast correctly! (RNA bug) */ + RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); + + /* socket interface */ + srna = RNA_def_struct(brna, interface_idname, "NodeSocketInterfaceStandard"); + RNA_def_struct_ui_text(srna, "String Node Socket Interface", "String socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); +} + +static void rna_def_node_socket_shader(BlenderRNA *brna, const char *identifier, const char *interface_idname) +{ + StructRNA *srna; + + srna = RNA_def_struct(brna, identifier, "NodeSocketStandard"); + RNA_def_struct_ui_text(srna, "Shader Node Socket", "Shader socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); + + /* socket interface */ + srna = RNA_def_struct(brna, interface_idname, "NodeSocketInterfaceStandard"); + RNA_def_struct_ui_text(srna, "Shader Node Socket Interface", "Shader socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); +} - rna_def_nodetree_active_api(srna, cprop); +static void rna_def_node_socket_virtual(BlenderRNA *brna, const char *identifier) +{ + StructRNA *srna; + + srna = RNA_def_struct(brna, identifier, "NodeSocketStandard"); + RNA_def_struct_ui_text(srna, "Virtual Node Socket", "Virtual socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); } -static void rna_def_texture_nodetree_api(BlenderRNA *brna, PropertyRNA *cprop) +static void rna_def_node_socket_standard_types(BlenderRNA *brna) { + /* XXX Workaround: Registered functions are not exposed in python by bpy, + * it expects them to be registered from python and use the native implementation. + * However, the standard socket types below are not registering these functions from python, + * so in order to call them in py scripts we need to overload and replace them with plain C callbacks. + * These types provide a usable basis for socket types defined in C. + */ + StructRNA *srna; PropertyRNA *parm; FunctionRNA *func; + + static float default_draw_color[] = { 0.0f, 0.0f, 0.0f, 1.0f }; + + srna = RNA_def_struct(brna, "NodeSocketStandard", "NodeSocket"); + RNA_def_struct_sdna(srna, "bNodeSocket"); + + /* draw socket */ + func = RNA_def_function(srna, "draw", "rna_NodeSocketStandard_draw"); + RNA_def_function_flag(func, FUNC_USE_SELF_ID); + RNA_def_function_ui_description(func, "Draw socket"); + parm = RNA_def_pointer(func, "context", "Context", "", ""); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL); + parm = RNA_def_property(func, "layout", PROP_POINTER, PROP_NONE); + RNA_def_property_struct_type(parm, "UILayout"); + RNA_def_property_ui_text(parm, "Layout", "Layout in the UI"); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL); + parm = RNA_def_property(func, "node", PROP_POINTER, PROP_NONE); + RNA_def_property_struct_type(parm, "Node"); + RNA_def_property_ui_text(parm, "Node", "Node the socket belongs to"); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR); - RNA_def_property_srna(cprop, "TextureNodes"); - srna = RNA_def_struct(brna, "TextureNodes", NULL); - RNA_def_struct_sdna(srna, "bNodeTree"); - RNA_def_struct_ui_text(srna, "Texture Nodes", "Collection of Texture Nodes"); - - func = RNA_def_function(srna, "new", "rna_NodeTree_node_texture_new"); - RNA_def_function_ui_description(func, "Add a node to this node tree"); - RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS); - parm = RNA_def_enum(func, "type", texture_node_type_items, 0, "Type", "Type of node to add"); - RNA_def_property_flag(parm, PROP_REQUIRED); - RNA_def_pointer(func, "group", "NodeTree", "", "The group tree"); - /* return value */ - parm = RNA_def_pointer(func, "node", "Node", "", "New node"); - RNA_def_function_return(func, parm); - - func = RNA_def_function(srna, "remove", "rna_NodeTree_node_remove"); - RNA_def_function_ui_description(func, "Remove a node from this node tree"); - RNA_def_function_flag(func, FUNC_USE_REPORTS); - parm = RNA_def_pointer(func, "node", "Node", "", "The node to remove"); + func = RNA_def_function(srna, "draw_color", "rna_NodeSocketStandard_draw_color"); + RNA_def_function_flag(func, FUNC_USE_SELF_ID); + RNA_def_function_ui_description(func, "Color of the socket icon"); + parm = RNA_def_pointer(func, "context", "Context", "", ""); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL); + parm = RNA_def_property(func, "node", PROP_POINTER, PROP_NONE); + RNA_def_property_struct_type(parm, "Node"); + RNA_def_property_ui_text(parm, "Node", "Node the socket belongs to"); RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR); - RNA_def_property_clear_flag(parm, PROP_THICK_WRAP); + parm = RNA_def_float_array(func, "color", 4, default_draw_color, 0.0f, 1.0f, "Color", "", 0.0f, 1.0f); + RNA_def_function_output(func, parm); + + + srna = RNA_def_struct(brna, "NodeSocketInterfaceStandard", "NodeSocketInterface"); + RNA_def_struct_sdna(srna, "bNodeSocket"); + + func = RNA_def_function(srna, "draw", "rna_NodeSocketInterfaceStandard_draw"); + RNA_def_function_flag(func, FUNC_USE_SELF_ID); + RNA_def_function_ui_description(func, "Draw template settings"); + parm = RNA_def_pointer(func, "context", "Context", "", ""); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL); + parm = RNA_def_property(func, "layout", PROP_POINTER, PROP_NONE); + RNA_def_property_struct_type(parm, "UILayout"); + RNA_def_property_ui_text(parm, "Layout", "Layout in the UI"); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL); - func = RNA_def_function(srna, "clear", "rna_NodeTree_node_clear"); - RNA_def_function_ui_description(func, "Remove all nodes from this node tree"); + func = RNA_def_function(srna, "draw_color", "rna_NodeSocketInterfaceStandard_draw_color"); + RNA_def_function_flag(func, FUNC_USE_SELF_ID); + RNA_def_function_ui_description(func, "Color of the socket icon"); + parm = RNA_def_pointer(func, "context", "Context", "", ""); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL); + parm = RNA_def_float_array(func, "color", 4, default_draw_color, 0.0f, 1.0f, "Color", "", 0.0f, 1.0f); + RNA_def_function_output(func, parm); - rna_def_nodetree_active_api(srna, cprop); -} -static void rna_def_node_socket(BlenderRNA *brna) -{ - StructRNA *srna; - PropertyRNA *prop; + /* XXX These types should eventually be registered at runtime. + * Then use the nodeStaticSocketType and nodeStaticSocketInterfaceType functions + * to get the idname strings from int type and subtype (see node_socket.c, register_standard_node_socket_types). + */ + + rna_def_node_socket_float(brna, "NodeSocketFloat", "NodeSocketInterfaceFloat", PROP_NONE); + rna_def_node_socket_float(brna, "NodeSocketFloatUnsigned", "NodeSocketInterfaceFloatUnsigned", PROP_UNSIGNED); + rna_def_node_socket_float(brna, "NodeSocketFloatPercentage", "NodeSocketInterfaceFloatPercentage", PROP_PERCENTAGE); + rna_def_node_socket_float(brna, "NodeSocketFloatFactor", "NodeSocketInterfaceFloatFactor", PROP_FACTOR); + rna_def_node_socket_float(brna, "NodeSocketFloatAngle", "NodeSocketInterfaceFloatAngle", PROP_ANGLE); + rna_def_node_socket_float(brna, "NodeSocketFloatTime", "NodeSocketInterfaceFloatTime", PROP_TIME); - srna = RNA_def_struct(brna, "NodeSocket", NULL); - RNA_def_struct_ui_text(srna, "Node Socket", "Input or output socket of a node"); - RNA_def_struct_sdna(srna, "bNodeSocket"); - RNA_def_struct_refine_func(srna, "rna_NodeSocket_refine"); - RNA_def_struct_ui_icon(srna, ICON_PLUG); - RNA_def_struct_path_func(srna, "rna_NodeSocket_path"); + rna_def_node_socket_int(brna, "NodeSocketInt", "NodeSocketInterfaceInt", PROP_NONE); + rna_def_node_socket_int(brna, "NodeSocketIntUnsigned", "NodeSocketInterfaceIntUnsigned", PROP_UNSIGNED); + rna_def_node_socket_int(brna, "NodeSocketIntPercentage", "NodeSocketInterfaceIntPercentage", PROP_PERCENTAGE); + rna_def_node_socket_int(brna, "NodeSocketIntFactor", "NodeSocketInterfaceIntFactor", PROP_FACTOR); - prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "type"); - RNA_def_property_enum_items(prop, node_socket_type_items); - RNA_def_property_enum_default(prop, 0); - RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_ui_text(prop, "Type", "Node Socket type"); + rna_def_node_socket_bool(brna, "NodeSocketBool", "NodeSocketInterfaceBool"); - prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE); - /* XXX must be editable for group sockets. if necessary use a special rna definition for these */ -/* RNA_def_property_clear_flag(prop, PROP_EDITABLE); */ - RNA_def_property_ui_text(prop, "Name", "Socket name"); - RNA_def_struct_name_property(srna, prop); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeGroupSocket_update"); + rna_def_node_socket_vector(brna, "NodeSocketVector", "NodeSocketInterfaceVector", PROP_NONE); + rna_def_node_socket_vector(brna, "NodeSocketVectorTranslation", "NodeSocketInterfaceVectorTranslation", PROP_TRANSLATION); + rna_def_node_socket_vector(brna, "NodeSocketVectorDirection", "NodeSocketInterfaceVectorDirection", PROP_DIRECTION); + rna_def_node_socket_vector(brna, "NodeSocketVectorVelocity", "NodeSocketInterfaceVectorVelocity", PROP_VELOCITY); + rna_def_node_socket_vector(brna, "NodeSocketVectorAcceleration", "NodeSocketInterfaceVectorAcceleration", PROP_ACCELERATION); + rna_def_node_socket_vector(brna, "NodeSocketVectorEuler", "NodeSocketInterfaceVectorEuler", PROP_EULER); + rna_def_node_socket_vector(brna, "NodeSocketVectorXYZ", "NodeSocketInterfaceVectorXYZ", PROP_XYZ); - prop = RNA_def_property(srna, "group_socket", PROP_POINTER, PROP_NONE); - RNA_def_property_pointer_sdna(prop, NULL, "groupsock"); - RNA_def_property_struct_type(prop, "NodeSocket"); - RNA_def_property_ui_text(prop, "Group Socket", - "For group nodes, the group input or output socket this corresponds to"); + rna_def_node_socket_color(brna, "NodeSocketColor", "NodeSocketInterfaceColor"); - prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "flag", SOCK_HIDDEN); - RNA_def_property_boolean_funcs(prop, NULL, "rna_NodeSocket_hide_set"); - RNA_def_property_ui_text(prop, "Hide", "Hide the socket"); - RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, NULL); + rna_def_node_socket_string(brna, "NodeSocketString", "NodeSocketInterfaceString"); - prop = RNA_def_property(srna, "is_linked", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "flag", SOCK_IN_USE); - RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_ui_text(prop, "Linked", "True if the socket is connected"); + rna_def_node_socket_shader(brna, "NodeSocketShader", "NodeSocketInterfaceShader"); - prop = RNA_def_property(srna, "show_expanded", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", SOCK_COLLAPSED); - RNA_def_property_ui_text(prop, "Expanded", "Socket links are expanded in the user interface"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, NULL); + rna_def_node_socket_virtual(brna, "NodeSocketVirtual"); } -static void rna_def_node_socket_subtype(BlenderRNA *brna, int type, int subtype, const char *name, const char *ui_name) +static void rna_def_node_sockets_api(BlenderRNA *brna, PropertyRNA *cprop, int in_out) { StructRNA *srna; - PropertyRNA *prop = NULL; - PropertySubType propsubtype = PROP_NONE; - - #define SUBTYPE(socktype, stypename, id, idname) { PROP_##id, #socktype "_" #id, 0, #idname, ""}, - static EnumPropertyItem subtype_items[] = { - NODE_DEFINE_SUBTYPES - {0, NULL, 0, NULL, NULL} - }; - #undef SUBTYPE + PropertyRNA *parm; + FunctionRNA *func; + const char *structtype = (in_out == SOCK_IN ? "NodeInputs" : "NodeOutputs"); + const char *uiname = (in_out == SOCK_IN ? "Node Inputs" : "Node Outputs"); + const char *newfunc = (in_out == SOCK_IN ? "rna_Node_inputs_new" : "rna_Node_outputs_new"); + const char *clearfunc = (in_out == SOCK_IN ? "rna_Node_inputs_clear" : "rna_Node_outputs_clear"); - #define SUBTYPE(socktype, stypename, id, idname) if (subtype == (PROP_##id)) propsubtype = PROP_##id; - NODE_DEFINE_SUBTYPES - #undef SUBTYPE - - srna = RNA_def_struct(brna, name, "NodeSocket"); - RNA_def_struct_ui_text(srna, ui_name, "Input or output socket of a node"); - RNA_def_struct_sdna(srna, "bNodeSocket"); - RNA_def_struct_ui_icon(srna, ICON_PLUG); - RNA_def_struct_path_func(srna, "rna_NodeSocket_path"); - - switch (type) { - case SOCK_INT: - RNA_def_struct_sdna_from(srna, "bNodeSocketValueInt", "default_value"); - - prop = RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "subtype"); - RNA_def_property_enum_items(prop, subtype_items); - RNA_def_property_ui_text(prop, "Subtype", "Subtype defining the socket value details"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocket_update"); - - prop = RNA_def_property(srna, "default_value", PROP_INT, propsubtype); - RNA_def_property_int_sdna(prop, NULL, "value"); - RNA_def_property_int_funcs(prop, NULL, NULL, "rna_NodeSocketInt_range"); - RNA_def_property_ui_text(prop, "Default Value", ""); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocket_update"); - break; - case SOCK_FLOAT: - RNA_def_struct_sdna_from(srna, "bNodeSocketValueFloat", "default_value"); - - prop = RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "subtype"); - RNA_def_property_enum_items(prop, subtype_items); - RNA_def_property_ui_text(prop, "Subtype", "Subtype defining the socket value details"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocket_update"); - - prop = RNA_def_property(srna, "default_value", PROP_FLOAT, propsubtype); - RNA_def_property_float_sdna(prop, NULL, "value"); - RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketFloat_range"); - RNA_def_property_ui_text(prop, "Default Value", ""); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocket_update"); - break; - case SOCK_BOOLEAN: - RNA_def_struct_sdna_from(srna, "bNodeSocketValueBoolean", "default_value"); - - prop = RNA_def_property(srna, "default_value", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "value", 1); - RNA_def_property_ui_text(prop, "Default Value", ""); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocket_update"); - break; - case SOCK_VECTOR: - RNA_def_struct_sdna_from(srna, "bNodeSocketValueVector", "default_value"); - - prop = RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "subtype"); - RNA_def_property_enum_items(prop, subtype_items); - RNA_def_property_ui_text(prop, "Subtype", "Subtype defining the socket value details"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocket_update"); - - prop = RNA_def_property(srna, "default_value", PROP_FLOAT, propsubtype); - RNA_def_property_float_sdna(prop, NULL, "value"); - RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketVector_range"); - RNA_def_property_ui_text(prop, "Default Value", ""); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocket_update"); - break; - case SOCK_RGBA: - RNA_def_struct_sdna_from(srna, "bNodeSocketValueRGBA", "default_value"); + RNA_def_property_srna(cprop, structtype); + srna= RNA_def_struct(brna, structtype, NULL); + RNA_def_struct_sdna(srna, "bNode"); + RNA_def_struct_ui_text(srna, uiname, "Collection of Node Sockets"); - prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_COLOR); - RNA_def_property_float_sdna(prop, NULL, "value"); - RNA_def_property_ui_text(prop, "Default Value", ""); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocket_update"); - break; - case SOCK_STRING: - RNA_def_struct_sdna_from(srna, "bNodeSocketValueString", "default_value"); - - prop = RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "subtype"); - RNA_def_property_enum_items(prop, subtype_items); - RNA_def_property_ui_text(prop, "Subtype", "Subtype defining the socket value details"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocket_update"); - - prop = RNA_def_property(srna, "default_value", PROP_STRING, PROP_FILEPATH); - RNA_def_property_string_sdna(prop, NULL, "value"); - RNA_def_property_ui_text(prop, "Default Value", ""); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocket_update"); - break; - } - - /* XXX need to reset the from-type here, so subtype subclasses cast correctly! (RNA bug) */ - RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); + func= RNA_def_function(srna, "new", newfunc); + RNA_def_function_ui_description(func, "Add a socket to this node"); + RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_REPORTS); + parm= RNA_def_string(func, "type", "", MAX_NAME, "Type", "Data type"); + RNA_def_property_flag(parm, PROP_REQUIRED); + parm= RNA_def_string(func, "name", "", MAX_NAME, "Name", ""); + RNA_def_property_flag(parm, PROP_REQUIRED); + RNA_def_string(func, "identifier", "", MAX_NAME, "Identifier", "Unique socket identifier"); + /* return value */ + parm= RNA_def_pointer(func, "socket", "NodeSocket", "", "New socket"); + RNA_def_function_return(func, parm); + + func= RNA_def_function(srna, "remove", "rna_Node_socket_remove"); + RNA_def_function_ui_description(func, "Remove a socket from this node"); + RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_REPORTS); + parm= RNA_def_pointer(func, "socket", "NodeSocket", "", "The socket to remove"); + RNA_def_property_flag(parm, PROP_REQUIRED); + + func= RNA_def_function(srna, "clear", clearfunc); + RNA_def_function_ui_description(func, "Remove all sockets from this node"); + RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_REPORTS); } static void rna_def_node(BlenderRNA *brna) { StructRNA *srna; PropertyRNA *prop; + FunctionRNA *func; + PropertyRNA *parm; + + static EnumPropertyItem dummy_static_type_items[] = { + {NODE_CUSTOM, "CUSTOM", 0, "Custom", "Custom Node"}, + {0, NULL, 0, NULL, NULL}}; srna = RNA_def_struct(brna, "Node", NULL); RNA_def_struct_ui_text(srna, "Node", "Node in a node tree"); @@ -4773,6 +6358,16 @@ static void rna_def_node(BlenderRNA *brna) RNA_def_struct_ui_icon(srna, ICON_NODE); RNA_def_struct_refine_func(srna, "rna_Node_refine"); RNA_def_struct_path_func(srna, "rna_Node_path"); + RNA_def_struct_register_funcs(srna, "rna_Node_register", "rna_Node_unregister", NULL); + RNA_def_struct_idprops_func(srna, "rna_Node_idprops"); + + prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE); + RNA_def_property_enum_sdna(prop, NULL, "type"); + RNA_def_property_enum_items(prop, dummy_static_type_items); + RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_node_static_type_itemf"); + RNA_def_property_enum_default(prop, NODE_CUSTOM); + RNA_def_property_clear_flag(prop, PROP_EDITABLE); + RNA_def_property_ui_text(prop, "Type", "Node type (deprecated, use bl_static_type or bl_idname for the actual identifier string)"); prop = RNA_def_property(srna, "location", PROP_FLOAT, PROP_XYZ); RNA_def_property_float_sdna(prop, NULL, "locx"); @@ -4812,13 +6407,24 @@ static void rna_def_node(BlenderRNA *brna) prop = RNA_def_property(srna, "inputs", PROP_COLLECTION, PROP_NONE); RNA_def_property_collection_sdna(prop, NULL, "inputs", NULL); + RNA_def_property_collection_funcs(prop, NULL, NULL, NULL, NULL, NULL, NULL, + "rna_Node_inputs_lookupstring", NULL); RNA_def_property_struct_type(prop, "NodeSocket"); RNA_def_property_ui_text(prop, "Inputs", ""); + rna_def_node_sockets_api(brna, prop, SOCK_IN); prop = RNA_def_property(srna, "outputs", PROP_COLLECTION, PROP_NONE); RNA_def_property_collection_sdna(prop, NULL, "outputs", NULL); + RNA_def_property_collection_funcs(prop, NULL, NULL, NULL, NULL, NULL, NULL, + "rna_Node_outputs_lookupstring", NULL); RNA_def_property_struct_type(prop, "NodeSocket"); RNA_def_property_ui_text(prop, "Outputs", ""); + rna_def_node_sockets_api(brna, prop, SOCK_OUT); + + prop = RNA_def_property(srna, "internal_links", PROP_COLLECTION, PROP_NONE); + RNA_def_property_collection_sdna(prop, NULL, "internal_links", NULL); + RNA_def_property_struct_type(prop, "NodeLink"); + RNA_def_property_ui_text(prop, "Internal Links", "Internal input-to-output connections for muting"); prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_sdna(prop, NULL, "parent"); @@ -4840,8 +6446,9 @@ static void rna_def_node(BlenderRNA *brna) RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, NULL); prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "flag", NODE_SELECT); - RNA_def_property_ui_text(prop, "Select", ""); + RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT); + RNA_def_property_boolean_funcs(prop, NULL, "rna_Node_select_set"); + RNA_def_property_ui_text(prop, "Select", "Node selection state"); RNA_def_property_update(prop, NC_NODE | NA_SELECTED, NULL); prop = RNA_def_property(srna, "show_options", PROP_BOOLEAN, PROP_NONE); @@ -4868,6 +6475,115 @@ static void rna_def_node(BlenderRNA *brna) RNA_def_property_boolean_sdna(prop, NULL, "flag", NODE_ACTIVE_TEXTURE); RNA_def_property_ui_text(prop, "Show Texture", "Draw node in viewport textured draw mode"); RNA_def_property_update(prop, 0, "rna_Node_update"); + + /* generic property update function */ + func = RNA_def_function(srna, "socket_value_update", "rna_Node_socket_value_update"); + RNA_def_function_ui_description(func, "Update after property changes"); + RNA_def_function_flag(func, FUNC_USE_SELF_ID); + parm = RNA_def_pointer(func, "context", "Context", "", ""); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL); + + func = RNA_def_function(srna, "is_registered_node_type", "rna_Node_is_registered_node_type"); + RNA_def_function_ui_description(func, "True if a registered node type"); + RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_SELF_TYPE); + parm = RNA_def_boolean(func, "result", FALSE, "Result", ""); + RNA_def_function_return(func, parm); + + /* registration */ + prop = RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE); + RNA_def_property_string_sdna(prop, NULL, "typeinfo->idname"); + RNA_def_property_string_funcs(prop, "rna_Node_bl_idname_get", "rna_Node_bl_idname_length", NULL); + RNA_def_property_flag(prop, PROP_REGISTER|PROP_NEVER_CLAMP); + RNA_def_property_ui_text(prop, "ID Name", ""); + + prop = RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE); + RNA_def_property_string_sdna(prop, NULL, "typeinfo->ui_name"); + RNA_def_property_string_funcs(prop, "rna_Node_bl_label_get", "rna_Node_bl_label_length", NULL); + RNA_def_property_flag(prop, PROP_REGISTER); + RNA_def_property_ui_text(prop, "Label", "The node label"); + + prop = RNA_def_property(srna, "bl_description", PROP_STRING, PROP_TRANSLATION); + RNA_def_property_string_sdna(prop, NULL, "typeinfo->ui_description"); + RNA_def_property_string_funcs(prop, "rna_Node_bl_description_get", "rna_Node_bl_description_length", NULL); + RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL); + + prop = RNA_def_property(srna, "bl_icon", PROP_ENUM, PROP_NONE); + RNA_def_property_enum_sdna(prop, NULL, "typeinfo->ui_icon"); + RNA_def_property_enum_funcs(prop, "rna_Node_bl_icon_get", NULL, NULL); + RNA_def_property_enum_items(prop, node_icon_items); + RNA_def_property_enum_default(prop, ICON_NODE); + RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL); + RNA_def_property_ui_text(prop, "Icon", "The node icon"); + + prop = RNA_def_property(srna, "bl_static_type", PROP_ENUM, PROP_NONE); + RNA_def_property_enum_sdna(prop, NULL, "typeinfo->type"); + RNA_def_property_enum_funcs(prop, "rna_Node_bl_static_type_get", NULL, NULL); + RNA_def_property_enum_items(prop, dummy_static_type_items); + RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_node_static_type_itemf"); + RNA_def_property_enum_default(prop, NODE_CUSTOM); + RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL); + RNA_def_property_ui_text(prop, "Static Type", "Node type (deprecated, use with care)"); + + /* poll */ + func = RNA_def_function(srna, "poll", NULL); + RNA_def_function_ui_description(func, "If non-null output is returned, the node type can be added to the tree"); + RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_REGISTER); + RNA_def_function_return(func, RNA_def_boolean(func, "visible", FALSE, "", "")); + parm = RNA_def_pointer(func, "node_tree", "NodeTree", "Node Tree", ""); + RNA_def_property_flag(parm, PROP_REQUIRED); + + func = RNA_def_function(srna, "poll_instance", NULL); + RNA_def_function_ui_description(func, "If non-null output is returned, the node can be added to the tree"); + RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL); + RNA_def_function_return(func, RNA_def_boolean(func, "visible", FALSE, "", "")); + parm = RNA_def_pointer(func, "node_tree", "NodeTree", "Node Tree", ""); + RNA_def_property_flag(parm, PROP_REQUIRED); + + /* update */ + func = RNA_def_function(srna, "update", NULL); + RNA_def_function_ui_description(func, "Update on editor changes"); + RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE); + + /* init */ + func = RNA_def_function(srna, "init", NULL); + RNA_def_function_ui_description(func, "Initialize a new instance of this node"); + RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE); + parm = RNA_def_pointer(func, "context", "Context", "", ""); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL); + + /* copy */ + func = RNA_def_function(srna, "copy", NULL); + RNA_def_function_ui_description(func, "Initialize a new instance of this node from an existing node"); + RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE); + parm = RNA_def_pointer(func, "node", "Node", "Node", "Existing node to copy"); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL); + + /* free */ + func = RNA_def_function(srna, "free", NULL); + RNA_def_function_ui_description(func, "Clean up node on removal"); + RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE); + + /* draw buttons */ + func = RNA_def_function(srna, "draw_buttons", NULL); + RNA_def_function_ui_description(func, "Draw node buttons"); + RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL); + parm = RNA_def_pointer(func, "context", "Context", "", ""); + RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL); + parm = RNA_def_property(func, "layout", PROP_POINTER, PROP_NONE); + RNA_def_property_struct_type(parm, "UILayout"); + RNA_def_property_ui_text(parm, "Layout", "Layout in the UI"); + RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL); + + /* draw buttons extended */ + func = RNA_def_function(srna, "draw_buttons_ext", NULL); + RNA_def_function_ui_description(func, "Draw node buttons in the sidebar"); + RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL); + parm = RNA_def_pointer(func, "context", "Context", "", ""); + RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL); + parm = RNA_def_property(func, "layout", PROP_POINTER, PROP_NONE); + RNA_def_property_struct_type(parm, "UILayout"); + RNA_def_property_ui_text(parm, "Layout", "Layout in the UI"); + RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL); } static void rna_def_node_link(BlenderRNA *brna) @@ -4880,63 +6596,165 @@ static void rna_def_node_link(BlenderRNA *brna) RNA_def_struct_sdna(srna, "bNodeLink"); RNA_def_struct_ui_icon(srna, ICON_NODE); + prop = RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", NODE_LINK_VALID); + RNA_def_struct_ui_text(srna, "Valid", "Link is valid"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, NULL); + prop = RNA_def_property(srna, "from_node", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_sdna(prop, NULL, "fromnode"); RNA_def_property_struct_type(prop, "Node"); + RNA_def_property_clear_flag(prop, PROP_EDITABLE); RNA_def_property_ui_text(prop, "From node", ""); prop = RNA_def_property(srna, "to_node", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_sdna(prop, NULL, "tonode"); RNA_def_property_struct_type(prop, "Node"); + RNA_def_property_clear_flag(prop, PROP_EDITABLE); RNA_def_property_ui_text(prop, "To node", ""); prop = RNA_def_property(srna, "from_socket", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_sdna(prop, NULL, "fromsock"); RNA_def_property_struct_type(prop, "NodeSocket"); + RNA_def_property_clear_flag(prop, PROP_EDITABLE); RNA_def_property_ui_text(prop, "From socket", ""); prop = RNA_def_property(srna, "to_socket", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_sdna(prop, NULL, "tosock"); RNA_def_property_struct_type(prop, "NodeSocket"); + RNA_def_property_clear_flag(prop, PROP_EDITABLE); RNA_def_property_ui_text(prop, "To socket", ""); + + prop = RNA_def_property(srna, "is_hidden", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_funcs(prop, "rna_NodeLink_is_hidden_get", NULL); + RNA_def_property_clear_flag(prop, PROP_EDITABLE); + RNA_def_property_ui_text(prop, "Is Hidden", "Link is hidden due to invisible sockets"); } -static void rna_def_group_sockets_api(BlenderRNA *brna, PropertyRNA *cprop, int in_out) +static void rna_def_nodetree_nodes_api(BlenderRNA *brna, PropertyRNA *cprop) +{ + StructRNA *srna; + PropertyRNA *parm, *prop; + FunctionRNA *func; + + RNA_def_property_srna(cprop, "Nodes"); + srna= RNA_def_struct(brna, "Nodes", NULL); + RNA_def_struct_sdna(srna, "bNodeTree"); + RNA_def_struct_ui_text(srna, "Nodes", "Collection of Nodes"); + + func= RNA_def_function(srna, "new", "rna_NodeTree_node_new"); + RNA_def_function_ui_description(func, "Add a node to this node tree"); + RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS); + parm= RNA_def_string(func, "type", "", MAX_NAME, "Type", "Type of node to add"); + RNA_def_property_flag(parm, PROP_REQUIRED); + /* return value */ + parm= RNA_def_pointer(func, "node", "Node", "", "New node"); + RNA_def_function_return(func, parm); + + func= RNA_def_function(srna, "remove", "rna_NodeTree_node_remove"); + RNA_def_function_ui_description(func, "Remove a node from this node tree"); + RNA_def_function_flag(func, FUNC_USE_REPORTS); + parm= RNA_def_pointer(func, "node", "Node", "", "The node to remove"); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR); + RNA_def_property_clear_flag(parm, PROP_THICK_WRAP); + + func= RNA_def_function(srna, "clear", "rna_NodeTree_node_clear"); + RNA_def_function_ui_description(func, "Remove all nodes from this node tree"); + RNA_def_function_flag(func, FUNC_USE_REPORTS); + + prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE); + RNA_def_property_struct_type(prop, "Node"); + RNA_def_property_pointer_funcs(prop, "rna_NodeTree_active_node_get", "rna_NodeTree_active_node_set", NULL, NULL); + RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK); + RNA_def_property_ui_text(prop, "Active Node", "Active node in this tree"); + RNA_def_property_update(prop, NC_SCENE | ND_OB_ACTIVE, NULL); +} + +static void rna_def_nodetree_link_api(BlenderRNA *brna, PropertyRNA *cprop) { StructRNA *srna; PropertyRNA *parm; FunctionRNA *func; - RNA_def_property_srna(cprop, (in_out == SOCK_IN ? "GroupInputs" : "GroupOutputs")); - srna = RNA_def_struct(brna, (in_out == SOCK_IN ? "GroupInputs" : "GroupOutputs"), NULL); + RNA_def_property_srna(cprop, "NodeLinks"); + srna = RNA_def_struct(brna, "NodeLinks", NULL); RNA_def_struct_sdna(srna, "bNodeTree"); - RNA_def_struct_ui_text(srna, "Group Sockets", "Collection of group sockets"); + RNA_def_struct_ui_text(srna, "Node Links", "Collection of Node Links"); - func = RNA_def_function(srna, "new", (in_out == SOCK_IN ? "rna_NodeTree_input_new" : "rna_NodeTree_output_new")); - RNA_def_function_ui_description(func, "Add a socket to the group tree"); + func = RNA_def_function(srna, "new", "rna_NodeTree_link_new"); + RNA_def_function_ui_description(func, "Add a node link to this node tree"); RNA_def_function_flag(func, FUNC_USE_REPORTS); - RNA_def_string(func, "name", "Socket", MAX_NAME, "Name", "Name of the socket"); - RNA_def_enum(func, "type", node_socket_type_items, SOCK_FLOAT, "Type", "Type of socket"); - /* return value */ - parm = RNA_def_pointer(func, "socket", "NodeSocket", "", "New socket"); + parm = RNA_def_pointer(func, "input", "NodeSocket", "", "The input socket"); + RNA_def_property_flag(parm, PROP_REQUIRED); + parm = RNA_def_pointer(func, "output", "NodeSocket", "", "The output socket"); + RNA_def_property_flag(parm, PROP_REQUIRED); + RNA_def_boolean(func, "verify_limits", TRUE, "Verify Limits", "Remove existing links if connection limit is exceeded"); + /* return */ + parm = RNA_def_pointer(func, "link", "NodeLink", "", "New node link"); RNA_def_function_return(func, parm); - func = RNA_def_function(srna, "expose", - (in_out == SOCK_IN ? "rna_NodeTree_input_expose" : "rna_NodeTree_output_expose")); - RNA_def_function_ui_description(func, "Expose an internal socket in the group tree"); + func = RNA_def_function(srna, "remove", "rna_NodeTree_link_remove"); + RNA_def_function_ui_description(func, "remove a node link from the node tree"); + RNA_def_function_flag(func, FUNC_USE_REPORTS); + parm = RNA_def_pointer(func, "link", "NodeLink", "", "The node link to remove"); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR); + RNA_def_property_clear_flag(parm, PROP_THICK_WRAP); + + func = RNA_def_function(srna, "clear", "rna_NodeTree_link_clear"); + RNA_def_function_ui_description(func, "remove all node links from the node tree"); + RNA_def_function_flag(func, FUNC_USE_REPORTS); +} + +static void rna_def_node_tree_sockets_api(BlenderRNA *brna, PropertyRNA *cprop, int in_out) +{ + StructRNA *srna; + PropertyRNA *parm; + FunctionRNA *func; + const char *structtype = (in_out == SOCK_IN ? "NodeTreeInputs" : "NodeTreeOutputs"); + const char *uiname = (in_out == SOCK_IN ? "Node Tree Inputs" : "Node Tree Outputs"); + const char *newfunc = (in_out == SOCK_IN ? "rna_NodeTree_inputs_new" : "rna_NodeTree_outputs_new"); + const char *clearfunc = (in_out == SOCK_IN ? "rna_NodeTree_inputs_clear" : "rna_NodeTree_outputs_clear"); + + RNA_def_property_srna(cprop, structtype); + srna= RNA_def_struct(brna, structtype, NULL); + RNA_def_struct_sdna(srna, "bNodeTree"); + RNA_def_struct_ui_text(srna, uiname, "Collection of Node Tree Sockets"); + + func= RNA_def_function(srna, "new", newfunc); + RNA_def_function_ui_description(func, "Add a socket to this node tree"); RNA_def_function_flag(func, FUNC_USE_REPORTS); - RNA_def_pointer(func, "sock", "NodeSocket", "Socket", "Internal node socket to expose"); + parm= RNA_def_string(func, "type", "", MAX_NAME, "Type", "Data type"); + RNA_def_property_flag(parm, PROP_REQUIRED); + parm= RNA_def_string(func, "name", "", MAX_NAME, "Name", ""); RNA_def_property_flag(parm, PROP_REQUIRED); - RNA_def_boolean(func, "add_link", TRUE, "Add Link", "If TRUE, adds a link to the internal socket"); /* return value */ - parm = RNA_def_pointer(func, "socket", "NodeSocket", "", "New socket"); + parm= RNA_def_pointer(func, "socket", "NodeSocketInterface", "", "New socket"); RNA_def_function_return(func, parm); + + func= RNA_def_function(srna, "remove", "rna_NodeTree_socket_remove"); + RNA_def_function_ui_description(func, "Remove a socket from this node tree"); + RNA_def_function_flag(func, FUNC_USE_REPORTS); + parm= RNA_def_pointer(func, "socket", "NodeSocketInterface", "", "The socket to remove"); + RNA_def_property_flag(parm, PROP_REQUIRED); + + func= RNA_def_function(srna, "clear", clearfunc); + RNA_def_function_ui_description(func, "Remove all sockets from this node tree"); + RNA_def_function_flag(func, FUNC_USE_REPORTS); } static void rna_def_nodetree(BlenderRNA *brna) { StructRNA *srna; PropertyRNA *prop; + FunctionRNA *func; + PropertyRNA *parm; + + static EnumPropertyItem static_type_items[] = { + {NTREE_SHADER, "SHADER", ICON_MATERIAL, "Shader", "Shader nodes"}, + {NTREE_TEXTURE, "TEXTURE", ICON_TEXTURE, "Texture", "Texture nodes"}, + {NTREE_COMPOSIT, "COMPOSITING", ICON_RENDERLAYERS, "Compositing", "Compositing nodes"}, + {0, NULL, 0, NULL, NULL} + }; srna = RNA_def_struct(brna, "NodeTree", "ID"); RNA_def_struct_ui_text(srna, "Node Tree", @@ -4944,10 +6762,18 @@ static void rna_def_nodetree(BlenderRNA *brna) RNA_def_struct_sdna(srna, "bNodeTree"); RNA_def_struct_ui_icon(srna, ICON_NODETREE); RNA_def_struct_refine_func(srna, "rna_NodeTree_refine"); + RNA_def_struct_register_funcs(srna, "rna_NodeTree_register", "rna_NodeTree_unregister", NULL); /* AnimData */ rna_def_animdata_common(srna); - + + /* Nodes Collection */ + prop = RNA_def_property(srna, "nodes", PROP_COLLECTION, PROP_NONE); + RNA_def_property_collection_sdna(prop, NULL, "nodes", NULL); + RNA_def_property_struct_type(prop, "Node"); + RNA_def_property_ui_text(prop, "Nodes", ""); + rna_def_nodetree_nodes_api(brna, prop); + /* NodeLinks Collection */ prop = RNA_def_property(srna, "links", PROP_COLLECTION, PROP_NONE); RNA_def_property_collection_sdna(prop, NULL, "links", NULL); @@ -4965,21 +6791,100 @@ static void rna_def_nodetree(BlenderRNA *brna) prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE); RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_enum_items(prop, nodetree_type_items); - RNA_def_property_ui_text(prop, "Type", "Node Tree type"); + RNA_def_property_enum_items(prop, static_type_items); + RNA_def_property_ui_text(prop, "Type", "Node Tree type (deprecated, bl_idname is the actual node tree type identifier)"); - /* group sockets */ prop = RNA_def_property(srna, "inputs", PROP_COLLECTION, PROP_NONE); RNA_def_property_collection_sdna(prop, NULL, "inputs", NULL); - RNA_def_property_struct_type(prop, "NodeSocket"); - RNA_def_property_ui_text(prop, "Inputs", ""); - rna_def_group_sockets_api(brna, prop, SOCK_IN); - + RNA_def_property_collection_funcs(prop, NULL, NULL, NULL, NULL, NULL, NULL, + "rna_NodeTree_inputs_lookupstring", NULL); + RNA_def_property_struct_type(prop, "NodeSocketInterface"); + RNA_def_property_clear_flag(prop, PROP_EDITABLE); + RNA_def_property_ui_text(prop, "Inputs", "Node tree inputs"); + rna_def_node_tree_sockets_api(brna, prop, SOCK_IN); + + prop = RNA_def_property(srna, "active_input", PROP_INT, PROP_UNSIGNED); + RNA_def_property_int_funcs(prop, "rna_NodeTree_active_input_get", "rna_NodeTree_active_input_set", NULL); + RNA_def_property_ui_text(prop, "Active Input", "Index of the active input"); + RNA_def_property_update(prop, NC_NODE, NULL); + prop = RNA_def_property(srna, "outputs", PROP_COLLECTION, PROP_NONE); RNA_def_property_collection_sdna(prop, NULL, "outputs", NULL); - RNA_def_property_struct_type(prop, "NodeSocket"); - RNA_def_property_ui_text(prop, "Outputs", ""); - rna_def_group_sockets_api(brna, prop, SOCK_OUT); + RNA_def_property_collection_funcs(prop, NULL, NULL, NULL, NULL, NULL, NULL, + "rna_NodeTree_outputs_lookupstring", NULL); + RNA_def_property_struct_type(prop, "NodeSocketInterface"); + RNA_def_property_clear_flag(prop, PROP_EDITABLE); + RNA_def_property_ui_text(prop, "Outputs", "Node tree outputs"); + rna_def_node_tree_sockets_api(brna, prop, SOCK_OUT); + + prop = RNA_def_property(srna, "active_output", PROP_INT, PROP_UNSIGNED); + RNA_def_property_int_funcs(prop, "rna_NodeTree_active_output_get", "rna_NodeTree_active_output_set", NULL); + RNA_def_property_ui_text(prop, "Active Output", "Index of the active output"); + RNA_def_property_update(prop, NC_NODE, NULL); + + /* exposed as a function for runtime interface type properties */ + func = RNA_def_function(srna, "interface_update", "rna_NodeTree_interface_update"); + RNA_def_function_ui_description(func, "Updated node group interface"); + parm = RNA_def_pointer(func, "context", "Context", "", ""); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL); + + /* registration */ + prop = RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE); + RNA_def_property_string_sdna(prop, NULL, "typeinfo->idname"); + RNA_def_property_string_funcs(prop, "rna_NodeTree_bl_idname_get", "rna_NodeTree_bl_idname_length", NULL); + RNA_def_property_flag(prop, PROP_REGISTER|PROP_NEVER_CLAMP); + RNA_def_property_ui_text(prop, "ID Name", ""); + + prop = RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE); + RNA_def_property_string_sdna(prop, NULL, "typeinfo->ui_name"); + RNA_def_property_string_funcs(prop, "rna_NodeTree_bl_label_get", "rna_NodeTree_bl_label_length", NULL); + RNA_def_property_flag(prop, PROP_REGISTER); + RNA_def_property_ui_text(prop, "Label", "The node tree label"); + + prop = RNA_def_property(srna, "bl_description", PROP_STRING, PROP_TRANSLATION); + RNA_def_property_string_sdna(prop, NULL, "typeinfo->ui_description"); + RNA_def_property_string_funcs(prop, "rna_NodeTree_bl_description_get", "rna_NodeTree_bl_description_length", NULL); + RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL); + + prop = RNA_def_property(srna, "bl_icon", PROP_ENUM, PROP_NONE); + RNA_def_property_enum_sdna(prop, NULL, "typeinfo->ui_icon"); + RNA_def_property_enum_funcs(prop, "rna_NodeTree_bl_icon_get", NULL, NULL); + RNA_def_property_enum_items(prop, node_icon_items); + RNA_def_property_enum_default(prop, ICON_NODETREE); + RNA_def_property_flag(prop, PROP_REGISTER); + RNA_def_property_ui_text(prop, "Icon", "The node tree icon"); + + /* poll */ + func = RNA_def_function(srna, "poll", NULL); + RNA_def_function_ui_description(func, "Check visibility in the editor"); + RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_REGISTER_OPTIONAL); + parm = RNA_def_pointer(func, "context", "Context", "", ""); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL); + RNA_def_function_return(func, RNA_def_boolean(func, "visible", FALSE, "", "")); + + /* draw add menu */ + func = RNA_def_function(srna, "draw_add_menu", NULL); + RNA_def_function_ui_description(func, "Draw the menu for adding nodes"); + RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL); + parm = RNA_def_pointer(func, "context", "Context", "", ""); + RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL); + parm = RNA_def_property(func, "layout", PROP_POINTER, PROP_NONE); + RNA_def_property_struct_type(parm, "UILayout"); + RNA_def_property_ui_text(parm, "Layout", "Menu layout in the UI"); + RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL); + + /* get a node tree from context */ + func = RNA_def_function(srna, "get_from_context", NULL); + RNA_def_function_ui_description(func, "Get a node tree from the context"); + RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_REGISTER_OPTIONAL); + parm = RNA_def_pointer(func, "context", "Context", "", ""); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL); + parm = RNA_def_pointer(func, "result_1", "NodeTree", "Node Tree", "Active node tree from context"); + RNA_def_function_output(func, parm); + parm = RNA_def_pointer(func, "result_2", "ID", "Owner ID", "ID data block that owns the node tree"); + RNA_def_function_output(func, parm); + parm = RNA_def_pointer(func, "result_3", "ID", "From ID", "Original ID data block selected from the context"); + RNA_def_function_output(func, parm); } static void rna_def_composite_nodetree(BlenderRNA *brna) @@ -4990,15 +6895,7 @@ static void rna_def_composite_nodetree(BlenderRNA *brna) srna = RNA_def_struct(brna, "CompositorNodeTree", "NodeTree"); RNA_def_struct_ui_text(srna, "Compositor Node Tree", "Node tree consisting of linked nodes used for compositing"); RNA_def_struct_sdna(srna, "bNodeTree"); - RNA_def_struct_ui_icon(srna, ICON_NODETREE); - - /* Nodes Collection */ - prop = RNA_def_property(srna, "nodes", PROP_COLLECTION, PROP_NONE); - RNA_def_property_collection_sdna(prop, NULL, "nodes", NULL); - RNA_def_property_struct_type(prop, "Node"); - RNA_def_property_ui_text(prop, "Nodes", ""); - - rna_def_composite_nodetree_api(brna, prop); + RNA_def_struct_ui_icon(srna, ICON_RENDERLAYERS); prop = RNA_def_property(srna, "render_quality", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "render_quality"); @@ -5029,6 +6926,11 @@ static void rna_def_composite_nodetree(BlenderRNA *brna) RNA_def_property_ui_text(prop, "Two Pass", "Use two pass execution during editing: first calculate fast nodes, " "second pass calculate all nodes"); + prop = RNA_def_property(srna, "is_local_tree", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_default(prop, FALSE); + RNA_def_property_flag(prop, PROP_IDPROPERTY); + RNA_def_property_ui_text(prop, "Local Scene Tree", "Local scene node tree, eligible for special node types"); + prop = RNA_def_property(srna, "use_viewer_border", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "flag", NTREE_VIEWER_BORDER); RNA_def_property_ui_text(prop, "Viewer Border", "Use boundaries for viewer nodes and composite backdrop"); @@ -5044,15 +6946,12 @@ static void rna_def_shader_nodetree(BlenderRNA *brna) RNA_def_struct_ui_text(srna, "Shader Node Tree", "Node tree consisting of linked nodes used for materials (and other shading datablocks)"); RNA_def_struct_sdna(srna, "bNodeTree"); - RNA_def_struct_ui_icon(srna, ICON_NODETREE); + RNA_def_struct_ui_icon(srna, ICON_MATERIAL); - /* Nodes Collection */ - prop = RNA_def_property(srna, "nodes", PROP_COLLECTION, PROP_NONE); - RNA_def_property_collection_sdna(prop, NULL, "nodes", NULL); - RNA_def_property_struct_type(prop, "Node"); - RNA_def_property_ui_text(prop, "Nodes", ""); - - rna_def_shader_nodetree_api(brna, prop); + prop = RNA_def_property(srna, "is_local_tree", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_default(prop, FALSE); + RNA_def_property_flag(prop, PROP_IDPROPERTY); + RNA_def_property_ui_text(prop, "Local Material Tree", "Local material node tree, eligible for special node types"); } static void rna_def_texture_nodetree(BlenderRNA *brna) @@ -5063,64 +6962,87 @@ static void rna_def_texture_nodetree(BlenderRNA *brna) srna = RNA_def_struct(brna, "TextureNodeTree", "NodeTree"); RNA_def_struct_ui_text(srna, "Texture Node Tree", "Node tree consisting of linked nodes used for textures"); RNA_def_struct_sdna(srna, "bNodeTree"); - RNA_def_struct_ui_icon(srna, ICON_NODETREE); - - /* Nodes Collection */ - prop = RNA_def_property(srna, "nodes", PROP_COLLECTION, PROP_NONE); - RNA_def_property_collection_sdna(prop, NULL, "nodes", NULL); - RNA_def_property_struct_type(prop, "Node"); - RNA_def_property_ui_text(prop, "Nodes", ""); + RNA_def_struct_ui_icon(srna, ICON_TEXTURE); - rna_def_texture_nodetree_api(brna, prop); + prop = RNA_def_property(srna, "is_local_tree", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_default(prop, FALSE); + RNA_def_property_flag(prop, PROP_IDPROPERTY); + RNA_def_property_ui_text(prop, "Local Texture Tree", "Local texture node tree, eligible for special node types"); } -static void define_specific_node(BlenderRNA *brna, int id, void (*def_func)(StructRNA *)) +static void define_specific_node(BlenderRNA *brna, const char *struct_name, const char *base_name, + const char *ui_name, const char *ui_desc, void (*def_func)(StructRNA *)) { - StructRNA *srna = def_node(brna, id); + StructRNA *srna; + FunctionRNA *func; + PropertyRNA *parm; + srna = RNA_def_struct(brna, struct_name, base_name); + RNA_def_struct_ui_text(srna, ui_name, ui_desc); + RNA_def_struct_sdna(srna, "bNode"); + + func = RNA_def_function(srna, "is_registered_node_type", "rna_Node_is_registered_node_type"); + RNA_def_function_ui_description(func, "True if a registered node type"); + RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_SELF_TYPE); + parm = RNA_def_boolean(func, "result", FALSE, "Result", ""); + RNA_def_function_return(func, parm); + if (def_func) def_func(srna); } +static void rna_def_node_instance_hash(BlenderRNA *brna) +{ + StructRNA *srna; + + srna = RNA_def_struct(brna, "NodeInstanceHash", NULL); + RNA_def_struct_ui_text(srna, "Node Instance Hash", "Hash table containing node instance data"); + + /* XXX This type is a stub for now, only used to store instance hash in the context. + * Eventually could use a StructRNA pointer to define a specific data type + * and expose lookup functions. + */ +} + void RNA_def_nodetree(BlenderRNA *brna) { - init(); - rna_def_nodetree(brna); - rna_def_node_socket(brna); - - /* Generate RNA definitions for all socket subtypes */ - #define SUBTYPE(socktype, stypename, id, idname) \ - rna_def_node_socket_subtype(brna, SOCK_##socktype, PROP_##id, "NodeSocket"#stypename#idname, \ - #idname" "#stypename" Node Socket"); - NODE_DEFINE_SUBTYPES - #undef SUBTYPE - rna_def_node_socket_subtype(brna, SOCK_BOOLEAN, 0, "NodeSocketBoolean", "Boolean Node Socket"); - rna_def_node_socket_subtype(brna, SOCK_RGBA, 0, "NodeSocketRGBA", "RGBA Node Socket"); - rna_def_node_socket_subtype(brna, SOCK_SHADER, 0, "NodeSocketShader", "Shader Closure Node Socket"); + rna_def_node_socket_interface(brna); rna_def_node(brna); rna_def_node_link(brna); rna_def_shader_node(brna); rna_def_compositor_node(brna); rna_def_texture_node(brna); - rna_def_special_node(brna); + + rna_def_nodetree(brna); + + rna_def_node_socket_standard_types(brna); rna_def_composite_nodetree(brna); rna_def_shader_nodetree(brna); rna_def_texture_nodetree(brna); + #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \ - define_specific_node(brna, ID, DefFunc); - - #include "rna_nodetree_types.h" + define_specific_node(brna, #Category #StructName, #Category, UIName, UIDesc, DefFunc); - define_specific_node(brna, NODE_GROUP, def_group); - define_specific_node(brna, NODE_FRAME, def_frame); - define_specific_node(brna, NODE_REROUTE, 0); + /* hack, don't want to add include path to RNA just for this, since in the future RNA types + * for nodes should be defined locally at runtime anyway ... + */ + #include "../../nodes/NOD_static_types.h" + + /* Node group types need to be defined for shader, compositor, texture nodes individually. + * Cannot use the static types header for this, since they share the same int id. + */ + define_specific_node(brna, "ShaderNodeGroup", "ShaderNode", "Group", "", def_group); + define_specific_node(brna, "CompositorNodeGroup", "CompositorNode", "Group", "", def_group); + define_specific_node(brna, "TextureNodeGroup", "TextureNode", "Group", "", def_group); /* special socket types */ rna_def_cmp_output_file_slot_file(brna); rna_def_cmp_output_file_slot_layer(brna); + + rna_def_node_instance_hash(brna); } /* clean up macro definition */ diff --git a/source/blender/makesrna/intern/rna_scene.c b/source/blender/makesrna/intern/rna_scene.c index d556cc0dcdc..e03e7d222c6 100644 --- a/source/blender/makesrna/intern/rna_scene.c +++ b/source/blender/makesrna/intern/rna_scene.c @@ -1173,13 +1173,12 @@ static void rna_SceneRenderLayer_pass_update(Main *bmain, Scene *activescene, Po rna_Scene_glsl_update(bmain, activescene, ptr); } -static void rna_Scene_use_nodes_set(PointerRNA *ptr, int value) +static void rna_Scene_use_nodes_update(bContext *C, PointerRNA *ptr) { Scene *scene = (Scene *)ptr->data; - scene->use_nodes = value; if (scene->use_nodes && scene->nodetree == NULL) - ED_node_composit_default(scene); + ED_node_composit_default(C, scene); } static void rna_Physics_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr) @@ -4533,9 +4532,9 @@ void RNA_def_scene(BlenderRNA *brna) prop = RNA_def_property(srna, "use_nodes", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "use_nodes", 1); - RNA_def_property_boolean_funcs(prop, NULL, "rna_Scene_use_nodes_set"); + RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE); RNA_def_property_ui_text(prop, "Use Nodes", "Enable the compositing node tree"); - RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL); + RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_use_nodes_update"); /* Sequencer */ prop = RNA_def_property(srna, "sequence_editor", PROP_POINTER, PROP_NONE); diff --git a/source/blender/makesrna/intern/rna_space.c b/source/blender/makesrna/intern/rna_space.c index d88e8ed782a..f365352ca30 100644 --- a/source/blender/makesrna/intern/rna_space.c +++ b/source/blender/makesrna/intern/rna_space.c @@ -25,6 +25,7 @@ */ #include <stdlib.h> +#include <string.h> #include "MEM_guardedalloc.h" @@ -32,6 +33,7 @@ #include "BKE_key.h" #include "BKE_movieclip.h" +#include "BKE_node.h" #include "DNA_action_types.h" #include "DNA_key_types.h" @@ -1014,20 +1016,91 @@ static void rna_BackgroundImage_clear(View3D *v3d) /* Space Node Editor */ -static int rna_SpaceNodeEditor_node_tree_poll(PointerRNA *ptr, PointerRNA value) +static void rna_SpaceNodeEditor_node_tree_set(PointerRNA *ptr, const PointerRNA value) +{ + SpaceNode *snode = (SpaceNode *)ptr->data; + ED_node_tree_start(snode, (bNodeTree *)value.data, NULL, NULL); +} + +static int rna_SpaceNodeEditor_node_tree_poll(PointerRNA *ptr, const PointerRNA value) { SpaceNode *snode = (SpaceNode *)ptr->data; bNodeTree *ntree = (bNodeTree *)value.data; - /* exclude group trees, only trees of the active type */ - return (ntree->nodetype == 0 && ntree->type == snode->treetype); + /* node tree type must match the selected type in node editor */ + return (strcmp(snode->tree_idname, ntree->idname) == 0); } -static void rna_SpaceNodeEditor_node_tree_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr) +static void rna_SpaceNodeEditor_node_tree_update(const bContext *C, PointerRNA *UNUSED(ptr)) { - SpaceNode *snode = (SpaceNode *)ptr->data; + ED_node_tree_update(C); +} + +static int rna_SpaceNodeEditor_tree_type_get(PointerRNA *ptr) +{ + SpaceNode *snode= (SpaceNode*)ptr->data; + return rna_node_tree_idname_to_enum(snode->tree_idname); +} +static void rna_SpaceNodeEditor_tree_type_set(PointerRNA *ptr, int value) +{ + SpaceNode *snode= (SpaceNode*)ptr->data; + ED_node_set_tree_type(snode, rna_node_tree_type_from_enum(value)); +} +static int rna_SpaceNodeEditor_tree_type_poll(void *Cv, bNodeTreeType *type) +{ + bContext *C = (bContext *)Cv; + if (type->poll) + return type->poll(C, type); + else + return TRUE; +} +static EnumPropertyItem *rna_SpaceNodeEditor_tree_type_itemf(bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), int *free) +{ + return rna_node_tree_type_itemf(C, rna_SpaceNodeEditor_tree_type_poll, free); +} + +static void rna_SpaceNodeEditor_path_get(PointerRNA *ptr, char *value) +{ + SpaceNode *snode = ptr->data; + ED_node_tree_path_get(snode, value); +} + +static int rna_SpaceNodeEditor_path_length(PointerRNA *ptr) +{ + SpaceNode *snode = ptr->data; + return ED_node_tree_path_length(snode); +} + +void rna_SpaceNodeEditor_path_clear(SpaceNode *snode, bContext *C) +{ + ED_node_tree_start(snode, NULL, NULL, NULL); + ED_node_tree_update(C); +} + +void rna_SpaceNodeEditor_path_start(SpaceNode *snode, bContext *C, PointerRNA *node_tree) +{ + ED_node_tree_start(snode, (bNodeTree *)node_tree->data, NULL, NULL); + ED_node_tree_update(C); +} + +void rna_SpaceNodeEditor_path_push(SpaceNode *snode, bContext *C, ReportList *reports, PointerRNA *node) +{ + PointerRNA tree_ptr; + + tree_ptr = RNA_pointer_get(node, "node_tree"); + if (!tree_ptr.data) { + BKE_reportf(reports, RPT_WARNING, "Missing node group tree in node %s", ((bNode *)node->data)->name); + return; + } - ED_node_tree_update(snode, scene); + ED_node_tree_push(snode, (bNodeTree *)tree_ptr.data, (bNode *)node->data); + ED_node_tree_update(C); +} + +void rna_SpaceNodeEditor_path_pop(SpaceNode *snode, bContext *C) +{ + ED_node_tree_pop(snode); + ED_node_tree_update(C); } static EnumPropertyItem *rna_SpaceProperties_texture_context_itemf(bContext *C, PointerRNA *UNUSED(ptr), @@ -3077,6 +3150,58 @@ static void rna_def_space_userpref(BlenderRNA *brna) } +static void rna_def_node_tree_path(BlenderRNA *brna) +{ + StructRNA *srna; + PropertyRNA *prop; + + srna = RNA_def_struct(brna, "NodeTreePath", NULL); + RNA_def_struct_sdna(srna, "bNodeTreePath"); + RNA_def_struct_ui_text(srna, "Node Tree Path", "Element of the node space tree path"); + + prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE); + RNA_def_property_pointer_sdna(prop, NULL, "nodetree"); + RNA_def_property_clear_flag(prop, PROP_EDITABLE); + RNA_def_property_ui_text(prop, "Node Tree", "Base node tree from context"); +} + +static void rna_def_space_node_path_api(BlenderRNA *brna, PropertyRNA *cprop) +{ + StructRNA *srna; + PropertyRNA *prop, *parm; + FunctionRNA *func; + + RNA_def_property_srna(cprop, "SpaceNodeEditorPath"); + srna = RNA_def_struct(brna, "SpaceNodeEditorPath", NULL); + RNA_def_struct_sdna(srna, "SpaceNode"); + RNA_def_struct_ui_text(srna, "Space Node Editor Path", "History of node trees in the editor"); + + prop = RNA_def_property(srna, "to_string", PROP_STRING, PROP_NONE); + RNA_def_property_string_funcs(prop, "rna_SpaceNodeEditor_path_get", "rna_SpaceNodeEditor_path_length", NULL); + RNA_def_property_clear_flag(prop, PROP_EDITABLE); + RNA_def_struct_ui_text(srna, "Path", "Get the node tree path as a string"); + + func = RNA_def_function(srna, "clear", "rna_SpaceNodeEditor_path_clear"); + RNA_def_function_ui_description(func, "Reset the node tree path"); + RNA_def_function_flag(func, FUNC_USE_CONTEXT); + + func = RNA_def_function(srna, "start", "rna_SpaceNodeEditor_path_start"); + RNA_def_function_ui_description(func, "Set the root node tree"); + RNA_def_function_flag(func, FUNC_USE_CONTEXT); + parm = RNA_def_pointer(func, "node_tree", "NodeTree", "Node Tree", ""); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_RNAPTR); + + func = RNA_def_function(srna, "push", "rna_SpaceNodeEditor_path_push"); + RNA_def_function_ui_description(func, "Append a node group tree to the path"); + RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS); + parm = RNA_def_pointer(func, "node", "NodeGroup", "Node", "Group node"); + RNA_def_property_flag(parm, PROP_REQUIRED | PROP_RNAPTR); + + func = RNA_def_function(srna, "pop", "rna_SpaceNodeEditor_path_pop"); + RNA_def_function_ui_description(func, "Remove the last node tree from the path"); + RNA_def_function_flag(func, FUNC_USE_CONTEXT); +} + static void rna_def_space_node(BlenderRNA *brna) { StructRNA *srna; @@ -3106,13 +3231,17 @@ static void rna_def_space_node(BlenderRNA *brna) {0, NULL, 0, NULL, NULL} }; + static EnumPropertyItem dummy_items[] = { + {0, "DUMMY", 0, "", ""}, + {0, NULL, 0, NULL, NULL}}; + srna = RNA_def_struct(brna, "SpaceNodeEditor", "Space"); RNA_def_struct_sdna(srna, "SpaceNode"); RNA_def_struct_ui_text(srna, "Space Node Editor", "Node editor space data"); prop = RNA_def_property(srna, "tree_type", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "treetype"); - RNA_def_property_enum_items(prop, nodetree_type_items); + RNA_def_property_enum_items(prop, dummy_items); + RNA_def_property_enum_funcs(prop, "rna_SpaceNodeEditor_tree_type_get", "rna_SpaceNodeEditor_tree_type_set", "rna_SpaceNodeEditor_tree_type_itemf"); RNA_def_property_ui_text(prop, "Tree Type", "Node tree type to display and edit"); RNA_def_property_update(prop, NC_SPACE | ND_SPACE_NODE, NULL); @@ -3137,17 +3266,29 @@ static void rna_def_space_node(BlenderRNA *brna) RNA_def_property_clear_flag(prop, PROP_EDITABLE); RNA_def_property_ui_text(prop, "ID From", "Datablock from which the edited datablock is linked"); + prop= RNA_def_property(srna, "path", PROP_COLLECTION, PROP_NONE); + RNA_def_property_collection_sdna(prop, NULL, "treepath", NULL); + RNA_def_property_struct_type(prop, "NodeTreePath"); + RNA_def_property_ui_text(prop, "Node Tree Path", "Path from the data block to the currently edited node tree"); + rna_def_space_node_path_api(brna, prop); + prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE); + RNA_def_property_pointer_funcs(prop, NULL, "rna_SpaceNodeEditor_node_tree_set", NULL, "rna_SpaceNodeEditor_node_tree_poll"); RNA_def_property_pointer_sdna(prop, NULL, "nodetree"); - RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_SpaceNodeEditor_node_tree_poll"); - RNA_def_property_flag(prop, PROP_EDITABLE); - RNA_def_property_ui_text(prop, "Node Tree", "Node tree being displayed"); + RNA_def_property_flag(prop, PROP_EDITABLE | PROP_CONTEXT_UPDATE); + RNA_def_property_ui_text(prop, "Node Tree", "Base node tree from context"); RNA_def_property_update(prop, NC_SPACE | ND_SPACE_NODE, "rna_SpaceNodeEditor_node_tree_update"); - prop = RNA_def_property(srna, "edit_tree", PROP_POINTER, PROP_NONE); + prop= RNA_def_property(srna, "edit_tree", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_sdna(prop, NULL, "edittree"); RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_ui_text(prop, "Edit Tree", "Edited node tree"); + RNA_def_property_ui_text(prop, "Edit Tree", "Node tree being displayed and edited"); + + prop= RNA_def_property(srna, "pin", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", SNODE_PIN); + RNA_def_property_ui_text(prop, "Pinned", "Use the pinned node tree"); + RNA_def_property_ui_icon(prop, ICON_UNPINNED, 1); + RNA_def_property_update(prop, NC_SPACE|ND_SPACE_NODE, NULL); prop = RNA_def_property(srna, "show_backdrop", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "flag", SNODE_BACKDRAW); @@ -3544,6 +3685,7 @@ void RNA_def_space(BlenderRNA *brna) rna_def_console_line(brna); rna_def_space_info(brna); rna_def_space_userpref(brna); + rna_def_node_tree_path(brna); rna_def_space_node(brna); rna_def_space_logic(brna); rna_def_space_clip(brna); diff --git a/source/blender/makesrna/intern/rna_texture.c b/source/blender/makesrna/intern/rna_texture.c index d86e5fd0d9c..009823555f0 100644 --- a/source/blender/makesrna/intern/rna_texture.c +++ b/source/blender/makesrna/intern/rna_texture.c @@ -107,6 +107,7 @@ EnumPropertyItem blend_type_items[] = { #include "RNA_access.h" +#include "BKE_context.h" #include "BKE_depsgraph.h" #include "BKE_image.h" #include "BKE_texture.h" @@ -167,7 +168,7 @@ static void rna_Texture_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *pt } else if (GS(id->name) == ID_NT) { bNodeTree *ntree = ptr->id.data; - ED_node_generic_update(bmain, ntree, NULL); + ED_node_tag_update_nodetree(bmain, ntree); } } @@ -384,15 +385,18 @@ static void rna_Texture_use_color_ramp_set(PointerRNA *ptr, int value) tex->coba = add_colorband(0); } -static void rna_Texture_use_nodes_set(PointerRNA *ptr, int v) +static void rna_Texture_use_nodes_update(bContext *C, PointerRNA *ptr) { Tex *tex = (Tex *)ptr->data; - tex->use_nodes = v; - tex->type = 0; + if (tex->use_nodes) { + tex->type = 0; + + if (tex->nodetree == NULL) + ED_node_texture_default(C, tex); + } - if (v && tex->nodetree == NULL) - ED_node_texture_default(tex); + rna_Texture_nodes_update(CTX_data_main(C), CTX_data_scene(C), ptr); } static void rna_ImageTexture_mipmap_set(PointerRNA *ptr, int value) @@ -2021,9 +2025,9 @@ static void rna_def_texture(BlenderRNA *brna) /* nodetree */ prop = RNA_def_property(srna, "use_nodes", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "use_nodes", 1); - RNA_def_property_boolean_funcs(prop, NULL, "rna_Texture_use_nodes_set"); + RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE); RNA_def_property_ui_text(prop, "Use Nodes", "Make this a node-based texture"); - RNA_def_property_update(prop, 0, "rna_Texture_nodes_update"); + RNA_def_property_update(prop, 0, "rna_Texture_use_nodes_update"); prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_sdna(prop, NULL, "nodetree"); diff --git a/source/blender/makesrna/intern/rna_ui_api.c b/source/blender/makesrna/intern/rna_ui_api.c index 0204fa5367b..41d1411d35c 100644 --- a/source/blender/makesrna/intern/rna_ui_api.c +++ b/source/blender/makesrna/intern/rna_ui_api.c @@ -419,6 +419,8 @@ void RNA_api_ui_layout(StructRNA *srna) {0, NULL, 0, NULL, NULL} }; + static float node_socket_color_default[] = { 0.0f, 0.0f, 0.0f, 1.0f }; + /* simple layout specifiers */ func = RNA_def_function(srna, "row", "uiLayoutRow"); parm = RNA_def_pointer(func, "layout", "UILayout", "", "Sub-layout to put items in"); @@ -829,6 +831,14 @@ void RNA_api_ui_layout(StructRNA *srna) parm = RNA_def_pointer(func, "item", "KeyMapItem", "", ""); RNA_def_property_flag(parm, PROP_REQUIRED | PROP_RNAPTR | PROP_NEVER_NULL); + func = RNA_def_function(srna, "template_component_menu", "uiTemplateComponentMenu"); + RNA_def_function_ui_description(func, "Item. Display expanded property in a popup menu"); + parm = RNA_def_pointer(func, "data", "AnyType", "", "Data from which to take property"); + RNA_def_property_flag(parm, PROP_REQUIRED|PROP_RNAPTR); + parm = RNA_def_string(func, "property", "", 0, "", "Identifier of property in data"); + RNA_def_property_flag(parm, PROP_REQUIRED); + RNA_def_string(func, "name", "", 0, "", ""); + func = RNA_def_function(srna, "introspect", "uiLayoutIntrospect"); parm = RNA_def_string(func, "string", "", 1024 * 1024, "Descr", "DESCR"); RNA_def_function_return(func, parm); @@ -843,6 +853,12 @@ void RNA_api_ui_layout(StructRNA *srna) RNA_def_function_flag(func, FUNC_USE_CONTEXT); api_ui_item_rna_common(func); /* RNA_def_boolean(func, "show_global_settings", 0, "", "Show widgets to control global color management settings"); */ + + /* node socket icon */ + func = RNA_def_function(srna, "template_node_socket", "uiTemplateNodeSocket"); + RNA_def_function_ui_description(func, "Node Socket Icon"); + RNA_def_function_flag(func, FUNC_USE_CONTEXT); + RNA_def_float_array(func, "color", 4, node_socket_color_default, 0.0f, 1.0f, "Color", "", 0.0f, 1.0f); } #endif diff --git a/source/blender/makesrna/intern/rna_userdef.c b/source/blender/makesrna/intern/rna_userdef.c index 3824ee28956..12fac82fb75 100644 --- a/source/blender/makesrna/intern/rna_userdef.c +++ b/source/blender/makesrna/intern/rna_userdef.c @@ -1884,6 +1884,12 @@ static void rna_def_userdef_theme_space_node(BlenderRNA *brna) RNA_def_property_ui_text(prop, "Group Node", ""); RNA_def_property_update(prop, 0, "rna_userdef_update"); + prop= RNA_def_property(srna, "group_socket_node", PROP_FLOAT, PROP_COLOR_GAMMA); + RNA_def_property_float_sdna(prop, NULL, "console_output"); + RNA_def_property_array(prop, 3); + RNA_def_property_ui_text(prop, "Group Socket Node", ""); + RNA_def_property_update(prop, 0, "rna_userdef_update"); + prop = RNA_def_property(srna, "frame_node", PROP_FLOAT, PROP_COLOR_GAMMA); RNA_def_property_float_sdna(prop, NULL, "movie"); RNA_def_property_array(prop, 4); diff --git a/source/blender/makesrna/intern/rna_world.c b/source/blender/makesrna/intern/rna_world.c index 02a04d36c23..b689a82c231 100644 --- a/source/blender/makesrna/intern/rna_world.c +++ b/source/blender/makesrna/intern/rna_world.c @@ -42,6 +42,7 @@ #include "MEM_guardedalloc.h" +#include "BKE_context.h" #include "BKE_depsgraph.h" #include "BKE_main.h" #include "BKE_texture.h" @@ -121,14 +122,14 @@ static void rna_World_stars_update(Main *UNUSED(bmain), Scene *UNUSED(scene), Po WM_main_add_notifier(NC_WORLD | ND_WORLD_STARS, wo); } -static void rna_World_use_nodes_update(Main *bmain, Scene *scene, PointerRNA *ptr) +static void rna_World_use_nodes_update(bContext *C, PointerRNA *ptr) { World *wrld = (World *)ptr->data; if (wrld->use_nodes && wrld->nodetree == NULL) - ED_node_shader_default(scene, &wrld->id); + ED_node_shader_default(C, &wrld->id); - rna_World_update(bmain, scene, ptr); + rna_World_update(CTX_data_main(C), CTX_data_scene(C), ptr); } #else @@ -581,6 +582,7 @@ void RNA_def_world(BlenderRNA *brna) prop = RNA_def_property(srna, "use_nodes", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "use_nodes", 1); RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); + RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE); RNA_def_property_ui_text(prop, "Use Nodes", "Use shader nodes to render the world"); RNA_def_property_update(prop, 0, "rna_World_use_nodes_update"); diff --git a/source/blender/nodes/CMakeLists.txt b/source/blender/nodes/CMakeLists.txt index 12842085189..f3b3d6b1f53 100644 --- a/source/blender/nodes/CMakeLists.txt +++ b/source/blender/nodes/CMakeLists.txt @@ -123,7 +123,7 @@ set(SRC composite/nodes/node_composite_pixelate.c composite/node_composite_tree.c - composite/node_composite_util.h + composite/node_composite_util.c shader/nodes/node_shader_camera.c shader/nodes/node_shader_common.c @@ -224,13 +224,16 @@ set(SRC intern/node_common.c intern/node_socket.c + composite/node_composite_util.h shader/node_shader_util.h texture/node_texture_util.h + NOD_common.h NOD_composite.h NOD_shader.h NOD_texture.h NOD_socket.h + NOD_static_types.h intern/node_util.h intern/node_exec.h intern/node_common.h diff --git a/source/blender/nodes/NOD_common.h b/source/blender/nodes/NOD_common.h new file mode 100644 index 00000000000..ac0ceab36d4 --- /dev/null +++ b/source/blender/nodes/NOD_common.h @@ -0,0 +1,54 @@ +/* + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * The Original Code is Copyright (C) 2005 Blender Foundation. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): Lukas Toenne. + * + * ***** END GPL LICENSE BLOCK ***** + */ + +/** \file NOD_common.h + * \ingroup nodes + */ + +#ifndef NOD_COMMON_H +#define NOD_COMMON_H + +#include "BKE_node.h" + +void register_node_type_frame(void); +void register_node_type_reroute(void); + +void register_node_type_group_input(void); +void register_node_type_group_output(void); + + +/* internal functions for editor */ +struct bNodeSocket *node_group_find_input_socket(struct bNode *groupnode, const char *identifier); +struct bNodeSocket *node_group_find_output_socket(struct bNode *groupnode, const char *identifier); +void node_group_verify(struct bNodeTree *ntree, struct bNode *node, struct ID *id); + +struct bNodeSocket *node_group_input_find_socket(struct bNode *node, const char *identifier); +struct bNodeSocket *node_group_output_find_socket(struct bNode *node, const char *identifier); +void node_group_input_verify(struct bNodeTree *ntree, struct bNode *node, struct ID *id); +void node_group_output_verify(struct bNodeTree *ntree, struct bNode *node, struct ID *id); + +#endif diff --git a/source/blender/nodes/NOD_composite.h b/source/blender/nodes/NOD_composite.h index 6d60ac0bb58..f272ec670e7 100644 --- a/source/blender/nodes/NOD_composite.h +++ b/source/blender/nodes/NOD_composite.h @@ -34,105 +34,109 @@ #include "BKE_node.h" -extern bNodeTreeType ntreeType_Composite; +extern struct bNodeTreeType *ntreeType_Composite; /* ****************** types array for all composite nodes ****************** */ -void register_node_type_cmp_group(struct bNodeTreeType *ttype); +void register_node_tree_type_cmp(void); -void register_node_type_cmp_rlayers(struct bNodeTreeType *ttype); -void register_node_type_cmp_image(struct bNodeTreeType *ttype); -void register_node_type_cmp_texture(struct bNodeTreeType *ttype); -void register_node_type_cmp_value(struct bNodeTreeType *ttype); -void register_node_type_cmp_rgb(struct bNodeTreeType *ttype); -void register_node_type_cmp_curve_time(struct bNodeTreeType *ttype); -void register_node_type_cmp_movieclip(struct bNodeTreeType *ttype); +void register_node_type_cmp_group(void); +void register_node_type_cmp_forloop(void); +void register_node_type_cmp_whileloop(void); + +void register_node_type_cmp_rlayers(void); +void register_node_type_cmp_image(void); +void register_node_type_cmp_texture(void); +void register_node_type_cmp_value(void); +void register_node_type_cmp_rgb(void); +void register_node_type_cmp_curve_time(void); +void register_node_type_cmp_movieclip(void); void register_node_type_cmp_usermask(struct bNodeTreeType *ttype); -void register_node_type_cmp_composite(struct bNodeTreeType *ttype); -void register_node_type_cmp_viewer(struct bNodeTreeType *ttype); -void register_node_type_cmp_splitviewer(struct bNodeTreeType *ttype); -void register_node_type_cmp_output_file(struct bNodeTreeType *ttype); -void register_node_type_cmp_view_levels(struct bNodeTreeType *ttype); - -void register_node_type_cmp_curve_rgb(struct bNodeTreeType *ttype); -void register_node_type_cmp_mix_rgb(struct bNodeTreeType *ttype); -void register_node_type_cmp_hue_sat(struct bNodeTreeType *ttype); -void register_node_type_cmp_brightcontrast(struct bNodeTreeType *ttype); -void register_node_type_cmp_gamma(struct bNodeTreeType *ttype); -void register_node_type_cmp_invert(struct bNodeTreeType *ttype); -void register_node_type_cmp_alphaover(struct bNodeTreeType *ttype); -void register_node_type_cmp_zcombine(struct bNodeTreeType *ttype); -void register_node_type_cmp_colorbalance(struct bNodeTreeType *ttype); -void register_node_type_cmp_huecorrect(struct bNodeTreeType *ttype); - -void register_node_type_cmp_normal(struct bNodeTreeType *ttype); -void register_node_type_cmp_curve_vec(struct bNodeTreeType *ttype); -void register_node_type_cmp_map_value(struct bNodeTreeType *ttype); -void register_node_type_cmp_map_range(struct bNodeTreeType *ttype); -void register_node_type_cmp_normalize(struct bNodeTreeType *ttype); - -void register_node_type_cmp_filter(struct bNodeTreeType *ttype); -void register_node_type_cmp_blur(struct bNodeTreeType *ttype); -void register_node_type_cmp_dblur(struct bNodeTreeType *ttype); -void register_node_type_cmp_bilateralblur(struct bNodeTreeType *ttype); -void register_node_type_cmp_vecblur(struct bNodeTreeType *ttype); -void register_node_type_cmp_dilateerode(struct bNodeTreeType *ttype); -void register_node_type_cmp_inpaint(struct bNodeTreeType *ttype); -void register_node_type_cmp_despeckle(struct bNodeTreeType *ttype); -void register_node_type_cmp_defocus(struct bNodeTreeType *ttype); - -void register_node_type_cmp_valtorgb(struct bNodeTreeType *ttype); -void register_node_type_cmp_rgbtobw(struct bNodeTreeType *ttype); -void register_node_type_cmp_setalpha(struct bNodeTreeType *ttype); -void register_node_type_cmp_idmask(struct bNodeTreeType *ttype); -void register_node_type_cmp_math(struct bNodeTreeType *ttype); -void register_node_type_cmp_seprgba(struct bNodeTreeType *ttype); -void register_node_type_cmp_combrgba(struct bNodeTreeType *ttype); -void register_node_type_cmp_sephsva(struct bNodeTreeType *ttype); -void register_node_type_cmp_combhsva(struct bNodeTreeType *ttype); -void register_node_type_cmp_sepyuva(struct bNodeTreeType *ttype); -void register_node_type_cmp_combyuva(struct bNodeTreeType *ttype); -void register_node_type_cmp_sepycca(struct bNodeTreeType *ttype); -void register_node_type_cmp_combycca(struct bNodeTreeType *ttype); -void register_node_type_cmp_premulkey(struct bNodeTreeType *ttype); - -void register_node_type_cmp_diff_matte(struct bNodeTreeType *ttype); -void register_node_type_cmp_distance_matte(struct bNodeTreeType *ttype); -void register_node_type_cmp_chroma_matte(struct bNodeTreeType *ttype); -void register_node_type_cmp_color_matte(struct bNodeTreeType *ttype); -void register_node_type_cmp_channel_matte(struct bNodeTreeType *ttype); -void register_node_type_cmp_color_spill(struct bNodeTreeType *ttype); -void register_node_type_cmp_luma_matte(struct bNodeTreeType *ttype); -void register_node_type_cmp_doubleedgemask(struct bNodeTreeType *ttype); -void register_node_type_cmp_keyingscreen(struct bNodeTreeType *ttype); -void register_node_type_cmp_keying(struct bNodeTreeType *ttype); - -void register_node_type_cmp_translate(struct bNodeTreeType *ttype); -void register_node_type_cmp_rotate(struct bNodeTreeType *ttype); -void register_node_type_cmp_scale(struct bNodeTreeType *ttype); -void register_node_type_cmp_flip(struct bNodeTreeType *ttype); -void register_node_type_cmp_crop(struct bNodeTreeType *ttype); -void register_node_type_cmp_displace(struct bNodeTreeType *ttype); -void register_node_type_cmp_mapuv(struct bNodeTreeType *ttype); -void register_node_type_cmp_transform(struct bNodeTreeType *ttype); -void register_node_type_cmp_stabilize2d(struct bNodeTreeType *ttype); -void register_node_type_cmp_moviedistortion(struct bNodeTreeType *ttype); -void register_node_type_cmp_mask(struct bNodeTreeType *ttype); - -void register_node_type_cmp_glare(struct bNodeTreeType *ttype); -void register_node_type_cmp_tonemap(struct bNodeTreeType *ttype); -void register_node_type_cmp_lensdist(struct bNodeTreeType *ttype); - - -void register_node_type_cmp_colorcorrection(struct bNodeTreeType *ttype); -void register_node_type_cmp_boxmask(struct bNodeTreeType *ttype); -void register_node_type_cmp_ellipsemask(struct bNodeTreeType *ttype); -void register_node_type_cmp_bokehimage(struct bNodeTreeType *ttype); -void register_node_type_cmp_bokehblur(struct bNodeTreeType *ttype); -void register_node_type_cmp_switch(struct bNodeTreeType *ttype); -void register_node_type_cmp_pixelate(struct bNodeTreeType *ttype); -void register_node_type_cmp_trackpos(struct bNodeTreeType *ttype); +void register_node_type_cmp_composite(void); +void register_node_type_cmp_viewer(void); +void register_node_type_cmp_splitviewer(void); +void register_node_type_cmp_output_file(void); +void register_node_type_cmp_view_levels(void); + +void register_node_type_cmp_curve_rgb(void); +void register_node_type_cmp_mix_rgb(void); +void register_node_type_cmp_hue_sat(void); +void register_node_type_cmp_brightcontrast(void); +void register_node_type_cmp_gamma(void); +void register_node_type_cmp_invert(void); +void register_node_type_cmp_alphaover(void); +void register_node_type_cmp_zcombine(void); +void register_node_type_cmp_colorbalance(void); +void register_node_type_cmp_huecorrect(void); + +void register_node_type_cmp_normal(void); +void register_node_type_cmp_curve_vec(void); +void register_node_type_cmp_map_value(void); +void register_node_type_cmp_map_range(void); +void register_node_type_cmp_normalize(void); + +void register_node_type_cmp_filter(void); +void register_node_type_cmp_blur(void); +void register_node_type_cmp_dblur(void); +void register_node_type_cmp_bilateralblur(void); +void register_node_type_cmp_vecblur(void); +void register_node_type_cmp_dilateerode(void); +void register_node_type_cmp_inpaint(void); +void register_node_type_cmp_despeckle(void); +void register_node_type_cmp_defocus(void); + +void register_node_type_cmp_valtorgb(void); +void register_node_type_cmp_rgbtobw(void); +void register_node_type_cmp_setalpha(void); +void register_node_type_cmp_idmask(void); +void register_node_type_cmp_math(void); +void register_node_type_cmp_seprgba(void); +void register_node_type_cmp_combrgba(void); +void register_node_type_cmp_sephsva(void); +void register_node_type_cmp_combhsva(void); +void register_node_type_cmp_sepyuva(void); +void register_node_type_cmp_combyuva(void); +void register_node_type_cmp_sepycca(void); +void register_node_type_cmp_combycca(void); +void register_node_type_cmp_premulkey(void); + +void register_node_type_cmp_diff_matte(void); +void register_node_type_cmp_distance_matte(void); +void register_node_type_cmp_chroma_matte(void); +void register_node_type_cmp_color_matte(void); +void register_node_type_cmp_channel_matte(void); +void register_node_type_cmp_color_spill(void); +void register_node_type_cmp_luma_matte(void); +void register_node_type_cmp_doubleedgemask(void); +void register_node_type_cmp_keyingscreen(void); +void register_node_type_cmp_keying(void); + +void register_node_type_cmp_translate(void); +void register_node_type_cmp_rotate(void); +void register_node_type_cmp_scale(void); +void register_node_type_cmp_flip(void); +void register_node_type_cmp_crop(void); +void register_node_type_cmp_displace(void); +void register_node_type_cmp_mapuv(void); +void register_node_type_cmp_transform(void); +void register_node_type_cmp_stabilize2d(void); +void register_node_type_cmp_moviedistortion(void); +void register_node_type_cmp_mask(void); + +void register_node_type_cmp_glare(void); +void register_node_type_cmp_tonemap(void); +void register_node_type_cmp_lensdist(void); + + +void register_node_type_cmp_colorcorrection(void); +void register_node_type_cmp_boxmask(void); +void register_node_type_cmp_ellipsemask(void); +void register_node_type_cmp_bokehimage(void); +void register_node_type_cmp_bokehblur(void); +void register_node_type_cmp_switch(void); +void register_node_type_cmp_pixelate(void); +void register_node_type_cmp_trackpos(void); #endif diff --git a/source/blender/nodes/NOD_shader.h b/source/blender/nodes/NOD_shader.h index 0a7a11e4506..9561fe00409 100644 --- a/source/blender/nodes/NOD_shader.h +++ b/source/blender/nodes/NOD_shader.h @@ -34,87 +34,91 @@ #include "BKE_node.h" -extern struct bNodeTreeType ntreeType_Shader; +extern struct bNodeTreeType *ntreeType_Shader; /* the type definitions array */ /* ****************** types array for all shaders ****************** */ -void register_node_type_sh_group(struct bNodeTreeType *ttype); - -void register_node_type_sh_output(struct bNodeTreeType *ttype); -void register_node_type_sh_material(struct bNodeTreeType *ttype); -void register_node_type_sh_camera(struct bNodeTreeType *ttype); -void register_node_type_sh_value(struct bNodeTreeType *ttype); -void register_node_type_sh_rgb(struct bNodeTreeType *ttype); -void register_node_type_sh_mix_rgb(struct bNodeTreeType *ttype); -void register_node_type_sh_valtorgb(struct bNodeTreeType *ttype); -void register_node_type_sh_rgbtobw(struct bNodeTreeType *ttype); -void register_node_type_sh_texture(struct bNodeTreeType *ttype); -void register_node_type_sh_normal(struct bNodeTreeType *ttype); -void register_node_type_sh_gamma(struct bNodeTreeType *ttype); -void register_node_type_sh_brightcontrast(struct bNodeTreeType *ttype); -void register_node_type_sh_geom(struct bNodeTreeType *ttype); -void register_node_type_sh_mapping(struct bNodeTreeType *ttype); -void register_node_type_sh_curve_vec(struct bNodeTreeType *ttype); -void register_node_type_sh_curve_rgb(struct bNodeTreeType *ttype); -void register_node_type_sh_math(struct bNodeTreeType *ttype); -void register_node_type_sh_vect_math(struct bNodeTreeType *ttype); -void register_node_type_sh_squeeze(struct bNodeTreeType *ttype); -void register_node_type_sh_dynamic(struct bNodeTreeType *ttype); -void register_node_type_sh_material_ext(struct bNodeTreeType *ttype); -void register_node_type_sh_invert(struct bNodeTreeType *ttype); -void register_node_type_sh_seprgb(struct bNodeTreeType *ttype); -void register_node_type_sh_combrgb(struct bNodeTreeType *ttype); -void register_node_type_sh_hue_sat(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_brick(struct bNodeTreeType *ttype); - -void register_node_type_sh_attribute(struct bNodeTreeType *ttype); -void register_node_type_sh_geometry(struct bNodeTreeType *ttype); -void register_node_type_sh_light_path(struct bNodeTreeType *ttype); -void register_node_type_sh_light_falloff(struct bNodeTreeType *ttype); -void register_node_type_sh_object_info(struct bNodeTreeType *ttype); -void register_node_type_sh_fresnel(struct bNodeTreeType *ttype); -void register_node_type_sh_layer_weight(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_coord(struct bNodeTreeType *ttype); -void register_node_type_sh_particle_info(struct bNodeTreeType *ttype); -void register_node_type_sh_hair_info(struct bNodeTreeType *ttype); -void register_node_type_sh_script(struct bNodeTreeType *ttype); -void register_node_type_sh_normal_map(struct bNodeTreeType *ttype); -void register_node_type_sh_tangent(struct bNodeTreeType *ttype); - -void register_node_type_sh_ambient_occlusion(struct bNodeTreeType *ttype); -void register_node_type_sh_background(struct bNodeTreeType *ttype); -void register_node_type_sh_bsdf_diffuse(struct bNodeTreeType *ttype); -void register_node_type_sh_bsdf_glossy(struct bNodeTreeType *ttype); -void register_node_type_sh_bsdf_glass(struct bNodeTreeType *ttype); -void register_node_type_sh_bsdf_refraction(struct bNodeTreeType *ttype); -void register_node_type_sh_bsdf_translucent(struct bNodeTreeType *ttype); -void register_node_type_sh_bsdf_transparent(struct bNodeTreeType *ttype); -void register_node_type_sh_bsdf_velvet(struct bNodeTreeType *ttype); -void register_node_type_sh_bsdf_anisotropic(struct bNodeTreeType *ttype); -void register_node_type_sh_emission(struct bNodeTreeType *ttype); -void register_node_type_sh_holdout(struct bNodeTreeType *ttype); -void register_node_type_sh_volume_transparent(struct bNodeTreeType *ttype); -void register_node_type_sh_volume_isotropic(struct bNodeTreeType *ttype); -void register_node_type_sh_mix_shader(struct bNodeTreeType *ttype); -void register_node_type_sh_add_shader(struct bNodeTreeType *ttype); - -void register_node_type_sh_output_lamp(struct bNodeTreeType *ttype); -void register_node_type_sh_output_material(struct bNodeTreeType *ttype); -void register_node_type_sh_output_world(struct bNodeTreeType *ttype); - -void register_node_type_sh_tex_image(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_environment(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_sky(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_voronoi(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_gradient(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_magic(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_wave(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_musgrave(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_noise(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_checker(struct bNodeTreeType *ttype); -void register_node_type_sh_bump(struct bNodeTreeType *ttype); +void register_node_tree_type_sh(void); + +void register_node_type_sh_group(void); +void register_node_type_sh_forloop(void); +void register_node_type_sh_whileloop(void); + +void register_node_type_sh_output(void); +void register_node_type_sh_material(void); +void register_node_type_sh_camera(void); +void register_node_type_sh_value(void); +void register_node_type_sh_rgb(void); +void register_node_type_sh_mix_rgb(void); +void register_node_type_sh_valtorgb(void); +void register_node_type_sh_rgbtobw(void); +void register_node_type_sh_texture(void); +void register_node_type_sh_normal(void); +void register_node_type_sh_gamma(void); +void register_node_type_sh_brightcontrast(void); +void register_node_type_sh_geom(void); +void register_node_type_sh_mapping(void); +void register_node_type_sh_curve_vec(void); +void register_node_type_sh_curve_rgb(void); +void register_node_type_sh_math(void); +void register_node_type_sh_vect_math(void); +void register_node_type_sh_squeeze(void); +void register_node_type_sh_dynamic(void); +void register_node_type_sh_material_ext(void); +void register_node_type_sh_invert(void); +void register_node_type_sh_seprgb(void); +void register_node_type_sh_combrgb(void); +void register_node_type_sh_hue_sat(void); +void register_node_type_sh_tex_brick(void); + +void register_node_type_sh_attribute(void); +void register_node_type_sh_geometry(void); +void register_node_type_sh_light_path(void); +void register_node_type_sh_light_falloff(void); +void register_node_type_sh_object_info(void); +void register_node_type_sh_fresnel(void); +void register_node_type_sh_layer_weight(void); +void register_node_type_sh_tex_coord(void); +void register_node_type_sh_particle_info(void); +void register_node_type_sh_hair_info(void); +void register_node_type_sh_script(void); +void register_node_type_sh_normal_map(void); +void register_node_type_sh_tangent(void); + +void register_node_type_sh_ambient_occlusion(void); +void register_node_type_sh_background(void); +void register_node_type_sh_bsdf_diffuse(void); +void register_node_type_sh_bsdf_glossy(void); +void register_node_type_sh_bsdf_glass(void); +void register_node_type_sh_bsdf_refraction(void); +void register_node_type_sh_bsdf_translucent(void); +void register_node_type_sh_bsdf_transparent(void); +void register_node_type_sh_bsdf_velvet(void); +void register_node_type_sh_bsdf_anisotropic(void); +void register_node_type_sh_emission(void); +void register_node_type_sh_holdout(void); +void register_node_type_sh_volume_transparent(void); +void register_node_type_sh_volume_isotropic(void); +void register_node_type_sh_mix_shader(void); +void register_node_type_sh_add_shader(void); + +void register_node_type_sh_output_lamp(void); +void register_node_type_sh_output_material(void); +void register_node_type_sh_output_world(void); + +void register_node_type_sh_tex_image(void); +void register_node_type_sh_tex_environment(void); +void register_node_type_sh_tex_sky(void); +void register_node_type_sh_tex_voronoi(void); +void register_node_type_sh_tex_gradient(void); +void register_node_type_sh_tex_magic(void); +void register_node_type_sh_tex_wave(void); +void register_node_type_sh_tex_musgrave(void); +void register_node_type_sh_tex_noise(void); +void register_node_type_sh_tex_checker(void); +void register_node_type_sh_bump(void); #endif diff --git a/source/blender/nodes/NOD_socket.h b/source/blender/nodes/NOD_socket.h index b14f7c4e884..5f7da1c3f4d 100644 --- a/source/blender/nodes/NOD_socket.h +++ b/source/blender/nodes/NOD_socket.h @@ -45,41 +45,11 @@ struct bNodeTree; struct bNode; struct bNodeStack; -void node_socket_type_init(struct bNodeSocketType *types[]); - -void *node_socket_make_default_value(int type); -void node_socket_free_default_value(int type, void *default_value); -void node_socket_init_default_value(int type, void *default_value); -void node_socket_copy_default_value(int type, void *to_default_value, void *from_default_value); -void node_socket_convert_default_value(int to_type, void *to_default_value, int from_type, void *from_default_value); - -void node_socket_set_default_value_int(void *default_value, PropertySubType subtype, int value, int min, int max); -void node_socket_set_default_value_float(void *default_value, PropertySubType subtype, float value, float min, float max); -void node_socket_set_default_value_boolean(void *default_value, char value); -void node_socket_set_default_value_vector(void *default_value, PropertySubType subtype, float x, float y, float z, float min, float max); -void node_socket_set_default_value_rgba(void *default_value, float r, float g, float b, float a); -void node_socket_set_default_value_shader(void *default_value); -void node_socket_set_default_value_mesh(void *default_value); -void node_socket_set_default_value_string(void *default_value, PropertySubType subtype, const char *value); - -struct bNodeSocket *node_add_input_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp); -struct bNodeSocket *node_add_output_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp); +struct bNodeSocket *node_add_socket_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp, int in_out); void node_verify_socket_templates(struct bNodeTree *ntree, struct bNode *node); - -/* Socket Converters */ - -#define SOCK_VECTOR_X 1 -#define SOCK_VECTOR_Y 2 -#define SOCK_VECTOR_Z 3 - -#define SOCK_RGBA_R 1 -#define SOCK_RGBA_G 2 -#define SOCK_RGBA_B 3 -#define SOCK_RGBA_A 4 - -#define SOCK_MESH_VERT_CO 1 -#define SOCK_MESH_VERT_NO 2 +void node_socket_init_default_value(struct bNodeSocket *sock); +void register_standard_node_socket_types(void); #endif diff --git a/source/blender/makesrna/intern/rna_nodetree_types.h b/source/blender/nodes/NOD_static_types.h index b7ec9235483..9d044772274 100644 --- a/source/blender/makesrna/intern/rna_nodetree_types.h +++ b/source/blender/nodes/NOD_static_types.h @@ -20,8 +20,8 @@ * ***** END GPL LICENSE BLOCK ***** */ -/** \file blender/makesrna/intern/rna_nodetree_types.h - * \ingroup RNA +/** \file blender/makesrna/intern/NOD_static_types.h + * \ingroup nodes */ /* intentionally no include guard */ @@ -34,6 +34,12 @@ /* 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", "" ) +DefNode( Node, NODE_GROUP, def_group, "GROUP", Group, "Group", "" ) +DefNode( Node, NODE_GROUP_INPUT, def_group_input, "GROUP_INPUT", GroupInput, "Group Input", "" ) +DefNode( Node, NODE_GROUP_OUTPUT, def_group_output, "GROUP_OUTPUT", GroupOutput, "Group Output", "" ) +DefNode( Node, NODE_REROUTE, 0, "REROUTE", Reroute, "Reroute", "" ) + DefNode( ShaderNode, SH_NODE_OUTPUT, 0, "OUTPUT", Output, "Output", "" ) DefNode( ShaderNode, SH_NODE_MATERIAL, def_sh_material, "MATERIAL", Material, "Material", "" ) DefNode( ShaderNode, SH_NODE_RGB, 0, "RGB", RGB, "RGB", "" ) @@ -186,7 +192,7 @@ DefNode( CompositorNode, CMP_NODE_KEYINGSCREEN, def_cmp_keyingscreen, "KEYIN 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( 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", "" ) @@ -209,6 +215,18 @@ DefNode( TextureNode, TEX_NODE_COMPOSE, 0, "COMPO DefNode( TextureNode, TEX_NODE_DECOMPOSE, 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", "" ) +/* 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", "" ) /* undefine macros */ diff --git a/source/blender/nodes/NOD_texture.h b/source/blender/nodes/NOD_texture.h index a1be9963b8a..ea003f23960 100644 --- a/source/blender/nodes/NOD_texture.h +++ b/source/blender/nodes/NOD_texture.h @@ -34,48 +34,52 @@ #include "BKE_node.h" -extern bNodeTreeType ntreeType_Texture; +extern struct bNodeTreeType *ntreeType_Texture; /* ****************** types array for all texture nodes ****************** */ -void register_node_type_tex_group(struct bNodeTreeType *ttype); +void register_node_tree_type_tex(void); -void register_node_type_tex_math(struct bNodeTreeType *ttype); -void register_node_type_tex_mix_rgb(struct bNodeTreeType *ttype); -void register_node_type_tex_valtorgb(struct bNodeTreeType *ttype); -void register_node_type_tex_valtonor(struct bNodeTreeType *ttype); -void register_node_type_tex_rgbtobw(struct bNodeTreeType *ttype); -void register_node_type_tex_output(struct bNodeTreeType *ttype); -void register_node_type_tex_viewer(struct bNodeTreeType *ttype); -void register_node_type_tex_checker(struct bNodeTreeType *ttype); -void register_node_type_tex_texture(struct bNodeTreeType *ttype); -void register_node_type_tex_bricks(struct bNodeTreeType *ttype); -void register_node_type_tex_image(struct bNodeTreeType *ttype); -void register_node_type_tex_curve_rgb(struct bNodeTreeType *ttype); -void register_node_type_tex_curve_time(struct bNodeTreeType *ttype); -void register_node_type_tex_invert(struct bNodeTreeType *ttype); -void register_node_type_tex_hue_sat(struct bNodeTreeType *ttype); -void register_node_type_tex_coord(struct bNodeTreeType *ttype); -void register_node_type_tex_distance(struct bNodeTreeType *ttype); +void register_node_type_tex_group(void); +void register_node_type_tex_forloop(void); +void register_node_type_tex_whileloop(void); -void register_node_type_tex_rotate(struct bNodeTreeType *ttype); -void register_node_type_tex_translate(struct bNodeTreeType *ttype); -void register_node_type_tex_scale(struct bNodeTreeType *ttype); -void register_node_type_tex_at(struct bNodeTreeType *ttype); +void register_node_type_tex_math(void); +void register_node_type_tex_mix_rgb(void); +void register_node_type_tex_valtorgb(void); +void register_node_type_tex_valtonor(void); +void register_node_type_tex_rgbtobw(void); +void register_node_type_tex_output(void); +void register_node_type_tex_viewer(void); +void register_node_type_tex_checker(void); +void register_node_type_tex_texture(void); +void register_node_type_tex_bricks(void); +void register_node_type_tex_image(void); +void register_node_type_tex_curve_rgb(void); +void register_node_type_tex_curve_time(void); +void register_node_type_tex_invert(void); +void register_node_type_tex_hue_sat(void); +void register_node_type_tex_coord(void); +void register_node_type_tex_distance(void); -void register_node_type_tex_compose(struct bNodeTreeType *ttype); -void register_node_type_tex_decompose(struct bNodeTreeType *ttype); +void register_node_type_tex_rotate(void); +void register_node_type_tex_translate(void); +void register_node_type_tex_scale(void); +void register_node_type_tex_at(void); -void register_node_type_tex_proc_voronoi(struct bNodeTreeType *ttype); -void register_node_type_tex_proc_blend(struct bNodeTreeType *ttype); -void register_node_type_tex_proc_magic(struct bNodeTreeType *ttype); -void register_node_type_tex_proc_marble(struct bNodeTreeType *ttype); -void register_node_type_tex_proc_clouds(struct bNodeTreeType *ttype); -void register_node_type_tex_proc_wood(struct bNodeTreeType *ttype); -void register_node_type_tex_proc_musgrave(struct bNodeTreeType *ttype); -void register_node_type_tex_proc_noise(struct bNodeTreeType *ttype); -void register_node_type_tex_proc_stucci(struct bNodeTreeType *ttype); -void register_node_type_tex_proc_distnoise(struct bNodeTreeType *ttype); +void register_node_type_tex_compose(void); +void register_node_type_tex_decompose(void); + +void register_node_type_tex_proc_voronoi(void); +void register_node_type_tex_proc_blend(void); +void register_node_type_tex_proc_magic(void); +void register_node_type_tex_proc_marble(void); +void register_node_type_tex_proc_clouds(void); +void register_node_type_tex_proc_wood(void); +void register_node_type_tex_proc_musgrave(void); +void register_node_type_tex_proc_noise(void); +void register_node_type_tex_proc_stucci(void); +void register_node_type_tex_proc_distnoise(void); #endif diff --git a/source/blender/nodes/composite/node_composite_tree.c b/source/blender/nodes/composite/node_composite_tree.c index 999bcb9bba5..d10ab9d8d49 100644 --- a/source/blender/nodes/composite/node_composite_tree.c +++ b/source/blender/nodes/composite/node_composite_tree.c @@ -44,6 +44,7 @@ #include "BKE_animsys.h" #include "BKE_colortools.h" +#include "BKE_context.h" #include "BKE_fcurve.h" #include "BKE_global.h" #include "BKE_main.h" @@ -64,14 +65,17 @@ #include "COM_compositor.h" #endif -static void foreach_nodetree(Main *main, void *calldata, bNodeTreeCallback func) +static void composite_get_from_context(const bContext *C, bNodeTreeType *UNUSED(treetype), bNodeTree **r_ntree, ID **r_id, ID **r_from) { - Scene *sce; - for (sce= main->scene.first; sce; sce= sce->id.next) { - if (sce->nodetree) { - func(calldata, &sce->id, sce->nodetree); - } - } + Scene *scene = CTX_data_scene(C); + + *r_from = NULL; + *r_id = &scene->id; + *r_ntree = scene->nodetree; + + /* update output sockets based on available layers */ + ntreeCompositForceHidden(scene->nodetree, scene); + } static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCallback func) @@ -85,6 +89,7 @@ static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCa func(calldata, NODE_CLASS_MATTE, N_("Matte")); func(calldata, NODE_CLASS_DISTORT, N_("Distort")); func(calldata, NODE_CLASS_GROUP, N_("Group")); + func(calldata, NODE_CLASS_INTERFACE, N_("Interface")); func(calldata, NODE_CLASS_LAYOUT, N_("Layout")); } @@ -106,22 +111,6 @@ static void free_cache(bNodeTree *ntree) free_node_cache(ntree, node); } -static void update_node(bNodeTree *ntree, bNode *node) -{ - bNodeSocket *sock; - - for (sock= node->outputs.first; sock; sock= sock->next) { - if (sock->cache) { - //free_compbuf(sock->cache); - //sock->cache= NULL; - } - } - node->need_exec= 1; - /* individual node update call */ - if (node->typeinfo->updatefunc) - node->typeinfo->updatefunc(ntree, node); -} - /* local tree then owns all compbufs */ static void localize(bNodeTree *localtree, bNodeTree *ntree) { @@ -145,16 +134,6 @@ static void localize(bNodeTree *localtree, bNodeTree *ntree) } } - /* copy over the preview buffers to update graduatly */ - if (node->preview) { - bNodePreview *preview = MEM_callocN(sizeof(bNodePreview), "Preview"); - preview->pad = node->preview->pad; - preview->xsize = node->preview->xsize; - preview->ysize = node->preview->ysize; - preview->rect = MEM_dupallocN(node->preview->rect); - node->new_node->preview = preview; - } - for (sock= node->outputs.first; sock; sock= sock->next) { sock->new_sock->cache= sock->cache; sock->cache= NULL; @@ -183,24 +162,8 @@ static void localize(bNodeTree *localtree, bNodeTree *ntree) } } -static void local_sync(bNodeTree *localtree, bNodeTree *ntree) +static void local_sync(bNodeTree *UNUSED(localtree), bNodeTree *UNUSED(ntree)) { - bNode *lnode; - - /* move over the compbufs and previews */ - for (lnode= localtree->nodes.first; lnode; lnode= lnode->next) { - if ( (lnode->exec & NODE_READY) && !(lnode->exec & NODE_SKIPPED) ) { - if (ntreeNodeExists(ntree, lnode->new_node)) { - - if (lnode->preview && lnode->preview->rect) { - nodeFreePreview(lnode->new_node); - lnode->new_node->preview= lnode->preview; - lnode->preview= NULL; - } - - } - } - } } static void local_merge(bNodeTree *localtree, bNodeTree *ntree) @@ -245,27 +208,38 @@ static void update(bNodeTree *ntree) ntreeSetOutput(ntree); ntree_update_reroute_nodes(ntree); + + if (ntree->update & NTREE_UPDATE_NODES) { + /* clean up preview cache, in case nodes have been removed */ + BKE_node_preview_remove_unused(ntree); + } } -bNodeTreeType ntreeType_Composite = { - /* type */ NTREE_COMPOSIT, - /* idname */ "NTCompositing Nodetree", +bNodeTreeType *ntreeType_Composite; + +void register_node_tree_type_cmp() +{ + bNodeTreeType *tt = ntreeType_Composite = MEM_callocN(sizeof(bNodeTreeType), "compositor node tree type"); - /* node_types */ { NULL, NULL }, + tt->type = NTREE_COMPOSIT; + strcpy(tt->idname, "CompositorNodeTree"); + strcpy(tt->ui_name, "Compositing"); + tt->ui_icon = 0; /* defined in drawnode.c */ + strcpy(tt->ui_description, ""); - /* free_cache */ free_cache, - /* free_node_cache */ free_node_cache, - /* foreach_nodetree */ foreach_nodetree, - /* foreach_nodeclass */ foreach_nodeclass, - /* localize */ localize, - /* local_sync */ local_sync, - /* local_merge */ local_merge, - /* update */ update, - /* update_node */ update_node, - /* validate_link */ NULL, - /* update_internal_links */ node_update_internal_links_default -}; - + tt->free_cache = free_cache; + tt->free_node_cache = free_node_cache; + tt->foreach_nodeclass = foreach_nodeclass; + tt->localize = localize; + tt->local_sync = local_sync; + tt->local_merge = local_merge; + tt->update = update; + tt->get_from_context = composite_get_from_context; + + tt->ext.srna = &RNA_CompositorNodeTree; + + ntreeTypeAdd(tt); +} void *COM_linker_hack = NULL; diff --git a/source/blender/nodes/composite/node_composite_util.c b/source/blender/nodes/composite/node_composite_util.c new file mode 100644 index 00000000000..b125473d5fa --- /dev/null +++ b/source/blender/nodes/composite/node_composite_util.c @@ -0,0 +1,59 @@ +/* + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * The Original Code is Copyright (C) 2006 Blender Foundation. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL LICENSE BLOCK ***** + */ + +/** \file blender/nodes/composite/node_composite_util.c + * \ingroup nodes + */ + +#include "node_composite_util.h" + + +int cmp_node_poll_default(bNodeType *UNUSED(ntype), bNodeTree *ntree) +{ + return (strcmp(ntree->idname, "CompositorNodeTree")==0); +} + +void cmp_node_update_default(bNodeTree *UNUSED(ntree), bNode *node) +{ + bNodeSocket *sock; + for(sock= node->outputs.first; sock; sock= sock->next) { + if(sock->cache) { + //free_compbuf(sock->cache); + //sock->cache= NULL; + } + } + node->need_exec= 1; +} + +void cmp_node_type_base(bNodeType *ntype, int type, const char *name, short nclass, short flag) +{ + node_type_base(ntype, type, name, nclass, flag); + + ntype->poll = cmp_node_poll_default; + ntype->updatefunc = cmp_node_update_default; + ntype->update_internal_links = node_update_internal_links_default; +} diff --git a/source/blender/nodes/composite/node_composite_util.h b/source/blender/nodes/composite/node_composite_util.h index a3c4bffe018..3f9cfc03089 100644 --- a/source/blender/nodes/composite/node_composite_util.h +++ b/source/blender/nodes/composite/node_composite_util.h @@ -59,4 +59,9 @@ #define CMP_SCALE_MAX 12000 +int cmp_node_poll_default(struct bNodeType *ntype, struct bNodeTree *ntree); +void cmp_node_update_default(struct bNodeTree *UNUSED(ntree), struct bNode *node); +void cmp_node_type_base(struct bNodeType *ntype, int type, const char *name, short nclass, short flag); + #endif /* __NODE_COMPOSITE_UTIL_H__ */ + diff --git a/source/blender/nodes/composite/nodes/node_composite_alphaOver.c b/source/blender/nodes/composite/nodes/node_composite_alphaOver.c index 217670621a8..d7c452e406e 100644 --- a/source/blender/nodes/composite/nodes/node_composite_alphaOver.c +++ b/source/blender/nodes/composite/nodes/node_composite_alphaOver.c @@ -43,19 +43,19 @@ static bNodeSocketTemplate cmp_node_alphaover_out[] = { { -1, 0, "" } }; -static void node_alphaover_init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_alphaover_init(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= MEM_callocN(sizeof(NodeTwoFloats), "NodeTwoFloats"); } -void register_node_type_cmp_alphaover(bNodeTreeType *ttype) +void register_node_type_cmp_alphaover() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_ALPHAOVER, "Alpha Over", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_ALPHAOVER, "Alpha Over", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_alphaover_in, cmp_node_alphaover_out); node_type_init(&ntype, node_alphaover_init); node_type_storage(&ntype, "NodeTwoFloats", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_bilateralblur.c b/source/blender/nodes/composite/nodes/node_composite_bilateralblur.c index b8bf379b14b..bb2f9023866 100644 --- a/source/blender/nodes/composite/nodes/node_composite_bilateralblur.c +++ b/source/blender/nodes/composite/nodes/node_composite_bilateralblur.c @@ -43,7 +43,7 @@ static bNodeSocketTemplate cmp_node_bilateralblur_out[] = { { -1, 0, "" } }; -static void node_composit_init_bilateralblur(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_bilateralblur(bNodeTree *UNUSED(ntree), bNode *node) { NodeBilateralBlurData *nbbd = MEM_callocN(sizeof(NodeBilateralBlurData), "node bilateral blur data"); node->storage = nbbd; @@ -51,14 +51,14 @@ static void node_composit_init_bilateralblur(bNodeTree *UNUSED(ntree), bNode *no nbbd->sigma_space = 5.0; } -void register_node_type_cmp_bilateralblur(bNodeTreeType *ttype) +void register_node_type_cmp_bilateralblur() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_BILATERALBLUR, "Bilateral Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_BILATERALBLUR, "Bilateral Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_bilateralblur_in, cmp_node_bilateralblur_out); node_type_init(&ntype, node_composit_init_bilateralblur); node_type_storage(&ntype, "NodeBilateralBlurData", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_blur.c b/source/blender/nodes/composite/nodes/node_composite_blur.c index 20fce05a40e..e531f1080cd 100644 --- a/source/blender/nodes/composite/nodes/node_composite_blur.c +++ b/source/blender/nodes/composite/nodes/node_composite_blur.c @@ -44,21 +44,21 @@ static bNodeSocketTemplate cmp_node_blur_out[] = { { -1, 0, "" } }; -static void node_composit_init_blur(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_blur(bNodeTree *UNUSED(ntree), bNode *node) { NodeBlurData *data = MEM_callocN(sizeof(NodeBlurData), "node blur data"); data->filtertype = R_FILTER_GAUSS; node->storage = data; } -void register_node_type_cmp_blur(bNodeTreeType *ttype) +void register_node_type_cmp_blur() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_BLUR, "Blur", NODE_CLASS_OP_FILTER, NODE_PREVIEW | NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_BLUR, "Blur", NODE_CLASS_OP_FILTER, NODE_PREVIEW | NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_blur_in, cmp_node_blur_out); node_type_init(&ntype, node_composit_init_blur); node_type_storage(&ntype, "NodeBlurData", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_bokehblur.c b/source/blender/nodes/composite/nodes/node_composite_bokehblur.c index ea3162a9e55..a2d9e6e1473 100644 --- a/source/blender/nodes/composite/nodes/node_composite_bokehblur.c +++ b/source/blender/nodes/composite/nodes/node_composite_bokehblur.c @@ -49,19 +49,19 @@ static bNodeSocketTemplate cmp_node_bokehblur_out[] = { { -1, 0, "" } }; -static void node_composit_init_bokehblur(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_bokehblur(bNodeTree *UNUSED(ntree), bNode *node) { node->custom3 = 4.0f; node->custom4 = 16.0f; } -void register_node_type_cmp_bokehblur(bNodeTreeType *ttype) +void register_node_type_cmp_bokehblur(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_BOKEHBLUR, "Bokeh Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_BOKEHBLUR, "Bokeh Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_bokehblur_in, cmp_node_bokehblur_out); node_type_init(&ntype, node_composit_init_bokehblur); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_bokehimage.c b/source/blender/nodes/composite/nodes/node_composite_bokehimage.c index b006280ca8a..c04682c42a6 100644 --- a/source/blender/nodes/composite/nodes/node_composite_bokehimage.c +++ b/source/blender/nodes/composite/nodes/node_composite_bokehimage.c @@ -41,7 +41,8 @@ static bNodeSocketTemplate cmp_node_bokehimage_out[] = { { SOCK_RGBA, 0, N_("Image"), 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f}, { -1, 0, "" } }; -static void node_composit_init_bokehimage(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) + +static void node_composit_init_bokehimage(bNodeTree *UNUSED(ntree), bNode *node) { NodeBokehImage * data = MEM_callocN(sizeof(NodeBokehImage), "NodeBokehImage"); data->angle = 0.0f; @@ -52,14 +53,14 @@ static void node_composit_init_bokehimage(bNodeTree *UNUSED(ntree), bNode *node, node->storage = data; } -void register_node_type_cmp_bokehimage(bNodeTreeType *ttype) +void register_node_type_cmp_bokehimage(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_BOKEHIMAGE, "Bokeh Image", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_BOKEHIMAGE, "Bokeh Image", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, cmp_node_bokehimage_out); node_type_init(&ntype, node_composit_init_bokehimage); node_type_storage(&ntype, "NodeBokehImage", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_boxmask.c b/source/blender/nodes/composite/nodes/node_composite_boxmask.c index eb2c58894f3..41820457b4b 100644 --- a/source/blender/nodes/composite/nodes/node_composite_boxmask.c +++ b/source/blender/nodes/composite/nodes/node_composite_boxmask.c @@ -44,7 +44,7 @@ static bNodeSocketTemplate cmp_node_boxmask_out[] = { { -1, 0, "" } }; -static void node_composit_init_boxmask(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_boxmask(bNodeTree *UNUSED(ntree), bNode *node) { NodeBoxMask *data = MEM_callocN(sizeof(NodeBoxMask), "NodeBoxMask"); data->x = 0.5; @@ -55,16 +55,16 @@ static void node_composit_init_boxmask(bNodeTree *UNUSED(ntree), bNode *node, bN node->storage = data; } -void register_node_type_cmp_boxmask(bNodeTreeType *ttype) +void register_node_type_cmp_boxmask(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MASK_BOX, "Box Mask", NODE_CLASS_MATTE, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MASK_BOX, "Box Mask", NODE_CLASS_MATTE, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_boxmask_in, cmp_node_boxmask_out); node_type_init(&ntype, node_composit_init_boxmask); node_type_storage(&ntype, "NodeBoxMask", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_brightness.c b/source/blender/nodes/composite/nodes/node_composite_brightness.c index 025f5c03c7c..babb753a98b 100644 --- a/source/blender/nodes/composite/nodes/node_composite_brightness.c +++ b/source/blender/nodes/composite/nodes/node_composite_brightness.c @@ -48,12 +48,12 @@ static bNodeSocketTemplate cmp_node_brightcontrast_out[] = { }; -void register_node_type_cmp_brightcontrast(bNodeTreeType *ttype) +void register_node_type_cmp_brightcontrast() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_BRIGHTCONTRAST, "Bright/Contrast", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_BRIGHTCONTRAST, "Bright/Contrast", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_brightcontrast_in, cmp_node_brightcontrast_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_channelMatte.c b/source/blender/nodes/composite/nodes/node_composite_channelMatte.c index acb0566be7c..b68bc066b12 100644 --- a/source/blender/nodes/composite/nodes/node_composite_channelMatte.c +++ b/source/blender/nodes/composite/nodes/node_composite_channelMatte.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate cmp_node_channel_matte_out[] = { {-1, 0, ""} }; -static void node_composit_init_channel_matte(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_channel_matte(bNodeTree *UNUSED(ntree), bNode *node) { NodeChroma *c= MEM_callocN(sizeof(NodeChroma), "node chroma"); node->storage=c; @@ -60,14 +60,14 @@ static void node_composit_init_channel_matte(bNodeTree *UNUSED(ntree), bNode *no node->custom2= 2; /* Green Channel */ } -void register_node_type_cmp_channel_matte(bNodeTreeType *ttype) +void register_node_type_cmp_channel_matte() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_CHANNEL_MATTE, "Channel Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_CHANNEL_MATTE, "Channel Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_channel_matte_in, cmp_node_channel_matte_out); node_type_init(&ntype, node_composit_init_channel_matte); node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_chromaMatte.c b/source/blender/nodes/composite/nodes/node_composite_chromaMatte.c index 29782c3bc51..f119c5ae04f 100644 --- a/source/blender/nodes/composite/nodes/node_composite_chromaMatte.c +++ b/source/blender/nodes/composite/nodes/node_composite_chromaMatte.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate cmp_node_chroma_out[] = { {-1, 0, ""} }; -static void node_composit_init_chroma_matte(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_chroma_matte(bNodeTree *UNUSED(ntree), bNode *node) { NodeChroma *c= MEM_callocN(sizeof(NodeChroma), "node chroma"); node->storage= c; @@ -56,14 +56,14 @@ static void node_composit_init_chroma_matte(bNodeTree *UNUSED(ntree), bNode *nod c->fstrength= 1.0f; } -void register_node_type_cmp_chroma_matte(bNodeTreeType *ttype) +void register_node_type_cmp_chroma_matte() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_CHROMA_MATTE, "Chroma Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_CHROMA_MATTE, "Chroma Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_chroma_in, cmp_node_chroma_out); node_type_init(&ntype, node_composit_init_chroma_matte); node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_colorMatte.c b/source/blender/nodes/composite/nodes/node_composite_colorMatte.c index 9905a2446b8..c1ed315adcb 100644 --- a/source/blender/nodes/composite/nodes/node_composite_colorMatte.c +++ b/source/blender/nodes/composite/nodes/node_composite_colorMatte.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate cmp_node_color_out[] = { {-1, 0, ""} }; -static void node_composit_init_color_matte(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_color_matte(bNodeTree *UNUSED(ntree), bNode *node) { NodeChroma *c= MEM_callocN(sizeof(NodeChroma), "node color"); node->storage= c; @@ -56,14 +56,14 @@ static void node_composit_init_color_matte(bNodeTree *UNUSED(ntree), bNode *node c->fstrength= 1.0f; } -void register_node_type_cmp_color_matte(bNodeTreeType *ttype) +void register_node_type_cmp_color_matte() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_COLOR_MATTE, "Color Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_COLOR_MATTE, "Color Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_color_in, cmp_node_color_out); node_type_init(&ntype, node_composit_init_color_matte); node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_colorSpill.c b/source/blender/nodes/composite/nodes/node_composite_colorSpill.c index 32fa446790e..848a5280992 100644 --- a/source/blender/nodes/composite/nodes/node_composite_colorSpill.c +++ b/source/blender/nodes/composite/nodes/node_composite_colorSpill.c @@ -43,7 +43,7 @@ static bNodeSocketTemplate cmp_node_color_spill_out[] = { {-1, 0, ""} }; -static void node_composit_init_color_spill(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_color_spill(bNodeTree *UNUSED(ntree), bNode *node) { NodeColorspill *ncs= MEM_callocN(sizeof(NodeColorspill), "node colorspill"); node->storage=ncs; @@ -54,14 +54,14 @@ static void node_composit_init_color_spill(bNodeTree *UNUSED(ntree), bNode *node ncs->unspill=0; /* do not use unspill */ } -void register_node_type_cmp_color_spill(bNodeTreeType *ttype) +void register_node_type_cmp_color_spill() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_COLOR_SPILL, "Color Spill", NODE_CLASS_MATTE, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_COLOR_SPILL, "Color Spill", NODE_CLASS_MATTE, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_color_spill_in, cmp_node_color_spill_out); node_type_init(&ntype, node_composit_init_color_spill); node_type_storage(&ntype, "NodeColorspill", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_colorbalance.c b/source/blender/nodes/composite/nodes/node_composite_colorbalance.c index da9ce64d994..ebd41441b31 100644 --- a/source/blender/nodes/composite/nodes/node_composite_colorbalance.c +++ b/source/blender/nodes/composite/nodes/node_composite_colorbalance.c @@ -46,7 +46,7 @@ static bNodeSocketTemplate cmp_node_colorbalance_out[] = { {-1, 0, ""} }; -static void node_composit_init_colorbalance(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_colorbalance(bNodeTree *UNUSED(ntree), bNode *node) { NodeColorBalance *n= node->storage= MEM_callocN(sizeof(NodeColorBalance), "node colorbalance"); @@ -55,15 +55,15 @@ static void node_composit_init_colorbalance(bNodeTree *UNUSED(ntree), bNode *nod n->gain[0] = n->gain[1] = n->gain[2] = 1.0f; } -void register_node_type_cmp_colorbalance(bNodeTreeType *ttype) +void register_node_type_cmp_colorbalance() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_COLORBALANCE, "Color Balance", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_COLORBALANCE, "Color Balance", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_colorbalance_in, cmp_node_colorbalance_out); node_type_size(&ntype, 400, 200, 400); node_type_init(&ntype, node_composit_init_colorbalance); node_type_storage(&ntype, "NodeColorBalance", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_colorcorrection.c b/source/blender/nodes/composite/nodes/node_composite_colorcorrection.c index 19f2fad2e42..9b09462ed0f 100644 --- a/source/blender/nodes/composite/nodes/node_composite_colorcorrection.c +++ b/source/blender/nodes/composite/nodes/node_composite_colorcorrection.c @@ -47,7 +47,7 @@ static bNodeSocketTemplate cmp_node_colorcorrection_out[] = { { -1,0,""} }; -static void node_composit_init_colorcorrection(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_colorcorrection(bNodeTree *UNUSED(ntree), bNode *node) { NodeColorCorrection *n= node->storage= MEM_callocN(sizeof(NodeColorCorrection), "node colorcorrection"); n->startmidtones = 0.2f; @@ -75,15 +75,15 @@ static void node_composit_init_colorcorrection(bNodeTree *UNUSED(ntree), bNode * node->custom1 = 7; // red + green + blue enabled } -void register_node_type_cmp_colorcorrection(bNodeTreeType *ttype) +void register_node_type_cmp_colorcorrection(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_COLORCORRECTION, "Color Correction", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_COLORCORRECTION, "Color Correction", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_colorcorrection_in, cmp_node_colorcorrection_out); node_type_size(&ntype, 400, 200, 600); node_type_init(&ntype, node_composit_init_colorcorrection); node_type_storage(&ntype, "NodeColorCorrection", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_common.c b/source/blender/nodes/composite/nodes/node_composite_common.c index 7198798a152..384653e7b41 100644 --- a/source/blender/nodes/composite/nodes/node_composite_common.c +++ b/source/blender/nodes/composite/nodes/node_composite_common.c @@ -33,25 +33,35 @@ #include "DNA_node_types.h" #include "node_composite_util.h" +#include "NOD_common.h" #include "node_common.h" #include "node_exec.h" #include "BKE_node.h" -void register_node_type_cmp_group(bNodeTreeType *ttype) +#include "RNA_access.h" + +void register_node_type_cmp_group() { static bNodeType ntype; - - node_type_base(ttype, &ntype, NODE_GROUP, "Group", NODE_CLASS_GROUP, NODE_OPTIONS | NODE_CONST_OUTPUT); + + /* NB: cannot use sh_node_type_base for node group, because it would map the node type + * to the shared NODE_GROUP integer type id. + */ + node_type_base_custom(&ntype, "CompositorNodeGroup", "Group", NODE_CLASS_GROUP, NODE_OPTIONS | NODE_CONST_OUTPUT); + ntype.type = NODE_GROUP; + ntype.poll = cmp_node_poll_default; + ntype.update_internal_links = node_update_internal_links_default; + ntype.ext.srna = RNA_struct_find("CompositorNodeGroup"); + BLI_assert(ntype.ext.srna != NULL); + RNA_struct_blender_type_set(ntype.ext.srna, &ntype); + node_type_socket_templates(&ntype, NULL, NULL); node_type_size(&ntype, 120, 60, 200); node_type_label(&ntype, node_group_label); - node_type_init(&ntype, node_group_init); - node_type_valid(&ntype, node_group_valid); - node_type_template(&ntype, node_group_template); node_type_update(&ntype, NULL, node_group_verify); - node_type_group_edit(&ntype, node_group_edit_get, node_group_edit_set, node_group_edit_clear); + strcpy(ntype.group_tree_idname, "CompositorNodeTree"); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_composite.c b/source/blender/nodes/composite/nodes/node_composite_composite.c index ea281a3f556..42e284e0c52 100644 --- a/source/blender/nodes/composite/nodes/node_composite_composite.c +++ b/source/blender/nodes/composite/nodes/node_composite_composite.c @@ -39,15 +39,15 @@ static bNodeSocketTemplate cmp_node_composite_in[] = { { -1, 0, "" } }; -void register_node_type_cmp_composite(bNodeTreeType *ttype) +void register_node_type_cmp_composite() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_COMPOSITE, "Composite", NODE_CLASS_OUTPUT, NODE_OPTIONS | NODE_PREVIEW); + cmp_node_type_base(&ntype, CMP_NODE_COMPOSITE, "Composite", NODE_CLASS_OUTPUT, NODE_OPTIONS | NODE_PREVIEW); node_type_socket_templates(&ntype, cmp_node_composite_in, NULL); /* Do not allow muting for this node. */ node_type_internal_links(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_crop.c b/source/blender/nodes/composite/nodes/node_composite_crop.c index 10af55480cd..bae36024b88 100644 --- a/source/blender/nodes/composite/nodes/node_composite_crop.c +++ b/source/blender/nodes/composite/nodes/node_composite_crop.c @@ -43,7 +43,7 @@ static bNodeSocketTemplate cmp_node_crop_out[] = { { -1, 0, "" } }; -static void node_composit_init_crop(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_crop(bNodeTree *UNUSED(ntree), bNode *node) { NodeTwoXYs *nxy= MEM_callocN(sizeof(NodeTwoXYs), "node xy data"); node->storage= nxy; @@ -53,14 +53,14 @@ static void node_composit_init_crop(bNodeTree *UNUSED(ntree), bNode *node, bNode nxy->y2= 0; } -void register_node_type_cmp_crop(bNodeTreeType *ttype) +void register_node_type_cmp_crop() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_CROP, "Crop", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_CROP, "Crop", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_crop_in, cmp_node_crop_out); node_type_init(&ntype, node_composit_init_crop); node_type_storage(&ntype, "NodeTwoXYs", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_curves.c b/source/blender/nodes/composite/nodes/node_composite_curves.c index 9f40159baf3..18999cdc985 100644 --- a/source/blender/nodes/composite/nodes/node_composite_curves.c +++ b/source/blender/nodes/composite/nodes/node_composite_curves.c @@ -41,24 +41,24 @@ static bNodeSocketTemplate cmp_node_time_out[] = { { -1, 0, "" } }; -static void node_composit_init_curves_time(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_curves_time(bNodeTree *UNUSED(ntree), bNode *node) { node->custom1= 1; node->custom2= 250; node->storage= curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f); } -void register_node_type_cmp_curve_time(bNodeTreeType *ttype) +void register_node_type_cmp_curve_time() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_TIME, "Time", NODE_CLASS_INPUT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_TIME, "Time", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, cmp_node_time_out); node_type_size(&ntype, 140, 100, 320); node_type_init(&ntype, node_composit_init_curves_time); node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -74,22 +74,22 @@ static bNodeSocketTemplate cmp_node_curve_vec_out[] = { { -1, 0, "" } }; -static void node_composit_init_curve_vec(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_curve_vec(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= curvemapping_add(3, -1.0f, -1.0f, 1.0f, 1.0f); } -void register_node_type_cmp_curve_vec(bNodeTreeType *ttype) +void register_node_type_cmp_curve_vec() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_CURVE_VEC, "Vector Curves", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_CURVE_VEC, "Vector Curves", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_curve_vec_in, cmp_node_curve_vec_out); node_type_size(&ntype, 200, 140, 320); node_type_init(&ntype, node_composit_init_curve_vec); node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -107,20 +107,20 @@ static bNodeSocketTemplate cmp_node_curve_rgb_out[] = { { -1, 0, "" } }; -static void node_composit_init_curve_rgb(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_curve_rgb(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= curvemapping_add(4, 0.0f, 0.0f, 1.0f, 1.0f); } -void register_node_type_cmp_curve_rgb(bNodeTreeType *ttype) +void register_node_type_cmp_curve_rgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_curve_rgb_in, cmp_node_curve_rgb_out); node_type_size(&ntype, 200, 140, 320); node_type_init(&ntype, node_composit_init_curve_rgb); node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_defocus.c b/source/blender/nodes/composite/nodes/node_composite_defocus.c index c05f1d6fcff..95d9e611584 100644 --- a/source/blender/nodes/composite/nodes/node_composite_defocus.c +++ b/source/blender/nodes/composite/nodes/node_composite_defocus.c @@ -44,7 +44,7 @@ static bNodeSocketTemplate cmp_node_defocus_out[] = { { -1, 0, "" } }; -static void node_composit_init_defocus(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_defocus(bNodeTree *UNUSED(ntree), bNode *node) { /* qdn: defocus node */ NodeDefocus *nbd = MEM_callocN(sizeof(NodeDefocus), "node defocus data"); @@ -61,14 +61,14 @@ static void node_composit_init_defocus(bNodeTree *UNUSED(ntree), bNode *node, bN node->storage = nbd; } -void register_node_type_cmp_defocus(bNodeTreeType *ttype) +void register_node_type_cmp_defocus() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_DEFOCUS, "Defocus", NODE_CLASS_OP_FILTER, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_DEFOCUS, "Defocus", NODE_CLASS_OP_FILTER, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_defocus_in, cmp_node_defocus_out); node_type_init(&ntype, node_composit_init_defocus); node_type_storage(&ntype, "NodeDefocus", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_despeckle.c b/source/blender/nodes/composite/nodes/node_composite_despeckle.c index 816a1803e47..9811e2762df 100644 --- a/source/blender/nodes/composite/nodes/node_composite_despeckle.c +++ b/source/blender/nodes/composite/nodes/node_composite_despeckle.c @@ -42,19 +42,19 @@ static bNodeSocketTemplate cmp_node_despeckle_out[] = { { -1, 0, "" } }; -static void node_composit_init_despeckle(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_despeckle(bNodeTree *UNUSED(ntree), bNode *node) { node->custom3 = 0.5f; node->custom4 = 0.5f; } -void register_node_type_cmp_despeckle(bNodeTreeType *ttype) +void register_node_type_cmp_despeckle() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_DESPECKLE, "Despeckle", NODE_CLASS_OP_FILTER, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_DESPECKLE, "Despeckle", NODE_CLASS_OP_FILTER, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_despeckle_in, cmp_node_despeckle_out); node_type_init(&ntype, node_composit_init_despeckle); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_diffMatte.c b/source/blender/nodes/composite/nodes/node_composite_diffMatte.c index 29712d54e32..1faf1d1e82c 100644 --- a/source/blender/nodes/composite/nodes/node_composite_diffMatte.c +++ b/source/blender/nodes/composite/nodes/node_composite_diffMatte.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate cmp_node_diff_matte_out[] = { {-1, 0, ""} }; -static void node_composit_init_diff_matte(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_diff_matte(bNodeTree *UNUSED(ntree), bNode *node) { NodeChroma *c= MEM_callocN(sizeof(NodeChroma), "node chroma"); node->storage= c; @@ -53,14 +53,14 @@ static void node_composit_init_diff_matte(bNodeTree *UNUSED(ntree), bNode *node, c->t2= 0.1f; } -void register_node_type_cmp_diff_matte(bNodeTreeType *ttype) +void register_node_type_cmp_diff_matte() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_DIFF_MATTE, "Difference Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_DIFF_MATTE, "Difference Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_diff_matte_in, cmp_node_diff_matte_out); node_type_init(&ntype, node_composit_init_diff_matte); node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_dilate.c b/source/blender/nodes/composite/nodes/node_composite_dilate.c index fabc54f61b3..d68a8c340d7 100644 --- a/source/blender/nodes/composite/nodes/node_composite_dilate.c +++ b/source/blender/nodes/composite/nodes/node_composite_dilate.c @@ -44,22 +44,21 @@ static bNodeSocketTemplate cmp_node_dilateerode_out[] = { { -1, 0, "" } }; -static void node_composit_init_dilateerode(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_dilateerode(bNodeTree *UNUSED(ntree), bNode *node) { NodeDilateErode *data = MEM_callocN(sizeof(NodeDilateErode), "NodeDilateErode"); data->falloff = PROP_SMOOTH; node->storage = data; } -void register_node_type_cmp_dilateerode(bNodeTreeType *ttype) +void register_node_type_cmp_dilateerode() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_DILATEERODE, "Dilate/Erode", NODE_CLASS_OP_FILTER, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_DILATEERODE, "Dilate/Erode", NODE_CLASS_OP_FILTER, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_dilateerode_in, cmp_node_dilateerode_out); node_type_init(&ntype, node_composit_init_dilateerode); - node_type_storage(&ntype, "NodeDilateErode", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_directionalblur.c b/source/blender/nodes/composite/nodes/node_composite_directionalblur.c index 6197d78563c..3a9c4928175 100644 --- a/source/blender/nodes/composite/nodes/node_composite_directionalblur.c +++ b/source/blender/nodes/composite/nodes/node_composite_directionalblur.c @@ -42,7 +42,7 @@ static bNodeSocketTemplate cmp_node_dblur_out[] = { { -1, 0, "" } }; -static void node_composit_init_dblur(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_dblur(bNodeTree *UNUSED(ntree), bNode *node) { NodeDBlurData *ndbd = MEM_callocN(sizeof(NodeDBlurData), "node dblur data"); node->storage = ndbd; @@ -50,14 +50,14 @@ static void node_composit_init_dblur(bNodeTree *UNUSED(ntree), bNode *node, bNod ndbd->center_y = 0.5; } -void register_node_type_cmp_dblur(bNodeTreeType *ttype) +void register_node_type_cmp_dblur() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_DBLUR, "Directional Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_DBLUR, "Directional Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_dblur_in, cmp_node_dblur_out); node_type_init(&ntype, node_composit_init_dblur); node_type_storage(&ntype, "NodeDBlurData", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_displace.c b/source/blender/nodes/composite/nodes/node_composite_displace.c index 251345d8a28..2ae7423b31b 100644 --- a/source/blender/nodes/composite/nodes/node_composite_displace.c +++ b/source/blender/nodes/composite/nodes/node_composite_displace.c @@ -47,12 +47,12 @@ static bNodeSocketTemplate cmp_node_displace_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_displace(bNodeTreeType *ttype) +void register_node_type_cmp_displace() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_DISPLACE, "Displace", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_DISPLACE, "Displace", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_displace_in, cmp_node_displace_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_distanceMatte.c b/source/blender/nodes/composite/nodes/node_composite_distanceMatte.c index 26f8055e7f2..1bbe71810c3 100644 --- a/source/blender/nodes/composite/nodes/node_composite_distanceMatte.c +++ b/source/blender/nodes/composite/nodes/node_composite_distanceMatte.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate cmp_node_distance_matte_out[] = { {-1, 0, ""} }; -static void node_composit_init_distance_matte(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_distance_matte(bNodeTree *UNUSED(ntree), bNode *node) { NodeChroma *c= MEM_callocN(sizeof(NodeChroma), "node chroma"); node->storage= c; @@ -54,14 +54,14 @@ static void node_composit_init_distance_matte(bNodeTree *UNUSED(ntree), bNode *n c->t2= 0.1f; } -void register_node_type_cmp_distance_matte(bNodeTreeType *ttype) +void register_node_type_cmp_distance_matte() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_DIST_MATTE, "Distance Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_DIST_MATTE, "Distance Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_distance_matte_in, cmp_node_distance_matte_out); node_type_init(&ntype, node_composit_init_distance_matte); node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_doubleEdgeMask.c b/source/blender/nodes/composite/nodes/node_composite_doubleEdgeMask.c index d5dd63a4042..767dfce4d59 100644 --- a/source/blender/nodes/composite/nodes/node_composite_doubleEdgeMask.c +++ b/source/blender/nodes/composite/nodes/node_composite_doubleEdgeMask.c @@ -42,12 +42,13 @@ static bNodeSocketTemplate cmp_node_doubleedgemask_out[] = { { -1, 0, "" } // output socket array terminator }; -void register_node_type_cmp_doubleedgemask(bNodeTreeType *ttype) +void register_node_type_cmp_doubleedgemask() { static bNodeType ntype; // allocate a node type data structure - node_type_base(ttype, &ntype, CMP_NODE_DOUBLEEDGEMASK, "Double Edge Mask", NODE_CLASS_MATTE, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_DOUBLEEDGEMASK, "Double Edge Mask", NODE_CLASS_MATTE, NODE_OPTIONS); + node_type_socket_templates(&ntype, cmp_node_doubleedgemask_in, cmp_node_doubleedgemask_out); node_type_socket_templates(&ntype, cmp_node_doubleedgemask_in, cmp_node_doubleedgemask_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_ellipsemask.c b/source/blender/nodes/composite/nodes/node_composite_ellipsemask.c index c2e34dc07a0..c4a01abc6d1 100644 --- a/source/blender/nodes/composite/nodes/node_composite_ellipsemask.c +++ b/source/blender/nodes/composite/nodes/node_composite_ellipsemask.c @@ -44,7 +44,7 @@ static bNodeSocketTemplate cmp_node_ellipsemask_out[] = { { -1, 0, "" } }; -static void node_composit_init_ellipsemask(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_ellipsemask(bNodeTree *UNUSED(ntree), bNode *node) { NodeEllipseMask *data = MEM_callocN(sizeof(NodeEllipseMask), "NodeEllipseMask"); data->x = 0.5; @@ -55,17 +55,17 @@ static void node_composit_init_ellipsemask(bNodeTree *UNUSED(ntree), bNode *node node->storage = data; } -void register_node_type_cmp_ellipsemask(bNodeTreeType *ttype) +void register_node_type_cmp_ellipsemask(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MASK_ELLIPSE, "Ellipse Mask", NODE_CLASS_MATTE, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MASK_ELLIPSE, "Ellipse Mask", NODE_CLASS_MATTE, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_ellipsemask_in, cmp_node_ellipsemask_out); node_type_size(&ntype, 260, 110, 320); node_type_init(&ntype, node_composit_init_ellipsemask); node_type_storage(&ntype, "NodeEllipseMask", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_filter.c b/source/blender/nodes/composite/nodes/node_composite_filter.c index 3ecc7282632..cdd3e136874 100644 --- a/source/blender/nodes/composite/nodes/node_composite_filter.c +++ b/source/blender/nodes/composite/nodes/node_composite_filter.c @@ -43,13 +43,13 @@ static bNodeSocketTemplate cmp_node_filter_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_filter(bNodeTreeType *ttype) +void register_node_type_cmp_filter() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_FILTER, "Filter", NODE_CLASS_OP_FILTER, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_FILTER, "Filter", NODE_CLASS_OP_FILTER, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_filter_in, cmp_node_filter_out); node_type_label(&ntype, node_filter_label); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_flip.c b/source/blender/nodes/composite/nodes/node_composite_flip.c index f56805809c5..0041cdfd44e 100644 --- a/source/blender/nodes/composite/nodes/node_composite_flip.c +++ b/source/blender/nodes/composite/nodes/node_composite_flip.c @@ -43,12 +43,12 @@ static bNodeSocketTemplate cmp_node_flip_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_flip(bNodeTreeType *ttype) +void register_node_type_cmp_flip() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_FLIP, "Flip", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_FLIP, "Flip", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_flip_in, cmp_node_flip_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_gamma.c b/source/blender/nodes/composite/nodes/node_composite_gamma.c index 6da56165979..43eaa26c863 100644 --- a/source/blender/nodes/composite/nodes/node_composite_gamma.c +++ b/source/blender/nodes/composite/nodes/node_composite_gamma.c @@ -45,12 +45,12 @@ static bNodeSocketTemplate cmp_node_gamma_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_gamma(bNodeTreeType *ttype) +void register_node_type_cmp_gamma() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_GAMMA, "Gamma", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_GAMMA, "Gamma", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_gamma_in, cmp_node_gamma_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_glare.c b/source/blender/nodes/composite/nodes/node_composite_glare.c index dde056de807..c2f889a7bf5 100644 --- a/source/blender/nodes/composite/nodes/node_composite_glare.c +++ b/source/blender/nodes/composite/nodes/node_composite_glare.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate cmp_node_glare_out[] = { { -1, 0, "" } }; -static void node_composit_init_glare(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_glare(bNodeTree *UNUSED(ntree), bNode *node) { NodeGlare *ndg = MEM_callocN(sizeof(NodeGlare), "node glare data"); ndg->quality = 1; @@ -57,14 +57,14 @@ static void node_composit_init_glare(bNodeTree *UNUSED(ntree), bNode *node, bNod node->storage = ndg; } -void register_node_type_cmp_glare(bNodeTreeType *ttype) +void register_node_type_cmp_glare() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_GLARE, "Glare", NODE_CLASS_OP_FILTER, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_GLARE, "Glare", NODE_CLASS_OP_FILTER, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_glare_in, cmp_node_glare_out); node_type_init(&ntype, node_composit_init_glare); node_type_storage(&ntype, "NodeGlare", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_hueSatVal.c b/source/blender/nodes/composite/nodes/node_composite_hueSatVal.c index 64ba24e082d..06ba1ba4851 100644 --- a/source/blender/nodes/composite/nodes/node_composite_hueSatVal.c +++ b/source/blender/nodes/composite/nodes/node_composite_hueSatVal.c @@ -44,7 +44,7 @@ static bNodeSocketTemplate cmp_node_hue_sat_out[] = { { -1, 0, "" } }; -static void node_composit_init_hue_sat(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_hue_sat(bNodeTree *UNUSED(ntree), bNode *node) { NodeHueSat *nhs= MEM_callocN(sizeof(NodeHueSat), "node hue sat"); node->storage= nhs; @@ -53,14 +53,14 @@ static void node_composit_init_hue_sat(bNodeTree *UNUSED(ntree), bNode *node, bN nhs->val= 1.0f; } -void register_node_type_cmp_hue_sat(bNodeTreeType *ttype) +void register_node_type_cmp_hue_sat() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_hue_sat_in, cmp_node_hue_sat_out); node_type_init(&ntype, node_composit_init_hue_sat); node_type_storage(&ntype, "NodeHueSat", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_huecorrect.c b/source/blender/nodes/composite/nodes/node_composite_huecorrect.c index 738f2f511f7..3ec4a9c9a4a 100644 --- a/source/blender/nodes/composite/nodes/node_composite_huecorrect.c +++ b/source/blender/nodes/composite/nodes/node_composite_huecorrect.c @@ -43,7 +43,7 @@ static bNodeSocketTemplate cmp_node_huecorrect_out[] = { { -1, 0, "" } }; -static void node_composit_init_huecorrect(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_huecorrect(bNodeTree *UNUSED(ntree), bNode *node) { CurveMapping *cumapping = node->storage= curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f); int c; @@ -59,15 +59,15 @@ static void node_composit_init_huecorrect(bNodeTree *UNUSED(ntree), bNode *node, cumapping->cur = 1; } -void register_node_type_cmp_huecorrect(bNodeTreeType *ttype) +void register_node_type_cmp_huecorrect() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_HUECORRECT, "Hue Correct", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_HUECORRECT, "Hue Correct", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_huecorrect_in, cmp_node_huecorrect_out); node_type_size(&ntype, 320, 140, 500); node_type_init(&ntype, node_composit_init_huecorrect); node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_idMask.c b/source/blender/nodes/composite/nodes/node_composite_idMask.c index 89ef4ad3d01..2d4fcc76462 100644 --- a/source/blender/nodes/composite/nodes/node_composite_idMask.c +++ b/source/blender/nodes/composite/nodes/node_composite_idMask.c @@ -44,12 +44,12 @@ static bNodeSocketTemplate cmp_node_idmask_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_idmask(bNodeTreeType *ttype) +void register_node_type_cmp_idmask() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_ID_MASK, "ID Mask", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_ID_MASK, "ID Mask", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_idmask_in, cmp_node_idmask_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_image.c b/source/blender/nodes/composite/nodes/node_composite_image.c index 563ad2b74b2..f9f289297d7 100644 --- a/source/blender/nodes/composite/nodes/node_composite_image.c +++ b/source/blender/nodes/composite/nodes/node_composite_image.c @@ -70,7 +70,7 @@ static bNodeSocket *cmp_node_image_add_render_pass_output(bNodeTree *ntree, bNod bNodeSocket *sock; NodeImageLayer *sockdata; - sock = node_add_output_from_template(ntree, node, &cmp_node_rlayers_out[rres_index]); + sock = node_add_socket_from_template(ntree, node, &cmp_node_rlayers_out[rres_index], SOCK_OUT); /* extra socket info */ sockdata = MEM_callocN(sizeof(NodeImageLayer), "node image layer"); sock->storage = sockdata; @@ -157,7 +157,7 @@ static void cmp_node_image_add_multilayer_outputs(bNodeTree *ntree, bNode *node, else type = SOCK_RGBA; - sock = nodeAddSocket(ntree, node, SOCK_OUT, rpass->name, type); + sock = nodeAddStaticSocket(ntree, node, SOCK_OUT, type, PROP_NONE, rpass->name, rpass->name); /* extra socket info */ sockdata = MEM_callocN(sizeof(NodeImageLayer), "node image layer"); sock->storage = sockdata; @@ -240,9 +240,6 @@ static void cmp_node_image_verify_outputs(bNodeTree *ntree, bNode *node) /* XXX make callback */ cmp_node_image_create_outputs(ntree, node); - /* flag all new sockets as dynamic, to prevent removal by socket verification function */ - for (newsock=node->outputs.first; newsock; newsock=newsock->next) - newsock->flag |= SOCK_DYNAMIC; for (newsock=node->outputs.first; newsock; newsock=newsock->next) { /* XXX make callback */ @@ -284,7 +281,7 @@ static void cmp_node_image_update(bNodeTree *ntree, bNode *node) cmp_node_image_verify_outputs(ntree, node); } -static void node_composit_init_image(bNodeTree *ntree, bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_image(bNodeTree *ntree, bNode *node) { ImageUser *iuser= MEM_callocN(sizeof(ImageUser), "node image user"); node->storage= iuser; @@ -308,38 +305,48 @@ static void node_composit_free_image(bNode *node) MEM_freeN(node->storage); } -static void node_composit_copy_image(bNode *orig_node, bNode *new_node) +static void node_composit_copy_image(bNodeTree *UNUSED(dest_ntree), bNode *dest_node, bNode *src_node) { bNodeSocket *sock; - new_node->storage= MEM_dupallocN(orig_node->storage); + dest_node->storage= MEM_dupallocN(src_node->storage); /* copy extra socket info */ - for (sock=orig_node->outputs.first; sock; sock=sock->next) + for (sock=src_node->outputs.first; sock; sock=sock->next) sock->new_sock->storage = MEM_dupallocN(sock->storage); } -void register_node_type_cmp_image(bNodeTreeType *ttype) +void register_node_type_cmp_image() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_IMAGE, "Image", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_IMAGE, "Image", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); node_type_init(&ntype, node_composit_init_image); node_type_storage(&ntype, "ImageUser", node_composit_free_image, node_composit_copy_image); node_type_update(&ntype, cmp_node_image_update, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } /* **************** RENDER RESULT ******************** */ -void register_node_type_cmp_rlayers(bNodeTreeType *ttype) +static int node_composit_poll_rlayers(bNodeType *UNUSED(ntype), bNodeTree *ntree) +{ + PointerRNA ptr; + + /* render layers node can only be used in local scene->nodetree, since it directly links to the scene */ + RNA_id_pointer_create((ID *)ntree, &ptr); + return (strcmp(ntree->idname, "CompositorNodeTree")==0 && RNA_boolean_get(&ptr, "is_local_tree")); +} + +void register_node_type_cmp_rlayers() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_R_LAYERS, "Render Layers", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_R_LAYERS, "Render Layers", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, cmp_node_rlayers_out); + ntype.poll = node_composit_poll_rlayers; - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_inpaint.c b/source/blender/nodes/composite/nodes/node_composite_inpaint.c index 4844b35fb62..83517d07b69 100644 --- a/source/blender/nodes/composite/nodes/node_composite_inpaint.c +++ b/source/blender/nodes/composite/nodes/node_composite_inpaint.c @@ -44,12 +44,12 @@ static bNodeSocketTemplate cmp_node_inpaint_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_inpaint(bNodeTreeType *ttype) +void register_node_type_cmp_inpaint(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_INPAINT, "Inpaint", NODE_CLASS_OP_FILTER, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_INPAINT, "Inpaint", NODE_CLASS_OP_FILTER, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_inpaint_in, cmp_node_inpaint_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_invert.c b/source/blender/nodes/composite/nodes/node_composite_invert.c index 0bfbe42868b..9765c3c8764 100644 --- a/source/blender/nodes/composite/nodes/node_composite_invert.c +++ b/source/blender/nodes/composite/nodes/node_composite_invert.c @@ -43,19 +43,19 @@ static bNodeSocketTemplate cmp_node_invert_out[] = { { -1, 0, "" } }; -static void node_composit_init_invert(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_invert(bNodeTree *UNUSED(ntree), bNode *node) { node->custom1 |= CMP_CHAN_RGB; } /* custom1 = mix type */ -void register_node_type_cmp_invert(bNodeTreeType *ttype) +void register_node_type_cmp_invert() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_invert_in, cmp_node_invert_out); node_type_init(&ntype, node_composit_init_invert); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_keying.c b/source/blender/nodes/composite/nodes/node_composite_keying.c index 51e0e9a8e39..464df4d72ab 100644 --- a/source/blender/nodes/composite/nodes/node_composite_keying.c +++ b/source/blender/nodes/composite/nodes/node_composite_keying.c @@ -60,7 +60,7 @@ static bNodeSocketTemplate cmp_node_keying_out[] = { { -1, 0, "" } }; -static void node_composit_init_keying(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_keying(bNodeTree *UNUSED(ntree), bNode *node) { NodeKeyingData *data; @@ -78,14 +78,14 @@ static void node_composit_init_keying(bNodeTree *UNUSED(ntree), bNode *node, bNo node->storage = data; } -void register_node_type_cmp_keying(bNodeTreeType *ttype) +void register_node_type_cmp_keying(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_KEYING, "Keying", NODE_CLASS_MATTE, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_KEYING, "Keying", NODE_CLASS_MATTE, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_keying_in, cmp_node_keying_out); node_type_init(&ntype, node_composit_init_keying); node_type_storage(&ntype, "NodeKeyingData", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_keyingscreen.c b/source/blender/nodes/composite/nodes/node_composite_keyingscreen.c index 1974087e8e7..b593196d815 100644 --- a/source/blender/nodes/composite/nodes/node_composite_keyingscreen.c +++ b/source/blender/nodes/composite/nodes/node_composite_keyingscreen.c @@ -50,7 +50,7 @@ static bNodeSocketTemplate cmp_node_keyingscreen_out[] = { { -1, 0, "" } }; -static void node_composit_init_keyingscreen(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_keyingscreen(bNodeTree *UNUSED(ntree), bNode *node) { NodeKeyingScreenData *data; @@ -59,14 +59,14 @@ static void node_composit_init_keyingscreen(bNodeTree *UNUSED(ntree), bNode *nod node->storage = data; } -void register_node_type_cmp_keyingscreen(bNodeTreeType *ttype) +void register_node_type_cmp_keyingscreen(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_KEYINGSCREEN, "Keying Screen", NODE_CLASS_MATTE, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_KEYINGSCREEN, "Keying Screen", NODE_CLASS_MATTE, NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, cmp_node_keyingscreen_out); node_type_init(&ntype, node_composit_init_keyingscreen); node_type_storage(&ntype, "NodeKeyingScreenData", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_lensdist.c b/source/blender/nodes/composite/nodes/node_composite_lensdist.c index 15d10e07946..78eeccbe4b1 100644 --- a/source/blender/nodes/composite/nodes/node_composite_lensdist.c +++ b/source/blender/nodes/composite/nodes/node_composite_lensdist.c @@ -43,7 +43,7 @@ static bNodeSocketTemplate cmp_node_lensdist_out[] = { { -1, 0, "" } }; -static void node_composit_init_lensdist(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_lensdist(bNodeTree *UNUSED(ntree), bNode *node) { NodeLensDist *nld = MEM_callocN(sizeof(NodeLensDist), "node lensdist data"); nld->jit = nld->proj = nld->fit = 0; @@ -51,14 +51,14 @@ static void node_composit_init_lensdist(bNodeTree *UNUSED(ntree), bNode *node, b } -void register_node_type_cmp_lensdist(bNodeTreeType *ttype) +void register_node_type_cmp_lensdist() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_LENSDIST, "Lens Distortion", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_LENSDIST, "Lens Distortion", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_lensdist_in, cmp_node_lensdist_out); node_type_init(&ntype, node_composit_init_lensdist); node_type_storage(&ntype, "NodeLensDist", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_levels.c b/source/blender/nodes/composite/nodes/node_composite_levels.c index f50a8838d74..2d24dfadbd3 100644 --- a/source/blender/nodes/composite/nodes/node_composite_levels.c +++ b/source/blender/nodes/composite/nodes/node_composite_levels.c @@ -45,19 +45,19 @@ static bNodeSocketTemplate cmp_node_view_levels_out[] = { {-1, 0, ""} }; -static void node_composit_init_view_levels(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_view_levels(bNodeTree *UNUSED(ntree), bNode *node) { node->custom1=1; /*All channels*/ } -void register_node_type_cmp_view_levels(bNodeTreeType *ttype) +void register_node_type_cmp_view_levels() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_VIEW_LEVELS, "Levels", NODE_CLASS_OUTPUT, NODE_OPTIONS|NODE_PREVIEW); + cmp_node_type_base(&ntype, CMP_NODE_VIEW_LEVELS, "Levels", NODE_CLASS_OUTPUT, NODE_OPTIONS|NODE_PREVIEW); node_type_socket_templates(&ntype, cmp_node_view_levels_in, cmp_node_view_levels_out); node_type_init(&ntype, node_composit_init_view_levels); node_type_storage(&ntype, "ImageUser", NULL, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_lummaMatte.c b/source/blender/nodes/composite/nodes/node_composite_lummaMatte.c index 60a7f3014de..2155db9ae20 100644 --- a/source/blender/nodes/composite/nodes/node_composite_lummaMatte.c +++ b/source/blender/nodes/composite/nodes/node_composite_lummaMatte.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate cmp_node_luma_matte_out[] = { {-1, 0, ""} }; -static void node_composit_init_luma_matte(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_luma_matte(bNodeTree *UNUSED(ntree), bNode *node) { NodeChroma *c= MEM_callocN(sizeof(NodeChroma), "node chroma"); node->storage=c; @@ -53,14 +53,14 @@ static void node_composit_init_luma_matte(bNodeTree *UNUSED(ntree), bNode *node, c->t2= 0.0f; } -void register_node_type_cmp_luma_matte(bNodeTreeType *ttype) +void register_node_type_cmp_luma_matte() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_LUMA_MATTE, "Luminance Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_LUMA_MATTE, "Luminance Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_luma_matte_in, cmp_node_luma_matte_out); node_type_init(&ntype, node_composit_init_luma_matte); node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_mapRange.c b/source/blender/nodes/composite/nodes/node_composite_mapRange.c index 07f34e79bd1..43d359db0a5 100644 --- a/source/blender/nodes/composite/nodes/node_composite_mapRange.c +++ b/source/blender/nodes/composite/nodes/node_composite_mapRange.c @@ -46,12 +46,12 @@ static bNodeSocketTemplate cmp_node_map_range_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_map_range(bNodeTreeType *ttype) +void register_node_type_cmp_map_range() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MAP_RANGE, "Map Range", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MAP_RANGE, "Map Range", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_map_range_in, cmp_node_map_range_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_mapUV.c b/source/blender/nodes/composite/nodes/node_composite_mapUV.c index fa4c8d7022c..eca8dea0470 100644 --- a/source/blender/nodes/composite/nodes/node_composite_mapUV.c +++ b/source/blender/nodes/composite/nodes/node_composite_mapUV.c @@ -44,12 +44,12 @@ static bNodeSocketTemplate cmp_node_mapuv_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_mapuv(bNodeTreeType *ttype) +void register_node_type_cmp_mapuv() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MAP_UV, "Map UV", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MAP_UV, "Map UV", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_mapuv_in, cmp_node_mapuv_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_mapValue.c b/source/blender/nodes/composite/nodes/node_composite_mapValue.c index 046eeaf4fc8..e12c7e2d2c7 100644 --- a/source/blender/nodes/composite/nodes/node_composite_mapValue.c +++ b/source/blender/nodes/composite/nodes/node_composite_mapValue.c @@ -42,19 +42,19 @@ static bNodeSocketTemplate cmp_node_map_value_out[] = { { -1, 0, "" } }; -static void node_composit_init_map_value(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_map_value(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= add_tex_mapping(); } -void register_node_type_cmp_map_value(bNodeTreeType *ttype) +void register_node_type_cmp_map_value() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MAP_VALUE, "Map Value", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MAP_VALUE, "Map Value", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_map_value_in, cmp_node_map_value_out); node_type_init(&ntype, node_composit_init_map_value); node_type_storage(&ntype, "TexMapping", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_mask.c b/source/blender/nodes/composite/nodes/node_composite_mask.c index 27534698422..f97e83f177a 100644 --- a/source/blender/nodes/composite/nodes/node_composite_mask.c +++ b/source/blender/nodes/composite/nodes/node_composite_mask.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate cmp_node_mask_out[] = { { -1, 0, "" } }; -static void node_composit_init_mask(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_mask(bNodeTree *UNUSED(ntree), bNode *node) { NodeMask *data = MEM_callocN(sizeof(NodeMask), "NodeMask"); data->size_x = data->size_y = 256; @@ -55,15 +55,15 @@ static void node_composit_init_mask(bNodeTree *UNUSED(ntree), bNode *node, bNode node->custom3 = 0.5f; /* shutter */ } -void register_node_type_cmp_mask(bNodeTreeType *ttype) +void register_node_type_cmp_mask(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MASK, "Mask", NODE_CLASS_INPUT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MASK, "Mask", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, cmp_node_mask_out); node_type_init(&ntype, node_composit_init_mask); node_type_storage(&ntype, "NodeMask", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_math.c b/source/blender/nodes/composite/nodes/node_composite_math.c index 5f5369ce03a..90c0d6ce30a 100644 --- a/source/blender/nodes/composite/nodes/node_composite_math.c +++ b/source/blender/nodes/composite/nodes/node_composite_math.c @@ -45,13 +45,13 @@ static bNodeSocketTemplate cmp_node_math_out[] = { }; -void register_node_type_cmp_math(bNodeTreeType *ttype) +void register_node_type_cmp_math() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_math_in, cmp_node_math_out); node_type_label(&ntype, node_math_label); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_mixrgb.c b/source/blender/nodes/composite/nodes/node_composite_mixrgb.c index 23e4fc90457..0a6559d4f2f 100644 --- a/source/blender/nodes/composite/nodes/node_composite_mixrgb.c +++ b/source/blender/nodes/composite/nodes/node_composite_mixrgb.c @@ -44,13 +44,13 @@ static bNodeSocketTemplate cmp_node_mix_rgb_out[] = { }; /* custom1 = mix type */ -void register_node_type_cmp_mix_rgb(bNodeTreeType *ttype) +void register_node_type_cmp_mix_rgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_mix_rgb_in, cmp_node_mix_rgb_out); node_type_label(&ntype, node_blend_label); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_movieclip.c b/source/blender/nodes/composite/nodes/node_composite_movieclip.c index 39d46e053bf..ae6f02452b4 100644 --- a/source/blender/nodes/composite/nodes/node_composite_movieclip.c +++ b/source/blender/nodes/composite/nodes/node_composite_movieclip.c @@ -42,7 +42,7 @@ static bNodeSocketTemplate cmp_node_movieclip_out[] = { { -1, 0, "" } }; -static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void init(bNodeTree *UNUSED(ntree), bNode *node) { MovieClipUser *user = MEM_callocN(sizeof(MovieClipUser), "node movie clip user"); @@ -50,14 +50,14 @@ static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(nt user->framenr = 1; } -void register_node_type_cmp_movieclip(bNodeTreeType *ttype) +void register_node_type_cmp_movieclip() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MOVIECLIP, "Movie Clip", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MOVIECLIP, "Movie Clip", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, cmp_node_movieclip_out); node_type_init(&ntype, init); node_type_storage(&ntype, "MovieClipUser", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_moviedistortion.c b/source/blender/nodes/composite/nodes/node_composite_moviedistortion.c index 198ffbb2857..b8770d1670e 100644 --- a/source/blender/nodes/composite/nodes/node_composite_moviedistortion.c +++ b/source/blender/nodes/composite/nodes/node_composite_moviedistortion.c @@ -60,21 +60,21 @@ static void storage_free(bNode *node) node->storage = NULL; } -static void storage_copy(bNode *orig_node, bNode *new_node) +static void storage_copy(bNodeTree *UNUSED(dest_ntree), bNode *dest_node, bNode *src_node) { - if (orig_node->storage) - new_node->storage = BKE_tracking_distortion_copy(orig_node->storage); + if (src_node->storage) + dest_node->storage = BKE_tracking_distortion_copy(src_node->storage); } -void register_node_type_cmp_moviedistortion(bNodeTreeType *ttype) +void register_node_type_cmp_moviedistortion() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MOVIEDISTORTION, "Movie Distortion", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MOVIEDISTORTION, "Movie Distortion", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_moviedistortion_in, cmp_node_moviedistortion_out); node_type_label(&ntype, label); node_type_storage(&ntype, NULL, storage_free, storage_copy); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_normal.c b/source/blender/nodes/composite/nodes/node_composite_normal.c index 88db5d36810..7a6d2fcd8e8 100644 --- a/source/blender/nodes/composite/nodes/node_composite_normal.c +++ b/source/blender/nodes/composite/nodes/node_composite_normal.c @@ -32,7 +32,6 @@ #include "node_composite_util.h" - /* **************** NORMAL ******************** */ static bNodeSocketTemplate cmp_node_normal_in[] = { { SOCK_VECTOR, 1, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_DIRECTION}, @@ -40,28 +39,17 @@ static bNodeSocketTemplate cmp_node_normal_in[] = { }; static bNodeSocketTemplate cmp_node_normal_out[] = { - { SOCK_VECTOR, 0, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_DIRECTION}, + { SOCK_VECTOR, 0, N_("Normal"), 0.0f, 0.0f, 1.0f, 0.0f, -1.0f, 1.0f, PROP_DIRECTION}, { SOCK_FLOAT, 0, N_("Dot")}, { -1, 0, "" } }; -static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) -{ - bNodeSocket *sock= node->outputs.first; - float *nor= ((bNodeSocketValueVector*)sock->default_value)->value; - - nor[0] = 0.0f; - nor[1] = 0.0f; - nor[2] = 1.0f; -} - -void register_node_type_cmp_normal(bNodeTreeType *ttype) +void register_node_type_cmp_normal() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_NORMAL, "Normal", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_NORMAL, "Normal", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_normal_in, cmp_node_normal_out); - node_type_init(&ntype, init); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_normalize.c b/source/blender/nodes/composite/nodes/node_composite_normalize.c index db811666900..2f19c6bc523 100644 --- a/source/blender/nodes/composite/nodes/node_composite_normalize.c +++ b/source/blender/nodes/composite/nodes/node_composite_normalize.c @@ -43,12 +43,12 @@ static bNodeSocketTemplate cmp_node_normalize_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_normalize(bNodeTreeType *ttype) +void register_node_type_cmp_normalize() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_NORMALIZE, "Normalize", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_NORMALIZE, "Normalize", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_normalize_in, cmp_node_normalize_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_outputFile.c b/source/blender/nodes/composite/nodes/node_composite_outputFile.c index d9a146ddaad..e008e17cbb0 100644 --- a/source/blender/nodes/composite/nodes/node_composite_outputFile.c +++ b/source/blender/nodes/composite/nodes/node_composite_outputFile.c @@ -34,6 +34,10 @@ #include "BLI_utildefines.h" #include "BLI_path_util.h" +#include "BKE_context.h" + +#include "RNA_access.h" + #include "node_composite_util.h" #include "IMB_imbuf.h" @@ -105,7 +109,7 @@ void ntreeCompositOutputFileUniqueLayer(ListBase *list, bNodeSocket *sock, const bNodeSocket *ntreeCompositOutputFileAddSocket(bNodeTree *ntree, bNode *node, const char *name, ImageFormatData *im_format) { NodeImageMultiFile *nimf = node->storage; - bNodeSocket *sock = nodeAddSocket(ntree, node, SOCK_IN, "", SOCK_RGBA); + bNodeSocket *sock = nodeAddStaticSocket(ntree, node, SOCK_IN, SOCK_RGBA, PROP_NONE, NULL, name); /* create format data for the input socket */ NodeImageMultiFileSocket *sockdata = MEM_callocN(sizeof(NodeImageMultiFileSocket), "socket image format"); @@ -165,14 +169,19 @@ void ntreeCompositOutputFileSetLayer(bNode *node, bNodeSocket *sock, const char ntreeCompositOutputFileUniqueLayer(&node->inputs, sock, name, '_'); } -static void init_output_file(bNodeTree *ntree, bNode *node, bNodeTemplate *ntemp) +/* XXX uses initfunc_api callback, regular initfunc does not support context yet */ +static void init_output_file(const bContext *C, PointerRNA *ptr) { + Scene *scene = CTX_data_scene(C); + bNodeTree *ntree = ptr->id.data; + bNode *node = ptr->data; NodeImageMultiFile *nimf= MEM_callocN(sizeof(NodeImageMultiFile), "node image multi file"); ImageFormatData *format = NULL; node->storage= nimf; + + if (scene) { + RenderData *rd = &scene->r; - if (ntemp->scene) { - RenderData *rd = &ntemp->scene->r; BLI_strncpy(nimf->base_path, rd->pic, sizeof(nimf->base_path)); nimf->format = rd->im_format; if (BKE_imtype_is_movie(nimf->format.imtype)) { @@ -200,41 +209,43 @@ static void free_output_file(bNode *node) MEM_freeN(node->storage); } -static void copy_output_file(struct bNode *node, struct bNode *target) +static void copy_output_file(bNodeTree *UNUSED(dest_ntree), bNode *dest_node, bNode *src_node) { - bNodeSocket *sock, *newsock; + bNodeSocket *src_sock, *dest_sock; - target->storage = MEM_dupallocN(node->storage); + dest_node->storage = MEM_dupallocN(src_node->storage); /* duplicate storage data in sockets */ - for (sock=node->inputs.first, newsock=target->inputs.first; sock && newsock; sock=sock->next, newsock=newsock->next) { - newsock->storage = MEM_dupallocN(sock->storage); + for (src_sock=src_node->inputs.first, dest_sock=dest_node->inputs.first; src_sock && dest_sock; src_sock=src_sock->next, dest_sock=dest_sock->next) { + dest_sock->storage = MEM_dupallocN(src_sock->storage); } } -static void update_output_file(bNodeTree *UNUSED(ntree), bNode *node) +static void update_output_file(bNodeTree *ntree, bNode *node) { bNodeSocket *sock; + PointerRNA ptr; + + cmp_node_update_default(ntree, node); /* automatically update the socket type based on linked input */ for (sock=node->inputs.first; sock; sock=sock->next) { if (sock->link) { - int linktype = sock->link->fromsock->type; - if (linktype != sock->type) - nodeSocketSetType(sock, linktype); + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr); + RNA_enum_set(&ptr, "type", sock->link->fromsock->type); } } } -void register_node_type_cmp_output_file(bNodeTreeType *ttype) +void register_node_type_cmp_output_file() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_OUTPUT_FILE, "File Output", NODE_CLASS_OUTPUT, NODE_OPTIONS|NODE_PREVIEW); + cmp_node_type_base(&ntype, CMP_NODE_OUTPUT_FILE, "File Output", NODE_CLASS_OUTPUT, NODE_OPTIONS|NODE_PREVIEW); node_type_socket_templates(&ntype, NULL, NULL); - node_type_init(&ntype, init_output_file); + ntype.initfunc_api = init_output_file; node_type_storage(&ntype, "NodeImageMultiFile", free_output_file, copy_output_file); node_type_update(&ntype, update_output_file, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_pixelate.c b/source/blender/nodes/composite/nodes/node_composite_pixelate.c index 3b65a2cdbd5..bb8df65ee23 100644 --- a/source/blender/nodes/composite/nodes/node_composite_pixelate.c +++ b/source/blender/nodes/composite/nodes/node_composite_pixelate.c @@ -45,12 +45,12 @@ static bNodeSocketTemplate cmp_node_pixelate_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_pixelate(bNodeTreeType *ttype) +void register_node_type_cmp_pixelate() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_PIXELATE, "Pixelate", NODE_CLASS_OP_FILTER, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_PIXELATE, "Pixelate", NODE_CLASS_OP_FILTER, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_pixelate_in, cmp_node_pixelate_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_premulkey.c b/source/blender/nodes/composite/nodes/node_composite_premulkey.c index 01eb3607760..75e34335c3a 100644 --- a/source/blender/nodes/composite/nodes/node_composite_premulkey.c +++ b/source/blender/nodes/composite/nodes/node_composite_premulkey.c @@ -44,12 +44,12 @@ static bNodeSocketTemplate cmp_node_premulkey_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_premulkey(bNodeTreeType *ttype) +void register_node_type_cmp_premulkey() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_PREMULKEY, "Alpha Convert", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_PREMULKEY, "Alpha Convert", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_premulkey_in, cmp_node_premulkey_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_rgb.c b/source/blender/nodes/composite/nodes/node_composite_rgb.c index 30b23a4c146..d2ebd84487d 100644 --- a/source/blender/nodes/composite/nodes/node_composite_rgb.c +++ b/source/blender/nodes/composite/nodes/node_composite_rgb.c @@ -32,32 +32,19 @@ #include "node_composite_util.h" - /* **************** RGB ******************** */ static bNodeSocketTemplate cmp_node_rgb_out[] = { - { SOCK_RGBA, 0, N_("RGBA"), 0.5f, 0.5f, 0.5f, 1.0f}, + { SOCK_RGBA, 0, N_("RGBA"), 0.5f, 0.5f, 0.5f, 1.0f}, { -1, 0, "" } }; -static void node_composit_init_rgb(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) -{ - bNodeSocket *sock= node->outputs.first; - float *col= ((bNodeSocketValueRGBA*)sock->default_value)->value; - /* uses the default value of the output socket, must be initialized here */ - col[0] = 0.5f; - col[1] = 0.5f; - col[2] = 0.5f; - col[3] = 1.0f; -} - -void register_node_type_cmp_rgb(bNodeTreeType *ttype) +void register_node_type_cmp_rgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_RGB, "RGB", NODE_CLASS_INPUT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_RGB, "RGB", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, cmp_node_rgb_out); - node_type_init(&ntype, node_composit_init_rgb); node_type_size_preset(&ntype, NODE_SIZE_SMALL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_rotate.c b/source/blender/nodes/composite/nodes/node_composite_rotate.c index 6b5521ea4d2..f52d54b9c64 100644 --- a/source/blender/nodes/composite/nodes/node_composite_rotate.c +++ b/source/blender/nodes/composite/nodes/node_composite_rotate.c @@ -44,18 +44,18 @@ static bNodeSocketTemplate cmp_node_rotate_out[] = { { -1, 0, "" } }; -static void node_composit_init_rotate(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_rotate(bNodeTree *UNUSED(ntree), bNode *node) { node->custom1= 1; /* Bilinear Filter*/ } -void register_node_type_cmp_rotate(bNodeTreeType *ttype) +void register_node_type_cmp_rotate() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_ROTATE, "Rotate", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_ROTATE, "Rotate", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_rotate_in, cmp_node_rotate_out); node_type_init(&ntype, node_composit_init_rotate); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_scale.c b/source/blender/nodes/composite/nodes/node_composite_scale.c index 6c2c6c37cb7..284b6dca72d 100644 --- a/source/blender/nodes/composite/nodes/node_composite_scale.c +++ b/source/blender/nodes/composite/nodes/node_composite_scale.c @@ -45,12 +45,12 @@ static bNodeSocketTemplate cmp_node_scale_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_scale(bNodeTreeType *ttype) +void register_node_type_cmp_scale() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_SCALE, "Scale", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_SCALE, "Scale", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_scale_in, cmp_node_scale_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_sepcombHSVA.c b/source/blender/nodes/composite/nodes/node_composite_sepcombHSVA.c index d463f35a07a..2043812c6eb 100644 --- a/source/blender/nodes/composite/nodes/node_composite_sepcombHSVA.c +++ b/source/blender/nodes/composite/nodes/node_composite_sepcombHSVA.c @@ -46,14 +46,14 @@ static bNodeSocketTemplate cmp_node_sephsva_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_sephsva(bNodeTreeType *ttype) +void register_node_type_cmp_sephsva() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_SEPHSVA, "Separate HSVA", NODE_CLASS_CONVERTOR, 0); + cmp_node_type_base(&ntype, CMP_NODE_SEPHSVA, "Separate HSVA", NODE_CLASS_CONVERTOR, 0); node_type_socket_templates(&ntype, cmp_node_sephsva_in, cmp_node_sephsva_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -70,12 +70,12 @@ static bNodeSocketTemplate cmp_node_combhsva_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_combhsva(bNodeTreeType *ttype) +void register_node_type_cmp_combhsva() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_COMBHSVA, "Combine HSVA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_COMBHSVA, "Combine HSVA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_combhsva_in, cmp_node_combhsva_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_sepcombRGBA.c b/source/blender/nodes/composite/nodes/node_composite_sepcombRGBA.c index 03b43f5073f..6b522184fe7 100644 --- a/source/blender/nodes/composite/nodes/node_composite_sepcombRGBA.c +++ b/source/blender/nodes/composite/nodes/node_composite_sepcombRGBA.c @@ -45,14 +45,14 @@ static bNodeSocketTemplate cmp_node_seprgba_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_seprgba(bNodeTreeType *ttype) +void register_node_type_cmp_seprgba() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_SEPRGBA, "Separate RGBA", NODE_CLASS_CONVERTOR, 0); + cmp_node_type_base(&ntype, CMP_NODE_SEPRGBA, "Separate RGBA", NODE_CLASS_CONVERTOR, 0); node_type_socket_templates(&ntype, cmp_node_seprgba_in, cmp_node_seprgba_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -70,12 +70,12 @@ static bNodeSocketTemplate cmp_node_combrgba_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_combrgba(bNodeTreeType *ttype) +void register_node_type_cmp_combrgba() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_COMBRGBA, "Combine RGBA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_COMBRGBA, "Combine RGBA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_combrgba_in, cmp_node_combrgba_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_sepcombYCCA.c b/source/blender/nodes/composite/nodes/node_composite_sepcombYCCA.c index 16aba1ba408..5940cf18c8a 100644 --- a/source/blender/nodes/composite/nodes/node_composite_sepcombYCCA.c +++ b/source/blender/nodes/composite/nodes/node_composite_sepcombYCCA.c @@ -47,14 +47,14 @@ static bNodeSocketTemplate cmp_node_sepycca_out[] = { }; -void register_node_type_cmp_sepycca(bNodeTreeType *ttype) +void register_node_type_cmp_sepycca() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_SEPYCCA, "Separate YCbCrA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_SEPYCCA, "Separate YCbCrA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_sepycca_in, cmp_node_sepycca_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -72,12 +72,12 @@ static bNodeSocketTemplate cmp_node_combycca_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_combycca(bNodeTreeType *ttype) +void register_node_type_cmp_combycca() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_COMBYCCA, "Combine YCbCrA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_COMBYCCA, "Combine YCbCrA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_combycca_in, cmp_node_combycca_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_sepcombYUVA.c b/source/blender/nodes/composite/nodes/node_composite_sepcombYUVA.c index 7d7ec166fd4..01dfd3b1abd 100644 --- a/source/blender/nodes/composite/nodes/node_composite_sepcombYUVA.c +++ b/source/blender/nodes/composite/nodes/node_composite_sepcombYUVA.c @@ -46,15 +46,14 @@ static bNodeSocketTemplate cmp_node_sepyuva_out[] = { { -1, 0, "" } }; - -void register_node_type_cmp_sepyuva(bNodeTreeType *ttype) +void register_node_type_cmp_sepyuva() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_SEPYUVA, "Separate YUVA", NODE_CLASS_CONVERTOR, 0); + cmp_node_type_base(&ntype, CMP_NODE_SEPYUVA, "Separate YUVA", NODE_CLASS_CONVERTOR, 0); node_type_socket_templates(&ntype, cmp_node_sepyuva_in, cmp_node_sepyuva_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -72,12 +71,12 @@ static bNodeSocketTemplate cmp_node_combyuva_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_combyuva(bNodeTreeType *ttype) +void register_node_type_cmp_combyuva() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_COMBYUVA, "Combine YUVA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_COMBYUVA, "Combine YUVA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_combyuva_in, cmp_node_combyuva_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_setalpha.c b/source/blender/nodes/composite/nodes/node_composite_setalpha.c index d36acc6c054..30e408dcccb 100644 --- a/source/blender/nodes/composite/nodes/node_composite_setalpha.c +++ b/source/blender/nodes/composite/nodes/node_composite_setalpha.c @@ -43,12 +43,12 @@ static bNodeSocketTemplate cmp_node_setalpha_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_setalpha(bNodeTreeType *ttype) +void register_node_type_cmp_setalpha() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_SETALPHA, "Set Alpha", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_SETALPHA, "Set Alpha", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_setalpha_in, cmp_node_setalpha_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_splitViewer.c b/source/blender/nodes/composite/nodes/node_composite_splitViewer.c index 38a6981613a..9fd61eca668 100644 --- a/source/blender/nodes/composite/nodes/node_composite_splitViewer.c +++ b/source/blender/nodes/composite/nodes/node_composite_splitViewer.c @@ -39,7 +39,7 @@ static bNodeSocketTemplate cmp_node_splitviewer_in[] = { { -1, 0, "" } }; -static void node_composit_init_splitviewer(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_splitviewer(bNodeTree *UNUSED(ntree), bNode *node) { ImageUser *iuser= MEM_callocN(sizeof(ImageUser), "node image user"); node->storage= iuser; @@ -49,11 +49,11 @@ static void node_composit_init_splitviewer(bNodeTree *UNUSED(ntree), bNode *node node->custom1= 50; /* default 50% split */ } -void register_node_type_cmp_splitviewer(bNodeTreeType *ttype) +void register_node_type_cmp_splitviewer() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_SPLITVIEWER, "Split Viewer", NODE_CLASS_OUTPUT, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_SPLITVIEWER, "Split Viewer", NODE_CLASS_OUTPUT, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_splitviewer_in, NULL); node_type_init(&ntype, node_composit_init_splitviewer); node_type_storage(&ntype, "ImageUser", node_free_standard_storage, node_copy_standard_storage); @@ -61,5 +61,5 @@ void register_node_type_cmp_splitviewer(bNodeTreeType *ttype) /* Do not allow muting for this node. */ node_type_internal_links(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_stabilize2d.c b/source/blender/nodes/composite/nodes/node_composite_stabilize2d.c index 6b345b4c15c..2aa2906d67a 100644 --- a/source/blender/nodes/composite/nodes/node_composite_stabilize2d.c +++ b/source/blender/nodes/composite/nodes/node_composite_stabilize2d.c @@ -45,12 +45,12 @@ static bNodeSocketTemplate cmp_node_stabilize2d_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_stabilize2d(bNodeTreeType *ttype) +void register_node_type_cmp_stabilize2d() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_STABILIZE2D, "Stabilize 2D", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_STABILIZE2D, "Stabilize 2D", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_stabilize2d_in, cmp_node_stabilize2d_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_switch.c b/source/blender/nodes/composite/nodes/node_composite_switch.c index 49fa61a8397..a6254de62d5 100644 --- a/source/blender/nodes/composite/nodes/node_composite_switch.c +++ b/source/blender/nodes/composite/nodes/node_composite_switch.c @@ -46,13 +46,13 @@ static bNodeSocketTemplate cmp_node_switch_out[] = { }; /* custom1 = mix type */ -void register_node_type_cmp_switch(bNodeTreeType *ttype) +void register_node_type_cmp_switch(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_SWITCH, "Switch", NODE_CLASS_LAYOUT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_SWITCH, "Switch", NODE_CLASS_LAYOUT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_switch_in, cmp_node_switch_out); node_type_size_preset(&ntype, NODE_SIZE_SMALL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_texture.c b/source/blender/nodes/composite/nodes/node_composite_texture.c index 515093fc3e1..3793dd4669a 100644 --- a/source/blender/nodes/composite/nodes/node_composite_texture.c +++ b/source/blender/nodes/composite/nodes/node_composite_texture.c @@ -44,12 +44,12 @@ static bNodeSocketTemplate cmp_node_texture_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_texture(bNodeTreeType *ttype) +void register_node_type_cmp_texture() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW); + cmp_node_type_base(&ntype, CMP_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW); node_type_socket_templates(&ntype, cmp_node_texture_in, cmp_node_texture_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_tonemap.c b/source/blender/nodes/composite/nodes/node_composite_tonemap.c index fd3a217b150..4f43297a182 100644 --- a/source/blender/nodes/composite/nodes/node_composite_tonemap.c +++ b/source/blender/nodes/composite/nodes/node_composite_tonemap.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate cmp_node_tonemap_out[] = { { -1, 0, "" } }; -static void node_composit_init_tonemap(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_tonemap(bNodeTree *UNUSED(ntree), bNode *node) { NodeTonemap *ntm = MEM_callocN(sizeof(NodeTonemap), "node tonemap data"); ntm->type = 1; @@ -57,14 +57,14 @@ static void node_composit_init_tonemap(bNodeTree *UNUSED(ntree), bNode *node, bN node->storage = ntm; } -void register_node_type_cmp_tonemap(bNodeTreeType *ttype) +void register_node_type_cmp_tonemap() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_TONEMAP, "Tonemap", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_TONEMAP, "Tonemap", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_tonemap_in, cmp_node_tonemap_out); node_type_init(&ntype, node_composit_init_tonemap); node_type_storage(&ntype, "NodeTonemap", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_trackpos.c b/source/blender/nodes/composite/nodes/node_composite_trackpos.c index 1583680720a..bc3c54702ac 100644 --- a/source/blender/nodes/composite/nodes/node_composite_trackpos.c +++ b/source/blender/nodes/composite/nodes/node_composite_trackpos.c @@ -39,21 +39,21 @@ static bNodeSocketTemplate cmp_node_trackpos_out[] = { { -1, 0, "" } }; -static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void init(bNodeTree *UNUSED(ntree), bNode *node) { NodeTrackPosData *data = MEM_callocN(sizeof(NodeTrackPosData), "node track position data"); node->storage = data; } -void register_node_type_cmp_trackpos(bNodeTreeType *ttype) +void register_node_type_cmp_trackpos(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_TRACKPOS, "Track Position", NODE_CLASS_INPUT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_TRACKPOS, "Track Position", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, cmp_node_trackpos_out); node_type_init(&ntype, init); node_type_storage(&ntype, "NodeTrackPosData", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_transform.c b/source/blender/nodes/composite/nodes/node_composite_transform.c index 3ed8bdb9995..9618cc85811 100644 --- a/source/blender/nodes/composite/nodes/node_composite_transform.c +++ b/source/blender/nodes/composite/nodes/node_composite_transform.c @@ -48,12 +48,12 @@ static bNodeSocketTemplate cmp_node_transform_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_transform(bNodeTreeType *ttype) +void register_node_type_cmp_transform() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_TRANSFORM, "Transform", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_TRANSFORM, "Transform", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_transform_in, cmp_node_transform_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_translate.c b/source/blender/nodes/composite/nodes/node_composite_translate.c index 5d555cdcda9..2449f614fe0 100644 --- a/source/blender/nodes/composite/nodes/node_composite_translate.c +++ b/source/blender/nodes/composite/nodes/node_composite_translate.c @@ -46,20 +46,20 @@ static bNodeSocketTemplate cmp_node_translate_out[] = { { -1, 0, "" } }; -static void node_composit_init_translate(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_translate(bNodeTree *UNUSED(ntree), bNode *node) { NodeTranslateData *data = MEM_callocN(sizeof(NodeTranslateData), "node translate data"); node->storage = data; } -void register_node_type_cmp_translate(bNodeTreeType *ttype) +void register_node_type_cmp_translate() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_TRANSLATE, "Translate", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_TRANSLATE, "Translate", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_translate_in, cmp_node_translate_out); node_type_init(&ntype, node_composit_init_translate); node_type_storage(&ntype, "NodeTranslateData", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_valToRgb.c b/source/blender/nodes/composite/nodes/node_composite_valToRgb.c index 5a23507bcc7..db02c51c95f 100644 --- a/source/blender/nodes/composite/nodes/node_composite_valToRgb.c +++ b/source/blender/nodes/composite/nodes/node_composite_valToRgb.c @@ -44,22 +44,22 @@ static bNodeSocketTemplate cmp_node_valtorgb_out[] = { { -1, 0, "" } }; -static void node_composit_init_valtorgb(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_valtorgb(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= add_colorband(1); } -void register_node_type_cmp_valtorgb(bNodeTreeType *ttype) +void register_node_type_cmp_valtorgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_valtorgb_in, cmp_node_valtorgb_out); node_type_size(&ntype, 240, 200, 320); node_type_init(&ntype, node_composit_init_valtorgb); node_type_storage(&ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -74,13 +74,13 @@ static bNodeSocketTemplate cmp_node_rgbtobw_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_rgbtobw(bNodeTreeType *ttype) +void register_node_type_cmp_rgbtobw() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTOR, 0); + cmp_node_type_base(&ntype, CMP_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTOR, 0); node_type_socket_templates(&ntype, cmp_node_rgbtobw_in, cmp_node_rgbtobw_out); node_type_size_preset(&ntype, NODE_SIZE_SMALL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_value.c b/source/blender/nodes/composite/nodes/node_composite_value.c index 306170baf93..491c01c465a 100644 --- a/source/blender/nodes/composite/nodes/node_composite_value.c +++ b/source/blender/nodes/composite/nodes/node_composite_value.c @@ -34,29 +34,17 @@ /* **************** VALUE ******************** */ static bNodeSocketTemplate cmp_node_value_out[] = { - /* XXX value nodes use the output sockets for buttons, so we need explicit limits here! */ - { SOCK_FLOAT, 0, N_("Value"), 0.0f, 0.0f, 0.0f, 0.0f, -FLT_MAX, FLT_MAX}, + { SOCK_FLOAT, 0, N_("Value"), 0.5f, 0, 0, 0, -FLT_MAX, FLT_MAX, PROP_NONE}, { -1, 0, "" } }; -static void node_composit_init_value(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) -{ - bNodeSocket *sock= node->outputs.first; - bNodeSocketValueFloat *dval= (bNodeSocketValueFloat*)sock->default_value; - /* uses the default value of the output socket, must be initialized here */ - dval->value = 0.5f; - dval->min = -FLT_MAX; - dval->max = FLT_MAX; -} - -void register_node_type_cmp_value(bNodeTreeType *ttype) +void register_node_type_cmp_value() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_VALUE, "Value", NODE_CLASS_INPUT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_VALUE, "Value", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, cmp_node_value_out); - node_type_init(&ntype, node_composit_init_value); node_type_size_preset(&ntype, NODE_SIZE_SMALL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_vecBlur.c b/source/blender/nodes/composite/nodes/node_composite_vecBlur.c index 35fb4a944db..02a5fdcc0e5 100644 --- a/source/blender/nodes/composite/nodes/node_composite_vecBlur.c +++ b/source/blender/nodes/composite/nodes/node_composite_vecBlur.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate cmp_node_vecblur_out[] = { { -1, 0, "" } }; -static void node_composit_init_vecblur(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_vecblur(bNodeTree *UNUSED(ntree), bNode *node) { NodeBlurData *nbd = MEM_callocN(sizeof(NodeBlurData), "node blur data"); node->storage = nbd; @@ -54,14 +54,14 @@ static void node_composit_init_vecblur(bNodeTree *UNUSED(ntree), bNode *node, bN } /* custom1: itterations, custom2: maxspeed (0 = nolimit) */ -void register_node_type_cmp_vecblur(bNodeTreeType *ttype) +void register_node_type_cmp_vecblur() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_VECBLUR, "Vector Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_VECBLUR, "Vector Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_vecblur_in, cmp_node_vecblur_out); node_type_init(&ntype, node_composit_init_vecblur); node_type_storage(&ntype, "NodeBlurData", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_viewer.c b/source/blender/nodes/composite/nodes/node_composite_viewer.c index 211ebe54eb0..a1e6640dcb6 100644 --- a/source/blender/nodes/composite/nodes/node_composite_viewer.c +++ b/source/blender/nodes/composite/nodes/node_composite_viewer.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate cmp_node_viewer_in[] = { { -1, 0, "" } }; -static void node_composit_init_viewer(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_viewer(bNodeTree *UNUSED(ntree), bNode *node) { ImageUser *iuser = MEM_callocN(sizeof(ImageUser), "node image user"); node->storage = iuser; @@ -52,16 +52,16 @@ static void node_composit_init_viewer(bNodeTree *UNUSED(ntree), bNode *node, bNo node->custom4 = 0.5f; } -void register_node_type_cmp_viewer(bNodeTreeType *ttype) +void register_node_type_cmp_viewer() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_VIEWER, "Viewer", NODE_CLASS_OUTPUT, NODE_OPTIONS | NODE_PREVIEW); + cmp_node_type_base(&ntype, CMP_NODE_VIEWER, "Viewer", NODE_CLASS_OUTPUT, NODE_OPTIONS | NODE_PREVIEW); node_type_socket_templates(&ntype, cmp_node_viewer_in, NULL); node_type_init(&ntype, node_composit_init_viewer); node_type_storage(&ntype, "ImageUser", node_free_standard_storage, node_copy_standard_storage); node_type_internal_links(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_zcombine.c b/source/blender/nodes/composite/nodes/node_composite_zcombine.c index ba81174e103..ca7258c5b97 100644 --- a/source/blender/nodes/composite/nodes/node_composite_zcombine.c +++ b/source/blender/nodes/composite/nodes/node_composite_zcombine.c @@ -48,12 +48,12 @@ static bNodeSocketTemplate cmp_node_zcombine_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_zcombine(bNodeTreeType *ttype) +void register_node_type_cmp_zcombine() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_ZCOMBINE, "Z Combine", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_ZCOMBINE, "Z Combine", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_zcombine_in, cmp_node_zcombine_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/intern/node_common.c b/source/blender/nodes/intern/node_common.c index d59061dfc0a..85e2f775ad9 100644 --- a/source/blender/nodes/intern/node_common.c +++ b/source/blender/nodes/intern/node_common.c @@ -31,19 +31,22 @@ #include <string.h> +#include <stddef.h> #include "DNA_node_types.h" #include "BLI_listbase.h" +#include "BLI_math.h" +#include "BLI_path_util.h" #include "BLI_string.h" #include "BLI_utildefines.h" #include "BLF_translation.h" #include "BKE_global.h" +#include "BKE_idprop.h" #include "BKE_library.h" #include "BKE_main.h" -#include "BLI_math.h" #include "BKE_node.h" #include "RNA_access.h" @@ -55,247 +58,110 @@ #include "node_util.h" #include "node_exec.h" #include "NOD_socket.h" +#include "NOD_common.h" + /**** Group ****/ -bNodeSocket *node_group_find_input(bNode *gnode, bNodeSocket *gsock) +bNodeSocket *node_group_find_input_socket(bNode *groupnode, const char *identifier) { bNodeSocket *sock; - for (sock=gnode->inputs.first; sock; sock=sock->next) - if (sock->groupsock == gsock) + for (sock=groupnode->inputs.first; sock; sock=sock->next) + if (strcmp(sock->identifier, identifier)==0) return sock; return NULL; } -bNodeSocket *node_group_find_output(bNode *gnode, bNodeSocket *gsock) +bNodeSocket *node_group_find_output_socket(bNode *groupnode, const char *identifier) { bNodeSocket *sock; - for (sock=gnode->outputs.first; sock; sock=sock->next) - if (sock->groupsock == gsock) + for (sock=groupnode->outputs.first; sock; sock=sock->next) + if (strcmp(sock->identifier, identifier)==0) return sock; return NULL; } -bNodeSocket *node_group_add_extern_socket(bNodeTree *UNUSED(ntree), ListBase *lb, int in_out, bNodeSocket *gsock) -{ - bNodeSocket *sock; - - if (gsock->flag & SOCK_INTERNAL) - return NULL; - - sock= MEM_callocN(sizeof(bNodeSocket), "sock"); - - /* make a copy of the group socket */ - *sock = *gsock; - sock->link = NULL; - sock->next = sock->prev = NULL; - sock->new_sock = NULL; - - /* group sockets are dynamically added */ - sock->flag |= SOCK_DYNAMIC|SOCK_COLLAPSED; - - sock->own_index = gsock->own_index; - sock->groupsock = gsock; - sock->limit = (in_out==SOCK_IN ? 1 : 0xFFF); - - sock->default_value = node_socket_make_default_value(sock->type); - node_socket_copy_default_value(sock->type, sock->default_value, gsock->default_value); - - if (lb) - BLI_addtail(lb, sock); - - return sock; -} - -bNodeSocket *node_group_add_socket(bNodeTree *ngroup, const char *name, int type, int in_out) -{ - bNodeSocketType *stype = ntreeGetSocketType(type); - bNodeSocket *gsock = MEM_callocN(sizeof(bNodeSocket), "bNodeSocket"); - - BLI_strncpy(gsock->name, name, sizeof(gsock->name)); - gsock->type = type; - /* group sockets are dynamically added */ - gsock->flag |= SOCK_DYNAMIC|SOCK_COLLAPSED; - - gsock->next = gsock->prev = NULL; - gsock->new_sock = NULL; - gsock->link = NULL; - /* assign new unique index */ - gsock->own_index = ngroup->cur_index++; - gsock->limit = (in_out==SOCK_IN ? 0xFFF : 1); - - if (stype->value_structsize > 0) - gsock->default_value = MEM_callocN(stype->value_structsize, "default socket value"); - - BLI_addtail(in_out==SOCK_IN ? &ngroup->inputs : &ngroup->outputs, gsock); - - ngroup->update |= (in_out==SOCK_IN ? NTREE_UPDATE_GROUP_IN : NTREE_UPDATE_GROUP_OUT); - - return gsock; -} - -bNodeSocket *node_group_expose_socket(bNodeTree *ngroup, bNodeSocket *sock, int in_out) -{ - bNodeSocket *gsock= node_group_add_socket(ngroup, sock->name, sock->type, in_out); - - /* initialize the default value. */ - node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value); - - return gsock; -} - -void node_group_expose_all_sockets(bNodeTree *ngroup) -{ - bNode *node; - bNodeSocket *sock, *gsock; - - for (node=ngroup->nodes.first; node; node=node->next) { - for (sock=node->inputs.first; sock; sock=sock->next) { - if (!sock->link && !nodeSocketIsHidden(sock)) { - gsock = node_group_add_socket(ngroup, sock->name, sock->type, SOCK_IN); - - /* initialize the default value. */ - node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value); - - sock->link = nodeAddLink(ngroup, NULL, gsock, node, sock); - } - } - for (sock=node->outputs.first; sock; sock=sock->next) { - if (nodeCountSocketLinks(ngroup, sock)==0 && !nodeSocketIsHidden(sock)) { - gsock = node_group_add_socket(ngroup, sock->name, sock->type, SOCK_OUT); - - /* initialize the default value. */ - node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value); - - gsock->link = nodeAddLink(ngroup, node, sock, NULL, gsock); - } - } - } -} - -void node_group_remove_socket(bNodeTree *ngroup, bNodeSocket *gsock, int in_out) -{ - nodeRemSocketLinks(ngroup, gsock); - - switch (in_out) { - case SOCK_IN: - BLI_remlink(&ngroup->inputs, gsock); - ngroup->update |= NTREE_UPDATE_GROUP_IN; - break; - case SOCK_OUT: - BLI_remlink(&ngroup->outputs, gsock); - ngroup->update |= NTREE_UPDATE_GROUP_OUT; - break; - } - - if (gsock->default_value) - MEM_freeN(gsock->default_value); - - MEM_freeN(gsock); -} - /* groups display their internal tree name as label */ const char *node_group_label(bNode *node) { return (node->id)? node->id->name + 2: IFACE_("Missing Datablock"); } -int node_group_valid(bNodeTree *ntree, bNodeTemplate *ntemp) +int node_group_poll_instance(bNode *node, bNodeTree *nodetree) { - bNodeTemplate childtemp; - bNode *node; - - /* regular groups cannot be recursive */ - if (ntree == ntemp->ngroup) - return 0; - - /* make sure all children are valid */ - for (node=ntemp->ngroup->nodes.first; node; node=node->next) { - childtemp = nodeMakeTemplate(node); - if (!nodeValid(ntree, &childtemp)) - return 0; - } - - return 1; -} - -bNodeTemplate node_group_template(bNode *node) -{ - bNodeTemplate ntemp; - ntemp.type = NODE_GROUP; - ntemp.ngroup = (bNodeTree *)node->id; - return ntemp; + bNodeTree *grouptree = (bNodeTree*)node->id; + if (grouptree) + return nodeGroupPoll(nodetree, grouptree); + else + return 1; } -void node_group_init(bNodeTree *ntree, bNode *node, bNodeTemplate *ntemp) +int nodeGroupPoll(bNodeTree *nodetree, bNodeTree *grouptree) { - node->id = (ID *)ntemp->ngroup; + bNode *node; + int valid = 1; - /* NB: group socket input/output roles are inverted internally! - * Group "inputs" work as outputs in links and vice versa. - */ - if (ntemp->ngroup) { - bNodeSocket *gsock; - for (gsock=ntemp->ngroup->inputs.first; gsock; gsock=gsock->next) - node_group_add_extern_socket(ntree, &node->inputs, SOCK_IN, gsock); - for (gsock=ntemp->ngroup->outputs.first; gsock; gsock=gsock->next) - node_group_add_extern_socket(ntree, &node->outputs, SOCK_OUT, gsock); + if (nodetree == grouptree) + return 0; + + for (node=grouptree->nodes.first; node; node=node->next) { + if (!node->typeinfo->poll_instance(node, nodetree)) { + valid = 0; + break; + } } + return valid; } -static bNodeSocket *group_verify_socket(bNodeTree *ntree, ListBase *lb, int in_out, bNodeSocket *gsock) +/* used for both group nodes and interface nodes */ +static bNodeSocket *group_verify_socket(bNodeTree *ntree, bNode *gnode, bNodeSocket *iosock, ListBase *verify_lb, int in_out) { bNodeSocket *sock; - /* group sockets tagged as internal are not exposed ever */ - if (gsock->flag & SOCK_INTERNAL) - return NULL; - - for (sock= lb->first; sock; sock= sock->next) { - if (sock->own_index==gsock->own_index) + for (sock= verify_lb->first; sock; sock= sock->next) { + if (strcmp(sock->identifier, iosock->identifier)==0) break; } if (sock) { - sock->groupsock = gsock; - - BLI_strncpy(sock->name, gsock->name, sizeof(sock->name)); - if (gsock->type != sock->type) - nodeSocketSetType(sock, gsock->type); - - /* XXX hack: group socket input/output roles are inverted internally, - * need to change the limit value when making actual node sockets from them. - */ - sock->limit = (in_out==SOCK_IN ? 1 : 0xFFF); - - BLI_remlink(lb, sock); - - return sock; + strcpy(sock->name, iosock->name); } else { - return node_group_add_extern_socket(ntree, NULL, in_out, gsock); + sock = nodeAddSocket(ntree, gnode, in_out, iosock->idname, iosock->identifier, iosock->name); + + if (iosock->typeinfo->interface_init_socket) + iosock->typeinfo->interface_init_socket(ntree, iosock, gnode, sock, "interface"); } + + /* remove from list temporarily, to distinguish from orphaned sockets */ + BLI_remlink(verify_lb, sock); + + return sock; } -static void group_verify_socket_list(bNodeTree *ntree, bNode *node, ListBase *lb, int in_out, ListBase *glb) +/* used for both group nodes and interface nodes */ +static void group_verify_socket_list(bNodeTree *ntree, bNode *gnode, + ListBase *iosock_lb, ListBase *verify_lb, int in_out) { - bNodeSocket *sock, *nextsock, *gsock; + bNodeSocket *iosock, *sock, *nextsock; /* step by step compare */ - for (gsock= glb->first; gsock; gsock=gsock->next) { + + iosock = iosock_lb->first; + for (; iosock; iosock = iosock->next) { /* abusing new_sock pointer for verification here! only used inside this function */ - gsock->new_sock= group_verify_socket(ntree, lb, in_out, gsock); + iosock->new_sock = group_verify_socket(ntree, gnode, iosock, verify_lb, in_out); } /* leftovers are removed */ - for (sock=lb->first; sock; sock=nextsock) { - nextsock=sock->next; - if (sock->flag & SOCK_DYNAMIC) - nodeRemoveSocket(ntree, node, sock); + for (sock = verify_lb->first; sock; sock = nextsock) { + nextsock = sock->next; + nodeRemoveSocket(ntree, gnode, sock); } /* and we put back the verified sockets */ - for (gsock= glb->first; gsock; gsock=gsock->next) { - if (gsock->new_sock) { - BLI_addtail(lb, gsock->new_sock); - gsock->new_sock = NULL; + iosock = iosock_lb->first; + for (; iosock; iosock = iosock->next) { + if (iosock->new_sock) { + BLI_addtail(verify_lb, iosock->new_sock); + iosock->new_sock = NULL; } } } @@ -304,59 +170,16 @@ static void group_verify_socket_list(bNodeTree *ntree, bNode *node, ListBase *lb void node_group_verify(struct bNodeTree *ntree, struct bNode *node, struct ID *id) { /* check inputs and outputs, and remove or insert them */ - if (node->id==id) { + if (id == node->id) { bNodeTree *ngroup= (bNodeTree *)node->id; - group_verify_socket_list(ntree, node, &node->inputs, SOCK_IN, &ngroup->inputs); - group_verify_socket_list(ntree, node, &node->outputs, SOCK_OUT, &ngroup->outputs); + group_verify_socket_list(ntree, node, &ngroup->inputs, &node->inputs, SOCK_IN); + group_verify_socket_list(ntree, node, &ngroup->outputs, &node->outputs, SOCK_OUT); } } -struct bNodeTree *node_group_edit_get(bNode *node) -{ - if (node->flag & NODE_GROUP_EDIT) - return (bNodeTree *)node->id; - else - return NULL; -} - -struct bNodeTree *node_group_edit_set(bNode *node, int edit) -{ - if (edit) { - bNodeTree *ngroup= (bNodeTree *)node->id; - if (ngroup) { - if (ngroup->id.lib) - ntreeMakeLocal(ngroup); - - node->flag |= NODE_GROUP_EDIT; - } - return ngroup; - } - else { - node->flag &= ~NODE_GROUP_EDIT; - return NULL; - } -} - -void node_group_edit_clear(bNode *node) -{ - bNodeTree *ngroup= (bNodeTree *)node->id; - bNode *inode; - - node->flag &= ~NODE_GROUP_EDIT; - - if (ngroup) - for (inode=ngroup->nodes.first; inode; inode=inode->next) - nodeGroupEditClear(inode); -} - -static void UNUSED_FUNCTION(node_group_link)(bNodeTree *ntree, bNodeSocket *sock, int in_out) -{ - node_group_expose_socket(ntree, sock, in_out); -} - /**** FRAME ****/ -static void node_frame_init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_frame_init(bNodeTree *UNUSED(ntree), bNode *node) { NodeFrame *data = (NodeFrame *)MEM_callocN(sizeof(NodeFrame), "frame node storage"); node->storage = data; @@ -366,19 +189,19 @@ static void node_frame_init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate data->label_size = 20; } -void register_node_type_frame(bNodeTreeType *ttype) +void register_node_type_frame(void) { /* frame type is used for all tree types, needs dynamic allocation */ bNodeType *ntype= MEM_callocN(sizeof(bNodeType), "frame node type"); - node_type_base(ttype, ntype, NODE_FRAME, "Frame", NODE_CLASS_LAYOUT, NODE_BACKGROUND|NODE_OPTIONS); + node_type_base(ntype, NODE_FRAME, "Frame", NODE_CLASS_LAYOUT, NODE_BACKGROUND|NODE_OPTIONS); node_type_init(ntype, node_frame_init); node_type_storage(ntype, "NodeFrame", node_free_standard_storage, node_copy_standard_storage); node_type_size(ntype, 150, 100, 0); node_type_compatibility(ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); ntype->needs_free = 1; - nodeRegisterType(ttype, ntype); + nodeRegisterType(ntype); } @@ -403,34 +226,34 @@ static void node_reroute_update_internal_links(bNodeTree *ntree, bNode *node) BLI_addtail(&node->internal_links, link); } -static void node_reroute_init(bNodeTree *ntree, bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_reroute_init(bNodeTree *ntree, bNode *node) { /* Note: Cannot use socket templates for this, since it would reset the socket type * on each file read via the template verification procedure. */ - nodeAddSocket(ntree, node, SOCK_IN, "Input", SOCK_RGBA); - nodeAddSocket(ntree, node, SOCK_OUT, "Output", SOCK_RGBA); + nodeAddStaticSocket(ntree, node, SOCK_IN, SOCK_RGBA, PROP_NONE, "Input", "Input"); + nodeAddStaticSocket(ntree, node, SOCK_OUT, SOCK_RGBA, PROP_NONE, "Output", "Output"); } -void register_node_type_reroute(bNodeTreeType *ttype) +void register_node_type_reroute(void) { /* frame type is used for all tree types, needs dynamic allocation */ bNodeType *ntype= MEM_callocN(sizeof(bNodeType), "frame node type"); - node_type_base(ttype, ntype, NODE_REROUTE, "Reroute", NODE_CLASS_LAYOUT, 0); + node_type_base(ntype, NODE_REROUTE, "Reroute", NODE_CLASS_LAYOUT, 0); node_type_init(ntype, node_reroute_init); node_type_internal_links(ntype, node_reroute_update_internal_links); ntype->needs_free = 1; - nodeRegisterType(ttype, ntype); + nodeRegisterType(ntype); } static void node_reroute_inherit_type_recursive(bNodeTree *ntree, bNode *node) { bNodeSocket *input = node->inputs.first; bNodeSocket *output = node->outputs.first; - int type = SOCK_FLOAT; bNodeLink *link; + int type = SOCK_FLOAT; /* XXX it would be a little bit more efficient to restrict actual updates * to rerout nodes connected to an updated node, but there's no reliable flag @@ -446,6 +269,8 @@ static void node_reroute_inherit_type_recursive(bNodeTree *ntree, bNode *node) bNode *tonode = link->tonode; if (!tonode || !fromnode) continue; + if (nodeLinkIsHidden(link)) + continue; if (tonode == node && fromnode->type == NODE_REROUTE && !fromnode->done) node_reroute_inherit_type_recursive(ntree, fromnode); @@ -462,9 +287,13 @@ static void node_reroute_inherit_type_recursive(bNodeTree *ntree, bNode *node) /* arbitrary, could also test output->type, both are the same */ if (input->type != type) { + PointerRNA input_ptr, output_ptr; /* same type for input/output */ - nodeSocketSetType(input, type); - nodeSocketSetType(output, type); + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, input, &input_ptr); + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, output, &output_ptr); + + RNA_enum_set(&input_ptr, "type", type); + RNA_enum_set(&output_ptr, "type", type); } } @@ -484,9 +313,8 @@ void ntree_update_reroute_nodes(bNodeTree *ntree) node_reroute_inherit_type_recursive(ntree, node); } -void BKE_node_tree_unlink_id_cb(void *calldata, struct ID *UNUSED(owner_id), struct bNodeTree *ntree) +void BKE_node_tree_unlink_id(ID *id, struct bNodeTree *ntree) { - ID *id = (ID *)calldata; bNode *node; for (node = ntree->nodes.first; node; node = node->next) { @@ -495,3 +323,179 @@ void BKE_node_tree_unlink_id_cb(void *calldata, struct ID *UNUSED(owner_id), str } } } + +/**** GROUP_INPUT / GROUP_OUTPUT ****/ + +static void node_group_input_init(bNodeTree *ntree, bNode *node) +{ + node_group_input_verify(ntree, node, (ID *)ntree); +} + +bNodeSocket *node_group_input_find_socket(bNode *node, const char *identifier) +{ + bNodeSocket *sock; + for (sock=node->outputs.first; sock; sock=sock->next) + if (strcmp(sock->identifier, identifier)==0) + return sock; + return NULL; +} + +void node_group_input_verify(bNodeTree *ntree, bNode *node, ID *id) +{ + /* check inputs and outputs, and remove or insert them */ + if (id == (ID *)ntree) { + /* value_in_out inverted for interface nodes to get correct socket value_property */ + group_verify_socket_list(ntree, node, &ntree->inputs, &node->outputs, SOCK_OUT); + + /* add virtual extension socket */ + nodeAddSocket(ntree, node, SOCK_OUT, "NodeSocketVirtual", "__extend__", ""); + } +} + +static void node_group_input_update(bNodeTree *ntree, bNode *node) +{ + bNodeSocket *extsock = node->outputs.last; + bNodeLink *link; + /* Adding a tree socket and verifying will remove the extension socket! + * This list caches the existing links from the extension socket + * so they can be recreated after verification. + */ + ListBase tmplinks; + + /* find links from the extension socket and store them */ + tmplinks.first = tmplinks.last = NULL; + for (link = ntree->links.first; link; link = link->next) { + if (nodeLinkIsHidden(link)) + continue; + if (link->fromsock == extsock) { + bNodeLink *tlink = MEM_callocN(sizeof(bNodeLink), "temporary link"); + *tlink = *link; + BLI_addtail(&tmplinks, tlink); + } + } + + if (tmplinks.first) { + bNodeSocket *gsock, *newsock; + /* XXX Multiple sockets can be connected to the extension socket at once, + * in that case the arbitrary first link determines name and type. + * This could be improved by choosing the "best" type among all links, + * whatever that means. + */ + bNodeLink *exposelink = tmplinks.first; + + /* XXX what if connecting virtual to virtual socket?? */ + gsock = ntreeAddSocketInterfaceFromSocket(ntree, exposelink->tonode, exposelink->tosock); + + node_group_input_verify(ntree, node, (ID *)ntree); + newsock = node_group_input_find_socket(node, gsock->identifier); + + /* redirect links from the extension socket */ + for (link = tmplinks.first; link; link = link->next) { + nodeAddLink(ntree, node, newsock, link->tonode, link->tosock); + } + + BLI_freelistN(&tmplinks); + } +} + +void register_node_type_group_input(void) +{ + /* used for all tree types, needs dynamic allocation */ + bNodeType *ntype= MEM_callocN(sizeof(bNodeType), "node type"); + + node_type_base(ntype, NODE_GROUP_INPUT, "Group Input", NODE_CLASS_INTERFACE, NODE_OPTIONS); + node_type_size(ntype, 140, 80, 200); + node_type_init(ntype, node_group_input_init); + node_type_update(ntype, node_group_input_update, node_group_input_verify); + node_type_compatibility(ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); + + ntype->needs_free = 1; + nodeRegisterType(ntype); +} + +static void node_group_output_init(bNodeTree *ntree, bNode *node) +{ + node_group_output_verify(ntree, node, (ID *)ntree); +} + +bNodeSocket *node_group_output_find_socket(bNode *node, const char *identifier) +{ + bNodeSocket *sock; + for (sock=node->inputs.first; sock; sock=sock->next) + if (strcmp(sock->identifier, identifier)==0) + return sock; + return NULL; +} + +void node_group_output_verify(bNodeTree *ntree, bNode *node, ID *id) +{ + /* check inputs and outputs, and remove or insert them */ + if (id == (ID *)ntree) { + /* value_in_out inverted for interface nodes to get correct socket value_property */ + group_verify_socket_list(ntree, node, &ntree->outputs, &node->inputs, SOCK_IN); + + /* add virtual extension socket */ + nodeAddSocket(ntree, node, SOCK_IN, "NodeSocketVirtual", "__extend__", ""); + } +} + +static void node_group_output_update(bNodeTree *ntree, bNode *node) +{ + bNodeSocket *extsock = node->inputs.last; + bNodeLink *link; + /* Adding a tree socket and verifying will remove the extension socket! + * This list caches the existing links to the extension socket + * so they can be recreated after verification. + */ + ListBase tmplinks; + + /* find links to the extension socket and store them */ + tmplinks.first = tmplinks.last = NULL; + for (link = ntree->links.first; link; link = link->next) { + if (nodeLinkIsHidden(link)) + continue; + if (link->tosock == extsock) { + bNodeLink *tlink = MEM_callocN(sizeof(bNodeLink), "temporary link"); + *tlink = *link; + BLI_addtail(&tmplinks, tlink); + } + } + + if (tmplinks.first) { + bNodeSocket *gsock, *newsock; + /* XXX Multiple sockets can be connected to the extension socket at once, + * in that case the arbitrary first link determines name and type. + * This could be improved by choosing the "best" type among all links, + * whatever that means. + */ + bNodeLink *exposelink = tmplinks.first; + + /* XXX what if connecting virtual to virtual socket?? */ + gsock = ntreeAddSocketInterfaceFromSocket(ntree, exposelink->fromnode, exposelink->fromsock); + + node_group_output_verify(ntree, node, (ID *)ntree); + newsock = node_group_output_find_socket(node, gsock->identifier); + + /* redirect links to the extension socket */ + for (link = tmplinks.first; link; link = link->next) { + nodeAddLink(ntree, link->fromnode, link->fromsock, node, newsock); + } + + BLI_freelistN(&tmplinks); + } +} + +void register_node_type_group_output(void) +{ + /* used for all tree types, needs dynamic allocation */ + bNodeType *ntype= MEM_callocN(sizeof(bNodeType), "node type"); + + node_type_base(ntype, NODE_GROUP_OUTPUT, "Group Output", NODE_CLASS_INTERFACE, NODE_OPTIONS); + node_type_size(ntype, 140, 80, 200); + node_type_init(ntype, node_group_output_init); + node_type_update(ntype, node_group_output_update, node_group_output_verify); + node_type_compatibility(ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); + + ntype->needs_free = 1; + nodeRegisterType(ntype); +} diff --git a/source/blender/nodes/intern/node_common.h b/source/blender/nodes/intern/node_common.h index 9e04a9e05f8..498da607b91 100644 --- a/source/blender/nodes/intern/node_common.h +++ b/source/blender/nodes/intern/node_common.h @@ -37,15 +37,8 @@ struct bNodeTree; -void node_group_init(struct bNodeTree *ntree, struct bNode *node, struct bNodeTemplate *ntemp); const char *node_group_label(struct bNode *node); -struct bNodeTemplate node_group_template(struct bNode *node); -int node_group_valid(struct bNodeTree *ntree, struct bNodeTemplate *ntemp); -void node_group_verify(struct bNodeTree *ntree, struct bNode *node, struct ID *id); - -struct bNodeTree *node_group_edit_get(struct bNode *node); -struct bNodeTree *node_group_edit_set(struct bNode *node, int edit); -void node_group_edit_clear(bNode *node); +int node_group_poll_instance(struct bNode *node, struct bNodeTree *nodetree); void ntree_update_reroute_nodes(struct bNodeTree *ntree); diff --git a/source/blender/nodes/intern/node_exec.c b/source/blender/nodes/intern/node_exec.c index 8cf7cc7a1ea..8fb23064bf0 100644 --- a/source/blender/nodes/intern/node_exec.c +++ b/source/blender/nodes/intern/node_exec.c @@ -41,12 +41,19 @@ #include "MEM_guardedalloc.h" #include "node_exec.h" +#include "node_util.h" +/* supported socket types in old nodes */ +int node_exec_socket_use_stack(bNodeSocket *sock) +{ + return ELEM3(sock->type, SOCK_FLOAT, SOCK_VECTOR, SOCK_RGBA); +} + /* for a given socket, find the actual stack entry */ bNodeStack *node_get_socket_stack(bNodeStack *stack, bNodeSocket *sock) { - if (stack && sock) + if (stack && sock && sock->stack_index >= 0) return stack + sock->stack_index; return NULL; } @@ -75,7 +82,10 @@ static void node_init_input_index(bNodeSocket *sock, int *index) sock->stack_index = sock->link->fromsock->stack_index; } else { - sock->stack_index = (*index)++; + if (node_exec_socket_use_stack(sock)) + sock->stack_index = (*index)++; + else + sock->stack_index = -1; } } @@ -91,19 +101,27 @@ static void node_init_output_index(bNodeSocket *sock, int *index, ListBase *inte } } /* if not internally connected, assign a new stack index anyway to avoid bad stack access */ - if (!link) - sock->stack_index = (*index)++; + if (!link) { + if (node_exec_socket_use_stack(sock)) + sock->stack_index = (*index)++; + else + sock->stack_index = -1; + } } else { - sock->stack_index = (*index)++; + if (node_exec_socket_use_stack(sock)) + sock->stack_index = (*index)++; + else + sock->stack_index = -1; } } /* basic preparation of socket stacks */ -static struct bNodeStack *setup_stack(bNodeStack *stack, bNodeSocket *sock) +static struct bNodeStack *setup_stack(bNodeStack *stack, bNodeTree *ntree, bNode *node, bNodeSocket *sock) { bNodeStack *ns = node_get_socket_stack(stack, sock); - float null_value[4] = {0.0f, 0.0f, 0.0f, 0.0f}; + if (!ns) + return NULL; /* don't mess with remote socket stacks, these are initialized by other nodes! */ if (sock->link) @@ -111,49 +129,37 @@ static struct bNodeStack *setup_stack(bNodeStack *stack, bNodeSocket *sock) ns->sockettype = sock->type; - if (sock->default_value) { - switch (sock->type) { + switch (sock->type) { case SOCK_FLOAT: - ns->vec[0] = ((bNodeSocketValueFloat *)sock->default_value)->value; + ns->vec[0] = node_socket_get_float(ntree, node, sock); break; case SOCK_VECTOR: - copy_v3_v3(ns->vec, ((bNodeSocketValueVector *)sock->default_value)->value); + node_socket_get_vector(ntree, node, sock, ns->vec); break; case SOCK_RGBA: - copy_v4_v4(ns->vec, ((bNodeSocketValueRGBA *)sock->default_value)->value); + node_socket_get_color(ntree, node, sock, ns->vec); break; - } - } - else { - switch (sock->type) { - case SOCK_FLOAT: - ns->vec[0] = 0.0f; - break; - case SOCK_VECTOR: - copy_v3_v3(ns->vec, null_value); - break; - case SOCK_RGBA: - copy_v4_v4(ns->vec, null_value); - break; - } } return ns; } -bNodeTreeExec *ntree_exec_begin(bNodeTree *ntree) +bNodeTreeExec *ntree_exec_begin(bNodeExecContext *context, bNodeTree *ntree, bNodeInstanceKey parent_key) { bNodeTreeExec *exec; bNode *node; bNodeExec *nodeexec; - bNodeSocket *sock, *gsock; + bNodeInstanceKey nodekey; + bNodeSocket *sock; bNodeStack *ns; int index; bNode **nodelist; int totnodes, n; - if ((ntree->init & NTREE_TYPE_INIT)==0) - ntreeInitTypes(ntree); + BLI_assert(ntreeIsValid(ntree)); + + /* ensure all sock->link pointers and node levels are correct */ + ntreeUpdateTree(ntree); /* get a dependency-sorted list of nodes */ ntreeGetDependencyList(ntree, &nodelist, &totnodes); @@ -165,9 +171,6 @@ bNodeTreeExec *ntree_exec_begin(bNodeTree *ntree) /* set stack indices */ index = 0; - /* group inputs essentially work as outputs */ - for (gsock=ntree->inputs.first; gsock; gsock = gsock->next) - node_init_output_index(gsock, &index, NULL); for (n=0; n < totnodes; ++n) { node = nodelist[n]; @@ -186,9 +189,6 @@ bNodeTreeExec *ntree_exec_begin(bNodeTree *ntree) node_init_output_index(sock, &index, NULL); } } - /* group outputs essentially work as inputs */ - for (gsock=ntree->outputs.first; gsock; gsock = gsock->next) - node_init_input_index(gsock, &index); /* allocated exec data pointers for nodes */ exec->totnodes = totnodes; @@ -201,11 +201,7 @@ bNodeTreeExec *ntree_exec_begin(bNodeTree *ntree) for (n=0; n < exec->stacksize; ++n) exec->stack[n].hasinput = 1; - /* prepare group tree inputs */ - for (sock=ntree->inputs.first; sock; sock=sock->next) { - /* ns = */ setup_stack(exec->stack, sock); - } - /* prepare all internal nodes for execution */ + /* prepare all nodes for execution */ for (n=0, nodeexec= exec->nodeexec; n < totnodes; ++n, ++nodeexec) { node = nodeexec->node = nodelist[n]; @@ -215,22 +211,20 @@ bNodeTreeExec *ntree_exec_begin(bNodeTree *ntree) if (sock->link && !(sock->link->flag & NODE_LINK_VALID)) node->need_exec= 0; - ns = setup_stack(exec->stack, sock); - ns->hasoutput = 1; + ns = setup_stack(exec->stack, ntree, node, sock); + if (ns) + ns->hasoutput = 1; } /* tag all outputs */ for (sock=node->outputs.first; sock; sock=sock->next) { - /* ns = */ setup_stack(exec->stack, sock); + /* ns = */ setup_stack(exec->stack, ntree, node, sock); } + nodekey = BKE_node_instance_key(parent_key, ntree, node); + nodeexec->data.preview = context->previews ? BKE_node_instance_hash_lookup(context->previews, nodekey) : NULL; if (node->typeinfo->initexecfunc) - nodeexec->data = node->typeinfo->initexecfunc(node); - } - /* prepare group tree outputs */ - for (sock=ntree->outputs.first; sock; sock=sock->next) { - ns = setup_stack(exec->stack, sock); - ns->hasoutput = 1; + nodeexec->data.data = node->typeinfo->initexecfunc(context, node, nodekey); } if (nodelist) @@ -250,7 +244,7 @@ void ntree_exec_end(bNodeTreeExec *exec) for (n=0, nodeexec= exec->nodeexec; n < exec->totnodes; ++n, ++nodeexec) { if (nodeexec->node->typeinfo) if (nodeexec->node->typeinfo->freeexecfunc) - nodeexec->node->typeinfo->freeexecfunc(nodeexec->node, nodeexec->data); + nodeexec->node->typeinfo->freeexecfunc(nodeexec->node, nodeexec->data.data); } if (exec->nodeexec) @@ -309,9 +303,7 @@ bool ntreeExecThreadNodes(bNodeTreeExec *exec, bNodeThreadStack *nts, void *call // if (node->typeinfo->compatibility == NODE_NEW_SHADING) // return false; if (node->typeinfo->execfunc) - node->typeinfo->execfunc(callerdata, node, nsin, nsout); - else if (node->typeinfo->newexecfunc) - node->typeinfo->newexecfunc(callerdata, thread, node, nodeexec->data, nsin, nsout); + node->typeinfo->execfunc(callerdata, thread, node, &nodeexec->data, nsin, nsout); } } diff --git a/source/blender/nodes/intern/node_exec.h b/source/blender/nodes/intern/node_exec.h index 5febda036e0..7d76ef34934 100644 --- a/source/blender/nodes/intern/node_exec.h +++ b/source/blender/nodes/intern/node_exec.h @@ -39,6 +39,8 @@ #include "BKE_node.h" +#include "node_util.h" + #include "RNA_types.h" struct bNodeTree; @@ -48,20 +50,20 @@ struct bNodeStack; /* Node execution data */ typedef struct bNodeExec { struct bNode *node; /* backpointer to node */ - void *data; /* custom data storage */ + bNodeExecData data; } bNodeExec; /* Execution Data for each instance of node tree execution */ typedef struct bNodeTreeExec { struct bNodeTree *nodetree; /* backpointer to node tree */ - int totnodes; /* total node count */ + int totnodes; /* total node count */ struct bNodeExec *nodeexec; /* per-node execution data */ int stacksize; struct bNodeStack *stack; /* socket data stack */ /* only used by material and texture trees to keep one stack for each thread */ - ListBase *threadstack; /* one instance of the stack for each thread */ + ListBase *threadstack; /* one instance of the stack for each thread */ } bNodeTreeExec; /* stores one stack copy for each thread (material and texture trees) */ @@ -71,14 +73,22 @@ typedef struct bNodeThreadStack { int used; } bNodeThreadStack; +int node_exec_socket_use_stack(struct bNodeSocket *sock); + struct bNodeStack *node_get_socket_stack(struct bNodeStack *stack, struct bNodeSocket *sock); void node_get_stack(struct bNode *node, struct bNodeStack *stack, struct bNodeStack **in, struct bNodeStack **out); -struct bNodeTreeExec *ntree_exec_begin(struct bNodeTree *ntree); +struct bNodeTreeExec *ntree_exec_begin(struct bNodeExecContext *context, struct bNodeTree *ntree, bNodeInstanceKey parent_key); void ntree_exec_end(struct bNodeTreeExec *exec); struct bNodeThreadStack *ntreeGetThreadStack(struct bNodeTreeExec *exec, int thread); void ntreeReleaseThreadStack(struct bNodeThreadStack *nts); bool ntreeExecThreadNodes(struct bNodeTreeExec *exec, struct bNodeThreadStack *nts, void *callerdata, int thread); +struct bNodeTreeExec *ntreeShaderBeginExecTree_internal(struct bNodeExecContext *context, struct bNodeTree *ntree, bNodeInstanceKey parent_key); +void ntreeShaderEndExecTree_internal(struct bNodeTreeExec *exec); + +struct bNodeTreeExec *ntreeTexBeginExecTree_internal(struct bNodeExecContext *context, struct bNodeTree *ntree, bNodeInstanceKey parent_key); +void ntreeTexEndExecTree_internal(struct bNodeTreeExec *exec); + #endif diff --git a/source/blender/nodes/intern/node_socket.c b/source/blender/nodes/intern/node_socket.c index 69256fafc3d..68ae8fa87b3 100644 --- a/source/blender/nodes/intern/node_socket.c +++ b/source/blender/nodes/intern/node_socket.c @@ -33,547 +33,95 @@ #include "DNA_node_types.h" -#include "DNA_mesh_types.h" -#include "DNA_meshdata_types.h" -#include "DNA_object_types.h" -#include "DNA_scene_types.h" - #include "BLI_listbase.h" #include "BLI_math.h" +#include "BLI_string.h" #include "BLI_utildefines.h" #include "BLI_string.h" -#include "BKE_DerivedMesh.h" #include "BKE_node.h" +#include "BKE_idprop.h" #include "RNA_access.h" +#include "RNA_define.h" #include "RNA_types.h" #include "MEM_guardedalloc.h" #include "NOD_socket.h" -/****************** FLOAT ******************/ - -static bNodeSocketType node_socket_type_float = { - /* type */ SOCK_FLOAT, - /* ui_name */ "Float", - /* ui_description */ "Floating Point", - /* ui_icon */ 0, - /* ui_color */ {160, 160, 160, 255}, - - /* value_structname */ "bNodeSocketValueFloat", - /* value_structsize */ sizeof(bNodeSocketValueFloat), - - /* buttonfunc */ NULL, -}; - -/****************** VECTOR ******************/ - -static bNodeSocketType node_socket_type_vector = { - /* type */ SOCK_VECTOR, - /* ui_name */ "Vector", - /* ui_description */ "3-dimensional floating point vector", - /* ui_icon */ 0, - /* ui_color */ {100, 100, 200, 255}, - - /* value_structname */ "bNodeSocketValueVector", - /* value_structsize */ sizeof(bNodeSocketValueVector), - - /* buttonfunc */ NULL, -}; - -/****************** RGBA ******************/ - -static bNodeSocketType node_socket_type_rgba = { - /* type */ SOCK_RGBA, - /* ui_name */ "RGBA", - /* ui_description */ "RGBA color", - /* ui_icon */ 0, - /* ui_color */ {200, 200, 40, 255}, - - /* value_structname */ "bNodeSocketValueRGBA", - /* value_structsize */ sizeof(bNodeSocketValueRGBA), - - /* buttonfunc */ NULL, -}; - -/****************** INT ******************/ - -static bNodeSocketType node_socket_type_int = { - /* type */ SOCK_INT, - /* ui_name */ "Int", - /* ui_description */ "Integer", - /* ui_icon */ 0, - /* ui_color */ {17, 133, 37, 255}, - - /* value_structname */ "bNodeSocketValueInt", - /* value_structsize */ sizeof(bNodeSocketValueInt), - - /* buttonfunc */ NULL, -}; - -/****************** BOOLEAN ******************/ - -static bNodeSocketType node_socket_type_boolean = { - /* type */ SOCK_BOOLEAN, - /* ui_name */ "Boolean", - /* ui_description */ "Boolean", - /* ui_icon */ 0, - /* ui_color */ {158, 139, 63, 255}, - - /* value_structname */ "bNodeSocketValueBoolean", - /* value_structsize */ sizeof(bNodeSocketValueBoolean), - - /* buttonfunc */ NULL, -}; - -/****************** SHADER ******************/ - -static bNodeSocketType node_socket_type_shader = { - /* type */ SOCK_SHADER, - /* ui_name */ "Shader", - /* ui_description */ "Shader", - /* ui_icon */ 0, - /* ui_color */ {100, 200, 100, 255}, - - /* value_structname */ NULL, - /* value_structsize */ 0, - - /* buttonfunc */ NULL, -}; - -/****************** MESH ******************/ - -static bNodeSocketType node_socket_type_mesh = { - /* type */ SOCK_MESH, - /* ui_name */ "Mesh", - /* ui_description */ "Mesh geometry data", - /* ui_icon */ 0, - /* ui_color */ {255, 133, 7, 255}, - - /* value_structname */ NULL, - /* value_structsize */ 0, - - /* buttonfunc */ NULL, -}; +struct Main; -/****************** STRING ******************/ - -static bNodeSocketType node_socket_type_string = { - /* type */ SOCK_STRING, - /* ui_name */ "String", - /* ui_description */ "String", - /* ui_icon */ 0, - /* ui_color */ {255, 255, 255, 255}, - - /* value_structname */ "bNodeSocketValueString", - /* value_structsize */ sizeof(bNodeSocketValueString), - - /* buttonfunc */ NULL, -}; - -void node_socket_type_init(bNodeSocketType *types[]) +struct bNodeSocket *node_add_socket_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp, int in_out) { - #define INIT_TYPE(name) types[node_socket_type_##name.type] = &node_socket_type_##name + bNodeSocket *sock = nodeAddStaticSocket(ntree, node, in_out, stemp->type, stemp->subtype, stemp->identifier, stemp->name); - INIT_TYPE(float); - INIT_TYPE(vector); - INIT_TYPE(rgba); - INIT_TYPE(int); - INIT_TYPE(boolean); - INIT_TYPE(shader); - INIT_TYPE(mesh); - INIT_TYPE(string); + sock->flag |= stemp->flag; - #undef INIT_TYPE -} - -void *node_socket_make_default_value(int type) -{ - /* XXX currently just allocates from stype->structsize. - * it might become necessary to do more complex allocations for later types. - */ - bNodeSocketType *stype = ntreeGetSocketType(type); - if (stype->value_structsize > 0) { - void *default_value = MEM_callocN(stype->value_structsize, "default socket value"); - return default_value; - } - else - return NULL; -} - -void node_socket_free_default_value(int UNUSED(type), void *default_value) -{ - /* XXX can just free the pointee for all current socket types. */ - if (default_value) - MEM_freeN(default_value); -} - -void node_socket_init_default_value(int type, void *default_value) -{ - switch (type) { - case SOCK_FLOAT: - node_socket_set_default_value_float(default_value, PROP_NONE, 0.0f, -FLT_MAX, FLT_MAX); - break; - case SOCK_INT: - node_socket_set_default_value_int(default_value, PROP_NONE, 0, INT_MIN, INT_MAX); - break; - case SOCK_BOOLEAN: - node_socket_set_default_value_boolean(default_value, FALSE); - break; - case SOCK_VECTOR: - node_socket_set_default_value_vector(default_value, PROP_NONE, 0.0f, 0.0f, 0.0f, -FLT_MAX, FLT_MAX); - break; - case SOCK_RGBA: - node_socket_set_default_value_rgba(default_value, 0.0f, 0.0f, 0.0f, 1.0f); - break; - case SOCK_SHADER: - node_socket_set_default_value_shader(default_value); - break; - case SOCK_MESH: - node_socket_set_default_value_mesh(default_value); - break; - case SOCK_STRING: - node_socket_set_default_value_string(default_value, PROP_NONE, (char *)""); - break; - } -} - -void node_socket_set_default_value_int(void *default_value, PropertySubType subtype, int value, int min, int max) -{ - bNodeSocketValueInt *val = default_value; - val->subtype = subtype; - val->value = value; - val->min = min; - val->max = max; -} - -void node_socket_set_default_value_float(void *default_value, PropertySubType subtype, float value, float min, float max) -{ - bNodeSocketValueFloat *val = default_value; - val->subtype = subtype; - val->value = value; - val->min = min; - val->max = max; -} - -void node_socket_set_default_value_boolean(void *default_value, char value) -{ - bNodeSocketValueBoolean *val = default_value; - val->value = value; -} - -void node_socket_set_default_value_vector(void *default_value, PropertySubType subtype, float x, float y, float z, float min, float max) -{ - bNodeSocketValueVector *val = default_value; - val->subtype = subtype; - val->value[0] = x; - val->value[1] = y; - val->value[2] = z; - val->min = min; - val->max = max; -} - -void node_socket_set_default_value_rgba(void *default_value, float r, float g, float b, float a) -{ - bNodeSocketValueRGBA *val = default_value; - val->value[0] = r; - val->value[1] = g; - val->value[2] = b; - val->value[3] = a; -} - -void node_socket_set_default_value_string(void *default_value, PropertySubType subtype, const char *value) -{ - bNodeSocketValueString *val = default_value; - val->subtype = subtype; - BLI_strncpy(val->value, value, 1024);//FILE_MAX -} - -void node_socket_set_default_value_shader(void *UNUSED(default_value)) -{ -} - -void node_socket_set_default_value_mesh(void *UNUSED(default_value)) -{ -} - - -void node_socket_copy_default_value(int type, void *to_default_value, void *from_default_value) -{ - /* XXX only one of these pointers is valid! just putting them here for convenience */ - bNodeSocketValueFloat *fromfloat= (bNodeSocketValueFloat*)from_default_value; - bNodeSocketValueInt *fromint= (bNodeSocketValueInt*)from_default_value; - bNodeSocketValueBoolean *frombool= (bNodeSocketValueBoolean*)from_default_value; - bNodeSocketValueVector *fromvector= (bNodeSocketValueVector*)from_default_value; - bNodeSocketValueRGBA *fromrgba= (bNodeSocketValueRGBA*)from_default_value; - bNodeSocketValueString *fromstring= (bNodeSocketValueString*)from_default_value; - - bNodeSocketValueFloat *tofloat= (bNodeSocketValueFloat*)to_default_value; - bNodeSocketValueInt *toint= (bNodeSocketValueInt*)to_default_value; - bNodeSocketValueBoolean *tobool= (bNodeSocketValueBoolean*)to_default_value; - bNodeSocketValueVector *tovector= (bNodeSocketValueVector*)to_default_value; - bNodeSocketValueRGBA *torgba= (bNodeSocketValueRGBA*)to_default_value; - bNodeSocketValueString *tostring= (bNodeSocketValueString*)to_default_value; - - switch (type) { - case SOCK_FLOAT: - *tofloat = *fromfloat; - break; - case SOCK_INT: - *toint = *fromint; - break; - case SOCK_BOOLEAN: - *tobool = *frombool; - break; - case SOCK_VECTOR: - *tovector = *fromvector; - break; - case SOCK_RGBA: - *torgba = *fromrgba; - break; - case SOCK_STRING: - *tostring = *fromstring; - break; - } -} - -/* XXX This is a makeshift function to have useful initial group socket values. - * In the end this should be implemented by a flexible socket data conversion system, - * which is yet to be implemented. The idea is that beside default standard conversions, - * such as int-to-float, it should be possible to quickly select a conversion method or - * a chain of conversions for each input, whenever there is more than one option. - * E.g. a vector-to-float conversion could use either of the x/y/z components or - * the vector length. - * - * In the interface this could be implemented by a pseudo-script textbox on linked inputs, - * with quick selection from a predefined list of conversion options. Some Examples: - * - vector component 'z' (vector->float): "z" - * - grayscale color (float->color): "gray" - * - color luminance (color->float): "lum" - * - matrix column 2 length (matrix->vector->float): "col[1].len" - * - mesh vertex coordinate 'y' (mesh->vertex->vector->float): "vertex.co.y" - * - * The actual conversion is then done by a series of conversion functions, - * which are defined in the socket type structs. - */ -void node_socket_convert_default_value(int to_type, void *to_default_value, int from_type, void *from_default_value) -{ - /* XXX only one of these pointers is valid! just putting them here for convenience */ - bNodeSocketValueFloat *fromfloat= (bNodeSocketValueFloat*)from_default_value; - bNodeSocketValueInt *fromint= (bNodeSocketValueInt*)from_default_value; - bNodeSocketValueBoolean *frombool= (bNodeSocketValueBoolean*)from_default_value; - bNodeSocketValueVector *fromvector= (bNodeSocketValueVector*)from_default_value; - bNodeSocketValueRGBA *fromrgba= (bNodeSocketValueRGBA*)from_default_value; - - bNodeSocketValueFloat *tofloat= (bNodeSocketValueFloat*)to_default_value; - bNodeSocketValueInt *toint= (bNodeSocketValueInt*)to_default_value; - bNodeSocketValueBoolean *tobool= (bNodeSocketValueBoolean*)to_default_value; - bNodeSocketValueVector *tovector= (bNodeSocketValueVector*)to_default_value; - bNodeSocketValueRGBA *torgba= (bNodeSocketValueRGBA*)to_default_value; - - switch (from_type) { - case SOCK_FLOAT: - switch (to_type) { - case SOCK_FLOAT: - tofloat->value = fromfloat->value; - break; - case SOCK_INT: - toint->value = (int)fromfloat->value; - break; - case SOCK_BOOLEAN: - tobool->value = (fromfloat->value > 0.0f); - break; - case SOCK_VECTOR: - tovector->value[0] = tovector->value[1] = tovector->value[2] = fromfloat->value; - break; - case SOCK_RGBA: - torgba->value[0] = torgba->value[1] = torgba->value[2] = torgba->value[3] = fromfloat->value; - break; - } - break; - case SOCK_INT: - switch (to_type) { - case SOCK_FLOAT: - tofloat->value = (float)fromint->value; - break; - case SOCK_INT: - toint->value = fromint->value; - break; - case SOCK_BOOLEAN: - tobool->value = (fromint->value > 0); - break; - case SOCK_VECTOR: - tovector->value[0] = tovector->value[1] = tovector->value[2] = (float)fromint->value; - break; - case SOCK_RGBA: - torgba->value[0] = torgba->value[1] = torgba->value[2] = torgba->value[3] = (float)fromint->value; - break; - } - break; - case SOCK_BOOLEAN: - switch (to_type) { - case SOCK_FLOAT: - tofloat->value = (float)frombool->value; - break; - case SOCK_INT: - toint->value = (int)frombool->value; - break; - case SOCK_BOOLEAN: - tobool->value = frombool->value; - break; - case SOCK_VECTOR: - tovector->value[0] = tovector->value[1] = tovector->value[2] = (float)frombool->value; - break; - case SOCK_RGBA: - torgba->value[0] = torgba->value[1] = torgba->value[2] = torgba->value[3] = (float)frombool->value; - break; - } - break; - case SOCK_VECTOR: - switch (to_type) { - case SOCK_FLOAT: - tofloat->value = fromvector->value[0]; - break; - case SOCK_INT: - toint->value = (int)fromvector->value[0]; - break; - case SOCK_BOOLEAN: - tobool->value = (fromvector->value[0] > 0.0f); - break; - case SOCK_VECTOR: - copy_v3_v3(tovector->value, fromvector->value); - break; - case SOCK_RGBA: - copy_v3_v3(torgba->value, fromvector->value); - torgba->value[3] = 1.0f; + /* initialize default_value */ + switch (stemp->type) { + case SOCK_FLOAT: { + bNodeSocketValueFloat *dval = sock->default_value; + dval->value = stemp->val1; + dval->min = stemp->min; + dval->max = stemp->max; break; } - break; - case SOCK_RGBA: - switch (to_type) { - case SOCK_FLOAT: - tofloat->value = fromrgba->value[0]; - break; - case SOCK_INT: - toint->value = (int)fromrgba->value[0]; - break; - case SOCK_BOOLEAN: - tobool->value = (fromrgba->value[0] > 0.0f); - break; - case SOCK_VECTOR: - copy_v3_v3(tovector->value, fromrgba->value); - break; - case SOCK_RGBA: - copy_v4_v4(torgba->value, fromrgba->value); + case SOCK_INT: { + bNodeSocketValueInt *dval = sock->default_value; + dval->value = (int)stemp->val1; + dval->min = (int)stemp->min; + dval->max = (int)stemp->max; break; } - break; - } -} - -static void node_socket_set_minmax_subtype(bNodeSocket *sock, struct bNodeSocketTemplate *stemp) -{ - switch (sock->type) { - case SOCK_FLOAT: - { - bNodeSocketValueFloat *dval= sock->default_value; - dval->min = stemp->min; - dval->max = stemp->max; - dval->subtype = stemp->subtype; + case SOCK_BOOLEAN: { + bNodeSocketValueBoolean *dval = sock->default_value; + dval->value = (int)stemp->val1; break; } - case SOCK_INT: - { - bNodeSocketValueInt *dval= sock->default_value; + case SOCK_VECTOR: { + bNodeSocketValueVector *dval = sock->default_value; + dval->value[0] = stemp->val1; + dval->value[1] = stemp->val2; + dval->value[2] = stemp->val3; dval->min = stemp->min; dval->max = stemp->max; - dval->subtype = stemp->subtype; break; } - case SOCK_VECTOR: - { - bNodeSocketValueVector *dval= sock->default_value; - dval->min = stemp->min; - dval->max = stemp->max; - dval->subtype = stemp->subtype; + case SOCK_RGBA: { + bNodeSocketValueRGBA *dval = sock->default_value; + dval->value[0] = stemp->val1; + dval->value[1] = stemp->val2; + dval->value[2] = stemp->val3; + dval->value[3] = stemp->val4; break; } } -} - -struct bNodeSocket *node_add_input_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp) -{ - bNodeSocket *sock = nodeAddSocket(ntree, node, SOCK_IN, stemp->name, stemp->type); - sock->flag |= stemp->flag; - - switch (stemp->type) { - case SOCK_INT: - node_socket_set_default_value_int(sock->default_value, stemp->subtype, (int)stemp->val1, (int)stemp->min, (int)stemp->max); - break; - case SOCK_FLOAT: - node_socket_set_default_value_float(sock->default_value, stemp->subtype, stemp->val1, stemp->min, stemp->max); - break; - case SOCK_BOOLEAN: - node_socket_set_default_value_boolean(sock->default_value, (char)stemp->val1); - break; - case SOCK_VECTOR: - node_socket_set_default_value_vector(sock->default_value, stemp->subtype, stemp->val1, stemp->val2, stemp->val3, stemp->min, stemp->max); - break; - case SOCK_RGBA: - node_socket_set_default_value_rgba(sock->default_value, stemp->val1, stemp->val2, stemp->val3, stemp->val4); - break; - case SOCK_SHADER: - node_socket_set_default_value_shader(sock->default_value); - break; - case SOCK_MESH: - node_socket_set_default_value_mesh(sock->default_value); - break; - case SOCK_STRING: - node_socket_set_default_value_string(sock->default_value, stemp->subtype, (char *)""); - break; - } return sock; } -struct bNodeSocket *node_add_output_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp) -{ - bNodeSocket *sock = nodeAddSocket(ntree, node, SOCK_OUT, stemp->name, stemp->type); - node_socket_set_minmax_subtype(sock, stemp); - return sock; -} - static bNodeSocket *verify_socket_template(bNodeTree *ntree, bNode *node, int in_out, ListBase *socklist, bNodeSocketTemplate *stemp) { bNodeSocket *sock; for (sock= socklist->first; sock; sock= sock->next) { - if (!(sock->flag & SOCK_DYNAMIC) && strncmp(sock->name, stemp->name, NODE_MAXSTR)==0) + if (strncmp(sock->name, stemp->name, NODE_MAXSTR)==0) break; } if (sock) { - sock->type = stemp->type; /* in future, read this from tydefs! */ + sock->type = stemp->type; if (stemp->limit == 0) sock->limit= 0xFFF; else sock->limit = stemp->limit; sock->flag |= stemp->flag; - /* Copy the property range and subtype parameters in case the template changed. - * NOT copying the actual value here, only button behavior changes! - */ - node_socket_set_minmax_subtype(sock, stemp); - BLI_remlink(socklist, sock); return sock; } else { /* no socket for this template found, make a new one */ - if (in_out==SOCK_IN) - sock = node_add_input_from_template(ntree, node, stemp); - else - sock = node_add_output_from_template(ntree, node, stemp); + sock = node_add_socket_from_template(ntree, node, stemp, in_out); /* remove the new socket from the node socket list first, * will be added back after verification. */ @@ -592,8 +140,7 @@ static void verify_socket_template_list(bNodeTree *ntree, bNode *node, int in_ou if (stemp_first==NULL) { for (sock = (bNodeSocket*)socklist->first; sock; sock=nextsock) { nextsock = sock->next; - if (!(sock->flag & SOCK_DYNAMIC)) - nodeRemoveSocket(ntree, node, sock); + nodeRemoveSocket(ntree, node, sock); } } else { @@ -606,8 +153,7 @@ static void verify_socket_template_list(bNodeTree *ntree, bNode *node, int in_ou /* leftovers are removed */ for (sock = (bNodeSocket*)socklist->first; sock; sock=nextsock) { nextsock = sock->next; - if (!(sock->flag & SOCK_DYNAMIC)) - nodeRemoveSocket(ntree, node, sock); + nodeRemoveSocket(ntree, node, sock); } /* and we put back the verified sockets */ @@ -635,14 +181,182 @@ static void verify_socket_template_list(bNodeTree *ntree, bNode *node, int in_ou void node_verify_socket_templates(bNodeTree *ntree, bNode *node) { bNodeType *ntype= node->typeinfo; - /* XXX Small trick: don't try to match socket lists when there are no templates. - * This also prevents group node sockets from being removed, without the need to explicitly + /* Don't try to match socket lists when there are no templates. + * This prevents group node sockets from being removed, without the need to explicitly * check the node type here. */ - if (ntype && ((ntype->inputs && ntype->inputs[0].type >= 0) || - (ntype->outputs && ntype->outputs[0].type >= 0))) - { - verify_socket_template_list(ntree, node, SOCK_IN, &node->inputs, ntype->inputs); - verify_socket_template_list(ntree, node, SOCK_OUT, &node->outputs, ntype->outputs); + if (ntype) { + if (ntype->inputs && ntype->inputs[0].type >= 0) + verify_socket_template_list(ntree, node, SOCK_IN, &node->inputs, ntype->inputs); + if (ntype->outputs && ntype->outputs[0].type >= 0) + verify_socket_template_list(ntree, node, SOCK_OUT, &node->outputs, ntype->outputs); + } +} + + +void node_socket_init_default_value(bNodeSocket *sock) +{ + int type = sock->typeinfo->type; + int subtype = sock->typeinfo->subtype; + + if (sock->default_value) + return; /* already initialized */ + + switch (type) { + case SOCK_FLOAT: { + bNodeSocketValueFloat *dval = MEM_callocN(sizeof(bNodeSocketValueFloat), "node socket value float"); + dval->subtype = subtype; + dval->value = 0.0f; + dval->min = -FLT_MAX; + dval->max = FLT_MAX; + + sock->default_value = dval; + break; + } + case SOCK_INT: { + bNodeSocketValueInt *dval = MEM_callocN(sizeof(bNodeSocketValueInt), "node socket value int"); + dval->subtype = subtype; + dval->value = 0; + dval->min = INT_MIN; + dval->max = INT_MAX; + + sock->default_value = dval; + break; + } + case SOCK_BOOLEAN: { + bNodeSocketValueBoolean *dval = MEM_callocN(sizeof(bNodeSocketValueBoolean), "node socket value bool"); + dval->value = false; + + sock->default_value = dval; + break; + } + case SOCK_VECTOR: { + bNodeSocketValueVector *dval = MEM_callocN(sizeof(bNodeSocketValueVector), "node socket value vector"); + dval->subtype = subtype; + copy_v3_v3(dval->value, (float[]){0.0f, 0.0f, 0.0f}); + dval->min = -FLT_MAX; + dval->max = FLT_MAX; + + sock->default_value = dval; + break; } + case SOCK_RGBA: { + bNodeSocketValueRGBA *dval = MEM_callocN(sizeof(bNodeSocketValueRGBA), "node socket value color"); + copy_v4_v4(dval->value, (float[]){0.0f, 0.0f, 0.0f, 1.0f}); + + sock->default_value = dval; + break; + } + case SOCK_STRING: { + bNodeSocketValueString *dval = MEM_callocN(sizeof(bNodeSocketValueString), "node socket value string"); + dval->subtype = subtype; + dval->value[0] = '\0'; + + sock->default_value = dval; + break; + } + } +} + + +static void standard_node_socket_interface_init_socket(bNodeTree *UNUSED(ntree), bNodeSocket *UNUSED(stemp), bNode *UNUSED(node), bNodeSocket *sock, const char *UNUSED(data_path)) +{ + /* initialize the type value */ + sock->type = sock->typeinfo->type; +} + +static bNodeSocketType *make_standard_socket_type(int type, int subtype) +{ + extern void ED_init_standard_node_socket_type(bNodeSocketType *); + + const char *socket_idname = nodeStaticSocketType(type, subtype); + const char *interface_idname = nodeStaticSocketInterfaceType(type, subtype); + bNodeSocketType *stype; + StructRNA *srna; + + stype = MEM_callocN(sizeof(bNodeSocketType), "node socket C type"); + BLI_strncpy(stype->idname, socket_idname, sizeof(stype->idname)); + + /* set the RNA type + * uses the exact same identifier as the socket type idname */ + srna = stype->ext_socket.srna = RNA_struct_find(socket_idname); + BLI_assert(srna != NULL); + /* associate the RNA type with the socket type */ + RNA_struct_blender_type_set(srna, stype); + + /* set the interface RNA type */ + srna = stype->ext_interface.srna = RNA_struct_find(interface_idname); + BLI_assert(srna != NULL); + /* associate the RNA type with the socket type */ + RNA_struct_blender_type_set(srna, stype); + + /* extra type info for standard socket types */ + stype->type = type; + stype->subtype = subtype; + + /* XXX bad-level call! needed for setting draw callbacks */ + ED_init_standard_node_socket_type(stype); + + stype->interface_init_socket = standard_node_socket_interface_init_socket; + + return stype; +} + +static bNodeSocketType *make_socket_type_virtual(void) +{ + extern void ED_init_node_socket_type_virtual(bNodeSocketType *); + + const char *socket_idname = "NodeSocketVirtual"; + bNodeSocketType *stype; + StructRNA *srna; + + stype = MEM_callocN(sizeof(bNodeSocketType), "node socket C type"); + BLI_strncpy(stype->idname, socket_idname, sizeof(stype->idname)); + + /* set the RNA type + * uses the exact same identifier as the socket type idname */ + srna = stype->ext_socket.srna = RNA_struct_find(socket_idname); + BLI_assert(srna != NULL); + /* associate the RNA type with the socket type */ + RNA_struct_blender_type_set(srna, stype); + + ED_init_node_socket_type_virtual(stype); + + return stype; +} + + +void register_standard_node_socket_types() +{ + /* draw callbacks are set in drawnode.c to avoid bad-level calls */ + + nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_NONE)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_UNSIGNED)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_PERCENTAGE)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_FACTOR)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_ANGLE)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_TIME)); + + nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_NONE)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_UNSIGNED)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_PERCENTAGE)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_FACTOR)); + + nodeRegisterSocketType(make_standard_socket_type(SOCK_BOOLEAN, PROP_NONE)); + + nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_NONE)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_TRANSLATION)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_DIRECTION)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_VELOCITY)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_ACCELERATION)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_EULER)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_XYZ)); + + nodeRegisterSocketType(make_standard_socket_type(SOCK_RGBA, PROP_NONE)); + + nodeRegisterSocketType(make_standard_socket_type(SOCK_STRING, PROP_NONE)); + + nodeRegisterSocketType(make_standard_socket_type(SOCK_SHADER, PROP_NONE)); + + nodeRegisterSocketType(make_socket_type_virtual()); } diff --git a/source/blender/nodes/intern/node_util.c b/source/blender/nodes/intern/node_util.c index 09e6ddd18a5..c622c1c5227 100644 --- a/source/blender/nodes/intern/node_util.c +++ b/source/blender/nodes/intern/node_util.c @@ -30,6 +30,7 @@ */ #include <limits.h> +#include <string.h> #include "DNA_action_types.h" #include "DNA_node_types.h" @@ -63,17 +64,17 @@ void node_free_standard_storage(bNode *node) } } -void node_copy_curves(bNode *orig_node, bNode *new_node) +void node_copy_curves(bNodeTree *UNUSED(dest_ntree), bNode *dest_node, bNode *src_node) { - new_node->storage = curvemapping_copy(orig_node->storage); + dest_node->storage = curvemapping_copy(src_node->storage); } -void node_copy_standard_storage(bNode *orig_node, bNode *new_node) +void node_copy_standard_storage(bNodeTree *UNUSED(dest_ntree), bNode *dest_node, bNode *src_node) { - new_node->storage = MEM_dupallocN(orig_node->storage); + dest_node->storage = MEM_dupallocN(src_node->storage); } -void *node_initexec_curves(bNode *node) +void *node_initexec_curves(bNodeExecContext *UNUSED(context), bNode *node, bNodeInstanceKey UNUSED(key)) { curvemapping_initialize(node->storage); return NULL; /* unused return */ @@ -129,6 +130,8 @@ void node_update_internal_links_default(bNodeTree *ntree, bNode *node) fromindex = INT_MAX; fromsock = NULL; for (link=ntree->links.first; link; link=link->next) { + if (nodeLinkIsHidden(link)) + continue; if (link->tonode == node && link->tosock->type == datatype) { int index = BLI_findindex(&node->inputs, link->tosock); if (index < fromindex) { @@ -146,6 +149,8 @@ void node_update_internal_links_default(bNodeTree *ntree, bNode *node) toindex = INT_MAX; tosock = NULL; for (link=ntree->links.first; link; link=link->next) { + if (nodeLinkIsHidden(link)) + continue; if (link->fromnode == node && link->fromsock->type == datatype) { int index = BLI_findindex(&node->outputs, link->fromsock); if (index < toindex) { @@ -188,3 +193,45 @@ void node_update_internal_links_default(bNodeTree *ntree, bNode *node) BLI_addtail(&node->internal_links, ilink); } } + +float node_socket_get_float(bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock) +{ + PointerRNA ptr; + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr); + return RNA_float_get(&ptr, "default_value"); +} + +void node_socket_set_float(bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock, float value) +{ + PointerRNA ptr; + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr); + RNA_float_set(&ptr, "default_value", value); +} + +void node_socket_get_color(bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock, float *value) +{ + PointerRNA ptr; + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr); + RNA_float_get_array(&ptr, "default_value", value); +} + +void node_socket_set_color(bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock, const float *value) +{ + PointerRNA ptr; + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr); + RNA_float_set_array(&ptr, "default_value", value); +} + +void node_socket_get_vector(bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock, float *value) +{ + PointerRNA ptr; + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr); + RNA_float_get_array(&ptr, "default_value", value); +} + +void node_socket_set_vector(bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock, const float *value) +{ + PointerRNA ptr; + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr); + RNA_float_set_array(&ptr, "default_value", value); +} diff --git a/source/blender/nodes/intern/node_util.h b/source/blender/nodes/intern/node_util.h index 6b783915816..2b3f84420f9 100644 --- a/source/blender/nodes/intern/node_util.h +++ b/source/blender/nodes/intern/node_util.h @@ -35,6 +35,8 @@ #include "DNA_listBase.h" +#include "BLI_utildefines.h" + #include "BKE_node.h" #include "MEM_guardedalloc.h" @@ -43,17 +45,29 @@ #include "GPU_material.h" /* For Shader muting GPU code... */ +#include "RNA_access.h" + struct bNodeTree; struct bNode; +/* data for initializing node execution */ +typedef struct bNodeExecContext { + struct bNodeInstanceHash *previews; +} bNodeExecContext; + +typedef struct bNodeExecData { + void *data; /* custom data storage */ + struct bNodePreview *preview; /* optional preview image */ +} bNodeExecData; + /**** Storage Data ****/ extern void node_free_curves(struct bNode *node); extern void node_free_standard_storage(struct bNode *node); -extern void node_copy_curves(struct bNode *orig_node, struct bNode *new_node); -extern void node_copy_standard_storage(struct bNode *orig_node, struct bNode *new_node); -extern void *node_initexec_curves(struct bNode *node); +extern void node_copy_curves(struct bNodeTree *dest_ntree, struct bNode *dest_node, struct bNode *src_node); +extern void node_copy_standard_storage(struct bNodeTree *dest_ntree, struct bNode *dest_node, struct bNode *src_node); +extern void *node_initexec_curves(struct bNodeExecContext *context, struct bNode *node, bNodeInstanceKey key); /**** Labels ****/ @@ -64,4 +78,11 @@ const char *node_filter_label(struct bNode *node); void node_update_internal_links_default(struct bNodeTree *ntree, struct bNode *node); +float node_socket_get_float(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock); +void node_socket_set_float(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock, float value); +void node_socket_get_color(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock, float *value); +void node_socket_set_color(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock, const float *value); +void node_socket_get_vector(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock, float *value); +void node_socket_set_vector(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock, const float *value); + #endif diff --git a/source/blender/nodes/shader/node_shader_tree.c b/source/blender/nodes/shader/node_shader_tree.c index 8fde0b9c342..30da509c09d 100644 --- a/source/blender/nodes/shader/node_shader_tree.c +++ b/source/blender/nodes/shader/node_shader_tree.c @@ -36,6 +36,7 @@ #include "DNA_material_types.h" #include "DNA_node_types.h" #include "DNA_scene_types.h" +#include "DNA_space_types.h" #include "DNA_world_types.h" #include "BLI_listbase.h" @@ -45,11 +46,14 @@ #include "BLF_translation.h" +#include "BKE_context.h" #include "BKE_global.h" #include "BKE_main.h" #include "BKE_node.h" #include "BKE_scene.h" +#include "RNA_access.h" + #include "GPU_material.h" #include "RE_shader_ext.h" @@ -59,23 +63,45 @@ #include "node_util.h" #include "node_shader_util.h" -static void foreach_nodetree(Main *main, void *calldata, bNodeTreeCallback func) +static int shader_tree_poll(const bContext *C, bNodeTreeType *UNUSED(treetype)) { - Material *ma; - Lamp *la; - World *wo; - - for (ma = main->mat.first; ma; ma = ma->id.next) - if (ma->nodetree) - func(calldata, &ma->id, ma->nodetree); - - for (la = main->lamp.first; la; la = la->id.next) - if (la->nodetree) - func(calldata, &la->id, la->nodetree); + Scene *scene = CTX_data_scene(C); + /* allow empty engine string too, this is from older versions that didn't have registerable engines yet */ + return (scene->r.engine[0] == '\0' + || strcmp(scene->r.engine, "BLENDER_RENDER")==0 + || strcmp(scene->r.engine, "CYCLES")==0); +} - for (wo = main->world.first; wo; wo = wo->id.next) - if (wo->nodetree) - func(calldata, &wo->id, wo->nodetree); +static void shader_get_from_context(const bContext *C, bNodeTreeType *UNUSED(treetype), bNodeTree **r_ntree, ID **r_id, ID **r_from) +{ + SpaceNode *snode = CTX_wm_space_node(C); + Scene *scene = CTX_data_scene(C); + Object *ob = OBACT; + + if (snode->shaderfrom == SNODE_SHADER_OBJECT) { + if (ob) { + if (ob->type == OB_LAMP) { + *r_from = &ob->id; + *r_id = ob->data; + *r_ntree = ((Lamp *)ob->data)->nodetree; + } + else { + Material *ma = give_current_material(ob, ob->actcol); + if (ma) { + *r_from = &ob->id; + *r_id = &ma->id; + *r_ntree = ma->nodetree; + } + } + } + } + else { /* SNODE_SHADER_WORLD */ + if (scene->world) { + *r_from = NULL; + *r_id = &scene->world->id; + *r_ntree = scene->world->nodetree; + } + } } static void foreach_nodeclass(Scene *scene, void *calldata, bNodeClassCallback func) @@ -93,6 +119,7 @@ static void foreach_nodeclass(Scene *scene, void *calldata, bNodeClassCallback f func(calldata, NODE_CLASS_CONVERTOR, N_("Convertor")); func(calldata, NODE_CLASS_SCRIPT, N_("Script")); func(calldata, NODE_CLASS_GROUP, N_("Group")); + func(calldata, NODE_CLASS_INTERFACE, N_("Interface")); func(calldata, NODE_CLASS_LAYOUT, N_("Layout")); } @@ -111,24 +138,8 @@ static void localize(bNodeTree *localtree, bNodeTree *UNUSED(ntree)) } } -static void local_sync(bNodeTree *localtree, bNodeTree *ntree) +static void local_sync(bNodeTree *UNUSED(localtree), bNodeTree *UNUSED(ntree)) { - bNode *lnode; - - /* copy over contents of previews */ - for (lnode = localtree->nodes.first; lnode; lnode = lnode->next) { - if (ntreeNodeExists(ntree, lnode->new_node)) { - bNode *node = lnode->new_node; - - if (node->preview && node->preview->rect) { - if (lnode->preview && lnode->preview->rect) { - int xsize = node->preview->xsize; - int ysize = node->preview->ysize; - memcpy(node->preview->rect, lnode->preview->rect, 4 * xsize + xsize * ysize * sizeof(char) * 4); - } - } - } - } } static void update(bNodeTree *ntree) @@ -136,26 +147,36 @@ static void update(bNodeTree *ntree) ntreeSetOutput(ntree); ntree_update_reroute_nodes(ntree); + + if (ntree->update & NTREE_UPDATE_NODES) { + /* clean up preview cache, in case nodes have been removed */ + BKE_node_preview_remove_unused(ntree); + } } -bNodeTreeType ntreeType_Shader = { - /* type */ NTREE_SHADER, - /* id_name */ "NTShader Nodetree", +bNodeTreeType *ntreeType_Shader; + +void register_node_tree_type_sh() +{ + bNodeTreeType *tt = ntreeType_Shader = MEM_callocN(sizeof(bNodeTreeType), "shader node tree type"); + + tt->type = NTREE_SHADER; + strcpy(tt->idname, "ShaderNodeTree"); + strcpy(tt->ui_name, "Shader"); + tt->ui_icon = 0; /* defined in drawnode.c */ + strcpy(tt->ui_description, ""); - /* node_types */ { NULL, NULL }, + tt->foreach_nodeclass = foreach_nodeclass; + tt->localize = localize; + tt->local_sync = local_sync; + tt->update = update; + tt->poll = shader_tree_poll; + tt->get_from_context = shader_get_from_context; - /* free_cache */ NULL, - /* free_node_cache */ NULL, - /* foreach_nodetree */ foreach_nodetree, - /* foreach_nodeclass */ foreach_nodeclass, - /* localize */ localize, - /* local_sync */ local_sync, - /* local_merge */ NULL, - /* update */ update, - /* update_node */ NULL, - /* validate_link */ NULL, - /* update_internal_links */ node_update_internal_links_default -}; + tt->ext.srna = &RNA_ShaderNodeTree; + + ntreeTypeAdd(tt); +} /* GPU material from shader nodes */ @@ -163,11 +184,11 @@ void ntreeGPUMaterialNodes(bNodeTree *ntree, GPUMaterial *mat) { bNodeTreeExec *exec; - exec = ntreeShaderBeginExecTree(ntree, 1); + exec = ntreeShaderBeginExecTree(ntree); ntreeExecGPUNodes(exec, mat, 1); - ntreeShaderEndExecTree(exec, 1); + ntreeShaderEndExecTree(exec); } /* **************** call to switch lamploop for material node ************ */ @@ -180,27 +201,16 @@ void set_node_shader_lamp_loop(void (*lamp_loop_func)(ShadeInput *, ShadeResult } -/* XXX Group nodes must set use_tree_data to false, since their trees can be shared by multiple nodes. - * If use_tree_data is true, the ntree->execdata pointer is checked to avoid multiple execution of top-level trees. - */ -bNodeTreeExec *ntreeShaderBeginExecTree(bNodeTree *ntree, int use_tree_data) +bNodeTreeExec *ntreeShaderBeginExecTree_internal(bNodeExecContext *context, bNodeTree *ntree, bNodeInstanceKey parent_key) { bNodeTreeExec *exec; bNode *node; - if (use_tree_data) { - /* XXX hack: prevent exec data from being generated twice. - * this should be handled by the renderer! - */ - if (ntree->execdata) - return ntree->execdata; - } - /* ensures only a single output node is enabled */ ntreeSetOutput(ntree); /* common base initialization */ - exec = ntree_exec_begin(ntree); + exec = ntree_exec_begin(context, ntree, parent_key); /* allocate the thread stack listbase array */ exec->threadstack = MEM_callocN(BLENDER_MAX_THREADS * sizeof(ListBase), "thread stack array"); @@ -208,43 +218,58 @@ bNodeTreeExec *ntreeShaderBeginExecTree(bNodeTree *ntree, int use_tree_data) for (node = exec->nodetree->nodes.first; node; node = node->next) node->need_exec = 1; - if (use_tree_data) { - /* XXX this should not be necessary, but is still used for cmp/sha/tex nodes, - * which only store the ntree pointer. Should be fixed at some point! - */ - ntree->execdata = exec; - } + return exec; +} + +bNodeTreeExec *ntreeShaderBeginExecTree(bNodeTree *ntree) +{ + bNodeExecContext context; + bNodeTreeExec *exec; + + /* XXX hack: prevent exec data from being generated twice. + * this should be handled by the renderer! + */ + if (ntree->execdata) + return ntree->execdata; + + context.previews = ntree->previews; + + exec = ntreeShaderBeginExecTree_internal(&context, ntree, NODE_INSTANCE_KEY_BASE); + + /* XXX this should not be necessary, but is still used for cmp/sha/tex nodes, + * which only store the ntree pointer. Should be fixed at some point! + */ + ntree->execdata = exec; return exec; } -/* XXX Group nodes must set use_tree_data to false, since their trees can be shared by multiple nodes. - * If use_tree_data is true, the ntree->execdata pointer is checked to avoid multiple execution of top-level trees. - */ -void ntreeShaderEndExecTree(bNodeTreeExec *exec, int use_tree_data) +void ntreeShaderEndExecTree_internal(bNodeTreeExec *exec) { - if (exec) { - bNodeTree *ntree = exec->nodetree; - bNodeThreadStack *nts; - int a; - - if (exec->threadstack) { - for (a = 0; a < BLENDER_MAX_THREADS; a++) { - for (nts = exec->threadstack[a].first; nts; nts = nts->next) - if (nts->stack) MEM_freeN(nts->stack); - BLI_freelistN(&exec->threadstack[a]); - } - - MEM_freeN(exec->threadstack); - exec->threadstack = NULL; + bNodeThreadStack *nts; + int a; + + if (exec->threadstack) { + for (a = 0; a < BLENDER_MAX_THREADS; a++) { + for (nts = exec->threadstack[a].first; nts; nts = nts->next) + if (nts->stack) MEM_freeN(nts->stack); + BLI_freelistN(&exec->threadstack[a]); } - ntree_exec_end(exec); + MEM_freeN(exec->threadstack); + exec->threadstack = NULL; + } + + ntree_exec_end(exec); +} + +void ntreeShaderEndExecTree(bNodeTreeExec *exec) +{ + if (exec) { + ntreeShaderEndExecTree_internal(exec); - if (use_tree_data) { - /* XXX clear nodetree backpointer to exec data, same problem as noted in ntreeBeginExecTree */ - ntree->execdata = NULL; - } + /* XXX clear nodetree backpointer to exec data, same problem as noted in ntreeBeginExecTree */ + exec->nodetree->execdata = NULL; } } @@ -272,7 +297,7 @@ bool ntreeShaderExecTree(bNodeTree *ntree, ShadeInput *shi, ShadeResult *shr) if (!exec) { BLI_lock_thread(LOCK_NODES); if (!ntree->execdata) - ntree->execdata = ntreeShaderBeginExecTree(ntree, 1); + ntree->execdata = ntreeShaderBeginExecTree(ntree); BLI_unlock_thread(LOCK_NODES); exec = ntree->execdata; diff --git a/source/blender/nodes/shader/node_shader_util.c b/source/blender/nodes/shader/node_shader_util.c index 1123a0dc44a..040172d9998 100644 --- a/source/blender/nodes/shader/node_shader_util.c +++ b/source/blender/nodes/shader/node_shader_util.c @@ -36,6 +36,20 @@ #include "node_exec.h" + +int sh_node_poll_default(bNodeType *UNUSED(ntype), bNodeTree *ntree) +{ + return (strcmp(ntree->idname, "ShaderNodeTree")==0); +} + +void sh_node_type_base(struct bNodeType *ntype, int type, const char *name, short nclass, short flag) +{ + node_type_base(ntype, type, name, nclass, flag); + + ntype->poll = sh_node_poll_default; + ntype->update_internal_links = node_update_internal_links_default; +} + /* ****** */ void nodestack_get_vec(float *in, short type_in, bNodeStack *ns) @@ -123,74 +137,6 @@ void ntreeShaderGetTexcoMode(bNodeTree *ntree, int r_mode, short *texco, int *mo } } -/* nodes that use ID data get synced with local data */ -void nodeShaderSynchronizeID(bNode *node, int copyto) -{ - if (node->id==NULL) return; - - if (ELEM(node->type, SH_NODE_MATERIAL, SH_NODE_MATERIAL_EXT)) { - bNodeSocket *sock; - Material *ma= (Material *)node->id; - int a; - - /* hrmf, case in loop isn't super fast, but we don't edit 100s of material at same time either! */ - for (a=0, sock= node->inputs.first; sock; sock= sock->next, a++) { - if (!nodeSocketIsHidden(sock)) { - if (copyto) { - switch (a) { - case MAT_IN_COLOR: - copy_v3_v3(&ma->r, ((bNodeSocketValueRGBA *)sock->default_value)->value); break; - case MAT_IN_SPEC: - copy_v3_v3(&ma->specr, ((bNodeSocketValueRGBA *)sock->default_value)->value); break; - case MAT_IN_REFL: - ma->ref= ((bNodeSocketValueFloat *)sock->default_value)->value; break; - case MAT_IN_MIR: - copy_v3_v3(&ma->mirr, ((bNodeSocketValueRGBA *)sock->default_value)->value); break; - case MAT_IN_AMB: - ma->amb = ((bNodeSocketValueFloat *)sock->default_value)->value; break; - case MAT_IN_EMIT: - ma->emit = ((bNodeSocketValueFloat *)sock->default_value)->value; break; - case MAT_IN_SPECTRA: - ma->spectra = ((bNodeSocketValueFloat *)sock->default_value)->value; break; - case MAT_IN_RAY_MIRROR: - ma->ray_mirror = ((bNodeSocketValueFloat *)sock->default_value)->value; break; - case MAT_IN_ALPHA: - ma->alpha = ((bNodeSocketValueFloat *)sock->default_value)->value; break; - case MAT_IN_TRANSLUCENCY: - ma->translucency = ((bNodeSocketValueFloat *)sock->default_value)->value; break; - } - } - else { - switch (a) { - case MAT_IN_COLOR: - copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, &ma->r); break; - case MAT_IN_SPEC: - copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, &ma->specr); break; - case MAT_IN_REFL: - ((bNodeSocketValueFloat *)sock->default_value)->value= ma->ref; break; - case MAT_IN_MIR: - copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, &ma->mirr); break; - case MAT_IN_AMB: - ((bNodeSocketValueFloat *)sock->default_value)->value = ma->amb; break; - case MAT_IN_EMIT: - ((bNodeSocketValueFloat *)sock->default_value)->value = ma->emit; break; - case MAT_IN_SPECTRA: - ((bNodeSocketValueFloat *)sock->default_value)->value = ma->spectra; break; - case MAT_IN_RAY_MIRROR: - ((bNodeSocketValueFloat *)sock->default_value)->value = ma->ray_mirror; break; - case MAT_IN_ALPHA: - ((bNodeSocketValueFloat *)sock->default_value)->value = ma->alpha; break; - case MAT_IN_TRANSLUCENCY: - ((bNodeSocketValueFloat *)sock->default_value)->value = ma->translucency; break; - } - } - } - } - } - -} - - void node_gpu_stack_from_data(struct GPUNodeStack *gs, int type, bNodeStack *ns) { memset(gs, 0, sizeof(*gs)); @@ -249,23 +195,24 @@ static void data_from_gpu_stack_list(ListBase *sockets, bNodeStack **ns, GPUNode bNode *nodeGetActiveTexture(bNodeTree *ntree) { /* this is the node we texture paint and draw in textured draw */ - bNode *node; + bNode *node, *tnode; if (!ntree) return NULL; - /* check for group edit */ - for (node= ntree->nodes.first; node; node= node->next) - if (node->flag & NODE_GROUP_EDIT) - break; - - if (node) - ntree = (bNodeTree *)node->id; - for (node= ntree->nodes.first; node; node= node->next) if (node->flag & NODE_ACTIVE_TEXTURE) return node; + /* node active texture node in this tree, look inside groups */ + for(node= ntree->nodes.first; node; node= node->next) { + if (node->type==NODE_GROUP) { + tnode = nodeGetActiveTexture((bNodeTree*)node->id); + if (tnode) + return tnode; + } + } + return NULL; } @@ -299,14 +246,7 @@ void ntreeExecGPUNodes(bNodeTreeExec *exec, GPUMaterial *mat, int do_outputs) node_get_stack(node, stack, nsin, nsout); gpu_stack_from_data_list(gpuin, &node->inputs, nsin); gpu_stack_from_data_list(gpuout, &node->outputs, nsout); - if (node->typeinfo->gpufunc(mat, node, gpuin, gpuout)) - data_from_gpu_stack_list(&node->outputs, nsout, gpuout); - } - else if (node->typeinfo->gpuextfunc) { - node_get_stack(node, stack, nsin, nsout); - gpu_stack_from_data_list(gpuin, &node->inputs, nsin); - gpu_stack_from_data_list(gpuout, &node->outputs, nsout); - if (node->typeinfo->gpuextfunc(mat, node, nodeexec->data, gpuin, gpuout)) + if (node->typeinfo->gpufunc(mat, node, &nodeexec->data, gpuin, gpuout)) data_from_gpu_stack_list(&node->outputs, nsout, gpuout); } } diff --git a/source/blender/nodes/shader/node_shader_util.h b/source/blender/nodes/shader/node_shader_util.h index 9c911501435..57b129335bb 100644 --- a/source/blender/nodes/shader/node_shader_util.h +++ b/source/blender/nodes/shader/node_shader_util.h @@ -79,6 +79,11 @@ #include "GPU_material.h" + +int sh_node_poll_default(struct bNodeType *ntype, struct bNodeTree *ntree); +void sh_node_type_base(struct bNodeType *ntype, int type, const char *name, short nclass, short flag); + + /* ********* exec data struct, remains internal *********** */ typedef struct ShaderCallData { @@ -86,40 +91,6 @@ typedef struct ShaderCallData { ShadeResult *shr; /* from render pipe */ } ShaderCallData; -/* output socket defines */ -#define GEOM_OUT_GLOB 0 -#define GEOM_OUT_LOCAL 1 -#define GEOM_OUT_VIEW 2 -#define GEOM_OUT_ORCO 3 -#define GEOM_OUT_UV 4 -#define GEOM_OUT_NORMAL 5 -#define GEOM_OUT_VCOL 6 -#define GEOM_OUT_VCOL_ALPHA 7 -#define GEOM_OUT_FRONTBACK 8 - - -/* input socket defines */ -#define MAT_IN_COLOR 0 -#define MAT_IN_SPEC 1 -#define MAT_IN_REFL 2 -#define MAT_IN_NORMAL 3 -#define MAT_IN_MIR 4 -#define MAT_IN_AMB 5 -#define MAT_IN_EMIT 6 -#define MAT_IN_SPECTRA 7 -#define MAT_IN_RAY_MIRROR 8 -#define MAT_IN_ALPHA 9 -#define MAT_IN_TRANSLUCENCY 10 -#define NUM_MAT_IN 11 /* for array size */ - -/* output socket defines */ -#define MAT_OUT_COLOR 0 -#define MAT_OUT_ALPHA 1 -#define MAT_OUT_NORMAL 2 -#define MAT_OUT_DIFFUSE 3 -#define MAT_OUT_SPEC 4 -#define MAT_OUT_AO 5 - extern void node_ID_title_cb(void *node_v, void *unused_v); void nodestack_get_vec(float *in, short type_in, bNodeStack *ns); diff --git a/source/blender/nodes/shader/nodes/node_shader_add_shader.c b/source/blender/nodes/shader/nodes/node_shader_add_shader.c index ec868b2cc38..75d4fb1a30a 100644 --- a/source/blender/nodes/shader/nodes/node_shader_add_shader.c +++ b/source/blender/nodes/shader/nodes/node_shader_add_shader.c @@ -40,24 +40,23 @@ static bNodeSocketTemplate sh_node_add_shader_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_add_shader(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_add_shader(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_add_shader", in, out); } /* node type definition */ -void register_node_type_sh_add_shader(bNodeTreeType *ttype) +void register_node_type_sh_add_shader() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_ADD_SHADER, "Add Shader", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_ADD_SHADER, "Add Shader", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_add_shader_in, sh_node_add_shader_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_add_shader); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.c b/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.c index 7dfefc9ece0..85814c4a041 100644 --- a/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.c +++ b/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.c @@ -39,25 +39,24 @@ static bNodeSocketTemplate sh_node_ambient_occlusion_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_ambient_occlusion(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_ambient_occlusion(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_ambient_occlusion", in, out, GPU_builtin(GPU_VIEW_NORMAL)); } /* node type definition */ -void register_node_type_sh_ambient_occlusion(bNodeTreeType *ttype) +void register_node_type_sh_ambient_occlusion() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_AMBIENT_OCCLUSION, "Ambient Occlusion", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_AMBIENT_OCCLUSION, "Ambient Occlusion", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_ambient_occlusion_in, sh_node_ambient_occlusion_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_ambient_occlusion); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_attribute.c b/source/blender/nodes/shader/nodes/node_shader_attribute.c index 9b2ed2f14f0..b6463655755 100644 --- a/source/blender/nodes/shader/nodes/node_shader_attribute.c +++ b/source/blender/nodes/shader/nodes/node_shader_attribute.c @@ -36,25 +36,23 @@ static bNodeSocketTemplate sh_node_attribute_out[] = { { -1, 0, "" } }; -static void node_shader_init_attribute(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_attribute(bNodeTree *UNUSED(ntree), bNode *node) { NodeShaderAttribute *attr = MEM_callocN(sizeof(NodeShaderAttribute), "NodeShaderAttribute"); node->storage = attr; } /* node type definition */ -void register_node_type_sh_attribute(bNodeTreeType *ttype) +void register_node_type_sh_attribute() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_ATTRIBUTE, "Attribute", NODE_CLASS_INPUT, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_ATTRIBUTE, "Attribute", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_attribute_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_attribute); node_type_storage(&ntype, "NodeShaderAttribute", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); - node_type_gpu(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_background.c b/source/blender/nodes/shader/nodes/node_shader_background.c index d82c513540c..b109a2e4596 100644 --- a/source/blender/nodes/shader/nodes/node_shader_background.c +++ b/source/blender/nodes/shader/nodes/node_shader_background.c @@ -41,18 +41,16 @@ static bNodeSocketTemplate sh_node_background_out[] = { }; /* node type definition */ -void register_node_type_sh_background(bNodeTreeType *ttype) +void register_node_type_sh_background() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BACKGROUND, "Background", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_BACKGROUND, "Background", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_background_in, sh_node_background_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); - node_type_gpu(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_brightness.c b/source/blender/nodes/shader/nodes/node_shader_brightness.c index fa77fce4c88..ccdbddadb14 100644 --- a/source/blender/nodes/shader/nodes/node_shader_brightness.c +++ b/source/blender/nodes/shader/nodes/node_shader_brightness.c @@ -43,23 +43,22 @@ static bNodeSocketTemplate sh_node_brightcontrast_out[] = { { -1, 0, "" } }; -static int gpu_shader_brightcontrast(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_brightcontrast(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "brightness_contrast", in, out); } -void register_node_type_sh_brightcontrast(bNodeTreeType *ttype) +void register_node_type_sh_brightcontrast() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BRIGHTCONTRAST, "Bright/Contrast", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_BRIGHTCONTRAST, "Bright/Contrast", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_brightcontrast_in, sh_node_brightcontrast_out); node_type_size(&ntype, 140, 100, 320); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, gpu_shader_brightcontrast); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_anisotropic.c b/source/blender/nodes/shader/nodes/node_shader_bsdf_anisotropic.c index 71780e9316e..e4b9c372607 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_anisotropic.c +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_anisotropic.c @@ -44,7 +44,7 @@ static bNodeSocketTemplate sh_node_bsdf_anisotropic_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_bsdf_anisotropic(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_bsdf_anisotropic(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[3].link) in[3].link = GPU_builtin(GPU_VIEW_NORMAL); @@ -53,18 +53,17 @@ static int node_shader_gpu_bsdf_anisotropic(GPUMaterial *mat, bNode *UNUSED(node } /* node type definition */ -void register_node_type_sh_bsdf_anisotropic(bNodeTreeType *ttype) +void register_node_type_sh_bsdf_anisotropic() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BSDF_ANISOTROPIC, "Anisotropic BSDF", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_BSDF_ANISOTROPIC, "Anisotropic BSDF", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_bsdf_anisotropic_in, sh_node_bsdf_anisotropic_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_bsdf_anisotropic); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_diffuse.c b/source/blender/nodes/shader/nodes/node_shader_bsdf_diffuse.c index ad9f197afb8..466c2db07d4 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_diffuse.c +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_diffuse.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate sh_node_bsdf_diffuse_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_bsdf_diffuse(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_bsdf_diffuse(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[2].link) in[2].link = GPU_builtin(GPU_VIEW_NORMAL); @@ -50,18 +50,17 @@ static int node_shader_gpu_bsdf_diffuse(GPUMaterial *mat, bNode *UNUSED(node), G } /* node type definition */ -void register_node_type_sh_bsdf_diffuse(bNodeTreeType *ttype) +void register_node_type_sh_bsdf_diffuse() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BSDF_DIFFUSE, "Diffuse BSDF", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_BSDF_DIFFUSE, "Diffuse BSDF", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_bsdf_diffuse_in, sh_node_bsdf_diffuse_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_bsdf_diffuse); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_glass.c b/source/blender/nodes/shader/nodes/node_shader_bsdf_glass.c index 9e188092570..b36a754e129 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_glass.c +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_glass.c @@ -42,7 +42,7 @@ static bNodeSocketTemplate sh_node_bsdf_glass_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_bsdf_glass(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_bsdf_glass(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[3].link) in[3].link = GPU_builtin(GPU_VIEW_NORMAL); @@ -51,18 +51,17 @@ static int node_shader_gpu_bsdf_glass(GPUMaterial *mat, bNode *UNUSED(node), GPU } /* node type definition */ -void register_node_type_sh_bsdf_glass(bNodeTreeType *ttype) +void register_node_type_sh_bsdf_glass() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BSDF_GLASS, "Glass BSDF", NODE_CLASS_SHADER, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_BSDF_GLASS, "Glass BSDF", NODE_CLASS_SHADER, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_bsdf_glass_in, sh_node_bsdf_glass_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_bsdf_glass); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.c b/source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.c index 5e32930b707..00d4f18fe65 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.c +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate sh_node_bsdf_glossy_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_bsdf_glossy(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_bsdf_glossy(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[2].link) in[2].link = GPU_builtin(GPU_VIEW_NORMAL); @@ -50,18 +50,17 @@ static int node_shader_gpu_bsdf_glossy(GPUMaterial *mat, bNode *UNUSED(node), GP } /* node type definition */ -void register_node_type_sh_bsdf_glossy(bNodeTreeType *ttype) +void register_node_type_sh_bsdf_glossy() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BSDF_GLOSSY, "Glossy BSDF", NODE_CLASS_SHADER, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_BSDF_GLOSSY, "Glossy BSDF", NODE_CLASS_SHADER, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_bsdf_glossy_in, sh_node_bsdf_glossy_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_bsdf_glossy); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_refraction.c b/source/blender/nodes/shader/nodes/node_shader_bsdf_refraction.c index 99e66e39002..e8509c489ef 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_refraction.c +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_refraction.c @@ -42,7 +42,7 @@ static bNodeSocketTemplate sh_node_bsdf_refraction_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_bsdf_refraction(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_bsdf_refraction(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[3].link) in[3].link = GPU_builtin(GPU_VIEW_NORMAL); @@ -51,18 +51,17 @@ static int node_shader_gpu_bsdf_refraction(GPUMaterial *mat, bNode *UNUSED(node) } /* node type definition */ -void register_node_type_sh_bsdf_refraction(bNodeTreeType *ttype) +void register_node_type_sh_bsdf_refraction() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BSDF_REFRACTION, "Refraction BSDF", NODE_CLASS_SHADER, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_BSDF_REFRACTION, "Refraction BSDF", NODE_CLASS_SHADER, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_bsdf_refraction_in, sh_node_bsdf_refraction_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_bsdf_refraction); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_translucent.c b/source/blender/nodes/shader/nodes/node_shader_bsdf_translucent.c index 3c7084886b7..ab4ced3f99e 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_translucent.c +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_translucent.c @@ -40,7 +40,7 @@ static bNodeSocketTemplate sh_node_bsdf_translucent_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_bsdf_translucent(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_bsdf_translucent(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[1].link) in[1].link = GPU_builtin(GPU_VIEW_NORMAL); @@ -49,18 +49,17 @@ static int node_shader_gpu_bsdf_translucent(GPUMaterial *mat, bNode *UNUSED(node } /* node type definition */ -void register_node_type_sh_bsdf_translucent(bNodeTreeType *ttype) +void register_node_type_sh_bsdf_translucent() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BSDF_TRANSLUCENT, "Translucent BSDF", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_BSDF_TRANSLUCENT, "Translucent BSDF", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_bsdf_translucent_in, sh_node_bsdf_translucent_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_bsdf_translucent); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_transparent.c b/source/blender/nodes/shader/nodes/node_shader_bsdf_transparent.c index 7fb452ad78d..843454dbb3e 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_transparent.c +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_transparent.c @@ -39,24 +39,23 @@ static bNodeSocketTemplate sh_node_bsdf_transparent_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_bsdf_transparent(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_bsdf_transparent(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_bsdf_transparent", in, out); } /* node type definition */ -void register_node_type_sh_bsdf_transparent(bNodeTreeType *ttype) +void register_node_type_sh_bsdf_transparent() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BSDF_TRANSPARENT, "Transparent BSDF", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_BSDF_TRANSPARENT, "Transparent BSDF", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_bsdf_transparent_in, sh_node_bsdf_transparent_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_bsdf_transparent); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_velvet.c b/source/blender/nodes/shader/nodes/node_shader_bsdf_velvet.c index a4d25d42d4e..ff9fd3a07fe 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_velvet.c +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_velvet.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate sh_node_bsdf_velvet_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_bsdf_velvet(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_bsdf_velvet(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[2].link) in[2].link = GPU_builtin(GPU_VIEW_NORMAL); @@ -50,18 +50,17 @@ static int node_shader_gpu_bsdf_velvet(GPUMaterial *mat, bNode *UNUSED(node), GP } /* node type definition */ -void register_node_type_sh_bsdf_velvet(bNodeTreeType *ttype) +void register_node_type_sh_bsdf_velvet() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BSDF_VELVET, "Velvet BSDF", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_BSDF_VELVET, "Velvet BSDF", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_bsdf_velvet_in, sh_node_bsdf_velvet_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_bsdf_velvet); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bump.c b/source/blender/nodes/shader/nodes/node_shader_bump.c index b0605f9b248..00733ebaf5c 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bump.c +++ b/source/blender/nodes/shader/nodes/node_shader_bump.c @@ -46,23 +46,22 @@ static bNodeSocketTemplate sh_node_bump_out[] = { { -1, 0, "" } }; -static int gpu_shader_bump(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_bump(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_bump", in, out, GPU_builtin(GPU_VIEW_NORMAL)); } /* node type definition */ -void register_node_type_sh_bump(bNodeTreeType *ttype) +void register_node_type_sh_bump() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BUMP, "Bump", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_BUMP, "Bump", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_bump_in, sh_node_bump_out); node_type_size(&ntype, 150, 60, 200); node_type_storage(&ntype, "BumpNode", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, gpu_shader_bump); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_camera.c b/source/blender/nodes/shader/nodes/node_shader_camera.c index fd36a94516e..8a406bc7f74 100644 --- a/source/blender/nodes/shader/nodes/node_shader_camera.c +++ b/source/blender/nodes/shader/nodes/node_shader_camera.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate sh_node_camera_out[] = { }; -static void node_shader_exec_camera(void *data, bNode *UNUSED(node), bNodeStack **UNUSED(in), bNodeStack **out) +static void node_shader_exec_camera(void *data, int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **UNUSED(in), bNodeStack **out) { if (data) { ShadeInput *shi= ((ShaderCallData *)data)->shi; /* Data we need for shading. */ @@ -52,22 +52,22 @@ static void node_shader_exec_camera(void *data, bNode *UNUSED(node), bNodeStack } } -static int gpu_shader_camera(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_camera(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "camera", in, out, GPU_builtin(GPU_VIEW_POSITION)); } -void register_node_type_sh_camera(bNodeTreeType *ttype) +void register_node_type_sh_camera() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_CAMERA, "Camera Data", NODE_CLASS_INPUT, 0); + sh_node_type_base(&ntype, SH_NODE_CAMERA, "Camera Data", NODE_CLASS_INPUT, 0); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_camera_out); node_type_size(&ntype, 95, 95, 120); node_type_storage(&ntype, "node_camera", NULL, NULL); - node_type_exec(&ntype, node_shader_exec_camera); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_camera); node_type_gpu(&ntype, gpu_shader_camera); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_common.c b/source/blender/nodes/shader/nodes/node_shader_common.c index 9c784709de3..8c148b86610 100644 --- a/source/blender/nodes/shader/nodes/node_shader_common.c +++ b/source/blender/nodes/shader/nodes/node_shader_common.c @@ -38,9 +38,12 @@ #include "BKE_node.h" #include "node_shader_util.h" +#include "NOD_common.h" #include "node_common.h" #include "node_exec.h" +#include "RNA_access.h" + static void copy_stack(bNodeStack *to, bNodeStack *from) { if (to != from) { @@ -61,16 +64,14 @@ static void move_stack(bNodeStack *to, bNodeStack *from) to->datatype = from->datatype; to->is_copy = from->is_copy; - zero_v4(from->vec); from->data = NULL; - from->datatype = 0; from->is_copy = 0; } } /**** GROUP ****/ -static void *group_initexec(bNode *node) +static void *group_initexec(bNodeExecContext *context, bNode *node, bNodeInstanceKey key) { bNodeTree *ngroup = (bNodeTree *)node->id; bNodeTreeExec *exec; @@ -79,7 +80,7 @@ static void *group_initexec(bNode *node) return NULL; /* initialize the internal node tree execution */ - exec = ntreeShaderBeginExecTree(ngroup, 0); + exec = ntreeShaderBeginExecTree_internal(context, ngroup, key); return exec; } @@ -88,42 +89,55 @@ static void group_freeexec(bNode *UNUSED(node), void *nodedata) { bNodeTreeExec*gexec = (bNodeTreeExec *)nodedata; - ntreeShaderEndExecTree(gexec, 0); + ntreeShaderEndExecTree_internal(gexec); } /* Copy inputs to the internal stack. */ -static void group_copy_inputs(bNode *node, bNodeStack **in, bNodeStack *gstack) +static void group_copy_inputs(bNode *gnode, bNodeStack **in, bNodeStack *gstack) { + bNodeTree *ngroup = (bNodeTree*)gnode->id; + bNode *node; bNodeSocket *sock; bNodeStack *ns; int a; - for (sock=node->inputs.first, a=0; sock; sock=sock->next, ++a) { - if (sock->groupsock) { - ns = node_get_socket_stack(gstack, sock->groupsock); - copy_stack(ns, in[a]); + + for (node = ngroup->nodes.first; node; node = node->next) { + if (node->type == NODE_GROUP_INPUT) { + for (sock = node->outputs.first, a = 0; sock; sock = sock->next, ++a) { + ns = node_get_socket_stack(gstack, sock); + if (ns) + copy_stack(ns, in[a]); + } } } } /* Copy internal results to the external outputs. */ -static void group_move_outputs(bNode *node, bNodeStack **out, bNodeStack *gstack) +static void group_move_outputs(bNode *gnode, bNodeStack **out, bNodeStack *gstack) { + bNodeTree *ngroup = (bNodeTree*)gnode->id; + bNode *node; bNodeSocket *sock; bNodeStack *ns; int a; - for (sock=node->outputs.first, a=0; sock; sock=sock->next, ++a) { - if (sock->groupsock) { - ns = node_get_socket_stack(gstack, sock->groupsock); - move_stack(out[a], ns); + + for (node = ngroup->nodes.first; node; node = node->next) { + if (node->type == NODE_GROUP_OUTPUT && (node->flag & NODE_DO_OUTPUT)) { + for (sock = node->inputs.first, a = 0; sock; sock = sock->next, ++a) { + ns = node_get_socket_stack(gstack, sock); + if (ns) + move_stack(out[a], ns); + } + break; /* only one active output node */ } } } -static void group_execute(void *data, int thread, struct bNode *node, void *nodedata, struct bNodeStack **in, struct bNodeStack **out) +static void group_execute(void *data, int thread, struct bNode *node, bNodeExecData *execdata, struct bNodeStack **in, struct bNodeStack **out) { - bNodeTreeExec *exec = (bNodeTreeExec *)nodedata; + bNodeTreeExec *exec = execdata->data; bNodeThreadStack *nts; if (!exec) @@ -147,62 +161,88 @@ static void group_execute(void *data, int thread, struct bNode *node, void *node ntreeReleaseThreadStack(nts); } -static void group_gpu_copy_inputs(bNode *node, GPUNodeStack *in, bNodeStack *gstack) +static void group_gpu_copy_inputs(bNode *gnode, GPUNodeStack *in, bNodeStack *gstack) { + bNodeTree *ngroup = (bNodeTree*)gnode->id; + bNode *node; bNodeSocket *sock; bNodeStack *ns; int a; - for (sock=node->inputs.first, a=0; sock; sock=sock->next, ++a) { - if (sock->groupsock) { - ns = node_get_socket_stack(gstack, sock->groupsock); - /* convert the external gpu stack back to internal node stack data */ - node_data_from_gpu_stack(ns, &in[a]); + + for (node = ngroup->nodes.first; node; node = node->next) { + if (node->type == NODE_GROUP_INPUT) { + for (sock = node->outputs.first, a = 0; sock; sock = sock->next, ++a) { + ns = node_get_socket_stack(gstack, sock); + if (ns) { + /* convert the external gpu stack back to internal node stack data */ + node_data_from_gpu_stack(ns, &in[a]); + } + } } } } /* Copy internal results to the external outputs. */ -static void group_gpu_move_outputs(bNode *node, GPUNodeStack *out, bNodeStack *gstack) +static void group_gpu_move_outputs(bNode *gnode, GPUNodeStack *out, bNodeStack *gstack) { + bNodeTree *ngroup = (bNodeTree*)gnode->id; + bNode *node; bNodeSocket *sock; bNodeStack *ns; int a; - for (sock=node->outputs.first, a=0; sock; sock=sock->next, ++a) { - if (sock->groupsock) { - ns = node_get_socket_stack(gstack, sock->groupsock); - /* convert the node stack data result back to gpu stack */ - node_gpu_stack_from_data(&out[a], sock->type, ns); + + for (node = ngroup->nodes.first; node; node = node->next) { + if (node->type == NODE_GROUP_OUTPUT && (node->flag & NODE_DO_OUTPUT)) { + for (sock = node->inputs.first, a = 0; sock; sock = sock->next, ++a) { + ns = node_get_socket_stack(gstack, sock); + if (ns) { + /* convert the node stack data result back to gpu stack */ + node_gpu_stack_from_data(&out[a], sock->type, ns); + } + } + break; /* only one active output node */ } } } -static int gpu_group_execute(GPUMaterial *mat, bNode *node, void *nodedata, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_group_execute(GPUMaterial *mat, bNode *node, bNodeExecData *execdata, GPUNodeStack *in, GPUNodeStack *out) { - bNodeTreeExec *exec = (bNodeTreeExec *)nodedata; + bNodeTreeExec *exec = execdata->data; group_gpu_copy_inputs(node, in, exec->stack); + #if 0 /* XXX NODE_GROUP_EDIT is deprecated, depends on node space */ ntreeExecGPUNodes(exec, mat, (node->flag & NODE_GROUP_EDIT)); + #else + ntreeExecGPUNodes(exec, mat, 0); + #endif group_gpu_move_outputs(node, out, exec->stack); return 1; } -void register_node_type_sh_group(bNodeTreeType *ttype) +void register_node_type_sh_group() { static bNodeType ntype; - - node_type_base(ttype, &ntype, NODE_GROUP, "Group", NODE_CLASS_GROUP, NODE_OPTIONS|NODE_CONST_OUTPUT); + + /* NB: cannot use sh_node_type_base for node group, because it would map the node type + * to the shared NODE_GROUP integer type id. + */ + node_type_base_custom(&ntype, "ShaderNodeGroup", "Group", NODE_CLASS_GROUP, NODE_OPTIONS | NODE_CONST_OUTPUT); + ntype.type = NODE_GROUP; + ntype.poll = sh_node_poll_default; + ntype.update_internal_links = node_update_internal_links_default; + ntype.ext.srna = RNA_struct_find("ShaderNodeGroup"); + BLI_assert(ntype.ext.srna != NULL); + RNA_struct_blender_type_set(ntype.ext.srna, &ntype); + node_type_socket_templates(&ntype, NULL, NULL); node_type_size(&ntype, 120, 60, 200); node_type_label(&ntype, node_group_label); - node_type_init(&ntype, node_group_init); - node_type_valid(&ntype, node_group_valid); - node_type_template(&ntype, node_group_template); node_type_update(&ntype, NULL, node_group_verify); - node_type_group_edit(&ntype, node_group_edit_get, node_group_edit_set, node_group_edit_clear); - node_type_exec_new(&ntype, group_initexec, group_freeexec, group_execute); - node_type_gpu_ext(&ntype, gpu_group_execute); + strcpy(ntype.group_tree_idname, "ShaderNodeTree"); + node_type_exec(&ntype, group_initexec, group_freeexec, group_execute); + node_type_gpu(&ntype, gpu_group_execute); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_curves.c b/source/blender/nodes/shader/nodes/node_shader_curves.c index 216e10a7e9a..7a6d4a08db0 100644 --- a/source/blender/nodes/shader/nodes/node_shader_curves.c +++ b/source/blender/nodes/shader/nodes/node_shader_curves.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate sh_node_curve_vec_out[] = { { -1, 0, "" } }; -static void node_shader_exec_curve_vec(void *UNUSED(data), bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_curve_vec(void *UNUSED(data), int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { float vec[3]; @@ -55,12 +55,12 @@ static void node_shader_exec_curve_vec(void *UNUSED(data), bNode *node, bNodeSta curvemapping_evaluate3F(node->storage, out[0]->vec, vec); } -static void node_shader_init_curve_vec(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_curve_vec(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= curvemapping_add(3, -1.0f, -1.0f, 1.0f, 1.0f); } -static int gpu_shader_curve_vec(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_curve_vec(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { float *array; int size; @@ -69,21 +69,20 @@ static int gpu_shader_curve_vec(GPUMaterial *mat, bNode *node, GPUNodeStack *in, return GPU_stack_link(mat, "curves_vec", in, out, GPU_texture(size, array)); } -void register_node_type_sh_curve_vec(bNodeTreeType *ttype) +void register_node_type_sh_curve_vec() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_CURVE_VEC, "Vector Curves", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_CURVE_VEC, "Vector Curves", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_curve_vec_in, sh_node_curve_vec_out); node_type_size(&ntype, 200, 140, 320); node_type_init(&ntype, node_shader_init_curve_vec); node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); - node_type_exec(&ntype, node_shader_exec_curve_vec); - node_type_exec_new(&ntype, node_initexec_curves, NULL, NULL); /* only for its initexec func */ + node_type_exec(&ntype, node_initexec_curves, NULL, node_shader_exec_curve_vec); node_type_gpu(&ntype, gpu_shader_curve_vec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -99,7 +98,7 @@ static bNodeSocketTemplate sh_node_curve_rgb_out[] = { { -1, 0, "" } }; -static void node_shader_exec_curve_rgb(void *UNUSED(data), bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_curve_rgb(void *UNUSED(data), int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { float vec[3]; @@ -112,12 +111,12 @@ static void node_shader_exec_curve_rgb(void *UNUSED(data), bNode *node, bNodeSta } } -static void node_shader_init_curve_rgb(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_curve_rgb(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= curvemapping_add(4, 0.0f, 0.0f, 1.0f, 1.0f); } -static int gpu_shader_curve_rgb(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_curve_rgb(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { float *array; int size; @@ -127,19 +126,18 @@ static int gpu_shader_curve_rgb(GPUMaterial *mat, bNode *node, GPUNodeStack *in, return GPU_stack_link(mat, "curves_rgb", in, out, GPU_texture(size, array)); } -void register_node_type_sh_curve_rgb(bNodeTreeType *ttype) +void register_node_type_sh_curve_rgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_curve_rgb_in, sh_node_curve_rgb_out); node_type_size(&ntype, 200, 140, 320); node_type_init(&ntype, node_shader_init_curve_rgb); node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); - node_type_exec(&ntype, node_shader_exec_curve_rgb); - node_type_exec_new(&ntype, node_initexec_curves, NULL, NULL); /* only for its initexec func */ + node_type_exec(&ntype, node_initexec_curves, NULL, node_shader_exec_curve_rgb); node_type_gpu(&ntype, gpu_shader_curve_rgb); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_emission.c b/source/blender/nodes/shader/nodes/node_shader_emission.c index 0c4cb7ed51c..d330afbdabe 100644 --- a/source/blender/nodes/shader/nodes/node_shader_emission.c +++ b/source/blender/nodes/shader/nodes/node_shader_emission.c @@ -40,24 +40,23 @@ static bNodeSocketTemplate sh_node_emission_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_emission(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_emission(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_emission", in, out, GPU_builtin(GPU_VIEW_NORMAL)); } /* node type definition */ -void register_node_type_sh_emission(bNodeTreeType *ttype) +void register_node_type_sh_emission() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_EMISSION, "Emission", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_EMISSION, "Emission", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_emission_in, sh_node_emission_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_emission); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_fresnel.c b/source/blender/nodes/shader/nodes/node_shader_fresnel.c index 80913e6b07a..fe15cc9bc04 100644 --- a/source/blender/nodes/shader/nodes/node_shader_fresnel.c +++ b/source/blender/nodes/shader/nodes/node_shader_fresnel.c @@ -38,25 +38,24 @@ static bNodeSocketTemplate sh_node_fresnel_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_fresnel(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_fresnel(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { /* todo: is incoming vector normalized? */ return GPU_stack_link(mat, "node_fresnel", in, out, GPU_builtin(GPU_VIEW_NORMAL), GPU_builtin(GPU_VIEW_POSITION)); } /* node type definition */ -void register_node_type_sh_fresnel(bNodeTreeType *ttype) +void register_node_type_sh_fresnel() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_FRESNEL, "Fresnel", NODE_CLASS_INPUT, 0); + sh_node_type_base(&ntype, SH_NODE_FRESNEL, "Fresnel", NODE_CLASS_INPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_fresnel_in, sh_node_fresnel_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_fresnel); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_gamma.c b/source/blender/nodes/shader/nodes/node_shader_gamma.c index 365bac77004..35b01cfb73e 100644 --- a/source/blender/nodes/shader/nodes/node_shader_gamma.c +++ b/source/blender/nodes/shader/nodes/node_shader_gamma.c @@ -41,18 +41,16 @@ static bNodeSocketTemplate sh_node_gamma_out[] = { { -1, 0, "" } }; -void register_node_type_sh_gamma(bNodeTreeType *ttype) +void register_node_type_sh_gamma() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_GAMMA, "Gamma", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_GAMMA, "Gamma", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_gamma_in, sh_node_gamma_out); node_type_size(&ntype, 140, 100, 320); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); - node_type_gpu(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_geom.c b/source/blender/nodes/shader/nodes/node_shader_geom.c index eb3d462d616..166e9453f35 100644 --- a/source/blender/nodes/shader/nodes/node_shader_geom.c +++ b/source/blender/nodes/shader/nodes/node_shader_geom.c @@ -51,7 +51,7 @@ static bNodeSocketTemplate sh_node_geom_out[] = { }; /* node execute callback */ -static void node_shader_exec_geom(void *data, bNode *node, bNodeStack **UNUSED(in), bNodeStack **out) +static void node_shader_exec_geom(void *data, int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **UNUSED(in), bNodeStack **out) { if (data) { ShadeInput *shi= ((ShaderCallData *)data)->shi; @@ -120,12 +120,12 @@ static void node_shader_exec_geom(void *data, bNode *node, bNodeStack **UNUSED(i } } -static void node_shader_init_geometry(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_geometry(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= MEM_callocN(sizeof(NodeGeometry), "NodeGeometry"); } -static int gpu_shader_geom(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_geom(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { NodeGeometry *ngeo= (NodeGeometry*)node->storage; GPUNodeLink *orco = GPU_attribute(CD_ORCO, ""); @@ -138,18 +138,18 @@ static int gpu_shader_geom(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUN } /* node type definition */ -void register_node_type_sh_geom(bNodeTreeType *ttype) +void register_node_type_sh_geom() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_GEOMETRY, "Geometry", NODE_CLASS_INPUT, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_GEOMETRY, "Geometry", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_geom_out); node_type_size(&ntype, 120, 80, 160); node_type_init(&ntype, node_shader_init_geometry); node_type_storage(&ntype, "NodeGeometry", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, node_shader_exec_geom); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_geom); node_type_gpu(&ntype, gpu_shader_geom); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_geometry.c b/source/blender/nodes/shader/nodes/node_shader_geometry.c index acef885d2d4..f57caa2f798 100644 --- a/source/blender/nodes/shader/nodes/node_shader_geometry.c +++ b/source/blender/nodes/shader/nodes/node_shader_geometry.c @@ -40,7 +40,7 @@ static bNodeSocketTemplate sh_node_geometry_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_geometry(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_geometry(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_geometry", in, out, GPU_builtin(GPU_VIEW_POSITION), GPU_builtin(GPU_VIEW_NORMAL), @@ -48,18 +48,17 @@ static int node_shader_gpu_geometry(GPUMaterial *mat, bNode *UNUSED(node), GPUNo } /* node type definition */ -void register_node_type_sh_geometry(bNodeTreeType *ttype) +void register_node_type_sh_geometry() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_NEW_GEOMETRY, "Geometry", NODE_CLASS_INPUT, 0); + sh_node_type_base(&ntype, SH_NODE_NEW_GEOMETRY, "Geometry", NODE_CLASS_INPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_geometry_out); node_type_size(&ntype, 120, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_geometry); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_hair_info.c b/source/blender/nodes/shader/nodes/node_shader_hair_info.c index 5cd4c8bd1d3..f03373ad066 100644 --- a/source/blender/nodes/shader/nodes/node_shader_hair_info.c +++ b/source/blender/nodes/shader/nodes/node_shader_hair_info.c @@ -36,18 +36,16 @@ static bNodeSocketTemplate outputs[] = { }; /* node type definition */ -void register_node_type_sh_hair_info(bNodeTreeType *ttype) +void register_node_type_sh_hair_info() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_HAIR_INFO, "Hair Info", NODE_CLASS_INPUT, 0); + sh_node_type_base(&ntype, SH_NODE_HAIR_INFO, "Hair Info", NODE_CLASS_INPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, outputs); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); - node_type_gpu(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_holdout.c b/source/blender/nodes/shader/nodes/node_shader_holdout.c index 18ad4994c9b..04769cad590 100644 --- a/source/blender/nodes/shader/nodes/node_shader_holdout.c +++ b/source/blender/nodes/shader/nodes/node_shader_holdout.c @@ -40,18 +40,16 @@ static bNodeSocketTemplate sh_node_holdout_out[] = { /* node type definition */ -void register_node_type_sh_holdout(bNodeTreeType *ttype) +void register_node_type_sh_holdout() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_HOLDOUT, "Holdout", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_HOLDOUT, "Holdout", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_holdout_in, sh_node_holdout_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); - node_type_gpu(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_hueSatVal.c b/source/blender/nodes/shader/nodes/node_shader_hueSatVal.c index b635ad1edd9..f4a5462b8cc 100644 --- a/source/blender/nodes/shader/nodes/node_shader_hueSatVal.c +++ b/source/blender/nodes/shader/nodes/node_shader_hueSatVal.c @@ -69,27 +69,27 @@ static void do_hue_sat_fac(bNode *UNUSED(node), float *out, float *hue, float *s } } -static void node_shader_exec_hue_sat(void *UNUSED(data), bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_hue_sat(void *UNUSED(data), int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { do_hue_sat_fac(node, out[0]->vec, in[0]->vec, in[1]->vec, in[2]->vec, in[4]->vec, in[3]->vec); } -static int gpu_shader_hue_sat(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_hue_sat(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "hue_sat", in, out); } -void register_node_type_sh_hue_sat(bNodeTreeType *ttype) +void register_node_type_sh_hue_sat() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_hue_sat_in, sh_node_hue_sat_out); node_type_size(&ntype, 150, 80, 250); - node_type_exec(&ntype, node_shader_exec_hue_sat); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_hue_sat); node_type_gpu(&ntype, gpu_shader_hue_sat); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_invert.c b/source/blender/nodes/shader/nodes/node_shader_invert.c index 2ea858f4e34..f3d4efc82d7 100644 --- a/source/blender/nodes/shader/nodes/node_shader_invert.c +++ b/source/blender/nodes/shader/nodes/node_shader_invert.c @@ -46,7 +46,7 @@ static bNodeSocketTemplate sh_node_invert_out[] = { { -1, 0, "" } }; -static void node_shader_exec_invert(void *UNUSED(data), bNode *UNUSED(node), bNodeStack **in, +static void node_shader_exec_invert(void *UNUSED(data), int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { float col[3], facm; @@ -67,21 +67,21 @@ bNodeStack **out) copy_v3_v3(out[0]->vec, col); } -static int gpu_shader_invert(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_invert(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "invert", in, out); } -void register_node_type_sh_invert(bNodeTreeType *ttype) +void register_node_type_sh_invert() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_invert_in, sh_node_invert_out); node_type_size(&ntype, 90, 80, 100); - node_type_exec(&ntype, node_shader_exec_invert); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_invert); node_type_gpu(&ntype, gpu_shader_invert); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_layer_weight.c b/source/blender/nodes/shader/nodes/node_shader_layer_weight.c index 3058483ebef..5b7cb4730ae 100644 --- a/source/blender/nodes/shader/nodes/node_shader_layer_weight.c +++ b/source/blender/nodes/shader/nodes/node_shader_layer_weight.c @@ -40,24 +40,23 @@ static bNodeSocketTemplate sh_node_layer_weight_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_layer_weight(GPUMaterial *UNUSED(mat), bNode *UNUSED(node), GPUNodeStack *UNUSED(in), GPUNodeStack *UNUSED(out)) +static int node_shader_gpu_layer_weight(GPUMaterial *UNUSED(mat), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *UNUSED(in), GPUNodeStack *UNUSED(out)) { return 0; } /* node type definition */ -void register_node_type_sh_layer_weight(bNodeTreeType *ttype) +void register_node_type_sh_layer_weight() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_LAYER_WEIGHT, "Layer Weight", NODE_CLASS_INPUT, 0); + sh_node_type_base(&ntype, SH_NODE_LAYER_WEIGHT, "Layer Weight", NODE_CLASS_INPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_layer_weight_in, sh_node_layer_weight_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_layer_weight); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_light_falloff.c b/source/blender/nodes/shader/nodes/node_shader_light_falloff.c index 2dec244ae3a..e30c59f6920 100644 --- a/source/blender/nodes/shader/nodes/node_shader_light_falloff.c +++ b/source/blender/nodes/shader/nodes/node_shader_light_falloff.c @@ -44,25 +44,24 @@ static bNodeSocketTemplate sh_node_light_falloff_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_light_falloff(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_light_falloff(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_light_falloff", in, out); } /* node type definition */ -void register_node_type_sh_light_falloff(bNodeTreeType *ttype) +void register_node_type_sh_light_falloff(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_LIGHT_FALLOFF, "Light Falloff", NODE_CLASS_OP_COLOR, 0); + sh_node_type_base(&ntype, SH_NODE_LIGHT_FALLOFF, "Light Falloff", NODE_CLASS_OP_COLOR, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_light_falloff_in, sh_node_light_falloff_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_light_falloff); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_light_path.c b/source/blender/nodes/shader/nodes/node_shader_light_path.c index b4a3d4e01e1..93efc5abfa4 100644 --- a/source/blender/nodes/shader/nodes/node_shader_light_path.c +++ b/source/blender/nodes/shader/nodes/node_shader_light_path.c @@ -41,24 +41,23 @@ static bNodeSocketTemplate sh_node_light_path_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_light_path(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_light_path(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_light_path", in, out); } /* node type definition */ -void register_node_type_sh_light_path(bNodeTreeType *ttype) +void register_node_type_sh_light_path() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_LIGHT_PATH, "Light Path", NODE_CLASS_INPUT, 0); + sh_node_type_base(&ntype, SH_NODE_LIGHT_PATH, "Light Path", NODE_CLASS_INPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_light_path_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_light_path); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_mapping.c b/source/blender/nodes/shader/nodes/node_shader_mapping.c index 396c1ac60bf..fc3ef736737 100644 --- a/source/blender/nodes/shader/nodes/node_shader_mapping.c +++ b/source/blender/nodes/shader/nodes/node_shader_mapping.c @@ -44,7 +44,7 @@ static bNodeSocketTemplate sh_node_mapping_out[] = { }; /* do the regular mapping options for blender textures */ -static void node_shader_exec_mapping(void *UNUSED(data), bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_mapping(void *UNUSED(data), int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { TexMapping *texmap= node->storage; float *vec= out[0]->vec; @@ -67,12 +67,12 @@ static void node_shader_exec_mapping(void *UNUSED(data), bNode *node, bNodeStack } -static void node_shader_init_mapping(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_mapping(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= add_tex_mapping(); } -static int gpu_shader_mapping(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_mapping(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { TexMapping *texmap= node->storage; float domin= (texmap->flag & TEXMAP_CLIP_MIN) != 0; @@ -86,18 +86,18 @@ static int gpu_shader_mapping(GPUMaterial *mat, bNode *node, GPUNodeStack *in, G return GPU_stack_link(mat, "mapping", in, out, tmat, tmin, tmax, tdomin, tdomax); } -void register_node_type_sh_mapping(bNodeTreeType *ttype) +void register_node_type_sh_mapping() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_MAPPING, "Mapping", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_MAPPING, "Mapping", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_mapping_in, sh_node_mapping_out); node_type_size(&ntype, 240, 160, 320); node_type_init(&ntype, node_shader_init_mapping); node_type_storage(&ntype, "TexMapping", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, node_shader_exec_mapping); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_mapping); node_type_gpu(&ntype, gpu_shader_mapping); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_material.c b/source/blender/nodes/shader/nodes/node_shader_material.c index a36f35c646d..29612ff74e2 100644 --- a/source/blender/nodes/shader/nodes/node_shader_material.c +++ b/source/blender/nodes/shader/nodes/node_shader_material.c @@ -29,7 +29,6 @@ * \ingroup shdnodes */ - #include "node_shader_util.h" /* **************** MATERIAL ******************** */ @@ -76,7 +75,7 @@ static bNodeSocketTemplate sh_node_material_ext_out[] = { { -1, 0, "" } }; -static void node_shader_exec_material(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_material(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { if (data && node->id) { ShadeResult shrnode; @@ -170,7 +169,7 @@ static void node_shader_exec_material(void *data, bNode *node, bNodeStack **in, col[3] = shrnode.alpha; if (shi->do_preview) - nodeAddToPreview(node, col, shi->xs, shi->ys, shi->do_manage); + BKE_node_preview_set_pixel(execdata->preview, col, shi->xs, shi->ys, shi->do_manage); copy_v3_v3(out[MAT_OUT_COLOR]->vec, col); out[MAT_OUT_ALPHA]->vec[0] = shrnode.alpha; @@ -208,7 +207,7 @@ static void node_shader_exec_material(void *data, bNode *node, bNodeStack **in, } -static void node_shader_init_material(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_material(bNodeTree *UNUSED(ntree), bNode *node) { node->custom1= SH_NODE_MAT_DIFF|SH_NODE_MAT_SPEC; } @@ -224,7 +223,7 @@ static GPUNodeLink *gpu_get_input_link(GPUNodeStack *in) return GPU_uniform(in->vec); } -static int gpu_shader_material(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_material(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (node->id) { GPUShadeInput shi; @@ -308,33 +307,33 @@ static int gpu_shader_material(GPUMaterial *mat, bNode *node, GPUNodeStack *in, return 0; } -void register_node_type_sh_material(bNodeTreeType *ttype) +void register_node_type_sh_material() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_MATERIAL, "Material", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW); + sh_node_type_base(&ntype, SH_NODE_MATERIAL, "Material", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW); node_type_compatibility(&ntype, NODE_OLD_SHADING); node_type_socket_templates(&ntype, sh_node_material_in, sh_node_material_out); node_type_size(&ntype, 120, 80, 240); node_type_init(&ntype, node_shader_init_material); - node_type_exec(&ntype, node_shader_exec_material); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_material); node_type_gpu(&ntype, gpu_shader_material); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } -void register_node_type_sh_material_ext(bNodeTreeType *ttype) +void register_node_type_sh_material_ext() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_MATERIAL_EXT, "Extended Material", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW); + sh_node_type_base(&ntype, SH_NODE_MATERIAL_EXT, "Extended Material", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW); node_type_compatibility(&ntype, NODE_OLD_SHADING); node_type_socket_templates(&ntype, sh_node_material_ext_in, sh_node_material_ext_out); node_type_size(&ntype, 120, 80, 240); node_type_init(&ntype, node_shader_init_material); - node_type_exec(&ntype, node_shader_exec_material); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_material); node_type_gpu(&ntype, gpu_shader_material); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_math.c b/source/blender/nodes/shader/nodes/node_shader_math.c index 0b71a3f13b4..08ba48176bb 100644 --- a/source/blender/nodes/shader/nodes/node_shader_math.c +++ b/source/blender/nodes/shader/nodes/node_shader_math.c @@ -45,8 +45,7 @@ static bNodeSocketTemplate sh_node_math_out[] = { { -1, 0, "" } }; -static void node_shader_exec_math(void *UNUSED(data), bNode *node, bNodeStack **in, -bNodeStack **out) +static void node_shader_exec_math(void *UNUSED(data), int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { switch (node->custom1) { @@ -207,7 +206,7 @@ bNodeStack **out) } } -static int gpu_shader_math(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_math(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { static const char *names[] = {"math_add", "math_subtract", "math_multiply", "math_divide", "math_sine", "math_cosine", "math_tangent", "math_asin", @@ -256,18 +255,18 @@ static int gpu_shader_math(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUN return 1; } -void register_node_type_sh_math(bNodeTreeType *ttype) +void register_node_type_sh_math() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_math_in, sh_node_math_out); node_type_size(&ntype, 120, 110, 160); node_type_label(&ntype, node_math_label); node_type_storage(&ntype, "node_math", NULL, NULL); - node_type_exec(&ntype, node_shader_exec_math); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_math); node_type_gpu(&ntype, gpu_shader_math); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_mixRgb.c b/source/blender/nodes/shader/nodes/node_shader_mixRgb.c index 18dcc8f7fef..2bbdf91dc65 100644 --- a/source/blender/nodes/shader/nodes/node_shader_mixRgb.c +++ b/source/blender/nodes/shader/nodes/node_shader_mixRgb.c @@ -44,7 +44,7 @@ static bNodeSocketTemplate sh_node_mix_rgb_out[] = { { -1, 0, "" } }; -static void node_shader_exec_mix_rgb(void *UNUSED(data), bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_mix_rgb(void *UNUSED(data), int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { /* stack order in: fac, col1, col2 */ /* stack order out: col */ @@ -62,7 +62,7 @@ static void node_shader_exec_mix_rgb(void *UNUSED(data), bNode *node, bNodeStack copy_v3_v3(out[0]->vec, col); } -static int gpu_shader_mix_rgb(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_mix_rgb(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { static const char *names[] = {"mix_blend", "mix_add", "mix_mult", "mix_sub", "mix_screen", "mix_div", "mix_diff", "mix_dark", "mix_light", @@ -73,17 +73,17 @@ static int gpu_shader_mix_rgb(GPUMaterial *mat, bNode *node, GPUNodeStack *in, G } -void register_node_type_sh_mix_rgb(bNodeTreeType *ttype) +void register_node_type_sh_mix_rgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_mix_rgb_in, sh_node_mix_rgb_out); node_type_size(&ntype, 100, 60, 150); node_type_label(&ntype, node_blend_label); - node_type_exec(&ntype, node_shader_exec_mix_rgb); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_mix_rgb); node_type_gpu(&ntype, gpu_shader_mix_rgb); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_mix_shader.c b/source/blender/nodes/shader/nodes/node_shader_mix_shader.c index 039e63a4dea..56178a8ddbe 100644 --- a/source/blender/nodes/shader/nodes/node_shader_mix_shader.c +++ b/source/blender/nodes/shader/nodes/node_shader_mix_shader.c @@ -41,24 +41,23 @@ static bNodeSocketTemplate sh_node_mix_shader_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_mix_shader(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_mix_shader(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_mix_shader", in, out); } /* node type definition */ -void register_node_type_sh_mix_shader(bNodeTreeType *ttype) +void register_node_type_sh_mix_shader() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_MIX_SHADER, "Mix Shader", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_MIX_SHADER, "Mix Shader", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_mix_shader_in, sh_node_mix_shader_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_mix_shader); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_normal.c b/source/blender/nodes/shader/nodes/node_shader_normal.c index 0ad58d6af76..a1f00ee0c33 100644 --- a/source/blender/nodes/shader/nodes/node_shader_normal.c +++ b/source/blender/nodes/shader/nodes/node_shader_normal.c @@ -39,26 +39,14 @@ static bNodeSocketTemplate sh_node_normal_in[] = { }; static bNodeSocketTemplate sh_node_normal_out[] = { - { SOCK_VECTOR, 0, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_DIRECTION}, + { SOCK_VECTOR, 0, N_("Normal"), 0.0f, 0.0f, 1.0f, 0.0f, -1.0f, 1.0f, PROP_DIRECTION}, { SOCK_FLOAT, 0, N_("Dot")}, { -1, 0, "" } }; -static void node_shader_init_normal(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) -{ - bNodeSocket *sock= node->outputs.first; - bNodeSocketValueVector *dval= (bNodeSocketValueVector*)sock->default_value; - - /* output value is used for normal vector */ - dval->value[0] = 0.0f; - dval->value[1] = 0.0f; - dval->value[2] = 1.0f; -} - /* generates normal, does dot product */ -static void node_shader_exec_normal(void *UNUSED(data), bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_normal(void *UNUSED(data), int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { - bNodeSocket *sock= node->outputs.first; float vec[3]; /* stack order input: normal */ @@ -66,29 +54,25 @@ static void node_shader_exec_normal(void *UNUSED(data), bNode *node, bNodeStack nodestack_get_vec(vec, SOCK_VECTOR, in[0]); - copy_v3_v3(out[0]->vec, ((bNodeSocketValueVector*)sock->default_value)->value); /* render normals point inside... the widget points outside */ - out[1]->vec[0] = -dot_v3v3(out[0]->vec, vec); + out[1]->vec[0] = -dot_v3v3(vec, out[0]->vec); } -static int gpu_shader_normal(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_normal(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { - bNodeSocket *sock= node->outputs.first; - GPUNodeLink *vec = GPU_uniform(((bNodeSocketValueVector*)sock->default_value)->value); - + GPUNodeLink *vec = GPU_uniform(out[0].vec); return GPU_stack_link(mat, "normal", in, out, vec); } -void register_node_type_sh_normal(bNodeTreeType *ttype) +void register_node_type_sh_normal() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_NORMAL, "Normal", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_NORMAL, "Normal", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_normal_in, sh_node_normal_out); - node_type_init(&ntype, node_shader_init_normal); - node_type_exec(&ntype, node_shader_exec_normal); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_normal); node_type_gpu(&ntype, gpu_shader_normal); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_normal_map.c b/source/blender/nodes/shader/nodes/node_shader_normal_map.c index 6a4eb9d81df..bca1b0e2798 100644 --- a/source/blender/nodes/shader/nodes/node_shader_normal_map.c +++ b/source/blender/nodes/shader/nodes/node_shader_normal_map.c @@ -40,31 +40,30 @@ static bNodeSocketTemplate sh_node_normal_map_out[] = { { -1, 0, "" } }; -static void node_shader_init_normal_map(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_normal_map(bNodeTree *UNUSED(ntree), bNode *node) { NodeShaderNormalMap *attr = MEM_callocN(sizeof(NodeShaderNormalMap), "NodeShaderNormalMap"); node->storage = attr; } -static int gpu_shader_normal_map(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_normal_map(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_normal_map", in, out, GPU_builtin(GPU_VIEW_NORMAL)); } /* node type definition */ -void register_node_type_sh_normal_map(bNodeTreeType *ttype) +void register_node_type_sh_normal_map() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_NORMAL_MAP, "Normal Map", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_NORMAL_MAP, "Normal Map", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_normal_map_in, sh_node_normal_map_out); node_type_size(&ntype, 250, 60, 250); node_type_init(&ntype, node_shader_init_normal_map); node_type_storage(&ntype, "NodeShaderNormalMap", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, gpu_shader_normal_map); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_object_info.c b/source/blender/nodes/shader/nodes/node_shader_object_info.c index ef283004d46..d00037546ea 100644 --- a/source/blender/nodes/shader/nodes/node_shader_object_info.c +++ b/source/blender/nodes/shader/nodes/node_shader_object_info.c @@ -37,25 +37,24 @@ static bNodeSocketTemplate sh_node_object_info_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_object_info(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_object_info(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_object_info", in, out); } /* node type definition */ -void register_node_type_sh_object_info(bNodeTreeType *ttype) +void register_node_type_sh_object_info(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_OBJECT_INFO, "Object Info", NODE_CLASS_INPUT, 0); + sh_node_type_base(&ntype, SH_NODE_OBJECT_INFO, "Object Info", NODE_CLASS_INPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_object_info_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_object_info); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_output.c b/source/blender/nodes/shader/nodes/node_shader_output.c index 6f7f900aecd..4c2fdf146da 100644 --- a/source/blender/nodes/shader/nodes/node_shader_output.c +++ b/source/blender/nodes/shader/nodes/node_shader_output.c @@ -39,7 +39,7 @@ static bNodeSocketTemplate sh_node_output_in[] = { { -1, 0, "" } }; -static void node_shader_exec_output(void *data, bNode *node, bNodeStack **in, bNodeStack **UNUSED(out)) +static void node_shader_exec_output(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **UNUSED(out)) { if (data) { ShadeInput *shi= ((ShaderCallData *)data)->shi; @@ -50,7 +50,7 @@ static void node_shader_exec_output(void *data, bNode *node, bNodeStack **in, bN nodestack_get_vec(col+3, SOCK_FLOAT, in[1]); if (shi->do_preview) { - nodeAddToPreview(node, col, shi->xs, shi->ys, shi->do_manage); + BKE_node_preview_set_pixel(execdata->preview, col, shi->xs, shi->ys, shi->do_manage); node->lasty= shi->ys; } @@ -65,7 +65,7 @@ static void node_shader_exec_output(void *data, bNode *node, bNodeStack **in, bN } } -static int gpu_shader_output(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_output(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { GPUNodeLink *outlink; @@ -80,19 +80,19 @@ static int gpu_shader_output(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack return 1; } -void register_node_type_sh_output(bNodeTreeType *ttype) +void register_node_type_sh_output() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_OUTPUT, "Output", NODE_CLASS_OUTPUT, NODE_PREVIEW); + sh_node_type_base(&ntype, SH_NODE_OUTPUT, "Output", NODE_CLASS_OUTPUT, NODE_PREVIEW); node_type_compatibility(&ntype, NODE_OLD_SHADING); node_type_socket_templates(&ntype, sh_node_output_in, NULL); node_type_size(&ntype, 80, 60, 200); - node_type_exec(&ntype, node_shader_exec_output); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_output); node_type_gpu(&ntype, gpu_shader_output); /* Do not allow muting output node. */ node_type_internal_links(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_output_lamp.c b/source/blender/nodes/shader/nodes/node_shader_output_lamp.c index ce406a8f5a1..e44326428b5 100644 --- a/source/blender/nodes/shader/nodes/node_shader_output_lamp.c +++ b/source/blender/nodes/shader/nodes/node_shader_output_lamp.c @@ -35,21 +35,19 @@ static bNodeSocketTemplate sh_node_output_lamp_in[] = { }; /* node type definition */ -void register_node_type_sh_output_lamp(bNodeTreeType *ttype) +void register_node_type_sh_output_lamp() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_OUTPUT_LAMP, "Lamp Output", NODE_CLASS_OUTPUT, 0); + sh_node_type_base(&ntype, SH_NODE_OUTPUT_LAMP, "Lamp Output", NODE_CLASS_OUTPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_output_lamp_in, NULL); node_type_size(&ntype, 120, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); - node_type_gpu(&ntype, NULL); /* Do not allow muting output node. */ node_type_internal_links(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_output_material.c b/source/blender/nodes/shader/nodes/node_shader_output_material.c index f185e13010b..90030d6699b 100644 --- a/source/blender/nodes/shader/nodes/node_shader_output_material.c +++ b/source/blender/nodes/shader/nodes/node_shader_output_material.c @@ -36,7 +36,7 @@ static bNodeSocketTemplate sh_node_output_material_in[] = { { -1, 0, "" } }; -static int node_shader_gpu_output_material(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_output_material(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { GPUNodeLink *outlink; @@ -48,21 +48,20 @@ static int node_shader_gpu_output_material(GPUMaterial *mat, bNode *UNUSED(node) /* node type definition */ -void register_node_type_sh_output_material(bNodeTreeType *ttype) +void register_node_type_sh_output_material() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_OUTPUT_MATERIAL, "Material Output", NODE_CLASS_OUTPUT, 0); + sh_node_type_base(&ntype, SH_NODE_OUTPUT_MATERIAL, "Material Output", NODE_CLASS_OUTPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_output_material_in, NULL); node_type_size(&ntype, 120, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_output_material); /* Do not allow muting output node. */ node_type_internal_links(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_output_world.c b/source/blender/nodes/shader/nodes/node_shader_output_world.c index 953197ab2cd..e9a60bd34e3 100644 --- a/source/blender/nodes/shader/nodes/node_shader_output_world.c +++ b/source/blender/nodes/shader/nodes/node_shader_output_world.c @@ -36,21 +36,19 @@ static bNodeSocketTemplate sh_node_output_world_in[] = { }; /* node type definition */ -void register_node_type_sh_output_world(bNodeTreeType *ttype) +void register_node_type_sh_output_world() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_OUTPUT_WORLD, "World Output", NODE_CLASS_OUTPUT, 0); + sh_node_type_base(&ntype, SH_NODE_OUTPUT_WORLD, "World Output", NODE_CLASS_OUTPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_output_world_in, NULL); node_type_size(&ntype, 120, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); - node_type_gpu(&ntype, NULL); /* Do not allow muting output node. */ node_type_internal_links(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_particle_info.c b/source/blender/nodes/shader/nodes/node_shader_particle_info.c index c7e31d117cc..e4d91d524d2 100644 --- a/source/blender/nodes/shader/nodes/node_shader_particle_info.c +++ b/source/blender/nodes/shader/nodes/node_shader_particle_info.c @@ -42,15 +42,15 @@ static bNodeSocketTemplate outputs[] = { }; /* node type definition */ -void register_node_type_sh_particle_info(bNodeTreeType *ttype) +void register_node_type_sh_particle_info(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_PARTICLE_INFO, "Particle Info", NODE_CLASS_INPUT, 0); + sh_node_type_base(&ntype, SH_NODE_PARTICLE_INFO, "Particle Info", NODE_CLASS_INPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, outputs); node_type_size(&ntype, 150, 60, 200); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_rgb.c b/source/blender/nodes/shader/nodes/node_shader_rgb.c index f37ff1d511b..b3215fc6803 100644 --- a/source/blender/nodes/shader/nodes/node_shader_rgb.c +++ b/source/blender/nodes/shader/nodes/node_shader_rgb.c @@ -34,49 +34,25 @@ /* **************** RGB ******************** */ static bNodeSocketTemplate sh_node_rgb_out[] = { - { SOCK_RGBA, 0, N_("Color")}, + { SOCK_RGBA, 0, N_("Color"), 0.5f, 0.5f, 0.5f, 1.0f}, { -1, 0, "" } }; -static void node_shader_init_rgb(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static int gpu_shader_rgb(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { - bNodeSocket *sock= node->outputs.first; - bNodeSocketValueRGBA *dval= (bNodeSocketValueRGBA*)sock->default_value; - /* uses the default value of the output socket, must be initialized here */ - dval->value[0] = 0.5f; - dval->value[1] = 0.5f; - dval->value[2] = 0.5f; - dval->value[3] = 1.0f; -} - -static void node_shader_exec_rgb(void *UNUSED(data), bNode *node, bNodeStack **UNUSED(in), bNodeStack **out) -{ - bNodeSocket *sock= node->outputs.first; - float *col= ((bNodeSocketValueRGBA*)sock->default_value)->value; - - copy_v3_v3(out[0]->vec, col); -} - -static int gpu_shader_rgb(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) -{ - bNodeSocket *sock= node->outputs.first; - float *col= ((bNodeSocketValueRGBA*)sock->default_value)->value; - GPUNodeLink *vec = GPU_uniform(col); - + GPUNodeLink *vec = GPU_uniform(out[0].vec); return GPU_stack_link(mat, "set_rgba", in, out, vec); } -void register_node_type_sh_rgb(bNodeTreeType *ttype) +void register_node_type_sh_rgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_RGB, "RGB", NODE_CLASS_INPUT, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_RGB, "RGB", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_rgb_out); - node_type_init(&ntype, node_shader_init_rgb); node_type_size(&ntype, 140, 80, 140); - node_type_exec(&ntype, node_shader_exec_rgb); node_type_gpu(&ntype, gpu_shader_rgb); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_script.c b/source/blender/nodes/shader/nodes/node_shader_script.c index b5563658a64..8b4c2702474 100644 --- a/source/blender/nodes/shader/nodes/node_shader_script.c +++ b/source/blender/nodes/shader/nodes/node_shader_script.c @@ -35,7 +35,7 @@ /* **************** Script ******************** */ -static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void init(bNodeTree *UNUSED(ntree), bNode *node) { NodeShaderScript *nss = MEM_callocN(sizeof(NodeShaderScript), "shader script node"); node->storage = nss; @@ -50,37 +50,29 @@ static void node_free_script(bNode *node) MEM_freeN(nss->bytecode); } - if (nss->prop) { - IDP_FreeProperty(nss->prop); - MEM_freeN(nss->prop); - } - MEM_freeN(nss); } } -static void node_copy_script(bNode *orig_node, bNode *new_node) +static void node_copy_script(bNodeTree *UNUSED(dest_ntree), bNode *dest_node, bNode *src_node) { - NodeShaderScript *orig_nss = orig_node->storage; - NodeShaderScript *new_nss = MEM_dupallocN(orig_nss); - - if (orig_nss->bytecode) - new_nss->bytecode = MEM_dupallocN(orig_nss->bytecode); + NodeShaderScript *src_nss = src_node->storage; + NodeShaderScript *dest_nss = MEM_dupallocN(src_nss); - if (orig_nss->prop) - new_nss->prop = IDP_CopyProperty(orig_nss->prop); + if (src_nss->bytecode) + dest_nss->bytecode = MEM_dupallocN(src_nss->bytecode); - new_node->storage = new_nss; + dest_node->storage = dest_nss; } -void register_node_type_sh_script(bNodeTreeType *ttype) +void register_node_type_sh_script() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_SCRIPT, "Script", NODE_CLASS_SCRIPT, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_SCRIPT, "Script", NODE_CLASS_SCRIPT, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_init(&ntype, init); node_type_storage(&ntype, "NodeShaderScript", node_free_script, node_copy_script); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_sepcombRGB.c b/source/blender/nodes/shader/nodes/node_shader_sepcombRGB.c index 70fba161de9..1f6cd3506e9 100644 --- a/source/blender/nodes/shader/nodes/node_shader_sepcombRGB.c +++ b/source/blender/nodes/shader/nodes/node_shader_sepcombRGB.c @@ -44,30 +44,30 @@ static bNodeSocketTemplate sh_node_seprgb_out[] = { { -1, 0, "" } }; -static void node_shader_exec_seprgb(void *UNUSED(data), bNode *UNUSED(node), bNodeStack **in, bNodeStack **out) +static void node_shader_exec_seprgb(void *UNUSED(data), int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { out[0]->vec[0] = in[0]->vec[0]; out[1]->vec[0] = in[0]->vec[1]; out[2]->vec[0] = in[0]->vec[2]; } -static int gpu_shader_seprgb(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_seprgb(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "separate_rgb", in, out); } -void register_node_type_sh_seprgb(bNodeTreeType *ttype) +void register_node_type_sh_seprgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_SEPRGB, "Separate RGB", NODE_CLASS_CONVERTOR, 0); + sh_node_type_base(&ntype, SH_NODE_SEPRGB, "Separate RGB", NODE_CLASS_CONVERTOR, 0); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_seprgb_in, sh_node_seprgb_out); node_type_size(&ntype, 80, 40, 140); - node_type_exec(&ntype, node_shader_exec_seprgb); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_seprgb); node_type_gpu(&ntype, gpu_shader_seprgb); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -84,28 +84,28 @@ static bNodeSocketTemplate sh_node_combrgb_out[] = { { -1, 0, "" } }; -static void node_shader_exec_combrgb(void *UNUSED(data), bNode *UNUSED(node), bNodeStack **in, bNodeStack **out) +static void node_shader_exec_combrgb(void *UNUSED(data), int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { out[0]->vec[0] = in[0]->vec[0]; out[0]->vec[1] = in[1]->vec[0]; out[0]->vec[2] = in[2]->vec[0]; } -static int gpu_shader_combrgb(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_combrgb(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "combine_rgb", in, out); } -void register_node_type_sh_combrgb(bNodeTreeType *ttype) +void register_node_type_sh_combrgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_COMBRGB, "Combine RGB", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_COMBRGB, "Combine RGB", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_combrgb_in, sh_node_combrgb_out); node_type_size(&ntype, 80, 40, 140); - node_type_exec(&ntype, node_shader_exec_combrgb); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_combrgb); node_type_gpu(&ntype, gpu_shader_combrgb); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_squeeze.c b/source/blender/nodes/shader/nodes/node_shader_squeeze.c index 8073f4b01d2..538efb15cb3 100644 --- a/source/blender/nodes/shader/nodes/node_shader_squeeze.c +++ b/source/blender/nodes/shader/nodes/node_shader_squeeze.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate sh_node_squeeze_out[] = { { -1, 0, "" } }; -static void node_shader_exec_squeeze(void *UNUSED(data), bNode *UNUSED(node), bNodeStack **in, bNodeStack **out) +static void node_shader_exec_squeeze(void *UNUSED(data), int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { float vec[3]; @@ -56,22 +56,22 @@ static void node_shader_exec_squeeze(void *UNUSED(data), bNode *UNUSED(node), bN out[0]->vec[0] = 1.0f / (1.0f + powf(M_E, -((vec[0] - vec[2]) * vec[1]))); } -static int gpu_shader_squeeze(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_squeeze(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "squeeze", in, out); } -void register_node_type_sh_squeeze(bNodeTreeType *ttype) +void register_node_type_sh_squeeze() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_SQUEEZE, "Squeeze Value", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_SQUEEZE, "Squeeze Value", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING); node_type_socket_templates(&ntype, sh_node_squeeze_in, sh_node_squeeze_out); node_type_size(&ntype, 120, 110, 160); node_type_storage(&ntype, "node_squeeze", NULL, NULL); - node_type_exec(&ntype, node_shader_exec_squeeze); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_squeeze); node_type_gpu(&ntype, gpu_shader_squeeze); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tangent.c b/source/blender/nodes/shader/nodes/node_shader_tangent.c index 6c0d6d7cd9f..a51c943285b 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tangent.c +++ b/source/blender/nodes/shader/nodes/node_shader_tangent.c @@ -34,7 +34,7 @@ static bNodeSocketTemplate sh_node_tangent_out[] = { { -1, 0, "" } }; -static void node_shader_init_tangent(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tangent(bNodeTree *UNUSED(ntree), bNode *node) { NodeShaderTangent *attr = MEM_callocN(sizeof(NodeShaderTangent), "NodeShaderTangent"); attr->axis = SHD_TANGENT_AXIS_Z; @@ -42,19 +42,16 @@ static void node_shader_init_tangent(bNodeTree *UNUSED(ntree), bNode *node, bNod } /* node type definition */ -void register_node_type_sh_tangent(bNodeTreeType *ttype) +void register_node_type_sh_tangent() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TANGENT, "Tangent", NODE_CLASS_INPUT, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TANGENT, "Tangent", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_tangent_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tangent); node_type_storage(&ntype, "NodeShaderTangent", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); - node_type_gpu(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } - diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_brick.c b/source/blender/nodes/shader/nodes/node_shader_tex_brick.c index 66bf0267586..dad74d324f8 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_brick.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_brick.c @@ -48,7 +48,7 @@ static bNodeSocketTemplate sh_node_tex_brick_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_brick(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_brick(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexBrick *tex = MEM_callocN(sizeof(NodeTexBrick), "NodeTexBrick"); default_tex_mapping(&tex->base.tex_mapping); @@ -62,7 +62,7 @@ static void node_shader_init_tex_brick(bNodeTree *UNUSED(ntree), bNode* node, bN node->storage = tex; } -static int node_shader_gpu_tex_brick(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_brick(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[0].link) in[0].link = GPU_attribute(CD_ORCO, ""); @@ -73,18 +73,17 @@ static int node_shader_gpu_tex_brick(GPUMaterial *mat, bNode *node, GPUNodeStack } /* node type definition */ -void register_node_type_sh_tex_brick(bNodeTreeType *ttype) +void register_node_type_sh_tex_brick(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_BRICK, "Brick Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_BRICK, "Brick Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_brick_in, sh_node_tex_brick_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_brick); node_type_storage(&ntype, "NodeTexBrick", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_brick); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_checker.c b/source/blender/nodes/shader/nodes/node_shader_tex_checker.c index 8a2ae2d40dc..aff92e58f90 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_checker.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_checker.c @@ -43,7 +43,7 @@ static bNodeSocketTemplate sh_node_tex_checker_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_checker(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_checker(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexChecker *tex = MEM_callocN(sizeof(NodeTexChecker), "NodeTexChecker"); default_tex_mapping(&tex->base.tex_mapping); @@ -52,7 +52,7 @@ static void node_shader_init_tex_checker(bNodeTree *UNUSED(ntree), bNode *node, node->storage = tex; } -static int node_shader_gpu_tex_checker(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_checker(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[0].link) in[0].link = GPU_attribute(CD_ORCO, ""); @@ -63,18 +63,17 @@ static int node_shader_gpu_tex_checker(GPUMaterial *mat, bNode *node, GPUNodeSta } /* node type definition */ -void register_node_type_sh_tex_checker(bNodeTreeType *ttype) +void register_node_type_sh_tex_checker() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_CHECKER, "Checker Texture", NODE_CLASS_TEXTURE, 0); + sh_node_type_base(&ntype, SH_NODE_TEX_CHECKER, "Checker Texture", NODE_CLASS_TEXTURE, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_checker_in, sh_node_tex_checker_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_checker); node_type_storage(&ntype, "NodeTexChecker", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_checker); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_coord.c b/source/blender/nodes/shader/nodes/node_shader_tex_coord.c index dd717874951..d2b69aebf96 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_coord.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_coord.c @@ -42,7 +42,7 @@ static bNodeSocketTemplate sh_node_tex_coord_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_tex_coord(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_coord(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { GPUNodeLink *orco = GPU_attribute(CD_ORCO, ""); GPUNodeLink *mtface = GPU_attribute(CD_MTFACE, ""); @@ -53,18 +53,17 @@ static int node_shader_gpu_tex_coord(GPUMaterial *mat, bNode *UNUSED(node), GPUN } /* node type definition */ -void register_node_type_sh_tex_coord(bNodeTreeType *ttype) +void register_node_type_sh_tex_coord() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_COORD, "Texture Coordinate", NODE_CLASS_INPUT, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_COORD, "Texture Coordinate", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_tex_coord_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_coord); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_environment.c b/source/blender/nodes/shader/nodes/node_shader_tex_environment.c index d2d0870e2ed..25cc892c944 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_environment.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_environment.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate sh_node_tex_environment_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_environment(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_environment(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexEnvironment *tex = MEM_callocN(sizeof(NodeTexEnvironment), "NodeTexEnvironment"); default_tex_mapping(&tex->base.tex_mapping); @@ -56,7 +56,7 @@ static void node_shader_init_tex_environment(bNodeTree *UNUSED(ntree), bNode *no node->storage = tex; } -static int node_shader_gpu_tex_environment(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_environment(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { Image *ima= (Image*)node->id; ImageUser *iuser= NULL; @@ -88,18 +88,17 @@ static int node_shader_gpu_tex_environment(GPUMaterial *mat, bNode *node, GPUNod } /* node type definition */ -void register_node_type_sh_tex_environment(bNodeTreeType *ttype) +void register_node_type_sh_tex_environment() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_ENVIRONMENT, "Environment Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_ENVIRONMENT, "Environment Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_environment_in, sh_node_tex_environment_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_environment); node_type_storage(&ntype, "NodeTexEnvironment", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_environment); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_gradient.c b/source/blender/nodes/shader/nodes/node_shader_tex_gradient.c index 0802ecdea1d..ab962c946f2 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_gradient.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_gradient.c @@ -40,7 +40,7 @@ static bNodeSocketTemplate sh_node_tex_gradient_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_gradient(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_gradient(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexGradient *tex = MEM_callocN(sizeof(NodeTexGradient), "NodeTexGradient"); default_tex_mapping(&tex->base.tex_mapping); @@ -50,7 +50,7 @@ static void node_shader_init_tex_gradient(bNodeTree *UNUSED(ntree), bNode *node, node->storage = tex; } -static int node_shader_gpu_tex_gradient(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_gradient(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[0].link) in[0].link = GPU_attribute(CD_ORCO, ""); @@ -61,18 +61,17 @@ static int node_shader_gpu_tex_gradient(GPUMaterial *mat, bNode *node, GPUNodeSt } /* node type definition */ -void register_node_type_sh_tex_gradient(bNodeTreeType *ttype) +void register_node_type_sh_tex_gradient() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_GRADIENT, "Gradient Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_GRADIENT, "Gradient Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_gradient_in, sh_node_tex_gradient_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_gradient); node_type_storage(&ntype, "NodeTexGradient", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_gradient); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_image.c b/source/blender/nodes/shader/nodes/node_shader_tex_image.c index 49b38434246..a30acd80712 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_image.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_image.c @@ -42,7 +42,7 @@ static bNodeSocketTemplate sh_node_tex_image_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_image(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_image(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexImage *tex = MEM_callocN(sizeof(NodeTexImage), "NodeTexImage"); default_tex_mapping(&tex->base.tex_mapping); @@ -56,7 +56,7 @@ static void node_shader_init_tex_image(bNodeTree *UNUSED(ntree), bNode *node, bN node->storage = tex; } -static int node_shader_gpu_tex_image(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_image(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { Image *ima= (Image*)node->id; ImageUser *iuser= NULL; @@ -88,18 +88,17 @@ static int node_shader_gpu_tex_image(GPUMaterial *mat, bNode *node, GPUNodeStack } /* node type definition */ -void register_node_type_sh_tex_image(bNodeTreeType *ttype) +void register_node_type_sh_tex_image() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_IMAGE, "Image Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_IMAGE, "Image Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_image_in, sh_node_tex_image_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_image); node_type_storage(&ntype, "NodeTexImage", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_image); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_magic.c b/source/blender/nodes/shader/nodes/node_shader_tex_magic.c index 86feabbcc2b..8d32cac9dab 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_magic.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_magic.c @@ -42,7 +42,7 @@ static bNodeSocketTemplate sh_node_tex_magic_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_magic(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_magic(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexMagic *tex = MEM_callocN(sizeof(NodeTexMagic), "NodeTexMagic"); default_tex_mapping(&tex->base.tex_mapping); @@ -52,7 +52,7 @@ static void node_shader_init_tex_magic(bNodeTree *UNUSED(ntree), bNode *node, bN node->storage = tex; } -static int node_shader_gpu_tex_magic(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_magic(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { NodeTexMagic *tex = (NodeTexMagic*)node->storage; float depth = tex->depth; @@ -66,18 +66,17 @@ static int node_shader_gpu_tex_magic(GPUMaterial *mat, bNode *node, GPUNodeStack } /* node type definition */ -void register_node_type_sh_tex_magic(bNodeTreeType *ttype) +void register_node_type_sh_tex_magic() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_MAGIC, "Magic Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_MAGIC, "Magic Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_magic_in, sh_node_tex_magic_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_magic); node_type_storage(&ntype, "NodeTexMagic", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_magic); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c b/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c index cd4b5743e14..d4f7c9d0c1c 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c @@ -46,7 +46,7 @@ static bNodeSocketTemplate sh_node_tex_musgrave_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_musgrave(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_musgrave(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexMusgrave *tex = MEM_callocN(sizeof(NodeTexMusgrave), "NodeTexMusgrave"); default_tex_mapping(&tex->base.tex_mapping); @@ -56,7 +56,7 @@ static void node_shader_init_tex_musgrave(bNodeTree *UNUSED(ntree), bNode *node, node->storage = tex; } -static int node_shader_gpu_tex_musgrave(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_musgrave(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[0].link) in[0].link = GPU_attribute(CD_ORCO, ""); @@ -67,18 +67,17 @@ static int node_shader_gpu_tex_musgrave(GPUMaterial *mat, bNode *node, GPUNodeSt } /* node type definition */ -void register_node_type_sh_tex_musgrave(bNodeTreeType *ttype) +void register_node_type_sh_tex_musgrave() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_MUSGRAVE, "Musgrave Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_MUSGRAVE, "Musgrave Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_musgrave_in, sh_node_tex_musgrave_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_musgrave); node_type_storage(&ntype, "NodeTexMusgrave", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_musgrave); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_noise.c b/source/blender/nodes/shader/nodes/node_shader_tex_noise.c index 18788f9e72c..0143645f448 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_noise.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_noise.c @@ -43,7 +43,7 @@ static bNodeSocketTemplate sh_node_tex_noise_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_noise(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_noise(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexNoise *tex = MEM_callocN(sizeof(NodeTexNoise), "NodeTexNoise"); default_tex_mapping(&tex->base.tex_mapping); @@ -52,7 +52,7 @@ static void node_shader_init_tex_noise(bNodeTree *UNUSED(ntree), bNode *node, bN node->storage = tex; } -static int node_shader_gpu_tex_noise(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_noise(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[0].link) in[0].link = GPU_attribute(CD_ORCO, ""); @@ -63,18 +63,17 @@ static int node_shader_gpu_tex_noise(GPUMaterial *mat, bNode *node, GPUNodeStack } /* node type definition */ -void register_node_type_sh_tex_noise(bNodeTreeType *ttype) +void register_node_type_sh_tex_noise() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_NOISE, "Noise Texture", NODE_CLASS_TEXTURE, 0); + sh_node_type_base(&ntype, SH_NODE_TEX_NOISE, "Noise Texture", NODE_CLASS_TEXTURE, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_noise_in, sh_node_tex_noise_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_noise); node_type_storage(&ntype, "NodeTexNoise", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_noise); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_sky.c b/source/blender/nodes/shader/nodes/node_shader_tex_sky.c index 7a1b853a7f4..2aa977bade6 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_sky.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_sky.c @@ -39,7 +39,7 @@ static bNodeSocketTemplate sh_node_tex_sky_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_sky(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_sky(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexSky *tex = MEM_callocN(sizeof(NodeTexSky), "NodeTexSky"); default_tex_mapping(&tex->base.tex_mapping); @@ -52,7 +52,7 @@ static void node_shader_init_tex_sky(bNodeTree *UNUSED(ntree), bNode *node, bNod node->storage = tex; } -static int node_shader_gpu_tex_sky(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_sky(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[0].link) in[0].link = GPU_attribute(CD_ORCO, ""); @@ -63,18 +63,17 @@ static int node_shader_gpu_tex_sky(GPUMaterial *mat, bNode *node, GPUNodeStack * } /* node type definition */ -void register_node_type_sh_tex_sky(bNodeTreeType *ttype) +void register_node_type_sh_tex_sky() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_SKY, "Sky Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_SKY, "Sky Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_sky_in, sh_node_tex_sky_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_sky); node_type_storage(&ntype, "NodeTexSky", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_sky); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.c b/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.c index d4cc24687b3..cf7d775914e 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate sh_node_tex_voronoi_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_voronoi(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_voronoi(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexVoronoi *tex = MEM_callocN(sizeof(NodeTexVoronoi), "NodeTexVoronoi"); default_tex_mapping(&tex->base.tex_mapping); @@ -51,7 +51,7 @@ static void node_shader_init_tex_voronoi(bNodeTree *UNUSED(ntree), bNode *node, node->storage = tex; } -static int node_shader_gpu_tex_voronoi(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_voronoi(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[0].link) in[0].link = GPU_attribute(CD_ORCO, ""); @@ -62,18 +62,17 @@ static int node_shader_gpu_tex_voronoi(GPUMaterial *mat, bNode *node, GPUNodeSta } /* node type definition */ -void register_node_type_sh_tex_voronoi(bNodeTreeType *ttype) +void register_node_type_sh_tex_voronoi() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_VORONOI, "Voronoi Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_VORONOI, "Voronoi Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_voronoi_in, sh_node_tex_voronoi_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_voronoi); node_type_storage(&ntype, "NodeTexVoronoi", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_voronoi); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_wave.c b/source/blender/nodes/shader/nodes/node_shader_tex_wave.c index 8b23de0310c..2f085df8d07 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_wave.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_wave.c @@ -44,7 +44,7 @@ static bNodeSocketTemplate sh_node_tex_wave_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_wave(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_wave(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexWave *tex = MEM_callocN(sizeof(NodeTexWave), "NodeTexWave"); default_tex_mapping(&tex->base.tex_mapping); @@ -54,7 +54,7 @@ static void node_shader_init_tex_wave(bNodeTree *UNUSED(ntree), bNode *node, bNo node->storage = tex; } -static int node_shader_gpu_tex_wave(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_wave(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[0].link) in[0].link = GPU_attribute(CD_ORCO, ""); @@ -65,18 +65,17 @@ static int node_shader_gpu_tex_wave(GPUMaterial *mat, bNode *node, GPUNodeStack } /* node type definition */ -void register_node_type_sh_tex_wave(bNodeTreeType *ttype) +void register_node_type_sh_tex_wave() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_WAVE, "Wave Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_WAVE, "Wave Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_wave_in, sh_node_tex_wave_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_wave); node_type_storage(&ntype, "NodeTexWave", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_wave); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_texture.c b/source/blender/nodes/shader/nodes/node_shader_texture.c index ec238b62408..4f6cc574be3 100644 --- a/source/blender/nodes/shader/nodes/node_shader_texture.c +++ b/source/blender/nodes/shader/nodes/node_shader_texture.c @@ -48,7 +48,7 @@ static bNodeSocketTemplate sh_node_texture_out[] = { { -1, 0, "" } }; -static void node_shader_exec_texture(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_texture(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { if (data && node->id) { ShadeInput *shi= ((ShaderCallData *)data)->shi; @@ -113,13 +113,14 @@ static void node_shader_exec_texture(void *data, bNode *node, bNodeStack **in, b copy_v3_v3(out[2]->vec, nor); - if (shi->do_preview) - nodeAddToPreview(node, out[1]->vec, shi->xs, shi->ys, shi->do_manage); + if (shi->do_preview) { + BKE_node_preview_set_pixel(execdata->preview, out[1]->vec, shi->xs, shi->ys, shi->do_manage); + } } } -static int gpu_shader_texture(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_texture(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { Tex *tex = (Tex*)node->id; @@ -143,16 +144,16 @@ static int gpu_shader_texture(GPUMaterial *mat, bNode *node, GPUNodeStack *in, G return 0; } -void register_node_type_sh_texture(bNodeTreeType *ttype) +void register_node_type_sh_texture() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW); + sh_node_type_base(&ntype, SH_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW); node_type_compatibility(&ntype, NODE_OLD_SHADING); node_type_socket_templates(&ntype, sh_node_texture_in, sh_node_texture_out); node_type_size(&ntype, 120, 80, 240); - node_type_exec(&ntype, node_shader_exec_texture); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_texture); node_type_gpu(&ntype, gpu_shader_texture); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_valToRgb.c b/source/blender/nodes/shader/nodes/node_shader_valToRgb.c index 182487d343e..e70ac6b700e 100644 --- a/source/blender/nodes/shader/nodes/node_shader_valToRgb.c +++ b/source/blender/nodes/shader/nodes/node_shader_valToRgb.c @@ -43,7 +43,7 @@ static bNodeSocketTemplate sh_node_valtorgb_out[] = { { -1, 0, "" } }; -static void node_shader_exec_valtorgb(void *UNUSED(data), bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_valtorgb(void *UNUSED(data), int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { /* stack order in: fac */ /* stack order out: col, alpha */ @@ -57,12 +57,12 @@ static void node_shader_exec_valtorgb(void *UNUSED(data), bNode *node, bNodeStac } } -static void node_shader_init_valtorgb(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_valtorgb(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= add_colorband(1); } -static int gpu_shader_valtorgb(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_valtorgb(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { float *array; int size; @@ -71,20 +71,20 @@ static int gpu_shader_valtorgb(GPUMaterial *mat, bNode *node, GPUNodeStack *in, return GPU_stack_link(mat, "valtorgb", in, out, GPU_texture(size, array)); } -void register_node_type_sh_valtorgb(bNodeTreeType *ttype) +void register_node_type_sh_valtorgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_valtorgb_in, sh_node_valtorgb_out); node_type_size(&ntype, 240, 200, 300); node_type_init(&ntype, node_shader_init_valtorgb); node_type_storage(&ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, node_shader_exec_valtorgb); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_valtorgb); node_type_gpu(&ntype, gpu_shader_valtorgb); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -99,7 +99,7 @@ static bNodeSocketTemplate sh_node_rgbtobw_out[] = { }; -static void node_shader_exec_rgbtobw(void *UNUSED(data), bNode *UNUSED(node), bNodeStack **in, bNodeStack **out) +static void node_shader_exec_rgbtobw(void *UNUSED(data), int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { /* stack order out: bw */ /* stack order in: col */ @@ -107,21 +107,21 @@ static void node_shader_exec_rgbtobw(void *UNUSED(data), bNode *UNUSED(node), bN out[0]->vec[0] = rgb_to_bw(in[0]->vec); } -static int gpu_shader_rgbtobw(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_rgbtobw(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "rgbtobw", in, out); } -void register_node_type_sh_rgbtobw(bNodeTreeType *ttype) +void register_node_type_sh_rgbtobw() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTOR, 0); + sh_node_type_base(&ntype, SH_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTOR, 0); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_rgbtobw_in, sh_node_rgbtobw_out); node_type_size(&ntype, 80, 40, 120); - node_type_exec(&ntype, node_shader_exec_rgbtobw); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_rgbtobw); node_type_gpu(&ntype, gpu_shader_rgbtobw); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_value.c b/source/blender/nodes/shader/nodes/node_shader_value.c index a3d1e5afec2..00a23283a14 100644 --- a/source/blender/nodes/shader/nodes/node_shader_value.c +++ b/source/blender/nodes/shader/nodes/node_shader_value.c @@ -34,49 +34,25 @@ /* **************** VALUE ******************** */ static bNodeSocketTemplate sh_node_value_out[] = { - /* XXX value nodes use the output sockets for buttons, so we need explicit limits here! */ - { SOCK_FLOAT, 0, N_("Value"), 0.0f, 0.0f, 0.0f, 0.0f, -FLT_MAX, FLT_MAX}, + { SOCK_FLOAT, 0, N_("Value"), 0.5f, 0, 0, 0, -FLT_MAX, FLT_MAX, PROP_NONE}, { -1, 0, "" } }; -static void node_shader_init_value(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static int gpu_shader_value(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { - bNodeSocket *sock= node->outputs.first; - bNodeSocketValueFloat *dval= (bNodeSocketValueFloat*)sock->default_value; - /* uses the default value of the output socket, must be initialized here */ - dval->value = 0.5f; - dval->min = -FLT_MAX; - dval->max = FLT_MAX; -} - -static void node_shader_exec_value(void *UNUSED(data), bNode *node, bNodeStack **UNUSED(in), bNodeStack **out) -{ - bNodeSocket *sock= node->outputs.first; - float val= ((bNodeSocketValueFloat*)sock->default_value)->value; - - out[0]->vec[0] = val; -} - -static int gpu_shader_value(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) -{ - bNodeSocket *sock= node->outputs.first; - float *val= &((bNodeSocketValueFloat*)sock->default_value)->value; - GPUNodeLink *vec = GPU_uniform(val); - + GPUNodeLink *vec = GPU_uniform(out[0].vec); return GPU_stack_link(mat, "set_value", in, out, vec); } -void register_node_type_sh_value(bNodeTreeType *ttype) +void register_node_type_sh_value() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_VALUE, "Value", NODE_CLASS_INPUT, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_VALUE, "Value", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_value_out); - node_type_init(&ntype, node_shader_init_value); node_type_size(&ntype, 80, 50, 120); - node_type_exec(&ntype, node_shader_exec_value); node_type_gpu(&ntype, gpu_shader_value); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_vectMath.c b/source/blender/nodes/shader/nodes/node_shader_vectMath.c index 3e00421ddf0..7a76f408916 100644 --- a/source/blender/nodes/shader/nodes/node_shader_vectMath.c +++ b/source/blender/nodes/shader/nodes/node_shader_vectMath.c @@ -47,7 +47,7 @@ static bNodeSocketTemplate sh_node_vect_math_out[] = { { -1, 0, "" } }; -static void node_shader_exec_vect_math(void *UNUSED(data), bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_vect_math(void *UNUSED(data), int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { float vec1[3], vec2[3]; @@ -102,7 +102,7 @@ static void node_shader_exec_vect_math(void *UNUSED(data), bNode *node, bNodeSta } -static int gpu_shader_vect_math(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_vect_math(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { static const char *names[] = {"vec_math_add", "vec_math_sub", "vec_math_average", "vec_math_dot", "vec_math_cross", @@ -139,18 +139,18 @@ static int gpu_shader_vect_math(GPUMaterial *mat, bNode *node, GPUNodeStack *in, return 1; } -void register_node_type_sh_vect_math(bNodeTreeType *ttype) +void register_node_type_sh_vect_math() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_VECT_MATH, "Vector Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_VECT_MATH, "Vector Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_vect_math_in, sh_node_vect_math_out); node_type_size(&ntype, 80, 75, 140); node_type_label(&ntype, node_vect_math_label); node_type_storage(&ntype, "node_vect_math", NULL, NULL); - node_type_exec(&ntype, node_shader_exec_vect_math); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_vect_math); node_type_gpu(&ntype, gpu_shader_vect_math); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_volume_isotropic.c b/source/blender/nodes/shader/nodes/node_shader_volume_isotropic.c index 5451eb303cc..5ce62e2e15b 100644 --- a/source/blender/nodes/shader/nodes/node_shader_volume_isotropic.c +++ b/source/blender/nodes/shader/nodes/node_shader_volume_isotropic.c @@ -40,24 +40,23 @@ static bNodeSocketTemplate sh_node_volume_isotropic_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_volume_isotropic(GPUMaterial *UNUSED(mat), bNode *UNUSED(node), GPUNodeStack *UNUSED(in), GPUNodeStack *UNUSED(out)) +static int node_shader_gpu_volume_isotropic(GPUMaterial *UNUSED(mat), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *UNUSED(in), GPUNodeStack *UNUSED(out)) { return 0; } /* node type definition */ -void register_node_type_sh_volume_isotropic(bNodeTreeType *ttype) +void register_node_type_sh_volume_isotropic() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_VOLUME_ISOTROPIC, "Isotropic Volume", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_VOLUME_ISOTROPIC, "Isotropic Volume", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_volume_isotropic_in, sh_node_volume_isotropic_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_volume_isotropic); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_volume_transparent.c b/source/blender/nodes/shader/nodes/node_shader_volume_transparent.c index ad7d7fceda3..cd4ad5d0080 100644 --- a/source/blender/nodes/shader/nodes/node_shader_volume_transparent.c +++ b/source/blender/nodes/shader/nodes/node_shader_volume_transparent.c @@ -40,24 +40,23 @@ static bNodeSocketTemplate sh_node_volume_transparent_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_volume_transparent(GPUMaterial *UNUSED(mat), bNode *UNUSED(node), GPUNodeStack *UNUSED(in), GPUNodeStack *UNUSED(out)) +static int node_shader_gpu_volume_transparent(GPUMaterial *UNUSED(mat), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *UNUSED(in), GPUNodeStack *UNUSED(out)) { return 0; } /* node type definition */ -void register_node_type_sh_volume_transparent(bNodeTreeType *ttype) +void register_node_type_sh_volume_transparent() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_VOLUME_TRANSPARENT, "Transparent Volume", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_VOLUME_TRANSPARENT, "Transparent Volume", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_volume_transparent_in, sh_node_volume_transparent_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_volume_transparent); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/node_texture_tree.c b/source/blender/nodes/texture/node_texture_tree.c index ba94531c259..0690ccdd19f 100644 --- a/source/blender/nodes/texture/node_texture_tree.c +++ b/source/blender/nodes/texture/node_texture_tree.c @@ -34,6 +34,7 @@ #include "DNA_texture_types.h" #include "DNA_node_types.h" +#include "DNA_space_types.h" #include "BLI_listbase.h" #include "BLI_threads.h" @@ -41,9 +42,11 @@ #include "BLF_translation.h" +#include "BKE_context.h" #include "BKE_global.h" #include "BKE_main.h" #include "BKE_node.h" +#include "BKE_paint.h" #include "node_common.h" #include "node_exec.h" @@ -51,16 +54,57 @@ #include "NOD_texture.h" #include "node_texture_util.h" +#include "RNA_access.h" + #include "RE_pipeline.h" #include "RE_shader_ext.h" -static void foreach_nodetree(Main *main, void *calldata, bNodeTreeCallback func) +static void texture_get_from_context(const bContext *C, bNodeTreeType *UNUSED(treetype), bNodeTree **r_ntree, ID **r_id, ID **r_from) { - Tex *tx; - for (tx = main->tex.first; tx; tx = tx->id.next) { - if (tx->nodetree) { - func(calldata, &tx->id, tx->nodetree); + SpaceNode *snode = CTX_wm_space_node(C); + Scene *scene = CTX_data_scene(C); + Object *ob = OBACT; + Tex *tx = NULL; + + if (snode->texfrom == SNODE_TEX_OBJECT) { + if (ob) { + tx = give_current_object_texture(ob); + if (tx) { + if (ob->type == OB_LAMP) + *r_from = (ID*)ob->data; + else + *r_from = (ID*)give_current_material(ob, ob->actcol); + + /* from is not set fully for material nodes, should be ID + Node then */ + *r_id = &tx->id; + *r_ntree = tx->nodetree; + } + } + } + else if (snode->texfrom == SNODE_TEX_WORLD) { + tx = give_current_world_texture(scene->world); + if (tx) { + *r_from = (ID *)scene->world; + *r_id = &tx->id; + *r_ntree = tx->nodetree; + } + } + else { + struct Brush *brush = NULL; + + if (ob && (ob->mode & OB_MODE_SCULPT)) + brush = paint_brush(&scene->toolsettings->sculpt->paint); + else + brush = paint_brush(&scene->toolsettings->imapaint.paint); + + if (brush) { + *r_from = (ID *)brush; + tx = give_current_brush_texture(brush); + if (tx) { + *r_id = &tx->id; + *r_ntree = tx->nodetree; + } } } } @@ -75,6 +119,7 @@ static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCa func(calldata, NODE_CLASS_CONVERTOR, N_("Convertor")); func(calldata, NODE_CLASS_DISTORT, N_("Distort")); func(calldata, NODE_CLASS_GROUP, N_("Group")); + func(calldata, NODE_CLASS_INTERFACE, N_("Interface")); func(calldata, NODE_CLASS_LAYOUT, N_("Layout")); } @@ -93,49 +138,42 @@ static void localize(bNodeTree *localtree, bNodeTree *UNUSED(ntree)) } } -static void local_sync(bNodeTree *localtree, bNodeTree *ntree) +static void local_sync(bNodeTree *UNUSED(localtree), bNodeTree *UNUSED(ntree)) { - bNode *lnode; - - /* copy over contents of previews */ - for (lnode = localtree->nodes.first; lnode; lnode = lnode->next) { - if (ntreeNodeExists(ntree, lnode->new_node)) { - bNode *node = lnode->new_node; - - if (node->preview && node->preview->rect) { - if (lnode->preview && lnode->preview->rect) { - int xsize = node->preview->xsize; - int ysize = node->preview->ysize; - memcpy(node->preview->rect, lnode->preview->rect, 4 * xsize + xsize * ysize * sizeof(char) * 4); - } - } - } - } } static void update(bNodeTree *ntree) { ntree_update_reroute_nodes(ntree); + + if (ntree->update & NTREE_UPDATE_NODES) { + /* clean up preview cache, in case nodes have been removed */ + BKE_node_preview_remove_unused(ntree); + } } -bNodeTreeType ntreeType_Texture = { - /* type */ NTREE_TEXTURE, - /* id_name */ "NTTexture Nodetree", +bNodeTreeType *ntreeType_Texture; + +void register_node_tree_type_tex() +{ + bNodeTreeType *tt = ntreeType_Texture = MEM_callocN(sizeof(bNodeTreeType), "texture node tree type"); - /* node_types */ { NULL, NULL }, + tt->type = NTREE_TEXTURE; + strcpy(tt->idname, "TextureNodeTree"); + strcpy(tt->ui_name, "Texture"); + tt->ui_icon = 0; /* defined in drawnode.c */ + strcpy(tt->ui_description, ""); - /* free_cache */ NULL, - /* free_node_cache */ NULL, - /* foreach_nodetree */ foreach_nodetree, - /* foreach_nodeclass */ foreach_nodeclass, - /* localize */ localize, - /* local_sync */ local_sync, - /* local_merge */ NULL, - /* update */ update, - /* update_node */ NULL, - /* validate_link */ NULL, - /* update_internal_links */ node_update_internal_links_default -}; + tt->foreach_nodeclass = foreach_nodeclass; + tt->update = update; + tt->localize = localize; + tt->local_sync = local_sync; + tt->get_from_context = texture_get_from_context; + + tt->ext.srna = &RNA_TextureNodeTree; + + ntreeTypeAdd(tt); +} int ntreeTexTagAnimated(bNodeTree *ntree) { @@ -158,24 +196,13 @@ int ntreeTexTagAnimated(bNodeTree *ntree) return 0; } -/* XXX Group nodes must set use_tree_data to false, since their trees can be shared by multiple nodes. - * If use_tree_data is true, the ntree->execdata pointer is checked to avoid multiple execution of top-level trees. - */ -bNodeTreeExec *ntreeTexBeginExecTree(bNodeTree *ntree, int use_tree_data) +bNodeTreeExec *ntreeTexBeginExecTree_internal(bNodeExecContext *context, bNodeTree *ntree, bNodeInstanceKey parent_key) { bNodeTreeExec *exec; bNode *node; - if (use_tree_data) { - /* XXX hack: prevent exec data from being generated twice. - * this should be handled by the renderer! - */ - if (ntree->execdata) - return ntree->execdata; - } - /* common base initialization */ - exec = ntree_exec_begin(ntree); + exec = ntree_exec_begin(context, ntree, parent_key); /* allocate the thread stack listbase array */ exec->threadstack = MEM_callocN(BLENDER_MAX_THREADS * sizeof(ListBase), "thread stack array"); @@ -183,12 +210,28 @@ bNodeTreeExec *ntreeTexBeginExecTree(bNodeTree *ntree, int use_tree_data) for (node = exec->nodetree->nodes.first; node; node = node->next) node->need_exec = 1; - if (use_tree_data) { - /* XXX this should not be necessary, but is still used for cmp/sha/tex nodes, - * which only store the ntree pointer. Should be fixed at some point! - */ - ntree->execdata = exec; - } + return exec; +} + +bNodeTreeExec *ntreeTexBeginExecTree(bNodeTree *ntree) +{ + bNodeExecContext context; + bNodeTreeExec *exec; + + /* XXX hack: prevent exec data from being generated twice. + * this should be handled by the renderer! + */ + if (ntree->execdata) + return ntree->execdata; + + context.previews = ntree->previews; + + exec = ntreeTexBeginExecTree_internal(&context, ntree, NODE_INSTANCE_KEY_BASE); + + /* XXX this should not be necessary, but is still used for cmp/sha/tex nodes, + * which only store the ntree pointer. Should be fixed at some point! + */ + ntree->execdata = exec; return exec; } @@ -207,35 +250,34 @@ static void tex_free_delegates(bNodeTreeExec *exec) MEM_freeN(ns->data); } -/* XXX Group nodes must set use_tree_data to false, since their trees can be shared by multiple nodes. - * If use_tree_data is true, the ntree->execdata pointer is checked to avoid multiple execution of top-level trees. - */ -void ntreeTexEndExecTree(bNodeTreeExec *exec, int use_tree_data) +void ntreeTexEndExecTree_internal(bNodeTreeExec *exec) { - if (exec) { - bNodeTree *ntree = exec->nodetree; - bNodeThreadStack *nts; - int a; + bNodeThreadStack *nts; + int a; + + if (exec->threadstack) { + tex_free_delegates(exec); - if (exec->threadstack) { - tex_free_delegates(exec); - - for (a = 0; a < BLENDER_MAX_THREADS; a++) { - for (nts = exec->threadstack[a].first; nts; nts = nts->next) - if (nts->stack) MEM_freeN(nts->stack); - BLI_freelistN(&exec->threadstack[a]); - } - - MEM_freeN(exec->threadstack); - exec->threadstack = NULL; + for (a = 0; a < BLENDER_MAX_THREADS; a++) { + for (nts = exec->threadstack[a].first; nts; nts = nts->next) + if (nts->stack) MEM_freeN(nts->stack); + BLI_freelistN(&exec->threadstack[a]); } - ntree_exec_end(exec); + MEM_freeN(exec->threadstack); + exec->threadstack = NULL; + } + + ntree_exec_end(exec); +} + +void ntreeTexEndExecTree(bNodeTreeExec *exec) +{ + if (exec) { + ntreeTexEndExecTree_internal(exec); - if (use_tree_data) { - /* XXX clear nodetree backpointer to exec data, same problem as noted in ntreeBeginExecTree */ - ntree->execdata = NULL; - } + /* XXX clear nodetree backpointer to exec data, same problem as noted in ntreeBeginExecTree */ + exec->nodetree->execdata = NULL; } } @@ -275,7 +317,7 @@ int ntreeTexExecTree( if (!exec) { BLI_lock_thread(LOCK_NODES); if (!nodes->execdata) - ntreeTexBeginExecTree(nodes, 1); + ntreeTexBeginExecTree(nodes); BLI_unlock_thread(LOCK_NODES); exec = nodes->execdata; diff --git a/source/blender/nodes/texture/node_texture_util.c b/source/blender/nodes/texture/node_texture_util.c index 06473d800d0..80644157b02 100644 --- a/source/blender/nodes/texture/node_texture_util.c +++ b/source/blender/nodes/texture/node_texture_util.c @@ -49,13 +49,28 @@ #include <assert.h> #include "node_texture_util.h" + +int tex_node_poll_default(bNodeType *UNUSED(ntype), bNodeTree *ntree) +{ + return (strcmp(ntree->idname, "TextureNodeTree")==0); +} + +void tex_node_type_base(struct bNodeType *ntype, int type, const char *name, short nclass, short flag) +{ + node_type_base(ntype, type, name, nclass, flag); + + ntype->poll = tex_node_poll_default; + ntype->update_internal_links = node_update_internal_links_default; +} + + static void tex_call_delegate(TexDelegate *dg, float *out, TexParams *params, short thread) { if (dg->node->need_exec) { dg->fn(out, params, dg->node, dg->in, thread); if (dg->cdata->do_preview) - tex_do_preview(dg->node, params->previewco, out); + tex_do_preview(dg->preview, params->previewco, out); } } @@ -112,19 +127,17 @@ void params_from_cdata(TexParams *out, TexCallData *in) out->mtex = in->mtex; } -void tex_do_preview(bNode *node, const float coord[2], const float col[4]) +void tex_do_preview(bNodePreview *preview, const float coord[2], const float col[4]) { - bNodePreview *preview = node->preview; - if (preview) { int xs = ((coord[0] + 1.0f) * 0.5f) * preview->xsize; int ys = ((coord[1] + 1.0f) * 0.5f) * preview->ysize; - - nodeAddToPreview(node, col, xs, ys, 0); /* 0 = no color management */ + + BKE_node_preview_set_pixel(preview, col, xs, ys, 0); /* 0 = no color management */ } } -void tex_output(bNode *node, bNodeStack **in, bNodeStack *out, TexFn texfn, TexCallData *cdata) +void tex_output(bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack *out, TexFn texfn, TexCallData *cdata) { TexDelegate *dg; if (!out->data) @@ -136,6 +149,7 @@ void tex_output(bNode *node, bNodeStack **in, bNodeStack *out, TexFn texfn, TexC dg->cdata = cdata; dg->fn = texfn; dg->node = node; + dg->preview = execdata->preview; memcpy(dg->in, in, MAX_SOCKET * sizeof(bNodeStack *)); dg->type = out->sockettype; } diff --git a/source/blender/nodes/texture/node_texture_util.h b/source/blender/nodes/texture/node_texture_util.h index 3b2a7e14f69..b81ea51ddff 100644 --- a/source/blender/nodes/texture/node_texture_util.h +++ b/source/blender/nodes/texture/node_texture_util.h @@ -65,6 +65,7 @@ #include "BKE_library.h" #include "node_util.h" +#include "NOD_texture.h" #include "NOD_texture.h" @@ -111,16 +112,21 @@ typedef struct TexDelegate { TexCallData *cdata; TexFn fn; bNode *node; + bNodePreview *preview; bNodeStack *in[MAX_SOCKET]; int type; } TexDelegate; + +int tex_node_poll_default(struct bNodeType *ntype, struct bNodeTree *ntree); +void tex_node_type_base(struct bNodeType *ntype, int type, const char *name, short nclass, short flag); + void tex_input_rgba(float *out, bNodeStack *in, TexParams *params, short thread); void tex_input_vec(float *out, bNodeStack *in, TexParams *params, short thread); float tex_input_value(bNodeStack *in, TexParams *params, short thread); -void tex_output(bNode *node, bNodeStack **in, bNodeStack *out, TexFn texfn, TexCallData *data); -void tex_do_preview(bNode *node, const float coord[2], const float col[4]); +void tex_output(bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack *out, TexFn texfn, TexCallData *data); +void tex_do_preview(bNodePreview *preview, const float coord[2], const float col[4]); void params_from_cdata(TexParams *out, TexCallData *in); diff --git a/source/blender/nodes/texture/nodes/node_texture_at.c b/source/blender/nodes/texture/nodes/node_texture_at.c index 4c2d276b902..ef930a39fe3 100644 --- a/source/blender/nodes/texture/nodes/node_texture_at.c +++ b/source/blender/nodes/texture/nodes/node_texture_at.c @@ -53,19 +53,19 @@ static void colorfn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack ** tex_input_rgba(out, in[0], &np, thread); } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_at(bNodeTreeType *ttype) +void register_node_type_tex_at() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_AT, "At", NODE_CLASS_DISTORT, 0); + tex_node_type_base(&ntype, TEX_NODE_AT, "At", NODE_CLASS_DISTORT, 0); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 140, 100, 320); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_bricks.c b/source/blender/nodes/texture/nodes/node_texture_bricks.c index b4f81f08e43..afcbf4216c3 100644 --- a/source/blender/nodes/texture/nodes/node_texture_bricks.c +++ b/source/blender/nodes/texture/nodes/node_texture_bricks.c @@ -50,7 +50,7 @@ static bNodeSocketTemplate outputs[] = { { -1, 0, "" } }; -static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void init(bNodeTree *UNUSED(ntree), bNode *node) { node->custom3 = 0.5; /* offset */ node->custom4 = 1.0; /* squash */ @@ -116,20 +116,20 @@ static void colorfn(float *out, TexParams *p, bNode *node, bNodeStack **in, shor } } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_bricks(bNodeTreeType *ttype) +void register_node_type_tex_bricks() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_BRICKS, "Bricks", NODE_CLASS_PATTERN, NODE_PREVIEW|NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_BRICKS, "Bricks", NODE_CLASS_PATTERN, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 150, 60, 150); node_type_init(&ntype, init); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_checker.c b/source/blender/nodes/texture/nodes/node_texture_checker.c index 1f653d1f7b9..53c91db0312 100644 --- a/source/blender/nodes/texture/nodes/node_texture_checker.c +++ b/source/blender/nodes/texture/nodes/node_texture_checker.c @@ -65,19 +65,19 @@ static void colorfn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack ** } } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_checker(bNodeTreeType *ttype) +void register_node_type_tex_checker() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_CHECKER, "Checker", NODE_CLASS_PATTERN, NODE_PREVIEW|NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_CHECKER, "Checker", NODE_CLASS_PATTERN, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 100, 60, 150); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_common.c b/source/blender/nodes/texture/nodes/node_texture_common.c index aa427ff3587..2af2a3a1999 100644 --- a/source/blender/nodes/texture/nodes/node_texture_common.c +++ b/source/blender/nodes/texture/nodes/node_texture_common.c @@ -38,9 +38,12 @@ #include "BKE_node.h" #include "node_texture_util.h" +#include "NOD_common.h" #include "node_common.h" #include "node_exec.h" +#include "RNA_access.h" + static void copy_stack(bNodeStack *to, bNodeStack *from) { if (to != from) { @@ -55,7 +58,7 @@ static void copy_stack(bNodeStack *to, bNodeStack *from) /**** GROUP ****/ -static void *group_initexec(bNode *node) +static void *group_initexec(bNodeExecContext *context, bNode *node, bNodeInstanceKey key) { bNodeTree *ngroup= (bNodeTree*)node->id; void *exec; @@ -64,7 +67,7 @@ static void *group_initexec(bNode *node) return NULL; /* initialize the internal node tree execution */ - exec = ntreeTexBeginExecTree(ngroup, 0); + exec = ntreeTexBeginExecTree_internal(context, ngroup, key); return exec; } @@ -73,43 +76,56 @@ static void group_freeexec(bNode *UNUSED(node), void *nodedata) { bNodeTreeExec*gexec= (bNodeTreeExec*)nodedata; - ntreeTexEndExecTree(gexec, 0); + ntreeTexEndExecTree_internal(gexec); } /* Copy inputs to the internal stack. * This is a shallow copy, no buffers are duplicated here! */ -static void group_copy_inputs(bNode *node, bNodeStack **in, bNodeStack *gstack) +static void group_copy_inputs(bNode *gnode, bNodeStack **in, bNodeStack *gstack) { + bNodeTree *ngroup = (bNodeTree*)gnode->id; + bNode *node; bNodeSocket *sock; bNodeStack *ns; int a; - for (sock=node->inputs.first, a=0; sock; sock=sock->next, ++a) { - if (sock->groupsock) { - ns = node_get_socket_stack(gstack, sock->groupsock); - copy_stack(ns, in[a]); + + for (node = ngroup->nodes.first; node; node = node->next) { + if (node->type == NODE_GROUP_INPUT) { + for (sock = node->outputs.first, a = 0; sock; sock = sock->next, ++a) { + ns = node_get_socket_stack(gstack, sock); + if (ns) + copy_stack(ns, in[a]); + } } } } /* Copy internal results to the external outputs. */ -static void group_copy_outputs(bNode *node, bNodeStack **out, bNodeStack *gstack) +static void group_copy_outputs(bNode *gnode, bNodeStack **out, bNodeStack *gstack) { + bNodeTree *ngroup = (bNodeTree*)gnode->id; + bNode *node; bNodeSocket *sock; bNodeStack *ns; int a; - for (sock=node->outputs.first, a=0; sock; sock=sock->next, ++a) { - if (sock->groupsock) { - ns = node_get_socket_stack(gstack, sock->groupsock); - copy_stack(out[a], ns); + + for (node = ngroup->nodes.first; node; node = node->next) { + if (node->type == NODE_GROUP_OUTPUT && (node->flag & NODE_DO_OUTPUT)) { + for (sock = node->inputs.first, a = 0; sock; sock = sock->next, ++a) { + ns = node_get_socket_stack(gstack, sock); + if (ns) + copy_stack(out[a], ns); + } + break; /* only one active output node */ } } } -static void group_execute(void *data, int thread, struct bNode *node, void *nodedata, struct bNodeStack **in, struct bNodeStack **out) +static void group_execute(void *data, int thread, struct bNode *node, bNodeExecData *execdata, struct bNodeStack **in, struct bNodeStack **out) { - bNodeTreeExec *exec= (bNodeTreeExec*)nodedata; + bNodeTreeExec *exec= execdata->data; bNodeThreadStack *nts; if (!exec) @@ -133,20 +149,27 @@ static void group_execute(void *data, int thread, struct bNode *node, void *node ntreeReleaseThreadStack(nts); } -void register_node_type_tex_group(bNodeTreeType *ttype) +void register_node_type_tex_group() { static bNodeType ntype; - node_type_base(ttype, &ntype, NODE_GROUP, "Group", NODE_CLASS_GROUP, NODE_OPTIONS|NODE_CONST_OUTPUT); + /* NB: cannot use sh_node_type_base for node group, because it would map the node type + * to the shared NODE_GROUP integer type id. + */ + node_type_base_custom(&ntype, "TextureNodeGroup", "Group", NODE_CLASS_GROUP, NODE_OPTIONS | NODE_CONST_OUTPUT); + ntype.type = NODE_GROUP; + ntype.poll = tex_node_poll_default; + ntype.update_internal_links = node_update_internal_links_default; + ntype.ext.srna = RNA_struct_find("TextureNodeGroup"); + BLI_assert(ntype.ext.srna != NULL); + RNA_struct_blender_type_set(ntype.ext.srna, &ntype); + node_type_socket_templates(&ntype, NULL, NULL); node_type_size(&ntype, 120, 60, 200); node_type_label(&ntype, node_group_label); - node_type_init(&ntype, node_group_init); - node_type_valid(&ntype, node_group_valid); - node_type_template(&ntype, node_group_template); node_type_update(&ntype, NULL, node_group_verify); - node_type_group_edit(&ntype, node_group_edit_get, node_group_edit_set, node_group_edit_clear); - node_type_exec_new(&ntype, group_initexec, group_freeexec, group_execute); + strcpy(ntype.group_tree_idname, "TextureNodeTree"); + node_type_exec(&ntype, group_initexec, group_freeexec, group_execute); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_compose.c b/source/blender/nodes/texture/nodes/node_texture_compose.c index 43a8ba1babf..ddaae829da9 100644 --- a/source/blender/nodes/texture/nodes/node_texture_compose.c +++ b/source/blender/nodes/texture/nodes/node_texture_compose.c @@ -52,19 +52,19 @@ static void colorfn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack ** out[i] = tex_input_value(in[i], p, thread); } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_compose(bNodeTreeType *ttype) +void register_node_type_tex_compose() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_COMPOSE, "Combine RGBA", NODE_CLASS_OP_COLOR, 0); + tex_node_type_base(&ntype, TEX_NODE_COMPOSE, "Combine RGBA", NODE_CLASS_OP_COLOR, 0); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 100, 60, 150); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_coord.c b/source/blender/nodes/texture/nodes/node_texture_coord.c index 971520ebc38..94793288ec3 100644 --- a/source/blender/nodes/texture/nodes/node_texture_coord.c +++ b/source/blender/nodes/texture/nodes/node_texture_coord.c @@ -43,20 +43,20 @@ static void vectorfn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack * copy_v3_v3(out, p->co); } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &vectorfn, data); + tex_output(node, execdata, in, out[0], &vectorfn, data); } -void register_node_type_tex_coord(bNodeTreeType *ttype) +void register_node_type_tex_coord() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_COORD, "Coordinates", NODE_CLASS_INPUT, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_COORD, "Coordinates", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, outputs); node_type_size(&ntype, 120, 110, 160); node_type_storage(&ntype, "node_coord", NULL, NULL); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_curves.c b/source/blender/nodes/texture/nodes/node_texture_curves.c index 5980f938938..94235eae93c 100644 --- a/source/blender/nodes/texture/nodes/node_texture_curves.c +++ b/source/blender/nodes/texture/nodes/node_texture_curves.c @@ -54,32 +54,31 @@ static void time_colorfn(float *out, TexParams *p, bNode *node, bNodeStack **UNU out[0] = CLAMPIS(fac, 0.0f, 1.0f); } -static void time_exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void time_exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &time_colorfn, data); + tex_output(node, execdata, in, out[0], &time_colorfn, data); } -static void time_init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void time_init(bNodeTree *UNUSED(ntree), bNode *node) { node->custom1= 1; node->custom2= 250; node->storage= curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f); } -void register_node_type_tex_curve_time(bNodeTreeType *ttype) +void register_node_type_tex_curve_time() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_CURVE_TIME, "Time", NODE_CLASS_INPUT, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_CURVE_TIME, "Time", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, time_outputs); node_type_size(&ntype, 140, 100, 320); node_type_init(&ntype, time_init); node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); - node_type_exec(&ntype, time_exec); - node_type_exec_new(&ntype, node_initexec_curves, NULL, NULL); /* only for its initexec func */ + node_type_exec(&ntype, node_initexec_curves, NULL, time_exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } /* **************** CURVE RGB ******************** */ @@ -102,27 +101,26 @@ static void rgb_colorfn(float *out, TexParams *p, bNode *node, bNodeStack **in, out[3] = cin[3]; } -static void rgb_exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void rgb_exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &rgb_colorfn, data); + tex_output(node, execdata, in, out[0], &rgb_colorfn, data); } -static void rgb_init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void rgb_init(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= curvemapping_add(4, 0.0f, 0.0f, 1.0f, 1.0f); } -void register_node_type_tex_curve_rgb(bNodeTreeType *ttype) +void register_node_type_tex_curve_rgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, rgb_inputs, rgb_outputs); node_type_size(&ntype, 200, 140, 320); node_type_init(&ntype, rgb_init); node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); - node_type_exec(&ntype, rgb_exec); - node_type_exec_new(&ntype, node_initexec_curves, NULL, NULL); /* only for its initexec func */ + node_type_exec(&ntype, node_initexec_curves, NULL, rgb_exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_decompose.c b/source/blender/nodes/texture/nodes/node_texture_decompose.c index 0866428ca6c..fa2c1d6398f 100644 --- a/source/blender/nodes/texture/nodes/node_texture_decompose.c +++ b/source/blender/nodes/texture/nodes/node_texture_decompose.c @@ -70,22 +70,22 @@ static void valuefn_a(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack *out = out[3]; } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &valuefn_r, data); - tex_output(node, in, out[1], &valuefn_g, data); - tex_output(node, in, out[2], &valuefn_b, data); - tex_output(node, in, out[3], &valuefn_a, data); + tex_output(node, execdata, in, out[0], &valuefn_r, data); + tex_output(node, execdata, in, out[1], &valuefn_g, data); + tex_output(node, execdata, in, out[2], &valuefn_b, data); + tex_output(node, execdata, in, out[3], &valuefn_a, data); } -void register_node_type_tex_decompose(bNodeTreeType *ttype) +void register_node_type_tex_decompose() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_DECOMPOSE, "Separate RGBA", NODE_CLASS_OP_COLOR, 0); + tex_node_type_base(&ntype, TEX_NODE_DECOMPOSE, "Separate RGBA", NODE_CLASS_OP_COLOR, 0); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 100, 60, 150); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_distance.c b/source/blender/nodes/texture/nodes/node_texture_distance.c index 8c3b1555d5d..fefa093481d 100644 --- a/source/blender/nodes/texture/nodes/node_texture_distance.c +++ b/source/blender/nodes/texture/nodes/node_texture_distance.c @@ -56,20 +56,20 @@ static void valuefn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack ** *out = len_v3v3(co2, co1); } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &valuefn, data); + tex_output(node, execdata, in, out[0], &valuefn, data); } -void register_node_type_tex_distance(bNodeTreeType *ttype) +void register_node_type_tex_distance() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_DISTANCE, "Distance", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_DISTANCE, "Distance", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 120, 110, 160); node_type_storage(&ntype, "node_distance", NULL, NULL); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_hueSatVal.c b/source/blender/nodes/texture/nodes/node_texture_hueSatVal.c index b5e9969a830..c5acf01801c 100644 --- a/source/blender/nodes/texture/nodes/node_texture_hueSatVal.c +++ b/source/blender/nodes/texture/nodes/node_texture_hueSatVal.c @@ -87,19 +87,19 @@ static void colorfn(float *out, TexParams *p, bNode *node, bNodeStack **in, shor out[3] = col[3]; } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_hue_sat(bNodeTreeType *ttype) +void register_node_type_tex_hue_sat() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 150, 80, 250); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_image.c b/source/blender/nodes/texture/nodes/node_texture_image.c index 2ef1669a266..e897b0e4e96 100644 --- a/source/blender/nodes/texture/nodes/node_texture_image.c +++ b/source/blender/nodes/texture/nodes/node_texture_image.c @@ -83,12 +83,12 @@ static void colorfn(float *out, TexParams *p, bNode *node, bNodeStack **UNUSED(i } } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void init(bNodeTree *UNUSED(ntree), bNode *node) { ImageUser *iuser= MEM_callocN(sizeof(ImageUser), "node image user"); node->storage= iuser; @@ -97,16 +97,16 @@ static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(nt iuser->ok= 1; } -void register_node_type_tex_image(bNodeTreeType *ttype) +void register_node_type_tex_image() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_IMAGE, "Image", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_IMAGE, "Image", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, outputs); node_type_size(&ntype, 120, 80, 300); node_type_init(&ntype, init); node_type_storage(&ntype, "ImageUser", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_invert.c b/source/blender/nodes/texture/nodes/node_texture_invert.c index 9c2963d2dc2..aa394bff8bc 100644 --- a/source/blender/nodes/texture/nodes/node_texture_invert.c +++ b/source/blender/nodes/texture/nodes/node_texture_invert.c @@ -58,19 +58,19 @@ static void colorfn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack ** out[3] = col[3]; } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_invert(bNodeTreeType *ttype) +void register_node_type_tex_invert() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 90, 80, 100); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_math.c b/source/blender/nodes/texture/nodes/node_texture_math.c index 95d70ccc7d6..e83579070a9 100644 --- a/source/blender/nodes/texture/nodes/node_texture_math.c +++ b/source/blender/nodes/texture/nodes/node_texture_math.c @@ -181,21 +181,21 @@ static void valuefn(float *out, TexParams *p, bNode *node, bNodeStack **in, shor } } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &valuefn, data); + tex_output(node, execdata, in, out[0], &valuefn, data); } -void register_node_type_tex_math(bNodeTreeType *ttype) +void register_node_type_tex_math() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 120, 110, 160); node_type_label(&ntype, node_math_label); node_type_storage(&ntype, "node_math", NULL, NULL); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_mixRgb.c b/source/blender/nodes/texture/nodes/node_texture_mixRgb.c index fe04854c734..7a68af4b1e2 100644 --- a/source/blender/nodes/texture/nodes/node_texture_mixRgb.c +++ b/source/blender/nodes/texture/nodes/node_texture_mixRgb.c @@ -59,20 +59,20 @@ static void colorfn(float *out, TexParams *p, bNode *node, bNodeStack **in, shor ramp_blend(node->custom1, out, fac, col2); } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_mix_rgb(bNodeTreeType *ttype) +void register_node_type_tex_mix_rgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 100, 60, 150); node_type_label(&ntype, node_blend_label); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_output.c b/source/blender/nodes/texture/nodes/node_texture_output.c index 2f5efe8c45e..8c8f7622d29 100644 --- a/source/blender/nodes/texture/nodes/node_texture_output.c +++ b/source/blender/nodes/texture/nodes/node_texture_output.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate inputs[] = { }; /* applies to render pipeline */ -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **UNUSED(out)) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **UNUSED(out)) { TexCallData *cdata = (TexCallData *)data; TexResult *target = cdata->target; @@ -54,7 +54,7 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **UNUSED(o tex_input_rgba(&target->tr, in[1], ¶ms, cdata->thread); else tex_input_rgba(&target->tr, in[0], ¶ms, cdata->thread); - tex_do_preview(node, params.co, &target->tr); + tex_do_preview(execdata->preview, params.co, &target->tr); } else { /* 0 means don't care, so just use first */ @@ -141,7 +141,7 @@ static void assign_index(struct bNode *node) node->custom1 = index; } -static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void init(bNodeTree *UNUSED(ntree), bNode *node) { TexNodeOutput *tno = MEM_callocN(sizeof(TexNodeOutput), "TEX_output"); node->storage= tno; @@ -151,26 +151,26 @@ static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(nt assign_index(node); } -static void copy(bNode *orig, bNode *new) +static void copy(bNodeTree *dest_ntree, bNode *dest_node, bNode *src_node) { - node_copy_standard_storage(orig, new); - unique_name(new); - assign_index(new); + node_copy_standard_storage(dest_ntree, dest_node, src_node); + unique_name(dest_node); + assign_index(dest_node); } -void register_node_type_tex_output(bNodeTreeType *ttype) +void register_node_type_tex_output() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_OUTPUT, "Output", NODE_CLASS_OUTPUT, NODE_PREVIEW|NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_OUTPUT, "Output", NODE_CLASS_OUTPUT, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, NULL); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, init); node_type_storage(&ntype, "TexNodeOutput", node_free_standard_storage, copy); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); /* Do not allow muting output. */ node_type_internal_links(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_proc.c b/source/blender/nodes/texture/nodes/node_texture_proc.c index de2dac22d81..504e77ebb27 100644 --- a/source/blender/nodes/texture/nodes/node_texture_proc.c +++ b/source/blender/nodes/texture/nodes/node_texture_proc.c @@ -129,11 +129,11 @@ static int count_outputs(bNode *node) { \ texfn(result, p, node, in, 1, &name##_map_inputs, thread); \ } \ - static void name##_exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) \ + static void name##_exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) \ { \ int outs = count_outputs(node); \ - if (outs >= 1) tex_output(node, in, out[0], &name##_colorfn, data); \ - if (outs >= 2) tex_output(node, in, out[1], &name##_normalfn, data); \ + if (outs >= 1) tex_output(node, execdata, in, out[0], &name##_colorfn, data); \ + if (outs >= 2) tex_output(node, execdata, in, out[1], &name##_normalfn, data); \ } @@ -281,7 +281,7 @@ ProcDef(stucci) /* --- */ -static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void init(bNodeTree *UNUSED(ntree), bNode *node) { Tex *tex = MEM_callocN(sizeof(Tex), "Tex"); node->storage= tex; @@ -296,18 +296,18 @@ static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(nt /* Node type definitions */ #define TexDef(TEXTYPE, outputs, name, Name) \ -void register_node_type_tex_proc_##name(bNodeTreeType *ttype) \ +void register_node_type_tex_proc_##name() \ { \ static bNodeType ntype; \ \ - node_type_base(ttype, &ntype, TEX_NODE_PROC+TEXTYPE, Name, NODE_CLASS_TEXTURE, NODE_PREVIEW|NODE_OPTIONS); \ + tex_node_type_base(&ntype, TEX_NODE_PROC+TEXTYPE, Name, NODE_CLASS_TEXTURE, NODE_PREVIEW|NODE_OPTIONS); \ node_type_socket_templates(&ntype, name##_inputs, outputs); \ node_type_size(&ntype, 140, 80, 140); \ node_type_init(&ntype, init); \ node_type_storage(&ntype, "Tex", node_free_standard_storage, node_copy_standard_storage); \ - node_type_exec(&ntype, name##_exec); \ + node_type_exec(&ntype, NULL, NULL, name##_exec); \ \ - nodeRegisterType(ttype, &ntype); \ + nodeRegisterType(&ntype); \ } #define C outputs_color_only diff --git a/source/blender/nodes/texture/nodes/node_texture_rotate.c b/source/blender/nodes/texture/nodes/node_texture_rotate.c index 1b1d57044a3..8f3f66dbee4 100644 --- a/source/blender/nodes/texture/nodes/node_texture_rotate.c +++ b/source/blender/nodes/texture/nodes/node_texture_rotate.c @@ -90,19 +90,19 @@ static void colorfn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack ** tex_input_rgba(out, in[0], &np, thread); } } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_rotate(bNodeTreeType *ttype) +void register_node_type_tex_rotate() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_ROTATE, "Rotate", NODE_CLASS_DISTORT, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_ROTATE, "Rotate", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 140, 100, 320); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_scale.c b/source/blender/nodes/texture/nodes/node_texture_scale.c index 56562724fb9..67e0c064b7c 100644 --- a/source/blender/nodes/texture/nodes/node_texture_scale.c +++ b/source/blender/nodes/texture/nodes/node_texture_scale.c @@ -63,19 +63,19 @@ static void colorfn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack ** tex_input_rgba(out, in[0], &np, thread); } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_scale(bNodeTreeType *ttype) +void register_node_type_tex_scale() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_SCALE, "Scale", NODE_CLASS_DISTORT, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_SCALE, "Scale", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 90, 80, 100); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_texture.c b/source/blender/nodes/texture/nodes/node_texture_texture.c index f839f485976..9970c3c2a26 100644 --- a/source/blender/nodes/texture/nodes/node_texture_texture.c +++ b/source/blender/nodes/texture/nodes/node_texture_texture.c @@ -90,19 +90,19 @@ static void colorfn(float *out, TexParams *p, bNode *node, bNodeStack **in, shor } } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_texture(bNodeTreeType *ttype) +void register_node_type_tex_texture() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 120, 80, 240); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_translate.c b/source/blender/nodes/texture/nodes/node_texture_translate.c index a95cb00a47d..3d5db4f863a 100644 --- a/source/blender/nodes/texture/nodes/node_texture_translate.c +++ b/source/blender/nodes/texture/nodes/node_texture_translate.c @@ -59,19 +59,19 @@ static void colorfn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack ** tex_input_rgba(out, in[0], &np, thread); } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_translate(bNodeTreeType *ttype) +void register_node_type_tex_translate() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_TRANSLATE, "Translate", NODE_CLASS_DISTORT, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_TRANSLATE, "Translate", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 90, 80, 100); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_valToNor.c b/source/blender/nodes/texture/nodes/node_texture_valToNor.c index bbfc1fa616b..d7495f9833d 100644 --- a/source/blender/nodes/texture/nodes/node_texture_valToNor.c +++ b/source/blender/nodes/texture/nodes/node_texture_valToNor.c @@ -75,19 +75,19 @@ static void normalfn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack * out[1] = val-nor[1]; out[2] = val-nor[2]; } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &normalfn, data); + tex_output(node, execdata, in, out[0], &normalfn, data); } -void register_node_type_tex_valtonor(bNodeTreeType *ttype) +void register_node_type_tex_valtonor() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_VALTONOR, "Value to Normal", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_VALTONOR, "Value to Normal", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 90, 80, 100); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_valToRgb.c b/source/blender/nodes/texture/nodes/node_texture_valToRgb.c index 78635453fc1..fec89aa03eb 100644 --- a/source/blender/nodes/texture/nodes/node_texture_valToRgb.c +++ b/source/blender/nodes/texture/nodes/node_texture_valToRgb.c @@ -52,28 +52,28 @@ static void valtorgb_colorfn(float *out, TexParams *p, bNode *node, bNodeStack * } } -static void valtorgb_exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void valtorgb_exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &valtorgb_colorfn, data); + tex_output(node, execdata, in, out[0], &valtorgb_colorfn, data); } -static void valtorgb_init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void valtorgb_init(bNodeTree *UNUSED(ntree), bNode *node) { node->storage = add_colorband(1); } -void register_node_type_tex_valtorgb(bNodeTreeType *ttype) +void register_node_type_tex_valtorgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, valtorgb_in, valtorgb_out); node_type_size(&ntype, 240, 200, 300); node_type_init(&ntype, valtorgb_init); node_type_storage(&ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, valtorgb_exec); + node_type_exec(&ntype, NULL, NULL, valtorgb_exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } /* **************** RGBTOBW ******************** */ @@ -94,19 +94,19 @@ static void rgbtobw_valuefn(float *out, TexParams *p, bNode *UNUSED(node), bNode *out = rgb_to_bw(cin); } -static void rgbtobw_exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void rgbtobw_exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &rgbtobw_valuefn, data); + tex_output(node, execdata, in, out[0], &rgbtobw_valuefn, data); } -void register_node_type_tex_rgbtobw(bNodeTreeType *ttype) +void register_node_type_tex_rgbtobw() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTOR, 0); + tex_node_type_base(&ntype, TEX_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTOR, 0); node_type_socket_templates(&ntype, rgbtobw_in, rgbtobw_out); node_type_size(&ntype, 80, 40, 120); - node_type_exec(&ntype, rgbtobw_exec); + node_type_exec(&ntype, NULL, NULL, rgbtobw_exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_viewer.c b/source/blender/nodes/texture/nodes/node_texture_viewer.c index 5cb8d8c438c..44724c9280f 100644 --- a/source/blender/nodes/texture/nodes/node_texture_viewer.c +++ b/source/blender/nodes/texture/nodes/node_texture_viewer.c @@ -42,7 +42,7 @@ static bNodeSocketTemplate outputs[] = { { -1, 0, "" } }; -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **UNUSED(out)) +static void exec(void *data, int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *execdata, bNodeStack **in, bNodeStack **UNUSED(out)) { TexCallData *cdata = (TexCallData *)data; @@ -52,21 +52,21 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **UNUSED(o params_from_cdata(¶ms, cdata); tex_input_rgba(col, in[0], ¶ms, cdata->thread); - tex_do_preview(node, params.previewco, col); + tex_do_preview(execdata->preview, params.previewco, col); } } -void register_node_type_tex_viewer(bNodeTreeType *ttype) +void register_node_type_tex_viewer() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_VIEWER, "Viewer", NODE_CLASS_OUTPUT, NODE_PREVIEW); + tex_node_type_base(&ntype, TEX_NODE_VIEWER, "Viewer", NODE_CLASS_OUTPUT, NODE_PREVIEW); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 100, 60, 150); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); /* Do not allow muting viewer node. */ node_type_internal_links(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/python/intern/bpy_rna.c b/source/blender/python/intern/bpy_rna.c index 8fe75032a46..ebd38e672da 100644 --- a/source/blender/python/intern/bpy_rna.c +++ b/source/blender/python/intern/bpy_rna.c @@ -3119,6 +3119,33 @@ static PyObject *pyrna_struct_is_property_set(BPy_StructRNA *self, PyObject *arg return PyBool_FromLong(RNA_property_is_set(&self->ptr, prop)); } +PyDoc_STRVAR(pyrna_struct_property_unset_doc, +".. method:: property_unset(property)\n" +"\n" +" Unset a property, will use default value afterward.\n" +); +static PyObject *pyrna_struct_property_unset(BPy_StructRNA *self, PyObject *args) +{ + PropertyRNA *prop; + const char *name; + + PYRNA_STRUCT_CHECK_OBJ(self); + + if (!PyArg_ParseTuple(args, "s:property_unset", &name)) + return NULL; + + if ((prop = RNA_struct_find_property(&self->ptr, name)) == NULL) { + PyErr_Format(PyExc_TypeError, + "%.200s.property_unset(\"%.200s\") not found", + RNA_struct_identifier(self->ptr.type), name); + return NULL; + } + + RNA_property_unset(&self->ptr, prop); + + Py_RETURN_NONE; +} + PyDoc_STRVAR(pyrna_struct_is_property_hidden_doc, ".. method:: is_property_hidden(property)\n" "\n" @@ -4633,6 +4660,7 @@ static struct PyMethodDef pyrna_struct_methods[] = { {"driver_remove", (PyCFunction)pyrna_struct_driver_remove, METH_VARARGS, pyrna_struct_driver_remove_doc}, {"is_property_set", (PyCFunction)pyrna_struct_is_property_set, METH_VARARGS, pyrna_struct_is_property_set_doc}, + {"property_unset", (PyCFunction)pyrna_struct_property_unset, METH_VARARGS, pyrna_struct_property_unset_doc}, {"is_property_hidden", (PyCFunction)pyrna_struct_is_property_hidden, METH_VARARGS, pyrna_struct_is_property_hidden_doc}, {"path_resolve", (PyCFunction)pyrna_struct_path_resolve, METH_VARARGS, pyrna_struct_path_resolve_doc}, {"path_from_id", (PyCFunction)pyrna_struct_path_from_id, METH_VARARGS, pyrna_struct_path_from_id_doc}, diff --git a/source/blender/render/intern/source/render_texture.c b/source/blender/render/intern/source/render_texture.c index 15ca865643b..96eaa656c36 100644 --- a/source/blender/render/intern/source/render_texture.c +++ b/source/blender/render/intern/source/render_texture.c @@ -121,7 +121,7 @@ static void init_render_texture(Render *re, Tex *tex) } if (tex->nodetree && tex->use_nodes) { - ntreeTexBeginExecTree(tex->nodetree, 1); /* has internal flag to detect it only does it once */ + ntreeTexBeginExecTree(tex->nodetree); /* has internal flag to detect it only does it once */ } } @@ -141,7 +141,7 @@ void init_render_textures(Render *re) static void end_render_texture(Tex *tex) { if (tex && tex->use_nodes && tex->nodetree && tex->nodetree->execdata) - ntreeTexEndExecTree(tex->nodetree->execdata, 1); + ntreeTexEndExecTree(tex->nodetree->execdata); } void end_render_textures(Render *re) diff --git a/source/blenderplayer/bad_level_call_stubs/stubs.c b/source/blenderplayer/bad_level_call_stubs/stubs.c index 28193b71bbd..f31983dcd62 100644 --- a/source/blenderplayer/bad_level_call_stubs/stubs.c +++ b/source/blenderplayer/bad_level_call_stubs/stubs.c @@ -106,8 +106,11 @@ struct bConstraintOb; struct bConstraintTarget; struct bContextDataResult; struct bNode; +struct bNodeType; struct bNodeSocket; +struct bNodeSocketType; struct bNodeTree; +struct bNodeTreeType; struct bPoseChannel; struct bPythonConstraint; struct bTheme; @@ -225,7 +228,7 @@ void ED_armature_edit_bone_remove(struct bArmature *arm, struct EditBone *exBone void object_test_constraints(struct Object *owner) {} void ED_object_parent(struct Object *ob, struct Object *par, int type, const char *substr) {} void ED_object_constraint_set_active(struct Object *ob, struct bConstraint *con) {} -void ED_node_composit_default(struct Scene *sce) {} +void ED_node_composit_default(struct bContext *C, struct Scene *scene) {} void *ED_region_draw_cb_activate(struct ARegionType *art, void(*draw)(const struct bContext *, struct ARegion *, void *), void *custumdata, int type) {return 0;} /* XXX this one looks weird */ void *ED_region_draw_cb_customdata(void *handle) {return 0;} /* XXX This one looks wrong also */ void ED_region_draw_cb_exit(struct ARegionType *art, void *handle) {} @@ -302,10 +305,21 @@ void ED_area_newspace(struct bContext *C, struct ScrArea *sa, int type) {} void ED_region_tag_redraw(struct ARegion *ar) {} void WM_event_add_fileselect(struct bContext *C, struct wmOperator *op) {} void WM_cursor_wait(int val) {} -void ED_node_texture_default(struct Tex *tx) {} -void ED_node_changed_update(struct bContext *C, struct bNode *node) {} -void ED_node_generic_update(struct Main *bmain, struct bNodeTree *ntree, struct bNode *node) {} -void ED_node_tree_update(struct SpaceNode *snode, struct Scene *scene) {} +void ED_node_texture_default(struct bContext *C, struct Tex *tx) {} +void ED_node_tag_update_id(struct ID *id) {} +void ED_node_tag_update_nodetree(struct Main *bmain, struct bNodeTree *ntree) {} +void ED_node_tree_update(const struct bContext *C) {} +void ED_node_set_tree_type(struct SpaceNode *snode, struct bNodeTreeType *typeinfo){} +void ED_init_custom_node_type(struct bNodeType *ntype){} +void ED_init_custom_node_socket_type(struct bNodeSocketType *stype){} +void ED_init_standard_node_socket_type(struct bNodeSocketType *) {} +void ED_init_node_socket_type_virtual(struct bNodeSocketType *) {} +int ED_node_tree_path_length(struct SpaceNode *snode){return 0;} +void ED_node_tree_path_get(struct SpaceNode *snode, char *value){} +void ED_node_tree_path_get_fixedbuf(struct SpaceNode *snode, char *value, int max_length){} +void ED_node_tree_start(struct SpaceNode *snode, struct bNodeTree *ntree, struct ID *id, struct ID *from){} +void ED_node_tree_push(struct SpaceNode *snode, struct bNodeTree *ntree, struct bNode *gnode){} +void ED_node_tree_pop(struct SpaceNode *snode){} void ED_view3d_scene_layers_update(struct Main *bmain, struct Scene *scene) {} int ED_view3d_scene_layer_set(int lay, const int *values) {return 0;} void ED_view3d_quadview_update(struct ScrArea *sa, struct ARegion *ar) {} @@ -317,7 +331,7 @@ void ED_view3d_update_viewmat(struct Scene *scene, struct View3D *v3d, struct AR float ED_view3d_grid_scale(struct Scene *scene, struct View3D *v3d, const char **grid_unit) {return 0.0f;} void view3d_apply_mat4(float mat[4][4], float *ofs, float *quat, float *dist) {} int text_file_modified(struct Text *text) {return 0;} -void ED_node_shader_default(struct Material *ma) {} +void ED_node_shader_default(struct bContext *C, struct ID *id) {} void ED_screen_animation_timer_update(struct bContext *C, int redraws) {} void ED_screen_animation_playing(struct wmWindowManager *wm) {} void ED_base_object_select(struct Base *base, short mode) {} @@ -456,6 +470,7 @@ void uiTemplateMarker(struct uiLayout *layout, struct PointerRNA *ptr, const cha void uiTemplateImageSettings(struct uiLayout *layout, struct PointerRNA *imfptr) {} void uiTemplateColorspaceSettings(struct uiLayout *layout, struct PointerRNA *ptr, const char *propname) {} void uiTemplateColormanagedViewSettings(struct uiLayout *layout, struct bContext *C, struct PointerRNA *ptr, const char *propname, int show_global_settings) {} +void uiTemplateComponentMenu(struct uiLayout *layout, struct PointerRNA *ptr, const char *propname, const char *name){} /* rna render */ struct RenderResult *RE_engine_begin_result(struct RenderEngine *engine, int x, int y, int w, int h) {return (struct RenderResult *) NULL;} |