List functions that allows to check, enable and assert the availability of components in the Face Elements of a Mesh. More...

Collaboration diagram for Face Requirements:

Functions
template<FaceMeshConcept MeshType>
bool	vcl::isFaceContainerCompact (const MeshType &m)
	Returns `true` if the given mesh has its FaceContainer compact.

template<FaceMeshConcept MeshType>
bool	vcl::isPerFaceAdjacentEdgesAvailable (const MeshType &m)
	Returns true if the AdjacentEdges component is available (enabled) in the Face element of the input mesh m.

template<FaceMeshConcept MeshType>
bool	vcl::enableIfPerFaceAdjacentEdgesOptional (MeshType &m)
	If the input mesh has a FaceContainer, and the Face Element has a AdjacentEdges Component, this function enables the Component in the Element if the component needs to be enabled (meaning that it is optional). Returns `true` if, after the call of this function, the AdjacentEdges component will be available in the Face Element of the mesh.

template<FaceMeshConcept MeshType>
bool	vcl::isPerFaceAdjacentFacesAvailable (const MeshType &m)
	Returns true if the AdjacentFaces component is available (enabled) in the Face element of the input mesh m.

template<FaceMeshConcept MeshType>
bool	vcl::enableIfPerFaceAdjacentFacesOptional (MeshType &m)
	If the input mesh has a FaceContainer, and the Face Element has a AdjacentFaces Component, this function enables the Component in the Element if the component needs to be enabled (meaning that it is optional). Returns `true` if, after the call of this function, the AdjacentFaces component will be available in the Face Element of the mesh.

template<FaceMeshConcept MeshType>
bool	vcl::isPerFaceColorAvailable (const MeshType &m)
	Returns true if the Color component is available (enabled) in the Face element of the input mesh m.

template<FaceMeshConcept MeshType>
bool	vcl::enableIfPerFaceColorOptional (MeshType &m)
	If the input mesh has a FaceContainer, and the Face Element has a Color Component, this function enables the Component in the Element if the component needs to be enabled (meaning that it is optional). Returns `true` if, after the call of this function, the Color component will be available in the Face Element of the mesh.

template<FaceMeshConcept MeshType>
bool	vcl::isPerFaceMarkAvailable (const MeshType &m)
	Returns true if the Mark component is available (enabled) in the Face element of the input mesh m.

template<FaceMeshConcept MeshType>
bool	vcl::enableIfPerFaceMarkOptional (MeshType &m)
	If the input mesh has a FaceContainer, and the Face Element has a Mark Component, this function enables the Component in the Element if the component needs to be enabled (meaning that it is optional). Returns `true` if, after the call of this function, the Mark component will be available in the Face Element of the mesh.

template<FaceMeshConcept MeshType>
bool	vcl::isPerFaceNormalAvailable (const MeshType &m)
	Returns true if the Normal component is available (enabled) in the Face element of the input mesh m.

template<FaceMeshConcept MeshType>
bool	vcl::enableIfPerFaceNormalOptional (MeshType &m)
	If the input mesh has a FaceContainer, and the Face Element has a Normal Component, this function enables the Component in the Element if the component needs to be enabled (meaning that it is optional). Returns `true` if, after the call of this function, the Normal component will be available in the Face Element of the mesh.

template<FaceMeshConcept MeshType>
bool	vcl::isPerFacePrincipalCurvatureAvailable (const MeshType &m)
	Returns true if the PrincipalCurvature component is available (enabled) in the Face element of the input mesh m.

template<FaceMeshConcept MeshType>
bool	vcl::enableIfPerFacePrincipalCurvatureOptional (MeshType &m)
	If the input mesh has a FaceContainer, and the Face Element has a PrincipalCurvature Component, this function enables the Component in the Element if the component needs to be enabled (meaning that it is optional). Returns `true` if, after the call of this function, the PrincipalCurvature component will be available in the Face Element of the mesh.

