See what's going on with flipcode!




This section of the archives stores flipcode's complete Developer Toolbox collection, featuring a variety of mini-articles and source code contributions from our readers.

 

  3D Platonic Primitive Generators
  Submitted by



This is a minimal C++ primitive polygon loader. I use it (and maintain it) for my 3d engine "DexVT", which can be found on my site.

If you like clean, minimal OOP code like I do, then this loader is for you. it manages to stay out of your code as much as possible.

PS. The Vector, Matrix, Transform utility classes are included as a bonus :)

Jerry Chen (Dextre)
http://onlyuser.cjb.net

Currently browsing [3DPlatonicPrimitives.zip] (7,232 bytes) - [Vector.cpp] - (4,856 bytes)

#include "Vector.h"

Vector::Vector() {} Vector::~Vector() {}

//============================================================================= Vector::Vector(float x, float y, float z) {this->x = x; this->y = y; this->z = z;} Vector::Vector(Vector &v) {*this = v;} Vector::Vector(float s) {x = s; y = s; z = s;} Vector::Vector(float *v) {memcpy(this->v, v, sizeof(float) * 3);}

//============================================================================= void Vector::toArray(float *v) { memcpy(v, this->v, sizeof(float) * 3); }

//============================================================================= Vector &Vector::operator=(Vector &v) {x = v.x; y = v.y; z = v.z; return *this;}

Vector &Vector::operator+=(Vector &v) {x += v.x; y += v.y; z += v.z; return *this;} Vector &Vector::operator-=(Vector &v) {x -= v.x; y -= v.y; z -= v.z; return *this;} Vector &Vector::operator&=(Vector &v) {x *= v.x; y *= v.y; z *= v.z; return *this;} Vector &Vector::operator*=(float s) {x *= s; y *= s; z *= s; return *this;} Vector &Vector::operator/=(float s) { float r = 1 / s; x *= r; y *= r; z *= r; return *this; } Vector &Vector::operator*=(Vector &v) { return *this = Vector( y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x ); } Vector &Vector::operator*=(Matrix &m) { return *this = Vector( x * m[0][0] + y * m[1][0] + z * m[2][0] + m[3][0], x * m[0][1] + y * m[1][1] + z * m[2][1] + m[3][1], x * m[0][2] + y * m[1][2] + z * m[2][2] + m[3][2] ); }

Vector Vector::operator+(Vector &v) {return Vector(*this) += v;} Vector Vector::operator-(Vector &v) {return Vector(*this) -= v;} Vector Vector::operator&(Vector &v) {return Vector(*this) &= v;} Vector Vector::operator*(float s) {return Vector(*this) *= s;} Vector Vector::operator/(float s) {return Vector(*this) /= s;} Vector Vector::operator*(Vector &v) {return Vector(*this) *= v;} Vector Vector::operator*(Matrix &m) {return Vector(*this) *= m;}

float &Vector::operator[](AXIS::AXIS axis) {return v[axis];} float Vector::operator|(Vector &v) {return x * v.x + y * v.y + z * v.z;} Vector Vector::operator-() {return *this * -1;}; bool Vector::operator==(Vector &v) {return x == v.x && y == v.y && z == v.z;} bool Vector::operator!=(Vector &v) {return x != v.x || y != v.y || z != v.z;}

//============================================================================= Vector &Vector::mask(Vector &m, Vector &v) { x = m.x ? v.x : x; y = m.y ? v.y : y; z = m.z ? v.z : z; return *this; }

Vector Vector::vec_interp(Vector &v, float s) { return interp(*this, v, s); }

float Vector::mod() { return (float) pow(*this | *this, 0.5f); }

float Vector::dist(Vector &v) { return (*this - v).mod(); }

Vector &Vector::normalize() { float t = this->mod(); return *this = (t != 0) ? *this / t : NULL_VECTOR; }

Vector Vector::normal() { return Vector(*this).normalize(); }

Vector Vector::normTri(Vector &v1, Vector &v2) { return ((v1 - *this) * (v2 - *this)).normalize(); }

