use crate::core::{BufferAttribute, BufferGeometry};
use crate::math::Vector3;
pub fn polyhedron_geometry(
vertices: &[f64],
indices: &[usize],
radius: f64,
detail: usize,
) -> BufferGeometry {
let mut vertex_buffer: Vec<f64> = Vec::new();
let mut uv_buffer: Vec<f64> = Vec::new();
subdivide(vertices, indices, detail, &mut vertex_buffer);
apply_radius(radius, &mut vertex_buffer);
generate_uvs(&vertex_buffer, &mut uv_buffer);
let mut geometry = BufferGeometry::new();
geometry.set_attribute(
"position",
BufferAttribute::new(vertex_buffer.iter().map(|&v| v as f32).collect(), 3),
);
geometry.set_attribute(
"normal",
BufferAttribute::new(vertex_buffer.iter().map(|&v| v as f32).collect(), 3),
);
geometry.set_attribute(
"uv",
BufferAttribute::new(uv_buffer.iter().map(|&v| v as f32).collect(), 2),
);
if detail == 0 {
geometry.compute_vertex_normals(); } else {
geometry.normalize_normals(); }
geometry
}
fn get_vertex_by_index(vertices: &[f64], index: usize, vertex: &mut Vector3) {
let stride = index * 3;
vertex.x = vertices[stride];
vertex.y = vertices[stride + 1];
vertex.z = vertices[stride + 2];
}
fn push_vertex(vertex_buffer: &mut Vec<f64>, vertex: &Vector3) {
vertex_buffer.push(vertex.x);
vertex_buffer.push(vertex.y);
vertex_buffer.push(vertex.z);
}
fn subdivide(vertices: &[f64], indices: &[usize], detail: usize, vertex_buffer: &mut Vec<f64>) {
let mut a = Vector3::ZERO;
let mut b = Vector3::ZERO;
let mut c = Vector3::ZERO;
let mut i = 0;
while i < indices.len() {
get_vertex_by_index(vertices, indices[i], &mut a);
get_vertex_by_index(vertices, indices[i + 1], &mut b);
get_vertex_by_index(vertices, indices[i + 2], &mut c);
subdivide_face(&a, &b, &c, detail, vertex_buffer);
i += 3;
}
}
fn subdivide_face(
a: &Vector3,
b: &Vector3,
c: &Vector3,
detail: usize,
vertex_buffer: &mut Vec<f64>,
) {
let cols = detail + 1;
let mut v: Vec<Vec<Vector3>> = Vec::new();
for i in 0..=cols {
v.push(Vec::new());
let mut aj = *a;
aj.lerp(c, i as f64 / cols as f64);
let mut bj = *b;
bj.lerp(c, i as f64 / cols as f64);
let rows = cols - i;
for j in 0..=rows {
if j == 0 && i == cols {
v[i].push(aj);
} else {
let mut p = aj;
p.lerp(&bj, j as f64 / rows as f64);
v[i].push(p);
}
}
}
for i in 0..cols {
for j in 0..(2 * (cols - i) - 1) {
let k = j / 2;
if j % 2 == 0 {
push_vertex(vertex_buffer, &v[i][k + 1]);
push_vertex(vertex_buffer, &v[i + 1][k]);
push_vertex(vertex_buffer, &v[i][k]);
} else {
push_vertex(vertex_buffer, &v[i][k + 1]);
push_vertex(vertex_buffer, &v[i + 1][k + 1]);
push_vertex(vertex_buffer, &v[i + 1][k]);
}
}
}
}
fn apply_radius(radius: f64, vertex_buffer: &mut [f64]) {
let mut vertex = Vector3::ZERO;
let mut i = 0;
while i < vertex_buffer.len() {
vertex.x = vertex_buffer[i];
vertex.y = vertex_buffer[i + 1];
vertex.z = vertex_buffer[i + 2];
vertex.normalize().multiply_scalar(radius);
vertex_buffer[i] = vertex.x;
vertex_buffer[i + 1] = vertex.y;
vertex_buffer[i + 2] = vertex.z;
i += 3;
}
}
fn azimuth(vector: &Vector3) -> f64 {
vector.z.atan2(-vector.x)
}
fn inclination(vector: &Vector3) -> f64 {
(-vector.y).atan2((vector.x * vector.x + vector.z * vector.z).sqrt())
}
fn generate_uvs(vertex_buffer: &[f64], uv_buffer: &mut Vec<f64>) {
let mut vertex = Vector3::ZERO;
let mut i = 0;
while i < vertex_buffer.len() {
vertex.x = vertex_buffer[i];
vertex.y = vertex_buffer[i + 1];
vertex.z = vertex_buffer[i + 2];
let u = azimuth(&vertex) / 2.0 / std::f64::consts::PI + 0.5;
let v = inclination(&vertex) / std::f64::consts::PI + 0.5;
uv_buffer.push(u);
uv_buffer.push(1.0 - v);
i += 3;
}
correct_uvs(vertex_buffer, uv_buffer);
correct_seam(uv_buffer);
}
fn correct_uvs(vertex_buffer: &[f64], uv_buffer: &mut [f64]) {
let mut a = Vector3::ZERO;
let mut b = Vector3::ZERO;
let mut c = Vector3::ZERO;
let mut centroid;
let mut i = 0;
let mut j = 0;
while i < vertex_buffer.len() {
a.set(vertex_buffer[i], vertex_buffer[i + 1], vertex_buffer[i + 2]);
b.set(
vertex_buffer[i + 3],
vertex_buffer[i + 4],
vertex_buffer[i + 5],
);
c.set(
vertex_buffer[i + 6],
vertex_buffer[i + 7],
vertex_buffer[i + 8],
);
let uv_a_x = uv_buffer[j];
let uv_b_x = uv_buffer[j + 2];
let uv_c_x = uv_buffer[j + 4];
centroid = a;
centroid.add(&b).add(&c).divide_scalar(3.0);
let azi = azimuth(¢roid);
correct_uv(uv_buffer, uv_a_x, j, &a, azi);
correct_uv(uv_buffer, uv_b_x, j + 2, &b, azi);
correct_uv(uv_buffer, uv_c_x, j + 4, &c, azi);
i += 9;
j += 6;
}
}
fn correct_uv(uv_buffer: &mut [f64], uv_x: f64, stride: usize, vector: &Vector3, azimuth: f64) {
if (azimuth < 0.0) && (uv_x == 1.0) {
uv_buffer[stride] = uv_x - 1.0;
}
if (vector.x == 0.0) && (vector.z == 0.0) {
uv_buffer[stride] = azimuth / 2.0 / std::f64::consts::PI + 0.5;
}
}
fn correct_seam(uv_buffer: &mut [f64]) {
let mut i = 0;
while i < uv_buffer.len() {
let x0 = uv_buffer[i];
let x1 = uv_buffer[i + 2];
let x2 = uv_buffer[i + 4];
let max = x0.max(x1).max(x2);
let min = x0.min(x1).min(x2);
if max > 0.9 && min < 0.1 {
if x0 < 0.2 {
uv_buffer[i] += 1.0;
}
if x1 < 0.2 {
uv_buffer[i + 2] += 1.0;
}
if x2 < 0.2 {
uv_buffer[i + 4] += 1.0;
}
}
i += 6;
}
}
pub fn icosahedron_geometry(radius: f64, detail: usize) -> BufferGeometry {
let t = (1.0 + 5.0f64.sqrt()) / 2.0;
let vertices = [
-1.0, t, 0.0, 1.0, t, 0.0, -1.0, -t, 0.0, 1.0, -t, 0.0, 0.0, -1.0, t, 0.0, 1.0, t, 0.0, -1.0, -t, 0.0, 1.0, -t, t, 0.0, -1.0, t, 0.0, 1.0, -t, 0.0, -1.0, -t, 0.0, 1.0,
];
let indices = [
0, 11, 5, 0, 5, 1, 0, 1, 7, 0, 7, 10, 0, 10, 11, 1, 5, 9, 5, 11, 4, 11, 10, 2, 10, 7, 6, 7, 1, 8, 3, 9, 4, 3, 4, 2, 3, 2, 6, 3, 6, 8, 3, 8, 9, 4, 9, 5, 2, 4, 11, 6, 2, 10, 8, 6, 7, 9, 8, 1,
];
polyhedron_geometry(&vertices, &indices, radius, detail)
}
pub fn octahedron_geometry(radius: f64, detail: usize) -> BufferGeometry {
let vertices = [
1.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, -1.0,
];
let indices = [
0, 2, 4, 0, 4, 3, 0, 3, 5, 0, 5, 2, 1, 2, 5, 1, 5, 3, 1, 3, 4, 1, 4, 2,
];
polyhedron_geometry(&vertices, &indices, radius, detail)
}
pub fn tetrahedron_geometry(radius: f64, detail: usize) -> BufferGeometry {
let vertices = [
1.0, 1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, -1.0,
];
let indices = [2, 1, 0, 0, 3, 2, 1, 3, 0, 2, 3, 1];
polyhedron_geometry(&vertices, &indices, radius, detail)
}
pub fn dodecahedron_geometry(radius: f64, detail: usize) -> BufferGeometry {
let t = (1.0 + 5.0f64.sqrt()) / 2.0;
let r = 1.0 / t;
let vertices = [
-1.0, -1.0, -1.0, -1.0, -1.0, 1.0, -1.0, 1.0, -1.0, -1.0, 1.0, 1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0, 1.0, -1.0, 1.0, 1.0, 1.0, 0.0, -r, -t, 0.0, -r, t, 0.0, r, -t, 0.0, r, t, -r, -t, 0.0, -r, t, 0.0, r, -t, 0.0, r, t, 0.0, -t, 0.0, -r, t, 0.0, -r, -t, 0.0, r, t, 0.0, r,
];
let indices = [
3, 11, 7, 3, 7, 15, 3, 15, 13, 7, 19, 17, 7, 17, 6, 7, 6, 15, 17, 4, 8, 17, 8, 10, 17, 10, 6, 8, 0, 16, 8, 16, 2, 8, 2, 10, 0, 12, 1, 0, 1, 18, 0, 18, 16, 6, 10, 2, 6, 2, 13, 6, 13, 15, 2, 16, 18, 2, 18, 3, 2, 3, 13, 18, 1, 9, 18, 9, 11, 18, 11, 3, 4, 14, 12, 4, 12, 0, 4, 0, 8, 11, 9, 5, 11, 5, 19, 11, 19, 7, 19, 5, 14, 19, 14, 4, 19, 4, 17, 1, 12, 14, 1, 14, 5, 1, 5, 9,
];
polyhedron_geometry(&vertices, &indices, radius, detail)
}