Алгоритм генерации сферы

#ifndef _SPHERE_H_
#define _SPHERE_H_
 
 
struct VertexSphere {
    float x, y, z;
 
    VertexSphere() : x(0.0f), y(0.0f), z(0.0f) {};
    VertexSphere(float a) : x(a), y(a), z(a) {};
    VertexSphere(float a, float b, float c) : x(a), y(b), z(c) {};
 
    VertexSphere operator- (const VertexSphere &obj) {
        return { x - obj.x, y - obj.y, z - obj.z };
    }
    VertexSphere operator+ (const VertexSphere &obj) {
        return { x + obj.x, y + obj.y, z + obj.z };
    }
    VertexSphere operator* (const VertexSphere &obj) {
        return { x * obj.x, y * obj.y, z * obj.z };
    }
    VertexSphere operator*= (const VertexSphere &obj) {
        x *= obj.x;
        y *= obj.y;
        z *= obj.z;
        return *this;
    }
    VertexSphere operator/ (const VertexSphere &obj) {
        return { x / obj.x, y / obj.y, z / obj.z };
    }
};
 
 
class Sphere {
public:
    Sphere() : pos({ 0.0f, 0.0f, 0.0f }), count(0), vertex(nullptr) {};
    Sphere(VertexSphere center, float radius, unsigned iteration = 4);
    ~Sphere() { if(vertex) delete[] vertex; }
    
    void init(float radius, unsigned iteration = 4);    // Инициализация вершин
    const VertexSphere* getVertex();                    // Получить вершины
    unsigned size() { return count; };                  // Размер (в вершинах)
 
private:
    VertexSphere pos;       // Позиция центра
    unsigned count;         // Кол-во вершин
    VertexSphere *vertex;   // Массив вершин
 
    VertexSphere middle(VertexSphere p1, VertexSphere p2);
    VertexSphere normal(VertexSphere posVert, float lenght);
    void recur(VertexSphere *vout, VertexSphere vin0, VertexSphere vin1, VertexSphere vin2, unsigned iter);
};
 
 
#endif // !_SPHERE_H_

#include <cmath>
#include <iostream>
#include "sphere.h"
 
 
Sphere::Sphere(VertexSphere center, float radius, unsigned iteration) {
    pos = center;
    init(radius, iteration);
}
 
void Sphere::init(float radius, unsigned iteration) {
    float r = radius;
    unsigned triangles = 2 << (2 + 2 * iteration);  // 2^3 получается всего 8 базовых треугольников, если не входить в рекурсию, иначе 2^(3 + 2n)
    count = triangles * 3;                  // кол-во вершин
    vertex = new VertexSphere[count];
 
    VertexSphere v0, v1, v2;    // Вершины базовых треугольников
    for (int i = 0; i < 8; i++) {
        // Инициализация вершин базовых треугольников
        switch (i) {
        case 0: v0 = { pos.x - r, pos.y, pos.z + r };   v1 = { pos.x + r, pos.y, pos.z + r };   v2 = { pos.x, pos.y + r, pos.z };       break;
        case 1: v0 = { pos.x - r, pos.y, pos.z + r };   v1 = { pos.x, pos.y - r, pos.z };       v2 = { pos.x + r, pos.y, pos.z + r };   break;
        case 2: v0 = { pos.x + r, pos.y, pos.z + r };   v1 = { pos.x + r, pos.y, pos.z - r };   v2 = { pos.x, pos.y + r, pos.z };       break;
        case 3: v0 = { pos.x + r, pos.y, pos.z + r };   v1 = { pos.x, pos.y - r, pos.z };       v2 = { pos.x + r, pos.y, pos.z - r };   break;
        case 4: v0 = { pos.x + r, pos.y, pos.z - r };   v1 = { pos.x - r, pos.y, pos.z - r };   v2 = { pos.x, pos.y + r, pos.z };       break;
        case 5: v0 = { pos.x + r, pos.y, pos.z - r };   v1 = { pos.x, pos.y - r, pos.z };       v2 = { pos.x - r, pos.y, pos.z - r };   break;
        case 6: v0 = { pos.x - r, pos.y, pos.z - r };   v1 = { pos.x - r, pos.y, pos.z + r };   v2 = { pos.x, pos.y + r, pos.z };       break;
        case 7: v0 = { pos.x - r, pos.y, pos.z - r };   v1 = { pos.x, pos.y - r, pos.z };       v2 = { pos.x - r, pos.y, pos.z + r };   break;
        }
        recur(vertex, v0, v1, v2, iteration);
    }
    for (int i = 0; i < count; i++) vertex[i] = normal(vertex[i], radius);
}
 
// Нормализация вершин - подгоняем длину до радиуса
VertexSphere Sphere::normal(VertexSphere vert, float lenght) {
    VertexSphere dist = vert - pos;
    float hypotenuse = sqrt(dist.x * dist.x + dist.y * dist.y + dist.z * dist.z);
    dist *= VertexSphere(lenght / hypotenuse);
    return pos + dist;
}
 
// Получение координат середины отрезка
VertexSphere Sphere::middle(VertexSphere p1, VertexSphere p2) {
    return p1 + ((p2 - p1) / VertexSphere(2.0f));
}
 
// Рекурсия, разбиение треугольников на более мелкие
void Sphere::recur(VertexSphere *vout, VertexSphere vin0, VertexSphere vin1, VertexSphere vin2, unsigned iteration) {
    static int n = 0;
    if (iteration) {
        VertexSphere m1, m2, m3, v0, v1, v2;
        // Середины отрезков
        m1 = middle(vin0, vin1);
        m2 = middle(vin1, vin2);
        m3 = middle(vin2, vin0);
        iteration--;
 
        for (int i = 0; i < 4; i++) {   // в одном базовом треугольнике 4 меньших
            switch (i) {
            case 0: v0 = { vin0.x, vin0.y, vin0.z };    v1 = { m1.x, m1.y, m1.z };          v2 = { m3.x, m3.y, m3.z };          break;
            case 1: v0 = { m1.x, m1.y, m1.z };          v1 = { vin1.x, vin1.y, vin1.z };    v2 = { m2.x, m2.y, m2.z };          break;
            case 2: v0 = { m3.x, m3.y, m3.z };          v1 = { m1.x, m1.y, m1.z };          v2 = { m2.x, m2.y, m2.z };          break;
            case 3: v0 = { m3.x, m3.y, m3.z };          v1 = { m2.x, m2.y, m2.z };          v2 = { vin2.x, vin2.y, vin2.z };    break;
            }
            recur(vout, v0, v1, v2, iteration);
        }
    }
    else {
        // Если конечная рекурсия возвращаем начальные вершины
        vout[n++] = { vin0.x, vin0.y, vin0.z };
        vout[n++] = { vin1.x, vin1.y, vin1.z };
        vout[n++] = { vin2.x, vin2.y, vin2.z };
    }
}
 
const VertexSphere* Sphere::getVertex() {
    if (!vertex) std::cout << "SPHERE::getVertex:: returned nullptr!\n";
    return vertex;
}