template<FaceMeshConcept MeshType>
bool	vcl::isPerFaceQualityAvailable (const MeshType &m)
	Returns true if the Quality component is available (enabled) in the Face element of the input mesh m.

template<FaceMeshConcept MeshType>
bool	vcl::enableIfPerFaceQualityOptional (MeshType &m)
	If the input mesh has a FaceContainer, and the Face Element has a Quality Component, this function enables the Component in the Element if the component needs to be enabled (meaning that it is optional). Returns `true` if, after the call of this function, the Quality component will be available in the Face Element of the mesh.

template<FaceMeshConcept MeshType>
bool	vcl::isPerFaceWedgeColorsAvailable (const MeshType &m)
	Returns true if the WedgeColors component is available (enabled) in the Face element of the input mesh m.

template<FaceMeshConcept MeshType>
bool	vcl::enableIfPerFaceWedgeColorsOptional (MeshType &m)
	If the input mesh has a FaceContainer, and the Face Element has a WedgeColors Component, this function enables the Component in the Element if the component needs to be enabled (meaning that it is optional). Returns `true` if, after the call of this function, the WedgeColors component will be available in the Face Element of the mesh.

template<FaceMeshConcept MeshType>
bool	vcl::isPerFaceWedgeTexCoordsAvailable (const MeshType &m)
	Returns true if the WedgeTexCoords component is available (enabled) in the Face element of the input mesh m.

template<FaceMeshConcept MeshType>
bool	vcl::enableIfPerFaceWedgeTexCoordsOptional (MeshType &m)
	If the input mesh has a FaceContainer, and the Face Element has a WedgeTexCoords Component, this function enables the Component in the Element if the component needs to be enabled (meaning that it is optional). Returns `true` if, after the call of this function, the WedgeTexCoords component will be available in the Face Element of the mesh.

template<FaceMeshConcept MeshType>
void	vcl::requireFaceContainerCompactness (const MeshType &m)
	This function asserts that a Mesh has the FaceContainer compact (no elements flagged as deleted).

template<FaceMeshConcept MeshType> requires HasPerFaceAdjacentEdges<MeshType>
void	vcl::requirePerFaceAdjacentEdges (const MeshType &m)
	This function asserts that a Mesh has a FaceContainer, the Face has a AdjacentEdges Component, and that the AdjacentEdges Component is enabled and available at runtime.

template<FaceMeshConcept MeshType> requires HasPerFaceAdjacentFaces<MeshType>
void	vcl::requirePerFaceAdjacentFaces (const MeshType &m)
	This function asserts that a Mesh has a FaceContainer, the Face has a AdjacentFaces Component, and that the AdjacentFaces Component is enabled and available at runtime.

template<FaceMeshConcept MeshType> requires HasPerFaceColor<MeshType>
void	vcl::requirePerFaceColor (const MeshType &m)
	This function asserts that a Mesh has a FaceContainer, the Face has a Color Component, and that the Color Component is enabled and available at runtime.

template<FaceMeshConcept MeshType> requires HasPerFaceMark<MeshType>
void	vcl::requirePerFaceMark (const MeshType &m)
	This function asserts that a Mesh has a FaceContainer, the Face has a Mark Component, and that the Mark Component is enabled and available at runtime.

template<FaceMeshConcept MeshType> requires HasPerFaceNormal<MeshType>
void	vcl::requirePerFaceNormal (const MeshType &m)
	This function asserts that a Mesh has a FaceContainer, the Face has a Normal Component, and that the Normal Component is enabled and available at runtime.

template<FaceMeshConcept MeshType> requires HasPerFacePrincipalCurvature<MeshType>
void	vcl::requirePerFacePrincipalCurvature (const MeshType &m)
	This function asserts that a Mesh has a FaceContainer, the Face has a PrincipalCurvature Component, and that the PrincipalCurvature Component is enabled and available at runtime.

template<FaceMeshConcept MeshType> requires HasPerFaceQuality<MeshType>
void	vcl::requirePerFaceQuality (const MeshType &m)
	This function asserts that a Mesh has a FaceContainer, the Face has a Quality Component, and that the Quality Component is enabled and available at runtime.

