G3D::MeshBuilder Class Reference

#include <MeshBuilder.h>

Public Types
enum	{ AUTO_WELD = -100 }

Public Member Functions
	MeshBuilder (bool twoSided=false, bool scaleAndCenter=true)
void	commit (std::string &name, Array< int > &indexArray, Array< Vector3 > &vertexArray)
void	addTriangle (const Vector3 &a, const Vector3 &b, const Vector3 &c)
void	addQuad (const Vector3 &a, const Vector3 &b, const Vector3 &c, const Vector3 &d)
void	addTriangle (const Triangle &t)
void	setName (const std::string &n)
void	setWeldRadius (double r)

Private Types
typedef Array< int >	List

Private Member Functions
void	centerTriList ()
void	computeBounds (Vector3 &min, Vector3 &max)

Private Attributes
std::string	name
bool	scaleAndCenter
Array< Vector3 >	triList
bool	_twoSided
double	close

Detailed Description

Allows creation of optimized watertight meshes from unoptimized polygon soups. See also G3D::MeshAlg for algorithms that operate on the output.

Member Typedef Documentation

typedef Array<int> G3D::MeshBuilder::List

private

Indices of vertices in or near a grid cell.

Member Enumeration Documentation

anonymous enum

Set setWeldRadius to AUTO_WELD to weld vertices closer than 1/2 the smallest edge length in a model.

Enumerator
AUTO_WELD

{AUTO_WELD = -100};

Constructor & Destructor Documentation

G3D::MeshBuilder::MeshBuilder ( bool  twoSided = false, bool  scaleAndCenter = true  )

inline

: scaleAndCenter(scaleAndCenter), _twoSided(twoSided), close(AUTO_WELD) {}

Member Function Documentation

void G3D::MeshBuilder::addQuad	(	const Vector3 &	a,
		const Vector3 &	b,
		const Vector3 &	c,
		const Vector3 &	d
	)

Adds two new triangles to the model. (Counter clockwise)

 {
 addTriangle(a, b, c);
 addTriangle(a, c, d);
}

Here is the call graph for this function:

void G3D::MeshBuilder::addTriangle	(	const Vector3 &	a,
		const Vector3 &	b,
		const Vector3 &	c
	)

Adds a new triangle to the model. (Counter clockwise)

 {
 triList.append(a, b, c);

 if (_twoSided) {
 triList.append(c, b, a);
 }
}

Here is the caller graph for this function:

void G3D::MeshBuilder::addTriangle

(

const Triangle &

t

)

 {
 addTriangle(t.vertex(0), t.vertex(1), t.vertex(2));
}

Here is the call graph for this function:

void G3D::MeshBuilder::centerTriList ( )

private

 {
 // Compute the range of the vertices
 Vector3 vmin, vmax;

 computeBounds(vmin, vmax);

 const Vector3 diagonal = vmax - vmin;
 float scale = max(max(diagonal.x, diagonal.y), diagonal.z) / 2.0f;
 debugAssert(scale > 0);

 const Vector3 translation = vmin + diagonal / 2.0f;

 // Center and scale all vertices in the input list
 int v;

 if (scaleAndCenter) {
 //Matrix3 rot90 = Matrix3::fromAxisAngle(Vector3::UNIT_Y, toRadians(180)) * Matrix3::fromAxisAngle(Vector3::UNIT_X, toRadians(90));
 for (v = 0; v < triList.size(); ++v) {
 triList[v] = (triList[v] - translation) / scale;
 //triList[v] = rot90 * triList[v];
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::MeshBuilder::commit	(	std::string &	name,
		Array< int > &	indexArray,
		Array< Vector3 > &	vertexArray
	)

Writes the model to the arrays, which can then be used with G3D::IFSModel::save and G3D::MeshAlg

 {
 n = name;

 // Make the data fit in a unit cube
 centerTriList();

 Array<int> toNew, toOld;

 if (close == MeshBuilder::AUTO_WELD) {
 Array<int> index;
 MeshAlg::createIndexArray(triList.size(), index);
 double minEdgeLen, maxEdgeLen, meanEdgeLen, medianEdgeLen;
 double minFaceArea, maxFaceArea, meanFaceArea, medianFaceArea;
 MeshAlg::computeAreaStatistics(triList, index,
 minEdgeLen, meanEdgeLen, medianEdgeLen, maxEdgeLen,
 minFaceArea, meanFaceArea, medianFaceArea, maxFaceArea);
 close = minEdgeLen * 0.1;
 }

 MeshAlg::computeWeld(triList, outvertexArray, toNew, toOld, (float)close);

 // Construct triangles
 for (int t = 0; t < triList.size(); t += 3) {
 int index[3];

 for (int i = 0; i < 3; ++i) {
 index[i] = toNew[t + i];
 }

 // Throw out zero size triangles
 if ((index[0] != index[1]) &&
 (index[1] != index[2]) &&
 (index[2] != index[0])) {
 indexArray.append(index[0], index[1], index[2]);
 }
 }
}

Here is the call graph for this function:

void G3D::MeshBuilder::computeBounds ( Vector3 &  min, Vector3 &  max  )

private

 {
 min = Vector3::inf(); 
 max = -min;

 int v;
 for (v = 0; v < triList.size(); ++v) {
 min = min.min(triList[v]);
 max = max.max(triList[v]);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::MeshBuilder::setName

(

const std::string &

n

)

 {
 name = n;
}

void G3D::MeshBuilder::setWeldRadius ( double  r )

inline

Vertices within this distance are considered identical. Use AUTO_WELD (the default) to have the distance be a function of the model size.

 {
 close = r;
 }

Member Data Documentation

bool G3D::MeshBuilder::_twoSided

private

double G3D::MeshBuilder::close

private

Collapse radius

std::string G3D::MeshBuilder::name

private

bool G3D::MeshBuilder::scaleAndCenter

private

Array<Vector3> G3D::MeshBuilder::triList

private

All of the triangles, as a long triangle list.

---

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

• dep/g3dlite/include/G3D/MeshBuilder.h
• dep/g3dlite/source/MeshBuilder.cpp