Differential D16083 Diff 56395 source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_vertices.cc

Changeset View

Standalone View

source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_vertices.cc

Show All 19 Lines	static void node_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Vector>(N_("Position 1"))		b.add_output<decl::Vector>(N_("Position 1"))
.field_source()		.field_source()
.description(N_("The position of the first vertex in the edge"));		.description(N_("The position of the first vertex in the edge"));
b.add_output<decl::Vector>(N_("Position 2"))		b.add_output<decl::Vector>(N_("Position 2"))
.field_source()		.field_source()
.description(N_("The position of the second vertex in the edge"));		.description(N_("The position of the second vertex in the edge"));
}		}

enum VertexNumber { VERTEX_ONE, VERTEX_TWO };		enum class VertNumber { V1, V2 };

static VArray<int> construct_edge_verts_gvarray(const Mesh &mesh,		static VArray<int> construct_edge_verts_gvarray(const Mesh &mesh,
const VertexNumber vertex,		const VertNumber vertex,
const eAttrDomain domain)		const eAttrDomain domain)
{		{
const Span<MEdge> edges = mesh.edges();		const Span<MEdge> edges = mesh.edges();
if (domain == ATTR_DOMAIN_EDGE) {		if (domain == ATTR_DOMAIN_EDGE) {
if (vertex == VERTEX_ONE) {		if (vertex == VertNumber::V1) {
return VArray<int>::ForFunc(edges.size(),		return VArray<int>::ForFunc(edges.size(),
[edges](const int i) -> int { return edges[i].v1; });		[edges](const int i) -> int { return edges[i].v1; });
}		}
return VArray<int>::ForFunc(edges.size(), [edges](const int i) -> int { return edges[i].v2; });		return VArray<int>::ForFunc(edges.size(), [edges](const int i) -> int { return edges[i].v2; });
}		}
return {};		return {};
}		}

class EdgeVerticesFieldInput final : public bke::MeshFieldInput {		class EdgeVertsInput final : public bke::MeshFieldInput {
private:		private:
VertexNumber vertex_;		VertNumber vertex_;

public:		public:
EdgeVerticesFieldInput(VertexNumber vertex)		EdgeVertsInput(VertNumber vertex)
: bke::MeshFieldInput(CPPType::get<int>(), "Edge Vertices Field"), vertex_(vertex)		: bke::MeshFieldInput(CPPType::get<int>(), "Edge Vertices Field"), vertex_(vertex)
{		{
category_ = Category::Generated;		category_ = Category::Generated;
}		}

GVArray get_varray_for_context(const Mesh &mesh,		GVArray get_varray_for_context(const Mesh &mesh,
const eAttrDomain domain,		const eAttrDomain domain,
IndexMask UNUSED(mask)) const final		IndexMask UNUSED(mask)) const final
{		{
return construct_edge_verts_gvarray(mesh, vertex_, domain);		return construct_edge_verts_gvarray(mesh, vertex_, domain);
}		}

uint64_t hash() const override		uint64_t hash() const override
{		{
return vertex_ == VERTEX_ONE ? 23847562893465 : 92384598734567;		return vertex_ == VertNumber::V1 ? 23847562893465 : 92384598734567;
}		}

bool is_equal_to(const fn::FieldNode &other) const override		bool is_equal_to(const fn::FieldNode &other) const override
{		{
if (const EdgeVerticesFieldInput other_field = dynamic_cast<const EdgeVerticesFieldInput >(		if (const EdgeVertsInput other_field = dynamic_cast<const EdgeVertsInput >(&other)) {
&other)) {
return vertex_ == other_field->vertex_;		return vertex_ == other_field->vertex_;
}		}
return false;		return false;
}		}

		std::optional<eAttrDomain> preferred_domain(const Mesh & /mesh/) const override
		{
		return ATTR_DOMAIN_EDGE;
		}
};		};

