/*!
Adds to this section a set of connected triangles defined by \a strip.
N triangular faces are generated, where \c{N == strip.count() - 2}.
The triangles are generated from vertices 0, 1, & 2, then 2, 1 & 3,
then 2, 3 & 4, and so on. In other words every second triangle has
the first and second vertices switched, as a new triangle is generated
from each successive set of three vertices.
If \a strip has less than three vertices this function exits without
doing anything.
Normals are calculated as for addTriangle(), given the above ordering.
This function is very similar to the OpenGL mode GL_TRIANGLE_STRIP. It
generates triangles along a strip whose two sides are the even and odd
vertices.
\sa addTriangulatedFace()
*/
void QGLBuilder::addTriangleStrip(const QGeometryData &strip)
{
if (strip.count() < 3)
return;
QGeometryData s = strip;
bool calcNormal = !s.hasField(QGL::Normal);
if (calcNormal)
{
QVector3DArray nm(s.count());
s.appendNormalArray(nm);
}
bool skip = false;
int k = 0;
for (int i = 0; i < s.count() - 2; ++i)
{
if (i % 2)
{
if (calcNormal)
skip = qCalculateNormal(i+1, i, i+2, s);
if (!skip)
dptr->addTriangle(i+1, i, i+2, s, k);
}
else
{
if (calcNormal)
skip = qCalculateNormal(i, i+1, i+2, s);
if (!skip)
dptr->addTriangle(i, i+1, i+2, s, k);
}
}
dptr->currentNode->setCount(dptr->currentNode->count() + k);
}
/*!
Add a series of quads by 'interleaving' \a top and \a bottom.
This function behaves like quadStrip(), where the odd-numbered vertices in
the input primitive are from \a top and the even-numbered vertices from
\a bottom.
It is trivial to do extrusions using this function:
\code
// create a series of quads for an extruded edge along -Y
addQuadsInterleaved(topEdge, topEdge.translated(QVector3D(0, -1, 0));
\endcode
N quad faces are generated where \c{N == min(top.count(), bottom.count() - 1}.
If \a top or \a bottom has less than 2 elements, this functions does
nothing.
Each face is formed by the \c{i'th} and \c{(i + 1)'th}
vertices of \a bottom, followed by the \c{(i + 1)'th} and \c{i'th}
vertices of \a top.
If the vertices in \a top and \a bottom are the perimeter vertices of
two polygons then this function can be used to generate quads which form
the sides of a \l{http://en.wikipedia.org/wiki/Prism_(geometry)}{prism}
with the polygons as the prisms top and bottom end-faces.
\image quad-extrude.png
In the diagram above, the \a top is shown in orange, and the \a bottom in
dark yellow. The first generated quad, (a, b, c, d) is generated in
the order shown by the blue arrow.
To create such a extruded prismatic solid, complete with top and bottom cap
polygons, given just the top edge do this:
\code
QGeometryData top = buildTopEdge();
QGeometryData bottom = top.translated(QVector3D(0, 0, -1));
builder.addQuadsInterleaved(top, bottom);
builder.addTriangulatedFace(top);
builder.addTriangulatedFace(bottom.reversed());
\endcode
The \a bottom QGeometryData must be \b{reversed} so that the correct
winding for an outward facing polygon is obtained.
*/
void QGLBuilder::addQuadsInterleaved(const QGeometryData &top,
const QGeometryData &bottom)
{
if (top.count() < 2 || bottom.count() < 2)
return;
QGeometryData zipped = bottom.interleavedWith(top);
bool calcNormal = !zipped.hasField(QGL::Normal);
if (calcNormal)
{
QVector3DArray nm(zipped.count());
zipped.appendNormalArray(nm);
}
bool skip = false;
QVector3D norm;
int k = 0;
for (int i = 0; i < zipped.count() - 2; i += 2)
{
if (calcNormal)
skip = qCalculateNormal(i, i+2, i+3, zipped, &norm);
if (!skip)
dptr->addTriangle(i, i+2, i+3, zipped, k);
if (skip)
skip = qCalculateNormal(i, i+3, i+1, zipped, &norm);
if (!skip)
{
if (calcNormal)
setNormals(i, i+3, i+1, zipped, norm);
dptr->addTriangle(i, i+3, i+1, zipped, k);
}
}
dptr->currentNode->setCount(dptr->currentNode->count() + k);
}
/*!
Adds to this section a set of quads defined by \a strip.
If \a strip has less than four vertices this function exits without
doing anything.
The first quad is formed from the 0'th, 2'nd, 3'rd and 1'st vertices.
The second quad is formed from the 2'nd, 4'th, 5'th and 3'rd vertices,
and so on, as shown in this diagram:
\image quads.png
One normal per quad is calculated if \a strip does not have normals.
For this reason quads should have all four vertices in the same plane.
If the vertices do not lie in the same plane, use addTriangles() instead.
Since internally \l{geometry-building}{quads are stored as two triangles},
each quad is actually divided in half into two triangles.
Degenerate triangles are skipped in the same way as addTriangles().
\sa addQuads(), addTriangleStrip()
*/
void QGLBuilder::addQuadStrip(const QGeometryData &strip)
{
if (strip.count() < 4)
return;
QGeometryData s = strip;
bool calcNormal = !s.hasField(QGL::Normal);
if (calcNormal)
{
QVector3DArray nm(s.count());
s.appendNormalArray(nm);
}
bool skip = false;
QVector3D norm;
int k = 0;
for (int i = 0; i < s.count() - 3; i += 2)
{
if (calcNormal)
skip = qCalculateNormal(i, i+2, i+3, s, &norm);
if (!skip)
dptr->addTriangle(i, i+2, i+3, s, k);
if (skip)
skip = qCalculateNormal(i, i+3, i+1, s, &norm);
if (!skip)
{
if (calcNormal)
setNormals(i, i+3, i+1, s, norm);
dptr->addTriangle(i, i+3, i+1, s, k);
}
}
dptr->currentNode->setCount(dptr->currentNode->count() + k);
}
/*!
Add \a quads - a series of one or more quads - to this builder.
If \a quads has less than four vertices this function exits without
doing anything.
One normal per quad is calculated if \a quads does not have normals.
For this reason quads should have all four vertices in the same plane.
If the vertices do not lie in the same plane, use addTriangleStrip()
to add two adjacent triangles instead.
Since internally \l{geometry-building}{quads are stored as two triangles},
each quad is actually divided in half into two triangles.
Degenerate triangles are skipped in the same way as addTriangles().
\sa addTriangles(), addTriangleStrip()
*/
void QGLBuilder::addQuads(const QGeometryData &quads)
{
if (quads.count() < 4)
return;
QGeometryData q = quads;
bool calcNormal = !q.hasField(QGL::Normal);
if (calcNormal)
{
QVector3DArray nm(q.count());
q.appendNormalArray(nm);
}
bool skip = false;
int k = 0;
QVector3D norm;
for (int i = 0; i < q.count(); i += 4)
{
if (calcNormal)
skip = qCalculateNormal(i, i+1, i+2, q, &norm);
if (!skip)
dptr->addTriangle(i, i+1, i+2, q, k);
if (skip)
skip = qCalculateNormal(i, i+2, i+3, q, &norm);
if (!skip)
{
if (calcNormal)
setNormals(i, i+2, i+3, q, norm);
dptr->addTriangle(i, i+2, i+3, q, k);
}
}
dptr->currentNode->setCount(dptr->currentNode->count() + k);
}
/*!
Add \a triangles - a series of one or more triangles - to this builder.
The data is broken into groups of 3 vertices, each processed as a triangle.
If \a triangles has less than 3 vertices this function exits without
doing anything. Any vertices at the end of the list under a multiple
of 3 are ignored.
If no normals are supplied in \a triangles, a normal is calculated; as
the cross-product \c{(b - a) x (c - a)}, for each group of 3
logical vertices \c{a(triangle, i), b(triangle, i+1), c(triangle, i+2)}.
In the case of a degenerate triangle, where the cross-product is null,
that triangle is skipped. Supplying normals suppresses this behaviour
(and means any degenerate triangles will be added to the geometry).
\b{Raw Triangle Mode}
If \a triangles has indices specified then no processing of any kind is
done and all the geometry is simply dumped in to the builder.
This \b{raw triangle} mode is for advanced use, and it is assumed that
the user knows what they are doing, in particular that the indices
supplied are correct, and normals are supplied and correct.
Normals are not calculated in raw triangle mode, and skipping of null
triangles is likewise not performed. See the section on
\l{raw-triangle-mode}{raw triangle mode}
in the class documentation above.
\sa addQuads(), operator>>()
*/
void QGLBuilder::addTriangles(const QGeometryData &triangles)
{
if (triangles.count() < 3)
return;
if (triangles.indexCount() > 0)
{
// raw triangle mode
if (dptr->currentSection == 0)
newSection();
dptr->currentSection->appendGeometry(triangles);
dptr->currentSection->appendIndices(triangles.indices());
dptr->currentNode->setCount(dptr->currentNode->count() + triangles.indexCount());
}
else
{
QGeometryData t = triangles;
bool calcNormal = !t.hasField(QGL::Normal);
if (calcNormal)
{
QVector3DArray nm(t.count());
t.appendNormalArray(nm);
}
bool skip = false;
int k = 0;
for (int i = 0; i < t.count() - 2; i += 3)
{
if (calcNormal)
skip = qCalculateNormal(i, i+1, i+2, t);
if (!skip)
dptr->addTriangle(i, i+1, i+2, t, k);
}
dptr->currentNode->setCount(dptr->currentNode->count() + k);
}
}
/*!
Adds to this section a set of connected triangles defined by \a fan.
N triangular faces are generated, where \c{N == fan.count() - 2}. Each
face contains the 0th vertex in \a fan, followed by the i'th and i+1'th
vertex - where i takes on the values from 1 to \c{fan.count() - 1}.
If \a fan has less than three vertices this function exits without
doing anything.
This function is similar to the OpenGL mode GL_TRIANGLE_FAN. It
generates a number of triangles all sharing one common vertex, which
is the 0'th vertex of the \a fan.
Normals are calculated as for addTriangle(), given the above ordering.
There is no requirement or assumption that all triangles lie in the
same plane. Degenerate triangles are skipped in the same way as
addTriangles().
\sa addTriangulatedFace()
*/
void QGLBuilder::addTriangleFan(const QGeometryData &fan)
{
if (fan.count() < 3)
return;
QGeometryData f = fan;
bool calcNormal = !f.hasField(QGL::Normal);
if (calcNormal)
{
QVector3DArray nm(f.count());
f.appendNormalArray(nm);
}
int k = 0;
bool skip = false;
for (int i = 1; i < f.count() - 1; ++i)
{
if (calcNormal)
skip = qCalculateNormal(0, i, i+1, f);
if (!skip)
dptr->addTriangle(0, i, i+1, f, k);
}
dptr->currentNode->setCount(dptr->currentNode->count() + k);
}
/*!
Adds to this section a polygonal face made of triangular sub-faces,
defined by \a face. The 0'th vertex is used for the center, while
the subsequent vertices form the perimeter of the face, which must
at minimum be a triangle.
If \a face has less than four vertices this function exits without
doing anything.
This function provides functionality similar to the OpenGL mode GL_POLYGON,
except it divides the face into sub-faces around a \b{central point}.
The center and perimeter vertices must lie in the same plane (unlike
triangle fan). If they do not normals will be incorrectly calculated.
\image triangulated-face.png
Here the sub-faces are shown divided by green lines. Note how this
function handles some re-entrant (non-convex) polygons, whereas
addTriangleFan will not support such polygons.
If required, the center point can be calculated using the center() function
of QGeometryData:
\code
QGeometryData face;
face.appendVertex(perimeter.center()); // perimeter is a QGeometryData
face.appendVertices(perimeter);
builder.addTriangulatedFace(face);
\endcode
N sub-faces are generated where \c{N == face.count() - 2}.
Each triangular sub-face consists of the center; followed by the \c{i'th}
and \c{((i + 1) % N)'th} vertex. The last face generated then is
\c{(center, face[N - 1], face[0]}, the closing face. Note that the closing
face is automatically created, unlike addTriangleFan().
If no normals are supplied in the vertices of \a face, normals are
calculated as per addTriangle(). One normal is calculated, since a
face's vertices lie in the same plane.
Degenerate triangles are skipped in the same way as addTriangles().
\sa addTriangleFan(), addTriangles()
*/
void QGLBuilder::addTriangulatedFace(const QGeometryData &face)
{
if (face.count() < 4)
return;
QGeometryData f;
f.appendGeometry(face);
int cnt = f.count();
bool calcNormal = !f.hasField(QGL::Normal);
if (calcNormal)
{
QVector3DArray nm(cnt);
f.appendNormalArray(nm);
}
bool skip = false;
QVector3D norm;
int k = 0;
for (int i = 1; i < cnt; ++i)
{
int n = i + 1;
if (n == cnt)
n = 1;
if (calcNormal)
{
skip = qCalculateNormal(0, i, n, f);
if (norm.isNull() && !skip)
{
norm = f.normalAt(0);
for (int i = 0; i < cnt; ++i)
f.normal(i) = norm;
}
}
if (!skip)
dptr->addTriangle(0, i, n, f, k);
}
dptr->currentNode->setCount(dptr->currentNode->count() + k);
}
/*!
\relates QGLCubeSphere
Builds the geometry for \a sphere within the specified
display \a list.
*/
QGLBuilder& operator<<(QGLBuilder& list, const QGLCubeSphere& sphere)
{
/*
A-----H
| |
| |
A-----D-----E-----H-----A
| | | | |
| | | | |
B-----C-----F-----G-----B
| |
| |
B-----G
^ d e
| c f
y
x-->
*/
qreal scale = sphere.diameter();
int depth = sphere.subdivisionDepth();
const qreal offset = 1.0f;
float cube[8][3] = {
{ -offset, offset, -offset}, // A - 0
{ -offset, -offset, -offset }, // B - 1
{ -offset, -offset, offset }, // C - 2
{ -offset, offset, offset }, // D - 3
{ offset, offset, offset }, // E - 4
{ offset, -offset, offset }, // F - 5
{ offset, -offset, -offset }, // G - 6
{ offset, offset, -offset }, // H - 7
};
int face[6][4] = {
{ 0, 1, 2, 3 }, // A-B-C-D
{ 3, 2, 5, 4 }, // D-C-F-E
{ 4, 5, 6, 7 }, // E-F-G-H
{ 7, 6, 1, 0 }, // H-G-B-A
{ 0, 3, 4, 7 }, // A-D-E-H
{ 2, 1, 6, 5 }, // C-B-G-F
};
const float v3 = 0.0f;
const float v2 = 0.333333333f;
const float v1 = 0.666666666f;
const float v0 = 1.0f;
const float u0 = 0.0f;
const float u1 = 0.25f;
const float u2 = 0.5f;
const float u3 = 0.75f;
const float u4 = 1.0f;
float tex[6][4][2] = {
{ {u0, v1}, {u0, v2}, {u1, v2}, {u1, v1} }, // A-B-C-D
{ {u1, v1}, {u1, v2}, {u2, v2}, {u2, v1} }, // D-C-F-E
{ {u2, v1}, {u2, v2}, {u3, v2}, {u3, v1} }, // E-F-G-H
{ {u3, v1}, {u3, v2}, {u4, v2}, {u4, v1} }, // H-G-B-A
{ {u1, v0}, {u1, v1}, {u2, v1}, {u2, v0} }, // A-D-E-H
{ {u1, v2}, {u1, v3}, {u2, v3}, {u2, v2} }, // C-B-G-F
};
// Generate the initial vertex list from a plain cube.
QVector3DArray vertices;
QVector3DArray normals;
QVector2DArray texCoords;
for (int ix = 0; ix < 6; ++ix) {
QVector3D n0(cube[face[ix][0]][0], cube[face[ix][0]][1], cube[face[ix][0]][2]);
QVector3D n1(cube[face[ix][1]][0], cube[face[ix][1]][1], cube[face[ix][1]][2]);
QVector3D n2(cube[face[ix][2]][0], cube[face[ix][2]][1], cube[face[ix][2]][2]);
QVector3D n3(cube[face[ix][3]][0], cube[face[ix][3]][1], cube[face[ix][3]][2]);
QVector2D t0(tex[ix][0][0], tex[ix][0][1]);
QVector2D t1(tex[ix][1][0], tex[ix][1][1]);
QVector2D t2(tex[ix][2][0], tex[ix][2][1]);
QVector2D t3(tex[ix][3][0], tex[ix][3][1]);
n0 = n0.normalized();
n1 = n1.normalized();
n2 = n2.normalized();
n3 = n3.normalized();
QVector3D v0 = n0 * scale / 2.0f;
QVector3D v1 = n1 * scale / 2.0f;
QVector3D v2 = n2 * scale / 2.0f;
QVector3D v3 = n3 * scale / 2.0f;
vertices.append(v0, v1, v2, v3);
normals.append(n0, n1, n2, n3);
texCoords.append(t0, t1, t2, t3);
}
// Subdivide the cube.
while (depth-- > 1) {
QVector3DArray newVertices;
QVector3DArray newNormals;
QVector2DArray newTexCoords;
int count = vertices.count();
for (int i = 0; i < count; i+= 4) {
QVector3D v0 = vertices.at(i);
QVector3D v1 = vertices.at(i+1);
QVector3D v2 = vertices.at(i+2);
QVector3D v3 = vertices.at(i+3);
QVector3D n0 = normals.at(i);
QVector3D n1 = normals.at(i+1);
QVector3D n2 = normals.at(i+2);
QVector3D n3 = normals.at(i+3);
QVector2D t0 = texCoords.at(i);
QVector2D t1 = texCoords.at(i+1);
QVector2D t2 = texCoords.at(i+2);
QVector2D t3 = texCoords.at(i+3);
QVector3D n01 = (v0 + v1).normalized();
QVector3D n12 = (v1 + v2).normalized();
QVector3D n23 = (v2 + v3).normalized();
QVector3D n30 = (v3 + v0).normalized();
QVector3D nc = (v0 + v1 + v2 + v3).normalized();
QVector3D v01 = n01 * scale / 2.0f;
QVector3D v12 = n12 * scale / 2.0f;
QVector3D v23 = n23 * scale / 2.0f;
QVector3D v30 = n30 * scale / 2.0f;
QVector3D vc = nc * scale / 2.0f;
QVector2D t01 = (t0 + t1) / 2;
QVector2D t12 = (t1 + t2) / 2;
QVector2D t23 = (t2 + t3) / 2;
QVector2D t30 = (t3 + t0) / 2;
QVector2D tc = (t2 + t0) / 2;
newVertices.append(v0, v01, vc, v30);
newNormals.append(n0, n01, nc, n30);
newTexCoords.append(t0, t01, tc, t30);
newVertices.append(v01, v1, v12, vc);
newNormals.append(n01, n1, n12, nc);
newTexCoords.append(t01, t1, t12, tc);
newVertices.append(vc, v12, v2, v23);
newNormals.append(nc, n12, n2, n23);
newTexCoords.append(tc, t12, t2, t23);
newVertices.append(v30, vc, v23, v3);
newNormals.append(n30, nc, n23, n3);
newTexCoords.append(t30, tc, t23, t3);
}
vertices = newVertices;
normals = newNormals;
texCoords = newTexCoords;
}
// Add the final vertices to the display list.
QGeometryData prim;
prim.appendVertexArray(vertices);
prim.appendNormalArray(normals);
prim.appendTexCoordArray(texCoords);
list.addTriangles(prim);
return list;
}
/*!
\relates QGLIcoSphere
Builds the geometry for \a sphere within the specified
display \a list.
*/
QGLBuilder& operator<<(QGLBuilder& list, const QGLIcoSphere& sphere)
{
qreal scale = sphere.diameter();
int depth = sphere.subdivisionDepth();
qreal tiny= 1.0f;
qreal large = phi*tiny;
float ico[12][3] = {
{ 0.0f, tiny, large }, // A - 0
{ 0.0f, tiny, -large }, // B - 1
{ 0.0f, -tiny, large }, // C - 2
{ 0.0f, -tiny, -large }, // D - 3
{ tiny, large, 0.0f }, // E - 4
{ tiny, -large, 0.0f }, // F - 5
{ -tiny, large, 0.0f }, // G - 6
{ -tiny, -large, 0.0f }, // H - 7
{ large, 0.0f, tiny}, // I - 8
{ large, 0.0f, -tiny}, // J - 9
{ -large, 0.0f, tiny}, // K - 10
{ -large, 0.0f, -tiny} // L - 11
};
int face[20][3] = {
{ 4, 0, 8 }, // E-A-I
{ 6, 0, 4 }, // G-A-E
{ 6, 10, 0 }, // G-K-A
{ 11, 10, 6 }, // L-K-G
{ 0, 2, 8 }, // A-C-I
{ 10, 2, 0 }, // K-C-A
{ 10, 7, 2 }, // K-H-C
{ 11, 7, 10 }, // L-H-K
{ 2, 5, 8 }, // C-F-I
{ 7, 5, 2 }, // H-F-C
{ 7, 3, 5 }, // H-D-F
{ 11, 3, 7 }, // L-D-H
{ 5, 9, 8 }, // F-J-I
{ 3, 9, 5 }, // D-J-F
{ 3, 1, 9 }, // D-B-J
{ 11, 1, 3 }, // L-B-D
{ 9, 4, 8 }, // J-E-I
{ 1, 4, 9 }, // B-E-J
{ 1, 6, 4 }, // B-G-E
{ 11, 6, 1 } // L-G-B
};
const float u0 = 0.0f;
const float u1 = 0.173205081f;
const float u2 = 0.346410162f;
const float u3 = 0.519615242f;
const float u4 = 0.692820323f;
const float u5 = 0.866025402f;
const float v9 = 0.0f;
const float v8 = 0.111111111f;
const float v7 = 0.222222222f;
const float v6 = 0.333333333f;
const float v5 = 0.444444444f;
const float v4 = 0.555555555f;
const float v3 = 0.666666666f;
const float v2 = 0.777777777f;
const float v1 = 0.888888888f;
const float v0 = 1.0f;
float tex[20][3][2] = {
{ { u0, v1 }, { u1, v2 }, { u1, v0 } }, // E-A-I
{ { u0, v3 }, { u1, v2 }, { u0, v1 } }, // G-A-E
{ { u0, v3 }, { u1, v4 }, { u1, v2 } }, // G-K-A
{ { u0, v5 }, { u1, v4 }, { u0, v3 } }, // L-K-G
{ { u1, v2 }, { u2, v3 }, { u2, v1 } }, // A-C-I
{ { u1, v4 }, { u2, v3 }, { u1, v2 } }, // K-C-A
{ { u1, v4 }, { u2, v5 }, { u2, v3 } }, // K-H-C
{ { u1, v6 }, { u2, v5 }, { u1, v4 } }, // L-H-K
{ { u2, v3 }, { u3, v4 }, { u3, v2 } }, // C-F-I
{ { u2, v5 }, { u3, v4 }, { u2, v3 } }, // H-F-C
{ { u2, v5 }, { u3, v6 }, { u3, v4 } }, // H-D-F
{ { u2, v7 }, { u3, v6 }, { u2, v5 } }, // L-D-H
{ { u3, v4 }, { u4, v5 }, { u4, v3 } }, // F-J-I
{ { u3, v6 }, { u4, v5 }, { u3, v4 } }, // D-J-F
{ { u3, v6 }, { u4, v7 }, { u4, v5 } }, // D-B-J
{ { u3, v8 }, { u4, v7 }, { u3, v6 } }, // L-B-D
{ { u4, v5 }, { u5, v6 }, { u5, v4 } }, // J-E-I
{ { u4, v7 }, { u5, v6 }, { u4, v5 } }, // B-E-J
{ { u4, v7 }, { u5, v8 }, { u5, v6 } }, // B-G-E
{ { u4, v9 }, { u5, v8 }, { u4, v7 } } // L-G-B
};
// Generate the initial vertex list from a plain icosahedron.
QVector3DArray vertices;
QVector3DArray normals;
QVector2DArray texCoords;
for (int ix = 0; ix < 20; ++ix) {
QVector3D n0(ico[face[ix][0]][0], ico[face[ix][0]][1], ico[face[ix][0]][2]);
QVector3D n1(ico[face[ix][1]][0], ico[face[ix][1]][1], ico[face[ix][1]][2]);
QVector3D n2(ico[face[ix][2]][0], ico[face[ix][2]][1], ico[face[ix][2]][2]);
QVector2D t0(tex[ix][0][0], tex[ix][0][1]);
QVector2D t1(tex[ix][1][0], tex[ix][1][1]);
QVector2D t2(tex[ix][2][0], tex[ix][2][1]);
n0 = n0.normalized();
n1 = n1.normalized();
n2 = n2.normalized();
QVector3D v0 = n0 * scale / 2.0f;
QVector3D v1 = n1 * scale / 2.0f;
QVector3D v2 = n2 * scale / 2.0f;
vertices.append(v0, v1, v2);
normals.append(n0, n1, n2);
texCoords.append(t0, t1, t2);
}
// Subdivide the icosahedron.
while (depth-- > 1) {
QVector3DArray newVertices;
QVector3DArray newNormals;
QVector2DArray newTexCoords;
int count = vertices.count();
for (int i = 0; i < count; i+= 3) {
QVector3D v0 = vertices.at(i);
QVector3D v1 = vertices.at(i+1);
QVector3D v2 = vertices.at(i+2);
QVector3D n0 = normals.at(i);
QVector3D n1 = normals.at(i+1);
QVector3D n2 = normals.at(i+2);
QVector2D t0 = texCoords.at(i);
QVector2D t1 = texCoords.at(i+1);
QVector2D t2 = texCoords.at(i+2);
QVector3D n01 = (v0 + v1).normalized();
QVector3D n12 = (v1 + v2).normalized();
QVector3D n20 = (v2 + v0).normalized();
QVector3D v01 = n01 * scale / 2.0f;
QVector3D v12 = n12 * scale / 2.0f;
QVector3D v20 = n20 * scale / 2.0f;
QVector2D t01 = (t0 + t1) / 2;
QVector2D t12 = (t1 + t2) / 2;
QVector2D t20 = (t2 + t0) / 2;
newVertices.append(v0, v01, v20);
newNormals.append(n0, n01, n20);
newTexCoords.append(t0, t01, t20);
newVertices.append(v01, v1, v12);
newNormals.append(n01, n1, n12);
newTexCoords.append(t01, t1, t12);
newVertices.append(v01, v12, v20);
newNormals.append(n01, n12, n20);
newTexCoords.append(t01, t12, t20);
newVertices.append(v20, v12, v2);
newNormals.append(n20, n12, n2);
newTexCoords.append(t20, t12, t2);
}
vertices = newVertices;
normals = newNormals;
texCoords = newTexCoords;
}
// Add the final vertices to the builder.
QGeometryData prim;
prim.appendVertexArray(vertices);
prim.appendNormalArray(normals);
prim.appendTexCoordArray(texCoords);
list.addTriangles(prim);
return list;
}
