Rename face normals to boundary normals

Author: aaronfranke

addons/nd/doc_classes/ArrayCellMeshND.xml

@@ -30,8 +30,8 @@
 		<member name="dimension" type="int" setter="set_dimension" getter="get_dimension" default="0">
 			The dimension of the mesh. This is calculated as the length of the first vertex. Setting this will resize all vertices to the new dimension, either truncating them or padding them with zeros as necessary. The amount of indices making up a simplex cell is equal to the dimension.
 		</member>
-		<member name="simplex_cell_face_normals" type="PackedFloat64Array[]" setter="set_simplex_cell_face_normals" getter="get_simplex_cell_face_normals" default="[]">
-			The normals of the simplex cells. Face normals define which side of the cell is the front side, and therefore should be drawn. Face normals can also be used to calculate vertex normals to determine how lighting angles are calculated for the cell. Each VectorN ([PackedFloat64Array]) in this array is for one cell, and should be normalized. This array should either be one-Nth as long as the [member cell_indices] array, or empty for no normals, or else the mesh is invalid.
+		<member name="simplex_cell_boundary_normals" type="PackedFloat64Array[]" setter="set_simplex_cell_boundary_normals" getter="get_simplex_cell_boundary_normals" default="[]">
+			The boundary normals of the simplex cells. Boundary normals define which side of the cell is the front side, and therefore should be drawn. Boundary normals can also be used to calculate vertex normals to determine how lighting angles are calculated for the cell. Each VectorN ([PackedFloat64Array]) in this array is for one cell, and should be normalized. This array should either be one-Nth as long as the [member cell_indices] array, or empty for no normals, or else the mesh is invalid.
 		</member>
 		<member name="simplex_cell_indices" type="PackedInt32Array" setter="set_simplex_cell_indices" getter="get_simplex_cell_indices" default="PackedInt32Array()">
 			The indices of the cell cells. Every 4 integers defines a cell cell. Each integer is an index to the [member vertices] array. Integers in this array should not exceed the length of the vertices array, or else the mesh is invalid.

addons/nd/doc_classes/CellMeshND.xml

@@ -10,10 +10,10 @@
 	<tutorials>
 	</tutorials>
 	<methods>
-		<method name="_get_simplex_cell_face_normals" qualifiers="virtual">
+		<method name="_get_simplex_cell_boundary_normals" qualifiers="virtual">
 			<return type="PackedFloat64Array[]" />
 			<description>
-				Callback method that should return the face normals of the simplex cells. Do not call this method. This can be overridden by derived classes when creating a custom mesh type in GDScript or another scripting language. See [method get_cell_face_normals] for details of the returned data.
+				Callback method that should return the boundary normals of the simplex cells. Do not call this method. This can be overridden by derived classes when creating a custom mesh type in GDScript or another scripting language. See [method get_cell_boundary_normals] for details of the returned data.
 			</description>
 		</method>
 		<method name="_get_simplex_cell_indices" qualifiers="virtual">
@@ -49,16 +49,16 @@
 				Gets the number of indices per cell. This is the number of vertices that make up a cell. For example, a triangle has 3 vertices, so the number of indices per cell is 3. The total number of indices in the [method get_cell_indices] array is equal to this value multiplied by [method get_cell_count].
 			</description>
 		</method>
-		<method name="get_simplex_cell_count">
-			<return type="int" />
+		<method name="get_simplex_cell_boundary_normals">
+			<return type="PackedFloat64Array[]" />
 			<description>
-				Gets the number of simplex cells in the cell mesh. Each simplex cell has [method get_indices_per_cell] vertex indices. Multiplying these together gives the length of the [method get_cell_indices] array.
+				Gets the boundary normals of the simplex cells. Normals define which side of the cell is the front side, and therefore should be drawn. Boundary normals can also be used to calculate vertex normals to determine how lighting angles are calculated for the cell. Each VectorN ([PackedFloat64Array]) in this array is for one cell, and should be normalized. This array should either be one-fourth as long as the [method get_cell_indices] array, or empty for no normals, or else the mesh is invalid.
 			</description>
 		</method>
-		<method name="get_simplex_cell_face_normals">
-			<return type="PackedFloat64Array[]" />
+		<method name="get_simplex_cell_count">
+			<return type="int" />
 			<description>