template<FaceMeshConcept MeshType> requires HasPerFaceWedgeColors<MeshType>
void	vcl::requirePerFaceWedgeColors (const MeshType &m)
	This function asserts that a Mesh has a FaceContainer, the Face has a WedgeColors Component, and that the WedgeColors Component is enabled and available at runtime.

template<FaceMeshConcept MeshType> requires HasPerFaceWedgeTexCoords<MeshType>
void	vcl::requirePerFaceWedgeTexCoords (const MeshType &m)
	This function asserts that a Mesh has a FaceContainer, the Face has a WedgeTexCoords Component, and that the WedgeTexCoords Component is enabled and available at runtime.

Detailed Description

List functions that allows to check, enable and assert the availability of components in the Face Elements of a Mesh.

Function Documentation

◆ enableIfPerFaceAdjacentEdgesOptional()

template<FaceMeshConcept MeshType>

bool vcl::enableIfPerFaceAdjacentEdgesOptional ( MeshType & m )

If the input mesh has a FaceContainer, and the Face Element has a AdjacentEdges Component, this function enables the Component in the Element if the component needs to be enabled (meaning that it is optional). Returns true if, after the call of this function, the AdjacentEdges component will be available in the Face Element of the mesh.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Parameters

[in] m the mesh on which enable the AdjacentEdges component in the Face Element.

Returns: true if the AdjacentEdges Component is available in the FaceElement after the call of this funciton.

◆ enableIfPerFaceAdjacentFacesOptional()

template<FaceMeshConcept MeshType>

bool vcl::enableIfPerFaceAdjacentFacesOptional ( MeshType & m )

If the input mesh has a FaceContainer, and the Face Element has a AdjacentFaces Component, this function enables the Component in the Element if the component needs to be enabled (meaning that it is optional). Returns true if, after the call of this function, the AdjacentFaces component will be available in the Face Element of the mesh.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Parameters

[in] m the mesh on which enable the AdjacentFaces component in the Face Element.

Returns: true if the AdjacentFaces Component is available in the FaceElement after the call of this funciton.

◆ enableIfPerFaceColorOptional()

template<FaceMeshConcept MeshType>

bool vcl::enableIfPerFaceColorOptional ( MeshType & m )

If the input mesh has a FaceContainer, and the Face Element has a Color Component, this function enables the Component in the Element if the component needs to be enabled (meaning that it is optional). Returns true if, after the call of this function, the Color component will be available in the Face Element of the mesh.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Parameters

[in] m the mesh on which enable the Color component in the Face Element.

Returns: true if the Color Component is available in the FaceElement after the call of this funciton.

◆ enableIfPerFaceMarkOptional()

template<FaceMeshConcept MeshType>

bool vcl::enableIfPerFaceMarkOptional ( MeshType & m )

If the input mesh has a FaceContainer, and the Face Element has a Mark Component, this function enables the Component in the Element if the component needs to be enabled (meaning that it is optional). Returns true if, after the call of this function, the Mark component will be available in the Face Element of the mesh.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Parameters

[in] m the mesh on which enable the Mark component in the Face Element.

Returns: true if the Mark Component is available in the FaceElement after the call of this funciton.

◆ enableIfPerFaceNormalOptional()

template<FaceMeshConcept MeshType>

bool vcl::enableIfPerFaceNormalOptional ( MeshType & m )

If the input mesh has a FaceContainer, and the Face Element has a Normal Component, this function enables the Component in the Element if the component needs to be enabled (meaning that it is optional). Returns true if, after the call of this function, the Normal component will be available in the Face Element of the mesh.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Parameters

[in] m the mesh on which enable the Normal component in the Face Element.

Returns: true if the Normal Component is available in the FaceElement after the call of this funciton.

◆ enableIfPerFacePrincipalCurvatureOptional()

template<FaceMeshConcept MeshType>

bool vcl::enableIfPerFacePrincipalCurvatureOptional ( MeshType & m )

