Differential D12689 Diff 42663 source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc

Changeset View

Standalone View

source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc

Show First 20 Lines • Show All 557 Lines • ▼ Show 20 Lines	for (const int i : range) {
output_splines[i] = fillet_spline(*input_splines[i], fillet_param, spline_offsets[i]);		output_splines[i] = fillet_spline(*input_splines[i], fillet_param, spline_offsets[i]);
}		}
});		});
output_curve->attributes = input_curve.attributes;		output_curve->attributes = input_curve.attributes;

return output_curve;		return output_curve;
}		}

static void geo_node_fillet_exec(GeoNodeExecParams params)		static void calculate_curve_fillet(GeometrySet &geometry_set,
		const GeometryNodeCurveFilletMode mode,
		const Field<float> &radius_field,
		const std::optional<Field<int>> &count_field,
		const bool limit_radius)
{		{
GeometrySet geometry_set = params.extract_input<GeometrySet>("Curve");

geometry_set = bke::geometry_set_realize_instances(geometry_set);

if (!geometry_set.has_curve()) {		if (!geometry_set.has_curve()) {
params.set_output("Curve", geometry_set);
return;		return;
}		}

NodeGeometryCurveFillet &node_storage = (NodeGeometryCurveFillet )params.node().storage;
const GeometryNodeCurveFilletMode mode = (GeometryNodeCurveFilletMode)node_storage.mode;
FilletParam fillet_param;		FilletParam fillet_param;
fillet_param.mode = mode;		fillet_param.mode = mode;

CurveComponent &component = geometry_set.get_component_for_write<CurveComponent>();		CurveComponent &component = geometry_set.get_component_for_write<CurveComponent>();
GeometryComponentFieldContext field_context{component, ATTR_DOMAIN_POINT};		GeometryComponentFieldContext field_context{component, ATTR_DOMAIN_POINT};
const int domain_size = component.attribute_domain_size(ATTR_DOMAIN_POINT);		const int domain_size = component.attribute_domain_size(ATTR_DOMAIN_POINT);
fn::FieldEvaluator field_evaluator{field_context, domain_size};		fn::FieldEvaluator field_evaluator{field_context, domain_size};

Field<float> radius_field = params.extract_input<Field<float>>("Radius");		field_evaluator.add(radius_field);
field_evaluator.add(std::move(radius_field));

if (mode == GEO_NODE_CURVE_FILLET_POLY) {		if (mode == GEO_NODE_CURVE_FILLET_POLY) {
Field<int> count_field = params.extract_input<Field<int>>("Count");		field_evaluator.add(*count_field);
field_evaluator.add(std::move(count_field));
}		}

field_evaluator.evaluate();		field_evaluator.evaluate();

fillet_param.radii = &field_evaluator.get_evaluated<float>(0);		fillet_param.radii = &field_evaluator.get_evaluated<float>(0);
if (fillet_param.radii->is_single() && fillet_param.radii->get_internal_single() < 0.0f) {		if (fillet_param.radii->is_single() && fillet_param.radii->get_internal_single() < 0.0f) {
params.set_output("Geometry", geometry_set);
return;		return;
}		}

if (mode == GEO_NODE_CURVE_FILLET_POLY) {		if (mode == GEO_NODE_CURVE_FILLET_POLY) {
fillet_param.counts = &field_evaluator.get_evaluated<int>(1);		fillet_param.counts = &field_evaluator.get_evaluated<int>(1);
}		}

fillet_param.limit_radius = params.extract_input<bool>("Limit Radius");		fillet_param.limit_radius = limit_radius;

const CurveEval &input_curve = *geometry_set.get_curve_for_read();		const CurveEval &input_curve = *geometry_set.get_curve_for_read();
std::unique_ptr<CurveEval> output_curve = fillet_curve(input_curve, fillet_param);		std::unique_ptr<CurveEval> output_curve = fillet_curve(input_curve, fillet_param);

params.set_output("Curve", GeometrySet::create_with_curve(output_curve.release()));		geometry_set.replace_curve(output_curve.release());
		}

		static void geo_node_fillet_exec(GeoNodeExecParams params)
		{
		GeometrySet geometry_set = params.extract_input<GeometrySet>("Curve");

		NodeGeometryCurveFillet &node_storage = (NodeGeometryCurveFillet )params.node().storage;
		const GeometryNodeCurveFilletMode mode = (GeometryNodeCurveFilletMode)node_storage.mode;

		Field<float> radius_field = params.extract_input<Field<float>>("Radius");
		const bool limit_radius = params.extract_input<bool>("Limit Radius");

		std::optional<Field<int>> count_field;
		if (mode == GEO_NODE_CURVE_FILLET_POLY) {
		count_field.emplace(params.extract_input<Field<int>>("Count"));
		}

		geometry_set.modify_geometry_sets([&](GeometrySet &geometry_set) {
		calculate_curve_fillet(geometry_set, mode, radius_field, count_field, limit_radius);
		});

		params.set_output("Curve", std::move(geometry_set));
}		}

} // namespace blender::nodes		} // namespace blender::nodes

void register_node_type_geo_curve_fillet()		void register_node_type_geo_curve_fillet()
{		{
static bNodeType ntype;		static bNodeType ntype;

geo_node_type_base(&ntype, GEO_NODE_CURVE_FILLET, "Curve Fillet", NODE_CLASS_GEOMETRY, 0);		geo_node_type_base(&ntype, GEO_NODE_CURVE_FILLET, "Curve Fillet", NODE_CLASS_GEOMETRY, 0);
ntype.draw_buttons = blender::nodes::geo_node_curve_fillet_layout;		ntype.draw_buttons = blender::nodes::geo_node_curve_fillet_layout;
node_type_storage(		node_type_storage(
&ntype, "NodeGeometryCurveFillet", node_free_standard_storage, node_copy_standard_storage);		&ntype, "NodeGeometryCurveFillet", node_free_standard_storage, node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_curve_fillet_declare;		ntype.declare = blender::nodes::geo_node_curve_fillet_declare;
node_type_init(&ntype, blender::nodes::geo_node_curve_fillet_init);		node_type_init(&ntype, blender::nodes::geo_node_curve_fillet_init);
node_type_update(&ntype, blender::nodes::geo_node_curve_fillet_update);		node_type_update(&ntype, blender::nodes::geo_node_curve_fillet_update);
ntype.geometry_node_execute = blender::nodes::geo_node_fillet_exec;		ntype.geometry_node_execute = blender::nodes::geo_node_fillet_exec;
nodeRegisterType(&ntype);		nodeRegisterType(&ntype);
}		}