-				Gets the face normals of the simplex cells. Normals define which side of the cell is the front side, and therefore should be drawn. Face normals can also be used to calculate vertex normals to determine how lighting angles are calculated for the cell. Each VectorN ([PackedFloat64Array]) in this array is for one cell, and should be normalized. This array should either be one-fourth as long as the [method get_cell_indices] array, or empty for no normals, or else the mesh is invalid.
+				Gets the number of simplex cells in the cell mesh. Each simplex cell has [method get_indices_per_cell] vertex indices. Multiplying these together gives the length of the [method get_cell_indices] array.
 			</description>
 		</method>
 		<method name="get_simplex_cell_indices">

model/mesh/cell/array_cell_mesh_nd.cpp

@@ -13,8 +13,8 @@ bool ArrayCellMeshND::validate_mesh_data() {
 	if (cell_indices_count % dimension != 0) {
 		return false; // Must be a multiple of _dimension.
 	}
-	const int64_t cell_face_normals_count = _simplex_cell_face_normals.size();
-	if (cell_face_normals_count > 0 && cell_face_normals_count * dimension != cell_indices_count) {
+	const int64_t cell_boundary_normals_count = _simplex_cell_boundary_normals.size();
+	if (cell_boundary_normals_count > 0 && cell_boundary_normals_count * dimension != cell_indices_count) {
 		return false; // Must have one normal per cell (dimension indices).
 	}
 	const int64_t cell_vertex_normals_count = _simplex_cell_vertex_normals.size();
@@ -55,11 +55,11 @@ PackedInt32Array ArrayCellMeshND::append_vertices(const Vector<VectorN> &p_verti
 
 void ArrayCellMeshND::merge_with(const Ref<ArrayCellMeshND> &p_other, const Ref<TransformND> &p_transform) {
 	const int64_t start_cell_index_count = _simplex_cell_indices.size();
-	const int64_t start_cell_face_normal_count = _simplex_cell_face_normals.size();
+	const int64_t start_cell_face_normal_count = _simplex_cell_boundary_normals.size();
 	const int64_t start_cell_vertex_normal_count = _simplex_cell_vertex_normals.size();
 	const int64_t start_vertex_count = _vertices.size();
 	const int64_t other_cell_index_count = p_other->_simplex_cell_indices.size();
-	const int64_t other_cell_face_normal_count = p_other->_simplex_cell_face_normals.size();
+	const int64_t other_cell_face_normal_count = p_other->_simplex_cell_boundary_normals.size();
 	const int64_t other_cell_vertex_normal_count = p_other->_simplex_cell_vertex_normals.size();
 	const int64_t other_vertex_count = p_other->_vertices.size();
 	const int64_t end_cell_index_count = start_cell_index_count + other_cell_index_count;
@@ -77,23 +77,23 @@ void ArrayCellMeshND::merge_with(const Ref<ArrayCellMeshND> &p_other, const Ref<
 	// Can't simply add these together in case the first mesh has no normals.
 	if (start_cell_face_normal_count > 0 || other_cell_face_normal_count > 0) {
 		const int64_t end_cell_normal_count = end_cell_index_count / dimension;
-		_simplex_cell_face_normals.resize(end_cell_normal_count);
+		_simplex_cell_boundary_normals.resize(end_cell_normal_count);
 		const int64_t start_normal_count = start_cell_index_count / dimension;
 		// Initialize the mesh's face normals to zero if it has none.
 		if (start_cell_face_normal_count == 0) {
 			for (int64_t i = 0; i < start_normal_count; i++) {
-				_simplex_cell_face_normals.set(i, VectorN());
+				_simplex_cell_boundary_normals.set(i, VectorN());
 			}
 		}
 		if (other_cell_face_normal_count == 0) {
 			for (int64_t i = 0; i < other_cell_index_count / dimension; i++) {
-				_simplex_cell_face_normals.set(start_normal_count + i, VectorN());
+				_simplex_cell_boundary_normals.set(start_normal_count + i, VectorN());
 			}
 		}
 		// Copy in the face normals from the other mesh.
 		if (other_cell_face_normal_count > 0) {
 			for (int64_t i = 0; i < other_cell_face_normal_count; i++) {
-				_simplex_cell_face_normals.set(start_normal_count + i, p_transform->xform_basis(p_other->_simplex_cell_face_normals[i]));
+				_simplex_cell_boundary_normals.set(start_normal_count + i, p_transform->xform_basis(p_other->_simplex_cell_boundary_normals[i]));
 			}
 		}
 	}
@@ -132,20 +132,20 @@ void ArrayCellMeshND::set_simplex_cell_indices(const PackedInt32Array &p_simplex
 	reset_mesh_data_validation();
 }
 
-Vector<VectorN> ArrayCellMeshND::get_simplex_cell_face_normals() {
-	return _simplex_cell_face_normals;
+Vector<VectorN> ArrayCellMeshND::get_simplex_cell_boundary_normals() {
+	return _simplex_cell_boundary_normals;
 }
 
-void ArrayCellMeshND::set_cell_face_normals(const Vector<VectorN> &p_simplex_cell_normals) {
-	_simplex_cell_face_normals = p_simplex_cell_normals;
+void ArrayCellMeshND::set_cell_boundary_normals(const Vector<VectorN> &p_simplex_cell_normals) {
+	_simplex_cell_boundary_normals = p_simplex_cell_normals;
 	reset_mesh_data_validation();
 }
 
-void ArrayCellMeshND::set_simplex_cell_face_normals_bind(const TypedArray<VectorN> &p_simplex_cell_face_normals) {
-	_simplex_cell_face_normals.clear();
-	_simplex_cell_face_normals.resize(p_simplex_cell_face_normals.size());
-	for (int i = 0; i < p_simplex_cell_face_normals.size(); i++) {
-		_simplex_cell_face_normals.set(i, p_simplex_cell_face_normals[i]);
+void ArrayCellMeshND::set_simplex_cell_boundary_normals_bind(const TypedArray<VectorN> &p_simplex_cell_boundary_normals) {
+	_simplex_cell_boundary_normals.clear();
+	_simplex_cell_boundary_normals.resize(p_simplex_cell_boundary_normals.size());
+	for (int i = 0; i < p_simplex_cell_boundary_normals.size(); i++) {
+		_simplex_cell_boundary_normals.set(i, p_simplex_cell_boundary_normals[i]);
 	}
 	reset_mesh_data_validation();
 }
@@ -205,13 +205,13 @@ void ArrayCellMeshND::_bind_methods() {
 
 	// Only bind the setters here because the getters are already bound in CellMeshND.
 	ClassDB::bind_method(D_METHOD("set_simplex_cell_indices", "simplex_cell_indices"), &ArrayCellMeshND::set_simplex_cell_indices);
-	ClassDB::bind_method(D_METHOD("set_simplex_cell_face_normals", "simplex_cell_normals"), &ArrayCellMeshND::set_simplex_cell_face_normals_bind);
+	ClassDB::bind_method(D_METHOD("set_simplex_cell_boundary_normals", "simplex_cell_normals"), &ArrayCellMeshND::set_simplex_cell_boundary_normals_bind);
 	ClassDB::bind_method(D_METHOD("set_simplex_cell_vertex_normals", "simplex_cell_vertex_normals"), &ArrayCellMeshND::set_simplex_cell_vertex_normals_bind);
 	ClassDB::bind_method(D_METHOD("set_vertices", "vertices"), &ArrayCellMeshND::set_vertices_bind);
 	ClassDB::bind_method(D_METHOD("set_dimension", "dimension"), &ArrayCellMeshND::set_dimension);
 
 	ADD_PROPERTY(PropertyInfo(Variant::PACKED_INT32_ARRAY, "simplex_cell_indices"), "set_simplex_cell_indices", "get_simplex_cell_indices");
-	ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "simplex_cell_face_normals", PROPERTY_HINT_ARRAY_TYPE, "PackedFloat64Array"), "set_simplex_cell_face_normals", "get_simplex_cell_face_normals");
+	ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "simplex_cell_boundary_normals", PROPERTY_HINT_ARRAY_TYPE, "PackedFloat64Array"), "set_simplex_cell_boundary_normals", "get_simplex_cell_boundary_normals");
 	ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "simplex_cell_vertex_normals", PROPERTY_HINT_ARRAY_TYPE, "PackedFloat64Array"), "set_simplex_cell_vertex_normals", "get_simplex_cell_vertex_normals");
 	ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "vertices", PROPERTY_HINT_ARRAY_TYPE, "PackedFloat64Array"), "set_vertices", "get_vertices");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "dimension", PROPERTY_HINT_RANGE, "0,1000,1", PROPERTY_USAGE_EDITOR), "set_dimension", "get_dimension");