If the input mesh has a FaceContainer, and the Face Element has a PrincipalCurvature Component, this function enables the Component in the Element if the component needs to be enabled (meaning that it is optional). Returns true if, after the call of this function, the PrincipalCurvature component will be available in the Face Element of the mesh.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Parameters

[in] m the mesh on which enable the PrincipalCurvature component in the Face Element.

Returns: true if the PrincipalCurvature Component is available in the FaceElement after the call of this funciton.

◆ enableIfPerFaceQualityOptional()

template<FaceMeshConcept MeshType>

bool vcl::enableIfPerFaceQualityOptional ( MeshType & m )

If the input mesh has a FaceContainer, and the Face Element has a Quality Component, this function enables the Component in the Element if the component needs to be enabled (meaning that it is optional). Returns true if, after the call of this function, the Quality component will be available in the Face Element of the mesh.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Parameters

[in] m the mesh on which enable the Quality component in the Face Element.

Returns: true if the Quality Component is available in the FaceElement after the call of this funciton.

◆ enableIfPerFaceWedgeColorsOptional()

template<FaceMeshConcept MeshType>

bool vcl::enableIfPerFaceWedgeColorsOptional ( MeshType & m )

If the input mesh has a FaceContainer, and the Face Element has a WedgeColors Component, this function enables the Component in the Element if the component needs to be enabled (meaning that it is optional). Returns true if, after the call of this function, the WedgeColors component will be available in the Face Element of the mesh.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Parameters

[in] m the mesh on which enable the WedgeColors component in the Face Element.

Returns: true if the WedgeColors Component is available in the FaceElement after the call of this funciton.

◆ enableIfPerFaceWedgeTexCoordsOptional()

template<FaceMeshConcept MeshType>

bool vcl::enableIfPerFaceWedgeTexCoordsOptional ( MeshType & m )

If the input mesh has a FaceContainer, and the Face Element has a WedgeTexCoords Component, this function enables the Component in the Element if the component needs to be enabled (meaning that it is optional). Returns true if, after the call of this function, the WedgeTexCoords component will be available in the Face Element of the mesh.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Parameters

[in] m the mesh on which enable the WedgeTexCoords component in the Face Element.

Returns: true if the WedgeTexCoords Component is available in the FaceElement after the call of this funciton.

◆ isFaceContainerCompact()

template<FaceMeshConcept MeshType>

bool vcl::isFaceContainerCompact ( const MeshType & m )

Returns true if the given mesh has its FaceContainer compact.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Parameters

m	the mesh on which check the compactness of the FaceContainer.

Returns: true if the FaceContainer is compact.

◆ isPerFaceAdjacentEdgesAvailable()

template<FaceMeshConcept MeshType>

bool vcl::isPerFaceAdjacentEdgesAvailable ( const MeshType & m )

Returns true if the AdjacentEdges component is available (enabled) in the Face element of the input mesh m.

This function returns true when the AdjacentEdges component can be used on the element, whether the component is horizontal, vertical or optional.

These are the following cases:

if the Face Element does not have a AdjacentEdges Component, the function returns false;
if the Face Element has a non-optional AdjacentEdges Component, the function returns true;
if the Face Element has an optional AdjacentEdges Component, the function returns true if the AdjacentEdges component is enabled, false otherwise (this check is the only one that is made at runtime);

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Parameters

[in] m the mesh on which check the availability of the AdjacentEdges Component in the Face Element.

Returns: true if the AdjacentEdges Component is available in the Face Element of the given Mesh.

◆ isPerFaceAdjacentFacesAvailable()

template<FaceMeshConcept MeshType>

bool vcl::isPerFaceAdjacentFacesAvailable ( const MeshType & m )

Returns true if the AdjacentFaces component is available (enabled) in the Face element of the input mesh m.

This function returns true when the AdjacentFaces component can be used on the element, whether the component is horizontal, vertical or optional.

These are the following cases:

if the Face Element does not have a AdjacentFaces Component, the function returns false;
if the Face Element has a non-optional AdjacentFaces Component, the function returns true;
if the Face Element has an optional AdjacentFaces Component, the function returns true if the AdjacentFaces component is enabled, false otherwise (this check is the only one that is made at runtime);

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Parameters

[in] m the mesh on which check the availability of the AdjacentFaces Component in the Face Element.

Returns: true if the AdjacentFaces Component is available in the Face Element of the given Mesh.

◆ isPerFaceColorAvailable()

template<FaceMeshConcept MeshType>

bool vcl::isPerFaceColorAvailable ( const MeshType & m )

Returns true if the Color component is available (enabled) in the Face element of the input mesh m.

This function returns true when the Color component can be used on the element, whether the component is horizontal, vertical or optional.

These are the following cases:

if the Face Element does not have a Color Component, the function returns false;
if the Face Element has a non-optional Color Component, the function returns true;
if the Face Element has an optional Color Component, the function returns true if the Color component is enabled, false otherwise (this check is the only one that is made at runtime);

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Parameters

[in] m the mesh on which check the availability of the Color Component in the Face Element.

Returns: true if the Color Component is available in the Face Element of the given Mesh.

◆ isPerFaceMarkAvailable()

template<FaceMeshConcept MeshType>

bool vcl::isPerFaceMarkAvailable ( const MeshType & m )

Returns true if the Mark component is available (enabled) in the Face element of the input mesh m.

This function returns true when the Mark component can be used on the element, whether the component is horizontal, vertical or optional.

These are the following cases:

if the Face Element does not have a Mark Component, the function returns false;
if the Face Element has a non-optional Mark Component, the function returns true;
if the Face Element has an optional Mark Component, the function returns true if the Mark component is enabled, false otherwise (this check is the only one that is made at runtime);

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Parameters

[in] m the mesh on which check the availability of the Mark Component in the Face Element.

Returns: true if the Mark Component is available in the Face Element of the given Mesh.

◆ isPerFaceNormalAvailable()

template<FaceMeshConcept MeshType>

bool vcl::isPerFaceNormalAvailable ( const MeshType & m )

Returns true if the Normal component is available (enabled) in the Face element of the input mesh m.

This function returns true when the Normal component can be used on the element, whether the component is horizontal, vertical or optional.

These are the following cases:

if the Face Element does not have a Normal Component, the function returns false;
if the Face Element has a non-optional Normal Component, the function returns true;
if the Face Element has an optional Normal Component, the function returns true if the Normal component is enabled, false otherwise (this check is the only one that is made at runtime);

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Parameters

[in] m the mesh on which check the availability of the Normal Component in the Face Element.

Returns: true if the Normal Component is available in the Face Element of the given Mesh.

◆ isPerFacePrincipalCurvatureAvailable()

template<FaceMeshConcept MeshType>

bool vcl::isPerFacePrincipalCurvatureAvailable ( const MeshType & m )

Returns true if the PrincipalCurvature component is available (enabled) in the Face element of the input mesh m.

This function returns true when the PrincipalCurvature component can be used on the element, whether the component is horizontal, vertical or optional.

These are the following cases:

if the Face Element does not have a PrincipalCurvature Component, the function returns false;
if the Face Element has a non-optional PrincipalCurvature Component, the function returns true;
if the Face Element has an optional PrincipalCurvature Component, the function returns true if the PrincipalCurvature component is enabled, false otherwise (this check is the only one that is made at runtime);

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Parameters

[in] m the mesh on which check the availability of the PrincipalCurvature Component in the Face Element.

Returns: true if the PrincipalCurvature Component is available in the Face Element of the given Mesh.

◆ isPerFaceQualityAvailable()

template<FaceMeshConcept MeshType>

bool vcl::isPerFaceQualityAvailable ( const MeshType & m )

Returns true if the Quality component is available (enabled) in the Face element of the input mesh m.

This function returns true when the Quality component can be used on the element, whether the component is horizontal, vertical or optional.

These are the following cases:

if the Face Element does not have a Quality Component, the function returns false;
if the Face Element has a non-optional Quality Component, the function returns true;
if the Face Element has an optional Quality Component, the function returns true if the Quality component is enabled, false otherwise (this check is the only one that is made at runtime);

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Parameters

[in] m the mesh on which check the availability of the Quality Component in the Face Element.

Returns: true if the Quality Component is available in the Face Element of the given Mesh.

◆ isPerFaceWedgeColorsAvailable()

template<FaceMeshConcept MeshType>

bool vcl::isPerFaceWedgeColorsAvailable ( const MeshType & m )

Returns true if the WedgeColors component is available (enabled) in the Face element of the input mesh m.

This function returns true when the WedgeColors component can be used on the element, whether the component is horizontal, vertical or optional.

These are the following cases:

if the Face Element does not have a WedgeColors Component, the function returns false;
if the Face Element has a non-optional WedgeColors Component, the function returns true;
if the Face Element has an optional WedgeColors Component, the function returns true if the WedgeColors component is enabled, false otherwise (this check is the only one that is made at runtime);

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Parameters

[in] m the mesh on which check the availability of the WedgeColors Component in the Face Element.

Returns: true if the WedgeColors Component is available in the Face Element of the given Mesh.

◆ isPerFaceWedgeTexCoordsAvailable()

template<FaceMeshConcept MeshType>

bool vcl::isPerFaceWedgeTexCoordsAvailable ( const MeshType & m )

Returns true if the WedgeTexCoords component is available (enabled) in the Face element of the input mesh m.

This function returns true when the WedgeTexCoords component can be used on the element, whether the component is horizontal, vertical or optional.

These are the following cases:

if the Face Element does not have a WedgeTexCoords Component, the function returns false;
if the Face Element has a non-optional WedgeTexCoords Component, the function returns true;
if the Face Element has an optional WedgeTexCoords Component, the function returns true if the WedgeTexCoords component is enabled, false otherwise (this check is the only one that is made at runtime);

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Parameters

[in] m the mesh on which check the availability of the WedgeTexCoords Component in the Face Element.

Returns: true if the WedgeTexCoords Component is available in the Face Element of the given Mesh.

◆ requireFaceContainerCompactness()

template<FaceMeshConcept MeshType>

void vcl::requireFaceContainerCompactness ( const MeshType & m )

This function asserts that a Mesh has the FaceContainer compact (no elements flagged as deleted).

If the FaceContainer is not compact, a vcl::MissingCompactnessException will be thrown.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Exceptions

vcl::MissingCompactnessException if the FaceContainer is not compact.

Parameters

[in] m the mesh on which check the compactness of the FaceContainer.

◆ requirePerFaceAdjacentEdges()

template<FaceMeshConcept MeshType>
requires HasPerFaceAdjacentEdges<MeshType>

void vcl::requirePerFaceAdjacentEdges ( const MeshType & m )

This function asserts that a Mesh has a FaceContainer, the Face has a AdjacentEdges Component, and that the AdjacentEdges Component is enabled and available at runtime.

If the Mesh:

has not a Container of the given ElementEnumType;
has the Container but the Element has not a Component of the given ComponentEnumType; a build error will be generated.

If the Mesh:

has the Face Container, the Face has the AdjacentEdges Component, but the Component is not enabled, a vcl::MissingComponentException will be thrown.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Exceptions

vcl::MissingComponentException if the AdjacentEdges Component is not enabled in the FaceContainer of the Mesh.

Parameters

[in] m the mesh on which check the availability of the AdjacentEdges Component in the Face.

◆ requirePerFaceAdjacentFaces()

template<FaceMeshConcept MeshType>
requires HasPerFaceAdjacentFaces<MeshType>

void vcl::requirePerFaceAdjacentFaces ( const MeshType & m )

This function asserts that a Mesh has a FaceContainer, the Face has a AdjacentFaces Component, and that the AdjacentFaces Component is enabled and available at runtime.

If the Mesh:

has not a Container of the given ElementEnumType;
has the Container but the Element has not a Component of the given ComponentEnumType; a build error will be generated.

If the Mesh:

has the Face Container, the Face has the AdjacentFaces Component, but the Component is not enabled, a vcl::MissingComponentException will be thrown.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Exceptions

vcl::MissingComponentException if the AdjacentFaces Component is not enabled in the FaceContainer of the Mesh.

Parameters

[in] m the mesh on which check the availability of the AdjacentFaces Component in the Face.

◆ requirePerFaceColor()

template<FaceMeshConcept MeshType>
requires HasPerFaceColor<MeshType>

void vcl::requirePerFaceColor ( const MeshType & m )

This function asserts that a Mesh has a FaceContainer, the Face has a Color Component, and that the Color Component is enabled and available at runtime.

If the Mesh:

has not a Container of the given ElementEnumType;
has the Container but the Element has not a Component of the given ComponentEnumType; a build error will be generated.

If the Mesh:

has the Face Container, the Face has the Color Component, but the Component is not enabled, a vcl::MissingComponentException will be thrown.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Exceptions

vcl::MissingComponentException if the Color Component is not enabled in the FaceContainer of the Mesh.

Parameters

[in] m the mesh on which check the availability of the Color Component in the Face.

◆ requirePerFaceMark()

template<FaceMeshConcept MeshType>
requires HasPerFaceMark<MeshType>

void vcl::requirePerFaceMark ( const MeshType & m )

This function asserts that a Mesh has a FaceContainer, the Face has a Mark Component, and that the Mark Component is enabled and available at runtime.

If the Mesh:

has not a Container of the given ElementEnumType;
has the Container but the Element has not a Component of the given ComponentEnumType; a build error will be generated.

If the Mesh:

has the Face Container, the Face has the Mark Component, but the Component is not enabled, a vcl::MissingComponentException will be thrown.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Exceptions

vcl::MissingComponentException if the Mark Component is not enabled in the FaceContainer of the Mesh.

Parameters

[in] m the mesh on which check the availability of the Mark Component in the Face.

◆ requirePerFaceNormal()

template<FaceMeshConcept MeshType>
requires HasPerFaceNormal<MeshType>

void vcl::requirePerFaceNormal ( const MeshType & m )

This function asserts that a Mesh has a FaceContainer, the Face has a Normal Component, and that the Normal Component is enabled and available at runtime.

If the Mesh:

has not a Container of the given ElementEnumType;
has the Container but the Element has not a Component of the given ComponentEnumType; a build error will be generated.

If the Mesh:

has the Face Container, the Face has the Normal Component, but the Component is not enabled, a vcl::MissingComponentException will be thrown.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Exceptions

vcl::MissingComponentException if the Normal Component is not enabled in the FaceContainer of the Mesh.

Parameters

[in] m the mesh on which check the availability of the Normal Component in the Face.

◆ requirePerFacePrincipalCurvature()

template<FaceMeshConcept MeshType>
requires HasPerFacePrincipalCurvature<MeshType>

void vcl::requirePerFacePrincipalCurvature ( const MeshType & m )

This function asserts that a Mesh has a FaceContainer, the Face has a PrincipalCurvature Component, and that the PrincipalCurvature Component is enabled and available at runtime.

If the Mesh:

has not a Container of the given ElementEnumType;
has the Container but the Element has not a Component of the given ComponentEnumType; a build error will be generated.

If the Mesh:

has the Face Container, the Face has the PrincipalCurvature Component, but the Component is not enabled, a vcl::MissingComponentException will be thrown.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Exceptions

vcl::MissingComponentException if the PrincipalCurvature Component is not enabled in the FaceContainer of the Mesh.

Parameters

[in] m the mesh on which check the availability of the PrincipalCurvature Component in the Face.

◆ requirePerFaceQuality()

template<FaceMeshConcept MeshType>
requires HasPerFaceQuality<MeshType>

void vcl::requirePerFaceQuality ( const MeshType & m )