static VArray<float3> construct_edge_positions_gvarray(const Mesh &mesh,		static VArray<float3> construct_edge_positions_gvarray(const Mesh &mesh,
const VertexNumber vertex,		const VertNumber vertex,
const eAttrDomain domain)		const eAttrDomain domain)
{		{
const Span<MVert> verts = mesh.verts();		const Span<MVert> verts = mesh.verts();
const Span<MEdge> edges = mesh.edges();		const Span<MEdge> edges = mesh.edges();

if (vertex == VERTEX_ONE) {		if (vertex == VertNumber::V1) {
return mesh.attributes().adapt_domain<float3>(		return mesh.attributes().adapt_domain<float3>(
VArray<float3>::ForFunc(edges.size(),		VArray<float3>::ForFunc(edges.size(),
[verts, edges](const int i) { return verts[edges[i].v1].co; }),		[verts, edges](const int i) { return verts[edges[i].v1].co; }),
ATTR_DOMAIN_EDGE,		ATTR_DOMAIN_EDGE,
domain);		domain);
}		}
return mesh.attributes().adapt_domain<float3>(		return mesh.attributes().adapt_domain<float3>(
VArray<float3>::ForFunc(edges.size(),		VArray<float3>::ForFunc(edges.size(),
[verts, edges](const int i) { return verts[edges[i].v2].co; }),		[verts, edges](const int i) { return verts[edges[i].v2].co; }),
ATTR_DOMAIN_EDGE,		ATTR_DOMAIN_EDGE,
domain);		domain);
}		}

class EdgePositionFieldInput final : public bke::MeshFieldInput {		class EdgePositionFieldInput final : public bke::MeshFieldInput {
private:		private:
VertexNumber vertex_;		VertNumber vertex_;

public:		public:
EdgePositionFieldInput(VertexNumber vertex)		EdgePositionFieldInput(VertNumber vertex)
: bke::MeshFieldInput(CPPType::get<float3>(), "Edge Position Field"), vertex_(vertex)		: bke::MeshFieldInput(CPPType::get<float3>(), "Edge Position Field"), vertex_(vertex)
{		{
category_ = Category::Generated;		category_ = Category::Generated;
}		}

GVArray get_varray_for_context(const Mesh &mesh,		GVArray get_varray_for_context(const Mesh &mesh,
const eAttrDomain domain,		const eAttrDomain domain,
IndexMask UNUSED(mask)) const final		IndexMask UNUSED(mask)) const final
{		{
return construct_edge_positions_gvarray(mesh, vertex_, domain);		return construct_edge_positions_gvarray(mesh, vertex_, domain);
}		}

uint64_t hash() const override		uint64_t hash() const override
{		{
return vertex_ == VERTEX_ONE ? 987456978362 : 374587679866;		return vertex_ == VertNumber::V1 ? 987456978362 : 374587679866;
}		}

bool is_equal_to(const fn::FieldNode &other) const override		bool is_equal_to(const fn::FieldNode &other) const override
{		{
if (const EdgePositionFieldInput other_field = dynamic_cast<const EdgePositionFieldInput >(		if (const EdgePositionFieldInput other_field = dynamic_cast<const EdgePositionFieldInput >(
&other)) {		&other)) {
return vertex_ == other_field->vertex_;		return vertex_ == other_field->vertex_;
}		}
return false;		return false;
}		}

		std::optional<eAttrDomain> preferred_domain(const Mesh & /mesh/) const override
		{
		return ATTR_DOMAIN_EDGE;
		}
};		};

static void node_geo_exec(GeoNodeExecParams params)		static void node_geo_exec(GeoNodeExecParams params)
{		{
Field<int> vertex_field_1{std::make_shared<EdgeVerticesFieldInput>(VERTEX_ONE)};		Field<int> vertex_field_1{std::make_shared<EdgeVertsInput>(VertNumber::V1)};
Field<int> vertex_field_2{std::make_shared<EdgeVerticesFieldInput>(VERTEX_TWO)};		Field<int> vertex_field_2{std::make_shared<EdgeVertsInput>(VertNumber::V2)};
Field<float3> position_field_1{std::make_shared<EdgePositionFieldInput>(VERTEX_ONE)};		Field<float3> position_field_1{std::make_shared<EdgePositionFieldInput>(VertNumber::V1)};
Field<float3> position_field_2{std::make_shared<EdgePositionFieldInput>(VERTEX_TWO)};		Field<float3> position_field_2{std::make_shared<EdgePositionFieldInput>(VertNumber::V2)};

params.set_output("Vertex Index 1", std::move(vertex_field_1));		params.set_output("Vertex Index 1", std::move(vertex_field_1));
params.set_output("Vertex Index 2", std::move(vertex_field_2));		params.set_output("Vertex Index 2", std::move(vertex_field_2));
params.set_output("Position 1", std::move(position_field_1));		params.set_output("Position 1", std::move(position_field_1));
params.set_output("Position 2", std::move(position_field_2));		params.set_output("Position 2", std::move(position_field_2));
}		}

} // namespace blender::nodes::node_geo_input_mesh_edge_vertices_cc		} // namespace blender::nodes::node_geo_input_mesh_edge_vertices_cc
Show All 11 Lines