float Vector::angle(Vector &v) { return this->normal() | v.normal(); }

int Vector::compare(Vector &v1, Vector &v2) { return sgn((*this | v1) - (*this | v2)); }

float Vector::sectPlane(Vector &p, Vector &v, Vector &n) { float t = n | *this; return (t != 0) ? (n | (v - p)) / t : BIG_NUMBER; }

Vector Vector::project(Vector &v) { Vector t = v.normal(); return t * (*this | t); }

Vector Vector::ortho(Vector &v) { return *this - this->project(v); }

Vector Vector::reflect(Vector &n) { if (this->angle(n) < 0) return *this + this->project(n) * -2; return *this; }

Vector &Vector::fromAngle(Vector &v) { return *this = FWD_VECTOR * RotateTrans(AXIS::X, v.pitch) * RotateTrans(AXIS::Y, v.yaw); }

Vector Vector::toAngle() { Vector t(x, 0, z); Vector r( 0, acosEx(t.angle(*this)), acosEx(t.angle(FWD_VECTOR)) ); if (x < 0) r.yaw *= -1; if (y > 0) r.pitch *= -1; return r; }

//============================================================================= Vector &Vector::vec_wrap(Vector &pMin, Vector &pMax) { x = wrap(x, pMin.x, pMax.x); y = wrap(y, pMin.y, pMax.y); z = wrap(z, pMin.z, pMax.z); return *this; }

Vector &Vector::vec_limit(Vector &pMin, Vector &pMax) { x = limit(x, pMin.x, pMax.x); y = limit(y, pMin.y, pMax.y); z = limit(z, pMin.z, pMax.z); return *this; }

void Vector::multEx(float *r, Matrix &m) { r[0] = x * m[0][0] + y * m[1][0] + z * m[2][0] + m[3][0]; r[1] = x * m[0][1] + y * m[1][1] + z * m[2][1] + m[3][1]; r[2] = x * m[0][2] + y * m[1][2] + z * m[2][2] + m[3][2]; r[3] = x * m[0][3] + y * m[1][3] + z * m[2][3] + m[3][3]; }

Currently browsing [3DPlatonicPrimitives.zip] (7,232 bytes) - [Transform.cpp] - (2,224 bytes)

#include "Transform.h"

ScaleTrans::ScaleTrans(Vector &v) { *((Matrix *) this) = IDENT_MATRIX; (*this)[0][0] = v.x; (*this)[1][1] = v.y; (*this)[2][2] = v.z; }

TranslateTrans::TranslateTrans(Vector &v) { *((Matrix *) this) = IDENT_MATRIX; (*this)[3][0] = v.x; (*this)[3][1] = v.y; (*this)[3][2] = v.z; }

RotateTrans::RotateTrans(AXIS::AXIS axis, float angle) { *((Matrix *) this) = IDENT_MATRIX; float pSin = (float) sin(angle); float pCos = (float) cos(angle); switch (axis) { case AXIS::X: (*this)[1][1] = pCos; (*this)[1][2] = pSin; (*this)[2][1] = -pSin; (*this)[2][2] = pCos; break; case AXIS::Y: (*this)[0][0] = pCos; (*this)[0][2] = -pSin; (*this)[2][0] = pSin; (*this)[2][2] = pCos; break; case AXIS::Z: (*this)[0][0] = pCos; (*this)[0][1] = pSin; (*this)[1][0] = -pSin; (*this)[1][1] = pCos; } }

ComboTrans::ComboTrans(Vector &origin, Vector &angle, Vector &scale) { *((Matrix *) this) = IDENT_MATRIX; (*this) *= ScaleTrans((Vector &) scale); (*this) *= RotateTrans(AXIS::Y, angle.roll); (*this) *= RotateTrans(AXIS::X, angle.pitch); (*this) *= RotateTrans(AXIS::Y, angle.yaw); (*this) *= TranslateTrans((Vector &) origin); }

ProjectTrans::ProjectTrans(float sw, float sh, float n, float f) { if (n <= 0 || n > f) throw Exception("invalid clipping planes"); *((Matrix *) this) = ZERO_MATRIX; cx = sw / 2; cy = sh / 2; }