This function asserts that a Mesh has a FaceContainer, the Face has a Quality Component, and that the Quality Component is enabled and available at runtime.

If the Mesh:

has not a Container of the given ElementEnumType;
has the Container but the Element has not a Component of the given ComponentEnumType; a build error will be generated.

If the Mesh:

has the Face Container, the Face has the Quality Component, but the Component is not enabled, a vcl::MissingComponentException will be thrown.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Exceptions

vcl::MissingComponentException if the Quality Component is not enabled in the FaceContainer of the Mesh.

Parameters

[in] m the mesh on which check the availability of the Quality Component in the Face.

◆ requirePerFaceWedgeColors()

template<FaceMeshConcept MeshType>
requires HasPerFaceWedgeColors<MeshType>

void vcl::requirePerFaceWedgeColors ( const MeshType & m )

This function asserts that a Mesh has a FaceContainer, the Face has a WedgeColors Component, and that the WedgeColors Component is enabled and available at runtime.

If the Mesh:

has not a Container of the given ElementEnumType;
has the Container but the Element has not a Component of the given ComponentEnumType; a build error will be generated.

If the Mesh:

has the Face Container, the Face has the WedgeColors Component, but the Component is not enabled, a vcl::MissingComponentException will be thrown.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Exceptions

vcl::MissingComponentException if the WedgeColors Component is not enabled in the FaceContainer of the Mesh.

Parameters

[in] m the mesh on which check the availability of the WedgeColors Component in the Face.

◆ requirePerFaceWedgeTexCoords()

template<FaceMeshConcept MeshType>
requires HasPerFaceWedgeTexCoords<MeshType>

void vcl::requirePerFaceWedgeTexCoords ( const MeshType & m )

This function asserts that a Mesh has a FaceContainer, the Face has a WedgeTexCoords Component, and that the WedgeTexCoords Component is enabled and available at runtime.

If the Mesh:

has not a Container of the given ElementEnumType;
has the Container but the Element has not a Component of the given ComponentEnumType; a build error will be generated.

If the Mesh:

has the Face Container, the Face has the WedgeTexCoords Component, but the Component is not enabled, a vcl::MissingComponentException will be thrown.

Template Parameters

MeshType the type of the Mesh to check, it must satisfy the FaceMeshConcept.

Exceptions

vcl::MissingComponentException if the WedgeTexCoords Component is not enabled in the FaceContainer of the Mesh.

Parameters

[in] m the mesh on which check the availability of the WedgeTexCoords Component in the Face.

Functions

Detailed Description

Function Documentation

◆ enableIfPerFaceAdjacentEdgesOptional()

◆ enableIfPerFaceAdjacentFacesOptional()

◆ enableIfPerFaceColorOptional()

◆ enableIfPerFaceMarkOptional()

◆ enableIfPerFaceNormalOptional()

◆ enableIfPerFacePrincipalCurvatureOptional()

◆ enableIfPerFaceQualityOptional()

◆ enableIfPerFaceWedgeColorsOptional()

◆ enableIfPerFaceWedgeTexCoordsOptional()

◆ isFaceContainerCompact()

◆ isPerFaceAdjacentEdgesAvailable()

◆ isPerFaceAdjacentFacesAvailable()

◆ isPerFaceColorAvailable()

◆ isPerFaceMarkAvailable()

◆ isPerFaceNormalAvailable()

◆ isPerFacePrincipalCurvatureAvailable()

◆ isPerFaceQualityAvailable()

◆ isPerFaceWedgeColorsAvailable()

◆ isPerFaceWedgeTexCoordsAvailable()

◆ requireFaceContainerCompactness()

◆ requirePerFaceAdjacentEdges()

◆ requirePerFaceAdjacentFaces()

◆ requirePerFaceColor()

◆ requirePerFaceMark()

◆ requirePerFaceNormal()

◆ requirePerFacePrincipalCurvature()

◆ requirePerFaceQuality()

◆ requirePerFaceWedgeColors()

◆ requirePerFaceWedgeTexCoords()