genode/repos/gems/include/nano3d/dodecahedron_shape.h
Norman Feske 259b127f96 Polygon drawing and rudimentary 3D routines
This patch adds two new painters located at gems/include/polygon_gfx.
Both painters draw convex polygons with an arbirary number of points.
The shaded-polygon painter interpolates the color and alpha values
whereas the textured-polygon painter applies a texture to the polygon.
The painters are accompanied by simplistic 3D routines located at
gems/include/nano3d/ and a corresponding example (gems/run/nano3d.run).
2015-07-07 19:48:04 +02:00

232 lines
5.3 KiB
C++

/*
* \brief Dodecahedron 3D object
* \author Norman Feske
* \date 2015-06-19
*/
/*
* Copyright (C) 2015 Genode Labs GmbH
*
* This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2.
*/
#ifndef _INCLUDE__NANO3D__DODECAHEDRON_SHAPE_H_
#define _INCLUDE__NANO3D__DODECAHEDRON_SHAPE_H_
#include <nano3d/vertex_array.h>
namespace Nano3d { class Dodecahedron_shape; }
class Nano3d::Dodecahedron_shape
{
private:
enum { NUM_VERTICES = 20, NUM_EDGES = 30, NUM_FACES = 12 };
struct Edge
{
unsigned left_face, right_face;
unsigned vertex[2];
Edge() : left_face(0), right_face(0), vertex { 0, 0 } { }
Edge(unsigned vertex_0, unsigned vertex_1,
unsigned left_face, unsigned right_face)
:
left_face(left_face), right_face(right_face),
vertex { vertex_0, vertex_1 }
{ }
};
class Face
{
public:
enum { NUM_EDGES = 5 };
private:
int _edges[NUM_EDGES];
public:
Face() : _edges{} { }
template <typename... EDGE_INDICES>
Face(EDGE_INDICES... edge_indices)
:
_edges { edge_indices... }
{ }
static constexpr unsigned num_edges() { return NUM_EDGES; }
int edge(unsigned i) const { return _edges[i]; }
};
typedef Nano3d::Vertex_array<NUM_VERTICES> Vertex_array;
Vertex_array _vertices;
Edge _edges[NUM_EDGES];
Face _faces[NUM_FACES];
/* ratio of edge length to radius, as 16.16 fixpoint number */
enum { A_TO_R = 46769 };
/* angle between two edges, scaled to 0..1024 range */
enum { DIHEDRAL_ANGLE = 332 };
public:
/**
* \param r radius of the surrounding sphere
*/
Dodecahedron_shape(int r)
{
/*
* Vertices
*/
/*
* There are four level, each with 5 vertices.
*
* y0 and y1 are the y positions of the first and second level.
* r0 and r1 are the radius of first and second levels.
* The third and fourth levels are symetric to the first levels.
*/
int const y0 = -(r * 52078) >> 16; /* r*0.7947 */
int const y1 = -(r * 11030) >> 16;
int const r0 = (r * 39780) >> 16; /* r*0.607 */
int const r1 = (r * 63910) >> 16;
enum { ANGLE_STEP = 1024 / 5 };
enum { ANGLE_HALF_STEP = 1024 / 10 };
int j = 0; /* index into '_vertices' array */
/* level 1 */
for (int i = 0; i < 5; i++) {
int const a = i*ANGLE_STEP;
_vertices[j++] = Vertex((r0*sin_frac16(a)) >> 16, y0,
(r0*cos_frac16(a)) >> 16);
}
/* level 2 */
for (int i = 0; i < 5; i++) {
int const a = i*ANGLE_STEP;
_vertices[j++] = Vertex((r1*sin_frac16(a)) >> 16, y1,
(r1*cos_frac16(a)) >> 16);
}
/* level 3 */
for (int i = 0; i < 5; i++) {
int const a = i*ANGLE_STEP + ANGLE_HALF_STEP;
_vertices[j++] = Vertex((r1*sin_frac16(a)) >> 16, -y1,
(r1*cos_frac16(a)) >> 16);
}
/* level 4 */
for (int i = 0; i < 5; i++) {
int const a = i*ANGLE_STEP + ANGLE_HALF_STEP;
_vertices[j++] = Vertex((r0*sin_frac16(a)) >> 16, -y0,
(r0*cos_frac16(a)) >> 16);
}
/*
* Edges
*/
j = 0; /* index into '_edges' array */
/* level 1 */
for (int i = 0; i < 5; i++)
_edges[j++] = Edge(i, (i+1)%5, i + 1, 0);
/* level 1 to level 2 */
for (int i = 0; i < 5; i++)
_edges[j++] = Edge(i, i + 5, 1 + (i + 4)%5, 1 + i);
/* level 2 to level 3 */
for (int i = 0; i < 5; i++)
_edges[j++] = Edge(i+5, i + 10, 1 + 5 + (i + 4)%5, 1 + i);
/* level 3 to level 2 */
for (int i = 0; i < 5; i++)
_edges[j++] = Edge(i + 10, (i + 1)%5 + 5, 1 + 5 + i, 1 + i);
/* level 3 to level 4 */
for (int i = 0; i < 5; i++)
_edges[j++] = Edge(i + 10, i + 15, 1 + 5 + (i + 4)%5, 1 + 5 + i);
/* level 4 */
for (int i = 0; i < 5; i++)
_edges[j++] = Edge(i + 15, (i + 1)%5 + 15, 11, 1 + 5 + i);
/*
* Faces
*/
j = 0; /* index into '_faces' array */
_faces[j++] = Face(0, 1, 2, 3, 4);
for (int i = 0; i < 5; i++)
_faces[j++] = Face(i, i + 5, i + 10, i + 15, 5 + (1 + i)%5);
for (int i = 0; i < 5; i++)
_faces[j++] = Face(i+20, i + 25, (i + 1)%5 + 20, 10 + (i + 1)%5, 15 + i);
_faces[j++] = Face(29, 28, 27, 26, 25);
}
Vertex_array const &vertex_array() const { return _vertices; }
/**
* Call functor 'fn' for each face of the object
*
* The functor is called with an array of 'unsigned' vertex indices
* and the number of indices as arguments.
*/
template <typename FN>
void for_each_face(FN const &fn) const
{
for (unsigned i = 0; i < NUM_FACES; i++) {
Face const face = _faces[i];
/*
* Asssemble array of vertex indices for the current face.
*/
unsigned vertex_indices[Face::num_edges()];
bool skip_face = false;
for (unsigned j = 0; j < Face::num_edges(); j++) {
Edge const edge = _edges[face.edge(j)];
int vertex_idx = -1;
if (edge.left_face == i)
vertex_idx = edge.vertex[1];
if (edge.right_face == i)
vertex_idx = edge.vertex[0];
if (vertex_idx == -1)
skip_face = true;
vertex_indices[j] = vertex_idx;
}
/* call functor with the information about the face vertices */
if (!skip_face)
fn(vertex_indices, Face::num_edges());
}
}
};
#endif /* _INCLUDE__NANO3D__DODECAHEDRON_SHAPE_H_ */