model/mesh/cell/array_cell_mesh_nd.h

@@ -7,7 +7,7 @@ class ArrayCellMeshND : public CellMeshND {
 	GDCLASS(ArrayCellMeshND, CellMeshND);
 
 	PackedInt32Array _simplex_cell_indices;
-	Vector<VectorN> _simplex_cell_face_normals;
+	Vector<VectorN> _simplex_cell_boundary_normals;
 	Vector<VectorN> _simplex_cell_vertex_normals;
 	Vector<VectorN> _vertices;
 
@@ -26,9 +26,9 @@ class ArrayCellMeshND : public CellMeshND {
 	virtual PackedInt32Array get_simplex_cell_indices() override;
 	void set_simplex_cell_indices(const PackedInt32Array &p_simplex_cell_indices);
 
-	virtual Vector<VectorN> get_simplex_cell_face_normals() override;
-	void set_cell_face_normals(const Vector<VectorN> &p_simplex_cell_face_normals);
-	void set_simplex_cell_face_normals_bind(const TypedArray<VectorN> &p_simplex_cell_face_normals);
+	virtual Vector<VectorN> get_simplex_cell_boundary_normals() override;
+	void set_cell_boundary_normals(const Vector<VectorN> &p_simplex_cell_boundary_normals);
+	void set_simplex_cell_boundary_normals_bind(const TypedArray<VectorN> &p_simplex_cell_boundary_normals);
 
 	virtual Vector<VectorN> get_simplex_cell_vertex_normals() override;
 	void set_simplex_cell_vertex_normals(const Vector<VectorN> &p_simplex_cell_vertex_normals);

model/mesh/cell/cell_mesh_nd.cpp

@@ -128,7 +128,7 @@ Ref<ArrayCellMeshND> CellMeshND::to_array_cell_mesh() {
 	array_mesh.instantiate();
 	array_mesh->set_vertices(get_vertices());
 	array_mesh->set_simplex_cell_indices(get_simplex_cell_indices());
-	array_mesh->set_cell_face_normals(get_simplex_cell_face_normals());
+	array_mesh->set_cell_boundary_normals(get_simplex_cell_boundary_normals());
 	array_mesh->set_simplex_cell_vertex_normals(get_simplex_cell_vertex_normals());
 	array_mesh->set_material(get_material());
 	return array_mesh;
@@ -164,16 +164,16 @@ Vector<VectorN> CellMeshND::get_simplex_cell_positions() {
 	return _cell_positions_cache;
 }
 
-Vector<VectorN> CellMeshND::get_simplex_cell_face_normals() {
-	TypedArray<VectorN> face_normals_bind;
-	GDVIRTUAL_CALL(_get_simplex_cell_face_normals, face_normals_bind);
-	Vector<VectorN> face_normals;
-	face_normals.resize(face_normals_bind.size());
-	for (int i = 0; i < face_normals_bind.size(); i++) {
-		const VectorN &cell_face_normal = face_normals_bind[i];
-		face_normals.set(i, cell_face_normal);
+Vector<VectorN> CellMeshND::get_simplex_cell_boundary_normals() {
+	TypedArray<VectorN> boundary_normals_bind;
+	GDVIRTUAL_CALL(_get_simplex_cell_boundary_normals, boundary_normals_bind);
+	Vector<VectorN> boundary_normals;
+	boundary_normals.resize(boundary_normals_bind.size());
+	for (int i = 0; i < boundary_normals_bind.size(); i++) {
+		const VectorN cell_face_normal = boundary_normals_bind[i];
+		boundary_normals.set(i, cell_face_normal);
 	}
-	return face_normals;
+	return boundary_normals;
 }
 
 Vector<VectorN> CellMeshND::get_simplex_cell_vertex_normals() {
@@ -182,25 +182,25 @@ Vector<VectorN> CellMeshND::get_simplex_cell_vertex_normals() {
 	Vector<VectorN> vertex_normals;
 	vertex_normals.resize(vertex_normals_bind.size());
 	for (int i = 0; i < vertex_normals_bind.size(); i++) {
-		const VectorN &cell_vertex_normal = vertex_normals_bind[i];
+		const VectorN cell_vertex_normal = vertex_normals_bind[i];
 		vertex_normals.set(i, cell_vertex_normal);
 	}
 	return vertex_normals;
 }
 
-TypedArray<VectorN> CellMeshND::get_simplex_cell_face_normals_bind() {
-	TypedArray<VectorN> face_normals_bind;
-	GDVIRTUAL_CALL(_get_simplex_cell_face_normals, face_normals_bind);
-	if (!face_normals_bind.is_empty()) {
-		return face_normals_bind;
+TypedArray<VectorN> CellMeshND::get_simplex_cell_boundary_normals_bind() {
+	TypedArray<VectorN> boundary_normals_bind;
+	GDVIRTUAL_CALL(_get_simplex_cell_boundary_normals, boundary_normals_bind);
+	if (!boundary_normals_bind.is_empty()) {
+		return boundary_normals_bind;
 	}
-	const Vector<VectorN> face_normals = get_simplex_cell_face_normals();
-	face_normals_bind.resize(face_normals.size());
-	for (int i = 0; i < face_normals.size(); i++) {
-		const VectorN &cell_face_normal = face_normals[i];
-		face_normals_bind[i] = cell_face_normal;
+	const Vector<VectorN> boundary_normals = get_simplex_cell_boundary_normals();
+	boundary_normals_bind.resize(boundary_normals.size());
+	for (int i = 0; i < boundary_normals.size(); i++) {
+		const VectorN &cell_face_normal = boundary_normals[i];
+		boundary_normals_bind[i] = cell_face_normal;
 	}
-	return face_normals_bind;
+	return boundary_normals_bind;
 }
 
 TypedArray<VectorN> CellMeshND::get_simplex_cell_vertex_normals_bind() {
@@ -263,9 +263,9 @@ Vector<PackedInt32Array> CellMeshND::decompose_polytope_cell_into_simplexes(cons
 			continue;
 		}
 		// This face is not a simplex, so we need to recurse.
-		Vector<VectorN> face_normals = p_poly_cell_normals;
-		face_normals.append(out_normals[i]);
-		Vector<PackedInt32Array> lower_simplexes = decompose_polytope_cell_into_simplexes(p_vertices, face, p_dimension - 1, pivot_item, face_normals);
+		Vector<VectorN> boundary_normals = p_poly_cell_normals;
+		boundary_normals.append(out_normals[i]);
+		Vector<PackedInt32Array> lower_simplexes = decompose_polytope_cell_into_simplexes(p_vertices, face, p_dimension - 1, pivot_item, boundary_normals);
 		for (PackedInt32Array &lower_simplex : lower_simplexes) {
 			lower_simplex.insert(0, pivot_item);
 			simplexes.append(lower_simplex);
@@ -328,10 +328,10 @@ void CellMeshND::_bind_methods() {
 
 	ClassDB::bind_static_method("CellMeshND", D_METHOD("calculate_edge_indices_from_simplex_cell_indices", "simplex_cell_indices", "dimension", "deduplicate"), &CellMeshND::calculate_edge_indices_from_simplex_cell_indices);
 	ClassDB::bind_method(D_METHOD("get_simplex_cell_indices"), &CellMeshND::get_simplex_cell_indices);
-	ClassDB::bind_method(D_METHOD("get_simplex_cell_face_normals"), &CellMeshND::get_simplex_cell_face_normals_bind);
+	ClassDB::bind_method(D_METHOD("get_simplex_cell_boundary_normals"), &CellMeshND::get_simplex_cell_boundary_normals_bind);
 	ClassDB::bind_method(D_METHOD("get_simplex_cell_vertex_normals"), &CellMeshND::get_simplex_cell_vertex_normals_bind);
 
 	GDVIRTUAL_BIND(_get_simplex_cell_indices);
-	GDVIRTUAL_BIND(_get_simplex_cell_face_normals);
+	GDVIRTUAL_BIND(_get_simplex_cell_boundary_normals);
 	GDVIRTUAL_BIND(_get_simplex_cell_vertex_normals);
 }

model/mesh/cell/cell_mesh_nd.h

@@ -27,10 +27,10 @@ class CellMeshND : public MeshND {
 	virtual int get_simplex_cell_count();
 	virtual int get_indices_per_simplex_cell();
 	virtual PackedInt32Array get_simplex_cell_indices();
-	virtual Vector<VectorN> get_simplex_cell_face_normals();
+	virtual Vector<VectorN> get_simplex_cell_boundary_normals();
 	virtual Vector<VectorN> get_simplex_cell_vertex_normals();
 	Vector<VectorN> get_simplex_cell_positions();
-	TypedArray<VectorN> get_simplex_cell_face_normals_bind();
+	TypedArray<VectorN> get_simplex_cell_boundary_normals_bind();
 	TypedArray<VectorN> get_simplex_cell_vertex_normals_bind();
 	TypedArray<VectorN> get_simplex_cell_positions_bind();
 
@@ -41,6 +41,6 @@ class CellMeshND : public MeshND {
 	virtual Vector<VectorN> get_edge_positions() override;
 
 	GDVIRTUAL0R(PackedInt32Array, _get_simplex_cell_indices);
-	GDVIRTUAL0R(TypedArray<VectorN>, _get_simplex_cell_face_normals);
+	GDVIRTUAL0R(TypedArray<VectorN>, _get_simplex_cell_boundary_normals);
 	GDVIRTUAL0R(TypedArray<VectorN>, _get_simplex_cell_vertex_normals);
 };