ProjectPerspectTrans::ProjectPerspectTrans(float sw, float sh, float aspect, float n, float f, float halfTan) : ProjectTrans(sw, sh, n, f) { float h = halfTan * n; float tempA = -h / n; float tempB = -f / (n - f); (*this)[0][0] = cx / aspect; (*this)[1][1] = -cy; (*this)[2][0] = cx * tempA; (*this)[2][1] = cy * tempA; (*this)[2][2] = tempA * tempB; (*this)[2][3] = tempA; (*this)[3][2] = h * tempB; }

ProjectOrthoTrans::ProjectOrthoTrans(float sw, float sh, float aspect, float n, float f, float zoom) : ProjectTrans(sw, sh, n, f) { float tempA = 1 / (n - f); (*this)[0][0] = zoom / aspect; (*this)[1][1] = -zoom; (*this)[2][2] = -tempA; (*this)[3][0] = cx; (*this)[3][1] = cy; (*this)[3][2] = n * tempA; (*this)[3][3] = 1; }

Currently browsing [3DPlatonicPrimitives.zip] (7,232 bytes) - [IMesh.h] - (555 bytes)

#ifndef H_IMESH
#define H_IMESH

#include "Vector.h"

class IMesh { protected: int mVertCnt; int mFaceCnt; public: IMesh(int vertCnt, int faceCnt); ~IMesh(); int getVertCnt(); int getFaceCnt(); virtual void resize(int vertCnt, int faceCnt); virtual Vector *getVertices() = 0; virtual void setVertex(int index, float x, float y, float z) = 0; virtual void setFace(int index, int a, int b, int c) = 0; virtual void setAnchor(int index, float x, float y) = 0; virtual void getDim(Vector &pMin, Vector &pMax) = 0; };

#endif

Currently browsing [3DPlatonicPrimitives.zip] (7,232 bytes) - [Matrix.cpp] - (4,216 bytes)

#include "Matrix.h"

Matrix::Matrix() {} Matrix::~Matrix() {}

//============================================================================= Matrix::Matrix(Matrix &m) {*this = m;} Matrix::Matrix(float s) { for (int i = 0; i < 4; i++) for (int j = 0; j < 4; j++) mItem[i][j] = (i == j) ? s : 0; } Matrix::Matrix(float **m) {this->set(m);}

//============================================================================= inline void Matrix::get(float **m) { for (int i = 0; i < 4; i++) for (int j = 0; j < 4; j++) m[i][j] = mItem[i][j]; }

inline Matrix &Matrix::set(float **m) { for (int i = 0; i < 4; i++) for (int j = 0; j < 4; j++) mItem[i][j] = m[i][j]; return *this; }

//============================================================================= void Matrix::toArray(float *m) { for (int i = 0; i < 4; i++) memcpy(&m[i * 4], mItem[i], sizeof(float) * 4); }

//============================================================================= inline Matrix &Matrix::mult(Matrix &m) { Matrix t; for (int i = 0; i < 4; i++) for (int j = 0; j < 4; j++) t[i][j] = mItem[i][0] * m[0][j] + mItem[i][1] * m[1][j] + mItem[i][2] * m[2][j] + mItem[i][3] * m[3][j]; return *this = t; }

inline Matrix &Matrix::scale(float s) { for (int i = 0; i < 4; i++) for (int j = 0; j < 4; j++) mItem[i][j] *= s; return *this; }

//============================================================================= inline Matrix Matrix::mult(Matrix &m1, Matrix &m2) { Matrix r; for (int i = 0; i < 4; i++) for (int j = 0; j < 4; j++) r[i][j] = m1[i][0] * m2[0][j] + m1[i][1] * m2[1][j] + m1[i][2] * m2[2][j] + m1[i][3] * m2[3][j]; return r; }

inline Matrix Matrix::scale(Matrix &m, float s) { Matrix r; for (int i = 0; i < 4; i++) for (int j = 0; j < 4; j++) r[i][j] = m[i][j] * s; return r; }

