fromAABB method

Polyhedron fromAABB(AABB aabb)

Configures this polyhedron so it does represent the given AABB.

Implementation

Polyhedron fromAABB(AABB aabb ) {
	faces.clear();
	this.vertices.clear();

	final min = aabb.min;
	final max = aabb.max;

	final vertices = [
		Vector3( max.x, max.y, max.z ),
		Vector3( max.x, max.y, min.z ),
		Vector3( max.x, min.y, max.z ),
		Vector3( max.x, min.y, min.z ),
		Vector3( min.x, max.y, max.z ),
		Vector3( min.x, max.y, min.z ),
		Vector3( min.x, min.y, max.z ),
		Vector3( min.x, min.y, min.z )
	];

	this.vertices.addAll( vertices );

	final sideTop = Polygon().fromContour( [
		vertices[ 4 ],
		vertices[ 0 ],
		vertices[ 1 ],
		vertices[ 5 ]
	] );

	final sideRight = Polygon().fromContour( [
		vertices[ 2 ],
		vertices[ 3 ],
		vertices[ 1 ],
		vertices[ 0 ]
	] );

	final sideFront = Polygon().fromContour( [
		vertices[ 6 ],
		vertices[ 2 ],
		vertices[ 0 ],
		vertices[ 4 ]
	] );

	final sideBack = Polygon().fromContour( [
		vertices[ 3 ],
		vertices[ 7 ],
		vertices[ 5 ],
		vertices[ 1 ]
	] );

	final sideBottom = Polygon().fromContour( [
		vertices[ 3 ],
		vertices[ 2 ],
		vertices[ 6 ],
		vertices[ 7 ]
	] );

	final sideLeft = Polygon().fromContour( [
		vertices[ 7 ],
		vertices[ 6 ],
		vertices[ 4 ],
		vertices[ 5 ]
	] );

	// link edges

	sideTop.edge?.linkOpponent( sideLeft.edge?.prev );
	sideTop.edge?.next?.linkOpponent( sideFront.edge?.prev );
	sideTop.edge?.next?.next?.linkOpponent( sideRight.edge?.prev );
	sideTop.edge?.prev?.linkOpponent( sideBack.edge?.prev );

	sideBottom.edge?.linkOpponent( sideBack.edge?.next );
	sideBottom.edge?.next?.linkOpponent( sideRight.edge?.next );
	sideBottom.edge?.next?.next?.linkOpponent( sideFront.edge?.next );
	sideBottom.edge?.prev?.linkOpponent( sideLeft.edge?.next );

	sideLeft.edge?.linkOpponent( sideBack.edge?.next?.next );
	sideBack.edge?.linkOpponent( sideRight.edge?.next?.next );
	sideRight.edge?.linkOpponent( sideFront.edge?.next?.next );
	sideFront.edge?.linkOpponent( sideLeft.edge?.next?.next );

	//
	faces.addAll( [sideTop, sideRight, sideFront, sideBack, sideBottom, sideLeft] );

	// compute centroids
	sideTop.computeCentroid();
	sideRight.computeCentroid();
	sideFront.computeCentroid();
	sideBack.computeCentroid();
	sideBottom.computeCentroid();
	sideLeft.computeCentroid();

	aabb.getCenter( centroid );

	//
	computeUniqueEdges();

	return this;
}