#include <EncodePreparator.h>

Public Types
enum	IndexSharing { INDICES_SEPARATE_FOR_ALL_VERTEX_ATTRIBUTES = 0, INDICES_SAME_FOR_VERTICES_AND_NORMALS = (1 << 0), INDICES_SAME_FOR_VERTICES_AND_FIRST_UV_SET = (1 << 1), INDICES_SAME_FOR_VERTICES_AND_ALL_UV_SETS = (1 << 2) \| INDICES_SAME_FOR_VERTICES_AND_FIRST_UV_SET, INDICES_SAME_FOR_VERTICES_AND_NORMALS_AND_FIRST_UV_SET = INDICES_SAME_FOR_VERTICES_AND_NORMALS \| INDICES_SAME_FOR_VERTICES_AND_FIRST_UV_SET, INDICES_SAME_FOR_ALL_VERTEX_ATTRIBUTES = INDICES_SAME_FOR_VERTICES_AND_NORMALS \| INDICES_SAME_FOR_VERTICES_AND_ALL_UV_SETS }

Public Member Functions
PreparationFlags &	atlasAddWrapBorder (bool v)

bool	atlasAddWrapBorder () const

PreparationFlags &	atlasRepeatingTextures (bool v)

bool	atlasRepeatingTextures () const

PreparationFlags &	cleanupUVs (bool v)

bool	cleanupUVs () const

PreparationFlags &	cleanupVertexNormals (bool v)

bool	cleanupVertexNormals () const

PreparationFlags &	createTextureAtlases (bool v)

bool	createTextureAtlases () const

PreparationFlags &	cutoutTextures (bool v)

bool	cutoutTextures () const

PreparationFlags &	determineMeshProperties (bool v)

bool	determineMeshProperties () const

PreparationFlags &	forceAtlasing (bool v)

bool	forceAtlasing () const

PreparationFlags &	indexSharing (IndexSharing v)

IndexSharing	indexSharing () const

PreparationFlags &	instancing (bool v)

bool	instancing () const

PreparationFlags &	maxAtlasDim (int v)

int	maxAtlasDim () const

PreparationFlags &	maxTexSize (uint32_t v)

uint32_t	maxTexSize () const

PreparationFlags &	mergeByMaterial (bool v)

bool	mergeByMaterial () const

PreparationFlags &	mergeToleranceNormals (float v)

float	mergeToleranceNormals () const

PreparationFlags &	mergeToleranceUVs (float v)

float	mergeToleranceUVs () const

PreparationFlags &	mergeToleranceVertices (float v)

float	mergeToleranceVertices () const

PreparationFlags &	mergeVertices (bool v)

bool	mergeVertices () const

PreparationFlags &	meshMerging (MeshMerging::Action v)

MeshMerging::Action	meshMerging () const

PreparationFlags &	offset (double x, double y, double z)

PreparationFlags &	offset (const double *xyz)

const double *	offset () const

PreparationFlags &	processHoles (HoleProcessor::Action v)

HoleProcessor::Action	processHoles () const

PreparationFlags &	processVertexNormals (VertexNormalProcessor::Action v)

VertexNormalProcessor::Action	processVertexNormals () const

PreparationFlags &	triangulate (bool v)

bool	triangulate () const

Detailed Description

Container class for the preparation flags. This class provides a number of chainable setters to control the preparation process.

See also: prtx::EncodePreparator::fetchFinalizedInstances()

Member Enumeration Documentation

◆ IndexSharing

enum prtx::EncodePreparator::PreparationFlags::IndexSharing

Index sharing types for vertex attributes (coordinates, normals, texture corrdinates).

Enumerator
INDICES_SEPARATE_FOR_ALL_VERTEX_ATTRIBUTES	All vertex attributes have independent indexing (= the most compact representation).
INDICES_SAME_FOR_VERTICES_AND_NORMALS	Vertex coordinates and vertex normals will use the same index. Data is replicated if needed.
INDICES_SAME_FOR_VERTICES_AND_FIRST_UV_SET	Vertex coordinates and the first texture coordinate set will use the same index. Data is replicated if needed.
INDICES_SAME_FOR_VERTICES_AND_ALL_UV_SETS	Vertex coordinates and all texture coordinate sets will use the same index. Data is replicated if needed.
INDICES_SAME_FOR_VERTICES_AND_NORMALS_AND_FIRST_UV_SET	Vertex coordinates, vertex normals and the first texture coordinate set will use the same index. Data is replicated if needed.
INDICES_SAME_FOR_ALL_VERTEX_ATTRIBUTES	All vertex attributes will use the same index. Data is replicated if needed.