//============================================================================= Matrix &Matrix::operator=(Matrix &m) { for (int i = 0; i < 4; i++) for (int j = 0; j < 4; j++) mItem[i][j] = m[i][j]; return *this; } Matrix Matrix::operator~() { Matrix r; for (int i = 0; i < 4; i++) for (int j = 0; j < 4; j++) r[i][j] = mItem[j][i]; return r; }

Matrix &Matrix::operator*=(Matrix &m) {return this->mult(m);} Matrix &Matrix::operator*=(float s) {return this->scale(s);} Matrix &Matrix::operator/=(float s) {return this->scale(1 / s);}

Matrix Matrix::operator*(Matrix &m) {return this->mult(*this, m);} Matrix Matrix::operator*(float s) {return this->scale(*this, s);} Matrix Matrix::operator/(float s) {return this->scale(*this, 1 / s);}

float *Matrix::operator[](int row) {return mItem[row];} Matrix Matrix::operator!() {return this->inverse();}

//============================================================================= inline void Matrix::minor(float **r, float **m, int rowCnt, int colCnt, int row, int col) { int row2 = 0; for (int i = 0; i < rowCnt; i++) if (i != row) { int col2 = 0; for (int j = 0; j < colCnt; j++) if (j != col) { r[row2][col2] = m[i][j]; col2++; } row2++; } }

inline float Matrix::cofact(float **t, float **m, int size, int row, int col) { minor(t, m, size, size, row, col); return (float) pow(-1, row + col) * det(t, size - 1); }

inline float Matrix::det(float **m, int size) { float result = 0; if (size == 1) result = m[0][0]; else { float **t = buildArray(size - 1, size - 1); for (int i = 0; i < size; i++) result += m[0][i] * cofact(t, m, size, 0, i); killArray(t, size - 1); } return result; }

Matrix &Matrix::invert() { float **m = buildArray(4, 4); float **t = buildArray(3, 3); float **r = buildArray(4, 4); this->get(m); for (int i = 0; i < 4; i++) for (int j = 0; j < 4; j++) r[i][j] = cofact(t, m, 4, i, j); float d = det(r, 4); this->set(r); killArray(m, 4); killArray(t, 3); killArray(r, 4); return *this = (d != 0) ? ~(*this) / d : ZERO_MATRIX; }

Matrix Matrix::inverse() { return Matrix(*this).invert(); }

Currently browsing [3DPlatonicPrimitives.zip] (7,232 bytes) - [IMesh.cpp] - (327 bytes)

#include "IMesh.h"

IMesh::IMesh(int vertCnt, int faceCnt) { this->resize(vertCnt, faceCnt); }

IMesh::~IMesh() { }

void IMesh::resize(int vertCnt, int faceCnt) { mVertCnt = vertCnt; mFaceCnt = faceCnt; }

int IMesh::getVertCnt() { return mVertCnt; }

int IMesh::getFaceCnt() { return mFaceCnt; }

Currently browsing [3DPlatonicPrimitives.zip] (7,232 bytes) - [Vector.h] - (2,905 bytes)

#ifndef H_VECTOR
#define H_VECTOR

#include <windows.h> // memcpy() #include <math.h> // pow() #include "Matrix.h" #include "Util.h" // BIG_NUMBER #define UNIT_VECTOR UnitVector #define NULL_VECTOR NullVector #define FWD_VECTOR FwdVector #define LEFT_VECTOR LeftVector #define UP_VECTOR UpVector #define RAND_VECTOR Vector(rand(), rand(), rand())

namespace AXIS { enum AXIS {X, Y, Z, S}; };

class Vector { public: union { float v[3]; struct { union {float x; float roll;}; union {float y; float pitch;}; union {float z; float yaw;}; }; };

Vector(); ~Vector(); //============================================================================= Vector(float x, float y, float z); Vector(Vector &v); Vector(float s); Vector(float *v); //============================================================================= void toArray(float *v); //============================================================================= Vector &operator=(Vector &v); //============================================================================= Vector &operator+=(Vector &v); Vector &operator-=(Vector &v); Vector &operator&=(Vector &v); Vector &operator*=(float s); Vector &operator/=(float s); Vector &operator*=(Vector &v); Vector &operator*=(Matrix &m); //============================================================================= Vector operator+(Vector &v); Vector operator-(Vector &v); Vector operator&(Vector &v); Vector operator*(float s); Vector operator/(float s); Vector operator*(Vector &v); Vector operator*(Matrix &m); //============================================================================= float &operator[](AXIS::AXIS axis); float operator|(Vector &v); Vector operator-(); bool operator==(Vector &v); bool operator!=(Vector &v); //============================================================================= Vector &mask(Vector &m, Vector &v); Vector vec_interp(Vector &v, float s); float mod(); float dist(Vector &v); Vector &normalize(); Vector normal(); Vector normTri(Vector &v1, Vector &v2); float angle(Vector &v); int compare(Vector &v1, Vector &v2); float sectPlane(Vector &p, Vector &v, Vector &n); Vector project(Vector &v); Vector ortho(Vector &v); Vector reflect(Vector &n); Vector &fromAngle(Vector &v); Vector toAngle(); //============================================================================= Vector &vec_wrap(Vector &pMin, Vector &pMax); Vector &vec_limit(Vector &pMin, Vector &pMax); void multEx(float *r, Matrix &m); //============================================================================= };

static Vector UnitVector(1.0); static Vector NullVector(0.0); static Vector FwdVector(0, 0, 1); static Vector LeftVector(1, 0, 0); static Vector UpVector(0, 1, 0);

#include "Transform.h"

#endif

Currently browsing [3DPlatonicPrimitives.zip] (7,232 bytes) - [Transform.h] - (1,004 bytes)

#ifndef H_TRANSFORM
#define H_TRANSFORM

#include <math.h> // sin(), cos() #include "Vector.h" #include "Matrix.h" #include "Exception.h"

class ScaleTrans : public Matrix {public: ScaleTrans(Vector &v);}; class TranslateTrans : public Matrix {public: TranslateTrans(Vector &v);}; class RotateTrans : public Matrix {public: RotateTrans(AXIS::AXIS axis, float angle);};

class ComboTrans : public Matrix { public: ComboTrans( Vector &origin, Vector &angle, Vector &scale ); };

class ProjectTrans : public Matrix { protected: float cx; float cy; public: ProjectTrans( float sw, float sh, float n, float f ); };

class ProjectPerspectTrans : public ProjectTrans { public: ProjectPerspectTrans( float sw, float sh, float aspect, float n, float f, float halfTan ); };

class ProjectOrthoTrans : public ProjectTrans { public: ProjectOrthoTrans( float sw, float sh, float aspect, float n, float f, float zoom ); };

#endif

Currently browsing [3DPlatonicPrimitives.zip] (7,232 bytes) - [Polygon.h] - (598 bytes)

#ifndef H_POLYGON
#define H_POLYGON

#include "IMesh.h"

class Polygon { public: static void makeBox(IMesh *mesh); static void makeGrid(IMesh *mesh, int gridX, int gridZ); static void makeCylinder(IMesh *mesh, int step); static void makeCone(IMesh *mesh, int step); static void makeSphere(IMesh *mesh, int stepLng, int stepLat); static void makeHemis(IMesh *mesh, int stepLng, int stepLat); static void makeTorus(IMesh *mesh, float radMajor, float radMinor, int stepMajor, int stepMinor); static void makeOcta(IMesh *mesh); static void makeTetra(IMesh *mesh); };

#endif

Currently browsing [3DPlatonicPrimitives.zip] (7,232 bytes) - [Matrix.h] - (2,546 bytes)

#ifndef H_MATRIX
#define H_MATRIX

#include <windows.h> // memcpy() #include <math.h> // pow() #define IDENT_MATRIX IdentMatrix #define ZERO_MATRIX ZeroMatrix

inline float **buildArray(int rowCnt, int colCnt) { float **r = new float *[rowCnt]; for (int i = 0; i < rowCnt; i++) r[i] = new float[colCnt]; return r; }

inline void killArray(float **m, int rowCnt) { for (int i = 0; i < rowCnt; i++) delete []m[i]; delete []m; }

class Matrix { private: float mItem[4][4];

//============================================================================= inline void get(float **m); inline Matrix &set(float **m); //============================================================================= inline Matrix &mult(Matrix &m); inline Matrix &scale(float s); //============================================================================= inline Matrix mult(Matrix &m1, Matrix &m2); inline Matrix scale(Matrix &m, float s); //============================================================================= static inline void minor(float **r, float **m, int rowCnt, int colCnt, int row, int col); static inline float cofact(float **t, float **m, int size, int row, int col); static inline float det(float **m, int size); //============================================================================= public: Matrix(); ~Matrix(); //============================================================================= Matrix(Matrix &m); Matrix(float **m); Matrix(float s); //============================================================================= void toArray(float *m); //============================================================================= Matrix &operator=(Matrix &m); Matrix operator~(); //============================================================================= Matrix &operator*=(Matrix &m); Matrix &operator*=(float s); Matrix &operator/=(float s); //============================================================================= Matrix operator*(Matrix &m); Matrix operator*(float s); Matrix operator/(float s); //============================================================================= float *operator[](int row); Matrix operator!(); //============================================================================= Matrix &invert(); Matrix inverse(); //============================================================================= };

static Matrix IdentMatrix(1.0); static Matrix ZeroMatrix(0.0);

#endif

Currently browsing [3DPlatonicPrimitives.zip] (7,232 bytes) - [Polygon.cpp] - (4,489 bytes)

#include "Polygon.h"

void Polygon::makeBox(IMesh *mesh) { mesh->resize(8, 12); mesh->setVertex(0, 0, 0, 0); mesh->setVertex(1, 1, 0, 0); mesh->setVertex(2, 1, 0, 1); mesh->setVertex(3, 0, 0, 1); mesh->setVertex(4, 0, 1, 0); mesh->setVertex(5, 1, 1, 0); mesh->setVertex(6, 1, 1, 1); mesh->setVertex(7, 0, 1, 1); mesh->setFace(0, 0, 4, 5); mesh->setFace(1, 5, 1, 0); mesh->setFace(2, 1, 5, 6); mesh->setFace(3, 6, 2, 1); mesh->setFace(4, 2, 6, 7); mesh->setFace(5, 7, 3, 2); mesh->setFace(6, 3, 7, 4); mesh->setFace(7, 4, 0, 3); mesh->setFace(8, 0, 1, 2); mesh->setFace(9, 2, 3, 0); mesh->setFace(10, 5, 4, 7); mesh->setFace(11, 7, 6, 5); }

void Polygon::makeGrid(IMesh *mesh, int gridX, int gridZ) { mesh->resize(gridX * gridZ, (gridX - 1) * (gridZ - 1) * 2); int vertCnt = 0; int faceCnt = 0; for (int x = 0; x < gridX; x++) for (int z = 0; z < gridZ; z++) { mesh->setVertex( vertCnt, 1 - (float) x / (gridX - 1), 0, 1 - (float) z / (gridZ - 1) ); if (x < gridX - 1 && z < gridZ - 1) { mesh->setFace( faceCnt++, vertCnt + 0, vertCnt + 1, vertCnt + 1 + gridZ ); mesh->setFace( faceCnt++, vertCnt + 1 + gridZ, vertCnt + gridZ, vertCnt + 0 ); } vertCnt++; } }

void Polygon::makeCylinder(IMesh *mesh, int step) { makeGrid(mesh, step + 1, 4); float unit = 2 * PI / step; int vertCnt = 0; for (int i = 0; i < step + 1; i++) { mesh->setVertex(vertCnt++, 0, 1, 0); Vector v = Vector(0, 0, 1) * RotateTrans(AXIS::Y, i * unit); mesh->setVertex(vertCnt++, v.x, v.y + 1, v.z); mesh->setVertex(vertCnt++, v.x, v.y, v.z); mesh->setVertex(vertCnt++, 0, 0, 0); } }

void Polygon::makeCone(IMesh *mesh, int step) { makeGrid(mesh, step + 1, 3); float unit = 2 * PI / step; int vertCnt = 0; for (int i = 0; i < step + 1; i++) { mesh->setVertex(vertCnt++, 0, 1, 0); Vector v = Vector(0, 0, 1) * RotateTrans(AXIS::Y, i * unit); mesh->setVertex(vertCnt++, v.x, v.y, v.z); mesh->setVertex(vertCnt++, 0, 0, 0); } }

void Polygon::makeSphere(IMesh *mesh, int stepLng, int stepLat) { makeGrid(mesh, stepLng + 1, (stepLat / 2) + 1); float unitLng = 2 * PI / stepLng; float unitLat = PI / (stepLat / 2); int vertCnt = 0; for (int i = 0; i < stepLng + 1; i++) for (int j = 0; j < (stepLat / 2) + 1; j++) { Vector v = Vector(0, 1, 0) * RotateTrans(AXIS::X, j * unitLat) * RotateTrans(AXIS::Y, i * unitLng); mesh->setVertex(vertCnt++, v.x, v.y, v.z); } }

void Polygon::makeHemis(IMesh *mesh, int stepLng, int stepLat) { makeGrid(mesh, stepLng + 1, (stepLat / 4) + 2); float unitLng = 2 * PI / stepLng; float unitLat = PI / (stepLat / 2); int vertCnt = 0; for (int i = 0; i < stepLng + 1; i++) { for (int j = 0; j < (stepLat / 4) + 1; j++) { Vector v = Vector(0, 1, 0) * RotateTrans(AXIS::X, j * unitLat) * RotateTrans(AXIS::Y, i * unitLng); mesh->setVertex(vertCnt++, v.x, v.y, v.z); } mesh->setVertex(vertCnt++, 0, 0, 0); } }

void Polygon::makeTorus( IMesh *mesh, float radMajor, float radMinor, int stepMajor, int stepMinor ) { makeGrid(mesh, stepMajor + 1, stepMinor + 1); float unitMajor = 2 * PI / stepMajor; float unitMinor = 2 * PI / stepMinor; int vertCnt = 0; for (int i = 0; i < stepMajor + 1; i++) for (int j = 0; j < stepMinor + 1; j++) { Vector v = Vector(0, radMinor, 0) * RotateTrans(AXIS::X, j * unitMinor) * TranslateTrans(Vector(0, 0, radMajor)) * RotateTrans(AXIS::Y, i * unitMajor); mesh->setVertex(vertCnt++, v.x, v.y, v.z); } }

void Polygon::makeOcta(IMesh *mesh) { mesh->resize(6, 8); mesh->setVertex(0, 0, 0, 0); mesh->setVertex(1, 1, 0, 0); mesh->setVertex(2, 1, 0, 1); mesh->setVertex(3, 0, 0, 1); mesh->setVertex(4, 0.5f, -1, 0.5f); mesh->setVertex(5, 0.5f, 1, 0.5f); mesh->setFace(0, 0, 1, 4); mesh->setFace(1, 1, 2, 4); mesh->setFace(2, 2, 3, 4); mesh->setFace(3, 3, 0, 4); mesh->setFace(4, 0, 5, 1); mesh->setFace(5, 1, 5, 2); mesh->setFace(6, 2, 5, 3); mesh->setFace(7, 3, 5, 0); }

void Polygon::makeTetra(IMesh *mesh) { mesh->resize(4, 4); mesh->setVertex(0, 0, 0, 0); mesh->setVertex(1, 1, 1, 0); mesh->setVertex(2, 0, 1, 1); mesh->setVertex(3, 1, 0, 1); mesh->setFace(0, 0, 1, 3); mesh->setFace(1, 0, 2, 1); mesh->setFace(2, 0, 3, 2); mesh->setFace(3, 1, 2, 3); }

The zip file viewer built into the Developer Toolbox made use of the zlib library, as well as the zlibdll source additions.

 

Copyright 1999-2008 (C) FLIPCODE.COM and/or the original content author(s). All rights reserved.
Please read our Terms, Conditions, and Privacy information.