Member Function Documentation

◆ atlasAddWrapBorder()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::atlasAddWrapBorder ( bool v )

If true, texture atlases are forced to have power of two dimensions.

◆ atlasRepeatingTextures()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::atlasRepeatingTextures ( bool v )

If true, repeating textures are put into texture atlases as well.

◆ cleanupUVs()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::cleanupUVs ( bool v )

If true, texture coordinates will be merged if they are within the tolerance set by mergeToleranceUVs().

◆ cleanupVertexNormals()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::cleanupVertexNormals ( bool v )

If true, vertex normals will be merged if they are within the tolerance set by mergeToleranceNormals().

◆ createTextureAtlases()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::createTextureAtlases ( bool v )

If true, texture atlases are created and the materials and geometries updated accordingly per fetch call.

◆ cutoutTextures()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::cutoutTextures ( bool v )

If true, textures are cut to the used area and the materials and geometries updated accordingly per fetch call. This cannot be turned off if texture atlases are activated.

◆ determineMeshProperties()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::determineMeshProperties ( bool v )

If true, performs a mesh analysis. The results can be accessed in FinalizedInstance::allMeshFacesConvex() and FinalizedInstance::allMeshFacesPlanar().

◆ forceAtlasing()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::forceAtlasing ( bool v )

If true, texture atlases are forced even for single textures.

◆ indexSharing()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::indexSharing ( IndexSharing v )

Specify the index setup of the finalized meshes.

See also: IndexSharing

◆ instancing()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::instancing ( bool v )

If true, the preparator shares/reuses cached/identical geometry objects over multiple instances.

◆ maxAtlasDim()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::maxAtlasDim ( int v )

Set max dimension for texture atlases. v is taken to the power of 2, e.g. 11 => 2048x2048.

◆ maxTexSize()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::maxTexSize ( uint32_t v )

Specifies the size to scale larger input images down to. Ignored if zero.

◆ mergeByMaterial()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::mergeByMaterial ( bool v )

[DEPRECATED, use meshMerging()] If true, meshes with the same material are combined per fetch call.

◆ mergeToleranceNormals()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::mergeToleranceNormals ( float v )

Merge tolerance for vertex normals. See cleanupVertexNormals().

◆ mergeToleranceUVs()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::mergeToleranceUVs ( float v )

Merge tolerance for texture coordinates. See cleanupUVs().

◆ mergeToleranceVertices()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::mergeToleranceVertices ( float v )

Merge tolerance for vertex coordinates. See mergeVertices().

◆ mergeVertices()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::mergeVertices ( bool v )

If true, vertices will be merged together if they are closer than the distance specified with mergeToleranceVertices(float v).

◆ meshMerging()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::meshMerging ( MeshMerging::Action v )

Control how new meshes should be merged with previous ones when added to the preparator.

◆ offset() [1/2]

PreparationFlags& prtx::EncodePreparator::PreparationFlags::offset	(	double	x,
		double	y,
		double	z
	)

All meshes are offset by (x,y,z).

◆ offset() [2/2]

PreparationFlags& prtx::EncodePreparator::PreparationFlags::offset ( const double * xyz )

All meshes are offset by xyz. xyz is expected contain three double values.

◆ processHoles()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::processHoles ( HoleProcessor::Action v )

The specified action is applied to faces with holes.

See also: HoleProcessor

◆ processVertexNormals()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::processVertexNormals ( VertexNormalProcessor::Action v )

The specified operation is applied to all vertex normals.

See also: VertexNormalProcessor

◆ triangulate()

PreparationFlags& prtx::EncodePreparator::PreparationFlags::triangulate ( bool v )

If true, all meshes are triangulated.

The documentation for this class was generated from the following file:

EncodePreparator.h

Public Types

Public Member Functions